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