Motown: ffmpeg implementations of framework 'parts'

services/media/framework_ffmpeg/ffmpeg_demux.cc

+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include <map>
+
+#include "base/logging.h"
+#include "services/media/framework/safe_clone.h"
+#include "services/media/framework_ffmpeg/ffmpeg_demux.h"
+#include "services/media/framework_ffmpeg/ffmpeg_io.h"
+#include "services/media/framework_ffmpeg/ffmpeg_type_converters.h"
+
+namespace mojo {
+namespace media {
+
+class FfmpegDemuxImpl : public FfmpegDemux {
+ public:
+  FfmpegDemuxImpl();
+
+  ~FfmpegDemuxImpl() override;
+
+  // Demux implementation.
+  Result Init(std::shared_ptr<Reader> reader) override;
+
+  std::unique_ptr<Metadata> metadata() const override;
+
+  const std::vector<DemuxStream*>& streams() const override;
+
+  // MultistreamSource implementation.
+  size_t stream_count() const override;
+
+  PacketPtr PullPacket(size_t* stream_index_out) override;
+
+ private:
+  class FfmpegDemuxStream : public DemuxStream {
+   public:
+    FfmpegDemuxStream(const AVFormatContext& format_context, size_t index);
+
+    ~FfmpegDemuxStream() override;
+
+    // Demux::DemuxStream implementation.
+    size_t index() const override;
+
+    std::unique_ptr<StreamType> stream_type() const override;
+
+   private:
+    AVStream* stream_;
+    size_t index_;
+    std::unique_ptr<StreamType> stream_type_;
+  };
+
+  // Specialized packet implementation.
+  class DemuxPacket : public Packet {
+   public:
+    DemuxPacket() {
+      av_init_packet(&av_packet_);
+    }
+
+    // Packet implementation.
+    int64_t presentation_time() const override { return av_packet_.pts; };
+
+    uint64_t duration() const override { return av_packet_.duration; };
+
+    bool end_of_stream() const override { return false; }
+
+    size_t size() const override { return size_t(av_packet_.size); }
+
+    void* payload() const override {
+      return reinterpret_cast<void*>(av_packet_.data);
+    }
+
+    AVPacket& av_packet() {
+      return av_packet_;
+    }
+
+   protected:
+    ~DemuxPacket() override {
+      av_free_packet(&av_packet_);
+    }
+
+    void Release() override { delete this; }
+
+  private:
+    AVPacket av_packet_;
+  };
+
+  struct AVFormatContextDeleter {
+    inline void operator()(AVFormatContext* ptr) const {
+      avformat_free_context(ptr);
+    }
+  };
+
+  // Produces an end-of-stream packet for next_stream_to_end_.
+  PacketPtr PullEndOfStreamPacket(size_t* stream_index_out);
+
+  // Copies metadata from the specified source into map.
+  void CopyMetadata(
+      AVDictionary* source,
+      std::map<std::string, std::string>& map);
+
+  std::shared_ptr<Reader> reader_;
+  std::unique_ptr<AVFormatContext, AVFormatContextDeleter> format_context_;
+  AvioContextPtr io_context_;
+  std::vector<DemuxStream*> streams_;
+  std::unique_ptr<Metadata> metadata_;
+  int64_t next_presentation_time_;
+  int next_stream_to_end_; // -1 means don't end. streams_.size() means stop.
+};
+
+// static
+std::shared_ptr<Demux> FfmpegDemux::Create() {
+  return std::shared_ptr<Demux>(new FfmpegDemuxImpl());
+}
+
+FfmpegDemuxImpl::FfmpegDemuxImpl() : next_stream_to_end_(-1) {}
+
+FfmpegDemuxImpl::~FfmpegDemuxImpl() {}
+
+Result FfmpegDemuxImpl::Init(std::shared_ptr<Reader> reader) {
+  static constexpr uint64_t kNanosecondsPerMicrosecond = 1000;
+
+  reader_ = reader;
+
+  io_context_ = CreateAvioContext(reader.get());
+  if (!io_context_) {
+    LOG(ERROR) << "CreateAvioContext failed (allocation failure)";
+    return Result::kInternalError;
+  }
+
+  // TODO(dalesat): Consider ffmpeg util to centralize memory management.
+  AVFormatContext* format_context = avformat_alloc_context();
+  format_context->flags |= AVFMT_FLAG_CUSTOM_IO | AVFMT_FLAG_FAST_SEEK;
+  format_context->pb = io_context_.get();
+
+  // TODO(dalesat): This synchronous operation may take a long time.
+  int r = avformat_open_input(&format_context, nullptr, nullptr, nullptr);
+  format_context_.reset(format_context);
+  if (r < 0) {
+    return Result::kInternalError;
+  }
+
+  // TODO(dalesat): This synchronous operation may take a long time.
+  r = avformat_find_stream_info(format_context_.get(), nullptr);
+  if (r < 0) {
+    LOG(ERROR) << "avformat_find_stream_info failed, result " << r;
+    return Result::kInternalError;
+  }
+
+  std::map<std::string, std::string> metadata_map;
+
+  CopyMetadata(format_context_->metadata, metadata_map);
+  for (uint i = 0; i < format_context_->nb_streams; i++) {
+    streams_.push_back(new FfmpegDemuxStream(*format_context_, i));
+    CopyMetadata(format_context_->streams[i]->metadata, metadata_map);
+  }
+
+  metadata_ = Metadata::Create(
+      format_context_->duration * kNanosecondsPerMicrosecond,
+      metadata_map["TITLE"],
+      metadata_map["ARTIST"],
+      metadata_map["ALBUM"],
+      metadata_map["PUBLISHER"],
+      metadata_map["GENRE"],
+      metadata_map["COMPOSER"]);
+
+  return Result::kOk;
+}
+
+std::unique_ptr<Metadata> FfmpegDemuxImpl::metadata() const {
+  return SafeClone(metadata_);
+}
+
+const std::vector<Demux::DemuxStream*>& FfmpegDemuxImpl::streams() const {
+  return streams_;
+}
+
+size_t FfmpegDemuxImpl::stream_count() const {
+  if (!format_context_) {
+    return 0;
+  }
+  return format_context_->nb_streams;
+}
+
+PacketPtr FfmpegDemuxImpl::PullPacket(size_t* stream_index_out) {
+  DCHECK(stream_index_out);
+
+  if (next_stream_to_end_ != -1) {
+    // We're producing end-of-stream packets for all the streams.
+    return PullEndOfStreamPacket(stream_index_out);
+  }
+
+  FfmpegDemuxImpl::DemuxPacket* demux_packet =
+      new FfmpegDemuxImpl::DemuxPacket();
+
+  demux_packet->av_packet().data = nullptr;
+  demux_packet->av_packet().size = 0;
+
+  if (av_read_frame(format_context_.get(), &demux_packet->av_packet()) < 0) {
+    // End of stream. Start producing end-of-stream packets for all the streams.
+    PacketPtr(demux_packet); // Deletes demux_packet.
+    next_stream_to_end_ = 0;
+    return PullEndOfStreamPacket(stream_index_out);
+  }
+
+  *stream_index_out =
+      static_cast<size_t>(demux_packet->av_packet().stream_index);
+  // TODO(dalesat): What if the packet has no PTS or duration?
+  next_presentation_time_ =
+      demux_packet->presentation_time() + demux_packet->duration();
+
+  return PacketPtr(demux_packet);
+}
+
+PacketPtr FfmpegDemuxImpl::PullEndOfStreamPacket(size_t* stream_index_out) {
+  DCHECK(next_stream_to_end_ >= 0);
+
+  if (static_cast<std::size_t>(next_stream_to_end_) >= streams_.size()) {
+    NOTREACHED() << "PullPacket called after all streams have ended";
+    return nullptr;
+  }
+
+  *stream_index_out = next_stream_to_end_++;
+  return Packet::CreateEndOfStream(next_presentation_time_);
+}
+
+void FfmpegDemuxImpl::CopyMetadata(
+    AVDictionary* source,
+    std::map<std::string, std::string>& map) {
+  if (source == nullptr) {
+    return;
+  }
+
+  for (AVDictionaryEntry *entry =
+      av_dict_get(source, "", nullptr, AV_DICT_IGNORE_SUFFIX);
+      entry != nullptr;
+      entry = av_dict_get(source, "", entry, AV_DICT_IGNORE_SUFFIX)) {
+    if (map.find(entry->key) == map.end()) {
+      map.emplace(entry->key, entry->value);
+    }
+  }
+}
+
+FfmpegDemuxImpl::FfmpegDemuxStream::FfmpegDemuxStream(
+    const AVFormatContext& format_context,
+    size_t index) :
+    stream_(format_context.streams[index]), index_(index) {
+  stream_type_ = StreamTypeFromAVCodecContext(*stream_->codec);
+}
+
+FfmpegDemuxImpl::FfmpegDemuxStream::~FfmpegDemuxStream() {}
+
+size_t FfmpegDemuxImpl::FfmpegDemuxStream::index() const {
+  return index_;
+}
+
+std::unique_ptr<StreamType> FfmpegDemuxImpl::FfmpegDemuxStream::stream_type()
+    const {
+  return SafeClone(stream_type_);
+}
+
+} // namespace media
+} // namespace mojo