| /********************************************************************** |
| * File: imgio.c (Formerly imageio.c) |
| * Description: Controls image input/output and selection of format. |
| * Author: Ray Smith |
| * Created: Mon Jun 11 11:47:26 BST 1990 |
| * |
| * (C) Copyright 1990, Hewlett-Packard Ltd. |
| ** Licensed under the Apache License, Version 2.0 (the "License"); |
| ** you may not use this file except in compliance with the License. |
| ** You may obtain a copy of the License at |
| ** http://www.apache.org/licenses/LICENSE-2.0 |
| ** Unless required by applicable law or agreed to in writing, software |
| ** distributed under the License is distributed on an "AS IS" BASIS, |
| ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| ** See the License for the specific language governing permissions and |
| ** limitations under the License. |
| * |
| **********************************************************************/ |
| |
| #include "mfcpch.h" //precompiled headers |
| #ifdef __MSW32__ |
| #include <io.h> |
| #else |
| #include <unistd.h> |
| #endif |
| #include <fcntl.h> |
| #include <sys/types.h> |
| #include <sys/stat.h> |
| #include <string.h> |
| #include "scanutils.h" |
| #include "stderr.h" |
| #include "fileerr.h" |
| #include "imgerrs.h" |
| #include "memry.h" |
| #include "imgs.h" |
| #include "imgbmp.h" |
| #include "imgtiff.h" |
| #include "imgio.h" |
| |
| #define DEFAULTIMAGETYPE "tif" //default to im files |
| |
| typedef struct |
| { |
| const char *string; //extension |
| IMAGE_OPENER opener; //opening function |
| IMAGE_READER reader; //reading function |
| IMAGE_WRITER writer; //writing function |
| } IMAGETYPE; //image type record |
| |
| static IMAGETYPE imagetypes[] = { { |
| "TIF", |
| open_tif_image, |
| read_tif_image, |
| write_moto_tif |
| }, |
| { |
| "itf", |
| open_tif_image, |
| read_tif_image, |
| write_inverse_tif |
| }, |
| { |
| "tif", |
| open_tif_image, |
| read_tif_image, |
| write_intel_tif |
| }, |
| { |
| "bmp", |
| open_bmp_image, |
| read_bmp_image, |
| write_bmp_image |
| }, |
| }; //image readers/writers |
| |
| #define MAXIMAGETYPES (sizeof(imagetypes)/sizeof(IMAGETYPE)) |
| |
| /********************************************************************** |
| * name_to_image_type |
| * |
| * Convert a file name to an image type, picking defaults if it is |
| * has no extension, and complaining if the extension is not supported. |
| **********************************************************************/ |
| |
| static inT8 name_to_image_type( //get image type |
| const char *name //name of image |
| ) { |
| const char *nametype; //type part of name |
| inT8 type; //imagetypes index |
| |
| nametype = strrchr (name, '.');//find extension |
| if (nametype != NULL) |
| nametype++; //ptr to extension |
| else |
| nametype = DEFAULTIMAGETYPE; //had none |
| |
| //find type of image |
| for (type = 0; type < MAXIMAGETYPES && strcmp (imagetypes[type].string, nametype); type++); |
| if (type >= MAXIMAGETYPES) { |
| //unrecognized type |
| BADIMAGETYPE.error ("name_to_image_type", TESSLOG, name); |
| return -1; |
| } |
| return type; |
| } |
| |
| |
| /********************************************************************** |
| * read_header |
| * |
| * Read the header of an image, typed according to the extension of |
| * the name. Return is 0 for success, -1 for failure. |
| **********************************************************************/ |
| |
| inT8 IMAGE::read_header( //get file header |
| const char *name //name of image |
| ) { |
| inT8 type; //image type |
| |
| destroy(); //destroy old image |
| //get type |
| type = name_to_image_type (name); |
| if (type < 0 || imagetypes[type].opener == NULL) { |
| CANTREADIMAGETYPE.error ("IMAGE::read_header", TESSLOG, name); |
| return -1; //read not supported |
| } |
| #ifdef __UNIX__ |
| if ((fd = open (name, O_RDONLY)) < 0) |
| #endif |
| #if defined (__MSW32__) || defined (__MAC__) |
| if ((fd = open (name, O_RDONLY | O_BINARY)) < 0) |
| #endif |
| { |
| CANTOPENFILE.error ("IMAGE::read_header", TESSLOG, name); |
| return -1; //failed |
| } |
| lineskip = |
| (*imagetypes[type].opener) (fd, &xsize, &ysize, &bpp, &photo_interp, |
| &res); |
| if (lineskip == -1) { |
| //get header |
| bpp = 0; //still empty |
| close(fd); |
| fd = -1; |
| return -1; //failed |
| } |
| if (res <= 0) |
| res = image_default_resolution; |
| // fprintf(stderr,"Image size=(%d,%d), bpp=%d\n", |
| // xsize,ysize,bpp); |
| //bytes per line |
| xdim = COMPUTE_IMAGE_XDIM (xsize, bpp); |
| bps = bpp == 24 ? 8 : bpp; |
| bytespp = (bpp + 7) / 8; |
| //funtion to read with |
| reader = imagetypes[type].reader; |
| return 0; //success |
| } |
| |
| |
| /********************************************************************** |
| * read |
| * |
| * Read a previously opened image file into memory. |
| * If buflines is 0, the whole image is read in one go. |
| * If buflines>0, memory space is reserved for reading just that many |
| * lines at once. |
| * As soon as a request is made to get a line past the end of the buffer, |
| * the buffer is re-read with a 50% overlap. |
| * Backward seeks are not allowed. |
| * Read returns -1 in case of failure or 0 if successful. |
| **********************************************************************/ |
| |
| inT8 IMAGE::read( //get rest of image |
| inT32 buflines //size of buffer |
| ) { |
| inT32 row; //image row |
| BOOL8 failed; //read failed |
| |
| if (fd < 0 || image != NULL) |
| IMAGEUNDEFINED.error ("IMAGE::read", ABORT, NULL); |
| |
| if (buflines <= 0 || buflines > ysize || reader == NULL) |
| buflines = ysize; //default to all |
| bufheight = buflines; |
| image = |
| (uinT8 *) alloc_big_mem ((size_t) (xdim * bufheight * sizeof (uinT8))); |
| if (image == NULL) { |
| MEMORY_OUT.error ("IMAGE::read", TESSLOG, NULL); |
| destroy(); |
| return -1; |
| } |
| captured = FALSE; |
| ymax = ysize; |
| ymin = ysize - buflines; //amount of image read |
| if (reader != NULL && lineskip < 0) |
| failed = (*reader) (fd, image, xsize, ysize, bpp, xdim) < 0; |
| else { |
| if (lineskip == 0) |
| failed =::read (fd, (char *) image, |
| (size_t) (xdim * bufheight)) != xdim * bufheight; |
| else { |
| for (failed = FALSE, row = 0; row < bufheight && !failed; row++) { |
| failed =::read (fd, (char *) image + row * xdim, |
| (size_t) xdim) != xdim; |
| failed |= lseek (fd, lineskip, SEEK_CUR) < 0; |
| } |
| } |
| } |
| if (failed) { |
| READFAILED.error ("IMAGE::read", TESSLOG, NULL); |
| destroy(); |
| return -1; //read failed |
| } |
| if (ymin <= 0) { |
| close(fd); //finished reading |
| fd = -1; //not open now |
| } |
| return 0; //success |
| } |
| |
| |
| /********************************************************************** |
| * bufread |
| * |
| * Read a bit more of an image into the buffer. |
| **********************************************************************/ |
| |
| inT8 IMAGE::bufread( //read more into buffer |
| inT32 y //required coord |
| ) { |
| inT32 readtop; //no of lines copied |
| inT32 linestoread; //no of lines to read |
| inT32 row; //row to read |
| BOOL8 failed; //read failed |
| |
| //copy needed? |
| if (y + bufheight / 2 >= ymin) { |
| //no of lines to move |
| readtop = y + bufheight / 2 - ymin + 1; |
| //copy inside it |
| copy_sub_image (this, 0, ymin, xsize, readtop, this, 0, ymax - readtop, TRUE); |
| } |
| else |
| readtop = 0; |
| ymax = y + bufheight / 2; //new top of image |
| ymin = ymax - bufheight; //possible bottom |
| if (ymin < 0) |
| ymin = 0; //clip to image size |
| linestoread = ymax - ymin - readtop; |
| if (lineskip == 0) |
| failed =::read (fd, (char *) (image + xdim * readtop), |
| (size_t) (xdim * linestoread)) != xdim * linestoread; |
| else { |
| for (failed = FALSE, row = 0; row < linestoread && !failed; row++) { |
| failed =::read (fd, (char *) (image + (readtop + row) * xdim), |
| (size_t) xdim) != xdim; |
| failed |= lseek (fd, lineskip, SEEK_CUR) < 0; |
| } |
| } |
| if (failed) { |
| READFAILED.error ("IMAGE::bufread", TESSLOG, NULL); |
| return -1; //read failed |
| } |
| if (ymin <= 0) { |
| close(fd); //finished reading |
| fd = -1; //not open now |
| } |
| return 0; //success |
| } |
| |
| |
| /********************************************************************** |
| * write |
| * |
| * Write an image to a file in a format determined by the name. |
| **********************************************************************/ |
| |
| inT8 IMAGE::write( //write image |
| const char *name //name to write |
| ) { |
| inT8 type; //type of image |
| |
| if (bpp == 0 || image == NULL || bufheight != ysize) |
| IMAGEUNDEFINED.error ("IMAGE::write", ABORT, NULL); |
| if (fd >= 0) { |
| close(fd); //close old file |
| fd = -1; //no longer open |
| } |
| //get image type |
| type = name_to_image_type (name); |
| if (type < 0 || imagetypes[type].writer == NULL) { |
| CANTWRITEIMAGETYPE.error ("IMAGE::write", TESSLOG, name); |
| return -1; //write not supported |
| } |
| #ifdef __UNIX__ |
| if ((fd = creat (name, 0666)) < 0) |
| #endif |
| #ifdef __MSW32__ |
| if ((fd = open (name, _O_CREAT | _O_WRONLY | _O_BINARY, _S_IWRITE)) < 0) |
| #endif |
| #ifdef __MAC__ |
| if ((fd = creat (name, O_WRONLY | O_BINARY)) < 0) |
| #endif |
| { |
| CANTCREATEFILE.error ("IMAGE::write", TESSLOG, name); |
| return -1; //failed |
| } |
| if (res <= 0) |
| res = image_default_resolution; |
| if ((*imagetypes[type].writer) (fd, image, xsize, ysize, bpp, photo_interp, |
| res) < 0) { |
| //get header |
| //write failed |
| WRITEFAILED.error ("IMAGE::write", TESSLOG, name); |
| close(fd); |
| fd = -1; |
| return -1; //failed |
| } |
| return 0; //success |
| } |
