sigrid/ffmpeg

configure+21−19

     huffman
     huffyuvdsp
     huffyuvencdsp
+    idctdsp
     intrax8
     lgplv3
     lpc
 # subsystems
 dct_select="rdft"
+dsputil_select="idctdsp"
 error_resilience_select="dsputil"
 intrax8_select="error_resilience"
 mdct_select="fft"
 mpeg_er_select="error_resilience"
 mpegaudio_select="mpegaudiodsp"
 mpegaudiodsp_select="dct"
-mpegvideo_select="blockdsp dsputil hpeldsp videodsp"
+mpegvideo_select="blockdsp dsputil hpeldsp idctdsp videodsp"
 mpegvideoenc_select="dsputil mpegvideo qpeldsp"
 # decoders / encoders
 ac3_decoder_select="ac3_parser ac3dsp bswapdsp mdct"
 ac3_encoder_select="ac3dsp audiodsp dsputil mdct"
 ac3_fixed_encoder_select="ac3dsp audiodsp dsputil mdct"
-aic_decoder_select="dsputil golomb"
+aic_decoder_select="golomb idctdsp"
 alac_encoder_select="lpc"
 als_decoder_select="bswapdsp"
 amrnb_decoder_select="lsp"
 amrwb_decoder_select="lsp"
 amv_decoder_select="sp5x_decoder"
 ape_decoder_select="bswapdsp"
-asv1_decoder_select="blockdsp bswapdsp dsputil"
+asv1_decoder_select="blockdsp bswapdsp idctdsp"
 asv1_encoder_select="bswapdsp dsputil"
-asv2_decoder_select="blockdsp bswapdsp dsputil"
+asv2_decoder_select="blockdsp bswapdsp idctdsp"
 asv2_encoder_select="bswapdsp dsputil"
 atrac1_decoder_select="mdct sinewin"
 atrac3_decoder_select="mdct"
 bink_decoder_select="blockdsp hpeldsp"
 binkaudio_dct_decoder_select="mdct rdft dct sinewin"
 binkaudio_rdft_decoder_select="mdct rdft sinewin"
-cavs_decoder_select="blockdsp dsputil golomb h264chroma qpeldsp videodsp"
+cavs_decoder_select="blockdsp golomb h264chroma idctdsp qpeldsp videodsp"
 cllc_decoder_select="bswapdsp"
 comfortnoise_encoder_select="lpc"
 cook_decoder_select="audiodsp mdct sinewin"
 cscd_decoder_select="lzo"
 cscd_decoder_suggest="zlib"
 dca_decoder_select="mdct"
-dnxhd_decoder_select="blockdsp dsputil"
+dnxhd_decoder_select="blockdsp idctdsp"
-dnxhd_encoder_select="aandcttables blockdsp dsputil mpegvideoenc"
+dnxhd_encoder_select="aandcttables blockdsp dsputil idctdsp mpegvideoenc"
-dvvideo_decoder_select="dsputil"
+dvvideo_decoder_select="idctdsp"
 dvvideo_encoder_select="dsputil"
 dxa_decoder_deps="zlib"
 eac3_decoder_select="ac3_decoder"
 eac3_encoder_select="ac3_encoder"
-eamad_decoder_select="aandcttables blockdsp bswapdsp dsputil mpegvideo"
+eamad_decoder_select="aandcttables blockdsp bswapdsp idctdsp mpegvideo"
-eatgq_decoder_select="aandcttables dsputil"
+eatgq_decoder_select="aandcttables idctdsp"
-eatqi_decoder_select="aandcttables blockdsp bswapdsp dsputil mpeg1video_decoder"
+eatqi_decoder_select="aandcttables blockdsp bswapdsp idctdsp mpeg1video_decoder"
 exr_decoder_deps="zlib"
 ffv1_decoder_select="golomb rangecoder"
 ffv1_encoder_select="rangecoder"
 fourxm_decoder_select="blockdsp bswapdsp"
 fraps_decoder_select="bswapdsp huffman"
 g2m_decoder_deps="zlib"
-g2m_decoder_select="blockdsp dsputil"
+g2m_decoder_select="blockdsp idctdsp"
 h261_decoder_select="mpeg_er mpegvideo"
 h261_encoder_select="aandcttables mpegvideoenc"
 h263_decoder_select="error_resilience h263_parser h263dsp mpeg_er mpegvideo qpeldsp"
 jpegls_encoder_select="golomb"
 jv_decoder_select="blockdsp"
 lagarith_decoder_select="huffyuvdsp"
-ljpeg_encoder_select="aandcttables dsputil"
+ljpeg_encoder_select="aandcttables idctdsp"
 loco_decoder_select="golomb"
-mdec_decoder_select="blockdsp dsputil mpegvideo"
+mdec_decoder_select="blockdsp idctdsp mpegvideo"
 metasound_decoder_select="lsp mdct sinewin"
-mimic_decoder_select="blockdsp bswapdsp dsputil hpeldsp"
+mimic_decoder_select="blockdsp bswapdsp hpeldsp idctdsp"
-mjpeg_decoder_select="blockdsp dsputil hpeldsp"
+mjpeg_decoder_select="blockdsp hpeldsp idctdsp"
 mjpeg_encoder_select="aandcttables mpegvideoenc"
 mjpegb_decoder_select="mjpeg_decoder"
 mlp_decoder_select="mlp_parser"
 mxpeg_decoder_select="mjpeg_decoder"
 nellymoser_decoder_select="mdct sinewin"
 nellymoser_encoder_select="audio_frame_queue mdct sinewin"
-nuv_decoder_select="dsputil lzo"
+nuv_decoder_select="idctdsp lzo"
 on2avc_decoder_select="mdct"
 opus_decoder_deps="avresample"
 png_decoder_deps="zlib"
 png_encoder_deps="zlib"
 png_encoder_select="huffyuvencdsp"
-prores_decoder_select="dsputil"
+prores_decoder_select="idctdsp"
 prores_encoder_select="dsputil"
 qcelp_decoder_select="lsp"
 qdm2_decoder_select="mdct rdft mpegaudiodsp"
 wmavoice_decoder_select="lsp rdft dct mdct sinewin"
 wmv1_decoder_select="h263_decoder"
 wmv1_encoder_select="h263_encoder"
-wmv2_decoder_select="blockdsp h263_decoder intrax8 videodsp"
+wmv2_decoder_select="blockdsp h263_decoder idctdsp intrax8 videodsp"
 wmv2_encoder_select="h263_encoder"
 wmv3_decoder_select="vc1_decoder"
 wmv3image_decoder_select="wmv3_decoder"

doc/optimization.txt+0−3

@@ -136,9 +136,6 @@ dct_unquantize_mpeg2 · 135 unmodified lines
136	dct_unquantize_h263	136	dct_unquantize_h263
137	Used in MPEG-4/H.263 en/decoding.	137	Used in MPEG-4/H.263 en/decoding.
138		138
139	FIXME remaining functions?
140	BTW, most of these functions are in dsputil.c/.h, some are in mpegvideo.c/.h.
141
142		139
143		140
144	Alignment:	141	Alignment:

libavcodec/Makefile+3−2

 OBJS-$(CONFIG_BSWAPDSP)                += bswapdsp.o
 OBJS-$(CONFIG_CABAC)                   += cabac.o
 OBJS-$(CONFIG_DCT)                     += dct.o dct32_fixed.o dct32_float.o
+OBJS-$(CONFIG_DSPUTIL)                 += dsputil.o
 OBJS-$(CONFIG_DXVA2)                   += dxva2.o
-OBJS-$(CONFIG_DSPUTIL)                 += dsputil.o faanidct.o          \
-                                          simple_idct.o jrevdct.o
 OBJS-$(CONFIG_ENCODERS)                += faandct.o jfdctfst.o jfdctint.o
 OBJS-$(CONFIG_ERROR_RESILIENCE)        += error_resilience.o
 FFT-OBJS-$(CONFIG_HARDCODED_TABLES)    += cos_tables.o cos_fixed_tables.o
 OBJS-$(CONFIG_HUFFMAN)                 += huffman.o
 OBJS-$(CONFIG_HUFFYUVDSP)              += huffyuvdsp.o
 OBJS-$(CONFIG_HUFFYUVENCDSP)           += huffyuvencdsp.o
+OBJS-$(CONFIG_IDCTDSP)                 += idctdsp.o faanidct.o          \
+                                          simple_idct.o jrevdct.o
 OBJS-$(CONFIG_INTRAX8)                 += intrax8.o intrax8dsp.o
 OBJS-$(CONFIG_LIBXVID)                 += libxvid_rc.o
 OBJS-$(CONFIG_LPC)                     += lpc.o

libavcodec/aic.c+11−12

 #include "avcodec.h"
 #include "bytestream.h"
-#include "dsputil.h"
 #include "internal.h"
 #include "get_bits.h"
 #include "golomb.h"
+#include "idctdsp.h"
 #include "unary.h"
 #define AIC_HDR_SIZE    24
 typedef struct AICContext {
     AVCodecContext *avctx;
     AVFrame        *frame;
-    DSPContext     dsp;
+    IDCTDSPContext idsp;
     ScanTable      scantable;
     int            num_x_slices;
                 recombine_block_il(ctx->block, ctx->scantable.permutated,
                                    &base_y, &ext_y, blk);
             unquant_block(ctx->block, ctx->quant);
-            ctx->dsp.idct(ctx->block);
+            ctx->idsp.idct(ctx->block);
             if (!ctx->interlaced) {
                 dst = Y + (blk >> 1) * 8 * ystride + (blk & 1) * 8;
-                ctx->dsp.put_signed_pixels_clamped(ctx->block, dst,
+                ctx->idsp.put_signed_pixels_clamped(ctx->block, dst, ystride);
-                                                   ystride);
             } else {
                 dst = Y + (blk & 1) * 8 + (blk >> 1) * ystride;
-                ctx->dsp.put_signed_pixels_clamped(ctx->block, dst,
+                ctx->idsp.put_signed_pixels_clamped(ctx->block, dst,
-                                                   ystride * 2);
+                                                    ystride * 2);
             }
         }
         Y += 16;
             recombine_block(ctx->block, ctx->scantable.permutated,
                             &base_c, &ext_c);
             unquant_block(ctx->block, ctx->quant);
-            ctx->dsp.idct(ctx->block);
+            ctx->idsp.idct(ctx->block);
-            ctx->dsp.put_signed_pixels_clamped(ctx->block, C[blk],
+            ctx->idsp.put_signed_pixels_clamped(ctx->block, C[blk],
-                                               ctx->frame->linesize[blk + 1]);
+                                                ctx->frame->linesize[blk + 1]);
             C[blk] += 8;
         }
     }
     avctx->pix_fmt = AV_PIX_FMT_YUV420P;
-    ff_dsputil_init(&ctx->dsp, avctx);
+    ff_idctdsp_init(&ctx->idsp, avctx);
     for (i = 0; i < 64; i++)
         scan[i] = i;
-    ff_init_scantable(ctx->dsp.idct_permutation, &ctx->scantable, scan);
+    ff_init_scantable(ctx->idsp.idct_permutation, &ctx->scantable, scan);
     ctx->mb_width  = FFALIGN(avctx->width,  16) >> 4;
     ctx->mb_height = FFALIGN(avctx->height, 16) >> 4;

libavcodec/arm/Makefile+13−10

                                           arm/ac3dsp_arm.o
 OBJS-$(CONFIG_AUDIODSP)                += arm/audiodsp_init_arm.o
 OBJS-$(CONFIG_BLOCKDSP)                += arm/blockdsp_init_arm.o
-OBJS-$(CONFIG_DSPUTIL)                 += arm/dsputil_init_arm.o        \
+OBJS-$(CONFIG_DSPUTIL)                 += arm/dsputil_init_arm.o
-                                          arm/dsputil_arm.o             \
-                                          arm/jrevdct_arm.o             \
-                                          arm/simple_idct_arm.o
 OBJS-$(CONFIG_FFT)                     += arm/fft_init_arm.o            \
                                           arm/fft_fixed_init_arm.o
 OBJS-$(CONFIG_H264CHROMA)              += arm/h264chroma_init_arm.o
 OBJS-$(CONFIG_H264QPEL)                += arm/h264qpel_init_arm.o
 OBJS-$(CONFIG_HPELDSP)                 += arm/hpeldsp_init_arm.o        \
                                           arm/hpeldsp_arm.o
+OBJS-$(CONFIG_IDCTDSP)                 += arm/idctdsp_init_arm.o        \
+                                          arm/idctdsp_arm.o             \
+                                          arm/jrevdct_arm.o             \
+                                          arm/simple_idct_arm.o
 OBJS-$(CONFIG_MPEGAUDIODSP)            += arm/mpegaudiodsp_init_arm.o
 OBJS-$(CONFIG_MPEGVIDEO)               += arm/mpegvideo_arm.o
 OBJS-$(CONFIG_NEON_CLOBBER_TEST)       += arm/neontest.o
 OBJS-$(CONFIG_RV40_DECODER)            += arm/rv34dsp_init_arm.o        \
                                           arm/rv40dsp_init_arm.o
-ARMV5TE-OBJS-$(CONFIG_DSPUTIL)         += arm/dsputil_init_armv5te.o    \
+ARMV5TE-OBJS-$(CONFIG_IDCTDSP)         += arm/idctdsp_init_armv5te.o    \
                                           arm/simple_idct_armv5te.o
 ARMV5TE-OBJS-$(CONFIG_MPEGVIDEO)       += arm/mpegvideo_armv5te.o       \
                                           arm/mpegvideo_armv5te_s.o
 ARMV6-OBJS-$(CONFIG_AC3DSP)            += arm/ac3dsp_armv6.o
 ARMV6-OBJS-$(CONFIG_DSPUTIL)           += arm/dsputil_init_armv6.o      \
-                                          arm/dsputil_armv6.o           \
+                                          arm/dsputil_armv6.o
-                                          arm/simple_idct_armv6.o
 ARMV6-OBJS-$(CONFIG_H264DSP)           += arm/h264dsp_armv6.o
 ARMV6-OBJS-$(CONFIG_HPELDSP)           += arm/hpeldsp_init_armv6.o      \
                                           arm/hpeldsp_armv6.o
+ARMV6-OBJS-$(CONFIG_IDCTDSP)           += arm/idctdsp_init_armv6.o      \
+                                          arm/idctdsp_armv6.o           \
+                                          arm/simple_idct_armv6.o
 ARMV6-OBJS-$(CONFIG_MPEGAUDIODSP)      += arm/mpegaudiodsp_fixed_armv6.o
 ARMV6-OBJS-$(CONFIG_MLP_DECODER)       += arm/mlpdsp_armv6.o
                                           arm/int_neon.o
 NEON-OBJS-$(CONFIG_BLOCKDSP)           += arm/blockdsp_init_neon.o      \
                                           arm/blockdsp_neon.o
-NEON-OBJS-$(CONFIG_DSPUTIL)            += arm/dsputil_init_neon.o       \
-                                          arm/dsputil_neon.o            \
-                                          arm/simple_idct_neon.o
 NEON-OBJS-$(CONFIG_FFT)                += arm/fft_neon.o                \
                                           arm/fft_fixed_neon.o
 NEON-OBJS-$(CONFIG_H264CHROMA)         += arm/h264cmc_neon.o
                                           arm/hpeldsp_neon.o
 NEON-OBJS-$(CONFIG_HPELDSP)            += arm/hpeldsp_init_neon.o       \
                                           arm/hpeldsp_neon.o
+NEON-OBJS-$(CONFIG_IDCTDSP)            += arm/idctdsp_init_neon.o       \
+                                          arm/idctdsp_neon.o            \
+                                          arm/simple_idct_neon.o
 NEON-OBJS-$(CONFIG_MDCT)               += arm/mdct_neon.o               \
                                           arm/mdct_fixed_neon.o
 NEON-OBJS-$(CONFIG_MPEGVIDEO)          += arm/mpegvideo_neon.o

libavcodec/arm/dsputil_arm.h+0−4

 #include "libavcodec/avcodec.h"
 #include "libavcodec/dsputil.h"
-void ff_dsputil_init_armv5te(DSPContext *c, AVCodecContext *avctx,
-                             unsigned high_bit_depth);
 void ff_dsputil_init_armv6(DSPContext *c, AVCodecContext *avctx,
                            unsigned high_bit_depth);
-void ff_dsputil_init_neon(DSPContext *c, AVCodecContext *avctx,
-                          unsigned high_bit_depth);
 #endif /* AVCODEC_ARM_DSPUTIL_ARM_H */

libavcodec/arm/dsputil_armv6.S+0−27

@@ -20,33 +20,6 @@ · 19 unmodified lines
20		20
21	#include "libavutil/arm/asm.S"	21	#include "libavutil/arm/asm.S"
22		22
23	function ff_add_pixels_clamped_armv6, export=1
24	push {r4-r8,lr}
25	mov r3, #8
26	1:
27	ldm r0!, {r4,r5,r12,lr}
28	ldrd r6, r7, [r1]
29	pkhbt r8, r4, r5, lsl #16
30	pkhtb r5, r5, r4, asr #16
31	pkhbt r4, r12, lr, lsl #16
32	pkhtb lr, lr, r12, asr #16
33	pld [r1, r2]
34	uxtab16 r8, r8, r6
35	uxtab16 r5, r5, r6, ror #8
36	uxtab16 r4, r4, r7
37	uxtab16 lr, lr, r7, ror #8
38	usat16 r8, #8, r8
39	usat16 r5, #8, r5
40	usat16 r4, #8, r4
41	usat16 lr, #8, lr
42	orr r6, r8, r5, lsl #8
43	orr r7, r4, lr, lsl #8
44	subs r3, r3, #1
45	strd_post r6, r7, r1, r2
46	bgt 1b
47	pop {r4-r8,pc}
48	endfunc
49
50	function ff_get_pixels_armv6, export=1	23	function ff_get_pixels_armv6, export=1
51	pld [r1, r2]	24	pld [r1, r2]
52	push {r4-r8, lr}	25	push {r4-r8, lr}

libavcodec/arm/dsputil_init_arm.c+0−60

@@ -28,71 +28,11 @@ · 27 unmodified lines
28	#include "libavcodec/dsputil.h"	28	#include "libavcodec/dsputil.h"
29	#include "dsputil_arm.h"	29	#include "dsputil_arm.h"
30		30
31	void ff_j_rev_dct_arm(int16_t *data);
32	void ff_simple_idct_arm(int16_t *data);
33
34	/* XXX: local hack */
35	static void (ff_put_pixels_clamped)(const int16_t block, uint8_t *pixels, int line_size);
36	static void (ff_add_pixels_clamped)(const int16_t block, uint8_t *pixels, int line_size);
37
38	void ff_add_pixels_clamped_arm(const int16_t block, uint8_t dest,
39	int line_size);
40
41	/* XXX: those functions should be suppressed ASAP when all IDCTs are
42	* converted */
43	static void j_rev_dct_arm_put(uint8_t dest, int line_size, int16_t block)
44	{
45	ff_j_rev_dct_arm(block);
46	ff_put_pixels_clamped(block, dest, line_size);
47	}
48
49	static void j_rev_dct_arm_add(uint8_t dest, int line_size, int16_t block)
50	{
51	ff_j_rev_dct_arm(block);
52	ff_add_pixels_clamped(block, dest, line_size);
53	}
54
55	static void simple_idct_arm_put(uint8_t dest, int line_size, int16_t block)
56	{
57	ff_simple_idct_arm(block);
58	ff_put_pixels_clamped(block, dest, line_size);
59	}
60
61	static void simple_idct_arm_add(uint8_t dest, int line_size, int16_t block)
62	{
63	ff_simple_idct_arm(block);
64	ff_add_pixels_clamped(block, dest, line_size);
65	}
66
67	av_cold void ff_dsputil_init_arm(DSPContext c, AVCodecContext avctx,	31	av_cold void ff_dsputil_init_arm(DSPContext c, AVCodecContext avctx,
68	unsigned high_bit_depth)	32	unsigned high_bit_depth)
69	{	33	{
70	int cpu_flags = av_get_cpu_flags();	34	int cpu_flags = av_get_cpu_flags();
71		35
72	ff_put_pixels_clamped = c->put_pixels_clamped;
73	ff_add_pixels_clamped = c->add_pixels_clamped;
74
75	if (!high_bit_depth) {
76	if (avctx->idct_algo == FF_IDCT_AUTO \|\|
77	avctx->idct_algo == FF_IDCT_ARM) {
78	c->idct_put = j_rev_dct_arm_put;
79	c->idct_add = j_rev_dct_arm_add;
80	c->idct = ff_j_rev_dct_arm;
81	c->idct_permutation_type = FF_LIBMPEG2_IDCT_PERM;
82	} else if (avctx->idct_algo == FF_IDCT_SIMPLEARM) {
83	c->idct_put = simple_idct_arm_put;
84	c->idct_add = simple_idct_arm_add;
85	c->idct = ff_simple_idct_arm;
86	c->idct_permutation_type = FF_NO_IDCT_PERM;
87	}
88	}
89
90	c->add_pixels_clamped = ff_add_pixels_clamped_arm;
91
92	if (have_armv5te(cpu_flags))
93	ff_dsputil_init_armv5te(c, avctx, high_bit_depth);
94	if (have_armv6(cpu_flags))	36	if (have_armv6(cpu_flags))
95	ff_dsputil_init_armv6(c, avctx, high_bit_depth);	37	ff_dsputil_init_armv6(c, avctx, high_bit_depth);
96	if (have_neon(cpu_flags))
97	ff_dsputil_init_neon(c, avctx, high_bit_depth);
98	}	38	}

libavcodec/arm/dsputil_init_armv6.c+0−18

@@ -26,13 +26,6 @@ · 25 unmodified lines
26	#include "libavcodec/mpegvideo.h"	26	#include "libavcodec/mpegvideo.h"
27	#include "dsputil_arm.h"	27	#include "dsputil_arm.h"
28		28
29	void ff_simple_idct_armv6(int16_t *data);
30	void ff_simple_idct_put_armv6(uint8_t dest, int line_size, int16_t data);
31	void ff_simple_idct_add_armv6(uint8_t dest, int line_size, int16_t data);
32
33	void ff_add_pixels_clamped_armv6(const int16_t block, uint8_t pixels,
34	int line_size);
35
36	void ff_get_pixels_armv6(int16_t block, const uint8_t pixels, int stride);	29	void ff_get_pixels_armv6(int16_t block, const uint8_t pixels, int stride);
37	void ff_diff_pixels_armv6(int16_t block, const uint8_t s1,	30	void ff_diff_pixels_armv6(int16_t block, const uint8_t s1,
38	const uint8_t *s2, int stride);	31	const uint8_t *s2, int stride);
@@ -56,17 +49,6 @@ int ff_pix_sum_armv6(uint8_t *pix, int line_size); · 17 unmodified lines
56	av_cold void ff_dsputil_init_armv6(DSPContext c, AVCodecContext avctx,	49	av_cold void ff_dsputil_init_armv6(DSPContext c, AVCodecContext avctx,
57	unsigned high_bit_depth)	50	unsigned high_bit_depth)
58	{	51	{
59	if (!high_bit_depth) {
60	if (avctx->idct_algo == FF_IDCT_AUTO \|\|
61	avctx->idct_algo == FF_IDCT_SIMPLEARMV6) {
62	c->idct_put = ff_simple_idct_put_armv6;
63	c->idct_add = ff_simple_idct_add_armv6;
64	c->idct = ff_simple_idct_armv6;
65	c->idct_permutation_type = FF_LIBMPEG2_IDCT_PERM;
66	}
67	}
68	c->add_pixels_clamped = ff_add_pixels_clamped_armv6;
69
70	if (!high_bit_depth)	52	if (!high_bit_depth)
71	c->get_pixels = ff_get_pixels_armv6;	53	c->get_pixels = ff_get_pixels_armv6;
72	c->diff_pixels = ff_diff_pixels_armv6;	54	c->diff_pixels = ff_diff_pixels_armv6;

libavcodec/arm/idctdsp_arm.Srenamed from libavcodec/arm/dsputil_arm.S+1−1

@@ -1,5 +1,5 @@
1	@	1	@
2	@ ARMv4 optimized DSP utils	2	@ ARMv4-optimized IDCT functions
3	@ Copyright (c) 2004 AGAWA Koji <i (AT) atty (DOT) jp>	3	@ Copyright (c) 2004 AGAWA Koji <i (AT) atty (DOT) jp>
4	@	4	@
5	@ This file is part of Libav.	5	@ This file is part of Libav.

libavcodec/arm/idctdsp_arm.h+34−0

@@ -0,0 +1,34 @@
	1	/*
	2	* Copyright (c) 2009 Mans Rullgard <mans@mansr.com>
	3	*
	4	* This file is part of Libav.
	5	*
	6	* Libav is free software; you can redistribute it and/or
	7	* modify it under the terms of the GNU Lesser General Public
	8	* License as published by the Free Software Foundation; either
	9	* version 2.1 of the License, or (at your option) any later version.
	10	*
	11	* Libav is distributed in the hope that it will be useful,
	12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	14	* Lesser General Public License for more details.
	15	*
	16	* You should have received a copy of the GNU Lesser General Public
	17	* License along with Libav; if not, write to the Free Software
	18	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
	19	*/
	20
	21	#ifndef AVCODEC_ARM_IDCTDSP_ARM_H
	22	#define AVCODEC_ARM_IDCTDSP_ARM_H
	23
	24	#include "libavcodec/avcodec.h"
	25	#include "libavcodec/idctdsp.h"
	26
	27	void ff_idctdsp_init_armv5te(IDCTDSPContext c, AVCodecContext avctx,
	28	unsigned high_bit_depth);
	29	void ff_idctdsp_init_armv6(IDCTDSPContext c, AVCodecContext avctx,
	30	unsigned high_bit_depth);
	31	void ff_idctdsp_init_neon(IDCTDSPContext c, AVCodecContext avctx,
	32	unsigned high_bit_depth);
	33
	34	#endif /* AVCODEC_ARM_IDCTDSP_ARM_H */

libavcodec/arm/idctdsp_armv6.S+48−0

@@ -0,0 +1,48 @@
	1	/*
	2	* Copyright (c) 2009 Mans Rullgard <mans@mansr.com>
	3	*
	4	* This file is part of Libav.
	5	*
	6	* Libav is free software; you can redistribute it and/or
	7	* modify it under the terms of the GNU Lesser General Public
	8	* License as published by the Free Software Foundation; either
	9	* version 2.1 of the License, or (at your option) any later version.
	10	*
	11	* Libav is distributed in the hope that it will be useful,
	12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	14	* Lesser General Public License for more details.
	15	*
	16	* You should have received a copy of the GNU Lesser General Public
	17	* License along with Libav; if not, write to the Free Software
	18	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
	19	*/
	20
	21	#include "libavutil/arm/asm.S"
	22
	23	function ff_add_pixels_clamped_armv6, export=1
	24	push {r4-r8,lr}
	25	mov r3, #8
	26	1:
	27	ldm r0!, {r4,r5,r12,lr}
	28	ldrd r6, r7, [r1]
	29	pkhbt r8, r4, r5, lsl #16
	30	pkhtb r5, r5, r4, asr #16
	31	pkhbt r4, r12, lr, lsl #16
	32	pkhtb lr, lr, r12, asr #16
	33	pld [r1, r2]
	34	uxtab16 r8, r8, r6
	35	uxtab16 r5, r5, r6, ror #8
	36	uxtab16 r4, r4, r7
	37	uxtab16 lr, lr, r7, ror #8
	38	usat16 r8, #8, r8
	39	usat16 r5, #8, r5
	40	usat16 r4, #8, r4
	41	usat16 lr, #8, lr
	42	orr r6, r8, r5, lsl #8
	43	orr r7, r4, lr, lsl #8
	44	subs r3, r3, #1
	45	strd_post r6, r7, r1, r2
	46	bgt 1b
	47	pop {r4-r8,pc}
	48	endfunc

libavcodec/arm/idctdsp_init_arm.c+98−0

@@ -0,0 +1,98 @@
	1	/*
	2	* ARM-optimized IDCT functions
	3	* Copyright (c) 2001 Lionel Ulmer
	4	*
	5	* This file is part of Libav.
	6	*
	7	* Libav 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	* Libav 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 Libav; if not, write to the Free Software
	19	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
	20	*/
	21
	22	#include <stdint.h>
	23
	24	#include "libavutil/attributes.h"
	25	#include "libavutil/cpu.h"
	26	#include "libavutil/arm/cpu.h"
	27	#include "libavcodec/avcodec.h"
	28	#include "libavcodec/idctdsp.h"
	29	#include "idctdsp_arm.h"
	30
	31	void ff_j_rev_dct_arm(int16_t *data);
	32	void ff_simple_idct_arm(int16_t *data);
	33
	34	/* XXX: local hack */
	35	static void (ff_put_pixels_clamped)(const int16_t block, uint8_t *pixels, int line_size);
	36	static void (ff_add_pixels_clamped)(const int16_t block, uint8_t *pixels, int line_size);
	37
	38	void ff_add_pixels_clamped_arm(const int16_t block, uint8_t dest,
	39	int line_size);
	40
	41	/* XXX: those functions should be suppressed ASAP when all IDCTs are
	42	* converted */
	43	static void j_rev_dct_arm_put(uint8_t dest, int line_size, int16_t block)
	44	{
	45	ff_j_rev_dct_arm(block);
	46	ff_put_pixels_clamped(block, dest, line_size);
	47	}
	48
	49	static void j_rev_dct_arm_add(uint8_t dest, int line_size, int16_t block)
	50	{
	51	ff_j_rev_dct_arm(block);
	52	ff_add_pixels_clamped(block, dest, line_size);
	53	}
	54
	55	static void simple_idct_arm_put(uint8_t dest, int line_size, int16_t block)
	56	{
	57	ff_simple_idct_arm(block);
	58	ff_put_pixels_clamped(block, dest, line_size);
	59	}
	60
	61	static void simple_idct_arm_add(uint8_t dest, int line_size, int16_t block)
	62	{
	63	ff_simple_idct_arm(block);
	64	ff_add_pixels_clamped(block, dest, line_size);
	65	}
	66
	67	av_cold void ff_idctdsp_init_arm(IDCTDSPContext c, AVCodecContext avctx,
	68	unsigned high_bit_depth)
	69	{
	70	int cpu_flags = av_get_cpu_flags();
	71
	72	ff_put_pixels_clamped = c->put_pixels_clamped;
	73	ff_add_pixels_clamped = c->add_pixels_clamped;
	74
	75	if (!high_bit_depth) {
	76	if (avctx->idct_algo == FF_IDCT_AUTO \|\|
	77	avctx->idct_algo == FF_IDCT_ARM) {
	78	c->idct_put = j_rev_dct_arm_put;
	79	c->idct_add = j_rev_dct_arm_add;
	80	c->idct = ff_j_rev_dct_arm;
	81	c->idct_permutation_type = FF_LIBMPEG2_IDCT_PERM;
	82	} else if (avctx->idct_algo == FF_IDCT_SIMPLEARM) {
	83	c->idct_put = simple_idct_arm_put;
	84	c->idct_add = simple_idct_arm_add;
	85	c->idct = ff_simple_idct_arm;
	86	c->idct_permutation_type = FF_NO_IDCT_PERM;
	87	}
	88	}
	89
	90	c->add_pixels_clamped = ff_add_pixels_clamped_arm;
	91
	92	if (have_armv5te(cpu_flags))
	93	ff_idctdsp_init_armv5te(c, avctx, high_bit_depth);
	94	if (have_armv6(cpu_flags))
	95	ff_idctdsp_init_armv6(c, avctx, high_bit_depth);
	96	if (have_neon(cpu_flags))
	97	ff_idctdsp_init_neon(c, avctx, high_bit_depth);
	98	}

libavcodec/arm/idctdsp_init_armv5te.crenamed from libavcodec/arm/dsputil_init_armv5te.c+3−3

@@ -22,14 +22,14 @@ · 21 unmodified lines
22		22
23	#include "libavutil/attributes.h"	23	#include "libavutil/attributes.h"
24	#include "libavcodec/avcodec.h"	24	#include "libavcodec/avcodec.h"
25	#include "libavcodec/dsputil.h"	25	#include "libavcodec/idctdsp.h"
26	#include "dsputil_arm.h"	26	#include "idctdsp_arm.h"
27		27
28	void ff_simple_idct_armv5te(int16_t *data);	28	void ff_simple_idct_armv5te(int16_t *data);
29	void ff_simple_idct_put_armv5te(uint8_t dest, int line_size, int16_t data);	29	void ff_simple_idct_put_armv5te(uint8_t dest, int line_size, int16_t data);
30	void ff_simple_idct_add_armv5te(uint8_t dest, int line_size, int16_t data);	30	void ff_simple_idct_add_armv5te(uint8_t dest, int line_size, int16_t data);
31		31
32	av_cold void ff_dsputil_init_armv5te(DSPContext c, AVCodecContext avctx,	32	av_cold void ff_idctdsp_init_armv5te(IDCTDSPContext c, AVCodecContext avctx,
33	unsigned high_bit_depth)	33	unsigned high_bit_depth)
34	{	34	{
35	if (!high_bit_depth &&	35	if (!high_bit_depth &&

libavcodec/arm/idctdsp_init_armv6.c+48−0

@@ -0,0 +1,48 @@
	1	/*
	2	* Copyright (c) 2009 Mans Rullgard <mans@mansr.com>
	3	*
	4	* This file is part of Libav.
	5	*
	6	* Libav is free software; you can redistribute it and/or
	7	* modify it under the terms of the GNU Lesser General Public
	8	* License as published by the Free Software Foundation; either
	9	* version 2.1 of the License, or (at your option) any later version.
	10	*
	11	* Libav is distributed in the hope that it will be useful,
	12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	14	* Lesser General Public License for more details.
	15	*
	16	* You should have received a copy of the GNU Lesser General Public
	17	* License along with Libav; if not, write to the Free Software
	18	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
	19	*/
	20
	21	#include <stdint.h>
	22
	23	#include "libavutil/attributes.h"
	24	#include "libavcodec/avcodec.h"
	25	#include "libavcodec/idctdsp.h"
	26	#include "idctdsp_arm.h"
	27
	28	void ff_simple_idct_armv6(int16_t *data);
	29	void ff_simple_idct_put_armv6(uint8_t dest, int line_size, int16_t data);
	30	void ff_simple_idct_add_armv6(uint8_t dest, int line_size, int16_t data);
	31
	32	void ff_add_pixels_clamped_armv6(const int16_t block, uint8_t pixels,
	33	int line_size);
	34
	35	av_cold void ff_idctdsp_init_armv6(IDCTDSPContext c, AVCodecContext avctx,
	36	unsigned high_bit_depth)
	37	{
	38	if (!high_bit_depth) {
	39	if (avctx->idct_algo == FF_IDCT_AUTO \|\|
	40	avctx->idct_algo == FF_IDCT_SIMPLEARMV6) {
	41	c->idct_put = ff_simple_idct_put_armv6;
	42	c->idct_add = ff_simple_idct_add_armv6;
	43	c->idct = ff_simple_idct_armv6;
	44	c->idct_permutation_type = FF_LIBMPEG2_IDCT_PERM;
	45	}
	46	}
	47	c->add_pixels_clamped = ff_add_pixels_clamped_armv6;
	48	}

libavcodec/arm/idctdsp_init_neon.crenamed from libavcodec/arm/dsputil_init_neon.c+4−4

@@ -1,5 +1,5 @@
1	/*	1	/*
2	* ARM NEON optimised DSP functions	2	* ARM-NEON-optimized IDCT functions
3	* Copyright (c) 2008 Mans Rullgard <mans@mansr.com>	3	* Copyright (c) 2008 Mans Rullgard <mans@mansr.com>
4	*	4	*
5	* This file is part of Libav.	5	* This file is part of Libav.
@@ -23,8 +23,8 @@ · 17 unmodified lines
23		23
24	#include "libavutil/attributes.h"	24	#include "libavutil/attributes.h"
25	#include "libavcodec/avcodec.h"	25	#include "libavcodec/avcodec.h"
26	#include "libavcodec/dsputil.h"	26	#include "libavcodec/idctdsp.h"
27	#include "dsputil_arm.h"	27	#include "idctdsp_arm.h"
28		28
29	void ff_simple_idct_neon(int16_t *data);	29	void ff_simple_idct_neon(int16_t *data);
30	void ff_simple_idct_put_neon(uint8_t dest, int line_size, int16_t data);	30	void ff_simple_idct_put_neon(uint8_t dest, int line_size, int16_t data);
@@ -34,7 +34,7 @@ void ff_add_pixels_clamped_neon(const int16_t , uint8_t , int); · 3 unmodified lines
34	void ff_put_pixels_clamped_neon(const int16_t , uint8_t , int);	34	void ff_put_pixels_clamped_neon(const int16_t , uint8_t , int);
35	void ff_put_signed_pixels_clamped_neon(const int16_t , uint8_t , int);	35	void ff_put_signed_pixels_clamped_neon(const int16_t , uint8_t , int);
36		36
37	av_cold void ff_dsputil_init_neon(DSPContext c, AVCodecContext avctx,	37	av_cold void ff_idctdsp_init_neon(IDCTDSPContext c, AVCodecContext avctx,
38	unsigned high_bit_depth)	38	unsigned high_bit_depth)
39	{	39	{
40	if (!high_bit_depth) {	40	if (!high_bit_depth) {

libavcodec/arm/idctdsp_neon.Srenamed from libavcodec/arm/dsputil_neon.S+1−1

@@ -1,5 +1,5 @@
1	/*	1	/*
2	* ARM NEON optimised DSP functions	2	* ARM-NEON-optimized IDCT functions
3	* Copyright (c) 2008 Mans Rullgard <mans@mansr.com>	3	* Copyright (c) 2008 Mans Rullgard <mans@mansr.com>
4	*	4	*
5	* This file is part of Libav.	5	* This file is part of Libav.

libavcodec/asv.c+0−1

@@ -84,7 +84,6 @@ av_cold void ff_asv_common_init(AVCodecContext *avctx) { · 83 unmodified lines
84	ASV1Context * const a = avctx->priv_data;	84	ASV1Context * const a = avctx->priv_data;
85		85
86	ff_bswapdsp_init(&a->bbdsp);	86	ff_bswapdsp_init(&a->bbdsp);
87	ff_dsputil_init(&a->dsp, avctx);
88		87
89	a->mb_width = (avctx->width + 15) / 16;	88	a->mb_width = (avctx->width + 15) / 16;
90	a->mb_height = (avctx->height + 15) / 16;	89	a->mb_height = (avctx->height + 15) / 16;

libavcodec/asv.h+2−0

 #include "blockdsp.h"
 #include "bswapdsp.h"
 #include "dsputil.h"
+#include "idctdsp.h"
 #include "get_bits.h"
 #include "put_bits.h"
     BlockDSPContext bdsp;
     BswapDSPContext bbdsp;
     DSPContext dsp;
+    IDCTDSPContext idsp;
     PutBitContext pb;
     GetBitContext gb;
     ScanTable scantable;

libavcodec/asvdec.c+9−7

 #include "avcodec.h"
 #include "blockdsp.h"
 #include "put_bits.h"
+#include "idctdsp.h"
 #include "internal.h"
 #include "mathops.h"
 #include "mpeg12data.h"
     uint8_t *dest_cb = frame->data[1] + (mb_y * 8 * frame->linesize[1]) + mb_x * 8;
     uint8_t *dest_cr = frame->data[2] + (mb_y * 8 * frame->linesize[2]) + mb_x * 8;
-    a->dsp.idct_put(dest_y                 , linesize, block[0]);
+    a->idsp.idct_put(dest_y,                    linesize, block[0]);
-    a->dsp.idct_put(dest_y              + 8, linesize, block[1]);
+    a->idsp.idct_put(dest_y + 8,                linesize, block[1]);
-    a->dsp.idct_put(dest_y + 8*linesize    , linesize, block[2]);
+    a->idsp.idct_put(dest_y + 8 * linesize,     linesize, block[2]);
-    a->dsp.idct_put(dest_y + 8*linesize + 8, linesize, block[3]);
+    a->idsp.idct_put(dest_y + 8 * linesize + 8, linesize, block[3]);
     if (!(a->avctx->flags&CODEC_FLAG_GRAY)) {
-        a->dsp.idct_put(dest_cb, frame->linesize[1], block[4]);
+        a->idsp.idct_put(dest_cb, frame->linesize[1], block[4]);
-        a->dsp.idct_put(dest_cr, frame->linesize[2], block[5]);
+        a->idsp.idct_put(dest_cr, frame->linesize[2], block[5]);
     }
 }
     ff_asv_common_init(avctx);
     ff_blockdsp_init(&a->bdsp, avctx);
+    ff_idctdsp_init(&a->idsp, avctx);
     init_vlcs(a);
-    ff_init_scantable(a->dsp.idct_permutation, &a->scantable, ff_asv_scantab);
+    ff_init_scantable(a->idsp.idct_permutation, &a->scantable, ff_asv_scantab);
     avctx->pix_fmt = AV_PIX_FMT_YUV420P;
     a->inv_qscale = avctx->extradata[0];

libavcodec/asvenc.c+1−0

@@ -247,6 +247,7 @@ static av_cold int encode_init(AVCodecContext *avctx){ · 246 unmodified lines
247	avctx->coded_frame->key_frame = 1;	247	avctx->coded_frame->key_frame = 1;
248		248
249	ff_asv_common_init(avctx);	249	ff_asv_common_init(avctx);
		250	ff_dsputil_init(&a->dsp, avctx);
250		251
251	if(avctx->global_quality == 0) avctx->global_quality= 4*FF_QUALITY_SCALE;	252	if(avctx->global_quality == 0) avctx->global_quality= 4*FF_QUALITY_SCALE;
252		253

libavcodec/cavs.c+4−3

 #include "get_bits.h"
 #include "golomb.h"
 #include "h264chroma.h"
+#include "idctdsp.h"
 #include "mathops.h"
 #include "qpeldsp.h"
 #include "cavs.h"
     AVSContext *h = avctx->priv_data;
     ff_blockdsp_init(&h->bdsp, avctx);
-    ff_dsputil_init(&h->dsp, avctx);
     ff_h264chroma_init(&h->h264chroma, 8);
+    ff_idctdsp_init(&h->idsp, avctx);
     ff_videodsp_init(&h->vdsp, 8);
     ff_cavsdsp_init(&h->cdsp, avctx);
-    ff_init_scantable_permutation(h->dsp.idct_permutation,
+    ff_init_scantable_permutation(h->idsp.idct_permutation,
                                   h->cdsp.idct_perm);
-    ff_init_scantable(h->dsp.idct_permutation, &h->scantable, ff_zigzag_direct);
+    ff_init_scantable(h->idsp.idct_permutation, &h->scantable, ff_zigzag_direct);
     h->avctx       = avctx;
     avctx->pix_fmt = AV_PIX_FMT_YUV420P;

libavcodec/cavs.h+2−2

 #include "cavsdsp.h"
 #include "blockdsp.h"
-#include "dsputil.h"
 #include "h264chroma.h"
+#include "idctdsp.h"
 #include "get_bits.h"
 #include "videodsp.h"
 typedef struct AVSContext {
     AVCodecContext *avctx;
-    DSPContext       dsp;
     BlockDSPContext bdsp;
     H264ChromaContext h264chroma;
+    IDCTDSPContext idsp;
     VideoDSPContext vdsp;
     CAVSDSPContext  cdsp;
     GetBitContext gb;

libavcodec/cavsdsp.c+1−1

@@ -24,7 +24,7 @@ · 23 unmodified lines
24		24
25	#include <stdio.h>	25	#include <stdio.h>
26		26
27	#include "dsputil.h"	27	#include "idctdsp.h"
28	#include "mathops.h"	28	#include "mathops.h"
29	#include "cavsdsp.h"	29	#include "cavsdsp.h"
30	#include "libavutil/common.h"	30	#include "libavutil/common.h"

libavcodec/dnxhddec.c+26−26

@@ -28,7 +28,7 @@ · 27 unmodified lines
28	#include "blockdsp.h"	28	#include "blockdsp.h"
29	#include "get_bits.h"	29	#include "get_bits.h"
30	#include "dnxhddata.h"	30	#include "dnxhddata.h"
31	#include "dsputil.h"	31	#include "idctdsp.h"
32	#include "internal.h"	32	#include "internal.h"
33		33
34	typedef struct DNXHDContext {	34	typedef struct DNXHDContext {
@@ -42,7 +42,7 @@ typedef struct DNXHDContext { · 7 unmodified lines
42	int cur_field; ///< current interlaced field	42	int cur_field; ///< current interlaced field
43	VLC ac_vlc, dc_vlc, run_vlc;	43	VLC ac_vlc, dc_vlc, run_vlc;
44	int last_dc[3];	44	int last_dc[3];
45	DSPContext dsp;	45	IDCTDSPContext idsp;
46	DECLARE_ALIGNED(16, int16_t, blocks)[12][64];	46	DECLARE_ALIGNED(16, int16_t, blocks)[12][64];
47	ScanTable scantable;	47	ScanTable scantable;
48	const CIDEntry *cid_table;	48	const CIDEntry *cid_table;
@@ -95,7 +95,7 @@ static int dnxhd_init_vlc(DNXHDContext *ctx, int cid) · 46 unmodified lines
95	ctx->cid_table->run_bits, 1, 1,	95	ctx->cid_table->run_bits, 1, 1,
96	ctx->cid_table->run_codes, 2, 2, 0);	96	ctx->cid_table->run_codes, 2, 2, 0);
97		97
98	ff_init_scantable(ctx->dsp.idct_permutation, &ctx->scantable,	98	ff_init_scantable(ctx->idsp.idct_permutation, &ctx->scantable,
99	ff_zigzag_direct);	99	ff_zigzag_direct);
100	ctx->cid = cid;	100	ctx->cid = cid;
101	}	101	}
@@ -136,7 +136,7 @@ static int dnxhd_decode_header(DNXHDContext ctx, AVFrame frame, · 34 unmodified lines
136	ctx->avctx->bits_per_raw_sample = 10;	136	ctx->avctx->bits_per_raw_sample = 10;
137	if (ctx->bit_depth != 10) {	137	if (ctx->bit_depth != 10) {
138	ff_blockdsp_init(&ctx->bdsp, ctx->avctx);	138	ff_blockdsp_init(&ctx->bdsp, ctx->avctx);
139	ff_dsputil_init(&ctx->dsp, ctx->avctx);	139	ff_idctdsp_init(&ctx->idsp, ctx->avctx);
140	ctx->bit_depth = 10;	140	ctx->bit_depth = 10;
141	ctx->decode_dct_block = dnxhd_decode_dct_block_10_444;	141	ctx->decode_dct_block = dnxhd_decode_dct_block_10_444;
142	}	142	}
@@ -146,7 +146,7 @@ static int dnxhd_decode_header(DNXHDContext ctx, AVFrame frame, · 3 unmodified lines
146	ctx->avctx->bits_per_raw_sample = 10;	146	ctx->avctx->bits_per_raw_sample = 10;
147	if (ctx->bit_depth != 10) {	147	if (ctx->bit_depth != 10) {
148	ff_blockdsp_init(&ctx->bdsp, ctx->avctx);	148	ff_blockdsp_init(&ctx->bdsp, ctx->avctx);
149	ff_dsputil_init(&ctx->dsp, ctx->avctx);	149	ff_idctdsp_init(&ctx->idsp, ctx->avctx);
150	ctx->bit_depth = 10;	150	ctx->bit_depth = 10;
151	ctx->decode_dct_block = dnxhd_decode_dct_block_10;	151	ctx->decode_dct_block = dnxhd_decode_dct_block_10;
152	}	152	}
@@ -155,7 +155,7 @@ static int dnxhd_decode_header(DNXHDContext ctx, AVFrame frame, · 2 unmodified lines
155	ctx->avctx->bits_per_raw_sample = 8;	155	ctx->avctx->bits_per_raw_sample = 8;
156	if (ctx->bit_depth != 8) {	156	if (ctx->bit_depth != 8) {
157	ff_blockdsp_init(&ctx->bdsp, ctx->avctx);	157	ff_blockdsp_init(&ctx->bdsp, ctx->avctx);
158	ff_dsputil_init(&ctx->dsp, ctx->avctx);	158	ff_idctdsp_init(&ctx->idsp, ctx->avctx);
159	ctx->bit_depth = 8;	159	ctx->bit_depth = 8;
160	ctx->decode_dct_block = dnxhd_decode_dct_block_8;	160	ctx->decode_dct_block = dnxhd_decode_dct_block_8;
161	}	161	}
@@ -340,34 +340,34 @@ static int dnxhd_decode_macroblock(DNXHDContext ctx, AVFrame frame, · 178 unmodified lines
340	dct_y_offset = dct_linesize_luma << 3;	340	dct_y_offset = dct_linesize_luma << 3;
341	dct_x_offset = 8 << shift1;	341	dct_x_offset = 8 << shift1;
342	if (!ctx->is_444) {	342	if (!ctx->is_444) {
343	ctx->dsp.idct_put(dest_y, dct_linesize_luma, ctx->blocks[0]);	343	ctx->idsp.idct_put(dest_y, dct_linesize_luma, ctx->blocks[0]);
344	ctx->dsp.idct_put(dest_y + dct_x_offset, dct_linesize_luma, ctx->blocks[1]);	344	ctx->idsp.idct_put(dest_y + dct_x_offset, dct_linesize_luma, ctx->blocks[1]);
345	ctx->dsp.idct_put(dest_y + dct_y_offset, dct_linesize_luma, ctx->blocks[4]);	345	ctx->idsp.idct_put(dest_y + dct_y_offset, dct_linesize_luma, ctx->blocks[4]);
346	ctx->dsp.idct_put(dest_y + dct_y_offset + dct_x_offset, dct_linesize_luma, ctx->blocks[5]);	346	ctx->idsp.idct_put(dest_y + dct_y_offset + dct_x_offset, dct_linesize_luma, ctx->blocks[5]);
347		347
348	if (!(ctx->avctx->flags & CODEC_FLAG_GRAY)) {	348	if (!(ctx->avctx->flags & CODEC_FLAG_GRAY)) {
349	dct_y_offset = dct_linesize_chroma << 3;	349	dct_y_offset = dct_linesize_chroma << 3;
350	ctx->dsp.idct_put(dest_u, dct_linesize_chroma, ctx->blocks[2]);	350	ctx->idsp.idct_put(dest_u, dct_linesize_chroma, ctx->blocks[2]);
351	ctx->dsp.idct_put(dest_v, dct_linesize_chroma, ctx->blocks[3]);	351	ctx->idsp.idct_put(dest_v, dct_linesize_chroma, ctx->blocks[3]);
352	ctx->dsp.idct_put(dest_u + dct_y_offset, dct_linesize_chroma, ctx->blocks[6]);	352	ctx->idsp.idct_put(dest_u + dct_y_offset, dct_linesize_chroma, ctx->blocks[6]);
353	ctx->dsp.idct_put(dest_v + dct_y_offset, dct_linesize_chroma, ctx->blocks[7]);	353	ctx->idsp.idct_put(dest_v + dct_y_offset, dct_linesize_chroma, ctx->blocks[7]);
354	}	354	}
355	} else {	355	} else {
356	ctx->dsp.idct_put(dest_y, dct_linesize_luma, ctx->blocks[0]);	356	ctx->idsp.idct_put(dest_y, dct_linesize_luma, ctx->blocks[0]);
357	ctx->dsp.idct_put(dest_y + dct_x_offset, dct_linesize_luma, ctx->blocks[1]);	357	ctx->idsp.idct_put(dest_y + dct_x_offset, dct_linesize_luma, ctx->blocks[1]);
358	ctx->dsp.idct_put(dest_y + dct_y_offset, dct_linesize_luma, ctx->blocks[6]);	358	ctx->idsp.idct_put(dest_y + dct_y_offset, dct_linesize_luma, ctx->blocks[6]);
359	ctx->dsp.idct_put(dest_y + dct_y_offset + dct_x_offset, dct_linesize_luma, ctx->blocks[7]);	359	ctx->idsp.idct_put(dest_y + dct_y_offset + dct_x_offset, dct_linesize_luma, ctx->blocks[7]);
360		360
361	if (!(ctx->avctx->flags & CODEC_FLAG_GRAY)) {	361	if (!(ctx->avctx->flags & CODEC_FLAG_GRAY)) {
362	dct_y_offset = dct_linesize_chroma << 3;	362	dct_y_offset = dct_linesize_chroma << 3;
363	ctx->dsp.idct_put(dest_u, dct_linesize_chroma, ctx->blocks[2]);	363	ctx->idsp.idct_put(dest_u, dct_linesize_chroma, ctx->blocks[2]);
364	ctx->dsp.idct_put(dest_u + dct_x_offset, dct_linesize_chroma, ctx->blocks[3]);	364	ctx->idsp.idct_put(dest_u + dct_x_offset, dct_linesize_chroma, ctx->blocks[3]);
365	ctx->dsp.idct_put(dest_u + dct_y_offset, dct_linesize_chroma, ctx->blocks[8]);	365	ctx->idsp.idct_put(dest_u + dct_y_offset, dct_linesize_chroma, ctx->blocks[8]);
366	ctx->dsp.idct_put(dest_u + dct_y_offset + dct_x_offset, dct_linesize_chroma, ctx->blocks[9]);	366	ctx->idsp.idct_put(dest_u + dct_y_offset + dct_x_offset, dct_linesize_chroma, ctx->blocks[9]);
367	ctx->dsp.idct_put(dest_v, dct_linesize_chroma, ctx->blocks[4]);	367	ctx->idsp.idct_put(dest_v, dct_linesize_chroma, ctx->blocks[4]);
368	ctx->dsp.idct_put(dest_v + dct_x_offset, dct_linesize_chroma, ctx->blocks[5]);	368	ctx->idsp.idct_put(dest_v + dct_x_offset, dct_linesize_chroma, ctx->blocks[5]);
369	ctx->dsp.idct_put(dest_v + dct_y_offset, dct_linesize_chroma, ctx->blocks[10]);	369	ctx->idsp.idct_put(dest_v + dct_y_offset, dct_linesize_chroma, ctx->blocks[10]);
370	ctx->dsp.idct_put(dest_v + dct_y_offset + dct_x_offset, dct_linesize_chroma, ctx->blocks[11]);	370	ctx->idsp.idct_put(dest_v + dct_y_offset + dct_x_offset, dct_linesize_chroma, ctx->blocks[11]);
371	}	371	}
372	}	372	}
373		373

libavcodec/dnxhdenc.c+5−4

     if (ctx->cid_table->bit_depth == 8) {
         for (i = 1; i < 64; i++) {
-            int j = ctx->m.dsp.idct_permutation[ff_zigzag_direct[i]];
+            int j = ctx->m.idsp.idct_permutation[ff_zigzag_direct[i]];
             weight_matrix[j] = ctx->cid_table->luma_weight[i];
         }
         ff_convert_matrix(&ctx->m, ctx->qmatrix_l, ctx->qmatrix_l16,
                           weight_matrix, ctx->m.intra_quant_bias, 1,
                           ctx->m.avctx->qmax, 1);
         for (i = 1; i < 64; i++) {
-            int j = ctx->m.dsp.idct_permutation[ff_zigzag_direct[i]];
+            int j = ctx->m.idsp.idct_permutation[ff_zigzag_direct[i]];
             weight_matrix[j] = ctx->cid_table->chroma_weight[i];
         }
         ff_convert_matrix(&ctx->m, ctx->qmatrix_c, ctx->qmatrix_c16,
         // 10-bit
         for (qscale = 1; qscale <= ctx->m.avctx->qmax; qscale++) {
             for (i = 1; i < 64; i++) {
-                int j = ctx->m.dsp.idct_permutation[ff_zigzag_direct[i]];
+                int j = ctx->m.idsp.idct_permutation[ff_zigzag_direct[i]];
                 /* The quantization formula from the VC-3 standard is:
                  * quantized = sign(block[i]) * floor(abs(block[i]/s) * p /
     ff_blockdsp_init(&ctx->bdsp, avctx);
     ff_dsputil_init(&ctx->m.dsp, avctx);
+    ff_idctdsp_init(&ctx->m.idsp, avctx);
     ff_dct_common_init(&ctx->m);
     if (!ctx->m.dct_quantize)
         ctx->m.dct_quantize = ff_dct_quantize_c;
             if (avctx->mb_decision == FF_MB_DECISION_RD || !RC_VARIANCE) {
                 dnxhd_unquantize_c(ctx, block, i, qscale, last_index);
-                ctx->m.dsp.idct(block);
+                ctx->m.idsp.idct(block);
                 ssd += dnxhd_ssd_block(block, src_block);
             }
         }

libavcodec/dsputil.c+1−161

@@ -33,7 +33,6 @@ · 32 unmodified lines
33	#include "dsputil.h"	33	#include "dsputil.h"
34	#include "simple_idct.h"	34	#include "simple_idct.h"
35	#include "faandct.h"	35	#include "faandct.h"
36	#include "faanidct.h"
37	#include "imgconvert.h"	36	#include "imgconvert.h"
38	#include "mathops.h"	37	#include "mathops.h"
39	#include "mpegvideo.h"	38	#include "mpegvideo.h"
@@ -48,60 +47,6 @@ uint32_t ff_square_tab[512] = { 0, }; · 8 unmodified lines
48	#define BIT_DEPTH 8	47	#define BIT_DEPTH 8
49	#include "dsputilenc_template.c"	48	#include "dsputilenc_template.c"
50		49
51	av_cold void ff_init_scantable(uint8_t permutation, ScanTable st,
52	const uint8_t *src_scantable)
53	{
54	int i, end;
55
56	st->scantable = src_scantable;
57
58	for (i = 0; i < 64; i++) {
59	int j = src_scantable[i];
60	st->permutated[i] = permutation[j];
61	}
62
63	end = -1;
64	for (i = 0; i < 64; i++) {
65	int j = st->permutated[i];
66	if (j > end)
67	end = j;
68	st->raster_end[i] = end;
69	}
70	}
71
72	av_cold void ff_init_scantable_permutation(uint8_t *idct_permutation,
73	int idct_permutation_type)
74	{
75	int i;
76
77	if (ARCH_X86)
78	if (ff_init_scantable_permutation_x86(idct_permutation,
79	idct_permutation_type))
80	return;
81
82	switch (idct_permutation_type) {
83	case FF_NO_IDCT_PERM:
84	for (i = 0; i < 64; i++)
85	idct_permutation[i] = i;
86	break;
87	case FF_LIBMPEG2_IDCT_PERM:
88	for (i = 0; i < 64; i++)
89	idct_permutation[i] = (i & 0x38) \| ((i & 6) >> 1) \| ((i & 1) << 2);
90	break;
91	case FF_TRANSPOSE_IDCT_PERM:
92	for (i = 0; i < 64; i++)
93	idct_permutation[i] = ((i & 7) << 3) \| (i >> 3);
94	break;
95	case FF_PARTTRANS_IDCT_PERM:
96	for (i = 0; i < 64; i++)
97	idct_permutation[i] = (i & 0x24) \| ((i & 3) << 3) \| ((i >> 3) & 3);
98	break;
99	default:
100	av_log(NULL, AV_LOG_ERROR,
101	"Internal error, IDCT permutation not set\n");
102	}
103	}
104
105	static int pix_sum_c(uint8_t *pix, int line_size)	50	static int pix_sum_c(uint8_t *pix, int line_size)
106	{	51	{
107	int s = 0, i, j;	52	int s = 0, i, j;
@@ -259,68 +204,6 @@ static void diff_pixels_c(int16_t restrict block, const uint8_t s1, · 151 unmodified lines
259	}	204	}
260	}	205	}
261		206
262	static void put_pixels_clamped_c(const int16_t block, uint8_t restrict pixels,
263	int line_size)
264	{
265	int i;
266
267	/* read the pixels */
268	for (i = 0; i < 8; i++) {
269	pixels[0] = av_clip_uint8(block[0]);
270	pixels[1] = av_clip_uint8(block[1]);
271	pixels[2] = av_clip_uint8(block[2]);
272	pixels[3] = av_clip_uint8(block[3]);
273	pixels[4] = av_clip_uint8(block[4]);
274	pixels[5] = av_clip_uint8(block[5]);
275	pixels[6] = av_clip_uint8(block[6]);
276	pixels[7] = av_clip_uint8(block[7]);
277
278	pixels += line_size;
279	block += 8;
280	}
281	}
282
283	static void put_signed_pixels_clamped_c(const int16_t *block,
284	uint8_t *restrict pixels,
285	int line_size)
286	{
287	int i, j;
288
289	for (i = 0; i < 8; i++) {
290	for (j = 0; j < 8; j++) {
291	if (*block < -128)
292	*pixels = 0;
293	else if (*block > 127)
294	*pixels = 255;
295	else
296	pixels = (uint8_t) (block + 128);
297	block++;
298	pixels++;
299	}
300	pixels += (line_size - 8);
301	}
302	}
303
304	static void add_pixels_clamped_c(const int16_t block, uint8_t restrict pixels,
305	int line_size)
306	{
307	int i;
308
309	/* read the pixels */
310	for (i = 0; i < 8; i++) {
311	pixels[0] = av_clip_uint8(pixels[0] + block[0]);
312	pixels[1] = av_clip_uint8(pixels[1] + block[1]);
313	pixels[2] = av_clip_uint8(pixels[2] + block[2]);
314	pixels[3] = av_clip_uint8(pixels[3] + block[3]);
315	pixels[4] = av_clip_uint8(pixels[4] + block[4]);
316	pixels[5] = av_clip_uint8(pixels[5] + block[5]);
317	pixels[6] = av_clip_uint8(pixels[6] + block[6]);
318	pixels[7] = av_clip_uint8(pixels[7] + block[7]);
319	pixels += line_size;
320	block += 8;
321	}
322	}
323
324	static int sum_abs_dctelem_c(int16_t *block)	207	static int sum_abs_dctelem_c(int16_t *block)
325	{	208	{
326	int sum = 0, i;	209	int sum = 0, i;
@@ -967,7 +850,7 @@ static int rd8x8_c(MpegEncContext s, uint8_t src1, uint8_t *src2, · 640 unmodified lines
967	s->dct_unquantize_inter(s, temp, 0, s->qscale);	850	s->dct_unquantize_inter(s, temp, 0, s->qscale);
968	}	851	}
969		852
970	s->dsp.idct_add(lsrc2, 8, temp);	853	s->idsp.idct_add(lsrc2, 8, temp);
971		854
972	distortion = s->dsp.sse[1](NULL, lsrc2, lsrc1, 8, 8);	855	distortion = s->dsp.sse[1](NULL, lsrc2, lsrc1, 8, 8);
973		856
@@ -1138,18 +1021,6 @@ WRAPPER8_16_SQ(quant_psnr8x8_c, quant_psnr16_c) · 164 unmodified lines
1138	WRAPPER8_16_SQ(rd8x8_c, rd16_c)	1021	WRAPPER8_16_SQ(rd8x8_c, rd16_c)
1139	WRAPPER8_16_SQ(bit8x8_c, bit16_c)	1022	WRAPPER8_16_SQ(bit8x8_c, bit16_c)
1140		1023
1141	static void jref_idct_put(uint8_t dest, int line_size, int16_t block)
1142	{
1143	ff_j_rev_dct(block);
1144	put_pixels_clamped_c(block, dest, line_size);
1145	}
1146
1147	static void jref_idct_add(uint8_t dest, int line_size, int16_t block)
1148	{
1149	ff_j_rev_dct(block);
1150	add_pixels_clamped_c(block, dest, line_size);
1151	}
1152
1153	/* draw the edges of width 'w' of an image of size width, height */	1024	/* draw the edges of width 'w' of an image of size width, height */
1154	// FIXME: Check that this is OK for MPEG-4 interlaced.	1025	// FIXME: Check that this is OK for MPEG-4 interlaced.
1155	static void draw_edges_8_c(uint8_t *buf, int wrap, int width, int height,	1026	static void draw_edges_8_c(uint8_t *buf, int wrap, int width, int height,
@@ -1209,36 +1080,8 @@ av_cold void ff_dsputil_init(DSPContext c, AVCodecContext avctx) · 53 unmodified lines
1209	}	1080	}
1210	#endif /* CONFIG_ENCODERS */	1081	#endif /* CONFIG_ENCODERS */
1211		1082
1212	if (avctx->bits_per_raw_sample == 10) {
1213	c->idct_put = ff_simple_idct_put_10;
1214	c->idct_add = ff_simple_idct_add_10;
1215	c->idct = ff_simple_idct_10;
1216	c->idct_permutation_type = FF_NO_IDCT_PERM;
1217	} else {
1218	if (avctx->idct_algo == FF_IDCT_INT) {
1219	c->idct_put = jref_idct_put;
1220	c->idct_add = jref_idct_add;
1221	c->idct = ff_j_rev_dct;
1222	c->idct_permutation_type = FF_LIBMPEG2_IDCT_PERM;
1223	} else if (avctx->idct_algo == FF_IDCT_FAAN) {
1224	c->idct_put = ff_faanidct_put;
1225	c->idct_add = ff_faanidct_add;
1226	c->idct = ff_faanidct;
1227	c->idct_permutation_type = FF_NO_IDCT_PERM;
1228	} else { // accurate/default
1229	c->idct_put = ff_simple_idct_put_8;
1230	c->idct_add = ff_simple_idct_add_8;
1231	c->idct = ff_simple_idct_8;
1232	c->idct_permutation_type = FF_NO_IDCT_PERM;
1233	}
1234	}
1235
1236	c->diff_pixels = diff_pixels_c;	1083	c->diff_pixels = diff_pixels_c;
1237		1084
1238	c->put_pixels_clamped = put_pixels_clamped_c;
1239	c->put_signed_pixels_clamped = put_signed_pixels_clamped_c;
1240	c->add_pixels_clamped = add_pixels_clamped_c;
1241
1242	c->sum_abs_dctelem = sum_abs_dctelem_c;	1085	c->sum_abs_dctelem = sum_abs_dctelem_c;
1243		1086
1244	c->pix_sum = pix_sum_c;	1087	c->pix_sum = pix_sum_c;
@@ -1309,7 +1152,4 @@ av_cold void ff_dsputil_init(DSPContext c, AVCodecContext avctx) · 64 unmodified lines
1309	ff_dsputil_init_ppc(c, avctx, high_bit_depth);	1152	ff_dsputil_init_ppc(c, avctx, high_bit_depth);
1310	if (ARCH_X86)	1153	if (ARCH_X86)
1311	ff_dsputil_init_x86(c, avctx, high_bit_depth);	1154	ff_dsputil_init_x86(c, avctx, high_bit_depth);
1312
1313	ff_init_scantable_permutation(c->idct_permutation,
1314	c->idct_permutation_type);
1315	}	1155	}

libavcodec/dsputil.h+0−66

@@ -44,22 +44,6 @@ typedef int (me_cmp_func)(struct MpegEncContext c, · 43 unmodified lines
44	uint8_t blk1 / align width (8 or 16) */,	44	uint8_t blk1 / align width (8 or 16) */,
45	uint8_t blk2 / align 1 */, int line_size, int h);	45	uint8_t blk2 / align 1 */, int line_size, int h);
46		46
47	/**
48	* Scantable.
49	*/
50	typedef struct ScanTable {
51	const uint8_t *scantable;
52	uint8_t permutated[64];
53	uint8_t raster_end[64];
54	} ScanTable;
55
56	void ff_init_scantable(uint8_t permutation, ScanTable st,
57	const uint8_t *src_scantable);
58	void ff_init_scantable_permutation(uint8_t *idct_permutation,
59	int idct_permutation_type);
60	int ff_init_scantable_permutation_x86(uint8_t *idct_permutation,
61	int idct_permutation_type);
62
63	/**	47	/**
64	* DSPContext.	48	* DSPContext.
65	*/	49	*/
@@ -72,15 +56,6 @@ typedef struct DSPContext { · 6 unmodified lines
72	const uint8_t s1 / align 8 */,	56	const uint8_t s1 / align 8 */,
73	const uint8_t s2 / align 8 */,	57	const uint8_t s2 / align 8 */,
74	int stride);	58	int stride);
75	void (put_pixels_clamped)(const int16_t block /* align 16 */,
76	uint8_t pixels / align 8 */,
77	int line_size);
78	void (put_signed_pixels_clamped)(const int16_t block /* align 16 */,
79	uint8_t pixels / align 8 */,
80	int line_size);
81	void (add_pixels_clamped)(const int16_t block /* align 16 */,
82	uint8_t pixels / align 8 */,
83	int line_size);
84	int (sum_abs_dctelem)(int16_t block /* align 16 */);	59	int (sum_abs_dctelem)(int16_t block /* align 16 */);
85		60
86	int (pix_sum)(uint8_t pix, int line_size);	61	int (pix_sum)(uint8_t pix, int line_size);
@@ -112,47 +87,6 @@ typedef struct DSPContext { · 25 unmodified lines
112	void (fdct)(int16_t block /* align 16 */);	87	void (fdct)(int16_t block /* align 16 */);
113	void (fdct248)(int16_t block /* align 16 */);	88	void (fdct248)(int16_t block /* align 16 */);
114		89
115	/* IDCT really */
116	void (idct)(int16_t block /* align 16 */);
117
118	/**
119	* block -> idct -> clip to unsigned 8 bit -> dest.
120	* (-1392, 0, 0, ...) -> idct -> (-174, -174, ...) -> put -> (0, 0, ...)
121	* @param line_size size in bytes of a horizontal line of dest
122	*/
123	void (idct_put)(uint8_t dest /* align 8 */,
124	int line_size, int16_t block / align 16 */);
125
126	/**
127	* block -> idct -> add dest -> clip to unsigned 8 bit -> dest.
128	* @param line_size size in bytes of a horizontal line of dest
129	*/
130	void (idct_add)(uint8_t dest /* align 8 */,
131	int line_size, int16_t block / align 16 */);
132
133	/**
134	* IDCT input permutation.
135	* Several optimized IDCTs need a permutated input (relative to the
136	* normal order of the reference IDCT).
137	* This permutation must be performed before the idct_put/add.
138	* Note, normally this can be merged with the zigzag/alternate scan<br>
139	* An example to avoid confusion:
140	* - (->decode coeffs -> zigzag reorder -> dequant -> reference IDCT -> ...)
141	* - (x -> reference DCT -> reference IDCT -> x)
142	* - (x -> reference DCT -> simple_mmx_perm = idct_permutation
143	* -> simple_idct_mmx -> x)
144	* - (-> decode coeffs -> zigzag reorder -> simple_mmx_perm -> dequant
145	* -> simple_idct_mmx -> ...)
146	*/
147	uint8_t idct_permutation[64];
148	int idct_permutation_type;
149	#define FF_NO_IDCT_PERM 1
150	#define FF_LIBMPEG2_IDCT_PERM 2
151	#define FF_SIMPLE_IDCT_PERM 3
152	#define FF_TRANSPOSE_IDCT_PERM 4
153	#define FF_PARTTRANS_IDCT_PERM 5
154	#define FF_SSE2_IDCT_PERM 6
155
156	int (*try_8x8basis)(int16_t rem[64], int16_t weight[64],	90	int (*try_8x8basis)(int16_t rem[64], int16_t weight[64],
157	int16_t basis[64], int scale);	91	int16_t basis[64], int scale);
158	void (*add_8x8basis)(int16_t rem[64], int16_t basis[64], int scale);	92	void (*add_8x8basis)(int16_t rem[64], int16_t basis[64], int scale);

libavcodec/dvdec.c+5−4

 #include "libavutil/imgutils.h"
 #include "libavutil/pixdesc.h"
 #include "avcodec.h"
+#include "idctdsp.h"
 #include "internal.h"
 #include "get_bits.h"
 #include "put_bits.h"
 static av_cold int dvvideo_decode_init(AVCodecContext *avctx)
 {
     DVVideoContext *s = avctx->priv_data;
-    DSPContext dsp;
+    IDCTDSPContext idsp;
     int i;
-    ff_dsputil_init(&dsp, avctx);
+    ff_idctdsp_init(&idsp, avctx);
     for (i = 0; i < 64; i++)
-       s->dv_zigzag[0][i] = dsp.idct_permutation[ff_zigzag_direct[i]];
+       s->dv_zigzag[0][i] = idsp.idct_permutation[ff_zigzag_direct[i]];
     memcpy(s->dv_zigzag[1], ff_dv_zigzag248_direct, sizeof(s->dv_zigzag[1]));
-    s->idct_put[0] = dsp.idct_put;
+    s->idct_put[0] = idsp.idct_put;
     s->idct_put[1] = ff_simple_idct248_put;
     return ff_dvvideo_init(avctx);

libavcodec/dxva2_mpeg2.c+1−1

@@ -110,7 +110,7 @@ static void fill_quantization_matrices(AVCodecContext *avctx, · 109 unmodified lines
110	for (i = 0; i < 4; i++)	110	for (i = 0; i < 4; i++)
111	qm->bNewQmatrix[i] = 1;	111	qm->bNewQmatrix[i] = 1;
112	for (i = 0; i < 64; i++) {	112	for (i = 0; i < 64; i++) {
113	int n = s->dsp.idct_permutation[ff_zigzag_direct[i]];	113	int n = s->idsp.idct_permutation[ff_zigzag_direct[i]];
114	qm->Qmatrix[0][i] = s->intra_matrix[n];;	114	qm->Qmatrix[0][i] = s->intra_matrix[n];;
115	qm->Qmatrix[1][i] = s->inter_matrix[n];;	115	qm->Qmatrix[1][i] = s->inter_matrix[n];;
116	qm->Qmatrix[2][i] = s->chroma_intra_matrix[n];;	116	qm->Qmatrix[2][i] = s->chroma_intra_matrix[n];;

libavcodec/eamad.c+5−4

 #include "get_bits.h"
 #include "aandcttab.h"
 #include "eaidct.h"
+#include "idctdsp.h"
 #include "internal.h"
 #include "mpeg12.h"
 #include "mpeg12data.h"
     AVCodecContext *avctx;
     BlockDSPContext bdsp;
     BswapDSPContext bbdsp;
-    DSPContext dsp;
+    IDCTDSPContext idsp;
     AVFrame *last_frame;
     GetBitContext gb;
     void *bitstream_buf;
     avctx->pix_fmt = AV_PIX_FMT_YUV420P;
     ff_blockdsp_init(&s->bdsp, avctx);
     ff_bswapdsp_init(&s->bbdsp);
-    ff_dsputil_init(&s->dsp, avctx);
+    ff_idctdsp_init(&s->idsp, avctx);
-    ff_init_scantable_permutation(s->dsp.idct_permutation, FF_NO_IDCT_PERM);
+    ff_init_scantable_permutation(s->idsp.idct_permutation, FF_NO_IDCT_PERM);
-    ff_init_scantable(s->dsp.idct_permutation, &s->scantable, ff_zigzag_direct);
+    ff_init_scantable(s->idsp.idct_permutation, &s->scantable, ff_zigzag_direct);
     ff_mpeg12_init_vlcs();
     s->last_frame = av_frame_alloc();

libavcodec/eatgq.c+1−1

@@ -32,7 +32,7 @@ · 31 unmodified lines
32	#define BITSTREAM_READER_LE	32	#define BITSTREAM_READER_LE
33	#include "get_bits.h"	33	#include "get_bits.h"
34	#include "bytestream.h"	34	#include "bytestream.h"
35	#include "dsputil.h"	35	#include "idctdsp.h"
36	#include "aandcttab.h"	36	#include "aandcttab.h"
37	#include "eaidct.h"	37	#include "eaidct.h"
38	#include "internal.h"	38	#include "internal.h"

libavcodec/eatqi.c+4−3

 #include "get_bits.h"
 #include "aandcttab.h"
 #include "eaidct.h"
+#include "idctdsp.h"
 #include "internal.h"
 #include "mpeg12.h"
 #include "mpegvideo.h"
     s->avctx = avctx;
     ff_blockdsp_init(&s->bdsp, avctx);
     ff_bswapdsp_init(&t->bsdsp);
-    ff_dsputil_init(&s->dsp, avctx);
+    ff_idctdsp_init(&s->idsp, avctx);
-    ff_init_scantable_permutation(s->dsp.idct_permutation, FF_NO_IDCT_PERM);
+    ff_init_scantable_permutation(s->idsp.idct_permutation, FF_NO_IDCT_PERM);
-    ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable, ff_zigzag_direct);
+    ff_init_scantable(s->idsp.idct_permutation, &s->intra_scantable, ff_zigzag_direct);
     s->qscale = 1;
     avctx->time_base = (AVRational){1, 15};
     avctx->pix_fmt = AV_PIX_FMT_YUV420P;

libavcodec/g2meet.c+6−6

@@ -31,7 +31,7 @@ · 30 unmodified lines
31	#include "avcodec.h"	31	#include "avcodec.h"
32	#include "blockdsp.h"	32	#include "blockdsp.h"
33	#include "bytestream.h"	33	#include "bytestream.h"
34	#include "dsputil.h"	34	#include "idctdsp.h"
35	#include "get_bits.h"	35	#include "get_bits.h"
36	#include "internal.h"	36	#include "internal.h"
37	#include "mjpeg.h"	37	#include "mjpeg.h"
@@ -74,7 +74,7 @@ static const uint8_t chroma_quant[64] = { · 36 unmodified lines
74		74
75	typedef struct JPGContext {	75	typedef struct JPGContext {
76	BlockDSPContext bdsp;	76	BlockDSPContext bdsp;
77	DSPContext dsp;	77	IDCTDSPContext idsp;
78	ScanTable scantable;	78	ScanTable scantable;
79		79
80	VLC dc_vlc[2], ac_vlc[2];	80	VLC dc_vlc[2], ac_vlc[2];
@@ -153,8 +153,8 @@ static av_cold int jpg_init(AVCodecContext avctx, JPGContext c) · 72 unmodified lines
153	return ret;	153	return ret;
154		154
155	ff_blockdsp_init(&c->bdsp, avctx);	155	ff_blockdsp_init(&c->bdsp, avctx);
156	ff_dsputil_init(&c->dsp, avctx);	156	ff_idctdsp_init(&c->idsp, avctx);
157	ff_init_scantable(c->dsp.idct_permutation, &c->scantable,	157	ff_init_scantable(c->idsp.idct_permutation, &c->scantable,
158	ff_zigzag_direct);	158	ff_zigzag_direct);
159		159
160	return 0;	160	return 0;
@@ -279,13 +279,13 @@ static int jpg_decode_data(JPGContext *c, int width, int height, · 118 unmodified lines
279	if ((ret = jpg_decode_block(c, &gb, 0,	279	if ((ret = jpg_decode_block(c, &gb, 0,
280	c->block[i + j * 2])) != 0)	280	c->block[i + j * 2])) != 0)
281	return ret;	281	return ret;
282	c->dsp.idct(c->block[i + j * 2]);	282	c->idsp.idct(c->block[i + j * 2]);
283	}	283	}
284	}	284	}
285	for (i = 1; i < 3; i++) {	285	for (i = 1; i < 3; i++) {
286	if ((ret = jpg_decode_block(c, &gb, i, c->block[i + 3])) != 0)	286	if ((ret = jpg_decode_block(c, &gb, i, c->block[i + 3])) != 0)
287	return ret;	287	return ret;
288	c->dsp.idct(c->block[i + 3]);	288	c->idsp.idct(c->block[i + 3]);
289	}	289	}
290		290
291	for (j = 0; j < 16; j++) {	291	for (j = 0; j < 16; j++) {

libavcodec/h263.c+4−4

@@ -267,7 +267,7 @@ void ff_h263_pred_acdc(MpegEncContext * s, int16_t *block, int n) · 266 unmodified lines
267	if (a != 1024) {	267	if (a != 1024) {
268	ac_val -= 16;	268	ac_val -= 16;
269	for(i=1;i<8;i++) {	269	for(i=1;i<8;i++) {
270	block[s->dsp.idct_permutation[i<<3]] += ac_val[i];	270	block[s->idsp.idct_permutation[i << 3]] += ac_val[i];
271	}	271	}
272	pred_dc = a;	272	pred_dc = a;
273	}	273	}
@@ -276,7 +276,7 @@ void ff_h263_pred_acdc(MpegEncContext * s, int16_t *block, int n) · 2 unmodified lines
276	if (c != 1024) {	276	if (c != 1024) {
277	ac_val -= 16 * wrap;	277	ac_val -= 16 * wrap;
278	for(i=1;i<8;i++) {	278	for(i=1;i<8;i++) {
279	block[s->dsp.idct_permutation[i ]] += ac_val[i + 8];	279	block[s->idsp.idct_permutation[i]] += ac_val[i + 8];
280	}	280	}
281	pred_dc = c;	281	pred_dc = c;
282	}	282	}
@@ -304,10 +304,10 @@ void ff_h263_pred_acdc(MpegEncContext * s, int16_t *block, int n) · 21 unmodified lines
304		304
305	/* left copy */	305	/* left copy */
306	for(i=1;i<8;i++)	306	for(i=1;i<8;i++)
307	ac_val1[i ] = block[s->dsp.idct_permutation[i<<3]];	307	ac_val1[i] = block[s->idsp.idct_permutation[i << 3]];
308	/* top copy */	308	/* top copy */
309	for(i=1;i<8;i++)	309	for(i=1;i<8;i++)
310	ac_val1[8 + i] = block[s->dsp.idct_permutation[i ]];	310	ac_val1[8 + i] = block[s->idsp.idct_permutation[i]];
311	}	311	}
312		312
313	int16_t ff_h263_pred_motion(MpegEncContext s, int block, int dir,	313	int16_t ff_h263_pred_motion(MpegEncContext s, int block, int dir,

libavcodec/idctdsp.c+197−0

@@ -0,0 +1,197 @@
	1	/*
	2	* This file is part of Libav.
	3	*
	4	* Libav 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	* Libav 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 Libav; 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
	28	av_cold void ff_init_scantable(uint8_t permutation, ScanTable st,
	29	const uint8_t *src_scantable)
	30	{
	31	int i, end;
	32
	33	st->scantable = src_scantable;
	34
	35	for (i = 0; i < 64; i++) {
	36	int j = src_scantable[i];
	37	st->permutated[i] = permutation[j];
	38	}
	39
	40	end = -1;
	41	for (i = 0; i < 64; i++) {
	42	int j = st->permutated[i];
	43	if (j > end)
	44	end = j;
	45	st->raster_end[i] = end;
	46	}
	47	}
	48
	49	av_cold void ff_init_scantable_permutation(uint8_t *idct_permutation,
	50	int idct_permutation_type)
	51	{
	52	int i;
	53
	54	if (ARCH_X86)
	55	if (ff_init_scantable_permutation_x86(idct_permutation,
	56	idct_permutation_type))
	57	return;
	58
	59	switch (idct_permutation_type) {
	60	case FF_NO_IDCT_PERM:
	61	for (i = 0; i < 64; i++)
	62	idct_permutation[i] = i;
	63	break;
	64	case FF_LIBMPEG2_IDCT_PERM:
	65	for (i = 0; i < 64; i++)
	66	idct_permutation[i] = (i & 0x38) \| ((i & 6) >> 1) \| ((i & 1) << 2);
	67	break;
	68	case FF_TRANSPOSE_IDCT_PERM:
	69	for (i = 0; i < 64; i++)
	70	idct_permutation[i] = ((i & 7) << 3) \| (i >> 3);
	71	break;
	72	case FF_PARTTRANS_IDCT_PERM:
	73	for (i = 0; i < 64; i++)
	74	idct_permutation[i] = (i & 0x24) \| ((i & 3) << 3) \| ((i >> 3) & 3);
	75	break;
	76	default:
	77	av_log(NULL, AV_LOG_ERROR,
	78	"Internal error, IDCT permutation not set\n");
	79	}
	80	}
	81
	82	static void put_pixels_clamped_c(const int16_t block, uint8_t restrict pixels,
	83	int line_size)
	84	{
	85	int i;
	86
	87	/* read the pixels */
	88	for (i = 0; i < 8; i++) {
	89	pixels[0] = av_clip_uint8(block[0]);
	90	pixels[1] = av_clip_uint8(block[1]);
	91	pixels[2] = av_clip_uint8(block[2]);
	92	pixels[3] = av_clip_uint8(block[3]);
	93	pixels[4] = av_clip_uint8(block[4]);
	94	pixels[5] = av_clip_uint8(block[5]);
	95	pixels[6] = av_clip_uint8(block[6]);
	96	pixels[7] = av_clip_uint8(block[7]);
	97
	98	pixels += line_size;
	99	block += 8;
	100	}
	101	}
	102
	103	static void put_signed_pixels_clamped_c(const int16_t *block,
	104	uint8_t *restrict pixels,
	105	int line_size)
	106	{
	107	int i, j;
	108
	109	for (i = 0; i < 8; i++) {
	110	for (j = 0; j < 8; j++) {
	111	if (*block < -128)
	112	*pixels = 0;
	113	else if (*block > 127)
	114	*pixels = 255;
	115	else
	116	pixels = (uint8_t) (block + 128);
	117	block++;
	118	pixels++;
	119	}
	120	pixels += (line_size - 8);
	121	}
	122	}
	123
	124	static void add_pixels_clamped_c(const int16_t block, uint8_t restrict pixels,
	125	int line_size)
	126	{
	127	int i;
	128
	129	/* read the pixels */
	130	for (i = 0; i < 8; i++) {
	131	pixels[0] = av_clip_uint8(pixels[0] + block[0]);
	132	pixels[1] = av_clip_uint8(pixels[1] + block[1]);
	133	pixels[2] = av_clip_uint8(pixels[2] + block[2]);
	134	pixels[3] = av_clip_uint8(pixels[3] + block[3]);
	135	pixels[4] = av_clip_uint8(pixels[4] + block[4]);
	136	pixels[5] = av_clip_uint8(pixels[5] + block[5]);
	137	pixels[6] = av_clip_uint8(pixels[6] + block[6]);
	138	pixels[7] = av_clip_uint8(pixels[7] + block[7]);
	139	pixels += line_size;
	140	block += 8;
	141	}
	142	}
	143
	144	static void jref_idct_put(uint8_t dest, int line_size, int16_t block)
	145	{
	146	ff_j_rev_dct(block);
	147	put_pixels_clamped_c(block, dest, line_size);
	148	}
	149
	150	static void jref_idct_add(uint8_t dest, int line_size, int16_t block)
	151	{
	152	ff_j_rev_dct(block);
	153	add_pixels_clamped_c(block, dest, line_size);
	154	}
	155
	156	av_cold void ff_idctdsp_init(IDCTDSPContext c, AVCodecContext avctx)
	157	{
	158	const unsigned high_bit_depth = avctx->bits_per_raw_sample > 8;
	159
	160	if (avctx->bits_per_raw_sample == 10) {
	161	c->idct_put = ff_simple_idct_put_10;
	162	c->idct_add = ff_simple_idct_add_10;
	163	c->idct = ff_simple_idct_10;
	164	c->idct_permutation_type = FF_NO_IDCT_PERM;
	165	} else {
	166	if (avctx->idct_algo == FF_IDCT_INT) {
	167	c->idct_put = jref_idct_put;
	168	c->idct_add = jref_idct_add;
	169	c->idct = ff_j_rev_dct;
	170	c->idct_permutation_type = FF_LIBMPEG2_IDCT_PERM;
	171	} else if (avctx->idct_algo == FF_IDCT_FAAN) {
	172	c->idct_put = ff_faanidct_put;
	173	c->idct_add = ff_faanidct_add;
	174	c->idct = ff_faanidct;
	175	c->idct_permutation_type = FF_NO_IDCT_PERM;
	176	} else { // accurate/default
	177	c->idct_put = ff_simple_idct_put_8;
	178	c->idct_add = ff_simple_idct_add_8;
	179	c->idct = ff_simple_idct_8;
	180	c->idct_permutation_type = FF_NO_IDCT_PERM;
	181	}
	182	}
	183
	184	c->put_pixels_clamped = put_pixels_clamped_c;
	185	c->put_signed_pixels_clamped = put_signed_pixels_clamped_c;
	186	c->add_pixels_clamped = add_pixels_clamped_c;
	187
	188	if (ARCH_ARM)
	189	ff_idctdsp_init_arm(c, avctx, high_bit_depth);
	190	if (ARCH_PPC)
	191	ff_idctdsp_init_ppc(c, avctx, high_bit_depth);
	192	if (ARCH_X86)
	193	ff_idctdsp_init_x86(c, avctx, high_bit_depth);
	194
	195	ff_init_scantable_permutation(c->idct_permutation,
	196	c->idct_permutation_type);
	197	}

libavcodec/idctdsp.h+104−0

@@ -0,0 +1,104 @@
	1	/*
	2	* This file is part of Libav.
	3	*
	4	* Libav 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	* Libav 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 Libav; if not, write to the Free Software
	16	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
	17	*/
	18
	19	#ifndef AVCODEC_IDCTDSP_H
	20	#define AVCODEC_IDCTDSP_H
	21
	22	#include <stdint.h>
	23
	24	#include "avcodec.h"
	25
	26	/**
	27	* Scantable.
	28	*/
	29	typedef struct ScanTable {
	30	const uint8_t *scantable;
	31	uint8_t permutated[64];
	32	uint8_t raster_end[64];
	33	} ScanTable;
	34
	35	void ff_init_scantable(uint8_t permutation, ScanTable st,
	36	const uint8_t *src_scantable);
	37	void ff_init_scantable_permutation(uint8_t *idct_permutation,
	38	int idct_permutation_type);
	39	int ff_init_scantable_permutation_x86(uint8_t *idct_permutation,
	40	int idct_permutation_type);
	41
	42	typedef struct IDCTDSPContext {
	43	/* pixel ops : interface with DCT */
	44	void (put_pixels_clamped)(const int16_t block /* align 16 */,
	45	uint8_t pixels / align 8 */,
	46	int line_size);
	47	void (put_signed_pixels_clamped)(const int16_t block /* align 16 */,
	48	uint8_t pixels / align 8 */,
	49	int line_size);
	50	void (add_pixels_clamped)(const int16_t block /* align 16 */,
	51	uint8_t pixels / align 8 */,
	52	int line_size);
	53
	54	void (idct)(int16_t block /* align 16 */);
	55
	56	/**
	57	* block -> idct -> clip to unsigned 8 bit -> dest.
	58	* (-1392, 0, 0, ...) -> idct -> (-174, -174, ...) -> put -> (0, 0, ...)
	59	* @param line_size size in bytes of a horizontal line of dest
	60	*/
	61	void (idct_put)(uint8_t dest /* align 8 */,
	62	int line_size, int16_t block / align 16 */);
	63
	64	/**
	65	* block -> idct -> add dest -> clip to unsigned 8 bit -> dest.
	66	* @param line_size size in bytes of a horizontal line of dest
	67	*/
	68	void (idct_add)(uint8_t dest /* align 8 */,
	69	int line_size, int16_t block / align 16 */);
	70
	71	/**
	72	* IDCT input permutation.
	73	* Several optimized IDCTs need a permutated input (relative to the
	74	* normal order of the reference IDCT).
	75	* This permutation must be performed before the idct_put/add.
	76	* Note, normally this can be merged with the zigzag/alternate scan<br>
	77	* An example to avoid confusion:
	78	* - (->decode coeffs -> zigzag reorder -> dequant -> reference IDCT -> ...)
	79	* - (x -> reference DCT -> reference IDCT -> x)
	80	* - (x -> reference DCT -> simple_mmx_perm = idct_permutation
	81	* -> simple_idct_mmx -> x)
	82	* - (-> decode coeffs -> zigzag reorder -> simple_mmx_perm -> dequant
	83	* -> simple_idct_mmx -> ...)
	84	*/
	85	uint8_t idct_permutation[64];
	86	int idct_permutation_type;
	87	#define FF_NO_IDCT_PERM 1
	88	#define FF_LIBMPEG2_IDCT_PERM 2
	89	#define FF_SIMPLE_IDCT_PERM 3
	90	#define FF_TRANSPOSE_IDCT_PERM 4
	91	#define FF_PARTTRANS_IDCT_PERM 5
	92	#define FF_SSE2_IDCT_PERM 6
	93	} IDCTDSPContext;
	94
	95	void ff_idctdsp_init(IDCTDSPContext c, AVCodecContext avctx);
	96
	97	void ff_idctdsp_init_arm(IDCTDSPContext c, AVCodecContext avctx,
	98	unsigned high_bit_depth);
	99	void ff_idctdsp_init_ppc(IDCTDSPContext c, AVCodecContext avctx,
	100	unsigned high_bit_depth);
	101	void ff_idctdsp_init_x86(IDCTDSPContext c, AVCodecContext avctx,
	102	unsigned high_bit_depth);
	103
	104	#endif /* AVCODEC_IDCTDSP_H */

libavcodec/intrax8.c+8−7

 #include "avcodec.h"
 #include "error_resilience.h"
 #include "get_bits.h"
+#include "idctdsp.h"
 #include "mpegvideo.h"
 #include "msmpeg4data.h"
 #include "intrax8huf.h"
 static void x8_ac_compensation(IntraX8Context * const w, int const direction, int const dc_level){
     MpegEncContext * const s= w->s;
     int t;
-#define B(x,y)  s->block[0][s->dsp.idct_permutation[(x)+(y)*8]]
+#define B(x, y) s->block[0][s->idsp.idct_permutation[(x) + (y) * 8]]
 #define T(x)  ((x) * dc_level + 0x8000) >> 16;
     switch(direction){
     case 0:
                                             s->current_picture.f->linesize[!!chroma] );
     }
     if(!zeros_only)
-        s->dsp.idct_add ( s->dest[chroma],
+        s->idsp.idct_add(s->dest[chroma],
-                          s->current_picture.f->linesize[!!chroma],
+                         s->current_picture.f->linesize[!!chroma],
-                          s->block[0] );
+                         s->block[0]);
 block_placed:
     assert(s->mb_width>0);
     w->prediction_table=av_mallocz(s->mb_width*2*2);//two rows, 2 blocks per cannon mb
-    ff_init_scantable(s->dsp.idct_permutation, &w->scantable[0], ff_wmv1_scantable[0]);
+    ff_init_scantable(s->idsp.idct_permutation, &w->scantable[0], ff_wmv1_scantable[0]);
-    ff_init_scantable(s->dsp.idct_permutation, &w->scantable[1], ff_wmv1_scantable[2]);
+    ff_init_scantable(s->idsp.idct_permutation, &w->scantable[1], ff_wmv1_scantable[2]);
-    ff_init_scantable(s->dsp.idct_permutation, &w->scantable[2], ff_wmv1_scantable[3]);
+    ff_init_scantable(s->idsp.idct_permutation, &w->scantable[2], ff_wmv1_scantable[3]);
     ff_intrax8dsp_init(&w->dsp);
 }

libavcodec/ljpegenc.c+5−4

 #include "libavutil/pixdesc.h"
 #include "avcodec.h"
-#include "dsputil.h"
+#include "idctdsp.h"
 #include "internal.h"
 #include "mjpegenc_common.h"
 #include "mpegvideo.h"
 #include "mjpegenc.h"
 typedef struct LJpegEncContext {
-    DSPContext dsp;
+    IDCTDSPContext idsp;
     ScanTable scantable;
     uint16_t matrix[64];
     s->scratch = av_malloc_array(avctx->width + 1, sizeof(*s->scratch));
-    ff_dsputil_init(&s->dsp, avctx);
+    ff_idctdsp_init(&s->idsp, avctx);
-    ff_init_scantable(s->dsp.idct_permutation, &s->scantable, ff_zigzag_direct);
+    ff_init_scantable(s->idsp.idct_permutation, &s->scantable,
+                      ff_zigzag_direct);
     av_pix_fmt_get_chroma_sub_sample(avctx->pix_fmt, &chroma_h_shift,
                                      &chroma_v_shift);

libavcodec/mdec.c+11−9

 #include "avcodec.h"
 #include "blockdsp.h"
+#include "idctdsp.h"
 #include "mpegvideo.h"
 #include "mpeg12.h"
 #include "thread.h"
 typedef struct MDECContext {
     AVCodecContext *avctx;
     BlockDSPContext bdsp;
-    DSPContext dsp;
+    IDCTDSPContext idsp;
     ThreadFrame frame;
     GetBitContext gb;
     ScanTable scantable;
     uint8_t *dest_cb = frame->data[1] + (mb_y * 8 * frame->linesize[1]) + mb_x * 8;
     uint8_t *dest_cr = frame->data[2] + (mb_y * 8 * frame->linesize[2]) + mb_x * 8;
-    a->dsp.idct_put(dest_y,                    linesize, block[0]);
+    a->idsp.idct_put(dest_y,                    linesize, block[0]);
-    a->dsp.idct_put(dest_y                + 8, linesize, block[1]);
+    a->idsp.idct_put(dest_y + 8,                linesize, block[1]);
-    a->dsp.idct_put(dest_y + 8 * linesize,     linesize, block[2]);
+    a->idsp.idct_put(dest_y + 8 * linesize,     linesize, block[2]);
-    a->dsp.idct_put(dest_y + 8 * linesize + 8, linesize, block[3]);
+    a->idsp.idct_put(dest_y + 8 * linesize + 8, linesize, block[3]);
     if (!(a->avctx->flags & CODEC_FLAG_GRAY)) {
-        a->dsp.idct_put(dest_cb, frame->linesize[1], block[4]);
+        a->idsp.idct_put(dest_cb, frame->linesize[1], block[4]);
-        a->dsp.idct_put(dest_cr, frame->linesize[2], block[5]);
+        a->idsp.idct_put(dest_cr, frame->linesize[2], block[5]);
     }
 }
     a->avctx           = avctx;
     ff_blockdsp_init(&a->bdsp, avctx);
-    ff_dsputil_init(&a->dsp, avctx);
+    ff_idctdsp_init(&a->idsp, avctx);
     ff_mpeg12_init_vlcs();
-    ff_init_scantable(a->dsp.idct_permutation, &a->scantable, ff_zigzag_direct);
+    ff_init_scantable(a->idsp.idct_permutation, &a->scantable,
+                      ff_zigzag_direct);
     if (avctx->idct_algo == FF_IDCT_AUTO)
         avctx->idct_algo = FF_IDCT_SIMPLE;

libavcodec/mimic.c+5−5

 #include "get_bits.h"
 #include "bytestream.h"
 #include "bswapdsp.h"
-#include "dsputil.h"
 #include "hpeldsp.h"
+#include "idctdsp.h"
 #include "thread.h"
 #define MIMIC_HEADER_SIZE   20
     ScanTable       scantable;
     BlockDSPContext bdsp;
     BswapDSPContext bbdsp;
-    DSPContext      dsp;
     HpelDSPContext  hdsp;
+    IDCTDSPContext  idsp;
     VLC             vlc;
     /* Kept in the context so multithreading can have a constant to read from */
     }
     ff_blockdsp_init(&ctx->bdsp, avctx);
     ff_bswapdsp_init(&ctx->bbdsp);
-    ff_dsputil_init(&ctx->dsp, avctx);
     ff_hpeldsp_init(&ctx->hdsp, avctx->flags);
-    ff_init_scantable(ctx->dsp.idct_permutation, &ctx->scantable, col_zag);
+    ff_idctdsp_init(&ctx->idsp, avctx);
+    ff_init_scantable(ctx->idsp.idct_permutation, &ctx->scantable, col_zag);
     for (i = 0; i < FF_ARRAY_ELEMS(ctx->frames); i++) {
         ctx->frames[i].f = av_frame_alloc();
                                    "block.\n");
                             return ret;
                         }
-                        ctx->dsp.idct_put(dst, stride, ctx->dct_block);
+                        ctx->idsp.idct_put(dst, stride, ctx->dct_block);
                     } else {
                         unsigned int backref = get_bits(&ctx->gb, 4);
                         int index            = (ctx->cur_index + backref) & 15;

libavcodec/mjpegdec.c+6−4

 #include "libavutil/opt.h"
 #include "avcodec.h"
 #include "blockdsp.h"
+#include "idctdsp.h"
 #include "internal.h"
 #include "mjpeg.h"
 #include "mjpegdec.h"
     s->avctx = avctx;
     ff_blockdsp_init(&s->bdsp, avctx);
     ff_hpeldsp_init(&s->hdsp, avctx->flags);
-    ff_dsputil_init(&s->dsp, avctx);
+    ff_idctdsp_init(&s->idsp, avctx);
-    ff_init_scantable(s->dsp.idct_permutation, &s->scantable, ff_zigzag_direct);
+    ff_init_scantable(s->idsp.idct_permutation, &s->scantable,
+                      ff_zigzag_direct);
     s->buffer_size   = 0;
     s->buffer        = NULL;
     s->start_code    = -1;
                                        "error y=%d x=%d\n", mb_y, mb_x);
                                 return AVERROR_INVALIDDATA;
                             }
-                            s->dsp.idct_put(ptr, linesize[c], s->block);
+                            s->idsp.idct_put(ptr, linesize[c], s->block);
                         }
                     } else {
                         int block_idx  = s->block_stride[c] * (v * mb_y + y) +
                                                  reference_data + block_offset,
                                                  linesize, 8);
                 } else {
-                    s->dsp.idct_put(ptr, linesize, *block);
+                    s->idsp.idct_put(ptr, linesize, *block);
                     ptr += 8;
                 }
             }

libavcodec/mjpegdec.h+2−2

 #include "avcodec.h"
 #include "blockdsp.h"
 #include "get_bits.h"
-#include "dsputil.h"
 #include "hpeldsp.h"
+#include "idctdsp.h"
 #define MAX_COMPONENTS 4
     uint64_t coefs_finished[MAX_COMPONENTS]; ///< bitmask of which coefs have been completely decoded (progressive mode)
     ScanTable scantable;
     BlockDSPContext bdsp;
-    DSPContext dsp;
     HpelDSPContext hdsp;
+    IDCTDSPContext idsp;
     int restart_interval;
     int restart_count;

libavcodec/mjpegenc_common.c+1−1

@@ -26,7 +26,7 @@ · 25 unmodified lines
26	#include "libavutil/pixfmt.h"	26	#include "libavutil/pixfmt.h"
27		27
28	#include "avcodec.h"	28	#include "avcodec.h"
29	#include "dsputil.h"	29	#include "idctdsp.h"
30	#include "put_bits.h"	30	#include "put_bits.h"
31	#include "mjpegenc_common.h"	31	#include "mjpegenc_common.h"
32	#include "mjpeg.h"	32	#include "mjpeg.h"

libavcodec/mjpegenc_common.h+1−1

@@ -24,7 +24,7 @@ · 23 unmodified lines
24	#include <stdint.h>	24	#include <stdint.h>
25		25
26	#include "avcodec.h"	26	#include "avcodec.h"
27	#include "dsputil.h"	27	#include "idctdsp.h"
28	#include "put_bits.h"	28	#include "put_bits.h"
29		29
30	void ff_mjpeg_encode_picture_header(AVCodecContext avctx, PutBitContext pb,	30	void ff_mjpeg_encode_picture_header(AVCodecContext avctx, PutBitContext pb,

libavcodec/mpeg12dec.c+15−15

 #include "avcodec.h"
 #include "bytestream.h"
-#include "dsputil.h"
 #include "error_resilience.h"
+#include "idctdsp.h"
 #include "internal.h"
 #include "mpeg_er.h"
 #include "mpeg12.h"
     /* we need some permutation to store matrices,
      * until MPV_common_init() sets the real permutation. */
     for (i = 0; i < 64; i++)
-        s2->dsp.idct_permutation[i] = i;
+        s2->idsp.idct_permutation[i] = i;
     ff_MPV_decode_defaults(s2);
         /* Quantization matrices may need reordering
          * if DCT permutation is changed. */
-        memcpy(old_permutation, s->dsp.idct_permutation, 64 * sizeof(uint8_t));
+        memcpy(old_permutation, s->idsp.idct_permutation, 64 * sizeof(uint8_t));
         if (ff_MPV_common_init(s) < 0)
             return -2;
-        quant_matrix_rebuild(s->intra_matrix,        old_permutation, s->dsp.idct_permutation);
+        quant_matrix_rebuild(s->intra_matrix,        old_permutation, s->idsp.idct_permutation);
-        quant_matrix_rebuild(s->inter_matrix,        old_permutation, s->dsp.idct_permutation);
+        quant_matrix_rebuild(s->inter_matrix,        old_permutation, s->idsp.idct_permutation);
-        quant_matrix_rebuild(s->chroma_intra_matrix, old_permutation, s->dsp.idct_permutation);
+        quant_matrix_rebuild(s->chroma_intra_matrix, old_permutation, s->idsp.idct_permutation);
-        quant_matrix_rebuild(s->chroma_inter_matrix, old_permutation, s->dsp.idct_permutation);
+        quant_matrix_rebuild(s->chroma_inter_matrix, old_permutation, s->idsp.idct_permutation);
         s1->mpeg_enc_ctx_allocated = 1;
     }
     int i;
     for (i = 0; i < 64; i++) {
-        int j = s->dsp.idct_permutation[ff_zigzag_direct[i]];
+        int j = s->idsp.idct_permutation[ff_zigzag_direct[i]];
         int v = get_bits(&s->gb, 8);
         if (v == 0) {
             av_log(s->avctx, AV_LOG_ERROR, "matrix damaged\n");
     }
     if (s->alternate_scan) {
-        ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable, ff_alternate_vertical_scan);
+        ff_init_scantable(s->idsp.idct_permutation, &s->inter_scantable, ff_alternate_vertical_scan);
-        ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable, ff_alternate_vertical_scan);
+        ff_init_scantable(s->idsp.idct_permutation, &s->intra_scantable, ff_alternate_vertical_scan);
     } else {
-        ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable, ff_zigzag_direct);
+        ff_init_scantable(s->idsp.idct_permutation, &s->inter_scantable, ff_zigzag_direct);
-        ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable, ff_zigzag_direct);
+        ff_init_scantable(s->idsp.idct_permutation, &s->intra_scantable, ff_zigzag_direct);
     }
     /* composite display not parsed */
         load_matrix(s, s->chroma_intra_matrix, s->intra_matrix, 1);
     } else {
         for (i = 0; i < 64; i++) {
-            j = s->dsp.idct_permutation[i];
+            j = s->idsp.idct_permutation[i];
             v = ff_mpeg1_default_intra_matrix[i];
             s->intra_matrix[j]        = v;
             s->chroma_intra_matrix[j] = v;
         load_matrix(s, s->chroma_inter_matrix, s->inter_matrix, 0);
     } else {
         for (i = 0; i < 64; i++) {
-            int j = s->dsp.idct_permutation[i];
+            int j = s->idsp.idct_permutation[i];
             v = ff_mpeg1_default_non_intra_matrix[i];
             s->inter_matrix[j]        = v;
             s->chroma_inter_matrix[j] = v;
     s1->mpeg_enc_ctx_allocated = 1;
     for (i = 0; i < 64; i++) {
-        int j = s->dsp.idct_permutation[i];
+        int j = s->idsp.idct_permutation[i];
         v = ff_mpeg1_default_intra_matrix[i];
         s->intra_matrix[j]        = v;
         s->chroma_intra_matrix[j] = v;

libavcodec/mpeg4videodec.c+20−19

  */
 #include "error_resilience.h"
+#include "idctdsp.h"
 #include "internal.h"
 #include "mpegutils.h"
 #include "mpegvideo.h"
                 n == 1 || n == 3) {
                 /* same qscale */
                 for (i = 1; i < 8; i++)
-                    block[s->dsp.idct_permutation[i << 3]] += ac_val[i];
+                    block[s->idsp.idct_permutation[i << 3]] += ac_val[i];
             } else {
                 /* different qscale, we must rescale */
                 for (i = 1; i < 8; i++)
-                    block[s->dsp.idct_permutation[i << 3]] += ROUNDED_DIV(ac_val[i] * qscale_table[xy], s->qscale);
+                    block[s->idsp.idct_permutation[i << 3]] += ROUNDED_DIV(ac_val[i] * qscale_table[xy], s->qscale);
             }
         } else {
             const int xy = s->mb_x + s->mb_y * s->mb_stride - s->mb_stride;
                 n == 2 || n == 3) {
                 /* same qscale */
                 for (i = 1; i < 8; i++)
-                    block[s->dsp.idct_permutation[i]] += ac_val[i + 8];
+                    block[s->idsp.idct_permutation[i]] += ac_val[i + 8];
             } else {
                 /* different qscale, we must rescale */
                 for (i = 1; i < 8; i++)
-                    block[s->dsp.idct_permutation[i]] += ROUNDED_DIV(ac_val[i + 8] * qscale_table[xy], s->qscale);
+                    block[s->idsp.idct_permutation[i]] += ROUNDED_DIV(ac_val[i + 8] * qscale_table[xy], s->qscale);
             }
         }
     }
     /* left copy */
     for (i = 1; i < 8; i++)
-        ac_val1[i] = block[s->dsp.idct_permutation[i << 3]];
+        ac_val1[i] = block[s->idsp.idct_permutation[i << 3]];
     /* top copy */
     for (i = 1; i < 8; i++)
-        ac_val1[8 + i] = block[s->dsp.idct_permutation[i]];
+        ac_val1[8 + i] = block[s->idsp.idct_permutation[i]];
 }
 /**
             /* load default matrixes */
             for (i = 0; i < 64; i++) {
-                int j = s->dsp.idct_permutation[i];
+                int j = s->idsp.idct_permutation[i];
                 v = ff_mpeg4_default_intra_matrix[i];
                 s->intra_matrix[j]        = v;
                 s->chroma_intra_matrix[j] = v;
                         break;
                     last = v;
-                    j = s->dsp.idct_permutation[ff_zigzag_direct[i]];
+                    j = s->idsp.idct_permutation[ff_zigzag_direct[i]];
                     s->intra_matrix[j]        = last;
                     s->chroma_intra_matrix[j] = last;
                 }
                 /* replicate last value */
                 for (; i < 64; i++) {
-                    int j = s->dsp.idct_permutation[ff_zigzag_direct[i]];
+                    int j = s->idsp.idct_permutation[ff_zigzag_direct[i]];
                     s->intra_matrix[j]        = last;
                     s->chroma_intra_matrix[j] = last;
                 }
                         break;
                     last = v;
-                    j = s->dsp.idct_permutation[ff_zigzag_direct[i]];
+                    j = s->idsp.idct_permutation[ff_zigzag_direct[i]];
                     s->inter_matrix[j]        = v;
                     s->chroma_inter_matrix[j] = v;
                 }
                 /* replicate last value */
                 for (; i < 64; i++) {
-                    int j = s->dsp.idct_permutation[ff_zigzag_direct[i]];
+                    int j = s->idsp.idct_permutation[ff_zigzag_direct[i]];
                     s->inter_matrix[j]        = last;
                     s->chroma_inter_matrix[j] = last;
                 }
     }
     if (s->alternate_scan) {
-        ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable,   ff_alternate_vertical_scan);
+        ff_init_scantable(s->idsp.idct_permutation, &s->inter_scantable,   ff_alternate_vertical_scan);
-        ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable,   ff_alternate_vertical_scan);
+        ff_init_scantable(s->idsp.idct_permutation, &s->intra_scantable,   ff_alternate_vertical_scan);
-        ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_vertical_scan);
+        ff_init_scantable(s->idsp.idct_permutation, &s->intra_h_scantable, ff_alternate_vertical_scan);
-        ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
+        ff_init_scantable(s->idsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
     } else {
-        ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable,   ff_zigzag_direct);
+        ff_init_scantable(s->idsp.idct_permutation, &s->inter_scantable,   ff_zigzag_direct);
-        ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable,   ff_zigzag_direct);
+        ff_init_scantable(s->idsp.idct_permutation, &s->intra_scantable,   ff_zigzag_direct);
-        ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
+        ff_init_scantable(s->idsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
-        ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
+        ff_init_scantable(s->idsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
     }
     if (s->pict_type == AV_PICTURE_TYPE_S &&

libavcodec/mpeg4videoenc.c+14−14

@@ -110,11 +110,11 @@ static inline void restore_ac_coeffs(MpegEncContext *s, int16_t block[6][64], · 109 unmodified lines
110	if (dir[n]) {	110	if (dir[n]) {
111	/* top prediction */	111	/* top prediction */
112	for (i = 1; i < 8; i++)	112	for (i = 1; i < 8; i++)
113	block[n][s->dsp.idct_permutation[i]] = ac_val[i + 8];	113	block[n][s->idsp.idct_permutation[i]] = ac_val[i + 8];
114	} else {	114	} else {
115	/* left prediction */	115	/* left prediction */
116	for (i = 1; i < 8; i++)	116	for (i = 1; i < 8; i++)
117	block[n][s->dsp.idct_permutation[i << 3]] = ac_val[i];	117	block[n][s->idsp.idct_permutation[i << 3]] = ac_val[i];
118	}	118	}
119	}	119	}
120	}	120	}
@@ -152,17 +152,17 @@ static inline int decide_ac_pred(MpegEncContext *s, int16_t block[6][64], · 31 unmodified lines
152	if (s->mb_y == 0 \|\| s->qscale == qscale_table[xy] \|\| n == 2 \|\| n == 3) {	152	if (s->mb_y == 0 \|\| s->qscale == qscale_table[xy] \|\| n == 2 \|\| n == 3) {
153	/* same qscale */	153	/* same qscale */
154	for (i = 1; i < 8; i++) {	154	for (i = 1; i < 8; i++) {
155	const int level = block[n][s->dsp.idct_permutation[i]];	155	const int level = block[n][s->idsp.idct_permutation[i]];
156	block[n][s->dsp.idct_permutation[i]] = level - ac_val[i + 8];	156	block[n][s->idsp.idct_permutation[i]] = level - ac_val[i + 8];
157	ac_val1[i] = block[n][s->dsp.idct_permutation[i << 3]];	157	ac_val1[i] = block[n][s->idsp.idct_permutation[i << 3]];
158	ac_val1[i + 8] = level;	158	ac_val1[i + 8] = level;
159	}	159	}
160	} else {	160	} else {
161	/* different qscale, we must rescale */	161	/* different qscale, we must rescale */
162	for (i = 1; i < 8; i++) {	162	for (i = 1; i < 8; i++) {
163	const int level = block[n][s->dsp.idct_permutation[i]];	163	const int level = block[n][s->idsp.idct_permutation[i]];
164	block[n][s->dsp.idct_permutation[i]] = level - ROUNDED_DIV(ac_val[i + 8] * qscale_table[xy], s->qscale);	164	block[n][s->idsp.idct_permutation[i]] = level - ROUNDED_DIV(ac_val[i + 8] * qscale_table[xy], s->qscale);
165	ac_val1[i] = block[n][s->dsp.idct_permutation[i << 3]];	165	ac_val1[i] = block[n][s->idsp.idct_permutation[i << 3]];
166	ac_val1[i + 8] = level;	166	ac_val1[i + 8] = level;
167	}	167	}
168	}	168	}
@@ -174,18 +174,18 @@ static inline int decide_ac_pred(MpegEncContext *s, int16_t block[6][64], · 5 unmodified lines
174	if (s->mb_x == 0 \|\| s->qscale == qscale_table[xy] \|\| n == 1 \|\| n == 3) {	174	if (s->mb_x == 0 \|\| s->qscale == qscale_table[xy] \|\| n == 1 \|\| n == 3) {
175	/* same qscale */	175	/* same qscale */
176	for (i = 1; i < 8; i++) {	176	for (i = 1; i < 8; i++) {
177	const int level = block[n][s->dsp.idct_permutation[i << 3]];	177	const int level = block[n][s->idsp.idct_permutation[i << 3]];
178	block[n][s->dsp.idct_permutation[i << 3]] = level - ac_val[i];	178	block[n][s->idsp.idct_permutation[i << 3]] = level - ac_val[i];
179	ac_val1[i] = level;	179	ac_val1[i] = level;
180	ac_val1[i + 8] = block[n][s->dsp.idct_permutation[i]];	180	ac_val1[i + 8] = block[n][s->idsp.idct_permutation[i]];
181	}	181	}
182	} else {	182	} else {
183	/* different qscale, we must rescale */	183	/* different qscale, we must rescale */
184	for (i = 1; i < 8; i++) {	184	for (i = 1; i < 8; i++) {
185	const int level = block[n][s->dsp.idct_permutation[i << 3]];	185	const int level = block[n][s->idsp.idct_permutation[i << 3]];
186	block[n][s->dsp.idct_permutation[i << 3]] = level - ROUNDED_DIV(ac_val[i] * qscale_table[xy], s->qscale);	186	block[n][s->idsp.idct_permutation[i << 3]] = level - ROUNDED_DIV(ac_val[i] * qscale_table[xy], s->qscale);
187	ac_val1[i] = level;	187	ac_val1[i] = level;
188	ac_val1[i + 8] = block[n][s->dsp.idct_permutation[i]];	188	ac_val1[i + 8] = block[n][s->idsp.idct_permutation[i]];
189	}	189	}
190	}	190	}
191	st[n] = s->intra_v_scantable.permutated;	191	st[n] = s->intra_v_scantable.permutated;

libavcodec/mpegvideo.c+27−25

 #include "libavutil/timer.h"
 #include "avcodec.h"
 #include "blockdsp.h"
-#include "dsputil.h"
+#include "idctdsp.h"
 #include "internal.h"
 #include "mathops.h"
 #include "mpegutils.h"
     ff_blockdsp_init(&s->bdsp, s->avctx);
     ff_dsputil_init(&s->dsp, s->avctx);
     ff_hpeldsp_init(&s->hdsp, s->avctx->flags);
+    ff_idctdsp_init(&s->idsp, s->avctx);
     ff_mpegvideodsp_init(&s->mdsp);
     ff_videodsp_init(&s->vdsp, s->avctx->bits_per_raw_sample);
      * note: only wmv uses different ones
      */
     if (s->alternate_scan) {
-        ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable  , ff_alternate_vertical_scan);
+        ff_init_scantable(s->idsp.idct_permutation, &s->inter_scantable, ff_alternate_vertical_scan);
-        ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable  , ff_alternate_vertical_scan);
+        ff_init_scantable(s->idsp.idct_permutation, &s->intra_scantable, ff_alternate_vertical_scan);
     } else {
-        ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable  , ff_zigzag_direct);
+        ff_init_scantable(s->idsp.idct_permutation, &s->inter_scantable, ff_zigzag_direct);
-        ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable  , ff_zigzag_direct);
+        ff_init_scantable(s->idsp.idct_permutation, &s->intra_scantable, ff_zigzag_direct);
     }
-    ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
+    ff_init_scantable(s->idsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
-    ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
+    ff_init_scantable(s->idsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
     return 0;
 }
                            int16_t *block, int i, uint8_t *dest, int line_size, int qscale)
 {
     s->dct_unquantize_intra(s, block, i, qscale);
-    s->dsp.idct_put (dest, line_size, block);
+    s->idsp.idct_put(dest, line_size, block);
 }
 /* add block[] to dest[] */
                            int16_t *block, int i, uint8_t *dest, int line_size)
 {
     if (s->block_last_index[i] >= 0) {
-        s->dsp.idct_add (dest, line_size, block);
+        s->idsp.idct_add(dest, line_size, block);
     }
 }
     if (s->block_last_index[i] >= 0) {
         s->dct_unquantize_inter(s, block, i, qscale);
-        s->dsp.idct_add (dest, line_size, block);
+        s->idsp.idct_add(dest, line_size, block);
     }
 }
        av_log(s->avctx, AV_LOG_DEBUG, "DCT coeffs of MB at %dx%d:\n", s->mb_x, s->mb_y);
        for(i=0; i<6; i++){
            for(j=0; j<64; j++){
-               av_log(s->avctx, AV_LOG_DEBUG, "%5d", block[i][s->dsp.idct_permutation[j]]);
+               av_log(s->avctx, AV_LOG_DEBUG, "%5d",
+                      block[i][s->idsp.idct_permutation[j]]);
            }
            av_log(s->avctx, AV_LOG_DEBUG, "\n");
        }
                     }
                 }
             }else{
-                s->dsp.idct_put(dest_y                          , dct_linesize, block[0]);
+                s->idsp.idct_put(dest_y,                           dct_linesize, block[0]);
-                s->dsp.idct_put(dest_y              + block_size, dct_linesize, block[1]);
+                s->idsp.idct_put(dest_y              + block_size, dct_linesize, block[1]);
-                s->dsp.idct_put(dest_y + dct_offset             , dct_linesize, block[2]);
+                s->idsp.idct_put(dest_y + dct_offset,              dct_linesize, block[2]);
-                s->dsp.idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]);
+                s->idsp.idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]);
                 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
                     if(s->chroma_y_shift){
-                        s->dsp.idct_put(dest_cb, uvlinesize, block[4]);
+                        s->idsp.idct_put(dest_cb, uvlinesize, block[4]);
-                        s->dsp.idct_put(dest_cr, uvlinesize, block[5]);
+                        s->idsp.idct_put(dest_cr, uvlinesize, block[5]);
                     }else{
                         dct_linesize = uvlinesize << s->interlaced_dct;
                         dct_offset   = s->interlaced_dct ? uvlinesize : uvlinesize * 8;
-                        s->dsp.idct_put(dest_cb,              dct_linesize, block[4]);
+                        s->idsp.idct_put(dest_cb,              dct_linesize, block[4]);
-                        s->dsp.idct_put(dest_cr,              dct_linesize, block[5]);
+                        s->idsp.idct_put(dest_cr,              dct_linesize, block[5]);
-                        s->dsp.idct_put(dest_cb + dct_offset, dct_linesize, block[6]);
+                        s->idsp.idct_put(dest_cb + dct_offset, dct_linesize, block[6]);
-                        s->dsp.idct_put(dest_cr + dct_offset, dct_linesize, block[7]);
+                        s->idsp.idct_put(dest_cr + dct_offset, dct_linesize, block[7]);
                         if(!s->chroma_x_shift){//Chroma444
-                            s->dsp.idct_put(dest_cb + 8,              dct_linesize, block[8]);
+                            s->idsp.idct_put(dest_cb + 8,              dct_linesize, block[8]);
-                            s->dsp.idct_put(dest_cr + 8,              dct_linesize, block[9]);
+                            s->idsp.idct_put(dest_cr + 8,              dct_linesize, block[9]);
-                            s->dsp.idct_put(dest_cb + 8 + dct_offset, dct_linesize, block[10]);
+                            s->idsp.idct_put(dest_cb + 8 + dct_offset, dct_linesize, block[10]);
-                            s->dsp.idct_put(dest_cr + 8 + dct_offset, dct_linesize, block[11]);
+                            s->idsp.idct_put(dest_cr + 8 + dct_offset, dct_linesize, block[11]);
                         }
                     }
                 }//gray

libavcodec/mpegvideo.h+2−0

 #include "get_bits.h"
 #include "h263dsp.h"
 #include "hpeldsp.h"
+#include "idctdsp.h"
 #include "mpegvideodsp.h"
 #include "put_bits.h"
 #include "ratecontrol.h"
     BlockDSPContext bdsp;
     DSPContext dsp;             ///< pointers for accelerated dsp functions
     HpelDSPContext hdsp;
+    IDCTDSPContext idsp;
     MpegVideoDSPContext mdsp;
     QpelDSPContext qdsp;
     VideoDSPContext vdsp;

libavcodec/mpegvideo_enc.c+11−9

 #include "avcodec.h"
 #include "dct.h"
 #include "dsputil.h"
+#include "idctdsp.h"
 #include "mpeg12.h"
 #include "mpegvideo.h"
 #include "h261.h"
             dsp->fdct == ff_jpeg_fdct_islow_10 ||
             dsp->fdct == ff_faandct) {
             for (i = 0; i < 64; i++) {
-                const int j = dsp->idct_permutation[i];
+                const int j = s->idsp.idct_permutation[i];
                 /* 16 <= qscale * quant_matrix[i] <= 7905
                  * Assume x = ff_aanscales[i] * qscale * quant_matrix[i]
                  *             19952 <=              x  <= 249205026
             }
         } else if (dsp->fdct == ff_fdct_ifast) {
             for (i = 0; i < 64; i++) {
-                const int j = dsp->idct_permutation[i];
+                const int j = s->idsp.idct_permutation[i];
                 /* 16 <= qscale * quant_matrix[i] <= 7905
                  * Assume x = ff_aanscales[i] * qscale * quant_matrix[i]
                  *             19952 <=              x  <= 249205026
             }
         } else {
             for (i = 0; i < 64; i++) {
-                const int j = dsp->idct_permutation[i];
+                const int j = s->idsp.idct_permutation[i];
                 /* We can safely suppose that 16 <= quant_matrix[i] <= 255
                  * Assume x = qscale * quant_matrix[i]
                  * So             16 <=              x  <= 7905
     /* init q matrix */
     for (i = 0; i < 64; i++) {
-        int j = s->dsp.idct_permutation[i];
+        int j = s->idsp.idct_permutation[i];
         if (CONFIG_MPEG4_ENCODER && s->codec_id == AV_CODEC_ID_MPEG4 &&
             s->mpeg_quant) {
             s->intra_matrix[j] = ff_mpeg4_default_intra_matrix[i];
     if (s->out_format == FMT_MJPEG) {
         /* for mjpeg, we do include qscale in the matrix */
         for(i=1;i<64;i++){
-            int j= s->dsp.idct_permutation[i];
+            int j = s->idsp.idct_permutation[i];
             s->intra_matrix[j] = av_clip_uint8((ff_mpeg1_default_intra_matrix[i] * s->qscale) >> 3);
         }
             if(s->out_format == FMT_H263){
                 unquant_coeff= alevel*qmul + qadd;
             }else{ //MPEG1
-                j= s->dsp.idct_permutation[ scantable[i] ]; //FIXME optimize
+                j = s->idsp.idct_permutation[scantable[i]]; // FIXME: optimize
                 if(s->mb_intra){
                         unquant_coeff = (int)(  alevel  * qscale * s->intra_matrix[j]) >> 3;
                         unquant_coeff =   (unquant_coeff - 1) | 1;
 #endif
     if(basis[0][0] == 0)
-        build_basis(s->dsp.idct_permutation);
+        build_basis(s->idsp.idct_permutation);
     qmul= qscale*2;
     qadd= (qscale-1)|1;
     *overflow= s->max_qcoeff < max; //overflow might have happened
     /* we need this permutation so that we correct the IDCT, we only permute the !=0 elements */
-    if (s->dsp.idct_permutation_type != FF_NO_IDCT_PERM)
+    if (s->idsp.idct_permutation_type != FF_NO_IDCT_PERM)
-        ff_block_permute(block, s->dsp.idct_permutation, scantable, last_non_zero);
+        ff_block_permute(block, s->idsp.idct_permutation,
+                         scantable, last_non_zero);
     return last_non_zero;
 }

libavcodec/mpegvideo_xvmc.c+1−1

@@ -307,7 +307,7 @@ void ff_xvmc_decode_mb(MpegEncContext *s) · 306 unmodified lines
307	if (s->mb_intra && (render->idct \|\| !render->unsigned_intra))	307	if (s->mb_intra && (render->idct \|\| !render->unsigned_intra))
308	*s->pblocks[i][0] -= 1 << 10;	308	*s->pblocks[i][0] -= 1 << 10;
309	if (!render->idct) {	309	if (!render->idct) {
310	s->dsp.idct(*s->pblocks[i]);	310	s->idsp.idct(*s->pblocks[i]);
311	/* It is unclear if MC hardware requires pixel diff values to be	311	/* It is unclear if MC hardware requires pixel diff values to be
312	* in the range [-255;255]. TODO: Clipping if such hardware is	312	* in the range [-255;255]. TODO: Clipping if such hardware is
313	* ever found. As of now it would only be an unnecessary	313	* ever found. As of now it would only be an unnecessary

libavcodec/msmpeg4.c+5−5

@@ -28,7 +28,7 @@ · 27 unmodified lines
28	*/	28	*/
29		29
30	#include "avcodec.h"	30	#include "avcodec.h"
31	#include "dsputil.h"	31	#include "idctdsp.h"
32	#include "mpegvideo.h"	32	#include "mpegvideo.h"
33	#include "msmpeg4.h"	33	#include "msmpeg4.h"
34	#include "libavutil/x86/asm.h"	34	#include "libavutil/x86/asm.h"
@@ -136,10 +136,10 @@ av_cold void ff_msmpeg4_common_init(MpegEncContext *s) · 101 unmodified lines
136		136
137		137
138	if(s->msmpeg4_version>=4){	138	if(s->msmpeg4_version>=4){
139	ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_wmv1_scantable[1]);	139	ff_init_scantable(s->idsp.idct_permutation, &s->intra_scantable, ff_wmv1_scantable[1]);
140	ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_wmv1_scantable[2]);	140	ff_init_scantable(s->idsp.idct_permutation, &s->intra_h_scantable, ff_wmv1_scantable[2]);
141	ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_wmv1_scantable[3]);	141	ff_init_scantable(s->idsp.idct_permutation, &s->intra_v_scantable, ff_wmv1_scantable[3]);
142	ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_wmv1_scantable[0]);	142	ff_init_scantable(s->idsp.idct_permutation, &s->inter_scantable, ff_wmv1_scantable[0]);
143	}	143	}
144	//Note the default tables are set in common_init in mpegvideo.c	144	//Note the default tables are set in common_init in mpegvideo.c
145		145

libavcodec/nuv.c+1−0

@@ -28,6 +28,7 @@ · 27 unmodified lines
28	#include "libavutil/lzo.h"	28	#include "libavutil/lzo.h"
29	#include "libavutil/imgutils.h"	29	#include "libavutil/imgutils.h"
30	#include "avcodec.h"	30	#include "avcodec.h"
		31	#include "idctdsp.h"
31	#include "internal.h"	32	#include "internal.h"
32	#include "rtjpeg.h"	33	#include "rtjpeg.h"
33		34

libavcodec/ppc/Makefile+1−1

 OBJS-$(CONFIG_H264QPEL)                += ppc/h264qpel.o
 OBJS-$(CONFIG_HPELDSP)                 += ppc/hpeldsp_altivec.o
 OBJS-$(CONFIG_HUFFYUVDSP)              += ppc/huffyuvdsp_altivec.o
+OBJS-$(CONFIG_IDCTDSP)                 += ppc/idctdsp.o
 OBJS-$(CONFIG_MPEGAUDIODSP)            += ppc/mpegaudiodsp_altivec.o
 OBJS-$(CONFIG_MPEGVIDEO)               += ppc/mpegvideo_altivec.o      \
                                           ppc/mpegvideodsp.o
 ALTIVEC-OBJS-$(CONFIG_DSPUTIL)         += ppc/dsputil_altivec.o         \
                                           ppc/fdct_altivec.o            \
-                                          ppc/idct_altivec.o            \
 FFT-OBJS-$(HAVE_GNU_AS)                += ppc/fft_altivec_s.o
 ALTIVEC-OBJS-$(CONFIG_FFT)             += $(FFT-OBJS-yes)

libavcodec/ppc/dsputil_altivec.h+0−3

@@ -29,9 +29,6 @@ · 28 unmodified lines
29		29
30	void ff_fdct_altivec(int16_t *block);	30	void ff_fdct_altivec(int16_t *block);
31		31
32	void ff_idct_put_altivec(uint8_t dest, int line_size, int16_t block);
33	void ff_idct_add_altivec(uint8_t dest, int line_size, int16_t block);
34
35	void ff_dsputil_init_altivec(DSPContext c, AVCodecContext avctx,	32	void ff_dsputil_init_altivec(DSPContext c, AVCodecContext avctx,
36	unsigned high_bit_depth);	33	unsigned high_bit_depth);
37		34

libavcodec/ppc/dsputil_ppc.c+0−6

                 c->fdct = ff_fdct_altivec;
             }
 #endif //CONFIG_ENCODERS
-            if ((avctx->idct_algo == FF_IDCT_AUTO) ||
-                (avctx->idct_algo == FF_IDCT_ALTIVEC)) {
-                c->idct_put              = ff_idct_put_altivec;
-                c->idct_add              = ff_idct_add_altivec;
-                c->idct_permutation_type = FF_TRANSPOSE_IDCT_PERM;
-            }
         }
     }
 }

libavcodec/ppc/idctdsp.crenamed from libavcodec/ppc/idct_altivec.c+27−3

 #include <altivec.h>
 #endif
+#include "libavutil/attributes.h"
+#include "libavutil/cpu.h"
+#include "libavutil/ppc/cpu.h"
 #include "libavutil/ppc/types_altivec.h"
-#include "dsputil_altivec.h"
+#include "libavcodec/idctdsp.h"
+#if HAVE_ALTIVEC
 #define IDCT_HALF                                       \
     /* 1st stage */                                     \
     { 19266, 26722, 25172, 22654,  19266,  22654, 25172, 26722 }
 };
-void ff_idct_put_altivec(uint8_t *dest, int stride, int16_t *blk)
+static void idct_put_altivec(uint8_t *dest, int stride, int16_t *blk)
 {
     vec_s16 *block = (vec_s16 *) blk;
     vec_u8 tmp;
     COPY(dest, vx7);
 }
-void ff_idct_add_altivec(uint8_t *dest, int stride, int16_t *blk)
+static void idct_add_altivec(uint8_t *dest, int stride, int16_t *blk)
 {
     vec_s16 *block = (vec_s16 *) blk;
     vec_u8 tmp;
     dest += stride;
     ADD(dest, vx7, perm1);
 }
+#endif /* HAVE_ALTIVEC */
+av_cold void ff_idctdsp_init_ppc(IDCTDSPContext *c, AVCodecContext *avctx,
+                                 unsigned high_bit_depth)
+{
+#if HAVE_ALTIVEC
+    if (PPC_ALTIVEC(av_get_cpu_flags())) {
+        if (!high_bit_depth) {
+            if ((avctx->idct_algo == FF_IDCT_AUTO) ||
+                (avctx->idct_algo == FF_IDCT_ALTIVEC)) {
+                c->idct_add              = idct_add_altivec;
+                c->idct_put              = idct_put_altivec;
+                c->idct_permutation_type = FF_TRANSPOSE_IDCT_PERM;
+            }
+        }
+    }
+#endif /* HAVE_ALTIVEC */
+}

libavcodec/proresdec.c+1−1

@@ -34,7 +34,7 @@ · 33 unmodified lines
34		34
35	#include "libavutil/intmath.h"	35	#include "libavutil/intmath.h"
36	#include "avcodec.h"	36	#include "avcodec.h"
37	#include "dsputil.h"	37	#include "idctdsp.h"
38	#include "internal.h"	38	#include "internal.h"
39	#include "proresdata.h"	39	#include "proresdata.h"
40	#include "proresdsp.h"	40	#include "proresdsp.h"

libavcodec/proresdsp.c+1−1

@@ -23,7 +23,7 @@ · 22 unmodified lines
23	#include "config.h"	23	#include "config.h"
24	#include "libavutil/attributes.h"	24	#include "libavutil/attributes.h"
25	#include "libavutil/common.h"	25	#include "libavutil/common.h"
26	#include "dsputil.h"	26	#include "idctdsp.h"
27	#include "proresdsp.h"	27	#include "proresdsp.h"
28	#include "simple_idct.h"	28	#include "simple_idct.h"
29		29

libavcodec/rtjpeg.c+4−4

@@ -121,7 +121,7 @@ int ff_rtjpeg_decode_frame_yuv420(RTJpegContext c, AVFrame f, · 120 unmodified lines
121	if (res < 0) \	121	if (res < 0) \
122	return res; \	122	return res; \
123	if (res > 0) \	123	if (res > 0) \
124	c->dsp.idct_put(dst, stride, block); \	124	c->idsp.idct_put(dst, stride, block); \
125	} while (0)	125	} while (0)
126	int16_t *block = c->block;	126	int16_t *block = c->block;
127	BLOCK(c->lquant, y1, f->linesize[0]);	127	BLOCK(c->lquant, y1, f->linesize[0]);
@@ -159,7 +159,7 @@ void ff_rtjpeg_decode_init(RTJpegContext *c, int width, int height, · 31 unmodified lines
159	const uint32_t lquant, const uint32_t cquant) {	159	const uint32_t lquant, const uint32_t cquant) {
160	int i;	160	int i;
161	for (i = 0; i < 64; i++) {	161	for (i = 0; i < 64; i++) {
162	int p = c->dsp.idct_permutation[i];	162	int p = c->idsp.idct_permutation[i];
163	c->lquant[p] = lquant[i];	163	c->lquant[p] = lquant[i];
164	c->cquant[p] = cquant[i];	164	c->cquant[p] = cquant[i];
165	}	165	}
@@ -171,13 +171,13 @@ void ff_rtjpeg_init(RTJpegContext c, AVCodecContext avctx) · 5 unmodified lines
171	{	171	{
172	int i;	172	int i;
173		173
174	ff_dsputil_init(&c->dsp, avctx);	174	ff_idctdsp_init(&c->idsp, avctx);
175		175
176	for (i = 0; i < 64; i++) {	176	for (i = 0; i < 64; i++) {
177	int z = ff_zigzag_direct[i];	177	int z = ff_zigzag_direct[i];
178	z = ((z << 3) \| (z >> 3)) & 63; // rtjpeg uses a transposed variant	178	z = ((z << 3) \| (z >> 3)) & 63; // rtjpeg uses a transposed variant
179		179
180	// permute the scan and quantization tables for the chosen idct	180	// permute the scan and quantization tables for the chosen idct
181	c->scan[i] = c->dsp.idct_permutation[z];	181	c->scan[i] = c->idsp.idct_permutation[z];
182	}	182	}
183	}	183	}

libavcodec/rtjpeg.h+3−2

@@ -23,15 +23,16 @@ · 22 unmodified lines
23	#define AVCODEC_RTJPEG_H	23	#define AVCODEC_RTJPEG_H
24		24
25	#include <stdint.h>	25	#include <stdint.h>
26	#include "dsputil.h"	26
27	#include "libavutil/mem.h"	27	#include "libavutil/mem.h"
		28	#include "idctdsp.h"
28		29
29	#define RTJPEG_FILE_VERSION 0	30	#define RTJPEG_FILE_VERSION 0
30	#define RTJPEG_HEADER_SIZE 12	31	#define RTJPEG_HEADER_SIZE 12
31		32
32	typedef struct RTJpegContext {	33	typedef struct RTJpegContext {
33	int w, h;	34	int w, h;
34	DSPContext dsp;	35	IDCTDSPContext idsp;
35	uint8_t scan[64];	36	uint8_t scan[64];
36	uint32_t lquant[64];	37	uint32_t lquant[64];
37	uint32_t cquant[64];	38	uint32_t cquant[64];

libavcodec/vc1dec.c+69−47

                 fieldtx = v->fieldtx_plane[topleft_mb_pos];
             stride_y       = s->linesize << fieldtx;
             v_dist         = (16 - fieldtx) >> (fieldtx == 0);
-            s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][0],
+            s->idsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][0],
-                                             s->dest[0] - 16 * s->linesize - 16,
+                                              s->dest[0] - 16 * s->linesize - 16,
-                                             stride_y);
+                                              stride_y);
-            s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][1],
+            s->idsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][1],
-                                             s->dest[0] - 16 * s->linesize - 8,
+                                              s->dest[0] - 16 * s->linesize - 8,
-                                             stride_y);
+                                              stride_y);
-            s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][2],
+            s->idsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][2],
-                                             s->dest[0] - v_dist * s->linesize - 16,
+                                              s->dest[0] - v_dist * s->linesize - 16,
-                                             stride_y);
+                                              stride_y);
-            s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][3],
+            s->idsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][3],
-                                             s->dest[0] - v_dist * s->linesize - 8,
+                                              s->dest[0] - v_dist * s->linesize - 8,
-                                             stride_y);
+                                              stride_y);
-            s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][4],
+            s->idsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][4],
-                                             s->dest[1] - 8 * s->uvlinesize - 8,
+                                              s->dest[1] - 8 * s->uvlinesize - 8,
-                                             s->uvlinesize);
+                                              s->uvlinesize);
-            s->dsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][5],
+            s->idsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][5],
-                                             s->dest[2] - 8 * s->uvlinesize - 8,
+                                              s->dest[2] - 8 * s->uvlinesize - 8,
-                                             s->uvlinesize);
+                                              s->uvlinesize);
         }
         if (s->mb_x == s->mb_width - 1) {
             top_mb_pos = (s->mb_y - 1) * s->mb_stride + s->mb_x;
                 fieldtx = v->fieldtx_plane[top_mb_pos];
             stride_y   = s->linesize << fieldtx;
             v_dist     = fieldtx ? 15 : 8;
-            s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][0],
+            s->idsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][0],
-                                             s->dest[0] - 16 * s->linesize,
+                                              s->dest[0] - 16 * s->linesize,
-                                             stride_y);
+                                              stride_y);
-            s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][1],
+            s->idsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][1],
-                                             s->dest[0] - 16 * s->linesize + 8,
+                                              s->dest[0] - 16 * s->linesize + 8,
-                                             stride_y);
+                                              stride_y);
-            s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][2],
+            s->idsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][2],
-                                             s->dest[0] - v_dist * s->linesize,
+                                              s->dest[0] - v_dist * s->linesize,
-                                             stride_y);
+                                              stride_y);
-            s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][3],
+            s->idsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][3],
-                                             s->dest[0] - v_dist * s->linesize + 8,
+                                              s->dest[0] - v_dist * s->linesize + 8,
-                                             stride_y);
+                                              stride_y);
-            s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][4],
+            s->idsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][4],
-                                             s->dest[1] - 8 * s->uvlinesize,
+                                              s->dest[1] - 8 * s->uvlinesize,
-                                             s->uvlinesize);
+                                              s->uvlinesize);
-            s->dsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][5],
+            s->idsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][5],
-                                             s->dest[2] - 8 * s->uvlinesize,
+                                              s->dest[2] - 8 * s->uvlinesize,
-                                             s->uvlinesize);
+                                              s->uvlinesize);
         }
     }
                 v->vc1dsp.vc1_inv_trans_8x8_dc(dst, linesize, block);
             else {
                 v->vc1dsp.vc1_inv_trans_8x8(block);
-                s->dsp.add_pixels_clamped(block, dst, linesize);
+                s->idsp.add_pixels_clamped(block, dst, linesize);
             }
         }
         break;
                     if (v->rangeredfrm)
                         for (j = 0; j < 64; j++)
                             s->block[i][j] <<= 1;
-                    s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
+                    s->idsp.put_signed_pixels_clamped(s->block[i],
+                                                      s->dest[dst_idx] + off,
+                                                      i & 4 ? s->uvlinesize
+                                                            : s->linesize);
                     if (v->pq >= 9 && v->overlap) {
                         if (v->c_avail)
                             v->vc1dsp.vc1_h_overlap(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
                     if (v->rangeredfrm)
                         for (j = 0; j < 64; j++)
                             s->block[i][j] <<= 1;
-                    s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off,
+                    s->idsp.put_signed_pixels_clamped(s->block[i],
-                                                     (i & 4) ? s->uvlinesize : s->linesize);
+                                                      s->dest[dst_idx] + off,
+                                                      (i & 4) ? s->uvlinesize
+                                                              : s->linesize);
                     if (v->pq >= 9 && v->overlap) {
                         if (v->c_avail)
                             v->vc1dsp.vc1_h_overlap(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
                     stride_y = s->uvlinesize;
                     off = 0;
                 }
-                s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, stride_y);
+                s->idsp.put_signed_pixels_clamped(s->block[i],
+                                                  s->dest[dst_idx] + off,
+                                                  stride_y);
                 //TODO: loop filter
             }
                 continue;
             v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
             off  = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
-            s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, (i & 4) ? s->uvlinesize : s->linesize);
+            s->idsp.put_signed_pixels_clamped(s->block[i],
+                                              s->dest[dst_idx] + off,
+                                              (i & 4) ? s->uvlinesize
+                                                      : s->linesize);
             // TODO: loop filter
         }
     } else {
             if (v->rangeredfrm)
                 for (j = 0; j < 64; j++)
                     s->block[i][j] <<= 1;
-            s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
+            s->idsp.put_signed_pixels_clamped(s->block[i],
+                                              s->dest[dst_idx] + off,
+                                              i & 4 ? s->uvlinesize
+                                                    : s->linesize);
         } else if (val) {
             vc1_decode_p_block(v, s->block[i], i, mquant, ttmb,
                                first_block, s->dest[dst_idx] + off,
                 for (j = 0; j < 64; j++)
                     s->block[i][j] <<= 1;
             off  = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
-            s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, (i & 4) ? s->uvlinesize : s->linesize);
+            s->idsp.put_signed_pixels_clamped(s->block[i],
+                                              s->dest[dst_idx] + off,
+                                              (i & 4) ? s->uvlinesize
+                                                      : s->linesize);
             // TODO: yet to perform loop filter
         }
     } else {
                 stride_y = s->uvlinesize;
                 off = 0;
             }
-            s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, stride_y);
+            s->idsp.put_signed_pixels_clamped(s->block[i],
+                                              s->dest[dst_idx] + off,
+                                              stride_y);
         }
     } else {
         s->mb_intra = v->is_intra[s->mb_x] = 0;
                     if (v->rangeredfrm)
                         for (j = 0; j < 64; j++)
                             s->block[k][j] <<= 1;
-                    s->dsp.put_signed_pixels_clamped(s->block[k], dst[k], k & 4 ? s->uvlinesize : s->linesize);
+                    s->idsp.put_signed_pixels_clamped(s->block[k], dst[k],
+                                                      k & 4 ? s->uvlinesize
+                                                            : s->linesize);
                 } else {
                     if (v->rangeredfrm)
                         for (j = 0; j < 64; j++)
                             s->block[k][j] = (s->block[k][j] - 64) << 1;
-                    s->dsp.put_pixels_clamped(s->block[k], dst[k], k & 4 ? s->uvlinesize : s->linesize);
+                    s->idsp.put_pixels_clamped(s->block[k], dst[k],
+                                               k & 4 ? s->uvlinesize
+                                                     : s->linesize);
                 }
             }

libavcodec/wmv2.c+12−11

  */
 #include "avcodec.h"
+#include "idctdsp.h"
 #include "mpegvideo.h"
 #include "msmpeg4data.h"
 #include "simple_idct.h"
     ff_blockdsp_init(&s->bdsp, s->avctx);
     ff_wmv2dsp_init(&w->wdsp);
-    s->dsp.idct_permutation_type = w->wdsp.idct_perm;
+    s->idsp.idct_permutation_type = w->wdsp.idct_perm;
-    ff_init_scantable_permutation(s->dsp.idct_permutation,
+    ff_init_scantable_permutation(s->idsp.idct_permutation,
                                   w->wdsp.idct_perm);
-    ff_init_scantable(s->dsp.idct_permutation, &w->abt_scantable[0],
+    ff_init_scantable(s->idsp.idct_permutation, &w->abt_scantable[0],
                       ff_wmv2_scantableA);
-    ff_init_scantable(s->dsp.idct_permutation, &w->abt_scantable[1],
+    ff_init_scantable(s->idsp.idct_permutation, &w->abt_scantable[1],
                       ff_wmv2_scantableB);
-    ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable,
+    ff_init_scantable(s->idsp.idct_permutation, &s->intra_scantable,
                       ff_wmv1_scantable[1]);
-    ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable,
+    ff_init_scantable(s->idsp.idct_permutation, &s->intra_h_scantable,
                       ff_wmv1_scantable[2]);
-    ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable,
+    ff_init_scantable(s->idsp.idct_permutation, &s->intra_v_scantable,
                       ff_wmv1_scantable[3]);
-    ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable,
+    ff_init_scantable(s->idsp.idct_permutation, &s->inter_scantable,
                       ff_wmv1_scantable[0]);
-    s->dsp.idct_put = w->wdsp.idct_put;
+    s->idsp.idct_put = w->wdsp.idct_put;
-    s->dsp.idct_add = w->wdsp.idct_add;
+    s->idsp.idct_add = w->wdsp.idct_add;
-    s->dsp.idct     = NULL;
+    s->idsp.idct     = NULL;
 }
 static void wmv2_add_block(Wmv2Context *w, int16_t *block1, uint8_t *dst, int stride, int n){

libavcodec/wmv2dsp.c+1−1

@@ -19,7 +19,7 @@ · 18 unmodified lines
19	#include "libavutil/attributes.h"	19	#include "libavutil/attributes.h"
20	#include "libavutil/common.h"	20	#include "libavutil/common.h"
21	#include "avcodec.h"	21	#include "avcodec.h"
22	#include "dsputil.h"	22	#include "idctdsp.h"
23	#include "mathops.h"	23	#include "mathops.h"
24	#include "wmv2dsp.h"	24	#include "wmv2dsp.h"
25		25

libavcodec/x86/Makefile+6−4

 OBJS-$(CONFIG_HPELDSP)                 += x86/hpeldsp_init.o
 OBJS-$(CONFIG_HUFFYUVDSP)              += x86/huffyuvdsp_init.o
 OBJS-$(CONFIG_HUFFYUVENCDSP)           += x86/huffyuvencdsp_mmx.o
+OBJS-$(CONFIG_IDCTDSP)                 += x86/idctdsp_init.o
 OBJS-$(CONFIG_LPC)                     += x86/lpc.o
 OBJS-$(CONFIG_MPEGAUDIODSP)            += x86/mpegaudiodsp.o
 OBJS-$(CONFIG_MPEGVIDEO)               += x86/mpegvideo.o              \
 MMX-OBJS-$(CONFIG_AUDIODSP)            += x86/audiodsp_mmx.o
 MMX-OBJS-$(CONFIG_BLOCKDSP)            += x86/blockdsp_mmx.o
-MMX-OBJS-$(CONFIG_DSPUTIL)             += x86/dsputil_mmx.o             \
+MMX-OBJS-$(CONFIG_DSPUTIL)             += x86/dsputil_mmx.o
-                                          x86/idct_mmx_xvid.o           \
-                                          x86/idct_sse2_xvid.o          \
-                                          x86/simple_idct.o
 MMX-OBJS-$(CONFIG_HPELDSP)             += x86/fpel_mmx.o                \
                                           x86/hpeldsp_mmx.o
 MMX-OBJS-$(CONFIG_HUFFYUVDSP)          += x86/huffyuvdsp_mmx.o
+MMX-OBJS-$(CONFIG_IDCTDSP)             += x86/idctdsp_mmx.o             \
+                                          x86/idct_mmx_xvid.o           \
+                                          x86/idct_sse2_xvid.o          \
+                                          x86/simple_idct.o
 MMX-OBJS-$(CONFIG_QPELDSP)             += x86/fpel_mmx.o
 MMX-OBJS-$(CONFIG_SVQ1_ENCODER)        += x86/svq1enc_mmx.o

libavcodec/x86/cavsdsp.c+2−1

 #include "libavutil/x86/asm.h"
 #include "libavutil/x86/cpu.h"
 #include "libavcodec/cavsdsp.h"
+#include "libavcodec/idctdsp.h"
 #include "constants.h"
-#include "dsputil_x86.h"
 #include "fpel.h"
+#include "idctdsp.h"
 #include "config.h"
 #if HAVE_MMX_INLINE

libavcodec/x86/dsputil_init.c+0−85

@@ -22,97 +22,18 @@ · 21 unmodified lines
22	#include "libavutil/x86/cpu.h"	22	#include "libavutil/x86/cpu.h"
23	#include "libavcodec/avcodec.h"	23	#include "libavcodec/avcodec.h"
24	#include "libavcodec/dsputil.h"	24	#include "libavcodec/dsputil.h"
25	#include "libavcodec/simple_idct.h"
26	#include "dsputil_x86.h"	25	#include "dsputil_x86.h"
27	#include "idct_xvid.h"
28
29	/* Input permutation for the simple_idct_mmx */
30	static const uint8_t simple_mmx_permutation[64] = {
31	0x00, 0x08, 0x04, 0x09, 0x01, 0x0C, 0x05, 0x0D,
32	0x10, 0x18, 0x14, 0x19, 0x11, 0x1C, 0x15, 0x1D,
33	0x20, 0x28, 0x24, 0x29, 0x21, 0x2C, 0x25, 0x2D,
34	0x12, 0x1A, 0x16, 0x1B, 0x13, 0x1E, 0x17, 0x1F,
35	0x02, 0x0A, 0x06, 0x0B, 0x03, 0x0E, 0x07, 0x0F,
36	0x30, 0x38, 0x34, 0x39, 0x31, 0x3C, 0x35, 0x3D,
37	0x22, 0x2A, 0x26, 0x2B, 0x23, 0x2E, 0x27, 0x2F,
38	0x32, 0x3A, 0x36, 0x3B, 0x33, 0x3E, 0x37, 0x3F,
39	};
40
41	static const uint8_t idct_sse2_row_perm[8] = { 0, 4, 1, 5, 2, 6, 3, 7 };
42
43	av_cold int ff_init_scantable_permutation_x86(uint8_t *idct_permutation,
44	int idct_permutation_type)
45	{
46	int i;
47
48	switch (idct_permutation_type) {
49	case FF_SIMPLE_IDCT_PERM:
50	for (i = 0; i < 64; i++)
51	idct_permutation[i] = simple_mmx_permutation[i];
52	return 1;
53	case FF_SSE2_IDCT_PERM:
54	for (i = 0; i < 64; i++)
55	idct_permutation[i] = (i & 0x38) \| idct_sse2_row_perm[i & 7];
56	return 1;
57	}
58
59	return 0;
60	}
61		26
62	static av_cold void dsputil_init_mmx(DSPContext c, AVCodecContext avctx,	27	static av_cold void dsputil_init_mmx(DSPContext c, AVCodecContext avctx,
63	int cpu_flags, unsigned high_bit_depth)	28	int cpu_flags, unsigned high_bit_depth)
64	{	29	{
65	#if HAVE_MMX_INLINE	30	#if HAVE_MMX_INLINE
66	c->put_pixels_clamped = ff_put_pixels_clamped_mmx;
67	c->put_signed_pixels_clamped = ff_put_signed_pixels_clamped_mmx;
68	c->add_pixels_clamped = ff_add_pixels_clamped_mmx;
69
70	if (!high_bit_depth) {	31	if (!high_bit_depth) {
71	c->draw_edges = ff_draw_edges_mmx;	32	c->draw_edges = ff_draw_edges_mmx;
72
73	switch (avctx->idct_algo) {
74	case FF_IDCT_AUTO:
75	case FF_IDCT_SIMPLEMMX:
76	c->idct_put = ff_simple_idct_put_mmx;
77	c->idct_add = ff_simple_idct_add_mmx;
78	c->idct = ff_simple_idct_mmx;
79	c->idct_permutation_type = FF_SIMPLE_IDCT_PERM;
80	break;
81	case FF_IDCT_XVIDMMX:
82	c->idct_put = ff_idct_xvid_mmx_put;
83	c->idct_add = ff_idct_xvid_mmx_add;
84	c->idct = ff_idct_xvid_mmx;
85	break;
86	}
87	}	33	}
88	#endif /* HAVE_MMX_INLINE */	34	#endif /* HAVE_MMX_INLINE */
89	}	35	}
90		36
91	static av_cold void dsputil_init_mmxext(DSPContext c, AVCodecContext avctx,
92	int cpu_flags, unsigned high_bit_depth)
93	{
94	#if HAVE_MMXEXT_INLINE
95	if (!high_bit_depth && avctx->idct_algo == FF_IDCT_XVIDMMX) {
96	c->idct_put = ff_idct_xvid_mmxext_put;
97	c->idct_add = ff_idct_xvid_mmxext_add;
98	c->idct = ff_idct_xvid_mmxext;
99	}
100	#endif /* HAVE_MMXEXT_INLINE */
101	}
102
103	static av_cold void dsputil_init_sse2(DSPContext c, AVCodecContext avctx,
104	int cpu_flags, unsigned high_bit_depth)
105	{
106	#if HAVE_SSE2_INLINE
107	if (!high_bit_depth && avctx->idct_algo == FF_IDCT_XVIDMMX) {
108	c->idct_put = ff_idct_xvid_sse2_put;
109	c->idct_add = ff_idct_xvid_sse2_add;
110	c->idct = ff_idct_xvid_sse2;
111	c->idct_permutation_type = FF_SSE2_IDCT_PERM;
112	}
113	#endif /* HAVE_SSE2_INLINE */
114	}
115
116	av_cold void ff_dsputil_init_x86(DSPContext c, AVCodecContext avctx,	37	av_cold void ff_dsputil_init_x86(DSPContext c, AVCodecContext avctx,
117	unsigned high_bit_depth)	38	unsigned high_bit_depth)
118	{	39	{
@@ -121,12 +42,6 @@ av_cold void ff_dsputil_init_x86(DSPContext c, AVCodecContext avctx, · 2 unmodified lines
121	if (X86_MMX(cpu_flags))	42	if (X86_MMX(cpu_flags))
122	dsputil_init_mmx(c, avctx, cpu_flags, high_bit_depth);	43	dsputil_init_mmx(c, avctx, cpu_flags, high_bit_depth);
123		44
124	if (X86_MMXEXT(cpu_flags))
125	dsputil_init_mmxext(c, avctx, cpu_flags, high_bit_depth);
126
127	if (X86_SSE2(cpu_flags))
128	dsputil_init_sse2(c, avctx, cpu_flags, high_bit_depth);
129
130	if (CONFIG_ENCODERS)	45	if (CONFIG_ENCODERS)
131	ff_dsputilenc_init_mmx(c, avctx, high_bit_depth);	46	ff_dsputilenc_init_mmx(c, avctx, high_bit_depth);
132	}	47	}

libavcodec/x86/dsputil_mmx.c+0−135

@@ -30,141 +30,6 @@ · 29 unmodified lines
30		30
31	#if HAVE_INLINE_ASM	31	#if HAVE_INLINE_ASM
32		32
33	void ff_put_pixels_clamped_mmx(const int16_t block, uint8_t pixels,
34	int line_size)
35	{
36	const int16_t *p;
37	uint8_t *pix;
38
39	/* read the pixels */
40	p = block;
41	pix = pixels;
42	/* unrolled loop */
43	__asm__ volatile (
44	"movq (%3), %%mm0 \n\t"
45	"movq 8(%3), %%mm1 \n\t"
46	"movq 16(%3), %%mm2 \n\t"
47	"movq 24(%3), %%mm3 \n\t"
48	"movq 32(%3), %%mm4 \n\t"
49	"movq 40(%3), %%mm5 \n\t"
50	"movq 48(%3), %%mm6 \n\t"
51	"movq 56(%3), %%mm7 \n\t"
52	"packuswb %%mm1, %%mm0 \n\t"
53	"packuswb %%mm3, %%mm2 \n\t"
54	"packuswb %%mm5, %%mm4 \n\t"
55	"packuswb %%mm7, %%mm6 \n\t"
56	"movq %%mm0, (%0) \n\t"
57	"movq %%mm2, (%0, %1) \n\t"
58	"movq %%mm4, (%0, %1, 2) \n\t"
59	"movq %%mm6, (%0, %2) \n\t"
60	:: "r" (pix), "r" ((x86_reg) line_size), "r" ((x86_reg) line_size * 3),
61	"r" (p)
62	: "memory");
63	pix += line_size * 4;
64	p += 32;
65
66	// if here would be an exact copy of the code above
67	// compiler would generate some very strange code
68	// thus using "r"
69	__asm__ volatile (
70	"movq (%3), %%mm0 \n\t"
71	"movq 8(%3), %%mm1 \n\t"
72	"movq 16(%3), %%mm2 \n\t"
73	"movq 24(%3), %%mm3 \n\t"
74	"movq 32(%3), %%mm4 \n\t"
75	"movq 40(%3), %%mm5 \n\t"
76	"movq 48(%3), %%mm6 \n\t"
77	"movq 56(%3), %%mm7 \n\t"
78	"packuswb %%mm1, %%mm0 \n\t"
79	"packuswb %%mm3, %%mm2 \n\t"
80	"packuswb %%mm5, %%mm4 \n\t"
81	"packuswb %%mm7, %%mm6 \n\t"
82	"movq %%mm0, (%0) \n\t"
83	"movq %%mm2, (%0, %1) \n\t"
84	"movq %%mm4, (%0, %1, 2) \n\t"
85	"movq %%mm6, (%0, %2) \n\t"
86	:: "r" (pix), "r" ((x86_reg) line_size), "r" ((x86_reg) line_size * 3),
87	"r" (p)
88	: "memory");
89	}
90
91	#define put_signed_pixels_clamped_mmx_half(off) \
92	"movq "#off"(%2), %%mm1 \n\t" \
93	"movq 16 + "#off"(%2), %%mm2 \n\t" \
94	"movq 32 + "#off"(%2), %%mm3 \n\t" \
95	"movq 48 + "#off"(%2), %%mm4 \n\t" \
96	"packsswb 8 + "#off"(%2), %%mm1 \n\t" \
97	"packsswb 24 + "#off"(%2), %%mm2 \n\t" \
98	"packsswb 40 + "#off"(%2), %%mm3 \n\t" \
99	"packsswb 56 + "#off"(%2), %%mm4 \n\t" \
100	"paddb %%mm0, %%mm1 \n\t" \
101	"paddb %%mm0, %%mm2 \n\t" \
102	"paddb %%mm0, %%mm3 \n\t" \
103	"paddb %%mm0, %%mm4 \n\t" \
104	"movq %%mm1, (%0) \n\t" \
105	"movq %%mm2, (%0, %3) \n\t" \
106	"movq %%mm3, (%0, %3, 2) \n\t" \
107	"movq %%mm4, (%0, %1) \n\t"
108
109	void ff_put_signed_pixels_clamped_mmx(const int16_t block, uint8_t pixels,
110	int line_size)
111	{
112	x86_reg line_skip = line_size;
113	x86_reg line_skip3;
114
115	__asm__ volatile (
116	"movq "MANGLE(ff_pb_80)", %%mm0 \n\t"
117	"lea (%3, %3, 2), %1 \n\t"
118	put_signed_pixels_clamped_mmx_half(0)
119	"lea (%0, %3, 4), %0 \n\t"
120	put_signed_pixels_clamped_mmx_half(64)
121	: "+&r" (pixels), "=&r" (line_skip3)
122	: "r" (block), "r" (line_skip)
123	: "memory");
124	}
125
126	void ff_add_pixels_clamped_mmx(const int16_t block, uint8_t pixels,
127	int line_size)
128	{
129	const int16_t *p;
130	uint8_t *pix;
131	int i;
132
133	/* read the pixels */
134	p = block;
135	pix = pixels;
136	MOVQ_ZERO(mm7);
137	i = 4;
138	do {
139	__asm__ volatile (
140	"movq (%2), %%mm0 \n\t"
141	"movq 8(%2), %%mm1 \n\t"
142	"movq 16(%2), %%mm2 \n\t"
143	"movq 24(%2), %%mm3 \n\t"
144	"movq %0, %%mm4 \n\t"
145	"movq %1, %%mm6 \n\t"
146	"movq %%mm4, %%mm5 \n\t"
147	"punpcklbw %%mm7, %%mm4 \n\t"
148	"punpckhbw %%mm7, %%mm5 \n\t"
149	"paddsw %%mm4, %%mm0 \n\t"
150	"paddsw %%mm5, %%mm1 \n\t"
151	"movq %%mm6, %%mm5 \n\t"
152	"punpcklbw %%mm7, %%mm6 \n\t"
153	"punpckhbw %%mm7, %%mm5 \n\t"
154	"paddsw %%mm6, %%mm2 \n\t"
155	"paddsw %%mm5, %%mm3 \n\t"
156	"packuswb %%mm1, %%mm0 \n\t"
157	"packuswb %%mm3, %%mm2 \n\t"
158	"movq %%mm0, %0 \n\t"
159	"movq %%mm2, %1 \n\t"
160	: "+m" (pix), "+m" ((pix + line_size))
161	: "r" (p)
162	: "memory");
163	pix += line_size * 2;
164	p += 16;
165	} while (--i);
166	}
167
168	/* Draw the edges of width 'w' of an image of size width, height	33	/* Draw the edges of width 'w' of an image of size width, height
169	* this MMX version can only handle w == 8 \|\| w == 16. */	34	* this MMX version can only handle w == 8 \|\| w == 16. */
170	void ff_draw_edges_mmx(uint8_t *buf, int wrap, int width, int height,	35	void ff_draw_edges_mmx(uint8_t *buf, int wrap, int width, int height,

libavcodec/x86/dsputil_x86.h+0−7

@@ -31,13 +31,6 @@ void ff_dsputilenc_init_mmx(DSPContext c, AVCodecContext avctx, · 30 unmodified lines
31	unsigned high_bit_depth);	31	unsigned high_bit_depth);
32	void ff_dsputil_init_pix_mmx(DSPContext c, AVCodecContext avctx);	32	void ff_dsputil_init_pix_mmx(DSPContext c, AVCodecContext avctx);
33		33
34	void ff_add_pixels_clamped_mmx(const int16_t block, uint8_t pixels,
35	int line_size);
36	void ff_put_pixels_clamped_mmx(const int16_t block, uint8_t pixels,
37	int line_size);
38	void ff_put_signed_pixels_clamped_mmx(const int16_t block, uint8_t pixels,
39	int line_size);
40
41	void ff_draw_edges_mmx(uint8_t *buf, int wrap, int width, int height,	34	void ff_draw_edges_mmx(uint8_t *buf, int wrap, int width, int height,
42	int w, int h, int sides);	35	int w, int h, int sides);
43		36

libavcodec/x86/idct_mmx_xvid.c+1−1

@@ -44,8 +44,8 @@ · 43 unmodified lines
44	#include "config.h"	44	#include "config.h"
45	#include "libavcodec/avcodec.h"	45	#include "libavcodec/avcodec.h"
46	#include "libavutil/mem.h"	46	#include "libavutil/mem.h"
47	#include "dsputil_x86.h"
48	#include "idct_xvid.h"	47	#include "idct_xvid.h"
		48	#include "idctdsp.h"
49		49
50	#if HAVE_MMX_INLINE	50	#if HAVE_MMX_INLINE
51		51

libavcodec/x86/idct_sse2_xvid.c+1−1

@@ -42,7 +42,7 @@ · 41 unmodified lines
42	#include "libavutil/mem.h"	42	#include "libavutil/mem.h"
43	#include "libavutil/x86/asm.h"	43	#include "libavutil/x86/asm.h"
44	#include "idct_xvid.h"	44	#include "idct_xvid.h"
45	#include "dsputil_x86.h"	45	#include "idctdsp.h"
46		46
47	#if HAVE_SSE2_INLINE	47	#if HAVE_SSE2_INLINE
48		48

libavcodec/x86/idctdsp.h+31−0

@@ -0,0 +1,31 @@
	1	/*
	2	* This file is part of Libav.
	3	*
	4	* Libav 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	* Libav 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 Libav; if not, write to the Free Software
	16	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
	17	*/
	18
	19	#ifndef AVCODEC_X86_IDCTDSP_H
	20	#define AVCODEC_X86_IDCTDSP_H
	21
	22	#include <stdint.h>
	23
	24	void ff_add_pixels_clamped_mmx(const int16_t block, uint8_t pixels,
	25	int line_size);
	26	void ff_put_pixels_clamped_mmx(const int16_t block, uint8_t pixels,
	27	int line_size);
	28	void ff_put_signed_pixels_clamped_mmx(const int16_t block, uint8_t pixels,
	29	int line_size);
	30
	31	#endif /* AVCODEC_X86_IDCTDSP_H */

libavcodec/x86/idctdsp_init.c+106−0

@@ -0,0 +1,106 @@
	1	/*
	2	* This file is part of Libav.
	3	*
	4	* Libav 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	* Libav 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 Libav; 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/cpu.h"
	22	#include "libavutil/x86/cpu.h"
	23	#include "libavcodec/avcodec.h"
	24	#include "libavcodec/idctdsp.h"
	25	#include "libavcodec/simple_idct.h"
	26	#include "idct_xvid.h"
	27	#include "idctdsp.h"
	28
	29	/* Input permutation for the simple_idct_mmx */
	30	static const uint8_t simple_mmx_permutation[64] = {
	31	0x00, 0x08, 0x04, 0x09, 0x01, 0x0C, 0x05, 0x0D,
	32	0x10, 0x18, 0x14, 0x19, 0x11, 0x1C, 0x15, 0x1D,
	33	0x20, 0x28, 0x24, 0x29, 0x21, 0x2C, 0x25, 0x2D,
	34	0x12, 0x1A, 0x16, 0x1B, 0x13, 0x1E, 0x17, 0x1F,
	35	0x02, 0x0A, 0x06, 0x0B, 0x03, 0x0E, 0x07, 0x0F,
	36	0x30, 0x38, 0x34, 0x39, 0x31, 0x3C, 0x35, 0x3D,
	37	0x22, 0x2A, 0x26, 0x2B, 0x23, 0x2E, 0x27, 0x2F,
	38	0x32, 0x3A, 0x36, 0x3B, 0x33, 0x3E, 0x37, 0x3F,
	39	};
	40
	41	static const uint8_t idct_sse2_row_perm[8] = { 0, 4, 1, 5, 2, 6, 3, 7 };
	42
	43	av_cold int ff_init_scantable_permutation_x86(uint8_t *idct_permutation,
	44	int idct_permutation_type)
	45	{
	46	int i;
	47
	48	switch (idct_permutation_type) {
	49	case FF_SIMPLE_IDCT_PERM:
	50	for (i = 0; i < 64; i++)
	51	idct_permutation[i] = simple_mmx_permutation[i];
	52	return 1;
	53	case FF_SSE2_IDCT_PERM:
	54	for (i = 0; i < 64; i++)
	55	idct_permutation[i] = (i & 0x38) \| idct_sse2_row_perm[i & 7];
	56	return 1;
	57	}
	58
	59	return 0;
	60	}
	61
	62	av_cold void ff_idctdsp_init_x86(IDCTDSPContext c, AVCodecContext avctx,
	63	unsigned high_bit_depth)
	64	{
	65	int cpu_flags = av_get_cpu_flags();
	66
	67	if (INLINE_MMX(cpu_flags)) {
	68	c->put_pixels_clamped = ff_put_pixels_clamped_mmx;
	69	c->put_signed_pixels_clamped = ff_put_signed_pixels_clamped_mmx;
	70	c->add_pixels_clamped = ff_add_pixels_clamped_mmx;
	71
	72	if (!high_bit_depth) {
	73	switch (avctx->idct_algo) {
	74	case FF_IDCT_AUTO:
	75	case FF_IDCT_SIMPLEMMX:
	76	c->idct_put = ff_simple_idct_put_mmx;
	77	c->idct_add = ff_simple_idct_add_mmx;
	78	c->idct = ff_simple_idct_mmx;
	79	c->idct_permutation_type = FF_SIMPLE_IDCT_PERM;
	80	break;
	81	case FF_IDCT_XVIDMMX:
	82	c->idct_put = ff_idct_xvid_mmx_put;
	83	c->idct_add = ff_idct_xvid_mmx_add;
	84	c->idct = ff_idct_xvid_mmx;
	85	break;
	86	}
	87	}
	88	}
	89
	90	if (INLINE_MMXEXT(cpu_flags)) {
	91	if (!high_bit_depth && avctx->idct_algo == FF_IDCT_XVIDMMX) {
	92	c->idct_put = ff_idct_xvid_mmxext_put;
	93	c->idct_add = ff_idct_xvid_mmxext_add;
	94	c->idct = ff_idct_xvid_mmxext;
	95	}
	96	}
	97
	98	if (INLINE_SSE2(cpu_flags)) {
	99	if (!high_bit_depth && avctx->idct_algo == FF_IDCT_XVIDMMX) {
	100	c->idct_put = ff_idct_xvid_sse2_put;
	101	c->idct_add = ff_idct_xvid_sse2_add;
	102	c->idct = ff_idct_xvid_sse2;
	103	c->idct_permutation_type = FF_SSE2_IDCT_PERM;
	104	}
	105	}
	106	}

libavcodec/x86/idctdsp_mmx.c+168−0

@@ -0,0 +1,168 @@
	1	/*
	2	* SIMD-optimized IDCT-related routines
	3	* Copyright (c) 2000, 2001 Fabrice Bellard
	4	* Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
	5	*
	6	* MMX optimization by Nick Kurshev <nickols_k@mail.ru>
	7	*
	8	* This file is part of Libav.
	9	*
	10	* Libav is free software; you can redistribute it and/or
	11	* modify it under the terms of the GNU Lesser General Public
	12	* License as published by the Free Software Foundation; either
	13	* version 2.1 of the License, or (at your option) any later version.
	14	*
	15	* Libav is distributed in the hope that it will be useful,
	16	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	17	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	18	* Lesser General Public License for more details.
	19	*
	20	* You should have received a copy of the GNU Lesser General Public
	21	* License along with Libav; if not, write to the Free Software
	22	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
	23	*/
	24
	25	#include "config.h"
	26	#include "libavutil/cpu.h"
	27	#include "libavutil/x86/asm.h"
	28	#include "idctdsp.h"
	29	#include "inline_asm.h"
	30
	31	#if HAVE_INLINE_ASM
	32
	33	void ff_put_pixels_clamped_mmx(const int16_t block, uint8_t pixels,
	34	int line_size)
	35	{
	36	const int16_t *p;
	37	uint8_t *pix;
	38
	39	/* read the pixels */
	40	p = block;
	41	pix = pixels;
	42	/* unrolled loop */
	43	__asm__ volatile (
	44	"movq (%3), %%mm0 \n\t"
	45	"movq 8(%3), %%mm1 \n\t"
	46	"movq 16(%3), %%mm2 \n\t"
	47	"movq 24(%3), %%mm3 \n\t"
	48	"movq 32(%3), %%mm4 \n\t"
	49	"movq 40(%3), %%mm5 \n\t"
	50	"movq 48(%3), %%mm6 \n\t"
	51	"movq 56(%3), %%mm7 \n\t"
	52	"packuswb %%mm1, %%mm0 \n\t"
	53	"packuswb %%mm3, %%mm2 \n\t"
	54	"packuswb %%mm5, %%mm4 \n\t"
	55	"packuswb %%mm7, %%mm6 \n\t"
	56	"movq %%mm0, (%0) \n\t"
	57	"movq %%mm2, (%0, %1) \n\t"
	58	"movq %%mm4, (%0, %1, 2) \n\t"
	59	"movq %%mm6, (%0, %2) \n\t"
	60	:: "r" (pix), "r" ((x86_reg) line_size), "r" ((x86_reg) line_size * 3),
	61	"r" (p)
	62	: "memory");
	63	pix += line_size * 4;
	64	p += 32;
	65
	66	// if here would be an exact copy of the code above
	67	// compiler would generate some very strange code
	68	// thus using "r"
	69	__asm__ volatile (
	70	"movq (%3), %%mm0 \n\t"
	71	"movq 8(%3), %%mm1 \n\t"
	72	"movq 16(%3), %%mm2 \n\t"
	73	"movq 24(%3), %%mm3 \n\t"
	74	"movq 32(%3), %%mm4 \n\t"
	75	"movq 40(%3), %%mm5 \n\t"
	76	"movq 48(%3), %%mm6 \n\t"
	77	"movq 56(%3), %%mm7 \n\t"
	78	"packuswb %%mm1, %%mm0 \n\t"
	79	"packuswb %%mm3, %%mm2 \n\t"
	80	"packuswb %%mm5, %%mm4 \n\t"
	81	"packuswb %%mm7, %%mm6 \n\t"
	82	"movq %%mm0, (%0) \n\t"
	83	"movq %%mm2, (%0, %1) \n\t"
	84	"movq %%mm4, (%0, %1, 2) \n\t"
	85	"movq %%mm6, (%0, %2) \n\t"
	86	:: "r" (pix), "r" ((x86_reg) line_size), "r" ((x86_reg) line_size * 3),
	87	"r" (p)
	88	: "memory");
	89	}
	90
	91	#define put_signed_pixels_clamped_mmx_half(off) \
	92	"movq "#off"(%2), %%mm1 \n\t" \
	93	"movq 16 + "#off"(%2), %%mm2 \n\t" \
	94	"movq 32 + "#off"(%2), %%mm3 \n\t" \
	95	"movq 48 + "#off"(%2), %%mm4 \n\t" \
	96	"packsswb 8 + "#off"(%2), %%mm1 \n\t" \
	97	"packsswb 24 + "#off"(%2), %%mm2 \n\t" \
	98	"packsswb 40 + "#off"(%2), %%mm3 \n\t" \
	99	"packsswb 56 + "#off"(%2), %%mm4 \n\t" \
	100	"paddb %%mm0, %%mm1 \n\t" \
	101	"paddb %%mm0, %%mm2 \n\t" \
	102	"paddb %%mm0, %%mm3 \n\t" \
	103	"paddb %%mm0, %%mm4 \n\t" \
	104	"movq %%mm1, (%0) \n\t" \
	105	"movq %%mm2, (%0, %3) \n\t" \
	106	"movq %%mm3, (%0, %3, 2) \n\t" \
	107	"movq %%mm4, (%0, %1) \n\t"
	108
	109	void ff_put_signed_pixels_clamped_mmx(const int16_t block, uint8_t pixels,
	110	int line_size)
	111	{
	112	x86_reg line_skip = line_size;
	113	x86_reg line_skip3;
	114
	115	__asm__ volatile (
	116	"movq "MANGLE(ff_pb_80)", %%mm0 \n\t"
	117	"lea (%3, %3, 2), %1 \n\t"
	118	put_signed_pixels_clamped_mmx_half(0)
	119	"lea (%0, %3, 4), %0 \n\t"
	120	put_signed_pixels_clamped_mmx_half(64)
	121	: "+&r" (pixels), "=&r" (line_skip3)
	122	: "r" (block), "r" (line_skip)
	123	: "memory");
	124	}
	125
	126	void ff_add_pixels_clamped_mmx(const int16_t block, uint8_t pixels,
	127	int line_size)
	128	{
	129	const int16_t *p;
	130	uint8_t *pix;
	131	int i;
	132
	133	/* read the pixels */
	134	p = block;
	135	pix = pixels;
	136	MOVQ_ZERO(mm7);
	137	i = 4;
	138	do {
	139	__asm__ volatile (
	140	"movq (%2), %%mm0 \n\t"
	141	"movq 8(%2), %%mm1 \n\t"
	142	"movq 16(%2), %%mm2 \n\t"
	143	"movq 24(%2), %%mm3 \n\t"
	144	"movq %0, %%mm4 \n\t"
	145	"movq %1, %%mm6 \n\t"
	146	"movq %%mm4, %%mm5 \n\t"
	147	"punpcklbw %%mm7, %%mm4 \n\t"
	148	"punpckhbw %%mm7, %%mm5 \n\t"
	149	"paddsw %%mm4, %%mm0 \n\t"
	150	"paddsw %%mm5, %%mm1 \n\t"
	151	"movq %%mm6, %%mm5 \n\t"
	152	"punpcklbw %%mm7, %%mm6 \n\t"
	153	"punpckhbw %%mm7, %%mm5 \n\t"
	154	"paddsw %%mm6, %%mm2 \n\t"
	155	"paddsw %%mm5, %%mm3 \n\t"
	156	"packuswb %%mm1, %%mm0 \n\t"
	157	"packuswb %%mm3, %%mm2 \n\t"
	158	"movq %%mm0, %0 \n\t"
	159	"movq %%mm2, %1 \n\t"
	160	: "+m" (pix), "+m" ((pix + line_size))
	161	: "r" (p)
	162	: "memory");
	163	pix += line_size * 2;
	164	p += 16;
	165	} while (--i);
	166	}
	167
	168	#endif /* HAVE_INLINE_ASM */

libavcodec/x86/mpegvideoenc_template.c+1−1

@@ -229,7 +229,7 @@ static int RENAME(dct_quantize)(MpegEncContext *s, · 228 unmodified lines
229	if(s->mb_intra) block[0]= level;	229	if(s->mb_intra) block[0]= level;
230	else block[0]= temp_block[0];	230	else block[0]= temp_block[0];
231		231
232	if(s->dsp.idct_permutation_type == FF_SIMPLE_IDCT_PERM){	232	if (s->idsp.idct_permutation_type == FF_SIMPLE_IDCT_PERM) {
233	if(last_non_zero_p1 <= 1) goto end;	233	if(last_non_zero_p1 <= 1) goto end;
234	block[0x08] = temp_block[0x01]; block[0x10] = temp_block[0x08];	234	block[0x08] = temp_block[0x01]; block[0x10] = temp_block[0x08];
235	block[0x20] = temp_block[0x10];	235	block[0x20] = temp_block[0x10];

libavcodec/x86/proresdsp_init.c+1−1

@@ -22,7 +22,7 @@ · 21 unmodified lines
22		22
23	#include "libavutil/attributes.h"	23	#include "libavutil/attributes.h"
24	#include "libavutil/x86/cpu.h"	24	#include "libavutil/x86/cpu.h"
25	#include "libavcodec/dsputil.h"	25	#include "libavcodec/idctdsp.h"
26	#include "libavcodec/proresdsp.h"	26	#include "libavcodec/proresdsp.h"
27		27
28	void ff_prores_idct_put_10_sse2(uint16_t *dst, int linesize,	28	void ff_prores_idct_put_10_sse2(uint16_t *dst, int linesize,

libavcodec/x86/simple_idct.c+1−1

@@ -23,7 +23,7 @@ · 22 unmodified lines
23	#include "libavutil/internal.h"	23	#include "libavutil/internal.h"
24	#include "libavutil/mem.h"	24	#include "libavutil/mem.h"
25	#include "libavutil/x86/asm.h"	25	#include "libavutil/x86/asm.h"
26	#include "dsputil_x86.h"	26	#include "idctdsp.h"
27		27
28	#if HAVE_INLINE_ASM	28	#if HAVE_INLINE_ASM
29		29

dsputil: Split off IDCT bits into their own context

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code