Switch to AVIO instead of a custom FFmpeg URLProtocol handler.

media/filters/audio_file_reader.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/filters/audio_file_reader.h"
 
-#include <string>
-#include "base/basictypes.h"
-#include "base/string_util.h"
+#include "base/logging.h"
 #include "base/time.h"
 #include "media/base/audio_bus.h"
 #include "media/ffmpeg/ffmpeg_common.h"
 #include "media/filters/ffmpeg_glue.h"
 
 namespace media {
 
 AudioFileReader::AudioFileReader(FFmpegURLProtocol* protocol)
-    : protocol_(protocol),
-      format_context_(NULL),
-      codec_context_(NULL),
-      stream_index_(0) {
+    : codec_context_(NULL),
+      stream_index_(0),
+      protocol_(protocol) {
 }
 
 AudioFileReader::~AudioFileReader() {
   Close();
 }
 
 int AudioFileReader::channels() const {
   return codec_context_->channels;
 }
 
 int AudioFileReader::sample_rate() const {
   return codec_context_->sample_rate;
 }
 
 base::TimeDelta AudioFileReader::duration() const {
   const AVRational av_time_base = {1, AV_TIME_BASE};
-  return ConvertFromTimeBase(av_time_base, format_context_->duration);
+  return ConvertFromTimeBase(av_time_base, glue_->format_context()->duration);
 }
 
 int64 AudioFileReader::number_of_frames() const {
   return static_cast<int64>(duration().InSecondsF() * sample_rate());
 }
 
 bool AudioFileReader::Open() {
-  // Add our data reader to the protocol list and get our unique key.
-  std::string key = FFmpegGlue::GetInstance()->AddProtocol(protocol_);
+  glue_.reset(new FFmpegGlue(protocol_));
+  AVFormatContext* format_context = glue_->format_context();
 
   // Open FFmpeg AVFormatContext.
-  DCHECK(!format_context_);
-  AVFormatContext* context = NULL;
-
-  int result = avformat_open_input(&context, key.c_str(), NULL, NULL);
-
-  // Remove our data reader from protocol list since avformat_open_input() setup
-  // the AVFormatContext with the data reader.
-  FFmpegGlue::GetInstance()->RemoveProtocol(protocol_);
-
-  if (result) {
-    DLOG(WARNING)
-        << "AudioFileReader::Open() : error in avformat_open_input() -"
-        << " result: " << result;
+  if (!glue_->OpenContext()) {
+    DLOG(WARNING) << "AudioFileReader::Open() : error in avformat_open_input()";
     return false;
   }
 
-  DCHECK(context);
-  format_context_ = context;
-
   // Get the codec context.
   codec_context_ = NULL;
-  for (size_t i = 0; i < format_context_->nb_streams; ++i) {
-    AVCodecContext* c = format_context_->streams[i]->codec;
+  for (size_t i = 0; i < format_context->nb_streams; ++i) {
+    AVCodecContext* c = format_context->streams[i]->codec;
     if (c->codec_type == AVMEDIA_TYPE_AUDIO) {
       codec_context_ = c;
       stream_index_ = i;
       break;
     }
   }
 
   // Get the codec.
   if (!codec_context_)
     return false;
 
-  avformat_find_stream_info(format_context_, NULL);
+  int result = avformat_find_stream_info(format_context, NULL);
+  if (result < 0) {
+    DLOG(WARNING)
+        << "AudioFileReader::Open() : error in avformat_find_stream_info()";
+    return false;
+  }
+
   AVCodec* codec = avcodec_find_decoder(codec_context_->codec_id);
   if (codec) {
     if ((result = avcodec_open2(codec_context_, codec, NULL)) < 0) {
       DLOG(WARNING) << "AudioFileReader::Open() : could not open codec -"
           << " result: " << result;
       return false;
     }
   } else {
     DLOG(WARNING) << "AudioFileReader::Open() : could not find codec -"
         << " result: " << result;
     return false;
   }
 
   return true;
 }
 
 void AudioFileReader::Close() {
   if (codec_context_) {
     avcodec_close(codec_context_);
     codec_context_ = NULL;
   }
-
-  if (format_context_) {
-    avformat_close_input(&format_context_);
-    format_context_ = NULL;
-  }
 }
 
 bool AudioFileReader::Read(AudioBus* audio_bus) {
-  DCHECK(format_context_ && codec_context_) <<
+  DCHECK(glue_.get() && codec_context_) <<
       "AudioFileReader::Read() : reader is not opened!";
 
   DCHECK_EQ(audio_bus->channels(), channels());
   if (audio_bus->channels() != channels())
     return false;
 
   size_t bytes_per_sample = av_get_bytes_per_sample(codec_context_->sample_fmt);
 
   // Holds decoded audio.
   scoped_ptr_malloc<AVFrame, ScopedPtrAVFree> av_frame(avcodec_alloc_frame());
 
   // Read until we hit EOF or we've read the requested number of frames.
   AVPacket packet;
   int current_frame = 0;
   bool continue_decoding = true;
 
   while (current_frame < audio_bus->frames() && continue_decoding &&
-         av_read_frame(format_context_, &packet) >= 0 &&
+         av_read_frame(glue_->format_context(), &packet) >= 0 &&
          av_dup_packet(&packet) >= 0) {
     // Skip packets from other streams.
     if (packet.stream_index != stream_index_) {
       av_free_packet(&packet);
       continue;
     }
 
     // Make a shallow copy of packet so we can slide packet.data as frames are
     // decoded from the packet; otherwise av_free_packet() will corrupt memory.
     AVPacket packet_temp = packet;
@@ skipping 42 matching lines @@
 
   // Zero any remaining frames.
   audio_bus->ZeroFramesPartial(
       current_frame, audio_bus->frames() - current_frame);
 
   // Fail if nothing has been decoded, otherwise return partial data.
   return current_frame > 0;
 }
 
 }  // namespace media