Merge commit '2df0c32ea12ddfa72ba88309812bfb13b674130f'
authorMichael Niedermayer <michaelni@gmx.at>
Tue, 14 Oct 2014 00:16:16 +0000 (02:16 +0200)
committerMichael Niedermayer <michaelni@gmx.at>
Tue, 14 Oct 2014 00:16:16 +0000 (02:16 +0200)
* commit '2df0c32ea12ddfa72ba88309812bfb13b674130f':
  lavc: use a separate field for exporting audio encoder padding

Conflicts:
libavcodec/audio_frame_queue.c
libavcodec/avcodec.h
libavcodec/libvorbisenc.c
libavcodec/utils.c
libavcodec/version.h
libavcodec/wmaenc.c

Merged-by: Michael Niedermayer <michaelni@gmx.at>
22 files changed:
1  2 
doc/APIchanges
libavcodec/aacenc.c
libavcodec/ac3enc.c
libavcodec/audio_frame_queue.c
libavcodec/avcodec.h
libavcodec/g722enc.c
libavcodec/libfaac.c
libavcodec/libfdk-aacenc.c
libavcodec/libmp3lame.c
libavcodec/libopencore-amr.c
libavcodec/libopusenc.c
libavcodec/libspeexenc.c
libavcodec/libtwolame.c
libavcodec/libvo-aacenc.c
libavcodec/libvo-amrwbenc.c
libavcodec/libvorbisenc.c
libavcodec/mpegaudioenc_template.c
libavcodec/nellymoserenc.c
libavcodec/ra144enc.c
libavcodec/utils.c
libavcodec/version.h
libavcodec/wmaenc.c

diff --cc doc/APIchanges
Simple merge
Simple merge
Simple merge
  
  av_cold void ff_af_queue_init(AVCodecContext *avctx, AudioFrameQueue *afq)
  {
 -    afq->avctx             = avctx;
 -    afq->next_pts          = AV_NOPTS_VALUE;
 +    afq->avctx = avctx;
-     afq->remaining_delay   = avctx->delay;
-     afq->remaining_samples = avctx->delay;
+     afq->remaining_delay   = avctx->initial_padding;
+     afq->remaining_samples = avctx->initial_padding;
 -    afq->frame_queue       = NULL;
 -}
 -
 -static void delete_next_frame(AudioFrameQueue *afq)
 -{
 -    AudioFrame *f = afq->frame_queue;
 -    if (f) {
 -        afq->frame_queue = f->next;
 -        f->next = NULL;
 -        av_freep(&f);
 -    }
 +    afq->frame_count       = 0;
  }
  
  void ff_af_queue_close(AudioFrameQueue *afq)
@@@ -2981,132 -2773,23 +2972,149 @@@ typedef struct AVCodecContext 
      int side_data_only_packets;
  
      /**
+      * Audio only. The number of "priming" samples (padding) inserted by the
+      * encoder at the beginning of the audio. I.e. this number of leading
+      * decoded samples must be discarded by the caller to get the original audio
+      * without leading padding.
+      *
+      * - decoding: unused
+      * - encoding: Set by libavcodec. The timestamps on the output packets are
+      *             adjusted by the encoder so that they always refer to the
+      *             first sample of the data actually contained in the packet,
+      *             including any added padding.  E.g. if the timebase is
+      *             1/samplerate and the timestamp of the first input sample is
+      *             0, the timestamp of the first output packet will be
+      *             -initial_padding.
+      */
+     int initial_padding;
++
++    /**
 +     * Timebase in which pkt_dts/pts and AVPacket.dts/pts are.
 +     * Code outside libavcodec should access this field using:
 +     * av_codec_{get,set}_pkt_timebase(avctx)
 +     * - encoding unused.
 +     * - decoding set by user.
 +     */
 +    AVRational pkt_timebase;
 +
 +    /**
 +     * AVCodecDescriptor
 +     * Code outside libavcodec should access this field using:
 +     * av_codec_{get,set}_codec_descriptor(avctx)
 +     * - encoding: unused.
 +     * - decoding: set by libavcodec.
 +     */
 +    const AVCodecDescriptor *codec_descriptor;
 +
 +#if !FF_API_LOWRES
 +    /**
 +     * low resolution decoding, 1-> 1/2 size, 2->1/4 size
 +     * - encoding: unused
 +     * - decoding: Set by user.
 +     * Code outside libavcodec should access this field using:
 +     * av_codec_{get,set}_lowres(avctx)
 +     */
 +     int lowres;
 +#endif
 +
 +    /**
 +     * Current statistics for PTS correction.
 +     * - decoding: maintained and used by libavcodec, not intended to be used by user apps
 +     * - encoding: unused
 +     */
 +    int64_t pts_correction_num_faulty_pts; /// Number of incorrect PTS values so far
 +    int64_t pts_correction_num_faulty_dts; /// Number of incorrect DTS values so far
 +    int64_t pts_correction_last_pts;       /// PTS of the last frame
 +    int64_t pts_correction_last_dts;       /// DTS of the last frame
 +
 +    /**
 +     * Character encoding of the input subtitles file.
 +     * - decoding: set by user
 +     * - encoding: unused
 +     */
 +    char *sub_charenc;
 +
 +    /**
 +     * Subtitles character encoding mode. Formats or codecs might be adjusting
 +     * this setting (if they are doing the conversion themselves for instance).
 +     * - decoding: set by libavcodec
 +     * - encoding: unused
 +     */
 +    int sub_charenc_mode;
 +#define FF_SUB_CHARENC_MODE_DO_NOTHING  -1  ///< do nothing (demuxer outputs a stream supposed to be already in UTF-8, or the codec is bitmap for instance)
 +#define FF_SUB_CHARENC_MODE_AUTOMATIC    0  ///< libavcodec will select the mode itself
 +#define FF_SUB_CHARENC_MODE_PRE_DECODER  1  ///< the AVPacket data needs to be recoded to UTF-8 before being fed to the decoder, requires iconv
 +
 +    /**
 +     * Skip processing alpha if supported by codec.
 +     * Note that if the format uses pre-multiplied alpha (common with VP6,
 +     * and recommended due to better video quality/compression)
 +     * the image will look as if alpha-blended onto a black background.
 +     * However for formats that do not use pre-multiplied alpha
 +     * there might be serious artefacts (though e.g. libswscale currently
 +     * assumes pre-multiplied alpha anyway).
 +     * Code outside libavcodec should access this field using AVOptions
 +     *
 +     * - decoding: set by user
 +     * - encoding: unused
 +     */
 +    int skip_alpha;
 +
 +    /**
 +     * Number of samples to skip after a discontinuity
 +     * - decoding: unused
 +     * - encoding: set by libavcodec
 +     */
 +    int seek_preroll;
 +
 +#if !FF_API_DEBUG_MV
 +    /**
 +     * debug motion vectors
 +     * Code outside libavcodec should access this field using AVOptions
 +     * - encoding: Set by user.
 +     * - decoding: Set by user.
 +     */
 +    int debug_mv;
 +#define FF_DEBUG_VIS_MV_P_FOR  0x00000001 //visualize forward predicted MVs of P frames
 +#define FF_DEBUG_VIS_MV_B_FOR  0x00000002 //visualize forward predicted MVs of B frames
 +#define FF_DEBUG_VIS_MV_B_BACK 0x00000004 //visualize backward predicted MVs of B frames
 +#endif
 +
 +    /**
 +     * custom intra quantization matrix
 +     * Code outside libavcodec should access this field using av_codec_g/set_chroma_intra_matrix()
 +     * - encoding: Set by user, can be NULL.
 +     * - decoding: unused.
 +     */
 +    uint16_t *chroma_intra_matrix;
 +
 +    /**
 +     * dump format separator.
 +     * can be ", " or "\n      " or anything else
 +     * Code outside libavcodec should access this field using AVOptions
 +     * (NO direct access).
 +     * - encoding: Set by user.
 +     * - decoding: Set by user.
 +     */
 +    uint8_t *dump_separator;
 +
  } AVCodecContext;
  
 +AVRational av_codec_get_pkt_timebase         (const AVCodecContext *avctx);
 +void       av_codec_set_pkt_timebase         (AVCodecContext *avctx, AVRational val);
 +
 +const AVCodecDescriptor *av_codec_get_codec_descriptor(const AVCodecContext *avctx);
 +void                     av_codec_set_codec_descriptor(AVCodecContext *avctx, const AVCodecDescriptor *desc);
 +
 +int  av_codec_get_lowres(const AVCodecContext *avctx);
 +void av_codec_set_lowres(AVCodecContext *avctx, int val);
 +
 +int  av_codec_get_seek_preroll(const AVCodecContext *avctx);
 +void av_codec_set_seek_preroll(AVCodecContext *avctx, int val);
 +
 +uint16_t *av_codec_get_chroma_intra_matrix(const AVCodecContext *avctx);
 +void av_codec_set_chroma_intra_matrix(AVCodecContext *avctx, uint16_t *val);
 +
  /**
   * AVProfile.
   */
Simple merge
@@@ -151,23 -152,12 +151,23 @@@ static av_cold int Faac_encode_init(AVC
      }
  
      if (!faacEncSetConfiguration(s->faac_handle, faac_cfg)) {
 -        av_log(avctx, AV_LOG_ERROR, "libfaac doesn't support this output format!\n");
 -        ret = AVERROR(EINVAL);
 -        goto error;
 +        int i;
 +        for (i = avctx->bit_rate/1000; i ; i--) {
 +            faac_cfg->bitRate = 1000*i / avctx->channels;
 +            if (faacEncSetConfiguration(s->faac_handle, faac_cfg))
 +                break;
 +        }
 +        if (!i) {
 +            av_log(avctx, AV_LOG_ERROR, "libfaac doesn't support this output format!\n");
 +            ret = AVERROR(EINVAL);
 +            goto error;
 +        } else {
 +            avctx->bit_rate = 1000*i;
 +            av_log(avctx, AV_LOG_WARNING, "libfaac doesn't support the specified bitrate, using %dkbit/s instead\n", i);
 +        }
      }
  
-     avctx->delay = FAAC_DELAY_SAMPLES;
+     avctx->initial_padding = FAAC_DELAY_SAMPLES;
      ff_af_queue_init(avctx, &s->afq);
  
      return 0;
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
@@@ -152,10 -148,10 +152,10 @@@ static int twolame_encode_frame(AVCodec
      if (ret < 0)  // twolame error
          return AVERROR_UNKNOWN;
  
 -    avpkt->duration = ff_samples_to_time_base(avctx, frame->nb_samples);
      if (frame) {
 +        avpkt->duration = ff_samples_to_time_base(avctx, frame->nb_samples);
          if (frame->pts != AV_NOPTS_VALUE)
-             avpkt->pts = frame->pts - ff_samples_to_time_base(avctx, avctx->delay);
+             avpkt->pts = frame->pts - ff_samples_to_time_base(avctx, avctx->initial_padding);
      } else {
          avpkt->pts = s->next_pts;
      }
Simple merge
Simple merge
index ed6baa9,0000000..96af536
mode 100644,000000..100644
--- /dev/null
@@@ -1,377 -1,0 +1,377 @@@
-         if (!avctx->delay && s->afq.frames) {
-             avctx->delay              = duration;
 +/*
 + * Copyright (c) 2002 Mark Hills <mark@pogo.org.uk>
 + *
 + * 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
 + */
 +
 +#include <vorbis/vorbisenc.h>
 +
 +#include "libavutil/avassert.h"
 +#include "libavutil/fifo.h"
 +#include "libavutil/opt.h"
 +#include "avcodec.h"
 +#include "audio_frame_queue.h"
 +#include "internal.h"
 +#include "vorbis.h"
 +#include "vorbis_parser.h"
 +
 +
 +/* Number of samples the user should send in each call.
 + * This value is used because it is the LCD of all possible frame sizes, so
 + * an output packet will always start at the same point as one of the input
 + * packets.
 + */
 +#define LIBVORBIS_FRAME_SIZE 64
 +
 +#define BUFFER_SIZE (1024 * 64)
 +
 +typedef struct LibvorbisEncContext {
 +    AVClass *av_class;                  /**< class for AVOptions            */
 +    vorbis_info vi;                     /**< vorbis_info used during init   */
 +    vorbis_dsp_state vd;                /**< DSP state used for analysis    */
 +    vorbis_block vb;                    /**< vorbis_block used for analysis */
 +    AVFifoBuffer *pkt_fifo;             /**< output packet buffer           */
 +    int eof;                            /**< end-of-file flag               */
 +    int dsp_initialized;                /**< vd has been initialized        */
 +    vorbis_comment vc;                  /**< VorbisComment info             */
 +    double iblock;                      /**< impulse block bias option      */
 +    VorbisParseContext vp;              /**< parse context to get durations */
 +    AudioFrameQueue afq;                /**< frame queue for timestamps     */
 +} LibvorbisEncContext;
 +
 +static const AVOption options[] = {
 +    { "iblock", "Sets the impulse block bias", offsetof(LibvorbisEncContext, iblock), AV_OPT_TYPE_DOUBLE, { .dbl = 0 }, -15, 0, AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM },
 +    { NULL }
 +};
 +
 +static const AVCodecDefault defaults[] = {
 +    { "b",  "0" },
 +    { NULL },
 +};
 +
 +static const AVClass vorbis_class = {
 +    .class_name = "libvorbis",
 +    .item_name  = av_default_item_name,
 +    .option     = options,
 +    .version    = LIBAVUTIL_VERSION_INT,
 +};
 +
 +static int vorbis_error_to_averror(int ov_err)
 +{
 +    switch (ov_err) {
 +    case OV_EFAULT: return AVERROR_BUG;
 +    case OV_EINVAL: return AVERROR(EINVAL);
 +    case OV_EIMPL:  return AVERROR(EINVAL);
 +    default:        return AVERROR_UNKNOWN;
 +    }
 +}
 +
 +static av_cold int libvorbis_setup(vorbis_info *vi, AVCodecContext *avctx)
 +{
 +    LibvorbisEncContext *s = avctx->priv_data;
 +    double cfreq;
 +    int ret;
 +
 +    if (avctx->flags & CODEC_FLAG_QSCALE || !avctx->bit_rate) {
 +        /* variable bitrate
 +         * NOTE: we use the oggenc range of -1 to 10 for global_quality for
 +         *       user convenience, but libvorbis uses -0.1 to 1.0.
 +         */
 +        float q = avctx->global_quality / (float)FF_QP2LAMBDA;
 +        /* default to 3 if the user did not set quality or bitrate */
 +        if (!(avctx->flags & CODEC_FLAG_QSCALE))
 +            q = 3.0;
 +        if ((ret = vorbis_encode_setup_vbr(vi, avctx->channels,
 +                                           avctx->sample_rate,
 +                                           q / 10.0)))
 +            goto error;
 +    } else {
 +        int minrate = avctx->rc_min_rate > 0 ? avctx->rc_min_rate : -1;
 +        int maxrate = avctx->rc_max_rate > 0 ? avctx->rc_max_rate : -1;
 +
 +        /* average bitrate */
 +        if ((ret = vorbis_encode_setup_managed(vi, avctx->channels,
 +                                               avctx->sample_rate, maxrate,
 +                                               avctx->bit_rate, minrate)))
 +            goto error;
 +
 +        /* variable bitrate by estimate, disable slow rate management */
 +        if (minrate == -1 && maxrate == -1)
 +            if ((ret = vorbis_encode_ctl(vi, OV_ECTL_RATEMANAGE2_SET, NULL)))
 +                goto error; /* should not happen */
 +    }
 +
 +    /* cutoff frequency */
 +    if (avctx->cutoff > 0) {
 +        cfreq = avctx->cutoff / 1000.0;
 +        if ((ret = vorbis_encode_ctl(vi, OV_ECTL_LOWPASS_SET, &cfreq)))
 +            goto error; /* should not happen */
 +    }
 +
 +    /* impulse block bias */
 +    if (s->iblock) {
 +        if ((ret = vorbis_encode_ctl(vi, OV_ECTL_IBLOCK_SET, &s->iblock)))
 +            goto error;
 +    }
 +
 +    if (avctx->channels == 3 &&
 +            avctx->channel_layout != (AV_CH_LAYOUT_STEREO|AV_CH_FRONT_CENTER) ||
 +        avctx->channels == 4 &&
 +            avctx->channel_layout != AV_CH_LAYOUT_2_2 &&
 +            avctx->channel_layout != AV_CH_LAYOUT_QUAD ||
 +        avctx->channels == 5 &&
 +            avctx->channel_layout != AV_CH_LAYOUT_5POINT0 &&
 +            avctx->channel_layout != AV_CH_LAYOUT_5POINT0_BACK ||
 +        avctx->channels == 6 &&
 +            avctx->channel_layout != AV_CH_LAYOUT_5POINT1 &&
 +            avctx->channel_layout != AV_CH_LAYOUT_5POINT1_BACK ||
 +        avctx->channels == 7 &&
 +            avctx->channel_layout != (AV_CH_LAYOUT_5POINT1|AV_CH_BACK_CENTER) ||
 +        avctx->channels == 8 &&
 +            avctx->channel_layout != AV_CH_LAYOUT_7POINT1) {
 +        if (avctx->channel_layout) {
 +            char name[32];
 +            av_get_channel_layout_string(name, sizeof(name), avctx->channels,
 +                                         avctx->channel_layout);
 +            av_log(avctx, AV_LOG_ERROR, "%s not supported by Vorbis: "
 +                                             "output stream will have incorrect "
 +                                             "channel layout.\n", name);
 +        } else {
 +            av_log(avctx, AV_LOG_WARNING, "No channel layout specified. The encoder "
 +                                               "will use Vorbis channel layout for "
 +                                               "%d channels.\n", avctx->channels);
 +        }
 +    }
 +
 +    if ((ret = vorbis_encode_setup_init(vi)))
 +        goto error;
 +
 +    return 0;
 +error:
 +    return vorbis_error_to_averror(ret);
 +}
 +
 +/* How many bytes are needed for a buffer of length 'l' */
 +static int xiph_len(int l)
 +{
 +    return 1 + l / 255 + l;
 +}
 +
 +static av_cold int libvorbis_encode_close(AVCodecContext *avctx)
 +{
 +    LibvorbisEncContext *s = avctx->priv_data;
 +
 +    /* notify vorbisenc this is EOF */
 +    if (s->dsp_initialized)
 +        vorbis_analysis_wrote(&s->vd, 0);
 +
 +    vorbis_block_clear(&s->vb);
 +    vorbis_dsp_clear(&s->vd);
 +    vorbis_info_clear(&s->vi);
 +
 +    av_fifo_freep(&s->pkt_fifo);
 +    ff_af_queue_close(&s->afq);
 +    av_freep(&avctx->extradata);
 +
 +    return 0;
 +}
 +
 +static av_cold int libvorbis_encode_init(AVCodecContext *avctx)
 +{
 +    LibvorbisEncContext *s = avctx->priv_data;
 +    ogg_packet header, header_comm, header_code;
 +    uint8_t *p;
 +    unsigned int offset;
 +    int ret;
 +
 +    vorbis_info_init(&s->vi);
 +    if ((ret = libvorbis_setup(&s->vi, avctx))) {
 +        av_log(avctx, AV_LOG_ERROR, "encoder setup failed\n");
 +        goto error;
 +    }
 +    if ((ret = vorbis_analysis_init(&s->vd, &s->vi))) {
 +        av_log(avctx, AV_LOG_ERROR, "analysis init failed\n");
 +        ret = vorbis_error_to_averror(ret);
 +        goto error;
 +    }
 +    s->dsp_initialized = 1;
 +    if ((ret = vorbis_block_init(&s->vd, &s->vb))) {
 +        av_log(avctx, AV_LOG_ERROR, "dsp init failed\n");
 +        ret = vorbis_error_to_averror(ret);
 +        goto error;
 +    }
 +
 +    vorbis_comment_init(&s->vc);
 +    if (!(avctx->flags & CODEC_FLAG_BITEXACT))
 +        vorbis_comment_add_tag(&s->vc, "encoder", LIBAVCODEC_IDENT);
 +
 +    if ((ret = vorbis_analysis_headerout(&s->vd, &s->vc, &header, &header_comm,
 +                                         &header_code))) {
 +        ret = vorbis_error_to_averror(ret);
 +        goto error;
 +    }
 +
 +    avctx->extradata_size = 1 + xiph_len(header.bytes)      +
 +                                xiph_len(header_comm.bytes) +
 +                                header_code.bytes;
 +    p = avctx->extradata = av_malloc(avctx->extradata_size +
 +                                     FF_INPUT_BUFFER_PADDING_SIZE);
 +    if (!p) {
 +        ret = AVERROR(ENOMEM);
 +        goto error;
 +    }
 +    p[0]    = 2;
 +    offset  = 1;
 +    offset += av_xiphlacing(&p[offset], header.bytes);
 +    offset += av_xiphlacing(&p[offset], header_comm.bytes);
 +    memcpy(&p[offset], header.packet, header.bytes);
 +    offset += header.bytes;
 +    memcpy(&p[offset], header_comm.packet, header_comm.bytes);
 +    offset += header_comm.bytes;
 +    memcpy(&p[offset], header_code.packet, header_code.bytes);
 +    offset += header_code.bytes;
 +    av_assert0(offset == avctx->extradata_size);
 +
 +    if ((ret = avpriv_vorbis_parse_extradata(avctx, &s->vp)) < 0) {
 +        av_log(avctx, AV_LOG_ERROR, "invalid extradata\n");
 +        return ret;
 +    }
 +
 +    vorbis_comment_clear(&s->vc);
 +
 +    avctx->frame_size = LIBVORBIS_FRAME_SIZE;
 +    ff_af_queue_init(avctx, &s->afq);
 +
 +    s->pkt_fifo = av_fifo_alloc(BUFFER_SIZE);
 +    if (!s->pkt_fifo) {
 +        ret = AVERROR(ENOMEM);
 +        goto error;
 +    }
 +
 +    return 0;
 +error:
 +    libvorbis_encode_close(avctx);
 +    return ret;
 +}
 +
 +static int libvorbis_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
 +                                  const AVFrame *frame, int *got_packet_ptr)
 +{
 +    LibvorbisEncContext *s = avctx->priv_data;
 +    ogg_packet op;
 +    int ret, duration;
 +
 +    /* send samples to libvorbis */
 +    if (frame) {
 +        const int samples = frame->nb_samples;
 +        float **buffer;
 +        int c, channels = s->vi.channels;
 +
 +        buffer = vorbis_analysis_buffer(&s->vd, samples);
 +        for (c = 0; c < channels; c++) {
 +            int co = (channels > 8) ? c :
 +                     ff_vorbis_encoding_channel_layout_offsets[channels - 1][c];
 +            memcpy(buffer[c], frame->extended_data[co],
 +                   samples * sizeof(*buffer[c]));
 +        }
 +        if ((ret = vorbis_analysis_wrote(&s->vd, samples)) < 0) {
 +            av_log(avctx, AV_LOG_ERROR, "error in vorbis_analysis_wrote()\n");
 +            return vorbis_error_to_averror(ret);
 +        }
 +        if ((ret = ff_af_queue_add(&s->afq, frame)) < 0)
 +            return ret;
 +    } else {
 +        if (!s->eof && s->afq.frame_alloc)
 +            if ((ret = vorbis_analysis_wrote(&s->vd, 0)) < 0) {
 +                av_log(avctx, AV_LOG_ERROR, "error in vorbis_analysis_wrote()\n");
 +                return vorbis_error_to_averror(ret);
 +            }
 +        s->eof = 1;
 +    }
 +
 +    /* retrieve available packets from libvorbis */
 +    while ((ret = vorbis_analysis_blockout(&s->vd, &s->vb)) == 1) {
 +        if ((ret = vorbis_analysis(&s->vb, NULL)) < 0)
 +            break;
 +        if ((ret = vorbis_bitrate_addblock(&s->vb)) < 0)
 +            break;
 +
 +        /* add any available packets to the output packet buffer */
 +        while ((ret = vorbis_bitrate_flushpacket(&s->vd, &op)) == 1) {
 +            if (av_fifo_space(s->pkt_fifo) < sizeof(ogg_packet) + op.bytes) {
 +                av_log(avctx, AV_LOG_ERROR, "packet buffer is too small\n");
 +                return AVERROR_BUG;
 +            }
 +            av_fifo_generic_write(s->pkt_fifo, &op, sizeof(ogg_packet), NULL);
 +            av_fifo_generic_write(s->pkt_fifo, op.packet, op.bytes, NULL);
 +        }
 +        if (ret < 0) {
 +            av_log(avctx, AV_LOG_ERROR, "error getting available packets\n");
 +            break;
 +        }
 +    }
 +    if (ret < 0) {
 +        av_log(avctx, AV_LOG_ERROR, "error getting available packets\n");
 +        return vorbis_error_to_averror(ret);
 +    }
 +
 +    /* check for available packets */
 +    if (av_fifo_size(s->pkt_fifo) < sizeof(ogg_packet))
 +        return 0;
 +
 +    av_fifo_generic_read(s->pkt_fifo, &op, sizeof(ogg_packet), NULL);
 +
 +    if ((ret = ff_alloc_packet2(avctx, avpkt, op.bytes)) < 0)
 +        return ret;
 +    av_fifo_generic_read(s->pkt_fifo, avpkt->data, op.bytes, NULL);
 +
 +    avpkt->pts = ff_samples_to_time_base(avctx, op.granulepos);
 +
 +    duration = avpriv_vorbis_parse_frame(&s->vp, avpkt->data, avpkt->size);
 +    if (duration > 0) {
 +        /* we do not know encoder delay until we get the first packet from
 +         * libvorbis, so we have to update the AudioFrameQueue counts */
++        if (!avctx->initial_padding && s->afq.frames) {
++            avctx->initial_padding    = duration;
 +            av_assert0(!s->afq.remaining_delay);
 +            s->afq.frames->duration  += duration;
 +            if (s->afq.frames->pts != AV_NOPTS_VALUE)
 +                s->afq.frames->pts       -= duration;
 +            s->afq.remaining_samples += duration;
 +        }
 +        ff_af_queue_remove(&s->afq, duration, &avpkt->pts, &avpkt->duration);
 +    }
 +
 +    *got_packet_ptr = 1;
 +    return 0;
 +}
 +
 +AVCodec ff_libvorbis_encoder = {
 +    .name           = "libvorbis",
 +    .long_name      = NULL_IF_CONFIG_SMALL("libvorbis"),
 +    .type           = AVMEDIA_TYPE_AUDIO,
 +    .id             = AV_CODEC_ID_VORBIS,
 +    .priv_data_size = sizeof(LibvorbisEncContext),
 +    .init           = libvorbis_encode_init,
 +    .encode2        = libvorbis_encode_frame,
 +    .close          = libvorbis_encode_close,
 +    .capabilities   = CODEC_CAP_DELAY,
 +    .sample_fmts    = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
 +                                                      AV_SAMPLE_FMT_NONE },
 +    .priv_class     = &vorbis_class,
 +    .defaults       = defaults,
 +};
index e9571d8,0000000..1bf9471
mode 100644,000000..100644
--- /dev/null
@@@ -1,785 -1,0 +1,785 @@@
-     avctx->delay      = 512 - 32 + 1;
 +/*
 + * The simplest mpeg audio layer 2 encoder
 + * Copyright (c) 2000, 2001 Fabrice Bellard
 + *
 + * 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
 + * The simplest mpeg audio layer 2 encoder.
 + */
 +
 +#include "libavutil/channel_layout.h"
 +
 +#include "avcodec.h"
 +#include "internal.h"
 +#include "put_bits.h"
 +
 +#define FRAC_BITS   15   /* fractional bits for sb_samples and dct */
 +#define WFRAC_BITS  14   /* fractional bits for window */
 +
 +#include "mpegaudio.h"
 +#include "mpegaudiodsp.h"
 +#include "mpegaudiodata.h"
 +#include "mpegaudiotab.h"
 +
 +/* currently, cannot change these constants (need to modify
 +   quantization stage) */
 +#define MUL(a,b) (((int64_t)(a) * (int64_t)(b)) >> FRAC_BITS)
 +
 +#define SAMPLES_BUF_SIZE 4096
 +
 +typedef struct MpegAudioContext {
 +    PutBitContext pb;
 +    int nb_channels;
 +    int lsf;           /* 1 if mpeg2 low bitrate selected */
 +    int bitrate_index; /* bit rate */
 +    int freq_index;
 +    int frame_size; /* frame size, in bits, without padding */
 +    /* padding computation */
 +    int frame_frac, frame_frac_incr, do_padding;
 +    short samples_buf[MPA_MAX_CHANNELS][SAMPLES_BUF_SIZE]; /* buffer for filter */
 +    int samples_offset[MPA_MAX_CHANNELS];       /* offset in samples_buf */
 +    int sb_samples[MPA_MAX_CHANNELS][3][12][SBLIMIT];
 +    unsigned char scale_factors[MPA_MAX_CHANNELS][SBLIMIT][3]; /* scale factors */
 +    /* code to group 3 scale factors */
 +    unsigned char scale_code[MPA_MAX_CHANNELS][SBLIMIT];
 +    int sblimit; /* number of used subbands */
 +    const unsigned char *alloc_table;
 +    int16_t filter_bank[512];
 +    int scale_factor_table[64];
 +    unsigned char scale_diff_table[128];
 +#if USE_FLOATS
 +    float scale_factor_inv_table[64];
 +#else
 +    int8_t scale_factor_shift[64];
 +    unsigned short scale_factor_mult[64];
 +#endif
 +    unsigned short total_quant_bits[17]; /* total number of bits per allocation group */
 +} MpegAudioContext;
 +
 +static av_cold int MPA_encode_init(AVCodecContext *avctx)
 +{
 +    MpegAudioContext *s = avctx->priv_data;
 +    int freq = avctx->sample_rate;
 +    int bitrate = avctx->bit_rate;
 +    int channels = avctx->channels;
 +    int i, v, table;
 +    float a;
 +
 +    if (channels <= 0 || channels > 2){
 +        av_log(avctx, AV_LOG_ERROR, "encoding %d channel(s) is not allowed in mp2\n", channels);
 +        return AVERROR(EINVAL);
 +    }
 +    bitrate = bitrate / 1000;
 +    s->nb_channels = channels;
 +    avctx->frame_size = MPA_FRAME_SIZE;
-         avpkt->pts = frame->pts - ff_samples_to_time_base(avctx, avctx->delay);
++    avctx->initial_padding = 512 - 32 + 1;
 +
 +    /* encoding freq */
 +    s->lsf = 0;
 +    for(i=0;i<3;i++) {
 +        if (avpriv_mpa_freq_tab[i] == freq)
 +            break;
 +        if ((avpriv_mpa_freq_tab[i] / 2) == freq) {
 +            s->lsf = 1;
 +            break;
 +        }
 +    }
 +    if (i == 3){
 +        av_log(avctx, AV_LOG_ERROR, "Sampling rate %d is not allowed in mp2\n", freq);
 +        return AVERROR(EINVAL);
 +    }
 +    s->freq_index = i;
 +
 +    /* encoding bitrate & frequency */
 +    for(i=1;i<15;i++) {
 +        if (avpriv_mpa_bitrate_tab[s->lsf][1][i] == bitrate)
 +            break;
 +    }
 +    if (i == 15 && !avctx->bit_rate) {
 +        i = 14;
 +        bitrate = avpriv_mpa_bitrate_tab[s->lsf][1][i];
 +        avctx->bit_rate = bitrate * 1000;
 +    }
 +    if (i == 15){
 +        av_log(avctx, AV_LOG_ERROR, "bitrate %d is not allowed in mp2\n", bitrate);
 +        return AVERROR(EINVAL);
 +    }
 +    s->bitrate_index = i;
 +
 +    /* compute total header size & pad bit */
 +
 +    a = (float)(bitrate * 1000 * MPA_FRAME_SIZE) / (freq * 8.0);
 +    s->frame_size = ((int)a) * 8;
 +
 +    /* frame fractional size to compute padding */
 +    s->frame_frac = 0;
 +    s->frame_frac_incr = (int)((a - floor(a)) * 65536.0);
 +
 +    /* select the right allocation table */
 +    table = ff_mpa_l2_select_table(bitrate, s->nb_channels, freq, s->lsf);
 +
 +    /* number of used subbands */
 +    s->sblimit = ff_mpa_sblimit_table[table];
 +    s->alloc_table = ff_mpa_alloc_tables[table];
 +
 +    av_dlog(avctx, "%d kb/s, %d Hz, frame_size=%d bits, table=%d, padincr=%x\n",
 +            bitrate, freq, s->frame_size, table, s->frame_frac_incr);
 +
 +    for(i=0;i<s->nb_channels;i++)
 +        s->samples_offset[i] = 0;
 +
 +    for(i=0;i<257;i++) {
 +        int v;
 +        v = ff_mpa_enwindow[i];
 +#if WFRAC_BITS != 16
 +        v = (v + (1 << (16 - WFRAC_BITS - 1))) >> (16 - WFRAC_BITS);
 +#endif
 +        s->filter_bank[i] = v;
 +        if ((i & 63) != 0)
 +            v = -v;
 +        if (i != 0)
 +            s->filter_bank[512 - i] = v;
 +    }
 +
 +    for(i=0;i<64;i++) {
 +        v = (int)(exp2((3 - i) / 3.0) * (1 << 20));
 +        if (v <= 0)
 +            v = 1;
 +        s->scale_factor_table[i] = v;
 +#if USE_FLOATS
 +        s->scale_factor_inv_table[i] = exp2(-(3 - i) / 3.0) / (float)(1 << 20);
 +#else
 +#define P 15
 +        s->scale_factor_shift[i] = 21 - P - (i / 3);
 +        s->scale_factor_mult[i] = (1 << P) * exp2((i % 3) / 3.0);
 +#endif
 +    }
 +    for(i=0;i<128;i++) {
 +        v = i - 64;
 +        if (v <= -3)
 +            v = 0;
 +        else if (v < 0)
 +            v = 1;
 +        else if (v == 0)
 +            v = 2;
 +        else if (v < 3)
 +            v = 3;
 +        else
 +            v = 4;
 +        s->scale_diff_table[i] = v;
 +    }
 +
 +    for(i=0;i<17;i++) {
 +        v = ff_mpa_quant_bits[i];
 +        if (v < 0)
 +            v = -v;
 +        else
 +            v = v * 3;
 +        s->total_quant_bits[i] = 12 * v;
 +    }
 +
 +    return 0;
 +}
 +
 +/* 32 point floating point IDCT without 1/sqrt(2) coef zero scaling */
 +static void idct32(int *out, int *tab)
 +{
 +    int i, j;
 +    int *t, *t1, xr;
 +    const int *xp = costab32;
 +
 +    for(j=31;j>=3;j-=2) tab[j] += tab[j - 2];
 +
 +    t = tab + 30;
 +    t1 = tab + 2;
 +    do {
 +        t[0] += t[-4];
 +        t[1] += t[1 - 4];
 +        t -= 4;
 +    } while (t != t1);
 +
 +    t = tab + 28;
 +    t1 = tab + 4;
 +    do {
 +        t[0] += t[-8];
 +        t[1] += t[1-8];
 +        t[2] += t[2-8];
 +        t[3] += t[3-8];
 +        t -= 8;
 +    } while (t != t1);
 +
 +    t = tab;
 +    t1 = tab + 32;
 +    do {
 +        t[ 3] = -t[ 3];
 +        t[ 6] = -t[ 6];
 +
 +        t[11] = -t[11];
 +        t[12] = -t[12];
 +        t[13] = -t[13];
 +        t[15] = -t[15];
 +        t += 16;
 +    } while (t != t1);
 +
 +
 +    t = tab;
 +    t1 = tab + 8;
 +    do {
 +        int x1, x2, x3, x4;
 +
 +        x3 = MUL(t[16], FIX(SQRT2*0.5));
 +        x4 = t[0] - x3;
 +        x3 = t[0] + x3;
 +
 +        x2 = MUL(-(t[24] + t[8]), FIX(SQRT2*0.5));
 +        x1 = MUL((t[8] - x2), xp[0]);
 +        x2 = MUL((t[8] + x2), xp[1]);
 +
 +        t[ 0] = x3 + x1;
 +        t[ 8] = x4 - x2;
 +        t[16] = x4 + x2;
 +        t[24] = x3 - x1;
 +        t++;
 +    } while (t != t1);
 +
 +    xp += 2;
 +    t = tab;
 +    t1 = tab + 4;
 +    do {
 +        xr = MUL(t[28],xp[0]);
 +        t[28] = (t[0] - xr);
 +        t[0] = (t[0] + xr);
 +
 +        xr = MUL(t[4],xp[1]);
 +        t[ 4] = (t[24] - xr);
 +        t[24] = (t[24] + xr);
 +
 +        xr = MUL(t[20],xp[2]);
 +        t[20] = (t[8] - xr);
 +        t[ 8] = (t[8] + xr);
 +
 +        xr = MUL(t[12],xp[3]);
 +        t[12] = (t[16] - xr);
 +        t[16] = (t[16] + xr);
 +        t++;
 +    } while (t != t1);
 +    xp += 4;
 +
 +    for (i = 0; i < 4; i++) {
 +        xr = MUL(tab[30-i*4],xp[0]);
 +        tab[30-i*4] = (tab[i*4] - xr);
 +        tab[   i*4] = (tab[i*4] + xr);
 +
 +        xr = MUL(tab[ 2+i*4],xp[1]);
 +        tab[ 2+i*4] = (tab[28-i*4] - xr);
 +        tab[28-i*4] = (tab[28-i*4] + xr);
 +
 +        xr = MUL(tab[31-i*4],xp[0]);
 +        tab[31-i*4] = (tab[1+i*4] - xr);
 +        tab[ 1+i*4] = (tab[1+i*4] + xr);
 +
 +        xr = MUL(tab[ 3+i*4],xp[1]);
 +        tab[ 3+i*4] = (tab[29-i*4] - xr);
 +        tab[29-i*4] = (tab[29-i*4] + xr);
 +
 +        xp += 2;
 +    }
 +
 +    t = tab + 30;
 +    t1 = tab + 1;
 +    do {
 +        xr = MUL(t1[0], *xp);
 +        t1[0] = (t[0] - xr);
 +        t[0] = (t[0] + xr);
 +        t -= 2;
 +        t1 += 2;
 +        xp++;
 +    } while (t >= tab);
 +
 +    for(i=0;i<32;i++) {
 +        out[i] = tab[bitinv32[i]];
 +    }
 +}
 +
 +#define WSHIFT (WFRAC_BITS + 15 - FRAC_BITS)
 +
 +static void filter(MpegAudioContext *s, int ch, const short *samples, int incr)
 +{
 +    short *p, *q;
 +    int sum, offset, i, j;
 +    int tmp[64];
 +    int tmp1[32];
 +    int *out;
 +
 +    offset = s->samples_offset[ch];
 +    out = &s->sb_samples[ch][0][0][0];
 +    for(j=0;j<36;j++) {
 +        /* 32 samples at once */
 +        for(i=0;i<32;i++) {
 +            s->samples_buf[ch][offset + (31 - i)] = samples[0];
 +            samples += incr;
 +        }
 +
 +        /* filter */
 +        p = s->samples_buf[ch] + offset;
 +        q = s->filter_bank;
 +        /* maxsum = 23169 */
 +        for(i=0;i<64;i++) {
 +            sum = p[0*64] * q[0*64];
 +            sum += p[1*64] * q[1*64];
 +            sum += p[2*64] * q[2*64];
 +            sum += p[3*64] * q[3*64];
 +            sum += p[4*64] * q[4*64];
 +            sum += p[5*64] * q[5*64];
 +            sum += p[6*64] * q[6*64];
 +            sum += p[7*64] * q[7*64];
 +            tmp[i] = sum;
 +            p++;
 +            q++;
 +        }
 +        tmp1[0] = tmp[16] >> WSHIFT;
 +        for( i=1; i<=16; i++ ) tmp1[i] = (tmp[i+16]+tmp[16-i]) >> WSHIFT;
 +        for( i=17; i<=31; i++ ) tmp1[i] = (tmp[i+16]-tmp[80-i]) >> WSHIFT;
 +
 +        idct32(out, tmp1);
 +
 +        /* advance of 32 samples */
 +        offset -= 32;
 +        out += 32;
 +        /* handle the wrap around */
 +        if (offset < 0) {
 +            memmove(s->samples_buf[ch] + SAMPLES_BUF_SIZE - (512 - 32),
 +                    s->samples_buf[ch], (512 - 32) * 2);
 +            offset = SAMPLES_BUF_SIZE - 512;
 +        }
 +    }
 +    s->samples_offset[ch] = offset;
 +}
 +
 +static void compute_scale_factors(MpegAudioContext *s,
 +                                  unsigned char scale_code[SBLIMIT],
 +                                  unsigned char scale_factors[SBLIMIT][3],
 +                                  int sb_samples[3][12][SBLIMIT],
 +                                  int sblimit)
 +{
 +    int *p, vmax, v, n, i, j, k, code;
 +    int index, d1, d2;
 +    unsigned char *sf = &scale_factors[0][0];
 +
 +    for(j=0;j<sblimit;j++) {
 +        for(i=0;i<3;i++) {
 +            /* find the max absolute value */
 +            p = &sb_samples[i][0][j];
 +            vmax = abs(*p);
 +            for(k=1;k<12;k++) {
 +                p += SBLIMIT;
 +                v = abs(*p);
 +                if (v > vmax)
 +                    vmax = v;
 +            }
 +            /* compute the scale factor index using log 2 computations */
 +            if (vmax > 1) {
 +                n = av_log2(vmax);
 +                /* n is the position of the MSB of vmax. now
 +                   use at most 2 compares to find the index */
 +                index = (21 - n) * 3 - 3;
 +                if (index >= 0) {
 +                    while (vmax <= s->scale_factor_table[index+1])
 +                        index++;
 +                } else {
 +                    index = 0; /* very unlikely case of overflow */
 +                }
 +            } else {
 +                index = 62; /* value 63 is not allowed */
 +            }
 +
 +            av_dlog(NULL, "%2d:%d in=%x %x %d\n",
 +                    j, i, vmax, s->scale_factor_table[index], index);
 +            /* store the scale factor */
 +            av_assert2(index >=0 && index <= 63);
 +            sf[i] = index;
 +        }
 +
 +        /* compute the transmission factor : look if the scale factors
 +           are close enough to each other */
 +        d1 = s->scale_diff_table[sf[0] - sf[1] + 64];
 +        d2 = s->scale_diff_table[sf[1] - sf[2] + 64];
 +
 +        /* handle the 25 cases */
 +        switch(d1 * 5 + d2) {
 +        case 0*5+0:
 +        case 0*5+4:
 +        case 3*5+4:
 +        case 4*5+0:
 +        case 4*5+4:
 +            code = 0;
 +            break;
 +        case 0*5+1:
 +        case 0*5+2:
 +        case 4*5+1:
 +        case 4*5+2:
 +            code = 3;
 +            sf[2] = sf[1];
 +            break;
 +        case 0*5+3:
 +        case 4*5+3:
 +            code = 3;
 +            sf[1] = sf[2];
 +            break;
 +        case 1*5+0:
 +        case 1*5+4:
 +        case 2*5+4:
 +            code = 1;
 +            sf[1] = sf[0];
 +            break;
 +        case 1*5+1:
 +        case 1*5+2:
 +        case 2*5+0:
 +        case 2*5+1:
 +        case 2*5+2:
 +            code = 2;
 +            sf[1] = sf[2] = sf[0];
 +            break;
 +        case 2*5+3:
 +        case 3*5+3:
 +            code = 2;
 +            sf[0] = sf[1] = sf[2];
 +            break;
 +        case 3*5+0:
 +        case 3*5+1:
 +        case 3*5+2:
 +            code = 2;
 +            sf[0] = sf[2] = sf[1];
 +            break;
 +        case 1*5+3:
 +            code = 2;
 +            if (sf[0] > sf[2])
 +              sf[0] = sf[2];
 +            sf[1] = sf[2] = sf[0];
 +            break;
 +        default:
 +            av_assert2(0); //cannot happen
 +            code = 0;           /* kill warning */
 +        }
 +
 +        av_dlog(NULL, "%d: %2d %2d %2d %d %d -> %d\n", j,
 +                sf[0], sf[1], sf[2], d1, d2, code);
 +        scale_code[j] = code;
 +        sf += 3;
 +    }
 +}
 +
 +/* The most important function : psycho acoustic module. In this
 +   encoder there is basically none, so this is the worst you can do,
 +   but also this is the simpler. */
 +static void psycho_acoustic_model(MpegAudioContext *s, short smr[SBLIMIT])
 +{
 +    int i;
 +
 +    for(i=0;i<s->sblimit;i++) {
 +        smr[i] = (int)(fixed_smr[i] * 10);
 +    }
 +}
 +
 +
 +#define SB_NOTALLOCATED  0
 +#define SB_ALLOCATED     1
 +#define SB_NOMORE        2
 +
 +/* Try to maximize the smr while using a number of bits inferior to
 +   the frame size. I tried to make the code simpler, faster and
 +   smaller than other encoders :-) */
 +static void compute_bit_allocation(MpegAudioContext *s,
 +                                   short smr1[MPA_MAX_CHANNELS][SBLIMIT],
 +                                   unsigned char bit_alloc[MPA_MAX_CHANNELS][SBLIMIT],
 +                                   int *padding)
 +{
 +    int i, ch, b, max_smr, max_ch, max_sb, current_frame_size, max_frame_size;
 +    int incr;
 +    short smr[MPA_MAX_CHANNELS][SBLIMIT];
 +    unsigned char subband_status[MPA_MAX_CHANNELS][SBLIMIT];
 +    const unsigned char *alloc;
 +
 +    memcpy(smr, smr1, s->nb_channels * sizeof(short) * SBLIMIT);
 +    memset(subband_status, SB_NOTALLOCATED, s->nb_channels * SBLIMIT);
 +    memset(bit_alloc, 0, s->nb_channels * SBLIMIT);
 +
 +    /* compute frame size and padding */
 +    max_frame_size = s->frame_size;
 +    s->frame_frac += s->frame_frac_incr;
 +    if (s->frame_frac >= 65536) {
 +        s->frame_frac -= 65536;
 +        s->do_padding = 1;
 +        max_frame_size += 8;
 +    } else {
 +        s->do_padding = 0;
 +    }
 +
 +    /* compute the header + bit alloc size */
 +    current_frame_size = 32;
 +    alloc = s->alloc_table;
 +    for(i=0;i<s->sblimit;i++) {
 +        incr = alloc[0];
 +        current_frame_size += incr * s->nb_channels;
 +        alloc += 1 << incr;
 +    }
 +    for(;;) {
 +        /* look for the subband with the largest signal to mask ratio */
 +        max_sb = -1;
 +        max_ch = -1;
 +        max_smr = INT_MIN;
 +        for(ch=0;ch<s->nb_channels;ch++) {
 +            for(i=0;i<s->sblimit;i++) {
 +                if (smr[ch][i] > max_smr && subband_status[ch][i] != SB_NOMORE) {
 +                    max_smr = smr[ch][i];
 +                    max_sb = i;
 +                    max_ch = ch;
 +                }
 +            }
 +        }
 +        if (max_sb < 0)
 +            break;
 +        av_dlog(NULL, "current=%d max=%d max_sb=%d max_ch=%d alloc=%d\n",
 +                current_frame_size, max_frame_size, max_sb, max_ch,
 +                bit_alloc[max_ch][max_sb]);
 +
 +        /* find alloc table entry (XXX: not optimal, should use
 +           pointer table) */
 +        alloc = s->alloc_table;
 +        for(i=0;i<max_sb;i++) {
 +            alloc += 1 << alloc[0];
 +        }
 +
 +        if (subband_status[max_ch][max_sb] == SB_NOTALLOCATED) {
 +            /* nothing was coded for this band: add the necessary bits */
 +            incr = 2 + nb_scale_factors[s->scale_code[max_ch][max_sb]] * 6;
 +            incr += s->total_quant_bits[alloc[1]];
 +        } else {
 +            /* increments bit allocation */
 +            b = bit_alloc[max_ch][max_sb];
 +            incr = s->total_quant_bits[alloc[b + 1]] -
 +                s->total_quant_bits[alloc[b]];
 +        }
 +
 +        if (current_frame_size + incr <= max_frame_size) {
 +            /* can increase size */
 +            b = ++bit_alloc[max_ch][max_sb];
 +            current_frame_size += incr;
 +            /* decrease smr by the resolution we added */
 +            smr[max_ch][max_sb] = smr1[max_ch][max_sb] - quant_snr[alloc[b]];
 +            /* max allocation size reached ? */
 +            if (b == ((1 << alloc[0]) - 1))
 +                subband_status[max_ch][max_sb] = SB_NOMORE;
 +            else
 +                subband_status[max_ch][max_sb] = SB_ALLOCATED;
 +        } else {
 +            /* cannot increase the size of this subband */
 +            subband_status[max_ch][max_sb] = SB_NOMORE;
 +        }
 +    }
 +    *padding = max_frame_size - current_frame_size;
 +    av_assert0(*padding >= 0);
 +}
 +
 +/*
 + * Output the mpeg audio layer 2 frame. Note how the code is small
 + * compared to other encoders :-)
 + */
 +static void encode_frame(MpegAudioContext *s,
 +                         unsigned char bit_alloc[MPA_MAX_CHANNELS][SBLIMIT],
 +                         int padding)
 +{
 +    int i, j, k, l, bit_alloc_bits, b, ch;
 +    unsigned char *sf;
 +    int q[3];
 +    PutBitContext *p = &s->pb;
 +
 +    /* header */
 +
 +    put_bits(p, 12, 0xfff);
 +    put_bits(p, 1, 1 - s->lsf); /* 1 = mpeg1 ID, 0 = mpeg2 lsf ID */
 +    put_bits(p, 2, 4-2);  /* layer 2 */
 +    put_bits(p, 1, 1); /* no error protection */
 +    put_bits(p, 4, s->bitrate_index);
 +    put_bits(p, 2, s->freq_index);
 +    put_bits(p, 1, s->do_padding); /* use padding */
 +    put_bits(p, 1, 0);             /* private_bit */
 +    put_bits(p, 2, s->nb_channels == 2 ? MPA_STEREO : MPA_MONO);
 +    put_bits(p, 2, 0); /* mode_ext */
 +    put_bits(p, 1, 0); /* no copyright */
 +    put_bits(p, 1, 1); /* original */
 +    put_bits(p, 2, 0); /* no emphasis */
 +
 +    /* bit allocation */
 +    j = 0;
 +    for(i=0;i<s->sblimit;i++) {
 +        bit_alloc_bits = s->alloc_table[j];
 +        for(ch=0;ch<s->nb_channels;ch++) {
 +            put_bits(p, bit_alloc_bits, bit_alloc[ch][i]);
 +        }
 +        j += 1 << bit_alloc_bits;
 +    }
 +
 +    /* scale codes */
 +    for(i=0;i<s->sblimit;i++) {
 +        for(ch=0;ch<s->nb_channels;ch++) {
 +            if (bit_alloc[ch][i])
 +                put_bits(p, 2, s->scale_code[ch][i]);
 +        }
 +    }
 +
 +    /* scale factors */
 +    for(i=0;i<s->sblimit;i++) {
 +        for(ch=0;ch<s->nb_channels;ch++) {
 +            if (bit_alloc[ch][i]) {
 +                sf = &s->scale_factors[ch][i][0];
 +                switch(s->scale_code[ch][i]) {
 +                case 0:
 +                    put_bits(p, 6, sf[0]);
 +                    put_bits(p, 6, sf[1]);
 +                    put_bits(p, 6, sf[2]);
 +                    break;
 +                case 3:
 +                case 1:
 +                    put_bits(p, 6, sf[0]);
 +                    put_bits(p, 6, sf[2]);
 +                    break;
 +                case 2:
 +                    put_bits(p, 6, sf[0]);
 +                    break;
 +                }
 +            }
 +        }
 +    }
 +
 +    /* quantization & write sub band samples */
 +
 +    for(k=0;k<3;k++) {
 +        for(l=0;l<12;l+=3) {
 +            j = 0;
 +            for(i=0;i<s->sblimit;i++) {
 +                bit_alloc_bits = s->alloc_table[j];
 +                for(ch=0;ch<s->nb_channels;ch++) {
 +                    b = bit_alloc[ch][i];
 +                    if (b) {
 +                        int qindex, steps, m, sample, bits;
 +                        /* we encode 3 sub band samples of the same sub band at a time */
 +                        qindex = s->alloc_table[j+b];
 +                        steps = ff_mpa_quant_steps[qindex];
 +                        for(m=0;m<3;m++) {
 +                            sample = s->sb_samples[ch][k][l + m][i];
 +                            /* divide by scale factor */
 +#if USE_FLOATS
 +                            {
 +                                float a;
 +                                a = (float)sample * s->scale_factor_inv_table[s->scale_factors[ch][i][k]];
 +                                q[m] = (int)((a + 1.0) * steps * 0.5);
 +                            }
 +#else
 +                            {
 +                                int q1, e, shift, mult;
 +                                e = s->scale_factors[ch][i][k];
 +                                shift = s->scale_factor_shift[e];
 +                                mult = s->scale_factor_mult[e];
 +
 +                                /* normalize to P bits */
 +                                if (shift < 0)
 +                                    q1 = sample << (-shift);
 +                                else
 +                                    q1 = sample >> shift;
 +                                q1 = (q1 * mult) >> P;
 +                                q1 += 1 << P;
 +                                if (q1 < 0)
 +                                    q1 = 0;
 +                                q[m] = (q1 * (unsigned)steps) >> (P + 1);
 +                            }
 +#endif
 +                            if (q[m] >= steps)
 +                                q[m] = steps - 1;
 +                            av_assert2(q[m] >= 0 && q[m] < steps);
 +                        }
 +                        bits = ff_mpa_quant_bits[qindex];
 +                        if (bits < 0) {
 +                            /* group the 3 values to save bits */
 +                            put_bits(p, -bits,
 +                                     q[0] + steps * (q[1] + steps * q[2]));
 +                        } else {
 +                            put_bits(p, bits, q[0]);
 +                            put_bits(p, bits, q[1]);
 +                            put_bits(p, bits, q[2]);
 +                        }
 +                    }
 +                }
 +                /* next subband in alloc table */
 +                j += 1 << bit_alloc_bits;
 +            }
 +        }
 +    }
 +
 +    /* padding */
 +    for(i=0;i<padding;i++)
 +        put_bits(p, 1, 0);
 +
 +    /* flush */
 +    flush_put_bits(p);
 +}
 +
 +static int MPA_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
 +                            const AVFrame *frame, int *got_packet_ptr)
 +{
 +    MpegAudioContext *s = avctx->priv_data;
 +    const int16_t *samples = (const int16_t *)frame->data[0];
 +    short smr[MPA_MAX_CHANNELS][SBLIMIT];
 +    unsigned char bit_alloc[MPA_MAX_CHANNELS][SBLIMIT];
 +    int padding, i, ret;
 +
 +    for(i=0;i<s->nb_channels;i++) {
 +        filter(s, i, samples + i, s->nb_channels);
 +    }
 +
 +    for(i=0;i<s->nb_channels;i++) {
 +        compute_scale_factors(s, s->scale_code[i], s->scale_factors[i],
 +                              s->sb_samples[i], s->sblimit);
 +    }
 +    for(i=0;i<s->nb_channels;i++) {
 +        psycho_acoustic_model(s, smr[i]);
 +    }
 +    compute_bit_allocation(s, smr, bit_alloc, &padding);
 +
 +    if ((ret = ff_alloc_packet2(avctx, avpkt, MPA_MAX_CODED_FRAME_SIZE)) < 0)
 +        return ret;
 +
 +    init_put_bits(&s->pb, avpkt->data, avpkt->size);
 +
 +    encode_frame(s, bit_alloc, padding);
 +
 +    if (frame->pts != AV_NOPTS_VALUE)
++        avpkt->pts = frame->pts - ff_samples_to_time_base(avctx, avctx->initial_padding);
 +
 +    avpkt->size = put_bits_count(&s->pb) / 8;
 +    *got_packet_ptr = 1;
 +    return 0;
 +}
 +
 +static const AVCodecDefault mp2_defaults[] = {
 +    { "b", "0" },
 +    { NULL },
 +};
 +
Simple merge
Simple merge
@@@ -1607,11 -1240,12 +1607,16 @@@ int attribute_align_arg avcodec_open2(A
          }
      }
  
 +    ret=0;
 +
+ #if FF_API_AUDIOENC_DELAY
+     if (av_codec_is_encoder(avctx->codec))
+         avctx->delay = avctx->initial_padding;
+ #endif
      if (av_codec_is_decoder(avctx->codec)) {
 +        if (!avctx->bit_rate)
 +            avctx->bit_rate = get_bit_rate(avctx);
          /* validate channel layout from the decoder */
          if (avctx->channel_layout) {
              int channels = av_get_channel_layout_nb_channels(avctx->channel_layout);
@@@ -1919,8 -1451,11 +1924,12 @@@ FF_ENABLE_DEPRECATION_WARNING
  
  end:
      av_frame_free(&padded_frame);
 +    av_free(extended_frame);
  
+ #if FF_API_AUDIOENC_DELAY
+     avctx->delay = avctx->initial_padding;
+ #endif
      return ret;
  }
  
@@@ -29,8 -29,8 +29,8 @@@
  #include "libavutil/version.h"
  
  #define LIBAVCODEC_VERSION_MAJOR 56
- #define LIBAVCODEC_VERSION_MINOR  4
- #define LIBAVCODEC_VERSION_MICRO 101
 -#define LIBAVCODEC_VERSION_MINOR  3
 -#define LIBAVCODEC_VERSION_MICRO  0
++#define LIBAVCODEC_VERSION_MINOR  5
++#define LIBAVCODEC_VERSION_MICRO 100
  
  #define LIBAVCODEC_VERSION_INT  AV_VERSION_INT(LIBAVCODEC_VERSION_MAJOR, \
                                                 LIBAVCODEC_VERSION_MINOR, \
  #ifndef FF_API_AFD
  #define FF_API_AFD               (LIBAVCODEC_VERSION_MAJOR < 57)
  #endif
 +#ifndef FF_API_VISMV
 +/* XXX: don't forget to drop the -vismv documentation */
 +#define FF_API_VISMV             (LIBAVCODEC_VERSION_MAJOR < 57)
 +#endif
 +#ifndef FF_API_DV_FRAME_PROFILE
 +#define FF_API_DV_FRAME_PROFILE  (LIBAVCODEC_VERSION_MAJOR < 57)
 +#endif
+ #ifndef FF_API_AUDIOENC_DELAY
+ #define FF_API_AUDIOENC_DELAY    (LIBAVCODEC_VERSION_MAJOR < 58)
+ #endif
  
  #endif /* AVCODEC_VERSION_H */
@@@ -88,9 -90,9 +88,7 @@@ static av_cold int encode_init(AVCodecC
                           (avctx->sample_rate * 8);
      block_align        = FFMIN(block_align, MAX_CODED_SUPERFRAME_SIZE);
      avctx->block_align = block_align;
-     avctx->frame_size  =
-     avctx->delay       = s->frame_len;
 -    avctx->bit_rate    = avctx->block_align * 8LL * avctx->sample_rate /
 -                         s->frame_len;
+     avctx->frame_size = avctx->initial_padding = s->frame_len;
  
      return 0;
  }
@@@ -400,10 -417,9 +398,10 @@@ static int encode_superframe(AVCodecCon
          put_bits(&s->pb, 8, 'N');
  
      flush_put_bits(&s->pb);
 +    av_assert0(put_bits_ptr(&s->pb) - s->pb.buf == avctx->block_align);
  
      if (frame->pts != AV_NOPTS_VALUE)
-         avpkt->pts = frame->pts - ff_samples_to_time_base(avctx, avctx->delay);
+         avpkt->pts = frame->pts - ff_samples_to_time_base(avctx, avctx->initial_padding);
  
      avpkt->size     = avctx->block_align;
      *got_packet_ptr = 1;