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

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

midi

开发平台：

Unix_Linux

deinterlace.c：源码内容
  1. /*****************************************************************************
  2.  * deinterlace.c : deinterlacer plugin for vlc
  3.  *****************************************************************************
  4.  * Copyright (C) 2000, 2001, 2002, 2003 the VideoLAN team
  5.  * $Id: ab0f9bbd2b9c0ef3714ce4a0aeb2009878831600 $
  6.  *
  7.  * Author: Sam 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 <errno.h>
  33. #include <assert.h>
  35. #ifdef HAVE_ALTIVEC_H
  36. #   include <altivec.h>
  37. #endif
  39. #include <vlc_common.h>
  40. #include <vlc_plugin.h>
  41. #include <vlc_vout.h>
  42. #include <vlc_sout.h>
  43. #include "vlc_filter.h"
  45. #ifdef CAN_COMPILE_MMXEXT
  46. #   include "mmx.h"
  47. #endif
  49. #include "filter_common.h"
  51. #define DEINTERLACE_DISCARD 1
  52. #define DEINTERLACE_MEAN    2
  53. #define DEINTERLACE_BLEND   3
  54. #define DEINTERLACE_BOB     4
  55. #define DEINTERLACE_LINEAR  5
  56. #define DEINTERLACE_X       6
  57. #define DEINTERLACE_YADIF   7
  58. #define DEINTERLACE_YADIF2X 8
  60. /*****************************************************************************
  61.  * Local protypes
  62.  *****************************************************************************/
  63. static int  Create    ( vlc_object_t * );
  64. static void Destroy   ( vlc_object_t * );
  66. static int  Init      ( vout_thread_t * );
  67. static void End       ( vout_thread_t * );
  68. static void Render    ( vout_thread_t *, picture_t * );
  70. static int  MouseEvent( vlc_object_t *p_this, char const *psz_var,
  71.                         vlc_value_t oldval, vlc_value_t newval, void *p_data );
  73. static void RenderDiscard( vout_thread_t *, picture_t *, picture_t *, int );
  74. static void RenderBob    ( vout_thread_t *, picture_t *, picture_t *, int );
  75. static void RenderMean   ( vout_thread_t *, picture_t *, picture_t * );
  76. static void RenderBlend  ( vout_thread_t *, picture_t *, picture_t * );
  77. static void RenderLinear ( vout_thread_t *, picture_t *, picture_t *, int );
  78. static void RenderX      ( picture_t *, picture_t * );
  79. static void RenderYadif  ( vout_thread_t *, picture_t *, picture_t *, int, int );
  81. static void MergeGeneric ( void *, const void *, const void *, size_t );
  82. #if defined(CAN_COMPILE_C_ALTIVEC)
  83. static void MergeAltivec ( void *, const void *, const void *, size_t );
  84. #endif
  85. #if defined(CAN_COMPILE_MMXEXT)
  86. static void MergeMMXEXT  ( void *, const void *, const void *, size_t );
  87. #endif
  88. #if defined(CAN_COMPILE_3DNOW)
  89. static void Merge3DNow   ( void *, const void *, const void *, size_t );
  90. #endif
  91. #if defined(CAN_COMPILE_SSE)
  92. static void MergeSSE2    ( void *, const void *, const void *, size_t );
  93. #endif
  94. #if defined(CAN_COMPILE_MMXEXT) || defined(CAN_COMPILE_SSE)
  95. static void EndMMX       ( void );
  96. #endif
  97. #if defined(CAN_COMPILE_3DNOW)
  98. static void End3DNow     ( void );
  99. #endif
  101. static void SetFilterMethod( vout_thread_t *p_vout, char *psz_method );
  102. static vout_thread_t *SpawnRealVout( vout_thread_t *p_vout );
  104. static int OpenFilter( vlc_object_t *p_this );
  105. static void CloseFilter( vlc_object_t *p_this );
  107. /*****************************************************************************
  108.  * Callback prototypes
  109.  *****************************************************************************/
  110. static int FilterCallback( vlc_object_t *, char const *,
  111.                            vlc_value_t, vlc_value_t, void * );
  113. /*****************************************************************************
  114.  * Module descriptor
  115.  *****************************************************************************/
  116. #define MODE_TEXT N_("Deinterlace mode")
  117. #define MODE_LONGTEXT N_("Deinterlace method to use for local playback.")
  119. #define SOUT_MODE_TEXT N_("Streaming deinterlace mode")
  120. #define SOUT_MODE_LONGTEXT N_("Deinterlace method to use for streaming.")
  122. #define FILTER_CFG_PREFIX "sout-deinterlace-"
  124. static const char *const mode_list[] = {
  125.     "discard", "blend", "mean", "bob", "linear", "x", "yadif", "yadif2x" };
  126. static const char *const mode_list_text[] = {
  127.     N_("Discard"), N_("Blend"), N_("Mean"), N_("Bob"), N_("Linear"), "X", "Yadif", "Yadif (2x)" };
  129. vlc_module_begin ()
  130.     set_description( N_("Deinterlacing video filter") )
  131.     set_shortname( N_("Deinterlace" ))
  132.     set_capability( "video filter", 0 )
  133.     set_category( CAT_VIDEO )
  134.     set_subcategory( SUBCAT_VIDEO_VFILTER )
  136.     set_section( N_("Display"),NULL)
  137.     add_string( "deinterlace-mode", "discard", NULL, MODE_TEXT,
  138.                 MODE_LONGTEXT, false )
  139.         change_string_list( mode_list, mode_list_text, 0 )
  140.         change_safe ()
  142.     add_shortcut( "deinterlace" )
  143.     set_callbacks( Create, Destroy )
  145.     add_submodule ()
  146.     set_capability( "video filter2", 0 )
  147.     set_section( N_("Streaming"),NULL)
  148.     add_string( FILTER_CFG_PREFIX "mode", "blend", NULL, SOUT_MODE_TEXT,
  149.                 SOUT_MODE_LONGTEXT, false )
  150.         change_string_list( mode_list, mode_list_text, 0 )
  151.     add_shortcut( "deinterlace" )
  152.     set_callbacks( OpenFilter, CloseFilter )
  153. vlc_module_end ()
  155. static const char *const ppsz_filter_options[] = {
  156.     "mode", NULL
  157. };
  159. /*****************************************************************************
  160.  * vout_sys_t: Deinterlace video output method descriptor
  161.  *****************************************************************************
  162.  * This structure is part of the video output thread descriptor.
  163.  * It describes the Deinterlace specific properties of an output thread.
  164.  *****************************************************************************/
  165. #define HISTORY_SIZE (3)
  166. struct vout_sys_t
  167. {
  168.     int        i_mode;        /* Deinterlace mode */
  169.     bool b_double_rate; /* Shall we double the framerate? */
  170.     bool b_half_height; /* Shall be devide the height by 2 */
  172.     mtime_t    last_date;
  173.     mtime_t    next_date;
  175.     vout_thread_t *p_vout;
  177.     vlc_mutex_t filter_lock;
  179.     void (*pf_merge) ( void *, const void *, const void *, size_t );
  180.     void (*pf_end_merge) ( void );
  182.     /* Yadif */
  183.     picture_t *pp_history[HISTORY_SIZE];
  184. };
  186. /*****************************************************************************
  187.  * Control: control facility for the vout (forwards to child vout)
  188.  *****************************************************************************/
  189. static int Control( vout_thread_t *p_vout, int i_query, va_list args )
  190. {
  191.     return vout_vaControl( p_vout->p_sys->p_vout, i_query, args );
  192. }
  194. /*****************************************************************************
  195.  * Create: allocates Deinterlace video thread output method
  196.  *****************************************************************************
  197.  * This function allocates and initializes a Deinterlace vout method.
  198.  *****************************************************************************/
  199. static int Create( vlc_object_t *p_this )
  200. {
  201.     vout_thread_t *p_vout = (vout_thread_t *)p_this;
  202.     vlc_value_t val;
  204.     /* Allocate structure */
  205.     p_vout->p_sys = malloc( sizeof( vout_sys_t ) );
  206.     if( p_vout->p_sys == NULL )
  207.         return VLC_ENOMEM;
  209.     p_vout->pf_init = Init;
  210.     p_vout->pf_end = End;
  211.     p_vout->pf_manage = NULL;
  212.     p_vout->pf_render = Render;
  213.     p_vout->pf_display = NULL;
  214.     p_vout->pf_control = Control;
  216.     p_vout->p_sys->i_mode = DEINTERLACE_DISCARD;
  217.     p_vout->p_sys->b_double_rate = false;
  218.     p_vout->p_sys->b_half_height = true;
  219.     p_vout->p_sys->last_date = 0;
  220.     p_vout->p_sys->p_vout = 0;
  221.     vlc_mutex_init( &p_vout->p_sys->filter_lock );
  223. #if defined(CAN_COMPILE_C_ALTIVEC)
  224.     if( vlc_CPU() & CPU_CAPABILITY_ALTIVEC )
  225.     {
  226.         p_vout->p_sys->pf_merge = MergeAltivec;
  227.         p_vout->p_sys->pf_end_merge = NULL;
  228.     }
  229.     else
  230. #endif
  231. #if defined(CAN_COMPILE_SSE)
  232.     if( vlc_CPU() & CPU_CAPABILITY_SSE2 )
  233.     {
  234.         p_vout->p_sys->pf_merge = MergeSSE2;
  235.         p_vout->p_sys->pf_end_merge = EndMMX;
  236.     }
  237.     else
  238. #endif
  239. #if defined(CAN_COMPILE_MMXEXT)
  240.     if( vlc_CPU() & CPU_CAPABILITY_MMXEXT )
  241.     {
  242.         p_vout->p_sys->pf_merge = MergeMMXEXT;
  243.         p_vout->p_sys->pf_end_merge = EndMMX;
  244.     }
  245.     else
  246. #endif
  247. #if defined(CAN_COMPILE_3DNOW)
  248.     if( vlc_CPU() & CPU_CAPABILITY_3DNOW )
  249.     {
  250.         p_vout->p_sys->pf_merge = Merge3DNow;
  251.         p_vout->p_sys->pf_end_merge = End3DNow;
  252.     }
  253.     else
  254. #endif
  255.     {
  256.         p_vout->p_sys->pf_merge = MergeGeneric;
  257.         p_vout->p_sys->pf_end_merge = NULL;
  258.     }
  260.     /* Look what method was requested */
  261.     var_Create( p_vout, "deinterlace-mode", VLC_VAR_STRING );
  262.     var_Change( p_vout, "deinterlace-mode", VLC_VAR_INHERITVALUE, &val, NULL );
  264.     if( val.psz_string == NULL )
  265.     {
  266.         msg_Err( p_vout, "configuration variable deinterlace-mode empty" );
  267.         msg_Err( p_vout, "no deinterlace mode provided, using "discard"" );
  269.         val.psz_string = strdup( "discard" );
  270.     }
  272.     msg_Dbg( p_vout, "using %s deinterlace mode", val.psz_string );
  274.     SetFilterMethod( p_vout, val.psz_string );
  276.     free( val.psz_string );
  278.     return VLC_SUCCESS;
  279. }
  281. /*****************************************************************************
  282.  * SetFilterMethod: setup the deinterlace method to use.
  283.  *****************************************************************************/
  284. static void SetFilterMethod( vout_thread_t *p_vout, char *psz_method )
  285. {
  286.     if( !strcmp( psz_method, "mean" ) )
  287.     {
  288.         p_vout->p_sys->i_mode = DEINTERLACE_MEAN;
  289.         p_vout->p_sys->b_double_rate = false;
  290.         p_vout->p_sys->b_half_height = true;
  291.     }
  292.     else if( !strcmp( psz_method, "blend" )
  293.              || !strcmp( psz_method, "average" )
  294.              || !strcmp( psz_method, "combine-fields" ) )
  295.     {
  296.         p_vout->p_sys->i_mode = DEINTERLACE_BLEND;
  297.         p_vout->p_sys->b_double_rate = false;
  298.         p_vout->p_sys->b_half_height = false;
  299.     }
  300.     else if( !strcmp( psz_method, "bob" )
  301.              || !strcmp( psz_method, "progressive-scan" ) )
  302.     {
  303.         p_vout->p_sys->i_mode = DEINTERLACE_BOB;
  304.         p_vout->p_sys->b_double_rate = true;
  305.         p_vout->p_sys->b_half_height = false;
  306.     }
  307.     else if( !strcmp( psz_method, "linear" ) )
  308.     {
  309.         p_vout->p_sys->i_mode = DEINTERLACE_LINEAR;
  310.         p_vout->p_sys->b_double_rate = true;
  311.         p_vout->p_sys->b_half_height = false;
  312.     }
  313.     else if( !strcmp( psz_method, "x" ) )
  314.     {
  315.         p_vout->p_sys->i_mode = DEINTERLACE_X;
  316.         p_vout->p_sys->b_double_rate = false;
  317.         p_vout->p_sys->b_half_height = false;
  318.     }
  319.     else if( !strcmp( psz_method, "yadif" ) )
  320.     {
  321.         p_vout->p_sys->i_mode = DEINTERLACE_YADIF;
  322.         p_vout->p_sys->b_double_rate = false;
  323.         p_vout->p_sys->b_half_height = false;
  324.     }
  325.     else if( !strcmp( psz_method, "yadif2x" ) )
  326.     {
  327.         p_vout->p_sys->i_mode = DEINTERLACE_YADIF2X;
  328.         p_vout->p_sys->b_double_rate = true;
  329.         p_vout->p_sys->b_half_height = false;
  330.     }
  331.     else
  332.     {
  333.         const bool b_i422 = p_vout->render.i_chroma == VLC_FOURCC('I','4','2','2');
  334.         if( strcmp( psz_method, "discard" ) )
  335.             msg_Err( p_vout, "no valid deinterlace mode provided, "
  336.                      "using "discard"" );
  338.         p_vout->p_sys->i_mode = DEINTERLACE_DISCARD;
  339.         p_vout->p_sys->b_double_rate = false;
  340.         p_vout->p_sys->b_half_height = !b_i422;
  341.     }
  343.     msg_Dbg( p_vout, "using %s deinterlace method", psz_method );
  344. }
  346. static void GetOutputFormat( vout_thread_t *p_vout,
  347.                              video_format_t *p_dst, const video_format_t *p_src )
  348. {
  349.     *p_dst = *p_src;
  351.     if( p_vout->p_sys->b_half_height )
  352.     {
  353.         p_dst->i_height /= 2;
  354.         p_dst->i_visible_height /= 2;
  355.         p_dst->i_y_offset /= 2;
  356.         p_dst->i_sar_den *= 2;
  357.     }
  359.     if( p_src->i_chroma == VLC_FOURCC('I','4','2','2') )
  360.     {
  361.         switch( p_vout->p_sys->i_mode )
  362.         {
  363.         case DEINTERLACE_MEAN:
  364.         case DEINTERLACE_LINEAR:
  365.         case DEINTERLACE_X:
  366.         case DEINTERLACE_YADIF:
  367.         case DEINTERLACE_YADIF2X:
  368.             p_dst->i_chroma = VLC_FOURCC('I','4','2','2');
  369.             break;
  370.         default:
  371.             p_dst->i_chroma = VLC_FOURCC('I','4','2','0');
  372.             break;
  373.         }
  374.     }
  375. }
  377. static bool IsChromaSupported( vlc_fourcc_t i_chroma )
  378. {
  379.     return i_chroma == VLC_FOURCC('I','4','2','0') ||
  380.            i_chroma == VLC_FOURCC('I','Y','U','V') ||
  381.            i_chroma == VLC_FOURCC('Y','V','1','2') ||
  382.            i_chroma == VLC_FOURCC('I','4','2','2');
  383. }
  385. /*****************************************************************************
  386.  * Init: initialize Deinterlace video thread output method
  387.  *****************************************************************************/
  388. static int Init( vout_thread_t *p_vout )
  389. {
  390.     I_OUTPUTPICTURES = 0;
  392.     if( !IsChromaSupported( p_vout->render.i_chroma ) )
  393.         return VLC_EGENERIC; /* unknown chroma */
  395.     /* Initialize the output structure, full of directbuffers since we want
  396.      * the decoder to output directly to our structures. */
  397.     p_vout->output.i_chroma = p_vout->render.i_chroma;
  398.     p_vout->output.i_width  = p_vout->render.i_width;
  399.     p_vout->output.i_height = p_vout->render.i_height;
  400.     p_vout->output.i_aspect = p_vout->render.i_aspect;
  401.     p_vout->fmt_out = p_vout->fmt_in;
  403.     /* Try to open the real video output */
  404.     p_vout->p_sys->p_vout = SpawnRealVout( p_vout );
  406.     if( p_vout->p_sys->p_vout == NULL )
  407.     {
  408.         /* Everything failed */
  409.         msg_Err( p_vout, "cannot open vout, aborting" );
  411.         return VLC_EGENERIC;
  412.     }
  414.     for( int i = 0; i < HISTORY_SIZE; i++ )
  415.         p_vout->p_sys->pp_history[i] = NULL;
  417.     vout_filter_AllocateDirectBuffers( p_vout, VOUT_MAX_PICTURES );
  419.     vout_filter_AddChild( p_vout, p_vout->p_sys->p_vout, MouseEvent );
  421.     var_AddCallback( p_vout, "deinterlace-mode", FilterCallback, NULL );
  423.     return VLC_SUCCESS;
  424. }
  426. /*****************************************************************************
  427.  * SpawnRealVout: spawn the real video output.
  428.  *****************************************************************************/
  429. static vout_thread_t *SpawnRealVout( vout_thread_t *p_vout )
  430. {
  431.     msg_Dbg( p_vout, "spawning the real video output" );
  433.     video_format_t fmt;
  434.     GetOutputFormat( p_vout, &fmt, &p_vout->fmt_out );
  436.     return vout_Create( p_vout, &fmt );
  437. }
  439. /*****************************************************************************
  440.  * End: terminate Deinterlace video thread output method
  441.  *****************************************************************************/
  442. static void End( vout_thread_t *p_vout )
  443. {
  444.     vout_sys_t *p_sys = p_vout->p_sys;
  446.     var_DelCallback( p_vout, "deinterlace-mode", FilterCallback, NULL );
  448.     for( int i = 0; i < HISTORY_SIZE; i++ )
  449.     {
  450.         if( p_sys->pp_history[i] )
  451.             picture_Release( p_sys->pp_history[i] );
  452.     }
  454.     if( p_sys->p_vout )
  455.     {
  456.         vout_filter_DelChild( p_vout, p_sys->p_vout, MouseEvent );
  457.         vout_CloseAndRelease( p_sys->p_vout );
  458.     }
  460.     vout_filter_ReleaseDirectBuffers( p_vout );
  461. }
  463. /*****************************************************************************
  464.  * Destroy: destroy Deinterlace video thread output method
  465.  *****************************************************************************
  466.  * Terminate an output method created by DeinterlaceCreateOutputMethod
  467.  *****************************************************************************/
  468. static void Destroy( vlc_object_t *p_this )
  469. {
  470.     vout_thread_t *p_vout = (vout_thread_t *)p_this;
  471.     vlc_mutex_destroy( &p_vout->p_sys->filter_lock );
  472.     free( p_vout->p_sys );
  473. }
  475. /**
  476.  * Forward mouse event with proper conversion.
  477.  */
  478. static int MouseEvent( vlc_object_t *p_this, char const *psz_var,
  479.                        vlc_value_t oldval, vlc_value_t newval, void *p_data )
  480. {
  481.     vout_thread_t *p_vout = p_data;
  482.     VLC_UNUSED(p_this); VLC_UNUSED(oldval);
  484.     if( !strcmp( psz_var, "mouse-y" ) && p_vout->p_sys->b_half_height )
  485.         newval.i_int *= 2;
  487.     return var_Set( p_vout, psz_var, newval );
  488. }
  490. /*****************************************************************************
  491.  * Render: displays previously rendered output
  492.  *****************************************************************************
  493.  * This function send the currently rendered image to Deinterlace image,
  494.  * waits until it is displayed and switch the two rendering buffers, preparing
  495.  * next frame.
  496.  *****************************************************************************/
  497. static void Render ( vout_thread_t *p_vout, picture_t *p_pic )
  498. {
  499.     vout_sys_t *p_sys = p_vout->p_sys;
  500.     picture_t *pp_outpic[2];
  502.     /* FIXME are they needed ? */
  503.     p_vout->fmt_out.i_x_offset = p_vout->fmt_in.i_x_offset;
  504.     p_vout->fmt_out.i_y_offset = p_vout->fmt_in.i_y_offset;
  505.     p_vout->fmt_out.i_visible_width = p_vout->fmt_in.i_visible_width;
  506.     p_vout->fmt_out.i_visible_height = p_vout->fmt_in.i_visible_height;
  508.     /* FIXME p_sys->p_vout->* should NOT be changed FIXME */
  509.     p_sys->p_vout->fmt_in.i_x_offset = p_vout->fmt_out.i_x_offset;
  510.     p_sys->p_vout->fmt_in.i_y_offset = p_vout->fmt_out.i_y_offset;
  511.     p_sys->p_vout->fmt_in.i_visible_width = p_vout->fmt_out.i_visible_width;
  512.     p_sys->p_vout->fmt_in.i_visible_height = p_vout->fmt_in.i_visible_height;
  513.     if( p_vout->p_sys->b_half_height )
  514.     {
  515.         p_sys->p_vout->fmt_in.i_y_offset /= 2;
  516.         p_sys->p_vout->fmt_in.i_visible_height /= 2;
  517.     }
  519.     if( p_vout->i_changes & VOUT_ASPECT_CHANGE )
  520.     {
  521.         p_vout->i_changes &= ~VOUT_ASPECT_CHANGE;
  523.         p_vout->fmt_out.i_aspect = p_vout->fmt_in.i_aspect;
  524.         p_vout->fmt_out.i_sar_num = p_vout->fmt_in.i_sar_num;
  525.         p_vout->fmt_out.i_sar_den = p_vout->fmt_in.i_sar_den;
  527.         video_format_t fmt = p_vout->fmt_out;
  528.         if( p_vout->p_sys->b_half_height )
  529.         {
  530.             fmt.i_height /= 2; fmt.i_visible_height /= 2; fmt.i_y_offset /= 2;
  531.             fmt.i_sar_den *= 2;
  532.         }
  534.         p_sys->p_vout = vout_Request( p_vout, p_sys->p_vout, &fmt );
  535.     }
  536.     if( !p_sys->p_vout )
  537.         return;
  539.     pp_outpic[0] = pp_outpic[1] = NULL;
  541.     vlc_mutex_lock( &p_vout->p_sys->filter_lock );
  543.     /* Get a new picture */
  544.     while( ( pp_outpic[0] = vout_CreatePicture( p_vout->p_sys->p_vout,
  545.                                                 0, 0, 0 ) )
  546.               == NULL )
  547.     {
  548.         if( !vlc_object_alive( p_vout ) || p_vout->b_error )
  549.         {
  550.             vlc_mutex_unlock( &p_vout->p_sys->filter_lock );
  551.             return;
  552.         }
  553.         msleep( VOUT_OUTMEM_SLEEP );
  554.     }
  556.     pp_outpic[0]->date = p_pic->date;
  558.     /* If we are using double rate, get an additional new picture */
  559.     if( p_vout->p_sys->b_double_rate )
  560.     {
  561.         while( ( pp_outpic[1] = vout_CreatePicture( p_vout->p_sys->p_vout,
  562.                                                  0, 0, 0 ) )
  563.                   == NULL )
  564.         {
  565.             if( !vlc_object_alive( p_vout ) || p_vout->b_error )
  566.             {
  567.                 vout_DestroyPicture( p_vout->p_sys->p_vout, pp_outpic[0] );
  568.                 vlc_mutex_unlock( &p_vout->p_sys->filter_lock );
  569.                 return;
  570.             }
  571.             msleep( VOUT_OUTMEM_SLEEP );
  572.         }
  574.         /* 20ms is a bit arbitrary, but it's only for the first image we get */
  575.         if( !p_vout->p_sys->last_date )
  576.             pp_outpic[1]->date = p_pic->date + 20000;
  577.         else
  578.             pp_outpic[1]->date = (3 * p_pic->date - p_vout->p_sys->last_date) / 2;
  579.         p_vout->p_sys->last_date = p_pic->date;
  580.     }
  582.     switch( p_vout->p_sys->i_mode )
  583.     {
  584.         case DEINTERLACE_DISCARD:
  585.             RenderDiscard( p_vout, pp_outpic[0], p_pic, 0 );
  586.             vout_DisplayPicture( p_vout->p_sys->p_vout, pp_outpic[0] );
  587.             break;
  589.         case DEINTERLACE_BOB:
  590.             RenderBob( p_vout, pp_outpic[0], p_pic, p_pic->b_top_field_first ? 0 : 1 );
  591.             vout_DisplayPicture( p_vout->p_sys->p_vout, pp_outpic[0] );
  592.             RenderBob( p_vout, pp_outpic[1], p_pic, p_pic->b_top_field_first ? 1 : 0 );
  593.             vout_DisplayPicture( p_vout->p_sys->p_vout, pp_outpic[1] );
  594.             break;
  596.         case DEINTERLACE_LINEAR:
  597.             RenderLinear( p_vout, pp_outpic[0], p_pic, p_pic->b_top_field_first ? 0 : 1 );
  598.             vout_DisplayPicture( p_vout->p_sys->p_vout, pp_outpic[0] );
  599.             RenderLinear( p_vout, pp_outpic[1], p_pic, p_pic->b_top_field_first ? 1 : 0 );
  600.             vout_DisplayPicture( p_vout->p_sys->p_vout, pp_outpic[1] );
  601.             break;
  603.         case DEINTERLACE_MEAN:
  604.             RenderMean( p_vout, pp_outpic[0], p_pic );
  605.             vout_DisplayPicture( p_vout->p_sys->p_vout, pp_outpic[0] );
  606.             break;
  608.         case DEINTERLACE_BLEND:
  609.             RenderBlend( p_vout, pp_outpic[0], p_pic );
  610.             vout_DisplayPicture( p_vout->p_sys->p_vout, pp_outpic[0] );
  611.             break;
  613.         case DEINTERLACE_X:
  614.             RenderX( pp_outpic[0], p_pic );
  615.             vout_DisplayPicture( p_vout->p_sys->p_vout, pp_outpic[0] );
  616.             break;
  618.         case DEINTERLACE_YADIF:
  619.             RenderYadif( p_vout, pp_outpic[0], p_pic, 0, 0 );
  620.             vout_DisplayPicture( p_vout->p_sys->p_vout, pp_outpic[0] );
  621.             break;
  623.         case DEINTERLACE_YADIF2X:
  624.             RenderYadif( p_vout, pp_outpic[0], p_pic, 0, p_pic->b_top_field_first ? 0 : 1 );
  625.             vout_DisplayPicture( p_vout->p_sys->p_vout, pp_outpic[0] );
  626.             RenderYadif( p_vout, pp_outpic[1], p_pic, 1, p_pic->b_top_field_first ? 1 : 0 );
  627.             vout_DisplayPicture( p_vout->p_sys->p_vout, pp_outpic[1] );
  628.             break;
  629.     }
  630.     vlc_mutex_unlock( &p_vout->p_sys->filter_lock );
  631. }
  633. /*****************************************************************************
  634.  * RenderDiscard: only keep TOP or BOTTOM field, discard the other.
  635.  *****************************************************************************/
  636. static void RenderDiscard( vout_thread_t *p_vout,
  637.                            picture_t *p_outpic, picture_t *p_pic, int i_field )
  638. {
  639.     int i_plane;
  641.     /* Copy image and skip lines */
  642.     for( i_plane = 0 ; i_plane < p_pic->i_planes ; i_plane++ )
  643.     {
  644.         uint8_t *p_in, *p_out_end, *p_out;
  645.         int i_increment;
  647.         p_in = p_pic->p[i_plane].p_pixels
  648.                    + i_field * p_pic->p[i_plane].i_pitch;
  650.         p_out = p_outpic->p[i_plane].p_pixels;
  651.         p_out_end = p_out + p_outpic->p[i_plane].i_pitch
  652.                              * p_outpic->p[i_plane].i_visible_lines;
  654.         switch( p_vout->render.i_chroma )
  655.         {
  656.         case VLC_FOURCC('I','4','2','0'):
  657.         case VLC_FOURCC('I','Y','U','V'):
  658.         case VLC_FOURCC('Y','V','1','2'):
  660.             for( ; p_out < p_out_end ; )
  661.             {
  662.                 vlc_memcpy( p_out, p_in, p_pic->p[i_plane].i_pitch );
  664.                 p_out += p_outpic->p[i_plane].i_pitch;
  665.                 p_in += 2 * p_pic->p[i_plane].i_pitch;
  666.             }
  667.             break;
  669.         case VLC_FOURCC('I','4','2','2'):
  671.             i_increment = 2 * p_pic->p[i_plane].i_pitch;
  673.             if( i_plane == Y_PLANE )
  674.             {
  675.                 for( ; p_out < p_out_end ; )
  676.                 {
  677.                     vlc_memcpy( p_out, p_in, p_pic->p[i_plane].i_pitch );
  678.                     p_out += p_outpic->p[i_plane].i_pitch;
  679.                     vlc_memcpy( p_out, p_in, p_pic->p[i_plane].i_pitch );
  680.                     p_out += p_outpic->p[i_plane].i_pitch;
  681.                     p_in += i_increment;
  682.                 }
  683.             }
  684.             else
  685.             {
  686.                 for( ; p_out < p_out_end ; )
  687.                 {
  688.                     vlc_memcpy( p_out, p_in, p_pic->p[i_plane].i_pitch );
  689.                     p_out += p_outpic->p[i_plane].i_pitch;
  690.                     p_in += i_increment;
  691.                 }
  692.             }
  693.             break;
  695.         default:
  696.             break;
  697.         }
  698.     }
  699. }
  701. /*****************************************************************************
  702.  * RenderBob: renders a BOB picture - simple copy
  703.  *****************************************************************************/
  704. static void RenderBob( vout_thread_t *p_vout,
  705.                        picture_t *p_outpic, picture_t *p_pic, int i_field )
  706. {
  707.     int i_plane;
  709.     /* Copy image and skip lines */
  710.     for( i_plane = 0 ; i_plane < p_pic->i_planes ; i_plane++ )
  711.     {
  712.         uint8_t *p_in, *p_out_end, *p_out;
  714.         p_in = p_pic->p[i_plane].p_pixels;
  715.         p_out = p_outpic->p[i_plane].p_pixels;
  716.         p_out_end = p_out + p_outpic->p[i_plane].i_pitch
  717.                              * p_outpic->p[i_plane].i_visible_lines;
  719.         switch( p_vout->render.i_chroma )
  720.         {
  721.             case VLC_FOURCC('I','4','2','0'):
  722.             case VLC_FOURCC('I','Y','U','V'):
  723.             case VLC_FOURCC('Y','V','1','2'):
  724.                 /* For BOTTOM field we need to add the first line */
  725.                 if( i_field == 1 )
  726.                 {
  727.                     vlc_memcpy( p_out, p_in, p_pic->p[i_plane].i_pitch );
  728.                     p_in += p_pic->p[i_plane].i_pitch;
  729.                     p_out += p_outpic->p[i_plane].i_pitch;
  730.                 }
  732.                 p_out_end -= 2 * p_outpic->p[i_plane].i_pitch;
  734.                 for( ; p_out < p_out_end ; )
  735.                 {
  736.                     vlc_memcpy( p_out, p_in, p_pic->p[i_plane].i_pitch );
  738.                     p_out += p_outpic->p[i_plane].i_pitch;
  740.                     vlc_memcpy( p_out, p_in, p_pic->p[i_plane].i_pitch );
  742.                     p_in += 2 * p_pic->p[i_plane].i_pitch;
  743.                     p_out += p_outpic->p[i_plane].i_pitch;
  744.                 }
  746.                 vlc_memcpy( p_out, p_in, p_pic->p[i_plane].i_pitch );
  748.                 /* For TOP field we need to add the last line */
  749.                 if( i_field == 0 )
  750.                 {
  751.                     p_in += p_pic->p[i_plane].i_pitch;
  752.                     p_out += p_outpic->p[i_plane].i_pitch;
  753.                     vlc_memcpy( p_out, p_in, p_pic->p[i_plane].i_pitch );
  754.                 }
  755.                 break;
  757.             case VLC_FOURCC('I','4','2','2'):
  758.                 /* For BOTTOM field we need to add the first line */
  759.                 if( i_field == 1 )
  760.                 {
  761.                     vlc_memcpy( p_out, p_in, p_pic->p[i_plane].i_pitch );
  762.                     p_in += p_pic->p[i_plane].i_pitch;
  763.                     p_out += p_outpic->p[i_plane].i_pitch;
  764.                 }
  766.                 p_out_end -= 2 * p_outpic->p[i_plane].i_pitch;
  768.                 if( i_plane == Y_PLANE )
  769.                 {
  770.                     for( ; p_out < p_out_end ; )
  771.                     {
  772.                         vlc_memcpy( p_out, p_in, p_pic->p[i_plane].i_pitch );
  774.                         p_out += p_outpic->p[i_plane].i_pitch;
  776.                         vlc_memcpy( p_out, p_in, p_pic->p[i_plane].i_pitch );
  778.                         p_in += 2 * p_pic->p[i_plane].i_pitch;
  779.                         p_out += p_outpic->p[i_plane].i_pitch;
  780.                     }
  781.                 }
  782.                 else
  783.                 {
  784.                     for( ; p_out < p_out_end ; )
  785.                     {
  786.                         vlc_memcpy( p_out, p_in, p_pic->p[i_plane].i_pitch );
  788.                         p_out += p_outpic->p[i_plane].i_pitch;
  789.                         p_in += 2 * p_pic->p[i_plane].i_pitch;
  790.                     }
  791.                 }
  793.                 vlc_memcpy( p_out, p_in, p_pic->p[i_plane].i_pitch );
  795.                 /* For TOP field we need to add the last line */
  796.                 if( i_field == 0 )
  797.                 {
  798.                     p_in += p_pic->p[i_plane].i_pitch;
  799.                     p_out += p_outpic->p[i_plane].i_pitch;
  800.                     vlc_memcpy( p_out, p_in, p_pic->p[i_plane].i_pitch );
  801.                 }
  802.                 break;
  803.         }
  804.     }
  805. }
  807. #define Merge p_vout->p_sys->pf_merge
  808. #define EndMerge if(p_vout->p_sys->pf_end_merge) p_vout->p_sys->pf_end_merge
  810. /*****************************************************************************
  811.  * RenderLinear: BOB with linear interpolation
  812.  *****************************************************************************/
  813. static void RenderLinear( vout_thread_t *p_vout,
  814.                           picture_t *p_outpic, picture_t *p_pic, int i_field )
  815. {
  816.     int i_plane;
  818.     /* Copy image and skip lines */
  819.     for( i_plane = 0 ; i_plane < p_pic->i_planes ; i_plane++ )
  820.     {
  821.         uint8_t *p_in, *p_out_end, *p_out;
  823.         p_in = p_pic->p[i_plane].p_pixels;
  824.         p_out = p_outpic->p[i_plane].p_pixels;
  825.         p_out_end = p_out + p_outpic->p[i_plane].i_pitch
  826.                              * p_outpic->p[i_plane].i_visible_lines;
  828.         /* For BOTTOM field we need to add the first line */
  829.         if( i_field == 1 )
  830.         {
  831.             vlc_memcpy( p_out, p_in, p_pic->p[i_plane].i_pitch );
  832.             p_in += p_pic->p[i_plane].i_pitch;
  833.             p_out += p_outpic->p[i_plane].i_pitch;
  834.         }
  836.         p_out_end -= 2 * p_outpic->p[i_plane].i_pitch;
  838.         for( ; p_out < p_out_end ; )
  839.         {
  840.             vlc_memcpy( p_out, p_in, p_pic->p[i_plane].i_pitch );
  842.             p_out += p_outpic->p[i_plane].i_pitch;
  844.             Merge( p_out, p_in, p_in + 2 * p_pic->p[i_plane].i_pitch,
  845.                    p_pic->p[i_plane].i_pitch );
  847.             p_in += 2 * p_pic->p[i_plane].i_pitch;
  848.             p_out += p_outpic->p[i_plane].i_pitch;
  849.         }
  851.         vlc_memcpy( p_out, p_in, p_pic->p[i_plane].i_pitch );
  853.         /* For TOP field we need to add the last line */
  854.         if( i_field == 0 )
  855.         {
  856.             p_in += p_pic->p[i_plane].i_pitch;
  857.             p_out += p_outpic->p[i_plane].i_pitch;
  858.             vlc_memcpy( p_out, p_in, p_pic->p[i_plane].i_pitch );
  859.         }
  860.     }
  861.     EndMerge();
  862. }
  864. static void RenderMean( vout_thread_t *p_vout,
  865.                         picture_t *p_outpic, picture_t *p_pic )
  866. {
  867.     int i_plane;
  869.     /* Copy image and skip lines */
  870.     for( i_plane = 0 ; i_plane < p_pic->i_planes ; i_plane++ )
  871.     {
  872.         uint8_t *p_in, *p_out_end, *p_out;
  874.         p_in = p_pic->p[i_plane].p_pixels;
  876.         p_out = p_outpic->p[i_plane].p_pixels;
  877.         p_out_end = p_out + p_outpic->p[i_plane].i_pitch
  878.                              * p_outpic->p[i_plane].i_visible_lines;
  880.         /* All lines: mean value */
  881.         for( ; p_out < p_out_end ; )
  882.         {
  883.             Merge( p_out, p_in, p_in + p_pic->p[i_plane].i_pitch,
  884.                    p_pic->p[i_plane].i_pitch );
  886.             p_out += p_outpic->p[i_plane].i_pitch;
  887.             p_in += 2 * p_pic->p[i_plane].i_pitch;
  888.         }
  889.     }
  890.     EndMerge();
  891. }
  893. static void RenderBlend( vout_thread_t *p_vout,
  894.                          picture_t *p_outpic, picture_t *p_pic )
  895. {
  896.     int i_plane;
  898.     /* Copy image and skip lines */
  899.     for( i_plane = 0 ; i_plane < p_pic->i_planes ; i_plane++ )
  900.     {
  901.         uint8_t *p_in, *p_out_end, *p_out;
  903.         p_in = p_pic->p[i_plane].p_pixels;
  905.         p_out = p_outpic->p[i_plane].p_pixels;
  906.         p_out_end = p_out + p_outpic->p[i_plane].i_pitch
  907.                              * p_outpic->p[i_plane].i_visible_lines;
  909.         switch( p_vout->render.i_chroma )
  910.         {
  911.             case VLC_FOURCC('I','4','2','0'):
  912.             case VLC_FOURCC('I','Y','U','V'):
  913.             case VLC_FOURCC('Y','V','1','2'):
  914.                 /* First line: simple copy */
  915.                 vlc_memcpy( p_out, p_in, p_pic->p[i_plane].i_pitch );
  916.                 p_out += p_outpic->p[i_plane].i_pitch;
  918.                 /* Remaining lines: mean value */
  919.                 for( ; p_out < p_out_end ; )
  920.                 {
  921.                     Merge( p_out, p_in, p_in + p_pic->p[i_plane].i_pitch,
  922.                            p_pic->p[i_plane].i_pitch );
  924.                     p_out += p_outpic->p[i_plane].i_pitch;
  925.                     p_in += p_pic->p[i_plane].i_pitch;
  926.                 }
  927.                 break;
  929.             case VLC_FOURCC('I','4','2','2'):
  930.                 /* First line: simple copy */
  931.                 vlc_memcpy( p_out, p_in, p_pic->p[i_plane].i_pitch );
  932.                 p_out += p_outpic->p[i_plane].i_pitch;
  934.                 /* Remaining lines: mean value */
  935.                 if( i_plane == Y_PLANE )
  936.                 {
  937.                     for( ; p_out < p_out_end ; )
  938.                     {
  939.                         Merge( p_out, p_in, p_in + p_pic->p[i_plane].i_pitch,
  940.                                p_pic->p[i_plane].i_pitch );
  942.                         p_out += p_outpic->p[i_plane].i_pitch;
  943.                         p_in += p_pic->p[i_plane].i_pitch;
  944.                     }
  945.                 }
  947.                 else
  948.                 {
  949.                     for( ; p_out < p_out_end ; )
  950.                     {
  951.                         Merge( p_out, p_in, p_in + p_pic->p[i_plane].i_pitch,
  952.                                p_pic->p[i_plane].i_pitch );
  954.                         p_out += p_outpic->p[i_plane].i_pitch;
  955.                         p_in += 2*p_pic->p[i_plane].i_pitch;
  956.                     }
  957.                 }
  958.                 break;
  959.         }
  960.     }
  961.     EndMerge();
  962. }
  964. #undef Merge
  966. static void MergeGeneric( void *_p_dest, const void *_p_s1,
  967.                           const void *_p_s2, size_t i_bytes )
  968. {
  969.     uint8_t* p_dest = (uint8_t*)_p_dest;
  970.     const uint8_t *p_s1 = (const uint8_t *)_p_s1;
  971.     const uint8_t *p_s2 = (const uint8_t *)_p_s2;
  972.     uint8_t* p_end = p_dest + i_bytes - 8;
  974.     while( p_dest < p_end )
  975.     {
  976.         *p_dest++ = ( (uint16_t)(*p_s1++) + (uint16_t)(*p_s2++) ) >> 1;
  977.         *p_dest++ = ( (uint16_t)(*p_s1++) + (uint16_t)(*p_s2++) ) >> 1;
  978.         *p_dest++ = ( (uint16_t)(*p_s1++) + (uint16_t)(*p_s2++) ) >> 1;
  979.         *p_dest++ = ( (uint16_t)(*p_s1++) + (uint16_t)(*p_s2++) ) >> 1;
  980.         *p_dest++ = ( (uint16_t)(*p_s1++) + (uint16_t)(*p_s2++) ) >> 1;
  981.         *p_dest++ = ( (uint16_t)(*p_s1++) + (uint16_t)(*p_s2++) ) >> 1;
  982.         *p_dest++ = ( (uint16_t)(*p_s1++) + (uint16_t)(*p_s2++) ) >> 1;
  983.         *p_dest++ = ( (uint16_t)(*p_s1++) + (uint16_t)(*p_s2++) ) >> 1;
  984.     }
  986.     p_end += 8;
  988.     while( p_dest < p_end )
  989.     {
  990.         *p_dest++ = ( (uint16_t)(*p_s1++) + (uint16_t)(*p_s2++) ) >> 1;
  991.     }
  992. }
  994. #if defined(CAN_COMPILE_MMXEXT)
  995. static void MergeMMXEXT( void *_p_dest, const void *_p_s1, const void *_p_s2,
  996.                          size_t i_bytes )
  997. {
  998.     uint8_t* p_dest = (uint8_t*)_p_dest;
  999.     const uint8_t *p_s1 = (const uint8_t *)_p_s1;
  1000.     const uint8_t *p_s2 = (const uint8_t *)_p_s2;
  1001.     uint8_t* p_end = p_dest + i_bytes - 8;
  1002.     while( p_dest < p_end )
  1003.     {
  1004.         __asm__  __volatile__( "movq %2,%%mm1;"
  1005.                                "pavgb %1, %%mm1;"
  1006.                                "movq %%mm1, %0" :"=m" (*p_dest):
  1007.                                                  "m" (*p_s1),
  1008.                                                  "m" (*p_s2) );
  1009.         p_dest += 8;
  1010.         p_s1 += 8;
  1011.         p_s2 += 8;
  1012.     }
  1014.     p_end += 8;
  1016.     while( p_dest < p_end )
  1017.     {
  1018.         *p_dest++ = ( (uint16_t)(*p_s1++) + (uint16_t)(*p_s2++) ) >> 1;
  1019.     }
  1020. }
  1021. #endif
  1023. #if defined(CAN_COMPILE_3DNOW)
  1024. static void Merge3DNow( void *_p_dest, const void *_p_s1, const void *_p_s2,
  1025.                         size_t i_bytes )
  1026. {
  1027.     uint8_t* p_dest = (uint8_t*)_p_dest;
  1028.     const uint8_t *p_s1 = (const uint8_t *)_p_s1;
  1029.     const uint8_t *p_s2 = (const uint8_t *)_p_s2;
  1030.     uint8_t* p_end = p_dest + i_bytes - 8;
  1031.     while( p_dest < p_end )
  1032.     {
  1033.         __asm__  __volatile__( "movq %2,%%mm1;"
  1034.                                "pavgusb %1, %%mm1;"
  1035.                                "movq %%mm1, %0" :"=m" (*p_dest):
  1036.                                                  "m" (*p_s1),
  1037.                                                  "m" (*p_s2) );
  1038.         p_dest += 8;
  1039.         p_s1 += 8;
  1040.         p_s2 += 8;
  1041.     }
  1043.     p_end += 8;
  1045.     while( p_dest < p_end )
  1046.     {
  1047.         *p_dest++ = ( (uint16_t)(*p_s1++) + (uint16_t)(*p_s2++) ) >> 1;
  1048.     }
  1049. }
  1050. #endif
  1052. #if defined(CAN_COMPILE_SSE)
  1053. static void MergeSSE2( void *_p_dest, const void *_p_s1, const void *_p_s2,
  1054.                        size_t i_bytes )
  1055. {
  1056.     uint8_t* p_dest = (uint8_t*)_p_dest;
  1057.     const uint8_t *p_s1 = (const uint8_t *)_p_s1;
  1058.     const uint8_t *p_s2 = (const uint8_t *)_p_s2;
  1059.     uint8_t* p_end;
  1060.     while( (uintptr_t)p_s1 % 16 )
  1061.     {
  1062.         *p_dest++ = ( (uint16_t)(*p_s1++) + (uint16_t)(*p_s2++) ) >> 1;
  1063.     }
  1064.     p_end = p_dest + i_bytes - 16;
  1065.     while( p_dest < p_end )
  1066.     {
  1067.         __asm__  __volatile__( "movdqu %2,%%xmm1;"
  1068.                                "pavgb %1, %%xmm1;"
  1069.                                "movdqu %%xmm1, %0" :"=m" (*p_dest):
  1070.                                                  "m" (*p_s1),
  1071.                                                  "m" (*p_s2) );
  1072.         p_dest += 16;
  1073.         p_s1 += 16;
  1074.         p_s2 += 16;
  1075.     }
  1077.     p_end += 16;
  1079.     while( p_dest < p_end )
  1080.     {
  1081.         *p_dest++ = ( (uint16_t)(*p_s1++) + (uint16_t)(*p_s2++) ) >> 1;
  1082.     }
  1083. }
  1084. #endif
  1086. #if defined(CAN_COMPILE_MMXEXT) || defined(CAN_COMPILE_SSE)
  1087. static void EndMMX( void )
  1088. {
  1089.     __asm__ __volatile__( "emms" :: );
  1090. }
  1091. #endif
  1093. #if defined(CAN_COMPILE_3DNOW)
  1094. static void End3DNow( void )
  1095. {
  1096.     __asm__ __volatile__( "femms" :: );
  1097. }
  1098. #endif
  1100. #ifdef CAN_COMPILE_C_ALTIVEC
  1101. static void MergeAltivec( void *_p_dest, const void *_p_s1,
  1102.                           const void *_p_s2, size_t i_bytes )
  1103. {
  1104.     uint8_t *p_dest = (uint8_t *)_p_dest;
  1105.     uint8_t *p_s1   = (uint8_t *)_p_s1;
  1106.     uint8_t *p_s2   = (uint8_t *)_p_s2;
  1107.     uint8_t *p_end  = p_dest + i_bytes - 15;
  1109.     /* Use C until the first 16-bytes aligned destination pixel */
  1110.     while( (int)p_dest & 0xF )
  1111.     {
  1112.         *p_dest++ = ( (uint16_t)(*p_s1++) + (uint16_t)(*p_s2++) ) >> 1;
  1113.     }
  1115.     if( ( (int)p_s1 & 0xF ) | ( (int)p_s2 & 0xF ) )
  1116.     {
  1117.         /* Unaligned source */
  1118.         vector unsigned char s1v, s2v, destv;
  1119.         vector unsigned char s1oldv, s2oldv, s1newv, s2newv;
  1120.         vector unsigned char perm1v, perm2v;
  1122.         perm1v = vec_lvsl( 0, p_s1 );
  1123.         perm2v = vec_lvsl( 0, p_s2 );
  1124.         s1oldv = vec_ld( 0, p_s1 );
  1125.         s2oldv = vec_ld( 0, p_s2 );
  1127.         while( p_dest < p_end )
  1128.         {
  1129.             s1newv = vec_ld( 16, p_s1 );
  1130.             s2newv = vec_ld( 16, p_s2 );
  1131.             s1v    = vec_perm( s1oldv, s1newv, perm1v );
  1132.             s2v    = vec_perm( s2oldv, s2newv, perm2v );
  1133.             s1oldv = s1newv;
  1134.             s2oldv = s2newv;
  1135.             destv  = vec_avg( s1v, s2v );
  1136.             vec_st( destv, 0, p_dest );
  1138.             p_s1   += 16;
  1139.             p_s2   += 16;
  1140.             p_dest += 16;
  1141.         }
  1142.     }
  1143.     else
  1144.     {
  1145.         /* Aligned source */
  1146.         vector unsigned char s1v, s2v, destv;
  1148.         while( p_dest < p_end )
  1149.         {
  1150.             s1v   = vec_ld( 0, p_s1 );
  1151.             s2v   = vec_ld( 0, p_s2 );
  1152.             destv = vec_avg( s1v, s2v );
  1153.             vec_st( destv, 0, p_dest );
  1155.             p_s1   += 16;
  1156.             p_s2   += 16;
  1157.             p_dest += 16;
  1158.         }
  1159.     }
  1161.     p_end += 15;
  1163.     while( p_dest < p_end )
  1164.     {
  1165.         *p_dest++ = ( (uint16_t)(*p_s1++) + (uint16_t)(*p_s2++) ) >> 1;
  1166.     }
  1167. }
  1168. #endif
  1170. /*****************************************************************************
  1171.  * RenderX: This algo works on a 8x8 block basic, it copies the top field
  1172.  * and apply a process to recreate the bottom field :
  1173.  *  If a 8x8 block is classified as :
  1174.  *   - progressive: it applies a small blend (1,6,1)
  1175.  *   - interlaced:
  1176.  *    * in the MMX version: we do a ME between the 2 fields, if there is a
  1177.  *    good match we use MC to recreate the bottom field (with a small
  1178.  *    blend (1,6,1) )
  1179.  *    * otherwise: it recreates the bottom field by an edge oriented
  1180.  *    interpolation.
  1181.   *****************************************************************************/
  1183. /* XDeint8x8Detect: detect if a 8x8 block is interlaced.
  1184.  * XXX: It need to access to 8x10
  1185.  * We use more than 8 lines to help with scrolling (text)
  1186.  * (and because XDeint8x8Frame use line 9)
  1187.  * XXX: smooth/uniform area with noise detection doesn't works well
  1188.  * but it's not really a problem because they don't have much details anyway
  1189.  */
  1190. static inline int ssd( int a ) { return a*a; }
  1191. static inline int XDeint8x8DetectC( uint8_t *src, int i_src )
  1192. {
  1193.     int y, x;
  1194.     int ff, fr;
  1195.     int fc;
  1197.     /* Detect interlacing */
  1198.     fc = 0;
  1199.     for( y = 0; y < 7; y += 2 )
  1200.     {
  1201.         ff = fr = 0;
  1202.         for( x = 0; x < 8; x++ )
  1203.         {
  1204.             fr += ssd(src[      x] - src[1*i_src+x]) +
  1205.                   ssd(src[i_src+x] - src[2*i_src+x]);
  1206.             ff += ssd(src[      x] - src[2*i_src+x]) +
  1207.                   ssd(src[i_src+x] - src[3*i_src+x]);
  1208.         }
  1209.         if( ff < 6*fr/8 && fr > 32 )
  1210.             fc++;
  1212.         src += 2*i_src;
  1213.     }
  1215.     return fc < 1 ? false : true;
  1216. }
  1217. #ifdef CAN_COMPILE_MMXEXT
  1218. static inline int XDeint8x8DetectMMXEXT( uint8_t *src, int i_src )
  1219. {
  1221.     int y, x;
  1222.     int32_t ff, fr;
  1223.     int fc;
  1225.     /* Detect interlacing */
  1226.     fc = 0;
  1227.     pxor_r2r( mm7, mm7 );
  1228.     for( y = 0; y < 9; y += 2 )
  1229.     {
  1230.         ff = fr = 0;
  1231.         pxor_r2r( mm5, mm5 );
  1232.         pxor_r2r( mm6, mm6 );
  1233.         for( x = 0; x < 8; x+=4 )
  1234.         {
  1235.             movd_m2r( src[        x], mm0 );
  1236.             movd_m2r( src[1*i_src+x], mm1 );
  1237.             movd_m2r( src[2*i_src+x], mm2 );
  1238.             movd_m2r( src[3*i_src+x], mm3 );
  1240.             punpcklbw_r2r( mm7, mm0 );
  1241.             punpcklbw_r2r( mm7, mm1 );
  1242.             punpcklbw_r2r( mm7, mm2 );
  1243.             punpcklbw_r2r( mm7, mm3 );
  1245.             movq_r2r( mm0, mm4 );
  1247.             psubw_r2r( mm1, mm0 );
  1248.             psubw_r2r( mm2, mm4 );
  1250.             psubw_r2r( mm1, mm2 );
  1251.             psubw_r2r( mm1, mm3 );
  1253.             pmaddwd_r2r( mm0, mm0 );
  1254.             pmaddwd_r2r( mm4, mm4 );
  1255.             pmaddwd_r2r( mm2, mm2 );
  1256.             pmaddwd_r2r( mm3, mm3 );
  1257.             paddd_r2r( mm0, mm2 );
  1258.             paddd_r2r( mm4, mm3 );
  1259.             paddd_r2r( mm2, mm5 );
  1260.             paddd_r2r( mm3, mm6 );
  1261.         }
  1263.         movq_r2r( mm5, mm0 );
  1264.         psrlq_i2r( 32, mm0 );
  1265.         paddd_r2r( mm0, mm5 );
  1266.         movd_r2m( mm5, fr );
  1268.         movq_r2r( mm6, mm0 );
  1269.         psrlq_i2r( 32, mm0 );
  1270.         paddd_r2r( mm0, mm6 );
  1271.         movd_r2m( mm6, ff );
  1273.         if( ff < 6*fr/8 && fr > 32 )
  1274.             fc++;
  1276.         src += 2*i_src;
  1277.     }
  1278.     return fc;
  1279. }
  1280. #endif
  1282. static inline void XDeint8x8MergeC( uint8_t *dst, int i_dst,
  1283.                                     uint8_t *src1, int i_src1,
  1284.                                     uint8_t *src2, int i_src2 )
  1285. {
  1286.     int y, x;
  1288.     /* Progressive */
  1289.     for( y = 0; y < 8; y += 2 )
  1290.     {
  1291.         memcpy( dst, src1, 8 );
  1292.         dst  += i_dst;
  1294.         for( x = 0; x < 8; x++ )
  1295.             dst[x] = (src1[x] + 6*src2[x] + src1[i_src1+x] + 4 ) >> 3;
  1296.         dst += i_dst;
  1298.         src1 += i_src1;
  1299.         src2 += i_src2;
  1300.     }
  1301. }
  1303. #ifdef CAN_COMPILE_MMXEXT
  1304. static inline void XDeint8x8MergeMMXEXT( uint8_t *dst, int i_dst,
  1305.                                          uint8_t *src1, int i_src1,
  1306.                                          uint8_t *src2, int i_src2 )
  1307. {
  1308.     static const uint64_t m_4 = INT64_C(0x0004000400040004);
  1309.     int y, x;
  1311.     /* Progressive */
  1312.     pxor_r2r( mm7, mm7 );
  1313.     for( y = 0; y < 8; y += 2 )
  1314.     {
  1315.         for( x = 0; x < 8; x +=4 )
  1316.         {
  1317.             movd_m2r( src1[x], mm0 );
  1318.             movd_r2m( mm0, dst[x] );
  1320.             movd_m2r( src2[x], mm1 );
  1321.             movd_m2r( src1[i_src1+x], mm2 );
  1323.             punpcklbw_r2r( mm7, mm0 );
  1324.             punpcklbw_r2r( mm7, mm1 );
  1325.             punpcklbw_r2r( mm7, mm2 );
  1326.             paddw_r2r( mm1, mm1 );
  1327.             movq_r2r( mm1, mm3 );
  1328.             paddw_r2r( mm3, mm3 );
  1329.             paddw_r2r( mm2, mm0 );
  1330.             paddw_r2r( mm3, mm1 );
  1331.             paddw_m2r( m_4, mm1 );
  1332.             paddw_r2r( mm1, mm0 );
  1333.             psraw_i2r( 3, mm0 );
  1334.             packuswb_r2r( mm7, mm0 );
  1335.             movd_r2m( mm0, dst[i_dst+x] );
  1336.         }
  1337.         dst += 2*i_dst;
  1338.         src1 += i_src1;
  1339.         src2 += i_src2;
  1340.     }
  1341. }
  1343. #endif
  1345. /* For debug */
  1346. static inline void XDeint8x8Set( uint8_t *dst, int i_dst, uint8_t v )
  1347. {
  1348.     int y;
  1349.     for( y = 0; y < 8; y++ )
  1350.         memset( &dst[y*i_dst], v, 8 );
  1351. }
  1353. /* XDeint8x8FieldE: Stupid deinterlacing (1,0,1) for block that miss a
  1354.  * neighbour
  1355.  * (Use 8x9 pixels)
  1356.  * TODO: a better one for the inner part.
  1357.  */
  1358. static inline void XDeint8x8FieldEC( uint8_t *dst, int i_dst,
  1359.                                      uint8_t *src, int i_src )
  1360. {
  1361.     int y, x;
  1363.     /* Interlaced */
  1364.     for( y = 0; y < 8; y += 2 )
  1365.     {
  1366.         memcpy( dst, src, 8 );
  1367.         dst += i_dst;
  1369.         for( x = 0; x < 8; x++ )
  1370.             dst[x] = (src[x] + src[2*i_src+x] ) >> 1;
  1371.         dst += 1*i_dst;
  1372.         src += 2*i_src;
  1373.     }
  1374. }
  1375. #ifdef CAN_COMPILE_MMXEXT
  1376. static inline void XDeint8x8FieldEMMXEXT( uint8_t *dst, int i_dst,
  1377.                                           uint8_t *src, int i_src )
  1378. {
  1379.     int y;
  1381.     /* Interlaced */
  1382.     for( y = 0; y < 8; y += 2 )
  1383.     {
  1384.         movq_m2r( src[0], mm0 );
  1385.         movq_r2m( mm0, dst[0] );
  1386.         dst += i_dst;
  1388.         movq_m2r( src[2*i_src], mm1 );
  1389.         pavgb_r2r( mm1, mm0 );
  1391.         movq_r2m( mm0, dst[0] );
  1393.         dst += 1*i_dst;
  1394.         src += 2*i_src;
  1395.     }
  1396. }
  1397. #endif
  1399. /* XDeint8x8Field: Edge oriented interpolation
  1400.  * (Need -4 and +5 pixels H, +1 line)
  1401.  */
  1402. static inline void XDeint8x8FieldC( uint8_t *dst, int i_dst,
  1403.                                     uint8_t *src, int i_src )
  1404. {
  1405.     int y, x;
  1407.     /* Interlaced */
  1408.     for( y = 0; y < 8; y += 2 )
  1409.     {
  1410.         memcpy( dst, src, 8 );
  1411.         dst += i_dst;
  1413.         for( x = 0; x < 8; x++ )
  1414.         {
  1415.             uint8_t *src2 = &src[2*i_src];
  1416.             /* I use 8 pixels just to match the MMX version, but it's overkill
  1417.              * 5 would be enough (less isn't good) */
  1418.             const int c0 = abs(src[x-4]-src2[x-2]) + abs(src[x-3]-src2[x-1]) +
  1419.                            abs(src[x-2]-src2[x+0]) + abs(src[x-1]-src2[x+1]) +
  1420.                            abs(src[x+0]-src2[x+2]) + abs(src[x+1]-src2[x+3]) +
  1421.                            abs(src[x+2]-src2[x+4]) + abs(src[x+3]-src2[x+5]);
  1423.             const int c1 = abs(src[x-3]-src2[x-3]) + abs(src[x-2]-src2[x-2]) +
  1424.                            abs(src[x-1]-src2[x-1]) + abs(src[x+0]-src2[x+0]) +
  1425.                            abs(src[x+1]-src2[x+1]) + abs(src[x+2]-src2[x+2]) +
  1426.                            abs(src[x+3]-src2[x+3]) + abs(src[x+4]-src2[x+4]);
  1428.             const int c2 = abs(src[x-2]-src2[x-4]) + abs(src[x-1]-src2[x-3]) +
  1429.                            abs(src[x+0]-src2[x-2]) + abs(src[x+1]-src2[x-1]) +
  1430.                            abs(src[x+2]-src2[x+0]) + abs(src[x+3]-src2[x+1]) +
  1431.                            abs(src[x+4]-src2[x+2]) + abs(src[x+5]-src2[x+3]);
  1433.             if( c0 < c1 && c1 <= c2 )
  1434.                 dst[x] = (src[x-1] + src2[x+1]) >> 1;
  1435.             else if( c2 < c1 && c1 <= c0 )
  1436.                 dst[x] = (src[x+1] + src2[x-1]) >> 1;
  1437.             else
  1438.                 dst[x] = (src[x+0] + src2[x+0]) >> 1;
  1439.         }
  1441.         dst += 1*i_dst;
  1442.         src += 2*i_src;
  1443.     }
  1444. }
  1445. #ifdef CAN_COMPILE_MMXEXT
  1446. static inline void XDeint8x8FieldMMXEXT( uint8_t *dst, int i_dst,
  1447.                                          uint8_t *src, int i_src )
  1448. {
  1449.     int y, x;
  1451.     /* Interlaced */
  1452.     for( y = 0; y < 8; y += 2 )
  1453.     {
  1454.         memcpy( dst, src, 8 );
  1455.         dst += i_dst;
  1457.         for( x = 0; x < 8; x++ )
  1458.         {
  1459.             uint8_t *src2 = &src[2*i_src];
  1460.             int32_t c0, c1, c2;
  1462.             movq_m2r( src[x-2], mm0 );
  1463.             movq_m2r( src[x-3], mm1 );
  1464.             movq_m2r( src[x-4], mm2 );
  1466.             psadbw_m2r( src2[x-4], mm0 );
  1467.             psadbw_m2r( src2[x-3], mm1 );
  1468.             psadbw_m2r( src2[x-2], mm2 );
  1470.             movd_r2m( mm0, c2 );
  1471.             movd_r2m( mm1, c1 );
  1472.             movd_r2m( mm2, c0 );
  1474.             if( c0 < c1 && c1 <= c2 )
  1475.                 dst[x] = (src[x-1] + src2[x+1]) >> 1;
  1476.             else if( c2 < c1 && c1 <= c0 )
  1477.                 dst[x] = (src[x+1] + src2[x-1]) >> 1;
  1478.             else
  1479.                 dst[x] = (src[x+0] + src2[x+0]) >> 1;
  1480.         }
  1482.         dst += 1*i_dst;
  1483.         src += 2*i_src;
  1484.     }
  1485. }
  1486. #endif
  1488. /* NxN arbitray size (and then only use pixel in the NxN block)
  1489.  */
  1490. static inline int XDeintNxNDetect( uint8_t *src, int i_src,
  1491.                                    int i_height, int i_width )
  1492. {
  1493.     int y, x;
  1494.     int ff, fr;
  1495.     int fc;
  1498.     /* Detect interlacing */
  1499.     /* FIXME way too simple, need to be more like XDeint8x8Detect */
  1500.     ff = fr = 0;
  1501.     fc = 0;
  1502.     for( y = 0; y < i_height - 2; y += 2 )
  1503.     {
  1504.         const uint8_t *s = &src[y*i_src];
  1505.         for( x = 0; x < i_width; x++ )
  1506.         {
  1507.             fr += ssd(s[      x] - s[1*i_src+x]);
  1508.             ff += ssd(s[      x] - s[2*i_src+x]);
  1509.         }
  1510.         if( ff < fr && fr > i_width / 2 )
  1511.             fc++;
  1512.     }
  1514.     return fc < 2 ? false : true;
  1515. }
  1517. static inline void XDeintNxNFrame( uint8_t *dst, int i_dst,
  1518.                                    uint8_t *src, int i_src,
  1519.                                    int i_width, int i_height )
  1520. {
  1521.     int y, x;
  1523.     /* Progressive */
  1524.     for( y = 0; y < i_height; y += 2 )
  1525.     {
  1526.         memcpy( dst, src, i_width );
  1527.         dst += i_dst;
  1529.         if( y < i_height - 2 )
  1530.         {
  1531.             for( x = 0; x < i_width; x++ )
  1532.                 dst[x] = (src[x] + 2*src[1*i_src+x] + src[2*i_src+x] + 2 ) >> 2;
  1533.         }
  1534.         else
  1535.         {
  1536.             /* Blend last line */
  1537.             for( x = 0; x < i_width; x++ )
  1538.                 dst[x] = (src[x] + src[1*i_src+x] ) >> 1;
  1539.         }
  1540.         dst += 1*i_dst;
  1541.         src += 2*i_src;
  1542.     }
  1543. }
  1545. static inline void XDeintNxNField( uint8_t *dst, int i_dst,
  1546.                                    uint8_t *src, int i_src,
  1547.                                    int i_width, int i_height )
  1548. {
  1549.     int y, x;
  1551.     /* Interlaced */
  1552.     for( y = 0; y < i_height; y += 2 )
  1553.     {
  1554.         memcpy( dst, src, i_width );
  1555.         dst += i_dst;
  1557.         if( y < i_height - 2 )
  1558.         {
  1559.             for( x = 0; x < i_width; x++ )
  1560.                 dst[x] = (src[x] + src[2*i_src+x] ) >> 1;
  1561.         }
  1562.         else
  1563.         {
  1564.             /* Blend last line */
  1565.             for( x = 0; x < i_width; x++ )
  1566.                 dst[x] = (src[x] + src[i_src+x]) >> 1;
  1567.         }
  1568.         dst += 1*i_dst;
  1569.         src += 2*i_src;
  1570.     }
  1571. }
  1573. static inline void XDeintNxN( uint8_t *dst, int i_dst, uint8_t *src, int i_src,
  1574.                               int i_width, int i_height )
  1575. {
  1576.     if( XDeintNxNDetect( src, i_src, i_width, i_height ) )
  1577.         XDeintNxNField( dst, i_dst, src, i_src, i_width, i_height );
  1578.     else
  1579.         XDeintNxNFrame( dst, i_dst, src, i_src, i_width, i_height );
  1580. }
  1583. static inline int median( int a, int b, int c )
  1584. {
  1585.     int min = a, max =a;
  1586.     if( b < min )
  1587.         min = b;
  1588.     else
  1589.         max = b;
  1591.     if( c < min )
  1592.         min = c;
  1593.     else if( c > max )
  1594.         max = c;
  1596.     return a + b + c - min - max;
  1597. }
  1600. /* XDeintBand8x8:
  1601.  */
  1602. static inline void XDeintBand8x8C( uint8_t *dst, int i_dst,
  1603.                                    uint8_t *src, int i_src,
  1604.                                    const int i_mbx, int i_modx )
  1605. {
  1606.     int x;
  1608.     for( x = 0; x < i_mbx; x++ )
  1609.     {
  1610.         int s;
  1611.         if( ( s = XDeint8x8DetectC( src, i_src ) ) )
  1612.         {
  1613.             if( x == 0 || x == i_mbx - 1 )
  1614.                 XDeint8x8FieldEC( dst, i_dst, src, i_src );
  1615.             else
  1616.                 XDeint8x8FieldC( dst, i_dst, src, i_src );
  1617.         }
  1618.         else
  1619.         {
  1620.             XDeint8x8MergeC( dst, i_dst,
  1621.                              &src[0*i_src], 2*i_src,
  1622.                              &src[1*i_src], 2*i_src );
  1623.         }
  1625.         dst += 8;
  1626.         src += 8;
  1627.     }
  1629.     if( i_modx )
  1630.         XDeintNxN( dst, i_dst, src, i_src, i_modx, 8 );
  1631. }
  1632. #ifdef CAN_COMPILE_MMXEXT
  1633. static inline void XDeintBand8x8MMXEXT( uint8_t *dst, int i_dst,
  1634.                                         uint8_t *src, int i_src,
  1635.                                         const int i_mbx, int i_modx )
  1636. {
  1637.     int x;
  1639.     /* Reset current line */
  1640.     for( x = 0; x < i_mbx; x++ )
  1641.     {
  1642.         int s;
  1643.         if( ( s = XDeint8x8DetectMMXEXT( src, i_src ) ) )
  1644.         {
  1645.             if( x == 0 || x == i_mbx - 1 )
  1646.                 XDeint8x8FieldEMMXEXT( dst, i_dst, src, i_src );
  1647.             else
  1648.                 XDeint8x8FieldMMXEXT( dst, i_dst, src, i_src );
  1649.         }
  1650.         else
  1651.         {
  1652.             XDeint8x8MergeMMXEXT( dst, i_dst,
  1653.                                   &src[0*i_src], 2*i_src,
  1654.                                   &src[1*i_src], 2*i_src );
  1655.         }
  1657.         dst += 8;
  1658.         src += 8;
  1659.     }
  1661.     if( i_modx )
  1662.         XDeintNxN( dst, i_dst, src, i_src, i_modx, 8 );
  1663. }
  1664. #endif
  1666. static void RenderX( picture_t *p_outpic, picture_t *p_pic )
  1667. {
  1668.     int i_plane;
  1670.     /* Copy image and skip lines */
  1671.     for( i_plane = 0 ; i_plane < p_pic->i_planes ; i_plane++ )
  1672.     {
  1673.         const int i_mby = ( p_outpic->p[i_plane].i_visible_lines + 7 )/8 - 1;
  1674.         const int i_mbx = p_outpic->p[i_plane].i_visible_pitch/8;
  1676.         const int i_mody = p_outpic->p[i_plane].i_visible_lines - 8*i_mby;
  1677.         const int i_modx = p_outpic->p[i_plane].i_visible_pitch - 8*i_mbx;
  1679.         const int i_dst = p_outpic->p[i_plane].i_pitch;
  1680.         const int i_src = p_pic->p[i_plane].i_pitch;
  1682.         int y, x;
  1684.         for( y = 0; y < i_mby; y++ )
  1685.         {
  1686.             uint8_t *dst = &p_outpic->p[i_plane].p_pixels[8*y*i_dst];
  1687.             uint8_t *src = &p_pic->p[i_plane].p_pixels[8*y*i_src];
  1689. #ifdef CAN_COMPILE_MMXEXT
  1690.             if( vlc_CPU() & CPU_CAPABILITY_MMXEXT )
  1691.                 XDeintBand8x8MMXEXT( dst, i_dst, src, i_src, i_mbx, i_modx );
  1692.             else
  1693. #endif
  1694.                 XDeintBand8x8C( dst, i_dst, src, i_src, i_mbx, i_modx );
  1695.         }
  1697.         /* Last line (C only)*/
  1698.         if( i_mody )
  1699.         {
  1700.             uint8_t *dst = &p_outpic->p[i_plane].p_pixels[8*y*i_dst];
  1701.             uint8_t *src = &p_pic->p[i_plane].p_pixels[8*y*i_src];
  1703.             for( x = 0; x < i_mbx; x++ )
  1704.             {
  1705.                 XDeintNxN( dst, i_dst, src, i_src, 8, i_mody );
  1707.                 dst += 8;
  1708.                 src += 8;
  1709.             }
  1711.             if( i_modx )
  1712.                 XDeintNxN( dst, i_dst, src, i_src, i_modx, i_mody );
  1713.         }
  1714.     }
  1716. #ifdef CAN_COMPILE_MMXEXT
  1717.     if( vlc_CPU() & CPU_CAPABILITY_MMXEXT )
  1718.         emms();
  1719. #endif
  1720. }
  1722. /*****************************************************************************
  1723.  * Yadif (Yet Another DeInterlacing Filter).
  1724.  *****************************************************************************/
  1725. /* */
  1726. struct vf_priv_s {
  1727.     /*
  1728.      * 0: Output 1 frame for each frame.
  1729.      * 1: Output 1 frame for each field.
  1730.      * 2: Like 0 but skips spatial interlacing check.
  1731.      * 3: Like 1 but skips spatial interlacing check.
  1732.      *
  1733.      * In vlc, only & 0x02 has meaning, as we do the & 0x01 ourself.
  1734.      */
  1735.     int mode;
  1736. };
  1738. /* I am unsure it is the right one */
  1739. typedef intptr_t x86_reg;
  1741. #define FFABS(a) ((a) >= 0 ? (a) : (-(a)))
  1742. #define FFMAX(a,b)      __MAX(a,b)
  1743. #define FFMAX3(a,b,c)   FFMAX(FFMAX(a,b),c)
  1744. #define FFMIN(a,b)      __MIN(a,b)
  1745. #define FFMIN3(a,b,c)   FFMIN(FFMIN(a,b),c)
  1747. /* yadif.h comes from vf_yadif.c of mplayer project */
  1748. #include "yadif.h"
  1750. static void RenderYadif( vout_thread_t *p_vout, picture_t *p_dst, picture_t *p_src, int i_order, int i_field )
  1751. {
  1752.     vout_sys_t *p_sys = p_vout->p_sys;
  1754.     /* */
  1755.     assert( i_order == 0 || i_order == 1 );
  1756.     assert( i_field == 0 || i_field == 1 );
  1758.     if( i_order == 0 )
  1759.     {
  1760.         /* Duplicate the picture
  1761.          * TODO when the vout rework is finished, picture_Hold() might be enough
  1762.          * but becarefull, the pitches must match */
  1763.         picture_t *p_dup = picture_New( p_src->format.i_chroma,
  1764.                                         p_src->format.i_width,
  1765.                                         p_src->format.i_height,
  1766.                                         p_src->format.i_aspect );
  1767.         if( p_dup )
  1768.             picture_Copy( p_dup, p_src );
  1770.         /* Slide the history */
  1771.         if( p_sys->pp_history[0] )
  1772.             picture_Release( p_sys->pp_history[0]  );
  1773.         for( int i = 1; i < HISTORY_SIZE; i++ )
  1774.             p_sys->pp_history[i-1] = p_sys->pp_history[i];
  1775.         p_sys->pp_history[HISTORY_SIZE-1] = p_dup;
  1776.     }
  1778.     /* As the pitches must match, use ONLY pictures coming from picture_New()! */
  1779.     picture_t *p_prev = p_sys->pp_history[0];
  1780.     picture_t *p_cur  = p_sys->pp_history[1];
  1781.     picture_t *p_next = p_sys->pp_history[2];
  1783.     /* Filter if we have all the pictures we need */
  1784.     if( p_prev && p_cur && p_next )
  1785.     {
  1786.         /* */
  1787.         void (*filter)(struct vf_priv_s *p, uint8_t *dst, uint8_t *prev, uint8_t *cur, uint8_t *next, int w, int refs, int parity);
  1788. #if defined(HAVE_YADIF_SSE2)
  1789.         if( vlc_CPU() & CPU_CAPABILITY_SSE2 )
  1790.             filter = yadif_filter_line_mmx2;
  1791.         else
  1792. #endif
  1793.             filter = yadif_filter_line_c;
  1795.         for( int n = 0; n < p_dst->i_planes; n++ )
  1796.         {
  1797.             const plane_t *prevp = &p_prev->p[n];
  1798.             const plane_t *curp  = &p_cur->p[n];
  1799.             const plane_t *nextp = &p_next->p[n];
  1800.             plane_t *dstp        = &p_dst->p[n];
  1802.             for( int y = 1; y < dstp->i_visible_lines - 1; y++ )
  1803.             {
  1804.                 if( (y % 2) == i_field )
  1805.                 {
  1806.                     vlc_memcpy( &dstp->p_pixels[y * dstp->i_pitch],
  1807.                                 &curp->p_pixels[y * curp->i_pitch], dstp->i_visible_pitch );
  1808.                 }
  1809.                 else
  1810.                 {
  1811.                     struct vf_priv_s cfg;
  1812.                     /* Spatial checks only when enough data */
  1813.                     cfg.mode = (y >= 2 && y < dstp->i_visible_lines - 2) ? 0 : 2;
  1815.                     assert( prevp->i_pitch == curp->i_pitch && curp->i_pitch == nextp->i_pitch );
  1816.                     filter( &cfg,
  1817.                             &dstp->p_pixels[y * dstp->i_pitch],
  1818.                             &prevp->p_pixels[y * prevp->i_pitch],
  1819.                             &curp->p_pixels[y * curp->i_pitch],
  1820.                             &nextp->p_pixels[y * nextp->i_pitch],
  1821.                             dstp->i_visible_pitch,
  1822.                             curp->i_pitch,
  1823.                             (i_field ^ (i_order == i_field)) & 1 );
  1824.                 }
  1826.                 /* We duplicate the first and last lines */
  1827.                 if( y == 1 )
  1828.                     vlc_memcpy(&dstp->p_pixels[(y-1) * dstp->i_pitch], &dstp->p_pixels[y * dstp->i_pitch], dstp->i_pitch);
  1829.                 else if( y == dstp->i_visible_lines - 2 )
  1830.                     vlc_memcpy(&dstp->p_pixels[(y+1) * dstp->i_pitch], &dstp->p_pixels[y * dstp->i_pitch], dstp->i_pitch);
  1831.             }
  1832.         }
  1834.         /* */
  1835.         p_dst->date = (p_next->date - p_cur->date) * i_order / 2 + p_cur->date;
  1836.     }
  1837.     else
  1838.     {
  1839.         /* Fallback to something simple
  1840.          * XXX it is wrong when we have 2 pictures, we should not output a picture */
  1841.         RenderX( p_dst, p_src );
  1842.     }
  1843. }
  1845. /*****************************************************************************
  1846.  * FilterCallback: called when changing the deinterlace method on the fly.
  1847.  *****************************************************************************/
  1848. static int FilterCallback( vlc_object_t *p_this, char const *psz_cmd,
  1849.                            vlc_value_t oldval, vlc_value_t newval,
  1850.                            void *p_data )
  1851. {
  1852.     VLC_UNUSED(psz_cmd); VLC_UNUSED(p_data); VLC_UNUSED(oldval);
  1853.     vout_thread_t * p_vout = (vout_thread_t *)p_this;
  1855.     msg_Dbg( p_vout, "using %s deinterlace mode", newval.psz_string );
  1857.     vlc_mutex_lock( &p_vout->p_sys->filter_lock );
  1858.     const bool b_old_half_height = p_vout->p_sys->b_half_height;
  1860.     SetFilterMethod( p_vout, newval.psz_string );
  1862.     if( !b_old_half_height == !p_vout->p_sys->b_half_height )
  1863.     {
  1864.         vlc_mutex_unlock( &p_vout->p_sys->filter_lock );
  1865.         return VLC_SUCCESS;
  1866.     }
  1868.     /* We need to kill the old vout */
  1869.     if( p_vout->p_sys->p_vout )
  1870.     {
  1871.         vout_filter_DelChild( p_vout, p_vout->p_sys->p_vout, MouseEvent );
  1872.         vout_CloseAndRelease( p_vout->p_sys->p_vout );
  1873.     }
  1875.     /* Try to open a new video output */
  1876.     p_vout->p_sys->p_vout = SpawnRealVout( p_vout );
  1878.     if( p_vout->p_sys->p_vout == NULL )
  1879.     {
  1880.         /* Everything failed */
  1881.         msg_Err( p_vout, "cannot open vout, aborting" );
  1883.         vlc_mutex_unlock( &p_vout->p_sys->filter_lock );
  1884.         return VLC_EGENERIC;
  1885.     }
  1887.     vout_filter_AddChild( p_vout, p_vout->p_sys->p_vout, MouseEvent );
  1889.     vlc_mutex_unlock( &p_vout->p_sys->filter_lock );
  1890.     return VLC_SUCCESS;
  1891. }
  1893. /*****************************************************************************
  1894.  * video filter2 functions
  1895.  *****************************************************************************/
  1896. static picture_t *Deinterlace( filter_t *p_filter, picture_t *p_pic )
  1897. {
  1898.     vout_thread_t *p_vout = (vout_thread_t *)p_filter->p_sys;
  1899.     picture_t *p_pic_dst;
  1901.     /* Request output picture */
  1902.     p_pic_dst = filter_NewPicture( p_filter );
  1903.     if( p_pic_dst == NULL )
  1904.     {
  1905.         picture_Release( p_pic );
  1906.         return NULL;
  1907.     }
  1909.     switch( p_vout->p_sys->i_mode )
  1910.     {
  1911.         case DEINTERLACE_DISCARD:
  1912.             RenderDiscard( p_vout, p_pic_dst, p_pic, 0 );
  1913.             break;
  1915.         case DEINTERLACE_BOB:
  1916. #if 0
  1917.             RenderBob( p_vout, pp_outpic[0], p_pic, 0 );
  1918.             RenderBob( p_vout, pp_outpic[1], p_pic, 1 );
  1919.             break;
  1920. #endif
  1922.         case DEINTERLACE_LINEAR:
  1923. #if 0
  1924.             RenderLinear( p_vout, pp_outpic[0], p_pic, 0 );
  1925.             RenderLinear( p_vout, pp_outpic[1], p_pic, 1 );
  1926. #endif
  1927.             msg_Err( p_vout, "doubling the frame rate is not supported yet" );
  1928.             picture_Release( p_pic_dst );
  1929.             picture_Release( p_pic );
  1930.             return NULL;
  1932.         case DEINTERLACE_MEAN:
  1933.             RenderMean( p_vout, p_pic_dst, p_pic );
  1934.             break;
  1936.         case DEINTERLACE_BLEND:
  1937.             RenderBlend( p_vout, p_pic_dst, p_pic );
  1938.             break;
  1940.         case DEINTERLACE_X:
  1941.             RenderX( p_pic_dst, p_pic );
  1942.             break;
  1944.         case DEINTERLACE_YADIF:
  1945.             msg_Err( p_vout, "delaying frames is not supported yet" );
  1946.             picture_Release( p_pic_dst );
  1947.             picture_Release( p_pic );
  1948.             return NULL;
  1950.         case DEINTERLACE_YADIF2X:
  1951.             msg_Err( p_vout, "doubling the frame rate is not supported yet" );
  1952.             picture_Release( p_pic_dst );
  1953.             picture_Release( p_pic );
  1954.             return NULL;
  1955.     }
  1957.     picture_CopyProperties( p_pic_dst, p_pic );
  1958.     p_pic_dst->b_progressive = true;
  1960.     picture_Release( p_pic );
  1961.     return p_pic_dst;
  1962. }
  1964. /*****************************************************************************
  1965.  * OpenFilter:
  1966.  *****************************************************************************/
  1967. static int OpenFilter( vlc_object_t *p_this )
  1968. {
  1969.     filter_t *p_filter = (filter_t*)p_this;
  1970.     vout_thread_t *p_vout;
  1971.     vlc_value_t val;
  1973.     if( !IsChromaSupported( p_filter->fmt_in.video.i_chroma ) )
  1974.         return VLC_EGENERIC;
  1976.     /* Impossible to use VLC_OBJECT_VOUT here because it would be used
  1977.      * by spu filters */
  1978.     p_vout = vlc_object_create( p_filter, sizeof(vout_thread_t) );
  1979.     vlc_object_attach( p_vout, p_filter );
  1980.     p_filter->p_sys = (filter_sys_t *)p_vout;
  1981.     p_vout->render.i_chroma = p_filter->fmt_in.video.i_chroma;
  1983.     config_ChainParse( p_filter, FILTER_CFG_PREFIX, ppsz_filter_options,
  1984.                    p_filter->p_cfg );
  1985.     var_Get( p_filter, FILTER_CFG_PREFIX "mode", &val );
  1987.     var_Create( p_filter, "deinterlace-mode", VLC_VAR_STRING );
  1988.     var_Set( p_filter, "deinterlace-mode", val );
  1989.     free( val.psz_string );
  1991.     if( Create( VLC_OBJECT(p_vout) ) != VLC_SUCCESS )
  1992.     {
  1993.         vlc_object_detach( p_vout );
  1994.         vlc_object_release( p_vout );
  1995.         return VLC_EGENERIC;
  1996.     }
  1998.     video_format_t fmt;
  1999.     GetOutputFormat( p_vout, &fmt, &p_filter->fmt_in.video );
  2000.     if( !p_filter->b_allow_fmt_out_change &&
  2001.         ( fmt.i_chroma != p_filter->fmt_in.video.i_chroma ||
  2002.           fmt.i_height != p_filter->fmt_in.video.i_height ) )
  2003.     {
  2004.         CloseFilter( VLC_OBJECT(p_filter) );
  2005.         return VLC_EGENERIC;
  2006.     }
  2007.     p_filter->fmt_out.video = fmt;
  2008.     p_filter->fmt_out.i_codec = fmt.i_chroma;
  2009.     p_filter->pf_video_filter = Deinterlace;
  2011.     msg_Dbg( p_filter, "deinterlacing" );
  2013.     return VLC_SUCCESS;
  2014. }
  2016. /*****************************************************************************
  2017.  * CloseFilter: clean up the filter
  2018.  *****************************************************************************/
  2019. static void CloseFilter( vlc_object_t *p_this )
  2020. {
  2021.     filter_t *p_filter = (filter_t*)p_this;
  2022.     vout_thread_t *p_vout = (vout_thread_t *)p_filter->p_sys;
  2024.     Destroy( VLC_OBJECT(p_vout) );
  2025.     vlc_object_detach( p_vout );
  2026.     vlc_object_release( p_vout );
  2027. }