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_outpic->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                     p_out += p_outpic->p[i_index].i_pitch
 520                                 - p_outpic->p[i_index].i_visible_pitch;
 521                 }
 522             }
 523             break;
 524
 525         default:
 526             break;
 527     }
 528 }
 529
 530 static void FilterI422( vout_thread_t *p_vout,
 531                         const picture_t *p_pic, picture_t *p_outpic )
 532 {
 533     int i_index;
 534     switch( p_vout->p_sys->i_mode )
 535     {
 536         case TRANSFORM_MODE_180:
 537         case TRANSFORM_MODE_HFLIP:
 538         case TRANSFORM_MODE_VFLIP:
 539             /* Fall back on the default implementation */
 540             FilterPlanar( p_vout, p_pic, p_outpic );
 541             return;
 542
 543         case TRANSFORM_MODE_90:
 544             for( i_index = 0 ; i_index < p_pic->i_planes ; i_index++ )
 545             {
 546                 int i_pitch = p_pic->p[i_index].i_pitch;
 547
 548                 uint8_t *p_in = p_pic->p[i_index].p_pixels;
 549
 550                 uint8_t *p_out = p_outpic->p[i_index].p_pixels;
 551                 uint8_t *p_out_end = p_out +
 552                     p_outpic->p[i_index].i_visible_lines *
 553                     p_outpic->p[i_index].i_pitch;
 554
 555                 if( i_index == 0 )
 556                 {
 557                     for( ; p_out < p_out_end ; )
 558                     {
 559                         uint8_t *p_line_end;
 560
 561                         p_out_end -= p_outpic->p[i_index].i_pitch
 562                                       - p_outpic->p[i_index].i_visible_pitch;
 563                         p_line_end = p_in + p_pic->p[i_index].i_visible_lines *
 564                             i_pitch;
 565
 566                         for( ; p_in < p_line_end ; )
 567                         {
 568                             p_line_end -= i_pitch;
 569                             *(--p_out_end) = *p_line_end;
 570                         }
 571
 572                         p_in++;
 573                     }
 574                 }
 575                 else /* i_index == 1 or 2 */
 576                 {
 577                     for( ; p_out < p_out_end ; )
 578                     {
 579                         uint8_t *p_line_end, *p_out_end2;
 580
 581                         p_out_end -= p_outpic->p[i_index].i_pitch
 582                                       - p_outpic->p[i_index].i_visible_pitch;
 583                         p_out_end2 = p_out_end - p_outpic->p[i_index].i_pitch;
 584                         p_line_end = p_in + p_pic->p[i_index].i_visible_lines *
 585                             i_pitch;
 586
 587                         for( ; p_in < p_line_end ; )
 588                         {
 589                             uint8_t p1, p2;
 590
 591                             p_line_end -= i_pitch;
 592                             p1 = *p_line_end;
 593                             p_line_end -= i_pitch;
 594                             p2 = *p_line_end;
 595
 596                             /* Trick for (x+y)/2 without overflow, based on
 597                              *   x + y == (x ^ y) + 2 * (x & y) */
 598                             *(--p_out_end) = (p1 & p2) + ((p1 ^ p2) / 2);
 599                             *(--p_out_end2) = (p1 & p2) + ((p1 ^ p2) / 2);
 600                         }
 601
 602                         p_out_end = p_out_end2;
 603                         p_in++;
 604                     }
 605                 }
 606             }
 607             break;
 608
 609         case TRANSFORM_MODE_270:
 610             for( i_index = 0 ; i_index < p_pic->i_planes ; i_index++ )
 611             {
 612                 int i_pitch = p_pic->p[i_index].i_pitch;
 613
 614                 uint8_t *p_in = p_pic->p[i_index].p_pixels;
 615
 616                 uint8_t *p_out = p_outpic->p[i_index].p_pixels;
 617                 uint8_t *p_out_end = p_out +
 618                     p_outpic->p[i_index].i_visible_lines *
 619                     p_outpic->p[i_index].i_pitch;
 620
 621                 if( i_index == 0 )
 622                 {
 623                     for( ; p_out < p_out_end ; )
 624                     {
 625                         uint8_t *p_in_end;
 626
 627                         p_in_end = p_in + p_pic->p[i_index].i_visible_lines *
 628                             i_pitch;
 629
 630                         for( ; p_in < p_in_end ; )
 631                         {
 632                             p_in_end -= i_pitch;
 633                             *p_out++ = *p_in_end;
 634                         }
 635
 636                         p_out += p_outpic->p[i_index].i_pitch
 637                                   - p_outpic->p[i_index].i_visible_pitch;
 638                         p_in++;
 639                     }
 640                 }
 641                 else /* i_index == 1 or 2 */
 642                 {
 643                     for( ; p_out < p_out_end ; )
 644                     {
 645                         uint8_t *p_in_end, *p_out2;
 646
 647                         p_in_end = p_in + p_pic->p[i_index].i_visible_lines *
 648                             i_pitch;
 649                         p_out2 = p_out + p_outpic->p[i_index].i_pitch;
 650
 651                         for( ; p_in < p_in_end ; )
 652                         {
 653                             uint8_t p1, p2;
 654
 655                             p_in_end -= i_pitch;
 656                             p1 = *p_in_end;
 657                             p_in_end -= i_pitch;
 658                             p2 = *p_in_end;
 659
 660                             /* Trick for (x+y)/2 without overflow, based on
 661                              *   x + y == (x ^ y) + 2 * (x & y) */
 662                             *p_out++ = (p1 & p2) + ((p1 ^ p2) / 2);
 663                             *p_out2++ = (p1 & p2) + ((p1 ^ p2) / 2);
 664                         }
 665
 666                         p_out2 += p_outpic->p[i_index].i_pitch
 667                                    - p_outpic->p[i_index].i_visible_pitch;
 668                         p_out = p_out2;
 669                         p_in++;
 670                     }
 671                 }
 672             }
 673             break;
 674
 675         default:
 676             break;
 677     }
 678 }
 679
 680 static void FilterYUYV( vout_thread_t *p_vout,
 681                         const picture_t *p_pic, picture_t *p_outpic )
 682 {
 683     int i_index;
 684     int i_y_offset, i_u_offset, i_v_offset;
 685     if( GetPackedYuvOffsets( p_pic->format.i_chroma, &i_y_offset,
 686                              &i_u_offset, &i_v_offset ) != VLC_SUCCESS )
 687         return;
 688
 689     switch( p_vout->p_sys->i_mode )
 690     {
 691         case TRANSFORM_MODE_HFLIP:
 692             /* Fall back on the default implementation */
 693             FilterPlanar( p_vout, p_pic, p_outpic );
 694             return;
 695
 696         case TRANSFORM_MODE_90:
 697             for( i_index = 0 ; i_index < p_pic->i_planes ; i_index++ )
 698             {
 699                 int i_pitch = p_pic->p[i_index].i_pitch;
 700
 701                 uint8_t *p_in = p_pic->p[i_index].p_pixels;
 702
 703                 uint8_t *p_out = p_outpic->p[i_index].p_pixels;
 704                 uint8_t *p_out_end = p_out +
 705                     p_outpic->p[i_index].i_visible_lines *
 706                     p_outpic->p[i_index].i_pitch;
 707
 708                 int i_offset  = i_u_offset;
 709                 int i_offset2 = i_v_offset;
 710                 for( ; p_out < p_out_end ; )
 711                 {
 712                     uint8_t *p_line_end;
 713
 714                     p_out_end -= p_outpic->p[i_index].i_pitch
 715                                   - p_outpic->p[i_index].i_visible_pitch;
 716                     p_line_end = p_in + p_pic->p[i_index].i_visible_lines *
 717                         i_pitch;
 718
 719                     for( ; p_in < p_line_end ; )
 720                     {
 721                         p_line_end -= i_pitch;
 722                         p_out_end -= 4;
 723                         p_out_end[i_y_offset+2] = p_line_end[i_y_offset];
 724                         p_out_end[i_u_offset] = p_line_end[i_offset];
 725                         p_line_end -= i_pitch;
 726                         p_out_end[i_y_offset] = p_line_end[i_y_offset];
 727                         p_out_end[i_v_offset] = p_line_end[i_offset2];
 728                     }
 729
 730                     p_in += 2;
 731
 732                     {
 733                         int a = i_offset;
 734                         i_offset = i_offset2;
 735                         i_offset2 = a;
 736                     }
 737                 }
 738             }
 739             break;
 740
 741         case TRANSFORM_MODE_180:
 742             for( i_index = 0 ; i_index < p_pic->i_planes ; i_index++ )
 743             {
 744                 uint8_t *p_in = p_pic->p[i_index].p_pixels;
 745                 uint8_t *p_in_end = p_in + p_pic->p[i_index].i_visible_lines
 746                                             * p_pic->p[i_index].i_pitch;
 747
 748                 uint8_t *p_out = p_outpic->p[i_index].p_pixels;
 749
 750                 for( ; p_in < p_in_end ; )
 751                 {
 752                     uint8_t *p_line_start = p_in_end
 753                                              - p_pic->p[i_index].i_pitch;
 754                     p_in_end -= p_pic->p[i_index].i_pitch
 755                                  - p_pic->p[i_index].i_visible_pitch;
 756
 757                     for( ; p_line_start < p_in_end ; )
 758                     {
 759                         p_in_end -= 4;
 760                         p_out[i_y_offset] = p_in_end[i_y_offset+2];
 761                         p_out[i_u_offset] = p_in_end[i_u_offset];
 762                         p_out[i_y_offset+2] = p_in_end[i_y_offset];
 763                         p_out[i_v_offset] = p_in_end[i_v_offset];
 764                         p_out += 4;
 765                     }
 766
 767                     p_out += p_outpic->p[i_index].i_pitch
 768                               - p_outpic->p[i_index].i_visible_pitch;
 769                 }
 770             }
 771             break;
 772
 773         case TRANSFORM_MODE_270:
 774             for( i_index = 0 ; i_index < p_pic->i_planes ; i_index++ )
 775             {
 776                 int i_pitch = p_pic->p[i_index].i_pitch;
 777
 778                 uint8_t *p_in = p_pic->p[i_index].p_pixels;
 779
 780                 uint8_t *p_out = p_outpic->p[i_index].p_pixels;
 781                 uint8_t *p_out_end = p_out +
 782                     p_outpic->p[i_index].i_visible_lines *
 783                     p_outpic->p[i_index].i_pitch;
 784
 785                 int i_offset  = i_u_offset;
 786                 int i_offset2 = i_v_offset;
 787                 for( ; p_out < p_out_end ; )
 788                 {
 789                     uint8_t *p_in_end;
 790
 791                     p_in_end = p_in
 792                              + p_pic->p[i_index].i_visible_lines * i_pitch;
 793
 794                     for( ; p_in < p_in_end ; )
 795                     {
 796                         p_in_end -= i_pitch;
 797                         p_out[i_y_offset] = p_in_end[i_y_offset];
 798                         p_out[i_u_offset] = p_in_end[i_offset];
 799                         p_in_end -= i_pitch;
 800                         p_out[i_y_offset+2] = p_in_end[i_y_offset];
 801                         p_out[i_v_offset] = p_in_end[i_offset2];
 802                         p_out += 4;
 803                     }
 804
 805                     p_out += p_outpic->p[i_index].i_pitch
 806                            - p_outpic->p[i_index].i_visible_pitch;
 807                     p_in += 2;
 808
 809                     {
 810                         int a = i_offset;
 811                         i_offset = i_offset2;
 812                         i_offset2 = a;
 813                     }
 814                 }
 815             }
 816             break;
 817
 818         case TRANSFORM_MODE_VFLIP:
 819             for( i_index = 0 ; i_index < p_pic->i_planes ; i_index++ )
 820             {
 821                 uint8_t *p_in = p_pic->p[i_index].p_pixels;
 822                 uint8_t *p_in_end = p_in + p_pic->p[i_index].i_visible_lines
 823                                          * p_pic->p[i_index].i_pitch;
 824
 825                 uint8_t *p_out = p_outpic->p[i_index].p_pixels;
 826
 827                 for( ; p_in < p_in_end ; )
 828                 {
 829                     uint8_t *p_line_end = p_in
 830                                         + p_pic->p[i_index].i_visible_pitch;
 831
 832                     for( ; p_in < p_line_end ; )
 833                     {
 834                         p_line_end -= 4;
 835                         p_out[i_y_offset] = p_line_end[i_y_offset+2];
 836                         p_out[i_u_offset] = p_line_end[i_u_offset];
 837                         p_out[i_y_offset+2] = p_line_end[i_y_offset];
 838                         p_out[i_v_offset] = p_line_end[i_v_offset];
 839                         p_out += 4;
 840                     }
 841
 842                     p_in += p_pic->p[i_index].i_pitch;
 843                     p_out += p_outpic->p[i_index].i_pitch
 844                                 - p_outpic->p[i_index].i_visible_pitch;
 845                 }
 846             }
 847             break;
 848
 849         default:
 850             break;
 851     }
 852 }