X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=modules%2Fvideo_filter%2Fadjust.c;h=35f7e1d824df73a3ab0a7a8f7c6014633df899c2;hb=22fdf98f4ce8ea6d3a48da5daa0b3c9fe41e13fe;hp=56d9c47a1bbb19c2bac6140ed4e9c744b8c7111a;hpb=707ee8ea31dd8f0c92ad4e9fdec955ee6205f2df;p=vlc diff --git a/modules/video_filter/adjust.c b/modules/video_filter/adjust.c index 56d9c47a1b..35f7e1d824 100644 --- a/modules/video_filter/adjust.c +++ b/modules/video_filter/adjust.c @@ -1,10 +1,11 @@ /***************************************************************************** * adjust.c : Contrast/Hue/Saturation/Brightness video plugin for vlc ***************************************************************************** - * Copyright (C) 2000, 2001, 2002, 2003 VideoLAN + * Copyright (C) 2000-2006 the VideoLAN team * $Id$ * * Authors: Simon Latapie + * Antoine Cellerier * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by @@ -18,21 +19,25 @@ * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111, USA. + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA. *****************************************************************************/ /***************************************************************************** * Preamble *****************************************************************************/ -#include -#include /* malloc(), free() */ -#include + +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif + #include -#include -#include +#include +#include +#include -#include "filter_common.h" +#include +#include "filter_picture.h" #ifndef M_PI # define M_PI 3.14159265358979323846 @@ -46,184 +51,162 @@ static int Create ( vlc_object_t * ); static void Destroy ( vlc_object_t * ); -static int Init ( vout_thread_t * ); -static void End ( vout_thread_t * ); -static void Render ( vout_thread_t *, picture_t * ); - -static int SendEvents( vlc_object_t *, char const *, - vlc_value_t, vlc_value_t, void * ); +static picture_t *FilterPlanar( filter_t *, picture_t * ); +static picture_t *FilterPacked( filter_t *, picture_t * ); +static int AdjustCallback( vlc_object_t *p_this, char const *psz_var, + vlc_value_t oldval, vlc_value_t newval, + void *p_data ); /***************************************************************************** * Module descriptor *****************************************************************************/ +#define THRES_TEXT N_("Brightness threshold") +#define THRES_LONGTEXT N_("When this mode is enabled, pixels will be " \ + "shown as black or white. The threshold value will be the brighness " \ + "defined below." ) #define CONT_TEXT N_("Image contrast (0-2)") -#define CONT_LONGTEXT N_("Set the image contrast, between 0 and 2. Defaults to 1") +#define CONT_LONGTEXT N_("Set the image contrast, between 0 and 2. Defaults to 1.") #define HUE_TEXT N_("Image hue (0-360)") -#define HUE_LONGTEXT N_("Set the image hue, between 0 and 360. Defaults to 0") +#define HUE_LONGTEXT N_("Set the image hue, between 0 and 360. Defaults to 0.") #define SAT_TEXT N_("Image saturation (0-3)") -#define SAT_LONGTEXT N_("Set the image saturation, between 0 and 3. Defaults to 1") +#define SAT_LONGTEXT N_("Set the image saturation, between 0 and 3. Defaults to 1.") #define LUM_TEXT N_("Image brightness (0-2)") -#define LUM_LONGTEXT N_("Set the image brightness, between 0 and 2. Defaults to 1") +#define LUM_LONGTEXT N_("Set the image brightness, between 0 and 2. Defaults to 1.") #define GAMMA_TEXT N_("Image gamma (0-10)") -#define GAMMA_LONGTEXT N_("Set the image gamma, between 0.01 and 10. Defaults to 1") - - -vlc_module_begin(); - set_description( _("Image properties filter") ); - set_capability( "video filter", 0 ); - - add_float_with_range( "contrast", 1.0, 0.0, 2.0, NULL, CONT_TEXT, CONT_LONGTEXT, VLC_FALSE ); - add_float_with_range( "brightness", 1.0, 0.0, 2.0, NULL, LUM_TEXT, LUM_LONGTEXT, VLC_FALSE ); - add_integer_with_range( "hue", 0, 0, 360, NULL, HUE_TEXT, HUE_LONGTEXT, VLC_FALSE ); - add_float_with_range( "saturation", 1.0, 0.0, 3.0, NULL, SAT_TEXT, SAT_LONGTEXT, VLC_FALSE ); - add_float_with_range( "gamma", 1.0, 0.01, 10.0, NULL, GAMMA_TEXT, GAMMA_LONGTEXT, VLC_FALSE ); - - add_shortcut( "adjust" ); - set_callbacks( Create, Destroy ); -vlc_module_end(); - -/***************************************************************************** - * vout_sys_t: adjust video output method descriptor - ***************************************************************************** - * This structure is part of the video output thread descriptor. - * It describes the adjust specific properties of an output thread. - *****************************************************************************/ -struct vout_sys_t -{ - vout_thread_t *p_vout; +#define GAMMA_LONGTEXT N_("Set the image gamma, between 0.01 and 10. Defaults to 1.") + +vlc_module_begin () + set_description( N_("Image properties filter") ) + set_shortname( N_("Image adjust" )) + set_category( CAT_VIDEO ) + set_subcategory( SUBCAT_VIDEO_VFILTER ) + set_capability( "video filter2", 0 ) + + add_float_with_range( "contrast", 1.0, 0.0, 2.0, NULL, + CONT_TEXT, CONT_LONGTEXT, false ) + add_float_with_range( "brightness", 1.0, 0.0, 2.0, NULL, + LUM_TEXT, LUM_LONGTEXT, false ) + add_integer_with_range( "hue", 0, 0, 360, NULL, + HUE_TEXT, HUE_LONGTEXT, false ) + add_float_with_range( "saturation", 1.0, 0.0, 3.0, NULL, + SAT_TEXT, SAT_LONGTEXT, false ) + add_float_with_range( "gamma", 1.0, 0.01, 10.0, NULL, + GAMMA_TEXT, GAMMA_LONGTEXT, false ) + + add_bool( "brightness-threshold", false, NULL, + THRES_TEXT, THRES_LONGTEXT, false ) + + add_shortcut( "adjust" ) + set_callbacks( Create, Destroy ) +vlc_module_end () + +static const char *const ppsz_filter_options[] = { + "contrast", "brightness", "hue", "saturation", "gamma", + "brightness-threshold", NULL }; -inline static int32_t clip( int32_t a ) -{ - return (a > 255) ? 255 : (a < 0) ? 0 : a; -} - /***************************************************************************** - * Control: control facility for the vout (forwards to child vout) + * filter_sys_t: adjust filter method descriptor *****************************************************************************/ -static int Control( vout_thread_t *p_vout, int i_query, va_list args ) +struct filter_sys_t { - return vout_vaControl( p_vout->p_sys->p_vout, i_query, args ); -} + vlc_mutex_t lock; + double f_contrast; + double f_brightness; + int i_hue; + double f_saturation; + double f_gamma; + bool b_brightness_threshold; +}; /***************************************************************************** - * Create: allocates adjust video thread output method - ***************************************************************************** - * This function allocates and initializes a adjust vout method. + * Create: allocates adjust video filter *****************************************************************************/ static int Create( vlc_object_t *p_this ) { - vout_thread_t *p_vout = (vout_thread_t *)p_this; + filter_t *p_filter = (filter_t *)p_this; + filter_sys_t *p_sys; - /* Allocate structure */ - p_vout->p_sys = malloc( sizeof( vout_sys_t ) ); - if( p_vout->p_sys == NULL ) + switch( p_filter->fmt_in.video.i_chroma ) { - msg_Err( p_vout, "out of memory" ); - return VLC_ENOMEM; + CASE_PLANAR_YUV + /* Planar YUV */ + p_filter->pf_video_filter = FilterPlanar; + break; + + CASE_PACKED_YUV_422 + /* Packed YUV 4:2:2 */ + p_filter->pf_video_filter = FilterPacked; + break; + + default: + msg_Err( p_filter, "Unsupported input chroma (%4.4s)", + (char*)&(p_filter->fmt_in.video.i_chroma) ); + return VLC_EGENERIC; } - p_vout->pf_init = Init; - p_vout->pf_end = End; - p_vout->pf_manage = NULL; - p_vout->pf_render = Render; - p_vout->pf_display = NULL; - p_vout->pf_control = Control; - - var_Create( p_vout, "contrast", VLC_VAR_FLOAT | VLC_VAR_DOINHERIT ); - var_Create( p_vout, "brightness", VLC_VAR_FLOAT | VLC_VAR_DOINHERIT ); - var_Create( p_vout, "hue", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT ); - var_Create( p_vout, "saturation", VLC_VAR_FLOAT | VLC_VAR_DOINHERIT ); - var_Create( p_vout, "gamma", VLC_VAR_FLOAT | VLC_VAR_DOINHERIT ); - - return VLC_SUCCESS; -} - -/***************************************************************************** - * Init: initialize adjust video thread output method - *****************************************************************************/ -static int Init( vout_thread_t *p_vout ) -{ - int i_index; - picture_t *p_pic; - - I_OUTPUTPICTURES = 0; - - /* Initialize the output structure */ - p_vout->output.i_chroma = p_vout->render.i_chroma; - p_vout->output.i_width = p_vout->render.i_width; - p_vout->output.i_height = p_vout->render.i_height; - p_vout->output.i_aspect = p_vout->render.i_aspect; - - /* Try to open the real video output */ - msg_Dbg( p_vout, "spawning the real video output" ); - - p_vout->p_sys->p_vout = vout_Create( p_vout, - p_vout->render.i_width, p_vout->render.i_height, - p_vout->render.i_chroma, p_vout->render.i_aspect ); - - /* Everything failed */ - if( p_vout->p_sys->p_vout == NULL ) + if( p_filter->fmt_in.video.i_chroma != p_filter->fmt_out.video.i_chroma ) { - msg_Err( p_vout, "can't open vout, aborting" ); - + msg_Err( p_filter, "Input and output chromas don't match" ); return VLC_EGENERIC; } - ALLOCATE_DIRECTBUFFERS( VOUT_MAX_PICTURES ); - - ADD_CALLBACKS( p_vout->p_sys->p_vout, SendEvents ); - - ADD_PARENT_CALLBACKS( SendEventsToChild ); + /* Allocate structure */ + p_filter->p_sys = malloc( sizeof( filter_sys_t ) ); + if( p_filter->p_sys == NULL ) + return VLC_ENOMEM; + p_sys = p_filter->p_sys; + + /* needed to get options passed in transcode using the + * adjust{name=value} syntax */ + config_ChainParse( p_filter, "", ppsz_filter_options, + p_filter->p_cfg ); + + p_sys->f_contrast = var_CreateGetFloatCommand( p_filter, "contrast" ); + p_sys->f_brightness = var_CreateGetFloatCommand( p_filter, "brightness" ); + p_sys->i_hue = var_CreateGetIntegerCommand( p_filter, "hue" ); + p_sys->f_saturation = var_CreateGetFloatCommand( p_filter, "saturation" ); + p_sys->f_gamma = var_CreateGetFloatCommand( p_filter, "gamma" ); + p_sys->b_brightness_threshold = + var_CreateGetBoolCommand( p_filter, "brightness-threshold" ); + + vlc_mutex_init( &p_sys->lock ); + var_AddCallback( p_filter, "contrast", AdjustCallback, p_sys ); + var_AddCallback( p_filter, "brightness", AdjustCallback, p_sys ); + var_AddCallback( p_filter, "hue", AdjustCallback, p_sys ); + var_AddCallback( p_filter, "saturation", AdjustCallback, p_sys ); + var_AddCallback( p_filter, "gamma", AdjustCallback, p_sys ); + var_AddCallback( p_filter, "brightness-threshold", + AdjustCallback, p_sys ); return VLC_SUCCESS; } /***************************************************************************** - * End: terminate adjust video thread output method - *****************************************************************************/ -static void End( vout_thread_t *p_vout ) -{ - int i_index; - - /* Free the fake output buffers we allocated */ - for( i_index = I_OUTPUTPICTURES ; i_index ; ) - { - i_index--; - free( PP_OUTPUTPICTURE[ i_index ]->p_data_orig ); - } -} - -/***************************************************************************** - * Destroy: destroy adjust video thread output method - ***************************************************************************** - * Terminate an output method created by adjustCreateOutputMethod + * Destroy: destroy adjust video filter *****************************************************************************/ static void Destroy( vlc_object_t *p_this ) { - vout_thread_t *p_vout = (vout_thread_t *)p_this; - - if( p_vout->p_sys->p_vout ) - { - DEL_CALLBACKS( p_vout->p_sys->p_vout, SendEvents ); - vlc_object_detach( p_vout->p_sys->p_vout ); - vout_Destroy( p_vout->p_sys->p_vout ); - } - - DEL_PARENT_CALLBACKS( SendEventsToChild ); - - free( p_vout->p_sys ); + filter_t *p_filter = (filter_t *)p_this; + filter_sys_t *p_sys = p_filter->p_sys; + + var_DelCallback( p_filter, "contrast", AdjustCallback, p_sys ); + var_DelCallback( p_filter, "brightness", AdjustCallback, p_sys ); + var_DelCallback( p_filter, "hue", AdjustCallback, p_sys ); + var_DelCallback( p_filter, "saturation", AdjustCallback, p_sys ); + var_DelCallback( p_filter, "gamma", AdjustCallback, p_sys ); + var_DelCallback( p_filter, "brightness-threshold", + AdjustCallback, p_sys ); + + vlc_mutex_destroy( &p_sys->lock ); + free( p_sys ); } /***************************************************************************** - * Render: displays previously rendered output - ***************************************************************************** - * This function send the currently rendered image to adjust modified image, - * waits until it is displayed and switch the two rendering buffers, preparing - * next frame. + * Run the filter on a Planar YUV picture *****************************************************************************/ -static void Render( vout_thread_t *p_vout, picture_t *p_pic ) +static picture_t *FilterPlanar( filter_t *p_filter, picture_t *p_pic ) { int pi_luma[256]; int pi_gamma[256]; @@ -232,67 +215,86 @@ static void Render( vout_thread_t *p_vout, picture_t *p_pic ) uint8_t *p_in, *p_in_v, *p_in_end, *p_line_end; uint8_t *p_out, *p_out_v; + bool b_thres; double f_hue; double f_gamma; int32_t i_cont, i_lum; int i_sat, i_sin, i_cos, i_x, i_y; int i; - vlc_value_t val; - /* This is a new frame. Get a structure from the video_output. */ - while( ( p_outpic = vout_CreatePicture( p_vout->p_sys->p_vout, 0, 0, 0 ) ) - == NULL ) + filter_sys_t *p_sys = p_filter->p_sys; + + if( !p_pic ) return NULL; + + p_outpic = filter_NewPicture( p_filter ); + if( !p_outpic ) { - if( p_vout->b_die || p_vout->b_error ) - { - return; - } - msleep( VOUT_OUTMEM_SLEEP ); + picture_Release( p_pic ); + return NULL; } - vout_DatePicture( p_vout->p_sys->p_vout, p_outpic, p_pic->date ); - vout_LinkPicture( p_vout->p_sys->p_vout, p_outpic ); - - /* Getvariables */ - var_Get( p_vout, "contrast", &val ); - i_cont = (int) ( val.f_float * 255 ); - var_Get( p_vout, "brightness", &val ); - i_lum = (int) (( val.f_float - 1.0 ) * 255 ); - var_Get( p_vout, "hue", &val ); - f_hue = (float) ( val.i_int * M_PI / 180 ); - var_Get( p_vout, "saturation", &val ); - i_sat = (int) (val.f_float * 256 ); - var_Get( p_vout, "gamma", &val ); - f_gamma = 1.0 / val.f_float; - - /* Contrast is a fast but kludged function, so I put this gap to be - * cleaner :) */ - i_lum += 128 - i_cont / 2; - - /* Fill the gamma lookup table */ - for( i = 0 ; i < 256 ; i++ ) + /* Get variables */ + vlc_mutex_lock( &p_sys->lock ); + i_cont = (int)( p_sys->f_contrast * 255 ); + i_lum = (int)( (p_sys->f_brightness - 1.0)*255 ); + f_hue = (float)( p_sys->i_hue * M_PI / 180 ); + i_sat = (int)( p_sys->f_saturation * 256 ); + f_gamma = 1.0 / p_sys->f_gamma; + b_thres = p_sys->b_brightness_threshold; + vlc_mutex_unlock( &p_sys->lock ); + + /* + * Threshold mode drops out everything about luma, contrast and gamma. + */ + if( b_thres != true ) { - pi_gamma[ i ] = clip( pow(i / 255.0, f_gamma) * 255.0); - } - /* Fill the luma lookup table */ - for( i = 0 ; i < 256 ; i++ ) + /* Contrast is a fast but kludged function, so I put this gap to be + * cleaner :) */ + i_lum += 128 - i_cont / 2; + + /* Fill the gamma lookup table */ + for( i = 0 ; i < 256 ; i++ ) + { + pi_gamma[ i ] = clip_uint8_vlc( pow(i / 255.0, f_gamma) * 255.0); + } + + /* Fill the luma lookup table */ + for( i = 0 ; i < 256 ; i++ ) + { + pi_luma[ i ] = pi_gamma[clip_uint8_vlc( i_lum + i_cont * i / 256)]; + } + } + else { - pi_luma[ i ] = pi_gamma[clip( i_lum + i_cont * i / 256)]; + /* + * We get luma as threshold value: the higher it is, the darker is + * the image. Should I reverse this? + */ + for( i = 0 ; i < 256 ; i++ ) + { + pi_luma[ i ] = (i < i_lum) ? 0 : 255; + } + + /* + * Desaturates image to avoid that strange yellow halo... + */ + i_sat = 0; } /* * Do the Y plane */ - p_in = p_pic->p[0].p_pixels; - p_in_end = p_in + p_pic->p[0].i_lines * p_pic->p[0].i_pitch - 8; + p_in = p_pic->p[Y_PLANE].p_pixels; + p_in_end = p_in + p_pic->p[Y_PLANE].i_visible_lines + * p_pic->p[Y_PLANE].i_pitch - 8; - p_out = p_outpic->p[0].p_pixels; + p_out = p_outpic->p[Y_PLANE].p_pixels; for( ; p_in < p_in_end ; ) { - p_line_end = p_in + p_pic->p[0].i_visible_pitch - 8; + p_line_end = p_in + p_pic->p[Y_PLANE].i_visible_pitch - 8; for( ; p_in < p_line_end ; ) { @@ -310,20 +312,23 @@ static void Render( vout_thread_t *p_vout, picture_t *p_pic ) *p_out++ = pi_luma[ *p_in++ ]; } - p_in += p_pic->p[0].i_pitch - p_pic->p[0].i_visible_pitch; - p_out += p_outpic->p[0].i_pitch - p_outpic->p[0].i_visible_pitch; + p_in += p_pic->p[Y_PLANE].i_pitch + - p_pic->p[Y_PLANE].i_visible_pitch; + p_out += p_outpic->p[Y_PLANE].i_pitch + - p_outpic->p[Y_PLANE].i_visible_pitch; } /* * Do the U and V planes */ - p_in = p_pic->p[1].p_pixels; - p_in_v = p_pic->p[2].p_pixels; - p_in_end = p_in + p_pic->p[1].i_lines * p_pic->p[1].i_pitch - 8; + p_in = p_pic->p[U_PLANE].p_pixels; + p_in_v = p_pic->p[V_PLANE].p_pixels; + p_in_end = p_in + p_pic->p[U_PLANE].i_visible_lines + * p_pic->p[U_PLANE].i_pitch - 8; - p_out = p_outpic->p[1].p_pixels; - p_out_v = p_outpic->p[2].p_pixels; + p_out = p_outpic->p[U_PLANE].p_pixels; + p_out_v = p_outpic->p[V_PLANE].p_pixels; i_sin = sin(f_hue) * 256; i_cos = cos(f_hue) * 256; @@ -335,16 +340,16 @@ static void Render( vout_thread_t *p_vout, picture_t *p_pic ) { #define WRITE_UV_CLIP() \ i_u = *p_in++ ; i_v = *p_in_v++ ; \ - *p_out++ = clip( (( ((i_u * i_cos + i_v * i_sin - i_x) >> 8) \ + *p_out++ = clip_uint8_vlc( (( ((i_u * i_cos + i_v * i_sin - i_x) >> 8) \ * i_sat) >> 8) + 128); \ - *p_out_v++ = clip( (( ((i_v * i_cos - i_u * i_sin - i_y) >> 8) \ + *p_out_v++ = clip_uint8_vlc( (( ((i_v * i_cos - i_u * i_sin - i_y) >> 8) \ * i_sat) >> 8) + 128) uint8_t i_u, i_v; for( ; p_in < p_in_end ; ) { - p_line_end = p_in + p_pic->p[1].i_visible_pitch - 8; + p_line_end = p_in + p_pic->p[U_PLANE].i_visible_pitch - 8; for( ; p_in < p_line_end ; ) { @@ -362,11 +367,16 @@ static void Render( vout_thread_t *p_vout, picture_t *p_pic ) WRITE_UV_CLIP(); } - p_in += p_pic->p[1].i_pitch - p_pic->p[1].i_visible_pitch; - p_in_v += p_pic->p[2].i_pitch - p_pic->p[2].i_visible_pitch; - p_out += p_outpic->p[1].i_pitch - p_outpic->p[1].i_visible_pitch; - p_out_v += p_outpic->p[2].i_pitch - p_outpic->p[2].i_visible_pitch; + p_in += p_pic->p[U_PLANE].i_pitch + - p_pic->p[U_PLANE].i_visible_pitch; + p_in_v += p_pic->p[V_PLANE].i_pitch + - p_pic->p[V_PLANE].i_visible_pitch; + p_out += p_outpic->p[U_PLANE].i_pitch + - p_outpic->p[U_PLANE].i_visible_pitch; + p_out_v += p_outpic->p[V_PLANE].i_pitch + - p_outpic->p[V_PLANE].i_visible_pitch; } +#undef WRITE_UV_CLIP } else { @@ -381,7 +391,7 @@ static void Render( vout_thread_t *p_vout, picture_t *p_pic ) for( ; p_in < p_in_end ; ) { - p_line_end = p_in + p_pic->p[1].i_visible_pitch - 8; + p_line_end = p_in + p_pic->p[U_PLANE].i_visible_pitch - 8; for( ; p_in < p_line_end ; ) { @@ -397,36 +407,277 @@ static void Render( vout_thread_t *p_vout, picture_t *p_pic ) WRITE_UV(); } - p_in += p_pic->p[1].i_pitch - p_pic->p[1].i_visible_pitch; - p_in_v += p_pic->p[2].i_pitch - p_pic->p[2].i_visible_pitch; - p_out += p_outpic->p[1].i_pitch - p_outpic->p[1].i_visible_pitch; - p_out_v += p_outpic->p[2].i_pitch - p_outpic->p[2].i_visible_pitch; + p_in += p_pic->p[U_PLANE].i_pitch + - p_pic->p[U_PLANE].i_visible_pitch; + p_in_v += p_pic->p[V_PLANE].i_pitch + - p_pic->p[V_PLANE].i_visible_pitch; + p_out += p_outpic->p[U_PLANE].i_pitch + - p_outpic->p[U_PLANE].i_visible_pitch; + p_out_v += p_outpic->p[V_PLANE].i_pitch + - p_outpic->p[V_PLANE].i_visible_pitch; } +#undef WRITE_UV } - vout_UnlinkPicture( p_vout->p_sys->p_vout, p_outpic ); - - vout_DisplayPicture( p_vout->p_sys->p_vout, p_outpic ); + return CopyInfoAndRelease( p_outpic, p_pic ); } /***************************************************************************** - * SendEvents: forward mouse and keyboard events to the parent p_vout + * Run the filter on a Packed YUV picture *****************************************************************************/ -static int SendEvents( vlc_object_t *p_this, char const *psz_var, - vlc_value_t oldval, vlc_value_t newval, void *p_data ) +static picture_t *FilterPacked( filter_t *p_filter, picture_t *p_pic ) { - var_Set( (vlc_object_t *)p_data, psz_var, newval ); + int pi_luma[256]; + int pi_gamma[256]; - return VLC_SUCCESS; + picture_t *p_outpic; + uint8_t *p_in, *p_in_v, *p_in_end, *p_line_end; + uint8_t *p_out, *p_out_v; + int i_y_offset, i_u_offset, i_v_offset; + + int i_lines, i_visible_lines, i_pitch, i_visible_pitch; + + bool b_thres; + double f_hue; + double f_gamma; + int32_t i_cont, i_lum; + int i_sat, i_sin, i_cos, i_x, i_y; + int i; + + filter_sys_t *p_sys = p_filter->p_sys; + + if( !p_pic ) return NULL; + + i_lines = p_pic->p->i_lines; + i_visible_lines = p_pic->p->i_visible_lines; + i_pitch = p_pic->p->i_pitch; + i_visible_pitch = p_pic->p->i_visible_pitch; + + if( GetPackedYuvOffsets( p_pic->format.i_chroma, &i_y_offset, + &i_u_offset, &i_v_offset ) != VLC_SUCCESS ) + { + msg_Warn( p_filter, "Unsupported input chroma (%4.4s)", + (char*)&(p_pic->format.i_chroma) ); + + picture_Release( p_pic ); + return NULL; + } + + p_outpic = filter_NewPicture( p_filter ); + if( !p_outpic ) + { + msg_Warn( p_filter, "can't get output picture" ); + + picture_Release( p_pic ); + return NULL; + } + + /* Get variables */ + vlc_mutex_lock( &p_sys->lock ); + i_cont = (int)( p_sys->f_contrast * 255 ); + i_lum = (int)( (p_sys->f_brightness - 1.0)*255 ); + f_hue = (float)( p_sys->i_hue * M_PI / 180 ); + i_sat = (int)( p_sys->f_saturation * 256 ); + f_gamma = 1.0 / p_sys->f_gamma; + b_thres = p_sys->b_brightness_threshold; + vlc_mutex_unlock( &p_sys->lock ); + + /* + * Threshold mode drops out everything about luma, contrast and gamma. + */ + if( b_thres != true ) + { + + /* Contrast is a fast but kludged function, so I put this gap to be + * cleaner :) */ + i_lum += 128 - i_cont / 2; + + /* Fill the gamma lookup table */ + for( i = 0 ; i < 256 ; i++ ) + { + pi_gamma[ i ] = clip_uint8_vlc( pow(i / 255.0, f_gamma) * 255.0); + } + + /* Fill the luma lookup table */ + for( i = 0 ; i < 256 ; i++ ) + { + pi_luma[ i ] = pi_gamma[clip_uint8_vlc( i_lum + i_cont * i / 256)]; + } + } + else + { + /* + * We get luma as threshold value: the higher it is, the darker is + * the image. Should I reverse this? + */ + for( i = 0 ; i < 256 ; i++ ) + { + pi_luma[ i ] = (i < i_lum) ? 0 : 255; + } + + /* + * Desaturates image to avoid that strange yellow halo... + */ + i_sat = 0; + } + + /* + * Do the Y plane + */ + + p_in = p_pic->p->p_pixels + i_y_offset; + p_in_end = p_in + p_pic->p->i_visible_lines * p_pic->p->i_pitch - 8 * 4; + + p_out = p_outpic->p->p_pixels + i_y_offset; + + for( ; p_in < p_in_end ; ) + { + p_line_end = p_in + i_visible_pitch - 8 * 4; + + for( ; p_in < p_line_end ; ) + { + /* Do 8 pixels at a time */ + *p_out = pi_luma[ *p_in ]; p_in += 2; p_out += 2; + *p_out = pi_luma[ *p_in ]; p_in += 2; p_out += 2; + *p_out = pi_luma[ *p_in ]; p_in += 2; p_out += 2; + *p_out = pi_luma[ *p_in ]; p_in += 2; p_out += 2; + *p_out = pi_luma[ *p_in ]; p_in += 2; p_out += 2; + *p_out = pi_luma[ *p_in ]; p_in += 2; p_out += 2; + *p_out = pi_luma[ *p_in ]; p_in += 2; p_out += 2; + *p_out = pi_luma[ *p_in ]; p_in += 2; p_out += 2; + } + + p_line_end += 8 * 4; + + for( ; p_in < p_line_end ; ) + { + *p_out = pi_luma[ *p_in ]; p_in += 2; p_out += 2; + } + + p_in += i_pitch - p_pic->p->i_visible_pitch; + p_out += i_pitch - p_outpic->p->i_visible_pitch; + } + + /* + * Do the U and V planes + */ + + p_in = p_pic->p->p_pixels + i_u_offset; + p_in_v = p_pic->p->p_pixels + i_v_offset; + p_in_end = p_in + i_visible_lines * i_pitch - 8 * 4; + + p_out = p_outpic->p->p_pixels + i_u_offset; + p_out_v = p_outpic->p->p_pixels + i_v_offset; + + i_sin = sin(f_hue) * 256; + i_cos = cos(f_hue) * 256; + + i_x = ( cos(f_hue) + sin(f_hue) ) * 32768; + i_y = ( cos(f_hue) - sin(f_hue) ) * 32768; + + if ( i_sat > 256 ) + { +#define WRITE_UV_CLIP() \ + i_u = *p_in; p_in += 4; i_v = *p_in_v; p_in_v += 4; \ + *p_out = clip_uint8_vlc( (( ((i_u * i_cos + i_v * i_sin - i_x) >> 8) \ + * i_sat) >> 8) + 128); \ + p_out += 4; \ + *p_out_v = clip_uint8_vlc( (( ((i_v * i_cos - i_u * i_sin - i_y) >> 8) \ + * i_sat) >> 8) + 128); \ + p_out_v += 4 + + uint8_t i_u, i_v; + + for( ; p_in < p_in_end ; ) + { + p_line_end = p_in + i_visible_pitch - 8 * 4; + + for( ; p_in < p_line_end ; ) + { + /* Do 8 pixels at a time */ + WRITE_UV_CLIP(); WRITE_UV_CLIP(); + WRITE_UV_CLIP(); WRITE_UV_CLIP(); + WRITE_UV_CLIP(); WRITE_UV_CLIP(); + WRITE_UV_CLIP(); WRITE_UV_CLIP(); + } + + p_line_end += 8 * 4; + + for( ; p_in < p_line_end ; ) + { + WRITE_UV_CLIP(); + } + + p_in += i_pitch - i_visible_pitch; + p_in_v += i_pitch - i_visible_pitch; + p_out += i_pitch - i_visible_pitch; + p_out_v += i_pitch - i_visible_pitch; + } +#undef WRITE_UV_CLIP + } + else + { +#define WRITE_UV() \ + i_u = *p_in; p_in += 4; i_v = *p_in_v; p_in_v += 4; \ + *p_out = (( ((i_u * i_cos + i_v * i_sin - i_x) >> 8) \ + * i_sat) >> 8) + 128; \ + p_out += 4; \ + *p_out_v = (( ((i_v * i_cos - i_u * i_sin - i_y) >> 8) \ + * i_sat) >> 8) + 128; \ + p_out_v += 4 + + uint8_t i_u, i_v; + + for( ; p_in < p_in_end ; ) + { + p_line_end = p_in + i_visible_pitch - 8 * 4; + + for( ; p_in < p_line_end ; ) + { + /* Do 8 pixels at a time */ + WRITE_UV(); WRITE_UV(); WRITE_UV(); WRITE_UV(); + WRITE_UV(); WRITE_UV(); WRITE_UV(); WRITE_UV(); + } + + p_line_end += 8 * 4; + + for( ; p_in < p_line_end ; ) + { + WRITE_UV(); + } + + p_in += i_pitch - i_visible_pitch; + p_in_v += i_pitch - i_visible_pitch; + p_out += i_pitch - i_visible_pitch; + p_out_v += i_pitch - i_visible_pitch; + } +#undef WRITE_UV + } + + return CopyInfoAndRelease( p_outpic, p_pic ); } -/***************************************************************************** - * SendEventsToChild: forward events to the child/children vout - *****************************************************************************/ -static int SendEventsToChild( vlc_object_t *p_this, char const *psz_var, - vlc_value_t oldval, vlc_value_t newval, void *p_data ) +static int AdjustCallback( vlc_object_t *p_this, char const *psz_var, + vlc_value_t oldval, vlc_value_t newval, + void *p_data ) { - vout_thread_t *p_vout = (vout_thread_t *)p_this; - var_Set( p_vout->p_sys->p_vout, psz_var, newval ); + VLC_UNUSED(p_this); VLC_UNUSED(oldval); + filter_sys_t *p_sys = (filter_sys_t *)p_data; + + vlc_mutex_lock( &p_sys->lock ); + if( !strcmp( psz_var, "contrast" ) ) + p_sys->f_contrast = newval.f_float; + else if( !strcmp( psz_var, "brightness" ) ) + p_sys->f_brightness = newval.f_float; + else if( !strcmp( psz_var, "hue" ) ) + p_sys->i_hue = newval.i_int; + else if( !strcmp( psz_var, "saturation" ) ) + p_sys->f_saturation = newval.f_float; + else if( !strcmp( psz_var, "gamma" ) ) + p_sys->f_gamma = newval.f_float; + else if( !strcmp( psz_var, "brightness-threshold" ) ) + p_sys->b_brightness_threshold = newval.b_bool; + vlc_mutex_unlock( &p_sys->lock ); + return VLC_SUCCESS; }