MultiVideoDecoder.h

Go to the documentation of this file.

#pragma once
 
#include "AudioTools/CoreAudio/AudioBasic/Collections/Vector.h"
#include "AudioTools/Video/CodecVideo.h"
 
namespace audio_tools {
 
class MultiVideoDecoder : public VideoDecoder, public VideoInfoSource {
 public:
  void addDecoder(VideoDecoder &decoder) {
    VideoFormat format = decoder.codecFormat();
    for (int i = 0; i < decoders.size(); i++) {
      if (decoders[i].format == format) {
        decoders.erase(i);
        break;
      }
    }
    DecoderInfo info;
    info.decoder = &decoder;
    info.format = format;
    decoders.push_back(info);
  }
 
  void setVideoInfoSource(VideoInfoSource &source) {
    p_video_info_source = &source;
  }
 
  void setOutput(Print &out) override {
    for (int i = 0; i < decoders.size(); i++) decoders[i].decoder->setOutput(out);
  }
 
  void setOutput(VideoOutput &out) override {
    for (int i = 0; i < decoders.size(); i++) decoders[i].decoder->setOutput(out);
  }
 
  void setVideoFormat(VideoFormat format) override {
    for (int i = 0; i < decoders.size(); i++)
      decoders[i].decoder->setVideoFormat(format);
  }
 
  VideoInfo videoInfo() override {
    return p_selected != nullptr ? p_selected->videoInfo() : VideoInfo{};
  }
 
  VideoFormat codecFormat() override { return p_selected_format; }
 
  bool begin() override {
    p_selected = nullptr;
    p_selected_format = VideoFormat::UNKNOWN;
    is_first = true;
    return true;
  }
 
  void end() override {
    if (p_selected != nullptr) p_selected->end();
    p_selected = nullptr;
    p_selected_format = VideoFormat::UNKNOWN;
    is_first = true;
  }
 
  size_t write(const uint8_t *data, size_t len) override {
    if (len == 0) return 0;
    ensureSelected(data, len);
    return p_selected != nullptr ? p_selected->write(data, len) : len;
  }
 
  void flush() override {
    if (p_selected != nullptr) p_selected->flush();
  }
 
  void setSkipRender(bool skip) override {
    if (p_selected != nullptr) p_selected->setSkipRender(skip);
  }
 
  bool isKeyFrame(const uint8_t *data, size_t len) override {
    ensureSelected(data, len);
    return p_selected != nullptr ? p_selected->isKeyFrame(data, len) : false;
  }
 
  uint64_t totalDecodeMs() const override {
    return p_selected != nullptr ? p_selected->totalDecodeMs() : 0;
  }
 
  VideoFormat selectedFormat() const { return p_selected_format; }
 
 protected:
  struct DecoderInfo {
    VideoDecoder *decoder = nullptr;
    VideoFormat format = VideoFormat::UNKNOWN;
  };
 
  Vector<DecoderInfo> decoders{0};
  VideoDecoder *p_selected = nullptr;
  VideoFormat p_selected_format = VideoFormat::UNKNOWN;
  VideoInfoSource *p_video_info_source = nullptr;
  bool is_first = true;
 
  void select(DecoderInfo &info) {
    p_selected = info.decoder;
    p_selected_format = info.format;
    p_selected->begin();
    LOGI("MultiVideoDecoder: selected decoder for format %d", (int)info.format);
  }
 
  void ensureSelected(const uint8_t *data, size_t len) {
    if (!is_first) return;
    is_first = false;
    if (p_video_info_source != nullptr) {
      VideoFormat source_format = p_video_info_source->videoInfo().format;
      for (int i = 0; i < decoders.size(); i++) {
        if (decoders[i].format == source_format) {
          LOGI("MultiVideoDecoder: format %d from VideoInfoSource",
               (int)source_format);
          select(decoders[i]);
          break;
        }
      }
    }
    if (p_selected == nullptr) {
      for (int i = 0; i < decoders.size(); i++) {
        if (decoders[i].decoder->isValid(data, len)) {
          select(decoders[i]);
          break;
        }
      }
    }
    if (p_selected == nullptr) {
      LOGE(
          "MultiVideoDecoder: could not determine video format from "
          "first %u bytes",
          (unsigned)len);
    }
  }
};
 
}  // namespace audio_tools