git.sesse.net Git - ffmpeg/blob - 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/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 {
  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
  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
 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 got_output = 0;
 117     int i = 0;
 118     int in_frame_bytes, out_frame_bytes;
 119
 120     in_frame = av_frame_alloc();
 121     if (!in_frame) {
 122         av_log(NULL, AV_LOG_ERROR, "Can't allocate input frame\n");
 123         return AVERROR(ENOMEM);
 124     }
 125
 126     in_frame->nb_samples = enc_ctx->frame_size;
 127     in_frame->format = enc_ctx->sample_fmt;
 128     in_frame->channel_layout = enc_ctx->channel_layout;
 129     if (av_frame_get_buffer(in_frame, 32) != 0) {
 130         av_log(NULL, AV_LOG_ERROR, "Can't allocate a buffer for input frame\n");
 131         return AVERROR(ENOMEM);
 132     }
 133
 134     out_frame = av_frame_alloc();
 135     if (!out_frame) {
 136         av_log(NULL, AV_LOG_ERROR, "Can't allocate output frame\n");
 137         return AVERROR(ENOMEM);
 138     }
 139
 140     raw_in = av_malloc(in_frame->linesize[0] * NUMBER_OF_AUDIO_FRAMES);
 141     if (!raw_in) {
 142         av_log(NULL, AV_LOG_ERROR, "Can't allocate memory for raw_in\n");
 143         return AVERROR(ENOMEM);
 144     }
 145
 146     raw_out = av_malloc(in_frame->linesize[0] * NUMBER_OF_AUDIO_FRAMES);
 147     if (!raw_out) {
 148         av_log(NULL, AV_LOG_ERROR, "Can't allocate memory for raw_out\n");
 149         return AVERROR(ENOMEM);
 150     }
 151
 152     for (i = 0; i < NUMBER_OF_AUDIO_FRAMES; i++) {
 153         av_init_packet(&enc_pkt);
 154         enc_pkt.data = NULL;
 155         enc_pkt.size = 0;
 156
 157         generate_raw_frame((uint16_t*)(in_frame->data[0]), i, enc_ctx->sample_rate,
 158                            enc_ctx->channels, enc_ctx->frame_size);
 159         in_frame_bytes = in_frame->nb_samples * in_frame->channels * sizeof(uint16_t);
 160         if (in_frame_bytes > in_frame->linesize[0]) {
 161             av_log(NULL, AV_LOG_ERROR, "Incorrect value of input frame linesize\n");
 162             return 1;
 163         }
 164         memcpy(raw_in + in_offset, in_frame->data[0], in_frame_bytes);
 165         in_offset += in_frame_bytes;
 166         result = avcodec_encode_audio2(enc_ctx, &enc_pkt, in_frame, &got_output);
 167         if (result < 0) {
 168             av_log(NULL, AV_LOG_ERROR, "Error encoding audio frame\n");
 169             return result;
 170         }
 171
 172         /* if we get an encoded packet, feed it straight to the decoder */
 173         if (got_output) {
 174             result = avcodec_decode_audio4(dec_ctx, out_frame, &got_output, &enc_pkt);
 175             if (result < 0) {
 176                 av_log(NULL, AV_LOG_ERROR, "Error decoding audio packet\n");
 177                 return result;
 178             }
 179
 180             if (got_output) {
 181                 if (result != enc_pkt.size) {
 182                     av_log(NULL, AV_LOG_INFO, "Decoder consumed only part of a packet, it is allowed to do so -- need to update this test\n");
 183                     return AVERROR_UNKNOWN;
 184                 }
 185
 186                 if (in_frame->nb_samples != out_frame->nb_samples) {
 187                     av_log(NULL, AV_LOG_ERROR, "Error frames before and after decoding has different number of samples\n");
 188                     return AVERROR_UNKNOWN;
 189                 }
 190
 191                 if (in_frame->channel_layout != out_frame->channel_layout) {
 192                     av_log(NULL, AV_LOG_ERROR, "Error frames before and after decoding has different channel layout\n");
 193                     return AVERROR_UNKNOWN;
 194                 }
 195
 196                 if (in_frame->format != out_frame->format) {
 197                     av_log(NULL, AV_LOG_ERROR, "Error frames before and after decoding has different sample format\n");
 198                     return AVERROR_UNKNOWN;
 199                 }
 200                 out_frame_bytes = out_frame->nb_samples * out_frame->channels * sizeof(uint16_t);
 201                 if (out_frame_bytes > out_frame->linesize[0]) {
 202                     av_log(NULL, AV_LOG_ERROR, "Incorrect value of output frame linesize\n");
 203                     return 1;
 204                 }
 205                 memcpy(raw_out + out_offset, out_frame->data[0], out_frame_bytes);
 206                 out_offset += out_frame_bytes;
 207             }
 208         }
 209         av_packet_unref(&enc_pkt);
 210     }
 211
 212     if (memcmp(raw_in, raw_out, out_frame_bytes * NUMBER_OF_AUDIO_FRAMES) != 0) {
 213         av_log(NULL, AV_LOG_ERROR, "Output differs\n");
 214         return 1;
 215     }
 216
 217     av_log(NULL, AV_LOG_INFO, "OK\n");
 218
 219     av_freep(&raw_in);
 220     av_freep(&raw_out);
 221     av_frame_free(&in_frame);
 222     av_frame_free(&out_frame);
 223     return 0;
 224 }
 225
 226 static int close_encoder(AVCodecContext **enc_ctx)
 227 {
 228     avcodec_close(*enc_ctx);
 229     av_freep(enc_ctx);
 230     return 0;
 231 }
 232
 233 static int close_decoder(AVCodecContext **dec_ctx)
 234 {
 235     avcodec_close(*dec_ctx);
 236     av_freep(dec_ctx);
 237     return 0;
 238 }
 239
 240 int main(void)
 241 {
 242     AVCodec *enc = NULL, *dec = NULL;
 243     AVCodecContext *enc_ctx = NULL, *dec_ctx = NULL;
 244     uint64_t channel_layouts[] = {AV_CH_LAYOUT_STEREO, AV_CH_LAYOUT_5POINT1_BACK, AV_CH_LAYOUT_SURROUND, AV_CH_LAYOUT_STEREO_DOWNMIX};
 245     int sample_rates[] = {8000, 44100, 48000, 192000};
 246     int cl, sr;
 247
 248     enc = avcodec_find_encoder(AV_CODEC_ID_FLAC);
 249     if (!enc) {
 250         av_log(NULL, AV_LOG_ERROR, "Can't find encoder\n");
 251         return 1;
 252     }
 253
 254     dec = avcodec_find_decoder(AV_CODEC_ID_FLAC);
 255     if (!dec) {
 256         av_log(NULL, AV_LOG_ERROR, "Can't find decoder\n");
 257         return 1;
 258     }
 259
 260     for (cl = 0; cl < FF_ARRAY_ELEMS(channel_layouts); cl++) {
 261         for (sr = 0; sr < FF_ARRAY_ELEMS(sample_rates); sr++) {
 262             if (init_encoder(enc, &enc_ctx, channel_layouts[cl], sample_rates[sr]) != 0)
 263                 return 1;
 264             if (init_decoder(dec, &dec_ctx, channel_layouts[cl]) != 0)
 265                 return 1;
 266             if (run_test(enc, dec, enc_ctx, dec_ctx) != 0)
 267                 return 1;
 268             close_encoder(&enc_ctx);
 269             close_decoder(&dec_ctx);
 270         }
 271     }
 272
 273     return 0;
 274 }