Motown: New wrapper classes for ffmpeg format context and io context

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/av_codec_context.h"
+#include "services/media/framework_ffmpeg/av_format_context.h"
+#include "services/media/framework_ffmpeg/av_io_context.h"
 #include "services/media/framework_ffmpeg/av_packet.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;
 
@@ skipping 67 matching lines @@
 
   // 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_;
+  AvFormatContextPtr format_context_;
+  AvIoContextPtr io_context_;
   std::vector<DemuxStream*> streams_;
   std::unique_ptr<Metadata> metadata_;
   int64_t next_pts_;
   int next_stream_to_end_ = -1; // -1: don't end, streams_.size(): stop.
 };
 
 // static
 std::shared_ptr<Demux> FfmpegDemux::Create() {
   return std::shared_ptr<Demux>(new FfmpegDemuxImpl());
 }
 
 FfmpegDemuxImpl::FfmpegDemuxImpl() {}
 
 FfmpegDemuxImpl::~FfmpegDemuxImpl() {}
 
 Result FfmpegDemuxImpl::Init(std::shared_ptr<Reader> reader) {
   static constexpr uint64_t kNanosecondsPerMicrosecond = 1000;
 
   reader_ = reader;
 
-  io_context_ = CreateAvioContext(reader.get());
+  io_context_ = AvIoContext::Create(reader);
   if (!io_context_) {
-    LOG(ERROR) << "CreateAvioContext failed (allocation failure)";
+    LOG(ERROR) << "AvIoContext::Create 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) {
+  format_context_ = AvFormatContext::OpenInput(io_context_);
+  if (!format_context_) {
     return Result::kInternalError;
   }
 
   // TODO(dalesat): This synchronous operation may take a long time.
-  r = avformat_find_stream_info(format_context_.get(), nullptr);
+  int 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));
@@ skipping 88 matching lines @@
     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);
+  stream_type_ = AvCodecContext::GetStreamType(*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