Home | History | Annotate | Download | only in include 
      1 /* ------------------------------------------------------------------
      2  * Copyright (C) 1998-2009 PacketVideo
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
     13  * express or implied.
     14  * See the License for the specific language governing permissions
     15  * and limitations under the License.
     16  * -------------------------------------------------------------------
     17  */
     18 #if !defined(PDU_PARCOM_H)
     19 #define PDU_PARCOM_H
     20 #include "oscl_base.h"
     21 #include "oscl_mem.h"
     22 #include "media_fragment.h"
     23 #include "media_packet.h"
     24 #include "golay.h"
     25 #include "oscl_time.h"
     26 #include "oscl_rand.h"
     27 #include "h324utils.h"
     28 #include "h223types.h"
     29 
     30 #ifndef PVMF_MEDIA_FRAG_GROUP_H_INCLUDED
     31 #include "pvmf_media_frag_group.h"
     32 #endif
     33 
     34 #ifndef PVMF_POOL_BUFFER_ALLOCATOR_H_INCLUDED
     35 #include "pvmf_pool_buffer_allocator.h"
     36 #endif
     37 
     38 #ifndef PVLOGGER_H_INCLUDED
     39 #include "pvlogger.h"
     40 #endif
     41 
     42 typedef enum
     43 {
     44     EHeaderErr = 0,
     45     ESizeErr
     46 } EMuxPduError;
     47 
     48 class H223PduParcomObserver
     49 {
     50     public:
     51         virtual ~H223PduParcomObserver() {}
     52         virtual uint32 MuxPduIndicate(uint8* pPdu, uint32 pduSz, int32 fClosing, int32 muxCode) = 0;
     53         virtual void MuxPduErrIndicate(EMuxPduError err) = 0;
     54         virtual void MuxSetupComplete(PVMFStatus status, TPVH223Level level) = 0;
     55 };
     56 
     57 class H223PduParcom
     58 {
     59     public:
     60         virtual ~H223PduParcom() {}
     61 
     62         /**
     63          * Returns the level associated with this parcom.
     64          **/
     65         virtual TPVH223Level GetLevel() = 0;
     66 
     67         /**
     68          * Constructs the parcom based on max_outstanding_pdus.
     69          **/
     70         virtual void Construct(uint16 max_outstanding_pdus) = 0;
     71         /**
     72          * Sets the base parcom observer.
     73          **/
     74         virtual void SetObserver(H223PduParcomObserver* observer) = 0;
     75         /**
     76          * Copies one stuffing sequence into the provided buffer.
     77          * @param buf The buffer to be used.
     78          * @param buf_size The maximum size of the buffer.
     79          * @param mux_code The multiplex code to be used in the stuffing header (may not apply for some parcoms)
     80          * @return The number of bytes copied.
     81          **/
     82         virtual uint32 GetStuffing(uint8* buf, uint32 buf_size, uint8 mux_code = 0) = 0;
     83 
     84         /**
     85          * @return The size of the header field.
     86          **/
     87         virtual uint32 GetHeaderSz() = 0;
     88 
     89         /**
     90          * Returns the stuffing size.
     91          * @return The size of the stuffing sequence.
     92          **/
     93         virtual uint32 GetStuffingSz() = 0;
     94 
     95         /**
     96          * Parses the bitstream and returns pdus using the MuxPduIndicate observer callback.
     97          * @param buf The buffer to be used.
     98          * @param buf_size The maximum size of the buffer.
     99          * @param mux_code The multiplex code to be used in the stuffing header (may not apply for some parcoms)
    100          * @return The number of bytes copied.
    101          **/
    102         virtual uint32 Parse(uint8* buffer, uint32 buffer_size) = 0;
    103 
    104         /**
    105          * Returns a header fragment.
    106          * @param frag The buffer to be used.
    107          * @param buf_size The maximum size of the buffer.
    108          * @param mux_code The multiplex code to be used in the stuffing header (may not apply for some parcoms)
    109          * @return The number of bytes copied.
    110          **/
    111         virtual void GetHdrFragment(OsclRefCounterMemFrag& frag) = 0;
    112 
    113         /**
    114          * Completes a pdu (sets the header and trailer info if any).
    115          * @param pdu The pdu to be completed.
    116          * @param mux_code The multiplex code for this pdu.
    117          * @param packet_marker The packet marker field.
    118          * @return The return status.
    119          **/
    120         virtual PVMFStatus CompletePdu(OsclSharedPtr<PVMFMediaDataImpl>& pdu, int8 mux_code, uint8 packet_marker) = 0;
    121 
    122         virtual void ResetStats() = 0;
    123         virtual void LogStats(TPVDirection dir) = 0;
    124 };
    125 
    126 typedef OsclSharedPtr<H223PduParcom> H223PduParcomSharedPtr;
    127 
    128 /** Base implementation with some common features to Level0,1,2. **/
    129 class H223PduParcomBase : public H223PduParcom
    130 {
    131     public:
    132         H223PduParcomBase():
    133                 iObserver(NULL),
    134                 iLogger(NULL),
    135                 iPduEndPos(NULL)
    136         {
    137             iPduPos = iPdu;
    138             iPduEndPos = &iPdu[H223_MAX_DEMUX_PDU_SIZE-1];
    139         }
    140 
    141         void SetObserver(H223PduParcomObserver* observer)
    142         {
    143             iObserver = observer;
    144         }
    145 
    146         void ResetStats();
    147         void LogStats(TPVDirection dir);
    148     protected:
    149         H223PduParcomObserver* iObserver;
    150         PVLogger* iLogger;
    151 
    152         uint8 iPdu[H223_MAX_DEMUX_PDU_SIZE];
    153         uint8* iPduPos;
    154         uint8* iPduEndPos;
    155 
    156         // Outgoing
    157         uint32 iNumFlagsTx;
    158         uint32 iNumStuffingTx;
    159         uint32 iNumPdusTx;
    160 
    161         // Incoming
    162         uint32 iNumFlagsRx;
    163         uint32 iNumStuffingRx;
    164         uint32 iNumPdusRx;
    165         uint32 iNumPmRx;
    166 
    167         uint32 iNumFlagErrorsRx;
    168         uint32 iCumFlagErrorsRx;
    169         uint32 iNumSyncLossRx;
    170         uint32 iNumBytesLossRx;
    171         uint32 iNumPduHdrErrorRx;
    172         uint32 iCumPduHdrErrorRx;
    173 };
    174 
    175 class PduParcomRefCounter: public OsclRefCounter
    176 {
    177     public:
    178         PduParcomRefCounter(H223PduParcom* p): ptr(p), refcnt(1) {}
    179 
    180         void addRef()
    181         {
    182             ++refcnt;
    183         }
    184 
    185         void removeRef()
    186         {
    187             --refcnt;
    188             if (refcnt == 0)
    189             {
    190                 if (ptr)
    191                 {
    192                     delete ptr;
    193                 }
    194                 delete this;
    195             }
    196         }
    197 
    198         uint32 getCount()
    199         {
    200             return refcnt;
    201         }
    202     private:
    203         H223PduParcom* ptr;
    204         uint32 refcnt;
    205 };
    206 
    207 #endif
    208