1 /*
2  * The contents of this file are subject to the Mozilla Public
3  * License Version 1.1 (the "License"); you may not use this file
4  * except in compliance with the License. You may obtain a copy of
5  * the License at http://www.mozilla.org/MPL/
6  *
7  * Software distributed under the License is distributed on an "AS
8  * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
9  * implied. See the License for the specific language governing
10  * rights and limitations under the License.
11  *
12  * The Original Code is MPEG4IP.
13  *
14  * The Initial Developer of the Original Code is Cisco Systems Inc.
15  * Portions created by Cisco Systems Inc. are
16  * Copyright (C) Cisco Systems Inc. 2001 - 2005.  All Rights Reserved.
17  *
18  * 3GPP features implementation is based on 3GPP's TS26.234-v5.60,
19  * and was contributed by Ximpo Group Ltd.
20  *
21  * Portions created by Ximpo Group Ltd. are
22  * Copyright (C) Ximpo Group Ltd. 2003, 2004.  All Rights Reserved.
23  *
24  * Contributor(s):
25  *      Dave Mackie     dmackie@cisco.com
26  *              Ximpo Group Ltd.                mp4v2@ximpo.com
27  *              Bill May                wmay@cisco.com
28  */
29 
30 #ifndef MP4V2_IMPL_ATOMS_H
31 #define MP4V2_IMPL_ATOMS_H
32 
33 namespace mp4v2 { namespace impl {
34 
35 ///////////////////////////////////////////////////////////////////////////////
36 
37 class MP4FtypAtom;
38 class MP4FreeAtom;
39 
40 /// ISO base media full-atom.
41 class MP4FullAtom : public MP4Atom
42 {
43 public:
44     MP4FullAtom( MP4File &file, const char* type );
45 
46     MP4Integer8Property&  version;
47     MP4Integer24Property& flags;
48 private:
49     MP4FullAtom();
50     MP4FullAtom( const MP4FullAtom &src );
51     MP4FullAtom &operator= ( const MP4FullAtom &src );
52 };
53 
54 // declare all the atom subclasses
55 // i.e. spare us atom_xxxx.h for all the atoms
56 //
57 // The majority of atoms just need their own constructor declared
58 // Some atoms have a few special needs
59 // A small minority of atoms need lots of special handling
60 
61 class MP4RootAtom : public MP4Atom
62 {
63 public:
64     MP4RootAtom(MP4File &file);
65     void BeginWrite(bool use64 = false);
66     void Write();
67     void FinishWrite(bool use64 = false);
68 
69     void BeginOptimalWrite();
70     void FinishOptimalWrite();
71 
72 protected:
73     uint32_t GetLastMdatIndex();
74     void WriteAtomType(const char* type, bool onlyOne);
75 
76 private:
77     MP4RootAtom();
78     MP4RootAtom( const MP4RootAtom &src );
79     MP4RootAtom &operator= ( const MP4RootAtom &src );
80 
81     MP4FtypAtom* m_rewrite_ftyp;
82     uint64_t     m_rewrite_ftypPosition;
83     MP4FreeAtom* m_rewrite_free;
84     uint64_t     m_rewrite_freePosition;
85 };
86 
87 /***********************************************************************
88  * Common atom classes - standard for anything that just contains atoms
89  * and non-maleable properties, treftype and url
90  ***********************************************************************/
91 class MP4StandardAtom : public MP4Atom {
92 public:
93     MP4StandardAtom(MP4File &file, const char *name);
94 private:
95     MP4StandardAtom();
96     MP4StandardAtom( const MP4StandardAtom &src );
97     MP4StandardAtom &operator= ( const MP4StandardAtom &src );
98 };
99 
100 class MP4TrefTypeAtom : public MP4Atom {
101 public:
102     MP4TrefTypeAtom(MP4File &file, const char* type);
103     void Read();
104 private:
105     MP4TrefTypeAtom();
106     MP4TrefTypeAtom( const MP4TrefTypeAtom &src );
107     MP4TrefTypeAtom &operator= ( const MP4TrefTypeAtom &src );
108 };
109 
110 class MP4UrlAtom : public MP4Atom {
111 public:
112     MP4UrlAtom(MP4File &file, const char *type="url ");
113     void Read();
114     void Write();
115 private:
116     MP4UrlAtom();
117     MP4UrlAtom( const MP4UrlAtom &src );
118     MP4UrlAtom &operator= ( const MP4UrlAtom &src );
119 };
120 
121 /***********************************************************************
122  * Sound and Video atoms - use the generic atoms when possible
123  * (MP4SoundAtom and MP4VideoAtom)
124  ***********************************************************************/
125 class MP4SoundAtom : public MP4Atom {
126 public:
127     MP4SoundAtom(MP4File &file, const char *atomid);
128     void Generate();
129     void Read();
130 protected:
131     void AddProperties(uint8_t version);
132 private:
133     MP4SoundAtom();
134     MP4SoundAtom( const MP4SoundAtom &src );
135     MP4SoundAtom &operator= ( const MP4SoundAtom &src );
136 };
137 
138 class MP4VideoAtom : public MP4Atom {
139 public:
140     MP4VideoAtom(MP4File &file, const char *atomid);
141     void Generate();
142 private:
143     MP4VideoAtom();
144     MP4VideoAtom( const MP4VideoAtom &src );
145     MP4VideoAtom &operator= ( const MP4VideoAtom &src );
146 };
147 
148 class MP4AmrAtom : public MP4Atom {
149 public:
150     MP4AmrAtom(MP4File &file, const char *type);
151     void Generate();
152 private:
153     MP4AmrAtom();
154     MP4AmrAtom( const MP4AmrAtom &src );
155     MP4AmrAtom &operator= ( const MP4AmrAtom &src );
156 };
157 
158 // H.264 atoms
159 
160 class MP4Avc1Atom : public MP4Atom {
161 public:
162     MP4Avc1Atom(MP4File &file);
163     void Generate();
164 private:
165     MP4Avc1Atom();
166     MP4Avc1Atom( const MP4Avc1Atom &src );
167     MP4Avc1Atom &operator= ( const MP4Avc1Atom &src );
168 };
169 
170 class MP4AvcCAtom : public MP4Atom {
171 public:
172     MP4AvcCAtom(MP4File &file);
173     void Generate();
174     void Clone(MP4AvcCAtom *dstAtom);
175 private:
176     MP4AvcCAtom();
177     MP4AvcCAtom( const MP4AvcCAtom &src );
178     MP4AvcCAtom &operator= ( const MP4AvcCAtom &src );
179 };
180 
181 
182 class MP4D263Atom : public MP4Atom {
183 public:
184     MP4D263Atom(MP4File &file);
185     void Generate();
186     void Write();
187 private:
188     MP4D263Atom();
189     MP4D263Atom( const MP4D263Atom &src );
190     MP4D263Atom &operator= ( const MP4D263Atom &src );
191 };
192 
193 class MP4DamrAtom : public MP4Atom {
194 public:
195     MP4DamrAtom(MP4File &file);
196     void Generate();
197 private:
198     MP4DamrAtom();
199     MP4DamrAtom( const MP4DamrAtom &src );
200     MP4DamrAtom &operator= ( const MP4DamrAtom &src );
201 };
202 
203 class MP4EncaAtom : public MP4Atom {
204 public:
205     MP4EncaAtom(MP4File &file);
206     void Generate();
207 private:
208     MP4EncaAtom();
209     MP4EncaAtom( const MP4EncaAtom &src );
210     MP4EncaAtom &operator= ( const MP4EncaAtom &src );
211 };
212 
213 class MP4EncvAtom : public MP4Atom {
214 public:
215     MP4EncvAtom(MP4File &file);
216     void Generate();
217 private:
218     MP4EncvAtom();
219     MP4EncvAtom( const MP4EncvAtom &src );
220     MP4EncvAtom &operator= ( const MP4EncvAtom &src );
221 };
222 
223 class MP4Mp4aAtom : public MP4Atom {
224 public:
225     MP4Mp4aAtom(MP4File &file);
226     void Generate();
227 private:
228     MP4Mp4aAtom();
229     MP4Mp4aAtom( const MP4Mp4aAtom &src );
230     MP4Mp4aAtom &operator= ( const MP4Mp4aAtom &src );
231 };
232 
233 class MP4Ac3Atom : public MP4Atom {
234 public:
235     MP4Ac3Atom(MP4File &file);
236     void Generate();
237 private:
238     MP4Ac3Atom();
239     MP4Ac3Atom( const MP4Ac3Atom &src );
240     MP4Ac3Atom &operator= ( const MP4Ac3Atom &src );
241 };
242 
243 class MP4DAc3Atom : public MP4Atom {
244 public:
245     MP4DAc3Atom(MP4File &file);
246     void Generate();
247     void Dump(uint8_t indent, bool dumpImplicits);
248 private:
249     MP4DAc3Atom();
250     MP4DAc3Atom( const MP4DAc3Atom &src );
251     MP4DAc3Atom &operator= ( const MP4DAc3Atom &src );
252 };
253 
254 class MP4Mp4sAtom : public MP4Atom {
255 public:
256     MP4Mp4sAtom(MP4File &file);
257     void Generate();
258 private:
259     MP4Mp4sAtom();
260     MP4Mp4sAtom( const MP4Mp4sAtom &src );
261     MP4Mp4sAtom &operator= ( const MP4Mp4sAtom &src );
262 };
263 
264 class MP4Mp4vAtom : public MP4Atom {
265 public:
266     MP4Mp4vAtom(MP4File &file);
267     void Generate();
268 private:
269     MP4Mp4vAtom();
270     MP4Mp4vAtom( const MP4Mp4vAtom &src );
271     MP4Mp4vAtom &operator= ( const MP4Mp4vAtom &src );
272 };
273 
274 
275 class MP4S263Atom : public MP4Atom {
276 public:
277     MP4S263Atom(MP4File &file);
278     void Generate();
279 private:
280     MP4S263Atom();
281     MP4S263Atom( const MP4S263Atom &src );
282     MP4S263Atom &operator= ( const MP4S263Atom &src );
283 };
284 
285 
286 
287 /************************************************************************
288  * Specialized Atoms
289  ************************************************************************/
290 
291 class MP4DrefAtom : public MP4Atom {
292 public:
293     MP4DrefAtom(MP4File &file);
294     void Read();
295 private:
296     MP4DrefAtom();
297     MP4DrefAtom( const MP4DrefAtom &src );
298     MP4DrefAtom &operator= ( const MP4DrefAtom &src );
299 };
300 
301 class MP4ElstAtom : public MP4Atom {
302 public:
303     MP4ElstAtom(MP4File &file);
304     void Generate();
305     void Read();
306 protected:
307     void AddProperties(uint8_t version);
308 private:
309     MP4ElstAtom();
310     MP4ElstAtom( const MP4ElstAtom &src );
311     MP4ElstAtom &operator= ( const MP4ElstAtom &src );
312 };
313 
314 class MP4FreeAtom : public MP4Atom {
315 public:
316     MP4FreeAtom( MP4File &file, const char* = NULL );
317     void Read();
318     void Write();
319 private:
320     MP4FreeAtom();
321     MP4FreeAtom( const MP4FreeAtom &src );
322     MP4FreeAtom &operator= ( const MP4FreeAtom &src );
323 };
324 
325 class MP4FtypAtom : public MP4Atom {
326 public:
327     MP4FtypAtom(MP4File &file);
328     void Generate();
329     void Read();
330 
331     MP4StringProperty&    majorBrand;
332     MP4Integer32Property& minorVersion;
333     MP4StringProperty&    compatibleBrands;
334 private:
335     MP4FtypAtom();
336     MP4FtypAtom( const MP4FtypAtom &src );
337     MP4FtypAtom &operator= ( const MP4FtypAtom &src );
338 };
339 
340 class MP4GminAtom : public MP4Atom {
341 public:
342     MP4GminAtom(MP4File &file);
343     void Generate();
344 private:
345     MP4GminAtom();
346     MP4GminAtom( const MP4GminAtom &src );
347     MP4GminAtom &operator= ( const MP4GminAtom &src );
348 };
349 
350 class MP4HdlrAtom : public MP4Atom {
351 public:
352     MP4HdlrAtom(MP4File &file);
353     void Read();
354 private:
355     MP4HdlrAtom();
356     MP4HdlrAtom( const MP4HdlrAtom &src );
357     MP4HdlrAtom &operator= ( const MP4HdlrAtom &src );
358 };
359 
360 class MP4HinfAtom : public MP4Atom {
361 public:
362     MP4HinfAtom(MP4File &file);
363     void Generate();
364 private:
365     MP4HinfAtom();
366     MP4HinfAtom( const MP4HinfAtom &src );
367     MP4HinfAtom &operator= ( const MP4HinfAtom &src );
368 };
369 
370 class MP4HntiAtom : public MP4Atom {
371 public:
372     MP4HntiAtom(MP4File &file);
373     void Read();
374 private:
375     MP4HntiAtom();
376     MP4HntiAtom( const MP4HntiAtom &src );
377     MP4HntiAtom &operator= ( const MP4HntiAtom &src );
378 };
379 
380 
381 class MP4MdatAtom : public MP4Atom {
382 public:
383     MP4MdatAtom(MP4File &file);
384     void Read();
385     void Write();
386 private:
387     MP4MdatAtom();
388     MP4MdatAtom( const MP4MdatAtom &src );
389     MP4MdatAtom &operator= ( const MP4MdatAtom &src );
390 };
391 
392 class MP4MdhdAtom : public MP4Atom {
393 public:
394     MP4MdhdAtom(MP4File &file);
395     void Generate();
396     void Read();
397 protected:
398     void AddProperties(uint8_t version);
399 private:
400     MP4MdhdAtom();
401     MP4MdhdAtom( const MP4MdhdAtom &src );
402     MP4MdhdAtom &operator= ( const MP4MdhdAtom &src );
403 };
404 
405 class MP4MvhdAtom : public MP4Atom {
406 public:
407     MP4MvhdAtom(MP4File &file);
408     void Generate();
409     void Read();
410 protected:
411     void AddProperties(uint8_t version);
412 private:
413     MP4MvhdAtom();
414     MP4MvhdAtom( const MP4MvhdAtom &src );
415     MP4MvhdAtom &operator= ( const MP4MvhdAtom &src );
416 };
417 
418 class MP4OhdrAtom : public MP4Atom {
419 public:
420     MP4OhdrAtom(MP4File &file);
421     ~MP4OhdrAtom();
422     void Read();
423 private:
424     MP4OhdrAtom();
425     MP4OhdrAtom( const MP4OhdrAtom &src );
426     MP4OhdrAtom &operator= ( const MP4OhdrAtom &src );
427 };
428 
429 class MP4RtpAtom : public MP4Atom {
430 public:
431     MP4RtpAtom(MP4File &file);
432     void Generate();
433     void Read();
434     void Write();
435 
436 protected:
437     void AddPropertiesStsdType();
438     void AddPropertiesHntiType();
439 
440     void GenerateStsdType();
441     void GenerateHntiType();
442 
443     void ReadStsdType();
444     void ReadHntiType();
445 
446     void WriteHntiType();
447 
448 private:
449     MP4RtpAtom();
450     MP4RtpAtom( const MP4RtpAtom &src );
451     MP4RtpAtom &operator= ( const MP4RtpAtom &src );
452 };
453 
454 class MP4SdpAtom : public MP4Atom {
455 public:
456     MP4SdpAtom(MP4File &file);
457     void Read();
458     void Write();
459 private:
460     MP4SdpAtom();
461     MP4SdpAtom( const MP4SdpAtom &src );
462     MP4SdpAtom &operator= ( const MP4SdpAtom &src );
463 };
464 
465 // sdtp - Independent and Disposable Samples Atom.
466 class MP4SdtpAtom : public MP4FullAtom {
467 public:
468     MP4SdtpAtom(MP4File &file);
469     void Read();
470 
471     // raw bytes; one byte for each sample.
472     // number of bytes == stsz.sampleCount.
473     MP4BytesProperty& data;
474 private:
475     MP4SdtpAtom();
476     MP4SdtpAtom( const MP4SdtpAtom &src );
477     MP4SdtpAtom &operator= ( const MP4SdtpAtom &src );
478 };
479 
480 class MP4SmiAtom : public MP4Atom {
481 public:
482     MP4SmiAtom(MP4File &file);
483     void Read();
484 private:
485     MP4SmiAtom();
486     MP4SmiAtom( const MP4SmiAtom &src );
487     MP4SmiAtom &operator= ( const MP4SmiAtom &src );
488 };
489 
490 class MP4StblAtom : public MP4Atom {
491 public:
492     MP4StblAtom(MP4File &file);
493     void Generate();
494 private:
495     MP4StblAtom();
496     MP4StblAtom( const MP4StblAtom &src );
497     MP4StblAtom &operator= ( const MP4StblAtom &src );
498 };
499 
500 class MP4StdpAtom : public MP4Atom {
501 public:
502     MP4StdpAtom(MP4File &file);
503     void Read();
504 private:
505     MP4StdpAtom();
506     MP4StdpAtom( const MP4StdpAtom &src );
507     MP4StdpAtom &operator= ( const MP4StdpAtom &src );
508 };
509 
510 class MP4StscAtom : public MP4Atom {
511 public:
512     MP4StscAtom(MP4File &file);
513     void Read();
514 private:
515     MP4StscAtom();
516     MP4StscAtom( const MP4StscAtom &src );
517     MP4StscAtom &operator= ( const MP4StscAtom &src );
518 };
519 
520 class MP4StsdAtom : public MP4Atom {
521 public:
522     MP4StsdAtom(MP4File &file);
523     void Read();
524 private:
525     MP4StsdAtom();
526     MP4StsdAtom( const MP4StsdAtom &src );
527     MP4StsdAtom &operator= ( const MP4StsdAtom &src );
528 };
529 
530 class MP4StszAtom : public MP4Atom {
531 public:
532     MP4StszAtom(MP4File &file);
533     void Read();
534     void Write();
535 private:
536     MP4StszAtom();
537     MP4StszAtom( const MP4StszAtom &src );
538     MP4StszAtom &operator= ( const MP4StszAtom &src );
539 };
540 
541 class MP4Stz2Atom : public MP4Atom {
542 public:
543     MP4Stz2Atom(MP4File &file);
544     void Read();
545 private:
546     MP4Stz2Atom();
547     MP4Stz2Atom( const MP4Stz2Atom &src );
548     MP4Stz2Atom &operator= ( const MP4Stz2Atom &src );
549 };
550 
551 class MP4TextAtom : public MP4Atom {
552 public:
553     MP4TextAtom(MP4File &file);
554     void Generate();
555     void Read();
556 protected:
557     void AddPropertiesStsdType();
558     void AddPropertiesGmhdType();
559 
560     void GenerateStsdType();
561     void GenerateGmhdType();
562 private:
563     MP4TextAtom();
564     MP4TextAtom( const MP4TextAtom &src );
565     MP4TextAtom &operator= ( const MP4TextAtom &src );
566 };
567 
568 class MP4Tx3gAtom : public MP4Atom {
569 public:
570     MP4Tx3gAtom(MP4File &file);
571     void Generate();
572 private:
573     MP4Tx3gAtom();
574     MP4Tx3gAtom( const MP4Tx3gAtom &src );
575     MP4Tx3gAtom &operator= ( const MP4Tx3gAtom &src );
576 };
577 
578 class MP4FtabAtom : public MP4Atom {
579 public:
580     MP4FtabAtom(MP4File &file);
581 private:
582     MP4FtabAtom();
583     MP4FtabAtom( const MP4FtabAtom &src );
584     MP4FtabAtom &operator= ( const MP4FtabAtom &src );
585 };
586 
587 class MP4TfhdAtom : public MP4Atom {
588 public:
589     MP4TfhdAtom(MP4File &file);
590     void Read();
591 protected:
592     void AddProperties(uint32_t flags);
593 private:
594     MP4TfhdAtom();
595     MP4TfhdAtom( const MP4TfhdAtom &src );
596     MP4TfhdAtom &operator= ( const MP4TfhdAtom &src );
597 };
598 
599 class MP4TkhdAtom : public MP4Atom {
600 public:
601     MP4TkhdAtom(MP4File &file);
602     void Generate();
603     void Read();
604 protected:
605     void AddProperties(uint8_t version);
606 private:
607     MP4TkhdAtom();
608     MP4TkhdAtom( const MP4TkhdAtom &src );
609     MP4TkhdAtom &operator= ( const MP4TkhdAtom &src );
610 };
611 
612 class MP4TrunAtom : public MP4Atom {
613 public:
614     MP4TrunAtom(MP4File &file);
615     void Read();
616 protected:
617     void AddProperties(uint32_t flags);
618 private:
619     MP4TrunAtom();
620     MP4TrunAtom( const MP4TrunAtom &src );
621     MP4TrunAtom &operator= ( const MP4TrunAtom &src );
622 };
623 
624 class MP4UdtaAtom : public MP4Atom {
625 public:
626     MP4UdtaAtom(MP4File &file);
627     void Read();
628 private:
629     MP4UdtaAtom();
630     MP4UdtaAtom( const MP4UdtaAtom &src );
631     MP4UdtaAtom &operator= ( const MP4UdtaAtom &src );
632 };
633 
634 class MP4UrnAtom : public MP4Atom {
635 public:
636     MP4UrnAtom(MP4File &file);
637     void Read();
638 private:
639     MP4UrnAtom();
640     MP4UrnAtom( const MP4UrnAtom &src );
641     MP4UrnAtom &operator= ( const MP4UrnAtom &src );
642 };
643 
644 class MP4VmhdAtom : public MP4Atom {
645 public:
646     MP4VmhdAtom(MP4File &file);
647     void Generate();
648 private:
649     MP4VmhdAtom();
650     MP4VmhdAtom( const MP4VmhdAtom &src );
651     MP4VmhdAtom &operator= ( const MP4VmhdAtom &src );
652 };
653 
654 class MP4HrefAtom : public MP4Atom {
655 public:
656     MP4HrefAtom(MP4File &file);
657     void Generate(void);
658 private:
659     MP4HrefAtom();
660     MP4HrefAtom( const MP4HrefAtom &src );
661     MP4HrefAtom &operator= ( const MP4HrefAtom &src );
662 };
663 
664 class MP4PaspAtom : public MP4Atom {
665 public:
666     MP4PaspAtom(MP4File &file);
667     void Generate();
668 private:
669     MP4PaspAtom();
670     MP4PaspAtom( const MP4PaspAtom &src );
671     MP4PaspAtom &operator= ( const MP4PaspAtom &src );
672 };
673 
674 class MP4ColrAtom : public MP4Atom {
675 public:
676     MP4ColrAtom(MP4File &file);
677     void Generate();
678 private:
679     MP4ColrAtom();
680     MP4ColrAtom( const MP4ColrAtom &src );
681     MP4ColrAtom &operator= ( const MP4ColrAtom &src );
682 };
683 
684 class IPodUUIDAtom : public MP4Atom {
685 public:
686     IPodUUIDAtom(MP4File &file);
687 private:
688     IPodUUIDAtom();
689     IPodUUIDAtom( const IPodUUIDAtom &src );
690     IPodUUIDAtom &operator= ( const IPodUUIDAtom &src );
691 };
692 
693 class MP4NmhdAtom : public MP4Atom {
694 public:
695     MP4NmhdAtom(MP4File &file);
696 private:
697     MP4NmhdAtom();
698     MP4NmhdAtom( const MP4NmhdAtom &src );
699     MP4NmhdAtom &operator= ( const MP4NmhdAtom &src );
700 };
701 
702 /*! Nero Chapter List.
703  * This atom defines the structure of a Nero chapter list.
704  * Although it is not completely clear if this structure is
705  * correct it is complete enough to successfully read and write
706  * the chapter list so that even Nero's software accepts it.
707  *
708  * The assumed format is as follows:
709  * - MP4Integer8Property("version")
710  * - MP4Integer24Property("flags")
711  * - MP4BytesProperty("reserved", 1)
712  * - MP4Integer32Property("chaptercount")\n
713  * - MP4TableProperty("chapters", "ref to chaptercount");
714  *     - MP4Integer64Property("starttime")\n
715  *       The start time of the chapter expressed in 100 nanosecond units
716  *     - MP4StringProperty("title", true)\n
717  *       The title of the chapter encoded in UTF-8
718  *
719  * The chapter title only accepts strings of 255 bytes so if a string
720  * only contains simple (two-byte) UTF-8 chars the maximum length is
721  * 127 chars.
722  */
723 class MP4ChplAtom : public MP4Atom {
724 public:
725     MP4ChplAtom(MP4File &file);
726     void Generate();
727 private:
728     MP4ChplAtom();
729     MP4ChplAtom( const MP4ChplAtom &src );
730     MP4ChplAtom &operator= ( const MP4ChplAtom &src );
731 };
732 
733 ///////////////////////////////////////////////////////////////////////////////
734 
735 /// iTMF hdlr-atom.
736 class MP4ItmfHdlrAtom : public MP4FullAtom
737 {
738 public:
739     MP4ItmfHdlrAtom(MP4File &file);
740     void Read();
741 
742     MP4Integer32Property& reserved1;
743     MP4BytesProperty&     handlerType;
744     MP4BytesProperty&     reserved2;
745     MP4BytesProperty&     name;
746 private:
747     MP4ItmfHdlrAtom();
748     MP4ItmfHdlrAtom( const MP4ItmfHdlrAtom &src );
749     MP4ItmfHdlrAtom &operator= ( const MP4ItmfHdlrAtom &src );
750 };
751 
752 /// iTMF item-atom.
753 class MP4ItemAtom : public MP4Atom
754 {
755 public:
756     MP4ItemAtom( MP4File &file, const char* type );
757 private:
758     MP4ItemAtom();
759     MP4ItemAtom( const MP4ItemAtom &src );
760     MP4ItemAtom &operator= ( const MP4ItemAtom &src );
761 };
762 
763 /// iTMF meaning-atom.
764 class MP4MeanAtom : public MP4FullAtom
765 {
766 public:
767     MP4MeanAtom(MP4File &file);
768     void Read();
769 
770     MP4BytesProperty& value;
771 private:
772     MP4MeanAtom();
773     MP4MeanAtom( const MP4MeanAtom &src );
774     MP4MeanAtom &operator= ( const MP4MeanAtom &src );
775 };
776 
777 /// iTMF name-atom.
778 class MP4NameAtom : public MP4FullAtom
779 {
780 public:
781     MP4NameAtom(MP4File &file);
782     void Read();
783 
784     MP4BytesProperty& value;
785 private:
786     MP4NameAtom();
787     MP4NameAtom( const MP4NameAtom &src );
788     MP4NameAtom &operator= ( const MP4NameAtom &src );
789 };
790 
791 /// iTMF data-atom.
792 class MP4DataAtom : public MP4Atom
793 {
794 public:
795     MP4DataAtom(MP4File &file);
796     void Read();
797 
798     MP4Integer16Property& typeReserved;
799     MP4Integer8Property&  typeSetIdentifier;
800     MP4BasicTypeProperty& typeCode;
801     MP4Integer32Property& locale;
802     MP4BytesProperty&     metadata;
803 private:
804     MP4DataAtom();
805     MP4DataAtom( const MP4DataAtom &src );
806     MP4DataAtom &operator= ( const MP4DataAtom &src );
807 };
808 
809 ///////////////////////////////////////////////////////////////////////////////
810 
811 /// QTFF udta data element-atom.
812 class MP4UdtaElementAtom : public MP4Atom
813 {
814 public:
815     MP4UdtaElementAtom( MP4File &file, const char* type );
816     void Read();
817 
818     MP4BytesProperty& value;
819 private:
820     MP4UdtaElementAtom();
821     MP4UdtaElementAtom( const MP4UdtaElementAtom &src );
822     MP4UdtaElementAtom &operator= ( const MP4UdtaElementAtom &src );
823 };
824 
825 ///////////////////////////////////////////////////////////////////////////////
826 
827 }} // namespace mp4v2::impl
828 
829 #endif // MP4V2_IMPL_ATOMS_H
830