box_definitions.h 17 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629
  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. #ifndef MEDIA_FORMATS_MP4_BOX_DEFINITIONS_H_
  5. #define MEDIA_FORMATS_MP4_BOX_DEFINITIONS_H_
  6. #include <stddef.h>
  7. #include <stdint.h>
  8. #include <string>
  9. #include <vector>
  10. #include "base/compiler_specific.h"
  11. #include "base/time/time.h"
  12. #include "media/base/decrypt_config.h"
  13. #include "media/base/media_export.h"
  14. #include "media/base/media_log.h"
  15. #include "media/base/video_codecs.h"
  16. #include "media/formats/mp4/aac.h"
  17. #include "media/formats/mp4/avc.h"
  18. #include "media/formats/mp4/box_reader.h"
  19. #include "media/formats/mp4/dts.h"
  20. #include "media/formats/mp4/dtsx.h"
  21. #include "media/formats/mp4/fourccs.h"
  22. #include "media/media_buildflags.h"
  23. #include "third_party/abseil-cpp/absl/types/optional.h"
  24. namespace media {
  25. namespace mp4 {
  26. // Size in bytes needed to store largest IV.
  27. const int kInitializationVectorSize = 16;
  28. enum TrackType { kInvalid = 0, kVideo, kAudio, kText, kHint };
  29. enum SampleFlags {
  30. kSampleIsNonSyncSample = 0x10000
  31. };
  32. #define DECLARE_BOX_METHODS(T) \
  33. T(); \
  34. T(const T& other); \
  35. ~T() override; \
  36. bool Parse(BoxReader* reader) override; \
  37. FourCC BoxType() const override
  38. struct MEDIA_EXPORT FileType : Box {
  39. DECLARE_BOX_METHODS(FileType);
  40. FourCC major_brand;
  41. uint32_t minor_version;
  42. };
  43. // If only copying the 'pssh' boxes, use ProtectionSystemSpecificHeader.
  44. // If access to the individual fields is needed, use
  45. // FullProtectionSystemSpecificHeader.
  46. struct MEDIA_EXPORT ProtectionSystemSpecificHeader : Box {
  47. DECLARE_BOX_METHODS(ProtectionSystemSpecificHeader);
  48. std::vector<uint8_t> raw_box;
  49. };
  50. struct MEDIA_EXPORT FullProtectionSystemSpecificHeader : Box {
  51. DECLARE_BOX_METHODS(FullProtectionSystemSpecificHeader);
  52. std::vector<uint8_t> system_id;
  53. std::vector<std::vector<uint8_t>> key_ids;
  54. std::vector<uint8_t> data;
  55. };
  56. struct MEDIA_EXPORT SampleAuxiliaryInformationOffset : Box {
  57. DECLARE_BOX_METHODS(SampleAuxiliaryInformationOffset);
  58. std::vector<uint64_t> offsets;
  59. };
  60. struct MEDIA_EXPORT SampleAuxiliaryInformationSize : Box {
  61. DECLARE_BOX_METHODS(SampleAuxiliaryInformationSize);
  62. uint8_t default_sample_info_size;
  63. uint32_t sample_count;
  64. std::vector<uint8_t> sample_info_sizes;
  65. };
  66. // Represent an entry in SampleEncryption box or CENC auxiliary info.
  67. struct MEDIA_EXPORT SampleEncryptionEntry {
  68. SampleEncryptionEntry();
  69. SampleEncryptionEntry(const SampleEncryptionEntry& other);
  70. ~SampleEncryptionEntry();
  71. // Parse SampleEncryptionEntry from |reader|.
  72. // |iv_size| specifies the size of initialization vector. |has_subsamples|
  73. // indicates whether this sample encryption entry constains subsamples.
  74. // Returns false if parsing fails.
  75. bool Parse(BufferReader* reader, uint8_t iv_size, bool has_subsamples);
  76. // Get accumulated size of subsamples. Returns false if there is an overflow
  77. // anywhere.
  78. bool GetTotalSizeOfSubsamples(size_t* total_size) const;
  79. uint8_t initialization_vector[kInitializationVectorSize];
  80. std::vector<SubsampleEntry> subsamples;
  81. };
  82. // ISO/IEC 23001-7:2015 8.1.1.
  83. struct MEDIA_EXPORT SampleEncryption : Box {
  84. enum SampleEncryptionFlags {
  85. kUseSubsampleEncryption = 2,
  86. };
  87. DECLARE_BOX_METHODS(SampleEncryption);
  88. bool use_subsample_encryption;
  89. // We may not know |iv_size| before reading this box, so we store the box
  90. // data for parsing later when |iv_size| is known.
  91. std::vector<uint8_t> sample_encryption_data;
  92. };
  93. struct MEDIA_EXPORT OriginalFormat : Box {
  94. DECLARE_BOX_METHODS(OriginalFormat);
  95. FourCC format;
  96. };
  97. struct MEDIA_EXPORT SchemeType : Box {
  98. DECLARE_BOX_METHODS(SchemeType);
  99. FourCC type;
  100. uint32_t version;
  101. };
  102. struct MEDIA_EXPORT TrackEncryption : Box {
  103. DECLARE_BOX_METHODS(TrackEncryption);
  104. // Note: this definition is specific to the CENC protection type.
  105. bool is_encrypted;
  106. uint8_t default_iv_size;
  107. std::vector<uint8_t> default_kid;
  108. uint8_t default_crypt_byte_block;
  109. uint8_t default_skip_byte_block;
  110. uint8_t default_constant_iv_size;
  111. uint8_t default_constant_iv[kInitializationVectorSize];
  112. };
  113. struct MEDIA_EXPORT SchemeInfo : Box {
  114. DECLARE_BOX_METHODS(SchemeInfo);
  115. TrackEncryption track_encryption;
  116. };
  117. struct MEDIA_EXPORT ProtectionSchemeInfo : Box {
  118. DECLARE_BOX_METHODS(ProtectionSchemeInfo);
  119. OriginalFormat format;
  120. SchemeType type;
  121. SchemeInfo info;
  122. bool HasSupportedScheme() const;
  123. bool IsCbcsEncryptionScheme() const;
  124. };
  125. struct MEDIA_EXPORT MovieHeader : Box {
  126. DECLARE_BOX_METHODS(MovieHeader);
  127. uint8_t version;
  128. uint64_t creation_time;
  129. uint64_t modification_time;
  130. uint32_t timescale;
  131. uint64_t duration;
  132. int32_t rate;
  133. int16_t volume;
  134. // A 3x3 matrix of [ A B C ]
  135. // [ D E F ]
  136. // [ U V W ]
  137. // Where A-F are 16.16 fixed point decimals
  138. // And U, V, W are 2.30 fixed point decimals.
  139. DisplayMatrix display_matrix;
  140. uint32_t next_track_id;
  141. };
  142. struct MEDIA_EXPORT TrackHeader : Box {
  143. DECLARE_BOX_METHODS(TrackHeader);
  144. uint64_t creation_time;
  145. uint64_t modification_time;
  146. uint32_t track_id;
  147. uint64_t duration;
  148. int16_t layer;
  149. int16_t alternate_group;
  150. int16_t volume;
  151. DisplayMatrix display_matrix; // See MovieHeader.display_matrix
  152. uint32_t width;
  153. uint32_t height;
  154. };
  155. struct MEDIA_EXPORT EditListEntry {
  156. uint64_t segment_duration;
  157. int64_t media_time;
  158. int16_t media_rate_integer;
  159. int16_t media_rate_fraction;
  160. };
  161. struct MEDIA_EXPORT EditList : Box {
  162. DECLARE_BOX_METHODS(EditList);
  163. std::vector<EditListEntry> edits;
  164. };
  165. struct MEDIA_EXPORT Edit : Box {
  166. DECLARE_BOX_METHODS(Edit);
  167. EditList list;
  168. };
  169. struct MEDIA_EXPORT HandlerReference : Box {
  170. DECLARE_BOX_METHODS(HandlerReference);
  171. TrackType type;
  172. std::string name;
  173. };
  174. #if BUILDFLAG(USE_PROPRIETARY_CODECS)
  175. struct MEDIA_EXPORT AVCDecoderConfigurationRecord : Box {
  176. DECLARE_BOX_METHODS(AVCDecoderConfigurationRecord);
  177. // Parses AVCDecoderConfigurationRecord data encoded in |data|.
  178. // Note: This method is intended to parse data outside the MP4StreamParser
  179. // context and therefore the box header is not expected to be present
  180. // in |data|.
  181. // Returns true if |data| was successfully parsed.
  182. bool Parse(const uint8_t* data, int data_size);
  183. bool Serialize(std::vector<uint8_t>& output) const;
  184. uint8_t version;
  185. uint8_t profile_indication;
  186. uint8_t profile_compatibility;
  187. uint8_t avc_level;
  188. uint8_t length_size;
  189. typedef std::vector<uint8_t> SPS;
  190. typedef std::vector<uint8_t> PPS;
  191. std::vector<SPS> sps_list;
  192. std::vector<PPS> pps_list;
  193. private:
  194. bool ParseInternal(BufferReader* reader, MediaLog* media_log);
  195. };
  196. #endif // BUILDFLAG(USE_PROPRIETARY_CODECS)
  197. struct MEDIA_EXPORT VPCodecConfigurationRecord : Box {
  198. DECLARE_BOX_METHODS(VPCodecConfigurationRecord);
  199. VideoCodecProfile profile;
  200. VideoColorSpace color_space;
  201. uint8_t level;
  202. };
  203. #if BUILDFLAG(ENABLE_AV1_DECODER)
  204. struct MEDIA_EXPORT AV1CodecConfigurationRecord : Box {
  205. DECLARE_BOX_METHODS(AV1CodecConfigurationRecord);
  206. VideoCodecProfile profile;
  207. };
  208. #endif
  209. struct MEDIA_EXPORT PixelAspectRatioBox : Box {
  210. DECLARE_BOX_METHODS(PixelAspectRatioBox);
  211. uint32_t h_spacing;
  212. uint32_t v_spacing;
  213. };
  214. struct MEDIA_EXPORT ColorParameterInformation : Box {
  215. DECLARE_BOX_METHODS(ColorParameterInformation);
  216. uint16_t colour_primaries;
  217. uint16_t transfer_characteristics;
  218. uint16_t matrix_coefficients;
  219. bool full_range;
  220. bool fully_parsed;
  221. };
  222. struct MEDIA_EXPORT MasteringDisplayColorVolume : Box {
  223. DECLARE_BOX_METHODS(MasteringDisplayColorVolume);
  224. float display_primaries_gx;
  225. float display_primaries_gy;
  226. float display_primaries_bx;
  227. float display_primaries_by;
  228. float display_primaries_rx;
  229. float display_primaries_ry;
  230. float white_point_x;
  231. float white_point_y;
  232. float max_display_mastering_luminance;
  233. float min_display_mastering_luminance;
  234. };
  235. // Mostly the same as MasteringDisplayColorVolume, but with a different fourcc
  236. // and slightly different layout and format of encoded values.
  237. struct MEDIA_EXPORT SMPTE2086MasteringDisplayMetadataBox
  238. : MasteringDisplayColorVolume {
  239. bool Parse(BoxReader* reader) override;
  240. FourCC BoxType() const override;
  241. };
  242. struct MEDIA_EXPORT ContentLightLevelInformation : Box {
  243. DECLARE_BOX_METHODS(ContentLightLevelInformation);
  244. uint16_t max_content_light_level;
  245. uint16_t max_pic_average_light_level;
  246. };
  247. // Same as ContentLightLevelInformation, but with a different fourcc.
  248. struct MEDIA_EXPORT ContentLightLevel : ContentLightLevelInformation {
  249. bool Parse(BoxReader* reader) override;
  250. FourCC BoxType() const override;
  251. };
  252. struct MEDIA_EXPORT VideoSampleEntry : Box {
  253. DECLARE_BOX_METHODS(VideoSampleEntry);
  254. FourCC format;
  255. uint16_t data_reference_index;
  256. uint16_t width;
  257. uint16_t height;
  258. PixelAspectRatioBox pixel_aspect;
  259. ProtectionSchemeInfo sinf;
  260. VideoCodec video_codec;
  261. VideoCodecProfile video_codec_profile;
  262. VideoCodecLevel video_codec_level;
  263. VideoColorSpace video_color_space;
  264. absl::optional<MasteringDisplayColorVolume> mastering_display_color_volume;
  265. absl::optional<ContentLightLevelInformation> content_light_level_information;
  266. bool IsFormatValid() const;
  267. scoped_refptr<BitstreamConverter> frame_bitstream_converter;
  268. };
  269. struct MEDIA_EXPORT ElementaryStreamDescriptor : Box {
  270. DECLARE_BOX_METHODS(ElementaryStreamDescriptor);
  271. uint8_t object_type;
  272. #if BUILDFLAG(USE_PROPRIETARY_CODECS)
  273. AAC aac;
  274. #endif
  275. };
  276. struct MEDIA_EXPORT FlacSpecificBox : Box {
  277. DECLARE_BOX_METHODS(FlacSpecificBox);
  278. // We only care about the first metadata block, and it must be
  279. // METADATA_BLOCK_STREAM_INFO.
  280. // For FLAC decoder configuration, this is needed as extradata().
  281. // TODO(wolenetz,xhwang): MediaCodec or CDM decode of FLAC may need the
  282. // METADATA_BLOCK_HEADER, too (and if so, we may need to force the
  283. // last-metadata-block-flag in that header to be true, to allow us to ignore
  284. // non-streaminfo blocks.) Alternatively, the header can be reconstructed.
  285. // See https://crbug.com/747050.
  286. std::vector<uint8_t> stream_info;
  287. // MP4StreamParser needs this subset of |stream_info| parsed:
  288. uint32_t sample_rate;
  289. uint8_t channel_count;
  290. uint8_t bits_per_sample;
  291. };
  292. struct MEDIA_EXPORT OpusSpecificBox : Box {
  293. DECLARE_BOX_METHODS(OpusSpecificBox);
  294. std::vector<uint8_t> extradata;
  295. base::TimeDelta seek_preroll;
  296. uint16_t codec_delay_in_frames;
  297. uint8_t channel_count;
  298. uint32_t sample_rate;
  299. };
  300. #if BUILDFLAG(USE_PROPRIETARY_CODECS) && BUILDFLAG(ENABLE_PLATFORM_DTS_AUDIO)
  301. struct MEDIA_EXPORT DtsSpecificBox : Box {
  302. DECLARE_BOX_METHODS(DtsSpecificBox);
  303. DTS dts;
  304. };
  305. struct MEDIA_EXPORT DtsUhdSpecificBox : Box {
  306. DECLARE_BOX_METHODS(DtsUhdSpecificBox);
  307. DTSX dtsx;
  308. };
  309. #endif // BUILDFLAG(USE_PROPRIETARY_CODECS) &&
  310. // BUILDFLAG(ENABLE_PLATFORM_DTS_AUDIO)
  311. struct MEDIA_EXPORT AudioSampleEntry : Box {
  312. DECLARE_BOX_METHODS(AudioSampleEntry);
  313. FourCC format;
  314. uint16_t data_reference_index;
  315. uint16_t channelcount;
  316. uint16_t samplesize;
  317. uint32_t samplerate;
  318. ProtectionSchemeInfo sinf;
  319. ElementaryStreamDescriptor esds;
  320. FlacSpecificBox dfla;
  321. OpusSpecificBox dops;
  322. #if BUILDFLAG(USE_PROPRIETARY_CODECS) && BUILDFLAG(ENABLE_PLATFORM_DTS_AUDIO)
  323. DtsSpecificBox ddts;
  324. DtsUhdSpecificBox udts;
  325. #endif // BUILDFLAG(USE_PROPRIETARY_CODECS) &&
  326. // BUILDFLAG(ENABLE_PLATFORM_DTS_AUDIO)
  327. };
  328. struct MEDIA_EXPORT SampleDescription : Box {
  329. DECLARE_BOX_METHODS(SampleDescription);
  330. TrackType type;
  331. std::vector<VideoSampleEntry> video_entries;
  332. std::vector<AudioSampleEntry> audio_entries;
  333. };
  334. struct MEDIA_EXPORT CencSampleEncryptionInfoEntry {
  335. CencSampleEncryptionInfoEntry();
  336. CencSampleEncryptionInfoEntry(const CencSampleEncryptionInfoEntry& other);
  337. ~CencSampleEncryptionInfoEntry();
  338. bool Parse(BoxReader* reader);
  339. bool is_encrypted;
  340. uint8_t iv_size;
  341. std::vector<uint8_t> key_id;
  342. uint8_t crypt_byte_block;
  343. uint8_t skip_byte_block;
  344. uint8_t constant_iv_size;
  345. uint8_t constant_iv[kInitializationVectorSize];
  346. };
  347. struct MEDIA_EXPORT SampleGroupDescription : Box { // 'sgpd'.
  348. DECLARE_BOX_METHODS(SampleGroupDescription);
  349. uint32_t grouping_type;
  350. std::vector<CencSampleEncryptionInfoEntry> entries;
  351. };
  352. struct MEDIA_EXPORT SampleTable : Box {
  353. DECLARE_BOX_METHODS(SampleTable);
  354. // Media Source specific: we ignore many of the sub-boxes in this box,
  355. // including some that are required to be present in the BMFF spec. This
  356. // includes the 'stts', 'stsc', and 'stco' boxes, which must contain no
  357. // samples in order to be compliant files.
  358. SampleDescription description;
  359. SampleGroupDescription sample_group_description;
  360. };
  361. struct MEDIA_EXPORT MediaHeader : Box {
  362. DECLARE_BOX_METHODS(MediaHeader);
  363. std::string language() const;
  364. uint64_t creation_time;
  365. uint64_t modification_time;
  366. uint32_t timescale;
  367. uint64_t duration;
  368. uint16_t language_code;
  369. };
  370. struct MEDIA_EXPORT MediaInformation : Box {
  371. DECLARE_BOX_METHODS(MediaInformation);
  372. SampleTable sample_table;
  373. };
  374. struct MEDIA_EXPORT Media : Box {
  375. DECLARE_BOX_METHODS(Media);
  376. MediaHeader header;
  377. HandlerReference handler;
  378. MediaInformation information;
  379. };
  380. struct MEDIA_EXPORT Track : Box {
  381. DECLARE_BOX_METHODS(Track);
  382. TrackHeader header;
  383. Media media;
  384. Edit edit;
  385. };
  386. struct MEDIA_EXPORT MovieExtendsHeader : Box {
  387. DECLARE_BOX_METHODS(MovieExtendsHeader);
  388. uint64_t fragment_duration;
  389. };
  390. struct MEDIA_EXPORT TrackExtends : Box {
  391. DECLARE_BOX_METHODS(TrackExtends);
  392. uint32_t track_id;
  393. uint32_t default_sample_description_index;
  394. uint32_t default_sample_duration;
  395. uint32_t default_sample_size;
  396. uint32_t default_sample_flags;
  397. };
  398. struct MEDIA_EXPORT MovieExtends : Box {
  399. DECLARE_BOX_METHODS(MovieExtends);
  400. MovieExtendsHeader header;
  401. std::vector<TrackExtends> tracks;
  402. };
  403. struct MEDIA_EXPORT Movie : Box {
  404. DECLARE_BOX_METHODS(Movie);
  405. bool fragmented;
  406. MovieHeader header;
  407. MovieExtends extends;
  408. std::vector<Track> tracks;
  409. std::vector<ProtectionSystemSpecificHeader> pssh;
  410. };
  411. struct MEDIA_EXPORT TrackFragmentDecodeTime : Box {
  412. DECLARE_BOX_METHODS(TrackFragmentDecodeTime);
  413. uint64_t decode_time;
  414. };
  415. struct MEDIA_EXPORT MovieFragmentHeader : Box {
  416. DECLARE_BOX_METHODS(MovieFragmentHeader);
  417. uint32_t sequence_number;
  418. };
  419. struct MEDIA_EXPORT TrackFragmentHeader : Box {
  420. DECLARE_BOX_METHODS(TrackFragmentHeader);
  421. uint32_t track_id;
  422. uint32_t sample_description_index;
  423. uint32_t default_sample_duration;
  424. uint32_t default_sample_size;
  425. uint32_t default_sample_flags;
  426. // As 'flags' might be all zero, we cannot use zeroness alone to identify
  427. // when default_sample_flags wasn't specified, unlike the other values.
  428. bool has_default_sample_flags;
  429. };
  430. struct MEDIA_EXPORT TrackFragmentRun : Box {
  431. DECLARE_BOX_METHODS(TrackFragmentRun);
  432. uint32_t sample_count;
  433. uint32_t data_offset;
  434. std::vector<uint32_t> sample_flags;
  435. std::vector<uint32_t> sample_sizes;
  436. std::vector<uint32_t> sample_durations;
  437. std::vector<int32_t> sample_composition_time_offsets;
  438. };
  439. // sample_depends_on values in ISO/IEC 14496-12 Section 8.40.2.3.
  440. enum SampleDependsOn {
  441. kSampleDependsOnUnknown = 0,
  442. kSampleDependsOnOthers = 1,
  443. kSampleDependsOnNoOther = 2,
  444. kSampleDependsOnReserved = 3,
  445. };
  446. class MEDIA_EXPORT IndependentAndDisposableSamples : public Box {
  447. public:
  448. DECLARE_BOX_METHODS(IndependentAndDisposableSamples);
  449. // Returns the SampleDependsOn value for the |i|'th value
  450. // in the track. If no data was parsed for the |i|'th sample,
  451. // then |kSampleDependsOnUnknown| is returned.
  452. SampleDependsOn sample_depends_on(size_t i) const;
  453. private:
  454. std::vector<SampleDependsOn> sample_depends_on_;
  455. };
  456. struct MEDIA_EXPORT SampleToGroupEntry {
  457. enum GroupDescriptionIndexBase {
  458. kTrackGroupDescriptionIndexBase = 0,
  459. kFragmentGroupDescriptionIndexBase = 0x10000,
  460. };
  461. uint32_t sample_count;
  462. uint32_t group_description_index;
  463. };
  464. struct MEDIA_EXPORT SampleToGroup : Box { // 'sbgp'.
  465. DECLARE_BOX_METHODS(SampleToGroup);
  466. uint32_t grouping_type;
  467. uint32_t grouping_type_parameter; // Version 1 only.
  468. std::vector<SampleToGroupEntry> entries;
  469. };
  470. struct MEDIA_EXPORT TrackFragment : Box {
  471. DECLARE_BOX_METHODS(TrackFragment);
  472. TrackFragmentHeader header;
  473. std::vector<TrackFragmentRun> runs;
  474. TrackFragmentDecodeTime decode_time;
  475. SampleAuxiliaryInformationOffset auxiliary_offset;
  476. SampleAuxiliaryInformationSize auxiliary_size;
  477. IndependentAndDisposableSamples sdtp;
  478. SampleGroupDescription sample_group_description;
  479. SampleToGroup sample_to_group;
  480. SampleEncryption sample_encryption;
  481. };
  482. struct MEDIA_EXPORT MovieFragment : Box {
  483. DECLARE_BOX_METHODS(MovieFragment);
  484. MovieFragmentHeader header;
  485. std::vector<TrackFragment> tracks;
  486. std::vector<ProtectionSystemSpecificHeader> pssh;
  487. };
  488. #undef DECLARE_BOX
  489. } // namespace mp4
  490. } // namespace media
  491. #endif // MEDIA_FORMATS_MP4_BOX_DEFINITIONS_H_