@@ -14,6 +14,7 @@ version next:

 - astreamsync audio filter

 - amerge audio filter

 - GSM audio parser

+- SMJPEG muxer

 - Automatic thread count based on detection number of (available) CPU cores

 - y41p Brooktree Uncompressed 4:1:1 12-bit encoder and decoder

 - ffprobe -show_error option

@@ -159,8 +159,7 @@ static float dts_delta_threshold = 10;

 static int print_stats = 1;

 static uint8_t *audio_buf;

-static uint8_t *audio_out;

-static unsigned int allocated_audio_out_size, allocated_audio_buf_size;

+static unsigned int allocated_audio_buf_size;

 #define DEFAULT_PASS_LOGFILENAME_PREFIX "av2pass"

@@ -225,6 +224,7 @@ typedef struct OutputStream {

     AVBitStreamFilterContext *bitstream_filters;

     AVCodec *enc;

     int64_t max_frames;

+    AVFrame *output_frame;

     /* video only */

     int video_resample;

@@ -767,6 +767,13 @@ void exit_program(int ret)

         }

         output_streams[i].bitstream_filters = NULL;

+        if (output_streams[i].output_frame) {

+            AVFrame *frame = output_streams[i].output_frame;

+            if (frame->extended_data != frame->data)

+                av_freep(&frame->extended_data);

+            av_freep(&frame);

+        }

+

 #if CONFIG_AVFILTER

         av_freep(&output_streams[i].avfilter);

 #endif

@@ -792,8 +799,7 @@ void exit_program(int ret)

     uninit_opts();

     av_free(audio_buf);

-    av_free(audio_out);

-    allocated_audio_buf_size = allocated_audio_out_size = 0;

+    allocated_audio_buf_size = 0;

 #if CONFIG_AVFILTER

     avfilter_uninit();

@@ -957,18 +963,75 @@ static void generate_silence(uint8_t* buf, enum AVSampleFormat sample_fmt, size_

     memset(buf, fill_char, size);

 }

+static int encode_audio_frame(AVFormatContext *s, OutputStream *ost,

+                              const uint8_t *buf, int buf_size)

+{

+    AVCodecContext *enc = ost->st->codec;

+    AVFrame *frame = NULL;

+    AVPacket pkt;

+    int ret, got_packet;

+

+    av_init_packet(&pkt);

+    pkt.data = NULL;

+    pkt.size = 0;

+

+    if (buf) {

+        if (!ost->output_frame) {

+            ost->output_frame = avcodec_alloc_frame();

+            if (!ost->output_frame) {

+                av_log(NULL, AV_LOG_FATAL, "out-of-memory in encode_audio_frame()\n");

+                exit_program(1);

+            }

+        }

+        frame = ost->output_frame;

+        if (frame->extended_data != frame->data)

+            av_freep(&frame->extended_data);

+        avcodec_get_frame_defaults(frame);

+

+        frame->nb_samples  = buf_size /

+                             (enc->channels * av_get_bytes_per_sample(enc->sample_fmt));

+        if ((ret = avcodec_fill_audio_frame(frame, enc->channels, enc->sample_fmt,

+                                            buf, buf_size, 1)) < 0) {

+            av_log(NULL, AV_LOG_FATAL, "Audio encoding failed\n");

+            exit_program(1);

+        }

+    }

+

+    got_packet = 0;

+    if (avcodec_encode_audio2(enc, &pkt, frame, &got_packet) < 0) {

+        av_log(NULL, AV_LOG_FATAL, "Audio encoding failed\n");

+        exit_program(1);

+    }

+

+    if (got_packet) {

+        pkt.stream_index = ost->index;

+        if (pkt.pts != AV_NOPTS_VALUE)

+            pkt.pts      = av_rescale_q(pkt.pts,      enc->time_base, ost->st->time_base);

+        if (pkt.duration > 0)

+            pkt.duration = av_rescale_q(pkt.duration, enc->time_base, ost->st->time_base);

+

+        write_frame(s, &pkt, ost);

+

+        audio_size += pkt.size;

+    }

+

+    if (frame)

+        ost->sync_opts += frame->nb_samples;

+

+    return pkt.size;

+}

+

 static void do_audio_out(AVFormatContext *s, OutputStream *ost,

                          InputStream *ist, AVFrame *decoded_frame)

 {

     uint8_t *buftmp;

-    int64_t audio_out_size, audio_buf_size;

+    int64_t audio_buf_size;

-    int size_out, frame_bytes, ret, resample_changed;

+    int size_out, frame_bytes, resample_changed;

     AVCodecContext *enc = ost->st->codec;

     AVCodecContext *dec = ist->st->codec;

     int osize = av_get_bytes_per_sample(enc->sample_fmt);

     int isize = av_get_bytes_per_sample(dec->sample_fmt);

-    const int coded_bps = av_get_bits_per_sample(enc->codec->id);

     uint8_t *buf = decoded_frame->data[0];

     int size     = decoded_frame->nb_samples * dec->channels * isize;

     int64_t allocated_for_size = size;

@@ -980,19 +1043,13 @@ need_realloc:

     audio_buf_size  = FFMAX(audio_buf_size, enc->frame_size);

     audio_buf_size *= osize * enc->channels;

-    audio_out_size = FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);

-    if (coded_bps > 8 * osize)

-        audio_out_size = audio_out_size * coded_bps / (8*osize);

-    audio_out_size += FF_MIN_BUFFER_SIZE;

-

-    if (audio_out_size > INT_MAX || audio_buf_size > INT_MAX) {

+    if (audio_buf_size > INT_MAX) {

         av_log(NULL, AV_LOG_FATAL, "Buffer sizes too large\n");

         exit_program(1);

     }

     av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);

-    av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);

-    if (!audio_buf || !audio_out) {

+    if (!audio_buf) {

         av_log(NULL, AV_LOG_FATAL, "Out of memory in do_audio_out\n");

         exit_program(1);

     }

@@ -1130,7 +1187,7 @@ need_realloc:

     }

     /* now encode as many frames as possible */

-    if (enc->frame_size > 1) {

+    if (!(enc->codec->capabilities & CODEC_CAP_VARIABLE_FRAME_SIZE)) {

         /* output resampled raw samples */

         if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {

             av_log(NULL, AV_LOG_FATAL, "av_fifo_realloc2() failed\n");

@@ -1141,62 +1198,11 @@ need_realloc:

         frame_bytes = enc->frame_size * osize * enc->channels;

         while (av_fifo_size(ost->fifo) >= frame_bytes) {

-            AVPacket pkt;

-            av_init_packet(&pkt);

-

             av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);

-

-            // FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()

-

-            ret = avcodec_encode_audio(enc, audio_out, audio_out_size,

-                                       (short *)audio_buf);

-            if (ret < 0) {

-                av_log(NULL, AV_LOG_FATAL, "Audio encoding failed\n");

-                exit_program(1);

-            }

-            audio_size += ret;

-            pkt.stream_index = ost->index;

-            pkt.data = audio_out;

-            pkt.size = ret;

-            if (enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)

-                pkt.pts = av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);

-            pkt.flags |= AV_PKT_FLAG_KEY;

-            write_frame(s, &pkt, ost);

-

-            ost->sync_opts += enc->frame_size;

+            encode_audio_frame(s, ost, audio_buf, frame_bytes);

         }

     } else {

-        AVPacket pkt;

-        av_init_packet(&pkt);

-

-        ost->sync_opts += size_out / (osize * enc->channels);

-

-        /* output a pcm frame */

-        /* determine the size of the coded buffer */

-        size_out /= osize;

-        if (coded_bps)

-            size_out = size_out * coded_bps / 8;

-

-        if (size_out > audio_out_size) {

-            av_log(NULL, AV_LOG_FATAL, "Internal error, buffer size too small\n");

-            exit_program(1);

-        }

-

-        // FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()

-        ret = avcodec_encode_audio(enc, audio_out, size_out,

-                                   (short *)buftmp);

-        if (ret < 0) {

-            av_log(NULL, AV_LOG_FATAL, "Audio encoding failed\n");

-            exit_program(1);

-        }

-        audio_size += ret;

-        pkt.stream_index = ost->index;

-        pkt.data = audio_out;

-        pkt.size = ret;

-        if (enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)

-            pkt.pts = av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);

-        pkt.flags |= AV_PKT_FLAG_KEY;

-        write_frame(s, &pkt, ost);

+        encode_audio_frame(s, ost, buftmp, size_out);

     }

 }

@@ -1692,6 +1698,7 @@ static void flush_encoders(OutputStream *ost_table, int nb_ostreams)

         OutputStream   *ost = &ost_table[i];

         AVCodecContext *enc = ost->st->codec;

         AVFormatContext *os = output_files[ost->file_index].ctx;

+        int stop_encoding = 0;

         if (!ost->encoding_needed)

             continue;

@@ -1705,41 +1712,35 @@ static void flush_encoders(OutputStream *ost_table, int nb_ostreams)

             AVPacket pkt;

             int fifo_bytes;

             av_init_packet(&pkt);

-            pkt.stream_index = ost->index;

+            pkt.data = NULL;

+            pkt.size = 0;

             switch (ost->st->codec->codec_type) {

             case AVMEDIA_TYPE_AUDIO:

                 fifo_bytes = av_fifo_size(ost->fifo);

-                ret = 0;

-                /* encode any samples remaining in fifo */

                 if (fifo_bytes > 0) {

-                    int osize = av_get_bytes_per_sample(enc->sample_fmt);

-                    int fs_tmp = enc->frame_size;

+                    /* encode any samples remaining in fifo */

+                    int frame_bytes = fifo_bytes;

                     av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);

-                    if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {

-                        enc->frame_size = fifo_bytes / (osize * enc->channels);

-                    } else { /* pad */

-                        int frame_bytes = enc->frame_size*osize*enc->channels;

+

+                    /* pad last frame with silence if needed */

+                    if (!(enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME)) {

+                        frame_bytes = enc->frame_size * enc->channels *

+                                      av_get_bytes_per_sample(enc->sample_fmt);

                         if (allocated_audio_buf_size < frame_bytes)

                             exit_program(1);

                         generate_silence(audio_buf+fifo_bytes, enc->sample_fmt, frame_bytes - fifo_bytes);

                     }

-

-                    ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf);

-                    pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,

-                                              ost->st->time_base.num, enc->sample_rate);

-                    enc->frame_size = fs_tmp;

-                }

-                if (ret <= 0) {

-                    ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);

-                }

-                if (ret < 0) {

-                    av_log(NULL, AV_LOG_FATAL, "Audio encoding failed\n");

-                    exit_program(1);

+                    encode_audio_frame(os, ost, audio_buf, frame_bytes);

+                } else {

+                    /* flush encoder with NULL frames until it is done

+                       returning packets */

+                    if (encode_audio_frame(os, ost, NULL, 0) == 0) {

+                        stop_encoding = 1;

+                        break;

+                    }

                 }

-                audio_size += ret;

-                pkt.flags  |= AV_PKT_FLAG_KEY;

                 break;

             case AVMEDIA_TYPE_VIDEO:

                 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);

@@ -1753,18 +1754,22 @@ static void flush_encoders(OutputStream *ost_table, int nb_ostreams)

                 if (ost->logfile && enc->stats_out) {

                     fprintf(ost->logfile, "%s", enc->stats_out);

                 }

+                if (ret <= 0) {

+                    stop_encoding = 1;

+                    break;

+                }

+                pkt.stream_index = ost->index;

+                pkt.data = bit_buffer;

+                pkt.size = ret;

+                if (enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)

+                    pkt.pts = av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);

+                write_frame(os, &pkt, ost);

                 break;

             default:

-                ret = -1;

+                stop_encoding = 1;

             }

-

-            if (ret <= 0)

+            if (stop_encoding)

                 break;

-            pkt.data = bit_buffer;

-            pkt.size = ret;

-            if (enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)

-                pkt.pts = av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);

-            write_frame(os, &pkt, ost);

         }

     }

 }

@@ -13,6 +13,14 @@ libavutil:   2011-04-18

 API changes, most recent first:

+2012-xx-xx - lavc 53.34.0

+  New audio encoding API:

+  xxxxxxx Add CODEC_CAP_VARIABLE_FRAME_SIZE capability for use by audio

+          encoders.

+  xxxxxxx Add avcodec_fill_audio_frame() as a convenience function.

+  xxxxxxx Add avcodec_encode_audio2() and deprecate avcodec_encode_audio().

+          Add AVCodec.encode2().

+

 2012-01-xx - xxxxxxx - lavfi 2.15.0

   Add a new installed header -- libavfilter/version.h -- with version macros.

@@ -317,7 +317,7 @@ library:

     @tab Used in Sierra CD-ROM games.

 @item Smacker                   @tab   @tab X

     @tab Multimedia format used by many games.

-@item SMJPEG                    @tab   @tab X

+@item SMJPEG                    @tab X @tab X

     @tab Used in certain Loki game ports.

 @item Sony OpenMG (OMA)         @tab X @tab X

     @tab Audio format used in Sony Sonic Stage and Sony Vegas.

@@ -176,8 +176,7 @@ static float dts_delta_threshold = 10;

 static int print_stats = 1;

 static uint8_t *audio_buf;

-static uint8_t *audio_out;

-static unsigned int allocated_audio_out_size, allocated_audio_buf_size;

+static unsigned int allocated_audio_buf_size;

 static uint8_t *input_tmp= NULL;

@@ -245,6 +244,7 @@ typedef struct OutputStream {

     AVBitStreamFilterContext *bitstream_filters;

     AVCodec *enc;

     int64_t max_frames;

+    AVFrame *output_frame;

     /* video only */

     int video_resample;

@@ -825,6 +825,13 @@ void av_noreturn exit_program(int ret)

             bsfc = next;

         }

         output_streams[i].bitstream_filters = NULL;

+

+        if (output_streams[i].output_frame) {

+            AVFrame *frame = output_streams[i].output_frame;

+            if (frame->extended_data != frame->data)

+                av_freep(&frame->extended_data);

+            av_freep(&frame);

+        }

     }

     for (i = 0; i < nb_input_files; i++) {

         avformat_close_input(&input_files[i].ctx);

@@ -847,8 +854,7 @@ void av_noreturn exit_program(int ret)

     uninit_opts();

     av_free(audio_buf);

-    av_free(audio_out);

-    allocated_audio_buf_size = allocated_audio_out_size = 0;

+    allocated_audio_buf_size = 0;

 #if CONFIG_AVFILTER

     avfilter_uninit();

@@ -1016,18 +1022,75 @@ static void generate_silence(uint8_t* buf, enum AVSampleFormat sample_fmt, size_

     memset(buf, fill_char, size);

 }

+static int encode_audio_frame(AVFormatContext *s, OutputStream *ost,

+                              const uint8_t *buf, int buf_size)

+{

+    AVCodecContext *enc = ost->st->codec;

+    AVFrame *frame = NULL;

+    AVPacket pkt;

+    int ret, got_packet;

+

+    av_init_packet(&pkt);

+    pkt.data = NULL;

+    pkt.size = 0;

+

+    if (buf) {

+        if (!ost->output_frame) {

+            ost->output_frame = avcodec_alloc_frame();

+            if (!ost->output_frame) {

+                av_log(NULL, AV_LOG_FATAL, "out-of-memory in encode_audio_frame()\n");

+                exit_program(1);

+            }

+        }

+        frame = ost->output_frame;

+        if (frame->extended_data != frame->data)

+            av_freep(&frame->extended_data);

+        avcodec_get_frame_defaults(frame);

+

+        frame->nb_samples  = buf_size /

+                             (enc->channels * av_get_bytes_per_sample(enc->sample_fmt));

+        if ((ret = avcodec_fill_audio_frame(frame, enc->channels, enc->sample_fmt,

+                                            buf, buf_size, 1)) < 0) {

+            av_log(NULL, AV_LOG_FATAL, "Audio encoding failed\n");

+            exit_program(1);

+        }

+    }

+

+    got_packet = 0;

+    if (avcodec_encode_audio2(enc, &pkt, frame, &got_packet) < 0) {

+        av_log(NULL, AV_LOG_FATAL, "Audio encoding failed\n");

+        exit_program(1);

+    }

+

+    if (got_packet) {

+        pkt.stream_index = ost->index;

+        if (pkt.pts != AV_NOPTS_VALUE)

+            pkt.pts      = av_rescale_q(pkt.pts,      enc->time_base, ost->st->time_base);

+        if (pkt.duration > 0)

+            pkt.duration = av_rescale_q(pkt.duration, enc->time_base, ost->st->time_base);

+

+        write_frame(s, &pkt, ost);

+

+        audio_size += pkt.size;

+    }

+

+    if (frame)

+        ost->sync_opts += frame->nb_samples;

+

+    return pkt.size;

+}

+

 static void do_audio_out(AVFormatContext *s, OutputStream *ost,

                          InputStream *ist, AVFrame *decoded_frame)

 {

     uint8_t *buftmp;

-    int64_t audio_out_size, audio_buf_size, size_out;

+    int64_t audio_buf_size, size_out;

-    int frame_bytes, ret, resample_changed;

+    int frame_bytes, resample_changed;

     AVCodecContext *enc = ost->st->codec;

     AVCodecContext *dec = ist->st->codec;

     int osize = av_get_bytes_per_sample(enc->sample_fmt);

     int isize = av_get_bytes_per_sample(dec->sample_fmt);

-    const int coded_bps = av_get_bits_per_sample(enc->codec->id);

     uint8_t *buf = decoded_frame->data[0];

     int size     = decoded_frame->nb_samples * dec->channels * isize;

     int64_t allocated_for_size = size;

@@ -1039,19 +1102,13 @@ need_realloc:

     audio_buf_size  = FFMAX(audio_buf_size, enc->frame_size);

     audio_buf_size *= osize * enc->channels;

-    audio_out_size = FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);

-    if (coded_bps > 8 * osize)

-        audio_out_size = audio_out_size * coded_bps / (8*osize);

-    audio_out_size += FF_MIN_BUFFER_SIZE;

-

-    if (audio_out_size > INT_MAX || audio_buf_size > INT_MAX) {

+    if (audio_buf_size > INT_MAX) {

         av_log(NULL, AV_LOG_FATAL, "Buffer sizes too large\n");

         exit_program(1);

     }

     av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);

-    av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);

-    if (!audio_buf || !audio_out) {

+    if (!audio_buf) {

         av_log(NULL, AV_LOG_FATAL, "Out of memory in do_audio_out\n");

         exit_program(1);

     }

@@ -1180,7 +1237,7 @@ need_realloc:

     av_assert0(ost->audio_resample || dec->sample_fmt==enc->sample_fmt);

     /* now encode as many frames as possible */

-    if (enc->frame_size > 1) {

+    if (!(enc->codec->capabilities & CODEC_CAP_VARIABLE_FRAME_SIZE)) {

         /* output resampled raw samples */

         if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {

             av_log(NULL, AV_LOG_FATAL, "av_fifo_realloc2() failed\n");

@@ -1191,62 +1248,11 @@ need_realloc:

         frame_bytes = enc->frame_size * osize * enc->channels;

         while (av_fifo_size(ost->fifo) >= frame_bytes) {

-            AVPacket pkt;

-            av_init_packet(&pkt);

-

             av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);

-

-            // FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()

-

-            ret = avcodec_encode_audio(enc, audio_out, audio_out_size,

-                                       (short *)audio_buf);

-            if (ret < 0) {

-                av_log(NULL, AV_LOG_FATAL, "Audio encoding failed\n");

-                exit_program(1);

-            }

-            audio_size += ret;

-            pkt.stream_index = ost->index;

-            pkt.data = audio_out;

-            pkt.size = ret;

-            if (enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)

-                pkt.pts = av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);

-            pkt.flags |= AV_PKT_FLAG_KEY;

-            write_frame(s, &pkt, ost);

-

-            ost->sync_opts += enc->frame_size;

+            encode_audio_frame(s, ost, audio_buf, frame_bytes);

         }

     } else {

-        AVPacket pkt;

-        av_init_packet(&pkt);

-

-        ost->sync_opts += size_out / (osize * enc->channels);

-

-        /* output a pcm frame */

-        /* determine the size of the coded buffer */

-        size_out /= osize;

-        if (coded_bps)

-            size_out = size_out * coded_bps / 8;

-

-        if (size_out > audio_out_size) {

-            av_log(NULL, AV_LOG_FATAL, "Internal error, buffer size too small\n");

-            exit_program(1);

-        }

-

-        // FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()

-        ret = avcodec_encode_audio(enc, audio_out, size_out,

-                                   (short *)buftmp);

-        if (ret < 0) {

-            av_log(NULL, AV_LOG_FATAL, "Audio encoding failed\n");

-            exit_program(1);

-        }

-        audio_size += ret;

-        pkt.stream_index = ost->index;

-        pkt.data = audio_out;

-        pkt.size = ret;

-        if (enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)

-            pkt.pts = av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);

-        pkt.flags |= AV_PKT_FLAG_KEY;

-        write_frame(s, &pkt, ost);

+        encode_audio_frame(s, ost, buftmp, size_out);

     }

 }

@@ -1743,6 +1749,7 @@ static void flush_encoders(OutputStream *ost_table, int nb_ostreams)

         OutputStream   *ost = &ost_table[i];

         AVCodecContext *enc = ost->st->codec;

         AVFormatContext *os = output_files[ost->file_index].ctx;

+        int stop_encoding = 0;

         if (!ost->encoding_needed)

             continue;

@@ -1756,41 +1763,35 @@ static void flush_encoders(OutputStream *ost_table, int nb_ostreams)

             AVPacket pkt;

             int fifo_bytes;

             av_init_packet(&pkt);

-            pkt.stream_index = ost->index;

+            pkt.data = NULL;

+            pkt.size = 0;

             switch (ost->st->codec->codec_type) {

             case AVMEDIA_TYPE_AUDIO:

                 fifo_bytes = av_fifo_size(ost->fifo);

-                ret = 0;

-                /* encode any samples remaining in fifo */

                 if (fifo_bytes > 0) {

-                    int osize = av_get_bytes_per_sample(enc->sample_fmt);

-                    int fs_tmp = enc->frame_size;

+                    /* encode any samples remaining in fifo */

+                    int frame_bytes = fifo_bytes;

                     av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);

-                    if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {

-                        enc->frame_size = fifo_bytes / (osize * enc->channels);

-                    } else { /* pad */

-                        int frame_bytes = enc->frame_size*osize*enc->channels;

+

+                    /* pad last frame with silence if needed */

+                    if (!(enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME)) {

+                        frame_bytes = enc->frame_size * enc->channels *

+                                      av_get_bytes_per_sample(enc->sample_fmt);

                         if (allocated_audio_buf_size < frame_bytes)

                             exit_program(1);

                         generate_silence(audio_buf+fifo_bytes, enc->sample_fmt, frame_bytes - fifo_bytes);

                     }

-

-                    ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf);

-                    pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,

-                                              ost->st->time_base.num, enc->sample_rate);

-                    enc->frame_size = fs_tmp;

-                }

-                if (ret <= 0) {

-                    ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);

-                }

-                if (ret < 0) {

-                    av_log(NULL, AV_LOG_FATAL, "Audio encoding failed\n");

-                    exit_program(1);

+                    encode_audio_frame(os, ost, audio_buf, frame_bytes);

+                } else {

+                    /* flush encoder with NULL frames until it is done

+                       returning packets */

+                    if (encode_audio_frame(os, ost, NULL, 0) == 0) {

+                        stop_encoding = 1;

+                        break;

+                    }

                 }

-                audio_size += ret;

-                pkt.flags  |= AV_PKT_FLAG_KEY;

                 break;

             case AVMEDIA_TYPE_VIDEO:

                 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);

@@ -1804,18 +1805,22 @@ static void flush_encoders(OutputStream *ost_table, int nb_ostreams)

                 if (ost->logfile && enc->stats_out) {

                     fprintf(ost->logfile, "%s", enc->stats_out);

                 }

+                if (ret <= 0) {

+                    stop_encoding = 1;

+                    break;

+                }

+                pkt.stream_index = ost->index;

+                pkt.data = bit_buffer;

+                pkt.size = ret;

+                if (enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)

+                    pkt.pts = av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);

+                write_frame(os, &pkt, ost);

                 break;

             default:

-                ret = -1;

+                stop_encoding = 1;

             }

-

-            if (ret <= 0)

+            if (stop_encoding)

                 break;

-            pkt.data = bit_buffer;

-            pkt.size = ret;

-            if (enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)

-                pkt.pts = av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);

-            write_frame(os, &pkt, ost);

         }

     }

 }

@@ -23,16 +23,18 @@

 #include "libavcodec/avcodec.h"

 #include "libavcodec/rv34dsp.h"

-void ff_rv34_inv_transform_neon(DCTELEM *block);

 void ff_rv34_inv_transform_noround_neon(DCTELEM *block);

-void ff_rv34_inv_transform_dc_neon(DCTELEM *block);

 void ff_rv34_inv_transform_noround_dc_neon(DCTELEM *block);

+void ff_rv34_idct_add_neon(uint8_t *dst, int stride, DCTELEM *block);

+void ff_rv34_idct_dc_add_neon(uint8_t *dst, int stride, int dc);

+

 void ff_rv34dsp_init_neon(RV34DSPContext *c, DSPContext* dsp)

 {

-    c->rv34_inv_transform_tab[0]    = ff_rv34_inv_transform_neon;

-    c->rv34_inv_transform_tab[1]    = ff_rv34_inv_transform_noround_neon;

-    c->rv34_inv_transform_dc_tab[0] = ff_rv34_inv_transform_dc_neon;

-    c->rv34_inv_transform_dc_tab[1] = ff_rv34_inv_transform_noround_dc_neon;

+    c->rv34_inv_transform    = ff_rv34_inv_transform_noround_neon;

+    c->rv34_inv_transform_dc = ff_rv34_inv_transform_noround_dc_neon;

+

+    c->rv34_idct_add    = ff_rv34_idct_add_neon;

+    c->rv34_idct_dc_add = ff_rv34_idct_dc_add_neon;

 }

@@ -19,13 +19,10 @@

  */

 #include "asm.S"

+#include "neon.S"

-.macro rv34_inv_transform

-        mov             r1,  #16

-        vld1.16         {d28}, [r0,:64], r1     @ block[i+8*0]

-        vld1.16         {d29}, [r0,:64], r1     @ block[i+8*1]

-        vld1.16         {d30}, [r0,:64], r1     @ block[i+8*2]

-        vld1.16         {d31}, [r0,:64], r1     @ block[i+8*3]

+.macro rv34_inv_transform    r0

+        vld1.16         {q14-q15}, [\r0,:128]

         vmov.s16        d0,  #13

         vshll.s16       q12, d29, #3

         vshll.s16       q13, d29, #4

@@ -35,12 +32,12 @@

         vmlal.s16       q10, d30, d0

         vmull.s16       q11, d28, d0

         vmlsl.s16       q11, d30, d0

-        vsubw.s16       q12, q12, d29   @ z2 = block[i+8*1]*7

-        vaddw.s16       q13, q13, d29   @ z3 = block[i+8*1]*17

+        vsubw.s16       q12, q12, d29   @ z2 = block[i+4*1]*7

+        vaddw.s16       q13, q13, d29   @ z3 = block[i+4*1]*17

         vsubw.s16       q9,  q9,  d31

         vaddw.s16       q1,  q1,  d31

-        vadd.s32        q13, q13, q9    @ z3 = 17*block[i+8*1] +  7*block[i+8*3]

-        vsub.s32        q12, q12, q1    @ z2 = 7*block[i+8*1]  - 17*block[i+8*3]

+        vadd.s32        q13, q13, q9    @ z3 = 17*block[i+4*1] +  7*block[i+4*3]

+        vsub.s32        q12, q12, q1    @ z2 = 7*block[i+4*1]  - 17*block[i+4*3]

         vadd.s32        q1,  q10, q13   @ z0 + z3

         vadd.s32        q2,  q11, q12   @ z1 + z2

         vsub.s32        q8,  q10, q13   @ z0 - z3

@@ -70,25 +67,39 @@

         vsub.s32        q15, q14, q9    @ z0 - z3

 .endm

-/* void ff_rv34_inv_transform_neon(DCTELEM *block); */

-function ff_rv34_inv_transform_neon, export=1

-        mov             r2,  r0

-        rv34_inv_transform

-        vrshrn.s32      d1,  q2,  #10   @ (z1 + z2) >> 10

-        vrshrn.s32      d0,  q1,  #10   @ (z0 + z3) >> 10

-        vrshrn.s32      d2,  q3,  #10   @ (z1 - z2) >> 10

-        vrshrn.s32      d3,  q15, #10   @ (z0 - z3) >> 10

-        vst4.16         {d0[0], d1[0], d2[0], d3[0]}, [r2,:64], r1

-        vst4.16         {d0[1], d1[1], d2[1], d3[1]}, [r2,:64], r1

-        vst4.16         {d0[2], d1[2], d2[2], d3[2]}, [r2,:64], r1

-        vst4.16         {d0[3], d1[3], d2[3], d3[3]}, [r2,:64], r1

+/* void rv34_idct_add_c(uint8_t *dst, int stride, DCTELEM *block) */

+function ff_rv34_idct_add_neon, export=1

+        mov             r3,  r0

+        rv34_inv_transform   r2

+        vmov.i16        q12, #0

+        vrshrn.s32      d16, q1,  #10   @ (z0 + z3) >> 10

+        vrshrn.s32      d17, q2,  #10   @ (z1 + z2) >> 10

+        vrshrn.s32      d18, q3,  #10   @ (z1 - z2) >> 10

+        vrshrn.s32      d19, q15, #10   @ (z0 - z3) >> 10

+        vld1.32         {d28[]},  [r0,:32], r1

+        vld1.32         {d29[]},  [r0,:32], r1

+        vtrn.32         q8,  q9

+        vld1.32         {d28[1]}, [r0,:32], r1

+        vld1.32         {d29[1]}, [r0,:32], r1

+        vst1.16         {q12}, [r2,:128]!       @ memset(block,    0, 16)

+        vst1.16         {q12}, [r2,:128]        @ memset(block+16, 0, 16)

+        vtrn.16         d16, d17

+        vtrn.32         d28, d29

+        vtrn.16         d18, d19

+        vaddw.u8        q0,   q8,  d28

+        vaddw.u8        q1,   q9,  d29

+        vqmovun.s16     d28,  q0

+        vqmovun.s16     d29,  q1

+        vst1.32         {d28[0]}, [r3,:32], r1

+        vst1.32         {d28[1]}, [r3,:32], r1

+        vst1.32         {d29[0]}, [r3,:32], r1

+        vst1.32         {d29[1]}, [r3,:32], r1

         bx              lr

 endfunc

 /* void rv34_inv_transform_noround_neon(DCTELEM *block); */

 function ff_rv34_inv_transform_noround_neon, export=1

-        mov             r2,  r0

-        rv34_inv_transform

+        rv34_inv_transform   r0

         vshl.s32        q11, q2,  #1

         vshl.s32        q10, q1,  #1

         vshl.s32        q12, q3,  #1

@@ -101,24 +112,33 @@ function ff_rv34_inv_transform_noround_neon, export=1

         vshrn.s32       d1,  q11, #11   @ (z1 + z2)*3 >> 11

         vshrn.s32       d2,  q12, #11   @ (z1 - z2)*3 >> 11

         vshrn.s32       d3,  q13, #11   @ (z0 - z3)*3 >> 11

-        vst4.16         {d0[0], d1[0], d2[0], d3[0]}, [r2,:64], r1

-        vst4.16         {d0[1], d1[1], d2[1], d3[1]}, [r2,:64], r1

-        vst4.16         {d0[2], d1[2], d2[2], d3[2]}, [r2,:64], r1

-        vst4.16         {d0[3], d1[3], d2[3], d3[3]}, [r2,:64], r1

+        vst4.16         {d0[0], d1[0], d2[0], d3[0]}, [r0,:64]!

+        vst4.16         {d0[1], d1[1], d2[1], d3[1]}, [r0,:64]!

+        vst4.16         {d0[2], d1[2], d2[2], d3[2]}, [r0,:64]!

+        vst4.16         {d0[3], d1[3], d2[3], d3[3]}, [r0,:64]!

         bx              lr

 endfunc

-/* void rv34_inv_transform_dc_c(DCTELEM *block) */

-function ff_rv34_inv_transform_dc_neon, export=1

-        vld1.16         {d28[]}, [r0,:16]       @ block[0]

-        vmov.i16        d4,  #169

-        mov             r1,  #16

-        vmull.s16       q3,  d28, d4

-        vrshrn.s32      d0,  q3,  #10

-        vst1.16         {d0}, [r0,:64], r1

-        vst1.16         {d0}, [r0,:64], r1

-        vst1.16         {d0}, [r0,:64], r1

-        vst1.16         {d0}, [r0,:64], r1

+/* void ff_rv34_idct_dc_add_neon(uint8_t *dst, int stride, int dc) */

+function ff_rv34_idct_dc_add_neon, export=1

+        mov             r3,  r0

+        vld1.32         {d28[]},  [r0,:32], r1

+        vld1.32         {d29[]},  [r0,:32], r1

+        vdup.16         d0,  r2

+        vmov.s16        d1,  #169

+        vld1.32         {d28[1]}, [r0,:32], r1

+        vmull.s16       q1,  d0,  d1    @ dc * 13 * 13

+        vld1.32         {d29[1]}, [r0,:32], r1

+        vrshrn.s32      d0,  q1,  #10   @ (dc * 13 * 13 + 0x200) >> 10

+        vmov            d1,  d0

+        vaddw.u8        q2,  q0,  d28

+        vaddw.u8        q3,  q0,  d29

+        vqmovun.s16     d28, q2

+        vqmovun.s16     d29, q3

+        vst1.32         {d28[0]}, [r3,:32], r1

+        vst1.32         {d29[0]}, [r3,:32], r1

+        vst1.32         {d28[1]}, [r3,:32], r1

+        vst1.32         {d29[1]}, [r3,:32], r1

         bx              lr

 endfunc

@@ -127,12 +147,10 @@ function ff_rv34_inv_transform_noround_dc_neon, export=1

         vld1.16         {d28[]}, [r0,:16]       @ block[0]

         vmov.i16        d4,  #251

         vorr.s16        d4,  #256               @ 13^2 * 3

-        mov             r1,  #16

         vmull.s16       q3,  d28, d4

         vshrn.s32       d0,  q3,  #11

-        vst1.64         {d0}, [r0,:64], r1

-        vst1.64         {d0}, [r0,:64], r1

-        vst1.64         {d0}, [r0,:64], r1

-        vst1.64         {d0}, [r0,:64], r1

+        vmov.i16        d1,  d0

+        vst1.64         {q0}, [r0,:128]!

+        vst1.64         {q0}, [r0,:128]!

         bx              lr

 endfunc

@@ -761,6 +761,11 @@ typedef struct RcOverride{

  * Encoders:

  * The encoder needs to be fed with NULL data at the end of encoding until the

  * encoder no longer returns data.

+ *

+ * NOTE: For encoders implementing the AVCodec.encode2() function, setting this

+ *       flag also means that the encoder must set the pts and duration for

+ *       each output packet. If this flag is not set, the pts and duration will

+ *       be determined by libavcodec from the input frame.

  */

 #define CODEC_CAP_DELAY           0x0020

 /**

@@ -816,6 +821,10 @@ typedef struct RcOverride{

  */

 #define CODEC_CAP_AUTO_THREADS     0x8000

 /**

+ * Audio encoder supports receiving a different number of samples in each call.

+ */

+#define CODEC_CAP_VARIABLE_FRAME_SIZE 0x10000

+/**

  * Codec is lossless.

  */

 #define CODEC_CAP_LOSSLESS         0x80000000

@@ -3314,6 +3323,19 @@ typedef struct AVCodec {

      * Initialize codec static data, called from avcodec_register().

      */

     void (*init_static_data)(struct AVCodec *codec);

+

+    /**

+     * Encode data to an AVPacket.

+     *

+     * @param      avctx          codec context

+     * @param      avpkt          output AVPacket (may contain a user-provided buffer)

+     * @param[in]  frame          AVFrame containing the raw data to be encoded