oggfformat.cpp

linux下的一款播放器

STDMETHODIMP_(UINT32) COggFileFormat::Release(void)
{
    if (InterlockedDecrement(&m_RefCount) > 0)
        return m_RefCount;

    delete this;
    return 0;
}

STDMETHODIMP COggFileFormat::QueryInterface(REFIID interfaceID, 
                                            void **ppInterfaceObj)
{
    if (IsEqualIID(interfaceID, IID_IUnknown)) {
        AddRef();
        *ppInterfaceObj = (IUnknown *)(IHXPlugin *)this;
        return HXR_OK;
    } else if (IsEqualIID(interfaceID, IID_IHXPlugin)) {
        AddRef();
        *ppInterfaceObj = (IHXPlugin *)this;
        return HXR_OK;
    } else if (IsEqualIID(interfaceID, IID_IHXFileFormatObject)) {
        AddRef();
        *ppInterfaceObj = (IHXFileFormatObject *)this;
        return HXR_OK;
    }

    *ppInterfaceObj = NULL;
    return HXR_NOINTERFACE;
}

STDMETHODIMP COggFileFormat::PageReaderInitDone(THIS_ HX_RESULT status)
{
    DPRINTF(D_OGG_FF, ("COFF::PageReaderInitDone(%08x)\n", status));

    HX_RESULT res = HXR_UNEXPECTED;

    if (m_State == InitPending)
    {
        changeState((HXR_OK == status) ? Ready : Start);

        m_pResponse->InitDone(status);
    }

    DPRINTF(D_OGG_FF, ("COFF::PageReaderInitDone() exiting\n"));

    return HXR_OK;
}

STDMETHODIMP COggFileFormat::ReadNextPageDone(THIS_ HX_RESULT status,
                                              ULONG32 ulFileOffset,
                                              UINT32 ulPageSize,
                                              ogg_page* pPage)
{
    DPRINTF(D_OGG_FF, 
            ("COFF::RNPD(%08x, (%u, %08x), %u)\n", 
             status, ulFileOffset, ulFileOffset, ulPageSize));
    
    HX_RESULT res = HXR_OK;

    if (m_pCurrentStrategy)
    {        
        res = m_pCurrentStrategy->ReadNextPageDone(status, 
                                                   ulFileOffset,
                                                   ulPageSize, 
                                                   pPage);

        DPRINTF(D_OGG_FF, ("COFF::RNPD() : res %08x\n", res));
        
        if ((HXR_OK == res) &&
            ((GetFirstStreamInfo == m_State) ||
             (GetNextLiveStreamInfo == m_State)))
        {
            res = cachePage(pPage);
            m_ulLastCachedPageOffset = ulFileOffset;
        }

        if ((HXR_OK == res) && m_pCurrentStrategy->Done())
        {
            switch(m_State) {
            case GetFirstStreamInfo:
                res = handleGetFirstStreamInfoDone();
                break;
            case FindLastPage:
                res = handleFindLastPageDone();
                break;
            case FindGroupEndPage:
                res = handleFindGroupEndPageDone();
                break;
            case FindGroupEndTime:
                res = handleFindGroupEndTimeDone();
                break;
            case FindLastGroupEndTime:
                res = handleFindLastGroupEndTimeDone();
                break;
            case GetNextStreamInfo:
                res = handleGetNextStreamInfoDone();
                break;
            case GetNextLiveStreamInfo:
                res = handleGetNextLiveStreamInfoDone();
                break;
            case FindSeekPointOffset:
                res = handleFindSeekPointOffsetDone();
                break;
            case CollectStreamHeaders:
                res = handleCollectHeadersDone();
                break;
            default:
                HX_ASSERT(!"Unexpected condition");
                res = HXR_UNEXPECTED;
                break;
            }
        }
    }
    else if (SeekBackToLastCachedPage == m_State)
    {
        res = handleSeekBackToLastCachedPage();
    }
    else if (GetPacketReadPending == m_State)
    {
        res = handlePacketReadPending(status, ulFileOffset,
                                      ulPageSize, pPage);
    }

    DPRINTF(D_OGG_FF, ("COFF::RNPD() : exiting res %08x\n", res));

    if (HXR_OK != res)
    {
        switch(m_State) {
        case GetFirstStreamInfo:
        case FindLastPage:
        case FindGroupEndPage:
        case FindGroupEndTime:
        case FindLastGroupEndTime:
        case GetNextStreamInfo:
        case SeekBackToLastCachedPage:
            m_pResponse->FileHeaderReady(res, 0);
            break;
        case FindSeekPointOffset:
        case CollectStreamHeaders:
            m_pResponse->SeekDone(res);
            break;
        case GetPacketReadPending:
        case GetNextLiveStreamInfo:
        {
            for (UINT32 i = 0; i < m_streamHdlr.StreamCount(); i++)
            {
                if (m_pGetPacketPending[i])
                {
                    m_pResponse->PacketReady(res, 0);
                }
            }
            changeState(Error);
        }break;
        default:
            HX_ASSERT(!"Unhandled Error");
            res = HXR_UNEXPECTED;
            break;
        }
    }

    return HXR_OK;
}

#ifdef _DEBUG
static const char* z_pStateNames[] = {
    "Start",
    "InitPending",
    "Ready",
    "GetFirstStreamInfo",
    "FindLastPage",
    "FindLastGroupEndTime",
    "FindGroupEndPage",
    "FindGroupEndTime",
    "GetNextStreamInfo",
    "SeekBackToLastCachedPage",
    "GetPacketReadPending",
    "GetNextLiveStreamInfo",
    "FindSeekPointOffset",
    "CollectStreamHeaders",
    "Error"
};
#endif /* _DEBUG */

void COggFileFormat::changeState(PluginState newState)
{
    DPRINTF(D_OGG_FF, ("COFF::changeState() : %s -> %s\n", 
                       z_pStateNames[m_State], 
                       z_pStateNames[newState]));
    m_State = newState;
}

HX_RESULT 
COggFileFormat::handleGetFirstStreamInfoDone()
{
    HX_RESULT res = HXR_UNEXPECTED;

    UINT16 uStreamCount = m_streamInfoStrategy.StreamCount();
    ULONG32 ulStartOffset;
    UINT32 uStartSize;

    if ((HXR_OK == m_streamInfoStrategy.StartPageOffset(ulStartOffset)) &&
        (HXR_OK == m_streamInfoStrategy.StartPageSize(uStartSize)))
    {

        DPRINTF(D_OGG_FF, ("COFF::hGFSID : StreamCount %u\n",
                           uStreamCount));
        DPRINTF(D_OGG_FF, ("COFF::hGFSID : StartPageOffset %u\n",
                           ulStartOffset));
        DPRINTF(D_OGG_FF, ("COFF::hGFSID : StartPageSize %u\n",
                           uStartSize));
    }
        
    for (UINT16 i = 0; i < uStreamCount;i++)
    {
        int serialNum;

        DPRINTF(D_OGG_FF, ("COFF::hGFSID : Stream %u\n",i));

        if (HXR_OK == m_streamInfoStrategy.GetStreamSerialNum(i, serialNum))
        {
            DPRINTF(D_OGG_FF, ("COFF::hGFSID :  Serial    %08x\n",
                               serialNum));

            const COggCodecInfo* pInfo = NULL;
            if (HXR_OK == m_streamInfoStrategy.GetCodecInfo(serialNum,
                                                            pInfo))
            {
                DPRINTF(D_OGG_FF, ("COFF::hGFSID :  CodecType %u\n",
                                   pInfo->Type()));
                DPRINTF(D_OGG_FF, ("COFF::hGFSID :  Dropped   %I64d\n",
                                   pInfo->GranulePosDropped()));
            }
        }
    }

    m_bIsLive = !m_pPageReader->IsSeekable();

    if (m_bIsLive)
    {
        // Live case

        UINT16 uNumAudioStreams = 0;
        UINT16 uNumVideoStreams = 0;
        
        res = getStreamTypeCountFromStreamInfo(uNumAudioStreams,
                                               uNumVideoStreams);
    
        if (HXR_OK == res)
        {
            res = m_streamHdlr.SetStreamTypeCounts(uNumAudioStreams,
                                                   uNumVideoStreams);
        }
        
        if (HXR_OK == res)
        {
            res = setupStreamHandlerFromStreamInfo();
        }
        
        if (HXR_OK == res)
        {
            res = sendCachedPagesToStreamHandler();
        }
        
        if (HXR_OK == res)
        {
            res = createAndSendFileHeader();
        }

        m_pCurrentStrategy = NULL;
    }
    else
    {
        changeState(FindLastPage);
        m_pCurrentStrategy = &m_findEOFStrategy;
        res = m_findEOFStrategy.Init(m_pPageReader);
    }

    return res;
}

HX_RESULT 
COggFileFormat::handleFindLastPageDone()
{
    HX_RESULT res = HXR_UNEXPECTED;

    ULONG32 ulStartOffset;
    ULONG32 ulLastPageOffset;
    UINT32 uLastPageSize;
    int serialNum ;

    if ((HXR_OK == m_streamInfoStrategy.StartPageOffset(ulStartOffset)) &&
        (HXR_OK == m_findEOFStrategy.LastPageSerialNum(serialNum)) &&
        (HXR_OK == m_findEOFStrategy.LastPageOffset(ulLastPageOffset)) &&
        (HXR_OK == m_findEOFStrategy.LastPageSize(uLastPageSize)))
    {
        if (m_streamInfoStrategy.HaveSerialNum(serialNum))
        {
            // Single group case
            DPRINTF(D_OGG_FF, ("COFF::hFLPD : single group\n"));

            const COggCodecInfo* pInfo = NULL;
            res = m_streamInfoStrategy.GetCodecInfo(serialNum, pInfo);

            if (HXR_OK == res)
            {
                changeState(FindLastGroupEndTime);
                m_pCurrentStrategy = &m_groupEndTimeStrategy;
                res = m_groupEndTimeStrategy.Init(m_pPageReader,
                                                  ulStartOffset,
                                                  ulLastPageOffset,
                                                  uLastPageSize,
                                                  serialNum,
                                                  pInfo);
            }
        }
        else
        {
            // Chained case
            DPRINTF(D_OGG_FF, ("COFF::hFLPD : chained\n"));

            changeState(FindGroupEndPage);
            m_pCurrentStrategy = &m_findGroupEndStrategy;
            res = m_findGroupEndStrategy.Init(m_pPageReader,
                                              &m_streamInfoStrategy,
                                              ulLastPageOffset);
                                              
        }
    }

    return res;
}

HX_RESULT 
COggFileFormat::handleFindGroupEndPageDone()
{
    HX_RESULT res = HXR_UNEXPECTED;

    ULONG32 ulStartOffset;
    ULONG32 ulLastPageOffset;
    UINT32 uLastPageSize;
    int serialNum ;

    if ((HXR_OK == m_streamInfoStrategy.StartPageOffset(ulStartOffset)) &&
        (HXR_OK == m_findGroupEndStrategy.LastPageSerialNum(serialNum)) &&
        (HXR_OK == m_findGroupEndStrategy.LastPageOffset(ulLastPageOffset)) &&
        (HXR_OK == m_findGroupEndStrategy.LastPageSize(uLastPageSize)))
    {
        const COggCodecInfo* pInfo = NULL;
        res = m_streamInfoStrategy.GetCodecInfo(serialNum, pInfo);
        
        if (HXR_OK == res)
        {
            changeState(FindGroupEndTime);
            m_pCurrentStrategy = &m_groupEndTimeStrategy;
            res = m_groupEndTimeStrategy.Init(m_pPageReader,
                                              ulStartOffset,
                                              ulLastPageOffset,
                                              uLastPageSize,
                                              serialNum,
                                              pInfo);
        }
    }

    return res;
}

HX_RESULT 
COggFileFormat::handleFindGroupEndTimeDone()
{
    HX_RESULT res = HXR_UNEXPECTED;

    ULONG32 ulLastPageOffset;
    UINT32 uLastPageSize;

    if ((HXR_OK == m_findGroupEndStrategy.LastPageOffset(ulLastPageOffset))&&
        (HXR_OK == m_findGroupEndStrategy.LastPageSize(uLastPageSize)))
    {
        res = addGroupToFileInfo(ulLastPageOffset);

        if (HXR_OK == res)
        {
            changeState(GetNextStreamInfo);
            m_pCurrentStrategy = &m_streamInfoStrategy;
            res = m_streamInfoStrategy.Init(m_pPageReader);
            
            if (HXR_OK == res)
            {
                res = m_pPageReader->Seek(ulLastPageOffset + uLastPageSize);
            }
        }
    }

    return res;
}

HX_RESULT 
COggFileFormat::handleFindLastGroupEndTimeDone()
{
    HX_RESULT res = HXR_UNEXPECTED;

    ULONG32 ulLastPageOffset;
    if (HXR_OK == m_findEOFStrategy.LastPageOffset(ulLastPageOffset))
    {
        res = addGroupToFileInfo(ulLastPageOffset);

        
        if (HXR_OK == res)
        {
            changeState(SeekBackToLastCachedPage);
            m_pCurrentStrategy = NULL;
            res = m_pPageReader->Seek(m_ulLastCachedPageOffset);
        }
    }

    return res;
}

HX_RESULT 
COggFileFormat::handleGetNextStreamInfoDone()
{
HX_RESULT res = HXR_UNEXPECTED;

    UINT16 uStreamCount = m_streamInfoStrategy.StreamCount();
    ULONG32 ulStartOffset;
    UINT32 uStartSize;

    if ((HXR_OK == m_streamInfoStrategy.StartPageOffset(ulStartOffset)) &&