---

RenderingEngine.cpp

Go to the documentation of this file.

#include "RenderingEngine.hpp"

RenderingEngine::RenderingEngine(int x, int y,
                                 long yBO, long uBO, long vBO,
                                 long yS, long uvS, bool two, Layout l)
{

    //  cout << "Initializing new RenderingEngine!!!" << nl;


    width = x;
    height = y;
    layout = l;

    ySize = yS;
    uvSize = uvS;
    bufOffsetY = yBO;
    bufOffsetU = uBO;
    bufOffsetV = vBO;


    if (two) {
        if (layout == UP_AND_DOWN)
            height *= 2;
        else
            width *= 2;

        ySize *= 2;
        uvSize *= 2;
        bufOffsetY *= 2;
        bufOffsetU *= 2;
        bufOffsetV *= 2;
    }
    // init video mode
    char buf[32];


    if (SDL_Init(SDL_INIT_VIDEO) < 0 || !SDL_VideoDriverName(buf, 1)) {
#if DEBUG >= 1
        cerr << "Could not init SDL video: " << SDL_GetError() << nl;
#endif
        exit(-1);               // use exception here l8er
    }

    video_info = SDL_GetVideoInfo();

    switch (video_info->vfmt->BitsPerPixel) {
    case 16:
    case 32:
        video_bpp = video_info->vfmt->BitsPerPixel;
        break;
    default:
        video_bpp = 16;
        break;
    }


    m_screen = SDL_SetVideoMode(width,
                                height, 32, SDL_SWSURFACE | SDL_ASYNCBLIT);



    if (m_screen == NULL) {
        cerr << "Couldn't initialize window with dimension " << width <<
            "x" << height << "!\n";
        exit(1);                // use exception here l8er
    }



    SDL_WM_SetCaption("mk2l rulez ;-)", "");

    m_dstrect.x = 0;
    m_dstrect.y = 0;
    m_dstrect.w = m_screen->w;
    m_dstrect.h = m_screen->h;


    m_image =
        SDL_CreateYUVOverlay(width, height, SDL_YV12_OVERLAY, m_screen);



    //  cout << "Init OK!" << nl;

}


void
 RenderingEngine::show(char *buffer, int delay)
{

    if (SDL_MUSTLOCK(m_screen)) {
        if (SDL_LockSurface(m_screen) < 0) {
            return;
        }
    }

    memcpy(m_image->pixels[0], buffer + bufOffsetY, ySize);
    memcpy(m_image->pixels[1], buffer + bufOffsetV, uvSize);
    memcpy(m_image->pixels[2], buffer + bufOffsetU, uvSize);

    SDL_DisplayYUVOverlay(m_image, &m_dstrect);
    SDL_UnlockYUVOverlay(m_image);

    SDL_Delay(delay);

    if (SDL_MUSTLOCK(m_screen)) {
        SDL_UnlockSurface(m_screen);
    }
    //  SDL_UpdateRect(m_screen, x, y, 1, 1);

}


void RenderingEngine::show(char *buffer1, char *buffer2, int delay)
{

    if (SDL_MUSTLOCK(m_screen)) {
        if (SDL_LockSurface(m_screen) < 0) {
            return;
        }
    }

    if (layout == UP_AND_DOWN) {
        // interleave buffers and send the stuff to the grafix card
        memcpy(m_image->pixels[0], buffer2, ySize / 2);
        memcpy(m_image->pixels[0] + ySize / 2, buffer1, ySize / 2);

        memcpy(m_image->pixels[1], buffer2 + bufOffsetV / 2, uvSize / 2);
        memcpy(m_image->pixels[1] + uvSize / 2, buffer1 + bufOffsetV / 2,
               uvSize / 2);

        memcpy(m_image->pixels[2], buffer2 + bufOffsetU / 2, uvSize / 2);
        memcpy(m_image->pixels[2] + uvSize / 2, buffer1 + bufOffsetU / 2,
               uvSize / 2);
    }

    else {
        long i = 0;
        long j = 0;
        while (i < ySize / 2) {
            memcpy(m_image->pixels[0] + j, buffer2 + i, width / 2);
            memcpy(m_image->pixels[0] + width / 2 + j, buffer1 + i,
                   width / 2);
            i += width / 2;
            j += width;
        }

        i = 0;
        j = 0;
        while (i < uvSize / 2) {
            memcpy(m_image->pixels[1] + j, buffer2 + bufOffsetV / 2 + i,
                   width / 4);
            memcpy(m_image->pixels[1] + width / 4 + j,
                   buffer1 + bufOffsetV / 2 + i, width / 4);

            memcpy(m_image->pixels[2] + j, buffer2 + bufOffsetU / 2 + i,
                   width / 4);
            memcpy(m_image->pixels[2] + width / 4 + j,
                   buffer1 + bufOffsetU / 2 + i, width / 4);

            i += width / 4;
            j += width / 2;
        }
    }

    SDL_DisplayYUVOverlay(m_image, &m_dstrect);
    SDL_UnlockYUVOverlay(m_image);

    SDL_Delay(delay);

    if (SDL_MUSTLOCK(m_screen)) {
        SDL_UnlockSurface(m_screen);
    }
}

---