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

media/filters/ffmpeg_demuxer.h

 // 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.
 
 // Implements the Demuxer interface using FFmpeg's libavformat.  At this time
 // will support demuxing any audio/video format thrown at it.  The streams
 // output mime types audio/x-ffmpeg and video/x-ffmpeg and include an integer
 // key FFmpegCodecID which contains the CodecID enumeration value.  The CodecIDs
 // can be used to create and initialize the corresponding FFmpeg decoder.
 //
@@ skipping 29 matching lines @@
 struct AVPacket;
 struct AVRational;
 struct AVStream;
 
 namespace media {
 
 class BitstreamConverter;
 class FFmpegDemuxer;
 class ScopedPtrAVFreePacket;
 
+typedef base::Callback<void(base::TimeDelta, base::TimeDelta)> NotifyBufferedCB;
+
 class FFmpegDemuxerStream : public DemuxerStream {
  public:
   // Keeps a copy of |demuxer| and initializes itself using information
   // inside |stream|.  Both parameters must outlive |this|.
-  FFmpegDemuxerStream(FFmpegDemuxer* demuxer, AVStream* stream);
+  FFmpegDemuxerStream(const NotifyBufferedCB& notify_buffered_cb_,

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

is this needed given FDS has a pointer to FD and calls methods on it? (mostly an
issue w/ mixing FDS-calling-into-FD conventions)

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

Yeah, I went back and forth on this.
FDS has an FD* but FD doesn't expose its host.  So to avoid this explicit
callback FD would have to increase its public API surface to either expose the
host or just expose this one method.  Given that that one method would have
exactly one caller, it seemed better to me to do it this way.
Do you feel strongly that it should go the other way?

[scherkus (not reviewing), 2012/06/21 23:18:42]

Ah! I hadn't noticed you were binding to DemuxerHost directly.

I think we're in a bit of a pickle here. 

Take a poorly muxed file w/ alternating 10 second chunks of audio and video
data. If we've demuxed the first 10 seconds of audio before getting to the first
second of video data we need to start playback -- what should we report?

1) Report [0,10] range (union of streams)
2) Report [0,1] range (intersection of streams)

Technically we should report (2) as seeking to time 9 would require fetching +
demuxing (1,9] of the video stream. ChunkDemuxer folks have implemented (2).

So -- perhaps FDS should call a method on FD and FD can crunch the intersection
+ report to host.

WDYT?

[Ami GONE FROM CHROMIUM, 2012/06/22 03:55:47]

Done % still using a CB since the stream doesn't know its own ID in the demuxer
and CB allows currying that in nicely.

+                      FFmpegDemuxer* demuxer, AVStream* stream);
 
   // Returns true is this stream has pending reads, false otherwise.
   //
   // Safe to call on any thread.
   bool HasPendingReads();
 
   // Enqueues the given AVPacket.  If |packet| is NULL an end of stream packet
   // is enqueued.
   void EnqueuePacket(scoped_ptr_malloc<AVPacket, ScopedPtrAVFreePacket> packet);
 
@@ skipping 35 matching lines @@
 
   // Attempts to fulfill a single pending read by dequeueing a buffer and read
   // callback pair and executing the callback. The calling function must
   // acquire |lock_| before calling this function.
   void FulfillPendingRead();
 
   // Converts an FFmpeg stream timestamp into a base::TimeDelta.
   static base::TimeDelta ConvertStreamTimestamp(const AVRational& time_base,
                                                 int64 timestamp);
 
+  NotifyBufferedCB notify_buffered_cb_;
   FFmpegDemuxer* demuxer_;
   AVStream* stream_;
   AudioDecoderConfig audio_config_;
   VideoDecoderConfig video_config_;
   Type type_;
   base::TimeDelta duration_;
   bool discontinuous_;
   bool stopped_;
+  base::TimeDelta last_packet_timestamp_;
 
   typedef std::deque<scoped_refptr<DecoderBuffer> > BufferQueue;
   BufferQueue buffer_queue_;
 
   typedef std::deque<ReadCB> ReadQueue;
   ReadQueue read_queue_;
 
   // Used to translate bitstream formats.
   scoped_ptr<BitstreamConverter> bitstream_converter_;
 
@@ skipping 127 matching lines @@
   // Set if we know duration of the audio stream. Used when processing end of
   // stream -- at this moment we definitely know duration.
   bool duration_known_;
 
   DISALLOW_COPY_AND_ASSIGN(FFmpegDemuxer);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_FILTERS_FFMPEG_DEMUXER_H_