Introducing DecoderBuffer and general Buffer cleanup.

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"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/stl_util.h"
 #include "base/string_util.h"
 #include "base/time.h"
 #include "media/base/audio_decoder_config.h"
-#include "media/base/data_buffer.h"
+#include "media/base/decoder_buffer.h"
 #include "media/base/limits.h"
 #include "media/base/media_switches.h"
 #include "media/base/video_decoder_config.h"
 #include "media/ffmpeg/ffmpeg_common.h"
 #include "media/filters/bitstream_converter.h"
 #include "media/filters/ffmpeg_glue.h"
 #include "media/filters/ffmpeg_h264_bitstream_converter.h"
 
 namespace media {
 
 //
-// AVPacketBuffer
-//
-class AVPacketBuffer : public Buffer {
- public:
-  AVPacketBuffer(scoped_ptr_malloc<AVPacket, ScopedPtrAVFreePacket> packet,
-                 const base::TimeDelta& timestamp,
-                 const base::TimeDelta& duration)
-      : Buffer(timestamp, duration),
-        packet_(packet.Pass()) {
-  }
-
-  // Buffer implementation.
-  virtual const uint8* GetData() const {
-    return reinterpret_cast<const uint8*>(packet_->data);
-  }
-
-  virtual int GetDataSize() const {
-    return packet_->size;
-  }
-
- protected:
-  virtual ~AVPacketBuffer() {}
-
- private:
-  scoped_ptr_malloc<AVPacket, ScopedPtrAVFreePacket> packet_;
-
-  DISALLOW_COPY_AND_ASSIGN(AVPacketBuffer);
-};
-
-
-//
 // FFmpegDemuxerStream
 //
 FFmpegDemuxerStream::FFmpegDemuxerStream(FFmpegDemuxer* demuxer,
                                          AVStream* stream)
     : demuxer_(demuxer),
       stream_(stream),
       type_(UNKNOWN),
       discontinuous_(false),
       stopped_(false) {
   DCHECK(demuxer_);
@@ skipping 21 matching lines @@
   DCHECK_EQ(MessageLoop::current(), demuxer_->message_loop());
   base::AutoLock auto_lock(lock_);
   DCHECK(!stopped_ || read_queue_.empty())
       << "Read queue should have been emptied if demuxing stream is stopped";
   return !read_queue_.empty();
 }
 
 void FFmpegDemuxerStream::EnqueuePacket(
     scoped_ptr_malloc<AVPacket, ScopedPtrAVFreePacket> packet) {
   DCHECK_EQ(MessageLoop::current(), demuxer_->message_loop());
-  base::TimeDelta timestamp =
-      ConvertStreamTimestamp(stream_->time_base, packet->pts);
-  base::TimeDelta duration =
-      ConvertStreamTimestamp(stream_->time_base, packet->duration);
 
   base::AutoLock auto_lock(lock_);
   if (stopped_) {
     NOTREACHED() << "Attempted to enqueue packet on a stopped stream";
     return;
   }
 
   // Convert if the packet if there is bitstream filter.
   if (packet->data && bitstream_converter_.get() &&
       !bitstream_converter_->ConvertPacket(packet.get())) {
     LOG(ERROR) << "Format converstion failed.";
   }
 
-  // Enqueue the callback and attempt to satisfy a read immediately.
-  scoped_refptr<Buffer> buffer(
-      new AVPacketBuffer(packet.Pass(), timestamp, duration));
-  if (!buffer) {
-    NOTREACHED() << "Unable to allocate AVPacketBuffer";
-    return;
-  }
+  // If a packet is returned by FFmpeg's av_parser_parse2() the packet will
+  // reference inner memory of FFmpeg.  As such we should transfer the packet
+  // into memory we control.
+  scoped_refptr<DecoderBuffer> buffer = DecoderBuffer::CopyFrom(
+      packet->data, packet->size);
+  buffer->SetTimestamp(ConvertStreamTimestamp(stream_->time_base, packet->pts));
+  buffer->SetDuration(ConvertStreamTimestamp(
+      stream_->time_base, packet->duration));
   buffer_queue_.push_back(buffer);
   FulfillPendingRead();
   return;
 }
 
 void FFmpegDemuxerStream::FlushBuffers() {
   DCHECK_EQ(MessageLoop::current(), demuxer_->message_loop());
   base::AutoLock auto_lock(lock_);
   DCHECK(read_queue_.empty()) << "Read requests should be empty";
   buffer_queue_.clear();
 }
 
 void FFmpegDemuxerStream::Stop() {
   DCHECK_EQ(MessageLoop::current(), demuxer_->message_loop());
   base::AutoLock auto_lock(lock_);
   buffer_queue_.clear();
   for (ReadQueue::iterator it = read_queue_.begin();
        it != read_queue_.end(); ++it) {
-    it->Run(scoped_refptr<Buffer>(new DataBuffer(0)));
+    it->Run(scoped_refptr<DecoderBuffer>(DecoderBuffer::CreateEOSBuffer()));
   }
   read_queue_.clear();
   stopped_ = true;
 }
 
 base::TimeDelta FFmpegDemuxerStream::duration() {
   return duration_;
 }
 
 DemuxerStream::Type FFmpegDemuxerStream::type() {
   return type_;
 }
 
 void FFmpegDemuxerStream::Read(const ReadCB& read_cb) {
   DCHECK(!read_cb.is_null());
 
   base::AutoLock auto_lock(lock_);
   // Don't accept any additional reads if we've been told to stop.
   // The demuxer_ may have been destroyed in the pipleine thread.
   //
   // TODO(scherkus): it would be cleaner if we replied with an error message.
   if (stopped_) {
-    read_cb.Run(scoped_refptr<Buffer>(new DataBuffer(0)));
+    read_cb.Run(scoped_refptr<DecoderBuffer>(DecoderBuffer::CreateEOSBuffer()));
     return;
   }
 
   // Buffers are only queued when there are no pending reads.
   DCHECK(buffer_queue_.empty() || read_queue_.empty());
 
   if (buffer_queue_.empty()) {
     demuxer_->message_loop()->PostTask(FROM_HERE, base::Bind(
         &FFmpegDemuxerStream::ReadTask, this, read_cb));
     return;
   }
 
   // Send the oldest buffer back.
-  scoped_refptr<Buffer> buffer = buffer_queue_.front();
+  scoped_refptr<DecoderBuffer> buffer = buffer_queue_.front();
   buffer_queue_.pop_front();
   read_cb.Run(buffer);
 }
 
 void FFmpegDemuxerStream::ReadTask(const ReadCB& read_cb) {
   DCHECK_EQ(MessageLoop::current(), demuxer_->message_loop());
 
   base::AutoLock auto_lock(lock_);
   // Don't accept any additional reads if we've been told to stop.
   //
   // TODO(scherkus): it would be cleaner if we replied with an error message.
   if (stopped_) {
-    read_cb.Run(scoped_refptr<Buffer>(new DataBuffer(0)));
+    read_cb.Run(scoped_refptr<DecoderBuffer>(DecoderBuffer::CreateEOSBuffer()));
     return;
   }
 
   // Enqueue the callback and attempt to satisfy it immediately.
   read_queue_.push_back(read_cb);
   FulfillPendingRead();
 
   // Check if there are still pending reads, demux some more.
   if (!read_queue_.empty()) {
     demuxer_->PostDemuxTask();
   }
 }
 
 void FFmpegDemuxerStream::FulfillPendingRead() {
   DCHECK_EQ(MessageLoop::current(), demuxer_->message_loop());
   lock_.AssertAcquired();
   if (buffer_queue_.empty() || read_queue_.empty()) {
     return;
   }
 
   // Dequeue a buffer and pending read pair.
-  scoped_refptr<Buffer> buffer = buffer_queue_.front();
+  scoped_refptr<DecoderBuffer> buffer = buffer_queue_.front();
   ReadCB read_cb(read_queue_.front());
   buffer_queue_.pop_front();
   read_queue_.pop_front();
 
   // Execute the callback.
   read_cb.Run(buffer);
 }
 
 void FFmpegDemuxerStream::EnableBitstreamConverter() {
   // Called by hardware decoder to require different bitstream converter.
   // Currently we assume that converter is determined by codec_id;
   DCHECK(stream_);
 
   if (stream_->codec->codec_id == CODEC_ID_H264) {
     // Use Chromium bitstream converter in case of H.264
     bitstream_converter_.reset(
         new FFmpegH264BitstreamConverter(stream_->codec));
     CHECK(bitstream_converter_->Initialize());
-    return;
-  }
-
-  const char* filter_name = NULL;
-  if (stream_->codec->codec_id == CODEC_ID_MPEG4) {
-    filter_name = "mpeg4video_es";
-  } else if (stream_->codec->codec_id == CODEC_ID_WMV3) {
-    filter_name = "vc1_asftorcv";
-  } else if (stream_->codec->codec_id == CODEC_ID_VC1) {
-    filter_name = "vc1_asftoannexg";
-  }
-
-  if (filter_name) {
+  } else if (stream_->codec->codec_id == CODEC_ID_MPEG4) {
     bitstream_converter_.reset(
-        new FFmpegBitstreamConverter(filter_name, stream_->codec));
+        new FFmpegBitstreamConverter("mpeg4video_es", stream_->codec));
     CHECK(bitstream_converter_->Initialize());
   }
 }
 
 const AudioDecoderConfig& FFmpegDemuxerStream::audio_decoder_config() {
   CHECK_EQ(type_, AUDIO);
   return audio_config_;
 }
 
 const VideoDecoderConfig& FFmpegDemuxerStream::video_decoder_config() {
@@ skipping 409 matching lines @@
   DCHECK_GE(packet->stream_index, 0);
   DCHECK_LT(packet->stream_index, static_cast<int>(streams_.size()));
 
   // Defend against ffmpeg giving us a bad stream index.
   if (packet->stream_index >= 0 &&
       packet->stream_index < static_cast<int>(streams_.size()) &&
       streams_[packet->stream_index] &&
       (!audio_disabled_ ||
        streams_[packet->stream_index]->type() != DemuxerStream::AUDIO)) {
     FFmpegDemuxerStream* demuxer_stream = streams_[packet->stream_index];
-
-    // If a packet is returned by FFmpeg's av_parser_parse2()
-    // the packet will reference an inner memory of FFmpeg.
-    // In this case, the packet's "destruct" member is NULL,
-    // and it MUST be duplicated. This fixes issue with MP3 and possibly
-    // other codecs.  It is safe to call this function even if the packet does
-    // not refer to inner memory from FFmpeg.
-    av_dup_packet(packet.get());
-
     demuxer_stream->EnqueuePacket(packet.Pass());
   }
 
   // Create a loop by posting another task.  This allows seek and message loop
   // quit tasks to get processed.
   if (StreamsHavePendingReads()) {
     PostDemuxTask();
   }
 }
 
@@ skipping 51 matching lines @@
   read_event_.Wait();
   return last_read_bytes_;
 }
 
 void FFmpegDemuxer::SignalReadCompleted(int size) {
   last_read_bytes_ = size;
   read_event_.Signal();
 }
 
 }  // namespace media