ffmpeg_stream_backend.h

Go to the documentation of this file.

 
#pragma once
 
// standard includes
#include <atomic>
#include <cstdint>
#include <mutex>
#include <string>
#include <vector>
 
// lib includes
#include <SDL.h>
 
// local includes
#include "third-party/moonlight-common-c/src/Limelight.h"
 
struct AVCodecContext;
struct AVFrame;
struct AVPacket;
struct SwrContext;
struct SwsContext;
 
namespace streaming {
 
  using SdlThreadContext = void;
 
  class FfmpegStreamBackend {
  public:
    FfmpegStreamBackend() = default;
 
    ~FfmpegStreamBackend();
 
    FfmpegStreamBackend(const FfmpegStreamBackend &) = delete;
    FfmpegStreamBackend &operator=(const FfmpegStreamBackend &) = delete;
 
    void initialize_callbacks(DECODER_RENDERER_CALLBACKS *videoCallbacks, AUDIO_RENDERER_CALLBACKS *audioCallbacks) const;
 
    void set_audio_playback_enabled(bool enabled);
 
    void shutdown();
 
    bool render_latest_video_frame(SDL_Renderer *renderer, int screenWidth, int screenHeight, bool allowDirectFramebuffer = true);
 
    bool has_decoded_video() const;
 
    bool has_unrendered_video_frame() const;
 
    std::uint64_t milliseconds_since_last_decoded_video_frame(std::uint64_t nowMicroseconds) const;
 
    std::string build_overlay_status_line() const;
 
    int setup_video_decoder(int videoFormat, int width, int height, int redrawRate, int drFlags);
 
    void start_video_decoder();
 
    void stop_video_decoder();
 
    void cleanup_video_decoder();
 
    int initialize_audio_decoder(int audioConfiguration, const OPUS_MULTISTREAM_CONFIGURATION *opusConfig, int arFlags);
 
    void start_audio_playback();
 
    void stop_audio_playback();
 
    void cleanup_audio_decoder();
 
    bool ensure_audio_resampler();
 
    void decode_and_play_audio_sample(const char *sampleData, int sampleLength);
 
  private:
    static int run_video_decode_thread_trampoline(SdlThreadContext *context);
 
    int run_video_decode_thread();
 
    int drop_queued_video_decode_units(VIDEO_FRAME_HANDLE *frameHandle, PDECODE_UNIT *decodeUnit);
 
    int prepare_video_decode_unit(VIDEO_FRAME_HANDLE *frameHandle, PDECODE_UNIT *decodeUnit);
 
    int decode_video_decode_unit(PDECODE_UNIT decodeUnit);
 
    int receive_available_video_frames();
 
    bool publish_video_frame(const AVFrame *frameToPresent);
 
    bool render_latest_video_frame_to_framebuffer(int screenWidth, int screenHeight);
 
    struct LatestVideoFrame {
      int width = 0;
      int height = 0;
      int yPitch = 0;
      int uPitch = 0;
      int vPitch = 0;
      std::vector<std::uint8_t> yPlane;
      std::vector<std::uint8_t> uPlane;
      std::vector<std::uint8_t> vPlane;
    };
 
    struct VideoState {  // NOSONAR(cpp:S1820) Owned video pipeline state intentionally groups FFmpeg, SDL, queue, and metric lifetimes.
      AVCodecContext *codecContext = nullptr;
      SwsContext *scaleContext = nullptr;
      SwsContext *presentScaleContext = nullptr;
      AVFrame *decodedFrame = nullptr;
      AVFrame *convertedFrame = nullptr;
      AVPacket *packet = nullptr;
      SDL_Texture *texture = nullptr;
      SDL_Thread *decoderThread = nullptr;
      int textureWidth = 0;
      int textureHeight = 0;
      std::uint64_t latestFrameVersion = 0;
      std::uint64_t renderedFrameVersion = 0;
      std::vector<std::uint8_t> convertedBuffer;
      std::vector<std::uint8_t> packetBuffer;
 
      [[nodiscard]] std::mutex &frame_mutex() const {
        return frameMutex_;
      }
 
    private:
      mutable std::mutex frameMutex_;  
 
    public:
      SDL_Rect directFramebufferDestination {0, 0, 0, 0};
      LatestVideoFrame latestFrame;
      LatestVideoFrame decodeFrame;
      LatestVideoFrame renderFrame;
      bool directFramebufferCleared = false;
      std::atomic<bool> decoderStopRequested = false;
      std::atomic<bool> hasFrame = false;
      std::atomic<std::uint64_t> publishedFrameVersion = 0;
      std::atomic<std::uint64_t> submittedDecodeUnitCount = 0;
      std::atomic<std::uint64_t> decodedFrameCount = 0;
      std::atomic<std::uint64_t> droppedDecodeUnitCount = 0;
      std::atomic<std::uint64_t> lastDecodeQueueUs = 0;
      std::atomic<std::uint64_t> lastReceiveAgeUs = 0;
      std::atomic<std::uint64_t> lastDecodedFrameUs = 0;
      std::atomic<int> lastDecodeFrameNumber = 0;
    };
 
    struct AudioState {
      AVCodecContext *codecContext = nullptr;
      SwrContext *resampleContext = nullptr;
      AVFrame *decodedFrame = nullptr;
      AVPacket *packet = nullptr;
      SDL_AudioDeviceID deviceId = 0;
      SDL_AudioSpec obtainedSpec {};
      std::vector<std::uint8_t> outputBuffer;
      int resampleInputSampleRate = 0;
      int resampleInputSampleFormat = -1;
      int resampleInputChannelCount = 0;
      std::atomic<bool> deviceStarted = false;
      std::atomic<std::uint64_t> queuedAudioBytes = 0;
    };
 
    VideoState video_ {};
    AudioState audio_ {};
    std::atomic<bool> audioPlaybackEnabled_ = false;
  };
 
}  // namespace streaming