tests/api/api-flac-test.c

   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 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     for (j = 0; j < frame_size; j++) {
  46         frame_data[channels * j] = 10000 * ((j / 10 * i) % 2);
  47         for (k = 1; k < channels; k++)
  48             frame_data[channels * j + k] = frame_data[channels * j] * (k + 1);
  49     }
  50     return 0;
  51 }
  52
  53 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     av_channel_layout_describe(ch_layout, name_buff, NAME_BUFF_SIZE);
  61     av_log(NULL, AV_LOG_INFO, "channel layout: %s, sample rate: %i\n", name_buff, sample_rate);
  62
  63     ctx = avcodec_alloc_context3(enc);
  64     if (!ctx) {
  65         av_log(NULL, AV_LOG_ERROR, "Can't allocate encoder context\n");
  66         return AVERROR(ENOMEM);
  67     }
  68
  69     ctx->sample_fmt = AV_SAMPLE_FMT_S16;
  70     ctx->sample_rate = sample_rate;
  71     av_channel_layout_copy(&ctx->ch_layout, ch_layout);
  72
  73     result = avcodec_open2(ctx, enc, NULL);
  74     if (result < 0) {
  75         av_log(ctx, AV_LOG_ERROR, "Can't open encoder\n");
  76         return result;
  77     }
  78
  79     *enc_ctx = ctx;
  80     return 0;
  81 }
  82
  83 static int init_decoder(const AVCodec *dec, AVCodecContext **dec_ctx,
  84                         const AVChannelLayout *ch_layout)
  85 {
  86     AVCodecContext *ctx;
  87     int result;
  88
  89     ctx = avcodec_alloc_context3(dec);
  90     if (!ctx) {
  91         av_log(NULL, AV_LOG_ERROR , "Can't allocate decoder context\n");
  92         return AVERROR(ENOMEM);
  93     }
  94
  95     ctx->request_sample_fmt = AV_SAMPLE_FMT_S16;
  96     av_channel_layout_copy(&ctx->ch_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(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     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     result = av_channel_layout_copy(&in_frame->ch_layout, &enc_ctx->ch_layout);
 134     if (result < 0)
 135         return result;
 136     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     out_frame = av_frame_alloc();
 142     if (!out_frame) {
 143         av_log(NULL, AV_LOG_ERROR, "Can't allocate output frame\n");
 144         return AVERROR(ENOMEM);
 145     }
 146
 147     raw_in = av_malloc(in_frame->linesize[0] * NUMBER_OF_AUDIO_FRAMES);
 148     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     raw_out = av_malloc(in_frame->linesize[0] * NUMBER_OF_AUDIO_FRAMES);
 154     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     for (i = 0; i < NUMBER_OF_AUDIO_FRAMES; i++) {
 160         result = av_frame_make_writable(in_frame);
 161         if (result < 0)
 162             return result;
 163
 164         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         in_frame_bytes = in_frame->nb_samples * in_frame->ch_layout.nb_channels * sizeof(uint16_t);
 167         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         memcpy(raw_in + in_offset, in_frame->data[0], in_frame_bytes);
 172         in_offset += in_frame_bytes;
 173         result = avcodec_send_frame(enc_ctx, in_frame);
 174         if (result < 0) {
 175             av_log(NULL, AV_LOG_ERROR, "Error submitting a frame for encoding\n");
 176             return result;
 177         }
 178
 179         while (result >= 0) {
 180             result = avcodec_receive_packet(enc_ctx, enc_pkt);
 181             if (result == AVERROR(EAGAIN))
 182                 break;
 183             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             result = avcodec_send_packet(dec_ctx, enc_pkt);
 190             av_packet_unref(enc_pkt);
 191             if (result < 0) {
 192                 av_log(NULL, AV_LOG_ERROR, "Error submitting a packet for decoding\n");
 193                 return result;
 194             }
 195
 196             result = avcodec_receive_frame(dec_ctx, out_frame);
 197             if (result == AVERROR(EAGAIN)) {
 198                 result = 0;
 199                 continue;
 200             } else if (result == AVERROR(EOF)) {
 201                 result = 0;
 202                 break;
 203             } else if (result < 0) {
 204                 av_log(NULL, AV_LOG_ERROR, "Error decoding audio packet\n");
 205                 return result;
 206             }
 207
 208             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             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             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             out_frame_bytes = out_frame->nb_samples * out_frame->ch_layout.nb_channels * sizeof(uint16_t);
 223             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             memcpy(raw_out + out_offset, out_frame->data[0], out_frame_bytes);
 228             out_offset += out_frame_bytes;
 229         }
 230     }
 231
 232     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     av_log(NULL, AV_LOG_INFO, "OK\n");
 238
 239     av_freep(&raw_in);
 240     av_freep(&raw_out);
 241     av_packet_free(&enc_pkt);
 242     av_frame_free(&in_frame);
 243     av_frame_free(&out_frame);
 244     return 0;
 245 }
 246
 247 int main(void)
 248 {
 249     const AVCodec *enc = NULL, *dec = NULL;
 250     AVCodecContext *enc_ctx = NULL, *dec_ctx = NULL;
 251     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     int sample_rates[] = {8000, 44100, 48000, 192000};
 256     int cl, sr;
 257
 258     enc = avcodec_find_encoder(AV_CODEC_ID_FLAC);
 259     if (!enc) {
 260         av_log(NULL, AV_LOG_ERROR, "Can't find encoder\n");
 261         return 1;
 262     }
 263
 264     dec = avcodec_find_decoder(AV_CODEC_ID_FLAC);
 265     if (!dec) {
 266         av_log(NULL, AV_LOG_ERROR, "Can't find decoder\n");
 267         return 1;
 268     }
 269
 270     for (cl = 0; cl < FF_ARRAY_ELEMS(channel_layouts); cl++) {
 271         for (sr = 0; sr < FF_ARRAY_ELEMS(sample_rates); sr++) {
 272             if (init_encoder(enc, &enc_ctx, &channel_layouts[cl], sample_rates[sr]) != 0)
 273                 return 1;
 274             if (init_decoder(dec, &dec_ctx, &channel_layouts[cl]) != 0)
 275                 return 1;
 276             if (run_test(enc, dec, enc_ctx, dec_ctx) != 0)
 277                 return 1;
 278             avcodec_free_context(&enc_ctx);
 279             avcodec_free_context(&dec_ctx);
 280         }
 281     }
 282
 283     return 0;
 284 }