Add Common Encryption support to BMFF, including subsample decryption.

media/mp4/track_run_iterator_unittest.cc

Index: media/mp4/track_run_iterator_unittest.cc
diff --git a/media/mp4/track_run_iterator_unittest.cc b/media/mp4/track_run_iterator_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..1430b891067a04f4f976b5e596c5f30e35b1cc9c
--- /dev/null
+++ b/media/mp4/track_run_iterator_unittest.cc
@@ -0,0 +1,394 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.

[ddorwin, 2012/07/17 01:14:21]

Did not review. Will review after test CL is landed and this is rebased.

+// 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 "media/mp4/box_definitions.h"
+#include "media/mp4/rcheck.h"
+#include "media/mp4/track_run_iterator.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+// The sum of the elements in a vector initialized with SumAscending,
+// less the value of the last element.
+static const int kSumAscending1 = 45;
+
+static const int kAudioScale = 48000;
+static const int kVideoScale = 25;
+
+static const uint32 kSampleIsDifferenceSampleFlagMask = 0x10000;
+
+static const uint8 kAuxInfo[] = {
+  0x41, 0x54, 0x65, 0x73, 0x74, 0x49, 0x76, 0x31,
+  0x41, 0x54, 0x65, 0x73, 0x74, 0x49, 0x76, 0x32,
+  0x00, 0x02,
+  0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+  0x00, 0x03, 0x00, 0x00, 0x00, 0x04
+};
+
+static const char kIv1[] = {
+  0x41, 0x54, 0x65, 0x73, 0x74, 0x49, 0x76, 0x31,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
+};
+
+static const uint8 kKeyId[] = {
+  0x41, 0x47, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x54,
+  0x65, 0x73, 0x74, 0x4b, 0x65, 0x79, 0x49, 0x44
+};
+
+namespace media {
+namespace mp4 {
+
+class TrackRunIteratorTest : public testing::Test {
+ public:
+  virtual void SetUp() OVERRIDE {
+    iter_.reset(new TrackRunIterator());
+  }
+
+ protected:
+  scoped_ptr<TrackRunIterator> iter_;
+
+  Movie CreateMovie() {
+    Movie moov;
+    moov.header.timescale = 1000;
+    moov.tracks.resize(3);
+    moov.extends.tracks.resize(2);
+    moov.tracks[0].header.track_id = 1;
+    moov.tracks[0].media.header.timescale = kAudioScale;
+    SampleDescription& desc1 =
+        moov.tracks[0].media.information.sample_table.description;
+    desc1.type = kAudio;
+    desc1.audio_entries.resize(1);
+    desc1.audio_entries[0].format = FOURCC_MP4A;
+    moov.extends.tracks[0].track_id = 1;
+
+    moov.tracks[1].header.track_id = 2;
+    moov.tracks[1].media.header.timescale = kVideoScale;
+    SampleDescription& desc2 =
+        moov.tracks[1].media.information.sample_table.description;
+    desc2.type = kVideo;
+    desc2.video_entries.resize(1);
+    desc2.video_entries[0].sinf.info.track_encryption.is_encrypted = false;
+    moov.extends.tracks[1].track_id = 2;
+
+    moov.tracks[2].header.track_id = 3;
+    moov.tracks[2].media.information.sample_table.description.type = kHint;
+    return moov;
+  }
+
+  MovieFragment CreateFragment() {
+    MovieFragment moof;
+    moof.tracks.resize(2);
+    moof.tracks[0].decode_time.decode_time = 0;
+    moof.tracks[0].header.track_id = 1;
+    moof.tracks[0].header.has_default_sample_flags = true;
+    moof.tracks[0].header.default_sample_duration = 1024;
+    moof.tracks[0].header.default_sample_size = 4;
+    moof.tracks[0].runs.resize(2);
+    moof.tracks[0].runs[0].sample_count = 10;
+    moof.tracks[0].runs[0].data_offset = 100;
+    SetAscending(&moof.tracks[0].runs[0].sample_sizes);
+
+    moof.tracks[0].runs[1].sample_count = 10;
+    moof.tracks[0].runs[1].data_offset = 10000;
+
+    moof.tracks[1].header.track_id = 2;
+    moof.tracks[1].header.has_default_sample_flags = false;
+    moof.tracks[1].decode_time.decode_time = 10;
+    moof.tracks[1].runs.resize(1);
+    moof.tracks[1].runs[0].sample_count = 10;
+    moof.tracks[1].runs[0].data_offset = 200;
+    SetAscending(&moof.tracks[1].runs[0].sample_sizes);
+    SetAscending(&moof.tracks[1].runs[0].sample_durations);
+    moof.tracks[1].runs[0].sample_flags.resize(10);
+    for (size_t i = 1; i < moof.tracks[1].runs[0].sample_flags.size(); i++) {
+      moof.tracks[1].runs[0].sample_flags[i] =
+          kSampleIsDifferenceSampleFlagMask;
+    }
+
+    return moof;
+  }
+
+  // Update the first sample description of a Track to indicate encryption
+  void AddEncryption(Track* track) {
+    SampleDescription* stsd =
+        &track->media.information.sample_table.description;
+    ProtectionSchemeInfo* sinf;
+    if (!stsd->video_entries.empty()) {
+       sinf = &stsd->video_entries[0].sinf;
+    } else {
+       sinf = &stsd->audio_entries[0].sinf;
+    }
+
+    sinf->type.type = FOURCC_CENC;
+    sinf->info.track_encryption.is_encrypted = true;
+    sinf->info.track_encryption.default_iv_size = 8;
+    sinf->info.track_encryption.default_kid.insert(
+        sinf->info.track_encryption.default_kid.begin(),
+        kKeyId, kKeyId + arraysize(kKeyId));
+  }
+
+  // Add aux info covering the first track run to a TrackFragment, and update
+  // the run to ensure it matches length and subsample information.
+  void AddAuxInfoHeaders(int offset, TrackFragment* frag) {
+    frag->auxiliary_offset.offsets.push_back(offset);
+    frag->auxiliary_size.sample_count = 2;
+    frag->auxiliary_size.sample_info_sizes.push_back(8);
+    frag->auxiliary_size.sample_info_sizes.push_back(22);
+    frag->runs[0].sample_count = 2;
+    frag->runs[0].sample_sizes[1] = 10;
+  }
+
+  void SetAscending(std::vector<uint32>* vec) {
+    vec->resize(10);
+    for (size_t i = 0; i < vec->size(); i++)
+      (*vec)[i] = i+1;
+  }
+};
+
+TEST_F(TrackRunIteratorTest, NoRunsTest) {
+  ASSERT_TRUE(iter_->Init(CreateMovie(), MovieFragment()));
+  EXPECT_FALSE(iter_->RunIsValid());
+  EXPECT_FALSE(iter_->SampleIsValid());
+}
+
+
+TEST_F(TrackRunIteratorTest, BasicOperationTest) {
+  MovieFragment moof = CreateFragment();
+  ASSERT_TRUE(iter_->Init(CreateMovie(), moof));
+  EXPECT_TRUE(iter_->RunIsValid());
+  EXPECT_FALSE(iter_->is_encrypted());
+  EXPECT_EQ(1u, iter_->track_id());
+  EXPECT_EQ(100, iter_->sample_offset());
+  EXPECT_EQ(1, iter_->sample_size());
+  EXPECT_EQ(TimeDeltaFromFrac(0, kAudioScale), iter_->dts());
+  EXPECT_EQ(TimeDeltaFromFrac(0, kAudioScale), iter_->cts());
+  EXPECT_EQ(TimeDeltaFromFrac(1024, kAudioScale), iter_->duration());
+  EXPECT_TRUE(iter_->is_keyframe());
+
+  for (int i = 0; i < 9; i++) iter_->AdvanceSample();
+
+  EXPECT_EQ(1u, iter_->track_id());
+  EXPECT_EQ(100 + kSumAscending1, iter_->sample_offset());
+  EXPECT_EQ(10, iter_->sample_size());
+  EXPECT_EQ(TimeDeltaFromFrac(1024 * 9, kAudioScale), iter_->dts());
+  EXPECT_EQ(TimeDeltaFromFrac(1024, kAudioScale), iter_->duration());
+  EXPECT_TRUE(iter_->is_keyframe());
+
+  iter_->AdvanceSample();
+  EXPECT_FALSE(iter_->SampleIsValid());
+  iter_->AdvanceRun();
+  EXPECT_TRUE(iter_->is_keyframe());
+  for (int i = 0; i < 9; i++) iter_->AdvanceSample();
+  EXPECT_EQ(2u, iter_->track_id());
+  EXPECT_EQ(200 + kSumAscending1, iter_->sample_offset());
+  EXPECT_EQ(10, iter_->sample_size());
+  int64 base_dts = kSumAscending1 + moof.tracks[1].decode_time.decode_time;
+  EXPECT_EQ(TimeDeltaFromFrac(base_dts, kVideoScale), iter_->dts());
+  EXPECT_EQ(TimeDeltaFromFrac(10, kVideoScale), iter_->duration());
+  EXPECT_FALSE(iter_->is_keyframe());
+
+  iter_->AdvanceRun();
+  EXPECT_EQ(1u, iter_->track_id());
+  EXPECT_EQ(TimeDeltaFromFrac(1024 * 10, kAudioScale), iter_->dts());
+  iter_->AdvanceSample();
+  EXPECT_EQ(moof.tracks[0].runs[1].data_offset +
+            moof.tracks[0].header.default_sample_size,
+            iter_->sample_offset());
+  iter_->AdvanceRun();
+  EXPECT_FALSE(iter_->RunIsValid());
+}
+
+TEST_F(TrackRunIteratorTest, TrackExtendsDefaultsTest) {
+  Movie moov = CreateMovie();
+  MovieFragment moof = CreateFragment();
+  moov.extends.tracks[0].default_sample_duration = 50;
+  moov.extends.tracks[0].default_sample_size = 3;
+  moov.extends.tracks[0].default_sample_flags =
+    kSampleIsDifferenceSampleFlagMask;
+  moof.tracks[0].header.has_default_sample_flags = false;
+  moof.tracks[0].header.default_sample_size = 0;
+  moof.tracks[0].header.default_sample_duration = 0;
+  moof.tracks[0].runs[0].sample_sizes.clear();
+  ASSERT_TRUE(iter_->Init(moov, moof));
+  iter_->AdvanceSample();
+  EXPECT_FALSE(iter_->is_keyframe());
+  EXPECT_EQ(3, iter_->sample_size());
+  EXPECT_EQ(moof.tracks[0].runs[0].data_offset + 3, iter_->sample_offset());
+  EXPECT_EQ(TimeDeltaFromFrac(50, kAudioScale), iter_->duration());
+  EXPECT_EQ(TimeDeltaFromFrac(50, kAudioScale), iter_->dts());
+}
+
+TEST_F(TrackRunIteratorTest, FirstSampleFlagTest) {
+  MovieFragment moof = CreateFragment();
+  moof.tracks[1].header.has_default_sample_flags = true;
+  moof.tracks[1].header.default_sample_flags =
+    kSampleIsDifferenceSampleFlagMask;
+  moof.tracks[1].runs[0].sample_flags.resize(1);
+  ASSERT_TRUE(iter_->Init(CreateMovie(), moof));
+  iter_->AdvanceRun();
+  EXPECT_TRUE(iter_->is_keyframe());
+  iter_->AdvanceSample();
+  EXPECT_FALSE(iter_->is_keyframe());
+}
+
+TEST_F(TrackRunIteratorTest, MinDecodeTest) {
+  MovieFragment moof = CreateFragment();
+  moof.tracks[0].decode_time.decode_time = kAudioScale;
+  ASSERT_TRUE(iter_->Init(CreateMovie(), moof));
+  EXPECT_EQ(TimeDeltaFromFrac(moof.tracks[1].decode_time.decode_time,
+                              kVideoScale),
+            iter_->GetMinDecodeTimestamp());
+}
+
+TEST_F(TrackRunIteratorTest, ReorderingTest) {
+  MovieFragment moof = CreateFragment();
+  std::vector<int32>& cts_offsets =
+    moof.tracks[1].runs[0].sample_composition_time_offsets;
+  cts_offsets.resize(10);
+  cts_offsets[0] = 2;
+  cts_offsets[1] = -1;
+  moof.tracks[1].decode_time.decode_time = 0;
+  ASSERT_TRUE(iter_->Init(CreateMovie(), moof));
+  iter_->AdvanceRun();
+  EXPECT_EQ(TimeDeltaFromFrac(0, kVideoScale), iter_->dts());
+  EXPECT_EQ(TimeDeltaFromFrac(2, kVideoScale), iter_->cts());
+  EXPECT_EQ(TimeDeltaFromFrac(1, kVideoScale), iter_->duration());
+  iter_->AdvanceSample();
+  EXPECT_EQ(TimeDeltaFromFrac(1, kVideoScale), iter_->dts());
+  EXPECT_EQ(TimeDeltaFromFrac(0, kVideoScale), iter_->cts());
+  EXPECT_EQ(TimeDeltaFromFrac(2, kVideoScale), iter_->duration());
+}
+
+TEST_F(TrackRunIteratorTest, IgnoreUnknownAuxInfoTest) {
+  MovieFragment moof = CreateFragment();
+  moof.tracks[1].auxiliary_offset.offsets.push_back(50);
+  moof.tracks[1].auxiliary_size.default_sample_info_size = 2;
+  moof.tracks[1].auxiliary_size.sample_count = 2;
+  moof.tracks[1].runs[0].sample_count = 2;
+  ASSERT_TRUE(iter_->Init(CreateMovie(), moof));
+  iter_->AdvanceRun();
+  EXPECT_FALSE(iter_->AuxInfoNeedsToBeCached());
+}
+
+TEST_F(TrackRunIteratorTest, DecryptConfigTest) {
+  Movie moov = CreateMovie();
+  AddEncryption(&moov.tracks[1]);
+
+  MovieFragment moof = CreateFragment();
+  AddAuxInfoHeaders(50, &moof.tracks[1]);
+
+  ASSERT_TRUE(iter_->Init(moov, moof));
+
+  // The run for track 2 will be first, since its aux info offset is the first
+  // element in the file.
+  EXPECT_TRUE(iter_->is_encrypted());
+  EXPECT_TRUE(iter_->AuxInfoNeedsToBeCached());
+  EXPECT_EQ(arraysize(kAuxInfo), static_cast<uint32>(iter_->aux_info_size()));
+  EXPECT_EQ(50, iter_->aux_info_offset());
+  EXPECT_EQ(50, iter_->GetMaxClearOffset());
+  EXPECT_FALSE(iter_->CacheAuxInfo(NULL, 0));
+  EXPECT_FALSE(iter_->CacheAuxInfo(kAuxInfo, 3));
+  EXPECT_TRUE(iter_->AuxInfoNeedsToBeCached());
+  EXPECT_TRUE(iter_->CacheAuxInfo(kAuxInfo, arraysize(kAuxInfo)));
+  EXPECT_FALSE(iter_->AuxInfoNeedsToBeCached());
+  EXPECT_EQ(200, iter_->sample_offset());
+  EXPECT_EQ(moof.tracks[0].runs[0].data_offset, iter_->GetMaxClearOffset());
+  scoped_ptr<DecryptConfig> config = iter_->GetDecryptConfig();
+  ASSERT_EQ(arraysize(kKeyId), static_cast<uint32>(config->key_id_size()));
+  EXPECT_TRUE(!memcmp(kKeyId, config->key_id(), config->key_id_size()));
+  ASSERT_EQ(arraysize(kIv1), config->iv().size());
+  EXPECT_TRUE(!memcmp(kIv1, config->iv().data(), config->iv().size()));
+  EXPECT_TRUE(config->subsamples().empty());
+  iter_->AdvanceSample();
+  config = iter_->GetDecryptConfig();
+  EXPECT_EQ(2u, config->subsamples().size());
+  EXPECT_EQ(1, config->subsamples()[0].clear_bytes);
+  EXPECT_EQ(4, config->subsamples()[1].cypher_bytes);
+}
+
+// It is legal for aux info blocks to be shared among multiple formats.
+TEST_F(TrackRunIteratorTest, SharedAuxInfoTest) {
+  Movie moov = CreateMovie();
+  AddEncryption(&moov.tracks[0]);
+  AddEncryption(&moov.tracks[1]);
+
+  MovieFragment moof = CreateFragment();
+  moof.tracks[0].runs.resize(1);
+  AddAuxInfoHeaders(50, &moof.tracks[0]);
+  AddAuxInfoHeaders(50, &moof.tracks[1]);
+  moof.tracks[0].auxiliary_size.default_sample_info_size = 8;
+
+  ASSERT_TRUE(iter_->Init(moov, moof));
+  EXPECT_EQ(1u, iter_->track_id());
+  EXPECT_EQ(50, iter_->aux_info_offset());
+  EXPECT_TRUE(iter_->CacheAuxInfo(kAuxInfo, arraysize(kAuxInfo)));
+  scoped_ptr<DecryptConfig> config = iter_->GetDecryptConfig();
+  ASSERT_EQ(arraysize(kIv1), config->iv().size());
+  EXPECT_TRUE(!memcmp(kIv1, config->iv().data(), config->iv().size()));
+  iter_->AdvanceSample();
+  EXPECT_EQ(50, iter_->GetMaxClearOffset());
+  iter_->AdvanceRun();
+  EXPECT_EQ(50, iter_->GetMaxClearOffset());
+  EXPECT_EQ(50, iter_->aux_info_offset());
+  EXPECT_TRUE(iter_->CacheAuxInfo(kAuxInfo, arraysize(kAuxInfo)));
+  EXPECT_EQ(200, iter_->GetMaxClearOffset());
+  ASSERT_EQ(arraysize(kIv1), config->iv().size());
+  EXPECT_TRUE(!memcmp(kIv1, config->iv().data(), config->iv().size()));
+  iter_->AdvanceSample();
+  EXPECT_EQ(201, iter_->GetMaxClearOffset());
+}
+
+
+// Sensible files are expected to place auxiliary information for a run
+// immediately before the main data for that run. Alternative schemes are
+// possible, however, including the somewhat reasonable behavior of placing all
+// aux info at the head of the 'mdat' box together, and the completely
+// unreasonable behavior demonstrated here:
+//  byte 50: track 2, run 1 aux info
+//  byte 100: track 1, run 1 data
+//  byte 200: track 2, run 1 data
+//  byte 201: track 1, run 2 aux info (*inside* track 2, run 1 data)
+//  byte 10000: track 1, run 2 data
+//  byte 20000: track 1, run 1 aux info
+TEST_F(TrackRunIteratorTest, PathologicalOrderingTest) {
+  return;
+  Movie moov = CreateMovie();
+  AddEncryption(&moov.tracks[0]);
+  AddEncryption(&moov.tracks[1]);
+
+  MovieFragment moof = CreateFragment();
+  AddAuxInfoHeaders(20000, &moof.tracks[0]);
+  moof.tracks[0].auxiliary_offset.offsets.push_back(201);
+  moof.tracks[0].auxiliary_size.sample_count += 2;
+  moof.tracks[0].auxiliary_size.default_sample_info_size = 8;
+  moof.tracks[0].runs[1].sample_count = 2;
+  AddAuxInfoHeaders(50, &moof.tracks[1]);
+  moof.tracks[1].runs[0].sample_sizes[0] = 5;
+
+  ASSERT_TRUE(iter_->Init(moov, moof));
+  EXPECT_EQ(2u, iter_->track_id());
+  EXPECT_EQ(50, iter_->aux_info_offset());
+  EXPECT_EQ(200, iter_->sample_offset());
+  EXPECT_TRUE(iter_->CacheAuxInfo(kAuxInfo, arraysize(kAuxInfo)));
+  EXPECT_EQ(100, iter_->GetMaxClearOffset());
+  iter_->AdvanceRun();
+  EXPECT_EQ(1u, iter_->track_id());
+  EXPECT_EQ(20000, iter_->aux_info_offset());
+  EXPECT_EQ(100, iter_->sample_offset());
+  EXPECT_TRUE(iter_->CacheAuxInfo(kAuxInfo, arraysize(kAuxInfo)));
+  EXPECT_EQ(200, iter_->GetMaxClearOffset());
+  iter_->AdvanceSample();
+  EXPECT_EQ(201, iter_->GetMaxClearOffset());
+  iter_->AdvanceRun();
+  EXPECT_EQ(1u, iter_->track_id());
+  EXPECT_EQ(201, iter_->aux_info_offset());
+  EXPECT_EQ(10000, iter_->sample_offset());
+  EXPECT_EQ(201, iter_->GetMaxClearOffset());
+  EXPECT_TRUE(iter_->CacheAuxInfo(kAuxInfo, arraysize(kAuxInfo)));
+  EXPECT_EQ(10000, iter_->GetMaxClearOffset());
+}
+
+}  // namespace mp4
+}  // namespace media