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

     format_video_sync = video_sync_method;

     if (format_video_sync < 0)

-        format_video_sync = (s->oformat->flags & AVFMT_VARIABLE_FPS) ? 2 : 1;

+        format_video_sync = (s->oformat->flags & AVFMT_NOTIMESTAMPS) ? 0 :

+                            (s->oformat->flags & AVFMT_VARIABLE_FPS) ? 2 : 1;

     if (format_video_sync) {

         double vdelta = sync_ipts - ost->sync_opts;

@@ -1710,15 +1711,13 @@ static int transcode_audio(InputStream *ist, AVPacket *pkt, int *got_output)

                                 pkt);

     if (ret < 0)

         return ret;

-    pkt->data   += ret;

-    pkt->size   -= ret;

     *got_output  = decoded_data_size > 0;

     /* Some bug in mpeg audio decoder gives */

     /* decoded_data_size < 0, it seems they are overflows */

     if (!*got_output) {

         /* no audio frame */

-        return 0;

+        return ret;

     }

     decoded_data_buf = (uint8_t *)samples;

@@ -1791,7 +1790,7 @@ static int transcode_audio(InputStream *ist, AVPacket *pkt, int *got_output)

         do_audio_out(output_files[ost->file_index].ctx, ost, ist,

                      decoded_data_buf, decoded_data_size);

     }

-    return 0;

+    return ret;

 }

 static int transcode_video(InputStream *ist, AVPacket *pkt, int *got_output, int64_t *pkt_pts)

@@ -1819,7 +1818,7 @@ static int transcode_video(InputStream *ist, AVPacket *pkt, int *got_output, int

     if (!*got_output) {

         /* no picture yet */

         av_freep(&decoded_frame);

-        return 0;

+        return ret;

     }

     ist->next_pts = ist->pts = decoded_frame->best_effort_timestamp;

     if (ist->st->codec->time_base.num != 0) {

@@ -1898,9 +1897,7 @@ static int transcode_subtitles(InputStream *ist, AVPacket *pkt, int *got_output)

     if (ret < 0)

         return ret;

     if (!*got_output)

-        return 0;

-

-    pkt->size = 0;

+        return ret;

     rate_emu_sleep(ist);

@@ -1914,23 +1911,21 @@ static int transcode_subtitles(InputStream *ist, AVPacket *pkt, int *got_output)

     }

     avsubtitle_free(&subtitle);

-    return 0;

+    return ret;

 }

 /* pkt = NULL means EOF (needed to flush decoder buffers) */

-static int output_packet(InputStream *ist, int ist_index,

+static int output_packet(InputStream *ist,

                          OutputStream *ost_table, int nb_ostreams,

                          const AVPacket *pkt)

 {

-    OutputStream *ost;

-    int ret = 0, i;

+    int i;

     int got_output;

     int64_t pkt_pts = AV_NOPTS_VALUE;

-

     AVPacket avpkt;

-    if(ist->next_pts == AV_NOPTS_VALUE)

-        ist->next_pts= ist->pts;

+    if (ist->next_pts == AV_NOPTS_VALUE)

+        ist->next_pts = ist->pts;

     if (pkt == NULL) {

         /* EOF handling */

@@ -1949,13 +1944,16 @@ static int output_packet(InputStream *ist, int ist_index,

     //while we have more to decode or while the decoder did output something on EOF

     while (ist->decoding_needed && (avpkt.size > 0 || (!pkt && got_output))) {

+        int ret = 0;

     handle_eof:

-        ist->pts= ist->next_pts;

-        if(avpkt.size && avpkt.size != pkt->size)

+        ist->pts = ist->next_pts;

+

+        if (avpkt.size && avpkt.size != pkt->size) {

             av_log(NULL, ist->showed_multi_packet_warning ? AV_LOG_VERBOSE : AV_LOG_WARNING,

                    "Multiple frames in a packet from stream %d\n", pkt->stream_index);

-            ist->showed_multi_packet_warning=1;

+            ist->showed_multi_packet_warning = 1;

+        }

         switch(ist->st->codec->codec_type) {

         case AVMEDIA_TYPE_AUDIO:

@@ -1973,13 +1971,15 @@ static int output_packet(InputStream *ist, int ist_index,

         if (ret < 0)

             return ret;

+        // touch data and size only if not EOF

+        if (pkt) {

+            avpkt.data += ret;

+            avpkt.size -= ret;

+        }

         if (!got_output) {

-            if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)

-                continue;

-            goto discard_packet;

+            continue;

         }

     }

- discard_packet:

     /* handle stream copy */

     if (!ist->decoding_needed) {

@@ -2000,7 +2000,7 @@ static int output_packet(InputStream *ist, int ist_index,

         }

     }

     for (i = 0; pkt && i < nb_ostreams; i++) {

-        ost = &ost_table[i];

+        OutputStream *ost = &ost_table[i];

         if (!check_output_constraints(ist, ost) || ost->encoding_needed)

             continue;

@@ -2636,7 +2636,7 @@ static int transcode(OutputFile *output_files,

         }

         //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->st->index, pkt.size);

-        if (output_packet(ist, ist_index, output_streams, nb_output_streams, &pkt) < 0) {

+        if (output_packet(ist, output_streams, nb_output_streams, &pkt) < 0) {

             av_log(NULL, AV_LOG_ERROR, "Error while decoding stream #%d:%d\n",

                    ist->file_index, ist->st->index);

@@ -2657,7 +2657,7 @@ static int transcode(OutputFile *output_files,

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

         ist = &input_streams[i];

         if (ist->decoding_needed) {

-            output_packet(ist, i, output_streams, nb_output_streams, NULL);

+            output_packet(ist, output_streams, nb_output_streams, NULL);

         }

     }

     flush_encoders(output_streams, nb_output_streams);

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

 2011-10-20 - b35e9e1 - lavu 51.22.0

   Add av_strtok() to avstring.h.

+2011-xx-xx - xxxxxxx - lavu 51.18.0

+  Add av_samples_get_buffer_size(), av_samples_fill_arrays(), and

+  av_samples_alloc(), to samplefmt.h.

+

+2011-xx-xx - xxxxxxx - lavu 51.17.0

+  Add planar sample formats and av_sample_fmt_is_planar() to samplefmt.h.

+

 2011-xx-xx - xxxxxxx - lavc 53.21.0

   Move some AVCodecContext fields to a new private struct, AVCodecInternal,

   which is accessed from a new field, AVCodecContext.internal.

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

     format_video_sync = video_sync_method;

     if (format_video_sync < 0)

-        format_video_sync = (s->oformat->flags & AVFMT_VARIABLE_FPS) ? 2 : 1;

+        format_video_sync = (s->oformat->flags & AVFMT_NOTIMESTAMPS) ? 0 :

+                            (s->oformat->flags & AVFMT_VARIABLE_FPS) ? 2 : 1;

     if (format_video_sync) {

         double vdelta = sync_ipts - ost->sync_opts + duration;

@@ -1735,15 +1736,13 @@ static int transcode_audio(InputStream *ist, AVPacket *pkt, int *got_output)

                                 pkt);

     if (ret < 0)

         return ret;

-    pkt->data   += ret;

-    pkt->size   -= ret;

     *got_output  = decoded_data_size > 0;

     /* Some bug in mpeg audio decoder gives */

     /* decoded_data_size < 0, it seems they are overflows */

     if (!*got_output) {

         /* no audio frame */

-        return 0;

+        return ret;

     }

     decoded_data_buf = (uint8_t *)samples;

@@ -1816,7 +1815,7 @@ static int transcode_audio(InputStream *ist, AVPacket *pkt, int *got_output)

         do_audio_out(output_files[ost->file_index].ctx, ost, ist,

                      decoded_data_buf, decoded_data_size);

     }

-    return 0;

+    return ret;

 }

 static int transcode_video(InputStream *ist, AVPacket *pkt, int *got_output, int64_t *pkt_pts, int64_t *pkt_dts)

@@ -1852,7 +1851,7 @@ static int transcode_video(InputStream *ist, AVPacket *pkt, int *got_output, int

     if (!*got_output) {

         /* no picture yet */

         av_freep(&decoded_frame);

-        return 0;

+        return ret;

     }

     if(decoded_frame->best_effort_timestamp != AV_NOPTS_VALUE)

@@ -1943,9 +1942,7 @@ static int transcode_subtitles(InputStream *ist, AVPacket *pkt, int *got_output)

     if (ret < 0)

         return ret;

     if (!*got_output)

-        return 0;

-

-    pkt->size = 0;

+        return ret;

     rate_emu_sleep(ist);

@@ -1959,15 +1956,14 @@ static int transcode_subtitles(InputStream *ist, AVPacket *pkt, int *got_output)

     }

     avsubtitle_free(&subtitle);

-    return 0;

+    return ret;

 }

 /* pkt = NULL means EOF (needed to flush decoder buffers) */

-static int output_packet(InputStream *ist, int ist_index,

+static int output_packet(InputStream *ist,

                          OutputStream *ost_table, int nb_ostreams,

                          const AVPacket *pkt)

 {

-    OutputStream *ost;

     int ret = 0, i;

     int got_output;

     int64_t pkt_dts = AV_NOPTS_VALUE;

@@ -1975,8 +1971,8 @@ static int output_packet(InputStream *ist, int ist_index,

     AVPacket avpkt;

-    if(ist->next_pts == AV_NOPTS_VALUE)

-        ist->next_pts= ist->pts;

+    if (ist->next_pts == AV_NOPTS_VALUE)

+        ist->next_pts = ist->pts;

     if (pkt == NULL) {

         /* EOF handling */

@@ -1999,12 +1995,14 @@ static int output_packet(InputStream *ist, int ist_index,

     //while we have more to decode or while the decoder did output something on EOF

     while (ist->decoding_needed && (avpkt.size > 0 || (!pkt && got_output))) {

     handle_eof:

-        ist->pts= ist->next_pts;

-        if(avpkt.size && avpkt.size != pkt->size)

+        ist->pts = ist->next_pts;

+

+        if (avpkt.size && avpkt.size != pkt->size) {

             av_log(NULL, ist->showed_multi_packet_warning ? AV_LOG_VERBOSE : AV_LOG_WARNING,

                    "Multiple frames in a packet from stream %d\n", pkt->stream_index);

-            ist->showed_multi_packet_warning=1;

+            ist->showed_multi_packet_warning = 1;

+        }

         switch(ist->st->codec->codec_type) {

         case AVMEDIA_TYPE_AUDIO:

@@ -2022,13 +2020,17 @@ static int output_packet(InputStream *ist, int ist_index,

         if (ret < 0)

             return ret;

+        // touch data and size only if not EOF

+        if (pkt) {

+            if(ist->st->codec->codec_type != AVMEDIA_TYPE_AUDIO)

+                ret = avpkt.size;

+            avpkt.data += ret;

+            avpkt.size -= ret;

+        }

         if (!got_output) {

-            if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)

-                continue;

-            goto discard_packet;

+            continue;

         }

     }

- discard_packet:

     /* handle stream copy */

     if (!ist->decoding_needed) {

@@ -2049,7 +2051,7 @@ static int output_packet(InputStream *ist, int ist_index,

         }

     }

     for (i = 0; pkt && i < nb_ostreams; i++) {

-        ost = &ost_table[i];

+        OutputStream *ost = &ost_table[i];

         if (!check_output_constraints(ist, ost) || ost->encoding_needed)

             continue;

@@ -2753,7 +2755,7 @@ static int transcode(OutputFile *output_files, int nb_output_files,

         }

         //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->st->index, pkt.size);

-        if (output_packet(ist, ist_index, output_streams, nb_output_streams, &pkt) < 0) {

+        if (output_packet(ist, output_streams, nb_output_streams, &pkt) < 0) {

             av_log(NULL, AV_LOG_ERROR, "Error while decoding stream #%d:%d\n",

                    ist->file_index, ist->st->index);

@@ -2774,7 +2776,7 @@ static int transcode(OutputFile *output_files, int nb_output_files,

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

         ist = &input_streams[i];

         if (ist->decoding_needed) {

-            output_packet(ist, i, output_streams, nb_output_streams, NULL);

+            output_packet(ist, output_streams, nb_output_streams, NULL);

         }

     }

     flush_encoders(output_streams, nb_output_streams);

@@ -22,8 +22,6 @@

         preserve8

-        .text

-

 .macro  call_2x_pixels  type, subp

 function ff_\type\()_pixels16\subp\()_armv6, export=1

         push            {r0-r3, lr}

@@ -23,7 +23,6 @@

 #include "asm.S"

         preserve8

-        .text

 function ff_clear_block_neon, export=1

         vmov.i16        q0,  #0

@@ -28,7 +28,6 @@

 #define M_SQRT1_2 0.70710678118654752440

-        .text

 function fft4_neon

         vld1.32         {d0-d3}, [r0,:128]

@@ -23,7 +23,6 @@

 #include "asm.S"

         preserve8

-        .text

 function ff_float_to_int16_neon, export=1

         subs            r2,  r2,  #8

@@ -392,9 +392,6 @@ function ff_\type\()_h264_chroma_mc2_neon, export=1

 endfunc

 .endm

-        .text

-        .align

-

         h264_chroma_mc8 put

         h264_chroma_mc8 avg

         h264_chroma_mc4 put

@@ -21,7 +21,6 @@

 #include "asm.S"

         preserve8

-        .text

 function ff_h264_idct_add_neon, export=1

         vld1.64         {d0-d3},  [r1,:128]

@@ -23,7 +23,6 @@

         preserve8

         .fpu neon

-        .text

 function ff_scalarproduct_int16_neon, export=1

         vmov.i16        q0,  #0

@@ -23,8 +23,6 @@

         preserve8

-        .text

-

 #define ff_fft_calc_neon X(ff_fft_calc_neon)

 function ff_imdct_half_neon, export=1

@@ -53,8 +53,6 @@

 #define COL_SHIFTED_1 524288 /* 1<< (COL_SHIFT-1) */

-        .text

-

 function ff_simple_idct_arm, export=1

         @@ void simple_idct_arm(int16_t *block)

         @@ save stack for reg needed (take all of them),

@@ -47,15 +47,20 @@ static av_cold int bethsoftvid_decode_init(AVCodecContext *avctx)

     return 0;

 }

-static void set_palette(AVFrame * frame, const uint8_t * palette_buffer)

+static int set_palette(AVFrame * frame, const uint8_t * palette_buffer, int buf_size)

 {

     uint32_t * palette = (uint32_t *)frame->data[1];

     int a;

+

+    if (buf_size < 256*3)

+        return AVERROR_INVALIDDATA;

+

     for(a = 0; a < 256; a++){

         palette[a] = 0xFF << 24 | AV_RB24(&palette_buffer[a * 3]) * 4;

         palette[a] |= palette[a] >> 6 & 0x30303;

     }

     frame->palette_has_changed = 1;

+    return 256*3;

 }

 static int bethsoftvid_decode_frame(AVCodecContext *avctx,

@@ -82,8 +87,7 @@ static int bethsoftvid_decode_frame(AVCodecContext *avctx,

     switch(block_type = *buf++){

         case PALETTE_BLOCK:

-            set_palette(&vid->frame, buf);

-            return 0;

+            return set_palette(&vid->frame, buf, buf_size);

         case VIDEO_YOFF_P_FRAME:

             yoffset = bytestream_get_le16(&buf);

             if(yoffset >= avctx->height)

@@ -384,7 +384,6 @@ static int pcm_decode_frame(AVCodecContext *avctx,

 #endif /* HAVE_BIGENDIAN */

     case CODEC_ID_PCM_U8:

         memcpy(samples, src, n*sample_size);

-        samples += n * sample_size;

         break;

     case CODEC_ID_PCM_ZORK:

         for (; n > 0; n--) {

@@ -430,7 +429,6 @@ static int pcm_decode_frame(AVCodecContext *avctx,

             }

             break;

         }

-        samples = (uint8_t *) dst_int32_t;

         break;

     }

     case CODEC_ID_PCM_LXF:

@@ -453,7 +451,6 @@ static int pcm_decode_frame(AVCodecContext *avctx,

                                  ((src8[2] & 0xF0) << 8) | (src8[4] << 4) | (src8[3] >> 4);

             }

         }

-        samples = (uint8_t *) dst_int32_t;

         break;

     }

     default:

@@ -25,6 +25,9 @@

  * @author Bartlomiej Wolowiec

  */

+#include "libavutil/log.h"

+#include "libavutil/opt.h"

+

 #include "avcodec.h"

 #if CONFIG_ZLIB

 #include <zlib.h>

@@ -44,7 +47,7 @@ static const uint8_t type_sizes2[6] = {

 };

 typedef struct TiffEncoderContext {

-    AVClass *avclass;

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

     AVCodecContext *avctx;

     AVFrame picture;

@@ -230,7 +233,6 @@ static int encode_frame(AVCodecContext * avctx, unsigned char *buf,

     p->key_frame = 1;

     avctx->coded_frame= &s->picture;

-    s->compr = TIFF_PACKBITS;

     if (avctx->compression_level == 0) {

         s->compr = TIFF_RAW;

     } else if(avctx->compression_level == 2) {

@@ -453,11 +455,26 @@ fail:

     return ret;

 }

-static const AVOption options[]={

-{"dpi", "set the image resolution (in dpi)", offsetof(TiffEncoderContext, dpi), AV_OPT_TYPE_INT, {.dbl = 72}, 1, 0x10000, AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_ENCODING_PARAM},

-{NULL}

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

+#define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM

+static const AVOption options[] = {

+    {"dpi", "set the image resolution (in dpi)", OFFSET(dpi), AV_OPT_TYPE_INT, {.dbl = 72}, 1, 0x10000, AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_ENCODING_PARAM},

+    { "compression_algo", NULL, OFFSET(compr), AV_OPT_TYPE_INT, {TIFF_PACKBITS}, TIFF_RAW, TIFF_DEFLATE, VE, "compression_algo" },

+    { "packbits", NULL, 0, AV_OPT_TYPE_CONST, {TIFF_PACKBITS}, 0, 0, VE, "compression_algo" },

+    { "raw",      NULL, 0, AV_OPT_TYPE_CONST, {TIFF_RAW},      0, 0, VE, "compression_algo" },

+    { "lzw",      NULL, 0, AV_OPT_TYPE_CONST, {TIFF_LZW},      0, 0, VE, "compression_algo" },

+#if CONFIG_ZLIB

+    { "deflate",  NULL, 0, AV_OPT_TYPE_CONST, {TIFF_DEFLATE},  0, 0, VE, "compression_algo" },

+#endif

+    { NULL },

+};

+

+static const AVClass tiffenc_class = {

+    .class_name = "TIFF encoder",

+    .item_name  = av_default_item_name,

+    .option     = options,

+    .version    = LIBAVUTIL_VERSION_INT,

 };

-static const AVClass class = { "tiff", av_default_item_name, options, LIBAVUTIL_VERSION_INT };

 AVCodec ff_tiff_encoder = {

     .name           = "tiff",

@@ -473,5 +490,5 @@ AVCodec ff_tiff_encoder = {

                               PIX_FMT_YUV411P, PIX_FMT_RGB48LE,

                               PIX_FMT_NONE},

     .long_name = NULL_IF_CONFIG_SMALL("TIFF image"),

-    .priv_class= &class,

+    .priv_class     = &tiffenc_class,

 };

@@ -270,7 +270,7 @@ static int init_buffers(AVFilterLink *inlink, int nb_samples)

         int nb_channels = av_get_channel_layout_nb_channels(outlink->channel_layout);

         if (av_samples_alloc(data, linesize, nb_channels, nb_samples,

-                             inlink->format, inlink->planar, 16) < 0)

+                             inlink->format, 16) < 0)

             goto fail_no_mem;

         aconvert->mix_samplesref =

             avfilter_get_audio_buffer_ref_from_arrays(data, linesize, AV_PERM_WRITE,

@@ -241,7 +241,7 @@ int av_asrc_buffer_add_buffer(AVFilterContext *ctx,

     av_samples_fill_arrays(data, linesize,

                            buf, nb_channels, nb_samples,

-                           sample_fmt, planar, 16);

+                           sample_fmt, 16);

     return av_asrc_buffer_add_samples(ctx,

                                       data, linesize, nb_samples,

@@ -91,7 +91,7 @@ AVFilterBufferRef *avfilter_default_get_audio_buffer(AVFilterLink *link, int per

     /* Calculate total buffer size, round to multiple of 16 to be SIMD friendly */

     if (av_samples_alloc(data, linesize,

                          nb_channels, nb_samples, link->format,

-                         link->planar, 16) < 0)

+                         16) < 0)

         return NULL;

     samplesref =

@@ -22,6 +22,8 @@

 #include "avformat.h"

 #define CDG_PACKET_SIZE    24

+#define CDG_COMMAND        0x09

+#define CDG_MASK           0x3F

 static int read_header(AVFormatContext *s, AVFormatParameters *ap)

 {

@@ -49,7 +51,12 @@ static int read_packet(AVFormatContext *s, AVPacket *pkt)

 {

     int ret;

-    ret = av_get_packet(s->pb, pkt, CDG_PACKET_SIZE);

+    while (1) {

+        ret = av_get_packet(s->pb, pkt, CDG_PACKET_SIZE);

+        if (ret < 1 || (pkt->data[0] & CDG_MASK) == CDG_COMMAND)

+            break;

+        av_free_packet(pkt);

+    }

     pkt->stream_index = 0;

     pkt->dts=pkt->pts= s->streams[0]->cur_dts;

@@ -64,4 +64,5 @@ AVOutputFormat ff_crc_muxer = {

     .write_header      = crc_write_header,

     .write_packet      = crc_write_packet,

     .write_trailer     = crc_write_trailer,

+    .flags             = AVFMT_NOTIMESTAMPS,

 };

@@ -40,4 +40,5 @@ AVOutputFormat ff_framecrc_muxer = {

     .audio_codec       = CODEC_ID_PCM_S16LE,

     .video_codec       = CODEC_ID_RAWVIDEO,

     .write_packet      = framecrc_write_packet,

+    .flags             = AVFMT_VARIABLE_FPS,

 };

@@ -75,6 +75,7 @@ AVOutputFormat ff_md5_muxer = {

     .write_header      = write_header,

     .write_packet      = write_packet,

     .write_trailer     = write_trailer,

+    .flags             = AVFMT_NOTIMESTAMPS,

 };

 #endif

@@ -102,5 +103,6 @@ AVOutputFormat ff_framemd5_muxer = {

     .audio_codec       = CODEC_ID_PCM_S16LE,

     .video_codec       = CODEC_ID_RAWVIDEO,

     .write_packet      = framemd5_write_packet,

+    .flags             = AVFMT_VARIABLE_FPS,

 };

 #endif

@@ -153,7 +153,7 @@

  */

 #define LIBAVUTIL_VERSION_MAJOR 51

-#define LIBAVUTIL_VERSION_MINOR 26

+#define LIBAVUTIL_VERSION_MINOR 27

 #define LIBAVUTIL_VERSION_MICRO  0

 #define LIBAVUTIL_VERSION_INT   AV_VERSION_INT(LIBAVUTIL_VERSION_MAJOR, \

@@ -25,15 +25,21 @@

 typedef struct SampleFmtInfo {

     char name[4];

     int bits;

+    int planar;

 } SampleFmtInfo;

 /** this table gives more information about formats */

 static const SampleFmtInfo sample_fmt_info[AV_SAMPLE_FMT_NB] = {

-    [AV_SAMPLE_FMT_U8]  = { .name = "u8",  .bits = 8 },

-    [AV_SAMPLE_FMT_S16] = { .name = "s16", .bits = 16 },

-    [AV_SAMPLE_FMT_S32] = { .name = "s32", .bits = 32 },

-    [AV_SAMPLE_FMT_FLT] = { .name = "flt", .bits = 32 },

-    [AV_SAMPLE_FMT_DBL] = { .name = "dbl", .bits = 64 },

+    [AV_SAMPLE_FMT_U8]   = { .name =   "u8", .bits =  8, .planar = 0 },

+    [AV_SAMPLE_FMT_S16]  = { .name =  "s16", .bits = 16, .planar = 0 },

+    [AV_SAMPLE_FMT_S32]  = { .name =  "s32", .bits = 32, .planar = 0 },

+    [AV_SAMPLE_FMT_FLT]  = { .name =  "flt", .bits = 32, .planar = 0 },

+    [AV_SAMPLE_FMT_DBL]  = { .name =  "dbl", .bits = 64, .planar = 0 },

+    [AV_SAMPLE_FMT_U8P]  = { .name =  "u8p", .bits =  8, .planar = 1 },

+    [AV_SAMPLE_FMT_S16P] = { .name = "s16p", .bits = 16, .planar = 1 },

+    [AV_SAMPLE_FMT_S32P] = { .name = "s32p", .bits = 32, .planar = 1 },

+    [AV_SAMPLE_FMT_FLTP] = { .name = "fltp", .bits = 32, .planar = 1 },

+    [AV_SAMPLE_FMT_DBLP] = { .name = "dblp", .bits = 64, .planar = 1 },

 };

 const char *av_get_sample_fmt_name(enum AVSampleFormat sample_fmt)

@@ -80,51 +86,74 @@ int av_get_bits_per_sample_fmt(enum AVSampleFormat sample_fmt)

 }

 #endif

-int av_samples_fill_arrays(uint8_t *pointers[8], int linesizes[8],

-                           uint8_t *buf, int nb_channels, int nb_samples,

-                           enum AVSampleFormat sample_fmt, int planar, int align)

+int av_sample_fmt_is_planar(enum AVSampleFormat sample_fmt)

+{

+     if (sample_fmt < 0 || sample_fmt >= AV_SAMPLE_FMT_NB)

+         return 0;

+     return sample_fmt_info[sample_fmt].planar;

+}

+

+int av_samples_get_buffer_size(int *linesize, int nb_channels, int nb_samples,

+                               enum AVSampleFormat sample_fmt, int align)

 {

-    int i, linesize;

+    int line_size;

     int sample_size = av_get_bytes_per_sample(sample_fmt);

+    int planar      = av_sample_fmt_is_planar(sample_fmt);

-    if (nb_channels * (uint64_t)nb_samples * sample_size >= INT_MAX - align*(uint64_t)nb_channels)

+    /* validate parameter ranges */

+    if (!sample_size || nb_samples <= 0 || nb_channels <= 0)

         return AVERROR(EINVAL);

-    linesize = planar ? FFALIGN(nb_samples*sample_size,             align) :

-                        FFALIGN(nb_samples*sample_size*nb_channels, align);

-

-    if (pointers) {

-        pointers[0] = buf;

-        for (i = 1; planar && i < nb_channels; i++) {

-            pointers[i] = pointers[i-1] + linesize;

-        }

-        memset(&pointers[i], 0, (8-i) * sizeof(pointers[0]));

-    }

-    if (linesizes) {

-        linesizes[0] = linesize;

-        for (i = 1; planar && i < nb_channels; i++)

-            linesizes[i] = linesizes[0];

-        memset(&linesizes[i], 0, (8-i) * sizeof(linesizes[0]));

-    }

+    /* check for integer overflow */

+    if (nb_channels > INT_MAX / align ||

+        (int64_t)nb_channels * nb_samples > (INT_MAX - (align * nb_channels)) / sample_size)

+        return AVERROR(EINVAL);

+

+    line_size = planar ? FFALIGN(nb_samples * sample_size,               align) :

+                         FFALIGN(nb_samples * sample_size * nb_channels, align);

+    if (linesize)

+        *linesize = line_size;

-    return planar ? linesize * nb_channels : linesize;

+    return planar ? line_size * nb_channels : line_size;

 }

-int av_samples_alloc(uint8_t *pointers[8], int linesizes[8],

-                     int nb_channels, int nb_samples,

-                     enum AVSampleFormat sample_fmt, int planar,

-                     int align)

+int av_samples_fill_arrays(uint8_t **audio_data, int *linesize,

+                           uint8_t *buf, int nb_channels, int nb_samples,

+                           enum AVSampleFormat sample_fmt, int align)

+{

+    int ch, planar, buf_size;

+

+    planar   = av_sample_fmt_is_planar(sample_fmt);

+    buf_size = av_samples_get_buffer_size(linesize, nb_channels, nb_samples,

+                                          sample_fmt, align);

+    if (buf_size < 0)

+        return buf_size;

+

+    audio_data[0] = buf;

+    for (ch = 1; planar && ch < nb_channels; ch++)

+        audio_data[ch] = audio_data[ch-1] + *linesize;

+

+    return 0;

+}

+

+int av_samples_alloc(uint8_t **audio_data, int *linesize, int nb_channels,

+                     int nb_samples, enum AVSampleFormat sample_fmt, int align)

 {

     uint8_t *buf;

-    int size = av_samples_fill_arrays(NULL, NULL,

-                                      NULL, nb_channels, nb_samples,

-                                      sample_fmt, planar, align);

+    int size = av_samples_get_buffer_size(NULL, nb_channels, nb_samples,

+                                          sample_fmt, align);

+    if (size < 0)

+        return size;

     buf = av_mallocz(size);

     if (!buf)

         return AVERROR(ENOMEM);

-    return av_samples_fill_arrays(pointers, linesizes,

-                                  buf, nb_channels, nb_samples,

-                                  sample_fmt, planar, align);

+    size = av_samples_fill_arrays(audio_data, linesize, buf, nb_channels,

+                                  nb_samples, sample_fmt, align);

+    if (size < 0) {

+        av_free(buf);

+        return size;

+    }

+    return 0;

 }

@@ -31,6 +31,13 @@ enum AVSampleFormat {

     AV_SAMPLE_FMT_S32,         ///< signed 32 bits

     AV_SAMPLE_FMT_FLT,         ///< float

     AV_SAMPLE_FMT_DBL,         ///< double

+

+    AV_SAMPLE_FMT_U8P,         ///< unsigned 8 bits, planar

+    AV_SAMPLE_FMT_S16P,        ///< signed 16 bits, planar

+    AV_SAMPLE_FMT_S32P,        ///< signed 32 bits, planar

+    AV_SAMPLE_FMT_FLTP,        ///< float, planar

+    AV_SAMPLE_FMT_DBLP,        ///< double, planar

+

     AV_SAMPLE_FMT_NB           ///< Number of sample formats. DO NOT USE if linking dynamically

 };

@@ -78,48 +85,64 @@ int av_get_bits_per_sample_fmt(enum AVSampleFormat sample_fmt);

 int av_get_bytes_per_sample(enum AVSampleFormat sample_fmt);

 /**

- * Fill channel data pointers and linesizes for samples with sample

+ * Check if the sample format is planar.

+ *

+ * @param sample_fmt the sample format to inspect

+ * @return 1 if the sample format is planar, 0 if it is interleaved

+ */

+int av_sample_fmt_is_planar(enum AVSampleFormat sample_fmt);

+

+/**

+ * Get the required buffer size for the given audio parameters.

+ *

+ * @param[out] linesize calculated linesize, may be NULL

+ * @param nb_channels   the number of channels

+ * @param nb_samples    the number of samples in a single channel

+ * @param sample_fmt    the sample format

+ * @return              required buffer size, or negative error code on failure

+ */

+int av_samples_get_buffer_size(int *linesize, int nb_channels, int nb_samples,

+                               enum AVSampleFormat sample_fmt, int align);

+

+/**

+ * Fill channel data pointers and linesize for samples with sample

  * format sample_fmt.

  *

  * The pointers array is filled with the pointers to the samples data:

- * for planar, set the start point of each plane's data within the buffer,

+ * for planar, set the start point of each channel's data within the buffer,

  * for packed, set the start point of the entire buffer only.

  *

- * The linesize array is filled with the aligned size of each samples

- * plane, that is linesize[i] will contain the linesize of the plane i,

- * and will be zero for all the unused planes. All linesize values are

- * equal.

+ * The linesize array is filled with the aligned size of each channel's data

+ * buffer for planar layout, or the aligned size of the buffer for all channels

+ * for packed layout.

  *

- * @param pointers array to be filled with the pointer for each plane, may be NULL

- * @param linesizes array to be filled with the linesize, may be NULL

- * @param buf the pointer to a buffer containing the samples

- * @param nb_samples the number of samples in a single channel

- * @param planar 1 if the samples layout is planar, 0 if it is packed

- * @param nb_channels the number of channels

- * @return the total size of the buffer, a negative

- * error code in case of failure

+ * @param[out] audio_data  array to be filled with the pointer for each channel

+ * @param[out] linesize    calculated linesize

+ * @param buf              the pointer to a buffer containing the samples

+ * @param nb_channels      the number of channels

+ * @param nb_samples       the number of samples in a single channel

+ * @param sample_fmt       the sample format

+ * @param align            buffer size alignment (1 = no alignment required)

+ * @return                 0 on success or a negative error code on failure

  */

-int av_samples_fill_arrays(uint8_t *pointers[8], int linesizes[8],

-                           uint8_t *buf, int nb_channels, int nb_samples,

-                           enum AVSampleFormat sample_fmt, int planar, int align);

+int av_samples_fill_arrays(uint8_t **audio_data, int *linesize, uint8_t *buf,

+                           int nb_channels, int nb_samples,

+                           enum AVSampleFormat sample_fmt, int align);

 /**

- * Allocate a samples buffer for nb_samples samples, and

- * fill pointers and linesizes accordingly.

- * The allocated samples buffer has to be freed by using

- * av_freep(&pointers[0]).

+ * Allocate a samples buffer for nb_samples samples, and fill data pointers and

+ * linesize accordingly.

+ * The allocated samples buffer can be freed by using av_freep(&audio_data[0])

  *

- * @param nb_channels number of audio channels

- * @param nb_samples number of samples per channel

- * @param planar 1 if the samples layout is planar, 0 if packed,

- * @param align the value to use for buffer size alignment

- * @return the size in bytes required for the samples buffer, a negative

- * error code in case of failure

+ * @param[out] audio_data  array to be filled with the pointer for each channel

+ * @param[out] linesize    aligned size for audio buffer(s)

+ * @param nb_channels      number of audio channels

+ * @param nb_samples       number of samples per channel

+ * @param align            buffer size alignment (1 = no alignment required)

+ * @return                 0 on success or a negative error code on failure

  * @see av_samples_fill_arrays()

  */

-int av_samples_alloc(uint8_t *pointers[8], int linesizes[8],

-                     int nb_channels, int nb_samples,

-                     enum AVSampleFormat sample_fmt, int planar,

-                     int align);

+int av_samples_alloc(uint8_t **audio_data, int *linesize, int nb_channels,

+                     int nb_samples, enum AVSampleFormat sample_fmt, int align);

-#endif /* AVCORE_SAMPLEFMT_H */

+#endif /* AVUTIL_SAMPLEFMT_H */

@@ -201,7 +201,7 @@ fate-nc-demux: CMD = framecrc  -i $(SAMPLES)/nc-camera/nc-sample-partial -vcodec

 FATE_TESTS += fate-nsv-demux