Refactor FFmpegVideoDecoder to try and generalize code common to all video decoders.

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/stl_util-inl.h"
 #include "base/string_util.h"
 #include "base/time.h"
 #include "media/base/filter_host.h"
+#include "media/ffmpeg/ffmpeg_util.h"
 #include "media/filters/ffmpeg_common.h"
 #include "media/filters/ffmpeg_demuxer.h"
 #include "media/filters/ffmpeg_glue.h"
 
 namespace media {
 
 //
 // AVPacketBuffer
 //
 class AVPacketBuffer : public Buffer {
@@ skipping 49 matching lines @@
                                 mime_type::kFFmpegVideo);
       media_format_.SetAsInteger(MediaFormat::kFFmpegCodecID,
                                  stream->codec->codec_id);
       break;
     default:
       NOTREACHED();
       break;
   }
 
   // Calculate the duration.
-  duration_ = ConvertTimestamp(stream->duration);
+  duration_ = ConvertStreamTimestamp(stream->time_base, stream->duration);
 }
 
 FFmpegDemuxerStream::~FFmpegDemuxerStream() {
   DCHECK(stopped_);
   DCHECK(read_queue_.empty());
   DCHECK(buffer_queue_.empty());
 }
 
 void* FFmpegDemuxerStream::QueryInterface(const char* id) {
   DCHECK(id);
   AVStreamProvider* interface_ptr = NULL;
   if (0 == strcmp(id, AVStreamProvider::interface_id())) {
     interface_ptr = this;
   }
   return interface_ptr;
 }
 
 bool FFmpegDemuxerStream::HasPendingReads() {
   DCHECK_EQ(MessageLoop::current(), demuxer_->message_loop());
   DCHECK(!stopped_ || read_queue_.empty())
       << "Read queue should have been emptied if demuxing stream is stopped";
   return !read_queue_.empty();
 }
 
 base::TimeDelta FFmpegDemuxerStream::EnqueuePacket(AVPacket* packet) {
   DCHECK_EQ(MessageLoop::current(), demuxer_->message_loop());
-  base::TimeDelta timestamp = ConvertTimestamp(packet->pts);
-  base::TimeDelta duration = ConvertTimestamp(packet->duration);
+  base::TimeDelta timestamp =
+      ConvertStreamTimestamp(stream_->time_base, packet->pts);
+  base::TimeDelta duration =
+      ConvertStreamTimestamp(stream_->time_base, packet->duration);
   if (stopped_) {
     NOTREACHED() << "Attempted to enqueue packet on a stopped stream";
     return timestamp;
   }
 
   // Enqueue the callback and attempt to satisfy a read immediately.
   scoped_refptr<Buffer> buffer =
       new AVPacketBuffer(packet, timestamp, duration);
   if (!buffer) {
     NOTREACHED() << "Unable to allocate AVPacketBuffer";
@@ skipping 66 matching lines @@
   // TODO(scherkus): get rid of |discontinuous_| and use buffer flags.
   if (discontinuous_) {
     buffer->SetDiscontinuous(true);
     discontinuous_ = false;
   }
 
   // Execute the callback.
   read_callback->Run(buffer);
 }
 
-base::TimeDelta FFmpegDemuxerStream::ConvertTimestamp(int64 timestamp) {
+// static
+base::TimeDelta FFmpegDemuxerStream::ConvertStreamTimestamp(
+    const AVRational& time_base, int64 timestamp) {
   if (timestamp == static_cast<int64>(AV_NOPTS_VALUE))
     return StreamSample::kInvalidTimestamp;
-  AVRational time_base = { 1, base::Time::kMicrosecondsPerSecond };
-  int64 microseconds = av_rescale_q(timestamp, stream_->time_base, time_base);
-  return base::TimeDelta::FromMicroseconds(microseconds);
+
+  return ConvertTimestamp(time_base, timestamp);
 }
 
 //
 // FFmpegDemuxer
 //
 FFmpegDemuxer::FFmpegDemuxer()
     : format_context_(NULL),
       read_event_(false, false),
       read_has_failed_(false),
       last_read_bytes_(0),
@@ skipping 350 matching lines @@
   read_event_.Wait();
   return last_read_bytes_;
 }
 
 void FFmpegDemuxer::SignalReadCompleted(size_t size) {
   last_read_bytes_ = size;
   read_event_.Signal();
 }
 
 }  // namespace media