framewriter.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/threadsync.h"
#include "twitchsdk/core/timer.h"
#include "twitchsdk/broadcast/iframewriter.h"
#include "twitchsdk/broadcast/packet.h"
#include "twitchsdk/broadcast/internal/muxers/flvmuxer.h"

#include <atomic>
#include <queue>
#include <mutex>

namespace ttv
{
    class IThread;
    class IMutex;

    namespace broadcast
    {
        class FrameWriter;
        class FlvMuxer;
        class IMuxer;
    }
}


class ttv::broadcast::FrameWriter : public IFrameWriter
{
public:
    enum class DelayState
    {
        Okay,
        Warning,
        Error
    };
    
    using StreamAbortFunc = std::function<void(FrameWriter* source, TTV_ErrorCode ec)>;
    using DelayStateChangedCallback = std::function<void(FrameWriter* source, DelayState state)>;
    using BandwidthStatCallback = std::function<void(FrameWriter* source, const BandwidthStat& stat)>;

public:
    FrameWriter(bool audioEnabled);
    virtual ~FrameWriter();

public:
    TTV_ErrorCode SetFlvMuxer(const std::shared_ptr<FlvMuxer>& flvMuxer);
    TTV_ErrorCode SetCustomMuxer(const std::shared_ptr<IMuxer>& muxer);

    TTV_ErrorCode Start(const VideoParams& videoParams);
    TTV_ErrorCode GetLastError();
    
    uint64_t GetQueueDelayInMilliseconds() const;
    uint32_t GetQueueDelayInBytes() const { return mNumQueuedBytes; }
    uint32_t GetRecommendedBitRate() const;
    
    void SetWarningDelayThresholdMilliseconds(uint64_t warningThreshHold) { mWarningDelayThreshold = warningThreshHold; }
    void SetErrorDelayThresholdMilliseconds(uint64_t errorThreshold) { mErrorDelayThreshold = errorThreshold; }
    
    DelayState GetDelayState() const { return mDelayState; }
    void SetDelayStateChangedCallback(const DelayStateChangedCallback& callback) { mDelayStateChangedCallback = callback; }
    
    void Shutdown();

    void SetStreamAbortCallback(StreamAbortFunc func) { mStreamAbortCallback = func; }
    
    void SetBandwidthStatCallback(const BandwidthStatCallback& callback) { mBandwidthStatCallback = callback; }
    
    TTV_ErrorCode GatherTrackingStats(uint64_t& averageRecommendedKbps, uint64_t& averageEncodedKbps);

    // IFrameWriter implementation
    virtual TTV_ErrorCode WritePacket(std::unique_ptr<Packet>&& packet) override;
    
private:
    void TransferPacketToOutputQueues(std::unique_ptr<Packet>&& packet);
    TTV_ErrorCode SendDataToMuxers();
    void UpdateRecommendedBitRate();
    void UpdateDelayState();

private:
    std::mutex mMutex;
    std::condition_variable mCondition;
    std::queue<std::unique_ptr<Packet>> mPacketQueue;
    bool mWriteFrameThreadProceed;                  
    
    std::shared_ptr<IThread> mWriteFrameThread;     
    std::shared_ptr<FlvMuxer> mFlvMuxer;
    std::shared_ptr<IMuxer> mCustomMuxer;
    StreamAbortFunc mStreamAbortCallback;           

    std::queue<std::unique_ptr<Packet>> mAudioPacketQueue;
    std::queue<std::unique_ptr<Packet>> mVideoPacketQueue;

    VideoParams mVideoParams;

    std::atomic<uint64_t> mLastSentPacketTimestamp;
    std::atomic<uint64_t> mLastReceivedPacketTimestamp;
    
    DelayStateChangedCallback mDelayStateChangedCallback;
    uint64_t mWarningDelayThreshold;
    uint64_t mErrorDelayThreshold;
    
    std::atomic<uint32_t> mNumQueuedBytes;          
    std::atomic<uint64_t> mEncodedBitCounter;       
    uint64_t mStreamStartSystemTime;                
    uint64_t mLastStatTime;                         
    
    struct TrackedStatsRunningTotals
    {
        TrackedStatsRunningTotals()
        :   recommendedBits(0)
        ,   encoderOutputBits(0)
        ,   elapsedSystemTime(0)
        {
        }
        
        uint64_t recommendedBits;
        uint64_t encoderOutputBits;
        uint64_t elapsedSystemTime;
    };
    TrackedStatsRunningTotals mRunningTotals;
    std::mutex mRunningTotalsMutex;
    
    BandwidthStatCallback mBandwidthStatCallback;   
    
    WaitForExpiry mBitrateUpdateTimer;              
    WaitForExpiry mBitrateIncreaseTimer;            
    uint32_t mRecommendedBitRate;                   

    TTV_ErrorCode mLastError;
    DelayState mDelayState;
    
    bool mAudioEnabled;
};