h64020
s 00077 / 00001 / 08351
d D 1.105 00 / 11 / 24 20 : 06 : 53 vincenzo 105 104
c rop_mirror per cmapped
e
s 00015 / 00003 / 08337
d D 1.104 00 / 02 / 18 15 : 59 : 01 max 104 103
c fix baco in rop_premultiply RGBM64 RGBM64;
rop_copy funz.su RAS_BW, RAS_BW
e
s 00001 / 00000 / 08339
d D 1.103 00 / 01 / 12 12 : 08 : 57 vincenzo 103 102
c rop_copy CM24->GR16
e
s 00005 / 00000 / 08334
d D 1.102 99 / 11 / 25 11 : 02 : 20 max 102 101
c rop mirror gestisce WB e BW
e
s 00002 / 00000 / 08332
d D 1.101 99 / 11 / 12 16 : 22 : 09 vincenzo 101 100
c rop_copy_cm16s12->rgbm
e
s 00002 / 00001 / 08330
d D 1.100 99 / 10 / 28 10 : 10 : 09 max 100 99
c rop_mirror supporta anche rastype RAS_WB
e
s 00016 / 00000 / 08315
d D 1.99 99 / 08 / 20 09 : 53 : 22 vincenzo 99 98
c messaggi(disattivati) di diagnostica sulla memoria
e
s 00090 / 00000 / 08225
d D 1.98 99 / 05 / 17 17 : 28 : 42 vincenzo 98 97
c CM16S12
e
s 00006 / 00021 / 08219
d D 1.97 99 / 04 / 01 17 : 59 : 05 vincenzo 97 96
c conversioni varie utilizzate per salvare i.mov
e
s 00374 / 00191 / 07866
d D 1.96 99 / 03 / 26 19 : 19 : 15 vincenzo 96 95
c rop_xrgb1555
e
s 00484 / 00000 / 07573
d D 1.95 99 / 03 / 03 16 : 08 : 21 max 95 94
c + rop_copy rgbx64->rgbx, rgbx64->rgb16;
+ rop_zoom_out rgbx64->rgbx, rgbx64->rgb16, rgbm64->rgbm
e
s 00013 / 00009 / 07560
d D 1.94 99 / 02 / 25 17:04:34 tross 94 93
c rop_subimage_to_raster anche per RGBM64
e
s 00007 / 00006 / 07562
d D 1.93 99 / 02 / 20 15:51:08 tross 93 92
c corretta rop_clear(sbagliava se y1 != 0)
e
s 00001 / 00001 / 07567
d D 1.92 99 / 02 / 17 19:07:11 vincenzo 92 91
c la clone_raster fa anche gli extra
e
s 00020 / 00016 / 07548
d D 1.91 99 / 02 / 15 17:31:49 tross 91 90
c corretta la clone_raster per CM
e
s 00029 / 00002 / 07535
d D 1.90 99 / 02 / 15 17:22:14 vincenzo 90 89
c RAS_GR16
e
s 00713 / 00426 / 06824
d D 1.89 99 / 01 / 11 18:03:57 tross 89 88
c migliorati extra:corretti bachi e aggiunte funz -
corretta
rop_custom_fill_cmap_penramp(baco tcheck cm24)
e
s 00034 / 00002 / 07216
d D 1.88 98 / 12 / 14
16:
21:17 vincenzo 88 87
c ristrutturazione megagalattica per le dll
e
s 00013 / 00000 / 07205
d D 1.87 98 / 10 / 23
17:
21:44 vincenzo 87 86
c convert_raster
e
s 00007 / 00001 / 07198
d D 1.86 98 / 09 / 24
18:
32:38 tross 86 85
c messa cmap.info in create_raster()
e
s 00003 / 00000 / 07196
d D 1.85 98 / 09 / 14
16:
15:32 vincenzo 85 84
c clone_raster mette anchge la cmap
e
s 01500 / 00701 / 05696
d D 1.84 98 / 09 / 14
15:
57:39 tross 84 83
c modifiche per CM24, velocizzati[un] premult_lpixel
e
s 00044 / 00064 / 06353
d D 1.83 98 / 08 / 14
17:
14:44 tross 83 82
c tolti UNICM
e
s 00013 / 00014 / 06404
d D 1.82 98 / 08 / 14
14:
39:55 tross 82 81
c tolto cmap.size
e
s 00348 / 00177 / 06070
d D 1.81 98 / 07 / 16
20:
02:00 tross 81 80
c rop_copy e rop_zoom_out rgb_rgb16
e
s 00028 / 00000 / 06219
d D 1.80 98 / 07 / 10
18:
32:08 vincenzo 80 79
c create_subraster e clone_raster
e
s 00005 / 00014 / 06214
d D 1.79 98 / 06 / 09
17:
29:54 vincenzo 79 78
c eliminata struct cmap_color
e
s 00025 / 00025 / 06203
d D 1.78 98 / 03 / 26
01:
07:03 tross 78 77
c assert(FALSE)-- > abort()per problemi di GP piena
e
s 00038 / 00000 / 06190
d D 1.77 98 / 03 / 13
18:
35:34 vincenzo 77 76
c create_raster e release_raster
e
s 00002 / 00002 / 06188
d D 1.76 98 / 03 / 09
15:
00:15 vincenzo 76 75
c rop_image_to_(sub)raster non inizializzava native_buffer
e
s 00004 / 00004 / 06186
d D 1.75 98 / 02 / 23
12:
35:57 vincenzo 75 74
c sbagliata scansione raster su premultiply
e
s 00082 / 00002 / 06108
d D 1.74 98 / 02 / 23
11:
15:21 tross 74 73
c rop_premultiply()
e
s 00056 / 00051 / 06054
d D 1.73 97 / 12 / 01
18:
26:04 vincenzo 73 72
c rgbx->bw_q, cm16->bw_q
e
s 00020 / 00000 / 06085
d D 1.72 97 / 11 / 28
17:
31:32 vincenzo 72 71
c gestione RAS_CMxSy(copy, pixbytes pix_to_ras etc)
e
s 00017 / 00001 / 06068
d D 1.71 97 / 11 / 18
16:
42:31 tross 71 70
c rop_copy RAS_CMxSy
e
s 00033 / 00001 / 06036
d D 1.70 97 / 09 / 26
12:
25:32 vincenzo 70 69
c rop_copy_rgb16_rgbm
e
s 00010 / 00007 / 06027
d D 1.69 97 / 09 / 23
15:
53:42 tross 69 68
c migliorata la rop_copy_bw
e
s 00043 / 00003 / 05991
d D 1.68 97 / 09 / 23
00:
00:23 tross 68 67
c rop_copy_bw_bw
e
s 00038 / 00000 / 05956
d D 1.67 97 / 09 / 22
22:
20:35 tross 67 66
c rop_copy_rgbx_rgb(vincenzo)
e
s 00006 / 00016 / 05950
d D 1.66 97 / 04 / 01
18:
46:33 vincenzo 66 65
c esportata la dither
e
s 00037 / 00021 / 05929
d D 1.65 97 / 03 / 27
19:
54:27 tross 65 64
c rop_copy_rgbm64_rgbm con random round
e
s 00001 / 00001 / 05949
d D 1.64 97 / 01 / 03
15:
10:39 roberto 64 63
c Corretto bug in rop_copy_90(CASE-- __OR)
e
s 00453 / 00002 / 05497
d D 1.63 96 / 11 / 24
22:
36:00 tross 63 62
c rop_copy_90_rgb_rgb16, rop_zoom_out_90_rgb_rgb16 / rgbm
e
s 00381 / 00003 / 05118
d D 1.62 96 / 09 / 14
21:
54:23 tross 62 61
c rop_zoom_out_bw_rgb16 / rgbm
e
s 00577 / 00323 / 04544
d D 1.61 96 / 09 / 12
19:
44:13 tross 61 60
c rop_zoom_out_bw_rgbm / rgb16, corretto rop_zoom_out_90_gr8_...
e
s 00026 / 00026 / 04841
d D 1.60 96 / 08 / 05
18:
15:12 vincenzo 60 59
c gl_color->LPIXEL
e
s 00002 / 00001 / 04865
d D 1.59 96 / 07 / 12
18:
41:01 vincenzo 59 58
c messo RGBM64 rop_pixbytes
e
s 00246 / 00123 / 04620
d D 1.58 96 / 07 / 10
17:
57:56 vincenzo 58 57
c introdotto rop_copy per RAS_RGBM64
e
s 00280 / 00086 / 04463
d D 1.57 96 / 07 / 10
01:
01:58 tross 57 56
c rop_zoom_out_90, per ora solo gr8-- > rgb16 / rgbm
e
s 00279 / 00110 / 04270
d D 1.56 96 / 07 / 09
16:
44:14 tross 56 55
c cmap.offset-- > cmap.info.offset_mask etc.
e
s 00238 / 00065 / 04142
d D 1.55 96 / 07 / 01
16:
24:22 tross 55 54
c rop_copy_90_bw / gr8_rgb16
e
s 00205 / 00009 / 04002
d D 1.54 96 / 06 / 27
20:
46:24 tross 54 53
c rop_copy_bw / gr8_rgb16, rop_zoom_out_gr8_rgb16, aggiornati nomi macro RGB16
e
s 00094 / 00047 / 03917
d D 1.53 96 / 06 / 27
04:
39:24 tross 53 52
c conversioni pix_type<->ras_type
e
s 00675 / 00343 / 03289
d D 1.52 96 / 06 / 26 02:04:18 tross 52 51
c potrebbero funziare un po' di copy e zoom_out ->rgb16
e
s 00002 / 00001 / 03630
d D 1.51 96 / 05 / 15 22:11:20 tross 51 50
c tmsg.h
e
s 00011 / 00000 / 03620
d D 1.50 96 / 05 / 11 13:34:15 tross 50 49
c variabili non inizializzate
e
s 00001 / 00001 / 03619
d D 1.49 96 / 04 / 10 02:05:56 tross 49 48
c rop_zoom_out_rgb_rgbm(con baco corretto)
e
s 00112 / 00001 / 03508
d D 1.48 96 / 04 / 10 02:01:59 tross 48 47
c
e
s 00104 / 00010 / 03405
d D 1.47 96 / 03 / 19 18:04:11 tross 47 46
c rop_zoom_out_gr8_rgbm
e
s 00139 / 00010 / 03276
d D 1.46 96 / 03 / 18 20:22:38 tross 46 45
c rop_zoom_out_rgbx
e
s 00003 / 00002 / 03283
d D 1.45 96 / 02 / 08 23:16:51 tross 45 44
c mancava la rop_copy_90 RGB--> RGB_
e
s 00000 / 00002 / 03285
d D 1.44 96 / 02 / 07
18:
24:05 tross 44 43
c tolta una printf
e
s 00091 / 00000 / 03196
d D 1.43 95 / 11 / 21
16:
33:23 roberto 43 42
c Introdotta rgb to rgbm
e
s 00004 / 00001 / 03192
d D 1.42 95 / 10 / 09
14:
57:40 vinz 42 41
c aggiunti i rop_copy RAS_CM16-- > quantized type
e
s 00061 / 00042 / 03132
d D 1.41 95 / 10 / 04
18:
16:37 tross 41 40
c corretto baco di
rop_copy:fatto rop_copy_same()
e
s 00061 / 00001 / 03113
d D 1.40 95 / 10 / 04
16:
05:47 tross 40 39
c rop_[sub] image_to_raster()
e
s 00095 / 00017 / 03019
d D 1.39 95 / 10 / 04
12:
27:49 vinz 39 38
c aggiunto il rop_shrink
e
s 00007 / 00007 / 03029
d D 1.38 95 / 09 / 25
02:
26:09 tross 38 37
c corretto baco(poco visibile)nei rop_zoom_out... _rgbm()
e
s 00001 / 00004 / 03035
d D 1.37 95 / 09 / 20
15:
57:00 tross 37 36
c migliorate rop_custom_fill_cmap_ramp / buffer
e
s 00060 / 00000 / 02979
d D 1.36 95 / 09 / 19
17:
22:55 tross 36 35
c rop_custom_fill_cmap_ramp / buffer
e
s 00002 / 00006 / 02977
d D 1.35 95 / 07 / 28
21:
35:43 tross 35 34
c estetica
e
s 00004 / 00000 / 02979
d D 1.34 95 / 07 / 28
17:
17:40 grisu 34 33
c corretto un baco sull' offset della cmap
e
s 00001 / 00001 / 02978
d D 1.33 95 / 07 / 28
15:
22:33 tross 33 32
c corretto baco di un controllo in rop_fill_cmap_buffer
e
s 00119 / 00005 / 02860
d D 1.32 95 / 07 / 27
21:
36:31 tross 32 31
c rop_fill_cmap_ramp / buffer
e
s 00275 / 00022 / 02590
d D 1.31 95 / 07 / 27
00:
05:00 tross 31 30
c rop_zoom_out_cm16_rgbm, rop_zoom_out_rgbm
e
s 00003 / 00001 / 02609
d D 1.30 95 / 07 / 09
22:
23:39 tross 30 29
c messaggio in rop_zoom_out access violation
e
s 00043 / 00034 / 02567
d D 1.29 95 / 07 / 04
01:
50:38 tross 29 28
c rop_zoom_out a scacchiera, cmap_offset presottratto a varie funz
e
s 00531 / 00005 / 02070
d D 1.28 95 / 07 / 04
00:
46:11 tross 28 27
c con rop_zoom_out funzionante per cm16_rgb_
e
s 00003 / 00001 / 02072
d D 1.27 95 / 07 / 03
15:
38:32 tross 27 26
c messaggio completo in caso di access violation
e
s 00086 / 00000 / 01987
d D 1.26 94 / 12 / 28
21:
07:43 tross 26 25
c aggiunta rop_copy_90_rgbm
e
s 00043 / 00000 / 01944
d D 1.25 94 / 11 / 30
22:
03:25 tross 25 24
c aggiunto rop_add / remove_white_to / from_cmap
e
s 00001 / 00001 / 01943
d D 1.24 94 / 10 / 26
00:
28:46 tross 24 23
c corretto baco rop_copy_rgb_rgbm
e
s 00147 / 00014 / 01797
d D 1.23 94 / 09 / 16
19:
45:57 tross 23 22
c cm8
e
s 00231 / 00000 / 01580
d D 1.22 94 / 09 / 16
00:
02:27 tross 22 21
c rop_copy_90_bw / gr8_rgbm
e
s 00243 / 00027 / 01337
d D 1.21 94 / 09 / 11
20:
52:53 tross 21 20
c con rop_copy_90-- > cm16
e
s 00243 / 00000 / 01121
d D 1.20 94 / 09 / 05
23:
18:47 tross 20 19
c iniziato rop_reduce
e
s 00059 / 00000 / 01062
d D 1.19 94 / 06 / 07
07:
01:19 tross 19 18
c rop_copy WB->RGBM
e
s 00096 / 00004 / 00966
d D 1.18 94 / 06 / 01
00:
42:00 tross 18 17
c con cura dimagrante per entrare nella cassetta
e
s 00124 / 00001 / 00846
d D 1.17 94 / 04 / 29
23:
15:12 tross 17 16
c rop_copy_90_bw_gr8
e
s 00009 / 00009 / 00838
d D 1.16 94 / 04 / 14
23:
21:49 tross 16 15
c wrap((+7) / 8)
e
s 00155 / 00001 / 00692
d D 1.15 94 / 04 / 06
16:
19:14 tross 15 14
c rop_copy_90_bw piu' veloce
e
s 00273 / 00068 / 00420
d D 1.14 94 / 04 / 06
03:
25:39 tross 14 13
c rop_copy_90 pare funzionare per bw e gr8
e
s 00003 / 00003 / 00485
d D 1.13 94 / 03 / 31
19:
38:31 tross 13 12
c
e
s 00012 / 00008 / 00476
d D 1.12 94 / 03 / 30
21:
06:15 tross 12 11
c
e
s 00001 / 00001 / 00483
d D 1.11 94 / 03 / 30
20:
46:54 tross 11 10
c
e
s 00030 / 00048 / 00454
d D 1.10 94 / 03 / 30
20:
45:37 tross 10 9
c rimesso a posto il wrap(in pixel)
e
s 00007 / 00000 / 00495
d D 1.9 94 / 03 / 30
17:
30:50 tross 9 8
c rop_pixbytes
e
s 00021 / 00006 / 00474
d D 1.8 94 / 03 / 13
17:
41:53 tross 8 7
c corretto baco su rop_copy tra dimensioni diverse
e
s 00005 / 00001 / 00475
d D 1.7 94 / 03 / 11
14:
04:27 tross 7 6
c bachetto rop_copy, per 3.01j
e
s 00187 / 00001 / 00289
d D 1.6 94 / 03 / 11
13:
48:45 tross 6 5
c per 3.01j
e
s 00024 / 00027 / 00266
d D 1.5 94 / 03 / 02
15:
14:56 tross 5 4
c cmap per copy bw->cm16 sempre lunga 256
e
s 00125 / 00008 / 00168
d D 1.4 94 / 02 / 28
15:
53:37 tross 4 3
c rop_copy per RAS_BW e RAS_WB
e
s 00002 / 00000 / 00174
d D 1.3 94 / 02 / 19
22:
17:18 tross 3 2
c per fullwarn su os_4
e
s 00024 / 00019 / 00150
d D 1.2 94 / 02 / 10
14:
04:52 tross 2 1
c cambiati i RAS_
e
s 00169 / 00000 / 00000
d D 1.1 94 / 02 / 04
22:
02:58 tross 1 0
c date and time created 94 / 02 / 04
22:
02:58 by tross
e
u
U
f e 0
t
T
I 14
D 32
#ifdef DEBUG
#include "stopwatch.h"
#endif
E 32
E 14
I 1
#include <stdio.h>
#include <string.h>
I 40
#include <stdlib.h>
E 40
I 32
#include <assert.h>
E 32
#include "toonz.h"
I 51
#include "tmsg.h"
E 51
D 39
#include "raster.h"
E 39
I 39
D 40
#include "rasterwork.h"
E 40
I 40
#include "raster.h"
E 40
E 39
#include "raster_p.h"
I 99
#define MEMORY_PRINTF
E 99
I 32
#define STW_DISABLE
#include "stopwatch.h"
I 61
#define BUFBYTE(X, Y, BUF, BYTEWRAP, BITOFFS) \
(((UCHAR *)(BUF))[(((X) + (BITOFFS)) >> 3) + (Y) * (BYTEWRAP)])
#define GET_BIT(X, Y, BUF, BYTEWRAP, BITOFFS) \
((BUFBYTE(X, Y, BUF, BYTEWRAP, BITOFFS) >> (7 - (((X) + (BITOFFS)) & 7))) & \
(UCHAR)1)
#define SET_BIT_0(X, Y, BUF, BYTEWRAP, BITOFFS) \
(BUFBYTE(X, Y, BUF, BYTEWRAP, BITOFFS) &= \
~(1 << (7 - (((X) + (BITOFFS)) & 7))))
#define SET_BIT_1(X, Y, BUF, BYTEWRAP, BITOFFS) \
(BUFBYTE(X, Y, BUF, BYTEWRAP, BITOFFS) |= \
(1 << (7 - (((X) + (BITOFFS)) & 7))))
#define BITCPY(XO, YO, BUFO, BYTEWRAPO, BITOFFSO, XI, YI, BUFI, BYTEWRAPI, \
BITOFFSI) \
{ \
if (GET_BIT(XI, YI, BUFI, BYTEWRAPI, BITOFFSI)) \
SET_BIT_1(XO, YO, BUFO, BYTEWRAPO, BITOFFSO); \
else \
SET_BIT_0(XO, YO, BUFO, BYTEWRAPO, BITOFFSO); \
}
I 62
#define GET_BWBIT(BIT, BUF) (((BUF)[(BIT) >> 3] >> (7 - ((BIT)&7))) & 1)
I 84
#define MAGICFAC (257U * 256U + 1U)
#define MAP24 PIX_CM24_PENMAP_COLMAP_TO_RGBM
#define MAP24_64 PIX_CM24_PENMAP_COLMAP_TO_RGBM64
I 95
#define PIX_RGB16_FROM_USHORT(R, G, B) \
(((((R)*BYTE_FROM_USHORT_MAGICFAC) + (1 << 23)) >> 16) & 0xf800 | \
((((G)*BYTE_FROM_USHORT_MAGICFAC) + (1 << 23)) >> 21) & 0x07e0 | \
((((B)*BYTE_FROM_USHORT_MAGICFAC) + (1 << 23)) >> 27))
D 96
#define PIX_RGB16_FROM_RGBX64(L) (PIX_RGB16_FROM_USHORT((L).r, (L).g, (L).b))
E 96
I 96
#define PIX_XRGB1555_FROM_USHORT(R, G, B) \
(((((R)*BYTE_FROM_USHORT_MAGICFAC) + (1 << 23)) >> 17) & 0x7c00 | \
((((G)*BYTE_FROM_USHORT_MAGICFAC) + (1 << 23)) >> 22) & 0x03e0 | \
((((B)*BYTE_FROM_USHORT_MAGICFAC) + (1 << 23)) >> 27))
E 96
I 96
#define PIX_RGB16_FROM_RGBX64(L) (PIX_RGB16_FROM_USHORT((L).r, (L).g, (L).b))
#define PIX_XRGB1555_FROM_RGBX64(L) \
(PIX_XRGB1555_FROM_USHORT((L).r, (L).g, (L).b))
E 96
E 95
E 84
I 66
D 74
E 74
E 66
E 62
/*---------------------------------------------------------------------------*/
E 61
D 52
E 52
E 32
I 6
D 14
/* TOGLIERE QUESTA ROBA (chiedere a Walter) */
E 14 static void rop_copy_90_bw(RASTER *rin, RASTER *rout, int x1, int y1,
int x2, int y2, int newx, int newy,
D 14 int ninety, int flip);
E 14
I 14
int mirror, int ninety);
E 14 static void rop_copy_90_gr8(RASTER *rin, RASTER *rout, int x1, int y1,
int x2, int y2, int newx, int newy,
D 14 int ninety, int flip);
E 14
I 14
int mirror, int ninety);
I 21 static void rop_copy_90_gr8_cm16(RASTER *rin, RASTER *rout, int x1,
int y1, int x2, int y2, int newx,
int newy, int mirror, int ninety);
I 84 static void rop_copy_90_gr8_cm24(RASTER *rin, RASTER *rout, int x1,
int y1, int x2, int y2, int newx,
int newy, int mirror, int ninety);
E 84
I 22 static void rop_copy_90_gr8_rgbm(RASTER *rin, RASTER *rout, int x1,
int y1, int x2, int y2, int newx,
int newy, int mirror, int ninety);
I 55 static void rop_copy_90_gr8_rgb16(RASTER *rin, RASTER *rout, int x1,
int y1, int x2, int y2, int newx,
int newy, int mirror, int ninety);
E 55
I 23 static void rop_copy_90_cm8_cm16(RASTER *rin, RASTER *rout, int x1,
int y1, int x2, int y2, int newx,
int newy, int mirror, int ninety);
I 84 static void rop_copy_90_cm8_cm24(RASTER *rin, RASTER *rout, int x1,
int y1, int x2, int y2, int newx,
int newy, int mirror, int ninety);
E 84
E 23
E 22
E 21
I 17 static void rop_copy_90_bw_gr8(RASTER *rin, RASTER *rout, int x1, int y1,
int x2, int y2, int newx, int newy,
int mirror, int ninety);
I 21 static void rop_copy_90_bw_cm16(RASTER *rin, RASTER *rout, int x1, int y1,
int x2, int y2, int newx, int newy,
int mirror, int ninety);
I 84 static void rop_copy_90_bw_cm24(RASTER *rin, RASTER *rout, int x1, int y1,
int x2, int y2, int newx, int newy,
int mirror, int ninety);
E 84
I 55 static void rop_copy_90_bw_rgb16(RASTER *rin, RASTER *rout, int x1,
int y1, int x2, int y2, int newx,
int newy, int mirror, int ninety);
E 55
I 22 static void rop_copy_90_bw_rgbm(RASTER *rin, RASTER *rout, int x1,
int y1, int x2, int y2, int newx,
int newy, int mirror, int ninety);
I 26 static void rop_copy_90_rgbm(RASTER *rin, RASTER *rout, int x1, int y1,
int x2, int y2, int newx, int newy,
int mirror, int ninety);
I 63 static void rop_copy_90_rgb_rgb16(RASTER *rin, RASTER *rout, int x1,
int y1, int x2, int y2, int newx,
int newy, int mirror, int ninety);
E 63
I 43 static void rop_copy_90_rgb_rgbm(RASTER *rin, RASTER *rout, int x1,
int y1, int x2, int y2, int newx,
int newy, int mirror, int ninety);
E 43
I 40
I 104 static void rop_copy_bw(RASTER *rin, RASTER *rout, int x1, int y1,
int x2, int y2, int newx, int newy);
E 104
/*---------------------------------------------------------------------------*/
I 88
D 89 static LPIXEL
rop_premult(LPIXEL color) {
UINT m, mm;
LPIXEL new_color;
m = color.m;
if (m == 255)
new_color = color;
else if (m == 0) {
new_color.r = 0;
new_color.g = 0;
new_color.b = 0;
new_color.m = 0;
} else {
mm = m * MAGICFAC;
new_color.r = (color.r * mm + (1U << 23)) >> 24;
new_color.g = (color.g * mm + (1U << 23)) >> 24;
new_color.b = (color.b * mm + (1U << 23)) >> 24;
new_color.m = m;
}
return new_color;
}
/*---------------------------------------------------------------------------*/
E 89
E 88
D 79 void rop_image_to_raster(IMAGE *img, RASTER *ras, int build_cmap)
E 79
I 79 void rop_image_to_raster(IMAGE *img, RASTER *ras, int get_cmap)
E 79 {
rop_subimage_to_raster(img, 0, 0, img->pixmap.xsize - 1,
img->pixmap.ysize - 1,
D 79 ras, build_cmap);
E 79
I 79
ras, get_cmap);
E 79
}
/*---------------------------------------------------------------------------*/
void rop_subimage_to_raster (IMAGE *img,
int img_x0, int img_y0, int img_x1, int img_y1,
D 79
RASTER *ras, int build_cmap)
E 79
I 79
RASTER *ras, int get_cmap)
E 79
{
int i;
NOT_LESS_THAN(0, img_x0)
NOT_LESS_THAN(0, img_y0)
NOT_MORE_THAN(img->pixmap.xsize - 1, img_x1)
NOT_MORE_THAN(img->pixmap.ysize - 1, img_y1)
assert(img_x0 <= img_x1);
assert(img_y0 <= img_y1);
memset(ras, 0, sizeof(*ras));
switch (img->type) {
CASE CMAPPED : ras->type = RAS_CM16;
D 76 ras->buffer = (USHORT *)img->pixmap.buffer + img_x0
E 76
I 76 ras->native_buffer = ras->buffer = (USHORT *)img->pixmap.buffer + img_x0
E 76 + img_y0 * img->pixmap.xsize;
I 84 CASE CMAPPED24 : ras->type = RAS_CM24;
ras->native_buffer = ras->buffer =
(ULONG *)img->pixmap.buffer + img_x0 + img_y0 * img->pixmap.xsize;
E 84 CASE RGB : ras->type = RAS_RGBM;
D 76 ras->buffer = (ULONG *)img->pixmap.buffer + img_x0
E 76
I 76
D 94 ras->native_buffer = ras->buffer = (ULONG *)img->pixmap.buffer + img_x0
E 94
I 94 ras->native_buffer = ras->buffer = (LPIXEL *)img->pixmap.buffer + img_x0
E 94
E 76 + img_y0 * img->pixmap.xsize;
I 94 CASE RGB64 : ras->type = RAS_RGBM64;
ras->native_buffer = ras->buffer =
(SPIXEL *)img->pixmap.buffer + img_x0 + img_y0 * img->pixmap.xsize;
E 94
D 78 DEFAULT : assert(FALSE);
E 78
I 78 DEFAULT : abort();
E 78
}
I 89 ras->extra_mask = img->pixmap.extra_mask;
if (img->type != CMAPPED24 && img->pixmap.extra_mask)
ras->native_extra = ras->extra =
img->pixmap.extra + img_x0 + img_y0 * img->pixmap.xsize;
else
ras->native_extra = ras->extra = NIL;
E 89 ras->wrap = img->pixmap.xsize;
ras->lx = img_x1 - img_x0 + 1;
ras->ly = img_y1 - img_y0 + 1;
D 56 ras->glob_matte = 0xff;
if (ras->type == RAS_CM16)
E 56
I 56
D 84 if (ras->type == RAS_CM8 || ras->type == RAS_CM16)
E 84
I 84 if (ras->type == RAS_CM8 || ras->type == RAS_CM16 ||
ras->type == RAS_CM24)
E 84
E 56 {
D 56 ras->cmap.offset = img->cmap.offset;
ras->cmap.size = img->cmap.size;
E 56
I 56
D 82 ras->cmap.size = img->cmap.size;
E 82 ras->cmap.info = img->cmap.info;
E 56
D 79 if (build_cmap) {
TMALLOC(ras->cmap.buffer, ras->cmap.size)
for (i = 0; i < ras->cmap.size; i++) {
D 60 ras->cmap.buffer[i].r = img->cmap.buffer[i].red;
ras->cmap.buffer[i].g = img->cmap.buffer[i].green;
ras->cmap.buffer[i].b = img->cmap.buffer[i].blue;
ras->cmap.buffer[i].m = img->cmap.buffer[i].matte;
E 60
I 60 ras->cmap.buffer[i].r = img->cmap.buffer[i].r;
ras->cmap.buffer[i].g = img->cmap.buffer[i].g;
ras->cmap.buffer[i].b = img->cmap.buffer[i].b;
ras->cmap.buffer[i].m = img->cmap.buffer[i].m;
E 60
}
}
E 79
I 79 if (get_cmap)
D 84 ras->cmap.buffer = img->cmap.buffer;
E 84
I 84 {
ras->cmap.buffer = img->cmap.buffer;
ras->cmap.penbuffer = img->cmap.penbuffer;
ras->cmap.colbuffer = img->cmap.colbuffer;
}
E 84
E 79 else D 84 ras->cmap.buffer = NIL;
E 84
I 84 {
ras->cmap.buffer = NIL;
ras->cmap.penbuffer = NIL;
ras->cmap.colbuffer = NIL;
}
E 84
}
}
E 40
E 26
E 22
E 21
E 17
E 14
E 6
/*---------------------------------------------------------------------------*/
I 88
/* ATTENZIONE !!!!! Esiste una copia esatta di questa func
in sources/util/image/timage/timg.c, per evitare che la image dipenda dalla
raster; ogni modifica di questa va anche riportata li'. Vincenzo */
E 88 int
rop_pixbits(RAS_TYPE rastertype) {
D 2
/* attenzione: appena entra il primo tipo non multiplo di 8 bits
* tutto il codice di questo pacchetto va ricontrollato da cima a fondo
*/
E 2 switch (rastertype) {
D 2 CASE RAS_BW : return 8;
CASE RAS_CM : return 16;
E 2
I 2
D 39 CASE RAS_BW : return 1;
CASE RAS_WB : return 1;
CASE RAS_GR8 : return 8;
I 23 CASE RAS_CM8 : return 8;
E 23 CASE RAS_CM16 : return 16;
CASE RAS_RGB : return 24;
CASE RAS_RGB_ : return 32;
E 2 CASE RAS_RGBM : return 32;
E 39
I 39 CASE RAS_BW : return 1;
CASE RAS_MBW16 : return 16;
CASE RAS_WB : return 1;
CASE RAS_GR8 : return 8;
I 90 CASE RAS_GR16 : return 16;
E 90 CASE RAS_CM8 : return 8;
D 83 CASE RAS_UNICM8 : return 8;
E 83
I 72 CASE RAS_CM8S8 : return 8;
CASE RAS_CM8S4 : return 8;
E 72 CASE RAS_CM16 : return 16;
I 98 CASE RAS_CM16S12 : return 16;
E 98
D 83 CASE RAS_UNICM16 : return 16;
I 53 CASE RAS_RGB16 : return 16;
E 83
I 72 CASE RAS_CM16S8 : return 16;
CASE RAS_CM16S4 : return 16;
I 84 CASE RAS_CM24 : return 32;
E 84
I 83 CASE RAS_RGB16 : return 16;
I 96
D 97 CASE RAS_XRGB1555 : return 16;
E 97
I 97 CASE RAS_RLEBW : return 1;
E 97
E 96
E 83
E 72
E 53 CASE RAS_RGB : return 24;
CASE RAS_RGB_ : return 32;
CASE RAS_RGBM : return 32;
I 58 CASE RAS_RGBM64 : return 64;
CASE RAS_RGB_64 : return 64;
E 58
E 39 DEFAULT : msg(MSG_IE, "rop_pixbits: invalid rastertype");
}
I 3 return 0;
E 3
}
I 39
E 39
/*---------------------------------------------------------------------------*/
I 9 int
rop_pixbytes(RAS_TYPE rastertype) {
return (rop_pixbits(rastertype) + 7) >> 3;
}
/*---------------------------------------------------------------------------*/
E 9 int rop_fillerbits(RAS_TYPE rastertype) {
switch (rastertype) {
D 2 CASE RAS_BW : return FALSE;
CASE RAS_CM : return FALSE;
E 2
I 2
D 39 CASE RAS_BW : return TRUE;
CASE RAS_WB : return TRUE;
CASE RAS_GR8 : return FALSE;
I 23 CASE RAS_CM8 : return FALSE;
E 23 CASE RAS_CM16 : return FALSE;
CASE RAS_RGB : return FALSE;
CASE RAS_RGB_ : return FALSE;
E 2 CASE RAS_RGBM : return FALSE;
E 39
I 39
D 84 CASE RAS_BW : return TRUE;
CASE RAS_WB : return TRUE;
CASE RAS_MBW16 : return FALSE;
CASE RAS_GR8 : return FALSE;
CASE RAS_CM8 : return FALSE;
D 83 CASE RAS_UNICM8 : return FALSE;
E 83 CASE RAS_CM16 : return FALSE;
D 83 CASE RAS_UNICM16 : return FALSE;
E 83
I 53 CASE RAS_RGB16 : return FALSE;
E 53 CASE RAS_RGB : return FALSE;
CASE RAS_RGB_ : return FALSE;
CASE RAS_RGBM : return FALSE;
I 59 CASE RAS_RGBM64 : return FALSE;
E 59
E 39 DEFAULT : msg(MSG_IE, "rop_fillerbits: invalid rastertype");
E 84
I 84 CASE RAS_BW : return TRUE;
CASE RAS_WB : return TRUE;
DEFAULT:
return FALSE;
E 84
}
I 3 return 0;
E 3
}
/*---------------------------------------------------------------------------*/
I 53 RAS_TYPE rop_standard_ras_type_of_pix_type(PIX_TYPE pix_type) {
switch (pix_type) {
D 96 CASE PIX_NONE : return RAS_NONE;
CASE PIX_BW : return RAS_BW;
CASE PIX_WB : return RAS_WB;
CASE PIX_GR8 : return RAS_GR8;
CASE PIX_CM8 : return RAS_CM8;
CASE PIX_CM16 : return RAS_CM16;
I 84 CASE PIX_CM24 : return RAS_CM24;
E 84
I 72 CASE PIX_CM8S8 : return RAS_CM8S8;
CASE PIX_CM8S4 : return RAS_CM8S4;
CASE PIX_CM16S8 : return RAS_CM16S8;
CASE PIX_CM16S4 : return RAS_CM16S4;
E 72 CASE PIX_RGB16 : return RAS_RGB16;
CASE PIX_RGB : return RAS_RGB;
CASE PIX_RGB_ : return RAS_RGB_;
CASE PIX_RGBM : return RAS_RGBM;
E 96
I 96 CASE PIX_NONE : return RAS_NONE;
CASE PIX_BW : return RAS_BW;
CASE PIX_WB : return RAS_WB;
CASE PIX_GR8 : return RAS_GR8;
CASE PIX_CM8 : return RAS_CM8;
CASE PIX_CM16 : return RAS_CM16;
CASE PIX_CM24 : return RAS_CM24;
CASE PIX_CM8S8 : return RAS_CM8S8;
CASE PIX_CM8S4 : return RAS_CM8S4;
I 98 CASE PIX_CM16S12 : return RAS_CM16S12;
E 98 CASE PIX_CM16S8 : return RAS_CM16S8;
CASE PIX_CM16S4 : return RAS_CM16S4;
CASE PIX_RGB16 : return RAS_RGB16;
D 97 CASE PIX_XRGB1555 : return RAS_XRGB1555;
E 97 CASE PIX_RGB : return RAS_RGB;
CASE PIX_RGB_ : return RAS_RGB_;
CASE PIX_RGBM : return RAS_RGBM;
E 96 DEFAULT :
D 63 assert(FALSE);
return RAS_NONE;
E 63
I 63
D 78 assert(FALSE);
E 78
I 78 abort();
E 78
E 63
}
I 63 return RAS_NONE;
E 63
}
/*---------------------------------------------------------------------------*/
PIX_TYPE rop_pix_type_of_ras_type(RAS_TYPE ras_type) {
switch (ras_type) {
D 96 CASE RAS_NONE : return PIX_NONE;
CASE RAS_BW : return PIX_BW;
CASE RAS_WB : return PIX_WB;
CASE RAS_GR8 : return PIX_GR8;
I 90 CASE RAS_GR16 : return PIX_RGB16;
E 90 CASE RAS_CM8 : return PIX_CM8;
CASE RAS_CM16 : return PIX_CM16;
CASE RAS_RGB16 : return PIX_RGB16;
CASE RAS_RGB : return PIX_RGB;
CASE RAS_RGB_ : return PIX_RGB_;
CASE RAS_RGBM : return PIX_RGBM;
CASE RAS_MBW16 : return PIX_BW;
D 83 CASE RAS_UNICM8 : return PIX_CM8;
CASE RAS_UNICM16 : return PIX_CM16;
E 83
I 72 CASE RAS_CM8S8 : return PIX_CM8S8;
CASE RAS_CM8S4 : return PIX_CM8S4;
CASE RAS_CM16S8 : return PIX_CM16S8;
CASE RAS_CM16S4 : return PIX_CM16S4;
I 84 CASE RAS_CM24 : return PIX_CM24;
E 96
I 96 CASE RAS_NONE : return PIX_NONE;
CASE RAS_BW : return PIX_BW;
CASE RAS_WB : return PIX_WB;
CASE RAS_GR8 : return PIX_GR8;
CASE RAS_GR16 : return PIX_RGB16;
CASE RAS_CM8 : return PIX_CM8;
CASE RAS_CM16 : return PIX_CM16;
CASE RAS_RGB16 : return PIX_RGB16;
D 97 CASE RAS_XRGB1555 : return PIX_XRGB1555;
E 97 CASE RAS_RGB : return PIX_RGB;
CASE RAS_RGB_ : return PIX_RGB_;
CASE RAS_RGBM : return PIX_RGBM;
CASE RAS_MBW16 : return PIX_BW;
CASE RAS_CM8S8 : return PIX_CM8S8;
CASE RAS_CM8S4 : return PIX_CM8S4;
I 98 CASE RAS_CM16S12 : return PIX_CM16S12;
E 98 CASE RAS_CM16S8 : return PIX_CM16S8;
CASE RAS_CM16S4 : return PIX_CM16S4;
CASE RAS_CM24 : return PIX_CM24;
E 96
E 84
E 72 DEFAULT :
D 63 assert(FALSE);
return PIX_NONE;
E 63
I 63
D 78 assert(FALSE);
E 78
I 78 abort();
E 78
E 63
}
I 63 return PIX_NONE;
E 63
}
/*---------------------------------------------------------------------------*/
I 74 void rop_premultiply(RASTER *rin, RASTER *rout) {
int x, y, wrapin, wrapout, lx, ly;
LPIXEL *in, *out, val, transp;
SPIXEL *in64, *out64, val64, transp64;
UINT m;
D 84
#define MAGICFAC (257U * 256U + 1U)
E 84
#define PREMULT(V, M) \
{ \
UINT mm = (M)*MAGICFAC; \
(V).r = ((V).r * mm + (1U << 23)) >> 24; \
(V).g = ((V).g * mm + (1U << 23)) >> 24; \
(V).b = ((V).b * mm + (1U << 23)) >> 24; \
}
#define PREMULT64(V, M) \
{ \
double mf = (double)(M) * (1.0 / 65535.0); \
(V).r = (USHORT)((double)((V).r) * mf + 0.5); \
(V).g = (USHORT)((double)((V).g) * mf + 0.5); \
(V).b = (USHORT)((double)((V).b) * mf + 0.5); \
}
assert(rin->lx == rout->lx && rin->ly == rout->ly);
wrapin = rin->wrap;
wrapout = rout->wrap;
lx = rin->lx;
ly = rin->ly;
switch (RASRAS(rin->type, rout->type)) {
CASE RASRAS(RAS_RGBM64, RAS_RGBM64)
: transp64.r = transp64.g = transp64.b = transp64.m = 0;
D 75 for (y = ly; y > 0; y--)
E 75
I 75 for (y = 0; y < ly; y++)
E 75 {
in64 = ((SPIXEL *)rin->buffer) + y * wrapin;
out64 = ((SPIXEL *)rout->buffer) + y * wrapout;
D 75 for (x = lx; x > 0; x--)
E 75
I 75 for (x = 0; x < lx; x++)
E 75 {
val64 = *in64++;
m = val64.m;
if (!m) *out64++ = transp64;
D 104 else if (m == 255U)
E 104
I 104 else if (m == 0xffff)
E 104 *out64++ = val64;
else {
PREMULT64(val64, m)
*out64++ = val64;
}
}
}
CASE RASRAS(RAS_RGBM, RAS_RGBM)
: transp.r = transp.g = transp.b = transp.m = 0;
D 75 for (y = ly; y > 0; y--)
E 75
I 75 for (y = 0; y < ly; y++)
E 75 {
in = ((LPIXEL *)rin->buffer) + y * wrapin;
out = ((LPIXEL *)rout->buffer) + y * wrapout;
D 75 for (x = lx; x > 0; x--)
E 75
I 75 for (x = 0; x < lx; x++)
E 75 {
val = *in++;
m = val.m;
if (!m)
*out++ = transp;
else if (m == 255U)
*out++ = val;
else {
PREMULT(val, m)
*out++ = val;
}
}
}
DEFAULT:
D 78 assert(FALSE);
E 78
I 78 abort();
E 78
}
I 89 if (rout->extra_mask)
rop_copy_extra(rin, rout, 0, 0, lx - 1, ly - 1, 0, 0);
E 89
}
/*---------------------------------------------------------------------------*/
E 74
E 53
I 41 static void rop_copy_same(RASTER *rin, RASTER *rout, int x1, int y1,
int x2, int y2, int newx, int newy) {
UCHAR *rowin, *rowout;
int rowsize, bytewrapin, bytewrapout, d;
int pixbits_in, pixbits_out;
int pixbytes_in, pixbytes_out;
I 104 if (((rin->type == RAS_BW) && (rout->type == RAS_BW)) ||
((rin->type == RAS_WB) && (rout->type == RAS_WB))) {
rop_copy_bw(rin, rout, x1, y1, x2, y2, newx, newy);
return;
}
E 104 pixbits_in = rop_pixbits(rin->type);
pixbytes_in = rop_pixbytes(rin->type);
pixbits_out = rop_pixbits(rout->type);
pixbytes_out = rop_pixbytes(rout->type);
/* pixsize compatibili */
assert(pixbits_in == pixbits_out);
/* per adesso niente pixel non multipli di 8 bits */
assert(!rop_fillerbits(rin->type));
assert(!rop_fillerbits(rout->type));
/* copia */
rowsize = pixbytes_in * (x2 - x1 + 1);
bytewrapin = rin->wrap * pixbytes_in;
bytewrapout = rout->wrap * pixbytes_out;
rowin = (UCHAR *)rin->buffer + y1 * bytewrapin + ((x1 * pixbits_in) >> 3);
rowout =
(UCHAR *)rout->buffer + newy * bytewrapout + ((newx * pixbits_out) >> 3);
d = y2 - y1 + 1;
while (d-- > 0) {
memmove(rowout, rowin, rowsize);
rowin += bytewrapin;
rowout += bytewrapout;
}
I 89 if (rin->type == RAS_CM24 && rout->type == RAS_CM24)
CLEAR_NEW_EXTRA_BITS_OF_RECT(rout, newx, newy, newx + x2 - x1,
newy + y2 - y1, rin)
}
/*---------------------------------------------------------------------------*/
void rop_copy_extra(RASTER *rin, RASTER *rout, int x1, int y1, int x2, int y2,
int newx, int newy) {
UCHAR *rowin, *rowout, *pixin, *pixout;
ULONG *rowin24, *rowout24, *pixin24, *pixout24;
int wrapin, wrapout, x, y, lx, ly, tmp;
if (!rout->extra_mask) return;
if (x1 > x2) {
tmp = x1;
x1 = x2;
x2 = tmp;
}
if (y1 > y2) {
tmp = y1;
y1 = y2;
y2 = tmp;
}
lx = x2 - x1 + 1;
ly = y2 - y1 + 1;
if (rin->extra_mask) {
wrapin = rin->wrap;
wrapout = rout->wrap;
if (rin->type == RAS_CM24) {
rowin24 = (ULONG *)rin->buffer + x1 + y1 * wrapin;
if (rout->type == RAS_CM24) {
rowout24 = (ULONG *)rout->buffer + newx + newy * wrapout;
for (y = 0; y < ly; y++) {
pixin24 = rowin24;
pixout24 = rowout24;
for (x = 0; x < lx; x++) {
*pixout24 = *pixout24 & 0x00ffffff | *pixin24 & 0xff000000;
pixin24++;
pixout24++;
}
rowin24 += wrapin;
rowout24 += wrapout;
}
} else {
rowout = rout->extra + newx + newy * wrapout;
for (y = 0; y < ly; y++) {
pixin24 = rowin24;
pixout = rowout;
for (x = 0; x < lx; x++) {
*pixout = (UCHAR)(*pixin24 >> 24);
pixin24++;
pixout++;
}
rowin24 += wrapin;
rowout += wrapout;
}
}
} else {
rowin = rin->extra + x1 + y1 * wrapin;
if (rout->type == RAS_CM24) {
rowout24 = (ULONG *)rout->buffer + newx + newy * wrapout;
for (y = 0; y < ly; y++) {
pixin = rowin;
pixout24 = rowout24;
for (x = 0; x < lx; x++) {
*pixout24 = *pixout24 & 0x00ffffff | *pixin << 24;
pixin++;
pixout24++;
}
rowin += wrapin;
rowout24 += wrapout;
}
} else {
rowout = rout->extra + newx + newy * wrapout;
for (y = 0; y < ly; y++) {
memmove(rowout, rowin, lx);
rowin += wrapin;
rowout += wrapout;
}
}
}
}
CLEAR_NEW_EXTRA_BITS_OF_RECT(rout, newx, newy, newx + lx - 1, newy + ly - 1,
rin)
E 89
}
/*---------------------------------------------------------------------------*/
E 41
I 18 static void rop_copy_gr8_rgbm(RASTER *rin, RASTER *rout, int x1, int y1,
int x2, int y2, int newx, int newy) {
LPIXEL *rowout, *pixout;
UCHAR *rowin, *pixin;
int wrapin, wrapout;
int x, lx, ly;
LPIXEL tmp;
lx = x2 - x1 + 1;
ly = y2 - y1 + 1;
wrapin = rin->wrap;
wrapout = rout->wrap;
rowin = (UCHAR *)rin->buffer + wrapin * y1 + x1;
rowout = (LPIXEL *)rout->buffer + wrapout * newy + newx;
while (ly-- > 0) {
pixin = rowin;
pixout = rowout;
for (x = 0; x < lx; x++) {
tmp.r = *pixin;
tmp.g = *pixin;
tmp.b = *pixin;
tmp.m = 0xff;
*pixout++ = tmp;
pixin++;
}
rowin += wrapin;
rowout += wrapout;
}
}
/*---------------------------------------------------------------------------*/
I 20
D 84 static void rop_reduce_gr8_rgbm(RASTER *rin, RASTER *rout, int x1,
int y1, int x2, int y2, int newx,
int newy, int factor) {
printf("rop_reduce_gr8_rgbm not implemented yet\n");
}
/*---------------------------------------------------------------------------*/
E 84
I 28
static void rop_zoom_out_gr8_rgbm(RASTER *rin, RASTER *rout,
D 31
int x1, int y1, int x2, int y2,
int newx, int newy, int factor)
E 31
I 31
int x1, int y1, int x2, int y2,
int newx, int newy, int abs_zoom_level)
E 31
{
D 47 printf("rop_zoom_out_gr8_rgbm not implemented yet\n");
E 47
I 47 UCHAR *rowin, *pixin, *in;
LPIXEL *rowout, *pixout, valout;
int tmp;
int wrapin, wrapout;
int x, y, lx, ly, xlast, ylast, xrest, yrest, i, j;
int factor, fac_fac_2_bits;
int fac_fac, yrest_fac, fac_xrest, yrest_xrest;
int fac_fac_2, yrest_fac_2, fac_xrest_2, yrest_xrest_2;
int fac_fac_4;
lx = x2 - x1 + 1;
ly = y2 - y1 + 1;
factor = 1 << abs_zoom_level;
D 61 xrest = lx % factor;
yrest = ly % factor;
E 61
I 61 xrest = lx & (factor - 1);
yrest = ly & (factor - 1);
E 61 xlast = x2 - xrest + 1;
ylast = y2 - yrest + 1;
fac_fac = factor * factor;
fac_fac_2 = fac_fac >> 1;
fac_fac_4 = fac_fac >> 2;
fac_fac_2_bits = 2 * abs_zoom_level - 1;
yrest_fac = yrest * factor;
yrest_fac_2 = yrest_fac >> 1;
fac_xrest = factor * xrest;
fac_xrest_2 = fac_xrest >> 1;
yrest_xrest = yrest * xrest;
yrest_xrest_2 = yrest_xrest >> 1;
wrapin = rin->wrap;
wrapout = rout->wrap;
valout.m = 0xff;
rowin = (UCHAR *)rin->buffer + wrapin * y1 + x1;
rowout = (LPIXEL *)rout->buffer + wrapout * newy + newx;
for (y = y1; y < ylast; y += factor) {
pixin = rowin;
pixout = rowout;
for (x = x1; x < xlast; x += factor) {
tmp = 0;
in = pixin;
for (j = 0; j < factor; j += 2) {
for (i = 0; i < factor; i += 2) {
tmp += *in;
in += wrapin;
in++;
tmp += *in;
in -= wrapin;
in++;
}
in += 2 * wrapin - factor;
}
valout.r = valout.g = valout.b = (tmp + fac_fac_4) >> fac_fac_2_bits;
*pixout++ = valout;
pixin += factor;
}
if (xrest) {
tmp = 0;
for (j = 0; j < factor; j++)
for (i = 0; i < xrest; i++) {
tmp += pixin[i + j * wrapin];
}
valout.r = valout.g = valout.b = (tmp + fac_xrest_2) / fac_xrest;
*pixout = valout;
}
rowin += wrapin * factor;
rowout += wrapout;
}
if (yrest) {
pixin = rowin;
pixout = rowout;
for (x = x1; x < xlast; x += factor) {
tmp = 0;
for (j = 0; j < yrest; j++)
for (i = 0; i < factor; i++) {
tmp += pixin[i + j * wrapin];
}
valout.r = valout.g = valout.b = (tmp + yrest_fac_2) / yrest_fac;
*pixout++ = valout;
pixin += factor;
}
if (xrest) {
tmp = 0;
for (j = 0; j < yrest; j++)
for (i = 0; i < xrest; i++) {
tmp += pixin[i + j * wrapin];
}
valout.r = valout.g = valout.b = (tmp + yrest_xrest_2) / yrest_xrest;
*pixout = valout;
}
}
E 47
}
/*---------------------------------------------------------------------------*/
E 28
E 20
E 18
D 2 static void rop_copy_cm_rgbm(RASTER *rin, RASTER *rout, int x1, int y1,
int x2, int y2, int newx, int newy)
E 2
I 2 static void rop_copy_cm16_rgbm(RASTER *rin, RASTER *rout, int x1, int y1,
int x2, int y2, int newx, int newy)
E 2 {
LPIXEL *rowout, *pixout, *cmap;
USHORT *rowin, *pixin;
D 18 int wrapin, wrapout, tmp, cmap_offset;
E 18
I 18
D 29 int wrapin, wrapout, cmap_offset;
E 29
I 29 int wrapin, wrapout;
E 29
E 18 int x, lx, ly;
D 84 if (!rin->cmap.buffer) {
D 2 printf("### INTERNAL ERROR - rop_copy_2_4; missing color map\n");
return;
E 2
I 2 printf("### INTERNAL ERROR - rop_copy_cm16_rgbm; missing color map\n");
return;
E 2
}
E 84
D 29 cmap = rin->cmap.buffer;
cmap_offset = rin->cmap.offset;
E 29
I 29
D 56 cmap = rin->cmap.buffer - rin->cmap.offset;
E 56
I 56 cmap = rin->cmap.buffer - rin->cmap.info.offset_mask;
E 56
E 29 lx = x2 - x1 + 1;
ly = y2 - y1 + 1;
D 8 wrapin = rin->wrap;
wrapout = rout->wrap;
E 8
I 8
D 10 if ((rin->wrap % sizeof(USHORT)) || (rout->wrap % sizeof(LPIXEL))) {
printf("### INTERNAL ERROR - rop_copy_cm16_rgbm; bad wrap\n");
return;
}
wrapin = rin->wrap / sizeof(USHORT);
wrapout = rout->wrap / sizeof(LPIXEL);
E 10
I 10 wrapin = rin->wrap;
wrapout = rout->wrap;
E 10
E 8
D 2 rowin = (USHORT *)rin->buffer + wrapin * y1 + x1;
rowout = (LPIXEL *)rout->buffer + wrapout * newy + newx;
E 2
I 2 rowin = (USHORT *)rin->buffer + wrapin * y1 + x1;
rowout = (LPIXEL *)rout->buffer + wrapout * newy + newx;
E 2
while (ly-- > 0) {
pixin = rowin;
pixout = rowout;
for (x = 0; x < lx; x++)
D 29 *pixout++ = cmap[*pixin++ - cmap_offset];
E 29
I 29 *pixout++ = cmap[*pixin++];
E 29 rowin += wrapin;
rowout += wrapout;
}
}
I 4
/*---------------------------------------------------------------------------*/
I 84 static void
rop_copy_cm24_rgbm(RASTER *rin, RASTER *rout, int x1, int y1, int x2, int y2,
int newx, int newy) {
LPIXEL *rowout, *pixout, valout, *penmap, *colmap;
ULONG *rowin, *pixin, valin;
I 89 UCHAR *exrow, *expix;
E 89 int wrapin, wrapout;
D 89 int x, lx, ly;
E 89
I 89 int x, lx, ly, lines;
E 89
penmap = rin->cmap.penbuffer;
colmap = rin->cmap.colbuffer;
lx = x2 - x1 + 1;
ly = y2 - y1 + 1;
I 89 lines = ly;
E 89 wrapin = rin->wrap;
wrapout = rout->wrap;
rowin = (ULONG *)rin->buffer + wrapin * y1 + x1;
rowout = (LPIXEL *)rout->buffer + wrapout * newy + newx;
D 89 while (ly-- > 0)
E 89
I 89 if (rin->extra_mask & rout->extra_mask)
E 89 {
D 89 pixin = rowin;
pixout = rowout;
for (x = 0; x < lx; x++) {
valin = *pixin++;
MAP24(valin, penmap, colmap, valout)
*pixout++ = valout;
}
rowin += wrapin;
rowout += wrapout;
E 89
I 89 exrow = rout->extra + wrapout * newy + newx;
while (lines-- > 0) {
pixin = rowin;
pixout = rowout;
expix = exrow;
for (x = 0; x < lx; x++) {
valin = *pixin++;
MAP24(valin, penmap, colmap, valout)
*pixout++ = valout;
*expix++ = (UCHAR)(valin >> 24);
}
rowin += wrapin;
rowout += wrapout;
exrow += wrapout;
}
E 89
}
I 89 else while (lines-- > 0) {
pixin = rowin;
pixout = rowout;
for (x = 0; x < lx; x++) {
valin = *pixin++;
MAP24(valin, penmap, colmap, valout)
*pixout++ = valout;
}
rowin += wrapin;
rowout += wrapout;
}
CLEAR_NEW_EXTRA_BITS_OF_RECT(rout, newx, newy, newx + lx - 1, newy + ly - 1,
rin)
E 89
}
/*---------------------------------------------------------------------------*/
E 84
I 58 static void rop_copy_cm16_rgbm64(RASTER *rin, RASTER *rout, int x1,
int y1, int x2, int y2, int newx,
int newy) {
SPIXEL *rowout, *pixout;
LPIXEL *cmap, src_pix;
USHORT *rowin, *pixin;
int wrapin, wrapout;
int x, lx, ly;
D 84 if (!rin->cmap.buffer) {
printf("### INTERNAL ERROR - rop_copy_cm16_rgbm; missing color map\n");
return;
}
E 84 cmap = rin->cmap.buffer - rin->cmap.info.offset_mask;
lx = x2 - x1 + 1;
ly = y2 - y1 + 1;
wrapin = rin->wrap;
wrapout = rout->wrap;
rowin = (USHORT *)rin->buffer + wrapin * y1 + x1;
rowout = (SPIXEL *)rout->buffer + wrapout * newy + newx;
while (ly-- > 0) {
pixin = rowin;
pixout = rowout;
for (x = 0; x < lx; x++) {
src_pix = cmap[*pixin++];
D 60 ROP_RGBM_TO_RGBM64(src_pix, *pixout)
E 60
I 60 PIX_RGBM_TO_RGBM64(src_pix, *pixout)
E 60 pixout++;
}
rowin += wrapin;
rowout += wrapout;
}
}
/*---------------------------------------------------------------------------*/
I 84 static void rop_copy_cm24_rgbm64(RASTER *rin, RASTER *rout, int x1,
int y1, int x2, int y2, int newx,
int newy) {
SPIXEL *rowout, *pixout, valout;
LPIXEL *penmap, *colmap;
ULONG *rowin, *pixin, valin;
I 89 UCHAR *exrow, *expix;
E 89 int wrapin, wrapout;
D 89 int x, lx, ly;
E 89
I 89 int x, lx, ly, lines;
E 89
penmap = rin->cmap.penbuffer;
colmap = rin->cmap.colbuffer;
lx = x2 - x1 + 1;
ly = y2 - y1 + 1;
I 89 lines = ly;
E 89 wrapin = rin->wrap;
wrapout = rout->wrap;
rowin = (ULONG *)rin->buffer + wrapin * y1 + x1;
rowout = (SPIXEL *)rout->buffer + wrapout * newy + newx;
D 89 while (ly-- > 0)
E 89
I 89 if (rin->extra_mask && rout->extra_mask)
E 89 {
D 89 pixin = rowin;
pixout = rowout;
for (x = 0; x < lx; x++) {
valin = *pixin++;
MAP24_64(valin, penmap, colmap, valout)
*pixout++ = valout;
}
rowin += wrapin;
rowout += wrapout;
E 89
I 89 exrow = rout->extra + wrapout * newy + newx;
while (lines-- > 0) {
pixin = rowin;
pixout = rowout;
expix = exrow;
for (x = 0; x < lx; x++) {
valin = *pixin++;
MAP24_64(valin, penmap, colmap, valout)
*pixout++ = valout;
*expix++ = (UCHAR)(valin >> 24);
}
rowin += wrapin;
rowout += wrapout;
exrow += wrapout;
}
E 89
}
I 89 else while (lines-- > 0) {
pixin = rowin;
pixout = rowout;
for (x = 0; x < lx; x++) {
valin = *pixin++;
MAP24_64(valin, penmap, colmap, valout)
*pixout++ = valout;
}
rowin += wrapin;
rowout += wrapout;
}
CLEAR_NEW_EXTRA_BITS_OF_RECT(rout, newx, newy, newx + lx - 1, newy + ly - 1,
rin)
E 89
}
/*---------------------------------------------------------------------------*/
E 84
static void rop_copy_rgbm_rgbm64(RASTER *rin, RASTER *rout,
D 65
int x1, int y1, int x2, int y2,
int newx, int newy)
E 65
I 65
int x1, int y1, int x2, int y2,
int newx, int newy)
E 65
{
SPIXEL *rowout, *pixout;
LPIXEL *rowin, *pixin;
int wrapin, wrapout;
int x, lx, ly;
lx = x2 - x1 + 1;
ly = y2 - y1 + 1;
wrapin = rin->wrap;
wrapout = rout->wrap;
rowin = (LPIXEL *)rin->buffer + wrapin * y1 + x1;
rowout = (SPIXEL *)rout->buffer + wrapout * newy + newx;
while (ly-- > 0) {
pixin = rowin;
pixout = rowout;
for (x = 0; x < lx; x++) {
D 60 ROP_RGBM_TO_RGBM64(*pixin, *pixout)
E 60
I 60 PIX_RGBM_TO_RGBM64(*pixin, *pixout)
E 60 pixin++;
pixout++;
}
rowin += wrapin;
rowout += wrapout;
}
}
/*---------------------------------------------------------------------------*/
static void rop_copy_rgbm64_rgbm(RASTER *rin, RASTER *rout,
D 65
int x1, int y1, int x2, int y2,
int newx, int newy)
E 65
I 65
int x1, int y1, int x2, int y2,
int newx, int newy)
E 65
{
LPIXEL *rowout, *pixout;
SPIXEL *rowin, *pixin;
int wrapin, wrapout;
int x, lx, ly;
I 65
D 66 UINT random_round;
#define BYTE_FROM_USHORT_CUSTOM_ROUNDED(X, R) \
((((X)*BYTE_FROM_USHORT_MAGICFAC) + (R)) >> 24)
#define RGBM64_TO_RGBM_CUSTOM_ROUNDED(S, L, R) \
{ \
(L).r = BYTE_FROM_USHORT_CUSTOM_ROUNDED((S).r, (R)); \
(L).g = BYTE_FROM_USHORT_CUSTOM_ROUNDED((S).g, (R)); \
(L).b = BYTE_FROM_USHORT_CUSTOM_ROUNDED((S).b, (R)); \
(L).m = PIX_BYTE_FROM_USHORT((S).m); \
}
E 66
D 66 tnz_random_seed(180461);
E 66
I 66 PIX_INIT_DITHER_RGBM64_TO_RGBM
E 66
E 65
lx = x2 - x1 + 1;
ly = y2 - y1 + 1;
wrapin = rin->wrap;
wrapout = rout->wrap;
rowin = (SPIXEL *)rin->buffer + wrapin * y1 + x1;
rowout = (LPIXEL *)rout->buffer + wrapout * newy + newx;
while (ly-- > 0) {
pixin = rowin;
pixout = rowout;
for (x = 0; x < lx; x++) {
D 60 ROP_RGBM64_TO_RGBM(*pixin, *pixout)
E 60
I 60
D 65 PIX_RGBM64_TO_RGBM(*pixin, *pixout)
E 65
I 65
D 66 random_round = tnz_random_uint();
random_round &= (1U << 24) - 1;
RGBM64_TO_RGBM_CUSTOM_ROUNDED(*pixin, *pixout, random_round)
E 66
I 66 PIX_DITHER_RGBM64_TO_RGBM(*pixin, *pixout)
E 66
E 65
E 60 pixin++;
pixout++;
}
rowin += wrapin;
rowout += wrapout;
}
}
/*---------------------------------------------------------------------------*/
I 95 static void rop_copy_rgbx64_rgbx(RASTER *rin, RASTER *rout, int x1,
int y1, int x2, int y2, int newx,
int newy) {
LPIXEL *rowout, *pixout;
SPIXEL *rowin, *pixin;
int wrapin, wrapout;
int x, lx, ly;
UINT random_round;
PIX_INIT_DITHER_RGBM64_TO_RGBM
lx = x2 - x1 + 1;
ly = y2 - y1 + 1;
wrapin = rin->wrap;
wrapout = rout->wrap;
rowin = (SPIXEL *)rin->buffer + wrapin * y1 + x1;
rowout = (LPIXEL *)rout->buffer + wrapout * newy + newx;
while (ly-- > 0) {
pixin = rowin;
pixout = rowout;
for (x = 0; x < lx; x++) {
random_round = tnz_random_uint() & ((1U << 24) - 1);
pixout->r = PIX_DITHER_BYTE_FROM_USHORT(pixin->r, random_round);
pixout->g = PIX_DITHER_BYTE_FROM_USHORT(pixin->g, random_round);
pixout->b = PIX_DITHER_BYTE_FROM_USHORT(pixin->b, random_round);
pixout->m = 0xff;
pixin++;
pixout++;
}
rowin += wrapin;
rowout += wrapout;
}
}
/*---------------------------------------------------------------------------*/
E 95
E 58
I 20
D 84 static void rop_reduce_cm16_rgbm(RASTER *rin, RASTER *rout, int x1,
int y1, int x2, int y2, int newx,
int newy, int factor)
E 84
I 84 static void rop_zoom_out_cm16_rgbm(RASTER *rin, RASTER *rout, int x1,
int y1, int x2, int y2, int newx,
int newy, int abs_zoom_level)
E 84 {
D 28 printf("rop_reduce_cm16_rgbm not implemented yet\n");
E 28
I 28
D 84 USHORT *rowin, *pixin;
E 84
I 84 USHORT *rowin, *pixin, *in;
E 84 LPIXEL *rowout, *pixout, *cmap, valin, valout;
int tmp_r, tmp_g, tmp_b, tmp_m;
D 29 int wrapin, wrapout, cmap_offset;
E 29
I 29 int wrapin, wrapout;
E 29 int x, y, lx, ly, xlast, ylast, xrest, yrest, i, j;
I 84 int factor, fac_fac_2_bits;
E 84 int fac_fac, yrest_fac, fac_xrest, yrest_xrest;
int fac_fac_2, yrest_fac_2, fac_xrest_2, yrest_xrest_2;
I 84 int fac_fac_4;
E 84
D 29 cmap = rin->cmap.buffer;
cmap_offset = rin->cmap.offset;
E 29
I 29
D 56 cmap = rin->cmap.buffer - rin->cmap.offset;
E 56
I 56 cmap = rin->cmap.buffer - rin->cmap.info.offset_mask;
E 56
E 29 lx = x2 - x1 + 1;
ly = y2 - y1 + 1;
I 84 factor = 1 << abs_zoom_level;
E 84
D 61 xrest = lx % factor;
yrest = ly % factor;
E 61
I 61 xrest = lx & (factor - 1);
yrest = ly & (factor - 1);
E 61 xlast = x2 - xrest + 1;
ylast = y2 - yrest + 1;
fac_fac = factor * factor;
fac_fac_2 = fac_fac >> 1;
I 84 fac_fac_4 = fac_fac >> 2;
fac_fac_2_bits = 2 * abs_zoom_level - 1;
E 84 yrest_fac = yrest * factor;
yrest_fac_2 = yrest_fac >> 1;
fac_xrest = factor * xrest;
fac_xrest_2 = fac_xrest >> 1;
yrest_xrest = yrest * xrest;
yrest_xrest_2 = yrest_xrest >> 1;
wrapin = rin->wrap;
wrapout = rout->wrap;
I 84 valout.m = 0xff;
E 84
rowin = (USHORT *)rin->buffer + wrapin * y1 + x1;
rowout = (LPIXEL *)rout->buffer + wrapout * newy + newx;
for (y = y1; y < ylast; y += factor) {
pixin = rowin;
pixout = rowout;
for (x = x1; x < xlast; x += factor) {
tmp_r = tmp_g = tmp_b = tmp_m = 0;
D 84 for (j = 0; j < factor; j++) for (i = 0; i < factor; i++)
E 84
I 84 in = pixin;
for (j = 0; j < factor; j += 2) {
for (i = 0; i < factor; i += 2)
E 84 {
D 29 valin = cmap[pixin[i + j * wrapin] - cmap_offset];
E 29
I 29
D 84 valin = cmap[pixin[i + j * wrapin]];
E 84
I 84 valin = cmap[*in];
tmp_r += valin.r;
tmp_g += valin.g;
tmp_b += valin.b;
tmp_m += valin.m;
in += wrapin;
in++;
valin = cmap[*in];
E 84
E 29 tmp_r += valin.r;
tmp_g += valin.g;
tmp_b += valin.b;
tmp_m += valin.m;
I 84 in -= wrapin;
in++;
E 84
}
D 84 valout.r = (tmp_r + fac_fac_2) / fac_fac;
valout.g = (tmp_g + fac_fac_2) / fac_fac;
valout.b = (tmp_b + fac_fac_2) / fac_fac;
valout.m = (tmp_m + fac_fac_2) / fac_fac;
E 84
I 84 in += 2 * wrapin - factor;
}
valout.r = (tmp_r + fac_fac_4) >> fac_fac_2_bits;
valout.g = (tmp_g + fac_fac_4) >> fac_fac_2_bits;
valout.b = (tmp_b + fac_fac_4) >> fac_fac_2_bits;
valout.m = (tmp_m + fac_fac_4) >> fac_fac_2_bits;
E 84 *pixout++ = valout;
pixin += factor;
}
if (xrest) {
tmp_r = tmp_g = tmp_b = tmp_m = 0;
for (j = 0; j < factor; j++)
for (i = 0; i < xrest; i++) {
D 29 valin = cmap[pixin[i + j * wrapin] - cmap_offset];
E 29
I 29 valin = cmap[pixin[i + j * wrapin]];
E 29 tmp_r += valin.r;
tmp_g += valin.g;
tmp_b += valin.b;
tmp_m += valin.m;
}
valout.r = (tmp_r + fac_xrest_2) / fac_xrest;
valout.g = (tmp_g + fac_xrest_2) / fac_xrest;
valout.b = (tmp_b + fac_xrest_2) / fac_xrest;
valout.m = (tmp_m + fac_xrest_2) / fac_xrest;
*pixout = valout;
}
rowin += wrapin * factor;
rowout += wrapout;
}
if (yrest) {
pixin = rowin;
pixout = rowout;
for (x = x1; x < xlast; x += factor) {
tmp_r = tmp_g = tmp_b = tmp_m = 0;
for (j = 0; j < yrest; j++)
for (i = 0; i < factor; i++) {
D 29 valin = cmap[pixin[i + j * wrapin] - cmap_offset];
E 29
I 29 valin = cmap[pixin[i + j * wrapin]];
E 29 tmp_r += valin.r;
tmp_g += valin.g;
tmp_b += valin.b;
tmp_m += valin.m;
}
valout.r = (tmp_r + yrest_fac_2) / yrest_fac;
valout.g = (tmp_g + yrest_fac_2) / yrest_fac;
valout.b = (tmp_b + yrest_fac_2) / yrest_fac;
valout.m = (tmp_m + yrest_fac_2) / yrest_fac;
*pixout++ = valout;
pixin += factor;
}
if (xrest) {
tmp_r = tmp_g = tmp_b = tmp_m = 0;
for (j = 0; j < yrest; j++)
for (i = 0; i < xrest; i++) {
D 29 valin = cmap[pixin[i + j * wrapin] - cmap_offset];
E 29
I 29 valin = cmap[pixin[i + j * wrapin]];
E 29 tmp_r += valin.r;
tmp_g += valin.g;
tmp_b += valin.b;
tmp_m += valin.m;
}
valout.r = (tmp_r + yrest_xrest_2) / yrest_xrest;
valout.g = (tmp_g + yrest_xrest_2) / yrest_xrest;
valout.b = (tmp_b + yrest_xrest_2) / yrest_xrest;
valout.m = (tmp_m + yrest_xrest_2) / yrest_xrest;
*pixout = valout;
}
}
}
/*---------------------------------------------------------------------------*/
D 84 static void rop_zoom_out_cm16_rgbm(RASTER *rin, RASTER *rout,
E 84
I 84 static void rop_zoom_out_cm24_rgbm(RASTER *rin, RASTER *rout,
E 84
D 31 int x1, int y1, int x2, int y2, int newx, int newy, int factor)
E 31
I 31 int x1, int y1, int x2, int y2, int newx, int newy, int abs_zoom_level)
E 31 {
D 31 printf(" rop_zoom_out_cm16_rgbm not implemented yet\n");
E 31
I 31
D 84 USHORT *rowin, *pixin, *in;
LPIXEL *rowout, *pixout, *cmap, valin, valout;
E 84
I 84 ULONG *rowin, *pixin, *in, win;
LPIXEL *rowout, *pixout, *penmap, *colmap, valin, valout;
E 84 int tmp_r, tmp_g, tmp_b, tmp_m;
int wrapin, wrapout;
int x, y, lx, ly, xlast, ylast, xrest, yrest, i, j;
int factor, fac_fac_2_bits;
int fac_fac, yrest_fac, fac_xrest, yrest_xrest;
int fac_fac_2, yrest_fac_2, fac_xrest_2, yrest_xrest_2;
int fac_fac_4;
D 56 cmap = rin->cmap.buffer - rin->cmap.offset;
E 56
I 56
D 84 cmap = rin->cmap.buffer - rin->cmap.info.offset_mask;
E 84
I 84 penmap = rin->cmap.penbuffer;
colmap = rin->cmap.colbuffer;
E 84
E 56 lx = x2 - x1 + 1;
ly = y2 - y1 + 1;
factor = 1 << abs_zoom_level;
D 61 xrest = lx % factor;
yrest = ly % factor;
E 61
I 61 xrest = lx & (factor - 1);
yrest = ly & (factor - 1);
E 61 xlast = x2 - xrest + 1;
ylast = y2 - yrest + 1;
fac_fac = factor * factor;
fac_fac_2 = fac_fac >> 1;
fac_fac_4 = fac_fac >> 2;
fac_fac_2_bits = 2 * abs_zoom_level - 1;
yrest_fac = yrest * factor;
yrest_fac_2 = yrest_fac >> 1;
fac_xrest = factor * xrest;
fac_xrest_2 = fac_xrest >> 1;
yrest_xrest = yrest * xrest;
yrest_xrest_2 = yrest_xrest >> 1;
wrapin = rin->wrap;
wrapout = rout->wrap;
valout.m = 0xff;
D 84 rowin = (USHORT *)rin->buffer + wrapin * y1 + x1;
E 84
I 84 rowin = (ULONG *)rin->buffer + wrapin * y1 + x1;
E 84 rowout = (LPIXEL *)rout->buffer + wrapout * newy + newx;
for (y = y1; y < ylast; y += factor) {
pixin = rowin;
pixout = rowout;
for (x = x1; x < xlast; x += factor) {
tmp_r = tmp_g = tmp_b = tmp_m = 0;
in = pixin;
for (j = 0; j < factor; j += 2) {
for (i = 0; i < factor; i += 2) {
D 84 valin = cmap[*in];
E 84
I 84 win = *in;
MAP24(win, penmap, colmap, valin)
E 84 tmp_r += valin.r;
tmp_g += valin.g;
tmp_b += valin.b;
tmp_m += valin.m;
D 38 in += factor;
in++;
E 38
I 38 in += wrapin;
in++;
E 38
D 84 valin = cmap[*in];
E 84
I 84 win = *in;
MAP24(win, penmap, colmap, valin)
E 84 tmp_r += valin.r;
tmp_g += valin.g;
tmp_b += valin.b;
tmp_m += valin.m;
D 38 in -= factor;
E 38
I 38 in -= wrapin;
E 38 in++;
}
in += 2 * wrapin - factor;
}
valout.r = (tmp_r + fac_fac_4) >> fac_fac_2_bits;
valout.g = (tmp_g + fac_fac_4) >> fac_fac_2_bits;
valout.b = (tmp_b + fac_fac_4) >> fac_fac_2_bits;
valout.m = (tmp_m + fac_fac_4) >> fac_fac_2_bits;
*pixout++ = valout;
pixin += factor;
}
if (xrest) {
tmp_r = tmp_g = tmp_b = tmp_m = 0;
for (j = 0; j < factor; j++)
for (i = 0; i < xrest; i++) {
D 84 valin = cmap[pixin[i + j * wrapin]];
E 84
I 84 win = pixin[i + j * wrapin];
MAP24(win, penmap, colmap, valin)
E 84 tmp_r += valin.r;
tmp_g += valin.g;
tmp_b += valin.b;
tmp_m += valin.m;
}
valout.r = (tmp_r + fac_xrest_2) / fac_xrest;
valout.g = (tmp_g + fac_xrest_2) / fac_xrest;
valout.b = (tmp_b + fac_xrest_2) / fac_xrest;
valout.m = (tmp_m + fac_xrest_2) / fac_xrest;
*pixout = valout;
}
rowin += wrapin * factor;
rowout += wrapout;
}
if (yrest) {
pixin = rowin;
pixout = rowout;
for (x = x1; x < xlast; x += factor) {
tmp_r = tmp_g = tmp_b = tmp_m = 0;
for (j = 0; j < yrest; j++)
for (i = 0; i < factor; i++) {
D 84 valin = cmap[pixin[i + j * wrapin]];
E 84
I 84 win = pixin[i + j * wrapin];
MAP24(win, penmap, colmap, valin)
E 84 tmp_r += valin.r;
tmp_g += valin.g;
tmp_b += valin.b;
tmp_m += valin.m;
}
valout.r = (tmp_r + yrest_fac_2) / yrest_fac;
valout.g = (tmp_g + yrest_fac_2) / yrest_fac;
valout.b = (tmp_b + yrest_fac_2) / yrest_fac;
valout.m = (tmp_m + yrest_fac_2) / yrest_fac;
*pixout++ = valout;
pixin += factor;
}
if (xrest) {
tmp_r = tmp_g = tmp_b = tmp_m = 0;
for (j = 0; j < yrest; j++)
for (i = 0; i < xrest; i++) {
D 84 valin = cmap[pixin[i + j * wrapin]];
E 84
I 84 win = pixin[i + j * wrapin];
MAP24(win, penmap, colmap, valin)
E 84 tmp_r += valin.r;
tmp_g += valin.g;
tmp_b += valin.b;
tmp_m += valin.m;
}
valout.r = (tmp_r + yrest_xrest_2) / yrest_xrest;
valout.g = (tmp_g + yrest_xrest_2) / yrest_xrest;
valout.b = (tmp_b + yrest_xrest_2) / yrest_xrest;
valout.m = (tmp_m + yrest_xrest_2) / yrest_xrest;
*pixout = valout;
}
}
E 31
}
/*---------------------------------------------------------------------------*/
D 46 static void rop_reduce_cm16_rgb_(RASTER *rin, RASTER *rout,
E 46
I 46
D 84 static void rop_reduce_cm16_rgbx(RASTER *rin, RASTER *rout,
E 46 int x1, int y1, int x2, int y2,
int newx, int newy, int factor)
E 84
I 84 static void rop_zoom_out_cm16_rgbx(RASTER *rin, RASTER *rout,
int x1, int y1, int x2, int y2,
int newx, int newy, int abs_zoom_level)
E 84 {
D 84 USHORT *rowin, *pixin;
E 84
I 84 USHORT *rowin, *pixin, *in;
E 84 LPIXEL *rowout, *pixout, *cmap, valin, valout;
D 84 int tmp_r, tmp_g, tmp_b, tmp_m;
E 84
I 84 int tmp_r, tmp_g, tmp_b;
E 84
D 29 int wrapin, wrapout, cmap_offset;
E 29
I 29 int wrapin, wrapout;
E 29 int x, y, lx, ly, xlast, ylast, xrest, yrest, i, j;
I 84 int factor, fac_fac_2_bits;
E 84 int fac_fac, yrest_fac, fac_xrest, yrest_xrest;
int fac_fac_2, yrest_fac_2, fac_xrest_2, yrest_xrest_2;
I 84 int fac_fac_4;
E 84
D 29 cmap = rin->cmap.buffer;
cmap_offset = rin->cmap.offset;
E 29
I 29
D 56 cmap = rin->cmap.buffer - rin->cmap.offset;
E 56
I 56 cmap = rin->cmap.buffer - rin->cmap.info.offset_mask;
E 56
E 29 lx = x2 - x1 + 1;
ly = y2 - y1 + 1;
I 84 factor = 1 << abs_zoom_level;
E 84
D 61 xrest = lx % factor;
yrest = ly % factor;
E 61
I 61 xrest = lx & (factor - 1);
yrest = ly & (factor - 1);
E 61 xlast = x2 - xrest + 1;
ylast = y2 - yrest + 1;
fac_fac = factor * factor;
fac_fac_2 = fac_fac >> 1;
I 84 fac_fac_4 = fac_fac >> 2;
fac_fac_2_bits = 2 * abs_zoom_level - 1;
E 84 yrest_fac = yrest * factor;
yrest_fac_2 = yrest_fac >> 1;
fac_xrest = factor * xrest;
fac_xrest_2 = fac_xrest >> 1;
yrest_xrest = yrest * xrest;
yrest_xrest_2 = yrest_xrest >> 1;
wrapin = rin->wrap;
wrapout = rout->wrap;
valout.m = 0xff;
rowin = (USHORT *)rin->buffer + wrapin * y1 + x1;
rowout = (LPIXEL *)rout->buffer + wrapout * newy + newx;
for (y = y1; y < ylast; y += factor) {
pixin = rowin;
pixout = rowout;
for (x = x1; x < xlast; x += factor) {
D 84 tmp_r = tmp_g = tmp_b = tmp_m = 0;
for (j = 0; j < factor; j++)
for (i = 0; i < factor; i++)
E 84
I 84 tmp_r = tmp_g = tmp_b = 0;
in = pixin;
for (j = 0; j < factor; j += 2) {
for (i = 0; i < factor; i += 2)
E 84
{
D 29 valin = cmap[pixin[i + j * wrapin] - cmap_offset];
E 29
I 29
D 84 valin = cmap[pixin[i + j * wrapin]];
E 84
I 84 valin = cmap[*in];
tmp_r += valin.r;
tmp_g += valin.g;
tmp_b += valin.b;
in += wrapin;
in++;
valin = cmap[*in];
E 84
E 29 tmp_r += valin.r;
tmp_g += valin.g;
tmp_b += valin.b;
I 84 in -= wrapin;
in++;
E 84
}
D 84 valout.r = (tmp_r + fac_fac_2) / fac_fac;
valout.g = (tmp_g + fac_fac_2) / fac_fac;
valout.b = (tmp_b + fac_fac_2) / fac_fac;
E 84
I 84 in += 2 * wrapin - factor;
}
valout.r = (tmp_r + fac_fac_4) >> fac_fac_2_bits;
valout.g = (tmp_g + fac_fac_4) >> fac_fac_2_bits;
valout.b = (tmp_b + fac_fac_4) >> fac_fac_2_bits;
E 84
*pixout++ = valout;
pixin += factor;
}
if (xrest) {
D 84 tmp_r = tmp_g = tmp_b = tmp_m = 0;
E 84
I 84 tmp_r = tmp_g = tmp_b = 0;
E 84 for (j = 0; j < factor; j++) for (i = 0; i < xrest; i++)
{
D 29 valin = cmap[pixin[i + j * wrapin] - cmap_offset];
E 29
I 29 valin = cmap[pixin[i + j * wrapin]];
E 29 tmp_r += valin.r;
tmp_g += valin.g;
tmp_b += valin.b;
}
valout.r = (tmp_r + fac_xrest_2) / fac_xrest;
valout.g = (tmp_g + fac_xrest_2) / fac_xrest;
valout.b = (tmp_b + fac_xrest_2) / fac_xrest;
*pixout = valout;
}
rowin += wrapin * factor;
rowout += wrapout;
}
if (yrest) {
pixin = rowin;
pixout = rowout;
for (x = x1; x < xlast; x += factor) {
D 84 tmp_r = tmp_g = tmp_b = tmp_m = 0;
E 84
I 84 tmp_r = tmp_g = tmp_b = 0;
E 84 for (j = 0; j < yrest; j++) for (i = 0; i < factor; i++)
{
D 29 valin = cmap[pixin[i + j * wrapin] - cmap_offset];
E 29
I 29 valin = cmap[pixin[i + j * wrapin]];
E 29 tmp_r += valin.r;
tmp_g += valin.g;
tmp_b += valin.b;
}
valout.r = (tmp_r + yrest_fac_2) / yrest_fac;
valout.g = (tmp_g + yrest_fac_2) / yrest_fac;
valout.b = (tmp_b + yrest_fac_2) / yrest_fac;
*pixout++ = valout;
pixin += factor;
}
if (xrest) {
D 84 tmp_r = tmp_g = tmp_b = tmp_m = 0;
E 84
I 84 tmp_r = tmp_g = tmp_b = 0;
E 84 for (j = 0; j < yrest; j++) for (i = 0; i < xrest; i++)
{
D 29 valin = cmap[pixin[i + j * wrapin] - cmap_offset];
E 29
I 29 valin = cmap[pixin[i + j * wrapin]];
E 29 tmp_r += valin.r;
tmp_g += valin.g;
tmp_b += valin.b;
}
valout.r = (tmp_r + yrest_xrest_2) / yrest_xrest;
valout.g = (tmp_g + yrest_xrest_2) / yrest_xrest;
valout.b = (tmp_b + yrest_xrest_2) / yrest_xrest;
*pixout = valout;
}
}
}
/*---------------------------------------------------------------------------*/
D 46 static void rop_zoom_out_cm16_rgb_(RASTER *rin, RASTER *rout,
E 46
I 46
D 84 static void rop_zoom_out_cm16_rgbx(RASTER *rin, RASTER *rout,
E 84
I 84 static void rop_zoom_out_cm24_rgbx(RASTER *rin, RASTER *rout,
E 84
E 46 int x1, int y1, int x2, int y2, int newx, int newy, int abs_zoom_level) {
D 29
USHORT *rowin, *pixin;
E 29
I 29
D 84
USHORT *rowin, *pixin, *in;
E 29
LPIXEL *rowout, *pixout, *cmap, valin, valout;
E 84
I 84
ULONG *rowin, *pixin, *in, win;
LPIXEL *rowout, *pixout, *penmap, *colmap, valin, valout;
E 84
D 46
int tmp_r, tmp_g, tmp_b, tmp_m;
E 46
I 46
int tmp_r, tmp_g, tmp_b;
E 46
D 29
int wrapin, wrapout, cmap_offset;
E 29
I 29
int wrapin, wrapout;
E 29
int x, y, lx, ly, xlast, ylast, xrest, yrest, i, j;
D 29
int factor, fac_fac_bits;
E 29
I 29
int factor, fac_fac_2_bits;
E 29
int fac_fac , yrest_fac, fac_xrest, yrest_xrest;
int fac_fac_2, yrest_fac_2, fac_xrest_2, yrest_xrest_2;
I 29
int fac_fac_4;
E 29
D 29
cmap=rin->cmap.buffer;
cmap_offset=rin->cmap.offset;
E 29
I 29
D 56
cmap=rin->cmap.buffer - rin->cmap.offset;
E 56
I 56
D 84
cmap=rin->cmap.buffer - rin->cmap.info.offset_mask;
E 84
I 84
penmap=rin->cmap.penbuffer;
colmap=rin->cmap.colbuffer;
E 84
E 56
E 29
lx=x2-x1+1;
ly=y2-y1+1;
factor = 1 << abs_zoom_level;
D 61
xrest = lx % factor;
yrest = ly % factor;
E 61
I 61
xrest = lx & (factor - 1);
yrest = ly & (factor - 1);
E 61
xlast = x2 - xrest + 1;
ylast = y2 - yrest + 1;
fac_fac = factor * factor; fac_fac_2 = fac_fac >> 1;
D 29
fac_fac_bits= 2 * abs_zoom_level;
E 29
I 29
fac_fac_4 = fac_fac >> 2; fac_fac_2_bits= 2 * abs_zoom_level - 1;
E 29
yrest_fac = yrest * factor; yrest_fac_2 = yrest_fac >> 1;
fac_xrest = factor * xrest; fac_xrest_2 = fac_xrest >> 1;
yrest_xrest = yrest * xrest; yrest_xrest_2 = yrest_xrest >> 1;
wrapin = rin ->wrap;
wrapout = rout->wrap;
valout.m = 0xff;
D 84
rowin = (USHORT*)rin->buffer + wrapin*y1 + x1;
E 84
I 84
rowin = (ULONG *)rin->buffer + wrapin*y1 + x1;
E 84
rowout = (LPIXEL*)rout->buffer + wrapout*newy + newx;
for (y = y1; y < ylast; y += factor)
{
pixin = rowin;
pixout = rowout;
for (x = x1; x < xlast; x += factor)
{
D 46
tmp_r = tmp_g = tmp_b = tmp_m = 0;
E 46
I 46
tmp_r = tmp_g = tmp_b = 0;
E 46
D 29
for (j = 0; j < factor; j++)
for (i = 0; i < factor; i++)
E 29
I 29
in = pixin;
for (j = 0; j < factor; j+=2)
{
for (i = 0; i < factor; i+=2)
E 29
{
D 29
valin = cmap[pixin[i + j*wrapin] - cmap_offset];
E 29
I 29
D 84
valin = cmap[*in];
E 84
I 84
win = *in;
MAP24 (win, penmap, colmap, valin)
E 84
E 29
tmp_r += valin.r;
tmp_g += valin.g;
tmp_b += valin.b;
I 29
D 38
in += factor;
E 38
I 38
in += wrapin;
E 38
in++;
D 84
valin = cmap[*in];
E 84
I 84
win = *in;
MAP24 (win, penmap, colmap, valin)
E 84
tmp_r += valin.r;
tmp_g += valin.g;
tmp_b += valin.b;
D 38
in -= factor;
E 38
I 38
in -= wrapin;
E 38
in++;
E 29
}
D 29
valout.r = (tmp_r + fac_fac_2) >> fac_fac_bits;
valout.g = (tmp_g + fac_fac_2) >> fac_fac_bits;
valout.b = (tmp_b + fac_fac_2) >> fac_fac_bits;
E 29
I 29
in += 2 * wrapin - factor;
}
valout.r = (tmp_r + fac_fac_4) >> fac_fac_2_bits;
valout.g = (tmp_g + fac_fac_4) >> fac_fac_2_bits;
valout.b = (tmp_b + fac_fac_4) >> fac_fac_2_bits;
E 29
*pixout++ = valout;
pixin += factor;
}
if (xrest)
{
D 46
tmp_r = tmp_g = tmp_b = tmp_m = 0;
E 46
I 46
tmp_r = tmp_g = tmp_b = 0;
E 46
for (j = 0; j < factor; j++)
for (i = 0; i < xrest; i++)
{
D 29
valin = cmap[pixin[i + j*wrapin] - cmap_offset];
E 29
I 29
D 84
valin = cmap[pixin[i + j*wrapin]];
E 84
I 84
win = pixin[i + j*wrapin];
MAP24 (win, penmap, colmap, valin)
E 84
E 29
tmp_r += valin.r;
tmp_g += valin.g;
tmp_b += valin.b;
}
valout.r = (tmp_r + fac_xrest_2) / fac_xrest;
valout.g = (tmp_g + fac_xrest_2) / fac_xrest;
valout.b = (tmp_b + fac_xrest_2) / fac_xrest;
*pixout = valout;
}
rowin += wrapin * factor;
rowout += wrapout;
}
if (yrest)
{
pixin = rowin;
pixout = rowout;
for (x = x1; x < xlast; x += factor)
{
D 46
tmp_r = tmp_g = tmp_b = tmp_m = 0;
E 46
I 46
tmp_r = tmp_g = tmp_b = 0;
E 46
for (j = 0; j < yrest; j++)
for (i = 0; i < factor; i++)
{
D 29
valin = cmap[pixin[i + j*wrapin] - cmap_offset];
E 29
I 29
D 84
valin = cmap[pixin[i + j*wrapin]];
E 84
I 84
win = pixin[i + j*wrapin];
MAP24 (win, penmap, colmap, valin)
E 84
E 29
tmp_r += valin.r;
tmp_g += valin.g;
tmp_b += valin.b;
}
valout.r = (tmp_r + yrest_fac_2) / yrest_fac;
valout.g = (tmp_g + yrest_fac_2) / yrest_fac;
valout.b = (tmp_b + yrest_fac_2) / yrest_fac;
*pixout++ = valout;
pixin += factor;
}
if (xrest)
{
D 46
tmp_r = tmp_g = tmp_b = tmp_m = 0;
E 46
I 46
tmp_r = tmp_g = tmp_b = 0;
E 46
for (j = 0; j < yrest; j++)
for (i = 0; i < xrest; i++)
{
D 29
valin = cmap[pixin[i + j*wrapin] - cmap_offset];
E 29
I 29
D 84
valin = cmap[pixin[i + j*wrapin]];
E 84
I 84
win = pixin[i + j*wrapin];
MAP24 (win, penmap, colmap, valin)
E 84
E 29
tmp_r += valin.r;
tmp_g += valin.g;
tmp_b += valin.b;
}
valout.r = (tmp_r + yrest_xrest_2) / yrest_xrest;
valout.g = (tmp_g + yrest_xrest_2) / yrest_xrest;
valout.b = (tmp_b + yrest_xrest_2) / yrest_xrest;
*pixout = valout;
}
}
E 28 }
/*---------------------------------------------------------------------------*/
I 81 static void rop_copy_rgb_rgb16(RASTER *rin, RASTER *rout, int x1, int y1, int x2, int y2, int newx, int newy) {
USHORT *rowout, *pixout;
UCHAR *rowin, *pixin;
int bytewrapin, wrapout;
int x, lx, ly;
lx=x2-x1+1;
ly=y2-y1+1;
bytewrapin = rin ->wrap * 3;
wrapout = rout->wrap;
rowin = (UCHAR*) rin ->buffer + bytewrapin * y1 + x1 * 3;
rowout = (USHORT*)rout->buffer + wrapout * newy + newx;
while(ly-->0)
{
pixin=rowin;
pixout=rowout;
for(x=0;x<lx;x++)
{
*pixout++ = PIX_RGB16_FROM_BYTES(pixin[0], pixin[1], pixin[2]);
pixin += 3;
}
rowin+=bytewrapin;
rowout+=wrapout;
} }
/*---------------------------------------------------------------------------*/
E 81
E 20
I 18 static void rop_copy_rgb_rgbm(RASTER *rin, RASTER *rout, int x1, int y1, int x2, int y2, int newx, int newy) {
LPIXEL *rowout, *pixout;
UCHAR *rowin, *pixin;
D 81
int wrapin, wrapout;
E 81
I 81
int bytewrapin, wrapout;
E 81
int x, lx, ly;
LPIXEL tmp;
lx=x2-x1+1;
ly=y2-y1+1;
D 81
wrapin = rin ->wrap * 3;
wrapout = rout->wrap;
E 81
I 81
bytewrapin = rin ->wrap * 3;
wrapout = rout->wrap;
E 81
D 24
rowin = (UCHAR*) rin ->buffer + wrapin*y1 + x1;
E 24
I 24
D 81
rowin = (UCHAR*) rin ->buffer + wrapin*y1 + x1 * 3;
E 24
rowout = (LPIXEL*)rout->buffer + wrapout*newy + newx;
E 81
I 81
rowin = (UCHAR*) rin ->buffer + bytewrapin * y1 + x1 * 3;
rowout = (LPIXEL*)rout->buffer + wrapout * newy + newx;
E 81
I 45
tmp.m = 0xff;
E 45
while(ly-->0)
{
pixin=rowin;
pixout=rowout;
for(x=0;x<lx;x++)
{
tmp.r = *pixin++;
tmp.g = *pixin++;
tmp.b = *pixin++;
D 45
tmp.m = 0xff;
E 45
*pixout++ = tmp;
}
D 81
rowin+=wrapin;
E 81
I 81
rowin+=bytewrapin;
E 81
rowout+=wrapout;
} }
/*---------------------------------------------------------------------------*/
I 67 static void rop_copy_rgbx_rgb(RASTER *rin, RASTER *rout, int x1, int y1, int x2, int y2, int newx, int newy) {
UCHAR *rowout, *pixout;
LPIXEL *rowin, *pixin;
int wrapin, wrapout;
int x, lx, ly;
lx=x2-x1+1;
ly=y2-y1+1;
wrapin = rin ->wrap;
wrapout = rout->wrap * 3;
rowin = (LPIXEL*) rin ->buffer + wrapin*y1 + x1;
rowout = (UCHAR*)rout->buffer + wrapout*newy + newx * 3;
while(ly-->0)
{
pixin=rowin;
pixout=rowout;
for(x=0;x<lx;x++, pixin++)
{
*pixout++ = pixin->b;
*pixout++ = pixin->g;
*pixout++ = pixin->r;
}
rowin+=wrapin;
rowout+=wrapout;
} }
/*---------------------------------------------------------------------------*/
I 81
D 84 static void rop_reduce_rgb_rgb16(RASTER *rin, RASTER *rout, int x1, int y1, int x2, int y2, int newx, int newy, int factor) { printf("rop_reduce_rgb_rgb16 not implemented yet\n"); }
/*---------------------------------------------------------------------------*/
E 81
E 67
I 20 static void rop_reduce_rgb_rgbm(RASTER *rin, RASTER *rout, int x1, int y1, int x2, int y2, int newx, int newy, int factor) { printf("rop_reduce_rgb_rgbm not implemented yet\n"); }
/*---------------------------------------------------------------------------*/
E 84
I 81 static void rop_zoom_out_rgb_rgb16(RASTER *rin, RASTER *rout, int x1, int y1, int x2, int y2, int newx, int newy, int abs_zoom_level) {
UCHAR *rowin, *pixin, *in;
USHORT *rowout, *pixout;
int tmp_r, tmp_g, tmp_b;
int wrapin_pixels, wrapin_bytes, wrapout;
int x, y, lx, ly, xlast, ylast, xrest, yrest, i, j;
int factor, fac_fac_2_bits;
int fac_fac , yrest_fac, fac_xrest, yrest_xrest;
int fac_fac_2, yrest_fac_2, fac_xrest_2, yrest_xrest_2;
int fac_fac_4;
lx=x2-x1+1;
ly=y2-y1+1;
factor = 1 << abs_zoom_level;
xrest = lx & (factor - 1);
yrest = ly & (factor - 1);
xlast = x2 - xrest + 1;
ylast = y2 - yrest + 1;
fac_fac = factor * factor; fac_fac_2 = fac_fac >> 1;
fac_fac_4 = fac_fac >> 2; fac_fac_2_bits= 2 * abs_zoom_level - 1;
yrest_fac = yrest * factor; yrest_fac_2 = yrest_fac >> 1;
fac_xrest = factor * xrest; fac_xrest_2 = fac_xrest >> 1;
yrest_xrest = yrest * xrest; yrest_xrest_2 = yrest_xrest >> 1;
wrapin_pixels = rin->wrap;
wrapin_bytes = wrapin_pixels * 3;
wrapout = rout->wrap;
rowin = (UCHAR *)rin->buffer + wrapin_bytes * y1 + 3 * x1;
rowout = (USHORT*)rout->buffer + wrapout * newy + newx;
for (y = y1; y < ylast; y += factor)
{
pixin = rowin;
pixout = rowout;
for (x = x1; x < xlast; x += factor)
{
tmp_r = tmp_g = tmp_b = 0;
in = pixin;
for (j = 0; j < factor; j+=2)
{
for (i = 0; i < factor; i+=2)
{
tmp_r += *in++;
tmp_g += *in++;
tmp_b += *in++;
in += wrapin_bytes;
tmp_r += *in++;
tmp_g += *in++;
tmp_b += *in++;
in -= wrapin_bytes;
}
in += 6 * wrapin_pixels - 3 * factor;
}
tmp_r = (tmp_r + fac_fac_4) >> fac_fac_2_bits;
tmp_g = (tmp_g + fac_fac_4) >> fac_fac_2_bits;
tmp_b = (tmp_b + fac_fac_4) >> fac_fac_2_bits;
*pixout++ = PIX_RGB16_FROM_BYTES (tmp_r, tmp_g, tmp_b);
pixin += 3 * factor;
}
if (xrest)
{
tmp_r = tmp_g = tmp_b = 0;
for (j = 0; j < factor; j++)
for (i = 0; i < xrest; i++)
{
tmp_r += pixin[3*i + j*wrapin_bytes];
tmp_g += pixin[3*i + j*wrapin_bytes + 1];
tmp_b += pixin[3*i + j*wrapin_bytes + 2];
}
tmp_r = (tmp_r + fac_xrest_2) / fac_xrest;
tmp_g = (tmp_g + fac_xrest_2) / fac_xrest;
tmp_b = (tmp_b + fac_xrest_2) / fac_xrest;
*pixout = PIX_RGB16_FROM_BYTES (tmp_r, tmp_g, tmp_b);
}
rowin += wrapin_bytes * factor;
rowout += wrapout;
}
if (yrest)
{
pixin = rowin;
pixout = rowout;
for (x = x1; x < xlast; x += factor)
{
tmp_r = tmp_g = tmp_b = 0;
for (j = 0; j < yrest; j++)
for (i = 0; i < factor; i++)
{
tmp_r += pixin[3*i + j*wrapin_bytes];
tmp_g += pixin[3*i + j*wrapin_bytes + 1];
tmp_b += pixin[3*i + j*wrapin_bytes + 2];
}
tmp_r = (tmp_r + yrest_fac_2) / yrest_fac;
tmp_g = (tmp_g + yrest_fac_2) / yrest_fac;
tmp_b = (tmp_b + yrest_fac_2) / yrest_fac;
*pixout++ = PIX_RGB16_FROM_BYTES (tmp_r, tmp_g, tmp_b);
pixin += 3 * factor;
}
if (xrest)
{
tmp_r = tmp_g = tmp_b = 0;
for (j = 0; j < yrest; j++)
for (i = 0; i < xrest; i++)
{
tmp_r += pixin[3*i + j*wrapin_bytes];
tmp_g += pixin[3*i + j*wrapin_bytes + 1];
tmp_b += pixin[3*i + j*wrapin_bytes + 2];
}
tmp_r = (tmp_r + yrest_xrest_2) / yrest_xrest;
tmp_g = (tmp_g + yrest_xrest_2) / yrest_xrest;
tmp_b = (tmp_b + yrest_xrest_2) / yrest_xrest;
*pixout = PIX_RGB16_FROM_BYTES (tmp_r, tmp_g, tmp_b);
}
} }
/*---------------------------------------------------------------------------*/
E 81
I 28 static void rop_zoom_out_rgb_rgbm(RASTER *rin, RASTER *rout,
D 31 int x1, int y1, int x2, int y2, int newx, int newy, int factor)
E 31
I 31 int x1,
int y1, int x2, int y2, int newx, int newy, int abs_zoom_level)
E 31 {
D 48
printf ("rop_zoom_out_rgb_rgbm not implemented yet\n");
E 48
I 48
UCHAR *rowin, *pixin, *in;
LPIXEL *rowout, *pixout, valout;
int tmp_r, tmp_g, tmp_b;
int wrapin_pixels, wrapin_bytes, wrapout;
int x, y, lx, ly, xlast, ylast, xrest, yrest, i, j;
int factor, fac_fac_2_bits;
int fac_fac , yrest_fac, fac_xrest, yrest_xrest;
int fac_fac_2, yrest_fac_2, fac_xrest_2, yrest_xrest_2;
int fac_fac_4;
lx=x2-x1+1;
ly=y2-y1+1;
factor = 1 << abs_zoom_level;
D 61
xrest = lx % factor;
yrest = ly % factor;
E 61
I 61
xrest = lx & (factor - 1);
yrest = ly & (factor - 1);
E 61
xlast = x2 - xrest + 1;
ylast = y2 - yrest + 1;
fac_fac = factor * factor; fac_fac_2 = fac_fac >> 1;
fac_fac_4 = fac_fac >> 2; fac_fac_2_bits= 2 * abs_zoom_level - 1;
yrest_fac = yrest * factor; yrest_fac_2 = yrest_fac >> 1;
fac_xrest = factor * xrest; fac_xrest_2 = fac_xrest >> 1;
yrest_xrest = yrest * xrest; yrest_xrest_2 = yrest_xrest >> 1;
wrapin_pixels = rin->wrap;
wrapin_bytes = wrapin_pixels * 3;
wrapout = rout->wrap;
valout.m = 0xff;
rowin = (UCHAR *)rin->buffer + wrapin_bytes*y1 + 3*x1;
rowout = (LPIXEL*)rout->buffer + wrapout*newy + newx;
for (y = y1; y < ylast; y += factor)
{
pixin = rowin;
pixout = rowout;
for (x = x1; x < xlast; x += factor)
{
tmp_r = tmp_g = tmp_b = 0;
in = pixin;
for (j = 0; j < factor; j+=2)
{
for (i = 0; i < factor; i+=2)
{
tmp_r += *in++;
tmp_g += *in++;
tmp_b += *in++;
in += wrapin_bytes;
tmp_r += *in++;
tmp_g += *in++;
tmp_b += *in++;
in -= wrapin_bytes;
}
in += 6 * wrapin_pixels - 3 * factor;
}
valout.r = (tmp_r + fac_fac_4) >> fac_fac_2_bits;
valout.g = (tmp_g + fac_fac_4) >> fac_fac_2_bits;
valout.b = (tmp_b + fac_fac_4) >> fac_fac_2_bits;
*pixout++ = valout;
pixin += 3 * factor;
}
if (xrest)
{
tmp_r = tmp_g = tmp_b = 0;
for (j = 0; j < factor; j++)
for (i = 0; i < xrest; i++)
{
tmp_r += pixin[3*i + j*wrapin_bytes];
tmp_g += pixin[3*i + j*wrapin_bytes + 1];
tmp_b += pixin[3*i + j*wrapin_bytes + 2];
}
valout.r = (tmp_r + fac_xrest_2) / fac_xrest;
valout.g = (tmp_g + fac_xrest_2) / fac_xrest;
valout.b = (tmp_b + fac_xrest_2) / fac_xrest;
*pixout = valout;
}
rowin += wrapin_bytes * factor;
rowout += wrapout;
}
if (yrest)
{
pixin = rowin;
pixout = rowout;
for (x = x1; x < xlast; x += factor)
{
tmp_r = tmp_g = tmp_b = 0;
for (j = 0; j < yrest; j++)
for (i = 0; i < factor; i++)
{
tmp_r += pixin[3*i + j*wrapin_bytes];
tmp_g += pixin[3*i + j*wrapin_bytes + 1];
tmp_b += pixin[3*i + j*wrapin_bytes + 2];
}
valout.r = (tmp_r + yrest_fac_2) / yrest_fac;
valout.g = (tmp_g + yrest_fac_2) / yrest_fac;
valout.b = (tmp_b + yrest_fac_2) / yrest_fac;
*pixout++ = valout;
D 49
pixin += factor;
E 49
I 49
pixin += 3 * factor;
E 49
}
if (xrest)
{
tmp_r = tmp_g = tmp_b = 0;
for (j = 0; j < yrest; j++)
for (i = 0; i < xrest; i++)
{
tmp_r += pixin[3*i + j*wrapin_bytes];
tmp_g += pixin[3*i + j*wrapin_bytes + 1];
tmp_b += pixin[3*i + j*wrapin_bytes + 2];
}
valout.r = (tmp_r + yrest_xrest_2) / yrest_xrest;
valout.g = (tmp_g + yrest_xrest_2) / yrest_xrest;
valout.b = (tmp_b + yrest_xrest_2) / yrest_xrest;
*pixout = valout;
}
}
E 48 }
/*---------------------------------------------------------------------------*/
I 68
D 69 static void rop_copy_bw_bw(RASTER *rin, RASTER *rout, int x1, int y1, int x2, int y2, int newx, int newy)
E 69
I 69 static void rop_copy_bw(RASTER *rin, RASTER *rout, int x1, int y1, int x2, int y2, int newx, int newy)
E 69 {
UINT mask;
D 69
int yin, yout, byte, byte1, byte2, newbyte, bytewrapin, bytewrapout;
E 69
I 69
int yin, yout, byte, byte1, byte2, newbyte, bytewrapin, bytewrapout, rest;
E 69
UCHAR *bytein, *byteout;
D 69
if ((x1 & 7) || ((x2 + 1) & 7))
E 69
I 69
if ((x1 & 7) || (newx & 7))
E 69
{
D 69
msg (MSG_IE, "rop_copy_bw_bw: x coordinates must be multiples of 8");
E 69
I 69
rop_copy_90_bw (rin, rout, x1, y1, x2, y2, newx, newy, FALSE, 0);
E 69
return;
}
mask = rin->type == rout->type ? 0x0 : 0xff;
byte1 = x1 >> 3;
byte2 = ((x2 + 1) >> 3) - 1;
I 69
rest = (x2 + 1) & 7;
E 69
newbyte = newx >> 3;
bytewrapin = (rin->wrap + 7) >> 3;
bytewrapout = (rout->wrap + 7) >> 3;
for (yin = y1, yout = newy; yin <= y2; yin++, yout++)
{
bytein = (UCHAR *)rin->buffer + yin * bytewrapin + byte1;
byteout = (UCHAR *)rout->buffer + yout * bytewrapout + newbyte;
if (mask)
for (byte = byte1; byte <= byte2; byte++)
*byteout++ = *bytein++ ^ mask;
else
for (byte = byte1; byte <= byte2; byte++)
*byteout++ = *bytein++;
I 69
if (rest)
*byteout |= (*bytein ^ mask) & (~0U << (7 - rest));
E 69
} }
/*---------------------------------------------------------------------------*/
E 68
E 28
E 20
E 18 static void rop_copy_bw_cm16(RASTER *rin, RASTER *rout, int x1, int y1, int x2, int y2, int newx, int newy) {
UCHAR *rowin, *bytein;
USHORT *rowout, *pixout;
LPIXEL *cmap;
I 5
D 21
int i_0, i_1, i_t;
E 21
I 21
USHORT i_0, i_1, i_t;
E 21
E 5
D 18
int wrapin, wrapout, tmp, cmap_offset, bit, bit_offs, startbit;
E 18
I 18
int wrapin, wrapout, cmap_offset, bit, bit_offs, startbit;
E 18
int x, lx, ly;
D 5
int reversed;
E 5
D 68
if(!rout->cmap.buffer)
E 68
I 68
D 84
if ( !rout->cmap.buffer)
E 68
{
D 68
msg (MSG_IE, "rop_copy_bw_cm16: missing color map");
return;
E 68
I 68
msg (MSG_IE, "rop_copy_bw_cm16: missing color map");
return;
E 68
}
E 84
cmap=rout->cmap.buffer;
D 56
cmap_offset=rout->cmap.offset;
E 56
I 56
cmap_offset=rout->cmap.info.offset_mask;
E 56
D 5
switch (rin->type)
E 5
I 5
if (cmap[0].r==0)
E 5
{
D 5
CASE RAS_BW: reversed = cmap[0].r!=0;
CASE RAS_WB: reversed = cmap[0].r==0;
DEFAULT: msg (MSG_IE, "rop_copy_bw_cm16: invalid rastertype");
E 5
I 5
i_0 = cmap_offset;
i_1 = cmap_offset + 255;
E 5
}
I 5
else
{
i_0 = cmap_offset + 255;
i_1 = cmap_offset;
}
if (rin->type==RAS_WB)
{
i_t = i_0;
i_0 = i_1;
i_1 = i_t;
}
E 5
lx=x2-x1+1;
ly=y2-y1+1;
D 8
wrapin = rin->wrap;
wrapout = rout->wrap;
E 8
I 8
D 10
if ((rin->wrap % sizeof(UCHAR)) || (rout->wrap % sizeof(USHORT)))
{
printf("### INTERNAL ERROR - rop_copy_bw_cm16; bad wrap\n");
return;
}
wrapin = rin->wrap / sizeof(UCHAR);
wrapout = rout->wrap / sizeof(USHORT);
E 8
bit_offs = rin->bit_offs;
E 10
I 10
D 16
wrapin = rin ->wrap / 8;
E 16
I 16
D 47
wrapin = (rin->wrap + 7) / 8;
E 47
I 47
wrapin = (rin->wrap + 7) >> 3;
E 47
E 16
bit_offs = rin ->bit_offs;
wrapout = rout->wrap;
E 10
rowin = (UCHAR*)rin->buffer + wrapin*y1 + ((x1 + bit_offs)>>3);
startbit = 7 - ((x1 + bit_offs) & 7);
rowout = (USHORT*)rout->buffer + wrapout*newy + newx;
while (ly-- > 0)
{
bytein = rowin;
bit = startbit;
pixout = rowout;
D 5
if (reversed)
for (x = lx; x > 0; x--)
{
*pixout++ = cmap_offset + 1 - ((*bytein >> bit) & 1);
if (bit==0)
{
bytein++;
bit = 7;
}
else
bit--;
}
else
for (x = lx; x > 0; x--)
E 5
I 5
for (x = lx; x > 0; x--)
{
*pixout++ = ((*bytein >> bit) & 1) ? i_1 : i_0;
if (bit==0)
E 5
{
D 5
*pixout++ = cmap_offset + ((*bytein >> bit) & 1);
if (bit==0)
{
bytein++;
bit = 7;
}
else
bit--;
E 5
I 5
bytein++;
bit = 7;
E 5
}
I 5
else
bit--;
}
E 5
rowin += wrapin;
rowout += wrapout;
} }
/*---------------------------------------------------------------------------*/
I 20
D 84 static void rop_reduce_bw_cm16(RASTER *rin, RASTER *rout, int x1, int y1, int x2, int y2, int newx, int newy, int factor)
E 84
I 84 static void rop_copy_bw_cm24(RASTER *rin, RASTER *rout, int x1, int y1, int x2, int y2, int newx, int newy)
E 84 {
D 84
printf ("rop_reduce_bw_cm16 not implemented yet\n");
E 84
I 84
UCHAR *rowin, *bytein;
ULONG *rowout, *pixout;
LPIXEL *penmap, *colmap;
ULONG i_0, i_1, i_t;
int wrapin, wrapout, bit, bit_offs, startbit;
int x, lx, ly;
penmap=rout->cmap.penbuffer;
colmap=rout->cmap.colbuffer;
if (penmap[0].r + colmap[0].r==0)
{
i_0 = 0;
i_1 = 255;
}
else
{
i_0 = 255;
i_1 = 0;
}
if (rin->type==RAS_WB)
{
i_t = i_0;
i_0 = i_1;
i_1 = i_t;
}
lx=x2-x1+1;
ly=y2-y1+1;
wrapin = (rin->wrap + 7) >> 3;
bit_offs = rin ->bit_offs;
wrapout = rout->wrap;
rowin = (UCHAR*)rin->buffer + wrapin*y1 + ((x1 + bit_offs)>>3);
startbit = 7 - ((x1 + bit_offs) & 7);
rowout = (ULONG*)rout->buffer + wrapout*newy + newx;
while (ly-- > 0)
{
bytein = rowin;
bit = startbit;
pixout = rowout;
for (x = lx; x > 0; x--)
{
*pixout++ = ((*bytein >> bit) & 1) ? i_1 : i_0;
if (bit==0)
{
bytein++;
bit = 7;
}
else
bit--;
}
rowin += wrapin;
rowout += wrapout;
}
I 89
if (rout->extra_mask)
rop_copy_extra (rin, rout, x1, y1, x2, y2, newx, newy);
E 89
E 84 }
/*---------------------------------------------------------------------------*/
I 28 static void rop_zoom_out_bw_cm16(RASTER *rin, RASTER *rout,
D 31 int x1, int y1, int x2, int y2, int newx, int newy, int factor)
E 31
I 31 int x1,
int y1, int x2, int y2, int newx, int newy, int abs_zoom_level)
E 31 { printf("rop_zoom_out_bw_cm16 not implemented yet\n"); }
/*---------------------------------------------------------------------------*/
I 84 static void rop_zoom_out_bw_cm24(RASTER *rin, RASTER *rout, int x1, int y1, int x2, int y2, int newx, int newy, int abs_zoom_level) { printf("rop_zoom_out_bw_cm24 not implemented yet\n"); }
/*---------------------------------------------------------------------------*/
E 84
E 28
E 20
I 19 static void rop_copy_bw_rgbm(RASTER *rin, RASTER *rout, int x1, int y1, int x2, int y2, int newx, int newy) {
UCHAR *rowin, *bytein;
LPIXEL *rowout, *pixout;
LPIXEL rgb_0, rgb_1;
int wrapin, wrapout, bit, bit_offs, startbit;
int x, lx, ly;
if (rin->type==RAS_WB)
{
rgb_0.r = 0xff; rgb_0.g = 0xff; rgb_0.b = 0xff; rgb_0.m = 0xff;
rgb_1.r = 0x00; rgb_1.g = 0x00; rgb_1.b = 0x00; rgb_1.m = 0xff;
}
else
{
rgb_0.r = 0x00; rgb_0.g = 0x00; rgb_0.b = 0x00; rgb_0.m = 0xff;
rgb_1.r = 0xff; rgb_1.g = 0xff; rgb_1.b = 0xff; rgb_1.m = 0xff;
}
lx=x2-x1+1;
ly=y2-y1+1;
D 47
wrapin = (rin->wrap + 7) / 8;
E 47
I 47
wrapin = (rin->wrap + 7) >> 3;
E 47
bit_offs = rin ->bit_offs;
wrapout = rout->wrap;
rowin = (UCHAR*)rin->buffer + wrapin*y1 + ((x1 + bit_offs)>>3);
startbit = 7 - ((x1 + bit_offs) & 7);
rowout = (LPIXEL*)rout->buffer + wrapout*newy + newx;
while (ly-- > 0)
{
bytein = rowin;
bit = startbit;
pixout = rowout;
for (x = lx; x > 0; x--)
{
*pixout++ = ((*bytein >> bit) & 1) ? rgb_1 : rgb_0;
if (bit==0)
{
bytein++;
bit = 7;
}
else
bit--;
}
rowin += wrapin;
rowout += wrapout;
} }
/*---------------------------------------------------------------------------*/
I 20
D 84 static void rop_reduce_bw_rgbm(RASTER *rin, RASTER *rout, int x1, int y1, int x2, int y2, int newx, int newy, int factor) { printf("rop_reduce_bw_rgbm not implemented yet\n"); }
/*---------------------------------------------------------------------------*/
E 84
I 28 static void rop_zoom_out_bw_rgbm(RASTER *rin, RASTER *rout,
D 31 int x1, int y1, int x2, int y2, int newx, int newy, int factor)
E 31
I 31 int x1,
int y1, int x2, int y2, int newx, int newy, int abs_zoom_level)
E 31
{
D 61 printf("rop_zoom_out_bw_rgbm not implemented yet\n");
E 61
I 61 UCHAR *rowin, *bytein, *in;
LPIXEL *rowout, *pixout, valout;
int val_0, val_1, tmp;
int wrapin, wrapout, bitin, bit, bit_offs, startbit;
int x, y, lx, ly, xlast, ylast, xrest, yrest, i, j;
int factor, fac_fac_2_bits;
int fac_fac, yrest_fac, fac_xrest, yrest_xrest;
int fac_fac_2, yrest_fac_2, fac_xrest_2, yrest_xrest_2;
int fac_fac_4;
if (rin->type == RAS_WB) {
val_0 = 0xff;
val_1 = 0x00;
} else {
val_0 = 0x00;
val_1 = 0xff;
}
lx = x2 - x1 + 1;
ly = y2 - y1 + 1;
factor = 1 << abs_zoom_level;
xrest = lx & (factor - 1);
yrest = ly & (factor - 1);
xlast = x2 - xrest + 1;
ylast = y2 - yrest + 1;
fac_fac = factor * factor;
fac_fac_2 = fac_fac >> 1;
fac_fac_4 = fac_fac >> 2;
fac_fac_2_bits = 2 * abs_zoom_level - 1;
yrest_fac = yrest * factor;
yrest_fac_2 = yrest_fac >> 1;
fac_xrest = factor * xrest;
fac_xrest_2 = fac_xrest >> 1;
yrest_xrest = yrest * xrest;
yrest_xrest_2 = yrest_xrest >> 1;
wrapin = (rin->wrap + 7) >> 3;
bit_offs = rin->bit_offs;
wrapout = rout->wrap;
valout.m = 0xff;
rowin = (UCHAR *)rin->buffer + wrapin * y1 + ((x1 + bit_offs) >> 3);
startbit = 7 - ((x1 + bit_offs) & 7);
rowout = (LPIXEL *)rout->buffer + wrapout * newy + newx;
for (y = y1; y < ylast; y += factor) {
bytein = rowin;
bitin = startbit;
pixout = rowout;
for (x = x1; x < xlast; x += factor) {
tmp = 0;
in = bytein;
bit = bitin;
for (j = 0; j < factor; j += 2) {
for (i = 0; i < factor; i += 2) {
tmp += ((*in >> bit) & 1);
in += wrapin;
if (bit == 0) {
in++;
bit = 7;
} else
bit--;
tmp += ((*in >> bit) & 1);
in -= wrapin;
if (bit == 0) {
in++;
bit = 7;
} else
bit--;
}
in += 2 * wrapin;
bit += factor;
while (bit > 7) {
in--;
bit -= 8;
}
}
tmp = tmp * val_1 + (fac_fac_2 - tmp) * val_0;
valout.r = valout.g = valout.b = (tmp + fac_fac_4) >> fac_fac_2_bits;
*pixout++ = valout;
bitin -= factor;
while (bitin < 0) {
bytein++;
bitin += 8;
}
}
if (xrest) {
tmp = 0;
for (j = 0; j < factor; j++)
for (i = 0; i < xrest; i++) {
tmp += GET_BIT(i, j, bytein, wrapin, 7 - bitin);
}
tmp = tmp * val_1 + (fac_xrest - tmp) * val_0;
valout.r = valout.g = valout.b = (tmp + fac_xrest_2) / fac_xrest;
*pixout = valout;
}
rowin += wrapin * factor;
rowout += wrapout;
}
if (yrest) {
bytein = rowin;
bitin = startbit;
pixout = rowout;
for (x = x1; x < xlast; x += factor) {
tmp = 0;
for (j = 0; j < yrest; j++)
for (i = 0; i < factor; i++) {
tmp += GET_BIT(i, j, bytein, wrapin, 7 - bitin);
}
tmp = tmp * val_1 + (yrest_fac - tmp) * val_0;
valout.r = valout.g = valout.b = (tmp + yrest_fac_2) / yrest_fac;
*pixout++ = valout;
bitin -= factor;
while (bitin < 0) {
bytein++;
bitin += 8;
}
}
if (xrest) {
tmp = 0;
for (j = 0; j < yrest; j++)
for (i = 0; i < xrest; i++) {
tmp += GET_BIT(i, j, bytein, wrapin, 7 - bitin);
}
tmp = tmp * val_1 + (yrest_xrest - tmp) * val_0;
valout.r = valout.g = valout.b = (tmp + yrest_xrest_2) / yrest_xrest;
*pixout = valout;
}
}
E 61
}
/*---------------------------------------------------------------------------*/
E 28
E 20
E 19 static void rop_copy_gr8_cm16(RASTER *rin, RASTER *rout, int x1, int y1,
int x2, int y2, int newx, int newy) {
UCHAR *rowin, *bytein;
USHORT *rowout, *pixout;
LPIXEL *cmap;
D 18 int wrapin, wrapout, tmp, cmap_offset;
E 18
I 18 int wrapin, wrapout, cmap_offset;
E 18 int x, lx, ly;
int i, reversed;
E 4
I 4
D 84 if (!rout->cmap.buffer) {
msg(MSG_IE, "rop_copy_gr8_cm16: missing color map");
return;
}
E 84 cmap = rout->cmap.buffer;
D 56 cmap_offset = rout->cmap.offset;
E 56
I 56 cmap_offset = rout->cmap.info.offset_mask;
E 56 reversed = cmap[0].r != 0;
lx = x2 - x1 + 1;
ly = y2 - y1 + 1;
D 8 wrapin = rin->wrap;
wrapout = rout->wrap;
E 8
I 8
D 10 if ((rin->wrap % sizeof(UCHAR)) || (rout->wrap % sizeof(USHORT))) {
printf("### INTERNAL ERROR - rop_copy_gr8_cm16; bad wrap\n");
return;
}
wrapin = rin->wrap / sizeof(UCHAR);
wrapout = rout->wrap / sizeof(USHORT);
E 10
I 10 wrapin = rin->wrap;
wrapout = rout->wrap;
E 10
E 8
rowin = (UCHAR *)rin->buffer + wrapin * y1 + x1;
rowout = (USHORT *)rout->buffer + wrapout * newy + newx;
while (ly-- > 0) {
bytein = rowin;
pixout = rowout;
if (reversed)
for (x = lx; x > 0; x--) *pixout++ = cmap_offset + (255 - *bytein++);
else
for (x = lx; x > 0; x--) *pixout++ = cmap_offset + *bytein++;
rowin += wrapin;
rowout += wrapout;
}
}
E 4
/*---------------------------------------------------------------------------*/
I 20
D 84 static void
rop_reduce_gr8_cm16(RASTER *rin, RASTER *rout, int x1, int y1, int x2, int y2,
int newx, int newy, int factor)
E 84
I 84 static void rop_copy_gr8_cm24(RASTER *rin, RASTER *rout, int x1, int y1,
int x2, int y2, int newx, int newy)
E 84 {
D 84 printf("rop_reduce_gr8_cm16 not implemented yet\n");
E 84
I 84 UCHAR *rowin, *bytein;
ULONG *rowout, *pixout;
LPIXEL *penmap, *colmap;
int wrapin, wrapout;
int x, lx, ly;
int i, reversed;
penmap = rout->cmap.penbuffer;
colmap = rout->cmap.colbuffer;
reversed = penmap[0].r + colmap[0].r != 0;
lx = x2 - x1 + 1;
ly = y2 - y1 + 1;
wrapin = rin->wrap;
wrapout = rout->wrap;
rowin = (UCHAR *)rin->buffer + wrapin * y1 + x1;
rowout = (ULONG *)rout->buffer + wrapout * newy + newx;
while (ly-- > 0) {
bytein = rowin;
pixout = rowout;
if (reversed)
for (x = lx; x > 0; x--) *pixout++ = 255 - *bytein++;
else
for (x = lx; x > 0; x--) *pixout++ = *bytein++;
rowin += wrapin;
rowout += wrapout;
}
I 89 if (rout->extra_mask)
rop_copy_extra(rin, rout, x1, y1, x2, y2, newx, newy);
E 89
E 84
}
/*---------------------------------------------------------------------------*/
I 28
static void rop_zoom_out_gr8_cm16(RASTER *rin, RASTER *rout,
D 31
int x1, int y1, int x2, int y2,
int newx, int newy, int factor)
E 31
I 31
int x1, int y1, int x2, int y2,
int newx, int newy, int abs_zoom_level)
E 31
{
printf("rop_zoom_out_gr8_cm16 not implemented yet\n");
}
/*---------------------------------------------------------------------------*/
I 84 static void rop_zoom_out_gr8_cm24(RASTER *rin, RASTER *rout, int x1,
int y1, int x2, int y2, int newx,
int newy, int abs_zoom_level) {
printf("rop_zoom_out_gr8_cm24 not implemented yet\n");
}
/*---------------------------------------------------------------------------*/
E 84
E 28
I 23 static void rop_copy_cm8_cm16(RASTER *rin, RASTER *rout, int x1, int y1,
int x2, int y2, int newx, int newy) {
UCHAR *rowin, *pixin;
USHORT *rowout, *pixout;
LPIXEL *cmapin, *cmapout;
int wrapin, wrapout, cmapin_offset, cmapout_offset, cmap_offset_delta;
int x, lx, ly;
D 84 if (!rin->cmap.buffer || !rout->cmap.buffer) {
msg(MSG_IE, "rop_copy_cm8_cm16: missing color map");
return;
}
E 84 cmapin = rin->cmap.buffer;
cmapout = rout->cmap.buffer;
D 56 cmapin_offset = rin->cmap.offset;
cmapout_offset = rout->cmap.offset;
E 56
I 56 cmapin_offset = rin->cmap.info.offset_mask;
cmapout_offset = rout->cmap.info.offset_mask;
E 56 cmap_offset_delta = cmapout_offset - cmapin_offset;
lx = x2 - x1 + 1;
ly = y2 - y1 + 1;
wrapin = rin->wrap;
wrapout = rout->wrap;
rowin = (UCHAR *)rin->buffer + wrapin * y1 + x1;
rowout = (USHORT *)rout->buffer + wrapout * newy + newx;
while (ly-- > 0) {
pixin = rowin;
pixout = rowout;
for (x = lx; x > 0; x--) *pixout++ = *pixin++ + cmap_offset_delta;
rowin += wrapin;
rowout += wrapout;
}
}
/*---------------------------------------------------------------------------*/
E 23
D 84 static void rop_reduce_bw_gr8(
RASTER *rin,
RASTER *rout,
E 84
I 84 static void rop_copy_cm8_cm24(
RASTER *rin, RASTER *rout,
E 84 int x1, int y1, int x2, int y2,
D 84 int newx, int newy,
int factor) { printf("rop_reduce_bw_gr8 not implemented yet\n"); }
/*---------------------------------------------------------------------------*/
I 28 static void rop_zoom_out_bw_gr8(RASTER *rin, RASTER *rout,
D 31 int x1, int y1, int x2, int y2, int newx, int newy, int factor)
E 31
I 31 int x1,
int y1, int x2, int y2, int newx, int newy, int abs_zoom_level)
E 31 {
printf("rop_zoom_out_bw_gr8 not implemented yet\n");
}
/*---------------------------------------------------------------------------*/
E 28
static void rop_reduce_gr8(RASTER *rin, RASTER *rout,
int x1, int y1, int x2, int y2,
int newx, int newy, int factor)
E 84
I 84
int newx, int newy)
E 84
{
D 84 UCHAR *rowin, *bytein;
UCHAR *rowout, *byteout;
int tmp;
int wrapin, wrapout;
int x, y, lx, ly, xlast, ylast, xrest, yrest, i, j;
E 84
I 84 UCHAR *rowin, *pixin;
ULONG *rowout, *pixout;
int wrapin, wrapout, cmapin_offset, cmap_offset_delta;
int x, lx, ly;
E 84
I 84 cmapin_offset = rin->cmap.info.offset_mask;
cmap_offset_delta = -cmapin_offset;
E 84 lx = x2 - x1 + 1;
ly = y2 - y1 + 1;
D 61 xrest = lx % factor;
yrest = ly % factor;
E 61
I 61
D 84 xrest = lx & (factor - 1);
yrest = ly & (factor - 1);
E 61
D 28 xlast = x2 - xrest - (factor - 1);
ylast = y2 - yrest - (factor - 1);
E 28
I 28 xlast = x2 - xrest + 1;
ylast = y2 - yrest + 1;
E 84
E 28 wrapin = rin->wrap;
wrapout = rout->wrap;
D 84 rowin = (UCHAR *)rin->buffer + wrapin * y1 + x1;
rowout = (UCHAR *)rout->buffer + wrapout * newy + newx;
D 28 for (y = y1; y <= ylast; y += factor)
E 28
I 28 for (y = y1; y < ylast; y += factor)
E 84
I 84 rowin = (UCHAR *)rin->buffer + wrapin * y1 + x1;
rowout = (ULONG *)rout->buffer + wrapout * newy + newx;
while (ly-- > 0)
E 84
E 28 {
D 84 bytein = rowin;
byteout = rowout;
for (x = x1; x < xlast; x += factor) {
tmp = 0;
for (j = 0; j < factor; j++)
for (i = 0; i < factor; i++) tmp += bytein[i + j * wrapin];
*byteout++ = tmp / (factor * factor);
bytein += factor;
}
if (xrest) {
tmp = 0;
for (j = 0; j < factor; j++)
for (i = 0; i < xrest; i++) tmp += bytein[i + j * wrapin];
*byteout = tmp / (factor * xrest);
}
rowin += wrapin * factor;
E 84
I 84 pixin = rowin;
pixout = rowout;
for (x = lx; x > 0; x--) *pixout++ = *pixin++ + cmap_offset_delta;
rowin += wrapin;
E 84 rowout += wrapout;
}
I 89 if (rout->extra_mask)
rop_copy_extra(rin, rout, x1, y1, x2, y2, newx, newy);
E 89
D 84 if (yrest) {
bytein = rowin;
byteout = rowout;
for (x = x1; x < xlast; x += factor) {
tmp = 0;
for (j = 0; j < yrest; j++)
for (i = 0; i < factor; i++) tmp += bytein[i + j * wrapin];
*byteout++ = tmp / (yrest * factor);
bytein += factor;
}
if (xrest) {
tmp = 0;
for (j = 0; j < yrest; j++)
for (i = 0; i < xrest; i++) tmp += bytein[i + j * wrapin];
*byteout = tmp / (yrest * xrest);
}
}
E 84
}
/*---------------------------------------------------------------------------*/
I 28
D 84
static void rop_zoom_out_gr8(RASTER *rin, RASTER *rout,
D 31
int x1, int y1, int x2, int y2,
int newx, int newy, int factor)
E 31
I 31
int x1, int y1, int x2, int y2,
int newx, int newy, int abs_zoom_level)
E 84
I 84
static void rop_zoom_out_bw_gr8(RASTER *rin, RASTER *rout,
int x1, int y1, int x2, int y2,
int newx, int newy, int abs_zoom_level)
E 84
E 31
{
D 84 printf("rop_zoom_out_gr8 not implemented yet\n");
E 84
I 84 printf("rop_zoom_out_bw_gr8 not implemented yet\n");
E 84
}
/*---------------------------------------------------------------------------*/
E 28
D 84 static void rop_reduce_cm16(RASTER *rin, RASTER *rout, int x1, int y1,
int x2, int y2, int newx, int newy,
int factor)
E 84
I 84 static void rop_zoom_out_gr8(RASTER *rin, RASTER *rout, int x1, int y1,
int x2, int y2, int newx, int newy,
int abs_zoom_level)
E 84 {
D 84 printf("rop_reduce_cm16 not implemented yet\n");
E 84
I 84 printf("rop_zoom_out_gr8 not implemented yet\n");
E 84
}
/*---------------------------------------------------------------------------*/
I 28
static void rop_zoom_out_cm16(RASTER *rin, RASTER *rout,
D 31
int x1, int y1, int x2, int y2,
int newx, int newy, int factor)
E 31
I 31
int x1, int y1, int x2, int y2,
int newx, int newy, int abs_zoom_level)
E 31
{
printf("rop_zoom_out_cm16 not implemented yet\n");
}
/*---------------------------------------------------------------------------*/
E 28
D 84 static void rop_reduce_rgbm(RASTER *rin, RASTER *rout, int x1, int y1,
int x2, int y2, int newx, int newy,
int factor)
E 84
I 84 static void rop_zoom_out_cm24(RASTER *rin, RASTER *rout, int x1, int y1,
int x2, int y2, int newx, int newy,
int abs_zoom_level)
E 84 {
D 84 printf("rop_reduce_rgbm not implemented yet\n");
E 84
I 84 printf("rop_zoom_out_cm24 not implemented yet\n");
E 84
}
/*---------------------------------------------------------------------------*/
I 28
static void rop_zoom_out_rgbm(RASTER *rin, RASTER *rout,
D 31
int x1, int y1, int x2, int y2,
int newx, int newy, int factor)
E 31
I 31
int x1, int y1, int x2, int y2,
int newx, int newy, int abs_zoom_level)
E 31
{
D 31 printf("rop_zoom_out_rgbm not implemented yet\n");
E 31
I 31 LPIXEL *rowin, *pixin, *in, valin;
LPIXEL *rowout, *pixout, valout;
int tmp_r, tmp_g, tmp_b, tmp_m;
int wrapin, wrapout;
int x, y, lx, ly, xlast, ylast, xrest, yrest, i, j;
int factor, fac_fac_2_bits;
int fac_fac, yrest_fac, fac_xrest, yrest_xrest;
int fac_fac_2, yrest_fac_2, fac_xrest_2, yrest_xrest_2;
int fac_fac_4;
lx = x2 - x1 + 1;
ly = y2 - y1 + 1;
factor = 1 << abs_zoom_level;
D 61 xrest = lx % factor;
yrest = ly % factor;
E 61
I 61 xrest = lx & (factor - 1);
yrest = ly & (factor - 1);
E 61 xlast = x2 - xrest + 1;
ylast = y2 - yrest + 1;
fac_fac = factor * factor;
fac_fac_2 = fac_fac >> 1;
fac_fac_4 = fac_fac >> 2;
fac_fac_2_bits = 2 * abs_zoom_level - 1;
yrest_fac = yrest * factor;
yrest_fac_2 = yrest_fac >> 1;
fac_xrest = factor * xrest;
fac_xrest_2 = fac_xrest >> 1;
yrest_xrest = yrest * xrest;
yrest_xrest_2 = yrest_xrest >> 1;
wrapin = rin->wrap;
wrapout = rout->wrap;
valout.m = 0xff;
rowin = (LPIXEL *)rin->buffer + wrapin * y1 + x1;
rowout = (LPIXEL *)rout->buffer + wrapout * newy + newx;
for (y = y1; y < ylast; y += factor) {
pixin = rowin;
pixout = rowout;
for (x = x1; x < xlast; x += factor) {
tmp_r = tmp_g = tmp_b = tmp_m = 0;
in = pixin;
for (j = 0; j < factor; j += 2) {
for (i = 0; i < factor; i += 2) {
valin = *in;
tmp_r += valin.r;
tmp_g += valin.g;
tmp_b += valin.b;
tmp_m += valin.m;
D 38 in += factor;
E 38
I 38 in += wrapin;
E 38 in++;
valin = *in;
tmp_r += valin.r;
tmp_g += valin.g;
tmp_b += valin.b;
tmp_m += valin.m;
D 38 in -= factor;
E 38
I 38 in -= wrapin;
E 38 in++;
}
in += 2 * wrapin - factor;
}
valout.r = (tmp_r + fac_fac_4) >> fac_fac_2_bits;
valout.g = (tmp_g + fac_fac_4) >> fac_fac_2_bits;
valout.b = (tmp_b + fac_fac_4) >> fac_fac_2_bits;
valout.m = (tmp_m + fac_fac_4) >> fac_fac_2_bits;
*pixout++ = valout;
pixin += factor;
}
if (xrest) {
tmp_r = tmp_g = tmp_b = tmp_m = 0;
for (j = 0; j < factor; j++)
for (i = 0; i < xrest; i++) {
valin = pixin[i + j * wrapin];
tmp_r += valin.r;
tmp_g += valin.g;
tmp_b += valin.b;
tmp_m += valin.m;
}
valout.r = (tmp_r + fac_xrest_2) / fac_xrest;
valout.g = (tmp_g + fac_xrest_2) / fac_xrest;
valout.b = (tmp_b + fac_xrest_2) / fac_xrest;
valout.m = (tmp_m + fac_xrest_2) / fac_xrest;
*pixout = valout;
}
rowin += wrapin * factor;
rowout += wrapout;
}
if (yrest) {
pixin = rowin;
pixout = rowout;
for (x = x1; x < xlast; x += factor) {
tmp_r = tmp_g = tmp_b = tmp_m = 0;
for (j = 0; j < yrest; j++)
for (i = 0; i < factor; i++) {
valin = pixin[i + j * wrapin];
tmp_r += valin.r;
tmp_g += valin.g;
tmp_b += valin.b;
tmp_m += valin.m;
}
valout.r = (tmp_r + yrest_fac_2) / yrest_fac;
valout.g = (tmp_g + yrest_fac_2) / yrest_fac;
valout.b = (tmp_b + yrest_fac_2) / yrest_fac;
valout.m = (tmp_m + yrest_fac_2) / yrest_fac;
*pixout++ = valout;
pixin += factor;
}
if (xrest) {
tmp_r = tmp_g = tmp_b = tmp_m = 0;
for (j = 0; j < yrest; j++)
for (i = 0; i < xrest; i++) {
valin = pixin[i + j * wrapin];
tmp_r += valin.r;
tmp_g += valin.g;
tmp_b += valin.b;
tmp_m += valin.m;
}
valout.r = (tmp_r + yrest_xrest_2) / yrest_xrest;
valout.g = (tmp_g + yrest_xrest_2) / yrest_xrest;
valout.b = (tmp_b + yrest_xrest_2) / yrest_xrest;
valout.m = (tmp_m + yrest_xrest_2) / yrest_xrest;
*pixout = valout;
}
}
E 31
}
/*---------------------------------------------------------------------------*/
I 46 static void rop_zoom_out_rgbx(RASTER *rin, RASTER *rout, int x1, int y1,
int x2, int y2, int newx, int newy,
int abs_zoom_level) {
LPIXEL *rowin, *pixin, *in, valin;
LPIXEL *rowout, *pixout, valout;
int tmp_r, tmp_g, tmp_b;
int wrapin, wrapout;
int x, y, lx, ly, xlast, ylast, xrest, yrest, i, j;
int factor, fac_fac_2_bits;
int fac_fac, yrest_fac, fac_xrest, yrest_xrest;
int fac_fac_2, yrest_fac_2, fac_xrest_2, yrest_xrest_2;
int fac_fac_4;
lx = x2 - x1 + 1;
ly = y2 - y1 + 1;
factor = 1 << abs_zoom_level;
D 61 xrest = lx % factor;
yrest = ly % factor;
E 61
I 61 xrest = lx & (factor - 1);
yrest = ly & (factor - 1);
E 61 xlast = x2 - xrest + 1;
ylast = y2 - yrest + 1;
fac_fac = factor * factor;
fac_fac_2 = fac_fac >> 1;
fac_fac_4 = fac_fac >> 2;
fac_fac_2_bits = 2 * abs_zoom_level - 1;
yrest_fac = yrest * factor;
yrest_fac_2 = yrest_fac >> 1;
fac_xrest = factor * xrest;
fac_xrest_2 = fac_xrest >> 1;
yrest_xrest = yrest * xrest;
yrest_xrest_2 = yrest_xrest >> 1;
wrapin = rin->wrap;
wrapout = rout->wrap;
valout.m = 0xff;
rowin = (LPIXEL *)rin->buffer + wrapin * y1 + x1;
rowout = (LPIXEL *)rout->buffer + wrapout * newy + newx;
for (y = y1; y < ylast; y += factor) {
pixin = rowin;
pixout = rowout;
for (x = x1; x < xlast; x += factor) {
tmp_r = tmp_g = tmp_b = 0;
in = pixin;
for (j = 0; j < factor; j += 2) {
for (i = 0; i < factor; i += 2) {
valin = *in;
tmp_r += valin.r;
tmp_g += valin.g;
tmp_b += valin.b;
in += wrapin;
in++;
valin = *in;
tmp_r += valin.r;
tmp_g += valin.g;
tmp_b += valin.b;
in -= wrapin;
in++;
}
in += 2 * wrapin - factor;
}
valout.r = (tmp_r + fac_fac_4) >> fac_fac_2_bits;
valout.g = (tmp_g + fac_fac_4) >> fac_fac_2_bits;
valout.b = (tmp_b + fac_fac_4) >> fac_fac_2_bits;
*pixout++ = valout;
pixin += factor;
}
if (xrest) {
tmp_r = tmp_g = tmp_b = 0;
for (j = 0; j < factor; j++)
for (i = 0; i < xrest; i++) {
valin = pixin[i + j * wrapin];
tmp_r += valin.r;
tmp_g += valin.g;
tmp_b += valin.b;
}
valout.r = (tmp_r + fac_xrest_2) / fac_xrest;
valout.g = (tmp_g + fac_xrest_2) / fac_xrest;
valout.b = (tmp_b + fac_xrest_2) / fac_xrest;
*pixout = valout;
}
rowin += wrapin * factor;
rowout += wrapout;
}
if (yrest) {
pixin = rowin;
pixout = rowout;
for (x = x1; x < xlast; x += factor) {
tmp_r = tmp_g = tmp_b = 0;
for (j = 0; j < yrest; j++)
for (i = 0; i < factor; i++) {
valin = pixin[i + j * wrapin];
tmp_r += valin.r;
tmp_g += valin.g;
tmp_b += valin.b;
}
valout.r = (tmp_r + yrest_fac_2) / yrest_fac;
valout.g = (tmp_g + yrest_fac_2) / yrest_fac;
valout.b = (tmp_b + yrest_fac_2) / yrest_fac;
*pixout++ = valout;
pixin += factor;
}
if (xrest) {
tmp_r = tmp_g = tmp_b = 0;
for (j = 0; j < yrest; j++)
for (i = 0; i < xrest; i++) {
valin = pixin[i + j * wrapin];
tmp_r += valin.r;
tmp_g += valin.g;
tmp_b += valin.b;
}
valout.r = (tmp_r + yrest_xrest_2) / yrest_xrest;
valout.g = (tmp_g + yrest_xrest_2) / yrest_xrest;
valout.b = (tmp_b + yrest_xrest_2) / yrest_xrest;
*pixout = valout;
}
}
}
I 95
/*---------------------------------------------------------------------------*/
static void
rop_zoom_out_rgbx64_rgbx(RASTER *rin, RASTER *rout, int x1, int y1, int x2,
int y2, int newx, int newy, int abs_zoom_level) {
SPIXEL *rowin, *pixin, *in, valin;
LPIXEL *rowout, *pixout, valout;
int tmp_r, tmp_g, tmp_b;
int wrapin, wrapout;
int x, y, lx, ly, xlast, ylast, xrest, yrest, i, j;
int factor, fac_fac_2_bits;
int fac_fac, yrest_fac, fac_xrest, yrest_xrest;
int fac_fac_2, yrest_fac_2, fac_xrest_2, yrest_xrest_2;
int fac_fac_4;
lx = x2 - x1 + 1;
ly = y2 - y1 + 1;
factor = 1 << abs_zoom_level;
xrest = lx & (factor - 1);
yrest = ly & (factor - 1);
xlast = x2 - xrest + 1;
ylast = y2 - yrest + 1;
fac_fac = factor * factor;
fac_fac_2 = fac_fac >> 1;
fac_fac_4 = fac_fac >> 2;
fac_fac_2_bits = 2 * abs_zoom_level - 1;
yrest_fac = yrest * factor;
yrest_fac_2 = yrest_fac >> 1;
fac_xrest = factor * xrest;
fac_xrest_2 = fac_xrest >> 1;
yrest_xrest = yrest * xrest;
yrest_xrest_2 = yrest_xrest >> 1;
wrapin = rin->wrap;
wrapout = rout->wrap;
valout.m = 0xff;
rowin = (SPIXEL *)rin->buffer + wrapin * y1 + x1;
rowout = (LPIXEL *)rout->buffer + wrapout * newy + newx;
for (y = y1; y < ylast; y += factor) {
pixin = rowin;
pixout = rowout;
for (x = x1; x < xlast; x += factor) {
tmp_r = tmp_g = tmp_b = 0;
in = pixin;
for (j = 0; j < factor; j += 2) {
for (i = 0; i < factor; i += 2) {
valin = *in;
tmp_r += valin.r;
tmp_g += valin.g;
tmp_b += valin.b;
in += wrapin;
in++;
valin = *in;
tmp_r += valin.r;
tmp_g += valin.g;
tmp_b += valin.b;
in -= wrapin;
in++;
}
in += 2 * wrapin - factor;
}
valout.r = PIX_BYTE_FROM_USHORT((tmp_r + fac_fac_4) >> fac_fac_2_bits);
valout.g = PIX_BYTE_FROM_USHORT((tmp_g + fac_fac_4) >> fac_fac_2_bits);
valout.b = PIX_BYTE_FROM_USHORT((tmp_b + fac_fac_4) >> fac_fac_2_bits);
*pixout++ = valout;
pixin += factor;
}
if (xrest) {
tmp_r = tmp_g = tmp_b = 0;
for (j = 0; j < factor; j++)
for (i = 0; i < xrest; i++) {
valin = pixin[i + j * wrapin];
tmp_r += valin.r;
tmp_g += valin.g;
tmp_b += valin.b;
}
valout.r = PIX_BYTE_FROM_USHORT((tmp_r + fac_xrest_2) / fac_xrest);
valout.g = PIX_BYTE_FROM_USHORT((tmp_g + fac_xrest_2) / fac_xrest);
valout.b = PIX_BYTE_FROM_USHORT((tmp_b + fac_xrest_2) / fac_xrest);
*pixout = valout;
}
rowin += wrapin * factor;
rowout += wrapout;
}
if (yrest) {
pixin = rowin;
pixout = rowout;
for (x = x1; x < xlast; x += factor) {
tmp_r = tmp_g = tmp_b = 0;
for (j = 0; j < yrest; j++)
for (i = 0; i < factor; i++) {
valin = pixin[i + j * wrapin];
tmp_r += valin.r;
tmp_g += valin.g;
tmp_b += valin.b;
}
valout.r = PIX_BYTE_FROM_USHORT((tmp_r + yrest_fac_2) / yrest_fac);
valout.g = PIX_BYTE_FROM_USHORT((tmp_g + yrest_fac_2) / yrest_fac);
valout.b = PIX_BYTE_FROM_USHORT((tmp_b + yrest_fac_2) / yrest_fac);
*pixout++ = valout;
pixin += factor;
}
if (xrest) {
tmp_r = tmp_g = tmp_b = 0;
for (j = 0; j < yrest; j++)
for (i = 0; i < xrest; i++) {
valin = pixin[i + j * wrapin];
tmp_r += valin.r;
tmp_g += valin.g;
tmp_b += valin.b;
}
valout.r = PIX_BYTE_FROM_USHORT((tmp_r + yrest_xrest_2) / yrest_xrest);
valout.g = PIX_BYTE_FROM_USHORT((tmp_g + yrest_xrest_2) / yrest_xrest);
valout.b = PIX_BYTE_FROM_USHORT((tmp_b + yrest_xrest_2) / yrest_xrest);
*pixout = valout;
}
}
}
/*---------------------------------------------------------------------------*/
static void rop_zoom_out_rgbm64_rgbm(RASTER *rin, RASTER *rout, int x1, int y1,
int x2, int y2, int newx, int newy,
int abs_zoom_level) {
SPIXEL *rowin, *pixin, *in, valin;
LPIXEL *rowout, *pixout, valout;
int tmp_r, tmp_g, tmp_b, tmp_m;
int wrapin, wrapout;
int x, y, lx, ly, xlast, ylast, xrest, yrest, i, j;
int factor, fac_fac_2_bits;
int fac_fac, yrest_fac, fac_xrest, yrest_xrest;
int fac_fac_2, yrest_fac_2, fac_xrest_2, yrest_xrest_2;
int fac_fac_4;
lx = x2 - x1 + 1;
ly = y2 - y1 + 1;
factor = 1 << abs_zoom_level;
xrest = lx & (factor - 1);
yrest = ly & (factor - 1);
xlast = x2 - xrest + 1;
ylast = y2 - yrest + 1;
fac_fac = factor * factor;
fac_fac_2 = fac_fac >> 1;
fac_fac_4 = fac_fac >> 2;
fac_fac_2_bits = 2 * abs_zoom_level - 1;
yrest_fac = yrest * factor;
yrest_fac_2 = yrest_fac >> 1;
fac_xrest = factor * xrest;
fac_xrest_2 = fac_xrest >> 1;
yrest_xrest = yrest * xrest;
yrest_xrest_2 = yrest_xrest >> 1;
wrapin = rin->wrap;
wrapout = rout->wrap;
E 95
I 95 rowin = (SPIXEL *)rin->buffer + wrapin * y1 + x1;
rowout = (LPIXEL *)rout->buffer + wrapout * newy + newx;
for (y = y1; y < ylast; y += factor) {
pixin = rowin;
pixout = rowout;
for (x = x1; x < xlast; x += factor) {
tmp_r = tmp_g = tmp_b = tmp_m = 0;
in = pixin;
for (j = 0; j < factor; j += 2) {
for (i = 0; i < factor; i += 2) {
valin = *in;
tmp_r += valin.r;
tmp_g += valin.g;
tmp_b += valin.b;
tmp_m += valin.m;
in += wrapin;
in++;
valin = *in;
tmp_r += valin.r;
tmp_g += valin.g;
tmp_b += valin.b;
tmp_m += valin.m;
in -= wrapin;
in++;
}
in += 2 * wrapin - factor;
}
valout.r = PIX_BYTE_FROM_USHORT((tmp_r + fac_fac_4) >> fac_fac_2_bits);
valout.g = PIX_BYTE_FROM_USHORT((tmp_g + fac_fac_4) >> fac_fac_2_bits);
valout.b = PIX_BYTE_FROM_USHORT((tmp_b + fac_fac_4) >> fac_fac_2_bits);
valout.m = PIX_BYTE_FROM_USHORT((tmp_m + fac_fac_4) >> fac_fac_2_bits);
*pixout++ = valout;
pixin += factor;
}
if (xrest) {
tmp_r = tmp_g = tmp_b = tmp_m = 0;
for (j = 0; j < factor; j++)
for (i = 0; i < xrest; i++) {
valin = pixin[i + j * wrapin];
tmp_r += valin.r;
tmp_g += valin.g;
tmp_b += valin.b;
tmp_m += valin.m;
}
valout.r = PIX_BYTE_FROM_USHORT((tmp_r + fac_xrest_2) / fac_xrest);
valout.g = PIX_BYTE_FROM_USHORT((tmp_g + fac_xrest_2) / fac_xrest);
valout.b = PIX_BYTE_FROM_USHORT((tmp_b + fac_xrest_2) / fac_xrest);
valout.m = PIX_BYTE_FROM_USHORT((tmp_m + fac_xrest_2) / fac_xrest);
*pixout = valout;
}
rowin += wrapin * factor;
rowout += wrapout;
}
if (yrest) {
pixin = rowin;
pixout = rowout;
for (x = x1; x < xlast; x += factor) {
tmp_r = tmp_g = tmp_b = tmp_m = 0;
for (j = 0; j < yrest; j++)
for (i = 0; i < factor; i++) {
valin = pixin[i + j * wrapin];
tmp_r += valin.r;
tmp_g += valin.g;
tmp_b += valin.b;
tmp_m += valin.m;
}
valout.r = PIX_BYTE_FROM_USHORT((tmp_r + yrest_fac_2) / yrest_fac);
valout.g = PIX_BYTE_FROM_USHORT((tmp_g + yrest_fac_2) / yrest_fac);
valout.b = PIX_BYTE_FROM_USHORT((tmp_b + yrest_fac_2) / yrest_fac);
valout.m = PIX_BYTE_FROM_USHORT((tmp_m + yrest_fac_2) / yrest_fac);
*pixout++ = valout;
pixin += factor;
}
if (xrest) {
tmp_r = tmp_g = tmp_b = tmp_m = 0;
for (j = 0; j < yrest; j++)
for (i = 0; i < xrest; i++) {
valin = pixin[i + j * wrapin];
tmp_r += valin.r;
tmp_g += valin.g;
tmp_b += valin.b;
tmp_m += valin.m;
}
valout.r = PIX_BYTE_FROM_USHORT((tmp_r + yrest_xrest_2) / yrest_xrest);
valout.g = PIX_BYTE_FROM_USHORT((tmp_g + yrest_xrest_2) / yrest_xrest);
valout.b = PIX_BYTE_FROM_USHORT((tmp_b + yrest_xrest_2) / yrest_xrest);
valout.m = PIX_BYTE_FROM_USHORT((tmp_m + yrest_xrest_2) / yrest_xrest);
*pixout = valout;
}
}
}
E 95
/*---------------------------------------------------------------------------*/
I 54 static void
rop_copy_bw_rgb16(RASTER *rin, RASTER *rout, int x1, int y1, int x2, int y2,
int newx, int newy) {
UCHAR *rowin, *bytein;
USHORT *rowout, *pixout;
USHORT rgb_0, rgb_1;
int wrapin, wrapout, bit, bit_offs, startbit;
int x, lx, ly;
if (rin->type == RAS_WB) {
rgb_0 = 0xffff;
rgb_1 = 0x0000;
} else {
rgb_0 = 0x0000;
rgb_1 = 0xffff;
}
lx = x2 - x1 + 1;
ly = y2 - y1 + 1;
wrapin = (rin->wrap + 7) >> 3;
bit_offs = rin->bit_offs;
wrapout = rout->wrap;
rowin = (UCHAR *)rin->buffer + wrapin * y1 + ((x1 + bit_offs) >> 3);
startbit = 7 - ((x1 + bit_offs) & 7);
rowout = (USHORT *)rout->buffer + wrapout * newy + newx;
while (ly-- > 0) {
bytein = rowin;
bit = startbit;
pixout = rowout;
for (x = lx; x > 0; x--) {
*pixout++ = ((*bytein >> bit) & 1) ? rgb_1 : rgb_0;
if (bit == 0) {
bytein++;
bit = 7;
} else
bit--;
}
rowin += wrapin;
rowout += wrapout;
}
}
/*---------------------------------------------------------------------------*/
I 61 static void rop_zoom_out_bw_rgb16(RASTER *rin, RASTER *rout, int x1,
int y1, int x2, int y2, int newx,
int newy, int abs_zoom_level) {
UCHAR *rowin, *bytein, *in;
USHORT *rowout, *pixout;
int val_0, val_1, tmp;
int wrapin, wrapout, bitin, bit, bit_offs, startbit;
int x, y, lx, ly, xlast, ylast, xrest, yrest, i, j;
int factor, fac_fac_2_bits;
int fac_fac, yrest_fac, fac_xrest, yrest_xrest;
int fac_fac_2, yrest_fac_2, fac_xrest_2, yrest_xrest_2;
int fac_fac_4;
if (rin->type == RAS_WB) {
val_0 = 0xff;
val_1 = 0x00;
} else {
val_0 = 0x00;
val_1 = 0xff;
}
lx = x2 - x1 + 1;
ly = y2 - y1 + 1;
factor = 1 << abs_zoom_level;
xrest = lx & (factor - 1);
yrest = ly & (factor - 1);
xlast = x2 - xrest + 1;
ylast = y2 - yrest + 1;
fac_fac = factor * factor;
fac_fac_2 = fac_fac >> 1;
fac_fac_4 = fac_fac >> 2;
fac_fac_2_bits = 2 * abs_zoom_level - 1;
yrest_fac = yrest * factor;
yrest_fac_2 = yrest_fac >> 1;
fac_xrest = factor * xrest;
fac_xrest_2 = fac_xrest >> 1;
yrest_xrest = yrest * xrest;
yrest_xrest_2 = yrest_xrest >> 1;
wrapin = (rin->wrap + 7) >> 3;
bit_offs = rin->bit_offs;
wrapout = rout->wrap;
rowin = (UCHAR *)rin->buffer + wrapin * y1 + ((x1 + bit_offs) >> 3);
startbit = 7 - ((x1 + bit_offs) & 7);
rowout = (USHORT *)rout->buffer + wrapout * newy + newx;
for (y = y1; y < ylast; y += factor) {
bytein = rowin;
bitin = startbit;
pixout = rowout;
for (x = x1; x < xlast; x += factor) {
tmp = 0;
in = bytein;
bit = bitin;
for (j = 0; j < factor; j += 2) {
for (i = 0; i < factor; i += 2) {
tmp += ((*in >> bit) & 1);
in += wrapin;
if (bit == 0) {
in++;
bit = 7;
} else
bit--;
tmp += ((*in >> bit) & 1);
in -= wrapin;
if (bit == 0) {
in++;
bit = 7;
} else
bit--;
}
in += 2 * wrapin;
bit += factor;
while (bit > 7) {
in--;
bit -= 8;
}
}
tmp = tmp * val_1 + (fac_fac_2 - tmp) * val_0;
tmp = (tmp + fac_fac_4) >> fac_fac_2_bits;
*pixout++ = PIX_RGB16_FROM_BYTES(tmp, tmp, tmp);
bitin -= factor;
while (bitin < 0) {
bytein++;
bitin += 8;
}
}
if (xrest) {
tmp = 0;
for (j = 0; j < factor; j++)
for (i = 0; i < xrest; i++) {
tmp += GET_BIT(i, j, bytein, wrapin, 7 - bitin);
}
tmp = tmp * val_1 + (fac_xrest - tmp) * val_0;
tmp = (tmp + fac_xrest_2) / fac_xrest;
*pixout = PIX_RGB16_FROM_BYTES(tmp, tmp, tmp);
}
rowin += wrapin * factor;
rowout += wrapout;
}
if (yrest) {
bytein = rowin;
bitin = startbit;
pixout = rowout;
for (x = x1; x < xlast; x += factor) {
tmp = 0;
for (j = 0; j < yrest; j++)
for (i = 0; i < factor; i++) {
tmp += GET_BIT(i, j, bytein, wrapin, 7 - bitin);
}
tmp = tmp * val_1 + (yrest_fac - tmp) * val_0;
tmp = (tmp + yrest_fac_2) / yrest_fac;
*pixout++ = PIX_RGB16_FROM_BYTES(tmp, tmp, tmp);
bitin -= factor;
while (bitin < 0) {
bytein++;
bitin += 8;
}
}
if (xrest) {
tmp = 0;
for (j = 0; j < yrest; j++)
for (i = 0; i < xrest; i++) {
tmp += GET_BIT(i, j, bytein, wrapin, 7 - bitin);
}
tmp = tmp * val_1 + (yrest_xrest - tmp) * val_0;
tmp = (tmp + yrest_xrest_2) / yrest_xrest;
*pixout = PIX_RGB16_FROM_BYTES(tmp, tmp, tmp);
}
}
}
/*---------------------------------------------------------------------------*/
E 61 static void rop_copy_gr8_rgb16(RASTER *rin, RASTER *rout, int x1, int y1,
int x2, int y2, int newx, int newy) {
UCHAR *rowin, *pixin, val;
USHORT *rowout, *pixout;
int wrapin, wrapout;
int x, y, lx, ly;
lx = x2 - x1 + 1;
ly = y2 - y1 + 1;
wrapin = rin->wrap;
wrapout = rout->wrap;
rowin = (UCHAR *)rin->buffer + wrapin * y1 + x1;
rowout = (USHORT *)rout->buffer + wrapout * newy + newx;
while (ly-- > 0) {
pixin = rowin;
pixout = rowout;
for (x = 0; x < lx; x++) {
val = *pixin++;
D 60 *pixout++ = ROP_RGB16_FROM_BYTES(val, val, val);
E 60
I 60 *pixout++ = PIX_RGB16_FROM_BYTES(val, val, val);
E 60
}
rowin += wrapin;
rowout += wrapout;
}
}
/*---------------------------------------------------------------------------*/
static void rop_zoom_out_gr8_rgb16(RASTER *rin, RASTER *rout, int x1, int y1,
int x2, int y2, int newx, int newy,
int abs_zoom_level) {
UCHAR *rowin, *pixin, *in;
USHORT *rowout, *pixout;
int tmp;
int wrapin, wrapout;
int x, y, lx, ly, xlast, ylast, xrest, yrest, i, j;
int factor, fac_fac_2_bits;
int fac_fac, yrest_fac, fac_xrest, yrest_xrest;
int fac_fac_2, yrest_fac_2, fac_xrest_2, yrest_xrest_2;
int fac_fac_4;
lx = x2 - x1 + 1;
ly = y2 - y1 + 1;
factor = 1 << abs_zoom_level;
D 61 xrest = lx % factor;
yrest = ly % factor;
E 61
I 61 xrest = lx & (factor - 1);
yrest = ly & (factor - 1);
E 61 xlast = x2 - xrest + 1;
ylast = y2 - yrest + 1;
fac_fac = factor * factor;
fac_fac_2 = fac_fac >> 1;
fac_fac_4 = fac_fac >> 2;
fac_fac_2_bits = 2 * abs_zoom_level - 1;
yrest_fac = yrest * factor;
yrest_fac_2 = yrest_fac >> 1;
fac_xrest = factor * xrest;
fac_xrest_2 = fac_xrest >> 1;
yrest_xrest = yrest * xrest;
yrest_xrest_2 = yrest_xrest >> 1;
wrapin = rin->wrap;
wrapout = rout->wrap;
rowin = (UCHAR *)rin->buffer + wrapin * y1 + x1;
rowout = (USHORT *)rout->buffer + wrapout * newy + newx;
for (y = y1; y < ylast; y += factor) {
pixin = rowin;
pixout = rowout;
for (x = x1; x < xlast; x += factor) {
tmp = 0;
in = pixin;
for (j = 0; j < factor; j += 2) {
for (i = 0; i < factor; i += 2) {
tmp += *in;
in += wrapin;
in++;
tmp += *in;
in -= wrapin;
in++;
}
in += 2 * wrapin - factor;
}
tmp = (tmp + fac_fac_4) >> fac_fac_2_bits;
D 60 *pixout++ = ROP_RGB16_FROM_BYTES(tmp, tmp, tmp);
E 60
I 60 *pixout++ = PIX_RGB16_FROM_BYTES(tmp, tmp, tmp);
E 60 pixin += factor;
}
if (xrest) {
tmp = 0;
for (j = 0; j < factor; j++)
for (i = 0; i < xrest; i++) {
tmp += pixin[i + j * wrapin];
}
tmp = (tmp + fac_xrest_2) / fac_xrest;
D 60 *pixout = ROP_RGB16_FROM_BYTES(tmp, tmp, tmp);
E 60
I 60 *pixout = PIX_RGB16_FROM_BYTES(tmp, tmp, tmp);
E 60
}
rowin += wrapin * factor;
rowout += wrapout;
}
if (yrest) {
pixin = rowin;
pixout = rowout;
for (x = x1; x < xlast; x += factor) {
tmp = 0;
for (j = 0; j < yrest; j++)
for (i = 0; i < factor; i++) {
tmp += pixin[i + j * wrapin];
}
tmp = (tmp + yrest_fac_2) / yrest_fac;
D 60 *pixout++ = ROP_RGB16_FROM_BYTES(tmp, tmp, tmp);
E 60
I 60 *pixout++ = PIX_RGB16_FROM_BYTES(tmp, tmp, tmp);
E 60 pixin += factor;
}
if (xrest) {
tmp = 0;
for (j = 0; j < yrest; j++)
for (i = 0; i < xrest; i++) {
tmp += pixin[i + j * wrapin];
}
tmp = (tmp + yrest_xrest_2) / yrest_xrest;
D 60 *pixout = ROP_RGB16_FROM_BYTES(tmp, tmp, tmp);
E 60
I 60 *pixout = PIX_RGB16_FROM_BYTES(tmp, tmp, tmp);
E 60
}
}
}
/*---------------------------------------------------------------------------*/
E 54
I 52 static void rop_copy_cm16_rgb16(RASTER *rin, RASTER *rout, int x1,
int y1, int x2, int y2, int newx,
int newy) {
USHORT *rowin, *pixin;
LPIXEL *cmap, val;
USHORT *rowout, *pixout;
int wrapin, wrapout;
int x, y, lx, ly;
D 56 cmap = rin->cmap.buffer - rin->cmap.offset;
E 56
I 56 cmap = rin->cmap.buffer - rin->cmap.info.offset_mask;
E 56 lx = x2 - x1 + 1;
ly = y2 - y1 + 1;
wrapin = rin->wrap;
wrapout = rout->wrap;
rowin = (USHORT *)rin->buffer + wrapin * y1 + x1;
rowout = (USHORT *)rout->buffer + wrapout * newy + newx;
while (ly-- > 0) {
pixin = rowin;
pixout = rowout;
for (x = 0; x < lx; x++) {
val = cmap[*pixin++];
D 54 *pixout++ = BYTES_TO_RGB16(val.r, val.g, val.b);
E 54
I 54
D 60 *pixout++ = ROP_RGB16_FROM_BYTES(val.r, val.g, val.b);
E 60
I 60 *pixout++ = PIX_RGB16_FROM_BYTES(val.r, val.g, val.b);
E 60
E 54
}
rowin += wrapin;
rowout += wrapout;
}
}
/*---------------------------------------------------------------------------*/
I 96 static void rop_copy_cm16_xrgb1555(RASTER *rin, RASTER *rout, int x1,
int y1, int x2, int y2, int newx,
int newy) {
USHORT *rowin, *pixin;
LPIXEL *cmap, val;
USHORT *rowout, *pixout;
int wrapin, wrapout;
int x, y, lx, ly;
cmap = rin->cmap.buffer - rin->cmap.info.offset_mask;
lx = x2 - x1 + 1;
ly = y2 - y1 + 1;
wrapin = rin->wrap;
wrapout = rout->wrap;
rowin = (USHORT *)rin->buffer + wrapin * y1 + x1;
rowout = (USHORT *)rout->buffer + wrapout * newy + newx;
while (ly-- > 0) {
pixin = rowin;
pixout = rowout;
for (x = 0; x < lx; x++) {
val = cmap[*pixin++];
*pixout++ = PIX_XRGB1555_FROM_BYTES(val.r, val.g, val.b);
}
rowin += wrapin;
rowout += wrapout;
}
}
/*---------------------------------------------------------------------------*/
E 96
I 84 static void rop_copy_cm24_rgb16(RASTER *rin, RASTER *rout, int x1,
int y1, int x2, int y2, int newx,
int newy) {
ULONG *rowin, *pixin, win;
LPIXEL *penmap, *colmap, val;
USHORT *rowout, *pixout;
int wrapin, wrapout;
int x, y, lx, ly;
penmap = rin->cmap.penbuffer;
colmap = rin->cmap.colbuffer;
lx = x2 - x1 + 1;
ly = y2 - y1 + 1;
wrapin = rin->wrap;
wrapout = rout->wrap;
rowin = (ULONG *)rin->buffer + wrapin * y1 + x1;
rowout = (USHORT *)rout->buffer + wrapout * newy + newx;
I 89
E 89 while (ly-- > 0) {
pixin = rowin;
pixout = rowout;
for (x = 0; x < lx; x++) {
win = *pixin++;
MAP24(win, penmap, colmap, val)
*pixout++ = PIX_RGB16_FROM_BYTES(val.r, val.g, val.b);
}
rowin += wrapin;
rowout += wrapout;
}
I 89 if (rout->extra_mask)
rop_copy_extra(rin, rout, x1, y1, x2, y2, newx, newy);
E 89
}
/*---------------------------------------------------------------------------*/
I 96 static void rop_copy_cm24_xrgb1555(RASTER *rin, RASTER *rout, int x1,
int y1, int x2, int y2, int newx,
int newy) {
ULONG *rowin, *pixin, win;
LPIXEL *penmap, *colmap, val;
USHORT *rowout, *pixout;
int wrapin, wrapout;
int x, y, lx, ly;
penmap = rin->cmap.penbuffer;
colmap = rin->cmap.colbuffer;
lx = x2 - x1 + 1;
ly = y2 - y1 + 1;
wrapin = rin->wrap;
wrapout = rout->wrap;
rowin = (ULONG *)rin->buffer + wrapin * y1 + x1;
rowout = (USHORT *)rout->buffer + wrapout * newy + newx;
while (ly-- > 0) {
pixin = rowin;
pixout = rowout;
for (x = 0; x < lx; x++) {
win = *pixin++;
MAP24(win, penmap, colmap, val)
*pixout++ = PIX_XRGB1555_FROM_BYTES(val.r, val.g, val.b);
}
rowin += wrapin;
rowout += wrapout;
}
if (rout->extra_mask) rop_copy_extra(rin, rout, x1, y1, x2, y2, newx, newy);
}
/*---------------------------------------------------------------------------*/
E 96
E 84 static void rop_zoom_out_cm16_rgb16(RASTER *rin, RASTER *rout, int x1,
int y1, int x2, int y2, int newx,
int newy, int abs_zoom_level) {
USHORT *rowin, *pixin, *in;
LPIXEL *cmap, valin;
USHORT *rowout, *pixout;
int tmp_r, tmp_g, tmp_b;
int wrapin, wrapout;
int x, y, lx, ly, xlast, ylast, xrest, yrest, i, j;
int factor, fac_fac_2_bits;
int fac_fac, yrest_fac, fac_xrest, yrest_xrest;
int fac_fac_2, yrest_fac_2, fac_xrest_2, yrest_xrest_2;
int fac_fac_4;
D 56 cmap = rin->cmap.buffer - rin->cmap.offset;
E 56
I 56 cmap = rin->cmap.buffer - rin->cmap.info.offset_mask;
E 56 lx = x2 - x1 + 1;
ly = y2 - y1 + 1;
factor = 1 << abs_zoom_level;
D 61 xrest = lx % factor;
yrest = ly % factor;
E 61
I 61 xrest = lx & (factor - 1);
yrest = ly & (factor - 1);
E 61 xlast = x2 - xrest + 1;
ylast = y2 - yrest + 1;
fac_fac = factor * factor;
fac_fac_2 = fac_fac >> 1;
fac_fac_4 = fac_fac >> 2;
fac_fac_2_bits = 2 * abs_zoom_level - 1;
yrest_fac = yrest * factor;
yrest_fac_2 = yrest_fac >> 1;
fac_xrest = factor * xrest;
fac_xrest_2 = fac_xrest >> 1;
yrest_xrest = yrest * xrest;
yrest_xrest_2 = yrest_xrest >> 1;
wrapin = rin->wrap;
wrapout = rout->wrap;
rowin = (USHORT *)rin->buffer + wrapin * y1 + x1;
rowout = (USHORT *)rout->buffer + wrapout * newy + newx;
for (y = y1; y < ylast; y += factor) {
pixin = rowin;
pixout = rowout;
for (x = x1; x < xlast; x += factor) {
tmp_r = tmp_g = tmp_b = 0;
in = pixin;
for (j = 0; j < factor; j += 2) {
for (i = 0; i < factor; i += 2) {
valin = cmap[*in];
tmp_r += valin.r;
tmp_g += valin.g;
tmp_b += valin.b;
in += wrapin;
in++;
valin = cmap[*in];
tmp_r += valin.r;
tmp_g += valin.g;
tmp_b += valin.b;
in -= wrapin;
in++;
}
in += 2 * wrapin - factor;
}
tmp_r = (tmp_r + fac_fac_4) >> fac_fac_2_bits;
tmp_g = (tmp_g + fac_fac_4) >> fac_fac_2_bits;
tmp_b = (tmp_b + fac_fac_4) >> fac_fac_2_bits;
D 54 *pixout++ = BYTES_TO_RGB16(tmp_r, tmp_g, tmp_b);
E 54
I 54
D 60 *pixout++ = ROP_RGB16_FROM_BYTES(tmp_r, tmp_g, tmp_b);
E 60
I 60 *pixout++ = PIX_RGB16_FROM_BYTES(tmp_r, tmp_g, tmp_b);
E 60
E 54 pixin += factor;
}
if (xrest) {
tmp_r = tmp_g = tmp_b = 0;
for (j = 0; j < factor; j++)
for (i = 0; i < xrest; i++) {
valin = cmap[pixin[i + j * wrapin]];
tmp_r += valin.r;
tmp_g += valin.g;
tmp_b += valin.b;
}
tmp_r = (tmp_r + fac_xrest_2) / fac_xrest;
tmp_g = (tmp_g + fac_xrest_2) / fac_xrest;
tmp_b = (tmp_b + fac_xrest_2) / fac_xrest;
D 54 *pixout = BYTES_TO_RGB16(tmp_r, tmp_g, tmp_b);
E 54
I 54
D 60 *pixout = ROP_RGB16_FROM_BYTES(tmp_r, tmp_g, tmp_b);
E 60
I 60 *pixout = PIX_RGB16_FROM_BYTES(tmp_r, tmp_g, tmp_b);
E 60
E 54
}
rowin += wrapin * factor;
rowout += wrapout;
}
if (yrest) {
pixin = rowin;
pixout = rowout;
for (x = x1; x < xlast; x += factor) {
tmp_r = tmp_g = tmp_b = 0;
for (j = 0; j < yrest; j++)
for (i = 0; i < factor; i++) {
valin = cmap[pixin[i + j * wrapin]];
tmp_r += valin.r;
tmp_g += valin.g;
tmp_b += valin.b;
}
tmp_r = (tmp_r + yrest_fac_2) / yrest_fac;
tmp_g = (tmp_g + yrest_fac_2) / yrest_fac;
tmp_b = (tmp_b + yrest_fac_2) / yrest_fac;
D 54 *pixout++ = BYTES_TO_RGB16(tmp_r, tmp_g, tmp_b);
E 54
I 54
D 60 *pixout++ = ROP_RGB16_FROM_BYTES(tmp_r, tmp_g, tmp_b);
E 60
I 60 *pixout++ = PIX_RGB16_FROM_BYTES(tmp_r, tmp_g, tmp_b);
E 60
E 54 pixin += factor;
}
if (xrest) {
tmp_r = tmp_g = tmp_b = 0;
for (j = 0; j < yrest; j++)
for (i = 0; i < xrest; i++) {
valin = cmap[pixin[i + j * wrapin]];
tmp_r += valin.r;
tmp_g += valin.g;
tmp_b += valin.b;
}
tmp_r = (tmp_r + yrest_xrest_2) / yrest_xrest;
tmp_g = (tmp_g + yrest_xrest_2) / yrest_xrest;
tmp_b = (tmp_b + yrest_xrest_2) / yrest_xrest;
D 54 *pixout = BYTES_TO_RGB16(tmp_r, tmp_g, tmp_b);
E 54
I 54
D 60 *pixout = ROP_RGB16_FROM_BYTES(tmp_r, tmp_g, tmp_b);
E 60
I 60 *pixout = PIX_RGB16_FROM_BYTES(tmp_r, tmp_g, tmp_b);
E 60
E 54
}
}
}
/*---------------------------------------------------------------------------*/
I 84 static void rop_zoom_out_cm24_rgb16(RASTER *rin, RASTER *rout, int x1,
int y1, int x2, int y2, int newx,
int newy, int abs_zoom_level) {
ULONG *rowin, *pixin, *in, win;
LPIXEL *penmap, *colmap, valin;
USHORT *rowout, *pixout;
int tmp_r, tmp_g, tmp_b;
int wrapin, wrapout;
int x, y, lx, ly, xlast, ylast, xrest, yrest, i, j;
int factor, fac_fac_2_bits;
int fac_fac, yrest_fac, fac_xrest, yrest_xrest;
int fac_fac_2, yrest_fac_2, fac_xrest_2, yrest_xrest_2;
int fac_fac_4;
penmap = rin->cmap.penbuffer;
colmap = rin->cmap.colbuffer;
lx = x2 - x1 + 1;
ly = y2 - y1 + 1;
factor = 1 << abs_zoom_level;
xrest = lx & (factor - 1);
yrest = ly & (factor - 1);
xlast = x2 - xrest + 1;
ylast = y2 - yrest + 1;
fac_fac = factor * factor;
fac_fac_2 = fac_fac >> 1;
fac_fac_4 = fac_fac >> 2;
fac_fac_2_bits = 2 * abs_zoom_level - 1;
yrest_fac = yrest * factor;
yrest_fac_2 = yrest_fac >> 1;
fac_xrest = factor * xrest;
fac_xrest_2 = fac_xrest >> 1;
yrest_xrest = yrest * xrest;
yrest_xrest_2 = yrest_xrest >> 1;
wrapin = rin->wrap;
wrapout = rout->wrap;
rowin = (ULONG *)rin->buffer + wrapin * y1 + x1;
rowout = (USHORT *)rout->buffer + wrapout * newy + newx;
for (y = y1; y < ylast; y += factor) {
pixin = rowin;
pixout = rowout;
for (x = x1; x < xlast; x += factor) {
tmp_r = tmp_g = tmp_b = 0;
in = pixin;
for (j = 0; j < factor; j += 2) {
for (i = 0; i < factor; i += 2) {
win = *in;
MAP24_64(win, penmap, colmap, valin)
tmp_r += valin.r;
tmp_g += valin.g;
tmp_b += valin.b;
in += wrapin;
in++;
win = *in;
MAP24_64(win, penmap, colmap, valin)
tmp_r += valin.r;
tmp_g += valin.g;
tmp_b += valin.b;
in -= wrapin;
in++;
}
in += 2 * wrapin - factor;
}
tmp_r = (tmp_r + fac_fac_4) >> fac_fac_2_bits;
tmp_g = (tmp_g + fac_fac_4) >> fac_fac_2_bits;
tmp_b = (tmp_b + fac_fac_4) >> fac_fac_2_bits;
*pixout++ = PIX_RGB16_FROM_BYTES(tmp_r, tmp_g, tmp_b);
pixin += factor;
}
if (xrest) {
tmp_r = tmp_g = tmp_b = 0;
for (j = 0; j < factor; j++)
for (i = 0; i < xrest; i++) {
win = pixin[i + j * wrapin];
MAP24_64(win, penmap, colmap, valin)
tmp_r += valin.r;
tmp_g += valin.g;
tmp_b += valin.b;
}
tmp_r = (tmp_r + fac_xrest_2) / fac_xrest;
tmp_g = (tmp_g + fac_xrest_2) / fac_xrest;
tmp_b = (tmp_b + fac_xrest_2) / fac_xrest;
*pixout = PIX_RGB16_FROM_BYTES(tmp_r, tmp_g, tmp_b);
}
rowin += wrapin * factor;
rowout += wrapout;
}
if (yrest) {
pixin = rowin;
pixout = rowout;
for (x = x1; x < xlast; x += factor) {
tmp_r = tmp_g = tmp_b = 0;
for (j = 0; j < yrest; j++)
for (i = 0; i < factor; i++) {
win = pixin[i + j * wrapin];
MAP24_64(win, penmap, colmap, valin)
tmp_r += valin.r;
tmp_g += valin.g;
tmp_b += valin.b;
}
tmp_r = (tmp_r + yrest_fac_2) / yrest_fac;
tmp_g = (tmp_g + yrest_fac_2) / yrest_fac;
tmp_b = (tmp_b + yrest_fac_2) / yrest_fac;
*pixout++ = PIX_RGB16_FROM_BYTES(tmp_r, tmp_g, tmp_b);
pixin += factor;
}
if (xrest) {
tmp_r = tmp_g = tmp_b = 0;
for (j = 0; j < yrest; j++)
for (i = 0; i < xrest; i++) {
win = pixin[i + j * wrapin];
MAP24_64(win, penmap, colmap, valin)
tmp_r += valin.r;
tmp_g += valin.g;
tmp_b += valin.b;
}
tmp_r = (tmp_r + yrest_xrest_2) / yrest_xrest;
tmp_g = (tmp_g + yrest_xrest_2) / yrest_xrest;
tmp_b = (tmp_b + yrest_xrest_2) / yrest_xrest;
*pixout = PIX_RGB16_FROM_BYTES(tmp_r, tmp_g, tmp_b);
}
}
}
/*---------------------------------------------------------------------------*/
E 84 static void rop_copy_rgbx_rgb16(RASTER *rin, RASTER *rout, int x1, int y1,
int x2, int y2, int newx, int newy) {
LPIXEL *rowin, *pixin, val;
USHORT *rowout, *pixout;
int wrapin, wrapout;
int x, y, lx, ly;
lx = x2 - x1 + 1;
ly = y2 - y1 + 1;
wrapin = rin->wrap;
wrapout = rout->wrap;
rowin = (LPIXEL *)rin->buffer + wrapin * y1 + x1;
rowout = (USHORT *)rout->buffer + wrapout * newy + newx;
while (ly-- > 0) {
pixin = rowin;
pixout = rowout;
for (x = 0; x < lx; x++) {
val = *pixin++;
D 70 *pixout++ =
(val.r << 8) & 0xf800 | (val.g << 3) & 0x7e0 | (val.b >> 3);
E 70
I 70 *pixout++ = PIX_RGB16_FROM_RGBX(val);
E 70
}
rowin += wrapin;
rowout += wrapout;
}
}
I 95
/*---------------------------------------------------------------------------*/
I 96
#define SWAP_SHORT(N) (((N) >> 8) | ((N) << 8))
E 96
I 96
static void
rop_copy_rgbx_xrgb1555(RASTER *rin, RASTER *rout, int x1, int y1, int x2,
int y2, int newx, int newy) {
LPIXEL *rowin, *pixin, val;
USHORT *rowout, *pixout, outval;
int wrapin, wrapout;
int x, y, lx, ly;
lx = x2 - x1 + 1;
ly = y2 - y1 + 1;
wrapin = rin->wrap;
wrapout = rout->wrap;
rowin = (LPIXEL *)rin->buffer + wrapin * y1 + x1;
rowout = (USHORT *)rout->buffer + wrapout * newy + newx;
while (ly-- > 0) {
pixin = rowin;
pixout = rowout;
for (x = 0; x < lx; x++) {
val = *pixin++;
outval = PIX_XRGB1555_FROM_RGBX(val);
*pixout++ = SWAP_SHORT(outval);
}
rowin += wrapin;
rowout += wrapout;
}
}
/*---------------------------------------------------------------------------*/
E 96 static void rop_copy_rgbx64_rgb16(RASTER *rin, RASTER *rout, int x1,
int y1, int x2, int y2, int newx,
int newy) {
SPIXEL *rowin, *pixin, val;
USHORT *rowout, *pixout;
int wrapin, wrapout;
int x, y, lx, ly;
lx = x2 - x1 + 1;
ly = y2 - y1 + 1;
wrapin = rin->wrap;
wrapout = rout->wrap;
E 95
I 95 rowin = (SPIXEL *)rin->buffer + wrapin * y1 + x1;
rowout = (USHORT *)rout->buffer + wrapout * newy + newx;
while (ly-- > 0) {
pixin = rowin;
pixout = rowout;
for (x = 0; x < lx; x++) {
val = *pixin++;
*pixout++ = PIX_RGB16_FROM_RGBX64(val);
}
rowin += wrapin;
rowout += wrapout;
}
}
E 95
/*---------------------------------------------------------------------------*/
I 96 static void
rop_copy_rgbx64_xrgb1555(RASTER *rin, RASTER *rout, int x1, int y1, int x2,
int y2, int newx, int newy) {
SPIXEL *rowin, *pixin, val;
USHORT *rowout, *pixout;
int wrapin, wrapout;
int x, y, lx, ly;
lx = x2 - x1 + 1;
ly = y2 - y1 + 1;
wrapin = rin->wrap;
wrapout = rout->wrap;
rowin = (SPIXEL *)rin->buffer + wrapin * y1 + x1;
rowout = (USHORT *)rout->buffer + wrapout * newy + newx;
while (ly-- > 0) {
pixin = rowin;
pixout = rowout;
for (x = 0; x < lx; x++) {
val = *pixin++;
*pixout++ = PIX_XRGB1555_FROM_RGBX64(val);
}
rowin += wrapin;
rowout += wrapout;
}
}
/*---------------------------------------------------------------------------*/
E 96
I 70 static void rop_copy_rgb16_rgbm(RASTER *rin, RASTER *rout, int x1,
int y1, int x2, int y2, int newx,
int newy) {
USHORT *rowin, *pixin;
LPIXEL *rowout, *pixout;
int wrapin, wrapout;
int x, y, lx, ly;
lx = x2 - x1 + 1;
ly = y2 - y1 + 1;
wrapin = rin->wrap;
wrapout = rout->wrap;
rowin = (USHORT *)rin->buffer + wrapin * y1 + x1;
rowout = (LPIXEL *)rout->buffer + wrapout * newy + newx;
while (ly-- > 0) {
pixin = rowin;
pixout = rowout;
for (x = 0; x < lx; x++, *pixin++, *pixout++)
PIX_RGB16_TO_RGBM(*pixin, *pixout)
rowin += wrapin;
rowout += wrapout;
}
}
/*---------------------------------------------------------------------------*/
I 96 static void rop_copy_xrgb1555_rgbm(RASTER *rin, RASTER *rout, int x1,
int y1, int x2, int y2, int newx,
int newy) {
USHORT *rowin, *pixin;
LPIXEL *rowout, *pixout;
int wrapin, wrapout;
int x, y, lx, ly;
lx = x2 - x1 + 1;
ly = y2 - y1 + 1;
wrapin = rin->wrap;
wrapout = rout->wrap;
rowin = (USHORT *)rin->buffer + wrapin * y1 + x1;
rowout = (LPIXEL *)rout->buffer + wrapout * newy + newx;
while (ly-- > 0) {
pixin = rowin;
pixout = rowout;
for (x = 0; x < lx; x++, *pixin++, *pixout++)
PIX_XRGB1555_TO_RGBM(*pixin, *pixout)
rowin += wrapin;
rowout += wrapout;
}
}
/*---------------------------------------------------------------------------*/
E 96
E 70 static void rop_zoom_out_rgbx_rgb16(RASTER *rin, RASTER *rout, int x1,
int y1, int x2, int y2, int newx,
int newy, int abs_zoom_level) {
LPIXEL *rowin, *pixin, *in, valin;
USHORT *rowout, *pixout;
int tmp_r, tmp_g, tmp_b;
int wrapin, wrapout;
int x, y, lx, ly, xlast, ylast, xrest, yrest, i, j;
int factor, fac_fac_2_bits;
int fac_fac, yrest_fac, fac_xrest, yrest_xrest;
int fac_fac_2, yrest_fac_2, fac_xrest_2, yrest_xrest_2;
int fac_fac_4;
lx = x2 - x1 + 1;
ly = y2 - y1 + 1;
factor = 1 << abs_zoom_level;
D 61 xrest = lx % factor;
yrest = ly % factor;
E 61
I 61 xrest = lx & (factor - 1);
yrest = ly & (factor - 1);
E 61 xlast = x2 - xrest + 1;
ylast = y2 - yrest + 1;
fac_fac = factor * factor;
fac_fac_2 = fac_fac >> 1;
fac_fac_4 = fac_fac >> 2;
fac_fac_2_bits = 2 * abs_zoom_level - 1;
yrest_fac = yrest * factor;
yrest_fac_2 = yrest_fac >> 1;
fac_xrest = factor * xrest;
fac_xrest_2 = fac_xrest >> 1;
yrest_xrest = yrest * xrest;
yrest_xrest_2 = yrest_xrest >> 1;
wrapin = rin->wrap;
wrapout = rout->wrap;
rowin = (LPIXEL *)rin->buffer + wrapin * y1 + x1;
rowout = (USHORT *)rout->buffer + wrapout * newy + newx;
for (y = y1; y < ylast; y += factor) {
pixin = rowin;
pixout = rowout;
for (x = x1; x < xlast; x += factor) {
tmp_r = tmp_g = tmp_b = 0;
in = pixin;
for (j = 0; j < factor; j += 2) {
for (i = 0; i < factor; i += 2) {
valin = *in;
tmp_r += valin.r;
tmp_g += valin.g;
tmp_b += valin.b;
in += wrapin;
in++;
valin = *in;
tmp_r += valin.r;
tmp_g += valin.g;
tmp_b += valin.b;
in -= wrapin;
in++;
}
in += 2 * wrapin - factor;
}
tmp_r = (tmp_r + fac_fac_4) >> fac_fac_2_bits;
tmp_g = (tmp_g + fac_fac_4) >> fac_fac_2_bits;
tmp_b = (tmp_b + fac_fac_4) >> fac_fac_2_bits;
D 54 *pixout++ = BYTES_TO_RGB16(tmp_r, tmp_g, tmp_b);
E 54
I 54
D 60 *pixout++ = ROP_RGB16_FROM_BYTES(tmp_r, tmp_g, tmp_b);
E 60
I 60 *pixout++ = PIX_RGB16_FROM_BYTES(tmp_r, tmp_g, tmp_b);
E 60
E 54 pixin += factor;
}
if (xrest) {
tmp_r = tmp_g = tmp_b = 0;
for (j = 0; j < factor; j++)
for (i = 0; i < xrest; i++) {
valin = pixin[i + j * wrapin];
tmp_r += valin.r;
tmp_g += valin.g;
tmp_b += valin.b;
}
tmp_r = (tmp_r + fac_xrest_2) / fac_xrest;
tmp_g = (tmp_g + fac_xrest_2) / fac_xrest;
tmp_b = (tmp_b + fac_xrest_2) / fac_xrest;
D 54 *pixout = BYTES_TO_RGB16(tmp_r, tmp_g, tmp_b);
E 54
I 54
D 60 *pixout = ROP_RGB16_FROM_BYTES(tmp_r, tmp_g, tmp_b);
E 60
I 60 *pixout = PIX_RGB16_FROM_BYTES(tmp_r, tmp_g, tmp_b);
E 60
E 54
}
rowin += wrapin * factor;
rowout += wrapout;
}
if (yrest) {
pixin = rowin;
pixout = rowout;
for (x = x1; x < xlast; x += factor) {
tmp_r = tmp_g = tmp_b = 0;
for (j = 0; j < yrest; j++)
for (i = 0; i < factor; i++) {
valin = pixin[i + j * wrapin];
tmp_r += valin.r;
tmp_g += valin.g;
tmp_b += valin.b;
}
tmp_r = (tmp_r + yrest_fac_2) / yrest_fac;
tmp_g = (tmp_g + yrest_fac_2) / yrest_fac;
tmp_b = (tmp_b + yrest_fac_2) / yrest_fac;
D 54 *pixout++ = BYTES_TO_RGB16(tmp_r, tmp_g, tmp_b);
E 54
I 54
D 60 *pixout++ = ROP_RGB16_FROM_BYTES(tmp_r, tmp_g, tmp_b);
E 60
I 60 *pixout++ = PIX_RGB16_FROM_BYTES(tmp_r, tmp_g, tmp_b);
E 60
E 54 pixin += factor;
}
if (xrest) {
tmp_r = tmp_g = tmp_b = 0;
for (j = 0; j < yrest; j++)
for (i = 0; i < xrest; i++) {
valin = pixin[i + j * wrapin];
tmp_r += valin.r;
tmp_g += valin.g;
tmp_b += valin.b;
}
tmp_r = (tmp_r + yrest_xrest_2) / yrest_xrest;
tmp_g = (tmp_g + yrest_xrest_2) / yrest_xrest;
tmp_b = (tmp_b + yrest_xrest_2) / yrest_xrest;
D 54 *pixout = BYTES_TO_RGB16(tmp_r, tmp_g, tmp_b);
E 54
I 54
D 60 *pixout = ROP_RGB16_FROM_BYTES(tmp_r, tmp_g, tmp_b);
E 60
I 60 *pixout = PIX_RGB16_FROM_BYTES(tmp_r, tmp_g, tmp_b);
E 60
E 54
}
}
}
/*---------------------------------------------------------------------------*/
I 95 static void rop_zoom_out_rgbx64_rgb16(RASTER *rin, RASTER *rout, int x1,
int y1, int x2, int y2, int newx,
int newy, int abs_zoom_level) {
SPIXEL *rowin, *pixin, *in, valin;
USHORT *rowout, *pixout;
int tmp_r, tmp_g, tmp_b;
int wrapin, wrapout;
int x, y, lx, ly, xlast, ylast, xrest, yrest, i, j;
int factor, fac_fac_2_bits;
int fac_fac, yrest_fac, fac_xrest, yrest_xrest;
int fac_fac_2, yrest_fac_2, fac_xrest_2, yrest_xrest_2;
int fac_fac_4;
lx = x2 - x1 + 1;
ly = y2 - y1 + 1;
factor = 1 << abs_zoom_level;
xrest = lx & (factor - 1);
yrest = ly & (factor - 1);
xlast = x2 - xrest + 1;
ylast = y2 - yrest + 1;
fac_fac = factor * factor;
fac_fac_4 = fac_fac >> 2;
fac_fac_2_bits = 2 * abs_zoom_level - 1;
yrest_fac = yrest * factor;
yrest_fac_2 = yrest_fac >> 1;
fac_xrest = factor * xrest;
fac_xrest_2 = fac_xrest >> 1;
yrest_xrest = yrest * xrest;
yrest_xrest_2 = yrest_xrest >> 1;
/*dafare*/
wrapin = rin->wrap;
wrapout = rout->wrap;
rowin = (SPIXEL *)rin->buffer + wrapin * y1 + x1;
rowout = (USHORT *)rout->buffer + wrapout * newy + newx;
for (y = y1; y < ylast; y += factor) {
pixin = rowin;
pixout = rowout;
for (x = x1; x < xlast; x += factor) {
tmp_r = tmp_g = tmp_b = 0;
in = pixin;
for (j = 0; j < factor; j += 2) {
for (i = 0; i < factor; i += 2) {
valin = *in;
tmp_r += valin.r;
tmp_g += valin.g;
tmp_b += valin.b;
in += wrapin;
in++;
valin = *in;
tmp_r += valin.r;
tmp_g += valin.g;
tmp_b += valin.b;
in -= wrapin;
in++;
}
in += 2 * wrapin - factor;
}
tmp_r = (tmp_r + fac_fac_4) >> fac_fac_2_bits;
tmp_g = (tmp_g + fac_fac_4) >> fac_fac_2_bits;
tmp_b = (tmp_b + fac_fac_4) >> fac_fac_2_bits;
*pixout++ = PIX_RGB16_FROM_USHORT(tmp_r, tmp_g, tmp_b);
pixin += factor;
}
if (xrest) {
tmp_r = tmp_g = tmp_b = 0;
for (j = 0; j < factor; j++)
for (i = 0; i < xrest; i++) {
valin = pixin[i + j * wrapin];
tmp_r += valin.r;
tmp_g += valin.g;
tmp_b += valin.b;
}
tmp_r = (tmp_r + fac_xrest_2) / fac_xrest;
tmp_g = (tmp_g + fac_xrest_2) / fac_xrest;
tmp_b = (tmp_b + fac_xrest_2) / fac_xrest;
*pixout = PIX_RGB16_FROM_USHORT(tmp_r, tmp_g, tmp_b);
}
rowin += wrapin * factor;
rowout += wrapout;
}
if (yrest) {
pixin = rowin;
pixout = rowout;
for (x = x1; x < xlast; x += factor) {
tmp_r = tmp_g = tmp_b = 0;
for (j = 0; j < yrest; j++)
for (i = 0; i < factor; i++) {
valin = pixin[i + j * wrapin];
tmp_r += valin.r;
tmp_g += valin.g;
tmp_b += valin.b;
}
tmp_r = (tmp_r + yrest_fac_2) / yrest_fac;
tmp_g = (tmp_g + yrest_fac_2) / yrest_fac;
tmp_b = (tmp_b + yrest_fac_2) / yrest_fac;
*pixout++ = PIX_RGB16_FROM_USHORT(tmp_r, tmp_g, tmp_b);
pixin += factor;
}
if (xrest) {
tmp_r = tmp_g = tmp_b = 0;
for (j = 0; j < yrest; j++)
for (i = 0; i < xrest; i++) {
valin = pixin[i + j * wrapin];
tmp_r += valin.r;
tmp_g += valin.g;
tmp_b += valin.b;
}
tmp_r = (tmp_r + yrest_xrest_2) / yrest_xrest;
tmp_g = (tmp_g + yrest_xrest_2) / yrest_xrest;
tmp_b = (tmp_b + yrest_xrest_2) / yrest_xrest;
*pixout = PIX_RGB16_FROM_USHORT(tmp_r, tmp_g, tmp_b);
}
}
}
/*---------------------------------------------------------------------------*/
E 95
E 52
E 46
E 28
E 20
/* copia un rettangolo da rin a rout.
* Le coordinate sono relative ai due raster: (0, 0) corrisponde
* al primo pixel del raster.
*
*/
void
rop_copy(RASTER *rin, RASTER *rout, int x1, int y1, int x2, int y2,
int newx, int newy) {
D 13 char *rowin, *rowout;
E 13
I 13
D 41 UCHAR *rowin, *rowout;
E 13
D 10 int rowsize, wrapin, wrapout, d, tmp;
E 10
I 10 int rowsize, bytewrapin, bytewrapout, d, tmp;
E 10
D 12 int pixbits_in, pixbits_out;
E 12
I 12 int pixbits_in, pixbits_out;
int pixbytes_in, pixbytes_out;
E 41
I 41 int tmp;
E 41
E 12
I 4 int rasras;
E 4
/* raddrizzo gli estremi */
if (x1 > x2) {
tmp = x1;
x1 = x2;
x2 = tmp;
}
if (y1 > y2) {
tmp = y1;
y1 = y2;
y2 = tmp;
}
/* controllo gli sconfinamenti */
if (x1 < 0 || y1 < 0 || x2 >= rin->lx || y2 >= rin->ly || newx < 0 ||
newy < 0 || newx + x2 - x1 >= rout->lx || newy + y2 - y1 >= rout->ly)
D 27 {
printf("### INTERNAL ERROR - rop_copy; access violation\n");
return;
}
E 27
I 27 {
printf(
"### INTERNAL ERROR - rop_copy; access violation\n"
" ((%d,%d)(%d,%d)in(%dx%d)->(%d,%d)in(%dx%d))\n",
x1, y1, x2, y2, rin->lx, rin->ly, newx, newy, rout->lx, rout->ly);
return;
}
E 27
D 2 if (rin->type == RAS_CM && rout->type == RAS_RGBM)
E 2
I 2
D 4 if (rin->type == RAS_CM16 && rout->type == RAS_RGBM)
E 2 {
D 2 rop_copy_cm_rgbm(rin, rout, x1, y1, x2, y2, newx, newy);
E 2
I 2 rop_copy_cm16_rgbm(rin, rout, x1, y1, x2, y2, newx, newy);
E 2 return;
}
E 4
D 10 pixbits_in = rop_pixbits(rin->type);
pixbits_out = rop_pixbits(rout->type);
E 10
I 10
D 23 pixbits_in = rop_pixbits(rin->type);
pixbytes_in = rop_pixbytes(rin->type);
pixbits_out = rop_pixbits(rout->type);
pixbytes_out = rop_pixbytes(rout->type);
E 23
E 10
D 4
E 4
I 4
D 96 rasras = RASRAS(rin->type, rout->type);
switch (rasras)
E 96
I 96 if (rin->type == rout->type)
rop_copy_same(rin, rout, x1, y1, x2, y2, newx, newy);
else E 96 {
I 73
D 96 CASE RASRAS(RAS_RGBM64, RAS_RGBM64)
: __OR RASRAS(RAS_RGB_64, RAS_RGB_64)
: __OR RASRAS(RAS_RGBM, RAS_RGB_)
: __OR RASRAS(RAS_RGBM, RAS_RGBM)
: __OR RASRAS(RAS_RGB_, RAS_RGB_)
: __OR RASRAS(RAS_RGB, RAS_RGB)
: __OR RASRAS(RAS_RGB16, RAS_RGB16)
:
D 83 __OR RASRAS(RAS_UNICM16, RAS_UNICM16)
:
E 83 __OR RASRAS(RAS_CM16S8, RAS_CM16S8)
: __OR RASRAS(RAS_CM16S4, RAS_CM16S4)
: __OR RASRAS(RAS_CM16, RAS_CM16)
: __OR RASRAS(RAS_MBW16, RAS_MBW16)
: __OR RASRAS(RAS_GR8, RAS_GR8)
:
I 90 __OR RASRAS(RAS_GR16, RAS_GR16)
:
E 90
D 83 __OR RASRAS(RAS_UNICM8, RAS_UNICM8)
:
E 83 __OR RASRAS(RAS_CM8, RAS_CM8)
: __OR RASRAS(RAS_CM8S8, RAS_CM8S8)
: __OR RASRAS(RAS_CM8S4, RAS_CM8S4)
:
I 84 __OR RASRAS(RAS_CM24, RAS_CM24)
:
E 84 rop_copy_same(rin, rout, x1, y1, x2, y2, newx, newy);
E 73
D 18 CASE RASRAS(RAS_CM16, RAS_RGBM)
:
E 18
I 18 CASE RASRAS(RAS_GR8, RAS_RGB_)
: __OR RASRAS(RAS_GR8, RAS_RGBM)
: rop_copy_gr8_rgbm(rin, rout, x1, y1, x2, y2, newx, newy);
D 41 return;
E 41
CASE RASRAS(RAS_CM16, RAS_RGB_)
: __OR RASRAS(RAS_CM16, RAS_RGBM)
:
E 18 rop_copy_cm16_rgbm(rin, rout, x1, y1, x2, y2, newx, newy);
D 41 return;
E 41
I 84 CASE RASRAS(RAS_CM24, RAS_RGB_)
: __OR RASRAS(RAS_CM24, RAS_RGBM)
: rop_copy_cm24_rgbm(rin, rout, x1, y1, x2, y2, newx, newy);
E 84
I 58 CASE RASRAS(RAS_CM16, RAS_RGB_64)
: __OR RASRAS(RAS_CM16, RAS_RGBM64)
: rop_copy_cm16_rgbm64(rin, rout, x1, y1, x2, y2, newx, newy);
I 84 CASE RASRAS(RAS_CM24, RAS_RGB_64)
: __OR RASRAS(RAS_CM24, RAS_RGBM64)
: rop_copy_cm24_rgbm64(rin, rout, x1, y1, x2, y2, newx, newy);
E 84 CASE RASRAS(RAS_RGBM, RAS_RGBM64)
: rop_copy_rgbm_rgbm64(rin, rout, x1, y1, x2, y2, newx, newy);
CASE RASRAS(RAS_RGBM64, RAS_RGBM)
: rop_copy_rgbm64_rgbm(rin, rout, x1, y1, x2, y2, newx, newy);
I 95 CASE RASRAS(RAS_RGB_64, RAS_RGB_)
: __OR RASRAS(RAS_RGBM64, RAS_RGB_)
: __OR RASRAS(RAS_RGB_64, RAS_RGBM)
: rop_copy_rgbx64_rgbx(rin, rout, x1, y1, x2, y2, newx, newy);
E 95
I 81 CASE RASRAS(RAS_RGB, RAS_RGB16)
: rop_copy_rgb_rgb16(rin, rout, x1, y1, x2, y2, newx, newy);
E 81
E 58
I 18 CASE RASRAS(RAS_RGB, RAS_RGB_)
: __OR RASRAS(RAS_RGB, RAS_RGBM)
: rop_copy_rgb_rgbm(rin, rout, x1, y1, x2, y2, newx, newy);
D 41 return;
E 41
I 68 CASE RASRAS(RAS_BW, RAS_BW)
: __OR RASRAS(RAS_BW, RAS_WB)
: __OR RASRAS(RAS_WB, RAS_BW)
: __OR RASRAS(RAS_WB, RAS_WB)
:
D 69 rop_copy_bw_bw(rin, rout, x1, y1, x2, y2, newx, newy);
E 69
I 69 rop_copy_bw(rin, rout, x1, y1, x2, y2, newx, newy);
E 69
E 68
E 18 CASE RASRAS(RAS_BW, RAS_CM16)
: __OR RASRAS(RAS_WB, RAS_CM16)
: rop_copy_bw_cm16(rin, rout, x1, y1, x2, y2, newx, newy);
I 19
D 41 return;
E 41
I 84 CASE RASRAS(RAS_BW, RAS_CM24)
: __OR RASRAS(RAS_WB, RAS_CM24)
: rop_copy_bw_cm24(rin, rout, x1, y1, x2, y2, newx, newy);
E 84 CASE RASRAS(RAS_BW, RAS_RGB_)
: __OR RASRAS(RAS_BW, RAS_RGBM)
: __OR RASRAS(RAS_WB, RAS_RGB_)
: __OR RASRAS(RAS_WB, RAS_RGBM)
: rop_copy_bw_rgbm(rin, rout, x1, y1, x2, y2, newx, newy);
E 19
D 41 return;
E 41
I 6
CASE RASRAS(RAS_GR8, RAS_CM16)
: rop_copy_gr8_cm16(rin, rout, x1, y1, x2, y2, newx, newy);
D 41 return;
E 41
I 23
I 84 CASE RASRAS(RAS_GR8, RAS_CM24)
: rop_copy_gr8_cm24(rin, rout, x1, y1, x2, y2, newx, newy);
E 84 CASE RASRAS(RAS_CM8, RAS_CM16)
: rop_copy_cm8_cm16(rin, rout, x1, y1, x2, y2, newx, newy);
D 41 return;
I 39 CASE RASRAS(RAS_CM16, RAS_BW)
: rop_copy_cm8_cm16(rin, rout, x1, y1, x2, y2, newx, newy);
return;
DEFAULT:
rop_copy_quantize(rasras, rin, rout, x1, y1, x2, y2, newx, newy);
return;
E 39
E 23
}
I 23 pixbits_in = rop_pixbits(rin->type);
pixbytes_in = rop_pixbytes(rin->type);
pixbits_out = rop_pixbits(rout->type);
pixbytes_out = rop_pixbytes(rout->type);
E 41
I 84 CASE RASRAS(RAS_CM8, RAS_CM24)
: rop_copy_cm8_cm24(rin, rout, x1, y1, x2, y2, newx, newy);
E 84
E 23
D 41
/* pixsize compatibili */
if (pixbits_in != pixbits_out) {
printf("### INTERNAL ERROR - rop_copy; different pixel size\n");
return;
}
/* per adesso niente pixel non multipli di 8 bits */
if (rop_fillerbits(rin->type) || rop_fillerbits(rout->type)) {
printf("### INTERNAL ERROR - rop_copy; fillerbits not allowed\n");
return;
}
E 41
I 41
D 52 CASE RASRAS(RAS_GR8, RAS_GR8)
: __OR RASRAS(RAS_CM8, RAS_CM8)
: __OR RASRAS(RAS_CM16, RAS_CM16)
: __OR RASRAS(RAS_RGB, RAS_RGB)
: __OR RASRAS(RAS_RGB_, RAS_RGB_)
: __OR RASRAS(RAS_RGBM, RAS_RGB_)
: __OR RASRAS(RAS_RGBM, RAS_RGBM)
:
E 52
I 52
D 73 CASE RASRAS(RAS_GR8, RAS_GR8)
: __OR RASRAS(RAS_CM8, RAS_CM8)
: __OR RASRAS(RAS_CM16, RAS_CM16)
: __OR RASRAS(RAS_RGB16, RAS_RGB16)
: __OR RASRAS(RAS_RGB, RAS_RGB)
: __OR RASRAS(RAS_RGB_, RAS_RGB_)
: __OR RASRAS(RAS_RGBM, RAS_RGB_)
: __OR RASRAS(RAS_RGBM, RAS_RGBM)
:
I 58 __OR RASRAS(RAS_RGBM64, RAS_RGBM64)
: __OR RASRAS(RAS_RGB_64, RAS_RGB_64)
:
E 58
E 52 __OR RASRAS(RAS_MBW16, RAS_MBW16)
: __OR RASRAS(RAS_UNICM8, RAS_UNICM8)
: __OR RASRAS(RAS_UNICM16, RAS_UNICM16)
:
I 72 __OR RASRAS(RAS_CM8S8, RAS_CM8S8)
: __OR RASRAS(RAS_CM8S4, RAS_CM8S4)
: __OR RASRAS(RAS_CM16S8, RAS_CM16S8)
: __OR RASRAS(RAS_CM16S4, RAS_CM16S4)
:
E 72 rop_copy_same(rin, rout, x1, y1, x2, y2, newx, newy);
D 71 CASE RASRAS(RAS_RGBM, RAS_UNICM16)
:
E 71
I 71 CASE RASRAS(RAS_RGB_, RAS_UNICM16)
: __OR RASRAS(RAS_RGBM, RAS_UNICM16)
: __OR RASRAS(RAS_RGB_, RAS_UNICM8)
:
E 71 __OR RASRAS(RAS_RGBM, RAS_UNICM8)
:
I 71 __OR RASRAS(RAS_RGB_, RAS_GR8)
:
E 71 __OR RASRAS(RAS_RGBM, RAS_GR8)
:
I 71 __OR RASRAS(RAS_RGB_, RAS_MBW16)
:
E 71 __OR RASRAS(RAS_RGBM, RAS_MBW16)
:
I 72 __OR RASRAS(RAS_RGB_, RAS_BW)
: __OR RASRAS(RAS_RGBM, RAS_BW)
: __OR RASRAS(RAS_RGB16, RAS_BW)
:
E 72
I 42 __OR RASRAS(RAS_CM16, RAS_UNICM16)
: __OR RASRAS(RAS_CM16, RAS_UNICM8)
: __OR RASRAS(RAS_CM16, RAS_GR8)
: __OR RASRAS(RAS_CM16, RAS_MBW16)
:
E 42 __OR RASRAS(RAS_UNICM16, RAS_UNICM8)
: __OR RASRAS(RAS_UNICM16, RAS_GR8)
:
I 71 __OR RASRAS(RAS_RGB_, RAS_CM16S8)
: __OR RASRAS(RAS_RGBM, RAS_CM16S8)
: __OR RASRAS(RAS_RGB_, RAS_CM16S4)
: __OR RASRAS(RAS_RGBM, RAS_CM16S4)
: __OR RASRAS(RAS_RGB_, RAS_CM8S8)
: __OR RASRAS(RAS_RGBM, RAS_CM8S8)
:
I 72 __OR RASRAS(RAS_RGB16, RAS_CM8S8)
:
E 72 __OR RASRAS(RAS_RGB_, RAS_CM8S4)
: __OR RASRAS(RAS_RGBM, RAS_CM8S4)
: __OR RASRAS(RAS_CM16, RAS_CM16S8)
: __OR RASRAS(RAS_CM16, RAS_CM16S4)
: __OR RASRAS(RAS_CM16, RAS_CM8S8)
: __OR RASRAS(RAS_CM16, RAS_CM8S4)
:
E 71
D 42 __OR RASRAS(RAS_CM16, RAS_MBW16)
:
E 42 rop_copy_quantize(rasras, rin, rout, x1, y1, x2, y2, newx, newy);
E 41
E 73
I 54 CASE RASRAS(RAS_BW, RAS_RGB16)
: __OR RASRAS(RAS_WB, RAS_RGB16)
: rop_copy_bw_rgb16(rin, rout, x1, y1, x2, y2, newx, newy);
CASE RASRAS(RAS_GR8, RAS_RGB16)
: rop_copy_gr8_rgb16(rin, rout, x1, y1, x2, y2, newx, newy);
E 54
I 52 CASE RASRAS(RAS_CM16, RAS_RGB16)
: rop_copy_cm16_rgb16(rin, rout, x1, y1, x2, y2, newx, newy);
I 84 CASE RASRAS(RAS_CM24, RAS_RGB16)
: rop_copy_cm24_rgb16(rin, rout, x1, y1, x2, y2, newx, newy);
E 84 CASE RASRAS(RAS_RGB_, RAS_RGB16)
: __OR RASRAS(RAS_RGBM, RAS_RGB16)
: rop_copy_rgbx_rgb16(rin, rout, x1, y1, x2, y2, newx, newy);
I 70
I 95 CASE RASRAS(RAS_RGB_64, RAS_RGB16)
: __OR RASRAS(RAS_RGBM64, RAS_RGB16)
: rop_copy_rgbx64_rgb16(rin, rout, x1, y1, x2, y2, newx, newy);
E 95
D 74 CASE RASRAS(RAS_RGB16, RAS_RGBM)
:
E 74
I 74 CASE RASRAS(RAS_RGB16, RAS_RGB_)
: __OR RASRAS(RAS_RGB16, RAS_RGBM)
:
E 74 rop_copy_rgb16_rgbm(rin, rout, x1, y1, x2, y2, newx, newy);
E 70
I 67 CASE RASRAS(RAS_RGB_, RAS_RGB)
: __OR RASRAS(RAS_RGBM, RAS_RGB)
: rop_copy_rgbx_rgb(rin, rout, x1, y1, x2, y2, newx, newy);
I 73
D 83 CASE RASRAS(RAS_RGBM, RAS_UNICM16)
: __OR RASRAS(RAS_RGBM, RAS_CM16S8)
: __OR RASRAS(RAS_RGBM, RAS_CM16S4)
: __OR RASRAS(RAS_RGBM, RAS_MBW16)
: __OR RASRAS(RAS_RGBM, RAS_UNICM8)
: __OR RASRAS(RAS_RGBM, RAS_GR8)
: __OR RASRAS(RAS_RGBM, RAS_CM8S8)
: __OR RASRAS(RAS_RGBM, RAS_CM8S4)
: __OR RASRAS(RAS_RGBM, RAS_BW)
:
__OR RASRAS(RAS_RGB_, RAS_UNICM16)
: __OR RASRAS(RAS_RGB_, RAS_CM16S8)
: __OR RASRAS(RAS_RGB_, RAS_CM16S4)
: __OR RASRAS(RAS_RGB_, RAS_MBW16)
: __OR RASRAS(RAS_RGB_, RAS_UNICM8)
: __OR RASRAS(RAS_RGB_, RAS_GR8)
: __OR RASRAS(RAS_RGB_, RAS_CM8S8)
: __OR RASRAS(RAS_RGB_, RAS_CM8S4)
: __OR RASRAS(RAS_RGB_, RAS_BW)
:
__OR RASRAS(RAS_RGB16, RAS_CM8S8)
: __OR RASRAS(RAS_RGB16, RAS_BW)
:
__OR RASRAS(RAS_CM16, RAS_UNICM16)
: __OR RASRAS(RAS_CM16, RAS_CM16S8)
: __OR RASRAS(RAS_CM16, RAS_CM16S4)
: __OR RASRAS(RAS_CM16, RAS_MBW16)
: __OR RASRAS(RAS_CM16, RAS_UNICM8)
: __OR RASRAS(RAS_CM16, RAS_GR8)
: __OR RASRAS(RAS_CM16, RAS_CM8S8)
: __OR RASRAS(RAS_CM16, RAS_CM8S4)
: __OR RASRAS(RAS_CM16, RAS_BW)
:
__OR RASRAS(RAS_UNICM16, RAS_UNICM8)
: __OR RASRAS(RAS_UNICM16, RAS_GR8)
:
E 83
I 83 CASE RASRAS(RAS_RGBM, RAS_CM16S8)
: __OR RASRAS(RAS_RGBM, RAS_CM16S4)
: __OR RASRAS(RAS_RGBM, RAS_MBW16)
: __OR RASRAS(RAS_RGBM, RAS_GR8)
:
I 90 __OR RASRAS(RAS_RGBM64, RAS_GR8)
: __OR RASRAS(RAS_RGBM, RAS_GR16)
: __OR RASRAS(RAS_RGBM64, RAS_GR16)
:
E 90 __OR RASRAS(RAS_RGBM, RAS_CM8S8)
: __OR RASRAS(RAS_RGBM, RAS_CM8S4)
: __OR RASRAS(RAS_RGBM, RAS_BW)
: __OR RASRAS(RAS_RGB_, RAS_CM16S8)
: __OR RASRAS(RAS_RGB_, RAS_CM16S4)
: __OR RASRAS(RAS_RGB_, RAS_MBW16)
: __OR RASRAS(RAS_RGB_, RAS_GR8)
: __OR RASRAS(RAS_RGB_, RAS_CM8S8)
: __OR RASRAS(RAS_RGB_, RAS_CM8S4)
: __OR RASRAS(RAS_RGB_, RAS_BW)
: __OR RASRAS(RAS_RGB16, RAS_CM8S8)
: __OR RASRAS(RAS_RGB16, RAS_BW)
: __OR RASRAS(RAS_CM16, RAS_CM16S8)
: __OR RASRAS(RAS_CM16, RAS_CM16S4)
: __OR RASRAS(RAS_CM16, RAS_MBW16)
: __OR RASRAS(RAS_CM16, RAS_GR8)
:
I 90 __OR RASRAS(RAS_CM16, RAS_GR16)
:
E 90 __OR RASRAS(RAS_CM16, RAS_CM8S8)
: __OR RASRAS(RAS_CM16, RAS_CM8S4)
: __OR RASRAS(RAS_CM16, RAS_BW)
:
I 84 __OR RASRAS(RAS_CM24, RAS_CM16S8)
: __OR RASRAS(RAS_CM24, RAS_CM16S4)
: __OR RASRAS(RAS_CM24, RAS_MBW16)
: __OR RASRAS(RAS_CM24, RAS_GR8)
:
D 89 __OR RASRAS(RAS_CM24, RAS_CM8S8)
: __OR RASRAS(RAS_CM24, RAS_CM8S4)
: __OR RASRAS(RAS_CM24, RAS_BW)
:
E 84
E 83 rop_copy_quantize(rasras, rin, rout, x1, y1, x2, y2, newx, newy);
E 73
E 67
E 52
D 41
/* copia */
D 10 rowsize = (pixbits_in * (x2 - x1 + 1)) >> 3;
I 7
#ifdef CHE_CAVOLO_VADO_A_SCRIVERE___WALTER
E 7 wrapin = (rin->wrap * pixbits_in) >> 3;
wrapout = (rout->wrap * pixbits_out) >> 3;
D 7
E 7
I 7
#else
wrapin = rin->wrap;
wrapout = rout->wrap;
#endif
E 7 rowin = (char *)rin->buffer + y1 * wrapin + ((x1 * pixbits_in) >> 3);
rowout = (char *)rout->buffer + newy * wrapout + ((newx * pixbits_out) >> 3);
E 10
I 10
D 11
rowsize = pixbytes_in * (x2-x1+1));
E 11
I 11 rowsize = pixbytes_in * (x2 - x1 + 1);
E 11 bytewrapin = rin->wrap * pixbytes_in;
bytewrapout = rout->wrap * pixbytes_out;
D 12 rowin = (UCHAR *)rin->buffer + y1 * wrapin + ((x1 * pixbits_in) >> 3);
rowout = (UCHAR *)rout->buffer + newy * wrapout + ((newx * pixbits_out) >> 3);
E 12
I 12 rowin =
(UCHAR *)rin->buffer + y1 * bytewrapin + ((x1 * pixbits_in) >> 3);
rowout =
(UCHAR *)rout->buffer + newy * bytewrapout + ((newx * pixbits_out) >> 3);
E 12
E 10 d = y2 - y1 + 1;
while (d-- > 0) {
memmove(rowout, rowin, rowsize);
D 10 rowin += wrapin;
rowout += wrapout;
E 10
I 10 rowin += bytewrapin;
rowout += bytewrapout;
E 41
I 41 DEFAULT :
D 52 assert(FALSE);
E 52
I 52 assert(!"rop_copy; invalid raster combination");
E 52
E 41
I 20
}
}
/*---------------------------------------------------------------------------*/
D 84
/* copia un rettangolo da rin a rout.
* Le coordinate sono relative ai due raster: (0, 0) corrisponde
* al primo pixel del raster.
* Riduce le dimensioni di un certo fattore facendo la media dei valori
* dei pixel.
*/
void
rop_reduce(RASTER *rin, RASTER *rout, int x1, int y1, int x2, int y2,
int newx, int newy, int factor) {
int tmp, newlx, newly;
int rasras;
if (factor == 1) rop_copy(rin, rout, x1, y1, x2, y2, newx, newy);
/* raddrizzo gli estremi */
if (x1 > x2) {
tmp = x1;
x1 = x2;
x2 = tmp;
}
if (y1 > y2) {
tmp = y1;
y1 = y2;
y2 = tmp;
}
/* controllo gli sconfinamenti */
newlx = (x2 - x1 + factor) / factor;
newly = (y2 - y1 + factor) / factor;
if (x1 < 0 || y1 < 0 || x2 >= rin->lx || y2 >= rin->ly || newx < 0 ||
newy < 0 || newx + newlx > rout->lx || newy + newly > rout->ly) {
printf("### INTERNAL ERROR - rop_reduce; access violation\n");
return;
}
rasras = RASRAS(rin->type, rout->type);
switch (rasras) {
CASE RASRAS(RAS_GR8, RAS_RGB_)
: __OR RASRAS(RAS_GR8, RAS_RGBM)
: rop_reduce_gr8_rgbm(rin, rout, x1, y1, x2, y2, newx, newy, factor);
return;
CASE RASRAS(RAS_CM16, RAS_RGB_)
:
D 28 __OR RASRAS(RAS_CM16, RAS_RGBM)
:
E 28
I 28
D 46 rop_reduce_cm16_rgb_(rin, rout, x1, y1, x2, y2, newx, newy, factor);
E 46
I 46 rop_reduce_cm16_rgbx(rin, rout, x1, y1, x2, y2, newx, newy, factor);
E 46 return;
CASE RASRAS(RAS_CM16, RAS_RGBM)
:
E 28 rop_reduce_cm16_rgbm(rin, rout, x1, y1, x2, y2, newx, newy, factor);
return;
I 81 CASE RASRAS(RAS_RGB, RAS_RGB16)
: rop_reduce_rgb_rgb16(rin, rout, x1, y1, x2, y2, newx, newy, factor);
return;
E 81 CASE RASRAS(RAS_RGB, RAS_RGB_)
: __OR RASRAS(RAS_RGB, RAS_RGBM)
: rop_reduce_rgb_rgbm(rin, rout, x1, y1, x2, y2, newx, newy, factor);
return;
CASE RASRAS(RAS_BW, RAS_CM16)
: __OR RASRAS(RAS_WB, RAS_CM16)
: rop_reduce_bw_cm16(rin, rout, x1, y1, x2, y2, newx, newy, factor);
return;
CASE RASRAS(RAS_BW, RAS_RGB_)
: __OR RASRAS(RAS_BW, RAS_RGBM)
: __OR RASRAS(RAS_WB, RAS_RGB_)
: __OR RASRAS(RAS_WB, RAS_RGBM)
: rop_reduce_bw_rgbm(rin, rout, x1, y1, x2, y2, newx, newy, factor);
return;
CASE RASRAS(RAS_GR8, RAS_CM16)
: rop_reduce_gr8_cm16(rin, rout, x1, y1, x2, y2, newx, newy, factor);
return;
CASE RASRAS(RAS_WB, RAS_GR8)
: __OR RASRAS(RAS_BW, RAS_GR8)
: rop_reduce_bw_gr8(rin, rout, x1, y1, x2, y2, newx, newy, factor);
return;
CASE RASRAS(RAS_GR8, RAS_GR8)
: rop_reduce_gr8(rin, rout, x1, y1, x2, y2, newx, newy, factor);
return;
CASE RASRAS(RAS_CM16, RAS_CM16)
: rop_reduce_cm16(rin, rout, x1, y1, x2, y2, newx, newy, factor);
return;
CASE RASRAS(RAS_RGB_, RAS_RGB_)
: __OR RASRAS(RAS_RGB_, RAS_RGBM)
: __OR RASRAS(RAS_RGBM, RAS_RGB_)
: __OR RASRAS(RAS_RGBM, RAS_RGBM)
: rop_reduce_rgbm(rin, rout, x1, y1, x2, y2, newx, newy, factor);
return;
DEFAULT:
D 52 printf(
"### INTERNAL ERROR - rop_reduce; invalid raster combination\n");
E 52
I 52 assert(!"rop_reduce; invalid raster combination");
E 52
I 28
}
}
/*---------------------------------------------------------------------------*/
E 84
I 39
/* copia un rettangolo da rin a rout.
* Le coordinate sono relative ai due raster: (0, 0) corrisponde
* al primo pixel del raster.
* Riduce le dimensioni di un fattore di subsampling pari a shrink.
* I due raster devono essere dello stesso tipo.
*/
void
rop_shrink(RASTER *rin, RASTER *rout, int x1, int y1, int x2, int y2,
int newx, int newy, int shrink) {
UCHAR *curr_pixin, *bufferin;
int i, j, tmp, bpp;
int xsize, ysize, wrapin, wrapout;
UCHAR *curr_pixout, *bufferout;
I 84 USHORT *curr_pixin_2, *curr_pixout_2;
ULONG *curr_pixin_4, *curr_pixout_4;
E 84
if (shrink == 1) return;
/* raddrizzo gli estremi */
if (x1 > x2) {
tmp = x1;
x1 = x2;
x2 = tmp;
}
if (y1 > y2) {
tmp = y1;
y1 = y2;
y2 = tmp;
}
E 39
I 39
/* controllo gli sconfinamenti */
if (x1 < 0 || y1 < 0 || x2 >= rin->lx || y2 >= rin->ly || newx < 0 ||
newy < 0 || newx + (x2 - x1 + shrink) / shrink > rout->lx ||
newy + (y2 - y1 + shrink) / shrink > rout->ly ||
rin->type != rout->type) {
printf("### INTERNAL ERROR - rop_shrink; access violation\n");
return;
}
bpp = rop_pixbytes(rin->type);
xsize = (x2 - x1 + shrink) / shrink;
ysize = (y2 - y1 + shrink) / shrink;
wrapin = rin->wrap * bpp;
bufferin = (UCHAR *)(rin->buffer) + wrapin * y1 + x1 * bpp;
wrapout = rout->wrap * bpp;
bufferout = (UCHAR *)(rout->buffer) + wrapout * newy + newx * bpp;
wrapin *= shrink;
D 84 shrink *= bpp;
E 84
for (i = 0; i < ysize; i++) {
curr_pixin = bufferin;
curr_pixout = bufferout;
bufferin += wrapin;
bufferout += wrapout;
D 84 for (j = 0; j < xsize; j++)
E 84
I 84 switch (bpp)
E 84 {
D 84 memcpy(curr_pixout, curr_pixin, bpp);
curr_pixin += shrink;
curr_pixout += bpp;
}
}
}
/*---------------------------------------------------------------------------*/
E 39
/* copia un rettangolo da rin a rout.
* Le coordinate sono relative ai due raster: (0, 0) corrisponde
* al primo pixel del raster.
* Riduce le dimensioni di una potenza di due facendo la media dei valori
D 29
* dei pixel, ma solo su circa 3/4 dei pixel.
E 29
I 29
* dei pixel, ma solo su una parte dei pixel.
E 29
*/
void
rop_zoom_out(RASTER *rin, RASTER *rout, int x1, int y1, int x2, int y2,
int newx, int newy, int abs_zoom_level) {
int tmp, newlx, newly;
int rasras, factor, abszl;
abszl = abs_zoom_level;
factor = 1 << abs_zoom_level;
if (factor == 1) rop_copy(rin, rout, x1, y1, x2, y2, newx, newy);
/* raddrizzo gli estremi */
if (x1 > x2) {
tmp = x1;
x1 = x2;
x2 = tmp;
}
if (y1 > y2) {
tmp = y1;
y1 = y2;
y2 = tmp;
}
/* controllo gli sconfinamenti */
newlx = (x2 - x1 + factor) / factor;
newly = (y2 - y1 + factor) / factor;
if (x1 < 0 || y1 < 0 || x2 >= rin->lx || y2 >= rin->ly || newx < 0 ||
newy < 0 || newx + newlx > rout->lx || newy + newly > rout->ly)
D 30 {
printf("### INTERNAL ERROR - rop_zoom_out; access violation\n");
return;
}
E 30
I 30 {
printf(
"### INTERNAL ERROR - rop_zoom_out; access violation\n"
" ((%d,%d)(%d,%d)in(%dx%d)->(%d,%d)in(%dx%d))\n",
x1, y1, x2, y2, rin->lx, rin->ly, newx, newy, rout->lx, rout->ly);
return;
}
E 30
rasras = RASRAS(rin->type, rout->type);
switch (rasras) {
CASE RASRAS(RAS_GR8, RAS_RGB_)
: __OR RASRAS(RAS_GR8, RAS_RGBM)
: rop_zoom_out_gr8_rgbm(rin, rout, x1, y1, x2, y2, newx, newy, abszl);
D 57 return;
E 57
CASE RASRAS(RAS_CM16, RAS_RGB_)
:
D 46 rop_zoom_out_cm16_rgb_(rin, rout, x1, y1, x2, y2, newx, newy, abszl);
E 46
I 46 rop_zoom_out_cm16_rgbx(rin, rout, x1, y1, x2, y2, newx, newy, abszl);
E 46
D 57 return;
E 57
CASE RASRAS(RAS_CM16, RAS_RGBM)
: rop_zoom_out_cm16_rgbm(rin, rout, x1, y1, x2, y2, newx, newy, abszl);
D 57 return;
E 57
I 81 CASE RASRAS(RAS_RGB, RAS_RGB16)
: rop_zoom_out_rgb_rgb16(rin, rout, x1, y1, x2, y2, newx, newy, abszl);
E 81 CASE RASRAS(RAS_RGB, RAS_RGB_)
: __OR RASRAS(RAS_RGB, RAS_RGBM)
: rop_zoom_out_rgb_rgbm(rin, rout, x1, y1, x2, y2, newx, newy, abszl);
D 57 return;
E 57
CASE RASRAS(RAS_BW, RAS_CM16)
: __OR RASRAS(RAS_WB, RAS_CM16)
: rop_zoom_out_bw_cm16(rin, rout, x1, y1, x2, y2, newx, newy, abszl);
D 57 return;
E 57
CASE RASRAS(RAS_BW, RAS_RGB_)
: __OR RASRAS(RAS_BW, RAS_RGBM)
: __OR RASRAS(RAS_WB, RAS_RGB_)
: __OR RASRAS(RAS_WB, RAS_RGBM)
: rop_zoom_out_bw_rgbm(rin, rout, x1, y1, x2, y2, newx, newy, abszl);
D 57 return;
E 57
CASE RASRAS(RAS_GR8, RAS_CM16)
: rop_zoom_out_gr8_cm16(rin, rout, x1, y1, x2, y2, newx, newy, abszl);
D 57 return;
E 57
CASE RASRAS(RAS_WB, RAS_GR8)
: __OR RASRAS(RAS_BW, RAS_GR8)
: rop_zoom_out_bw_gr8(rin, rout, x1, y1, x2, y2, newx, newy, abszl);
D 57 return;
E 57
CASE RASRAS(RAS_GR8, RAS_GR8)
: rop_zoom_out_gr8(rin, rout, x1, y1, x2, y2, newx, newy, abszl);
D 57 return;
E 57
CASE RASRAS(RAS_CM16, RAS_CM16)
: rop_zoom_out_cm16(rin, rout, x1, y1, x2, y2, newx, newy, abszl);
D 57 return;
E 57
CASE RASRAS(RAS_RGB_, RAS_RGB_)
: __OR RASRAS(RAS_RGB_, RAS_RGBM)
: __OR RASRAS(RAS_RGBM, RAS_RGB_)
:
D 46 __OR RASRAS(RAS_RGBM, RAS_RGBM)
:
E 46
I 46 rop_zoom_out_rgbx(rin, rout, x1, y1, x2, y2, newx, newy, abszl);
D 57 return;
E 57
CASE RASRAS(RAS_RGBM, RAS_RGBM)
:
E 46 rop_zoom_out_rgbm(rin, rout, x1, y1, x2, y2, newx, newy, abszl);
D 57 return;
E 57
I 54
I 61 CASE RASRAS(RAS_BW, RAS_RGB16)
: __OR RASRAS(RAS_WB, RAS_RGB16)
: rop_zoom_out_bw_rgb16(rin, rout, x1, y1, x2, y2, newx, newy, abszl);
E 61 CASE RASRAS(RAS_GR8, RAS_RGB16)
: rop_zoom_out_gr8_rgb16(rin, rout, x1, y1, x2, y2, newx, newy, abszl);
E 54
I 52 CASE RASRAS(RAS_CM16, RAS_RGB16)
: rop_zoom_out_cm16_rgb16(rin, rout, x1, y1, x2, y2, newx, newy, abszl);
CASE RASRAS(RAS_RGB_, RAS_RGB16)
: __OR RASRAS(RAS_RGBM, RAS_RGB16)
: rop_zoom_out_rgbx_rgb16(rin, rout, x1, y1, x2, y2, newx, newy, abszl);
E 52 DEFAULT :
D 52 printf(
"### INTERNAL ERROR - rop_zoom_out; invalid raster combination\n");
E 52
I 52 assert(!"rop_zoom_out; invalid raster combination");
E 52
E 28
E 20
E 10
}
}
/*---------------------------------------------------------------------------*/
D 14
/* TOPPA TEMPORANEA PER INPUT, rifare completamente
*
* chiedere a Walter
E 14
I 14
/* copia un rettangolo da rin a rout,
* specchiandolo orizzontalmente se mirror e' dispari,
* e poi ruotandolo del multiplo di novanta gradi specificato
* da ninety in senso antiorario
E 14
*
*/
I 14
D 17
/* RIVEDERE COMPLETAMENTE, PER ADESSO FUNZIA SOLO PER BW->BW e GR8->GR8 */
E 17
I 17
D 23
/* RIVEDERE COMPLETAMENTE, PER ADESSO FUNZIA SOLO PER POCHI TIPI DI RASTER */
E 17
E 23
E 14
void rop_copy_90(RASTER *rin, RASTER *rout,
int x1, int y1, int x2, int y2, int newx, int newy,
D 14
int ninety, int flip)
E 14
I 14
D 15
int mirror, int ninety)
E 15
I 15
int mirror, int ninety)
E 15
E 14
{
D 13 char *rowin, *rowout;
E 13
I 13
D 23 UCHAR *rowin, *rowout;
E 13
D 10 int rowsize, wrapin, wrapout, d, tmp;
E 10
I 10
D 14 int rowsize, bytewrapin, bytewrapout, d, tmp;
E 14
I 14 int rowsize, bytewrapin, bytewrapout, d, tmp, newdx, newdy;
E 14
E 10
D 12 int pixbits_in, pixbits_out;
E 12
I 12 int pixbits_in, pixbits_out;
int pixbytes_in, pixbytes_out;
E 23
I 23 int newdx, newdy, tmp;
E 23
E 12 int rasras;
D 14 if (ninety != 1 || flip != 1) {
printf("### INTERNAL ERROR - rop_copy_90; ?????????????????\n");
return;
}
E 14
I 14 mirror &= 1;
ninety &= 3;
I 18
if (!ninety && !mirror) {
rop_copy(rin, rout, x1, y1, x2, y2, newx, newy);
return;
}
E 18
E 14
/* raddrizzo gli estremi */
if (x1 > x2) {
tmp = x1;
x1 = x2;
x2 = tmp;
}
if (y1 > y2) {
tmp = y1;
y1 = y2;
y2 = tmp;
}
I 14 switch (ninety) {
CASE 0 : __OR 2 : newdx = x2 - x1 + 1;
newdy = y2 - y1 + 1;
CASE 1 : __OR 3 : newdx = y2 - y1 + 1;
newdy = x2 - x1 + 1;
I 50
D 78 DEFAULT : assert(FALSE);
newdx = newdy = 0;
E 78
I 78 DEFAULT : abort();
newdx = newdy = 0;
E 78
E 50
}
E 14
/* controllo gli sconfinamenti */
if(x1<0 || y1<0 || x2>=rin->lx || y2>=rin->ly
|| newx<0 || newy<0 ||
D 14
newx+x2-x1>=rout->lx || newy+y2-y1>=rout->ly)
E 14
I 14
newx+newdx>rout->lx || newy+newdy>rout->ly)
E 14
{
printf("### INTERNAL ERROR - rop_copy_90; access violation\n");
return;
}
D 12 pixbits_in = rop_pixbits(rin->type);
pixbits_out = rop_pixbits(rout->type);
E 12
I 12
D 23 pixbits_in = rop_pixbits(rin->type);
pixbytes_in = rop_pixbytes(rin->type);
pixbits_out = rop_pixbits(rout->type);
pixbytes_out = rop_pixbytes(rout->type);
E 23
E 12 rasras = RASRAS(rin->type, rout->type);
switch (rasras) {
CASE RASRAS(RAS_WB, RAS_WB)
: __OR RASRAS(RAS_BW, RAS_BW)
:
D 14
/*
rop_copy_90_bw(rin, rout, x1, y1, x2, y2, newx, newy, ninety, flip);
*/
rop_copy(rin, rout, x1, y1, x2, y2, newx, newy);
E 14
I 14 rop_copy_90_bw(rin, rout, x1, y1, x2, y2, newx, newy, mirror, ninety);
E 14 return;
I 17 CASE RASRAS(RAS_WB, RAS_GR8)
: __OR RASRAS(RAS_BW, RAS_GR8)
: rop_copy_90_bw_gr8(rin, rout, x1, y1, x2, y2, newx, newy, mirror,
ninety);
return;
I 21 CASE RASRAS(RAS_WB, RAS_CM16)
: __OR RASRAS(RAS_BW, RAS_CM16)
: rop_copy_90_bw_cm16(rin, rout, x1, y1, x2, y2, newx, newy, mirror,
ninety);
return;
I 55 CASE RASRAS(RAS_WB, RAS_RGB16)
: __OR RASRAS(RAS_BW, RAS_RGB16)
: rop_copy_90_bw_rgb16(rin, rout, x1, y1, x2, y2, newx, newy, mirror,
ninety);
E 55
I 22 CASE RASRAS(RAS_WB, RAS_RGB_)
: __OR RASRAS(RAS_WB, RAS_RGBM)
: __OR RASRAS(RAS_BW, RAS_RGB_)
: __OR RASRAS(RAS_BW, RAS_RGBM)
: rop_copy_90_bw_rgbm(rin, rout, x1, y1, x2, y2, newx, newy, mirror,
ninety);
return;
E 22
E 21
E 17 CASE RASRAS(RAS_GR8, RAS_GR8)
:
D 14
/*
rop_copy_90_gr8(rin, rout, x1, y1, x2, y2, newx, newy, ninety, flip);
*/
rop_copy(rin, rout, x1, y1, x2, y2, newx, newy);
E 14
I 14 rop_copy_90_gr8(rin, rout, x1, y1, x2, y2, newx, newy, mirror, ninety);
E 14 return;
I 21 CASE RASRAS(RAS_GR8, RAS_CM16)
: rop_copy_90_gr8_cm16(rin, rout, x1, y1, x2, y2, newx, newy, mirror,
ninety);
return;
I 55 CASE RASRAS(RAS_GR8, RAS_RGB16)
: rop_copy_90_gr8_rgb16(rin, rout, x1, y1, x2, y2, newx, newy, mirror,
ninety);
return;
E 55
I 22 CASE RASRAS(RAS_GR8, RAS_RGB_)
: __OR RASRAS(RAS_GR8, RAS_RGBM)
: rop_copy_90_gr8_rgbm(rin, rout, x1, y1, x2, y2, newx, newy, mirror,
ninety);
return;
I 23 CASE RASRAS(RAS_CM8, RAS_CM16)
: rop_copy_90_cm8_cm16(rin, rout, x1, y1, x2, y2, newx, newy, mirror,
ninety);
return;
I 26 CASE RASRAS(RAS_RGB_, RAS_RGB_)
: __OR RASRAS(RAS_RGBM, RAS_RGB_)
: __OR RASRAS(RAS_RGBM, RAS_RGBM)
: rop_copy_90_rgbm(rin, rout, x1, y1, x2, y2, newx, newy, mirror, ninety);
return;
I 63 CASE RASRAS(RAS_RGB, RAS_RGB16)
: rop_copy_90_rgb_rgb16(rin, rout, x1, y1, x2, y2, newx, newy, mirror,
ninety);
return;
E 63
I 45 CASE RASRAS(RAS_RGB, RAS_RGB_)
:
E 45
I 43
D 64 CASE RASRAS(RAS_RGB, RAS_RGBM)
:
E 64
I 64 __OR RASRAS(RAS_RGB, RAS_RGBM)
:
E 64 rop_copy_90_rgb_rgbm(rin, rout, x1, y1, x2, y2, newx, newy, mirror,
ninety);
return;
E 43
E 26
E 23
E 22
E 21 DEFAULT :
D 45 printf("### INTERNAL ERROR - rop_copy_90; ?????????????????\n");
E 45
I 45
D 78 assert(FALSE);
E 78
I 78 abort();
E 78
E 45
E 6
}
I 6
D 21
/* QUI NON CI SI ARRIVA */
E 6
E 4
/* pixsize compatibili */
if (pixbits_in != pixbits_out) {
printf("### INTERNAL ERROR - rop_copy; different pixel size\n");
return;
}
/* per adesso niente pixel non multipli di 8 bits */
D 2 if (pixbits_in & 7) {
printf("### INTERNAL ERROR - rop_copy; byte fraction pixels\n");
E 2
I 2 if (rop_fillerbits(rin->type) || rop_fillerbits(rout->type)) {
printf("### INTERNAL ERROR - rop_copy; fillerbits not allowed\n");
E 2 return;
}
D 4
E 4
I 4
E 4
/* copia */
rowsize = (pixbits_in * (x2 - x1 + 1)) >> 3;
D 10 wrapin = (rin->wrap * pixbits_in) >> 3;
wrapout = (rout->wrap * pixbits_out) >> 3;
E 10
I 10 bytewrapin = rin->wrap * pixbytes_in;
bytewrapout = rout->wrap * pixbytes_out;
E 10
D 10 rowin = (char *)rin->buffer + y1 * wrapin + ((x1 * pixbits_in) >> 3);
rowout = (char *)rout->buffer + newy * wrapout + ((newx * pixbits_out) >> 3);
E 10
I 10
D 12 rowin = (UCHAR *)rin->buffer + y1 * wrapin + ((x1 * pixbits_in) >> 3);
rowout = (UCHAR *)rout->buffer + newy * wrapout + ((newx * pixbits_out) >> 3);
E 12
I 12 rowin =
(UCHAR *)rin->buffer + y1 * bytewrapin + ((x1 * pixbits_in) >> 3);
rowout =
(UCHAR *)rout->buffer + newy * bytewrapout + ((newx * pixbits_out) >> 3);
E 12
E 10 d = y2 - y1 + 1;
while (d-- > 0) {
memmove(rowout, rowin, rowsize);
D 10 rowin += wrapin;
rowout += wrapout;
E 10
I 10 rowin += bytewrapin;
rowout += bytewrapout;
E 10
}
E 21
}
/*---------------------------------------------------------------------------*/
I 15
#ifdef VERSIONE_LENTA
E 15
I 6
static void rop_copy_90_bw(RASTER *rin, RASTER *rout,
int x1, int y1, int x2, int y2,
int newx, int newy,
D 14
int ninety, int flip)
E 14
I 14
int mirror, int ninety)
E 14
{
D 14
#ifdef WALTER
UCHAR *rowin,
*bytein;
LPIXEL *cmap;
int wrapin, wrapout, tmp, cmap_offset, bit, bit_offs, startbit;
int x, lx, ly;
#define SET_BIT(BYTE, BIT, VAL) \
{ \
if (VAL) \
*BYTE |= (1 << (BIT)); \
else \
*BYTE &= ~(1 << (BIT)); \
}
E 14
I 14 UCHAR *bufin, *bufout;
int bytewrapin, bytewrapout, bitoffsin, bitoffsout, wrapin;
int u, v, lu, lv, su, sv, u00, v00, u0, v0, dudx, dudy, dvdx, dvdy;
int x, y, lx, ly;
int u1, v1, u2, v2;
D 61
#define BUFBYTE(X, Y, BUF, BYTEWRAP, BITOFFS) \
(((UCHAR *)(BUF))[(((X) + (BITOFFS)) >> 3) + (Y) * (BYTEWRAP)])
#define GET_BIT(X, Y, BUF, BYTEWRAP, BITOFFS) \
((BUFBYTE(X, Y, BUF, BYTEWRAP, BITOFFS) >> (7 - (((X) + (BITOFFS)) & 7))) & 1)
#define SET_BIT_0(X, Y, BUF, BYTEWRAP, BITOFFS) \
(BUFBYTE(X, Y, BUF, BYTEWRAP, BITOFFS) &= \
~(1 << (7 - (((X) + (BITOFFS)) & 7))))
#define SET_BIT_1(X, Y, BUF, BYTEWRAP, BITOFFS) \
(BUFBYTE(X, Y, BUF, BYTEWRAP, BITOFFS) |= \
(1 << (7 - (((X) + (BITOFFS)) & 7))))
E 61
#ifdef DEBUG
STW_INIT(0, "rop_copy_90_bw")
E 84
I 84 CASE 1 : for (j = 0; j < xsize; j++) {
*curr_pixout = *curr_pixin;
curr_pixin += shrink;
curr_pixout++;
}
CASE 2 : curr_pixin_2 = (USHORT *)curr_pixin;
curr_pixout_2 = (USHORT *)curr_pixout;
for (j = 0; j < xsize; j++) {
*curr_pixout_2 = *curr_pixin_2;
curr_pixin_2 += shrink;
curr_pixout_2++;
}
CASE 4 : curr_pixin_4 = (ULONG *)curr_pixin;
curr_pixout_4 = (ULONG *)curr_pixout;
for (j = 0; j < xsize; j++) {
*curr_pixout_4 = *curr_pixin_4;
E 84
I 84 curr_pixin_4 += shrink;
curr_pixout_4++;
}
DEFAULT:
for (j = 0; j < xsize; j++) {
memcpy(curr_pixout, curr_pixin, bpp);
curr_pixin += shrink * bpp;
curr_pixout += bpp;
}
}
}
}
/*---------------------------------------------------------------------------*/
/* copia un rettangolo da rin a rout.
* Le coordinate sono relative ai due raster: (0, 0) corrisponde
* al primo pixel del raster.
* Riduce le dimensioni di una potenza di due facendo la media dei valori
* dei pixel, ma solo su una parte dei pixel.
*/
void rop_zoom_out(RASTER *rin, RASTER *rout, int x1, int y1, int x2, int y2,
int newx, int newy, int abs_zoom_level) {
int tmp, newlx, newly;
int rasras, factor, abszl;
abszl = abs_zoom_level;
factor = 1 << abs_zoom_level;
if (factor == 1) rop_copy(rin, rout, x1, y1, x2, y2, newx, newy);
/* raddrizzo gli estremi */
if (x1 > x2) {
tmp = x1;
x1 = x2;
x2 = tmp;
}
if (y1 > y2) {
tmp = y1;
y1 = y2;
y2 = tmp;
}
/* controllo gli sconfinamenti */
newlx = (x2 - x1 + factor) / factor;
newly = (y2 - y1 + factor) / factor;
E 89
I 89 __OR RASRAS(RAS_CM24, RAS_CM8S8)
: __OR RASRAS(RAS_CM24, RAS_CM8S4)
: __OR RASRAS(RAS_CM24, RAS_BW)
: rop_copy_quantize(rasras, rin, rout, x1, y1, x2, y2, newx, newy);
DEFAULT:
assert(!"rop_copy; invalid raster combination");
E 96
I 96 rasras = RASRAS(rin->type, rout->type);
switch (rasras) {
CASE RASRAS(RAS_RGBM, RAS_RGB_)
: rop_copy_same(rin, rout, x1, y1, x2, y2, newx, newy);
CASE RASRAS(RAS_GR8, RAS_RGB_)
: __OR RASRAS(RAS_GR8, RAS_RGBM)
: rop_copy_gr8_rgbm(rin, rout, x1, y1, x2, y2, newx, newy);
CASE RASRAS(RAS_CM16, RAS_RGB_)
: __OR RASRAS(RAS_CM16, RAS_RGBM)
: rop_copy_cm16_rgbm(rin, rout, x1, y1, x2, y2, newx, newy);
CASE RASRAS(RAS_CM24, RAS_RGB_)
: __OR RASRAS(RAS_CM24, RAS_RGBM)
: rop_copy_cm24_rgbm(rin, rout, x1, y1, x2, y2, newx, newy);
CASE RASRAS(RAS_CM16, RAS_RGB_64)
: __OR RASRAS(RAS_CM16, RAS_RGBM64)
: rop_copy_cm16_rgbm64(rin, rout, x1, y1, x2, y2, newx, newy);
CASE RASRAS(RAS_CM24, RAS_RGB_64)
: __OR RASRAS(RAS_CM24, RAS_RGBM64)
: rop_copy_cm24_rgbm64(rin, rout, x1, y1, x2, y2, newx, newy);
CASE RASRAS(RAS_RGBM, RAS_RGBM64)
: rop_copy_rgbm_rgbm64(rin, rout, x1, y1, x2, y2, newx, newy);
CASE RASRAS(RAS_RGBM64, RAS_RGBM)
: rop_copy_rgbm64_rgbm(rin, rout, x1, y1, x2, y2, newx, newy);
CASE RASRAS(RAS_RGB_64, RAS_RGB_)
: __OR RASRAS(RAS_RGBM64, RAS_RGB_)
: __OR RASRAS(RAS_RGB_64, RAS_RGBM)
: rop_copy_rgbx64_rgbx(rin, rout, x1, y1, x2, y2, newx, newy);
CASE RASRAS(RAS_RGB, RAS_RGB16)
: rop_copy_rgb_rgb16(rin, rout, x1, y1, x2, y2, newx, newy);
CASE RASRAS(RAS_RGB, RAS_RGB_)
: __OR RASRAS(RAS_RGB, RAS_RGBM)
: rop_copy_rgb_rgbm(rin, rout, x1, y1, x2, y2, newx, newy);
D 104 CASE RASRAS(RAS_BW, RAS_BW)
: __OR RASRAS(RAS_BW, RAS_WB)
:
E 104
I 104 CASE RASRAS(RAS_BW, RAS_WB)
:
E 104 __OR RASRAS(RAS_WB, RAS_BW)
: __OR RASRAS(RAS_WB, RAS_WB)
: rop_copy_bw(rin, rout, x1, y1, x2, y2, newx, newy);
CASE RASRAS(RAS_BW, RAS_CM16)
: __OR RASRAS(RAS_WB, RAS_CM16)
: rop_copy_bw_cm16(rin, rout, x1, y1, x2, y2, newx, newy);
CASE RASRAS(RAS_BW, RAS_CM24)
: __OR RASRAS(RAS_WB, RAS_CM24)
: rop_copy_bw_cm24(rin, rout, x1, y1, x2, y2, newx, newy);
CASE RASRAS(RAS_BW, RAS_RGB_)
: __OR RASRAS(RAS_BW, RAS_RGBM)
: __OR RASRAS(RAS_WB, RAS_RGB_)
: __OR RASRAS(RAS_WB, RAS_RGBM)
: rop_copy_bw_rgbm(rin, rout, x1, y1, x2, y2, newx, newy);
CASE RASRAS(RAS_GR8, RAS_CM16)
: rop_copy_gr8_cm16(rin, rout, x1, y1, x2, y2, newx, newy);
CASE RASRAS(RAS_GR8, RAS_CM24)
: rop_copy_gr8_cm24(rin, rout, x1, y1, x2, y2, newx, newy);
CASE RASRAS(RAS_CM8, RAS_CM16)
: rop_copy_cm8_cm16(rin, rout, x1, y1, x2, y2, newx, newy);
CASE RASRAS(RAS_CM8, RAS_CM24)
: rop_copy_cm8_cm24(rin, rout, x1, y1, x2, y2, newx, newy);
CASE RASRAS(RAS_BW, RAS_RGB16)
: __OR RASRAS(RAS_WB, RAS_RGB16)
: rop_copy_bw_rgb16(rin, rout, x1, y1, x2, y2, newx, newy);
CASE RASRAS(RAS_GR8, RAS_RGB16)
: rop_copy_gr8_rgb16(rin, rout, x1, y1, x2, y2, newx, newy);
CASE RASRAS(RAS_CM16, RAS_RGB16)
: rop_copy_cm16_rgb16(rin, rout, x1, y1, x2, y2, newx, newy);
CASE RASRAS(RAS_CM24, RAS_RGB16)
: rop_copy_cm24_rgb16(rin, rout, x1, y1, x2, y2, newx, newy);
D 97 CASE RASRAS(RAS_CM16, RAS_XRGB1555)
: rop_copy_cm16_xrgb1555(rin, rout, x1, y1, x2, y2, newx, newy);
CASE RASRAS(RAS_CM24, RAS_XRGB1555)
: rop_copy_cm24_xrgb1555(rin, rout, x1, y1, x2, y2, newx, newy);
E 97 CASE RASRAS(RAS_RGB_, RAS_RGB16)
: __OR RASRAS(RAS_RGBM, RAS_RGB16)
: rop_copy_rgbx_rgb16(rin, rout, x1, y1, x2, y2, newx, newy);
D 97 CASE RASRAS(RAS_RGB_, RAS_XRGB1555)
: __OR RASRAS(RAS_RGBM, RAS_XRGB1555)
: rop_copy_rgbx_xrgb1555(rin, rout, x1, y1, x2, y2, newx, newy);
E 97 CASE RASRAS(RAS_RGB_64, RAS_RGB16)
: __OR RASRAS(RAS_RGBM64, RAS_RGB16)
: rop_copy_rgbx64_rgb16(rin, rout, x1, y1, x2, y2, newx, newy);
D 97 CASE RASRAS(RAS_RGB_64, RAS_XRGB1555)
: __OR RASRAS(RAS_RGBM64, RAS_XRGB1555)
: rop_copy_rgbx64_xrgb1555(rin, rout, x1, y1, x2, y2, newx, newy);
E 97 CASE RASRAS(RAS_RGB16, RAS_RGB_)
: __OR RASRAS(RAS_RGB16, RAS_RGBM)
: rop_copy_rgb16_rgbm(rin, rout, x1, y1, x2, y2, newx, newy);
D 97 CASE RASRAS(RAS_XRGB1555, RAS_RGB_)
: __OR RASRAS(RAS_XRGB1555, RAS_RGBM)
: rop_copy_xrgb1555_rgbm(rin, rout, x1, y1, x2, y2, newx, newy);
E 97 CASE RASRAS(RAS_RGB_, RAS_RGB)
: __OR RASRAS(RAS_RGBM, RAS_RGB)
: rop_copy_rgbx_rgb(rin, rout, x1, y1, x2, y2, newx, newy);
CASE RASRAS(RAS_RGBM, RAS_CM16S8)
:
I 98 __OR RASRAS(RAS_RGBM, RAS_CM16S12)
:
E 98 __OR RASRAS(RAS_RGBM, RAS_CM16S4)
: __OR RASRAS(RAS_RGBM, RAS_MBW16)
: __OR RASRAS(RAS_RGBM, RAS_GR8)
: __OR RASRAS(RAS_RGBM64, RAS_GR8)
: __OR RASRAS(RAS_RGBM, RAS_GR16)
: __OR RASRAS(RAS_RGBM64, RAS_GR16)
: __OR RASRAS(RAS_RGBM, RAS_CM8S8)
: __OR RASRAS(RAS_RGBM, RAS_CM8S4)
: __OR RASRAS(RAS_RGBM, RAS_BW)
: __OR RASRAS(RAS_RGB_, RAS_CM16S8)
: __OR RASRAS(RAS_RGB_, RAS_CM16S4)
: __OR RASRAS(RAS_RGB_, RAS_MBW16)
: __OR RASRAS(RAS_RGB_, RAS_GR8)
: __OR RASRAS(RAS_RGB_, RAS_CM8S8)
: __OR RASRAS(RAS_RGB_, RAS_CM8S4)
: __OR RASRAS(RAS_RGB_, RAS_BW)
: __OR RASRAS(RAS_RGB16, RAS_CM8S8)
: __OR RASRAS(RAS_RGB16, RAS_BW)
:
I 98 __OR RASRAS(RAS_CM16, RAS_CM16S12)
:
E 98 __OR RASRAS(RAS_CM16, RAS_CM16S8)
: __OR RASRAS(RAS_CM16, RAS_CM16S4)
: __OR RASRAS(RAS_CM16, RAS_MBW16)
: __OR RASRAS(RAS_CM16, RAS_GR8)
: __OR RASRAS(RAS_CM16, RAS_GR16)
: __OR RASRAS(RAS_CM16, RAS_CM8S8)
: __OR RASRAS(RAS_CM16, RAS_CM8S4)
: __OR RASRAS(RAS_CM16, RAS_BW)
:
I 98 __OR RASRAS(RAS_CM24, RAS_CM16S12)
:
E 98 __OR RASRAS(RAS_CM24, RAS_CM16S8)
: __OR RASRAS(RAS_CM24, RAS_CM16S4)
: __OR RASRAS(RAS_CM24, RAS_MBW16)
: __OR RASRAS(RAS_CM24, RAS_GR8)
:
I 103 __OR RASRAS(RAS_CM24, RAS_GR16)
:
E 103 __OR RASRAS(RAS_CM24, RAS_CM8S8)
: __OR RASRAS(RAS_CM24, RAS_CM8S4)
: __OR RASRAS(RAS_CM24, RAS_BW)
:
I 97 __OR RASRAS(RAS_CM8S8, RAS_RGBM)
: __OR RASRAS(RAS_CM8S8, RAS_RGB_)
:
I 101 __OR RASRAS(RAS_CM16S12, RAS_RGBM)
: __OR RASRAS(RAS_CM16S12, RAS_RGB_)
:
E 101 __OR RASRAS(RAS_RLEBW, RAS_RGB_)
: __OR RASRAS(RAS_RLEBW, RAS_RGBM)
:
E 97 rop_copy_quantize(rasras, rin, rout, x1, y1, x2, y2, newx, newy);
DEFAULT:
assert(!"rop_copy; invalid raster combination");
}
E 96
}
if (rout->extra_mask)
if (!(rin->type == RAS_CM24 || rout->type == RAS_CM24))
rop_copy_extra(rin, rout, x1, y1, x2, y2, newx, newy);
/* else e' gia' stato fatto dalle copy particolari */
}
/*---------------------------------------------------------------------------*/
/* copia un rettangolo da rin a rout.
* Le coordinate sono relative ai due raster: (0, 0) corrisponde
* al primo pixel del raster.
* Riduce le dimensioni di un fattore di subsampling pari a shrink.
* I due raster devono essere dello stesso tipo.
*/
D 94 void rop_shrink(RASTER *rin, RASTER *rout, int x1, int y1, int x2, int y2,
int newx, int newy, int shrink) {
E 94
I 94 void rop_shrink(RASTER * rin, RASTER * rout, int x1, int y1, int x2,
int y2, int newx, int newy, int shrink) {
E 94 UCHAR *curr_pixin, *bufferin;
int i, j, tmp, bpp;
int xsize, ysize, wrapin, wrapout;
UCHAR *curr_pixout, *bufferout;
USHORT *curr_pixin_2, *curr_pixout_2;
ULONG *curr_pixin_4, *curr_pixout_4;
if (shrink == 1) {
rop_copy(rin, rout, x1, y1, x2, y2, newx, newy);
return;
}
/* raddrizzo gli estremi */
if (x1 > x2) {
tmp = x1;
x1 = x2;
x2 = tmp;
}
if (y1 > y2) {
tmp = y1;
y1 = y2;
y2 = tmp;
}
/* controllo gli sconfinamenti */
if (x1 < 0 || y1 < 0 || x2 >= rin->lx || y2 >= rin->ly || newx < 0 ||
newy < 0 || newx + (x2 - x1 + shrink) / shrink > rout->lx ||
newy + (y2 - y1 + shrink) / shrink > rout->ly ||
rin->type != rout->type) {
printf("### INTERNAL ERROR - rop_shrink; access violation\n");
return;
}
bpp = rop_pixbytes(rin->type);
xsize = (x2 - x1 + shrink) / shrink;
ysize = (y2 - y1 + shrink) / shrink;
wrapin = rin->wrap * bpp;
bufferin = (UCHAR *)(rin->buffer) + wrapin * y1 + x1 * bpp;
wrapout = rout->wrap * bpp;
bufferout = (UCHAR *)(rout->buffer) + wrapout * newy + newx * bpp;
wrapin *= shrink;
for (i = 0; i < ysize; i++) {
curr_pixin = bufferin;
curr_pixout = bufferout;
bufferin += wrapin;
bufferout += wrapout;
switch (bpp) {
CASE 1 : for (j = 0; j < xsize; j++) {
*curr_pixout = *curr_pixin;
curr_pixin += shrink;
curr_pixout++;
}
CASE 2 : curr_pixin_2 = (USHORT *)curr_pixin;
curr_pixout_2 = (USHORT *)curr_pixout;
for (j = 0; j < xsize; j++) {
*curr_pixout_2 = *curr_pixin_2;
curr_pixin_2 += shrink;
curr_pixout_2++;
}
CASE 4 : curr_pixin_4 = (ULONG *)curr_pixin;
curr_pixout_4 = (ULONG *)curr_pixout;
for (j = 0; j < xsize; j++) {
*curr_pixout_4 = *curr_pixin_4;
curr_pixin_4 += shrink;
curr_pixout_4++;
}
DEFAULT:
for (j = 0; j < xsize; j++) {
memcpy(curr_pixout, curr_pixin, bpp);
curr_pixin += shrink * bpp;
curr_pixout += bpp;
}
}
}
if (rin->extra_mask && rout->extra_mask &&
!(rin->type == RAS_CM24 || rout->type == RAS_CM24)) {
wrapin = rin->wrap * shrink;
wrapout = rout->wrap;
bufferin = rin->extra + x1 + y1 * wrapin;
bufferout = rout->extra + newx + newy * wrapout;
for (i = 0; i < ysize; i++) {
curr_pixin = bufferin;
curr_pixout = bufferout;
bufferin += wrapin;
bufferout += wrapout;
for (j = 0; j < xsize; j++) {
*curr_pixout = *curr_pixin;
curr_pixin += shrink;
curr_pixout++;
}
}
}
}
/*---------------------------------------------------------------------------*/
/* copia un rettangolo da rin a rout.
* Le coordinate sono relative ai due raster: (0, 0) corrisponde
* al primo pixel del raster.
* Riduce le dimensioni di una potenza di due facendo la media dei valori
* dei pixel, ma solo su una parte dei pixel.
*/
void rop_zoom_out(RASTER * rin, RASTER * rout, int x1, int y1, int x2, int y2,
int newx, int newy, int abs_zoom_level) {
int tmp, newlx, newly;
int rasras, factor, abszl;
if (rout->extra_mask) assert(0);
abszl = abs_zoom_level;
factor = 1 << abs_zoom_level;
if (factor == 1) rop_copy(rin, rout, x1, y1, x2, y2, newx, newy);
/* raddrizzo gli estremi */
if (x1 > x2) {
tmp = x1;
x1 = x2;
x2 = tmp;
}
if (y1 > y2) {
tmp = y1;
y1 = y2;
y2 = tmp;
}
/* controllo gli sconfinamenti */
newlx = (x2 - x1 + factor) / factor;
newly = (y2 - y1 + factor) / factor;
E 89 if (x1 < 0 || y1 < 0 || x2 >= rin->lx || y2 >= rin->ly || newx < 0 ||
newy < 0 || newx + newlx > rout->lx || newy + newly > rout->ly) {
printf(
"### INTERNAL ERROR - rop_zoom_out; access violation\n"
" ((%d,%d)(%d,%d)in(%dx%d)->(%d,%d)in(%dx%d))\n",
x1, y1, x2, y2, rin->lx, rin->ly, newx, newy, rout->lx, rout->ly);
return;
}
rasras = RASRAS(rin->type, rout->type);
switch (rasras) {
CASE RASRAS(RAS_GR8, RAS_RGB_)
: __OR RASRAS(RAS_GR8, RAS_RGBM)
: rop_zoom_out_gr8_rgbm(rin, rout, x1, y1, x2, y2, newx, newy, abszl);
CASE RASRAS(RAS_CM16, RAS_RGB_)
: rop_zoom_out_cm16_rgbx(rin, rout, x1, y1, x2, y2, newx, newy,
abszl);
CASE RASRAS(RAS_CM24, RAS_RGB_)
: rop_zoom_out_cm24_rgbx(rin, rout, x1, y1, x2, y2, newx, newy,
abszl);
CASE RASRAS(RAS_CM16, RAS_RGBM)
: rop_zoom_out_cm16_rgbm(rin, rout, x1, y1, x2, y2, newx, newy,
abszl);
CASE RASRAS(RAS_CM24, RAS_RGBM)
: rop_zoom_out_cm24_rgbm(rin, rout, x1, y1, x2, y2, newx, newy,
abszl);
CASE RASRAS(RAS_RGB, RAS_RGB16)
: rop_zoom_out_rgb_rgb16(rin, rout, x1, y1, x2, y2, newx, newy,
abszl);
CASE RASRAS(RAS_RGB, RAS_RGB_)
: __OR RASRAS(RAS_RGB, RAS_RGBM)
: rop_zoom_out_rgb_rgbm(rin, rout, x1, y1, x2, y2, newx, newy, abszl);
CASE RASRAS(RAS_BW, RAS_CM16)
: __OR RASRAS(RAS_WB, RAS_CM16)
: rop_zoom_out_bw_cm16(rin, rout, x1, y1, x2, y2, newx, newy, abszl);
CASE RASRAS(RAS_BW, RAS_CM24)
: __OR RASRAS(RAS_WB, RAS_CM24)
: rop_zoom_out_bw_cm24(rin, rout, x1, y1, x2, y2, newx, newy, abszl);
CASE RASRAS(RAS_BW, RAS_RGB_)
: __OR RASRAS(RAS_BW, RAS_RGBM)
: __OR RASRAS(RAS_WB, RAS_RGB_)
: __OR RASRAS(RAS_WB, RAS_RGBM)
: rop_zoom_out_bw_rgbm(rin, rout, x1, y1, x2, y2, newx, newy, abszl);
CASE RASRAS(RAS_GR8, RAS_CM16)
: rop_zoom_out_gr8_cm16(rin, rout, x1, y1, x2, y2, newx, newy, abszl);
CASE RASRAS(RAS_GR8, RAS_CM24)
: rop_zoom_out_gr8_cm24(rin, rout, x1, y1, x2, y2, newx, newy, abszl);
CASE RASRAS(RAS_WB, RAS_GR8)
: __OR RASRAS(RAS_BW, RAS_GR8)
: rop_zoom_out_bw_gr8(rin, rout, x1, y1, x2, y2, newx, newy, abszl);
CASE RASRAS(RAS_GR8, RAS_GR8)
: rop_zoom_out_gr8(rin, rout, x1, y1, x2, y2, newx, newy, abszl);
CASE RASRAS(RAS_CM16, RAS_CM16)
: rop_zoom_out_cm16(rin, rout, x1, y1, x2, y2, newx, newy, abszl);
CASE RASRAS(RAS_CM16, RAS_CM24)
: rop_zoom_out_cm24(rin, rout, x1, y1, x2, y2, newx, newy, abszl);
CASE RASRAS(RAS_RGB_, RAS_RGB_)
: __OR RASRAS(RAS_RGB_, RAS_RGBM)
: __OR RASRAS(RAS_RGBM, RAS_RGB_)
: rop_zoom_out_rgbx(rin, rout, x1, y1, x2, y2, newx, newy, abszl);
CASE RASRAS(RAS_RGBM, RAS_RGBM)
: rop_zoom_out_rgbm(rin, rout, x1, y1, x2, y2, newx, newy, abszl);
CASE RASRAS(RAS_BW, RAS_RGB16)
: __OR RASRAS(RAS_WB, RAS_RGB16)
: rop_zoom_out_bw_rgb16(rin, rout, x1, y1, x2, y2, newx, newy, abszl);
CASE RASRAS(RAS_GR8, RAS_RGB16)
: rop_zoom_out_gr8_rgb16(rin, rout, x1, y1, x2, y2, newx, newy,
abszl);
CASE RASRAS(RAS_CM16, RAS_RGB16)
: rop_zoom_out_cm16_rgb16(rin, rout, x1, y1, x2, y2, newx, newy,
abszl);
CASE RASRAS(RAS_CM24, RAS_RGB16)
: rop_zoom_out_cm24_rgb16(rin, rout, x1, y1, x2, y2, newx, newy,
abszl);
CASE RASRAS(RAS_RGB_, RAS_RGB16)
: __OR RASRAS(RAS_RGBM, RAS_RGB16)
: rop_zoom_out_rgbx_rgb16(rin, rout, x1, y1, x2, y2, newx, newy,
abszl);
I 95 CASE RASRAS(RAS_RGBM64, RAS_RGB_)
: __OR RASRAS(RAS_RGB_64, RAS_RGB_)
: __OR RASRAS(RAS_RGB_64, RAS_RGBM)
: rop_zoom_out_rgbx64_rgbx(rin, rout, x1, y1, x2, y2, newx, newy,
abszl);
CASE RASRAS(RAS_RGBM64, RAS_RGB16)
: __OR RASRAS(RAS_RGB_64, RAS_RGB16)
: rop_zoom_out_rgbx64_rgb16(rin, rout, x1, y1, x2, y2, newx, newy,
abszl);
CASE RASRAS(RAS_RGBM64, RAS_RGBM)
: rop_zoom_out_rgbm64_rgbm(rin, rout, x1, y1, x2, y2, newx, newy,
abszl);
E 95 DEFAULT : assert(!"rop_zoom_out; invalid raster combination");
}
}
/*---------------------------------------------------------------------------*/
/* copia un rettangolo da rin a rout,
* specchiandolo orizzontalmente se mirror e' dispari,
* e poi ruotandolo del multiplo di novanta gradi specificato
* da ninety in senso antiorario
*
*/
void rop_copy_90(RASTER * rin, RASTER * rout, int x1, int y1, int x2, int y2,
int newx, int newy, int mirror, int ninety) {
int newdx, newdy, tmp;
int rasras;
I 89 if (rout->extra_mask) assert(0);
E 89 mirror &= 1;
ninety &= 3;
if (!ninety && !mirror) {
rop_copy(rin, rout, x1, y1, x2, y2, newx, newy);
return;
}
/* raddrizzo gli estremi */
if (x1 > x2) {
tmp = x1;
x1 = x2;
x2 = tmp;
}
if (y1 > y2) {
tmp = y1;
y1 = y2;
y2 = tmp;
}
switch (ninety) {
CASE 0 : __OR 2 : newdx = x2 - x1 + 1;
newdy = y2 - y1 + 1;
CASE 1 : __OR 3 : newdx = y2 - y1 + 1;
newdy = x2 - x1 + 1;
DEFAULT:
abort();
newdx = newdy = 0;
}
/* controllo gli sconfinamenti */
if (x1 < 0 || y1 < 0 || x2 >= rin->lx || y2 >= rin->ly || newx < 0 ||
newy < 0 || newx + newdx > rout->lx || newy + newdy > rout->ly) {
printf("### INTERNAL ERROR - rop_copy_90; access violation\n");
return;
}
rasras = RASRAS(rin->type, rout->type);
switch (rasras) {
CASE RASRAS(RAS_WB, RAS_WB)
: __OR RASRAS(RAS_BW, RAS_BW)
: rop_copy_90_bw(rin, rout, x1, y1, x2, y2, newx, newy, mirror,
ninety);
return;
CASE RASRAS(RAS_WB, RAS_GR8)
: __OR RASRAS(RAS_BW, RAS_GR8)
: rop_copy_90_bw_gr8(rin, rout, x1, y1, x2, y2, newx, newy, mirror,
ninety);
return;
CASE RASRAS(RAS_WB, RAS_CM16)
: __OR RASRAS(RAS_BW, RAS_CM16)
: rop_copy_90_bw_cm16(rin, rout, x1, y1, x2, y2, newx, newy, mirror,
ninety);
return;
CASE RASRAS(RAS_WB, RAS_CM24)
: __OR RASRAS(RAS_BW, RAS_CM24)
: rop_copy_90_bw_cm24(rin, rout, x1, y1, x2, y2, newx, newy, mirror,
ninety);
return;
CASE RASRAS(RAS_WB, RAS_RGB16)
: __OR RASRAS(RAS_BW, RAS_RGB16)
: rop_copy_90_bw_rgb16(rin, rout, x1, y1, x2, y2, newx, newy, mirror,
ninety);
CASE RASRAS(RAS_WB, RAS_RGB_)
: __OR RASRAS(RAS_WB, RAS_RGBM)
: __OR RASRAS(RAS_BW, RAS_RGB_)
: __OR RASRAS(RAS_BW, RAS_RGBM)
: rop_copy_90_bw_rgbm(rin, rout, x1, y1, x2, y2, newx, newy, mirror,
ninety);
return;
CASE RASRAS(RAS_GR8, RAS_GR8)
: rop_copy_90_gr8(rin, rout, x1, y1, x2, y2, newx, newy, mirror,
ninety);
return;
CASE RASRAS(RAS_GR8, RAS_CM16)
: rop_copy_90_gr8_cm16(rin, rout, x1, y1, x2, y2, newx, newy, mirror,
ninety);
return;
CASE RASRAS(RAS_GR8, RAS_CM24)
: rop_copy_90_gr8_cm24(rin, rout, x1, y1, x2, y2, newx, newy, mirror,
ninety);
return;
CASE RASRAS(RAS_GR8, RAS_RGB16)
: rop_copy_90_gr8_rgb16(rin, rout, x1, y1, x2, y2, newx, newy, mirror,
ninety);
return;
CASE RASRAS(RAS_GR8, RAS_RGB_)
: __OR RASRAS(RAS_GR8, RAS_RGBM)
: rop_copy_90_gr8_rgbm(rin, rout, x1, y1, x2, y2, newx, newy, mirror,
ninety);
return;
CASE RASRAS(RAS_CM8, RAS_CM16)
: rop_copy_90_cm8_cm16(rin, rout, x1, y1, x2, y2, newx, newy, mirror,
ninety);
return;
CASE RASRAS(RAS_CM8, RAS_CM24)
: rop_copy_90_cm8_cm24(rin, rout, x1, y1, x2, y2, newx, newy, mirror,
ninety);
return;
CASE RASRAS(RAS_RGB_, RAS_RGB_)
: __OR RASRAS(RAS_RGBM, RAS_RGB_)
: __OR RASRAS(RAS_RGBM, RAS_RGBM)
: rop_copy_90_rgbm(rin, rout, x1, y1, x2, y2, newx, newy, mirror,
ninety);
return;
CASE RASRAS(RAS_RGB, RAS_RGB16)
: rop_copy_90_rgb_rgb16(rin, rout, x1, y1, x2, y2, newx, newy, mirror,
ninety);
return;
CASE RASRAS(RAS_RGB, RAS_RGB_)
: __OR RASRAS(RAS_RGB, RAS_RGBM)
: rop_copy_90_rgb_rgbm(rin, rout, x1, y1, x2, y2, newx, newy, mirror,
ninety);
return;
DEFAULT:
abort();
}
}
/*---------------------------------------------------------------------------*/
#ifdef VERSIONE_LENTA
static void rop_copy_90_bw(RASTER * rin, RASTER * rout, int x1, int y1,
int x2, int y2, int newx, int newy, int mirror,
int ninety) {
UCHAR *bufin, *bufout;
int bytewrapin, bytewrapout, bitoffsin, bitoffsout, wrapin;
int u, v, lu, lv, su, sv, u00, v00, u0, v0, dudx, dudy, dvdx, dvdy;
int x, y, lx, ly;
int u1, v1, u2, v2;
#ifdef DEBUG
STW_INIT(0, "rop_copy_90_bw")
E 84 STW_START(0)
#endif
E 14
I 14 mirror &= 1;
ninety &= 3;
E 14
D 14 if (!ninety && !flip)
E 14
I 14 if (!ninety && !mirror)
E 14 {
rop_copy(rin, rout, x1, y1, x2, y2, newx, newy);
return;
}
D 14 lx = x2 - x1 + 1;
ly = y2 - y1 + 1;
D 10 wrapin = rin->wrap;
wrapout = rout->wrap;
bit_offs = rin->bit_offs;
E 10
I 10 wrapin = rin->wrap / 8;
bit_offs = rin->bit_offs;
wrapout = rout->wrap;
E 14
I 14 u1 = x1;
v1 = y1;
u2 = x2;
v2 = y2;
su = u2 - u1;
sv = v2 - v1;
lu = u2 - u1 + 1;
lv = v2 - v1 + 1;
E 14
E 10
D 14 rowin = (UCHAR *)rin->buffer + wrapin * y1 + ((x1 + bit_offs) >> 3);
startbit = 7 - ((x1 + bit_offs) & 7);
rowout = (USHORT *)rout->buffer + wrapout * newy + newx;
while (ly-- > 0)
E 14
I 14 if (ninety & 1)
E 14 {
D 14 bytein = rowin;
bit = startbit;
pixout = rowout;
for (x = lx; x > 0; x--) {
outbyte = outx
SET_BIT (rout->buffer
*pixout++ = ((*bytein >> bit) & 1) ? i_1 : i_0;
if (bit==0)
E 14
I 14
lx = lv;
ly = lu;
}
else {
lx = lu;
ly = lv;
}
dudx = 0;
dudy = 0;
dvdx = 0;
dvdy = 0;
switch ((mirror << 2) + ninety) {
CASE(0 << 2) + 0 : u00 = u1;
v00 = v1;
dudx = 1;
dvdy = 1;
CASE(0 << 2) + 1 : u00 = u1;
v00 = v1 + sv;
dudy = 1;
dvdx = -1;
CASE(0 << 2) + 2 : u00 = u1 + su;
v00 = v1 + sv;
dudx = -1;
dvdy = -1;
CASE(0 << 2) + 3 : u00 = u1 + su;
v00 = v1;
dudy = -1;
dvdx = 1;
CASE(1 << 2) + 0 : u00 = u1 + su;
v00 = v1;
dudx = -1;
dvdy = 1;
CASE(1 << 2) + 1 : u00 = u1 + su;
v00 = v1 + sv;
dudy = -1;
dvdx = -1;
CASE(1 << 2) + 2 : u00 = u1;
v00 = v1 + sv;
dudx = 1;
dvdy = -1;
CASE(1 << 2) + 3 : u00 = u1;
v00 = v1;
dudy = 1;
dvdx = 1;
}
D 16 bufin = rin->buffer;
bytewrapin = rin->wrap / 8;
bitoffsin = rin->bit_offs;
E 16
I 16 bufin = rin->buffer;
D 47 bytewrapin = (rin->wrap + 7) / 8;
E 47
I 47 bytewrapin = (rin->wrap + 7) >> 3;
E 47 bitoffsin = rin->bit_offs;
E 16 bufout = rout->buffer;
D 16 bytewrapout = rout->wrap / 8;
E 16
I 16
D 47 bytewrapout = (rout->wrap + 7) / 8;
E 47
I 47 bytewrapout = (rout->wrap + 7) >> 3;
E 47
E 16 bitoffsout = rout->bit_offs;
if (dudx)
for (u0 = u00, v0 = v00, y = newy; y < newy + ly; v0 += dvdy, y++)
for (u = u0, v = v0, x = newx; x < newx + lx; u += dudx, x++)
E 14 {
D 14 bytein++;
bit = 7;
E 14
I 14 if (GET_BIT(u, v, bufin, bytewrapin, bitoffsin))
SET_BIT_1(x, y, bufout, bytewrapout, bitoffsout);
else SET_BIT_0(x, y, bufout, bytewrapout, bitoffsout);
E 14
}
D 14 else bit--;
}
rowin += wrapin;
rowout += wrapout;
}
E 14
I 14 else for (u0 = u00, v0 = v00, y = newy; y < newy + ly;
u0 += dudy, y++) for (u = u0, v = v0, x = newx; x < newx + lx;
v += dvdx, x++) {
if (GET_BIT(u, v, bufin, bytewrapin, bitoffsin))
SET_BIT_1(x, y, bufout, bytewrapout, bitoffsout);
else
SET_BIT_0(x, y, bufout, bytewrapout, bitoffsout);
I 82
}
E 82
D 82
}
E 82
I 15
#ifdef DEBUG
STW_STOP(0) STW_PRINT(stdout)
#endif
}
#endif
/*---------------------------------------------------------------------------*/
static void rop_copy_90_bw(RASTER *rin, RASTER *rout, int x1, int y1, int x2,
int y2, int newx, int newy, int mirror, int ninety) {
UCHAR *bufin, *bufout;
UCHAR tmpbyte;
int bytewrapin, bytewrapout, bitoffsin, bitoffsout, wrapin;
I 83 int u, v, lu, lv, su, sv, u00, v00, u0, v0, dudx, dudy, dvdx, dvdy;
int x, y, lx, ly;
int u1, v1, u2, v2;
#ifdef DEBUG
STW_INIT(0, "rop_copy_90_bw")
STW_START(0)
#endif
mirror &= 1;
ninety &= 3;
if (!ninety && !mirror) {
rop_copy(rin, rout, x1, y1, x2, y2, newx, newy);
return;
}
u1 = x1;
v1 = y1;
E 83
D 83 int u, v, lu, lv, su, sv, u00, v00, u0, v0, dudx, dudy, dvdx, dvdy;
int x, y, lx, ly;
int u1, v1, u2, v2;
D 61
#define BUFBYTE(X, Y, BUF, BYTEWRAP, BITOFFS) \
(((UCHAR *)(BUF))[(((X) + (BITOFFS)) >> 3) + (Y) * (BYTEWRAP)])
#define GET_BIT(X, Y, BUF, BYTEWRAP, BITOFFS) \
((BUFBYTE(X, Y, BUF, BYTEWRAP, BITOFFS) >> (7 - (((X) + (BITOFFS)) & 7))) & \
(UCHAR)1)
#define SET_BIT_0(X, Y, BUF, BYTEWRAP, BITOFFS) \
(BUFBYTE(X, Y, BUF, BYTEWRAP, BITOFFS) &= \
~(1 << (7 - (((X) + (BITOFFS)) & 7))))
#define SET_BIT_1(X, Y, BUF, BYTEWRAP, BITOFFS) \
(BUFBYTE(X, Y, BUF, BYTEWRAP, BITOFFS) |= \
(1 << (7 - (((X) + (BITOFFS)) & 7))))
#define BITCPY(XO, YO, BUFO, BYTEWRAPO, BITOFFSO, XI, YI, BUFI, BYTEWRAPI, \
BITOFFSI) \
{ \
if (GET_BIT(XI, YI, BUFI, BYTEWRAPI, BITOFFSI)) \
SET_BIT_1(XO, YO, BUFO, BYTEWRAPO, BITOFFSO); \
else \
SET_BIT_0(XO, YO, BUFO, BYTEWRAPO, BITOFFSO); \
}
E 61
#ifdef DEBUG
STW_INIT(0, "rop_copy_90_bw") STW_START(0)
#endif
mirror &= 1;
ninety &= 3;
if (!ninety && !mirror) {
rop_copy(rin, rout, x1, y1, x2, y2, newx, newy);
return;
}
u1 = x1;
v1 = y1;
E 83 u2 = x2;
v2 = y2;
su = u2 - u1;
sv = v2 - v1;
lu = u2 - u1 + 1;
lv = v2 - v1 + 1;
if (ninety & 1) {
lx = lv;
ly = lu;
} else {
lx = lu;
ly = lv;
}
dudx = 0;
dudy = 0;
dvdx = 0;
dvdy = 0;
switch ((mirror << 2) + ninety) {
CASE(0 << 2) + 0 : u00 = u1;
v00 = v1;
dudx = 1;
dvdy = 1;
CASE(0 << 2) + 1 : u00 = u1;
v00 = v1 + sv;
dudy = 1;
dvdx = -1;
CASE(0 << 2) + 2 : u00 = u1 + su;
v00 = v1 + sv;
dudx = -1;
dvdy = -1;
CASE(0 << 2) + 3 : u00 = u1 + su;
v00 = v1;
dudy = -1;
dvdx = 1;
CASE(1 << 2) + 0 : u00 = u1 + su;
v00 = v1;
dudx = -1;
dvdy = 1;
CASE(1 << 2) + 1 : u00 = u1 + su;
v00 = v1 + sv;
dudy = -1;
dvdx = -1;
CASE(1 << 2) + 2 : u00 = u1;
v00 = v1 + sv;
dudx = 1;
dvdy = -1;
CASE(1 << 2) + 3 : u00 = u1;
v00 = v1;
dudy = 1;
dvdx = 1;
I 50
D 78 DEFAULT : assert(FALSE);
u00 = v00 = dudy = dvdx = 0;
E 78
I 78 DEFAULT : abort();
u00 = v00 = dudy = dvdx = 0;
E 78
E 50
}
D 16 bufin = rin->buffer;
bytewrapin = rin->wrap / 8;
bitoffsin = rin->bit_offs;
E 16
I 16 bufin = rin->buffer;
D 47 bytewrapin = (rin->wrap + 7) / 8;
E 47
I 47 bytewrapin = (rin->wrap + 7) >> 3;
E 47 bitoffsin = rin->bit_offs;
E 16 bufout = rout->buffer;
D 16 bytewrapout = rout->wrap / 8;
E 16
I 16
D 47 bytewrapout = (rout->wrap + 7) / 8;
E 47
I 47 bytewrapout = (rout->wrap + 7) >> 3;
E 47
E 16 bitoffsout = rout->bit_offs;
if (dudx)
for (u0 = u00, v0 = v00, y = newy; y < newy + ly; v0 += dvdy, y++) {
u = u0;
v = v0;
x = newx;
for (; x < newx + lx && ((x + bitoffsout) & 7); u += dudx, x++)
BITCPY(x, y, bufout, bytewrapout, bitoffsout, u, v, bufin, bytewrapin,
bitoffsin)
for (; x < newx + lx - 7; x += 8) {
tmpbyte = GET_BIT(u, v, bufin, bytewrapin, bitoffsin) << 7;
u += dudx;
tmpbyte |= GET_BIT(u, v, bufin, bytewrapin, bitoffsin) << 6;
u += dudx;
tmpbyte |= GET_BIT(u, v, bufin, bytewrapin, bitoffsin) << 5;
u += dudx;
tmpbyte |= GET_BIT(u, v, bufin, bytewrapin, bitoffsin) << 4;
u += dudx;
tmpbyte |= GET_BIT(u, v, bufin, bytewrapin, bitoffsin) << 3;
u += dudx;
tmpbyte |= GET_BIT(u, v, bufin, bytewrapin, bitoffsin) << 2;
u += dudx;
tmpbyte |= GET_BIT(u, v, bufin, bytewrapin, bitoffsin) << 1;
u += dudx;
tmpbyte |= GET_BIT(u, v, bufin, bytewrapin, bitoffsin);
u += dudx;
BUFBYTE(x, y, bufout, bytewrapout, bitoffsout) = tmpbyte;
}
for (; x < newx + lx; u += dudx, x++)
BITCPY(x, y, bufout, bytewrapout, bitoffsout, u, v, bufin, bytewrapin,
bitoffsin)
}
else
for (u0 = u00, v0 = v00, y = newy; y < newy + ly; u0 += dudy, y++) {
u = u0;
v = v0;
x = newx;
for (; x < newx + lx && ((x + bitoffsout) & 7); v += dvdx, x++)
BITCPY(x, y, bufout, bytewrapout, bitoffsout, u, v, bufin, bytewrapin,
bitoffsin)
for (; x < newx + lx - 7; x += 8) {
tmpbyte = GET_BIT(u, v, bufin, bytewrapin, bitoffsin) << 7;
v += dvdx;
tmpbyte |= GET_BIT(u, v, bufin, bytewrapin, bitoffsin) << 6;
v += dvdx;
tmpbyte |= GET_BIT(u, v, bufin, bytewrapin, bitoffsin) << 5;
v += dvdx;
tmpbyte |= GET_BIT(u, v, bufin, bytewrapin, bitoffsin) << 4;
v += dvdx;
tmpbyte |= GET_BIT(u, v, bufin, bytewrapin, bitoffsin) << 3;
v += dvdx;
tmpbyte |= GET_BIT(u, v, bufin, bytewrapin, bitoffsin) << 2;
v += dvdx;
tmpbyte |= GET_BIT(u, v, bufin, bytewrapin, bitoffsin) << 1;
v += dvdx;
tmpbyte |= GET_BIT(u, v, bufin, bytewrapin, bitoffsin);
v += dvdx;
BUFBYTE(x, y, bufout, bytewrapout, bitoffsout) = tmpbyte;
}
for (; x < newx + lx; v += dvdx, x++)
BITCPY(x, y, bufout, bytewrapout, bitoffsout, u, v, bufin, bytewrapin,
bitoffsin)
}
E 15
#ifdef DEBUG
STW_STOP(0) STW_PRINT(stdout)
#endif
}
/*---------------------------------------------------------------------------*/
E 14
I 14
#ifdef VERSIONE_LENTA
static void
rop_copy_90_gr8(RASTER *rin, RASTER *rout, int x1, int y1, int x2, int y2,
int newx, int newy, int mirror, int ninety) {
UCHAR *bufin, *bufout;
int wrapin, wrapout;
int u, v, lu, lv, su, sv, u00, v00, u0, v0, dudx, dudy, dvdx, dvdy;
int x, y, lx, ly;
int u1, v1, u2, v2;
#ifdef DEBUG
STW_INIT(0, "rop_copy_90_gr8")
STW_START(0)
#endif
E 14
D 14
#else
E 14
I 14 mirror &= 1;
ninety &= 3;
E 14
D 14 if (!ninety && !flip)
E 14
I 14 if (!ninety && !mirror)
E 14 {
rop_copy(rin, rout, x1, y1, x2, y2, newx, newy);
return;
}
I 14 u1 = x1;
v1 = y1;
u2 = x2;
v2 = y2;
su = u2 - u1;
sv = v2 - v1;
lu = u2 - u1 + 1;
lv = v2 - v1 + 1;
if (ninety & 1) {
lx = lv;
ly = lu;
} else {
lx = lu;
ly = lv;
}
dudx = 0;
dudy = 0;
dvdx = 0;
dvdy = 0;
switch ((mirror << 2) + ninety) {
CASE(0 << 2) + 0 : u00 = u1;
v00 = v1;
dudx = 1;
dvdy = 1;
CASE(0 << 2) + 1 : u00 = u1;
v00 = v1 + sv;
dudy = 1;
dvdx = -1;
CASE(0 << 2) + 2 : u00 = u1 + su;
v00 = v1 + sv;
dudx = -1;
dvdy = -1;
CASE(0 << 2) + 3 : u00 = u1 + su;
v00 = v1;
dudy = -1;
dvdx = 1;
CASE(1 << 2) + 0 : u00 = u1 + su;
v00 = v1;
dudx = -1;
dvdy = 1;
CASE(1 << 2) + 1 : u00 = u1 + su;
v00 = v1 + sv;
dudy = -1;
dvdx = -1;
CASE(1 << 2) + 2 : u00 = u1;
v00 = v1 + sv;
dudx = 1;
dvdy = -1;
CASE(1 << 2) + 3 : u00 = u1;
v00 = v1;
dudy = 1;
dvdx = 1;
}
bufin = rin->buffer;
wrapin = rin->wrap;
bufout = rout->buffer;
wrapout = rout->wrap;
if (dudx)
for (u0 = u00, v0 = v00, y = newy; y < newy + ly; v0 += dvdy, y++)
for (u = u0, v = v0, x = newx; x < newx + lx; u += dudx, x++) {
bufout[x + y * wrapout] = bufin[u + v * wrapin];
}
else
for (u0 = u00, v0 = v00, y = newy; y < newy + ly; u0 += dudy, y++)
for (u = u0, v = v0, x = newx; x < newx + lx; v += dvdx, x++) {
bufout[x + y * wrapout] = bufin[u + v * wrapin];
}
#ifdef DEBUG
STW_STOP(0)
STW_PRINT(stdout)
E 14
#endif
}
I 14
#endif
E 14
/*---------------------------------------------------------------------------*/
static void rop_copy_90_gr8(RASTER *rin, RASTER *rout,
int x1, int y1, int x2, int y2,
int newx, int newy,
D 14
int ninety, int flip)
E 14
I 14
int mirror, int ninety)
E 14
{
D 14 if (!ninety && !flip)
E 14
I 14 UCHAR *bufin, *bufout, *bytein, *byteout;
int wrapin, wrapout;
int u, v, lu, lv, su, sv, u00, v00, u0, v0, dindx, dudy, dvdy;
int x, y, lx, ly;
int u1, v1, u2, v2;
#ifdef DEBUG
STW_INIT(0, "rop_copy_90_gr8")
STW_START(0)
#endif
mirror &= 1;
ninety &= 3;
if (!ninety && !mirror)
E 14 {
rop_copy(rin, rout, x1, y1, x2, y2, newx, newy);
return;
}
I 14
u1 = x1;
v1 = y1;
u2 = x2;
v2 = y2;
su = u2 - u1;
sv = v2 - v1;
lu = u2 - u1 + 1;
lv = v2 - v1 + 1;
if (ninety & 1) {
lx = lv;
ly = lu;
} else {
lx = lu;
ly = lv;
}
bufin = rin->buffer;
wrapin = rin->wrap;
bufout = rout->buffer;
wrapout = rout->wrap;
dudy = 0;
dvdy = 0;
switch ((mirror << 2) + ninety) {
CASE(0 << 2) + 0 : u00 = u1;
v00 = v1;
dvdy = 1;
dindx = 1;
CASE(0 << 2) + 1 : u00 = u1;
v00 = v1 + sv;
dudy = 1;
dindx = -wrapin;
D 61 CASE(0 << 2) + 2 : u00 = u1 + su;
v00 = v1 + sv;
dvdy = -1;
dindx = -1;
CASE(0 << 2) + 3 : u00 = u1 + su;
v00 = v1;
dudy = -1;
dindx = wrapin;
CASE(1 << 2) + 0 : u00 = u1 + su;
v00 = v1;
dvdy = 1;
dindx = -1;
CASE(1 << 2) + 1 : u00 = u1 + su;
v00 = v1 + sv;
dudy = -1;
dindx = -wrapin;
CASE(1 << 2) + 2 : u00 = u1;
v00 = v1 + sv;
dvdy = -1;
dindx = 1;
CASE(1 << 2) + 3 : u00 = u1;
v00 = v1;
dudy = 1;
dindx = wrapin;
I 50 DEFAULT : assert(FALSE);
u00 = v00 = dudy = dindx = 0;
E 50
}
for (u0 = u00, v0 = v00, y = newy; y < newy + ly;
u0 += dudy, v0 += dvdy, y++) {
bytein = bufin + u0 + v0 * wrapin;
byteout = bufout + newx + y * wrapout;
for (x = newx; x < newx + lx; x++) {
*byteout++ = *bytein;
bytein += dindx;
}
}
I 17
#ifdef DEBUG
STW_STOP(0) STW_PRINT(stdout)
#endif
}
/*---------------------------------------------------------------------------*/
I 21 static void rop_copy_90_gr8_cm16(RASTER * rin, RASTER * rout, int x1,
int y1, int x2, int y2, int newx,
int newy, int mirror, int ninety) {
UCHAR *bufin, *bytein;
USHORT *bufout, *pixout;
LPIXEL *cmap;
int wrapin, wrapout, cmap_offset;
int u, v, lu, lv, su, sv, u00, v00, u0, v0, dindx, dudy, dvdy;
int x, y, lx, ly;
int u1, v1, u2, v2;
int reversed;
mirror &= 1;
ninety &= 3;
if (!ninety && !mirror) {
rop_copy(rin, rout, x1, y1, x2, y2, newx, newy);
return;
}
if (!rout->cmap.buffer) {
msg(MSG_IE, "rop_copy_90_gr8_cm16: missing color map");
return;
}
cmap = rout->cmap.buffer;
D 56 cmap_offset = rout->cmap.offset;
E 56
I 56 cmap_offset = rout->cmap.info.offset_mask;
E 56 reversed = cmap[0].r != 0;
u1 = x1;
v1 = y1;
u2 = x2;
v2 = y2;
su = u2 - u1;
sv = v2 - v1;
lu = u2 - u1 + 1;
lv = v2 - v1 + 1;
if (ninety & 1) {
lx = lv;
ly = lu;
} else {
lx = lu;
ly = lv;
}
bufin = rin->buffer;
wrapin = rin->wrap;
bufout = rout->buffer;
wrapout = rout->wrap;
dudy = 0;
dvdy = 0;
switch ((mirror << 2) + ninety) {
CASE(0 << 2) + 0 : u00 = u1;
v00 = v1;
dvdy = 1;
dindx = 1;
CASE(0 << 2) + 1 : u00 = u1;
v00 = v1 + sv;
dudy = 1;
dindx = -wrapin;
CASE(0 << 2) + 2 : u00 = u1 + su;
v00 = v1 + sv;
dvdy = -1;
dindx = -1;
CASE(0 << 2) + 3 : u00 = u1 + su;
v00 = v1;
dudy = -1;
dindx = wrapin;
CASE(1 << 2) + 0 : u00 = u1 + su;
v00 = v1;
dvdy = 1;
dindx = -1;
CASE(1 << 2) + 1 : u00 = u1 + su;
v00 = v1 + sv;
dudy = -1;
dindx = -wrapin;
CASE(1 << 2) + 2 : u00 = u1;
v00 = v1 + sv;
dvdy = -1;
dindx = 1;
CASE(1 << 2) + 3 : u00 = u1;
v00 = v1;
dudy = 1;
dindx = wrapin;
I 50 DEFAULT : assert(FALSE);
u00 = v00 = dudy = dindx = 0;
E 50
}
for (u0 = u00, v0 = v00, y = newy; y < newy + ly;
u0 += dudy, v0 += dvdy, y++) {
bytein = bufin + u0 + v0 * wrapin;
pixout = bufout + newx + y * wrapout;
if (reversed)
for (x = newx; x < newx + lx; x++) {
*pixout++ = cmap_offset + (255 - *bytein);
bytein += dindx;
}
else
for (x = newx; x < newx + lx; x++) {
*pixout++ = cmap_offset + *bytein;
bytein += dindx;
}
I 23
}
}
/*---------------------------------------------------------------------------*/
static void rop_copy_90_cm8_cm16(RASTER * rin, RASTER * rout, int x1, int y1,
int x2, int y2, int newx, int newy, int mirror,
int ninety) {
UCHAR *bufin, *pixin;
USHORT *bufout, *pixout;
LPIXEL *cmapin, *cmapout;
int wrapin, wrapout, cmapin_offset, cmapout_offset, cmap_offset_delta;
int u, v, lu, lv, su, sv, u00, v00, u0, v0, dindx, dudy, dvdy;
int x, y, lx, ly;
int u1, v1, u2, v2;
mirror &= 1;
ninety &= 3;
if (!ninety && !mirror) {
rop_copy(rin, rout, x1, y1, x2, y2, newx, newy);
return;
}
if (!rin->cmap.buffer || !rout->cmap.buffer) {
msg(MSG_IE, "rop_copy_90_cm8_cm16: missing color map");
return;
}
cmapin = rin->cmap.buffer;
cmapout = rout->cmap.buffer;
D 56 cmapin_offset = rin->cmap.offset;
cmapout_offset = rout->cmap.offset;
E 56
I 56 cmapin_offset = rin->cmap.info.offset_mask;
cmapout_offset = rout->cmap.info.offset_mask;
E 56 cmap_offset_delta = cmapout_offset - cmapin_offset;
u1 = x1;
v1 = y1;
u2 = x2;
v2 = y2;
su = u2 - u1;
sv = v2 - v1;
lu = u2 - u1 + 1;
lv = v2 - v1 + 1;
if (ninety & 1) {
lx = lv;
ly = lu;
} else {
lx = lu;
ly = lv;
}
bufin = rin->buffer;
wrapin = rin->wrap;
bufout = rout->buffer;
wrapout = rout->wrap;
dudy = 0;
dvdy = 0;
switch ((mirror << 2) + ninety) {
CASE(0 << 2) + 0 : u00 = u1;
v00 = v1;
dvdy = 1;
dindx = 1;
CASE(0 << 2) + 1 : u00 = u1;
v00 = v1 + sv;
dudy = 1;
dindx = -wrapin;
CASE(0 << 2) + 2 : u00 = u1 + su;
v00 = v1 + sv;
dvdy = -1;
dindx = -1;
CASE(0 << 2) + 3 : u00 = u1 + su;
v00 = v1;
dudy = -1;
dindx = wrapin;
CASE(1 << 2) + 0 : u00 = u1 + su;
v00 = v1;
dvdy = 1;
dindx = -1;
CASE(1 << 2) + 1 : u00 = u1 + su;
v00 = v1 + sv;
dudy = -1;
dindx = -wrapin;
CASE(1 << 2) + 2 : u00 = u1;
v00 = v1 + sv;
dvdy = -1;
dindx = 1;
CASE(1 << 2) + 3 : u00 = u1;
v00 = v1;
dudy = 1;
dindx = wrapin;
I 50 DEFAULT : assert(FALSE);
u00 = v00 = dudy = dindx = 0;
E 50
}
for (u0 = u00, v0 = v00, y = newy; y < newy + ly;
u0 += dudy, v0 += dvdy, y++) {
pixin = bufin + u0 + v0 * wrapin;
pixout = bufout + newx + y * wrapout;
for (x = newx; x < newx + lx; x++) {
*pixout++ = *pixin + cmap_offset_delta;
pixin += dindx;
}
E 23
}
}
/*---------------------------------------------------------------------------*/
I 22
D 55 static void rop_copy_90_gr8_rgbm(RASTER * rin, RASTER * rout, int x1,
int y1, int x2, int y2, int newx,
int newy, int mirror, int ninety)
E 55
I 55 static void
rop_copy_90_gr8_rgb16(RASTER * rin, RASTER * rout, int x1, int y1, int x2,
int y2, int newx, int newy, int mirror, int ninety)
E 55 {
UCHAR *bufin, *bytein;
D 55 LPIXEL *bufout, *pixout, tmp;
E 55
I 55 USHORT *bufout, *pixout;
E 55 int wrapin, wrapout;
int u, v, lu, lv, su, sv, u00, v00, u0, v0, dindx, dudy, dvdy;
int x, y, lx, ly;
int u1, v1, u2, v2;
mirror &= 1;
ninety &= 3;
if (!ninety && !mirror) {
rop_copy(rin, rout, x1, y1, x2, y2, newx, newy);
return;
}
u1 = x1;
v1 = y1;
u2 = x2;
v2 = y2;
su = u2 - u1;
sv = v2 - v1;
lu = u2 - u1 + 1;
lv = v2 - v1 + 1;
if (ninety & 1) {
lx = lv;
ly = lu;
} else {
lx = lu;
ly = lv;
}
bufin = rin->buffer;
wrapin = rin->wrap;
E 61
I 61 CASE(0 << 2) + 2 : u00 = u1 + su;
v00 = v1 + sv;
dvdy = -1;
dindx = -1;
CASE(0 << 2) + 3 : u00 = u1 + su;
v00 = v1;
dudy = -1;
dindx = wrapin;
CASE(1 << 2) + 0 : u00 = u1 + su;
v00 = v1;
dvdy = 1;
dindx = -1;
CASE(1 << 2) + 1 : u00 = u1 + su;
v00 = v1 + sv;
dudy = -1;
dindx = -wrapin;
CASE(1 << 2) + 2 : u00 = u1;
v00 = v1 + sv;
dvdy = -1;
dindx = 1;
CASE(1 << 2) + 3 : u00 = u1;
v00 = v1;
dudy = 1;
dindx = wrapin;
D 78 DEFAULT : assert(FALSE);
u00 = v00 = dudy = dindx = 0;
E 78
I 78 DEFAULT : abort();
u00 = v00 = dudy = dindx = 0;
E 78
}
for (u0 = u00, v0 = v00, y = newy; y < newy + ly; u0 += dudy, v0 += dvdy, y++) {
bytein = bufin + u0 + v0 * wrapin;
byteout = bufout + newx + y * wrapout;
for (x = newx; x < newx + lx; x++) {
*byteout++ = *bytein;
bytein += dindx;
D 62
}
}
E 62
I 62
}
}
E 62
#ifdef DEBUG
STW_STOP(0) STW_PRINT(stdout)
#endif
}
/*---------------------------------------------------------------------------*/
static void rop_copy_90_gr8_cm16(RASTER *rin, RASTER *rout, int x1, int y1,
int x2, int y2, int newx, int newy, int mirror,
int ninety) {
UCHAR *bufin, *bytein;
USHORT *bufout, *pixout;
LPIXEL *cmap;
int wrapin, wrapout, cmap_offset;
int u, v, lu, lv, su, sv, u00, v00, u0, v0, dindx, dudy, dvdy;
int x, y, lx, ly;
int u1, v1, u2, v2;
int reversed;
mirror &= 1;
ninety &= 3;
if (!ninety && !mirror) {
rop_copy(rin, rout, x1, y1, x2, y2, newx, newy);
return;
}
D 84 if (!rout->cmap.buffer) {
msg(MSG_IE, "rop_copy_90_gr8_cm16: missing color map");
return;
}
E 84 cmap = rout->cmap.buffer;
cmap_offset = rout->cmap.info.offset_mask;
reversed = cmap[0].r != 0;
u1 = x1;
v1 = y1;
u2 = x2;
v2 = y2;
su = u2 - u1;
sv = v2 - v1;
lu = u2 - u1 + 1;
lv = v2 - v1 + 1;
if (ninety & 1) {
lx = lv;
ly = lu;
} else {
lx = lu;
ly = lv;
}
bufin = rin->buffer;
wrapin = rin->wrap;
bufout = rout->buffer;
wrapout = rout->wrap;
dudy = 0;
dvdy = 0;
switch ((mirror << 2) + ninety) {
CASE(0 << 2) + 0 : u00 = u1;
v00 = v1;
dvdy = 1;
dindx = 1;
CASE(0 << 2) + 1 : u00 = u1;
v00 = v1 + sv;
dudy = 1;
dindx = -wrapin;
CASE(0 << 2) + 2 : u00 = u1 + su;
v00 = v1 + sv;
dvdy = -1;
dindx = -1;
CASE(0 << 2) + 3 : u00 = u1 + su;
v00 = v1;
dudy = -1;
dindx = wrapin;
CASE(1 << 2) + 0 : u00 = u1 + su;
v00 = v1;
dvdy = 1;
dindx = -1;
CASE(1 << 2) + 1 : u00 = u1 + su;
v00 = v1 + sv;
dudy = -1;
dindx = -wrapin;
CASE(1 << 2) + 2 : u00 = u1;
v00 = v1 + sv;
dvdy = -1;
dindx = 1;
CASE(1 << 2) + 3 : u00 = u1;
v00 = v1;
dudy = 1;
dindx = wrapin;
D 78 DEFAULT : assert(FALSE);
u00 = v00 = dudy = dindx = 0;
E 78
I 78 DEFAULT : abort();
u00 = v00 = dudy = dindx = 0;
E 78
}
for (u0 = u00, v0 = v00, y = newy; y < newy + ly;
u0 += dudy, v0 += dvdy, y++) {
bytein = bufin + u0 + v0 * wrapin;
pixout = bufout + newx + y * wrapout;
if (reversed)
for (x = newx; x < newx + lx; x++) {
*pixout++ = cmap_offset + (255 - *bytein);
bytein += dindx;
}
else
for (x = newx; x < newx + lx; x++) {
*pixout++ = cmap_offset + *bytein;
bytein += dindx;
}
}
}
/*---------------------------------------------------------------------------*/
I 84 static void rop_copy_90_gr8_cm24(RASTER *rin, RASTER *rout, int x1,
int y1, int x2, int y2, int newx,
int newy, int mirror, int ninety) {
UCHAR *bufin, *bytein;
ULONG *bufout, *pixout;
LPIXEL *penmap, *colmap;
int wrapin, wrapout;
int u, v, lu, lv, su, sv, u00, v00, u0, v0, dindx, dudy, dvdy;
int x, y, lx, ly;
int u1, v1, u2, v2;
int reversed;
mirror &= 1;
ninety &= 3;
if (!ninety && !mirror) {
rop_copy(rin, rout, x1, y1, x2, y2, newx, newy);
return;
}
penmap = rout->cmap.penbuffer;
colmap = rout->cmap.colbuffer;
reversed = penmap[0].r + colmap[0].r != 0;
u1 = x1;
v1 = y1;
u2 = x2;
v2 = y2;
su = u2 - u1;
sv = v2 - v1;
lu = u2 - u1 + 1;
lv = v2 - v1 + 1;
if (ninety & 1) {
lx = lv;
ly = lu;
} else {
lx = lu;
ly = lv;
}
bufin = rin->buffer;
wrapin = rin->wrap;
bufout = rout->buffer;
wrapout = rout->wrap;
dudy = 0;
dvdy = 0;
switch ((mirror << 2) + ninety) {
CASE(0 << 2) + 0 : u00 = u1;
v00 = v1;
dvdy = 1;
dindx = 1;
CASE(0 << 2) + 1 : u00 = u1;
v00 = v1 + sv;
dudy = 1;
dindx = -wrapin;
CASE(0 << 2) + 2 : u00 = u1 + su;
v00 = v1 + sv;
dvdy = -1;
dindx = -1;
CASE(0 << 2) + 3 : u00 = u1 + su;
v00 = v1;
dudy = -1;
dindx = wrapin;
CASE(1 << 2) + 0 : u00 = u1 + su;
v00 = v1;
dvdy = 1;
dindx = -1;
CASE(1 << 2) + 1 : u00 = u1 + su;
v00 = v1 + sv;
dudy = -1;
dindx = -wrapin;
CASE(1 << 2) + 2 : u00 = u1;
v00 = v1 + sv;
dvdy = -1;
dindx = 1;
CASE(1 << 2) + 3 : u00 = u1;
v00 = v1;
dudy = 1;
dindx = wrapin;
DEFAULT:
abort();
u00 = v00 = dudy = dindx = 0;
}
for (u0 = u00, v0 = v00, y = newy; y < newy + ly;
u0 += dudy, v0 += dvdy, y++) {
bytein = bufin + u0 + v0 * wrapin;
pixout = bufout + newx + y * wrapout;
if (reversed)
for (x = newx; x < newx + lx; x++) {
*pixout++ = 255 - *bytein;
bytein += dindx;
}
else
for (x = newx; x < newx + lx; x++) {
*pixout++ = *bytein;
bytein += dindx;
}
}
}
/*---------------------------------------------------------------------------*/
E 84 static void rop_copy_90_cm8_cm16(RASTER *rin, RASTER *rout, int x1,
int y1, int x2, int y2, int newx,
int newy, int mirror, int ninety) {
UCHAR *bufin, *pixin;
USHORT *bufout, *pixout;
D 84 LPIXEL *cmapin, *cmapout;
E 84 int wrapin, wrapout, cmapin_offset, cmapout_offset, cmap_offset_delta;
int u, v, lu, lv, su, sv, u00, v00, u0, v0, dindx, dudy, dvdy;
int x, y, lx, ly;
int u1, v1, u2, v2;
mirror &= 1;
ninety &= 3;
if (!ninety && !mirror) {
rop_copy(rin, rout, x1, y1, x2, y2, newx, newy);
return;
}
D 84 if (!rin->cmap.buffer || !rout->cmap.buffer) {
msg(MSG_IE, "rop_copy_90_cm8_cm16: missing color map");
return;
}
cmapin = rin->cmap.buffer;
cmapout = rout->cmap.buffer;
E 84 cmapin_offset = rin->cmap.info.offset_mask;
cmapout_offset = rout->cmap.info.offset_mask;
cmap_offset_delta = cmapout_offset - cmapin_offset;
u1 = x1;
v1 = y1;
u2 = x2;
v2 = y2;
su = u2 - u1;
sv = v2 - v1;
lu = u2 - u1 + 1;
lv = v2 - v1 + 1;
if (ninety & 1) {
lx = lv;
ly = lu;
} else {
lx = lu;
ly = lv;
}
bufin = rin->buffer;
wrapin = rin->wrap;
bufout = rout->buffer;
wrapout = rout->wrap;
dudy = 0;
dvdy = 0;
switch ((mirror << 2) + ninety) {
CASE(0 << 2) + 0 : u00 = u1;
v00 = v1;
dvdy = 1;
dindx = 1;
CASE(0 << 2) + 1 : u00 = u1;
v00 = v1 + sv;
dudy = 1;
dindx = -wrapin;
CASE(0 << 2) + 2 : u00 = u1 + su;
v00 = v1 + sv;
dvdy = -1;
dindx = -1;
CASE(0 << 2) + 3 : u00 = u1 + su;
v00 = v1;
dudy = -1;
dindx = wrapin;
CASE(1 << 2) + 0 : u00 = u1 + su;
v00 = v1;
dvdy = 1;
dindx = -1;
CASE(1 << 2) + 1 : u00 = u1 + su;
v00 = v1 + sv;
dudy = -1;
dindx = -wrapin;
CASE(1 << 2) + 2 : u00 = u1;
v00 = v1 + sv;
dvdy = -1;
dindx = 1;
CASE(1 << 2) + 3 : u00 = u1;
v00 = v1;
dudy = 1;
dindx = wrapin;
D 78 DEFAULT : assert(FALSE);
u00 = v00 = dudy = dindx = 0;
E 78
I 78 DEFAULT : abort();
u00 = v00 = dudy = dindx = 0;
E 78
}
for (u0 = u00, v0 = v00, y = newy; y < newy + ly;
u0 += dudy, v0 += dvdy, y++) {
pixin = bufin + u0 + v0 * wrapin;
pixout = bufout + newx + y * wrapout;
for (x = newx; x < newx + lx; x++) {
*pixout++ = *pixin + cmap_offset_delta;
pixin += dindx;
}
}
}
/*---------------------------------------------------------------------------*/
I 84 static void rop_copy_90_cm8_cm24(RASTER *rin, RASTER *rout, int x1,
int y1, int x2, int y2, int newx,
int newy, int mirror, int ninety) {
UCHAR *bufin, *pixin;
ULONG *bufout, *pixout;
int wrapin, wrapout, cmapin_offset, cmap_offset_delta;
int u, v, lu, lv, su, sv, u00, v00, u0, v0, dindx, dudy, dvdy;
int x, y, lx, ly;
int u1, v1, u2, v2;
mirror &= 1;
ninety &= 3;
if (!ninety && !mirror) {
rop_copy(rin, rout, x1, y1, x2, y2, newx, newy);
return;
}
cmapin_offset = rin->cmap.info.offset_mask;
cmap_offset_delta = -cmapin_offset;
u1 = x1;
v1 = y1;
u2 = x2;
v2 = y2;
su = u2 - u1;
sv = v2 - v1;
lu = u2 - u1 + 1;
lv = v2 - v1 + 1;
if (ninety & 1) {
lx = lv;
ly = lu;
} else {
lx = lu;
ly = lv;
}
bufin = rin->buffer;
wrapin = rin->wrap;
bufout = rout->buffer;
wrapout = rout->wrap;
dudy = 0;
dvdy = 0;
switch ((mirror << 2) + ninety) {
CASE(0 << 2) + 0 : u00 = u1;
v00 = v1;
dvdy = 1;
dindx = 1;
CASE(0 << 2) + 1 : u00 = u1;
v00 = v1 + sv;
dudy = 1;
dindx = -wrapin;
CASE(0 << 2) + 2 : u00 = u1 + su;
v00 = v1 + sv;
dvdy = -1;
dindx = -1;
CASE(0 << 2) + 3 : u00 = u1 + su;
v00 = v1;
dudy = -1;
dindx = wrapin;
CASE(1 << 2) + 0 : u00 = u1 + su;
v00 = v1;
dvdy = 1;
dindx = -1;
CASE(1 << 2) + 1 : u00 = u1 + su;
v00 = v1 + sv;
dudy = -1;
dindx = -wrapin;
CASE(1 << 2) + 2 : u00 = u1;
v00 = v1 + sv;
dvdy = -1;
dindx = 1;
CASE(1 << 2) + 3 : u00 = u1;
v00 = v1;
dudy = 1;
dindx = wrapin;
DEFAULT:
abort();
u00 = v00 = dudy = dindx = 0;
}
for (u0 = u00, v0 = v00, y = newy; y < newy + ly;
u0 += dudy, v0 += dvdy, y++) {
pixin = bufin + u0 + v0 * wrapin;
pixout = bufout + newx + y * wrapout;
for (x = newx; x < newx + lx; x++) {
*pixout++ = *pixin + cmap_offset_delta;
pixin += dindx;
}
}
}
/*---------------------------------------------------------------------------*/
E 84 static void rop_copy_90_gr8_rgb16(RASTER *rin, RASTER *rout, int x1,
int y1, int x2, int y2, int newx,
int newy, int mirror, int ninety) {
UCHAR *bufin, *bytein;
USHORT *bufout, *pixout;
int wrapin, wrapout;
int u, v, lu, lv, su, sv, u00, v00, u0, v0, dindx, dudy, dvdy;
int x, y, lx, ly;
int u1, v1, u2, v2;
mirror &= 1;
ninety &= 3;
if (!ninety && !mirror) {
rop_copy(rin, rout, x1, y1, x2, y2, newx, newy);
return;
}
u1 = x1;
v1 = y1;
u2 = x2;
v2 = y2;
su = u2 - u1;
sv = v2 - v1;
lu = u2 - u1 + 1;
lv = v2 - v1 + 1;
if (ninety & 1) {
lx = lv;
ly = lu;
} else {
lx = lu;
ly = lv;
}
bufin = rin->buffer;
wrapin = rin->wrap;
E 61 bufout = rout->buffer;
wrapout = rout->wrap;
dudy = 0;
dvdy = 0;
switch ((mirror << 2) + ninety) {
CASE(0 << 2) + 0 : u00 = u1;
v00 = v1;
dvdy = 1;
dindx = 1;
CASE(0 << 2) + 1 : u00 = u1;
v00 = v1 + sv;
dudy = 1;
dindx = -wrapin;
CASE(0 << 2) + 2 : u00 = u1 + su;
v00 = v1 + sv;
dvdy = -1;
dindx = -1;
CASE(0 << 2) + 3 : u00 = u1 + su;
v00 = v1;
dudy = -1;
dindx = wrapin;
CASE(1 << 2) + 0 : u00 = u1 + su;
v00 = v1;
dvdy = 1;
dindx = -1;
CASE(1 << 2) + 1 : u00 = u1 + su;
v00 = v1 + sv;
dudy = -1;
dindx = -wrapin;
CASE(1 << 2) + 2 : u00 = u1;
v00 = v1 + sv;
dvdy = -1;
dindx = 1;
CASE(1 << 2) + 3 : u00 = u1;
v00 = v1;
dudy = 1;
dindx = wrapin;
I 50
D 78 DEFAULT : assert(FALSE);
u00 = v00 = dudy = dindx = 0;
E 78
I 78 DEFAULT : abort();
u00 = v00 = dudy = dindx = 0;
E 78
E 50
}
for (u0 = u00, v0 = v00, y = newy; y < newy + ly;
u0 += dudy, v0 += dvdy, y++) {
bytein = bufin + u0 + v0 * wrapin;
pixout = bufout + newx + y * wrapout;
for (x = newx; x < newx + lx; x++) {
D 55 tmp.r = *bytein;
tmp.g = *bytein;
tmp.b = *bytein;
I 43 tmp.m = 0xff;
*pixout++ = tmp;
E 55
I 55
D 60 *pixout++ = ROP_RGB16_FROM_BYTES(*bytein, *bytein, *bytein);
E 60
I 60 *pixout++ = PIX_RGB16_FROM_BYTES(*bytein, *bytein, *bytein);
E 60
E 55 bytein += dindx;
}
}
}
/*---------------------------------------------------------------------------*/
D 55
static void rop_copy_90_rgb_rgbm(RASTER *rin, RASTER *rout,
E 55
I 55
D 56
static void rop_copy_90_gr8_rgbm(RASTER *rin, RASTER *rout,
E 55
int x1, int y1, int x2, int y2,
int newx, int newy,
int mirror, int ninety)
E 56
I 56
D 57
#ifdef DAFARE
E 57
static void rop_zoom_out_90_gr8_rgb16(RASTER *rin, RASTER *rout,
int x1, int y1, int x2, int y2,
int newx, int newy,
int abs_zoom_level,
int mirror, int ninety)
E 56
{
D 55 UCHAR *bufin, *bytein, *appo;
E 55
I 55
D 56 UCHAR *bufin, *bytein;
E 55 LPIXEL *bufout, *pixout, tmp;
E 56
I 56 UCHAR *bufin, *rowin, *pixin, *in;
int tmp;
USHORT *bufout, *rowout, *pixout;
E 56 int wrapin, wrapout;
D 57 int u, v, lu, lv, su, sv, u00, v00, u0, v0, dindx, dudy, dvdy;
int x, y, lx, ly;
E 57 int u1, v1, u2, v2;
I 56
D 57 int ulast, vlast, urest, vrest, i, j;
E 57
I 57 int u, v, lu, lv, startu, startv;
int p, q, lp, lq;
int dudp, dvdp, dudq, dvdq, dindp, dindq;
int plast, qlast, prest, qrest, i, j;
E 57 int factor, fac_fac_2_bits;
D 57 int fac_fac, vrest_fac, fac_urest, vrest_urest;
int fac_fac_2, vrest_fac_2, fac_urest_2, vrest_urest_2;
E 57
I 57 int fac_fac, qrest_fac, fac_prest, qrest_prest;
int fac_fac_2, qrest_fac_2, fac_prest_2, qrest_prest_2;
E 57 int fac_fac_4;
E 56
mirror &= 1;
ninety &= 3;
D 44 printf("mirror = %d ninety = %d\n", mirror, ninety);
E 44 if (!ninety && !mirror) {
D 56 rop_copy(rin, rout, x1, y1, x2, y2, newx, newy);
E 56
I 56
D 57 rop_zoom_out(rin, rout, x1, y1, x2, y2, newx, newy);
E 57
I 57 rop_zoom_out(rin, rout, x1, y1, x2, y2, newx, newy, abs_zoom_level);
E 57
E 56 return;
}
u1 = x1;
v1 = y1;
u2 = x2;
v2 = y2;
D 57 su = u2 - u1;
sv = v2 - v1;
E 57 lu = u2 - u1 + 1;
lv = v2 - v1 + 1;
if (ninety & 1) {
D 57 lx = lv;
ly = lu;
E 57
I 57 lp = lv;
lq = lu;
E 57
} else {
D 57 lx = lu;
ly = lv;
E 57
I 57 lp = lu;
lq = lv;
E 57
}
D 57
E 57
I 56 factor = 1 << abs_zoom_level;
D 57 urest = lu % factor;
vrest = lv % factor;
ulast = u2 - urest + 1;
vlast = v2 - vrest + 1;
E 57
I 57
D 61 prest = lp % factor;
qrest = lq % factor;
E 61
I 61 prest = lp & (factor - 1);
qrest = lq & (factor - 1);
E 61 plast = lp - prest;
qlast = lq - qrest;
E 57 fac_fac = factor * factor;
fac_fac_2 = fac_fac >> 1;
fac_fac_4 = fac_fac >> 2;
fac_fac_2_bits = 2 * abs_zoom_level - 1;
D 57 vrest_fac = vrest * factor;
vrest_fac_2 = vrest_fac >> 1;
fac_urest = factor * urest;
fac_urest_2 = fac_urest >> 1;
vrest_urest = vrest * urest;
vrest_urest_2 = vrest_urest >> 1;
E 57
I 57 qrest_fac = qrest * factor;
qrest_fac_2 = qrest_fac >> 1;
fac_prest = factor * prest;
fac_prest_2 = fac_prest >> 1;
qrest_prest = qrest * prest;
qrest_prest_2 = qrest_prest >> 1;
E 57
E 56 bufin = rin->buffer;
D 55 wrapin = rin->wrap * 3; /* mi muovo di bytes */
E 55
I 55 wrapin = rin->wrap;
E 55 bufout = rout->buffer;
wrapout = rout->wrap;
D 57 dudy = 0;
dvdy = 0;
E 57 switch ((mirror << 2) + ninety) {
D 55 CASE(0 << 2) + 0 : u00 = u1;
v00 = v1;
dvdy = 1;
dindx = 3;
E 55
I 55
D 57 CASE(0 << 2) + 0 : u00 = u1;
v00 = v1;
dvdy = 1;
dindx = 1;
E 55 CASE(0 << 2) + 1 : u00 = u1;
v00 = v1 + sv;
dudy = 1;
dindx = -wrapin;
D 55 CASE(0 << 2) + 2 : u00 = u1 + su;
v00 = v1 + sv;
dvdy = -1;
dindx = -3;
E 55
I 55 CASE(0 << 2) + 2 : u00 = u1 + su;
v00 = v1 + sv;
dvdy = -1;
dindx = -1;
E 55 CASE(0 << 2) + 3 : u00 = u1 + su;
v00 = v1;
dudy = -1;
dindx = wrapin;
D 55 CASE(1 << 2) + 0 : u00 = u1 + su;
v00 = v1;
dvdy = 1;
dindx = -3;
E 55
I 55 CASE(1 << 2) + 0 : u00 = u1 + su;
v00 = v1;
dvdy = 1;
dindx = -1;
E 55 CASE(1 << 2) + 1 : u00 = u1 + su;
v00 = v1 + sv;
dudy = -1;
dindx = -wrapin;
D 55 CASE(1 << 2) + 2 : u00 = u1;
v00 = v1 + sv;
dvdy = -1;
dindx = 3;
E 55
I 55 CASE(1 << 2) + 2 : u00 = u1;
v00 = v1 + sv;
dvdy = -1;
dindx = 1;
E 55 CASE(1 << 2) + 3 : u00 = u1;
v00 = v1;
dudy = 1;
dindx = wrapin;
I 50 DEFAULT : assert(FALSE);
u00 = v00 = dudy = dindx = 0;
E 50
}
for (u0 = u00, v0 = v00, y = newy; y < newy + ly;
u0 += dudy, v0 += dvdy, y++) {
D 55 bytein = bufin + u0 * 3 + v0 * wrapin;
E 55
I 55 bytein = bufin + u0 + v0 * wrapin;
E 55 pixout = bufout + newx + y * wrapout;
for (x = newx; x < newx + lx; x++) {
D 55 appo = bytein;
tmp.r = *appo++;
tmp.g = *appo++;
tmp.b = *appo;
E 55
I 55
D 56 tmp.r = *bytein;
tmp.g = *bytein;
tmp.b = *bytein;
E 55
E 43 tmp.m = 0xff;
*pixout++ = tmp;
E 56
I 56 *pixout++ = ROP_RGB16_FROM_BYTES(*bytein, *bytein, *bytein);
E 56 bytein += dindx;
}
E 57
I 57 CASE(0 << 2) + 0 : dudp = 1;
dvdp = 0;
dudq = 0;
dvdq = 1;
startu = u1;
startv = v1;
CASE(0 << 2) + 1 : dudp = 0;
dvdp = -1;
dudq = 1;
dvdq = 0;
startu = u1;
startv = v2;
CASE(0 << 2) + 2 : dudp = -1;
dvdp = 0;
dudq = 0;
dvdq = -1;
startu = u2;
startv = v2;
CASE(0 << 2) + 3 : dudp = 0;
dvdp = 1;
dudq = -1;
dvdq = 0;
startu = u2;
startv = v1;
CASE(1 << 2) + 0 : dudp = -1;
dvdp = 0;
dudq = 0;
dvdq = 1;
startu = u2;
startv = v1;
D 61 CASE(1 << 2) + 1 : dudp = 0;
dvdp = 1;
dudq = 1;
dvdq = 0;
startu = u2;
startv = v2;
E 61
I 61 CASE(1 << 2) + 1 : dudp = 0;
dvdp = -1;
dudq = -1;
dvdq = 0;
startu = u2;
startv = v2;
E 61 CASE(1 << 2) + 2 : dudp = 1;
dvdp = 0;
dudq = 0;
dvdq = -1;
startu = u1;
startv = v2;
D 61 CASE(1 << 2) + 3 : dudp = 0;
dvdp = -1;
dudq = -1;
dvdq = 0;
startu = u1;
startv = v1;
E 61
I 61 CASE(1 << 2) + 3 : dudp = 0;
dvdp = 1;
dudq = 1;
dvdq = 0;
startu = u1;
startv = v1;
E 61 DEFAULT :
D 78 assert(FALSE);
dudp = dvdp = dudq = dvdq = startu = startv = 0;
E 78
I 78 abort();
dudp = dvdp = dudq = dvdq = startu = startv = 0;
E 78
E 57
}
I 57 dindp = dudp + wrapin * dvdp;
dindq = dudq + wrapin * dvdq;
E 57
D 56
}
/*---------------------------------------------------------------------------*/
E 22
E 21
D 55
static void rop_copy_90_bw_gr8(RASTER *rin, RASTER *rout,
int x1, int y1, int x2, int y2,
int newx, int newy,
int mirror, int ninety)
E 55
I 55
static void rop_copy_90_rgb_rgbm(RASTER *rin, RASTER *rout,
int x1, int y1, int x2, int y2,
int newx, int newy,
int mirror, int ninety)
E 55
{
D 55 UCHAR *bufin, *bufout, *bytein, *byteout;
int bytewrapin, bitoffsin, wrapout;
int value_for_0, value_for_1;
int u, v, lu, lv, su, sv, u00, v00, u0, v0, dudy, dvdy, dudx, dvdx;
E 55
I 55 UCHAR *bufin, *bytein, *appo;
LPIXEL *bufout, *pixout, tmp;
int wrapin, wrapout;
int u, v, lu, lv, su, sv, u00, v00, u0, v0, dindx, dudy, dvdy;
E 55 int x, y, lx, ly;
int u1, v1, u2, v2;
D 55
#ifdef DEBUG
STW_INIT(0, "rop_copy_90_bw_gr8") STW_START(0)
#endif
E 55 mirror &= 1;
D 55 ninety &= 3;
if (!ninety && !mirror) {
rop_copy(rin, rout, x1, y1, x2, y2, newx, newy);
return;
E 55
I 55 ninety &= 3;
if (!ninety && !mirror) {
rop_copy(rin, rout, x1, y1, x2, y2, newx, newy);
return;
}
E 56
D 56 u1 = x1;
v1 = y1;
u2 = x2;
v2 = y2;
su = u2 - u1;
sv = v2 - v1;
lu = u2 - u1 + 1;
lv = v2 - v1 + 1;
if (ninety & 1) {
lx = lv;
ly = lu;
} else {
lx = lu;
ly = lv;
}
bufin = rin->buffer;
wrapin = rin->wrap * 3; /* mi muovo di bytes */
bufout = rout->buffer;
wrapout = rout->wrap;
dudy = 0;
dvdy = 0;
switch ((mirror << 2) + ninety)
E 56
I 56
D 57 rowin = (UCHAR *)rin->buffer + wrapin * v1 + u1;
rowout = (USHORT *)rout->buffer + wrapout * newy + newx;
for (v = v1; v < vlast; v += factor)
E 57
I 57 rowin = (UCHAR *)rin->buffer + startu + startv * wrapin;
rowout = (USHORT *)rout->buffer + newx + newy * wrapout;
for (q = 0; q < qlast; q += factor)
E 57
E 56 {
D 56 CASE(0 << 2) + 0 : u00 = u1;
v00 = v1;
dvdy = 1;
dindx = 3;
CASE(0 << 2) + 1 : u00 = u1;
v00 = v1 + sv;
dudy = 1;
dindx = -wrapin;
CASE(0 << 2) + 2 : u00 = u1 + su;
v00 = v1 + sv;
dvdy = -1;
dindx = -3;
CASE(0 << 2) + 3 : u00 = u1 + su;
v00 = v1;
dudy = -1;
dindx = wrapin;
CASE(1 << 2) + 0 : u00 = u1 + su;
v00 = v1;
dvdy = 1;
dindx = -3;
CASE(1 << 2) + 1 : u00 = u1 + su;
v00 = v1 + sv;
dudy = -1;
dindx = -wrapin;
CASE(1 << 2) + 2 : u00 = u1;
v00 = v1 + sv;
dvdy = -1;
dindx = 3;
CASE(1 << 2) + 3 : u00 = u1;
v00 = v1;
dudy = 1;
dindx = wrapin;
DEFAULT:
assert(FALSE);
u00 = v00 = dudy = dindx = 0;
E 56
I 56 pixin = rowin;
pixout = rowout;
D 57 for (u = u1; u < ulast; u += factor)
E 57
I 57
D 58 for (p = 0; p < plast; p += factor)
E 57 {
tmp = 0;
in = pixin;
for (j = 0; j < factor; j += 2) {
for (i = 0; i < factor; i += 2) {
tmp += *in;
D 57 in += wrapin;
in++;
E 57
I 57 in += dindp + dindq;
E 57 tmp += *in;
D 57 in -= wrapin;
in++;
E 57
I 57 in += dindp - dindq;
E 57
}
D 57 in += 2 * wrapin - factor;
E 57
I 57 in += 2 * dindq - factor * dindp;
E 57
}
tmp = (tmp + fac_fac_4) >> fac_fac_2_bits;
*pixout++ = ROP_RGB16_FROM_BYTES(tmp, tmp, tmp);
D 57 pixin += factor;
E 57
I 57 pixin += factor * dindp;
E 57
}
D 57 if (urest)
E 57
I 57 if (prest)
E 57 {
tmp = 0;
for (j = 0; j < factor; j++)
D 57 for (i = 0; i < urest; i++)
E 57
I 57 for (i = 0; i < prest; i++)
E 57 {
D 57 tmp += pixin[i + j * wrapin];
E 57
I 57 tmp += pixin[i * dindp + j * dindq];
E 57
}
D 57 tmp = (tmp + fac_urest_2) / fac_urest;
E 57
I 57 tmp = (tmp + fac_prest_2) / fac_prest;
E 57 *pixout = ROP_RGB16_FROM_BYTES(tmp, tmp, tmp);
}
D 57 rowin += wrapin * factor;
E 57
I 57 rowin += factor * dindq;
E 57 rowout += wrapout;
E 56
}
D 56
for (u0 = u00, v0 = v00, y = newy; y < newy + ly;
u0 += dudy, v0 += dvdy, y++)
E 56
I 56
D 57 if (vrest)
E 57
I 57 if (qrest)
E 57
E 56 {
D 56 bytein = bufin + u0 * 3 + v0 * wrapin;
pixout = bufout + newx + y * wrapout;
for (x = newx; x < newx + lx; x++)
E 56
I 56 pixin = rowin;
pixout = rowout;
D 57 for (u = u1; u < ulast; u += factor)
E 57
I 57 for (p = 0; p < plast; p += factor)
E 57
E 56 {
D 56 appo = bytein;
tmp.r = *appo++;
tmp.g = *appo++;
tmp.b = *appo;
tmp.m = 0xff;
*pixout++ = tmp;
bytein += dindx;
E 56
I 56 tmp = 0;
D 57 for (j = 0; j < vrest; j++)
E 57
I 57 for (j = 0; j < qrest; j++)
E 57 for (i = 0; i < factor; i++) {
D 57 tmp += pixin[i + j * wrapin];
E 57
I 57 tmp += pixin[i * dindp + j * dindq];
E 57
}
D 57 tmp = (tmp + vrest_fac_2) / vrest_fac;
E 57
I 57 tmp = (tmp + qrest_fac_2) / qrest_fac;
E 57 *pixout++ = ROP_RGB16_FROM_BYTES(tmp, tmp, tmp);
D 57 pixin += factor;
E 57
I 57 pixin += factor * dindp;
E 57
}
D 57 if (urest)
E 57
I 57 if (prest)
E 57 {
tmp = 0;
D 57 for (j = 0; j < vrest; j++) for (i = 0; i < urest; i++)
E 57
I 57 for (j = 0; j < qrest; j++) for (i = 0; i < prest; i++)
E 57 {
D 57 tmp += pixin[i + j * wrapin];
E 57
I 57 tmp += pixin[i * dindp + j * dindq];
E 57
}
D 57 tmp = (tmp + vrest_urest_2) / vrest_urest;
E 57
I 57 tmp = (tmp + qrest_prest_2) / qrest_prest;
E 57 *pixout = ROP_RGB16_FROM_BYTES(tmp, tmp, tmp);
E 56
}
}
D 56
}
E 56
D 57
E 57
D 56
/*---------------------------------------------------------------------------*/
E 56
I 56
}
E 56
D 56
static void rop_copy_90_bw_gr8(RASTER *rin, RASTER *rout,
int x1, int y1, int x2, int y2,
E 56
I 56
D 57
#endif
E 57
/*---------------------------------------------------------------------------*/
static void rop_copy_90_gr8_rgbm(RASTER *rin, RASTER *rout,
int x1, int y1, int x2, int y2,
int newx, int newy,
int mirror, int ninety)
{
UCHAR *bufin, *bytein;
LPIXEL *bufout, *pixout, tmp;
int wrapin, wrapout;
int u, v, lu, lv, su, sv, u00, v00, u0, v0, dindx, dudy, dvdy;
int x, y, lx, ly;
int u1, v1, u2, v2;
mirror &= 1;
ninety &= 3;
if (!ninety && !mirror) {
rop_copy(rin, rout, x1, y1, x2, y2, newx, newy);
return;
}
u1 = x1;
v1 = y1;
u2 = x2;
v2 = y2;
su = u2 - u1;
sv = v2 - v1;
lu = u2 - u1 + 1;
lv = v2 - v1 + 1;
if (ninety & 1) {
lx = lv;
ly = lu;
} else {
lx = lu;
ly = lv;
}
bufin = rin->buffer;
wrapin = rin->wrap;
bufout = rout->buffer;
wrapout = rout->wrap;
dudy = 0;
dvdy = 0;
switch ((mirror << 2) + ninety) {
CASE(0 << 2) + 0 : u00 = u1;
v00 = v1;
dvdy = 1;
dindx = 1;
CASE(0 << 2) + 1 : u00 = u1;
v00 = v1 + sv;
dudy = 1;
dindx = -wrapin;
CASE(0 << 2) + 2 : u00 = u1 + su;
v00 = v1 + sv;
dvdy = -1;
dindx = -1;
CASE(0 << 2) + 3 : u00 = u1 + su;
v00 = v1;
dudy = -1;
dindx = wrapin;
CASE(1 << 2) + 0 : u00 = u1 + su;
v00 = v1;
dvdy = 1;
dindx = -1;
CASE(1 << 2) + 1 : u00 = u1 + su;
v00 = v1 + sv;
dudy = -1;
dindx = -wrapin;
E 58
I 58 for (p = 0; p < plast; p += factor) {
tmp = 0;
in = pixin;
for (j = 0; j < factor; j += 2) {
for (i = 0; i < factor; i += 2) {
tmp += *in;
in += dindp + dindq;
tmp += *in;
in += dindp - dindq;
}
in += 2 * dindq - factor * dindp;
}
tmp = (tmp + fac_fac_4) >> fac_fac_2_bits;
D 60 *pixout++ = ROP_RGB16_FROM_BYTES(tmp, tmp, tmp);
E 60
I 60 *pixout++ = PIX_RGB16_FROM_BYTES(tmp, tmp, tmp);
E 60 pixin += factor * dindp;
}
if (prest) {
tmp = 0;
for (j = 0; j < factor; j++)
for (i = 0; i < prest; i++) {
tmp += pixin[i * dindp + j * dindq];
}
tmp = (tmp + fac_prest_2) / fac_prest;
D 60 *pixout = ROP_RGB16_FROM_BYTES(tmp, tmp, tmp);
E 60
I 60 *pixout = PIX_RGB16_FROM_BYTES(tmp, tmp, tmp);
E 60
}
rowin += factor * dindq;
rowout += wrapout;
}
D 59 if (qrest)
E 59
I 59 if (qrest)
E 59 {
pixin = rowin;
pixout = rowout;
for (p = 0; p < plast; p += factor) {
tmp = 0;
for (j = 0; j < qrest; j++)
for (i = 0; i < factor; i++) {
tmp += pixin[i * dindp + j * dindq];
}
tmp = (tmp + qrest_fac_2) / qrest_fac;
D 60 *pixout++ = ROP_RGB16_FROM_BYTES(tmp, tmp, tmp);
E 60
I 60 *pixout++ = PIX_RGB16_FROM_BYTES(tmp, tmp, tmp);
E 60 pixin += factor * dindp;
}
if (prest) {
tmp = 0;
for (j = 0; j < qrest; j++)
for (i = 0; i < prest; i++) {
tmp += pixin[i * dindp + j * dindq];
}
tmp = (tmp + qrest_prest_2) / qrest_prest;
D 60 *pixout = ROP_RGB16_FROM_BYTES(tmp, tmp, tmp);
E 60
I 60 *pixout = PIX_RGB16_FROM_BYTES(tmp, tmp, tmp);
E 60
}
}
}
/*---------------------------------------------------------------------------*/
static void rop_copy_90_gr8_rgbm(RASTER *rin, RASTER *rout,
int x1, int y1, int x2, int y2,
int newx, int newy,
int mirror, int ninety)
{
UCHAR *bufin, *bytein;
LPIXEL *bufout, *pixout, tmp;
int wrapin, wrapout;
int u, v, lu, lv, su, sv, u00, v00, u0, v0, dindx, dudy, dvdy;
int x, y, lx, ly;
int u1, v1, u2, v2;
mirror &= 1;
ninety &= 3;
if (!ninety && !mirror) {
rop_copy(rin, rout, x1, y1, x2, y2, newx, newy);
return;
}
u1 = x1;
v1 = y1;
u2 = x2;
v2 = y2;
su = u2 - u1;
sv = v2 - v1;
lu = u2 - u1 + 1;
lv = v2 - v1 + 1;
if (ninety & 1) {
lx = lv;
ly = lu;
}
D 65 else {
lx = lu;
ly = lv;
}
bufin = rin->buffer;
wrapin = rin->wrap;
bufout = rout->buffer;
wrapout = rout->wrap;
dudy = 0;
dvdy = 0;
switch ((mirror << 2) + ninety) {
E 65
I 65 else {
lx = lu;
ly = lv;
}
bufin = rin->buffer;
wrapin = rin->wrap;
bufout = rout->buffer;
wrapout = rout->wrap;
dudy = 0;
dvdy = 0;
switch ((mirror << 2) + ninety) {
E 65 CASE(0 << 2) + 0 : u00 = u1;
v00 = v1;
dvdy = 1;
dindx = 1;
CASE(0 << 2) + 1 : u00 = u1;
v00 = v1 + sv;
dudy = 1;
dindx = -wrapin;
CASE(0 << 2) + 2 : u00 = u1 + su;
v00 = v1 + sv;
dvdy = -1;
dindx = -1;
CASE(0 << 2) + 3 : u00 = u1 + su;
v00 = v1;
dudy = -1;
dindx = wrapin;
CASE(1 << 2) + 0 : u00 = u1 + su;
v00 = v1;
dvdy = 1;
dindx = -1;
CASE(1 << 2) + 1 : u00 = u1 + su;
v00 = v1 + sv;
dudy = -1;
dindx = -wrapin;
E 58 CASE(1 << 2) + 2 : u00 = u1;
v00 = v1 + sv;
dvdy = -1;
dindx = 1;
CASE(1 << 2) + 3 : u00 = u1;
v00 = v1;
dudy = 1;
dindx = wrapin;
D 78 DEFAULT : assert(FALSE);
u00 = v00 = dudy = dindx = 0;
E 78
I 78 DEFAULT : abort();
u00 = v00 = dudy = dindx = 0;
E 78
}
for (u0 = u00, v0 = v00, y = newy; y < newy + ly;
u0 += dudy, v0 += dvdy, y++) {
bytein = bufin + u0 + v0 * wrapin;
pixout = bufout + newx + y * wrapout;
for (x = newx; x < newx + lx; x++) {
tmp.r = *bytein;
tmp.g = *bytein;
tmp.b = *bytein;
tmp.m = 0xff;
*pixout++ = tmp;
bytein += dindx;
}
}
}
/*---------------------------------------------------------------------------*/
I 57 static void rop_zoom_out_90_gr8_rgbm(
RASTER * rin, RASTER * rout, int x1, int y1, int x2, int y2, int newx,
int newy, int abs_zoom_level, int mirror, int ninety) {
UCHAR *bufin, *rowin, *pixin, *in;
int tmp;
LPIXEL *bufout, *rowout, *pixout, valout;
int wrapin, wrapout;
int u1, v1, u2, v2;
int u, v, lu, lv, startu, startv;
int p, q, lp, lq;
int dudp, dvdp, dudq, dvdq, dindp, dindq;
int plast, qlast, prest, qrest, i, j;
int factor, fac_fac_2_bits;
int fac_fac, qrest_fac, fac_prest, qrest_prest;
int fac_fac_2, qrest_fac_2, fac_prest_2, qrest_prest_2;
int fac_fac_4;
mirror &= 1;
ninety &= 3;
if (!ninety && !mirror) {
rop_zoom_out(rin, rout, x1, y1, x2, y2, newx, newy, abs_zoom_level);
return;
}
u1 = x1;
v1 = y1;
u2 = x2;
v2 = y2;
lu = u2 - u1 + 1;
lv = v2 - v1 + 1;
if (ninety & 1) {
lp = lv;
lq = lu;
} else {
lp = lu;
lq = lv;
}
factor = 1 << abs_zoom_level;
D 61 prest = lp % factor;
qrest = lq % factor;
E 61
I 61 prest = lp & (factor - 1);
qrest = lq & (factor - 1);
E 61 plast = lp - prest;
qlast = lq - qrest;
fac_fac = factor * factor;
fac_fac_2 = fac_fac >> 1;
fac_fac_4 = fac_fac >> 2;
fac_fac_2_bits = 2 * abs_zoom_level - 1;
qrest_fac = qrest * factor;
qrest_fac_2 = qrest_fac >> 1;
fac_prest = factor * prest;
fac_prest_2 = fac_prest >> 1;
qrest_prest = qrest * prest;
qrest_prest_2 = qrest_prest >> 1;
bufin = rin->buffer;
wrapin = rin->wrap;
bufout = rout->buffer;
wrapout = rout->wrap;
switch ((mirror << 2) + ninety) {
CASE(0 << 2) + 0 : dudp = 1;
dvdp = 0;
dudq = 0;
dvdq = 1;
startu = u1;
startv = v1;
CASE(0 << 2) + 1 : dudp = 0;
dvdp = -1;
dudq = 1;
dvdq = 0;
startu = u1;
startv = v2;
CASE(0 << 2) + 2 : dudp = -1;
dvdp = 0;
dudq = 0;
dvdq = -1;
startu = u2;
startv = v2;
CASE(0 << 2) + 3 : dudp = 0;
dvdp = 1;
dudq = -1;
dvdq = 0;
startu = u2;
startv = v1;
CASE(1 << 2) + 0 : dudp = -1;
dvdp = 0;
dudq = 0;
dvdq = 1;
startu = u2;
startv = v1;
D 61 CASE(1 << 2) + 1 : dudp = 0;
dvdp = 1;
dudq = 1;
dvdq = 0;
startu = u2;
startv = v2;
E 61
I 61 CASE(1 << 2) + 1 : dudp = 0;
dvdp = -1;
dudq = -1;
dvdq = 0;
startu = u2;
startv = v2;
E 61 CASE(1 << 2) + 2 : dudp = 1;
dvdp = 0;
dudq = 0;
dvdq = -1;
startu = u1;
startv = v2;
D 61 CASE(1 << 2) + 3 : dudp = 0;
dvdp = -1;
dudq = -1;
dvdq = 0;
startu = u1;
startv = v1;
E 61
I 61 CASE(1 << 2) + 3 : dudp = 0;
dvdp = 1;
dudq = 1;
dvdq = 0;
startu = u1;
startv = v1;
E 61 DEFAULT :
D 78 assert(FALSE);
dudp = dvdp = dudq = dvdq = startu = startv = 0;
E 78
I 78 abort();
dudp = dvdp = dudq = dvdq = startu = startv = 0;
E 78
}
dindp = dudp + wrapin * dvdp;
dindq = dudq + wrapin * dvdq;
rowin = (UCHAR *)rin->buffer + startu + startv * wrapin;
rowout = (LPIXEL *)rout->buffer + newx + newy * wrapout;
valout.m = 0xff;
for (q = 0; q < qlast; q += factor) {
pixin = rowin;
pixout = rowout;
for (p = 0; p < plast; p += factor) {
tmp = 0;
in = pixin;
for (j = 0; j < factor; j += 2) {
for (i = 0; i < factor; i += 2) {
tmp += *in;
in += dindp + dindq;
tmp += *in;
in += dindp - dindq;
}
in += 2 * dindq - factor * dindp;
}
tmp = (tmp + fac_fac_4) >> fac_fac_2_bits;
valout.r = valout.g = valout.b = tmp;
*pixout++ = valout;
pixin += factor * dindp;
}
if (prest) {
tmp = 0;
for (j = 0; j < factor; j++)
for (i = 0; i < prest; i++) {
tmp += pixin[i * dindp + j * dindq];
}
tmp = (tmp + fac_prest_2) / fac_prest;
valout.r = valout.g = valout.b = tmp;
*pixout++ = valout;
}
rowin += factor * dindq;
rowout += wrapout;
}
if (qrest) {
pixin = rowin;
pixout = rowout;
for (p = 0; p < plast; p += factor) {
tmp = 0;
for (j = 0; j < qrest; j++)
for (i = 0; i < factor; i++) {
tmp += pixin[i * dindp + j * dindq];
}
tmp = (tmp + qrest_fac_2) / qrest_fac;
valout.r = valout.g = valout.b = tmp;
*pixout++ = valout;
pixin += factor * dindp;
}
if (prest) {
tmp = 0;
for (j = 0; j < qrest; j++)
for (i = 0; i < prest; i++) {
tmp += pixin[i * dindp + j * dindq];
}
tmp = (tmp + qrest_prest_2) / qrest_prest;
valout.r = valout.g = valout.b = tmp;
*pixout++ = valout;
}
}
}
/*---------------------------------------------------------------------------*/
I 63 static void rop_copy_90_rgb_rgb16(RASTER * rin, RASTER * rout, int x1,
int y1, int x2, int y2, int newx,
int newy, int mirror, int ninety) {
UCHAR *bufin, *bytein;
USHORT *bufout, *pixout;
int wrapin, wrapout;
int u, v, lu, lv, su, sv, u00, v00, u0, v0, dindx, dudy, dvdy;
int x, y, lx, ly;
int u1, v1, u2, v2;
mirror &= 1;
ninety &= 3;
if (!ninety && !mirror) {
rop_copy(rin, rout, x1, y1, x2, y2, newx, newy);
return;
}
u1 = x1;
v1 = y1;
u2 = x2;
v2 = y2;
su = u2 - u1;
sv = v2 - v1;
lu = u2 - u1 + 1;
lv = v2 - v1 + 1;
if (ninety & 1) {
lx = lv;
ly = lu;
} else {
lx = lu;
ly = lv;
}
bufin = rin->buffer;
wrapin = rin->wrap * 3; /* mi muovo di bytes */
bufout = rout->buffer;
wrapout = rout->wrap;
dudy = 0;
dvdy = 0;
switch ((mirror << 2) + ninety) {
CASE(0 << 2) + 0 : u00 = u1;
v00 = v1;
dvdy = 1;
dindx = 3;
D 81 CASE(0 << 2) + 1 : u00 = u1;
v00 = v1 + sv;
dudy = 1;
dindx = -wrapin;
CASE(0 << 2) + 2 : u00 = u1 + su;
v00 = v1 + sv;
dvdy = -1;
dindx = -3;
CASE(0 << 2) + 3 : u00 = u1 + su;
v00 = v1;
dudy = -1;
dindx = wrapin;
CASE(1 << 2) + 0 : u00 = u1 + su;
v00 = v1;
dvdy = 1;
dindx = -3;
CASE(1 << 2) + 1 : u00 = u1 + su;
v00 = v1 + sv;
dudy = -1;
dindx = -wrapin;
CASE(1 << 2) + 2 : u00 = u1;
v00 = v1 + sv;
dvdy = -1;
dindx = 3;
CASE(1 << 2) + 3 : u00 = u1;
v00 = v1;
dudy = 1;
dindx = wrapin;
D 78 DEFAULT : assert(FALSE);
u00 = v00 = dudy = dindx = 0;
E 78
I 78 DEFAULT : abort();
u00 = v00 = dudy = dindx = 0;
E 78
}
for (u0 = u00, v0 = v00, y = newy; y < newy + ly;
u0 += dudy, v0 += dvdy, y++) {
bytein = bufin + u0 * 3 + v0 * wrapin;
pixout = bufout + newx + y * wrapout;
for (x = newx; x < newx + lx; x++) {
*pixout++ = PIX_RGB16_FROM_BYTES(bytein[0], bytein[1], bytein[2]);
bytein += dindx;
}
}
}
/*---------------------------------------------------------------------------*/
static void rop_zoom_out_90_rgb_rgb16(
RASTER * rin, RASTER * rout, int x1, int y1, int x2, int y2, int newx,
int newy, int abs_zoom_level, int mirror, int ninety) {
UCHAR *bufin, *rowin, *pixin, *in;
int tmp_r, tmp_g, tmp_b;
USHORT *bufout, *rowout, *pixout;
int wrapin_bytes, wrapin_pixels, wrapout;
int u1, v1, u2, v2;
int u, v, lu, lv, startu, startv;
int p, q, lp, lq;
int dudp, dvdp, dudq, dvdq, dindp, dindq;
int plast, qlast, prest, qrest, i, j;
int factor, fac_fac_2_bits;
int fac_fac, qrest_fac, fac_prest, qrest_prest;
int fac_fac_2, qrest_fac_2, fac_prest_2, qrest_prest_2;
int fac_fac_4;
mirror &= 1;
ninety &= 3;
if (!ninety && !mirror) {
rop_zoom_out(rin, rout, x1, y1, x2, y2, newx, newy, abs_zoom_level);
return;
}
u1 = x1;
v1 = y1;
u2 = x2;
v2 = y2;
lu = u2 - u1 + 1;
lv = v2 - v1 + 1;
if (ninety & 1) {
lp = lv;
lq = lu;
} else {
lp = lu;
lq = lv;
}
factor = 1 << abs_zoom_level;
prest = lp & (factor - 1);
qrest = lq & (factor - 1);
plast = lp - prest;
qlast = lq - qrest;
fac_fac = factor * factor;
fac_fac_2 = fac_fac >> 1;
fac_fac_4 = fac_fac >> 2;
fac_fac_2_bits = 2 * abs_zoom_level - 1;
qrest_fac = qrest * factor;
qrest_fac_2 = qrest_fac >> 1;
fac_prest = factor * prest;
fac_prest_2 = fac_prest >> 1;
qrest_prest = qrest * prest;
qrest_prest_2 = qrest_prest >> 1;
bufin = rin->buffer;
wrapin_pixels = rin->wrap;
wrapin_bytes = wrapin_pixels * 3;
bufout = rout->buffer;
wrapout = rout->wrap;
switch ((mirror << 2) + ninety) {
CASE(0 << 2) + 0 : dudp = 1;
dvdp = 0;
dudq = 0;
dvdq = 1;
startu = u1;
startv = v1;
CASE(0 << 2) + 1 : dudp = 0;
dvdp = -1;
dudq = 1;
dvdq = 0;
startu = u1;
startv = v2;
CASE(0 << 2) + 2 : dudp = -1;
dvdp = 0;
dudq = 0;
dvdq = -1;
startu = u2;
startv = v2;
CASE(0 << 2) + 3 : dudp = 0;
dvdp = 1;
dudq = -1;
dvdq = 0;
startu = u2;
startv = v1;
CASE(1 << 2) + 0 : dudp = -1;
dvdp = 0;
dudq = 0;
dvdq = 1;
startu = u2;
startv = v1;
CASE(1 << 2) + 1 : dudp = 0;
dvdp = -1;
dudq = -1;
dvdq = 0;
startu = u2;
startv = v2;
CASE(1 << 2) + 2 : dudp = 1;
dvdp = 0;
dudq = 0;
dvdq = -1;
startu = u1;
startv = v2;
CASE(1 << 2) + 3 : dudp = 0;
dvdp = 1;
dudq = 1;
dvdq = 0;
startu = u1;
startv = v1;
DEFAULT:
D 78 assert(FALSE);
dudp = dvdp = dudq = dvdq = startu = startv = 0;
E 78
I 78 abort();
dudp = dvdp = dudq = dvdq = startu = startv = 0;
E 78
}
dindp = (dudp + wrapin_pixels * dvdp) * 3;
dindq = (dudq + wrapin_pixels * dvdq) * 3;
rowin = (UCHAR *)rin->buffer + startu * 3 + startv * wrapin_bytes;
rowout = (USHORT *)rout->buffer + newx + newy * wrapout;
for (q = 0; q < qlast; q += factor) {
pixin = rowin;
pixout = rowout;
for (p = 0; p < plast; p += factor) {
tmp_r = tmp_g = tmp_b = 0;
in = pixin;
for (j = 0; j < factor; j += 2) {
for (i = 0; i < factor; i += 2) {
tmp_r += in[0];
tmp_g += in[1];
tmp_b += in[2];
in += dindp + dindq;
tmp_r += in[0];
tmp_g += in[1];
tmp_b += in[2];
in += dindp - dindq;
}
in += 2 * dindq - factor * dindp;
}
tmp_r = (tmp_r + fac_fac_4) >> fac_fac_2_bits;
tmp_g = (tmp_g + fac_fac_4) >> fac_fac_2_bits;
tmp_b = (tmp_b + fac_fac_4) >> fac_fac_2_bits;
*pixout++ = PIX_RGB16_FROM_BYTES(tmp_r, tmp_g, tmp_b);
pixin += factor * dindp;
}
if (prest) {
tmp_r = tmp_g = tmp_b = 0;
for (j = 0; j < factor; j++)
for (i = 0; i < prest; i++) {
tmp_r += pixin[i * dindp + j * dindq];
tmp_g += pixin[i * dindp + j * dindq + 1];
tmp_b += pixin[i * dindp + j * dindq + 2];
}
tmp_r = (tmp_r + fac_prest_2) / fac_prest;
tmp_g = (tmp_g + fac_prest_2) / fac_prest;
tmp_b = (tmp_b + fac_prest_2) / fac_prest;
*pixout++ = PIX_RGB16_FROM_BYTES(tmp_r, tmp_g, tmp_b);
}
rowin += factor * dindq;
rowout += wrapout;
}
if (qrest) {
pixin = rowin;
pixout = rowout;
for (p = 0; p < plast; p += factor) {
tmp_r = tmp_g = tmp_b = 0;
for (j = 0; j < qrest; j++)
for (i = 0; i < factor; i++) {
E 81
I 81 CASE(0 << 2) + 1 : u00 = u1;
v00 = v1 + sv;
dudy = 1;
dindx = -wrapin;
CASE(0 << 2) + 2 : u00 = u1 + su;
v00 = v1 + sv;
dvdy = -1;
dindx = -3;
CASE(0 << 2) + 3 : u00 = u1 + su;
v00 = v1;
dudy = -1;
dindx = wrapin;
CASE(1 << 2) + 0 : u00 = u1 + su;
v00 = v1;
dvdy = 1;
dindx = -3;
CASE(1 << 2) + 1 : u00 = u1 + su;
v00 = v1 + sv;
dudy = -1;
dindx = -wrapin;
CASE(1 << 2) + 2 : u00 = u1;
v00 = v1 + sv;
dvdy = -1;
dindx = 3;
CASE(1 << 2) + 3 : u00 = u1;
v00 = v1;
dudy = 1;
dindx = wrapin;
DEFAULT:
abort();
u00 = v00 = dudy = dindx = 0;
}
for (u0 = u00, v0 = v00, y = newy; y < newy + ly;
u0 += dudy, v0 += dvdy, y++) {
bytein = bufin + u0 * 3 + v0 * wrapin;
pixout = bufout + newx + y * wrapout;
for (x = newx; x < newx + lx; x++) {
*pixout++ = PIX_RGB16_FROM_BYTES(bytein[0], bytein[1], bytein[2]);
bytein += dindx;
}
}
}
/*---------------------------------------------------------------------------*/
static void rop_zoom_out_90_rgb_rgb16(
RASTER * rin, RASTER * rout, int x1, int y1, int x2, int y2, int newx,
int newy, int abs_zoom_level, int mirror, int ninety) {
UCHAR *bufin, *rowin, *pixin, *in;
int tmp_r, tmp_g, tmp_b;
USHORT *bufout, *rowout, *pixout;
int wrapin_bytes, wrapin_pixels, wrapout;
int u1, v1, u2, v2;
int u, v, lu, lv, startu, startv;
int p, q, lp, lq;
int dudp, dvdp, dudq, dvdq, dindp, dindq;
int plast, qlast, prest, qrest, i, j;
int factor, fac_fac_2_bits;
int fac_fac, qrest_fac, fac_prest, qrest_prest;
int fac_fac_2, qrest_fac_2, fac_prest_2, qrest_prest_2;
int fac_fac_4;
mirror &= 1;
ninety &= 3;
if (!ninety && !mirror) {
rop_zoom_out(rin, rout, x1, y1, x2, y2, newx, newy, abs_zoom_level);
return;
}
u1 = x1;
v1 = y1;
u2 = x2;
v2 = y2;
lu = u2 - u1 + 1;
lv = v2 - v1 + 1;
if (ninety & 1) {
lp = lv;
lq = lu;
} else {
lp = lu;
lq = lv;
}
factor = 1 << abs_zoom_level;
prest = lp & (factor - 1);
qrest = lq & (factor - 1);
plast = lp - prest;
qlast = lq - qrest;
fac_fac = factor * factor;
fac_fac_2 = fac_fac >> 1;
fac_fac_4 = fac_fac >> 2;
fac_fac_2_bits = 2 * abs_zoom_level - 1;
qrest_fac = qrest * factor;
qrest_fac_2 = qrest_fac >> 1;
fac_prest = factor * prest;
fac_prest_2 = fac_prest >> 1;
qrest_prest = qrest * prest;
qrest_prest_2 = qrest_prest >> 1;
bufin = rin->buffer;
wrapin_pixels = rin->wrap;
wrapin_bytes = wrapin_pixels * 3;
bufout = rout->buffer;
wrapout = rout->wrap;
switch ((mirror << 2) + ninety) {
CASE(0 << 2) + 0 : dudp = 1;
dvdp = 0;
dudq = 0;
dvdq = 1;
startu = u1;
startv = v1;
CASE(0 << 2) + 1 : dudp = 0;
dvdp = -1;
dudq = 1;
dvdq = 0;
startu = u1;
startv = v2;
CASE(0 << 2) + 2 : dudp = -1;
dvdp = 0;
dudq = 0;
dvdq = -1;
startu = u2;
startv = v2;
CASE(0 << 2) + 3 : dudp = 0;
dvdp = 1;
dudq = -1;
dvdq = 0;
startu = u2;
startv = v1;
CASE(1 << 2) + 0 : dudp = -1;
dvdp = 0;
dudq = 0;
dvdq = 1;
startu = u2;
startv = v1;
CASE(1 << 2) + 1 : dudp = 0;
dvdp = -1;
dudq = -1;
dvdq = 0;
startu = u2;
startv = v2;
CASE(1 << 2) + 2 : dudp = 1;
dvdp = 0;
dudq = 0;
dvdq = -1;
startu = u1;
startv = v2;
CASE(1 << 2) + 3 : dudp = 0;
dvdp = 1;
dudq = 1;
dvdq = 0;
startu = u1;
startv = v1;
DEFAULT:
abort();
dudp = dvdp = dudq = dvdq = startu = startv = 0;
}
dindp = (dudp + wrapin_pixels * dvdp) * 3;
dindq = (dudq + wrapin_pixels * dvdq) * 3;
rowin = (UCHAR *)rin->buffer + startu * 3 + startv * wrapin_bytes;
rowout = (USHORT *)rout->buffer + newx + newy * wrapout;
for (q = 0; q < qlast; q += factor) {
pixin = rowin;
pixout = rowout;
for (p = 0; p < plast; p += factor) {
tmp_r = tmp_g = tmp_b = 0;
in = pixin;
for (j = 0; j < factor; j += 2) {
for (i = 0; i < factor; i += 2) {
tmp_r += in[0];
tmp_g += in[1];
tmp_b += in[2];
in += dindp + dindq;
tmp_r += in[0];
tmp_g += in[1];
tmp_b += in[2];
in += dindp - dindq;
}
in += 2 * dindq - factor * dindp;
}
tmp_r = (tmp_r + fac_fac_4) >> fac_fac_2_bits;
tmp_g = (tmp_g + fac_fac_4) >> fac_fac_2_bits;
tmp_b = (tmp_b + fac_fac_4) >> fac_fac_2_bits;
*pixout++ = PIX_RGB16_FROM_BYTES(tmp_r, tmp_g, tmp_b);
pixin += factor * dindp;
}
if (prest) {
tmp_r = tmp_g = tmp_b = 0;
for (j = 0; j < factor; j++)
for (i = 0; i < prest; i++) {
tmp_r += pixin[i * dindp + j * dindq];
tmp_g += pixin[i * dindp + j * dindq + 1];
tmp_b += pixin[i * dindp + j * dindq + 2];
}
tmp_r = (tmp_r + fac_prest_2) / fac_prest;
tmp_g = (tmp_g + fac_prest_2) / fac_prest;
tmp_b = (tmp_b + fac_prest_2) / fac_prest;
*pixout++ = PIX_RGB16_FROM_BYTES(tmp_r, tmp_g, tmp_b);
}
rowin += factor * dindq;
rowout += wrapout;
}
if (qrest) {
pixin = rowin;
pixout = rowout;
for (p = 0; p < plast; p += factor) {
tmp_r = tmp_g = tmp_b = 0;
for (j = 0; j < qrest; j++)
for (i = 0; i < factor; i++) {
E 81 tmp_r += pixin[i * dindp + j * dindq];
tmp_g += pixin[i * dindp + j * dindq + 1];
tmp_b += pixin[i * dindp + j * dindq + 2];
}
tmp_r = (tmp_r + qrest_fac_2) / qrest_fac;
tmp_g = (tmp_g + qrest_fac_2) / qrest_fac;
tmp_b = (tmp_b + qrest_fac_2) / qrest_fac;
*pixout++ = PIX_RGB16_FROM_BYTES(tmp_r, tmp_g, tmp_b);
pixin += factor * dindp;
}
if (prest) {
tmp_r = tmp_g = tmp_b = 0;
for (j = 0; j < qrest; j++)
for (i = 0; i < prest; i++) {
tmp_r += pixin[i * dindp + j * dindq];
tmp_g += pixin[i * dindp + j * dindq + 1];
tmp_b += pixin[i * dindp + j * dindq + 2];
}
tmp_r = (tmp_r + qrest_prest_2) / qrest_prest;
tmp_g = (tmp_g + qrest_prest_2) / qrest_prest;
tmp_b = (tmp_b + qrest_prest_2) / qrest_prest;
*pixout++ = PIX_RGB16_FROM_BYTES(tmp_r, tmp_g, tmp_b);
}
}
}
/*---------------------------------------------------------------------------*/
E 63
E 57 static void rop_copy_90_rgb_rgbm(RASTER * rin, RASTER * rout, int x1,
int y1, int x2, int y2, int newx,
int newy, int mirror, int ninety) {
UCHAR *bufin, *bytein, *appo;
LPIXEL *bufout, *pixout, tmp;
int wrapin, wrapout;
int u, v, lu, lv, su, sv, u00, v00, u0, v0, dindx, dudy, dvdy;
int x, y, lx, ly;
int u1, v1, u2, v2;
mirror &= 1;
ninety &= 3;
if (!ninety && !mirror) {
rop_copy(rin, rout, x1, y1, x2, y2, newx, newy);
return;
}
u1 = x1;
v1 = y1;
u2 = x2;
v2 = y2;
su = u2 - u1;
sv = v2 - v1;
lu = u2 - u1 + 1;
lv = v2 - v1 + 1;
if (ninety & 1) {
lx = lv;
ly = lu;
} else {
lx = lu;
ly = lv;
}
bufin = rin->buffer;
wrapin = rin->wrap * 3; /* mi muovo di bytes */
bufout = rout->buffer;
wrapout = rout->wrap;
dudy = 0;
dvdy = 0;
switch ((mirror << 2) + ninety) {
CASE(0 << 2) + 0 : u00 = u1;
v00 = v1;
dvdy = 1;
dindx = 3;
CASE(0 << 2) + 1 : u00 = u1;
v00 = v1 + sv;
dudy = 1;
dindx = -wrapin;
CASE(0 << 2) + 2 : u00 = u1 + su;
v00 = v1 + sv;
dvdy = -1;
dindx = -3;
CASE(0 << 2) + 3 : u00 = u1 + su;
v00 = v1;
dudy = -1;
dindx = wrapin;
CASE(1 << 2) + 0 : u00 = u1 + su;
v00 = v1;
dvdy = 1;
dindx = -3;
CASE(1 << 2) + 1 : u00 = u1 + su;
v00 = v1 + sv;
dudy = -1;
dindx = -wrapin;
CASE(1 << 2) + 2 : u00 = u1;
v00 = v1 + sv;
dvdy = -1;
dindx = 3;
CASE(1 << 2) + 3 : u00 = u1;
v00 = v1;
dudy = 1;
dindx = wrapin;
D 78 DEFAULT : assert(FALSE);
u00 = v00 = dudy = dindx = 0;
E 78
I 78 DEFAULT : abort();
u00 = v00 = dudy = dindx = 0;
E 78
}
for (u0 = u00, v0 = v00, y = newy; y < newy + ly;
u0 += dudy, v0 += dvdy, y++) {
bytein = bufin + u0 * 3 + v0 * wrapin;
pixout = bufout + newx + y * wrapout;
for (x = newx; x < newx + lx; x++) {
appo = bytein;
tmp.r = *appo++;
tmp.g = *appo++;
tmp.b = *appo;
tmp.m = 0xff;
*pixout++ = tmp;
bytein += dindx;
}
}
}
/*---------------------------------------------------------------------------*/
I 63 static void rop_zoom_out_90_rgb_rgbm(
RASTER * rin, RASTER * rout, int x1, int y1, int x2, int y2, int newx,
int newy, int abs_zoom_level, int mirror, int ninety) {
UCHAR *bufin, *rowin, *pixin, *in;
int tmp_r, tmp_g, tmp_b;
LPIXEL *bufout, *rowout, *pixout, valout;
int wrapin_bytes, wrapin_pixels, wrapout;
int u1, v1, u2, v2;
int u, v, lu, lv, startu, startv;
int p, q, lp, lq;
int dudp, dvdp, dudq, dvdq, dindp, dindq;
int plast, qlast, prest, qrest, i, j;
int factor, fac_fac_2_bits;
int fac_fac, qrest_fac, fac_prest, qrest_prest;
int fac_fac_2, qrest_fac_2, fac_prest_2, qrest_prest_2;
int fac_fac_4;
mirror &= 1;
ninety &= 3;
if (!ninety && !mirror) {
rop_zoom_out(rin, rout, x1, y1, x2, y2, newx, newy, abs_zoom_level);
return;
}
u1 = x1;
v1 = y1;
u2 = x2;
v2 = y2;
lu = u2 - u1 + 1;
lv = v2 - v1 + 1;
if (ninety & 1) {
lp = lv;
lq = lu;
} else {
lp = lu;
lq = lv;
}
factor = 1 << abs_zoom_level;
prest = lp & (factor - 1);
qrest = lq & (factor - 1);
plast = lp - prest;
qlast = lq - qrest;
fac_fac = factor * factor;
fac_fac_2 = fac_fac >> 1;
fac_fac_4 = fac_fac >> 2;
fac_fac_2_bits = 2 * abs_zoom_level - 1;
qrest_fac = qrest * factor;
qrest_fac_2 = qrest_fac >> 1;
fac_prest = factor * prest;
fac_prest_2 = fac_prest >> 1;
qrest_prest = qrest * prest;
qrest_prest_2 = qrest_prest >> 1;
bufin = rin->buffer;
wrapin_pixels = rin->wrap;
wrapin_bytes = wrapin_pixels * 3;
bufout = rout->buffer;
wrapout = rout->wrap;
switch ((mirror << 2) + ninety) {
CASE(0 << 2) + 0 : dudp = 1;
dvdp = 0;
dudq = 0;
dvdq = 1;
startu = u1;
startv = v1;
CASE(0 << 2) + 1 : dudp = 0;
dvdp = -1;
dudq = 1;
dvdq = 0;
startu = u1;
startv = v2;
CASE(0 << 2) + 2 : dudp = -1;
dvdp = 0;
dudq = 0;
dvdq = -1;
startu = u2;
startv = v2;
CASE(0 << 2) + 3 : dudp = 0;
dvdp = 1;
dudq = -1;
dvdq = 0;
startu = u2;
startv = v1;
CASE(1 << 2) + 0 : dudp = -1;
dvdp = 0;
dudq = 0;
dvdq = 1;
startu = u2;
startv = v1;
CASE(1 << 2) + 1 : dudp = 0;
dvdp = -1;
dudq = -1;
dvdq = 0;
startu = u2;
startv = v2;
CASE(1 << 2) + 2 : dudp = 1;
dvdp = 0;
dudq = 0;
dvdq = -1;
startu = u1;
startv = v2;
CASE(1 << 2) + 3 : dudp = 0;
dvdp = 1;
dudq = 1;
dvdq = 0;
startu = u1;
startv = v1;
DEFAULT:
D 78 assert(FALSE);
dudp = dvdp = dudq = dvdq = startu = startv = 0;
E 78
I 78 abort();
dudp = dvdp = dudq = dvdq = startu = startv = 0;
E 78
}
dindp = (dudp + wrapin_pixels * dvdp) * 3;
dindq = (dudq + wrapin_pixels * dvdq) * 3;
rowin = (UCHAR *)rin->buffer + startu * 3 + startv * wrapin_bytes;
rowout = (LPIXEL *)rout->buffer + newx + newy * wrapout;
valout.m = 0xff;
for (q = 0; q < qlast; q += factor) {
pixin = rowin;
pixout = rowout;
for (p = 0; p < plast; p += factor) {
tmp_r = tmp_g = tmp_b = 0;
in = pixin;
for (j = 0; j < factor; j += 2) {
for (i = 0; i < factor; i += 2) {
tmp_r += in[0];
tmp_g += in[1];
tmp_b += in[2];
in += dindp + dindq;
tmp_r += in[0];
tmp_g += in[1];
tmp_b += in[2];
in += dindp - dindq;
}
in += 2 * dindq - factor * dindp;
}
valout.r = (tmp_r + fac_fac_4) >> fac_fac_2_bits;
valout.g = (tmp_g + fac_fac_4) >> fac_fac_2_bits;
valout.b = (tmp_b + fac_fac_4) >> fac_fac_2_bits;
*pixout++ = valout;
pixin += factor * dindp;
}
if (prest) {
tmp_r = tmp_g = tmp_b = 0;
for (j = 0; j < factor; j++)
for (i = 0; i < prest; i++) {
tmp_r += pixin[i * dindp + j * dindq];
tmp_g += pixin[i * dindp + j * dindq + 1];
tmp_b += pixin[i * dindp + j * dindq + 2];
}
valout.r = (tmp_r + fac_prest_2) / fac_prest;
valout.g = (tmp_g + fac_prest_2) / fac_prest;
valout.b = (tmp_b + fac_prest_2) / fac_prest;
*pixout++ = valout;
}
rowin += factor * dindq;
rowout += wrapout;
}
if (qrest) {
pixin = rowin;
pixout = rowout;
for (p = 0; p < plast; p += factor) {
tmp_r = tmp_g = tmp_b = 0;
for (j = 0; j < qrest; j++)
for (i = 0; i < factor; i++) {
tmp_r += pixin[i * dindp + j * dindq];
tmp_g += pixin[i * dindp + j * dindq + 1];
tmp_b += pixin[i * dindp + j * dindq + 2];
}
valout.r = (tmp_r + qrest_fac_2) / qrest_fac;
valout.g = (tmp_g + qrest_fac_2) / qrest_fac;
valout.b = (tmp_b + qrest_fac_2) / qrest_fac;
*pixout++ = valout;
pixin += factor * dindp;
}
if (prest) {
tmp_r = tmp_g = tmp_b = 0;
for (j = 0; j < qrest; j++)
for (i = 0; i < prest; i++) {
tmp_r += pixin[i * dindp + j * dindq];
tmp_g += pixin[i * dindp + j * dindq + 1];
tmp_b += pixin[i * dindp + j * dindq + 2];
}
valout.r = (tmp_r + qrest_prest_2) / qrest_prest;
valout.g = (tmp_g + qrest_prest_2) / qrest_prest;
valout.b = (tmp_b + qrest_prest_2) / qrest_prest;
*pixout++ = valout;
}
}
}
/*---------------------------------------------------------------------------*/
E 63 static void rop_copy_90_bw_gr8(RASTER * rin, RASTER * rout, int x1,
int y1, int x2, int y2,
E 56 int newx, int newy, int mirror, int ninety) {
UCHAR *bufin, *bufout, *bytein, *byteout;
int bytewrapin, bitoffsin, wrapout;
int value_for_0, value_for_1;
int u, v, lu, lv, su, sv, u00, v00, u0, v0, dudy, dvdy, dudx, dvdx;
int x, y, lx, ly;
int u1, v1, u2, v2;
mirror &= 1;
ninety &= 3;
if (!ninety && !mirror) {
rop_copy(rin, rout, x1, y1, x2, y2, newx, newy);
return;
E 55
}
switch (rin->type) {
CASE RAS_WB : value_for_0 = 255;
value_for_1 = 0;
CASE RAS_BW : value_for_0 = 0;
value_for_1 = 255;
DEFAULT:
printf("bad raster type in rop_copy_90_bw_gr8\n");
return;
}
u1 = x1;
v1 = y1;
u2 = x2;
v2 = y2;
su = u2 - u1;
sv = v2 - v1;
lu = u2 - u1 + 1;
lv = v2 - v1 + 1;
if (ninety & 1) {
lx = lv;
ly = lu;
} else {
lx = lu;
ly = lv;
}
bufin = rin->buffer;
D 47 bytewrapin = (rin->wrap + 7) / 8;
E 47
I 47 bytewrapin = (rin->wrap + 7) >> 3;
E 47 bitoffsin = rin->bit_offs;
bufout = rout->buffer;
wrapout = rout->wrap;
dudx = 0;
dudy = 0;
dvdx = 0;
dvdy = 0;
switch ((mirror << 2) + ninety) {
CASE(0 << 2) + 0 : u00 = u1;
v00 = v1;
dudx = 1;
dvdy = 1;
CASE(0 << 2) + 1 : u00 = u1;
v00 = v1 + sv;
dudy = 1;
dvdx = -1;
CASE(0 << 2) + 2 : u00 = u1 + su;
v00 = v1 + sv;
dudx = -1;
dvdy = -1;
CASE(0 << 2) + 3 : u00 = u1 + su;
v00 = v1;
dudy = -1;
dvdx = 1;
CASE(1 << 2) + 0 : u00 = u1 + su;
v00 = v1;
dudx = -1;
dvdy = 1;
CASE(1 << 2) + 1 : u00 = u1 + su;
v00 = v1 + sv;
dudy = -1;
dvdx = -1;
CASE(1 << 2) + 2 : u00 = u1;
v00 = v1 + sv;
dudx = 1;
dvdy = -1;
CASE(1 << 2) + 3 : u00 = u1;
v00 = v1;
dudy = 1;
dvdx = 1;
I 50
D 78 DEFAULT : assert(FALSE);
u00 = v00 = dudy = dvdx = 0;
E 78
I 78 DEFAULT : abort();
u00 = v00 = dudy = dvdx = 0;
E 78
E 50
}
if (dudx)
for (u0 = u00, v0 = v00, y = newy; y < newy + ly; v0 += dvdy, y++) {
u = u0;
v = v0;
byteout = bufout + newx + y * wrapout;
for (x = newx; x < newx + lx; u += dudx, x++) {
if (GET_BIT(u, v, bufin, bytewrapin, bitoffsin))
*byteout++ = value_for_1;
else
*byteout++ = value_for_0;
}
}
else
for (u0 = u00, v0 = v00, y = newy; y < newy + ly; u0 += dudy, y++) {
u = u0;
v = v0;
byteout = bufout + newx + y * wrapout;
for (x = newx; x < newx + lx; v += dvdx, x++) {
if (GET_BIT(u, v, bufin, bytewrapin, bitoffsin))
*byteout++ = value_for_1;
else
*byteout++ = value_for_0;
I 21
}
}
D 55
#ifdef DEBUG
STW_STOP(0) STW_PRINT(stdout)
#endif
E 55
}
/*---------------------------------------------------------------------------*/
static void rop_copy_90_bw_cm16(RASTER * rin, RASTER * rout, int x1,
int y1, int x2, int y2, int newx,
int newy, int mirror, int ninety) {
UCHAR *bufin, *bytein;
USHORT *bufout, *pixout;
LPIXEL *cmap;
int bytewrapin, bitoffsin, wrapout, cmap_offset;
USHORT value_for_0, value_for_1, value_tmp;
int u, v, lu, lv, su, sv, u00, v00, u0, v0, dudy, dvdy, dudx, dvdx;
int x, y, lx, ly;
int u1, v1, u2, v2;
D 55
#ifdef DEBUG
STW_INIT(0, "rop_copy_90_bw_gr8") STW_START(0)
#endif
E 55 mirror &= 1;
ninety &= 3;
if (!ninety && !mirror) {
rop_copy(rin, rout, x1, y1, x2, y2, newx, newy);
return;
}
D 84 if (!rout->cmap.buffer) {
msg(MSG_IE, "rop_copy_90_bw_cm16: missing color map");
return;
}
E 84 cmap = rout->cmap.buffer;
D 56 cmap_offset = rout->cmap.offset;
E 56
I 56 cmap_offset = rout->cmap.info.offset_mask;
E 56 if (cmap[0].r == 0) {
value_for_0 = cmap_offset;
value_for_1 = cmap_offset + 255;
}
else {
value_for_0 = cmap_offset + 255;
value_for_1 = cmap_offset;
}
if (rin->type == RAS_WB) {
value_tmp = value_for_0;
value_for_0 = value_for_1;
value_for_1 = value_tmp;
I 22
}
u1 = x1;
v1 = y1;
u2 = x2;
v2 = y2;
su = u2 - u1;
sv = v2 - v1;
lu = u2 - u1 + 1;
lv = v2 - v1 + 1;
if (ninety & 1) {
lx = lv;
ly = lu;
} else {
lx = lu;
ly = lv;
}
bufin = rin->buffer;
D 47 bytewrapin = (rin->wrap + 7) / 8;
E 47
I 47 bytewrapin = (rin->wrap + 7) >> 3;
E 47 bitoffsin = rin->bit_offs;
bufout = rout->buffer;
wrapout = rout->wrap;
dudx = 0;
dudy = 0;
dvdx = 0;
dvdy = 0;
switch ((mirror << 2) + ninety) {
CASE(0 << 2) + 0 : u00 = u1;
v00 = v1;
dudx = 1;
dvdy = 1;
CASE(0 << 2) + 1 : u00 = u1;
v00 = v1 + sv;
dudy = 1;
dvdx = -1;
CASE(0 << 2) + 2 : u00 = u1 + su;
v00 = v1 + sv;
dudx = -1;
dvdy = -1;
CASE(0 << 2) + 3 : u00 = u1 + su;
v00 = v1;
dudy = -1;
dvdx = 1;
CASE(1 << 2) + 0 : u00 = u1 + su;
v00 = v1;
dudx = -1;
dvdy = 1;
CASE(1 << 2) + 1 : u00 = u1 + su;
v00 = v1 + sv;
dudy = -1;
dvdx = -1;
CASE(1 << 2) + 2 : u00 = u1;
v00 = v1 + sv;
dudx = 1;
dvdy = -1;
CASE(1 << 2) + 3 : u00 = u1;
v00 = v1;
dudy = 1;
dvdx = 1;
I 50
D 78 DEFAULT : assert(FALSE);
u00 = v00 = dudy = dvdx = 0;
E 78
I 78 DEFAULT : abort();
u00 = v00 = dudy = dvdx = 0;
E 78
E 50
}
if (dudx)
for (u0 = u00, v0 = v00, y = newy; y < newy + ly; v0 += dvdy, y++) {
u = u0;
v = v0;
pixout = bufout + newx + y * wrapout;
for (x = newx; x < newx + lx; u += dudx, x++) {
if (GET_BIT(u, v, bufin, bytewrapin, bitoffsin))
*pixout++ = value_for_1;
else
*pixout++ = value_for_0;
}
}
else
for (u0 = u00, v0 = v00, y = newy; y < newy + ly; u0 += dudy, y++) {
u = u0;
v = v0;
pixout = bufout + newx + y * wrapout;
for (x = newx; x < newx + lx; v += dvdx, x++) {
if (GET_BIT(u, v, bufin, bytewrapin, bitoffsin))
*pixout++ = value_for_1;
else
*pixout++ = value_for_0;
}
}
I 55
}
/*---------------------------------------------------------------------------*/
I 84 static void rop_copy_90_bw_cm24(RASTER * rin, RASTER * rout, int x1,
int y1, int x2, int y2, int newx,
int newy, int mirror, int ninety) {
UCHAR *bufin, *bytein;
ULONG *bufout, *pixout;
LPIXEL *penmap, *colmap;
int bytewrapin, bitoffsin, wrapout;
ULONG value_for_0, value_for_1, value_tmp;
int u, v, lu, lv, su, sv, u00, v00, u0, v0, dudy, dvdy, dudx, dvdx;
int x, y, lx, ly;
int u1, v1, u2, v2;
mirror &= 1;
ninety &= 3;
if (!ninety && !mirror) {
rop_copy(rin, rout, x1, y1, x2, y2, newx, newy);
return;
}
penmap = rout->cmap.penbuffer;
colmap = rout->cmap.colbuffer;
if (penmap[0].r + colmap[0].r == 0) {
value_for_0 = 0;
value_for_1 = 255;
} else {
value_for_0 = 255;
value_for_1 = 0;
}
if (rin->type == RAS_WB) {
value_tmp = value_for_0;
value_for_0 = value_for_1;
value_for_1 = value_tmp;
}
u1 = x1;
v1 = y1;
u2 = x2;
v2 = y2;
su = u2 - u1;
sv = v2 - v1;
lu = u2 - u1 + 1;
lv = v2 - v1 + 1;
if (ninety & 1) {
lx = lv;
ly = lu;
} else {
lx = lu;
ly = lv;
}
bufin = rin->buffer;
bytewrapin = (rin->wrap + 7) >> 3;
bitoffsin = rin->bit_offs;
bufout = rout->buffer;
wrapout = rout->wrap;
dudx = 0;
dudy = 0;
dvdx = 0;
dvdy = 0;
switch ((mirror << 2) + ninety) {
CASE(0 << 2) + 0 : u00 = u1;
v00 = v1;
dudx = 1;
dvdy = 1;
CASE(0 << 2) + 1 : u00 = u1;
v00 = v1 + sv;
dudy = 1;
dvdx = -1;
CASE(0 << 2) + 2 : u00 = u1 + su;
v00 = v1 + sv;
dudx = -1;
dvdy = -1;
CASE(0 << 2) + 3 : u00 = u1 + su;
v00 = v1;
dudy = -1;
dvdx = 1;
CASE(1 << 2) + 0 : u00 = u1 + su;
v00 = v1;
dudx = -1;
dvdy = 1;
CASE(1 << 2) + 1 : u00 = u1 + su;
v00 = v1 + sv;
dudy = -1;
dvdx = -1;
CASE(1 << 2) + 2 : u00 = u1;
v00 = v1 + sv;
dudx = 1;
dvdy = -1;
CASE(1 << 2) + 3 : u00 = u1;
v00 = v1;
dudy = 1;
dvdx = 1;
DEFAULT:
abort();
u00 = v00 = dudy = dvdx = 0;
}
if (dudx)
for (u0 = u00, v0 = v00, y = newy; y < newy + ly; v0 += dvdy, y++) {
u = u0;
v = v0;
pixout = bufout + newx + y * wrapout;
for (x = newx; x < newx + lx; u += dudx, x++) {
if (GET_BIT(u, v, bufin, bytewrapin, bitoffsin))
*pixout++ = value_for_1;
else
*pixout++ = value_for_0;
}
}
else
for (u0 = u00, v0 = v00, y = newy; y < newy + ly; u0 += dudy, y++) {
u = u0;
v = v0;
pixout = bufout + newx + y * wrapout;
for (x = newx; x < newx + lx; v += dvdx, x++) {
if (GET_BIT(u, v, bufin, bytewrapin, bitoffsin))
*pixout++ = value_for_1;
else
*pixout++ = value_for_0;
}
}
}
/*---------------------------------------------------------------------------*/
E 84 static void rop_copy_90_bw_rgb16(
RASTER * rin, RASTER * rout, int x1, int y1, int x2, int y2, int newx,
int newy, int mirror, int ninety) {
UCHAR *bufin, *bytein;
USHORT *bufout, *pixout;
int bytewrapin, bitoffsin, wrapout;
USHORT value_for_0, value_for_1;
int u, v, lu, lv, su, sv, u00, v00, u0, v0, dudy, dvdy, dudx, dvdx;
int x, y, lx, ly;
int u1, v1, u2, v2;
mirror &= 1;
ninety &= 3;
if (!ninety && !mirror) {
rop_copy(rin, rout, x1, y1, x2, y2, newx, newy);
return;
}
switch (rin->type) {
CASE RAS_WB : value_for_0 = 0xffff;
value_for_1 = 0x0000;
CASE RAS_BW : value_for_0 = 0x0000;
value_for_1 = 0xffff;
DEFAULT:
printf("bad raster type in rop_copy_90_bw_rgb16\n");
return;
}
u1 = x1;
v1 = y1;
u2 = x2;
v2 = y2;
su = u2 - u1;
sv = v2 - v1;
lu = u2 - u1 + 1;
lv = v2 - v1 + 1;
if (ninety & 1) {
lx = lv;
ly = lu;
} else {
lx = lu;
ly = lv;
}
bufin = rin->buffer;
bytewrapin = (rin->wrap + 7) >> 3;
bitoffsin = rin->bit_offs;
bufout = rout->buffer;
wrapout = rout->wrap;
dudx = 0;
dudy = 0;
dvdx = 0;
dvdy = 0;
switch ((mirror << 2) + ninety) {
CASE(0 << 2) + 0 : u00 = u1;
v00 = v1;
dudx = 1;
dvdy = 1;
CASE(0 << 2) + 1 : u00 = u1;
v00 = v1 + sv;
dudy = 1;
dvdx = -1;
CASE(0 << 2) + 2 : u00 = u1 + su;
v00 = v1 + sv;
dudx = -1;
dvdy = -1;
CASE(0 << 2) + 3 : u00 = u1 + su;
v00 = v1;
dudy = -1;
dvdx = 1;
CASE(1 << 2) + 0 : u00 = u1 + su;
v00 = v1;
dudx = -1;
dvdy = 1;
CASE(1 << 2) + 1 : u00 = u1 + su;
v00 = v1 + sv;
dudy = -1;
dvdx = -1;
CASE(1 << 2) + 2 : u00 = u1;
v00 = v1 + sv;
dudx = 1;
dvdy = -1;
CASE(1 << 2) + 3 : u00 = u1;
v00 = v1;
dudy = 1;
dvdx = 1;
D 78 DEFAULT : assert(FALSE);
u00 = v00 = dudy = dvdx = 0;
E 78
I 78 DEFAULT : abort();
u00 = v00 = dudy = dvdx = 0;
E 78
}
E 55
D 55
#ifdef DEBUG
STW_STOP(0) STW_PRINT(stdout)
#endif
E 55
I 55 if (dudx) for (u0 = u00, v0 = v00, y = newy; y < newy + ly;
v0 += dvdy, y++) {
u = u0;
v = v0;
pixout = bufout + newx + y * wrapout;
for (x = newx; x < newx + lx; u += dudx, x++) {
if (GET_BIT(u, v, bufin, bytewrapin, bitoffsin))
*pixout++ = value_for_1;
else
*pixout++ = value_for_0;
}
}
else for (u0 = u00, v0 = v00, y = newy; y < newy + ly;
u0 += dudy, y++) {
u = u0;
v = v0;
pixout = bufout + newx + y * wrapout;
for (x = newx; x < newx + lx; v += dvdx, x++) {
if (GET_BIT(u, v, bufin, bytewrapin, bitoffsin))
*pixout++ = value_for_1;
else
*pixout++ = value_for_0;
}
}
E 55
}
/*---------------------------------------------------------------------------*/
static void rop_copy_90_bw_rgbm(RASTER * rin, RASTER * rout, int x1,
int y1, int x2, int y2, int newx,
int newy,
D 52 int mirror, int ninety) {
UCHAR *bufin, *bytein;
LPIXEL *bufout, *pixout;
int bytewrapin, bitoffsin, wrapout;
LPIXEL value_for_0, value_for_1;
int u, v, lu, lv, su, sv, u00, v00, u0, v0, dudy, dvdy, dudx, dvdx;
int x, y, lx, ly;
int u1, v1, u2, v2;
#ifdef DEBUG
STW_INIT(0, "rop_copy_90_bw_gr8")
STW_START(0)
#endif
mirror &= 1;
ninety &= 3;
if (!ninety && !mirror) {
rop_copy(rin, rout, x1, y1, x2, y2, newx, newy);
return;
}
switch (rin->type) {
CASE RAS_WB : value_for_0.r = 255;
value_for_0.g = 255;
value_for_0.b = 255;
value_for_0.m = 255;
value_for_1.r = 0;
value_for_1.g = 0;
value_for_1.b = 0;
value_for_1.m = 255;
CASE RAS_BW : value_for_0.r = 0;
value_for_0.g = 0;
value_for_0.b = 0;
value_for_0.m = 255;
value_for_1.r = 255;
value_for_1.g = 255;
value_for_1.b = 255;
value_for_1.m = 255;
DEFAULT:
printf("bad raster type in rop_copy_90_bw_rgbm\n");
return;
E 22
}
u1 = x1;
v1 = y1;
u2 = x2;
v2 = y2;
su = u2 - u1;
sv = v2 - v1;
lu = u2 - u1 + 1;
lv = v2 - v1 + 1;
if (ninety & 1) {
lx = lv;
ly = lu;
} else {
lx = lu;
ly = lv;
}
bufin = rin->buffer;
D 47 bytewrapin = (rin->wrap + 7) / 8;
E 47
I 47 bytewrapin = (rin->wrap + 7) >> 3;
E 47 bitoffsin = rin->bit_offs;
bufout = rout->buffer;
wrapout = rout->wrap;
dudx = 0;
dudy = 0;
dvdx = 0;
dvdy = 0;
switch ((mirror << 2) + ninety) {
CASE(0 << 2) + 0 : u00 = u1;
v00 = v1;
dudx = 1;
dvdy = 1;
CASE(0 << 2) + 1 : u00 = u1;
v00 = v1 + sv;
dudy = 1;
dvdx = -1;
CASE(0 << 2) + 2 : u00 = u1 + su;
v00 = v1 + sv;
dudx = -1;
dvdy = -1;
CASE(0 << 2) + 3 : u00 = u1 + su;
v00 = v1;
dudy = -1;
dvdx = 1;
CASE(1 << 2) + 0 : u00 = u1 + su;
v00 = v1;
dudx = -1;
dvdy = 1;
CASE(1 << 2) + 1 : u00 = u1 + su;
v00 = v1 + sv;
dudy = -1;
dvdx = -1;
CASE(1 << 2) + 2 : u00 = u1;
v00 = v1 + sv;
dudx = 1;
dvdy = -1;
CASE(1 << 2) + 3 : u00 = u1;
v00 = v1;
dudy = 1;
dvdx = 1;
I 50 DEFAULT : assert(FALSE);
u00 = v00 = dudy = dvdx = 0;
E 50
}
if (dudx)
for (u0 = u00, v0 = v00, y = newy; y < newy + ly; v0 += dvdy, y++) {
u = u0;
v = v0;
pixout = bufout + newx + y * wrapout;
for (x = newx; x < newx + lx; u += dudx, x++) {
if (GET_BIT(u, v, bufin, bytewrapin, bitoffsin))
*pixout++ = value_for_1;
else
*pixout++ = value_for_0;
}
}
else
for (u0 = u00, v0 = v00, y = newy; y < newy + ly; u0 += dudy, y++) {
u = u0;
v = v0;
pixout = bufout + newx + y * wrapout;
for (x = newx; x < newx + lx; v += dvdx, x++) {
if (GET_BIT(u, v, bufin, bytewrapin, bitoffsin))
*pixout++ = value_for_1;
else
*pixout++ = value_for_0;
E 21
}
}
E 17
#ifdef DEBUG
STW_STOP(0) STW_PRINT(stdout)
#endif
I 26
}
/*---------------------------------------------------------------------------*/
static void rop_copy_90_rgbm(RASTER * rin, RASTER * rout, int x1, int y1,
int x2, int y2, int newx, int newy,
int mirror, int ninety) {
LPIXEL *bufin, *pixin;
LPIXEL *bufout, *pixout;
int wrapin, wrapout;
int u, v, lu, lv, su, sv, u00, v00, u0, v0, dindx, dudy, dvdy;
int x, y, lx, ly;
int u1, v1, u2, v2;
mirror &= 1;
ninety &= 3;
if (!ninety && !mirror) {
rop_copy(rin, rout, x1, y1, x2, y2, newx, newy);
return;
}
u1 = x1;
v1 = y1;
u2 = x2;
v2 = y2;
su = u2 - u1;
sv = v2 - v1;
lu = u2 - u1 + 1;
lv = v2 - v1 + 1;
if (ninety & 1) {
lx = lv;
ly = lu;
} else {
lx = lu;
ly = lv;
}
bufin = rin->buffer;
wrapin = rin->wrap;
bufout = rout->buffer;
wrapout = rout->wrap;
dudy = 0;
dvdy = 0;
switch ((mirror << 2) + ninety) {
CASE(0 << 2) + 0 : u00 = u1;
v00 = v1;
dvdy = 1;
dindx = 1;
CASE(0 << 2) + 1 : u00 = u1;
v00 = v1 + sv;
dudy = 1;
dindx = -wrapin;
CASE(0 << 2) + 2 : u00 = u1 + su;
v00 = v1 + sv;
dvdy = -1;
dindx = -1;
CASE(0 << 2) + 3 : u00 = u1 + su;
v00 = v1;
dudy = -1;
dindx = wrapin;
CASE(1 << 2) + 0 : u00 = u1 + su;
v00 = v1;
dvdy = 1;
dindx = -1;
CASE(1 << 2) + 1 : u00 = u1 + su;
v00 = v1 + sv;
dudy = -1;
dindx = -wrapin;
CASE(1 << 2) + 2 : u00 = u1;
v00 = v1 + sv;
dvdy = -1;
dindx = 1;
CASE(1 << 2) + 3 : u00 = u1;
v00 = v1;
dudy = 1;
dindx = wrapin;
I 50 DEFAULT : assert(FALSE);
u00 = v00 = dudy = dindx = 0;
E 50
}
for (u0 = u00, v0 = v00, y = newy; y < newy + ly;
u0 += dudy, v0 += dvdy, y++) {
pixin = bufin + u0 + v0 * wrapin;
pixout = bufout + newx + y * wrapout;
for (x = newx; x < newx + lx; x++) {
*pixout++ = *pixin;
pixin += dindx;
}
}
E 26
E 14
}
/*---------------------------------------------------------------------------*/
E 6 void rop_clear(RASTER * r, int x1, int y1, int x2, int y2) {
D 13 char *pix;
E 13
I 13 UCHAR *pix;
E 13 int l, x, y, tmp, rowsize, wrap, pixbits;
if (x1 > x2) {
tmp = x1;
x1 = x2;
x2 = tmp;
}
if (y1 > y2) {
tmp = y1;
y1 = y2;
y2 = tmp;
}
/* controllo gli sconfinamenti */
if (x1 < 0 || y1 < 0 || x2 - x1 >= r->lx || y2 - y1 >= r->ly) {
printf("### INTERNAL ERROR - rop_clear; access violation\n");
return;
}
pixbits = rop_pixbits(r->type);
/* per adesso niente pixel non multipli di 8 bits */
D 2 if (pixbits & 7)
E 2
I 2 if (rop_fillerbits(r->type))
E 2 {
printf("### INTERNAL ERROR - rop_clear; byte fraction pixels\n");
return;
}
wrap = (r->wrap * pixbits) >> 3;
rowsize = ((x2 - x1 + 1) * pixbits) >> 3;
D 10 pix = (char *)r->buffer + (((x1 + y1 * r->wrap) * pixbits) >> 3);
E 10
I 10 pix = (UCHAR *)r->buffer + (((x1 + y1 * r->wrap) * pixbits) >> 3);
E 10 l = y2 - y1 + 1;
while (l-- > 0) {
memset(pix, 0, rowsize);
pix += wrap;
}
}
D 6
E 6
/*---------------------------------------------------------------------------*/
I 6
I 25 void
rop_add_white_to_cmap(RASTER * ras) {
int i;
UCHAR m, white;
for (i = 0; i < ras->cmap.size; i++) {
m = ras->cmap.buffer[i].m;
if (ras->cmap.buffer[i].r > m || ras->cmap.buffer[i].g > m ||
ras->cmap.buffer[i].b > m)
break;
white = (UCHAR)255 - m;
ras->cmap.buffer[i].r += white;
ras->cmap.buffer[i].g += white;
ras->cmap.buffer[i].b += white;
}
if (i < ras->cmap.size)
fprintf(stderr, "\7add_white: cmap is not premultiplied\n");
}
/*---------------------------------------------------------------------------*/
void rop_remove_white_from_cmap(RASTER * ras) {
int i;
UCHAR m, white;
for (i = 0; i < ras->cmap.size; i++) {
m = ras->cmap.buffer[i].m;
white = (UCHAR)255 - m;
ras->cmap.buffer[i].r -= white;
ras->cmap.buffer[i].g -= white;
ras->cmap.buffer[i].b -= white;
if (ras->cmap.buffer[i].r > m || ras->cmap.buffer[i].g > m ||
ras->cmap.buffer[i].b > m)
break;
}
if (i < ras->cmap.size)
fprintf(stderr, "\7remove_white: cmap is not premultiplied\n");
I 32
}
/*---------------------------------------------------------------------------*/
static LPIXEL premult_lpixel(LPIXEL lpixel) {
int m;
LPIXEL new_lpixel;
m = lpixel.m;
if (m == 255)
return lpixel;
else if (m == 0) {
new_lpixel.r = 0;
new_lpixel.g = 0;
new_lpixel.b = 0;
new_lpixel.m = 0;
} else {
new_lpixel.r = (lpixel.r * m + 127) / 255;
new_lpixel.g = (lpixel.g * m + 127) / 255;
new_lpixel.b = (lpixel.b * m + 127) / 255;
new_lpixel.m = m;
}
return new_lpixel;
}
/*---------------------------------------------------------------------------*/
static LPIXEL unpremult_lpixel(LPIXEL lpixel) {
int m, m_2;
LPIXEL new_lpixel;
m = lpixel.m;
if (m == 255)
return lpixel;
else if (m == 0) {
new_lpixel.r = 255;
new_lpixel.g = 255;
new_lpixel.b = 255;
new_lpixel.m = 0;
D 51
}
E 51
I 51
}
E 51 else {
m_2 = m >> 1;
new_lpixel.r = (lpixel.r * 255 + m_2) / m;
new_lpixel.g = (lpixel.g * 255 + m_2) / m;
new_lpixel.b = (lpixel.b * 255 + m_2) / m;
E 52
I 52
int mirror, int ninety)
{
UCHAR *bufin, *bytein;
LPIXEL *bufout, *pixout;
int bytewrapin, bitoffsin, wrapout;
LPIXEL value_for_0, value_for_1;
int u, v, lu, lv, su, sv, u00, v00, u0, v0, dudy, dvdy, dudx, dvdx;
int x, y, lx, ly;
int u1, v1, u2, v2;
D 55
#ifdef DEBUG
STW_INIT(0, "rop_copy_90_bw_gr8") STW_START(0)
#endif
E 55 mirror &= 1;
ninety &= 3;
if (!ninety && !mirror) {
rop_copy(rin, rout, x1, y1, x2, y2, newx, newy);
return;
}
switch (rin->type) {
CASE RAS_WB : value_for_0.r = 255;
value_for_0.g = 255;
value_for_0.b = 255;
value_for_0.m = 255;
value_for_1.r = 0;
value_for_1.g = 0;
value_for_1.b = 0;
value_for_1.m = 255;
CASE RAS_BW : value_for_0.r = 0;
value_for_0.g = 0;
value_for_0.b = 0;
value_for_0.m = 255;
value_for_1.r = 255;
value_for_1.g = 255;
value_for_1.b = 255;
value_for_1.m = 255;
DEFAULT:
printf("bad raster type in rop_copy_90_bw_rgbm\n");
return;
}
u1 = x1;
v1 = y1;
u2 = x2;
v2 = y2;
su = u2 - u1;
sv = v2 - v1;
lu = u2 - u1 + 1;
lv = v2 - v1 + 1;
if (ninety & 1) {
lx = lv;
ly = lu;
} else {
lx = lu;
ly = lv;
}
D 53
bufin = rin->buffer;
bytewrapin = (rin->wrap + 7) >> 3;
bitoffsin = rin->bit_offs;
bufout = rout->buffer;
wrapout = rout->wrap;
dudx = 0;
dudy = 0;
dvdx = 0;
dvdy = 0;
switch ((mirror << 2) + ninety) {
CASE(0 << 2) + 0 : u00 = u1;
v00 = v1;
dudx = 1;
dvdy = 1;
CASE(0 << 2) + 1 : u00 = u1;
v00 = v1 + sv;
dudy = 1;
dvdx = -1;
CASE(0 << 2) + 2 : u00 = u1 + su;
v00 = v1 + sv;
dudx = -1;
dvdy = -1;
CASE(0 << 2) + 3 : u00 = u1 + su;
v00 = v1;
dudy = -1;
dvdx = 1;
CASE(1 << 2) + 0 : u00 = u1 + su;
v00 = v1;
dudx = -1;
dvdy = 1;
CASE(1 << 2) + 1 : u00 = u1 + su;
v00 = v1 + sv;
dudy = -1;
dvdx = -1;
CASE(1 << 2) + 2 : u00 = u1;
v00 = v1 + sv;
dudx = 1;
dvdy = -1;
CASE(1 << 2) + 3 : u00 = u1;
v00 = v1;
dudy = 1;
dvdx = 1;
DEFAULT:
assert(FALSE);
u00 = v00 = dudy = dvdx = 0;
}
if (dudx)
for (u0 = u00, v0 = v00, y = newy; y < newy + ly; v0 += dvdy, y++) {
u = u0;
v = v0;
pixout = bufout + newx + y * wrapout;
for (x = newx; x < newx + lx; u += dudx, x++) {
if (GET_BIT(u, v, bufin, bytewrapin, bitoffsin))
*pixout++ = value_for_1;
else
*pixout++ = value_for_0;
}
}
else
for (u0 = u00, v0 = v00, y = newy; y < newy + ly; u0 += dudy, y++) {
u = u0;
v = v0;
pixout = bufout + newx + y * wrapout;
for (x = newx; x < newx + lx; v += dvdx, x++) {
E 53
I 53
bufin = rin->buffer;
bytewrapin = (rin->wrap + 7) >> 3;
bitoffsin = rin->bit_offs;
bufout = rout->buffer;
wrapout = rout->wrap;
dudx = 0;
dudy = 0;
dvdx = 0;
dvdy = 0;
switch ((mirror << 2) + ninety) {
CASE(0 << 2) + 0 : u00 = u1;
v00 = v1;
dudx = 1;
dvdy = 1;
CASE(0 << 2) + 1 : u00 = u1;
v00 = v1 + sv;
dudy = 1;
dvdx = -1;
CASE(0 << 2) + 2 : u00 = u1 + su;
v00 = v1 + sv;
dudx = -1;
dvdy = -1;
CASE(0 << 2) + 3 : u00 = u1 + su;
v00 = v1;
dudy = -1;
dvdx = 1;
CASE(1 << 2) + 0 : u00 = u1 + su;
v00 = v1;
dudx = -1;
dvdy = 1;
CASE(1 << 2) + 1 : u00 = u1 + su;
v00 = v1 + sv;
dudy = -1;
dvdx = -1;
CASE(1 << 2) + 2 : u00 = u1;
v00 = v1 + sv;
dudx = 1;
dvdy = -1;
CASE(1 << 2) + 3 : u00 = u1;
v00 = v1;
dudy = 1;
dvdx = 1;
D 78 DEFAULT : assert(FALSE);
u00 = v00 = dudy = dvdx = 0;
E 78
I 78 DEFAULT : abort();
u00 = v00 = dudy = dvdx = 0;
E 78
}
if (dudx)
for (u0 = u00, v0 = v00, y = newy; y < newy + ly; v0 += dvdy, y++) {
u = u0;
v = v0;
pixout = bufout + newx + y * wrapout;
for (x = newx; x < newx + lx; u += dudx, x++) {
if (GET_BIT(u, v, bufin, bytewrapin, bitoffsin))
*pixout++ = value_for_1;
else
*pixout++ = value_for_0;
}
}
else
for (u0 = u00, v0 = v00, y = newy; y < newy + ly; u0 += dudy, y++) {
u = u0;
v = v0;
pixout = bufout + newx + y * wrapout;
for (x = newx; x < newx + lx; v += dvdx, x++) {
E 53 if (GET_BIT(u, v, bufin, bytewrapin, bitoffsin)) *pixout++ =
value_for_1;
else *pixout++ = value_for_0;
}
}
D 55
#ifdef DEBUG
STW_STOP(0) STW_PRINT(stdout)
#endif
E 55
}
/*---------------------------------------------------------------------------*/
I 62 static void rop_zoom_out_90_bw_rgbm(
RASTER * rin, RASTER * rout, int x1, int y1, int x2, int y2, int newx,
int newy, int abs_zoom_level, int mirror, int ninety) {
UCHAR *bufin;
int val_0, val_1, tmp;
LPIXEL *bufout, *rowout, *pixout, valout;
int bitrowin, bytewrapin, bitwrapin, wrapout, bitin, bit, bit_offs,
startbit;
int u1, v1, u2, v2;
int u, v, lu, lv, startu, startv;
int p, q, lp, lq, s, t; /* s=p+q, t=p-q */
int dudp, dvdp, dudq, dvdq;
int dinbitsdp, dinbitsdq, dinbitsds, dinbitsdt;
int plast, qlast, prest, qrest, i, j;
int factor, fac_fac_2_bits;
int fac_fac, qrest_fac, fac_prest, qrest_prest;
int fac_fac_2, qrest_fac_2, fac_prest_2, qrest_prest_2;
int fac_fac_4;
mirror &= 1;
ninety &= 3;
if (!ninety && !mirror) {
rop_zoom_out(rin, rout, x1, y1, x2, y2, newx, newy, abs_zoom_level);
return;
}
if (rin->type == RAS_WB) {
val_0 = 0xff;
val_1 = 0x00;
} else {
val_0 = 0x00;
val_1 = 0xff;
}
u1 = x1;
v1 = y1;
u2 = x2;
v2 = y2;
lu = u2 - u1 + 1;
lv = v2 - v1 + 1;
if (ninety & 1) {
lp = lv;
lq = lu;
} else {
lp = lu;
lq = lv;
}
factor = 1 << abs_zoom_level;
prest = lp & (factor - 1);
qrest = lq & (factor - 1);
plast = lp - prest;
qlast = lq - qrest;
fac_fac = factor * factor;
fac_fac_2 = fac_fac >> 1;
fac_fac_4 = fac_fac >> 2;
fac_fac_2_bits = 2 * abs_zoom_level - 1;
qrest_fac = qrest * factor;
qrest_fac_2 = qrest_fac >> 1;
fac_prest = factor * prest;
fac_prest_2 = fac_prest >> 1;
qrest_prest = qrest * prest;
qrest_prest_2 = qrest_prest >> 1;
bufin = rin->buffer;
bytewrapin = (rin->wrap + 7) >> 3;
bitwrapin = bytewrapin << 3;
bit_offs = rin->bit_offs;
bufout = rout->buffer;
wrapout = rout->wrap;
switch ((mirror << 2) + ninety) {
CASE(0 << 2) + 0 : dudp = 1;
dvdp = 0;
dudq = 0;
dvdq = 1;
startu = u1;
startv = v1;
CASE(0 << 2) + 1 : dudp = 0;
dvdp = -1;
dudq = 1;
dvdq = 0;
startu = u1;
startv = v2;
CASE(0 << 2) + 2 : dudp = -1;
dvdp = 0;
dudq = 0;
dvdq = -1;
startu = u2;
startv = v2;
CASE(0 << 2) + 3 : dudp = 0;
dvdp = 1;
dudq = -1;
dvdq = 0;
startu = u2;
startv = v1;
CASE(1 << 2) + 0 : dudp = -1;
dvdp = 0;
dudq = 0;
dvdq = 1;
startu = u2;
startv = v1;
CASE(1 << 2) + 1 : dudp = 0;
dvdp = -1;
dudq = -1;
dvdq = 0;
startu = u2;
startv = v2;
CASE(1 << 2) + 2 : dudp = 1;
dvdp = 0;
dudq = 0;
dvdq = -1;
startu = u1;
startv = v2;
CASE(1 << 2) + 3 : dudp = 0;
dvdp = 1;
dudq = 1;
dvdq = 0;
startu = u1;
startv = v1;
DEFAULT:
D 78 assert(FALSE);
dudp = dvdp = dudq = dvdq = startu = startv = 0;
E 78
I 78 abort();
dudp = dvdp = dudq = dvdq = startu = startv = 0;
E 78
}
dinbitsdp = dudp + bitwrapin * dvdp;
dinbitsdq = dudq + bitwrapin * dvdq;
dinbitsds = dinbitsdp + dinbitsdq;
dinbitsdt = dinbitsdp - dinbitsdq;
bitrowin = bit_offs + startu + startv * bitwrapin;
rowout = (LPIXEL *)rout->buffer + newx + newy * wrapout;
valout.m = 0xff;
for (q = 0; q < qlast; q += factor) {
bitin = bitrowin;
pixout = rowout;
for (p = 0; p < plast; p += factor) {
tmp = 0;
bit = bitin;
for (j = 0; j < factor; j += 2) {
for (i = 0; i < factor; i += 2) {
tmp += GET_BWBIT(bit, bufin);
bit += dinbitsds;
tmp += GET_BWBIT(bit, bufin);
bit += dinbitsdt;
}
bit += 2 * dinbitsdq - factor * dinbitsdp;
}
tmp = tmp * val_1 + (fac_fac_2 - tmp) * val_0;
tmp = (tmp + fac_fac_4) >> fac_fac_2_bits;
valout.r = valout.g = valout.b = tmp;
*pixout++ = valout;
bitin += factor * dinbitsdp;
}
if (prest) {
tmp = 0;
for (j = 0; j < factor; j++)
for (i = 0; i < prest; i++) {
tmp += GET_BWBIT(bitin + i * dinbitsdp + j * dinbitsdq, bufin);
}
tmp = tmp * val_1 + (fac_prest - tmp) * val_0;
tmp = (tmp + fac_prest_2) / fac_prest;
valout.r = valout.g = valout.b = tmp;
*pixout++ = valout;
}
bitrowin += factor * dinbitsdq;
rowout += wrapout;
}
if (qrest) {
bitin = bitrowin;
pixout = rowout;
for (p = 0; p < plast; p += factor) {
tmp = 0;
for (j = 0; j < qrest; j++)
for (i = 0; i < factor; i++) {
tmp += GET_BWBIT(bitin + i * dinbitsdp + j * dinbitsdq, bufin);
}
tmp = tmp * val_1 + (qrest_fac - tmp) * val_0;
tmp = (tmp + qrest_fac_2) / qrest_fac;
valout.r = valout.g = valout.b = tmp;
*pixout++ = valout;
bitin += factor * dinbitsdp;
}
if (prest) {
tmp = 0;
for (j = 0; j < qrest; j++)
for (i = 0; i < prest; i++) {
tmp += GET_BWBIT(bitin + i * dinbitsdp + j * dinbitsdq, bufin);
}
tmp = tmp * val_1 + (qrest_prest - tmp) * val_0;
tmp = (tmp + qrest_prest_2) / qrest_prest;
valout.r = valout.g = valout.b = tmp;
*pixout++ = valout;
}
}
}
/*---------------------------------------------------------------------------*/
static void rop_zoom_out_90_bw_rgb16(
RASTER * rin, RASTER * rout, int x1, int y1, int x2, int y2, int newx,
int newy, int abs_zoom_level, int mirror, int ninety) {
UCHAR *bufin;
int val_0, val_1, tmp;
USHORT *bufout, *rowout, *pixout;
int bitrowin, bytewrapin, bitwrapin, wrapout, bitin, bit, bit_offs,
startbit;
int u1, v1, u2, v2;
int u, v, lu, lv, startu, startv;
int p, q, lp, lq, s, t; /* s=p+q, t=p-q */
int dudp, dvdp, dudq, dvdq;
int dinbitsdp, dinbitsdq, dinbitsds, dinbitsdt;
int plast, qlast, prest, qrest, i, j;
int factor, fac_fac_2_bits;
int fac_fac, qrest_fac, fac_prest, qrest_prest;
int fac_fac_2, qrest_fac_2, fac_prest_2, qrest_prest_2;
int fac_fac_4;
mirror &= 1;
ninety &= 3;
if (!ninety && !mirror) {
rop_zoom_out(rin, rout, x1, y1, x2, y2, newx, newy, abs_zoom_level);
return;
}
if (rin->type == RAS_WB) {
val_0 = 0xff;
val_1 = 0x00;
} else {
val_0 = 0x00;
val_1 = 0xff;
}
u1 = x1;
v1 = y1;
u2 = x2;
v2 = y2;
lu = u2 - u1 + 1;
lv = v2 - v1 + 1;
if (ninety & 1) {
lp = lv;
lq = lu;
} else {
lp = lu;
lq = lv;
}
factor = 1 << abs_zoom_level;
prest = lp & (factor - 1);
qrest = lq & (factor - 1);
plast = lp - prest;
qlast = lq - qrest;
fac_fac = factor * factor;
fac_fac_2 = fac_fac >> 1;
fac_fac_4 = fac_fac >> 2;
fac_fac_2_bits = 2 * abs_zoom_level - 1;
qrest_fac = qrest * factor;
qrest_fac_2 = qrest_fac >> 1;
fac_prest = factor * prest;
fac_prest_2 = fac_prest >> 1;
qrest_prest = qrest * prest;
qrest_prest_2 = qrest_prest >> 1;
bufin = rin->buffer;
bytewrapin = (rin->wrap + 7) >> 3;
bitwrapin = bytewrapin << 3;
bit_offs = rin->bit_offs;
bufout = rout->buffer;
wrapout = rout->wrap;
switch ((mirror << 2) + ninety) {
CASE(0 << 2) + 0 : dudp = 1;
dvdp = 0;
dudq = 0;
dvdq = 1;
startu = u1;
startv = v1;
CASE(0 << 2) + 1 : dudp = 0;
dvdp = -1;
dudq = 1;
dvdq = 0;
startu = u1;
startv = v2;
CASE(0 << 2) + 2 : dudp = -1;
dvdp = 0;
dudq = 0;
dvdq = -1;
startu = u2;
startv = v2;
CASE(0 << 2) + 3 : dudp = 0;
dvdp = 1;
dudq = -1;
dvdq = 0;
startu = u2;
startv = v1;
CASE(1 << 2) + 0 : dudp = -1;
dvdp = 0;
dudq = 0;
dvdq = 1;
startu = u2;
startv = v1;
CASE(1 << 2) + 1 : dudp = 0;
dvdp = -1;
dudq = -1;
dvdq = 0;
startu = u2;
startv = v2;
CASE(1 << 2) + 2 : dudp = 1;
dvdp = 0;
dudq = 0;
dvdq = -1;
startu = u1;
startv = v2;
CASE(1 << 2) + 3 : dudp = 0;
dvdp = 1;
dudq = 1;
dvdq = 0;
startu = u1;
startv = v1;
DEFAULT:
D 78 assert(FALSE);
dudp = dvdp = dudq = dvdq = startu = startv = 0;
E 78
I 78 abort();
dudp = dvdp = dudq = dvdq = startu = startv = 0;
E 78
}
dinbitsdp = dudp + bitwrapin * dvdp;
dinbitsdq = dudq + bitwrapin * dvdq;
dinbitsds = dinbitsdp + dinbitsdq;
dinbitsdt = dinbitsdp - dinbitsdq;
bitrowin = bit_offs + startu + startv * bitwrapin;
rowout = (USHORT *)rout->buffer + newx + newy * wrapout;
for (q = 0; q < qlast; q += factor) {
bitin = bitrowin;
pixout = rowout;
for (p = 0; p < plast; p += factor) {
tmp = 0;
bit = bitin;
for (j = 0; j < factor; j += 2) {
for (i = 0; i < factor; i += 2) {
tmp += GET_BWBIT(bit, bufin);
bit += dinbitsds;
tmp += GET_BWBIT(bit, bufin);
bit += dinbitsdt;
}
bit += 2 * dinbitsdq - factor * dinbitsdp;
}
tmp = tmp * val_1 + (fac_fac_2 - tmp) * val_0;
tmp = (tmp + fac_fac_4) >> fac_fac_2_bits;
*pixout++ = PIX_RGB16_FROM_BYTES(tmp, tmp, tmp);
bitin += factor * dinbitsdp;
}
if (prest) {
tmp = 0;
for (j = 0; j < factor; j++)
for (i = 0; i < prest; i++) {
tmp += GET_BWBIT(bitin + i * dinbitsdp + j * dinbitsdq, bufin);
}
tmp = tmp * val_1 + (fac_prest - tmp) * val_0;
tmp = (tmp + fac_prest_2) / fac_prest;
*pixout++ = PIX_RGB16_FROM_BYTES(tmp, tmp, tmp);
}
bitrowin += factor * dinbitsdq;
rowout += wrapout;
}
if (qrest) {
bitin = bitrowin;
pixout = rowout;
for (p = 0; p < plast; p += factor) {
tmp = 0;
for (j = 0; j < qrest; j++)
for (i = 0; i < factor; i++) {
tmp += GET_BWBIT(bitin + i * dinbitsdp + j * dinbitsdq, bufin);
}
tmp = tmp * val_1 + (qrest_fac - tmp) * val_0;
tmp = (tmp + qrest_fac_2) / qrest_fac;
*pixout++ = PIX_RGB16_FROM_BYTES(tmp, tmp, tmp);
bitin += factor * dinbitsdp;
}
if (prest) {
tmp = 0;
for (j = 0; j < qrest; j++)
for (i = 0; i < prest; i++) {
tmp += GET_BWBIT(bitin + i * dinbitsdp + j * dinbitsdq, bufin);
}
tmp = tmp * val_1 + (qrest_prest - tmp) * val_0;
tmp = (tmp + qrest_prest_2) / qrest_prest;
*pixout++ = PIX_RGB16_FROM_BYTES(tmp, tmp, tmp);
}
}
}
/*---------------------------------------------------------------------------*/
E 62 static void rop_copy_90_rgbm(RASTER * rin, RASTER * rout, int x1,
int y1, int x2, int y2, int newx,
int newy, int mirror, int ninety) {
LPIXEL *bufin, *pixin;
LPIXEL *bufout, *pixout;
int wrapin, wrapout;
int u, v, lu, lv, su, sv, u00, v00, u0, v0, dindx, dudy, dvdy;
int x, y, lx, ly;
int u1, v1, u2, v2;
mirror &= 1;
ninety &= 3;
if (!ninety && !mirror) {
rop_copy(rin, rout, x1, y1, x2, y2, newx, newy);
return;
}
u1 = x1;
v1 = y1;
u2 = x2;
v2 = y2;
su = u2 - u1;
sv = v2 - v1;
lu = u2 - u1 + 1;
lv = v2 - v1 + 1;
if (ninety & 1) {
lx = lv;
ly = lu;
} else {
lx = lu;
ly = lv;
}
bufin = rin->buffer;
wrapin = rin->wrap;
bufout = rout->buffer;
wrapout = rout->wrap;
dudy = 0;
dvdy = 0;
switch ((mirror << 2) + ninety) {
CASE(0 << 2) + 0 : u00 = u1;
v00 = v1;
dvdy = 1;
dindx = 1;
CASE(0 << 2) + 1 : u00 = u1;
v00 = v1 + sv;
dudy = 1;
dindx = -wrapin;
CASE(0 << 2) + 2 : u00 = u1 + su;
v00 = v1 + sv;
dvdy = -1;
dindx = -1;
CASE(0 << 2) + 3 : u00 = u1 + su;
v00 = v1;
dudy = -1;
dindx = wrapin;
CASE(1 << 2) + 0 : u00 = u1 + su;
v00 = v1;
dvdy = 1;
dindx = -1;
CASE(1 << 2) + 1 : u00 = u1 + su;
v00 = v1 + sv;
dudy = -1;
dindx = -wrapin;
CASE(1 << 2) + 2 : u00 = u1;
v00 = v1 + sv;
dvdy = -1;
dindx = 1;
CASE(1 << 2) + 3 : u00 = u1;
v00 = v1;
dudy = 1;
dindx = wrapin;
D 78 DEFAULT : assert(FALSE);
u00 = v00 = dudy = dindx = 0;
E 78
I 78 DEFAULT : abort();
u00 = v00 = dudy = dindx = 0;
E 78
}
for (u0 = u00, v0 = v00, y = newy; y < newy + ly;
u0 += dudy, v0 += dvdy, y++) {
pixin = bufin + u0 + v0 * wrapin;
pixout = bufout + newx + y * wrapout;
for (x = newx; x < newx + lx; x++) {
*pixout++ = *pixin;
pixin += dindx;
}
I 57
}
}
/*---------------------------------------------------------------------------*/
/* vedi sia rop_zoom_out che rop_copy_90
*/
void rop_zoom_out_90(RASTER * rin, RASTER * rout, int x1, int y1, int x2,
int y2, int newx, int newy, int abs_zoom_level,
int mirror, int ninety) {
int tmp, newlx, newly;
int rasras, factor, abszl;
abszl = abs_zoom_level;
factor = 1 << abs_zoom_level;
if (factor == 1)
rop_copy_90(rin, rout, x1, y1, x2, y2, newx, newy, mirror, ninety);
/* raddrizzo gli estremi */
if (x1 > x2) {
tmp = x1;
x1 = x2;
x2 = tmp;
}
if (y1 > y2) {
tmp = y1;
y1 = y2;
y2 = tmp;
}
/* controllo gli sconfinamenti */
if (ninety & 1) {
newlx = (y2 - y1 + factor) / factor;
newly = (x2 - x1 + factor) / factor;
} else {
newlx = (x2 - x1 + factor) / factor;
newly = (y2 - y1 + factor) / factor;
}
if (x1 < 0 || y1 < 0 || x2 >= rin->lx || y2 >= rin->ly || newx < 0 ||
newy < 0 || newx + newlx > rout->lx || newy + newly > rout->ly) {
printf(
"### INTERNAL ERROR - rop_zoom_out; access violation\n"
" ((%d,%d)(%d,%d)in(%dx%d)->(%d,%d)in(%dx%d))\n",
x1, y1, x2, y2, rin->lx, rin->ly, newx, newy, rout->lx, rout->ly);
return;
}
rasras = RASRAS(rin->type, rout->type);
switch (rasras) {
I 62 CASE RASRAS(RAS_WB, RAS_RGB16)
: __OR RASRAS(RAS_BW, RAS_RGB16)
: rop_zoom_out_90_bw_rgb16(rin, rout, x1, y1, x2, y2, newx, newy,
abszl, mirror, ninety);
CASE RASRAS(RAS_WB, RAS_RGB_)
: __OR RASRAS(RAS_WB, RAS_RGBM)
: __OR RASRAS(RAS_BW, RAS_RGB_)
: __OR RASRAS(RAS_BW, RAS_RGBM)
: rop_zoom_out_90_bw_rgbm(rin, rout, x1, y1, x2, y2, newx, newy,
abszl, mirror, ninety);
E 62 CASE RASRAS(RAS_GR8, RAS_RGB16)
: rop_zoom_out_90_gr8_rgb16(rin, rout, x1, y1, x2, y2, newx, newy,
abszl, mirror, ninety);
CASE RASRAS(RAS_GR8, RAS_RGB_)
: __OR RASRAS(RAS_GR8, RAS_RGBM)
: rop_zoom_out_90_gr8_rgbm(rin, rout, x1, y1, x2, y2, newx, newy,
abszl,
I 63 mirror, ninety);
CASE RASRAS(RAS_RGB, RAS_RGB16)
: rop_zoom_out_90_rgb_rgb16(rin, rout, x1, y1, x2, y2, newx, newy,
abszl, mirror, ninety);
CASE RASRAS(RAS_RGB, RAS_RGB_)
: __OR RASRAS(RAS_RGB, RAS_RGBM)
: rop_zoom_out_90_rgb_rgbm(rin, rout, x1, y1, x2, y2, newx, newy,
abszl,
E 63 mirror, ninety);
DEFAULT:
assert(!"rop_zoom_out_90; invalid raster combination");
E 57
}
}
/*---------------------------------------------------------------------------*/
void rop_clear(RASTER * r, int x1, int y1, int x2, int y2) {
UCHAR *pix;
D 89 int l, x, y, tmp, rowsize, wrap, pixbits;
E 89
I 89 ULONG *row24, *pix24;
D 93 int lines, x, y, lx, tmp, rowsize, wrap, pixbits;
E 93
I 93 int lines, x, y, lx, tmp, rowbytes, wrap, bytewrap, pixbits;
E 93
E 89
if (x1 > x2) {
tmp = x1;
x1 = x2;
x2 = tmp;
}
if (y1 > y2) {
tmp = y1;
y1 = y2;
y2 = tmp;
}
/* controllo gli sconfinamenti */
if (x1 < 0 || y1 < 0 || x2 - x1 >= r->lx || y2 - y1 >= r->ly) {
printf("### INTERNAL ERROR - rop_clear; access violation\n");
return;
}
pixbits = rop_pixbits(r->type);
/* per adesso niente pixel non multipli di 8 bits */
if (rop_fillerbits(r->type)) {
printf("### INTERNAL ERROR - rop_clear; byte fraction pixels\n");
return;
}
D 93 wrap = (r->wrap * pixbits) >> 3;
rowsize = ((x2 - x1 + 1) * pixbits) >> 3;
E 93
I 93 wrap = r->wrap;
bytewrap = (wrap * pixbits + 7) >> 3;
rowbytes = ((x2 - x1 + 1) * pixbits) >> 3;
E 93
D 89 pix = (UCHAR *)r->buffer + (((x1 + y1 * r->wrap) * pixbits) >> 3);
l = y2 - y1 + 1;
while (l-- > 0)
E 89
I 89 lx = x2 - x1 + 1;
lines = y2 - y1 + 1;
if (r->type == RAS_CM24) {
row24 = (ULONG *)r->buffer + x1 + y1 * wrap;
while (lines-- > 0) {
pix24 = row24;
for (x = 0; x < lx; x++) *pix24++ &= 0xff000000;
row24 += wrap;
}
} else {
D 93 pix = (UCHAR *)r->buffer + (((x1 + y1 * wrap) * pixbits) >> 3);
E 93
I 93 pix = (UCHAR *)r->buffer + ((x1 * pixbits) >> 3) + y1 * bytewrap;
E 93 while (lines-- > 0) {
D 93 memset(pix, 0, rowsize);
pix += wrap;
E 93
I 93 memset(pix, 0, rowbytes);
pix += bytewrap;
E 93
}
}
}
/*---------------------------------------------------------------------------*/
void rop_and_extra_bits(RASTER * ras, UCHAR and_mask, int x1, int y1,
int x2, int y2) {
int x, y, lx, ly, wrap;
ULONG *row24, *pix24, and_mask24;
UCHAR *row8, *pix8;
lx = x2 - x1 + 1;
ly = y2 - y1 + 1;
wrap = ras->wrap;
if (ras->type == RAS_CM24) {
and_mask24 = (and_mask << 24) | 0xffffff;
row24 = (ULONG *)ras->buffer + x1 + y1 * wrap;
for (y = 0; y < ly; y++, row24 += wrap) {
pix24 = row24;
for (x = 0; x < lx; x++, pix24++) *pix24 &= and_mask24;
}
} else
E 89 {
D 89 memset(pix, 0, rowsize);
pix += wrap;
E 89
I 89 if (!ras->extra) return;
row8 = ras->extra + x1 + y1 * wrap;
for (y = 0; y < ly; y++, row8 += wrap) {
pix8 = row8;
if (and_mask)
for (x = 0; x < lx; x++, pix8++) *row8 &= and_mask;
else
memset(row8, 0, lx);
}
E 89
}
}
/*---------------------------------------------------------------------------*/
void rop_add_white_to_cmap(RASTER * ras) {
int i;
UCHAR m, white;
I 82
D 84 int cmap_size;
E 84
I 84 int cmap_size, colbuf_size, penbuf_size;
LPIXEL *buffer, *penbuffer, *colbuffer;
E 84
E 82
D 82 for (i = 0; i < ras->cmap.size; i++)
E 82
I 82
D 84 cmap_size = TCM_MIN_CMAP_BUFFER_SIZE(ras->cmap.info);
for (i = 0; i < cmap_size; i++)
E 82 {
m = ras->cmap.buffer[i].m;
if (ras->cmap.buffer[i].r > m || ras->cmap.buffer[i].g > m ||
ras->cmap.buffer[i].b > m)
break;
white = (UCHAR)255 - m;
ras->cmap.buffer[i].r += white;
ras->cmap.buffer[i].g += white;
ras->cmap.buffer[i].b += white;
E 84
I 84 buffer = ras->cmap.buffer;
penbuffer = ras->cmap.penbuffer;
colbuffer = ras->cmap.colbuffer;
if (buffer) {
cmap_size = TCM_MIN_CMAP_BUFFER_SIZE(ras->cmap.info);
for (i = 0; i < cmap_size; i++) {
m = buffer[i].m;
if (buffer[i].r > m || buffer[i].g > m || buffer[i].b > m)
break;
white = (UCHAR)255 - m;
buffer[i].r += white;
buffer[i].g += white;
buffer[i].b += white;
}
if (i < cmap_size)
fprintf(stderr, "\7add_white: cmap is not premultiplied\n");
} else if (colbuffer && penbuffer) {
colbuf_size = TCM_MIN_CMAP_COLBUFFER_SIZE(ras->cmap.info);
penbuf_size = TCM_MIN_CMAP_PENBUFFER_SIZE(ras->cmap.info);
for (i = 0; i < colbuf_size; i++) {
m = colbuffer[i].m;
if (colbuffer[i].r > m || colbuffer[i].g > m ||
colbuffer[i].b > m)
break;
white = (UCHAR)i - m; /* i & 0xff == tone */
colbuffer[i].r += white;
colbuffer[i].g += white;
colbuffer[i].b += white;
}
if (i < colbuf_size)
fprintf(stderr,
"\7add_white: color cmap is not premultiplied\n");
for (i = 0; i < penbuf_size; i++) {
m = penbuffer[i].m;
if (penbuffer[i].r > m || penbuffer[i].g > m ||
penbuffer[i].b > m)
break;
white = (UCHAR)~i - m; /* 255 - (i & 0xff) == 255 - tone */
penbuffer[i].r += white;
penbuffer[i].g += white;
penbuffer[i].b += white;
}
if (i < penbuf_size)
fprintf(stderr,
"\7add_white: pencil cmap is not premultiplied\n");
E 84
}
D 82 if (i < ras->cmap.size)
E 82
I 82
D 84 if (i < cmap_size)
E 82 fprintf(stderr, "\7add_white: cmap is not premultiplied\n");
E 84
}
/*---------------------------------------------------------------------------*/
void rop_remove_white_from_cmap(RASTER * ras) {
int i;
UCHAR m, white;
I 82
D 84 int cmap_size;
E 84
I 84 int cmap_size, colbuf_size, penbuf_size;
LPIXEL *buffer, *penbuffer, *colbuffer;
E 84
E 82
D 82 for (i = 0; i < ras->cmap.size; i++)
E 82
I 82
D 84 cmap_size = TCM_MIN_CMAP_BUFFER_SIZE(ras->cmap.info);
for (i = 0; i < cmap_size; i++)
E 84
I 84 buffer = ras->cmap.buffer;
penbuffer = ras->cmap.penbuffer;
colbuffer = ras->cmap.colbuffer;
if (buffer) {
cmap_size = TCM_MIN_CMAP_BUFFER_SIZE(ras->cmap.info);
for (i = 0; i < cmap_size; i++) {
m = buffer[i].m;
white = (UCHAR)255 - m;
buffer[i].r -= white;
buffer[i].g -= white;
buffer[i].b -= white;
if (buffer[i].r > m || buffer[i].g > m || buffer[i].b > m) break;
}
if (i < cmap_size)
fprintf(stderr, "\7remove_white: cmap is not premultiplied\n");
} else if (colbuffer && penbuffer)
E 84
E 82 {
D 84 m = ras->cmap.buffer[i].m;
white = (UCHAR)255 - m;
ras->cmap.buffer[i].r -= white;
ras->cmap.buffer[i].g -= white;
ras->cmap.buffer[i].b -= white;
if (ras->cmap.buffer[i].r > m || ras->cmap.buffer[i].g > m ||
ras->cmap.buffer[i].b > m)
break;
E 84
I 84 colbuf_size = TCM_MIN_CMAP_COLBUFFER_SIZE(ras->cmap.info);
penbuf_size = TCM_MIN_CMAP_PENBUFFER_SIZE(ras->cmap.info);
for (i = 0; i < colbuf_size; i++) {
m = colbuffer[i].m;
white = (UCHAR)i - m; /* i & 0xff == tone */
colbuffer[i].r -= white;
colbuffer[i].g -= white;
colbuffer[i].b -= white;
if (colbuffer[i].r > m || colbuffer[i].g > m ||
colbuffer[i].b > m)
break;
}
if (i < colbuf_size)
fprintf(stderr,
"\7add_white: color cmap is not premultiplied\n");
for (i = 0; i < penbuf_size; i++) {
m = penbuffer[i].m;
white = (UCHAR)~i - m; /* 255 - (i & 0xff) == 255 - tone */
penbuffer[i].r -= white;
penbuffer[i].g -= white;
penbuffer[i].b -= white;
if (penbuffer[i].r > m || penbuffer[i].g > m ||
penbuffer[i].b > m)
break;
}
if (i < penbuf_size)
fprintf(stderr,
"\7add_white: pencil cmap is not premultiplied\n");
E 84
}
D 82 if (i < ras->cmap.size)
E 82
I 82
D 84 if (i < cmap_size)
E 82 fprintf(stderr, "\7remove_white: cmap is not premultiplied\n");
E 84
}
/*---------------------------------------------------------------------------*/
D 84 static LPIXEL premult_lpixel(LPIXEL lpixel)
E 84
I 84 LPIXEL premult_lpixel(LPIXEL lpixel)
E 84 {
D 84 int m;
E 84
I 84 UINT m, mm;
E 84 LPIXEL new_lpixel;
m = lpixel.m;
if (m == 255)
D 84 return lpixel;
E 84
I 84 new_lpixel = lpixel;
E 84 else if (m == 0) {
new_lpixel.r = 0;
new_lpixel.g = 0;
new_lpixel.b = 0;
new_lpixel.m = 0;
}
else {
D 84 new_lpixel.r = (lpixel.r * m + 127) / 255;
new_lpixel.g = (lpixel.g * m + 127) / 255;
new_lpixel.b = (lpixel.b * m + 127) / 255;
E 84
I 84 mm = m * MAGICFAC;
new_lpixel.r = (lpixel.r * mm + (1U << 23)) >> 24;
new_lpixel.g = (lpixel.g * mm + (1U << 23)) >> 24;
new_lpixel.b = (lpixel.b * mm + (1U << 23)) >> 24;
E 84 new_lpixel.m = m;
}
return new_lpixel;
}
/*---------------------------------------------------------------------------*/
D 84 static LPIXEL unpremult_lpixel(LPIXEL lpixel)
E 84
I 84 LPIXEL unpremult_lpixel(LPIXEL lpixel)
E 84 {
int m, m_2;
LPIXEL new_lpixel;
m = lpixel.m;
if (m == 255)
return lpixel;
else if (m == 0) {
new_lpixel.r = 255;
new_lpixel.g = 255;
new_lpixel.b = 255;
new_lpixel.m = 0;
} else {
m_2 = m >> 1;
new_lpixel.r = (lpixel.r * 255 + m_2) / m;
new_lpixel.g = (lpixel.g * 255 + m_2) / m;
new_lpixel.b = (lpixel.b * 255 + m_2) / m;
E 52 new_lpixel.m = m;
}
return new_lpixel;
}
/*---------------------------------------------------------------------------*/
void rop_fill_cmap_ramp(RASTER * ras, TCM_INFO info,
D 89 LPIXEL color, LPIXEL pencil, int color_index, int pencil_index,
int already_premultiplied) {
LPIXEL val, *ramp;
int ramp_index;
int c_r, c_g, c_b, c_m, p_r, p_g, p_b, p_m, d_r, d_g, d_b, d_m;
int tone, tmax, tmax_2;
int tmax_2_r, tmax_2_g, tmax_2_b, tmax_2_m;
I 34
D 35
/* Secondo noi (Grisu & Roberto) l'offset non ci vuole
E 34
ramp_index = color_index << info.color_offs |
pencil_index << info.pencil_offs | info.offset_mask;
I 34
*/
ramp_index = color_index << info.color_offs |
pencil_index << info.pencil_offs;
E 35
I 35 ramp_index =
color_index << info.color_offs | pencil_index << info.pencil_offs;
E 35
E 34 ramp = ras->cmap.buffer + ramp_index;
if (!already_premultiplied) {
color = premult_lpixel(color);
pencil = premult_lpixel(pencil);
}
c_r = color.r;
p_r = pencil.r;
d_r = c_r - p_r;
c_g = color.g;
p_g = pencil.g;
d_g = c_g - p_g;
c_b = color.b;
p_b = pencil.b;
d_b = c_b - p_b;
c_m = color.m;
p_m = pencil.m;
d_m = c_m - p_m;
tmax = info.n_tones - 1;
tmax_2 = tmax >> 1;
tmax_2_r = d_r < 0 ? -tmax_2 : tmax_2;
tmax_2_g = d_g < 0 ? -tmax_2 : tmax_2;
tmax_2_b = d_b < 0 ? -tmax_2 : tmax_2;
tmax_2_m = d_m < 0 ? -tmax_2 : tmax_2;
ramp[0] = pencil;
for (tone = 1; tone < info.n_tones - 1; tone++) {
val.r = p_r + (d_r * tone + tmax_2_r) / tmax;
val.g = p_g + (d_g * tone + tmax_2_g) / tmax;
val.b = p_b + (d_b * tone + tmax_2_b) / tmax;
val.m = p_m + (d_m * tone + tmax_2_m) / tmax;
D 82 ramp[tone << info.tone_offs] = val;
E 82
I 82 ramp[tone] = val;
E 82
}
ramp[info.n_tones - 1] = color;
}
/*---------------------------------------------------------------------------*/
I 84 void rop_fill_cmap_colramp(RASTER * ras, TCM_INFO info,
LPIXEL color, int color_index,
int already_premultiplied) {
LPIXEL val, *colbuffer;
int index, tone;
UINT magic_tone, c_r, c_g, c_b, c_m;
if (!already_premultiplied) color = premult_lpixel(color);
c_r = color.r;
c_g = color.g;
c_b = color.b;
c_m = color.m;
colbuffer = ras->cmap.colbuffer;
index = color_index << info.tone_bits;
for (tone = 0; tone < info.n_tones; tone++) {
magic_tone = tone * MAGICFAC;
val.r = (UCHAR)((c_r * magic_tone + (1 << 23)) >> 24);
val.g = (UCHAR)((c_g * magic_tone + (1 << 23)) >> 24);
val.b = (UCHAR)((c_b * magic_tone + (1 << 23)) >> 24);
val.m = (UCHAR)((c_m * magic_tone + (1 << 23)) >> 24);
colbuffer[index++] = val;
}
}
/*---------------------------------------------------------------------------*/
void rop_fill_cmap_penramp(RASTER * ras, TCM_INFO info, LPIXEL pencil,
int pencil_index,
int already_premultiplied) {
LPIXEL val, *penbuffer;
int index, enot;
UINT magic_enot, p_r, p_g, p_b, p_m;
if (!already_premultiplied)
D 88 pencil = premult(pencil);
E 88
I 88 pencil = rop_premult(pencil);
E 88 p_r = pencil.r;
p_g = pencil.g;
p_b = pencil.b;
p_m = pencil.m;
penbuffer = ras->cmap.penbuffer;
index = pencil_index << info.tone_bits;
for (enot = info.n_tones - 1; enot >= 0; enot--) {
magic_enot = enot * MAGICFAC;
val.r = (UCHAR)((p_r * magic_enot + (1 << 23)) >> 24);
val.g = (UCHAR)((p_g * magic_enot + (1 << 23)) >> 24);
val.b = (UCHAR)((p_b * magic_enot + (1 << 23)) >> 24);
val.m = (UCHAR)((p_m * magic_enot + (1 << 23)) >> 24);
penbuffer[index++] = val;
}
}
/*---------------------------------------------------------------------------*/
E 84
I 36 void rop_custom_fill_cmap_ramp(
RASTER * ras, TCM_INFO info, LPIXEL color, LPIXEL pencil,
int color_index, int pencil_index, int already_premultiplied,
int *custom_tone) {
LPIXEL val, *ramp;
int ramp_index;
int c_r, c_g, c_b, c_m, p_r, p_g, p_b, p_m, d_r, d_g, d_b, d_m;
int tone, tmax, tmax_2;
int tmax_2_r, tmax_2_g, tmax_2_b, tmax_2_m;
ramp_index =
color_index << info.color_offs | pencil_index << info.pencil_offs;
ramp = ras->cmap.buffer + ramp_index;
if (!already_premultiplied) {
color = premult_lpixel(color);
pencil = premult_lpixel(pencil);
}
c_r = color.r;
p_r = pencil.r;
d_r = c_r - p_r;
c_g = color.g;
p_g = pencil.g;
d_g = c_g - p_g;
c_b = color.b;
p_b = pencil.b;
d_b = c_b - p_b;
c_m = color.m;
p_m = pencil.m;
d_m = c_m - p_m;
tmax = info.n_tones - 1;
tmax_2 = tmax >> 1;
tmax_2_r = d_r < 0 ? -tmax_2 : tmax_2;
tmax_2_g = d_g < 0 ? -tmax_2 : tmax_2;
tmax_2_b = d_b < 0 ? -tmax_2 : tmax_2;
tmax_2_m = d_m < 0 ? -tmax_2 : tmax_2;
D 37 ramp[0] = pencil;
for (tone = 1; tone < info.n_tones - 1; tone++)
E 37
I 37 for (tone = 0; tone < info.n_tones; tone++)
E 37 {
D 37
/* only the following 4 lines are different from the
non-custom version */
E 37 val.r = p_r + (d_r * custom_tone[tone] + tmax_2_r) / tmax;
val.g = p_g + (d_g * custom_tone[tone] + tmax_2_g) / tmax;
val.b = p_b + (d_b * custom_tone[tone] + tmax_2_b) / tmax;
val.m = p_m + (d_m * custom_tone[tone] + tmax_2_m) / tmax;
D 82 ramp[tone << info.tone_offs] = val;
E 82
I 82 ramp[tone] = val;
E 82
}
D 37 ramp[info.n_tones - 1] = color;
E 37
}
/*---------------------------------------------------------------------------*/
E 36
D 84 void rop_fill_cmap_buffer(RASTER * ras, TCM_INFO info, LPIXEL * color,
LPIXEL * pencil, int already_premultiplied) {
D 82 int min_cmap_buffer_size, i, j;
E 82
I 82 int i, j;
E 82
D 82 min_cmap_buffer_size = TCM_MIN_CMAP_BUFFER_SIZE(info);
D 33 assert(min_cmap_buffer_size < ras->cmap.size);
E 33
I 33 assert(ras->cmap.size >= min_cmap_buffer_size);
E 82
E 33 for (i = 0; i < info.n_colors; i++) for (j = 0; j < info.n_pencils; j++)
rop_fill_cmap_ramp(ras, info, color[i], pencil[j], i, j,
already_premultiplied);
I 36
}
/*---------------------------------------------------------------------------*/
void rop_custom_fill_cmap_buffer(
RASTER * ras, TCM_INFO info, LPIXEL * color, LPIXEL * pencil,
int already_premultiplied, int *custom_tone) {
D 82 int min_cmap_buffer_size, i, j;
E 82
I 82 int i, j;
E 82
D 82 min_cmap_buffer_size = TCM_MIN_CMAP_BUFFER_SIZE(info);
assert(ras->cmap.size >= min_cmap_buffer_size);
E 82 for (i = 0; i < info.n_colors;
i++) for (j = 0; j < info.n_pencils; j++)
rop_custom_fill_cmap_ramp(ras, info, color[i], pencil[j], i, j,
already_premultiplied, custom_tone);
E 36
E 32
}
I 66
/*---------------------------------------------------------------------------*/
E 84
I 84 void
rop_custom_fill_cmap_colramp(RASTER * ras, TCM_INFO info, LPIXEL color,
int color_index, int already_premultiplied,
int *custom_tone) {
LPIXEL val, *colbuffer;
int index, tone;
UINT magic_tone, c_r, c_g, c_b, c_m;
E 84
I 77
D 84 void release_raster(RASTER * raster) {
if (!raster->native_buffer)
E 84
I 84 if (!already_premultiplied) color = premult_lpixel(color);
c_r = color.r;
c_g = color.g;
c_b = color.b;
c_m = color.m;
colbuffer = ras->cmap.colbuffer;
index = color_index << info.tone_bits;
for (tone = 0; tone < info.n_tones; tone++)
E 84 {
D 84 tmsg_error("release_raster, missing buffer");
return;
E 84
I 84 magic_tone = custom_tone[tone] * MAGICFAC;
val.r = (UCHAR)((c_r * magic_tone + (1 << 23)) >> 24);
val.g = (UCHAR)((c_g * magic_tone + (1 << 23)) >> 24);
val.b = (UCHAR)((c_b * magic_tone + (1 << 23)) >> 24);
val.m = (UCHAR)((c_m * magic_tone + (1 << 23)) >> 24);
colbuffer[index++] = val;
E 84
}
D 84
release_memory_chunk(raster->native_buffer);
if (raster->type == RAS_CM16 && raster->cmap.buffer)
free(raster->cmap.buffer);
memset(raster, 0, sizeof(RASTER));
return;
}
/*-----------------------------------------------------------------*/
void create_raster(RASTER * raster, int xsize, int ysize,
RAS_TYPE type) {
int pixsize;
memset(raster, 0, sizeof(RASTER));
pixsize = rop_pixbytes(type);
if (!(raster->native_buffer =
get_memory_chunk(xsize * ysize * pixsize)))
tmsg_fatal("can't allocate %d Mbytes",
((xsize / 1024) * (ysize / 1024)) * pixsize);
raster->buffer = raster->native_buffer;
raster->type = type;
raster->wrap = raster->lx = xsize;
raster->ly = ysize;
return;
}
I 80
/*-----------------------------------------------------------------*/
int
create_subraster(RASTER * rin, RASTER * rout, int x0, int y0,
int x1, int y1) {
if (x1 < x0 || y1 < y0) return FALSE;
*rout = *rin;
if (x0 < 0) x0 = 0;
if (y0 < 0) y0 = 0;
if (x1 > rin->lx - 1) x1 = rin->lx - 1;
if (y1 > rin->ly - 1) y1 = rin->ly - 1;
rout->lx = x1 - x0 + 1;
rout->ly = y1 - y0 + 1;
rout->buffer = (UCHAR *)(rin->buffer) +
(y0 * rin->wrap + x0) * rop_pixbytes(rin->type);
return TRUE;
E 84
}
D 84
/*-----------------------------------------------------------------*/
E 84
I 84
/*---------------------------------------------------------------------------*/
E 84
D 84 void
clone_raster(RASTER * rin, RASTER * rout)
E 84
I 84 void
rop_custom_fill_cmap_penramp(
RASTER * ras, TCM_INFO info, LPIXEL pencil, int pencil_index,
int already_premultiplied, int *custom_tone)
E 84 {
D 84 create_raster(rout, rin->lx, rin->ly, rin->type);
rop_copy(rin, rout, 0, 0, rin->lx - 1, rin->ly - 1, 0, 0);
}
E 84
I 84 LPIXEL val, *penbuffer;
int index, enot;
UINT magic_enot, p_r, p_g, p_b, p_m;
E 84
I 84 if (!already_premultiplied)
D 88 pencil = premult(pencil);
E 88
I 88 pencil = rop_premult(pencil);
E 88
E 84
E 80
E 77
E 66
E 25
E 6
E 1
I 84 p_r = pencil.r;
p_g = pencil.g;
p_b = pencil.b;
p_m = pencil.m;
penbuffer = ras->cmap.penbuffer;
index = pencil_index << info.tone_bits;
for (enot = info.n_tones - 1; enot >= 0; enot--) {
magic_enot = custom_tone[enot] * MAGICFAC;
val.r = (UCHAR)((p_r * magic_enot + (1 << 23)) >> 24);
val.g = (UCHAR)((p_g * magic_enot + (1 << 23)) >> 24);
val.b = (UCHAR)((p_b * magic_enot + (1 << 23)) >> 24);
val.m = (UCHAR)((p_m * magic_enot + (1 << 23)) >> 24);
penbuffer[index++] = val;
}
}
/*---------------------------------------------------------------------------*/
void rop_fill_cmap_buffer(RASTER * ras, TCM_INFO info, LPIXEL * color,
LPIXEL * pencil, int already_premultiplied) {
int i, j;
for (i = 0; i < info.n_colors; i++)
for (j = 0; j < info.n_pencils; j++)
rop_fill_cmap_ramp(ras, info, color[i], pencil[j], i, j,
already_premultiplied);
}
/*---------------------------------------------------------------------------*/
void rop_fill_cmap_colbuffer(RASTER * ras, TCM_INFO info,
LPIXEL * color,
int already_premultiplied) {
int i;
for (i = 0; i < info.n_colors; i++)
rop_fill_cmap_colramp(ras, info, color[i], i,
already_premultiplied);
}
E 89
I 89
LPIXEL color, LPIXEL pencil,
int color_index, int pencil_index,
int already_premultiplied)
{
LPIXEL val, *ramp;
int ramp_index;
int c_r, c_g, c_b, c_m, p_r, p_g, p_b, p_m, d_r, d_g, d_b, d_m;
int tone, tmax, tmax_2;
int tmax_2_r, tmax_2_g, tmax_2_b, tmax_2_m;
ramp_index =
color_index << info.color_offs | pencil_index << info.pencil_offs;
ramp = ras->cmap.buffer + ramp_index;
if (!already_premultiplied) {
color = premult_lpixel(color);
pencil = premult_lpixel(pencil);
}
c_r = color.r;
p_r = pencil.r;
d_r = c_r - p_r;
c_g = color.g;
p_g = pencil.g;
d_g = c_g - p_g;
c_b = color.b;
p_b = pencil.b;
d_b = c_b - p_b;
D 94 c_m = color.m;
p_m = pencil.m;
d_m = c_m - p_m;
tmax = info.n_tones - 1;
tmax_2 = tmax >> 1;
tmax_2_r = d_r < 0 ? -tmax_2 : tmax_2;
E 94
I 94 c_m = color.m;
p_m = pencil.m;
d_m = c_m - p_m;
tmax = info.n_tones - 1;
tmax_2 = tmax >> 1;
tmax_2_r = d_r < 0 ? -tmax_2 : tmax_2;
E 94 tmax_2_g = d_g < 0 ? -tmax_2 : tmax_2;
tmax_2_b = d_b < 0 ? -tmax_2 : tmax_2;
tmax_2_m = d_m < 0 ? -tmax_2 : tmax_2;
ramp[0] = pencil;
for (tone = 1; tone < info.n_tones - 1; tone++) {
val.r = p_r + (d_r * tone + tmax_2_r) / tmax;
val.g = p_g + (d_g * tone + tmax_2_g) / tmax;
val.b = p_b + (d_b * tone + tmax_2_b) / tmax;
val.m = p_m + (d_m * tone + tmax_2_m) / tmax;
ramp[tone] = val;
}
ramp[info.n_tones - 1] = color;
}
/*---------------------------------------------------------------------------*/
void rop_fill_cmap_colramp(RASTER * ras, TCM_INFO info, LPIXEL color,
int color_index, int already_premultiplied) {
LPIXEL val, *colbuffer;
int index, tone;
UINT magic_tone, c_r, c_g, c_b, c_m;
if (!already_premultiplied) color = premult_lpixel(color);
c_r = color.r;
c_g = color.g;
c_b = color.b;
c_m = color.m;
colbuffer = ras->cmap.colbuffer;
index = color_index << info.tone_bits;
for (tone = 0; tone < info.n_tones; tone++) {
magic_tone = tone * MAGICFAC;
val.r = (UCHAR)((c_r * magic_tone + (1 << 23)) >> 24);
val.g = (UCHAR)((c_g * magic_tone + (1 << 23)) >> 24);
val.b = (UCHAR)((c_b * magic_tone + (1 << 23)) >> 24);
val.m = (UCHAR)((c_m * magic_tone + (1 << 23)) >> 24);
colbuffer[index++] = val;
}
}
/*---------------------------------------------------------------------------*/
void rop_fill_cmap_penramp(RASTER * ras, TCM_INFO info, LPIXEL pencil,
int pencil_index, int already_premultiplied) {
LPIXEL val, *penbuffer;
int index, enot;
UINT magic_enot, p_r, p_g, p_b, p_m;
if (!already_premultiplied) pencil = premult_lpixel(pencil);
p_r = pencil.r;
p_g = pencil.g;
p_b = pencil.b;
p_m = pencil.m;
penbuffer = ras->cmap.penbuffer;
index = pencil_index << info.tone_bits;
for (enot = info.n_tones - 1; enot >= 0; enot--) {
magic_enot = enot * MAGICFAC;
val.r = (UCHAR)((p_r * magic_enot + (1 << 23)) >> 24);
val.g = (UCHAR)((p_g * magic_enot + (1 << 23)) >> 24);
val.b = (UCHAR)((p_b * magic_enot + (1 << 23)) >> 24);
val.m = (UCHAR)((p_m * magic_enot + (1 << 23)) >> 24);
penbuffer[index++] = val;
}
}
/*---------------------------------------------------------------------------*/
void rop_custom_fill_cmap_ramp(RASTER * ras, TCM_INFO info, LPIXEL color,
LPIXEL pencil, int color_index, int pencil_index,
int already_premultiplied, int *custom_tone) {
LPIXEL val, *ramp;
int ramp_index;
int c_r, c_g, c_b, c_m, p_r, p_g, p_b, p_m, d_r, d_g, d_b, d_m;
int tone, tmax, tmax_2;
int tmax_2_r, tmax_2_g, tmax_2_b, tmax_2_m;
ramp_index =
color_index << info.color_offs | pencil_index << info.pencil_offs;
ramp = ras->cmap.buffer + ramp_index;
if (!already_premultiplied) {
color = premult_lpixel(color);
pencil = premult_lpixel(pencil);
}
c_r = color.r;
p_r = pencil.r;
d_r = c_r - p_r;
c_g = color.g;
p_g = pencil.g;
d_g = c_g - p_g;
c_b = color.b;
p_b = pencil.b;
d_b = c_b - p_b;
c_m = color.m;
p_m = pencil.m;
d_m = c_m - p_m;
tmax = info.n_tones - 1;
tmax_2 = tmax >> 1;
tmax_2_r = d_r < 0 ? -tmax_2 : tmax_2;
tmax_2_g = d_g < 0 ? -tmax_2 : tmax_2;
tmax_2_b = d_b < 0 ? -tmax_2 : tmax_2;
tmax_2_m = d_m < 0 ? -tmax_2 : tmax_2;
for (tone = 0; tone < info.n_tones; tone++) {
val.r = p_r + (d_r * custom_tone[tone] + tmax_2_r) / tmax;
val.g = p_g + (d_g * custom_tone[tone] + tmax_2_g) / tmax;
val.b = p_b + (d_b * custom_tone[tone] + tmax_2_b) / tmax;
val.m = p_m + (d_m * custom_tone[tone] + tmax_2_m) / tmax;
ramp[tone] = val;
}
}
/*---------------------------------------------------------------------------*/
void rop_custom_fill_cmap_colramp(RASTER * ras, TCM_INFO info, LPIXEL color,
int color_index, int already_premultiplied,
int *custom_tone) {
LPIXEL val, *colbuffer;
int index, tone;
UINT magic_tone, c_r, c_g, c_b, c_m;
if (!already_premultiplied) color = premult_lpixel(color);
c_r = color.r;
c_g = color.g;
c_b = color.b;
c_m = color.m;
colbuffer = ras->cmap.colbuffer;
index = color_index << info.tone_bits;
for (tone = 0; tone < info.n_tones; tone++) {
magic_tone = custom_tone[tone] * MAGICFAC;
val.r = (UCHAR)((c_r * magic_tone + (1 << 23)) >> 24);
val.g = (UCHAR)((c_g * magic_tone + (1 << 23)) >> 24);
val.b = (UCHAR)((c_b * magic_tone + (1 << 23)) >> 24);
val.m = (UCHAR)((c_m * magic_tone + (1 << 23)) >> 24);
colbuffer[index++] = val;
}
}
/*---------------------------------------------------------------------------*/
void rop_custom_fill_cmap_penramp(RASTER * ras, TCM_INFO info, LPIXEL pencil,
int pencil_index, int already_premultiplied,
int *custom_tone) {
LPIXEL val, *penbuffer;
int index, tone, maxtone;
UINT magic_enot, p_r, p_g, p_b, p_m;
if (!already_premultiplied) pencil = premult_lpixel(pencil);
p_r = pencil.r;
p_g = pencil.g;
p_b = pencil.b;
p_m = pencil.m;
penbuffer = ras->cmap.penbuffer;
index = pencil_index << info.tone_bits;
maxtone = info.n_tones - 1;
for (tone = 0; tone < info.n_tones; tone++) {
magic_enot = (maxtone - custom_tone[tone]) * MAGICFAC;
val.r = (UCHAR)((p_r * magic_enot + (1 << 23)) >> 24);
val.g = (UCHAR)((p_g * magic_enot + (1 << 23)) >> 24);
val.b = (UCHAR)((p_b * magic_enot + (1 << 23)) >> 24);
val.m = (UCHAR)((p_m * magic_enot + (1 << 23)) >> 24);
penbuffer[index++] = val;
}
}
/*---------------------------------------------------------------------------*/
void rop_fill_cmap_buffer(RASTER * ras, TCM_INFO info, LPIXEL * color,
LPIXEL * pencil, int already_premultiplied) {
int i, j;
for (i = 0; i < info.n_colors; i++)
for (j = 0; j < info.n_pencils; j++)
rop_fill_cmap_ramp(ras, info, color[i], pencil[j], i, j,
already_premultiplied);
}
/*---------------------------------------------------------------------------*/
void rop_fill_cmap_colbuffer(RASTER * ras, TCM_INFO info, LPIXEL * color,
int already_premultiplied) {
int i;
for (i = 0; i < info.n_colors; i++)
rop_fill_cmap_colramp(ras, info, color[i], i, already_premultiplied);
}
E 89
/*---------------------------------------------------------------------------*/
void
rop_fill_cmap_penbuffer(RASTER * ras, TCM_INFO info, LPIXEL * pencil,
int already_premultiplied) {
int i;
for (i = 0; i < info.n_pencils; i++)
rop_fill_cmap_penramp(ras, info, pencil[i], i, already_premultiplied);
}
/*---------------------------------------------------------------------------*/
void rop_custom_fill_cmap_buffer(RASTER * ras, TCM_INFO info, LPIXEL * color,
LPIXEL * pencil, int already_premultiplied,
int *custom_tone) {
int i, j;
for (i = 0; i < info.n_colors; i++)
for (j = 0; j < info.n_pencils; j++)
rop_custom_fill_cmap_ramp(ras, info, color[i], pencil[j], i, j,
already_premultiplied, custom_tone);
}
/*---------------------------------------------------------------------------*/
void rop_custom_fill_cmap_colbuffer(RASTER * ras, TCM_INFO info, LPIXEL * color,
int already_premultiplied,
int *custom_tone) {
int i;
for (i = 0; i < info.n_colors; i++)
rop_custom_fill_cmap_colramp(ras, info, color[i], i, already_premultiplied,
custom_tone);
}
/*---------------------------------------------------------------------------*/
void rop_custom_fill_cmap_penbuffer(RASTER * ras, TCM_INFO info,
LPIXEL * pencil, int already_premultiplied,
int *custom_tone) {
int i;
for (i = 0; i < info.n_pencils; i++)
rop_custom_fill_cmap_penramp(ras, info, pencil[i], i, already_premultiplied,
custom_tone);
}
/*---------------------------------------------------------------------------*/
void release_raster(RASTER * raster) {
D 89 if (!raster->native_buffer)
E 89
I 89 rop_clear_extra(raster);
if (!(raster->native_buffer || raster->buffer))
E 89 {
D 89 tmsg_error("release_raster, missing buffer");
return;
E 89
I 89 tmsg_error("release_raster, missing buffer");
return;
E 89
}
I 89 if (raster->native_buffer)
I 99 {
E 99 release_memory_chunk(raster->native_buffer);
I 99 MEMORY_PRINTF("libero %x\n", raster->native_buffer);
}
E 99 else I 99 {
E 99 release_memory_chunk(raster->buffer);
I 99 MEMORY_PRINTF("libero %x\n", raster->buffer);
}
E 99
E 89
D 89 release_memory_chunk(raster->native_buffer);
E 89 if (raster->type == RAS_CM16 && raster->cmap.buffer)
free(raster->cmap.buffer);
D 89
E 89
I 89 else if (raster->type == RAS_CM24 && raster->cmap.penbuffer) {
free(raster->cmap.penbuffer);
free(raster->cmap.colbuffer);
}
E 89 memset(raster, 0, sizeof(RASTER));
return;
}
D 89
/*-----------------------------------------------------------------*/
E 89
I 89
/*---------------------------------------------------------------------------*/
void
rop_clear_extra(RASTER * raster) {
if (raster->extra_mask && raster->type != RAS_CM24) {
if (!(raster->native_extra || raster->extra)) {
tmsg_error("release_extra, missing extra buffer");
return;
}
if (raster->native_extra)
I 99 {
E 99 release_memory_chunk(raster->native_extra);
I 99 MEMORY_PRINTF("libero extra %x\n", raster->native_extra);
}
E 99 else I 99 {
E 99 release_memory_chunk(raster->extra);
I 99 MEMORY_PRINTF("libero extra %x\n", raster->extra);
}
E 99
}
raster->extra_mask = 0;
}
/*---------------------------------------------------------------------------*/
void rop_clear_patches(RASTER * raster) {
raster->extra_mask &= ~7;
if (!raster->extra_mask) rop_clear_extra(raster);
}
/*---------------------------------------------------------------------------*/
void rop_clear_extra_but_not_patches(RASTER * raster) {
raster->extra_mask &= 7;
if (!raster->extra_mask) rop_clear_extra(raster);
}
E 89
I 89
/*---------------------------------------------------------------------------*/
E 89 void
create_raster(RASTER * raster, int xsize, int ysize, RAS_TYPE type) {
int pixsize;
memset(raster, 0, sizeof(RASTER));
pixsize = rop_pixbytes(type);
if (!(raster->native_buffer = get_memory_chunk(xsize * ysize * pixsize)))
D 86 tmsg_fatal("can't allocate %d Mbytes",
((xsize / 1024) * (ysize / 1024)) * pixsize);
E 86
I 86 tmsg_fatal("can't allocate %d Mbytes",
(xsize * ysize * pixsize + (512 * 1024)) / (1024 * 1024));
E 86
I 99 MEMORY_PRINTF("alloco %x: %dX%dX%d=%d bytes\n", raster->native_buffer,
xsize, ysize, pixsize, xsize * ysize * pixsize);
E 99 raster->buffer = raster->native_buffer;
raster->type = type;
raster->wrap = raster->lx = xsize;
raster->ly = ysize;
I 86 switch (type) {
CASE RAS_CM16 : raster->cmap.info = Tcm_new_default_info;
CASE RAS_CM24 : raster->cmap.info = Tcm_24_default_info;
}
E 86 return;
}
/*-----------------------------------------------------------------*/
D 89 int create_subraster(RASTER * rin, RASTER * rout, int x0, int y0, int x1,
int y1)
E 89
I 89 void
create_raster_with_extra(RASTER * raster, int xsize, int ysize, RAS_TYPE type,
UCHAR extra_mask) {
create_raster(raster, xsize, ysize, type);
raster->extra_mask = extra_mask;
if (extra_mask && type != RAS_CM24) {
if (!(raster->native_extra = get_memory_chunk(xsize * ysize)))
tmsg_fatal("can't allocate %d Mbytes",
(xsize * ysize + (512 * 1024)) / (1024 * 1024));
I 99 MEMORY_PRINTF("alloco extra %x: %dX%d=%d bytes\n",
raster->native_extra, xsize, ysize, xsize * ysize);
E 99 raster->extra = raster->native_extra;
}
}
/*-----------------------------------------------------------------*/
int create_subraster(RASTER * rin, RASTER * rout, int x0, int y0, int x1,
int y1)
E 89 {
if (x1 < x0 || y1 < y0) return FALSE;
*rout = *rin;
if (x0 < 0) x0 = 0;
if (y0 < 0) y0 = 0;
if (x1 > rin->lx - 1) x1 = rin->lx - 1;
if (y1 > rin->ly - 1) y1 = rin->ly - 1;
rout->lx = x1 - x0 + 1;
rout->ly = y1 - y0 + 1;
rout->buffer =
(UCHAR *)(rin->buffer) + (y0 * rin->wrap + x0) * rop_pixbytes(rin->type);
I 89 if (rin->extra) rout->extra = rin->extra + x0 + y0 * rin->wrap;
E 89 return TRUE;
}
/*-----------------------------------------------------------------*/
void clone_raster(RASTER * rin, RASTER * rout) {
I 91 int size;
E 91
D 89 create_raster(rout, rin->lx, rin->ly, rin->type);
I 85
E 89
I 89
D 90 create_raster_with_extra(rout, rin->lx, rin->ly, rin->type,
rin->extra_mask);
E 90
I 90
D 92 create_raster(rout, rin->lx, rin->ly, rin->type);
E 92
I 92 create_raster_with_extra(rout, rin->lx, rin->ly, rin->type,
rin->extra_mask);
E 92
E 90
E 89
E 85 rop_copy(rin, rout, 0, 0, rin->lx - 1, rin->ly - 1, 0, 0);
I 85 if (rin->type == RAS_CM16 || rin->type == RAS_CM24)
I 90 {
E 90 rout->cmap = rin->cmap;
I 90
D 91 TCALLOC(rout->cmap.buffer, TCM_CMAP_BUFFER_SIZE(rout->cmap.info));
memcpy(rout->cmap.buffer, rin->cmap.buffer,
TCM_CMAP_BUFFER_SIZE(rout->cmap.info));
if (rin->type == RAS_CM24)
E 91
I 91
if (rin->cmap.buffer)
E 91 {
D 91 if (rin->cmap.penbuffer) {
TCALLOC(rout->cmap.penbuffer,
TCM_CMAP_PENBUFFER_SIZE(rout->cmap.info));
memcpy(rout->cmap.penbuffer, rin->cmap.penbuffer,
TCM_CMAP_PENBUFFER_SIZE(rout->cmap.info));
}
if (rin->cmap.colbuffer) {
TCALLOC(rout->cmap.colbuffer,
TCM_CMAP_COLBUFFER_SIZE(rout->cmap.info));
memcpy(rout->cmap.colbuffer, rin->cmap.colbuffer,
TCM_CMAP_COLBUFFER_SIZE(rout->cmap.info));
}
E 91
I 91 size = TCM_CMAP_BUFFER_SIZE(rout->cmap.info);
TMALLOC(rout->cmap.buffer, size);
memcpy(rout->cmap.buffer, rin->cmap.buffer, size * sizeof(LPIXEL));
}
if (rin->cmap.penbuffer) {
size = TCM_CMAP_PENBUFFER_SIZE(rout->cmap.info);
TMALLOC(rout->cmap.penbuffer, size);
memcpy(rout->cmap.penbuffer, rin->cmap.penbuffer, size * sizeof(LPIXEL));
size = TCM_CMAP_COLBUFFER_SIZE(rout->cmap.info);
TMALLOC(rout->cmap.colbuffer, size);
memcpy(rout->cmap.colbuffer, rin->cmap.colbuffer, size * sizeof(LPIXEL));
E 91
}
}
E 90
E 85
}
I 87
/*-----------------------------------------------------------------*/
void
convert_raster(RASTER * r, RAS_TYPE type) {
RASTER raux;
if (r->type == type) return;
D 89 create_raster(&raux, r->lx, r->ly, type);
E 89
I 89 create_raster_with_extra(&raux, r->lx, r->ly, type, r->extra_mask);
E 89 rop_copy(r, &raux, 0, 0, r->lx - 1, r->ly - 1, 0, 0);
release_raster(r);
*r = raux;
}
I 98
/*-----------------------------------------------------------------*/
static UCHAR Reverse_lut[256];
static void init_reverse_lut(void) {
UCHAR meta_lut[] = {0x0, 0x8, 0x4, 0xc, 0x2, 0xa, 0x6, 0xe,
0x1, 0x9, 0x5, 0xd, 0x3, 0xb, 0x7, 0xf};
static int i = 0;
if (i == 256) return;
for (i = 0; i < 256; i++)
Reverse_lut[i] = (meta_lut[i & 0xf] << 4) | (meta_lut[i >> 4]);
}
/*------------------------------------------------------------------------*/
I 105 static void rop_mirror_v_cm16_rgbm(RASTER * rin, RASTER * rout) {
LPIXEL *rowout, *pixout, *cmap;
USHORT *rowin, *pixin;
int wrapin, wrapout;
int x, lx, ly;
cmap = rin->cmap.buffer - rin->cmap.info.offset_mask;
lx = rin->lx;
ly = rin->ly;
wrapin = rin->wrap;
wrapout = rout->wrap;
rowin = (USHORT *)rin->buffer;
rowout = (LPIXEL *)rout->buffer + wrapout * (ly - 1);
while (ly-- > 0) {
pixin = rowin;
pixout = rowout;
for (x = 0; x < lx; x++) *pixout++ = cmap[*pixin++];
rowin += wrapin;
rowout -= wrapout;
}
}
/*------------------------------------------------------------------------*/
static void rop_mirror_v_cm24_rgbm(RASTER * rin, RASTER * rout) {
LPIXEL *rowout, *pixout, valout, *penmap, *colmap;
ULONG *rowin, *pixin, valin;
UCHAR *exrow, *expix;
int wrapin, wrapout;
int x, lx, ly, lines;
penmap = rin->cmap.penbuffer;
colmap = rin->cmap.colbuffer;
lx = rin->lx;
ly = rin->ly;
lines = ly;
wrapin = rin->wrap;
wrapout = rout->wrap;
rowin = (ULONG *)rin->buffer;
rowout = (LPIXEL *)rout->buffer + wrapout * (ly - 1);
while (lines-- > 0) {
pixin = rowin;
pixout = rowout;
for (x = 0; x < lx; x++) {
valin = *pixin++;
MAP24(valin, penmap, colmap, valout)
*pixout++ = valout;
}
rowin += wrapin;
rowout -= wrapout;
}
}
/*------------------------------------------------------------------------*/
E 105 void rop_mirror(RASTER * rin, RASTER * rout, TBOOL is_vertical) {
UCHAR *buffer1, *buffer2, *auxbuf;
int bpp, lx, ly, wrapin, wrapout, scanline_in, scanline_out, lx_size;
int i, j;
lx = rin->lx;
ly = rin->ly;
wrapin = rin->wrap;
wrapout = rout->wrap;
I 105 if (rin->type == RAS_CM16 && rout->type == RAS_RGBM && is_vertical) {
rop_mirror_v_cm16_rgbm(rin, rout);
return;
}
if (rin->type == RAS_CM24 && rout->type == RAS_RGBM && is_vertical) {
rop_mirror_v_cm24_rgbm(rin, rout);
return;
}
E 105 assert(rin->type == rout->type);
bpp = rop_pixbytes(rin->type);
scanline_in = wrapin * bpp;
scanline_out = wrapout * bpp;
lx_size = lx * bpp;
D 100 if (rin->type == RAS_BW)
E 100
I 100 if ((rin->type == RAS_BW) || (rin->type == RAS_WB))
E 100 {
lx_size = (lx_size + 7) / 8;
scanline_in = (scanline_in + 7) / 8;
scanline_out = (scanline_out + 7) / 8;
if (!is_vertical) init_reverse_lut();
}
buffer1 = rin->buffer;
if (is_vertical)
D 105 {
E 105
I 105 {
E 105 buffer2 = (UCHAR *)rout->buffer + (ly - 1) * scanline_out;
TMALLOC(auxbuf, lx_size)
for (i = 0; i < ly / 2; i++) {
memcpy(auxbuf, buffer1, lx_size);
memcpy(buffer1, buffer2, lx_size);
memcpy(buffer2, auxbuf, lx_size);
buffer1 += scanline_in;
buffer2 -= scanline_out;
}
}
else {
buffer2 = (UCHAR *)rout->buffer + lx_size;
TMALLOC(auxbuf, bpp)
for (i = 0; i < ly; i++) {
for (j = 0; j < lx_size / 2; j += bpp) {
memcpy(auxbuf, buffer1 + j, bpp);
memcpy(buffer1 + j, buffer1 + lx_size - j - bpp, bpp);
memcpy(buffer2 - j - bpp, auxbuf, bpp);
if (rin->type == RAS_BW) {
buffer1[lx_size - j - bpp] =
Reverse_lut[buffer1[lx_size - j - bpp]];
buffer1[j] = Reverse_lut[buffer1[j]];
}
I 102 else if (rin->type == RAS_WB) {
buffer1[lx_size - j - bpp] =
~Reverse_lut[buffer1[lx_size - j - bpp]];
buffer1[j] = ~Reverse_lut[buffer1[j]];
}
E 102
}
buffer1 += scanline_in;
buffer2 += scanline_out;
}
}
free(auxbuf);
}
E 98
E 87
E 84