pe_istreamctrl_interface.cpp

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

/*****************************************************************************
******************************************************************************
**                                                                          **
**  Copyright (c) 2006 Videon Central, Inc.                                 **
**  All rights reserved.                                                    **
**                                                                          **
**  The computer program contained herein contains proprietary information  **
**  which is the property of Videon Central, Inc.  The program may be used  **
**  and/or copied only with the written permission of Videon Central, Inc.  **
**  or in accordance with the terms and conditions stipulated in the        **
**  agreement/contract under which the programs have been supplied.         **
**                                                                          **
******************************************************************************
*****************************************************************************/
/**
 * @file pe_istreamctrl_interface.cpp
 *
 * $Revision: 1.16 $ 
 *
 * DVD Presentation Engine API source file.
 *
 */

#include "decoder.h"
#include "vdvd_types.h"
#include "osapi.h"
#include "dbgprint.h"
#include "pe_app.h"
#include "pe_consumer.h"
#include "pe_types.h"
#include "utility.h"
#ifdef DMALLOC
#include "dmalloc.h"
#endif

#define DEBUG_ISTRMCTRL_IF DBG_ERROR
#define DBG_ON(x) (DEBUG_ISTRMCTRL_IF >= x)


/*
 * Private Function Prototypes
 ****************************************************************************/
static PE_STATUS peiStrmSendMessage(ISTREAMCTRLHANDLE *iStrmCtrl, ISTREAMCTRL_MESSAGE message_id,
    ULONG ulData0, ULONG ulData1, ULONG ulData2, ULONG ulData3, ULONG ulData4, BOOLEAN fSynchronous);

/**
 * Provides stream configuration control.
 *
 * @param handle       - iStrmCtrl handle.
 * @param StreamType   - iStrmCtrl stream type.
 * @param fSynchronous - flag to indicate if the call should be processed synchronously or asynchronously.
 *
 * @return PE_STATUS - PE Error code.
 */
PE_STATUS PEiStreamCtrlConfigure(PE_HANDLE handle, PE_ISTREAMCTRL_STREAM_TYPE StreamType, BOOLEAN fSynchronous)
{
    /* verify input */
    if (NULL == handle)
    {
        return (PE_INVALID_HANDLE);
    }
    if (StreamType >= STREAM_TYPE_INVALID)
    {
        return (PE_NOT_SUPPORTED);
    }

    return ( peiStrmSendMessage( ((PEHANDLE *)handle)->iStreamCtrl, PE_CONFIG, StreamType, fSynchronous, 0, 0, 0, fSynchronous) );
}

/**
 * Delete all PEConsumer objects and reset iStreamCtrl to the UNREALIZED state.
 *
 * @param handle - iStrmCtrl handle.
 *
 * @return PE_STATUS - Error code.
 */
PE_STATUS PEiStreamCtrlReset(PE_HANDLE handle)
{
    /* verify input */
    if (NULL == handle)
    {
        return (PE_INVALID_HANDLE);
    }

    return ( peiStrmSendMessage( ((PEHANDLE *)handle)->iStreamCtrl, PE_RESET, 0, 0, 0, 0, 0, PE_SYNC) );
}

/**
 * Sets graphics mode and creates and configures all required surfaces,
 * display layers, palettes, etc.
 *
 * @param handle - iStrmCtrl handle.
 * @param Mode   - graphics mode (HDMV, BDJ, or DVD).
 *
 * @return PE_STATUS - PE Error code.
 */
PE_STATUS PEiStreamCtrlSetGraphicsMode(PE_HANDLE handle, PE_ISTEAMCTRL_GRAPHICS_MODE Mode)
{
    /* verify input */
    if (NULL == handle)
    {
        return (PE_INVALID_HANDLE);
    }

    return ( peiStrmSendMessage( ((PEHANDLE *)handle)->iStreamCtrl, PE_SET_GRAPHICS_MODE, Mode, 0, 0, 0, 0, PE_SYNC) );
}

/**
 * Stops stream playback operation.
 *
 * @param handle - iStrmCtrl handle.
 * @param input  - which iStreamCtrl input (PEConsumer) to stop.
 *
 * @return PE_STATUS - Error code.
 *
 */
PE_STATUS PEiStreamCtrlStopStream(PE_HANDLE handle, PE_ISTREAMCTRL_INPUT input, BOOLEAN fHoldPicture)
{
    /* verify input */
    if (NULL == handle)
    {
        return (PE_INVALID_HANDLE);
    }

    return ( peiStrmSendMessage( ((PEHANDLE *)handle)->iStreamCtrl, PE_STOP_STREAM, input, fHoldPicture, 0, 0, 0, PE_SYNC) );
}

/**
 * Commences stream playback operation.
 *
 * @param handle - iStrmCtrl handle.
 *
 * @return PE_STATUS - PE Error code.
 */
PE_STATUS PEiStreamCtrlRun(PE_HANDLE handle)
{
    /* verify input */
    if (NULL == handle)
    {
        return (PE_INVALID_HANDLE);
    }

    return ( peiStrmSendMessage( ((PEHANDLE *)handle)->iStreamCtrl, PE_RUN, 0, 0, 0, 0, 0, PE_ASYNC) );
}

/**
 * Stops stream playback operation.
 *
 * @param handle - iStrmCtrl handle.
 *
 * @return PE_STATUS - Error code.
 */
PE_STATUS PEiStreamCtrlStop(PE_HANDLE handle, BOOLEAN fHoldPicture)
{
    /* verify input */
    if (NULL == handle)
    {
        return (PE_INVALID_HANDLE);
    }

    return ( peiStrmSendMessage( ((PEHANDLE *)handle)->iStreamCtrl, PE_STOP, fHoldPicture, 0, 0, 0, 0, PE_SYNC) );
}

/**
 * Pauses stream playback operation.
 *
 * @param handle - iStrmCtrl handle.
 *
 * @return PE_STATUS - Error code.
 */
PE_STATUS PEiStreamCtrlPause(PE_HANDLE handle)
{
    /* verify input */
    if (NULL == handle)
    {
        return (PE_INVALID_HANDLE);
    }

    return ( peiStrmSendMessage( ((PEHANDLE *)handle)->iStreamCtrl, PE_PAUSE, 0, 0, 0, 0, 0, PE_ASYNC) );
}

/**
 * Pauses stream playback.
 *
 * @param handle - iStrmCtrl handle.
 *
 * @return PE_STATUS - Error code.
 */
PE_STATUS PEiStreamCtrlStillOn(PE_HANDLE handle)
{
    /* verify input */
    if (NULL == handle)
    {
        return (PE_INVALID_HANDLE);
    }

    return ( peiStrmSendMessage( ((PEHANDLE *)handle)->iStreamCtrl, PE_STILL, TRUE, 0, 0, 0, 0, PE_SYNC) );
}

/**
 * Un-Pauses stream playback.
 *
 * @param handle - iStrmCtrl handle.
 *
 * @return PE_STATUS - Error code.
 */
PE_STATUS PEiStreamCtrlStillOff(PE_HANDLE handle)
{
    /* verify input */
    if (NULL == handle)
    {
        return (PE_INVALID_HANDLE);
    }

    return ( peiStrmSendMessage( ((PEHANDLE *)handle)->iStreamCtrl, PE_STILL, FALSE, 0, 0, 0, 0, PE_ASYNC) );
}

/**
 * Used for single frame step operations.
 *
 * @param handle - iStrmCtrl handle.
 *
 * @return PE_STATUS - Error code.
 */
PE_STATUS PEiStreamCtrlStep(PE_HANDLE handle)
{
    /* verify input */
    if (NULL == handle)
    {
        return (PE_INVALID_HANDLE);
    }

    return ( peiStrmSendMessage( ((PEHANDLE *)handle)->iStreamCtrl, PE_STEP, 0, 0, 0, 0, 0, PE_ASYNC) );
}

/**
 * Resumes playback operation.
 *
 * @param handle - iStrmCtrl handle.
 *
 * @return PE_STATUS - Error code.
 */
PE_STATUS PEiStreamCtrlResume(PE_HANDLE handle)
{
    /* verify input */
    if (NULL == handle)
    {
        return (PE_INVALID_HANDLE);
    }

    return ( peiStrmSendMessage( ((PEHANDLE *)handle)->iStreamCtrl, PE_RESUME, 0, 0, 0, 0, 0, PE_SYNC) );
}

/**
 * Resumes playback operation after a transition to Idle due to the beginning of stream event.
 *
 * @param handle - iStrmCtrl handle.
 *
 * @return PE_STATUS - Error code.
 */
PE_STATUS PEiStreamCtrlResumeFromIdle(PE_HANDLE handle, PE_ISTREAMCTRL_INPUT input)
{
    /* verify input */
    if (NULL == handle)
    {
        return (PE_INVALID_HANDLE);
    }

    return ( peiStrmSendMessage( ((PEHANDLE *)handle)->iStreamCtrl, PE_RESUME, input, 1, 0, 0, 0, PE_SYNC) );
}

/**
 * Requests that the indicated PEConsumer fill it's buffers with data prior to start of playback.
 * Used to help provide a smooth startup transition.
 *
 * @param handle - iStrmCtrl handle.
 * @param input - which iStreamCtrl input (PEConsumer) to prefill.
 * @param SyncType - Allows for asyncronous calling.
 *
 * @return PE_STATUS - Error code.
 */
PE_STATUS PEiStreamCtrlPrefill(PE_HANDLE handle, PE_ISTREAMCTRL_INPUT input, BOOLEAN fSynchronous)
{
    /* verify input */
    if (NULL == handle)
    {
        return (PE_INVALID_HANDLE);
    }

    return ( peiStrmSendMessage( ((PEHANDLE *)handle)->iStreamCtrl, PE_PREFILL, input, fSynchronous, 0, 0, 0, fSynchronous) );
}

/**
 * Flushes the indicated PEConsumer.
 *
 * @param handle - iStrmCtrl handle.
 * @param input  - which iStreamCtrl input (PEConsumer) to flush.
 *
 * @return PE_STATUS - Error code.
 */
PE_STATUS PEiStreamCtrlFlush(PE_HANDLE handle, PE_ISTREAMCTRL_INPUT input)
{
    /* verify input */
    if (NULL == handle)
    {
        return (PE_INVALID_HANDLE);
    }

    return ( peiStrmSendMessage( ((PEHANDLE *)handle)->iStreamCtrl, PE_FLUSH, input, 0, 0, 0, 0, PE_SYNC) );
}

/**
 * Dynamic register/cancel PE callback events to the previously registered callback function.
 *
 * @param handle  - iStrmCtrl handle.
 * @param input   - iStrmCtrl eventCallback.
 *
 * @return PE_STATUS - Error code.
 */
PE_STATUS PEiStreamCtrlRequestDecodeDoneEvent(PE_HANDLE handle, PE_ISTREAMCTRL_INPUT input)
{
    /* verify input */
    if (NULL == handle)
    {
        return (PE_INVALID_HANDLE);
    }

    return ( peiStrmSendMessage( ((PEHANDLE *)handle)->iStreamCtrl, PE_REQUEST_DECODE_DONE, (ULONG)input, 0, 0, 0, 0, PE_SYNC) );
}

/**
 * Returns the current state of the PE.
 *
 * @param handle - iStrmCtrl handle.
 *
 * @return PE_STATUS - Error code.
 */
PE_STATUS PEiStreamCtrlGetState(PE_HANDLE handle, PE_ISTREAMCTRL_STATE *pState)
{
    /* verify input */
    if (NULL == handle)
    {
        return (PE_INVALID_HANDLE);
    }
    if (NULL == pState)
    {
        return (PE_NULL_POINTER);
    }

    return ( peiStrmSendMessage( ((PEHANDLE *)handle)->iStreamCtrl, PE_GET_STATE, (ULONG)pState, 0, 0, 0, 0, PE_SYNC) );
}


/**
 * Attaches a cStream to the PE input for control by the iStrmCtrl interface.
 *
 * @param handle         - iStrmCtrl handle.
 * @param cstream_handle - Streaming class handle.
 *
 * @return PE_STATUS - Error code.
 */
PE_STATUS PEiStreamCtrlAttachInputStream(PE_HANDLE handle, STREAM_HANDLE cstream_handle, PE_ISTREAMCTRL_INPUT input)
{
    /* verify input */
    if (NULL == handle)
    {
        DbgPrint(("PEiStreamCtrlAttachInputStream() - invalid handle\n"));
        return (PE_INVALID_HANDLE);
    }
    if (NULL == cstream_handle)
    {
        DbgPrint(("PEiStreamCtrlAttachInputStream() - invalid handle\n"));
        return (PE_NULL_POINTER);
    }

    return ( peiStrmSendMessage( ((PEHANDLE *)handle)->iStreamCtrl, PE_ATTACH_INPUT_STREAM, input, (ULONG)cstream_handle, 0, 0, 0, PE_SYNC) );
}

/**
 * Assigns the pes_id video stream to the de-multiplexer for processing.
 *
 * @param handle - iStrmCtrl handle.
 * @param lPesId - Packetized elementary stream identifier.
 *
 * @return PE_STATUS - Error code.
 */
PE_STATUS PEiStreamCtrlDemuxAddVideoPS(PE_HANDLE handle, LONG lPesId, PE_ISTREAMCTRL_INPUT input, PE_ISTREAMCTRL_VIDEO_TYPE VideoType)
{
    /* verify input */
    if (NULL == handle)
    {
        return (PE_INVALID_HANDLE);
    }

    return ( peiStrmSendMessage( ((PEHANDLE *)handle)->iStreamCtrl, PE_DEMUX_VIDEO_PS, lPesId, input, VideoType, 0, 0, PE_SYNC) );
}

/**