FFmpeg coverage

Directory: ../../../ffmpeg/
File: src/tests/api/api-flac-test.c
Date: 2026-04-24 19:58:39
Exec Total Coverage
Lines: 101 154 65.6%
Functions: 5 5 100.0%
Branches: 42 74 56.8%
Line Branch Exec Source
1 /*
2 * Copyright (c) 2015 Ludmila Glinskih
3 * Copyright (c) 2001 Fabrice Bellard
4 *
5 * Permission is hereby granted, free of charge, to any person obtaining a copy
6 * of this software and associated documentation files (the "Software"), to deal
7 * in the Software without restriction, including without limitation the rights
8 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
9 * copies of the Software, and to permit persons to whom the Software is
10 * furnished to do so, subject to the following conditions:
11 *
12 * The above copyright notice and this permission notice shall be included in
13 * all copies or substantial portions of the Software.
14 *
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
18 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
21 * THE SOFTWARE.
22 */
23
24 /*
25 * FLAC codec test.
26 * Encodes raw data to FLAC format and decodes it back to raw. Compares raw-data
27 * after that.
28 */
29
30 #include "libavcodec/avcodec.h"
31 #include "libavutil/channel_layout.h"
32 #include "libavutil/common.h"
33 #include "libavutil/mem.h"
34 #include "libavutil/samplefmt.h"
35
36 #define NUMBER_OF_AUDIO_FRAMES 200
37 #define NAME_BUFF_SIZE 100
38
39 /* generate i-th frame of test audio */
40 3200 static int generate_raw_frame(uint16_t *frame_data, int i, int sample_rate,
41 int channels, int frame_size)
42 {
43 int j, k;
44
45
2/2
✓ Branch 0 taken 20940800 times.
✓ Branch 1 taken 3200 times.
 20944000 for (j = 0; j < frame_size; j++) {
46 20940800 frame_data[channels * j] = 10000 * ((j / 10 * i) % 2);
47
2/2
✓ Branch 0 taken 47116800 times.
✓ Branch 1 taken 20940800 times.
 68057600 for (k = 1; k < channels; k++)
48 47116800 frame_data[channels * j + k] = frame_data[channels * j] * (k + 1);
49 }
50 3200 return 0;
51 }
52
53 16 static int init_encoder(const AVCodec *enc, AVCodecContext **enc_ctx,
54 const AVChannelLayout *ch_layout, int sample_rate)
55 {
56 AVCodecContext *ctx;
57 int result;
58 char name_buff[NAME_BUFF_SIZE];
59
60 16 av_channel_layout_describe(ch_layout, name_buff, NAME_BUFF_SIZE);
61 16 av_log(NULL, AV_LOG_INFO, "channel layout: %s, sample rate: %i\n", name_buff, sample_rate);
62
63 16 ctx = avcodec_alloc_context3(enc);
64
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 16 times.
 16 if (!ctx) {
65 ✗ av_log(NULL, AV_LOG_ERROR, "Can't allocate encoder context\n");
66 ✗ return AVERROR(ENOMEM);
67 }
68
69 16 ctx->sample_fmt = AV_SAMPLE_FMT_S16;
70 16 ctx->sample_rate = sample_rate;
71 16 av_channel_layout_copy(&ctx->ch_layout, ch_layout);
72
73 16 result = avcodec_open2(ctx, enc, NULL);
74
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 16 times.
 16 if (result < 0) {
75 ✗ av_log(ctx, AV_LOG_ERROR, "Can't open encoder\n");
76 ✗ return result;
77 }
78
79 16 *enc_ctx = ctx;
80 16 return 0;
81 }
82
83 16 static int init_decoder(const AVCodec *dec, AVCodecContext **dec_ctx,
84 const AVChannelLayout *ch_layout)
85 {
86 AVCodecContext *ctx;
87 int result;
88
89 16 ctx = avcodec_alloc_context3(dec);
90
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 16 times.
 16 if (!ctx) {
91 ✗ av_log(NULL, AV_LOG_ERROR , "Can't allocate decoder context\n");
92 ✗ return AVERROR(ENOMEM);
93 }
94
95 16 ctx->request_sample_fmt = AV_SAMPLE_FMT_S16;
96 16 av_channel_layout_copy(&ctx->ch_layout, ch_layout);
97
98 16 result = avcodec_open2(ctx, dec, NULL);
99
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 16 times.
 16 if (result < 0) {
100 ✗ av_log(ctx, AV_LOG_ERROR, "Can't open decoder\n");
101 ✗ return result;
102 }
103
104 16 *dec_ctx = ctx;
105 16 return 0;
106 }
107
108 16 static int run_test(const AVCodec *enc, const AVCodec *dec,
109 AVCodecContext *enc_ctx, AVCodecContext *dec_ctx)
110 {
111 AVPacket *enc_pkt;
112 AVFrame *in_frame, *out_frame;
113 16 uint8_t *raw_in = NULL, *raw_out = NULL;
114 16 int in_offset = 0, out_offset = 0;
115 16 int result = 0;
116 16 int i = 0;
117 int in_frame_bytes, out_frame_bytes;
118
119 16 enc_pkt = av_packet_alloc();
120
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 16 times.
 16 if (!enc_pkt) {
121 ✗ av_log(NULL, AV_LOG_ERROR, "Can't allocate output packet\n");
122 ✗ return AVERROR(ENOMEM);
123 }
124
125 16 in_frame = av_frame_alloc();
126
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 16 times.
 16 if (!in_frame) {
127 ✗ av_log(NULL, AV_LOG_ERROR, "Can't allocate input frame\n");
128 ✗ return AVERROR(ENOMEM);
129 }
130
131 16 in_frame->nb_samples = enc_ctx->frame_size;
132 16 in_frame->format = enc_ctx->sample_fmt;
133 16 result = av_channel_layout_copy(&in_frame->ch_layout, &enc_ctx->ch_layout);
134
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 16 times.
 16 if (result < 0)
135 ✗ return result;
136
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 16 times.
 16 if (av_frame_get_buffer(in_frame, 0) != 0) {
137 ✗ av_log(NULL, AV_LOG_ERROR, "Can't allocate a buffer for input frame\n");
138 ✗ return AVERROR(ENOMEM);
139 }
140
141 16 out_frame = av_frame_alloc();
142
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 16 times.
 16 if (!out_frame) {
143 ✗ av_log(NULL, AV_LOG_ERROR, "Can't allocate output frame\n");
144 ✗ return AVERROR(ENOMEM);
145 }
146
147 16 raw_in = av_malloc(in_frame->linesize[0] * NUMBER_OF_AUDIO_FRAMES);
148
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 16 times.
 16 if (!raw_in) {
149 ✗ av_log(NULL, AV_LOG_ERROR, "Can't allocate memory for raw_in\n");
150 ✗ return AVERROR(ENOMEM);
151 }
152
153 16 raw_out = av_malloc(in_frame->linesize[0] * NUMBER_OF_AUDIO_FRAMES);
154
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 16 times.
 16 if (!raw_out) {
155 ✗ av_log(NULL, AV_LOG_ERROR, "Can't allocate memory for raw_out\n");
156 ✗ return AVERROR(ENOMEM);
157 }
158
159
2/2
✓ Branch 0 taken 3200 times.
✓ Branch 1 taken 16 times.
 3216 for (i = 0; i < NUMBER_OF_AUDIO_FRAMES; i++) {
160 3200 result = av_frame_make_writable(in_frame);
161
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3200 times.
 3200 if (result < 0)
162 ✗ return result;
163
164 3200 generate_raw_frame((uint16_t*)(in_frame->data[0]), i, enc_ctx->sample_rate,
165 enc_ctx->ch_layout.nb_channels, enc_ctx->frame_size);
166 3200 in_frame_bytes = in_frame->nb_samples * in_frame->ch_layout.nb_channels * sizeof(uint16_t);
167
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3200 times.
 3200 if (in_frame_bytes > in_frame->linesize[0]) {
168 ✗ av_log(NULL, AV_LOG_ERROR, "Incorrect value of input frame linesize\n");
169 ✗ return 1;
170 }
171 3200 memcpy(raw_in + in_offset, in_frame->data[0], in_frame_bytes);
172 3200 in_offset += in_frame_bytes;
173 3200 result = avcodec_send_frame(enc_ctx, in_frame);
174
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3200 times.
 3200 if (result < 0) {
175 ✗ av_log(NULL, AV_LOG_ERROR, "Error submitting a frame for encoding\n");
176 ✗ return result;
177 }
178
179
1/2
✓ Branch 0 taken 6400 times.
✗ Branch 1 not taken.
 6400 while (result >= 0) {
180 6400 result = avcodec_receive_packet(enc_ctx, enc_pkt);
181
2/2
✓ Branch 0 taken 3200 times.
✓ Branch 1 taken 3200 times.
 6400 if (result == AVERROR(EAGAIN))
182 3200 break;
183
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 3200 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 3200 else if (result < 0 && result != AVERROR_EOF) {
184 ✗ av_log(NULL, AV_LOG_ERROR, "Error encoding audio frame\n");
185 ✗ return result;
186 }
187
188 /* if we get an encoded packet, feed it straight to the decoder */
189 3200 result = avcodec_send_packet(dec_ctx, enc_pkt);
190 3200 av_packet_unref(enc_pkt);
191
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3200 times.
 3200 if (result < 0) {
192 ✗ av_log(NULL, AV_LOG_ERROR, "Error submitting a packet for decoding\n");
193 ✗ return result;
194 }
195
196 3200 result = avcodec_receive_frame(dec_ctx, out_frame);
197
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3200 times.
 3200 if (result == AVERROR(EAGAIN)) {
198 ✗ result = 0;
199 ✗ continue;
200
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3200 times.
 3200 } else if (result == AVERROR(EOF)) {
201 ✗ result = 0;
202 ✗ break;
203
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3200 times.
 3200 } else if (result < 0) {
204 ✗ av_log(NULL, AV_LOG_ERROR, "Error decoding audio packet\n");
205 ✗ return result;
206 }
207
208
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3200 times.
 3200 if (in_frame->nb_samples != out_frame->nb_samples) {
209 ✗ av_log(NULL, AV_LOG_ERROR, "Error frames before and after decoding has different number of samples\n");
210 ✗ return AVERROR_UNKNOWN;
211 }
212
213
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 3200 times.
 3200 if (av_channel_layout_compare(&in_frame->ch_layout, &out_frame->ch_layout)) {
214 ✗ av_log(NULL, AV_LOG_ERROR, "Error frames before and after decoding has different channel layout\n");
215 ✗ return AVERROR_UNKNOWN;
216 }
217
218
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3200 times.
 3200 if (in_frame->format != out_frame->format) {
219 ✗ av_log(NULL, AV_LOG_ERROR, "Error frames before and after decoding has different sample format\n");
220 ✗ return AVERROR_UNKNOWN;
221 }
222 3200 out_frame_bytes = out_frame->nb_samples * out_frame->ch_layout.nb_channels * sizeof(uint16_t);
223
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3200 times.
 3200 if (out_frame_bytes > out_frame->linesize[0]) {
224 ✗ av_log(NULL, AV_LOG_ERROR, "Incorrect value of output frame linesize\n");
225 ✗ return 1;
226 }
227 3200 memcpy(raw_out + out_offset, out_frame->data[0], out_frame_bytes);
228 3200 out_offset += out_frame_bytes;
229 }
230 }
231
232
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 16 times.
 16 if (memcmp(raw_in, raw_out, out_frame_bytes * NUMBER_OF_AUDIO_FRAMES) != 0) {
233 ✗ av_log(NULL, AV_LOG_ERROR, "Output differs\n");
234 ✗ return 1;
235 }
236
237 16 av_log(NULL, AV_LOG_INFO, "OK\n");
238
239 16 av_freep(&raw_in);
240 16 av_freep(&raw_out);
241 16 av_packet_free(&enc_pkt);
242 16 av_frame_free(&in_frame);
243 16 av_frame_free(&out_frame);
244 16 return 0;
245 }
246
247 1 int main(void)
248 {
249 1 const AVCodec *enc = NULL, *dec = NULL;
250 1 AVCodecContext *enc_ctx = NULL, *dec_ctx = NULL;
251 1 const AVChannelLayout channel_layouts[] = { AV_CHANNEL_LAYOUT_STEREO,
252 AV_CHANNEL_LAYOUT_5POINT1_BACK,
253 AV_CHANNEL_LAYOUT_SURROUND,
254 AV_CHANNEL_LAYOUT_STEREO_DOWNMIX };
255 1 int sample_rates[] = {8000, 44100, 48000, 192000};
256 int cl, sr;
257
258 1 enc = avcodec_find_encoder(AV_CODEC_ID_FLAC);
259
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
 1 if (!enc) {
260 ✗ av_log(NULL, AV_LOG_ERROR, "Can't find encoder\n");
261 ✗ return 1;
262 }
263
264 1 dec = avcodec_find_decoder(AV_CODEC_ID_FLAC);
265
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
 1 if (!dec) {
266 ✗ av_log(NULL, AV_LOG_ERROR, "Can't find decoder\n");
267 ✗ return 1;
268 }
269
270
2/2
✓ Branch 0 taken 4 times.
✓ Branch 1 taken 1 times.
 5 for (cl = 0; cl < FF_ARRAY_ELEMS(channel_layouts); cl++) {
271
2/2
✓ Branch 0 taken 16 times.
✓ Branch 1 taken 4 times.
 20 for (sr = 0; sr < FF_ARRAY_ELEMS(sample_rates); sr++) {
272
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 16 times.
 16 if (init_encoder(enc, &enc_ctx, &channel_layouts[cl], sample_rates[sr]) != 0)
273 ✗ return 1;
274
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 16 times.
 16 if (init_decoder(dec, &dec_ctx, &channel_layouts[cl]) != 0)
275 ✗ return 1;
276
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 16 times.
 16 if (run_test(enc, dec, enc_ctx, dec_ctx) != 0)
277 ✗ return 1;
278 16 avcodec_free_context(&enc_ctx);
279 16 avcodec_free_context(&dec_ctx);
280 }
281 }
282
283 1 return 0;
284 }
285