path: root/packages/mplayer/files/vo_pxa.c

/*
 * Video driver for PXA 27x Overlay 2, in conjunction with kernel driver
 * by Tim Chick <tim (DOT) chick (AT) csr (DOT) com>
 * (C) 2007
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>

#include "config.h"
#include "video_out.h"
#include "video_out_internal.h"
#include "sub.h"
#include "aspect.h"
#include "mp_msg.h"
#include "subopt-helper.h"

#include "vo_pxa.h"

static vo_info_t info = {
	"PXA 27x Framebuffer",
	"pxa",
	"Tim Chick <tim (DOT) chick (AT) csr (DOT) com>",
	"For Sharp Zaurus SL-C1000 etc"
};

LIBVO_EXTERN(pxa);

static pxa_priv_t st_pxa_priv;

/*****************************************************************************
 * preinit
 *
 * Preinitializes driver
 *   arg - currently it's vo_subdevice
 *   returns: zero on successful initialization, non-zero on error.
 *
 ****************************************************************************/
static int preinit(const char *vo_subdevice)
{
    pxa_priv_t *priv = &st_pxa_priv;
    int rc;
    
    mp_msg(MSGT_VO, MSGL_V, "vo_pxa: preinit() was called\n");

    /* fill pxa_priv_t information */
    memset(priv, 0, sizeof(*priv));
    priv->fd = -1;
    
    /* We need to open the base framebuffer device, to change and restore modes */
    priv->base_fd = open( "/dev/fb0", O_RDWR );
    
    if( priv->base_fd < 0 )
    {
        mp_msg( MSGT_VO, MSGL_ERR, "vo_pxa: Could not open base framebuffer device\n");
        return -1;
    }
    
    /* Get the base fb var data, so we can restore if we change video modes */
    rc = ioctl( priv->base_fd, FBIOGET_VSCREENINFO, &(priv->base_orig_fb_var) );
    
    if( rc == -1 )
    {
        mp_msg( MSGT_VO, MSGL_ERR, "vo_pxa: FBIOGET_VSCREENINFO preinit base_fd failed %d\n",
                errno );
        
        /* If this failed, close down the FD so we don't try to set this again */
        close( priv->base_fd );
        priv->base_fd = -1;
        
        return -1;
    }
    
    return 0;
}


/*****************************************************************************
 * config
 *
 * Config the display driver.
 * params:
 *   src_width,srcheight: image source size
 *   dst_width,dst_height: size of the requested window size, just a hint
 *   fullscreen: flag, 0=windowd 1=fullscreen, just a hint
 *   title: window title, if available
 *   format: fourcc of pixel format
 * returns : zero on successful initialization, non-zero on error.
 *
 ****************************************************************************/
static int config(uint32_t src_width, uint32_t src_height,
                  uint32_t dst_width, uint32_t dst_height, uint32_t flags,
                  char *title, uint32_t format)
{
    pxa_priv_t *priv = &st_pxa_priv;
    int rc;
    int i;
    
    mp_msg(MSGT_VO, MSGL_V, "vo_pxa: config() src_width:%d, src_height:%d, dst_width:%d, dst_height:%d\n",
	   src_width, src_height, dst_width, dst_height);

    /* Check format */
    if( !vo_pxa_query_format(format) )
    {
        mp_msg( MSGT_VO, MSGL_ERR, "vo_pxa: unsupported fourcc for this driver: %x (%s)\n",
                format, vo_format_name(format) );
        goto err_out;
    }
    priv->format = format;
    
    /* Change resolution? */
    priv->vm = flags & VOFLAG_MODESWITCHING;
    if( priv->vm )
    {
        priv->my_fb_var = priv->base_orig_fb_var;
        
        /* Hard coded values suck, never mind */
        priv->my_fb_var.xres = 240;
        priv->my_fb_var.yres = 320;
        priv->my_fb_var.pixclock = 134617;
        priv->my_fb_var.left_margin = 20;
        priv->my_fb_var.right_margin = 46;
        priv->my_fb_var.upper_margin = 1;
        priv->my_fb_var.lower_margin = 0;
        priv->my_fb_var.hsync_len = 20;
        priv->my_fb_var.vsync_len = 2;
    
        rc = ioctl( priv->base_fd, FBIOPUT_VSCREENINFO, &(priv->my_fb_var) );
        
        if( rc == -1 )
        {
            mp_msg( MSGT_VO, MSGL_ERR, "vo_pxa: config() Set FBIOPUT_VSCREENINFO on base_fd failed %d\n",
                    errno );
            priv->vm = 0;
            goto err_out;
        }
        
        /* We need this sleep, to make the change in resolution actually happen, before we open the overlay */
        sleep(1);
    }
 
   
    /* Open up the overlay fbdev */
    priv->fd = open( "/dev/fb2", O_RDWR );

    if( priv->fd < 0 )
    {
        mp_msg( MSGT_VO, MSGL_ERR, "vo_pxa: Could not open /dev/fb2: %d\n", errno );
        goto err_out;
    }
    
    /* Read in fb var data */
    rc = ioctl( priv->fd, FBIOGET_VSCREENINFO, &(priv->my_fb_var) );
    
    if( rc == -1 )
    {
        mp_msg( MSGT_VO, MSGL_ERR, "vo_pxa: config() FBIOGET_VSCREENINFO from fd failed %d\n",
                errno );
        goto err_out;
    }
    
    /* Store away the source dimensions, so we can place in centre of screen later in vm mode */
    priv->src_width = src_width;
    priv->src_height = src_height;
    
    /* Set up the buffer */
    if( priv->vm )
    {
        /* Ignore size, as the rest of the screen is toast. Use max size */
        priv->my_fb_var.xres = 240;
        priv->my_fb_var.yres = 320;

        /* Do we need to rotate? */
        if( priv->src_width > priv->src_height )
        {
            /* Yes */
            priv->rotate = 1;
        }

        priv->width  = 240;
        priv->height = 320;
    }
    else
    {
        priv->my_fb_var.xres = src_width;
        priv->my_fb_var.yres = src_height;
        priv->width = src_width;
        priv->height = src_height;
    }
    
    priv->my_fb_var.nonstd = ( 4 << 20)  /* Format YV12 */
                           | ( 0 <<  0)  /* x position */
                           | ( 0 << 10); /* y position */ 
    /* We have to set the bits per pixel to a valid value, even though it is
     * incorrect for YV12
     */
    priv->my_fb_var.bits_per_pixel = 16;
    
    rc = ioctl( priv->fd, FBIOPUT_VSCREENINFO, &(priv->my_fb_var) );
    
    if( rc == -1 )
    {
        mp_msg( MSGT_VO, MSGL_ERR, "vo_pxa: config() FBIOPUT_VSCREENINFO to fd failed: %d\n",
                errno );
        goto err_out;
    }
        
    /* Next get the fixed fbvars, so we can mmap the data for all 3 planes */
    rc = ioctl( priv->fd, FBIOGET_FSCREENINFO, &(priv->my_fb_fix) );
    
    if( rc == -1 )
    {
        mp_msg( MSGT_VO, MSGL_ERR, "vo_pxa: config() FBIOGET_FSCREENINFO from fd failed: %d\n", 
                errno );
        goto err_out;
    }
    
    priv->fb_mem_base = mmap( NULL, priv->my_fb_fix.smem_len, (PROT_READ | PROT_WRITE ),
                        MAP_SHARED,
                        priv->fd,
                        0 );

    if( priv->fb_mem_base == MAP_FAILED )
    {
        mp_msg( MSGT_VO, MSGL_ERR, "vo_pxa: mmap fd buffer failed: %d\n", errno );
        goto err_out;
    }

    /* Finally, find the offsets of each plane by getting the var data again */
    rc = ioctl( priv->fd, FBIOGET_VSCREENINFO, &(priv->my_fb_var) );
    
    if( rc == -1 )
    {
        mp_msg( MSGT_VO, MSGL_ERR, "vo_pxa: config() FBIOGET_VSCREENINFO from fd (2) failed %d\n", 
                errno );
        goto err_out;
    }
    
    /* Fill the overlay with black */
    memset( priv->fb_mem_base + priv->my_fb_var.red.offset, 16, priv->my_fb_var.red.length );
    memset( priv->fb_mem_base + priv->my_fb_var.green.offset, 128, priv->my_fb_var.green.length );
    memset( priv->fb_mem_base + priv->my_fb_var.blue.offset, 128, priv->my_fb_var.blue.length );
    
    /* Now open the OSD overlay - overlay 1, and fill with transparent */
    sleep( 1 );
    
    priv->overlay_fd = open( "/dev/fb1", O_RDWR );

    if( priv->overlay_fd < 0 )
    {
        mp_msg( MSGT_VO, MSGL_ERR, "vo_pxa: Could not open /dev/fb1: %d\n", errno );
        goto err_out;
    }
    
    /* Read in fb var data */
    rc = ioctl( priv->overlay_fd, FBIOGET_VSCREENINFO, &(priv->osd_fb_var) );
    
    if( rc == -1 )
    {
        mp_msg( MSGT_VO, MSGL_ERR, "vo_pxa: config() FBIOGET_VSCREENINFO from overlay_fd failed; %d\n",
                errno );
        goto err_out;
    }

    priv->osd_fb_var.xres = priv->width;
    priv->osd_fb_var.yres = priv->height;
    priv->osd_fb_var.nonstd = ( 0 <<  0)  /* x position */
                            | ( 0 << 10); /* y position */
    /* Use 15 bit mode, with top bit transparency */
    priv->osd_fb_var.bits_per_pixel = 16;
    
    rc = ioctl( priv->overlay_fd, FBIOPUT_VSCREENINFO, &(priv->osd_fb_var) );
    
    if( rc == -1 )
    {
        mp_msg( MSGT_VO, MSGL_ERR, "vo_pxa: config() FBIOPUT_VSCREENINFO to overlay_fd failed: %d\n",
                errno );
        goto err_out;
    }
        
    /* Next get the fixed fbvars, so we can mmap the data */
    rc = ioctl( priv->overlay_fd, FBIOGET_FSCREENINFO, &(priv->osd_fb_fix) );
    
    if( rc == -1 )
    {
        mp_msg( MSGT_VO, MSGL_ERR, "vo_pxa: config() FBIOGET_FSCREENINFO from overlay_fd failed %d\n",
                errno );
        goto err_out;
    }
    
    priv->osd_mem_base = mmap( NULL, priv->osd_fb_fix.smem_len, (PROT_READ | PROT_WRITE ),
                               MAP_SHARED,
                               priv->overlay_fd,
                               0 );

    if( priv->osd_mem_base == MAP_FAILED )
    {
        mp_msg( MSGT_VO, MSGL_ERR, "vo_pxa: mmap osd_mem_base failed: %d\n", errno );
        goto err_out;
    }
    
    /* Fill the overlay with transparent */
    vo_pxa_clear_osd( priv->osd_mem_base, priv->osd_fb_fix.smem_len );

    /* We are good to go! */
    mp_msg( MSGT_VO, MSGL_V, "vo_pxa: Opened video overlay %d x %d fourcc %s\n",
            priv->my_fb_var.xres,
            priv->my_fb_var.yres,
            vo_format_name(format) );
    
    return 0;
    
    err_out:

    /* Don't do anything here for the moment */
    return -1;
}


/*****************************************************************************
 *
 * control
 *
 * Control display
 *
 ****************************************************************************/
static int control(uint32_t request, void *data, ...)
{
    mp_msg(MSGT_VO, MSGL_V, "vo_pxa: control %08x\n", request );
    
    switch( request )
    {
        case VOCTRL_QUERY_FORMAT:
            return( vo_pxa_query_format( *(uint32_t *)data ) );
            break;
    }
    
    return VO_NOTIMPL;
}


/*****************************************************************************
 *
 * draw_frame
 *
 * Display a new RGB/BGR frame of the video to the screen.
 * params:
 *   src[0] - pointer to the image
 *
 ****************************************************************************/
int draw_frame(uint8_t *src[])
{
    /* This is not implimented */
    mp_msg(MSGT_VO, MSGL_ERR, "vo_pxa: dummy draw_frame() was called\n");
    return -1;
}


/*****************************************************************************
 *
 * draw_slice
 *
 * Draw a planar YUV slice to the buffer:
 * params:
 *   src[3] = source image planes (Y,U,V)
 *   stride[3] = source image planes line widths (in bytes)
 *   w,h = width*height of area to be copied (in Y pixels)
 *   x,y = position at the destination image (in Y pixels)
 *
 ****************************************************************************/
int draw_slice(uint8_t *src[], int stride[], int w,int h, int x,int y)
{
    pxa_priv_t *priv = &st_pxa_priv;
    
    /* This routine is only display routine actually implimented */
    mp_msg(MSGT_VO, MSGL_V, "vo_pxa: draw_slice() w %d h %d x %d y %d stride %d %d %d\n",
           w, h, x, y, stride[0], stride[1], stride[2] );
    
    /* It would be faster to check if source and dest have same geometry and copy
     * whole block
     * For the moment we just copy a line at a time
     */

    /* In vm mode rotate if wider than long */
    if( priv->vm )
    {
        /* Do we nee to rotate? */
        if( priv->rotate )
        {
            /* Yes, rotated version */
            int dst_x_offset = 0;
            int dst_y_offset = 0;
            int src_x_offset = 0;
            int src_y_offset = 0;
        
            /* Figure out  dst offset */
            if( priv->src_width < 320 )
            {
                dst_x_offset = ( ( 320 -  priv->src_width ) / 2 );
                /* Make it a multiple of 16 */
                dst_x_offset &= ~(0xf);
            }
        
            if( priv->src_height < 240 )
            {
                dst_y_offset = ( ( 240 -  priv->src_height ) / 2 );
                /* Make it a multiple of 16 */
                dst_y_offset &= ~(0xf);
            }
        
            dst_x_offset += x;
            dst_y_offset += y;
        
            if( ( dst_x_offset >= 320 ) || ( dst_y_offset >= 240 ) )
            {
                /* Nothing to do - drawing off the screen! */
                return( 0 );
            }
        
            /* Limit to drawable area */
            if( ( w + dst_x_offset ) > 320 )
            {
                w = ( 320 - dst_x_offset );
            }
        
            if( ( h + dst_y_offset ) > 240 )
            {
                h = ( 240 - dst_y_offset );
            }
            
            /* And source offset */
            if( priv->src_width > 320 )
            {
                src_x_offset = ( ( priv->src_width - 320 ) / 2 );
                /* Make it a multiple of 16 */
                src_x_offset &= ~(0xf);
            }
        
            if( priv->src_height > 240 )
            {
                src_y_offset = ( ( priv->src_height - 240 ) / 2 );
                /* Make it a multiple of 16 */
                src_y_offset &= ~(0xf);
            }
            
        
            /* Y first */
            vo_pxa_copy_and_rotate( src[0] + src_x_offset + (src_y_offset * stride[0]), stride[0],
                                    priv->fb_mem_base + priv->my_fb_var.red.offset  + (240 * dst_x_offset) + (240 - dst_y_offset - h),
                                    w, h, 240 );
            /* Now U */
            vo_pxa_copy_and_rotate( src[1] + src_x_offset/2 + (src_y_offset/2 * stride[1]), stride[1],
                                    priv->fb_mem_base + priv->my_fb_var.green.offset + (120 * dst_x_offset/2) + (120 - dst_y_offset/2 - h/2),
                                    w/2, h/2, 120 );
            vo_pxa_copy_and_rotate( src[2] + src_x_offset/2 + (src_y_offset/2 * stride[2]), stride[2],
                                    priv->fb_mem_base + priv->my_fb_var.blue.offset + (120 * dst_x_offset/2) + (120 - dst_y_offset/2 - h/2),
                                    w/2, h/2, 120 );
        }
        else
        {
            /* Don't rotate */
            int i;
            uint8_t *my_src;
            uint8_t *dest;
            int dst_x_offset = 0;
            int dst_y_offset = 0;
            int src_x_offset = 0;
            int src_y_offset = 0;
        
            /* Figure out  dst offset */
            if( priv->src_width < 240 )
            {
                dst_x_offset = ( ( 240 -  priv->src_width ) / 2 );
                /* Make it a multiple of 16 */
                dst_x_offset &= ~(0xf);
            }
        
            if( priv->src_height < 320 )
            {
                dst_y_offset = ( ( 320 -  priv->src_height ) / 2 );
                /* Make it a multiple of 16 */
                dst_y_offset &= ~(0xf);
            }
        
            dst_x_offset += x;
            dst_y_offset += y;
        
            if( ( dst_x_offset >= 240 ) || ( dst_y_offset >= 320 ) )
            {
                /* Nothing to do - drawing off the screen! */
                return( 0 );
            }
        
            /* Limit to drawable area */
            if( ( w + dst_x_offset ) > 240 )
            {
                w = ( 240 - dst_x_offset );
            }
        
            if( ( h + dst_y_offset ) > 320 )
            {
                h = ( 320 - dst_y_offset );
            }

            /* And source offset */
            if( priv->src_width > 240 )
            {
                src_x_offset = ( ( priv->src_width - 240 ) / 2 );
                /* Make it a multiple of 16 */
                src_x_offset &= ~(0xf);
            }
        
            if( priv->src_height > 320 )
            {
                src_y_offset = ( ( priv->src_height - 320 ) / 2 );
                /* Make it a multiple of 16 */
                src_y_offset &= ~(0xf);
            }
            
            /* First Y */
            for( i = 0; i<h; i++ )
            {
                dest = priv->fb_mem_base + 
                    priv->my_fb_var.red.offset + 
                    ( (dst_y_offset+i) * priv->my_fb_fix.line_length ) +
                    dst_x_offset;
                my_src = src[0] + src_x_offset + (stride[0] * (i+src_y_offset));
                memcpy( dest, my_src, w );
            }

            /* Now U */
            for( i = 0; i<(h/2); i++ )
            {
                dest = priv->fb_mem_base + 
                    priv->my_fb_var.green.offset + 
                    ( ((dst_y_offset/2)+i) * (priv->my_fb_fix.line_length/2) ) +
                    dst_x_offset/2;
                my_src = src[1] + src_x_offset/2 + (stride[1] * (i+(src_y_offset/2)));
                memcpy( dest, my_src, w/2 );
            }
    
            /* Finaly V */
            for( i = 0; i<(h/2); i++ )
            {
                dest = priv->fb_mem_base + 
                    priv->my_fb_var.blue.offset + 
                    ( ((dst_y_offset/2)+i) * (priv->my_fb_fix.line_length/2) ) +
                    dst_x_offset/2;
                my_src = src[2] + src_x_offset/2 + (stride[2] * (i+(src_y_offset/2)));
                memcpy( dest, my_src, w/2 );
            }
            
        }
    }
    else
    {
        /* Not full screen mode */
        uint8_t *my_src;
        uint8_t *dest;
        size_t length;
        int i;
        
        /* It would be faster to check if source and dest have same geometry and copy
         * whole block
         * For the moment we just copy a line at a time
         */

        /* Limit area written to */
        if( x >= priv->my_fb_fix.line_length )
        {
            return 0;
        }
    
        if( w + x > priv->my_fb_fix.line_length )
        {
            w = priv->my_fb_fix.line_length - x;
        }
    
        if( y>= priv->my_fb_var.yres )
        {
            return 0;
        }
    
        if( h + y > priv->my_fb_var.yres )
        {
            h = priv->my_fb_var.yres - y;
        }
    
        /* First Y */
        for( i = 0; i<h; i++ )
        {
            dest = priv->fb_mem_base + 
                priv->my_fb_var.red.offset + 
                ( (y+i) * priv->my_fb_fix.line_length ) +
                x;
            my_src = src[0] + stride[0] * i;
            memcpy( dest, my_src, w );
        }

        /* Now U */
        for( i = 0; i<(h/2); i++ )
        {
            dest = priv->fb_mem_base + 
                priv->my_fb_var.green.offset + 
                ( ((y/2)+i) * (priv->my_fb_fix.line_length/2) ) +
                x;
            my_src = src[1] + stride[1] * i;
            memcpy( dest, my_src, w/2 );
        }
    
        /* Finaly V */
        for( i = 0; i<(h/2); i++ )
        {
            dest = priv->fb_mem_base + 
                priv->my_fb_var.blue.offset + 
                ( ((y/2)+i) * (priv->my_fb_fix.line_length/2) ) +
                x;
            my_src = src[2] + stride[2] * i;
            memcpy( dest, my_src, w/2 );
        }
    }
    return 0;
}

static void draw_osd(void)
{
    pxa_priv_t *priv = &st_pxa_priv;
    int osd_has_changed;

    /* This gets called every frame, so systems which do the OSD without a
     * seperate overlay can mix in the image. We need to find out if the osd
     * has actually been updated!
     */
    mp_msg(MSGT_VO, MSGL_V, "vo_pxa: draw_osd() was called\n");
    
    osd_has_changed = vo_update_osd( priv->width, priv->height);

    if(osd_has_changed)
    {
        int i;
        
        mp_msg(MSGT_VO, MSGL_V, "vo_pxa: Clear and update OSD\n");
        
        /* Fill with transparent */
        vo_pxa_clear_osd( priv->osd_mem_base, priv->osd_fb_fix.smem_len );
        
        priv->osd_cleared = 1;
        
        /* now update */
        if( priv->rotate )
        {
            vo_draw_text( priv->width, priv->height, vo_pxa_draw_alpha_with_rotate );
        }
        else
        {
            vo_draw_text( priv->width, priv->height, vo_pxa_draw_alpha );
        }
    }
}

/*****************************************************************************
 *
 * flip_page
 *
 * Blit/Flip buffer to the screen. Must be called after each frame!
 *
 *
 ****************************************************************************/
static void flip_page(void)
{
    mp_msg(MSGT_VO, MSGL_V, "vo_pxa: flip_page() was called\n");
}

/*****************************************************************************
 *
 * check_events
 *
 *
 ****************************************************************************/
static void check_events(void)
{
    mp_msg(MSGT_VO, MSGL_V, "vo_pxa: check_events() was called\n");
}

/*****************************************************************************
 *
 * uninit
 *
 *
 ****************************************************************************/
static void uninit(void)
{
    pxa_priv_t *priv = &st_pxa_priv;
    int rc;

    mp_msg(MSGT_VO, MSGL_V, "vo_pxa: uninit() was called\n");
    
    if( priv->vm )
    {
        /* We need these sleeps, to make the change in resolution actually happen */
        sleep(1);

        /* Restore original resolution */
        if( priv->base_fd >= 0 )
        {
            rc = ioctl( priv->base_fd, FBIOPUT_VSCREENINFO, &(priv->base_orig_fb_var) );
    
            if( rc == -1 )
            {
                mp_msg( MSGT_VO, MSGL_ERR, "vo_pxa: uninit() FBIOPUT_VSCREENINFO to base_fd failed %d\n",
                        errno );
            }
        }
        /* We need these sleeps, to make the change in resolution actually happen */
        /* For some reason, if we change the reolution the overlay buffer never gets deleted? */
        sleep(1);
    }
    

    /* We need to force the overlays to be really disabled, otherwise they
     * will come back as zombies after suspend, resume
     * This trick seems to work, but will not be needed once kernel driver
     * is fixed
     */
    if( priv->fd >= 0 )
    {
        rc = ioctl( priv->fd, FBIOGET_VSCREENINFO, &(priv->my_fb_var) );

        if( rc == -1 )
        {
            mp_msg( MSGT_VO, MSGL_ERR, "vo_pxa: uninit() FBIOGET_VSCREENINFO from fd failed %d\n",
                    errno );
        }
	priv->my_fb_var.bits_per_pixel = 0;

        rc = ioctl( priv->fd, FBIOPUT_VSCREENINFO, &(priv->my_fb_var) );

        if( rc == -1 )
        {
            mp_msg( MSGT_VO, MSGL_ERR, "vo_pxa: uninit() FBIOPUT_VSCREENINFO from fd failed %d\n",
                    errno );
        }
    }

    if( priv->overlay_fd >= 0 )
    {
        rc = ioctl( priv->overlay_fd, FBIOGET_VSCREENINFO, &(priv->my_fb_var) );

        if( rc == -1 )
        {
            mp_msg( MSGT_VO, MSGL_ERR, "vo_pxa: uninit() FBIOGET_VSCREENINFO from overlay_fd failed %d\n",
                    errno );
        }
        priv->my_fb_var.bits_per_pixel = 0;

        rc = ioctl( priv->overlay_fd, FBIOPUT_VSCREENINFO, &(priv->my_fb_var) );

        if( rc == -1 )
        {
            mp_msg( MSGT_VO, MSGL_ERR, "vo_pxa: uninit() FBIOPUT_VSCREENINFO from overlay_fd failed %d\n",
                    errno );
        }
    }

    if( priv->base_fd >= 0 )
    {
        close( priv->base_fd );
        priv->base_fd = -1;
    }
}

/*****************************************************************************
 *
 * Internal functions, not part of mplayer API
 *
 ****************************************************************************/

static int vo_pxa_query_format( uint32_t format )
{
    mp_msg(MSGT_VO, MSGL_V, "vo_pxa: vo_pxa_query_format was called: %x (%s)\n",
	   format, vo_format_name(format));

    switch (format)
    {
        /* Planar YUV Formats */
        /* Warning! dropthrough */
        case IMGFMT_YV12:
        case IMGFMT_IYUV:
        case IMGFMT_I420:
            return( VFCAP_CSP_SUPPORTED | VFCAP_CSP_SUPPORTED_BY_HW
                    | VFCAP_HWSCALE_UP | VFCAP_HWSCALE_DOWN | VFCAP_OSD
                    | VFCAP_ACCEPT_STRIDE );
            break;
    }
        
    return 0;
}

static void vo_pxa_copy_and_rotate( uint8_t *src, int stride, uint8_t *dst, int w, int h, int dst_stride )
{
    int i,j;
    uint8_t *my_src, *my_dst;
    Vo_Pxa_Pixel_Data8 *img_dst_pixel_data8;                       
        
    /* Loop so writing consectuive data in rotated image */
    /* This produces some pretty good assembler - better than the handcoded stuff in w100 */
    for( j=0; j<w; j++ )
    {
        my_src = src + j + ( stride * (h - 1) );

        img_dst_pixel_data8 = (Vo_Pxa_Pixel_Data8 *)dst;
        
        /* Allow for src not multiple of 8 by running off the end a little. Should not matter */
        for( i=0; i<((h+7)/8); i++ )
        {
            register Vo_Pxa_Pixel_Data8 build_pixels;
                
            build_pixels.a = *my_src;
            my_src -= stride;
            build_pixels.a |= (*my_src<<8);
            my_src -= stride;
            build_pixels.a |= (*my_src<<16);
            my_src -= stride;
            build_pixels.a |= (*my_src<<24);
            my_src -= stride;

            build_pixels.b = *my_src;
            my_src -= stride;
            build_pixels.b |= (*my_src<<8);
            my_src -= stride;
            build_pixels.b |= (*my_src<<16);
            my_src -= stride;
            build_pixels.b |= (*my_src<<24);
            my_src -= stride;
                
            *img_dst_pixel_data8++ = build_pixels;
        }
        
        /* Allow source not as big as dest */
        dst += dst_stride;
    }   
}

static void vo_pxa_draw_alpha( int x, int y, int w, int h, unsigned char *src,
                               unsigned char *srca, int stride )
{
    /* Dump data into our 15bit buffer with transparency */
    pxa_priv_t *priv = &st_pxa_priv;
    int i,j;
    unsigned char *src_ptr = src;
    unsigned char *a_ptr = srca;
    unsigned short *out_ptr;
    
    mp_msg(MSGT_VO, MSGL_V, "vo_pxa: vo_pxa_draw_alpha() w %d y %d w %d h %d\n", x, y, w, h );
    
    /* We ignore the alpha channel, other than off or on */
    for( i=0; i<h; i++ )
    {
        out_ptr = priv->osd_mem_base + x + ( priv->width * ( y + i ) );
        src_ptr = src + ( i * stride );
        a_ptr = srca + ( i * stride );
            
        for( j=0; j<w; j++ )
        {
            /* The srca is a 0-255 transpaency level, where 0 is transparent.
             * We only support transparent on or off
             */
            if( *a_ptr++ )
            {
                unsigned int grey;
                /* The src is a greylevel from 0 - 255 */
                /* We may as well use this value */
                grey = *src_ptr++ >> 3;
                *out_ptr++ = grey | (grey << 5) | (grey<<10);                
            }
            else
            {                
                *out_ptr++ = 0x8000;
                src_ptr++;
            }
            
        }
    }
}

static void vo_pxa_draw_alpha_with_rotate( int x, int y, int w, int h, unsigned char *src,
                                           unsigned char *srca, int stride )
{
    /* Dump data into our 15bit buffer with transparency */
    pxa_priv_t *priv = &st_pxa_priv;
    int i,j;
    unsigned char *src_ptr = src;
    unsigned char *a_ptr = srca;
    unsigned short *out_ptr;
    
    mp_msg(MSGT_VO, MSGL_V, "vo_pxa: vo_pxa_draw_alpha_with_rotate() x %d y %d w %d h %d\n", x, y, w, h );
        
    if( x >= 320 )
    {
        /* Off the screen */
        return;
    }

    /* Limit to size of screen/memory */
    if( ( w + x ) > 320 )
    {
        w = 320 - x;
    }
    
    if( y >= 240 )
    {
        /* Off the screen */
        return;
    }
    
    /* Limit to size of screen/memory */
    if( ( y + h ) > 240 )
    {
        h = 240 - y;
    }
    
    
    /* We ignore the alpha channel, other than off or on */
    for( i=0; i<w; i++ )
    {
        out_ptr = priv->osd_mem_base + y + ( priv->width * ( x + i ) );
        src_ptr = src + i + ( stride * (h - 1));
        a_ptr = srca + i + ( stride * (h - 1));
            
        for( j=0; j<h; j++ )
        {
            /* The srca is a 0-255 transpaency level, where 0 is transparent.
             * We only support transparent on or off
             */
            if( *a_ptr )
            {
                unsigned int grey;
                /* The src is a greylevel from 0 - 255 */
                /* We may as well use this value */
                grey = *src_ptr >> 3;
                *out_ptr++ = grey | (grey << 5) | (grey<<10);                
            }
            else
            {                
                *out_ptr++ = 0x8000;
                src_ptr;
            }
            a_ptr -= stride;
            src_ptr -= stride;
        }
    }
}

static void vo_pxa_clear_osd( uint16_t *mem_base, int len )
{
    /* fill whole area with 0x8000 -> trsnaparent.
     * assume area is word aligned, and a mulitple of 16 bytes in length
     * However I tried I could not get the compiler to generate this.
     * It always wanted to  to do ldmia 4 words from stack followed by
     * stmia 4 words. This seems odd!
     */
    __asm__ __volatile__ (
        "mov        r4, %0         \n\t"
        "mov        r5, %1, lsr #4      \n\t"
        "subs       r5, r5, #1\n\t"
        "mov	r0, #0x80000000         \n\t"
        "orr	r0, r0, #0x00008000     \n\t"
        "mov	r1, r0                  \n\t"
        "mov	r2, r0                  \n\t"
        "mov	r3, r0                  \n\t"
        "1:					\n\t"
        "subs       r5, r5, #1\n\t"
        "stmia      r4!, {r0, r1, r2, r3} \n\t"
        "bne        1b \n\t"
        : 
        : "r"(mem_base), "r"(len)
        : "memory", "r0", "r1", "r2", "r3", "r4", "r5", "cc" );
}