quicktime_t* quicktime_open(char *filename, int rd, int wr)
{
quicktime_t *new_file = calloc(1, sizeof(quicktime_t));
int result = 0;
//printf("quicktime_open 1\n");
quicktime_init(new_file);
new_file->wr = wr;
new_file->rd = rd;
new_file->mdat.atom.start = 0;
result = quicktime_file_open(new_file, filename, rd, wr);
if(!result)
{
if(rd)
{
if(quicktime_read_info(new_file))
{
quicktime_close(new_file);
fprintf(stderr, "quicktime_open: error in header\n");
new_file = 0;
}
}
/* start the data atom */
/* also don't want to do this if making a streamable file */
if(wr)
{
quicktime_set_presave(new_file, 1);
// android requires the ftyp header
const unsigned char ftyp_data[] =
{
0x00, 0x00, 0x00, 0x18, 0x66, 0x74, 0x79, 0x70,
0x6d, 0x70, 0x34, 0x32, 0x00, 0x00, 0x00, 0x01,
0x6d, 0x70, 0x34, 0x32, 0x61, 0x76, 0x63, 0x31
};
quicktime_write_data(new_file, (char*)ftyp_data, sizeof(ftyp_data));
quicktime_atom_write_header64(new_file,
&new_file->mdat.atom,
"mdat");
quicktime_set_presave(new_file, 0);
}
}
else
{
//printf("quicktime_open 10\n");
quicktime_close(new_file);
//printf("quicktime_open 100\n");
new_file = 0;
}
return new_file;
}
int mpeg2enc(int argc, char *argv[])
{
stdin_fd = stdin;
verbose = 1;
/* Read command line */
readcmdline(argc, argv);
/* read quantization matrices */
readquantmat();
if(!strlen(out_path))
{
fprintf(stderr, "No output file given.\n");
}
/* open output file */
if(!(outfile = fopen(out_path, "wb")))
{
sprintf(errortext,"Couldn't create output file %s", out_path);
error(errortext);
}
init();
if(nframes < 0x7fffffff)
printf("Frame Completion Current bitrate Predicted file size\n");
putseq();
stop_slice_engines();
stop_motion_engines();
stop_transform_engines();
stop_itransform_engines();
fclose(outfile);
fclose(statfile);
if(qt_file) quicktime_close(qt_file);
if(qt_output) quicktime_close(qt_output);
if(mpeg_file) mpeg3_close(mpeg_file);
if(do_stdin)
{
fclose(stdin_fd);
}
pthread_mutex_destroy(&input_lock);
pthread_mutex_destroy(&output_lock);
return 0;
}
quicktime_t* quicktime_open(char *filename, int rd, int wr)
{
quicktime_t *new_file = calloc(1, sizeof(quicktime_t));
char flags[10];
int result = 0;
//printf("quicktime_open 1\n");
quicktime_init(new_file);
new_file->wr = wr;
new_file->rd = rd;
new_file->mdat.atom.start = 0;
result = quicktime_file_open(new_file, filename, rd, wr);
if(!result)
{
if(rd)
{
if(quicktime_read_info(new_file))
{
quicktime_close(new_file);
fprintf(stderr, "quicktime_open: error in header\n");
new_file = 0;
}
}
/* start the data atom */
/* also don't want to do this if making a streamable file */
if(wr)
{
quicktime_set_presave(new_file, 1);
quicktime_atom_write_header64(new_file,
&new_file->mdat.atom,
"mdat");
quicktime_set_presave(new_file, 0);
}
}
else
{
//printf("quicktime_open 10\n");
quicktime_close(new_file);
//printf("quicktime_open 100\n");
new_file = 0;
}
return new_file;
}
static void
IDirectFBVideoProvider_OpenQuicktime_Destruct( IDirectFBVideoProvider *thiz )
{
IDirectFBVideoProvider_OpenQuicktime_data *data;
data = (IDirectFBVideoProvider_OpenQuicktime_data*)thiz->priv;
thiz->Stop( thiz );
#ifdef SEGFAULTS_IN_OPENQUICKTIME
quicktime_close( data->file );
#endif
D_FREE( data->video.buffer );
D_FREE( data->rgb.lines );
pthread_mutex_destroy( &data->video.lock );
pthread_mutex_destroy( &data->audio.lock );
D_FREE( data->filename );
D_FREE( thiz->priv );
thiz->priv = NULL;
#ifndef DFB_DEBUG
D_FREE( thiz );
#endif
}
void* trap_interrupt()
{
pthread_mutex_lock(&mutex);
if(!predicate)
{
predicate = 1;
printf("interrupt trapped 1\n");
quicktime_close(output);
printf("interrupt trapped 2\n");
exit(0);
// Can't join any threads in the mpeg library which may have been interrupted
// before unblocking.
// mpeg3_close(input);
}
}
main(int argc, char *argv[])
{
quicktime_t *file;
int result = 0;
if(argc < 2)
{
printf("Dump all tables in movie.\n");
exit(1);
}
if(!(file = quicktime_open(argv[1], 1, 0)))
{
printf("Open failed\n");
exit(1);
}
quicktime_dump(file);
quicktime_close(file);
}
int quicktime_make_streamable(char *in_path, char *out_path)
{
quicktime_t file, *old_file, new_file;
int moov_exists = 0, mdat_exists = 0, result, atoms = 1;
int64_t mdat_start, mdat_size;
quicktime_atom_t leaf_atom;
int64_t moov_length;
quicktime_init(&file);
/* find the moov atom in the old file */
if(!(file.stream = fopen(in_path, "rb")))
{
perror("quicktime_make_streamable");
return 1;
}
file.total_length = quicktime_get_file_length(in_path);
/* get the locations of moov and mdat atoms */
do
{
/*printf("%x\n", quicktime_position(&file)); */
result = quicktime_atom_read_header(&file, &leaf_atom);
if(!result)
{
if(quicktime_atom_is(&leaf_atom, "moov"))
{
moov_exists = atoms;
moov_length = leaf_atom.size;
}
else
if(quicktime_atom_is(&leaf_atom, "mdat"))
{
mdat_start = quicktime_position(&file) - HEADER_LENGTH;
mdat_size = leaf_atom.size;
mdat_exists = atoms;
}
quicktime_atom_skip(&file, &leaf_atom);
atoms++;
}
}while(!result && quicktime_position(&file) < file.total_length);
fclose(file.stream);
if(!moov_exists)
{
printf("quicktime_make_streamable: no moov atom\n");
return 1;
}
if(!mdat_exists)
{
printf("quicktime_make_streamable: no mdat atom\n");
return 1;
}
/* copy the old file to the new file */
if(moov_exists && mdat_exists)
{
/* moov wasn't the first atom */
if(moov_exists > 1)
{
char *buffer;
int64_t buf_size = 1000000;
result = 0;
/* read the header proper */
if(!(old_file = quicktime_open(in_path, 1, 0)))
{
return 1;
}
quicktime_shift_offsets(&(old_file->moov), moov_length);
/* open the output file */
if(!(new_file.stream = fopen(out_path, "wb")))
{
perror("quicktime_make_streamable");
result = 1;
}
else
{
/* set up some flags */
new_file.wr = 1;
new_file.rd = 0;
quicktime_write_moov(&new_file, &(old_file->moov));
quicktime_set_position(old_file, mdat_start);
if(!(buffer = calloc(1, buf_size)))
{
result = 1;
printf("quicktime_make_streamable: out of memory\n");
}
else
{
while(quicktime_position(old_file) < mdat_start + mdat_size && !result)
{
if(quicktime_position(old_file) + buf_size > mdat_start + mdat_size)
buf_size = mdat_start + mdat_size - quicktime_position(old_file);
if(!quicktime_read_data(old_file, buffer, buf_size)) result = 1;
if(!result)
{
if(!quicktime_write_data(&new_file, buffer, buf_size)) result = 1;
}
}
free(buffer);
}
fclose(new_file.stream);
}
quicktime_close(old_file);
}
else
{
printf("quicktime_make_streamable: header already at 0 offset\n");
return 0;
}
}
return 0;
}
quicktime_t* quicktime_open(char *filename, int rd, int wr, int append)
{
quicktime_t *new_file = malloc(sizeof(quicktime_t));
char flags[10];
int exists = 0;
quicktime_init(new_file);
new_file->wr = wr;
new_file->rd = rd;
new_file->mdat.start = 0;
if (!strcmp(&filename[strlen(filename)-4], ".mp4")) {
new_file->use_mp4 = TRUE;
} else {
new_file->use_mp4 = FALSE;
}
if(rd && (new_file->stream = fopen(filename, "rb")))
{
exists = 1;
fclose(new_file->stream);
new_file->stream = NULL;
}
if(rd && !wr)
sprintf(flags, "rb");
else if(!rd && wr)
sprintf(flags, "wb");
else if(rd && wr)
{
if(exists)
sprintf(flags, "rb+");
else
sprintf(flags, "wb+");
}
if(!(new_file->stream = fopen(filename, flags)))
{
perror("quicktime_open");
free(new_file);
return 0;
}
if(rd && exists)
{
fseek(new_file->stream, 0, SEEK_END);
new_file->total_length = ftell(new_file->stream);
fseek(new_file->stream, 0, SEEK_SET);
if(quicktime_read_info(new_file))
{
quicktime_close(new_file);
new_file = 0;
}
}
if(wr) {
if(!exists || !append) {
/* start the data atom */
quicktime_write_int32(new_file, 0);
quicktime_write_char32(new_file, "mdat");
} else {
quicktime_set_position(new_file,
new_file->mdat.start + new_file->mdat.size);
fseek(new_file->stream,
new_file->mdat.start + new_file->mdat.size, SEEK_SET);
}
}
return new_file;
}
int main(int argc, char *argv[])
{
quicktime_t *file;
FILE *output;
int result = 0;
int i, j;
int64_t length;
char string[1024], *prefix = 0, *input = 0;
char *data = 0;
int bytes = 0, old_bytes = 0;
float output_rate = 0;
float input_rate;
int64_t input_frame;
int64_t new_length;
int width, height;
int rgb_to_ppm = 0;
if(argc < 3)
{
usage();
}
for(i = 1, j = 0; i < argc; i++)
{
if(!strcmp(argv[i], "-f"))
{
if(i + 1 < argc)
{
output_rate = atof(argv[++i]);
}
else
usage();
}
else
if(j == 0)
{
input = argv[i];
j++;
}
else
if(j == 1)
{
prefix = argv[i];
j++;
}
}
if(!prefix || !input) usage();
if(!(file = quicktime_open(input, 1, 0)))
{
printf("Open failed\n");
exit(1);
}
if(!quicktime_video_tracks(file))
{
printf("No video tracks.\n");
exit(1);
}
if(quicktime_match_32(quicktime_video_compressor(file, 0), QUICKTIME_RAW))
{
printf("Converting to ppm.\n");
rgb_to_ppm = 1;
}
length = quicktime_video_length(file, 0);
input_rate = quicktime_frame_rate(file, 0);
if(!output_rate) output_rate = input_rate;
new_length = output_rate / input_rate * length;
width = quicktime_video_width(file, 0);
height = quicktime_video_height(file, 0);
for(i = 0; i < new_length; i++)
{
/* Get output file */
sprintf(string, "%s%06d", prefix, i);
if(!(output = fopen(string, "wb")))
{
perror("Open failed");
exit(1);
}
/* Get input frame */
input_frame = (int64_t)(input_rate / output_rate * i);
bytes = quicktime_frame_size(file, input_frame, 0);
if(data)
{
if(bytes > old_bytes) { free(data); data = 0; }
}
if(!data)
{
old_bytes = bytes;
data = malloc(bytes);
}
quicktime_set_video_position(file, input_frame, 0);
quicktime_read_data(file, data, bytes);
if(rgb_to_ppm)
{
fprintf(output, "P6\n%d %d\n%d\n", width, height, 0xff);
}
if(!fwrite(data, bytes, 1, output))
{
perror("write failed");
}
fclose(output);
}
quicktime_close(file);
}
int quicktime_make_streamable(char *in_path, char *out_path)
{
quicktime_t file, *old_file, new_file;
int moov_exists = 0, mdat_exists = 0, result, atoms = 1;
int64_t mdat_start, mdat_size;
quicktime_atom_t leaf_atom;
int64_t moov_start, moov_end;
int ftyp_exists = 0;
int ftyp_size = 0;
unsigned char *ftyp_data = 0;
quicktime_init(&file);
/* find the moov atom in the old file */
if(!(file.stream = fopen(in_path, "rb")))
{
perror("quicktime_make_streamable");
return 1;
}
file.total_length = quicktime_get_file_length(in_path);
/* get the locations of moov and mdat atoms */
do
{
result = quicktime_atom_read_header(&file, &leaf_atom);
//printf("0x%llx %s\n", quicktime_position(&file), leaf_atom.type);
if(!result)
{
if(quicktime_atom_is(&leaf_atom, "ftyp"))
{
ftyp_exists = 1;
ftyp_data = calloc(1, leaf_atom.size);
ftyp_size = leaf_atom.size;
quicktime_set_position(&file,
quicktime_position(&file) - HEADER_LENGTH);
quicktime_read_data(&file, (char*)ftyp_data, ftyp_size);
}
else
if(quicktime_atom_is(&leaf_atom, "moov"))
{
moov_exists = atoms;
}
else
if(quicktime_atom_is(&leaf_atom, "mdat"))
{
mdat_start = quicktime_position(&file) - HEADER_LENGTH;
mdat_size = leaf_atom.size;
mdat_exists = atoms;
}
quicktime_atom_skip(&file, &leaf_atom);
atoms++;
}
}while(!result && quicktime_position(&file) < file.total_length);
fclose(file.stream);
if(!moov_exists)
{
printf("quicktime_make_streamable: no moov atom\n");
if(ftyp_data) free(ftyp_data);
return 1;
}
if(!mdat_exists)
{
printf("quicktime_make_streamable: no mdat atom\n");
if(ftyp_data) free(ftyp_data);
return 1;
}
/* copy the old file to the new file */
if(moov_exists && mdat_exists)
{
/* moov wasn't the first atom */
if(moov_exists > 1)
{
char *buffer;
int64_t buf_size = 1000000;
result = 0;
/* read the header proper */
if(!(old_file = quicktime_open(in_path, 1, 0)))
{
if(ftyp_data) free(ftyp_data);
return 1;
}
/* open the output file */
if(!(new_file.stream = fopen(out_path, "wb")))
{
perror("quicktime_make_streamable");
result = 1;
}
else
{
/* set up some flags */
new_file.wr = 1;
new_file.rd = 0;
/* Write ftyp header */
if(ftyp_exists)
{
quicktime_write_data(&new_file, (char*)ftyp_data, ftyp_size);
}
/* Write moov once to get final size with our substituted headers */
moov_start = quicktime_position(&new_file);
quicktime_write_moov(&new_file, &(old_file->moov), 0);
moov_end = quicktime_position(&new_file);
printf("make_streamable 0x%llx 0x%llx\n", (long long)moov_end - moov_start, (long long)mdat_start);
quicktime_shift_offsets(&(old_file->moov),
moov_end - moov_start - mdat_start + ftyp_size);
/* Write again with shifted offsets */
quicktime_set_position(&new_file, moov_start);
quicktime_write_moov(&new_file, &(old_file->moov), 0);
quicktime_set_position(old_file, mdat_start);
if(!(buffer = calloc(1, buf_size)))
{
result = 1;
printf("quicktime_make_streamable: out of memory\n");
}
else
{
while(quicktime_position(old_file) < mdat_start + mdat_size && !result)
{
if(quicktime_position(old_file) + buf_size > mdat_start + mdat_size)
buf_size = mdat_start + mdat_size - quicktime_position(old_file);
if(!quicktime_read_data(old_file, buffer, buf_size)) result = 1;
if(!result)
{
if(!quicktime_write_data(&new_file, buffer, buf_size)) result = 1;
}
}
free(buffer);
}
fclose(new_file.stream);
}
quicktime_close(old_file);
}
else
{
printf("quicktime_make_streamable: header already at 0 offset\n");
if(ftyp_data) free(ftyp_data);
return 0;
}
}
if(ftyp_data) free(ftyp_data);
return 0;
}
/*
* mp4extract
* required arg1 should be the MP4 input file
* required arg2 should be the output file for the extracted track
*/
int main(int argc, char** argv)
{
/* variables controlable from command line */
bool extractVideo = TRUE;
/* internal variables */
char* mp4FileName = NULL;
char* outFileName = NULL;
quicktime_t* mp4File = NULL;
FILE* outFile = NULL;
int track = 0;
int frame, numFrames;
u_int8_t buf[64*1024]; /* big enough? */
int bufSize;
/* begin process command line */
progName = argv[0];
while (1) {
int c = -1;
int option_index = 0;
static struct option long_options[] = {
{ "audio", 0, 0, 'a' },
{ "video", 0, 0, 'v' },
{ NULL, 0, 0, 0 }
};
c = getopt_long(argc, argv, "av",
long_options, &option_index);
if (c == -1)
break;
switch (c) {
case 'a': {
extractVideo = FALSE;
break;
}
case 'v': {
extractVideo = TRUE;
break;
}
case '?':
break;
default:
fprintf(stderr, "%s: unknown option specified, ignoring: %c\n",
progName, c);
}
}
/* check that we have at least two non-option arguments */
if ((argc - optind) < 2) {
fprintf(stderr,
"usage: %s <mpeg-file> <mov-file>\n",
progName);
exit(1);
}
/* point to the specified file names */
mp4FileName = argv[optind++];
outFileName = argv[optind++];
/* warn about extraneous non-option arguments */
if (optind < argc) {
fprintf(stderr, "%s: unknown options specified, ignoring: ", progName);
while (optind < argc) {
fprintf(stderr, "%s ", argv[optind++]);
}
fprintf(stderr, "\n");
}
/* end processing of command line */
/* open the MP4 file */
mp4File = quicktime_open(mp4FileName, 1, 0, 0);
if (mp4File == NULL) {
fprintf(stderr,
"%s: error %s: %s\n",
progName, mp4FileName, strerror(errno));
exit(2);
}
/* open output file for writing */
outFile = fopen(outFileName, "wb");
if (outFile == NULL) {
fprintf(stderr,
"%s: error opening %s: %s\n",
progName, outFileName, strerror(errno));
exit(3);
}
/* add MPEG-4 video config info at beginning of output file */
if (extractVideo) {
if (!strcasecmp(quicktime_video_compressor(mp4File, track), "mp4v")) {
u_char* pConfig;
int configSize;
quicktime_get_mp4_video_decoder_config(mp4File, track,
&pConfig, &configSize);
if (fwrite(pConfig, 1, configSize, outFile) != configSize) {
fprintf(stderr,
"%s: write error: %s\n",
progName, strerror(errno));
exit(4);
}
free(pConfig);
}
}
if (extractVideo) {
numFrames = quicktime_video_length(mp4File, track);
} else {
numFrames = quicktime_audio_length(mp4File, track);
}
for (frame = 0; frame < numFrames; frame++) {
if (extractVideo) {
bufSize = quicktime_read_frame(mp4File,
&buf[0], track);
} else { // extract audio
bufSize = quicktime_read_audio_frame(mp4File,
&buf[0], sizeof(buf), track);
}
if (bufSize <= 0) {
fprintf(stderr,
"%s: read error: %s\n",
progName, strerror(errno));
exit(5);
}
if (fwrite(buf, 1, bufSize, outFile) != bufSize) {
fprintf(stderr,
"%s: write error: %s\n",
progName, strerror(errno));
exit(4);
}
}
/* cleanup */
quicktime_close(mp4File);
fclose(outFile);
exit(0);
}
int main(int argc, char *argv[])
{
int error = 0;
int frame_count = -1;
char *row_pointers[3];
int do_audio = 0;
int do_video = 0;
int channels = 0;
long afragment = 65536;
float **audio_output;
int layer = 0;
int astream = 0;
char input_path[1024];
char output_path[1024];
int i;
long current_frame = 0;
long current_sample = 0;
pthread_mutex_init(&mutex, NULL);
signal(SIGINT, trap_interrupt);
input_path[0] = 0;
output_path[0] = 0;
if(argc < 3)
{
printf("Usage: %s [-a] [-v] <mpeg file> <output movie> [frame count]\n", argv[0]);
exit(1);
}
for(i = 1; i < argc; i++)
{
if(!strcmp(argv[i], "-a"))
{
do_audio = 1;
}
else
if(!strcmp(argv[i], "-v"))
{
do_video = 1;
}
else
if(!input_path[0])
{
strcpy(input_path, argv[i]);
}
else
if(!output_path[0])
{
strcpy(output_path, argv[i]);
}
else
frame_count = atol(argv[i]);
}
//printf("main 1\n");
if(!(input = mpeg3_open(input_path, &error)))
{
exit(1);
}
//printf("main 1\n");
if(!(output = quicktime_open(output_path, 0, 1)))
{
exit(1);
}
//printf("main 1\n");
if(do_video)
{
if(!mpeg3_total_vstreams(input))
{
do_video = 0;
}
else
{
quicktime_set_video(output,
1,
mpeg3_video_width(input, layer),
mpeg3_video_height(input, layer),
mpeg3_frame_rate(input, layer),
VIDEO_CODEC);
quicktime_set_jpeg(output, 80, 0);
}
}
//printf("main 1\n");
if(do_audio)
{
if(!mpeg3_total_astreams(input))
{
do_audio = 0;
}
else
{
int i;
channels = mpeg3_audio_channels(input, astream);
quicktime_set_audio(output,
channels,
mpeg3_sample_rate(input, 0),
24,
AUDIO_CODEC);
audio_output = malloc(sizeof(float*) * channels);
for(i = 0; i < channels; i++)
audio_output[i] = malloc(sizeof(float) * afragment);
}
}
//printf("main 1\n");
// quicktime_set_jpeg(output, 100, 0);
// mpeg3_set_mmx(input, 0);
while((!(do_video && mpeg3_end_of_video(input, layer)) ||
!(do_audio && mpeg3_end_of_audio(input, astream))) &&
(current_frame < frame_count || frame_count < 0))
{
//printf("%d %d\n", mpeg3_end_of_video(input, layer), mpeg3_end_of_audio(input, astream));
if(do_audio)
{
if(!mpeg3_end_of_audio(input, astream))
{
int fragment = afragment;
int i, j, k;
i = astream;
k = 0;
for(j = 0; j < mpeg3_audio_channels(input, i); j++, k++)
{
if(j == 0)
mpeg3_read_audio(input,
audio_output[k], /* Pointer to pre-allocated buffer of floats */
0, /* Pointer to pre-allocated buffer of int16's */
j, /* Channel to decode */
fragment, /* Number of samples to decode */
i);
else
mpeg3_reread_audio(input,
audio_output[k], /* Pointer to pre-allocated buffer of floats */
0, /* Pointer to pre-allocated buffer of int16's */
j, /* Channel to decode */
fragment, /* Number of samples to decode */
i);
}
quicktime_encode_audio(output,
0,
audio_output,
fragment);
current_sample += fragment;
if(!do_video)
{
printf(" %d samples written\r", current_sample);
fflush(stdout);
}
}
else
current_sample += afragment;
}
if(do_video)
{
if(!mpeg3_end_of_video(input, layer))
{
int fragment;
if(do_audio)
fragment = (long)((double)current_sample /
mpeg3_sample_rate(input, 0) *
mpeg3_frame_rate(input, layer) -
current_frame);
else
fragment = 1;
for(i = 0; i < fragment && !mpeg3_end_of_video(input, layer); i++)
{
mpeg3_read_yuvframe_ptr(input,
&row_pointers[0],
&row_pointers[1],
&row_pointers[2],
layer);
switch(mpeg3_colormodel(input, layer))
{
case MPEG3_YUV420P:
quicktime_set_cmodel(output, BC_YUV420P);
break;
case MPEG3_YUV422P:
quicktime_set_cmodel(output, BC_YUV422P);
break;
}
quicktime_encode_video(output,
(unsigned char **)row_pointers,
0);
current_frame++;
printf(" %d frames written\r", current_frame);
fflush(stdout);
}
}
}
}
printf("main 2\n");
printf("\n");
quicktime_close(output);
mpeg3_close(input);
}
int
cmdline_main (int argc, char *argv[])
{
guchar *output;
int num_frames = 1;
#ifdef MOVIES
int generate_movie = 0;
quicktime_t *output_movie;
guchar **rows;
#endif
int antialiasing = 0, supersampling = 0;
int img_width, img_height;
char *generator = 0;
userval_info_t *userval_info;
int num_input_drawables = 0;
gboolean size_is_set = FALSE;
char *script = NULL;
char *output_filename;
gboolean htmldoc = FALSE;
define_t *defines = NULL;
int bench_render_count = 1;
int render_num;
gboolean bench_no_output = FALSE;
gboolean bench_no_backend = FALSE;
int compile_time_limit = DEFAULT_OPTIMIZATION_TIMEOUT;
for (;;)
{
static struct option long_options[] =
{
{ "version", no_argument, 0, OPTION_VERSION },
{ "help", no_argument, 0, OPTION_HELP },
{ "intersampling", no_argument, 0, 'i' },
{ "oversampling", no_argument, 0, 'o' },
{ "cache", required_argument, 0, 'c' },
{ "generator", required_argument, 0, 'g' },
{ "size", required_argument, 0, 's' },
{ "script-file", required_argument, 0, 'f' },
{ "htmldoc", no_argument, 0, OPTION_HTMLDOC },
{ "bench-no-output", no_argument, 0, OPTION_BENCH_NO_OUTPUT },
{ "bench-only-compile", no_argument, 0, OPTION_BENCH_ONLY_COMPILE },
{ "bench-no-compile-time-limit", no_argument, 0, OPTION_BENCH_NO_COMPILE_TIME_LIMIT },
{ "bench-no-backend", no_argument, 0, OPTION_BENCH_NO_BACKEND },
{ "bench-render-count", required_argument, 0, OPTION_BENCH_RENDER_COUNT },
#ifdef MOVIES
{ "frames", required_argument, 0, 'F' },
{ "movie", required_argument, 0, 'M' },
#endif
{ 0, 0, 0, 0 }
};
int option, option_index;
option = getopt_long(argc, argv,
#ifdef MOVIES
"f:ioF:D:M:c:g:s:",
#else
"f:ioD:c:g:s:",
#endif
long_options, &option_index);
if (option == -1)
break;
switch (option)
{
case OPTION_VERSION :
printf("MathMap " MATHMAP_VERSION "\n"
"\n"
"Copyright (C) 1997-2009 Mark Probst\n"
"\n"
"This program is free software; you can redistribute it and/or modify\n"
"it under the terms of the GNU General Public License as published by\n"
"the Free Software Foundation; either version 2 of the License, or\n"
"(at your option) any later version.\n"
"\n"
"This program is distributed in the hope that it will be useful,\n"
"but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
"MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
"GNU General Public License for more details.\n"
"\n"
"You should have received a copy of the GNU General Public License\n"
"along with this program; if not, write to the Free Software\n"
"Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.\n");
return 0;
case OPTION_HELP :
usage();
return 0;
case OPTION_HTMLDOC :
htmldoc = TRUE;
break;
case 'f' :
if (!g_file_get_contents(optarg, &script, NULL, NULL))
{
fprintf(stderr, _("Error: The script file `%s' could not be read.\n"), optarg);
return 1;
}
break;
case 'i' :
antialiasing = 1;
break;
case 'o' :
supersampling = 1;
break;
case 'c' :
cache_size = atoi(optarg);
assert(cache_size > 0);
break;
case 'D' :
append_define(optarg, &defines);
break;
case 'I' :
alloc_cmdline_image_input_drawable(optarg);
break;
case 'g' :
generator = optarg;
break;
case 's' :
if (!parse_image_size(optarg, &img_width, &img_height))
{
fprintf(stderr, _("Error: Invalid image size. Syntax is <width>x<height>. Example: 1024x768.\n"));
exit(1);
}
size_is_set = 1;
break;
case OPTION_BENCH_RENDER_COUNT :
bench_render_count = atoi(optarg);
break;
case OPTION_BENCH_ONLY_COMPILE :
bench_render_count = 0;
break;
case OPTION_BENCH_NO_OUTPUT :
bench_no_output = TRUE;
break;
case OPTION_BENCH_NO_COMPILE_TIME_LIMIT :
compile_time_limit = -1;
break;
case OPTION_BENCH_NO_BACKEND :
bench_no_backend = TRUE;
break;
#ifdef MOVIES
case 'F' :
generate_movie = 1;
num_frames = atoi(optarg);
assert(num_frames > 0);
break;
case 'M' :
alloc_cmdline_movie_input_drawable(optarg);
break;
#endif
}
}
if (script != NULL)
{
if (argc - optind != 1)
{
usage();
return 1;
}
output_filename = argv[optind];
}
else
{
if (argc - optind != 2)
{
usage();
return 1;
}
script = argv[optind];
output_filename = argv[optind + 1];
}
init_tags();
init_builtins();
init_macros();
init_compiler();
if (htmldoc)
{
mathmap_t *mathmap = parse_mathmap(script);
filter_t *filter;
FILE *out;
if (mathmap == NULL)
{
fprintf(stderr, _("Error: Could not read MathMap script: %s\n"), error_string);
return 1;
}
out = fopen(output_filename, "w");
if (out == NULL)
{
fprintf(stderr, _("Error: Cannot open file `%s' for writing: %s\n"),
output_filename, strerror(errno));
return 1;
}
for (filter = mathmap->filters; filter != NULL; filter = filter->next)
{
if (filter->kind != FILTER_MATHMAP)
continue;
if (!write_filter_html_doc(out, filter->v.mathmap.decl))
return 1;
}
fclose(out);
}
else if (generator == 0)
{
char *support_paths[4];
mathmap_t *mathmap;
mathmap_invocation_t *invocation;
int current_frame;
support_paths[0] = g_strdup_printf("%s/mathmap", GIMPDATADIR);
support_paths[1] = g_strdup_printf("%s/.gimp-2.6/mathmap", getenv("HOME"));
support_paths[2] = g_strdup_printf("%s/.gimp-2.4/mathmap", getenv("HOME"));
support_paths[3] = NULL;
mathmap = compile_mathmap(script, support_paths, compile_time_limit, bench_no_backend);
if (bench_no_backend)
return 0;
if (mathmap == 0)
{
fprintf(stderr, _("Error: %s\n"), error_string);
exit(1);
}
if (bench_render_count == 0)
return 0;
if (!size_is_set)
for (userval_info = mathmap->main_filter->userval_infos;
userval_info != NULL;
userval_info = userval_info->next)
{
define_t *define;
unsigned char *image;
if (userval_info->type != USERVAL_IMAGE)
continue;
define = lookup_define(defines, userval_info->name);
if (define == NULL)
{
fprintf(stderr, _("Error: No value defined for input image `%s'.\n"), userval_info->name);
return 1;
}
image = read_image(define->value, &img_width, &img_height);
if (image == NULL)
{
fprintf(stderr, _("Error: Could not read input image `%s'.\n"), define->value);
return 1;
}
free(image);
size_is_set = TRUE;
break;
}
if (!size_is_set)
{
fprintf(stderr, _("Error: Image size not set and no input images given.\n"));
exit(1);
}
invocation = invoke_mathmap(mathmap, NULL, img_width, img_height, TRUE);
for (userval_info = mathmap->main_filter->userval_infos;
userval_info != NULL;
userval_info = userval_info->next)
{
userval_t *userval = &invocation->uservals[userval_info->index];
define_t *define = lookup_define(defines, userval_info->name);
if (define == NULL)
{
if (userval_info->type == USERVAL_IMAGE)
{
fprintf(stderr, _("Error: No value defined for input image `%s'.\n"), userval_info->name);
return 1;
}
}
else
switch (userval_info->type)
{
case USERVAL_INT_CONST :
userval->v.int_const = atoi(define->value);
break;
case USERVAL_FLOAT_CONST :
userval->v.float_const = g_ascii_strtod(define->value, NULL);
break;
case USERVAL_BOOL_CONST :
userval->v.bool_const = (float)atoi(define->value);
break;
case USERVAL_IMAGE :
assign_image_userval_drawable(userval_info, userval,
alloc_cmdline_image_input_drawable(define->value));
++num_input_drawables;
break;
default :
fprintf(stderr, _("Error: Can only define user values for types int, float, bool and image.\n"));
return 1;
}
}
for (render_num = 0; render_num < bench_render_count; ++render_num)
{
#ifdef MOVIES
for (i = 0; i < num_input_drawables; ++i)
if (input_drawables[i].type == DRAWABLE_MOVIE)
{
assert(quicktime_video_width(input_drawables[i].v.movie, 0) == img_width);
assert(quicktime_video_height(input_drawables[i].v.movie, 0) == img_height);
}
#endif
invocation_set_antialiasing(invocation, antialiasing);
invocation->supersampling = supersampling;
invocation->output_bpp = 4;
output = (guchar*)malloc((long)invocation->output_bpp * (long)img_width * (long)img_height);
assert(output != 0);
#ifdef MOVIES
if (generate_movie)
{
output_movie = quicktime_open(output_filename, 0, 1);
assert(output_movie != 0);
quicktime_set_video(output_movie, 1, img_width, img_height, 25, QUICKTIME_JPEG);
assert(quicktime_supported_video(output_movie, 0));
quicktime_seek_start(output_movie);
rows = (guchar**)malloc(sizeof(guchar*) * img_height);
for (i = 0; i < img_height; ++i)
rows[i] = output + img_width * invocation->output_bpp * i;
}
#endif
for (current_frame = 0; current_frame < num_frames; ++current_frame)
{
float current_t = (float)current_frame / (float)num_frames;
image_t *closure = closure_image_alloc(&invocation->mathfuncs,
NULL,
invocation->mathmap->main_filter->num_uservals,
invocation->uservals,
img_width, img_height);
mathmap_frame_t *frame = invocation_new_frame(invocation, closure,
current_frame, current_t);
call_invocation_parallel_and_join(frame, closure, 0, 0, img_width, img_height, output, 1);
invocation_free_frame(frame);
#ifdef MOVIES
if (generate_movie && !bench_no_output)
{
fprintf(stderr, _("writing frame %d\n"), current_frame);
assert(quicktime_encode_video(output_movie, rows, 0) == 0);
}
#endif
closure_image_free(closure);
}
if (!bench_no_output)
{
#ifdef MOVIES
if (generate_movie)
quicktime_close(output_movie);
else
#endif
write_image(output_filename, img_width, img_height, output,
invocation->output_bpp, img_width * invocation->output_bpp, IMAGE_FORMAT_PNG);
}
free(output);
}
}
else
{
if (strcmp(generator, "blender") == 0)
{
if (!blender_generate_plug_in(script, output_filename))
return 1;
}
/*
else if (strcmp(generator, "pixeltree") == 0)
{
if (!pixeltree_generate_plug_in(argv[optind], argv[optind + 1]))
return 1;
}
*/
else
{
fprintf(stderr, _("Unknown generator `%s'\n"), generator);
return 1;
}
}
return 0;
}
