Merge CV, ver=5.1; ops/methods from HV, and interface from CV where possible
[goodguy/history.git] / cinelerra-5.1 / libzmpeg3 / mpeg2qt.c
diff --git a/cinelerra-5.1/libzmpeg3/mpeg2qt.c b/cinelerra-5.1/libzmpeg3/mpeg2qt.c
new file mode 100644 (file)
index 0000000..141237e
--- /dev/null
@@ -0,0 +1,289 @@
+#include <pthread.h>
+#include <signal.h>
+
+#include "colormodels.h"
+#include "libmpeg3.h"
+#include "quicktime.h"
+
+#define OUTPUT_PATH "movie.mov"
+//#define VIDEO_CODEC QUICKTIME_DIVX
+#define VIDEO_CODEC QUICKTIME_JPEG
+//#define VIDEO_CODEC QUICKTIME_YUV420
+#define AUDIO_CODEC QUICKTIME_TWOS
+//#define AUDIO_CODEC QUICKTIME_VORBIS
+
+
+// Hack for libdv to remove glib dependancy
+
+void
+g_log (const char    *log_domain,
+       int  log_level,
+       const char    *format,
+       ...)
+{
+}
+
+void
+g_logv (const char    *log_domain,
+       int  log_level,
+       const char    *format,
+       ...)
+{
+}
+
+
+
+// Hack for XFree86 4.1.0
+
+int atexit(void (*function)(void))
+{
+       return 0;
+}
+
+
+// Dump mpeg video to a quicktime movie
+
+quicktime_t *output;
+mpeg3_t *input;
+pthread_mutex_t mutex;
+int predicate = 0;
+
+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);
+       }
+}
+
+
+
+
+
+int main(int argc, char *argv[])
+{
+       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)))
+       {
+               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);
+}
+
+
+
+
+
+
+
+