← Back to branch summary

~ubuntu-branches/ubuntu/breezy/gimp/breezy

« back to all changes in this revision

Viewing changes to plug-ins/faxg3/g3.c

  • Committer: Bazaar Package Importer
  • Author(s): Sebastien Bacher
  • Date: 2005-10-04 19:04:46 UTC
  • Revision ID: james.westby@ubuntu.com-20051004190446-ukh32kwk56s4sjhu
Tags: upstream-2.2.8
Import upstream version 2.2.8

Show diffs side-by-side

added added

removed removed

Lines of Context:
plug-ins/faxg3/g3.c
 
1
/* #ident "@(#)g3.c     3.1 95/08/30 Copyright (c) Gert Doering" */
 
2
 
 
3
#include "config.h"
 
4
 
 
5
#include <stdio.h>
 
6
#include <stdlib.h>
 
7
#ifdef HAVE_UNISTD_H
 
8
#include <unistd.h>
 
9
#endif
 
10
#include <sys/types.h>
 
11
#include <string.h>
 
12
 
 
13
#include "g3.h"
 
14
 
 
15
struct g3code t_white[66] = {
 
16
{ 0,   0, 0x0ac,  8 },
 
17
{ 0,   1, 0x038,  6 },
 
18
{ 0,   2, 0x00e,  4 },
 
19
{ 0,   3, 0x001,  4 },
 
20
{ 0,   4, 0x00d,  4 },
 
21
{ 0,   5, 0x003,  4 },
 
22
{ 0,   6, 0x007,  4 },
 
23
{ 0,   7, 0x00f,  4 },
 
24
{ 0,   8, 0x019,  5 },
 
25
{ 0,   9, 0x005,  5 },
 
26
{ 0,  10, 0x01c,  5 },
 
27
{ 0,  11, 0x002,  5 },
 
28
{ 0,  12, 0x004,  6 },
 
29
{ 0,  13, 0x030,  6 },
 
30
{ 0,  14, 0x00b,  6 },
 
31
{ 0,  15, 0x02b,  6 },
 
32
{ 0,  16, 0x015,  6 },
 
33
{ 0,  17, 0x035,  6 },
 
34
{ 0,  18, 0x072,  7 },
 
35
{ 0,  19, 0x018,  7 },
 
36
{ 0,  20, 0x008,  7 },
 
37
{ 0,  21, 0x074,  7 },
 
38
{ 0,  22, 0x060,  7 },
 
39
{ 0,  23, 0x010,  7 },
 
40
{ 0,  24, 0x00a,  7 },
 
41
{ 0,  25, 0x06a,  7 },
 
42
{ 0,  26, 0x064,  7 },
 
43
{ 0,  27, 0x012,  7 },
 
44
{ 0,  28, 0x00c,  7 },
 
45
{ 0,  29, 0x040,  8 },
 
46
{ 0,  30, 0x0c0,  8 },
 
47
{ 0,  31, 0x058,  8 },
 
48
{ 0,  32, 0x0d8,  8 },
 
49
{ 0,  33, 0x048,  8 },
 
50
{ 0,  34, 0x0c8,  8 },
 
51
{ 0,  35, 0x028,  8 },
 
52
{ 0,  36, 0x0a8,  8 },
 
53
{ 0,  37, 0x068,  8 },
 
54
{ 0,  38, 0x0e8,  8 },
 
55
{ 0,  39, 0x014,  8 },
 
56
{ 0,  40, 0x094,  8 },
 
57
{ 0,  41, 0x054,  8 },
 
58
{ 0,  42, 0x0d4,  8 },
 
59
{ 0,  43, 0x034,  8 },
 
60
{ 0,  44, 0x0b4,  8 },
 
61
{ 0,  45, 0x020,  8 },
 
62
{ 0,  46, 0x0a0,  8 },
 
63
{ 0,  47, 0x050,  8 },
 
64
{ 0,  48, 0x0d0,  8 },
 
65
{ 0,  49, 0x04a,  8 },
 
66
{ 0,  50, 0x0ca,  8 },
 
67
{ 0,  51, 0x02a,  8 },
 
68
{ 0,  52, 0x0aa,  8 },
 
69
{ 0,  53, 0x024,  8 },
 
70
{ 0,  54, 0x0a4,  8 },
 
71
{ 0,  55, 0x01a,  8 },
 
72
{ 0,  56, 0x09a,  8 },
 
73
{ 0,  57, 0x05a,  8 },
 
74
{ 0,  58, 0x0da,  8 },
 
75
{ 0,  59, 0x052,  8 },
 
76
{ 0,  60, 0x0d2,  8 },
 
77
{ 0,  61, 0x04c,  8 },
 
78
{ 0,  62, 0x0cc,  8 },
 
79
{ 0,  63, 0x02c,  8 },
 
80
{ 0, -1, 0, 11 },               /* 11 0-bits == EOL, special handling */
 
81
{ 0, -1, 0, 0 }};               /* end of table */
 
82
 
 
83
/* make-up codes white */
 
84
struct g3code m_white[28] = {
 
85
{ 0,  64, 0x01b,  5 },
 
86
{ 0, 128, 0x009,  5 },
 
87
{ 0, 192, 0x03a,  6 },
 
88
{ 0, 256, 0x076,  7 },
 
89
{ 0, 320, 0x06c,  8 },
 
90
{ 0, 384, 0x0ec,  8 },
 
91
{ 0, 448, 0x026,  8 },
 
92
{ 0, 512, 0x0a6,  8 },
 
93
{ 0, 576, 0x016,  8 },
 
94
{ 0, 640, 0x0e6,  8 },
 
95
{ 0, 704, 0x066,  9 },
 
96
{ 0, 768, 0x166,  9 },
 
97
{ 0, 832, 0x096,  9 },
 
98
{ 0, 896, 0x196,  9 },
 
99
{ 0, 960, 0x056,  9 },
 
100
{ 0,1024, 0x156,  9 },
 
101
{ 0,1088, 0x0d6,  9 },
 
102
{ 0,1152, 0x1d6,  9 },
 
103
{ 0,1216, 0x036,  9 },
 
104
{ 0,1280, 0x136,  9 },
 
105
{ 0,1344, 0x0b6,  9 },
 
106
{ 0,1408, 0x1b6,  9 },
 
107
{ 0,1472, 0x032,  9 },
 
108
{ 0,1536, 0x132,  9 },
 
109
{ 0,1600, 0x0b2,  9 },
 
110
{ 0,1664, 0x006,  6 },
 
111
{ 0,1728, 0x1b2,  9 },
 
112
{ 0,  -1, 0, 0} };
 
113
 
 
114
 
 
115
struct g3code t_black[66] = {
 
116
{ 0,   0, 0x3b0, 10 },
 
117
{ 0,   1, 0x002,  3 },
 
118
{ 0,   2, 0x003,  2 },
 
119
{ 0,   3, 0x001,  2 },
 
120
{ 0,   4, 0x006,  3 },
 
121
{ 0,   5, 0x00c,  4 },
 
122
{ 0,   6, 0x004,  4 },
 
123
{ 0,   7, 0x018,  5 },
 
124
{ 0,   8, 0x028,  6 },
 
125
{ 0,   9, 0x008,  6 },
 
126
{ 0,  10, 0x010,  7 },
 
127
{ 0,  11, 0x050,  7 },
 
128
{ 0,  12, 0x070,  7 },
 
129
{ 0,  13, 0x020,  8 },
 
130
{ 0,  14, 0x0e0,  8 },
 
131
{ 0,  15, 0x030,  9 },
 
132
{ 0,  16, 0x3a0, 10 },
 
133
{ 0,  17, 0x060, 10 },
 
134
{ 0,  18, 0x040, 10 },
 
135
{ 0,  19, 0x730, 11 },
 
136
{ 0,  20, 0x0b0, 11 },
 
137
{ 0,  21, 0x1b0, 11 },
 
138
{ 0,  22, 0x760, 11 },
 
139
{ 0,  23, 0x0a0, 11 },
 
140
{ 0,  24, 0x740, 11 },
 
141
{ 0,  25, 0x0c0, 11 },
 
142
{ 0,  26, 0x530, 12 },
 
143
{ 0,  27, 0xd30, 12 },
 
144
{ 0,  28, 0x330, 12 },
 
145
{ 0,  29, 0xb30, 12 },
 
146
{ 0,  30, 0x160, 12 },
 
147
{ 0,  31, 0x960, 12 },
 
148
{ 0,  32, 0x560, 12 },
 
149
{ 0,  33, 0xd60, 12 },
 
150
{ 0,  34, 0x4b0, 12 },
 
151
{ 0,  35, 0xcb0, 12 },
 
152
{ 0,  36, 0x2b0, 12 },
 
153
{ 0,  37, 0xab0, 12 },
 
154
{ 0,  38, 0x6b0, 12 },
 
155
{ 0,  39, 0xeb0, 12 },
 
156
{ 0,  40, 0x360, 12 },
 
157
{ 0,  41, 0xb60, 12 },
 
158
{ 0,  42, 0x5b0, 12 },
 
159
{ 0,  43, 0xdb0, 12 },
 
160
{ 0,  44, 0x2a0, 12 },
 
161
{ 0,  45, 0xaa0, 12 },
 
162
{ 0,  46, 0x6a0, 12 },
 
163
{ 0,  47, 0xea0, 12 },
 
164
{ 0,  48, 0x260, 12 },
 
165
{ 0,  49, 0xa60, 12 },
 
166
{ 0,  50, 0x4a0, 12 },
 
167
{ 0,  51, 0xca0, 12 },
 
168
{ 0,  52, 0x240, 12 },
 
169
{ 0,  53, 0xec0, 12 },
 
170
{ 0,  54, 0x1c0, 12 },
 
171
{ 0,  55, 0xe40, 12 },
 
172
{ 0,  56, 0x140, 12 },
 
173
{ 0,  57, 0x1a0, 12 },
 
174
{ 0,  58, 0x9a0, 12 },
 
175
{ 0,  59, 0xd40, 12 },
 
176
{ 0,  60, 0x340, 12 },
 
177
{ 0,  61, 0x5a0, 12 },
 
178
{ 0,  62, 0x660, 12 },
 
179
{ 0,  63, 0xe60, 12 },
 
180
{ 0,  -1, 0x000, 11 },
 
181
{ 0,  -1, 0, 0 } };
 
182
 
 
183
struct g3code m_black[28] = {
 
184
{ 0,  64, 0x3c0, 10 },
 
185
{ 0, 128, 0x130, 12 },
 
186
{ 0, 192, 0x930, 12 },
 
187
{ 0, 256, 0xda0, 12 },
 
188
{ 0, 320, 0xcc0, 12 },
 
189
{ 0, 384, 0x2c0, 12 },
 
190
{ 0, 448, 0xac0, 12 },
 
191
{ 0, 512, 0x6c0, 13 },
 
192
{ 0, 576,0x16c0, 13 },
 
193
{ 0, 640, 0xa40, 13 },
 
194
{ 0, 704,0x1a40, 13 },
 
195
{ 0, 768, 0x640, 13 },
 
196
{ 0, 832,0x1640, 13 },
 
197
{ 0, 896, 0x9c0, 13 },
 
198
{ 0, 960,0x19c0, 13 },
 
199
{ 0,1024, 0x5c0, 13 },
 
200
{ 0,1088,0x15c0, 13 },
 
201
{ 0,1152, 0xdc0, 13 },
 
202
{ 0,1216,0x1dc0, 13 },
 
203
{ 0,1280, 0x940, 13 },
 
204
{ 0,1344,0x1940, 13 },
 
205
{ 0,1408, 0x540, 13 },
 
206
{ 0,1472,0x1540, 13 },
 
207
{ 0,1536, 0xb40, 13 },
 
208
{ 0,1600,0x1b40, 13 },
 
209
{ 0,1664, 0x4c0, 13 },
 
210
{ 0,1728,0x14c0, 13 },
 
211
{ 0,  -1, 0, 0 } };
 
212
 
 
213
void tree_add_node( struct g3_tree *p, struct g3code * g3c,
 
214
                        int bit_code, int bit_length )
 
215
{
 
216
int i;
 
217
 
 
218
    if ( bit_length <= FBITS )          /* leaf (multiple bits) */
 
219
    {
 
220
        g3c->nr_bits = bit_length;      /* leaf tag */
 
221
 
 
222
        if ( bit_length == FBITS )      /* full width */
 
223
        {
 
224
            p->nextb[ bit_code ] = (struct g3_tree *) g3c;
 
225
        }
 
226
        else                            /* fill bits */
 
227
          for ( i=0; i< ( 1 << (FBITS-bit_length)); i++ )
 
228
          {
 
229
            p->nextb[ bit_code + ( i << bit_length ) ] = (struct g3_tree *) g3c;
 
230
          }
 
231
    }
 
232
    else                                /* node */
 
233
    {
 
234
    struct g3_tree *p2;
 
235
 
 
236
        p2 = p->nextb[ bit_code & BITM ];
 
237
        if ( p2 == 0 )                  /* no sub-node exists */
 
238
        {
 
239
            p2 = p->nextb[ bit_code & BITM ] =
 
240
                ( struct g3_tree * ) calloc( 1, sizeof( struct g3_tree ));
 
241
            if ( p2 == NULL ) { perror( "malloc 3" ); exit(11); }
 
242
            p2->nr_bits = 0;            /* node tag */
 
243
 
 
244
        }
 
245
        if ( p2->nr_bits != 0 )
 
246
        {
 
247
            fprintf( stderr, "internal table setup error\n" ); exit(6);
 
248
        }
 
249
        tree_add_node( p2, g3c, bit_code >> FBITS, bit_length - FBITS );
 
250
    }
 
251
}
 
252
 
 
253
void build_tree (struct g3_tree ** p, struct g3code * c )
 
254
{
 
255
    if ( *p == NULL )
 
256
    {
 
257
        (*p) = (struct g3_tree *) calloc( 1, sizeof(struct g3_tree) );
 
258
        if ( *p == NULL ) { perror( "malloc(1)" ); exit(10); }
 
259
 
 
260
        (*p)->nr_bits=0;
 
261
    }
 
262
 
 
263
    while ( c->bit_length != 0 )
 
264
    {
 
265
        tree_add_node( *p, c, c->bit_code, c->bit_length );
 
266
        c++;
 
267
    }
 
268
}
 
269
 
 
270
void init_byte_tab (int reverse, int byte_tab[] )
 
271
{
 
272
int i;
 
273
    if ( reverse ) for ( i=0; i<256; i++ ) byte_tab[i] = i;
 
274
    else
 
275
      for ( i=0; i<256; i++ )
 
276
             byte_tab[i] = ( ((i & 0x01) << 7) | ((i & 0x02) << 5) |
 
277
                             ((i & 0x04) << 3) | ((i & 0x08) << 1) |
 
278
                             ((i & 0x10) >> 1) | ((i & 0x20) >> 3) |
 
279
                             ((i & 0x40) >> 5) | ((i & 0x80) >> 7) );
 
280
}