rvxvdec.cpp

来自「symbian 下的helix player源代码」· C++ 代码 · 共 610 行 · 第 1/2 页

	    DEBUG_OUTF("C:\\RVX.TXT",
		(s, "     Segment%2d: Valid=%s Offset=%d\n",
		    i,
		    pCodecData->Segments[i].bIsValid ? "T" : "F",
		    pCodecData->Segments[i].ulSegmentOffset));
	    HX_ASSERT(pCodecData->Segments[i].ulSegmentOffset < pCodecData->dataLength);
	    HX_ASSERT(pCodecData->Segments[i].ulSegmentOffset < 100000);
	}
    }
#endif	// _TRACK_CODEC_INPUT

    retVal = CheckCallback(m_pStream);
    if (SUCCEEDED(retVal))
    {
        retVal = m_pCodecLib->PNStream_Input(m_pStream, NULL,
                                    (HXCODEC_DATA*) pFrameToDecode->m_pData);
        if(pFrameToDecode->m_pData)
        {
            ((HXCODEC_DATA*) pFrameToDecode->m_pData)->data = NULL;
        }
    }
#endif	// _DRY_RUN

    return retVal;
}


/****************************************************************************
 *  Method:
 *    CRVDecoder::DecodeDone
 */
HX_RESULT CRVXVDecoder::DecodeDone(HXCODEC_DATA* pData)
{
    if (pData)
    {
	m_ulLastTimeStamp = pData->timestamp;
    }

    return m_pVideoFormat->DecodeDone(pData);
}


/****************************************************************************
 *  Method:
 *    CRVDecoder::GetImageInfo
 */
HX_RESULT CRVXVDecoder::GetImageInfo(HX_MOF* &pImageInfo)
{
    ULONG32 ulSize;
    ULONG32* pMofBuf = NULL;
    HX_RESULT retVal = HXR_OK;

    HX_VECTOR_DELETE(m_pImageInfoBuffer);

    retVal = m_pCodecLib->PNStream_GetStreamHeaderSize(m_pStream,
						       &ulSize);

    if (retVal == HXR_OK)
    {
	HX_ASSERT((ulSize == sizeof(HX_FORMAT_IMAGE)) ||
		  (ulSize == sizeof(HX_FORMAT_IMAGE2)));

	pMofBuf = new ULONG32[ulSize / 4 + 1];

	retVal = HXR_FAIL;
	if (pMofBuf && (ulSize >= sizeof(HX_MOF)))
	{
	    retVal = HXR_OK;
	}
    }

    if (retVal == HXR_OK)
    {
	retVal = m_pCodecLib->PNStream_GetStreamHeader(m_pStream,
						       (HX_MOF *) pMofBuf);
    }

    if (retVal == HXR_OK)
    {
	m_pImageInfoBuffer = pMofBuf;
	pMofBuf = NULL;
	pImageInfo = (HX_MOF*) m_pImageInfoBuffer;
    }

    HX_VECTOR_DELETE(pMofBuf);

    return retVal;
}


/****************************************************************************
 *  Method:
 *    CRVDecoder::OnNewImage
 */
HX_RESULT CRVXVDecoder::OnNewImage(HXSTREAM streamRef,
				   HXSTREAM fromStreamRef,
				   HXCODEC_DATA* pData)
{
    CRVXVDecoder* pDecoder = (CRVXVDecoder*) streamRef;

    return pDecoder->DecodeDone(pData);
}


/****************************************************************************
 *  Method:
 *    CRVXVDecoder::ResetSequence()
 */
void CRVXVDecoder::ResetSequence(ULONG32 ulNewSequenceStartTS)
{
    m_ulSequenceStartTS = ulNewSequenceStartTS;
    m_bNewSequence = TRUE;
}

CRADynamicCodecLibrary* CRVXVDecoder::CreateCodecLibrary()
{
    return new CRADynamicCodecLibrary(m_pContext);
}

/****************************************************************************
 *  Private Methods
 */
/****************************************************************************
 *  Method:
 *    CRVXVDecoder::OpenCodec()
 */
HX_RESULT CRVXVDecoder::OpenCodec(const HX_MOF* pMofIn)
{
    HX_MOFTAG mofTag = 0;
    HX_RESULT retVal = HXR_OK;

    HX_ASSERT(pMofIn);

    mofTag = pMofIn->submoftag;
    m_moftagIn = mofTag;

    HX_DELETE(m_pCodecLib);

    // Create Codec Library
    m_pCodecLib = CreateCodecLibrary();

    retVal = HXR_OUTOFMEMORY;
    if (m_pCodecLib != NULL)
    {
	retVal = HXR_OK;
    }

    // Load Codec into library
    if (SUCCEEDED(retVal))
    {
	retVal = m_pCodecLib->LoadCodecLib(mofTag);
    }

    // Open the codec
    if (SUCCEEDED(retVal))
    {
	retVal = m_pCodecLib->PNCodec_Open(mofTag, &m_pCodec);

	if (FAILED(retVal))
	{
	    retVal = HXR_REQUEST_UPGRADE;
	}
    }

    return retVal;
}


/****************************************************************************
 *  Method:
 *    CRVXVDecoder::OpenStream
 */
HX_RESULT CRVXVDecoder::OpenStream(const HX_MOF* pMofIn)
{
    ULONG32 ulMofInDataSize = 0;
    ULONG32* pMofInData = NULL;
    HX_FORMAT_IMAGE2 mofOut;
    HXCODEC_INIT codecInit;
    HX_RESULT retVal = HXR_OK;

    HX_ASSERT(pMofIn);

    // Open Stream in some format: try most preferred first
    if (SUCCEEDED(retVal))
    {
	mofOut.cbLength = sizeof(HX_FORMAT_IMAGE2);
	mofOut.moftag = HX_MEDIA_IMAGE2;
	mofOut.submoftag = HX_YUV420_ID;
	m_moftagOut = HX_YUV420_ID;
    }

    if (SUCCEEDED(retVal))
    {
	codecInit.pInMof = (HX_MOF*) pMofIn;
	codecInit.pOutMof = (HX_MOF*) &mofOut;
	codecInit.memoryRef = (HXMEMORY) m_pInputAllocator;
	codecInit.pContext = m_pContext;
    }

    if (retVal == HXR_OK)
    {
	retVal = m_pCodecLib->PNCodec_StreamOpen(m_pCodec,
						 &m_pStream,
						 &codecInit);

	// TODO: If this fails, try other formats...
    }

    if (retVal == HXR_OK)
    {
	retVal = m_pCodecLib->PNStream_SetDataCallback(
		    m_pStream,
		    this,
		    (HXMEMORY) m_pOutputAllocator,
		    OnNewImage);
    }

    if (retVal == HXR_OK)
    {
	SetCodecQuality();
    }

    if (retVal == HXR_OK)
    {
	BOOL bAllowDifferentOutputSizes = TRUE;

	//  tell codec we can handle different output sizes
	m_pCodecLib->PNStream_SetProperty(m_pStream,
					  SP_ALLOW_DIFFERENT_OUPUT_SIZES,
					  &bAllowDifferentOutputSizes);
    }

    // TODO: Setup image format based on codec output format

    return retVal;
}


/****************************************************************************
 *  Method:
 *    CRVXVDecoder::GetQualityPreference
 */
HX_RESULT CRVXVDecoder::GetQualityPreference(UINT16 &usQuality)
{
    HX_RESULT pnr = HXR_OK;

#if defined(HELIX_FEATURE_PREFERENCES)
    IHXBuffer* pBuffer = NULL;
    IHXPreferences* pPreferences = 0;

    if (!m_pContext ||
	(m_pContext->QueryInterface(IID_IHXPreferences, (void**) &pPreferences) !=
	 HXR_OK))
    {
	pnr = HXR_INVALID_PARAMETER;
    }
    else
    {
	ReadPrefINT16(pPreferences, "Quality", usQuality);
    }

    HX_RELEASE(pPreferences);
#endif

    return pnr;
}


/****************************************************************************
 *  Method:
 *    CRVXVDecoder::GetQualityPreference
 */
void CRVXVDecoder::SetCodecQuality(void)
{
    BOOL bOn, bOff;
    UINT16 usQualityPreference = 4;

    GetQualityPreference(usQualityPreference);

    // Turn on or off post filter based on flags in source URL
    // if the URL turns off post filter or the TLC quality
    // preference is < 4 we turn off the post filter
    bOn = (usQualityPreference >= 4);

    m_pCodecLib->PNStream_SetProperty (m_pStream, SP_POSTFILTER, &bOn);

    // Turn on or off FRU based on flags in source URL
    bOn = (usQualityPreference >= 4);

    m_pCodecLib->PNStream_SetProperty (m_pStream, SP_TEMPORALINTERP, &bOn);

    // Turn on or off full decoding of B frames (reverse switch)
    bOff = (usQualityPreference < 2);
    m_pCodecLib->PNStream_SetProperty (m_pStream, SP_NOFULLDECODE, &bOff);

    // Turn on or off deblocking of B frames (reverse switch)
    bOff = (usQualityPreference < 3);
    m_pCodecLib->PNStream_SetProperty (m_pStream, SP_NODEBLOCKBFRAMES, &bOff);

    // Turn on or off decode of B-frames based on flags in source URL
    bOn = (usQualityPreference >= 1);

    m_pCodecLib->PNStream_SetProperty (m_pStream, SP_DECODE_B_FRAMES, &bOn);
}