@@ -327,7 +327,7 @@ OBJS-$(CONFIG_MSMPEG4V3_ENCODER)       += msmpeg4.o msmpeg4enc.o msmpeg4data.o \

                                           h263dec.o h263.o ituh263dec.o        \

                                           mpeg4videodec.o

 OBJS-$(CONFIG_MSRLE_DECODER)           += msrle.o msrledec.o

-OBJS-$(CONFIG_MSA1_DECODER)            += mss3.o

+OBJS-$(CONFIG_MSA1_DECODER)            += mss3.o mss34dsp.o

 OBJS-$(CONFIG_MSS1_DECODER)            += mss1.o

 OBJS-$(CONFIG_MSVIDEO1_DECODER)        += msvideo1.o

 OBJS-$(CONFIG_MSVIDEO1_ENCODER)        += msvideo1enc.o elbg.o

@@ -175,10 +175,10 @@ static int X264_frame(AVCodecContext *ctx, AVPacket *pkt, const AVFrame *frame,

             x4->params.b_tff = frame->top_field_first;

             x264_encoder_reconfig(x4->enc, &x4->params);

         }

-        if (x4->params.vui.i_sar_height != ctx->sample_aspect_ratio.den

-         || x4->params.vui.i_sar_width != ctx->sample_aspect_ratio.num) {

+        if (x4->params.vui.i_sar_height != ctx->sample_aspect_ratio.den ||

+            x4->params.vui.i_sar_width  != ctx->sample_aspect_ratio.num) {

             x4->params.vui.i_sar_height = ctx->sample_aspect_ratio.den;

-            x4->params.vui.i_sar_width = ctx->sample_aspect_ratio.num;

+            x4->params.vui.i_sar_width  = ctx->sample_aspect_ratio.num;

             x264_encoder_reconfig(x4->enc, &x4->params);

         }

     }

@@ -119,15 +119,9 @@ int main(int argc, char **argv)

     int flags[2] = { AV_CPU_FLAG_MMX, AV_CPU_FLAG_MMX2 };

     int flags_size = HAVE_MMX2 ? 2 : 1;

-    for(;;) {

-        c = getopt(argc, argv, "h");

-        if (c == -1)

-            break;

-        switch(c) {

-        case 'h':

-            help();

-            return 1;

-        }

+    if (argc > 1) {

+        help();

+        return 1;

     }

     printf("ffmpeg motion test\n");

@@ -26,6 +26,8 @@

 #include "avcodec.h"

 #include "bytestream.h"

+#include "dsputil.h"

+#include "mss34dsp.h"

 #define HEADER_SIZE 27

@@ -119,39 +121,6 @@ typedef struct MSS3Context {

     int              hblock[16 * 16];

 } MSS3Context;

-static const uint8_t mss3_luma_quant[64] = {

-    16,  11,  10,  16,  24,  40,  51,  61,

-    12,  12,  14,  19,  26,  58,  60,  55,

-    14,  13,  16,  24,  40,  57,  69,  56,

-    14,  17,  22,  29,  51,  87,  80,  62,

-    18,  22,  37,  56,  68, 109, 103,  77,

-    24,  35,  55,  64,  81, 104, 113,  92,

-    49,  64,  78,  87, 103, 121, 120, 101,

-    72,  92,  95,  98, 112, 100, 103,  99

-};

-

-static const uint8_t mss3_chroma_quant[64] = {

-    17, 18, 24, 47, 99, 99, 99, 99,

-    18, 21, 26, 66, 99, 99, 99, 99,

-    24, 26, 56, 99, 99, 99, 99, 99,

-    47, 66, 99, 99, 99, 99, 99, 99,

-    99, 99, 99, 99, 99, 99, 99, 99,

-    99, 99, 99, 99, 99, 99, 99, 99,

-    99, 99, 99, 99, 99, 99, 99, 99,

-    99, 99, 99, 99, 99, 99, 99, 99

-};

-

-static const uint8_t zigzag_scan[64] = {

-    0,   1,  8, 16,  9,  2,  3, 10,

-    17, 24, 32, 25, 18, 11,  4,  5,

-    12, 19, 26, 33, 40, 48, 41, 34,

-    27, 20, 13,  6,  7, 14, 21, 28,

-    35, 42, 49, 56, 57, 50, 43, 36,

-    29, 22, 15, 23, 30, 37, 44, 51,

-    58, 59, 52, 45, 38, 31, 39, 46,

-    53, 60, 61, 54, 47, 55, 62, 63

-};

-

 static void model2_reset(Model2 *m)

 {

@@ -578,7 +547,7 @@ static int decode_dct(RangeCoder *c, DCTBlockCoder *bc, int *block,

         if (!sign)

             val = -val;

-        zz_pos = zigzag_scan[pos];

+        zz_pos = ff_zigzag_direct[pos];

         block[zz_pos] = val * bc->qmat[zz_pos];

         pos++;

     }

@@ -586,58 +555,6 @@ static int decode_dct(RangeCoder *c, DCTBlockCoder *bc, int *block,

     return pos == 64 ? 0 : -1;

 }

-#define DCT_TEMPLATE(blk, step, SOP, shift)                         \

-    const int t0 = -39409 * blk[7 * step] -  58980 * blk[1 * step]; \

-    const int t1 =  39410 * blk[1 * step] -  58980 * blk[7 * step]; \

-    const int t2 = -33410 * blk[5 * step] - 167963 * blk[3 * step]; \

-    const int t3 =  33410 * blk[3 * step] - 167963 * blk[5 * step]; \

-    const int t4 =          blk[3 * step] +          blk[7 * step]; \

-    const int t5 =          blk[1 * step] +          blk[5 * step]; \

-    const int t6 =  77062 * t4            +  51491 * t5;            \

-    const int t7 =  77062 * t5            -  51491 * t4;            \

-    const int t8 =  35470 * blk[2 * step] -  85623 * blk[6 * step]; \

-    const int t9 =  35470 * blk[6 * step] +  85623 * blk[2 * step]; \

-    const int tA = SOP(blk[0 * step] - blk[4 * step]);              \

-    const int tB = SOP(blk[0 * step] + blk[4 * step]);              \

-                                                                    \

-    blk[0 * step] = (  t1 + t6  + t9 + tB) >> shift;                \

-    blk[1 * step] = (  t3 + t7  + t8 + tA) >> shift;                \

-    blk[2 * step] = (  t2 + t6  - t8 + tA) >> shift;                \

-    blk[3 * step] = (  t0 + t7  - t9 + tB) >> shift;                \

-    blk[4 * step] = (-(t0 + t7) - t9 + tB) >> shift;                \

-    blk[5 * step] = (-(t2 + t6) - t8 + tA) >> shift;                \

-    blk[6 * step] = (-(t3 + t7) + t8 + tA) >> shift;                \

-    blk[7 * step] = (-(t1 + t6) + t9 + tB) >> shift;                \

-

-#define SOP_ROW(a) ((a) << 16) + 0x2000

-#define SOP_COL(a) ((a + 32) << 16)

-

-static void dct_put(uint8_t *dst, int stride, int *block)

-{

-    int i, j;

-    int *ptr;

-

-    ptr = block;

-    for (i = 0; i < 8; i++) {

-        DCT_TEMPLATE(ptr, 1, SOP_ROW, 13);

-        ptr += 8;

-    }

-

-    ptr = block;

-    for (i = 0; i < 8; i++) {

-        DCT_TEMPLATE(ptr, 8, SOP_COL, 22);

-        ptr++;

-    }

-

-    ptr = block;

-    for (j = 0; j < 8; j++) {

-        for (i = 0; i < 8; i++)

-            dst[i] = av_clip_uint8(ptr[i] + 128);

-        dst += stride;

-        ptr += 8;

-    }

-}

-

 static void decode_dct_block(RangeCoder *c, DCTBlockCoder *bc,

                              uint8_t *dst, int stride, int block_size,

                              int *block, int mb_x, int mb_y)

@@ -655,7 +572,7 @@ static void decode_dct_block(RangeCoder *c, DCTBlockCoder *bc,

                 c->got_error = 1;

                 return;

             }

-            dct_put(dst + i * 8, stride, block);

+            ff_mss34_dct_put(dst + i * 8, stride, block);

         }

         dst += 8 * stride;

     }

@@ -702,14 +619,6 @@ static void decode_haar_block(RangeCoder *c, HaarBlockCoder *hc,

     }

 }

-static void gen_quant_mat(uint16_t *qmat, const uint8_t *ref, float scale)

-{

-    int i;

-

-    for (i = 0; i < 64; i++)

-        qmat[i] = (uint16_t)(ref[i] * scale + 50.0) / 100;

-}

-

 static void reset_coders(MSS3Context *ctx, int quality)

 {

     int i, j;

@@ -726,15 +635,8 @@ static void reset_coders(MSS3Context *ctx, int quality)

         for (j = 0; j < 125; j++)

             model_reset(&ctx->image_coder[i].vq_model[j]);

         if (ctx->dct_coder[i].quality != quality) {

-            float scale;

             ctx->dct_coder[i].quality = quality;

-            if (quality > 50)

-                scale = 200.0f - 2 * quality;

-            else

-                scale = 5000.0f / quality;

-            gen_quant_mat(ctx->dct_coder[i].qmat,

-                          i ? mss3_chroma_quant : mss3_luma_quant,

-                          scale);

+            ff_mss34_gen_quant_mat(ctx->dct_coder[i].qmat, quality, !i);

         }

         memset(ctx->dct_coder[i].prev_dc, 0,

                sizeof(*ctx->dct_coder[i].prev_dc) *

new file mode 100644

@@ -0,0 +1,114 @@

+/*

+ * Common stuff for some Microsoft Screen codecs

+ * Copyright (C) 2012 Konstantin Shishkov

+ *

+ * This file is part of FFmpeg.

+ *

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

+ * modify it under the terms of the GNU Lesser General Public

+ * License as published by the Free Software Foundation; either

+ * version 2.1 of the License, or (at your option) any later version.

+ *

+ * FFmpeg is distributed in the hope that it will be useful,

+ * but WITHOUT ANY WARRANTY; without even the implied warranty of

+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

+ * Lesser General Public License for more details.

+ *

+ * You should have received a copy of the GNU Lesser General Public

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

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

+ */

+

+#include <stdint.h>

+#include "libavutil/common.h"

+#include "mss34dsp.h"

+

+static const uint8_t luma_quant[64] = {

+    16,  11,  10,  16,  24,  40,  51,  61,

+    12,  12,  14,  19,  26,  58,  60,  55,

+    14,  13,  16,  24,  40,  57,  69,  56,

+    14,  17,  22,  29,  51,  87,  80,  62,

+    18,  22,  37,  56,  68, 109, 103,  77,

+    24,  35,  55,  64,  81, 104, 113,  92,

+    49,  64,  78,  87, 103, 121, 120, 101,

+    72,  92,  95,  98, 112, 100, 103,  99

+};

+

+static const uint8_t chroma_quant[64] = {

+    17, 18, 24, 47, 99, 99, 99, 99,

+    18, 21, 26, 66, 99, 99, 99, 99,

+    24, 26, 56, 99, 99, 99, 99, 99,

+    47, 66, 99, 99, 99, 99, 99, 99,

+    99, 99, 99, 99, 99, 99, 99, 99,

+    99, 99, 99, 99, 99, 99, 99, 99,

+    99, 99, 99, 99, 99, 99, 99, 99,

+    99, 99, 99, 99, 99, 99, 99, 99

+};

+

+void ff_mss34_gen_quant_mat(uint16_t *qmat, int quality, int luma)

+{

+    int i;

+    const uint8_t *qsrc = luma ? luma_quant : chroma_quant;

+

+    if (quality >= 50) {

+        int scale = 200 - 2 * quality;

+

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

+            qmat[i] = (qsrc[i] * scale + 50) / 100;

+    } else {

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

+            qmat[i] = (5000 * qsrc[i] / quality + 50) / 100;

+    }

+}

+

+#define DCT_TEMPLATE(blk, step, SOP, shift)                         \

+    const int t0 = -39409 * blk[7 * step] -  58980 * blk[1 * step]; \

+    const int t1 =  39410 * blk[1 * step] -  58980 * blk[7 * step]; \

+    const int t2 = -33410 * blk[5 * step] - 167963 * blk[3 * step]; \

+    const int t3 =  33410 * blk[3 * step] - 167963 * blk[5 * step]; \

+    const int t4 =          blk[3 * step] +          blk[7 * step]; \

+    const int t5 =          blk[1 * step] +          blk[5 * step]; \

+    const int t6 =  77062 * t4            +  51491 * t5;            \

+    const int t7 =  77062 * t5            -  51491 * t4;            \

+    const int t8 =  35470 * blk[2 * step] -  85623 * blk[6 * step]; \

+    const int t9 =  35470 * blk[6 * step] +  85623 * blk[2 * step]; \

+    const int tA = SOP(blk[0 * step] - blk[4 * step]);              \

+    const int tB = SOP(blk[0 * step] + blk[4 * step]);              \

+                                                                    \

+    blk[0 * step] = (  t1 + t6  + t9 + tB) >> shift;                \

+    blk[1 * step] = (  t3 + t7  + t8 + tA) >> shift;                \

+    blk[2 * step] = (  t2 + t6  - t8 + tA) >> shift;                \

+    blk[3 * step] = (  t0 + t7  - t9 + tB) >> shift;                \

+    blk[4 * step] = (-(t0 + t7) - t9 + tB) >> shift;                \

+    blk[5 * step] = (-(t2 + t6) - t8 + tA) >> shift;                \

+    blk[6 * step] = (-(t3 + t7) + t8 + tA) >> shift;                \

+    blk[7 * step] = (-(t1 + t6) + t9 + tB) >> shift;                \

+

+#define SOP_ROW(a) ((a) << 16) + 0x2000

+#define SOP_COL(a) ((a + 32) << 16)

+

+void ff_mss34_dct_put(uint8_t *dst, int stride, int *block)

+{

+    int i, j;

+    int *ptr;

+

+    ptr = block;

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

+        DCT_TEMPLATE(ptr, 1, SOP_ROW, 13);

+        ptr += 8;

+    }

+

+    ptr = block;

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

+        DCT_TEMPLATE(ptr, 8, SOP_COL, 22);

+        ptr++;

+    }

+

+    ptr = block;

+    for (j = 0; j < 8; j++) {

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

+            dst[i] = av_clip_uint8(ptr[i] + 128);

+        dst += stride;

+        ptr += 8;

+    }

+}

new file mode 100644

@@ -0,0 +1,45 @@

+/*

+ * Common stuff for some Microsoft Screen codecs

+ * Copyright (C) 2012 Konstantin Shishkov

+ *

+ * This file is part of FFmpeg.

+ *

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

+ * modify it under the terms of the GNU Lesser General Public

+ * License as published by the Free Software Foundation; either

+ * version 2.1 of the License, or (at your option) any later version.

+ *

+ * FFmpeg is distributed in the hope that it will be useful,

+ * but WITHOUT ANY WARRANTY; without even the implied warranty of

+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

+ * Lesser General Public License for more details.

+ *

+ * You should have received a copy of the GNU Lesser General Public

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

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

+ */

+

+#ifndef AVCODEC_MSS34DSP_H

+#define AVCODEC_MSS34DSP_H

+

+#include <stdint.h>

+

+/**

+ * Generate quantisation matrix for given quality.

+ *

+ * @param qmat    destination matrix

+ * @param quality quality setting (1-100)

+ * @param luma    generate quantisation matrix for luma or chroma

+ */

+void ff_mss34_gen_quant_mat(uint16_t *qmat, int quality, int luma);

+

+/**

+ * Transform and output DCT block.

+ *

+ * @param dst     output plane

+ * @param stride  output plane stride

+ * @param block   block to transform and output

+ */

+void ff_mss34_dct_put(uint8_t *dst, int stride, int *block);

+

+#endif /* AVCODEC_MSS34DSP_H */

@@ -135,12 +135,13 @@ static int config_output(AVFilterLink *outlink)

     return 0;

 }

-static void filter_samples(AVFilterLink *inlink, AVFilterBufferRef *insamplesref)

+static int  filter_samples(AVFilterLink *inlink, AVFilterBufferRef *insamplesref)

 {

     AConvertContext *aconvert = inlink->dst->priv;

     const int n = insamplesref->audio->nb_samples;

     AVFilterLink *const outlink = inlink->dst->outputs[0];

     AVFilterBufferRef *outsamplesref = ff_get_audio_buffer(outlink, AV_PERM_WRITE, n);

+    int ret;

     swr_convert(aconvert->swr, outsamplesref->data, n,

                         (void *)insamplesref->data, n);

@@ -148,8 +149,9 @@ static void filter_samples(AVFilterLink *inlink, AVFilterBufferRef *insamplesref

     avfilter_copy_buffer_ref_props(outsamplesref, insamplesref);

     outsamplesref->audio->channel_layout = outlink->channel_layout;

-    ff_filter_samples(outlink, outsamplesref);

+    ret = ff_filter_samples(outlink, outsamplesref);

     avfilter_unref_buffer(insamplesref);

+    return ret;

 }

 AVFilter avfilter_af_aconvert = {

@@ -212,7 +212,7 @@ static inline void copy_samples(int nb_inputs, struct amerge_input in[],

     }

 }

-static void filter_samples(AVFilterLink *inlink, AVFilterBufferRef *insamples)

+static int filter_samples(AVFilterLink *inlink, AVFilterBufferRef *insamples)

 {

     AVFilterContext *ctx = inlink->dst;

     AMergeContext *am = ctx->priv;

@@ -232,7 +232,7 @@ static void filter_samples(AVFilterLink *inlink, AVFilterBufferRef *insamples)

     for (i = 1; i < am->nb_inputs; i++)

         nb_samples = FFMIN(nb_samples, am->in[i].nb_samples);

     if (!nb_samples)

-        return;

+        return 0;

     outbuf = ff_get_audio_buffer(ctx->outputs[0], AV_PERM_WRITE, nb_samples);

     outs = outbuf->data[0];

@@ -285,7 +285,7 @@ static void filter_samples(AVFilterLink *inlink, AVFilterBufferRef *insamples)

             }

         }

     }

-    ff_filter_samples(ctx->outputs[0], outbuf);

+    return ff_filter_samples(ctx->outputs[0], outbuf);

 }

 static av_cold int init(AVFilterContext *ctx, const char *args)

@@ -305,9 +305,7 @@ static int output_frame(AVFilterLink *outlink, int nb_samples)

     if (s->next_pts != AV_NOPTS_VALUE)

         s->next_pts += nb_samples;

-    ff_filter_samples(outlink, out_buf);

-

-    return 0;

+    return ff_filter_samples(outlink, out_buf);

 }

 /**

@@ -448,31 +446,37 @@ static int request_frame(AVFilterLink *outlink)

     return output_frame(outlink, available_samples);

 }

-static void filter_samples(AVFilterLink *inlink, AVFilterBufferRef *buf)

+static int filter_samples(AVFilterLink *inlink, AVFilterBufferRef *buf)

 {

     AVFilterContext  *ctx = inlink->dst;

     MixContext       *s = ctx->priv;

     AVFilterLink *outlink = ctx->outputs[0];

-    int i;

+    int i, ret = 0;

     for (i = 0; i < ctx->nb_inputs; i++)

         if (ctx->inputs[i] == inlink)

             break;

     if (i >= ctx->nb_inputs) {

         av_log(ctx, AV_LOG_ERROR, "unknown input link\n");

-        return;

+        ret = AVERROR(EINVAL);

+        goto fail;

     }

     if (i == 0) {

         int64_t pts = av_rescale_q(buf->pts, inlink->time_base,

                                    outlink->time_base);

-        frame_list_add_frame(s->frame_list, buf->audio->nb_samples, pts);

+        ret = frame_list_add_frame(s->frame_list, buf->audio->nb_samples, pts);

+        if (ret < 0)

+            goto fail;

     }

-    av_audio_fifo_write(s->fifos[i], (void **)buf->extended_data,

-                        buf->audio->nb_samples);

+    ret = av_audio_fifo_write(s->fifos[i], (void **)buf->extended_data,

+                              buf->audio->nb_samples);

+fail:

     avfilter_unref_buffer(buf);

+

+    return ret;

 }

 static int init(AVFilterContext *ctx, const char *args)

@@ -168,13 +168,14 @@ static int config_output(AVFilterLink *outlink)

     return 0;

 }

-static void filter_samples(AVFilterLink *inlink, AVFilterBufferRef *insamplesref)

+static int filter_samples(AVFilterLink *inlink, AVFilterBufferRef *insamplesref)

 {

     AResampleContext *aresample = inlink->dst->priv;

     const int n_in  = insamplesref->audio->nb_samples;

     int n_out       = n_in * aresample->ratio * 2 ;

     AVFilterLink *const outlink = inlink->dst->outputs[0];

     AVFilterBufferRef *outsamplesref = ff_get_audio_buffer(outlink, AV_PERM_WRITE, n_out);

+    int ret;

     avfilter_copy_buffer_ref_props(outsamplesref, insamplesref);

@@ -193,15 +194,16 @@ static void filter_samples(AVFilterLink *inlink, AVFilterBufferRef *insamplesref

     if (n_out <= 0) {

         avfilter_unref_buffer(outsamplesref);

         avfilter_unref_buffer(insamplesref);

-        return;

+        return 0;

     }

     outsamplesref->audio->sample_rate = outlink->sample_rate;

     outsamplesref->audio->nb_samples  = n_out;

-    ff_filter_samples(outlink, outsamplesref);

+    ret = ff_filter_samples(outlink, outsamplesref);

     aresample->req_fullfilled= 1;

     avfilter_unref_buffer(insamplesref);

+    return ret;

 }

 static int request_frame(AVFilterLink *outlink)

@@ -131,7 +131,7 @@ static int push_samples(AVFilterLink *outlink)

     return nb_out_samples;

 }

-static void filter_samples(AVFilterLink *inlink, AVFilterBufferRef *insamples)

+static int filter_samples(AVFilterLink *inlink, AVFilterBufferRef *insamples)

 {

     AVFilterContext *ctx = inlink->dst;

     ASNSContext *asns = ctx->priv;

@@ -145,7 +145,7 @@ static void filter_samples(AVFilterLink *inlink, AVFilterBufferRef *insamples)

         if (ret < 0) {

             av_log(ctx, AV_LOG_ERROR,

                    "Stretching audio fifo failed, discarded %d samples\n", nb_samples);

-            return;

+            return -1;

         }

     }

     av_audio_fifo_write(asns->fifo, (void **)insamples->extended_data, nb_samples);

@@ -155,6 +155,7 @@ static void filter_samples(AVFilterLink *inlink, AVFilterBufferRef *insamples)

     if (av_audio_fifo_size(asns->fifo) >= asns->nb_out_samples)

         push_samples(outlink);

+    return 0;

 }

 static int request_frame(AVFilterLink *outlink)

@@ -40,7 +40,7 @@ static av_cold int init(AVFilterContext *ctx, const char *args)

     return 0;

 }

-static void filter_samples(AVFilterLink *inlink, AVFilterBufferRef *samplesref)

+static int filter_samples(AVFilterLink *inlink, AVFilterBufferRef *samplesref)

 {

     AVFilterContext *ctx = inlink->dst;

     ShowInfoContext *showinfo = ctx->priv;

@@ -83,7 +83,7 @@ static void filter_samples(AVFilterLink *inlink, AVFilterBufferRef *samplesref)

     av_log(ctx, AV_LOG_INFO, "]\n");

     showinfo->frame++;

-    ff_filter_samples(inlink->dst->outputs[0], samplesref);

+    return ff_filter_samples(inlink->dst->outputs[0], samplesref);

 }

 AVFilter avfilter_af_ashowinfo = {

@@ -107,11 +107,12 @@ static int config_output(AVFilterLink *outlink)

     return 0;

 }

-static void send_out(AVFilterContext *ctx, int out_id)

+static int send_out(AVFilterContext *ctx, int out_id)

 {

     AStreamSyncContext *as = ctx->priv;

     struct buf_queue *queue = &as->queue[out_id];

     AVFilterBufferRef *buf = queue->buf[queue->tail];

+    int ret;

     queue->buf[queue->tail] = NULL;

     as->var_values[VAR_B1 + out_id]++;

@@ -121,11 +122,12 @@ static void send_out(AVFilterContext *ctx, int out_id)

             av_q2d(ctx->outputs[out_id]->time_base) * buf->pts;

     as->var_values[VAR_T1 + out_id] += buf->audio->nb_samples /

                                    (double)ctx->inputs[out_id]->sample_rate;

-    ff_filter_samples(ctx->outputs[out_id], buf);

+    ret = ff_filter_samples(ctx->outputs[out_id], buf);

     queue->nb--;

     queue->tail = (queue->tail + 1) % QUEUE_SIZE;

     if (as->req[out_id])

         as->req[out_id]--;

+    return ret;

 }

 static void send_next(AVFilterContext *ctx)

@@ -165,7 +167,7 @@ static int request_frame(AVFilterLink *outlink)

     return 0;

 }

-static void filter_samples(AVFilterLink *inlink, AVFilterBufferRef *insamples)

+static int filter_samples(AVFilterLink *inlink, AVFilterBufferRef *insamples)

 {

     AVFilterContext *ctx = inlink->dst;

     AStreamSyncContext *as = ctx->priv;

@@ -175,6 +177,7 @@ static void filter_samples(AVFilterLink *inlink, AVFilterBufferRef *insamples)

         insamples;

     as->eof &= ~(1 << id);

     send_next(ctx);

+    return 0;

 }

 AVFilter avfilter_af_astreamsync = {

@@ -37,6 +37,9 @@ typedef struct ASyncContext {

     int resample;

     float min_delta_sec;

     int max_comp;

+

+    /* set by filter_samples() to signal an output frame to request_frame() */

+    int got_output;

 } ASyncContext;

 #define OFFSET(x) offsetof(ASyncContext, x)

@@ -112,9 +115,13 @@ static int request_frame(AVFilterLink *link)

 {

     AVFilterContext *ctx = link->src;

     ASyncContext      *s = ctx->priv;

-    int ret = ff_request_frame(ctx->inputs[0]);

+    int ret = 0;

     int nb_samples;

+    s->got_output = 0;

+    while (ret >= 0 && !s->got_output)

+        ret = ff_request_frame(ctx->inputs[0]);

+

     /* flush the fifo */

     if (ret == AVERROR_EOF && (nb_samples = avresample_get_delay(s->avr))) {

         AVFilterBufferRef *buf = ff_get_audio_buffer(link, AV_PERM_WRITE,

@@ -124,18 +131,18 @@ static int request_frame(AVFilterLink *link)

         avresample_convert(s->avr, (void**)buf->extended_data, buf->linesize[0],

                            nb_samples, NULL, 0, 0);

         buf->pts = s->pts;

-        ff_filter_samples(link, buf);

-        return 0;

+        return ff_filter_samples(link, buf);

     }

     return ret;

 }

-static void write_to_fifo(ASyncContext *s, AVFilterBufferRef *buf)

+static int write_to_fifo(ASyncContext *s, AVFilterBufferRef *buf)

 {

-    avresample_convert(s->avr, NULL, 0, 0, (void**)buf->extended_data,

-                       buf->linesize[0], buf->audio->nb_samples);

+    int ret = avresample_convert(s->avr, NULL, 0, 0, (void**)buf->extended_data,

+                                 buf->linesize[0], buf->audio->nb_samples);

     avfilter_unref_buffer(buf);

+    return ret;

 }

 /* get amount of data currently buffered, in samples */

@@ -144,7 +151,7 @@ static int64_t get_delay(ASyncContext *s)

     return avresample_available(s->avr) + avresample_get_delay(s->avr);

 }

-static void filter_samples(AVFilterLink *inlink, AVFilterBufferRef *buf)

+static int filter_samples(AVFilterLink *inlink, AVFilterBufferRef *buf)

 {

     AVFilterContext  *ctx = inlink->dst;

     ASyncContext       *s = ctx->priv;

@@ -152,7 +159,7 @@ static void filter_samples(AVFilterLink *inlink, AVFilterBufferRef *buf)

     int nb_channels = av_get_channel_layout_nb_channels(buf->audio->channel_layout);

     int64_t pts = (buf->pts == AV_NOPTS_VALUE) ? buf->pts :

                   av_rescale_q(buf->pts, inlink->time_base, outlink->time_base);

-    int out_size;

+    int out_size, ret;

     int64_t delta;

     /* buffer data until we get the first timestamp */

@@ -160,14 +167,12 @@ static void filter_samples(AVFilterLink *inlink, AVFilterBufferRef *buf)

         if (pts != AV_NOPTS_VALUE) {

             s->pts = pts - get_delay(s);

         }

-        write_to_fifo(s, buf);

-        return;

+        return write_to_fifo(s, buf);

     }

     /* now wait for the next timestamp */

     if (pts == AV_NOPTS_VALUE) {

-        write_to_fifo(s, buf);

-        return;

+        return write_to_fifo(s, buf);

     }

     /* when we have two timestamps, compute how many samples would we have

@@ -190,8 +195,10 @@ static void filter_samples(AVFilterLink *inlink, AVFilterBufferRef *buf)

     if (out_size > 0) {

         AVFilterBufferRef *buf_out = ff_get_audio_buffer(outlink, AV_PERM_WRITE,

                                                          out_size);

-        if (!buf_out)

-            return;

+        if (!buf_out) {

+            ret = AVERROR(ENOMEM);

+            goto fail;

+        }

         avresample_read(s->avr, (void**)buf_out->extended_data, out_size);

         buf_out->pts = s->pts;

@@ -200,7 +207,10 @@ static void filter_samples(AVFilterLink *inlink, AVFilterBufferRef *buf)

             av_samples_set_silence(buf_out->extended_data, out_size - delta,

                                    delta, nb_channels, buf->format);

         }

-        ff_filter_samples(outlink, buf_out);

+        ret = ff_filter_samples(outlink, buf_out);

+        if (ret < 0)

+            goto fail;

+        s->got_output = 1;

     } else {

         av_log(ctx, AV_LOG_WARNING, "Non-monotonous timestamps, dropping "

                "whole buffer.\n");

@@ -210,9 +220,13 @@ static void filter_samples(AVFilterLink *inlink, AVFilterBufferRef *buf)

     avresample_read(s->avr, NULL, avresample_available(s->avr));

     s->pts = pts - avresample_get_delay(s->avr);

-    avresample_convert(s->avr, NULL, 0, 0, (void**)buf->extended_data,

-                       buf->linesize[0], buf->audio->nb_samples);

+    ret = avresample_convert(s->avr, NULL, 0, 0, (void**)buf->extended_data,

+                             buf->linesize[0], buf->audio->nb_samples);

+

+fail:

     avfilter_unref_buffer(buf);

+

+    return ret;

 }

 AVFilter avfilter_af_asyncts = {

@@ -1040,7 +1040,7 @@ static void push_samples(ATempoContext *atempo,

     atempo->nsamples_out += n_out;

 }

-static void filter_samples(AVFilterLink *inlink,

+static int filter_samples(AVFilterLink *inlink,

                            AVFilterBufferRef *src_buffer)

 {

     AVFilterContext  *ctx = inlink->dst;

@@ -1074,6 +1074,7 @@ static void filter_samples(AVFilterLink *inlink,

     atempo->nsamples_in += n_in;

     avfilter_unref_bufferp(&src_buffer);

+    return 0;

 }

 static int request_frame(AVFilterLink *outlink)

@@ -313,7 +313,7 @@ static int channelmap_query_formats(AVFilterContext *ctx)

     return 0;

 }

-static void channelmap_filter_samples(AVFilterLink *inlink, AVFilterBufferRef *buf)

+static int channelmap_filter_samples(AVFilterLink *inlink, AVFilterBufferRef *buf)

 {

     AVFilterContext  *ctx = inlink->dst;

     AVFilterLink *outlink = ctx->outputs[0];

@@ -330,8 +330,10 @@ static void channelmap_filter_samples(AVFilterLink *inlink, AVFilterBufferRef *b

         if (nch_out > FF_ARRAY_ELEMS(buf->data)) {

             uint8_t **new_extended_data =

                 av_mallocz(nch_out * sizeof(*buf->extended_data));

-            if (!new_extended_data)

-                return;

+            if (!new_extended_data) {

+                avfilter_unref_buffer(buf);

+                return AVERROR(ENOMEM);

+            }

             if (buf->extended_data == buf->data) {

                 buf->extended_data = new_extended_data;

             } else {

@@ -353,7 +355,7 @@ static void channelmap_filter_samples(AVFilterLink *inlink, AVFilterBufferRef *b

         memcpy(buf->data, buf->extended_data,

            FFMIN(FF_ARRAY_ELEMS(buf->data), nch_out) * sizeof(buf->data[0]));

-    ff_filter_samples(outlink, buf);

+    return ff_filter_samples(outlink, buf);

 }

 static int channelmap_config_input(AVFilterLink *inlink)

@@ -105,24 +105,29 @@ static int query_formats(AVFilterContext *ctx)

     return 0;

 }

-static void filter_samples(AVFilterLink *inlink, AVFilterBufferRef *buf)

+static int filter_samples(AVFilterLink *inlink, AVFilterBufferRef *buf)

 {

     AVFilterContext *ctx = inlink->dst;

-    int i;

+    int i, ret = 0;

     for (i = 0; i < ctx->nb_outputs; i++) {

         AVFilterBufferRef *buf_out = avfilter_ref_buffer(buf, ~AV_PERM_WRITE);

-        if (!buf_out)

-            return;

+        if (!buf_out) {

+            ret = AVERROR(ENOMEM);

+            break;

+        }

         buf_out->data[0] = buf_out->extended_data[0] = buf_out->extended_data[i];

         buf_out->audio->channel_layout =

             av_channel_layout_extract_channel(buf->audio->channel_layout, i);

-        ff_filter_samples(ctx->outputs[i], buf_out);

+        ret = ff_filter_samples(ctx->outputs[i], buf_out);

+        if (ret < 0)

+            break;

     }

     avfilter_unref_buffer(buf);

+    return ret;

 }

 AVFilter avfilter_af_channelsplit = {

@@ -120,13 +120,15 @@ static inline int16_t *scalarproduct(const int16_t *in, const int16_t *endin, in

     return out;

 }

-static void filter_samples(AVFilterLink *inlink, AVFilterBufferRef *insamples)

+static int filter_samples(AVFilterLink *inlink, AVFilterBufferRef *insamples)

 {

     AVFilterLink *outlink = inlink->dst->outputs[0];

     int16_t *taps, *endin, *in, *out;

     AVFilterBufferRef *outsamples =

         ff_get_audio_buffer(inlink, AV_PERM_WRITE,

                                   insamples->audio->nb_samples);

+    int ret;

+

     avfilter_copy_buffer_ref_props(outsamples, insamples);

     taps  = ((EarwaxContext *)inlink->dst->priv)->taps;

@@ -144,8 +146,9 @@ static void filter_samples(AVFilterLink *inlink, AVFilterBufferRef *insamples)

     // save part of input for next round

     memcpy(taps, endin, NUMTAPS * sizeof(*taps));

-    ff_filter_samples(outlink, outsamples);

+    ret = ff_filter_samples(outlink, outsamples);

     avfilter_unref_buffer(insamples);

+    return ret;

 }

 AVFilter avfilter_af_earwax = {

@@ -92,7 +92,7 @@ static const AVClass join_class = {

     .version    = LIBAVUTIL_VERSION_INT,

 };

-static void filter_samples(AVFilterLink *link, AVFilterBufferRef *buf)

+static int filter_samples(AVFilterLink *link, AVFilterBufferRef *buf)

 {

     AVFilterContext *ctx = link->dst;

     JoinContext       *s = ctx->priv;

@@ -104,6 +104,8 @@ static void filter_samples(AVFilterLink *link, AVFilterBufferRef *buf)

     av_assert0(i < ctx->nb_inputs);

     av_assert0(!s->input_frames[i]);

     s->input_frames[i] = buf;

+

+    return 0;

 }

 static int parse_maps(AVFilterContext *ctx)

@@ -468,11 +470,11 @@ static int join_request_frame(AVFilterLink *outlink)

     priv->nb_in_buffers = ctx->nb_inputs;

     buf->buf->priv      = priv;

-    ff_filter_samples(outlink, buf);