开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 多媒体编程 > 查看源码
Ap4AtomFactory.cpp
资源名称：fullMPCcode.rar　[点击查看]
上传用户：xjjlds
上传日期：2015-12-05
资源大小：22823k
文件大小：12k
源码类别：

多媒体编程

开发平台：

Visual C++

Ap4AtomFactory.cpp：源码内容
  1. /*****************************************************************
  2. |
  3. |    AP4 - Atom Factory
  4. |
  5. |    Copyright 2002 Gilles Boccon-Gibod
  6. |
  7. |
  8. |    This file is part of Bento4/AP4 (MP4 Atom Processing Library).
  9. |
  10. |    Unless you have obtained Bento4 under a difference license,
  11. |    this version of Bento4 is Bento4|GPL.
  12. |    Bento4|GPL is free software; you can redistribute it and/or modify
  13. |    it under the terms of the GNU General Public License as published by
  14. |    the Free Software Foundation; either version 2, or (at your option)
  15. |    any later version.
  16. |
  17. |    Bento4|GPL is distributed in the hope that it will be useful,
  18. |    but WITHOUT ANY WARRANTY; without even the implied warranty of
  19. |    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20. |    GNU General Public License for more details.
  21. |
  22. |    You should have received a copy of the GNU General Public License
  23. |    along with Bento4|GPL; see the file COPYING.  If not, write to the
  24. |    Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  25. |    02111-1307, USA.
  26. |
  27.  ****************************************************************/
  29. /*----------------------------------------------------------------------
  30. |       includes
  31. +---------------------------------------------------------------------*/
  32. #include "Ap4.h"
  33. #include "Ap4AtomFactory.h"
  34. #include "Ap4SampleEntry.h"
  35. #include "Ap4IsmaCryp.h"
  36. #include "Ap4UrlAtom.h"
  37. #include "Ap4MoovAtom.h"
  38. #include "Ap4MvhdAtom.h"
  39. #include "Ap4TrakAtom.h"
  40. #include "Ap4HdlrAtom.h"
  41. #include "Ap4DrefAtom.h"
  42. #include "Ap4TkhdAtom.h"
  43. #include "Ap4MdhdAtom.h"
  44. #include "Ap4StsdAtom.h"
  45. #include "Ap4StscAtom.h"
  46. #include "Ap4StcoAtom.h"
  47. #include "Ap4Co64Atom.h"
  48. #include "Ap4StszAtom.h"
  49. #include "Ap4EsdsAtom.h"
  50. #include "Ap4SttsAtom.h"
  51. #include "Ap4CttsAtom.h"
  52. #include "Ap4StssAtom.h"
  53. #include "Ap4FtypAtom.h"
  54. #include "Ap4VmhdAtom.h"
  55. #include "Ap4SmhdAtom.h"
  56. #include "Ap4NmhdAtom.h"
  57. #include "Ap4HmhdAtom.h"
  58. #include "Ap4SchmAtom.h"
  59. #include "Ap4FrmaAtom.h"
  60. #include "Ap4TimsAtom.h"
  61. #include "Ap4RtpAtom.h"
  62. #include "Ap4SdpAtom.h"
  63. #include "Ap4IkmsAtom.h"
  64. #include "Ap4IsfmAtom.h"
  65. #include "Ap4TrefTypeAtom.h"
  66. #include "Ap4AvcCAtom.h"
  67. #include "Ap4FtabAtom.h"
  68. #include "Ap4ChplAtom.h"
  69. #include "Ap4DataAtom.h"
  71. /*----------------------------------------------------------------------
  72. |       class variables
  73. +---------------------------------------------------------------------*/
  74. AP4_AtomFactory AP4_AtomFactory::DefaultFactory;
  76. /*----------------------------------------------------------------------
  77. |       AP4_AtomFactory::AddTypeHandler
  78. +---------------------------------------------------------------------*/
  79. AP4_Result
  80. AP4_AtomFactory::AddTypeHandler(TypeHandler* handler)
  81. {
  82.     return m_TypeHandlers.Add(handler);
  83. }
  85. /*----------------------------------------------------------------------
  86. |       AP4_AtomFactory::RemoveTypeHandler
  87. +---------------------------------------------------------------------*/
  88. AP4_Result
  89. AP4_AtomFactory::RemoveTypeHandler(TypeHandler* handler)
  90. {
  91.     return m_TypeHandlers.Remove(handler);
  92. }
  94. /*----------------------------------------------------------------------
  95. |       AP4_AtomFactory::CreateAtomFromStream
  96. +---------------------------------------------------------------------*/
  97. AP4_Result
  98. AP4_AtomFactory::CreateAtomFromStream(AP4_ByteStream& stream, 
  99.                                       AP4_Atom*&      atom)
  100. {
  101.     AP4_Size bytes_available = 0;
  102.     if (AP4_FAILED(stream.GetSize(bytes_available)) ||
  103.         bytes_available == 0) {
  104.         bytes_available = (AP4_Size)((unsigned long)(-1));
  105.     }
  106.     return CreateAtomFromStream(stream, bytes_available, atom);
  107. }
  109. /*----------------------------------------------------------------------
  110. |       AP4_AtomFactory::CreateAtomFromStream
  111. +---------------------------------------------------------------------*/
  112. AP4_Result
  113. AP4_AtomFactory::CreateAtomFromStream(AP4_ByteStream& stream, 
  114.                                       AP4_Size&       bytes_available,
  115.                                       AP4_Atom*&      atom)
  116. {
  117.     AP4_Result result;
  119.     // NULL by default
  120.     atom = NULL;
  122.     // check that there are enough bytes for at least a header
  123.     if (bytes_available < 8) return AP4_ERROR_EOS;
  125.     // remember current stream offset
  126.     AP4_Offset start;
  127.     stream.Tell(start);
  129.     // read atom size
  130.     AP4_UI32 size;
  131.     result = stream.ReadUI32(size);
  132.     if (AP4_FAILED(result)) {
  133.         stream.Seek(start);
  134.         return result;
  135.     }
  137.     if (size == 0) {
  138.         // atom extends to end of file
  139.         AP4_Size streamSize = 0;
  140.         stream.GetSize(streamSize);
  141.         if (streamSize >= start) {
  142.             size = streamSize - start;
  143.         }
  144.     }
  146.     // check the size (we don't handle extended size yet)
  147.     if (size != 1 && size < 8 || size > bytes_available) {
  148.         stream.Seek(start);
  149.         return AP4_ERROR_INVALID_FORMAT;
  150.     }
  152.     // read atom type
  153.     AP4_Atom::Type type;
  154.     result = stream.ReadUI32(type);
  155.     if (AP4_FAILED(result)) {
  156.         stream.Seek(start);
  157.         return result;
  158.     }
  160. if (size == 1)
  161. {
  162. AP4_UI32 size_high;
  164. result = stream.ReadUI32(size_high);
  165. if (AP4_FAILED(result) || size_high) {
  166. stream.Seek(start);
  167. return AP4_ERROR_INVALID_FORMAT;
  168. }
  170. result = stream.ReadUI32(size);
  171. if (AP4_FAILED(result)) {
  172. stream.Seek(start);
  173. return result;
  174. }
  175. }
  177.     // create the atom
  178.     switch (type) {
  179.       case AP4_ATOM_TYPE_MOOV:
  180.         atom = new AP4_MoovAtom(size, stream, *this);
  181.         break;
  183.       case AP4_ATOM_TYPE_MVHD:
  184.         atom = new AP4_MvhdAtom(size, stream);
  185.         break;
  187.       case AP4_ATOM_TYPE_TRAK:
  188.         atom = new AP4_TrakAtom(size, stream, *this);
  189.         break;
  191.       case AP4_ATOM_TYPE_HDLR:
  192.         atom = new AP4_HdlrAtom(size, stream);
  193.         break;
  195.       case AP4_ATOM_TYPE_DREF:
  196.         atom = new AP4_DrefAtom(size, stream, *this);
  197.         break;
  199.       case AP4_ATOM_TYPE_URL:
  200.         atom = new AP4_UrlAtom(size, stream);
  201.         break;
  203.       case AP4_ATOM_TYPE_TKHD:
  204.         atom = new AP4_TkhdAtom(size, stream);
  205.         break;
  207.       case AP4_ATOM_TYPE_MDHD:
  208.         atom = new AP4_MdhdAtom(size, stream);
  209.         break;
  211.       case AP4_ATOM_TYPE_STSD:
  212.         atom = new AP4_StsdAtom(size, stream, *this);
  213.         break;
  215.       case AP4_ATOM_TYPE_STSC:
  216.         atom = new AP4_StscAtom(size, stream);
  217.         break;
  219.       case AP4_ATOM_TYPE_STCO:
  220.         atom = new AP4_StcoAtom(size, stream);
  221.         break;
  223.       case AP4_ATOM_TYPE_CO64:
  224.         atom = new AP4_Co64Atom(size, stream);
  225.         break;
  227.       case AP4_ATOM_TYPE_STSZ:
  228.         atom = new AP4_StszAtom(size, stream);
  229.         break;
  231.       case AP4_ATOM_TYPE_STTS:
  232.         atom = new AP4_SttsAtom(size, stream);
  233.         break;
  235.       case AP4_ATOM_TYPE_CTTS:
  236.         atom = new AP4_CttsAtom(size, stream);
  237.         break;
  239.       case AP4_ATOM_TYPE_STSS:
  240.         atom = new AP4_StssAtom(size, stream);
  241.         break;
  243.       case AP4_ATOM_TYPE_MP4S:
  244.         atom = new AP4_Mp4sSampleEntry(size, stream, *this);
  245.         break;
  247.       case AP4_ATOM_TYPE_MP4A:
  248.         atom = new AP4_Mp4aSampleEntry(size, stream, *this);
  249.         break;
  251.       case AP4_ATOM_TYPE_MP4V:
  252.         atom = new AP4_Mp4vSampleEntry(size, stream, *this);
  253.         break;
  255.       case AP4_ATOM_TYPE_AVC1:
  256.         atom = new AP4_Avc1SampleEntry(size, stream, *this);
  257.         break;
  259.       case AP4_ATOM_TYPE_ENCA:
  260.         atom = new AP4_EncaSampleEntry(size, stream, *this);
  261.         break;
  263.       case AP4_ATOM_TYPE_ENCV:
  264.         atom = new AP4_EncvSampleEntry(size, stream, *this);
  265.         break;
  267.       case AP4_ATOM_TYPE_ESDS:
  268.         atom = new AP4_EsdsAtom(size, stream);
  269.         break;
  271.       case AP4_ATOM_TYPE_VMHD:
  272.         atom = new AP4_VmhdAtom(size, stream);
  273.         break;
  275.       case AP4_ATOM_TYPE_SMHD:
  276.         atom = new AP4_SmhdAtom(size, stream);
  277.         break;
  279.       case AP4_ATOM_TYPE_NMHD:
  280.         atom = new AP4_NmhdAtom(size, stream);
  281.         break;
  283.       case AP4_ATOM_TYPE_HMHD:
  284.         atom = new AP4_HmhdAtom(size, stream);
  285.         break;
  287.       case AP4_ATOM_TYPE_FRMA:
  288.         atom = new AP4_FrmaAtom(size, stream);
  289.         break;
  291.       case AP4_ATOM_TYPE_SCHM:
  292.           atom = new AP4_SchmAtom(size, stream);
  293.           break;
  295.       case AP4_ATOM_TYPE_FTYP:
  296.         atom = new AP4_FtypAtom(size, stream);
  297.         break;
  298.           
  299.       case AP4_ATOM_TYPE_RTP:
  300.         if (m_Context == AP4_ATOM_TYPE_HNTI) {
  301.             atom = new AP4_RtpAtom(size, stream);
  302.         } else {
  303.             atom = new AP4_RtpHintSampleEntry(size, stream, *this);
  304.         }
  305.         break;
  306.       
  307.       case AP4_ATOM_TYPE_TIMS:
  308.         atom = new AP4_TimsAtom(size, stream);
  309.         break;
  310.  
  311.       case AP4_ATOM_TYPE_SDP:
  312.         atom = new AP4_SdpAtom(size, stream);
  313.         break;
  315.       case AP4_ATOM_TYPE_IKMS:
  316.         atom = new AP4_IkmsAtom(size, stream);
  317.         break;
  319.       case AP4_ATOM_TYPE_ISFM:
  320.         atom = new AP4_IsfmAtom(size, stream);
  321.         break;
  323.       case AP4_ATOM_TYPE_HINT:
  324.         atom = new AP4_TrefTypeAtom(type, size, stream);
  325.         break;
  327.       // container atoms
  328.       case AP4_ATOM_TYPE_TREF:
  329.       case AP4_ATOM_TYPE_HNTI:
  330.       case AP4_ATOM_TYPE_STBL:
  331.       case AP4_ATOM_TYPE_MDIA:
  332.       case AP4_ATOM_TYPE_DINF:
  333.       case AP4_ATOM_TYPE_MINF:
  334.       case AP4_ATOM_TYPE_SCHI:
  335.       case AP4_ATOM_TYPE_SINF:
  336.       case AP4_ATOM_TYPE_UDTA:
  337.       case AP4_ATOM_TYPE_ILST:
  338.   case AP4_ATOM_TYPE_NAM:
  339.   case AP4_ATOM_TYPE_ART:
  340.       case AP4_ATOM_TYPE_WRT:
  341.       case AP4_ATOM_TYPE_ALB:
  342.       case AP4_ATOM_TYPE_DAY:
  343.       case AP4_ATOM_TYPE_TOO:
  344.       case AP4_ATOM_TYPE_CMT:
  345.       case AP4_ATOM_TYPE_GEN:
  346.   case AP4_ATOM_TYPE_TRKN:
  347.   case AP4_ATOM_TYPE_EDTS: {
  348.           AP4_UI32 context = m_Context;
  349.           m_Context = type; // set the context for the children
  350.           atom = new AP4_ContainerAtom(type, size, false, stream, *this);
  351.           m_Context = context; // restore the previous context
  352.           break;
  353.       }
  355.       // full container atoms
  356.       case AP4_ATOM_TYPE_META:
  357.         atom = new AP4_ContainerAtom(type, size, true, stream, *this);
  358.         break;
  360.       // other
  362.       case AP4_ATOM_TYPE_AVCC:
  363.         atom = new AP4_AvcCAtom(size, stream);
  364.         break;
  366.       case AP4_ATOM_TYPE_TEXT:
  367.         atom = new AP4_TextSampleEntry(size, stream, *this);
  368.         break;
  370.       case AP4_ATOM_TYPE_TX3G:
  371.         atom = new AP4_Tx3gSampleEntry(size, stream, *this);
  372.         break;
  374.       case AP4_ATOM_TYPE_FTAB:
  375.         atom = new AP4_FtabAtom(size, stream);
  376.         break;
  378.       case AP4_ATOM_TYPE_S263:
  379.         atom = new AP4_VisualSampleEntry(AP4_ATOM_TYPE_S263, size, stream, *this); // TODO
  380.         break;
  382.   case AP4_ATOM_TYPE_SAMR:
  383.         atom = new AP4_AudioSampleEntry(AP4_ATOM_TYPE_SAMR, size, stream, *this); // TODO
  384.         break;
  386.       case AP4_ATOM_TYPE_CHPL:
  387.         atom = new AP4_ChplAtom(size, stream);
  388.         break;
  390.   case AP4_ATOM_TYPE_DATA:
  391.         atom = new AP4_DataAtom(size, stream);
  392.         break;
  394.       default:
  395.         // try all the external type handlers
  396.         {
  397.             atom = NULL;
  398.             AP4_List<TypeHandler>::Item* handler_item = m_TypeHandlers.FirstItem();
  399.             while (handler_item) {
  400.                 TypeHandler* handler = handler_item->GetData();
  401.                 if (AP4_SUCCEEDED(handler->CreateAtom(type, size, stream, atom))) {
  402.                     break;
  403.                 }
  404.                 handler_item = handler_item->GetNext();
  405.             }
  406.             if (atom == NULL) {
  407.                 // no custom handlers, create a generic atom
  408.                 atom = new AP4_UnknownAtom(type, size, false, stream);
  409.             }
  410.             break;
  411.         }
  412.     }
  414.     // skip to the end of the atom
  415.     bytes_available -= size;
  416.     result = stream.Seek(start+size);
  417.     if (AP4_FAILED(result)) {
  418.         delete atom;
  419.         atom = NULL;
  420.     }
  422.     return result;
  423. }