version update
[goodguy/cinelerra.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 #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