FFmpeg  4.4
api-flac-test.c
Go to the documentation of this file.
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 */
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 
51 static int init_encoder(AVCodec *enc, AVCodecContext **enc_ctx,
52  int64_t ch_layout, int sample_rate)
53 {
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 
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 
82  int64_t ch_layout)
83 {
85  int result;
86 
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 
108 static int run_test(AVCodec *enc, AVCodec *dec, AVCodecContext *enc_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 
245 int main(void)
246 {
247  AVCodec *enc = NULL, *dec = NULL;
248  AVCodecContext *enc_ctx = NULL, *dec_ctx = NULL;
250  int sample_rates[] = {8000, 44100, 48000, 192000};
251  int cl, sr;
252 
254  if (!enc) {
255  av_log(NULL, AV_LOG_ERROR, "Can't find encoder\n");
256  return 1;
257  }
258 
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);
275  }
276  }
277 
278  return 0;
279 }
static int generate_raw_frame(uint16_t *frame_data, int i, int sample_rate, int channels, int frame_size)
Definition: api-flac-test.c:38
#define NUMBER_OF_AUDIO_FRAMES
Definition: api-flac-test.c:34
static int init_encoder(AVCodec *enc, AVCodecContext **enc_ctx, int64_t ch_layout, int sample_rate)
Definition: api-flac-test.c:51
int main(void)
static int init_decoder(AVCodec *dec, AVCodecContext **dec_ctx, int64_t ch_layout)
Definition: api-flac-test.c:81
#define NAME_BUFF_SIZE
Definition: api-flac-test.c:35
static int run_test(AVCodec *enc, AVCodec *dec, AVCodecContext *enc_ctx, AVCodecContext *dec_ctx)
channels
Definition: aptx.h:33
uint8_t
Libavcodec external API header.
common internal and external API header
#define NULL
Definition: coverity.c:32
static const uint16_t channel_layouts[7]
Definition: dca_lbr.c:114
sample_rates
sample_rate
static AVCodecContext * dec_ctx
#define AV_CH_LAYOUT_STEREO_DOWNMIX
#define AV_CH_LAYOUT_SURROUND
void av_get_channel_layout_string(char *buf, int buf_size, int nb_channels, uint64_t channel_layout)
Return a description of a channel layout.
#define AV_CH_LAYOUT_STEREO
#define AV_CH_LAYOUT_5POINT1_BACK
int attribute_align_arg avcodec_open2(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options)
Initialize the AVCodecContext to use the given AVCodec.
Definition: avcodec.c:144
AVCodec * avcodec_find_decoder(enum AVCodecID id)
Find a registered decoder with a matching codec ID.
Definition: allcodecs.c:946
AVCodec * avcodec_find_encoder(enum AVCodecID id)
Find a registered encoder with a matching codec ID.
Definition: allcodecs.c:941
AVCodecContext * avcodec_alloc_context3(const AVCodec *codec)
Allocate an AVCodecContext and set its fields to default values.
Definition: options.c:173
void avcodec_free_context(AVCodecContext **avctx)
Free the codec context and everything associated with it and write NULL to the provided pointer.
Definition: options.c:188
@ AV_CODEC_ID_FLAC
Definition: codec_id.h:436
int avcodec_receive_frame(AVCodecContext *avctx, AVFrame *frame)
Return decoded output data from a decoder.
Definition: decode.c:643
int avcodec_send_packet(AVCodecContext *avctx, const AVPacket *avpkt)
Supply raw packet data as input to a decoder.
Definition: decode.c:580
int avcodec_receive_packet(AVCodecContext *avctx, AVPacket *avpkt)
Read encoded data from the encoder.
Definition: encode.c:395
int avcodec_send_frame(AVCodecContext *avctx, const AVFrame *frame)
Supply a raw video or audio frame to the encoder.
Definition: encode.c:364
void av_packet_free(AVPacket **pkt)
Free the packet, if the packet is reference counted, it will be unreferenced first.
Definition: avpacket.c:75
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:634
AVPacket * av_packet_alloc(void)
Allocate an AVPacket and set its fields to default values.
Definition: avpacket.c:64
#define AVERROR_UNKNOWN
Unknown error, typically from an external library.
Definition: error.h:71
#define AVERROR_EOF
End of file.
Definition: error.h:55
#define AVERROR(e)
Definition: error.h:43
int av_frame_get_buffer(AVFrame *frame, int align)
Allocate new buffer(s) for audio or video data.
Definition: frame.c:337
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:203
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:190
int av_frame_make_writable(AVFrame *frame)
Ensure that the frame data is writable, avoiding data copy if possible.
Definition: frame.c:611
#define AV_LOG_INFO
Standard information.
Definition: log.h:205
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
@ AV_SAMPLE_FMT_S16
signed 16 bits
Definition: samplefmt.h:61
int i
Definition: input.c:407
int frame_size
Definition: mxfenc.c:2206
#define FF_ARRAY_ELEMS(a)
main external API structure.
Definition: avcodec.h:536
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1204
int sample_rate
samples per second
Definition: avcodec.h:1196
int channels
number of audio channels
Definition: avcodec.h:1197
uint64_t channel_layout
Audio channel layout.
Definition: avcodec.h:1247
int frame_size
Number of samples per channel in an audio frame.
Definition: avcodec.h:1216
AVCodec.
Definition: codec.h:197
This structure describes decoded (raw) audio or video data.
Definition: frame.h:318
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:384
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:332
int channels
number of audio channels, only used for audio.
Definition: frame.h:624
uint64_t channel_layout
Channel layout of the audio data.
Definition: frame.h:495
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:349
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames,...
Definition: frame.h:391
This structure stores compressed data.
Definition: packet.h:346
#define av_freep(p)
#define av_malloc(s)
#define av_log(a,...)
AVFormatContext * ctx
Definition: movenc.c:48