cpu: move Doxygen to header file
[vlc.git] / modules / video_filter / blend.cpp
1 /*****************************************************************************
2  * blend2.cpp: Blend one picture with alpha onto another picture
3  *****************************************************************************
4  * Copyright (C) 2012 Laurent Aimar
5  * $Id$
6  *
7  * Authors: Laurent Aimar <fenrir _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 #ifdef HAVE_CONFIG_H
28 # include "config.h"
29 #endif
30
31 #include <assert.h>
32 #include <vlc_common.h>
33 #include <vlc_plugin.h>
34 #include <vlc_filter.h>
35 #include "filter_picture.h"
36
37 /*****************************************************************************
38  * Module descriptor
39  *****************************************************************************/
40 static int  Open (vlc_object_t *);
41 static void Close(vlc_object_t *);
42
43 vlc_module_begin()
44     set_description(N_("Video pictures blending"))
45     set_capability("video blending", 100)
46     set_callbacks(Open, Close)
47 vlc_module_end()
48
49 static inline unsigned div255(unsigned v)
50 {
51     /* It is exact for 8 bits, and has a max error of 1 for 9 and 10 bits
52      * while respecting full opacity/transparency */
53     return ((v >> 8) + v + 1) >> 8;
54     //return v / 255;
55 }
56
57 template <typename T>
58 void merge(T *dst, unsigned src, unsigned f)
59 {
60     *dst = div255((255 - f) * (*dst) + src * f);
61 }
62
63 struct CPixel {
64     unsigned i, j, k;
65     unsigned a;
66 };
67
68 class CPicture {
69 public:
70     CPicture(const picture_t *picture,
71              const video_format_t *fmt,
72              unsigned x, unsigned y) : picture(picture), fmt(fmt), x(x), y(y)
73     {
74     }
75     CPicture(const CPicture &src) : picture(src.picture), fmt(src.fmt), x(src.x), y(src.y)
76     {
77     }
78     const video_format_t *getFormat() const
79     {
80         return fmt;
81     }
82     bool isFull(unsigned) const
83     {
84         return true;
85     }
86
87 protected:
88     template <unsigned ry>
89     uint8_t *getLine(unsigned plane = 0) const
90     {
91         return &picture->p[plane].p_pixels[(y / ry) * picture->p[plane].i_pitch];
92     }
93     const picture_t *picture;
94     const video_format_t *fmt;
95     unsigned x;
96     unsigned y;
97 };
98
99 template <typename pixel, unsigned rx, unsigned ry, bool has_alpha, bool swap_uv>
100 class CPictureYUVPlanar : public CPicture {
101 public:
102     CPictureYUVPlanar(const CPicture &cfg) : CPicture(cfg)
103     {
104         data[0] = CPicture::getLine< 1>(0);
105         data[1] = CPicture::getLine<ry>(swap_uv ? 2 : 1);
106         data[2] = CPicture::getLine<ry>(swap_uv ? 1 : 2);
107         if (has_alpha)
108             data[3] = CPicture::getLine<1>(3);
109     }
110     void get(CPixel *px, unsigned dx, bool full = true) const
111     {
112         px->i = *getPointer(0, dx);
113         if (full) {
114             px->j = *getPointer(1, dx);
115             px->k = *getPointer(2, dx);
116         }
117         if (has_alpha)
118             px->a = *getPointer(3, dx);
119     }
120     void merge(unsigned dx, const CPixel &spx, unsigned a, bool full)
121     {
122         ::merge(getPointer(0, dx), spx.i, a);
123         if (full) {
124             ::merge(getPointer(1, dx), spx.j, a);
125             ::merge(getPointer(2, dx), spx.k, a);
126         }
127     }
128     bool isFull(unsigned dx) const
129     {
130         return (y % ry) == 0 && ((x + dx) % rx) == 0;
131     }
132     void nextLine()
133     {
134         y++;
135         data[0] += picture->p[0].i_pitch;
136         if ((y % ry) == 0) {
137             data[1] += picture->p[swap_uv ? 2 : 1].i_pitch;
138             data[2] += picture->p[swap_uv ? 1 : 2].i_pitch;
139         }
140         if (has_alpha)
141             data[3] += picture->p[3].i_pitch;
142     }
143 private:
144     pixel *getPointer(unsigned plane, unsigned dx) const
145     {
146         if (plane == 1 || plane == 2)
147             return (pixel*)&data[plane][(x + dx) / rx * sizeof(pixel)];
148         else
149             return (pixel*)&data[plane][(x + dx) /  1 * sizeof(pixel)];
150     }
151     uint8_t *data[4];
152 };
153
154 template <bool swap_uv>
155 class CPictureYUVSemiPlanar : public CPicture {
156 public:
157     CPictureYUVSemiPlanar(const CPicture &cfg) : CPicture(cfg)
158     {
159         data[0] = CPicture::getLine<1>(0);
160         data[1] = CPicture::getLine<2>(1);
161     }
162     void get(CPixel *px, unsigned dx, bool full = true) const
163     {
164         px->i = *getPointer(0, dx);
165         if (full) {
166             px->j = getPointer(1, dx)[swap_uv];
167             px->k = getPointer(1, dx)[!swap_uv];
168         }
169     }
170     void merge(unsigned dx, const CPixel &spx, unsigned a, bool full)
171     {
172         ::merge(getPointer(0, dx), spx.i, a);
173         if (full) {
174             ::merge(&getPointer(1, dx)[ swap_uv], spx.j, a);
175             ::merge(&getPointer(1, dx)[!swap_uv], spx.k, a);
176         }
177     }
178     bool isFull(unsigned dx) const
179     {
180         return (y % 2) == 0 && ((x + dx) % 2) == 0;
181     }
182     void nextLine()
183     {
184         y++;
185         data[0] += picture->p[0].i_pitch;
186         if ((y % 2) == 0)
187             data[1] += picture->p[1].i_pitch;
188     }
189 private:
190     uint8_t *getPointer(unsigned plane, unsigned dx) const
191     {
192         if (plane == 0)
193             return &data[plane][x + dx];
194         else
195             return &data[plane][(x + dx) / 2 * 2];
196     }
197     uint8_t *data[2];
198 };
199
200 template <unsigned offset_y, unsigned offset_u, unsigned offset_v>
201 class CPictureYUVPacked : public CPicture {
202 public:
203     CPictureYUVPacked(const CPicture &cfg) : CPicture(cfg)
204     {
205         data = CPicture::getLine<1>(0);
206     }
207     void get(CPixel *px, unsigned dx, bool full = true) const
208     {
209         uint8_t *data = getPointer(dx);
210         px->i = data[offset_y];
211         if (full) {
212             px->j = data[offset_u];
213             px->k = data[offset_v];
214         }
215     }
216     void merge(unsigned dx, const CPixel &spx, unsigned a, bool full)
217     {
218         uint8_t *data = getPointer(dx);
219         ::merge(&data[offset_y], spx.i, a);
220         if (full) {
221             ::merge(&data[offset_u], spx.j, a);
222             ::merge(&data[offset_v], spx.k, a);
223         }
224     }
225     bool isFull(unsigned dx) const
226     {
227         return ((x + dx) % 2) == 0;
228     }
229     void nextLine()
230     {
231         y++;
232         data += picture->p[0].i_pitch;
233     }
234 private:
235     uint8_t *getPointer(unsigned dx) const
236     {
237         return &data[(x + dx) * 2];
238     }
239     uint8_t *data;
240 };
241
242 class CPictureYUVP : public CPicture {
243 public:
244     CPictureYUVP(const CPicture &cfg) : CPicture(cfg)
245     {
246         data = CPicture::getLine<1>(0);
247     }
248     void get(CPixel *px, unsigned dx, bool = true) const
249     {
250         px->i = *getPointer(dx);
251     }
252     void nextLine()
253     {
254         y++;
255         data += picture->p[0].i_pitch;
256     }
257 private:
258     uint8_t *getPointer(unsigned dx) const
259     {
260         return &data[x + dx];
261     }
262     uint8_t *data;
263 };
264
265 template <unsigned bytes, bool has_alpha>
266 class CPictureRGBX : public CPicture {
267 public:
268     CPictureRGBX(const CPicture &cfg) : CPicture(cfg)
269     {
270         if (has_alpha) {
271             offset_r = 0;
272             offset_g = 1;
273             offset_b = 2;
274             offset_a = 3;
275         } else {
276 #ifdef WORDS_BIGENDIAN
277             offset_r = (8 * bytes - fmt->i_lrshift) / 8;
278             offset_g = (8 * bytes - fmt->i_lgshift) / 8;
279             offset_b = (8 * bytes - fmt->i_lbshift) / 8;
280 #else
281             offset_r = fmt->i_lrshift / 8;
282             offset_g = fmt->i_lgshift / 8;
283             offset_b = fmt->i_lbshift / 8;
284 #endif
285         }
286         data = CPicture::getLine<1>(0);
287     }
288     void get(CPixel *px, unsigned dx, bool = true) const
289     {
290         const uint8_t *src = getPointer(dx);
291         px->i = src[offset_r];
292         px->j = src[offset_g];
293         px->k = src[offset_b];
294         if (has_alpha)
295             px->a = src[offset_a];
296     }
297     void merge(unsigned dx, const CPixel &spx, unsigned a, bool)
298     {
299         uint8_t *dst = getPointer(dx);
300         if (has_alpha) {
301             // Handle different cases of existing alpha in the
302             // destination buffer. If the existing alpha is 0,
303             // the RGB components should be copied as is and
304             // alpha set to 'a'. If the existing alpha is 255,
305             // this should behave just as the non-alpha case below.
306
307             // First blend the existing color based on its
308             // alpha with the incoming color.
309             ::merge(&dst[offset_r], spx.i, 255 - dst[offset_a]);
310             ::merge(&dst[offset_g], spx.j, 255 - dst[offset_a]);
311             ::merge(&dst[offset_b], spx.k, 255 - dst[offset_a]);
312             // Now blend in the new color on top with the normal formulas.
313             ::merge(&dst[offset_r], spx.i, a);
314             ::merge(&dst[offset_g], spx.j, a);
315             ::merge(&dst[offset_b], spx.k, a);
316             // Finally set dst_a = (255 * src_a + prev_a * (255 - src_a))/255.
317             ::merge(&dst[offset_a], 255, a);
318         } else {
319             ::merge(&dst[offset_r], spx.i, a);
320             ::merge(&dst[offset_g], spx.j, a);
321             ::merge(&dst[offset_b], spx.k, a);
322         }
323     }
324     void nextLine()
325     {
326         y++;
327         data += picture->p[0].i_pitch;
328     }
329 private:
330     uint8_t *getPointer(unsigned dx) const
331     {
332         return &data[(x + dx) * bytes];
333     }
334     unsigned offset_r;
335     unsigned offset_g;
336     unsigned offset_b;
337     unsigned offset_a;
338     uint8_t *data;
339 };
340
341 class CPictureRGB16 : public CPicture {
342 public:
343     CPictureRGB16(const CPicture &cfg) : CPicture(cfg)
344     {
345         data = CPicture::getLine<1>(0);
346     }
347     void get(CPixel *px, unsigned dx, bool = true) const
348     {
349         const uint16_t data = *getPointer(dx);
350         px->i = (data & fmt->i_rmask) >> fmt->i_lrshift;
351         px->j = (data & fmt->i_gmask) >> fmt->i_lgshift;
352         px->k = (data & fmt->i_bmask) >> fmt->i_lbshift;
353     }
354     void merge(unsigned dx, const CPixel &spx, unsigned a, bool full)
355     {
356         CPixel dpx;
357         get(&dpx, dx, full);
358
359         ::merge(&dpx.i, spx.i, a);
360         ::merge(&dpx.j, spx.j, a);
361         ::merge(&dpx.k, spx.k, a);
362
363         *getPointer(dx) = (dpx.i << fmt->i_lrshift) |
364                           (dpx.j << fmt->i_lgshift) |
365                           (dpx.k << fmt->i_lbshift);
366     }
367     void nextLine()
368     {
369         y++;
370         data += picture->p[0].i_pitch;
371     }
372 private:
373     uint16_t *getPointer(unsigned dx) const
374     {
375         return (uint16_t*)&data[(x + dx) * 2];
376     }
377     uint8_t *data;
378 };
379
380 typedef CPictureYUVPlanar<uint8_t,  1,1, true,  false> CPictureYUVA;
381
382 typedef CPictureYUVPlanar<uint8_t,  4,4, false, true>  CPictureYV9;
383 typedef CPictureYUVPlanar<uint8_t,  4,4, false, false> CPictureI410_8;
384
385 typedef CPictureYUVPlanar<uint8_t,  4,1, false, false> CPictureI411_8;
386
387 typedef CPictureYUVSemiPlanar<false>                   CPictureNV12;
388 typedef CPictureYUVSemiPlanar<true>                    CPictureNV21;
389
390 typedef CPictureYUVPlanar<uint8_t,  2,2, false, true>  CPictureYV12;
391 typedef CPictureYUVPlanar<uint8_t,  2,2, false, false> CPictureI420_8;
392 typedef CPictureYUVPlanar<uint16_t, 2,2, false, false> CPictureI420_16;
393
394 typedef CPictureYUVPlanar<uint8_t,  2,1, false, false> CPictureI422_8;
395 typedef CPictureYUVPlanar<uint16_t, 2,1, false, false> CPictureI422_16;
396
397 typedef CPictureYUVPlanar<uint8_t,  1,1, false, false> CPictureI444_8;
398 typedef CPictureYUVPlanar<uint16_t, 1,1, false, false> CPictureI444_16;
399
400 typedef CPictureYUVPacked<0, 1, 3> CPictureYUYV;
401 typedef CPictureYUVPacked<1, 0, 2> CPictureUYVY;
402 typedef CPictureYUVPacked<0, 3, 1> CPictureYVYU;
403 typedef CPictureYUVPacked<1, 2, 0> CPictureVYUY;
404
405 typedef CPictureRGBX<4, true>  CPictureRGBA;
406 typedef CPictureRGBX<4, false> CPictureRGB32;
407 typedef CPictureRGBX<3, false> CPictureRGB24;
408
409 struct convertNone {
410     convertNone(const video_format_t *, const video_format_t *) {}
411     void operator()(CPixel &)
412     {
413     }
414 };
415
416 template <unsigned dst, unsigned src>
417 struct convertBits {
418     convertBits(const video_format_t *, const video_format_t *) {}
419     void operator()(CPixel &p)
420     {
421         p.i = p.i * ((1 << dst) - 1) /  ((1 << src) - 1);
422         p.j = p.j * ((1 << dst) - 1) /  ((1 << src) - 1);
423         p.k = p.k * ((1 << dst) - 1) /  ((1 << src) - 1);
424     }
425 };
426 typedef convertBits< 9, 8> convert8To9Bits;
427 typedef convertBits<10, 8> convert8To10Bits;
428 typedef convertBits<16, 8> convert8To16Bits;
429
430 struct convertRgbToYuv8 {
431     convertRgbToYuv8(const video_format_t *, const video_format_t *) {}
432     void operator()(CPixel &p)
433     {
434         uint8_t y, u, v;
435         rgb_to_yuv(&y, &u, &v, p.i, p.j, p.k);
436         p.i = y;
437         p.j = u;
438         p.k = v;
439     }
440 };
441
442 struct convertYuv8ToRgb {
443     convertYuv8ToRgb(const video_format_t *, const video_format_t *) {}
444     void operator()(CPixel &p)
445     {
446         int r, g, b;
447         yuv_to_rgb(&r, &g, &b, p.i, p.j, p.k);
448         p.i = r;
449         p.j = g;
450         p.k = b;
451     }
452 };
453
454 struct convertRgbToRgbSmall {
455     convertRgbToRgbSmall(const video_format_t *dst, const video_format_t *) : fmt(*dst) {}
456     void operator()(CPixel &p)
457     {
458         p.i >>= fmt.i_rrshift;
459         p.j >>= fmt.i_rgshift;
460         p.k >>= fmt.i_rbshift;
461     }
462 private:
463     const video_format_t &fmt;
464 };
465
466 struct convertYuvpToAny {
467     void operator()(CPixel &p)
468     {
469         unsigned index = p.i;
470         p.i = palette.palette[index][0];
471         p.j = palette.palette[index][1];
472         p.k = palette.palette[index][2];
473         p.a = palette.palette[index][3];
474     }
475 protected:
476     video_palette_t palette;
477 };
478 struct convertYuvpToYuva8 : public convertYuvpToAny {
479     convertYuvpToYuva8(const video_format_t *, const video_format_t *src)
480     {
481         palette = *src->p_palette;
482     }
483 };
484 struct convertYuvpToRgba : public convertYuvpToAny {
485     convertYuvpToRgba(const video_format_t *, const video_format_t *src)
486     {
487         const video_palette_t *p = src->p_palette;
488         for (int i = 0; i < p->i_entries; i++) {
489             int r, g, b;
490             yuv_to_rgb(&r, &g, &b,
491                        p->palette[i][0],
492                        p->palette[i][1],
493                        p->palette[i][2]);
494             palette.palette[i][0] = r;
495             palette.palette[i][1] = g;
496             palette.palette[i][2] = b;
497             palette.palette[i][3] = p->palette[i][3];
498         }
499     }
500 };
501
502 template <class G, class F>
503 struct compose {
504     compose(const video_format_t *dst, const video_format_t *src) : f(dst, src), g(dst, src) {}
505     void operator()(CPixel &p)
506     {
507         f(p);
508         g(p);
509     }
510 private:
511     F f;
512     G g;
513 };
514
515 template <class TDst, class TSrc, class TConvert>
516 void Blend(const CPicture &dst_data, const CPicture &src_data,
517            unsigned width, unsigned height, int alpha)
518 {
519     TSrc src(src_data);
520     TDst dst(dst_data);
521     TConvert convert(dst_data.getFormat(), src_data.getFormat());
522
523     for (unsigned y = 0; y < height; y++) {
524         for (unsigned x = 0; x < width; x++) {
525             CPixel spx;
526
527             src.get(&spx, x);
528             convert(spx);
529
530             unsigned a = div255(alpha * spx.a);
531             if (a <= 0)
532                 continue;
533
534             if (dst.isFull(x))
535                 dst.merge(x, spx, a, true);
536             else
537                 dst.merge(x, spx, a, false);
538         }
539         src.nextLine();
540         dst.nextLine();
541     }
542 }
543
544 typedef void (*blend_function_t)(const CPicture &dst_data, const CPicture &src_data,
545                                  unsigned width, unsigned height, int alpha);
546
547 static const struct {
548     vlc_fourcc_t     dst;
549     vlc_fourcc_t     src;
550     blend_function_t blend;
551 } blends[] = {
552 #undef RGB
553 #undef YUV
554 #define RGB(csp, picture, cvt) \
555     { csp, VLC_CODEC_YUVA, Blend<picture, CPictureYUVA, compose<cvt, convertYuv8ToRgb> > }, \
556     { csp, VLC_CODEC_RGBA, Blend<picture, CPictureRGBA, compose<cvt, convertNone> > }, \
557     { csp, VLC_CODEC_YUVP, Blend<picture, CPictureYUVP, compose<cvt, convertYuvpToRgba> > }
558 #define YUV(csp, picture, cvt) \
559     { csp, VLC_CODEC_YUVA, Blend<picture, CPictureYUVA, compose<cvt, convertNone> > }, \
560     { csp, VLC_CODEC_RGBA, Blend<picture, CPictureRGBA, compose<cvt, convertRgbToYuv8> > }, \
561     { csp, VLC_CODEC_YUVP, Blend<picture, CPictureYUVP, compose<cvt, convertYuvpToYuva8> > }
562
563     RGB(VLC_CODEC_RGB15,    CPictureRGB16,    convertRgbToRgbSmall),
564     RGB(VLC_CODEC_RGB16,    CPictureRGB16,    convertRgbToRgbSmall),
565     RGB(VLC_CODEC_RGB24,    CPictureRGB24,    convertNone),
566     RGB(VLC_CODEC_RGB32,    CPictureRGB32,    convertNone),
567     RGB(VLC_CODEC_RGBA,     CPictureRGBA,     convertNone),
568
569     YUV(VLC_CODEC_YV9,      CPictureYV9,      convertNone),
570     YUV(VLC_CODEC_I410,     CPictureI410_8,   convertNone),
571
572     YUV(VLC_CODEC_I411,     CPictureI411_8,   convertNone),
573
574     YUV(VLC_CODEC_YV12,     CPictureYV12,     convertNone),
575     YUV(VLC_CODEC_NV12,     CPictureNV12,     convertNone),
576     YUV(VLC_CODEC_NV21,     CPictureNV21,     convertNone),
577     YUV(VLC_CODEC_J420,     CPictureI420_8,   convertNone),
578     YUV(VLC_CODEC_I420,     CPictureI420_8,   convertNone),
579 #ifdef WORDS_BIGENDIAN
580     YUV(VLC_CODEC_I420_9B,  CPictureI420_16,  convert8To9Bits),
581     YUV(VLC_CODEC_I420_10B, CPictureI420_16,  convert8To10Bits),
582 #else
583     YUV(VLC_CODEC_I420_9L,  CPictureI420_16,  convert8To9Bits),
584     YUV(VLC_CODEC_I420_10L, CPictureI420_16,  convert8To10Bits),
585 #endif
586
587     YUV(VLC_CODEC_J422,     CPictureI422_8,   convertNone),
588     YUV(VLC_CODEC_I422,     CPictureI422_8,   convertNone),
589 #ifdef WORDS_BIGENDIAN
590     YUV(VLC_CODEC_I422_9B,  CPictureI422_16,  convert8To9Bits),
591     YUV(VLC_CODEC_I422_10B, CPictureI422_16,  convert8To10Bits),
592 #else
593     YUV(VLC_CODEC_I422_9L,  CPictureI422_16,  convert8To9Bits),
594     YUV(VLC_CODEC_I422_10L, CPictureI422_16,  convert8To10Bits),
595 #endif
596
597     YUV(VLC_CODEC_J444,     CPictureI444_8,   convertNone),
598     YUV(VLC_CODEC_I444,     CPictureI444_8,   convertNone),
599 #ifdef WORDS_BIGENDIAN
600     YUV(VLC_CODEC_I444_9B,  CPictureI444_16,  convert8To9Bits),
601     YUV(VLC_CODEC_I444_10B, CPictureI444_16,  convert8To10Bits),
602     YUV(VLC_CODEC_I444_16B, CPictureI444_16,  convert8To16Bits),
603 #else
604     YUV(VLC_CODEC_I444_9L,  CPictureI444_16,  convert8To9Bits),
605     YUV(VLC_CODEC_I444_10L, CPictureI444_16,  convert8To10Bits),
606     YUV(VLC_CODEC_I444_16L, CPictureI444_16,  convert8To16Bits),
607 #endif
608
609     YUV(VLC_CODEC_YUYV,     CPictureYUYV,     convertNone),
610     YUV(VLC_CODEC_UYVY,     CPictureUYVY,     convertNone),
611     YUV(VLC_CODEC_YVYU,     CPictureYVYU,     convertNone),
612     YUV(VLC_CODEC_VYUY,     CPictureVYUY,     convertNone),
613
614 #undef RGB
615 #undef YUV
616 };
617
618 struct filter_sys_t {
619     filter_sys_t() : blend(NULL)
620     {
621     }
622     blend_function_t blend;
623 };
624
625 /**
626  * It blends 2 picture together.
627  */
628 static void Blend(filter_t *filter,
629                   picture_t *dst, const picture_t *src,
630                   int x_offset, int y_offset, int alpha)
631 {
632     filter_sys_t *sys = filter->p_sys;
633
634     if( x_offset < 0 || y_offset < 0 )
635     {
636         msg_Err( filter, "Blend cannot process negative offsets" );
637         return;
638     }
639
640     int width  = __MIN((int)filter->fmt_out.video.i_visible_width - x_offset,
641                        (int)filter->fmt_in.video.i_visible_width);
642     int height = __MIN((int)filter->fmt_out.video.i_visible_height - y_offset,
643                        (int)filter->fmt_in.video.i_visible_height);
644     if (width <= 0 || height <= 0 || alpha <= 0)
645         return;
646
647     video_format_FixRgb(&filter->fmt_out.video);
648     video_format_FixRgb(&filter->fmt_in.video);
649
650     sys->blend(CPicture(dst, &filter->fmt_out.video,
651                         filter->fmt_out.video.i_x_offset + x_offset,
652                         filter->fmt_out.video.i_y_offset + y_offset),
653                CPicture(src, &filter->fmt_in.video,
654                         filter->fmt_in.video.i_x_offset,
655                         filter->fmt_in.video.i_y_offset),
656                width, height, alpha);
657 }
658
659 static int Open(vlc_object_t *object)
660 {
661     filter_t *filter = (filter_t *)object;
662     const vlc_fourcc_t src = filter->fmt_in.video.i_chroma;
663     const vlc_fourcc_t dst = filter->fmt_out.video.i_chroma;
664
665     filter_sys_t *sys = new filter_sys_t();
666     for (size_t i = 0; i < sizeof(blends) / sizeof(*blends); i++) {
667         if (blends[i].src == src && blends[i].dst == dst)
668             sys->blend = blends[i].blend;
669     }
670
671     if (!sys->blend) {
672        msg_Err(filter, "no matching alpha blending routine (chroma: %4.4s -> %4.4s)",
673                (char *)&src, (char *)&dst);
674         delete sys;
675         return VLC_EGENERIC;
676     }
677
678     filter->pf_video_blend = Blend;
679     filter->p_sys          = sys;
680     return VLC_SUCCESS;
681 }
682
683 static void Close(vlc_object_t *object)
684 {
685     filter_t *filter = (filter_t *)object;
686     delete filter->p_sys;
687 }
688