cinelerra-5.1/cinelerra/overlayframe.h

   1
   2 /*
   3  * CINELERRA
   4  * Copyright (C) 2008 Adam Williams <broadcast at earthling dot net>
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  *
  20  */
  21
  22 #ifndef OVERLAYFRAME_H
  23 #define OVERLAYFRAME_H
  24
  25 #include "loadbalance.h"
  26 #include "overlayframe.inc"
  27 #include "vframe.h"
  28
  29 #include <math.h>
  30 #include <stdio.h>
  31 #include <string.h>
  32 #include <stdint.h>
  33 #include <stdlib.h>
  34 #include <unistd.h>
  35
  36 #define DIRECT_COPY 0
  37 #define BILINEAR 1
  38 #define BICUBIC 2
  39 #define LANCZOS 3
  40
  41 #define STD_ALPHA(mx, Sa, Da) (Sa + Da - (Sa * Da) / mx)
  42 #define STD_BLEND(mx, Sc, Sa, Dc, Da) ((Sc * (mx - Da) + Dc * (mx - Sa)) / mx)
  43
  44 #define ZERO 0
  45 #define ONE 1
  46 #define TWO 2
  47
  48 // NORMAL       [Sa + Da * (1 - Sa), Sc * Sa + Dc * (1 - Sa)])
  49 #define ALPHA_NORMAL(mx, Sa, Da) (Sa + (Da * (mx - Sa)) / mx)
  50 #define COLOR_NORMAL(mx, Sc, Sa, Dc, Da) ((Sc * Sa + Dc * (mx - Sa)) / mx)
  51 #define CHROMA_NORMAL COLOR_NORMAL
  52
  53 // ADDITION     [(Sa + Da), (Sc + Dc)]
  54 #define ALPHA_ADDITION(mx, Sa, Da) (Sa + Da)
  55 #define COLOR_ADDITION(mx, Sc, Sa, Dc, Da) (Sc + Dc)
  56 #define CHROMA_ADDITION COLOR_ADDITION
  57
  58 // SUBTRACT     [(Sa - Da), (Sc - Dc)]
  59 #define ALPHA_SUBTRACT(mx, Sa, Da) (Sa - Da)
  60 #define COLOR_SUBTRACT(mx, Sc, Sa, Dc, Da) (Sc - Dc)
  61 #define CHROMA_SUBTRACT COLOR_SUBTRACT
  62
  63 // MULTIPLY     [Sa + Da - Sa*Da, Sc*(1 - Da) + Dc*(1 - Sa) +  Sc * Dc]
  64 #define ALPHA_MULTIPLY STD_ALPHA
  65 #define COLOR_MULTIPLY(mx, Sc, Sa, Dc, Da) (STD_BLEND(mx,Sc,Sa,Dc,Da) + \
  66   (Sc * Dc) / mx)
  67 #define CHROMA_MULTIPLY COLOR_MULTIPLY
  68
  69 // DIVIDE       [Sa + Da - Sa*Da, Sc*(1 - Da) + Dc*(1 - Sa) +  Sc / Dc]
  70 #define ALPHA_DIVIDE STD_ALPHA
  71 #define COLOR_DIVIDE(mx, Sc, Sa, Dc, Da) (STD_BLEND(mx,Sc,Sa,Dc,Da) + \
  72   (Dc > ZERO ? (Sc * mx) / Dc : ZERO))
  73 #define CHROMA_DIVIDE COLOR_DIVIDE
  74
  75 // REPLACE      [Sa, Sc] (fade = 1)
  76 #define ALPHA_REPLACE(mx, Sa, Da) Sa
  77 #define COLOR_REPLACE(mx, Sc, Sa, Dc, Da) Sc
  78 #define CHROMA_REPLACE COLOR_REPLACE
  79
  80 // MAX          [max(Sa, Da), MAX(Sc, Dc)]
  81 #define ALPHA_MAX(mx, Sa, Da) (Sa > Da ? Sa : Da)
  82 #define COLOR_MAX(mx, Sc, Sa, Dc, Da) (Sc > Dc ? Sc : Dc)
  83 #define CHROMA_MAX(mx, Sc, Sa, Dc, Da) (mabs(Sc) > mabs(Dc) ? Sc : Dc)
  84
  85 // MIN          [min(Sa, Da), MIN(Sc, Dc)]
  86 #define ALPHA_MIN(mx, Sa, Da) (Sa < Da ? Sa : Da)
  87 #define COLOR_MIN(mx, Sc, Sa, Dc, Da) (Sc < Dc ? Sc : Dc)
  88 #define CHROMA_MIN(mx, Sc, Sa, Dc, Da) (mabs(Sc) < mabs(Dc) ? Sc : Dc)
  89
  90 // DARKEN       [Sa + Da - Sa*Da, Sc*(1 - Da) + Dc*(1 - Sa) +  min(Sc*Da, Dc*Sa)]
  91 #define ALPHA_DARKEN STD_ALPHA
  92 #define COLOR_DARKEN(mx, Sc, Sa, Dc, Da) (STD_BLEND(mx,Sc,Sa,Dc,Da) + \
  93   mmin(Sc * Da, Dc * Sa) / mx)
  94 #define CHROMA_DARKEN(mx, Sc, Sa, Dc, Da) (CHROMA_XOR(mx,Sc,Sa,Dc,Da) + \
  95   (mabs(Sc * Da) < mabs(Dc * Sa) ? Sc * Da : Dc * Sa) / mx)
  96
  97 // LIGHTEN      [Sa + Da - Sa*Da, Sc*(1 - Da) + Dc*(1 - Sa) +  max(Sc*Da, Dc*Sa)]
  98 #define ALPHA_LIGHTEN STD_ALPHA
  99 #define COLOR_LIGHTEN(mx, Sc, Sa, Dc, Da) (STD_BLEND(mx,Sc,Sa,Dc,Da) + \
 100   mmax(Sc * Da, Dc * Sa) / mx)
 101 #define CHROMA_LIGHTEN(mx, Sc, Sa, Dc, Da) (CHROMA_XOR(mx,Sc,Sa,Dc,Da) + \
 102   (mabs(Sc * Da) > mabs(Dc * Sa) ? Sc * Da : Dc * Sa) / mx)
 103
 104 // DST          [Da, Dc]
 105 #define ALPHA_DST(mx, Sa, Da) Da
 106 #define COLOR_DST(mx, Sc, Sa, Dc, Da) Dc
 107 #define CHROMA_DST COLOR_DST
 108
 109 // DST_ATOP     [Sa, Sc * (1 - Da) + Dc * Sa]
 110 #define ALPHA_DST_ATOP(mx, Sa, Da) Sa
 111 #define COLOR_DST_ATOP(mx, Sc, Sa, Dc, Da) ((Sc * (mx - Da) + Dc * Sa) / mx)
 112 #define CHROMA_DST_ATOP COLOR_DST_ATOP
 113
 114 // DST_IN       [Da * Sa, Dc * Sa]
 115 #define ALPHA_DST_IN(mx, Sa, Da) ((Da * Sa) / mx)
 116 #define COLOR_DST_IN(mx, Sc, Sa, Dc, Da) ((Dc * Sa) / mx)
 117 #define CHROMA_DST_IN COLOR_DST_IN
 118
 119 // DST_OUT      [Da * (1 - Sa), Dc * (1 - Sa)]
 120 #define ALPHA_DST_OUT(mx, Sa, Da) (Da * (mx - Sa) / mx)
 121 #define COLOR_DST_OUT(mx, Sc, Sa, Dc, Da) (Dc * (mx - Sa) / mx)
 122 #define CHROMA_DST_OUT COLOR_DST_OUT
 123
 124 // DST_OVER     [Sa + Da - Sa*Da, Sc * (1 - Da) + Dc]
 125 #define ALPHA_DST_OVER STD_ALPHA
 126 #define COLOR_DST_OVER(mx, Sc, Sa, Dc, Da) (Sc * (mx - Da)/ mx + Dc)
 127 #define CHROMA_DST_OVER COLOR_DST_OVER
 128
 129 // SRC                  [Sa, Sc]
 130 #define ALPHA_SRC(mx, Sa, Da) Sa
 131 #define COLOR_SRC(mx, Sc, Sa, Dc, Da) Sc
 132 #define CHROMA_SRC COLOR_SRC
 133
 134 // SRC_ATOP     [Da, Sc * Da + Dc * (1 - Sa)]
 135 #define ALPHA_SRC_ATOP(mx, Sa, Da) Da
 136 #define COLOR_SRC_ATOP(mx, Sc, Sa, Dc, Da) ((Sc * Da + Dc * (mx - Sa)) / mx)
 137 #define CHROMA_SRC_ATOP COLOR_SRC_ATOP
 138
 139 // SRC_IN       [Sa * Da, Sc * Da]
 140 #define ALPHA_SRC_IN(mx, Sa, Da) ((Sa * Da) / mx)
 141 #define COLOR_SRC_IN(mx, Sc, Sa, Dc, Da) (Sc * Da / mx)
 142 #define CHROMA_SRC_IN COLOR_SRC_IN
 143
 144 // SRC_OUT      [Sa * (1 - Da), Sc * (1 - Da)]
 145 #define ALPHA_SRC_OUT(mx, Sa, Da) (Sa * (mx - Da) / mx)
 146 #define COLOR_SRC_OUT(mx, Sc, Sa, Dc, Da) (Sc * (mx - Da) / mx)
 147 #define CHROMA_SRC_OUT COLOR_SRC_OUT
 148
 149 // SRC_OVER     [Sa + Da - Sa*Da, Sc + (1 - Sa) * Dc]
 150 #define ALPHA_SRC_OVER STD_ALPHA
 151 #define COLOR_SRC_OVER(mx, Sc, Sa, Dc, Da) (Sc + Dc * (mx - Sa) / mx)
 152 #define CHROMA_SRC_OVER COLOR_SRC_OVER
 153
 154 // AND  [Sa * Da, Sc * Dc]
 155 #define ALPHA_AND(mx, Sa, Da) ((Sa * Da) / mx)
 156 #define COLOR_AND(mx, Sc, Sa, Dc, Da) ((Sc * Dc) / mx)
 157 #define CHROMA_AND COLOR_AND
 158
 159 // OR   [Sa + Da - Sa * Da, Sc + Dc - Sc * Dc]
 160 #define ALPHA_OR(mx, Sa, Da) (Sa + Da - (Sa * Da) / mx)
 161 #define COLOR_OR(mx, Sc, Sa, Dc, Da) (Sc + Dc - (Sc * Dc) / mx)
 162 #define CHROMA_OR COLOR_OR
 163
 164 // XOR  [Sa + Da - 2 * Sa * Da, Sc * (1 - Da) + Dc * (1 - Sa)]
 165 #define ALPHA_XOR(mx, Sa, Da) (Sa + Da - (TWO * Sa * Da / mx))
 166 #define COLOR_XOR(mx, Sc, Sa, Dc, Da) ((Sc * (mx - Da) + Dc * (mx - Sa)) / mx)
 167 #define CHROMA_XOR COLOR_XOR
 168
 169 //SVG 1.2
 170 //https://www.w3.org/TR/2004/WD-SVG12-20041027/rendering.html
 171 // OVERLAY [Sa + Da - Sa * Da,  Sc*(1 - Da) + Dc*(1 - Sa) +
 172 //   2*Dc < Da ? 2*Sc*Dc : Sa*Da - 2*(Da-Dc)*(Sa-Sc) ]
 173 #define ALPHA_OVERLAY STD_ALPHA
 174 #define COLOR_OVERLAY(mx, Sc, Sa, Dc, Da) (STD_BLEND(mx,Sc,Sa,Dc,Da) + \
 175   ((TWO * Dc < Da) ? \
 176     (TWO * Sc * Dc) : (Sa * Da - TWO * (Da - Dc) * (Sa - Sc))) / mx)
 177 #define CHROMA_OVERLAY COLOR_OVERLAY
 178
 179 // SCREEN [Sa + Da - Sa * Da, Sc + Dc - (Sc * Dc)] (same as OR)
 180 #define ALPHA_SCREEN STD_ALPHA
 181 #define COLOR_SCREEN(mx, Sc, Sa, Dc, Da) (Sc + Dc - (Sc * Dc) / mx)
 182 #define CHROMA_SCREEN COLOR_SCREEN
 183
 184 // BURN [Sa + Da - Sa * Da,  Sc*(1 - Da) + Dc*(1 - Sa) +
 185 //  Sc <= 0 || Sc*Da + Dc*Sa <= Sa*Da ? 0 : (Sc*Da + Dc*Sa - Sa*Da)*Sa/Sc]
 186 #define ALPHA_BURN STD_ALPHA
 187 #define COLOR_BURN(mx, Sc, Sa, Dc, Da) (STD_BLEND(mx,Sc,Sa,Dc,Da) + \
 188   ((Sc <= ZERO || Sc * Da + Dc * Sa <= Sa * Da) ? ZERO : \
 189     (Sa * ((Sc * Da + Dc * Sa - Sa * Da) / Sc) / mx)))
 190 #define CHROMA_BURN COLOR_BURN
 191
 192 // DODGE [Sa + Da - Sa * Da,  Sc*(1 - Da) + Dc*(1 - Sa) +
 193 //  Sa <= Sc || Sc*Da + Dc*Sa >= Sa*Da) ? Sa*Da : Dc*Sa / (1 - Sc/Sa)]
 194 #define ALPHA_DODGE STD_ALPHA
 195 #define COLOR_DODGE(mx, Sc, Sa, Dc, Da) (STD_BLEND(mx,Sc,Sa,Dc,Da) + \
 196   ((Sa <= Sc || Sc * Da + Dc * Sa >= Sa * Da) ? (Sa * Da) : \
 197     (Sa * ((Dc * Sa) / (Sa - Sc))) / mx))
 198 #define CHROMA_DODGE COLOR_DODGE
 199
 200 // HARDLIGHT [Sa + Da - Sa * Da, Sc*(1 - Da) + Dc*(1 - Sa) +
 201 //  2*Sc < Sa ? 2*Sc*Dc : Sa*Da - 2*(Da - Dc)*(Sa - Sc)]
 202 #define ALPHA_HARDLIGHT STD_ALPHA
 203 #define COLOR_HARDLIGHT(mx, Sc, Sa, Dc, Da) (STD_BLEND(mx,Sc,Sa,Dc,Da) + \
 204   ((TWO * Sc < Sa) ? \
 205     (TWO * Sc * Dc) : (Sa * Da - TWO * (Da - Dc) * (Sa - Sc))) / mx)
 206 #define CHROMA_HARDLIGHT COLOR_HARDLIGHT
 207
 208 // SOFTLIGHT [Sa + Da - Sa * Da,  Sc*(1 - Da) + Dc*(1 - Sa) +
 209 //  Da > 0 ? (Dc*Sa + 2*Sc*(Da - Dc))/Da : 0]
 210 #define ALPHA_SOFTLIGHT STD_ALPHA
 211 #define COLOR_SOFTLIGHT(mx, Sc, Sa, Dc, Da) (STD_BLEND(mx,Sc,Sa,Dc,Da) + \
 212   ((Da > ZERO) ? \
 213     (Dc * ((Dc*Sa + TWO * Sc * (Da - Dc)) / Da) / mx) : ZERO))
 214 #define CHROMA_SOFTLIGHT COLOR_SOFTLIGHT
 215
 216 // DIFFERENCE [Sa + Da - Sa * Da,  Sc*(1 - Da) + Dc*(1 - Sa) +
 217 //  abs(Sc * Da - Dc * Sa)]
 218 #define ALPHA_DIFFERENCE STD_ALPHA
 219 #define COLOR_DIFFERENCE(mx, Sc, Sa, Dc, Da) (STD_BLEND(mx,Sc,Sa,Dc,Da) + \
 220   (mabs(Sc * Da - Dc * Sa) / mx))
 221 #define CHROMA_DIFFERENCE COLOR_DIFFERENCE
 222
 223 static inline int   mabs(int32_t v) { return abs(v); }
 224 static inline int   mabs(int64_t v) { return llabs(v); }
 225 static inline float mabs(float v)   { return fabsf(v); }
 226 static inline int   mmin(int32_t a, int32_t b) { return a < b ? a : b; }
 227 static inline int   mmin(int64_t a, int64_t b) { return a < b ? a : b; }
 228 static inline float mmin(float a, float b)   { return a < b ? a : b; }
 229 static inline int   mmax(int32_t a, int32_t b) { return a > b ? a : b; }
 230 static inline int   mmax(int64_t a, int64_t b) { return a > b ? a : b; }
 231 static inline float mmax(float a, float b)   { return a > b ? a : b; }
 232
 233 static inline int32_t aclip(int32_t v, int mx) {
 234         return v < 0 ? 0 : v > mx ? mx : v;
 235 }
 236 static inline int64_t aclip(int64_t v, int mx) {
 237         return v < 0 ? 0 : v > mx ? mx : v;
 238 }
 239 static inline float   aclip(float v, float mx) {
 240         return v < 0 ? 0 : v > mx ? mx : v;
 241 }
 242 static inline float   aclip(float v, int mx) {
 243         return v < 0 ? 0 : v > mx ? mx : v;
 244 }
 245 static inline int   aclip(int v, float mx) {
 246         return v < 0 ? 0 : v > mx ? mx : v;
 247 }
 248 static inline int32_t cclip(int32_t v, int mx) {
 249         return v > (mx/=2) ? mx : v < (mx=(-mx-1)) ? mx : v;
 250 }
 251 static inline int64_t cclip(int64_t v, int mx) {
 252         return v > (mx/=2) ? mx : v < (mx=(-mx-1)) ? mx : v;
 253 }
 254 static inline float   cclip(float v, float mx) {
 255         return v > (mx/=2) ? mx : v < (mx=(-mx)) ? mx : v;
 256 }
 257 static inline float   cclip(float v, int mx) {
 258         return v > (mx/=2) ? mx : v < (mx=(-mx-1)) ? mx : v;
 259 }
 260 static inline int   cclip(int v, float mx) {
 261         return v > (mx/=2) ? mx : v < (mx=(-mx-1)) ? mx : v;
 262 }
 263
 264 /* number of data pts per unit x in lookup table */
 265 #define TRANSFORM_SPP    (4096)
 266 /* bits of fraction past TRANSFORM_SPP on kernel index accumulation */
 267 #define INDEX_FRACTION   (8)
 268 #define TRANSFORM_MIN    (.5 / TRANSFORM_SPP)
 269
 270 #define ZTYP(ty) typedef ty z_##ty __attribute__ ((__unused__))
 271 ZTYP(int8_t);   ZTYP(uint8_t);
 272 ZTYP(int16_t);  ZTYP(uint16_t);
 273 ZTYP(int32_t);  ZTYP(uint32_t);
 274 ZTYP(int64_t);  ZTYP(uint64_t);
 275 ZTYP(float);    ZTYP(double);
 276
 277 #define ALPHA3_BLEND(FN, typ, inp, out, mx, iofs, oofs, rnd) \
 278   typ inp0 = (typ)inp[0], inp1 = (typ)inp[1] - iofs; \
 279   typ inp2 = (typ)inp[2] - iofs, inp3 = mx; \
 280   typ out0 = (typ)out[0], out1 = (typ)out[1] - oofs; \
 281   typ out2 = (typ)out[2] - oofs, out3 = mx; \
 282   r = COLOR_##FN(mx, inp0, inp3, out0, out3); \
 283   if( oofs ) { \
 284     g = CHROMA_##FN(mx, inp1, inp3, out1, out3); \
 285     b = CHROMA_##FN(mx, inp2, inp3, out2, out3); \
 286   } \
 287   else { \
 288     g = COLOR_##FN(mx, inp1, inp3, out1, out3); \
 289     b = COLOR_##FN(mx, inp2, inp3, out2, out3); \
 290   }
 291
 292 #define ALPHA4_BLEND(FN, typ, inp, out, mx, iofs, oofs, rnd) \
 293   typ inp0 = (typ)inp[0], inp1 = (typ)inp[1] - iofs; \
 294   typ inp2 = (typ)inp[2] - iofs, inp3 = inp[3]; \
 295   typ out0 = (typ)out[0], out1 = (typ)out[1] - oofs; \
 296   typ out2 = (typ)out[2] - oofs, out3 = out[3]; \
 297   r = COLOR_##FN(mx, inp0, inp3, out0, out3); \
 298   if( oofs ) { \
 299     g = CHROMA_##FN(mx, inp1, inp3, out1, out3); \
 300     b = CHROMA_##FN(mx, inp2, inp3, out2, out3); \
 301   } \
 302   else { \
 303     g = COLOR_##FN(mx, inp1, inp3, out1, out3); \
 304     b = COLOR_##FN(mx, inp2, inp3, out2, out3); \
 305   } \
 306   a = ALPHA_##FN(mx, inp3, out3)
 307
 308 #define ALPHA_STORE(out, ofs, mx) \
 309   out[0] = r; \
 310   out[1] = g + ofs; \
 311   out[2] = b + ofs
 312
 313 #define ALPHA3_STORE(out, ofs, mx) \
 314   r = aclip(r, mx); \
 315   g = ofs ? cclip(g, mx) : aclip(g, mx); \
 316   b = ofs ? cclip(b, mx) : aclip(b, mx); \
 317   if( trnsp ) { \
 318     r = (r * opcty + out0 * trnsp) / mx; \
 319     g = (g * opcty + out1 * trnsp) / mx; \
 320     b = (b * opcty + out2 * trnsp) / mx; \
 321   } \
 322   ALPHA_STORE(out, ofs, mx)
 323
 324 #define ALPHA4_STORE(out, ofs, mx) \
 325   r = aclip(r, mx); \
 326   g = ofs ? cclip(g, mx) : aclip(g, mx); \
 327   b = ofs ? cclip(b, mx) : aclip(b, mx); \
 328   if( trnsp ) { \
 329     r = (r * opcty + out0 * trnsp) / mx; \
 330     g = (g * opcty + out1 * trnsp) / mx; \
 331     b = (b * opcty + out2 * trnsp) / mx; \
 332     a = (a * opcty + out3 * trnsp) / mx; \
 333   } \
 334   ALPHA_STORE(out, ofs, mx); \
 335   out[3] = aclip(a, mx)
 336
 337 #define BLEND_SWITCH(FN) \
 338         switch( mode ) { \
 339         case TRANSFER_NORMAL:           FN(NORMAL); \
 340         case TRANSFER_ADDITION:         FN(ADDITION); \
 341         case TRANSFER_SUBTRACT:         FN(SUBTRACT); \
 342         case TRANSFER_MULTIPLY:         FN(MULTIPLY); \
 343         case TRANSFER_DIVIDE:           FN(DIVIDE); \
 344         case TRANSFER_REPLACE:          FN(REPLACE); \
 345         case TRANSFER_MAX:              FN(MAX); \
 346         case TRANSFER_MIN:              FN(MIN); \
 347         case TRANSFER_DARKEN:           FN(DARKEN); \
 348         case TRANSFER_LIGHTEN:          FN(LIGHTEN); \
 349         case TRANSFER_DST:              FN(DST); \
 350         case TRANSFER_DST_ATOP:         FN(DST_ATOP); \
 351         case TRANSFER_DST_IN:           FN(DST_IN); \
 352         case TRANSFER_DST_OUT:          FN(DST_OUT); \
 353         case TRANSFER_DST_OVER:         FN(DST_OVER); \
 354         case TRANSFER_SRC:              FN(SRC); \
 355         case TRANSFER_SRC_ATOP:         FN(SRC_ATOP); \
 356         case TRANSFER_SRC_IN:           FN(SRC_IN); \
 357         case TRANSFER_SRC_OUT:          FN(SRC_OUT); \
 358         case TRANSFER_SRC_OVER:         FN(SRC_OVER); \
 359         case TRANSFER_AND:              FN(AND); \
 360         case TRANSFER_OR:               FN(OR); \
 361         case TRANSFER_XOR:              FN(XOR); \
 362         case TRANSFER_OVERLAY:          FN(OVERLAY); \
 363         case TRANSFER_SCREEN:           FN(SCREEN); \
 364         case TRANSFER_BURN:             FN(BURN); \
 365         case TRANSFER_DODGE:            FN(DODGE); \
 366         case TRANSFER_HARDLIGHT:        FN(HARDLIGHT); \
 367         case TRANSFER_SOFTLIGHT:        FN(SOFTLIGHT); \
 368         case TRANSFER_DIFFERENCE:       FN(DIFFERENCE); \
 369         }
 370
 371 class OverlayKernel
 372 {
 373 public:
 374         OverlayKernel(int interpolation_type);
 375         ~OverlayKernel();
 376
 377         float *lookup;
 378         float width;
 379         int n;
 380         int type;
 381 };
 382
 383 class DirectEngine;
 384
 385 class DirectPackage : public LoadPackage
 386 {
 387 public:
 388         DirectPackage();
 389
 390         int out_row1, out_row2;
 391 };
 392
 393 class NNEngine;
 394
 395 class NNPackage : public LoadPackage
 396 {
 397 public:
 398         NNPackage();
 399
 400         int out_row1, out_row2;
 401 };
 402
 403 class SampleEngine;
 404
 405 class SamplePackage : public LoadPackage
 406 {
 407 public:
 408         SamplePackage();
 409
 410         int out_col1, out_col2;
 411 };
 412
 413
 414 class DirectUnit : public LoadClient
 415 {
 416 public:
 417         DirectUnit(DirectEngine *server);
 418         ~DirectUnit();
 419
 420         void process_package(LoadPackage *package);
 421         DirectEngine *engine;
 422
 423         DirectPackage *pkg;
 424         int ix, iy, ox, ow;
 425         VFrame *output, *input;
 426         int mode;
 427         float fade;
 428
 429         void rgb_float();
 430         void rgba_float();
 431         void rgb888();
 432         void yuv888();
 433         void rgba8888();
 434         void yuva8888();
 435         void rgb161616();
 436         void yuv161616();
 437         void rgba16161616();
 438         void yuva16161616();
 439 };
 440
 441 class NNUnit : public LoadClient
 442 {
 443 public:
 444         NNUnit(NNEngine *server);
 445         ~NNUnit();
 446
 447         void process_package(LoadPackage *package);
 448         NNEngine *engine;
 449
 450         NNPackage *pkg;
 451         int ix, iy, ox, ow;
 452         VFrame *output, *input;
 453         int mode;
 454         float fade;
 455         int *ly;
 456
 457         void rgb_float();
 458         void rgba_float();
 459         void rgb888();
 460         void yuv888();
 461         void rgba8888();
 462         void yuva8888();
 463         void rgb161616();
 464         void yuv161616();
 465         void rgba16161616();
 466         void yuva16161616();
 467 };
 468
 469 class SampleUnit : public LoadClient
 470 {
 471 public:
 472         SampleUnit(SampleEngine *server);
 473         ~SampleUnit();
 474
 475         void process_package(LoadPackage *package);
 476         SampleEngine *engine;
 477
 478         SamplePackage *pkg;
 479         VFrame *voutput, *vinput;
 480         int mode;
 481         float fade;
 482
 483         int i1i, i2i, o1i, o2i, oh, kd;
 484         float i1f, i2f, o1f, o2f, *k;
 485         int *lookup_sx0, *lookup_sx1, *lookup_sk;
 486         float *lookup_wacc;
 487
 488         void rgb_float();
 489         void rgba_float();
 490         void rgb888();
 491         void yuv888();
 492         void rgba8888();
 493         void yuva8888();
 494         void rgb161616();
 495         void yuv161616();
 496         void rgba16161616();
 497         void yuva16161616();
 498 };
 499
 500
 501 class DirectEngine : public LoadServer
 502 {
 503 public:
 504         DirectEngine(int cpus);
 505         ~DirectEngine();
 506
 507         void init_packages();
 508         LoadClient* new_client();
 509         LoadPackage* new_package();
 510
 511         VFrame *output;
 512         VFrame *input;
 513         int in_x1;
 514         int in_y1;
 515         int out_x1;
 516         int out_x2;
 517         int out_y1;
 518         int out_y2;
 519         float alpha;
 520         int mode;
 521 };
 522
 523 class NNEngine : public LoadServer
 524 {
 525 public:
 526         NNEngine(int cpus);
 527         ~NNEngine();
 528
 529         void init_packages();
 530         LoadClient* new_client();
 531         LoadPackage* new_package();
 532
 533         VFrame *output;
 534         VFrame *input;
 535         float in_x1;
 536         float in_x2;
 537         float in_y1;
 538         float in_y2;
 539         float out_x1;
 540         float out_x2;
 541         int out_x1i;
 542         int out_x2i;
 543         float out_y1;
 544         float out_y2;
 545         float alpha;
 546         int mode;
 547
 548         int *in_lookup_x;
 549         int *in_lookup_y;
 550 };
 551
 552 class SampleEngine : public LoadServer
 553 {
 554 public:
 555         SampleEngine(int cpus);
 556         ~SampleEngine();
 557
 558         void init_packages();
 559         LoadClient* new_client();
 560         LoadPackage* new_package();
 561
 562         VFrame *output;
 563         VFrame *input;
 564         OverlayKernel *kernel;
 565
 566         int col_out1;
 567         int col_out2;
 568         int row_in;
 569
 570         float in1;
 571         float in2;
 572         float out1;
 573         float out2;
 574
 575         float alpha;
 576         int mode;
 577
 578         int *lookup_sx0;
 579         int *lookup_sx1;
 580         int *lookup_sk;
 581         float *lookup_wacc;
 582         int kd;
 583 };
 584
 585 class OverlayFrame
 586 {
 587 public:
 588         OverlayFrame(int cpus = 1);
 589         virtual ~OverlayFrame();
 590
 591         int overlay(VFrame *output,
 592                 VFrame *input,
 593                 float in_x1,
 594                 float in_y1,
 595                 float in_x2,
 596                 float in_y2,
 597                 float out_x1,
 598                 float out_y1,
 599                 float out_x2,
 600                 float out_y2,
 601                 float alpha,
 602                 int mode,
 603                 int interpolation_type);
 604
 605         DirectEngine *direct_engine;
 606         NNEngine *nn_engine;
 607         SampleEngine *sample_engine;
 608
 609         VFrame *temp_frame;
 610         int cpus;
 611         OverlayKernel *kernel[4];
 612 };
 613
 614 #endif