LCOV - code coverage report
Current view: top level - libavcodec/tests - dct.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 208 251 82.9 %
Date: 2017-10-24 00:14:43 Functions: 7 8 87.5 %

          Line data    Source code
       1             : /*
       2             :  * (c) 2001 Fabrice Bellard
       3             :  *     2007 Marc Hoffman <marc.hoffman@analog.com>
       4             :  *
       5             :  * This file is part of FFmpeg.
       6             :  *
       7             :  * FFmpeg is free software; you can redistribute it and/or
       8             :  * modify it under the terms of the GNU Lesser General Public
       9             :  * License as published by the Free Software Foundation; either
      10             :  * version 2.1 of the License, or (at your option) any later version.
      11             :  *
      12             :  * FFmpeg is distributed in the hope that it will be useful,
      13             :  * but WITHOUT ANY WARRANTY; without even the implied warranty of
      14             :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      15             :  * Lesser General Public License for more details.
      16             :  *
      17             :  * You should have received a copy of the GNU Lesser General Public
      18             :  * License along with FFmpeg; if not, write to the Free Software
      19             :  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
      20             :  */
      21             : 
      22             : /**
      23             :  * @file
      24             :  * DCT test (c) 2001 Fabrice Bellard
      25             :  * Started from sample code by Juan J. Sierralta P.
      26             :  */
      27             : 
      28             : #include "config.h"
      29             : #include <stdlib.h>
      30             : #include <stdio.h>
      31             : #include <string.h>
      32             : #if HAVE_UNISTD_H
      33             : #include <unistd.h>
      34             : #endif
      35             : #include <math.h>
      36             : 
      37             : #include "libavutil/cpu.h"
      38             : #include "libavutil/common.h"
      39             : #include "libavutil/internal.h"
      40             : #include "libavutil/lfg.h"
      41             : #include "libavutil/time.h"
      42             : 
      43             : #include "libavcodec/dct.h"
      44             : #include "libavcodec/idctdsp.h"
      45             : #include "libavcodec/simple_idct.h"
      46             : #include "libavcodec/xvididct.h"
      47             : #include "libavcodec/aandcttab.h"
      48             : #include "libavcodec/faandct.h"
      49             : #include "libavcodec/faanidct.h"
      50             : #include "libavcodec/dctref.h"
      51             : 
      52             : struct algo {
      53             :     const char *name;
      54             :     void (*func)(int16_t *block);
      55             :     enum idct_permutation_type perm_type;
      56             :     int cpu_flag;
      57             :     int nonspec;
      58             : };
      59             : 
      60             : static const struct algo fdct_tab[] = {
      61             :     { "REF-DBL",     ff_ref_fdct,          FF_IDCT_PERM_NONE },
      62             :     { "IJG-AAN-INT", ff_fdct_ifast,        FF_IDCT_PERM_NONE },
      63             :     { "IJG-LLM-INT", ff_jpeg_fdct_islow_8, FF_IDCT_PERM_NONE },
      64             : #if CONFIG_FAANDCT
      65             :     { "FAAN",        ff_faandct,           FF_IDCT_PERM_NONE },
      66             : #endif /* CONFIG_FAANDCT */
      67             : };
      68             : 
      69       60000 : static void ff_prores_idct_wrap(int16_t *dst){
      70       60000 :     LOCAL_ALIGNED(16, int16_t, qmat, [64]);
      71             :     int i;
      72             : 
      73     3900000 :     for(i=0; i<64; i++){
      74     3840000 :         qmat[i]=4;
      75             :     }
      76       60000 :     ff_prores_idct(dst, qmat);
      77     3900000 :     for(i=0; i<64; i++) {
      78     3840000 :          dst[i] -= 512;
      79             :     }
      80       60000 : }
      81             : 
      82             : static const struct algo idct_tab[] = {
      83             :     { "REF-DBL",     ff_ref_idct,          FF_IDCT_PERM_NONE },
      84             :     { "INT",         ff_j_rev_dct,         FF_IDCT_PERM_LIBMPEG2 },
      85             :     { "SIMPLE-C",    ff_simple_idct_8,     FF_IDCT_PERM_NONE },
      86             :     { "SIMPLE-C10",  ff_simple_idct_10,    FF_IDCT_PERM_NONE },
      87             :     { "SIMPLE-C12",  ff_simple_idct_12,    FF_IDCT_PERM_NONE, 0, 1 },
      88             :     { "PR-C",        ff_prores_idct_wrap,  FF_IDCT_PERM_NONE, 0, 1 },
      89             : #if CONFIG_FAANIDCT
      90             :     { "FAANI",       ff_faanidct,          FF_IDCT_PERM_NONE },
      91             : #endif /* CONFIG_FAANIDCT */
      92             : #if CONFIG_MPEG4_DECODER
      93             :     { "XVID",        ff_xvid_idct,         FF_IDCT_PERM_NONE, 0, 1 },
      94             : #endif /* CONFIG_MPEG4_DECODER */
      95             : };
      96             : 
      97             : #if ARCH_AARCH64
      98             : #include "aarch64/dct.c"
      99             : #elif ARCH_ARM
     100             : #include "arm/dct.c"
     101             : #elif ARCH_PPC
     102             : #include "ppc/dct.c"
     103             : #elif ARCH_X86
     104             : #include "x86/dct.c"
     105             : #else
     106             : static const struct algo fdct_tab_arch[] = { { 0 } };
     107             : static const struct algo idct_tab_arch[] = { { 0 } };
     108             : #endif
     109             : 
     110             : #define AANSCALE_BITS 12
     111             : 
     112             : #define NB_ITS 20000
     113             : #define NB_ITS_SPEED 50000
     114             : 
     115             : DECLARE_ALIGNED(16, static int16_t, block)[64];
     116             : DECLARE_ALIGNED(8,  static int16_t, block1)[64];
     117             : 
     118     1220000 : static void init_block(int16_t block[64], int test, int is_idct, AVLFG *prng, int vals)
     119             : {
     120             :     int i, j;
     121             : 
     122     1220000 :     memset(block, 0, 64 * sizeof(*block));
     123             : 
     124     1220000 :     switch (test) {
     125      360000 :     case 0:
     126    23400000 :         for (i = 0; i < 64; i++)
     127    23040000 :             block[i] = (av_lfg_get(prng) % (2*vals)) -vals;
     128      360000 :         if (is_idct) {
     129      360000 :             ff_ref_fdct(block);
     130    23400000 :             for (i = 0; i < 64; i++)
     131    23040000 :                 block[i] >>= 3;
     132             :         }
     133      360000 :         break;
     134      500000 :     case 1:
     135      500000 :         j = av_lfg_get(prng) % 10 + 1;
     136     3242825 :         for (i = 0; i < j; i++) {
     137     2742825 :             int idx = av_lfg_get(prng) % 64;
     138     2742825 :             block[idx] = av_lfg_get(prng) % (2*vals) -vals;
     139             :         }
     140      500000 :         break;
     141      360000 :     case 2:
     142      360000 :         block[ 0] = av_lfg_get(prng) % (16*vals) - (8*vals);
     143      360000 :         block[63] = (block[0] & 1) ^ 1;
     144      360000 :         break;
     145             :     }
     146     1220000 : }
     147             : 
     148     1220000 : static void permute(int16_t dst[64], const int16_t src[64],
     149             :                     enum idct_permutation_type perm_type)
     150             : {
     151             :     int i;
     152             : 
     153             : #if ARCH_X86
     154     1220000 :     if (permute_x86(dst, src, perm_type))
     155      120000 :         return;
     156             : #endif
     157             : 
     158     1100000 :     switch (perm_type) {
     159       60000 :     case FF_IDCT_PERM_LIBMPEG2:
     160     3900000 :         for (i = 0; i < 64; i++)
     161     3840000 :             dst[(i & 0x38) | ((i & 6) >> 1) | ((i & 1) << 2)] = src[i];
     162       60000 :         break;
     163           0 :     case FF_IDCT_PERM_PARTTRANS:
     164           0 :         for (i = 0; i < 64; i++)
     165           0 :             dst[(i & 0x24) | ((i & 3) << 3) | ((i >> 3) & 3)] = src[i];
     166           0 :         break;
     167      480000 :     case FF_IDCT_PERM_TRANSPOSE:
     168    31200000 :         for (i = 0; i < 64; i++)
     169    30720000 :             dst[(i>>3) | ((i<<3)&0x38)] = src[i];
     170      480000 :         break;
     171      560000 :     default:
     172    36400000 :         for (i = 0; i < 64; i++)
     173    35840000 :             dst[i] = src[i];
     174      560000 :         break;
     175             :     }
     176             : }
     177             : 
     178          61 : static int dct_error(const struct algo *dct, int test, int is_idct, int speed, const int bits)
     179             : {
     180          61 :     void (*ref)(int16_t *block) = is_idct ? ff_ref_idct : ff_ref_fdct;
     181             :     int it, i, scale;
     182             :     int err_inf, v;
     183          61 :     int64_t err2, ti, ti1, it1, err_sum = 0;
     184          61 :     int64_t sysErr[64], sysErrMax = 0;
     185          61 :     int64_t err2_matrix[64], err2_max = 0;
     186          61 :     int maxout = 0;
     187          61 :     int blockSumErrMax = 0, blockSumErr;
     188             :     AVLFG prng;
     189          61 :     const int vals=1<<bits;
     190             :     double omse, ome;
     191             :     int spec_err;
     192             : 
     193          61 :     av_lfg_init(&prng, 1);
     194             : 
     195          61 :     err_inf = 0;
     196          61 :     err2 = 0;
     197        3965 :     for (i = 0; i < 64; i++)
     198        3904 :         err2_matrix[i] = sysErr[i] = 0;
     199     1220061 :     for (it = 0; it < NB_ITS; it++) {
     200     1220000 :         init_block(block1, test, is_idct, &prng, vals);
     201     1220000 :         permute(block, block1, dct->perm_type);
     202             : 
     203     1220000 :         dct->func(block);
     204     1220000 :         emms_c();
     205             : 
     206     1220000 :         if (!strcmp(dct->name, "IJG-AAN-INT")) {
     207     1300000 :             for (i = 0; i < 64; i++) {
     208     1280000 :                 scale = 8 * (1 << (AANSCALE_BITS + 11)) / ff_aanscales[i];
     209     1280000 :                 block[i] = (block[i] * scale) >> AANSCALE_BITS;
     210             :             }
     211             :         }
     212             : 
     213     1220000 :         ref(block1);
     214     1220000 :         if (!strcmp(dct->name, "PR-SSE2"))
     215     3900000 :             for (i = 0; i < 64; i++)
     216     3840000 :                 block1[i] = av_clip(block1[i], 4-512, 1019-512);
     217             : 
     218     1220000 :         blockSumErr = 0;
     219    79300000 :         for (i = 0; i < 64; i++) {
     220    78080000 :             int err = block[i] - block1[i];
     221    78080000 :             err_sum += err;
     222    78080000 :             v = abs(err);
     223    78080000 :             if (v > err_inf)
     224          68 :                 err_inf = v;
     225    78080000 :             err2_matrix[i] += v * v;
     226    78080000 :             err2 += v * v;
     227    78080000 :             sysErr[i] += block[i] - block1[i];
     228    78080000 :             blockSumErr += v;
     229    78080000 :             if (abs(block[i]) > maxout)
     230         842 :                 maxout = abs(block[i]);
     231             :         }
     232     1220000 :         if (blockSumErrMax < blockSumErr)
     233         271 :             blockSumErrMax = blockSumErr;
     234             :     }
     235        3965 :     for (i = 0; i < 64; i++) {
     236        3904 :         sysErrMax = FFMAX(sysErrMax, FFABS(sysErr[i]));
     237        3904 :         err2_max  = FFMAX(err2_max , FFABS(err2_matrix[i]));
     238             :     }
     239             : 
     240        3965 :     for (i = 0; i < 64; i++) {
     241        3904 :         if (i % 8 == 0)
     242         488 :             printf("\n");
     243        3904 :         printf("%7d ", (int) sysErr[i]);
     244             :     }
     245          61 :     printf("\n");
     246             : 
     247          61 :     omse = (double) err2 / NB_ITS / 64;
     248          61 :     ome  = (double) err_sum / NB_ITS / 64;
     249             : 
     250          61 :     spec_err = is_idct && (err_inf > 1 || omse > 0.02 || fabs(ome) > 0.0015);
     251          61 :     if (test < 2)
     252          43 :         spec_err = is_idct && ((double) err2_max / NB_ITS > 0.06 || (double) sysErrMax / NB_ITS > 0.015);
     253             : 
     254          61 :     printf("%s %s: max_err=%d omse=%0.8f ome=%0.8f syserr=%0.8f maxout=%d blockSumErr=%d\n",
     255             :            is_idct ? "IDCT" : "DCT", dct->name, err_inf,
     256          61 :            omse, ome, (double) sysErrMax / NB_ITS,
     257             :            maxout, blockSumErrMax);
     258             : 
     259          61 :     if (spec_err && !dct->nonspec) {
     260           0 :         printf("Failed!\n");
     261           0 :         return 1;
     262             :     }
     263             : 
     264          61 :     if (!speed)
     265          61 :         return 0;
     266             : 
     267             :     /* speed test */
     268             : 
     269           0 :     init_block(block, test, is_idct, &prng, vals);
     270           0 :     permute(block1, block, dct->perm_type);
     271             : 
     272           0 :     ti = av_gettime_relative();
     273           0 :     it1 = 0;
     274             :     do {
     275           0 :         for (it = 0; it < NB_ITS_SPEED; it++) {
     276           0 :             memcpy(block, block1, sizeof(block));
     277           0 :             dct->func(block);
     278             :         }
     279           0 :         emms_c();
     280           0 :         it1 += NB_ITS_SPEED;
     281           0 :         ti1 = av_gettime_relative() - ti;
     282           0 :     } while (ti1 < 1000000);
     283             : 
     284           0 :     printf("%s %s: %0.1f kdct/s\n", is_idct ? "IDCT" : "DCT", dct->name,
     285           0 :            (double) it1 * 1000.0 / (double) ti1);
     286             : 
     287           0 :     return 0;
     288             : }
     289             : 
     290             : DECLARE_ALIGNED(8, static uint8_t, img_dest)[64];
     291             : DECLARE_ALIGNED(8, static uint8_t, img_dest1)[64];
     292             : 
     293       20000 : static void idct248_ref(uint8_t *dest, ptrdiff_t linesize, int16_t *block)
     294             : {
     295             :     static int init;
     296             :     static double c8[8][8];
     297             :     static double c4[4][4];
     298             :     double block1[64], block2[64], block3[64];
     299             :     double s, sum, v;
     300             :     int i, j, k;
     301             : 
     302       20000 :     if (!init) {
     303           1 :         init = 1;
     304             : 
     305           9 :         for (i = 0; i < 8; i++) {
     306           8 :             sum = 0;
     307          72 :             for (j = 0; j < 8; j++) {
     308          64 :                 s = (i == 0) ? sqrt(1.0 / 8.0) : sqrt(1.0 / 4.0);
     309          64 :                 c8[i][j] = s * cos(M_PI * i * (j + 0.5) / 8.0);
     310          64 :                 sum += c8[i][j] * c8[i][j];
     311             :             }
     312             :         }
     313             : 
     314           5 :         for (i = 0; i < 4; i++) {
     315           4 :             sum = 0;
     316          20 :             for (j = 0; j < 4; j++) {
     317          16 :                 s = (i == 0) ? sqrt(1.0 / 4.0) : sqrt(1.0 / 2.0);
     318          16 :                 c4[i][j] = s * cos(M_PI * i * (j + 0.5) / 4.0);
     319          16 :                 sum += c4[i][j] * c4[i][j];
     320             :             }
     321             :         }
     322             :     }
     323             : 
     324             :     /* butterfly */
     325       20000 :     s = 0.5 * sqrt(2.0);
     326      100000 :     for (i = 0; i < 4; i++) {
     327      720000 :         for (j = 0; j < 8; j++) {
     328     1280000 :             block1[8 * (2 * i) + j] =
     329     1280000 :                 (block[8 * (2 * i) + j] + block[8 * (2 * i + 1) + j]) * s;
     330     1280000 :             block1[8 * (2 * i + 1) + j] =
     331     1280000 :                 (block[8 * (2 * i) + j] - block[8 * (2 * i + 1) + j]) * s;
     332             :         }
     333             :     }
     334             : 
     335             :     /* idct8 on lines */
     336      180000 :     for (i = 0; i < 8; i++) {
     337     1440000 :         for (j = 0; j < 8; j++) {
     338     1280000 :             sum = 0;
     339    11520000 :             for (k = 0; k < 8; k++)
     340    10240000 :                 sum += c8[k][j] * block1[8 * i + k];
     341     1280000 :             block2[8 * i + j] = sum;
     342             :         }
     343             :     }
     344             : 
     345             :     /* idct4 */
     346      180000 :     for (i = 0; i < 8; i++) {
     347      800000 :         for (j = 0; j < 4; j++) {
     348             :             /* top */
     349      640000 :             sum = 0;
     350     3200000 :             for (k = 0; k < 4; k++)
     351     2560000 :                 sum += c4[k][j] * block2[8 * (2 * k) + i];
     352      640000 :             block3[8 * (2 * j) + i] = sum;
     353             : 
     354             :             /* bottom */
     355      640000 :             sum = 0;
     356     3200000 :             for (k = 0; k < 4; k++)
     357     2560000 :                 sum += c4[k][j] * block2[8 * (2 * k + 1) + i];
     358      640000 :             block3[8 * (2 * j + 1) + i] = sum;
     359             :         }
     360             :     }
     361             : 
     362             :     /* clamp and store the result */
     363      180000 :     for (i = 0; i < 8; i++) {
     364     1440000 :         for (j = 0; j < 8; j++) {
     365     1280000 :             v = block3[8 * i + j];
     366     1280000 :             if      (v < 0)   v = 0;
     367     1226527 :             else if (v > 255) v = 255;
     368     1280000 :             dest[i * linesize + j] = (int) rint(v);
     369             :         }
     370             :     }
     371       20000 : }
     372             : 
     373           1 : static void idct248_error(const char *name,
     374             :                           void (*idct248_put)(uint8_t *dest,
     375             :                                               ptrdiff_t line_size,
     376             :                                               int16_t *block),
     377             :                           int speed)
     378             : {
     379             :     int it, i, it1, ti, ti1, err_max, v;
     380             :     AVLFG prng;
     381             : 
     382           1 :     av_lfg_init(&prng, 1);
     383             : 
     384             :     /* just one test to see if code is correct (precision is less
     385             :        important here) */
     386           1 :     err_max = 0;
     387       20001 :     for (it = 0; it < NB_ITS; it++) {
     388             :         /* XXX: use forward transform to generate values */
     389     1300000 :         for (i = 0; i < 64; i++)
     390     1280000 :             block1[i] = av_lfg_get(&prng) % 256 - 128;
     391       20000 :         block1[0] += 1024;
     392             : 
     393     1300000 :         for (i = 0; i < 64; i++)
     394     1280000 :             block[i] = block1[i];
     395       20000 :         idct248_ref(img_dest1, 8, block);
     396             : 
     397     1300000 :         for (i = 0; i < 64; i++)
     398     1280000 :             block[i] = block1[i];
     399       20000 :         idct248_put(img_dest, 8, block);
     400             : 
     401     1300000 :         for (i = 0; i < 64; i++) {
     402     1280000 :             v = abs((int) img_dest[i] - (int) img_dest1[i]);
     403     1280000 :             if (v == 255)
     404           0 :                 printf("%d %d\n", img_dest[i], img_dest1[i]);
     405     1280000 :             if (v > err_max)
     406           1 :                 err_max = v;
     407             :         }
     408             : #if 0
     409             :         printf("ref=\n");
     410             :         for(i=0;i<8;i++) {
     411             :             int j;
     412             :             for(j=0;j<8;j++) {
     413             :                 printf(" %3d", img_dest1[i*8+j]);
     414             :             }
     415             :             printf("\n");
     416             :         }
     417             : 
     418             :         printf("out=\n");
     419             :         for(i=0;i<8;i++) {
     420             :             int j;
     421             :             for(j=0;j<8;j++) {
     422             :                 printf(" %3d", img_dest[i*8+j]);
     423             :             }
     424             :             printf("\n");
     425             :         }
     426             : #endif
     427             :     }
     428           1 :     printf("%s %s: err_inf=%d\n", 1 ? "IDCT248" : "DCT248", name, err_max);
     429             : 
     430           1 :     if (!speed)
     431           1 :         return;
     432             : 
     433           0 :     ti = av_gettime_relative();
     434           0 :     it1 = 0;
     435             :     do {
     436           0 :         for (it = 0; it < NB_ITS_SPEED; it++) {
     437           0 :             for (i = 0; i < 64; i++)
     438           0 :                 block[i] = block1[i];
     439           0 :             idct248_put(img_dest, 8, block);
     440             :         }
     441           0 :         emms_c();
     442           0 :         it1 += NB_ITS_SPEED;
     443           0 :         ti1 = av_gettime_relative() - ti;
     444           0 :     } while (ti1 < 1000000);
     445             : 
     446           0 :     printf("%s %s: %0.1f kdct/s\n", 1 ? "IDCT248" : "DCT248", name,
     447           0 :            (double) it1 * 1000.0 / (double) ti1);
     448             : }
     449             : 
     450           0 : static void help(void)
     451             : {
     452           0 :     printf("dct-test [-i] [<test-number>] [<bits>]\n"
     453             :            "test-number 0 -> test with random matrixes\n"
     454             :            "            1 -> test with random sparse matrixes\n"
     455             :            "            2 -> do 3. test from MPEG-4 std\n"
     456             :            "bits        Number of time domain bits to use, 8 is default\n"
     457             :            "-i          test IDCT implementations\n"
     458             :            "-4          test IDCT248 implementations\n"
     459             :            "-t          speed test\n");
     460           0 : }
     461             : 
     462             : #if !HAVE_GETOPT
     463             : #include "compat/getopt.c"
     464             : #endif
     465             : 
     466           5 : int main(int argc, char **argv)
     467             : {
     468           5 :     int test_idct = 0, test_248_dct = 0;
     469             :     int c, i;
     470           5 :     int test = 1;
     471           5 :     int speed = 0;
     472           5 :     int err = 0;
     473           5 :     int bits=8;
     474             : 
     475           5 :     ff_ref_dct_init();
     476             : 
     477             :     for (;;) {
     478          13 :         c = getopt(argc, argv, "ih4t");
     479           9 :         if (c == -1)
     480           5 :             break;
     481           4 :         switch (c) {
     482           3 :         case 'i':
     483           3 :             test_idct = 1;
     484           3 :             break;
     485           1 :         case '4':
     486           1 :             test_248_dct = 1;
     487           1 :             break;
     488           0 :         case 't':
     489           0 :             speed = 1;
     490           0 :             break;
     491           0 :         default:
     492             :         case 'h':
     493           0 :             help();
     494           0 :             return 0;
     495             :         }
     496             :     }
     497             : 
     498           5 :     if (optind < argc)
     499           3 :         test = atoi(argv[optind]);
     500           5 :     if(optind+1 < argc) bits= atoi(argv[optind+1]);
     501             : 
     502           5 :     printf("ffmpeg DCT/IDCT test\n");
     503             : 
     504           5 :     if (test_248_dct) {
     505           1 :         idct248_error("SIMPLE-C", ff_simple_idct248_put, speed);
     506             :     } else {
     507           4 :         const int cpu_flags = av_get_cpu_flags();
     508           4 :         if (test_idct) {
     509          27 :             for (i = 0; i < FF_ARRAY_ELEMS(idct_tab); i++)
     510          24 :                 err |= dct_error(&idct_tab[i], test, test_idct, speed, bits);
     511             : 
     512          33 :             for (i = 0; idct_tab_arch[i].name; i++)
     513          30 :                 if (!(~cpu_flags & idct_tab_arch[i].cpu_flag))
     514          30 :                     err |= dct_error(&idct_tab_arch[i], test, test_idct, speed, bits);
     515             :         }
     516             : #if CONFIG_FDCTDSP
     517             :         else {
     518           5 :             for (i = 0; i < FF_ARRAY_ELEMS(fdct_tab); i++)
     519           4 :                 err |= dct_error(&fdct_tab[i], test, test_idct, speed, bits);
     520             : 
     521           4 :             for (i = 0; fdct_tab_arch[i].name; i++)
     522           3 :                 if (!(~cpu_flags & fdct_tab_arch[i].cpu_flag))
     523           3 :                     err |= dct_error(&fdct_tab_arch[i], test, test_idct, speed, bits);
     524             :         }
     525             : #endif /* CONFIG_FDCTDSP */
     526             :     }
     527             : 
     528           5 :     if (err)
     529           0 :         printf("Error: %d.\n", err);
     530             : 
     531           5 :     return !!err;
     532             : }

Generated by: LCOV version 1.13