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());
+}
+
 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/07/03 21:03:47]

Is there a reason you didn't change the name to buf_size? With all the sizes, it
wasn't immediately clear what "size" meant when reading the code below.

[strobe_, 2012/07/19 02:43:34]

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_.AuxInfoNeedsToBeCached()) {
+    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;
+  queue_.PeekAt(runs_.sample_offset() + moof_head_, &buf, &size);
+  if (size < runs_.sample_size()) return false;
 
-  std::vector<uint8> frame_buf(buf, buf + runs_.size());
+  scoped_ptr<DecryptConfig> decrypt_config;
+  if (runs_.is_encrypted())
+    decrypt_config = runs_.GetDecryptConfig();
+
+  std::vector<uint8> frame_buf(buf, buf + runs_.sample_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()) {
+      // XXX(strobe): decide how best to make these modifications

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

TODO

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

Sorry, "XXX" is personal shorthand for "resolve before checking this in" (easy
to grep for).

+      std::vector<SubsampleEntry>* subsamples =
+          decrypt_config->mutable_subsamples();
+
+      const int nalu_size_diff = 4 - size_of_nalu_length_;
+      size_t expected_size = runs_.sample_size() +
+          decrypt_config->subsamples().size() * nalu_size_diff;
+      RCHECK(frame_buf.size() == expected_size);
+      for (size_t i = 0; i < decrypt_config->subsamples().size(); i++)
+        (*subsamples)[i].clear_bytes += nalu_size_diff;
+    }
+
     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 +=
+            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();
+           << ", size=" << runs_.sample_size();
 
   if (audio) {
     audio_buffers->push_back(stream_buf);
   } else {
     video_buffers->push_back(stream_buf);
   }
 
   runs_.AdvanceSample();
   return true;
 }
@@ skipping 23 matching lines @@
   return true;
 }
 
 void MP4StreamParser::ChangeState(State new_state) {
   DVLOG(2) << "Changing state: " << new_state;
   state_ = new_state;
 }
 
 }  // namespace mp4
 }  // namespace media