[deb_ffmpeg.git] / ffmpeg / libavresample / avresample-test.c

/*
 * Copyright (c) 2002 Fabrice Bellard
 * Copyright (c) 2012 Justin Ruggles <justin.ruggles@gmail.com>
 *
 * 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 <stdio.h>

#include "libavutil/avstring.h"
#include "libavutil/common.h"
#include "libavutil/lfg.h"
#include "libavutil/libm.h"
#include "libavutil/log.h"
#include "libavutil/mem.h"
#include "libavutil/opt.h"
#include "libavutil/samplefmt.h"
#include "avresample.h"

static double dbl_rand(AVLFG *lfg)
{
    return 2.0 * (av_lfg_get(lfg) / (double)UINT_MAX) - 1.0;
}

#define PUT_FUNC(name, fmt, type, expr)                                     \
static void put_sample_ ## name(void **data, enum AVSampleFormat sample_fmt,\
                                int channels, int sample, int ch,           \
                                double v_dbl)                               \
{                                                                           \
    type v = expr;                                                          \
    type **out = (type **)data;                                             \
    if (av_sample_fmt_is_planar(sample_fmt))                                \
        out[ch][sample] = v;                                                \
    else                                                                    \
        out[0][sample * channels + ch] = v;                                 \
}

PUT_FUNC(u8,  AV_SAMPLE_FMT_U8,  uint8_t, av_clip_uint8 ( lrint(v_dbl * (1  <<  7)) + 128))
PUT_FUNC(s16, AV_SAMPLE_FMT_S16, int16_t, av_clip_int16 ( lrint(v_dbl * (1  << 15))))
PUT_FUNC(s32, AV_SAMPLE_FMT_S32, int32_t, av_clipl_int32(llrint(v_dbl * (1U << 31))))
PUT_FUNC(flt, AV_SAMPLE_FMT_FLT, float,   v_dbl)
PUT_FUNC(dbl, AV_SAMPLE_FMT_DBL, double,  v_dbl)

static void put_sample(void **data, enum AVSampleFormat sample_fmt,
                       int channels, int sample, int ch, double v_dbl)
{
    switch (av_get_packed_sample_fmt(sample_fmt)) {
    case AV_SAMPLE_FMT_U8:
        put_sample_u8(data, sample_fmt, channels, sample, ch, v_dbl);
        break;
    case AV_SAMPLE_FMT_S16:
        put_sample_s16(data, sample_fmt, channels, sample, ch, v_dbl);
        break;
    case AV_SAMPLE_FMT_S32:
        put_sample_s32(data, sample_fmt, channels, sample, ch, v_dbl);
        break;
    case AV_SAMPLE_FMT_FLT:
        put_sample_flt(data, sample_fmt, channels, sample, ch, v_dbl);
        break;
    case AV_SAMPLE_FMT_DBL:
        put_sample_dbl(data, sample_fmt, channels, sample, ch, v_dbl);
        break;
    }
}

static void audiogen(AVLFG *rnd, void **data, enum AVSampleFormat sample_fmt,
                     int channels, int sample_rate, int nb_samples)
{
    int i, ch, k;
    double v, f, a, ampa;
    double tabf1[AVRESAMPLE_MAX_CHANNELS];
    double tabf2[AVRESAMPLE_MAX_CHANNELS];
    double taba[AVRESAMPLE_MAX_CHANNELS];

#define PUT_SAMPLE put_sample(data, sample_fmt, channels, k, ch, v);

    k = 0;

    /* 1 second of single freq sine at 1000 Hz */
    a = 0;
    for (i = 0; i < 1 * sample_rate && k < nb_samples; i++, k++) {
        v = sin(a) * 0.30;
        for (ch = 0; ch < channels; ch++)
            PUT_SAMPLE
        a += M_PI * 1000.0 * 2.0 / sample_rate;
    }

    /* 1 second of varying frequency between 100 and 10000 Hz */
    a = 0;
    for (i = 0; i < 1 * sample_rate && k < nb_samples; i++, k++) {
        v = sin(a) * 0.30;
        for (ch = 0; ch < channels; ch++)
            PUT_SAMPLE
        f  = 100.0 + (((10000.0 - 100.0) * i) / sample_rate);
        a += M_PI * f * 2.0 / sample_rate;
    }

    /* 0.5 second of low amplitude white noise */
    for (i = 0; i < sample_rate / 2 && k < nb_samples; i++, k++) {
        v = dbl_rand(rnd) * 0.30;
        for (ch = 0; ch < channels; ch++)
            PUT_SAMPLE
    }

    /* 0.5 second of high amplitude white noise */
    for (i = 0; i < sample_rate / 2 && k < nb_samples; i++, k++) {
        v = dbl_rand(rnd);
        for (ch = 0; ch < channels; ch++)
            PUT_SAMPLE
    }

    /* 1 second of unrelated ramps for each channel */
    for (ch = 0; ch < channels; ch++) {
        taba[ch]  = 0;
        tabf1[ch] = 100 + av_lfg_get(rnd) % 5000;
        tabf2[ch] = 100 + av_lfg_get(rnd) % 5000;
    }
    for (i = 0; i < 1 * sample_rate && k < nb_samples; i++, k++) {
        for (ch = 0; ch < channels; ch++) {
            v = sin(taba[ch]) * 0.30;
            PUT_SAMPLE
            f = tabf1[ch] + (((tabf2[ch] - tabf1[ch]) * i) / sample_rate);
            taba[ch] += M_PI * f * 2.0 / sample_rate;
        }
    }

    /* 2 seconds of 500 Hz with varying volume */
    a    = 0;
    ampa = 0;
    for (i = 0; i < 2 * sample_rate && k < nb_samples; i++, k++) {
        for (ch = 0; ch < channels; ch++) {
            double amp = (1.0 + sin(ampa)) * 0.15;
            if (ch & 1)
                amp = 0.30 - amp;
            v = sin(a) * amp;
            PUT_SAMPLE
            a    += M_PI * 500.0 * 2.0 / sample_rate;
            ampa += M_PI *  2.0 / sample_rate;
        }
    }
}

/* formats, rates, and layouts are ordered for priority in testing.
   e.g. 'avresample-test 4 2 2' will test all input/output combinations of
   S16/FLTP/S16P/FLT, 48000/44100, and stereo/mono */

static const enum AVSampleFormat formats[] = {
    AV_SAMPLE_FMT_S16,
    AV_SAMPLE_FMT_FLTP,
    AV_SAMPLE_FMT_S16P,
    AV_SAMPLE_FMT_FLT,
    AV_SAMPLE_FMT_S32P,
    AV_SAMPLE_FMT_S32,
    AV_SAMPLE_FMT_U8P,
    AV_SAMPLE_FMT_U8,
    AV_SAMPLE_FMT_DBLP,
    AV_SAMPLE_FMT_DBL,
};

static const int rates[] = {
    48000,
    44100,
    16000
};

static const uint64_t layouts[] = {
    AV_CH_LAYOUT_STEREO,
    AV_CH_LAYOUT_MONO,
    AV_CH_LAYOUT_5POINT1,
    AV_CH_LAYOUT_7POINT1,
};

int main(int argc, char **argv)
{
    AVAudioResampleContext *s;
    AVLFG rnd;
    int ret = 0;
    uint8_t *in_buf = NULL;
    uint8_t *out_buf = NULL;
    unsigned int in_buf_size;
    unsigned int out_buf_size;
    uint8_t  *in_data[AVRESAMPLE_MAX_CHANNELS] = { 0 };
    uint8_t *out_data[AVRESAMPLE_MAX_CHANNELS] = { 0 };
    int in_linesize;
    int out_linesize;
    uint64_t in_ch_layout;
    int in_channels;
    enum AVSampleFormat in_fmt;
    int in_rate;
    uint64_t out_ch_layout;
    int out_channels;
    enum AVSampleFormat out_fmt;
    int out_rate;
    int num_formats, num_rates, num_layouts;
    int i, j, k, l, m, n;

    num_formats = 2;
    num_rates   = 2;
    num_layouts = 2;
    if (argc > 1) {
        if (!av_strncasecmp(argv[1], "-h", 3)) {
            av_log(NULL, AV_LOG_INFO, "Usage: avresample-test [<num formats> "
                   "[<num sample rates> [<num channel layouts>]]]\n"
                   "Default is 2 2 2\n");
            return 0;
        }
        num_formats = strtol(argv[1], NULL, 0);
        num_formats = av_clip(num_formats, 1, FF_ARRAY_ELEMS(formats));
    }
    if (argc > 2) {
        num_rates = strtol(argv[2], NULL, 0);
        num_rates = av_clip(num_rates, 1, FF_ARRAY_ELEMS(rates));
    }
    if (argc > 3) {
        num_layouts = strtol(argv[3], NULL, 0);
        num_layouts = av_clip(num_layouts, 1, FF_ARRAY_ELEMS(layouts));
    }

    av_log_set_level(AV_LOG_DEBUG);

    av_lfg_init(&rnd, 0xC0FFEE);

    in_buf_size = av_samples_get_buffer_size(&in_linesize, 8, 48000 * 6,
                                             AV_SAMPLE_FMT_DBLP, 0);
    out_buf_size = in_buf_size;

    in_buf = av_malloc(in_buf_size);
    if (!in_buf)
        goto end;
    out_buf = av_malloc(out_buf_size);
    if (!out_buf)
        goto end;

    s = avresample_alloc_context();
    if (!s) {
        av_log(NULL, AV_LOG_ERROR, "Error allocating AVAudioResampleContext\n");
        ret = 1;
        goto end;
    }

    for (i = 0; i < num_formats; i++) {
        in_fmt = formats[i];
        for (k = 0; k < num_layouts; k++) {
            in_ch_layout = layouts[k];
            in_channels  = av_get_channel_layout_nb_channels(in_ch_layout);
            for (m = 0; m < num_rates; m++) {
                in_rate = rates[m];

                ret = av_samples_fill_arrays(in_data, &in_linesize, in_buf,
                                             in_channels, in_rate * 6,
                                             in_fmt, 0);
                if (ret < 0) {
                    av_log(s, AV_LOG_ERROR, "failed in_data fill arrays\n");
                    goto end;
                }
                audiogen(&rnd, (void **)in_data, in_fmt, in_channels, in_rate, in_rate * 6);

                for (j = 0; j < num_formats; j++) {
                    out_fmt = formats[j];
                    for (l = 0; l < num_layouts; l++) {
                        out_ch_layout = layouts[l];
                        out_channels  = av_get_channel_layout_nb_channels(out_ch_layout);
                        for (n = 0; n < num_rates; n++) {
                            out_rate = rates[n];

                            av_log(NULL, AV_LOG_INFO, "%s to %s, %d to %d channels, %d Hz to %d Hz\n",
                                   av_get_sample_fmt_name(in_fmt), av_get_sample_fmt_name(out_fmt),
                                   in_channels, out_channels, in_rate, out_rate);

                            ret = av_samples_fill_arrays(out_data, &out_linesize,
                                                         out_buf, out_channels,
                                                         out_rate * 6, out_fmt, 0);
                            if (ret < 0) {
                                av_log(s, AV_LOG_ERROR, "failed out_data fill arrays\n");
                                goto end;
                            }

                            av_opt_set_int(s, "in_channel_layout",  in_ch_layout,  0);
                            av_opt_set_int(s, "in_sample_fmt",      in_fmt,        0);
                            av_opt_set_int(s, "in_sample_rate",     in_rate,       0);
                            av_opt_set_int(s, "out_channel_layout", out_ch_layout, 0);
                            av_opt_set_int(s, "out_sample_fmt",     out_fmt,       0);
                            av_opt_set_int(s, "out_sample_rate",    out_rate,      0);

                            av_opt_set_int(s, "internal_sample_fmt", AV_SAMPLE_FMT_FLTP, 0);

                            ret = avresample_open(s);
                            if (ret < 0) {
                                av_log(s, AV_LOG_ERROR, "Error opening context\n");
                                goto end;
                            }

                            ret = avresample_convert(s, out_data, out_linesize, out_rate * 6,
                                                         in_data,  in_linesize,  in_rate * 6);
                            if (ret < 0) {
                                char errbuf[256];
                                av_strerror(ret, errbuf, sizeof(errbuf));
                                av_log(NULL, AV_LOG_ERROR, "%s\n", errbuf);
                                goto end;
                            }
                            av_log(NULL, AV_LOG_INFO, "Converted %d samples to %d samples\n",
                                   in_rate * 6, ret);
                            if (avresample_get_delay(s) > 0)
                                av_log(NULL, AV_LOG_INFO, "%d delay samples not converted\n",
                                       avresample_get_delay(s));
                            if (avresample_available(s) > 0)
                                av_log(NULL, AV_LOG_INFO, "%d samples available for output\n",
                                       avresample_available(s));
                            av_log(NULL, AV_LOG_INFO, "\n");

                            avresample_close(s);
                        }
                    }
                }
            }
        }
    }

    ret = 0;

end:
    av_freep(&in_buf);
    av_freep(&out_buf);
    avresample_free(&s);
    return ret;
}
Commit	Line	Data
2ba45a60 DM	1	/*
	2	* Copyright (c) 2002 Fabrice Bellard
	3	* Copyright (c) 2012 Justin Ruggles <justin.ruggles@gmail.com>
	4	*
	5	* This file is part of FFmpeg.
	6	*
	7	* FFmpeg is free software; you can redistribute it and/or
	8	* modify it under the terms of the GNU Lesser General Public
	9	* License as published by the Free Software Foundation; either
	10	* version 2.1 of the License, or (at your option) any later version.
	11	*
	12	* FFmpeg is distributed in the hope that it will be useful,
	13	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	15	* Lesser General Public License for more details.
	16	*
	17	* You should have received a copy of the GNU Lesser General Public
	18	* License along with FFmpeg; if not, write to the Free Software
	19	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
	20	*/
	21
	22	#include <stdint.h>
	23	#include <stdio.h>
	24
	25	#include "libavutil/avstring.h"
	26	#include "libavutil/common.h"
	27	#include "libavutil/lfg.h"
	28	#include "libavutil/libm.h"
	29	#include "libavutil/log.h"
	30	#include "libavutil/mem.h"
	31	#include "libavutil/opt.h"
	32	#include "libavutil/samplefmt.h"
	33	#include "avresample.h"
	34
	35	static double dbl_rand(AVLFG *lfg)
	36	{
	37	return 2.0 * (av_lfg_get(lfg) / (double)UINT_MAX) - 1.0;
	38	}
	39
	40	#define PUT_FUNC(name, fmt, type, expr) \
	41	static void put_sample_ ## name(void **data, enum AVSampleFormat sample_fmt,\
	42	int channels, int sample, int ch, \
	43	double v_dbl) \
	44	{ \
	45	type v = expr; \
	46	type out = (type )data; \
	47	if (av_sample_fmt_is_planar(sample_fmt)) \
	48	out[ch][sample] = v; \
	49	else \
	50	out[0][sample * channels + ch] = v; \
	51	}
	52
	53	PUT_FUNC(u8, AV_SAMPLE_FMT_U8, uint8_t, av_clip_uint8 ( lrint(v_dbl * (1 << 7)) + 128))
	54	PUT_FUNC(s16, AV_SAMPLE_FMT_S16, int16_t, av_clip_int16 ( lrint(v_dbl * (1 << 15))))
	55	PUT_FUNC(s32, AV_SAMPLE_FMT_S32, int32_t, av_clipl_int32(llrint(v_dbl * (1U << 31))))
	56	PUT_FUNC(flt, AV_SAMPLE_FMT_FLT, float, v_dbl)
	57	PUT_FUNC(dbl, AV_SAMPLE_FMT_DBL, double, v_dbl)
	58
	59	static void put_sample(void **data, enum AVSampleFormat sample_fmt,
	60	int channels, int sample, int ch, double v_dbl)
	61	{
	62	switch (av_get_packed_sample_fmt(sample_fmt)) {
	63	case AV_SAMPLE_FMT_U8:
	64	put_sample_u8(data, sample_fmt, channels, sample, ch, v_dbl);
65	break;
66	case AV_SAMPLE_FMT_S16:
67	put_sample_s16(data, sample_fmt, channels, sample, ch, v_dbl);
68	break;
69	case AV_SAMPLE_FMT_S32:
70	put_sample_s32(data, sample_fmt, channels, sample, ch, v_dbl);
71	break;
72	case AV_SAMPLE_FMT_FLT:
73	put_sample_flt(data, sample_fmt, channels, sample, ch, v_dbl);
74	break;
75	case AV_SAMPLE_FMT_DBL:
76	put_sample_dbl(data, sample_fmt, channels, sample, ch, v_dbl);
77	break;
78	}
79	}
80
81	static void audiogen(AVLFG rnd, void *data, enum AVSampleFormat sample_fmt,
82	int channels, int sample_rate, int nb_samples)
83	{
84	int i, ch, k;
85	double v, f, a, ampa;
86	double tabf1[AVRESAMPLE_MAX_CHANNELS];
87	double tabf2[AVRESAMPLE_MAX_CHANNELS];
88	double taba[AVRESAMPLE_MAX_CHANNELS];
89
90	#define PUT_SAMPLE put_sample(data, sample_fmt, channels, k, ch, v);
91
92	k = 0;
93
94	/* 1 second of single freq sine at 1000 Hz */
95	a = 0;
96	for (i = 0; i < 1 * sample_rate && k < nb_samples; i++, k++) {
97	v = sin(a) * 0.30;
98	for (ch = 0; ch < channels; ch++)
99	PUT_SAMPLE
100	a += M_PI * 1000.0 * 2.0 / sample_rate;
101	}
102
103	/* 1 second of varying frequency between 100 and 10000 Hz */
104	a = 0;
105	for (i = 0; i < 1 * sample_rate && k < nb_samples; i++, k++) {
106	v = sin(a) * 0.30;
107	for (ch = 0; ch < channels; ch++)
108	PUT_SAMPLE
109	f = 100.0 + (((10000.0 - 100.0) * i) / sample_rate);
110	a += M_PI * f * 2.0 / sample_rate;
111	}
112
113	/* 0.5 second of low amplitude white noise */
114	for (i = 0; i < sample_rate / 2 && k < nb_samples; i++, k++) {
115	v = dbl_rand(rnd) * 0.30;
116	for (ch = 0; ch < channels; ch++)
117	PUT_SAMPLE
118	}
119
120	/* 0.5 second of high amplitude white noise */
121	for (i = 0; i < sample_rate / 2 && k < nb_samples; i++, k++) {
122	v = dbl_rand(rnd);
123	for (ch = 0; ch < channels; ch++)
124	PUT_SAMPLE
125	}
126
127	/* 1 second of unrelated ramps for each channel */
128	for (ch = 0; ch < channels; ch++) {
129	taba[ch] = 0;
130	tabf1[ch] = 100 + av_lfg_get(rnd) % 5000;
131	tabf2[ch] = 100 + av_lfg_get(rnd) % 5000;
132	}
133	for (i = 0; i < 1 * sample_rate && k < nb_samples; i++, k++) {
134	for (ch = 0; ch < channels; ch++) {
135	v = sin(taba[ch]) * 0.30;
136	PUT_SAMPLE
137	f = tabf1[ch] + (((tabf2[ch] - tabf1[ch]) * i) / sample_rate);
138	taba[ch] += M_PI * f * 2.0 / sample_rate;
139	}
140	}
141
142	/* 2 seconds of 500 Hz with varying volume */
143	a = 0;
144	ampa = 0;
145	for (i = 0; i < 2 * sample_rate && k < nb_samples; i++, k++) {
146	for (ch = 0; ch < channels; ch++) {
147	double amp = (1.0 + sin(ampa)) * 0.15;
148	if (ch & 1)
149	amp = 0.30 - amp;
150	v = sin(a) * amp;
151	PUT_SAMPLE
152	a += M_PI * 500.0 * 2.0 / sample_rate;
153	ampa += M_PI * 2.0 / sample_rate;
154	}
155	}
156	}
157
158	/* formats, rates, and layouts are ordered for priority in testing.
159	e.g. 'avresample-test 4 2 2' will test all input/output combinations of
160	S16/FLTP/S16P/FLT, 48000/44100, and stereo/mono */
161
162	static const enum AVSampleFormat formats[] = {
163	AV_SAMPLE_FMT_S16,
164	AV_SAMPLE_FMT_FLTP,
165	AV_SAMPLE_FMT_S16P,
166	AV_SAMPLE_FMT_FLT,
167	AV_SAMPLE_FMT_S32P,
168	AV_SAMPLE_FMT_S32,
169	AV_SAMPLE_FMT_U8P,
170	AV_SAMPLE_FMT_U8,
171	AV_SAMPLE_FMT_DBLP,
172	AV_SAMPLE_FMT_DBL,
173	};
174
175	static const int rates[] = {
176	48000,
177	44100,
178	16000
179	};
180
181	static const uint64_t layouts[] = {
182	AV_CH_LAYOUT_STEREO,
183	AV_CH_LAYOUT_MONO,
184	AV_CH_LAYOUT_5POINT1,
185	AV_CH_LAYOUT_7POINT1,
186	};
187
188	int main(int argc, char **argv)
189	{
190	AVAudioResampleContext *s;
191	AVLFG rnd;
192	int ret = 0;
193	uint8_t *in_buf = NULL;
194	uint8_t *out_buf = NULL;
195	unsigned int in_buf_size;
196	unsigned int out_buf_size;
197	uint8_t *in_data[AVRESAMPLE_MAX_CHANNELS] = { 0 };
198	uint8_t *out_data[AVRESAMPLE_MAX_CHANNELS] = { 0 };
199	int in_linesize;
200	int out_linesize;
201	uint64_t in_ch_layout;
202	int in_channels;
203	enum AVSampleFormat in_fmt;
204	int in_rate;
205	uint64_t out_ch_layout;
206	int out_channels;
207	enum AVSampleFormat out_fmt;
208	int out_rate;
209	int num_formats, num_rates, num_layouts;
210	int i, j, k, l, m, n;
211
212	num_formats = 2;
213	num_rates = 2;
214	num_layouts = 2;
215	if (argc > 1) {
216	if (!av_strncasecmp(argv[1], "-h", 3)) {
217	av_log(NULL, AV_LOG_INFO, "Usage: avresample-test [<num formats> "
218	"[<num sample rates> [<num channel layouts>]]]\n"
219	"Default is 2 2 2\n");
220	return 0;
221	}
222	num_formats = strtol(argv[1], NULL, 0);
223	num_formats = av_clip(num_formats, 1, FF_ARRAY_ELEMS(formats));
224	}
225	if (argc > 2) {
226	num_rates = strtol(argv[2], NULL, 0);
227	num_rates = av_clip(num_rates, 1, FF_ARRAY_ELEMS(rates));
228	}
229	if (argc > 3) {
230	num_layouts = strtol(argv[3], NULL, 0);
231	num_layouts = av_clip(num_layouts, 1, FF_ARRAY_ELEMS(layouts));
232	}
233
234	av_log_set_level(AV_LOG_DEBUG);
235
236	av_lfg_init(&rnd, 0xC0FFEE);
237
238	in_buf_size = av_samples_get_buffer_size(&in_linesize, 8, 48000 * 6,
239	AV_SAMPLE_FMT_DBLP, 0);
240	out_buf_size = in_buf_size;
241
242	in_buf = av_malloc(in_buf_size);
243	if (!in_buf)
244	goto end;
245	out_buf = av_malloc(out_buf_size);
246	if (!out_buf)
247	goto end;
248
249	s = avresample_alloc_context();
250	if (!s) {
251	av_log(NULL, AV_LOG_ERROR, "Error allocating AVAudioResampleContext\n");
252	ret = 1;
253	goto end;
254	}
255
256	for (i = 0; i < num_formats; i++) {
257	in_fmt = formats[i];
258	for (k = 0; k < num_layouts; k++) {
259	in_ch_layout = layouts[k];
260	in_channels = av_get_channel_layout_nb_channels(in_ch_layout);
261	for (m = 0; m < num_rates; m++) {
262	in_rate = rates[m];
263
264	ret = av_samples_fill_arrays(in_data, &in_linesize, in_buf,
265	in_channels, in_rate * 6,
266	in_fmt, 0);
267	if (ret < 0) {
268	av_log(s, AV_LOG_ERROR, "failed in_data fill arrays\n");
269	goto end;
270	}
271	audiogen(&rnd, (void *)in_data, in_fmt, in_channels, in_rate, in_rate 6);
272
273	for (j = 0; j < num_formats; j++) {
274	out_fmt = formats[j];
275	for (l = 0; l < num_layouts; l++) {
276	out_ch_layout = layouts[l];
277	out_channels = av_get_channel_layout_nb_channels(out_ch_layout);
278	for (n = 0; n < num_rates; n++) {
279	out_rate = rates[n];
280
281	av_log(NULL, AV_LOG_INFO, "%s to %s, %d to %d channels, %d Hz to %d Hz\n",
282	av_get_sample_fmt_name(in_fmt), av_get_sample_fmt_name(out_fmt),
283	in_channels, out_channels, in_rate, out_rate);
284
285	ret = av_samples_fill_arrays(out_data, &out_linesize,
286	out_buf, out_channels,
287	out_rate * 6, out_fmt, 0);
288	if (ret < 0) {
289	av_log(s, AV_LOG_ERROR, "failed out_data fill arrays\n");
290	goto end;
291	}
292
293	av_opt_set_int(s, "in_channel_layout", in_ch_layout, 0);
294	av_opt_set_int(s, "in_sample_fmt", in_fmt, 0);
295	av_opt_set_int(s, "in_sample_rate", in_rate, 0);
296	av_opt_set_int(s, "out_channel_layout", out_ch_layout, 0);
297	av_opt_set_int(s, "out_sample_fmt", out_fmt, 0);
298	av_opt_set_int(s, "out_sample_rate", out_rate, 0);
299
300	av_opt_set_int(s, "internal_sample_fmt", AV_SAMPLE_FMT_FLTP, 0);
301
302	ret = avresample_open(s);
303	if (ret < 0) {
304	av_log(s, AV_LOG_ERROR, "Error opening context\n");
305	goto end;
306	}
307
308	ret = avresample_convert(s, out_data, out_linesize, out_rate * 6,
309	in_data, in_linesize, in_rate * 6);
310	if (ret < 0) {
311	char errbuf[256];
312	av_strerror(ret, errbuf, sizeof(errbuf));
313	av_log(NULL, AV_LOG_ERROR, "%s\n", errbuf);
314	goto end;
315	}
316	av_log(NULL, AV_LOG_INFO, "Converted %d samples to %d samples\n",
317	in_rate * 6, ret);
318	if (avresample_get_delay(s) > 0)
319	av_log(NULL, AV_LOG_INFO, "%d delay samples not converted\n",
320	avresample_get_delay(s));
321	if (avresample_available(s) > 0)
322	av_log(NULL, AV_LOG_INFO, "%d samples available for output\n",
323	avresample_available(s));
324	av_log(NULL, AV_LOG_INFO, "\n");
325
326	avresample_close(s);
327	}
328	}
329	}
330	}
331	}
332	}
333
334	ret = 0;
335
336	end:
337	av_freep(&in_buf);
338	av_freep(&out_buf);
339	avresample_free(&s);
340	return ret;
341	}