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; }
 
  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 - see its own member
    // declaration below)
    default_video_decoder.setOutput(*p_video_output);
    default_video_decoder.setVideoInfoSource(default_demuxer);
    if (!default_video_decoder.begin()) {
      LOGE("VideoPlayer: MultiVideoDecoder begin() failed");
      return false;
    }
    default_demuxer.setOutputVideo(video_sync);
 
    // audio (optional - see the class comment's "Audio clock" section)
    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 (see
    // CodecCopy::writeAll()'s own comment - duplicated here rather than
    // reused 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; }
 
 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 by default (see the class comment) - populated via
  // addDemuxer().
  MultiVideoDemuxer default_demuxer;
  // Declared before video_sync below, which takes this address at
  // construction time.
  MultiVideoDecoder default_video_decoder;
  // Empty by default (see the class comment) - populated via
  // addAudioDecoder().
  MultiDecoder default_audio_decoder;
 
  PacedVideoOutput video_sync{default_video_decoder};
  AudioTimeSourceStream audio_clock;
  EncodedAudioStream audio_out;
 
  bool use_audio_clock = false;
  int buffer_size = 1024;
  bool active = false;
};
 
}  // namespace audio_tools