rmovie 0.5.0

data/ext/rmovie/quadrupel/qp_frame.h

@@ -0,0 +1,49 @@
+#ifndef QP_FRAME_H
+#define QP_FRAME_H
+
+#include "qp_util.h"
+
+#include <ffmpeg/avcodec.h>
+#include <ffmpeg/avformat.h>
+
+/* 
+ * Basic frame manipulation routines. This should remain general enough to
+ * be used in ffmpeg-php or rmovie. 
+ */
+
+typedef struct {
+    AVFrame *av_frame;
+    int width;
+    int height;
+    int pixel_format;
+    int keyframe;
+    int64_t pts;
+} qp_frame_context;
+
+int qp_get_frame_height(qp_frame_context *frame);
+int qp_get_frame_width(qp_frame_context *frame);
+const char* qp_get_frame_pixel_format_name(qp_frame_context *frame_ctx);
+
+/* This should be static */
+void qp_free_av_frame(AVFrame *av_frame);
+
+qp_frame_context* qp_alloc_frame_ctx(qp_malloc_t malloc_func);
+void qp_free_frame_ctx(qp_frame_context *frame_ctx, qp_free_t free_func);
+
+
+int qp_convert_av_frame(AVFrame **av_frame, int pixel_format, 
+        int new_format, int width, int height, int free_buffers);
+
+int qp_convert_frame(qp_frame_context *frame, int new_fmt);
+int qp_crop_frame(qp_frame_context *frame,
+        int crop_top, int crop_bottom, int crop_left, int crop_right);
+int qp_resample_frame(qp_frame_context *frame,
+        int wanted_width, int wanted_height, int crop_top, int crop_bottom,
+        int crop_left, int crop_right);
+
+int qp_output_frame_as_string(qp_frame_context *frame, unsigned char**);
+
+double qp_get_pts(qp_frame_context *frame);
+long qp_frame_is_keyframe(qp_frame_context *frame);
+
+#endif

data/ext/rmovie/quadrupel/qp_movie.c

@@ -0,0 +1,1179 @@
+#include <stdlib.h>
+#include <string.h>
+
+#include "qp_util.h"
+#include "qp_movie.h"
+#include "qp_frame.h"
+
+#define LRINT(x) ((long) ((x)+0.5))
+#define MAX(a,b) ((a) > (b) ? (a) : (b))
+
+#if LIBAVFORMAT_BUILD > 4628
+#define GET_CODEC_FIELD(codec, field) codec->field
+#define GET_CODEC_PTR(codec) codec
+#else
+#define GET_CODEC_FIELD(codec, field) codec.field
+#define GET_CODEC_PTR(codec) &codec
+#endif
+
+#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
+
+/* 
+ * TODO: this should return error as a string so that the calling
+ * program can decided how to display it.
+ */
+/*
+static void _php_print_av_error(const char *filename, int err) 
+{
+    char* err_string;
+    switch(err) {   
+       case AVERROR_IO:
+            fprintf(stderr, "%s: I/O error.\n", filename);
+            break;  
+       case AVERROR_NOMEM:
+            fprintf(stderr, "%s: Not enough memory.\n", filename);
+            break;  
+        case AVERROR_NOTSUPP:
+            fprintf(stderr, "%s: Operation not supported.\n", filename);
+            break;  
+ 
+       case AVERROR_NUMEXPECTED:
+            fprintf(stderr, "%s: Incorrect image filename syntax.\n", filename);  
+            break;  
+        case AVERROR_INVALIDDATA:   
+            fprintf(stderr, "%s: Error while parsing header\n", filename);  
+            break;  
+        case AVERROR_NOFMT:     
+            fprintf(stderr, "%s: Unknown format\n", filename);  
+        case AVERROR_UNKNOWN:
+            // Fall thru to default case 
+        default:    
+            fprintf(stderr, "%s: Error while opening file (%d)\n", filename, err);  
+            break;  
+    }   
+}
+*/
+
+int qp_open_movie_file(qp_movie_context *movie_ctx, const char* filename)
+{
+    int ret;
+
+    if (movie_ctx->fmt_ctx) {
+        av_close_input_file(movie_ctx->fmt_ctx);
+        movie_ctx->fmt_ctx = NULL;
+    }
+
+    /* open the file with generic libav function */
+    ret = av_open_input_file(&(movie_ctx->fmt_ctx), filename, NULL, 0, NULL);
+
+    if (ret) {
+        return ret;
+    }
+
+    /* If not enough info to get the stream parameters, we decode the
+     *        first frames to get it. */
+    if (av_find_stream_info(movie_ctx->fmt_ctx)) {
+        /* Don't fail here since this is not a problem for formats like .mov */
+    }
+    return 0;
+}
+
+
+void qp_free_movie_ctx(qp_movie_context *movie_ctx, qp_free_t free_func)
+{
+    int i;
+    qp_free_t free_function = free_func ? free_func : free;
+
+    if (movie_ctx->codec_ctx) {
+        for (i = 0; i < MAX_STREAMS; i++) {
+            if (movie_ctx->codec_ctx[i]) {
+                avcodec_close(movie_ctx->codec_ctx[i]);
+            }
+            movie_ctx->codec_ctx[i] = NULL;
+        }
+    }
+
+    if (movie_ctx->fmt_ctx) {
+        av_close_input_file(movie_ctx->fmt_ctx);
+    }
+
+    free_function(movie_ctx);
+}
+
+
+qp_movie_context* qp_alloc_movie_ctx(qp_malloc_t malloc_func)
+{
+    int i;
+    qp_movie_context *movie_ctx = NULL;
+
+    qp_malloc_t malloc_function = malloc_func ? malloc_func : malloc;
+
+    movie_ctx = (qp_movie_context *)malloc_function(sizeof(qp_movie_context));
+    movie_ctx->fmt_ctx = NULL;
+    movie_ctx->frame_number = 0;
+    movie_ctx->mode = QP_FRAME_BASED;
+
+    for (i = 0; i < MAX_STREAMS; i++) {
+        movie_ctx->codec_ctx[i] = NULL;
+    }
+
+    return movie_ctx;
+}
+
+
+static int get_stream_index(AVFormatContext *fmt_ctx, int type)
+{
+    int i;
+
+    for (i = 0; i < fmt_ctx->nb_streams; i++) {
+        if (fmt_ctx->streams[i] &&
+                GET_CODEC_FIELD(fmt_ctx->streams[i]->codec, codec_type) == type) {
+            return i;
+        }
+    }
+    /* stream not found */
+    return -1;
+}
+
+
+static AVCodecContext* get_decoder_context(qp_movie_context *movie_ctx, int stream_type)
+{
+    AVCodec *decoder;
+    int stream_index;
+
+    stream_index = get_stream_index(movie_ctx->fmt_ctx, stream_type);
+    if (stream_index < 0) {
+        return NULL;
+    }
+
+    /* check if the codec for this stream is already open */
+    if (!movie_ctx->codec_ctx[stream_index]) {
+
+        /* find the decoder */
+        decoder = avcodec_find_decoder(GET_CODEC_FIELD(
+                    movie_ctx->fmt_ctx->streams[stream_index]->codec,
+                    codec_id));
+
+        if (!decoder) {
+            return NULL;
+        }
+
+        movie_ctx->codec_ctx[stream_index] =
+            GET_CODEC_PTR(movie_ctx->fmt_ctx->streams[stream_index]->codec);
+
+       /* open the decoder */
+        if (avcodec_open(movie_ctx->codec_ctx[stream_index], decoder) < 0) {
+            return NULL;
+        }
+    }
+    return movie_ctx->codec_ctx[stream_index];
+}
+
+
+static AVStream *get_video_stream(AVFormatContext *fmt_ctx)
+{
+    int i = get_stream_index(fmt_ctx, CODEC_TYPE_VIDEO);
+
+    return i < 0 ? NULL : fmt_ctx->streams[i];
+}
+
+
+static AVStream *get_audio_stream(AVFormatContext *fmt_ctx)
+{
+    int i = get_stream_index(fmt_ctx, CODEC_TYPE_AUDIO);
+
+    return i < 0 ? NULL : fmt_ctx->streams[i];
+}
+
+
+float qp_get_frame_rate(qp_movie_context *movie_ctx)
+{
+    AVStream *st = get_video_stream(movie_ctx->fmt_ctx);
+    float rate = 0.0f;
+
+    if (!st) {
+        return rate;
+    }
+
+#if LIBAVCODEC_BUILD > 4753
+    if (GET_CODEC_FIELD(st->codec, codec_type) == CODEC_TYPE_VIDEO){
+        if (st->r_frame_rate.den && st->r_frame_rate.num) {
+            rate = av_q2d(st->r_frame_rate);
+        } else {
+            rate = 1 / av_q2d(GET_CODEC_FIELD(st->codec, time_base));
+        }
+    }
+    return (float)rate;
+#else
+    return (float)GET_CODEC_FIELD(st->codec, frame_rate) /
+        GET_CODEC_FIELD(st->codec, frame_rate_base);
+#endif
+}
+
+
+float qp_get_duration(qp_movie_context *movie_ctx)
+{
+    float duration;
+
+    duration = (float)movie_ctx->fmt_ctx->duration / AV_TIME_BASE;
+
+    if (duration < 0) {
+        duration = 0.0f;
+    }
+    return duration;
+}
+
+
+long qp_get_frame_count(qp_movie_context *movie_ctx)
+{
+    /* does this movie have a video stream?  */
+    if (!get_video_stream(movie_ctx->fmt_ctx)) {
+        return 0;
+    }
+
+    return LRINT(qp_get_frame_rate(movie_ctx) *
+            qp_get_duration(movie_ctx));
+}
+
+
+char* qp_get_file_name(qp_movie_context *movie_ctx)
+{
+    return movie_ctx->fmt_ctx->filename;
+}
+
+
+char* qp_get_comment(qp_movie_context *movie_ctx)
+{
+    return movie_ctx->fmt_ctx->comment;
+}
+
+
+char* qp_get_title(qp_movie_context *movie_ctx)
+{
+    return movie_ctx->fmt_ctx->title;
+}
+
+
+char* qp_get_author(qp_movie_context *movie_ctx)
+{
+    return movie_ctx->fmt_ctx->author;
+}
+
+
+char* qp_get_copyright(qp_movie_context *movie_ctx)
+{
+    return movie_ctx->fmt_ctx->author;
+}
+
+
+char* qp_get_album(qp_movie_context *movie_ctx)
+{
+    return movie_ctx->fmt_ctx->album;
+}
+
+
+char* qp_get_genre(qp_movie_context *movie_ctx)
+{
+    return movie_ctx->fmt_ctx->genre;
+}
+
+
+int qp_get_year(qp_movie_context *movie_ctx)
+{
+    return movie_ctx->fmt_ctx->year;
+}
+
+
+int qp_get_track(qp_movie_context *movie_ctx)
+{
+    return movie_ctx->fmt_ctx->track;
+}
+
+
+int qp_get_movie_width(qp_movie_context *movie_ctx)
+{
+    AVStream *st = get_video_stream(movie_ctx->fmt_ctx);
+
+    if (!st) {
+        return 0;
+    }
+
+    return GET_CODEC_FIELD(st->codec, width);
+}
+
+
+int qp_get_movie_height(qp_movie_context *movie_ctx)
+{
+    AVStream *st = get_video_stream(movie_ctx->fmt_ctx);
+
+    if (!st) {
+        return 0;
+    }
+
+    return GET_CODEC_FIELD(st->codec, height);
+}
+
+
+long qp_get_current_frame_number(qp_movie_context *movie_ctx)
+{
+    AVCodecContext *decoder_ctx = NULL;
+
+    decoder_ctx = get_decoder_context(movie_ctx, CODEC_TYPE_VIDEO);
+    if (!decoder_ctx) {
+        return 0;
+    }
+
+    if (movie_ctx->frame_number <= 0) {
+        return 1; /* no frames read yet so return the first */
+    } else {
+        return movie_ctx->frame_number;
+    }
+}
+
+
+static int get_format_number(qp_movie_context *movie_ctx, int codec_type)
+{
+    AVCodecContext *decoder_ctx = NULL;
+
+    decoder_ctx = get_decoder_context(movie_ctx, codec_type);
+
+    return decoder_ctx ? decoder_ctx->pix_fmt : 0;
+}
+
+
+const char* qp_get_movie_pixel_format_name(qp_movie_context *movie_ctx) 
+{
+    int pix_fmt;
+    const char *fmt = NULL;
+ 
+    pix_fmt = get_format_number(movie_ctx, CODEC_TYPE_VIDEO);
+    fmt = avcodec_get_pix_fmt_name(pix_fmt);
+
+    if (fmt) {
+        return fmt;
+    } else {
+        return NULL;
+    }
+}
+
+
+int qp_get_bit_rate(qp_movie_context *movie_ctx)
+{
+    return movie_ctx->fmt_ctx->bit_rate;
+}
+
+
+const char* qp_get_codec_name(qp_movie_context *movie_ctx, int type)
+{
+    AVCodecContext *decoder_ctx = NULL;
+    AVCodec *p = NULL;
+    const char *codec_name;
+    char buf1[32];
+
+    if (!qp_has_video(movie_ctx)) {
+        return NULL;
+    }
+
+    decoder_ctx = get_decoder_context(movie_ctx, type);
+    if (!decoder_ctx) {
+        return NULL;
+    }
+
+    p = avcodec_find_decoder(decoder_ctx->codec_id);
+
+    /* Copied from libavcodec/utils.c::avcodec_string */
+    if (p) {
+        codec_name = p->name;
+        if (decoder_ctx->codec_id == CODEC_ID_MP3) {
+            if (decoder_ctx->sub_id == 2)
+                codec_name = "mp2";
+            else if (decoder_ctx->sub_id == 1)
+                codec_name = "mp1";
+        }
+    } else if (decoder_ctx->codec_id == CODEC_ID_MPEG2TS) {
+        /* fake mpeg2 transport stream codec (currently not registered) */
+        codec_name = "mpeg2ts";
+    } else if (decoder_ctx->codec_name[0] != '\0') {
+        codec_name = decoder_ctx->codec_name;
+    } else {
+        /* output avi tags */
+        if (decoder_ctx->codec_type == CODEC_TYPE_VIDEO) {
+            snprintf(buf1, sizeof(buf1), "%c%c%c%c",
+                    decoder_ctx->codec_tag & 0xff,
+                    (decoder_ctx->codec_tag >> 8) & 0xff,
+                    (decoder_ctx->codec_tag >> 16) & 0xff,
+                    (decoder_ctx->codec_tag >> 24) & 0xff);
+        } else {
+            snprintf(buf1, sizeof(buf1), "0x%04x", decoder_ctx->codec_tag);
+        }
+        codec_name = buf1;
+    }
+
+    return codec_name;
+}
+
+
+int qp_has_audio(qp_movie_context *movie_ctx)
+{
+    return get_audio_stream(movie_ctx->fmt_ctx) ? 1 : 0;
+}
+
+
+int qp_has_video(qp_movie_context *movie_ctx)
+{
+    return get_video_stream(movie_ctx->fmt_ctx) ? 1 : 0;
+}
+
+
+int qp_get_num_audio_channels(qp_movie_context *movie_ctx)
+{
+    AVCodecContext *decoder_ctx = NULL;
+
+    if (!qp_has_audio(movie_ctx)) {
+        return 0;
+    }
+
+    decoder_ctx = get_decoder_context(movie_ctx, CODEC_TYPE_AUDIO);
+    if (!decoder_ctx) {
+        return 0;
+    }
+
+    return decoder_ctx->channels;
+}
+
+
+int qp_get_codec_sample_rate(qp_movie_context *movie_ctx, int type)
+{
+    AVCodecContext *decoder_ctx = NULL;
+
+    decoder_ctx = get_decoder_context(movie_ctx, type);
+    if (!decoder_ctx) {
+        return 0;
+    }
+
+    return decoder_ctx->sample_rate;
+}
+
+/* Returns the bit rate for codec of type. */
+int qp_get_codec_bit_rate(qp_movie_context *movie_ctx, int type)
+{
+    AVCodecContext *decoder_ctx = NULL;
+
+    decoder_ctx = get_decoder_context(movie_ctx, type);
+    if (!decoder_ctx) {
+        return 0;
+    }
+
+    return decoder_ctx->bit_rate;
+}
+
+/*
+static int movie_get_buffer (AVCodecContext *context, AVFrame *picture)
+{
+    char *buf = NULL;
+    long bufsize = 0;
+    int width;
+    int height;
+
+    width = context->width;
+    height = context->height;
+
+    if (avcodec_check_dimensions(context, width, height)) {
+        return -1;
+    }
+
+    switch (context->codec_type) {
+        case CODEC_TYPE_VIDEO:
+            avcodec_align_dimensions (context, &width, &height);
+
+            bufsize = avpicture_get_size (context->pix_fmt, width, height);
+
+            if (width != context->width || height != context->height) {
+                context->width = width;
+                context->height = height;
+
+                return avcodec_default_get_buffer (context, picture);
+            }
+
+            buf = av_mallocz(bufsize);
+            //printf("get buffer %p\n", buf);
+
+            avpicture_fill((AVPicture *) picture, buf,
+                    context->pix_fmt, context->width, context->height);
+            break;
+        case CODEC_TYPE_AUDIO:
+        default:
+            //assert("movie_get_buffer: Not implemented for audio");
+            break;
+    }
+
+    // tell ffmpeg we own this buffer 
+    picture->type = FF_BUFFER_TYPE_USER;
+
+    return 0;
+}
+
+static void movie_release_buffer(AVCodecContext *context, AVFrame *picture)
+{
+    int i;
+    char *buf = NULL;
+
+    if (picture->type != FF_BUFFER_TYPE_USER) {
+        return;
+    }
+
+    buf = (char*) (picture->opaque);
+    if (buf == NULL) {
+        return;
+    }
+
+    av_free(buf);
+
+    picture->opaque = NULL;
+
+    // zero out the reference in ffmpeg
+    for (i = 0; i < 4; i++) {
+        picture->data[i] = NULL;
+        picture->linesize[i] = 0;
+    }
+}
+*/
+
+static void rewind_movie(qp_movie_context *movie_ctx) {
+    if (
+
+#if LIBAVFORMAT_BUILD >= 4619
+            av_seek_frame(movie_ctx->fmt_ctx, -1, 0, 0)
+#else 
+            av_seek_frame(movie_ctx->fmt_ctx, -1, 0)
+#endif
+            < 0) {
+        
+        /* If we can't seek, fall back to reopening the file. */
+        qp_open_movie_file(movie_ctx, qp_get_file_name(movie_ctx));
+    }
+    
+    movie_ctx->frame_number = 0; 
+}
+
+/* 
+ * get_av_frame()
+ *  Returns an av_frame from the movie
+ */
+static AVFrame* get_av_frame(qp_movie_context *movie_ctx, 
+        int wanted_frame, int *is_keyframe, int64_t *pts)
+{
+    AVCodecContext *decoder_ctx = NULL;
+    AVPacket packet;
+    AVFrame *frame = NULL;
+    int got_frame; 
+    int video_stream;
+
+    video_stream = get_stream_index(movie_ctx->fmt_ctx, 
+            CODEC_TYPE_VIDEO);
+    if (video_stream < 0) {
+        return NULL;
+    }
+ 
+    decoder_ctx = get_decoder_context(movie_ctx, CODEC_TYPE_VIDEO);
+    if (decoder_ctx == NULL) {
+        return NULL;
+    }
+
+    /* set buffer functions */
+    //decoder_ctx->get_buffer = movie_get_buffer;
+    //decoder_ctx->release_buffer = movie_release_buffer;
+
+    /* Rewind to the beginning of the stream if wanted frame already passed */
+    if (wanted_frame > 0 && wanted_frame <= movie_ctx->frame_number) {
+
+        rewind_movie(movie_ctx);
+
+        /* flush decoder buffers here */
+        avcodec_flush_buffers(decoder_ctx);
+    }
+
+    frame = avcodec_alloc_frame();
+    
+    /* read frames looking for wanted_frame */ 
+    while (av_read_frame(movie_ctx->fmt_ctx, &packet) >= 0) {
+       
+		/* hurry up if we're still a ways from the target frame */
+        if (wanted_frame != QP_GETFRAME_KEYFRAME &&
+                wanted_frame != QP_GETFRAME_NEXTFRAME &&
+                wanted_frame - movie_ctx->frame_number > 
+				decoder_ctx->gop_size + 1) {
+           decoder_ctx->hurry_up = 1;
+        } else {
+           decoder_ctx->hurry_up = 0;
+        }
+
+        if (packet.stream_index == video_stream) {
+        
+            avcodec_decode_video(decoder_ctx, frame, &got_frame,
+                    packet.data, packet.size);
+        
+            if (got_frame) {
+                movie_ctx->frame_number++; 
+                /* FIXME: 
+                 *        With the addition of the keyframe logic, this loop is 
+                 *        getting a little too tricky. wanted_frame is way 
+                 *        overloaded. Refactor to make clearer what is going on.
+                 */
+
+                /* 
+                 * if caller wants next keyframe then get it and break out of 
+                 * loop.
+                 */
+                if (wanted_frame == QP_GETFRAME_KEYFRAME && 
+                        (packet.flags & PKT_FLAG_KEY)) {
+                    /* free wanted frame packet */
+                    *is_keyframe = 1;
+                    *pts = packet.pts;
+                    av_free_packet(&packet);
+                    goto found_frame; 
+                }
+                
+                if (wanted_frame == QP_GETFRAME_NEXTFRAME || 
+                        movie_ctx->frame_number == wanted_frame) {
+                    /* free wanted frame packet */
+                    *is_keyframe = (packet.flags & PKT_FLAG_KEY);
+                    *pts = packet.pts;
+                    av_free_packet(&packet);
+                    goto found_frame; 
+                }
+            }
+        }
+
+        /* free the packet allocated by av_read_frame */
+        av_free_packet(&packet);
+    }
+
+    /* free av_frame struct. Buffers are managed by the codec context
+       and will be freed when the codec is closed */
+    free(frame);
+    return NULL;
+
+found_frame:
+    return frame;
+}
+
+
+int qp_get_frame(qp_movie_context *movie_ctx, int wanted_frame,
+        qp_frame_context **frame_ctx_handle) {
+    int is_keyframe = 0;
+    int64_t pts;
+    AVFrame *decoded_frame = NULL;
+    qp_frame_context *frame_ctx = NULL;
+
+    decoded_frame = get_av_frame(movie_ctx, wanted_frame, &is_keyframe, &pts);
+    if (!decoded_frame) {
+        fprintf(stderr, "Error getting av_frame\n");
+        return -1;
+    }
+
+    /* TODO: Create higher level function in qp_frame.c for this */
+    if (*frame_ctx_handle == NULL) {
+        *frame_ctx_handle = qp_alloc_frame_ctx(NULL);
+        if (*frame_ctx_handle == NULL) {
+            fprintf(stderr, "Error allocating frame context\n");
+            free(decoded_frame);
+            return -2;
+        }
+    }
+    
+    frame_ctx = *frame_ctx_handle;
+    
+    /* TODO: Provide function(s) for setting these in frame.c */
+    frame_ctx->width = qp_get_movie_width(movie_ctx);
+    frame_ctx->height = qp_get_movie_height(movie_ctx);
+    frame_ctx->pixel_format = get_format_number(movie_ctx, CODEC_TYPE_VIDEO);
+    frame_ctx->keyframe = is_keyframe;
+    frame_ctx->pts = pts;
+
+    frame_ctx->av_frame = avcodec_alloc_frame();
+    avpicture_alloc((AVPicture*)frame_ctx->av_frame, frame_ctx->pixel_format,
+            frame_ctx->width, frame_ctx->height);
+
+    /* 
+     * FIXME: temporary hack until I figure out how to pass new buffers 
+     * to the decoder 
+     */
+    img_copy((AVPicture*)frame_ctx->av_frame, 
+            (AVPicture *)decoded_frame, frame_ctx->pixel_format, 
+            frame_ctx->width, frame_ctx->height);
+
+    free(decoded_frame);
+
+    return 0;
+}
+
+
+/* 
+ * pre_read_frame()
+ * ffmpeg seems not to fill in some AVCodecContext fields until at least
+ * one frame is read. This function will read a frame without moving the
+ * frame counter.
+ */
+static void pre_read_frame(qp_movie_context *movie_ctx) {
+    AVFrame *frame = NULL;
+    int is_keyframe;
+    int64_t pts;
+
+    frame = get_av_frame(movie_ctx, QP_GETFRAME_NEXTFRAME, &is_keyframe, &pts);
+
+    // We only get called if frames haven't been read so we can just
+    // rewind once we're through
+    rewind_movie(movie_ctx);
+    if (frame) {
+        free(frame);
+    }
+}
+
+
+double qp_get_pixel_aspect_ratio(qp_movie_context *movie_ctx)
+{
+    AVCodecContext *decoder_ctx = NULL;
+
+    decoder_ctx = get_decoder_context(movie_ctx, CODEC_TYPE_VIDEO);
+    if (!decoder_ctx) {
+        return 0;
+    }
+
+    if (decoder_ctx->sample_aspect_ratio.num == 0 &&
+            movie_ctx->frame_number == 0) {
+        // pre read a frame so ffmpeg will fill in sample aspect ratio field.
+        pre_read_frame(movie_ctx);
+
+        if (decoder_ctx->sample_aspect_ratio.num == 0) {
+            return 0;
+        }
+    }
+
+    return av_q2d(decoder_ctx->sample_aspect_ratio);
+}
+
+
+// TODO: Make these fields in qp_movie_context struct
+//int16_t *movie_ctx->audio_samples;
+int audio_input_frame_size;
+
+
+int open_audio(qp_movie_context *movie_ctx, AVFormatContext *oc, AVStream *st)
+{
+    AVCodecContext *c;
+    AVCodec *codec;
+
+    c = st->codec;
+
+    /* find the audio encoder */
+    codec = avcodec_find_encoder(c->codec_id);
+    if (!codec) {
+        fprintf(stderr, "codec not found\n");
+        return 1;
+    }
+
+    /* open it */
+    if (avcodec_open(c, codec) < 0) {
+        fprintf(stderr, "could not open codec\n");
+        return 2;
+    }
+
+    movie_ctx->audio_outbuf_size = 4 * MAX_AUDIO_PACKET_SIZE;
+    movie_ctx->audio_outbuf = (uint8_t *)malloc(movie_ctx->audio_outbuf_size);
+
+    /* ugly hack for PCM codecs (will be removed ASAP with new PCM
+       support to compute the input frame size in movie_ctx->audio_samples */
+    if (c->frame_size <= 1) {
+        audio_input_frame_size = movie_ctx->audio_outbuf_size / c->channels;
+        switch(st->codec->codec_id) {
+        case CODEC_ID_PCM_S16LE:
+        case CODEC_ID_PCM_S16BE:
+        case CODEC_ID_PCM_U16LE:
+        case CODEC_ID_PCM_U16BE:
+            audio_input_frame_size >>= 1;
+            break;
+        default:
+            break;
+        }
+    } else {
+        audio_input_frame_size = c->frame_size;
+    }
+    movie_ctx->audio_samples = (int16_t *)malloc(audio_input_frame_size * 2 * c->channels);
+    return 0;
+}
+
+
+
+int write_audio_frame(qp_movie_context *movie_ctx, AVFormatContext *oc, 
+        AVStream *st)
+{
+    AVCodecContext *c;
+    AVPacket pkt;
+    av_init_packet(&pkt);
+
+    c = st->codec;
+
+    pkt.size = avcodec_encode_audio(c, movie_ctx->audio_outbuf, 
+            movie_ctx->audio_outbuf_size, (short *)movie_ctx->audio_samples);
+
+    pkt.pts= av_rescale_q(c->coded_frame->pts, c->time_base, st->time_base);
+    pkt.flags |= PKT_FLAG_KEY;
+    pkt.stream_index= st->index;
+    pkt.data= movie_ctx->audio_outbuf;
+
+    /* write the compressed frame in the media file */
+    if (av_write_frame(oc, &pkt) != 0) {
+        fprintf(stderr, "Error while writing audio frame\n");
+        return 2;
+    }
+    return 0;
+}
+
+/*
+ * add an audio output stream
+ */
+AVStream *add_audio_stream(AVCodecContext *icodec,
+        AVFormatContext *oc, int codec_id)
+{
+    AVCodecContext *c;
+    AVStream *st;
+
+    st = av_new_stream(oc, 1);
+    if (!st) {
+        fprintf(stderr, "Could not alloc stream\n");
+        return NULL;
+    }
+
+    c = st->codec;
+    c->codec_id = codec_id;
+    c->codec_type = CODEC_TYPE_AUDIO;
+
+    /* put sample parameters */
+    c->bit_rate = icodec->bit_rate;
+    c->sample_rate = icodec->sample_rate;
+    c->channels = icodec->channels;
+    return st;
+}
+
+
+/* add a video output stream */
+static AVStream *add_video_stream(qp_movie_context *movie_ctx,
+        AVFormatContext *oc, int codec_id)
+{
+    AVCodecContext *c;
+    AVStream *st;
+
+    st = av_new_stream(oc, 0);
+    if (!st) {
+        fprintf(stderr, "Could not alloc stream\n");
+        return NULL;
+    }
+
+    c = st->codec;
+    c->codec_id = codec_id;
+    c->codec_type = CODEC_TYPE_VIDEO;
+
+    /* put sample parameters */
+    // TODO: This should be input video stream bitrate not total bit rate
+    c->bit_rate = qp_get_bit_rate(movie_ctx);
+    /* resolution must be a multiple of two */
+    c->width = qp_get_movie_width(movie_ctx);
+    c->height = qp_get_movie_height(movie_ctx);
+    /* time base: this is the fundamental unit of time (in seconds) in terms
+       of which frame timestamps are represented. for fixed-fps content,
+       timebase should be 1/framerate and timestamp increments should be
+       identically 1. */
+    //c->time_base.den = STREAM_FRAME_RATE;
+    // TODO: Should probably just pass num/den from decoder ctx
+    c->time_base.den = qp_get_frame_rate(movie_ctx);
+    c->time_base.num = 1;
+
+    c->gop_size = 12; /* emit one intra frame every twelve frames at most */
+    c->pix_fmt = PIX_FMT_YUV420P;
+    if (c->codec_id == CODEC_ID_MPEG2VIDEO) {
+        /* just for testing, we also add B frames */
+        c->max_b_frames = 2;
+    }
+    if (c->codec_id == CODEC_ID_MPEG1VIDEO){
+        /* needed to avoid using macroblocks in which some coeffs overflow
+           this doesnt happen with normal video, it just happens here as the
+           motion of the chroma plane doesnt match the luma plane */
+        c->mb_decision=2;
+    }
+    // some formats want stream headers to be seperate
+    if (!strcmp(oc->oformat->name, "mp4") || 
+            !strcmp(oc->oformat->name, "mov") || 
+            !strcmp(oc->oformat->name, "3gp")) {
+        c->flags |= CODEC_FLAG_GLOBAL_HEADER;
+    }
+
+    return st;
+}
+
+
+AVFrame *alloc_picture(int pix_fmt, int width, int height)
+{
+    AVFrame *picture;
+    uint8_t *picture_buf;
+    int size;
+
+    picture = avcodec_alloc_frame();
+    if (!picture)
+        return NULL;
+    size = avpicture_get_size(pix_fmt, width, height);
+    picture_buf = (uint8_t *)malloc(size);
+    if (!picture_buf) {
+        av_free(picture);
+        return NULL;
+    }
+    avpicture_fill((AVPicture *)picture, picture_buf,
+                   pix_fmt, width, height);
+    return picture;
+}
+
+
+static int write_video_frame(qp_movie_context *movie_ctx, AVFormatContext *oc, 
+        AVStream *st, AVFrame *decoded_frame, int pixel_format)
+{
+    int out_size, ret;
+    AVCodecContext *c;
+
+    c = st->codec;
+
+    // encode the image
+    out_size = avcodec_encode_video(c, movie_ctx->video_outbuf, movie_ctx->video_outbuf_size, decoded_frame);
+    // if zero size, it means the image was buffered
+    if (out_size > 0) {
+        AVPacket pkt;
+        av_init_packet(&pkt);
+
+        pkt.pts= av_rescale_q(c->coded_frame->pts, c->time_base, st->time_base);
+        if (c->coded_frame->key_frame) {
+            pkt.flags |= PKT_FLAG_KEY;
+        }
+        pkt.stream_index= st->index;
+        pkt.data= movie_ctx->video_outbuf;
+        pkt.size= out_size;
+
+        // write the compressed frame in the media file 
+        ret = av_write_frame(oc, &pkt);
+    } else {
+        ret = 0;
+    }
+    if (ret != 0) {
+        fprintf(stderr, "Error while writing video frame\n");
+    }
+    return ret;
+}
+
+
+static void close_audio(qp_movie_context *movie_ctx, AVFormatContext *oc, 
+        AVStream *st)
+{
+    avcodec_close(st->codec);
+
+    av_free(movie_ctx->audio_samples);
+    av_free(movie_ctx->audio_outbuf);
+}
+
+
+int qp_export_movie(qp_movie_context *movie_ctx, const char *filename)
+{
+    AVFrame *decoded_frame = NULL;
+    AVPacket packet;
+    AVCodecContext *video_decoder_ctx = NULL;
+    AVCodecContext *audio_decoder_ctx = NULL;
+    AVCodec *video_codec = NULL;
+    //AVCodec *input_audio_codec = NULL;
+    AVOutputFormat *fmt = NULL;
+    AVFormatContext *oc = NULL;
+    AVStream *video_st = NULL;
+    AVStream *audio_st = NULL;
+    int video_stream_index = -1;
+    int audio_stream_index = -1;
+    int i;
+    int got_frame;
+
+    /* auto detect the output format from the name. default is mpeg. */
+    fmt = guess_format(NULL, filename, NULL);
+    if (!fmt) {
+        printf("Could not deduce output format from file extension: using MPEG.\n");
+        fmt = guess_format("mpeg", NULL, NULL);
+    }
+    if (!fmt) {
+        fprintf(stderr, "Could not find suitable output format\n");
+        return 1;
+    }
+
+    /* allocate the output media context */
+    oc = av_alloc_format_context();
+    if (!oc) {
+        fprintf(stderr, "Memory error\n");
+        return 2;
+    }
+    oc->oformat = fmt;
+    snprintf(oc->filename, sizeof(oc->filename), "%s", filename);
+
+    // add the audio and video streams using the default format codecs
+    // and initialize the codecs 
+
+    // create a video stream if the input has a video stream and the
+    // output format supports video
+    if (fmt->video_codec != CODEC_ID_NONE && qp_has_video(movie_ctx)) {
+        video_stream_index = get_stream_index(movie_ctx->fmt_ctx,
+                CODEC_TYPE_VIDEO);
+        if (video_stream_index < 0) {
+            fprintf(stderr, "can't find video stream index\n");
+            return 3;
+        }
+ 
+        video_st = add_video_stream(movie_ctx, oc, fmt->video_codec);
+        video_decoder_ctx = get_decoder_context(movie_ctx, CODEC_TYPE_VIDEO);
+    }
+
+    // create a audio stream if the input has a audio stream and the
+    // output format supports audio
+    if (fmt->audio_codec != CODEC_ID_NONE && qp_has_audio(movie_ctx)) {
+        audio_stream_index = get_stream_index(movie_ctx->fmt_ctx,
+                CODEC_TYPE_AUDIO);
+        if (audio_stream_index < 0) {
+            fprintf(stderr, "can't find audio stream index\n");
+            return 4;
+        }
+        audio_st = add_audio_stream(movie_ctx->fmt_ctx->streams[audio_stream_index]->codec, oc, fmt->audio_codec);
+        audio_decoder_ctx = get_decoder_context(movie_ctx, CODEC_TYPE_AUDIO);
+    }
+
+    /* set the output parameters (must be done even if no parameters). */
+    if (av_set_parameters(oc, NULL) < 0) {
+        fprintf(stderr, "Invalid output format parameters\n");
+        return 5;
+    }
+
+    //dump_format(oc, 0, filename, 1);
+
+    /* now that all the parameters are set, we can open the audio and
+       video codecs and allocate the necessary encode buffers */
+
+    /* find the video encoder */
+    // TODO: Might have to do the default codec thing here
+    if (video_st) {
+        video_codec = avcodec_find_encoder(video_st->codec->codec_id);
+        if (!video_codec) {
+            fprintf(stderr, "codec not found\n");
+            return 6;
+        }
+
+        /* open the codec */
+        if (avcodec_open(video_st->codec, video_codec) < 0) {
+            fprintf(stderr, "could not open codec\n");
+            return 7;
+        }
+
+        movie_ctx->video_outbuf = NULL;
+        // TODO: need to correctly handle raw picture as in
+        // output_example.c
+        if (!(oc->oformat->flags & AVFMT_RAWPICTURE)) {
+            /* allocate output buffer */
+            /* XXX: API change will be done */
+            movie_ctx->video_outbuf_size = 200000;
+            movie_ctx->video_outbuf = (uint8_t *)malloc(movie_ctx->video_outbuf_size);
+        }
+    } 
+
+    if (audio_st) {
+        open_audio(movie_ctx, oc, audio_st);
+    }
+
+    /* open the output file, if needed */
+    if (!(fmt->flags & AVFMT_NOFILE)) {
+        if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
+            fprintf(stderr, "Could not open '%s'\n", filename);
+            return 9;
+        }
+    }
+
+    /* write the stream header, if any */
+    av_write_header(oc);
+
+    rewind_movie(movie_ctx);
+
+    decoded_frame = avcodec_alloc_frame();
+    
+    while (av_read_frame(movie_ctx->fmt_ctx, &packet) >= 0) {
+        if (packet.stream_index == video_stream_index && video_st) {
+
+            avcodec_decode_video(video_decoder_ctx, decoded_frame, 
+                    &got_frame, packet.data, packet.size);
+
+            if (got_frame) {
+
+                // TODO: this allocates a new frame buffer for each frame
+                // conversion which is way inefficient.
+                qp_convert_av_frame(&decoded_frame, 
+                        get_format_number(movie_ctx, CODEC_TYPE_VIDEO),
+                                PIX_FMT_YUV420P, 
+                                qp_get_movie_width(movie_ctx), 
+                                qp_get_movie_height(movie_ctx), 0);
+
+                // TODO: Allow resizing movie during export
+                //qp_resample_frame();
+
+                /* write interleaved audio and video frames */
+                write_video_frame(movie_ctx, oc, video_st, decoded_frame, 
+                        get_format_number(movie_ctx, CODEC_TYPE_VIDEO));
+            }
+        } else if (packet.stream_index == audio_stream_index && audio_st) {
+            int out_size = 0;
+
+            movie_ctx->audio_samples = 
+                av_fast_realloc(movie_ctx->audio_samples, 
+                        &movie_ctx->audio_samples_size, 
+                        MAX(packet.size, AVCODEC_MAX_AUDIO_FRAME_SIZE));
+
+            avcodec_decode_audio(audio_decoder_ctx, 
+                    movie_ctx->audio_samples, &out_size, packet.data, 
+                    packet.size);
+           
+            if (out_size > 0) {
+                write_audio_frame(movie_ctx, oc, audio_st);
+            }
+        } else {
+            // nop
+        }
+
+        /* free the packet allocated by av_read_frame */
+        av_free_packet(&packet);
+    }
+
+    /* close each codec */
+    if (video_st) {
+        avcodec_close(video_st->codec);
+        av_free(decoded_frame->data[0]);
+        av_free(decoded_frame);
+        av_free(movie_ctx->video_outbuf);
+    }
+
+    if (audio_st) {
+        close_audio(movie_ctx, oc, audio_st);
+    }
+
+    /* write the trailer, if any */
+    av_write_trailer(oc);
+
+    /* free the streams */
+    for (i = 0; i < oc->nb_streams; i++) {
+        av_freep(&oc->streams[i]);
+    }
+
+    if (!(fmt->flags & AVFMT_NOFILE)) {
+        /* close the output file */
+        url_fclose(&oc->pb);
+    }
+
+    /* free the stream */
+    av_free(oc);
+
+    return 0;
+}