git.sesse.net Git - vlc/blob - 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
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation; either version 2 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 General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program; if not, write to the Free Software
  21  * Foundation, 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         ::merge(&dst[offset_r], spx.i, a);
 301         ::merge(&dst[offset_g], spx.j, a);
 302         ::merge(&dst[offset_b], spx.k, a);
 303     }
 304     void nextLine()
 305     {
 306         y++;
 307         data += picture->p[0].i_pitch;
 308     }
 309 private:
 310     uint8_t *getPointer(unsigned dx) const
 311     {
 312         return &data[(x + dx) * bytes];
 313     }
 314     unsigned offset_r;
 315     unsigned offset_g;
 316     unsigned offset_b;
 317     unsigned offset_a;
 318     uint8_t *data;
 319 };
 320
 321 class CPictureRGB16 : public CPicture {
 322 public:
 323     CPictureRGB16(const CPicture &cfg) : CPicture(cfg)
 324     {
 325         data = CPicture::getLine<1>(0);
 326     }
 327     void get(CPixel *px, unsigned dx, bool = true) const
 328     {
 329         const uint16_t data = *getPointer(dx);
 330         px->i = (data & fmt->i_rmask) >> fmt->i_lrshift;
 331         px->j = (data & fmt->i_gmask) >> fmt->i_lgshift;
 332         px->k = (data & fmt->i_bmask) >> fmt->i_lbshift;
 333     }
 334     void merge(unsigned dx, const CPixel &spx, unsigned a, bool full)
 335     {
 336         CPixel dpx;
 337         get(&dpx, dx, full);
 338
 339         ::merge(&dpx.i, spx.i, a);
 340         ::merge(&dpx.j, spx.j, a);
 341         ::merge(&dpx.k, spx.k, a);
 342
 343         *getPointer(dx) = (dpx.i << fmt->i_lrshift) |
 344                           (dpx.j << fmt->i_lgshift) |
 345                           (dpx.k << fmt->i_lbshift);
 346     }
 347     void nextLine()
 348     {
 349         y++;
 350         data += picture->p[0].i_pitch;
 351     }
 352 private:
 353     uint16_t *getPointer(unsigned dx) const
 354     {
 355         return (uint16_t*)&data[(x + dx) * 2];
 356     }
 357     uint8_t *data;
 358 };
 359
 360 typedef CPictureYUVPlanar<uint8_t,  1,1, true,  false> CPictureYUVA;
 361
 362 typedef CPictureYUVPlanar<uint8_t,  4,4, false, true>  CPictureYV9;
 363 typedef CPictureYUVPlanar<uint8_t,  4,4, false, false> CPictureI410_8;
 364
 365 typedef CPictureYUVPlanar<uint8_t,  4,1, false, false> CPictureI411_8;
 366
 367 typedef CPictureYUVSemiPlanar<false>                   CPictureNV12;
 368 typedef CPictureYUVSemiPlanar<true>                    CPictureNV21;
 369
 370 typedef CPictureYUVPlanar<uint8_t,  2,2, false, true>  CPictureYV12;
 371 typedef CPictureYUVPlanar<uint8_t,  2,2, false, false> CPictureI420_8;
 372 typedef CPictureYUVPlanar<uint16_t, 2,2, false, false> CPictureI420_16;
 373
 374 typedef CPictureYUVPlanar<uint8_t,  2,1, false, false> CPictureI422_8;
 375 typedef CPictureYUVPlanar<uint16_t, 2,1, false, false> CPictureI422_16;
 376
 377 typedef CPictureYUVPlanar<uint8_t,  1,1, false, false> CPictureI444_8;
 378 typedef CPictureYUVPlanar<uint16_t, 1,1, false, false> CPictureI444_16;
 379
 380 typedef CPictureYUVPacked<0, 1, 3> CPictureYUYV;
 381 typedef CPictureYUVPacked<1, 0, 2> CPictureUYVY;
 382 typedef CPictureYUVPacked<0, 3, 1> CPictureYVYU;
 383 typedef CPictureYUVPacked<1, 2, 0> CPictureVYUY;
 384
 385 typedef CPictureRGBX<4, true>  CPictureRGBA;
 386 typedef CPictureRGBX<4, false> CPictureRGB32;
 387 typedef CPictureRGBX<3, false> CPictureRGB24;
 388
 389 struct convertNone {
 390     convertNone(const video_format_t *, const video_format_t *) {}
 391     void operator()(CPixel &)
 392     {
 393     }
 394 };
 395
 396 template <unsigned dst, unsigned src>
 397 struct convertBits {
 398     convertBits(const video_format_t *, const video_format_t *) {}
 399     void operator()(CPixel &p)
 400     {
 401         p.i = p.i * ((1 << dst) - 1) /  ((1 << src) - 1);
 402         p.j = p.j * ((1 << dst) - 1) /  ((1 << src) - 1);
 403         p.k = p.k * ((1 << dst) - 1) /  ((1 << src) - 1);
 404     }
 405 };
 406 typedef convertBits< 9, 8> convert8To9Bits;
 407 typedef convertBits<10, 8> convert8To10Bits;
 408
 409 struct convertRgbToYuv8 {
 410     convertRgbToYuv8(const video_format_t *, const video_format_t *) {}
 411     void operator()(CPixel &p)
 412     {
 413         uint8_t y, u, v;
 414         rgb_to_yuv(&y, &u, &v, p.i, p.j, p.k);
 415         p.i = y;
 416         p.j = u;
 417         p.k = v;
 418     }
 419 };
 420
 421 struct convertYuv8ToRgb {
 422     convertYuv8ToRgb(const video_format_t *, const video_format_t *) {}
 423     void operator()(CPixel &p)
 424     {
 425         int r, g, b;
 426         yuv_to_rgb(&r, &g, &b, p.i, p.j, p.k);
 427         p.i = r;
 428         p.j = g;
 429         p.k = b;
 430     }
 431 };
 432
 433 struct convertRgbToRgbSmall {
 434     convertRgbToRgbSmall(const video_format_t *dst, const video_format_t *) : fmt(*dst) {}
 435     void operator()(CPixel &p)
 436     {
 437         p.i >>= fmt.i_rrshift;
 438         p.j >>= fmt.i_rgshift;
 439         p.k >>= fmt.i_rbshift;
 440     }
 441 private:
 442     const video_format_t &fmt;
 443 };
 444
 445 struct convertYuvpToAny {
 446     void operator()(CPixel &p)
 447     {
 448         unsigned index = p.i;
 449         p.i = palette.palette[index][0];
 450         p.j = palette.palette[index][1];
 451         p.k = palette.palette[index][2];
 452         p.a = palette.palette[index][3];
 453     }
 454 protected:
 455     video_palette_t palette;
 456 };
 457 struct convertYuvpToYuva8 : public convertYuvpToAny {
 458     convertYuvpToYuva8(const video_format_t *, const video_format_t *src)
 459     {
 460         palette = *src->p_palette;
 461     }
 462 };
 463 struct convertYuvpToRgba : public convertYuvpToAny {
 464     convertYuvpToRgba(const video_format_t *, const video_format_t *src)
 465     {
 466         const video_palette_t *p = src->p_palette;
 467         for (int i = 0; i < p->i_entries; i++) {
 468             int r, g, b;
 469             yuv_to_rgb(&r, &g, &b,
 470                        p->palette[i][0],
 471                        p->palette[i][1],
 472                        p->palette[i][2]);
 473             palette.palette[i][0] = r;
 474             palette.palette[i][1] = g;
 475             palette.palette[i][2] = b;
 476             palette.palette[i][3] = p->palette[i][3];
 477         }
 478     }
 479 };
 480
 481 template <class G, class F>
 482 struct compose {
 483     compose(const video_format_t *dst, const video_format_t *src) : f(dst, src), g(dst, src) {}
 484     void operator()(CPixel &p)
 485     {
 486         f(p);
 487         g(p);
 488     }
 489 private:
 490     F f;
 491     G g;
 492 };
 493
 494 template <class TDst, class TSrc, class TConvert>
 495 void Blend(const CPicture &dst_data, const CPicture &src_data,
 496            unsigned width, unsigned height, int alpha)
 497 {
 498     TSrc src(src_data);
 499     TDst dst(dst_data);
 500     TConvert convert(dst_data.getFormat(), src_data.getFormat());
 501
 502     for (unsigned y = 0; y < height; y++) {
 503         for (unsigned x = 0; x < width; x++) {
 504             CPixel spx;
 505
 506             src.get(&spx, x);
 507             convert(spx);
 508
 509             unsigned a = div255(alpha * spx.a);
 510             if (a <= 0)
 511                 continue;
 512
 513             if (dst.isFull(x))
 514                 dst.merge(x, spx, a, true);
 515             else
 516                 dst.merge(x, spx, a, false);
 517         }
 518         src.nextLine();
 519         dst.nextLine();
 520     }
 521 }
 522
 523 typedef void (*blend_function_t)(const CPicture &dst_data, const CPicture &src_data,
 524                                  unsigned width, unsigned height, int alpha);
 525
 526 static const struct {
 527     vlc_fourcc_t     dst;
 528     vlc_fourcc_t     src;
 529     blend_function_t blend;
 530 } blends[] = {
 531 #undef RGB
 532 #undef YUV
 533 #define RGB(csp, picture, cvt) \
 534     { csp, VLC_CODEC_YUVA, Blend<picture, CPictureYUVA, compose<cvt, convertYuv8ToRgb> > }, \
 535     { csp, VLC_CODEC_RGBA, Blend<picture, CPictureRGBA, compose<cvt, convertNone> > }, \
 536     { csp, VLC_CODEC_YUVP, Blend<picture, CPictureYUVP, compose<cvt, convertYuvpToRgba> > }
 537 #define YUV(csp, picture, cvt) \
 538     { csp, VLC_CODEC_YUVA, Blend<picture, CPictureYUVA, compose<cvt, convertNone> > }, \
 539     { csp, VLC_CODEC_RGBA, Blend<picture, CPictureRGBA, compose<cvt, convertRgbToYuv8> > }, \
 540     { csp, VLC_CODEC_YUVP, Blend<picture, CPictureYUVP, compose<cvt, convertYuvpToYuva8> > }
 541
 542     RGB(VLC_CODEC_RGB15,    CPictureRGB16,    convertRgbToRgbSmall),
 543     RGB(VLC_CODEC_RGB16,    CPictureRGB16,    convertRgbToRgbSmall),
 544     RGB(VLC_CODEC_RGB24,    CPictureRGB24,    convertNone),
 545     RGB(VLC_CODEC_RGB32,    CPictureRGB32,    convertNone),
 546
 547     YUV(VLC_CODEC_YV9,      CPictureYV9,      convertNone),
 548     YUV(VLC_CODEC_I410,     CPictureI410_8,   convertNone),
 549
 550     YUV(VLC_CODEC_I411,     CPictureI411_8,   convertNone),
 551
 552     YUV(VLC_CODEC_YV12,     CPictureYV12,     convertNone),
 553     YUV(VLC_CODEC_NV12,     CPictureNV12,     convertNone),
 554     YUV(VLC_CODEC_NV21,     CPictureNV21,     convertNone),
 555     YUV(VLC_CODEC_J420,     CPictureI420_8,   convertNone),
 556     YUV(VLC_CODEC_I420,     CPictureI420_8,   convertNone),
 557 #ifdef WORDS_BIGENDIAN
 558     YUV(VLC_CODEC_I420_9B,  CPictureI420_16,  convert8To9Bits),
 559     YUV(VLC_CODEC_I420_10B, CPictureI420_16,  convert8To10Bits),
 560 #else
 561     YUV(VLC_CODEC_I420_9L,  CPictureI420_16,  convert8To9Bits),
 562     YUV(VLC_CODEC_I420_10L, CPictureI420_16,  convert8To10Bits),
 563 #endif
 564
 565     YUV(VLC_CODEC_J422,     CPictureI422_8,   convertNone),
 566     YUV(VLC_CODEC_I422,     CPictureI422_8,   convertNone),
 567 #ifdef WORDS_BIGENDIAN
 568     YUV(VLC_CODEC_I422_9B,  CPictureI422_16,  convert8To9Bits),
 569     YUV(VLC_CODEC_I422_10B, CPictureI422_16,  convert8To10Bits),
 570 #else
 571     YUV(VLC_CODEC_I422_9L,  CPictureI422_16,  convert8To9Bits),
 572     YUV(VLC_CODEC_I422_10L, CPictureI422_16,  convert8To10Bits),
 573 #endif
 574
 575     YUV(VLC_CODEC_J444,     CPictureI444_8,   convertNone),
 576     YUV(VLC_CODEC_I444,     CPictureI444_8,   convertNone),
 577 #ifdef WORDS_BIGENDIAN
 578     YUV(VLC_CODEC_I444_9B,  CPictureI444_16,  convert8To9Bits),
 579     YUV(VLC_CODEC_I444_10B, CPictureI444_16,  convert8To10Bits),
 580 #else
 581     YUV(VLC_CODEC_I444_9L,  CPictureI444_16,  convert8To9Bits),
 582     YUV(VLC_CODEC_I444_10L, CPictureI444_16,  convert8To10Bits),
 583 #endif
 584
 585     YUV(VLC_CODEC_YUYV,     CPictureYUYV,     convertNone),
 586     YUV(VLC_CODEC_UYVY,     CPictureUYVY,     convertNone),
 587     YUV(VLC_CODEC_YVYU,     CPictureYVYU,     convertNone),
 588     YUV(VLC_CODEC_VYUY,     CPictureVYUY,     convertNone),
 589
 590 #undef RGB
 591 #undef YUV
 592 };
 593
 594 struct filter_sys_t {
 595     filter_sys_t() : blend(NULL)
 596     {
 597     }
 598     blend_function_t blend;
 599 };
 600
 601 /**
 602  * It blends 2 picture together.
 603  */
 604 static void Blend(filter_t *filter,
 605                   picture_t *dst, const picture_t *src,
 606                   int x_offset, int y_offset, int alpha)
 607 {
 608     filter_sys_t *sys = filter->p_sys;
 609
 610     if( x_offset < 0 || y_offset < 0 )
 611     {
 612         msg_Err( filter, "Blend cannot process negative offsets" );
 613         return;
 614     }
 615
 616     int width  = __MIN((int)filter->fmt_out.video.i_visible_width - x_offset,
 617                        (int)filter->fmt_in.video.i_visible_width);
 618     int height = __MIN((int)filter->fmt_out.video.i_visible_height - y_offset,
 619                        (int)filter->fmt_in.video.i_visible_height);
 620     if (width <= 0 || height <= 0 || alpha <= 0)
 621         return;
 622
 623     video_format_FixRgb(&filter->fmt_out.video);
 624     video_format_FixRgb(&filter->fmt_in.video);
 625
 626     sys->blend(CPicture(dst, &filter->fmt_out.video,
 627                         filter->fmt_out.video.i_x_offset + x_offset,
 628                         filter->fmt_out.video.i_y_offset + y_offset),
 629                CPicture(src, &filter->fmt_in.video,
 630                         filter->fmt_in.video.i_x_offset,
 631                         filter->fmt_in.video.i_y_offset),
 632                width, height, alpha);
 633 }
 634
 635 static int Open(vlc_object_t *object)
 636 {
 637     filter_t *filter = (filter_t *)object;
 638     const vlc_fourcc_t src = filter->fmt_in.video.i_chroma;
 639     const vlc_fourcc_t dst = filter->fmt_out.video.i_chroma;
 640
 641     filter_sys_t *sys = new filter_sys_t();
 642     for (size_t i = 0; i < sizeof(blends) / sizeof(*blends); i++) {
 643         if (blends[i].src == src && blends[i].dst == dst)
 644             sys->blend = blends[i].blend;
 645     }
 646
 647     if (!sys->blend) {
 648        msg_Err(filter, "no matching alpha blending routine (chroma: %4.4s -> %4.4s)",
 649                (char *)&src, (char *)&dst);
 650         delete sys;
 651         return VLC_EGENERIC;
 652     }
 653
 654     filter->pf_video_blend = Blend;
 655     filter->p_sys          = sys;
 656     return VLC_SUCCESS;
 657 }
 658
 659 static void Close(vlc_object_t *object)
 660 {
 661     filter_t *filter = (filter_t *)object;
 662     delete filter->p_sys;
 663 }
 664