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

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

多媒体编程

开发平台：

Visual C++

Ap4RtpHint.cpp：源码内容
  1. /*****************************************************************
  2. |
  3. |    AP4 - RTP Hint Objects
  4. |
  5. |    Copyright 2002-2005 Gilles Boccon-Gibod & Julien Boeuf
  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. ****************************************************************/
  28. /*----------------------------------------------------------------------
  29. |       includes
  30. +---------------------------------------------------------------------*/
  31. #include "Ap4RtpHint.h"
  32. #include "Ap4ByteStream.h"
  33. #include "Ap4Atom.h"
  35. /*----------------------------------------------------------------------
  36. |       AP4_RtpSampleData::~AP4_RtpSampleData
  37. +---------------------------------------------------------------------*/
  38. AP4_RtpSampleData::~AP4_RtpSampleData()
  39. {
  40.     AP4_List<AP4_RtpPacket>::Item* it = m_Packets.FirstItem();
  41.     while (it != NULL) {
  42.         it->GetData()->Release();
  43.         it = it->GetNext();
  44.     }
  45. }
  47. /*----------------------------------------------------------------------
  48. |       AP4_RtpSampleData::AP4_RtpSampleData
  49. +---------------------------------------------------------------------*/
  50. AP4_RtpSampleData::AP4_RtpSampleData(AP4_ByteStream& stream, AP4_Size size)
  51. {
  52.     // save the start position
  53.     AP4_Offset start, extra_data_start;
  54.     stream.Tell(start);
  56.     AP4_UI16 packet_count;
  57.     stream.ReadUI16(packet_count);
  58.     
  59.     AP4_UI16 reserved;
  60.     stream.ReadUI16(reserved); // later, check that reserved is 0
  62.     // packets
  63.     for (AP4_UI16 i=0; i<packet_count; i++) {
  64.         AP4_RtpPacket* packet = new AP4_RtpPacket(stream);
  65.         m_Packets.Add(packet);
  66.     }
  68.     // extra data
  69.     stream.Tell(extra_data_start);
  70.     AP4_Size extra_data_size = size - (extra_data_start-start);
  71.     if (extra_data_size != 0) {
  72.         m_ExtraData.SetDataSize(extra_data_size);
  73.         stream.Read(m_ExtraData.UseData(), extra_data_size);
  74.     }
  75. }
  77. /*----------------------------------------------------------------------
  78. |       AP4_RtpSampleData::GetSize
  79. +---------------------------------------------------------------------*/
  80. AP4_Size
  81. AP4_RtpSampleData::GetSize()
  82. {
  83.     // packet count and reserved
  84.     AP4_Size result = 4;
  86.     // packets
  87.     AP4_List<AP4_RtpPacket>::Item* it = m_Packets.FirstItem();
  88.     while (it != NULL) {
  89.         result = it->GetData()->GetSize();
  90.         it = it->GetNext();
  91.     }
  93.     // extra data
  94.     result += m_ExtraData.GetDataSize();
  96.     return result;
  97. }
  99. /*----------------------------------------------------------------------
  100. |       AP4_RtpSampleData::ToByteStream
  101. +---------------------------------------------------------------------*/
  102. AP4_ByteStream*
  103. AP4_RtpSampleData::ToByteStream()
  104. {
  105.     // refresh the size
  106.     AP4_Size size = GetSize();
  108.     // create a memory stream
  109.     AP4_MemoryByteStream* stream = new AP4_MemoryByteStream(size);
  111.     // write in it
  112.     AP4_Result result = stream->WriteUI16(static_cast<AP4_UI16>(m_Packets.ItemCount()));
  113.     if (AP4_FAILED(result)) goto bail;
  115.     result = stream->WriteUI16(0); // reserved
  116.     if (AP4_FAILED(result)) goto bail;
  118.     {
  119. AP4_List<AP4_RtpPacket>::Item* it = m_Packets.FirstItem();
  120. while (it != NULL) {
  121. result = it->GetData()->Write(*stream);
  122. if (AP4_FAILED(result)) goto bail;
  123. it = it->GetNext();
  124. }
  125. }
  127.     result = stream->Write(m_ExtraData.GetData(), m_ExtraData.GetDataSize());
  128.     if (AP4_FAILED(result)) goto bail;
  130.     // return
  131.     return stream;
  133. bail:
  134.     stream->Release();
  135.     return NULL;
  136. }
  139. /*----------------------------------------------------------------------
  140. |       AP4_RtpSampleData::AddPacket
  141. +---------------------------------------------------------------------*/
  142. AP4_Result
  143. AP4_RtpSampleData::AddPacket(AP4_RtpPacket* packet)
  144. {
  145.     packet->AddReference();
  146.     return m_Packets.Add(packet);
  147. }
  149. /*----------------------------------------------------------------------
  150. |       AP4_RtpPacket::AP4_RtpPacket
  151. +---------------------------------------------------------------------*/
  152. AP4_RtpPacket::AP4_RtpPacket(AP4_Integer relative_time, 
  153.                              bool p_bit, 
  154.                              bool x_bit, 
  155.                              bool m_bit, 
  156.                              AP4_UI08 payload_type, 
  157.                              AP4_UI16 sequence_seed, 
  158.                              AP4_Integer time_stamp_offset /* = 0 */,
  159.                              bool bframe_flag /* = false */, 
  160.                              bool repeat_flag /* = false */) :
  161.     m_ReferenceCount(1),
  162.     m_RelativeTime(relative_time),
  163.     m_PBit(p_bit),
  164.     m_XBit(x_bit),
  165.     m_MBit(m_bit),
  166.     m_PayloadType(payload_type),
  167.     m_SequenceSeed(sequence_seed),
  168.     m_TimeStampOffset(time_stamp_offset),
  169.     m_BFrameFlag(bframe_flag),
  170.     m_RepeatFlag(repeat_flag)
  171. {}
  173. /*----------------------------------------------------------------------
  174. |       AP4_RtpPacket::AP4_RtpPacket
  175. +---------------------------------------------------------------------*/
  176. AP4_RtpPacket::AP4_RtpPacket(AP4_ByteStream& stream) :
  177.     m_ReferenceCount(1),
  178.     m_TimeStampOffset(0)
  179. {
  180.     AP4_UI08 octet;
  182.     // relative time
  183.     AP4_UI32 relative_time;
  184.     stream.ReadUI32(relative_time);
  185.     m_RelativeTime = relative_time;
  187.     // pbit and xbit
  188.     stream.ReadUI08(octet);
  189.     m_PBit = (octet & 0x20) != 0;
  190.     m_XBit = (octet & 0x10) != 0;
  192.     // mbit and payload type
  193.     stream.ReadUI08(octet);
  194.     m_MBit = (octet & 0x80) != 0;
  195.     m_PayloadType = octet & 0x7F;
  197.     // sequence seed
  198.     stream.ReadUI16(m_SequenceSeed);
  200.     // extra, bframe and repeat flags
  201.     stream.ReadUI08(octet);
  202.     stream.ReadUI08(octet); // repeat on purpose
  203.     bool extra_flag = (octet & 0x04) != 0;
  205.     // bframe and repeat flags
  206.     m_BFrameFlag = (octet & 0x02) != 0;
  207.     m_RepeatFlag = (octet & 0x01) != 0;
  209.     // constructor count
  210.     AP4_UI16 constructor_count;
  211.     stream.ReadUI16(constructor_count);
  213.     // parse the packet extra data
  214.     if (extra_flag) {
  215.         // read the length
  216.         AP4_UI32 extra_length;
  217.         stream.ReadUI32(extra_length);
  219.         // check it 
  220.         if (extra_length < 4) 
  221.             throw AP4_Exception(AP4_ERROR_INVALID_RTP_PACKET_EXTRA_DATA);
  223.         // now read the entries
  224.         extra_length -= 4;
  225.         while (extra_length > 0) {
  226.             AP4_UI32 entry_length;
  227.             AP4_UI32 entry_tag;
  228.             stream.ReadUI32(entry_length);
  229.             stream.ReadUI32(entry_tag);
  231.             // check the entry
  232.             if (entry_length < 8) {
  233.                 throw AP4_Exception(AP4_ERROR_INVALID_RTP_PACKET_EXTRA_DATA);
  234.             }
  236.             // parse the single entry that's currently defined in the spec
  237.             if (entry_tag == AP4_ATOM_TYPE('r','t','p','o') && entry_length == 12) {
  238.                 AP4_UI32 time_stamp_offset;
  239.                 stream.ReadUI32(time_stamp_offset);
  240.                 m_TimeStampOffset = time_stamp_offset;
  241.             } else {
  242.                 // ignore it
  243.                 AP4_Offset cur_pos;
  244.                 stream.Tell(cur_pos);
  245.                 stream.Seek(cur_pos + entry_length - 8); // 8 = length + tag
  246.             }
  248.             extra_length -= entry_length;
  249.         }
  250.     }
  252.     // constructors
  253.     for (AP4_UI16 i=0; i<constructor_count; i++) {
  254.         AP4_RtpConstructor* constructor = NULL;
  255.         AP4_RtpConstructorFactory::CreateConstructorFromStream(stream, constructor);
  256.         m_Constructors.Add(constructor);
  257.     }
  258. }
  260. /*----------------------------------------------------------------------
  261. |       AP4_RtpPacket::AP4_RtpPacket
  262. +---------------------------------------------------------------------*/
  263. AP4_RtpPacket::~AP4_RtpPacket()
  264. {
  265.     AP4_List<AP4_RtpConstructor>::Item* it = m_Constructors.FirstItem();
  266.     while (it != NULL) {
  267.         it->GetData()->Release();
  268.         it = it->GetNext();
  269.     }
  270. }
  272. /*----------------------------------------------------------------------
  273. |       AP4_RtpPacket::AddReference
  274. +---------------------------------------------------------------------*/
  275. void
  276. AP4_RtpPacket::AddReference()
  277. {
  278.     m_ReferenceCount++;
  279. }
  281. /*----------------------------------------------------------------------
  282. |       AP4_RtpPacket::Release
  283. +---------------------------------------------------------------------*/
  284. void
  285. AP4_RtpPacket::Release()
  286. {
  287.     if (--m_ReferenceCount == 0) {
  288.         delete this;
  289.     }
  290. }
  292. /*----------------------------------------------------------------------
  293. |       AP4_RtpPacket::GetSize
  294. +---------------------------------------------------------------------*/
  295. AP4_Size
  296. AP4_RtpPacket::GetSize()
  297. {
  298.     AP4_Size result = 12 + (m_TimeStampOffset != 0)?16:0; 
  299.     result += m_Constructors.ItemCount() * AP4_RTP_CONSTRUCTOR_SIZE;
  300.     return result;
  301. }
  303. /*----------------------------------------------------------------------
  304. |       AP4_RtpPacket::Write
  305. +---------------------------------------------------------------------*/
  306. AP4_Result
  307. AP4_RtpPacket::Write(AP4_ByteStream& stream) 
  308. {
  309.     // check the payload type
  310.     if (m_PayloadType > 128) return AP4_FAILURE;
  312.     // now write
  313.     AP4_Result result = stream.WriteUI32(m_RelativeTime);
  314.     if (AP4_FAILED(result)) return result;
  316.     result = stream.WriteUI08(0x80 | m_PBit << 5 | m_XBit << 4);
  317.     if (AP4_FAILED(result)) return result;
  319.     result = stream.WriteUI08(m_MBit << 7 | m_PayloadType);
  320.     if (AP4_FAILED(result)) return result;
  322.     result = stream.WriteUI16(m_SequenceSeed);
  323.     if (AP4_FAILED(result)) return result;
  325.     result = stream.WriteUI08(0);
  326.     if (AP4_FAILED(result)) return result;
  328.     // deal with extra flag
  329.     bool extra_flag = m_TimeStampOffset != 0;
  330.     result = stream.WriteUI08(0x00 | extra_flag << 2 
  331.                                    | m_BFrameFlag << 1 
  332.                                    | m_RepeatFlag << 0);
  333.     if (AP4_FAILED(result)) return result;
  336.     // constructor count
  337.     result = stream.WriteUI16(static_cast<AP4_UI16>(m_Constructors.ItemCount()));
  339.     // write extra data
  340.     if (extra_flag) {
  341.         // extra_length
  342.         result = stream.WriteUI32(16); // 4 (extra_length) + 12 (rtpo atom)
  343.         if (AP4_FAILED(result)) return result;
  345.         // rtpo atom
  346.         result = stream.WriteUI32(12); // size
  347.         if (AP4_FAILED(result)) return result;
  348.         result = stream.WriteUI32(AP4_ATOM_TYPE('r','t','p','o'));
  349.         if (AP4_FAILED(result)) return result;
  350.         result = stream.WriteUI32(m_TimeStampOffset);
  351.         if (AP4_FAILED(result)) return result;
  352.     }
  354.     // constructors
  355.     AP4_List<AP4_RtpConstructor>::Item* it = m_Constructors.FirstItem();
  356.     while (it != NULL) {
  357.         result = it->GetData()->Write(stream);
  358.         if (AP4_FAILED(result)) return result;
  359.         it = it->GetNext();
  360.     }
  361.     return result;
  362. }
  364. /*----------------------------------------------------------------------
  365. |       AP4_RtpPacket::AddConstructor
  366. +---------------------------------------------------------------------*/
  367. AP4_Result
  368. AP4_RtpPacket::AddConstructor(AP4_RtpConstructor* constructor) 
  369. {
  370.     constructor->AddReference();
  371.     return m_Constructors.Add(constructor);
  372. }
  374. /*----------------------------------------------------------------------
  375. |       AP4_RtpConstructor::GetConstructedDataSize
  376. +---------------------------------------------------------------------*/
  377. AP4_Size
  378. AP4_RtpPacket::GetConstructedDataSize()
  379. {
  380.     // header + ssrc
  381.     AP4_Size size = 12;
  383.     // constructed data from constructors
  384.     AP4_List<AP4_RtpConstructor>::Item* constructors_it 
  385.         = m_Constructors.FirstItem();
  386.     while (constructors_it != NULL) {
  387.         size += constructors_it->GetData()->GetConstructedDataSize();
  388.         constructors_it = constructors_it->GetNext();
  389.     }
  391.     return size;
  392. }
  395. /*----------------------------------------------------------------------
  396. |       AP4_RtpConstructor::AddReference
  397. +---------------------------------------------------------------------*/
  398. void
  399. AP4_RtpConstructor::AddReference()
  400. {
  401.     m_ReferenceCount++;
  402. }
  404. /*----------------------------------------------------------------------
  405. |       AP4_RtpConstructor::Release
  406. +---------------------------------------------------------------------*/
  407. void
  408. AP4_RtpConstructor::Release()
  409. {
  410.     if (--m_ReferenceCount == 0) {
  411.         delete this;
  412.     }
  413. }
  414. /*----------------------------------------------------------------------
  415. |       AP4_RtpConstructor::Write
  416. +---------------------------------------------------------------------*/
  417. AP4_Result
  418. AP4_RtpConstructor::Write(AP4_ByteStream& stream)
  419. {
  420.     AP4_Result result = stream.WriteUI08(m_Type);
  421.     if (AP4_FAILED(result)) return result;
  423.     return DoWrite(stream);
  424. }
  426. /*----------------------------------------------------------------------
  427. |       AP4_NoopRtpConstructor::AP4_NoopRtpConstructor
  428. +---------------------------------------------------------------------*/
  429. AP4_NoopRtpConstructor::AP4_NoopRtpConstructor(AP4_ByteStream& stream) :
  430.     AP4_RtpConstructor(AP4_RTP_CONSTRUCTOR_TYPE_NOOP)
  431. {
  432.     AP4_Offset cur_offset;
  433.     stream.Tell(cur_offset);
  434.     stream.Seek(cur_offset+15);
  435. }
  437. /*----------------------------------------------------------------------
  438. |       AP4_NoopRtpConstructor::DoWrite
  439. +---------------------------------------------------------------------*/
  440. AP4_Result
  441. AP4_NoopRtpConstructor::DoWrite(AP4_ByteStream& stream)
  442. {
  443.     AP4_UI08 pad[15];
  445.     return stream.Write(pad, sizeof(pad));
  446. }
  448. /*----------------------------------------------------------------------
  449. |       AP4_ImmediateRtpConstructor::AP4_ImmediateRtpConstructor
  450. +---------------------------------------------------------------------*/
  451. AP4_ImmediateRtpConstructor::AP4_ImmediateRtpConstructor(const AP4_DataBuffer& data) :
  452.     AP4_RtpConstructor(AP4_RTP_CONSTRUCTOR_TYPE_IMMEDIATE),
  453.     m_Data(data)
  454. {}
  456. /*----------------------------------------------------------------------
  457. |       AP4_ImmediateRtpConstructor::AP4_ImmediateRtpConstructor
  458. +---------------------------------------------------------------------*/
  459. AP4_ImmediateRtpConstructor::AP4_ImmediateRtpConstructor(AP4_ByteStream& stream) :
  460.     AP4_RtpConstructor(AP4_RTP_CONSTRUCTOR_TYPE_IMMEDIATE)
  461. {
  462.     AP4_Offset cur_offset;
  463.     stream.Tell(cur_offset);
  465.     // data
  466.     AP4_UI08 data_size;
  467.     stream.ReadUI08(data_size);
  468.     m_Data.SetDataSize(data_size);
  469.     stream.Read(m_Data.UseData(), data_size);
  471.     // reposition the stream
  472.     stream.Seek(cur_offset+15);
  473. }
  476. /*----------------------------------------------------------------------
  477. |       AP4_ImmediateRtpConstructor::DoWrite
  478. +---------------------------------------------------------------------*/
  479. AP4_Result
  480. AP4_ImmediateRtpConstructor::DoWrite(AP4_ByteStream& stream)
  481. {
  482.     // first check that the data is not too large
  483.     if (m_Data.GetDataSize() > 14) return AP4_FAILURE;
  485.     // now write
  486.     AP4_Result result = stream.WriteUI08(static_cast<AP4_UI08>(m_Data.GetDataSize()));
  487.     if (AP4_FAILED(result)) return result;
  489.     result = stream.Write(m_Data.GetData(), m_Data.GetDataSize());
  490.     if (AP4_FAILED(result)) return result;
  492.     // pad
  493.     AP4_Byte pad[14];
  494.     return stream.Write(pad, sizeof(pad)-m_Data.GetDataSize());
  495. }
  496. /*----------------------------------------------------------------------
  497. |       AP4_SampleRtpConstructor::AP4_SampleRtpConstructor
  498. +---------------------------------------------------------------------*/
  499. AP4_SampleRtpConstructor::AP4_SampleRtpConstructor(AP4_UI08 track_ref_index, 
  500.                                                    AP4_UI16 length, 
  501.                                                    AP4_UI32 sample_num, 
  502.                                                    AP4_UI32 sample_offset) :
  503.     AP4_RtpConstructor(AP4_RTP_CONSTRUCTOR_TYPE_SAMPLE),
  504.     m_TrackRefIndex(track_ref_index),
  505.     m_Length(length),
  506.     m_SampleNum(sample_num),
  507.     m_SampleOffset(sample_offset)
  508. {}
  510. /*----------------------------------------------------------------------
  511. |       AP4_SampleRtpConstructor::AP4_SampleRtpConstructor
  512. +---------------------------------------------------------------------*/
  513. AP4_SampleRtpConstructor::AP4_SampleRtpConstructor(AP4_ByteStream& stream) :
  514.     AP4_RtpConstructor(AP4_RTP_CONSTRUCTOR_TYPE_SAMPLE)
  515. {
  516.     // offset
  517.     AP4_Offset cur_offset;
  518.     stream.Tell(cur_offset);
  520.     // data
  521.     stream.ReadUI08(m_TrackRefIndex);
  522.     stream.ReadUI16(m_Length);
  523.     stream.ReadUI32(m_SampleNum);
  524.     stream.ReadUI32(m_SampleOffset);
  526.     // reposition the stream
  527.     stream.Seek(cur_offset+15);
  528. }
  529. /*----------------------------------------------------------------------
  530. |       AP4_SampleRtpConstructor::DoWrite
  531. +---------------------------------------------------------------------*/
  532. AP4_Result
  533. AP4_SampleRtpConstructor::DoWrite(AP4_ByteStream& stream)
  534. {
  535.     AP4_Result result = stream.WriteUI08(m_TrackRefIndex);
  536.     if (AP4_FAILED(result)) return result;
  538.     result = stream.WriteUI16(m_Length);
  539.     if (AP4_FAILED(result)) return result;
  541.     result = stream.WriteUI32(m_SampleNum);
  542.     if (AP4_FAILED(result)) return result;
  544.     result = stream.WriteUI32(m_SampleOffset);
  545.     if (AP4_FAILED(result)) return result;
  547.     result = stream.WriteUI16(1); // bytes per block
  548.     if (AP4_FAILED(result)) return result;
  550.     return stream.WriteUI16(1); // samples per block
  551. }
  553. /*----------------------------------------------------------------------
  554. |       AP4_SampleDescRtpConstructor::AP4_SampleDescRtpConstructor
  555. +---------------------------------------------------------------------*/
  556. AP4_SampleDescRtpConstructor::AP4_SampleDescRtpConstructor(AP4_UI08 track_ref_index, 
  557.                                                            AP4_UI16 length, 
  558.                                                            AP4_UI32 sample_desc_index, 
  559.                                                            AP4_UI32 sample_desc_offset) :
  560.     AP4_RtpConstructor(AP4_RTP_CONSTRUCTOR_TYPE_SAMPLE_DESC),
  561.     m_TrackRefIndex(track_ref_index),
  562.     m_Length(length),
  563.     m_SampleDescIndex(sample_desc_index),
  564.     m_SampleDescOffset(sample_desc_offset)
  565. {}
  567. /*----------------------------------------------------------------------
  568. |       AP4_SampleDescRtpConstructor::AP4_SampleDescRtpConstructor
  569. +---------------------------------------------------------------------*/
  570. AP4_SampleDescRtpConstructor::AP4_SampleDescRtpConstructor(AP4_ByteStream& stream) :
  571.     AP4_RtpConstructor(AP4_RTP_CONSTRUCTOR_TYPE_SAMPLE_DESC)
  572. {
  573.     // offset
  574.     AP4_Offset cur_offset;
  575.     stream.Tell(cur_offset);
  577.     // data
  578.     stream.ReadUI08(m_TrackRefIndex);
  579.     stream.ReadUI16(m_Length);
  580.     stream.ReadUI32(m_SampleDescIndex);
  581.     stream.ReadUI32(m_SampleDescOffset);
  583.     // reposition the stream
  584.     stream.Seek(cur_offset+15);
  585. }
  587. /*----------------------------------------------------------------------
  588. |       AP4_SampleDescRtpConstructor::DoWrite
  589. +---------------------------------------------------------------------*/
  590. AP4_Result
  591. AP4_SampleDescRtpConstructor::DoWrite(AP4_ByteStream& stream)
  592. {
  593.     AP4_Result result = stream.WriteUI08(m_TrackRefIndex);
  594.     if (AP4_FAILED(result)) return result;
  596.     result = stream.WriteUI16(m_Length);
  597.     if (AP4_FAILED(result)) return result;
  599.     result = stream.WriteUI32(m_SampleDescIndex);
  600.     if (AP4_FAILED(result)) return result;
  602.     result = stream.WriteUI32(m_SampleDescOffset);
  603.     if (AP4_FAILED(result)) return result;
  605.     return stream.WriteUI32(0); // reserved
  606. }
  608. /*----------------------------------------------------------------------
  609. |       AP4_RtpConstructorFactory::CreateConstructorFromStream
  610. +---------------------------------------------------------------------*/
  611. AP4_Result
  612. AP4_RtpConstructorFactory::CreateConstructorFromStream(AP4_ByteStream& stream, 
  613.                                                        AP4_RtpConstructor*& constructor)
  614. {
  615.     // read the first byte (type)
  616.     AP4_RtpConstructor::Type type;
  617.     AP4_Result result = stream.ReadUI08(type);
  618.     if (AP4_FAILED(result)) return result;
  620.     switch(type) {
  621.         case AP4_RTP_CONSTRUCTOR_TYPE_NOOP:
  622.             constructor = new AP4_NoopRtpConstructor(stream);
  623.             break;
  624.         case AP4_RTP_CONSTRUCTOR_TYPE_IMMEDIATE:
  625.             constructor = new AP4_ImmediateRtpConstructor(stream);
  626.             break;
  627.         case AP4_RTP_CONSTRUCTOR_TYPE_SAMPLE:
  628.             constructor = new AP4_SampleRtpConstructor(stream);
  629.             break;
  630.         case AP4_RTP_CONSTRUCTOR_TYPE_SAMPLE_DESC:
  631.             constructor = new AP4_SampleDescRtpConstructor(stream);
  632.             break;
  633.         default:
  634.             return AP4_ERROR_INVALID_RTP_CONSTRUCTOR_TYPE;
  635.     }
  637.     return AP4_SUCCESS;
  638. }