image/imgtiff.h File Reference

#include "host.h"
#include "bitstrm.h"

Go to the source code of this file.

Functions

• INT8 open_tif_image (int fd, INT32 *xsize, INT32 *ysize, INT8 *bpp, INT8 *photo, INT32 *res)
• INT32 read_eol (R_BITSTREAM *bits, UINT16 &code)
• INT8 read_tif_image (int fd, UINT8 *pixels, INT32 xsize, INT32 ysize, INT8 bpp, INT32)
• INT8 write_intel_tif (int fd, UINT8 *pixels, INT32 xsize, INT32 ysize, INT8 bpp, INT8 photo, INT32 res)
• INT8 write_inverse_tif (int fd, UINT8 *pixels, INT32 xsize, INT32 ysize, INT8 bpp, INT8 photo, INT32 res)
• INT8 write_moto_tif (int fd, UINT8 *pixels, INT32 xsize, INT32 ysize, INT8 bpp, INT8 photo, INT32 res)
• INT8 write_tif_image (int fd, UINT8 *pixels, INT32 xsize, INT32 ysize, INT8 bpp, INT32 res, INT16 type, INT16 photo)

---

Function Documentation

INT8 open_tif_image	(	int	fd,
		INT32 *	xsize,
		INT32 *	ysize,
		INT8 *	bpp,
		INT8 *	photo,
		INT32 *	res
	)

Read the header of a tif format image and prepare to read the rest.

Definition at line 197 of file imgtiff.cpp.

References __NATIVE__, BADIMAGEFORMAT, ERRCODE::error(), FALSE, INTEL, LOG, MOTO, READFAILED, reverse16(), reverse32(), tprintf(), and TRUE.

                     {
  INT16 filetype;
  INT32 start;                   //start of tiff directory
  INT16 entries;                 //no of tiff entries
  INT32 imagestart;              //location of image in file
  INT32 resoffset;               //location of res
  TIFFENTRY tiffentry;           //tag table entry
  BOOL8 compressed;              //compression control
  MYRATIONAL resinfo;            //resolution
  BOOL8 strips = false;          //if in strips

  *xsize = -1;                   //illegal values
  *ysize = -1;
  *bpp = -1;
  *res = -1;
  resoffset = -1;
  if (read (fd, (char *) &filetype, sizeof filetype) != sizeof filetype
  || filetype != INTEL && filetype != MOTO) {
    BADIMAGEFORMAT.error ("read_tif_image", LOG, "Filetype");
    return -1;
  }
  lseek (fd, 4L, 0);
  if (read (fd, (char *) &start, sizeof start) != sizeof start) {
    READFAILED.error ("read_tif_image", LOG, "Start of tag table");
    return -1;
  }

  if (filetype != __NATIVE__)
    start = reverse32 (start);
  if (start <= 0) {
    BADIMAGEFORMAT.error ("read_tif_image", LOG, "Start of tag table");
    return -1;
  }
  lseek (fd, start, 0);
  if (read (fd, (char *) &entries, sizeof (INT16)) != sizeof (INT16)) {
    BADIMAGEFORMAT.error ("read_tif_image", LOG, "Size of tag table");
    return -1;
  }
  if (filetype != __NATIVE__)
    entries = reverse16 (entries);
  //      printf("No of tiff directory entries=%d\n",entries);
  imagestart = 0;
  compressed = FALSE;
  for (; entries-- > 0;) {
    if (read (fd, (char *) &tiffentry, sizeof tiffentry) !=
    sizeof tiffentry) {
      BADIMAGEFORMAT.error ("read_tif_image", LOG, "Tag table entry");
      return -1;
    }
    if (filetype != __NATIVE__) {
      tiffentry.type = reverse16 (tiffentry.type);
      tiffentry.tag = reverse16 (tiffentry.tag);
      tiffentry.length = reverse32 (tiffentry.length);
    }
    if (tiffentry.type != 3) {   //Full 32bit value
      if (filetype != __NATIVE__)
        tiffentry.value = reverse32 (tiffentry.value);
    }
    else {
      /* A 16bit value in 4 bytes - handle with care. SEE NOTE at start of file */
      if (__NATIVE__ == MOTO) {
        if (filetype == MOTO)    //MOTO file on MOTO Machine
          tiffentry.value = tiffentry.value >> 16;
        else                     //INTEL file on MOTO Machine
          tiffentry.value = reverse32 (tiffentry.value);
      }
      else {                     //INTEL Machine
        if (filetype == MOTO)    //MOTO file on INTEL Machine
          tiffentry.value = reverse16 ((UINT16) tiffentry.value);
        //INTEL file on INTEL Machine NO ACTION NEEDED
      }
                                 //Clear top 2 MSBytes
      tiffentry.value &= 0x0000ffff;
    }

    //   printf("Tag=%x, Type=%x, Length=%x, value=%x\n",
    //     tiffentry.tag,tiffentry.type,tiffentry.length,tiffentry.value);
    switch (tiffentry.tag) {
      case 0x101:
        *ysize = tiffentry.value;
        break;
      case 0x100:
        *xsize = tiffentry.value;
        break;
      case 0x102:
        if (tiffentry.length == 1)
          *bpp = (INT8) tiffentry.value;
        else
          *bpp = 24;
        break;
      case 0x111:
        imagestart = tiffentry.value;
        strips = tiffentry.length > 1;
        break;
      case 0x103:
        if (tiffentry.value == 3) {
          compressed = TRUE;
        }
        else if (tiffentry.value != 1) {
          BADIMAGEFORMAT.error ("read_tif_image", LOG, "Compression");
          return -1;
        }
        break;
      case 0x11a:
      case 0x11b:
                                 //resolution
        resoffset = tiffentry.value;
        break;
      case 0x106:
        *photo = (INT8) tiffentry.value;
        break;
    }                            //endswitch
  }
  if (*xsize <= 0 || *ysize <= 0 || *bpp > 24 || imagestart <= 0) {
    BADIMAGEFORMAT.error ("read_tif_image", LOG, "Vital tag");
    return -1;
  }
  tprintf ("Image has %d bit%c per pixel and size (%d,%d)\n",
    *bpp, *bpp == 1 ? ' ' : 's', *xsize, *ysize);
  if (resoffset >= 0) {
    lseek (fd, resoffset, 0);
    if (read (fd, (char *) &resinfo, sizeof (resinfo)) != sizeof (resinfo)) {
      READFAILED.error ("read_tif_image", LOG, "Resolution");
      return -1;
    }
    if (filetype != __NATIVE__) {
      resinfo.top = reverse32 (resinfo.top);
      resinfo.bottom = reverse32 (resinfo.bottom);
    }
    *res = resinfo.top / resinfo.bottom;
    tprintf ("Resolution=%d\n", *res);
  }
  lseek (fd, (long) imagestart, 0);
  if (strips) {
    if (read (fd, (char *) &imagestart, sizeof (imagestart)) !=
    sizeof (imagestart)) {
      READFAILED.error ("read_tif_image", LOG, "Strip offset");
      return -1;
    }
    if (filetype != __NATIVE__)
      imagestart = reverse32 (imagestart);
                                 //indirection
    lseek (fd, (long) imagestart, 0);
  }
  return compressed ? -2 : 0;
}

INT32 read_eol	(	R_BITSTREAM *	bits,
		UINT16 &	code
	)

Take bits out of the stream until and end-of-line code is hit.

Definition at line 436 of file imgtiff.cpp.

References EOL_CODE, EOL_LENGTH, EOL_MASK, FALSE, R_BITSTREAM::read_code(), and TRUE.

Referenced by read_tif_image().

                {
  BOOL8 anyones;                 //any 1 bits skipped
  INT32 bitcount;                //total bits skipped

  anyones = FALSE;
  bitcount = 0;
  while ((code & EOL_MASK) != EOL_CODE) {
    if (code & 1)
      anyones = TRUE;            //discarded one bit
    bitcount++;                  //total discarded bits
    code = bits->read_code (1);  //take single bits
  }
                                 //extract EOL code
  code = bits->read_code (EOL_LENGTH);

  if (!anyones)
    bitcount = 0;                //ignore filler bits
  return bitcount;
}

INT8 read_tif_image	(	int	fd,
		UINT8 *	pixels,
		INT32	xsize,
		INT32	ysize,
		INT8	bpp,
		INT32
	)

Read a whole tif image into memory.

Definition at line 355 of file imgtiff.cpp.

References IMAGE::capture(), IMAGELINE::init(), long_black_codes, long_black_lengths, LONG_CODE_SIZE, long_white_codes, long_white_lengths, R_BITSTREAM::masks(), R_BITSTREAM::open(), IMAGELINE::pixels, IMAGE::put_line(), R_BITSTREAM::read_code(), read_eol(), short_black_codes, short_black_lengths, SHORT_CODE_SIZE, short_white_codes, short_white_lengths, tprintf(), and TRUE.

                     {
  INT32 xindex;                  //indices in image
  INT32 yindex;
  INT32 length;                  //short length
  INT32 biglength;               //extender
  UINT8 *lengths;                //current lengths
  UINT16 *codes;                 //current codes
  UINT16 codeword;               //current code word
  IMAGELINE imageline;           //current line
  IMAGE image;                   //dummy image
  R_BITSTREAM bits;              //read bitstream
  UINT8 colour;                  //current colour

  image.capture (pixels, xsize, ysize, bpp);
  codeword = bits.open (fd);     //open bitstream
  read_eol(&bits, codeword);  //find end of line
  for (yindex = ysize - 1; yindex >= 0; yindex--) {
    imageline.init ();
    colour = TRUE;
    for (xindex = 0; xindex < xsize;) {
      if (colour) {
        lengths = long_white_lengths;
        codes = long_white_codes;
      }
      else {
        lengths = long_black_lengths;
        codes = long_black_codes;
      }
      for (biglength = 0; biglength < LONG_CODE_SIZE
        && (codeword & bits.masks (*lengths))
        != *codes; codes++, lengths++, biglength++);
      if (biglength < LONG_CODE_SIZE) {
        codeword = bits.read_code (*lengths);
        biglength++;
        biglength *= SHORT_CODE_SIZE;
      }
      else
        biglength = 0;
      if (colour) {
        lengths = short_white_lengths;
        codes = short_white_codes;
      }
      else {
        lengths = short_black_lengths;
        codes = short_black_codes;
      }
      for (length = 0; length < SHORT_CODE_SIZE
        && (codeword & bits.masks (*lengths))
        != *codes; codes++, lengths++, length++);
      if (length < SHORT_CODE_SIZE) {
        codeword = bits.read_code (*lengths);
        for (length += biglength; length > 0; length--, xindex++)
          imageline.pixels[xindex] = colour;
        colour = !colour;
      }
      else
        break;
    }
    if (xindex < xsize) {
      tprintf ("%d pixels short on line %d", xsize - xindex, yindex);
      tprintf (", unknown code=%x\n", codeword);
    }
    xindex = read_eol (&bits, codeword);
    if (xindex > 0)
      tprintf ("Discarding %d bits on line %d\n", xindex, yindex);
    image.put_line (0, yindex, xsize, &imageline, 0);
  }
  return 0;
}

INT8 write_intel_tif	(	int	fd,
		UINT8 *	pixels,
		INT32	xsize,
		INT32	ysize,
		INT8	bpp,
		INT8	photo,
		INT32	res
	)

Write a whole tif format image and close the file.

Definition at line 480 of file imgtiff.cpp.

References INTEL, and write_tif_image().

                      {
  return write_tif_image (fd, pixels, xsize, ysize, bpp, res, INTEL, photo);
  //use intel format
}

INT8 write_inverse_tif	(	int	fd,
		UINT8 *	pixels,
		INT32	xsize,
		INT32	ysize,
		INT8	bpp,
		INT8	photo,
		INT32	res
	)

Write a whole tif format image and close the file.

Definition at line 497 of file imgtiff.cpp.

References INTEL, and write_tif_image().

                        {
  return write_tif_image (fd, pixels, xsize, ysize, bpp, res, INTEL,
    1 - photo);
  //use intel format
}

INT8 write_moto_tif	(	int	fd,
		UINT8 *	pixels,
		INT32	xsize,
		INT32	ysize,
		INT8	bpp,
		INT8	photo,
		INT32	res
	)

Write a whole tif format image and close the file.

Definition at line 463 of file imgtiff.cpp.

References MOTO, and write_tif_image().

                     {
  return write_tif_image (fd, pixels, xsize, ysize, bpp, res, MOTO, photo);
  //use moto format
}

INT8 write_tif_image	(	int	fd,
		UINT8 *	pixels,
		INT32	xsize,
		INT32	ysize,
		INT8	bpp,
		INT32	res,
		INT16	type,
		INT16	photo
	)

Write a whole tif format image and close the file.

Definition at line 515 of file imgtiff.cpp.

References __NATIVE__, COMPUTE_IMAGE_XDIM, ENTRIES, ERRCODE::error(), INTEL, TIFFENTRY::length, LOG, MOTO, resolution, reverse16(), reverse32(), START, TIFFENTRY::tag, TIFFENTRY::type, TIFFENTRY::value, and WRITEFAILED.

Referenced by write_intel_tif(), write_inverse_tif(), and write_moto_tif().

                      {
  INT32 size;                    //line/image size
  INT16 entries;                 //no of tiff entries
  INT32 start;                   //start of tag table
  INT32 zero = 0;
  MYRATIONAL resolution;         //resolution
  TIFFENTRY entry;               //current entry

  static TIFFENTRY tags[ENTRIES] = {
    {0xfe, 4, 1, 0},
    {0x100, 3, 1, 0},
    {0x101, 3, 1, 0},
    {0x102, 3, 1, 0},
    {0x103, 3, 1, 1},
    {0x106, 3, 1, 1},
    {                            /*line art */
      0x107, 3, 1, 1
    },
    {0x10a, 3, 1, 1},
    {
      0x111, 4, 1, START + ENTRIES * sizeof (TIFFENTRY)
      + sizeof (INT32) + sizeof (short) + sizeof (MYRATIONAL) * 2
    }
    ,
    {0x112, 3, 1, 1}
    ,
    {0x115, 3, 1, 1}
    ,
    {0x116, 4, 1, 0}
    ,
    {0x117, 4, 1, 0}
    ,
    {0x118, 3, 1, 0}
    ,
    {0x119, 3, 1, 1}
    ,
    {
      0x11a, 5, 1, START + ENTRIES * sizeof (TIFFENTRY)
      + sizeof (INT32) + sizeof (short)
    },
    {
      0x11b, 5, 1, START + ENTRIES * sizeof (TIFFENTRY)
      + sizeof (INT32) + sizeof (short) + sizeof (MYRATIONAL)
    }
    ,
    {0x11c, 3, 1, 1}
    ,
    {0x128, 3, 1, 2}
  };

  resolution.top = res;
  resolution.bottom = 1;
  if (write (fd, (char *) &type, sizeof type) != sizeof type
  || type != INTEL && type != MOTO) {
    WRITEFAILED.error ("write_tif_image", LOG, "Filetype");
    return -1;
  }
  start = START;
  entries = 0x002a;
  if (type != __NATIVE__)
    entries = reverse16 (entries);
  if (write (fd, (char *) &entries, sizeof entries) != sizeof entries) {
    WRITEFAILED.error ("write_tif_image", LOG, "Version");
    return -1;
  }
  if (type != __NATIVE__)
    start = reverse32 (start);
  if (write (fd, (char *) &start, sizeof start) != sizeof start) {
    WRITEFAILED.error ("write_tif_image", LOG, "Start");
    return -1;
  }
  lseek (fd, (long) START, 0);
  entries = ENTRIES;
  if (type != __NATIVE__)
    entries = reverse16 (entries);
  if (write (fd, (char *) &entries, sizeof entries) != sizeof entries) {
    WRITEFAILED.error ("write_tif_image", LOG, "Entries");
    return -1;
  }
                                 //line length
  size = COMPUTE_IMAGE_XDIM (xsize, bpp);
  size *= ysize;                 //total image size
  //      if (photo==0)
  //      {
  //              tags[0].tag=0xfe;
  //              tags[0].type=4;
  //              tags[0].value=0;
  //      }
  //      else
  //      {
  //              tags[0].tag=0xff;
  //              tags[0].type=3;
  //              tags[0].value=1;
  //      }
  tags[1].value = xsize;
  tags[2].value = ysize;
  if (bpp == 24) {
    tags[3].value = 8;
    tags[10].value = 3;
    tags[5].value = 2;
  }
  else {
    tags[3].value = bpp;
    tags[5].value = photo;
  }
  tags[11].value = ysize;
  tags[14].value = (1 << bpp) - 1;
  tags[12].value = size;
  for (entries = 0; entries < ENTRIES; entries++) {
    entry = tags[entries];       //get an entry
    /* NB Convert entry.value BEFORE converting entry.type!!! */
    if (entry.type != 3) {       //Full 32bit value
      if (type != __NATIVE__)
        entry.value = reverse32 (entry.value);
    }
    else {
      /* A 16bit value in 4 bytes - handle with care.
        SEE NOTE at start of file */
      entry.value &= 0x0000ffff; //Ensure top 2 MSBytes clear
      if (__NATIVE__ == MOTO) {
        if (type == MOTO)        //MOTO file on MOTO Machine
          entry.value = entry.value << 16;
        else                     //INTEL file on MOTO Machine
          entry.value = reverse32 (entry.value);
      }
      else {                     //INTEL Machine
        if (type == MOTO)        //MOTO file on INTEL Machine
          entry.value = reverse16 ((UINT16) entry.value);
        //INTEL file on INTEL Machine NO ACTION NEEDED
      }
    }
    if (type != __NATIVE__) {
      entry.tag = reverse16 (entry.tag);
      entry.type = reverse16 (entry.type);
      entry.length = reverse32 (entry.length);
    }
    if (write (fd, (char *) &entry, sizeof (TIFFENTRY)) !=
    sizeof (TIFFENTRY)) {
      WRITEFAILED.error ("write_tif_image", LOG, "Tag Table");
      return -1;
    }
  }
  if (write (fd, (char *) &zero, sizeof zero) != sizeof zero) {
    WRITEFAILED.error ("write_tif_image", LOG, "Tag table Terminator");
    return -1;
  }
  if (type != __NATIVE__) {
    resolution.top = reverse32 (resolution.top);
    resolution.bottom = reverse32 (resolution.bottom);
  }
  if (write (fd, (char *) &resolution, sizeof resolution) != sizeof resolution
    || write (fd, (char *) &resolution,
  sizeof resolution) != sizeof resolution) {
    WRITEFAILED.error ("write_tif_image", LOG, "Resolution");
    return -1;
  }
  if (write (fd, (char *) pixels, (size_t) size) != size) {
    WRITEFAILED.error ("write_tif_image", LOG, "Image");
    return -1;
  }
  close(fd); 
  return 0;
}

---