1/*
2 * This file is part of FFmpeg.
3 *
4 * FFmpeg is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2.1 of the License, or (at your option) any later version.
8 *
9 * FFmpeg is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12 * Lesser General Public License for more details.
13 *
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with FFmpeg; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17 */
18#include "config.h"
19
20#include <stdlib.h>
21#include <stdio.h>
22#include <inttypes.h>
23#include "libavutil/mem.h"
24#include "libavutil/audio_fifo.c"
25
26#define MAX_CHANNELS    32
27
28
29typedef struct TestStruct {
30    const enum AVSampleFormat format;
31    const int nb_ch;
32    void const *data_planes[MAX_CHANNELS];
33    const int nb_samples_pch;
34} TestStruct;
35
36static const uint8_t data_U8 [] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11                        };
37static const int16_t data_S16[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11                        };
38static const float   data_FLT[] = {0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0};
39
40static const TestStruct test_struct[] = {
41    {.format = AV_SAMPLE_FMT_U8   , .nb_ch = 1, .data_planes = {data_U8 ,             }, .nb_samples_pch = 12},
42    {.format = AV_SAMPLE_FMT_U8P  , .nb_ch = 2, .data_planes = {data_U8 , data_U8 +6, }, .nb_samples_pch = 6 },
43    {.format = AV_SAMPLE_FMT_S16  , .nb_ch = 1, .data_planes = {data_S16,             }, .nb_samples_pch = 12},
44    {.format = AV_SAMPLE_FMT_S16P , .nb_ch = 2, .data_planes = {data_S16, data_S16+6, }, .nb_samples_pch = 6 },
45    {.format = AV_SAMPLE_FMT_FLT  , .nb_ch = 1, .data_planes = {data_FLT,             }, .nb_samples_pch = 12},
46    {.format = AV_SAMPLE_FMT_FLTP , .nb_ch = 2, .data_planes = {data_FLT, data_FLT+6, }, .nb_samples_pch = 6 }
47};
48
49static void free_data_planes(AVAudioFifo *afifo, void **output_data)
50{
51    int i;
52    for (i = 0; i < afifo->nb_buffers; ++i){
53        av_freep(&output_data[i]);
54    }
55    av_freep(&output_data);
56}
57
58static void ERROR(const char *str)
59{
60    fprintf(stderr, "%s\n", str);
61    exit(1);
62}
63
64static void print_audio_bytes(const TestStruct *test_sample, void **data_planes, int nb_samples)
65{
66    int p, b, f;
67    int byte_offset      = av_get_bytes_per_sample(test_sample->format);
68    int buffers          = av_sample_fmt_is_planar(test_sample->format)
69                                         ? test_sample->nb_ch : 1;
70    int line_size        = (buffers > 1) ? nb_samples * byte_offset
71                                         : nb_samples * byte_offset * test_sample->nb_ch;
72    for (p = 0; p < buffers; ++p){
73        for(b = 0; b < line_size; b+=byte_offset){
74            for (f = 0; f < byte_offset; f++){
75                int order = !HAVE_BIGENDIAN ? (byte_offset - f - 1) : f;
76                printf("%02x", *((uint8_t*)data_planes[p] + b + order));
77            }
78            putchar(' ');
79        }
80        putchar('\n');
81    }
82}
83
84static int read_samples_from_audio_fifo(AVAudioFifo* afifo, void ***output, int nb_samples)
85{
86    int i;
87    int samples        = FFMIN(nb_samples, afifo->nb_samples);
88    int tot_elements   = !av_sample_fmt_is_planar(afifo->sample_fmt)
89                         ? samples : afifo->channels * samples;
90    void **data_planes = av_malloc_array(afifo->nb_buffers, sizeof(void*));
91    if (!data_planes)
92        ERROR("failed to allocate memory!");
93    if (*output)
94        free_data_planes(afifo, *output);
95    *output            = data_planes;
96
97    for (i = 0; i < afifo->nb_buffers; ++i){
98        data_planes[i] = av_malloc_array(tot_elements, afifo->sample_size);
99        if (!data_planes[i])
100            ERROR("failed to allocate memory!");
101    }
102
103    return av_audio_fifo_read(afifo, *output, nb_samples);
104}
105
106static int write_samples_to_audio_fifo(AVAudioFifo* afifo, const TestStruct *test_sample,
107                                       int nb_samples, int offset)
108{
109    int offset_size, i;
110    void *data_planes[MAX_CHANNELS];
111
112    if(nb_samples > test_sample->nb_samples_pch - offset){
113        return 0;
114    }
115    if(offset >= test_sample->nb_samples_pch){
116        return 0;
117    }
118    offset_size  = offset * afifo->sample_size;
119
120    for (i = 0; i < afifo->nb_buffers ; ++i){
121        data_planes[i] = (uint8_t*)test_sample->data_planes[i] + offset_size;
122    }
123
124    return av_audio_fifo_write(afifo, data_planes, nb_samples);
125}
126
127static void test_function(const TestStruct *test_sample)
128{
129    int ret, i;
130    void **output_data  = NULL;
131    AVAudioFifo *afifo  = av_audio_fifo_alloc(test_sample->format, test_sample->nb_ch,
132                                            test_sample->nb_samples_pch);
133    if (!afifo) {
134        ERROR("ERROR: av_audio_fifo_alloc returned NULL!");
135    }
136    ret = write_samples_to_audio_fifo(afifo, test_sample, test_sample->nb_samples_pch, 0);
137    if (ret < 0){
138        ERROR("ERROR: av_audio_fifo_write failed!");
139    }
140    printf("written: %d\n", ret);
141
142    ret = write_samples_to_audio_fifo(afifo, test_sample, test_sample->nb_samples_pch, 0);
143    if (ret < 0){
144        ERROR("ERROR: av_audio_fifo_write failed!");
145    }
146    printf("written: %d\n", ret);
147    printf("remaining samples in audio_fifo: %d\n\n", av_audio_fifo_size(afifo));
148
149    ret = read_samples_from_audio_fifo(afifo, &output_data, test_sample->nb_samples_pch);
150    if (ret < 0){
151        ERROR("ERROR: av_audio_fifo_read failed!");
152    }
153    printf("read: %d\n", ret);
154    print_audio_bytes(test_sample, output_data, ret);
155    printf("remaining samples in audio_fifo: %d\n\n", av_audio_fifo_size(afifo));
156
157    /* test av_audio_fifo_peek */
158    ret = av_audio_fifo_peek(afifo, output_data, afifo->nb_samples);
159    if (ret < 0){
160        ERROR("ERROR: av_audio_fifo_peek failed!");
161    }
162    printf("peek:\n");
163    print_audio_bytes(test_sample, output_data, ret);
164    printf("\n");
165
166    /* test av_audio_fifo_peek_at */
167    printf("peek_at:\n");
168    for (i = 0; i < afifo->nb_samples; ++i){
169        ret = av_audio_fifo_peek_at(afifo, output_data, 1, i);
170        if (ret < 0){
171            ERROR("ERROR: av_audio_fifo_peek_at failed!");
172        }
173        printf("%d:\n", i);
174        print_audio_bytes(test_sample, output_data, ret);
175    }
176    printf("\n");
177
178    /* test av_audio_fifo_drain */
179    ret = av_audio_fifo_drain(afifo, afifo->nb_samples);
180    if (ret < 0){
181        ERROR("ERROR: av_audio_fifo_drain failed!");
182    }
183    if (afifo->nb_samples){
184        ERROR("drain failed to flush all samples in audio_fifo!");
185    }
186
187    /* deallocate */
188    free_data_planes(afifo, output_data);
189    av_audio_fifo_free(afifo);
190}
191
192int main(void)
193{
194    int t, tests = sizeof(test_struct)/sizeof(test_struct[0]);
195
196    for (t = 0; t < tests; ++t){
197        printf("\nTEST: %d\n\n", t+1);
198        test_function(&test_struct[t]);
199    }
200    return 0;
201}
202