Update duration when demuxed packets exceed known duration.

media/filters/ffmpeg_demuxer_unittest.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 <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
 #include <deque>
 #include <string>
@@ skipping 93 matching lines @@
         message_loop_.task_runner(), data_source_.get(),
         encrypted_media_init_data_cb, tracks_updated_cb, new MediaLog()));
   }
 
   MOCK_METHOD1(CheckPoint, void(int v));
 
   void InitializeDemuxerInternal(bool enable_text,
                                  media::PipelineStatus expected_pipeline_status,
                                  base::Time timeline_offset) {
     if (expected_pipeline_status == PIPELINE_OK)
-      EXPECT_CALL(host_, SetDuration(_));
+      EXPECT_CALL(host_, SetDuration(_)).Times(AnyNumber());
     WaitableMessageLoopEvent event;
     demuxer_->Initialize(&host_, event.GetPipelineStatusCB(), enable_text);
     demuxer_->timeline_offset_ = timeline_offset;
     event.RunAndWaitForStatus(expected_pipeline_status);
   }
 
   void InitializeDemuxer() {
     InitializeDemuxerInternal(/*enable_text=*/false, PIPELINE_OK, base::Time());
   }
 
@@ skipping 91 matching lines @@
   MOCK_METHOD2(OnEncryptedMediaInitData,
                void(EmeInitDataType init_data_type,
                     const std::vector<uint8_t>& init_data));
 
   void OnMediaTracksUpdated(std::unique_ptr<MediaTracks> tracks) {
     CHECK(tracks.get());
     media_tracks_ = std::move(tracks);
   }
 
   // Accessor to demuxer internals.
-  void set_duration_known(bool duration_known) {
+  void SetDurationKnown(bool duration_known) {
     demuxer_->duration_known_ = duration_known;
+    if (!duration_known)
+      demuxer_->duration_ = kInfiniteDuration;
   }
 
   bool IsStreamStopped(DemuxerStream::Type type) {
     DemuxerStream* stream = demuxer_->GetStream(type);
     CHECK(stream);
     return !static_cast<FFmpegDemuxerStream*>(stream)->demuxer_;
   }
 
   // Fixture members.
   std::unique_ptr<FileDataSource> data_source_;
@@ skipping 570 matching lines @@
     base::RunLoop().Run();
   }
 
   EXPECT_TRUE(got_eos_buffer);
 }
 
 TEST_F(FFmpegDemuxerTest, Read_EndOfStream_NoDuration) {
   // Verify that end of stream buffers are created.
   CreateDemuxer("bear-320x240.webm");
   InitializeDemuxer();
-  set_duration_known(false);
-  EXPECT_CALL(host_, SetDuration(base::TimeDelta::FromMilliseconds(2767)));
+  SetDurationKnown(false);
+  EXPECT_CALL(host_, SetDuration(base::TimeDelta::FromMilliseconds(2744)));
   ReadUntilEndOfStream(demuxer_->GetStream(DemuxerStream::AUDIO));
   ReadUntilEndOfStream(demuxer_->GetStream(DemuxerStream::VIDEO));
 }
 
 TEST_F(FFmpegDemuxerTest, Read_EndOfStream_NoDuration_VideoOnly) {
   // Verify that end of stream buffers are created.
   CreateDemuxer("bear-320x240-video-only.webm");
   InitializeDemuxer();
-  set_duration_known(false);
-  EXPECT_CALL(host_, SetDuration(base::TimeDelta::FromMilliseconds(2736)));
+  SetDurationKnown(false);
+  EXPECT_CALL(host_, SetDuration(base::TimeDelta::FromMilliseconds(2703)));
   ReadUntilEndOfStream(demuxer_->GetStream(DemuxerStream::VIDEO));
 }
 
 TEST_F(FFmpegDemuxerTest, Read_EndOfStream_NoDuration_AudioOnly) {
   // Verify that end of stream buffers are created.
   CreateDemuxer("bear-320x240-audio-only.webm");
   InitializeDemuxer();
-  set_duration_known(false);
-  EXPECT_CALL(host_, SetDuration(base::TimeDelta::FromMilliseconds(2767)));
+  SetDurationKnown(false);
+  EXPECT_CALL(host_, SetDuration(base::TimeDelta::FromMilliseconds(2744)));
   ReadUntilEndOfStream(demuxer_->GetStream(DemuxerStream::AUDIO));
 }
 
 TEST_F(FFmpegDemuxerTest, Read_EndOfStream_NoDuration_UnsupportedStream) {
   // Verify that end of stream buffers are created and we don't crash
   // if there are streams in the file that we don't support.
   CreateDemuxer("vorbis_audio_wmv_video.mkv");
   InitializeDemuxer();
-  set_duration_known(false);
-  EXPECT_CALL(host_, SetDuration(base::TimeDelta::FromMilliseconds(1014)));
+  SetDurationKnown(false);
+  EXPECT_CALL(host_, SetDuration(base::TimeDelta::FromMilliseconds(991)));

[chcunningham, 2017/01/27 21:41:13]

I'm confused about why the durations came down here. We init stream duration in
the same way as usual, only now we allow it to grow past that starting point.
When we pick up the max duration from the various streams, we now use the
dynamic stream duration() instead of GetElapsedTime(), but I expect those would
be roughly equivalent (or even that duration() would be bigger, since elapsed
time used cur_dts while duration_ uses pts).

With that said, I could imagine the durations going *up*, but coming down is
surprising.

[DaleCurtis, 2017/01/27 21:50:56]

I'm not sure, I spot checked a couple of the files (decode to wav, analyze
sample count) and the lengths are accurate now, whereas before they were
slightly too long.

   ReadUntilEndOfStream(demuxer_->GetStream(DemuxerStream::AUDIO));
 }
 
 TEST_F(FFmpegDemuxerTest, Seek) {
   // We're testing that the demuxer frees all queued packets when it receives
   // a Seek().
   CreateDemuxer("bear-320x240.webm");
   InitializeDemuxer();
 
   // Get our streams.
@@ skipping 641 matching lines @@
   EXPECT_EQ(astream, preferred_seeking_stream(base::TimeDelta()));
 
   // Now pretend that audio stream got disabled.
   astream->set_enabled(false, base::TimeDelta());
   // Since there's no other enabled streams, the preferred seeking stream should
   // still be the audio stream.
   EXPECT_EQ(astream, preferred_seeking_stream(base::TimeDelta()));
 }
 
 }  // namespace media