@@ -1267,7 +1267,8 @@ static void do_video_out(AVFormatContext *s,

         av_init_packet(&pkt);

         pkt.stream_index= ost->index;

-        if (s->oformat->flags & AVFMT_RAWPICTURE) {

+        if (s->oformat->flags & AVFMT_RAWPICTURE &&

+            enc->codec->id == CODEC_ID_RAWVIDEO) {

             /* raw pictures are written as AVPicture structure to

                avoid any copies. We support temporarily the older

                method. */

@@ -1528,7 +1529,7 @@ static void flush_encoders(OutputStream *ost_table, int nb_ostreams)

         if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)

             continue;

-        if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))

+        if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE) && enc->codec->id == CODEC_ID_RAWVIDEO)

             continue;

         for(;;) {

@@ -22,6 +22,19 @@ API changes, most recent first:

 2011-10-20 - b35e9e1 - lavu 51.22.0

   Add av_strtok() to avstring.h.

+2011-xx-xx - xxxxxxx - lavc 53.25.0

+  Add nb_samples and extended_data fields to AVFrame.

+  Deprecate AVCODEC_MAX_AUDIO_FRAME_SIZE.

+  Deprecate avcodec_decode_audio3() in favor of avcodec_decode_audio4().

+  avcodec_decode_audio4() writes output samples to an AVFrame, which allows

+  audio decoders to use get_buffer().

+

+2011-xx-xx - xxxxxxx - lavc 53.24.0

+  Change AVFrame.data[4]/base[4]/linesize[4]/error[4] to [8] at next major bump.

+  Change AVPicture.data[4]/linesize[4] to [8] at next major bump.

+  Change AVCodecContext.error[4] to [8] at next major bump.

+  Add AV_NUM_DATA_POINTERS to simplify the bump transition.

+

 2011-11-23 - bbb46f3 - lavu 51.18.0

   Add av_samples_get_buffer_size(), av_samples_fill_arrays(), and

   av_samples_alloc(), to samplefmt.h.

@@ -53,48 +53,26 @@ and should try to fix issues their commit causes.

 @anchor{Coding Rules}

 @section Coding Rules

-FFmpeg is programmed in the ISO C90 language with a few additional

-features from ISO C99, namely:

-@itemize @bullet

-@item

-the @samp{inline} keyword;

-@item

-@samp{//} comments;

-@item

-designated struct initializers (@samp{struct s x = @{ .i = 17 @};})

-@item

-compound literals (@samp{x = (struct s) @{ 17, 23 @};})

-@end itemize

-

-These features are supported by all compilers we care about, so we will not

-accept patches to remove their use unless they absolutely do not impair

-clarity and performance.

+@subsection Code formatting conventions

-All code must compile with recent versions of GCC and a number of other

-currently supported compilers. To ensure compatibility, please do not use

-additional C99 features or GCC extensions. Especially watch out for:

+There are the following guidelines regarding the indentation in files:

 @itemize @bullet

 @item

-mixing statements and declarations;

-@item

-@samp{long long} (use @samp{int64_t} instead);

-@item

-@samp{__attribute__} not protected by @samp{#ifdef __GNUC__} or similar;

-@item

-GCC statement expressions (@samp{(x = (@{ int y = 4; y; @})}).

-@end itemize

-

 Indent size is 4.

-The presentation is one inspired by 'indent -i4 -kr -nut'.

+@item

 The TAB character is forbidden outside of Makefiles as is any

 form of trailing whitespace. Commits containing either will be

 rejected by the git repository.

+@item

+You should try to limit your code lines to 80 characters; however, do so if and only if this improves readability.

+@end itemize

+The presentation is one inspired by 'indent -i4 -kr -nut'.

 The main priority in FFmpeg is simplicity and small code size in order to

 minimize the bug count.

-Comments: Use the JavaDoc/Doxygen

-format (see examples below) so that code documentation

+@subsection Comments

+Use the JavaDoc/Doxygen  format (see examples below) so that code documentation

 can be generated automatically. All nontrivial functions should have a comment

 above them explaining what the function does, even if it is just one sentence.

 All structures and their member variables should be documented, too.

@@ -128,11 +106,69 @@ int myfunc(int my_parameter)

 ...

 @end example

+@subsection C language features

+

+FFmpeg is programmed in the ISO C90 language with a few additional

+features from ISO C99, namely:

+@itemize @bullet

+@item

+the @samp{inline} keyword;

+@item

+@samp{//} comments;

+@item

+designated struct initializers (@samp{struct s x = @{ .i = 17 @};})

+@item

+compound literals (@samp{x = (struct s) @{ 17, 23 @};})

+@end itemize

+

+These features are supported by all compilers we care about, so we will not

+accept patches to remove their use unless they absolutely do not impair

+clarity and performance.

+

+All code must compile with recent versions of GCC and a number of other

+currently supported compilers. To ensure compatibility, please do not use

+additional C99 features or GCC extensions. Especially watch out for:

+@itemize @bullet

+@item

+mixing statements and declarations;

+@item

+@samp{long long} (use @samp{int64_t} instead);

+@item

+@samp{__attribute__} not protected by @samp{#ifdef __GNUC__} or similar;

+@item

+GCC statement expressions (@samp{(x = (@{ int y = 4; y; @})}).

+@end itemize

+

+@subsection Naming conventions

+All names are using underscores (_), not CamelCase. For example, @samp{avfilter_get_video_buffer} is

+a valid function name and @samp{AVFilterGetVideo} is not. The only exception from this are structure names;

+they should always be in the CamelCase

+

+There are following conventions for naming variables and functions:

+@itemize @bullet

+@item

+For local variables no prefix is required.

+@item

+For variables and functions declared as @code{static} no prefixes are required.

+@item

+For variables and functions used internally by the library, @code{ff_} prefix should be used.

+For example, @samp{ff_w64_demuxer}.

+@item

+For variables and functions used internally across multiple libraries, use @code{avpriv_}. For example,

+@samp{avpriv_aac_parse_header}.

+@item

+For exported names, each library has its own prefixes. Just check the existing code and name accordingly.

+@end itemize

+

+@subsection Miscellanous conventions

+@itemize @bullet

+@item

 fprintf and printf are forbidden in libavformat and libavcodec,

 please use av_log() instead.

-

+@item

 Casts should be used only when necessary. Unneeded parentheses

 should also be avoided if they don't make the code easier to understand.

+@end itemize

 @section Development Policy

@@ -840,13 +840,22 @@ bash directly to work around this:

 bash ./configure

 @end example

-@subsection Darwin (MacOS X, iPhone)

+@anchor{Darwin}

+@subsection Darwin (OSX, iPhone)

-MacOS X on PowerPC or ARM (iPhone) requires a preprocessor from

+The toolchain provided with Xcode is sufficient to build the basic

+unacelerated code.

+

+OSX on PowerPC or ARM (iPhone) requires a preprocessor from

 @url{http://github.com/yuvi/gas-preprocessor} to build the optimized

 assembler functions. Just download the Perl script and put it somewhere

 in your PATH, FFmpeg's configure will pick it up automatically.

+OSX on amd64 and x86 requires @command{yasm} to build most of the

+optimized assembler functions @url{http://mxcl.github.com/homebrew/, Homebrew},

+@url{http://www.gentoo.org/proj/en/gentoo-alt/prefix/bootstrap-macos.xml, Gentoo Prefix}

+or @url{http://www.macports.org, MacPorts} can easily provide it.

+

 @section Windows

 To get help and instructions for building FFmpeg under Windows, check out

@@ -1295,7 +1295,8 @@ static void do_video_out(AVFormatContext *s,

         av_init_packet(&pkt);

         pkt.stream_index= ost->index;

-        if (s->oformat->flags & AVFMT_RAWPICTURE) {

+        if (s->oformat->flags & AVFMT_RAWPICTURE &&

+            enc->codec->id == CODEC_ID_RAWVIDEO) {

             /* raw pictures are written as AVPicture structure to

                avoid any copies. We support temporarily the older

                method. */

@@ -1560,7 +1561,7 @@ static void flush_encoders(OutputStream *ost_table, int nb_ostreams)

         if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)

             continue;

-        if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))

+        if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE) && enc->codec->id == CODEC_ID_RAWVIDEO)

             continue;

         for(;;) {

@@ -41,6 +41,7 @@

 /** decoder context */

 typedef struct EightSvxContext {

+    AVFrame frame;

     const int8_t *table;

     /* buffer used to store the whole audio decoded/interleaved chunk,

@@ -99,11 +100,13 @@ static int delta_decode(int8_t *dst, const uint8_t *src, int src_size,

     return dst-dst0;

 }

-static int eightsvx_decode_frame(AVCodecContext *avctx, void *data, int *data_size,

-                                 AVPacket *avpkt)

+/** decode a frame */

+static int eightsvx_decode_frame(AVCodecContext *avctx, void *data,

+                                 int *got_frame_ptr, AVPacket *avpkt)

 {

     EightSvxContext *esc = avctx->priv_data;

-    int out_data_size, n;

+    int n, out_data_size, ret;

+    uint8_t *out_date;

     uint8_t *src, *dst;

     /* decode and interleave the first packet */

@@ -145,19 +148,22 @@ static int eightsvx_decode_frame(AVCodecContext *avctx, void *data, int *data_si

             memcpy(esc->samples, deinterleaved_samples, esc->samples_size);

     }

-    /* return single packed with fixed size */

-    out_data_size = FFMIN(MAX_FRAME_SIZE, esc->samples_size - esc->samples_idx);

-    if (*data_size < out_data_size) {

-        av_log(avctx, AV_LOG_ERROR, "Provided buffer with size %d is too small.\n", *data_size);

-        return AVERROR(EINVAL);

+    /* get output buffer */

+    esc->frame.nb_samples = (FFMIN(MAX_FRAME_SIZE, esc->samples_size - esc->samples_idx) +avctx->channels-1)  / avctx->channels;

+    if ((ret = avctx->get_buffer(avctx, &esc->frame)) < 0) {

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

+        return ret;

     }

-    *data_size = out_data_size;

-    dst = data;

+    *got_frame_ptr   = 1;

+    *(AVFrame *)data = esc->frame;

+

+    dst = esc->frame.data[0];

     src = esc->samples + esc->samples_idx;

+    out_data_size = esc->frame.nb_samples * avctx->channels;

     for (n = out_data_size; n > 0; n--)

         *dst++ = *src++ + 128;

-    esc->samples_idx += *data_size;

+    esc->samples_idx += out_data_size;

     return avctx->codec->id == CODEC_ID_8SVX_FIB || avctx->codec->id == CODEC_ID_8SVX_EXP ?

         (avctx->frame_number == 0)*2 + out_data_size / 2 :

@@ -184,6 +190,9 @@ static av_cold int eightsvx_decode_init(AVCodecContext *avctx)

     }

     avctx->sample_fmt = AV_SAMPLE_FMT_U8;

+    avcodec_get_frame_defaults(&esc->frame);

+    avctx->coded_frame = &esc->frame;

+

     return 0;

 }

@@ -206,6 +215,7 @@ AVCodec ff_eightsvx_fib_decoder = {

   .init           = eightsvx_decode_init,

   .decode         = eightsvx_decode_frame,

   .close          = eightsvx_decode_close,

+  .capabilities   = CODEC_CAP_DR1,

   .long_name      = NULL_IF_CONFIG_SMALL("8SVX fibonacci"),

 };

@@ -217,6 +227,7 @@ AVCodec ff_eightsvx_exp_decoder = {

   .init           = eightsvx_decode_init,

   .decode         = eightsvx_decode_frame,

   .close          = eightsvx_decode_close,

+  .capabilities   = CODEC_CAP_DR1,

   .long_name      = NULL_IF_CONFIG_SMALL("8SVX exponential"),

 };

@@ -228,5 +239,6 @@ AVCodec ff_pcm_s8_planar_decoder = {

     .init           = eightsvx_decode_init,

     .close          = eightsvx_decode_close,

     .decode         = eightsvx_decode_frame,

+    .capabilities   = CODEC_CAP_DR1,

     .long_name      = NULL_IF_CONFIG_SMALL("PCM signed 8-bit planar"),

 };

@@ -251,6 +251,7 @@ typedef struct {

  */

 typedef struct {

     AVCodecContext *avctx;

+    AVFrame frame;

     MPEG4AudioConfig m4ac;

@@ -471,15 +471,17 @@ static int decode_ga_specific_config(AACContext *ac, AVCodecContext *avctx,

  * @param   ac          pointer to AACContext, may be null

  * @param   avctx       pointer to AVCCodecContext, used for logging

  * @param   m4ac        pointer to MPEG4AudioConfig, used for parsing

- * @param   data        pointer to AVCodecContext extradata

- * @param   data_size   size of AVCCodecContext extradata

+ * @param   data        pointer to buffer holding an audio specific config

+ * @param   bit_size    size of audio specific config or data in bits

+ * @param   sync_extension look for an appended sync extension

  *

  * @return  Returns error status or number of consumed bits. <0 - error

  */

 static int decode_audio_specific_config(AACContext *ac,

                                         AVCodecContext *avctx,

                                         MPEG4AudioConfig *m4ac,

-                                        const uint8_t *data, int data_size, int asclen)

+                                        const uint8_t *data, int bit_size,

+                                        int sync_extension)

 {

     GetBitContext gb;

     int i;

@@ -489,9 +491,9 @@ static int decode_audio_specific_config(AACContext *ac,

          av_dlog(avctx, "%02x ", avctx->extradata[i]);

     av_dlog(avctx, "\n");

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

+    init_get_bits(&gb, data, bit_size);

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

+    if ((i = avpriv_mpeg4audio_get_config(m4ac, data, bit_size, sync_extension)) < 0)

         return -1;

     if (m4ac->sampling_index > 12) {

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

@@ -591,7 +593,7 @@ static av_cold int aac_decode_init(AVCodecContext *avctx)

     if (avctx->extradata_size > 0) {

         if (decode_audio_specific_config(ac, ac->avctx, &ac->m4ac,

                                          avctx->extradata,

-                                         avctx->extradata_size, 8*avctx->extradata_size) < 0)

+                                         avctx->extradata_size*8, 1) < 0)

             return -1;

     } else {

         int sr, i;

@@ -665,6 +667,9 @@ static av_cold int aac_decode_init(AVCodecContext *avctx)

     cbrt_tableinit();

+    avcodec_get_frame_defaults(&ac->frame);

+    avctx->coded_frame = &ac->frame;

+

     return 0;

 }

@@ -2132,12 +2137,12 @@ static int parse_adts_frame_header(AACContext *ac, GetBitContext *gb)

 }

 static int aac_decode_frame_int(AVCodecContext *avctx, void *data,

-                                int *data_size, GetBitContext *gb)

+                                int *got_frame_ptr, GetBitContext *gb)

 {

     AACContext *ac = avctx->priv_data;

     ChannelElement *che = NULL, *che_prev = NULL;

     enum RawDataBlockType elem_type, elem_type_prev = TYPE_END;

-    int err, elem_id, data_size_tmp;

+    int err, elem_id;

     int samples = 0, multiplier, audio_found = 0;

     if (show_bits(gb, 12) == 0xfff) {

@@ -2250,24 +2255,26 @@ static int aac_decode_frame_int(AVCodecContext *avctx, void *data,

         avctx->frame_size = samples;

     }

-    data_size_tmp = samples * avctx->channels *

-                    av_get_bytes_per_sample(avctx->sample_fmt);

-    if (*data_size < data_size_tmp) {

-        av_log(avctx, AV_LOG_ERROR,

-               "Output buffer too small (%d) or trying to output too many samples (%d) for this frame.\n",

-               *data_size, data_size_tmp);

-        return -1;

-    }

-    *data_size = data_size_tmp;

-

     if (samples) {

+        /* get output buffer */

+        ac->frame.nb_samples = samples;

+        if ((err = avctx->get_buffer(avctx, &ac->frame)) < 0) {

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

+            return err;

+        }

+

         if (avctx->sample_fmt == AV_SAMPLE_FMT_FLT)

-            ac->fmt_conv.float_interleave(data, (const float **)ac->output_data,

+            ac->fmt_conv.float_interleave((float *)ac->frame.data[0],

+                                          (const float **)ac->output_data,

                                           samples, avctx->channels);

         else

-            ac->fmt_conv.float_to_int16_interleave(data, (const float **)ac->output_data,

+            ac->fmt_conv.float_to_int16_interleave((int16_t *)ac->frame.data[0],

+                                                   (const float **)ac->output_data,

                                                    samples, avctx->channels);

+

+        *(AVFrame *)data = ac->frame;

     }

+    *got_frame_ptr = !!samples;

     if (ac->output_configured && audio_found)

         ac->output_configured = OC_LOCKED;

@@ -2276,7 +2283,7 @@ static int aac_decode_frame_int(AVCodecContext *avctx, void *data,

 }

 static int aac_decode_frame(AVCodecContext *avctx, void *data,

-                            int *data_size, AVPacket *avpkt)

+                            int *got_frame_ptr, AVPacket *avpkt)

 {

     const uint8_t *buf = avpkt->data;

     int buf_size = avpkt->size;

@@ -2287,7 +2294,7 @@ static int aac_decode_frame(AVCodecContext *avctx, void *data,

     init_get_bits(&gb, buf, buf_size * 8);

-    if ((err = aac_decode_frame_int(avctx, data, data_size, &gb)) < 0)

+    if ((err = aac_decode_frame_int(avctx, data, got_frame_ptr, &gb)) < 0)

         return err;

     buf_consumed = (get_bits_count(&gb) + 7) >> 3;

@@ -2340,30 +2347,40 @@ static inline uint32_t latm_get_value(GetBitContext *b)

 static int latm_decode_audio_specific_config(struct LATMContext *latmctx,

                                              GetBitContext *gb, int asclen)

 {

-    AVCodecContext *avctx = latmctx->aac_ctx.avctx;

-    AACContext *ac= &latmctx->aac_ctx;

-    MPEG4AudioConfig m4ac=ac->m4ac;

-    int  config_start_bit = get_bits_count(gb);

-    int     bits_consumed, esize;

+    AACContext *ac        = &latmctx->aac_ctx;

+    AVCodecContext *avctx = ac->avctx;

+    MPEG4AudioConfig m4ac = {0};

+    int config_start_bit  = get_bits_count(gb);

+    int sync_extension    = 0;

+    int bits_consumed, esize;

+

+    if (asclen) {

+        sync_extension = 1;

+        asclen         = FFMIN(asclen, get_bits_left(gb));

+    } else

+        asclen         = get_bits_left(gb);

     if (config_start_bit % 8) {

         av_log_missing_feature(latmctx->aac_ctx.avctx, "audio specific "

                                "config not byte aligned.\n", 1);

         return AVERROR_INVALIDDATA;

-    } else {

-        bits_consumed =

-            decode_audio_specific_config(ac, avctx, &m4ac,

+    }

+    bits_consumed = decode_audio_specific_config(NULL, avctx, &m4ac,

                                          gb->buffer + (config_start_bit / 8),

-                                         get_bits_left(gb) / 8, asclen);

+                                         asclen, sync_extension);

-        if (bits_consumed < 0)

-            return AVERROR_INVALIDDATA;

-        if(ac->m4ac.sample_rate != m4ac.sample_rate || m4ac.chan_config != ac->m4ac.chan_config)

-            ac->m4ac= m4ac;

+    if (bits_consumed < 0)

+        return AVERROR_INVALIDDATA;

+

+    if (ac->m4ac.sample_rate != m4ac.sample_rate ||

+        ac->m4ac.chan_config != m4ac.chan_config) {

+

+        av_log(avctx, AV_LOG_INFO, "audio config changed\n");

+        latmctx->initialized = 0;

         esize = (bits_consumed+7) / 8;

-        if (avctx->extradata_size <= esize) {

+        if (avctx->extradata_size < esize) {

             av_free(avctx->extradata);

             avctx->extradata = av_malloc(esize + FF_INPUT_BUFFER_PADDING_SIZE);

             if (!avctx->extradata)

@@ -2373,9 +2390,8 @@ static int latm_decode_audio_specific_config(struct LATMContext *latmctx,

         avctx->extradata_size = esize;

         memcpy(avctx->extradata, gb->buffer + (config_start_bit/8), esize);

         memset(avctx->extradata+esize, 0, FF_INPUT_BUFFER_PADDING_SIZE);

-

-        skip_bits_long(gb, bits_consumed);

     }

+    skip_bits_long(gb, bits_consumed);

     return bits_consumed;

 }

@@ -2512,8 +2528,8 @@ static int read_audio_mux_element(struct LATMContext *latmctx,

 }

-static int latm_decode_frame(AVCodecContext *avctx, void *out, int *out_size,

-                             AVPacket *avpkt)

+static int latm_decode_frame(AVCodecContext *avctx, void *out,

+                             int *got_frame_ptr, AVPacket *avpkt)

 {

     struct LATMContext *latmctx = avctx->priv_data;

     int                 muxlength, err;

@@ -2535,12 +2551,12 @@ static int latm_decode_frame(AVCodecContext *avctx, void *out, int *out_size,

     if (!latmctx->initialized) {

         if (!avctx->extradata) {

-            *out_size = 0;

+            *got_frame_ptr = 0;

             return avpkt->size;

         } else {

             if ((err = decode_audio_specific_config(

                     &latmctx->aac_ctx, avctx, &latmctx->aac_ctx.m4ac,

-                    avctx->extradata, avctx->extradata_size, 8*avctx->extradata_size)) < 0)

+                    avctx->extradata, avctx->extradata_size*8, 1)) < 0)

                 return err;

             latmctx->initialized = 1;

         }

@@ -2553,7 +2569,7 @@ static int latm_decode_frame(AVCodecContext *avctx, void *out, int *out_size,

         return AVERROR_INVALIDDATA;

     }

-    if ((err = aac_decode_frame_int(avctx, out, out_size, &gb)) < 0)

+    if ((err = aac_decode_frame_int(avctx, out, got_frame_ptr, &gb)) < 0)

         return err;

     return muxlength;

@@ -2583,7 +2599,7 @@ AVCodec ff_aac_decoder = {

     .sample_fmts = (const enum AVSampleFormat[]) {

         AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_NONE

     },

-    .capabilities = CODEC_CAP_CHANNEL_CONF,

+    .capabilities = CODEC_CAP_CHANNEL_CONF | CODEC_CAP_DR1,

     .channel_layouts = aac_channel_layout,

 };

@@ -2604,7 +2620,7 @@ AVCodec ff_aac_latm_decoder = {

     .sample_fmts = (const enum AVSampleFormat[]) {

         AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_NONE

     },

-    .capabilities = CODEC_CAP_CHANNEL_CONF,

+    .capabilities = CODEC_CAP_CHANNEL_CONF | CODEC_CAP_DR1,

     .channel_layouts = aac_channel_layout,

     .flush = flush,

 };

@@ -208,6 +208,9 @@ static av_cold int ac3_decode_init(AVCodecContext *avctx)

     }

     s->downmixed = 1;

+    avcodec_get_frame_defaults(&s->frame);

+    avctx->coded_frame = &s->frame;

+

     return 0;

 }

@@ -1296,16 +1299,15 @@ static int decode_audio_block(AC3DecodeContext *s, int blk)

 /**

  * Decode a single AC-3 frame.

  */

-static int ac3_decode_frame(AVCodecContext * avctx, void *data, int *data_size,

-                            AVPacket *avpkt)

+static int ac3_decode_frame(AVCodecContext * avctx, void *data,

+                            int *got_frame_ptr, AVPacket *avpkt)

 {

     const uint8_t *buf = avpkt->data;

     int buf_size = avpkt->size;

     AC3DecodeContext *s = avctx->priv_data;

-    float   *out_samples_flt = data;

-    int16_t *out_samples_s16 = data;

-    int blk, ch, err;

-    int data_size_orig, data_size_tmp;

+    float   *out_samples_flt;

+    int16_t *out_samples_s16;

+    int blk, ch, err, ret;

     const uint8_t *channel_map;

     const float *output[AC3_MAX_CHANNELS];

@@ -1322,8 +1324,6 @@ static int ac3_decode_frame(AVCodecContext * avctx, void *data, int *data_size,

     init_get_bits(&s->gbc, buf, buf_size * 8);

     /* parse the syncinfo */

-    data_size_orig = *data_size;

-    *data_size = 0;

     err = parse_frame_header(s);

     if (err) {

@@ -1345,6 +1345,7 @@ static int ac3_decode_frame(AVCodecContext * avctx, void *data, int *data_size,

                 /* TODO: add support for substreams and dependent frames */

                 if(s->frame_type == EAC3_FRAME_TYPE_DEPENDENT || s->substreamid) {

                     av_log(avctx, AV_LOG_ERROR, "unsupported frame type : skipping frame\n");

+                    *got_frame_ptr = 0;

                     return s->frame_size;

                 } else {

                     av_log(avctx, AV_LOG_ERROR, "invalid frame type\n");

@@ -1406,21 +1407,24 @@ static int ac3_decode_frame(AVCodecContext * avctx, void *data, int *data_size,

     if (s->bitstream_mode == 0x7 && s->channels > 1)

         avctx->audio_service_type = AV_AUDIO_SERVICE_TYPE_KARAOKE;

+    /* get output buffer */

+    s->frame.nb_samples = s->num_blocks * 256;

+    if ((ret = avctx->get_buffer(avctx, &s->frame)) < 0) {

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

+        return ret;

+    }

+    out_samples_flt = (float   *)s->frame.data[0];

+    out_samples_s16 = (int16_t *)s->frame.data[0];

+

     /* decode the audio blocks */

     channel_map = ff_ac3_dec_channel_map[s->output_mode & ~AC3_OUTPUT_LFEON][s->lfe_on];

     for (ch = 0; ch < s->out_channels; ch++)

         output[ch] = s->output[channel_map[ch]];

-    data_size_tmp = s->num_blocks * 256 * avctx->channels;

-    data_size_tmp *= avctx->sample_fmt == AV_SAMPLE_FMT_FLT ? sizeof(*out_samples_flt) : sizeof(*out_samples_s16);

-    if (data_size_orig < data_size_tmp)

-        return -1;

-    *data_size = data_size_tmp;

     for (blk = 0; blk < s->num_blocks; blk++) {

         if (!err && decode_audio_block(s, blk)) {

             av_log(avctx, AV_LOG_ERROR, "error decoding the audio block\n");

             err = 1;

         }

-

         if (avctx->sample_fmt == AV_SAMPLE_FMT_FLT) {

             s->fmt_conv.float_interleave(out_samples_flt, output, 256,

                                          s->out_channels);

@@ -1431,8 +1435,10 @@ static int ac3_decode_frame(AVCodecContext * avctx, void *data, int *data_size,

             out_samples_s16 += 256 * s->out_channels;

         }

     }

-    *data_size = s->num_blocks * 256 * avctx->channels *

-                 av_get_bytes_per_sample(avctx->sample_fmt);

+

+    *got_frame_ptr   = 1;

+    *(AVFrame *)data = s->frame;

+

     return FFMIN(buf_size, s->frame_size);

 }

@@ -1477,6 +1483,7 @@ AVCodec ff_ac3_decoder = {

     .init = ac3_decode_init,

     .close = ac3_decode_end,

     .decode = ac3_decode_frame,

+    .capabilities = CODEC_CAP_DR1,

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

     .sample_fmts = (const enum AVSampleFormat[]) {

         AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_NONE

@@ -1499,6 +1506,7 @@ AVCodec ff_eac3_decoder = {

     .init = ac3_decode_init,

     .close = ac3_decode_end,

     .decode = ac3_decode_frame,

+    .capabilities = CODEC_CAP_DR1,

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

     .sample_fmts = (const enum AVSampleFormat[]) {

         AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_NONE

@@ -68,6 +68,7 @@

 typedef struct {

     AVClass        *class;                  ///< class for AVOptions

     AVCodecContext *avctx;                  ///< parent context

+    AVFrame frame;                          ///< AVFrame for decoded output

     GetBitContext gbc;                      ///< bitstream reader

 ///@name Bit stream information

@@ -84,6 +84,7 @@ static const int swf_index_tables[4][16] = {

 /* end of tables */

 typedef struct ADPCMDecodeContext {

+    AVFrame frame;

     ADPCMChannelStatus status[6];

 } ADPCMDecodeContext;

@@ -124,6 +125,10 @@ static av_cold int adpcm_decode_init(AVCodecContext * avctx)

         break;

     }

     avctx->sample_fmt = AV_SAMPLE_FMT_S16;

+

+    avcodec_get_frame_defaults(&c->frame);

+    avctx->coded_frame = &c->frame;

+

     return 0;

 }

@@ -501,9 +506,8 @@ static int get_nb_samples(AVCodecContext *avctx, const uint8_t *buf,

         decode_top_nibble_next = 1; \

     }

-static int adpcm_decode_frame(AVCodecContext *avctx,

-                            void *data, int *data_size,

-                            AVPacket *avpkt)

+static int adpcm_decode_frame(AVCodecContext *avctx, void *data,

+                              int *got_frame_ptr, AVPacket *avpkt)

 {

     const uint8_t *buf = avpkt->data;

     int buf_size = avpkt->size;

@@ -514,7 +518,7 @@ static int adpcm_decode_frame(AVCodecContext *avctx,

     const uint8_t *src;

     int st; /* stereo */

     int count1, count2;

-    int nb_samples, coded_samples, out_bps, out_size;

+    int nb_samples, coded_samples, ret;

     nb_samples = get_nb_samples(avctx, buf, buf_size, &coded_samples);

     if (nb_samples <= 0) {

@@ -522,22 +526,22 @@ static int adpcm_decode_frame(AVCodecContext *avctx,

         return AVERROR_INVALIDDATA;

     }

-    out_bps  = av_get_bytes_per_sample(avctx->sample_fmt);

-    out_size = nb_samples * avctx->channels * out_bps;

-    if (*data_size < out_size) {

-        av_log(avctx, AV_LOG_ERROR, "output buffer is too small\n");

-        return AVERROR(EINVAL);

+    /* get output buffer */

+    c->frame.nb_samples = nb_samples;

+    if ((ret = avctx->get_buffer(avctx, &c->frame)) < 0) {

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

+        return ret;

     }

+    samples = (short *)c->frame.data[0];

+

     /* use coded_samples when applicable */

     /* it is always <= nb_samples, so the output buffer will be large enough */

     if (coded_samples) {

         if (coded_samples != nb_samples)

             av_log(avctx, AV_LOG_WARNING, "mismatch in coded sample count\n");

-        nb_samples = coded_samples;

-        out_size = nb_samples * avctx->channels * out_bps;

+        c->frame.nb_samples = nb_samples = coded_samples;

     }

-    samples = data;

     src = buf;

     st = avctx->channels == 2 ? 1 : 0;

@@ -576,7 +580,7 @@ static int adpcm_decode_frame(AVCodecContext *avctx,

                 cs->step_index = 88;

             }

-            samples = (short*)data + channel;

+            samples = (short *)c->frame.data[0] + channel;

             for (m = 0; m < 32; m++) {

                 *samples = adpcm_ima_qt_expand_nibble(cs, src[0] & 0x0F, 3);

@@ -628,7 +632,7 @@ static int adpcm_decode_frame(AVCodecContext *avctx,

         }

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

-            samples = (short*)data + i;

+            samples = (short *)c->frame.data[0] + i;

             cs = &c->status[i];

             for (n = nb_samples >> 1; n > 0; n--, src++) {

                 uint8_t v = *src;

@@ -965,7 +969,7 @@ static int adpcm_decode_frame(AVCodecContext *avctx,

             }

         }

-        out_size = count * 28 * avctx->channels * out_bps;

+        c->frame.nb_samples = count * 28;

         src = src_end;

         break;

     }

@@ -1144,7 +1148,7 @@ static int adpcm_decode_frame(AVCodecContext *avctx,

             prev[0][i] = (int16_t)bytestream_get_be16(&src);

         for (ch = 0; ch <= st; ch++) {

-            samples = (unsigned short *) data + ch;

+            samples = (short *)c->frame.data[0] + ch;

             /* Read in every sample for this channel.  */

             for (i = 0; i < nb_samples / 14; i++) {

@@ -1177,7 +1181,10 @@ static int adpcm_decode_frame(AVCodecContext *avctx,

     default:

         return -1;

     }

-    *data_size = out_size;

+

+    *got_frame_ptr   = 1;

+    *(AVFrame *)data = c->frame;

+

     return src - buf;

 }

@@ -1190,6 +1197,7 @@ AVCodec ff_ ## name_ ## _decoder = {                        \

     .priv_data_size = sizeof(ADPCMDecodeContext),           \

     .init           = adpcm_decode_init,                    \

     .decode         = adpcm_decode_frame,                   \

+    .capabilities   = CODEC_CAP_DR1,                        \

     .long_name      = NULL_IF_CONFIG_SMALL(long_name_),     \

 }

@@ -40,6 +40,7 @@ typedef struct {

 } ADXChannelState;

 typedef struct {

+    AVFrame frame;

     int channels;

     ADXChannelState prev[2];

     int header_parsed;

@@ -50,6 +50,10 @@ static av_cold int adx_decode_init(AVCodecContext *avctx)

     c->channels = avctx->channels;

     avctx->sample_fmt = AV_SAMPLE_FMT_S16;

+

+    avcodec_get_frame_defaults(&c->frame);

+    avctx->coded_frame = &c->frame;

+

     return 0;

 }

@@ -89,36 +93,42 @@ static int adx_decode(ADXContext *c, int16_t *out, const uint8_t *in, int ch)

     return 0;

 }

-static int adx_decode_frame(AVCodecContext *avctx, void *data, int *data_size,

-                            AVPacket *avpkt)

+static int adx_decode_frame(AVCodecContext *avctx, void *data,

+                            int *got_frame_ptr, AVPacket *avpkt)

 {

     int buf_size        = avpkt->size;

     ADXContext *c       = avctx->priv_data;

-    int16_t *samples    = data;

+    int16_t *samples;

     const uint8_t *buf  = avpkt->data;

-    int num_blocks, ch;

+    int num_blocks, ch, ret;

     if (c->eof) {

-        *data_size = 0;

+        *got_frame_ptr = 0;

         return buf_size;

     }

-    /* 18 bytes of data are expanded into 32*2 bytes of audio,

-       so guard against buffer overflows */

+    /* calculate number of blocks in the packet */

     num_blocks = buf_size / (BLOCK_SIZE * c->channels);

-    if (num_blocks > *data_size / (BLOCK_SAMPLES * c->channels)) {

-        buf_size   = (*data_size / (BLOCK_SAMPLES * c->channels)) * BLOCK_SIZE;

-        num_blocks = buf_size / (BLOCK_SIZE * c->channels);

-    }