Use av_rescale_q() for converting FFmpeg timestamps to base::TimeDelta.

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 33 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(AVPacketBuffer);
 };
 
 
 //
 // FFmpegDemuxerStream
 //
 FFmpegDemuxerStream::FFmpegDemuxerStream(FFmpegDemuxer* demuxer,
                                          AVStream* stream)
     : demuxer_(demuxer),
-      av_stream_(stream),
+      stream_(stream),
       discontinuous_(false) {
   DCHECK(demuxer_);
 
   // Determine our media format.
   switch (stream->codec->codec_type) {
     case CODEC_TYPE_AUDIO:
       media_format_.SetAsString(MediaFormat::kMimeType,
                                 mime_type::kFFmpegAudio);
       break;
     case CODEC_TYPE_VIDEO:
       media_format_.SetAsString(MediaFormat::kMimeType,
                                 mime_type::kFFmpegVideo);
       break;
     default:
       NOTREACHED();
       break;
   }
 
-  // Calculate the time base and duration in microseconds.
-  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);
-  time_base_ = base::TimeDelta::FromMicroseconds(time_base_us);
-  duration_ = base::TimeDelta::FromMicroseconds(duration_us);
+  // Calculate the duration.
+  duration_ = ConvertTimestamp(stream->duration);
 }
 
 FFmpegDemuxerStream::~FFmpegDemuxerStream() {
   // Since |buffer_queue_| uses scoped_refptr everything will get released.
   while (!read_queue_.empty()) {
     delete read_queue_.front();
     read_queue_.pop_front();
   }
 }
 
@@ skipping 10 matching lines @@
   }
   return interface_ptr;
 }
 
 bool FFmpegDemuxerStream::HasPendingReads() {
   AutoLock auto_lock(lock_);
   return !read_queue_.empty();
 }
 
 base::TimeDelta FFmpegDemuxerStream::EnqueuePacket(AVPacket* packet) {
-  base::TimeDelta timestamp = time_base_ * packet->pts;
-  base::TimeDelta duration = time_base_ * packet->duration;
+  base::TimeDelta timestamp = ConvertTimestamp(packet->pts);
+  base::TimeDelta duration = ConvertTimestamp(packet->duration);
   Buffer* buffer = new AVPacketBuffer(packet, timestamp, duration);
   DCHECK(buffer);
   {
     AutoLock auto_lock(lock_);
     buffer_queue_.push_back(buffer);
   }
   FulfillPendingReads();
   return timestamp;
 }
 
@@ skipping 38 matching lines @@
       if (discontinuous_) {
         buffer->SetDiscontinuous(true);
         discontinuous_ = false;
       }
     }
     read_callback->Run(buffer);
   }
   return pending_reads;
 }
 
+base::TimeDelta FFmpegDemuxerStream::ConvertTimestamp(int64 timestamp) {
+  AVRational time_base = { 1, base::Time::kMicrosecondsPerSecond };
+  int64 microseconds = av_rescale_q(timestamp, stream_->time_base, time_base);
+  return base::TimeDelta::FromMicroseconds(microseconds);
+}
+
 
 //
 // FFmpegDemuxer
 //
 FFmpegDemuxer::FFmpegDemuxer()
     : thread_("DemuxerThread") {
 }
 
 FFmpegDemuxer::~FFmpegDemuxer() {
   Stop();
@@ skipping 163 matching lines @@
   StreamVector::iterator iter;
   for (iter = streams_.begin(); iter != streams_.end(); ++iter) {
     if ((*iter)->HasPendingReads()) {
       return true;
     }
   }
   return false;
 }
 
 }  // namespace media