@@ -1545,7 +1545,6 @@ h264_parser_select="golomb h264chroma h264dsp h264pred"

 libaacplus_encoder_deps="libaacplus"

 libcelt_decoder_deps="libcelt"

 libdirac_decoder_deps="libdirac !libschroedinger"

-libdirac_encoder_deps="libdirac"

 libfaac_encoder_deps="libfaac"

 libgsm_decoder_deps="libgsm"

 libgsm_encoder_deps="libgsm"

@@ -3145,8 +3144,8 @@ enabled libcelt    && require libcelt celt/celt.h celt_decode -lcelt0 &&

                       { check_lib celt/celt.h celt_decoder_create_custom -lcelt0 ||

                         die "ERROR: libcelt version must be >= 0.11.0."; }

 enabled libdirac   && require_pkg_config dirac                          \

-    "libdirac_decoder/dirac_parser.h libdirac_encoder/dirac_encoder.h"  \

-    "dirac_decoder_init dirac_encoder_init"

+    "libdirac_decoder/dirac_parser.h"  \

+    "dirac_decoder_init"

 enabled libfaac    && require2 libfaac "stdint.h faac.h" faacEncGetVersion -lfaac

 enabled libfreetype && require_pkg_config freetype2 "ft2build.h freetype/freetype.h" FT_Init_FreeType

 enabled libgsm     && require  libgsm gsm/gsm.h gsm_create -lgsm

@@ -603,7 +603,7 @@ OBJS-$(CONFIG_MATROSKA_MUXER)          += xiph.o mpeg4audio.o \

                                           flacdec.o flacdata.o flac.o \

                                           mpegaudiodata.o vorbis_data.o

 OBJS-$(CONFIG_MP3_MUXER)               += mpegaudiodata.o mpegaudiodecheader.o

-OBJS-$(CONFIG_MOV_DEMUXER)             += mpeg4audio.o mpegaudiodata.o timecode.o

+OBJS-$(CONFIG_MOV_DEMUXER)             += mpeg4audio.o mpegaudiodata.o ac3tab.o timecode.o

 OBJS-$(CONFIG_MOV_MUXER)               += mpeg4audio.o mpegaudiodata.o

 OBJS-$(CONFIG_MPEGTS_MUXER)            += mpegvideo.o mpeg4audio.o

 OBJS-$(CONFIG_MPEGTS_DEMUXER)          += mpeg4audio.o mpegaudiodata.o

@@ -624,7 +624,6 @@ OBJS-$(CONFIG_WTV_DEMUXER)             += mpeg4audio.o mpegaudiodata.o

 OBJS-$(CONFIG_LIBAACPLUS_ENCODER)         += libaacplus.o

 OBJS-$(CONFIG_LIBCELT_DECODER)            += libcelt_dec.o

 OBJS-$(CONFIG_LIBDIRAC_DECODER)           += libdiracdec.o

-OBJS-$(CONFIG_LIBDIRAC_ENCODER)           += libdiracenc.o libdirac_libschro.o

 OBJS-$(CONFIG_LIBFAAC_ENCODER)            += libfaac.o

 OBJS-$(CONFIG_LIBGSM_DECODER)             += libgsm.o

 OBJS-$(CONFIG_LIBGSM_ENCODER)             += libgsm.o

@@ -50,6 +50,9 @@ typedef struct A64Context {

     uint8_t *mc_colram;

     uint8_t *mc_palette;

     int mc_pal_size;

+

+    /* pts of the next packet that will be output */

+    int64_t next_pts;

 } A64Context;

 #endif /* AVCODEC_A64ENC_H */

@@ -28,6 +28,7 @@

 #include "a64colors.h"

 #include "a64tables.h"

 #include "elbg.h"

+#include "internal.h"

 #include "libavutil/intreadwrite.h"

 #define DITHERSTEPS   8

@@ -221,6 +222,8 @@ static av_cold int a64multi_init_encoder(AVCodecContext *avctx)

     if (!avctx->codec_tag)

          avctx->codec_tag = AV_RL32("a64m");

+    c->next_pts = AV_NOPTS_VALUE;

+

     return 0;

 }

@@ -239,11 +242,10 @@ static void a64_compress_colram(unsigned char *buf, int *charmap, uint8_t *colra

     }

 }

-static int a64multi_encode_frame(AVCodecContext *avctx, unsigned char *buf,

-                                 int buf_size, void *data)

+static int a64multi_encode_frame(AVCodecContext *avctx, AVPacket *pkt,

+                                 const AVFrame *pict, int *got_packet)

 {

     A64Context *c = avctx->priv_data;

-    AVFrame *pict = data;

     AVFrame *const p = (AVFrame *) & c->picture;

     int frame;

@@ -251,7 +253,8 @@ static int a64multi_encode_frame(AVCodecContext *avctx, unsigned char *buf,

     int b_height;

     int b_width;

-    int req_size;

+    int req_size, ret;

+    uint8_t *buf;

     int *charmap     = c->mc_charmap;

     uint8_t *colram  = c->mc_colram;

@@ -274,7 +277,7 @@ static int a64multi_encode_frame(AVCodecContext *avctx, unsigned char *buf,

     }

     /* no data, means end encoding asap */

-    if (!data) {

+    if (!pict) {

         /* all done, end encoding */

         if (!c->mc_lifetime) return 0;

         /* no more frames in queue, prepare to flush remaining frames */

@@ -292,6 +295,8 @@ static int a64multi_encode_frame(AVCodecContext *avctx, unsigned char *buf,

             p->key_frame = 1;

             to_meta_with_crop(avctx, p, meta + 32000 * c->mc_frame_counter);

             c->mc_frame_counter++;

+            if (c->next_pts == AV_NOPTS_VALUE)

+                c->next_pts = pict->pts;

             /* lifetime is not reached so wait for next frame first */

             return 0;

         }

@@ -302,6 +307,13 @@ static int a64multi_encode_frame(AVCodecContext *avctx, unsigned char *buf,

         req_size = 0;

         /* any frames to encode? */

         if (c->mc_lifetime) {

+            req_size = charset_size + c->mc_lifetime*(screen_size + colram_size);

+            if ((ret = ff_alloc_packet(pkt, req_size)) < 0) {

+                av_log(avctx, AV_LOG_ERROR, "Error getting output packet of size %d.\n", req_size);

+                return ret;

+            }

+            buf = pkt->data;

+

             /* calc optimal new charset + charmaps */

             ff_init_elbg(meta, 32, 1000 * c->mc_lifetime, best_cb, CHARSET_CHARS, 50, charmap, &c->randctx);

             ff_do_elbg  (meta, 32, 1000 * c->mc_lifetime, best_cb, CHARSET_CHARS, 50, charmap, &c->randctx);

@@ -310,15 +322,12 @@ static int a64multi_encode_frame(AVCodecContext *avctx, unsigned char *buf,

             render_charset(avctx, charset, colram);

             /* copy charset to buf */

-            memcpy(buf,charset, charset_size);

+            memcpy(buf, charset, charset_size);

             /* advance pointers */

             buf      += charset_size;

             charset  += charset_size;

-            req_size += charset_size;

         }

-        /* no charset so clean buf */

-        else memset(buf, 0, charset_size);

         /* write x frames to buf */

         for (frame = 0; frame < c->mc_lifetime; frame++) {

@@ -351,11 +360,12 @@ static int a64multi_encode_frame(AVCodecContext *avctx, unsigned char *buf,

         /* reset counter */

         c->mc_frame_counter = 0;

-        if (req_size > buf_size) {

-            av_log(avctx, AV_LOG_ERROR, "buf size too small (need %d, got %d)\n", req_size, buf_size);

-            return -1;

-        }

-        return req_size;

+        pkt->pts = pkt->dts = c->next_pts;

+        c->next_pts         = AV_NOPTS_VALUE;

+

+        pkt->size   = req_size;

+        pkt->flags |= AV_PKT_FLAG_KEY;

+        *got_packet = !!req_size;

     }

     return 0;

 }

@@ -366,7 +376,7 @@ AVCodec ff_a64multi_encoder = {

     .id             = CODEC_ID_A64_MULTI,

     .priv_data_size = sizeof(A64Context),

     .init           = a64multi_init_encoder,

-    .encode         = a64multi_encode_frame,

+    .encode2        = a64multi_encode_frame,

     .close          = a64multi_close_encoder,

     .pix_fmts       = (const enum PixelFormat[]) {PIX_FMT_GRAY8, PIX_FMT_NONE},

     .long_name      = NULL_IF_CONFIG_SMALL("Multicolor charset for Commodore 64"),

@@ -379,7 +389,7 @@ AVCodec ff_a64multi5_encoder = {

     .id             = CODEC_ID_A64_MULTI5,

     .priv_data_size = sizeof(A64Context),

     .init           = a64multi_init_encoder,

-    .encode         = a64multi_encode_frame,

+    .encode2        = a64multi_encode_frame,

     .close          = a64multi_close_encoder,

     .pix_fmts       = (const enum PixelFormat[]) {PIX_FMT_GRAY8, PIX_FMT_NONE},

     .long_name      = NULL_IF_CONFIG_SMALL("Multicolor charset for Commodore 64, extended with 5th color (colram)"),

@@ -134,7 +134,7 @@ int avpriv_ac3_parse_header(GetBitContext *gbc, AC3HeaderInfo *hdr)

                         (hdr->num_blocks * 256.0));

         hdr->channels = ff_ac3_channels_tab[hdr->channel_mode] + hdr->lfe_on;

     }

-    hdr->channel_layout = ff_ac3_channel_layout_tab[hdr->channel_mode];

+    hdr->channel_layout = avpriv_ac3_channel_layout_tab[hdr->channel_mode];

     if (hdr->lfe_on)

         hdr->channel_layout |= AV_CH_LOW_FREQUENCY;

@@ -1378,7 +1378,7 @@ static int ac3_decode_frame(AVCodecContext * avctx, void *data,

                 avctx->request_channels < s->channels) {

             s->out_channels = avctx->request_channels;

             s->output_mode  = avctx->request_channels == 1 ? AC3_CHMODE_MONO : AC3_CHMODE_STEREO;

-            s->channel_layout = ff_ac3_channel_layout_tab[s->output_mode];

+            s->channel_layout = avpriv_ac3_channel_layout_tab[s->output_mode];

         }

         avctx->channels       = s->out_channels;

         avctx->channel_layout = s->channel_layout;

@@ -84,7 +84,7 @@ const uint8_t ff_ac3_channels_tab[8] = {

 /**

  * Map audio coding mode (acmod) to channel layout mask.

  */

-const uint16_t ff_ac3_channel_layout_tab[8] = {

+const uint16_t avpriv_ac3_channel_layout_tab[8] = {

     AV_CH_LAYOUT_STEREO,

     AV_CH_LAYOUT_MONO,

     AV_CH_LAYOUT_STEREO,

@@ -33,7 +33,7 @@

 extern const uint16_t ff_ac3_frame_size_tab[38][3];

 extern const uint8_t  ff_ac3_channels_tab[8];

-extern const uint16_t ff_ac3_channel_layout_tab[8];

+extern const uint16_t avpriv_ac3_channel_layout_tab[8];

 extern const uint8_t  ff_ac3_enc_channel_map[8][2][6];

 extern const uint8_t  ff_ac3_dec_channel_map[8][2][6];

 extern const uint16_t ff_ac3_sample_rate_tab[3];

@@ -400,7 +400,7 @@ void avcodec_register_all(void)

     /* external libraries */

     REGISTER_ENCODER (LIBAACPLUS, libaacplus);

     REGISTER_DECODER (LIBCELT, libcelt);

-    REGISTER_ENCDEC  (LIBDIRAC, libdirac);

+    REGISTER_DECODER (LIBDIRAC, libdirac);

     REGISTER_ENCODER (LIBFAAC, libfaac);

     REGISTER_ENCDEC  (LIBGSM, libgsm);

     REGISTER_ENCDEC  (LIBGSM_MS, libgsm_ms);

@@ -325,10 +325,12 @@ static inline int decode_mb(ASV1Context *a, DCTELEM block[6][64]){

     return 0;

 }

+#define MAX_MB_SIZE (30*16*16*3/2/8)

+

 static inline int encode_mb(ASV1Context *a, DCTELEM block[6][64]){

     int i;

-    if(a->pb.buf_end - a->pb.buf - (put_bits_count(&a->pb)>>3) < 30*16*16*3/2/8){

+    if (a->pb.buf_end - a->pb.buf - (put_bits_count(&a->pb)>>3) < MAX_MB_SIZE) {

         av_log(a->avctx, AV_LOG_ERROR, "encoded frame too large\n");

         return -1;

     }

@@ -461,14 +463,22 @@ static int decode_frame(AVCodecContext *avctx,

 }

 #if CONFIG_ASV1_ENCODER || CONFIG_ASV2_ENCODER

-static int encode_frame(AVCodecContext *avctx, unsigned char *buf, int buf_size, void *data){

+static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,

+                        const AVFrame *pict, int *got_packet)

+{

     ASV1Context * const a = avctx->priv_data;

-    AVFrame *pict = data;

     AVFrame * const p= &a->picture;

-    int size;

+    int size, ret;

     int mb_x, mb_y;

-    init_put_bits(&a->pb, buf, buf_size);

+    if (!pkt->data &&

+        (ret = av_new_packet(pkt, a->mb_height*a->mb_width*MAX_MB_SIZE +

+                                  FF_MIN_BUFFER_SIZE)) < 0) {

+        av_log(avctx, AV_LOG_ERROR, "Error getting output packet.\n");

+        return ret;

+    }

+

+    init_put_bits(&a->pb, pkt->data, pkt->size);

     *p = *pict;

     p->pict_type= AV_PICTURE_TYPE_I;

@@ -505,14 +515,18 @@ static int encode_frame(AVCodecContext *avctx, unsigned char *buf, int buf_size,

     size= put_bits_count(&a->pb)/32;

     if(avctx->codec_id == CODEC_ID_ASV1)

-        a->dsp.bswap_buf((uint32_t*)buf, (uint32_t*)buf, size);

+        a->dsp.bswap_buf((uint32_t*)pkt->data, (uint32_t*)pkt->data, size);

     else{

         int i;

         for(i=0; i<4*size; i++)

-            buf[i]= av_reverse[ buf[i] ];

+            pkt->data[i] = av_reverse[pkt->data[i]];

     }

-    return size*4;

+    pkt->size   = size*4;

+    pkt->flags |= AV_PKT_FLAG_KEY;

+    *got_packet = 1;

+

+    return 0;

 }

 #endif /* CONFIG_ASV1_ENCODER || CONFIG_ASV2_ENCODER */

@@ -634,7 +648,7 @@ AVCodec ff_asv1_encoder = {

     .id             = CODEC_ID_ASV1,

     .priv_data_size = sizeof(ASV1Context),

     .init           = encode_init,

-    .encode         = encode_frame,

+    .encode2        = encode_frame,

     //encode_end,

     .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_NONE},

     .long_name= NULL_IF_CONFIG_SMALL("ASUS V1"),

@@ -648,7 +662,7 @@ AVCodec ff_asv2_encoder = {

     .id             = CODEC_ID_ASV2,

     .priv_data_size = sizeof(ASV1Context),

     .init           = encode_init,

-    .encode         = encode_frame,

+    .encode2        = encode_frame,

     //encode_end,

     .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_NONE},

     .long_name= NULL_IF_CONFIG_SMALL("ASUS V2"),

@@ -1135,17 +1135,25 @@ static int encode_slice(AVCodecContext *c, void *arg){

     return 0;

 }

-static int encode_frame(AVCodecContext *avctx, unsigned char *buf, int buf_size, void *data){

+static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,

+                        const AVFrame *pict, int *got_packet)

+{

     FFV1Context *f = avctx->priv_data;

     RangeCoder * const c= &f->slice_context[0]->c;

-    AVFrame *pict = data;

     AVFrame * const p= &f->picture;

     int used_count= 0;

     uint8_t keystate=128;

     uint8_t *buf_p;

-    int i;

+    int i, ret;

+

+    if (!pkt->data &&

+        (ret = av_new_packet(pkt, avctx->width*avctx->height*((8*2+1+1)*4)/8

+                                  + FF_MIN_BUFFER_SIZE)) < 0) {

+        av_log(avctx, AV_LOG_ERROR, "Error getting output packet.\n");

+        return ret;

+    }

-    ff_init_range_encoder(c, buf, buf_size);

+    ff_init_range_encoder(c, pkt->data, pkt->size);

     ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);

     *p = *pict;

@@ -1165,7 +1173,7 @@ static int encode_frame(AVCodecContext *avctx, unsigned char *buf, int buf_size,

     if(!f->ac){

         used_count += ff_rac_terminate(c);

 //printf("pos=%d\n", used_count);

-        init_put_bits(&f->slice_context[0]->pb, buf + used_count, buf_size - used_count);

+        init_put_bits(&f->slice_context[0]->pb, pkt->data + used_count, pkt->size - used_count);

     }else if (f->ac>1){

         int i;

         for(i=1; i<256; i++){

@@ -1176,8 +1184,8 @@ static int encode_frame(AVCodecContext *avctx, unsigned char *buf, int buf_size,

     for(i=1; i<f->slice_count; i++){

         FFV1Context *fs= f->slice_context[i];

-        uint8_t *start= buf + (buf_size-used_count)*i/f->slice_count;

-        int len= buf_size/f->slice_count;

+        uint8_t *start = pkt->data + (pkt->size-used_count)*i/f->slice_count;

+        int len = pkt->size/f->slice_count;

         if(fs->ac){

             ff_init_range_encoder(&fs->c, start, len);

@@ -1187,7 +1195,7 @@ static int encode_frame(AVCodecContext *avctx, unsigned char *buf, int buf_size,

     }

     avctx->execute(avctx, encode_slice, &f->slice_context[0], NULL, f->slice_count, sizeof(void*));

-    buf_p=buf;

+    buf_p = pkt->data;

     for(i=0; i<f->slice_count; i++){

         FFV1Context *fs= f->slice_context[i];

         int bytes;

@@ -1202,7 +1210,7 @@ static int encode_frame(AVCodecContext *avctx, unsigned char *buf, int buf_size,

             used_count= 0;

         }

         if(i>0){

-            av_assert0(bytes < buf_size/f->slice_count);

+            av_assert0(bytes < pkt->size/f->slice_count);

             memmove(buf_p, fs->ac ? fs->c.bytestream_start : fs->pb.buf, bytes);

             av_assert0(bytes < (1<<24));

             AV_WB24(buf_p+bytes, bytes);

@@ -1255,7 +1263,11 @@ static int encode_frame(AVCodecContext *avctx, unsigned char *buf, int buf_size,

         avctx->stats_out[0] = '\0';

     f->picture_number++;

-    return buf_p-buf;

+    pkt->size   = buf_p - pkt->data;

+    pkt->flags |= AV_PKT_FLAG_KEY*p->key_frame;

+    *got_packet = 1;

+

+    return 0;

 }

 #endif /* CONFIG_FFV1_ENCODER */

@@ -1843,7 +1855,7 @@ AVCodec ff_ffv1_encoder = {

     .id             = CODEC_ID_FFV1,

     .priv_data_size = sizeof(FFV1Context),

     .init           = encode_init,

-    .encode         = encode_frame,

+    .encode2        = encode_frame,

     .close          = common_end,

     .capabilities = CODEC_CAP_SLICE_THREADS,

     .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_YUVA420P, PIX_FMT_YUV444P, PIX_FMT_YUVA444P, PIX_FMT_YUV440P, PIX_FMT_YUV422P, PIX_FMT_YUV411P, PIX_FMT_YUV410P, PIX_FMT_0RGB32, PIX_FMT_RGB32, PIX_FMT_YUV420P16, PIX_FMT_YUV422P16, PIX_FMT_YUV444P16, PIX_FMT_YUV420P9, PIX_FMT_YUV420P10, PIX_FMT_YUV422P10, PIX_FMT_GRAY16, PIX_FMT_GRAY8, PIX_FMT_NONE},

@@ -33,6 +33,7 @@

 #include <limits.h>

+#include "libavutil/audioconvert.h"

 #include "libavutil/crc.h"

 #include "avcodec.h"

 #include "internal.h"

@@ -62,6 +63,15 @@ typedef struct FLACContext {

     int32_t *decoded[FLAC_MAX_CHANNELS];    ///< decoded samples

 } FLACContext;

+static const int64_t flac_channel_layouts[6] = {

+    AV_CH_LAYOUT_MONO,

+    AV_CH_LAYOUT_STEREO,

+    AV_CH_LAYOUT_SURROUND,

+    AV_CH_LAYOUT_QUAD,

+    AV_CH_LAYOUT_5POINT0,

+    AV_CH_LAYOUT_5POINT1

+};

+

 static void allocate_buffers(FLACContext *s);

 int avpriv_flac_is_extradata_valid(AVCodecContext *avctx,

@@ -120,6 +130,9 @@ static av_cold int flac_decode_init(AVCodecContext *avctx)

     avcodec_get_frame_defaults(&s->frame);

     avctx->coded_frame = &s->frame;

+    if (avctx->channels <= FF_ARRAY_ELEMS(flac_channel_layouts))

+        avctx->channel_layout = flac_channel_layouts[avctx->channels - 1];

+

     return 0;

 }

@@ -49,6 +49,7 @@

 #include <zlib.h>

 #include "avcodec.h"

+#include "internal.h"

 #include "put_bits.h"

 #include "bytestream.h"

@@ -194,11 +195,10 @@ static int encode_bitstream(FlashSVContext *s, AVFrame *p, uint8_t *buf,

 }

-static int flashsv_encode_frame(AVCodecContext *avctx, uint8_t *buf,

-                                int buf_size, void *data)

+static int flashsv_encode_frame(AVCodecContext *avctx, AVPacket *pkt,

+                                const AVFrame *pict, int *got_packet)

 {

     FlashSVContext * const s = avctx->priv_data;

-    AVFrame *pict = data;

     AVFrame * const p = &s->frame;

     uint8_t *pfptr;

     int res;

@@ -228,15 +228,15 @@ static int flashsv_encode_frame(AVCodecContext *avctx, uint8_t *buf,

         I_frame = 1;

     }

-    if (buf_size < s->image_width * s->image_height * 3) {

+    if ((res = ff_alloc_packet(pkt, s->image_width * s->image_height * 3)) < 0) {

         //Conservative upper bound check for compressed data

-        av_log(avctx, AV_LOG_ERROR, "buf_size %d <  %d\n",

-               buf_size, s->image_width * s->image_height * 3);

-        return -1;

+        av_log(avctx, AV_LOG_ERROR, "Error getting output packet of size %d.\n",

+               s->image_width * s->image_height * 3);

+        return res;

     }

-    res = encode_bitstream(s, p, buf, buf_size, opt_w * 16, opt_h * 16,

-                           pfptr, &I_frame);

+    pkt->size = encode_bitstream(s, p, pkt->data, pkt->size, opt_w * 16, opt_h * 16,

+                                 pfptr, &I_frame);

     //save the current frame

     if (p->linesize[0] > 0)

@@ -259,7 +259,11 @@ static int flashsv_encode_frame(AVCodecContext *avctx, uint8_t *buf,

     avctx->coded_frame = p;

-    return res;

+    if (p->key_frame)

+        pkt->flags |= AV_PKT_FLAG_KEY;

+    *got_packet = 1;

+

+    return 0;

 }

 static av_cold int flashsv_encode_end(AVCodecContext *avctx)

@@ -281,7 +285,7 @@ AVCodec ff_flashsv_encoder = {

     .id             = CODEC_ID_FLASHSV,

     .priv_data_size = sizeof(FlashSVContext),

     .init           = flashsv_encode_init,

-    .encode         = flashsv_encode_frame,

+    .encode2        = flashsv_encode_frame,

     .close          = flashsv_encode_end,

     .pix_fmts       = (const enum PixelFormat[]){PIX_FMT_BGR24, PIX_FMT_NONE},

     .long_name      = NULL_IF_CONFIG_SMALL("Flash Screen Video"),

@@ -43,6 +43,7 @@

 #include "avcodec.h"

 #include "bytestream.h"

+#include "internal.h"

 #include "lzw.h"

 /* The GIF format uses reversed order for bitstreams... */

@@ -155,20 +156,32 @@ static av_cold int gif_encode_init(AVCodecContext *avctx)

 }

 /* better than nothing gif encoder */

-static int gif_encode_frame(AVCodecContext *avctx, unsigned char *outbuf, int buf_size, void *data)

+static int gif_encode_frame(AVCodecContext *avctx, AVPacket *pkt,

+                            const AVFrame *pict, int *got_packet)

 {

     GIFContext *s = avctx->priv_data;

-    AVFrame *pict = data;

     AVFrame *const p = (AVFrame *)&s->picture;

-    uint8_t *outbuf_ptr = outbuf;

-    uint8_t *end = outbuf + buf_size;

+    uint8_t *outbuf_ptr, *end;

+    int ret;

+

+    if ((ret = ff_alloc_packet(pkt, avctx->width*avctx->height*7/5 + FF_MIN_BUFFER_SIZE)) < 0) {

+        av_log(avctx, AV_LOG_ERROR, "Error getting output packet.\n");

+        return ret;

+    }

+    outbuf_ptr = pkt->data;

+    end        = pkt->data + pkt->size;

     *p = *pict;

     p->pict_type = AV_PICTURE_TYPE_I;

     p->key_frame = 1;

     gif_image_write_header(avctx, &outbuf_ptr, (uint32_t *)pict->data[1]);

     gif_image_write_image(avctx, &outbuf_ptr, end, pict->data[0], pict->linesize[0]);

-    return outbuf_ptr - outbuf;

+

+    pkt->size   = outbuf_ptr - pkt->data;

+    pkt->flags |= AV_PKT_FLAG_KEY;

+    *got_packet = 1;

+

+    return 0;

 }

 static int gif_encode_close(AVCodecContext *avctx)

@@ -186,7 +199,7 @@ AVCodec ff_gif_encoder = {

     .id             = CODEC_ID_GIF,

     .priv_data_size = sizeof(GIFContext),

     .init           = gif_encode_init,

-    .encode         = gif_encode_frame,

+    .encode2        = gif_encode_frame,

     .close          = gif_encode_close,

     .pix_fmts= (const enum PixelFormat[]){PIX_FMT_RGB8, PIX_FMT_BGR8, PIX_FMT_RGB4_BYTE, PIX_FMT_BGR4_BYTE, PIX_FMT_GRAY8, PIX_FMT_PAL8, PIX_FMT_NONE},

     .long_name= NULL_IF_CONFIG_SMALL("GIF (Graphics Interchange Format)"),

@@ -28,6 +28,7 @@

 #include "avcodec.h"

 #include "get_bits.h"

 #include "golomb.h"

+#include "internal.h"

 #include "mathops.h"

 #include "dsputil.h"

 #include "mjpeg.h"

@@ -227,23 +228,19 @@ static void ls_store_lse(JLSState *state, PutBitContext *pb){

     put_bits(pb, 16, state->reset);

 }

-static int encode_picture_ls(AVCodecContext *avctx, unsigned char *buf, int buf_size, void *data){

+static int encode_picture_ls(AVCodecContext *avctx, AVPacket *pkt,

+                             const AVFrame *pict, int *got_packet)

+{

     JpeglsContext * const s = avctx->priv_data;

-    AVFrame *pict = data;

     AVFrame * const p= (AVFrame*)&s->picture;

     const int near = avctx->prediction_method;

     PutBitContext pb, pb2;

     GetBitContext gb;

     uint8_t *buf2, *zero, *cur, *last;

     JLSState *state;

-    int i, size;

+    int i, size, ret;

     int comps;

-    buf2 = av_malloc(buf_size);

-

-    init_put_bits(&pb, buf, buf_size);

-    init_put_bits(&pb2, buf2, buf_size);

-

     *p = *pict;

     p->pict_type= AV_PICTURE_TYPE_I;

     p->key_frame= 1;

@@ -253,6 +250,17 @@ static int encode_picture_ls(AVCodecContext *avctx, unsigned char *buf, int buf_

     else

         comps = 3;

+    if ((ret = ff_alloc_packet(pkt, avctx->width*avctx->height*comps*4 +

+                                    FF_MIN_BUFFER_SIZE)) < 0) {

+        av_log(avctx, AV_LOG_ERROR, "Error getting output packet.\n");

+        return ret;

+    }

+

+    buf2 = av_malloc(pkt->size);

+

+    init_put_bits(&pb, pkt->data, pkt->size);

+    init_put_bits(&pb2, buf2, pkt->size);

+

     /* write our own JPEG header, can't use mjpeg_picture_header */

     put_marker(&pb, SOI);

     put_marker(&pb, SOF48);

@@ -366,7 +374,10 @@ static int encode_picture_ls(AVCodecContext *avctx, unsigned char *buf, int buf_

     emms_c();

-    return put_bits_count(&pb) >> 3;

+    pkt->size   = put_bits_count(&pb) >> 3;

+    pkt->flags |= AV_PKT_FLAG_KEY;

+    *got_packet = 1;

+    return 0;

 }

 static av_cold int encode_init_ls(AVCodecContext *ctx) {

@@ -388,7 +399,7 @@ AVCodec ff_jpegls_encoder = { //FIXME avoid MPV_* lossless JPEG should not need

     .id             = CODEC_ID_JPEGLS,

     .priv_data_size = sizeof(JpeglsContext),

     .init           = encode_init_ls,

-    .encode         = encode_picture_ls,

+    .encode2        = encode_picture_ls,

     .pix_fmts       = (const enum PixelFormat[]){PIX_FMT_BGR24, PIX_FMT_RGB24, PIX_FMT_GRAY8, PIX_FMT_GRAY16, PIX_FMT_NONE},

     .long_name      = NULL_IF_CONFIG_SMALL("JPEG-LS"),

 };

@@ -242,9 +242,14 @@ static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, AVPac

          * gives a file with ZLIB fourcc, but frame is really uncompressed.

          * To be sure that's true check also frame size */

         if (c->compression == COMP_ZLIB_NORMAL && c->imgtype == IMGTYPE_RGB24 &&

-            len == width * height * 3)

-            break;

-        if (c->flags & FLAG_MULTITHREAD) {

+            len == width * height * 3) {

+            if (c->flags & FLAG_PNGFILTER) {

+                memcpy(c->decomp_buf, encoded, len);

+                encoded = c->decomp_buf;

+            } else {

+                break;

+            }

+        } else if (c->flags & FLAG_MULTITHREAD) {

             int ret;

             mthread_inlen = AV_RL32(encoded);

             mthread_inlen = FFMIN(mthread_inlen, len - 8);

@@ -68,12 +68,20 @@ typedef struct LclEncContext {

  * Encode a frame

  *

  */

-static int encode_frame(AVCodecContext *avctx, unsigned char *buf, int buf_size, void *data){

+static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,

+                        const AVFrame *pict, int *got_packet)

+{

     LclEncContext *c = avctx->priv_data;

-    AVFrame *pict = data;

     AVFrame * const p = &c->pic;

-    int i;

+    int i, ret;

     int zret; // Zlib return code

+    int max_size = deflateBound(&c->zstream, avctx->width * avctx->height * 3);

+

+    if (!pkt->data &&

+        (ret = av_new_packet(pkt, max_size)) < 0) {

+            av_log(avctx, AV_LOG_ERROR, "Error allocating packet of size %d.\n", max_size);

+            return ret;

+    }

     *p = *pict;

     p->pict_type= AV_PICTURE_TYPE_I;

@@ -89,8 +97,8 @@ static int encode_frame(AVCodecContext *avctx, unsigned char *buf, int buf_size,

         av_log(avctx, AV_LOG_ERROR, "Deflate reset error: %d\n", zret);

         return -1;

     }

-    c->zstream.next_out = buf;

-    c->zstream.avail_out = buf_size;

+    c->zstream.next_out  = pkt->data;

+    c->zstream.avail_out = pkt->size;

     for(i = avctx->height - 1; i >= 0; i--) {

         c->zstream.next_in = p->data[0]+p->linesize[0]*i;

@@ -107,7 +115,11 @@ static int encode_frame(AVCodecContext *avctx, unsigned char *buf, int buf_size,

         return -1;

     }

-    return c->zstream.total_out;

+    pkt->size   = c->zstream.total_out;

+    pkt->flags |= AV_PKT_FLAG_KEY;

+    *got_packet = 1;

+

+    return 0;

 }

 /*

@@ -176,7 +188,7 @@ AVCodec ff_zlib_encoder = {

     .id             = CODEC_ID_ZLIB,

     .priv_data_size = sizeof(LclEncContext),

     .init           = encode_init,

-    .encode         = encode_frame,

+    .encode2        = encode_frame,

     .close          = encode_end,

     .pix_fmts = (const enum PixelFormat[]) { PIX_FMT_BGR24, PIX_FMT_NONE },

     .long_name = NULL_IF_CONFIG_SMALL("LCL (LossLess Codec Library) ZLIB"),

deleted file mode 100644

@@ -1,405 +0,0 @@

-/*

- * Dirac encoding support via libdirac library

- * Copyright (c) 2005 BBC, Andrew Kennedy <dirac at rd dot bbc dot co dot uk>

- * Copyright (c) 2006-2008 BBC, Anuradha Suraparaju <asuraparaju at gmail dot com >

- *

- * This file is part of FFmpeg.

- *

- * FFmpeg is free software; you can redistribute it and/or

- * modify it under the terms of the GNU Lesser General Public

- * License as published by the Free Software Foundation; either

- * version 2.1 of the License, or (at your option) any later version.

- *

- * FFmpeg is distributed in the hope that it will be useful,

- * but WITHOUT ANY WARRANTY; without even the implied warranty of

- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

- * Lesser General Public License for more details.

- *

- * You should have received a copy of the GNU Lesser General Public

- * License along with FFmpeg; if not, write to the Free Software

- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

- */

-

-/**

-* @file

-* Dirac encoding support via libdirac library; more details about the

-* Dirac project can be found at http://dirac.sourceforge.net/.

-* The libdirac_encoder library implements Dirac specification version 2.2

-* (http://dirac.sourceforge.net/specification.html).

-*/

-

-#include "libdirac_libschro.h"

-#include "libdirac.h"

-

-#undef NDEBUG

-#include <assert.h>

-

-

-#include <libdirac_encoder/dirac_encoder.h>

-

-/** Dirac encoder private data */

-typedef struct DiracEncoderParams {

-    /** Dirac encoder context */

-    dirac_encoder_context_t enc_ctx;

-

-    /** frame being encoded */

-    AVFrame picture;

-

-    /** frame size */

-    int frame_size;

-

-    /** Dirac encoder handle */

-    dirac_encoder_t* p_encoder;

-

-    /** input frame buffer */

-    unsigned char *p_in_frame_buf;

-

-    /** buffer to store encoder output before writing it to the frame queue */

-    unsigned char *enc_buf;

-

-    /** size of encoder buffer */

-    int enc_buf_size;

-

-    /** queue storing encoded frames */

-    DiracSchroQueue enc_frame_queue;

-

-    /** end of sequence signalled by user, 0 - false, 1 - true */

-    int eos_signalled;

-

-    /** end of sequence returned by encoder, 0 - false, 1 - true */

-    int eos_pulled;

-} DiracEncoderParams;

-

-/**

-* Works out Dirac-compatible chroma format.

-*/

-static dirac_chroma_t GetDiracChromaFormat(enum PixelFormat ff_pix_fmt)

-{

-    int num_formats = sizeof(dirac_pixel_format_map) /

-                      sizeof(dirac_pixel_format_map[0]);

-    int idx;

-

-    for (idx = 0; idx < num_formats; ++idx)

-        if (dirac_pixel_format_map[idx].ff_pix_fmt == ff_pix_fmt)

-            return dirac_pixel_format_map[idx].dirac_pix_fmt;

-    return formatNK;

-}

-

-/**

-* Dirac video preset table. Ensure that this tables matches up correctly

-* with the ff_dirac_schro_video_format_info table in libdirac_libschro.c.

-*/

-static const VideoFormat ff_dirac_video_formats[]={

-    VIDEO_FORMAT_CUSTOM           ,

-    VIDEO_FORMAT_QSIF525          ,

-    VIDEO_FORMAT_QCIF             ,

-    VIDEO_FORMAT_SIF525           ,

-    VIDEO_FORMAT_CIF              ,

-    VIDEO_FORMAT_4SIF525          ,

-    VIDEO_FORMAT_4CIF             ,

-    VIDEO_FORMAT_SD_480I60        ,

-    VIDEO_FORMAT_SD_576I50        ,

-    VIDEO_FORMAT_HD_720P60        ,

-    VIDEO_FORMAT_HD_720P50        ,

-    VIDEO_FORMAT_HD_1080I60       ,

-    VIDEO_FORMAT_HD_1080I50       ,

-    VIDEO_FORMAT_HD_1080P60       ,

-    VIDEO_FORMAT_HD_1080P50       ,

-    VIDEO_FORMAT_DIGI_CINEMA_2K24 ,

-    VIDEO_FORMAT_DIGI_CINEMA_4K24 ,

-};

-

-/**

-* Returns the video format preset matching the input video dimensions and

-* time base.

-*/

-static VideoFormat GetDiracVideoFormatPreset(AVCodecContext *avccontext)

-{

-    unsigned int num_formats = sizeof(ff_dirac_video_formats) /

-                               sizeof(ff_dirac_video_formats[0]);

-

-    unsigned int idx = ff_dirac_schro_get_video_format_idx(avccontext);

-

-    return (idx < num_formats) ?

-                 ff_dirac_video_formats[idx] : VIDEO_FORMAT_CUSTOM;

-}

-

-static av_cold int libdirac_encode_init(AVCodecContext *avccontext)

-{

-

-    DiracEncoderParams* p_dirac_params = avccontext->priv_data;

-    int no_local = 1;

-    int verbose  = avccontext->debug;

-    VideoFormat preset;

-

-    /* get Dirac preset */

-    preset = GetDiracVideoFormatPreset(avccontext);

-

-    /* initialize the encoder context */

-    dirac_encoder_context_init(&p_dirac_params->enc_ctx, preset);

-

-    p_dirac_params->enc_ctx.src_params.chroma = GetDiracChromaFormat(avccontext->pix_fmt);

-

-    if (p_dirac_params->enc_ctx.src_params.chroma == formatNK) {

-        av_log(avccontext, AV_LOG_ERROR,

-               "Unsupported pixel format %d. This codec supports only "

-               "Planar YUV formats (yuv420p, yuv422p, yuv444p\n",

-               avccontext->pix_fmt);

-        return -1;

-    }

-

-    p_dirac_params->enc_ctx.src_params.frame_rate.numerator   = avccontext->time_base.den;

-    p_dirac_params->enc_ctx.src_params.frame_rate.denominator = avccontext->time_base.num;

-

-    p_dirac_params->enc_ctx.src_params.width  = avccontext->width;

-    p_dirac_params->enc_ctx.src_params.height = avccontext->height;

-

-    p_dirac_params->frame_size = avpicture_get_size(avccontext->pix_fmt,

-                                                    avccontext->width,

-                                                    avccontext->height);

-

-    avccontext->coded_frame = &p_dirac_params->picture;

-