git.sesse.net Git - ffmpeg/blob - libavutil/tests/audio_fifo.c

   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
  19 #include <stdlib.h>
  20 #include <stdio.h>
  21 #include <inttypes.h>
  22 #include "libavutil/mem.h"
  23 #include "libavutil/audio_fifo.c"
  24
  25 #define MAX_CHANNELS    32
  26
  27
  28 typedef struct TestStruct {
  29     const enum AVSampleFormat format;
  30     const int nb_ch;
  31     void const *data_planes[MAX_CHANNELS];
  32     const int nb_samples_pch;
  33 } TestStruct;
  34
  35 static const uint8_t data_U8 [] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11                        };
  36 static const int16_t data_S16[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11                        };
  37 static 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};
  38
  39 static const TestStruct test_struct[] = {
  40     {.format = AV_SAMPLE_FMT_U8   , .nb_ch = 1, .data_planes = {data_U8 ,             }, .nb_samples_pch = 12},
  41     {.format = AV_SAMPLE_FMT_U8P  , .nb_ch = 2, .data_planes = {data_U8 , data_U8 +6, }, .nb_samples_pch = 6 },
  42     {.format = AV_SAMPLE_FMT_S16  , .nb_ch = 1, .data_planes = {data_S16,             }, .nb_samples_pch = 12},
  43     {.format = AV_SAMPLE_FMT_S16P , .nb_ch = 2, .data_planes = {data_S16, data_S16+6, }, .nb_samples_pch = 6 },
  44     {.format = AV_SAMPLE_FMT_FLT  , .nb_ch = 1, .data_planes = {data_FLT,             }, .nb_samples_pch = 12},
  45     {.format = AV_SAMPLE_FMT_FLTP , .nb_ch = 2, .data_planes = {data_FLT, data_FLT+6, }, .nb_samples_pch = 6 }
  46 };
  47
  48 static void free_data_planes(AVAudioFifo *afifo, void **output_data)
  49 {
  50     int i;
  51     for (i = 0; i < afifo->nb_buffers; ++i){
  52         av_freep(&output_data[i]);
  53     }
  54     av_freep(&output_data);
  55 }
  56
  57 static void ERROR(const char *str)
  58 {
  59     fprintf(stderr, "%s\n", str);
  60     exit(1);
  61 }
  62
  63 static void print_audio_bytes(const TestStruct *test_sample, void **data_planes, int nb_samples)
  64 {
  65     int p, b, f;
  66     int byte_offset      = av_get_bytes_per_sample(test_sample->format);
  67     int buffers          = av_sample_fmt_is_planar(test_sample->format)
  68                                          ? test_sample->nb_ch : 1;
  69     int line_size        = (buffers > 1) ? nb_samples * byte_offset
  70                                          : nb_samples * byte_offset * test_sample->nb_ch;
  71     for (p = 0; p < buffers; ++p){
  72         for(b = 0; b < line_size; b+=byte_offset){
  73             for (f = 0; f < byte_offset; f++){
  74                 int order = !HAVE_BIGENDIAN ? (byte_offset - f - 1) : f;
  75                 printf("%02x", *((uint8_t*)data_planes[p] + b + order));
  76             }
  77             putchar(' ');
  78         }
  79         putchar('\n');
  80     }
  81 }
  82
  83 static int read_samples_from_audio_fifo(AVAudioFifo* afifo, void ***output, int nb_samples)
  84 {
  85     int i;
  86     int samples        = FFMIN(nb_samples, afifo->nb_samples);
  87     int tot_elements   = !av_sample_fmt_is_planar(afifo->sample_fmt)
  88                          ? samples : afifo->channels * samples;
  89     void **data_planes = av_malloc_array(afifo->nb_buffers, sizeof(void*));
  90     if (!data_planes)
  91         ERROR("failed to allocate memory!");
  92     if (*output)
  93         free_data_planes(afifo, *output);
  94     *output            = data_planes;
  95
  96     for (i = 0; i < afifo->nb_buffers; ++i){
  97         data_planes[i] = av_malloc_array(tot_elements, afifo->sample_size);
  98         if (!data_planes[i])
  99             ERROR("failed to allocate memory!");
 100     }
 101
 102     return av_audio_fifo_read(afifo, *output, nb_samples);
 103 }
 104
 105 static int write_samples_to_audio_fifo(AVAudioFifo* afifo, const TestStruct *test_sample,
 106                                        int nb_samples, int offset)
 107 {
 108     int offset_size, i;
 109     void *data_planes[MAX_CHANNELS];
 110
 111     if(nb_samples > test_sample->nb_samples_pch - offset){
 112         return 0;
 113     }
 114     if(offset >= test_sample->nb_samples_pch){
 115         return 0;
 116     }
 117     offset_size  = offset * afifo->sample_size;
 118
 119     for (i = 0; i < afifo->nb_buffers ; ++i){
 120         data_planes[i] = (uint8_t*)test_sample->data_planes[i] + offset_size;
 121     }
 122
 123     return av_audio_fifo_write(afifo, data_planes, nb_samples);
 124 }
 125
 126 static void test_function(const TestStruct *test_sample)
 127 {
 128     int ret, i;
 129     void **output_data  = NULL;
 130     AVAudioFifo *afifo  = av_audio_fifo_alloc(test_sample->format, test_sample->nb_ch,
 131                                             test_sample->nb_samples_pch);
 132     if (!afifo) {
 133         ERROR("ERROR: av_audio_fifo_alloc returned NULL!");
 134     }
 135     ret = write_samples_to_audio_fifo(afifo, test_sample, test_sample->nb_samples_pch, 0);
 136     if (ret < 0){
 137         ERROR("ERROR: av_audio_fifo_write failed!");
 138     }
 139     printf("written: %d\n", ret);
 140
 141     ret = write_samples_to_audio_fifo(afifo, test_sample, test_sample->nb_samples_pch, 0);
 142     if (ret < 0){
 143         ERROR("ERROR: av_audio_fifo_write failed!");
 144     }
 145     printf("written: %d\n", ret);
 146     printf("remaining samples in audio_fifo: %d\n\n", av_audio_fifo_size(afifo));
 147
 148     ret = read_samples_from_audio_fifo(afifo, &output_data, test_sample->nb_samples_pch);
 149     if (ret < 0){
 150         ERROR("ERROR: av_audio_fifo_read failed!");
 151     }
 152     printf("read: %d\n", ret);
 153     print_audio_bytes(test_sample, output_data, ret);
 154     printf("remaining samples in audio_fifo: %d\n\n", av_audio_fifo_size(afifo));
 155
 156     /* test av_audio_fifo_peek */
 157     ret = av_audio_fifo_peek(afifo, output_data, afifo->nb_samples);
 158     if (ret < 0){
 159         ERROR("ERROR: av_audio_fifo_peek failed!");
 160     }
 161     printf("peek:\n");
 162     print_audio_bytes(test_sample, output_data, ret);
 163     printf("\n");
 164
 165     /* test av_audio_fifo_peek_at */
 166     printf("peek_at:\n");
 167     for (i = 0; i < afifo->nb_samples; ++i){
 168         ret = av_audio_fifo_peek_at(afifo, output_data, 1, i);
 169         if (ret < 0){
 170             ERROR("ERROR: av_audio_fifo_peek_at failed!");
 171         }
 172         printf("%d:\n", i);
 173         print_audio_bytes(test_sample, output_data, ret);
 174     }
 175     printf("\n");
 176
 177     /* test av_audio_fifo_drain */
 178     ret = av_audio_fifo_drain(afifo, afifo->nb_samples);
 179     if (ret < 0){
 180         ERROR("ERROR: av_audio_fifo_drain failed!");
 181     }
 182     if (afifo->nb_samples){
 183         ERROR("drain failed to flush all samples in audio_fifo!");
 184     }
 185
 186     /* deallocate */
 187     free_data_planes(afifo, output_data);
 188     av_audio_fifo_free(afifo);
 189 }
 190
 191 int main(void)
 192 {
 193     int t, tests = sizeof(test_struct)/sizeof(test_struct[0]);
 194
 195     for (t = 0; t < tests; ++t){
 196         printf("\nTEST: %d\n\n", t+1);
 197         test_function(&test_struct[t]);
 198     }
 199     return 0;
 200 }