Improving WebM video duration estimation.

media/formats/webm/webm_cluster_parser.h

 // Copyright 2014 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.
 
 #ifndef MEDIA_FORMATS_WEBM_WEBM_CLUSTER_PARSER_H_
 #define MEDIA_FORMATS_WEBM_WEBM_CLUSTER_PARSER_H_
 
 #include <deque>
 #include <map>
 #include <set>
@@ skipping 13 matching lines @@
 class MEDIA_EXPORT WebMClusterParser : public WebMParserClient {
  public:
   typedef StreamParser::TrackId TrackId;
   typedef std::deque<scoped_refptr<StreamParserBuffer> > BufferQueue;
   typedef std::map<TrackId, const BufferQueue> TextBufferQueueMap;
 
   // Arbitrarily-chosen numbers to estimate the duration of a buffer if none is
   // set and there is not enough information to get a better estimate.
   enum {
     kDefaultAudioBufferDurationInMs = 23,  // Common 1k samples @44.1kHz
-    kDefaultVideoBufferDurationInMs = 42  // Low 24fps to reduce stalls
+    kDefaultVideoBufferDurationInMs = 63   // Low 16fps to reduce stalls

[wolenetz, 2015/03/28 00:26:06]

nit: comment here (and elaborate in CL description) that, in combination with
compliant coded frame processing discontinuity detection logic, this mitigates
videos with framerates as low as 8fps (max 0.125ms timestamp delta) causing gaps
when this estimate is used (though not in all cases, like varying frame-rate
streams, since we might have already determined a lesser estimate from previous
frames).

[chcunningham, 2015/04/13 23:25:18]

Done.

   };
 
   // Opus packets encode the duration and other parameters in the 5 most
   // significant bits of the first byte. The index in this array corresponds
   // to the duration of each frame of the packet in microseconds. See
   // https://tools.ietf.org/html/rfc6716#page-14
   static const uint16_t kOpusFrameDurationsMu[];
 
  private:
   // Helper class that manages per-track state.
@@ skipping 20 matching lines @@
     const BufferQueue& ready_buffers() const { return ready_buffers_; }
 
     // If |last_added_buffer_missing_duration_| is set, updates its duration
     // relative to |buffer|'s timestamp, and adds it to |buffers_| and unsets
     // |last_added_buffer_missing_duration_|. Then, if |buffer| is missing
     // duration, saves |buffer| into |last_added_buffer_missing_duration_|, or
     // otherwise adds |buffer| to |buffers_|.
     bool AddBuffer(const scoped_refptr<StreamParserBuffer>& buffer);
 
     // If |last_added_buffer_missing_duration_| is set, updates its duration to
-    // be non-kNoTimestamp() value of |estimated_next_frame_duration_| or an
-    // arbitrary default, then adds it to |buffers_| and unsets
+    // be non-kNoTimestamp() value of |estimated_next_frame_duration_| or a
+    // hard-coded default, then adds it to |buffers_| and unsets
     // |last_added_buffer_missing_duration_|. (This method helps stream parser
     // emit all buffers in a media segment before signaling end of segment.)
     void ApplyDurationEstimateIfNeeded();
 
     // Clears |ready_buffers_| (use ExtractReadyBuffers() to fill it again).
     // Leaves as-is |buffers_| and any possibly held-aside buffer that is
     // missing duration.
     void ClearReadyBuffers();
 
     // Clears all buffer state, including any possibly held-aside buffer that
@@ skipping 13 matching lines @@
     // Helper that sanity-checks |buffer| duration, updates
     // |estimated_next_frame_duration_|, and adds |buffer| to |buffers_|.
     // Returns false if |buffer| failed sanity check and therefore was not added
     // to |buffers_|. Returns true otherwise.
     bool QueueBuffer(const scoped_refptr<StreamParserBuffer>& buffer);
 
     // Helper that calculates the buffer duration to use in
     // ApplyDurationEstimateIfNeeded().
     base::TimeDelta GetDurationEstimate();
 
+    // Counts the number of estimated durations used in this track. Used to
+    // prevent log spam for MEDIA_LOG()s about estimated duration.
+    int num_duration_estimates_;
+
     int track_num_;
     bool is_video_;
 
     // Parsed track buffers, each with duration and in (decode) timestamp order,
     // that have not yet been extracted into |ready_buffers_|. Note that up to
     // one additional buffer missing duration may be tracked by
     // |last_added_buffer_missing_duration_|.
     BufferQueue buffers_;
     scoped_refptr<StreamParserBuffer> last_added_buffer_missing_duration_;
 
     // Buffers in (decode) timestamp order that were previously parsed into and
     // extracted from |buffers_|. Buffers are moved from |buffers_| to
     // |ready_buffers_| by ExtractReadyBuffers() if they are below a specified
     // upper bound timestamp. Track users can therefore extract only those
     // parsed buffers which are "ready" for emission (all before some maximum
     // timestamp).
     BufferQueue ready_buffers_;
 
     // If kNoTimestamp(), then |estimated_next_frame_duration_| will be used.
     base::TimeDelta default_duration_;
 
     // If kNoTimestamp(), then a default value will be used. This estimate is
-    // the maximum duration seen or derived so far for this track, and is valid
-    // only if |default_duration_| is kNoTimestamp().
+    // the maximum (for video), or minimum (for audio) duration seen so far for
+    // this track, and is used only if |default_duration_| is kNoTimestamp().
+    // TODO(chcunningham): Use maximum for audio too, adding checks to disable
+    // splicing when these estimates are observed in SourceBufferStream.
     base::TimeDelta estimated_next_frame_duration_;
 
     LogCB log_cb_;
   };
 
   typedef std::map<int, Track> TextTrackMap;
 
  public:
   WebMClusterParser(int64 timecode_scale,
                     int audio_track_num,
@@ skipping 162 matching lines @@
   DecodeTimestamp ready_buffer_upper_bound_;
 
   LogCB log_cb_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(WebMClusterParser);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_FORMATS_WEBM_WEBM_CLUSTER_PARSER_H_