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) {
   DCHECK(demuxer_);
 
   // Determine our media format.
   switch (stream->codec->codec_type) {
     case AVMEDIA_TYPE_AUDIO:
       type_ = AUDIO;
@@ skipping 39 matching lines @@
         !bitstream_converter_->ConvertPacket(packet.get())) {
       LOG(ERROR) << "Format converstion failed.";
     }
 
     // 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));
+    buffer->SetDuration(std::max(
+        base::TimeDelta(), ConvertStreamTimestamp(

[scherkus (not reviewing), 2012/06/21 21:57:04]

this means duration can no longer be kNoTimestamp() -- we shouldn't change that
behaviour as a 0 duration implies that the duration is known to be 0 as opposed
to being unknown (i.e,. requires decoding the audio buffer to get the true
duration)

[Ami GONE FROM CHROMIUM, 2012/06/21 22:49:02]

That's interesting that you say that.
What would you say if I told you I saw negative durations come out of ffmpeg?
Because I would totally tell you this.
(triggered the DCHECK_LT(start, end) in Ranges::Add(start,end) in DRT /
layouttests)

Where do you think we use this kNoTimestamp?

[scherkus (not reviewing), 2012/06/21 22:58:22]

How negative were these durations? Were they −9,223,372,036,854,775,808 or
something else?

I know FFAD::IsTimestampMarkerPacket() checks for it but that's about it

[Ami GONE FROM CHROMIUM, 2012/06/21 23:18:11]

They were between 0 and -1.
Hmm.
ok, dropping.

+            stream_->time_base, packet->duration)));
+    if (last_packet_timestamp_ > base::TimeDelta() &&

[scherkus (not reviewing), 2012/06/21 21:57:04]

timestamps can be negative -- do you mean to check for kNoTimestamp()?

[Ami GONE FROM CHROMIUM, 2012/06/21 22:49:02]

No, I meant to check for TimeDelta() (to detect a flush as a proxy for a seek). 
Done.

[scherkus (not reviewing), 2012/06/21 22:58:22]

Why not use kNoTS() to detect a flush isntead of zero (which is a valid
timestamp)?

[Ami GONE FROM CHROMIUM, 2012/06/21 23:18:11]

Done.

+        last_packet_timestamp_ < buffer->GetTimestamp()) {
+      DCHECK(buffer->GetDuration() >= base::TimeDelta())

[scherkus (not reviewing), 2012/06/21 21:57:04]

ditto around here

[Ami GONE FROM CHROMIUM, 2012/06/21 22:49:02]

This is leftover from debugging the aforementioned DRT crashes.  Gone.

+          << buffer->GetDuration().ToInternalValue();
+      notify_buffered_cb_.Run(last_packet_timestamp_,
+                              buffer->GetTimestamp() + buffer->GetDuration());
+    }
+    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_ = base::TimeDelta();

[scherkus (not reviewing), 2012/06/21 21:57:04]

kNoTS() here + ctor initializer list?

 }
 
 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 381 matching lines @@
       // 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(&DemuxerHost::AddBufferedTimeRange,
+                       base::Unretained(host_)),
+            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 110 matching lines @@
   DCHECK_GE(packet->stream_index, 0);
   DCHECK_LT(packet->stream_index, static_cast<int>(streams_.size()));
 
   // Defend against ffmpeg giving us a bad stream index.
   if (packet->stream_index >= 0 &&
       packet->stream_index < static_cast<int>(streams_.size()) &&
       streams_[packet->stream_index] &&
       (!audio_disabled_ ||
        streams_[packet->stream_index]->type() != DemuxerStream::AUDIO)) {
     FFmpegDemuxerStream* demuxer_stream = streams_[packet->stream_index];
+
     demuxer_stream->EnqueuePacket(packet.Pass());
   }
 
   // Create a loop by posting another task.  This allows seek and message loop
   // quit tasks to get processed.
   if (StreamsHavePendingReads()) {
     PostDemuxTask();
   }
 }
 
@@ skipping 50 matching lines @@
   read_event_.Wait();
   return last_read_bytes_;
 }
 
 void FFmpegDemuxer::SignalReadCompleted(int size) {
   last_read_bytes_ = size;
   read_event_.Signal();
 }
 
 }  // namespace media