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();

[ddorwin, 2016/06/17 23:32:41]

Is that the best way to handle this? We know it is encrypted. Or is the caller
supposed to know to handle this as an unsupported scheme, in which case we
should comment this above this function?

[dougsteed, 2016/10/10 18:18:01]

Done.

+  FourCC fourCC = sinf.type.type;
+  EncryptionScheme::CipherMode mode = EncryptionScheme::CIPHER_MODE_UNENCRYPTED;
+  EncryptionScheme::Pattern pattern;
+  bool pattern_encryption = false;

[ddorwin, 2016/06/17 23:32:41]

nit: is_/uses_...

[dougsteed, 2016/10/10 18:18:02]

Done.

+  switch (fourCC) {
+    case FOURCC_CENC:
+      mode = EncryptionScheme::CIPHER_MODE_AES_CTR;
+      break;
+#if BUILDFLAG(ENABLE_CBCS_ENCRYPTION_SCHEME)
+    case FOURCC_CBCS:
+      mode = EncryptionScheme::CIPHER_MODE_AES_CBC;
+      pattern_encryption = true;
+      break;
+#endif
+    default:
+      DLOG(WARNING) << "Unsupported encryption scheme: " << fourCC;

[ddorwin, 2016/06/17 23:32:40]

Should this be a DCHECK based on line 40?

[dougsteed, 2016/10/10 18:18:02]

Done.

+      break;
+  }
+#if BUILDFLAG(ENABLE_CBCS_ENCRYPTION_SCHEME)
+  if (pattern_encryption) {
+    uint8_t crypt = sinf.info.track_encryption.default_crypt_byte_block;

[ddorwin, 2016/06/17 23:32:40]

ditto on "crypt"

[dougsteed, 2016/10/10 18:18:01]

as mentioned above, this is the term used in the standard.

+    uint8_t skip = sinf.info.track_encryption.default_skip_byte_block;
+    pattern = EncryptionScheme::Pattern(crypt, skip);
+  }
+#endif
+  return EncryptionScheme(mode, pattern);
+}
+
+}  // namespace
+
 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)

[ddorwin, 2016/06/17 23:32:40]

Continuing from line 41, we know it's encrypted, but if the scheme is not
recognized, we just say "unencrypted". We should probably fail in some way
rather than silently continuing, which will be harder to debug.

[dougsteed, 2016/10/10 18:18:01]

Done.

+                                    : 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