@@ -1,4 +1,9 @@

 -------------------------------------------------------------------

+Sat Mar 22 17:10:14 UTC 2014 - i@margueirte.su

+

+- update version 20140321.

+

+-------------------------------------------------------------------

 Tue Nov 19 07:53:08 UTC 2013 - obs@botter.cc

 - add -fno-aggressive-loop-optimizations to extra-cflags in

​

@@ -14,8 +14,8 @@

 # Please submit bugfixes or comments via http://bugs.links2linux.org/

 Name:           libx264

-%define soname  135

-%define svn     20130723

+%define soname  142

+%define svn     20140321

 Version:        0.%{soname}svn%{svn}

 Release:        1

 License:        GPL-2.0+

​

@@ -1,218 +0,0 @@

-/*****************************************************************************

- * display-x11.c: x11 interface

- *****************************************************************************

- * Copyright (C) 2005-2013 x264 project

- *

- * Authors: Tuukka Toivonen <tuukkat@ee.oulu.fi>

- *

- * This program is free software; you can redistribute it and/or modify

- * it under the terms of the GNU General Public License as published by

- * the Free Software Foundation; either version 2 of the License, or

- * (at your option) any later version.

- *

- * This program is distributed in the hope that it will be useful,

- * but WITHOUT ANY WARRANTY; without even the implied warranty of

- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

- * GNU General Public License for more details.

- *

- * You should have received a copy of the GNU General Public License

- * along with this program; if not, write to the Free Software

- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111, USA.

- *

- * This program is also available under a commercial proprietary license.

- * For more information, contact us at licensing@x264.com.

- *****************************************************************************/

-

-#include <X11/Xlib.h>

-#include <X11/Xutil.h>

-#include <stdio.h>

-#include <stdlib.h>

-#include <string.h>

-

-#include "common.h"

-#include "display.h"

-

-static long event_mask = ConfigureNotify|ExposureMask|KeyPressMask|ButtonPressMask|StructureNotifyMask|ResizeRedirectMask;

-

-static Display *disp_display = NULL;

-static struct disp_window

-{

-    int init;

-    Window window;

-} disp_window[10];

-

-static inline void disp_chkerror( int cond, char *e )

-{

-    if( !cond )

-        return;

-    fprintf( stderr, "error: %s\n", e ? e : "?" );

-    abort();

-}

-

-static void disp_init_display( void )

-{

-    Visual *visual;

-    int dpy_class;

-    int screen;

-    int dpy_depth;

-

-    if( disp_display )

-        return;

-    memset( &disp_window, 0, sizeof(disp_window) );

-    disp_display = XOpenDisplay( "" );

-    disp_chkerror( !disp_display, "no display" );

-    screen = DefaultScreen( disp_display );

-    visual = DefaultVisual( disp_display, screen );

-    dpy_class = visual->class;

-    dpy_depth = DefaultDepth( disp_display, screen );

-    disp_chkerror( !((dpy_class == TrueColor && dpy_depth == 32)

-        || (dpy_class == TrueColor && dpy_depth == 24)

-        || (dpy_class == TrueColor && dpy_depth == 16)

-        || (dpy_class == PseudoColor && dpy_depth == 8)),

-        "requires 8 bit PseudoColor or 16/24/32 bit TrueColor display" );

-}

-

-static void disp_init_window( int num, int width, int height, const unsigned char *title )

-{

-    XSetWindowAttributes xswa;

-    XEvent xev;

-    int screen = DefaultScreen(disp_display);

-    Visual *visual = DefaultVisual (disp_display, screen);

-    char buf[200];

-    Window window;

-

-    if( title )

-        snprintf( buf, 200, "%s: %i/disp", title, num );

-    else

-        snprintf( buf, 200, "%i/disp", num );

-

-    XSizeHints *shint = XAllocSizeHints();

-    disp_chkerror( !shint, "memerror" );

-    shint->min_width = shint->max_width = shint->width = width;

-    shint->min_height = shint->max_height = shint->height = height;

-    shint->flags = PSize | PMinSize | PMaxSize;

-    disp_chkerror( num < 0 || num >= 10, "bad win num" );

-    if( !disp_window[num].init )

-    {

-        unsigned int mask = 0;

-        disp_window[num].init = 1;

-        unsigned int bg = WhitePixel( disp_display, screen );

-        unsigned int fg = BlackPixel( disp_display, screen );

-        int dpy_depth = DefaultDepth( disp_display, screen );

-        if( dpy_depth==32 || dpy_depth==24 || dpy_depth==16 )

-        {

-            mask |= CWColormap;

-            xswa.colormap = XCreateColormap( disp_display, DefaultRootWindow( disp_display ), visual, AllocNone );

-        }

-        xswa.background_pixel = bg;

-        xswa.border_pixel = fg;

-        xswa.backing_store = Always;

-        xswa.backing_planes = -1;

-        xswa.bit_gravity = NorthWestGravity;

-        mask = CWBackPixel | CWBorderPixel | CWBackingStore | CWBackingPlanes | CWBitGravity;

-        window = XCreateWindow( disp_display, DefaultRootWindow( disp_display ),

-                                shint->x, shint->y, shint->width, shint->height,

-                                1, dpy_depth, InputOutput, visual, mask, &xswa );

-        disp_window[num].window = window;

-

-        XSelectInput( disp_display, window, event_mask );

-        XSetStandardProperties( disp_display, window, buf, buf, None, NULL, 0, shint );

-        XMapWindow( disp_display, window );

-

-        do {

-            XNextEvent( disp_display, &xev );

-        } while( xev.type != MapNotify || xev.xmap.event != window );

-    }

-    window = disp_window[num].window;

-    XSetStandardProperties( disp_display, window, buf, buf, None, NULL, 0, shint );

-    XResizeWindow( disp_display, window, width, height );

-    XSync( disp_display, 1 );

-    XFree( shint );

-}

-

-void disp_sync( void )

-{

-    XSync( disp_display, 1 );

-}

-

-void disp_setcolor( unsigned char *name )

-{

-    XColor c_exact, c_nearest;

-

-    int screen = DefaultScreen( disp_display );

-    GC gc = DefaultGC( disp_display, screen );

-    Colormap cm = DefaultColormap( disp_display, screen );

-    Status st = XAllocNamedColor( disp_display, cm, name, &c_nearest, &c_exact );

-    disp_chkerror( st != 1, "XAllocNamedColor error" );

-    XSetForeground( disp_display, gc, c_nearest.pixel );

-}

-

-void disp_gray( int num, char *data, int width, int height, int stride, const unsigned char *title )

-{

-    char dummy;

-

-    disp_init_display();

-    disp_init_window( num, width, height, title );

-    int screen = DefaultScreen( disp_display );

-    Visual *visual = DefaultVisual( disp_display, screen );

-    int dpy_depth = DefaultDepth( disp_display, screen );

-    XImage *ximage = XCreateImage( disp_display, visual, dpy_depth, ZPixmap, 0, &dummy, width, height, 8, 0 );

-    disp_chkerror( !ximage, "no ximage" );

-#if WORDS_BIGENDIAN

-    ximage->byte_order = MSBFirst;

-    ximage->bitmap_bit_order = MSBFirst;

-#else

-    ximage->byte_order = LSBFirst;

-    ximage->bitmap_bit_order = LSBFirst;

-#endif

-

-    int pixelsize = dpy_depth>8 ? sizeof(int) : sizeof(unsigned char);

-    uint8_t *image = malloc( width * height * pixelsize );

-    disp_chkerror( !image, "malloc failed" );

-    for( int y = 0; y < height; y++ )

-        for( int x = 0; x < width; x++ )

-            memset( &image[(width*y + x)*pixelsize], data[y*stride+x], pixelsize );

-    ximage->data = image;

-    GC gc = DefaultGC( disp_display, screen );

-

-    XPutImage( disp_display, disp_window[num].window, gc, ximage, 0, 0, 0, 0, width, height );

-    XPutImage( disp_display, disp_window[num].window, gc, ximage, 0, 0, 0, 0, width, height );

-

-    XDestroyImage( ximage );

-    XSync( disp_display, 1 );

-

-}

-

-void disp_gray_zoom(int num, char *data, int width, int height, int stride, const unsigned char *title, int zoom)

-{

-    unsigned char *dataz = malloc( width*zoom * height*zoom );

-    disp_chkerror( !dataz, "malloc" );

-    for( int y = 0; y < height; y++ )

-        for( int x = 0; x < width; x++ )

-            for( int y0 = 0; y0 < zoom; y0++ )

-                for( int x0 = 0; x0 < zoom; x0++ )

-                    dataz[(y*zoom + y0)*width*zoom + x*zoom + x0] = data[y*stride+x];

-    disp_gray( num, dataz, width*zoom, height*zoom, width*zoom, title );

-    free( dataz );

-}

-

-void disp_point( int num, int x1, int y1 )

-{

-    int screen = DefaultScreen( disp_display );

-    GC gc = DefaultGC( disp_display, screen );

-    XDrawPoint( disp_display, disp_window[num].window, gc, x1, y1 );

-}

-

-void disp_line( int num, int x1, int y1, int x2, int y2 )

-{

-    int screen = DefaultScreen( disp_display );

-    GC gc = DefaultGC( disp_display, screen );

-    XDrawLine( disp_display, disp_window[num].window, gc, x1, y1, x2, y2 );

-}

-

-void disp_rect( int num, int x1, int y1, int x2, int y2 )

-{

-    int screen = DefaultScreen( disp_display );

-    GC gc = DefaultGC( disp_display, screen );

-    XDrawRectangle( disp_display, disp_window[num].window, gc, x1, y1, x2-x1, y2-y1 );

-}

​

@@ -1,41 +0,0 @@

-/*****************************************************************************

- * display.h: x11 visualization interface

- *****************************************************************************

- * Copyright (C) 2005-2013 x264 project

- *

- * Authors: Tuukka Toivonen <tuukkat@ee.oulu.fi>

- *

- * This program is free software; you can redistribute it and/or modify

- * it under the terms of the GNU General Public License as published by

- * the Free Software Foundation; either version 2 of the License, or

- * (at your option) any later version.

- *

- * This program is distributed in the hope that it will be useful,

- * but WITHOUT ANY WARRANTY; without even the implied warranty of

- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

- * GNU General Public License for more details.

- *

- * You should have received a copy of the GNU General Public License

- * along with this program; if not, write to the Free Software

- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111, USA.

- *

- * This program is also available under a commercial proprietary license.

- * For more information, contact us at licensing@x264.com.

- *****************************************************************************/

-

-#ifndef X264_DISPLAY_H

-#define X264_DISPLAY_H

-

-void disp_sync(void);

-void disp_setcolor(unsigned char *name);

-/* Display a region of byte wide memory as a grayscale image.

- * num is the window to use for displaying. */

-void disp_gray(int num, char *data, int width, int height,

-               int stride, const unsigned char *title);

-void disp_gray_zoom(int num, char *data, int width, int height,

-               int stride, const unsigned char *title, int zoom);

-void disp_point(int num, int x1, int y1);

-void disp_line(int num, int x1, int y1, int x2, int y2);

-void disp_rect(int num, int x1, int y1, int x2, int y2);

-

-#endif

​

@@ -1,341 +0,0 @@

-/*****************************************************************************

- * visualize.c: visualization

- *****************************************************************************

- * Copyright (C) 2005-2013 x264 project

- *

- * Authors: Tuukka Toivonen <tuukkat@ee.oulu.fi>

- *

- * This program is free software; you can redistribute it and/or modify

- * it under the terms of the GNU General Public License as published by

- * the Free Software Foundation; either version 2 of the License, or

- * (at your option) any later version.

- *

- * This program is distributed in the hope that it will be useful,

- * but WITHOUT ANY WARRANTY; without even the implied warranty of

- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

- * GNU General Public License for more details.

- *

- * You should have received a copy of the GNU General Public License

- * along with this program; if not, write to the Free Software

- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111, USA.

- *

- * This program is also available under a commercial proprietary license.

- * For more information, contact us at licensing@x264.com.

- *****************************************************************************/

-

-/*

- * Some explanation of the symbols used:

- * Red/pink: intra block

- * Blue: inter block

- * Green: skip block

- * Yellow: B-block (not visualized properly yet)

- *

- * Motion vectors have black dot at their target (ie. at the MB center),

- * instead of arrowhead. The black dot is enclosed in filled diamond with radius

- * depending on reference frame number (one frame back = zero width, normal case).

- *

- * The intra blocks have generally lines drawn perpendicular

- * to the prediction direction, so for example, if there is a pink block

- * with horizontal line at the top of it, it is interpolated by assuming

- * luma to be vertically constant.

- * DC predicted blocks have both horizontal and vertical lines,

- * pink blocks with a diagonal line are predicted using the planar function.

- */

-

-#include "common.h"

-#include "visualize.h"

-#include "display.h"

-

-typedef struct

-{

-    int     i_type;

-    int     i_partition;

-    int     i_sub_partition[4];

-    int     i_intra16x16_pred_mode;

-    int     intra4x4_pred_mode[4][4];

-    int8_t  ref[2][4][4];                  /* [list][y][x] */

-    int16_t mv[2][4][4][2];                /* [list][y][x][mvxy] */

-} visualize_t;

-

-/* Return string from stringlist corresponding to the given code */

-#define GET_STRING(sl, code) get_string((sl), sizeof(sl)/sizeof(*(sl)), code)

-

-typedef struct

-{

-    int code;

-    char *string;

-} stringlist_t;

-

-static char *get_string( const stringlist_t *sl, int entries, int code )

-{

-    for( int i = 0; i < entries; i++ )

-        if( sl[i].code == code )

-            return sl[i].string;

-    return "?";

-}

-

-/* Plot motion vector */

-static void mv( int x0, int y0, int16_t dmv[2], int ref, int zoom, char *col )

-{

-    int dx = dmv[0];

-    int dy = dmv[1];

-

-    dx = (dx * zoom + 2) >> 2;

-    dy = (dy * zoom + 2) >> 2;

-    disp_line( 0, x0, y0, x0+dx, y0+dy );

-    for( int i = 1; i < ref; i++ )

-    {

-        disp_line( 0, x0  , y0-i, x0+i, y0   );

-        disp_line( 0, x0+i, y0  , x0  , y0+i );

-        disp_line( 0, x0  , y0+i, x0-i, y0   );

-        disp_line( 0, x0-i, y0  , x0  , y0-i );

-    }

-    disp_setcolor( "black" );

-    disp_point( 0, x0, y0 );

-    disp_setcolor( col );

-}

-

-int x264_visualize_init( x264_t *h )

-{

-    CHECKED_MALLOC( h->visualize, h->mb.i_mb_width * h->mb.i_mb_height * sizeof(visualize_t) );

-    return 0;

-fail:

-    return -1;

-}

-

-void x264_visualize_mb( x264_t *h )

-{

-    visualize_t *v = (visualize_t*)h->visualize + h->mb.i_mb_xy;

-

-    /* Save all data for the MB that we need for drawing the visualization */

-    v->i_type = h->mb.i_type;

-    v->i_partition = h->mb.i_partition;

-    for( int i = 0; i < 4; i++ )

-        v->i_sub_partition[i] = h->mb.i_sub_partition[i];

-    for( int y = 0; y < 4; y++ )

-        for( int x = 0; x < 4; x++ )

-            v->intra4x4_pred_mode[y][x] = h->mb.cache.intra4x4_pred_mode[X264_SCAN8_0+y*8+x];

-    for( int l = 0; l < 2; l++ )

-        for( int y = 0; y < 4; y++ )

-            for( int x = 0; x < 4; x++ )

-            {

-                for( int i = 0; i < 2; i++ )

-                    v->mv[l][y][x][i] = h->mb.cache.mv[l][X264_SCAN8_0+y*8+x][i];

-                v->ref[l][y][x] = h->mb.cache.ref[l][X264_SCAN8_0+y*8+x];

-            }

-    v->i_intra16x16_pred_mode = h->mb.i_intra16x16_pred_mode;

-}

-

-void x264_visualize_close( x264_t *h )

-{

-    x264_free(h->visualize);

-}

-

-/* Display visualization (block types, MVs) of the encoded frame */

-/* FIXME: B-type MBs not handled yet properly */

-void x264_visualize_show( x264_t *h )

-{

-    static const stringlist_t mb_types[] =

-    {

-        /* Block types marked as NULL will not be drawn */

-        { I_4x4   , "red" },

-        { I_8x8   , "#ff5640" },

-        { I_16x16 , "#ff8060" },

-        { I_PCM   , "violet" },

-        { P_L0    , "SlateBlue" },

-        { P_8x8   , "blue" },

-        { P_SKIP  , "green" },

-        { B_DIRECT, "yellow" },

-        { B_L0_L0 , "yellow" },

-        { B_L0_L1 , "yellow" },

-        { B_L0_BI , "yellow" },

-        { B_L1_L0 , "yellow" },

-        { B_L1_L1 , "yellow" },

-        { B_L1_BI , "yellow" },

-        { B_BI_L0 , "yellow" },

-        { B_BI_L1 , "yellow" },

-        { B_BI_BI , "yellow" },

-        { B_8x8   , "yellow" },

-        { B_SKIP  , "yellow" },

-    };

-

-    static const int waitkey = 1;     /* Wait for enter after each frame */

-    static const int drawbox = 1;     /* Draw box around each block */

-    static const int borders = 0;     /* Display extrapolated borders outside frame */

-    static const int zoom = 2;        /* Zoom factor */

-

-    static const int pad = 32;

-    pixel *const frame = h->fdec->plane[0];

-    const int width = h->param.i_width;

-    const int height = h->param.i_height;

-    const int stride = h->fdec->i_stride[0];

-

-    if( borders )

-        disp_gray_zoom( 0, frame - pad*stride - pad, width+2*pad, height+2*pad, stride, "fdec", zoom );

-    else

-        disp_gray_zoom( 0, frame, width, height, stride, "fdec", zoom );

-

-    for( int mb_xy = 0; mb_xy < h->mb.i_mb_width * h->mb.i_mb_height; mb_xy++ )

-    {

-        visualize_t *const v = (visualize_t*)h->visualize + mb_xy;

-        const int mb_y = mb_xy / h->mb.i_mb_width;

-        const int mb_x = mb_xy % h->mb.i_mb_width;

-        char *const col = GET_STRING( mb_types, v->i_type );

-        int x = mb_x*16*zoom;

-        int y = mb_y*16*zoom;

-        int l = 0;

-

-        if( !col )

-            continue;

-

-        if( borders )

-        {

-            x += pad*zoom;

-            y += pad*zoom;

-        }

-

-        disp_setcolor( col );

-        if( drawbox ) disp_rect( 0, x, y, x+16*zoom-1, y+16*zoom-1 );

-

-        if( v->i_type==P_L0 || v->i_type==P_8x8 || v->i_type==P_SKIP )

-        {

-            /* Predicted (inter) mode, with motion vector */

-            if( v->i_partition == D_16x16 || v->i_type == P_SKIP )

-                mv( x+8*zoom, y+8*zoom, v->mv[l][0][0], v->ref[l][0][0], zoom, col );

-            else if (v->i_partition == D_16x8)

-            {

-                if( drawbox ) disp_rect( 0, x, y, x+16*zoom, y+8*zoom );

-                mv( x+8*zoom, y+4*zoom, v->mv[l][0][0], v->ref[l][0][0], zoom, col );

-                if( drawbox ) disp_rect( 0, x, y+8*zoom, x+16*zoom, y+16*zoom );

-                mv( x+8*zoom, y+12*zoom, v->mv[l][2][0], v->ref[l][2][0], zoom, col );

-            }

-            else if( v->i_partition==D_8x16 )

-            {

-                if( drawbox ) disp_rect( 0, x,          y, x+8*zoom,  y+16*zoom );

-                mv( x+4*zoom, y+8*zoom, v->mv[l][0][0], v->ref[l][0][0], zoom, col );

-                if( drawbox ) disp_rect( 0, x+8*zoom,   y, x+16*zoom, y+16*zoom );

-                mv( x+12*zoom, y+8*zoom, v->mv[l][0][2], v->ref[l][0][2], zoom, col );

-            }

-            else if( v->i_partition==D_8x8 )

-            {

-                for( int i = 0; i < 2; i++ )

-                    for( int j = 0; j < 2; j++ )

-                    {

-                        int sp = v->i_sub_partition[i*2+j];

-                        const int x0 = x + j*8*zoom;

-                        const int y0 = y + i*8*zoom;

-                        l = x264_mb_partition_listX_table[0][sp] ? 0 : 1; /* FIXME: not tested if this works */

-                        if( IS_SUB8x8(sp) )

-                        {

-                            if( drawbox ) disp_rect( 0, x0, y0, x0+8*zoom, y0+8*zoom );

-                            mv( x0+4*zoom, y0+4*zoom, v->mv[l][2*i][2*j], v->ref[l][2*i][2*j], zoom, col );

-                        }

-                        else if( IS_SUB8x4(sp) )

-                        {

-                            if( drawbox ) disp_rect( 0, x0, y0, x0+8*zoom, y0+4*zoom );

-                            if( drawbox ) disp_rect( 0, x0, y0+4*zoom, x0+8*zoom, y0+8*zoom );

-                            mv( x0+4*zoom, y0+2*zoom, v->mv[l][2*i][2*j], v->ref[l][2*i][2*j], zoom, col );

-                            mv( x0+4*zoom, y0+6*zoom, v->mv[l][2*i+1][2*j], v->ref[l][2*i+1][2*j], zoom, col );

-                        }

-                        else if( IS_SUB4x8(sp) )

-                        {

-                            if( drawbox ) disp_rect( 0, x0, y0, x0+4*zoom, y0+8*zoom );

-                            if( drawbox ) disp_rect( 0, x0+4*zoom, y0, x0+8*zoom, y0+8*zoom );

-                            mv( x0+2*zoom, y0+4*zoom, v->mv[l][2*i][2*j], v->ref[l][2*i][2*j], zoom, col );

-                            mv( x0+6*zoom, y0+4*zoom, v->mv[l][2*i][2*j+1], v->ref[l][2*i][2*j+1], zoom, col );

-                        }

-                        else if( IS_SUB4x4(sp) )

-                        {

-                            if( drawbox ) disp_rect( 0, x0, y0, x0+4*zoom, y0+4*zoom );

-                            if( drawbox ) disp_rect( 0, x0+4*zoom, y0, x0+8*zoom, y0+4*zoom );

-                            if( drawbox ) disp_rect( 0, x0, y0+4*zoom, x0+4*zoom, y0+8*zoom );

-                            if( drawbox ) disp_rect( 0, x0+4*zoom, y0+4*zoom, x0+8*zoom, y0+8*zoom );

-                            mv( x0+2*zoom, y0+2*zoom, v->mv[l][2*i][2*j], v->ref[l][2*i][2*j], zoom, col );

-                            mv( x0+6*zoom, y0+2*zoom, v->mv[l][2*i][2*j+1], v->ref[l][2*i][2*j+1], zoom, col );

-                            mv( x0+2*zoom, y0+6*zoom, v->mv[l][2*i+1][2*j], v->ref[l][2*i+1][2*j], zoom, col );

-                            mv( x0+6*zoom, y0+6*zoom, v->mv[l][2*i+1][2*j+1], v->ref[l][2*i+1][2*j+1], zoom, col );

-                        }

-                    }

-            }

-        }

-

-        if( IS_INTRA(v->i_type) || v->i_type == I_PCM )

-        {

-            /* Intra coded */

-            if( v->i_type == I_16x16 )

-            {

-                switch (v->i_intra16x16_pred_mode) {

-                case I_PRED_16x16_V:

-                    disp_line( 0, x+2*zoom, y+2*zoom, x+14*zoom, y+2*zoom );

-                    break;

-                case I_PRED_16x16_H:

-                    disp_line( 0, x+2*zoom, y+2*zoom, x+2*zoom, y+14*zoom );

-                    break;

-                case I_PRED_16x16_DC:

-                case I_PRED_16x16_DC_LEFT:

-                case I_PRED_16x16_DC_TOP:

-                case I_PRED_16x16_DC_128:

-                    disp_line( 0, x+2*zoom, y+2*zoom, x+14*zoom, y+2*zoom );

-                    disp_line( 0, x+2*zoom, y+2*zoom, x+2*zoom, y+14*zoom );

-                    break;

-                case I_PRED_16x16_P:

-                    disp_line( 0, x+2*zoom, y+2*zoom, x+8*zoom, y+8*zoom );

-                    break;

-                }

-            }

-            if( v->i_type==I_4x4 || v->i_type==I_8x8 )

-            {

-                const int di = v->i_type == I_8x8 ? 2 : 1;

-                const int zoom2 = zoom * di;

-                for( int i = 0; i < 4; i += di )

-                    for( int j = 0; j < 4; j += di )

-                    {

-                        const int x0 = x + j*4*zoom;

-                        const int y0 = y + i*4*zoom;

-                        if( drawbox ) disp_rect( 0, x0, y0, x0+4*zoom2, y0+4*zoom2 );

-                        switch( v->intra4x4_pred_mode[i][j] )

-                        {

-                            case I_PRED_4x4_V:        /* Vertical */

-                                disp_line( 0, x0+0*zoom2, y0+1*zoom2, x0+4*zoom2, y0+1*zoom2 );

-                                break;

-                            case I_PRED_4x4_H:        /* Horizontal */

-                                disp_line( 0, x0+1*zoom2, y0+0*zoom2, x0+1*zoom2, y0+4*zoom2 );

-                                break;

-                            case I_PRED_4x4_DC:        /* DC, average from top and left sides */

-                            case I_PRED_4x4_DC_LEFT:

-                            case I_PRED_4x4_DC_TOP:

-                            case I_PRED_4x4_DC_128:

-                                disp_line( 0, x0+1*zoom2, y0+1*zoom2, x0+4*zoom2, y0+1*zoom2 );

-                                disp_line( 0, x0+1*zoom2, y0+1*zoom2, x0+1*zoom2, y0+4*zoom2 );

-                                break;

-                            case I_PRED_4x4_DDL:    /* Topright-bottomleft */

-                                disp_line( 0, x0+0*zoom2, y0+0*zoom2, x0+4*zoom2, y0+4*zoom2 );

-                                break;

-                            case I_PRED_4x4_DDR:    /* Topleft-bottomright */

-                                disp_line( 0, x0+0*zoom2, y0+4*zoom2, x0+4*zoom2, y0+0*zoom2 );

-                                break;

-                            case I_PRED_4x4_VR:        /* Mix of topleft-bottomright and vertical */

-                                disp_line( 0, x0+0*zoom2, y0+2*zoom2, x0+4*zoom2, y0+1*zoom2 );

-                                break;

-                            case I_PRED_4x4_HD:        /* Mix of topleft-bottomright and horizontal */

-                                disp_line( 0, x0+2*zoom2, y0+0*zoom2, x0+1*zoom2, y0+4*zoom2 );

-                                break;

-                            case I_PRED_4x4_VL:        /* Mix of topright-bottomleft and vertical */

-                                disp_line( 0, x0+0*zoom2, y0+1*zoom2, x0+4*zoom2, y0+2*zoom2 );

-                                break;

-                            case I_PRED_4x4_HU:        /* Mix of topright-bottomleft and horizontal */

-                                disp_line( 0, x0+1*zoom2, y0+0*zoom2, x0+2*zoom2, y0+4*zoom2 );

-                                break;

-                        }

-                    }

-            }

-        }

-    }

-

-    disp_sync();

-    if( waitkey )

-        getchar();

-}

-/* }}} */

-

-//EOF

​

@@ -1,36 +0,0 @@

-/*****************************************************************************

- * visualize.h: visualization

- *****************************************************************************

- * Copyright (C) 2005-2013 x264 project

- *

- * Authors: Tuukka Toivonen <tuukkat@ee.oulu.fi>

- *

- * This program is free software; you can redistribute it and/or modify

- * it under the terms of the GNU General Public License as published by

- * the Free Software Foundation; either version 2 of the License, or

- * (at your option) any later version.

- *

- * This program is distributed in the hope that it will be useful,

- * but WITHOUT ANY WARRANTY; without even the implied warranty of

- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

- * GNU General Public License for more details.

- *

- * You should have received a copy of the GNU General Public License

- * along with this program; if not, write to the Free Software

- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111, USA.

- *

- * This program is also available under a commercial proprietary license.

- * For more information, contact us at licensing@x264.com.

- *****************************************************************************/

-

-#ifndef X264_VISUALIZE_H

-#define X264_VISUALIZE_H

-

-#include "common/common.h"

-

-int  x264_visualize_init( x264_t *h );

-void x264_visualize_mb( x264_t *h );

-void x264_visualize_show( x264_t *h );

-void x264_visualize_close( x264_t *h );

-

-#endif

​

@@ -1,792 +0,0 @@

-/*****************************************************************************

- * xyuv.c: a SDL yuv 420 planer viewer.

- *****************************************************************************

- * Copyright (C) 2004 Laurent Aimar <fenrir@via.ecp.fr>

- *

- * This program is free software; you can redistribute it and/or modify

- * it under the terms of the GNU General Public License as published by

- * the Free Software Foundation; either version 2 of the License, or

- * (at your option) any later version.

- *

- * This program is distributed in the hope that it will be useful,

- * but WITHOUT ANY WARRANTY; without even the implied warranty of

- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

- * GNU General Public License for more details.

- *

- * You should have received a copy of the GNU General Public License

- * along with this program; if not, write to the Free Software

- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111, USA.

- *****************************************************************************/

-

-#include <stdlib.h>

-#include <stdio.h>

-#include <string.h>

-#include <stdint.h>

-

-#include <SDL/SDL.h>

-

-#define YUV_MAX 20

-#define SDL_TITLE "xyuv: %s - %d/%d - %.2ffps"

-typedef struct

-{

-    /* globals */

-    int     i_width;

-    int     i_height;

-    int     i_frame_size;

-    int     i_frame;

-    int     i_frames;

-    float   f_fps;

-

-    float   f_y;

-

-    int     b_pause;

-    int     b_grid;

-    int     b_split;

-    int     b_diff;

-    int     i_join;

-

-    /* Constructed picture */

-    int     i_wall_width;   /* in picture count */

-

-    /* YUV files */

-    int     i_yuv;

-    struct

-    {

-        char    *name;

-        FILE    *f;         /* handles */

-        int     i_frames;   /* frames count */

-

-        /* Position in the whole picture */

-        int     x, y;

-    } yuv[YUV_MAX];

-

-    /* SDL */

-    int i_sdl_width;

-    int i_sdl_height;

-

-    int i_display_width;

-    int i_display_height;

-    char *title;

-

-    SDL_Surface *screen;

-    SDL_Overlay *overlay;

-

-    /* */

-    uint8_t *pic;

-

-} xyuv_t;

-

-xyuv_t xyuv = {

-    .i_width = 0,

-    .i_height = 0,

-    .i_frame  = 1,

-    .i_frames = 0,

-    .f_fps = 25.0,

-    .f_y = 0.0,

-    .i_wall_width = 0,

-

-    .i_yuv = 0,

-

-    .b_pause = 0,

-    .b_split = 0,

-    .b_diff = 0,

-    .i_join = -1,

-

-    .title = NULL,

-    .pic = NULL,

-};

-

-static void help( void )

-{

-    fprintf( stderr,

-             "Syntax: xyuv [options] file [file2 ...]\n"

-             "\n"

-             "      --help                  Print this help\n"

-             "\n"

-             "  -s, --size <WIDTHxHEIGHT>   Set input size\n"

-             "  -w, --width <integer>       Set width\n"

-             "  -h, --height <integer>      Set height\n"

-             "\n"

-             "  -S, --split                 Show splited Y/U/V planes\n"

-             "  -d, --diff                  Show difference (only 2 files) in split mode\n"

-             "  -j, --joint <integer>\n"

-             "\n"

-             "  -y <float>                  Set Y factor\n"

-             "\n"

-             "  -g, --grid                  Show a grid (macroblock 16x16)\n"

-             "  -W <integer>                Set wall width (in picture count)\n"

-             "  -f, --fps <float>           Set fps\n"

-             "\n" );

-}

-

-static void xyuv_count_frames( xyuv_t *xyuv );

-static void xyuv_detect( int *pi_width, int *pi_height );

-static void xyuv_display( xyuv_t *xyuv, int i_frame );

-

-int main( int argc, char **argv )

-{

-    int i;

-

-    /* Parse commande line */

-    for( i = 1; i < argc; i++ ) {

-        if( !strcasecmp( argv[i], "--help" ) ) {

-            help();

-            return 0;

-        }

-        if( !strcmp( argv[i], "-d" ) || !strcasecmp( argv[i], "--diff" ) ) {

-            xyuv.b_diff = 1;

-        } else if( !strcmp( argv[i], "-S" ) || !strcasecmp( argv[i], "--split" ) ) {

-            xyuv.b_split = 1;

-        } else if( !strcmp( argv[i], "-f" ) || !strcasecmp( argv[i], "--fps" ) ) {

-            if( i >= argc -1 ) goto err_missing_arg;

-            xyuv.f_fps = atof( argv[++i] );

-        } else if( !strcmp( argv[i], "-h" ) || !strcasecmp( argv[i], "--height" ) ) {

-            if( i >= argc -1 ) goto err_missing_arg;

-            xyuv.i_height = atoi( argv[++i] );

-        } else if( !strcmp( argv[i], "-w" ) || !strcasecmp( argv[i], "--width" ) ) {

-            if( i >= argc -1 ) goto err_missing_arg;

-            xyuv.i_width = atoi( argv[++i] );

-        } else if( !strcmp( argv[i], "-s" ) || !strcasecmp( argv[i], "--size" ) ) {

-            char *p;

-

-            if( i >= argc -1 ) goto err_missing_arg;

-

-            xyuv.i_width = strtol( argv[++i], &p, 0 );

-            p++;

-            xyuv.i_height = atoi( p );

-        } else if( !strcmp( argv[i], "-W" ) ) {

-            if( i >= argc -1 ) goto err_missing_arg;

-            xyuv.i_wall_width = atoi( argv[++i] );

-        } else if( !strcmp( argv[i], "-y" ) ) {

-            if( i >= argc -1 ) goto err_missing_arg;

-            xyuv.f_y = atof( argv[++i] );

-        } else if( !strcmp( argv[i], "-j" ) || !strcasecmp( argv[i], "--join" ) ) {

-            if( i >= argc -1 ) goto err_missing_arg;

-            xyuv.i_join = atoi( argv[++i] );

-        } else if( !strcmp( argv[i], "-g" ) || !strcasecmp( argv[i], "--grid" ) ) {

-            xyuv.b_grid = 1;

-        } else {

-            FILE *f = fopen( argv[i], "rb" );

-            if( !f ) {

-                fprintf( stderr, "cannot open YUV %s\n", argv[i] );

-            } else {

-                xyuv.yuv[xyuv.i_yuv].name = strdup( argv[i] );

-                xyuv.yuv[xyuv.i_yuv].f = f;

-                xyuv.yuv[xyuv.i_yuv].i_frames = 0;

-

-                xyuv.i_yuv++;

-            }

-        }

-    }

-

-    if( xyuv.i_yuv == 0 ) {

-        fprintf( stderr, "no file to display\n" );

-        return -1;

-    }

-    if( xyuv.i_width == 0 || xyuv.i_height == 0 ) {

-        char *psz = xyuv.yuv[0].name;

-        char *num;

-        char *x;

-        /* See if we find widthxheight in the file name */

-        for( ;; ) {

-            if( !( x = strchr( psz+1, 'x' ) ) ) {

-                break;

-            }

-            num = x;

-            while( num > psz && num[-1] >= '0' && num[-1] <= '9' )

-                num--;

-

-            if( num != x && x[1] >= '0' && x[1] <= '9' ) {

-                xyuv.i_width = atoi( num );

-                xyuv.i_height = atoi( x+1 );

-                break;

-            }

-            psz = x;

-        }

-        fprintf( stderr, "file name gives %dx%d\n", xyuv.i_width, xyuv.i_height );

-    }

-

-    if( xyuv.i_width == 0 || xyuv.i_height == 0 ) {

-        xyuv_detect( &xyuv.i_width, &xyuv.i_height );

-    }

-

-    if( xyuv.i_width == 0 || xyuv.i_height == 0 ) {

-        fprintf( stderr, "invalid or missing frames size\n" );

-        return -1;

-    }

-    if( xyuv.b_diff && xyuv.i_yuv != 2 ) {

-        fprintf( stderr, "--diff works only with 2 files\n" );

-        return -1;

-    }

-    if( (xyuv.i_join == 0 || xyuv.i_join >= xyuv.i_width) && xyuv.i_yuv != 2 ) {

-        fprintf( stderr, "--join woeks only with two files and range is [1, width-1]\n" );

-        return -1;

-    }

-    if( xyuv.i_join % 2 != 0 ) {

-        if( xyuv.i_join + 1 < xyuv.i_width )

-            xyuv.i_join++;

-        else

-            xyuv.i_join--;

-    }

-

-    /* Now check frames */

-    fprintf( stderr, "displaying :\n" );

-    xyuv.i_frame_size = 3 * xyuv.i_width * xyuv.i_height / 2;

-    xyuv_count_frames( &xyuv );

-    for( i = 0; i < xyuv.i_yuv; i++ ) {

-        fprintf( stderr, " - '%s' : %d frames\n", xyuv.yuv[i].name, xyuv.yuv[i].i_frames );

-    }

-

-    if( xyuv.i_frames == 0 ) {

-        fprintf( stderr, "no frames to display\n" );

-    }

-

-    xyuv.pic = malloc( xyuv.i_frame_size );

-

-    /* calculate SDL view */

-    if( xyuv.i_wall_width > xyuv.i_yuv ) {

-        xyuv.i_wall_width = xyuv.i_yuv;

-    }

-    if( xyuv.i_wall_width == 0 ) {

-        while( xyuv.i_wall_width < xyuv.i_yuv && xyuv.i_wall_width * xyuv.i_wall_width < xyuv.i_yuv ) {

-            xyuv.i_wall_width++;

-        }

-    }

-

-    for( i = 0; i < xyuv.i_yuv; i++ ) {

-        if( xyuv.b_diff || xyuv.i_join > 0 ) {

-            xyuv.yuv[i].x = 0;

-            xyuv.yuv[i].y = 0;

-        } else if( xyuv.b_split ) {

-            xyuv.yuv[i].x = (i%xyuv.i_wall_width) * 3 * xyuv.i_width / 2;

-            xyuv.yuv[i].y = (i/xyuv.i_wall_width) * xyuv.i_height;

-        } else {

-            xyuv.yuv[i].x = (i%xyuv.i_wall_width) * xyuv.i_width;

-            xyuv.yuv[i].y = (i/xyuv.i_wall_width) * xyuv.i_height;

-        }

-    }

-    if( xyuv.b_diff ) {

-        xyuv.i_sdl_width = 3 * xyuv.i_width / 2;

-        xyuv.i_sdl_height= xyuv.i_height;

-    } else if( xyuv.i_join > 0 ) {

-        xyuv.i_sdl_width = xyuv.i_width;

-        xyuv.i_sdl_height= xyuv.i_height;

-    } else if( xyuv.b_split ) {

-        xyuv.i_sdl_width = xyuv.i_wall_width * 3 * xyuv.i_width / 2;

-        xyuv.i_sdl_height= xyuv.i_height * ( ( xyuv.i_yuv  + xyuv.i_wall_width - 1 ) / xyuv.i_wall_width );

-    } else {

-        xyuv.i_sdl_width = xyuv.i_wall_width * xyuv.i_width;

-        xyuv.i_sdl_height= xyuv.i_height * ( ( xyuv.i_yuv  + xyuv.i_wall_width - 1 ) / xyuv.i_wall_width );

-    }

-    xyuv.i_display_width = xyuv.i_sdl_width;

-    xyuv.i_display_height = xyuv.i_sdl_height;

-

-    /* Open SDL */

-    if( SDL_Init( SDL_INIT_EVENTTHREAD|SDL_INIT_NOPARACHUTE|SDL_INIT_VIDEO) ) {

-        fprintf( stderr, "cannot init SDL\n" );

-        return -1;

-    }

-

-    SDL_EnableKeyRepeat(SDL_DEFAULT_REPEAT_DELAY, 100 );

-    SDL_EventState( SDL_KEYUP, SDL_IGNORE );

-

-    xyuv.screen = SDL_SetVideoMode( xyuv.i_sdl_width, xyuv.i_sdl_height, 0,

-                                    SDL_HWSURFACE|SDL_RESIZABLE|

-                                    SDL_ASYNCBLIT|SDL_HWACCEL );

-    if( xyuv.screen == NULL ) {

-        fprintf( stderr, "SDL_SetVideoMode failed\n" );

-        return -1;

-    }

-

-    SDL_LockSurface( xyuv.screen );

-    xyuv.overlay = SDL_CreateYUVOverlay( xyuv.i_sdl_width, xyuv.i_sdl_height,

-                                         SDL_YV12_OVERLAY,

-                                         xyuv.screen );

-    /* reset with black */

-    memset( xyuv.overlay->pixels[0],   0, xyuv.overlay->pitches[0] * xyuv.i_sdl_height );

-    memset( xyuv.overlay->pixels[1], 128, xyuv.overlay->pitches[1] * xyuv.i_sdl_height / 2);

-    memset( xyuv.overlay->pixels[2], 128, xyuv.overlay->pitches[2] * xyuv.i_sdl_height / 2);

-    SDL_UnlockSurface( xyuv.screen );

-

-    if( xyuv.overlay == NULL ) {

-        fprintf( stderr, "recon: SDL_CreateYUVOverlay failed\n" );

-        return -1;

-    }

-

-    for( ;; ) {

-        SDL_Event event;

-        static int b_fullscreen = 0;

-        int64_t i_start = SDL_GetTicks();

-        int i_wait;

-

-        if( !xyuv.b_pause ) {

-            xyuv_display( &xyuv, xyuv.i_frame );

-        }

-

-        for( ;; ) {

-            int b_refresh = 0;

-            while( SDL_PollEvent( &event ) )  {

-                switch( event.type )

-                {

-                    case SDL_QUIT:

-                        if( b_fullscreen )

-                            SDL_WM_ToggleFullScreen( xyuv.screen );

-                        exit( 1 );

-

-                    case SDL_KEYDOWN:

-                        switch( event.key.keysym.sym )

-                        {

-                            case SDLK_q:

-                            case SDLK_ESCAPE:

-                                if( b_fullscreen )

-                                    SDL_WM_ToggleFullScreen( xyuv.screen );

-                                exit(1);

-

-                            case SDLK_f:

-                                if( SDL_WM_ToggleFullScreen( xyuv.screen ) )

-                                    b_fullscreen = 1 - b_fullscreen;

-                                break;

-

-                            case SDLK_g:

-                                if( xyuv.b_grid )

-                                    xyuv.b_grid = 0;

-                                else

-                                    xyuv.b_grid = 1;

-                                if( xyuv.b_pause )

-                                    b_refresh = 1;

-                                break;

-

-                            case SDLK_SPACE:

-                                if( xyuv.b_pause )

-                                    xyuv.b_pause = 0;

-                                else

-                                    xyuv.b_pause = 1;

-                                break;

-                            case SDLK_LEFT:

-                                if( xyuv.i_frame > 1 ) xyuv.i_frame--;

-                                b_refresh = 1;

-                                break;

-

-                            case SDLK_RIGHT:

-                                if( xyuv.i_frame >= xyuv.i_frames )

-                                    xyuv_count_frames( &xyuv );

-                                if( xyuv.i_frame < xyuv.i_frames ) xyuv.i_frame++;

-                                b_refresh = 1;

-                                break;

-

-                            case SDLK_HOME:

-                                xyuv.i_frame = 1;

-                                if( xyuv.b_pause )

-                                    b_refresh = 1;

-                                break;

-

-                            case SDLK_END:

-                                xyuv_count_frames( &xyuv );

-                                xyuv.i_frame = xyuv.i_frames;

-                                b_refresh = 1;

-                                break;

-

-                            case SDLK_UP:

-                                xyuv.i_frame += xyuv.i_frames / 20;

-

-                                if( xyuv.i_frame >= xyuv.i_frames )

-                                    xyuv_count_frames( &xyuv );

-

-                                if( xyuv.i_frame > xyuv.i_frames )

-                                    xyuv.i_frame = xyuv.i_frames;

-                                b_refresh = 1;

-                                break;

-

-                            case SDLK_DOWN:

-                                xyuv.i_frame -= xyuv.i_frames / 20;

-                                if( xyuv.i_frame < 1 )

-                                    xyuv.i_frame = 1;

-                                b_refresh = 1;

-                                break;

-

-                            case SDLK_PAGEUP:

-                                xyuv.i_frame += xyuv.i_frames / 10;

-

-                                if( xyuv.i_frame >= xyuv.i_frames )

-                                    xyuv_count_frames( &xyuv );

-

-                                if( xyuv.i_frame > xyuv.i_frames )

-                                    xyuv.i_frame = xyuv.i_frames;

-                                b_refresh = 1;

-                                break;

-

-                            case SDLK_PAGEDOWN:

-                                xyuv.i_frame -= xyuv.i_frames / 10;

-                                if( xyuv.i_frame < 1 )

-                                    xyuv.i_frame = 1;

-                                b_refresh = 1;

-                                break;

-

-                            default:

-                                break;

-                        }

-                        break;

-                    case SDL_VIDEORESIZE:

-                        xyuv.i_display_width = event.resize.w;

-                        xyuv.i_display_height = event.resize.h;

-                        xyuv.screen = SDL_SetVideoMode( xyuv.i_display_width, xyuv.i_display_height, 0,

-                                                        SDL_HWSURFACE|SDL_RESIZABLE|

-                                                        SDL_ASYNCBLIT|SDL_HWACCEL );

-                        xyuv_display( &xyuv, xyuv.i_frame );

-                        break;

-

-                    default:

-                        break;

-                }

-            }

-            if( b_refresh ) {

-                xyuv.b_pause = 1;

-                xyuv_display( &xyuv, xyuv.i_frame );

-            }

-            /* wait */

-            i_wait = 1000 / xyuv.f_fps - ( SDL_GetTicks() - i_start);

-            if( i_wait < 0 )

-                break;

-            else if( i_wait > 200 )

-                SDL_Delay( 200 );

-            else {

-                SDL_Delay( i_wait );

-                break;

-            }

-        }

-        if( !xyuv.b_pause ) {

-            /* next frame */

-            if( xyuv.i_frame == xyuv.i_frames )

-                    xyuv.b_pause = 1;

-            else if( xyuv.i_frame < xyuv.i_frames )

-                xyuv.i_frame++;

-        }

-    }

-

-

-    return 0;

-

-err_missing_arg:

-    fprintf( stderr, "missing arg for option=%s\n", argv[i] );

-    return -1;

-}

-

-

-static void xyuv_display( xyuv_t *xyuv, int i_frame )

-{

-    SDL_Rect rect;

-    int i_picture = 0;

-    int i;

-

-    if( i_frame > xyuv->i_frames )

-        return;

-

-    xyuv->i_frame = i_frame;

-

-    /* Load and copy pictue data */

-    for( i = 0; i < xyuv->i_yuv; i++ ) {

-        int i_plane;

-

-        fprintf( stderr, "yuv[%d] %d/%d\n", i, i_frame, xyuv->yuv[i].i_frames );

-        if( i_frame - 1 >= xyuv->yuv[i].i_frames ) {

-            xyuv_count_frames( xyuv );

-            if( i_frame - 1 >= xyuv->yuv[i].i_frames )

-                continue;

-        }

-        i_picture++;

-

-        fseek( xyuv->yuv[i].f, (xyuv->i_frame-1) * xyuv->i_frame_size, SEEK_SET );

-        fread( xyuv->pic, xyuv->i_frame_size, 1, xyuv->yuv[i].f );

-

-        SDL_LockYUVOverlay( xyuv->overlay );

-

-        if( xyuv->b_diff || xyuv->b_split ) {

-            /* Reset UV */

-            for( i_plane = 1; i_plane < 3; i_plane++ ) {

-                memset( xyuv->overlay->pixels[i_plane], 128, xyuv->overlay->pitches[i_plane] * xyuv->overlay->h / 2 );

-            }

-            /* Show diff in Y plane of overlay */

-

-            for( i_plane = 0; i_plane < 3; i_plane++ ) {

-                int div = i_plane == 0 ? 1 : 2;

-                uint8_t *src = xyuv->pic;

-                uint8_t *dst = xyuv->overlay->pixels[0] +

-                                (xyuv->yuv[i].x + xyuv->yuv[i].y * xyuv->overlay->pitches[0] );

-                int j;

-                if( i_plane == 1 ) {

-                    src +=  5*xyuv->i_width * xyuv->i_height/4;

-                    dst += xyuv->i_width;

-                } else if( i_plane == 2 ) {

-                    src += xyuv->i_width * xyuv->i_height;

-                    dst += xyuv->i_width + xyuv->i_height / 2 * xyuv->overlay->pitches[0];

-                }

-

-                for( j = 0; j < xyuv->i_height / div; j++ ) {

-                    if( i_picture == 1 || xyuv->b_split ) {

-                        memcpy( dst, src, xyuv->i_width / div );

-                    } else {

-                        int k;

-                        for( k = 0; k < xyuv->i_width / div; k++ ) {

-                            dst[k] = abs( dst[k] - src[k]);

-                        }

-                    }

-                    src += xyuv->i_width / div;

-                    dst += xyuv->overlay->pitches[0];

-                }

-            }

-        } else {

-            for( i_plane = 0; i_plane < 3; i_plane++ ) {

-                int div = i_plane == 0 ? 1 : 2;

-                uint8_t *src = xyuv->pic;

-                uint8_t *dst = xyuv->overlay->pixels[i_plane] +

-                                ((xyuv->yuv[i].x + xyuv->yuv[i].y * xyuv->overlay->pitches[i_plane] ) / div );

-                int w = xyuv->i_width / div;

-                int j;

-

-                if( i_plane == 1 ) {

-                    src +=  5*xyuv->i_width * xyuv->i_height/4;

-                } else if( i_plane == 2 ) {

-                    src += xyuv->i_width * xyuv->i_height;

-                }

-                if( xyuv->i_join > 0 ) {

-                    if( i_picture > 1 ) {

-                        src += xyuv->i_join / div;

-                        dst += xyuv->i_join / div;

-                        w = (xyuv->i_width - xyuv->i_join) /div;

-                    } else {

-                        w = xyuv->i_join / div;

-                    }

-                }

-

-                for( j = 0; j < xyuv->i_height / div; j++ ) {

-                    memcpy( dst, src, w );

-                    src += xyuv->i_width / div;

-                    dst += xyuv->overlay->pitches[i_plane];

-                }

-            }

-        }

-

-        SDL_UnlockYUVOverlay( xyuv->overlay );

-    }

-

-    if( xyuv->f_y != 0.0 ) {

-        uint8_t *pix = xyuv->overlay->pixels[0];

-        int j;

-

-        for( j = 0; j < xyuv->i_sdl_height; j++ ) {

-            int k;

-            for( k = 0; k < xyuv->i_sdl_width; k++ ) {

-                int v= pix[k] * xyuv->f_y;

-                if( v > 255 )

-                    pix[k] = 255;

-                else if( v < 0 )

-                    pix[k] = 0;

-                else

-                    pix[k] = v;

-            }

-            pix += xyuv->overlay->pitches[0];

-        }

-    }

-    if( xyuv->b_grid ) {

-        int x, y;

-

-        for( y = 0; y < xyuv->i_sdl_height; y += 4 ) {

-            uint8_t *p = xyuv->overlay->pixels[0] + y * xyuv->overlay->pitches[0];

-            for( x = 0; x < xyuv->i_sdl_width; x += 4 ) {

-                if( x%16== 0 || y%16 == 0 )

-                    p[x] = 0;

-            }

-        }

-    }

-

-    /* Update display */

-    rect.x = 0;

-    rect.y = 0;

-    rect.w = xyuv->i_display_width;

-    rect.h = xyuv->i_display_height;

-    SDL_DisplayYUVOverlay( xyuv->overlay, &rect );

-