开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > midi > 查看源码
transform.c
资源名称：vlc-1.0.5.zip　[点击查看]
上传用户：kjfoods
上传日期：2020-07-06
资源大小：29949k
文件大小：29k
源码类别：

midi

开发平台：

Unix_Linux

transform.c：源码内容
  1. /*****************************************************************************
  2.  * transform.c : transform image module for vlc
  3.  *****************************************************************************
  4.  * Copyright (C) 2000-2006 the VideoLAN team
  5.  * $Id: 0409cf1acb126d2dd18f6c027694f55e707e65c6 $
  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.  *****************************************************************************/
  24. /*****************************************************************************
  25.  * Preamble
  26.  *****************************************************************************/
  28. #ifdef HAVE_CONFIG_H
  29. # include "config.h"
  30. #endif
  32. #include <vlc_common.h>
  33. #include <vlc_plugin.h>
  34. #include <vlc_vout.h>
  36. #include "filter_common.h"
  37. #include "filter_picture.h"
  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
  45. /*****************************************************************************
  46.  * Local prototypes
  47.  *****************************************************************************/
  48. static int  Create    ( vlc_object_t * );
  49. static void Destroy   ( vlc_object_t * );
  51. static int  Init      ( vout_thread_t * );
  52. static void End       ( vout_thread_t * );
  53. static void Render    ( vout_thread_t *, picture_t * );
  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 * );
  59. static int  MouseEvent( vlc_object_t *, char const *,
  60.                         vlc_value_t, vlc_value_t, void * );
  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'")
  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") };
  73. #define CFG_PREFIX "transform-"
  75. vlc_module_begin ()
  76.     set_description( N_("Video transformation filter") )
  77.     set_shortname( N_("Transformation"))
  78.     set_capability( "video filter", 0 )
  79.     set_category( CAT_VIDEO )
  80.     set_subcategory( SUBCAT_VIDEO_VFILTER )
  82.     add_string( CFG_PREFIX "type", "90", NULL,
  83.                           TYPE_TEXT, TYPE_LONGTEXT, false)
  84.         change_string_list( type_list, type_list_text, 0)
  86.     add_shortcut( "transform" )
  87.     set_callbacks( Create, Destroy )
  88. vlc_module_end ()
  90. static const char *const ppsz_filter_options[] = {
  91.     "type", NULL
  92. };
  94. /*****************************************************************************
  95.  * vout_sys_t: Transform video output method descriptor
  96.  *****************************************************************************
  97.  * This structure is part of the video output thread descriptor.
  98.  * It describes the Transform specific properties of an output thread.
  99.  *****************************************************************************/
  100. struct vout_sys_t
  101. {
  102.     int i_mode;
  103.     bool b_rotation;
  104.     vout_thread_t *p_vout;
  106.     void (*pf_filter)( vout_thread_t *, const picture_t *, picture_t * );
  107. };
  109. /*****************************************************************************
  110.  * Control: control facility for the vout (forwards to child vout)
  111.  *****************************************************************************/
  112. static int Control( vout_thread_t *p_vout, int i_query, va_list args )
  113. {
  114.     return vout_vaControl( p_vout->p_sys->p_vout, i_query, args );
  115. }
  117. /*****************************************************************************
  118.  * Create: allocates Transform video thread output method
  119.  *****************************************************************************
  120.  * This function allocates and initializes a Transform vout method.
  121.  *****************************************************************************/
  122. static int Create( vlc_object_t *p_this )
  123. {
  124.     vout_thread_t *p_vout = (vout_thread_t *)p_this;
  125.     char *psz_method;
  127.     /* Allocate structure */
  128.     p_vout->p_sys = malloc( sizeof( vout_sys_t ) );
  129.     if( p_vout->p_sys == NULL )
  130.         return VLC_ENOMEM;
  132.     p_vout->pf_init = Init;
  133.     p_vout->pf_end = End;
  134.     p_vout->pf_manage = NULL;
  135.     p_vout->pf_render = Render;
  136.     p_vout->pf_display = NULL;
  137.     p_vout->pf_control = Control;
  139.     config_ChainParse( p_vout, CFG_PREFIX, ppsz_filter_options,
  140.                            p_vout->p_cfg );
  142.     /* Look what method was requested */
  143.     psz_method = var_CreateGetNonEmptyStringCommand( p_vout, "transform-type" );
  145.     switch( p_vout->fmt_in.i_chroma )
  146.     {
  147.         CASE_PLANAR_YUV_SQUARE
  148.         case VLC_FOURCC('G','R','E','Y'):
  149.             p_vout->p_sys->pf_filter = FilterPlanar;
  150.             break;
  152.         case VLC_FOURCC('I','4','2','2'):
  153.         case VLC_FOURCC('J','4','2','2'):
  154.             p_vout->p_sys->pf_filter = FilterI422;
  155.             break;
  157.         CASE_PACKED_YUV_422
  158.             p_vout->p_sys->pf_filter = FilterYUYV;
  159.             break;
  161.         default:
  162.             msg_Err( p_vout, "Unsupported chroma" );
  163.             free( p_vout->p_sys );
  164.             return VLC_EGENERIC;
  165.     }
  167.     if( psz_method == NULL )
  168.     {
  169.         msg_Err( p_vout, "configuration variable %s empty", "transform-type" );
  170.         msg_Err( p_vout, "no valid transform mode provided, using '90'" );
  171.         p_vout->p_sys->i_mode = TRANSFORM_MODE_90;
  172.         p_vout->p_sys->b_rotation = 1;
  173.     }
  174.     else
  175.     {
  176.         if( !strcmp( psz_method, "hflip" ) )
  177.         {
  178.             p_vout->p_sys->i_mode = TRANSFORM_MODE_HFLIP;
  179.             p_vout->p_sys->b_rotation = 0;
  180.         }
  181.         else if( !strcmp( psz_method, "vflip" ) )
  182.         {
  183.             p_vout->p_sys->i_mode = TRANSFORM_MODE_VFLIP;
  184.             p_vout->p_sys->b_rotation = 0;
  185.         }
  186.         else if( !strcmp( psz_method, "90" ) )
  187.         {
  188.             p_vout->p_sys->i_mode = TRANSFORM_MODE_90;
  189.             p_vout->p_sys->b_rotation = 1;
  190.         }
  191.         else if( !strcmp( psz_method, "180" ) )
  192.         {
  193.             p_vout->p_sys->i_mode = TRANSFORM_MODE_180;
  194.             p_vout->p_sys->b_rotation = 0;
  195.         }
  196.         else if( !strcmp( psz_method, "270" ) )
  197.         {
  198.             p_vout->p_sys->i_mode = TRANSFORM_MODE_270;
  199.             p_vout->p_sys->b_rotation = 1;
  200.         }
  201.         else
  202.         {
  203.             msg_Err( p_vout, "no valid transform mode provided, using '90'" );
  204.             p_vout->p_sys->i_mode = TRANSFORM_MODE_90;
  205.             p_vout->p_sys->b_rotation = 1;
  206.         }
  208.         free( psz_method );
  209.     }
  211.     return VLC_SUCCESS;
  212. }
  214. /*****************************************************************************
  215.  * Init: initialize Transform video thread output method
  216.  *****************************************************************************/
  217. static int Init( vout_thread_t *p_vout )
  218. {
  219.     video_format_t fmt;
  221.     I_OUTPUTPICTURES = 0;
  222.     memset( &fmt, 0, sizeof(video_format_t) );
  224.     /* Initialize the output structure */
  225.     p_vout->output.i_chroma = p_vout->render.i_chroma;
  226.     p_vout->output.i_width  = p_vout->render.i_width;
  227.     p_vout->output.i_height = p_vout->render.i_height;
  228.     p_vout->output.i_aspect = p_vout->render.i_aspect;
  229.     p_vout->fmt_out = p_vout->fmt_in;
  230.     fmt = p_vout->fmt_out;
  232.     /* Try to open the real video output */
  233.     msg_Dbg( p_vout, "spawning the real video output" );
  235.     if( p_vout->p_sys->b_rotation )
  236.     {
  237.         fmt.i_width = p_vout->fmt_out.i_height;
  238.         fmt.i_visible_width = p_vout->fmt_out.i_visible_height;
  239.         fmt.i_x_offset = p_vout->fmt_out.i_y_offset;
  241.         fmt.i_height = p_vout->fmt_out.i_width;
  242.         fmt.i_visible_height = p_vout->fmt_out.i_visible_width;
  243.         fmt.i_y_offset = p_vout->fmt_out.i_x_offset;
  245.         fmt.i_aspect = VOUT_ASPECT_FACTOR *
  246.             (uint64_t)VOUT_ASPECT_FACTOR / fmt.i_aspect;
  248.         fmt.i_sar_num = p_vout->fmt_out.i_sar_den;
  249.         fmt.i_sar_den = p_vout->fmt_out.i_sar_num;
  250.     }
  252.     p_vout->p_sys->p_vout = vout_Create( p_vout, &fmt );
  254.     /* Everything failed */
  255.     if( p_vout->p_sys->p_vout == NULL )
  256.     {
  257.         msg_Err( p_vout, "cannot open vout, aborting" );
  258.         return VLC_EGENERIC;
  259.     }
  261.     vout_filter_AllocateDirectBuffers( p_vout, VOUT_MAX_PICTURES );
  263.     vout_filter_AddChild( p_vout, p_vout->p_sys->p_vout, MouseEvent );
  265.     return VLC_SUCCESS;
  266. }
  268. /*****************************************************************************
  269.  * End: terminate Transform video thread output method
  270.  *****************************************************************************/
  271. static void End( vout_thread_t *p_vout )
  272. {
  273.     vout_sys_t *p_sys = p_vout->p_sys;
  275.     vout_filter_DelChild( p_vout, p_sys->p_vout, MouseEvent );
  276.     vout_CloseAndRelease( p_sys->p_vout );
  278.     vout_filter_ReleaseDirectBuffers( p_vout );
  279. }
  281. /*****************************************************************************
  282.  * Destroy: destroy Transform video thread output method
  283.  *****************************************************************************
  284.  * Terminate an output method created by TransformCreateOutputMethod
  285.  *****************************************************************************/
  286. static void Destroy( vlc_object_t *p_this )
  287. {
  288.     vout_thread_t *p_vout = (vout_thread_t *)p_this;
  290.     free( p_vout->p_sys );
  291. }
  293. /*****************************************************************************
  294.  * Render: displays previously rendered output
  295.  *****************************************************************************
  296.  * This function send the currently rendered image to Transform image, waits
  297.  * until it is displayed and switch the two rendering buffers, preparing next
  298.  * frame.
  299.  *****************************************************************************/
  300. static void Render( vout_thread_t *p_vout, picture_t *p_pic )
  301. {
  302.     picture_t *p_outpic;
  304.     /* This is a new frame. Get a structure from the video_output. */
  305.     while( ( p_outpic = vout_CreatePicture( p_vout->p_sys->p_vout, 0, 0, 0 ) )
  306.               == NULL )
  307.     {
  308.         if( !vlc_object_alive (p_vout) || p_vout->b_error )
  309.         {
  310.             return;
  311.         }
  312.         msleep( VOUT_OUTMEM_SLEEP );
  313.     }
  315.     p_outpic->date = p_pic->date;
  316.     vout_LinkPicture( p_vout->p_sys->p_vout, p_outpic );
  318.     p_vout->p_sys->pf_filter( p_vout, p_pic, p_outpic );
  320.     vout_UnlinkPicture( p_vout->p_sys->p_vout, p_outpic );
  322.     vout_DisplayPicture( p_vout->p_sys->p_vout, p_outpic );
  323. }
  325. /**
  326.  * Forward mouse event with proper conversion.
  327.  */
  328. static int MouseEvent( vlc_object_t *p_this, char const *psz_var,
  329.                        vlc_value_t oldval, vlc_value_t newval, void *p_data )
  330. {
  331.     vout_thread_t *p_vout = p_data;
  332.     VLC_UNUSED(p_this); VLC_UNUSED(oldval);
  334.     /* Translate the mouse coordinates
  335.      * FIXME missing lock */
  336.     if( !strcmp( psz_var, "mouse-x" ) )
  337.     {
  338.         switch( p_vout->p_sys->i_mode )
  339.         {
  340.         case TRANSFORM_MODE_270:
  341.             newval.i_int = p_vout->p_sys->p_vout->output.i_width
  342.                              - newval.i_int;
  343.         case TRANSFORM_MODE_90:
  344.             psz_var = "mouse-y";
  345.             break;
  347.         case TRANSFORM_MODE_180:
  348.         case TRANSFORM_MODE_HFLIP:
  349.             newval.i_int = p_vout->p_sys->p_vout->output.i_width
  350.                              - newval.i_int;
  351.             break;
  353.         case TRANSFORM_MODE_VFLIP:
  354.         default:
  355.             break;
  356.         }
  357.     }
  358.     else if( !strcmp( psz_var, "mouse-y" ) )
  359.     {
  360.         switch( p_vout->p_sys->i_mode )
  361.         {
  362.         case TRANSFORM_MODE_90:
  363.             newval.i_int = p_vout->p_sys->p_vout->output.i_height
  364.                              - newval.i_int;
  365.         case TRANSFORM_MODE_270:
  366.             psz_var = "mouse-x";
  367.             break;
  369.         case TRANSFORM_MODE_180:
  370.         case TRANSFORM_MODE_VFLIP:
  371.             newval.i_int = p_vout->p_sys->p_vout->output.i_height
  372.                              - newval.i_int;
  373.             break;
  375.         case TRANSFORM_MODE_HFLIP:
  376.         default:
  377.             break;
  378.         }
  379.     }
  381.     return var_Set( p_vout, psz_var, newval );
  382. }
  384. static void FilterPlanar( vout_thread_t *p_vout,
  385.                           const picture_t *p_pic, picture_t *p_outpic )
  386. {
  387.     int i_index;
  388.     switch( p_vout->p_sys->i_mode )
  389.     {
  390.         case TRANSFORM_MODE_90:
  391.             for( i_index = 0 ; i_index < p_pic->i_planes ; i_index++ )
  392.             {
  393.                 int i_pitch = p_pic->p[i_index].i_pitch;
  395.                 uint8_t *p_in = p_pic->p[i_index].p_pixels;
  397.                 uint8_t *p_out = p_outpic->p[i_index].p_pixels;
  398.                 uint8_t *p_out_end = p_out +
  399.                     p_outpic->p[i_index].i_visible_lines *
  400.                     p_outpic->p[i_index].i_pitch;
  402.                 for( ; p_out < p_out_end ; )
  403.                 {
  404.                     uint8_t *p_line_end;
  406.                     p_out_end -= p_outpic->p[i_index].i_pitch
  407.                                   - p_outpic->p[i_index].i_visible_pitch;
  408.                     p_line_end = p_in + p_pic->p[i_index].i_visible_lines *
  409.                         i_pitch;
  411.                     for( ; p_in < p_line_end ; )
  412.                     {
  413.                         p_line_end -= i_pitch;
  414.                         *(--p_out_end) = *p_line_end;
  415.                     }
  417.                     p_in++;
  418.                 }
  419.             }
  420.             break;
  422.         case TRANSFORM_MODE_180:
  423.             for( i_index = 0 ; i_index < p_pic->i_planes ; i_index++ )
  424.             {
  425.                 uint8_t *p_in = p_pic->p[i_index].p_pixels;
  426.                 uint8_t *p_in_end = p_in + p_pic->p[i_index].i_visible_lines
  427.                                             * p_pic->p[i_index].i_pitch;
  429.                 uint8_t *p_out = p_outpic->p[i_index].p_pixels;
  431.                 for( ; p_in < p_in_end ; )
  432.                 {
  433.                     uint8_t *p_line_start = p_in_end
  434.                                              - p_pic->p[i_index].i_pitch;
  435.                     p_in_end -= p_pic->p[i_index].i_pitch
  436.                                  - p_pic->p[i_index].i_visible_pitch;
  438.                     for( ; p_line_start < p_in_end ; )
  439.                     {
  440.                         *p_out++ = *(--p_in_end);
  441.                     }
  443.                     p_out += p_outpic->p[i_index].i_pitch
  444.                               - p_outpic->p[i_index].i_visible_pitch;
  445.                 }
  446.             }
  447.             break;
  449.         case TRANSFORM_MODE_270:
  450.             for( i_index = 0 ; i_index < p_pic->i_planes ; i_index++ )
  451.             {
  452.                 int i_pitch = p_pic->p[i_index].i_pitch;
  454.                 uint8_t *p_in = p_pic->p[i_index].p_pixels;
  456.                 uint8_t *p_out = p_outpic->p[i_index].p_pixels;
  457.                 uint8_t *p_out_end = p_out +
  458.                     p_outpic->p[i_index].i_visible_lines *
  459.                     p_outpic->p[i_index].i_pitch;
  461.                 for( ; p_out < p_out_end ; )
  462.                 {
  463.                     uint8_t *p_in_end;
  465.                     p_in_end = p_in + p_pic->p[i_index].i_visible_lines *
  466.                         i_pitch;
  468.                     for( ; p_in < p_in_end ; )
  469.                     {
  470.                         p_in_end -= i_pitch;
  471.                         *p_out++ = *p_in_end;
  472.                     }
  474.                     p_out += p_outpic->p[i_index].i_pitch
  475.                               - p_outpic->p[i_index].i_visible_pitch;
  476.                     p_in++;
  477.                 }
  478.             }
  479.             break;
  481.         case TRANSFORM_MODE_HFLIP:
  482.             for( i_index = 0 ; i_index < p_pic->i_planes ; i_index++ )
  483.             {
  484.                 uint8_t *p_in = p_pic->p[i_index].p_pixels;
  485.                 uint8_t *p_in_end = p_in + p_pic->p[i_index].i_visible_lines
  486.                                             * p_pic->p[i_index].i_pitch;
  488.                 uint8_t *p_out = p_outpic->p[i_index].p_pixels;
  490.                 for( ; p_in < p_in_end ; )
  491.                 {
  492.                     p_in_end -= p_pic->p[i_index].i_pitch;
  493.                     vlc_memcpy( p_out, p_in_end,
  494.                                 p_pic->p[i_index].i_visible_pitch );
  495.                     p_out += p_pic->p[i_index].i_pitch;
  496.                 }
  497.             }
  498.             break;
  500.         case TRANSFORM_MODE_VFLIP:
  501.             for( i_index = 0 ; i_index < p_pic->i_planes ; i_index++ )
  502.             {
  503.                 uint8_t *p_in = p_pic->p[i_index].p_pixels;
  504.                 uint8_t *p_in_end = p_in + p_pic->p[i_index].i_visible_lines
  505.                                          * p_pic->p[i_index].i_pitch;
  507.                 uint8_t *p_out = p_outpic->p[i_index].p_pixels;
  509.                 for( ; p_in < p_in_end ; )
  510.                 {
  511.                     uint8_t *p_line_end = p_in
  512.                                         + p_pic->p[i_index].i_visible_pitch;
  514.                     for( ; p_in < p_line_end ; )
  515.                     {
  516.                         *p_out++ = *(--p_line_end);
  517.                     }
  519.                     p_in += p_pic->p[i_index].i_pitch;
  520.                 }
  521.             }
  522.             break;
  524.         default:
  525.             break;
  526.     }
  527. }
  529. static void FilterI422( vout_thread_t *p_vout,
  530.                         const picture_t *p_pic, picture_t *p_outpic )
  531. {
  532.     int i_index;
  533.     switch( p_vout->p_sys->i_mode )
  534.     {
  535.         case TRANSFORM_MODE_180:
  536.         case TRANSFORM_MODE_HFLIP:
  537.         case TRANSFORM_MODE_VFLIP:
  538.             /* Fall back on the default implementation */
  539.             FilterPlanar( p_vout, p_pic, p_outpic );
  540.             return;
  542.         case TRANSFORM_MODE_90:
  543.             for( i_index = 0 ; i_index < p_pic->i_planes ; i_index++ )
  544.             {
  545.                 int i_pitch = p_pic->p[i_index].i_pitch;
  547.                 uint8_t *p_in = p_pic->p[i_index].p_pixels;
  549.                 uint8_t *p_out = p_outpic->p[i_index].p_pixels;
  550.                 uint8_t *p_out_end = p_out +
  551.                     p_outpic->p[i_index].i_visible_lines *
  552.                     p_outpic->p[i_index].i_pitch;
  554.                 if( i_index == 0 )
  555.                 {
  556.                     for( ; p_out < p_out_end ; )
  557.                     {
  558.                         uint8_t *p_line_end;
  560.                         p_out_end -= p_outpic->p[i_index].i_pitch
  561.                                       - p_outpic->p[i_index].i_visible_pitch;
  562.                         p_line_end = p_in + p_pic->p[i_index].i_visible_lines *
  563.                             i_pitch;
  565.                         for( ; p_in < p_line_end ; )
  566.                         {
  567.                             p_line_end -= i_pitch;
  568.                             *(--p_out_end) = *p_line_end;
  569.                         }
  571.                         p_in++;
  572.                     }
  573.                 }
  574.                 else /* i_index == 1 or 2 */
  575.                 {
  576.                     for( ; p_out < p_out_end ; )
  577.                     {
  578.                         uint8_t *p_line_end, *p_out_end2;
  580.                         p_out_end -= p_outpic->p[i_index].i_pitch
  581.                                       - p_outpic->p[i_index].i_visible_pitch;
  582.                         p_out_end2 = p_out_end - p_outpic->p[i_index].i_pitch;
  583.                         p_line_end = p_in + p_pic->p[i_index].i_visible_lines *
  584.                             i_pitch;
  586.                         for( ; p_in < p_line_end ; )
  587.                         {
  588.                             uint8_t p1, p2;
  590.                             p_line_end -= i_pitch;
  591.                             p1 = *p_line_end;
  592.                             p_line_end -= i_pitch;
  593.                             p2 = *p_line_end;
  595.                             /* Trick for (x+y)/2 without overflow, based on
  596.                              *   x + y == (x ^ y) + 2 * (x & y) */
  597.                             *(--p_out_end) = (p1 & p2) + ((p1 ^ p2) / 2);
  598.                             *(--p_out_end2) = (p1 & p2) + ((p1 ^ p2) / 2);
  599.                         }
  601.                         p_out_end = p_out_end2;
  602.                         p_in++;
  603.                     }
  604.                 }
  605.             }
  606.             break;
  608.         case TRANSFORM_MODE_270:
  609.             for( i_index = 0 ; i_index < p_pic->i_planes ; i_index++ )
  610.             {
  611.                 int i_pitch = p_pic->p[i_index].i_pitch;
  613.                 uint8_t *p_in = p_pic->p[i_index].p_pixels;
  615.                 uint8_t *p_out = p_outpic->p[i_index].p_pixels;
  616.                 uint8_t *p_out_end = p_out +
  617.                     p_outpic->p[i_index].i_visible_lines *
  618.                     p_outpic->p[i_index].i_pitch;
  620.                 if( i_index == 0 )
  621.                 {
  622.                     for( ; p_out < p_out_end ; )
  623.                     {
  624.                         uint8_t *p_in_end;
  626.                         p_in_end = p_in + p_pic->p[i_index].i_visible_lines *
  627.                             i_pitch;
  629.                         for( ; p_in < p_in_end ; )
  630.                         {
  631.                             p_in_end -= i_pitch;
  632.                             *p_out++ = *p_in_end;
  633.                         }
  635.                         p_out += p_outpic->p[i_index].i_pitch
  636.                                   - p_outpic->p[i_index].i_visible_pitch;
  637.                         p_in++;
  638.                     }
  639.                 }
  640.                 else /* i_index == 1 or 2 */
  641.                 {
  642.                     for( ; p_out < p_out_end ; )
  643.                     {
  644.                         uint8_t *p_in_end, *p_out2;
  646.                         p_in_end = p_in + p_pic->p[i_index].i_visible_lines *
  647.                             i_pitch;
  648.                         p_out2 = p_out + p_outpic->p[i_index].i_pitch;
  650.                         for( ; p_in < p_in_end ; )
  651.                         {
  652.                             uint8_t p1, p2;
  654.                             p_in_end -= i_pitch;
  655.                             p1 = *p_in_end;
  656.                             p_in_end -= i_pitch;
  657.                             p2 = *p_in_end;
  659.                             /* Trick for (x+y)/2 without overflow, based on
  660.                              *   x + y == (x ^ y) + 2 * (x & y) */
  661.                             *p_out++ = (p1 & p2) + ((p1 ^ p2) / 2);
  662.                             *p_out2++ = (p1 & p2) + ((p1 ^ p2) / 2);
  663.                         }
  665.                         p_out2 += p_outpic->p[i_index].i_pitch
  666.                                    - p_outpic->p[i_index].i_visible_pitch;
  667.                         p_out = p_out2;
  668.                         p_in++;
  669.                     }
  670.                 }
  671.             }
  672.             break;
  674.         default:
  675.             break;
  676.     }
  677. }
  679. static void FilterYUYV( vout_thread_t *p_vout,
  680.                         const picture_t *p_pic, picture_t *p_outpic )
  681. {
  682.     int i_index;
  683.     int i_y_offset, i_u_offset, i_v_offset;
  684.     if( GetPackedYuvOffsets( p_pic->format.i_chroma, &i_y_offset,
  685.                              &i_u_offset, &i_v_offset ) != VLC_SUCCESS )
  686.         return;
  688.     switch( p_vout->p_sys->i_mode )
  689.     {
  690.         case TRANSFORM_MODE_HFLIP:
  691.             /* Fall back on the default implementation */
  692.             FilterPlanar( p_vout, p_pic, p_outpic );
  693.             return;
  695.         case TRANSFORM_MODE_90:
  696.             for( i_index = 0 ; i_index < p_pic->i_planes ; i_index++ )
  697.             {
  698.                 int i_pitch = p_pic->p[i_index].i_pitch;
  700.                 uint8_t *p_in = p_pic->p[i_index].p_pixels;
  702.                 uint8_t *p_out = p_outpic->p[i_index].p_pixels;
  703.                 uint8_t *p_out_end = p_out +
  704.                     p_outpic->p[i_index].i_visible_lines *
  705.                     p_outpic->p[i_index].i_pitch;
  707.                 int i_offset  = i_u_offset;
  708.                 int i_offset2 = i_v_offset;
  709.                 for( ; p_out < p_out_end ; )
  710.                 {
  711.                     uint8_t *p_line_end;
  713.                     p_out_end -= p_outpic->p[i_index].i_pitch
  714.                                   - p_outpic->p[i_index].i_visible_pitch;
  715.                     p_line_end = p_in + p_pic->p[i_index].i_visible_lines *
  716.                         i_pitch;
  718.                     for( ; p_in < p_line_end ; )
  719.                     {
  720.                         p_line_end -= i_pitch;
  721.                         p_out_end -= 4;
  722.                         p_out_end[i_y_offset+2] = p_line_end[i_y_offset];
  723.                         p_out_end[i_u_offset] = p_line_end[i_offset];
  724.                         p_line_end -= i_pitch;
  725.                         p_out_end[i_y_offset] = p_line_end[i_y_offset];
  726.                         p_out_end[i_v_offset] = p_line_end[i_offset2];
  727.                     }
  729.                     p_in += 2;
  731.                     {
  732.                         int a = i_offset;
  733.                         i_offset = i_offset2;
  734.                         i_offset2 = a;
  735.                     }
  736.                 }
  737.             }
  738.             break;
  740.         case TRANSFORM_MODE_180:
  741.             for( i_index = 0 ; i_index < p_pic->i_planes ; i_index++ )
  742.             {
  743.                 uint8_t *p_in = p_pic->p[i_index].p_pixels;
  744.                 uint8_t *p_in_end = p_in + p_pic->p[i_index].i_visible_lines
  745.                                             * p_pic->p[i_index].i_pitch;
  747.                 uint8_t *p_out = p_outpic->p[i_index].p_pixels;
  749.                 for( ; p_in < p_in_end ; )
  750.                 {
  751.                     uint8_t *p_line_start = p_in_end
  752.                                              - p_pic->p[i_index].i_pitch;
  753.                     p_in_end -= p_pic->p[i_index].i_pitch
  754.                                  - p_pic->p[i_index].i_visible_pitch;
  756.                     for( ; p_line_start < p_in_end ; )
  757.                     {
  758.                         p_in_end -= 4;
  759.                         p_out[i_y_offset] = p_in_end[i_y_offset+2];
  760.                         p_out[i_u_offset] = p_in_end[i_u_offset];
  761.                         p_out[i_y_offset+2] = p_in_end[i_y_offset];
  762.                         p_out[i_v_offset] = p_in_end[i_v_offset];
  763.                         p_out += 4;
  764.                     }
  766.                     p_out += p_outpic->p[i_index].i_pitch
  767.                               - p_outpic->p[i_index].i_visible_pitch;
  768.                 }
  769.             }
  770.             break;
  772.         case TRANSFORM_MODE_270:
  773.             for( i_index = 0 ; i_index < p_pic->i_planes ; i_index++ )
  774.             {
  775.                 int i_pitch = p_pic->p[i_index].i_pitch;
  777.                 uint8_t *p_in = p_pic->p[i_index].p_pixels;
  779.                 uint8_t *p_out = p_outpic->p[i_index].p_pixels;
  780.                 uint8_t *p_out_end = p_out +
  781.                     p_outpic->p[i_index].i_visible_lines *
  782.                     p_outpic->p[i_index].i_pitch;
  784.                 int i_offset  = i_u_offset;
  785.                 int i_offset2 = i_v_offset;
  786.                 for( ; p_out < p_out_end ; )
  787.                 {
  788.                     uint8_t *p_in_end;
  790.                     p_in_end = p_in
  791.                              + p_pic->p[i_index].i_visible_lines * i_pitch;
  793.                     for( ; p_in < p_in_end ; )
  794.                     {
  795.                         p_in_end -= i_pitch;
  796.                         p_out[i_y_offset] = p_in_end[i_y_offset];
  797.                         p_out[i_u_offset] = p_in_end[i_offset];
  798.                         p_in_end -= i_pitch;
  799.                         p_out[i_y_offset+2] = p_in_end[i_y_offset];
  800.                         p_out[i_v_offset] = p_in_end[i_offset2];
  801.                         p_out += 4;
  802.                     }
  804.                     p_out += p_outpic->p[i_index].i_pitch
  805.                            - p_outpic->p[i_index].i_visible_pitch;
  806.                     p_in += 2;
  808.                     {
  809.                         int a = i_offset;
  810.                         i_offset = i_offset2;
  811.                         i_offset2 = a;
  812.                     }
  813.                 }
  814.             }
  815.             break;
  817.         case TRANSFORM_MODE_VFLIP:
  818.             for( i_index = 0 ; i_index < p_pic->i_planes ; i_index++ )
  819.             {
  820.                 uint8_t *p_in = p_pic->p[i_index].p_pixels;
  821.                 uint8_t *p_in_end = p_in + p_pic->p[i_index].i_visible_lines
  822.                                          * p_pic->p[i_index].i_pitch;
  824.                 uint8_t *p_out = p_outpic->p[i_index].p_pixels;
  826.                 for( ; p_in < p_in_end ; )
  827.                 {
  828.                     uint8_t *p_line_end = p_in
  829.                                         + p_pic->p[i_index].i_visible_pitch;
  831.                     for( ; p_in < p_line_end ; )
  832.                     {
  833.                         p_line_end -= 4;
  834.                         p_out[i_y_offset] = p_line_end[i_y_offset+2];
  835.                         p_out[i_u_offset] = p_line_end[i_u_offset];
  836.                         p_out[i_y_offset+2] = p_line_end[i_y_offset];
  837.                         p_out[i_v_offset] = p_line_end[i_v_offset];
  838.                         p_out += 4;
  839.                     }
  841.                     p_in += p_pic->p[i_index].i_pitch;
  842.                 }
  843.             }
  844.             break;
  846.         default:
  847.             break;
  848.     }
  849. }