jpegtran.pas

DELPHI版的JPEG文件解码源程序

                else
                  if keymatch(arg, '-outfile', 5) then
                  begin
                    { Set output file name. }
                    Inc(argn);
                    if (argn >= argc) then      { advance to next argument }
                      usage;
                    outfilename := ParamStr(argn);	{ save it away for later use }
                  end
                  else
                    if keymatch(arg, '-progressive', 2) then
                    begin
                      { Select simple progressive mode. }
  {$ifdef C_PROGRESSIVE_SUPPORTED}
                      simple_progressive := TRUE;
                      { We must postpone execution until num_components is known. }
  {$else}
                      WriteLn(output, progname,
                        ': sorry, progressive output was not compiled');
                      Stop(EXIT_FAILURE);
  {$endif}
                    end
                    else
                      if keymatch(arg, '-restart', 2) then
                      begin
                        ch := 'x';
                        { Restart interval in MCU rows (or in MCUs with 'b'). }
                        Inc(argn);
                        if (argn >= argc) then { advance to next argument }
	                  usage;
                        arg := ParamStr(argn);
                        if (length(arg) > 1) and (arg[length(arg)] in ['b','B']) then
                        begin
                          ch := arg[length(arg)];
                          arg := Copy(arg, 1, Length(arg)-1);
                        end;

                        Val(arg, lval, code);
                        if (code <> 1) or (lval < 0) or (lval > Long(65535)) then
	                  usage;

                        if (ch = 'b') or (ch = 'B') then
                        begin
                          cinfo^.restart_interval := uint(lval);
	                  cinfo^.restart_in_rows := 0; { else prior '-restart n' overrides me }
                        end
                        else
                        begin
	                  cinfo^.restart_in_rows := int(lval);
	                  { restart_interval will be computed during startup }
                        end;

                      end
                      else
                        if keymatch(arg, '-rotate', 3) then
                        begin { Rotate 90, 180, or 270 degrees (measured clockwise). }
                          Inc(argn);
                          if (argn >= argc)	then { advance to next argument }
                            usage;
                          if (keymatch(ParamStr(argn), '90', 2)) then
	                    select_transform(JXFORM_ROT_90)
                          else
                            if keymatch(ParamStr(argn), '180', 3) then
                              select_transform(JXFORM_ROT_180)
                            else
                              if keymatch(ParamStr(argn), '270', 3) then
                                select_transform(JXFORM_ROT_270)
                              else
	                        usage;
                         end
                         else
                         if keymatch(arg, '-scans', 2) then
                         begin
                           { Set scan script. }
         {$ifdef C_MULTISCAN_FILES_SUPPORTED}
                           Inc(argn);
                           if (argn >= argc) then       { advance to next argument }
	                     usage;
                           scansarg := ParamStr(argn);
                           { We must postpone reading the file in case -progressive appears. }
         {$else}
                           WriteLn(output, progname,
                             ': sorry, multi-scan output was not compiled');
                           Stop(EXIT_FAILURE);
         {$endif}
                         end
                         else
                           if keymatch(arg, '-transpose', 2) then
                             { Transpose (across UL-to-LR axis). }
                             select_transform(JXFORM_TRANSPOSE)
                           else
                             if keymatch(arg, '-transverse', 7) then
                               { Transverse transpose (across UR-to-LL axis). }
                               select_transform(JXFORM_TRANSVERSE)
                             else
                               if keymatch(arg, '-trim', 4) then
                                 { Trim off any partial edge MCUs that
                                   the transform can't handle. }
                                 transformoption.trim := TRUE
                               else
                                 usage;                { bogus switch }
  end;

  { Post-switch-scanning cleanup }

  if (for_real) then
  begin

{$ifdef C_PROGRESSIVE_SUPPORTED}
    if (simple_progressive) then { process -progressive; -scans can override }
      jpeg_simple_progression(cinfo);
{$endif}

{$ifdef C_MULTISCAN_FILES_SUPPORTED}
    if (scansarg <> '') then       { process -scans if it was present }
    begin
      WriteLn('Scripts are not supported in PasJPEG.');
      {if not read_scan_script(cinfo, scansarg) then
	usage;
      }
    end;
{$endif}
  end;

  parse_switches  := argn;	{ return index of next arg (file name) }
end;


{ The main program. }

{main (int argc, char **argv)}
var
  srcinfo : jpeg_decompress_struct;
  dstinfo : jpeg_compress_struct;
  jsrcerr, jdsterr : jpeg_error_mgr;
{$ifdef PROGRESS_REPORT}
  progress : cdjpeg_progress_mgr;
{$endif}
  src_coef_arrays,
  dst_coef_arrays : jvirt_barray_tbl_ptr;
  file_index : int;
  input_file : FILE;
  output_file : FILE;
begin
  { On Mac, fetch a command line. }
{$ifdef USE_CCOMMAND}
  argc := ccommand(@argv);
{$endif}

  progname := ParamStr(0);

  { Initialize the JPEG decompression object with default error handling. }
  srcinfo.err := jpeg_std_error(jsrcerr);
  jpeg_create_decompress(@srcinfo);
  { Initialize the JPEG compression object with default error handling. }
  dstinfo.err := jpeg_std_error(jdsterr);
  jpeg_create_compress(@dstinfo);

  { Now safe to enable signal catcher.
    Note: we assume only the decompression object will have virtual arrays. }

{$ifdef NEED_SIGNAL_CATCHER}
  enable_signal_catcher(j_common_ptr(@srcinfo));
{$endif}

  { Scan command line to find file names.
    It is convenient to use just one switch-parsing routine, but the switch
    values read here are mostly ignored; we will rescan the switches after
    opening the input file.  Also note that most of the switches affect the
    destination JPEG object, so we parse into that and then copy over what
    needs to affects the source too. }

  file_index := parse_switches(@dstinfo, 0, FALSE);
  jsrcerr.trace_level := jdsterr.trace_level;
  srcinfo.mem^.max_memory_to_use := dstinfo.mem^.max_memory_to_use;

{$ifdef TWO_FILE_COMMANDLINE}
  { Must have either -outfile switch or explicit output file name }
  if (outfilename = '') then
  begin
    if (file_index <> ParamCount-1) then
    begin
      WriteLn(output, progname, ': must name one input and one output file');
      usage;
    end;
    outfilename := ParamStr(file_index+1);
  end
  else
  begin
    if (file_index <> ParamCount-1) then
    begin
      WriteLn(output, progname, ': must name one input and one output file');
      usage;
    end;
  end;
{$else}
  { Unix style: expect zero or one file name }
  if (file_index < argc-1) then
  begin
    WriteLn(output, progname, ': only one input file');
    usage;
  end;
{$endif} { TWO_FILE_COMMANDLINE }

  { Open the input file. }
  if (file_index < ParamCount) then
  begin
    assign(input_file, ParamStr(file_index));
    {$I-}
    reset(input_file, 1);
    {$IFDEF IoCheck} {$I+} {$ENDIF}
    if (IOresult <> 0) then
    begin
      WriteLn(output, progname, ': can''t open ', ParamStr(file_index));
      Stop(EXIT_FAILURE);
    end;
  end
  else
  begin
    { default input file is stdin }
    assign(input_file, '');
    reset(input_file, 1);
  end;

  { Open the output file. }
  if (outfilename <> '') then
  begin
    assign(output_file, outfilename);
    {$I-}
    rewrite(output_file, 1);
    {$IFDEF IoCheck} {$I+} {$ENDIF}
    if (IOresult <> 0) then
    begin
      WriteLn(output, progname, ': can''t open ', outfilename);
      Stop(EXIT_FAILURE);
    end;
  end
  else
  begin
    { default output file is stdout }
    assign(output_file, '');
    rewrite(output_file, 1);
  end;

{$ifdef PROGRESS_REPORT}
  start_progress_monitor(j_common_ptr(@dstinfo), @progress);
{$endif}

  { Specify data source for decompression }
  jpeg_stdio_src(@srcinfo, @input_file);

  { Enable saving of extra markers that we want to copy }
  jcopy_markers_setup(@srcinfo, copyoption);

  { Read file header }
  {void} jpeg_read_header(@srcinfo, TRUE);

  { Any space needed by a transform option must be requested before
    jpeg_read_coefficients so that memory allocation will be done right. }

{$ifdef TRANSFORMS_SUPPORTED}
  jtransform_request_workspace(@srcinfo, transformoption);
{$endif}

  { Read source file as DCT coefficients }
  src_coef_arrays := jpeg_read_coefficients(@srcinfo);

  { Initialize destination compression parameters from source values }
  jpeg_copy_critical_parameters(@srcinfo, @dstinfo);

  { Adjust destination parameters if required by transform options;
    also find out which set of coefficient arrays will hold the output. }

{$ifdef TRANSFORMS_SUPPORTED}
  dst_coef_arrays := jtransform_adjust_parameters(@srcinfo, @dstinfo,
						 src_coef_arrays,
						 transformoption);
{$else}
  dst_coef_arrays := src_coef_arrays;
{$endif}

  { Adjust default compression parameters by re-parsing the options }
  file_index := parse_switches(@dstinfo, 0, TRUE);

  { Specify data destination for compression }
  jpeg_stdio_dest(@dstinfo, @output_file);

  { Start compressor (note no image data is actually written here) }
  jpeg_write_coefficients(@dstinfo, dst_coef_arrays);

  { Copy to the output file any extra markers that we want to preserve }
  jcopy_markers_execute(@srcinfo, @dstinfo, copyoption);

  { Execute image transformation, if any }
{$ifdef TRANSFORMS_SUPPORTED}
  jtransform_execute_transformation(@srcinfo, @dstinfo,
				    src_coef_arrays,
				    transformoption);
{$endif}

  { Finish compression and release memory }
  jpeg_finish_compress(@dstinfo);
  jpeg_destroy_compress(@dstinfo);
  {void} jpeg_finish_decompress(@srcinfo);
  jpeg_destroy_decompress(@srcinfo);

  { Close files, if we opened them }
  close(input_file);
  close(output_file);

{$ifdef PROGRESS_REPORT}
  end_progress_monitor(j_common_ptr(@dstinfo));
{$endif}

  { All done. }
  if jsrcerr.num_warnings + jdsterr.num_warnings <> 0 then
    Stop(EXIT_WARNING)
  else
    Stop(EXIT_SUCCESS);
end.