Switch to AVIO instead of a custom FFmpeg URLProtocol handler.

media/filters/ffmpeg_demuxer.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/ffmpeg_demuxer.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/bind.h"
@@ skipping 244 matching lines @@
 }
 
 //
 // FFmpegDemuxer
 //
 FFmpegDemuxer::FFmpegDemuxer(
     const scoped_refptr<base::MessageLoopProxy>& message_loop,
     const scoped_refptr<DataSource>& data_source)
     : host_(NULL),
       message_loop_(message_loop),
-      format_context_(NULL),
       data_source_(data_source),
       read_event_(false, false),
       read_has_failed_(false),
       last_read_bytes_(0),
       read_position_(0),
       bitrate_(0),
       start_time_(kNoTimestamp()),
       audio_disabled_(false),
       duration_known_(false) {
   DCHECK(message_loop_);
   DCHECK(data_source_);
 }
 
-FFmpegDemuxer::~FFmpegDemuxer() {
-  // In this destructor, we clean up resources held by FFmpeg. It is ugly to
-  // close the codec contexts here because the corresponding codecs are opened
-  // in the decoder filters. By reaching this point, all filters should have
-  // stopped, so this is the only safe place to do the global clean up.
-  // TODO(hclam): close the codecs in the corresponding decoders.
-  if (!format_context_)
-    return;
-
-  DestroyAVFormatContext(format_context_);
-  format_context_ = NULL;
-}
+FFmpegDemuxer::~FFmpegDemuxer() {}
 
 void FFmpegDemuxer::PostDemuxTask() {
   message_loop_->PostTask(FROM_HERE,
                           base::Bind(&FFmpegDemuxer::DemuxTask, this));
 }
 
 void FFmpegDemuxer::Stop(const base::Closure& callback) {
   // Post a task to notify the streams to stop as well.
   message_loop_->PostTask(FROM_HERE,
                           base::Bind(&FFmpegDemuxer::StopTask, this, callback));
@@ skipping 36 matching lines @@
       return *iter;
     }
   }
   return NULL;
 }
 
 base::TimeDelta FFmpegDemuxer::GetStartTime() const {
   return start_time_;
 }
 
-size_t FFmpegDemuxer::Read(size_t size, uint8* data) {
+int FFmpegDemuxer::Read(int size, uint8* data) {
   DCHECK(host_);
   DCHECK(data_source_);
 
   // If read has ever failed, return with an error.
   // TODO(hclam): use a more meaningful constant as error.
   if (read_has_failed_)
     return AVERROR(EIO);
 
   // Even though FFmpeg defines AVERROR_EOF, it's not to be used with I/O
   // routines.  Instead return 0 for any read at or past EOF.
@@ skipping 95 matching lines @@
 
 void FFmpegDemuxer::InitializeTask(DemuxerHost* host,
                                    const PipelineStatusCB& status_cb) {
   DCHECK(message_loop_->BelongsToCurrentThread());
   host_ = host;
 
   // TODO(scherkus): DataSource should have a host by this point,
   // see http://crbug.com/122071
   data_source_->set_host(host);
 
-  // Add ourself to Protocol list and get our unique key.
-  std::string key = FFmpegGlue::GetInstance()->AddProtocol(this);
-
-  // Open FFmpeg AVFormatContext.
-  DCHECK(!format_context_);
-  AVFormatContext* context = avformat_alloc_context();
+  glue_.reset(new FFmpegGlue(this));
+  AVFormatContext* format_context = glue_->format_context();
 
   // Disable ID3v1 tag reading to avoid costly seeks to end of file for data we
   // don't use.  FFmpeg will only read ID3v1 tags if no other metadata is
   // available, so add a metadata entry to ensure some is always present.
-  av_dict_set(&context->metadata, "skip_id3v1_tags", "", 0);
+  av_dict_set(&format_context->metadata, "skip_id3v1_tags", "", 0);
 
-  int result = avformat_open_input(&context, key.c_str(), NULL, NULL);
-
-  // Remove ourself from protocol list.
-  FFmpegGlue::GetInstance()->RemoveProtocol(this);
-
-  if (result < 0) {
+  if (!glue_->OpenContext()) {
     status_cb.Run(DEMUXER_ERROR_COULD_NOT_OPEN);
     return;
   }
 
-  DCHECK(context);
-  format_context_ = context;
-
   // Fully initialize AVFormatContext by parsing the stream a little.
-  result = avformat_find_stream_info(format_context_, NULL);
+  int result = avformat_find_stream_info(format_context, NULL);
   if (result < 0) {
     status_cb.Run(DEMUXER_ERROR_COULD_NOT_PARSE);
     return;
   }
 
   // Create demuxer stream entries for each possible AVStream.
-  streams_.resize(format_context_->nb_streams);
+  streams_.resize(format_context->nb_streams);
   bool found_audio_stream = false;
   bool found_video_stream = false;
 
   base::TimeDelta max_duration;
-  for (size_t i = 0; i < format_context_->nb_streams; ++i) {
-    AVCodecContext* codec_context = format_context_->streams[i]->codec;
+  for (size_t i = 0; i < format_context->nb_streams; ++i) {
+    AVCodecContext* codec_context = format_context->streams[i]->codec;
     AVMediaType codec_type = codec_context->codec_type;
 
     if (codec_type == AVMEDIA_TYPE_AUDIO) {
       if (found_audio_stream)
         continue;
       // Ensure the codec is supported.
       if (CodecIDToAudioCodec(codec_context->codec_id) == kUnknownAudioCodec)
         continue;
       found_audio_stream = true;
     } else if (codec_type == AVMEDIA_TYPE_VIDEO) {
       if (found_video_stream)
         continue;
       // Ensure the codec is supported.
       if (CodecIDToVideoCodec(codec_context->codec_id) == kUnknownVideoCodec)
         continue;
       found_video_stream = true;
     } else {
       continue;
     }
 
-    AVStream* stream = format_context_->streams[i];
+    AVStream* stream = format_context->streams[i];
     scoped_refptr<FFmpegDemuxerStream> demuxer_stream(
         new FFmpegDemuxerStream(this, stream));
 
     streams_[i] = demuxer_stream;
     max_duration = std::max(max_duration, demuxer_stream->duration());
 
     if (stream->first_dts != static_cast<int64_t>(AV_NOPTS_VALUE)) {
       const base::TimeDelta first_dts = ConvertFromTimeBase(
           stream->time_base, stream->first_dts);
       if (start_time_ == kNoTimestamp() || first_dts < start_time_)
         start_time_ = first_dts;
     }
   }
 
   if (!found_audio_stream && !found_video_stream) {
     status_cb.Run(DEMUXER_ERROR_NO_SUPPORTED_STREAMS);
     return;
   }
 
-  if (format_context_->duration != static_cast<int64_t>(AV_NOPTS_VALUE)) {
+  if (format_context->duration != static_cast<int64_t>(AV_NOPTS_VALUE)) {
     // If there is a duration value in the container use that to find the
     // maximum between it and the duration from A/V streams.
     const AVRational av_time_base = {1, AV_TIME_BASE};
     max_duration =
         std::max(max_duration,
-                 ConvertFromTimeBase(av_time_base, format_context_->duration));
+                 ConvertFromTimeBase(av_time_base, format_context->duration));
   } else {
     // The duration is unknown, in which case this is likely a live stream.
     max_duration = kInfiniteDuration();
   }
 
   // Some demuxers, like WAV, do not put timestamps on their frames. We
   // assume the the start time is 0.
   if (start_time_ == kNoTimestamp())
     start_time_ = base::TimeDelta();
 
   // Good to go: set the duration and bitrate and notify we're done
   // initializing.
   host_->SetDuration(max_duration);
   duration_known_ = (max_duration != kInfiniteDuration());
 
   int64 filesize_in_bytes = 0;
   GetSize(&filesize_in_bytes);
-  bitrate_ = CalculateBitrate(format_context_, max_duration, filesize_in_bytes);
+  bitrate_ = CalculateBitrate(format_context, max_duration, filesize_in_bytes);
   if (bitrate_ > 0)
     data_source_->SetBitrate(bitrate_);
 
   status_cb.Run(PIPELINE_OK);
 }
 
 void FFmpegDemuxer::SeekTask(base::TimeDelta time, const PipelineStatusCB& cb) {
   DCHECK(message_loop_->BelongsToCurrentThread());
 
   // Tell streams to flush buffers due to seeking.
   StreamVector::iterator iter;
   for (iter = streams_.begin(); iter != streams_.end(); ++iter) {
     if (*iter)
       (*iter)->FlushBuffers();
   }
 
   // Always seek to a timestamp less than or equal to the desired timestamp.
   int flags = AVSEEK_FLAG_BACKWARD;
 
   // Passing -1 as our stream index lets FFmpeg pick a default stream.  FFmpeg
   // will attempt to use the lowest-index video stream, if present, followed by
   // the lowest-index audio stream.
-  if (av_seek_frame(format_context_, -1, time.InMicroseconds(), flags) < 0) {
+  if (av_seek_frame(glue_->format_context(), -1, time.InMicroseconds(),
+                    flags) < 0) {
     // Use VLOG(1) instead of NOTIMPLEMENTED() to prevent the message being
     // captured from stdout and contaminates testing.
     // TODO(scherkus): Implement this properly and signal error (BUG=23447).
     VLOG(1) << "Not implemented";
   }
 
   // Notify we're finished seeking.
   cb.Run(PIPELINE_OK);
 }
 
 void FFmpegDemuxer::DemuxTask() {
   DCHECK(message_loop_->BelongsToCurrentThread());
 
   // Make sure we have work to do before demuxing.
   if (!StreamsHavePendingReads()) {
     return;
   }
 
   // Allocate and read an AVPacket from the media.
   scoped_ptr_malloc<AVPacket, ScopedPtrAVFreePacket> packet(new AVPacket());
-  int result = av_read_frame(format_context_, packet.get());
+  int result = av_read_frame(glue_->format_context(), packet.get());
   if (result < 0) {
     // Update the duration based on the audio stream if
     // it was previously unknown http://crbug.com/86830
     if (!duration_known_) {
       // Search streams for AUDIO one.
       for (StreamVector::iterator iter = streams_.begin();
            iter != streams_.end();
            ++iter) {
         if (*iter && (*iter)->type() == DemuxerStream::AUDIO) {
           base::TimeDelta duration = (*iter)->GetElapsedTime();
@@ skipping 107 matching lines @@
   } else if (audio) {
     buffered = audio->GetBufferedRanges();
   } else if (video) {
     buffered = video->GetBufferedRanges();
   }
   for (size_t i = 0; i < buffered.size(); ++i)
     host_->AddBufferedTimeRange(buffered.start(i), buffered.end(i));
 }
 
 }  // namespace media