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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > Symbian > 查看源码
h263pyld.cpp
资源名称：helix.src.0812.rar　[点击查看]
上传用户：zhongxx05
上传日期：2007-06-06
资源大小：33641k
文件大小：13k
源码类别：

Symbian

开发平台：

C/C++

h263pyld.cpp：源码内容
  1. /* ***** BEGIN LICENSE BLOCK *****
  2.  * Version: RCSL 1.0/RPSL 1.0
  3.  *
  4.  * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved.
  5.  *
  6.  * The contents of this file, and the files included with this file, are
  7.  * subject to the current version of the RealNetworks Public Source License
  8.  * Version 1.0 (the "RPSL") available at
  9.  * http://www.helixcommunity.org/content/rpsl unless you have licensed
  10.  * the file under the RealNetworks Community Source License Version 1.0
  11.  * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl,
  12.  * in which case the RCSL will apply. You may also obtain the license terms
  13.  * directly from RealNetworks.  You may not use this file except in
  14.  * compliance with the RPSL or, if you have a valid RCSL with RealNetworks
  15.  * applicable to this file, the RCSL.  Please see the applicable RPSL or
  16.  * RCSL for the rights, obligations and limitations governing use of the
  17.  * contents of the file.
  18.  *
  19.  * This file is part of the Helix DNA Technology. RealNetworks is the
  20.  * developer of the Original Code and owns the copyrights in the portions
  21.  * it created.
  22.  *
  23.  * This file, and the files included with this file, is distributed and made
  24.  * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  25.  * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  26.  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS
  27.  * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
  28.  *
  29.  * Technology Compatibility Kit Test Suite(s) Location:
  30.  *    http://www.helixcommunity.org/content/tck
  31.  *
  32.  * Contributor(s):
  33.  *
  34.  * ***** END LICENSE BLOCK ***** */
  36. #include "h263pyld.h"
  37. #include "debug.h"
  38. #include "ihxpckts.h"
  39. #include <string.h>
  40. #include "rfc2190hlpr.h"
  41. #include "rfc2429hlpr.h"
  42. #include "bitstream.h"
  43. #include "bitpack.h"
  45. #define D_H263 0 // D_INFO
  47. CH263PayloadFormat::CH263PayloadFormat() :
  48.     m_lRefCount(0),
  49.     m_pCCF(0),
  50.     m_state(NeedPSC),
  51.     m_ulFrameSize(0),
  52.     m_ulTimestamp(0),
  53.     m_pDepackHlpr(0)
  54. {
  55. #ifdef DEBUG
  56.     debug_level() |= D_H263;
  57. #endif /* DEBUG */
  58. }
  60. CH263PayloadFormat::~CH263PayloadFormat()
  61. {
  62.     HX_RELEASE(m_pCCF);
  64.     FlushInput();
  65.     FlushOutput();
  67.     delete m_pDepackHlpr;
  68.     m_pDepackHlpr = 0;
  69. }
  71. /*
  72.  * IUnknown methods
  73.  */
  74. STDMETHODIMP CH263PayloadFormat::QueryInterface(REFIID riid,
  75.    void** ppvObj)
  76. {
  77.     HX_RESULT res = HXR_NOINTERFACE;
  79.     *ppvObj = NULL;
  81.     if (IsEqualIID(riid, IID_IUnknown))
  82.     {
  83. AddRef();
  84. *ppvObj = this;
  85. res = HXR_OK;
  86.     }
  87.     else if (IsEqualIID(riid, IID_IHXPayloadFormatObject))
  88.     {
  89. AddRef();
  90. *ppvObj = (IHXPayloadFormatObject*)this;
  91. res = HXR_OK;
  92.     }
  94.     return res;
  95. }
  97. STDMETHODIMP_(ULONG32) CH263PayloadFormat::AddRef()
  98. {
  99.     return InterlockedIncrement(&m_lRefCount);
  100. }
  102. STDMETHODIMP_(ULONG32) CH263PayloadFormat::Release()
  103. {
  104.     if (InterlockedDecrement(&m_lRefCount) > 0)
  105.     {
  106.         return m_lRefCount;
  107.     }
  109.     delete this;
  110.     return 0;
  111. }
  113. /*
  114.  * IHXPayloadFormatObject methods
  115.  */
  116. STDMETHODIMP CH263PayloadFormat::Init(THIS_
  117.       IUnknown* pContext,
  118.       BOOL bPacketize)
  119. {
  120.     DPRINTF(D_H263, ("CH263PayloadFormat::Init(%p, %d)n",
  121.      pContext, bPacketize));
  123.     HX_RESULT res = HXR_UNEXPECTED;
  125.     if (!bPacketize)
  126.     {
  127. // Currently we only support depacketization
  128. res = pContext->QueryInterface(IID_IHXCommonClassFactory,
  129.        (void**)&m_pCCF);
  130.     }
  132.     return res;
  133. }
  135. STDMETHODIMP CH263PayloadFormat::Close()
  136. {
  137.     DPRINTF(D_H263, ("CH263PayloadFormat::Close()n"));
  139.     Flush();
  141.     return HXR_OK;
  142. }
  144. STDMETHODIMP CH263PayloadFormat::Reset()
  145. {
  146.     // Called on Seeks
  147.     DPRINTF(D_H263, ("CH263PayloadFormat::Reset()n"));
  149.     FlushInput();
  150.     FlushOutput();
  151.     m_state = NeedPSC;
  153.     return HXR_OK;
  154. }
  156. STDMETHODIMP CH263PayloadFormat::SetStreamHeader(IHXValues* pHeader)
  157. {
  158.     DPRINTF(D_H263, ("CH263PayloadFormat::SetStreamHeader()n"));
  160.     return HXR_OK;
  161. }
  163. STDMETHODIMP CH263PayloadFormat::GetStreamHeader(REF(IHXValues*) pHeader)
  164. {
  165.     DPRINTF(D_H263, ("CH263PayloadFormat::GetStreamHeader()n"));
  167.     return HXR_OK;
  168. }
  170. STDMETHODIMP CH263PayloadFormat::SetPacket(IHXPacket* pPacket)
  171. {
  172.     DPRINTF(D_H263, ("CH263PayloadFormat::SetPacket()n"));
  174.     HX_RESULT res = HXR_UNEXPECTED;
  176.     if (!pPacket->IsLost())
  177.     {
  178. IHXBuffer* pBuf = pPacket->GetBuffer();
  179. const UINT8* pData = 0;
  180. ULONG32 ulDataSize = 0;
  181. BOOL bP = FALSE;
  183. res = HXR_OK;
  185. if (!m_pDepackHlpr)
  186.     res = CreateHelper(pBuf->GetBuffer(), pBuf->GetSize());
  188. if (SUCCEEDED(res) &&
  189.     SUCCEEDED(res = m_pDepackHlpr->OnPacket(pBuf->GetBuffer(),
  190.     pBuf->GetSize())))
  191. {
  192.     BOOL bDone = FALSE;
  193.     BOOL bPacketAdded = FALSE;
  195.     /* Cache values since ProcessPacket() uses
  196.      * m_pDepackHlpr and can change it's state.
  197.      */
  198.     UINT32 ulDataSize = m_pDepackHlpr->DataSize();
  199.     BOOL bIsPictureStart = m_pDepackHlpr->IsPictureStart();
  201.     while(!bDone && SUCCEEDED(res))
  202.     {
  203. switch(m_state) {
  204. case NeedPSC:
  205.     // See if this packet has a PSC
  206.     if (bIsPictureStart)
  207.     {
  208. m_ulFrameSize = 0; // Make sure the frame size is 0
  210. // Add the packet to the input queue
  211. res = AddPacket(ulDataSize, pPacket);
  213. // Signal that we added this packet
  214. bPacketAdded = TRUE;
  216. // Cache the timestamp for this frame
  217. m_ulTimestamp = pPacket->GetTime();
  219. // Change state
  220. m_state = GotPSC;
  221.     }
  222.     else
  223.     {
  224. // Signal that we are done handling this packet
  225. bDone = TRUE;
  226.     }
  227.     break;
  228. case GotPSC:
  229.     if (pPacket->GetTime() == m_ulTimestamp)
  230.     {
  231. // See if the packet has been added yet
  232. if (!bPacketAdded)
  233. {
  234.     DPRINTF (D_H263,("Multi-packetn"));
  235.     // Add the packet to the input queue
  236.     res = AddPacket(ulDataSize, pPacket);
  238.     // Signal that we added this packet
  239.     bPacketAdded = TRUE;
  240. }
  242. // Check for the marker bit. The marker bit
  243. // is always mapped to odd ASM rule numbers
  244. if ((pPacket->GetASMRuleNumber() & 0x1) == 1)
  245.     m_state = GotFrame;
  246. else
  247.     bDone = TRUE;
  248.     }
  249.     else
  250.     {
  251. // This appears to be a different frame.
  252. // Goto the GotFrame state so that we
  253. // process the current frame
  254. m_state = GotFrame;
  255.     }
  256.     break;
  257. case GotFrame:
  258.     if (!m_inputQueue.IsEmpty())
  259.     {
  260. // Process the packets in the input queue
  261. res = ProcessPackets();
  262.     }
  264.     // Change to the NeedPSC state
  265.     m_state = NeedPSC;
  267.     if (bPacketAdded)
  268. bDone = TRUE;
  269. };
  270.     }
  271. }
  273. if (!SUCCEEDED(res))
  274. {
  275.     /* Something unexpected happened.
  276.      * Flush everything.
  277.      */
  278.     FlushInput();
  279. }
  281. HX_RELEASE(pBuf);
  282.     }
  283.     else
  284.     {
  285. FlushInput();
  286. res = HXR_OK;
  287.     }
  289.     return res;
  290. }
  292. STDMETHODIMP CH263PayloadFormat::GetPacket(REF(IHXPacket*) pPacket)
  293. {
  294.     DPRINTF(D_H263, ("CH263PayloadFormat::GetPacket()n"));
  295.     HX_RESULT res = HXR_FAILED;
  297.     if (!m_outputQueue.IsEmpty())
  298.     {
  299. pPacket = (IHXPacket*)m_outputQueue.RemoveHead();
  300. res = HXR_OK;
  301.     }
  303.     DPRINTF(D_H263, ("CH263PayloadFormat::GetPacket() : %08xn", res));
  305.     return res;
  306. }
  308. STDMETHODIMP CH263PayloadFormat::Flush()
  309. {
  310.     // Called at the end of the clip
  311.     DPRINTF(D_H263, ("CH263PayloadFormat::Flush()n"));
  313.     FlushInput();
  315.     return HXR_OK;
  316. }
  318. static HX_RESULT GetH263FrameSize(int fmt, HXxSize &FrameDim)
  319. {
  320.     HX_RESULT res = HXR_NO_DATA;
  322.     if (fmt == 1)
  323.     {
  324. FrameDim.cx = 128;
  325. FrameDim.cy = 96;
  327. res = HXR_OK;
  328.     }
  329.     else if ((fmt >= 2) && (fmt < 6))
  330.     {
  331. FrameDim.cx = 176;
  332. FrameDim.cy = 144;
  334. for(;fmt > 2; fmt--)
  335. {
  336.     FrameDim.cx <<= 1;
  337.     FrameDim.cy <<= 1;
  338. }
  340. res = HXR_OK;
  341.     }
  342.     else
  343. HX_ASSERT(FALSE);
  345.     return res;
  346. }
  348. static HX_RESULT HandleH263Plus(Bitstream& bs, HXxSize &FrameDim)
  349. {
  350.     HX_RESULT res = HXR_UNEXPECTED;
  352.     if (bs.GetBits(3) == 1) // UFEP
  353.     {
  354. int fmt = bs.GetBits(3); // OPPTYPE (bits 1-3)
  356. if (fmt != 0x6)
  357.     res = GetH263FrameSize(fmt, FrameDim);
  358. else
  359. {
  360.     // This frame has custom dimensions
  362.     bs.GetBits(11) ; // OPPTYPE (bits 4-14)
  364.     if (bs.GetBits(4) == 0x8) // OPPTYPE (bits 15-18)
  365.     {
  366. bs.GetBits(6); // MPPTYPE (bits 1-6)
  367. if (bs.GetBits(3) == 0x1) // MPPTYPE (bits 7-9)
  368. {
  369.     if (bs.GetBits(1)) // CPM
  370. bs.GetBits(2); // PSBI
  372.     bs.GetBits(4); // CPFMT (bits 1-4)
  374.     int pwi = (bs.GetBits(9) + 1) * 4;
  376.     if (bs.GetBits(1)) // CPFMT (bit 14)
  377.     {
  378. int phi = (bs.GetBits(9)) * 4;
  380. if ((phi >= 1) && (phi <= 288))
  381. {
  382.     FrameDim.cx = pwi;
  383.     FrameDim.cy = phi;
  384.     res = HXR_OK;
  385. }
  386.     }
  387. }
  388.     }
  389. }
  390.     }
  392.     return res;
  393. }
  395. HX_RESULT CH263PayloadFormat::GetFrameDimensions(IHXBuffer* pBuffer,
  396.  HXxSize &FrameDim)
  397. {
  398.     DPRINTF(D_H263, ("CH263PayloadFormat::GetFrameDimensions()n"));
  400.     HX_RESULT res = HXR_UNEXPECTED;
  401.     Bitstream bs;
  403.     if (pBuffer->GetSize() >= 5)
  404.     {
  405. bs.SetBuffer(pBuffer->GetBuffer());
  407. if (bs.GetBits(22) == 0x20) // Check PSC
  408. {
  409.     bs.GetBits(8); // Skip TR
  411.     if (bs.GetBits(2) == 0x02) // PTYPE(bits 1 & 2)
  412.     {
  413. bs.GetBits(3); // PTYPE(bits 3-5)
  415. int fmt = bs.GetBits(3); // Get Format
  417. if (fmt != 0x7)
  418. {
  419.     res = GetH263FrameSize(fmt, FrameDim);
  420. }
  421. else if (pBuffer->GetSize() >= 13)
  422. {
  423.     // This has an extended PTYPE
  424.     res = HandleH263Plus(bs, FrameDim);
  425. }
  426.     }
  427. }
  428.     }
  430.     DPRINTF(D_H263, ("CH263PayloadFormat::GetFrameDimensions() : %dn", res));
  431.     return res;
  432. }
  435. HX_RESULT CH263PayloadFormat::ProcessPackets()
  436. {
  437.     HX_RESULT res = HXR_UNEXPECTED;
  439.     if (m_pCCF)
  440.     {
  441. IHXBuffer* pBuf = 0;
  442. IHXRTPPacket* pOutRTPPkt = 0;
  443. ULONG32 ulFrameBytes = (m_ulFrameSize + 7) >> 3;
  445. if (!m_pDepackHlpr)
  446.     res = CreateHelper(pBuf->GetBuffer(), pBuf->GetSize());
  447. else
  448.     res = HXR_OK;
  450. if (SUCCEEDED(res) &&
  451.     SUCCEEDED((res = m_pCCF->CreateInstance(IID_IHXBuffer,
  452.     (void**)(&pBuf)))) &&
  453.     SUCCEEDED((res = pBuf->SetSize(ulFrameBytes))) &&
  454.     SUCCEEDED((res = m_pCCF->CreateInstance(IID_IHXRTPPacket,
  455.     (void**)(&pOutRTPPkt)))))
  456. {
  457.     BitPacker bp(pBuf->GetBuffer(), pBuf->GetSize());
  459.     LISTPOSITION pos = m_inputQueue.GetHeadPosition();
  461.     while((pos != 0) && SUCCEEDED(res))
  462.     {
  463. IHXPacket* pPacket = (IHXPacket*)m_inputQueue.GetNext(pos);
  464. IHXBuffer* pPktBuf = pPacket->GetBuffer();
  466. res = m_pDepackHlpr->OnPacket(pPktBuf->GetBuffer(),
  467.       pPktBuf->GetSize());
  468. if (SUCCEEDED(res))
  469.     res = m_pDepackHlpr->CopyPayload(bp);
  471. ULONG32 used = bp.BytesUsed();
  472. HX_ASSERT(used <= ulFrameBytes);
  474. // Release the packet buffer
  475. HX_RELEASE(pPktBuf);
  476.     }
  478.     if (SUCCEEDED(res))
  479.     {
  480. IHXPacket* pFirstPkt = (IHXPacket*)m_inputQueue.GetHead();
  481. IHXRTPPacket* pRTPPkt = 0;
  483. if (SUCCEEDED(pFirstPkt->QueryInterface(IID_IHXRTPPacket,
  484. (void**)&pRTPPkt)))
  485. {
  486.     res = pOutRTPPkt->SetRTP(pBuf,
  487.      pRTPPkt->GetTime(),
  488.      pRTPPkt->GetRTPTime(),
  489.      pRTPPkt->GetStreamNumber(),
  490.      pRTPPkt->GetASMFlags(),
  491.      pRTPPkt->GetASMRuleNumber());
  492. }
  493. else
  494. {
  495.     res = pOutRTPPkt->Set(pBuf,
  496.   pFirstPkt->GetTime(),
  497.   pFirstPkt->GetStreamNumber(),
  498.   pFirstPkt->GetASMFlags(),
  499.   pFirstPkt->GetASMRuleNumber());
  500. }
  502. IHXPacket* pOutPkt = 0;
  503. res = pOutRTPPkt->QueryInterface(IID_IHXPacket,
  504.  (void**)&pOutPkt);
  506. if (SUCCEEDED(res))
  507.     m_outputQueue.AddTail(pOutPkt);
  509. HX_RELEASE(pRTPPkt);
  510.     }
  512. }
  514. HX_RELEASE(pBuf);
  515. HX_RELEASE(pOutRTPPkt);
  516.     }
  518.     FlushInput();
  520.     return res;
  521. }
  523. HX_RESULT CH263PayloadFormat::AddPacket(ULONG32 ulDataSize, IHXPacket* pPacket)
  524. {
  525.     HX_RESULT res = HXR_OUTOFMEMORY;
  527.     if (m_inputQueue.AddTail(pPacket))
  528.     {
  529. m_ulFrameSize += ulDataSize;
  531. pPacket->AddRef();
  533. res = HXR_OK;
  534.     }
  536.     return res;
  537. }
  539. void CH263PayloadFormat::FlushInput()
  540. {
  541.     LISTPOSITION pos = m_inputQueue.GetHeadPosition();
  543.     while(pos != 0)
  544.     {
  545. IHXPacket* pPacket = (IHXPacket*)m_inputQueue.GetNext(pos);
  547. HX_RELEASE(pPacket);
  548.     }
  550.     m_inputQueue.RemoveAll();
  551.     m_ulFrameSize = 0;
  552.     m_state = NeedPSC;
  553. }
  555. void CH263PayloadFormat::FlushOutput()
  556. {
  557.     LISTPOSITION pos = m_outputQueue.GetHeadPosition();
  559.     while(pos != 0)
  560.     {
  561. IHXPacket* pPacket = (IHXPacket*)m_outputQueue.GetNext(pos);
  563. HX_RELEASE(pPacket);
  564.     }
  566.     m_outputQueue.RemoveAll();
  567. }
  569. HX_RESULT CH263PayloadFormat::CreateHelper(const UINT8* pBuf,
  570.                                            ULONG32 ulBufSize)
  571. {
  572.     HX_RESULT res = HXR_UNEXPECTED;
  574. #if defined(HELIX_FEATURE_H263_RFC2429)
  575.     // Try the RFC2429 helper first
  576.     if (FAILED(res))
  577.     {
  578.         HX_DELETE(m_pDepackHlpr);
  579.         m_pDepackHlpr = new CRFC2429Helper();
  580.         if (m_pDepackHlpr)
  581.         {
  582.             res = m_pDepackHlpr->OnPacket(pBuf, ulBufSize);
  583.         }
  584.     }
  585. #endif
  587. #if defined(HELIX_FEATURE_H263_RFC2190)
  588.     // If the RFC2429 helper didn't succeed, then
  589.     // try the RFC2190 helper next.
  590.     if (FAILED(res))
  591.     {
  592.         HX_DELETE(m_pDepackHlpr);
  593.         m_pDepackHlpr = new CRFC2190Helper();
  594.         if (m_pDepackHlpr)
  595.         {
  596.             res = m_pDepackHlpr->OnPacket(pBuf, ulBufSize);
  597.         }
  598.     }
  599. #endif
  601.     return res;
  602. }