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
 338 #define BLEND_SWITCH(FN) \
 339         switch( mode ) { \
 340         case TRANSFER_NORMAL:           FN(NORMAL); \
 341         case TRANSFER_ADDITION:         FN(ADDITION); \
 342         case TRANSFER_SUBTRACT:         FN(SUBTRACT); \
 343         case TRANSFER_MULTIPLY:         FN(MULTIPLY); \
 344         case TRANSFER_DIVIDE:           FN(DIVIDE); \
 345         case TRANSFER_REPLACE:          FN(REPLACE); \
 346         case TRANSFER_MAX:              FN(MAX); \
 347         case TRANSFER_MIN:              FN(MIN); \
 348         case TRANSFER_DARKEN:           FN(DARKEN); \
 349         case TRANSFER_LIGHTEN:          FN(LIGHTEN); \
 350         case TRANSFER_DST:              FN(DST); \
 351         case TRANSFER_DST_ATOP:         FN(DST_ATOP); \
 352         case TRANSFER_DST_IN:           FN(DST_IN); \
 353         case TRANSFER_DST_OUT:          FN(DST_OUT); \
 354         case TRANSFER_DST_OVER:         FN(DST_OVER); \
 355         case TRANSFER_SRC:              FN(SRC); \
 356         case TRANSFER_SRC_ATOP:         FN(SRC_ATOP); \
 357         case TRANSFER_SRC_IN:           FN(SRC_IN); \
 358         case TRANSFER_SRC_OUT:          FN(SRC_OUT); \
 359         case TRANSFER_SRC_OVER:         FN(SRC_OVER); \
 360         case TRANSFER_AND:              FN(AND); \
 361         case TRANSFER_OR:               FN(OR); \
 362         case TRANSFER_XOR:              FN(XOR); \
 363         case TRANSFER_OVERLAY:          FN(OVERLAY); \
 364         case TRANSFER_SCREEN:           FN(SCREEN); \
 365         case TRANSFER_BURN:             FN(BURN); \
 366         case TRANSFER_DODGE:            FN(DODGE); \
 367         case TRANSFER_HARDLIGHT:        FN(HARDLIGHT); \
 368         case TRANSFER_SOFTLIGHT:        FN(SOFTLIGHT); \
 369         case TRANSFER_DIFFERENCE:       FN(DIFFERENCE); \
 370         }
 371
 372 class OverlayKernel
 373 {
 374 public:
 375         OverlayKernel(int interpolation_type);
 376         ~OverlayKernel();
 377
 378         float *lookup;
 379         float width;
 380         int n;
 381         int type;
 382 };
 383
 384 class DirectEngine;
 385
 386 class DirectPackage : public LoadPackage
 387 {
 388 public:
 389         DirectPackage();
 390
 391         int out_row1, out_row2;
 392 };
 393
 394 class NNEngine;
 395
 396 class NNPackage : public LoadPackage
 397 {
 398 public:
 399         NNPackage();
 400
 401         int out_row1, out_row2;
 402 };
 403
 404 class SampleEngine;
 405
 406 class SamplePackage : public LoadPackage
 407 {
 408 public:
 409         SamplePackage();
 410
 411         int out_col1, out_col2;
 412 };
 413
 414
 415 class DirectUnit : public LoadClient
 416 {
 417 public:
 418         DirectUnit(DirectEngine *server);
 419         ~DirectUnit();
 420
 421         void process_package(LoadPackage *package);
 422         DirectEngine *engine;
 423 };
 424
 425 class NNUnit : public LoadClient
 426 {
 427 public:
 428         NNUnit(NNEngine *server);
 429         ~NNUnit();
 430
 431         void process_package(LoadPackage *package);
 432
 433         NNEngine *engine;
 434 };
 435
 436 class SampleUnit : public LoadClient
 437 {
 438 public:
 439         SampleUnit(SampleEngine *server);
 440         ~SampleUnit();
 441
 442         void process_package(LoadPackage *package);
 443
 444         SampleEngine *engine;
 445 };
 446
 447
 448 class DirectEngine : public LoadServer
 449 {
 450 public:
 451         DirectEngine(int cpus);
 452         ~DirectEngine();
 453
 454         void init_packages();
 455         LoadClient* new_client();
 456         LoadPackage* new_package();
 457
 458         VFrame *output;
 459         VFrame *input;
 460         int in_x1;
 461         int in_y1;
 462         int out_x1;
 463         int out_x2;
 464         int out_y1;
 465         int out_y2;
 466         float alpha;
 467         int mode;
 468 };
 469
 470 class NNEngine : public LoadServer
 471 {
 472 public:
 473         NNEngine(int cpus);
 474         ~NNEngine();
 475
 476         void init_packages();
 477         LoadClient* new_client();
 478         LoadPackage* new_package();
 479
 480         VFrame *output;
 481         VFrame *input;
 482         float in_x1;
 483         float in_x2;
 484         float in_y1;
 485         float in_y2;
 486         float out_x1;
 487         float out_x2;
 488         int out_x1i;
 489         int out_x2i;
 490         float out_y1;
 491         float out_y2;
 492         float alpha;
 493         int mode;
 494
 495         int *in_lookup_x;
 496         int *in_lookup_y;
 497 };
 498
 499 class SampleEngine : public LoadServer
 500 {
 501 public:
 502         SampleEngine(int cpus);
 503         ~SampleEngine();
 504
 505         void init_packages();
 506         LoadClient* new_client();
 507         LoadPackage* new_package();
 508
 509         VFrame *output;
 510         VFrame *input;
 511         OverlayKernel *kernel;
 512
 513         int col_out1;
 514         int col_out2;
 515         int row_in;
 516
 517         float in1;
 518         float in2;
 519         float out1;
 520         float out2;
 521
 522         float alpha;
 523         int mode;
 524
 525         int *lookup_sx0;
 526         int *lookup_sx1;
 527         int *lookup_sk;
 528         float *lookup_wacc;
 529         int kd;
 530 };
 531
 532 class OverlayFrame
 533 {
 534 public:
 535         OverlayFrame(int cpus = 1);
 536         virtual ~OverlayFrame();
 537
 538         int overlay(VFrame *output,
 539                 VFrame *input,
 540                 float in_x1,
 541                 float in_y1,
 542                 float in_x2,
 543                 float in_y2,
 544                 float out_x1,
 545                 float out_y1,
 546                 float out_x2,
 547                 float out_y2,
 548                 float alpha,
 549                 int mode,
 550                 int interpolation_type);
 551
 552         DirectEngine *direct_engine;
 553         NNEngine *nn_engine;
 554         SampleEngine *sample_engine;
 555
 556         VFrame *temp_frame;
 557         int cpus;
 558         OverlayKernel *kernel[4];
 559 };
 560
 561 #endif