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;
end;


{ Finish up at the end of the file. }

{METHODDEF}
procedure finish_input_ppm (cinfo : j_compress_ptr;
                            sinfo : cjpeg_source_ptr); far;
begin
  { no work }
end;


{ The module selection routine for PPM format input. }

{GLOBAL}
function jinit_read_ppm (cinfo : j_compress_ptr) : cjpeg_source_ptr;
var
  source : ppm_source_ptr;
begin
  { Create module interface object }
  source := ppm_source_ptr (
      cinfo^.mem^.alloc_small (j_common_ptr(cinfo), JPOOL_IMAGE,
				  SIZEOF(ppm_source_struct)) );
  { Fill in method ptrs, except get_pixel_rows which start_input sets }
  source^.pub.start_input := start_input_ppm;
  source^.pub.finish_input := finish_input_ppm;

  jinit_read_ppm  := cjpeg_source_ptr(source);
end;


end.