/* stdio functions */ static int GSDLLCALL gsdll_stdin(void *instance, char *buf, int len) { int c; int count = 0; char *init=buf; int eof; int hlen=len; eof=yylex(buf,&hlen); // fprintf(stderr, "eof %d\n",eof); if(eof==1001){ fprintf(color_fd,"%s",buf); fflush(color_fd); fprintf(black_fd,"%s",buf); fflush(black_fd); return (strlen(buf)); } else if(eof==1000){ fprintf(temp_fd,"%s",buf); fflush(temp_fd); fclose(temp_fd); read_fd=gp_fopen("temp.ps","rb"); // fprintf(stderr, "Seitenende %d %d %s\n",hlen,strlen(buf),buf); while( (c=fgetc(read_fd)) != EOF) { fputc(c,choose); } // fprintf(stderr, "Seitenende ende %d %d %s\n",hlen,strlen(buf),buf); fflush(choose); fclose(read_fd); temp_fd=gp_fopen("temp.ps","wb"); return (strlen(buf)); } else if(eof!=0){ // fprintf(stderr, "Mittendrin %s\n",buf); fprintf(temp_fd,"%s",buf); fflush(temp_fd); return (strlen(buf)); } else { fprintf(stderr, "Dateiende\n"); read_fd=gp_fopen("temp.ps","rb"); while( (c=fgetc(read_fd)) != EOF) { fputc(c,choose); } fflush(choose); fclose(read_fd); fclose(temp_fd); temp_fd=gp_fopen("temp.ps","wb"); return 0; } }
int main(int argc, char *argv[]) { int code; const char * gsargv[12]; char arg[64]; int gsargc; gsargv[0] = "ps2colordetect"; /* actual value doesn't matter */ gsargv[1] = "-dNOPAUSE"; gsargv[2] = "-dBATCH"; gsargv[3] = "-dSAFER"; // gsargv[4] = "-sDEVICE=pdfwrite"; gsargv[4] = "-sDEVICE=display"; gsargv[5] = "-dDisplayHandle=0"; sprintf(arg,"-dDisplayFormat=%d",DISPLAY_COLORS_RGB|DISPLAY_ALPHA_NONE|DISPLAY_DEPTH_8|DISPLAY_LITTLEENDIAN|DISPLAY_BOTTOMFIRST); gsargv[6] = arg; gsargv[7] = "-sOutputFile=out.pdf"; gsargv[8] = "-c"; gsargv[9] = ".setpdfwrite"; gsargv[10] = "-f"; // gsargv[11] = "input.ps"; gsargv[11] = "-"; gsargc=12; code = gsapi_new_instance(&minst, NULL); if (code < 0) return 1; gsapi_set_stdio(minst, gsdll_stdin, gsdll_stdout, gsdll_stderr); gsapi_set_display_callback(minst, &display); color_fd=gp_fopen("color.ps","wb"); black_fd=gp_fopen("black.ps","wb"); temp_fd=gp_fopen("temp.ps","wb"); choose=black_fd; code = gsapi_init_with_args(minst, gsargc, gsargv); gsapi_exit(minst); gsapi_delete_instance(minst); fclose(color_fd); fclose(black_fd); fclose(temp_fd); if ((code == 0) || (code == gs_error_Quit)) return 0; return 1; }
FILE * gp_open_printer (const gs_memory_t *mem, char *fname, int binary_mode) { if (strlen(fname) == 0) return gp_open_scratch_file(mem, gp_scratch_file_name_prefix, fname, binary_mode ? "wb" : "w"); else return gp_fopen(fname, binary_mode ? "wb" : "b"); }
FILE * gp_open_printer(const gs_memory_t *mem, char fname[gp_file_name_sizeof], int binary_mode) { if (strlen(fname) == 0 || !strcmp(fname, "PRN")) { if (binary_mode) gp_set_file_binary(fileno(stdprn), 1); stdprn->_flag = _IOWRT; /* Make stdprn buffered to improve performance */ return stdprn; } else return gp_fopen(fname, (binary_mode ? "wb" : "w")); }
FILE * gp_open_scratch_file (const gs_memory_t *mem, const char *prefix, char fname[gp_file_name_sizeof], const char *mode) { char thefname[256]; Str255 thepfname; OSErr myErr; short foundVRefNum; long foundDirID; FSSpec fSpec; FILE *f; int prefix_length = strlen(prefix); if (prefix_length > gp_file_name_sizeof) return NULL; strcpy (fname, (char *) prefix); { char newName[50]; tmpnam (newName); if ( prefix_length + strlen(newName) > gp_file_name_sizeof ) return NULL; strcat (fname, newName); } if ( strlen(fname) > 255 ) return NULL; if ( strrchr(fname,':') == NULL ) { memmove((char*)&thepfname[1],(char *)&fname[0],strlen(fname)); thepfname[0]=strlen(fname); myErr = FindFolder(kOnSystemDisk,kTemporaryFolderType,kCreateFolder, &foundVRefNum, &foundDirID); if ( myErr != noErr ) { emprintf(mem, "Can't find temp folder.\n"); return (NULL); } FSMakeFSSpec(foundVRefNum, foundDirID,thepfname, &fSpec); convertSpecToPath(&fSpec, thefname, sizeof(thefname) - 1); sprintf(fname,"%s",thefname); } else { sprintf((char*)&thefname[0],"%s\0",fname); memmove((char*)&thepfname[1],(char *)&thefname[0],strlen(thefname)); thepfname[0]=strlen(thefname); } f = gp_fopen (thefname, mode); if (f == NULL) emprintf1(mem, "**** Could not open temporary file %s\n", fname); return f; }
int clist_fopen(char *fname, const char *fmode, clist_file_ptr *pcf, gs_memory_t *mem, bool ok_to_compress) { if ( *fname == 0 ) { if ( fmode[0] == 'r' ) return_error(gs_error_invalidfileaccess); *pcf = (clist_file_ptr)gp_open_scratch_file(gp_scratch_file_name_prefix, fname, fmode); } else *pcf = gp_fopen(fname, fmode); if ( *pcf == NULL ) { eprintf1("Could not open the scratch file %s.\n", fname); return_error(gs_error_invalidfileaccess); } return 0; }
static int clist_fopen(char fname[gp_file_name_sizeof], const char *fmode, clist_file_ptr * pcf, gs_memory_t * mem, gs_memory_t *data_mem, bool ok_to_compress) { if (*fname == 0) { if (fmode[0] == 'r') return_error(gs_error_invalidfileaccess); if (gp_can_share_fdesc()) { *pcf = (clist_file_ptr)wrap_file(mem, gp_open_scratch_file_rm(mem, gp_scratch_file_name_prefix, fname, fmode), fmode); /* If the platform supports FILE duplication then we overwrite the * file name with an encoded form of the FILE pointer */ file_to_fake_path(*pcf, fname); } else { *pcf = (clist_file_ptr)wrap_file(mem, gp_open_scratch_file_64(mem, gp_scratch_file_name_prefix, fname, fmode), fmode); } } else { // Check if a special path is passed in. If so, clone the FILE handle clist_file_ptr ocf = fake_path_to_file(fname); if (ocf) { *pcf = wrap_file(mem, gp_fdup(((IFILE *)ocf)->f, fmode), fmode); } else { *pcf = wrap_file(mem, gp_fopen(fname, fmode), fmode); } } if (*pcf == NULL) { emprintf1(mem, "Could not open the scratch file %s.\n", fname); return_error(gs_error_invalidfileaccess); } return 0; }
/* Transform an entire buffer */ int gscms_transform_color_buffer(gx_device *dev, gsicc_link_t *icclink, gsicc_bufferdesc_t *input_buff_desc, gsicc_bufferdesc_t *output_buff_desc, void *inputbuffer, void *outputbuffer) { cmsHTRANSFORM hTransform = (cmsHTRANSFORM) icclink->link_handle; DWORD dwInputFormat,dwOutputFormat,curr_input,curr_output; int planar,numbytes,big_endian,hasalpha,k; unsigned char *inputpos, *outputpos; int numchannels; #if DUMP_CMS_BUFFER FILE *fid_in, *fid_out; #endif /* Although little CMS does make assumptions about data types in its transformations you can change it after the fact. */ /* Set us to the proper output type */ /* Note, we could speed this up by passing back the encoded data type to the caller so that we could avoid having to go through this computation each time if they are doing multiple calls to this operation */ _LPcmsTRANSFORM p = (_LPcmsTRANSFORM) (LPSTR) hTransform; curr_input = p->InputFormat; curr_output = p->OutputFormat; /* Color space MUST be the same */ dwInputFormat = COLORSPACE_SH(T_COLORSPACE(curr_input)); dwOutputFormat = COLORSPACE_SH(T_COLORSPACE(curr_output)); /* Now set if we have planar, num bytes, endian case, and alpha data to skip */ /* Planar -- pdf14 case for example */ planar = input_buff_desc->is_planar; dwInputFormat = dwInputFormat | PLANAR_SH(planar); planar = output_buff_desc->is_planar; dwOutputFormat = dwOutputFormat | PLANAR_SH(planar); /* 8 or 16 byte input and output */ numbytes = input_buff_desc->bytes_per_chan; if (numbytes>2) numbytes = 0; /* littleCMS encodes float with 0 ToDO. */ dwInputFormat = dwInputFormat | BYTES_SH(numbytes); numbytes = output_buff_desc->bytes_per_chan; if (numbytes>2) numbytes = 0; dwOutputFormat = dwOutputFormat | BYTES_SH(numbytes); /* endian */ big_endian = !input_buff_desc->little_endian; dwInputFormat = dwInputFormat | ENDIAN16_SH(big_endian); big_endian = !output_buff_desc->little_endian; dwOutputFormat = dwOutputFormat | ENDIAN16_SH(big_endian); /* number of channels */ numchannels = input_buff_desc->num_chan; dwInputFormat = dwInputFormat | CHANNELS_SH(numchannels); numchannels = output_buff_desc->num_chan; dwOutputFormat = dwOutputFormat | CHANNELS_SH(numchannels); /* alpha, which is passed through unmolested */ /* ToDo: Right now we always must have alpha last */ /* This is really only going to be an issue when we have interleaved alpha data */ hasalpha = input_buff_desc->has_alpha; dwInputFormat = dwInputFormat | EXTRA_SH(hasalpha); dwOutputFormat = dwOutputFormat | EXTRA_SH(hasalpha); /* Change the formaters */ cmsChangeBuffersFormat(hTransform,dwInputFormat,dwOutputFormat); /* littleCMS knows nothing about word boundarys. As such, we need to do this row by row adjusting for our stride. Output buffer must already be allocated. ToDo: Check issues with plane and row stride and word boundry */ inputpos = (unsigned char *) inputbuffer; outputpos = (unsigned char *) outputbuffer; if(input_buff_desc->is_planar){ /* Do entire buffer. Care must be taken here with respect to row stride, word boundry and number of source versus output channels. We may need to take a closer look at this. */ cmsDoTransform(hTransform,inputpos,outputpos, input_buff_desc->plane_stride); #if DUMP_CMS_BUFFER fid_in = gp_fopen("CM_Input.raw","ab"); fid_out = fp_fopen("CM_Output.raw","ab"); fwrite((unsigned char*) inputbuffer,sizeof(unsigned char), input_buff_desc->plane_stride * input_buff_desc->num_chan, fid_in); fwrite((unsigned char*) outputbuffer,sizeof(unsigned char), output_buff_desc->plane_stride * output_buff_desc->num_chan, fid_out); fclose(fid_in); fclose(fid_out); #endif } else { /* Do row by row. */ for(k = 0; k < input_buff_desc->num_rows ; k++){ cmsDoTransform(hTransform,inputpos,outputpos, input_buff_desc->pixels_per_row); inputpos += input_buff_desc->row_stride; outputpos += output_buff_desc->row_stride; } #if DUMP_CMS_BUFFER fid_in = gp_fopen("CM_Input.raw","ab"); fid_out = gp_fopen("CM_Output.raw","ab"); fwrite((unsigned char*) inputbuffer,sizeof(unsigned char), input_buff_desc->row_stride,fid_in); fwrite((unsigned char*) outputbuffer,sizeof(unsigned char), output_buff_desc->row_stride,fid_out); fclose(fid_in); fclose(fid_out); #endif } return 0; }
/* Transform an entire buffer */ void gscms_transform_color_buffer(gx_device *dev, gsicc_link_t *icclink, gsicc_bufferdesc_t *input_buff_desc, gsicc_bufferdesc_t *output_buff_desc, void *inputbuffer, void *outputbuffer) { cmsHTRANSFORM hTransform = (cmsHTRANSFORM)icclink->link_handle; cmsUInt32Number dwInputFormat, dwOutputFormat, num_src_lcms, num_des_lcms; int planar,numbytes, big_endian, hasalpha, k; unsigned char *inputpos, *outputpos; #if DUMP_CMS_BUFFER FILE *fid_in, *fid_out; #endif /* Although little CMS does make assumptions about data types in its transformations you can change it after the fact. */ /* Set us to the proper output type */ /* Note, we could speed this up by passing back the encoded data type to the caller so that we could avoid having to go through this computation each time if they are doing multiple calls to this operation */ /* Color space MUST be the same */ dwInputFormat = COLORSPACE_SH(T_COLORSPACE(cmsGetTransformInputFormat(hTransform))); dwOutputFormat = COLORSPACE_SH(T_COLORSPACE(cmsGetTransformOutputFormat(hTransform))); /* Now set if we have planar, num bytes, endian case, and alpha data to skip */ /* Planar -- pdf14 case for example */ planar = input_buff_desc->is_planar; dwInputFormat = dwInputFormat | PLANAR_SH(planar); planar = output_buff_desc->is_planar; dwOutputFormat = dwOutputFormat | PLANAR_SH(planar); /* 8 or 16 byte input and output */ numbytes = input_buff_desc->bytes_per_chan; if (numbytes>2) numbytes = 0; /* littleCMS encodes float with 0 ToDO. */ dwInputFormat = dwInputFormat | BYTES_SH(numbytes); numbytes = output_buff_desc->bytes_per_chan; if (numbytes>2) numbytes = 0; dwOutputFormat = dwOutputFormat | BYTES_SH(numbytes); /* endian */ big_endian = !input_buff_desc->little_endian; dwInputFormat = dwInputFormat | ENDIAN16_SH(big_endian); big_endian = !output_buff_desc->little_endian; dwOutputFormat = dwOutputFormat | ENDIAN16_SH(big_endian); /* number of channels. This should not really be changing! */ num_src_lcms = T_CHANNELS(cmsGetTransformInputFormat(hTransform)); num_des_lcms = T_CHANNELS(cmsGetTransformOutputFormat(hTransform)); if (num_src_lcms != input_buff_desc->num_chan || num_des_lcms != output_buff_desc->num_chan) { /* We can't transform this. Someone is doing something odd */ return; } dwInputFormat = dwInputFormat | CHANNELS_SH(num_src_lcms); dwOutputFormat = dwOutputFormat | CHANNELS_SH(num_des_lcms); /* alpha, which is passed through unmolested */ /* ToDo: Right now we always must have alpha last */ /* This is really only going to be an issue when we have interleaved alpha data */ hasalpha = input_buff_desc->has_alpha; dwInputFormat = dwInputFormat | EXTRA_SH(hasalpha); dwOutputFormat = dwOutputFormat | EXTRA_SH(hasalpha); /* Change the formatters */ cmsChangeBuffersFormat(hTransform,dwInputFormat,dwOutputFormat); /* littleCMS knows nothing about word boundarys. As such, we need to do this row by row adjusting for our stride. Output buffer must already be allocated. ToDo: Check issues with plane and row stride and word boundry */ inputpos = (byte *) inputbuffer; outputpos = (byte *) outputbuffer; if(input_buff_desc->is_planar) { /* Determine if we can do this in one operation or if we have to break it up. Essentially if the width * height = plane_stride then yes. If we are doing some subsection of a plane then no. */ if (input_buff_desc->num_rows * input_buff_desc->pixels_per_row == input_buff_desc->plane_stride && output_buff_desc->num_rows * output_buff_desc->pixels_per_row == output_buff_desc->plane_stride) { /* Do entire buffer.*/ cmsDoTransform(hTransform, inputpos, outputpos, input_buff_desc->plane_stride); } else { /* We have to do this row by row, with memory transfers */ byte *temp_des, *temp_src; int source_size = input_buff_desc->bytes_per_chan * input_buff_desc->pixels_per_row; int des_size = output_buff_desc->bytes_per_chan * output_buff_desc->pixels_per_row; int y, i; temp_src = (byte*) gs_alloc_bytes(icclink->icc_link_cache->memory, source_size * input_buff_desc->num_chan, "gscms_transform_color_buffer"); if (temp_src == NULL) return; temp_des = (byte*) gs_alloc_bytes(icclink->icc_link_cache->memory, des_size * output_buff_desc->num_chan, "gscms_transform_color_buffer"); if (temp_des == NULL) return; for (y = 0; y < input_buff_desc->num_rows; y++) { byte *src_cm = temp_src; byte *src_buff = inputpos; byte *des_cm = temp_des; byte *des_buff = outputpos; /* Put into planar temp buffer */ for (i = 0; i < input_buff_desc->num_chan; i ++) { memcpy(src_cm, src_buff, source_size); src_cm += source_size; src_buff += input_buff_desc->plane_stride; } /* Transform */ cmsDoTransform(hTransform, temp_src, temp_des, input_buff_desc->pixels_per_row); /* Get out of temp planar buffer */ for (i = 0; i < output_buff_desc->num_chan; i ++) { memcpy(des_buff, des_cm, des_size); des_cm += des_size; des_buff += output_buff_desc->plane_stride; } inputpos += input_buff_desc->row_stride; outputpos += output_buff_desc->row_stride; } gs_free_object(icclink->icc_link_cache->memory, temp_src, "gscms_transform_color_buffer"); gs_free_object(icclink->icc_link_cache->memory, temp_des, "gscms_transform_color_buffer"); } } else { /* Do row by row. */ for(k = 0; k < input_buff_desc->num_rows ; k++) { cmsDoTransform(hTransform, inputpos, outputpos, input_buff_desc->pixels_per_row); inputpos += input_buff_desc->row_stride; outputpos += output_buff_desc->row_stride; } } #if DUMP_CMS_BUFFER fid_in = gp_fopen("CM_Input.raw","ab"); fid_out = gp_fopen("CM_Output.raw","ab"); fwrite((unsigned char*) inputbuffer,sizeof(unsigned char), input_buff_desc->row_stride,fid_in); fwrite((unsigned char*) outputbuffer,sizeof(unsigned char), output_buff_desc->row_stride,fid_out); fclose(fid_in); fclose(fid_out); #endif }
FILE * popen (const char * fname, const char * mode ) { return gp_fopen (fname, mode); }