• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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_
438