54b15df6d10b44c0c7b328461ae3b2479cc0ec30
[vlc.git] / modules / video_filter / adjust.c
1 /*****************************************************************************
2  * adjust.c : Contrast/Hue/Saturation/Brightness video plugin for vlc
3  *****************************************************************************
4  * Copyright (C) 2000-2006 VLC authors and VideoLAN
5  *
6  * Authors: Simon Latapie <garf@via.ecp.fr>
7  *          Antoine Cellerier <dionoea -at- videolan d0t org>
8  *          Martin Briza <gamajun@seznam.cz> (SSE)
9  *
10  * This program is free software; you can redistribute it and/or modify it
11  * under the terms of the GNU Lesser General Public License as published by
12  * the Free Software Foundation; either version 2.1 of the License, or
13  * (at your option) any later version.
14  *
15  * This program is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18  * GNU Lesser General Public License for more details.
19  *
20  * You should have received a copy of the GNU Lesser General Public License
21  * along with this program; if not, write to the Free Software Foundation,
22  * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
23  *****************************************************************************/
24
25 /*****************************************************************************
26  * Preamble
27  *****************************************************************************/
28
29 #ifdef HAVE_CONFIG_H
30 # include "config.h"
31 #endif
32
33 #include <math.h>
34 #include <stdatomic.h>
35
36 #include <vlc_common.h>
37 #include <vlc_plugin.h>
38 #include <vlc_filter.h>
39 #include <vlc_picture.h>
40 #include "filter_picture.h"
41
42 #include "adjust_sat_hue.h"
43
44 /*****************************************************************************
45  * Local prototypes
46  *****************************************************************************/
47 static int  Create    ( filter_t * );
48
49 static picture_t *FilterPacked( filter_t *, picture_t * );
50
51 /*****************************************************************************
52  * Module descriptor
53  *****************************************************************************/
54
55 #define THRES_TEXT N_("Brightness threshold")
56 #define THRES_LONGTEXT N_("When this mode is enabled, pixels will be " \
57         "shown as black or white. The threshold value will be the brightness " \
58         "defined below." )
59 #define CONT_TEXT N_("Image contrast (0-2)")
60 #define CONT_LONGTEXT N_("Set the image contrast, between 0 and 2. Defaults to 1.")
61 #define HUE_TEXT N_("Image hue (-180..180)")
62 #define HUE_LONGTEXT N_("Set the image hue, between -180 and 180. Defaults to 0.")
63 #define SAT_TEXT N_("Image saturation (0-3)")
64 #define SAT_LONGTEXT N_("Set the image saturation, between 0 and 3. Defaults to 1.")
65 #define LUM_TEXT N_("Image brightness (0-2)")
66 #define LUM_LONGTEXT N_("Set the image brightness, between 0 and 2. Defaults to 1.")
67 #define GAMMA_TEXT N_("Image gamma (0-10)")
68 #define GAMMA_LONGTEXT N_("Set the image gamma, between 0.01 and 10. Defaults to 1.")
69
70 vlc_module_begin ()
71     set_description( N_("Image properties filter") )
72     set_shortname( N_("Image adjust" ))
73     set_category( CAT_VIDEO )
74     set_subcategory( SUBCAT_VIDEO_VFILTER )
75
76     add_float_with_range( "contrast", 1.0, 0.0, 2.0,
77                           CONT_TEXT, CONT_LONGTEXT, false )
78         change_safe()
79     add_float_with_range( "brightness", 1.0, 0.0, 2.0,
80                            LUM_TEXT, LUM_LONGTEXT, false )
81         change_safe()
82     add_float_with_range( "hue", 0, -180., +180.,
83                             HUE_TEXT, HUE_LONGTEXT, false )
84         change_safe()
85     add_float_with_range( "saturation", 1.0, 0.0, 3.0,
86                           SAT_TEXT, SAT_LONGTEXT, false )
87         change_safe()
88     add_float_with_range( "gamma", 1.0, 0.01, 10.0,
89                           GAMMA_TEXT, GAMMA_LONGTEXT, false )
90         change_safe()
91     add_bool( "brightness-threshold", false,
92               THRES_TEXT, THRES_LONGTEXT, false )
93         change_safe()
94
95     add_shortcut( "adjust" )
96     set_callback_video_filter( Create )
97 vlc_module_end ()
98
99 static const char *const ppsz_filter_options[] = {
100     "contrast", "brightness", "hue", "saturation", "gamma",
101     "brightness-threshold", NULL
102 };
103
104 /*****************************************************************************
105  * filter_sys_t: adjust filter method descriptor
106  *****************************************************************************/
107 typedef struct
108 {
109     _Atomic float f_contrast;
110     _Atomic float f_brightness;
111     _Atomic float f_hue;
112     _Atomic float f_saturation;
113     _Atomic float f_gamma;
114     atomic_bool  b_brightness_threshold;
115     int (*pf_process_sat_hue)( picture_t *, picture_t *, int, int, int,
116                                int, int );
117     int (*pf_process_sat_hue_clip)( picture_t *, picture_t *, int, int,
118                                     int, int, int );
119 } filter_sys_t;
120
121 static int FloatCallback( vlc_object_t *obj, char const *varname,
122                           vlc_value_t oldval, vlc_value_t newval, void *data )
123 {
124     _Atomic float *atom = data;
125
126     atomic_store_explicit( atom, newval.f_float, memory_order_relaxed );
127     (void) obj; (void) varname; (void) oldval;
128     return VLC_SUCCESS;
129 }
130
131 static int BoolCallback( vlc_object_t *obj, char const *varname,
132                          vlc_value_t oldval, vlc_value_t newval, void *data )
133 {
134     atomic_bool *atom = data;
135
136     atomic_store_explicit( atom, newval.b_bool, memory_order_relaxed );
137     (void) obj; (void) varname; (void) oldval;
138     return VLC_SUCCESS;
139 }
140
141 VIDEO_FILTER_WRAPPER_CLOSE( FilterPlanar, Destroy )
142
143 static const struct vlc_filter_operations packed_filter_ops =
144 {
145     .filter_video = FilterPacked, .close = Destroy,
146 };
147
148 /*****************************************************************************
149  * Create: allocates adjust video filter
150  *****************************************************************************/
151 static int Create( filter_t *p_filter )
152 {
153     if( p_filter->fmt_in.video.i_chroma != p_filter->fmt_out.video.i_chroma )
154     {
155         msg_Err( p_filter, "Input and output chromas don't match" );
156         return VLC_EGENERIC;
157     }
158
159     /* Allocate structure */
160     filter_sys_t *p_sys = vlc_obj_malloc( VLC_OBJECT(p_filter), sizeof( *p_sys ) );
161     if( p_sys == NULL )
162         return VLC_ENOMEM;
163     p_filter->p_sys = p_sys;
164
165     /* Choose Planar/Packed function and pointer to a Hue/Saturation processing
166      * function*/
167     switch( p_filter->fmt_in.video.i_chroma )
168     {
169         CASE_PLANAR_YUV
170             /* Planar YUV */
171             p_filter->ops = &FilterPlanar_ops;
172             p_sys->pf_process_sat_hue_clip = planar_sat_hue_clip_C;
173             p_sys->pf_process_sat_hue = planar_sat_hue_C;
174             break;
175
176         CASE_PLANAR_YUV10
177         CASE_PLANAR_YUV9
178             /* Planar YUV 9-bit or 10-bit */
179             p_filter->ops = &FilterPlanar_ops;
180             p_sys->pf_process_sat_hue_clip = planar_sat_hue_clip_C_16;
181             p_sys->pf_process_sat_hue = planar_sat_hue_C_16;
182             break;
183
184         CASE_PACKED_YUV_422
185             /* Packed YUV 4:2:2 */
186             p_filter->ops = &packed_filter_ops;
187             p_sys->pf_process_sat_hue_clip = packed_sat_hue_clip_C;
188             p_sys->pf_process_sat_hue = packed_sat_hue_C;
189             break;
190
191         default:
192             msg_Dbg( p_filter, "Unsupported input chroma (%4.4s)",
193                      (char*)&(p_filter->fmt_in.video.i_chroma) );
194             return VLC_EGENERIC;
195     }
196
197     /* needed to get options passed in transcode using the
198      * adjust{name=value} syntax */
199     config_ChainParse( p_filter, "", ppsz_filter_options, p_filter->p_cfg );
200
201     atomic_init( &p_sys->f_contrast,
202                  var_CreateGetFloatCommand( p_filter, "contrast" ) );
203     atomic_init( &p_sys->f_brightness,
204                  var_CreateGetFloatCommand( p_filter, "brightness" ) );
205     atomic_init( &p_sys->f_hue, var_CreateGetFloatCommand( p_filter, "hue" ) );
206     atomic_init( &p_sys->f_saturation,
207                  var_CreateGetFloatCommand( p_filter, "saturation" ) );
208     atomic_init( &p_sys->f_gamma,
209                  var_CreateGetFloatCommand( p_filter, "gamma" ) );
210     atomic_init( &p_sys->b_brightness_threshold,
211                  var_CreateGetBoolCommand( p_filter, "brightness-threshold" ) );
212
213     var_AddCallback( p_filter, "contrast", FloatCallback, &p_sys->f_contrast );
214     var_AddCallback( p_filter, "brightness", FloatCallback,
215                      &p_sys->f_brightness );
216     var_AddCallback( p_filter, "hue", FloatCallback, &p_sys->f_hue );
217     var_AddCallback( p_filter, "saturation", FloatCallback,
218                      &p_sys->f_saturation );
219     var_AddCallback( p_filter, "gamma", FloatCallback, &p_sys->f_gamma );
220     var_AddCallback( p_filter, "brightness-threshold", BoolCallback,
221                      &p_sys->b_brightness_threshold );
222
223     return VLC_SUCCESS;
224 }
225
226 /*****************************************************************************
227  * Destroy: destroy adjust video filter
228  *****************************************************************************/
229 static void Destroy( filter_t *p_filter )
230 {
231     filter_sys_t *p_sys = p_filter->p_sys;
232
233     var_DelCallback( p_filter, "contrast", FloatCallback, &p_sys->f_contrast );
234     var_DelCallback( p_filter, "brightness", FloatCallback,
235                      &p_sys->f_brightness );
236     var_DelCallback( p_filter, "hue", FloatCallback, &p_sys->f_hue );
237     var_DelCallback( p_filter, "saturation", FloatCallback,
238                      &p_sys->f_saturation );
239     var_DelCallback( p_filter, "gamma", FloatCallback, &p_sys->f_gamma );
240     var_DelCallback( p_filter, "brightness-threshold", BoolCallback,
241                      &p_sys->b_brightness_threshold );
242 }
243
244 /*****************************************************************************
245  * Run the filter on a Planar YUV picture
246  *****************************************************************************/
247 static void FilterPlanar( filter_t *p_filter, picture_t *p_pic, picture_t *p_outpic )
248 {
249     /* The full range will only be used for 10-bit */
250     int pi_luma[1024];
251     int pi_gamma[1024];
252
253     filter_sys_t *p_sys = p_filter->p_sys;
254
255     bool b_16bit;
256     float f_range;
257     switch( p_filter->fmt_in.video.i_chroma )
258     {
259         CASE_PLANAR_YUV10
260             b_16bit = true;
261             f_range = 1024.f;
262             break;
263         CASE_PLANAR_YUV9
264             b_16bit = true;
265             f_range = 512.f;
266             break;
267         default:
268             b_16bit = false;
269             f_range = 256.f;
270     }
271
272     const float f_max = f_range - 1.f;
273     const unsigned i_max = f_max;
274     const int i_range = f_range;
275     const unsigned i_size = i_range;
276     const unsigned i_mid = i_range >> 1;
277
278     /* Get variables */
279     int32_t i_cont = lroundf( atomic_load_explicit( &p_sys->f_contrast, memory_order_relaxed ) * f_max );
280     int32_t i_lum = lroundf( (atomic_load_explicit( &p_sys->f_brightness, memory_order_relaxed ) - 1.f) * f_max );
281     float f_hue = atomic_load_explicit( &p_sys->f_hue, memory_order_relaxed ) * (float)(M_PI / 180.);
282     int i_sat = (int)( atomic_load_explicit( &p_sys->f_saturation, memory_order_relaxed ) * f_range );
283     float f_gamma = 1.f / atomic_load_explicit( &p_sys->f_gamma, memory_order_relaxed );
284
285     /*
286      * Threshold mode drops out everything about luma, contrast and gamma.
287      */
288     if( !atomic_load_explicit( &p_sys->b_brightness_threshold,
289                                memory_order_relaxed ) )
290     {
291
292         /* Contrast is a fast but kludged function, so I put this gap to be
293          * cleaner :) */
294         i_lum += i_mid - i_cont / 2;
295
296         /* Fill the gamma lookup table */
297         for( unsigned i = 0 ; i < i_size; i++ )
298         {
299             pi_gamma[ i ] = VLC_CLIP( powf(i / f_max, f_gamma) * f_max, 0, i_max );
300         }
301
302         /* Fill the luma lookup table */
303         for( unsigned i = 0 ; i < i_size; i++ )
304         {
305             pi_luma[ i ] = pi_gamma[VLC_CLIP( (int)(i_lum + i_cont * i / i_range), 0, (int) i_max )];
306         }
307     }
308     else
309     {
310         /*
311          * We get luma as threshold value: the higher it is, the darker is
312          * the image. Should I reverse this?
313          */
314         for( int i = 0 ; i < i_range; i++ )
315         {
316             pi_luma[ i ] = (i < i_lum) ? 0 : i_max;
317         }
318
319         /*
320          * Desaturates image to avoid that strange yellow halo...
321          */
322         i_sat = 0;
323     }
324
325     /*
326      * Do the Y plane
327      */
328     if ( b_16bit )
329     {
330         uint16_t *p_in, *p_in_end, *p_line_end;
331         uint16_t *p_out;
332         p_in = (uint16_t *) p_pic->p[Y_PLANE].p_pixels;
333         p_in_end = p_in + p_pic->p[Y_PLANE].i_visible_lines
334             * (p_pic->p[Y_PLANE].i_pitch >> 1) - 8;
335
336         p_out = (uint16_t *) p_outpic->p[Y_PLANE].p_pixels;
337
338         for( ; p_in < p_in_end ; )
339         {
340             p_line_end = p_in + (p_pic->p[Y_PLANE].i_visible_pitch >> 1) - 8;
341
342             for( ; p_in < p_line_end ; )
343             {
344                 /* Do 8 pixels at a time */
345                 *p_out++ = pi_luma[ *p_in++ ]; *p_out++ = pi_luma[ *p_in++ ];
346                 *p_out++ = pi_luma[ *p_in++ ]; *p_out++ = pi_luma[ *p_in++ ];
347                 *p_out++ = pi_luma[ *p_in++ ]; *p_out++ = pi_luma[ *p_in++ ];
348                 *p_out++ = pi_luma[ *p_in++ ]; *p_out++ = pi_luma[ *p_in++ ];
349             }
350
351             p_line_end += 8;
352
353             for( ; p_in < p_line_end ; )
354             {
355                 *p_out++ = pi_luma[ *p_in++ ];
356             }
357
358             p_in += (p_pic->p[Y_PLANE].i_pitch >> 1)
359                 - (p_pic->p[Y_PLANE].i_visible_pitch >> 1);
360             p_out += (p_outpic->p[Y_PLANE].i_pitch >> 1)
361                 - (p_outpic->p[Y_PLANE].i_visible_pitch >> 1);
362         }
363     }
364     else
365     {
366         uint8_t *p_in, *p_in_end, *p_line_end;
367         uint8_t *p_out;
368         p_in = p_pic->p[Y_PLANE].p_pixels;
369         p_in_end = p_in + p_pic->p[Y_PLANE].i_visible_lines
370                  * p_pic->p[Y_PLANE].i_pitch - 8;
371
372         p_out = p_outpic->p[Y_PLANE].p_pixels;
373
374         for( ; p_in < p_in_end ; )
375         {
376             p_line_end = p_in + p_pic->p[Y_PLANE].i_visible_pitch - 8;
377
378             for( ; p_in < p_line_end ; )
379             {
380                 /* Do 8 pixels at a time */
381                 *p_out++ = pi_luma[ *p_in++ ]; *p_out++ = pi_luma[ *p_in++ ];
382                 *p_out++ = pi_luma[ *p_in++ ]; *p_out++ = pi_luma[ *p_in++ ];
383                 *p_out++ = pi_luma[ *p_in++ ]; *p_out++ = pi_luma[ *p_in++ ];
384                 *p_out++ = pi_luma[ *p_in++ ]; *p_out++ = pi_luma[ *p_in++ ];
385             }
386
387             p_line_end += 8;
388
389             for( ; p_in < p_line_end ; )
390             {
391                 *p_out++ = pi_luma[ *p_in++ ];
392             }
393
394             p_in += p_pic->p[Y_PLANE].i_pitch
395                   - p_pic->p[Y_PLANE].i_visible_pitch;
396             p_out += p_outpic->p[Y_PLANE].i_pitch
397                    - p_outpic->p[Y_PLANE].i_visible_pitch;
398         }
399     }
400
401     /*
402      * Do the U and V planes
403      */
404
405     int i_sin = sinf(f_hue) * f_max;
406     int i_cos = cosf(f_hue) * f_max;
407
408     /* pow(2, (bpp * 2) - 1) */
409     int i_x = ( cosf(f_hue) + sinf(f_hue) ) * f_range * i_mid;
410     int i_y = ( cosf(f_hue) - sinf(f_hue) ) * f_range * i_mid;
411
412     if ( i_sat > i_range )
413     {
414         /* Currently no errors are implemented in the function, if any are added
415          * check them here */
416         p_sys->pf_process_sat_hue_clip( p_pic, p_outpic, i_sin, i_cos, i_sat,
417                                         i_x, i_y );
418     }
419     else
420     {
421         /* Currently no errors are implemented in the function, if any are added
422          * check them here */
423         p_sys->pf_process_sat_hue( p_pic, p_outpic, i_sin, i_cos, i_sat,
424                                         i_x, i_y );
425     }
426 }
427
428 /*****************************************************************************
429  * Run the filter on a Packed YUV picture
430  *****************************************************************************/
431 static picture_t *FilterPacked( filter_t *p_filter, picture_t *p_pic )
432 {
433     int pi_luma[256];
434     int pi_gamma[256];
435
436     picture_t *p_outpic;
437     uint8_t *p_in, *p_in_end, *p_line_end;
438     uint8_t *p_out;
439     int i_y_offset, i_u_offset, i_v_offset;
440
441     int i_pitch, i_visible_pitch;
442
443     double  f_hue;
444     double  f_gamma;
445     int32_t i_cont, i_lum;
446     int i_sat, i_sin, i_cos, i_x, i_y;
447
448     filter_sys_t *p_sys = p_filter->p_sys;
449
450     if( !p_pic ) return NULL;
451
452     i_pitch = p_pic->p->i_pitch;
453     i_visible_pitch = p_pic->p->i_visible_pitch;
454
455     if( GetPackedYuvOffsets( p_pic->format.i_chroma, &i_y_offset,
456                              &i_u_offset, &i_v_offset ) != VLC_SUCCESS )
457     {
458         msg_Warn( p_filter, "Unsupported input chroma (%4.4s)",
459                   (char*)&(p_pic->format.i_chroma) );
460
461         picture_Release( p_pic );
462         return NULL;
463     }
464
465     p_outpic = filter_NewPicture( p_filter );
466     if( !p_outpic )
467     {
468         msg_Warn( p_filter, "can't get output picture" );
469
470         picture_Release( p_pic );
471         return NULL;
472     }
473
474     /* Get variables */
475     i_cont = (int)( atomic_load_explicit( &p_sys->f_contrast, memory_order_relaxed ) * 255 );
476     i_lum = (int)( (atomic_load_explicit( &p_sys->f_brightness, memory_order_relaxed ) - 1.0)*255 );
477     f_hue = atomic_load_explicit( &p_sys->f_hue, memory_order_relaxed ) * (float)(M_PI / 180.);
478     i_sat = (int)( atomic_load_explicit( &p_sys->f_saturation, memory_order_relaxed ) * 256 );
479     f_gamma = 1.0 / atomic_load_explicit( &p_sys->f_gamma, memory_order_relaxed );
480
481     /*
482      * Threshold mode drops out everything about luma, contrast and gamma.
483      */
484     if( !atomic_load_explicit( &p_sys->b_brightness_threshold, memory_order_relaxed ) )
485     {
486
487         /* Contrast is a fast but kludged function, so I put this gap to be
488          * cleaner :) */
489         i_lum += 128 - i_cont / 2;
490
491         /* Fill the gamma lookup table */
492         for( int i = 0 ; i < 256 ; i++ )
493         {
494           pi_gamma[ i ] = clip_uint8_vlc( pow(i / 255.0, f_gamma) * 255.0);
495         }
496
497         /* Fill the luma lookup table */
498         for( int i = 0 ; i < 256 ; i++ )
499         {
500             pi_luma[ i ] = pi_gamma[clip_uint8_vlc( i_lum + i_cont * i / 256)];
501         }
502     }
503     else
504     {
505         /*
506          * We get luma as threshold value: the higher it is, the darker is
507          * the image. Should I reverse this?
508          */
509         for( int i = 0 ; i < 256 ; i++ )
510         {
511             pi_luma[ i ] = (i < i_lum) ? 0 : 255;
512         }
513
514         /*
515          * Desaturates image to avoid that strange yellow halo...
516          */
517         i_sat = 0;
518     }
519
520     /*
521      * Do the Y plane
522      */
523
524     p_in = p_pic->p->p_pixels + i_y_offset;
525     p_in_end = p_in + p_pic->p->i_visible_lines * p_pic->p->i_pitch - 8 * 4;
526
527     p_out = p_outpic->p->p_pixels + i_y_offset;
528
529     for( ; p_in < p_in_end ; )
530     {
531         p_line_end = p_in + i_visible_pitch - 8 * 4;
532
533         for( ; p_in < p_line_end ; )
534         {
535             /* Do 8 pixels at a time */
536             *p_out = pi_luma[ *p_in ]; p_in += 2; p_out += 2;
537             *p_out = pi_luma[ *p_in ]; p_in += 2; p_out += 2;
538             *p_out = pi_luma[ *p_in ]; p_in += 2; p_out += 2;
539             *p_out = pi_luma[ *p_in ]; p_in += 2; p_out += 2;
540             *p_out = pi_luma[ *p_in ]; p_in += 2; p_out += 2;
541             *p_out = pi_luma[ *p_in ]; p_in += 2; p_out += 2;
542             *p_out = pi_luma[ *p_in ]; p_in += 2; p_out += 2;
543             *p_out = pi_luma[ *p_in ]; p_in += 2; p_out += 2;
544         }
545
546         p_line_end += 8 * 4;
547
548         for( ; p_in < p_line_end ; )
549         {
550             *p_out = pi_luma[ *p_in ]; p_in += 2; p_out += 2;
551         }
552
553         p_in += i_pitch - p_pic->p->i_visible_pitch;
554         p_out += i_pitch - p_outpic->p->i_visible_pitch;
555     }
556
557     /*
558      * Do the U and V planes
559      */
560
561     i_sin = sin(f_hue) * 256;
562     i_cos = cos(f_hue) * 256;
563
564     i_x = ( cos(f_hue) + sin(f_hue) ) * 32768;
565     i_y = ( cos(f_hue) - sin(f_hue) ) * 32768;
566
567     if ( i_sat > 256 )
568     {
569         if ( p_sys->pf_process_sat_hue_clip( p_pic, p_outpic, i_sin, i_cos, i_sat,
570                                              i_x, i_y ) != VLC_SUCCESS )
571         {
572             /* Currently only one error can happen in the function, but if there
573              * will be more of them, this message must go away */
574             msg_Warn( p_filter, "Unsupported input chroma (%4.4s)",
575                       (char*)&(p_pic->format.i_chroma) );
576             picture_Release( p_pic );
577             return NULL;
578         }
579     }
580     else
581     {
582         if ( p_sys->pf_process_sat_hue( p_pic, p_outpic, i_sin, i_cos, i_sat,
583                                         i_x, i_y ) != VLC_SUCCESS )
584         {
585             /* Currently only one error can happen in the function, but if there
586              * will be more of them, this message must go away */
587             msg_Warn( p_filter, "Unsupported input chroma (%4.4s)",
588                       (char*)&(p_pic->format.i_chroma) );
589             picture_Release( p_pic );
590             return NULL;
591         }
592     }
593
594     return CopyInfoAndRelease( p_outpic, p_pic );
595 }