pe_consumer_bdrom.cpp

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

                    break;

                case AUDIO_SAMPLING_FREQUENCY_96_KHz:
                    dapAudioParams.sample_rate = 96000;
                    break;

                case AUDIO_SAMPLING_FREQUENCY_192_KHz:
                    dapAudioParams.sample_rate = 192000;
                    break;
            }

            switch(pAttributes->n_channels)
            {
                case AUDIO_MONO:
                    dapAudioParams.num_channels = 1;
                    break;

                case AUDIO_DUAL_MONO:
                case AUDIO_STEREO:
                    dapAudioParams.num_channels = 2;
                    break;

                case AUDIO_3_CHANNELS:
                    dapAudioParams.num_channels = 3;
                    break;

                case AUDIO_4_CHANNELS:
                    dapAudioParams.num_channels = 4;
                    break;

                case AUDIO_5_CHANNELS:
                    dapAudioParams.num_channels = 5;
                    break;

                case AUDIO_6_CHANNELS:
                    dapAudioParams.num_channels = 6;
                    break;

                case AUDIO_7_CHANNELS:
                    dapAudioParams.num_channels = 7;
                    break;

                case AUDIO_8_CHANNELS:
                    dapAudioParams.num_channels = 8;
                    break;

                case AUDIO_MULTI_CHANNEL:            /* Blu-Ray audio_presentation_type 6  */
                case AUDIO_STEREO_PLUS_MULTI_EXT:    /* Blu-Ray audio_presentation_type 12 */
                case AUDIO_CHANNELS_INVALID:
                    dapAudioParams.num_channels = 0;
                    break;
            }
        }
        else
        {
            /* the audio attributes were NULL */
            dapAudioParams.sample_rate = 48000;
            dapAudioParams.num_channels = 0;
        }

        // if need to check if already running before changing streams use
        // if (IS_PECONSUMER_STATE_RUNNING(m_ConsumerState) == TRUE)

        error = m_audioDecode[1]->SelectAudioStream(&dapAudioParams);
        if (VDVD_IS_ERROR(error))
        {
            m_audioDecode[1] = NULL;
            status           = PE_FAILURE;
        }

    }

    return (status);

} /* end cPEConsumer_BDROM::DemuxAddSecondaryAudioTS() */

/**
 * Assigns the PID for the Presentation Graphics stream.
 * If idle (not being used to demux) then become active.
 *
 * @param LONG lPID
 *
 * @return PE_STATUS
 */
PE_STATUS cPEConsumer_BDROM::DemuxAddPGTS(LONG lPID, PVOID pDecoder)
{
    DBGPRINT(DBG_ON(DBG_TRACE), ("cPEConsumer_BDROM::DemuxAddPGTS - enter\n"));

    if (pDecoder == NULL)
    {
        return (PE_NULL_POINTER);
    }
    if (m_ConsumerState == PE_CONSUMER_STATE_UNREALIZED)
    {
        return (PE_INVALID_STATE);
    }

    /* if the pg decoder hasn't been intialized then do it now */
    if (m_pg_dec == NULL)
    {
        /* Initialize the Presentation Graphics */
        m_pg_dec = pDecoder;
    }
    else
    {
        /* flush the pg decoder */
        PGStop(m_pg_dec);
    }
    PGRun(m_pg_dec);


    DBGPRINT(DBG_ON(DBG_TRACE), ("cPEConsumer_BDROM::DemuxAddPGTS - exit\n"));

    m_pg_pid = lPID;

    return (PE_SUCCESS);

} /* end cPEConsumer_BDROM::DemuxAddPGTS() */

/**
 * Assigns the PID for the Interactive Graphics stream.
 * If idle (not being used to demux) then become active.
 *
 * @param LONG lPID
 *
 * @return PE_STATUS
 */
PE_STATUS cPEConsumer_BDROM::DemuxAddIGTS(LONG lPID, PVOID pDecoder)
{
    DBGPRINT(DBG_ON(DBG_TRACE), ("cPEConsumer_BDROM::DemuxAddIGTS - enter\n"));

    if (pDecoder == NULL)
    {
        return (PE_NULL_POINTER);
    }
    if (m_ConsumerState == PE_CONSUMER_STATE_UNREALIZED)
    {
        return (PE_INVALID_STATE);
    }

    /* if the ig decoder hasn't been intialized then do it now */
    if (m_ig_dec == NULL)
    {
        /* Initialize the Interactive Graphics Decoder */
        m_ig_dec = pDecoder;
        if (m_ConsumerInput == INPUT_BDROM_SUBPATH_INTERACTIVE_GRAPHICS)
        {
            IGSynchronize(m_ig_dec, IG_DECODE_ASYNC);
        }
        else
        {
            IGSynchronize(m_ig_dec, IG_DECODE_SYNC);
        }
        IGRun(m_ig_dec);
    }
    else
    {
        /* flush the ig decoder */
        IGStop(m_ig_dec);
        if (m_ConsumerInput == INPUT_BDROM_SUBPATH_INTERACTIVE_GRAPHICS)
        {
            IGSynchronize(m_ig_dec, IG_DECODE_ASYNC);
        }
        else
        {
            IGSynchronize(m_ig_dec, IG_DECODE_SYNC);
        }
        IGRun(m_ig_dec);
    }


    m_ig_pid = lPID;

    return (PE_SUCCESS);

} /* end cPEConsumer_BDROM::DemuxAddIGTS() */

/**
 * Assigns the PID for the font based SubText stream.
 * If idle (not being used to demux) then become active.
 *
 * @param LONG lPID
 *
 * @return PE_STATUS
 */
PE_STATUS cPEConsumer_BDROM::DemuxAddSubTextTS(LONG lPID, PVOID pDecoder)
{
    DBGPRINT(DBG_ON(DBG_TRACE), ("cPEConsumer_BDROM::DemuxAddSubTextTS - enter\n"));

    if (pDecoder == NULL)
    {
        return (PE_NULL_POINTER);
    }
    if (m_ConsumerState == PE_CONSUMER_STATE_UNREALIZED)
    {
        return (PE_INVALID_STATE);
    }

    /* if the pg decoder hasn't been intialized then do it now */
    if (m_st_dec == NULL)
    {
        /* Initialize the Subtext Decoder */
        m_st_dec = pDecoder;
    }
    else
    {
        /* flush the st decoder */
        if (TextSTGetState(m_st_dec) != TEXTST_STATE_STOPPED)
        {
            TextSTStop(m_st_dec);
        }
        TextSTFlush(m_st_dec);
    }


    m_st_pid = lPID;

    return (PE_SUCCESS);

} /* end cPEConsumer_BDROM::DemuxAddSubTextTS() */

/**
 * Detachs the video output stream from the demux.
 * If there are no other streams being demuxed become idle.
 *
 * @return PE_STATUS
 */
PE_STATUS cPEConsumer_BDROM::DemuxRemoveVideoTS(void)
{
    DBGPRINT(DBG_ON(DBG_TRACE), ("cPEConsumer_BDROM::DemuxRemoveVideoTS()\n"));

    if (m_ConsumerState == PE_CONSUMER_STATE_UNREALIZED)
    {
        return (PE_INVALID_STATE);
    }

    /* Invalidate video decoder */
    m_videoDecode[0] = NULL;

    return (PE_SUCCESS);

} /* end cPEConsumer_BDROM::DemuxRemoveVideoTS() */

/**
 * Detachs the audio output stream from the demux.
 * If there are no other streams being demuxed become idle.
 *
 * @return PE_STATUS
 */
PE_STATUS cPEConsumer_BDROM::DemuxRemoveAudioTS(void)
{
    PE_ISTREAMCTRL_AUDIO_ATTRIBUTES audio_attributes;

    DBGPRINT(DBG_ON(DBG_TRACE), ("cPEConsumer_BDROM::DemuxRemoveAudioTS()\n"));

    if (m_ConsumerState == PE_CONSUMER_STATE_UNREALIZED)
    {
        return (PE_INVALID_STATE);
    }

	/* TODO-SDK - Most transport stream demultiplexers require a PID setting for audio.
	 * If an independent stop is available for the audio decoder, it might also be used.
	 */

    /*
     * Add an audio demux with an invalid PID, to be sure no audio will
     * be presented.
     */
    audio_attributes.sampling_frequency = AUDIO_SAMPLING_FREQUENCY_INVALID;
    audio_attributes.n_channels         = AUDIO_CHANNELS_INVALID;
    DemuxAddAudioTS(0x181F, AUDIO_TYPE_AC3, &audio_attributes, m_audioDecode[0]);

    /* Invalidate audio decoder */
    m_audioDecode[0] = NULL;

    return (PE_SUCCESS);

} /* end cPEConsumer_BDROM::DemuxRemoveAudioTS() */

/**
 * Detach the Secondary Audio Stream from the demux.
 * If there are no other streams being demuxed become idle.
 *
 * @return PE_STATUS
 */
PE_STATUS cPEConsumer_BDROM::DemuxRemoveSecondaryAudioTS(void)
{
    DBGPRINT(DBG_ON(DBG_TRACE), ("cPEConsumer_BDROM::DemuxRemoveSecondaryAudioTS()\n"));

    if (m_ConsumerState == PE_CONSUMER_STATE_UNREALIZED)
    {
        return (PE_INVALID_STATE);
    }

    /* Invalidate secondary audio decoder */
    m_audioDecode[1] = NULL;

    return (PE_SUCCESS);

} /* end cPEConsumer_BDROM::DemuxRemoveSecondaryAudioTS() */

/**
 * Detach the Presentation Graphics stream from the demux.
 * If there are no other streams being demuxed become idle.
 *
 * @return PE_STATUS
 */
PE_STATUS cPEConsumer_BDROM::DemuxRemovePGTS(void)
{
    PE_STATUS status = PE_SUCCESS;

    DBGPRINT(DBG_ON(DBG_TRACE), ("cPEConsumer_BDROM::DemuxRemovePGTS()\n"));

    if (m_ConsumerState == PE_CONSUMER_STATE_UNREALIZED)
    {
        return (PE_INVALID_STATE);
    }


    /* Stop PG decoder */
    if (m_pg_dec != NULL)
    {
        PGStop(m_pg_dec);
        m_pg_dec = NULL;
    }

    m_pg_pid = -1;

    return (status);

} /* end cPEConsumer_BDROM::DemuxRemovePGTS() */

/**
 * Detach the Interactive Graphics stream from the demux.
 * If there are no other streams being demuxed become idle.
 *
 * @return PE_STATUS
 */
PE_STATUS cPEConsumer_BDROM::DemuxRemoveIGTS(void)
{
    PE_STATUS status = PE_SUCCESS;

    DBGPRINT(DBG_ON(DBG_TRACE), ("cPEConsumer_BDROM::DemuxRemoveIGTS()\n"));

    if (m_ConsumerState == PE_CONSUMER_STATE_UNREALIZED)
    {
        return (PE_INVALID_STATE);
    }


    /* Stop IG decoder */
    if (m_ig_dec != NULL)
    {
        IGStop(m_ig_dec);
        m_ig_dec = NULL;
    }

    m_ig_pid = -1;

    return (status);

} /* end cPEConsumer_BDROM::DemuxRemoveIGTS() */

/**
 * Detach the font based SubText stream from the demux.
 * If there are no other streams being demuxed become idle.
 *
 * @return PE_STATUS
 */
PE_STATUS cPEConsumer_BDROM::DemuxRemoveSubTextTS(void)
{
    PE_STATUS status = PE_SUCCESS;

    DBGPRINT(DBG_ON(DBG_TRACE), ("cPEConsumer_BDROM::DemuxRemoveSubTextTS()\n"));

    if (m_ConsumerState == PE_CONSUMER_STATE_UNREALIZED)
    {
        return (PE_INVALID_STATE);
    }


    /* Stop ST decoder */
    if (m_st_dec != NULL)
    {
        if (TextSTGetState(m_st_dec) != TEXTST_STATE_STOPPED)
        {
            TextSTStop(m_st_dec);
        }
        TextSTFlush(m_st_dec);
        m_st_dec = NULL;
    }

    m_st_pid = -1;

    return (status);

} /* cPEConsumer_BDROM::DemuxRemoveSubTextTS() */

/**
 * Return status of PG demux for this consumer
 *
 * @return PE_STATUS
 */
PE_STATUS cPEConsumer_BDROM::DemuxGetPGTS(LONG *pPID, BOOLEAN *pfIsActive)
{
    // SDK: if we are demuxing then *pPID = m_pg_pid;