MythTV master
filters.cpp
Go to the documentation of this file.
1/* filter.c version 0.7
2* contient les filtres applicable a un buffer
3* creation : 01/10/2000
4* -ajout de sinFilter()
5* -ajout de zoomFilter()
6* -copie de zoomFilter() en zoomFilterRGB(), gérant les 3 couleurs
7* -optimisation de sinFilter (utilisant une table de sin)
8* -asm
9* -optimisation de la procedure de génération du buffer de transformation
10* la vitesse est maintenant comprise dans [0..128] au lieu de [0..100]
11*/
12
13//#define _DEBUG_PIXEL;
14
15#include <algorithm>
16#include <array>
17#include <cmath>
18#include <cstdint>
19#include <cstdio>
20#include <cstdlib>
21
22#include "filters.h"
23#include "goom_tools.h"
24#include "goomconfig.h"
25#include "graphic.h"
26#include "zoom_filters.h"
27#include "libmythbase/mythconfig.h"
28#include "libmythbase/mythrandom.h"
29#ifndef __cpp_size_t_suffix
30#include <libmythbase/sizetliteral.h>
31#endif
32
33static constexpr int8_t EFFECT_DISTORS { 4 };
34static constexpr int8_t EFFECT_DISTORS_SL { 2 };
35
36extern volatile uint32_t resolx;
37extern volatile uint32_t c_resoly;
38
39/* Prototype to keep gcc from spewing warnings */
40static void select_zoom_filter (void);
41
42#if HAVE_MMX
43
44static int zf_use_xmmx = 0;
45static int zf_use_mmx = 0;
46
47static void select_zoom_filter (void) {
48 static int s_firsttime = 1;
49 if (s_firsttime){
50 if (zoom_filter_xmmx_supported()) {
51 zf_use_xmmx = 1;
52 printf ("Extended MMX detected. Using the fastest method !\n");
53 }
54 else if (zoom_filter_mmx_supported()) {
55 zf_use_mmx = 1;
56 printf ("MMX detected. Using fast method !\n");
57 }
58 else {
59 printf ("Too bad ! No MMX detected.\n");
60 }
61 s_firsttime = 0;
62 }
63}
64
65#else /* !HAVE_MMX */
66
67static void select_zoom_filter (void) {
68 static int firsttime = 1;
69 if (firsttime) {
70 printf ("No MMX support compiled in\n");
71 firsttime = 0;
72 }
73}
74
75#endif /* HAVE_MMX */
76
77
78uint32_t mmx_zoom_size;
79
80unsigned int *coeffs = nullptr, *freecoeffs = nullptr;
81
82sintvec brutS; // source
83sintvec brutD; // dest
84sintvec brutT; // temp (en cours de génération)
85
86// TODO : virer
87uint32_t *expix1 = nullptr; // pointeur exporte vers p1
88uint32_t *expix2 = nullptr; // pointeur exporte vers p2
89// fin TODO
90
91uint32_t zoom_width;
92
93unsigned int prevX = 0, prevY = 0;
94
95static std::array<int,0x10000> sintable;
96static int vitesse = 127;
97static char theMode = AMULETTE_MODE;
98static bool waveEffect = false;
99static bool hypercosEffect = false;
100static int vPlaneEffect = 0;
101static int hPlaneEffect = 0;
102static char noisify = 1;
103static int middleX, middleY;
104
105//static unsigned char sqrtperte = 16 ;
106
108//static int buffratio = 0;
109int buffratio = 0;
110
111static constexpr uint8_t BUFFPOINTNB { 16 };
112static constexpr int32_t BUFFPOINTMASK { 0xffff };
113//static constexpr uint8_t BUFFINCR { 0xff };
114
115static constexpr int8_t sqrtperte { 16 };
116// faire : a % sqrtperte <=> a & pertemask
117static constexpr int8_t PERTEMASK { 0xf };
118// faire : a / sqrtperte <=> a >> PERTEDEC
119static constexpr uint8_t PERTEDEC { 4 };
120
121static std::vector<int> firedec;
122
123
124// retourne x>>s , en testant le signe de x
125static inline int ShiftRight(int x,int s) {return (x<0) ? -((-x)>>s) : (x>>s); }
126
128GoomCoefficients precalCoef = {};
129
130/* Prototypes to keep gcc from spewing warnings */
131void generatePrecalCoef (void);
132void calculatePXandPY (int x, int y, int *px, int *py);
133void setPixelRGB (unsigned int * buffer, unsigned int x, unsigned int y, Color c);
134void setPixelRGB_ (unsigned int * buffer, unsigned int x, Color c);
135inline void getPixelRGB (const unsigned int * buffer, unsigned int x, unsigned int y, Color * c);
136void getPixelRGB_ (const unsigned int * buffer, unsigned int x, Color * c);
137
138void
139generatePrecalCoef ()
140{
141 static int s_firstime = 1;
142
143 if (s_firstime) {
144 s_firstime = 0;
145
146 for (int coefh = 0; coefh < 16; coefh++) {
147
148 for (int coefv = 0; coefv < 16; coefv++) {
149 int i = 0;
150 int diffcoeffh = sqrtperte - coefh;
151 int diffcoeffv = sqrtperte - coefv;
152
153 // coeffs[myPos] = ((px >> PERTEDEC) + prevX * (py >> PERTEDEC)) <<
154 // 2;
155 if (!(coefh || coefv))
156 i = 255;
157 else {
158 int i1 = diffcoeffh * diffcoeffv;
159 int i2 = coefh * diffcoeffv;
160 int i3 = diffcoeffh * coefv;
161 int i4 = coefh * coefv;
162 if (i1)
163 i1--;
164 if (i2)
165 i2--;
166 if (i3)
167 i3--;
168 if (i4)
169 i4--;
170
171 i = (i1) | (i2 << 8) | (i3 << 16) | (i4 << 24);
172 }
173 precalCoef[coefh][coefv] = i;
174 }
175 }
176 }
177}
178
179/*
180 calculer px et py en fonction de x,y,middleX,middleY et theMode
181 px et py indique la nouvelle position (en sqrtperte ieme de pixel)
182 (valeur * 16)
183 */
184/*inline*/ void
185calculatePXandPY (int x, int y, int *px, int *py)
186{
187 if (theMode == WATER_MODE) {
188 static int s_wave = 0;
189 static int s_wavesp = 0;
190
191 int yy = y + MythRandomTriangularInt(3) + (s_wave / 10);
192 yy = std::max(yy, 0);
193 if (yy >= (int)c_resoly)
194 yy = c_resoly - 1;
195
196 *px = (x << 4) + firedec[yy] + (s_wave / 10);
197 *py = (y << 4) + 132 - ((vitesse < 131) ? vitesse : 130);
198
199 s_wavesp += MythRandomTriangularInt(2);
200 if (s_wave < -10)
201 s_wavesp += 2;
202 if (s_wave > 10)
203 s_wavesp -= 2;
204 s_wave += (s_wavesp / 10) + MythRandomTriangularInt(2);
205 if (s_wavesp > 100)
206 s_wavesp = (s_wavesp * 9) / 10;
207 }
208 else {
209 int dist = 0;
210 int fvitesse = vitesse << 4;
211
212 if (noisify != 0) {
213 x += MythRandomTriangularInt(noisify);
214 y += MythRandomTriangularInt(noisify);
215 }
216 int vx = (x - middleX) << 9;
217 int vy = (y - middleY) << 9;
218
219 if (hPlaneEffect)
220 vx += hPlaneEffect * (y - middleY);
221 // else vx = (x - middleX) << 9 ;
222
223 if (vPlaneEffect)
224 vy += vPlaneEffect * (x - middleX);
225 // else vy = (y - middleY) << 9 ;
226
227 if (waveEffect) {
228 fvitesse *=
229 1024 +
230 ShiftRight (sintable[(unsigned short) ((dist * 0xffff) + EFFECT_DISTORS)], 6);
231 fvitesse /= 1024;
232 }
233
234 if (hypercosEffect) {
235 vx += ShiftRight (sintable[(-vy + dist) & 0xffff], 1);
236 vy += ShiftRight (sintable[(vx + dist) & 0xffff], 1);
237 }
238
239 int vx9 = ShiftRight (vx, 9);
240 int vy9 = ShiftRight (vy, 9);
241 dist = (vx9 * vx9) + (vy9 * vy9);
242
243 switch (theMode) {
244 case WAVE_MODE:
245 fvitesse *=
246 1024 +
247 ShiftRight (sintable[(unsigned short) (dist * 0xffff * EFFECT_DISTORS)], 6);
248 fvitesse>>=10;
249 break;
250 case CRYSTAL_BALL_MODE:
251 fvitesse += (dist >> (10-EFFECT_DISTORS_SL));
252 break;
253 case AMULETTE_MODE:
254 fvitesse -= (dist >> (4 - EFFECT_DISTORS_SL));
255 break;
256 case SCRUNCH_MODE:
257 fvitesse -= (dist >> (10 - EFFECT_DISTORS_SL));
258 break;
259 case HYPERCOS1_MODE:
260 vx = vx + ShiftRight (sintable[(-vy + dist) & 0xffff], 1);
261 vy = vy + ShiftRight (sintable[(vx + dist) & 0xffff], 1);
262 break;
263 case HYPERCOS2_MODE:
264 vx =
265 vx + ShiftRight (sintable[(-ShiftRight (vy, 1) + dist) & 0xffff], 0);
266 vy =
267 vy + ShiftRight (sintable[(ShiftRight (vx, 1) + dist) & 0xffff], 0);
268 fvitesse = 128 << 4;
269 break;
270 case YONLY_MODE:
271 fvitesse *= 1024 + ShiftRight (sintable[vy & 0xffff], 6);
272 fvitesse >>= 10;
273 break;
274 case SPEEDWAY_MODE:
275 fvitesse -= (ShiftRight(vy,10-EFFECT_DISTORS_SL));
276 break;
277 }
278
279 fvitesse = std::max(fvitesse, -3024);
280
281 int ppx = 0;
282 int ppy = 0;
283 if (vx < 0) { // pb avec decalage sur nb negatif
284 ppx = -(-(vx * fvitesse) >> 16);
285 /* 16 = 9 + 7 (7 = nb chiffre virgule de vitesse * (v = 128 => immobile)
286 * * * * * 9 = nb chiffre virgule de vx) */
287 } else {
288 ppx = ((vx * fvitesse) >> 16);
289 }
290
291 if (vy < 0)
292 ppy = -(-(vy * fvitesse) >> 16);
293 else
294 ppy = ((vy * fvitesse) >> 16);
295
296 *px = (middleX << 4) + ppx;
297 *py = (middleY << 4) + ppy;
298 }
299}
300
301//#define _DEBUG
302
303/*inline*/ void
304setPixelRGB (unsigned int * buffer, unsigned int x, unsigned int y, Color c)
305{
306 // buffer[ y*WIDTH + x ] = (c.r<<16)|(c.v<<8)|c.b
307#ifdef _DEBUG_PIXEL
308 if (x + y * resolx >= resolx * resoly) {
309 fprintf (stderr, "setPixel ERROR : hors du tableau... %i, %i\n", x, y);
310 // exit (1) ;
311 }
312#endif
313
314 buffer[(y * resolx) + x] =
315 (c.b << (BLEU * 8)) | (c.v << (VERT * 8)) | (c.r << (ROUGE * 8));
316}
317
318
319/*inline*/ void
320setPixelRGB_ (unsigned int * buffer, unsigned int x, Color c)
321{
322#ifdef _DEBUG
323 if (x >= resolx * c_resoly) {
324 printf ("setPixel ERROR : hors du tableau... %i\n", x);
325 // exit (1) ;
326 }
327#endif
328
329 buffer[x] = (c.r << (ROUGE * 8)) | (c.v << (VERT * 8)) | c.b << (BLEU * 8);
330}
331
332
333
334inline void
335getPixelRGB (const unsigned int * buffer, unsigned int x, unsigned int y, Color * c)
336{
337#ifdef _DEBUG
338 if (x + y * resolx >= resolx * c_resoly) {
339 printf ("getPixel ERROR : hors du tableau... %i, %i\n", x, y);
340 // exit (1) ;
341 }
342#endif
343
344 /* ATTENTION AU PETIT INDIEN */
345 unsigned int i = *(buffer + (x + y * resolx));
346 c->b = (i >> (BLEU * 8)) & 0xff;
347 c->v = (i >> (VERT * 8)) & 0xff;
348 c->r = (i >> (ROUGE * 8)) & 0xff;
349}
350
351
352/*inline*/ void
353getPixelRGB_ (const unsigned int * buffer, unsigned int x, Color * c)
354{
355 unsigned char *tmp8 = nullptr;
356
357#ifdef _DEBUG
358 if (x >= resolx * c_resoly) {
359 printf ("getPixel ERROR : hors du tableau... %i\n", x);
360 // exit (1) ;
361 }
362#endif
363
364#ifdef __BIG_ENDIAN__
365 c->b = *(unsigned char *) (tmp8 = (unsigned char *) (buffer + x));
366 c->r = *(unsigned char *) (++tmp8);
367 c->v = *(unsigned char *) (++tmp8);
368 c->b = *(unsigned char *) (++tmp8);
369
370#else
371 /* ATTENTION AU PETIT INDIEN */
372 c->b = *(tmp8 = (unsigned char *) (buffer + x));
373 c->v = *(++tmp8);
374 c->r = *(++tmp8);
375 // *c = (Color) buffer[x+y*WIDTH] ;
376#endif
377}
378
379
380static
381void c_zoom (unsigned int *lexpix1, unsigned int *lexpix2,
382 unsigned int lprevX, unsigned int lprevY,
383 const sintvec& lbrutS, const sintvec& lbrutD)
384{
385 Color couleur {};
386// unsigned int coefv, coefh;
387
388 unsigned int ax = (lprevX - 1) << PERTEDEC;
389 unsigned int ay = (lprevY - 1) << PERTEDEC;
390
391 int bufsize = lprevX * lprevY * 2;
392 int bufwidth = lprevX;
393
394 lexpix1[0]=lexpix1[lprevX-1]=lexpix1[(lprevX*lprevY)-1]=lexpix1[(lprevX*lprevY)-lprevX]=0;
395
396 for (int myPos = 0; myPos < bufsize; myPos += 2) {
397 Color col1 {};
398 Color col2 {};
399 Color col3 {};
400 Color col4 {};
401 int brutSmypos = lbrutS[myPos];
402
403 int myPos2 = myPos + 1;
404
405 int px = brutSmypos + (((lbrutD[myPos] - brutSmypos) * buffratio) >> BUFFPOINTNB);
406 brutSmypos = lbrutS[myPos2];
407 int py = brutSmypos + (((lbrutD[myPos2] - brutSmypos) * buffratio) >> BUFFPOINTNB);
408
409 px = std::max(px, 0);
410 py = std::max(py, 0);
411
412 int pos = ((px >> PERTEDEC) + (lprevX * (py >> PERTEDEC)));
413 // coef en modulo 15
414 int lcoeffs = precalCoef[px & PERTEMASK][py & PERTEMASK];
415
416 if ((py >= (int)ay) || (px >= (int)ax)) {
417 pos = lcoeffs = 0;
418 }
419
420 getPixelRGB_ (lexpix1, pos, &col1);
421 getPixelRGB_ (lexpix1, pos + 1, &col2);
422 getPixelRGB_ (lexpix1, pos + bufwidth, &col3);
423 getPixelRGB_ (lexpix1, pos + bufwidth + 1, &col4);
424
425 int c1 = lcoeffs;
426 int c2 = (c1 & 0x0000ff00) >> 8;
427 int c3 = (c1 & 0x00ff0000) >> 16;
428 int c4 = (c1 & 0xff000000) >> 24;
429 c1 = c1 & 0xff;
430
431 couleur.r = (col1.r * c1) + (col2.r * c2) + (col3.r * c3) + (col4.r * c4);
432 if (couleur.r > 5)
433 couleur.r -= 5;
434 couleur.r >>= 8;
435
436 couleur.v = (col1.v * c1) + (col2.v * c2) + (col3.v * c3) + (col4.v * c4);
437 if (couleur.v > 5)
438 couleur.v -= 5;
439 couleur.v >>= 8;
440
441 couleur.b = (col1.b * c1) + (col2.b * c2) + (col3.b * c3) + (col4.b * c4);
442 if (couleur.b > 5)
443 couleur.b -= 5;
444 couleur.b >>= 8;
445
446 setPixelRGB_ (lexpix2, myPos >> 1, couleur);
447 }
448}
449
450/*===============================================================*/
451void
452zoomFilterFastRGB (unsigned int * pix1, unsigned int * pix2, ZoomFilterData * zf, unsigned int resx, unsigned int resy, int switchIncr, float switchMult)
453{
454 [[maybe_unused]] static unsigned char s_pertedec = 8;
455 static char s_firstTime = 1;
456
457 static constexpr int8_t INTERLACE_INCR { 16 };
458 //static constexpr int8_t INTERLACE_ADD { 9 };
459 //static constexpr int8_t INTERLACE_AND { 0xf };
460 static int s_interlaceStart = -2;
461
462 expix1 = pix1;
463 expix2 = pix2;
464
466 if ((prevX != resx) || (prevY != resy)) {
467 prevX = resx;
468 prevY = resy;
469
470 brutS.clear();
471 brutD.clear();
472 brutT.clear();
473
474 middleX = resx / 2;
475 middleY = resy - 1;
476 s_firstTime = 1;
477 firedec.clear();
478 }
479
480 if (s_interlaceStart != -2)
481 zf = nullptr;
482
484 if (zf) {
485 static bool s_reverse = false; // vitesse inversé..(zoom out)
486 s_reverse = zf->reverse;
487 vitesse = zf->vitesse;
488 if (s_reverse)
489 vitesse = 256 - vitesse;
490 s_pertedec = zf->pertedec;
491 middleX = zf->middleX;
492 middleY = zf->middleY;
493 theMode = zf->mode;
494 hPlaneEffect = zf->hPlaneEffect;
495 vPlaneEffect = zf->vPlaneEffect;
496 waveEffect = zf->waveEffect;
497 hypercosEffect = zf->hypercosEffect;
498 noisify = zf->noisify;
499 }
500
502 if (s_firstTime || zf) {
503
504 // generation d'une table de sinus
505 if (s_firstTime) {
506 s_firstTime = 0;
507 generatePrecalCoef ();
508 select_zoom_filter ();
509
510#ifdef __cpp_size_t_suffix
511 brutS.resize(2Z * resx * resy);
512 brutD.resize(2Z * resx * resy);
513 brutT.resize(2Z * resx * resy);
514#else
515 brutS.resize(2_Z * resx * resy);
516 brutD.resize(2_Z * resx * resy);
517 brutT.resize(2_Z * resx * resy);
518#endif
520 {
521 int yperte = 0;
522 int yofs = 0;
523
524 for (unsigned int y = 0; y < resy; y++, yofs += resx) {
525 int xofs = yofs << 1;
526 int xperte = 0;
527
528 for (unsigned int x = 0; x < resx; x++) {
529 brutS[xofs++] = xperte;
530 brutS[xofs++] = yperte;
531 xperte += sqrtperte;
532 }
533 yperte += sqrtperte;
534 }
535 buffratio = 0;
536 }
537
538 for (uint16_t us = 0; us < 0xffff; us++) {
539 sintable[us] =
540 roundf(1024 * sinf ((float) us * 360
541 / ((float)sintable.size() - 1)
542 * std::numbers::pi_v<float> / 180));
543 }
544
545 {
546 firedec.resize(prevY);
547
548 for (int loopv = prevY; loopv != 0;) {
549 static int s_decc = 0;
550 static int s_spdc = 0;
551 static int s_accel = 0;
552
553 loopv--;
554 firedec[loopv] = s_decc;
555 s_decc += s_spdc / 10;
556 s_spdc += MythRandomTriangularInt(2);
557
558 if (s_decc > 4)
559 s_spdc -= 1;
560 if (s_decc < -4)
561 s_spdc += 1;
562
563 if (s_spdc > 30)
564 s_spdc = s_spdc - MythRandomInt(0, 2) + (s_accel / 10);
565 if (s_spdc < -30)
566 s_spdc = s_spdc + MythRandomInt(0, 2) + (s_accel / 10);
567
568 if (s_decc > 8 && s_spdc > 1)
569 s_spdc -= MythRandomInt(-2, 0);
570
571 if (s_decc < -8 && s_spdc < -1)
572 s_spdc += MythRandomInt(2, 4);
573
574 if (s_decc > 8 || s_decc < -8)
575 s_decc = s_decc * 8 / 9;
576
577 s_accel += MythRandomTriangularInt(1);
578 if (s_accel > 20)
579 s_accel -= 2;
580 if (s_accel < -20)
581 s_accel += 2;
582 }
583 }
584 }
585
586 s_interlaceStart = 0;
587 }
588 // generation du buffer de trans
589 if (s_interlaceStart==-1) {
590
591 /* sauvegarde de l'etat actuel dans la nouvelle source */
592
593 unsigned int y = prevX * prevY * 2;
594 for (unsigned int x = 0; x < y; x += 2) {
595 int brutSmypos = brutS[x];
596 int x2 = x + 1;
597
598 brutS[x] =
599 brutSmypos + (((brutD[x] - brutSmypos) * buffratio) >> BUFFPOINTNB);
600 brutSmypos = brutS[x2];
601 brutS[x2] =
602 brutSmypos +
603 (((brutD[x2] - brutSmypos) * buffratio) >> BUFFPOINTNB);
604 }
605 buffratio = 0;
606
607 brutD.swap(brutT);
608 s_interlaceStart = -2;
609 }
610
611 if (s_interlaceStart>=0) {
612 int maxEnd = (s_interlaceStart+INTERLACE_INCR);
613 /* creation de la nouvelle destination */
614 auto y = (unsigned int)s_interlaceStart;
615 for ( ; (y < prevY) && (y < (unsigned int)maxEnd); y++) {
616 unsigned int premul_y_prevX = y * prevX * 2;
617 for (unsigned int x = 0; x < prevX; x++) {
618 int px = 0;
619 int py = 0;
620
621 calculatePXandPY (x, y, &px, &py);
622
623 brutT[premul_y_prevX] = px;
624 brutT[premul_y_prevX + 1] = py;
625 premul_y_prevX += 2;
626 }
627 }
628 s_interlaceStart += INTERLACE_INCR;
629 if (y >= prevY-1) s_interlaceStart = -1;
630 }
631
632 if (switchIncr != 0) {
633 buffratio += switchIncr;
634 buffratio = std::min(buffratio, BUFFPOINTMASK);
635 }
636
637 if (switchMult != 1.0F) {
638 buffratio =
639 (int) (((float) BUFFPOINTMASK * (1.0F - switchMult)) +
640 ((float) buffratio * switchMult));
641 }
642
643 zoom_width = prevX;
644 mmx_zoom_size = prevX * prevY;
645
646#if HAVE_MMX
647 if (zf_use_xmmx) {
648 zoom_filter_xmmx (prevX, prevY,expix1, expix2,
649 brutS, brutD, buffratio, precalCoef);
650 } else if (zf_use_mmx) {
651 zoom_filter_mmx (prevX, prevY,expix1, expix2,
652 brutS, brutD, buffratio, precalCoef);
653 } else {
654 c_zoom (expix1, expix2, prevX, prevY, brutS, brutD);
655 }
656#else
657 c_zoom (expix1, expix2, prevX, prevY, brutS, brutD);
658#endif
659}
660
661void
662pointFilter (unsigned int * pix1, Color c, float t1, float t2, float t3, float t4, unsigned int cycle)
663{
664 auto x = (unsigned int) ((int) (resolx/2) + (int) (t1 * cosf ((float) cycle / t3)));
665 auto y = (unsigned int) ((int) (c_resoly/2) + (int) (t2 * sinf ((float) cycle / t4)));
666
667 if ((x > 1) && (y > 1) && (x < resolx - 2) && (y < c_resoly - 2)) {
668 setPixelRGB (pix1, x + 1, y, c);
669 setPixelRGB (pix1, x, y + 1, c);
670 setPixelRGB (pix1, x + 1, y + 1, WHITE);
671 setPixelRGB (pix1, x + 2, y + 1, c);
672 setPixelRGB (pix1, x + 1, y + 2, c);
673 }
674}
sintable
static std::array< int, 0x10000 > sintable
Definition: filters.cpp:95
brutS
sintvec brutS
Definition: filters.cpp:82
hypercosEffect
static bool hypercosEffect
Definition: filters.cpp:99
mmx_zoom_size
uint32_t mmx_zoom_size
Definition: filters.cpp:78
expix2
uint32_t * expix2
Definition: filters.cpp:88
calculatePXandPY
void calculatePXandPY(int x, int y, int *px, int *py)
Definition: filters.cpp:185
getPixelRGB_
void getPixelRGB_(const unsigned int *buffer, unsigned int x, Color *c)
Definition: filters.cpp:353
noisify
static char noisify
Definition: filters.cpp:102
zoom_width
uint32_t zoom_width
Definition: filters.cpp:91
PERTEMASK
static constexpr int8_t PERTEMASK
Definition: filters.cpp:117
waveEffect
static bool waveEffect
Definition: filters.cpp:98
getPixelRGB
void getPixelRGB(const unsigned int *buffer, unsigned int x, unsigned int y, Color *c)
Definition: filters.cpp:335
EFFECT_DISTORS_SL
static constexpr int8_t EFFECT_DISTORS_SL
Definition: filters.cpp:34
select_zoom_filter
static void select_zoom_filter(void)
Definition: filters.cpp:67
vitesse
static int vitesse
Definition: filters.cpp:96
zoomFilterFastRGB
void zoomFilterFastRGB(unsigned int *pix1, unsigned int *pix2, ZoomFilterData *zf, unsigned int resx, unsigned int resy, int switchIncr, float switchMult)
Definition: filters.cpp:452
pointFilter
void pointFilter(unsigned int *pix1, Color c, float t1, float t2, float t3, float t4, unsigned int cycle)
Definition: filters.cpp:662
BUFFPOINTNB
static constexpr uint8_t BUFFPOINTNB
Definition: filters.cpp:111
c_zoom
static void c_zoom(unsigned int *lexpix1, unsigned int *lexpix2, unsigned int lprevX, unsigned int lprevY, const sintvec &lbrutS, const sintvec &lbrutD)
Definition: filters.cpp:381
setPixelRGB_
void setPixelRGB_(unsigned int *buffer, unsigned int x, Color c)
Definition: filters.cpp:320
vPlaneEffect
static int vPlaneEffect
Definition: filters.cpp:100
theMode
static char theMode
Definition: filters.cpp:97
sqrtperte
static constexpr int8_t sqrtperte
Definition: filters.cpp:115
middleX
static int middleX
Definition: filters.cpp:103
coeffs
unsigned int * coeffs
Definition: filters.cpp:80
setPixelRGB
void setPixelRGB(unsigned int *buffer, unsigned int x, unsigned int y, Color c)
Definition: filters.cpp:304
prevY
unsigned int prevY
Definition: filters.cpp:93
freecoeffs
unsigned int * freecoeffs
Definition: filters.cpp:80
prevX
unsigned int prevX
Definition: filters.cpp:93
BUFFPOINTMASK
static constexpr int32_t BUFFPOINTMASK
Definition: filters.cpp:112
precalCoef
GoomCoefficients precalCoef
modif d'optim by Jeko : precalcul des 4 coefs résultant des 2 pos
Definition: filters.cpp:128
firedec
static std::vector< int > firedec
Definition: filters.cpp:121
generatePrecalCoef
void generatePrecalCoef(void)
Definition: filters.cpp:139
buffratio
int buffratio
modif by jeko : fixedpoint : buffration = (16:16) (donc 0<=buffration<=2^16)
Definition: filters.cpp:109
EFFECT_DISTORS
static constexpr int8_t EFFECT_DISTORS
Definition: filters.cpp:33
resolx
volatile uint32_t resolx
Definition: goom_core.cpp:66
middleY
static int middleY
Definition: filters.cpp:103
ShiftRight
static int ShiftRight(int x, int s)
Definition: filters.cpp:125
hPlaneEffect
static int hPlaneEffect
Definition: filters.cpp:101
PERTEDEC
static constexpr uint8_t PERTEDEC
Definition: filters.cpp:119
expix1
uint32_t * expix1
Definition: filters.cpp:87
brutD
sintvec brutD
Definition: filters.cpp:83
c_resoly
volatile uint32_t c_resoly
Definition: goom_core.cpp:66
brutT
sintvec brutT
Definition: filters.cpp:84
YONLY_MODE
#define YONLY_MODE
Definition: filters.h:37
CRYSTAL_BALL_MODE
#define CRYSTAL_BALL_MODE
Definition: filters.h:31
HYPERCOS2_MODE
#define HYPERCOS2_MODE
Definition: filters.h:36
AMULETTE_MODE
#define AMULETTE_MODE
Definition: filters.h:33
WAVE_MODE
#define WAVE_MODE
Definition: filters.h:30
WATER_MODE
#define WATER_MODE
Definition: filters.h:34
SCRUNCH_MODE
#define SCRUNCH_MODE
Definition: filters.h:32
SPEEDWAY_MODE
#define SPEEDWAY_MODE
Definition: filters.h:38
HYPERCOS1_MODE
#define HYPERCOS1_MODE
Definition: filters.h:35
cycle
static uint32_t cycle
Definition: goom_core.cpp:29
resoly
uint32_t resoly
Definition: goom_core.cpp:66
goom_tools.h
VERT
#define VERT
Definition: goomconfig.h:12
ROUGE
#define ROUGE
position des composantes
Definition: goomconfig.h:10
BLEU
#define BLEU
Definition: goomconfig.h:11
WHITE
const Color WHITE
Definition: graphic.cpp:4
uint16_t
unsigned short uint16_t
Definition: iso6937tables.h:3
mythrandom.h
Convenience inline random number generator functions.
x2
static int x2
Definition: mythsocket.cpp:55
MythRandomStd::MythRandomTriangularInt
int MythRandomTriangularInt(int x)
Generate a random signed int over a symmetric triangular distribution with a minimum of -x,...
Definition: mythrandom.h:72
MythRandomStd::MythRandomInt
int MythRandomInt(int min, int max)
generate a uniformly distributed random signed int in the closed interval [min, max].
Definition: mythrandom.h:58
Color
Definition: graphic.h:5
Color::b
unsigned short b
Definition: graphic.h:6
Color::v
unsigned short v
Definition: graphic.h:6
Color::r
unsigned short r
Definition: graphic.h:6
ZoomFilterData::hypercosEffect
bool hypercosEffect
Definition: filters.h:23
ZoomFilterData::pertedec
unsigned char pertedec
Definition: filters.h:13
ZoomFilterData::waveEffect
bool waveEffect
Definition: filters.h:22
ZoomFilterData::vPlaneEffect
int vPlaneEffect
Definition: filters.h:20
ZoomFilterData::noisify
char noisify
Definition: filters.h:25
ZoomFilterData::reverse
bool reverse
Definition: filters.h:16
ZoomFilterData::hPlaneEffect
int hPlaneEffect
Definition: filters.h:19
zoom_filter_mmx_supported
int zoom_filter_mmx_supported()
Definition: zoom_filter_mmx.cpp:134
zoom_filter_mmx
void zoom_filter_mmx(int prevX, int prevY, const unsigned int *expix1, unsigned int *expix2, const sintvec &brutS, const sintvec &brutD, int buffratio, const GoomCoefficients &precalCoef)
Definition: zoom_filter_mmx.cpp:138
zoom_filter_xmmx
void zoom_filter_xmmx(int prevX, int prevY, unsigned int *expix1, unsigned int *expix2, const sintvec &brutS, const sintvec &brutD, int buffratio, GoomCoefficients &precalCoef)
Definition: zoom_filter_xmmx.cpp:261
zoom_filter_xmmx_supported
int zoom_filter_xmmx_supported()
Definition: zoom_filter_xmmx.cpp:258
zoom_filters.h
sintvec
std::vector< signed int > sintvec
Definition: zoom_filters.h:4
GoomCoefficients
std::array< std::array< int, 16 >, 16 > GoomCoefficients
Definition: zoom_filters.h:5
Generated on Mon Jun 1 2026 03:15:42 for MythTV by doxygen 1.9.4