Fix encrypted AAC in BMFF by adding subsample info.

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/callback_helpers.h"
 #include "base/logging.h"
 #include "base/time.h"
@@ skipping 291 matching lines @@
     std::vector<uint8> param_sets;
     RCHECK(AVC::ConvertConfigToAnnexB(avc_config, &param_sets));
     frame_buf->insert(frame_buf->begin(),
                       param_sets.begin(), param_sets.end());
     if (!subsamples->empty())
       (*subsamples)[0].clear_bytes += param_sets.size();
   }
   return true;
 }
 
+bool MP4StreamParser::PrepareAACBuffer(
+    const AAC& aac_config, std::vector<uint8>* frame_buf,
+    std::vector<SubsampleEntry>* subsamples) const {
+  // Append an ADTS header to every audio sample.
+  RCHECK(aac_config.ConvertEsdsToADTS(frame_buf));
+
+  // As above, adjust subsample information to account for the headers. AAC is
+  // not required to use subsample encryption, so we may need to add an entry.
+  if (subsamples->empty()) {
+    SubsampleEntry entry;
+    entry.clear_bytes = AAC::kADTSHeaderSize;
+    entry.cypher_bytes = frame_buf->size() - AAC::kADTSHeaderSize;
+    subsamples->push_back(entry);
+  } else {
+    (*subsamples)[0].clear_bytes += AAC::kADTSHeaderSize;
+  }
+  return true;
+}
+
 bool MP4StreamParser::EnqueueSample(BufferQueue* audio_buffers,
                                     BufferQueue* video_buffers,
                                     bool* err) {
   if (!runs_->IsRunValid()) {
     // Flush any buffers we've gotten in this chunk so that buffers don't
     // cross NewSegment() calls
     *err = !SendAndFlushSamples(audio_buffers, video_buffers);
     if (*err)
       return false;
 
@@ skipping 37 matching lines @@
     queue_.PeekAt(runs_->aux_info_offset() + moof_head_, &buf, &buf_size);
     if (buf_size < runs_->aux_info_size()) return false;
     *err = !runs_->CacheAuxInfo(buf, buf_size);
     return !*err;
   }
 
   queue_.PeekAt(runs_->sample_offset() + moof_head_, &buf, &buf_size);
   if (buf_size < runs_->sample_size()) return false;
 
   scoped_ptr<DecryptConfig> decrypt_config;
-  if (runs_->is_encrypted())
+  std::vector<SubsampleEntry> subsamples;
+  if (runs_->is_encrypted()) {
     decrypt_config = runs_->GetDecryptConfig();
+    subsamples = decrypt_config->subsamples();
+  }
 
   std::vector<uint8> frame_buf(buf, buf + runs_->sample_size());
   if (video) {
-    std::vector<SubsampleEntry> subsamples;
-    if (decrypt_config.get())
-      subsamples = decrypt_config->subsamples();
     if (!PrepareAVCBuffer(runs_->video_description().avcc,
                           &frame_buf, &subsamples)) {
       DLOG(ERROR) << "Failed to prepare AVC sample for decode";
       *err = true;
       return false;
     }
-    if (!subsamples.empty()) {
-      decrypt_config.reset(new DecryptConfig(
-          decrypt_config->key_id(),
-          decrypt_config->iv(),
-          decrypt_config->checksum(),
-          decrypt_config->data_offset(),
-          subsamples));
-    }
   }
 
   if (audio) {
-    const AAC& aac = runs_->audio_description().esds.aac;
-    if (!aac.ConvertEsdsToADTS(&frame_buf)) {
-      DLOG(ERROR) << "Failed to convert ESDS to ADTS";
+    if (!PrepareAACBuffer(runs_->audio_description().esds.aac,
+                          &frame_buf, &subsamples)) {
+      DLOG(ERROR) << "Failed to prepare AAC sample for decode";
       *err = true;
       return false;
     }
   }
 
+  if (decrypt_config.get() != NULL && !subsamples.empty()) {
+    decrypt_config.reset(new DecryptConfig(
+        decrypt_config->key_id(),
+        decrypt_config->iv(),
+        decrypt_config->checksum(),
+        decrypt_config->data_offset(),
+        subsamples));
+  }
+
   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());
   stream_buf->SetTimestamp(runs_->cts());
   stream_buf->SetDecodeTimestamp(runs_->dts());
@@ skipping 51 matching lines @@
   return !err;
 }
 
 void MP4StreamParser::ChangeState(State new_state) {
   DVLOG(2) << "Changing state: " << new_state;
   state_ = new_state;
 }
 
 }  // namespace mp4
 }  // namespace media