pe_consumer.h

这是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_consumer.h
 *
 * $Revision: 1.20 $ 
 *
 * PE Consumer Base Class Definition
 * The PE Consumer moves data from an input stream to a decoder or demux.
 *
 */

#ifndef PE_CONSUMER_H
#define PE_CONSUMER_H

#define IS_PECONSUMER_STATE_RUNNING(x)  ( (x == PE_CONSUMER_STATE_RUN) || (x == PE_CONSUMER_STATE_STILL) )


/* PEConsumer States */
typedef enum _tagPE_CONSUMER_STATE
{
    PE_CONSUMER_STATE_UNREALIZED = 0,
    PE_CONSUMER_STATE_REALIZING,
    PE_CONSUMER_STATE_STOP,
    PE_CONSUMER_STATE_STILL,
    PE_CONSUMER_STATE_RUN,

    /* this is always the last value */
    PE_CONSUMER_STATE_INVALID
} PE_CONSUMER_STATE;

/* function prototype for PEConsumer callbacks.
 * The pEventInfo is optional based on the event. If the event has no info this should be passed as NULL */
typedef PE_STATUS(*PE_CONSUMER_CALLBACK)(PVOID pContext, PE_EVENT_CODE event, PVOID pEventinfo, PE_ISTREAMCTRL_INPUT ConsumerInput);


typedef struct _tagPE_CONSUMER_CONFIG_INFO
{
    PE_ISTREAMCTRL_INPUT input;
    BOOLEAN         fPlaybackStarted;
} PE_CONSUMER_CONFIG_INFO;




class cPEConsumer
{
public:

    cPEConsumer()
    {
        m_InputStream                         = NULL;
        m_fKillDataProc                       = FALSE;
        m_dataProcID                          = 0;
        m_ConsumerState                       = PE_CONSUMER_STATE_UNREALIZED;
        m_ConsumerInput                       = INPUT_MAIN;
        m_fStop                               = FALSE;
        m_fAbort                              = FALSE;
        m_fPrefill                            = FALSE;
        m_fSyncPrefill                        = FALSE;
        m_fSuspend                            = FALSE;
        m_fStillOn                            = FALSE;
        m_videoDecode[0]                      = NULL;
        m_audioDecode[0]                      = NULL;
        m_videoDecode[1]                      = NULL;
        m_audioDecode[1]                      = NULL;
        m_playrate.rate                       = PLAY_RATE_NORMAL;
        m_playrate.direction                  = PE_ISTREAMCTRL_DIRECTION_FORWARD;
        m_playrate.mode                       = PE_ISTREAMCTRL_DEC_MODE_ALL;
        m_playrate.discontiguous              = FALSE;
        m_playrate.read_skip                  = 0;
        m_playrate.display_skip               = 0;
        m_playrate.persistence                = 1;
    }

    virtual ~cPEConsumer()
    {
        DbgPrint(("cPEConsumer Class Destructor\n"));
    }

    void * operator new( size_t size )
    {
        return ( OS_MemAlloc(size) );
    }

    void operator delete( void * pvPFB )
    {
        OS_MemFree(pvPFB);
    }

    /* Override these if additional processing is required */
    virtual PE_STATUS Configure(PE_CONSUMER_CONFIG_INFO *pConfigInfo);
    virtual PE_STATUS Reset(void);

    PE_STATUS AttachEvent(PE_CONSUMER_CALLBACK function, PVOID pContext);
    PE_STATUS AttachInputStream(cStream *pStream, PE_ISTREAMCTRL_INPUT input);

    PE_CONSUMER_STATE GetState(void)
    {
        return (m_ConsumerState);
    }

    PE_ISTREAMCTRL_PLAYRATE GetRate(void);

    PE_STATUS ResumeFromIdle(void)
    {
        m_fSuspend = FALSE;
        return (PE_SUCCESS);
    }

    virtual PE_STATUS SetRate(PE_ISTREAMCTRL_PLAYRATE *pPlayRate);
    virtual PE_STATUS Run(void);

    virtual PE_STATUS Stop(BOOLEAN fHoldPicture)
    {
        DbgPrint(("cPEConsumer::Stop - SHOULD OVERRIDE THIS\n"));
        return (PE_NOT_IMPLEMENTED);
    }
    virtual PE_STATUS Prefill(BOOLEAN fBlocking)
    {
        m_fPrefill = TRUE;
        m_fSyncPrefill = fBlocking; // set flag for synchronous prefill
        if (m_fSyncPrefill)
        {
            while (m_fPrefill)      // if sync prefill, block until prefilled
            {
                OS_TaskYield();
            }
            m_fSyncPrefill = FALSE;
        }
        return (PE_SUCCESS);
    }
    virtual PE_STATUS Flush(void)
    {
        DbgPrint(("cPEConsumer::Flush - SHOULD OVERRIDE THIS\n"));
        return (PE_NOT_IMPLEMENTED);
    }
    virtual PE_STATUS RequestDecodeDoneEvent(void);
    virtual PE_STATUS ForceLastPictureDecode(void);
    virtual PE_STATUS StillOnOff(BOOLEAN fStillOn)
    {
        if (fStillOn)
        {
            m_fStillOn = TRUE;
            m_playrate.rate = PLAY_RATE_PAUSE;
            m_playrate.persistence   = 0;
            SetVideoDecodeRate(&m_playrate);
        }
        else
        {
            m_fStillOn = FALSE;
            m_playrate.rate = PLAY_RATE_NORMAL;
            m_playrate.persistence   = 1;
            SetVideoDecodeRate(&m_playrate);
        }
        return (PE_SUCCESS);
    }
    virtual PE_STATUS DemuxAddVideoPS(LONG lPID, PE_ISTREAMCTRL_VIDEO_TYPE VideoType, LONG lExtID,
        PE_ISTREAMCTRL_VIDEO_EXT_TYPE ExtVideoType, Decoder* pDecoder);
    virtual PE_STATUS DemuxAddSecondaryVideoPS(LONG lPID, PE_ISTREAMCTRL_VIDEO_TYPE VideoType, LONG lExtID,
        PE_ISTREAMCTRL_VIDEO_EXT_TYPE ExtVideoType, PVOID pDecoder)
    {
        DbgPrint(("cPEConsumer::DemuxAddSecondaryVideoPS - SHOULD OVERRIDE THIS\n"));
        return (PE_NOT_IMPLEMENTED);
    }
    virtual PE_STATUS DemuxAddAudioPS(LONG lPID, LONG lSubID, PE_ISTREAMCTRL_AUDIO_TYPE AudioType, PE_ISTREAMCTRL_AUDIO_ATTRIBUTES *pAttributes, Decoder* pDecoder);
    virtual PE_STATUS DemuxAddSecondaryAudioPS(LONG lPID, LONG lSubID, PE_ISTREAMCTRL_AUDIO_TYPE AudioType, PE_ISTREAMCTRL_AUDIO_ATTRIBUTES *pAttributes, PVOID pDecoder)
    {
        DbgPrint(("cPEConsumer::DemuxAddSecondaryAudioTS - SHOULD OVERRIDE THIS\n"));
        return (PE_NOT_IMPLEMENTED);
    }
    virtual PE_STATUS DemuxAddSubstituteAudioPS(LONG lPID, LONG lSubID, PE_ISTREAMCTRL_AUDIO_TYPE AudioType, PE_ISTREAMCTRL_AUDIO_ATTRIBUTES *pAttributes, PVOID pDecoder)
    {
        DbgPrint(("cPEConsumer::DemuxAddSubstituteAudioPS - SHOULD OVERRIDE THIS\n"));
        return (PE_NOT_IMPLEMENTED);
    }
    virtual PE_STATUS DemuxAddSubpicPS(LONG lPID, LONG lSubID, PVOID pDecoder)
    {
        DbgPrint(("cPEConsumer::DemuxAddSubpicPS - SHOULD OVERRIDE THIS\n"));
        return (PE_NOT_IMPLEMENTED);
    }
    virtual PE_STATUS DemuxRemoveVideoPS(void);
    virtual PE_STATUS DemuxRemoveAudioPS(void);
    virtual PE_STATUS DemuxRemoveSecondaryVideoPS(void)
    {
        DbgPrint(("cPEConsumer::DemuxRemoveSecondaryVideoPS - SHOULD OVERRIDE THIS\n"));
        return (PE_NOT_IMPLEMENTED);
    }
    virtual PE_STATUS DemuxRemoveSecondaryAudioPS(void)
    {
        DbgPrint(("cPEConsumer::DemuxRemoveSecondaryAudioPS - SHOULD OVERRIDE THIS\n"));
        return (PE_NOT_IMPLEMENTED);
    }
    virtual PE_STATUS DemuxRemoveSubstituteAudioPS(void)
    {
        DbgPrint(("cPEConsumer::DemuxRemoveSubstituteAudioPS - SHOULD OVERRIDE THIS\n"));
        return (PE_NOT_IMPLEMENTED);
    }
    virtual PE_STATUS DemuxRemoveSubpicPS(void)
    {
        DbgPrint(("cPEConsumer::DemuxRemoveSubpicPS - SHOULD OVERRIDE THIS\n"));
        return (PE_NOT_IMPLEMENTED);
    }
    virtual PE_STATUS DemuxAddVideoTS(LONG lPID, PE_ISTREAMCTRL_VIDEO_TYPE VideoType, Decoder* pDecoder)
    {
        DbgPrint(("cPEConsumer::DemuxAddVideoTS - SHOULD OVERRIDE THIS\n"));
        return (PE_NOT_IMPLEMENTED);
    }
    virtual PE_STATUS DemuxAddAudioTS(LONG lPID, PE_ISTREAMCTRL_AUDIO_TYPE AudioType, PE_ISTREAMCTRL_AUDIO_ATTRIBUTES *pAttributes, Decoder* pDecoder)
    {
        DbgPrint(("cPEConsumer::DemuxAddAudioTS - SHOULD OVERRIDE THIS\n"));
        return (PE_NOT_IMPLEMENTED);
    }
    virtual PE_STATUS DemuxAddSecondaryAudioTS(LONG lPID, PE_ISTREAMCTRL_AUDIO_TYPE AudioType, PE_ISTREAMCTRL_AUDIO_ATTRIBUTES *pAttributes, PVOID pDecoder)
    {
        DbgPrint(("cPEConsumer::DemuxAddSecondaryAudioTS - SHOULD OVERRIDE THIS\n"));
        return (PE_NOT_IMPLEMENTED);
    }
    virtual PE_STATUS DemuxAddPGTS(LONG lPID, PVOID pDecoder)
    {
        DbgPrint(("cPEConsumer::DemuxAddPGTS - SHOULD OVERRIDE THIS\n"));
        return (PE_NOT_IMPLEMENTED);
    }
    virtual PE_STATUS DemuxAddIGTS(LONG lPID, PVOID pDecoder)
    {
        DbgPrint(("cPEConsumer::DemuxAddIGTS - SHOULD OVERRIDE THIS\n"));
        return (PE_NOT_IMPLEMENTED);
    }
    virtual PE_STATUS DemuxAddSubTextTS(LONG lPID, PVOID pDecoder)
    {
        DbgPrint(("cPEConsumer::DemuxAddSubTextTS - SHOULD OVERRIDE THIS\n"));
        return (PE_NOT_IMPLEMENTED);
    }
    virtual PE_STATUS DemuxRemoveVideoTS(void)
    {
        DbgPrint(("cPEConsumer::DemuxRemoveVideoTS - SHOULD OVERRIDE THIS\n"));
        return (PE_NOT_IMPLEMENTED);
    }
    virtual PE_STATUS DemuxRemoveAudioTS(void)
    {
        DbgPrint(("cPEConsumer::DemuxRemoveAudioTS - SHOULD OVERRIDE THIS\n"));
        return (PE_NOT_IMPLEMENTED);
    }
    virtual PE_STATUS DemuxRemovePGTS(void)
    {
        DbgPrint(("cPEConsumer::DemuxRemovePGTS - SHOULD OVERRIDE THIS\n"));
        return (PE_NOT_IMPLEMENTED);
    }
    virtual PE_STATUS DemuxRemoveIGTS(void)
    {
        DbgPrint(("cPEConsumer::DemuxRemoveIGTS - SHOULD OVERRIDE THIS\n"));
        return (PE_NOT_IMPLEMENTED);
    }
    virtual PE_STATUS DemuxRemoveSubTextTS(void)
    {
        DbgPrint(("cPEConsumer::DemuxRemoveSubTextTS - SHOULD OVERRIDE THIS\n"));
        return (PE_NOT_IMPLEMENTED);
    }
    virtual PE_STATUS DemuxRemoveSecondaryAudioTS(void)
    {
        DbgPrint(("cPEConsumer::DemuxRemoveSecondaryAudioTS - SHOULD OVERRIDE THIS\n"));
        return (PE_NOT_IMPLEMENTED);
    }

    virtual PE_STATUS DemuxGetVideoPS(LONG *plPID, BOOLEAN *pfIsActive)
    {
        DbgPrint(("cPEConsumer::DemuxGetVideoPS - SHOULD OVERRIDE THIS\n"));
        return (PE_NOT_IMPLEMENTED);
    };
    virtual PE_STATUS DemuxGetAudioPS(LONG *plPID, LONG *plSubID, BOOLEAN *pfIsActive)
    {
        DbgPrint(("cPEConsumer::DemuxGetAudioPS - SHOULD OVERRIDE THIS\n"));
        return (PE_NOT_IMPLEMENTED);
    };
    virtual PE_STATUS DemuxGetSubpicPS(LONG *plPID, LONG *plSubID, BOOLEAN *pfIsActive)
    {
        DbgPrint(("cPEConsumer::DemuxGetSubpicPS - SHOULD OVERRIDE THIS\n"));
        return (PE_NOT_IMPLEMENTED);
    };
    virtual PE_STATUS DemuxGetVideoTS(LONG *pPID, BOOLEAN *pfIsActive)
    {
        DbgPrint(("cPEConsumer::DemuxGetVideoTS - SHOULD OVERRIDE THIS\n"));
        return (PE_NOT_IMPLEMENTED);
    };
    virtual PE_STATUS DemuxGetSecondaryVideoTS(LONG *pPID, BOOLEAN *pfIsActive)
    {
        DbgPrint(("cPEConsumer::DemuxGetSecondaryVideoTS - SHOULD OVERRIDE THIS\n"));
        return (PE_NOT_IMPLEMENTED);
    };
    virtual PE_STATUS DemuxGetAudioTS(LONG *pPID, BOOLEAN *pfIsActive)
    {
        DbgPrint(("cPEConsumer::DemuxGetAudioTS - SHOULD OVERRIDE THIS\n"));
        return (PE_NOT_IMPLEMENTED);
    };
    virtual PE_STATUS DemuxGetSecondaryAudioTS(LONG *pPID, BOOLEAN *pfIsActive)
    {
        DbgPrint(("cPEConsumer::DemuxGetSecondaryAudioTS - SHOULD OVERRIDE THIS\n"));
        return (PE_NOT_IMPLEMENTED);
    };
    virtual PE_STATUS DemuxGetPGTS(LONG *pPID, BOOLEAN *pfIsActive)
    {
        DbgPrint(("cPEConsumer::DemuxGetPGTS - SHOULD OVERRIDE THIS\n"));
        return (PE_NOT_IMPLEMENTED);
    };
    virtual PE_STATUS DemuxGetIGTS(LONG *pPID, BOOLEAN *pfIsActive)
    {
        DbgPrint(("cPEConsumer::DemuxGetIGTS - SHOULD OVERRIDE THIS\n"));
        return (PE_NOT_IMPLEMENTED);
    };
    virtual PE_STATUS DemuxGetSubTextTS(LONG *pPID, BOOLEAN *pfIsActive)
    {
        DbgPrint(("cPEConsumer::DemuxGetSubTextTS - SHOULD OVERRIDE THIS\n"));
        return (PE_NOT_IMPLEMENTED);
    };
    virtual PE_STATUS UpdateMasterNavPackPTS(TIME90k time90k_NavPackPTS)
    {
        DbgPrint(("cPEConsumer::UpdateMasterNavPackPTS - SHOULD OVERRIDE THIS\n"));
        return (PE_NOT_IMPLEMENTED);
    }

    PE_STATUS GetVidPTS(TIME45k* pTime45k_PTS, TIME45k* pTime45k_STC);

private:
    /* event callback to iStreamCtrl */
    PE_CONSUMER_CALLBACK peConsumerCallback;
    PVOID peConsumerCallbackContext;

    virtual PE_STATUS dataProc(void);


    static ULONG peConsumerDataProcCaller(PVOID pvParam)
    {
        PE_STATUS status = PE_SUCCESS;

        if (NULL != pvParam)
        {
            status = ( (cPEConsumer*)pvParam )->dataProc();
        }

        OS_TaskExit();

        return (status);
    }

    virtual PE_STATUS processData(PEINPUTMESSAGE *pInMessage)
    {
        DbgPrint(("cPEConsumer::processData - SHOULD OVERRIDE THIS\n"));
        return (PE_NOT_IMPLEMENTED);
    };

    virtual PE_STATUS processInfo(PEINPUTMESSAGE *pInMessage)
    {
        DbgPrint(("cPEConsumer::processInfo - SHOULD OVERRIDE THIS\n"));
        return (PE_NOT_IMPLEMENTED);
    };


protected:

    PE_STATUS SendEvent(PE_EVENT_CODE event, PVOID pEventinfo);
    PE_STATUS SendPayloadToDecoder(Decoder* decoder, cPayload *pPayload);
    virtual PE_STATUS SetVideoDecodeRate(PE_ISTREAMCTRL_PLAYRATE *pPlayRate);

    

    /* override these to modify default behavior */
    virtual PE_STATUS ProcessBegOfStream(PVOID StreamContext);
    virtual PE_STATUS ProcessEndOfStream(PVOID StreamContext);


    cStream*                     m_InputStream;
    PE_CONSUMER_STATE            m_ConsumerState;
    PE_ISTREAMCTRL_INPUT         m_ConsumerInput;
    BOOLEAN                      m_fKillDataProc;
    BOOLEAN                      m_fStop;
    BOOLEAN                      m_fAbort;
    BOOLEAN                      m_fPrefill;
    BOOLEAN                      m_fSyncPrefill;
    BOOLEAN                      m_fSuspend;
    BOOLEAN                      m_fStillOn;
    int                          m_dataProcID;
    Decoder*                     m_videoDecode[2];
    Decoder*                     m_audioDecode[2];
    PE_ISTREAMCTRL_PLAYRATE      m_playrate;
    BOOLEAN                      m_fPlaybackStarted;
};

#endif