#define __TCC_COMPAT__
#include <stdio.h>
#include <string.h>
#include <osbind.h>
#include <memory.h>
#include <aesbind.h>
#include <vdibind.h>
#include <gemfast.h>
#include <e_gem.h>
#include "load_img.h"

#ifndef FALSE
#define FALSE 0
#define TRUE  !FALSE
#endif

/* VDI <-> Device palette order conversion matrixes: */
/* Four-plane vdi-device */
int vdi2dev4[]={0,15,1,2,4,6,3,5,7,8,9,10,12,14,11,13};
/* Two-plane vdi-device */
int vdi2dev2[]={0,3,1,2};

void get_colors(int handle, short *palette, int col){
	int i, idx;

	/* get current color palette */
	for(i=0; i < col; i ++){
		/* device->vdi->device palette order */
		switch(planes){
		case 1:
			idx=i;break;
		case 2:
			idx=vdi2dev2[i];break;
		case 4:
			idx=vdi2dev4[i];break;
		default:
			if(i<16)
				idx=vdi2dev4[i];
			else
				idx= i==255 ? 1 : i;
		}
		vq_color(handle, i, 0, (int *)palette + idx * 3);
	}
}

void img_set_colors(int handle, short *palette, int col){
	int i, idx, end;

	/* set color palette */
	end=min(1<<col,1<<planes);
	for(i=0; i<end; i++){
	switch(planes){	/* MAR -- war col 10.01.2001 */
	 	case 1:
    		idx=i;break;
		case 2:
			idx=vdi2dev2[i];break;
		case 4:
			idx=vdi2dev4[i];break;
		default:
			if(i<16)
				idx=vdi2dev4[i];
			else
				idx= i==255 ? 1 : i;
    }
    vs_color(handle, i, (int *)palette + idx * 3);
  }
}

int convert(MFDB *image, long size){
	int plane, mplanes;
	char *line_addr, *buf_addr, *new_addr, *new1_addr, *image_addr, *screen_addr;
	MFDB  dev_form, tmp;
	long	new_size;

	/* convert size from words to bytes */
	size <<= 1;

	/* memory for the device raster */
	new_size=size*(long)planes;
	if((new_addr=(char *) calloc(1,new_size)) == NULL)
		return(FALSE);

	/* initialize MFDBs */
	tmp=*image;
	tmp.fd_nplanes=planes;
	tmp.fd_addr=new_addr;
	tmp.fd_stand=1;             /* standard format */
	dev_form=tmp;
	screen_addr=new_addr;
	dev_form.fd_stand=0;          /* device format */
	image_addr=(char *)image->fd_addr;

	/* initialize some variables and zero temp. line buffer */
	mplanes=min(image->fd_nplanes, planes);
	/* convert image */
	line_addr=image_addr;
	buf_addr=screen_addr;
		if(mplanes>1){
			/* cut/pad color planes into temp buf */
			for(plane=0; plane<mplanes; plane ++){
			memcpy(buf_addr, line_addr, size);
				line_addr += size;
			buf_addr += size;
			}
		}else{
			/* fill temp line bitplanes with a b&w line */
			for(plane=0; plane < planes; plane ++){
			memcpy(buf_addr, line_addr, size);
			buf_addr += size;
			}
		}
	free(image->fd_addr);
		/* convert image line in temp into current device raster format */
	if((new1_addr=(char *) calloc(1,new_size)) == NULL)
		return(FALSE);
	dev_form.fd_addr=new1_addr;
		vr_trnfm(x_handle, &tmp, &dev_form);
	free(new_addr);

	/* change image description */
	image->fd_stand=0;          /* device format */
	image->fd_addr=new1_addr;
	image->fd_nplanes=planes;
	return(TRUE);
}

int transform_img(MFDB *image){		/* return FALSE if transform_img fails */
	int success;
	long size;

	if(!image->fd_addr)
		return(FALSE);

	size=(long)((long)image->fd_wdwidth * (long)image->fd_h);
	success=convert(image, size);		/* Use vr_trfm(), which needs quite a lot memory. */
	if(success)		return(TRUE);
/*	else				show_error(ERR_ALLOC);	*/
	return(FALSE);
}


/* Loads & depacks IMG (0 if succeded, else error). */
/* Bitplanes are one after another in address IMG_HEADER.addr. */
int depack_img(char *name, IMG_header *pic){
	int	b, line, plane, width, word_aligned, opcode, patt_len, pal_size,
			byte_repeat, patt_repeat, scan_repeat, error = FALSE;
	char	*pattern, *to, *endline, *puffer, sol_pat;
	long	size;
	FILE *fp;

	if((fp = fopen(name, "rb")) == NULL)
		return(ERR_FILE);

	setvbuf(fp,NULL,_IOLBF,BUFSIZ);

	/* read header info (bw & ximg) into image structure */
	fread((char *)&(pic->version), 2, 8 + 3, fp);

	/* only 2-256 color imgs */
	if(pic->planes < 1 || pic->planes > 8){
		error = ERR_COLOR;
		goto end_depack;
	}

	/* if XIMG, read info */
	if(pic->magic == XIMG && pic->paltype == 0){
		pal_size = (1 << pic->planes) * 3 * 2;
		if((pic->palette = (short *)calloc(1,pal_size))){
			fread((char *)pic->palette, 1, pal_size, fp);
		}
	}else{
		pic->palette = NULL;
	}

	/* width in bytes word aliged */
	word_aligned = (pic->img_w + 15) >> 4;
	word_aligned <<= 1;

	/* width byte aligned */
	width = (pic->img_w + 7) >> 3;

	/* allocate memory for the picture */
	free(pic->addr);
	size = (long)((long)word_aligned * (long)pic->img_h * (long)pic->planes); /*MAR*/

	/* check for header validity & malloc long... */
	if (pic->length > 7 && pic->planes < 33 && pic->img_w > 0 && pic->img_h > 0){
		if(!(pic->addr=(char *)calloc(1,size))){
			error = ERR_ALLOC;
			goto end_depack;
		}
	}else{
		error = ERR_HEADER;
		goto end_depack;
	}

	patt_len = pic->pat_len;

	/* jump over the header and possible (XIMG) info */
	fseek(fp, (long) pic->length * 2L, SEEK_SET);

	for(line=0,to=pic->addr; line<pic->img_h; line+=scan_repeat){	/* depack whole img */
		for(plane=0,scan_repeat=1; plane<pic->planes; plane++){	/* depack one scan line */
			puffer=to=pic->addr+(long)(line+plane*pic->img_h)*(long)word_aligned;
			endline=puffer+width;
			do{	/* depack one line in one bitplane */
				switch((opcode= fgetc(fp))){
				case 0:	/* pattern or scan repeat */
					if((patt_repeat=fgetc(fp))){	/* repeat a pattern */
						fread(to,patt_len,1,fp);
						pattern=to;
						to+=patt_len;
						while(--patt_repeat){	/* copy pattern */
							memcpy(to,pattern,patt_len);
							to+=patt_len;
						}
					}else{	/* repeat a line */
						if(fgetc(fp)==0xFF)
							scan_repeat=fgetc(fp);
						else{
							error = ERR_DEPACK;
							goto end_depack;
						}
					}
					break;
				case 0x80:	/* Literal */
					byte_repeat=fgetc(fp);
					fread(to,byte_repeat,1,fp);
					to+=byte_repeat;
					break;
				default:	/* Solid run */
					byte_repeat = opcode & 0x7F;
					sol_pat = opcode&0x80 ? 0xFF : 0x00;
					while(byte_repeat--)	*to++=sol_pat;
				}
			}while(to<endline);

			if(to == endline){
				/* ensure that lines aren't repeated past the end of the img */
				if(line + scan_repeat > pic->img_h)
					scan_repeat = pic->img_h - line;
				/* copy line to image buffer */
				if(scan_repeat>1){
					/* calculate address of a current line in a current bitplane */
/*					to=pic->addr+(long)(line+1+plane*pic->img_h)*(long)word_aligned;*/
					for(b=scan_repeat-1; b; --b){
						memcpy(to, puffer, width);
						to+=word_aligned;
					}
				}
			}else{
				error = ERR_DEPACK;
				goto end_depack;
			}
		}
	}

	end_depack:
	fclose(fp);
	return(error);
}

int half_img(MFDB *s, MFDB *d){
	int pxy[8], i, j;
	MFDB tmp;

	mfdb(&tmp,NULL,s->fd_w/2,s->fd_h,s->fd_stand,s->fd_nplanes);
	tmp.fd_w=s->fd_w/2;
	tmp.fd_addr=calloc(1,mfdb_size(&tmp));
	if(!tmp.fd_addr)
		return(FALSE);

	pxy[1]=pxy[5]=0;
	pxy[3]=pxy[7]=s->fd_h-1;
	for(i=0;i<s->fd_w/2;i++){
		pxy[0]=pxy[2]=2*i;
		pxy[4]=pxy[6]=i;
		vro_cpyfm(x_handle,S_ONLY,pxy,s,&tmp);
	}
	pxy[0]=pxy[4]=0;
	pxy[2]=pxy[6]=s->fd_w/2-1;
	for(j=0;j<s->fd_h/2;j++){
		pxy[1]=pxy[3]=2*j;
		pxy[5]=pxy[7]=j;
		vro_cpyfm(x_handle,S_ONLY,pxy,&tmp,d);
	}
	free(tmp.fd_addr);
	return(TRUE);
}