src/media/formats/mp4/box_definitions.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 "media/formats/mp4/box_definitions.h"
   6
   7 #include "base/logging.h"
   8 #include "media/formats/mp4/es_descriptor.h"
   9 #include "media/formats/mp4/rcheck.h"
  10
  11 namespace media {
  12 namespace mp4 {
  13
  14 FileType::FileType() {}
  15 FileType::~FileType() {}
  16 FourCC FileType::BoxType() const { return FOURCC_FTYP; }
  17
  18 bool FileType::Parse(BoxReader* reader) {
  19   RCHECK(reader->ReadFourCC(&major_brand) && reader->Read4(&minor_version));
  20   size_t num_brands = (reader->size() - reader->pos()) / sizeof(FourCC);
  21   return reader->SkipBytes(sizeof(FourCC) * num_brands);  // compatible_brands
  22 }
  23
  24 ProtectionSystemSpecificHeader::ProtectionSystemSpecificHeader() {}
  25 ProtectionSystemSpecificHeader::~ProtectionSystemSpecificHeader() {}
  26 FourCC ProtectionSystemSpecificHeader::BoxType() const { return FOURCC_PSSH; }
  27
  28 bool ProtectionSystemSpecificHeader::Parse(BoxReader* reader) {
  29   // Validate the box's contents and hang on to the system ID.
  30   uint32 size;
  31   RCHECK(reader->ReadFullBoxHeader() &&
  32          reader->ReadVec(&system_id, 16) &&
  33          reader->Read4(&size) &&
  34          reader->HasBytes(size));
  35
  36   // Copy the entire box, including the header, for passing to EME as initData.
  37   DCHECK(raw_box.empty());
  38   raw_box.assign(reader->data(), reader->data() + reader->size());
  39   return true;
  40 }
  41
  42 SampleAuxiliaryInformationOffset::SampleAuxiliaryInformationOffset() {}
  43 SampleAuxiliaryInformationOffset::~SampleAuxiliaryInformationOffset() {}
  44 FourCC SampleAuxiliaryInformationOffset::BoxType() const { return FOURCC_SAIO; }
  45
  46 bool SampleAuxiliaryInformationOffset::Parse(BoxReader* reader) {
  47   RCHECK(reader->ReadFullBoxHeader());
  48   if (reader->flags() & 1)
  49     RCHECK(reader->SkipBytes(8));
  50
  51   uint32 count;
  52   RCHECK(reader->Read4(&count) &&
  53          reader->HasBytes(count * (reader->version() == 1 ? 8 : 4)));
  54   offsets.resize(count);
  55
  56   for (uint32 i = 0; i < count; i++) {
  57     if (reader->version() == 1) {
  58       RCHECK(reader->Read8(&offsets[i]));
  59     } else {
  60       RCHECK(reader->Read4Into8(&offsets[i]));
  61     }
  62   }
  63   return true;
  64 }
  65
  66 SampleAuxiliaryInformationSize::SampleAuxiliaryInformationSize()
  67   : default_sample_info_size(0), sample_count(0) {
  68 }
  69 SampleAuxiliaryInformationSize::~SampleAuxiliaryInformationSize() {}
  70 FourCC SampleAuxiliaryInformationSize::BoxType() const { return FOURCC_SAIZ; }
  71
  72 bool SampleAuxiliaryInformationSize::Parse(BoxReader* reader) {
  73   RCHECK(reader->ReadFullBoxHeader());
  74   if (reader->flags() & 1)
  75     RCHECK(reader->SkipBytes(8));
  76
  77   RCHECK(reader->Read1(&default_sample_info_size) &&
  78          reader->Read4(&sample_count));
  79   if (default_sample_info_size == 0)
  80     return reader->ReadVec(&sample_info_sizes, sample_count);
  81   return true;
  82 }
  83
  84 OriginalFormat::OriginalFormat() : format(FOURCC_NULL) {}
  85 OriginalFormat::~OriginalFormat() {}
  86 FourCC OriginalFormat::BoxType() const { return FOURCC_FRMA; }
  87
  88 bool OriginalFormat::Parse(BoxReader* reader) {
  89   return reader->ReadFourCC(&format);
  90 }
  91
  92 SchemeType::SchemeType() : type(FOURCC_NULL), version(0) {}
  93 SchemeType::~SchemeType() {}
  94 FourCC SchemeType::BoxType() const { return FOURCC_SCHM; }
  95
  96 bool SchemeType::Parse(BoxReader* reader) {
  97   RCHECK(reader->ReadFullBoxHeader() &&
  98          reader->ReadFourCC(&type) &&
  99          reader->Read4(&version));
 100   return true;
 101 }
 102
 103 TrackEncryption::TrackEncryption()
 104   : is_encrypted(false), default_iv_size(0) {
 105 }
 106 TrackEncryption::~TrackEncryption() {}
 107 FourCC TrackEncryption::BoxType() const { return FOURCC_TENC; }
 108
 109 bool TrackEncryption::Parse(BoxReader* reader) {
 110   uint8 flag;
 111   RCHECK(reader->ReadFullBoxHeader() &&
 112          reader->SkipBytes(2) &&
 113          reader->Read1(&flag) &&
 114          reader->Read1(&default_iv_size) &&
 115          reader->ReadVec(&default_kid, 16));
 116   is_encrypted = (flag != 0);
 117   if (is_encrypted) {
 118     RCHECK(default_iv_size == 8 || default_iv_size == 16);
 119   } else {
 120     RCHECK(default_iv_size == 0);
 121   }
 122   return true;
 123 }
 124
 125 SchemeInfo::SchemeInfo() {}
 126 SchemeInfo::~SchemeInfo() {}
 127 FourCC SchemeInfo::BoxType() const { return FOURCC_SCHI; }
 128
 129 bool SchemeInfo::Parse(BoxReader* reader) {
 130   return reader->ScanChildren() && reader->ReadChild(&track_encryption);
 131 }
 132
 133 ProtectionSchemeInfo::ProtectionSchemeInfo() {}
 134 ProtectionSchemeInfo::~ProtectionSchemeInfo() {}
 135 FourCC ProtectionSchemeInfo::BoxType() const { return FOURCC_SINF; }
 136
 137 bool ProtectionSchemeInfo::Parse(BoxReader* reader) {
 138   RCHECK(reader->ScanChildren() &&
 139          reader->ReadChild(&format) &&
 140          reader->ReadChild(&type));
 141   if (type.type == FOURCC_CENC)
 142     RCHECK(reader->ReadChild(&info));
 143   // Other protection schemes are silently ignored. Since the protection scheme
 144   // type can't be determined until this box is opened, we return 'true' for
 145   // non-CENC protection scheme types. It is the parent box's responsibility to
 146   // ensure that this scheme type is a supported one.
 147   return true;
 148 }
 149
 150 MovieHeader::MovieHeader()
 151     : creation_time(0),
 152       modification_time(0),
 153       timescale(0),
 154       duration(0),
 155       rate(-1),
 156       volume(-1),
 157       next_track_id(0) {}
 158 MovieHeader::~MovieHeader() {}
 159 FourCC MovieHeader::BoxType() const { return FOURCC_MVHD; }
 160
 161 bool MovieHeader::Parse(BoxReader* reader) {
 162   RCHECK(reader->ReadFullBoxHeader());
 163
 164   if (reader->version() == 1) {
 165     RCHECK(reader->Read8(&creation_time) &&
 166            reader->Read8(&modification_time) &&
 167            reader->Read4(&timescale) &&
 168            reader->Read8(&duration));
 169   } else {
 170     RCHECK(reader->Read4Into8(&creation_time) &&
 171            reader->Read4Into8(&modification_time) &&
 172            reader->Read4(&timescale) &&
 173            reader->Read4Into8(&duration));
 174   }
 175
 176   RCHECK(reader->Read4s(&rate) &&
 177          reader->Read2s(&volume) &&
 178          reader->SkipBytes(10) &&  // reserved
 179          reader->SkipBytes(36) &&  // matrix
 180          reader->SkipBytes(24) &&  // predefined zero
 181          reader->Read4(&next_track_id));
 182   return true;
 183 }
 184
 185 TrackHeader::TrackHeader()
 186     : creation_time(0),
 187       modification_time(0),
 188       track_id(0),
 189       duration(0),
 190       layer(-1),
 191       alternate_group(-1),
 192       volume(-1),
 193       width(0),
 194       height(0) {}
 195 TrackHeader::~TrackHeader() {}
 196 FourCC TrackHeader::BoxType() const { return FOURCC_TKHD; }
 197
 198 bool TrackHeader::Parse(BoxReader* reader) {
 199   RCHECK(reader->ReadFullBoxHeader());
 200   if (reader->version() == 1) {
 201     RCHECK(reader->Read8(&creation_time) &&
 202            reader->Read8(&modification_time) &&
 203            reader->Read4(&track_id) &&
 204            reader->SkipBytes(4) &&    // reserved
 205            reader->Read8(&duration));
 206   } else {
 207     RCHECK(reader->Read4Into8(&creation_time) &&
 208            reader->Read4Into8(&modification_time) &&
 209            reader->Read4(&track_id) &&
 210            reader->SkipBytes(4) &&   // reserved
 211            reader->Read4Into8(&duration));
 212   }
 213
 214   RCHECK(reader->SkipBytes(8) &&  // reserved
 215          reader->Read2s(&layer) &&
 216          reader->Read2s(&alternate_group) &&
 217          reader->Read2s(&volume) &&
 218          reader->SkipBytes(2) &&  // reserved
 219          reader->SkipBytes(36) &&  // matrix
 220          reader->Read4(&width) &&
 221          reader->Read4(&height));
 222   width >>= 16;
 223   height >>= 16;
 224   return true;
 225 }
 226
 227 SampleDescription::SampleDescription() : type(kInvalid) {}
 228 SampleDescription::~SampleDescription() {}
 229 FourCC SampleDescription::BoxType() const { return FOURCC_STSD; }
 230
 231 bool SampleDescription::Parse(BoxReader* reader) {
 232   uint32 count;
 233   RCHECK(reader->SkipBytes(4) &&
 234          reader->Read4(&count));
 235   video_entries.clear();
 236   audio_entries.clear();
 237
 238   // Note: this value is preset before scanning begins. See comments in the
 239   // Parse(Media*) function.
 240   if (type == kVideo) {
 241     RCHECK(reader->ReadAllChildren(&video_entries));
 242   } else if (type == kAudio) {
 243     RCHECK(reader->ReadAllChildren(&audio_entries));
 244   }
 245   return true;
 246 }
 247
 248 SyncSample::SyncSample() : is_present(false) {}
 249 SyncSample::~SyncSample() {}
 250 FourCC SyncSample::BoxType() const { return FOURCC_STSS; }
 251
 252 bool SyncSample::Parse(BoxReader* reader) {
 253   uint32 entry_count;
 254   RCHECK(reader->ReadFullBoxHeader() &&
 255          reader->Read4(&entry_count));
 256
 257   is_present = true;
 258
 259   entries.resize(entry_count);
 260
 261   if (entry_count == 0)
 262     return true;
 263
 264   for (size_t i = 0; i < entry_count; ++i)
 265     RCHECK(reader->Read4(&entries[i]));
 266
 267   return true;
 268 }
 269
 270 bool SyncSample::IsSyncSample(size_t k) const {
 271   // ISO/IEC 14496-12 Section 8.6.2.1 : If the sync sample box is not present,
 272   // every sample is a sync sample.
 273   if (!is_present)
 274     return true;
 275
 276   // ISO/IEC 14496-12  Section 8.6.2.3 : If entry_count is zero, there are no
 277   // sync samples within the stream.
 278   if (entries.size() == 0u)
 279     return false;
 280
 281   for (size_t i = 0; i < entries.size(); ++i) {
 282     if (entries[i] == k)
 283       return true;
 284   }
 285
 286   return false;
 287 }
 288
 289 SampleTable::SampleTable() {}
 290 SampleTable::~SampleTable() {}
 291 FourCC SampleTable::BoxType() const { return FOURCC_STBL; }
 292
 293 bool SampleTable::Parse(BoxReader* reader) {
 294   return reader->ScanChildren() &&
 295       reader->ReadChild(&description) &&
 296       reader->MaybeReadChild(&sync_sample);
 297 }
 298
 299 EditList::EditList() {}
 300 EditList::~EditList() {}
 301 FourCC EditList::BoxType() const { return FOURCC_ELST; }
 302
 303 bool EditList::Parse(BoxReader* reader) {
 304   uint32 count;
 305   RCHECK(reader->ReadFullBoxHeader() && reader->Read4(&count));
 306
 307   if (reader->version() == 1) {
 308     RCHECK(reader->HasBytes(count * 20));
 309   } else {
 310     RCHECK(reader->HasBytes(count * 12));
 311   }
 312   edits.resize(count);
 313
 314   for (std::vector<EditListEntry>::iterator edit = edits.begin();
 315        edit != edits.end(); ++edit) {
 316     if (reader->version() == 1) {
 317       RCHECK(reader->Read8(&edit->segment_duration) &&
 318              reader->Read8s(&edit->media_time));
 319     } else {
 320       RCHECK(reader->Read4Into8(&edit->segment_duration) &&
 321              reader->Read4sInto8s(&edit->media_time));
 322     }
 323     RCHECK(reader->Read2s(&edit->media_rate_integer) &&
 324            reader->Read2s(&edit->media_rate_fraction));
 325   }
 326   return true;
 327 }
 328
 329 Edit::Edit() {}
 330 Edit::~Edit() {}
 331 FourCC Edit::BoxType() const { return FOURCC_EDTS; }
 332
 333 bool Edit::Parse(BoxReader* reader) {
 334   return reader->ScanChildren() && reader->ReadChild(&list);
 335 }
 336
 337 HandlerReference::HandlerReference() : type(kInvalid) {}
 338 HandlerReference::~HandlerReference() {}
 339 FourCC HandlerReference::BoxType() const { return FOURCC_HDLR; }
 340
 341 bool HandlerReference::Parse(BoxReader* reader) {
 342   FourCC hdlr_type;
 343   RCHECK(reader->SkipBytes(8) && reader->ReadFourCC(&hdlr_type));
 344   // Note: remaining fields in box ignored
 345   if (hdlr_type == FOURCC_VIDE) {
 346     type = kVideo;
 347   } else if (hdlr_type == FOURCC_SOUN) {
 348     type = kAudio;
 349   } else {
 350     type = kInvalid;
 351   }
 352   return true;
 353 }
 354
 355 AVCDecoderConfigurationRecord::AVCDecoderConfigurationRecord()
 356     : version(0),
 357       profile_indication(0),
 358       profile_compatibility(0),
 359       avc_level(0),
 360       length_size(0) {}
 361
 362 AVCDecoderConfigurationRecord::~AVCDecoderConfigurationRecord() {}
 363 FourCC AVCDecoderConfigurationRecord::BoxType() const { return FOURCC_AVCC; }
 364
 365 bool AVCDecoderConfigurationRecord::Parse(BoxReader* reader) {
 366   return ParseInternal(reader, reader->log_cb());
 367 }
 368
 369 bool AVCDecoderConfigurationRecord::Parse(const uint8* data, int data_size) {
 370   BufferReader reader(data, data_size);
 371   return ParseInternal(&reader, LogCB());
 372 }
 373
 374 bool AVCDecoderConfigurationRecord::ParseInternal(BufferReader* reader,
 375                                                   const LogCB& log_cb) {
 376   RCHECK(reader->Read1(&version) && version == 1 &&
 377          reader->Read1(&profile_indication) &&
 378          reader->Read1(&profile_compatibility) &&
 379          reader->Read1(&avc_level));
 380
 381   uint8 length_size_minus_one;
 382   RCHECK(reader->Read1(&length_size_minus_one) &&
 383          (length_size_minus_one & 0xfc) == 0xfc);
 384   length_size = (length_size_minus_one & 0x3) + 1;
 385
 386   RCHECK(length_size != 3); // Only values of 1, 2, and 4 are valid.
 387
 388   uint8 num_sps;
 389   RCHECK(reader->Read1(&num_sps) && (num_sps & 0xe0) == 0xe0);
 390   num_sps &= 0x1f;
 391
 392   sps_list.resize(num_sps);
 393   for (int i = 0; i < num_sps; i++) {
 394     uint16 sps_length;
 395     RCHECK(reader->Read2(&sps_length) &&
 396            reader->ReadVec(&sps_list[i], sps_length));
 397     RCHECK(sps_list[i].size() > 4);
 398
 399     if (!log_cb.is_null()) {
 400       MEDIA_LOG(log_cb) << "Video codec: avc1." << std::hex
 401                         << static_cast<int>(sps_list[i][1])
 402                         << static_cast<int>(sps_list[i][2])
 403                         << static_cast<int>(sps_list[i][3]);
 404     }
 405   }
 406
 407   uint8 num_pps;
 408   RCHECK(reader->Read1(&num_pps));
 409
 410   pps_list.resize(num_pps);
 411   for (int i = 0; i < num_pps; i++) {
 412     uint16 pps_length;
 413     RCHECK(reader->Read2(&pps_length) &&
 414            reader->ReadVec(&pps_list[i], pps_length));
 415   }
 416
 417   return true;
 418 }
 419
 420 PixelAspectRatioBox::PixelAspectRatioBox() : h_spacing(1), v_spacing(1) {}
 421 PixelAspectRatioBox::~PixelAspectRatioBox() {}
 422 FourCC PixelAspectRatioBox::BoxType() const { return FOURCC_PASP; }
 423
 424 bool PixelAspectRatioBox::Parse(BoxReader* reader) {
 425   RCHECK(reader->Read4(&h_spacing) &&
 426          reader->Read4(&v_spacing));
 427   return true;
 428 }
 429
 430 VideoSampleEntry::VideoSampleEntry()
 431     : format(FOURCC_NULL),
 432       data_reference_index(0),
 433       width(0),
 434       height(0) {}
 435
 436 VideoSampleEntry::~VideoSampleEntry() {}
 437 FourCC VideoSampleEntry::BoxType() const {
 438   DCHECK(false) << "VideoSampleEntry should be parsed according to the "
 439                 << "handler type recovered in its Media ancestor.";
 440   return FOURCC_NULL;
 441 }
 442
 443 bool VideoSampleEntry::Parse(BoxReader* reader) {
 444   format = reader->type();
 445   RCHECK(reader->SkipBytes(6) &&
 446          reader->Read2(&data_reference_index) &&
 447          reader->SkipBytes(16) &&
 448          reader->Read2(&width) &&
 449          reader->Read2(&height) &&
 450          reader->SkipBytes(50));
 451
 452   RCHECK(reader->ScanChildren() &&
 453          reader->MaybeReadChild(&pixel_aspect));
 454
 455   if (format == FOURCC_ENCV) {
 456     // Continue scanning until a recognized protection scheme is found, or until
 457     // we run out of protection schemes.
 458     while (sinf.type.type != FOURCC_CENC) {
 459       if (!reader->ReadChild(&sinf))
 460         return false;
 461     }
 462   }
 463
 464   if (IsFormatValid())
 465     RCHECK(reader->ReadChild(&avcc));
 466
 467   return true;
 468 }
 469
 470 bool VideoSampleEntry::IsFormatValid() const {
 471   return format == FOURCC_AVC1 || format == FOURCC_AVC3 ||
 472       (format == FOURCC_ENCV && (sinf.format.format == FOURCC_AVC1 ||
 473                                  sinf.format.format == FOURCC_AVC3));
 474 }
 475
 476 ElementaryStreamDescriptor::ElementaryStreamDescriptor()
 477     : object_type(kForbidden) {}
 478
 479 ElementaryStreamDescriptor::~ElementaryStreamDescriptor() {}
 480
 481 FourCC ElementaryStreamDescriptor::BoxType() const {
 482   return FOURCC_ESDS;
 483 }
 484
 485 bool ElementaryStreamDescriptor::Parse(BoxReader* reader) {
 486   std::vector<uint8> data;
 487   ESDescriptor es_desc;
 488
 489   RCHECK(reader->ReadFullBoxHeader());
 490   RCHECK(reader->ReadVec(&data, reader->size() - reader->pos()));
 491   RCHECK(es_desc.Parse(data));
 492
 493   object_type = es_desc.object_type();
 494
 495   if (object_type != 0x40) {
 496     MEDIA_LOG(reader->log_cb()) << "Audio codec: mp4a."
 497                                 << std::hex << static_cast<int>(object_type);
 498   }
 499
 500   if (es_desc.IsAAC(object_type))
 501     RCHECK(aac.Parse(es_desc.decoder_specific_info(), reader->log_cb()));
 502
 503   return true;
 504 }
 505
 506 AudioSampleEntry::AudioSampleEntry()
 507     : format(FOURCC_NULL),
 508       data_reference_index(0),
 509       channelcount(0),
 510       samplesize(0),
 511       samplerate(0) {}
 512
 513 AudioSampleEntry::~AudioSampleEntry() {}
 514
 515 FourCC AudioSampleEntry::BoxType() const {
 516   DCHECK(false) << "AudioSampleEntry should be parsed according to the "
 517                 << "handler type recovered in its Media ancestor.";
 518   return FOURCC_NULL;
 519 }
 520
 521 bool AudioSampleEntry::Parse(BoxReader* reader) {
 522   format = reader->type();
 523   RCHECK(reader->SkipBytes(6) &&
 524          reader->Read2(&data_reference_index) &&
 525          reader->SkipBytes(8) &&
 526          reader->Read2(&channelcount) &&
 527          reader->Read2(&samplesize) &&
 528          reader->SkipBytes(4) &&
 529          reader->Read4(&samplerate));
 530   // Convert from 16.16 fixed point to integer
 531   samplerate >>= 16;
 532
 533   RCHECK(reader->ScanChildren());
 534   if (format == FOURCC_ENCA) {
 535     // Continue scanning until a recognized protection scheme is found, or until
 536     // we run out of protection schemes.
 537     while (sinf.type.type != FOURCC_CENC) {
 538       if (!reader->ReadChild(&sinf))
 539         return false;
 540     }
 541   }
 542
 543   // ESDS is not valid in case of EAC3.
 544   RCHECK(reader->MaybeReadChild(&esds));
 545   return true;
 546 }
 547
 548 MediaHeader::MediaHeader()
 549     : creation_time(0),
 550       modification_time(0),
 551       timescale(0),
 552       duration(0) {}
 553 MediaHeader::~MediaHeader() {}
 554 FourCC MediaHeader::BoxType() const { return FOURCC_MDHD; }
 555
 556 bool MediaHeader::Parse(BoxReader* reader) {
 557   RCHECK(reader->ReadFullBoxHeader());
 558
 559   if (reader->version() == 1) {
 560     RCHECK(reader->Read8(&creation_time) &&
 561            reader->Read8(&modification_time) &&
 562            reader->Read4(&timescale) &&
 563            reader->Read8(&duration));
 564   } else {
 565     RCHECK(reader->Read4Into8(&creation_time) &&
 566            reader->Read4Into8(&modification_time) &&
 567            reader->Read4(&timescale) &&
 568            reader->Read4Into8(&duration));
 569   }
 570   // Skip language information
 571   return reader->SkipBytes(4);
 572 }
 573
 574 MediaInformation::MediaInformation() {}
 575 MediaInformation::~MediaInformation() {}
 576 FourCC MediaInformation::BoxType() const { return FOURCC_MINF; }
 577
 578 bool MediaInformation::Parse(BoxReader* reader) {
 579   return reader->ScanChildren() &&
 580          reader->ReadChild(&sample_table);
 581 }
 582
 583 Media::Media() {}
 584 Media::~Media() {}
 585 FourCC Media::BoxType() const { return FOURCC_MDIA; }
 586
 587 bool Media::Parse(BoxReader* reader) {
 588   RCHECK(reader->ScanChildren() &&
 589          reader->ReadChild(&header) &&
 590          reader->ReadChild(&handler));
 591
 592   // Maddeningly, the HandlerReference box specifies how to parse the
 593   // SampleDescription box, making the latter the only box (of those that we
 594   // support) which cannot be parsed correctly on its own (or even with
 595   // information from its strict ancestor tree). We thus copy the handler type
 596   // to the sample description box *before* parsing it to provide this
 597   // information while parsing.
 598   information.sample_table.description.type = handler.type;
 599   RCHECK(reader->ReadChild(&information));
 600   return true;
 601 }
 602
 603 Track::Track() {}
 604 Track::~Track() {}
 605 FourCC Track::BoxType() const { return FOURCC_TRAK; }
 606
 607 bool Track::Parse(BoxReader* reader) {
 608   RCHECK(reader->ScanChildren() &&
 609          reader->ReadChild(&header) &&
 610          reader->ReadChild(&media) &&
 611          reader->MaybeReadChild(&edit));
 612   return true;
 613 }
 614
 615 MovieExtendsHeader::MovieExtendsHeader() : fragment_duration(0) {}
 616 MovieExtendsHeader::~MovieExtendsHeader() {}
 617 FourCC MovieExtendsHeader::BoxType() const { return FOURCC_MEHD; }
 618
 619 bool MovieExtendsHeader::Parse(BoxReader* reader) {
 620   RCHECK(reader->ReadFullBoxHeader());
 621   if (reader->version() == 1) {
 622     RCHECK(reader->Read8(&fragment_duration));
 623   } else {
 624     RCHECK(reader->Read4Into8(&fragment_duration));
 625   }
 626   return true;
 627 }
 628
 629 TrackExtends::TrackExtends()
 630     : track_id(0),
 631       default_sample_description_index(0),
 632       default_sample_duration(0),
 633       default_sample_size(0),
 634       default_sample_flags(0) {}
 635 TrackExtends::~TrackExtends() {}
 636 FourCC TrackExtends::BoxType() const { return FOURCC_TREX; }
 637
 638 bool TrackExtends::Parse(BoxReader* reader) {
 639   RCHECK(reader->ReadFullBoxHeader() &&
 640          reader->Read4(&track_id) &&
 641          reader->Read4(&default_sample_description_index) &&
 642          reader->Read4(&default_sample_duration) &&
 643          reader->Read4(&default_sample_size) &&
 644          reader->Read4(&default_sample_flags));
 645   return true;
 646 }
 647
 648 MovieExtends::MovieExtends() {}
 649 MovieExtends::~MovieExtends() {}
 650 FourCC MovieExtends::BoxType() const { return FOURCC_MVEX; }
 651
 652 bool MovieExtends::Parse(BoxReader* reader) {
 653   header.fragment_duration = 0;
 654   return reader->ScanChildren() &&
 655          reader->MaybeReadChild(&header) &&
 656          reader->ReadChildren(&tracks);
 657 }
 658
 659 Movie::Movie() : fragmented(false) {}
 660 Movie::~Movie() {}
 661 FourCC Movie::BoxType() const { return FOURCC_MOOV; }
 662
 663 bool Movie::Parse(BoxReader* reader) {
 664   return reader->ScanChildren() &&
 665          reader->ReadChild(&header) &&
 666          reader->ReadChildren(&tracks) &&
 667          // Media Source specific: 'mvex' required
 668          reader->ReadChild(&extends) &&
 669          reader->MaybeReadChildren(&pssh);
 670 }
 671
 672 TrackFragmentDecodeTime::TrackFragmentDecodeTime() : decode_time(0) {}
 673 TrackFragmentDecodeTime::~TrackFragmentDecodeTime() {}
 674 FourCC TrackFragmentDecodeTime::BoxType() const { return FOURCC_TFDT; }
 675
 676 bool TrackFragmentDecodeTime::Parse(BoxReader* reader) {
 677   RCHECK(reader->ReadFullBoxHeader());
 678   if (reader->version() == 1)
 679     return reader->Read8(&decode_time);
 680   else
 681     return reader->Read4Into8(&decode_time);
 682 }
 683
 684 MovieFragmentHeader::MovieFragmentHeader() : sequence_number(0) {}
 685 MovieFragmentHeader::~MovieFragmentHeader() {}
 686 FourCC MovieFragmentHeader::BoxType() const { return FOURCC_MFHD; }
 687
 688 bool MovieFragmentHeader::Parse(BoxReader* reader) {
 689   return reader->SkipBytes(4) && reader->Read4(&sequence_number);
 690 }
 691
 692 TrackFragmentHeader::TrackFragmentHeader()
 693     : track_id(0),
 694       sample_description_index(0),
 695       default_sample_duration(0),
 696       default_sample_size(0),
 697       default_sample_flags(0),
 698       has_default_sample_flags(false) {}
 699
 700 TrackFragmentHeader::~TrackFragmentHeader() {}
 701 FourCC TrackFragmentHeader::BoxType() const { return FOURCC_TFHD; }
 702
 703 bool TrackFragmentHeader::Parse(BoxReader* reader) {
 704   RCHECK(reader->ReadFullBoxHeader() && reader->Read4(&track_id));
 705
 706   // Media Source specific: reject tracks that set 'base-data-offset-present'.
 707   // Although the Media Source requires that 'default-base-is-moof' (14496-12
 708   // Amendment 2) be set, we omit this check as many otherwise-valid files in
 709   // the wild don't set it.
 710   //
 711   //  RCHECK((flags & 0x020000) && !(flags & 0x1));
 712   RCHECK(!(reader->flags() & 0x1));
 713
 714   if (reader->flags() & 0x2) {
 715     RCHECK(reader->Read4(&sample_description_index));
 716   } else {
 717     sample_description_index = 0;
 718   }
 719
 720   if (reader->flags() & 0x8) {
 721     RCHECK(reader->Read4(&default_sample_duration));
 722   } else {
 723     default_sample_duration = 0;
 724   }
 725
 726   if (reader->flags() & 0x10) {
 727     RCHECK(reader->Read4(&default_sample_size));
 728   } else {
 729     default_sample_size = 0;
 730   }
 731
 732   if (reader->flags() & 0x20) {
 733     RCHECK(reader->Read4(&default_sample_flags));
 734     has_default_sample_flags = true;
 735   } else {
 736     has_default_sample_flags = false;
 737   }
 738
 739   return true;
 740 }
 741
 742 TrackFragmentRun::TrackFragmentRun()
 743     : sample_count(0), data_offset(0) {}
 744 TrackFragmentRun::~TrackFragmentRun() {}
 745 FourCC TrackFragmentRun::BoxType() const { return FOURCC_TRUN; }
 746
 747 bool TrackFragmentRun::Parse(BoxReader* reader) {
 748   RCHECK(reader->ReadFullBoxHeader() &&
 749          reader->Read4(&sample_count));
 750   const uint32 flags = reader->flags();
 751
 752   bool data_offset_present = (flags & 0x1) != 0;
 753   bool first_sample_flags_present = (flags & 0x4) != 0;
 754   bool sample_duration_present = (flags & 0x100) != 0;
 755   bool sample_size_present = (flags & 0x200) != 0;
 756   bool sample_flags_present = (flags & 0x400) != 0;
 757   bool sample_composition_time_offsets_present = (flags & 0x800) != 0;
 758
 759   if (data_offset_present) {
 760     RCHECK(reader->Read4(&data_offset));
 761   } else {
 762     data_offset = 0;
 763   }
 764
 765   uint32 first_sample_flags;
 766   if (first_sample_flags_present)
 767     RCHECK(reader->Read4(&first_sample_flags));
 768
 769   int fields = sample_duration_present + sample_size_present +
 770       sample_flags_present + sample_composition_time_offsets_present;
 771   RCHECK(reader->HasBytes(fields * sample_count));
 772
 773   if (sample_duration_present)
 774     sample_durations.resize(sample_count);
 775   if (sample_size_present)
 776     sample_sizes.resize(sample_count);
 777   if (sample_flags_present)
 778     sample_flags.resize(sample_count);
 779   if (sample_composition_time_offsets_present)
 780     sample_composition_time_offsets.resize(sample_count);
 781
 782   for (uint32 i = 0; i < sample_count; ++i) {
 783     if (sample_duration_present)
 784       RCHECK(reader->Read4(&sample_durations[i]));
 785     if (sample_size_present)
 786       RCHECK(reader->Read4(&sample_sizes[i]));
 787     if (sample_flags_present)
 788       RCHECK(reader->Read4(&sample_flags[i]));
 789     if (sample_composition_time_offsets_present)
 790       RCHECK(reader->Read4s(&sample_composition_time_offsets[i]));
 791   }
 792
 793   if (first_sample_flags_present) {
 794     if (sample_flags.size() == 0) {
 795       sample_flags.push_back(first_sample_flags);
 796     } else {
 797       sample_flags[0] = first_sample_flags;
 798     }
 799   }
 800   return true;
 801 }
 802
 803 SampleToGroup::SampleToGroup() : grouping_type(0), grouping_type_parameter(0) {}
 804 SampleToGroup::~SampleToGroup() {}
 805 FourCC SampleToGroup::BoxType() const { return FOURCC_SBGP; }
 806
 807 bool SampleToGroup::Parse(BoxReader* reader) {
 808   RCHECK(reader->ReadFullBoxHeader() &&
 809          reader->Read4(&grouping_type));
 810
 811   if (reader->version() == 1)
 812     RCHECK(reader->Read4(&grouping_type_parameter));
 813
 814   if (grouping_type != FOURCC_SEIG) {
 815     DLOG(WARNING) << "SampleToGroup box with grouping_type '" << grouping_type
 816                   << "' is not supported.";
 817     return true;
 818   }
 819
 820   uint32 count;
 821   RCHECK(reader->Read4(&count));
 822   entries.resize(count);
 823   for (uint32 i = 0; i < count; ++i) {
 824     RCHECK(reader->Read4(&entries[i].sample_count) &&
 825            reader->Read4(&entries[i].group_description_index));
 826   }
 827   return true;
 828 }
 829
 830 CencSampleEncryptionInfoEntry::CencSampleEncryptionInfoEntry()
 831     : is_encrypted(false), iv_size(0) {}
 832 CencSampleEncryptionInfoEntry::~CencSampleEncryptionInfoEntry() {}
 833
 834 SampleGroupDescription::SampleGroupDescription() : grouping_type(0) {}
 835 SampleGroupDescription::~SampleGroupDescription() {}
 836 FourCC SampleGroupDescription::BoxType() const { return FOURCC_SGPD; }
 837
 838 bool SampleGroupDescription::Parse(BoxReader* reader) {
 839   RCHECK(reader->ReadFullBoxHeader() &&
 840          reader->Read4(&grouping_type));
 841
 842   if (grouping_type != FOURCC_SEIG) {
 843     DLOG(WARNING) << "SampleGroupDescription box with grouping_type '"
 844                   << grouping_type << "' is not supported.";
 845     return true;
 846   }
 847
 848   const uint8 version = reader->version();
 849
 850   const size_t kKeyIdSize = 16;
 851   const size_t kEntrySize = sizeof(uint32) + kKeyIdSize;
 852   uint32 default_length = 0;
 853   if (version == 1) {
 854       RCHECK(reader->Read4(&default_length));
 855       RCHECK(default_length == 0 || default_length >= kEntrySize);
 856   }
 857
 858   uint32 count;
 859   RCHECK(reader->Read4(&count));
 860   entries.resize(count);
 861   for (uint32 i = 0; i < count; ++i) {
 862     if (version == 1) {
 863       if (default_length == 0) {
 864         uint32 description_length = 0;
 865         RCHECK(reader->Read4(&description_length));
 866         RCHECK(description_length >= kEntrySize);
 867       }
 868     }
 869
 870     uint8 flag;
 871     RCHECK(reader->SkipBytes(2) &&  // reserved.
 872            reader->Read1(&flag) &&
 873            reader->Read1(&entries[i].iv_size) &&
 874            reader->ReadVec(&entries[i].key_id, kKeyIdSize));
 875
 876     entries[i].is_encrypted = (flag != 0);
 877     if (entries[i].is_encrypted) {
 878       RCHECK(entries[i].iv_size == 8 || entries[i].iv_size == 16);
 879     } else {
 880       RCHECK(entries[i].iv_size == 0);
 881     }
 882   }
 883   return true;
 884 }
 885
 886 TrackFragment::TrackFragment() {}
 887 TrackFragment::~TrackFragment() {}
 888 FourCC TrackFragment::BoxType() const { return FOURCC_TRAF; }
 889
 890 bool TrackFragment::Parse(BoxReader* reader) {
 891   RCHECK(reader->ScanChildren() &&
 892          reader->ReadChild(&header) &&
 893          // Media Source specific: 'tfdt' required
 894          reader->ReadChild(&decode_time) &&
 895          reader->MaybeReadChildren(&runs) &&
 896          reader->MaybeReadChild(&auxiliary_offset) &&
 897          reader->MaybeReadChild(&auxiliary_size) &&
 898          reader->MaybeReadChild(&sdtp));
 899
 900   // There could be multiple SampleGroupDescription and SampleToGroup boxes with
 901   // different grouping types. For common encryption, the relevant grouping type
 902   // is 'seig'. Continue reading until 'seig' is found, or until running out of
 903   // child boxes.
 904   while (sample_group_description.grouping_type != FOURCC_SEIG &&
 905          reader->HasChild(&sample_group_description)) {
 906     RCHECK(reader->ReadChild(&sample_group_description));
 907   }
 908   while (sample_to_group.grouping_type != FOURCC_SEIG &&
 909          reader->HasChild(&sample_to_group)) {
 910     RCHECK(reader->ReadChild(&sample_to_group));
 911   }
 912   return true;
 913 }
 914
 915 MovieFragment::MovieFragment() {}
 916 MovieFragment::~MovieFragment() {}
 917 FourCC MovieFragment::BoxType() const { return FOURCC_MOOF; }
 918
 919 bool MovieFragment::Parse(BoxReader* reader) {
 920   RCHECK(reader->ScanChildren() &&
 921          reader->ReadChild(&header) &&
 922          reader->ReadChildren(&tracks) &&
 923          reader->MaybeReadChildren(&pssh));
 924   return true;
 925 }
 926
 927 IndependentAndDisposableSamples::IndependentAndDisposableSamples() {}
 928 IndependentAndDisposableSamples::~IndependentAndDisposableSamples() {}
 929 FourCC IndependentAndDisposableSamples::BoxType() const { return FOURCC_SDTP; }
 930
 931 bool IndependentAndDisposableSamples::Parse(BoxReader* reader) {
 932   RCHECK(reader->ReadFullBoxHeader());
 933   RCHECK(reader->version() == 0);
 934   RCHECK(reader->flags() == 0);
 935
 936   int sample_count = reader->size() - reader->pos();
 937   sample_depends_on_.resize(sample_count);
 938   for (int i = 0; i < sample_count; ++i) {
 939     uint8 sample_info;
 940     RCHECK(reader->Read1(&sample_info));
 941
 942     sample_depends_on_[i] =
 943         static_cast<SampleDependsOn>((sample_info >> 4) & 0x3);
 944
 945     RCHECK(sample_depends_on_[i] != kSampleDependsOnReserved);
 946   }
 947
 948   return true;
 949 }
 950
 951 SampleDependsOn IndependentAndDisposableSamples::sample_depends_on(
 952     size_t i) const {
 953   if (i >= sample_depends_on_.size())
 954     return kSampleDependsOnUnknown;
 955
 956   return sample_depends_on_[i];
 957 }
 958
 959 }  // namespace mp4
 960 }  // namespace media