LCOV - code coverage report
Current view: top level - src/tests/api - api-flac-test.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 103 146 70.5 %
Date: 2017-04-24 03:48:25 Functions: 7 7 100.0 %

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

Generated by: LCOV version 1.13