@@ -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.

@@ -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

@@ -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;

     }

@@ -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:

@@ -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;

@@ -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 {

@@ -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));

@@ -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;

@@ -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"),

@@ -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 */

@@ -24,261 +24,227 @@

  * Interface to libmp3lame for mp3 encoding.

  */

+#include <lame/lame.h>

+

 #include "libavutil/intreadwrite.h"

 #include "libavutil/log.h"

 #include "libavutil/opt.h"

 #include "avcodec.h"

+#include "internal.h"

 #include "mpegaudio.h"

-#include <lame/lame.h>

+#include "mpegaudiodecheader.h"

 #define BUFFER_SIZE (7200 + 2 * MPA_FRAME_SIZE + MPA_FRAME_SIZE / 4+1000) // FIXME: Buffer size to small? Adding 1000 to make up for it.

-typedef struct Mp3AudioContext {

+

+typedef struct LAMEContext {

     AVClass *class;

+    AVCodecContext *avctx;

     lame_global_flags *gfp;

-    int stereo;

     uint8_t buffer[BUFFER_SIZE];

     int buffer_index;

-    struct {

-        int *left;

-        int *right;

-    } s32_data;

     int reservoir;

-} Mp3AudioContext;

+    void *planar_samples[2];

+} LAMEContext;

+

-static av_cold int MP3lame_encode_init(AVCodecContext *avctx)

+static av_cold int mp3lame_encode_close(AVCodecContext *avctx)

 {

-    Mp3AudioContext *s = avctx->priv_data;

+    LAMEContext *s = avctx->priv_data;

+    av_freep(&avctx->coded_frame);

+    av_freep(&s->planar_samples[0]);

+    av_freep(&s->planar_samples[1]);

+

+    lame_close(s->gfp);

+    return 0;

+}

+

+static av_cold int mp3lame_encode_init(AVCodecContext *avctx)

+{

+    LAMEContext *s = avctx->priv_data;

+    int ret;

+

+    s->avctx = avctx;

+

+    /* initialize LAME and get defaults */

+    if ((s->gfp = lame_init()) == NULL)

+        return AVERROR(ENOMEM);

+

+    /* channels */

     if (avctx->channels > 2) {

         av_log(avctx, AV_LOG_ERROR,

                "Invalid number of channels %d, must be <= 2\n", avctx->channels);

-        return AVERROR(EINVAL);

+        ret =  AVERROR(EINVAL);

+        goto error;

     }

+    lame_set_num_channels(s->gfp, avctx->channels);

+    lame_set_mode(s->gfp, avctx->channels > 1 ? JOINT_STEREO : MONO);

-    s->stereo = avctx->channels > 1 ? 1 : 0;

-

-    if ((s->gfp = lame_init()) == NULL)

-        goto err;

-    lame_set_in_samplerate(s->gfp, avctx->sample_rate);

+    /* sample rate */

+    lame_set_in_samplerate (s->gfp, avctx->sample_rate);

     lame_set_out_samplerate(s->gfp, avctx->sample_rate);

-    lame_set_num_channels(s->gfp, avctx->channels);

-    if (avctx->compression_level == FF_COMPRESSION_DEFAULT) {

+

+    /* algorithmic quality */

+    if (avctx->compression_level == FF_COMPRESSION_DEFAULT)

         lame_set_quality(s->gfp, 5);

-    } else {

+    else

         lame_set_quality(s->gfp, avctx->compression_level);

-    }

-    lame_set_mode(s->gfp, s->stereo ? JOINT_STEREO : MONO);

-    lame_set_brate(s->gfp, avctx->bit_rate / 1000);

+

+    /* rate control */

     if (avctx->flags & CODEC_FLAG_QSCALE) {

-        lame_set_brate(s->gfp, 0);

         lame_set_VBR(s->gfp, vbr_default);

         lame_set_VBR_quality(s->gfp, avctx->global_quality / (float)FF_QP2LAMBDA);

+    } else {

+        if (avctx->bit_rate)

+            lame_set_brate(s->gfp, avctx->bit_rate / 1000);

     }

-    lame_set_bWriteVbrTag(s->gfp,0);

-    lame_set_disable_reservoir(s->gfp, !s->reservoir);

-    if (lame_init_params(s->gfp) < 0)

-        goto err_close;

-    avctx->frame_size             = lame_get_framesize(s->gfp);

+    /* do not get a Xing VBR header frame from LAME */

+    lame_set_bWriteVbrTag(s->gfp,0);

-    if(!(avctx->coded_frame= avcodec_alloc_frame())) {

-        lame_close(s->gfp);

+    /* bit reservoir usage */

+    lame_set_disable_reservoir(s->gfp, !s->reservoir);

-        return AVERROR(ENOMEM);

+    /* set specified parameters */

+    if (lame_init_params(s->gfp) < 0) {

+        ret = -1;

+        goto error;

     }

-    if(AV_SAMPLE_FMT_S32 == avctx->sample_fmt && s->stereo) {

-        int nelem = 2 * avctx->frame_size;

-

-        if(! (s->s32_data.left = av_malloc(nelem * sizeof(int)))) {

-            av_freep(&avctx->coded_frame);

-            lame_close(s->gfp);

+    avctx->frame_size  = lame_get_framesize(s->gfp);

+    avctx->coded_frame = avcodec_alloc_frame();

+    if (!avctx->coded_frame) {

+        ret = AVERROR(ENOMEM);

+        goto error;

+    }

-            return AVERROR(ENOMEM);

+    /* sample format */

+    if (avctx->sample_fmt == AV_SAMPLE_FMT_S32 ||

+        avctx->sample_fmt == AV_SAMPLE_FMT_FLT) {

+        int ch;

+        for (ch = 0; ch < avctx->channels; ch++) {

+            s->planar_samples[ch] = av_malloc(avctx->frame_size *

+                                              av_get_bytes_per_sample(avctx->sample_fmt));

+            if (!s->planar_samples[ch]) {

+                ret = AVERROR(ENOMEM);

+                goto error;

+            }

         }

-

-        s->s32_data.right = s->s32_data.left + avctx->frame_size;

     }

     return 0;

-

-err_close:

-    lame_close(s->gfp);

-err:

-    return -1;

+error:

+    mp3lame_encode_close(avctx);

+    return ret;

 }

-static const int sSampleRates[] = {

-    44100, 48000,  32000, 22050, 24000, 16000, 11025, 12000, 8000, 0

-};

-

-static const int sBitRates[2][3][15] = {

-    {

-        { 0, 32, 64, 96, 128, 160, 192, 224, 256, 288, 320, 352, 384, 416, 448 },

-        { 0, 32, 48, 56, 64,  80,  96,  112, 128, 160, 192, 224, 256, 320, 384 },

-        { 0, 32, 40, 48, 56,  64,  80,  96,  112, 128, 160, 192, 224, 256, 320 }

-    },

-    {

-        { 0, 32, 48, 56, 64, 80, 96, 112, 128, 144, 160, 176, 192, 224, 256 },

-        { 0,  8, 16, 24, 32, 40, 48,  56,  64,  80,  96, 112, 128, 144, 160 },

-        { 0,  8, 16, 24, 32, 40, 48,  56,  64,  80,  96, 112, 128, 144, 160 }

-    },

-};

-

-static const int sSamplesPerFrame[2][3] = {

-    { 384, 1152, 1152 },

-    { 384, 1152,  576 }

-};

-

-static const int sBitsPerSlot[3] = { 32, 8, 8 };

-

-static int mp3len(void *data, int *samplesPerFrame, int *sampleRate)

+#define DEINTERLEAVE(type, scale) do {                  \

+    int ch, i;                                          \

+    for (ch = 0; ch < s->avctx->channels; ch++) {       \

+        const type *input = samples;                    \

+        type      *output = s->planar_samples[ch];      \

+        input += ch;                                    \

+        for (i = 0; i < s->avctx->frame_size; i++) {    \

+            output[i] = *input * scale;                 \

+            input += s->avctx->channels;                \

+        }                                               \

+    }                                                   \

+} while (0)

+

+static int encode_frame_int16(LAMEContext *s, void *samples)

 {

-    uint32_t header  = AV_RB32(data);

-    int layerID      = 3 - ((header >> 17) & 0x03);

-    int bitRateID    = ((header >> 12) & 0x0f);

-    int sampleRateID = ((header >> 10) & 0x03);

-    int bitsPerSlot  = sBitsPerSlot[layerID];

-    int isPadded     = ((header >> 9) & 0x01);

-    static int const mode_tab[4] = { 2, 3, 1, 0 };

-    int mode    = mode_tab[(header >> 19) & 0x03];

-    int mpeg_id = mode > 0;

-    int temp0, temp1, bitRate;

-

-    if (((header >> 21) & 0x7ff) != 0x7ff || mode == 3 || layerID == 3 ||

-        sampleRateID == 3) {

-        return -1;

+    if (s->avctx->channels > 1) {

+        return lame_encode_buffer_interleaved(s->gfp, samples,

+                                              s->avctx->frame_size,

+                                              s->buffer + s->buffer_index,

+                                              BUFFER_SIZE - s->buffer_index);

+    } else {

+        return lame_encode_buffer(s->gfp, samples, NULL, s->avctx->frame_size,

+                                  s->buffer + s->buffer_index,

+                                  BUFFER_SIZE - s->buffer_index);

     }

+}

-    if (!samplesPerFrame)

-        samplesPerFrame = &temp0;

-    if (!sampleRate)

-        sampleRate      = &temp1;

+static int encode_frame_int32(LAMEContext *s, void *samples)

+{

+    DEINTERLEAVE(int32_t, 1);

-    //*isMono = ((header >>  6) & 0x03) == 0x03;

+    return lame_encode_buffer_int(s->gfp,

+                                  s->planar_samples[0], s->planar_samples[1],

+                                  s->avctx->frame_size,

+                                  s->buffer + s->buffer_index,

+                                  BUFFER_SIZE - s->buffer_index);

+}

-    *sampleRate      = sSampleRates[sampleRateID] >> mode;

-    bitRate          = sBitRates[mpeg_id][layerID][bitRateID] * 1000;

-    *samplesPerFrame = sSamplesPerFrame[mpeg_id][layerID];

-    //av_log(NULL, AV_LOG_DEBUG,

-    //       "sr:%d br:%d spf:%d l:%d m:%d\n",

-    //       *sampleRate, bitRate, *samplesPerFrame, layerID, mode);

+static int encode_frame_float(LAMEContext *s, void *samples)

+{

+    DEINTERLEAVE(float, 32768.0f);

-    return *samplesPerFrame * bitRate / (bitsPerSlot * *sampleRate) + isPadded;

+    return lame_encode_buffer_float(s->gfp,

+                                    s->planar_samples[0], s->planar_samples[1],

+                                    s->avctx->frame_size,

+                                    s->buffer + s->buffer_index,

+                                    BUFFER_SIZE - s->buffer_index);

 }

-static int MP3lame_encode_frame(AVCodecContext *avctx, unsigned char *frame,

+static int mp3lame_encode_frame(AVCodecContext *avctx, unsigned char *frame,

                                 int buf_size, void *data)

 {

-    Mp3AudioContext *s = avctx->priv_data;

+    LAMEContext *s = avctx->priv_data;

+    MPADecodeHeader hdr;

     int len;

     int lame_result;

-    /* lame 3.91 dies on '1-channel interleaved' data */

-

-    if (!data){

-        lame_result= lame_encode_flush(

-                s->gfp,

-                s->buffer + s->buffer_index,

-                BUFFER_SIZE - s->buffer_index

-                );

-#if 2147483647 == INT_MAX

-    }else if(AV_SAMPLE_FMT_S32 == avctx->sample_fmt){

-        if (s->stereo) {

-            int32_t *rp = data;

-            int32_t *mp = rp + 2*avctx->frame_size;

-            int *wpl = s->s32_data.left;

-            int *wpr = s->s32_data.right;

-

-            while (rp < mp) {

-                *wpl++ = *rp++;

-                *wpr++ = *rp++;

-            }

-

-            lame_result = lame_encode_buffer_int(

-                s->gfp,

-                s->s32_data.left,

-                s->s32_data.right,

-                avctx->frame_size,

-                s->buffer + s->buffer_index,

-                BUFFER_SIZE - s->buffer_index

-                );

-        } else {

-            lame_result = lame_encode_buffer_int(

-                s->gfp,

-                data,

-                data,

-                avctx->frame_size,

-                s->buffer + s->buffer_index,

-                BUFFER_SIZE - s->buffer_index

-                );

-        }

-#endif

-    }else{

-        if (s->stereo) {

-            lame_result = lame_encode_buffer_interleaved(

-                s->gfp,

-                data,

-                avctx->frame_size,

-                s->buffer + s->buffer_index,

-                BUFFER_SIZE - s->buffer_index

-                );

-        } else {

-            lame_result = lame_encode_buffer(

-                s->gfp,

-                data,

-                data,

-                avctx->frame_size,

-                s->buffer + s->buffer_index,

-                BUFFER_SIZE - s->buffer_index

-                );

+    if (data) {

+        switch (avctx->sample_fmt) {

+        case AV_SAMPLE_FMT_S16:

+            lame_result = encode_frame_int16(s, data);

+            break;

+        case AV_SAMPLE_FMT_S32:

+            lame_result = encode_frame_int32(s, data);

+            break;

+        case AV_SAMPLE_FMT_FLT:

+            lame_result = encode_frame_float(s, data);

+            break;

+        default:

+            return AVERROR_BUG;

         }

+    } else {

+        lame_result = lame_encode_flush(s->gfp, s->buffer + s->buffer_index,

+                                        BUFFER_SIZE - s->buffer_index);

     }

-

     if (lame_result < 0) {

         if (lame_result == -1) {

-            /* output buffer too small */

             av_log(avctx, AV_LOG_ERROR,

                    "lame: output buffer too small (buffer index: %d, free bytes: %d)\n",

                    s->buffer_index, BUFFER_SIZE - s->buffer_index);

         }

         return -1;

     }

-

     s->buffer_index += lame_result;

+    /* Move 1 frame from the LAME buffer to the output packet, if available.

+       We have to parse the first frame header in the output buffer to

+       determine the frame size. */

     if (s->buffer_index < 4)

         return 0;

-

-    len = mp3len(s->buffer, NULL, NULL);

-    //av_log(avctx, AV_LOG_DEBUG, "in:%d packet-len:%d index:%d\n",

-    //       avctx->frame_size, len, s->buffer_index);

+    if (avpriv_mpegaudio_decode_header(&hdr, AV_RB32(s->buffer))) {

+        av_log(avctx, AV_LOG_ERROR, "free format output not supported\n");

+        return -1;

+    }

+    len = hdr.frame_size;

+    av_dlog(avctx, "in:%d packet-len:%d index:%d\n", avctx->frame_size, len,

+            s->buffer_index);

     if (len <= s->buffer_index) {

         memcpy(frame, s->buffer, len);

         s->buffer_index -= len;

-

         memmove(s->buffer, s->buffer + len, s->buffer_index);

-        // FIXME fix the audio codec API, so we do not need the memcpy()

-        /*for(i=0; i<len; i++) {

-            av_log(avctx, AV_LOG_DEBUG, "%2X ", frame[i]);

-        }*/

         return len;

     } else

         return 0;

 }

-static av_cold int MP3lame_encode_close(AVCodecContext *avctx)

-{

-    Mp3AudioContext *s = avctx->priv_data;

-

-    av_freep(&s->s32_data.left);

-    av_freep(&avctx->coded_frame);

-

-    lame_close(s->gfp);

-    return 0;

-}

-

-#define OFFSET(x) offsetof(Mp3AudioContext, x)

+#define OFFSET(x) offsetof(LAMEContext, x)

 #define AE AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM

 static const AVOption options[] = {

     { "reservoir", "Use bit reservoir.", OFFSET(reservoir), AV_OPT_TYPE_INT, { 1 }, 0, 1, AE },

@@ -292,21 +258,30 @@ static const AVClass libmp3lame_class = {

     .version    = LIBAVUTIL_VERSION_INT,

 };

+static const AVCodecDefault libmp3lame_defaults[] = {

+    { "b",          "0" },

+    { NULL },

+};

+

+static const int libmp3lame_sample_rates[] = {

+    44100, 48000,  32000, 22050, 24000, 16000, 11025, 12000, 8000, 0

+};

+

 AVCodec ff_libmp3lame_encoder = {

     .name                  = "libmp3lame",

     .type                  = AVMEDIA_TYPE_AUDIO,

     .id                    = CODEC_ID_MP3,

-    .priv_data_size        = sizeof(Mp3AudioContext),

-    .init                  = MP3lame_encode_init,

-    .encode                = MP3lame_encode_frame,

-    .close                 = MP3lame_encode_close,

+    .priv_data_size        = sizeof(LAMEContext),

+    .init                  = mp3lame_encode_init,

+    .encode                = mp3lame_encode_frame,

+    .close                 = mp3lame_encode_close,

     .capabilities          = CODEC_CAP_DELAY,

-    .sample_fmts           = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16,

-#if 2147483647 == INT_MAX

-    AV_SAMPLE_FMT_S32,

-#endif

+    .sample_fmts           = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S32,

+                                                             AV_SAMPLE_FMT_FLT,

+                                                             AV_SAMPLE_FMT_S16,

                                                              AV_SAMPLE_FMT_NONE },

-    .supported_samplerates = sSampleRates,

+    .supported_samplerates = libmp3lame_sample_rates,

     .long_name             = NULL_IF_CONFIG_SMALL("libmp3lame MP3 (MPEG audio layer 3)"),

     .priv_class            = &libmp3lame_class,

+    .defaults              = libmp3lame_defaults,

 };

@@ -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)) {

@@ -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) {

@@ -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 */

@@ -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;

@@ -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,

@@ -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},