MP4 support for Common Encryption 'cbcs' scheme.

media/formats/mp4/mp4_stream_parser.cc

 // Copyright 2014 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/formats/mp4/mp4_stream_parser.h"
 
 #include <stddef.h>
 
 #include <limits>
 #include <memory>
 #include <utility>
 #include <vector>
 
 #include "base/callback_helpers.h"
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/time/time.h"
 #include "build/build_config.h"
 #include "media/base/audio_decoder_config.h"
+#include "media/base/encryption_scheme.h"
 #include "media/base/media_tracks.h"
 #include "media/base/media_util.h"
 #include "media/base/stream_parser_buffer.h"
 #include "media/base/text_track_config.h"
 #include "media/base/timestamp_constants.h"
 #include "media/base/video_decoder_config.h"
 #include "media/base/video_util.h"
 #include "media/formats/mp4/box_definitions.h"
 #include "media/formats/mp4/box_reader.h"
 #include "media/formats/mp4/es_descriptor.h"
 #include "media/formats/mp4/rcheck.h"
 #include "media/formats/mpeg/adts_constants.h"
 
 namespace media {
 namespace mp4 {
 
+namespace {
+
+EncryptionScheme GetEncryptionScheme(const ProtectionSchemeInfo& sinf) {
+  if (!sinf.HasSupportedScheme())
+    return Unencrypted();
+  FourCC fourCC = sinf.type.type;
+  EncryptionScheme::CipherMode mode = EncryptionScheme::CIPHER_MODE_UNENCRYPTED;
+  EncryptionScheme::Pattern pattern;
+  bool pattern_encryption = false;
+  switch (fourCC) {
+    case FOURCC_CENC:
+      mode = EncryptionScheme::CIPHER_MODE_AES_CTR;
+      break;
+#if BUILDFLAG(ENABLE_CENC_NEW_EDITIONS)
+    case FOURCC_CENS:
+      mode = EncryptionScheme::CIPHER_MODE_AES_CTR;
+      pattern_encryption = true;
+      break;
+    case FOURCC_CBC1:
+      mode = EncryptionScheme::CIPHER_MODE_AES_CBC;
+      break;
+    case FOURCC_CBCS:
+      mode = EncryptionScheme::CIPHER_MODE_AES_CBC;
+      pattern_encryption = true;
+      break;
+#endif
+    default:
+      break;

[ddorwin, 2016/05/24 23:25:03]

Should this be a DLOG that we don't recognize the scheme?

[dougsteed, 2016/05/25 17:23:21]

Done.

+  }
+#if BUILDFLAG(ENABLE_CENC_NEW_EDITIONS)
+  if (pattern_encryption) {
+    uint8_t crypt = sinf.info.track_encryption.default_crypt_byte_block;
+    uint8_t skip = sinf.info.track_encryption.default_skip_byte_block;
+    pattern = EncryptionScheme::Pattern(crypt, skip);
+  }
+#endif
+  return EncryptionScheme(mode, pattern);
+}
+}

[kqyang, 2016/05/23 20:57:34]

nit: }  // namespace

[dougsteed, 2016/05/25 17:23:21]

Done.

+
 MP4StreamParser::MP4StreamParser(const std::set<int>& audio_object_types,
                                  bool has_sbr)
     : state_(kWaitingForInit),
       moof_head_(0),
       mdat_tail_(0),
       highest_end_offset_(0),
       has_audio_(false),
       has_video_(false),
       audio_track_id_(0),
       video_track_id_(0),
@@ skipping 263 matching lines @@
         sample_format = kSampleFormatS32;
       } else {
         LOG(ERROR) << "Unsupported sample size.";
         return false;
       }
 
       is_audio_track_encrypted_ = entry.sinf.info.track_encryption.is_encrypted;
       DVLOG(1) << "is_audio_track_encrypted_: " << is_audio_track_encrypted_;
       audio_config.Initialize(
           codec, sample_format, channel_layout, sample_per_second, extra_data,
-          is_audio_track_encrypted_ ? AesCtrEncryptionScheme() : Unencrypted(),
+          is_audio_track_encrypted_ ? GetEncryptionScheme(entry.sinf)
+                                    : Unencrypted(),
           base::TimeDelta(), 0);
       has_audio_ = true;
       audio_track_id_ = track->header.track_id;
       media_tracks->AddAudioTrack(
           audio_config, base::UintToString(audio_track_id_), "main",
           track->media.handler.name, track->media.header.language());
       continue;
     }
 
     if (track->media.handler.type == kVideo) {
@@ skipping 31 matching lines @@
       }
 
       is_video_track_encrypted_ = entry.sinf.info.track_encryption.is_encrypted;
       DVLOG(1) << "is_video_track_encrypted_: " << is_video_track_encrypted_;
       video_config.Initialize(
           entry.video_codec, entry.video_codec_profile, PIXEL_FORMAT_YV12,
           COLOR_SPACE_HD_REC709, coded_size, visible_rect, natural_size,
           // No decoder-specific buffer needed for AVC;
           // SPS/PPS are embedded in the video stream
           EmptyExtraData(),
-          is_video_track_encrypted_ ? AesCtrEncryptionScheme() : Unencrypted());
+          is_video_track_encrypted_ ? GetEncryptionScheme(entry.sinf)
+                                    : Unencrypted());
       has_video_ = true;
       video_track_id_ = track->header.track_id;
       media_tracks->AddVideoTrack(
           video_config, base::UintToString(video_track_id_), "main",
           track->media.handler.name, track->media.header.language());
       continue;
     }
 
     // TODO(wolenetz): Investigate support in MSE and Chrome MSE for CEA 608/708
     // embedded caption data in video track. At time of init segment parsing, we
@@ skipping 185 matching lines @@
         !PrepareAACBuffer(runs_->audio_description().esds.aac,
                           &frame_buf, &subsamples)) {
       MEDIA_LOG(ERROR, media_log_) << "Failed to prepare AAC sample for decode";
       *err = true;
       return false;
     }
   }
 
   if (decrypt_config) {
     if (!subsamples.empty()) {
-    // Create a new config with the updated subsamples.
-    decrypt_config.reset(new DecryptConfig(
-        decrypt_config->key_id(),
-        decrypt_config->iv(),
-        subsamples));
+      // Create a new config with the updated subsamples.
+      decrypt_config.reset(new DecryptConfig(decrypt_config->key_id(),
+                                             decrypt_config->iv(), subsamples));
     }
     // else, use the existing config.
   } else if ((audio && is_audio_track_encrypted_) ||
              (video && is_video_track_encrypted_)) {
     // The media pipeline requires a DecryptConfig with an empty |iv|.
     // TODO(ddorwin): Refactor so we do not need a fake key ID ("1");
     decrypt_config.reset(
         new DecryptConfig("1", "", std::vector<SubsampleEntry>()));
   }
 
@@ skipping 106 matching lines @@
       runs.AdvanceSample();
     }
     runs.AdvanceRun();
   }
 
   return true;
 }
 
 }  // namespace mp4
 }  // namespace media