media/formats/mp4/box_definitions.h

   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 #ifndef MEDIA_FORMATS_MP4_BOX_DEFINITIONS_H_
   6 #define MEDIA_FORMATS_MP4_BOX_DEFINITIONS_H_
   7
   8 #include <string>
   9 #include <vector>
  10
  11 #include "base/basictypes.h"
  12 #include "base/compiler_specific.h"
  13 #include "media/base/media_export.h"
  14 #include "media/base/media_log.h"
  15 #include "media/formats/mp4/aac.h"
  16 #include "media/formats/mp4/avc.h"
  17 #include "media/formats/mp4/box_reader.h"
  18 #include "media/formats/mp4/fourccs.h"
  19
  20 namespace media {
  21 namespace mp4 {
  22
  23 enum TrackType {
  24   kInvalid = 0,
  25   kVideo,
  26   kAudio,
  27   kHint
  28 };
  29
  30 enum SampleFlags {
  31   kSampleIsNonSyncSample = 0x10000
  32 };
  33
  34 #define DECLARE_BOX_METHODS(T) \
  35   T(); \
  36   ~T() override; \
  37   bool Parse(BoxReader* reader) override; \
  38   FourCC BoxType() const override;
  39
  40 struct MEDIA_EXPORT FileType : Box {
  41   DECLARE_BOX_METHODS(FileType);
  42
  43   FourCC major_brand;
  44   uint32 minor_version;
  45 };
  46
  47 // If only copying the 'pssh' boxes, use ProtectionSystemSpecificHeader.
  48 // If access to the individual fields is needed, use
  49 // FullProtectionSystemSpecificHeader.
  50 struct MEDIA_EXPORT ProtectionSystemSpecificHeader : Box {
  51   DECLARE_BOX_METHODS(ProtectionSystemSpecificHeader);
  52
  53   std::vector<uint8> raw_box;
  54 };
  55
  56 struct MEDIA_EXPORT FullProtectionSystemSpecificHeader : Box {
  57   DECLARE_BOX_METHODS(FullProtectionSystemSpecificHeader);
  58
  59   std::vector<uint8> system_id;
  60   std::vector<std::vector<uint8>> key_ids;
  61   std::vector<uint8> data;
  62 };
  63
  64 struct MEDIA_EXPORT SampleAuxiliaryInformationOffset : Box {
  65   DECLARE_BOX_METHODS(SampleAuxiliaryInformationOffset);
  66
  67   std::vector<uint64> offsets;
  68 };
  69
  70 struct MEDIA_EXPORT SampleAuxiliaryInformationSize : Box {
  71   DECLARE_BOX_METHODS(SampleAuxiliaryInformationSize);
  72
  73   uint8 default_sample_info_size;
  74   uint32 sample_count;
  75   std::vector<uint8> sample_info_sizes;
  76 };
  77
  78 struct MEDIA_EXPORT OriginalFormat : Box {
  79   DECLARE_BOX_METHODS(OriginalFormat);
  80
  81   FourCC format;
  82 };
  83
  84 struct MEDIA_EXPORT SchemeType : Box {
  85   DECLARE_BOX_METHODS(SchemeType);
  86
  87   FourCC type;
  88   uint32 version;
  89 };
  90
  91 struct MEDIA_EXPORT TrackEncryption : Box {
  92   DECLARE_BOX_METHODS(TrackEncryption);
  93
  94   // Note: this definition is specific to the CENC protection type.
  95   bool is_encrypted;
  96   uint8 default_iv_size;
  97   std::vector<uint8> default_kid;
  98 };
  99
 100 struct MEDIA_EXPORT SchemeInfo : Box {
 101   DECLARE_BOX_METHODS(SchemeInfo);
 102
 103   TrackEncryption track_encryption;
 104 };
 105
 106 struct MEDIA_EXPORT ProtectionSchemeInfo : Box {
 107   DECLARE_BOX_METHODS(ProtectionSchemeInfo);
 108
 109   OriginalFormat format;
 110   SchemeType type;
 111   SchemeInfo info;
 112 };
 113
 114 struct MEDIA_EXPORT MovieHeader : Box {
 115   DECLARE_BOX_METHODS(MovieHeader);
 116
 117   uint64 creation_time;
 118   uint64 modification_time;
 119   uint32 timescale;
 120   uint64 duration;
 121   int32 rate;
 122   int16 volume;
 123   uint32 next_track_id;
 124 };
 125
 126 struct MEDIA_EXPORT TrackHeader : Box {
 127   DECLARE_BOX_METHODS(TrackHeader);
 128
 129   uint64 creation_time;
 130   uint64 modification_time;
 131   uint32 track_id;
 132   uint64 duration;
 133   int16 layer;
 134   int16 alternate_group;
 135   int16 volume;
 136   uint32 width;
 137   uint32 height;
 138 };
 139
 140 struct MEDIA_EXPORT EditListEntry {
 141   uint64 segment_duration;
 142   int64 media_time;
 143   int16 media_rate_integer;
 144   int16 media_rate_fraction;
 145 };
 146
 147 struct MEDIA_EXPORT EditList : Box {
 148   DECLARE_BOX_METHODS(EditList);
 149
 150   std::vector<EditListEntry> edits;
 151 };
 152
 153 struct MEDIA_EXPORT Edit : Box {
 154   DECLARE_BOX_METHODS(Edit);
 155
 156   EditList list;
 157 };
 158
 159 struct MEDIA_EXPORT HandlerReference : Box {
 160   DECLARE_BOX_METHODS(HandlerReference);
 161
 162   TrackType type;
 163 };
 164
 165 struct MEDIA_EXPORT AVCDecoderConfigurationRecord : Box {
 166   DECLARE_BOX_METHODS(AVCDecoderConfigurationRecord);
 167
 168   // Parses AVCDecoderConfigurationRecord data encoded in |data|.
 169   // Note: This method is intended to parse data outside the MP4StreamParser
 170   //       context and therefore the box header is not expected to be present
 171   //       in |data|.
 172   // Returns true if |data| was successfully parsed.
 173   bool Parse(const uint8* data, int data_size);
 174
 175   uint8 version;
 176   uint8 profile_indication;
 177   uint8 profile_compatibility;
 178   uint8 avc_level;
 179   uint8 length_size;
 180
 181   typedef std::vector<uint8> SPS;
 182   typedef std::vector<uint8> PPS;
 183
 184   std::vector<SPS> sps_list;
 185   std::vector<PPS> pps_list;
 186
 187  private:
 188   bool ParseInternal(BufferReader* reader,
 189                      const scoped_refptr<MediaLog>& media_log);
 190 };
 191
 192 struct MEDIA_EXPORT PixelAspectRatioBox : Box {
 193   DECLARE_BOX_METHODS(PixelAspectRatioBox);
 194
 195   uint32 h_spacing;
 196   uint32 v_spacing;
 197 };
 198
 199 struct MEDIA_EXPORT VideoSampleEntry : Box {
 200   DECLARE_BOX_METHODS(VideoSampleEntry);
 201
 202   FourCC format;
 203   uint16 data_reference_index;
 204   uint16 width;
 205   uint16 height;
 206
 207   PixelAspectRatioBox pixel_aspect;
 208   ProtectionSchemeInfo sinf;
 209
 210   // Currently expected to be present regardless of format.
 211   AVCDecoderConfigurationRecord avcc;
 212
 213   bool IsFormatValid() const;
 214 };
 215
 216 struct MEDIA_EXPORT ElementaryStreamDescriptor : Box {
 217   DECLARE_BOX_METHODS(ElementaryStreamDescriptor);
 218
 219   uint8 object_type;
 220   AAC aac;
 221 };
 222
 223 struct MEDIA_EXPORT AudioSampleEntry : Box {
 224   DECLARE_BOX_METHODS(AudioSampleEntry);
 225
 226   FourCC format;
 227   uint16 data_reference_index;
 228   uint16 channelcount;
 229   uint16 samplesize;
 230   uint32 samplerate;
 231
 232   ProtectionSchemeInfo sinf;
 233   ElementaryStreamDescriptor esds;
 234 };
 235
 236 struct MEDIA_EXPORT SampleDescription : Box {
 237   DECLARE_BOX_METHODS(SampleDescription);
 238
 239   TrackType type;
 240   std::vector<VideoSampleEntry> video_entries;
 241   std::vector<AudioSampleEntry> audio_entries;
 242 };
 243
 244 struct MEDIA_EXPORT SyncSample : Box {
 245   DECLARE_BOX_METHODS(SyncSample);
 246
 247   // Returns true if the |k|th sample is a sync sample (aka a random
 248   // access point). Returns false if sample |k| is not a sync sample.
 249   bool IsSyncSample(size_t k) const;
 250
 251   bool is_present;
 252   std::vector<uint32> entries;
 253 };
 254
 255 struct MEDIA_EXPORT CencSampleEncryptionInfoEntry {
 256   CencSampleEncryptionInfoEntry();
 257   ~CencSampleEncryptionInfoEntry();
 258
 259   bool is_encrypted;
 260   uint8 iv_size;
 261   std::vector<uint8> key_id;
 262 };
 263
 264 struct MEDIA_EXPORT SampleGroupDescription : Box {  // 'sgpd'.
 265   DECLARE_BOX_METHODS(SampleGroupDescription);
 266
 267   uint32 grouping_type;
 268   std::vector<CencSampleEncryptionInfoEntry> entries;
 269 };
 270
 271 struct MEDIA_EXPORT SampleTable : Box {
 272   DECLARE_BOX_METHODS(SampleTable);
 273
 274   // Media Source specific: we ignore many of the sub-boxes in this box,
 275   // including some that are required to be present in the BMFF spec. This
 276   // includes the 'stts', 'stsc', and 'stco' boxes, which must contain no
 277   // samples in order to be compliant files.
 278   SampleDescription description;
 279   SyncSample sync_sample;
 280   SampleGroupDescription sample_group_description;
 281 };
 282
 283 struct MEDIA_EXPORT MediaHeader : Box {
 284   DECLARE_BOX_METHODS(MediaHeader);
 285
 286   uint64 creation_time;
 287   uint64 modification_time;
 288   uint32 timescale;
 289   uint64 duration;
 290 };
 291
 292 struct MEDIA_EXPORT MediaInformation : Box {
 293   DECLARE_BOX_METHODS(MediaInformation);
 294
 295   SampleTable sample_table;
 296 };
 297
 298 struct MEDIA_EXPORT Media : Box {
 299   DECLARE_BOX_METHODS(Media);
 300
 301   MediaHeader header;
 302   HandlerReference handler;
 303   MediaInformation information;
 304 };
 305
 306 struct MEDIA_EXPORT Track : Box {
 307   DECLARE_BOX_METHODS(Track);
 308
 309   TrackHeader header;
 310   Media media;
 311   Edit edit;
 312 };
 313
 314 struct MEDIA_EXPORT MovieExtendsHeader : Box {
 315   DECLARE_BOX_METHODS(MovieExtendsHeader);
 316
 317   uint64 fragment_duration;
 318 };
 319
 320 struct MEDIA_EXPORT TrackExtends : Box {
 321   DECLARE_BOX_METHODS(TrackExtends);
 322
 323   uint32 track_id;
 324   uint32 default_sample_description_index;
 325   uint32 default_sample_duration;
 326   uint32 default_sample_size;
 327   uint32 default_sample_flags;
 328 };
 329
 330 struct MEDIA_EXPORT MovieExtends : Box {
 331   DECLARE_BOX_METHODS(MovieExtends);
 332
 333   MovieExtendsHeader header;
 334   std::vector<TrackExtends> tracks;
 335 };
 336
 337 struct MEDIA_EXPORT Movie : Box {
 338   DECLARE_BOX_METHODS(Movie);
 339
 340   bool fragmented;
 341   MovieHeader header;
 342   MovieExtends extends;
 343   std::vector<Track> tracks;
 344   std::vector<ProtectionSystemSpecificHeader> pssh;
 345 };
 346
 347 struct MEDIA_EXPORT TrackFragmentDecodeTime : Box {
 348   DECLARE_BOX_METHODS(TrackFragmentDecodeTime);
 349
 350   uint64 decode_time;
 351 };
 352
 353 struct MEDIA_EXPORT MovieFragmentHeader : Box {
 354   DECLARE_BOX_METHODS(MovieFragmentHeader);
 355
 356   uint32 sequence_number;
 357 };
 358
 359 struct MEDIA_EXPORT TrackFragmentHeader : Box {
 360   DECLARE_BOX_METHODS(TrackFragmentHeader);
 361
 362   uint32 track_id;
 363
 364   uint32 sample_description_index;
 365   uint32 default_sample_duration;
 366   uint32 default_sample_size;
 367   uint32 default_sample_flags;
 368
 369   // As 'flags' might be all zero, we cannot use zeroness alone to identify
 370   // when default_sample_flags wasn't specified, unlike the other values.
 371   bool has_default_sample_flags;
 372 };
 373
 374 struct MEDIA_EXPORT TrackFragmentRun : Box {
 375   DECLARE_BOX_METHODS(TrackFragmentRun);
 376
 377   uint32 sample_count;
 378   uint32 data_offset;
 379   std::vector<uint32> sample_flags;
 380   std::vector<uint32> sample_sizes;
 381   std::vector<uint32> sample_durations;
 382   std::vector<int32> sample_composition_time_offsets;
 383 };
 384
 385 // sample_depends_on values in ISO/IEC 14496-12 Section 8.40.2.3.
 386 enum SampleDependsOn {
 387   kSampleDependsOnUnknown = 0,
 388   kSampleDependsOnOthers = 1,
 389   kSampleDependsOnNoOther = 2,
 390   kSampleDependsOnReserved = 3,
 391 };
 392
 393 class MEDIA_EXPORT IndependentAndDisposableSamples : public Box {
 394  public:
 395   DECLARE_BOX_METHODS(IndependentAndDisposableSamples);
 396
 397   // Returns the SampleDependsOn value for the |i|'th value
 398   // in the track. If no data was parsed for the |i|'th sample,
 399   // then |kSampleDependsOnUnknown| is returned.
 400   SampleDependsOn sample_depends_on(size_t i) const;
 401
 402  private:
 403   std::vector<SampleDependsOn> sample_depends_on_;
 404 };
 405
 406 struct MEDIA_EXPORT SampleToGroupEntry {
 407   enum GroupDescriptionIndexBase {
 408     kTrackGroupDescriptionIndexBase = 0,
 409     kFragmentGroupDescriptionIndexBase = 0x10000,
 410   };
 411
 412   uint32 sample_count;
 413   uint32 group_description_index;
 414 };
 415
 416 struct MEDIA_EXPORT SampleToGroup : Box {  // 'sbgp'.
 417   DECLARE_BOX_METHODS(SampleToGroup);
 418
 419   uint32 grouping_type;
 420   uint32 grouping_type_parameter;  // Version 1 only.
 421   std::vector<SampleToGroupEntry> entries;
 422 };
 423
 424 struct MEDIA_EXPORT TrackFragment : Box {
 425   DECLARE_BOX_METHODS(TrackFragment);
 426
 427   TrackFragmentHeader header;
 428   std::vector<TrackFragmentRun> runs;
 429   TrackFragmentDecodeTime decode_time;
 430   SampleAuxiliaryInformationOffset auxiliary_offset;
 431   SampleAuxiliaryInformationSize auxiliary_size;
 432   IndependentAndDisposableSamples sdtp;
 433   SampleGroupDescription sample_group_description;
 434   SampleToGroup sample_to_group;
 435 };
 436
 437 struct MEDIA_EXPORT MovieFragment : Box {
 438   DECLARE_BOX_METHODS(MovieFragment);
 439
 440   MovieFragmentHeader header;
 441   std::vector<TrackFragment> tracks;
 442   std::vector<ProtectionSystemSpecificHeader> pssh;
 443 };
 444
 445 #undef DECLARE_BOX
 446
 447 }  // namespace mp4
 448 }  // namespace media
 449
 450 #endif  // MEDIA_FORMATS_MP4_BOX_DEFINITIONS_H_