DASH Media Packaging SDK
 All Classes Namespaces Functions Variables Typedefs Enumerator
wvm_media_parser.cc
1 // Copyright 2014 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4 
5 #include "packager/media/formats/wvm/wvm_media_parser.h"
6 
7 #include <map>
8 #include <sstream>
9 #include <vector>
10 
11 #include "packager/base/stl_util.h"
12 #include "packager/base/strings/string_number_conversions.h"
13 #include "packager/media/base/aes_encryptor.h"
14 #include "packager/media/base/audio_stream_info.h"
15 #include "packager/media/base/key_source.h"
16 #include "packager/media/base/media_sample.h"
17 #include "packager/media/base/status.h"
18 #include "packager/media/base/video_stream_info.h"
19 #include "packager/media/filters/avc_decoder_configuration.h"
20 #include "packager/media/formats/mp2t/adts_header.h"
21 #include "packager/media/formats/mp4/aac_audio_specific_config.h"
22 #include "packager/media/formats/mp4/es_descriptor.h"
23 
24 #define HAS_HEADER_EXTENSION(x) ((x != 0xBC) && (x != 0xBE) && (x != 0xBF) \
25  && (x != 0xF0) && (x != 0xF2) && (x != 0xF8) \
26  && (x != 0xFF))
27 
28 namespace {
29 const uint32_t kMpeg2ClockRate = 90000;
30 const uint32_t kPesOptPts = 0x80;
31 const uint32_t kPesOptDts = 0x40;
32 const uint32_t kPesOptAlign = 0x04;
33 const uint32_t kPsmStreamId = 0xBC;
34 const uint32_t kPaddingStreamId = 0xBE;
35 const uint32_t kIndexMagic = 0x49444d69;
36 const uint32_t kIndexStreamId = 0xBF; // private_stream_2
37 const uint32_t kIndexVersion4HeaderSize = 12;
38 const uint32_t kEcmStreamId = 0xF0;
39 const uint32_t kV2MetadataStreamId = 0xF1; // EMM_stream
40 const uint32_t kScramblingBitsMask = 0x30;
41 const uint32_t kStartCode1 = 0x00;
42 const uint32_t kStartCode2 = 0x00;
43 const uint32_t kStartCode3 = 0x01;
44 const uint32_t kStartCode4Pack = 0xBA;
45 const uint32_t kStartCode4System = 0xBB;
46 const uint32_t kStartCode4ProgramEnd = 0xB9;
47 const uint32_t kPesStreamIdVideoMask = 0xF0;
48 const uint32_t kPesStreamIdVideo = 0xE0;
49 const uint32_t kPesStreamIdAudioMask = 0xE0;
50 const uint32_t kPesStreamIdAudio = 0xC0;
51 const uint32_t kVersion4 = 4;
52 const int kAdtsHeaderMinSize = 7;
53 const uint8_t kAacSampleSizeBits = 16;
54 // Applies to all video streams.
55 const uint8_t kNaluLengthSize = 4; // unit is bytes.
56 // Placeholder sampling frequency for all audio streams, which
57 // will be overwritten after filter parsing.
58 const uint32_t kDefaultSamplingFrequency = 100;
59 const uint16_t kEcmSizeBytes = 80;
60 const uint32_t kInitializationVectorSizeBytes = 16;
61 // ECM fields for processing.
62 const uint32_t kEcmContentKeySizeBytes = 16;
63 const uint32_t kEcmDCPFlagsSizeBytes = 3;
64 const uint32_t kEcmCCIFlagsSizeBytes = 1;
65 const uint32_t kEcmFlagsSizeBytes =
66  kEcmCCIFlagsSizeBytes + kEcmDCPFlagsSizeBytes;
67 const uint32_t kEcmPaddingSizeBytes = 12;
68 const uint32_t kAssetKeySizeBytes = 16;
69 // Default audio and video PES stream IDs.
70 const uint8_t kDefaultAudioStreamId = kPesStreamIdAudio;
71 const uint8_t kDefaultVideoStreamId = kPesStreamIdVideo;
72 
73 enum Type {
74  Type_void = 0,
75  Type_uint8 = 1,
76  Type_int8 = 2,
77  Type_uint16 = 3,
78  Type_int16 = 4,
79  Type_uint32 = 5,
80  Type_int32 = 6,
81  Type_uint64 = 7,
82  Type_int64 = 8,
83  Type_string = 9,
84  Type_BinaryData = 10
85 };
86 } // namespace
87 
88 namespace edash_packager {
89 namespace media {
90 namespace wvm {
91 
92 WvmMediaParser::WvmMediaParser()
93  : is_initialized_(false),
94  parse_state_(StartCode1),
95  is_psm_needed_(true),
96  skip_bytes_(0),
97  metadata_is_complete_(false),
98  current_program_id_(0),
99  pes_stream_id_(0),
100  prev_pes_stream_id_(0),
101  pes_packet_bytes_(0),
102  pes_flags_1_(0),
103  pes_flags_2_(0),
104  prev_pes_flags_1_(0),
105  pes_header_data_bytes_(0),
106  timestamp_(0),
107  pts_(0),
108  dts_(0),
109  index_program_id_(0),
110  media_sample_(NULL),
111  crypto_unit_start_pos_(0),
112  stream_id_count_(0),
113  decryption_key_source_(NULL) {
114 }
115 
116 WvmMediaParser::~WvmMediaParser() {}
117 
118 void WvmMediaParser::Init(const InitCB& init_cb,
119  const NewSampleCB& new_sample_cb,
120  KeySource* decryption_key_source) {
121  DCHECK(!is_initialized_);
122  DCHECK(!init_cb.is_null());
123  DCHECK(!new_sample_cb.is_null());
124  decryption_key_source_ = decryption_key_source;
125  init_cb_ = init_cb;
126  new_sample_cb_ = new_sample_cb;
127 }
128 
129 bool WvmMediaParser::Parse(const uint8_t* buf, int size) {
130  uint32_t num_bytes, prev_size;
131  num_bytes = prev_size = 0;
132  const uint8_t* read_ptr = buf;
133  const uint8_t* end = read_ptr + size;
134 
135  while (read_ptr < end) {
136  switch (parse_state_) {
137  case StartCode1:
138  if (*read_ptr == kStartCode1) {
139  parse_state_ = StartCode2;
140  }
141  break;
142  case StartCode2:
143  if (*read_ptr == kStartCode2) {
144  parse_state_ = StartCode3;
145  } else {
146  parse_state_ = StartCode1;
147  }
148  break;
149  case StartCode3:
150  if (*read_ptr == kStartCode3) {
151  parse_state_ = StartCode4;
152  } else {
153  parse_state_ = StartCode1;
154  }
155  break;
156  case StartCode4:
157  switch (*read_ptr) {
158  case kStartCode4Pack:
159  parse_state_ = PackHeader1;
160  break;
161  case kStartCode4System:
162  parse_state_ = SystemHeader1;
163  break;
164  case kStartCode4ProgramEnd:
165  parse_state_ = ProgramEnd;
166  continue;
167  default:
168  parse_state_ = PesStreamId;
169  continue;
170  }
171  break;
172  case PackHeader1:
173  parse_state_ = PackHeader2;
174  break;
175  case PackHeader2:
176  parse_state_ = PackHeader3;
177  break;
178  case PackHeader3:
179  parse_state_ = PackHeader4;
180  break;
181  case PackHeader4:
182  parse_state_ = PackHeader5;
183  break;
184  case PackHeader5:
185  parse_state_ = PackHeader6;
186  break;
187  case PackHeader6:
188  parse_state_ = PackHeader7;
189  break;
190  case PackHeader7:
191  parse_state_ = PackHeader8;
192  break;
193  case PackHeader8:
194  parse_state_ = PackHeader9;
195  break;
196  case PackHeader9:
197  parse_state_ = PackHeader10;
198  break;
199  case PackHeader10:
200  skip_bytes_ = *read_ptr & 0x07;
201  parse_state_ = PackHeaderStuffingSkip;
202  break;
203  case SystemHeader1:
204  skip_bytes_ = *read_ptr;
205  skip_bytes_ <<= 8;
206  parse_state_ = SystemHeader2;
207  break;
208  case SystemHeader2:
209  skip_bytes_ |= *read_ptr;
210  parse_state_ = SystemHeaderSkip;
211  break;
212  case PackHeaderStuffingSkip:
213  if ((end - read_ptr) >= (int32_t)skip_bytes_) {
214  read_ptr += skip_bytes_;
215  skip_bytes_ = 0;
216  parse_state_ = StartCode1;
217  } else {
218  skip_bytes_ -= (end - read_ptr);
219  read_ptr = end;
220  }
221  continue;
222  case SystemHeaderSkip:
223  if ((end - read_ptr) >= (int32_t)skip_bytes_) {
224  read_ptr += skip_bytes_;
225  skip_bytes_ = 0;
226  parse_state_ = StartCode1;
227  } else {
228  uint32_t remaining_size = end - read_ptr;
229  skip_bytes_ -= remaining_size;
230  read_ptr = end;
231  }
232  continue;
233  case PesStreamId:
234  pes_stream_id_ = *read_ptr;
235  if (!metadata_is_complete_ &&
236  (pes_stream_id_ != kPsmStreamId) &&
237  (pes_stream_id_ != kIndexStreamId) &&
238  (pes_stream_id_ != kEcmStreamId) &&
239  (pes_stream_id_ != kV2MetadataStreamId) &&
240  (pes_stream_id_ != kPaddingStreamId)) {
241  metadata_is_complete_ = true;
242  }
243  parse_state_ = PesPacketLength1;
244  break;
245  case PesPacketLength1:
246  pes_packet_bytes_ = *read_ptr;
247  pes_packet_bytes_ <<= 8;
248  parse_state_ = PesPacketLength2;
249  break;
250  case PesPacketLength2:
251  pes_packet_bytes_ |= *read_ptr;
252  if (HAS_HEADER_EXTENSION(pes_stream_id_)) {
253  parse_state_ = PesExtension1;
254  } else {
255  pes_flags_1_ = pes_flags_2_ = 0;
256  pes_header_data_bytes_ = 0;
257  parse_state_ = PesPayload;
258  }
259  break;
260  case PesExtension1:
261  prev_pes_flags_1_ = pes_flags_1_;
262  pes_flags_1_ = *read_ptr;
263  --pes_packet_bytes_;
264  parse_state_ = PesExtension2;
265  break;
266  case PesExtension2:
267  pes_flags_2_ = *read_ptr;
268  --pes_packet_bytes_;
269  parse_state_ = PesExtension3;
270  break;
271  case PesExtension3:
272  pes_header_data_bytes_ = *read_ptr;
273  --pes_packet_bytes_;
274  if (pes_flags_2_ & kPesOptPts) {
275  parse_state_ = Pts1;
276  } else {
277  parse_state_ = PesHeaderData;
278  }
279  break;
280  case Pts1:
281  timestamp_ = (*read_ptr & 0x0E);
282  --pes_header_data_bytes_;
283  --pes_packet_bytes_;
284  parse_state_ = Pts2;
285  break;
286  case Pts2:
287  timestamp_ <<= 7;
288  timestamp_ |= *read_ptr;
289  --pes_header_data_bytes_;
290  --pes_packet_bytes_;
291  parse_state_ = Pts3;
292  break;
293  case Pts3:
294  timestamp_ <<= 7;
295  timestamp_ |= *read_ptr >> 1;
296  --pes_header_data_bytes_;
297  --pes_packet_bytes_;
298  parse_state_ = Pts4;
299  break;
300  case Pts4:
301  timestamp_ <<= 8;
302  timestamp_ |= *read_ptr;
303  --pes_header_data_bytes_;
304  --pes_packet_bytes_;
305  parse_state_ = Pts5;
306  break;
307  case Pts5:
308  timestamp_ <<= 7;
309  timestamp_ |= *read_ptr >> 1;
310  pts_ = timestamp_;
311  --pes_header_data_bytes_;
312  --pes_packet_bytes_;
313  if (pes_flags_2_ & kPesOptDts) {
314  parse_state_ = Dts1;
315  } else {
316  dts_ = pts_;
317  parse_state_ = PesHeaderData;
318  }
319  break;
320  case Dts1:
321  timestamp_ = (*read_ptr & 0x0E);
322  --pes_header_data_bytes_;
323  --pes_packet_bytes_;
324  parse_state_ = Dts2;
325  break;
326  case Dts2:
327  timestamp_ <<= 7;
328  timestamp_ |= *read_ptr;
329  --pes_header_data_bytes_;
330  --pes_packet_bytes_;
331  parse_state_ = Dts3;
332  break;
333  case Dts3:
334  timestamp_ <<= 7;
335  timestamp_ |= *read_ptr >> 1;
336  --pes_header_data_bytes_;
337  --pes_packet_bytes_;
338  parse_state_ = Dts4;
339  break;
340  case Dts4:
341  timestamp_ <<= 8;
342  timestamp_ |= *read_ptr;
343  --pes_header_data_bytes_;
344  --pes_packet_bytes_;
345  parse_state_ = Dts5;
346  break;
347  case Dts5:
348  timestamp_ <<= 7;
349  timestamp_ |= *read_ptr >> 1;
350  dts_ = timestamp_;
351  --pes_header_data_bytes_;
352  --pes_packet_bytes_;
353  parse_state_ = PesHeaderData;
354  break;
355  case PesHeaderData:
356  num_bytes = end - read_ptr;
357  if (num_bytes >= pes_header_data_bytes_) {
358  num_bytes = pes_header_data_bytes_;
359  parse_state_ = PesPayload;
360  }
361  pes_header_data_bytes_ -= num_bytes;
362  pes_packet_bytes_ -= num_bytes;
363  read_ptr += num_bytes;
364  continue;
365  case PesPayload:
366  switch (pes_stream_id_) {
367  case kPsmStreamId:
368  psm_data_.clear();
369  parse_state_ = PsmPayload;
370  continue;
371  case kPaddingStreamId:
372  parse_state_ = Padding;
373  continue;
374  case kEcmStreamId:
375  ecm_.clear();
376  parse_state_ = EcmPayload;
377  continue;
378  case kIndexStreamId:
379  parse_state_ = IndexPayload;
380  continue;
381  default:
382  if (!DemuxNextPes(false)) {
383  return false;
384  }
385  parse_state_ = EsPayload;
386  }
387  continue;
388  case PsmPayload:
389  num_bytes = end - read_ptr;
390  if (num_bytes >= pes_packet_bytes_) {
391  num_bytes = pes_packet_bytes_;
392  parse_state_ = StartCode1;
393  }
394  if (num_bytes > 0) {
395  pes_packet_bytes_ -= num_bytes;
396  prev_size = psm_data_.size();
397  psm_data_.resize(prev_size + num_bytes);
398  memcpy(&psm_data_[prev_size], read_ptr, num_bytes);
399  }
400  read_ptr += num_bytes;
401  continue;
402  case EcmPayload:
403  num_bytes = end - read_ptr;
404  if (num_bytes >= pes_packet_bytes_) {
405  num_bytes = pes_packet_bytes_;
406  parse_state_ = StartCode1;
407  }
408  if (num_bytes > 0) {
409  pes_packet_bytes_ -= num_bytes;
410  prev_size = ecm_.size();
411  ecm_.resize(prev_size + num_bytes);
412  memcpy(&ecm_[prev_size], read_ptr, num_bytes);
413  }
414  if ((pes_packet_bytes_ == 0) && !ecm_.empty()) {
415  if (!ProcessEcm()) {
416  return(false);
417  }
418  }
419  read_ptr += num_bytes;
420  continue;
421  case IndexPayload:
422  num_bytes = end - read_ptr;
423  if (num_bytes >= pes_packet_bytes_) {
424  num_bytes = pes_packet_bytes_;
425  parse_state_ = StartCode1;
426  }
427  if (num_bytes > 0) {
428  pes_packet_bytes_ -= num_bytes;
429  prev_size = index_data_.size();
430  index_data_.resize(prev_size + num_bytes);
431  memcpy(&index_data_[prev_size], read_ptr, num_bytes);
432  }
433  if (pes_packet_bytes_ == 0 && !index_data_.empty()) {
434  if (!metadata_is_complete_) {
435  if (!ParseIndexEntry()) {
436  return false;
437  }
438  }
439  }
440  read_ptr += num_bytes;
441  continue;
442  case EsPayload:
443  num_bytes = end - read_ptr;
444  if (num_bytes >= pes_packet_bytes_) {
445  num_bytes = pes_packet_bytes_;
446  parse_state_ = StartCode1;
447  }
448  pes_packet_bytes_ -= num_bytes;
449  if (pes_stream_id_ != kV2MetadataStreamId) {
450  sample_data_.resize(sample_data_.size() + num_bytes);
451  memcpy(&sample_data_[sample_data_.size() - num_bytes], read_ptr,
452  num_bytes);
453  }
454  prev_pes_stream_id_ = pes_stream_id_;
455  read_ptr += num_bytes;
456  continue;
457  case Padding:
458  num_bytes = end - read_ptr;
459  if (num_bytes >= pes_packet_bytes_) {
460  num_bytes = pes_packet_bytes_;
461  parse_state_ = StartCode1;
462  }
463  pes_packet_bytes_ -= num_bytes;
464  read_ptr += num_bytes;
465  continue;
466  case ProgramEnd:
467  parse_state_ = StartCode1;
468  metadata_is_complete_ = true;
469  if (!DemuxNextPes(true)) {
470  return false;
471  }
472  Flush();
473  // Reset.
474  dts_ = pts_ = 0;
475  parse_state_ = StartCode1;
476  prev_media_sample_data_.Reset();
477  current_program_id_++;
478  ecm_.clear();
479  index_data_.clear();
480  psm_data_.clear();
481  break;
482  default:
483  break;
484  }
485  ++read_ptr;
486  }
487  return true;
488 }
489 
490 bool WvmMediaParser::EmitLastSample(uint32_t stream_id,
491  scoped_refptr<MediaSample>& new_sample) {
492  std::string key = base::UintToString(current_program_id_)
493  .append(":")
494  .append(base::UintToString(stream_id));
495  std::map<std::string, uint32_t>::iterator it =
496  program_demux_stream_map_.find(key);
497  if (it == program_demux_stream_map_.end())
498  return false;
499  return EmitSample(stream_id, (*it).second, new_sample, true);
500 }
501 
502 bool WvmMediaParser::EmitPendingSamples() {
503  // Emit queued samples which were built when not initialized.
504  while (!media_sample_queue_.empty()) {
505  DemuxStreamIdMediaSample& demux_stream_media_sample =
506  media_sample_queue_.front();
507  if (!EmitSample(demux_stream_media_sample.parsed_audio_or_video_stream_id,
508  demux_stream_media_sample.demux_stream_id,
509  demux_stream_media_sample.media_sample,
510  false)) {
511  return false;
512  }
513  media_sample_queue_.pop_front();
514  }
515  return true;
516 }
517 
518 void WvmMediaParser::Flush() {
519  // Flush the last audio and video sample for current program.
520  // Reset the streamID when successfully emitted.
521  if (prev_media_sample_data_.audio_sample != NULL) {
522  if (!EmitLastSample(prev_pes_stream_id_,
523  prev_media_sample_data_.audio_sample)) {
524  LOG(ERROR) << "Did not emit last sample for audio stream with ID = "
525  << prev_pes_stream_id_;
526  }
527  }
528  if (prev_media_sample_data_.video_sample != NULL) {
529  if (!EmitLastSample(prev_pes_stream_id_,
530  prev_media_sample_data_.video_sample)) {
531  LOG(ERROR) << "Did not emit last sample for video stream with ID = "
532  << prev_pes_stream_id_;
533  }
534  }
535 }
536 
537 bool WvmMediaParser::ParseIndexEntry() {
538  // Do not parse index entry at the beginning of any track *after* the first
539  // track.
540  if (current_program_id_ > 0) {
541  return true;
542  }
543  uint32_t index_size = 0;
544  if (index_data_.size() < kIndexVersion4HeaderSize) {
545  return false;
546  }
547 
548  const uint8_t* read_ptr = vector_as_array(&index_data_);
549  if (ntohlFromBuffer(read_ptr) != kIndexMagic) {
550  index_data_.clear();
551  return false;
552  }
553  read_ptr += 4;
554 
555  uint32_t version = ntohlFromBuffer(read_ptr);
556  read_ptr += 4;
557  if (version == kVersion4) {
558  index_size = kIndexVersion4HeaderSize + ntohlFromBuffer(read_ptr);
559  if (index_data_.size() < index_size) {
560  // We do not yet have the full index. Keep accumulating index data.
561  return true;
562  }
563  read_ptr += sizeof(uint32_t);
564 
565  // Index metadata
566  uint32_t index_metadata_max_size = index_size - kIndexVersion4HeaderSize;
567  if (index_metadata_max_size < sizeof(uint8_t)) {
568  index_data_.clear();
569  return false;
570  }
571 
572  uint64_t track_duration = 0;
573  int16_t trick_play_rate = 0;
574  uint32_t sampling_frequency = kDefaultSamplingFrequency;
575  uint32_t time_scale = kMpeg2ClockRate;
576  uint16_t video_width = 0;
577  uint16_t video_height = 0;
578  uint32_t pixel_width = 0;
579  uint32_t pixel_height = 0;
580  uint8_t nalu_length_size = kNaluLengthSize;
581  uint8_t num_channels = 0;
582  int audio_pes_stream_id = 0;
583  int video_pes_stream_id = 0;
584  bool has_video = false;
585  bool has_audio = false;
586  std::vector<uint8_t> audio_codec_config;
587  std::vector<uint8_t> video_codec_config;
588  uint8_t num_index_entries = *read_ptr;
589  ++read_ptr;
590  --index_metadata_max_size;
591 
592  for (uint8_t idx = 0; idx < num_index_entries; ++idx) {
593  if (index_metadata_max_size < (2 * sizeof(uint8_t)) + sizeof(uint32_t)) {
594  return false;
595  }
596  uint8_t tag = *read_ptr;
597  ++read_ptr;
598  uint8_t type = *read_ptr;
599  ++read_ptr;
600  uint32_t length = ntohlFromBuffer(read_ptr);
601  read_ptr += sizeof(uint32_t);
602  index_metadata_max_size -= (2 * sizeof(uint8_t)) + sizeof(uint32_t);
603  if (index_metadata_max_size < length) {
604  return false;
605  }
606  int64_t value = 0;
607  Tag tagtype = Unset;
608  std::vector<uint8_t> binary_data;
609  switch (Type(type)) {
610  case Type_uint8:
611  if (length == sizeof(uint8_t)) {
612  tagtype = GetTag(tag, length, read_ptr, &value);
613  } else {
614  return false;
615  }
616  break;
617  case Type_int8:
618  if (length == sizeof(int8_t)) {
619  tagtype = GetTag(tag, length, read_ptr, &value);
620  } else {
621  return false;
622  }
623  break;
624  case Type_uint16:
625  if (length == sizeof(uint16_t)) {
626  tagtype = GetTag(tag, length, read_ptr, &value);
627  } else {
628  return false;
629  }
630  break;
631  case Type_int16:
632  if (length == sizeof(int16_t)) {
633  tagtype = GetTag(tag, length, read_ptr, &value);
634  } else {
635  return false;
636  }
637  break;
638  case Type_uint32:
639  if (length == sizeof(uint32_t)) {
640  tagtype = GetTag(tag, length, read_ptr, &value);
641  } else {
642  return false;
643  }
644  break;
645  case Type_int32:
646  if (length == sizeof(int32_t)) {
647  tagtype = GetTag(tag, length, read_ptr, &value);
648  } else {
649  return false;
650  }
651  break;
652  case Type_uint64:
653  if (length == sizeof(uint64_t)) {
654  tagtype = GetTag(tag, length, read_ptr, &value);
655  } else {
656  return false;
657  }
658  break;
659  case Type_int64:
660  if (length == sizeof(int64_t)) {
661  tagtype = GetTag(tag, length, read_ptr, &value);
662  } else {
663  return false;
664  }
665  break;
666  case Type_string:
667  case Type_BinaryData:
668  binary_data.assign(read_ptr, read_ptr + length);
669  tagtype = Tag(tag);
670  break;
671  default:
672  break;
673  }
674 
675  switch (tagtype) {
676  case TrackDuration:
677  track_duration = value;
678  break;
679  case TrackTrickPlayRate:
680  trick_play_rate = value;
681  break;
682  case VideoStreamId:
683  video_pes_stream_id = value;
684  break;
685  case AudioStreamId:
686  audio_pes_stream_id = value;
687  break;
688  case VideoWidth:
689  video_width = (uint16_t)value;
690  break;
691  case VideoHeight:
692  video_height = (uint16_t)value;
693  break;
694  case AudioNumChannels:
695  num_channels = (uint8_t)value;
696  break;
697  case VideoType:
698  has_video = true;
699  break;
700  case AudioType:
701  has_audio = true;
702  break;
703  case VideoPixelWidth:
704  pixel_width = static_cast<uint32_t>(value);
705  break;
706  case VideoPixelHeight:
707  pixel_height = static_cast<uint32_t>(value);
708  break;
709  case Audio_EsDescriptor: {
710  mp4::ESDescriptor descriptor;
711  if (!descriptor.Parse(binary_data)) {
712  LOG(ERROR) <<
713  "Could not extract AudioSpecificConfig from ES_Descriptor";
714  return false;
715  }
716  audio_codec_config = descriptor.decoder_specific_info();
717  break;
718  }
719  case Audio_EC3SpecificData:
720  case Audio_DtsSpecificData:
721  case Audio_AC3SpecificData:
722  LOG(ERROR) << "Audio type not supported.";
723  return false;
724  case AVCDecoderConfigurationRecord:
725  video_codec_config = binary_data;
726  break;
727  default:
728  break;
729  }
730 
731  read_ptr += length;
732  index_metadata_max_size -= length;
733  }
734  // End Index metadata
735  index_size = read_ptr - vector_as_array(&index_data_);
736 
737  if (has_video) {
738  VideoCodec video_codec = kCodecH264;
739  stream_infos_.push_back(new VideoStreamInfo(
740  stream_id_count_, time_scale, track_duration, video_codec,
741  std::string(), std::string(), video_width, video_height,
742  pixel_width, pixel_height, trick_play_rate, nalu_length_size,
743  vector_as_array(&video_codec_config), video_codec_config.size(),
744  true));
745  program_demux_stream_map_[base::UintToString(index_program_id_) + ":" +
746  base::UintToString(video_pes_stream_id ?
747  video_pes_stream_id :
748  kDefaultVideoStreamId)] =
749  stream_id_count_++;
750  }
751  if (has_audio) {
752  AudioCodec audio_codec = kCodecAAC;
753  stream_infos_.push_back(new AudioStreamInfo(
754  stream_id_count_, time_scale, track_duration, audio_codec,
755  std::string(), std::string(), kAacSampleSizeBits, num_channels,
756  sampling_frequency, vector_as_array(&audio_codec_config),
757  audio_codec_config.size(), true));
758  program_demux_stream_map_[base::UintToString(index_program_id_) + ":" +
759  base::UintToString(audio_pes_stream_id ?
760  audio_pes_stream_id :
761  kDefaultAudioStreamId)] =
762  stream_id_count_++;
763  }
764  }
765 
766  index_program_id_++;
767  index_data_.clear();
768  return true;
769 }
770 
771 bool WvmMediaParser::DemuxNextPes(bool is_program_end) {
772  bool output_encrypted_sample = false;
773  if (!sample_data_.empty() && (prev_pes_flags_1_ & kScramblingBitsMask)) {
774  // Decrypt crypto unit.
775  if (!content_decryptor_) {
776  output_encrypted_sample = true;
777  } else {
778  content_decryptor_->Decrypt(&sample_data_[crypto_unit_start_pos_],
779  sample_data_.size() - crypto_unit_start_pos_,
780  &sample_data_[crypto_unit_start_pos_]);
781  }
782  }
783  // Demux media sample if we are at program end or if we are not at a
784  // continuation PES.
785  if ((pes_flags_2_ & kPesOptPts) || is_program_end) {
786  if (!sample_data_.empty()) {
787  if (!Output(output_encrypted_sample)) {
788  return false;
789  }
790  }
791  StartMediaSampleDemux();
792  }
793 
794  crypto_unit_start_pos_ = sample_data_.size();
795  return true;
796 }
797 
798 void WvmMediaParser::StartMediaSampleDemux() {
799  bool is_key_frame = ((pes_flags_1_ & kPesOptAlign) != 0);
800  media_sample_ = MediaSample::CreateEmptyMediaSample();
801  media_sample_->set_dts(dts_);
802  media_sample_->set_pts(pts_);
803  media_sample_->set_is_key_frame(is_key_frame);
804 
805  sample_data_.clear();
806 }
807 
808 bool WvmMediaParser::Output(bool output_encrypted_sample) {
809  if (output_encrypted_sample) {
810  media_sample_->set_data(vector_as_array(&sample_data_),
811  sample_data_.size());
812  media_sample_->set_is_encrypted(true);
813  } else {
814  if ((prev_pes_stream_id_ & kPesStreamIdVideoMask) == kPesStreamIdVideo) {
815  // Convert video stream to unit stream and get config.
816  std::vector<uint8_t> nal_unit_stream;
817  if (!byte_to_unit_stream_converter_.ConvertByteStreamToNalUnitStream(
818  vector_as_array(&sample_data_), sample_data_.size(),
819  &nal_unit_stream)) {
820  LOG(ERROR) << "Could not convert h.264 byte stream sample";
821  return false;
822  }
823  media_sample_->set_data(nal_unit_stream.data(), nal_unit_stream.size());
824  if (!is_initialized_) {
825  // Set extra data for video stream from AVC Decoder Config Record.
826  // Also, set codec string from the AVC Decoder Config Record.
827  std::vector<uint8_t> decoder_config_record;
828  byte_to_unit_stream_converter_.GetAVCDecoderConfigurationRecord(
829  &decoder_config_record);
830  for (uint32_t i = 0; i < stream_infos_.size(); i++) {
831  if (stream_infos_[i]->stream_type() == media::kStreamVideo &&
832  stream_infos_[i]->codec_string().empty()) {
833  const std::vector<uint8_t>* stream_config;
834  if (stream_infos_[i]->extra_data().empty()) {
835  // Decoder config record not available for stream. Use the one
836  // computed from the first video stream.
837  stream_infos_[i]->set_extra_data(decoder_config_record);
838  stream_config = &decoder_config_record;
839  } else {
840  // Use stream-specific config record.
841  stream_config = &stream_infos_[i]->extra_data();
842  }
843  DCHECK(stream_config);
844 
845  VideoStreamInfo* video_stream_info =
846  reinterpret_cast<VideoStreamInfo*>(stream_infos_[i].get());
847  AVCDecoderConfiguration avc_config;
848  if (!avc_config.Parse(*stream_config)) {
849  LOG(WARNING) << "Failed to parse AVCDecoderConfigurationRecord. "
850  "Using computed configuration record instead.";
851  video_stream_info->set_extra_data(decoder_config_record);
852  if (!avc_config.Parse(decoder_config_record)) {
853  LOG(ERROR) << "Failed to parse AVCDecoderConfigurationRecord.";
854  return false;
855  }
856  }
857  video_stream_info->set_codec_string(avc_config.GetCodecString());
858 
859  if (avc_config.pixel_width() != video_stream_info->pixel_width() ||
860  avc_config.pixel_height() !=
861  video_stream_info->pixel_height()) {
862  LOG_IF(WARNING, video_stream_info->pixel_width() != 0 ||
863  video_stream_info->pixel_height() != 0)
864  << "Pixel aspect ratio in WVM metadata ("
865  << video_stream_info->pixel_width() << ","
866  << video_stream_info->pixel_height()
867  << ") does not match with SAR in "
868  "AVCDecoderConfigurationRecord ("
869  << avc_config.pixel_width() << ","
870  << avc_config.pixel_height()
871  << "). Use AVCDecoderConfigurationRecord.";
872  video_stream_info->set_pixel_width(avc_config.pixel_width());
873  video_stream_info->set_pixel_height(avc_config.pixel_height());
874  }
875  if (avc_config.coded_width() != video_stream_info->width() ||
876  avc_config.coded_height() != video_stream_info->height()) {
877  LOG(WARNING) << "Resolution in WVM metadata ("
878  << video_stream_info->width() << ","
879  << video_stream_info->height()
880  << ") does not match with resolution in "
881  "AVCDecoderConfigurationRecord ("
882  << avc_config.coded_width() << ","
883  << avc_config.coded_height()
884  << "). Use AVCDecoderConfigurationRecord.";
885  video_stream_info->set_width(avc_config.coded_width());
886  video_stream_info->set_height(avc_config.coded_height());
887  }
888  }
889  }
890  }
891  } else if ((prev_pes_stream_id_ & kPesStreamIdAudioMask) ==
892  kPesStreamIdAudio) {
893  // Set data on the audio stream.
894  int frame_size = media::mp2t::AdtsHeader::GetAdtsFrameSize(
895  vector_as_array(&sample_data_), kAdtsHeaderMinSize);
896  media::mp2t::AdtsHeader adts_header;
897  const uint8_t* frame_ptr = vector_as_array(&sample_data_);
898  if (!adts_header.Parse(frame_ptr, frame_size)) {
899  LOG(ERROR) << "Could not parse ADTS header";
900  return false;
901  }
902  size_t header_size = adts_header.GetAdtsHeaderSize(frame_ptr,
903  frame_size);
904  media_sample_->set_data(frame_ptr + header_size,
905  frame_size - header_size);
906  if (!is_initialized_) {
907  for (uint32_t i = 0; i < stream_infos_.size(); i++) {
908  if (stream_infos_[i]->stream_type() == media::kStreamAudio &&
909  stream_infos_[i]->codec_string().empty()) {
910  AudioStreamInfo* audio_stream_info =
911  reinterpret_cast<AudioStreamInfo*>(stream_infos_[i].get());
912  if (audio_stream_info->extra_data().empty()) {
913  // Set AudioStreamInfo fields using information from the ADTS
914  // header.
915  audio_stream_info->set_sampling_frequency(
916  adts_header.GetSamplingFrequency());
917  std::vector<uint8_t> audio_specific_config;
918  if (!adts_header.GetAudioSpecificConfig(&audio_specific_config)) {
919  LOG(ERROR) << "Could not compute AACaudiospecificconfig";
920  return false;
921  }
922  audio_stream_info->set_extra_data(audio_specific_config);
923  audio_stream_info->set_codec_string(
924  AudioStreamInfo::GetCodecString(
925  kCodecAAC, adts_header.GetObjectType()));
926  } else {
927  // Set AudioStreamInfo fields using information from the
928  // AACAudioSpecificConfig record.
929  mp4::AACAudioSpecificConfig aac_config;
930  if (!aac_config.Parse(stream_infos_[i]->extra_data())) {
931  LOG(ERROR) << "Could not parse AACAudioSpecificconfig";
932  return false;
933  }
934  audio_stream_info->set_sampling_frequency(aac_config.frequency());
935  audio_stream_info->set_codec_string(
936  AudioStreamInfo::GetCodecString(
937  kCodecAAC, aac_config.audio_object_type()));
938  }
939  }
940  }
941  }
942  }
943  }
944 
945  if (!is_initialized_) {
946  bool all_streams_have_config = true;
947  // Check if all collected stream infos have extra_data set.
948  for (uint32_t i = 0; i < stream_infos_.size(); i++) {
949  if (stream_infos_[i]->codec_string().empty()) {
950  all_streams_have_config = false;
951  break;
952  }
953  }
954  if (all_streams_have_config) {
955  init_cb_.Run(stream_infos_);
956  is_initialized_ = true;
957  }
958  }
959 
960  DCHECK_GT(media_sample_->data_size(), 0UL);
961  std::string key = base::UintToString(current_program_id_).append(":")
962  .append(base::UintToString(prev_pes_stream_id_));
963  std::map<std::string, uint32_t>::iterator it =
964  program_demux_stream_map_.find(key);
965  if (it == program_demux_stream_map_.end()) {
966  // TODO(ramjic): Log error message here and in other error cases through
967  // this method.
968  return false;
969  }
970  DemuxStreamIdMediaSample demux_stream_media_sample;
971  demux_stream_media_sample.parsed_audio_or_video_stream_id =
972  prev_pes_stream_id_;
973  demux_stream_media_sample.demux_stream_id = (*it).second;
974  demux_stream_media_sample.media_sample = media_sample_;
975  // Check if sample can be emitted.
976  if (!is_initialized_) {
977  media_sample_queue_.push_back(demux_stream_media_sample);
978  } else {
979  // flush the sample queue and emit all queued samples.
980  while (!media_sample_queue_.empty()) {
981  if (!EmitPendingSamples())
982  return false;
983  }
984  // Emit current sample.
985  if (!EmitSample(prev_pes_stream_id_, (*it).second, media_sample_, false))
986  return false;
987  }
988  return true;
989 }
990 
991 bool WvmMediaParser::EmitSample(uint32_t parsed_audio_or_video_stream_id,
992  uint32_t stream_id,
993  scoped_refptr<MediaSample>& new_sample,
994  bool isLastSample) {
995  DCHECK(new_sample);
996  if (isLastSample) {
997  if ((parsed_audio_or_video_stream_id & kPesStreamIdVideoMask) ==
998  kPesStreamIdVideo) {
999  new_sample->set_duration(prev_media_sample_data_.video_sample_duration);
1000  } else if ((parsed_audio_or_video_stream_id & kPesStreamIdAudioMask) ==
1001  kPesStreamIdAudio) {
1002  new_sample->set_duration(prev_media_sample_data_.audio_sample_duration);
1003  }
1004  if (!new_sample_cb_.Run(stream_id, new_sample)) {
1005  LOG(ERROR) << "Failed to process the last sample.";
1006  return false;
1007  }
1008  return true;
1009  }
1010 
1011  // Cannot emit current sample. Compute duration first and then,
1012  // emit previous sample.
1013  if ((parsed_audio_or_video_stream_id & kPesStreamIdVideoMask) ==
1014  kPesStreamIdVideo) {
1015  if (prev_media_sample_data_.video_sample == NULL) {
1016  prev_media_sample_data_.video_sample = new_sample;
1017  prev_media_sample_data_.video_stream_id = stream_id;
1018  return true;
1019  }
1020  prev_media_sample_data_.video_sample->set_duration(
1021  new_sample->dts() - prev_media_sample_data_.video_sample->dts());
1022  prev_media_sample_data_.video_sample_duration =
1023  prev_media_sample_data_.video_sample->duration();
1024  if (!new_sample_cb_.Run(prev_media_sample_data_.video_stream_id,
1025  prev_media_sample_data_.video_sample)) {
1026  LOG(ERROR) << "Failed to process the video sample.";
1027  return false;
1028  }
1029  prev_media_sample_data_.video_sample = new_sample;
1030  prev_media_sample_data_.video_stream_id = stream_id;
1031  } else if ((parsed_audio_or_video_stream_id & kPesStreamIdAudioMask) ==
1032  kPesStreamIdAudio) {
1033  if (prev_media_sample_data_.audio_sample == NULL) {
1034  prev_media_sample_data_.audio_sample = new_sample;
1035  prev_media_sample_data_.audio_stream_id = stream_id;
1036  return true;
1037  }
1038  prev_media_sample_data_.audio_sample->set_duration(
1039  new_sample->dts() - prev_media_sample_data_.audio_sample->dts());
1040  prev_media_sample_data_.audio_sample_duration =
1041  prev_media_sample_data_.audio_sample->duration();
1042  if (!new_sample_cb_.Run(prev_media_sample_data_.audio_stream_id,
1043  prev_media_sample_data_.audio_sample)) {
1044  LOG(ERROR) << "Failed to process the audio sample.";
1045  return false;
1046  }
1047  prev_media_sample_data_.audio_sample = new_sample;
1048  prev_media_sample_data_.audio_stream_id = stream_id;
1049  }
1050  return true;
1051 }
1052 
1053 bool WvmMediaParser::GetAssetKey(const uint32_t asset_id,
1054  EncryptionKey* encryption_key) {
1055  DCHECK(decryption_key_source_);
1056  Status status = decryption_key_source_->FetchKeys(asset_id);
1057  if (!status.ok()) {
1058  LOG(ERROR) << "Fetch Key(s) failed for AssetID = " << asset_id
1059  << ", error = " << status;
1060  return false;
1061  }
1062 
1063  status = decryption_key_source_->GetKey(KeySource::TRACK_TYPE_HD,
1064  encryption_key);
1065  if (!status.ok()) {
1066  LOG(ERROR) << "Fetch Key(s) failed for AssetID = " << asset_id
1067  << ", error = " << status;
1068  return false;
1069  }
1070 
1071  return true;
1072 }
1073 
1074 bool WvmMediaParser::ProcessEcm() {
1075  // An error will be returned later if the samples need to be decrypted.
1076  if (!decryption_key_source_)
1077  return true;
1078 
1079  if (current_program_id_ > 0) {
1080  return true;
1081  }
1082  if (ecm_.size() != kEcmSizeBytes) {
1083  LOG(ERROR) << "Unexpected ECM size = " << ecm_.size()
1084  << ", expected size = " << kEcmSizeBytes;
1085  return false;
1086  }
1087  const uint8_t* ecm_data = ecm_.data();
1088  DCHECK(ecm_data);
1089  ecm_data += sizeof(uint32_t); // old version field - skip.
1090  ecm_data += sizeof(uint32_t); // clear lead - skip.
1091  ecm_data += sizeof(uint32_t); // system id(includes ECM version) - skip.
1092  uint32_t asset_id = ntohlFromBuffer(ecm_data);
1093  if (asset_id == 0) {
1094  LOG(ERROR) << "AssetID in ECM is not valid.";
1095  return false;
1096  }
1097  ecm_data += sizeof(uint32_t); // asset_id.
1098  EncryptionKey encryption_key;
1099  if (!GetAssetKey(asset_id, &encryption_key)) {
1100  return false;
1101  }
1102  if (encryption_key.key.size() < kAssetKeySizeBytes) {
1103  LOG(ERROR) << "Asset Key size of " << encryption_key.key.size()
1104  << " for AssetID = " << asset_id
1105  << " is less than minimum asset key size.";
1106  return false;
1107  }
1108  // Legacy WVM content may have asset keys > 16 bytes.
1109  // Use only the first 16 bytes of the asset key to get
1110  // the content key.
1111  std::vector<uint8_t> asset_key(
1112  encryption_key.key.begin(),
1113  encryption_key.key.begin() + kAssetKeySizeBytes);
1114  std::vector<uint8_t> iv(kInitializationVectorSizeBytes);
1115  AesCbcCtsDecryptor asset_decryptor;
1116  if (!asset_decryptor.InitializeWithIv(asset_key, iv)) {
1117  LOG(ERROR) << "Failed to initialize asset_decryptor.";
1118  return false;
1119  }
1120 
1121  const size_t content_key_buffer_size =
1122  kEcmFlagsSizeBytes + kEcmContentKeySizeBytes +
1123  kEcmPaddingSizeBytes; // flags + contentKey + padding.
1124  std::vector<uint8_t> content_key_buffer(content_key_buffer_size);
1125  asset_decryptor.Decrypt(
1126  ecm_data, content_key_buffer_size, vector_as_array(&content_key_buffer));
1127 
1128  std::vector<uint8_t> decrypted_content_key_vec(
1129  content_key_buffer.begin() + 4,
1130  content_key_buffer.begin() + 20);
1131  scoped_ptr<AesCbcCtsDecryptor> content_decryptor(new AesCbcCtsDecryptor);
1132  if (!content_decryptor->InitializeWithIv(decrypted_content_key_vec, iv)) {
1133  LOG(ERROR) << "Failed to initialize content decryptor.";
1134  return false;
1135  }
1136 
1137  content_decryptor_ = content_decryptor.Pass();
1138  return true;
1139 }
1140 
1141 DemuxStreamIdMediaSample::DemuxStreamIdMediaSample() :
1142  demux_stream_id(0),
1143  parsed_audio_or_video_stream_id(0) {}
1144 
1145 DemuxStreamIdMediaSample::~DemuxStreamIdMediaSample() {}
1146 
1147 PrevSampleData::PrevSampleData() {
1148  Reset();
1149 }
1150 
1151 PrevSampleData::~PrevSampleData() {}
1152 
1153 void PrevSampleData::Reset() {
1154  audio_sample = NULL;
1155  video_sample = NULL;
1156  audio_stream_id = 0;
1157  video_stream_id = 0;
1158  audio_sample_duration = 0;
1159  video_sample_duration = 0;
1160 }
1161 
1162 } // namespace wvm
1163 } // namespace media
1164 } // namespace edash_packager
edash_packager::media::mp2t::AdtsHeader::GetAdtsFrameSize
static size_t GetAdtsFrameSize(const uint8_t *data, size_t num_bytes)
Definition: adts_header.cc:23
edash_packager::media::KeySource
KeySource is responsible for encryption key acquisition.
Definition: key_source.h:29
edash_packager::media::MediaSample::CreateEmptyMediaSample
static scoped_refptr< MediaSample > CreateEmptyMediaSample()
Create a MediaSample object with default members.
Definition: media_sample.cc:74
edash_packager::media::AudioStreamInfo::GetCodecString
static std::string GetCodecString(AudioCodec codec, uint8_t audio_object_type)
Definition: audio_stream_info.cc:110
Generated on Tue Dec 15 2015 00:22:29 for DASH Media Packaging SDK by   doxygen 1.8.6