Merge 143765 - Ensure media's buffered ranges always have a range that includes currentTime.

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"
@@ skipping 12 matching lines @@
 #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 {
 
 //
 // FFmpegDemuxerStream
 //
-FFmpegDemuxerStream::FFmpegDemuxerStream(FFmpegDemuxer* demuxer,
-                                         AVStream* stream)
+FFmpegDemuxerStream::FFmpegDemuxerStream(
+    FFmpegDemuxer* demuxer,
+    AVStream* stream)
     : demuxer_(demuxer),
       stream_(stream),
       type_(UNKNOWN),
       discontinuous_(false),
-      stopped_(false) {
+      stopped_(false),
+      last_packet_timestamp_(kNoTimestamp()) {
   DCHECK(demuxer_);
 
   // Determine our media format.
   switch (stream->codec->codec_type) {
     case AVMEDIA_TYPE_AUDIO:
       type_ = AUDIO;
       AVCodecContextToAudioDecoderConfig(stream->codec, &audio_config_);
       break;
     case AVMEDIA_TYPE_VIDEO:
       type_ = VIDEO;
@@ skipping 37 matching lines @@
     }
 
     // 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.
     buffer = DecoderBuffer::CopyFrom(packet->data, packet->size);
     buffer->SetTimestamp(ConvertStreamTimestamp(
         stream_->time_base, packet->pts));
     buffer->SetDuration(ConvertStreamTimestamp(
         stream_->time_base, packet->duration));
+    if (buffer->GetTimestamp() != kNoTimestamp() &&
+        last_packet_timestamp_ != kNoTimestamp() &&
+        last_packet_timestamp_ < buffer->GetTimestamp()) {
+      buffered_ranges_.Add(last_packet_timestamp_, buffer->GetTimestamp());
+      demuxer_->message_loop()->PostTask(FROM_HERE, base::Bind(
+          &FFmpegDemuxer::NotifyBufferingChanged, demuxer_));
+    }
+    last_packet_timestamp_ = buffer->GetTimestamp();
   }
 
   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();
+  last_packet_timestamp_ = kNoTimestamp();
 }
 
 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<DecoderBuffer>(DecoderBuffer::CreateEOSBuffer()));
   }
@@ skipping 109 matching lines @@
   base::AutoLock auto_lock(lock_);
   DCHECK(stopped_);
   DCHECK(read_queue_.empty());
   DCHECK(buffer_queue_.empty());
 }
 
 base::TimeDelta FFmpegDemuxerStream::GetElapsedTime() const {
   return ConvertStreamTimestamp(stream_->time_base, stream_->cur_dts);
 }
 
+Ranges<base::TimeDelta> FFmpegDemuxerStream::GetBufferedRanges() {
+  base::AutoLock auto_lock(lock_);
+  return buffered_ranges_;
+}
+
 // static
 base::TimeDelta FFmpegDemuxerStream::ConvertStreamTimestamp(
     const AVRational& time_base, int64 timestamp) {
   if (timestamp == static_cast<int64>(AV_NOPTS_VALUE))
     return kNoTimestamp();
 
   return ConvertFromTimeBase(time_base, timestamp);
 }
 
 //
@@ skipping 452 matching lines @@
 int FFmpegDemuxer::WaitForRead() {
   read_event_.Wait();
   return last_read_bytes_;
 }
 
 void FFmpegDemuxer::SignalReadCompleted(int size) {
   last_read_bytes_ = size;
   read_event_.Signal();
 }
 
+void FFmpegDemuxer::NotifyBufferingChanged() {
+  DCHECK_EQ(MessageLoop::current(), message_loop_);
+  Ranges<base::TimeDelta> buffered;
+  scoped_refptr<DemuxerStream> audio =
+      audio_disabled_ ? NULL : GetStream(DemuxerStream::AUDIO);
+  scoped_refptr<DemuxerStream> video = GetStream(DemuxerStream::VIDEO);
+  if (audio && video) {
+    buffered = audio->GetBufferedRanges().IntersectionWith(
+        video->GetBufferedRanges());
+  } else if (audio) {
+    buffered = audio->GetBufferedRanges();
+  } else if (video) {
+    buffered = video->GetBufferedRanges();
+  }
+  for (size_t i = 0; i < buffered.size(); ++i)
+    host_->AddBufferedTimeRange(buffered.start(i), buffered.end(i));
+}
+
 }  // namespace media