mpeg_tsdemux.cpp

这是DVD中伺服部分的核心代码

    {
        if( configInfo->tConfigInfo.tOutputPin[i].wPID == configInfo->wPID )
        {
            if ( configInfo->tConfigInfo.tOutputPin[i].pDestStream != NULL )
            {
                configInfo->wPIDIndex = i;
                return TRUE;
            }
        }
    }

    return FALSE;
#endif

} /* end MPEG2TS_IsBeingWatched() */

/************************************************************************/
/************************************************************************/
/**                                                                    **/
/************************************************************************/
/************************************************************************/
BOOLEAN MPEG2TS_IsPATPMT( TSDEMUXINFO *configInfo )
{
    return FALSE;
} /* end MPEG2TS_IsPATPMT() */ 

/************************************************************************/
/************************************************************************/
/**                                                                    **/
/************************************************************************/
/************************************************************************/
void MPEG2TS_Process_PATPMT( TSDEMUXINFO *configInfo )
{
    return;
} /* end MPEG2TS_Process_PATPMT() */

/************************************************************************/
/************************************************************************/
/**                                                                    **/
/**             procedure MPEG2_GetValidPacket()                       **/
/**                                                                    **/
/** PURPOSE: To get a payload buffer from the input stream.            **/
/**                                                                    **/
/************************************************************************/
/************************************************************************/
BOOLEAN MPEG2_GetValidPacket( TSDEMUXINFO *configInfo, ULONG ulLine )
{
    BOOLEAN           fRet = MPEGTS_FAILURE;
    DEMUXIOSTREAM     *pInputPin  = NULL;
    DEMUXINPUTMESSAGE *pInMessage = NULL;

    pInputPin = configInfo->tConfigInfo.tInputPin;

    if( pInputPin != NULL )
    {
        /* Get a new message with more data */
        pInMessage = (DEMUXINPUTMESSAGE *)pInputPin->Read( OS_WAIT_FOREVER );
        if( pInMessage != NULL )
        {
            configInfo->messInput   = (DEMUXINPUTMESSAGE *)pInMessage;
            configInfo->pbInputData = (BYTE *)KSEG0( (configInfo->messInput->payload->get_rd_ptr()) );
            configInfo->ulInputSize = configInfo->messInput->payload->get_size();
            fRet = MPEGTS_SUCCESS;
        }
    }

    return( fRet );

} /* end MPEG2_GetValidPacket() */

/************************************************************************/
/************************************************************************/
/**                                                                    **/
/**              procedure MPEG2TS_ProcessPID()                        **/
/**                                                                    **/
/************************************************************************/
/************************************************************************/
void MPEG2TS_ProcessPID( TSDEMUXINFO *configInfo )
{
    PMPG_TRANSPORT_HDR pThdr;
    MPG_PES_HDR        mpgPes;
    BYTE *pTransportBuffer = configInfo->pbData;
    BYTE *pPayload;
    BYTE *pTempPayload;

    pThdr = (PMPG_TRANSPORT_HDR)( pTransportBuffer );
    pPayload = MpgGetPayload( pTransportBuffer );

    configInfo->fPayloadUnitStart = FALSE;
    if( pThdr->wPayloadUnitStartIndicator )
    {
        configInfo->fPayloadUnitStart = TRUE;
        if ( MpgIsPes( MpgShowStart((PVOID)pPayload) ) )
        {
            pTempPayload = (PBYTE) MpgReadPESHdr( &mpgPes, (PVOID) pPayload );
#ifdef PES_PRINT
            DbgPrint(( "PES %08x %04x %01x %01x %01x %01x %02x %02x %02x\n", mpgPes.dwStartCode, mpgPes.wLength, 
                mpgPes.bOriginalOrCopy, mpgPes.bMarkerBit, mpgPes.bPESExtensionFlag, mpgPes.bPTSDTSFlags, 
                mpgPes.bPES_header_data_length, pTempPayload - pTransportBuffer, sizeof (mpgPes) ));
#endif
            
            configInfo->fPtsExisted = FALSE;
            if( mpgPes.bPTSDTSFlags & MPG_PES_PTS_FLAG )
            {
                configInfo->fPtsExisted = TRUE;
                configInfo->ulPTS       = MpgGetPESPTS32( pPayload );
//                DbgPrint( ( "PTS = %08x\n", configInfo->ulPTS ));
            }

            configInfo->fDtsExisted = FALSE;
            if( mpgPes.bPTSDTSFlags & MPG_PES_DTS_FLAG )
            {
                configInfo->fDtsExisted = TRUE;
                configInfo->ulDTS = MpgGetPESDTS32 ( pPayload );
//                DbgPrint(( "DTS %8d ", configInfo->ulDTS ));
            }
            pPayload = pTempPayload;

#ifdef PES_PRINT
            DbgPrint(( "PAYLOAD %02x %02x %02x %02x %02x %02x %02x %02x\n", *((BYTE *)pPayload+0), 
                *((BYTE *)pPayload+1), *((BYTE *)pPayload+2), *((BYTE *)pPayload+3), *((BYTE *)pPayload+4), 
                *((BYTE *)pPayload+5), *((BYTE *)pPayload+6), *((BYTE *)pPayload+7)  ));
#endif
        }
    }

    configInfo->pbPayload     = pPayload;
    configInfo->wPID          = pThdr->wPID;
    configInfo->ulPayloadSize = MPG_TRANSPORT_SIZE - (pPayload - pTransportBuffer);

} /* end MPEG2TS_ProcessPID() */

/************************************************************************/
/************************************************************************/
/**                                                                    **/
/************************************************************************/
/************************************************************************/
ULONG MPEG2TS_GetSync(TSDEMUXINFO *configInfo)
{
    PBYTE   pbData = configInfo->pbInputData; //(PBYTE) configInfo->messInput->payload->get_rd_ptr();
    ULONG   ulSize = configInfo->ulInputSize; //configInfo->messInput->payload->get_size();
    ULONG   ulOffset;
    ULONG   ulRemaining;
    BOOLEAN fSyncFound;

    DbgPrint(( "MPEG2TS_GetSync: 0x%08x 0x%08x\n", (int)pbData, (int)ulSize ));

    fSyncFound = FALSE;
    for( ulOffset = 0; ulOffset < ulSize; ulOffset++ )
    {
        if( pbData[ulOffset] == 0x47 )
        {
            ulRemaining = ulSize - ulOffset;

            if ( ulRemaining < MPG_TRANSPORT_SIZE )
            {
                DbgPrint(("MPEG2TS_GetSync: OUT OF DATA %d\n", (int)ulRemaining));
                break;
            }
            else if( ulRemaining < ((ULONG)(MPG_TRANSPORT_SIZE*2)) )
            {
                if( pbData[ulOffset+MPG_TRANSPORT_SIZE] == 0x47 )
                {
                    fSyncFound = TRUE;
                    break;
                }
            }
            else
            {
                if( (pbData[ulOffset+MPG_TRANSPORT_SIZE]   == 0x47) &&
                    (pbData[ulOffset+MPG_TRANSPORT_SIZE*2] == 0x47) )
                {
                    fSyncFound = TRUE;
                    break;
                }
            }
        }
    }

    if( fSyncFound == TRUE )
    {
//    configInfo->messInput->payload->set_rd_ptr( pbData + ulOffset );
        configInfo->pbInputData += ulOffset;
        configInfo->ulInputSize -= ulOffset;
        if( pbData[ulOffset] == 0x47 )
        {
            DbgPrint(("MPEG2TS_GetSync: 0x%08x\n", (int)(pbData + ulOffset ) ));
            return NO_SYNC; //FULL_PID;
        }
        else
        {
            DbgPrint(( "GetSync: NO_SYNC\n" ));
            return NO_SYNC;
        }
    }
    else
    {
        DbgPrint(( "MPEG2TS_GetSync: Sync not found\n" ));
        configInfo->pbInputData += ulOffset;
        configInfo->ulInputSize -= ulOffset;
//    configInfo->messInput->payload->set_rd_ptr( pbData + ulSize );
        return NO_SYNC;
    }

} /* end MPEG2TS_GetSync() */

/************************************************************************/  
/************************************************************************/  
/**                                                                    **/
/**              procedure MPEG2TS_CheckForData()                      **/
/**                                                                    **/
/** PURPOSE: To make sure there is a full packet to process.           **/
/**                                                                    **/
/************************************************************************/  
/************************************************************************/  
ULONG MPEG2TS_CheckForData( TSDEMUXINFO *configInfo )
{
#if 1
    ULONG ulPartialSize;
    ULONG ulRet = TS_DEMUX_EXIT;

    // Check for a Valid Packet 
    if( configInfo->ulInputSize == 0 )
    {
        //Release the current payload
        delete (DEMUXPAYLOAD *)configInfo->messInput->payload;
        configInfo->messInput->payload = NULL;
        configInfo->tConfigInfo.tInputPin->ReleaseMsg(configInfo->messInput);
        configInfo->messInput = NULL;

        //Get a new payload
        MPEG2_GetValidPacket( configInfo, __LINE__ );
    }

    // Is there enuff data 
    if ( configInfo->ulInputSize > MPG_TRANSPORT_SIZE )
    {
        configInfo->pbData        = configInfo->pbInputData;
        configInfo->ulPartialSize = MPG_TRANSPORT_SIZE;
        ulRet = FULL_PID;
    }
    else
    {
        // No
        ulPartialSize      = configInfo->ulInputSize;
        configInfo->pbData = (BYTE *)&(configInfo->bPartialPacket[0]);

        // Assemble dummy packet
        memcpy ( &configInfo->pbData[0], configInfo->pbInputData, ulPartialSize );

        //Release the current payload
        delete (DEMUXPAYLOAD *)configInfo->messInput->payload;
        configInfo->messInput->payload = NULL;
        configInfo->tConfigInfo.tInputPin->ReleaseMsg(configInfo->messInput);
        configInfo->messInput = NULL;

        // Check for a Valid Packet
        MPEG2_GetValidPacket ( configInfo, __LINE__ );

        configInfo->ulPartialSize = MPG_TRANSPORT_SIZE - ulPartialSize;

        memcpy( &configInfo->pbData[ulPartialSize], configInfo->pbInputData, configInfo->ulPartialSize );
        
        ulRet = FULL_PID;
    }

    //Make sure that the transport packet starts with a 0x47
    if( *configInfo->pbData != 0x47 )
    {
        DbgPrint(( "MPEG2TS_CheckForData: LOST SYNC %d\n", configInfo->ulPartialSize ));
        ulRet = NO_SYNC;
    }

    return( ulRet );

#else
    ULONG ulPartialSize;
    ULONG ulRet = TS_DEMUX_EXIT;

    // Check for a Valid Packet 
    if ( configInfo->messInput->payload->get_size() == 0 )
    {
        //Release the current payload
        delete (DEMUXPAYLOAD *)configInfo->messInput->payload;
        configInfo->messInput->payload = NULL;
        configInfo->tConfigInfo.tInputPin->ReleaseMsg(configInfo->messInput);