FFmpeg: libavutil/tests/audio_fifo.c Source File

FFmpeg
audio_fifo.c
Go to the documentation of this file.
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 
29  typedef 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 
36  static const uint8_t data_U8 [] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
37  static const int16_t data_S16[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
38  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};
39 
40  static 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 
49  static 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 
58  static void ERROR(const char *str)
59 {
60  fprintf(stderr, "%s\n", str);
61  exit(1);
62 }
63 
64  static 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 
84  static 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 
106  static 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 
127  static 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 
192  int 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 }
av_audio_fifo_free
void av_audio_fifo_free(AVAudioFifo *af)
Free an AVAudioFifo.
Definition: audio_fifo.c:48
main
int main(void)
Definition: audio_fifo.c:192
AV_SAMPLE_FMT_FLTP
@ AV_SAMPLE_FMT_FLTP
float, planar
Definition: samplefmt.h:66
output
filter_frame For filters that do not use the this method is called when a frame is pushed to the filter s input It can be called at any time except in a reentrant way If the input frame is enough to produce output
Definition: filter_design.txt:225
b
#define b
Definition: input.c:41
TestStruct::nb_samples_pch
const int nb_samples_pch
Definition: audio_fifo.c:33
output_data
static int output_data(MLPDecodeContext *m, unsigned int substr, AVFrame *frame, int *got_frame_ptr)
Write the audio data into the output buffer.
Definition: mlpdec.c:1087
TestStruct
Definition: audio_fifo.c:29
AVAudioFifo::nb_samples
int nb_samples
number of samples currently in the FIFO
Definition: audio_fifo.c:40
AVAudioFifo
Context for an Audio FIFO Buffer.
Definition: audio_fifo.c:37
av_audio_fifo_drain
int av_audio_fifo_drain(AVAudioFifo *af, int nb_samples)
Drain data from an AVAudioFifo.
Definition: audio_fifo.c:194
TestStruct::data_planes
const void * data_planes[MAX_CHANNELS]
Definition: audio_fifo.c:32
AVAudioFifo::channels
int channels
number of channels
Definition: audio_fifo.c:43
AVAudioFifo::sample_size
int sample_size
size, in bytes, of one sample in a buffer
Definition: audio_fifo.c:45
av_audio_fifo_write
int av_audio_fifo_write(AVAudioFifo *af, void **data, int nb_samples)
Write data to an AVAudioFifo.
Definition: audio_fifo.c:119
av_sample_fmt_is_planar
int av_sample_fmt_is_planar(enum AVSampleFormat sample_fmt)
Check if the sample format is planar.
Definition: samplefmt.c:114
NULL
#define NULL
Definition: coverity.c:32
ERROR
static void ERROR(const char *str)
Definition: audio_fifo.c:58
av_audio_fifo_alloc
AVAudioFifo * av_audio_fifo_alloc(enum AVSampleFormat sample_fmt, int channels, int nb_samples)
Allocate an AVAudioFifo.
Definition: audio_fifo.c:62
MAX_CHANNELS
#define MAX_CHANNELS
Definition: audio_fifo.c:26
test_function
static void test_function(const TestStruct *test_sample)
Definition: audio_fifo.c:127
write_samples_to_audio_fifo
static int write_samples_to_audio_fifo(AVAudioFifo *afifo, const TestStruct *test_sample, int nb_samples, int offset)
Definition: audio_fifo.c:106
TestStruct::format
enum AVSampleFormat format
Definition: audio_fifo.c:30
TestStruct::nb_ch
const int nb_ch
Definition: audio_fifo.c:31
av_audio_fifo_peek_at
int av_audio_fifo_peek_at(AVAudioFifo *af, void **data, int nb_samples, int offset)
Peek data from an AVAudioFifo.
Definition: audio_fifo.c:150
f
f
Definition: af_crystalizer.c:122
AV_SAMPLE_FMT_U8P
@ AV_SAMPLE_FMT_U8P
unsigned 8 bits, planar
Definition: samplefmt.h:63
for
for(k=2;k<=8;++k)
Definition: h264pred_template.c:425
printf
printf("static const uint8_t my_array[100] = {\n")
offset
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
Definition: writing_filters.txt:86
av_audio_fifo_size
int av_audio_fifo_size(AVAudioFifo *af)
Get the current number of samples in the AVAudioFifo available for reading.
Definition: audio_fifo.c:221
audio_fifo.c
AV_SAMPLE_FMT_S16P
@ AV_SAMPLE_FMT_S16P
signed 16 bits, planar
Definition: samplefmt.h:64
data_U8
static const uint8_t data_U8[]
Definition: audio_fifo.c:36
tests
const TestCase tests[]
Definition: fifo_muxer.c:242
av_audio_fifo_read
int av_audio_fifo_read(AVAudioFifo *af, void **data, int nb_samples)
Read data from an AVAudioFifo.
Definition: audio_fifo.c:174
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
read_samples_from_audio_fifo
static int read_samples_from_audio_fifo(AVAudioFifo *afifo, void ***output, int nb_samples)
Definition: audio_fifo.c:84
av_get_bytes_per_sample
int av_get_bytes_per_sample(enum AVSampleFormat sample_fmt)
Return number of bytes per sample.
Definition: samplefmt.c:108
AV_SAMPLE_FMT_U8
@ AV_SAMPLE_FMT_U8
unsigned 8 bits
Definition: samplefmt.h:57
av_malloc_array
#define av_malloc_array(a, b)
Definition: tableprint_vlc.h:31
AVSampleFormat
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:55
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
AV_SAMPLE_FMT_S16
@ AV_SAMPLE_FMT_S16
signed 16 bits
Definition: samplefmt.h:58
data_FLT
static const float data_FLT[]
Definition: audio_fifo.c:38
ret
ret
Definition: filter_design.txt:187
data_S16
static const int16_t data_S16[]
Definition: audio_fifo.c:37
AVAudioFifo::sample_fmt
enum AVSampleFormat sample_fmt
sample format
Definition: audio_fifo.c:44
samples
Filter the word "frame" indicates either a video frame or a group of audio samples
Definition: filter_design.txt:8
test_struct
static const TestStruct test_struct[]
Definition: audio_fifo.c:40
mem.h
AVAudioFifo::nb_buffers
int nb_buffers
number of buffers
Definition: audio_fifo.c:39
free_data_planes
static void free_data_planes(AVAudioFifo *afifo, void **output_data)
Definition: audio_fifo.c:49
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
convert_header.str
string str
Definition: convert_header.py:20
print_audio_bytes
static void print_audio_bytes(const TestStruct *test_sample, void **data_planes, int nb_samples)
Definition: audio_fifo.c:64
av_audio_fifo_peek
int av_audio_fifo_peek(AVAudioFifo *af, void **data, int nb_samples)
Peek data from an AVAudioFifo.
Definition: audio_fifo.c:145
AV_SAMPLE_FMT_FLT
@ AV_SAMPLE_FMT_FLT
float
Definition: samplefmt.h:60
Generated on Tue Feb 28 2023 21:34:11 for FFmpeg by   doxygen 1.8.17

AltStyle によって変換されたページ (->オリジナル) /