@@ -66,6 +66,7 @@ easier to use. The changes are:

 - libutvideo wrapper (--enable-libutvideo)

 - aevalsrc audio source added

 - Ut Video decoder

+- Speex encoding via libspeex

 version 0.8:

@@ -182,7 +182,7 @@ External library support:

   --enable-libopenjpeg     enable JPEG 2000 decoding via OpenJPEG [no]

   --enable-librtmp         enable RTMP[E] support via librtmp [no]

   --enable-libschroedinger enable Dirac support via libschroedinger [no]

-  --enable-libspeex        enable Speex encoding and decoding via libspeex [no]

+  --enable-libspeex        enable Speex support via libspeex [no]

   --enable-libstagefright-h264  enable H.264 decoding via libstagefright [no]

   --enable-libtheora       enable Theora encoding via libtheora [no]

   --enable-libutvideo      enable Ut Video decoding via libutvideo [no]

@@ -702,6 +702,7 @@ SKIPHEADERS-$(CONFIG_LIBSCHROEDINGER)  += libschroedinger.h

 SKIPHEADERS-$(CONFIG_VAAPI)            += vaapi_internal.h

 SKIPHEADERS-$(CONFIG_VDPAU)            += vdpau.h

 SKIPHEADERS-$(CONFIG_XVMC)             += xvmc.h

+SKIPHEADERS-$(HAVE_W32THREADS)         += w32pthreads.h

 TESTPROGS = cabac dct fft fft-fixed h264 iirfilter rangecoder snow

 TESTPROGS-$(HAVE_MMX) += motion

@@ -55,7 +55,7 @@ static int aac_adtstoasc_filter(AVBitStreamFilterContext *bsfc,

         if (show_bits(&gb, 12) != 0xfff)

             return 0;

-    if (ff_aac_parse_header(&gb, &hdr) < 0) {

+    if (avpriv_aac_parse_header(&gb, &hdr) < 0) {

         av_log(avctx, AV_LOG_ERROR, "Error parsing ADTS frame header!\n");

         return -1;

     }

@@ -78,7 +78,7 @@ static int aac_adtstoasc_filter(AVBitStreamFilterContext *bsfc,

                 return -1;

             }

             init_put_bits(&pb, pce_data, MAX_PCE_SIZE);

-            pce_size = ff_copy_pce_data(&pb, &gb)/8;

+            pce_size = avpriv_copy_pce_data(&pb, &gb)/8;

             flush_put_bits(&pb);

             buf_size -= get_bits_count(&gb)/8;

             buf      += get_bits_count(&gb)/8;

@@ -40,7 +40,7 @@ static int aac_sync(uint64_t state, AACAC3ParseContext *hdr_info,

     tmp.u64 = av_be2ne64(state);

     init_get_bits(&bits, tmp.u8+8-AAC_ADTS_HEADER_SIZE, AAC_ADTS_HEADER_SIZE * 8);

-    if ((size = ff_aac_parse_header(&bits, &hdr)) < 0)

+    if ((size = avpriv_aac_parse_header(&bits, &hdr)) < 0)

         return 0;

     *need_next_header = 0;

     *new_frame_start  = 1;

@@ -26,7 +26,7 @@

 #include "get_bits.h"

 #include "mpeg4audio.h"

-int ff_aac_parse_header(GetBitContext *gbc, AACADTSHeaderInfo *hdr)

+int avpriv_aac_parse_header(GetBitContext *gbc, AACADTSHeaderInfo *hdr)

 {

     int size, rdb, ch, sr;

     int aot, crc_abs;

@@ -39,7 +39,7 @@ int ff_aac_parse_header(GetBitContext *gbc, AACADTSHeaderInfo *hdr)

     crc_abs = get_bits1(gbc);    /* protection_absent */

     aot     = get_bits(gbc, 2);  /* profile_objecttype */

     sr      = get_bits(gbc, 4);  /* sample_frequency_index */

-    if(!ff_mpeg4audio_sample_rates[sr])

+    if(!avpriv_mpeg4audio_sample_rates[sr])

         return AAC_AC3_PARSE_ERROR_SAMPLE_RATE;

     skip_bits1(gbc);             /* private_bit */

     ch      = get_bits(gbc, 3);  /* channel_configuration */

@@ -62,7 +62,7 @@ int ff_aac_parse_header(GetBitContext *gbc, AACADTSHeaderInfo *hdr)

     hdr->crc_absent     = crc_abs;

     hdr->num_aac_frames = rdb + 1;

     hdr->sampling_index = sr;

-    hdr->sample_rate    = ff_mpeg4audio_sample_rates[sr];

+    hdr->sample_rate    = avpriv_mpeg4audio_sample_rates[sr];

     hdr->samples        = (rdb + 1) * 1024;

     hdr->bit_rate       = size * 8 * hdr->sample_rate / hdr->samples;

@@ -49,6 +49,6 @@ typedef struct {

  * -2 if the version element is invalid, -3 if the sample rate

  * element is invalid, or -4 if the bit rate element is invalid.

  */

-int ff_aac_parse_header(GetBitContext *gbc, AACADTSHeaderInfo *hdr);

+int avpriv_aac_parse_header(GetBitContext *gbc, AACADTSHeaderInfo *hdr);

 #endif /* AVCODEC_AACADTSDEC_H */

@@ -472,7 +472,7 @@ static int decode_audio_specific_config(AACContext *ac,

     init_get_bits(&gb, data, data_size * 8);

-    if ((i = ff_mpeg4audio_get_config(m4ac, data, asclen/8)) < 0)

+    if ((i = avpriv_mpeg4audio_get_config(m4ac, data, asclen/8)) < 0)

         return -1;

     if (m4ac->sampling_index > 12) {

         av_log(avctx, AV_LOG_ERROR, "invalid sampling rate index %d\n", m4ac->sampling_index);

@@ -2077,7 +2077,7 @@ static int parse_adts_frame_header(AACContext *ac, GetBitContext *gb)

     int size;

     AACADTSHeaderInfo hdr_info;

-    size = ff_aac_parse_header(gb, &hdr_info);

+    size = avpriv_aac_parse_header(gb, &hdr_info);

     if (size > 0) {

         if (hdr_info.chan_config) {

             enum ChannelPosition new_che_pos[4][MAX_ELEM_ID];

@@ -180,7 +180,7 @@ static av_cold int aac_encode_init(AVCodecContext *avctx)

     avctx->frame_size = 1024;

     for (i = 0; i < 16; i++)

-        if (avctx->sample_rate == ff_mpeg4audio_sample_rates[i])

+        if (avctx->sample_rate == avpriv_mpeg4audio_sample_rates[i])

             break;

     if (i == 16) {

         av_log(avctx, AV_LOG_ERROR, "Unsupported sample rate %d\n", avctx->sample_rate);

@@ -491,7 +491,7 @@ static void put_bitstream_info(AVCodecContext *avctx, AACEncContext *s,

         put_bits(&s->pb, 8, namelen - 16);

     put_bits(&s->pb, 4, 0); //extension type - filler

     padbits = 8 - (put_bits_count(&s->pb) & 7);

-    align_put_bits(&s->pb);

+    avpriv_align_put_bits(&s->pb);

     for (i = 0; i < namelen - 2; i++)

         put_bits(&s->pb, 8, name[i]);

     put_bits(&s->pb, 12 - padbits, 0);

@@ -35,7 +35,7 @@ static const uint8_t eac3_blocks[4] = {

 };

-int ff_ac3_parse_header(GetBitContext *gbc, AC3HeaderInfo *hdr)

+int avpriv_ac3_parse_header(GetBitContext *gbc, AC3HeaderInfo *hdr)

 {

     int frame_size_code;

@@ -141,7 +141,7 @@ static int ac3_sync(uint64_t state, AACAC3ParseContext *hdr_info,

     GetBitContext gbc;

     init_get_bits(&gbc, tmp.u8+8-AC3_HEADER_SIZE, 54);

-    err = ff_ac3_parse_header(&gbc, &hdr);

+    err = avpriv_ac3_parse_header(&gbc, &hdr);

     if(err < 0)

         return 0;

@@ -36,6 +36,6 @@

  * -2 if the bsid (version) element is invalid, -3 if the fscod (sample rate)

  * element is invalid, or -4 if the frmsizecod (bit rate) element is invalid.

  */

-int ff_ac3_parse_header(GetBitContext *gbc, AC3HeaderInfo *hdr);

+int avpriv_ac3_parse_header(GetBitContext *gbc, AC3HeaderInfo *hdr);

 #endif /* AVCODEC_AC3_PARSER_H */

@@ -261,7 +261,7 @@ static int parse_frame_header(AC3DecodeContext *s)

     AC3HeaderInfo hdr;

     int err;

-    err = ff_ac3_parse_header(&s->gbc, &hdr);

+    err = avpriv_ac3_parse_header(&s->gbc, &hdr);

     if(err)

         return err;

@@ -289,7 +289,7 @@ static av_cold int read_specific_config(ALSDecContext *ctx)

     init_get_bits(&gb, avctx->extradata, avctx->extradata_size * 8);

-    config_offset = ff_mpeg4audio_get_config(&m4ac, avctx->extradata,

+    config_offset = avpriv_mpeg4audio_get_config(&m4ac, avctx->extradata,

                                              avctx->extradata_size);

     if (config_offset < 0)

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

     }

     emms_c();

-    align_put_bits(&a->pb);

+    avpriv_align_put_bits(&a->pb);

     while(put_bits_count(&a->pb)&31)

         put_bits(&a->pb, 8, 0);

@@ -210,8 +210,10 @@ enum CodecID {

     CODEC_ID_DFA,

     CODEC_ID_WMV3IMAGE,

     CODEC_ID_VC1IMAGE,

+#if LIBAVCODEC_VERSION_MAJOR == 53

     CODEC_ID_8SVX_RAW,

     CODEC_ID_G2M,

+#endif

     CODEC_ID_UTVIDEO_DEPRECATED,

     CODEC_ID_UTVIDEO = 0x800,

@@ -676,8 +678,10 @@ typedef struct RcOverride{

 /* Codec can export data for HW decoding (XvMC). */

 #define CODEC_CAP_HWACCEL         0x0010

 /**

- * Codec has a nonzero delay and needs to be fed with NULL at the end to get the delayed data.

- * If this is not set, the codec is guaranteed to never be fed with NULL data.

+ * Codec has a nonzero delay and needs to be fed with avpkt->data=NULL,

+ * avpkt->size=0 at the end to get the delayed data until the decoder no longer

+ * returns frames. If this is not set, the codec is guaranteed to never be fed

+ * with NULL data.

  */

 #define CODEC_CAP_DELAY           0x0020

 /**

@@ -3608,6 +3612,7 @@ enum PixelFormat avcodec_find_best_pix_fmt(int64_t pix_fmt_mask, enum PixelForma

 enum PixelFormat avcodec_find_best_pix_fmt2(enum PixelFormat dst_pix_fmt1, enum PixelFormat dst_pix_fmt2,

                                             enum PixelFormat src_pix_fmt, int has_alpha, int *loss_ptr);

+#if FF_API_GET_ALPHA_INFO

 #define FF_ALPHA_TRANSP       0x0001 /* image has some totally transparent pixels */

 #define FF_ALPHA_SEMI_TRANSP  0x0002 /* image has some transparent pixels */

@@ -3615,8 +3620,10 @@ enum PixelFormat avcodec_find_best_pix_fmt2(enum PixelFormat dst_pix_fmt1, enum

  * Tell if an image really has transparent alpha values.

  * @return ored mask of FF_ALPHA_xxx constants

  */

+attribute_deprecated

 int img_get_alpha_info(const AVPicture *src,

                        enum PixelFormat pix_fmt, int width, int height);

+#endif

 /* deinterlace a picture */

 /* deinterlace - if not supported return -1 */

@@ -3940,6 +3947,10 @@ int avcodec_open2(AVCodecContext *avctx, AVCodec *codec, AVDictionary **options)

  * samples should be 16 byte aligned unless the CPU doesn't need it

  * (AltiVec and SSE do).

  *

+ * @note Codecs which have the CODEC_CAP_DELAY capability set have a delay

+ * between input and output, these need to be fed with avpkt->data=NULL,

+ * avpkt->size=0 at the end to return the remaining frames.

+ *

  * @param avctx the codec context

  * @param[out] samples the output buffer, sample type in avctx->sample_fmt

  * @param[in,out] frame_size_ptr the output buffer size in bytes

@@ -3973,8 +3984,9 @@ int avcodec_decode_audio3(AVCodecContext *avctx, int16_t *samples,

  *

  * In practice, avpkt->data should have 4 byte alignment at minimum.

  *

- * @note Some codecs have a delay between input and output, these need to be

- * fed with avpkt->data=NULL, avpkt->size=0 at the end to return the remaining frames.

+ * @note Codecs which have the CODEC_CAP_DELAY capability set have a delay

+ * between input and output, these need to be fed with avpkt->data=NULL,

+ * avpkt->size=0 at the end to return the remaining frames.

  *

  * @param avctx the codec context

  * @param[out] picture The AVFrame in which the decoded video frame will be stored.

@@ -41,7 +41,7 @@ const uint8_t ff_log2_run[41]={

 24,

 };

-void align_put_bits(PutBitContext *s)

+void avpriv_align_put_bits(PutBitContext *s)

 {

     put_bits(s,s->bit_left & 7,0);

 }

@@ -56,7 +56,7 @@ void ff_put_string(PutBitContext *pb, const char *string, int terminate_string)

         put_bits(pb, 8, 0);

 }

-void ff_copy_bits(PutBitContext *pb, const uint8_t *src, int length)

+void avpriv_copy_bits(PutBitContext *pb, const uint8_t *src, int length)

 {

     int words= length>>4;

     int bits= length&15;

@@ -625,8 +625,8 @@ static int decode_seq_header(AVSContext *h) {

     s->low_delay =       get_bits1(&s->gb);

     h->mb_width  = (s->width  + 15) >> 4;

     h->mb_height = (s->height + 15) >> 4;

-    h->s.avctx->time_base.den = ff_frame_rate_tab[frame_rate_code].num;

-    h->s.avctx->time_base.num = ff_frame_rate_tab[frame_rate_code].den;

+    h->s.avctx->time_base.den = avpriv_frame_rate_tab[frame_rate_code].num;

+    h->s.avctx->time_base.num = avpriv_frame_rate_tab[frame_rate_code].den;

     h->s.avctx->width  = s->width;

     h->s.avctx->height = s->height;

     if(!h->top_qp)

@@ -664,7 +664,7 @@ static int cavs_decode_frame(AVCodecContext * avctx,void *data, int *data_size,

     buf_ptr = buf;

     buf_end = buf + buf_size;

     for(;;) {

-        buf_ptr = ff_find_start_code(buf_ptr,buf_end, &stc);

+        buf_ptr = avpriv_mpv_find_start_code(buf_ptr,buf_end, &stc);

         if((stc & 0xFFFFFE00) || buf_ptr == buf_end)

             return FFMAX(0, buf_ptr - buf - s->parse_context.last_index);

         input_size = (buf_end - buf_ptr)*8;

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

     emms_c();

-    align_put_bits(&a->pb);

+    avpriv_align_put_bits(&a->pb);

     while(get_bit_count(&a->pb)&31)

         put_bits(&a->pb, 8, 0);

@@ -145,7 +145,7 @@ static int parse_source_parameters(AVCodecContext *avctx, GetBitContext *gb,

     }

     if (source->frame_rate_index > 0) {

         if (source->frame_rate_index <= 8)

-            frame_rate = ff_frame_rate_tab[source->frame_rate_index];

+            frame_rate = avpriv_frame_rate_tab[source->frame_rate_index];

         else

             frame_rate = dirac_frame_rate[source->frame_rate_index-9];

     }

@@ -242,7 +242,7 @@ static int parse_source_parameters(AVCodecContext *avctx, GetBitContext *gb,

     return 0;

 }

-int ff_dirac_parse_sequence_header(AVCodecContext *avctx, GetBitContext *gb,

+int avpriv_dirac_parse_sequence_header(AVCodecContext *avctx, GetBitContext *gb,

                                    dirac_source_params *source)

 {

     unsigned version_major;

@@ -51,7 +51,7 @@ typedef struct {

     uint8_t color_spec_index;       ///< index into dirac_color_spec_presets[]

 } dirac_source_params;

-int ff_dirac_parse_sequence_header(AVCodecContext *avctx, GetBitContext *gb,

-                                   dirac_source_params *source);

+int avpriv_dirac_parse_sequence_header(AVCodecContext *avctx, GetBitContext *gb,

+                                       dirac_source_params *source);

 #endif /* AVCODEC_DIRAC_H */

@@ -349,7 +349,7 @@ static av_cold int dvvideo_init(AVCodecContext *avctx)

 static av_cold int dvvideo_init_encoder(AVCodecContext *avctx)

 {

-    if (!ff_dv_codec_profile(avctx)) {

+    if (!avpriv_dv_codec_profile(avctx)) {

         av_log(avctx, AV_LOG_ERROR, "Found no DV profile for %ix%i %s video\n",

                avctx->width, avctx->height, av_get_pix_fmt_name(avctx->pix_fmt));

         return -1;

@@ -1072,7 +1072,7 @@ static int dvvideo_decode_frame(AVCodecContext *avctx,

     const uint8_t* vsc_pack;

     int apt, is16_9;

-    s->sys = ff_dv_frame_profile2(avctx, s->sys, buf, buf_size);

+    s->sys = avpriv_dv_frame_profile2(avctx, s->sys, buf, buf_size);

     if (!s->sys || buf_size < s->sys->frame_size || dv_init_dynamic_tables(s->sys)) {

         av_log(avctx, AV_LOG_ERROR, "could not find dv frame profile\n");

         return -1; /* NOTE: we only accept several full frames */

@@ -1246,7 +1246,7 @@ static int dvvideo_encode_frame(AVCodecContext *c, uint8_t *buf, int buf_size,

 {

     DVVideoContext *s = c->priv_data;

-    s->sys = ff_dv_codec_profile(c);

+    s->sys = avpriv_dv_codec_profile(c);

     if (!s->sys || buf_size < s->sys->frame_size || dv_init_dynamic_tables(s->sys))

         return -1;

@@ -246,7 +246,7 @@ static const DVprofile dv_profiles[] = {

     }

 };

-const DVprofile* ff_dv_frame_profile2(AVCodecContext* codec, const DVprofile *sys,

+const DVprofile* avpriv_dv_frame_profile2(AVCodecContext* codec, const DVprofile *sys,

                                   const uint8_t* frame, unsigned buf_size)

 {

    int i, dsf, stype;

@@ -276,13 +276,13 @@ const DVprofile* ff_dv_frame_profile2(AVCodecContext* codec, const DVprofile *sy

    return NULL;

 }

-const DVprofile* ff_dv_frame_profile(const DVprofile *sys,

+const DVprofile* avpriv_dv_frame_profile(const DVprofile *sys,

                                   const uint8_t* frame, unsigned buf_size)

 {

-    return ff_dv_frame_profile2(NULL, sys, frame, buf_size);

+    return avpriv_dv_frame_profile2(NULL, sys, frame, buf_size);

 }

-const DVprofile* ff_dv_codec_profile(AVCodecContext* codec)

+const DVprofile* avpriv_dv_codec_profile(AVCodecContext* codec)

 {

     int i;

@@ -274,11 +274,11 @@ enum dv_pack_type {

  */

 #define DV_MAX_BPM 8

-const DVprofile* ff_dv_frame_profile(const DVprofile *sys,

+const DVprofile* avpriv_dv_frame_profile(const DVprofile *sys,

                                   const uint8_t* frame, unsigned buf_size);

-const DVprofile* ff_dv_frame_profile2(AVCodecContext* codec, const DVprofile *sys,

+const DVprofile* avpriv_dv_frame_profile2(AVCodecContext* codec, const DVprofile *sys,

                                   const uint8_t* frame, unsigned buf_size);

-const DVprofile* ff_dv_codec_profile(AVCodecContext* codec);

+const DVprofile* avpriv_dv_codec_profile(AVCodecContext* codec);

 static inline int dv_write_dif_id(enum dv_section_type t, uint8_t chan_num,

                                   uint8_t seq_num, uint8_t dif_num,

@@ -95,8 +95,8 @@ typedef struct FLACFrameInfo {

  * @param[out] s       where parsed information is stored

  * @param[in]  buffer  pointer to start of 34-byte streaminfo data

  */

-void ff_flac_parse_streaminfo(AVCodecContext *avctx, struct FLACStreaminfo *s,

-                              const uint8_t *buffer);

+void avpriv_flac_parse_streaminfo(AVCodecContext *avctx, struct FLACStreaminfo *s,

+                                  const uint8_t *buffer);

 /**

  * Validate the FLAC extradata.

@@ -105,9 +105,9 @@ void ff_flac_parse_streaminfo(AVCodecContext *avctx, struct FLACStreaminfo *s,

  * @param[out] streaminfo_start pointer to start of 34-byte STREAMINFO data.

  * @return 1 if valid, 0 if not valid.

  */

-int ff_flac_is_extradata_valid(AVCodecContext *avctx,

-                               enum FLACExtradataFormat *format,

-                               uint8_t **streaminfo_start);

+int avpriv_flac_is_extradata_valid(AVCodecContext *avctx,

+                                   enum FLACExtradataFormat *format,

+                                   uint8_t **streaminfo_start);

 /**

  * Parse the metadata block parameters from the header.

@@ -116,8 +116,8 @@ int ff_flac_is_extradata_valid(AVCodecContext *avctx,

  * @param[out] type metadata block type

  * @param[out] size metadata block size

  */

-void ff_flac_parse_block_header(const uint8_t *block_header,

-                                int *last, int *type, int *size);

+void avpriv_flac_parse_block_header(const uint8_t *block_header,

+                                    int *last, int *type, int *size);

 /**

  * Calculate an estimate for the maximum frame size based on verbatim mode.

@@ -63,7 +63,7 @@ typedef struct FLACContext {

 static void allocate_buffers(FLACContext *s);

-int ff_flac_is_extradata_valid(AVCodecContext *avctx,

+int avpriv_flac_is_extradata_valid(AVCodecContext *avctx,

                                enum FLACExtradataFormat *format,

                                uint8_t **streaminfo_start)

 {

@@ -104,11 +104,11 @@ static av_cold int flac_decode_init(AVCodecContext *avctx)

     if (!avctx->extradata)

         return 0;

-    if (!ff_flac_is_extradata_valid(avctx, &format, &streaminfo))

+    if (!avpriv_flac_is_extradata_valid(avctx, &format, &streaminfo))

         return -1;

     /* initialize based on the demuxer-supplied streamdata header */

-    ff_flac_parse_streaminfo(avctx, (FLACStreaminfo *)s, streaminfo);

+    avpriv_flac_parse_streaminfo(avctx, (FLACStreaminfo *)s, streaminfo);

     if (s->bps > 16)

         avctx->sample_fmt = AV_SAMPLE_FMT_S32;

     else

@@ -140,7 +140,7 @@ static void allocate_buffers(FLACContext *s)

     }

 }

-void ff_flac_parse_streaminfo(AVCodecContext *avctx, struct FLACStreaminfo *s,

+void avpriv_flac_parse_streaminfo(AVCodecContext *avctx, struct FLACStreaminfo *s,

                               const uint8_t *buffer)

 {

     GetBitContext gb;

@@ -174,7 +174,7 @@ void ff_flac_parse_streaminfo(AVCodecContext *avctx, struct FLACStreaminfo *s,

     dump_headers(avctx, s);

 }

-void ff_flac_parse_block_header(const uint8_t *block_header,

+void avpriv_flac_parse_block_header(const uint8_t *block_header,

                                 int *last, int *type, int *size)

 {

     int tmp = bytestream_get_byte(&block_header);

@@ -201,12 +201,12 @@ static int parse_streaminfo(FLACContext *s, const uint8_t *buf, int buf_size)

         /* need more data */

         return 0;

     }

-    ff_flac_parse_block_header(&buf[4], NULL, &metadata_type, &metadata_size);

+    avpriv_flac_parse_block_header(&buf[4], NULL, &metadata_type, &metadata_size);

     if (metadata_type != FLAC_METADATA_TYPE_STREAMINFO ||

         metadata_size != FLAC_STREAMINFO_SIZE) {

         return AVERROR_INVALIDDATA;

     }

-    ff_flac_parse_streaminfo(s->avctx, (FLACStreaminfo *)s, &buf[8]);

+    avpriv_flac_parse_streaminfo(s->avctx, (FLACStreaminfo *)s, &buf[8]);

     allocate_buffers(s);

     s->got_streaminfo = 1;

@@ -228,7 +228,7 @@ static int get_metadata_size(const uint8_t *buf, int buf_size)

     do {

         if (buf_end - buf < 4)

             return 0;

-        ff_flac_parse_block_header(buf, &metadata_last, NULL, &metadata_size);

+        avpriv_flac_parse_block_header(buf, &metadata_last, NULL, &metadata_size);

         buf += 4;

         if (buf_end - buf < metadata_size) {

             /* need more data in order to read the complete header */

@@ -25,7 +25,7 @@ void ff_flv_encode_picture_header(MpegEncContext * s, int picture_number)

 {

       int format;

-      align_put_bits(&s->pb);

+      avpriv_align_put_bits(&s->pb);

       put_bits(&s->pb, 17, 1);

       put_bits(&s->pb, 5, (s->h263_flv-1)); /* 0: h263 escape codes 1: 11-bit escape codes */

@@ -53,7 +53,7 @@ void ff_h261_encode_picture_header(MpegEncContext * s, int picture_number){

     H261Context * h = (H261Context *) s;

     int format, temp_ref;

-    align_put_bits(&s->pb);

+    avpriv_align_put_bits(&s->pb);

     /* Update the pointer to last GOB */

     s->ptr_lastgob = put_bits_ptr(&s->pb);

@@ -153,7 +153,7 @@ static inline int parse_nal_units(AVCodecParserContext *s,

     for(;;) {

         int src_length, dst_length, consumed;

-        buf = ff_find_start_code(buf, buf_end, &state);

+        buf = avpriv_mpv_find_start_code(buf, buf_end, &state);

         if(buf >= buf_end)

             break;

         --buf;

@@ -747,6 +747,7 @@ int av_picture_pad(AVPicture *dst, const AVPicture *src, int height, int width,

     return 0;

 }

+#if FF_API_GET_ALPHA_INFO

 /* NOTE: we scan all the pixels to have an exact information */

 static int get_alpha_info_pal8(const AVPicture *src, int width, int height)

 {

@@ -793,6 +794,7 @@ int img_get_alpha_info(const AVPicture *src,

     }

     return ret;

 }

+#endif

 #if !(HAVE_MMX && HAVE_YASM)

 /* filter parameters: [-1 4 2 4 -1] // 8 */

@@ -53,7 +53,7 @@ AVHWAccel *ff_find_hwaccel(enum CodecID codec_id, enum PixelFormat pix_fmt);

  */

 int ff_match_2uint16(const uint16_t (*tab)[2], int size, int a, int b);

-unsigned int ff_toupper4(unsigned int x);

+unsigned int avpriv_toupper4(unsigned int x);

 /**

  * does needed setup of pkt_pts/pos and such for (re)get_buffer();

@@ -126,7 +126,7 @@ void h263_encode_picture_header(MpegEncContext * s, int picture_number)

     coded_frame_rate= 1800000;

     coded_frame_rate_base= (1000+best_clock_code)*best_divisor;

-    align_put_bits(&s->pb);

+    avpriv_align_put_bits(&s->pb);

     /* Update the pointer to last GOB */

     s->ptr_lastgob = put_bits_ptr(&s->pb);

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

             put_bits(&pb, 8, v);

         }

     }

-    align_put_bits(&pb);

+    avpriv_align_put_bits(&pb);

     av_free(buf2);

     /* End of image */

@@ -1,9 +1,8 @@

 LIBAVCODEC_$MAJOR {

-        global: *;

-        local:

-                ff_*_bsf;

-                ff_*_decoder;

-                ff_*_encoder;

-                ff_*_hwaccel;

-                ff_*_parser;

+        global: av*;

+                audio_resample;

+                audio_resample_close;

+                #deprecated, remove after next bump

+                img_get_alpha_info;

+        local:  *;

 };

@@ -1,5 +1,7 @@

 /*

- * Copyright (c) 2009 by Xuggle Incorporated.  All rights reserved.

+ * Copyright (C) 2009 Justin Ruggles

+ * Copyright (c) 2009 Xuggle Incorporated

+ *

  * This file is part of FFmpeg.

  *

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

@@ -16,163 +18,307 @@

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

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

  */

-#include <libavcodec/avcodec.h>

+

+/**

+ * @file

+ * libspeex Speex audio encoder

+ *

+ * Usage Guide

+ * This explains the values that need to be set prior to initialization in

+ * order to control various encoding parameters.

+ *

+ * Channels

+ *     Speex only supports mono or stereo, so avctx->channels must be set to

+ *     1 or 2.

+ *

+ * Sample Rate / Encoding Mode

+ *     Speex has 3 modes, each of which uses a specific sample rate.

+ *         narrowband     :  8 kHz

+ *         wideband       : 16 kHz

+ *         ultra-wideband : 32 kHz

+ *     avctx->sample_rate must be set to one of these 3 values.  This will be

+ *     used to set the encoding mode.

+ *

+ * Rate Control

+ *     VBR mode is turned on by setting CODEC_FLAG_QSCALE in avctx->flags.

+ *     avctx->global_quality is used to set the encoding quality.

+ *     For CBR mode, avctx->bit_rate can be used to set the constant bitrate.

+ *     Alternatively, the 'cbr_quality' option can be set from 0 to 10 to set

+ *     a constant bitrate based on quality.

+ *     For ABR mode, set avctx->bit_rate and set the 'abr' option to 1.

+ *     Approx. Bitrate Range:

+ *         narrowband     : 2400 - 25600 bps

+ *         wideband       : 4000 - 43200 bps

+ *         ultra-wideband : 4400 - 45200 bps

+ *

+ * Complexity

+ *     Encoding complexity is controlled by setting avctx->compression_level.

+ *     The valid range is 0 to 10.  A higher setting gives generally better

+ *     quality at the expense of encoding speed.  This does not affect the

+ *     bit rate.

+ *

+ * Frames-per-Packet

+ *     The encoder defaults to using 1 frame-per-packet.  However, it is

+ *     sometimes desirable to use multiple frames-per-packet to reduce the

+ *     amount of container overhead.  This can be done by setting the

+ *     'frames_per_packet' option to a value 1 to 8.

+ */

+

 #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"

 typedef struct {

-    SpeexBits bits;

-    void *enc_state;

-    SpeexHeader header;

+    AVClass *class;             ///< AVClass for private options

+    SpeexBits bits;             ///< libspeex bitwriter context

+    SpeexHeader header;         ///< libspeex header struct

+    void *enc_state;            ///< libspeex encoder state

+    int frames_per_packet;      ///< number of frames to encode in each packet

+    float vbr_quality;          ///< VBR quality 0.0 to 10.0

+    int cbr_quality;            ///< CBR quality 0 to 10

+    int abr;                    ///< flag to enable ABR

+    int pkt_frame_count;        ///< frame count for the current packet

+    int lookahead;              ///< encoder delay

+    int sample_count;           ///< total sample count (used for pts)

 } LibSpeexEncContext;

+static av_cold void print_enc_params(AVCodecContext *avctx,

+                                     LibSpeexEncContext *s)

+{

+    const char *mode_str = "unknown";

+

+    av_log(avctx, AV_LOG_DEBUG, "channels: %d\n", avctx->channels);

+    switch (s->header.mode) {

+    case SPEEX_MODEID_NB:  mode_str = "narrowband";     break;

+    case SPEEX_MODEID_WB:  mode_str = "wideband";       break;

+    case SPEEX_MODEID_UWB: mode_str = "ultra-wideband"; break;

+    }

+    av_log(avctx, AV_LOG_DEBUG, "mode: %s\n", mode_str);

+    if (s->header.vbr) {

+        av_log(avctx, AV_LOG_DEBUG, "rate control: VBR\n");

+        av_log(avctx, AV_LOG_DEBUG, "  quality: %f\n", s->vbr_quality);

+    } else if (s->abr) {

+        av_log(avctx, AV_LOG_DEBUG, "rate control: ABR\n");

+        av_log(avctx, AV_LOG_DEBUG, "  bitrate: %d bps\n", avctx->bit_rate);

+    } else {

+        av_log(avctx, AV_LOG_DEBUG, "rate control: CBR\n");

+        av_log(avctx, AV_LOG_DEBUG, "  bitrate: %d bps\n", avctx->bit_rate);

+    }

+    av_log(avctx, AV_LOG_DEBUG, "complexity: %d\n",

+           avctx->compression_level);

+    av_log(avctx, AV_LOG_DEBUG, "frame size: %d samples\n",

+           avctx->frame_size);

+    av_log(avctx, AV_LOG_DEBUG, "frames per packet: %d\n",

+           s->frames_per_packet);

+    av_log(avctx, AV_LOG_DEBUG, "packet size: %d\n",

+           avctx->frame_size * s->frames_per_packet);

+}

-static av_cold int libspeex_encode_init(AVCodecContext *avctx)

+static av_cold int encode_init(AVCodecContext *avctx)

 {

-    LibSpeexEncContext *s = (LibSpeexEncContext*)avctx->priv_data;

+    LibSpeexEncContext *s = avctx->priv_data;

     const SpeexMode *mode;

+    uint8_t *header_data;

+    int header_size;

+    int32_t complexity;

-    if ((avctx->sample_fmt != SAMPLE_FMT_S16 && avctx->sample_fmt != SAMPLE_FMT_FLT) ||

-            avctx->sample_rate <= 0 ||

-            avctx->channels <= 0 ||

-            avctx->channels > 2)

-    {

-        av_log(avctx, AV_LOG_ERROR, "Unsupported sample format, rate, or channels for speex");

-        return -1;

+    /* channels */

+    if (avctx->channels < 1 || avctx->channels > 2) {

+        av_log(avctx, AV_LOG_ERROR, "Invalid channels (%d). Only stereo and "

+               "mono are supported\n", avctx->channels);

+        return AVERROR(EINVAL);

     }

-    if (avctx->sample_rate <= 8000)

-        mode = &speex_nb_mode;

-    else if (avctx->sample_rate <= 16000)

-        mode = &speex_wb_mode;

-    else

-        mode = &speex_uwb_mode;

+    /* sample rate and encoding mode */

+    switch (avctx->sample_rate) {

+    case  8000: mode = &speex_nb_mode;  break;

+    case 16000: mode = &speex_wb_mode;  break;

+    case 32000: mode = &speex_uwb_mode; break;

+    default:

+        av_log(avctx, AV_LOG_ERROR, "Sample rate of %d Hz is not supported. "

+               "Resample to 8, 16, or 32 kHz.\n", avctx->sample_rate);

+        return AVERROR(EINVAL);

+    }

-    speex_bits_init(&s->bits);

+    /* initialize libspeex */

     s->enc_state = speex_encoder_init(mode);

-    if (!s->enc_state)

-    {

-        av_log(avctx, AV_LOG_ERROR, "could not initialize speex encoder");

+    if (!s->enc_state) {

+        av_log(avctx, AV_LOG_ERROR, "Error initializing libspeex\n");

         return -1;

     }

+    speex_init_header(&s->header, avctx->sample_rate, avctx->channels, mode);

-    // initialize the header

-    speex_init_header(&s->header, avctx->sample_rate,

-            avctx->channels, mode);

-

-    // TODO: It'd be nice to support VBR here, but

-    // I'm uncertain what AVCodecContext options to use

-    // to signal whether to turn it on.

+    /* rate control method and parameters */

     if (avctx->flags & CODEC_FLAG_QSCALE) {

-        spx_int32_t quality = 0;

-        // Map global_quality's mpeg 1/2/4 scale into Speex's 0-10 scale

-        if (avctx->global_quality > FF_LAMBDA_MAX)

-            quality = 0; // lowest possible quality

-        else

-            quality = (spx_int32_t)((FF_LAMBDA_MAX-avctx->global_quality)*10.0/FF_LAMBDA_MAX);

-        speex_encoder_ctl(s->enc_state, SPEEX_SET_QUALITY, &quality);

+        /* VBR */

+        s->header.vbr = 1;

+        speex_encoder_ctl(s->enc_state, SPEEX_SET_VBR, &s->header.vbr);

+        s->vbr_quality = av_clipf(avctx->global_quality / (float)FF_QP2LAMBDA,

+                                  0.0f, 10.0f);

+        speex_encoder_ctl(s->enc_state, SPEEX_SET_VBR_QUALITY, &s->vbr_quality);

     } else {

-        // default to CBR

-        if (avctx->bit_rate > 0)

-            speex_encoder_ctl(s->enc_state, SPEEX_SET_BITRATE, &avctx->bit_rate);

-        // otherwise just take the default quality setting

+        s->header.bitrate = avctx->bit_rate;

+        if (avctx->bit_rate > 0) {

+            /* CBR or ABR by bitrate */

+            if (s->abr) {

+                speex_encoder_ctl(s->enc_state, SPEEX_SET_ABR,

+                                  &s->header.bitrate);

+                speex_encoder_ctl(s->enc_state, SPEEX_GET_ABR,

+                                  &s->header.bitrate);

+            } else {

+                speex_encoder_ctl(s->enc_state, SPEEX_SET_BITRATE,

+                                  &s->header.bitrate);

+                speex_encoder_ctl(s->enc_state, SPEEX_GET_BITRATE,

+                                  &s->header.bitrate);

+            }

+        } else {

+            /* CBR by quality */

+            speex_encoder_ctl(s->enc_state, SPEEX_SET_QUALITY,

+                              &s->cbr_quality);

+            speex_encoder_ctl(s->enc_state, SPEEX_GET_BITRATE,

+                              &s->header.bitrate);

+        }

+        /* stereo side information adds about 800 bps to the base bitrate */

+        /* TODO: this should be calculated exactly */

+        avctx->bit_rate = s->header.bitrate + (avctx->channels == 2 ? 800 : 0);

     }

-    // reset the bit-rate to the actual bit rate speex will use

-    speex_encoder_ctl(s->enc_state, SPEEX_GET_BITRATE, &s->header.bitrate);

-    avctx->bit_rate = s->header.bitrate;

-

-    // get the actual sample rate

-    speex_encoder_ctl(s->enc_state, SPEEX_GET_SAMPLING_RATE, &s->header.rate);

-    avctx->sample_rate = s->header.rate;

-

-    // get the frame-size.  To align with FLV, we're going to put 2 frames

-    // per packet.  If someone can tell me how to make this configurable

-    // from the avcodec contents, I'll mod this so it's not hard-coded.