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