Merge remote-tracking branch 'qatar/master'

* qatar/master: (36 commits)
  adpcmenc: Use correct frame_size for Yamaha ADPCM.
  avcodec: add ff_samples_to_time_base() convenience function to internal.h
  adx parser: set duration
  mlp parser: set duration instead of frame_size
  gsm parser: set duration
  mpegaudio parser: set duration instead of frame_size
  (e)ac3 parser: set duration instead of frame_size
  flac parser: set duration instead of frame_size
  avcodec: add duration field to AVCodecParserContext
  avutil: add av_rescale_q_rnd() to allow different rounding
  pnmdec: remove useless .pix_fmts
  libmp3lame: support float and s32 sample formats
  libmp3lame: renaming, rearrangement, alignment, and comments
  libmp3lame: use the LAME default bit rate
  libmp3lame: use avpriv_mpegaudio_decode_header() for output frame parsing
  libmp3lame: cosmetics: remove some pointless comments
  libmp3lame: convert some debugging code to av_dlog()
  libmp3lame: remove outdated comment.
  libmp3lame: do not set coded_frame->key_frame.
  libmp3lame: improve error handling in MP3lame_encode_init()
  ...

Conflicts:
	doc/APIchanges
	libavcodec/libmp3lame.c
	libavcodec/pcxenc.c
	libavcodec/pnmdec.c
	libavcodec/pnmenc.c
	libavcodec/sgienc.c
	libavcodec/utils.c
	libavformat/hls.c
	libavutil/avutil.h
	libswscale/x86/swscale_mmx.c
Merged-by: Michael Niedermayer <michaelni@gmx.at>

doc/APIchanges

@@ -32,6 +32,12 @@ API changes, most recent first:
 2012-01-24 - xxxxxxx - lavfi 2.60.100
   Add avfilter_graph_dump.
 
+2012-xx-xx - xxxxxxx - lavc 54.x.x
+  Add duration field to AVCodecParserContext
+
+2012-02-xx - xxxxxxx - lavu 51.23.1 - mathematics.h
+  Add av_rescale_q_rnd()
+
 2012-02-xx - xxxxxxx - lavu 51.22.1 - pixdesc.h
   Add PIX_FMT_PSEUDOPAL flag.
 

libavcodec/Makefile

@@ -630,7 +630,7 @@ OBJS-$(CONFIG_LIBGSM_DECODER)             += libgsm.o
 OBJS-$(CONFIG_LIBGSM_ENCODER)             += libgsm.o
 OBJS-$(CONFIG_LIBGSM_MS_DECODER)          += libgsm.o
 OBJS-$(CONFIG_LIBGSM_MS_ENCODER)          += libgsm.o
-OBJS-$(CONFIG_LIBMP3LAME_ENCODER)         += libmp3lame.o
+OBJS-$(CONFIG_LIBMP3LAME_ENCODER)         += libmp3lame.o mpegaudiodecheader.o
 OBJS-$(CONFIG_LIBOPENCORE_AMRNB_DECODER)  += libopencore-amr.o
 OBJS-$(CONFIG_LIBOPENCORE_AMRNB_ENCODER)  += libopencore-amr.o
 OBJS-$(CONFIG_LIBOPENCORE_AMRWB_DECODER)  += libopencore-amr.o

libavcodec/aac_ac3_parser.c

@@ -93,7 +93,7 @@ get_next:
             avctx->channels = s->channels;
             avctx->channel_layout = s->channel_layout;
         }
-        avctx->frame_size = s->samples;
+        s1->duration = s->samples;
         avctx->audio_service_type = s->service_type;
     }
 

libavcodec/adpcmenc.c

@@ -125,7 +125,7 @@ static av_cold int adpcm_encode_init(AVCodecContext *avctx)
         }
         break;
     case CODEC_ID_ADPCM_YAMAHA:
-        avctx->frame_size  = BLKSIZE * avctx->channels;
+        avctx->frame_size  = BLKSIZE * 2 / avctx->channels;
         avctx->block_align = BLKSIZE;
         break;
     case CODEC_ID_ADPCM_SWF:

libavcodec/adx_parser.c

@@ -80,6 +80,9 @@ static int adx_parse(AVCodecParserContext *s1,
         *poutbuf_size = 0;
         return buf_size;
     }
+
+    s1->duration = BLOCK_SAMPLES;
+
     *poutbuf = buf;
     *poutbuf_size = buf_size;
     return next;

libavcodec/avcodec.h

@@ -4182,6 +4182,13 @@ typedef struct AVCodecParserContext {
      * Previous frame byte position.
      */
     int64_t last_pos;
+
+    /**
+     * Duration of the current frame.
+     * For audio, this is in units of 1 / AVCodecContext.sample_rate.
+     * For all other types, this is in units of AVCodecContext.time_base.
+     */
+    int duration;
 } AVCodecParserContext;
 
 typedef struct AVCodecParser {

libavcodec/flac_parser.c

@@ -71,6 +71,7 @@ typedef struct FLACHeaderMarker {
 } FLACHeaderMarker;
 
 typedef struct FLACParseContext {
+    AVCodecParserContext *pc;      /**< parent context                        */
     AVCodecContext *avctx;         /**< codec context pointer for logging     */
     FLACHeaderMarker *headers;     /**< linked-list that starts at the first
                                         CRC-8 verified header within buffer   */
@@ -458,7 +459,7 @@ static int get_best_header(FLACParseContext* fpc, const uint8_t **poutbuf,
 
     fpc->avctx->sample_rate = header->fi.samplerate;
     fpc->avctx->channels    = header->fi.channels;
-    fpc->avctx->frame_size  = header->fi.blocksize;
+    fpc->pc->duration       = header->fi.blocksize;
     *poutbuf = flac_fifo_read_wrap(fpc, header->offset, *poutbuf_size,
                                         &fpc->wrap_buf,
                                         &fpc->wrap_buf_allocated_size);
@@ -484,7 +485,7 @@ static int flac_parse(AVCodecParserContext *s, AVCodecContext *avctx,
     if (s->flags & PARSER_FLAG_COMPLETE_FRAMES) {
         FLACFrameInfo fi;
         if (frame_header_is_valid(avctx, buf, &fi))
-            avctx->frame_size = fi.blocksize;
+            s->duration = fi.blocksize;
         *poutbuf      = buf;
         *poutbuf_size = buf_size;
         return buf_size;
@@ -630,8 +631,8 @@ static int flac_parse(AVCodecParserContext *s, AVCodecContext *avctx,
             av_log(avctx, AV_LOG_DEBUG, "Junk frame till offset %i\n",
                    fpc->best_header->offset);
 
-            /* Set frame_size to 0. It is unknown or invalid in a junk frame. */
-            avctx->frame_size = 0;
+            /* Set duration to 0. It is unknown or invalid in a junk frame. */
+            s->duration = 0;
             *poutbuf_size     = fpc->best_header->offset;
             *poutbuf          = flac_fifo_read_wrap(fpc, 0, *poutbuf_size,
                                                     &fpc->wrap_buf,
@@ -652,6 +653,7 @@ handle_error:
 static int flac_parse_init(AVCodecParserContext *c)
 {
     FLACParseContext *fpc = c->priv_data;
+    fpc->pc = c;
     /* There will generally be FLAC_MIN_HEADERS buffered in the fifo before
        it drains.  This is allocated early to avoid slow reallocation. */
     fpc->fifo_buf = av_fifo_alloc(FLAC_AVG_FRAME_SIZE * (FLAC_MIN_HEADERS + 3));

libavcodec/gsm_parser.c

@@ -31,6 +31,7 @@
 typedef struct GSMParseContext {
     ParseContext pc;
     int block_size;
+    int duration;
     int remaining;
 } GSMParseContext;
 
@@ -44,8 +45,14 @@ static int gsm_parse(AVCodecParserContext *s1, AVCodecContext *avctx,
 
     if (!s->block_size) {
         switch (avctx->codec_id) {
-        case CODEC_ID_GSM:    s->block_size = GSM_BLOCK_SIZE;    break;
-        case CODEC_ID_GSM_MS: s->block_size = GSM_MS_BLOCK_SIZE; break;
+        case CODEC_ID_GSM:
+            s->block_size = GSM_BLOCK_SIZE;
+            s->duration   = GSM_FRAME_SIZE;
+            break;
+        case CODEC_ID_GSM_MS:
+            s->block_size = GSM_MS_BLOCK_SIZE;
+            s->duration   = GSM_FRAME_SIZE * 2;
+            break;
         default:
             return AVERROR(EINVAL);
         }
@@ -66,6 +73,9 @@ static int gsm_parse(AVCodecParserContext *s1, AVCodecContext *avctx,
         *poutbuf_size = 0;
         return buf_size;
     }
+
+    s1->duration = s->duration;
+
     *poutbuf      = buf;
     *poutbuf_size = buf_size;
     return next;

libavcodec/huffyuv.c

@@ -1261,9 +1261,10 @@ static av_cold int decode_end(AVCodecContext *avctx)
 #endif /* CONFIG_HUFFYUV_DECODER || CONFIG_FFVHUFF_DECODER */
 
 #if CONFIG_HUFFYUV_ENCODER || CONFIG_FFVHUFF_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)
+{
     HYuvContext *s = avctx->priv_data;
-    AVFrame *pict = data;
     const int width= s->width;
     const int width2= s->width>>1;
     const int height= s->height;
@@ -1271,7 +1272,13 @@ static int encode_frame(AVCodecContext *avctx, unsigned char *buf, int buf_size,
     const int fake_ustride= s->interlaced ? pict->linesize[1]*2  : pict->linesize[1];
     const int fake_vstride= s->interlaced ? pict->linesize[2]*2  : pict->linesize[2];
     AVFrame * const p= &s->picture;
-    int i, j, size=0;
+    int i, j, size = 0, ret;
+
+    if (!pkt->data &&
+        (ret = av_new_packet(pkt, width * height * 3 * 4 + FF_MIN_BUFFER_SIZE)) < 0) {
+        av_log(avctx, AV_LOG_ERROR, "Error allocating output packet.\n");
+        return ret;
+    }
 
     *p = *pict;
     p->pict_type= AV_PICTURE_TYPE_I;
@@ -1282,7 +1289,7 @@ static int encode_frame(AVCodecContext *avctx, unsigned char *buf, int buf_size,
             generate_len_table(s->len[i], s->stats[i]);
             if(generate_bits_table(s->bits[i], s->len[i])<0)
                 return -1;
-            size+= store_table(s, s->len[i], &buf[size]);
+            size += store_table(s, s->len[i], &pkt->data[size]);
         }
 
         for(i=0; i<3; i++)
@@ -1290,7 +1297,7 @@ static int encode_frame(AVCodecContext *avctx, unsigned char *buf, int buf_size,
                 s->stats[i][j] >>= 1;
     }
 
-    init_put_bits(&s->pb, buf+size, buf_size-size);
+    init_put_bits(&s->pb, pkt->data + size, pkt->size - size);
 
     if(avctx->pix_fmt == PIX_FMT_YUV422P || avctx->pix_fmt == PIX_FMT_YUV420P){
         int lefty, leftu, leftv, y, cy;
@@ -1473,12 +1480,16 @@ static int encode_frame(AVCodecContext *avctx, unsigned char *buf, int buf_size,
         avctx->stats_out[0] = '\0';
     if(!(s->avctx->flags2 & CODEC_FLAG2_NO_OUTPUT)){
         flush_put_bits(&s->pb);
-        s->dsp.bswap_buf((uint32_t*)buf, (uint32_t*)buf, size);
+        s->dsp.bswap_buf((uint32_t*)pkt->data, (uint32_t*)pkt->data, size);
     }
 
     s->picture_number++;
 
-    return size*4;
+    pkt->size   = size*4;
+    pkt->flags |= AV_PKT_FLAG_KEY;
+    *got_packet = 1;
+
+    return 0;
 }
 
 static av_cold int encode_end(AVCodecContext *avctx)
@@ -1531,7 +1542,7 @@ AVCodec ff_huffyuv_encoder = {
     .id             = CODEC_ID_HUFFYUV,
     .priv_data_size = sizeof(HYuvContext),
     .init           = encode_init,
-    .encode         = encode_frame,
+    .encode2        = encode_frame,
     .close          = encode_end,
     .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUV422P, PIX_FMT_RGB24, PIX_FMT_RGB32, PIX_FMT_NONE},
     .long_name = NULL_IF_CONFIG_SMALL("Huffyuv / HuffYUV"),
@@ -1545,7 +1556,7 @@ AVCodec ff_ffvhuff_encoder = {
     .id             = CODEC_ID_FFVHUFF,
     .priv_data_size = sizeof(HYuvContext),
     .init           = encode_init,
-    .encode         = encode_frame,
+    .encode2        = encode_frame,
     .close          = encode_end,
     .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_RGB24, PIX_FMT_RGB32, PIX_FMT_NONE},
     .long_name = NULL_IF_CONFIG_SMALL("Huffyuv FFmpeg variant"),

libavcodec/internal.h

@@ -26,6 +26,7 @@
 
 #include <stdint.h>
 
+#include "libavutil/mathematics.h"
 #include "libavutil/pixfmt.h"
 #include "avcodec.h"
 
@@ -137,4 +138,14 @@ int avpriv_unlock_avformat(void);
  */
 int ff_alloc_packet(AVPacket *avpkt, int size);
 
+/**
+ * Rescale from sample rate to AVCodecContext.time_base.
+ */
+static av_always_inline int64_t ff_samples_to_time_base(AVCodecContext *avctx,
+                                                        int64_t samples)
+{
+    return av_rescale_q(samples, (AVRational){ 1, avctx->sample_rate },
+                        avctx->time_base);
+}
+
 #endif /* AVCODEC_INTERNAL_H */

libavcodec/libspeexenc.c

@@ -67,7 +67,6 @@
 #include <speex/speex.h>
 #include <speex/speex_header.h>
 #include <speex/speex_stereo.h>
-#include "libavutil/mathematics.h"
 #include "libavutil/opt.h"
 #include "avcodec.h"
 #include "internal.h"
@@ -258,9 +257,7 @@ static int encode_frame(AVCodecContext *avctx, uint8_t *frame, int buf_size,
     /* write output if all frames for the packet have been encoded */
     if (s->pkt_frame_count == s->frames_per_packet) {
         s->pkt_frame_count = 0;
-        avctx->coded_frame->pts =
-            av_rescale_q(s->next_pts, (AVRational){ 1, avctx->sample_rate },
-                         avctx->time_base);
+        avctx->coded_frame->pts = ff_samples_to_time_base(avctx, s->next_pts);
         s->next_pts += s->pkt_sample_count;
         s->pkt_sample_count = 0;
         if (buf_size > speex_bits_nbytes(&s->bits)) {

libavcodec/libvorbis.c

@@ -29,8 +29,8 @@
 #include "libavutil/opt.h"
 #include "avcodec.h"
 #include "bytestream.h"
+#include "internal.h"
 #include "vorbis.h"
-#include "libavutil/mathematics.h"
 
 #undef NDEBUG
 #include <assert.h>
@@ -268,7 +268,8 @@ static int oggvorbis_encode_frame(AVCodecContext *avccontext,
         op2->packet = context->buffer + sizeof(ogg_packet);
 
         l = op2->bytes;
-        avccontext->coded_frame->pts = av_rescale_q(op2->granulepos, (AVRational) { 1, avccontext->sample_rate }, avccontext->time_base);
+        avccontext->coded_frame->pts = ff_samples_to_time_base(avccontext,
+                                                               op2->granulepos);
         //FIXME we should reorder the user supplied pts and not assume that they are spaced by 1/sample_rate
 
         if (l > buf_size) {

libavcodec/mlp_parser.c

@@ -314,7 +314,7 @@ static int mlp_parse(AVCodecParserContext *s,
         else
             avctx->sample_fmt = AV_SAMPLE_FMT_S16;
         avctx->sample_rate = mh.group1_samplerate;
-        avctx->frame_size = mh.access_unit_size;
+        s->duration = mh.access_unit_size;
 
         if (mh.stream_type == 0xbb) {
             /* MLP stream */

libavcodec/mpegaudio_parser.c

@@ -78,7 +78,7 @@ static int mpegaudio_parse(AVCodecParserContext *s1,
                     if(s->header_count > 1){
                         avctx->sample_rate= sr;
                         avctx->channels   = channels;
-                        avctx->frame_size = frame_size;
+                        s1->duration      = frame_size;
                         avctx->bit_rate   = bit_rate;
                     }
                     break;

libavcodec/pcxenc.c

@@ -29,6 +29,7 @@
 #include "avcodec.h"
 #include "bytestream.h"
 #include "libavutil/imgutils.h"
+#include "internal.h"
 
 typedef struct PCXContext {
     AVFrame picture;
@@ -96,20 +97,20 @@ static int pcx_rle_encode(      uint8_t *dst, int dst_size,
     return dst - dst_start;
 }
 
-static int pcx_encode_frame(AVCodecContext *avctx,
-                            unsigned char *buf, int buf_size, void *data)
+static int pcx_encode_frame(AVCodecContext *avctx, AVPacket *pkt,
+                            const AVFrame *frame, int *got_packet)
 {
     PCXContext *s = avctx->priv_data;
     AVFrame *const pict = &s->picture;
-    const uint8_t *buf_start = buf;
-    const uint8_t *buf_end   = buf + buf_size;
+    const uint8_t *buf_end;
+    uint8_t *buf;
 
-    int bpp, nplanes, i, y, line_bytes, written;
+    int bpp, nplanes, i, y, line_bytes, written, ret, max_pkt_size;
     const uint32_t *pal = NULL;
     uint32_t palette256[256];
     const uint8_t *src;
 
-    *pict = *(AVFrame *)data;
+    *pict = *frame;
     pict->pict_type = AV_PICTURE_TYPE_I;
     pict->key_frame = 1;
 
@@ -151,6 +152,14 @@ static int pcx_encode_frame(AVCodecContext *avctx,
     line_bytes = (avctx->width * bpp + 7) >> 3;
     line_bytes = (line_bytes + 1) & ~1;
 
+    max_pkt_size = 128 + avctx->height * 2 * line_bytes * nplanes + (pal ? 256*3 + 1 : 0);
+    if ((ret = ff_alloc_packet(pkt, max_pkt_size)) < 0) {
+        av_log(avctx, AV_LOG_ERROR, "Error getting output packet of size %d.\n", max_pkt_size);
+        return ret;
+    }
+    buf     = pkt->data;
+    buf_end = pkt->data + pkt->size;
+
     bytestream_put_byte(&buf, 10);                  // manufacturer
     bytestream_put_byte(&buf, 5);                   // version
     bytestream_put_byte(&buf, 1);                   // encoding
@@ -167,7 +176,7 @@ static int pcx_encode_frame(AVCodecContext *avctx,
     bytestream_put_byte(&buf, nplanes);             // number of planes
     bytestream_put_le16(&buf, line_bytes);          // scanline plane size in bytes
 
-    while (buf - buf_start < 128)
+    while (buf - pkt->data < 128)
         *buf++= 0;
 
     src = pict->data[0];
@@ -193,7 +202,11 @@ static int pcx_encode_frame(AVCodecContext *avctx,
         }
     }
 
-    return buf - buf_start;
+    pkt->size   = buf - pkt->data;
+    pkt->flags |= AV_PKT_FLAG_KEY;
+    *got_packet = 1;
+
+    return 0;
 }
 
 AVCodec ff_pcx_encoder = {
@@ -202,7 +215,7 @@ AVCodec ff_pcx_encoder = {
     .id             = CODEC_ID_PCX,
     .priv_data_size = sizeof(PCXContext),
     .init           = pcx_encode_init,
-    .encode         = pcx_encode_frame,
+    .encode2        = pcx_encode_frame,
     .pix_fmts = (const enum PixelFormat[]){
         PIX_FMT_RGB24,
         PIX_FMT_RGB8, PIX_FMT_BGR8, PIX_FMT_RGB4_BYTE, PIX_FMT_BGR4_BYTE, PIX_FMT_GRAY8, PIX_FMT_PAL8,

libavcodec/pnmdec.c

@@ -201,7 +201,6 @@ AVCodec ff_pgm_decoder = {
     .close          = ff_pnm_end,
     .decode         = pnm_decode_frame,
     .capabilities   = CODEC_CAP_DR1,
-    .pix_fmts  = (const enum PixelFormat[]){PIX_FMT_GRAY8, PIX_FMT_GRAY16BE, PIX_FMT_NONE},
     .long_name = NULL_IF_CONFIG_SMALL("PGM (Portable GrayMap) image"),
 };
 #endif
@@ -216,7 +215,6 @@ AVCodec ff_pgmyuv_decoder = {
     .close          = ff_pnm_end,
     .decode         = pnm_decode_frame,
     .capabilities   = CODEC_CAP_DR1,
-    .pix_fmts  = (const enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_NONE},
     .long_name = NULL_IF_CONFIG_SMALL("PGMYUV (Portable GrayMap YUV) image"),
 };
 #endif
@@ -231,7 +229,6 @@ AVCodec ff_ppm_decoder = {
     .close          = ff_pnm_end,
     .decode         = pnm_decode_frame,
     .capabilities   = CODEC_CAP_DR1,
-    .pix_fmts  = (const enum PixelFormat[]){PIX_FMT_RGB24, PIX_FMT_RGB48BE, PIX_FMT_NONE},
     .long_name = NULL_IF_CONFIG_SMALL("PPM (Portable PixelMap) image"),
 };
 #endif
@@ -246,7 +243,6 @@ AVCodec ff_pbm_decoder = {
     .close          = ff_pnm_end,
     .decode         = pnm_decode_frame,
     .capabilities   = CODEC_CAP_DR1,
-    .pix_fmts  = (const enum PixelFormat[]){PIX_FMT_MONOWHITE, PIX_FMT_NONE},
     .long_name = NULL_IF_CONFIG_SMALL("PBM (Portable BitMap) image"),
 };
 #endif
@@ -261,7 +257,6 @@ AVCodec ff_pam_decoder = {
     .close          = ff_pnm_end,
     .decode         = pnm_decode_frame,
     .capabilities   = CODEC_CAP_DR1,
-    .pix_fmts  = (const enum PixelFormat[]){PIX_FMT_RGB24, PIX_FMT_RGB32, PIX_FMT_GRAY8, PIX_FMT_MONOBLACK, PIX_FMT_NONE},
     .long_name = NULL_IF_CONFIG_SMALL("PAM (Portable AnyMap) image"),
 };
 #endif

libavcodec/pnmenc.c

@@ -20,21 +20,23 @@
  */
 
 #include "avcodec.h"
+#include "internal.h"
 #include "pnm.h"
 
 
-static int pnm_encode_frame(AVCodecContext *avctx, unsigned char *outbuf,
-                            int buf_size, void *data)
+static int pnm_encode_frame(AVCodecContext *avctx, AVPacket *pkt,
+                            const AVFrame *pict, int *got_packet)
 {
     PNMContext *s     = avctx->priv_data;
-    AVFrame *pict     = data;
     AVFrame * const p = (AVFrame*)&s->picture;
-    int i, h, h1, c, n, linesize;
+    int i, h, h1, c, n, linesize, ret;
     uint8_t *ptr, *ptr1, *ptr2;
 
-    if (buf_size < avpicture_get_size(avctx->pix_fmt, avctx->width, avctx->height) + 200) {
+    if ((ret = ff_alloc_packet(pkt, avpicture_get_size(avctx->pix_fmt,
+                                                       avctx->width,
+                                                       avctx->height) + 200)) < 0) {
         av_log(avctx, AV_LOG_ERROR, "encoded frame too large\n");
-        return -1;
+        return ret;
     }
 
     *p           = *pict;
@@ -42,8 +44,8 @@ static int pnm_encode_frame(AVCodecContext *avctx, unsigned char *outbuf,
     p->key_frame = 1;
 
     s->bytestream_start =
-    s->bytestream       = outbuf;
-    s->bytestream_end   = outbuf + buf_size;
+    s->bytestream       = pkt->data;
+    s->bytestream_end   = pkt->data + pkt->size;
 
     h  = avctx->height;
     h1 = h;
@@ -107,7 +109,11 @@ static int pnm_encode_frame(AVCodecContext *avctx, unsigned char *outbuf,
                 ptr2 += p->linesize[2];
         }
     }
-    return s->bytestream - s->bytestream_start;
+    pkt->size   = s->bytestream - s->bytestream_start;
+    pkt->flags |= AV_PKT_FLAG_KEY;
+    *got_packet = 1;
+
+    return 0;
 }
 
 
@@ -118,7 +124,7 @@ AVCodec ff_pgm_encoder = {
     .id             = CODEC_ID_PGM,
     .priv_data_size = sizeof(PNMContext),
     .init           = ff_pnm_init,
-    .encode         = pnm_encode_frame,
+    .encode2        = pnm_encode_frame,
     .pix_fmts  = (const enum PixelFormat[]){PIX_FMT_GRAY8, PIX_FMT_GRAY16BE, PIX_FMT_NONE},
     .long_name = NULL_IF_CONFIG_SMALL("PGM (Portable GrayMap) image"),
 };
@@ -131,7 +137,7 @@ AVCodec ff_pgmyuv_encoder = {
     .id             = CODEC_ID_PGMYUV,
     .priv_data_size = sizeof(PNMContext),
     .init           = ff_pnm_init,
-    .encode         = pnm_encode_frame,
+    .encode2        = pnm_encode_frame,
     .pix_fmts  = (const enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_NONE},
     .long_name = NULL_IF_CONFIG_SMALL("PGMYUV (Portable GrayMap YUV) image"),
 };
@@ -144,7 +150,7 @@ AVCodec ff_ppm_encoder = {
     .id             = CODEC_ID_PPM,
     .priv_data_size = sizeof(PNMContext),
     .init           = ff_pnm_init,
-    .encode         = pnm_encode_frame,
+    .encode2        = pnm_encode_frame,
     .pix_fmts  = (const enum PixelFormat[]){PIX_FMT_RGB24, PIX_FMT_RGB48BE, PIX_FMT_NONE},
     .long_name = NULL_IF_CONFIG_SMALL("PPM (Portable PixelMap) image"),
 };
@@ -157,7 +163,7 @@ AVCodec ff_pbm_encoder = {
     .id             = CODEC_ID_PBM,
     .priv_data_size = sizeof(PNMContext),
     .init           = ff_pnm_init,
-    .encode         = pnm_encode_frame,
+    .encode2        = pnm_encode_frame,
     .pix_fmts  = (const enum PixelFormat[]){PIX_FMT_MONOWHITE, PIX_FMT_NONE},
     .long_name = NULL_IF_CONFIG_SMALL("PBM (Portable BitMap) image"),
 };

libavcodec/roqvideo.h

@@ -69,7 +69,7 @@ typedef struct RoqContext {
 
     unsigned int framesSinceKeyframe;
 
-    AVFrame *frame_to_enc;
+    const AVFrame *frame_to_enc;
     uint8_t *out_buf;
     struct RoqTempData *tmpData;
 } RoqContext;

libavcodec/roqvideoenc.c

@@ -59,6 +59,7 @@
 #include "roqvideo.h"
 #include "bytestream.h"
 #include "elbg.h"
+#include "internal.h"
 #include "mathops.h"
 
 #define CHROMA_BIAS 1
@@ -112,7 +113,7 @@ static inline int square(int x)
     return x*x;
 }
 
-static inline int eval_sse(uint8_t *a, uint8_t *b, int count)
+static inline int eval_sse(const uint8_t *a, const uint8_t *b, int count)
 {
     int diff=0;
 
@@ -124,8 +125,8 @@ static inline int eval_sse(uint8_t *a, uint8_t *b, int count)
 
 // FIXME Could use DSPContext.sse, but it is not so speed critical (used
 // just for motion estimation).
-static int block_sse(uint8_t **buf1, uint8_t **buf2, int x1, int y1, int x2,
-                     int y2, int *stride1, int *stride2, int size)
+static int block_sse(uint8_t * const *buf1, uint8_t * const *buf2, int x1, int y1,
+                     int x2, int y2, const int *stride1, const int *stride2, int size)
 {
     int i, k;
     int sse=0;
@@ -260,7 +261,7 @@ static void create_cel_evals(RoqContext *enc, RoqTempdata *tempData)
 /**
  * Get macroblocks from parts of the image
  */
-static void get_frame_mb(AVFrame *frame, int x, int y, uint8_t mb[], int dim)
+static void get_frame_mb(const AVFrame *frame, int x, int y, uint8_t mb[], int dim)
 {
     int i, j, cp;
 
@@ -754,8 +755,8 @@ static void reconstruct_and_encode_image(RoqContext *enc, RoqTempdata *tempData,
 /**
  * Create a single YUV cell from a 2x2 section of the image
  */
-static inline void frame_block_to_cell(uint8_t *block, uint8_t **data,
-                                       int top, int left, int *stride)
+static inline void frame_block_to_cell(uint8_t *block, uint8_t * const *data,
+                                       int top, int left, const int *stride)
 {
     int i, j, u=0, v=0;
 
@@ -775,7 +776,7 @@ static inline void frame_block_to_cell(uint8_t *block, uint8_t **data,
 /**
  * Create YUV clusters for the entire image
  */
-static void create_clusters(AVFrame *frame, int w, int h, uint8_t *yuvClusters)
+static void create_clusters(const AVFrame *frame, int w, int h, uint8_t *yuvClusters)
 {
     int i, j, k, l;
 
@@ -1001,13 +1002,12 @@ static void roq_write_video_info_chunk(RoqContext *enc)
     bytestream_put_byte(&enc->out_buf, 0x00);
 }
 
-static int roq_encode_frame(AVCodecContext *avctx, unsigned char *buf, int buf_size, void *data)
+static int roq_encode_frame(AVCodecContext *avctx, AVPacket *pkt,
+                            const AVFrame *frame, int *got_packet)
 {
     RoqContext *enc = avctx->priv_data;
-    AVFrame *frame= data;
-    uint8_t *buf_start = buf;
+    int size, ret;
 
-    enc->out_buf = buf;
     enc->avctx = avctx;
 
     enc->frame_to_enc = frame;
@@ -1019,10 +1019,12 @@ static int roq_encode_frame(AVCodecContext *avctx, unsigned char *buf, int buf_s
 
     /* 138 bits max per 8x8 block +
      *     256 codebooks*(6 bytes 2x2 + 4 bytes 4x4) + 8 bytes frame header */
-    if (((enc->width*enc->height/64)*138+7)/8 + 256*(6+4) + 8 > buf_size) {
-        av_log(avctx, AV_LOG_ERROR, "  RoQ: Output buffer too small!\n");
-        return -1;
+    size = ((enc->width * enc->height / 64) * 138 + 7) / 8 + 256 * (6 + 4) + 8;
+    if ((ret = ff_alloc_packet(pkt, size)) < 0) {
+        av_log(avctx, AV_LOG_ERROR, "Error getting output packet with size %d.\n", size);
+        return ret;
     }
+    enc->out_buf = pkt->data;
 
     /* Check for I frame */
     if (enc->framesSinceKeyframe == avctx->gop_size)
@@ -1046,7 +1048,12 @@ static int roq_encode_frame(AVCodecContext *avctx, unsigned char *buf, int buf_s
     /* Encode the actual frame */
     roq_encode_video(enc);
 
-    return enc->out_buf - buf_start;
+    pkt->size   = enc->out_buf - pkt->data;
+    if (enc->framesSinceKeyframe == 1)
+        pkt->flags |= AV_PKT_FLAG_KEY;
+    *got_packet = 1;
+
+    return 0;
 }
 
 static int roq_encode_end(AVCodecContext *avctx)
@@ -1071,7 +1078,7 @@ AVCodec ff_roq_encoder = {
     .id                   = CODEC_ID_ROQ,
     .priv_data_size       = sizeof(RoqContext),
     .init                 = roq_encode_init,
-    .encode               = roq_encode_frame,
+    .encode2              = roq_encode_frame,
     .close                = roq_encode_end,
     .supported_framerates = (const AVRational[]){{30,1}, {0,0}},
     .pix_fmts             = (const enum PixelFormat[]){PIX_FMT_YUV444P, PIX_FMT_NONE},

libavcodec/sgienc.c

@@ -21,6 +21,7 @@
 
 #include "avcodec.h"
 #include "bytestream.h"
+#include "internal.h"
 #include "sgi.h"
 #include "rle.h"
 
@@ -41,17 +42,17 @@ static av_cold int encode_init(AVCodecContext *avctx)
     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 *frame, int *got_packet)
 {
     SgiContext *s = avctx->priv_data;
     AVFrame * const p = &s->picture;
-    uint8_t *offsettab, *lengthtab, *in_buf, *encode_buf;
-    int x, y, z, length, tablesize;
+    uint8_t *offsettab, *lengthtab, *in_buf, *encode_buf, *buf;
+    int x, y, z, length, tablesize, ret;
     unsigned int width, height, depth, dimension, bytes_per_channel, pixmax, put_be;
-    unsigned char *orig_buf = buf, *end_buf = buf + buf_size;
+    unsigned char *end_buf;
 
-    *p = *(AVFrame*)data;
+    *p = *frame;
     p->pict_type = AV_PICTURE_TYPE_I;
     p->key_frame = 1;
 
@@ -106,12 +107,18 @@ static int encode_frame(AVCodecContext *avctx, unsigned char *buf,
     }
 
     tablesize = depth * height * 4;
-    length = tablesize * 2 + SGI_HEADER_SIZE;
-
-    if (buf_size < length) {
-        av_log(avctx, AV_LOG_ERROR, "buf_size too small(need %d, got %d)\n", length, buf_size);
-        return -1;
+    length = SGI_HEADER_SIZE;
+    if (avctx->coder_type == FF_CODER_TYPE_RAW)
+        length += depth * height * width;
+    else // assume ff_rl_encode() produces at most 2x size of input
+        length += tablesize * 2 + depth * height * (2 * width + 1);
+
+    if ((ret = ff_alloc_packet(pkt, length)) < 0) {
+        av_log(avctx, AV_LOG_ERROR, "Error getting output packet of size %d.\n", length);
+        return ret;
     }
+    buf     = pkt->data;
+    end_buf = pkt->data + pkt->size;
 
     /* Encode header. */
     bytestream_put_be16(&buf, SGI_MAGIC);
@@ -153,7 +160,7 @@ static int encode_frame(AVCodecContext *avctx, unsigned char *buf,
             in_buf = p->data[0] + p->linesize[0] * (height - 1) + z;
 
             for (y = 0; y < height; y++) {
-                bytestream_put_be32(&offsettab, buf - orig_buf);
+                bytestream_put_be32(&offsettab, buf - pkt->data);
 
                 for (x = 0; x < width; x++)
                     encode_buf[x] = in_buf[depth * x];
@@ -193,7 +200,11 @@ static int encode_frame(AVCodecContext *avctx, unsigned char *buf,
     }
 
     /* total length */
-    return buf - orig_buf;
+    pkt->size = buf - pkt->data;
+    pkt->flags |= AV_PKT_FLAG_KEY;
+    *got_packet = 1;
+
+    return 0;
 }
 
 AVCodec ff_sgi_encoder = {
@@ -202,7 +213,7 @@ AVCodec ff_sgi_encoder = {
     .id             = CODEC_ID_SGI,
     .priv_data_size = sizeof(SgiContext),
     .init           = encode_init,
-    .encode         = encode_frame,
+    .encode2        = encode_frame,
     .pix_fmts= (const enum PixelFormat[]){PIX_FMT_RGB24, PIX_FMT_RGBA,
                                           PIX_FMT_RGB48LE, PIX_FMT_RGB48BE,
                                           PIX_FMT_RGBA64LE, PIX_FMT_RGBA64BE,

libavcodec/targaenc.c

@@ -22,6 +22,7 @@
 #include "libavutil/intreadwrite.h"
 #include "libavutil/pixdesc.h"
 #include "avcodec.h"
+#include "internal.h"
 #include "rle.h"
 #include "targa.h"
 
@@ -39,7 +40,7 @@ typedef struct TargaContext {
  * @param h Image height
  * @return Size of output in bytes, or -1 if larger than out_size
  */
-static int targa_encode_rle(uint8_t *outbuf, int out_size, AVFrame *pic,
+static int targa_encode_rle(uint8_t *outbuf, int out_size, const AVFrame *pic,
                             int bpp, int w, int h)
 {
     int y,ret;
@@ -59,7 +60,7 @@ static int targa_encode_rle(uint8_t *outbuf, int out_size, AVFrame *pic,
     return out - outbuf;
 }
 
-static int targa_encode_normal(uint8_t *outbuf, AVFrame *pic, int bpp, int w, int h)
+static int targa_encode_normal(uint8_t *outbuf, const AVFrame *pic, int bpp, int w, int h)
 {
     int i, n = bpp * w;
     uint8_t *out = outbuf;
@@ -74,11 +75,10 @@ static int targa_encode_normal(uint8_t *outbuf, AVFrame *pic, int bpp, int w, in
     return out - outbuf;
 }
 
-static int targa_encode_frame(AVCodecContext *avctx,
-                              unsigned char *outbuf,
-                              int buf_size, void *data){
-    AVFrame *p = data;
-    int bpp, picsize, datasize = -1;
+static int targa_encode_frame(AVCodecContext *avctx, AVPacket *pkt,
+                              const AVFrame *p, int *got_packet)
+{
+    int bpp, picsize, datasize = -1, ret;
     uint8_t *out;
 
     if(avctx->width > 0xffff || avctx->height > 0xffff) {
@@ -86,46 +86,43 @@ static int targa_encode_frame(AVCodecContext *avctx,
         return AVERROR(EINVAL);
     }
     picsize = avpicture_get_size(avctx->pix_fmt, avctx->width, avctx->height);
-    if(buf_size < picsize + 45) {
+    if ((ret = ff_alloc_packet(pkt, picsize + 45)) < 0) {
         av_log(avctx, AV_LOG_ERROR, "encoded frame too large\n");
-        return AVERROR(EINVAL);
+        return ret;
     }
 
-    p->pict_type= AV_PICTURE_TYPE_I;
-    p->key_frame= 1;
-
     /* zero out the header and only set applicable fields */
-    memset(outbuf, 0, 12);
-    AV_WL16(outbuf+12, avctx->width);
-    AV_WL16(outbuf+14, avctx->height);
+    memset(pkt->data, 0, 12);
+    AV_WL16(pkt->data+12, avctx->width);
+    AV_WL16(pkt->data+14, avctx->height);
     /* image descriptor byte: origin is always top-left, bits 0-3 specify alpha */
-    outbuf[17] = 0x20 | (avctx->pix_fmt == PIX_FMT_BGRA ? 8 : 0);
+    pkt->data[17] = 0x20 | (avctx->pix_fmt == PIX_FMT_BGRA ? 8 : 0);
 
     switch(avctx->pix_fmt) {
     case PIX_FMT_GRAY8:
-        outbuf[2] = TGA_BW;      /* uncompressed grayscale image */
-        outbuf[16] = 8;          /* bpp */
+        pkt->data[2]  = TGA_BW;     /* uncompressed grayscale image */
+        pkt->data[16] = 8;          /* bpp */
         break;
     case PIX_FMT_RGB555LE:
-        outbuf[2] = TGA_RGB;     /* uncompresses true-color image */
-        outbuf[16] = 16;         /* bpp */
+        pkt->data[2]  = TGA_RGB;    /* uncompresses true-color image */
+        pkt->data[16] = 16;         /* bpp */
         break;
     case PIX_FMT_BGR24:
-        outbuf[2] = TGA_RGB;     /* uncompressed true-color image */
-        outbuf[16] = 24;         /* bpp */
+        pkt->data[2]  = TGA_RGB;    /* uncompressed true-color image */
+        pkt->data[16] = 24;         /* bpp */
         break;
     case PIX_FMT_BGRA:
-        outbuf[2] = TGA_RGB;     /* uncompressed true-color image */
-        outbuf[16] = 32;         /* bpp */
+        pkt->data[2]  = TGA_RGB;    /* uncompressed true-color image */
+        pkt->data[16] = 32;         /* bpp */
         break;
     default:
         av_log(avctx, AV_LOG_ERROR, "Pixel format '%s' not supported.\n",
                av_get_pix_fmt_name(avctx->pix_fmt));
         return AVERROR(EINVAL);
     }
-    bpp = outbuf[16] >> 3;
+    bpp = pkt->data[16] >> 3;
 
-    out = outbuf + 18;  /* skip past the header we just output */
+    out = pkt->data + 18;  /* skip past the header we just output */
 
     /* try RLE compression */
     if (avctx->coder_type != FF_CODER_TYPE_RAW)
@@ -133,7 +130,7 @@ static int targa_encode_frame(AVCodecContext *avctx,
 
     /* if that worked well, mark the picture as RLE compressed */
     if(datasize >= 0)
-        outbuf[2] |= 8;
+        pkt->data[2] |= 8;
 
     /* if RLE didn't make it smaller, go back to no compression */
     else datasize = targa_encode_normal(out, p, bpp, avctx->width, avctx->height);
@@ -145,7 +142,11 @@ static int targa_encode_frame(AVCodecContext *avctx,
      * aspect ratio and encoder ID fields available? */
     memcpy(out, "\0\0\0\0\0\0\0\0TRUEVISION-XFILE.", 26);
 
-    return out + 26 - outbuf;
+    pkt->size   = out + 26 - pkt->data;
+    pkt->flags |= AV_PKT_FLAG_KEY;
+    *got_packet = 1;
+
+    return 0;
 }
 
 static av_cold int targa_encode_init(AVCodecContext *avctx)
@@ -154,6 +155,7 @@ static av_cold int targa_encode_init(AVCodecContext *avctx)
 
     avcodec_get_frame_defaults(&s->picture);
     s->picture.key_frame= 1;
+    s->picture.pict_type = AV_PICTURE_TYPE_I;
     avctx->coded_frame= &s->picture;
 
     return 0;
@@ -165,7 +167,7 @@ AVCodec ff_targa_encoder = {
     .id = CODEC_ID_TARGA,
     .priv_data_size = sizeof(TargaContext),
     .init = targa_encode_init,
-    .encode = targa_encode_frame,
+    .encode2 = targa_encode_frame,
     .pix_fmts= (const enum PixelFormat[]){PIX_FMT_BGR24, PIX_FMT_BGRA, PIX_FMT_RGB555LE, PIX_FMT_GRAY8, PIX_FMT_NONE},
     .long_name= NULL_IF_CONFIG_SMALL("Truevision Targa image"),
 };

libavcodec/utils.c

@@ -993,9 +993,8 @@ int attribute_align_arg avcodec_encode_audio2(AVCodecContext *avctx,
         if (!ret && *got_packet_ptr) {
             if (!(avctx->codec->capabilities & CODEC_CAP_DELAY)) {
                 avpkt->pts = frame->pts;
-                avpkt->duration = av_rescale_q(frame->nb_samples,
-                                               (AVRational){ 1, avctx->sample_rate },
-                                               avctx->time_base);
+                avpkt->duration = ff_samples_to_time_base(avctx,
+                                                          frame->nb_samples);
             }
             avpkt->dts = avpkt->pts;
         } else {
@@ -1053,9 +1052,8 @@ int attribute_align_arg avcodec_encode_audio2(AVCodecContext *avctx,
                    once all encoders supporting CODEC_CAP_SMALL_LAST_FRAME use
                    encode2() */
                 if (fs_tmp) {
-                    avpkt->duration = av_rescale_q(avctx->frame_size,
-                                                   (AVRational){ 1, avctx->sample_rate },
-                                                   avctx->time_base);
+                    avpkt->duration = ff_samples_to_time_base(avctx,
+                                                              avctx->frame_size);
                 }
             }
             avpkt->size = ret;
@@ -1128,9 +1126,8 @@ int attribute_align_arg avcodec_encode_audio(AVCodecContext *avctx,
            this is needed because the avcodec_encode_audio() API does not have
            a way for the user to provide pts */
         if(avctx->sample_rate && avctx->time_base.num)
-            frame->pts = av_rescale_q(avctx->internal->sample_count,
-                                  (AVRational){ 1, avctx->sample_rate },
-                                  avctx->time_base);
+            frame->pts = ff_samples_to_time_base(avctx,
+                                                avctx->internal->sample_count);
         else
             frame->pts = AV_NOPTS_VALUE;
         avctx->internal->sample_count += frame->nb_samples;

libavcodec/v410enc.c

@@ -22,6 +22,7 @@
 
 #include "libavutil/intreadwrite.h"
 #include "avcodec.h"
+#include "internal.h"
 
 static av_cold int v410_encode_init(AVCodecContext *avctx)
 {
@@ -40,20 +41,19 @@ static av_cold int v410_encode_init(AVCodecContext *avctx)
     return 0;
 }
 
-static int v410_encode_frame(AVCodecContext *avctx, uint8_t *buf,
-                             int buf_size, void *data)
+static int v410_encode_frame(AVCodecContext *avctx, AVPacket *pkt,
+                             const AVFrame *pic, int *got_packet)
 {
-    AVFrame *pic = data;
-    uint8_t *dst = buf;
+    uint8_t *dst;
     uint16_t *y, *u, *v;
     uint32_t val;
-    int i, j;
-    int output_size = 0;
+    int i, j, ret;
 
-    if (buf_size < avctx->width * avctx->height * 4) {
-        av_log(avctx, AV_LOG_ERROR, "Out buffer is too small.\n");
-        return AVERROR(ENOMEM);
+    if ((ret = ff_alloc_packet(pkt, avctx->width * avctx->height * 4)) < 0) {
+        av_log(avctx, AV_LOG_ERROR, "Error getting output packet.\n");
+        return ret;
     }
+    dst = pkt->data;
 
     avctx->coded_frame->reference = 0;
     avctx->coded_frame->key_frame = 1;
@@ -70,14 +70,15 @@ static int v410_encode_frame(AVCodecContext *avctx, uint8_t *buf,
             val |= (uint32_t) v[j] << 22;
             AV_WL32(dst, val);
             dst += 4;
-            output_size += 4;
         }
         y += pic->linesize[0] >> 1;
         u += pic->linesize[1] >> 1;
         v += pic->linesize[2] >> 1;
     }
 
-    return output_size;
+    pkt->flags |= AV_PKT_FLAG_KEY;
+    *got_packet = 1;
+    return 0;
 }
 
 static av_cold int v410_encode_close(AVCodecContext *avctx)
@@ -92,7 +93,7 @@ AVCodec ff_v410_encoder = {
     .type         = AVMEDIA_TYPE_VIDEO,
     .id           = CODEC_ID_V410,
     .init         = v410_encode_init,
-    .encode       = v410_encode_frame,
+    .encode2      = v410_encode_frame,
     .close        = v410_encode_close,
     .pix_fmts     = (const enum PixelFormat[]){ PIX_FMT_YUV444P10, PIX_FMT_NONE },
     .long_name    = NULL_IF_CONFIG_SMALL("Uncompressed 4:4:4 10-bit"),

libavcodec/x86/h264_deblock.asm

@@ -830,9 +830,13 @@ cglobal deblock_v_chroma_8_mmxext, 5,6
 ; void ff_deblock_h_chroma( uint8_t *pix, int stride, int alpha, int beta, int8_t *tc0 )
 ;-----------------------------------------------------------------------------
 cglobal deblock_h_chroma_8_mmxext, 5,7
-%if ARCH_X86_64
+%if UNIX64
     %define buf0 [rsp-24]
     %define buf1 [rsp-16]
+%elif WIN64
+    sub   rsp, 16
+    %define buf0 [rsp]
+    %define buf1 [rsp+8]
 %else
     %define buf0 r0m
     %define buf1 r2m
@@ -849,6 +853,9 @@ cglobal deblock_h_chroma_8_mmxext, 5,7
     movq  m0, buf0
     movq  m3, buf1
     TRANSPOSE8x4B_STORE PASS8ROWS(t5, r0, r1, t6)
+%if WIN64
+    add   rsp, 16
+%endif
     RET
 
 ALIGN 16

libavcodec/zmbvenc.c

@@ -29,6 +29,7 @@
 
 #include "libavutil/intreadwrite.h"
 #include "avcodec.h"
+#include "internal.h"
 
 #include <zlib.h>
 
@@ -115,19 +116,18 @@ static int zmbv_me(ZmbvEncContext *c, uint8_t *src, int sstride, uint8_t *prev,
     return bv;
 }
 
-static int encode_frame(AVCodecContext *avctx, uint8_t *buf, int buf_size, void *data)
+static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
+                        const AVFrame *pict, int *got_packet)
 {
     ZmbvEncContext * const c = avctx->priv_data;
-    AVFrame *pict = data;
     AVFrame * const p = &c->pic;
-    uint8_t *src, *prev;
+    uint8_t *src, *prev, *buf;
     uint32_t *palptr;
-    int len = 0;
     int keyframe, chpal;
     int fl;
-    int work_size = 0;
+    int work_size = 0, pkt_size;
     int bw, bh;
-    int i, j;
+    int i, j, ret;
 
     keyframe = !c->curfrm;
     c->curfrm++;
@@ -138,17 +138,6 @@ static int encode_frame(AVCodecContext *avctx, uint8_t *buf, int buf_size, void
     p->key_frame= keyframe;
     chpal = !keyframe && memcmp(p->data[1], c->pal2, 1024);
 
-    fl = (keyframe ? ZMBV_KEYFRAME : 0) | (chpal ? ZMBV_DELTAPAL : 0);
-    *buf++ = fl; len++;
-    if(keyframe){
-        deflateReset(&c->zstream);
-        *buf++ = 0; len++; // hi ver
-        *buf++ = 1; len++; // lo ver
-        *buf++ = 1; len++; // comp
-        *buf++ = 4; len++; // format - 8bpp
-        *buf++ = ZMBV_BLOCK; len++; // block width
-        *buf++ = ZMBV_BLOCK; len++; // block height
-    }
     palptr = (uint32_t*)p->data[1];
     src = p->data[0];
     prev = c->prev;
@@ -223,6 +212,9 @@ static int encode_frame(AVCodecContext *avctx, uint8_t *buf, int buf_size, void
         src += p->linesize[0];
     }
 
+    if (keyframe)
+        deflateReset(&c->zstream);
+
     c->zstream.next_in = c->work_buf;
     c->zstream.avail_in = work_size;
     c->zstream.total_in = 0;
@@ -235,8 +227,29 @@ static int encode_frame(AVCodecContext *avctx, uint8_t *buf, int buf_size, void
         return -1;
     }
 
+    pkt_size = c->zstream.total_out + 1 + 6*keyframe;
+    if ((ret = ff_alloc_packet(pkt, pkt_size)) < 0) {
+        av_log(avctx, AV_LOG_ERROR, "Error getting packet of size %d.\n", pkt_size);
+        return ret;
+    }
+    buf = pkt->data;
+
+    fl = (keyframe ? ZMBV_KEYFRAME : 0) | (chpal ? ZMBV_DELTAPAL : 0);
+    *buf++ = fl;
+    if (keyframe) {
+        *buf++ = 0; // hi ver
+        *buf++ = 1; // lo ver
+        *buf++ = 1; // comp
+        *buf++ = 4; // format - 8bpp
+        *buf++ = ZMBV_BLOCK; // block width
+        *buf++ = ZMBV_BLOCK; // block height
+    }
     memcpy(buf, c->comp_buf, c->zstream.total_out);
-    return len + c->zstream.total_out;
+
+    pkt->flags |= AV_PKT_FLAG_KEY*keyframe;
+    *got_packet = 1;
+
+    return 0;
 }
 
 
@@ -329,7 +342,7 @@ AVCodec ff_zmbv_encoder = {
     .id             = CODEC_ID_ZMBV,
     .priv_data_size = sizeof(ZmbvEncContext),
     .init           = encode_init,
-    .encode         = encode_frame,
+    .encode2        = encode_frame,
     .close          = encode_end,
     .pix_fmts = (const enum PixelFormat[]){PIX_FMT_PAL8, PIX_FMT_NONE},
     .long_name = NULL_IF_CONFIG_SMALL("Zip Motion Blocks Video"),

libavformat/hls.c

@@ -609,16 +609,13 @@ start:
         if (var->needed && !var->pkt.data) {
             while (1) {
                 int64_t ts_diff;
+                AVStream *st;
                 ret = av_read_frame(var->ctx, &var->pkt);
                 if (ret < 0) {
-                    if (!url_feof(&var->pb)) {
+                    if (!url_feof(&var->pb))
                         return ret;
-                    } else {
-                        if ((var->cur_seq_no - var->start_seq_no) == (var->n_segments)) {
-                            return AVERROR_EOF;
-                        }
-                    }
                     reset_packet(&var->pkt);
+                    break;
                 } else {
                     if (c->first_timestamp == AV_NOPTS_VALUE)
                         c->first_timestamp = var->pkt.dts;
@@ -632,21 +629,17 @@ start:
                     break;
                 }
 
-                ts_diff = var->pkt.dts - c->seek_timestamp;
-                if (ts_diff >= 0) {
-                    if (c->seek_flags & AVSEEK_FLAG_ANY) {
-                        c->seek_timestamp = AV_NOPTS_VALUE;
-                        break;
-                    }
-
-                    /* Seek to keyframe */
-                    if (var->pkt.flags & AV_PKT_FLAG_KEY) {
+                st = var->ctx->streams[var->pkt.stream_index];
+                ts_diff = av_rescale_rnd(var->pkt.dts, AV_TIME_BASE,
+                                         st->time_base.den, AV_ROUND_DOWN) -
+                          c->seek_timestamp;
+                if (ts_diff >= 0 && (c->seek_flags  & AVSEEK_FLAG_ANY ||
+                                     var->pkt.flags & AV_PKT_FLAG_KEY)) {
                     c->seek_timestamp = AV_NOPTS_VALUE;
                     break;
                 }
             }
         }
-        }
         /* Check if this stream has the packet with the lowest dts */
         if (var->pkt.data) {
             if (minvariant < 0 ||
@@ -685,8 +678,12 @@ static int hls_read_seek(AVFormatContext *s, int stream_index,
     if ((flags & AVSEEK_FLAG_BYTE) || !c->variants[0]->finished)
         return AVERROR(ENOSYS);
 
-    c->seek_timestamp = timestamp;
     c->seek_flags     = flags;
+    c->seek_timestamp = stream_index < 0 ? timestamp :
+                        av_rescale_rnd(timestamp, AV_TIME_BASE,
+                                       s->streams[stream_index]->time_base.den,
+                                       flags & AVSEEK_FLAG_BACKWARD ?
+                                       AV_ROUND_DOWN : AV_ROUND_UP);
     timestamp = av_rescale_rnd(timestamp, 1, stream_index >= 0 ?
                                s->streams[stream_index]->time_base.den :
                                AV_TIME_BASE, flags & AVSEEK_FLAG_BACKWARD ?
@@ -712,6 +709,10 @@ static int hls_read_seek(AVFormatContext *s, int stream_index,
         av_free_packet(&var->pkt);
         reset_packet(&var->pkt);
         var->pb.eof_reached = 0;
+        /* Clear any buffered data */
+        var->pb.buf_end = var->pb.buf_ptr = var->pb.buffer;
+        /* Reset the pos, to let the mpegts demuxer know we've seeked. */
+        var->pb.pos = 0;
 
         /* Locate the segment that contains the target timestamp */
         for (j = 0; j < var->n_segments; j++) {
@@ -723,7 +724,7 @@ static int hls_read_seek(AVFormatContext *s, int stream_index,
             }
             pos += var->segments[j]->duration;
         }
-        if (ret != 0)
+        if (ret)
             c->seek_timestamp = AV_NOPTS_VALUE;
     }
     return ret;

libavformat/utils.c

@@ -942,11 +942,10 @@ static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
         compute_frame_duration(&num, &den, st, pc, pkt);
         if (den && num) {
             pkt->duration = av_rescale_rnd(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num, AV_ROUND_DOWN);
-
-            if(pkt->duration != 0 && s->packet_buffer)
-                update_initial_durations(s, st, pkt);
         }
     }
+    if(pkt->duration != 0 && s->packet_buffer)
+        update_initial_durations(s, st, pkt);
 
     /* correct timestamps with byte offset if demuxers only have timestamps
        on packet boundaries */
@@ -1099,6 +1098,20 @@ static int read_frame_internal(AVFormatContext *s, AVPacket *pkt)
                 if (pkt->size) {
                 got_packet:
                     pkt->duration = 0;
+                    if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
+                        if (st->codec->sample_rate > 0) {
+                            pkt->duration = av_rescale_q_rnd(st->parser->duration,
+                                                             (AVRational){ 1, st->codec->sample_rate },
+                                                             st->time_base,
+                                                             AV_ROUND_DOWN);
+                        }
+                    } else if (st->codec->time_base.num != 0 &&
+                               st->codec->time_base.den != 0) {
+                        pkt->duration = av_rescale_q_rnd(st->parser->duration,
+                                                         st->codec->time_base,
+                                                         st->time_base,
+                                                         AV_ROUND_DOWN);
+                    }
                     pkt->stream_index = st->index;
                     pkt->pts = st->parser->pts;
                     pkt->dts = st->parser->dts;

libavutil/avutil.h

@@ -154,7 +154,7 @@
  */
 
 #define LIBAVUTIL_VERSION_MAJOR 51
-#define LIBAVUTIL_VERSION_MINOR 39
+#define LIBAVUTIL_VERSION_MINOR 40
 #define LIBAVUTIL_VERSION_MICRO 100
 
 #define LIBAVUTIL_VERSION_INT   AV_VERSION_INT(LIBAVUTIL_VERSION_MAJOR, \

libavutil/mathematics.c

@@ -131,10 +131,17 @@ int64_t av_rescale(int64_t a, int64_t b, int64_t c){
     return av_rescale_rnd(a, b, c, AV_ROUND_NEAR_INF);
 }
 
-int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq){
+int64_t av_rescale_q_rnd(int64_t a, AVRational bq, AVRational cq,
+                         enum AVRounding rnd)
+{
     int64_t b= bq.num * (int64_t)cq.den;
     int64_t c= cq.num * (int64_t)bq.den;
-    return av_rescale_rnd(a, b, c, AV_ROUND_NEAR_INF);
+    return av_rescale_rnd(a, b, c, rnd);
+}
+
+int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
+{
+    return av_rescale_q_rnd(a, bq, cq, AV_ROUND_NEAR_INF);
 }
 
 int av_compare_ts(int64_t ts_a, AVRational tb_a, int64_t ts_b, AVRational tb_b){

libavutil/mathematics.h

@@ -95,6 +95,12 @@ int64_t av_rescale_rnd(int64_t a, int64_t b, int64_t c, enum AVRounding) av_cons
  */
 int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq) av_const;
 
+/**
+ * Rescale a 64-bit integer by 2 rational numbers with specified rounding.
+ */
+int64_t av_rescale_q_rnd(int64_t a, AVRational bq, AVRational cq,
+                         enum AVRounding) av_const;
+
 /**
  * Compare 2 timestamps each in its own timebases.
  * The result of the function is undefined if one of the timestamps

libswscale/swscale_internal.h

@@ -358,10 +358,11 @@ typedef struct SwsContext {
 #define U_TEMP                "11*8+4*4*256*2+24"
 #define V_TEMP                "11*8+4*4*256*2+32"
 #define Y_TEMP                "11*8+4*4*256*2+40"
-#define UV_OFF_PX             "11*8+4*4*256*2+48"
-#define UV_OFF_BYTE           "11*8+4*4*256*2+56"
-#define DITHER16              "11*8+4*4*256*2+64"
-#define DITHER32              "11*8+4*4*256*2+80"
+#define ALP_MMX_FILTER_OFFSET "11*8+4*4*256*2+48"
+#define UV_OFF_PX             "11*8+4*4*256*3+48"
+#define UV_OFF_BYTE           "11*8+4*4*256*3+56"
+#define DITHER16              "11*8+4*4*256*3+64"
+#define DITHER32              "11*8+4*4*256*3+80"
 
     DECLARE_ALIGNED(8, uint64_t, redDither);
     DECLARE_ALIGNED(8, uint64_t, greenDither);
@@ -383,6 +384,7 @@ typedef struct SwsContext {
     DECLARE_ALIGNED(8, uint64_t, u_temp);
     DECLARE_ALIGNED(8, uint64_t, v_temp);
     DECLARE_ALIGNED(8, uint64_t, y_temp);
+    int32_t alpMmxFilter[4 * MAX_FILTER_SIZE];
     // alignment of these values is not necessary, but merely here
     // to maintain the same offset across x8632 and x86-64. Once we
     // use proper offset macros in the asm, they can be removed.
@@ -421,7 +423,6 @@ typedef struct SwsContext {
 #if HAVE_VIS
     DECLARE_ALIGNED(8, uint64_t, sparc_coeffs)[10];
 #endif
-    int32_t alpMmxFilter[4 * MAX_FILTER_SIZE];
     int use_mmx_vfilter;
 
     /* function pointers for swScale() */

libswscale/x86/swscale_template.c

@@ -342,7 +342,7 @@ static void RENAME(yuv2rgb32_X_ar)(SwsContext *c, const int16_t *lumFilter,
         "movq                      %%mm2, "U_TEMP"(%0)  \n\t"
         "movq                      %%mm4, "V_TEMP"(%0)  \n\t"
         "movq                      %%mm5, "Y_TEMP"(%0)  \n\t"
-        YSCALEYUV2PACKEDX_ACCURATE_YA(LUM_MMX_FILTER_OFFSET)
+        YSCALEYUV2PACKEDX_ACCURATE_YA(ALP_MMX_FILTER_OFFSET)
         "movq               "Y_TEMP"(%0), %%mm5         \n\t"
         "psraw                        $3, %%mm1         \n\t"
         "psraw                        $3, %%mm7         \n\t"
@@ -372,7 +372,7 @@ static void RENAME(yuv2rgb32_X)(SwsContext *c, const int16_t *lumFilter,
     if (CONFIG_SWSCALE_ALPHA && c->alpPixBuf) {
         YSCALEYUV2PACKEDX
         YSCALEYUV2RGBX
-        YSCALEYUV2PACKEDX_YA(LUM_MMX_FILTER_OFFSET, %%mm0, %%mm3, %%mm6, %%mm1, %%mm7)
+        YSCALEYUV2PACKEDX_YA(ALP_MMX_FILTER_OFFSET, %%mm0, %%mm3, %%mm6, %%mm1, %%mm7)
         "psraw                        $3, %%mm1         \n\t"
         "psraw                        $3, %%mm7         \n\t"
         "packuswb                  %%mm7, %%mm1         \n\t"

tests/ref/acodec/adpcm_yam

-006f8dc92eb4f7bab82eded314ca1124 *./tests/data/acodec/adpcm_yam.wav
-266298 ./tests/data/acodec/adpcm_yam.wav
-c36a9d5a1e0ad57fbe9665a31373b7c1 *./tests/data/adpcm_yam.acodec.out.wav
-stddev: 1247.60 PSNR: 34.41 MAXDIFF:39895 bytes:  1064960/  1058400
+e9c14f701d25947317db9367b9dc772d *./tests/data/acodec/adpcm_yam.wav
+265274 ./tests/data/acodec/adpcm_yam.wav
+1488b5974fa040a65f0d407fc0224c6a *./tests/data/adpcm_yam.acodec.out.wav
+stddev: 1247.60 PSNR: 34.41 MAXDIFF:39895 bytes:  1060864/  1058400