Switch to AVIO instead of a custom FFmpeg URLProtocol handler.

media/webm/webm_stream_parser.cc

 // Copyright (c) 2012 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 "media/webm/webm_stream_parser.h"
 
 #include <string>
 
 #include "base/callback.h"
 #include "base/logging.h"
@@ skipping 22 matching lines @@
   bool Parse(const uint8* data, int size);
 
   const AudioDecoderConfig& audio_config() const;
   const VideoDecoderConfig& video_config() const;
 
  private:
   static const uint8 kWebMHeader[];
   static const int kSegmentSizeOffset;
   static const uint8 kEmptyCluster[];
 
-  AVFormatContext* CreateFormatContext(const uint8* data, int size);
+  bool OpenFormatContext(const uint8* data, int size);
   bool SetupStreamConfigs();
 
   AudioDecoderConfig audio_config_;
   VideoDecoderConfig video_config_;
 
   // Backing buffer for |url_protocol_|.
   scoped_array<uint8> url_protocol_buffer_;
 
-  // Protocol used by |format_context_|. It must outlive the context object.
+  // Protocol used by FFmpegGlue. It must outlive the context object.
   scoped_ptr<InMemoryUrlProtocol> url_protocol_;
 
-  // FFmpeg format context for this demuxer. It is created by
-  // avformat_open_input() during demuxer initialization and cleaned up with
-  // DestroyAVFormatContext() in the destructor.
-  AVFormatContext* format_context_;
+  // Glue for interfacing InMemoryUrlProtocol with FFmpeg.
+  scoped_ptr<FFmpegGlue> glue_;
 
   DISALLOW_COPY_AND_ASSIGN(FFmpegConfigHelper);
 };
 
 // WebM File Header. This is prepended to the INFO & TRACKS
 // data passed to Init() before handing it to FFmpeg. Essentially
 // we are making the INFO & TRACKS data look like a small WebM
 // file so we can use FFmpeg to initialize the AVFormatContext.
 const uint8 FFmpegConfigHelper::kWebMHeader[] = {
   0x1A, 0x45, 0xDF, 0xA3, 0x9F,  // EBML (size = 0x1f)
@@ skipping 11 matching lines @@
 };
 
 // Offset of the segment size field in kWebMHeader. Used to update
 // the segment size field before handing the buffer to FFmpeg.
 const int FFmpegConfigHelper::kSegmentSizeOffset = sizeof(kWebMHeader) - 8;
 
 const uint8 FFmpegConfigHelper::kEmptyCluster[] = {
   0x1F, 0x43, 0xB6, 0x75, 0x80  // CLUSTER (size = 0)
 };
 
-FFmpegConfigHelper::FFmpegConfigHelper() : format_context_(NULL) {}
+FFmpegConfigHelper::FFmpegConfigHelper() {}
 
 FFmpegConfigHelper::~FFmpegConfigHelper() {
-  if (!format_context_)
-    return;
-
-  DestroyAVFormatContext(format_context_);
-  format_context_ = NULL;
-
   if (url_protocol_.get()) {
-    FFmpegGlue::GetInstance()->RemoveProtocol(url_protocol_.get());
     url_protocol_.reset();
     url_protocol_buffer_.reset();
   }
+
+  if (glue_.get())
+    glue_.reset();
 }
 
 bool FFmpegConfigHelper::Parse(const uint8* data, int size) {
-  format_context_ = CreateFormatContext(data, size);
-  return format_context_ && SetupStreamConfigs();
+  return OpenFormatContext(data, size) && SetupStreamConfigs();
 }
 
 const AudioDecoderConfig& FFmpegConfigHelper::audio_config() const {
   return audio_config_;
 }
 
 const VideoDecoderConfig& FFmpegConfigHelper::video_config() const {
   return video_config_;
 }
 
-AVFormatContext* FFmpegConfigHelper::CreateFormatContext(const uint8* data,
-                                                         int size) {
+bool FFmpegConfigHelper::OpenFormatContext(const uint8* data, int size) {
   DCHECK(!url_protocol_.get());
   DCHECK(!url_protocol_buffer_.get());
+  DCHECK(!glue_.get());
 
   int segment_size = size + sizeof(kEmptyCluster);
   int buf_size = sizeof(kWebMHeader) + segment_size;
   url_protocol_buffer_.reset(new uint8[buf_size]);
   uint8* buf = url_protocol_buffer_.get();
   memcpy(buf, kWebMHeader, sizeof(kWebMHeader));
   memcpy(buf + sizeof(kWebMHeader), data, size);
   memcpy(buf + sizeof(kWebMHeader) + size, kEmptyCluster,
          sizeof(kEmptyCluster));
 
   // Update the segment size in the buffer.
   int64 tmp = (segment_size & GG_LONGLONG(0x00FFFFFFFFFFFFFF)) |
       GG_LONGLONG(0x0100000000000000);
   for (int i = 0; i < 8; i++) {
     buf[kSegmentSizeOffset + i] = (tmp >> (8 * (7 - i))) & 0xff;
   }
 
   url_protocol_.reset(new InMemoryUrlProtocol(buf, buf_size, true));
-  std::string key = FFmpegGlue::GetInstance()->AddProtocol(url_protocol_.get());
+  glue_.reset(new FFmpegGlue(url_protocol_.get()));
 
   // Open FFmpeg AVFormatContext.
-  AVFormatContext* context = NULL;
-  int result = avformat_open_input(&context, key.c_str(), NULL, NULL);
-
-  if (result < 0)
-    return NULL;
-
-  return context;
+  return glue_->OpenContext() >= 0;
 }
 
 bool FFmpegConfigHelper::SetupStreamConfigs() {
-  int result = avformat_find_stream_info(format_context_, NULL);
+  AVFormatContext* format_context = glue_->format_context();
+  int result = avformat_find_stream_info(format_context, NULL);
 
   if (result < 0)
     return false;
 
   bool no_supported_streams = true;
-  for (size_t i = 0; i < format_context_->nb_streams; ++i) {
-    AVStream* stream = format_context_->streams[i];
+  for (size_t i = 0; i < format_context->nb_streams; ++i) {
+    AVStream* stream = format_context->streams[i];
     AVCodecContext* codec_context = stream->codec;
     AVMediaType codec_type = codec_context->codec_type;
 
     if (codec_type == AVMEDIA_TYPE_AUDIO &&
         stream->codec->codec_id == CODEC_ID_VORBIS &&
         !audio_config_.IsValidConfig()) {
       AVCodecContextToAudioDecoderConfig(stream->codec, &audio_config_);
       no_supported_streams = false;
       continue;
     }
@@ skipping 277 matching lines @@
   if (!video_buffers.empty() && !video_cb_.Run(video_buffers))
     return -1;
 
   if (cluster_ended)
     end_of_segment_cb_.Run();
 
   return bytes_parsed;
 }
 
 }  // namespace media