7 #include "packager/media/formats/mp4/encrypting_fragmenter.h"
11 #include "packager/media/base/aes_encryptor.h"
12 #include "packager/media/base/aes_pattern_cryptor.h"
13 #include "packager/media/base/buffer_reader.h"
14 #include "packager/media/base/key_source.h"
15 #include "packager/media/base/media_sample.h"
16 #include "packager/media/filters/nalu_reader.h"
17 #include "packager/media/filters/vp8_parser.h"
18 #include "packager/media/filters/vp9_parser.h"
19 #include "packager/media/formats/mp4/box_definitions.h"
21 namespace edash_packager {
26 const size_t kCencBlockSize = 16u;
30 void AddSubsamples(uint64_t clear_bytes,
31 uint64_t cipher_bytes,
32 std::vector<SubsampleEntry>* subsamples) {
33 CHECK_LT(cipher_bytes, std::numeric_limits<uint32_t>::max());
34 const uint64_t kUInt16Max = std::numeric_limits<uint16_t>::max();
35 while (clear_bytes > kUInt16Max) {
36 subsamples->push_back(SubsampleEntry(kUInt16Max, 0));
37 clear_bytes -= kUInt16Max;
40 if (clear_bytes > 0 || cipher_bytes > 0)
41 subsamples->push_back(SubsampleEntry(clear_bytes, cipher_bytes));
44 VideoCodec GetVideoCodec(
const StreamInfo& stream_info) {
45 if (stream_info.stream_type() != kStreamVideo)
46 return kUnknownVideoCodec;
47 const VideoStreamInfo& video_stream_info =
48 static_cast<const VideoStreamInfo&
>(stream_info);
49 return video_stream_info.codec();
52 uint8_t GetNaluLengthSize(
const StreamInfo& stream_info) {
53 if (stream_info.stream_type() != kStreamVideo)
56 const VideoStreamInfo& video_stream_info =
57 static_cast<const VideoStreamInfo&
>(stream_info);
58 return video_stream_info.nalu_length_size();
63 scoped_refptr<StreamInfo> info,
65 scoped_ptr<EncryptionKey> encryption_key,
67 FourCC protection_scheme,
68 uint8_t crypt_byte_block,
69 uint8_t skip_byte_block)
72 encryption_key_(encryption_key.Pass()),
73 nalu_length_size_(GetNaluLengthSize(*info)),
74 video_codec_(GetVideoCodec(*info)),
75 clear_time_(clear_time),
76 protection_scheme_(protection_scheme),
77 crypt_byte_block_(crypt_byte_block),
78 skip_byte_block_(skip_byte_block) {
79 DCHECK(encryption_key_);
80 switch (video_codec_) {
96 LOG(WARNING) <<
"Unknown video codec '" << video_codec_
97 <<
"', whole subsamples will be encrypted.";
101 EncryptingFragmenter::~EncryptingFragmenter() {}
105 if (!fragment_initialized()) {
111 Status status = EncryptSample(sample);
123 if (header_parser_ && !header_parser_->Initialize(info_->extra_data()))
124 return Status(error::MUXER_FAILURE,
"Fail to read SPS and PPS data.");
126 traf()->auxiliary_size.sample_info_sizes.clear();
127 traf()->auxiliary_offset.offsets.clear();
128 if (IsSubsampleEncryptionRequired()) {
129 traf()->sample_encryption.flags |=
130 SampleEncryption::kUseSubsampleEncryption;
132 traf()->sample_encryption.sample_encryption_entries.clear();
134 const bool enable_encryption = clear_time_ <= 0;
135 if (!enable_encryption) {
139 const uint32_t kClearSampleDescriptionIndex = 2;
141 traf()->header.flags |=
142 TrackFragmentHeader::kSampleDescriptionIndexPresentMask;
143 traf()->header.sample_description_index = kClearSampleDescriptionIndex;
150 DCHECK_LE(clear_time_, 0);
153 DCHECK_GT(clear_time_, 0);
154 clear_time_ -= fragment_duration();
160 bool enable_encryption) {
161 return (!enable_encryption || encryptor_) ? Status::OK :
CreateEncryptor();
166 traf()->auxiliary_offset.offsets.push_back(0);
169 const size_t per_sample_iv_size =
170 (protection_scheme_ == FOURCC_cbcs) ? 0 : encryptor_->iv().size();
171 traf()->sample_encryption.iv_size = per_sample_iv_size;
175 saiz.sample_count = traf()->runs[0].sample_sizes.size();
176 if (!saiz.sample_info_sizes.empty()) {
178 &saiz.default_sample_info_size)) {
179 saiz.default_sample_info_size = 0;
184 DCHECK(!IsSubsampleEncryptionRequired());
185 saiz.default_sample_info_size = per_sample_iv_size;
189 CHECK(!saiz.sample_info_sizes.empty() || saiz.default_sample_info_size != 0);
193 DCHECK(encryption_key_);
194 scoped_ptr<AesCryptor> encryptor;
195 switch (protection_scheme_) {
204 crypt_byte_block(), skip_byte_block(), AesCryptor::kDontUseConstantIv,
209 crypt_byte_block(), skip_byte_block(), AesCryptor::kUseConstantIv,
213 return Status(error::MUXER_FAILURE,
"Unsupported protection scheme.");
216 DCHECK(!encryption_key_->iv.empty());
217 const bool initialized =
218 encryptor->InitializeWithIv(encryption_key_->key, encryption_key_->iv);
220 return Status(error::MUXER_FAILURE,
"Failed to create the encryptor.");
221 encryptor_ = encryptor.Pass();
225 void EncryptingFragmenter::EncryptBytes(uint8_t* data, uint32_t size) {
227 CHECK(encryptor_->Crypt(data, size, data));
230 Status EncryptingFragmenter::EncryptSample(scoped_refptr<MediaSample> sample) {
233 SampleEncryptionEntry sample_encryption_entry;
235 if (protection_scheme_ != FOURCC_cbcs)
236 sample_encryption_entry.initialization_vector = encryptor_->iv();
237 uint8_t* data = sample->writable_data();
238 if (IsSubsampleEncryptionRequired()) {
240 std::vector<VPxFrameInfo> vpx_frames;
241 if (!vpx_parser_->Parse(sample->data(), sample->data_size(),
243 return Status(error::MUXER_FAILURE,
"Failed to parse vpx frame.");
246 const bool is_superframe = vpx_frames.size() > 1;
247 for (
const VPxFrameInfo& frame : vpx_frames) {
248 SubsampleEntry subsample;
249 subsample.clear_bytes = frame.uncompressed_header_size;
250 subsample.cipher_bytes =
251 frame.frame_size - frame.uncompressed_header_size;
259 if (is_superframe || protection_scheme_ == FOURCC_cbc1) {
260 const uint16_t misalign_bytes =
261 subsample.cipher_bytes % kCencBlockSize;
262 subsample.clear_bytes += misalign_bytes;
263 subsample.cipher_bytes -= misalign_bytes;
266 sample_encryption_entry.subsamples.push_back(subsample);
267 if (subsample.cipher_bytes > 0)
268 EncryptBytes(data + subsample.clear_bytes, subsample.cipher_bytes);
269 data += frame.frame_size;
272 const NaluReader::CodecType nalu_type =
273 (video_codec_ == kCodecHVC1 || video_codec_ == kCodecHEV1)
276 NaluReader reader(nalu_type, nalu_length_size_, data,
277 sample->data_size());
281 uint64_t accumulated_clear_bytes = 0;
284 NaluReader::Result result;
285 while ((result = reader.Advance(&nalu)) == NaluReader::kOk) {
286 if (nalu.is_video_slice()) {
290 const int64_t video_slice_header_size =
291 header_parser_ ? header_parser_->GetHeaderSize(nalu) : 0;
292 if (video_slice_header_size < 0)
293 return Status(error::MUXER_FAILURE,
"Failed to read slice header.");
295 uint64_t current_clear_bytes =
296 nalu.header_size() + video_slice_header_size;
297 uint64_t cipher_bytes = nalu.payload_size() - video_slice_header_size;
301 if (protection_scheme_ == FOURCC_cbc1) {
302 const uint16_t misalign_bytes = cipher_bytes % kCencBlockSize;
303 current_clear_bytes += misalign_bytes;
304 cipher_bytes -= misalign_bytes;
307 const uint8_t* nalu_data = nalu.data() + current_clear_bytes;
308 EncryptBytes(const_cast<uint8_t*>(nalu_data), cipher_bytes);
311 accumulated_clear_bytes + nalu_length_size_ + current_clear_bytes,
312 cipher_bytes, &sample_encryption_entry.subsamples);
313 accumulated_clear_bytes = 0;
316 accumulated_clear_bytes +=
317 nalu_length_size_ + nalu.header_size() + nalu.payload_size();
320 if (result != NaluReader::kEOStream)
321 return Status(error::MUXER_FAILURE,
"Failed to parse NAL units.");
322 AddSubsamples(accumulated_clear_bytes, 0,
323 &sample_encryption_entry.subsamples);
327 traf()->auxiliary_size.sample_info_sizes.push_back(
328 sample_encryption_entry.ComputeSize());
330 EncryptBytes(data, sample->data_size());
333 traf()->sample_encryption.sample_encryption_entries.push_back(
334 sample_encryption_entry);
335 encryptor_->UpdateIv();
339 bool EncryptingFragmenter::IsSubsampleEncryptionRequired() {
340 return vpx_parser_ || nalu_length_size_ != 0;