Remove DemuxerStream::GetAVStream() once and for all.

media/filters/chunk_demuxer.cc

 // Copyright (c) 2011 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.
 
 // Implements a Demuxer that can switch among different data sources mid-stream.
 // Uses FFmpegDemuxer under the covers, so see the caveats at the top of
 // ffmpeg_demuxer.h.
 
 #include "media/filters/chunk_demuxer.h"
 
@@ skipping 13 matching lines @@
 
 namespace media {
 
 // 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.
 //
 // TODO(acolwell): Remove this once GetAVStream() has been removed from
 // the DemuxerStream interface.
+//   ^^^^^^^^^^^ IS THIS STILL NEEDED? ^^^^^^^^^^^^

[acolwell GONE FROM CHROMIUM, 2011/10/26 17:09:13]

For now yes since we still need an AVStream to construct the VideoDecoderConfig.
In a separate CL I'll probably be able to extract the frame rate & aspect info
from the WebM headers.

Perhaps the comment should be changed to indicate this can be removed when we
are able to create AudioDecoderConfig & VideoDecoderConfigs w/o needing an
AVStream.

[scherkus (not reviewing), 2011/10/26 19:08:00]

Done.

 static const uint8 kWebMHeader[] = {
   0x1A, 0x45, 0xDF, 0xA3, 0x9F,  // EBML (size = 0x1f)
   0x42, 0x86, 0x81, 0x01,  // EBMLVersion = 1
   0x42, 0xF7, 0x81, 0x01,  // EBMLReadVersion = 1
   0x42, 0xF2, 0x81, 0x04,  // EBMLMaxIDLength = 4
   0x42, 0xF3, 0x81, 0x08,  // EBMLMaxSizeLength = 8
   0x42, 0x82, 0x84, 0x77, 0x65, 0x62, 0x6D,  // DocType = "webm"
   0x42, 0x87, 0x81, 0x02,  // DocTypeVersion = 2
   0x42, 0x85, 0x81, 0x02,  // DocTypeReadVersion = 2
   // EBML end
@@ skipping 28 matching lines @@
 
   void AddBuffers(const BufferQueue& buffers);
   void Shutdown();
 
   bool GetLastBufferTimestamp(base::TimeDelta* timestamp) const;
 
   // DemuxerStream methods.
   virtual void Read(const ReadCallback& read_callback);
   virtual Type type();
   virtual void EnableBitstreamConverter();
-  virtual AVStream* GetAVStream();
   virtual const AudioDecoderConfig& audio_decoder_config();
+  virtual const VideoDecoderConfig& video_decoder_config();
 
  private:
   Type type_;
   AVStream* av_stream_;
   AudioDecoderConfig audio_config_;
+  VideoDecoderConfig video_config_;
 
   mutable base::Lock lock_;
   ReadCBQueue read_cbs_;
   BufferQueue buffers_;
   bool shutdown_called_;
   bool received_end_of_stream_;
 
   // Keeps track of the timestamp of the last buffer we have
   // added to |buffers_|. This is used to enforce buffers with strictly
   // monotonically increasing timestamps.
   base::TimeDelta last_buffer_timestamp_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(ChunkDemuxerStream);
 };
 
 ChunkDemuxerStream::ChunkDemuxerStream(Type type, AVStream* stream)
     : type_(type),
       av_stream_(stream),
       shutdown_called_(false),
       received_end_of_stream_(false),
       last_buffer_timestamp_(kNoTimestamp) {
   if (type_ == AUDIO) {
     AVCodecContextToAudioDecoderConfig(stream->codec, &audio_config_);
+  } else if (type_ == VIDEO) {
+    AVCodecContextToVideoDecoderConfig(stream->codec,
+                                       stream->r_frame_rate,
+                                       GetAspectRatio(stream),
+                                       &video_config_);
   }
 }
 
 ChunkDemuxerStream::~ChunkDemuxerStream() {}
 
 void ChunkDemuxerStream::Flush() {
   VLOG(1) << "Flush()";
   base::AutoLock auto_lock(lock_);
   buffers_.clear();
   received_end_of_stream_ = false;
@@ skipping 142 matching lines @@
   }
 
   DCHECK(buffer.get());
   read_callback.Run(buffer);
 }
 
 DemuxerStream::Type ChunkDemuxerStream::type() { return type_; }
 
 void ChunkDemuxerStream::EnableBitstreamConverter() {}
 
-AVStream* ChunkDemuxerStream::GetAVStream() { return av_stream_; }
-
 const AudioDecoderConfig& ChunkDemuxerStream::audio_decoder_config() {
   CHECK_EQ(type_, AUDIO);
   return audio_config_;
 }
 
+const VideoDecoderConfig& ChunkDemuxerStream::video_decoder_config() {
+  CHECK_EQ(type_, VIDEO);
+  return video_config_;
+}
+
 ChunkDemuxer::ChunkDemuxer(ChunkDemuxerClient* client)
     : state_(WAITING_FOR_INIT),
       client_(client),
       format_context_(NULL),
       buffered_bytes_(0),
       seek_waits_for_data_(true) {
   DCHECK(client);
 }
 
 ChunkDemuxer::~ChunkDemuxer() {
@@ skipping 440 matching lines @@
     base::AutoUnlock auto_unlock(lock_);
     if (cb.is_null()) {
       host()->SetError(error);
       return;
     }
     cb.Run(error);
   }
 }
 
 }  // namespace media