filter_chain: introduce dedicated filter_chain_NewVideo() for video filters
[vlc.git] / modules / video_filter / canvas.c
1 /*****************************************************************************
2  * canvas.c : automatically resize and padd a video to fit in canvas
3  *****************************************************************************
4  * Copyright (C) 2008 VLC authors and VideoLAN
5  * $Id$
6  *
7  * Authors: Antoine Cellerier <dionoea at videolan dot org>
8  *
9  * This program is free software; you can redistribute it and/or modify it
10  * under the terms of the GNU Lesser General Public License as published by
11  * the Free Software Foundation; either version 2.1 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 Lesser General Public License for more details.
18  *
19  * You should have received a copy of the GNU Lesser General Public License
20  * along with this program; if not, write to the Free Software Foundation,
21  * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
22  *****************************************************************************/
23
24 /*****************************************************************************
25  * Preamble
26  *****************************************************************************/
27
28 #ifdef HAVE_CONFIG_H
29 # include "config.h"
30 #endif
31
32 #include <limits.h>
33
34 #include <vlc_common.h>
35 #include <vlc_plugin.h>
36 #include <vlc_filter.h>
37
38 /*****************************************************************************
39  * Local and extern prototypes.
40  *****************************************************************************/
41 static int  Activate( vlc_object_t * );
42 static void Destroy( vlc_object_t * );
43 static picture_t *Filter( filter_t *, picture_t * );
44
45 /* This module effectively implements a form of picture-in-picture.
46  *  - The outer picture is called the canvas.
47  *  - The innter picture is callsed the subpicture.
48  *
49  * NB, all of the following operatons take into account aspect ratio
50  *
51  * A canvas is of canvas_{width,height}.
52  * In Pad mode:
53  *  - The subpicture is upconverted with a inverse scalefactor of:
54  *     (The size of subpicture's largest dimension)
55  *     --------------------------------------------
56  *     (The size of canvas's equivalent dimension)
57  *
58  *   Ie, The subpicture's largest dimension is made equal to the
59  *   equivalent canvas dimension.
60  *
61  *  - The upconverted subpicture's smallest dimension is then padded
62  *    to make the upconverted subpicture have the same dimensions of
63  *    the canvas.
64  *
65  * In Crop mode:
66  *  - The subpicture is upconverted with an inverse scalefactor of:
67  *     (The size of subpicture's smallest dimension)
68  *     --------------------------------------------
69  *     (The size of canvas's equivalent dimension)
70  *
71  *   Ie, The subpicture's smallest dimension is made equal to the
72  *   equivalent canvas dimension. (The subpicture will then be
73  *   larger than the canvas)
74  *
75  *  - The upconverted subpicture's largest dimension is then cropped
76  *    to make the upconverted subpicture have the same dimensions of
77  *    the canvas.
78  */
79
80 /* NB, use of `padd' in this module is a 16-17th Century spelling of `pad' */
81
82 #define WIDTH_TEXT N_( "Output width" )
83 #define WIDTH_LONGTEXT N_( \
84     "Output (canvas) image width" )
85 #define HEIGHT_TEXT N_( "Output height" )
86 #define HEIGHT_LONGTEXT N_( \
87     "Output (canvas) image height" )
88 #define ASPECT_TEXT N_( "Output picture aspect ratio" )
89 #define ASPECT_LONGTEXT N_( \
90     "Set the canvas' picture aspect ratio. " \
91     "If omitted, the canvas is assumed to have the same SAR as the input." )
92 #define PADD_TEXT N_( "Pad video" )
93 #define PADD_LONGTEXT N_( \
94     "If enabled, video will be padded to fit in canvas after scaling. " \
95     "Otherwise, video will be cropped to fix in canvas after scaling." )
96 #define CANVAS_HELP N_( "Automatically resize and pad a video" )
97
98 #define CFG_PREFIX "canvas-"
99
100 /*****************************************************************************
101  * Module descriptor
102  *****************************************************************************/
103 vlc_module_begin ()
104     set_shortname( N_("Canvas") )
105     set_description( N_("Canvas video filter") )
106     set_capability( "video filter2", 0 )
107     set_help( CANVAS_HELP )
108     set_callbacks( Activate, Destroy )
109
110     set_category( CAT_VIDEO )
111     set_subcategory( SUBCAT_VIDEO_VFILTER )
112
113     add_integer_with_range( CFG_PREFIX "width", 0, 0, INT_MAX,
114                             WIDTH_TEXT, WIDTH_LONGTEXT, false )
115     add_integer_with_range( CFG_PREFIX "height", 0, 0, INT_MAX,
116                             HEIGHT_TEXT, HEIGHT_LONGTEXT, false )
117
118     add_string( CFG_PREFIX "aspect", NULL,
119                 ASPECT_TEXT, ASPECT_LONGTEXT, false )
120
121     add_bool( CFG_PREFIX "padd", true,
122               PADD_TEXT, PADD_LONGTEXT, false )
123 vlc_module_end ()
124
125 static const char *const ppsz_filter_options[] = {
126     "width", "height", "aspect", "padd", NULL
127 };
128
129 struct filter_sys_t
130 {
131     filter_chain_t *p_chain;
132 };
133
134 static picture_t *video_new( filter_t *p_filter )
135 {
136     return filter_NewPicture( p_filter->owner.sys );
137 }
138
139 static void video_del( filter_t *p_filter, picture_t *p_pic )
140 {
141     return filter_DeletePicture( p_filter->owner.sys, p_pic );
142 }
143
144 /*****************************************************************************
145  *
146  *****************************************************************************/
147 static int Activate( vlc_object_t *p_this )
148 {
149     filter_t *p_filter = (filter_t *)p_this;
150     unsigned i_canvas_width; /* visible width of output canvas */
151     unsigned i_canvas_height; /* visible height of output canvas */
152     unsigned i_canvas_aspect; /* canvas PictureAspectRatio */
153     es_format_t fmt; /* target format after up/down conversion */
154     char psz_croppadd[100];
155     int i_padd,i_offset;
156     char *psz_aspect, *psz_parser;
157     bool b_padd;
158     unsigned i_fmt_in_aspect;
159
160     if( !p_filter->b_allow_fmt_out_change )
161     {
162         msg_Err( p_filter, "Picture format change isn't allowed" );
163         return VLC_EGENERIC;
164     }
165
166     if( p_filter->fmt_in.video.i_chroma != p_filter->fmt_out.video.i_chroma )
167     {
168         msg_Err( p_filter, "Input and output chromas don't match" );
169         return VLC_EGENERIC;
170     }
171
172     config_ChainParse( p_filter, CFG_PREFIX, ppsz_filter_options,
173                        p_filter->p_cfg );
174
175     i_canvas_width = var_CreateGetInteger( p_filter, CFG_PREFIX "width" );
176     i_canvas_height = var_CreateGetInteger( p_filter, CFG_PREFIX "height" );
177
178     if( i_canvas_width == 0 || i_canvas_height == 0 )
179     {
180         msg_Err( p_filter, "Width and height options must be set" );
181         return VLC_EGENERIC;
182     }
183
184     if( i_canvas_width & 1 || i_canvas_height & 1 )
185     {
186         /* If this restriction were ever relaxed, it is very important to
187          * get the field polatiry correct */
188         msg_Err( p_filter, "Width and height options must be even integers" );
189         return VLC_EGENERIC;
190     }
191
192     if( p_filter->fmt_in.video.i_sar_num )
193         i_fmt_in_aspect = (int64_t)p_filter->fmt_in.video.i_sar_num *
194                       p_filter->fmt_in.video.i_visible_width *
195                       VOUT_ASPECT_FACTOR /
196                       p_filter->fmt_in.video.i_sar_den /
197                       p_filter->fmt_in.video.i_visible_height;
198     else
199         i_fmt_in_aspect = (int64_t)p_filter->fmt_in.video.i_visible_width *
200                       VOUT_ASPECT_FACTOR /
201                       p_filter->fmt_in.video.i_visible_height;
202
203     psz_aspect = var_CreateGetNonEmptyString( p_filter, CFG_PREFIX "aspect" );
204     if( psz_aspect )
205     {
206         psz_parser = strchr( psz_aspect, ':' );
207         int numerator = atoi( psz_aspect );
208         int denominator = psz_parser ? atoi( psz_parser+1 ) : 0;
209         denominator = denominator == 0 ? 1 : denominator;
210         i_canvas_aspect = numerator * VOUT_ASPECT_FACTOR / denominator;
211         free( psz_aspect );
212
213         if( numerator <= 0 || denominator < 0 )
214         {
215             msg_Err( p_filter, "Aspect ratio must be strictly positive" );
216             return VLC_EGENERIC;
217         }
218     }
219     else
220     {
221         /* if there is no user supplied aspect ratio, assume the canvas
222          * has the same sample aspect ratio as the subpicture */
223         /* aspect = subpic_sar * canvas_width / canvas_height
224          *  where subpic_sar = subpic_ph * subpic_par / subpic_pw */
225         i_canvas_aspect = (uint64_t) p_filter->fmt_in.video.i_visible_height
226                         * i_fmt_in_aspect
227                         * i_canvas_width
228                         / (i_canvas_height * p_filter->fmt_in.video.i_visible_width);
229     }
230
231     b_padd = var_CreateGetBool( p_filter, CFG_PREFIX "padd" );
232
233     filter_sys_t *p_sys = (filter_sys_t *)malloc( sizeof( filter_sys_t ) );
234     if( !p_sys )
235         return VLC_ENOMEM;
236     p_filter->p_sys = p_sys;
237
238     filter_owner_t owner = {
239         .sys = p_filter,
240         .video = {
241             .buffer_new = video_new,
242             .buffer_del = video_del,
243         },
244     };
245
246     p_sys->p_chain = filter_chain_NewVideo( p_filter, true, &owner );
247     if( !p_sys->p_chain )
248     {
249         msg_Err( p_filter, "Could not allocate filter chain" );
250         free( p_sys );
251         return VLC_EGENERIC;
252     }
253
254     es_format_Copy( &fmt, &p_filter->fmt_in );
255
256     /* one dimension will end up with one of the following: */
257     fmt.video.i_visible_width = i_canvas_width;
258     fmt.video.i_visible_height = i_canvas_height;
259
260     if( b_padd )
261     {
262         /* Padd */
263         if( i_canvas_aspect > i_fmt_in_aspect )
264         {
265             /* The canvas has a wider aspect than the subpicture:
266              *  ie, pillarbox the [scaled] subpicture */
267             /* The following is derived form:
268              * width = upconverted_subpic_height * subpic_par / canvas_sar
269              *  where canvas_sar = canvas_width / (canvas_height * canvas_par)
270              * then simplify */
271             fmt.video.i_visible_width = i_canvas_width
272                               * i_fmt_in_aspect
273                               / i_canvas_aspect;
274             if( fmt.video.i_visible_width & 1 ) fmt.video.i_visible_width -= 1;
275
276             i_padd = (i_canvas_width - fmt.video.i_visible_width) / 2;
277             i_offset = (i_padd & 1);
278             snprintf( psz_croppadd, 100, "croppadd{paddleft=%d,paddright=%d}",
279                       i_padd - i_offset, i_padd + i_offset );
280         }
281         else
282         {
283             /* The canvas has a taller aspect than the subpicture:
284              *  ie, letterbox the [scaled] subpicture */
285             fmt.video.i_visible_height = i_canvas_height
286                                * i_canvas_aspect
287                                / i_fmt_in_aspect;
288             if( fmt.video.i_visible_height & 1 ) fmt.video.i_visible_height -= 1;
289
290             i_padd = (i_canvas_height - fmt.video.i_visible_height ) / 2;
291             i_offset = (i_padd & 1);
292             snprintf( psz_croppadd, 100, "croppadd{paddtop=%d,paddbottom=%d}",
293                       i_padd - i_offset, i_padd + i_offset );
294         }
295     }
296     else
297     {
298         /* Crop */
299         if( i_canvas_aspect < i_fmt_in_aspect )
300         {
301             /* The canvas has a narrower aspect than the subpicture:
302              *  ie, crop the [scaled] subpicture horizontally */
303             fmt.video.i_visible_width = i_canvas_width
304                               * i_fmt_in_aspect
305                               / i_canvas_aspect;
306             if( fmt.video.i_visible_width & 1 ) fmt.video.i_visible_width -= 1;
307
308             i_padd = (fmt.video.i_visible_width - i_canvas_width) / 2;
309             i_offset = (i_padd & 1);
310             snprintf( psz_croppadd, 100, "croppadd{cropleft=%d,cropright=%d}",
311                       i_padd - i_offset, i_padd + i_offset );
312         }
313         else
314         {
315             /* The canvas has a shorter aspect than the subpicture:
316              *  ie, crop the [scaled] subpicture vertically */
317             fmt.video.i_visible_height = i_canvas_height
318                                * i_canvas_aspect
319                                / i_fmt_in_aspect;
320             if( fmt.video.i_visible_height & 1 ) fmt.video.i_visible_height -= 1;
321
322             i_padd = (fmt.video.i_visible_height - i_canvas_height) / 2;
323             i_offset = (i_padd & 1);
324             snprintf( psz_croppadd, 100, "croppadd{croptop=%d,cropbottom=%d}",
325                       i_padd - i_offset, i_padd + i_offset );
326         }
327     }
328
329     /* xxx, should the clean area include the letter-boxing?
330      *  probably not, as some codecs can make use of that information
331      *  and it should be a scaled version of the input clean area
332      *   -- davidf */
333     fmt.video.i_width = p_filter->fmt_in.video.i_width * fmt.video.i_visible_width / p_filter->fmt_in.video.i_visible_width;
334     fmt.video.i_height = p_filter->fmt_in.video.i_height * fmt.video.i_visible_height / p_filter->fmt_in.video.i_visible_height;
335
336     filter_chain_Reset( p_sys->p_chain, &p_filter->fmt_in, &fmt );
337     /* Append scaling module */
338     filter_chain_AppendFilter( p_sys->p_chain, NULL, NULL, NULL, NULL );
339     /* Append padding module */
340     filter_chain_AppendFromString( p_sys->p_chain, psz_croppadd );
341
342     fmt = *filter_chain_GetFmtOut( p_sys->p_chain );
343     es_format_Copy( &p_filter->fmt_out, &fmt );
344
345     vlc_ureduce( &p_filter->fmt_out.video.i_sar_num,
346         &p_filter->fmt_out.video.i_sar_den,
347         i_canvas_aspect    * p_filter->fmt_out.video.i_visible_height,
348         VOUT_ASPECT_FACTOR * p_filter->fmt_out.video.i_visible_width,
349         0);
350
351     if( p_filter->fmt_out.video.i_visible_width != i_canvas_width
352      || p_filter->fmt_out.video.i_visible_height != i_canvas_height )
353     {
354         msg_Warn( p_filter, "Looks like something went wrong. "
355                   "Output size is %dx%d while we asked for %dx%d",
356                   p_filter->fmt_out.video.i_visible_width,
357                   p_filter->fmt_out.video.i_visible_height,
358                   i_canvas_width, i_canvas_height );
359     }
360
361     p_filter->pf_video_filter = Filter;
362
363     return VLC_SUCCESS;
364 }
365
366 /*****************************************************************************
367  *
368  *****************************************************************************/
369 static void Destroy( vlc_object_t *p_this )
370 {
371     filter_t *p_filter = (filter_t *)p_this;
372     filter_chain_Delete( p_filter->p_sys->p_chain );
373     free( p_filter->p_sys );
374 }
375
376 /*****************************************************************************
377  *
378  *****************************************************************************/
379 static picture_t *Filter( filter_t *p_filter, picture_t *p_pic )
380 {
381     return filter_chain_VideoFilter( p_filter->p_sys->p_chain, p_pic );
382 }