Ability for demuxer clients to get to FFmpeg's AVStream object exposed as an ...

media/filters/ffmpeg_demuxer.cc

 // Copyright (c) 2009 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 "base/scoped_ptr.h"
 #include "base/string_util.h"
 #include "base/time.h"
 #include "media/base/filter_host.h"
 #include "media/filters/ffmpeg_common.h"
 #include "media/filters/ffmpeg_demuxer.h"
@@ skipping 31 matching lines @@
   scoped_ptr<AVPacket> packet_;
 
   DISALLOW_COPY_AND_ASSIGN(AVPacketBuffer);
 };
 
 
 //
 // FFmpegDemuxerStream
 //
 FFmpegDemuxerStream::FFmpegDemuxerStream(FFmpegDemuxer* demuxer,
-                                         const AVStream& stream)
-    : demuxer_(demuxer) {
+                                         AVStream* stream)
+    : demuxer_(demuxer),
+      av_stream_(stream) {
   DCHECK(demuxer_);
 
   // Determine our media format.
-  switch (stream.codec->codec_type) {
+  switch (stream->codec->codec_type) {
     case CODEC_TYPE_AUDIO:
       media_format_.SetAsString(MediaFormat::kMimeType,
                                 mime_type::kFFmpegAudio);
       media_format_.SetAsInteger(MediaFormat::kChannels,
-                                 stream.codec->channels);
+                                 stream->codec->channels);
       media_format_.SetAsInteger(MediaFormat::kSampleRate,
-                                 stream.codec->sample_rate);
+                                 stream->codec->sample_rate);
       break;
     case CODEC_TYPE_VIDEO:
       media_format_.SetAsString(MediaFormat::kMimeType,
                                 mime_type::kFFmpegVideo);
       media_format_.SetAsInteger(MediaFormat::kHeight,
-                                 stream.codec->height);
+                                 stream->codec->height);
       media_format_.SetAsInteger(MediaFormat::kWidth,
-                                 stream.codec->width);
+                                 stream->codec->width);
       break;
     default:
       NOTREACHED();
       break;
   }
-  int codec_id = static_cast<int>(stream.codec->codec_id);
+  int codec_id = static_cast<int>(stream->codec->codec_id);
   media_format_.SetAsInteger(kFFmpegCodecID, codec_id);
 
   // Calculate the time base and duration in microseconds.
-  int64 time_base_us = static_cast<int64>(av_q2d(stream.time_base) *
+  int64 time_base_us = static_cast<int64>(av_q2d(stream->time_base) *
       base::Time::kMicrosecondsPerSecond);
-  int64 duration_us = static_cast<int64>(time_base_us * stream.duration);
+  int64 duration_us = static_cast<int64>(time_base_us * stream->duration);
   time_base_ = base::TimeDelta::FromMicroseconds(time_base_us);
   duration_ = base::TimeDelta::FromMicroseconds(duration_us);
 }
 
 FFmpegDemuxerStream::~FFmpegDemuxerStream() {
   // Since |input_queue_| and |output_queue_| use scoped_refptr everything
   // should get released.
 }
 
+// static
+const char* FFmpegDemuxerStream::interface_id() {
+  return interface_id::kFFmpegDemuxerStream;
+}
+
+void* FFmpegDemuxerStream::QueryInterface(const char* id) {
+  DCHECK(id);
+  FFmpegDemuxerStream* interface_ptr = NULL;
+  if (0 == strcmp(id, interface_id())) {
+    interface_ptr = this;
+  }
+  return interface_ptr;
+}
+
 bool FFmpegDemuxerStream::HasPendingReads() {
   AutoLock auto_lock(lock_);
   return !output_queue_.empty();
 }
 
 void FFmpegDemuxerStream::EnqueuePacket(AVPacket* packet) {
   base::TimeDelta timestamp = time_base_ * packet->pts;
   base::TimeDelta duration = time_base_ * packet->duration;
   Buffer* buffer = new AVPacketBuffer(packet, timestamp, duration);
   DCHECK(buffer);
@@ skipping 47 matching lines @@
 //
 FFmpegDemuxer::FFmpegDemuxer()
     : demuxing_(false),
       format_context_(NULL) {
 }
 
 FFmpegDemuxer::~FFmpegDemuxer() {
   if (format_context_) {
     av_free(format_context_);
   }
-  while (!streams_.empty()) {
-    delete streams_.back();
-    streams_.pop_back();
-  }
 }
 
 void FFmpegDemuxer::ScheduleDemux() {
   if (!demuxing_) {
     demuxing_ = true;
     host_->PostTask(NewRunnableMethod(this, &FFmpegDemuxer::Demux));
   }
 }
 
 void FFmpegDemuxer::Stop() {
@@ skipping 33 matching lines @@
     return false;
   }
 
   // Create demuxer streams for all supported streams.
   base::TimeDelta max_duration;
   for (size_t i = 0; i < format_context_->nb_streams; ++i) {
     CodecType codec_type = format_context_->streams[i]->codec->codec_type;
     if (codec_type == CODEC_TYPE_AUDIO || codec_type == CODEC_TYPE_VIDEO) {
       AVStream* stream = format_context_->streams[i];
       FFmpegDemuxerStream* demuxer_stream
-          = new FFmpegDemuxerStream(this, *stream);
+          = new FFmpegDemuxerStream(this, stream);
       DCHECK(demuxer_stream);
       streams_.push_back(demuxer_stream);
       max_duration = std::max(max_duration, demuxer_stream->duration());
     }
   }
   if (streams_.empty()) {
     host_->Error(DEMUXER_ERROR_NO_SUPPORTED_STREAMS);
     return false;
   }
 
   // We have at least one supported stream, set the duration and notify we're
   // done initializing.
   host_->SetDuration(max_duration);
   host_->InitializationComplete();
   return true;
 }
 
 size_t FFmpegDemuxer::GetNumberOfStreams() {
   return streams_.size();
 }
 
-DemuxerStream* FFmpegDemuxer::GetStream(int stream) {
+scoped_refptr<DemuxerStream> FFmpegDemuxer::GetStream(int stream) {
   DCHECK(stream >= 0);
   DCHECK(stream < static_cast<int>(streams_.size()));
-  return streams_[stream];
+  return streams_[stream].get();
 }
 
 void FFmpegDemuxer::Demux() {
   DCHECK(demuxing_);
 
   // Loop until we've satisfied every stream.
   while (StreamsHavePendingReads()) {
     // Allocate and read an AVPacket from the media.
     scoped_ptr<AVPacket> packet(new AVPacket());
     int result = av_read_frame(format_context_, packet.get());
@@ skipping 19 matching lines @@
   StreamVector::iterator iter;
   for (iter = streams_.begin(); iter != streams_.end(); ++iter) {
     if ((*iter)->HasPendingReads()) {
       return true;
     }
   }
   return false;
 }
 
 }  // namespace media