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

 - Apple ProRes encoder

 - ffprobe -count_packets and -count_frames options

 - Sun Rasterfile Encoder

+- ID3v2 attached pictures reading and writing

 version 0.10:

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

 API changes, most recent first:

+<<<<<<< HEAD

 2012-02-21 - xxxxxxx - lavc 54.4.100

   Add av_get_pcm_codec() function.

@@ -35,6 +36,13 @@ API changes, most recent first:

 2012-01-24 - xxxxxxx - lavfi 2.60.100

   Add avfilter_graph_dump.

+||||||| merged common ancestors

+=======

+2012-xx-xx - xxxxxxx - lavf 54.2.0 - avformat.h

+  Add AVStream.attached_pic and AV_DISPOSITION_ATTACHED_PIC,

+  used for dealing with attached pictures/cover art.

+

+>>>>>>> qatar/master

 2012-02-25 - c9bca80 - lavu 51.24.0 - error.h

   Add AVERROR_UNKNOWN

@@ -370,5 +370,39 @@ Wrap around segment index once it reaches @var{limit}.

 ffmpeg -i in.mkv -c copy -map 0 -f segment -list out.list out%03d.nut

 @end example

+@section mp3

+

+The MP3 muxer writes a raw MP3 stream with an ID3v2 header at the beginning and

+optionally an ID3v1 tag at the end. ID3v2.3 and ID3v2.4 are supported, the

+@code{id3v2_version} option controls which one is used. The legacy ID3v1 tag is

+not written by default, but may be enabled with the @code{write_id3v1} option.

+

+For seekable output the muxer also writes a Xing frame at the beginning, which

+contains the number of frames in the file. It is useful for computing duration

+of VBR files.

+

+The muxer supports writing ID3v2 attached pictures (APIC frames). The pictures

+are supplied to the muxer in form of a video stream with a single packet. There

+can be any number of those streams, each will correspond to a single APIC frame.

+The stream metadata tags @var{title} and @var{comment} map to APIC

+@var{description} and @var{picture type} respectively. See

+@url{http://id3.org/id3v2.4.0-frames} for allowed picture types.

+

+Note that the APIC frames must be written at the beginning, so the muxer will

+buffer the audio frames until it gets all the pictures. It is therefore advised

+to provide the pictures as soon as possible to avoid excessive buffering.

+

+Examples:

+

+Write an mp3 with an ID3v2.3 header and an ID3v1 footer:

+@example

+ffmpeg -i INPUT -id3v2_version 3 -write_id3v1 1 out.mp3

+@end example

+

+Attach a picture to an mp3:

+@example

+ffmpeg -i input.mp3 -i cover.png -c copy -metadata:s:v title="Album cover"

+-metadata:s:v comment="Cover (Front)" out.mp3

+@end example

 @c man end MUXERS

@@ -114,55 +114,6 @@ static VLC vlc_spectral[11];

 static const char overread_err[] = "Input buffer exhausted before END element found\n";

-static ChannelElement *get_che(AACContext *ac, int type, int elem_id)

-{

-    // For PCE based channel configurations map the channels solely based on tags.

-    if (!ac->m4ac.chan_config) {

-        return ac->tag_che_map[type][elem_id];

-    }

-    // For indexed channel configurations map the channels solely based on position.

-    switch (ac->m4ac.chan_config) {

-    case 7:

-        if (ac->tags_mapped == 3 && type == TYPE_CPE) {

-            ac->tags_mapped++;

-            return ac->tag_che_map[TYPE_CPE][elem_id] = ac->che[TYPE_CPE][2];

-        }

-    case 6:

-        /* Some streams incorrectly code 5.1 audio as SCE[0] CPE[0] CPE[1] SCE[1]

-           instead of SCE[0] CPE[0] CPE[1] LFE[0]. If we seem to have

-           encountered such a stream, transfer the LFE[0] element to the SCE[1]'s mapping */

-        if (ac->tags_mapped == tags_per_config[ac->m4ac.chan_config] - 1 && (type == TYPE_LFE || type == TYPE_SCE)) {

-            ac->tags_mapped++;

-            return ac->tag_che_map[type][elem_id] = ac->che[TYPE_LFE][0];

-        }

-    case 5:

-        if (ac->tags_mapped == 2 && type == TYPE_CPE) {

-            ac->tags_mapped++;

-            return ac->tag_che_map[TYPE_CPE][elem_id] = ac->che[TYPE_CPE][1];

-        }

-    case 4:

-        if (ac->tags_mapped == 2 && ac->m4ac.chan_config == 4 && type == TYPE_SCE) {

-            ac->tags_mapped++;

-            return ac->tag_che_map[TYPE_SCE][elem_id] = ac->che[TYPE_SCE][1];

-        }

-    case 3:

-    case 2:

-        if (ac->tags_mapped == (ac->m4ac.chan_config != 2) && type == TYPE_CPE) {

-            ac->tags_mapped++;

-            return ac->tag_che_map[TYPE_CPE][elem_id] = ac->che[TYPE_CPE][0];

-        } else if (ac->m4ac.chan_config == 2) {

-            return NULL;

-        }

-    case 1:

-        if (!ac->tags_mapped && type == TYPE_SCE) {

-            ac->tags_mapped++;

-            return ac->tag_che_map[TYPE_SCE][elem_id] = ac->che[TYPE_SCE][0];

-        }

-    default:

-        return NULL;

-    }

-}

-

 static int count_channels(uint8_t (*layout)[3], int tags)

 {

     int i, sum = 0;

@@ -455,6 +406,90 @@ static void flush(AVCodecContext *avctx)

 }

 /**

+ * Set up channel positions based on a default channel configuration

+ * as specified in table 1.17.

+ *

+ * @return  Returns error status. 0 - OK, !0 - error

+ */

+static av_cold int set_default_channel_config(AVCodecContext *avctx,

+                                              uint8_t (*layout_map)[3],

+                                              int *tags,

+                                              int channel_config)

+{

+    if (channel_config < 1 || channel_config > 7) {

+        av_log(avctx, AV_LOG_ERROR, "invalid default channel configuration (%d)\n",

+               channel_config);

+        return -1;

+    }

+    *tags = tags_per_config[channel_config];

+    memcpy(layout_map, aac_channel_layout_map[channel_config-1], *tags * sizeof(*layout_map));

+    return 0;

+}

+

+static ChannelElement *get_che(AACContext *ac, int type, int elem_id)

+{

+    // For PCE based channel configurations map the channels solely based on tags.

+    if (!ac->m4ac.chan_config) {

+        return ac->tag_che_map[type][elem_id];

+    }

+    // Allow single CPE stereo files to be signalled with mono configuration.

+    if (!ac->tags_mapped && type == TYPE_CPE && ac->m4ac.chan_config == 1) {

+        uint8_t layout_map[MAX_ELEM_ID*4][3];

+        int layout_map_tags;

+

+        if (set_default_channel_config(ac->avctx, layout_map, &layout_map_tags,

+                                       2) < 0)

+            return NULL;

+        if (output_configure(ac, layout_map, layout_map_tags,

+                             2, OC_TRIAL_FRAME) < 0)

+            return NULL;

+

+        ac->m4ac.chan_config = 2;

+    }

+    // For indexed channel configurations map the channels solely based on position.

+    switch (ac->m4ac.chan_config) {

+    case 7:

+        if (ac->tags_mapped == 3 && type == TYPE_CPE) {

+            ac->tags_mapped++;

+            return ac->tag_che_map[TYPE_CPE][elem_id] = ac->che[TYPE_CPE][2];

+        }

+    case 6:

+        /* Some streams incorrectly code 5.1 audio as SCE[0] CPE[0] CPE[1] SCE[1]

+           instead of SCE[0] CPE[0] CPE[1] LFE[0]. If we seem to have

+           encountered such a stream, transfer the LFE[0] element to the SCE[1]'s mapping */

+        if (ac->tags_mapped == tags_per_config[ac->m4ac.chan_config] - 1 && (type == TYPE_LFE || type == TYPE_SCE)) {

+            ac->tags_mapped++;

+            return ac->tag_che_map[type][elem_id] = ac->che[TYPE_LFE][0];

+        }

+    case 5:

+        if (ac->tags_mapped == 2 && type == TYPE_CPE) {

+            ac->tags_mapped++;

+            return ac->tag_che_map[TYPE_CPE][elem_id] = ac->che[TYPE_CPE][1];

+        }

+    case 4:

+        if (ac->tags_mapped == 2 && ac->m4ac.chan_config == 4 && type == TYPE_SCE) {

+            ac->tags_mapped++;

+            return ac->tag_che_map[TYPE_SCE][elem_id] = ac->che[TYPE_SCE][1];

+        }

+    case 3:

+    case 2:

+        if (ac->tags_mapped == (ac->m4ac.chan_config != 2) && type == TYPE_CPE) {

+            ac->tags_mapped++;

+            return ac->tag_che_map[TYPE_CPE][elem_id] = ac->che[TYPE_CPE][0];

+        } else if (ac->m4ac.chan_config == 2) {

+            return NULL;

+        }

+    case 1:

+        if (!ac->tags_mapped && type == TYPE_SCE) {

+            ac->tags_mapped++;

+            return ac->tag_che_map[TYPE_SCE][elem_id] = ac->che[TYPE_SCE][0];

+        }

+    default:

+        return NULL;

+    }

+}

+

+/**

  * Decode an array of 4 bit element IDs, optionally interleaved with a stereo/mono switching bit.

  *

  * @param type speaker type/position for these channels

@@ -551,27 +586,6 @@ static int decode_pce(AVCodecContext *avctx, MPEG4AudioConfig *m4ac,

 }

 /**

- * Set up channel positions based on a default channel configuration

- * as specified in table 1.17.

- *

- * @return  Returns error status. 0 - OK, !0 - error

- */

-static av_cold int set_default_channel_config(AVCodecContext *avctx,

-                                              uint8_t (*layout_map)[3],

-                                              int *tags,

-                                              int channel_config)

-{

-    if (channel_config < 1 || channel_config > 7) {

-        av_log(avctx, AV_LOG_ERROR, "invalid default channel configuration (%d)\n",

-               channel_config);

-        return -1;

-    }

-    *tags = tags_per_config[channel_config];

-    memcpy(layout_map, aac_channel_layout_map[channel_config-1], *tags * sizeof(*layout_map));

-    return 0;

-}

-

-/**

  * Decode GA "General Audio" specific configuration; reference: table 4.1.

  *

  * @param   ac          pointer to AACContext, may be null

@@ -2138,6 +2138,17 @@ static av_cold int validate_options(AC3EncodeContext *s)

     s->bit_alloc.sr_code  = i % 3;

     s->bitstream_id       = s->eac3 ? 16 : 8 + s->bit_alloc.sr_shift;

+    /* select a default bit rate if not set by the user */

+    if (!avctx->bit_rate) {

+        switch (s->fbw_channels) {

+        case 1: avctx->bit_rate =  96000; break;

+        case 2: avctx->bit_rate = 192000; break;

+        case 3: avctx->bit_rate = 320000; break;

+        case 4: avctx->bit_rate = 384000; break;

+        case 5: avctx->bit_rate = 448000; break;

+        }

+    }

+

     /* validate bit rate */

     if (s->eac3) {

         int max_br, min_br, wpf, min_br_dist, min_br_code;

@@ -2186,15 +2197,20 @@ static av_cold int validate_options(AC3EncodeContext *s)

             wpf--;

         s->frame_size_min = 2 * wpf;

     } else {

+        int best_br = 0, best_code = 0, best_diff = INT_MAX;

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

-            if ((ff_ac3_bitrate_tab[i] >> s->bit_alloc.sr_shift)*1000 == avctx->bit_rate)

+            int br   = (ff_ac3_bitrate_tab[i] >> s->bit_alloc.sr_shift) * 1000;

+            int diff = abs(br - avctx->bit_rate);

+            if (diff < best_diff) {

+                best_br   = br;

+                best_code = i;

+                best_diff = diff;

+            }

+            if (!best_diff)

                 break;

         }

-        if (i == 19) {

-            av_log(avctx, AV_LOG_ERROR, "invalid bit rate\n");

-            return AVERROR(EINVAL);

-        }

-        s->frame_size_code = i << 1;

+        avctx->bit_rate    = best_br;

+        s->frame_size_code = best_code << 1;

         s->frame_size_min  = 2 * ff_ac3_frame_size_tab[s->frame_size_code][s->bit_alloc.sr_code];

         s->num_blks_code   = 0x3;

         s->num_blocks      = 6;

@@ -157,4 +157,5 @@ AVCodec ff_ac3_fixed_encoder = {

     .long_name = NULL_IF_CONFIG_SMALL("ATSC A/52A (AC-3)"),

     .priv_class = &ac3enc_class,

     .channel_layouts = ff_ac3_channel_layouts,

+    .defaults        = ac3_defaults,

 };

@@ -155,5 +155,6 @@ AVCodec ff_ac3_encoder = {

     .long_name = NULL_IF_CONFIG_SMALL("ATSC A/52A (AC-3)"),

     .priv_class = &ac3enc_class,

     .channel_layouts = ff_ac3_channel_layouts,

+    .defaults        = ac3_defaults,

 };

 #endif

@@ -20,6 +20,7 @@

  */

 #include "libavutil/opt.h"

+#include "internal.h"

 #include "ac3.h"

 #if AC3ENC_TYPE == AC3ENC_TYPE_AC3_FIXED

@@ -78,3 +79,8 @@ static const AVOption eac3_options[] = {

     {"auto", "Selected by the Encoder", 0, AV_OPT_TYPE_CONST, {.dbl = AC3ENC_OPT_AUTO }, INT_MIN, INT_MAX, AC3ENC_PARAM, "cpl_start_band"},

 {NULL}

 };

+

+static const AVCodecDefault ac3_defaults[] = {

+    { "b",  "0" },

+    { NULL }

+};

@@ -200,6 +200,10 @@ static enum Mode unpack_bitstream(AMRContext *p, const uint8_t *buf,

     p->bad_frame_indicator = !get_bits1(&gb); // quality bit

     skip_bits(&gb, 2);                        // two padding bits

+    if (mode >= N_MODES || buf_size < frame_sizes_nb[mode] + 1) {

+        return NO_DATA;

+    }

+

     if (mode < MODE_DTX)

         ff_amr_bit_reorder((uint16_t *) &p->frame, sizeof(AMRNBFrame), buf + 1,

                            amr_unpacking_bitmaps_per_mode[mode]);

@@ -947,6 +951,10 @@ static int amrnb_decode_frame(AVCodecContext *avctx, void *data,

     buf_out = (float *)p->avframe.data[0];

     p->cur_frame_mode = unpack_bitstream(p, buf, buf_size);

+    if (p->cur_frame_mode == NO_DATA) {

+        av_log(avctx, AV_LOG_ERROR, "Corrupt bitstream\n");

+        return AVERROR_INVALIDDATA;

+    }

     if (p->cur_frame_mode == MODE_DTX) {

         av_log_missing_feature(avctx, "dtx mode", 0);

         av_log(avctx, AV_LOG_INFO, "Note: libopencore_amrnb supports dtx\n");

@@ -582,17 +582,19 @@ typedef struct RcOverride{

 #define CODEC_FLAG_BITEXACT       0x00800000 ///< Use only bitexact stuff (except (I)DCT).

 /* Fx : Flag for h263+ extra options */

 #define CODEC_FLAG_AC_PRED        0x01000000 ///< H.263 advanced intra coding / MPEG-4 AC prediction

-#define CODEC_FLAG_CBP_RD         0x04000000 ///< Use rate distortion optimization for cbp.

-#define CODEC_FLAG_QP_RD          0x08000000 ///< Use rate distortion optimization for qp selectioon.

 #define CODEC_FLAG_LOOP_FILTER    0x00000800 ///< loop filter

 #define CODEC_FLAG_INTERLACED_ME  0x20000000 ///< interlaced motion estimation

 #define CODEC_FLAG_CLOSED_GOP     0x80000000

 #define CODEC_FLAG2_FAST          0x00000001 ///< Allow non spec compliant speedup tricks.

-#define CODEC_FLAG2_STRICT_GOP    0x00000002 ///< Strictly enforce GOP size.

 #define CODEC_FLAG2_NO_OUTPUT     0x00000004 ///< Skip bitstream encoding.

 #define CODEC_FLAG2_LOCAL_HEADER  0x00000008 ///< Place global headers at every keyframe instead of in extradata.

 #define CODEC_FLAG2_DROP_FRAME_TIMECODE 0x00002000 ///< timecode is in drop frame format. DEPRECATED!!!!

+#if FF_API_MPV_GLOBAL_OPTS

+#define CODEC_FLAG_CBP_RD         0x04000000 ///< Use rate distortion optimization for cbp.

+#define CODEC_FLAG_QP_RD          0x08000000 ///< Use rate distortion optimization for qp selectioon.

+#define CODEC_FLAG2_STRICT_GOP    0x00000002 ///< Strictly enforce GOP size.

 #define CODEC_FLAG2_SKIP_RD       0x00004000 ///< RD optimal MB level residual skipping

+#endif

 #define CODEC_FLAG2_CHUNKS        0x00008000 ///< Input bitstream might be truncated at a packet boundaries instead of only at frame boundaries.

 #define CODEC_FLAG2_SHOW_ALL      0x00400000 ///< Show all frames before the first keyframe

@@ -1492,19 +1494,21 @@ typedef struct AVCodecContext {

     int b_frame_strategy;

+#if FF_API_MPV_GLOBAL_OPTS

     /**

      * luma single coefficient elimination threshold

      * - encoding: Set by user.

      * - decoding: unused

      */

-    int luma_elim_threshold;

+    attribute_deprecated int luma_elim_threshold;

     /**

      * chroma single coeff elimination threshold

      * - encoding: Set by user.

      * - decoding: unused

      */

-    int chroma_elim_threshold;

+    attribute_deprecated int chroma_elim_threshold;

+#endif

     /**

      * qscale offset between IP and B-frames

@@ -1735,13 +1739,15 @@ typedef struct AVCodecContext {

      */

     int inter_quant_bias;

+#if FF_API_COLOR_TABLE_ID

     /**

      * color table ID

      * - encoding: unused

      * - decoding: Which clrtable should be used for 8bit RGB images.

      *             Tables have to be stored somewhere. FIXME

      */

-    int color_table_id;

+    attribute_deprecated int color_table_id;

+#endif

     /**

      * slice flags

@@ -1799,19 +1805,19 @@ typedef struct AVCodecContext {

      */

     int noise_reduction;

+#if FF_API_INTER_THRESHOLD

     /**

-     *

-     * - encoding: Set by user.

-     * - decoding: unused

+     * @deprecated this field is unused

      */

-    int inter_threshold;

+    attribute_deprecated int inter_threshold;

+#endif

+#if FF_API_MPV_GLOBAL_OPTS

     /**

-     * quantizer noise shaping

-     * - encoding: Set by user.

-     * - decoding: unused

+     * @deprecated use mpegvideo private options instead

      */

-    int quantizer_noise_shaping;

+    attribute_deprecated int quantizer_noise_shaping;

+#endif

     /**

      * Motion estimation threshold below which no motion estimation is

@@ -228,7 +228,7 @@ static av_cold int decode_init(AVCodecContext *avctx) {

             av_log(avctx, AV_LOG_ERROR,

                    "CamStudio codec error: invalid depth %i bpp\n",

                    avctx->bits_per_coded_sample);

-            return 1;

+            return AVERROR_INVALIDDATA;

     }

     c->bpp = avctx->bits_per_coded_sample;

     avcodec_get_frame_defaults(&c->pic);

@@ -242,7 +242,7 @@ static av_cold int decode_init(AVCodecContext *avctx) {

     c->decomp_buf = av_malloc(c->decomp_size + AV_LZO_OUTPUT_PADDING);

     if (!c->decomp_buf) {

         av_log(avctx, AV_LOG_ERROR, "Can't allocate decompression buffer.\n");

-        return 1;

+        return AVERROR(ENOMEM);

     }

     return 0;

 }

@@ -131,9 +131,8 @@ static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,

     memcpy (buf +   8, "V1.0", 4);

     write32(buf +  20, 1); /* new image */

     write32(buf +  24, HEADER_SIZE);

-    if(!(avctx->flags & CODEC_FLAG_BITEXACT)){

+    if (!(avctx->flags & CODEC_FLAG_BITEXACT))

         memcpy (buf + 160, LIBAVCODEC_IDENT, FFMIN(sizeof(LIBAVCODEC_IDENT), 100));

-    }

     write32(buf + 660, 0xFFFFFFFF); /* unencrypted */

     /* Image information header */

@@ -258,5 +258,6 @@ AVCodec ff_eac3_encoder = {

     .long_name       = NULL_IF_CONFIG_SMALL("ATSC A/52 E-AC-3"),

     .priv_class      = &eac3enc_class,

     .channel_layouts = ff_ac3_channel_layouts,

+    .defaults        = ac3_defaults,

 };

 #endif

@@ -84,6 +84,8 @@ void ff_flv2_encode_ac_esc(PutBitContext *pb, int slevel, int level, int run, in

     }

 }

+FF_MPV_GENERIC_CLASS(flv)

+

 AVCodec ff_flv_encoder = {

     .name           = "flv",

     .type           = AVMEDIA_TYPE_VIDEO,

@@ -94,4 +96,5 @@ AVCodec ff_flv_encoder = {

     .close          = ff_MPV_encode_end,

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

     .long_name= NULL_IF_CONFIG_SMALL("Flash Video (FLV) / Sorenson Spark / Sorenson H.263"),

+    .priv_class     = &flv_class,

 };

@@ -321,6 +321,8 @@ static void h261_encode_block(H261Context * h, DCTELEM * block, int n){

     }

 }

+FF_MPV_GENERIC_CLASS(h261)

+

 AVCodec ff_h261_encoder = {

     .name           = "h261",

     .type           = AVMEDIA_TYPE_VIDEO,

@@ -331,4 +333,5 @@ AVCodec ff_h261_encoder = {

     .close          = ff_MPV_encode_end,

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

     .long_name= NULL_IF_CONFIG_SMALL("H.261"),

+    .priv_class     = &h261_class,

 };

@@ -148,7 +148,7 @@ static inline int get_p_cbp(MpegEncContext * s,

                       int motion_x, int motion_y){

     int cbp, i;

-    if(s->flags & CODEC_FLAG_CBP_RD){

+    if (s->mpv_flags & FF_MPV_FLAG_CBP_RD) {

         int best_cbpy_score= INT_MAX;

         int best_cbpc_score= INT_MAX;

         int cbpc = (-1), cbpy= (-1);

@@ -1998,6 +1998,8 @@ decode_intra_mb:

         }

         // The pixels are stored in the same order as levels in h->mb array.

+        if ((int) (h->cabac.bytestream_end - ptr) < mb_size)

+            return -1;

         memcpy(h->mb, ptr, mb_size); ptr+=mb_size;

         ff_init_cabac_decoder(&h->cabac, ptr, h->cabac.bytestream_end - ptr);

@@ -20,12 +20,13 @@

 /**

  * @file

- * Ogg Vorbis codec support via libvorbisenc.

+ * Vorbis encoding support via libvorbisenc.

  * @author Mark Hills <mark@pogo.org.uk>

  */

 #include <vorbis/vorbisenc.h>

+#include "libavutil/fifo.h"

 #include "libavutil/opt.h"

 #include "avcodec.h"

 #include "bytestream.h"

@@ -35,32 +36,41 @@

 #undef NDEBUG

 #include <assert.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 OGGVORBIS_FRAME_SIZE 64

 #define BUFFER_SIZE (1024 * 64)

 typedef struct OggVorbisContext {

-    AVClass *av_class;

-    vorbis_info vi;

-    vorbis_dsp_state vd;

-    vorbis_block vb;

-    uint8_t buffer[BUFFER_SIZE];

-    int buffer_index;

-    int eof;

-

-    /* decoder */

-    vorbis_comment vc;

-    ogg_packet op;

-

-    double iblock;

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

+    ogg_packet op;                      /**< ogg packet                     */

+    double iblock;                      /**< impulse block bias option      */

 } OggVorbisContext;

 static const AVOption options[] = {

     { "iblock", "Sets the impulse block bias", offsetof(OggVorbisContext, 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 class = { "libvorbis", av_default_item_name, options, LIBAVUTIL_VERSION_INT };

+

 static int vorbis_error_to_averror(int ov_err)

 {

     switch (ov_err) {

@@ -71,27 +81,34 @@ static int vorbis_error_to_averror(int ov_err)

     }

 }

-static av_cold int oggvorbis_init_encoder(vorbis_info *vi, AVCodecContext *avccontext)

+static av_cold int oggvorbis_init_encoder(vorbis_info *vi,

+                                          AVCodecContext *avctx)

 {

-    OggVorbisContext *context = avccontext->priv_data;

+    OggVorbisContext *s = avctx->priv_data;

     double cfreq;

     int ret;

-    if (avccontext->flags & CODEC_FLAG_QSCALE) {

-        /* variable bitrate */

-        float q = avccontext->global_quality / (float)FF_QP2LAMBDA;

-        if ((ret = vorbis_encode_setup_vbr(vi, avccontext->channels,

-                                           avccontext->sample_rate,

+    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 = avccontext->rc_min_rate > 0 ? avccontext->rc_min_rate : -1;

-        int maxrate = avccontext->rc_min_rate > 0 ? avccontext->rc_max_rate : -1;

+        int minrate = avctx->rc_min_rate > 0 ? avctx->rc_min_rate : -1;

+        int maxrate = avctx->rc_max_rate > 0 ? avctx->rc_max_rate : -1;

-        /* constant bitrate */

-        if ((ret = vorbis_encode_setup_managed(vi, avccontext->channels,

-                                               avccontext->sample_rate, minrate,

-                                               avccontext->bit_rate, maxrate)))

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

@@ -101,43 +118,44 @@ static av_cold int oggvorbis_init_encoder(vorbis_info *vi, AVCodecContext *avcco

     }

     /* cutoff frequency */

-    if (avccontext->cutoff > 0) {

-        cfreq = avccontext->cutoff / 1000.0;

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

     }

-    if (context->iblock) {

-        if ((ret = vorbis_encode_ctl(vi, OV_ECTL_IBLOCK_SET, &context->iblock)))

+    /* impulse block bias */

+    if (s->iblock) {

+        if ((ret = vorbis_encode_ctl(vi, OV_ECTL_IBLOCK_SET, &s->iblock)))

             goto error;

     }

-    if (avccontext->channels == 3 &&

-            avccontext->channel_layout != (AV_CH_LAYOUT_STEREO|AV_CH_FRONT_CENTER) ||

-        avccontext->channels == 4 &&

-            avccontext->channel_layout != AV_CH_LAYOUT_2_2 &&

-            avccontext->channel_layout != AV_CH_LAYOUT_QUAD ||

-        avccontext->channels == 5 &&

-            avccontext->channel_layout != AV_CH_LAYOUT_5POINT0 &&

-            avccontext->channel_layout != AV_CH_LAYOUT_5POINT0_BACK ||

-        avccontext->channels == 6 &&

-            avccontext->channel_layout != AV_CH_LAYOUT_5POINT1 &&

-            avccontext->channel_layout != AV_CH_LAYOUT_5POINT1_BACK ||

-        avccontext->channels == 7 &&

-            avccontext->channel_layout != (AV_CH_LAYOUT_5POINT1|AV_CH_BACK_CENTER) ||

-        avccontext->channels == 8 &&

-            avccontext->channel_layout != AV_CH_LAYOUT_7POINT1) {

-        if (avccontext->channel_layout) {

+    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), avccontext->channels,

-                                         avccontext->channel_layout);

-            av_log(avccontext, AV_LOG_ERROR, "%s not supported by Vorbis: "

+            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(avccontext, AV_LOG_WARNING, "No channel layout specified. The encoder "

+            av_log(avctx, AV_LOG_WARNING, "No channel layout specified. The encoder "

                                                "will use Vorbis channel layout for "

-                                               "%d channels.\n", avccontext->channels);

+                                               "%d channels.\n", avctx->channels);

         }

     }

@@ -155,59 +173,64 @@ static int xiph_len(int l)

     return 1 + l / 255 + l;

 }

-static av_cold int oggvorbis_encode_close(AVCodecContext *avccontext)

+static av_cold int oggvorbis_encode_close(AVCodecContext *avctx)

 {

-    OggVorbisContext *context = avccontext->priv_data;

-/*  ogg_packet op ; */

+    OggVorbisContext *s = avctx->priv_data;

-    vorbis_analysis_wrote(&context->vd, 0);  /* notify vorbisenc this is EOF */

+    /* notify vorbisenc this is EOF */

+    if (s->dsp_initialized)

+        vorbis_analysis_wrote(&s->vd, 0);

-    vorbis_block_clear(&context->vb);

-    vorbis_dsp_clear(&context->vd);

-    vorbis_info_clear(&context->vi);

+    vorbis_block_clear(&s->vb);

+    vorbis_dsp_clear(&s->vd);

+    vorbis_info_clear(&s->vi);

-    av_freep(&avccontext->coded_frame);

-    av_freep(&avccontext->extradata);

+    av_fifo_free(s->pkt_fifo);

+    av_freep(&avctx->coded_frame);

+    av_freep(&avctx->extradata);

     return 0;

 }

-static av_cold int oggvorbis_encode_init(AVCodecContext *avccontext)

+static av_cold int oggvorbis_encode_init(AVCodecContext *avctx)

 {

-    OggVorbisContext *context = avccontext->priv_data;

+    OggVorbisContext *s = avctx->priv_data;

     ogg_packet header, header_comm, header_code;

     uint8_t *p;

     unsigned int offset;

     int ret;

-    vorbis_info_init(&context->vi);

-    if ((ret = oggvorbis_init_encoder(&context->vi, avccontext))) {

-        av_log(avccontext, AV_LOG_ERROR, "oggvorbis_encode_init: init_encoder failed\n");

+    vorbis_info_init(&s->vi);

+    if ((ret = oggvorbis_init_encoder(&s->vi, avctx))) {

+        av_log(avctx, AV_LOG_ERROR, "encoder setup failed\n");

         goto error;

     }

-    if ((ret = vorbis_analysis_init(&context->vd, &context->vi))) {

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

     }

-    if ((ret = vorbis_block_init(&context->vd, &context->vb))) {

+    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(&context->vc);

-    vorbis_comment_add_tag(&context->vc, "encoder", LIBAVCODEC_IDENT);

+    vorbis_comment_init(&s->vc);

+    vorbis_comment_add_tag(&s->vc, "encoder", LIBAVCODEC_IDENT);

-    if ((ret = vorbis_analysis_headerout(&context->vd, &context->vc, &header,

-                                         &header_comm, &header_code))) {

+    if ((ret = vorbis_analysis_headerout(&s->vd, &s->vc, &header, &header_comm,

+                                         &header_code))) {

         ret = vorbis_error_to_averror(ret);

         goto error;

     }

-    avccontext->extradata_size =

-        1 + xiph_len(header.bytes) + xiph_len(header_comm.bytes) +

-        header_code.bytes;

-    p = avccontext->extradata =

-            av_malloc(avccontext->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);

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

@@ -222,100 +245,107 @@ static av_cold int oggvorbis_encode_init(AVCodecContext *avccontext)

     offset += header_comm.bytes;

     memcpy(&p[offset], header_code.packet, header_code.bytes);

     offset += header_code.bytes;

-    assert(offset == avccontext->extradata_size);

+    assert(offset == avctx->extradata_size);

-#if 0

-    vorbis_block_clear(&context->vb);

-    vorbis_dsp_clear(&context->vd);

-    vorbis_info_clear(&context->vi);

-#endif

-    vorbis_comment_clear(&context->vc);

+    vorbis_comment_clear(&s->vc);

-    avccontext->frame_size = OGGVORBIS_FRAME_SIZE;

+    avctx->frame_size = OGGVORBIS_FRAME_SIZE;

+

+    s->pkt_fifo = av_fifo_alloc(BUFFER_SIZE);

+    if (!s->pkt_fifo) {

+        ret = AVERROR(ENOMEM);

+        goto error;

+    }

-    avccontext->coded_frame = avcodec_alloc_frame();

-    if (!avccontext->coded_frame) {

+    avctx->coded_frame = avcodec_alloc_frame();

+    if (!avctx->coded_frame) {

         ret = AVERROR(ENOMEM);

         goto error;

     }

     return 0;

 error:

-    oggvorbis_encode_close(avccontext);

+    oggvorbis_encode_close(avctx);

     return ret;

 }

-static int oggvorbis_encode_frame(AVCodecContext *avccontext,

-                                  unsigned char *packets,

+static int oggvorbis_encode_frame(AVCodecContext *avctx, unsigned char *packets,

                                   int buf_size, void *data)