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;
    if (is_first) {
      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);
      }
    }
    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 {
    return p_selected != nullptr ? p_selected->isKeyFrame(data, len) : false;
  }
 
  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);
  }
};
 
}  // namespace audio_tools