VideoPlayer.h

Go to the documentation of this file.

#pragma once
 
#include "AudioTools/AudioCodecs/AudioCodecsBase.h"
#include "AudioTools/AudioCodecs/AudioEncoded.h"
#include "AudioTools/AudioCodecs/ContainerCommon.h"
#include "AudioTools/AudioCodecs/MultiDecoder.h"
#include "AudioTools/CoreAudio/AudioIO.h"
#include "AudioTools/Video/MultiVideoDecoder.h"
#include "AudioTools/Video/MultiVideoDemuxer.h"
#include "AudioTools/Video/Video.h"
 
namespace audio_tools {
 
class VideoPlayer {
 public:
  VideoPlayer() = default;
 
  VideoPlayer(Demuxer& demuxer, VideoOutput& videoOutput) {
    addDemuxer(demuxer);
    setVideoOutput(videoOutput);
  }
 
  VideoPlayer(Demuxer& demuxer, VideoOutput& videoOutput,
              AudioOutput& audioOutput) {
    addDemuxer(demuxer);
    setVideoOutput(videoOutput);
    setAudioOutput(audioOutput);
  }
 
  VideoPlayer(Demuxer& demuxer, VideoOutput& videoOutput,
              Print& audioOutput) {
    addDemuxer(demuxer);
    setVideoOutput(videoOutput);
    setAudioOutput(audioOutput);
  }
 
  VideoPlayer(Demuxer& demuxer, VideoOutput& videoOutput,
              AudioStream& audioOutput) {
    addDemuxer(demuxer);
    setVideoOutput(videoOutput);
    setAudioOutput(audioOutput);
  }
 
  VideoPlayer(VideoPlayer const&) = delete;
  VideoPlayer& operator=(VideoPlayer const&) = delete;
 
  void addDemuxer(Demuxer& demuxer) { default_demuxer.addDemuxer(demuxer); }
 
  void addVideoDecoder(VideoDecoder& decoder) {
    default_video_decoder.addDecoder(decoder);
  }
 
  void setVideoOutput(VideoOutput& out) { p_video_output = &out; }
 
  void addAudioDecoder(AudioDecoder& decoder, const char* mime = nullptr) {
    default_audio_decoder.addDecoder(decoder, mime);
  }
 
  void setAudioOutput(Print& out) {
    p_audio_output = &out;
    p_audio_output_typed = nullptr;
    p_audio_stream = nullptr;
  }
  void setAudioOutput(AudioOutput& out) {
    p_audio_output = &out;
    p_audio_output_typed = &out;
    p_audio_stream = nullptr;
  }
  void setAudioOutput(AudioStream& out) {
    p_audio_output = &out;
    p_audio_output_typed = nullptr;
    p_audio_stream = &out;
  }
 
  void setUseAudioClock(bool active) { use_audio_clock = active; }
  bool useAudioClock() const { return use_audio_clock; }
 
  void setBufferSize(int size) { buffer_size = size; }
 
  void setSchedulingDelayMs(uint32_t delayMs) {
    video_sync.setSchedulingDelayMs(delayMs);
  }
  void setCatchUpThresholdFrames(float frames) {
    video_sync.setCatchUpThresholdFrames(frames);
  }
  void setIgnorePFrames(bool active) { video_sync.setIgnorePFrames(active); }
  void setResyncThresholdMs(uint32_t ms) {
    video_sync.setResyncThresholdMs(ms);
  }
  void setResyncQueueFillFraction(float fraction) {
    video_sync.setResyncQueueFillFraction(fraction);
  }
  void setMaxQueuedIFrames(int count) {
    video_sync.setMaxQueuedIFrames(count);
  }
  void setTaskParameters(uint32_t stackSizeWords, uint8_t priority,
                          int core = -1) {
    video_sync.setTaskParameters(stackSizeWords, priority, core);
  }
  void setQueueBytes(size_t bytes) { video_sync.setQueueBytes(bytes); }
  void setQueueUsePSRAM(bool flag) { video_sync.setQueueUsePSRAM(flag); }
 
  bool begin(Stream& source) {
    if (p_video_output == nullptr) {
      LOGE("VideoPlayer: no VideoOutput set - call setVideoOutput() first");
      return false;
    }
    p_source = &source;
 
    // video: decoder -> display, buffered/paced through video_sync
    // (video_sync's target is fixed at construction time - it is
    // initialized from default_video_decoder in the member declaration
    // below)
    default_video_decoder.setOutput(*p_video_output);
    default_video_decoder.setVideoInfoSource(default_demuxer);
    // Default no-op for a VideoOutput that doesn't need it (see
    // VideoOutput::setVideoInfoSource()'s own comment) - saves every
    // sketch its own setVideoInfoSource() call for one that does (e.g.
    // OutputTinyGPU/OutputOpenCV/OutputTFT_eSPI).
    p_video_output->setVideoInfoSource(default_demuxer);
    if (!default_video_decoder.begin()) {
      LOGE("VideoPlayer: MultiVideoDecoder begin() failed");
      return false;
    }
    default_demuxer.setOutputVideo(video_sync);
 
    // audio path is optional - only wired up when setAudioOutput() was
    // called
    if (p_audio_output != nullptr) {
      default_audio_decoder.setMimeSource(default_demuxer);
      audio_out.setDecoder(&default_audio_decoder);
      if (use_audio_clock) {
        // Route through the most specific overload available (see
        // setAudioOutput()'s own comment) so audio-info change
        // notifications still reach the real output.
        if (p_audio_output_typed != nullptr) {
          audio_clock.setOutput(*p_audio_output_typed);
        } else if (p_audio_stream != nullptr) {
          audio_clock.setStream(*p_audio_stream);
        } else {
          audio_clock.setOutput(*p_audio_output);
        }
        audio_out.setStream(audio_clock);
        video_sync.setAudioClock(audio_clock);
      } else if (p_audio_output_typed != nullptr) {
        audio_out.setOutput(*p_audio_output_typed);
      } else if (p_audio_stream != nullptr) {
        audio_out.setStream(*p_audio_stream);
      } else {
        audio_out.setOutput(*p_audio_output);
      }
      if (!audio_out.begin()) {
        LOGE("VideoPlayer: EncodedAudioStream begin() failed");
        return false;
      }
      default_demuxer.setOutputAudio(audio_out);
    }
 
    if (!default_demuxer.begin()) {
      LOGE("VideoPlayer: MultiVideoDemuxer begin() failed");
      return false;
    }
    active = true;
    return true;
  }
 
  void end() {
    active = false;
    video_sync.end();
    default_video_decoder.end();
    if (p_audio_output != nullptr) audio_out.end();
    default_demuxer.end();
  }
 
  size_t copy() {
    if (!active || p_source == nullptr) return 0;
    float fps = default_demuxer.getVideoInfo().fps;
    if (fps > 0) video_sync.setFps(fps);
    uint8_t buffer[buffer_size];
    size_t len = p_source->readBytes(buffer, buffer_size);
    if (len == 0) return 0;
    // Retry on a partial accept instead of dropping the remainder, which
    // would desync the demuxer from the real byte stream (duplicated here
    // rather than reusing CodecCopy::writeAll() since CodecCopy binds its
    // Stream& at construction time, before begin(Stream&)'s source is
    // known).
    size_t written = 0;
    while (written < len) {
      size_t n = default_demuxer.write(buffer + written, len - written);
      if (n == 0) break;
      written += n;
    }
    return written;
  }
 
  size_t copyAll() {
    size_t result = 0;
    size_t step = copy();
    while (step > 0) {
      result += step;
      step = copy();
    }
    return result;
  }
 
  bool isActive() const { return active; }
  operator bool() const { return active; }
 
  void setActive(bool isActive) { active = isActive; }
 
  MultiVideoDemuxer& demuxer() { return default_demuxer; }
  MultiVideoDecoder& videoDecoder() { return default_video_decoder; }
  MultiDecoder& audioDecoder() { return default_audio_decoder; }
  PacedVideoOutput& videoSyncTask() { return video_sync; }
  Stream* getStream() { return p_source; }
  void logTo(Print& out) { video_sync.logTo(out); }
 
 protected:
  VideoOutput* p_video_output = nullptr;
  Print* p_audio_output = nullptr;
  // Set alongside p_audio_output by the matching setAudioOutput()
  // overload - see its own comment for why begin() prefers these over
  // the generic Print* above when wiring audio_clock/audio_out.
  AudioOutput* p_audio_output_typed = nullptr;
  AudioStream* p_audio_stream = nullptr;
  Stream* p_source = nullptr;
 
  // Empty until addDemuxer() registers a container demuxer.
  MultiVideoDemuxer default_demuxer;
  // Declared before video_sync below, which takes this address at
  // construction time.
  MultiVideoDecoder default_video_decoder;
  // Empty until addAudioDecoder() registers an audio codec decoder.
  MultiDecoder default_audio_decoder;
 
  PacedVideoOutput video_sync{default_video_decoder};
  AudioTimeSourceStream audio_clock;
  EncodedAudioStream audio_out;
 
  bool use_audio_clock = true;
  int buffer_size = 1024;
  bool active = false;
};
 
}  // namespace audio_tools