Fix mp4 keyframe parsing, removing unused stss parsing.

media/formats/mp4/track_run_iterator_unittest.cc

 // 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.
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/string_split.h"
 #include "media/formats/mp4/box_definitions.h"
 #include "media/formats/mp4/rcheck.h"
@@ skipping 55 matching lines @@
     moov_.tracks[0].media.header.timescale = kAudioScale;
     SampleDescription& desc1 =
         moov_.tracks[0].media.information.sample_table.description;
     AudioSampleEntry aud_desc;
     aud_desc.format = FOURCC_MP4A;
     aud_desc.sinf.info.track_encryption.is_encrypted = false;
     desc1.type = kAudio;
     desc1.audio_entries.push_back(aud_desc);
     moov_.extends.tracks[0].track_id = 1;
     moov_.extends.tracks[0].default_sample_description_index = 1;
-    moov_.tracks[0].media.information.sample_table.sync_sample.is_present =
-        false;
     moov_.tracks[1].header.track_id = 2;
     moov_.tracks[1].media.header.timescale = kVideoScale;
     SampleDescription& desc2 =
         moov_.tracks[1].media.information.sample_table.description;
     VideoSampleEntry vid_desc;
     vid_desc.format = FOURCC_AVC1;
     vid_desc.sinf.info.track_encryption.is_encrypted = false;
     desc2.type = kVideo;
     desc2.video_entries.push_back(vid_desc);
     moov_.extends.tracks[1].track_id = 2;
     moov_.extends.tracks[1].default_sample_description_index = 1;
-    SyncSample& video_sync_sample =
-        moov_.tracks[1].media.information.sample_table.sync_sample;
-    video_sync_sample.is_present = true;
-    video_sync_sample.entries.resize(1);
-    video_sync_sample.entries[0] = 0;
 
     moov_.tracks[2].header.track_id = 3;
     moov_.tracks[2].media.information.sample_table.description.type = kHint;
   }
 
   uint32 ToSampleFlags(const std::string& str) {
     CHECK_EQ(str.length(), 2u);
 
     SampleDependsOn sample_depends_on = kSampleDependsOnReserved;
     bool is_non_sync_sample = false;
@@ skipping 59 matching lines @@
       trun->sample_flags[i] = ToSampleFlags(flags_data[i]);
   }
 
   std::string KeyframeAndRAPInfo(TrackRunIterator* iter) {
     CHECK(iter->IsRunValid());
     std::stringstream ss;
     ss << iter->track_id();
 
     while (iter->IsSampleValid()) {
       ss << " " << (iter->is_keyframe() ? "K" : "P");
-      if (iter->is_random_access_point())
-        ss << "R";
       iter->AdvanceSample();
     }
 
     return ss.str();
   }
 
   MovieFragment CreateFragment() {
     MovieFragment moof;
     moof.tracks.resize(2);
     moof.tracks[0].decode_time.decode_time = 0;
@@ skipping 189 matching lines @@
   // Ensure that keyframes are flagged correctly in the face of BMFF boxes which
   // explicitly specify the flags for the first sample in a run and rely on
   // defaults for all subsequent samples
   iter_.reset(new TrackRunIterator(&moov_, media_log_));
   MovieFragment moof = CreateFragment();
   moof.tracks[1].header.has_default_sample_flags = true;
   moof.tracks[1].header.default_sample_flags = ToSampleFlags("UN");
   SetFlagsOnSamples("US", &moof.tracks[1].runs[0]);
 
   ASSERT_TRUE(iter_->Init(moof));
-  EXPECT_EQ("1 KR KR KR KR KR KR KR KR KR KR", KeyframeAndRAPInfo(iter_.get()));
+  EXPECT_EQ("1 K K K K K K K K K K", KeyframeAndRAPInfo(iter_.get()));
 
   iter_->AdvanceRun();
-  EXPECT_EQ("2 KR P P P P P P P P P", KeyframeAndRAPInfo(iter_.get()));
+  EXPECT_EQ("2 K P P P P P P P P P", KeyframeAndRAPInfo(iter_.get()));
 }
 
 // Verify that parsing fails if a reserved value is in the sample flags.
 TEST_F(TrackRunIteratorTest, SampleInfoTest_ReservedInSampleFlags) {
   iter_.reset(new TrackRunIterator(&moov_, media_log_));
   MovieFragment moof = CreateFragment();
   // Change the "depends on" field on one of the samples to a
   // reserved value.
   moof.tracks[1].runs[0].sample_flags[0] = ToSampleFlags("RS");
   ASSERT_FALSE(iter_->Init(moof));
@@ skipping 267 matching lines @@
   EXPECT_EQ(iter_->GetMaxClearOffset(), 101);
   iter_->AdvanceRun();
   EXPECT_EQ(iter_->track_id(), 1u);
   EXPECT_EQ(iter_->aux_info_offset(), 201);
   EXPECT_EQ(iter_->sample_offset(), 10000);
   EXPECT_EQ(iter_->GetMaxClearOffset(), 201);
   EXPECT_TRUE(iter_->CacheAuxInfo(kAuxInfo, arraysize(kAuxInfo)));
   EXPECT_EQ(iter_->GetMaxClearOffset(), 10000);
 }
 
-TEST_F(TrackRunIteratorTest, MissingAndEmptyStss) {
+TEST_F(TrackRunIteratorTest, KeyFrameFlagCombinations) {
+  // Setup both audio and video tracks to each have 6 samples covering all the
+  // combinations of mp4 "sync sample" and "depends on" relationships.
   MovieFragment moof = CreateFragment();
-
-  // Setup track 0 to not have an stss box, which means that all samples should
-  // be marked as random access points unless the kSampleIsNonSyncSample flag is
-  // set in the sample flags.
-  moov_.tracks[0].media.information.sample_table.sync_sample.is_present = false;
-  moov_.tracks[0].media.information.sample_table.sync_sample.entries.resize(0);
   moof.tracks[0].runs.resize(1);
+  moof.tracks[1].runs.resize(1);
   moof.tracks[0].runs[0].sample_count = 6;
-  moof.tracks[0].runs[0].data_offset = 100;
+  moof.tracks[1].runs[0].sample_count = 6;
   SetFlagsOnSamples("US UN OS ON NS NN", &moof.tracks[0].runs[0]);
-
-  // Setup track 1 to have an stss box with no entries, which normally means
-  // that none of the samples should be random access points. If the
-  // kSampleIsNonSyncSample flag is NOT set though, the sample should be
-  // considered a random access point.
-  moov_.tracks[1].media.information.sample_table.sync_sample.is_present = true;
-  moov_.tracks[1].media.information.sample_table.sync_sample.entries.resize(0);
-  moof.tracks[1].runs.resize(1);
-  moof.tracks[1].runs[0].sample_count = 6;
-  moof.tracks[1].runs[0].data_offset = 200;
   SetFlagsOnSamples("US UN OS ON NS NN", &moof.tracks[1].runs[0]);
-
   iter_.reset(new TrackRunIterator(&moov_, media_log_));
 
   ASSERT_TRUE(iter_->Init(moof));
   EXPECT_TRUE(iter_->IsRunValid());
 
-  // Verify that all samples except for the ones that have the
-  // kSampleIsNonSyncSample flag set are marked as random access points.
-  EXPECT_EQ("1 KR P PR P KR K", KeyframeAndRAPInfo(iter_.get()));
+  // Keyframes should be marked according to downstream's expectations that
+  // keyframes serve as points of random access for seeking.
+
+  // For audio, any sync sample should be marked as a key frame. Whether a
+  // sample "depends on" other samples is not considered. Unlike video samples,
+  // audio samples are often marked as depending on other samples but are still
+  // workable for random access. While we allow for parsing of audio samples
+  // that are non-sync samples, we generally expect all audio samples to be sync
+  // samples and downstream will log and discard any non-sync audio samples.
+  EXPECT_EQ("1 K P K P K P", KeyframeAndRAPInfo(iter_.get()));
 
   iter_->AdvanceRun();
 
-  // Verify that nothing is marked as a random access point.
-  EXPECT_EQ("2 KR P PR P KR K", KeyframeAndRAPInfo(iter_.get()));
+  // For video, any key frame should be both a sync sample and have no known
+  // dependents. Ideally, a video sync sample should always be marked as having
+  // no dependents, but we occasionally encounter media where all samples are
+  // marked "sync" and we must rely on combining the two flags to pick out the
+  // true key frames. See http://crbug.com/310712 and http://crbug.com/507916.
+  // Realiably knowing the keyframes for video is also critical to SPS PPS
+  // insertion.
+  EXPECT_EQ("2 K P P P K P", KeyframeAndRAPInfo(iter_.get()));
 }
 
-
 }  // namespace mp4
 }  // namespace media