git.sesse.net Git - vlc/blob - modules/video_filter/transform.c

   1 /*****************************************************************************
   2  * transform.c : transform image module for vlc
   3  *****************************************************************************
   4  * Copyright (C) 2000-2006 the VideoLAN team
   5  * $Id$
   6  *
   7  * Authors: Samuel Hocevar <sam@zoy.org>
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation; either version 2 of the License, or
  12  * (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  22  *****************************************************************************/
  23
  24 /*****************************************************************************
  25  * Preamble
  26  *****************************************************************************/
  27
  28 #ifdef HAVE_CONFIG_H
  29 # include "config.h"
  30 #endif
  31
  32 #include <vlc_common.h>
  33 #include <vlc_plugin.h>
  34 #include <vlc_vout.h>
  35
  36 #include "filter_common.h"
  37 #include "filter_picture.h"
  38
  39 #define TRANSFORM_MODE_HFLIP   1
  40 #define TRANSFORM_MODE_VFLIP   2
  41 #define TRANSFORM_MODE_90      3
  42 #define TRANSFORM_MODE_180     4
  43 #define TRANSFORM_MODE_270     5
  44
  45 /*****************************************************************************
  46  * Local prototypes
  47  *****************************************************************************/
  48 static int  Create    ( vlc_object_t * );
  49 static void Destroy   ( vlc_object_t * );
  50
  51 static int  Init      ( vout_thread_t * );
  52 static void End       ( vout_thread_t * );
  53 static void Render    ( vout_thread_t *, picture_t * );
  54
  55 static void FilterPlanar( vout_thread_t *, const picture_t *, picture_t * );
  56 static void FilterI422( vout_thread_t *, const picture_t *, picture_t * );
  57 static void FilterYUYV( vout_thread_t *, const picture_t *, picture_t * );
  58
  59 static int  MouseEvent( vlc_object_t *, char const *,
  60                         vlc_value_t, vlc_value_t, void * );
  61
  62 /*****************************************************************************
  63  * Module descriptor
  64  *****************************************************************************/
  65 #define TYPE_TEXT N_("Transform type")
  66 #define TYPE_LONGTEXT N_("One of '90', '180', '270', 'hflip' and 'vflip'")
  67
  68 static const char *const type_list[] = { "90", "180", "270", "hflip", "vflip" };
  69 static const char *const type_list_text[] = { N_("Rotate by 90 degrees"),
  70   N_("Rotate by 180 degrees"), N_("Rotate by 270 degrees"),
  71   N_("Flip horizontally"), N_("Flip vertically") };
  72
  73 #define TRANSFORM_HELP N_("Rotate or flip the video")
  74 #define CFG_PREFIX "transform-"
  75
  76 vlc_module_begin ()
  77     set_description( N_("Video transformation filter") )
  78     set_shortname( N_("Transformation"))
  79     set_help(TRANSFORM_HELP)
  80     set_capability( "video filter", 0 )
  81     set_category( CAT_VIDEO )
  82     set_subcategory( SUBCAT_VIDEO_VFILTER )
  83
  84     add_string( CFG_PREFIX "type", "90", NULL,
  85                           TYPE_TEXT, TYPE_LONGTEXT, false)
  86         change_string_list( type_list, type_list_text, 0)
  87
  88     add_shortcut( "transform" )
  89     set_callbacks( Create, Destroy )
  90 vlc_module_end ()
  91
  92 static const char *const ppsz_filter_options[] = {
  93     "type", NULL
  94 };
  95
  96 /*****************************************************************************
  97  * vout_sys_t: Transform video output method descriptor
  98  *****************************************************************************
  99  * This structure is part of the video output thread descriptor.
 100  * It describes the Transform specific properties of an output thread.
 101  *****************************************************************************/
 102 struct vout_sys_t
 103 {
 104     int i_mode;
 105     bool b_rotation;
 106     vout_thread_t *p_vout;
 107
 108     void (*pf_filter)( vout_thread_t *, const picture_t *, picture_t * );
 109 };
 110
 111 /*****************************************************************************
 112  * Control: control facility for the vout (forwards to child vout)
 113  *****************************************************************************/
 114 static int Control( vout_thread_t *p_vout, int i_query, va_list args )
 115 {
 116     return vout_vaControl( p_vout->p_sys->p_vout, i_query, args );
 117 }
 118
 119 /*****************************************************************************
 120  * Create: allocates Transform video thread output method
 121  *****************************************************************************
 122  * This function allocates and initializes a Transform vout method.
 123  *****************************************************************************/
 124 static int Create( vlc_object_t *p_this )
 125 {
 126     vout_thread_t *p_vout = (vout_thread_t *)p_this;
 127     char *psz_method;
 128
 129     /* Allocate structure */
 130     p_vout->p_sys = malloc( sizeof( vout_sys_t ) );
 131     if( p_vout->p_sys == NULL )
 132         return VLC_ENOMEM;
 133
 134     p_vout->pf_init = Init;
 135     p_vout->pf_end = End;
 136     p_vout->pf_manage = NULL;
 137     p_vout->pf_render = Render;
 138     p_vout->pf_display = NULL;
 139     p_vout->pf_control = Control;
 140
 141     config_ChainParse( p_vout, CFG_PREFIX, ppsz_filter_options,
 142                            p_vout->p_cfg );
 143
 144     /* Look what method was requested */
 145     psz_method = var_CreateGetNonEmptyStringCommand( p_vout, "transform-type" );
 146
 147     switch( p_vout->fmt_in.i_chroma )
 148     {
 149         CASE_PLANAR_YUV_SQUARE
 150         case VLC_CODEC_GREY:
 151             p_vout->p_sys->pf_filter = FilterPlanar;
 152             break;
 153
 154         case VLC_CODEC_I422:
 155         case VLC_CODEC_J422:
 156             p_vout->p_sys->pf_filter = FilterI422;
 157             break;
 158
 159         CASE_PACKED_YUV_422
 160             p_vout->p_sys->pf_filter = FilterYUYV;
 161             break;
 162
 163         default:
 164             msg_Err( p_vout, "Unsupported chroma" );
 165             free( p_vout->p_sys );
 166             return VLC_EGENERIC;
 167     }
 168
 169     if( psz_method == NULL )
 170     {
 171         msg_Err( p_vout, "configuration variable %s empty", "transform-type" );
 172         msg_Err( p_vout, "no valid transform mode provided, using '90'" );
 173         p_vout->p_sys->i_mode = TRANSFORM_MODE_90;
 174         p_vout->p_sys->b_rotation = 1;
 175     }
 176     else
 177     {
 178         if( !strcmp( psz_method, "hflip" ) )
 179         {
 180             p_vout->p_sys->i_mode = TRANSFORM_MODE_HFLIP;
 181             p_vout->p_sys->b_rotation = 0;
 182         }
 183         else if( !strcmp( psz_method, "vflip" ) )
 184         {
 185             p_vout->p_sys->i_mode = TRANSFORM_MODE_VFLIP;
 186             p_vout->p_sys->b_rotation = 0;
 187         }
 188         else if( !strcmp( psz_method, "90" ) )
 189         {
 190             p_vout->p_sys->i_mode = TRANSFORM_MODE_90;
 191             p_vout->p_sys->b_rotation = 1;
 192         }
 193         else if( !strcmp( psz_method, "180" ) )
 194         {
 195             p_vout->p_sys->i_mode = TRANSFORM_MODE_180;
 196             p_vout->p_sys->b_rotation = 0;
 197         }
 198         else if( !strcmp( psz_method, "270" ) )
 199         {
 200             p_vout->p_sys->i_mode = TRANSFORM_MODE_270;
 201             p_vout->p_sys->b_rotation = 1;
 202         }
 203         else
 204         {
 205             msg_Err( p_vout, "no valid transform mode provided, using '90'" );
 206             p_vout->p_sys->i_mode = TRANSFORM_MODE_90;
 207             p_vout->p_sys->b_rotation = 1;
 208         }
 209
 210         free( psz_method );
 211     }
 212
 213     return VLC_SUCCESS;
 214 }
 215
 216 /*****************************************************************************
 217  * Init: initialize Transform video thread output method
 218  *****************************************************************************/
 219 static int Init( vout_thread_t *p_vout )
 220 {
 221     video_format_t fmt;
 222
 223     I_OUTPUTPICTURES = 0;
 224     memset( &fmt, 0, sizeof(video_format_t) );
 225
 226     /* Initialize the output structure */
 227     p_vout->output.i_chroma = p_vout->render.i_chroma;
 228     p_vout->output.i_width  = p_vout->render.i_width;
 229     p_vout->output.i_height = p_vout->render.i_height;
 230     p_vout->output.i_aspect = p_vout->render.i_aspect;
 231     p_vout->fmt_out = p_vout->fmt_in;
 232     fmt = p_vout->fmt_out;
 233
 234     /* Try to open the real video output */
 235     msg_Dbg( p_vout, "spawning the real video output" );
 236
 237     if( p_vout->p_sys->b_rotation )
 238     {
 239         fmt.i_width = p_vout->fmt_out.i_height;
 240         fmt.i_visible_width = p_vout->fmt_out.i_visible_height;
 241         fmt.i_x_offset = p_vout->fmt_out.i_y_offset;
 242
 243         fmt.i_height = p_vout->fmt_out.i_width;
 244         fmt.i_visible_height = p_vout->fmt_out.i_visible_width;
 245         fmt.i_y_offset = p_vout->fmt_out.i_x_offset;
 246
 247         fmt.i_sar_num = p_vout->fmt_out.i_sar_den;
 248         fmt.i_sar_den = p_vout->fmt_out.i_sar_num;
 249     }
 250
 251     p_vout->p_sys->p_vout = vout_Create( p_vout, &fmt );
 252
 253     /* Everything failed */
 254     if( p_vout->p_sys->p_vout == NULL )
 255     {
 256         msg_Err( p_vout, "cannot open vout, aborting" );
 257         return VLC_EGENERIC;
 258     }
 259
 260     vout_filter_AllocateDirectBuffers( p_vout, VOUT_MAX_PICTURES );
 261
 262     vout_filter_AddChild( p_vout, p_vout->p_sys->p_vout, MouseEvent );
 263
 264     return VLC_SUCCESS;
 265 }
 266
 267 /*****************************************************************************
 268  * End: terminate Transform video thread output method
 269  *****************************************************************************/
 270 static void End( vout_thread_t *p_vout )
 271 {
 272     vout_sys_t *p_sys = p_vout->p_sys;
 273
 274     vout_filter_DelChild( p_vout, p_sys->p_vout, MouseEvent );
 275     vout_CloseAndRelease( p_sys->p_vout );
 276
 277     vout_filter_ReleaseDirectBuffers( p_vout );
 278 }
 279
 280 /*****************************************************************************
 281  * Destroy: destroy Transform video thread output method
 282  *****************************************************************************
 283  * Terminate an output method created by TransformCreateOutputMethod
 284  *****************************************************************************/
 285 static void Destroy( vlc_object_t *p_this )
 286 {
 287     vout_thread_t *p_vout = (vout_thread_t *)p_this;
 288
 289     free( p_vout->p_sys );
 290 }
 291
 292 /*****************************************************************************
 293  * Render: displays previously rendered output
 294  *****************************************************************************
 295  * This function send the currently rendered image to Transform image, waits
 296  * until it is displayed and switch the two rendering buffers, preparing next
 297  * frame.
 298  *****************************************************************************/
 299 static void Render( vout_thread_t *p_vout, picture_t *p_pic )
 300 {
 301     picture_t *p_outpic;
 302
 303     /* This is a new frame. Get a structure from the video_output. */
 304     while( ( p_outpic = vout_CreatePicture( p_vout->p_sys->p_vout, 0, 0, 0 ) )
 305               == NULL )
 306     {
 307         if( !vlc_object_alive (p_vout) || p_vout->b_error )
 308         {
 309             return;
 310         }
 311         msleep( VOUT_OUTMEM_SLEEP );
 312     }
 313
 314     p_outpic->date = p_pic->date;
 315     vout_LinkPicture( p_vout->p_sys->p_vout, p_outpic );
 316
 317     p_vout->p_sys->pf_filter( p_vout, p_pic, p_outpic );
 318
 319     vout_UnlinkPicture( p_vout->p_sys->p_vout, p_outpic );
 320
 321     vout_DisplayPicture( p_vout->p_sys->p_vout, p_outpic );
 322 }
 323
 324 /**
 325  * Forward mouse event with proper conversion.
 326  */
 327 static int MouseEvent( vlc_object_t *p_this, char const *psz_var,
 328                        vlc_value_t oldval, vlc_value_t newval, void *p_data )
 329 {
 330     vout_thread_t *p_vout = p_data;
 331     VLC_UNUSED(p_this); VLC_UNUSED(oldval);
 332
 333     /* Translate the mouse coordinates
 334      * FIXME missing lock */
 335     if( !strcmp( psz_var, "mouse-x" ) )
 336     {
 337         switch( p_vout->p_sys->i_mode )
 338         {
 339         case TRANSFORM_MODE_270:
 340             newval.i_int = p_vout->p_sys->p_vout->output.i_width
 341                              - newval.i_int;
 342         case TRANSFORM_MODE_90:
 343             psz_var = "mouse-y";
 344             break;
 345
 346         case TRANSFORM_MODE_180:
 347         case TRANSFORM_MODE_HFLIP:
 348             newval.i_int = p_vout->p_sys->p_vout->output.i_width
 349                              - newval.i_int;
 350             break;
 351
 352         case TRANSFORM_MODE_VFLIP:
 353         default:
 354             break;
 355         }
 356     }
 357     else if( !strcmp( psz_var, "mouse-y" ) )
 358     {
 359         switch( p_vout->p_sys->i_mode )
 360         {
 361         case TRANSFORM_MODE_90:
 362             newval.i_int = p_vout->p_sys->p_vout->output.i_height
 363                              - newval.i_int;
 364         case TRANSFORM_MODE_270:
 365             psz_var = "mouse-x";
 366             break;
 367
 368         case TRANSFORM_MODE_180:
 369         case TRANSFORM_MODE_VFLIP:
 370             newval.i_int = p_vout->p_sys->p_vout->output.i_height
 371                              - newval.i_int;
 372             break;
 373
 374         case TRANSFORM_MODE_HFLIP:
 375         default:
 376             break;
 377         }
 378     }
 379
 380     return var_Set( p_vout, psz_var, newval );
 381 }
 382
 383 static void FilterPlanar( vout_thread_t *p_vout,
 384                           const picture_t *p_pic, picture_t *p_outpic )
 385 {
 386     int i_index;
 387     switch( p_vout->p_sys->i_mode )
 388     {
 389         case TRANSFORM_MODE_90:
 390             for( i_index = 0 ; i_index < p_pic->i_planes ; i_index++ )
 391             {
 392                 int i_pitch = p_pic->p[i_index].i_pitch;
 393
 394                 uint8_t *p_in = p_pic->p[i_index].p_pixels;
 395
 396                 uint8_t *p_out = p_outpic->p[i_index].p_pixels;
 397                 uint8_t *p_out_end = p_out +
 398                     p_outpic->p[i_index].i_visible_lines *
 399                     p_outpic->p[i_index].i_pitch;
 400
 401                 for( ; p_out < p_out_end ; )
 402                 {
 403                     uint8_t *p_line_end;
 404
 405                     p_out_end -= p_outpic->p[i_index].i_pitch
 406                                   - p_outpic->p[i_index].i_visible_pitch;
 407                     p_line_end = p_in + p_pic->p[i_index].i_visible_lines *
 408                         i_pitch;
 409
 410                     for( ; p_in < p_line_end ; )
 411                     {
 412                         p_line_end -= i_pitch;
 413                         *(--p_out_end) = *p_line_end;
 414                     }
 415
 416                     p_in++;
 417                 }
 418             }
 419             break;
 420
 421         case TRANSFORM_MODE_180:
 422             for( i_index = 0 ; i_index < p_pic->i_planes ; i_index++ )
 423             {
 424                 uint8_t *p_in = p_pic->p[i_index].p_pixels;
 425                 uint8_t *p_in_end = p_in + p_pic->p[i_index].i_visible_lines
 426                                             * p_pic->p[i_index].i_pitch;
 427
 428                 uint8_t *p_out = p_outpic->p[i_index].p_pixels;
 429
 430                 for( ; p_in < p_in_end ; )
 431                 {
 432                     uint8_t *p_line_start = p_in_end
 433                                              - p_pic->p[i_index].i_pitch;
 434                     p_in_end -= p_pic->p[i_index].i_pitch
 435                                  - p_pic->p[i_index].i_visible_pitch;
 436
 437                     for( ; p_line_start < p_in_end ; )
 438                     {
 439                         *p_out++ = *(--p_in_end);
 440                     }
 441
 442                     p_out += p_outpic->p[i_index].i_pitch
 443                               - p_outpic->p[i_index].i_visible_pitch;
 444                 }
 445             }
 446             break;
 447
 448         case TRANSFORM_MODE_270:
 449             for( i_index = 0 ; i_index < p_pic->i_planes ; i_index++ )
 450             {
 451                 int i_pitch = p_pic->p[i_index].i_pitch;
 452
 453                 uint8_t *p_in = p_pic->p[i_index].p_pixels;
 454
 455                 uint8_t *p_out = p_outpic->p[i_index].p_pixels;
 456                 uint8_t *p_out_end = p_out +
 457                     p_outpic->p[i_index].i_visible_lines *
 458                     p_outpic->p[i_index].i_pitch;
 459
 460                 for( ; p_out < p_out_end ; )
 461                 {
 462                     uint8_t *p_in_end;
 463
 464                     p_in_end = p_in + p_pic->p[i_index].i_visible_lines *
 465                         i_pitch;
 466
 467                     for( ; p_in < p_in_end ; )
 468                     {
 469                         p_in_end -= i_pitch;
 470                         *p_out++ = *p_in_end;
 471                     }
 472
 473                     p_out += p_outpic->p[i_index].i_pitch
 474                               - p_outpic->p[i_index].i_visible_pitch;
 475                     p_in++;
 476                 }
 477             }
 478             break;
 479
 480         case TRANSFORM_MODE_HFLIP:
 481             for( i_index = 0 ; i_index < p_pic->i_planes ; i_index++ )
 482             {
 483                 uint8_t *p_in = p_pic->p[i_index].p_pixels;
 484                 uint8_t *p_in_end = p_in + p_pic->p[i_index].i_visible_lines
 485                                             * p_pic->p[i_index].i_pitch;
 486
 487                 uint8_t *p_out = p_outpic->p[i_index].p_pixels;
 488
 489                 for( ; p_in < p_in_end ; )
 490                 {
 491                     p_in_end -= p_pic->p[i_index].i_pitch;
 492                     vlc_memcpy( p_out, p_in_end,
 493                                 p_pic->p[i_index].i_visible_pitch );
 494                     p_out += p_pic->p[i_index].i_pitch;
 495                 }
 496             }
 497             break;
 498
 499         case TRANSFORM_MODE_VFLIP:
 500             for( i_index = 0 ; i_index < p_pic->i_planes ; i_index++ )
 501             {
 502                 uint8_t *p_in = p_pic->p[i_index].p_pixels;
 503                 uint8_t *p_in_end = p_in + p_pic->p[i_index].i_visible_lines
 504                                          * p_pic->p[i_index].i_pitch;
 505
 506                 uint8_t *p_out = p_outpic->p[i_index].p_pixels;
 507
 508                 for( ; p_in < p_in_end ; )
 509                 {
 510                     uint8_t *p_line_end = p_in
 511                                         + p_pic->p[i_index].i_visible_pitch;
 512
 513                     for( ; p_in < p_line_end ; )
 514                     {
 515                         *p_out++ = *(--p_line_end);
 516                     }
 517
 518                     p_in += p_pic->p[i_index].i_pitch;
 519                 }
 520             }
 521             break;
 522
 523         default:
 524             break;
 525     }
 526 }
 527
 528 static void FilterI422( vout_thread_t *p_vout,
 529                         const picture_t *p_pic, picture_t *p_outpic )
 530 {
 531     int i_index;
 532     switch( p_vout->p_sys->i_mode )
 533     {
 534         case TRANSFORM_MODE_180:
 535         case TRANSFORM_MODE_HFLIP:
 536         case TRANSFORM_MODE_VFLIP:
 537             /* Fall back on the default implementation */
 538             FilterPlanar( p_vout, p_pic, p_outpic );
 539             return;
 540
 541         case TRANSFORM_MODE_90:
 542             for( i_index = 0 ; i_index < p_pic->i_planes ; i_index++ )
 543             {
 544                 int i_pitch = p_pic->p[i_index].i_pitch;
 545
 546                 uint8_t *p_in = p_pic->p[i_index].p_pixels;
 547
 548                 uint8_t *p_out = p_outpic->p[i_index].p_pixels;
 549                 uint8_t *p_out_end = p_out +
 550                     p_outpic->p[i_index].i_visible_lines *
 551                     p_outpic->p[i_index].i_pitch;
 552
 553                 if( i_index == 0 )
 554                 {
 555                     for( ; p_out < p_out_end ; )
 556                     {
 557                         uint8_t *p_line_end;
 558
 559                         p_out_end -= p_outpic->p[i_index].i_pitch
 560                                       - p_outpic->p[i_index].i_visible_pitch;
 561                         p_line_end = p_in + p_pic->p[i_index].i_visible_lines *
 562                             i_pitch;
 563
 564                         for( ; p_in < p_line_end ; )
 565                         {
 566                             p_line_end -= i_pitch;
 567                             *(--p_out_end) = *p_line_end;
 568                         }
 569
 570                         p_in++;
 571                     }
 572                 }
 573                 else /* i_index == 1 or 2 */
 574                 {
 575                     for( ; p_out < p_out_end ; )
 576                     {
 577                         uint8_t *p_line_end, *p_out_end2;
 578
 579                         p_out_end -= p_outpic->p[i_index].i_pitch
 580                                       - p_outpic->p[i_index].i_visible_pitch;
 581                         p_out_end2 = p_out_end - p_outpic->p[i_index].i_pitch;
 582                         p_line_end = p_in + p_pic->p[i_index].i_visible_lines *
 583                             i_pitch;
 584
 585                         for( ; p_in < p_line_end ; )
 586                         {
 587                             uint8_t p1, p2;
 588
 589                             p_line_end -= i_pitch;
 590                             p1 = *p_line_end;
 591                             p_line_end -= i_pitch;
 592                             p2 = *p_line_end;
 593
 594                             /* Trick for (x+y)/2 without overflow, based on
 595                              *   x + y == (x ^ y) + 2 * (x & y) */
 596                             *(--p_out_end) = (p1 & p2) + ((p1 ^ p2) / 2);
 597                             *(--p_out_end2) = (p1 & p2) + ((p1 ^ p2) / 2);
 598                         }
 599
 600                         p_out_end = p_out_end2;
 601                         p_in++;
 602                     }
 603                 }
 604             }
 605             break;
 606
 607         case TRANSFORM_MODE_270:
 608             for( i_index = 0 ; i_index < p_pic->i_planes ; i_index++ )
 609             {
 610                 int i_pitch = p_pic->p[i_index].i_pitch;
 611
 612                 uint8_t *p_in = p_pic->p[i_index].p_pixels;
 613
 614                 uint8_t *p_out = p_outpic->p[i_index].p_pixels;
 615                 uint8_t *p_out_end = p_out +
 616                     p_outpic->p[i_index].i_visible_lines *
 617                     p_outpic->p[i_index].i_pitch;
 618
 619                 if( i_index == 0 )
 620                 {
 621                     for( ; p_out < p_out_end ; )
 622                     {
 623                         uint8_t *p_in_end;
 624
 625                         p_in_end = p_in + p_pic->p[i_index].i_visible_lines *
 626                             i_pitch;
 627
 628                         for( ; p_in < p_in_end ; )
 629                         {
 630                             p_in_end -= i_pitch;
 631                             *p_out++ = *p_in_end;
 632                         }
 633
 634                         p_out += p_outpic->p[i_index].i_pitch
 635                                   - p_outpic->p[i_index].i_visible_pitch;
 636                         p_in++;
 637                     }
 638                 }
 639                 else /* i_index == 1 or 2 */
 640                 {
 641                     for( ; p_out < p_out_end ; )
 642                     {
 643                         uint8_t *p_in_end, *p_out2;
 644
 645                         p_in_end = p_in + p_pic->p[i_index].i_visible_lines *
 646                             i_pitch;
 647                         p_out2 = p_out + p_outpic->p[i_index].i_pitch;
 648
 649                         for( ; p_in < p_in_end ; )
 650                         {
 651                             uint8_t p1, p2;
 652
 653                             p_in_end -= i_pitch;
 654                             p1 = *p_in_end;
 655                             p_in_end -= i_pitch;
 656                             p2 = *p_in_end;
 657
 658                             /* Trick for (x+y)/2 without overflow, based on
 659                              *   x + y == (x ^ y) + 2 * (x & y) */
 660                             *p_out++ = (p1 & p2) + ((p1 ^ p2) / 2);
 661                             *p_out2++ = (p1 & p2) + ((p1 ^ p2) / 2);
 662                         }
 663
 664                         p_out2 += p_outpic->p[i_index].i_pitch
 665                                    - p_outpic->p[i_index].i_visible_pitch;
 666                         p_out = p_out2;
 667                         p_in++;
 668                     }
 669                 }
 670             }
 671             break;
 672
 673         default:
 674             break;
 675     }
 676 }
 677
 678 static void FilterYUYV( vout_thread_t *p_vout,
 679                         const picture_t *p_pic, picture_t *p_outpic )
 680 {
 681     int i_index;
 682     int i_y_offset, i_u_offset, i_v_offset;
 683     if( GetPackedYuvOffsets( p_pic->format.i_chroma, &i_y_offset,
 684                              &i_u_offset, &i_v_offset ) != VLC_SUCCESS )
 685         return;
 686
 687     switch( p_vout->p_sys->i_mode )
 688     {
 689         case TRANSFORM_MODE_HFLIP:
 690             /* Fall back on the default implementation */
 691             FilterPlanar( p_vout, p_pic, p_outpic );
 692             return;
 693
 694         case TRANSFORM_MODE_90:
 695             for( i_index = 0 ; i_index < p_pic->i_planes ; i_index++ )
 696             {
 697                 int i_pitch = p_pic->p[i_index].i_pitch;
 698
 699                 uint8_t *p_in = p_pic->p[i_index].p_pixels;
 700
 701                 uint8_t *p_out = p_outpic->p[i_index].p_pixels;
 702                 uint8_t *p_out_end = p_out +
 703                     p_outpic->p[i_index].i_visible_lines *
 704                     p_outpic->p[i_index].i_pitch;
 705
 706                 int i_offset  = i_u_offset;
 707                 int i_offset2 = i_v_offset;
 708                 for( ; p_out < p_out_end ; )
 709                 {
 710                     uint8_t *p_line_end;
 711
 712                     p_out_end -= p_outpic->p[i_index].i_pitch
 713                                   - p_outpic->p[i_index].i_visible_pitch;
 714                     p_line_end = p_in + p_pic->p[i_index].i_visible_lines *
 715                         i_pitch;
 716
 717                     for( ; p_in < p_line_end ; )
 718                     {
 719                         p_line_end -= i_pitch;
 720                         p_out_end -= 4;
 721                         p_out_end[i_y_offset+2] = p_line_end[i_y_offset];
 722                         p_out_end[i_u_offset] = p_line_end[i_offset];
 723                         p_line_end -= i_pitch;
 724                         p_out_end[i_y_offset] = p_line_end[i_y_offset];
 725                         p_out_end[i_v_offset] = p_line_end[i_offset2];
 726                     }
 727
 728                     p_in += 2;
 729
 730                     {
 731                         int a = i_offset;
 732                         i_offset = i_offset2;
 733                         i_offset2 = a;
 734                     }
 735                 }
 736             }
 737             break;
 738
 739         case TRANSFORM_MODE_180:
 740             for( i_index = 0 ; i_index < p_pic->i_planes ; i_index++ )
 741             {
 742                 uint8_t *p_in = p_pic->p[i_index].p_pixels;
 743                 uint8_t *p_in_end = p_in + p_pic->p[i_index].i_visible_lines
 744                                             * p_pic->p[i_index].i_pitch;
 745
 746                 uint8_t *p_out = p_outpic->p[i_index].p_pixels;
 747
 748                 for( ; p_in < p_in_end ; )
 749                 {
 750                     uint8_t *p_line_start = p_in_end
 751                                              - p_pic->p[i_index].i_pitch;
 752                     p_in_end -= p_pic->p[i_index].i_pitch
 753                                  - p_pic->p[i_index].i_visible_pitch;
 754
 755                     for( ; p_line_start < p_in_end ; )
 756                     {
 757                         p_in_end -= 4;
 758                         p_out[i_y_offset] = p_in_end[i_y_offset+2];
 759                         p_out[i_u_offset] = p_in_end[i_u_offset];
 760                         p_out[i_y_offset+2] = p_in_end[i_y_offset];
 761                         p_out[i_v_offset] = p_in_end[i_v_offset];
 762                         p_out += 4;
 763                     }
 764
 765                     p_out += p_outpic->p[i_index].i_pitch
 766                               - p_outpic->p[i_index].i_visible_pitch;
 767                 }
 768             }
 769             break;
 770
 771         case TRANSFORM_MODE_270:
 772             for( i_index = 0 ; i_index < p_pic->i_planes ; i_index++ )
 773             {
 774                 int i_pitch = p_pic->p[i_index].i_pitch;
 775
 776                 uint8_t *p_in = p_pic->p[i_index].p_pixels;
 777
 778                 uint8_t *p_out = p_outpic->p[i_index].p_pixels;
 779                 uint8_t *p_out_end = p_out +
 780                     p_outpic->p[i_index].i_visible_lines *
 781                     p_outpic->p[i_index].i_pitch;
 782
 783                 int i_offset  = i_u_offset;
 784                 int i_offset2 = i_v_offset;
 785                 for( ; p_out < p_out_end ; )
 786                 {
 787                     uint8_t *p_in_end;
 788
 789                     p_in_end = p_in
 790                              + p_pic->p[i_index].i_visible_lines * i_pitch;
 791
 792                     for( ; p_in < p_in_end ; )
 793                     {
 794                         p_in_end -= i_pitch;
 795                         p_out[i_y_offset] = p_in_end[i_y_offset];
 796                         p_out[i_u_offset] = p_in_end[i_offset];
 797                         p_in_end -= i_pitch;
 798                         p_out[i_y_offset+2] = p_in_end[i_y_offset];
 799                         p_out[i_v_offset] = p_in_end[i_offset2];
 800                         p_out += 4;
 801                     }
 802
 803                     p_out += p_outpic->p[i_index].i_pitch
 804                            - p_outpic->p[i_index].i_visible_pitch;
 805                     p_in += 2;
 806
 807                     {
 808                         int a = i_offset;
 809                         i_offset = i_offset2;
 810                         i_offset2 = a;
 811                     }
 812                 }
 813             }
 814             break;
 815
 816         case TRANSFORM_MODE_VFLIP:
 817             for( i_index = 0 ; i_index < p_pic->i_planes ; i_index++ )
 818             {
 819                 uint8_t *p_in = p_pic->p[i_index].p_pixels;
 820                 uint8_t *p_in_end = p_in + p_pic->p[i_index].i_visible_lines
 821                                          * p_pic->p[i_index].i_pitch;
 822
 823                 uint8_t *p_out = p_outpic->p[i_index].p_pixels;
 824
 825                 for( ; p_in < p_in_end ; )
 826                 {
 827                     uint8_t *p_line_end = p_in
 828                                         + p_pic->p[i_index].i_visible_pitch;
 829
 830                     for( ; p_in < p_line_end ; )
 831                     {
 832                         p_line_end -= 4;
 833                         p_out[i_y_offset] = p_line_end[i_y_offset+2];
 834                         p_out[i_u_offset] = p_line_end[i_u_offset];
 835                         p_out[i_y_offset+2] = p_line_end[i_y_offset];
 836                         p_out[i_v_offset] = p_line_end[i_v_offset];
 837                         p_out += 4;
 838                     }
 839
 840                     p_in += p_pic->p[i_index].i_pitch;
 841                 }
 842             }
 843             break;
 844
 845         default:
 846             break;
 847     }
 848 }