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