oggfformat.cpp

linux下的一款播放器

        (HXR_OK == m_streamInfoStrategy.StartPageSize(uStartSize)))
    {

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

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

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

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

    ULONG32 ulLastPageOffset;
    UINT32 uLastPageSize;
    int lastSerialNum ;

    if ((HXR_OK == m_findEOFStrategy.LastPageSerialNum(lastSerialNum)) &&
        (HXR_OK == m_findEOFStrategy.LastPageOffset(ulLastPageOffset)) &&
        (HXR_OK == m_findEOFStrategy.LastPageSize(uLastPageSize)))
    {
        if (m_streamInfoStrategy.HaveSerialNum(lastSerialNum))
        {
            // last group in the chain
            DPRINTF(D_OGG_FF, ("COFF::hGNSID : last group\n"));

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

            if (HXR_OK == res)
            {
                changeState(FindLastGroupEndTime);
                m_pCurrentStrategy = &m_groupEndTimeStrategy;
                res = m_groupEndTimeStrategy.Init(m_pPageReader,
                                                  ulStartOffset,
                                                  ulLastPageOffset,
                                                  uLastPageSize,
                                                  lastSerialNum,
                                                  pInfo);
            }
        }
        else
        {
            // There are more groups in the chain
            DPRINTF(D_OGG_FF, ("COFF::hGNSID : not the last group\n"));

            changeState(FindGroupEndPage);
            m_pCurrentStrategy = &m_findGroupEndStrategy;

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

    return res;
}

HX_RESULT 
COggFileFormat::handleGetNextLiveStreamInfoDone()
{
    HX_RESULT res = setupStreamHandlerFromStreamInfo();

    if (HXR_OK == res)
    {
        res = sendCachedPagesToStreamHandler();
    }

    m_pCurrentStrategy = NULL;

    if (HXR_OK == res)
    {
        res = dispatchPendingRequests();
        
        if (HXR_NO_DATA == res)
        {
            // We need more data
            res = m_pPageReader->ReadNextPage();
        }
        else if (HXR_OK == res)
        {
            changeState(Ready);
        }
    }

    return res;
}

HX_RESULT 
COggFileFormat::handleFindSeekPointOffsetDone()
{
    ULONG32 ulSeekPointOffset;
    ULONG32 ulStartPageOffset;
    const COggGroupInfo* pGroupInfo = NULL;

    HX_RESULT res = m_seekStrategy.GetSeekPointOffset(ulSeekPointOffset);

    if (HXR_OK == res)
    {
        res = m_seekStrategy.GetGroupInfo(pGroupInfo);
    }
    
    if (HXR_OK == res)
    {
        res = pGroupInfo->GetStartPageOffset(ulStartPageOffset);
    }

    if (HXR_OK == res)
    {
        if (ulStartPageOffset == ulSeekPointOffset)
        {
            // The seek point is at the start page so
            // we don't need to worry about getting the
            // headers
            m_pCurrentStrategy = NULL;
            changeState(GetPacketReadPending);
            res = m_pPageReader->Seek(ulSeekPointOffset);

            if (HXR_OK == res)
            {
                res = m_pResponse->SeekDone(HXR_OK);
            }
        }
        else
        {
            m_pCurrentStrategy = &m_collectHeaderStrategy;
            changeState(CollectStreamHeaders);
            res = m_collectHeaderStrategy.Init(m_pPageReader,
                                               pGroupInfo);
        }
    }

    return res;
}

HX_RESULT 
COggFileFormat::handleCollectHeadersDone()
{
    ULONG32 ulSeekPointOffset;

    HX_RESULT res = HXR_OK;

    while(HXR_OK == res)
    {
        ogg_page* pPage = NULL;

        res = m_collectHeaderStrategy.GetNextPage(pPage);

        if (HXR_OK == res)
        {
            COggStream* pStream = 
                m_streamHdlr.GetStream(ogg_page_serialno(pPage));

            if (pStream)
            {
                res = pStream->OnPage(pPage);
            }
            else
            {
                res = HXR_UNEXPECTED;
            }

            OggUtil::DestroyPage(pPage);
        }
    }

    if (HXR_NO_DATA == res)
    {
        // This is the expected case
        res = HXR_OK;
    }

    if (HXR_OK == res)
    {
        res = m_seekStrategy.GetSeekPointOffset(ulSeekPointOffset);
    }

    if (HXR_OK == res)
    {
        m_pCurrentStrategy = NULL;
        changeState(GetPacketReadPending);
        res = m_pPageReader->Seek(ulSeekPointOffset);
        
        if (HXR_OK == res)
        {
            res = m_pResponse->SeekDone(HXR_OK);
        }
    }

    return res;
}

HX_RESULT 
COggFileFormat::handleSeekBackToLastCachedPage()
{
    UINT16 uNumAudioStreams = 0;
    UINT16 uNumVideoStreams = 0;

    HX_RESULT res = getStreamTypeCountFromFileInfo(uNumAudioStreams,
                                                   uNumVideoStreams);
    
    if (HXR_OK == res)
    {
        res = m_streamHdlr.SetStreamTypeCounts(uNumAudioStreams,
                                               uNumVideoStreams);
    }

    if (HXR_OK == res)
    {
        res = setupStreamHandlerFromGroupInfo(0);
    }

    if (HXR_OK == res)
    {
        res = sendCachedPagesToStreamHandler();
    }
    
    if (HXR_OK == res)
    {
        res = createAndSendFileHeader();
    }

    return res;
}

HX_RESULT 
COggFileFormat::handlePacketReadPending(HX_RESULT status,
                                        ULONG32 ulFileOffset,
                                        UINT32 uPageSize,
                                        ogg_page* pPage)
{
    HX_RESULT res = HXR_UNEXPECTED;

    if (HXR_OK == status)
    {
        BOOL bChangedState = FALSE;
        COggStream* pStream = m_streamHdlr.GetStream(ogg_page_serialno(pPage));

        if (pStream)
        {
            res = pStream->OnPage(pPage);
        }
        else if (m_bIsLive)
        {
            // The page is not for the current group and we are dealing with
            // a live stream
            COggTimestamp timestamp;
            res = m_streamHdlr.GetStartTimestamp(m_liveNextGroupStartTime);
            
            if (HXR_OK == res)
            {
                res = m_streamHdlr.OnEndOfGroup();
            }

            if (HXR_OK == res)
            {
                changeState(GetNextLiveStreamInfo);
                m_pCurrentStrategy = &m_streamInfoStrategy;

                res = m_streamInfoStrategy.Init(m_pPageReader);
        
                if (HXR_OK == res)
                {
                    res = m_pCurrentStrategy->ReadNextPageDone(status, 
                                                               ulFileOffset,
                                                               uPageSize, 
                                                               pPage);
                }
                
                if (HXR_OK == res)
                {
                    bChangedState = TRUE;
                    res = cachePage(pPage);
                }
                
            }
        }
        else
        {
            // The page is not for the current group and we are not dealing 
            // with a live stream

            // check to see if this page is part of the next group in
            // the file
            res = handleFileGroupChange(pPage);
        }

        if ((HXR_OK == res) && !bChangedState)
        {
            res = dispatchPendingRequests();

            if (HXR_NO_DATA == res)
            {
                // We need more data
                res = m_pPageReader->ReadNextPage();
            }
            else if ((HXR_OK == res) &&
                     (GetNextLiveStreamInfo != m_State))
            {
                changeState(Ready);
            }
        }
    }
    else if (HXR_AT_END == status)
    {
        res = m_streamHdlr.OnEndOfFile();
    }

    return res;
}

HX_RESULT 
COggFileFormat::addGroupToFileInfo(ULONG32 ulLastPageOffset)
{
    HX_RESULT res = HXR_UNEXPECTED;
    ULONG32 ulStartOffset;
    UINT32 uStartSize;
    COggTimestamp duration;
    UINT16 uStreamCount = m_streamInfoStrategy.StreamCount();

    if ((HXR_OK == m_streamInfoStrategy.StartPageOffset(ulStartOffset)) &&
        (HXR_OK == m_streamInfoStrategy.StartPageSize(uStartSize)) && 
        (HXR_OK == m_groupEndTimeStrategy.GetDuration(duration)))
    {
        COggGroupInfo* pGroupInfo = new COggGroupInfo(ulStartOffset, 
                                                      uStartSize,
                                                      ulLastPageOffset,
                                                      duration);

        if (pGroupInfo)
        {
            res = HXR_OK;

            // Add all the codec info objects to the group info
            for (UINT16 i = 0; (HXR_OK == res) && (i < uStreamCount); i++)
            {
                int serialNum;
                const COggCodecInfo* pInfo = NULL;

                res = m_streamInfoStrategy.GetStreamSerialNum(i, serialNum);

                if (HXR_OK == res)
                {
                    res = m_streamInfoStrategy.GetCodecInfo(serialNum, pInfo);
                }

                if (HXR_OK == res)
                {
                    res = pGroupInfo->AddCodecInfo(serialNum, pInfo);
                }
            }

            if (HXR_OK == res)
            {
                res = m_fileInfo.AddGroupInfo(pGroupInfo);

                if (HXR_OK != res)
                {
                    delete pGroupInfo;
                }
            }
        }
        else
        {
            res = HXR_OUTOFMEMORY;
        }
    }

    DPRINTF(D_OGG_FF, ("COFF::aGTFI : done %08x\n", res));

    return res;
}

HX_RESULT 
COggFileFormat::getStreamTypeCountFromFileInfo(UINT16& uNumAudioStreams,
                                               UINT16& uNumVideoStreams) const
{
    HX_RESULT res = HXR_OK;

    uNumAudioStreams = 0;
    uNumVideoStreams = 0;

    // Compute stream type counts
    for (UINT32 i = 0; ((HXR_OK == res) && 
                        (i < m_fileInfo.GroupCount())); i++)
    {
        const COggGroupInfo* pGroupInfo = NULL;
        
        res = m_fileInfo.GetGroupInfo(i, pGroupInfo);
        
        if (HXR_OK == res)
        {
            UINT32 uGroupAudioCount = 0;
            UINT32 uGroupVideoCount = 0;

            for (UINT16 j = 0; ((HXR_OK == res) &&
                                (j < pGroupInfo->StreamCount())); j++)
            {
                int serialNum;
                res = pGroupInfo->GetStreamSerialNum(j, serialNum);

                if (HXR_OK == res)
                {
                    const COggCodecInfo* pCodecInfo = NULL;

                    res = pGroupInfo->GetCodecInfo(serialNum, pCodecInfo);