Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

  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. 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_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_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_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 * av_frame_get_channels(in_frame) * 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 * av_frame_get_channels(out_frame) * 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_free_packet(&enc_pkt);
  210.     }
  211.  
  212.     if (memcmp(raw_in, raw_out, out_frame_bytes * NUMBER_OF_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.     avcodec_register_all();
  249.  
  250.     enc = avcodec_find_encoder(AV_CODEC_ID_FLAC);
  251.     if (!enc) {
  252.         av_log(NULL, AV_LOG_ERROR, "Can't find encoder\n");
  253.         return 1;
  254.     }
  255.  
  256.     dec = avcodec_find_decoder(AV_CODEC_ID_FLAC);
  257.     if (!dec) {
  258.         av_log(NULL, AV_LOG_ERROR, "Can't find decoder\n");
  259.         return 1;
  260.     }
  261.  
  262.     for (cl = 0; cl < FF_ARRAY_ELEMS(channel_layouts); cl++) {
  263.         for (sr = 0; sr < FF_ARRAY_ELEMS(sample_rates); sr++) {
  264.             if (init_encoder(enc, &enc_ctx, channel_layouts[cl], sample_rates[sr]) != 0)
  265.                 return 1;
  266.             if (init_decoder(dec, &dec_ctx, channel_layouts[cl]) != 0)
  267.                 return 1;
  268.             if (run_test(enc, dec, enc_ctx, dec_ctx) != 0)
  269.                 return 1;
  270.             close_encoder(&enc_ctx);
  271.             close_decoder(&dec_ctx);
  272.         }
  273.     }
  274.  
  275.     return 0;
  276. }
  277.