1 /* 8 bit decoding routines */
8 static void dispatchDecoder(unsigned char **pFrame, unsigned char codeType, unsigned char **pData, int *pDataRemain, int *curXb, int *curYb);
10 void decodeFrame8(unsigned char *pFrame, unsigned char *pMap, int mapRemain, unsigned char *pData, int dataRemain)
19 for (i=0; i<xb/2; i++)
21 dispatchDecoder(&pFrame, (*pMap) & 0xf, &pData, &dataRemain, &i, &j);
22 if (pFrame < (unsigned char *)g_vBackBuf1)
23 fprintf(stderr, "danger! pointing out of bounds below after dispatch decoder: %d, %d (1) [%x]\n", i, j, (*pMap) & 0xf);
24 else if (pFrame >= ((unsigned char *)g_vBackBuf1) + g_width*g_height)
25 fprintf(stderr, "danger! pointing out of bounds above after dispatch decoder: %d, %d (1) [%x]\n", i, j, (*pMap) & 0xf);
26 dispatchDecoder(&pFrame, (*pMap) >> 4, &pData, &dataRemain, &i, &j);
27 if (pFrame < (unsigned char *)g_vBackBuf1)
28 fprintf(stderr, "danger! pointing out of bounds below after dispatch decoder: %d, %d (2) [%x]\n", i, j, (*pMap) >> 4);
29 else if (pFrame >= ((unsigned char *)g_vBackBuf1) + g_width*g_height)
30 fprintf(stderr, "danger! pointing out of bounds above after dispatch decoder: %d, %d (2) [%x]\n", i, j, (*pMap) >> 4);
40 static void relClose(int i, int *x, int *y)
51 static void relFar(int i, int sign, int *x, int *y)
55 *x = sign * (8 + (i % 7));
60 *x = sign * (-14 + (i - 56) % 29);
61 *y = sign * (8 + (i - 56) / 29);
65 /* copies an 8x8 block from pSrc to pDest.
66 pDest and pSrc are both g_width bytes wide */
67 static void copyFrame(unsigned char *pDest, unsigned char *pSrc)
73 memcpy(pDest, pSrc, 8);
79 // Fill in the next eight bytes with p[0], p[1], p[2], or p[3],
80 // depending on the corresponding two-bit value in pat0 and pat1
81 static void patternRow4Pixels(unsigned char *pFrame,
82 unsigned char pat0, unsigned char pat1,
85 unsigned short mask=0x0003;
86 unsigned short shift=0;
87 unsigned short pattern = (pat1 << 8) | pat0;
91 *pFrame++ = p[(mask & pattern) >> shift];
97 // Fill in the next four 2x2 pixel blocks with p[0], p[1], p[2], or p[3],
98 // depending on the corresponding two-bit value in pat0.
99 static void patternRow4Pixels2(unsigned char *pFrame,
103 unsigned char mask=0x03;
104 unsigned char shift=0;
109 pel = p[(mask & pat0) >> shift];
112 pFrame[g_width + 0] = pel;
113 pFrame[g_width + 1] = pel;
120 // Fill in the next four 2x1 pixel blocks with p[0], p[1], p[2], or p[3],
121 // depending on the corresponding two-bit value in pat.
122 static void patternRow4Pixels2x1(unsigned char *pFrame, unsigned char pat, unsigned char *p)
124 unsigned char mask=0x03;
125 unsigned char shift=0;
130 pel = p[(mask & pat) >> shift];
139 // Fill in the next 4x4 pixel block with p[0], p[1], p[2], or p[3],
140 // depending on the corresponding two-bit value in pat0, pat1, pat2, and pat3.
141 static void patternQuadrant4Pixels(unsigned char *pFrame, unsigned char pat0, unsigned char pat1, unsigned char pat2, unsigned char pat3, unsigned char *p)
143 unsigned long mask = 0x00000003UL;
146 unsigned long pat = (pat3 << 24) | (pat2 << 16) | (pat1 << 8) | pat0;
150 pFrame[i&3] = p[(pat & mask) >> shift];
160 // fills the next 8 pixels with either p[0] or p[1], depending on pattern
161 static void patternRow2Pixels(unsigned char *pFrame, unsigned char pat, unsigned char *p)
163 unsigned char mask=0x01;
167 *pFrame++ = p[(mask & pat) ? 1 : 0];
172 // fills the next four 2 x 2 pixel boxes with either p[0] or p[1], depending on pattern
173 static void patternRow2Pixels2(unsigned char *pFrame, unsigned char pat, unsigned char *p)
176 unsigned char mask=0x1;
180 pel = p[(mask & pat) ? 1 : 0];
182 pFrame[0] = pel; // upper-left
183 pFrame[1] = pel; // upper-right
184 pFrame[g_width + 0] = pel; // lower-left
185 pFrame[g_width + 1] = pel; // lower-right
192 // fills pixels in the next 4 x 4 pixel boxes with either p[0] or p[1], depending on pat0 and pat1.
193 static void patternQuadrant2Pixels(unsigned char *pFrame, unsigned char pat0, unsigned char pat1, unsigned char *p)
196 unsigned short mask = 0x0001;
198 unsigned short pat = (pat1 << 8) | pat0;
204 pel = p[(pat & mask) ? 1 : 0];
206 pFrame[j + i * g_width] = pel;
213 static void dispatchDecoder(unsigned char **pFrame, unsigned char codeType, unsigned char **pData, int *pDataRemain, int *curXb, int *curYb)
216 unsigned char pat[16];
220 /* Data is processed in 8x8 pixel blocks.
221 There are 16 ways to encode each block.
227 /* block is copied from block in current frame */
228 copyFrame(*pFrame, *pFrame + ((unsigned char *)g_vBackBuf2 - (unsigned char *)g_vBackBuf1));
230 /* block is unchanged from two frames ago */
235 /* Block is copied from nearby (below and/or to the right) within the
236 new frame. The offset within the buffer from which to grab the
237 patch of 8 pixels is given by grabbing a byte B from the data
238 stream, which is broken into a positive x and y offset according
239 to the following mapping:
245 x = -14 + ((B - 56) % 29)
246 y = 8 + ((B - 56) / 29)
248 relFar(*(*pData)++, 1, &x, &y);
249 copyFrame(*pFrame, *pFrame + x + y*g_width);
255 /* Block is copied from nearby (above and/or to the left) within the
262 x = -(-14 + ((B - 56) % 29))
263 y = -( 8 + ((B - 56) / 29))
265 relFar(*(*pData)++, -1, &x, &y);
266 copyFrame(*pFrame, *pFrame + x + y*g_width);
272 /* Similar to 0x2 and 0x3, except this method copies from the
273 "current" frame, rather than the "new" frame, and instead of the
274 lopsided mapping they use, this one uses one which is symmetric
275 and centered around the top-left corner of the block. This uses
276 only 1 byte still, though, so the range is decreased, since we
277 have to encode all directions in a single byte. The byte we pull
278 from the data stream, I'll call B. Call the highest 4 bits of B
279 BH and the lowest 4 bytes BL. Then the offset from which to copy
285 relClose(*(*pData)++, &x, &y);
286 copyFrame(*pFrame, *pFrame + ((unsigned char *)g_vBackBuf2 - (unsigned char *)g_vBackBuf1) + x + y*g_width);
292 /* Similar to 0x4, but instead of one byte for the offset, this uses
293 two bytes to encode a larger range, the first being the x offset
294 as a signed 8-bit value, and the second being the y offset as a
297 x = (signed char)*(*pData)++;
298 y = (signed char)*(*pData)++;
299 copyFrame(*pFrame, *pFrame + ((unsigned char *)g_vBackBuf2 - (unsigned char *)g_vBackBuf1) + x + y*g_width);
305 /* I can't figure out how any file containing a block of this type
306 could still be playable, since it appears that it would leave the
307 internal bookkeeping in an inconsistent state in the BG player
308 code. Ahh, well. Perhaps it was a bug in the BG player code that
309 just didn't happen to be exposed by any of the included movies.
310 Anyway, this skips the next two blocks, doing nothing to them.
311 Note that if you've reached the end of a row, this means going on
317 if (++*curXb == (g_width >> 3))
319 *pFrame += 7*g_width;
321 if (++*curYb == (g_height >> 3))
328 /* Ok, here's where it starts to get really...interesting. This is,
329 incidentally, the part where they started using self-modifying
330 code. So, most of the following encodings are "patterned" blocks,
331 where we are given a number of pixel values and then bitmapped
332 values to specify which pixel values belong to which squares. For
333 this encoding, we are given the following in the data stream:
337 These are pixel values (i.e. 8-bit indices into the palette). If
338 P0 <= P1, we then get 8 more bytes from the data stream, one for
339 each row in the block:
341 B0 B1 B2 B3 B4 B5 B6 B7
343 For each row, the leftmost pixel is represented by the low-order
344 bit, and the rightmost by the high-order bit. Use your imagination
345 in between. If a bit is set, the pixel value is P1 and if it is
346 unset, the pixel value is P0.
348 So, for example, if we had:
350 11 22 fe 83 83 83 83 83 83 fe
352 This would represent the following layout:
354 11 22 22 22 22 22 22 22 ; fe == 11111110
355 22 22 11 11 11 11 11 22 ; 83 == 10000011
356 22 22 11 11 11 11 11 22 ; 83 == 10000011
357 22 22 11 11 11 11 11 22 ; 83 == 10000011
358 22 22 11 11 11 11 11 22 ; 83 == 10000011
359 22 22 11 11 11 11 11 22 ; 83 == 10000011
360 22 22 11 11 11 11 11 22 ; 83 == 10000011
361 11 22 22 22 22 22 22 22 ; fe == 11111110
363 If, on the other hand, P0 > P1, we get two more bytes from the
368 Each of these bytes contains two 4-bit patterns. These patterns
369 work like the patterns above with 8 bytes, except each bit
370 represents a 2x2 pixel region.
372 B0 contains the pattern for the top two rows and B1 contains
373 the pattern for the bottom two rows. Note that the low-order
374 nibble of each byte contains the pattern for the upper of the
375 two rows that that byte controls.
383 11 11 22 22 22 22 22 22 ; e == 1 1 1 0
384 11 11 22 22 22 22 22 22 ;
385 22 22 22 22 22 22 11 11 ; 7 == 0 1 1 1
386 22 22 22 22 22 22 11 11 ;
387 11 11 11 11 11 11 22 22 ; 3 == 1 0 0 0
388 11 11 11 11 11 11 22 22 ;
389 22 22 22 22 11 11 11 11 ; 8 == 0 0 1 1
390 22 22 22 22 11 11 11 11 ;
398 patternRow2Pixels(*pFrame, *(*pData)++, p);
406 patternRow2Pixels2(*pFrame, *(*pData) & 0xf, p);
407 *pFrame += 2*g_width;
408 patternRow2Pixels2(*pFrame, *(*pData)++ >> 4, p);
409 *pFrame += 2*g_width;
412 *pFrame -= (8*g_width - 8);
416 /* Ok, this one is basically like encoding 0x7, only more
417 complicated. Again, we start out by getting two bytes on the data
422 if P0 <= P1 then we get the following from the data stream:
429 P0 P1 and B0 B1 are used for the top-left corner, P2 P3 B2 B3 for
430 the bottom-left corner, P4 P5 B4 B5 for the top-right, P6 P7 B6 B7
431 for the bottom-right. (So, each codes for a 4x4 pixel array.)
432 Since we have 16 bits in B0 B1, there is one bit for each pixel in
433 the array. The convention for the bit-mapping is, again, left to
434 right and top to bottom.
436 So, basically, the top-left quarter of the block is an arbitrary
437 pattern with 2 pixels, the bottom-left a different arbitrary
438 pattern with 2 different pixels, and so on.
440 For example if the next 16 bytes were:
442 00 22 f9 9f 44 55 aa 55 11 33 cc 33 66 77 01 ef
446 22 22 22 22 | 11 11 33 33 ; f = 1111, c = 1100
447 22 00 00 22 | 11 11 33 33 ; 9 = 1001, c = 1100
448 22 00 00 22 | 33 33 11 11 ; 9 = 1001, 3 = 0011
449 22 22 22 22 | 33 33 11 11 ; f = 1111, 3 = 0011
450 ------------+------------
451 44 55 44 55 | 66 66 66 66 ; a = 1010, 0 = 0000
452 44 55 44 55 | 77 66 66 66 ; a = 1010, 1 = 0001
453 55 44 55 44 | 66 77 77 77 ; 5 = 0101, e = 1110
454 55 44 55 44 | 77 77 77 77 ; 5 = 0101, f = 1111
456 I've added a dividing line in the above to clearly delineate the
460 Now, if P0 > P1 then we get 10 more bytes from the data stream:
462 B0 B1 B2 B3 P2 P3 B4 B5 B6 B7
464 Now, if P2 <= P3, then the first six bytes [P0 P1 B0 B1 B2 B3]
465 represent the left half of the block and the latter six bytes
466 [P2 P3 B4 B5 B6 B7] represent the right half.
470 22 00 01 37 f7 31 11 66 8c e6 73 31
474 22 22 22 22 | 11 11 11 66 ; 0: 0000 | 8: 1000
475 00 22 22 22 | 11 11 66 66 ; 1: 0001 | C: 1100
476 00 00 22 22 | 11 66 66 66 ; 3: 0011 | e: 1110
477 00 00 00 22 | 11 66 11 66 ; 7: 0111 | 6: 0101
478 00 00 00 00 | 66 66 66 11 ; f: 1111 | 7: 0111
479 00 00 00 22 | 66 66 11 11 ; 7: 0111 | 3: 0011
480 00 00 22 22 | 66 66 11 11 ; 3: 0011 | 3: 0011
481 00 22 22 22 | 66 11 11 11 ; 1: 0001 | 1: 0001
484 On the other hand, if P0 > P1 and P2 > P3, then
485 [P0 P1 B0 B1 B2 B3] represent the top half of the
486 block and [P2 P3 B4 B5 B6 B7] represent the bottom half.
490 22 00 cc 66 33 19 66 11 18 24 42 81
494 22 22 00 00 22 22 00 00 ; cc: 11001100
495 22 00 00 22 22 00 00 22 ; 66: 01100110
496 00 00 22 22 00 00 22 22 ; 33: 00110011
497 00 22 22 00 00 22 22 22 ; 19: 00011001
498 -----------------------
499 66 66 66 11 11 66 66 66 ; 18: 00011000
500 66 66 11 66 66 11 66 66 ; 24: 00100100
501 66 11 66 66 66 66 11 66 ; 42: 01000010
502 11 66 66 66 66 66 66 11 ; 81: 10000001
504 if ( (*pData)[0] <= (*pData)[1])
506 // four quadrant case
511 pat[0] = *(*pData)++;
512 pat[1] = *(*pData)++;
513 patternQuadrant2Pixels(*pFrame, pat[0], pat[1], p);
515 // alternate between moving down and moving up and right
517 *pFrame += 4 - 4*g_width; // up and right
519 *pFrame += 4*g_width; // down
522 else if ( (*pData)[6] <= (*pData)[7])
532 pat[0] = *(*pData)++;
533 pat[1] = *(*pData)++;
534 patternQuadrant2Pixels(*pFrame, pat[0], pat[1], p);
537 *pFrame -= (4*g_width - 4);
539 *pFrame += 4*g_width;
552 patternRow2Pixels(*pFrame, *(*pData)++, p);
555 *pFrame -= (8*g_width - 8);
560 /* Similar to the previous 2 encodings, only more complicated. And
561 it will get worse before it gets better. No longer are we dealing
562 with patterns over two pixel values. Now we are dealing with
563 patterns over 4 pixel values with 2 bits assigned to each pixel
564 (or block of pixels).
566 So, first on the data stream are our 4 pixel values:
570 Now, if P0 <= P1 AND P2 <= P3, we get 16 bytes of pattern, each
571 2 bits representing a 1x1 pixel (00=P0, 01=P1, 10=P2, 11=P3). The
572 ordering is again left to right and top to bottom. The most
573 significant bits represent the left side at the top, and so on.
575 If P0 <= P1 AND P2 > P3, we get 4 bytes of pattern, each 2 bits
576 representing a 2x2 pixel. Ordering is left to right and top to
579 if P0 > P1 AND P2 <= P3, we get 8 bytes of pattern, each 2 bits
580 representing a 2x1 pixel (i.e. 2 pixels wide, and 1 high).
582 if P0 > P1 AND P2 > P3, we get 8 bytes of pattern, each 2 bits
583 representing a 1x2 pixel (i.e. 1 pixel wide, and 2 high).
585 if ( (*pData)[0] <= (*pData)[1])
587 if ( (*pData)[2] <= (*pData)[3])
596 pat[0] = *(*pData)++;
597 pat[1] = *(*pData)++;
598 patternRow4Pixels(*pFrame, pat[0], pat[1], p);
602 *pFrame -= (8*g_width - 8);
611 patternRow4Pixels2(*pFrame, *(*pData)++, p);
612 *pFrame += 2*g_width;
613 patternRow4Pixels2(*pFrame, *(*pData)++, p);
614 *pFrame += 2*g_width;
615 patternRow4Pixels2(*pFrame, *(*pData)++, p);
616 *pFrame += 2*g_width;
617 patternRow4Pixels2(*pFrame, *(*pData)++, p);
618 *pFrame -= (6*g_width - 8);
623 if ( (*pData)[2] <= (*pData)[3])
633 pat[0] = *(*pData)++;
634 patternRow4Pixels2x1(*pFrame, pat[0], p);
638 *pFrame -= (8*g_width - 8);
650 pat[0] = *(*pData)++;
651 pat[1] = *(*pData)++;
652 patternRow4Pixels(*pFrame, pat[0], pat[1], p);
654 patternRow4Pixels(*pFrame, pat[0], pat[1], p);
658 *pFrame -= (8*g_width - 8);
664 /* Similar to the previous, only a little more complicated.
666 We are still dealing with patterns over 4 pixel values with 2 bits
667 assigned to each pixel (or block of pixels).
669 So, first on the data stream are our 4 pixel values:
673 Now, if P0 <= P1, the block is divided into 4 quadrants, ordered
674 (as with opcode 0x8) TL, BL, TR, BR. In this case the next data
675 in the data stream should be:
678 P4 P5 P6 P7 B4 B5 B6 B7
679 P8 P9 P10 P11 B8 B9 B10 B11
680 P12 P13 P14 P15 B12 B13 B14 B15
682 Each 2 bits represent a 1x1 pixel (00=P0, 01=P1, 10=P2, 11=P3).
683 The ordering is again left to right and top to bottom. The most
684 significant bits represent the right side at the top, and so on.
686 If P0 > P1 then the next data on the data stream is:
688 B0 B1 B2 B3 B4 B5 B6 B7
689 P4 P5 P6 P7 B8 B9 B10 B11 B12 B13 B14 B15
691 Now, in this case, if P4 <= P5,
692 [P0 P1 P2 P3 B0 B1 B2 B3 B4 B5 B6 B7] represent the left half of
693 the block and the other bytes represent the right half. If P4 >
694 P5, then [P0 P1 P2 P3 B0 B1 B2 B3 B4 B5 B6 B7] represent the top
695 half of the block and the other bytes represent the bottom half.
697 if ( (*pData)[0] <= (*pData)[1])
705 pat[0] = *(*pData)++;
706 pat[1] = *(*pData)++;
707 pat[2] = *(*pData)++;
708 pat[3] = *(*pData)++;
710 patternQuadrant4Pixels(*pFrame, pat[0], pat[1], pat[2], pat[3], p);
713 *pFrame -= (4*g_width - 4);
715 *pFrame += 4*g_width;
720 if ( (*pData)[12] <= (*pData)[13])
733 pat[0] = *(*pData)++;
734 pat[1] = *(*pData)++;
735 pat[2] = *(*pData)++;
736 pat[3] = *(*pData)++;
738 patternQuadrant4Pixels(*pFrame, pat[0], pat[1], pat[2], pat[3], p);
741 *pFrame -= (4*g_width - 4);
743 *pFrame += 4*g_width;
759 pat[0] = *(*pData)++;
760 pat[1] = *(*pData)++;
761 patternRow4Pixels(*pFrame, pat[0], pat[1], p);
765 *pFrame -= (8*g_width - 8);
771 /* In this encoding we get raw pixel data in the data stream -- 64
772 bytes of pixel data. 1 byte for each pixel, and in the standard
777 memcpy(*pFrame, *pData, 8);
782 *pFrame -= (8*g_width - 8);
786 /* In this encoding we get raw pixel data in the data stream -- 16
787 bytes of pixel data. 1 byte for each block of 2x2 pixels, and in
788 the standard order (l->r, t->b).
796 (*pFrame)[2*k] = (*pData)[k];
797 (*pFrame)[2*k+1] = (*pData)[k];
804 *pFrame -= (8*g_width - 8);
808 /* In this encoding we get raw pixel data in the data stream -- 4
809 bytes of pixel data. 1 byte for each block of 4x4 pixels, and in
810 the standard order (l->r, t->b).
818 (*pFrame)[k*g_width+j] = (*pData)[0];
819 (*pFrame)[k*g_width+j+4] = (*pData)[1];
822 *pFrame += 4*g_width;
826 *pFrame -= (8*g_width - 8);
830 /* This encoding represents a solid 8x8 frame. We get 1 byte of pixel
831 data from the data stream.
835 memset(*pFrame, **pData, 8);
840 *pFrame -= (8*g_width - 8);
844 /* This encoding represents a "dithered" frame, which is
845 checkerboarded with alternate pixels of two colors. We get 2
846 bytes of pixel data from the data stream, and these bytes are
849 P0 P1 P0 P1 P0 P1 P0 P1
850 P1 P0 P1 P0 P1 P0 P1 P0
852 P0 P1 P0 P1 P0 P1 P0 P1
853 P1 P0 P1 P0 P1 P0 P1 P0
859 (*pFrame)[j] = (*pData)[(i+j)&1];
865 *pFrame -= (8*g_width - 8);