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