rework set default transtion, nested proxy edl fixes, doubleclick proxy media fix...
[goodguy/history.git] / 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