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 19 namespace media { 20 namespace mp4 { 21 22 enum 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 35 struct MEDIA_EXPORT FileType : Box { 36 DECLARE_BOX_METHODS(FileType); 37 38 FourCC major_brand; 39 uint32 minor_version; 40 }; 41 42 struct MEDIA_EXPORT ProtectionSystemSpecificHeader : Box { 43 DECLARE_BOX_METHODS(ProtectionSystemSpecificHeader); 44 45 std::vector<uint8> system_id; 46 std::vector<uint8> raw_box; 47 }; 48 49 struct MEDIA_EXPORT SampleAuxiliaryInformationOffset : Box { 50 DECLARE_BOX_METHODS(SampleAuxiliaryInformationOffset); 51 52 std::vector<uint64> offsets; 53 }; 54 55 struct 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 63 struct MEDIA_EXPORT OriginalFormat : Box { 64 DECLARE_BOX_METHODS(OriginalFormat); 65 66 FourCC format; 67 }; 68 69 struct MEDIA_EXPORT SchemeType : Box { 70 DECLARE_BOX_METHODS(SchemeType); 71 72 FourCC type; 73 uint32 version; 74 }; 75 76 struct 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 85 struct MEDIA_EXPORT SchemeInfo : Box { 86 DECLARE_BOX_METHODS(SchemeInfo); 87 88 TrackEncryption track_encryption; 89 }; 90 91 struct MEDIA_EXPORT ProtectionSchemeInfo : Box { 92 DECLARE_BOX_METHODS(ProtectionSchemeInfo); 93 94 OriginalFormat format; 95 SchemeType type; 96 SchemeInfo info; 97 }; 98 99 struct 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 111 struct 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 125 struct MEDIA_EXPORT EditListEntry { 126 uint64 segment_duration; 127 int64 media_time; 128 int16 media_rate_integer; 129 int16 media_rate_fraction; 130 }; 131 132 struct MEDIA_EXPORT EditList : Box { 133 DECLARE_BOX_METHODS(EditList); 134 135 std::vector<EditListEntry> edits; 136 }; 137 138 struct MEDIA_EXPORT Edit : Box { 139 DECLARE_BOX_METHODS(Edit); 140 141 EditList list; 142 }; 143 144 struct MEDIA_EXPORT HandlerReference : Box { 145 DECLARE_BOX_METHODS(HandlerReference); 146 147 TrackType type; 148 }; 149 150 struct 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 166 struct MEDIA_EXPORT PixelAspectRatioBox : Box { 167 DECLARE_BOX_METHODS(PixelAspectRatioBox); 168 169 uint32 h_spacing; 170 uint32 v_spacing; 171 }; 172 173 struct 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 bool IsFormatValid() const; 188 }; 189 190 struct MEDIA_EXPORT ElementaryStreamDescriptor : Box { 191 DECLARE_BOX_METHODS(ElementaryStreamDescriptor); 192 193 uint8 object_type; 194 AAC aac; 195 }; 196 197 struct MEDIA_EXPORT AudioSampleEntry : Box { 198 DECLARE_BOX_METHODS(AudioSampleEntry); 199 200 FourCC format; 201 uint16 data_reference_index; 202 uint16 channelcount; 203 uint16 samplesize; 204 uint32 samplerate; 205 206 ProtectionSchemeInfo sinf; 207 ElementaryStreamDescriptor esds; 208 }; 209 210 struct MEDIA_EXPORT SampleDescription : Box { 211 DECLARE_BOX_METHODS(SampleDescription); 212 213 TrackType type; 214 std::vector<VideoSampleEntry> video_entries; 215 std::vector<AudioSampleEntry> audio_entries; 216 }; 217 218 struct MEDIA_EXPORT SampleTable : Box { 219 DECLARE_BOX_METHODS(SampleTable); 220 221 // Media Source specific: we ignore many of the sub-boxes in this box, 222 // including some that are required to be present in the BMFF spec. This 223 // includes the 'stts', 'stsc', and 'stco' boxes, which must contain no 224 // samples in order to be compliant files. 225 SampleDescription description; 226 }; 227 228 struct MEDIA_EXPORT MediaHeader : Box { 229 DECLARE_BOX_METHODS(MediaHeader); 230 231 uint64 creation_time; 232 uint64 modification_time; 233 uint32 timescale; 234 uint64 duration; 235 }; 236 237 struct MEDIA_EXPORT MediaInformation : Box { 238 DECLARE_BOX_METHODS(MediaInformation); 239 240 SampleTable sample_table; 241 }; 242 243 struct MEDIA_EXPORT Media : Box { 244 DECLARE_BOX_METHODS(Media); 245 246 MediaHeader header; 247 HandlerReference handler; 248 MediaInformation information; 249 }; 250 251 struct MEDIA_EXPORT Track : Box { 252 DECLARE_BOX_METHODS(Track); 253 254 TrackHeader header; 255 Media media; 256 Edit edit; 257 }; 258 259 struct MEDIA_EXPORT MovieExtendsHeader : Box { 260 DECLARE_BOX_METHODS(MovieExtendsHeader); 261 262 uint64 fragment_duration; 263 }; 264 265 struct MEDIA_EXPORT TrackExtends : Box { 266 DECLARE_BOX_METHODS(TrackExtends); 267 268 uint32 track_id; 269 uint32 default_sample_description_index; 270 uint32 default_sample_duration; 271 uint32 default_sample_size; 272 uint32 default_sample_flags; 273 }; 274 275 struct MEDIA_EXPORT MovieExtends : Box { 276 DECLARE_BOX_METHODS(MovieExtends); 277 278 MovieExtendsHeader header; 279 std::vector<TrackExtends> tracks; 280 }; 281 282 struct MEDIA_EXPORT Movie : Box { 283 DECLARE_BOX_METHODS(Movie); 284 285 bool fragmented; 286 MovieHeader header; 287 MovieExtends extends; 288 std::vector<Track> tracks; 289 std::vector<ProtectionSystemSpecificHeader> pssh; 290 }; 291 292 struct MEDIA_EXPORT TrackFragmentDecodeTime : Box { 293 DECLARE_BOX_METHODS(TrackFragmentDecodeTime); 294 295 uint64 decode_time; 296 }; 297 298 struct MEDIA_EXPORT MovieFragmentHeader : Box { 299 DECLARE_BOX_METHODS(MovieFragmentHeader); 300 301 uint32 sequence_number; 302 }; 303 304 struct MEDIA_EXPORT TrackFragmentHeader : Box { 305 DECLARE_BOX_METHODS(TrackFragmentHeader); 306 307 uint32 track_id; 308 309 uint32 sample_description_index; 310 uint32 default_sample_duration; 311 uint32 default_sample_size; 312 uint32 default_sample_flags; 313 314 // As 'flags' might be all zero, we cannot use zeroness alone to identify 315 // when default_sample_flags wasn't specified, unlike the other values. 316 bool has_default_sample_flags; 317 }; 318 319 struct MEDIA_EXPORT TrackFragmentRun : Box { 320 DECLARE_BOX_METHODS(TrackFragmentRun); 321 322 uint32 sample_count; 323 uint32 data_offset; 324 std::vector<uint32> sample_flags; 325 std::vector<uint32> sample_sizes; 326 std::vector<uint32> sample_durations; 327 std::vector<int32> sample_composition_time_offsets; 328 }; 329 330 // sample_depends_on values in ISO/IEC 14496-12 Section 8.40.2.3. 331 enum SampleDependsOn { 332 kSampleDependsOnUnknown = 0, 333 kSampleDependsOnOthers = 1, 334 kSampleDependsOnNoOther = 2, 335 kSampleDependsOnReserved = 3, 336 }; 337 338 class MEDIA_EXPORT IndependentAndDisposableSamples : public Box { 339 public: 340 DECLARE_BOX_METHODS(IndependentAndDisposableSamples); 341 342 // Returns the SampleDependsOn value for the |i|'th value 343 // in the track. If no data was parsed for the |i|'th sample, 344 // then |kSampleDependsOnUnknown| is returned. 345 SampleDependsOn sample_depends_on(size_t i) const; 346 347 private: 348 std::vector<SampleDependsOn> sample_depends_on_; 349 }; 350 351 struct MEDIA_EXPORT TrackFragment : Box { 352 DECLARE_BOX_METHODS(TrackFragment); 353 354 TrackFragmentHeader header; 355 std::vector<TrackFragmentRun> runs; 356 TrackFragmentDecodeTime decode_time; 357 SampleAuxiliaryInformationOffset auxiliary_offset; 358 SampleAuxiliaryInformationSize auxiliary_size; 359 IndependentAndDisposableSamples sdtp; 360 }; 361 362 struct MEDIA_EXPORT MovieFragment : Box { 363 DECLARE_BOX_METHODS(MovieFragment); 364 365 MovieFragmentHeader header; 366 std::vector<TrackFragment> tracks; 367 std::vector<ProtectionSystemSpecificHeader> pssh; 368 }; 369 370 #undef DECLARE_BOX 371 372 } // namespace mp4 373 } // namespace media 374 375 #endif // MEDIA_MP4_BOX_DEFINITIONS_H_ 376