Add Common Encryption support to BMFF, including subsample decryption.

media/mp4/box_definitions.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/mp4/box_definitions.h"
 
 #include "base/logging.h"
 #include "media/mp4/box_reader.h"
 #include "media/mp4/fourccs.h"
 #include "media/mp4/rcheck.h"
@@ skipping 67 matching lines @@
 
 bool OriginalFormat::Parse(BoxReader* reader) {
   return reader->ReadFourCC(&format);
 }
 
 SchemeType::SchemeType() : type(FOURCC_NULL), version(0) {}
 SchemeType::~SchemeType() {}
 FourCC SchemeType::BoxType() const { return FOURCC_SCHM; }
 
 bool SchemeType::Parse(BoxReader* reader) {
-  RCHECK(reader->SkipBytes(4) &&
+  RCHECK(reader->ReadFullBoxHeader() &&

[ddorwin, 2012/06/26 06:09:19]

Why all the RCHECKs? Macros are discouraged, and this one actually has a return
in it, which is really unexpected.
I assume there was a specific reason it was allowed in the previous CL?

[strobe_, 2012/06/27 02:01:21]

The alternatives were worse. ;)

There are some tricky cases during parsing where we might be exposed to memory
corruption or otherwise produce invalid data. We catch those by using
WARN_UNUSED_RESULT on common functions that might return an error indicating
that parsing should immediately halt with an error state. The hierarchical
nature of BMFF means that even in this very simple parser, RCHECK gets used
quite a bit. Replacing each of those instances with the corresponding four-line
definition turned out to be really messy, and we also had a couple places where
the messiness of the code hid logic bugs in the original effort.

          reader->ReadFourCC(&type) &&
          reader->Read4(&version));
   RCHECK(type == FOURCC_CENC);
   return true;
 }
 
 TrackEncryption::TrackEncryption()
   : is_encrypted(false), default_iv_size(0) {
 }
 TrackEncryption::~TrackEncryption() {}
 FourCC TrackEncryption::BoxType() const { return FOURCC_TENC; }
 
 bool TrackEncryption::Parse(BoxReader* reader) {
   uint8 flag;
-  RCHECK(reader->SkipBytes(2) &&
+  RCHECK(reader->ReadFullBoxHeader() &&
+         reader->SkipBytes(2) &&
          reader->Read1(&flag) &&
          reader->Read1(&default_iv_size) &&
          reader->ReadVec(&default_kid, 16));
   is_encrypted = (flag != 0);
   if (is_encrypted) {
     RCHECK(default_iv_size == 8 || default_iv_size == 16);
   } else {
     RCHECK(default_iv_size == 0);
   }
   return true;
 }
 
 SchemeInfo::SchemeInfo() {}
 SchemeInfo::~SchemeInfo() {}
 FourCC SchemeInfo::BoxType() const { return FOURCC_SCHI; }
 
 bool SchemeInfo::Parse(BoxReader* reader) {
   return reader->ScanChildren() && reader->ReadChild(&track_encryption);
 }
 
 ProtectionSchemeInfo::ProtectionSchemeInfo() {}
 ProtectionSchemeInfo::~ProtectionSchemeInfo() {}
 FourCC ProtectionSchemeInfo::BoxType() const { return FOURCC_SINF; }
 
 bool ProtectionSchemeInfo::Parse(BoxReader* reader) {
-  return reader->ScanChildren() &&
+  RCHECK(reader->ScanChildren() &&
          reader->ReadChild(&type) &&
-         reader->ReadChild(&info);
+         reader->ReadChild(&info));
+  return true;
 }
 
 MovieHeader::MovieHeader()
     : creation_time(0),
       modification_time(0),
       timescale(0),
       duration(0),
       rate(-1),
       volume(-1),
       next_track_id(0) {}
@@ skipping 213 matching lines @@
 
 bool VideoSampleEntry::Parse(BoxReader* reader) {
   format = reader->type();
   RCHECK(reader->SkipBytes(6) &&
          reader->Read2(&data_reference_index) &&
          reader->SkipBytes(16) &&
          reader->Read2(&width) &&
          reader->Read2(&height) &&
          reader->SkipBytes(50));
 
+  // TODO(strobe): Finalize format signaling for encrypted media
+  // (http://crbug.com/132351). For now, we assume that every video track is
+  // AVC, and that any track may have a Common Encryption header regardless of
+  // format.
   RCHECK(reader->ScanChildren());
-  if (format == FOURCC_ENCV) {
-    RCHECK(reader->ReadChild(&sinf));
-  }
-
-  // TODO(strobe): finalize format signaling for encrypted media
-  // (http://crbug.com/132351)
-  //
-  //  if (format == FOURCC_AVC1 ||
-  //      (format == FOURCC_ENCV &&
-  //       sinf.format.format == FOURCC_AVC1)) {
-    RCHECK(reader->ReadChild(&avcc));
-  //  }
+  RCHECK(reader->ReadChild(&avcc) && reader->MaybeReadChild(&sinf));
   return true;
 }
 
 AudioSampleEntry::AudioSampleEntry()
     : format(FOURCC_NULL),
       data_reference_index(0),
       channelcount(0),
       samplesize(0),
       samplerate(0) {}
 
 AudioSampleEntry::~AudioSampleEntry() {}
 FourCC AudioSampleEntry::BoxType() const {
   DCHECK(false) << "AudioSampleEntry should be parsed according to the "
                 << "handler type recovered in its Media ancestor.";
   return FOURCC_NULL;
 }
 
 bool AudioSampleEntry::Parse(BoxReader* reader) {
   format = reader->type();
   RCHECK(reader->SkipBytes(6) &&
          reader->Read2(&data_reference_index) &&
          reader->SkipBytes(8) &&
          reader->Read2(&channelcount) &&
          reader->Read2(&samplesize) &&
          reader->SkipBytes(4) &&
          reader->Read4(&samplerate));
   // Convert from 16.16 fixed point to integer
   samplerate >>= 16;
 
-  RCHECK(reader->ScanChildren());
-  if (format == FOURCC_ENCA) {
-    RCHECK(reader->ReadChild(&sinf));
-  }
+  RCHECK(reader->ScanChildren() &&
+         reader->MaybeReadChild(&sinf));
   return true;
 }
 
 MediaHeader::MediaHeader()
     : creation_time(0),
       modification_time(0),
       timescale(0),
       duration(0) {}
 MediaHeader::~MediaHeader() {}
 FourCC MediaHeader::BoxType() const { return FOURCC_MDHD; }
@@ skipping 257 matching lines @@
 bool MovieFragment::Parse(BoxReader* reader) {
   RCHECK(reader->ScanChildren() &&
          reader->ReadChild(&header) &&
          reader->ReadChildren(&tracks) &&
          reader->MaybeReadChildren(&pssh));
   return true;
 }
 
 }  // namespace mp4
 }  // namespace media