Fix swscale linking
[vlc.git] / modules / video_filter / swscale.c
1 /*****************************************************************************
2  * swscale.c: scaling and chroma conversion using libswscale
3  *****************************************************************************
4  * Copyright (C) 1999-2008 the VideoLAN team
5  * $Id$
6  *
7  * Authors: Laurent Aimar <fenrir@via.ecp.fr>
8  *          Gildas Bazin <gbazin@videolan.org>
9  *
10  * This program is free software; you can redistribute it and/or modify
11  * it under the terms of the GNU General Public License as published by
12  * the Free Software Foundation; either version 2 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 General Public License for more details.
19  *
20  * You should have received a copy of the GNU General Public License
21  * along with this program; if not, write to the Free Software
22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
23  *****************************************************************************/
24
25 /*****************************************************************************
26  * Preamble
27  *****************************************************************************/
28 #ifdef HAVE_CONFIG_H
29 # include "config.h"
30 #endif
31
32 #include <vlc_common.h>
33 #include <vlc_plugin.h>
34 #include <vlc_vout.h>
35 #include <vlc_filter.h>
36
37 #ifdef HAVE_LIBSWSCALE_SWSCALE_H
38 #   include <libswscale/swscale.h>
39 #   include <libavcodec/avcodec.h>
40 #elif defined(HAVE_FFMPEG_SWSCALE_H)
41 #   include <ffmpeg/swscale.h>
42 #   include <ffmpeg/avcodec.h>
43 #endif
44
45 /* Gruikkkkkkkkkk!!!!! */
46 #include "../codec/avcodec/avcodec.h"
47 #undef AVPALETTE_SIZE
48
49 #define AVPALETTE_SIZE (256 * sizeof(uint32_t))
50
51 /*****************************************************************************
52  * Module descriptor
53  *****************************************************************************/
54 static int  OpenScaler( vlc_object_t * );
55 static void CloseScaler( vlc_object_t * );
56
57 #define SCALEMODE_TEXT N_("Scaling mode")
58 #define SCALEMODE_LONGTEXT N_("Scaling mode to use.")
59
60 static const int pi_mode_values[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
61 const char *const ppsz_mode_descriptions[] =
62 { N_("Fast bilinear"), N_("Bilinear"), N_("Bicubic (good quality)"),
63   N_("Experimental"), N_("Nearest neighbour (bad quality)"),
64   N_("Area"), N_("Luma bicubic / chroma bilinear"), N_("Gauss"),
65   N_("SincR"), N_("Lanczos"), N_("Bicubic spline") };
66
67 vlc_module_begin();
68     set_description( N_("Video scaling filter") );
69     set_capability( "video filter2", 150 );
70     set_category( CAT_VIDEO );
71     set_subcategory( SUBCAT_VIDEO_VFILTER );
72     set_callbacks( OpenScaler, CloseScaler );
73     add_integer( "swscale-mode", 2, NULL, SCALEMODE_TEXT, SCALEMODE_LONGTEXT, true );
74         change_integer_list( pi_mode_values, ppsz_mode_descriptions, NULL );
75 vlc_module_end();
76
77 /* Version checking */
78 #if LIBSWSCALE_VERSION_INT >= ((0<<16)+(5<<8)+0)
79 /****************************************************************************
80  * Local prototypes
81  ****************************************************************************/
82
83 void *( *swscale_fast_memcpy )( void *, const void *, size_t );
84
85 /**
86  * Internal swscale filter structure.
87  */
88 struct filter_sys_t
89 {
90     SwsFilter *p_src_filter;
91     SwsFilter *p_dst_filter;
92     int i_cpu_mask, i_sws_flags;
93
94     video_format_t fmt_in;
95     video_format_t fmt_out;
96
97     struct SwsContext *ctx;
98     struct SwsContext *ctxA;
99     picture_t *p_src_a;
100     picture_t *p_dst_a;
101     int i_extend_factor;
102     picture_t *p_src_e;
103     picture_t *p_dst_e;
104     bool b_add_a;
105     bool b_copy;
106 };
107
108 static picture_t *Filter( filter_t *, picture_t * );
109 static int  Init( filter_t * );
110 static void Clean( filter_t * );
111
112 typedef struct
113 {
114     int  i_fmti;
115     int  i_fmto;
116     bool b_has_a;
117     bool b_add_a;
118     int  i_sws_flags;
119     bool b_copy;
120 } ScalerConfiguration;
121
122 static int GetParameters( ScalerConfiguration *,
123                           const video_format_t *p_fmti,
124                           const video_format_t *p_fmto,
125                           int i_sws_flags_default );
126
127 static int GetSwsCpuMask(void);
128
129 /* SwScaler point resize quality seems really bad, let our scale module do it
130  * (change it to true to try) */
131 #define ALLOW_YUVP (false)
132 /* SwScaler does not like too small picture */
133 #define MINIMUM_WIDTH (32)
134
135 /* XXX is it always 3 even for BIG_ENDIAN (blend.c seems to think so) ? */
136 #define OFFSET_A (3)
137
138 /*****************************************************************************
139  * OpenScaler: probe the filter and return score
140  *****************************************************************************/
141 static int OpenScaler( vlc_object_t *p_this )
142 {
143     filter_t *p_filter = (filter_t*)p_this;
144     filter_sys_t *p_sys;
145
146     int i_sws_mode;
147
148     float sws_lum_gblur = 0.0, sws_chr_gblur = 0.0;
149     int sws_chr_vshift = 0, sws_chr_hshift = 0;
150     float sws_chr_sharpen = 0.0, sws_lum_sharpen = 0.0;
151
152     if( GetParameters( NULL,
153                        &p_filter->fmt_in.video,
154                        &p_filter->fmt_out.video, 0 ) )
155         return VLC_EGENERIC;
156
157     /* */
158     p_filter->pf_video_filter = Filter;
159     /* Allocate the memory needed to store the decoder's structure */
160     if( ( p_filter->p_sys = p_sys = malloc(sizeof(filter_sys_t)) ) == NULL )
161         return VLC_ENOMEM;
162
163     /* FIXME pointer assignment may not be atomic */
164     swscale_fast_memcpy = vlc_memcpy;
165
166     /* Set CPU capabilities */
167     p_sys->i_cpu_mask = GetSwsCpuMask();
168
169     /* */
170     i_sws_mode = var_CreateGetInteger( p_filter, "swscale-mode" );
171     switch( i_sws_mode )
172     {
173     case 0:  p_sys->i_sws_flags = SWS_FAST_BILINEAR; break;
174     case 1:  p_sys->i_sws_flags = SWS_BILINEAR; break;
175     case 2:  p_sys->i_sws_flags = SWS_BICUBIC; break;
176     case 3:  p_sys->i_sws_flags = SWS_X; break;
177     case 4:  p_sys->i_sws_flags = SWS_POINT; break;
178     case 5:  p_sys->i_sws_flags = SWS_AREA; break;
179     case 6:  p_sys->i_sws_flags = SWS_BICUBLIN; break;
180     case 7:  p_sys->i_sws_flags = SWS_GAUSS; break;
181     case 8:  p_sys->i_sws_flags = SWS_SINC; break;
182     case 9:  p_sys->i_sws_flags = SWS_LANCZOS; break;
183     case 10: p_sys->i_sws_flags = SWS_SPLINE; break;
184     default: p_sys->i_sws_flags = SWS_BICUBIC; i_sws_mode = 2; break;
185     }
186
187     p_sys->p_src_filter = NULL;
188     p_sys->p_dst_filter = NULL;
189
190     /* Misc init */
191     p_sys->ctx = NULL;
192     p_sys->ctxA = NULL;
193     p_sys->p_src_a = NULL;
194     p_sys->p_dst_a = NULL;
195     p_sys->p_src_e = NULL;
196     p_sys->p_dst_e = NULL;
197     memset( &p_sys->fmt_in,  0, sizeof(p_sys->fmt_in) );
198     memset( &p_sys->fmt_out, 0, sizeof(p_sys->fmt_out) );
199
200     if( Init( p_filter ) )
201     {
202         if( p_sys->p_src_filter )
203             sws_freeFilter( p_sys->p_src_filter );
204         free( p_sys );
205         return VLC_EGENERIC;
206     }
207
208     msg_Dbg( p_filter, "%ix%i chroma: %4.4s -> %ix%i chroma: %4.4s with scaling using %s",
209              p_filter->fmt_in.video.i_width, p_filter->fmt_in.video.i_height,
210              (char *)&p_filter->fmt_in.video.i_chroma,
211              p_filter->fmt_out.video.i_width, p_filter->fmt_out.video.i_height,
212              (char *)&p_filter->fmt_out.video.i_chroma,
213              ppsz_mode_descriptions[i_sws_mode] );
214
215     return VLC_SUCCESS;
216 }
217
218 /*****************************************************************************
219  * CloseFilter: clean up the filter
220  *****************************************************************************/
221 static void CloseScaler( vlc_object_t *p_this )
222 {
223     filter_t *p_filter = (filter_t*)p_this;
224     filter_sys_t *p_sys = p_filter->p_sys;
225
226     Clean( p_filter );
227     if( p_sys->p_src_filter )
228         sws_freeFilter( p_sys->p_src_filter );
229     free( p_sys );
230 }
231
232 /*****************************************************************************
233  * Helpers
234  *****************************************************************************/
235 static int GetSwsCpuMask(void)
236 {
237     const unsigned int i_cpu = vlc_CPU();
238     int i_sws_cpu = 0;
239
240     if( i_cpu & CPU_CAPABILITY_MMX )
241         i_sws_cpu |= SWS_CPU_CAPS_MMX;
242 #if (LIBSWSCALE_VERSION_INT >= ((0<<16)+(5<<8)+0))
243     if( i_cpu & CPU_CAPABILITY_MMXEXT )
244         i_sws_cpu |= SWS_CPU_CAPS_MMX2;
245 #endif
246     if( i_cpu & CPU_CAPABILITY_3DNOW )
247         i_sws_cpu |= SWS_CPU_CAPS_3DNOW;
248
249     if( i_cpu & CPU_CAPABILITY_ALTIVEC )
250         i_sws_cpu |= SWS_CPU_CAPS_ALTIVEC;
251
252     return i_sws_cpu;
253 }
254 static bool IsFmtSimilar( const video_format_t *p_fmt1, const video_format_t *p_fmt2 )
255 {
256     return p_fmt1->i_chroma == p_fmt2->i_chroma &&
257            p_fmt1->i_width  == p_fmt2->i_width &&
258            p_fmt1->i_height == p_fmt2->i_height;
259 }
260
261 static int GetParameters( ScalerConfiguration *p_cfg,
262                           const video_format_t *p_fmti,
263                           const video_format_t *p_fmto,
264                           int i_sws_flags_default )
265 {
266     int i_fmti = -1;
267     int i_fmto = -1;
268
269     bool b_has_ai = false;
270     bool b_has_ao = false;
271     int i_sws_flags = i_sws_flags_default;
272
273     GetFfmpegChroma( &i_fmti, *p_fmti );
274     GetFfmpegChroma( &i_fmto, *p_fmto );
275
276     if( p_fmti->i_chroma == p_fmto->i_chroma )
277     {
278         if( p_fmti->i_chroma == VLC_FOURCC( 'Y', 'U', 'V', 'P' ) && ALLOW_YUVP )
279         {
280             i_fmti = i_fmto = PIX_FMT_GRAY8;
281             i_sws_flags = SWS_POINT;
282         }
283     }
284
285     if( p_fmti->i_chroma == VLC_FOURCC( 'Y', 'U', 'V', 'A' ) )
286     {
287         i_fmti = PIX_FMT_YUV444P;
288         b_has_ai = true;
289     }
290     else if( p_fmti->i_chroma == VLC_FOURCC( 'R', 'G', 'B', 'A' ) )
291     {
292         i_fmti = PIX_FMT_BGR32;
293         b_has_ai = true;
294     }
295
296     if( p_fmto->i_chroma == VLC_FOURCC( 'Y', 'U', 'V', 'A' ) )
297     {
298         i_fmto = PIX_FMT_YUV444P;
299         b_has_ao = true;
300     }
301     else if( p_fmto->i_chroma == VLC_FOURCC( 'R', 'G', 'B', 'A' ) )
302     {
303         i_fmto = PIX_FMT_BGR32;
304         b_has_ao = true;
305     }
306
307     if( p_cfg )
308     {
309         p_cfg->i_fmti = i_fmti;
310         p_cfg->i_fmto = i_fmto;
311         p_cfg->b_has_a = b_has_ai && b_has_ao;
312         p_cfg->b_add_a = (!b_has_ai) && b_has_ao;
313         p_cfg->b_copy = i_fmti == i_fmto && p_fmti->i_width == p_fmto->i_width && p_fmti->i_height == p_fmto->i_height;
314         p_cfg->i_sws_flags = i_sws_flags;
315     }
316
317     if( i_fmti < 0 || i_fmto < 0 )
318         return VLC_EGENERIC;
319
320     return VLC_SUCCESS;
321 }
322
323 static int Init( filter_t *p_filter )
324 {
325     filter_sys_t *p_sys = p_filter->p_sys;
326     const video_format_t *p_fmti = &p_filter->fmt_in.video;
327     const video_format_t *p_fmto = &p_filter->fmt_out.video;
328
329     if( IsFmtSimilar( p_fmti, &p_sys->fmt_in ) &&
330         IsFmtSimilar( p_fmto, &p_sys->fmt_out ) &&
331         p_sys->ctx )
332     {
333         return VLC_SUCCESS;
334     }
335     Clean( p_filter );
336
337     /* Init with new parameters */
338     ScalerConfiguration cfg;
339     if( GetParameters( &cfg, p_fmti, p_fmto, p_sys->i_sws_flags ) )
340     {
341         msg_Err( p_filter, "format not supported" );
342         return VLC_EGENERIC;
343     }
344     if( p_fmti->i_width <= 0 || p_fmto->i_width <= 0 )
345     {
346         msg_Err( p_filter, "0 width not supported" );
347         return VLC_EGENERIC;
348     }
349
350     /* swscale does not like too small width */
351     p_sys->i_extend_factor = 1;
352     while( __MIN( p_fmti->i_width, p_fmto->i_width ) * p_sys->i_extend_factor < MINIMUM_WIDTH)
353         p_sys->i_extend_factor++;
354
355     const unsigned i_fmti_width = p_fmti->i_width * p_sys->i_extend_factor;
356     const unsigned i_fmto_width = p_fmto->i_width * p_sys->i_extend_factor;
357     for( int n = 0; n < (cfg.b_has_a ? 2 : 1); n++ )
358     {
359         const int i_fmti = n == 0 ? cfg.i_fmti : PIX_FMT_GRAY8;
360         const int i_fmto = n == 0 ? cfg.i_fmto : PIX_FMT_GRAY8;
361         struct SwsContext *ctx;
362
363         ctx = sws_getContext( i_fmti_width, p_fmti->i_height, i_fmti,
364                               i_fmto_width, p_fmto->i_height, i_fmto,
365                               cfg.i_sws_flags | p_sys->i_cpu_mask,
366                               p_sys->p_src_filter, p_sys->p_dst_filter, 0 );
367         if( n == 0 )
368             p_sys->ctx = ctx;
369         else
370             p_sys->ctxA = ctx;
371     }
372     if( p_sys->ctxA )
373     {
374         p_sys->p_src_a = picture_New( VLC_FOURCC( 'G', 'R', 'E', 'Y' ), i_fmti_width, p_fmti->i_height, 0 );
375         p_sys->p_dst_a = picture_New( VLC_FOURCC( 'G', 'R', 'E', 'Y' ), i_fmto_width, p_fmto->i_height, 0 );
376     }
377     if( p_sys->i_extend_factor != 1 )
378     {
379         p_sys->p_src_e = picture_New( p_fmti->i_chroma, i_fmti_width, p_fmti->i_height, 0 );
380         p_sys->p_dst_e = picture_New( p_fmto->i_chroma, i_fmto_width, p_fmto->i_height, 0 );
381
382         memset( p_sys->p_src_e->p[0].p_pixels, 0, p_sys->p_src_e->p[0].i_pitch * p_sys->p_src_e->p[0].i_lines );
383         memset( p_sys->p_dst_e->p[0].p_pixels, 0, p_sys->p_dst_e->p[0].i_pitch * p_sys->p_dst_e->p[0].i_lines );
384     }
385
386     if( !p_sys->ctx ||
387         ( cfg.b_has_a && ( !p_sys->ctxA || !p_sys->p_src_a || !p_sys->p_dst_a ) ) ||
388         ( p_sys->i_extend_factor != 1 && ( !p_sys->p_src_e || !p_sys->p_dst_e ) ) )
389     {
390         msg_Err( p_filter, "could not init SwScaler and/or allocate memory" );
391         Clean( p_filter );
392         return VLC_EGENERIC;
393     }
394
395     p_sys->b_add_a = cfg.b_add_a;
396     p_sys->b_copy = cfg.b_copy;
397     p_sys->fmt_in  = *p_fmti;
398     p_sys->fmt_out = *p_fmto;
399
400 #if 0
401     msg_Dbg( p_filter, "%ix%i chroma: %4.4s -> %ix%i chroma: %4.4s extend by %d",
402              p_fmti->i_width, p_fmti->i_height, (char *)&p_fmti->i_chroma,
403              p_fmto->i_width, p_fmto->i_height, (char *)&p_fmto->i_chroma,
404              p_sys->i_extend_factor );
405 #endif
406     return VLC_SUCCESS;
407 }
408 static void Clean( filter_t *p_filter )
409 {
410     filter_sys_t *p_sys = p_filter->p_sys;
411
412     if( p_sys->p_src_e )
413         picture_Release( p_sys->p_src_e );
414     if( p_sys->p_dst_e )
415         picture_Release( p_sys->p_dst_e );
416
417     if( p_sys->p_src_a )
418         picture_Release( p_sys->p_src_a );
419     if( p_sys->p_dst_a )
420         picture_Release( p_sys->p_dst_a );
421
422     if( p_sys->ctxA )
423         sws_freeContext( p_sys->ctxA );
424
425     if( p_sys->ctx )
426         sws_freeContext( p_sys->ctx );
427
428     /* We have to set it to null has we call be called again :( */
429     p_sys->ctx = NULL;
430     p_sys->ctxA = NULL;
431     p_sys->p_src_a = NULL;
432     p_sys->p_dst_a = NULL;
433     p_sys->p_src_e = NULL;
434     p_sys->p_dst_e = NULL;
435 }
436
437 static void GetPixels( uint8_t *pp_pixel[3], int pi_pitch[3],
438                        const picture_t *p_picture,
439                        int i_plane_start, int i_plane_count )
440 {
441     int n;
442     for( n = 0; n < __MIN(i_plane_count, p_picture->i_planes-i_plane_start ); n++ )
443     {
444         pp_pixel[n] = p_picture->p[i_plane_start+n].p_pixels;
445         pi_pitch[n] = p_picture->p[i_plane_start+n].i_pitch;
446     }
447     for( ; n < 3; n++ )
448     {
449         pp_pixel[n] = NULL;
450         pi_pitch[n] = 0;
451     }
452 }
453
454 static void ExtractA( picture_t *p_dst, const picture_t *p_src, unsigned i_width, unsigned i_height )
455 {
456     plane_t *d = &p_dst->p[0];
457     const plane_t *s = &p_src->p[0];
458
459     for( unsigned y = 0; y < i_height; y++ )
460         for( unsigned x = 0; x < i_width; x++ )
461             d->p_pixels[y*d->i_pitch+x] = s->p_pixels[y*s->i_pitch+4*x+OFFSET_A];
462 }
463 static void InjectA( picture_t *p_dst, const picture_t *p_src, unsigned i_width, unsigned i_height )
464 {
465     plane_t *d = &p_dst->p[0];
466     const plane_t *s = &p_src->p[0];
467
468     for( unsigned y = 0; y < i_height; y++ )
469         for( unsigned x = 0; x < i_width; x++ )
470             d->p_pixels[y*d->i_pitch+4*x+OFFSET_A] = s->p_pixels[y*s->i_pitch+x];
471 }
472 static void FillA( plane_t *d, int i_offset )
473 {
474     for( int y = 0; y < d->i_visible_lines; y++ )
475         for( int x = 0; x < d->i_visible_pitch; x += d->i_pixel_pitch )
476             d->p_pixels[y*d->i_pitch+x+i_offset] = 0xff;
477 }
478
479 static void CopyPad( picture_t *p_dst, const picture_t *p_src )
480 {
481     picture_Copy( p_dst, p_src );
482     for( int n = 0; n < p_dst->i_planes; n++ )
483     {
484         const plane_t *s = &p_src->p[n];
485         plane_t *d = &p_dst->p[n];
486
487         for( int y = 0; y < s->i_lines; y++ )
488         {
489             for( int x = s->i_visible_pitch; x < d->i_visible_pitch; x += s->i_pixel_pitch )
490                 memcpy( &d->p_pixels[y*d->i_pitch + x], &d->p_pixels[y*d->i_pitch + s->i_visible_pitch - s->i_pixel_pitch], s->i_pixel_pitch );
491         }
492     }
493 }
494
495 static void Convert( filter_t *p_filter, struct SwsContext *ctx,
496                      picture_t *p_dst, picture_t *p_src, int i_height, int i_plane_start, int i_plane_count )
497 {
498     uint8_t palette[AVPALETTE_SIZE];
499
500     uint8_t *src[3]; int src_stride[3];
501     uint8_t *dst[3]; int dst_stride[3];
502
503     GetPixels( src, src_stride, p_src, i_plane_start, i_plane_count );
504     if( p_filter->fmt_in.video.i_chroma == VLC_FOURCC( 'R', 'G', 'B', 'P' ) )
505     {
506         memset( palette, 0, sizeof(palette) );
507         if( p_filter->fmt_in.video.p_palette )
508             memcpy( palette, p_filter->fmt_in.video.p_palette->palette,
509                     __MIN( sizeof(video_palette_t), AVPALETTE_SIZE ) );
510         src[1] = palette;
511         src_stride[1] = 4;
512     }
513
514     GetPixels( dst, dst_stride, p_dst, i_plane_start, i_plane_count );
515
516 #if LIBSWSCALE_VERSION_INT  >= ((0<<16)+(5<<8)+0)
517     sws_scale( ctx, src, src_stride, 0, i_height,
518                dst, dst_stride );
519 #else
520     sws_scale_ordered( ctx, src, src_stride, 0, i_height,
521                        dst, dst_stride );
522 #endif
523 }
524
525 /****************************************************************************
526  * Filter: the whole thing
527  ****************************************************************************
528  * This function is called just after the thread is launched.
529  ****************************************************************************/
530 static picture_t *Filter( filter_t *p_filter, picture_t *p_pic )
531 {
532     filter_sys_t *p_sys = p_filter->p_sys;
533     const video_format_t *p_fmti = &p_filter->fmt_in.video;
534     const video_format_t *p_fmto = &p_filter->fmt_out.video;
535     picture_t *p_pic_dst;
536
537     /* Check if format properties changed */
538     if( Init( p_filter ) )
539     {
540         picture_Release( p_pic );
541         return NULL;
542     }
543
544     /* Request output picture */
545     p_pic_dst = filter_NewPicture( p_filter );
546     if( !p_pic_dst )
547     {
548         picture_Release( p_pic );
549         return NULL;
550     }
551
552     /* */
553     picture_t *p_src = p_pic;
554     picture_t *p_dst = p_pic_dst;
555     if( p_sys->i_extend_factor != 1 )
556     {
557         p_src = p_sys->p_src_e;
558         p_dst = p_sys->p_dst_e;
559
560         CopyPad( p_src, p_pic );
561     }
562
563     if( p_sys->b_copy )
564         picture_CopyPixels( p_dst, p_src );
565     else
566         Convert( p_filter, p_sys->ctx, p_dst, p_src, p_fmti->i_height, 0, 3 );
567     if( p_sys->ctxA )
568     {
569         /* We extract the A plane to rescale it, and then we reinject it. */
570         if( p_fmti->i_chroma == VLC_FOURCC( 'R', 'G', 'B', 'A' ) )
571             ExtractA( p_sys->p_src_a, p_src, p_fmti->i_width * p_sys->i_extend_factor, p_fmti->i_height );
572         else
573             plane_CopyPixels( p_sys->p_src_a->p, p_src->p+A_PLANE );
574
575         Convert( p_filter, p_sys->ctxA, p_sys->p_dst_a, p_sys->p_src_a, p_fmti->i_height, 0, 1 );
576         if( p_fmto->i_chroma == VLC_FOURCC( 'R', 'G', 'B', 'A' ) )
577             InjectA( p_dst, p_sys->p_dst_a, p_fmto->i_width * p_sys->i_extend_factor, p_fmto->i_height );
578         else
579             plane_CopyPixels( p_dst->p+A_PLANE, p_sys->p_dst_a->p );
580     }
581     else if( p_sys->b_add_a )
582     {
583         /* We inject a complete opaque alpha plane */
584         if( p_fmto->i_chroma == VLC_FOURCC( 'R', 'G', 'B', 'A' ) )
585             FillA( &p_dst->p[0], OFFSET_A );
586         else
587             FillA( &p_dst->p[A_PLANE], 0 );
588     }
589
590     if( p_sys->i_extend_factor != 1 )
591     {
592         picture_CopyPixels( p_pic_dst, p_dst );
593     }
594
595     picture_CopyProperties( p_pic_dst, p_pic );
596     picture_Release( p_pic );
597     return p_pic_dst;
598 }
599
600 #else /* LIBSWSCALE_VERSION_INT >= ((0<<16)+(5<<8)+0) */
601
602 int OpenScaler( vlc_object_t *p_this )
603 {
604     return VLC_EGENERIC;
605 }
606
607 void CloseScaler( vlc_object_t *p_this )
608 {
609 }
610
611 #endif /* LIBSWSCALE_VERSION_INT >= ((0<<16)+(5<<8)+0) */