sdl_video_render.cpp

这是在PCA下的基于IPP库示例代码例子,在网上下了IPP的库之后,设置相关参数就可以编译该代码.

/*
//
//                  INTEL CORPORATION PROPRIETARY INFORMATION
//     This software is supplied under the terms of a license agreement or
//     nondisclosure agreement with Intel Corporation and may not be copied
//     or disclosed except in accordance with the terms of that agreement.
//       Copyright(c) 2003-2005 Intel Corporation. All Rights Reserved.
//
*/

#include "sdl_video_render.h"

#if defined(UMC_ENABLE_SDL_VIDEO_RENDER)

namespace UMC
{

SDLVideoRender::SDLVideoRender()
    :m_Surface(NULL)
{
    if (!(SDL_WasInit(SDL_INIT_VIDEO) & SDL_INIT_VIDEO))
        SDL_InitSubSystem(SDL_INIT_VIDEO);
}

SDLVideoRender::~SDLVideoRender()
{
    Close();

} // SDLVideoRender::~SDLVideoRender()

Status SDLVideoRender::SetFullScreen(ModuleContext& /*rContext*/, bool bFullScreen)
{
    Status umcRes = UMC_OK;
    Uint32 uiFlags = SDL_HWSURFACE|SDL_RESIZABLE|SDL_ANYFORMAT;

    if (bFullScreen)
        uiFlags |= SDL_FULLSCREEN;

    m_SuncMut.Lock();

    m_Surface = SDL_SetVideoMode(m_dst_rect.right - m_dst_rect.left,
                                 m_dst_rect.bottom - m_dst_rect.top,
                                 0, uiFlags);

    if (!m_Surface)
        umcRes = UMC_OPERATION_FAILED;

    if (UMC_OK == umcRes)
    {
        for (int i = 0; i < m_iBuffersNum; i++ )
        {
            SDL_Overlay* overlay = (SDL_Overlay *)m_Buffers[i].surface;
            if (overlay)
                SDL_FreeYUVOverlay(overlay);
            m_Buffers[i].surface = NULL;
        }

        for (m_iBuffersNum = 0;
             m_iBuffersNum < MAX_FRAME_BUFFERS;
             m_iBuffersNum++)
        {
            m_Buffers[m_iBuffersNum].surface = SDL_CreateYUVOverlay(m_SrcInfo.width,
                                                                    m_SrcInfo.height,
                                                                    m_ofmt,
                                                                    m_Surface);
            if (NULL == m_Buffers[m_iBuffersNum].surface)
                break;
        }
        if (m_iBuffersNum != MAX_FRAME_BUFFERS)
            umcRes = UMC_FAILED_TO_ALLOCATE_BUFFER;
    }

    m_SuncMut.Unlock();

    return umcRes;
} // Status SDLVideoRender::SetFullScreen(ModuleContext &, bool bFullScreen)


Status SDLVideoRender::Init(MediaReceiverParams* pInit)
{
    Status umcRes = UMC_OK;

    VideoRenderParams *pParams = DynamicCast<VideoRenderParams>(pInit);

    if (NULL == pParams)
        umcRes = UMC_NULL_PTR;

    if (UMC_OK == umcRes)
    {
        switch (pParams->color_format)
        {
        case UYVY:
            m_ofmt = SDL_UYVY_OVERLAY;
            break;

        case YUY2:
            m_ofmt = SDL_YUY2_OVERLAY;
            break;

        case YV12:
            m_ofmt = SDL_YV12_OVERLAY;
            break;

        default:
            umcRes = UMC_FAILED_TO_INITIALIZE;
        }
    }

    if (UMC_OK == umcRes)
    {
        m_iBuffersNum = MAX_FRAME_BUFFERS;
        umcRes = BaseVideoRender::Init(pInit);
    }

    return umcRes;

} // Status SDLVideoRender::Init(MediaReceiverParams* pInit)

// Resize the display rectangular
Status SDLVideoRender::ResizeDisplay(UMC::RECT &disp, UMC::RECT &range)
{
    Status umcRes = BaseVideoRender::ResizeDisplay(disp, range);

    if (UMC_OK == umcRes)
    {
        ModuleContext Context;
        umcRes = SetFullScreen(Context, false);
    }

    return umcRes;
} // Status SDLVideoRender::ResizeDisplay(UMC::RECT &disp, UMC::RECT &range)

int SDLVideoRender::LockSurface(unsigned char** vidmem)
{
    if (m_iWriteIndex < 0)
        return 0;

    SDL_Overlay *overlay = (SDL_Overlay *)m_Buffers[m_iWriteIndex].surface;
    if (SDL_LockYUVOverlay(overlay))
        return 0;

    if (NULL != vidmem)
        *vidmem = overlay->pixels[0];

    vm_debug_trace(0, __VM_STRING("SDLVideoRender::LockSurface: buffer %d\n"), m_iWriteIndex);

    return overlay->pitches[0];

} // int SDLVideoRender::LockSurface(unsigned char** vidmem)

int SDLVideoRender::UnlockSurface(unsigned char** vidmem)
{
    if (m_iWriteIndex < 0)
        return 0;
    SDL_Overlay *overlay = (SDL_Overlay *)m_Buffers[m_iWriteIndex].surface;
    SDL_UnlockYUVOverlay(overlay);
    vm_debug_trace(0, __VM_STRING("SDLVideoRender::UnlockSurface: buffer %d\n"), m_iWriteIndex);

    return 1;

} // int SDLVideoRender::UnlockSurface(unsigned char** vidmem)

double SDLVideoRender::GetRenderFrame()
{
    // Process SDL window events
    SDL_Event event;
    ModuleContext Context;

    while (SDL_PollEvent(&event))
    {
        if (event.type != SDL_VIDEORESIZE) continue;
        m_dst_rect.right = m_dst_rect.left + event.resize.w;
        m_dst_rect.bottom = m_dst_rect.top + event.resize.h;
        SetFullScreen(Context, false);
    }

    return BaseVideoRender::GetRenderFrame();

} // double SDLVideoRender::GetRenderFrame()

Status SDLVideoRender::RenderFrame()
{
    Status umcRes = UMC_OK;

    if (m_iReadIndex < 0)
        umcRes = UMC_NOT_INITIALIZED;

    if (UMC_OK == umcRes)
    {
        SDL_Rect view_port;
        view_port.x = 0;
        view_port.y = 0;
        view_port.w = m_dst_rect.right - m_dst_rect.left;
        view_port.h = m_dst_rect.bottom - m_dst_rect.top;

        m_SuncMut.Lock();
        SDL_Overlay *overlay = reinterpret_cast<SDL_Overlay*>(m_Buffers[m_iReadIndex].surface);
        if ( m_bShow )
        {
            int iRes = SDL_DisplayYUVOverlay(overlay, &view_port);
            if (0 != iRes)
                umcRes = UMC_OPERATION_FAILED;
            vm_debug_trace(0, __VM_STRING("SDLVideoRender::RenderFrame: buffer %d\n"), m_iReadIndex);
        }
        m_hFreeBufSema.Signal();
        m_SuncMut.Unlock();
    }

    return umcRes;
} // Status SDLVideoRender::RenderFrame()


Status SDLVideoRender::ShowLastFrame()
{
    Status umcRes = UMC_OK;

    if (m_iReadIndex < 0)
        umcRes = UMC_NOT_INITIALIZED;

    if (UMC_OK == umcRes)
    {
        SDL_Rect view_port;
        view_port.x = 0;
        view_port.y = 0;
        view_port.w = m_dst_rect.right - m_dst_rect.left;
        view_port.h = m_dst_rect.bottom - m_dst_rect.top;

        m_SuncMut.Lock();
        SDL_Overlay *overlay = reinterpret_cast<SDL_Overlay*>(m_Buffers[m_iReadIndex].surface);
        if ( m_bShow )
        {
            int iRes = SDL_DisplayYUVOverlay(overlay, &view_port);
            if (0 != iRes)
                umcRes = UMC_OPERATION_FAILED;
            vm_debug_trace(0, __VM_STRING("SDLVideoRender::RenderFrame: buffer %d\n"), m_iReadIndex);
        }
        m_SuncMut.Unlock();
    }

    return umcRes;

} // Status SDLVideoRender::ShowLastFrame()

Status SDLVideoRender::Close()
{
    for (int i = 0; i < m_iBuffersNum; i++ )
    {
        SDL_Overlay* overlay = (SDL_Overlay *)m_Buffers[i].surface;
        if (overlay)
            SDL_FreeYUVOverlay(overlay);
        m_Buffers[i].surface = NULL;
    }

    if (m_Surface)
        m_Surface = NULL;

    SDL_Quit();

    return BaseVideoRender::Close();

} // Status SDLVideoRender::Close()

} // namespace UMC

#endif // defined(UMC_ENABLE_SDL_VIDEO_RENDER)