int main(int argc, char **argv)
{
int motors_socket;
int listen_socket;
int client_socket;
int rc;
rc = parse_switches(argc, argv);
if (rc < 0) {
usage(argv[0]);
goto error;
}
listen_socket = server_start(listen_port);
if (listen_socket < 0) {
fprintf(stderr, "server_start returned exit status %d\n", listen_socket);
goto error;
}
motors_socket = connect_to_server(motors_ip, motors_port);
if (motors_socket < 0) {
fprintf(stderr, "connect_to_server returned exit status %d\n", errno);
goto error;
}
if (verbose) {
printf("Connected to motors-rpi\n");
}
while (1) {
client_socket = server_get_connection(listen_socket);
main_loop(client_socket, motors_socket);
close(client_socket);
}
close(listen_socket);
return EXIT_SUCCESS;
error:
return EXIT_FAILURE;
}
int
main (int argc, char **argv)
{
struct jpeg_decompress_struct cinfo;
struct jpeg_error_mgr jerr;
#ifdef PROGRESS_REPORT
struct cdjpeg_progress_mgr progress;
#endif
int file_index;
djpeg_dest_ptr dest_mgr = NULL;
FILE * input_file;
FILE * output_file;
JDIMENSION num_scanlines;
/* On Mac, fetch a command line. */
#ifdef USE_CCOMMAND
argc = ccommand(&argv);
#endif
progname = argv[0];
if (progname == NULL || progname[0] == 0)
progname = "djpeg"; /* in case C library doesn't provide it */
/* Initialize the JPEG decompression object with default error handling. */
cinfo.err = jpeg_std_error(&jerr);
jpeg_create_decompress(&cinfo);
/* Add some application-specific error messages (from cderror.h) */
jerr.addon_message_table = cdjpeg_message_table;
jerr.first_addon_message = JMSG_FIRSTADDONCODE;
jerr.last_addon_message = JMSG_LASTADDONCODE;
/* Insert custom marker processor for COM and APP12.
* APP12 is used by some digital camera makers for textual info,
* so we provide the ability to display it as text.
* If you like, additional APPn marker types can be selected for display,
* but don't try to override APP0 or APP14 this way (see libjpeg.doc).
*/
jpeg_set_marker_processor(&cinfo, JPEG_COM, print_text_marker);
jpeg_set_marker_processor(&cinfo, JPEG_APP0+12, print_text_marker);
/* Now safe to enable signal catcher. */
#ifdef NEED_SIGNAL_CATCHER
enable_signal_catcher((j_common_ptr) &cinfo);
#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 ignored; we will rescan the switches after opening
* the input file.
* (Exception: tracing level set here controls verbosity for COM markers
* found during jpeg_read_header...)
*/
file_index = parse_switches(&cinfo, argc, argv, 0, FALSE);
#ifdef TWO_FILE_COMMANDLINE
/* Must have either -outfile switch or explicit output file name */
if (outfilename == NULL) {
if (file_index != argc-2) {
fprintf(stderr, "%s: must name one input and one output file\n",
progname);
usage();
}
outfilename = argv[file_index+1];
} else {
if (file_index != argc-1) {
fprintf(stderr, "%s: must name one input and one output file\n",
progname);
usage();
}
}
#else
/* Unix style: expect zero or one file name */
if (file_index < argc-1) {
fprintf(stderr, "%s: only one input file\n", progname);
usage();
}
#endif /* TWO_FILE_COMMANDLINE */
/* Open the input file. */
if (file_index < argc) {
if ((input_file = fopen(argv[file_index], READ_BINARY)) == NULL) {
fprintf(stderr, "%s: can't open %s\n", progname, argv[file_index]);
exit(EXIT_FAILURE);
}
} else {
/* default input file is stdin */
input_file = read_stdin();
}
/* Open the output file. */
if (outfilename != NULL) {
if ((output_file = fopen(outfilename, WRITE_BINARY)) == NULL) {
fprintf(stderr, "%s: can't open %s\n", progname, outfilename);
exit(EXIT_FAILURE);
}
} else {
/* default output file is stdout */
output_file = write_stdout();
}
#ifdef PROGRESS_REPORT
start_progress_monitor((j_common_ptr) &cinfo, &progress);
#endif
/* Specify data source for decompression */
jpeg_stdio_src(&cinfo, input_file);
/* Read file header, set default decompression parameters */
(void) jpeg_read_header(&cinfo, TRUE);
/* Adjust default decompression parameters by re-parsing the options */
file_index = parse_switches(&cinfo, argc, argv, 0, TRUE);
/* Initialize the output module now to let it override any crucial
* option settings (for instance, GIF wants to force color quantization).
*/
switch (requested_fmt) {
#ifdef BMP_SUPPORTED
case FMT_BMP:
dest_mgr = jinit_write_bmp(&cinfo, FALSE);
break;
case FMT_OS2:
dest_mgr = jinit_write_bmp(&cinfo, TRUE);
break;
#endif
#ifdef GIF_SUPPORTED
case FMT_GIF:
dest_mgr = jinit_write_gif(&cinfo);
break;
#endif
#ifdef PPM_SUPPORTED
case FMT_PPM:
dest_mgr = jinit_write_ppm(&cinfo);
break;
#endif
#ifdef RLE_SUPPORTED
case FMT_RLE:
dest_mgr = jinit_write_rle(&cinfo);
break;
#endif
#ifdef TARGA_SUPPORTED
case FMT_TARGA:
dest_mgr = jinit_write_targa(&cinfo);
break;
#endif
default:
ERREXIT(&cinfo, JERR_UNSUPPORTED_FORMAT);
break;
}
dest_mgr->output_file = output_file;
/* Start decompressor */
(void) jpeg_start_decompress(&cinfo);
/* Write output file header */
(*dest_mgr->start_output) (&cinfo, dest_mgr);
/* Process data */
while (cinfo.output_scanline < cinfo.output_height) {
num_scanlines = jpeg_read_scanlines(&cinfo, dest_mgr->buffer,
dest_mgr->buffer_height);
(*dest_mgr->put_pixel_rows) (&cinfo, dest_mgr, num_scanlines);
}
#ifdef PROGRESS_REPORT
/* Hack: count final pass as done in case finish_output does an extra pass.
* The library won't have updated completed_passes.
*/
progress.pub.completed_passes = progress.pub.total_passes;
#endif
/* Finish decompression and release memory.
* I must do it in this order because output module has allocated memory
* of lifespan JPOOL_IMAGE; it needs to finish before releasing memory.
*/
(*dest_mgr->finish_output) (&cinfo, dest_mgr);
(void) jpeg_finish_decompress(&cinfo);
jpeg_destroy_decompress(&cinfo);
/* Close files, if we opened them */
if (input_file != stdin)
fclose(input_file);
if (output_file != stdout)
fclose(output_file);
#ifdef PROGRESS_REPORT
end_progress_monitor((j_common_ptr) &cinfo);
#endif
/* All done. */
exit(jerr.num_warnings ? EXIT_WARNING : EXIT_SUCCESS);
return 0; /* suppress no-return-value warnings */
}
int
main (int argc, char **argv)
{
struct jpeg_compress_struct cinfo;
struct jpeg_error_mgr jerr;
#ifdef PROGRESS_REPORT
struct cdjpeg_progress_mgr progress;
#endif
int file_index;
cjpeg_source_ptr src_mgr;
FILE * input_file;
FILE * output_file;
JDIMENSION num_scanlines;
/* On Mac, fetch a command line. */
#ifdef USE_CCOMMAND
argc = ccommand(&argv);
#endif
progname = argv[0];
if (progname == NULL || progname[0] == 0)
progname = "cjpeg"; /* in case C library doesn't provide it */
/* Initialize the JPEG compression object with default error handling. */
cinfo.err = jpeg_std_error(&jerr);
jpeg_create_compress(&cinfo);
/* Add some application-specific error messages (from cderror.h) */
jerr.addon_message_table = cdjpeg_message_table;
jerr.first_addon_message = JMSG_FIRSTADDONCODE;
jerr.last_addon_message = JMSG_LASTADDONCODE;
/* Now safe to enable signal catcher. */
#ifdef NEED_SIGNAL_CATCHER
enable_signal_catcher((j_common_ptr) &cinfo);
#endif
/* Initialize JPEG parameters.
* Much of this may be overridden later.
* In particular, we don't yet know the input file's color space,
* but we need to provide some value for jpeg_set_defaults() to work.
*/
cinfo.in_color_space = JCS_RGB; /* arbitrary guess */
jpeg_set_defaults(&cinfo);
/* Scan command line to find file names.
* It is convenient to use just one switch-parsing routine, but the switch
* values read here are ignored; we will rescan the switches after opening
* the input file.
*/
file_index = parse_switches(&cinfo, argc, argv, 0, FALSE);
#ifdef TWO_FILE_COMMANDLINE
/* Must have either -outfile switch or explicit output file name */
if (outfilename == NULL) {
if (file_index != argc-2) {
fprintf(stderr, "%s: must name one input and one output file\n",
progname);
usage();
}
outfilename = argv[file_index+1];
} else {
if (file_index != argc-1) {
fprintf(stderr, "%s: must name one input and one output file\n",
progname);
usage();
}
}
#else
/* Unix style: expect zero or one file name */
if (file_index < argc-1) {
fprintf(stderr, "%s: only one input file\n", progname);
usage();
}
#endif /* TWO_FILE_COMMANDLINE */
/* Open the input file. */
if (file_index < argc) {
if ((input_file = fopen(argv[file_index], READ_BINARY)) == NULL) {
fprintf(stderr, "%s: can't open %s\n", progname, argv[file_index]);
exit(EXIT_FAILURE);
}
} else {
/* default input file is stdin */
input_file = read_stdin();
}
/* Open the output file. */
if (outfilename != NULL) {
if ((output_file = fopen(outfilename, WRITE_BINARY)) == NULL) {
fprintf(stderr, "%s: can't open %s\n", progname, outfilename);
exit(EXIT_FAILURE);
}
} else {
/* default output file is stdout */
output_file = write_stdout();
}
#ifdef PROGRESS_REPORT
start_progress_monitor((j_common_ptr) &cinfo, &progress);
#endif
/* Figure out the input file format, and set up to read it. */
src_mgr = select_file_type(&cinfo, input_file);
src_mgr->input_file = input_file;
/* Read the input file header to obtain file size & colorspace. */
(*src_mgr->start_input) (&cinfo, src_mgr);
/* Now that we know input colorspace, fix colorspace-dependent defaults */
jpeg_default_colorspace(&cinfo);
/* Adjust default compression parameters by re-parsing the options */
file_index = parse_switches(&cinfo, argc, argv, 0, TRUE);
/* Specify data destination for compression */
jpeg_stdio_dest(&cinfo, output_file);
/* Start compressor */
jpeg_start_compress(&cinfo, TRUE);
/* Process data */
while (cinfo.next_scanline < cinfo.image_height) {
num_scanlines = (*src_mgr->get_pixel_rows) (&cinfo, src_mgr);
(void) jpeg_write_scanlines(&cinfo, src_mgr->buffer, num_scanlines);
}
/* Finish compression and release memory */
(*src_mgr->finish_input) (&cinfo, src_mgr);
jpeg_finish_compress(&cinfo);
jpeg_destroy_compress(&cinfo);
/* Close files, if we opened them */
if (input_file != stdin)
fclose(input_file);
if (output_file != stdout)
fclose(output_file);
#ifdef PROGRESS_REPORT
end_progress_monitor((j_common_ptr) &cinfo);
#endif
/* All done. */
exit(jerr.num_warnings ? EXIT_WARNING : EXIT_SUCCESS);
return 0; /* suppress no-return-value warnings */
}
int
main (int argc, char **argv)
{
struct jpeg_compress_struct cinfo;
struct jpeg_error_mgr jerr;
#ifdef PROGRESS_REPORT
struct cdjpeg_progress_mgr progress;
#endif
int file_index;
cjpeg_source_ptr src_mgr;
FILE * input_file;
FILE * output_file = NULL;
unsigned char *outbuffer = NULL;
unsigned long outsize = 0;
JDIMENSION num_scanlines;
/* On Mac, fetch a command line. */
#ifdef USE_CCOMMAND
argc = ccommand(&argv);
#endif
progname = argv[0];
if (progname == NULL || progname[0] == 0)
progname = "cjpeg"; /* in case C library doesn't provide it */
/* Initialize the JPEG compression object with default error handling. */
cinfo.err = jpeg_std_error(&jerr);
jpeg_create_compress(&cinfo);
/* Add some application-specific error messages (from cderror.h) */
jerr.addon_message_table = cdjpeg_message_table;
jerr.first_addon_message = JMSG_FIRSTADDONCODE;
jerr.last_addon_message = JMSG_LASTADDONCODE;
/* Now safe to enable signal catcher. */
#ifdef NEED_SIGNAL_CATCHER
enable_signal_catcher((j_common_ptr) &cinfo);
#endif
/* Initialize JPEG parameters.
* Much of this may be overridden later.
* In particular, we don't yet know the input file's color space,
* but we need to provide some value for jpeg_set_defaults() to work.
*/
cinfo.in_color_space = JCS_RGB; /* arbitrary guess */
cinfo.use_moz_defaults = TRUE;
jpeg_set_defaults(&cinfo);
/* Scan command line to find file names.
* It is convenient to use just one switch-parsing routine, but the switch
* values read here are ignored; we will rescan the switches after opening
* the input file.
*/
file_index = parse_switches(&cinfo, argc, argv, 0, FALSE);
#ifdef TWO_FILE_COMMANDLINE
if (!memdst) {
/* Must have either -outfile switch or explicit output file name */
if (outfilename == NULL) {
if (file_index != argc-2) {
fprintf(stderr, "%s: must name one input and one output file\n",
progname);
usage();
}
outfilename = argv[file_index+1];
} else {
if (file_index != argc-1) {
fprintf(stderr, "%s: must name one input and one output file\n",
progname);
usage();
}
}
}
#else
/* Unix style: expect zero or one file name */
if (file_index < argc-1) {
fprintf(stderr, "%s: only one input file\n", progname);
usage();
}
#endif /* TWO_FILE_COMMANDLINE */
/* Open the input file. */
if (file_index < argc) {
if ((input_file = fopen(argv[file_index], READ_BINARY)) == NULL) {
fprintf(stderr, "%s: can't open %s\n", progname, argv[file_index]);
exit(EXIT_FAILURE);
}
} else {
/* default input file is stdin */
input_file = read_stdin();
}
/* Open the output file. */
if (outfilename != NULL) {
if ((output_file = fopen(outfilename, WRITE_BINARY)) == NULL) {
fprintf(stderr, "%s: can't open %s\n", progname, outfilename);
exit(EXIT_FAILURE);
}
} else if (!memdst) {
/* default output file is stdout */
output_file = write_stdout();
}
#ifdef PROGRESS_REPORT
start_progress_monitor((j_common_ptr) &cinfo, &progress);
#endif
/* Figure out the input file format, and set up to read it. */
src_mgr = select_file_type(&cinfo, input_file);
src_mgr->input_file = input_file;
/* Read the input file header to obtain file size & colorspace. */
(*src_mgr->start_input) (&cinfo, src_mgr);
/* Now that we know input colorspace, fix colorspace-dependent defaults */
#if JPEG_RAW_READER
if (!is_jpeg)
#endif
jpeg_default_colorspace(&cinfo);
/* Adjust default compression parameters by re-parsing the options */
file_index = parse_switches(&cinfo, argc, argv, 0, TRUE);
/* Specify data destination for compression */
#if JPEG_LIB_VERSION >= 80 || defined(MEM_SRCDST_SUPPORTED)
if (memdst)
jpeg_mem_dest(&cinfo, &outbuffer, &outsize);
else
#endif
jpeg_stdio_dest(&cinfo, output_file);
/* Start compressor */
jpeg_start_compress(&cinfo, TRUE);
/* Copy metadata */
if (is_jpeg) {
jpeg_saved_marker_ptr marker;
/* In the current implementation, we don't actually need to examine the
* option flag here; we just copy everything that got saved.
* But to avoid confusion, we do not output JFIF and Adobe APP14 markers
* if the encoder library already wrote one.
*/
for (marker = src_mgr->marker_list; marker != NULL; marker = marker->next) {
if (cinfo.write_JFIF_header &&
marker->marker == JPEG_APP0 &&
marker->data_length >= 5 &&
GETJOCTET(marker->data[0]) == 0x4A &&
GETJOCTET(marker->data[1]) == 0x46 &&
GETJOCTET(marker->data[2]) == 0x49 &&
GETJOCTET(marker->data[3]) == 0x46 &&
GETJOCTET(marker->data[4]) == 0)
continue; /* reject duplicate JFIF */
if (cinfo.write_Adobe_marker &&
marker->marker == JPEG_APP0+14 &&
marker->data_length >= 5 &&
GETJOCTET(marker->data[0]) == 0x41 &&
GETJOCTET(marker->data[1]) == 0x64 &&
GETJOCTET(marker->data[2]) == 0x6F &&
GETJOCTET(marker->data[3]) == 0x62 &&
GETJOCTET(marker->data[4]) == 0x65)
continue; /* reject duplicate Adobe */
jpeg_write_marker(&cinfo, marker->marker, marker->data, marker->data_length);
}
}
/* Process data */
while (cinfo.next_scanline < cinfo.image_height) {
num_scanlines = (*src_mgr->get_pixel_rows) (&cinfo, src_mgr);
#if JPEG_RAW_READER
if (is_jpeg)
(void) jpeg_write_raw_data(&cinfo, src_mgr->plane_pointer, num_scanlines);
else
#endif
(void) jpeg_write_scanlines(&cinfo, src_mgr->buffer, num_scanlines);
}
/* Finish compression and release memory */
(*src_mgr->finish_input) (&cinfo, src_mgr);
jpeg_finish_compress(&cinfo);
jpeg_destroy_compress(&cinfo);
/* Close files, if we opened them */
if (input_file != stdin)
fclose(input_file);
if (output_file != stdout && output_file != NULL)
fclose(output_file);
#ifdef PROGRESS_REPORT
end_progress_monitor((j_common_ptr) &cinfo);
#endif
if (memdst) {
fprintf(stderr, "Compressed size: %lu bytes\n", outsize);
if (outbuffer != NULL)
free(outbuffer);
}
/* All done. */
exit(jerr.num_warnings ? EXIT_WARNING : EXIT_SUCCESS);
return 0; /* suppress no-return-value warnings */
}
int main(int argc, char **argv)
{
FILE *fp;
int iBr = NO_WRITING;
int bForce = 0;
int bPrintVersion = 0;
int bKeepLabel = 1;
int bWritePartitionInfo = 0;
int iHeads = -1;
int iRet = 0;
nls_init();
if(parse_switches(argc, argv, &iBr, &bForce, &bPrintVersion,
&bKeepLabel, &bWritePartitionInfo, &iHeads))
{
print_help(argv[0]);
return 0;
}
if(bPrintVersion)
{
print_version();
if(argc < 3)
return 0;
}
fp=fopen(argv[argc-1], (iBr || bWritePartitionInfo) ? "r+b" : "rb");
if(!fp)
{
printf(_("Unable to open %s, %s\n"), argv[argc-1], strerror(errno));
return 1;
}
if(iBr == AUTO_BR)
{
iBr = smart_select(fp);
if(!iBr)
printf(_("Unable to automaticly select boot record for %s\n"),
argv[argc-1]);
}
if(iBr && !bForce)
{
if(!sanity_check(fp, argv[argc-1], iBr, 1))
{
fclose(fp);
return 1;
}
}
if(bWritePartitionInfo)
{
if(!iBr && !bForce)
{
if(!sanity_check(fp, argv[argc-1], FAT32_BR, 1))
{
fclose(fp);
return 1;
}
}
if(write_partition_start_sector_number(fp))
{
printf(_("Start sector %ld (nr of hidden sectors) successfully written to %s\n"),
partition_start_sector(fp),
argv[argc-1]);
if( write_partition_physical_disk_drive_id(fp) )
{
printf(_("Physical disk drive id 0x80 (C:) successfully written to %s\n"),
argv[argc-1]);
if( write_partition_number_of_heads(fp, iHeads))
{
printf(_("Number of heads (%d) successfully written to %s\n"),
iHeads != -1 ? iHeads : partition_number_of_heads(fp),
argv[argc-1]);
}
else
{
printf(_("Failed writing number of heads to %s\n"),
argv[argc-1]);
}
}
else
{
printf(_("Failed writing physical disk drive id to %s\n"),
argv[argc-1]);
}
}
else
{
printf(_("Failed writing start sector to %s, this is only possible to do with\n"),
argv[argc-1]);
printf(_("real partitions!\n"));
iRet = 1;
}
}
switch(iBr)
{
case NO_WRITING:
{
if( ! bWritePartitionInfo )
{
diagnose(fp, argv[argc-1]);
}
break;
}
case MBR_WIN7FAT:
{
if(write_win7_fat_mbr(fp))
printf(_("Windows 7 FAT master boot record successfully written to %s\n"),
argv[argc-1]);
else
{
printf(_("Failed writing Windows 7 FAT master boot record to %s\n"),
argv[argc-1]);
iRet = 1;
}
}
case MBR_WIN7:
{
if(write_win7_mbr(fp))
printf(_("Windows 7 master boot record successfully written to %s\n"),
argv[argc-1]);
else
{
printf(_("Failed writing Windows 7 master boot record to %s\n"),
argv[argc-1]);
iRet = 1;
}
}
break;
case MBR_VISTA:
{
if(write_vista_mbr(fp))
printf(_("Windows Vista master boot record successfully written to %s\n"),
argv[argc-1]);
else
{
printf(_("Failed writing Windows Vista master boot record to %s\n"),
argv[argc-1]);
iRet = 1;
}
}
break;
case MBR_2000:
{
if(write_2000_mbr(fp))
printf(_("Windows 2000/XP/2003 master boot record successfully written to %s\n"),
argv[argc-1]);
else
{
printf(_("Failed writing Windows 2000/XP/2003 master boot record to %s\n"),
argv[argc-1]);
iRet = 1;
}
}
break;
case MBR_95B:
{
if(write_95b_mbr(fp))
printf(_("Windows 95B/98/98SE/ME master boot record successfully written to %s\n"),
argv[argc-1]);
else
{
printf(_("Failed writing Windows 95B/98/98SE/ME master boot record to %s\n"),
argv[argc-1]);
iRet = 1;
}
}
break;
case MBR_DOS:
{
if(write_dos_mbr(fp))
printf(_("DOS/Windows NT master boot record successfully written to %s\n"),
argv[argc-1]);
else
{
printf(_("Failed writing DOS/Windows NT master boot record to %s\n"),
argv[argc-1]);
iRet = 1;
}
}
break;
case MBR_SYSLINUX:
{
if(write_syslinux_mbr(fp))
printf(_("Syslinux master boot record successfully written to %s\n"),
argv[argc-1]);
else
{
printf(_("Failed writing syslinux master boot record to %s\n"),
argv[argc-1]);
iRet = 1;
}
}
break;
case MBR_GPT_SYSLINUX:
{
if(write_syslinux_gpt_mbr(fp))
printf(_("Syslinux GPT master boot record successfully written to %s\n"),
argv[argc-1]);
else
{
printf(_("Failed writing syslinux GPT master boot record to %s\n"),
argv[argc-1]);
iRet = 1;
}
}
break;
case MBR_ZERO:
{
if(write_zero_mbr(fp))
printf(_("Empty (zeroed) master boot record successfully written to %s\n"),
argv[argc-1]);
else
{
printf(_("Failed writing empty (zeroed) master boot record to %s\n"),
argv[argc-1]);
iRet = 1;
}
}
break;
case FAT12W7_BR:
{
if(write_fat_12_w7_br(fp, bKeepLabel))
printf(_("FAT12 Win 7 boot record successfully written to %s\n"),
argv[argc-1]);
else
{
printf(_("Failed writing FAT12 Win 7 boot record to %s\n"),
argv[argc-1]);
iRet = 1;
}
}
break;
case FAT12_BR:
{
if(write_fat_12_br(fp, bKeepLabel))
printf(_("FAT12 boot record successfully written to %s\n"),
argv[argc-1]);
else
{
printf(_("Failed writing FAT12 boot record to %s\n"),
argv[argc-1]);
iRet = 1;
}
}
break;
case FAT16_BR:
{
if(write_fat_16_br(fp, bKeepLabel))
printf(_("FAT16 boot record successfully written to %s\n"),
argv[argc-1]);
else
{
printf(_("Failed writing FAT16 boot record to %s\n"),
argv[argc-1]);
iRet = 1;
}
}
break;
case FAT16FD_BR:
{
if(write_fat_16_fd_br(fp, bKeepLabel))
printf(_("FAT16 FreeDOS boot record successfully written to %s\n"),
argv[argc-1]);
else
{
printf(_("Failed writing FAT16 FreeDOS boot record to %s\n"),
argv[argc-1]);
iRet = 1;
}
}
break;
case FAT32NT_BR:
{
if(write_fat_32_nt_br(fp, bKeepLabel))
printf(_("FAT32 NT boot record successfully written to %s\n"),
argv[argc-1]);
else
{
printf(_("Failed writing FAT32 NT boot record to %s\n"),
argv[argc-1]);
iRet = 1;
}
}
break;
case FAT32PE_BR:
{
if(write_fat_32_pe_br(fp, bKeepLabel))
printf(_("FAT32 PE boot record successfully written to %s\n"),
argv[argc-1]);
else
{
printf(_("Failed writing FAT32 PE boot record to %s\n"),
argv[argc-1]);
iRet = 1;
}
}
break;
case FAT32FD_BR:
{
if(write_fat_32_fd_br(fp, bKeepLabel))
printf(_("FAT32 FreeDOS boot record successfully written to %s\n"),
argv[argc-1]);
else
{
printf(_("Failed writing FAT32 FreeDOS boot record to %s\n"),
argv[argc-1]);
iRet = 1;
}
}
break;
case FAT32W7_BR:
{
if(write_fat_32_w7_br(fp, bKeepLabel))
printf(_("FAT32 Win 7 boot record successfully written to %s\n"),
argv[argc-1]);
else
{
printf(_("Failed writing FAT32 Win 7 boot record to %s\n"),
argv[argc-1]);
iRet = 1;
}
}
break;
case FAT32_BR:
{
if(write_fat_32_br(fp, bKeepLabel))
printf(_("FAT32 DOS boot record successfully written to %s\n"),
argv[argc-1]);
else
{
printf(_("Failed writing FAT32 DOS boot record to %s\n"),
argv[argc-1]);
iRet = 1;
}
}
break;
case NTFS_BR:
{
if(write_ntfs_br(fp))
printf(_("NTFS Windows 7 boot record successfully written to %s\n"),
argv[argc-1]);
else
{
printf(_("Failed writing NTFS Windows 7 boot record to %s\n"),
argv[argc-1]);
iRet = 1;
}
}
break;
default:
{
printf(_("Whoops, internal error, unknown boot record\n"));
}
break;
}
fclose(fp);
return iRet;
} /* main */
int
main (int argc, char **argv)
{
struct jpeg_decompress_struct srcinfo;
struct jpeg_compress_struct dstinfo;
struct jpeg_error_mgr jsrcerr, jdsterr;
#ifdef PROGRESS_REPORT
struct cdjpeg_progress_mgr progress;
#endif
jvirt_barray_ptr * src_coef_arrays;
jvirt_barray_ptr * dst_coef_arrays;
int file_index;
FILE * input_file;
FILE * output_file;
/* On Mac, fetch a command line. */
#ifdef USE_CCOMMAND
argc = ccommand(&argv);
#endif
progname = argv[0];
if (progname == NULL || progname[0] == 0)
progname = "jpegtran"; /* in case C library doesn't provide it */
/* 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, argc, argv, 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 == NULL) {
if (file_index != argc-2) {
fprintf(stderr, "%s: must name one input and one output file\n",
progname);
usage();
}
outfilename = argv[file_index+1];
} else {
if (file_index != argc-1) {
fprintf(stderr, "%s: must name one input and one output file\n",
progname);
usage();
}
}
#else
/* Unix style: expect zero or one file name */
if (file_index < argc-1) {
fprintf(stderr, "%s: only one input file\n", progname);
usage();
}
#endif /* TWO_FILE_COMMANDLINE */
/* Open the input file. */
if (file_index < argc) {
if ((input_file = fopen(argv[file_index], READ_BINARY)) == NULL) {
fprintf(stderr, "%s: can't open %s\n", progname, argv[file_index]);
exit(EXIT_FAILURE);
}
} else {
/* default input file is stdin */
input_file = read_stdin();
}
/* Open the output file. */
if (outfilename != NULL) {
if ((output_file = fopen(outfilename, WRITE_BINARY)) == NULL) {
fprintf(stderr, "%s: can't open %s\n", progname, outfilename);
exit(EXIT_FAILURE);
}
} else {
/* default output file is stdout */
output_file = write_stdout();
}
#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.
*/
#if 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.
*/
#if 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, argc, argv, 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 */
#if 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 */
if (input_file != stdin)
fclose(input_file);
if (output_file != stdout)
fclose(output_file);
#ifdef PROGRESS_REPORT
end_progress_monitor((j_common_ptr) &dstinfo);
#endif
/* All done. */
exit(jsrcerr.num_warnings + jdsterr.num_warnings ?EXIT_WARNING:EXIT_SUCCESS);
return 0; /* suppress no-return-value warnings */
}
int
main (int argc, char **argv)
{
struct jpeg_decompress_struct srcinfo;
struct jpeg_compress_struct dstinfo;
struct jpeg_error_mgr jsrcerr, jdsterr;
#ifdef PROGRESS_REPORT
struct cdjpeg_progress_mgr progress;
#endif
jvirt_barray_ptr * src_coef_arrays;
jvirt_barray_ptr * dst_coef_arrays;
int file_index;
/* We assume all-in-memory processing and can therefore use only a
* single file pointer for sequential input and output operation.
*/
FILE * fp;
unsigned char *inbuffer = NULL;
unsigned long insize = 0;
unsigned char *outbuffer = NULL;
unsigned long outsize = 0;
/* On Mac, fetch a command line. */
#ifdef USE_CCOMMAND
argc = ccommand(&argv);
#endif
progname = argv[0];
if (progname == NULL || progname[0] == 0)
progname = "jpegtran"; /* in case C library doesn't provide it */
/* 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);
dstinfo.use_moz_defaults = TRUE;
/* 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, argc, argv, 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 == NULL) {
if (file_index != argc-2) {
fprintf(stderr, "%s: must name one input and one output file\n",
progname);
usage();
}
outfilename = argv[file_index+1];
} else {
if (file_index != argc-1) {
fprintf(stderr, "%s: must name one input and one output file\n",
progname);
usage();
}
}
#else
/* Unix style: expect zero or one file name */
if (file_index < argc-1) {
fprintf(stderr, "%s: only one input file\n", progname);
usage();
}
#endif /* TWO_FILE_COMMANDLINE */
/* Open the input file. */
if (file_index < argc) {
if ((fp = fopen(argv[file_index], READ_BINARY)) == NULL) {
fprintf(stderr, "%s: can't open %s for reading\n", progname, argv[file_index]);
exit(EXIT_FAILURE);
}
} else {
/* default input file is stdin */
fp = read_stdin();
}
#ifdef PROGRESS_REPORT
start_progress_monitor((j_common_ptr) &dstinfo, &progress);
#endif
/* Specify data source for decompression */
memsrc = dstinfo.use_moz_defaults; /* needed to revert to original */
#if JPEG_LIB_VERSION >= 80 || defined(MEM_SRCDST_SUPPORTED)
if (memsrc) {
size_t nbytes;
do {
inbuffer = (unsigned char *)realloc(inbuffer, insize + INPUT_BUF_SIZE);
if (inbuffer == NULL) {
fprintf(stderr, "%s: memory allocation failure\n", progname);
exit(EXIT_FAILURE);
}
nbytes = JFREAD(fp, &inbuffer[insize], INPUT_BUF_SIZE);
if (nbytes < INPUT_BUF_SIZE && ferror(fp)) {
if (file_index < argc)
fprintf(stderr, "%s: can't read from %s\n", progname,
argv[file_index]);
else
fprintf(stderr, "%s: can't read from stdin\n", progname);
}
insize += (unsigned long)nbytes;
} while (nbytes == INPUT_BUF_SIZE);
jpeg_mem_src(&srcinfo, inbuffer, insize);
} else
#endif
jpeg_stdio_src(&srcinfo, fp);
/* 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.
*/
#if TRANSFORMS_SUPPORTED
/* Fail right away if -perfect is given and transformation is not perfect.
*/
if (!jtransform_request_workspace(&srcinfo, &transformoption)) {
fprintf(stderr, "%s: transformation is not perfect\n", progname);
exit(EXIT_FAILURE);
}
#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.
*/
#if TRANSFORMS_SUPPORTED
dst_coef_arrays = jtransform_adjust_parameters(&srcinfo, &dstinfo,
src_coef_arrays,
&transformoption);
#else
dst_coef_arrays = src_coef_arrays;
#endif
/* Close input file, if we opened it.
* Note: we assume that jpeg_read_coefficients consumed all input
* until JPEG_REACHED_EOI, and that jpeg_finish_decompress will
* only consume more while (! cinfo->inputctl->eoi_reached).
* We cannot call jpeg_finish_decompress here since we still need the
* virtual arrays allocated from the source object for processing.
*/
if (fp != stdin)
fclose(fp);
/* Open the output file. */
if (outfilename != NULL) {
if ((fp = fopen(outfilename, WRITE_BINARY)) == NULL) {
fprintf(stderr, "%s: can't open %s for writing\n", progname, outfilename);
exit(EXIT_FAILURE);
}
} else {
/* default output file is stdout */
fp = write_stdout();
}
/* Adjust default compression parameters by re-parsing the options */
file_index = parse_switches(&dstinfo, argc, argv, 0, TRUE);
/* Specify data destination for compression */
#if JPEG_LIB_VERSION >= 80 || defined(MEM_SRCDST_SUPPORTED)
if (dstinfo.use_moz_defaults)
jpeg_mem_dest(&dstinfo, &outbuffer, &outsize);
else
#endif
jpeg_stdio_dest(&dstinfo, fp);
/* 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 */
#if TRANSFORMS_SUPPORTED
jtransform_execute_transformation(&srcinfo, &dstinfo,
src_coef_arrays,
&transformoption);
#endif
/* Finish compression and release memory */
jpeg_finish_compress(&dstinfo);
if (dstinfo.use_moz_defaults) {
size_t nbytes;
unsigned char *buffer = outbuffer;
unsigned long size = outsize;
if (insize < size) {
size = insize;
buffer = inbuffer;
}
nbytes = JFWRITE(fp, buffer, size);
if (nbytes < size && ferror(fp)) {
if (file_index < argc)
fprintf(stderr, "%s: can't write to %s\n", progname,
argv[file_index]);
else
fprintf(stderr, "%s: can't write to stdout\n", progname);
}
}
jpeg_destroy_compress(&dstinfo);
(void) jpeg_finish_decompress(&srcinfo);
jpeg_destroy_decompress(&srcinfo);
/* Close output file, if we opened it */
if (fp != stdout)
fclose(fp);
#ifdef PROGRESS_REPORT
end_progress_monitor((j_common_ptr) &dstinfo);
#endif
/* All done. */
exit(jsrcerr.num_warnings + jdsterr.num_warnings ?EXIT_WARNING:EXIT_SUCCESS);
return 0; /* suppress no-return-value warnings */
}
int
startup (int argc, char **argv)
{
struct jpeg_decompress_struct srcinfo;
struct jpeg_compress_struct dstinfo;
struct jpeg_error_mgr jsrcerr, jdsterr;
#ifdef PROGRESS_REPORT
struct cdjpeg_progress_mgr progress;
#endif
jvirt_barray_ptr * coef_arrays;
int file_index;
FILE * input_file;
FILE * output_file;
/* On Mac, fetch a command line. */
#ifdef USE_CCOMMAND
argc = ccommand(&argv);
#endif
progname = argv[0];
if (progname == NULL || progname[0] == 0)
progname = "jpegtran"; /* in case C library doesn't provide it */
/* 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 ignored; we will rescan the switches after opening
* the input file.
*/
file_index = parse_switches(&dstinfo, argc, argv, 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 == NULL) {
if (file_index != argc-2) {
fprintf(stderr, "%s: must name one input and one output file\n",
progname);
usage();
}
outfilename = argv[file_index+1];
} else {
if (file_index != argc-1) {
fprintf(stderr, "%s: must name one input and one output file\n",
progname);
usage();
}
}
#else
/* Unix style: expect zero or one file name */
if (file_index < argc-1) {
fprintf(stderr, "%s: only one input file\n", progname);
usage();
}
#endif /* TWO_FILE_COMMANDLINE */
/* Open the input file. */
if (file_index < argc) {
if ((input_file = fopen(argv[file_index], READ_BINARY)) == NULL) {
fprintf(stderr, "%s: can't open %s\n", progname, argv[file_index]);
exit(EXIT_FAILURE);
}
} else {
/* default input file is stdin */
input_file = read_stdin();
}
/* Open the output file. */
if (outfilename != NULL) {
if ((output_file = fopen(outfilename, WRITE_BINARY)) == NULL) {
fprintf(stderr, "%s: can't open %s\n", progname, outfilename);
exit(EXIT_FAILURE);
}
} else {
/* default output file is stdout */
output_file = write_stdout();
}
#ifdef PROGRESS_REPORT
start_progress_monitor((j_common_ptr) &dstinfo, &progress);
#endif
/* Specify data source for decompression */
jpeg_stdio_src(&srcinfo, input_file);
/* Read file header */
(void) jpeg_read_header(&srcinfo, TRUE);
/* Read source file as DCT coefficients */
coef_arrays = jpeg_read_coefficients(&srcinfo);
/* Initialize destination compression parameters from source values */
jpeg_copy_critical_parameters(&srcinfo, &dstinfo);
/* Adjust default compression parameters by re-parsing the options */
file_index = parse_switches(&dstinfo, argc, argv, 0, TRUE);
/* Specify data destination for compression */
jpeg_stdio_dest(&dstinfo, output_file);
/* Start compressor */
jpeg_write_coefficients(&dstinfo, coef_arrays);
/* ought to copy source comments here... */
/* 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 */
if (input_file != stdin)
fclose(input_file);
if (output_file != stdout)
fclose(output_file);
#ifdef PROGRESS_REPORT
end_progress_monitor((j_common_ptr) &dstinfo);
#endif
/* All done. */
exit(jsrcerr.num_warnings + jdsterr.num_warnings ?EXIT_WARNING:EXIT_SUCCESS);
return 0; /* suppress no-return-value warnings */
}
process_one_file (int argc, char **argv, int old_file_index)
{
struct jpeg_decompress_struct cinfo;
struct jpeg_error_mgr jerr;
char *infilename;
char workfilename[PATH_MAX];
const char *default_extension = NULL;
#ifdef PROGRESS_REPORT
struct cdjpeg_progress_mgr progress;
#endif
int file_index;
djpeg_dest_ptr dest_mgr = NULL;
FILE * input_file = NULL;
FILE * output_file = NULL;
JDIMENSION num_scanlines;
/* Initialize the JPEG decompression object with default error handling. */
cinfo.err = jpeg_std_error(&jerr);
jpeg_create_decompress(&cinfo);
/* Add some application-specific error messages (from cderror.h) */
jerr.addon_message_table = cdjpeg_message_table;
jerr.first_addon_message = JMSG_FIRSTADDONCODE;
jerr.last_addon_message = JMSG_LASTADDONCODE;
/* Insert custom marker processor for COM and APP12.
* APP12 is used by some digital camera makers for textual info,
* so we provide the ability to display it as text.
* If you like, additional APPn marker types can be selected for display,
* but don't try to override APP0 or APP14 this way (see libjpeg.doc).
*/
jpeg_set_marker_processor(&cinfo, JPEG_COM, print_text_marker);
jpeg_set_marker_processor(&cinfo, JPEG_APP0+12, print_text_marker);
/* Now safe to enable signal catcher. */
#ifdef NEED_SIGNAL_CATCHER
enable_signal_catcher((j_common_ptr) &cinfo);
#endif
/* Scan command line to find next file name.
* It is convenient to use just one switch-parsing routine, but the switch
* values read here are ignored; we will rescan the switches after opening
* the input file.
* (Exception: tracing level set here controls verbosity for COM markers
* found during jpeg_read_header...)
*/
file_index = parse_switches(&cinfo, argc, argv, old_file_index, FALSE);
if (file_index >= argc) {
fprintf(stderr, "%s: missing input file name\n", progname);
usage();
}
/* Open the input file. */
infilename = argv[file_index];
if ((input_file = fopen(infilename, READ_BINARY)) == NULL) {
fprintf(stderr, "%s: can't open %s\n", progname, infilename);
goto fail;
}
#ifdef PROGRESS_REPORT
start_progress_monitor((j_common_ptr) &cinfo, &progress);
#endif
/* Specify data source for decompression */
jpeg_stdio_src(&cinfo, input_file);
/* Read file header, set default decompression parameters */
(void) jpeg_read_header(&cinfo, TRUE);
/* Adjust default decompression parameters by re-parsing the options */
file_index = parse_switches(&cinfo, argc, argv, old_file_index, TRUE);
/* Initialize the output module now to let it override any crucial
* option settings (for instance, GIF wants to force color quantization).
*/
switch (requested_fmt) {
#ifdef BMP_SUPPORTED
case FMT_BMP:
dest_mgr = jinit_write_bmp(&cinfo, FALSE);
default_extension = ".bmp";
break;
case FMT_OS2:
dest_mgr = jinit_write_bmp(&cinfo, TRUE);
default_extension = ".bmp";
break;
#endif
#ifdef GIF_SUPPORTED
case FMT_GIF:
dest_mgr = jinit_write_gif(&cinfo);
default_extension = ".gif";
break;
#endif
#ifdef PPM_SUPPORTED
case FMT_PPM:
dest_mgr = jinit_write_ppm(&cinfo);
default_extension = ".ppm";
break;
#endif
#ifdef RLE_SUPPORTED
case FMT_RLE:
dest_mgr = jinit_write_rle(&cinfo);
default_extension = ".rle";
break;
#endif
#ifdef TARGA_SUPPORTED
case FMT_TARGA:
dest_mgr = jinit_write_targa(&cinfo);
default_extension = ".tga";
break;
#endif
default:
ERREXIT(&cinfo, JERR_UNSUPPORTED_FORMAT);
break;
}
/* If user didn't supply -outfile switch, select output file name. */
if (outfilename == NULL) {
int i;
outfilename = workfilename;
/* Make outfilename be infilename with appropriate extension */
strcpy(outfilename, infilename);
for (i = strlen(outfilename)-1; i >= 0; i--) {
switch (outfilename[i]) {
case ':':
case '/':
case '\\':
i = 0; /* stop scanning */
break;
case '.':
outfilename[i] = '\0'; /* lop off existing extension */
i = 0; /* stop scanning */
break;
default:
break; /* keep scanning */
}
}
strcat(outfilename, default_extension);
}
fprintf(stderr, "Decompressing %s => %s\n", infilename, outfilename);
#ifndef NO_OVERWRITE_CHECK
if (! is_write_ok(outfilename))
goto fail;
#endif
/* Open the output file. */
if ((output_file = fopen(outfilename, WRITE_BINARY)) == NULL) {
fprintf(stderr, "%s: can't create %s\n", progname, outfilename);
goto fail;
}
dest_mgr->output_file = output_file;
/* Start decompressor */
(void) jpeg_start_decompress(&cinfo);
/* Write output file header */
(*dest_mgr->start_output) (&cinfo, dest_mgr);
/* Process data */
while (cinfo.output_scanline < cinfo.output_height) {
num_scanlines = jpeg_read_scanlines(&cinfo, dest_mgr->buffer,
dest_mgr->buffer_height);
(*dest_mgr->put_pixel_rows) (&cinfo, dest_mgr, num_scanlines);
}
#ifdef PROGRESS_REPORT
/* Hack: count final pass as done in case finish_output does an extra pass.
* The library won't have updated completed_passes.
*/
progress.pub.completed_passes = progress.pub.total_passes;
#endif
/* Finish decompression and release memory.
* I must do it in this order because output module has allocated memory
* of lifespan JPOOL_IMAGE; it needs to finish before releasing memory.
*/
(*dest_mgr->finish_output) (&cinfo, dest_mgr);
(void) jpeg_finish_decompress(&cinfo);
/* Clean up and exit */
fail:
jpeg_destroy_decompress(&cinfo);
if (input_file != NULL) fclose(input_file);
if (output_file != NULL) fclose(output_file);
#ifdef PROGRESS_REPORT
end_progress_monitor((j_common_ptr) &cinfo);
#endif
/* Disable signal catcher. */
#ifdef NEED_SIGNAL_CATCHER
enable_signal_catcher((j_common_ptr) NULL);
#endif
return file_index;
}
int
main (int argc, char **argv)
{
struct jpeg_decompress_struct srcinfo;
struct jpeg_compress_struct dstinfo;
struct jpeg_error_mgr jsrcerr, jdsterr;
#ifdef PROGRESS_REPORT
struct cdjpeg_progress_mgr progress;
#endif
jvirt_barray_ptr * src_coef_arrays;
jvirt_barray_ptr * dst_coef_arrays;
int file_index;
FILE * input_file;
FILE * output_file;
#ifdef USE_CCOMMAND
argc = ccommand(&argv);
#endif
progname = argv[0];
if (progname == NULL || progname[0] == 0)
progname = "jpegtran";
srcinfo.err = jpeg_std_error(&jsrcerr);
jpeg_create_decompress(&srcinfo);
dstinfo.err = jpeg_std_error(&jdsterr);
jpeg_create_compress(&dstinfo);
#ifdef NEED_SIGNAL_CATCHER
enable_signal_catcher((j_common_ptr) &srcinfo);
#endif
file_index = parse_switches(&dstinfo, argc, argv, 0, FALSE);
jsrcerr.trace_level = jdsterr.trace_level;
srcinfo.mem->max_memory_to_use = dstinfo.mem->max_memory_to_use;
#ifdef TWO_FILE_COMMANDLINE
if (outfilename == NULL) {
if (file_index != argc-2) {
fprintf(stderr, "%s: must name one input and one output file\n",
progname);
usage();
}
outfilename = argv[file_index+1];
} else {
if (file_index != argc-1) {
fprintf(stderr, "%s: must name one input and one output file\n",
progname);
usage();
}
}
#else
if (file_index < argc-1) {
fprintf(stderr, "%s: only one input file\n", progname);
usage();
}
#endif
if (file_index < argc) {
if ((input_file = fopen(argv[file_index], READ_BINARY)) == NULL) {
fprintf(stderr, "%s: can't open %s\n", progname, argv[file_index]);
exit(EXIT_FAILURE);
}
} else {
input_file = read_stdin();
}
if (outfilename != NULL) {
if ((output_file = fopen(outfilename, WRITE_BINARY)) == NULL) {
fprintf(stderr, "%s: can't open %s\n", progname, outfilename);
exit(EXIT_FAILURE);
}
} else {
output_file = write_stdout();
}
#ifdef PROGRESS_REPORT
start_progress_monitor((j_common_ptr) &dstinfo, &progress);
#endif
jpeg_stdio_src(&srcinfo, input_file);
jcopy_markers_setup(&srcinfo, copyoption);
(void) jpeg_read_header(&srcinfo, TRUE);
#if TRANSFORMS_SUPPORTED
jtransform_request_workspace(&srcinfo, &transformoption);
#endif
src_coef_arrays = jpeg_read_coefficients(&srcinfo);
jpeg_copy_critical_parameters(&srcinfo, &dstinfo);
#if TRANSFORMS_SUPPORTED
dst_coef_arrays = jtransform_adjust_parameters(&srcinfo, &dstinfo,
src_coef_arrays,
&transformoption);
#else
dst_coef_arrays = src_coef_arrays;
#endif
file_index = parse_switches(&dstinfo, argc, argv, 0, TRUE);
jpeg_stdio_dest(&dstinfo, output_file);
/* Start compressor (note no image data is actually written here) */
jpeg_write_coefficients(&dstinfo, dst_coef_arrays);
jcopy_markers_execute(&srcinfo, &dstinfo, copyoption);
#if TRANSFORMS_SUPPORTED
jtransform_execute_transformation(&srcinfo, &dstinfo,
src_coef_arrays,
&transformoption);
#endif
jpeg_finish_compress(&dstinfo);
jpeg_destroy_compress(&dstinfo);
(void) jpeg_finish_decompress(&srcinfo);
jpeg_destroy_decompress(&srcinfo);
if (input_file != stdin)
fclose(input_file);
if (output_file != stdout)
fclose(output_file);
#ifdef PROGRESS_REPORT
end_progress_monitor((j_common_ptr) &dstinfo);
#endif
exit(jsrcerr.num_warnings + jdsterr.num_warnings ?EXIT_WARNING:EXIT_SUCCESS);
return 0;
}
int
main (int argc, char **argv)
{
struct jpegxr_file_struct finfo;
struct jpeg_error_mgr jerr;
#ifdef PROGRESS_REPORT
struct cdjpeg_progress_mgr progress;
#endif
int file_index;
djpeg_dest_ptr dest_mgr = NULL;
FILE * input_file;
FILE * output_file;
JDIMENSION num_scanlines;
/* On Mac, fetch a command line. */
#ifdef USE_CCOMMAND
argc = ccommand(&argv);
#endif
progname = argv[0];
if (progname == NULL || progname[0] == 0)
progname = "djpeg-xr"; /* in case C library doesn't provide it */
/* Initialize the JPEG-XR file decompression object with default error
* handling. */
finfo.err = jpeg_std_error(&jerr);
jpegxr_file_create_decompress(&finfo);
/* Add some application-specific error messages (from cderror.h) */
jerr.addon_message_table = cdjpeg_message_table;
jerr.first_addon_message = JMSG_FIRSTADDONCODE;
jerr.last_addon_message = JMSG_LASTADDONCODE;
/* Now safe to enable signal catcher. */
#ifdef NEED_SIGNAL_CATCHER
enable_signal_catcher((j_common_ptr) &finfo);
#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 ignored; we will rescan the switches after opening
* the input file.
* (Exception: tracing level set here controls verbosity for COM markers
* found during jpeg_read_header...)
*/
file_index = parse_switches(&finfo, argc, argv, 0, FALSE);
#ifdef TWO_FILE_COMMANDLINE
/* Must have either -outfile switch or explicit output file name */
if (outfilename == NULL) {
if (file_index != argc-2) {
fprintf(stderr, "%s: must name one input and one output file\n",
progname);
usage();
}
outfilename = argv[file_index+1];
} else {
if (file_index != argc-1) {
fprintf(stderr, "%s: must name one input and one output file\n",
progname);
usage();
}
}
#else
/* Unix style: expect zero or one file name */
if (file_index < argc-1) {
fprintf(stderr, "%s: only one input file\n", progname);
usage();
}
#endif /* TWO_FILE_COMMANDLINE */
/* Open the input file. */
if (file_index < argc) {
if ((input_file = fopen(argv[file_index], READ_BINARY)) == NULL) {
fprintf(stderr, "%s: can't open %s\n", progname, argv[file_index]);
exit(EXIT_FAILURE);
}
} else {
/* default input file is stdin */
input_file = read_stdin();
}
/* Open the output file. */
if (outfilename != NULL) {
if ((output_file = fopen(outfilename, WRITE_BINARY)) == NULL) {
fprintf(stderr, "%s: can't open %s\n", progname, outfilename);
exit(EXIT_FAILURE);
}
} else {
/* default output file is stdout */
output_file = write_stdout();
}
#ifdef PROGRESS_REPORT
start_progress_monitor((j_common_ptr) &finfo, &progress);
#endif
/* Specify data source for decompression */
jpeg_stdio_src((j_common_ptr) &finfo, input_file);
/* Read file header */
(void) jpegxr_file_read_metadata(&finfo);
/* TODO - initialise the output module here */
/* Start decompressor */
(void) jpegxr_file_start_decompress(&finfo);
/* Write output file header */
//(*dest_mgr->start_output) (&finfo, dest_mgr);
/* TODO - process data, equivalent to jpeg_read_scanlines() */
//(*dest_mgr->finish_output) (&finfo, dest_mgr);
/* Finish decompression and release memory.
* Must be done in this order because output module has allocated memory
* of lifespan JPOOL_IMAGE; it needs to finish before releasing memory.
*/
(void) jpegxr_file_finish_decompress(&finfo);
jpegxr_file_destroy(&finfo);
/* Close files, if we opened them */
if (input_file != stdin)
fclose(input_file);
if (output_file != stdout)
fclose(output_file);
#ifdef PROGRESS_REPORT
end_progress_monitor((j_common_ptr) &finfo);
#endif
/* All done. */
exit(jerr.num_warnings ? EXIT_WARNING : EXIT_SUCCESS);
return 0; /* suppress no-return-value warnings */
}
map<string, string> parse_switches(int argc, char **argv) {
return parse_switches(argc, (const char **) argv);
}
void PatchTableParams::set_from_switches(int argc, const char **argv) {
map<string, string> switches = parse_switches(argc, argv);
if (switches.count("-speed")) { set_speed(atoi(switches["-speed"].c_str())); }
if (switches.count("-limit")) { limit = int(1000*1000*atof(switches["-limit"].c_str())); }
if (switches.count("-enrich_limit")) { enrich_limit = int(1000*1000*atof(switches["-enrich_limit"].c_str())); }
if (switches.count("-regular_grid")) { regular_grid = atoi(switches["-regular_grid"].c_str()); }
#if TABLE_OPTIMIZE_REGULAR
regular_grid = true;
#endif
if (switches.count("-table_knn")) { table_knn = atoi(switches["-table_knn"].c_str()); }
if (switches.count("-randomize_dt")) { randomize_dt = atoi(switches["-randomize_dt"].c_str()); }
if (switches.count("-parallel_dt")) { parallel_dt = atoi(switches["-parallel_dt"].c_str()); }
if (switches.count("-dt_threads")) { dt_threads = atoi(switches["-dt_threads"].c_str()); }
#if TABLE_OPENMP
if (switches.count("-threads")) { threads = atoi(switches["-threads"].c_str()); }
#endif
if (switches.count("-verbose")) { verbose = atoi(switches["-verbose"].c_str()); }
if (switches.count("-populate_nearest")) { populate_nearest = atoi(switches["-populate_nearest"].c_str()); }
if (switches.count("-populate_random")) { populate_random = bool(atoi(switches["-populate_random"].c_str())); }
if (switches.count("-partition_step")) { partition_step = atoi(switches["-partition_step"].c_str()); }
if (switches.count("-ndims")) { ndims = atoi(switches["-ndims"].c_str()); }
if (switches.count("-nchroma")) { nchroma = atoi(switches["-nchroma"].c_str()); }
if (switches.count("-ntables")) { ntables = atoi(switches["-ntables"].c_str()); }
if (switches.count("-nslices")) {
vector<string> nL = str_split(switches["-nslices"], ',');
ndims = nL.size();
nslices.resize(ndims);
ASSERT2(nL.size() == nslices.size(), "expected -nslices size to match number of dims");
for (int i = 0; i < (int) nL.size(); i++) {
nslices[i] = atoi(nL[i].c_str());
}
printf("Parsed nslices: ");
for (int i = 0; i < (int) nL.size(); i++) {
printf("%d ", nslices[i]);
}
printf("\n");
}
if (switches.count("-run_dt")) { run_dt = bool(atoi(switches["-run_dt"].c_str())); }
if (switches.count("-do_prop")) { do_prop = atoi(switches["-do_prop"].c_str()); }
if (switches.count("-prop_y_step")) { prop_y_step = atof(switches["-prop_y_step"].c_str()); }
if (switches.count("-do_rs")) { do_rs = atoi(switches["-do_rs"].c_str()); }
if (switches.count("-spatial")) { spatial = atoi(switches["-spatial"].c_str()); }
if (switches.count("-prob_rs")) { prob_rs = atof(switches["-prob_rs"].c_str()); }
#if TABLE_RS_TABLE
if (switches.count("-rs_table")) { rs_table = atoi(switches["-rs_table"].c_str()); printf("set rs_table=%d\n", rs_table); }
#endif
if (switches.count("-load")) { load_filename = switches["-load"]; }
if (switches.count("-save")) { save_filename = switches["-save"]; }
if (switches.count("-check_existing")) { check_existing = bool(atoi(switches["-check_existing"].c_str())); }
if (switches.count("-patch_w")) { patch_w = atoi(switches["-patch_w"].c_str()); }
if (switches.count("-pca_samples")) { pca_samples = atoi(switches["-pca_samples"].c_str()); }
if (switches.count("-pca_mean")) { pca_mean = bool(atoi(switches["-pca_mean"].c_str())); }
if (switches.count("-pca_subtract_mean")) { pca_subtract_mean = bool(atoi(switches["-pca_subtract_mean"].c_str())); }
#if TABLE_ENABLE_ANN
if (switches.count("-ann")) { ann = bool(atoi(switches["-ann"].c_str())); }
if (switches.count("-ann_agrid")) { ann_agrid = atoi(switches["-ann_agrid"].c_str()); }
if (switches.count("-ann_bgrid")) { ann_bgrid = atoi(switches["-ann_bgrid"].c_str()); }
if (switches.count("-ann_eps")) { ann_eps = atof(switches["-ann_eps"].c_str()); }
#endif
#if TABLE_CLUSTER_KMEANS
if (switches.count("-cluster_kmeans")) { cluster_kmeans = bool(atoi(switches["-cluster_kmeans"].c_str())); }
if (switches.count("-cluster_count")) { cluster_count = atoi(switches["-cluster_count"].c_str()); }
if (switches.count("-cluster_limit")) { cluster_limit = int(1000*1000*atof(switches["-cluster_limit"].c_str())); }
#endif
if (switches.count("-dt_knn")) { dt_knn = atoi(switches["-dt_knn"].c_str()); }
if (switches.count("-prop_iters")) { prop_iters = atoi(switches["-prop_iters"].c_str()); }
if (switches.count("-dt_iters")) { dt_iters = atoi(switches["-dt_iters"].c_str()); }
if (switches.count("-query_step")) { query_step = atoi(switches["-query_step"].c_str()); }
if (switches.count("-coherence_spatial")) { coherence_spatial = atof(switches["-coherence_spatial"].c_str()); }
if (switches.count("-coherence_temporal")) { coherence_temporal = atof(switches["-coherence_temporal"].c_str()); }
if (switches.count("-recalc_dist_temporal")) { recalc_dist_temporal = bool(atoi(switches["-recalc_dist_temporal"].c_str())); }
if (switches.count("-dt_algo")) {
string mode = switches["-dt_algo"];
if (mode == string("raster")) { dt_algo = DT_ALGO_RASTER; }
else if (mode == string("prop")) { dt_algo = DT_ALGO_PROP; }
else if (mode == string("brute")) { dt_algo = DT_ALGO_BRUTE; }
else if (mode == string("kdtree")) { dt_algo = DT_ALGO_KDTREE; }
else if (mode == string("downsample")) { dt_algo = DT_ALGO_DOWNSAMPLE; }
else if (mode == string("hybrid")) { dt_algo = DT_ALGO_HYBRID; }
else if (mode == string("euclidean")) { dt_algo = DT_ALGO_EUCLIDEAN; }
else { fprintf(stderr, "invalid dt_algo\n"); exit(1); }
}
if (switches.count("-colorspace")) {
string mode = switches["-colorspace"];
if (mode == string("yuv")) { colorspace = PATCHTABLE_COLORSPACE_YUV; }
else if (mode == string("lab")) { colorspace = PATCHTABLE_COLORSPACE_LAB; }
else if (mode == string("rgb")) { convert_colorspace = false; }
else { fprintf(stderr, "unsupported colorspace\n"); exit(1); }
}
if (switches.count("-lookup_algo")) {
string mode = switches["-lookup_algo"];
if (mode == string("table")) { lookup_algo = LOOKUP_ALGO_TABLE; }
else if (mode == string("brute")) { lookup_algo = LOOKUP_ALGO_BRUTE; }
else if (mode == string("kdtree")) { lookup_algo = LOOKUP_ALGO_KDTREE; }
else if (mode == string("pm")) { lookup_algo = LOOKUP_ALGO_PM; }
else if (mode == string("treecann")) { lookup_algo = LOOKUP_ALGO_TREECANN; }
else { fprintf(stderr, "unsupported lookup_algo\n"); exit(1); }
}
if (switches.count("-kcoherence_algo")) {
string mode = switches["-kcoherence_algo"];
if (mode == string("flann")) { kcoherence_algo = KCOHERENCE_ALGO_FLANN; }
else if (mode == string("pm")) { kcoherence_algo = KCOHERENCE_ALGO_PM; }
else if (mode == string("ann")) { kcoherence_algo = KCOHERENCE_ALGO_ANN; }
else if (mode == string("treecann")) { kcoherence_algo = KCOHERENCE_ALGO_TREECANN; }
else { fprintf(stderr, "unsupported lookup_algo\n"); exit(1); }
}
if (switches.count("-dim_algo")) {
string mode = switches["-dim_algo"];
if (mode == string("pca")) { dim_algo = TABLE_DIM_ALGO_PCA; }
else if (mode == string("wh")) { dim_algo = TABLE_DIM_ALGO_WH; }
else { fprintf(stderr, "unsupported dim_algo\n"); exit(1); }
}
if (switches.count("-flann_trees")) { flann_trees = atoi(switches["-flann_trees"].c_str()); }
if (switches.count("-flann_checks")) { flann_checks = atoi(switches["-flann_checks"].c_str()); }
if (switches.count("-flann_build_step")) { flann_build_step = atoi(switches["-flann_build_step"].c_str()); }
if (switches.count("-flann_eps")) { flann_eps = atof(switches["-flann_eps"].c_str()); }
if (switches.count("-treecann_eps")) { treecann_eps = atof(switches["-treecann_eps"].c_str()); }
if (switches.count("-flann_reset_step")) { flann_reset_step = atoi(switches["-flann_reset_step"].c_str()); }
if (switches.count("-query_iters")) { query_iters = atoi(switches["-query_iters"].c_str()); }
if (switches.count("-compare")) { compare = switches["-compare"].c_str(); }
if (switches.count("-treecann_agrid")) { treecann_agrid = atoi(switches["-treecann_agrid"].c_str()); }
if (switches.count("-treecann_bgrid")) { treecann_bgrid = atoi(switches["-treecann_bgrid"].c_str()); }
if (switches.count("-kcoherence")) { kcoherence = atoi(switches["-kcoherence"].c_str()); }
if (switches.count("-kcoherence_iter")) { kcoherence_iter = atoi(switches["-kcoherence_iter"].c_str()); }
if (switches.count("-kcoherence_min_dist")) { kcoherence_min_dist = atoi(switches["-kcoherence_min_dist"].c_str()); }
if (switches.count("-kcoherence_step")) { kcoherence_step = atoi(switches["-kcoherence_step"].c_str()); }
if (switches.count("-kcoherence_enrich")) { kcoherence_enrich = atoi(switches["-kcoherence_enrich"].c_str()); }
if (switches.count("-incoherence")) { incoherence = bool(atoi(switches["-incoherence"].c_str())); }
if (switches.count("-incoherence_min_dist")) { incoherence_min_dist = atoi(switches["-incoherence_min_dist"].c_str()); }
if (switches.count("-save_kcoherence")) { save_kcoherence = bool(atoi(switches["-save_kcoherence"].c_str())); }
if (switches.count("-triangle_factor")) { triangle_factor = atof(switches["-triangle_factor"].c_str()); }
if (switches.count("-init_random")) { init_random = bool(atoi(switches["-init_random"].c_str())); }
if (switches.count("-pm_iters")) { pm_iters = atoi(switches["-pm_iters"].c_str()); }
if (switches.count("-pm_enrich")) { pm_enrich = bool(atoi(switches["-pm_enrich"].c_str())); }
if (switches.count("-sanitize_input")) { sanitize_input = bool(atoi(switches["-sanitize_input"].c_str())); }
if (switches.count("-do_table_lookup")) { do_table_lookup = bool(atoi(switches["-do_table_lookup"].c_str())); }
#if TABLE_PRODUCT_QUANTIZE
if (switches.count("-product_quantize")) { product_quantize = bool(atoi(switches["-product_quantize"].c_str())); }
if (switches.count("-product_quantize_log")) { product_quantize_log = bool(atoi(switches["-product_quantize_log"].c_str())); }
if (switches.count("-product_quantize_dt_all")) { product_quantize_dt_all = bool(atoi(switches["-product_quantize_dt_all"].c_str())); }
if (switches.count("-product_quantize_dims")) { product_quantize_dims = atoi(switches["-product_quantize_dims"].c_str()); }
if (switches.count("-product_quantize_mapn")) { product_quantize_mapn = atoi(switches["-product_quantize_mapn"].c_str()); }
if (switches.count("-product_quantize_knn")) { product_quantize_knn = atoi(switches["-product_quantize_knn"].c_str()); }
#endif
#if (TABLE_CLUSTER_KMEANS||TABLE_PRODUCT_QUANTIZE)
if (switches.count("-kmeans_attempts")) { kmeans_attempts = atoi(switches["-kmeans_attempts"].c_str()); }
if (switches.count("-kmeans_max_iters")) { kmeans_max_iters = atoi(switches["-kmeans_max_iters"].c_str()); }
if (switches.count("-kmeans_eps")) { kmeans_eps = atof(switches["-kmeans_eps"].c_str()); }
#endif
if (switches.count("-grid_ndims")) { grid_ndims = atoi(switches["-grid_ndims"].c_str()); }
if (switches.count("-table_ratio")) { table_ratio = atof(switches["-table_ratio"].c_str()); }
if (switches.count("-prop_dist")) { prop_dist = atoi(switches["-prop_dist"].c_str()); }
if (switches.count("-kdtree_add_unique")) { kdtree_add_unique = bool(atoi(switches["-kdtree_add_unique"].c_str())); }
if (switches.count("-filter_dims")) {
vector<string> nL = str_split(switches["-filter_dims"], ',');
ndims = nL.size();
filter_dims.resize(ndims);
for (int i = 0; i < (int) nL.size(); i++) {
filter_dims[i] = atoi(nL[i].c_str());
}
}
if (switches.count("-auto_filter")) {
auto_filter = bool(atoi(switches["-auto_filter"].c_str()));
}
if (auto_filter) {
if (ndims == 6 ) { filter_dims = vector<int>({2,1,5,0,3,10}); }
else if (ndims == 7 ) { filter_dims = vector<int>({5,1,3,10,0,6,2}); }
else if (ndims == 8 ) { filter_dims = vector<int>({2,1,6,3,0,5,19,10}); }
else if (ndims == 10) { filter_dims = vector<int>({2,6,19,10,3,0,1,15,5,13}); }
else if (ndims == 11) { filter_dims = vector<int>({13,19,6,1,3,30,10,0,5,28,2}); }
else { fprintf(stderr, "auto_filter -ndims not supported: %d\n", ndims); ASSERT2(false, "ndims not supported"); }
}
}
int
main (int argc, char **argv)
{
struct jpeg_decompress_struct cinfo;
struct jpeg_error_mgr jerr;
#ifdef PROGRESS_REPORT
struct cdjpeg_progress_mgr progress;
#endif
int file_index;
djpeg_dest_ptr dest_mgr = NULL;
FILE * input_file;
FILE * output_file;
unsigned char *inbuffer = NULL;
unsigned long insize = 0;
JDIMENSION num_scanlines;
/* On Mac, fetch a command line. */
#ifdef USE_CCOMMAND
argc = ccommand(&argv);
#endif
progname = argv[0];
if (progname == NULL || progname[0] == 0)
progname = "djpeg"; /* in case C library doesn't provide it */
/* Initialize the JPEG decompression object with default error handling. */
cinfo.err = jpeg_std_error(&jerr);
jpeg_create_decompress(&cinfo);
/* Add some application-specific error messages (from cderror.h) */
jerr.addon_message_table = cdjpeg_message_table;
jerr.first_addon_message = JMSG_FIRSTADDONCODE;
jerr.last_addon_message = JMSG_LASTADDONCODE;
/* Insert custom marker processor for COM and APP12.
* APP12 is used by some digital camera makers for textual info,
* so we provide the ability to display it as text.
* If you like, additional APPn marker types can be selected for display,
* but don't try to override APP0 or APP14 this way (see libjpeg.txt).
*/
jpeg_set_marker_processor(&cinfo, JPEG_COM, print_text_marker);
jpeg_set_marker_processor(&cinfo, JPEG_APP0+12, print_text_marker);
/* Scan command line to find file names. */
/* It is convenient to use just one switch-parsing routine, but the switch
* values read here are ignored; we will rescan the switches after opening
* the input file.
* (Exception: tracing level set here controls verbosity for COM markers
* found during jpeg_read_header...)
*/
file_index = parse_switches(&cinfo, argc, argv, 0, FALSE);
#ifdef TWO_FILE_COMMANDLINE
/* Must have either -outfile switch or explicit output file name */
if (outfilename == NULL) {
if (file_index != argc-2) {
fprintf(stderr, "%s: must name one input and one output file\n",
progname);
usage();
}
outfilename = argv[file_index+1];
} else {
if (file_index != argc-1) {
fprintf(stderr, "%s: must name one input and one output file\n",
progname);
usage();
}
}
#else
/* Unix style: expect zero or one file name */
if (file_index < argc-1) {
fprintf(stderr, "%s: only one input file\n", progname);
usage();
}
#endif /* TWO_FILE_COMMANDLINE */
/* Open the input file. */
if (file_index < argc) {
if ((input_file = fopen(argv[file_index], READ_BINARY)) == NULL) {
fprintf(stderr, "%s: can't open %s\n", progname, argv[file_index]);
exit(EXIT_FAILURE);
}
} else {
/* default input file is stdin */
input_file = read_stdin();
}
/* Open the output file. */
if (outfilename != NULL) {
if ((output_file = fopen(outfilename, WRITE_BINARY)) == NULL) {
fprintf(stderr, "%s: can't open %s\n", progname, outfilename);
exit(EXIT_FAILURE);
}
} else {
/* default output file is stdout */
output_file = write_stdout();
}
#ifdef PROGRESS_REPORT
start_progress_monitor((j_common_ptr) &cinfo, &progress);
#endif
/* Specify data source for decompression */
#if JPEG_LIB_VERSION >= 80 || defined(MEM_SRCDST_SUPPORTED)
if (memsrc) {
size_t nbytes;
do {
inbuffer = (unsigned char *)realloc(inbuffer, insize + INPUT_BUF_SIZE);
if (inbuffer == NULL) {
fprintf(stderr, "%s: memory allocation failure\n", progname);
exit(EXIT_FAILURE);
}
nbytes = JFREAD(input_file, &inbuffer[insize], INPUT_BUF_SIZE);
if (nbytes < INPUT_BUF_SIZE && ferror(input_file)) {
if (file_index < argc)
fprintf(stderr, "%s: can't read from %s\n", progname,
argv[file_index]);
else
fprintf(stderr, "%s: can't read from stdin\n", progname);
}
insize += (unsigned long)nbytes;
} while (nbytes == INPUT_BUF_SIZE);
fprintf(stderr, "Compressed size: %lu bytes\n", insize);
jpeg_mem_src(&cinfo, inbuffer, insize);
} else
#endif
jpeg_stdio_src(&cinfo, input_file);
/* Read file header, set default decompression parameters */
(void) jpeg_read_header(&cinfo, TRUE);
/* Adjust default decompression parameters by re-parsing the options */
file_index = parse_switches(&cinfo, argc, argv, 0, TRUE);
/* Initialize the output module now to let it override any crucial
* option settings (for instance, GIF wants to force color quantization).
*/
switch (requested_fmt) {
#ifdef BMP_SUPPORTED
case FMT_BMP:
dest_mgr = jinit_write_bmp(&cinfo, FALSE);
break;
case FMT_OS2:
dest_mgr = jinit_write_bmp(&cinfo, TRUE);
break;
#endif
#ifdef GIF_SUPPORTED
case FMT_GIF:
dest_mgr = jinit_write_gif(&cinfo);
break;
#endif
#ifdef PPM_SUPPORTED
case FMT_PPM:
dest_mgr = jinit_write_ppm(&cinfo);
break;
#endif
#ifdef RLE_SUPPORTED
case FMT_RLE:
dest_mgr = jinit_write_rle(&cinfo);
break;
#endif
#ifdef TARGA_SUPPORTED
case FMT_TARGA:
dest_mgr = jinit_write_targa(&cinfo);
break;
#endif
default:
ERREXIT(&cinfo, JERR_UNSUPPORTED_FORMAT);
break;
}
dest_mgr->output_file = output_file;
/* Start decompressor */
(void) jpeg_start_decompress(&cinfo);
/* Strip decode */
if (strip || skip) {
JDIMENSION tmp;
/* Check for valid endY. We cannot check this value until after
* jpeg_start_decompress() is called. Note that we have already verified
* that startY <= endY.
*/
if (endY > cinfo.output_height - 1) {
fprintf(stderr, "%s: strip %d-%d exceeds image height %d\n", progname,
startY, endY, cinfo.output_height);
exit(EXIT_FAILURE);
}
/* Write output file header. This is a hack to ensure that the destination
* manager creates an image of the proper size for the partial decode.
*/
tmp = cinfo.output_height;
cinfo.output_height = endY - startY + 1;
if (skip)
cinfo.output_height = tmp - cinfo.output_height;
(*dest_mgr->start_output) (&cinfo, dest_mgr);
cinfo.output_height = tmp;
/* Process data */
if (skip) {
while (cinfo.output_scanline < startY) {
num_scanlines = jpeg_read_scanlines(&cinfo, dest_mgr->buffer,
dest_mgr->buffer_height);
(*dest_mgr->put_pixel_rows) (&cinfo, dest_mgr, num_scanlines);
}
jpeg_skip_scanlines(&cinfo, endY - startY + 1);
while (cinfo.output_scanline < cinfo.output_height) {
num_scanlines = jpeg_read_scanlines(&cinfo, dest_mgr->buffer,
dest_mgr->buffer_height);
(*dest_mgr->put_pixel_rows) (&cinfo, dest_mgr, num_scanlines);
}
} else {
jpeg_skip_scanlines(&cinfo, startY);
while (cinfo.output_scanline <= endY) {
num_scanlines = jpeg_read_scanlines(&cinfo, dest_mgr->buffer,
dest_mgr->buffer_height);
(*dest_mgr->put_pixel_rows) (&cinfo, dest_mgr, num_scanlines);
}
jpeg_skip_scanlines(&cinfo, cinfo.output_height - endY + 1);
}
/* Normal full image decode */
} else {
/* Write output file header */
(*dest_mgr->start_output) (&cinfo, dest_mgr);
/* Process data */
while (cinfo.output_scanline < cinfo.output_height) {
num_scanlines = jpeg_read_scanlines(&cinfo, dest_mgr->buffer,
dest_mgr->buffer_height);
(*dest_mgr->put_pixel_rows) (&cinfo, dest_mgr, num_scanlines);
}
}
#ifdef PROGRESS_REPORT
/* Hack: count final pass as done in case finish_output does an extra pass.
* The library won't have updated completed_passes.
*/
progress.pub.completed_passes = progress.pub.total_passes;
#endif
/* Finish decompression and release memory.
* I must do it in this order because output module has allocated memory
* of lifespan JPOOL_IMAGE; it needs to finish before releasing memory.
*/
(*dest_mgr->finish_output) (&cinfo, dest_mgr);
(void) jpeg_finish_decompress(&cinfo);
jpeg_destroy_decompress(&cinfo);
/* Close files, if we opened them */
if (input_file != stdin)
fclose(input_file);
if (output_file != stdout)
fclose(output_file);
#ifdef PROGRESS_REPORT
end_progress_monitor((j_common_ptr) &cinfo);
#endif
if (memsrc && inbuffer != NULL)
free(inbuffer);
/* All done. */
exit(jerr.num_warnings ? EXIT_WARNING : EXIT_SUCCESS);
return 0; /* suppress no-return-value warnings */
}
