Ejemplo n.º 1
0
Archivo: iff.c Proyecto: jinjoh/NOOR
unsigned short imb_update_iff(int file, int code)
{
	int	buf[2], filelen, skip;
	uchar nop;

	if (file<=0) return (FALSE);

	filelen = BLI_filesize(file)-8;			/* calc filelength  */

	lseek(file,0L,2);		/* seek end */

	if (filelen & 1){						/* make length 'even' */
		switch(code){
		case BODY:
			nop = IFFNOP;
			break;
		}
		if (write(file,&nop,1)!=1) return (FALSE);
		filelen++;
	}
	lseek(file,4L,0);

	buf[0] = BIG_LONG(filelen);
	
	if (write(file, buf, 4) != 4) return (FALSE);
	if (code == 0) return (TRUE);

	filelen-=4;
	lseek(file,4L,1);

	while (filelen>0){		/* seek BODY */
		read(file, buf, 8);
		filelen -= 8;
		if (buf[0] == code) break;
		
		skip = (BIG_LONG(buf[1]) + 1) & ~1;
		filelen -= skip;
		lseek(file, skip, 1);
	}
	if (filelen <= 0) {
		printf("update_iff: couldn't find chunk\n");
		return (FALSE);
	}

	lseek(file, -4L, 1);
	
	buf[0] = BIG_LONG(filelen);
	
	if (write(file, buf, 4)!=4) return (FALSE);

	return (TRUE);
}
Ejemplo n.º 2
0
static int IMB_ispic_name(const char *name)
{
	ImFileType *type;
	struct stat st;
	int fp, buf[10];

	if(UTIL_DEBUG) printf("IMB_ispic_name: loading %s\n", name);
	
	if(stat(name,&st) == -1)
		return FALSE;
	if(((st.st_mode) & S_IFMT) != S_IFREG)
		return FALSE;

	if((fp = open(name,O_BINARY|O_RDONLY)) < 0)
		return FALSE;

	if(read(fp, buf, 32) != 32) {
		close(fp);
		return FALSE;
	}

	close(fp);

	/* XXX move this exception */
	if((BIG_LONG(buf[0]) & 0xfffffff0) == 0xffd8ffe0)
		return JPG;

	for(type=IMB_FILE_TYPES; type->is_a; type++)
		if(type->is_a((uchar*)buf))
			return type->filetype;

	return FALSE;
}
Ejemplo n.º 3
0
int IMB_ispic_type(const char *name)
{
	/* increased from 32 to 64 because of the bitmaps header size */
#define HEADER_SIZE 64

	unsigned char buf[HEADER_SIZE];
	const ImFileType *type;
	BLI_stat_t st;
	int fp;

	BLI_assert(!BLI_path_is_rel(name));

	if (UTIL_DEBUG) printf("%s: loading %s\n", __func__, name);
	
	if (BLI_stat(name, &st) == -1)
		return false;
	if (((st.st_mode) & S_IFMT) != S_IFREG)
		return false;

	if ((fp = BLI_open(name, O_BINARY | O_RDONLY, 0)) == -1)
		return false;

	memset(buf, 0, sizeof(buf));
	if (read(fp, buf, HEADER_SIZE) <= 0) {
		close(fp);
		return false;
	}

	close(fp);

	/* XXX move this exception */
	if ((BIG_LONG(((int *)buf)[0]) & 0xfffffff0) == 0xffd8ffe0)
		return IMB_FTYPE_JPG;

	for (type = IMB_FILE_TYPES; type < IMB_FILE_TYPES_LAST; type++) {
		if (type->is_a) {
			if (type->is_a(buf)) {
				return type->filetype;
			}
		}
		else if (type->is_a_filepath) {
			if (type->is_a_filepath(name)) {
				return type->filetype;
			}
		}
	}

	return 0;

#undef HEADER_SIZE
}
Ejemplo n.º 4
0
struct ImBuf *IMB_loadiffmem(int *mem, int flags) {
    int len,maxlen;
    struct ImBuf *ibuf;

    // IMB_loadiffmem shouldn't be used anymore in new development
    // it's still here to be backwards compatible...

    maxlen= (GET_BIG_LONG(mem+1) + 1) & ~1;

    if (GET_ID(mem) == CAT) {
        mem += 3;
        maxlen -= 4;
        while(maxlen > 0) {
            if (GET_ID(mem) == FORM) {
                len = ((GET_BIG_LONG(mem+1) + 1) & ~1) + 8;
                if ((GET_ID(mem+2) == ILBM) || (GET_ID(mem+2) == ANIM)) break;
                mem = (int *)((uchar *)mem +len);
                maxlen -= len;
            } else return(0);
        }
    }

    if (maxlen > 0) {
        if (GET_ID(mem) == FORM) {
            if (GET_ID(mem+2) == ILBM) {
                return (imb_loadamiga(mem, flags));
            } else if (GET_ID(mem+5) == ILBM) {			/* animaties */
                return (imb_loadamiga(mem+3, flags));
            } else if (GET_ID(mem+2) == ANIM) {
                return (imb_loadanim(mem, flags));
            }
        } else if ((GS(mem) == IMAGIC) || (GSS(mem) == IMAGIC)) {
            return (imb_loadiris((uchar *) mem,flags));
        } else if ((BIG_LONG(mem[0]) & 0xfffffff0) == 0xffd8ffe0) {
            return (0);
        }
    }

    ibuf = imb_loadtarga((uchar *) mem,maxlen,flags);
    if (ibuf) return(ibuf);

    if (IB_verbose) fprintf(stderr,"Unknown fileformat\n");
    return (0);
}
Ejemplo n.º 5
0
static boolean
handle_app1 (j_decompress_ptr cinfo)
{
    INT32 length, i;
    char neogeo[128];

    INPUT_VARS(cinfo);

    length = 0;
    INPUT_2BYTES(cinfo, length, return FALSE);
    length -= 2;

    if (length < 16) {
        for (i = 0; i < length; i++) INPUT_BYTE(cinfo, neogeo[i], return FALSE);
        length = 0;
        if (strncmp(neogeo, "NeoGeo", 6) == 0) memcpy(&ibuf_ftype, neogeo + 6, 4);
        ibuf_ftype = BIG_LONG(ibuf_ftype);
    }
    INPUT_SYNC(cinfo);		/* do before skip_input_data */
    if (length > 0) (*cinfo->src->skip_input_data) (cinfo, length);
    return TRUE;
}
Ejemplo n.º 6
0
struct ImBuf *IMB_loadiffname(const char *naam, int flags) {
    int file;
    struct ImBuf *ibuf;
    int buf[1];

    file = open(naam, O_BINARY|O_RDONLY);

    if (file == -1) return (0);

    ibuf= IMB_loadifffile(file, flags);

    if (ibuf == NULL) {
        if (read(file, buf, 4) != 4) buf[0] = 0;
        if ((BIG_LONG(buf[0]) & 0xfffffff0) == 0xffd8ffe0)
            ibuf = imb_ibJpegImageFromFilename(naam, flags);
    }

    if (ibuf) {
        strncpy(ibuf->name, naam, sizeof(ibuf->name));
        if (flags & IB_fields) IMB_de_interlace(ibuf);
    }
    close(file);
    return(ibuf);
}
Ejemplo n.º 7
0
ImBuf *imb_loadtarga(unsigned char *mem, size_t mem_size, int flags, char colorspace[IM_MAX_SPACE])
{
	TARGA tga;
	struct ImBuf *ibuf;
	int col, count, size;
	unsigned int *rect, *cmap = NULL /*, mincol = 0*/, maxcol = 0;
	uchar *cp = (uchar *) &col;

	if (checktarga(&tga, mem) == 0) return(NULL);

	colorspace_set_default_role(colorspace, IM_MAX_SPACE, COLOR_ROLE_DEFAULT_BYTE);

	if (flags & IB_test) ibuf = IMB_allocImBuf(tga.xsize, tga.ysize, tga.pixsize, 0);
	else ibuf = IMB_allocImBuf(tga.xsize, tga.ysize, (tga.pixsize + 0x7) & ~0x7, IB_rect);

	if (ibuf == NULL) return(NULL);
	ibuf->ftype = TGA;
	mem = mem + 18 + tga.numid;
	
	cp[0] = 0xff;
	cp[1] = cp[2] = 0;
	
	if (tga.mapsize) {
		/* load color map */
		/*mincol = tga.maporig;*/ /*UNUSED*/
		maxcol = tga.mapsize;
		cmap = MEM_callocN(sizeof(unsigned int) * maxcol, "targa cmap");

		for (count = 0; count < maxcol; count++) {
			switch (tga.mapbits >> 3) {
				case 4:
					cp[0] = mem[3];
					cp[1] = mem[0];
					cp[2] = mem[1];
					cp[3] = mem[2];
					mem += 4;
					break;
				case 3:
					cp[1] = mem[0];
					cp[2] = mem[1];
					cp[3] = mem[2];
					mem += 3;
					break;
				case 2:
					cp[1] = mem[1];
					cp[0] = mem[0];
					mem += 2;
					break;
				case 1:
					col = *mem++;
					break;
			}
			cmap[count] = col;
		}
		
		size = 0;
		for (col = maxcol - 1; col > 0; col >>= 1) size++;
		ibuf->planes = size;

		if (tga.mapbits != 32) {    /* set alpha bits  */
			cmap[0] &= BIG_LONG(0x00ffffffl);
		}
	}
Ejemplo n.º 8
0
ImBuf *imb_loadtarga(const unsigned char *mem,
                     size_t mem_size,
                     int flags,
                     char colorspace[IM_MAX_SPACE])
{
  TARGA tga;
  struct ImBuf *ibuf;
  int count, size;
  unsigned int *rect, *cmap = NULL /*, mincol = 0*/, cmap_max = 0;
  int32_t cp_data;
  uchar *cp = (uchar *)&cp_data;

  if (checktarga(&tga, mem) == 0) {
    return NULL;
  }

  colorspace_set_default_role(colorspace, IM_MAX_SPACE, COLOR_ROLE_DEFAULT_BYTE);

  if (flags & IB_test) {
    ibuf = IMB_allocImBuf(tga.xsize, tga.ysize, tga.pixsize, 0);
  }
  else {
    ibuf = IMB_allocImBuf(tga.xsize, tga.ysize, (tga.pixsize + 0x7) & ~0x7, IB_rect);
  }

  if (ibuf == NULL) {
    return NULL;
  }
  ibuf->ftype = IMB_FTYPE_TGA;
  if (tga.imgtyp < 4) {
    ibuf->foptions.flag |= RAWTGA;
  }
  mem = mem + 18 + tga.numid;

  cp[0] = 0xff;
  cp[1] = cp[2] = 0;

  if (tga.mapsize) {
    /* load color map */
    /*mincol = tga.maporig;*/ /*UNUSED*/
    cmap_max = tga.mapsize;
    cmap = MEM_callocN(sizeof(unsigned int) * cmap_max, "targa cmap");

    for (count = 0; count < cmap_max; count++) {
      switch (tga.mapbits >> 3) {
        case 4:
          cp[0] = mem[3];
          cp[1] = mem[0];
          cp[2] = mem[1];
          cp[3] = mem[2];
          mem += 4;
          break;
        case 3:
          cp[1] = mem[0];
          cp[2] = mem[1];
          cp[3] = mem[2];
          mem += 3;
          break;
        case 2:
          cp[1] = mem[1];
          cp[0] = mem[0];
          mem += 2;
          break;
        case 1:
          cp_data = *mem++;
          break;
      }
      cmap[count] = cp_data;
    }

    size = 0;
    for (int cmap_index = cmap_max - 1; cmap_index > 0; cmap_index >>= 1) {
      size++;
    }
    ibuf->planes = size;

    if (tga.mapbits != 32) { /* set alpha bits  */
      cmap[0] &= BIG_LONG(0x00ffffffl);
    }
  }
Ejemplo n.º 9
0
Archivo: iff.c Proyecto: jinjoh/NOOR
unsigned short imb_start_iff(struct ImBuf *ibuf, int file)
{
	unsigned int *point, size, *buf;
	
	if ((point=buf=(unsigned int *)malloc(32768))==0) return FALSE;

	*point++ = FORM;				/* FORMxxxxILBM in buffer */
	*point++ = 0;

	if (IS_amiga(ibuf)){
		struct BitMapHeader *bmhd;

		*point++ = ILBM;
		*point++ = CAMG;
		*point++ = 4;
		*point++ = (ibuf->ftype & 0xffff);

		*point++=BMHD;
		*point++=sizeof(struct BitMapHeader);

		bmhd=(struct BitMapHeader *)point;		/* bmhd points to location where bmhd will be */
		point=(unsigned int *)((char *)point+sizeof(struct BitMapHeader));	/* advance pointer already */

		bmhd->w=ibuf->x;
		bmhd->h=ibuf->y;
		bmhd->pageWidth=ibuf->x;
		bmhd->pageHeight=ibuf->y;
		bmhd->x=0;
		bmhd->y=0;
		bmhd->nPlanes=ibuf->depth;
		bmhd->masking=0;
		if (ibuf->flags & IB_vert){
			bmhd->compression=2;
		}
		else{
			bmhd->compression=1;
		}
		bmhd->pad1=0;
		bmhd->transparentColor=0;
		bmhd->xAspect=1;
		bmhd->yAspect=1;
	} else if (IS_anim(ibuf)){
		struct Adat *adat;
		extern float adat_gamma;
		extern float adat_distort;
		
		*point++ = ANIM;
		*point++ = ADAT;
		*point++ = BIG_LONG(sizeof(struct Adat));

		adat = (struct Adat *)point;
		point = (unsigned int *)((char *)point+sizeof(struct Adat));	/* advance pointer already */

		adat->w = BIG_SHORT(ibuf->x);
		adat->h = BIG_SHORT(ibuf->y);

		adat->type = BIG_SHORT(ibuf->ftype);
		adat->xorig = BIG_SHORT(ibuf->xorig);
		adat->yorig = BIG_SHORT(ibuf->yorig);
		adat->pad = 0;
		adat->gamma = adat_gamma;
		adat->distort = adat_distort;
	}

	size=((uchar *)point-(uchar *)buf);
	if (write(file,buf,size)!=size){
		free(buf);
		return (FALSE);
	}

	if (ibuf->cmap){
		if (IS_anim(ibuf)){
			size = ibuf->maxcol * sizeof(int);
			buf[0] = CMAP;
			buf[1] = BIG_LONG(size);
			if (write(file,buf,8) != 8){
				free(buf);
				return (FALSE);
			}
			if (write(file,ibuf->cmap,size) != size){
				free(buf);
				return (FALSE);
			}
		} else{
			uchar *cpoint,*cols;
			unsigned int i,bits;

			point = buf;
			if (IS_amiga(ibuf)){
				*(point++) = CMAP;
				*(point++) = BIG_LONG(3*ibuf->maxcol);
			}

			cpoint = (uchar *) point;
			cols = (uchar *)ibuf->cmap;
			if ((ibuf->cbits > 0) && (ibuf->cbits < 8)){
				bits = ~((1 << (8-ibuf->cbits)) - 1);
			} else bits = -1;

			if (IS_ham(ibuf)) bits = -1;
			
			for (i=0 ; i<ibuf->maxcol ; i++){
				*(cpoint++) = cols[0] & bits;
				*(cpoint++) = cols[1] & bits;
				*(cpoint++) = cols[2] & bits;
				cols += 4;
			}
			if (ibuf->maxcol & 1) *(cpoint++)=0;

			size=(cpoint-(uchar *)buf);
			if (write(file,buf,size)!=size){
				free(buf);
				return (FALSE);
			}
		}
	}

	if (IS_amiga(ibuf)) buf[0] = BODY;
	if (IS_anim(ibuf)) buf[0] = BODY;
	buf[1]=0;

	if (write(file,buf,8)!=8){
		free(buf);
		return(FALSE);
	}

	free(buf);
	return (TRUE);
}
Ejemplo n.º 10
0
static void write_jpeg(struct jpeg_compress_struct * cinfo, struct ImBuf * ibuf)
{
    JSAMPLE * buffer = NULL;
    JSAMPROW row_pointer[1];
    uchar * rect;
    int x, y;
    char neogeo[128];
    ImMetaData *iptr;
    char *text;

    jpeg_start_compress(cinfo, TRUE);

    strcpy(neogeo, "NeoGeo");
    ibuf_ftype = BIG_LONG(ibuf->ftype);

    memcpy(neogeo + 6, &ibuf_ftype, 4);
    jpeg_write_marker(cinfo, 0xe1, (JOCTET*) neogeo, 10);

    if(ibuf->metadata) {
        /* key + max value + "Blender" */
        text= MEM_mallocN(530, "stamp info read");
        iptr= ibuf->metadata;
        while(iptr) {
            if (!strcmp (iptr->key, "None")) {
                jpeg_write_marker(cinfo, JPEG_COM, (JOCTET *) iptr->value, strlen (iptr->value) + 1);
                goto next_stamp_info;
            }

            /*
             * The JPEG format don't support a pair "key/value"
             * like PNG, so we "encode" the stamp in a
             * single string:
             *	"Blender:key:value"
             *
             * The first "Blender" is a simple identify to help
             * in the read process.
             */
            sprintf (text, "Blender:%s:%s", iptr->key, iptr->value);
            jpeg_write_marker(cinfo, JPEG_COM, (JOCTET *) text, strlen (text)+1);
next_stamp_info:
            iptr = iptr->next;
        }
        MEM_freeN(text);
    }

    row_pointer[0] =
        MEM_mallocN(sizeof(JSAMPLE) *
                    cinfo->input_components *
                    cinfo->image_width, "jpeg row_pointer");

    for(y = ibuf->y - 1; y >= 0; y--) {
        rect = (uchar *) (ibuf->rect + y * ibuf->x);
        buffer = row_pointer[0];

        switch(cinfo->in_color_space) {
        case JCS_RGB:
            for (x = 0; x < ibuf->x; x++) {
                *buffer++ = rect[0];
                *buffer++ = rect[1];
                *buffer++ = rect[2];
                rect += 4;
            }
            break;
        case JCS_GRAYSCALE:
            for (x = 0; x < ibuf->x; x++) {
                *buffer++ = rect[0];
                rect += 4;
            }
            break;
        case JCS_UNKNOWN:
            memcpy(buffer, rect, 4 * ibuf->x);
            break;
        /* default was missing... intentional ? */
        default:
            ; /* do nothing */
        }

        jpeg_write_scanlines(cinfo, row_pointer, 1);
    }

    jpeg_finish_compress(cinfo);
    MEM_freeN(row_pointer[0]);
}
Ejemplo n.º 11
0
static void bptolscanl(unsigned int *buf, int size, unsigned int **list, int nobp, int offset)
{
	/* 	converts bitplanes to a buffer with ints
	by 4 dividiable amount of bitplanes,
	the width of bitplanes is rounded at ints 	*/

	list += nobp;

	for (;nobp>0;)
	{
		int todo,i;
		register int bp1, bp2, bp3, bp4, data;
		register unsigned int *point;
		int loffset;
		/*register unsigned int bp1, bp2, bp3, bp4;*/

		bp1 = bp2 = bp3 = bp4 = todo = 0;
		point = buf;
		loffset = offset;

		if (nobp & 1){
			list -= 1;
			nobp -= 1;
			for(i=size;i>0;i--)
			{
				if (todo==0)
				{
					bp1 = BIG_LONG((list[0])[loffset]);
					loffset++;
					todo=32;
				}

				data = *point;
				data<<=1;

				if (bp1<0) data+=1;
				bp1<<=1;

				/*		data += (bp1 >> 31);
					bp1 <<= 1;
				*/
				*(point++)=data;
				todo--;
			}
		} else if (nobp & 2){
			list -= 2;
			nobp -= 2;
			for(i=size;i>0;i--)
			{
				if (todo==0)
				{
					bp1 = BIG_LONG((list[0])[loffset]);
					bp2 = BIG_LONG((list[1])[loffset]);
					loffset++;
					todo=32;
				}

				data = *point;
				data<<=2;

				if (bp1<0) data+=1;
				bp1<<=1;
				if (bp2<0) data+=2;
				bp2<<=1;

				/*		data += (bp1 >> 31) + ((bp2 & 0x80000000) >> 30);
				bp1 <<= 1; bp2 <<= 1;
				*/
				*(point++)=data;
				todo--;
			}
		} else{
			list -= 4;
			nobp -= 4;
			for(i=size;i>0;i--)
			{
				if (todo==0) {
					bp1 = BIG_LONG((list[0])[loffset]);
					bp2 = BIG_LONG((list[1])[loffset]);
					bp3 = BIG_LONG((list[2])[loffset]);
					bp4 = BIG_LONG((list[3])[loffset]);
					loffset++;
					todo=32;
				}

				data = *point;
				data<<=4;

				if (bp1<0) data+=1;
				bp1<<=1;
				if (bp2<0) data+=2;
				bp2<<=1;
				if (bp3<0) data+=4;
				bp3<<=1;
				if (bp4<0) data+=8;
				bp4<<=1;

				/*		data += (bp1 >> 31) \
				+ ((bp2 & 0x80000000) >> 30) \
				+ ((bp3 & 0x80000000) >> 29) \
				+ ((bp4 & 0x80000000) >> 28);
		
				bp1 <<= 1; bp2 <<= 1;
				bp3 <<= 1; bp4 <<= 1;
				*/
				
				*(point++)=data;
				todo--;
			}
		}
	}
}