/***************************************************************
Pict file pdr modules:

	Created by Peter Kennard.  Sept 29, 1991
		Functions to read, parse and decompress pict file pixel map
		data chunks and transfer the pixels to a pj screen, or to 
		single line pixel buffers in true color mode.
****************************************************************/
#include "errcodes.h"
#include "pict.h"
#include "picdrive.h"
#include "syslib.h"


void intel_swap_pixMap(pixMap *pm)
/* Intel swap integer fields in an apple pixel map header. */
{
static USHORT pmswaps[] = {
	SET_OFFSET(pixMap,rowBytes),
	SWAP_WORDS(7),
	SWAP_LONGS(1),
	SET_OFFSET(pixMap,pixelType),
	SWAP_WORDS(4),
	SWAP_LONGS(2),
	SWAP_WORDS(2),
	END_SWAPTAB
};
	intel_swap_struct(pm,pmswaps);
}
static Errcode read_pixMap(Pfile *pf, pixMap *pm)
/* Read a pixMap header from the file, and make allowance for version 1 or 2
 * types. Convert version 1 to version 2 format. */
{

	/* Note the baseAddr field is NOT in the file */

	if(pf_read(pf,&pm->PMAP_FSTART, PMAP_FSIZE) < Success)
		goto error;

	intel_swap_pixMap(pm);

	if(!(pm->rowBytes & 0x8000)) /* This is a BITmap */
	{
		/* Go back to end of bitMap in file and load pixMap values that 
		 * would be valid for a bitmap. */

		pf_seek_bytes(pf, sizeof(bitMap)-sizeof(pixMap));
		pm->packType = PACK_BRUN;
		pm->packSize = 0;
		pm->pixelType = 0;
		pm->cmpSize = 1;
		pm->pixelSize = 1;
		pm->cmpCount = 1;
		pm->planeBytes = 0;
		pm->myflags = PM_NOCTABLE;
	}
	else /* This is a pixel map.  Clear sign bit */
	{
		pm->rowBytes &= ~(0x8000);
		pm->myflags = 0;
		if(pm->pixelType == 16)
			pm->myflags |= PM_NOCTABLE;
	}

#ifdef PRINTSTUFF
#define PRTIT(f) printf(sizeof(MEMBER(pixMap,f)) > 2?"%s %ld\n":"%s %d\n",\
	#f, pm->f )

	PRTIT( rowBytes); 
	PRTIT(Bounds.top);    
	PRTIT(Bounds.left);    
	PRTIT(Bounds.right);    
	PRTIT(Bounds.bot);    
	PRTIT( version);
	PRTIT( packType);
	PRTIT( packSize);
	PRTIT( pixelType); 
	PRTIT( pixelSize); 
	PRTIT( cmpCount);
	PRTIT( cmpSize);
	PRTIT( planeBytes); 
#undef PRTIT
#endif /* PRINTSTUFF */

	return(Success);
error:
	return(pf->lasterr);
}
static Errcode read_cTable_head(Pfile *pf, colorTable *ct)
/* Read header for pixel map color table from file and intel swap it. */
{
static USHORT ctswaps[] = {
	SWAP_LONGS(1),
	SWAP_WORDS(2),
	END_SWAPTAB
};
	pf_read(pf,ct,sizeof(*ct));
	intel_swap_struct(ct,ctswaps);
	return(pf->lasterr);
}
static Errcode read_colorTable(Pfile *pf)
/* Read a color table header from file, alloc a buffer for pf->cTable and 
 * read in the color values from the file. */
{
ULONG bytesize;
ctEntry *entry;
colorTable ct;
USHORT use_indices;
int i;

	if(read_cTable_head(pf,&ct) < Success)
		goto error;

	bytesize = (ct.ctSize+1) * sizeof(ctEntry);

	freez(&pf->cTable);
	if((pf->cTable = malloc(bytesize + sizeof(colorTable))) == NULL)
		return(pf->lasterr = Err_no_memory);

	if(pf_read(pf,CT_ENTRIES(pf->cTable),bytesize) < Success)
		goto error;
	intel_swap_words(CT_ENTRIES(pf->cTable),bytesize>>1);

	*pf->cTable = ct;

#ifdef PRINTSTUFF
	#define PRTIT(f) printf(sizeof(ct.f) > 2?"%s %ld\n":"%s %d\n",\
		#f, pf->cTable->f )

		PRTIT(id);  
		PRTIT(ctFlags);    
		PRTIT(ctSize);    
	#undef PRTIT
#endif /* PRINTSTUFF */

	/* Check table entry order and set inorder flag if it is.  I would assume
	 * these tables may not be in order or the pixel_ix field wouldn't 
	 * exist, if they are not we need to make pen ids equal indices. Some
	 * pics I have gotten have all zeros in the index field and they display
	 * ok if the table is assumed to be in index order so I set it here */

	use_indices = 0;
	entry = CT_ENTRIES(pf->cTable);
	for(i = ct.ctSize;i >= 0;--i)
	{
		use_indices |= entry->pixel_ix;
		++entry;
	}
	/* Entry is at max now so we count down in loop below. */

	pf->flags |= PH_CTAB_INORDER; /* be optimistic */
	for(i = ct.ctSize;i >= 0;--i)
	{
		--entry;
		if(!use_indices)
			entry->pixel_ix = i;
		else
		{
			if((entry)->pixel_ix != i)
				pf->flags &= ~PH_CTAB_INORDER;
		}
	}
	
	return(Success);
error:
	return(pf->lasterr);
}
static Errcode skip_colorTable(Pfile *pf)
/* Read color table header from file and skip by the data.  Used for ignored 
 * chunks. */
{
colorTable ct;

	if(read_cTable_head(pf,&ct) >= Success)
		pf_seek_bytes(pf,(ct.ctSize+1) * sizeof(ctEntry));
	return(pf->lasterr);
}
static Errcode load_colorTable(Pfile *pf)
/* Load previously read in Apple style color table into a pj color map. */
{
Cmap *cmap;
Rgb3 *rgb;
ctEntry *cte;
int count;
USHORT max_ix;

	cmap = pf->screen->cmap;
	cte = CT_ENTRIES(pf->cTable);
	max_ix = cmap->num_colors;

	/* note ctSize is one less than actual size of table */
	for(count = pf->cTable->ctSize;count >= 0;--count)
	{
		/* must be within range of destination */
		if(cte->pixel_ix < max_ix)
		{
			rgb = &cmap->ctab[cte->pixel_ix];
			rgb->r = (cte->r >> 8);
			rgb->g = (cte->g >> 8);
			rgb->b = (cte->b >> 8);
		}
		++cte;
	}
	pj_cmap_load(pf->screen,cmap);
	return(Success);
}
static Errcode read_rowbytes_line(Pfile *pf,void *buf,unsigned maxsize)
/* Read line of implicit rowBytes size for an unpacked line. */
{
	return(pf_read(pf,buf,pf->pm.rowBytes));
}
static Errcode donothing_unpack(BYTE *packline, UBYTE *buf, int len)
/* Filler function: Does nothing. */
{
	return(Success);
}

/***********  bit to byte a pixel expander functions ********* /

/* All are: void expand_Xbit(UBYTE *bitbuf,UBYTE *pix, UBYTE *maxpix)
 * 
 * bitbuf is a buffer of X bit wide pixels, input
 * pix is the output buffer of byte wide pixels
 * maxpix it the loop controller or one beyond the last output pixel available
 */

typedef union bitbytes {
	struct {
		UBYTE low; 
		UBYTE hi; 
	} b;
	USHORT w; 
} Bitbytes;

static void dont_make_pixels(UBYTE *bitbuf,UBYTE *pix, UBYTE *maxpix, int bpr)
/* donothing place holder function for pixel cruncher */
{
	return;
}
static void expand_1bit(UBYTE *bitbuf,UBYTE *pix, UBYTE *maxpix, int bpr)
/* Expand buffer of 1 bit pixels to byte a pixel buffer. */
{
Bitbytes bits;
int count;

	bits.w = 0;
	count = 0;
	while(pix < maxpix)
	{
		if(--count <= 0)
		{
			count = 8;
			bits.b.low = *bitbuf++;
		}
		bits.w <<= 1;
		*pix++ = bits.b.hi & 1;
	}
}
static void expand_2bit(UBYTE *bitbuf,UBYTE *pix, UBYTE *maxpix, int bpr)
/* Expand buffer of 2 bit pixels to byte a pixel buffer. */
{
Bitbytes bits;
int count;

	bits.w = 0;
	count = 0;
	while(pix < maxpix)
	{
		if(--count <= 0)
		{
			count = 4;
			bits.b.low = *bitbuf++;
		}
		bits.w <<= 2;
		*pix++ = bits.b.hi & 0x3;
	}
}
static void expand_4bit(UBYTE *bitbuf,UBYTE *pix, UBYTE *maxpix, int bpr)
/* Expand buffer of 4 bit pixels to byte a pixel buffer. */
{
UBYTE b;

	for(;;)
	{
		if(pix >= maxpix)
			break;
		b = *bitbuf++;
		*pix++ = b >> 4;
		if(pix >= maxpix)
			break;
		*pix++ = b & 0xF;
	}
}
static void bits16_to_Rgb3(UBYTE *bitbuf, UBYTE *pix, UBYTE *maxpix, int bpr)
/* Expand 16 bit apple pixels to 24 bit r,g,b pixels */
{
USHORT *pix16 = (USHORT *)bitbuf;
Bitbytes bits;
#define RGB ((Rgb3 *)pix)

	/* layout of apple 16 bit pixel is 0rrrrrgggggbbbbb */

	while(pix < maxpix)
	{
		bits.w = *pix16++ << 1;
		RGB->r = (bits.b.hi & 0xF8) | ((bits.b.hi>>5) & 0x07);

		RGB->g = (bits.b.hi & 0x07);
		bits.w <<= 5;
		RGB->g |= (bits.b.hi & 0xF8);

		RGB->b = (bits.b.hi & 0x07);
		bits.w <<= 5;
		RGB->b |= (bits.b.hi & 0xF8);
		pix += sizeof(*RGB);
	}
#undef RGB
}
static void interleave_rgbs(UBYTE *bitbuf, UBYTE *pix, UBYTE *maxpix, int bpr)
/* Take 3 end to end [rrr][ggg][bbb] buffers and produce one buffer of 
 * ordered rgb triples  rgbrgbrgb. Bpr is 4x the length of the input buffer
 * used by each color component. The fourth color component is used as an
 * Alpha channel if present and is not used by the PDR. */
{
UBYTE *reds;
UBYTE *greens;
UBYTE *blues;
#define RGB ((Rgb3 *)pix)

	/* Layout of apple 32 bit pixels as decompressed by byte run compression
	 * is bpr/4 reds bpr/4 greens bpr/4 blues bpr/4 alphas */

	bpr >>= 2;
	reds = bitbuf;
	greens = reds + bpr;
	blues = greens + bpr;

	while(pix < maxpix)
	{
		RGB->r = *reds++;
		RGB->g = *greens++;
		RGB->b = *blues++;
		pix = OPTR(pix,sizeof(*RGB));
	}
#undef RGB
}
static void copy_pixel_bytes(UBYTE *bitbuf, UBYTE *pix, UBYTE *maxpix, int bpr)
/* this copies unpacked pixels just as they are */
{
	copy_bytes(bitbuf,pix,SIZE(pix,maxpix));
}
/*******************************************************************/
/*** transfer mode "blit" logic functions D must equal s + width !! 
 *** and is used for the loop test. Each function will logicly merge
 *** string s into d putting the result in d. */

static void or_pixels(UBYTE *s,UBYTE *d)
{
UBYTE *maxs;

	maxs = d;
	while(s < maxs)
		*d++ |= *s++;
}
static void xor_pixels(UBYTE *s,UBYTE *d)
{
UBYTE *maxs;

	maxs = d;
	while(s < maxs)
		*d++ ^= *s++;
}
static void andnot_pixels(UBYTE *s,UBYTE *d)
{
UBYTE *maxs;

	maxs = d;
	while(s < maxs)
		*d++ &= ~(*s++);
}
static void not_pixels(UBYTE *s,UBYTE *d)
{
UBYTE *maxs;

	maxs = d;
	while(s < maxs)
		*d++ = ~(*s++);
}
static void ornot_pixels(UBYTE *s,UBYTE *d)
{
UBYTE *maxs;

	maxs = d;
	while(s < maxs)
		*d++ |= ~(*s++);
}
static void xornot_pixels(UBYTE *s,UBYTE *d)
{
UBYTE *maxs;

	maxs = d;
	while(s < maxs)
		*d++ ^= ~(*s++);
}
static void and_pixels(UBYTE *s,UBYTE *d)
{
UBYTE *maxs;

	maxs = d;
	while(s < maxs)
		*d++ &= *s++;
}
static Errcode init_pixmap_transfer(Pfile *pf)
/* Sets up state variables in pictfile to start pixel transfer from file
 * to output raster of rgb lines from a pixel map record in the file. 
 * It sets the state to correspond to the description of the pixel data in 
 * the previously read pixel map header. */
{
LONG bsize;

	/* get width and height of output raster from this pixel map */

	pf->pixwidth = pf->pm.Bounds.right - pf->pm.Bounds.left;

	if(pf->mode == PF_RGBLINES)
		pf->pixwidth *= sizeof(Rgb3);

	pf->pmheight = pf->pm.Bounds.bot - pf->pm.Bounds.top;

	/* We potentially use 3 buffers one for pixels, one for packed
	 * bits, and one for unpacked bits. Maybe a little bigger than needed
	 * but surely enough.  Make sure it is at least 2*width for transfer
	 * mode functionality which needs an extra buffer for compositing.
	 * When the composite function is called, all buffer space other than
	 * pixbuf can be overwritten and used. */

	bsize = (pf->pm.rowBytes*3)+128;
	if(bsize < pf->pixwidth)
		bsize += pf->pixwidth;
	bsize += pf->pixwidth;

	/* re-allocate pixel buffer if too small */
	if(pf->pixbuf == NULL || pf->pbsize < bsize)
	{
		freez(&pf->pixbuf);
		if((pf->pixbuf = malloc(bsize)) == NULL)
			return(pf->lasterr = Err_no_memory);
		pf->pbsize = bsize;
	}

	/* We use one pixwidth line of pixels for the output buffer. */

	pf->maxpix = OPTR(pf->pixbuf,pf->pixwidth); 

	/* Select pixel expansion or crunching function based on pixel depth. */
	switch(pf->pm.pixelSize)
	{
		case 1:
			pf->make_pixels = expand_1bit;
			goto setup_bitbuf;
		case 2:
			pf->make_pixels = expand_2bit;
			goto setup_bitbuf;
		case 4:
			pf->make_pixels = expand_4bit;
			goto setup_bitbuf;
		case 16:
			pf->make_pixels = bits16_to_Rgb3;
			goto setup_bitbuf;
		case 32:
		{
		/* Note: In the unpacked case we copy the pixels.  This is because
		 * we are loading the pixels into an ouput line buffer and the 
		 * make_pixels function is used to load the pixels into the output 
		 * line.  Maybe an extra copy but code is simpler in rgb_readline() */

			switch(pf->pm.packType)
			{
				case PACK_BRUN_CMP:
					pf->make_pixels = interleave_rgbs;
					goto setup_bitbuf;
				case NOPACK_ODDSIZE: /* not packed, out RGBs are the same in
									  * this case */
					pf->make_pixels = copy_pixel_bytes; 
					goto setup_bitbuf;
			}
			goto set_dont_make;
		}
		default: /* If we don't support it, just do nothing. */
		case 8:
		set_dont_make:
		{
			pf->make_pixels = dont_make_pixels;
			pf->bitbuf = pf->pixbuf;  /* this needs no expansion so unpack 
							  		    * readbuf direct to pixbuf */
			break;
		}
		setup_bitbuf:
		{
			/* Set up a bitbuf as a separate area where decompressed bits 
			 * are put before being converted to pixels. note this is 
			 * long aligned */

			pf->bitbuf = OPTR(pf->maxpix,4-(pf->pixwidth & 3));   
			break;
		}
	}

	/* Select read function based on ranges of bytes per row as defined
	 * by apple docs. */

	if(pf->pm.rowBytes < 8) /* Data is unpacked and lines are bpr size. */
	{
		pf->read_line = read_rowbytes_line; 
		pf->pm.packType = NOPACK; /* set to select no packing packtype */
	}
	else if(pf->pm.rowBytes <= 250) 
	{
		/* imbedded size is a leading byte */
		pf->read_line = read_chunk8;
	}
	else  
	{
		/* imbedded size is a leading short int */
		pf->read_line = read_chunk16;
	}

	/* Select unpacker function based on packType field. */

	switch(pf->pm.packType)
	{
		case PACK_BRUN: /* byte run byte a pixel compression */
			pf->unpack_line = brun_unpack_line; 
			goto packed_line;
		case NOPACK: /* unpacked format */
		case NOPACK_ODDSIZE: 
			goto unpacked_line;
		case PACK_CHUNKRUN: /* word run compression only for 16 bit pixels */
		{
			if(pf->pm.pixelSize != 16)	
				goto unpacked_line;
			pf->unpack_line = wrun_unpack_line;
			goto packed_line;
		}
		case PACK_BRUN_CMP: /* Each byte size component byte run compressed */
		{
			if(pf->pm.pixelSize != 32)
				goto unpacked_line;
			if(pf->pm.cmpCount == 3)
				pf->unpack_line = brun_unpack_3compbytes;
			else
				pf->unpack_line = brun_unpack_line; 
			goto packed_line;
		}
		default:  /* Just make ugly screen of data. not supported */
		unpacked_line:
			pf->unpack_line = donothing_unpack; /* no compression */
			pf->readbuf = pf->bitbuf; /* no unpacking read to bitbuf */
			break;
		packed_line:
			/* Use a separate read area since we are unpacking */
			pf->readbuf = OPTR(pf->bitbuf,pf->pm.rowBytes); 
			break;
	}

	/* Set maxsize safety margin for reader so it won't overrun buffer. */
	pf->max_read_size = pf->pbsize - SIZE(pf->pixbuf,pf->readbuf) - 2;

	/* Select blit logic function for transfer mode field. */

	switch(pf->tmode)
	{
		default:
			pf->tmode = 0;
		case 0:  /* d = s NO compositing logic */
			break;
		case 1:  /* d |= s */
			pf->composite_pixels = or_pixels;
			break;
		case 2:  /* d ^= s */
			pf->composite_pixels = xor_pixels;
			break;
		case 3:  /* d &= ~s */
			pf->composite_pixels = andnot_pixels;
			break;
		case 4: /* d = ~s */
			pf->composite_pixels = not_pixels;
			break;
		case 5: /* d |= ~s */
			pf->composite_pixels = ornot_pixels;
			break;
		case 6: /* d ^= ~s */
			pf->composite_pixels = xornot_pixels;
			break;
		case 7: /* d &= s */
			pf->composite_pixels = and_pixels;
			break;
	}
	return(Success);
}
static Errcode pixmap_to_screen(Pfile *pf)
/* Using functions set by init_pixmap_transfer() read pixels and move
 * them to the screen via the transfer methods selected. */
{
int ret;
UBYTE *dstbuf;
SHORT height;
Coor x,y;

	height = pf->pmheight;
	dstbuf = pf->tmode == 0 ? pf->pixbuf:pf->maxpix;
	y = pf->dstRect.top;
	x = pf->dstRect.left;

	/** THE getit unpackit convertit blitit loop !!! ***/

	while(height-- > 0)
	{
		if(pf->read_line(pf,pf->readbuf,pf->max_read_size) < 0)
			goto error;

		if((ret = pf->unpack_line(pf->readbuf,pf->bitbuf,
								  pf->pm.rowBytes)) < Success)
		{
			goto reterr;
		}

		pf->make_pixels(pf->bitbuf,pf->pixbuf,pf->maxpix,pf->pm.rowBytes);

		if(pf->tmode)
		{
			/* note dstbuf and maxpix are and must be the same! */
			/* get source */
			pj_get_hseg(pf->screen,pf->maxpix,x,y,pf->pixwidth); 
			pf->composite_pixels(pf->pixbuf,pf->maxpix);
		}

		pj_put_hseg(pf->screen,dstbuf,x,y,pf->pixwidth);
		++y;
	}
	return(Success);
reterr:
	pf->lasterr = ret;
error:
	return(pf->lasterr);
}
static Errcode skip_bitsrect(Pfile *pf,pixMap *pm)
/* Seek by pixel data for an ignored pixMap. */
{
SHORT height;
Errcode  (*skipit)(Pfile *);

	/* Get width and height of pixel map. */

	height = pf->pm.Bounds.bot - pf->pm.Bounds.top;

	if(pf->pm.rowBytes < 8) /* data is unpacked and lines are bpr size */
		return(pf_seek_bytes(pf, height*pm->rowBytes));

	/* Data is in embedded size chunks */

	if(pf->pm.rowBytes <= 250) 
		skipit = skip_chunk8;
	else
		skipit = skip_chunk16;

	while(height-- > 0)
	{
		if(skipit(pf) < Success)
			break;
	}
	return(pf->lasterr);
}
Errcode do_pixmap(Pfile *pf)
/* Read in a pixel map record from the file and either get info,
 * transfer to screen, or prepare to read the first RGB line depending
 * on the pf->mode. */
{
	pf->got_bitmap = TRUE;
	if(read_pixMap(pf,&pf->pm) < Success)
		goto error;

	if(pf->mode == PF_SCANINFO)
	{
	  /* Set offset to first pixel map if we are in an RGB true color file. */
		if((pf->ainfo.depth = pf->pm.pixelSize) > 8)
		{
			if((pf->first_pmap_oset = ftell(pf->file)) < 0)
				return(pf->lasterr = pj_errno_errcode());	
			pf->first_pmap_oset -= PMAP_FSIZE; /* we already read it */
		}
		return(pf->lasterr = RET_ENDSCAN);
	}
	else if(pf->mode == PF_FULLFRAME)  
	{
		/* Ignore true color data for full frame mode. */

		if((pf->ainfo.depth = pf->pm.pixelSize) > 8)
			return(skip_pmap_data(pf,&pf->pm));
	}

	/* If there is one, read the color map and load it into the screen. */

	if(!(pf->pm.myflags & PM_NOCTABLE))
	{
		if(read_colorTable(pf) < Success)
			goto error;
		if(pf->mode == PF_FULLFRAME)
			load_colorTable(pf);
	}

	/* Read in relative positioning rectangles. */

	if(read_pRect(pf,&pf->srcRect) < Success)
		goto error;

	if(read_pRect(pf,&pf->dstRect) < Success)
		goto error;

	/* Set destination rect as relative to picture frame. */
	set_rect_relto(&pf->dstRect, &pf->frame);

	/* Read transfer mode field. */

	if(read_short(pf,&pf->tmode) < Success)
		goto error;

#ifdef PRINTSTUFF

	printf("srect t %d l %d b %d r %d\n" 
	       "drect t %d l %d b %d r %d\n" 
	       "tmode %d\n", 
			pf->srcRect.top,
			pf->srcRect.left,
			pf->srcRect.bot,
			pf->srcRect.right,

			pf->dstRect.top,
			pf->dstRect.left,
			pf->dstRect.bot,
			pf->dstRect.right,

		    pf->tmode );

#endif /* PRINTSTUFF */

	if(pf->op & 1) /* ops 0x90 and 0x98 and 0x9a have no clipping region 
					* ops 0x91 and 0x99 and 0x9b do */
	{
		skip_region(pf); /* we don't use these now */
	}

	/* Set up state environment for pixel transfer. */

	if(init_pixmap_transfer(pf) < Success)
		goto error;

	/* If we are doing full screens transfer the whole pixMap to the screen */

	if(pf->mode == PF_FULLFRAME)
	{
		if(pf->pm.pixelSize > 8)
			return(pf->lasterr = Err_unimpl);
		return(pixmap_to_screen(pf));
	}

	/* else, We are doing RGB lines and just initalized the next pixMap. */

	return(pf->lasterr = RET_PMAPSTART);
error:
	return(pf->lasterr);
}
static Errcode skip_pmap_data(Pfile *pf, pixMap *pm)
/* Seek by all data for an ignored pixMap */
{
	if(!(pm->myflags & PM_NOCTABLE))
	{
		if(skip_colorTable(pf) < Success)
			goto error;
	}
	skip_bitsrect(pf,pm);
error:
	return(pf->lasterr);
}
Errcode skip_pattern(Pfile *pf)
/* Seek over and ignore a fill patern description. */
{
SHORT patType;
pixMap pm;

	if(read_short(pf,&patType) < Success)
		goto error;

#ifdef PRINTSTUFF
	printf("pat%d ", patType );
#endif /* PRINTSTUFF */

	pf_seek_bytes(pf,8);  /* skip over pattern words */

	switch(patType)
	{
		case 1:
		{
			if(read_pixMap(pf,&pm) < Success)
				goto error;
			skip_pmap_data(pf,&pm);
			break;
		}
		case 2: /* dither pattern */
			pf_seek_bytes(pf,sizeof(RGBColor));
			break;
		default:
			pf->lasterr = Err_format;
			break;
	}

error:
	return(pf->lasterr);
}
Errcode do_truecolor(Pfile *pf)
/* Read the pixel map header info and prepare to read the next RGB line
 * from that pixMap or return info if scanning. */
{
	/* Seek past a dummy size of 0 and an end of file opcode */
	if(pf_seek_bytes(pf,4) < Success)
		goto error;

#ifdef  PRINTSTUFF
	printf("True color!!\n");
#endif

	do_pixmap(pf);

error:
	return(pf->lasterr);
}
Errcode pict_rgb_readline(Pfile *pf, Rgb3 *linebuf)
/* Read next available RGB line in the file. */
{
int ret;

	++pf->last_rgbline; /* next please */

#ifdef PRINTSTUFF
	printf("readline %d", pf->last_rgbline );
#endif

	for(;;)
	{
		if(pf->lasterr < Success)
			return(pf->lasterr);

		if(pf->lasterr == RET_EOPIC) /* Alas, no more pixels. */
			goto stuff_white;

		if(pf->last_rgbline >= pf->ainfo.height) /* bigger than pic size ! */
			return(Err_eof);

		if(pf->last_rgbline < pf->dstRect.top) /* gap in pixel maps! */
			goto stuff_white;

		/* Scan through opcodes to next pixMap record or to EOPIC if
		 * the line we want is beyond the last one in the current pixMap. */

		if(pf->last_rgbline >= pf->dstRect.bot)
			do_pictops(pf);
		else
			break;
	}

	/* Read compressed line of pixels. */
	if(pf->read_line(pf,pf->readbuf,pf->max_read_size) < 0)
		goto error;

	/* Clip if somehow outside of line. */
	if(((USHORT)pf->dstRect.left) >= pf->ainfo.width)
		goto stuff_white;

	/* Unpack line of pixels. */
	if((ret = pf->unpack_line(pf->readbuf,pf->bitbuf,
								  pf->pm.rowBytes)) < Success)
	{
		pf->lasterr = ret;
		goto error;
	}

	if(pf->dstRect.left > 0 || pf->dstRect.right > pf->ainfo.width)
	{
		/* If we are somehow offset from output line put in what we got
		 * and leave the rest white. This is really an error. */

		stuff_bytes(0xFF,linebuf,pf->pixwidth);
		pf->make_pixels(pf->bitbuf,pf->pixbuf,pf->maxpix,pf->pm.rowBytes);
		copy_bytes( pf->pixbuf, linebuf + pf->dstRect.left,
				(pf->ainfo.width - pf->dstRect.left)*sizeof(Rgb3) );
	}
	else 
		pf->make_pixels(pf->bitbuf,(UBYTE *)linebuf,
						OPTR(linebuf,pf->pixwidth),pf->pm.rowBytes);

	/* We did this one ok, next line please. */
	++pf->dstRect.top;  
	return(Success);

stuff_white:
	stuff_bytes(0xFF,linebuf,pf->pixwidth);
	return(Success);

error:
	printf("error");
	return(pf->lasterr);
}