broadcasttypes.h

Go to the documentation of this file.

/********************************************************************************************
 * Twitch Broadcasting SDK
 *
 * This software is supplied under the terms of a license agreement with Twitch Interactive, Inc. and
 * may not be copied or used except in accordance with the terms of that agreement
 * Copyright (c) 2012-2016 Twitch Interactive, Inc.
 *********************************************************************************************/

#pragma once

#include "twitchsdk/core/types/coretypes.h"
#include "twitchsdk/broadcast/broadcasterrortypes.h"
#include <vector>

namespace ttv
{
    namespace broadcast
    {
        const uint32_t kMinBitRate = 300;               
        const uint32_t kMaxBitRate = 6000;              
        const uint32_t kDefaultInitialBitRate = 1500;   
        const uint32_t kDefaultFramesPerSecond = 30;    
        const uint32_t kMinFramesPerSecond = 10;        
        const uint32_t kMaxFramesPerSecond = 60;        
        const uint32_t kMaxFrameWidth = 1920;           
        const uint32_t kMaxFrameHeight = 1200;          
        const float kRecommendedBitsPerPixel = 0.1f;
        
        struct IngestServer
        {
            IngestServer();
            IngestServer(const IngestServer& other);
            void operator=(const IngestServer& other);

            std::string serverName;     
            std::string serverUrl;      
            uint32_t priority;          
            uint32_t serverId;          
        };

        enum class PixelFormat
        {
            TTV_PF_BGRA = 0x00010203,
            TTV_PF_ABGR = 0x01020300,
            TTV_PF_RGBA = 0x02010003,
            TTV_PF_ARGB = 0x03020100
        };

        enum class YUVFormat
        {
            TTV_YUV_NONE = -1,
            TTV_YUV_I420,       
            TTV_YUV_YV12,       
            TTV_YUV_NV12        
        };

        enum class EncodingCpuUsage
        {   
            Default,
            Low,
            Medium,
            High
        };

        struct VideoParams
        {
            VideoParams();

            uint32_t outputWidth;
            uint32_t outputHeight;
            uint32_t targetFramesPerSecond;
            uint32_t initialKbps;
            uint32_t minimumKbps;
            uint32_t maximumKbps;
            EncodingCpuUsage encodingCpuUsage;
            bool automaticBitRateAdjustmentEnabled;

            static TTV_ErrorCode ConfigureForBandwidth(uint32_t expectedKbps, uint32_t framesPerSecond, float bitsPerPixel, float aspectRatio, VideoParams& result);
            static TTV_ErrorCode ConfigureForResolution(uint32_t width, uint32_t height, uint32_t framesPerSecond, float bitsPerPixel, VideoParams& result);
        };
        
        
        enum class ConnectionType
        {
            Wifi,
            Ethernet,
            Cellular,
            Unknown
        };

        
        enum class AudioFormat
        {
            None,   
            PCM,    
            MP3,    
            AAC,    
        };
        
        enum class AudioSampleFormat
        {
            TTV_ASF_PCM_S16     
        };

        enum class AudioSampleRate
        {
            Hz11250 = 11250,
            Hz22500 = 22500,
            Hz44100 = 44100
        };

        typedef uint32_t AudioLayerId;

        struct ArchivingState
        {
            ArchivingState();

            std::string cureUrl;                
            bool recordingEnabled;              
        };

        struct GameInfo
        {   
            GameInfo();

            std::string name;           
            uint32_t popularity;        
            uint32_t gameId;            
        };

        struct GameInfoList
        {
            std::vector<GameInfo> games;
        };

        enum class StreamStartFlags
        {
            None = 0,
            BandwidthTest = 1 << 0
        };

        enum class BroadcastState
        {
            Initialized,              
            ReadyToBroadcast,         
            StartingBroadcast,        
            Broadcasting,             
            StoppingBroadcast         
        };
        
        struct BandwidthStat
        {
            uint64_t recommendedBitsPerSecond;      
            uint64_t measuredBitsPerSecond;         
            uint64_t encoderOutputBitsPerSecond;    
            double backBufferSeconds;               
            double recordedTime;                    
            double congestionLevel;                 
        };

        struct MuxerParameters
        {
            std::string appVersion; 

            uint32_t videoWidth; 
            uint32_t videoHeight; 
            uint32_t frameRate; 
            std::vector<uint8_t> videoSps; 
            std::vector<uint8_t> videoPps; 

            AudioFormat audioFormat; 
            uint32_t audioSampleRate; 
            uint32_t audioSampleSize; 
            bool audioEnabled; 
            bool audioStereo; 
        };
    }
}