int FastZoom(FZOOM_DATA *data) { FZOOM_DATA fzdata ; MFDB std_src, std_dst ; MFDB *pstd_src, *pstd_dst ; int use_std_vdi = NeedStdVDI(data->src->fd_nplanes) ; if ( use_std_vdi ) { if ( data->std_src ) { std_src.fd_addr = NULL ; pstd_src = data->std_src ; } else { memcpy( &std_src, data->src, sizeof(MFDB) ) ; std_src.fd_addr = img_alloc( std_src.fd_w, std_src.fd_h, std_src.fd_nplanes ) ; if ( std_src.fd_addr == NULL ) return( -3 ) ; std_src.fd_stand = 1 ; pstd_src = &std_src ; } if ( data->std_dst ) { std_dst.fd_addr = NULL ; pstd_dst = data->std_dst ; } else { memcpy( &std_dst, data->dst, sizeof(MFDB) ) ; std_dst.fd_addr = img_alloc( std_dst.fd_w, std_dst.fd_h, std_dst.fd_nplanes ) ; if ( std_dst.fd_addr == NULL ) { if ( std_src.fd_addr ) free( std_src.fd_addr ) ; return( -3 ) ; } std_dst.fd_stand = 1 ; pstd_dst = &std_dst ; } vr_trnfm( handle, data->src, pstd_src ) ; StdVDI2ClassicAtari( pstd_src, data->src ) ; memcpy( &fzdata, data, sizeof(FZOOM_DATA) ) ; fzdata.std_src = pstd_src ; fzdata.std_dst = pstd_dst ; } else memcpy( &fzdata, data, sizeof(FZOOM_DATA) ) ; fast_zoom( &fzdata ) ; if ( use_std_vdi ) { ClassicAtari2StdVDI( fzdata.dst, pstd_dst ) ; vr_trnfm( handle, pstd_dst, fzdata.dst ) ; vr_trnfm( handle, pstd_src, data->src ) ; if ( std_dst.fd_addr ) free( std_dst.fd_addr ) ; if ( std_src.fd_addr ) free( std_src.fd_addr ) ; } return( 0 ) ; }
/* jpeg_load_img: * Read a JPEG file into an image. */ int jpeg_load_img(img I) { struct jpeg_decompress_struct *cinfo = I->us; struct my_error_mgr *jerr; JSAMPARRAY buffer; img_alloc(I); jerr = (struct my_error_mgr*)cinfo->err; if (setjmp(jerr->jb)) { /* Oops, something went wrong. */ I->err = IE_IMGFORMAT; jpeg_destroy_decompress(cinfo); return 0; } cinfo->out_color_space = JCS_RGB; cinfo->out_color_components = cinfo->output_components = 3; /* Start decompression. */ buffer = cinfo->mem->alloc_sarray((j_common_ptr)cinfo, JPOOL_IMAGE, cinfo->output_width * cinfo->output_components, 1); while (cinfo->output_scanline < cinfo->output_height) { pel *p, *end; unsigned char *q; jpeg_read_scanlines(cinfo, buffer, 1); /* Now we have a buffer in RGB format. */ for (p = I->data[cinfo->output_scanline - 1], end = p + I->width, q = (unsigned char*)buffer[0]; p < end; ++p, q += 3) *p = PEL(*q, *(q + 1), *(q + 2)); } jpeg_finish_decompress(cinfo); jpeg_destroy_decompress(cinfo); return 1; }
IMAGE *img_creat(char *name, int nr, int nc) { int i, j; IMAGE *newptr; newptr = img_alloc(); newptr->data = (int *) malloc ((unsigned) (nr * nc * sizeof(int))); newptr->name = img_basename(name); newptr->rows = nr; newptr->cols = nc; for (i = 0; i < nr; i++) { for (j = 0; j < nc; j++) { img_setpixel(newptr, i, j, 0); } } return (newptr); }
int mac_load(char *name, MFDB *out, GEM_WINDOW *wprog) { FILE *stream ; size_t taille ; void *in ; perf_start( PERF_DISK, &PerfInfo ) ; stream = fopen(name, "rb") ; if (stream == NULL) return(-1) ; fseek(stream, 0x280, SEEK_SET) ; out->fd_nplanes = 1 ; out->fd_w = 576 ; out->fd_h = 720 ; out->fd_stand = 0 ; out->fd_wdwidth = out->fd_w/16 ; out->fd_addr = img_alloc(576, 720, 1) ; if (out->fd_addr == NULL) { fclose(stream) ; return(-3) ; } taille = file_size(name)-sizeof(MACPAINT_HEADER) ; in = malloc(taille) ; if (in == NULL) { fclose(stream) ; free(out->fd_addr) ; return(-3) ; } fread(in, taille, 1, stream) ; fclose(stream) ; perf_stop( PERF_DISK, &PerfInfo ) ; perf_start( PERF_COMPRESS, &PerfInfo ) ; packbits_dcmps(in, out->fd_addr, out->fd_w, out->fd_h, out->fd_nplanes) ; perf_stop( PERF_COMPRESS, &PerfInfo ) ; free(in) ; return(0) ; }
/* make_backing_image: * Create the img structure which represents our back-buffer. */ void make_backing_image() { img I; I = img_new_blank(width, height); img_alloc(I); /* wry += height - backing_image->height; if (wry < BORDER || wry > height - BORDER) wry = height - BORDER;*/ if (backing_image) { int w2, h2; struct imgrect *ir; /* Copy old contents of backing image to ll corner of new one. */ w2 = backing_image->width; if (w2 > width) w2 = width; h2 = backing_image->height; if (h2 > height) h2 = height; img_simple_blt(I, 0, height - h2, backing_image, 0, backing_image->height - h2, w2, h2); /* Move all of the image rectangles. */ for (ir = imgrects; ir < imgrects + nimgrects; ++ir) { if (ir->filename) { ir->y += height - backing_image->height; /* Possible it has scrolled off the window. */ if (ir->x > width || ir->y + ir->h < 0) { unlink(ir->filename); xfree(ir->filename); memset(ir, 0, sizeof *ir); } } } /* Adjust placement of new images. */ if (wrx >= w2) wrx = w2; img_delete(backing_image); } backing_image = I; wrx = BORDER; wry = height - BORDER; rowheight = 2 * BORDER; }
IMAGE *img_open(char *filename) { IMAGE *newptr; FILE *pgm; char line[512], intbuf[100], ch; int type, nc, nr, maxval, i, j, k, found; newptr = img_alloc(); if ((pgm = fopen(filename, "r")) == NULL) { printf("IMGOPEN: Couldn't open '%s'\n", filename); return(NULL); } newptr->name = img_basename(filename); /*** Scan pnm type information, expecting P5 ***/ fgets(line, 511, pgm); sscanf(line, "P%d", &type); if (type != 5 && type != 2) { printf("IMGOPEN: Only handles pgm files (type P5 or P2)\n"); fclose(pgm); return(NULL); } /*** Get dimensions of pgm ***/ fgets(line, 511, pgm); sscanf(line, "%d %d", &nc, &nr); newptr->rows = nr; newptr->cols = nc; /*** Get maxval ***/ fgets(line, 511, pgm); sscanf(line, "%d", &maxval); if (maxval > 255) { printf("IMGOPEN: Only handles pgm files of 8 bits or less\n"); fclose(pgm); return(NULL); } newptr->data = (int *) malloc ((unsigned) (nr * nc * sizeof(int))); if (newptr->data == NULL) { printf("IMGOPEN: Couldn't allocate space for image data\n"); fclose(pgm); return(NULL); } if (type == 5) { for (i = 0; i < nr; i++) { for (j = 0; j < nc; j++) { img_setpixel(newptr, i, j, fgetc(pgm)); } } } else if (type == 2) { for (i = 0; i < nr; i++) { for (j = 0; j < nc; j++) { k = 0; found = 0; while (!found) { ch = (char) fgetc(pgm); if (ch >= '0' && ch <= '9') { intbuf[k] = ch; k++; } else { if (k != 0) { intbuf[k] = '\0'; found = 1; } } } img_setpixel(newptr, i, j, atoi(intbuf)); } } } else { printf("IMGOPEN: Fatal impossible error\n"); fclose(pgm); return (NULL); } fclose(pgm); return (newptr); }
int_m bmp_read(const char *file_name, image_buffer *result) { FILE *file = fopen(file_name, "rb"); if (file == NULL) { fprintf(stderr, "error opening file: %s\n", file_name); return 0; } bitmap_header bmp; if (fread(&bmp, 1, sizeof(bmp), file) != sizeof(bmp)) { fprintf(stderr, "%s\n", "error reading header of bitmap."); fclose(file); return 0; } if (bmp.fileheader.filetype[0] != 'B' || bmp.fileheader.filetype[1] != 'M' || bmp.headersize != sizeof(bitmap_header) - sizeof(file_header) || bmp.planes != 1 || bmp.bitsperpixel != 24 || bmp.compression != 0) { fprintf(stderr, "%s\n", "error reading bitmap. invalid header."); fclose(file); return 0; } if (!img_alloc(bmp.width, bmp.height, result)) { fprintf(stderr, "%s\n", "error reading bitmap, cannot allocate image."); fclose(file); return 0; } uint_m buffer_size = 3 * result->width * result->height; if (fread(result->pixels, 1, buffer_size, file) != buffer_size) { fprintf(stderr, "%s\n", "error reading bitmap, cannot read full buffer."); img_dealloc(result); fclose(file); return 0; } uint_m scanline_length = result->width * 3; for (uint32_t i = 0; i < result->height; ++i) { uint8_t *scanline = (uint8_t *)&result->pixels[i * result->width]; for (uint32_t j = 0; j < scanline_length;) { uint8_t temp = scanline[j]; scanline[j] = scanline[j + 2]; scanline[j + 2] = temp; j += 3; } } fclose(file); return 1; }
int png_load_img(img I) { unsigned char **p, **q; png_structp png_ptr; png_infop info_ptr; png_uint_32 width, height; int i, j, bit_depth, color_type, interlace_type; png_bytepp row_pointers; img_alloc(I); png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, png_catch_error, NULL); if (png_ptr == NULL) { I->err = IE_HDRFORMAT; return 0; } if (setjmp(png_jmpbuf(png_ptr))) { png_destroy_read_struct(&png_ptr, (png_infopp)NULL, (png_infopp)NULL); I->err = IE_HDRFORMAT; return 0; } info_ptr = png_create_info_struct(png_ptr); if (info_ptr == NULL) { png_destroy_read_struct(&png_ptr, (png_infopp)NULL, (png_infopp)NULL); I->err = IE_HDRFORMAT; return 0; } rewind(I->fp); png_init_io(png_ptr, I->fp); png_read_info(png_ptr, info_ptr); /* Get image specific data */ png_get_IHDR(png_ptr, info_ptr, &width, &height, &bit_depth, &color_type, &interlace_type, NULL, NULL); /* Convert greyscale images to 8-bit RGB */ if (color_type == PNG_COLOR_TYPE_GRAY || color_type == PNG_COLOR_TYPE_GRAY_ALPHA) { if (bit_depth < 8) { png_set_expand_gray_1_2_4_to_8(png_ptr); } png_set_gray_to_rgb(png_ptr); } /* Change paletted images to RGB */ if (color_type == PNG_COLOR_TYPE_PALETTE) png_set_expand(png_ptr); if (bit_depth < 8) png_set_expand(png_ptr); if (bit_depth == 16) png_set_strip_16(png_ptr); /* The gdk img widget appears to expect 8-bit RGB followed by a * filler byte. */ png_set_filler(png_ptr, 0, PNG_FILLER_AFTER); /* Update the info structure after the transforms */ png_read_update_info(png_ptr, info_ptr); /* png_set_rows(png_ptr, info_ptr, row_pointers)*/ /* Allocate space before reading the image */ row_pointers = png_malloc(png_ptr, height * sizeof(png_bytep)); for (i = 0; i < height; i++) { row_pointers[i] = png_malloc(png_ptr, png_get_rowbytes(png_ptr, info_ptr)); } /* Read in the image and copy it to the gdk img structure */ png_read_image(png_ptr, row_pointers); p = (unsigned char **)I->data; q = (unsigned char **)row_pointers; for (i = 0; i < height; i++) { for (j = 0; j < png_get_rowbytes(png_ptr, info_ptr); j++) { p[i][j] = q[i][j]; } } png_read_end(png_ptr, info_ptr); /* Clean up */ png_free(png_ptr, row_pointers); png_destroy_read_struct(&png_ptr, &info_ptr, (png_infopp)NULL); return 1; }
/* gif_load_img: * Load GIF image. */ int gif_load_img(img I) { GifFileType *g = I->us; struct SavedImage *si; int ret = 0; unsigned char *p, *end; GifColorType *pal; pel *q; if (DGifSlurp(g) == GIF_ERROR) { I->err = IE_IMGFORMAT; return 0; } /* Now allocate memory and copy the image into it. */ img_alloc(I); /* Retrieve only the first image. */ if (g->ImageCount < 1) { I->err = IE_IMGFORMAT; goto fail; } si = g->SavedImages; if (si->ImageDesc.Width != I->width || si->ImageDesc.Height != I->height) { I->err = IE_IMGFORMAT; goto fail; } if (si->ImageDesc.ColorMap) pal = si->ImageDesc.ColorMap->Colors; else pal = g->SColorMap->Colors; if (si->ImageDesc.Interlace) { int i; unsigned char *gifsrc = si->RasterBits; /* Deal with deranged interlaced GIF file. */ #define COPYROW(src, dest) for (p = (src), q = (dest); p < (src) + I->width; ++p, ++q) \ *q = PELA(pal[*p].Red, pal[*p].Green, pal[*p].Blue, *p == g->SBackGroundColor ? 255 : 0); /* Pass 1: every 8th row, starting at row 0. */ for (i = 0; i < I->height; i += 8) { COPYROW(gifsrc, I->data[i]); gifsrc += I->width; } /* Pass 2: every 8th row, starting at row 4. */ for (i = 4; i < I->height; i += 8) { COPYROW(gifsrc, I->data[i]); gifsrc += I->width; } /* Pass 3: every 4th row, starting at row 2. */ for (i = 2; i < I->height; i += 4) { COPYROW(gifsrc, I->data[i]); gifsrc += I->width; } /* Pass 4: every 2nd row, starting at row 1. */ for (i = 1; i < I->height; i += 2) { COPYROW(gifsrc, I->data[i]); gifsrc += I->width; } } else for (p = (unsigned char*)si->RasterBits, end = p + I->width * I->height, q = I->flat; p < end; ++p, ++q) *q = PELA(pal[*p].Red, pal[*p].Green, pal[*p].Blue, *p == g->SBackGroundColor ? 255 : 0); ret = 1; fail: DGifCloseFile(g); return ret; }
void clip_put(GEM_WINDOW *gwnd, int x1, int y1, int x2, int y2) { VXIMAGE *vimage ; int xy[8] ; int temp ; int larg ; int w, h ; if ( !GWIsWindowValid( gwnd ) ) return ; vimage = (VXIMAGE *) gwnd->Extension ; if (x2 < x1) { temp = x1 ; x1 = x2 ; x2 = temp ; } if (y2 < y1) { temp = y1 ; y1 = y2 ; y2 = temp ; } FreeClipboard() ; w = 1+x2-x1 ; h = 1+y2-y1 ; if (w % 16) larg = (16+w) & 0xFFF0 ; else larg = w ; if (larg < MINIW) larg = MINIW ; if (h < MINIH) h = MINIH ; clipboard.img.fd_addr = img_alloc(larg, h, nb_plane) ; if (clipboard.img.fd_addr == NULL) { form_error(8) ; return ; } clipboard.img.fd_w = larg ; clipboard.img.fd_h = h ; clipboard.img.fd_wdwidth = larg/16 ; clipboard.img.fd_nplanes = nb_plane ; clipboard.img.fd_stand = 0 ; clipboard.gwindow = gwnd ; clipboard.x = x1 ; clipboard.y = y1 ; clipboard.w = 1+x2-x1 ; clipboard.h = 1+y2-y1 ; img_raz(&clipboard.img) ; xy[0] = x1 ; xy[1] = y1 ; xy[2] = x2 ; xy[3] = y2 ; xy[4] = 0 ; xy[5] = 0 ; xy[6] = x2-x1 ; xy[7] = y2-y1 ; vro_cpyfm(handle, S_ONLY, xy, &vimage->raster, &clipboard.img) ; if ( config.clip_gem == 1 ) { char name[PATH_MAX] ; mouse_busy() ; if ( clbd_getpath( name ) == 0 ) { INFO_IMAGE info ; IMG_MODULE *img_module ; memcpy( &info, &vimage->inf_img, sizeof(INFO_IMAGE) ) ; info.largeur = clipboard.img.fd_w ; info.hauteur = clipboard.img.fd_h ; info.compress = 1 ; strcat( name, "SCRAP." ) ; if ( Truecolor ) info.lformat = IID_TIFF ; else info.lformat = IID_IMG ; img_module = DImgGetModuleFromIID( info.lformat ) ; if ( img_module ) { strcat( name, img_module->Capabilities.file_extension ) ; save_picture( name, &clipboard.img, &info, NULL ) ; } } mouse_restore() ; } }
int init_rtmemory(void) { int err = 0 ; if ( RTZoomSrc.fd_addr != NULL ) free( RTZoomSrc.fd_addr ) ; if ( RTZoomDst.fd_addr != NULL ) free( RTZoomDst.fd_addr ) ; if ( RTZoomSrcStd.fd_addr != NULL ) free( RTZoomSrcStd.fd_addr ) ; if ( RTZoomDstStd.fd_addr != NULL ) free( RTZoomDstStd.fd_addr ) ; memset( &RTZoomSrc, 0, sizeof(MFDB) ) ; RTZoomSrc.fd_w = config.rt_width / config.rt_zoomlevel ; if ( RTZoomSrc.fd_w % 16 ) RTZoomSrc.fd_w = ( RTZoomSrc.fd_w + 16 ) & 0xFFF0 ; RTZoomSrc.fd_wdwidth = RTZoomSrc.fd_w / 16 ; if ( RTZoomSrc.fd_w % 16 ) RTZoomSrc.fd_wdwidth++ ; RTZoomSrc.fd_h = config.rt_height / config.rt_zoomlevel ; RTZoomSrc.fd_nplanes = nb_plane ; RTZoomSrc.fd_addr = img_alloc( RTZoomSrc.fd_w, RTZoomSrc.fd_h, RTZoomSrc.fd_nplanes ) ; if ( RTZoomSrc.fd_addr == NULL ) err = -3 ; else img_raz( &RTZoomSrc ) ; if ( !err ) { memset( &RTZoomDst, 0, sizeof(MFDB) ) ; RTZoomDst.fd_w = RTZoomSrc.fd_w * config.rt_zoomlevel ; RTZoomDst.fd_wdwidth = RTZoomDst.fd_w / 16 ; if ( RTZoomDst.fd_w %16 ) RTZoomDst.fd_wdwidth++ ; RTZoomDst.fd_h = config.rt_height ; RTZoomDst.fd_nplanes = nb_plane ; RTZoomDst.fd_addr = img_alloc( RTZoomDst.fd_w, RTZoomDst.fd_h, RTZoomDst.fd_nplanes ) ; if ( RTZoomDst.fd_addr == NULL ) { err = -3 ; free( RTZoomSrc.fd_addr ) ; memset( &RTZoomSrc, 0, sizeof(MFDB) ) ; } else img_raz( &RTZoomDst ) ; } StdVDINeeded = (char)FZNeedStdFormat ; if ( !err && StdVDINeeded ) { /* Il va y avoir des allocations suppl‚mentaires */ memcpy( &RTZoomSrcStd, &RTZoomSrc, sizeof(MFDB) ) ; RTZoomSrcStd.fd_stand = 1 ; RTZoomSrcStd.fd_addr = img_alloc( RTZoomSrcStd.fd_w, RTZoomSrcStd.fd_h, RTZoomSrcStd.fd_nplanes ) ; if ( RTZoomSrcStd.fd_addr == NULL ) { err = -3 ; free( RTZoomSrc.fd_addr ) ; memset( &RTZoomSrc, 0, sizeof(MFDB) ) ; free( RTZoomDst.fd_addr ) ; memset( &RTZoomDst, 0, sizeof(MFDB) ) ; } else img_raz( &RTZoomSrcStd ) ; if ( !err ) { memcpy( &RTZoomDstStd, &RTZoomDst, sizeof(MFDB) ) ; RTZoomDstStd.fd_stand = 1 ; RTZoomDstStd.fd_addr = img_alloc( RTZoomDstStd.fd_w, RTZoomDstStd.fd_h, RTZoomDstStd.fd_nplanes ) ; if ( RTZoomDstStd.fd_addr == NULL ) { err = -3 ; free( RTZoomSrcStd.fd_addr ) ; memset( &RTZoomSrcStd, 0, sizeof(MFDB) ) ; free( RTZoomSrc.fd_addr ) ; memset( &RTZoomSrc, 0, sizeof(MFDB) ) ; free( RTZoomDst.fd_addr ) ; memset( &RTZoomDst, 0, sizeof(MFDB) ) ; } else img_raz( &RTZoomDstStd ) ; } } return( err ) ; }