mpeg_tsdemux.cpp

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

        configInfo->messInput = NULL;

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

    // Is there enuff data 
    if ( configInfo->messInput->payload->get_size() > MPG_TRANSPORT_SIZE )
    {
        // Yes Return FULL PACKET
        // Set data pointer to Address
        //DbgPrint(( "FULL PACKET %08x @ OFFSET %08x\n",  configInfo->messInput->payload, configInfo->messInput->payload->get_rd_ptr() ));
        configInfo->pbData        = (BYTE *) configInfo->messInput->payload->get_rd_ptr();
        configInfo->ulPartialSize = MPG_TRANSPORT_SIZE;
        ulRet = FULL_PID;
    }
    else
    {
        // No
        ulPartialSize      = configInfo->messInput->payload->get_size();
        configInfo->pbData = (BYTE *)&(configInfo->bPartialPacket[0]);

        // Assemble dummy packet
        memcpy ( &configInfo->pbData[0], configInfo->messInput->payload->get_rd_ptr(), 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->messInput->payload->get_rd_ptr(), 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 );
#endif

} /* end MPEG2TS_CheckForData() */

/************************************************************************/
/************************************************************************/
/**                                                                    **/
/**            procedure MPEG2TS_UpdatePackets()                       **/
/**                                                                    **/
/** PURPOSE: To make sure we have a full packet to process.            **/
/**                                                                    **/
/************************************************************************/
/************************************************************************/
ULONG MPEG2TS_UpdatePackets( TSDEMUXINFO *configInfo )
{
#if 1
    PBYTE pbData;
    ULONG ulSize;
    ULONG ulRet;

    ulRet = configInfo->ulDemuxState;
    
    //Check for a Valid Packet 
    switch( configInfo->ulDemuxState )
    {
    case NO_SYNC:
        pbData = configInfo->pbInputData;
        ulSize = configInfo->ulInputSize;
        if( pbData[0] == 0x47 )
        {
            if( ulSize >= MPG_TRANSPORT_SIZE )
            {
                ulRet = FULL_PID;
            }
            else
            {
                ulRet = PARTIAL_PID;
            }
        }
        break;

    case PARTIAL_PID:
    case FULL_PID:
        configInfo->pbInputData += configInfo->ulPartialSize;
        configInfo->ulInputSize -= configInfo->ulPartialSize;
        ulRet = FULL_PID;
        break;

    case TS_DEMUX_EXIT:
    default:
        break;
    }

    return( ulRet );

#else
    PBYTE pbData;
    ULONG ulSize;
    ULONG ulRet;
    ULONG ulReadAddr;

    ulRet = configInfo->ulDemuxState;
    
    //Check for a Valid Packet 
    switch( configInfo->ulDemuxState )
    {
    case NO_SYNC:
        pbData = (BYTE *)configInfo->messInput->payload->get_rd_ptr();
        ulSize = configInfo->messInput->payload->get_size();
        if( pbData[0] == 0x47 )
        {
            if( ulSize >= MPG_TRANSPORT_SIZE )
            {
                ulRet = FULL_PID;
            }
            else
            {
                ulRet = PARTIAL_PID;
            }
        }
        break;

    case PARTIAL_PID:
    case FULL_PID:
        ulReadAddr = (ULONG)(configInfo->messInput->payload->get_rd_ptr()) + configInfo->ulPartialSize;
        configInfo->messInput->payload->set_rd_ptr( (BYTE *)ulReadAddr );
        ulRet = FULL_PID;
        break;

    case TS_DEMUX_EXIT:
    default:
        break;
    }

    return( ulRet );
#endif

} /* end MPEG2TS_UpdatePackets() */ 

/************************************************************************/
/************************************************************************/
/**                                                                    **/
/**           procedure MPEG2TSDemuxGetErrorCnt()                      **/
/**                                                                    **/
/** PURPOSE: To return the current error count.                        **/
/**                                                                    **/
/************************************************************************/
/************************************************************************/
ULONG MPEG2TSDemuxGetErrorCnt( void )
{
    return( ulTSDemuxErrorCnt );
} /* end MPEG2TSDemuxGetErrorCnt() */

/************************************************************************/
/************************************************************************/
/**                                                                    **/
/************************************************************************/
/************************************************************************/
void MPEG2TSFlushPayload( void )
{
    DbgPrint(( "MPEG2TSFlushPayload:begin\n" ));

    if( tDemuxInfo.messInput != NULL )
    {
        DbgPrint(( "MPEG2TSFlushPayload: delete messInput payload and message\n" ));

        delete (DEMUXPAYLOAD *)tDemuxInfo.messInput->payload;
        tDemuxInfo.messInput->payload = NULL;
        tDemuxInfo.tConfigInfo.tInputPin->ReleaseMsg( tDemuxInfo.messInput );
        tDemuxInfo.messInput = NULL;
    }

    DbgPrint(( "MPEG2TSFlushPayload:end\n" ));

} /* end MPEG2TSFlushPayload() */
 
/*****************************************************************************
******************************************************************************
**                                                                          **
**  MPEG2TS Demux Thread                                                    **
**                                                                          **
******************************************************************************
*****************************************************************************/

/**
 * MPEG2TSDemuxThreadProc Function. Implements the state machine of the MPEG2
 * (Program Stream) Demux.
 *
 * @param
 *    PVOID pvDemuxInfo - Demux information
 *
 * @retval
 *    None.
 *
 * @remark
 *    None.
 *
 * @verified
 *    No.
 */
ULONG MPEG2TSDemuxThreadProc( PVOID pvDemuxInfo )
{
    TSDEMUXINFO *pDemuxInfo;

    /* Initialization */
    DbgPrint(("MPEG2TSDemuxThreadProc: Begin 0x%08x\n", (int)pvDemuxInfo ));

    ulTSDemuxErrorCnt = 0;

    pDemuxInfo = &tDemuxInfo;
    pDemuxInfo->pDynamicConfigInfo = (DEMUXCONFIGINFO *)pvDemuxInfo;

    /* Initialize and wait until there is an input payload */
    MPEG2TS_DemuxInit( pDemuxInfo );
    do
    {
        OS_TaskDelay( 2 );
        MPEG2TS_DemuxUpdate( pDemuxInfo );
    } while( (MPEG2_GetValidPacket( pDemuxInfo, __LINE__ ) == MPEGTS_FAILURE) );

    DbgPrint(("MPEG2TSDemuxThreadProc: ready to parse\n" ));
    
    /* MPEG2TS Demux State Machine */
    while( pDemuxInfo->ulDemuxState != TS_DEMUX_EXIT )
    {
        //Update parameters from the NAV
        MPEG2TS_DemuxUpdate( pDemuxInfo );

        //Check for a FULL or PARTIAL or NO_SYNC in the data
        pDemuxInfo->ulDemuxState = MPEG2TS_CheckForData( pDemuxInfo );

        switch( pDemuxInfo->ulDemuxState )
        {
        case NO_SYNC:
            pDemuxInfo->ulDemuxState = MPEG2TS_GetSync(pDemuxInfo);
            ulTSDemuxErrorCnt++;
            break;

        case PARTIAL_PID:
        case FULL_PID:
#if 1
            if( MPEG2TS_IsBeingWatched( pDemuxInfo ) )
            {
                MPEG2TS_ProcessPID( pDemuxInfo );
                MPEG2TS_Send_PID( pDemuxInfo );
            }
#else
            MPEG2TS_ProcessPID( pDemuxInfo );
            if( MPEG2TS_IsPATPMT(pDemuxInfo) )
            {
                MPEG2TS_Process_PATPMT(pDemuxInfo);
            }
            if ( MPEG2TS_IsBeingWatched( pDemuxInfo ) )
            {
                MPEG2TS_Send_PID( pDemuxInfo );
            }
#endif
            break;

        case TS_DEMUX_EXIT:
        default:
            pDemuxInfo->ulDemuxState = TS_DEMUX_EXIT;
            break;
        }

        //Update the payload pointers
        MPEG2TS_UpdatePackets( pDemuxInfo );
    }

    DbgPrint(("MPEG2TSDemuxThreadProc: End\n"));

    return 0;

} /* end MPEG2TSDemuxThreadProc() */