minisurf.cpp

linux下的一款播放器

#if defined (HELIX_FEATURE_CC_YUY2out)
           if (nDstCID == CID_YUY2)
               m_fpColorConverter = XINGtoYUY2;
#endif //HELIX_FEATURE_CC_YUY2out

#if defined (HELIX_FEATURE_CC_RGB32out)
           if (nDstCID == CID_RGB32)
               m_fpColorConverter = XINGtoRGB32;
#endif //HELIX_FEATURE_CC_YUY2out
        
#if defined (HELIX_FEATURE_CC_RGB565out)
           if (nDstCID == CID_RGB565)
               m_fpColorConverter = XINGtoRGB565;
#endif //HELIX_FEATURE_CC_RGB565out

           m_nSrcPitch = 768;
           break;
    }

    HX_ASSERT(m_fpColorConverter);
    
#if defined(HELIX_CONFIG_NOSTATICS)
    SetSrcI420Colors (0, 0, 0, 0, GetColorData());
#else    
    SetSrcI420Colors (0, 0, 0, 0); 
    SetDestI420Colors (0, 0, 0, 0);
    SetI420ChromaResamplingMode (0);
#endif    
    
    return m_fpColorConverter ? HXR_OK : HXR_FAIL;
}



/************************************************************************
 *  Method:
 *    IHXVideoSurface::Blt
 */
STDMETHODIMP CMiniBaseSurface::Blt(UCHAR*              pSrcBuffer,
                                   HXBitmapInfoHeader* pBitmapInfo,
                                   REF(HXxRect)        rDestRect,
                                   REF(HXxRect)        rSrcRect)
{
    
    HX_RESULT hr = BeginOptimizedBlt(pBitmapInfo);
    if (FAILED(hr))
    {
        return hr;
    }
        
    int nDstWidth   = rDestRect.right - rDestRect.left;
    int nDstHeight  = rDestRect.bottom - rDestRect.top;

    // ensure destination buffers are allocated, ensuring that we properly handle image stretching.
    if(ScaleDuringRender(GetDstCID()))
    {
        hr = AllocateDestBuffers(pBitmapInfo->biWidth, pBitmapInfo->biHeight);
    }
    else
    {
        // we stretch during the transfer from source to dest 
        // buffer; dest buffer must be same size as dest rect.
        hr = AllocateDestBuffers(nDstWidth, nDstHeight);
    }
    if(FAILED(hr))
    {
        return hr;
    }


    UCHAR*  pDestBuffer = NULL;
    LONG32  nDestPitch  = 0;
    HXxSize dstSize     = m_dstBufSize;

    hr = _LockDestBuffer(&pDestBuffer,
                         &nDestPitch,
                         m_nSrcCID,
                         dstSize);

    if (FAILED(hr))
        return hr;

    HXxRect rcDst = rDestRect;
    HXxRect rcSrc = rSrcRect;

    // If the dest buffer dimensions do not match the dest rect,
    // map the dest rect to the dest buffer for video transfer.
    if ((m_dstBufSize.cx != nDstWidth) | 
        (m_dstBufSize.cy != nDstHeight))
    {
 
        rcDst.left = (rcDst.left*m_dstBufSize.cx) / nDstWidth;
        rcDst.right = (rcDst.right*m_dstBufSize.cx) / nDstWidth;
        rcDst.top = (rcDst.top*m_dstBufSize.cy) / nDstHeight;
        rcDst.bottom = (rcDst.bottom*m_dstBufSize.cy) / nDstHeight;
    }


    hr = _TransferToDestBuffer(pSrcBuffer,
                               pBitmapInfo,
                               &rcSrc,
                               &rcDst,
                               pDestBuffer,
                               nDestPitch);
    
    _UnlockDestBuffer(pDestBuffer);

    if (SUCCEEDED(hr))
        hr = _RenderDestBuffer(&rcDst, &rDestRect);
    
    //Give the device a chance to keep the screen alive.
    _KeepScreenAlive();
    
    return hr;
}

/************************************************************************
 *  Method:
 *    IHXVideoSurface::OptimizedBlt
 */
STDMETHODIMP CMiniBaseSurface::OptimizedBlt(UCHAR* pSrcBuffer,
                                            REF(HXxRect) rDestRect,
                                            REF(HXxRect) rSrcRect)
{
    return Blt(pSrcBuffer, 
               m_pOptimizedFormat,
               rDestRect,
               rSrcRect); 
}

/************************************************************************
 *  Method:
 *    IHXVideoSurface::EndOptimizedBlt
 */
STDMETHODIMP CMiniBaseSurface::EndOptimizedBlt(void)
{
    HX_RESULT hr =  DestroyDestBuffers(m_nDstBuffers);
    HX_DELETE(m_pOptimizedFormat);
    m_nSrcCID = CID_UNKNOWN;

    return hr;
}

/************************************************************************
 *  Method:
 *    IHXVideoSurface::GetOptimizedFormat
 */
STDMETHODIMP CMiniBaseSurface::GetOptimizedFormat(REF(HX_COMPRESSION_TYPE) ulType)
{
    ulType = 0;
    return HXR_OK;
}

/************************************************************************
 *  Method:
 *    IHXVideoSurface::GetPreferredFormat
 */
STDMETHODIMP CMiniBaseSurface::GetPreferredFormat(REF(HX_COMPRESSION_TYPE) ulType)
{                             
    ulType = 0;
    return HXR_OK;
}                                                        
                                      

HX_RESULT 
CMiniBaseSurface::_TransferToDestBuffer(UCHAR* pSrcBuffer,
                                        HXBitmapInfoHeader* pBitmapInfo,
                                        HXxRect* prSrcRect,
                                        HXxRect* prDstRect,
                                        UCHAR* pDstBuffer,
                                        LONG32 nDstPitch)
{
    if (!m_fpColorConverter)
        return HXR_FAIL;

    int nRet = m_fpColorConverter( pDstBuffer,
                                   m_dstBufSize.cx,
                                   m_dstBufSize.cy,
                                   nDstPitch,
                                   prDstRect->left, prDstRect->top,
                                   prDstRect->right-prDstRect->left, 
                                   prDstRect->bottom-prDstRect->top,
                                   pSrcBuffer,
                                   pBitmapInfo->biWidth,
                                   pBitmapInfo->biHeight,
                                   m_nSrcPitch,
                                   prSrcRect->left, prSrcRect->top,
                                   prSrcRect->right-prSrcRect->left, 
                                   prSrcRect->bottom-prSrcRect->top
#if defined(HELIX_CONFIG_NOSTATICS)    
                                   ,GetColorData()
#endif    
                                   );
    if (nRet < 0)
        return HXR_FAIL;
    else
        return HXR_OK;
}


BOOL CMiniBaseSurface::ScaleDuringRender(int nCID)
{
    // Our YUVtoYUV color converters do not scale so scaling
    // must be done during rendering.
    //
    // Our XXXtoRGB do scaling
    return (nCID == CID_DVPF) | 
           (nCID >= CID_I420 && nCID <= CID_UYVY);
}

HX_RESULT CMiniBaseSurface::AllocateDestBuffers(int nWidth,
                                                int nHeight,
                                                int nCount)
{
    if (nWidth == m_dstBufSize.cx &&
        nHeight == m_dstBufSize.cy &&
        nCount == m_nDstBuffers)
    {
        return HXR_OK;
    }
    else
    {
        DestroyDestBuffers(m_nDstBuffers);
    }

    HX_RESULT hr = _CreateDestBuffer(m_nSrcCID, nWidth, nHeight, nCount);

    if (HXR_OK == hr)
    {
        m_dstBufSize.cx = nWidth;
        m_dstBufSize.cy = nHeight;

        m_nDstBuffers = nCount;
    }

    return hr;
}

HX_RESULT CMiniBaseSurface::DestroyDestBuffers(int nCount)
{
    HX_RESULT hr = HXR_OK;

    if (m_dstBufSize.cx || m_dstBufSize.cy)
    {
        hr = _DestroyDestBuffer(m_nSrcCID, nCount); 

        memset(&m_dstBufSize, 0, sizeof(m_dstBufSize));
        m_nDstBuffers = 0;
    }

    return hr;
}