1// Copyright (c) 2012 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_MP4_BOX_DEFINITIONS_H_ 6#define MEDIA_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/mp4/aac.h" 15#include "media/mp4/avc.h" 16#include "media/mp4/box_reader.h" 17#include "media/mp4/fourccs.h" 18 19namespace media { 20namespace mp4 { 21 22enum TrackType { 23 kInvalid = 0, 24 kVideo, 25 kAudio, 26 kHint 27}; 28 29#define DECLARE_BOX_METHODS(T) \ 30 T(); \ 31 virtual ~T(); \ 32 virtual bool Parse(BoxReader* reader) OVERRIDE; \ 33 virtual FourCC BoxType() const OVERRIDE; \ 34 35struct MEDIA_EXPORT FileType : Box { 36 DECLARE_BOX_METHODS(FileType); 37 38 FourCC major_brand; 39 uint32 minor_version; 40}; 41 42struct MEDIA_EXPORT ProtectionSystemSpecificHeader : Box { 43 DECLARE_BOX_METHODS(ProtectionSystemSpecificHeader); 44 45 std::vector<uint8> system_id; 46 std::vector<uint8> raw_box; 47}; 48 49struct MEDIA_EXPORT SampleAuxiliaryInformationOffset : Box { 50 DECLARE_BOX_METHODS(SampleAuxiliaryInformationOffset); 51 52 std::vector<uint64> offsets; 53}; 54 55struct MEDIA_EXPORT SampleAuxiliaryInformationSize : Box { 56 DECLARE_BOX_METHODS(SampleAuxiliaryInformationSize); 57 58 uint8 default_sample_info_size; 59 uint32 sample_count; 60 std::vector<uint8> sample_info_sizes; 61}; 62 63struct MEDIA_EXPORT OriginalFormat : Box { 64 DECLARE_BOX_METHODS(OriginalFormat); 65 66 FourCC format; 67}; 68 69struct MEDIA_EXPORT SchemeType : Box { 70 DECLARE_BOX_METHODS(SchemeType); 71 72 FourCC type; 73 uint32 version; 74}; 75 76struct MEDIA_EXPORT TrackEncryption : Box { 77 DECLARE_BOX_METHODS(TrackEncryption); 78 79 // Note: this definition is specific to the CENC protection type. 80 bool is_encrypted; 81 uint8 default_iv_size; 82 std::vector<uint8> default_kid; 83}; 84 85struct MEDIA_EXPORT SchemeInfo : Box { 86 DECLARE_BOX_METHODS(SchemeInfo); 87 88 TrackEncryption track_encryption; 89}; 90 91struct MEDIA_EXPORT ProtectionSchemeInfo : Box { 92 DECLARE_BOX_METHODS(ProtectionSchemeInfo); 93 94 OriginalFormat format; 95 SchemeType type; 96 SchemeInfo info; 97}; 98 99struct MEDIA_EXPORT MovieHeader : Box { 100 DECLARE_BOX_METHODS(MovieHeader); 101 102 uint64 creation_time; 103 uint64 modification_time; 104 uint32 timescale; 105 uint64 duration; 106 int32 rate; 107 int16 volume; 108 uint32 next_track_id; 109}; 110 111struct MEDIA_EXPORT TrackHeader : Box { 112 DECLARE_BOX_METHODS(TrackHeader); 113 114 uint64 creation_time; 115 uint64 modification_time; 116 uint32 track_id; 117 uint64 duration; 118 int16 layer; 119 int16 alternate_group; 120 int16 volume; 121 uint32 width; 122 uint32 height; 123}; 124 125struct MEDIA_EXPORT EditListEntry { 126 uint64 segment_duration; 127 int64 media_time; 128 int16 media_rate_integer; 129 int16 media_rate_fraction; 130}; 131 132struct MEDIA_EXPORT EditList : Box { 133 DECLARE_BOX_METHODS(EditList); 134 135 std::vector<EditListEntry> edits; 136}; 137 138struct MEDIA_EXPORT Edit : Box { 139 DECLARE_BOX_METHODS(Edit); 140 141 EditList list; 142}; 143 144struct MEDIA_EXPORT HandlerReference : Box { 145 DECLARE_BOX_METHODS(HandlerReference); 146 147 TrackType type; 148}; 149 150struct MEDIA_EXPORT AVCDecoderConfigurationRecord : Box { 151 DECLARE_BOX_METHODS(AVCDecoderConfigurationRecord); 152 153 uint8 version; 154 uint8 profile_indication; 155 uint8 profile_compatibility; 156 uint8 avc_level; 157 uint8 length_size; 158 159 typedef std::vector<uint8> SPS; 160 typedef std::vector<uint8> PPS; 161 162 std::vector<SPS> sps_list; 163 std::vector<PPS> pps_list; 164}; 165 166struct MEDIA_EXPORT PixelAspectRatioBox : Box { 167 DECLARE_BOX_METHODS(PixelAspectRatioBox); 168 169 uint32 h_spacing; 170 uint32 v_spacing; 171}; 172 173struct MEDIA_EXPORT VideoSampleEntry : Box { 174 DECLARE_BOX_METHODS(VideoSampleEntry); 175 176 FourCC format; 177 uint16 data_reference_index; 178 uint16 width; 179 uint16 height; 180 181 PixelAspectRatioBox pixel_aspect; 182 ProtectionSchemeInfo sinf; 183 184 // Currently expected to be present regardless of format. 185 AVCDecoderConfigurationRecord avcc; 186}; 187 188struct MEDIA_EXPORT ElementaryStreamDescriptor : Box { 189 DECLARE_BOX_METHODS(ElementaryStreamDescriptor); 190 191 uint8 object_type; 192 AAC aac; 193}; 194 195struct MEDIA_EXPORT AudioSampleEntry : Box { 196 DECLARE_BOX_METHODS(AudioSampleEntry); 197 198 FourCC format; 199 uint16 data_reference_index; 200 uint16 channelcount; 201 uint16 samplesize; 202 uint32 samplerate; 203 204 ProtectionSchemeInfo sinf; 205 ElementaryStreamDescriptor esds; 206}; 207 208struct MEDIA_EXPORT SampleDescription : Box { 209 DECLARE_BOX_METHODS(SampleDescription); 210 211 TrackType type; 212 std::vector<VideoSampleEntry> video_entries; 213 std::vector<AudioSampleEntry> audio_entries; 214}; 215 216struct MEDIA_EXPORT SampleTable : Box { 217 DECLARE_BOX_METHODS(SampleTable); 218 219 // Media Source specific: we ignore many of the sub-boxes in this box, 220 // including some that are required to be present in the BMFF spec. This 221 // includes the 'stts', 'stsc', and 'stco' boxes, which must contain no 222 // samples in order to be compliant files. 223 SampleDescription description; 224}; 225 226struct MEDIA_EXPORT MediaHeader : Box { 227 DECLARE_BOX_METHODS(MediaHeader); 228 229 uint64 creation_time; 230 uint64 modification_time; 231 uint32 timescale; 232 uint64 duration; 233}; 234 235struct MEDIA_EXPORT MediaInformation : Box { 236 DECLARE_BOX_METHODS(MediaInformation); 237 238 SampleTable sample_table; 239}; 240 241struct MEDIA_EXPORT Media : Box { 242 DECLARE_BOX_METHODS(Media); 243 244 MediaHeader header; 245 HandlerReference handler; 246 MediaInformation information; 247}; 248 249struct MEDIA_EXPORT Track : Box { 250 DECLARE_BOX_METHODS(Track); 251 252 TrackHeader header; 253 Media media; 254 Edit edit; 255}; 256 257struct MEDIA_EXPORT MovieExtendsHeader : Box { 258 DECLARE_BOX_METHODS(MovieExtendsHeader); 259 260 uint64 fragment_duration; 261}; 262 263struct MEDIA_EXPORT TrackExtends : Box { 264 DECLARE_BOX_METHODS(TrackExtends); 265 266 uint32 track_id; 267 uint32 default_sample_description_index; 268 uint32 default_sample_duration; 269 uint32 default_sample_size; 270 uint32 default_sample_flags; 271}; 272 273struct MEDIA_EXPORT MovieExtends : Box { 274 DECLARE_BOX_METHODS(MovieExtends); 275 276 MovieExtendsHeader header; 277 std::vector<TrackExtends> tracks; 278}; 279 280struct MEDIA_EXPORT Movie : Box { 281 DECLARE_BOX_METHODS(Movie); 282 283 bool fragmented; 284 MovieHeader header; 285 MovieExtends extends; 286 std::vector<Track> tracks; 287 std::vector<ProtectionSystemSpecificHeader> pssh; 288}; 289 290struct MEDIA_EXPORT TrackFragmentDecodeTime : Box { 291 DECLARE_BOX_METHODS(TrackFragmentDecodeTime); 292 293 uint64 decode_time; 294}; 295 296struct MEDIA_EXPORT MovieFragmentHeader : Box { 297 DECLARE_BOX_METHODS(MovieFragmentHeader); 298 299 uint32 sequence_number; 300}; 301 302struct MEDIA_EXPORT TrackFragmentHeader : Box { 303 DECLARE_BOX_METHODS(TrackFragmentHeader); 304 305 uint32 track_id; 306 307 uint32 sample_description_index; 308 uint32 default_sample_duration; 309 uint32 default_sample_size; 310 uint32 default_sample_flags; 311 312 // As 'flags' might be all zero, we cannot use zeroness alone to identify 313 // when default_sample_flags wasn't specified, unlike the other values. 314 bool has_default_sample_flags; 315}; 316 317struct MEDIA_EXPORT TrackFragmentRun : Box { 318 DECLARE_BOX_METHODS(TrackFragmentRun); 319 320 uint32 sample_count; 321 uint32 data_offset; 322 std::vector<uint32> sample_flags; 323 std::vector<uint32> sample_sizes; 324 std::vector<uint32> sample_durations; 325 std::vector<int32> sample_composition_time_offsets; 326}; 327 328struct MEDIA_EXPORT TrackFragment : Box { 329 DECLARE_BOX_METHODS(TrackFragment); 330 331 TrackFragmentHeader header; 332 std::vector<TrackFragmentRun> runs; 333 TrackFragmentDecodeTime decode_time; 334 SampleAuxiliaryInformationOffset auxiliary_offset; 335 SampleAuxiliaryInformationSize auxiliary_size; 336}; 337 338struct MEDIA_EXPORT MovieFragment : Box { 339 DECLARE_BOX_METHODS(MovieFragment); 340 341 MovieFragmentHeader header; 342 std::vector<TrackFragment> tracks; 343 std::vector<ProtectionSystemSpecificHeader> pssh; 344}; 345 346#undef DECLARE_BOX 347 348} // namespace mp4 349} // namespace media 350 351#endif // MEDIA_MP4_BOX_DEFINITIONS_H_ 352