Unit rdppm;

{ rdppm.c

  Copyright (C) 1991-1997, Thomas G. Lane.
  This file is part of the Independent JPEG Group's software.
  For conditions of distribution and use, see the accompanying README file.

  This file contains routines to read input images in PPM/PGM format.
  The extended 2-byte-per-sample raw PPM/PGM formats are supported.
  The PBMPLUS library is NOT required to compile this software
  (but it is highly useful as a set of PPM image manipulation programs).

  These routines may need modification for non-Unix environments or
  specialized applications.  As they stand, they assume input from
  an ordinary stdio stream.  They further assume that reading begins
  at the start of the file; start_input may need work if the
  user interface has already read some data (e.g., to determine that
  the file is indeed PPM format).
 }

interface

{$define CHAR_IS_UNSIGNED}

{$I jconfig.inc}

uses
  jdeferr,
  jmorecfg,
  jerror,
  jpeglib,
  jinclude,
  cdjpeg;               { Common decls for cjpeg/djpeg applications }

{GLOBAL}
function jinit_read_ppm (cinfo : j_compress_ptr) : cjpeg_source_ptr;


implementation

{ Portions of this code are based on the PBMPLUS library, which is:
*
* Copyright (C) 1988 by Jef Poskanzer.
*
* Permission to use, copy, modify, and distribute this software and its
* documentation for any purpose and without fee is hereby granted, provided
* that the above copyright notice appear in all copies and that both that
* copyright notice and this permission notice appear in supporting
* documentation.  This software is provided "as is" without express or
* implied warranty.
}


{ Macros to deal with unsigned chars as efficiently as compiler allows }

{$ifdef HAVE_UNSIGNED_CHAR}
type
  U_CHAR = unsigned char;
  UCH = int;
{$else} { !HAVE_UNSIGNED_CHAR }
  {$ifdef CHAR_IS_UNSIGNED}
  type
    U_CHAR = byte;
    U_CHARptr = ^U_CHAR;
    UCH = int;
  {$else}
  type
    U_CHAR = char;
    UCH(x) = int (x and $FF)
  {$endif}
{$endif} { HAVE_UNSIGNED_CHAR }


{ macro }
function ReadOK(f : FILEptr; buffer : pointer; len : size_t) : boolean;
begin
  ReadOK := JFREAD(f, buffer,len) = size_t(len);
end;
{
  On most systems, reading individual bytes with getc() is drastically less
  efficient than buffering a row at a time with fread().  On PCs, we must
  allocate the buffer in near data space, because we are assuming small-data
  memory model, wherein fread() can't reach far memory.  If you need to
  process very wide images on a PC, you might have to compile in large-memory
  model, or else replace fread() with a getc() loop --- which will be much
  slower.
 }


{ Private version of data source object }

type
  ppm_source_ptr = ^ppm_source_struct;
  ppm_source_struct = record
    pub : cjpeg_source_struct; { public fields }

    iobuffer : U_CHARptr;               { non-FAR pointer to I/O buffer }
    pixrow : JSAMPROW;                  { FAR pointer to same }
    buffer_width : size_t;              { width of I/O buffer }
    rescale : JSAMPROW;                 { => maxval-remapping array, or NIL }
  end;
const
  LF = #10;
  CR = #13;

{LOCAL}
function pbm_getc (var infile : file) : char;
{ Read next char, skipping over any comments }
{ A comment/newline sequence is returned as a newline }
var
  {register} ch : char;
begin
  {getch} BlockRead(infile, ch, 1);
  if (ch = '#') then
  begin
    repeat
      BlockRead(infile, ch, 1);
    until (ch = LF) or eof(infile);
  end;
  pbm_getc := ch;
end;


{LOCAL}

function read_pbm_integer (cinfo : j_compress_ptr; var infile : file) : uint;
{ Read an unsigned decimal integer from the PPM file }
{ Swallows one trailing character after the integer }
{ Note that on a 16-bit-int machine, only values up to 64k can be read. }
{ This should not be a problem in practice. }
const
  TAB = ^I;
var
  {register} ch : char;
  {register} val : uint;
begin
  { Skip any leading whitespace }
  repeat
    ch := pbm_getc(infile);
    if eof(infile) then
      ERREXIT(j_common_ptr(cinfo), JERR_INPUT_EOF);
  until (ch <> ' ') and (ch <> TAB) and (ch <> LF) and (ch <> CR);

  if (ch < '0') or (ch > '9') then
    ERREXIT(j_common_ptr(cinfo), JERR_PPM_NONNUMERIC);

  val := ord(ch) - ord('0');
  repeat
    ch := pbm_getc(infile);
    if (ch >= '0') and (ch <= '9') then
    begin
      val := val * 10;
      Inc(val, ord(ch) - ord('0'));
    end
    else
      break;
  until FALSE;
  read_pbm_integer := val;
end;

{ Read one row of pixels.

  We provide several different versions depending on input file format.
  In all cases, input is scaled to the size of JSAMPLE.

  A really fast path is provided for reading byte/sample raw files with
  maxval := MAXJSAMPLE, which is the normal case for 8-bit data. }


{METHODDEF}
function get_text_gray_row (cinfo : j_compress_ptr;
                            sinfo : cjpeg_source_ptr) : JDIMENSION; far;
{ This version is for reading text-format PGM files with any maxval }
var
  source : ppm_source_ptr;
  infile : FILEptr;
  {register} ptr : JSAMPLE_PTR;
  {register} rescale : JSAMPROW;
  col : JDIMENSION;
begin
  source := ppm_source_ptr(sinfo);
  infile := source^.pub.input_file;
  rescale := source^.rescale;
  ptr := JSAMPLE_PTR(source^.pub.buffer^[0]);
  for col := pred(cinfo^.image_width) downto 0 do
  begin
    ptr^ := rescale^[read_pbm_integer(cinfo, infile^)];
    Inc(ptr);
  end;
  get_text_gray_row := 1;
end;


{METHODDEF}
function get_text_rgb_row (cinfo : j_compress_ptr;
                           sinfo : cjpeg_source_ptr) : JDIMENSION; far;
{ This version is for reading text-format PPM files with any maxval }
var
  source : ppm_source_ptr;
  infile : FILEptr;
  {register} ptr : JSAMPLE_PTR;
  {register} rescale : JSAMPROW;
  col : JDIMENSION;
begin
  source := ppm_source_ptr(sinfo);
  infile := source^.pub.input_file;
  rescale := source^.rescale;
  ptr := JSAMPLE_PTR(source^.pub.buffer^[0]);
  for col := pred(cinfo^.image_width) downto 0 do
  begin
    ptr^ := rescale^[read_pbm_integer(cinfo, infile^)];
    Inc(ptr);
    ptr^ := rescale^[read_pbm_integer(cinfo, infile^)];
    Inc(ptr);
    ptr^ := rescale^[read_pbm_integer(cinfo, infile^)];
    Inc(ptr);
  end;
  get_text_rgb_row := 1;
end;


{METHODDEF}
function get_scaled_gray_row (cinfo : j_compress_ptr;
                              sinfo : cjpeg_source_ptr) : JDIMENSION; far;
{ This version is for reading raw-byte-format PGM files with any maxval }
var
  source : ppm_source_ptr;
  {register} ptr : JSAMPLE_PTR;
  {register} bufferptr : U_CHARptr ;
  {register} rescale : JSAMPROW;
  col : JDIMENSION;
begin
  source := ppm_source_ptr(sinfo);
  rescale := source^.rescale;
  if not ReadOK(source^.pub.input_file, source^.iobuffer,
                source^.buffer_width) then
    ERREXIT(j_common_ptr(cinfo), JERR_INPUT_EOF);
  ptr := JSAMPLE_PTR(source^.pub.buffer^[0]);
  bufferptr := source^.iobuffer;
  for col := pred(cinfo^.image_width) downto 0 do
  begin
    ptr^ := rescale^[UCH(bufferptr^)];
    Inc(ptr);
    Inc(bufferptr);
  end;
  get_scaled_gray_row := 1;
end;


{METHODDEF}
function get_scaled_rgb_row (cinfo : j_compress_ptr;
                             sinfo : cjpeg_source_ptr) : JDIMENSION; far;
{ This version is for reading raw-byte-format PPM files with any maxval }
var
  source : ppm_source_ptr;
  {register} ptr : JSAMPLE_PTR;
  {register} bufferptr : U_CHARptr ;
  {register} rescale : JSAMPROW;
  col : JDIMENSION;
begin
  source := ppm_source_ptr (sinfo);
  rescale := source^.rescale;

  if not ReadOK(source^.pub.input_file, source^.iobuffer,
                source^.buffer_width) then
    ERREXIT(j_common_ptr(cinfo), JERR_INPUT_EOF);
  ptr := JSAMPLE_PTR(source^.pub.buffer^[0]);
  bufferptr := source^.iobuffer;
  for col := pred(cinfo^.image_width) downto 0 do
  begin
    ptr^ := rescale^[UCH(bufferptr^)];
    Inc(ptr);
    Inc(bufferptr);
    ptr^ := rescale^[UCH(bufferptr^)];
    Inc(ptr);
    Inc(bufferptr);
    ptr^ := rescale^[UCH(bufferptr^)];
    Inc(ptr);
    Inc(bufferptr);
  end;
  get_scaled_rgb_row := 1;
end;


{METHODDEF}
function get_raw_row (cinfo : j_compress_ptr;
                      sinfo : cjpeg_source_ptr) : JDIMENSION; far;
{ This version is for reading raw-byte-format files with maxval := MAXJSAMPLE.
  In this case we just read right into the JSAMPLE buffer!
  Note that same code works for PPM and PGM files. }
var
  source : ppm_source_ptr;
begin
  source := ppm_source_ptr(sinfo);

  if not ReadOK(source^.pub.input_file, source^.iobuffer,
                source^.buffer_width) then
    ERREXIT(j_common_ptr(cinfo), JERR_INPUT_EOF);
  get_raw_row := 1;
end;


{METHODDEF}
function get_word_gray_row (cinfo : j_compress_ptr;
                            sinfo : cjpeg_source_ptr) : JDIMENSION; far;
{ This version is for reading raw-word-format PGM files with any maxval }
var
  source : ppm_source_ptr;
  {register} ptr : JSAMPLE_PTR;
  {register} bufferptr : U_CHARptr;
  {register} rescale : JSAMPROW;
  col : JDIMENSION;
var
  {register} temp : int;
begin
  source := ppm_source_ptr (sinfo);
  rescale := source^.rescale;
  if not ReadOK(source^.pub.input_file, source^.iobuffer,
                source^.buffer_width) then
    ERREXIT(j_common_ptr(cinfo), JERR_INPUT_EOF);
  ptr := JSAMPLE_PTR(source^.pub.buffer^[0]);
  bufferptr := source^.iobuffer;
  for col := pred(cinfo^.image_width) downto 0 do
  begin
    temp  := UCH(bufferptr^);
    Inc(bufferptr);
    temp := temp or (UCH(bufferptr^) shl 8);
    Inc(bufferptr);
    ptr^ := rescale^[temp];
    Inc(ptr);
  end;
  get_word_gray_row := 1;
end;


{METHODDEF}
function get_word_rgb_row (cinfo : j_compress_ptr;
                           sinfo : cjpeg_source_ptr) : JDIMENSION; far;
{ This version is for reading raw-word-format PPM files with any maxval }
var
  source : ppm_source_ptr;
  {register} ptr : JSAMPLE_PTR;
  {register} bufferptr : U_CHARptr;
  {register} rescale : JSAMPROW;
  col : JDIMENSION;
var
  {register} temp : int;
begin
  source := ppm_source_ptr(sinfo);
  rescale := source^.rescale;
  if not ReadOK(source^.pub.input_file, source^.iobuffer,
                source^.buffer_width) then
    ERREXIT(j_common_ptr(cinfo), JERR_INPUT_EOF);
  ptr := JSAMPLE_PTR(source^.pub.buffer^[0]);
  bufferptr := source^.iobuffer;
  for col := pred(cinfo^.image_width) downto 0 do
  begin
    temp  := UCH(bufferptr^);
    Inc(bufferptr);
    temp := temp or (UCH(bufferptr^) shl 8);
    Inc(bufferptr);
    ptr^ := rescale^[temp];
    Inc(ptr);
    temp  := UCH(bufferptr^);
    Inc(bufferptr);
    temp := temp or (UCH(bufferptr^) shl 8);
    Inc(bufferptr);
    ptr^ := rescale^[temp];
    Inc(ptr);
    temp  := UCH(bufferptr^);
    Inc(bufferptr);
    temp := temp or (UCH(bufferptr^) shl 8);
    Inc(bufferptr);
    ptr^ := rescale^[temp];
    Inc(ptr);
  end;
  get_word_rgb_row := 1;
end;


{ Read the file header; return image size and component count. }

{METHODDEF}
procedure start_input_ppm (cinfo : j_compress_ptr;
                           sinfo : cjpeg_source_ptr); far;
var
  source : ppm_source_ptr;
  c : char;
  w, h, maxval : uint;
  need_iobuffer, use_raw_buffer, need_rescale : boolean;
var
  val, half_maxval : INT32;
begin
  source := ppm_source_ptr(sinfo);
  {getch} BlockRead(source^.pub.input_file^, c, 1);
  if (c <> 'P') then
    ERREXIT(j_common_ptr(cinfo), JERR_PPM_NOT);

  {getch} BlockRead(source^.pub.input_file^, c, 1);
  { subformat discriminator character }

  { detect unsupported variants (ie, PBM) before trying to read header }
  case (c) of
  '2',                  { it's a text-format PGM file }
  '3',                  { it's a text-format PPM file }
  '5',                  { it's a raw-format PGM file }
  '6':;                 { it's a raw-format PPM file }
  else
    ERREXIT(j_common_ptr(cinfo), JERR_PPM_NOT);
  end;

  { fetch the remaining header info }
  w := read_pbm_integer(cinfo, source^.pub.input_file^);
  h := read_pbm_integer(cinfo, source^.pub.input_file^);
  maxval := read_pbm_integer(cinfo, source^.pub.input_file^);

  if (w <= 0) or (h <= 0) or (maxval <= 0) then { error check }
    ERREXIT(j_common_ptr(cinfo), JERR_PPM_NOT);

  cinfo^.data_precision := BITS_IN_JSAMPLE; { we always rescale data to this }
  cinfo^.image_width := JDIMENSION (w);
  cinfo^.image_height := JDIMENSION (h);

  { initialize flags to most common settings }
  need_iobuffer := TRUE;                { do we need an I/O buffer? }
  use_raw_buffer := FALSE;      { do we map input buffer onto I/O buffer? }
  need_rescale := TRUE;         { do we need a rescale array? }

  case (c) of
  '2':                  { it's a text-format PGM file }
    begin
      cinfo^.input_components := 1;
      cinfo^.in_color_space := JCS_GRAYSCALE;
      {$IFDEF DEBUG}
      TRACEMS2(j_common_ptr(cinfo), 1, JTRC_PGM_TEXT, w, h);
      {$ENDIF}
      source^.pub.get_pixel_rows := get_text_gray_row;
      need_iobuffer := FALSE;
    end;

  '3':                  { it's a text-format PPM file }
    begin
      cinfo^.input_components := 3;
      cinfo^.in_color_space := JCS_RGB;
      {$IFDEF DEBUG}
      TRACEMS2(j_common_ptr(cinfo), 1, JTRC_PPM_TEXT, w, h);
      {$ENDIF}
      source^.pub.get_pixel_rows := get_text_rgb_row;
      need_iobuffer := FALSE;
    end;

  '5':                  { it's a raw-format PGM file }
    begin
      cinfo^.input_components := 1;
      cinfo^.in_color_space := JCS_GRAYSCALE;
      TRACEMS2(j_common_ptr(cinfo), 1, JTRC_PGM, w, h);
      if (maxval > 255) then
      begin
        source^.pub.get_pixel_rows := get_word_gray_row;
      end
      else
        if (maxval = MAXJSAMPLE) and (SIZEOF(JSAMPLE) = SIZEOF(U_CHAR)) then
        begin
          source^.pub.get_pixel_rows := get_raw_row;
          use_raw_buffer := TRUE;
          need_rescale := FALSE;
        end
        else
        begin
          source^.pub.get_pixel_rows := get_scaled_gray_row;
        end;
    end;

  '6':                  { it's a raw-format PPM file }
    begin
      cinfo^.input_components := 3;
      cinfo^.in_color_space := JCS_RGB;
      {$IFDEF DEBUG}
      TRACEMS2(j_common_ptr(cinfo), 1, JTRC_PPM, w, h);
      {$ENDIF}
      if (maxval > 255) then
      begin
        source^.pub.get_pixel_rows := get_word_rgb_row;
      end
      else
        if (maxval = MAXJSAMPLE) and (SIZEOF(JSAMPLE) = SIZEOF(U_CHAR)) then
        begin
          source^.pub.get_pixel_rows := get_raw_row;
          use_raw_buffer := TRUE;
          need_rescale := FALSE;
        end
        else
        begin
          source^.pub.get_pixel_rows := get_scaled_rgb_row;
        end;
    end;
  end;

  { Allocate space for I/O buffer: 1 or 3 bytes or words/pixel. }
  if (need_iobuffer) then
  begin
    if (maxval<=255) then
      source^.buffer_width := size_t ( w * cinfo^.input_components *
                                     SIZEOF(U_CHAR) )
    else
      source^.buffer_width := size_t ( w * cinfo^.input_components *
                                     (2*SIZEOF(U_CHAR)) );

    source^.iobuffer := U_CHARptr (
      cinfo^.mem^.alloc_small (j_common_ptr(cinfo), JPOOL_IMAGE,
                                  source^.buffer_width) );
  end;

  { Create compressor input buffer. }
  if (use_raw_buffer) then
  begin
    { For unscaled raw-input case, we can just map it onto the I/O buffer. }
    { Synthesize a JSAMPARRAY pointer structure }
    { Cast here implies near^.far pointer conversion on PCs }
    source^.pixrow := JSAMPROW (source^.iobuffer);
    source^.pub.buffer := JSAMPARRAY(@source^.pixrow);
    source^.pub.buffer_height := 1;
  end
  else
  begin
    { Need to translate anyway, so make a separate sample buffer. }
    source^.pub.buffer := cinfo^.mem^.alloc_sarray
      (j_common_ptr(cinfo), JPOOL_IMAGE,
       JDIMENSION (w * cinfo^.input_components), JDIMENSION(1) );
    source^.pub.buffer_height := 1;
  end;

  { Compute the rescaling array if required. }
  if (need_rescale) then
  begin
    { On 16-bit-int machines we have to be careful of maxval := 65535 }
    source^.rescale := JSAMPROW (
      cinfo^.mem^.alloc_small (j_common_ptr(cinfo), JPOOL_IMAGE,
                          size_t ((long(maxval) + long(1)) * SIZEOF(JSAMPLE))) );
    half_maxval := maxval div 2;
    for val := 0 to INT32(maxval) do
    begin
      { The multiplication here must be done in 32 bits to avoid overflow }
      source^.rescale^[val] := JSAMPLE ((val*MAXJSAMPLE + half_maxval) div maxval);
    end;
  end