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)
-    : demuxer_(demuxer),
+FFmpegDemuxerStream::FFmpegDemuxerStream(
+    const NotifyBufferedCB& notify_buffered_cb,
+    FFmpegDemuxer* demuxer,
+    AVStream* stream)
+    : notify_buffered_cb_(notify_buffered_cb),
+      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 (last_packet_timestamp_ != kNoTimestamp() &&
+        last_packet_timestamp_ < buffer->GetTimestamp()) {
+      notify_buffered_cb_.Run(last_packet_timestamp_, buffer->GetTimestamp());
+    }
+    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 353 matching lines @@
 
   // Fully initialize AVFormatContext by parsing the stream a little.
   result = avformat_find_stream_info(format_context_, NULL);
   if (result < 0) {
     status_cb.Run(DEMUXER_ERROR_COULD_NOT_PARSE);
     return;
   }
 
   // Create demuxer stream entries for each possible AVStream.
   streams_.resize(format_context_->nb_streams);
+  buffered_times_.resize(streams_.size());
   bool found_audio_stream = false;
   bool found_video_stream = false;
 
   base::TimeDelta max_duration;
   for (size_t i = 0; i < format_context_->nb_streams; ++i) {
     AVCodecContext* codec_context = format_context_->streams[i]->codec;
     AVMediaType codec_type = codec_context->codec_type;
 
     if (codec_type == AVMEDIA_TYPE_AUDIO) {
       if (found_audio_stream)
         continue;
       // Ensure the codec is supported.
       if (CodecIDToAudioCodec(codec_context->codec_id) == kUnknownAudioCodec)
         continue;
       found_audio_stream = true;
     } else if (codec_type == AVMEDIA_TYPE_VIDEO) {
       if (found_video_stream)
         continue;
       // Ensure the codec is supported.
       if (CodecIDToVideoCodec(codec_context->codec_id) == kUnknownVideoCodec)
         continue;
       found_video_stream = true;
     } else {
       continue;
     }
 
     AVStream* stream = format_context_->streams[i];
     scoped_refptr<FFmpegDemuxerStream> demuxer_stream(
-        new FFmpegDemuxerStream(this, stream));
+        new FFmpegDemuxerStream(
+            base::Bind(&FFmpegDemuxer::NotifyBufferedRange, this, i),
+            this, stream));
 
     streams_[i] = demuxer_stream;
     max_duration = std::max(max_duration, demuxer_stream->duration());
 
     if (stream->first_dts != static_cast<int64_t>(AV_NOPTS_VALUE)) {
       const base::TimeDelta first_dts = ConvertFromTimeBase(
           stream->time_base, stream->first_dts);
       if (start_time_ == kNoTimestamp() || first_dts < start_time_)
         start_time_ = first_dts;
     }
@@ skipping 179 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::NotifyBufferedRange(
+    int stream_id, base::TimeDelta start, base::TimeDelta end) {
+  buffered_times_[stream_id].Add(start, end);

[scherkus (not reviewing), 2012/06/22 06:13:51]

I think each FDS stream should hold onto its own range + provide a public
accessor. Then this CB would be a simple notification and instead of iterating
over streams_ or buffered_times_ would do the intersection of non-NULL calls to
GetStream(AUDIO) and GetStream(VIDEO) (or roll your own for loop that plucks out
the appropriate FDS objects)

There's a bug here with multitrack files as unused streams will always have
buffered_times_ entries that are always empty/zero (i.e., the 0th track might be
a subtitles track!)

[Ami GONE FROM CHROMIUM, 2012/06/22 17:15:32]

Done.

+
+  Ranges<base::TimeDelta> buffered = buffered_times_[0];
+  for (size_t i = 1; i < streams_.size(); ++i)
+    buffered = buffered.IntersectionWith(buffered_times_[i]);
+  for (size_t i = 0; i < buffered.size(); ++i)
+    host_->AddBufferedTimeRange(buffered.start(i), buffered.end(i));
+}
+
 }  // namespace media