Fix corrupted audio and video at playback start in ogg containers.

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/base64.h"
@@ skipping 66 matching lines @@
   }
 
   // NOTE: Do not use AVStream->first_dts since |start_time| should be a
   // presentation timestamp.
   return start_time;
 }
 
 //
 // FFmpegDemuxerStream
 //
-FFmpegDemuxerStream::FFmpegDemuxerStream(
-    FFmpegDemuxer* demuxer,
-    AVStream* stream,
-    bool discard_negative_timestamps)
+FFmpegDemuxerStream::FFmpegDemuxerStream(FFmpegDemuxer* demuxer,
+                                         AVStream* stream)
     : demuxer_(demuxer),
       task_runner_(base::MessageLoopProxy::current()),
       stream_(stream),
       type_(UNKNOWN),
       end_of_stream_(false),
       last_packet_timestamp_(kNoTimestamp()),
       bitstream_converter_enabled_(false),
-      discard_negative_timestamps_(discard_negative_timestamps) {
+      fixup_negative_ogg_timestamps_(false) {
   DCHECK(demuxer_);
 
   bool is_encrypted = false;
 
   // Determine our media format.
   switch (stream->codec->codec_type) {
     case AVMEDIA_TYPE_AUDIO:
       type_ = AUDIO;
       AVStreamToAudioDecoderConfig(stream, &audio_config_, true);
       is_encrypted = audio_config_.is_encrypted();
@@ skipping 146 matching lines @@
   }
 
   buffer->set_duration(
       ConvertStreamTimestamp(stream_->time_base, packet->duration));
 
   // Note: If pts is AV_NOPTS_VALUE, stream_timestamp will be kNoTimestamp().
   const base::TimeDelta stream_timestamp =
       ConvertStreamTimestamp(stream_->time_base, packet->pts);
 
   if (stream_timestamp != kNoTimestamp()) {
-    buffer->set_timestamp(stream_timestamp - demuxer_->start_time());
+    // If this is an OGG file with negative timestamps don't rebase any other
+    // stream types against the negative starting time.
+    base::TimeDelta start_time = demuxer_->start_time();
+    if (fixup_negative_ogg_timestamps_ && type() != AUDIO &&
+        start_time < base::TimeDelta()) {
+      DCHECK(stream_timestamp >= base::TimeDelta());
+      start_time = base::TimeDelta();
+    }
+
+    buffer->set_timestamp(stream_timestamp - start_time);
 
     // If enabled, mark packets with negative timestamps for post-decode
     // discard.
-    if (discard_negative_timestamps_ && stream_timestamp < base::TimeDelta()) {
+    if (fixup_negative_ogg_timestamps_ &&
+        stream_timestamp < base::TimeDelta()) {
       if (stream_timestamp + buffer->duration() < base::TimeDelta()) {
         // Discard the entire packet if it's entirely before zero.
         buffer->set_discard_padding(
             std::make_pair(kInfiniteDuration(), base::TimeDelta()));
       } else {
         // Only discard part of the frame if it overlaps zero.
         buffer->set_discard_padding(
             std::make_pair(-stream_timestamp, base::TimeDelta()));
       }
     }
@@ skipping 215 matching lines @@
   DCHECK(task_runner_->BelongsToCurrentThread());
   CHECK(!pending_seek_);
 
   // TODO(scherkus): Inspect |pending_read_| and cancel IO via |blocking_url_|,
   // otherwise we can end up waiting for a pre-seek read to complete even though
   // we know we're going to drop it on the floor.
 
   // FFmpeg requires seeks to be adjusted according to the lowest starting time.
   const base::TimeDelta seek_time = time + start_time_;
 
-  // Choose the preferred stream if |seek_time| occurs after its starting time,
-  // otherwise use the fallback stream.
+  // Choose the seeking stream based on whether it contains the seek time, if no
+  // match can be found prefer the preferred stream.
   DCHECK(preferred_stream_for_seeking_.second != kNoTimestamp());
-  const int stream_index = seek_time >= preferred_stream_for_seeking_.second
-                               ? preferred_stream_for_seeking_.first
-                               : fallback_stream_for_seeking_.first;
+  const int stream_index =
+      seek_time < preferred_stream_for_seeking_.second &&
+              seek_time >= fallback_stream_for_seeking_.second
+          ? fallback_stream_for_seeking_.first
+          : preferred_stream_for_seeking_.first;
   DCHECK_NE(stream_index, -1);
 
   const AVStream* seeking_stream =
       glue_->format_context()->streams[stream_index];
 
   pending_seek_ = true;
   base::PostTaskAndReplyWithResult(
       blocking_thread_.message_loop_proxy().get(),
       FROM_HERE,
       base::Bind(&av_seek_frame,
@@ skipping 152 matching lines @@
     return;
   }
 
   // Create demuxer stream entries for each possible AVStream. Each stream
   // is examined to determine if it is supported or not (is the codec enabled
   // for it in this release?). Unsupported streams are skipped, allowing for
   // partial playback. At least one audio or video stream must be playable.
   AVFormatContext* format_context = glue_->format_context();
   streams_.resize(format_context->nb_streams);
 
+  // FFmpeg doesn't guarantee packets will be in timestamp order across streams

[DaleCurtis, 2014/06/27 21:10:33]

If you decide we should keep this, I can refactor this whole section into a
static method so it's not polluting OnFindStreamInfoDone().

+  // in an ogg container after a seek.  Internally it only considers the file
+  // position when demuxing.  It's an open question whether FFmpeg should fix
+  // this: http://lists.ffmpeg.org/pipermail/ffmpeg-devel/2014-June/159212.html
+  //
+  // As a workaround to ensure playback starts correctly, use the position of
+  // packets demuxed during avformat_find_stream_info() to adjust the seek info.
+  int first_ogg_stream = -1;
+  int64_t first_ogg_packet_pos = std::numeric_limits<int64_t>::max();
+
   // Estimate the start time for each stream by looking through the packets
   // buffered during avformat_find_stream_info().  These values will be
   // considered later when determining the actual stream start time.
   //
   // These packets haven't been completely processed yet, so only look through
   // these values if the AVFormatContext has a valid start time.
   //
   // If no estimate is found, the stream entry will be kInfiniteDuration().
   std::vector<base::TimeDelta> start_time_estimates(format_context->nb_streams,
                                                     kInfiniteDuration());
   if (format_context->packet_buffer &&
       format_context->start_time != static_cast<int64>(AV_NOPTS_VALUE)) {
     struct AVPacketList* packet_buffer = format_context->packet_buffer;
     while (packet_buffer != format_context->packet_buffer_end) {
       DCHECK_LT(static_cast<size_t>(packet_buffer->pkt.stream_index),
                 start_time_estimates.size());
       const AVStream* stream =
           format_context->streams[packet_buffer->pkt.stream_index];
       if (packet_buffer->pkt.pts != static_cast<int64>(AV_NOPTS_VALUE)) {
         const base::TimeDelta packet_pts =
             ConvertFromTimeBase(stream->time_base, packet_buffer->pkt.pts);
         if (packet_pts < start_time_estimates[stream->index])
           start_time_estimates[stream->index] = packet_pts;
       }
+      if (packet_buffer->pkt.pos != -1 &&
+          packet_buffer->pkt.pos < first_ogg_packet_pos) {
+        first_ogg_stream = stream->index;
+        first_ogg_packet_pos = packet_buffer->pkt.pos;
+      }
       packet_buffer = packet_buffer->next;
     }
   }
 
   AVStream* audio_stream = NULL;
   AudioDecoderConfig audio_config;
 
   AVStream* video_stream = NULL;
   VideoDecoderConfig video_config;
 
   // If available, |start_time_| will be set to the lowest stream start time.
   start_time_ = kInfiniteDuration();
 
   base::TimeDelta max_duration;
   for (size_t i = 0; i < format_context->nb_streams; ++i) {
     AVStream* stream = format_context->streams[i];
     const AVCodecContext* codec_context = stream->codec;
     const AVMediaType codec_type = codec_context->codec_type;
-    bool discard_negative_timestamps = false;
 
     if (codec_type == AVMEDIA_TYPE_AUDIO) {
       if (audio_stream)
         continue;
 
       // Log the codec detected, whether it is supported or not.
       UMA_HISTOGRAM_SPARSE_SLOWLY("Media.DetectedAudioCodec",
                                   codec_context->codec_id);
       // Ensure the codec is supported. IsValidConfig() also checks that the
       // channel layout and sample format are valid.
       AVStreamToAudioDecoderConfig(stream, &audio_config, false);
       if (!audio_config.IsValidConfig())
         continue;
       audio_stream = stream;
-
-      // Enable post-decode frame dropping for packets with negative timestamps
-      // as outlined in section A.2 in the Ogg Vorbis spec:
-      // http://xiph.org/vorbis/doc/Vorbis_I_spec.html
-      discard_negative_timestamps =
-          audio_config.codec() == kCodecVorbis &&
-          strcmp(glue_->format_context()->iformat->name, "ogg") == 0;
     } else if (codec_type == AVMEDIA_TYPE_VIDEO) {
       if (video_stream)
         continue;
 
       // Log the codec detected, whether it is supported or not.
       UMA_HISTOGRAM_SPARSE_SLOWLY("Media.DetectedVideoCodec",
                                   codec_context->codec_id);
       // Ensure the codec is supported. IsValidConfig() also checks that the
       // frame size and visible size are valid.
       AVStreamToVideoDecoderConfig(stream, &video_config, false);
 
       if (!video_config.IsValidConfig())
         continue;
       video_stream = stream;
     } else if (codec_type == AVMEDIA_TYPE_SUBTITLE) {
       if (codec_context->codec_id != AV_CODEC_ID_WEBVTT || !text_enabled_) {
         continue;
       }
     } else {
       continue;
     }
 
-    streams_[i] =
-        new FFmpegDemuxerStream(this, stream, discard_negative_timestamps);
+    streams_[i] = new FFmpegDemuxerStream(this, stream);
     max_duration = std::max(max_duration, streams_[i]->duration());
 
     const base::TimeDelta start_time =
         ExtractStartTime(stream, start_time_estimates[i]);
-    if (start_time == kNoTimestamp())
+    const bool has_start_time = start_time != kNoTimestamp();
+
+    // Always prefer the video stream for seeking.  If none exists, we'll swap
+    // the fallback stream with the preferred stream below.
+    if (codec_type == AVMEDIA_TYPE_VIDEO) {
+      preferred_stream_for_seeking_ =
+          StreamSeekInfo(i, has_start_time ? start_time : base::TimeDelta());
+    }
+
+    if (!has_start_time)
       continue;
 
     if (start_time < start_time_) {
       start_time_ = start_time;
 
       // Choose the stream with the lowest starting time as the fallback stream
       // for seeking.  Video should always be preferred.
-      fallback_stream_for_seeking_ = std::make_pair(i, start_time);
+      fallback_stream_for_seeking_ = StreamSeekInfo(i, start_time);
     }
-
-    // Always prefer the video stream for seeking.  If none exists, we'll swap
-    // the fallback stream with the preferred stream below.
-    if (codec_type == AVMEDIA_TYPE_VIDEO)
-      preferred_stream_for_seeking_ = std::make_pair(i, start_time);
   }
 
   if (!audio_stream && !video_stream) {
     status_cb.Run(DEMUXER_ERROR_NO_SUPPORTED_STREAMS);
     return;
   }
 
   if (text_enabled_)
     AddTextStreams();
 
   if (format_context->duration != static_cast<int64_t>(AV_NOPTS_VALUE)) {
     // If there is a duration value in the container use that to find the
     // maximum between it and the duration from A/V streams.
     const AVRational av_time_base = {1, AV_TIME_BASE};
     max_duration =
         std::max(max_duration,
                  ConvertFromTimeBase(av_time_base, format_context->duration));
   } else {
     // The duration is unknown, in which case this is likely a live stream.
     max_duration = kInfiniteDuration();
   }
 
+  // Ogg has some peculiarities around negative timestamps, so use this flag to
+  // setup the FFmpegDemuxerStreams appropriately.
+  //
+  // Post-decode frame dropping for packets with negative timestamps is outlined
+  // in section A.2 in the Ogg Vorbis spec:
+  // http://xiph.org/vorbis/doc/Vorbis_I_spec.html
+  if (strcmp(format_context->iformat->name, "ogg") == 0 && audio_stream &&
+      audio_stream->codec->codec_id == AV_CODEC_ID_VORBIS) {
+    for (size_t i = 0; i < streams_.size(); ++i) {
+      if (streams_[i])
+        streams_[i]->enable_negative_timestamp_fixups_for_ogg();
+    }
+
+    // Fixup the seeking information to avoid selecting the audio stream unless
+    // it has a lower file position.  See notes on |first_ogg_stream|.
+    if (first_ogg_stream != audio_stream->index &&
+        fallback_stream_for_seeking_.first == audio_stream->index &&
+        fallback_stream_for_seeking_.second < base::TimeDelta()) {
+      fallback_stream_for_seeking_.second = base::TimeDelta();
+    }
+  }
+
   // If no start time could be determined, default to zero and prefer the video
   // stream over the audio stream for seeking.  E.g., The WAV demuxer does not
   // put timestamps on its frames.
   if (start_time_ == kInfiniteDuration()) {
     start_time_ = base::TimeDelta();
-    preferred_stream_for_seeking_ = std::make_pair(
+    preferred_stream_for_seeking_ = StreamSeekInfo(
         video_stream ? video_stream->index : audio_stream->index, start_time_);
   } else if (!video_stream) {
     // If no video stream exists, use the audio or text stream found above.
     preferred_stream_for_seeking_ = fallback_stream_for_seeking_;
   }
 
   // MPEG-4 B-frames cause grief for a simple container like AVI. Enable PTS
   // generation so we always get timestamps, see http://crbug.com/169570
   if (strcmp(format_context->iformat->name, "avi") == 0)
     format_context->flags |= AVFMT_FLAG_GENPTS;
@@ skipping 306 matching lines @@
   }
   for (size_t i = 0; i < buffered.size(); ++i)
     host_->AddBufferedTimeRange(buffered.start(i), buffered.end(i));
 }
 
 void FFmpegDemuxer::OnDataSourceError() {
   host_->OnDemuxerError(PIPELINE_ERROR_READ);
 }
 
 }  // namespace media