hvirtual/libmpeg3/mpeg2qt.c

Go to the documentation of this file.

#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);
}

---