Add Common Encryption support to BMFF, including subsample decryption.

media/mp4/mp4_stream_parser.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/mp4_stream_parser.h"
 
 #include "base/callback.h"
 #include "base/logging.h"
 #include "base/time.h"
 #include "media/base/audio_decoder_config.h"
@@ skipping 82 matching lines @@
   } while (result && !err);
 
   if (err) {
     DLOG(ERROR) << "Unknown error while parsing MP4";
     queue_.Reset();
     moov_.reset();
     ChangeState(kError);
     return false;
   }
 
-  if (!audio_buffers.empty() &&
-      (audio_cb_.is_null() || !audio_cb_.Run(audio_buffers)))
-    return false;
-  if (!video_buffers.empty() &&
-      (video_cb_.is_null() || !video_cb_.Run(video_buffers)))
-    return false;
-
+  if (!audio_buffers.empty()) {
+    CHECK(!audio_cb_.is_null());
+    RCHECK(audio_cb_.Run(audio_buffers));
+  }
+  if (!video_buffers.empty()) {
+    CHECK(!video_cb_.is_null());
+    RCHECK(video_cb_.Run(video_buffers));
+  }
   return true;
 }
 
 bool MP4StreamParser::ParseBox(bool* err) {
   const uint8* buf;
   int size;
   queue_.Peek(&buf, &size);
   if (!size) return false;
 
   scoped_ptr<BoxReader> reader(BoxReader::ReadTopLevelBox(buf, size, err));
@@ skipping 39 matching lines @@
         track->media.information.sample_table.description;
     if (track->media.handler.type == kAudio && !audio_config.IsValidConfig()) {
       RCHECK(!samp_descr.audio_entries.empty());
       const AudioSampleEntry& entry = samp_descr.audio_entries[0];
 
       // TODO(strobe): We accept all format values, pending clarification on
       // the formats used for encrypted media (http://crbug.com/132351).
       //  RCHECK(entry.format == FOURCC_MP4A ||
       //         (entry.format == FOURCC_ENCA &&
       //          entry.sinf.format.format == FOURCC_MP4A));
+      RCHECK(EmitKeyNeeded(entry.sinf.info.track_encryption));
 
       const ChannelLayout layout =
           AVC::ConvertAACChannelCountToChannelLayout(entry.channelcount);
       audio_config.Initialize(kCodecAAC, entry.samplesize, layout,
                               entry.samplerate, NULL, 0, false);
       has_audio_ = true;
       audio_track_id_ = track->header.track_id;
     }
     if (track->media.handler.type == kVideo && !video_config.IsValidConfig()) {
       RCHECK(!samp_descr.video_entries.empty());
       const VideoSampleEntry& entry = samp_descr.video_entries[0];
 
       //  RCHECK(entry.format == FOURCC_AVC1 ||
       //         (entry.format == FOURCC_ENCV &&
       //          entry.sinf.format.format == FOURCC_AVC1));
+      RCHECK(EmitKeyNeeded(entry.sinf.info.track_encryption));
 
       // TODO(strobe): Recover correct crop box and pixel aspect ratio
       video_config.Initialize(kCodecH264, H264PROFILE_MAIN,  VideoFrame::YV12,
                               gfx::Size(entry.width, entry.height),
                               gfx::Rect(0, 0, entry.width, entry.height),
                               // Bogus duration used for framerate, since real
                               // framerate may be variable
                               1000, track->media.header.timescale,
                               1, 1,
                               // No decoder-specific buffer needed for AVC;
@@ skipping 26 matching lines @@
 bool MP4StreamParser::ParseMoof(BoxReader* reader) {
   RCHECK(moov_.get());  // Must already have initialization segment
   MovieFragment moof;
   RCHECK(moof.Parse(reader));
   RCHECK(runs_.Init(*moov_, moof));
   new_segment_cb_.Run(runs_.GetMinDecodeTimestamp());
   ChangeState(kEmittingSamples);
   return true;
 }
 
+bool MP4StreamParser::EmitKeyNeeded(const TrackEncryption& track_encryption) {
+  if (!track_encryption.is_encrypted) return true;
+  scoped_array<uint8> kid(new uint8[track_encryption.default_kid.size()]);
+  memcpy(kid.get(), &track_encryption.default_kid[0],
+         track_encryption.default_kid.size());
+  return need_key_cb_.Run(kid.Pass(), track_encryption.default_kid.size());

[ddorwin, 2012/06/26 23:16:20]

For ISO, the initData is supposed to be the PSSH. Most likely, it will be
specified to be all PSSHes.

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

Oh, duh, that makes a lot more sense! Where's that specified?

[ddorwin, 2012/07/03 21:03:46]

This is based on discussions with others, though there are no implementations or
examples yet. :)
https://www.w3.org/Bugs/Public/show_bug.cgi?id=17673

[strobe_, 2012/07/13 00:47:07]

OK, comment added.

+}
+
 bool MP4StreamParser::EnqueueSample(BufferQueue* audio_buffers,
                                     BufferQueue* video_buffers,
                                     bool* err) {
   if (!runs_.RunValid()) {
     ChangeState(kParsingBoxes);
     return true;
   }
 
   if (!runs_.SampleValid()) {
     runs_.AdvanceRun();
     return true;
   }
 
   DCHECK(!(*err));
 
   const uint8* buf;
   int size;

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

buf_size would make this function easier to read.

[strobe_, 2012/07/13 00:47:07]

Done.

[strobe_, 2012/07/13 00:47:07]

Done.

   queue_.Peek(&buf, &size);
   if (!size) return false;
 
   bool audio = has_audio_ && audio_track_id_ == runs_.track_id();
   bool video = has_video_ && video_track_id_ == runs_.track_id();
 
   // Skip this entire track if it's not one we're interested in
   if (!audio && !video) runs_.AdvanceRun();
 
   // Attempt to cache the auxiliary information first. Aux info is usually
   // placed in a contiguous block before the sample data, rather than being
   // interleaved. If we didn't cache it, this would require that we retain the
   // start of the segment buffer while reading samples. Aux info is typically
   // quite small compared to sample data, so this pattern is useful on
   // memory-constrained devices where the source buffer consumes a substantial
   // portion of the total system memory.
-  if (runs_.NeedsCENC()) {
-    queue_.PeekAt(runs_.cenc_offset() + moof_head_, &buf, &size);
-    return runs_.CacheCENC(buf, size);
+  if (runs_.AuxInfoRequired()) {
+    queue_.PeekAt(runs_.aux_info_offset() + moof_head_, &buf, &size);
+    if (size < runs_.aux_info_size()) return false;
+    *err = !runs_.CacheAuxInfo(buf, size);
+    return !*err;
   }
 
   queue_.PeekAt(runs_.offset() + moof_head_, &buf, &size);
   if (size < runs_.size()) return false;
 
+  scoped_ptr<DecryptConfig> decrypt_config;
+  if (runs_.is_encrypted())
+    decrypt_config = runs_.GetDecryptConfig();
+
   std::vector<uint8> frame_buf(buf, buf + runs_.size());
   if (video) {
+    // TODO(strobe): move all this to separate method, add unittest
     RCHECK(AVC::ConvertToAnnexB(size_of_nalu_length_, &frame_buf));
+
+    if (decrypt_config.get()) {
+      const int nalu_size_diff = 4 - size_of_nalu_length_;
+      size_t expected_size = runs_.size() +

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

expected size of what?
what is runs_.size()? It seems to be the frame size less subsample headers or
something.

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

size() is the size of the current sample; IV and subsamples (the auxiliary info)
is stored independently from the notional sample in CENC. I've renamed to
sample_size() and sample_offset() to make this clearer.

+          decrypt_config->subsample_count() * nalu_size_diff;
+      RCHECK(frame_buf.size() == expected_size);
+      for (int i = 0; i < decrypt_config->subsample_count(); i++)
+        decrypt_config->mutable_subsamples()[i].clear_bytes += nalu_size_diff;

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

Rather than mutable_subsamples, you could have an AddFooToSubsamples() function.
Not sure what Foo is or if it could be made generic. Seems better than exposing
a member to be modified.

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

Two reasons we need to mutate:

1. To convert each NALU from AVC format (with a length prefix) to Annex B (with
an 0x00000001 start code before each NALU). This amounts to adding a constant
factor to each subsample's clear byte count.

2. To inject SPS/PPS. This is a variable-sized addition to the first subsample's
clear bytes count.

Do you prefer adding two appropriate methods on the DecryptConfig, or addding a
DecryptConfig::SetSubsamples() method and mutate a copy locally, or just making
a new DecryptConfig with values pulled from the old one?

[ddorwin, 2012/07/03 21:03:46]

Since we are just passing the DecryptConfig to someone else and don't need to
store the modifications, a new one might be best.
I'd be interested to know what others prefer.

Can you add 1 and 2 above as comments in the appropriate places?

[strobe_, 2012/07/13 00:47:07]

Done.

+    }
+
     if (!parameter_sets_inserted_) {
+      if (!runs_.is_keyframe()) {
+        LOG(INFO) << "XXX skipping initial non-keyframe sample";
+        runs_.AdvanceSample();
+        return true;
+      }
+
       const AVCDecoderConfigurationRecord* avc_config = NULL;
       for (size_t t = 0; t < moov_->tracks.size(); t++) {
         if (moov_->tracks[t].header.track_id == runs_.track_id()) {
           avc_config = &moov_->tracks[t].media.information.
               sample_table.description.video_entries[0].avcc;
           break;
         }
       }
       RCHECK(avc_config != NULL);
-      RCHECK(AVC::InsertParameterSets(*avc_config, &frame_buf));
+      std::vector<uint8> param_sets;
+      RCHECK(AVC::ConvertParameterSets(*avc_config, &param_sets));
+      frame_buf.insert(frame_buf.begin(),
+                       param_sets.begin(), param_sets.end());
+      if (decrypt_config.get()) {
+        decrypt_config->mutable_subsamples()[0].clear_bytes +=

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

Hmm, another mutable use. I guess it's not as simple as I suggested above. What
is this doing?

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

see above

+            param_sets.size();
+      }
       parameter_sets_inserted_ = true;
     }
   }
 
   scoped_refptr<StreamParserBuffer> stream_buf =
     StreamParserBuffer::CopyFrom(&frame_buf[0], frame_buf.size(),
                                  runs_.is_keyframe());
 
+  if (runs_.is_encrypted())
+    stream_buf->SetDecryptConfig(decrypt_config.Pass());
+
   stream_buf->SetDuration(runs_.duration());
   // We depend on the decoder performing frame reordering without reordering
   // timestamps, and only provide the decode timestamp in the buffer.
   stream_buf->SetTimestamp(runs_.dts());
 
   DVLOG(3) << "Pushing frame: aud=" << audio
            << ", key=" << runs_.is_keyframe()
            << ", dur=" << runs_.duration().InMilliseconds()
            << ", dts=" << runs_.dts().InMilliseconds()
            << ", size=" << runs_.size();
@@ skipping 33 matching lines @@
   return true;
 }
 
 void MP4StreamParser::ChangeState(State new_state) {
   DVLOG(2) << "Changing state: " << new_state;
   state_ = new_state;
 }
 
 }  // namespace mp4
 }  // namespace media