DistillerStatus gjpg_passthrough(DistillerInput *din, DistillerOutput *dout)
{
strcpy(dout->mimeType, din->mimeType);
SetDataLength(dout,DataLength(din));
SetData(dout, DataPtr(din));
DataNeedsFree(dout,gm_False);
return distOk;
}
//============================================================================
// Asyncload will queue up a buffer for loading in our loading list the first time it is called.
// It will load in "length" number of bytes, if length is non zero. If length is zero the entire file will be loaded
// When called subsequent times it will check to see if the data has been loaded.
// Returns kPending while still loading the file. Returns kSuccess when the data has been loaded.
// While a file is loading(fLoading == true, and fLoaded == false) a buffer, no paremeters of the buffer should be modified.
plSoundBuffer::ELoadReturnVal plSoundBuffer::AsyncLoad(plAudioFileReader::StreamType type, unsigned length /* = 0 */ )
{
if(!gLoaderThread.IsRunning())
return kError; // we cannot load the data since the load thread is no longer running
if(!fLoading && !fLoaded)
{
fAsyncLoadLength = length;
fStreamType = type;
if(fData == nil )
{
fData = new uint8_t[ fAsyncLoadLength ? fAsyncLoadLength : fDataLength ];
if( fData == nil )
return kError;
}
gLoaderThread.AddBuffer(this);
fLoading = true;
}
if(fLoaded)
{
if(fLoading) // ensures we only do this stuff one time
{
ELoadReturnVal retVal = kSuccess;
if(fError)
{
retVal = kError;
fError = false;
}
if(fReader)
{
fHeader = fReader->GetHeader();
SetDataLength(fReader->GetDataSize());
}
fFlags &= ~kIsExternal;
fLoading = false;
return retVal;
}
return kSuccess;
}
return kPending;
}
int
main(int argc, char *argv[])
{
DistillerStatus st;
UINT32 len;
int i;
char nextfile[MAX_FILENAME];
char logFile[MAX_FILENAME];
char *timeStr;
TestRun runs[MAX_TESTRUNS];
FILE *f;
time_t t;
int numRuns;
int repeatCount;
DistillerInput in;
DistillerOutput out;
C_DistillerType distType;
sprintf(distType.string, "test " INPUT_MIME_TYPE);
if (argc < 3) {
usage();
exit(1);
}
if (!(numRuns = readInputFile(argv[1],runs))) {
fprintf(stderr, "Error reading input file %s.\n", argv[1]);
exit(1);
}
repeatCount = atoi(argv[2]);
if (repeatCount <=0) {
fprintf(stderr, "Invaild count value.\n");
exit(1);
}
if ((st = DistillerInit(distType, 0, NULL)) != distOk) {
fprintf(stderr, "DistillerInit failed: error %d\n", (int)st);
exit(1);
}
sprintf(logFile,"harness.log");
t = time(NULL);
timeStr = ctime(&t);
printf("%s\n",logFile);
if ((f = fopen(logFile, "a")) == NULL) {
fprintf(stderr, "Can't open log file %s\n", logFile);
return 0;
}
SetMimeType(&in, INPUT_MIME_TYPE);
for (i=0;i<numRuns;i++) {
int fd;
int count;
int ii;
fprintf(stdout,"Test run for case %s:\n",runs[i].inputFileName);
fprintf(f,"Test run for case %s:\n",runs[i].inputFileName);
printArguments(f,*(runs[i].argList));
fd = open(runs[i].inputFileName, O_RDONLY);
if (fd == -1) {
fprintf(stderr, "Can't read %s, skipping\n", runs[i].inputFileName);
fprintf(f, "Can't read %s, skipping\n", runs[i].inputFileName);
continue;
}
for (len = 0;
(count = read(fd, (void*)(buf+len), (sizeof(buf)-len))) > 0;
len += count)
;
fprintf(stderr, "Read %lu bytes from %s\n", len, runs[i].inputFileName);
fprintf(f, "Read %lu bytes from %s\n", len, runs[i].inputFileName);
SetData(&in, (void *)buf);
SetDataLength(&in, len);
SetMetadata(&in, NULL);
SetMetadataLength(&in, 0);
for (ii= 0; ii<repeatCount; ii++) {
fprintf(stderr,"Calling distiller main\n");
fprintf(f,"Calling distiller main\n");
/* Distiller status */
st = DistillerMain(runs[i].argList->arg,runs[i].argList->nargs,&in,&out);
if (st != distOk) {
fprintf(stderr, "DistillerMain failed: error %d\n", (int)st);
fprintf(f, "DistillerMain failed: error %d\n", (int)st);
}
close(fd);
strcpy(nextfile,runs[i].inputFileName);
strcat(nextfile, ".OUT");
fd = open(nextfile, O_CREAT | O_WRONLY | O_TRUNC, 0666);
if (fd == -1) {
fprintf(stderr, "Can't write %s, using stdout\n", nextfile);
fprintf(f, "Can't write %s, using stdout\n", nextfile);
fd = fileno(stdout);
}
len = write(fd, (const void *)DataPtr(&out), (size_t)(DataLength(&out)));
if (fd != fileno(stdout))
close(fd);
fprintf(stderr, "Wrote %lu of %lu bytes to %s\n", len, DataLength(&out), nextfile);
fprintf(f, "Wrote %lu of %lu bytes to %s\n", len, DataLength(&out), nextfile);
if (out.data.freeMe == gm_True)
DistillerFree(DataPtr(&out));
if (out.metadata.freeMe == gm_True)
DistillerFree(MetadataPtr(&out));
}
}
fclose(f);
return(1);
}
int
main(int argc, char *argv[])
{
DistillerStatus st;
UINT32 len;
Argument args[12];
int nargs = 0;
int i;
char *k;
FILE *f;
char nextfile[255];
DistillerInput in;
DistillerOutput out;
C_DistillerType distType;
sprintf(distType.string, "test " INPUT_MIME_TYPE);
if ((argc < 2) || (argc >= 2 && strncmp(argv[1], "-h", 2) == 0)) {
usage();
exit(1);
}
if ((f = fopen(argv[1], "r")) == NULL) {
fprintf(stderr, "Can't open input file %s\n", argv[1]);
exit(1);
}
for (i=2; i<argc-1; i += 2, nargs++) {
SET_ARG_ID(args[nargs], strtoul(&argv[i][1], (char**)NULL, 0));
switch (argv[i][0]) {
case 'i':
SET_ARG_INT(args[nargs], strtol(argv[i+1], (char**)NULL, 0));
fprintf(stderr, "Arg id %lu is %ld\n", ARG_ID(args[nargs]),
ARG_INT(args[nargs]));
break;
case 'f':
SET_ARG_DOUBLE(args[nargs], strtod(argv[i+1], (char**)NULL));
fprintf(stderr, "Arg id %lu is %f\n", ARG_ID(args[nargs]),
(float)ARG_DOUBLE(args[nargs]));
break;
case 's':
default:
SET_ARG_STRING(args[nargs], argv[i+1]);
fprintf(stderr, "Arg id %lu is \"%s\"\n", ARG_ID(args[nargs]),
ARG_STRING(args[nargs]));
}
}
if ((st = DistillerInit(distType, 0, NULL)) != distOk) {
fprintf(stderr, "DistillerInit failed: error %d\n", (int)st);
exit(1);
}
SetMimeType(&in, INPUT_MIME_TYPE);
while (fgets(nextfile, 254, f) != NULL) {
char nextfile2[255];
int fd;
int count;
int ii;
nextfile[strlen(nextfile)-1] = 0;
fd = open(nextfile, O_RDONLY);
if (fd == -1) {
fprintf(stderr, "Can't read %s, skipping\n", nextfile);
continue;
}
for (len = 0;
(count = read(fd, (void*)(buf+len), (sizeof(buf)-len))) > 0;
len += count)
;
fprintf(stderr, "Read %lu bytes from %s\n", len, nextfile);
SetData(&in, (void *)buf);
SetDataLength(&in, len);
SetMetadata(&in, NULL);
SetMetadataLength(&in, 0);
for (ii= 0; ii<REPEAT_COUNT; ii++) {
fprintf(stderr,"Calling distiller main\n");
st = DistillerMain(args,nargs,&in,&out);
if (st != distOk) {
fprintf(stderr, "DistillerMain failed: error %d\n", (int)st);
}
close(fd);
strcpy(nextfile2, argv[argc-1]);
if (nextfile2[strlen(nextfile2)-1] != '/')
strcat(nextfile2,"/");
k = strrchr(nextfile, '/');
if (k)
strcat(nextfile2, k+1);
else
strcat(nextfile2, nextfile);
strcat(nextfile2, ".OUT");
fd = open(nextfile2, O_CREAT | O_WRONLY | O_TRUNC, 0666);
if (fd == -1) {
fprintf(stderr, "Can't write %s, using stdout\n", nextfile2);
fd = fileno(stdout);
}
len = write(fd, (const void *)DataPtr(&out), (size_t)(DataLength(&out)));
if (fd != fileno(stdout))
close(fd);
fprintf(stderr, "Wrote %lu of %lu bytes to %s\n", len, DataLength(&out), nextfile2);
if (out.data.freeMe == gm_True)
DistillerFree(DataPtr(&out));
if (out.metadata.freeMe == gm_True)
DistillerFree(MetadataPtr(&out));
}
}
return(1);
}
DistillerStatus
DistillerMain(Argument *args, int nargs,
DistillerInput *din,
DistillerOutput *dout)
{
JSAMPROW handoff = NULL;
JDIMENSION handoff_height, handoff_width, num_scanlines;
int max_x=-1, max_y=-1, min_x=-1, min_y=-1, qual=55, i;
int expert=0, resize=0, quality=3, nodistill=0, ismap=0;
double scale = 0.5;
cjpeg_source_ptr src_mgr;
void *phase1_data;
INT32 phase1_length;
int fin_denom, fin_qual;
DistillerStatus result = distBadInput;
SetData(dout, NULL);
bailout_now = 0;
if ( (setjmp(jumpbuffer) != 0) ) {
/*
* fatal error occurred, so return immediately.
*/
MonitorClientSend(monID, "Distiller Errors",
"Resetting distiller...\n", "Log");
DistillerExit();
DistillerInit(dType, 0, NULL);
if (DataPtr(dout) != NULL)
DataNeedsFree(dout,gm_True);
else
DataNeedsFree(dout,gm_False);
return distFatalError;
}
/*
* parse distillation arguments. set default values for some
* things, then override them if args are specified. Default will
* be to scale each axis by 0.5, turn quality down to 55%.
*/
for (i=0; i<nargs; i++) {
INT32 argval = ARG_INT(args[i]);
switch(ARG_ID(args[i])) {
case GJPG_MAX_X:
max_x = (int) argval;
break;
case GJPG_MAX_Y:
max_y = (int) argval;
break;
case GJPG_MIN_X:
min_x = (int) argval;
break;
case GJPG_MIN_Y:
min_y = (int) argval;
break;
case GJPG_SCALE:
scale = (double) ARG_DOUBLE(args[i]);
break;
case GJPG_QUAL:
qual = (int) argval;
break;
case FRONT_RESIZE:
resize = (int) argval;
break;
case FRONT_NO_DISTILL:
nodistill = (int) argval;
break;
case FRONT_QUALITY:
if (argval >= 1 && argval <= 5)
quality = (int) argval;
break;
case FRONT_EXPERT:
expert = (int) argval;
break;
case FRONT_ISMAP:
ismap = (int) argval;
break;
default:
break;
}
}
if (nodistill) {
return gjpg_passthrough(din, dout);
}
/* First pass through, we're just going to convert the GIF to JPEG */
phase1_data = NULL;
phase1_length = 0;
dstinfo.in_color_space = JCS_RGB;
jpeg_set_defaults(&dstinfo);
src_mgr = jinit_read_gif(&dstinfo, (JOCTET *) DataPtr(din),
(INT32) DataLength(din));
(*src_mgr->start_input)(&dstinfo, src_mgr);
jpeg_default_colorspace(&dstinfo);
jpeg_mem_dest(&dstinfo, (void **) &phase1_data, (UINT32 *) &phase1_length);
jpeg_start_compress(&dstinfo, TRUE);
while (dstinfo.next_scanline < dstinfo.image_height) {
num_scanlines = (*src_mgr->get_pixel_rows)(&dstinfo, src_mgr);
jpeg_write_scanlines(&dstinfo, src_mgr->buffer, num_scanlines);
}
(*src_mgr->finish_input)(&dstinfo, src_mgr);
jpeg_finish_compress(&dstinfo);
/* early bailout because of animated or transparent gif? */
if (bailout_now
&& DataLength(din) <= bailout_thresh[quality]) {
result = distBadInput;
goto JPGMUNGE_RETURN;
}
/* Now we're into the second pass. Let's do our JPEG->JPEG
* distillation. We need to compute the denominator and the quality
* knob setting. */
if (expert) {
/* Do expert-like things here. Need to work out still. */
fin_qual = qual;
fin_denom = compute_scale_denom(max_x, max_y, min_x, min_y,
srcinfo.image_width,
srcinfo.image_height, scale);
} else {
/* We're in beginner mode. Life is easier. */
if (ismap) {
fin_qual = ismap_qual[quality-1];
fin_denom = ismap_denom[quality-1];
} else if (resize) {
fin_qual = noscale_qual[quality-1];
fin_denom = noscale_denom[quality-1];
} else {
fin_qual = norm_qual[quality-1];
fin_denom = norm_denom[quality-1];
}
}
/* Prep the input decompressor */
jpeg_mem_src(&srcinfo, phase1_data, phase1_length);
jpeg_read_header(&srcinfo, TRUE);
srcinfo.scale_num = 1;
srcinfo.scale_denom = fin_denom;
srcinfo.dither_mode = JDITHER_ORDERED;
srcinfo.dct_method = JDCT_FASTEST;
jpeg_start_decompress(&srcinfo);
/* Prep the output compressor */
SetDataLength(dout,0);
SetData(dout, NULL);
sprintf(dout->mimeType, "image/jpeg");
jpeg_mem_dest(&dstinfo, (void **) &(DataPtr(dout)),
(UINT32 *) &(DataLength(dout)));
dstinfo.image_width = srcinfo.output_width;
dstinfo.image_height = srcinfo.output_height;
dstinfo.input_components = srcinfo.output_components;
dstinfo.in_color_space = srcinfo.out_color_space;
jpeg_set_defaults(&dstinfo);
jpeg_set_quality(&dstinfo, fin_qual, TRUE);
jpeg_start_compress(&dstinfo, TRUE);
handoff_height = (JDIMENSION) 1;
handoff_width =
srcinfo.output_width*sizeof(JSAMPLE)*srcinfo.output_components;
handoff = (JSAMPROW) malloc(handoff_width);
/* We're going to need some buffer space to hand off data
from the decompressor to the compressor. */
while (srcinfo.output_scanline < srcinfo.output_height) {
num_scanlines = jpeg_read_scanlines(&srcinfo, &handoff, handoff_height);
jpeg_write_scanlines(&dstinfo, &handoff, num_scanlines);
}
jpeg_finish_decompress(&srcinfo);
jpeg_finish_compress(&dstinfo);
result = distOk;
JPGMUNGE_RETURN:
if (handoff)
free(handoff);
DataNeedsFree(dout,gm_True);
if (phase1_data)
free(phase1_data);
if (DataLength(dout) > DataLength(din)) {
SetDataLength(dout, DataLength(din));
memcpy(DataPtr(dout), DataPtr(din), DataLength(din));
sprintf(dout->mimeType, "image/gif");
}
DEBUG("finished processing\n");
return result;
}
