![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to encode.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / contrib / isode-beta / others / quipu / photo|
Return to encode.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / isode-beta / others / quipu / photo |
1.1 root 1: /* encode.c - implement encoding routines */
2:
3: #ifndef lint
4: static char *rcsid = "$Header: /f/osi/others/quipu/photo/RCS/encode.c,v 7.1 90/07/09 14:40:25 mrose Exp $";
5: #endif
6:
7: /*
8: * $Header: /f/osi/others/quipu/photo/RCS/encode.c,v 7.1 90/07/09 14:40:25 mrose Exp $
9: *
10: *
11: * $Log: encode.c,v $
12: * Revision 7.1 90/07/09 14:40:25 mrose
13: * sync
14: *
15: * Revision 7.0 89/11/23 22:01:39 mrose
16: * Release 6.0
17: *
18: */
19:
20: /*
21: * NOTICE
22: *
23: * Acquisition, use, and distribution of this module and related
24: * materials are subject to the restrictions of a license agreement.
25: * Consult the Preface in the User's Manual for the full terms of
26: * this agreement.
27: *
28: */
29:
30:
31:
32: #include <stdio.h>
33: #include "quipu/photo.h"
34:
35: extern int PIC_LINESIZE,STOP,NUMLINES;
36:
37: int a0, a1, b1, b2; /* markers */
38: int optlen;
39:
40: char * malloc();
41:
42:
43: /* ROUTINE: encode_t4
44: /*
45: /* SYNOPSIS: Implements CCITT recommendation T.4.
46: /* This recomendation is concerned with compressing of bit maps.
47: /*
48: /* DESCRIPTION:
49: /* This routine sets up the data buffers, then calls routines
50: /* to encode one line of the bit map. A line can be encoded either one
51: /* dimensionally or two dimensionally depending upon the 'k parameter'.
52: /* When a line is encode two dimensionally, the line before is used as a
53: /* reference. For each line encoded a record of where the run changes occur
54: /* are kept. this is the used as the reference.
55: /*
56: */
57:
58:
59: char * encode_t4 (k_param,inbuf, eolnskip)
60: int k_param;
61: char * inbuf;
62: int eolnskip;
63:
64: {
65: bit_string ref_line; /* Reference line */
66: bit_string t4_line; /* Output encoded line */
67: bit_string code_line; /* Line we are codeing */
68:
69: short i,j; /* Loop variable */
70: int run_buf [LINEBUF], run_buf2 [LINEBUF];
71:
72:
73: ref_line.run_top = run_buf;
74: code_line.run_top = run_buf2;
75:
76: code_line.dbuf_top = inbuf;
77: t4_line.dbuf_top = malloc (PIC_LINESIZE * NUMLINES);
78:
79: set_input (&code_line);
80: set_output (&t4_line);
81:
82: /* Repeat this loop once for every input line expected */
83: for (i=0; i< NUMLINES; i++) {
84:
85: put_eoln (&t4_line); /* eoln marker before each new data line */
86: if (code_line.run_top == run_buf) { /*swap buffers*/
87: ref_line.run_top = run_buf;
88: code_line.run_top = run_buf2;
89: } else {
90: ref_line.run_top = run_buf2;
91: code_line.run_top = run_buf;
92: }
93:
94: /* reset pointers */
95: code_line.run_pos = code_line.run_top;
96: ref_line.run_pos = ref_line.run_top;
97:
98: /* fill buffer for coding line */
99:
100: get_runs (&code_line);
101: code_line.run_pos = code_line.run_top;
102:
103: if (i % k_param == 0) {
104: set_bit (&t4_line); /* tag bit, 1-d line follows */
105: code_one (&code_line,&t4_line);
106:
107: } else {
108: clr_bit (&t4_line); /* tag bit, 2-d line follows */
109: code_two (&ref_line,&code_line,&t4_line);
110: }
111: /* skip any extra eoln bit in orig data */
112: for (j=0;j<eolnskip;j++)
113: get_bit (&code_line);
114:
115: }
116: /* now finish as per X409 */
117: put_eoln (&t4_line);
118: set_bit (&t4_line);
119: put_eoln (&t4_line);
120: set_bit (&t4_line);
121: put_eoln (&t4_line);
122: set_bit (&t4_line);
123: put_eoln (&t4_line);
124: set_bit (&t4_line);
125: put_eoln (&t4_line);
126: set_bit (&t4_line);
127: put_eoln (&t4_line);
128: set_bit (&t4_line);
129:
130: /* flush buffers, write length */
131: flush_output (&t4_line);
132: return (t4_line.dbuf_top);
133: }
134:
135:
136:
137: /* ROUTINE: code_one
138: /*
139: /* SYNOPSIS: codes one line of a bit map into t4
140: /*
141: /* DESCRIPTION:
142: /* To encode a line one dimensionally, bits are read in until
143: /* a change is noticed, when this happens, the run_length code for the number
144: /* of bits read in is found, and written to the output file.
145: /* A run_length code may consist of two parts if the run is large, a make up
146: /* and a terminal code.
147: */
148:
149: code_one (lineptr,t4_lineptr)
150:
151: bit_string * lineptr; /* input line */
152: bit_string * t4_lineptr; /* output line */
153:
154: {
155: char colour = WHITE; /* the colour of the current bit */
156: full_code code; /* the code for the characters run_length */
157: int old_pos = 1; /* the number of bits of the same colur read in */
158:
159:
160: do {
161: /* get code for next run = pos of current change - pos of last change */
162: code = get_code (*++lineptr->run_pos - old_pos,colour);
163:
164: if (code.make.length != 0)
165: put_code (t4_lineptr,code.make); /* the make code */
166: put_code (t4_lineptr, code.term); /* the terminal code */
167: colour = 1 - colour;
168: old_pos = *lineptr->run_pos;
169:
170: } while (*lineptr->run_pos <= PIC_LINESIZE);
171: }
172:
173:
174:
175:
176:
177:
178: /* ROUTINE: code_two
179: /*
180: /* SYNOPSIS: Codes one line of a bit map two dimensionally as
181: /* described by CCITT T.4.
182: /*
183: /* DESCRIPTION: Two lines are compared by looking at the list of run changes.
184: /* In order to do this, this list has to be created for the line we are about
185: /* to encode. The encoding procedure then follows the flow chart in the CCITT
186: /* recommendation.
187: /* That is summarised as follows, find the positions a0,a1,b1,b2, the compare
188: /* the to see which mode is required. The positions of a1,b1,b2 are found from
189: /* the run change list. a0 is known in advance.
190: */
191:
192: code_two (ref_lineptr,code_lineptr,t4_lineptr)
193:
194: bit_string * ref_lineptr; /* reference line */
195: bit_string * code_lineptr; /* line to encode */
196: bit_string * t4_lineptr; /* output line */
197:
198: {
199: char colour = WHITE;
200: char ref_colour = WHITE;
201:
202: a0 = 0;
203: code_lineptr->run_pos = code_lineptr->run_top;
204:
205: do {
206: /* move all pointers to be level with a0 to start keeping colour */
207: /* variables up to date. Move past a0, then move back, this ensures*/
208: /* we are at the change immediately before a0 */
209:
210: if ( *(code_lineptr->run_pos) > a0)
211: while ( *(--code_lineptr->run_pos) > a0 )
212: ;
213:
214: if ( *ref_lineptr->run_pos < a0 )
215: do
216: ref_colour = 1 - ref_colour;
217: while (*++ref_lineptr->run_pos < a0) ;
218:
219: if ( *(ref_lineptr->run_pos) > a0)
220: do
221: ref_colour = 1-ref_colour;
222: while ( *(--ref_lineptr->run_pos) > a0 ) ;
223:
224: /* find a1 */
225: a1 = *(++code_lineptr->run_pos);
226: if (a1 >= STOP)
227: code_lineptr->run_pos--;
228:
229: if (ref_colour != colour) {
230: ref_lineptr->run_pos++;
231: ref_colour = 1 - ref_colour;
232: }
233:
234: /* find b1 */
235: b1 = *(++ref_lineptr->run_pos);
236: if (b1 >= STOP) {
237: ref_lineptr->run_pos--;
238: ref_colour = 1 - ref_colour;
239: b2 = STOP;
240:
241: } else {
242: /* find b2 */
243: b2 = *(++ref_lineptr->run_pos);
244: if (b2 >= STOP) {
245: ref_lineptr->run_pos--;
246: ref_colour = 1 - ref_colour;
247: }
248: }
249:
250: /* select mode and code it */
251: if (a1 >= STOP) {
252: a0=STOP; /* to stop loop */
253: }
254: else {
255: if (a1 > b2)
256: pass_mode (t4_lineptr);
257:
258: else {
259: if (abs (a1-b1) <= 3) {
260: vertical_mode (t4_lineptr);
261: colour = 1 - colour;
262:
263: } else
264: horizontal_mode (code_lineptr,t4_lineptr,colour);
265: }
266: }
267: } while (a0 < STOP );
268:
269: }
270:
271:
272: /* ROUTINE: Pass_mode
273: /*
274: /* SYNOPSIS: Encodes pass_mode
275: /*
276: /* DESCRIPTION: When pass mode is detected, the pass mode code is written to
277: /* the output, and a0 is moved to underneath b2.
278: */
279:
280: pass_mode (t4_lineptr)
281: bit_string * t4_lineptr;
282:
283: {
284: static code_word code = {4,0x0200};
285: put_code (t4_lineptr,code);
286: a0 = b2;
287: }
288:
289:
290: /* ROUTINE: Vertical_mode
291: /*
292: /* SYNOPSIS: Encodes vertical mode.
293: /*
294: /* DESCRIPTION: Vertical mode is encoded by writing a particualr code
295: /* depending on the offset between a1 and b1.
296: /* a0 is moved to a1
297: */
298:
299: vertical_mode (t4_lineptr)
300:
301: bit_string * t4_lineptr;
302:
303: {
304: static code_word code [7] = {
305: {7,0x080 }, /* -3 */
306: {6,0x100 }, /* -2 */
307: {3,0x800 }, /* -1 */
308: {1,0x1000 }, /* 0 */
309: {3,0xc00 }, /* 1 */
310: {6,0x180 }, /* 2 */
311: {7,0xc0 }, /* 3 */
312: };
313: put_code (t4_lineptr, code [a1-b1+3]);
314:
315: a0 = a1;
316: }
317:
318:
319:
320:
321: /* ROUTINE: Horizontal_mode
322: /*
323: /* SYNOPSIS: Encodes horizontal mode
324: /*
325: /* DESCRIPTION: When horizontal mode is detected no further compaction can
326: /* can take place, so the next two run lengths are written to the output.
327: /* a0 is moved to after these runs.
328: */
329:
330: horizontal_mode (code_lineptr,t4_lineptr,colour)
331:
332: bit_string * t4_lineptr;
333: bit_string * code_lineptr;
334: char colour;
335:
336: {
337: int a2;
338: static code_word h_code = {3,0x0400};
339: full_code code;
340:
341: if (a0 == 0) /* special case at start of line */
342: a0 = 1;
343:
344: /* find a2 */
345: a2 = *(++code_lineptr->run_pos);
346: if (a2 >= STOP)
347: code_lineptr->run_pos--;
348:
349: put_code (t4_lineptr,h_code); /* code for horiz mode */
350:
351: /* get & put first run */
352: code = get_code (a1-a0,colour);
353: if (code.make.length != 0)
354: put_code (t4_lineptr,code.make);
355: put_code (t4_lineptr,code.term);
356:
357: /* get & put second run */
358: code = get_code (a2-a1,1-colour);
359: if (code.make.length != 0)
360: put_code (t4_lineptr,code.make);
361: put_code (t4_lineptr,code.term);
362:
363: a0=a2;
364: }
365:
366:
367: /* ROUTINE: Put_code () */
368: /* */
369: /* SYNOPSIS: appends the code word to the 'line'. */
370: /* */
371:
372: put_code (lineptr,code)
373:
374: bit_string * lineptr;
375: code_word code;
376: {
377:
378: int i;
379: short mask;
380:
381: mask = MSB_MASK; /* set mask to first bit of pattern */
382:
383: for (i=0; i< code.length ; i++) {
384: if ((code.pattern & mask) == WHITE)
385: clr_bit (lineptr);
386: else
387: set_bit (lineptr);
388:
389: mask >>= 1;
390: }
391: }
392:
393:
394:
395:
396: /* ROUTINE: put_eoln */
397: /* */
398: /* SYNOPSIS: Puts an end of line marker at the end of a t4 line. */
399: /* An end of line (eoln) marker is 11 (or more) zero's */
400: /* followed by a 1. */
401:
402: put_eoln (lineptr)
403:
404: bit_string * lineptr;
405:
406: {
407: int i;
408:
409: for (i=0 ; i< 11; i++)
410: clr_bit (lineptr);
411:
412: set_bit (lineptr);
413:
414: }
415:
416:
417:
418: /* ROUTINE: get_runs
419: *
420: * SYNOPSIS: set the runs change buffer fo the next input line
421: *
422: * DESCRIPTION: To optimise the input process, sequences of all 1's or 0's
423: * - the most likely combinations are looked for as special cases, if not
424: * found the runs are counted as bits.
425: *
426: */
427:
428: get_runs (lineptr)
429: bit_string * lineptr;
430:
431: {
432: register i,j;
433: char colour = WHITE;
434:
435: *lineptr->run_pos++ = 0;
436:
437: for (i=1; i <= PIC_LINESIZE; i++)
438: if (get_bit (lineptr) != colour) {
439: *(lineptr->run_pos++) = i;
440: colour = 1 - colour;
441: }
442:
443: *lineptr->run_pos++ = STOP;
444: *lineptr->run_pos = STOP;
445:
446: }
447:
448: /* ROUTINE: set_output;
449: *
450: * SYNOPSIS: Initialises the output buffers, writes the ENODE id, and
451: * leaves room for the length (to be filled in later);
452: */
453:
454: set_output (lineptr)
455: bit_string * lineptr;
456: {
457: lineptr->dbuf_top += 5; /* leave room for length and id char*/
458: lineptr->dbuf = lineptr->dbuf_top;
459:
460: lineptr->mask = BIT_MASK;
461: }
462:
463:
464:
465: /* ROUTINE: flush_output;
466: /*
467: /* SYNOPSIS: flush the output buffer, and set file length;
468: */
469:
470: flush_output (lineptr)
471: bit_string * lineptr;
472: {
473: long length, len;
474: int count = 0,i;
475:
476: if ( lineptr->mask != BIT_MASK ) /* writes last char if necessary */
477: lineptr->dbuf++;
478:
479: /* find and write length */
480: len = length = lineptr->dbuf - lineptr->dbuf_top;
481:
482: if (length <= 127) { /* short form length */
483: *(--lineptr->dbuf_top) = length;
484: *(--lineptr->dbuf_top) = 0x03; /* bit map id */
485: optlen = length + 2;
486: }
487: else {
488: /* see how many bytes needed for length */
489: while (len != 0)
490: {
491: len >>= 8;
492: count++;
493: }
494:
495: /* go back and write this info */
496:
497:
498: for (i=0;i<count;i++)
499: *(--lineptr->dbuf_top) = (length >> (8 * i));
500:
501: *(--lineptr->dbuf_top) = 0x80 + count; /* length marker*/
502: *(--lineptr->dbuf_top) = 0x03; /* bit map id */
503:
504: optlen = length + count + 1;
505: }
506: }
507:
508:
509: /* ROUTINE: set_input;
510: /*
511: /* SYNOPSIS: Initialises the input buffers
512: */
513:
514: set_input (lineptr)
515: bit_string * lineptr;
516: {
517: lineptr->mask = BIT_MASK;
518: lineptr->dbuf = lineptr->dbuf_top;
519: lineptr->pos = *lineptr->dbuf++;
520: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.