streamer.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/component.h"
#include "twitchsdk/core/eventsource.h"
#include "twitchsdk/core/timer.h"
#include "twitchsdk/core/concurrentqueue.h"
#include "twitchsdk/broadcast/broadcasttypes.h"
#include "twitchsdk/broadcast/iaudioencoder.h"
#include "twitchsdk/broadcast/internal/task/channelinfotask.h"
#include "twitchsdk/broadcast/internal/framewriter.h"

namespace ttv
{   
    class TaskRunner;
    class TrackingContext;

    namespace broadcast
    {
        class Streamer;
        struct StreamerContext;
        class AudioStreamer;
        class FlvMuxer;
        class FrameWriter;
        class StreamStats;
        class VideoFrame;
        class VideoStreamer;
        class IVideoEncoder;
        class IVideoCapture;
        class IAudioCapture;
        class IAudioMixer;
        class StreamerListenerProxy;
        class IBandwidthStatListener;
        class IMuxer;
    }
}


struct ttv::broadcast::StreamerContext
{
    StreamerContext()
    :   isBusy(false)
    ,   connectionType(ConnectionType::Unknown)
    {}
    
    std::atomic_bool isBusy;
    std::shared_ptr<TrackingContext> sharedTrackingContext;
    ConnectionType connectionType;
    std::string category;
    std::string title;
};


class ttv::broadcast::Streamer : public ttv::UserComponent
{
public:
    enum class StreamerState
    {
        Stopped,
        Starting,
        Started,
        Stopping
    };

    struct StartParams
    {
        VideoParams videoParams;
        IngestServer ingestServer;
        StreamStartFlags flags;
        std::wstring outputFile;
    };

    using StartCallback = std::function<void(TTV_ErrorCode ec)>;
    using StopCallback = std::function<void(TTV_ErrorCode ec)>;
    using FrameWriterDelayStateChangedCallback = std::function<void(FrameWriter::DelayState state)>;

    class IListener
    {
    public:
        virtual void OnStartComplete(Streamer* source, TTV_ErrorCode ec) = 0;
        virtual void OnStopComplete(Streamer* source, TTV_ErrorCode ec) = 0;
        virtual void OnStreamerStateChanged(Streamer* source, StreamerState state, TTV_ErrorCode ec) = 0;
        virtual void OnBandwidthWarning(Streamer* source, TTV_ErrorCode ec, uint32_t backupMilliseconds) = 0;
        virtual void OnStreamInfoFetched(Streamer* source, TTV_ErrorCode ec, const StreamInfo& streamInfo) = 0;
    };

public:
    Streamer(const std::shared_ptr<User>& user, const std::shared_ptr<StreamerContext>& context);
    virtual ~Streamer();

    void AddListener(const std::shared_ptr<IListener>& listener);
    void RemoveListener(const std::shared_ptr<IListener>& listener);
    
    void AddBandwidthStatListener(const std::shared_ptr<IBandwidthStatListener>& listener);
    void RemoveBandwidthStatListener(const std::shared_ptr<IBandwidthStatListener>& listener);

    TTV_ErrorCode SetVideoEncoder(const std::shared_ptr<IVideoEncoder>& encoder);
    TTV_ErrorCode SetAudioEncoder(const std::shared_ptr<IAudioEncoder>& encoder);
    TTV_ErrorCode SetCustomMuxer(const std::shared_ptr<IMuxer>& muxer);

    void SetBroadcasterSoftware(const std::string& str) { mBroadcasterSoftware = str; }
    
    void SetForceArchiveBroadcast(bool forceArchive) { mForceArchiveBroadcast = forceArchive; }
    
    void SetFrameWriterDelayStateChangedCallback(const FrameWriterDelayStateChangedCallback& callback) { mFrameWriterDelayStateChangedCallback = callback; }

    // Component overrides
    virtual void SetTaskRunner(std::shared_ptr<TaskRunner> taskRunner) override;
    virtual TTV_ErrorCode Initialize() override;
    virtual void Update() override;
    virtual TTV_ErrorCode Shutdown() override;

    // UserComponent overrides
    virtual std::string GetLoggerName() const override;
    virtual bool CheckShutdown() override;
    virtual void CompleteShutdown() override;

    TTV_ErrorCode Start(const StartParams& params, StartCallback&& callback);

    TTV_ErrorCode Stop(const std::string& reason, StopCallback&& callback);

    TTV_ErrorCode GetVolume(AudioLayerId layer, float& volume) const;
    TTV_ErrorCode SetVolume(AudioLayerId layer, float volume);
    void SetAudioCapturer(AudioLayerId layerId, const std::shared_ptr<IAudioCapture>& capturer);
    void SetAudioCapturerEnabled(AudioLayerId layer, bool enabled);
    void GetAudioCapturers(std::vector<std::shared_ptr<IAudioCapture>>& result) const;
    std::shared_ptr<IAudioCapture> GetAudioCapturer(AudioLayerId layer) const;

    void SetVideoCapturer(std::shared_ptr<IVideoCapture> capturer);
    std::shared_ptr<IVideoCapture> GetVideoCapturer() const;

    uint64_t GetStreamTime() const;

    std::shared_ptr<StreamStats> GetStreamStats() { return mStreamStats; }
    std::shared_ptr<const StreamStats> GetStreamStats() const { return mStreamStats; }

    VideoParams GetVideoParams() const { return mStartParams.videoParams; }

    TTV_ErrorCode ValidateParams(const VideoParams& videoParams, const IngestServer& ingestServer) const;

    StreamerState GetStreamerState() const;

    //TTV_ErrorCode SendMetaData(const char* authToken,
    //                         TwitchAPI::MetaDataEventClass eventClass, const char* name,
    //                         int64_t streamTime, unsigned long sequenceNumber,
    //                         const char* humanDescription, const char* data,
    //                         TTV_TaskCallback callback, void* userData);

    static std::string GetComponentName() { return "ttv::Streamer"; }
    static void GetRequiredAuthScopes(std::vector<std::string>& scopes);

private:
    TTV_ErrorCode FetchChannelInfo(std::function<void(TTV_ErrorCode ec)>&& callback);
    TTV_ErrorCode AddVideoFrame(const std::shared_ptr<VideoFrame>& frame);
    TTV_ErrorCode GetStreamInfo();
    TTV_ErrorCode SetIngestServer(const IngestServer& ingestServer);
    TTV_ErrorCode SetStreamName(const std::string& streamKey, bool absEnabled);

    TTV_ErrorCode KickOffStart(const StartParams& params, StartCallback&& callback);
    TTV_ErrorCode InternalStart(const StartParams& params);
    TTV_ErrorCode InternalStop(TTV_ErrorCode ec, bool solicited, StopCallback&& callback);
    TTV_ErrorCode UpdateBandwidthWarningState();
    
    TTV_ErrorCode TrackStartFailure(TTV_ErrorCode ec, bool synchronous);
    TTV_ErrorCode TrackMinuteBroadcast();
    
    void NotifyStreamerStateChanged();

private:
    std::unique_ptr<StreamInfo> mStreamInfo;

private:
    StartParams mStartParams;
    AudioParams mAudioParams;
    IngestServer mSelectedIngestServer;
    std::shared_ptr<StreamerContext> mContext;
    std::string mOutputStreamName;
    std::shared_ptr<FlvMuxer> mFlvMuxer;
    std::shared_ptr<FrameWriter> mFrameWriter;
    std::shared_ptr<StreamStats> mStreamStats;
    std::shared_ptr<VideoStreamer> mVideoStreamer;
    std::shared_ptr<AudioStreamer> mAudioStreamer;
    EventSource<IListener> mListeners;
    ttv::ConcurrentQueue<BandwidthStat> mStatQueue;
    EventSource<IBandwidthStatListener> mBandwidthStatListeners;

    ChannelId mChannelId; 
    std::string mStreamKey; 

    std::string mBroadcasterSoftware; 
    uint64_t mInitialTime; 
    mutable std::mutex mStateMutex;
    StreamerState mStreamerState;
    RetryTimer mStreamInfoFetchTimer;
    StreamerState mLastReportedStreamerState; 
    TTV_ErrorCode mStateChangeError; 
    WaitForExpiry mBandwidthWarningTimer;
    TTV_ErrorCode mBandwidthWarningState;
    
    WaitForExpiry mMinuteBroadcastTrackingTimer;
    
    std::shared_ptr<IVideoEncoder> mVideoEncoder;
    std::shared_ptr<IAudioEncoder> mAudioEncoder;

    std::shared_ptr<IVideoCapture> mVideoCapturer;

    std::shared_ptr<IMuxer> mCustomMuxer;
    std::shared_ptr<TrackingContext> mTrackingContext;
    
    FrameWriterDelayStateChangedCallback mFrameWriterDelayStateChangedCallback;

    bool mFirstFrameSubmitted;
    bool mBandwidthTestMode;
    bool mForceArchiveBroadcast; 
};


class ttv::broadcast::StreamerListenerProxy : public Streamer::IListener
{
public:
    typedef std::function<void(Streamer* source, TTV_ErrorCode ec)> StartCompleteFunc;
    typedef std::function<void(Streamer* source, TTV_ErrorCode ec)> StopCompleteFunc;
    typedef std::function<void(Streamer* source, Streamer::StreamerState state, TTV_ErrorCode ec)> StreamerStateChangedFunc;
    typedef std::function<void(Streamer* source, TTV_ErrorCode ec, uint32_t backupMilliseconds)> BandwidthWarningFunc;
    typedef std::function<void(Streamer* source, TTV_ErrorCode ec, const StreamInfo& streamInfo)> StreamInfoFetchedFunc;

public:
    virtual void OnStartComplete(Streamer* source, TTV_ErrorCode ec) override
    {
        if (mStartCompleteFunc != nullptr)
        {
            mStartCompleteFunc(source, ec);
        }
    }

    virtual void OnStopComplete(Streamer* source, TTV_ErrorCode ec) override
    {
        if (mStopCompleteFunc != nullptr)
        {
            mStopCompleteFunc(source, ec);
        }
    }

    virtual void OnStreamerStateChanged(Streamer* source, Streamer::StreamerState state, TTV_ErrorCode ec) override
    {
        if (mStreamerStateChangedFunc != nullptr)
        {
            mStreamerStateChangedFunc(source, state, ec);
        }
    }
    
    virtual void OnBandwidthWarning(Streamer* source, TTV_ErrorCode ec, uint32_t backupMilliseconds) override
    {
        if (mBandwidthWarningFunc != nullptr)
        {
            mBandwidthWarningFunc(source, ec, backupMilliseconds);
        }
    }

    virtual void OnStreamInfoFetched(Streamer* source, TTV_ErrorCode ec, const StreamInfo& streamInfo) override
    {
        if (mStreamInfoFetchedFunc != nullptr)
        {
            mStreamInfoFetchedFunc(source, ec, streamInfo);
        }
    }
    
public:
    StartCompleteFunc mStartCompleteFunc;
    StopCompleteFunc mStopCompleteFunc;
    StreamerStateChangedFunc mStreamerStateChangedFunc;
    BandwidthWarningFunc mBandwidthWarningFunc;
    StreamInfoFetchedFunc mStreamInfoFetchedFunc;
};