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(LOGICAL_CHANNEL_H)
     19 #define LOGICAL_CHANNEL_H
     20 #include "oscl_mem.h"
     21 #include "adaptationlayer.h"
     22 #include "h324utils.h"
     23 
     24 #ifndef OSCL_MEM_MEMPOOL_H_INCLUDED
     25 #include "oscl_mem_mempool.h"
     26 #endif
     27 
     28 #ifndef PVMF_MEDIA_CLOCK_H_INCLUDED
     29 #include "pvmf_media_clock.h"
     30 #endif
     31 
     32 #ifndef OSCL_MAP_H_INCLUDED
     33 #include "oscl_map.h"
     34 #endif
     35 
     36 #ifndef PVMF_MEDIA_DATA_H_INCLUDED
     37 #include "pvmf_media_data.h"
     38 #endif
     39 
     40 #ifndef PVMF_SIMPLE_MEDIA_BUFFER_H_INCLUDED
     41 #include "pvmf_simple_media_buffer.h"
     42 #endif
     43 
     44 #ifndef PVMF_NODE_INTERFACE_H_INCLUDED
     45 #include "pvmf_node_interface.h"
     46 #endif
     47 
     48 #ifndef PVMF_PORT_BASE_IMPL_H_INCLUDED
     49 #include "pvmf_port_base_impl.h"
     50 #endif
     51 
     52 #ifndef PVMF_MEDIA_FRAG_GROUP_H_INCLUDED
     53 #include "pvmf_media_frag_group.h"
     54 #endif
     55 
     56 #ifndef PVLOGGER_H_INCLUDED
     57 #include "pvlogger.h"
     58 #endif
     59 
     60 #ifndef PVMI_CONFIG_AND_CAPABILITY_H_INCLUDED
     61 #include "pvmi_config_and_capability_utils.h"
     62 #endif
     63 
     64 #define INVALID_MUX_CODE 0xFF
     65 #define DEF_NUM_MEDIA_DATA 100
     66 #define SKEW_CHECK_INTERVAL 2000
     67 #define PARSING_JITTER_DURATION 200
     68 #define PVDEBUG_LOG_BITSTREAM_PKT(iDebug, comp, pkt) \
     69 {\
     70 uint8* ptrbuf = pkt->GetMediaPtr();\
     71 PVDEBUG_LOG_BITSTREAM(iDebug, (comp, ptrbuf, pkt->GetMediaSize()) );\
     72 pkt->ClearMediaPtr();\
     73 }
     74 
     75 class LCMediaDataEntry
     76 {
     77     public:
     78         LCMediaDataEntry() : next(NULL) {}
     79         ~LCMediaDataEntry()
     80         {
     81             mediaData.Unbind();
     82         }
     83         PVMFSharedMediaDataPtr mediaData;
     84         LCMediaDataEntry* next;
     85 };
     86 
     87 class LcnAlloc : public Oscl_DefAlloc
     88 {
     89     public:
     90         void* allocate(const uint32 size)
     91         {
     92             void* tmp = (void*)OSCL_DEFAULT_MALLOC(size);
     93             OSCL_ASSERT(tmp != 0);
     94             return tmp;
     95         }
     96         void deallocate(void* p)
     97         {
     98             OSCL_DEFAULT_FREE(p);
     99         }
    100 };
    101 
    102 class LogicalChannelObserver
    103 {
    104     public:
    105         virtual ~LogicalChannelObserver() {}
    106         virtual int32 GetTimestamp() = 0;
    107         virtual void LogicalChannelError(TPVDirection direction, TPVChannelId id, PVMFStatus error) = 0;
    108         virtual void SkewDetected(TPVChannelId lcn1, TPVChannelId lcn2, uint32 skew) = 0;
    109         virtual void ReceivedFormatSpecificInfo(TPVChannelId lcn, uint8* fsi, uint32 fsi_len) = 0;
    110 };
    111 
    112 class H223LogicalChannel : public PvmfPortBaseImpl,
    113         public PVMFPortActivityHandler,
    114         public PvmiCapabilityAndConfig,
    115         public virtual LogicalChannelInfo
    116 {
    117     public:
    118         H223LogicalChannel(TPVChannelId num,
    119                            bool segmentable,
    120                            OsclSharedPtr<AdaptationLayer>& al,
    121                            PS_DataType data_type,
    122                            LogicalChannelObserver* observer,
    123                            uint32 bitrate,
    124                            uint32 sample_interval,
    125                            uint32 num_media_data);
    126         virtual ~H223LogicalChannel();
    127 
    128         /* allocate resources in this function */
    129         virtual void Init() = 0;
    130 
    131         // LogicalChannelInfo virtuals
    132         TPVChannelId GetLogicalChannelNumber()
    133         {
    134             return lcn;
    135         }
    136 
    137         uint32 GetSduSize()
    138         {
    139             return iAl->GetSduSize();
    140         }
    141 
    142         bool IsSegmentable()
    143         {
    144             return iSegmentable;
    145         }
    146 
    147         uint32 GetBitrate()
    148         {
    149             return iBitrate;
    150         }
    151 
    152         uint32 GetSampleInterval()
    153         {
    154             return iSampleInterval;
    155         }
    156 
    157         const uint8* GetFormatSpecificInfo(uint32* format_specific_info_len);
    158         PVMFTimestamp GetLastSduTimestamp()
    159         {
    160             return iLastSduTimestamp;
    161         }
    162 
    163         PVMFFormatType GetFormatType()
    164         {
    165             PVCodecType_t codec_type = GetCodecType(iDataType);
    166             return PVCodecTypeToPVMFFormatType(codec_type);
    167         }
    168 
    169         OsclAny SetNext(H223LogicalChannel* lcn_next)
    170         {
    171             next = lcn_next;
    172         }
    173         H223LogicalChannel* GetNext()
    174         {
    175             return next;
    176         }
    177 
    178         OsclSharedPtr<AdaptationLayer>GetAl()
    179         {
    180             return iAl;
    181         }
    182 
    183         OsclAny SetSampleInterval(uint16 sample_interval)
    184         {
    185             iSampleInterval = sample_interval;
    186         }
    187 
    188         /* Flushes the pending AL SDU data */
    189         virtual OsclAny Flush() = 0;
    190 
    191         virtual OsclAny ResetStats() = 0;
    192         virtual OsclAny LogStats() = 0;
    193 
    194         // Functions to pause and resume
    195         virtual void Pause();
    196         virtual void Resume();
    197 
    198         // Set format specific information
    199         PVMFStatus SetFormatSpecificInfo(uint8* info, uint16 info_len);
    200 
    201         void SetTimestampOffset(uint32 offset)
    202         {
    203             iIncomingSkew = offset;
    204         }
    205         void SetDatapathLatency(uint32 aLatency);
    206 
    207         void SetClock(PVMFMediaClock* aClock)
    208         {
    209             iClock = aClock;
    210         }
    211 
    212         //CapabilityAndConfig virtuals
    213         OSCL_IMPORT_REF void QueryInterface(const PVUuid& aUuid, OsclAny*& aPtr);
    214 
    215         /* PVMFPortActivityHandler virtuals */
    216         void HandlePortActivity(const PVMFPortActivity &aActivity)
    217         {
    218             OSCL_UNUSED_ARG(aActivity);
    219         }
    220         PVMFStatus setConfigParametersSync(PvmiKvp* selectedKvp, PvmiCapabilityAndConfig* aConfig, PVMFFormatType lcn_format_type = PVMF_MIME_FORMAT_UNKNOWN, bool aTryTwice = false);
    221 
    222 
    223 
    224         //Set the audio/video MIO latencies for the respective channel
    225         void SetAudioLatency(int32 aAudioLatency)
    226         {
    227             iAudioLatency = aAudioLatency;
    228         }
    229         void SetVideoLatency(int32 aVideoLatency)
    230         {
    231             iVideoLatency = aVideoLatency;
    232         }
    233 
    234     protected:
    235         TPVChannelId lcn;
    236         bool iSegmentable;
    237         H223LogicalChannel* next;
    238         OsclSharedPtr<AdaptationLayer> iAl;
    239         uint32 iBitrate;
    240         uint32 iSampleInterval;
    241         LogicalChannelObserver* iObserver;
    242         uint8* iFormatSpecificInfo;
    243         uint32 iFormatSpecificInfoLen;
    244         PVLogger* iLogger;
    245         uint32 iIncomingSkew;
    246         PVMFTimestamp iLastSduTimestamp;
    247         PS_DataType iDataType;
    248         OsclMemAllocator iKvpMemAlloc;
    249         uint32 iNumMediaData;
    250         uint32 iMaxSduSize;
    251         bool iSendFormatSpecificInfo;
    252         uint32 iDatapathLatency;
    253         PVMFFormatType iMediaType;
    254         bool iPaused;
    255         PVMFMediaClock* iClock;
    256         int32 iAudioLatency;
    257         int32 iVideoLatency;
    258 
    259 };
    260 
    261 /* For outgoing A/V/C ( to be muxed) */
    262 class H223OutgoingChannel : public H223LogicalChannel
    263 {
    264     public:
    265         H223OutgoingChannel(TPVChannelId num,
    266                             bool segmentable,
    267                             OsclSharedPtr<AdaptationLayer>& al,
    268                             PS_DataType data_type,
    269                             LogicalChannelObserver* observer,
    270                             uint32 bitrate,
    271                             uint32 sample_interval,
    272                             uint32 num_media_data);
    273         ~H223OutgoingChannel();
    274 
    275         void Init();
    276 
    277         TPVDirection GetDirection()
    278         {
    279             return OUTGOING;
    280         }
    281         bool GetNextPacket(PVMFSharedMediaDataPtr& aMediaData, PVMFStatus aStatus);
    282 
    283         OsclAny ReleasePacket(PVMFSharedMediaDataPtr& aMediaData);
    284 
    285         OsclAny Flush();
    286 
    287         OsclAny ResetStats();
    288         OsclAny LogStats();
    289         OsclAny SetSkewReference(LogicalChannelInfo* reference_channel)
    290         {
    291             iSkewReferenceChannel = reference_channel;
    292         }
    293 
    294         void BufferMedia(uint16 aMs);
    295         void SetBufferSizeMs(uint32 buffer_size_ms);
    296 
    297         uint32 GetNumBytesTransferred()
    298         {
    299             return iNumBytesIn;
    300         }
    301         // Functions to pause and resume the output of data from the logical channel to the mux
    302         void Resume();
    303 
    304         OSCL_IMPORT_REF PVMFStatus Connect(PVMFPortInterface* aPort);
    305         OSCL_IMPORT_REF virtual PVMFStatus PeerConnect(PVMFPortInterface* aPort);
    306 
    307         // Implement pure virtuals from PvmiCapabilityAndConfig interface
    308         OSCL_IMPORT_REF void setObserver(PvmiConfigAndCapabilityCmdObserver* aObserver);
    309         OSCL_IMPORT_REF PVMFStatus getParametersSync(PvmiMIOSession aSession, PvmiKeyType aIdentifier,
    310                 PvmiKvp*& aParameters, int& num_parameter_elements,
    311                 PvmiCapabilityContext aContext);
    312         OSCL_IMPORT_REF PVMFStatus releaseParameters(PvmiMIOSession aSession, PvmiKvp* aParameters, int num_elements);
    313         OSCL_IMPORT_REF void createContext(PvmiMIOSession aSession, PvmiCapabilityContext& aContext);
    314         OSCL_IMPORT_REF void setContextParameters(PvmiMIOSession aSession, PvmiCapabilityContext& aContext,
    315                 PvmiKvp* aParameters, int num_parameter_elements);
    316         OSCL_IMPORT_REF void DeleteContext(PvmiMIOSession aSession, PvmiCapabilityContext& aContext);
    317         OSCL_IMPORT_REF void setParametersSync(PvmiMIOSession aSession, PvmiKvp* aParameters,
    318                                                int num_elements, PvmiKvp * & aRet_kvp);
    319         OSCL_IMPORT_REF PVMFCommandId setParametersAsync(PvmiMIOSession aSession, PvmiKvp* aParameters,
    320                 int num_elements, PvmiKvp*& aRet_kvp, OsclAny* context = NULL);
    321         OSCL_IMPORT_REF uint32 getCapabilityMetric(PvmiMIOSession aSession);
    322         OSCL_IMPORT_REF PVMFStatus verifyParametersSync(PvmiMIOSession aSession, PvmiKvp* aParameters, int num_elements);
    323         /* PVMFPortActivityHandler virtuals */
    324         void HandlePortActivity(const PVMFPortActivity &aActivity);
    325     protected:
    326         virtual PVMFStatus PutData(PVMFSharedMediaMsgPtr media_msg);
    327 
    328         bool FragmentPacket(PVMFSharedMediaDataPtr& aMediaData, PVMFSharedMediaDataPtr& newpack);
    329 
    330         OsclSharedPtr<PVMFMediaDataImpl> StartAlPdu();
    331 
    332         PVMFStatus CompletePdu();
    333 
    334         PVMFStatus AppendOutgoingPkt(OsclSharedPtr<PVMFMediaDataImpl>& pdu, PVMFTimestamp timestamp,
    335                                      OsclRefCounterMemFrag* fsi = NULL);
    336 
    337         OsclAny ResetSkewParameters();
    338 
    339 
    340         PVMFStatus VerifyAndSetParameter(PvmiKvp* aKvp, bool aSetParam);
    341 
    342         PVMFStatus NegotiateInputSettings(PvmiCapabilityAndConfig* config);
    343         PVMFStatus NegotiateFSISettings(PvmiCapabilityAndConfig* config);
    344         PVMFStatus ReceivedFSIFromPeer(PvmiKvp* kvp);
    345 
    346         OsclMemPoolFixedChunkAllocator* iMediaMsgMemoryPool;
    347         OsclMemPoolFixedChunkAllocator* iMediaDataEntryAlloc;
    348         LCMediaDataEntry* lastMediaData;
    349         PVMFMediaFragGroupCombinedAlloc<OsclMemAllocator>* iMediaFragGroupAlloc;
    350         OsclMemPoolFixedChunkAllocator* iPduPktMemPool;
    351         OsclSharedPtr<PVMFMediaDataImpl> iCurPdu;
    352 
    353         TimeValue iCreateTime;
    354         TimeValue iStartTime;
    355         uint32 iNumPacketsIn;
    356         uint32 iNumSdusIn;
    357         uint32 iNumSdusDropped;
    358         uint32 iNumBytesIn;
    359         uint32 iNumSdusOut;
    360         uint32 iNumBytesOut;
    361         uint32 iMaxPacketMuxTime;
    362         uint32 iMaxSduMuxTime;
    363         uint32 iNumFlush;
    364         uint32 iNumBytesFlushed;
    365         // skew related
    366         LogicalChannelInfo* iSkewReferenceChannel;
    367         int32 iSetBufferMediaMs;
    368         int32 iSetBufferMediaBytes;
    369         int32 iBufferMediaMs;
    370         int32 iBufferMediaBytes;
    371         bool iMuxingStarted;
    372         PVMFTimestamp iCurPduTimestamp;
    373         uint32 iNumPendingPdus;
    374         PVLogger* iOutgoingAudioLogger;
    375         PVLogger* iOutgoingVideoLogger;
    376         bool iWaitForRandomAccessPoint;
    377         uint32 iBufferSizeMs;
    378         OsclRefCounterMemFrag iFsiFrag;
    379 };
    380 
    381 class H223OutgoingControlChannel : public H223OutgoingChannel
    382 {
    383     public:
    384         H223OutgoingControlChannel(OsclSharedPtr<AdaptationLayer>& al,
    385                                    PS_DataType data_type,
    386                                    LogicalChannelObserver* observer,
    387                                    uint32 bitrate,
    388                                    uint32 sample_interval,
    389                                    uint32 num_media_data)
    390                 : H223OutgoingChannel(0, SEGMENTABLE, al, data_type, observer, bitrate, sample_interval, num_media_data)
    391         {
    392         }
    393 
    394         PVMFStatus PutData(PVMFSharedMediaMsgPtr aMsg);
    395         OSCL_IMPORT_REF PVMFStatus PeerConnect(PVMFPortInterface* aPort);
    396 
    397 };
    398 
    399 #define NUM_INCOMING_SDU_BUFFERS 8
    400 /* For incoming (from the remote terminal) A/V/C */
    401 class H223IncomingChannel : public H223LogicalChannel
    402 {
    403     public:
    404         H223IncomingChannel(TPVChannelId num,
    405                             bool segmentable,
    406                             OsclSharedPtr<AdaptationLayer>& al,
    407                             PS_DataType data_type,
    408                             LogicalChannelObserver* observer,
    409                             uint32 bitrate,
    410                             uint32 sample_interval,
    411                             uint32 num_media_data);
    412         ~H223IncomingChannel();
    413         void Init();
    414 
    415         TPVDirection GetDirection()
    416         {
    417             return INCOMING;
    418         }
    419 
    420         virtual PVMFStatus PutData(PVMFSharedMediaMsgPtr aMsg)
    421         {
    422             OSCL_UNUSED_ARG(aMsg);
    423             return PVMFErrNotSupported;
    424         }
    425 
    426         PVMFStatus GetData(PVMFSharedMediaMsgPtr aMsg)
    427         {
    428             OSCL_UNUSED_ARG(aMsg);
    429             return PVMFErrNotSupported;
    430         }
    431 
    432         /* Dispaches packets to bound PAcketInput */
    433         PVMFStatus AlPduData(uint8* buf, uint16 len);
    434 
    435         PVMFStatus AlDispatch();
    436 
    437         OsclAny ResetAlPdu();
    438         OsclAny AllocateAlPdu();
    439         OsclAny AppendAlPduFrag();
    440         uint32 CopyAlPduData(uint8* buf, uint16 len);
    441         uint32 CopyToCurrentFrag(uint8* buf, uint16 len);
    442 
    443         OsclAny Flush();
    444 
    445         OsclAny ResetStats();
    446         OsclAny LogStats();
    447 
    448         uint32 GetNumSdusIn()
    449         {
    450             return iNumSdusIn;
    451         }
    452         // overload Connect to send out format specific info if available
    453         PVMFStatus Connect(PVMFPortInterface* aPort);
    454 
    455 
    456         // Implement pure virtuals from PvmiCapabilityAndConfig interface
    457         OSCL_IMPORT_REF void setObserver(PvmiConfigAndCapabilityCmdObserver* aObserver);
    458         OSCL_IMPORT_REF PVMFStatus getParametersSync(PvmiMIOSession aSession, PvmiKeyType aIdentifier,
    459                 PvmiKvp*& aParameters, int& num_parameter_elements,
    460                 PvmiCapabilityContext aContext);
    461         OSCL_IMPORT_REF PVMFStatus releaseParameters(PvmiMIOSession aSession, PvmiKvp* aParameters, int num_elements);
    462         OSCL_IMPORT_REF void createContext(PvmiMIOSession aSession, PvmiCapabilityContext& aContext);
    463         OSCL_IMPORT_REF void setContextParameters(PvmiMIOSession aSession, PvmiCapabilityContext& aContext,
    464                 PvmiKvp* aParameters, int num_parameter_elements);
    465         OSCL_IMPORT_REF void DeleteContext(PvmiMIOSession aSession, PvmiCapabilityContext& aContext);
    466         OSCL_IMPORT_REF void setParametersSync(PvmiMIOSession aSession, PvmiKvp* aParameters,
    467                                                int num_elements, PvmiKvp * & aRet_kvp);
    468         OSCL_IMPORT_REF PVMFCommandId setParametersAsync(PvmiMIOSession aSession, PvmiKvp* aParameters,
    469                 int num_elements, PvmiKvp*& aRet_kvp, OsclAny* context = NULL);
    470         OSCL_IMPORT_REF uint32 getCapabilityMetric(PvmiMIOSession aSession);
    471         OSCL_IMPORT_REF PVMFStatus verifyParametersSync(PvmiMIOSession aSession, PvmiKvp* aParameters, int num_elements);
    472         /* PVMFPortActivityHandler virtuals */
    473         void HandlePortActivity(const PVMFPortActivity &aActivity);
    474 
    475     private:
    476         void PreAlPduData();
    477         PVMFStatus VerifyAndSetParameter(PvmiKvp* aKvp, bool aSetParam);
    478         PVMFStatus NegotiateOutputSettings(PvmiCapabilityAndConfig* config);
    479 
    480         OsclAny SendFormatSpecificInfo();
    481 
    482         PVMFStatus DispatchPendingSdus();
    483 
    484         PVMFStatus SendBeginOfStreamMediaCommand();
    485 
    486         void SetSampleTimestamps(PVMFTimestamp& aTSOffset);
    487         PVMFBufferPoolAllocator iMemFragmentAlloc;
    488         OsclMemPoolFixedChunkAllocator* iMediaMsgMemoryPool;
    489         PVMFMediaFragGroupCombinedAlloc<OsclMemAllocator>* iMediaFragGroupAlloc;
    490         OsclMemPoolFixedChunkAllocator* iPduPktMemPool;
    491 
    492         OsclMemAllocator iMemAlloc;
    493         PVMFSimpleMediaBufferCombinedAlloc iMediaDataAlloc;
    494         Oscl_Vector<PVMFSharedMediaMsgPtr, OsclMemAllocator> iPendingSdus;
    495         OsclSharedPtr<PVMFMediaDataImpl> iAlPduMediaData;
    496         uint8* iAlPduFragPos;
    497         OsclRefCounterMemFrag iAlPduFrag;
    498         uint32 iPduSize;
    499         uint32 iCurPduSize;
    500         TimeValue iCreateTime;
    501         TimeValue iStartTime;
    502         uint32 iNumPdusIn;
    503         uint32 iNumSdusIn;
    504         uint32 iNumBytesIn;
    505         uint32 iSduSizeExceededCnt;
    506         uint32 iNumCrcErrors;
    507         uint32 iNumSeqNumErrors;
    508         uint32 iNumAbort;
    509         uint32 iNumBytesFlushed;
    510         PVMFTimestamp iCurTimestamp;
    511         friend class TSC_324m;
    512         PVLogger* iIncomingAudioLogger;
    513         PVLogger* iIncomingVideoLogger;
    514         int32 iRenderingSkew;
    515 };
    516 
    517 class MuxSduData
    518 {
    519     public:
    520         MuxSduData();
    521         OsclSharedPtr<H223OutgoingChannel> lcn;
    522         PVMFSharedMediaDataPtr sdu;
    523         uint16 size;
    524         uint16 cur_frag_num;
    525         uint16 cur_pos;
    526 };
    527 typedef Oscl_Vector<MuxSduData, OsclMemAllocator> MuxSduDataList;
    528 
    529 #endif
    530 
    531