FFmpeg coverage

GCC Code Coverage Report

Directory:	../../../ffmpeg/		Exec	Total	Coverage
File:	src/libavcodec/idctdsp.c	Lines:	130	173	75.1 %
Date:	2021-04-19 06:27:07	Branches:	48	61	78.7 %


/*
 * This file is part of FFmpeg.
 *
 * FFmpeg is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * FFmpeg is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with FFmpeg; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

#include "config.h"
#include "libavutil/attributes.h"
#include "libavutil/common.h"
#include "avcodec.h"
#include "dct.h"
#include "faanidct.h"
#include "idctdsp.h"
#include "simple_idct.h"
#include "xvididct.h"

av_cold void ff_init_scantable(uint8_t *permutation, ScanTable *st,
                               const uint8_t *src_scantable)
{
    int i, end;

    st->scantable = src_scantable;

    for (i = 0; i < 64; i++) {
        int j = src_scantable[i];
        st->permutated[i] = permutation[j];
    }

    end = -1;
    for (i = 0; i < 64; i++) {
        int j = st->permutated[i];
        if (j > end)
            end = j;
        st->raster_end[i] = end;
    }
}

av_cold void ff_init_scantable_permutation(uint8_t *idct_permutation,
                                           enum idct_permutation_type perm_type)
{
    int i;

    if (ARCH_X86)
        if (ff_init_scantable_permutation_x86(idct_permutation,
                                              perm_type))
            return;

    switch (perm_type) {
    case FF_IDCT_PERM_NONE:
        for (i = 0; i < 64; i++)
            idct_permutation[i] = i;
        break;
    case FF_IDCT_PERM_LIBMPEG2:
        for (i = 0; i < 64; i++)
            idct_permutation[i] = (i & 0x38) | ((i & 6) >> 1) | ((i & 1) << 2);
        break;
    case FF_IDCT_PERM_TRANSPOSE:
        for (i = 0; i < 64; i++)
            idct_permutation[i] = ((i & 7) << 3) | (i >> 3);
        break;
    case FF_IDCT_PERM_PARTTRANS:
        for (i = 0; i < 64; i++)
            idct_permutation[i] = (i & 0x24) | ((i & 3) << 3) | ((i >> 3) & 3);
        break;
    default:
        av_log(NULL, AV_LOG_ERROR,
               "Internal error, IDCT permutation not set\n");
    }
}

void ff_put_pixels_clamped_c(const int16_t *block, uint8_t *av_restrict pixels,
                             ptrdiff_t line_size)
{
    int i;

    /* read the pixels */
    for (i = 0; i < 8; i++) {
        pixels[0] = av_clip_uint8(block[0]);
        pixels[1] = av_clip_uint8(block[1]);
        pixels[2] = av_clip_uint8(block[2]);
        pixels[3] = av_clip_uint8(block[3]);
        pixels[4] = av_clip_uint8(block[4]);
        pixels[5] = av_clip_uint8(block[5]);
        pixels[6] = av_clip_uint8(block[6]);
        pixels[7] = av_clip_uint8(block[7]);

        pixels += line_size;
        block  += 8;
    }
}

static void put_pixels_clamped4_c(const int16_t *block, uint8_t *av_restrict pixels,
                                 int line_size)
{
    int i;

    /* read the pixels */
    for(i=0;i<4;i++) {
        pixels[0] = av_clip_uint8(block[0]);
        pixels[1] = av_clip_uint8(block[1]);
        pixels[2] = av_clip_uint8(block[2]);
        pixels[3] = av_clip_uint8(block[3]);

        pixels += line_size;
        block += 8;
    }
}

static void put_pixels_clamped2_c(const int16_t *block, uint8_t *av_restrict pixels,
                                 int line_size)
{
    int i;

    /* read the pixels */
    for(i=0;i<2;i++) {
        pixels[0] = av_clip_uint8(block[0]);
        pixels[1] = av_clip_uint8(block[1]);

        pixels += line_size;
        block += 8;
    }
}

static void put_signed_pixels_clamped_c(const int16_t *block,
                                        uint8_t *av_restrict pixels,
                                        ptrdiff_t line_size)
{
    int i, j;

    for (i = 0; i < 8; i++) {
        for (j = 0; j < 8; j++) {
            if (*block < -128)
                *pixels = 0;
            else if (*block > 127)
                *pixels = 255;
            else
                *pixels = (uint8_t) (*block + 128);
            block++;
            pixels++;
        }
        pixels += (line_size - 8);
    }
}

void ff_add_pixels_clamped_c(const int16_t *block, uint8_t *av_restrict pixels,
                             ptrdiff_t line_size)
{
    int i;

    /* read the pixels */
    for (i = 0; i < 8; i++) {
        pixels[0] = av_clip_uint8(pixels[0] + block[0]);
        pixels[1] = av_clip_uint8(pixels[1] + block[1]);
        pixels[2] = av_clip_uint8(pixels[2] + block[2]);
        pixels[3] = av_clip_uint8(pixels[3] + block[3]);
        pixels[4] = av_clip_uint8(pixels[4] + block[4]);
        pixels[5] = av_clip_uint8(pixels[5] + block[5]);
        pixels[6] = av_clip_uint8(pixels[6] + block[6]);
        pixels[7] = av_clip_uint8(pixels[7] + block[7]);
        pixels   += line_size;
        block    += 8;
    }
}

static void add_pixels_clamped4_c(const int16_t *block, uint8_t *av_restrict pixels,
                          int line_size)
{
    int i;

    /* read the pixels */
    for(i=0;i<4;i++) {
        pixels[0] = av_clip_uint8(pixels[0] + block[0]);
        pixels[1] = av_clip_uint8(pixels[1] + block[1]);
        pixels[2] = av_clip_uint8(pixels[2] + block[2]);
        pixels[3] = av_clip_uint8(pixels[3] + block[3]);
        pixels += line_size;
        block += 8;
    }
}

static void add_pixels_clamped2_c(const int16_t *block, uint8_t *av_restrict pixels,
                          int line_size)
{
    int i;

    /* read the pixels */
    for(i=0;i<2;i++) {
        pixels[0] = av_clip_uint8(pixels[0] + block[0]);
        pixels[1] = av_clip_uint8(pixels[1] + block[1]);
        pixels += line_size;
        block += 8;
    }
}

static void ff_jref_idct4_put(uint8_t *dest, ptrdiff_t line_size, int16_t *block)
{
    ff_j_rev_dct4 (block);
    put_pixels_clamped4_c(block, dest, line_size);
}
static void ff_jref_idct4_add(uint8_t *dest, ptrdiff_t line_size, int16_t *block)
{
    ff_j_rev_dct4 (block);
    add_pixels_clamped4_c(block, dest, line_size);
}

static void ff_jref_idct2_put(uint8_t *dest, ptrdiff_t line_size, int16_t *block)
{
    ff_j_rev_dct2 (block);
    put_pixels_clamped2_c(block, dest, line_size);
}
static void ff_jref_idct2_add(uint8_t *dest, ptrdiff_t line_size, int16_t *block)
{
    ff_j_rev_dct2 (block);
    add_pixels_clamped2_c(block, dest, line_size);
}

static void ff_jref_idct1_put(uint8_t *dest, ptrdiff_t line_size, int16_t *block)
{
    dest[0] = av_clip_uint8((block[0] + 4)>>3);
}
static void ff_jref_idct1_add(uint8_t *dest, ptrdiff_t line_size, int16_t *block)
{
    dest[0] = av_clip_uint8(dest[0] + ((block[0] + 4)>>3));
}

av_cold void ff_idctdsp_init(IDCTDSPContext *c, AVCodecContext *avctx)
{
    const unsigned high_bit_depth = avctx->bits_per_raw_sample > 8;

    if (avctx->lowres==1) {
        c->idct_put  = ff_jref_idct4_put;
        c->idct_add  = ff_jref_idct4_add;
        c->idct      = ff_j_rev_dct4;
        c->perm_type = FF_IDCT_PERM_NONE;
    } else if (avctx->lowres==2) {
        c->idct_put  = ff_jref_idct2_put;
        c->idct_add  = ff_jref_idct2_add;
        c->idct      = ff_j_rev_dct2;
        c->perm_type = FF_IDCT_PERM_NONE;
    } else if (avctx->lowres==3) {
        c->idct_put  = ff_jref_idct1_put;
        c->idct_add  = ff_jref_idct1_add;
        c->idct      = ff_j_rev_dct1;
        c->perm_type = FF_IDCT_PERM_NONE;
    } else {
        if (avctx->bits_per_raw_sample == 10 || avctx->bits_per_raw_sample == 9) {
            /* 10-bit MPEG-4 Simple Studio Profile requires a higher precision IDCT
               However, it only uses idct_put */
            if (c->mpeg4_studio_profile) {
                c->idct_put              = ff_simple_idct_put_int32_10bit;
                c->idct_add              = NULL;
                c->idct                  = NULL;
            } else {
                c->idct_put              = ff_simple_idct_put_int16_10bit;
                c->idct_add              = ff_simple_idct_add_int16_10bit;
                c->idct                  = ff_simple_idct_int16_10bit;
            }
            c->perm_type             = FF_IDCT_PERM_NONE;
        } else if (avctx->bits_per_raw_sample == 12) {
            c->idct_put              = ff_simple_idct_put_int16_12bit;
            c->idct_add              = ff_simple_idct_add_int16_12bit;
            c->idct                  = ff_simple_idct_int16_12bit;
            c->perm_type             = FF_IDCT_PERM_NONE;
        } else {
            if (avctx->idct_algo == FF_IDCT_INT) {
                c->idct_put  = ff_jref_idct_put;
                c->idct_add  = ff_jref_idct_add;
                c->idct      = ff_j_rev_dct;
                c->perm_type = FF_IDCT_PERM_LIBMPEG2;
#if CONFIG_FAANIDCT
            } else if (avctx->idct_algo == FF_IDCT_FAAN) {
                c->idct_put  = ff_faanidct_put;
                c->idct_add  = ff_faanidct_add;
                c->idct      = ff_faanidct;
                c->perm_type = FF_IDCT_PERM_NONE;
#endif /* CONFIG_FAANIDCT */
            } else { // accurate/default
                /* Be sure FF_IDCT_NONE will select this one, since it uses FF_IDCT_PERM_NONE */
                c->idct_put  = ff_simple_idct_put_int16_8bit;
                c->idct_add  = ff_simple_idct_add_int16_8bit;
                c->idct      = ff_simple_idct_int16_8bit;
                c->perm_type = FF_IDCT_PERM_NONE;
            }
        }
    }

    c->put_pixels_clamped        = ff_put_pixels_clamped_c;
    c->put_signed_pixels_clamped = put_signed_pixels_clamped_c;
    c->add_pixels_clamped        = ff_add_pixels_clamped_c;

    if (CONFIG_MPEG4_DECODER && avctx->idct_algo == FF_IDCT_XVID)
        ff_xvid_idct_init(c, avctx);

    if (ARCH_AARCH64)
        ff_idctdsp_init_aarch64(c, avctx, high_bit_depth);
    if (ARCH_ALPHA)
        ff_idctdsp_init_alpha(c, avctx, high_bit_depth);
    if (ARCH_ARM)
        ff_idctdsp_init_arm(c, avctx, high_bit_depth);
    if (ARCH_PPC)
        ff_idctdsp_init_ppc(c, avctx, high_bit_depth);
    if (ARCH_X86)
        ff_idctdsp_init_x86(c, avctx, high_bit_depth);
    if (ARCH_MIPS)
        ff_idctdsp_init_mips(c, avctx, high_bit_depth);

    ff_init_scantable_permutation(c->idct_permutation,
                                  c->perm_type);
}


Generated by: GCOVR (Version 4.2)

Line	Branch	Exec	Source
1			/*
2			* This file is part of FFmpeg.
3			*
4			* FFmpeg is free software; you can redistribute it and/or
5			* modify it under the terms of the GNU Lesser General Public
6			* License as published by the Free Software Foundation; either
7			* version 2.1 of the License, or (at your option) any later version.
8			*
9			* FFmpeg is distributed in the hope that it will be useful,
10			* but WITHOUT ANY WARRANTY; without even the implied warranty of
11			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12			* Lesser General Public License for more details.
13			*
14			* You should have received a copy of the GNU Lesser General Public
15			* License along with FFmpeg; if not, write to the Free Software
16			* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17			*/
18
19			#include "config.h"
20			#include "libavutil/attributes.h"
21			#include "libavutil/common.h"
22			#include "avcodec.h"
23			#include "dct.h"
24			#include "faanidct.h"
25			#include "idctdsp.h"
26			#include "simple_idct.h"
27			#include "xvididct.h"
28
29		41049	av_cold void ff_init_scantable(uint8_t permutation, ScanTable st,
30			const uint8_t *src_scantable)
31			{
32			int i, end;
33
34		41049	st->scantable = src_scantable;
35
36	✓✓	2668185	for (i = 0; i < 64; i++) {
37		2627136	int j = src_scantable[i];
38		2627136	st->permutated[i] = permutation[j];
39			}
40
41		41049	end = -1;
42	✓✓	2668185	for (i = 0; i < 64; i++) {
43		2627136	int j = st->permutated[i];
44	✓✓	2627136	if (j > end)
45		554043	end = j;
46		2627136	st->raster_end[i] = end;
47			}
48		41049	}
49
50		1828	av_cold void ff_init_scantable_permutation(uint8_t *idct_permutation,
51			enum idct_permutation_type perm_type)
52			{
53			int i;
54
55			if (ARCH_X86)
56	✓✓	1828	if (ff_init_scantable_permutation_x86(idct_permutation,
57			perm_type))
58		4	return;
59
60	✓✓✓✗ ✗	1824	switch (perm_type) {
61		1532	case FF_IDCT_PERM_NONE:
62	✓✓	99580	for (i = 0; i < 64; i++)
63		98048	idct_permutation[i] = i;
64		1532	break;
65		4	case FF_IDCT_PERM_LIBMPEG2:
66	✓✓	260	for (i = 0; i < 64; i++)
67		256	idct_permutation[i] = (i & 0x38) \| ((i & 6) >> 1) \| ((i & 1) << 2);
68		4	break;
69		288	case FF_IDCT_PERM_TRANSPOSE:
70	✓✓	18720	for (i = 0; i < 64; i++)
71		18432	idct_permutation[i] = ((i & 7) << 3) \| (i >> 3);
72		288	break;
73			case FF_IDCT_PERM_PARTTRANS:
74			for (i = 0; i < 64; i++)
75			idct_permutation[i] = (i & 0x24) \| ((i & 3) << 3) \| ((i >> 3) & 3);
76			break;
77			default:
78			av_log(NULL, AV_LOG_ERROR,
79			"Internal error, IDCT permutation not set\n");
80			}
81			}
82
83		141450	void ff_put_pixels_clamped_c(const int16_t block, uint8_t av_restrict pixels,
84			ptrdiff_t line_size)
85			{
86			int i;
87
88			/* read the pixels */
89	✓✓	1273050	for (i = 0; i < 8; i++) {
90		1131600	pixels[0] = av_clip_uint8(block[0]);
91		1131600	pixels[1] = av_clip_uint8(block[1]);
92		1131600	pixels[2] = av_clip_uint8(block[2]);
93		1131600	pixels[3] = av_clip_uint8(block[3]);
94		1131600	pixels[4] = av_clip_uint8(block[4]);
95		1131600	pixels[5] = av_clip_uint8(block[5]);
96		1131600	pixels[6] = av_clip_uint8(block[6]);
97		1131600	pixels[7] = av_clip_uint8(block[7]);
98
99		1131600	pixels += line_size;
100		1131600	block += 8;
101			}
102		141450	}
103
104		14262	static void put_pixels_clamped4_c(const int16_t block, uint8_t av_restrict pixels,
105			int line_size)
106			{
107			int i;
108
109			/* read the pixels */
110	✓✓	71310	for(i=0;i<4;i++) {
111		57048	pixels[0] = av_clip_uint8(block[0]);
112		57048	pixels[1] = av_clip_uint8(block[1]);
113		57048	pixels[2] = av_clip_uint8(block[2]);
114		57048	pixels[3] = av_clip_uint8(block[3]);
115
116		57048	pixels += line_size;
117		57048	block += 8;
118			}
119		14262	}
120
121			static void put_pixels_clamped2_c(const int16_t block, uint8_t av_restrict pixels,
122			int line_size)
123			{
124			int i;
125
126			/* read the pixels */
127			for(i=0;i<2;i++) {
128			pixels[0] = av_clip_uint8(block[0]);
129			pixels[1] = av_clip_uint8(block[1]);
130
131			pixels += line_size;
132			block += 8;
133			}
134			}
135
136		1027936	static void put_signed_pixels_clamped_c(const int16_t *block,
137			uint8_t *av_restrict pixels,
138			ptrdiff_t line_size)
139			{
140			int i, j;
141
142	✓✓	9251424	for (i = 0; i < 8; i++) {
143	✓✓	74011392	for (j = 0; j < 8; j++) {
144	✓✓	65787904	if (*block < -128)
145		73	*pixels = 0;
146	✓✓	65787831	else if (*block > 127)
147		43966	*pixels = 255;
148			else
149		65743865	pixels = (uint8_t) (block + 128);
150		65787904	block++;
151		65787904	pixels++;
152			}
153		8223488	pixels += (line_size - 8);
154			}
155		1027936	}
156
157		451709	void ff_add_pixels_clamped_c(const int16_t block, uint8_t av_restrict pixels,
158			ptrdiff_t line_size)
159			{
160			int i;
161
162			/* read the pixels */
163	✓✓	4065381	for (i = 0; i < 8; i++) {
164		3613672	pixels[0] = av_clip_uint8(pixels[0] + block[0]);
165		3613672	pixels[1] = av_clip_uint8(pixels[1] + block[1]);
166		3613672	pixels[2] = av_clip_uint8(pixels[2] + block[2]);
167		3613672	pixels[3] = av_clip_uint8(pixels[3] + block[3]);
168		3613672	pixels[4] = av_clip_uint8(pixels[4] + block[4]);
169		3613672	pixels[5] = av_clip_uint8(pixels[5] + block[5]);
170		3613672	pixels[6] = av_clip_uint8(pixels[6] + block[6]);
171		3613672	pixels[7] = av_clip_uint8(pixels[7] + block[7]);
172		3613672	pixels += line_size;
173		3613672	block += 8;
174			}
175		451709	}
176
177		73763	static void add_pixels_clamped4_c(const int16_t block, uint8_t av_restrict pixels,
178			int line_size)
179			{
180			int i;
181
182			/* read the pixels */
183	✓✓	368815	for(i=0;i<4;i++) {
184		295052	pixels[0] = av_clip_uint8(pixels[0] + block[0]);
185		295052	pixels[1] = av_clip_uint8(pixels[1] + block[1]);
186		295052	pixels[2] = av_clip_uint8(pixels[2] + block[2]);
187		295052	pixels[3] = av_clip_uint8(pixels[3] + block[3]);
188		295052	pixels += line_size;
189		295052	block += 8;
190			}
191		73763	}
192
193			static void add_pixels_clamped2_c(const int16_t block, uint8_t av_restrict pixels,
194			int line_size)
195			{
196			int i;
197
198			/* read the pixels */
199			for(i=0;i<2;i++) {
200			pixels[0] = av_clip_uint8(pixels[0] + block[0]);
201			pixels[1] = av_clip_uint8(pixels[1] + block[1]);
202			pixels += line_size;
203			block += 8;
204			}
205			}
206
207		14262	static void ff_jref_idct4_put(uint8_t dest, ptrdiff_t line_size, int16_t block)
208			{
209		14262	ff_j_rev_dct4 (block);
210		14262	put_pixels_clamped4_c(block, dest, line_size);
211		14262	}
212		73763	static void ff_jref_idct4_add(uint8_t dest, ptrdiff_t line_size, int16_t block)
213			{
214		73763	ff_j_rev_dct4 (block);
215		73763	add_pixels_clamped4_c(block, dest, line_size);
216		73763	}
217
218			static void ff_jref_idct2_put(uint8_t dest, ptrdiff_t line_size, int16_t block)
219			{
220			ff_j_rev_dct2 (block);
221			put_pixels_clamped2_c(block, dest, line_size);
222			}
223			static void ff_jref_idct2_add(uint8_t dest, ptrdiff_t line_size, int16_t block)
224			{
225			ff_j_rev_dct2 (block);
226			add_pixels_clamped2_c(block, dest, line_size);
227			}
228
229			static void ff_jref_idct1_put(uint8_t dest, ptrdiff_t line_size, int16_t block)
230			{
231			dest[0] = av_clip_uint8((block[0] + 4)>>3);
232			}
233			static void ff_jref_idct1_add(uint8_t dest, ptrdiff_t line_size, int16_t block)
234			{
235			dest[0] = av_clip_uint8(dest[0] + ((block[0] + 4)>>3));
236			}
237
238		1603	av_cold void ff_idctdsp_init(IDCTDSPContext c, AVCodecContext avctx)
239			{
240		1603	const unsigned high_bit_depth = avctx->bits_per_raw_sample > 8;
241
242	✓✓	1603	if (avctx->lowres==1) {
243		1	c->idct_put = ff_jref_idct4_put;
244		1	c->idct_add = ff_jref_idct4_add;
245		1	c->idct = ff_j_rev_dct4;
246		1	c->perm_type = FF_IDCT_PERM_NONE;
247	✗✓	1602	} else if (avctx->lowres==2) {
248			c->idct_put = ff_jref_idct2_put;
249			c->idct_add = ff_jref_idct2_add;
250			c->idct = ff_j_rev_dct2;
251			c->perm_type = FF_IDCT_PERM_NONE;
252	✗✓	1602	} else if (avctx->lowres==3) {
253			c->idct_put = ff_jref_idct1_put;
254			c->idct_add = ff_jref_idct1_add;
255			c->idct = ff_j_rev_dct1;
256			c->perm_type = FF_IDCT_PERM_NONE;
257			} else {
258	✓✓✗✓	1602	if (avctx->bits_per_raw_sample == 10 \|\| avctx->bits_per_raw_sample == 9) {
259			/* 10-bit MPEG-4 Simple Studio Profile requires a higher precision IDCT
260			However, it only uses idct_put */
261	✗✓	23	if (c->mpeg4_studio_profile) {
262			c->idct_put = ff_simple_idct_put_int32_10bit;
263			c->idct_add = NULL;
264			c->idct = NULL;
265			} else {
266		23	c->idct_put = ff_simple_idct_put_int16_10bit;
267		23	c->idct_add = ff_simple_idct_add_int16_10bit;
268		23	c->idct = ff_simple_idct_int16_10bit;
269			}
270		23	c->perm_type = FF_IDCT_PERM_NONE;
271	✓✓	1579	} else if (avctx->bits_per_raw_sample == 12) {
272		4	c->idct_put = ff_simple_idct_put_int16_12bit;
273		4	c->idct_add = ff_simple_idct_add_int16_12bit;
274		4	c->idct = ff_simple_idct_int16_12bit;
275		4	c->perm_type = FF_IDCT_PERM_NONE;
276			} else {
277	✓✓	1575	if (avctx->idct_algo == FF_IDCT_INT) {
278		4	c->idct_put = ff_jref_idct_put;
279		4	c->idct_add = ff_jref_idct_add;
280		4	c->idct = ff_j_rev_dct;
281		4	c->perm_type = FF_IDCT_PERM_LIBMPEG2;
282			#if CONFIG_FAANIDCT
283	✗✓	1571	} else if (avctx->idct_algo == FF_IDCT_FAAN) {
284			c->idct_put = ff_faanidct_put;
285			c->idct_add = ff_faanidct_add;
286			c->idct = ff_faanidct;
287			c->perm_type = FF_IDCT_PERM_NONE;
288			#endif /* CONFIG_FAANIDCT */
289			} else { // accurate/default
290			/* Be sure FF_IDCT_NONE will select this one, since it uses FF_IDCT_PERM_NONE */
291		1571	c->idct_put = ff_simple_idct_put_int16_8bit;
292		1571	c->idct_add = ff_simple_idct_add_int16_8bit;
293		1571	c->idct = ff_simple_idct_int16_8bit;
294		1571	c->perm_type = FF_IDCT_PERM_NONE;
295			}
296			}
297			}
298
299		1603	c->put_pixels_clamped = ff_put_pixels_clamped_c;
300		1603	c->put_signed_pixels_clamped = put_signed_pixels_clamped_c;
301		1603	c->add_pixels_clamped = ff_add_pixels_clamped_c;
302
303	✓✓	1603	if (CONFIG_MPEG4_DECODER && avctx->idct_algo == FF_IDCT_XVID)
304		4	ff_xvid_idct_init(c, avctx);
305
306			if (ARCH_AARCH64)
307			ff_idctdsp_init_aarch64(c, avctx, high_bit_depth);
308			if (ARCH_ALPHA)
309			ff_idctdsp_init_alpha(c, avctx, high_bit_depth);
310			if (ARCH_ARM)
311			ff_idctdsp_init_arm(c, avctx, high_bit_depth);
312			if (ARCH_PPC)
313			ff_idctdsp_init_ppc(c, avctx, high_bit_depth);
314			if (ARCH_X86)
315		1603	ff_idctdsp_init_x86(c, avctx, high_bit_depth);
316			if (ARCH_MIPS)
317			ff_idctdsp_init_mips(c, avctx, high_bit_depth);
318
319		1603	ff_init_scantable_permutation(c->idct_permutation,
320			c->perm_type);
321		1603	}