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/common.h"
32 #include "libavutil/samplefmt.h"
33
34 #define NUMBER_OF_AUDIO_FRAMES 200
35 #define NAME_BUFF_SIZE 100
36
37 /* generate i-th frame of test audio */
generate_raw_frame(uint16_t * frame_data,int i,int sample_rate,int channels,int frame_size)38 static int generate_raw_frame(uint16_t *frame_data, int i, int sample_rate,
39 int channels, int frame_size)
40 {
41 int j, k;
42
43 for (j = 0; j < frame_size; j++) {
44 frame_data[channels * j] = 10000 * ((j / 10 * i) % 2);
45 for (k = 1; k < channels; k++)
46 frame_data[channels * j + k] = frame_data[channels * j] * (k + 1);
47 }
48 return 0;
49 }
50
init_encoder(AVCodec * enc,AVCodecContext ** enc_ctx,int64_t ch_layout,int sample_rate)51 static int init_encoder(AVCodec *enc, AVCodecContext **enc_ctx,
52 int64_t ch_layout, int sample_rate)
53 {
54 AVCodecContext *ctx;
55 int result;
56 char name_buff[NAME_BUFF_SIZE];
57
58 av_get_channel_layout_string(name_buff, NAME_BUFF_SIZE, 0, ch_layout);
59 av_log(NULL, AV_LOG_INFO, "channel layout: %s, sample rate: %i\n", name_buff, sample_rate);
60
61 ctx = avcodec_alloc_context3(enc);
62 if (!ctx) {
63 av_log(NULL, AV_LOG_ERROR, "Can't allocate encoder context\n");
64 return AVERROR(ENOMEM);
65 }
66
67 ctx->sample_fmt = AV_SAMPLE_FMT_S16;
68 ctx->sample_rate = sample_rate;
69 ctx->channel_layout = ch_layout;
70
71 result = avcodec_open2(ctx, enc, NULL);
72 if (result < 0) {
73 av_log(ctx, AV_LOG_ERROR, "Can't open encoder\n");
74 return result;
75 }
76
77 *enc_ctx = ctx;
78 return 0;
79 }
80
init_decoder(AVCodec * dec,AVCodecContext ** dec_ctx,int64_t ch_layout)81 static int init_decoder(AVCodec *dec, AVCodecContext **dec_ctx,
82 int64_t ch_layout)
83 {
84 AVCodecContext *ctx;
85 int result;
86
87 ctx = avcodec_alloc_context3(dec);
88 if (!ctx) {
89 av_log(NULL, AV_LOG_ERROR , "Can't allocate decoder context\n");
90 return AVERROR(ENOMEM);
91 }
92
93 ctx->request_sample_fmt = AV_SAMPLE_FMT_S16;
94 /* XXX: FLAC ignores it for some reason */
95 ctx->request_channel_layout = ch_layout;
96 ctx->channel_layout = ch_layout;
97
98 result = avcodec_open2(ctx, dec, NULL);
99 if (result < 0) {
100 av_log(ctx, AV_LOG_ERROR, "Can't open decoder\n");
101 return result;
102 }
103
104 *dec_ctx = ctx;
105 return 0;
106 }
107
run_test(AVCodec * enc,AVCodec * dec,AVCodecContext * enc_ctx,AVCodecContext * dec_ctx)108 static int run_test(AVCodec *enc, AVCodec *dec, AVCodecContext *enc_ctx,
109 AVCodecContext *dec_ctx)
110 {
111 AVPacket *enc_pkt;
112 AVFrame *in_frame, *out_frame;
113 uint8_t *raw_in = NULL, *raw_out = NULL;
114 int in_offset = 0, out_offset = 0;
115 int result = 0;
116 int i = 0;
117 int in_frame_bytes, out_frame_bytes;
118
119 enc_pkt = av_packet_alloc();
120 if (!enc_pkt) {
121 av_log(NULL, AV_LOG_ERROR, "Can't allocate output packet\n");
122 return AVERROR(ENOMEM);
123 }
124
125 in_frame = av_frame_alloc();
126 if (!in_frame) {
127 av_log(NULL, AV_LOG_ERROR, "Can't allocate input frame\n");
128 return AVERROR(ENOMEM);
129 }
130
131 in_frame->nb_samples = enc_ctx->frame_size;
132 in_frame->format = enc_ctx->sample_fmt;
133 in_frame->channel_layout = enc_ctx->channel_layout;
134 if (av_frame_get_buffer(in_frame, 0) != 0) {
135 av_log(NULL, AV_LOG_ERROR, "Can't allocate a buffer for input frame\n");
136 return AVERROR(ENOMEM);
137 }
138
139 out_frame = av_frame_alloc();
140 if (!out_frame) {
141 av_log(NULL, AV_LOG_ERROR, "Can't allocate output frame\n");
142 return AVERROR(ENOMEM);
143 }
144
145 raw_in = av_malloc(in_frame->linesize[0] * NUMBER_OF_AUDIO_FRAMES);
146 if (!raw_in) {
147 av_log(NULL, AV_LOG_ERROR, "Can't allocate memory for raw_in\n");
148 return AVERROR(ENOMEM);
149 }
150
151 raw_out = av_malloc(in_frame->linesize[0] * NUMBER_OF_AUDIO_FRAMES);
152 if (!raw_out) {
153 av_log(NULL, AV_LOG_ERROR, "Can't allocate memory for raw_out\n");
154 return AVERROR(ENOMEM);
155 }
156
157 for (i = 0; i < NUMBER_OF_AUDIO_FRAMES; i++) {
158 result = av_frame_make_writable(in_frame);
159 if (result < 0)
160 return result;
161
162 generate_raw_frame((uint16_t*)(in_frame->data[0]), i, enc_ctx->sample_rate,
163 enc_ctx->channels, enc_ctx->frame_size);
164 in_frame_bytes = in_frame->nb_samples * in_frame->channels * sizeof(uint16_t);
165 if (in_frame_bytes > in_frame->linesize[0]) {
166 av_log(NULL, AV_LOG_ERROR, "Incorrect value of input frame linesize\n");
167 return 1;
168 }
169 memcpy(raw_in + in_offset, in_frame->data[0], in_frame_bytes);
170 in_offset += in_frame_bytes;
171 result = avcodec_send_frame(enc_ctx, in_frame);
172 if (result < 0) {
173 av_log(NULL, AV_LOG_ERROR, "Error submitting a frame for encoding\n");
174 return result;
175 }
176
177 while (result >= 0) {
178 result = avcodec_receive_packet(enc_ctx, enc_pkt);
179 if (result == AVERROR(EAGAIN))
180 break;
181 else if (result < 0 && result != AVERROR_EOF) {
182 av_log(NULL, AV_LOG_ERROR, "Error encoding audio frame\n");
183 return result;
184 }
185
186 /* if we get an encoded packet, feed it straight to the decoder */
187 result = avcodec_send_packet(dec_ctx, enc_pkt);
188 av_packet_unref(enc_pkt);
189 if (result < 0) {
190 av_log(NULL, AV_LOG_ERROR, "Error submitting a packet for decoding\n");
191 return result;
192 }
193
194 result = avcodec_receive_frame(dec_ctx, out_frame);
195 if (result == AVERROR(EAGAIN)) {
196 result = 0;
197 continue;
198 } else if (result == AVERROR(EOF)) {
199 result = 0;
200 break;
201 } else if (result < 0) {
202 av_log(NULL, AV_LOG_ERROR, "Error decoding audio packet\n");
203 return result;
204 }
205
206 if (in_frame->nb_samples != out_frame->nb_samples) {
207 av_log(NULL, AV_LOG_ERROR, "Error frames before and after decoding has different number of samples\n");
208 return AVERROR_UNKNOWN;
209 }
210
211 if (in_frame->channel_layout != out_frame->channel_layout) {
212 av_log(NULL, AV_LOG_ERROR, "Error frames before and after decoding has different channel layout\n");
213 return AVERROR_UNKNOWN;
214 }
215
216 if (in_frame->format != out_frame->format) {
217 av_log(NULL, AV_LOG_ERROR, "Error frames before and after decoding has different sample format\n");
218 return AVERROR_UNKNOWN;
219 }
220 out_frame_bytes = out_frame->nb_samples * out_frame->channels * sizeof(uint16_t);
221 if (out_frame_bytes > out_frame->linesize[0]) {
222 av_log(NULL, AV_LOG_ERROR, "Incorrect value of output frame linesize\n");
223 return 1;
224 }
225 memcpy(raw_out + out_offset, out_frame->data[0], out_frame_bytes);
226 out_offset += out_frame_bytes;
227 }
228 }
229
230 if (memcmp(raw_in, raw_out, out_frame_bytes * NUMBER_OF_AUDIO_FRAMES) != 0) {
231 av_log(NULL, AV_LOG_ERROR, "Output differs\n");
232 return 1;
233 }
234
235 av_log(NULL, AV_LOG_INFO, "OK\n");
236
237 av_freep(&raw_in);
238 av_freep(&raw_out);
239 av_packet_free(&enc_pkt);
240 av_frame_free(&in_frame);
241 av_frame_free(&out_frame);
242 return 0;
243 }
244
main(void)245 int main(void)
246 {
247 AVCodec *enc = NULL, *dec = NULL;
248 AVCodecContext *enc_ctx = NULL, *dec_ctx = NULL;
249 uint64_t channel_layouts[] = {AV_CH_LAYOUT_STEREO, AV_CH_LAYOUT_5POINT1_BACK, AV_CH_LAYOUT_SURROUND, AV_CH_LAYOUT_STEREO_DOWNMIX};
250 int sample_rates[] = {8000, 44100, 48000, 192000};
251 int cl, sr;
252
253 enc = avcodec_find_encoder(AV_CODEC_ID_FLAC);
254 if (!enc) {
255 av_log(NULL, AV_LOG_ERROR, "Can't find encoder\n");
256 return 1;
257 }
258
259 dec = avcodec_find_decoder(AV_CODEC_ID_FLAC);
260 if (!dec) {
261 av_log(NULL, AV_LOG_ERROR, "Can't find decoder\n");
262 return 1;
263 }
264
265 for (cl = 0; cl < FF_ARRAY_ELEMS(channel_layouts); cl++) {
266 for (sr = 0; sr < FF_ARRAY_ELEMS(sample_rates); sr++) {
267 if (init_encoder(enc, &enc_ctx, channel_layouts[cl], sample_rates[sr]) != 0)
268 return 1;
269 if (init_decoder(dec, &dec_ctx, channel_layouts[cl]) != 0)
270 return 1;
271 if (run_test(enc, dec, enc_ctx, dec_ctx) != 0)
272 return 1;
273 avcodec_free_context(&enc_ctx);
274 avcodec_free_context(&dec_ctx);
275 }
276 }
277
278 return 0;
279 }
280