idct: Change type of array stride parameters to ptrdiff_t

ptrdiff_t is the correct type for array strides and similar.

Diego Biurrun committed 10 years ago

Commit 2ec9fa51 parent b2939a736 files · +184 −166Browse files

Unified · Split

36 files

doc/optimization.txt +1 −1
libavcodec/arm/idct.h +7 −6
libavcodec/arm/idctdsp_arm.S +1 −1
libavcodec/arm/idctdsp_init_arm.c +10 −5
libavcodec/arm/idctdsp_init_armv6.c +1 −1
libavcodec/arm/simple_idct_armv6.S +2 −2
libavcodec/arm/simple_idct_neon.S +2 −2
libavcodec/arm/vc1dsp_init_neon.c +7 −7
libavcodec/arm/vc1dsp_neon.S +3 −3
libavcodec/dct.h +3 −2
libavcodec/dv.h +1 −1
libavcodec/dvdec.c +1 −1
libavcodec/faanidct.c +7 −3
libavcodec/faanidct.h +3 −2
libavcodec/idctdsp.c +5 −5
libavcodec/idctdsp.h +7 −7
libavcodec/jrevdct.c +2 −2
libavcodec/ppc/idctdsp.c +2 −2
libavcodec/ppc/vc1dsp_altivec.c +2 −1
libavcodec/simple_idct.c +6 −6
libavcodec/simple_idct.h +9 −8
libavcodec/simple_idct_template.c +4 −4
libavcodec/tests/dct.c +3 −2
libavcodec/vc1dsp.c +27 −27
libavcodec/vc1dsp.h +7 −7
libavcodec/wmv2dsp.c +2 −2
libavcodec/wmv2dsp.h +2 −2
libavcodec/x86/idctdsp.h +4 −3
libavcodec/x86/idctdsp_mmx.c +3 −3
libavcodec/x86/simple_idct.c +2 −2
libavcodec/x86/simple_idct.h +3 −2
libavcodec/x86/vc1dsp_mmx.c +30 −30
libavcodec/x86/xvididct.h +7 −6
libavcodec/x86/xvididct_mmx.c +4 −4
libavcodec/x86/xvididct_sse2.c +2 −2
libavcodec/xvididct.c +2 −2

@@ -142,7 +142,7 @@ Alignment: · 141 unmodified lines
142	142	Some instructions on some architectures have strict alignment restrictions,
143	143	for example most SSE/SSE2 instructions on x86.
144	144	The minimum guaranteed alignment is written in the .h files, for example:
145		− void (put_pixels_clamped)(const int16_t block/align 16/, UINT8 pixels/align 8*/, int line_size);
	145	+ void (put_pixels_clamped)(const int16_t block/align 16/, uint8_t pixels/align 8*/, ptrdiff_t stride);
146	146
147	147
148	148	General Tips:

libavcodec/arm/idct.h+7−6

@@ -19,6 +19,7 @@ · 18 unmodified lines
19	19	#ifndef AVCODEC_ARM_IDCT_H
20	20	#define AVCODEC_ARM_IDCT_H
21	21
	22	+#include <stddef.h>
22	23	#include <stdint.h>
23	24
24	25	void ff_j_rev_dct_arm(int16_t *data);
@@ -26,15 +27,15 @@ void ff_j_rev_dct_arm(int16_t *data); · 1 unmodified line
26	27	void ff_simple_idct_arm(int16_t *data);
27	28
28	29	void ff_simple_idct_armv5te(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_put_armv5te(uint8_t dest, ptrdiff_t line_size, int16_t data);
	31	+void ff_simple_idct_add_armv5te(uint8_t dest, ptrdiff_t line_size, int16_t data);
31	32
32	33	void ff_simple_idct_armv6(int16_t *data);
33		−void ff_simple_idct_put_armv6(uint8_t dest, int line_size, int16_t data);
34		−void ff_simple_idct_add_armv6(uint8_t dest, int line_size, int16_t data);
	34	+void ff_simple_idct_put_armv6(uint8_t dest, ptrdiff_t line_size, int16_t data);
	35	+void ff_simple_idct_add_armv6(uint8_t dest, ptrdiff_t line_size, int16_t data);
35	36
36	37	void ff_simple_idct_neon(int16_t *data);
37		−void ff_simple_idct_put_neon(uint8_t dest, int line_size, int16_t data);
38		−void ff_simple_idct_add_neon(uint8_t dest, int line_size, int16_t data);
	38	+void ff_simple_idct_put_neon(uint8_t dest, ptrdiff_t line_size, int16_t data);
	39	+void ff_simple_idct_add_neon(uint8_t dest, ptrdiff_t line_size, int16_t data);
39	40
40	41	#endif /* AVCODEC_ARM_IDCT_H */

libavcodec/arm/idctdsp_arm.S+1−1

@@ -22,7 +22,7 @@ · 21 unmodified lines
22	22	#include "config.h"
23	23	#include "libavutil/arm/asm.S"
24	24
25		−@ void ff_add_pixels_clamped_arm(int16_t block, uint8_t dest, int stride)
	25	+@ void ff_add_pixels_clamped_arm(int16_t block, uint8_t dest, ptrdiff_t stride)
26	26	function ff_add_pixels_clamped_arm, export=1, align=5
27	27	push {r4-r10}
28	28	mov r10, #8

libavcodec/arm/idctdsp_init_arm.c+10−5

@@ -19,6 +19,7 @@ · 18 unmodified lines
19	19	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20	20	*/
21	21
	22	+#include <stddef.h>
22	23	#include <stdint.h>
23	24
24	25	#include "libavutil/attributes.h"
@@ -30,29 +31,33 @@ · 5 unmodified lines
30	31	#include "idctdsp_arm.h"
31	32
32	33	void ff_add_pixels_clamped_arm(const int16_t block, uint8_t dest,
33		− int line_size);
	34	+ ptrdiff_t line_size);
34	35
35	36	/* XXX: those functions should be suppressed ASAP when all IDCTs are
36	37	* converted */
37		−static void j_rev_dct_arm_put(uint8_t dest, int line_size, int16_t block)
	38	+static void j_rev_dct_arm_put(uint8_t *dest, ptrdiff_t line_size,
	39	+ int16_t *block)
38	40	{
39	41	ff_j_rev_dct_arm(block);
40	42	ff_put_pixels_clamped(block, dest, line_size);
41	43	}
42	44
43		−static void j_rev_dct_arm_add(uint8_t dest, int line_size, int16_t block)
	45	+static void j_rev_dct_arm_add(uint8_t *dest, ptrdiff_t line_size,
	46	+ int16_t *block)
44	47	{
45	48	ff_j_rev_dct_arm(block);
46	49	ff_add_pixels_clamped(block, dest, line_size);
47	50	}
48	51
49		−static void simple_idct_arm_put(uint8_t dest, int line_size, int16_t block)
	52	+static void simple_idct_arm_put(uint8_t *dest, ptrdiff_t line_size,
	53	+ int16_t *block)
50	54	{
51	55	ff_simple_idct_arm(block);
52	56	ff_put_pixels_clamped(block, dest, line_size);
53	57	}
54	58
55		−static void simple_idct_arm_add(uint8_t dest, int line_size, int16_t block)
	59	+static void simple_idct_arm_add(uint8_t *dest, ptrdiff_t line_size,
	60	+ int16_t *block)
56	61	{
57	62	ff_simple_idct_arm(block);
58	63	ff_add_pixels_clamped(block, dest, line_size);

libavcodec/arm/idctdsp_init_armv6.c+1−1

@@ -27,7 +27,7 @@ · 26 unmodified lines
27	27	#include "idctdsp_arm.h"
28	28
29	29	void ff_add_pixels_clamped_armv6(const int16_t block, uint8_t pixels,
30		− int line_size);
	30	+ ptrdiff_t line_size);
31	31
32	32	av_cold void ff_idctdsp_init_armv6(IDCTDSPContext c, AVCodecContext avctx,
33	33	unsigned high_bit_depth)

libavcodec/arm/simple_idct_armv6.S+2−2

@@ -390,7 +390,7 @@ function ff_simple_idct_armv6, export=1 · 389 unmodified lines
390	390	pop {r4-r11, pc}
391	391	endfunc
392	392
393		−/* ff_simple_idct_add_armv6(uint8_t dest, int line_size, int16_t data); */
	393	+/* ff_simple_idct_add_armv6(uint8_t dest, ptrdiff_t line_size, int16_t data); */
394	394	function ff_simple_idct_add_armv6, export=1
395	395	push {r0, r1, r4-r11, lr}
396	396	sub sp, sp, #128
@@ -407,7 +407,7 @@ function ff_simple_idct_add_armv6, export=1 · 10 unmodified lines
407	407	pop {r4-r11, pc}
408	408	endfunc
409	409
410		−/* ff_simple_idct_put_armv6(uint8_t dest, int line_size, int16_t data); */
	410	+/* ff_simple_idct_put_armv6(uint8_t dest, ptrdiff_t line_size, int16_t data); */
411	411	function ff_simple_idct_put_armv6, export=1
412	412	push {r0, r1, r4-r11, lr}
413	413	sub sp, sp, #128

libavcodec/arm/simple_idct_neon.S+2−2

@@ -261,7 +261,7 @@ endconst · 260 unmodified lines
261	261	pop {r4-r7, pc}
262	262	.endm
263	263
264		−/* void ff_simple_idct_put_neon(uint8_t dst, int line_size, int16_t data); */
	264	+/* void ff_simple_idct_put_neon(uint8_t dst, ptrdiff_t line_size, int16_t data); */
265	265	function ff_simple_idct_put_neon, export=1
266	266	idct_start r2
267	267
@@ -316,7 +316,7 @@ function idct_col4_add8_neon · 48 unmodified lines
316	316	bx lr
317	317	endfunc
318	318
319		−/* void ff_simple_idct_add_neon(uint8_t dst, int line_size, int16_t data); */
	319	+/* void ff_simple_idct_add_neon(uint8_t dst, ptrdiff_t line_size, int16_t data); */
320	320	function ff_simple_idct_add_neon, export=1
321	321	idct_start r2
322	322

libavcodec/arm/vc1dsp_init_neon.c+7−7

@@ -25,14 +25,14 @@ · 24 unmodified lines
25	25	#include "config.h"
26	26
27	27	void ff_vc1_inv_trans_8x8_neon(int16_t *block);
28		−void ff_vc1_inv_trans_4x8_neon(uint8_t dest, int linesize, int16_t block);
29		−void ff_vc1_inv_trans_8x4_neon(uint8_t dest, int linesize, int16_t block);
30		−void ff_vc1_inv_trans_4x4_neon(uint8_t dest, int linesize, int16_t block);
	28	+void ff_vc1_inv_trans_4x8_neon(uint8_t dest, ptrdiff_t stride, int16_t block);
	29	+void ff_vc1_inv_trans_8x4_neon(uint8_t dest, ptrdiff_t stride, int16_t block);
	30	+void ff_vc1_inv_trans_4x4_neon(uint8_t dest, ptrdiff_t stride, int16_t block);
31	31
32		−void ff_vc1_inv_trans_8x8_dc_neon(uint8_t dest, int linesize, int16_t block);
33		−void ff_vc1_inv_trans_4x8_dc_neon(uint8_t dest, int linesize, int16_t block);
34		−void ff_vc1_inv_trans_8x4_dc_neon(uint8_t dest, int linesize, int16_t block);
35		−void ff_vc1_inv_trans_4x4_dc_neon(uint8_t dest, int linesize, int16_t block);
	32	+void ff_vc1_inv_trans_8x8_dc_neon(uint8_t dest, ptrdiff_t stride, int16_t block);
	33	+void ff_vc1_inv_trans_4x8_dc_neon(uint8_t dest, ptrdiff_t stride, int16_t block);
	34	+void ff_vc1_inv_trans_8x4_dc_neon(uint8_t dest, ptrdiff_t stride, int16_t block);
	35	+void ff_vc1_inv_trans_4x4_dc_neon(uint8_t dest, ptrdiff_t stride, int16_t block);
36	36
37	37	void ff_put_pixels8x8_neon(uint8_t block, const uint8_t pixels,
38	38	ptrdiff_t line_size, int rnd);

libavcodec/arm/vc1dsp_neon.S+3−3

@@ -426,7 +426,7 @@ function ff_vc1_inv_trans_8x8_neon, export=1 · 425 unmodified lines
426	426	bx lr
427	427	endfunc
428	428
429		−@ (uint8_t dest [r0], int linesize [r1], int16_t block [r2])
	429	+@ (uint8_t dest [r0], ptrdiff_t stride [r1], int16_t block [r2])
430	430	function ff_vc1_inv_trans_8x4_neon, export=1
431	431	vld1.64 {q0-q1}, [r2,:128]! @ load 8 * 4 * 2 = 64 bytes / 16 bytes per quad = 4 quad registers
432	432	vld1.64 {q2-q3}, [r2,:128]
@@ -511,7 +511,7 @@ function ff_vc1_inv_trans_8x4_neon, export=1 · 78 unmodified lines
511	511	bx lr
512	512	endfunc
513	513
514		−@ (uint8_t dest [r0], int linesize [r1], int16_t block [r2])
	514	+@ (uint8_t dest [r0], ptrdiff_t stride [r1], int16_t block [r2])
515	515	function ff_vc1_inv_trans_4x8_neon, export=1
516	516	mov r12, #(8 * 2) @ 8 elements per line, each element 2 bytes
517	517	vld4.16 {d0[], d2[], d4[], d6[]}, [r2,:64], r12 @ read each column into a q register
@@ -593,7 +593,7 @@ endfunc · 75 unmodified lines
593	593	vshr.s16 q1, q1, #\rshift @ dst[3,1] >>= rshift
594	594	.endm
595	595
596		−@ (uint8_t dest [r0], int linesize [r1], int16_t block [r2])
	596	+@ (uint8_t dest [r0], ptrdiff_t stride [r1], int16_t block [r2])
597	597	function ff_vc1_inv_trans_4x4_neon, export=1
598	598	mov r12, #(8 * 2) @ 8 elements per line, each element 2 bytes
599	599	vld4.16 {d0[], d1[], d2[], d3[]}, [r2,:64], r12 @ read each column into a register

libavcodec/dct.h+3−2

@@ -24,6 +24,7 @@ · 23 unmodified lines
24	24	#ifndef AVCODEC_DCT_H
25	25	#define AVCODEC_DCT_H
26	26
	27	+#include <stddef.h>
27	28	#include <stdint.h>
28	29
29	30	#include "rdft.h"
@@ -59,7 +60,7 @@ void ff_fdct248_islow_8(int16_t *data); · 29 unmodified lines
59	60	void ff_fdct248_islow_10(int16_t *data);
60	61
61	62	void ff_j_rev_dct(int16_t *data);
62		−void ff_jref_idct_put(uint8_t dest, int line_size, int16_t block);
63		−void ff_jref_idct_add(uint8_t dest, int line_size, int16_t block);
	63	+void ff_jref_idct_put(uint8_t dest, ptrdiff_t line_size, int16_t block);
	64	+void ff_jref_idct_add(uint8_t dest, ptrdiff_t line_size, int16_t block);
64	65
65	66	#endif /* AVCODEC_DCT_H */

libavcodec/dv.h+1−1

@@ -47,7 +47,7 @@ typedef struct DVVideoContext { · 46 unmodified lines
47	47
48	48	void (get_pixels)(int16_t block, const uint8_t *pixels, ptrdiff_t linesize);
49	49	void (fdct[2])(int16_t block);
50		− void (idct_put[2])(uint8_t dest, int line_size, int16_t *block);
	50	+ void (idct_put[2])(uint8_t dest, ptrdiff_t stride, int16_t *block);
51	51	me_cmp_func ildct_cmp;
52	52	DVwork_chunk work_chunks[4 * 12 * 27];
53	53	uint32_t idct_factor[2 * 4 * 16 * 64];

libavcodec/dvdec.c+1−1

@@ -52,7 +52,7 @@ typedef struct BlockInfo { · 51 unmodified lines
52	52	const uint32_t *factor_table;
53	53	const uint8_t *scan_table;
54	54	uint8_t pos; /* position in block */
55		− void (idct_put)(uint8_t dest, int line_size, int16_t *block);
	55	+ void (idct_put)(uint8_t dest, ptrdiff_t stride, int16_t *block);
56	56	uint8_t partial_bit_count;
57	57	uint32_t partial_bit_buffer;
58	58	int shift_offset;

libavcodec/faanidct.c+7−3

@@ -47,7 +47,9 @@ B6B0/8, B6B1/8, B6B2/8, B6B3/8, B6B4/8, B6B5/8, B6B6/8, B6B7/8, · 46 unmodified lines
47	47	B7B0/8, B7B1/8, B7B2/8, B7B3/8, B7B4/8, B7B5/8, B7B6/8, B7B7/8,
48	48	};
49	49
50		−static inline void p8idct(int16_t data[64], FLOAT temp[64], uint8_t *dest, int stride, int x, int y, int type){
	50	+static inline void p8idct(int16_t data[64], FLOAT temp[64], uint8_t *dest,
	51	+ ptrdiff_t stride, int x, int y, int type)
	52	+{
51	53	int i;
52	54	FLOAT s04, d04, s17, d17, s26, d26, s53, d53;
53	55	FLOAT os07, os16, os25, os34;
@@ -135,7 +137,8 @@ void ff_faanidct(int16_t block[64]){ · 81 unmodified lines
135	137	p8idct(block, temp, NULL, 0, 8, 1, 1);
136	138	}
137	139
138		−void ff_faanidct_add(uint8_t *dest, int line_size, int16_t block[64]){
	140	+void ff_faanidct_add(uint8_t *dest, ptrdiff_t line_size, int16_t block[64])
	141	+{
139	142	FLOAT temp[64];
140	143	int i;
141	144
@@ -148,7 +151,8 @@ void ff_faanidct_add(uint8_t *dest, int line_size, int16_t block[64]){ · 6 unmodified lines
148	151	p8idct(NULL , temp, dest, line_size, 8, 1, 2);
149	152	}
150	153
151		−void ff_faanidct_put(uint8_t *dest, int line_size, int16_t block[64]){
	154	+void ff_faanidct_put(uint8_t *dest, ptrdiff_t line_size, int16_t block[64])
	155	+{
152	156	FLOAT temp[64];
153	157	int i;
154	158

libavcodec/faanidct.h+3−2

@@ -22,10 +22,11 @@ · 21 unmodified lines
22	22	#ifndef AVCODEC_FAANIDCT_H
23	23	#define AVCODEC_FAANIDCT_H
24	24
	25	+#include <stddef.h>
25	26	#include <stdint.h>
26	27
27	28	void ff_faanidct(int16_t block[64]);
28		−void ff_faanidct_add(uint8_t *dest, int line_size, int16_t block[64]);
29		−void ff_faanidct_put(uint8_t *dest, int line_size, int16_t block[64]);
	29	+void ff_faanidct_add(uint8_t *dest, ptrdiff_t line_size, int16_t block[64]);
	30	+void ff_faanidct_put(uint8_t *dest, ptrdiff_t line_size, int16_t block[64]);
30	31
31	32	#endif /* AVCODEC_FAANIDCT_H */

libavcodec/idctdsp.c+5−5

@@ -79,11 +79,11 @@ av_cold void ff_init_scantable_permutation(uint8_t *idct_permutation, · 78 unmodified lines
79	79	}
80	80	}
81	81
82		−void (ff_put_pixels_clamped)(const int16_t block, uint8_t *pixels, int line_size);
83		−void (ff_add_pixels_clamped)(const int16_t block, uint8_t *pixels, int line_size);
	82	+void (ff_put_pixels_clamped)(const int16_t block, uint8_t *pixels, ptrdiff_t line_size);
	83	+void (ff_add_pixels_clamped)(const int16_t block, uint8_t *pixels, ptrdiff_t line_size);
84	84
85	85	static void put_pixels_clamped_c(const int16_t block, uint8_t restrict pixels,
86		− int line_size)
	86	+ ptrdiff_t line_size)
87	87	{
88	88	int i;
89	89
@@ -105,7 +105,7 @@ static void put_pixels_clamped_c(const int16_t block, uint8_t restrict pixels, · 15 unmodified lines
105	105
106	106	static void put_signed_pixels_clamped_c(const int16_t *block,
107	107	uint8_t *restrict pixels,
108		− int line_size)
	108	+ ptrdiff_t line_size)
109	109	{
110	110	int i, j;
111	111
@@ -125,7 +125,7 @@ static void put_signed_pixels_clamped_c(const int16_t *block, · 13 unmodified lines
125	125	}
126	126
127	127	static void add_pixels_clamped_c(const int16_t block, uint8_t restrict pixels,
128		− int line_size)
	128	+ ptrdiff_t line_size)
129	129	{
130	130	int i;
131	131

libavcodec/idctdsp.h+7−7

@@ -52,13 +52,13 @@ typedef struct IDCTDSPContext { · 51 unmodified lines
52	52	/* pixel ops : interface with DCT */
53	53	void (put_pixels_clamped)(const int16_t block /* align 16 */,
54	54	uint8_t pixels / align 8 */,
55		− int line_size);
	55	+ ptrdiff_t line_size);
56	56	void (put_signed_pixels_clamped)(const int16_t block /* align 16 */,
57	57	uint8_t pixels / align 8 */,
58		− int line_size);
	58	+ ptrdiff_t line_size);
59	59	void (add_pixels_clamped)(const int16_t block /* align 16 */,
60	60	uint8_t pixels / align 8 */,
61		− int line_size);
	61	+ ptrdiff_t line_size);
62	62
63	63	void (idct)(int16_t block /* align 16 */);
64	64
@@ -68,14 +68,14 @@ typedef struct IDCTDSPContext { · 3 unmodified lines
68	68	* @param line_size size in bytes of a horizontal line of dest
69	69	*/
70	70	void (idct_put)(uint8_t dest /* align 8 */,
71		− int line_size, int16_t block / align 16 */);
	71	+ ptrdiff_t line_size, int16_t block / align 16 */);
72	72
73	73	/**
74	74	* block -> idct -> add dest -> clip to unsigned 8 bit -> dest.
75	75	* @param line_size size in bytes of a horizontal line of dest
76	76	*/
77	77	void (idct_add)(uint8_t dest /* align 8 */,
78		− int line_size, int16_t block / align 16 */);
	78	+ ptrdiff_t line_size, int16_t block / align 16 */);
79	79
80	80	/**
81	81	* IDCT input permutation.
@@ -95,8 +95,8 @@ typedef struct IDCTDSPContext { · 13 unmodified lines
95	95	enum idct_permutation_type perm_type;
96	96	} IDCTDSPContext;
97	97
98		−extern void (ff_put_pixels_clamped)(const int16_t block, uint8_t *pixels, int line_size);
99		−extern void (ff_add_pixels_clamped)(const int16_t block, uint8_t *pixels, int line_size);
	98	+extern void (ff_put_pixels_clamped)(const int16_t block, uint8_t *pixels, ptrdiff_t line_size);
	99	+extern void (ff_add_pixels_clamped)(const int16_t block, uint8_t *pixels, ptrdiff_t line_size);
100	100
101	101	void ff_idctdsp_init(IDCTDSPContext c, AVCodecContext avctx);
102	102

libavcodec/jrevdct.c+2−2

@@ -943,13 +943,13 @@ void ff_j_rev_dct(DCTBLOCK data) · 942 unmodified lines
943	943	}
944	944	}
945	945
946		−void ff_jref_idct_put(uint8_t dest, int line_size, int16_t block)
	946	+void ff_jref_idct_put(uint8_t dest, ptrdiff_t line_size, int16_t block)
947	947	{
948	948	ff_j_rev_dct(block);
949	949	ff_put_pixels_clamped(block, dest, line_size);
950	950	}
951	951
952		−void ff_jref_idct_add(uint8_t dest, int line_size, int16_t block)
	952	+void ff_jref_idct_add(uint8_t dest, ptrdiff_t line_size, int16_t block)
953	953	{
954	954	ff_j_rev_dct(block);
955	955	ff_add_pixels_clamped(block, dest, line_size);

libavcodec/ppc/idctdsp.c+2−2

@@ -153,7 +153,7 @@ static const vec_s16 constants[5] = { · 152 unmodified lines
153	153	{ 19266, 26722, 25172, 22654, 19266, 22654, 25172, 26722 }
154	154	};
155	155
156		−static void idct_put_altivec(uint8_t dest, int stride, int16_t blk)
	156	+static void idct_put_altivec(uint8_t dest, ptrdiff_t stride, int16_t blk)
157	157	{
158	158	vec_s16 block = (vec_s16 ) blk;
159	159	vec_u8 tmp;
@@ -182,7 +182,7 @@ static void idct_put_altivec(uint8_t dest, int stride, int16_t blk) · 22 unmodified lines
182	182	COPY(dest, vx7);
183	183	}
184	184
185		−static void idct_add_altivec(uint8_t dest, int stride, int16_t blk)
	185	+static void idct_add_altivec(uint8_t dest, ptrdiff_t stride, int16_t blk)
186	186	{
187	187	vec_s16 block = (vec_s16 ) blk;
188	188	vec_u8 tmp;

libavcodec/ppc/vc1dsp_altivec.c+2−1

@@ -229,7 +229,8 @@ static void vc1_inv_trans_8x8_altivec(int16_t block[64]) · 228 unmodified lines
229	229
230	230	/** Do inverse transform on 8x4 part of block
231	231	*/
232		−static void vc1_inv_trans_8x4_altivec(uint8_t dest, int stride, int16_t block)
	232	+static void vc1_inv_trans_8x4_altivec(uint8_t *dest, ptrdiff_t stride,
	233	+ int16_t *block)
233	234	{
234	235	vector signed short src0, src1, src2, src3, src4, src5, src6, src7;
235	236	vector signed int s0, s1, s2, s3, s4, s5, s6, s7;

libavcodec/simple_idct.c+6−6

@@ -49,7 +49,7 @@ · 48 unmodified lines
49	49	and the butterfly must be multiplied by 0.5 * sqrt(2.0) */
50	50	#define C_SHIFT (4+1+12)
51	51
52		−static inline void idct4col_put(uint8_t dest, int line_size, const int16_t col)
	52	+static inline void idct4col_put(uint8_t dest, ptrdiff_t line_size, const int16_t col)
53	53	{
54	54	int c0, c1, c2, c3, a0, a1, a2, a3;
55	55
@@ -85,7 +85,7 @@ static inline void idct4col_put(uint8_t dest, int line_size, const int16_t col · 29 unmodified lines
85	85	/* XXX: I think a 1.0/sqrt(2) normalization should be needed to
86	86	compensate the extra butterfly stage - I don't have the full DV
87	87	specification */
88		−void ff_simple_idct248_put(uint8_t dest, int line_size, int16_t block)
	88	+void ff_simple_idct248_put(uint8_t dest, ptrdiff_t line_size, int16_t block)
89	89	{
90	90	int i;
91	91	int16_t *ptr;
@@ -128,7 +128,7 @@ void ff_simple_idct248_put(uint8_t dest, int line_size, int16_t block) · 36 unmodified lines
128	128	#define C2 C_FIX(0.2705980501)
129	129	#define C3 C_FIX(0.5)
130	130	#define C_SHIFT (4+1+12)
131		−static inline void idct4col_add(uint8_t dest, int line_size, const int16_t col)
	131	+static inline void idct4col_add(uint8_t dest, ptrdiff_t line_size, const int16_t col)
132	132	{
133	133	int c0, c1, c2, c3, a0, a1, a2, a3;
134	134
@@ -173,7 +173,7 @@ static inline void idct4row(int16_t *row) · 38 unmodified lines
173	173	row[3]= (c0 - c1) >> R_SHIFT;
174	174	}
175	175
176		−void ff_simple_idct84_add(uint8_t dest, int line_size, int16_t block)
	176	+void ff_simple_idct84_add(uint8_t dest, ptrdiff_t line_size, int16_t block)
177	177	{
178	178	int i;
179	179
@@ -188,7 +188,7 @@ void ff_simple_idct84_add(uint8_t dest, int line_size, int16_t block) · 8 unmodified lines
188	188	}
189	189	}
190	190
191		−void ff_simple_idct48_add(uint8_t dest, int line_size, int16_t block)
	191	+void ff_simple_idct48_add(uint8_t dest, ptrdiff_t line_size, int16_t block)
192	192	{
193	193	int i;
194	194
@@ -203,7 +203,7 @@ void ff_simple_idct48_add(uint8_t dest, int line_size, int16_t block) · 8 unmodified lines
203	203	}
204	204	}
205	205
206		−void ff_simple_idct44_add(uint8_t dest, int line_size, int16_t block)
	206	+void ff_simple_idct44_add(uint8_t dest, ptrdiff_t line_size, int16_t block)
207	207	{
208	208	int i;
209	209

libavcodec/simple_idct.h+9−8

@@ -28,14 +28,15 @@ · 27 unmodified lines
28	28	#ifndef AVCODEC_SIMPLE_IDCT_H
29	29	#define AVCODEC_SIMPLE_IDCT_H
30	30
	31	+#include <stddef.h>
31	32	#include <stdint.h>
32	33
33		−void ff_simple_idct_put_8(uint8_t dest, int line_size, int16_t block);
34		−void ff_simple_idct_add_8(uint8_t dest, int line_size, int16_t block);
	34	+void ff_simple_idct_put_8(uint8_t dest, ptrdiff_t line_size, int16_t block);
	35	+void ff_simple_idct_add_8(uint8_t dest, ptrdiff_t line_size, int16_t block);
35	36	void ff_simple_idct_8(int16_t *block);
36	37
37		−void ff_simple_idct_put_10(uint8_t dest, int line_size, int16_t block);
38		−void ff_simple_idct_add_10(uint8_t dest, int line_size, int16_t block);
	38	+void ff_simple_idct_put_10(uint8_t dest, ptrdiff_t line_size, int16_t block);
	39	+void ff_simple_idct_add_10(uint8_t dest, ptrdiff_t line_size, int16_t block);
39	40	void ff_simple_idct_10(int16_t *block);
40	41	/**
41	42	* Special version of ff_simple_idct_10() which does dequantization
@@ -44,10 +45,10 @@ void ff_simple_idct_10(int16_t *block); · 2 unmodified lines
44	45	*/
45	46	void ff_prores_idct(int16_t block, const int16_t qmat);
46	47
47		−void ff_simple_idct248_put(uint8_t dest, int line_size, int16_t block);
	48	+void ff_simple_idct248_put(uint8_t dest, ptrdiff_t line_size, int16_t block);
48	49
49		−void ff_simple_idct84_add(uint8_t dest, int line_size, int16_t block);
50		−void ff_simple_idct48_add(uint8_t dest, int line_size, int16_t block);
51		−void ff_simple_idct44_add(uint8_t dest, int line_size, int16_t block);
	50	+void ff_simple_idct84_add(uint8_t dest, ptrdiff_t line_size, int16_t block);
	51	+void ff_simple_idct48_add(uint8_t dest, ptrdiff_t line_size, int16_t block);
	52	+void ff_simple_idct44_add(uint8_t dest, ptrdiff_t line_size, int16_t block);
52	53
53	54	#endif /* AVCODEC_SIMPLE_IDCT_H */

libavcodec/simple_idct_template.c+4−4

@@ -222,7 +222,7 @@ static inline void FUNC(idctRowCondDC)(int16_t *row, int extra_shift) · 221 unmodified lines
222	222	} \
223	223	} while (0)
224	224
225		−static inline void FUNC(idctSparseColPut)(pixel *dest, int line_size,
	225	+static inline void FUNC(idctSparseColPut)(pixel *dest, ptrdiff_t line_size,
226	226	int16_t *col)
227	227	{
228	228	int a0, a1, a2, a3, b0, b1, b2, b3;
@@ -246,7 +246,7 @@ static inline void FUNC(idctSparseColPut)(pixel *dest, int line_size, · 17 unmodified lines
246	246	dest[0] = av_clip_pixel((a0 - b0) >> COL_SHIFT);
247	247	}
248	248
249		−static inline void FUNC(idctSparseColAdd)(pixel *dest, int line_size,
	249	+static inline void FUNC(idctSparseColAdd)(pixel *dest, ptrdiff_t line_size,
250	250	int16_t *col)
251	251	{
252	252	int a0, a1, a2, a3, b0, b1, b2, b3;
@@ -286,7 +286,7 @@ static inline void FUNC(idctSparseCol)(int16_t *col) · 33 unmodified lines
286	286	col[56] = ((a0 - b0) >> COL_SHIFT);
287	287	}
288	288
289		−void FUNC(ff_simple_idct_put)(uint8_t dest_, int line_size, int16_t block)
	289	+void FUNC(ff_simple_idct_put)(uint8_t dest_, ptrdiff_t line_size, int16_t block)
290	290	{
291	291	pixel dest = (pixel )dest_;
292	292	int i;
@@ -300,7 +300,7 @@ void FUNC(ff_simple_idct_put)(uint8_t dest_, int line_size, int16_t block) · 7 unmodified lines
300	300	FUNC(idctSparseColPut)(dest + i, line_size, block + i);
301	301	}
302	302
303		−void FUNC(ff_simple_idct_add)(uint8_t dest_, int line_size, int16_t block)
	303	+void FUNC(ff_simple_idct_add)(uint8_t dest_, ptrdiff_t line_size, int16_t block)
304	304	{
305	305	pixel dest = (pixel )dest_;
306	306	int i;

libavcodec/tests/dct.c+3−2

@@ -253,7 +253,7 @@ static int dct_error(const struct algo *dct, int test, int is_idct, int speed) · 252 unmodified lines
253	253	DECLARE_ALIGNED(8, static uint8_t, img_dest)[64];
254	254	DECLARE_ALIGNED(8, static uint8_t, img_dest1)[64];
255	255
256		−static void idct248_ref(uint8_t dest, int linesize, int16_t block)
	256	+static void idct248_ref(uint8_t dest, ptrdiff_t linesize, int16_t block)
257	257	{
258	258	static int init;
259	259	static double c8[8][8];
@@ -334,7 +334,8 @@ static void idct248_ref(uint8_t dest, int linesize, int16_t block) · 74 unmodified lines
334	334	}
335	335
336	336	static void idct248_error(const char *name,
337		− void (idct248_put)(uint8_t dest, int line_size,
	337	+ void (idct248_put)(uint8_t dest,
	338	+ ptrdiff_t line_size,
338	339	int16_t *block),
339	340	int speed)
340	341	{

libavcodec/vc1dsp.c+27−27

@@ -235,7 +235,7 @@ static void vc1_h_loop_filter16_c(uint8_t *src, int stride, int pq) · 234 unmodified lines
235	235	}
236	236
237	237	/* Do inverse transform on 8x8 block */
238		−static void vc1_inv_trans_8x8_dc_c(uint8_t dest, int linesize, int16_t block)
	238	+static void vc1_inv_trans_8x8_dc_c(uint8_t dest, ptrdiff_t stride, int16_t block)
239	239	{
240	240	int i;
241	241	int dc = block[0];
@@ -252,7 +252,7 @@ static void vc1_inv_trans_8x8_dc_c(uint8_t dest, int linesize, int16_t block) · 10 unmodified lines
252	252	dest[5] = av_clip_uint8(dest[5] + dc);
253	253	dest[6] = av_clip_uint8(dest[6] + dc);
254	254	dest[7] = av_clip_uint8(dest[7] + dc);
255		− dest += linesize;
	255	+ dest += stride;
256	256	}
257	257	}
258	258
@@ -326,7 +326,7 @@ static void vc1_inv_trans_8x8_c(int16_t block[64]) · 67 unmodified lines
326	326	}
327	327
328	328	/* Do inverse transform on 8x4 part of block */
329		−static void vc1_inv_trans_8x4_dc_c(uint8_t dest, int linesize, int16_t block)
	329	+static void vc1_inv_trans_8x4_dc_c(uint8_t dest, ptrdiff_t stride, int16_t block)
330	330	{
331	331	int i;
332	332	int dc = block[0];
@@ -343,11 +343,11 @@ static void vc1_inv_trans_8x4_dc_c(uint8_t dest, int linesize, int16_t block) · 10 unmodified lines
343	343	dest[5] = av_clip_uint8(dest[5] + dc);
344	344	dest[6] = av_clip_uint8(dest[6] + dc);
345	345	dest[7] = av_clip_uint8(dest[7] + dc);
346		− dest += linesize;
	346	+ dest += stride;
347	347	}
348	348	}
349	349
350		−static void vc1_inv_trans_8x4_c(uint8_t dest, int linesize, int16_t block)
	350	+static void vc1_inv_trans_8x4_c(uint8_t dest, ptrdiff_t stride, int16_t block)
351	351	{
352	352	int i;
353	353	register int t1, t2, t3, t4, t5, t6, t7, t8;
@@ -392,10 +392,10 @@ static void vc1_inv_trans_8x4_c(uint8_t dest, int linesize, int16_t block) · 38 unmodified lines
392	392	t3 = 22 * src[ 8] + 10 * src[24];
393	393	t4 = 22 * src[24] - 10 * src[ 8];
394	394
395		− dest[0 * linesize] = av_clip_uint8(dest[0 * linesize] + ((t1 + t3) >> 7));
396		− dest[1 * linesize] = av_clip_uint8(dest[1 * linesize] + ((t2 - t4) >> 7));
397		− dest[2 * linesize] = av_clip_uint8(dest[2 * linesize] + ((t2 + t4) >> 7));
398		− dest[3 * linesize] = av_clip_uint8(dest[3 * linesize] + ((t1 - t3) >> 7));
	395	+ dest[0 * stride] = av_clip_uint8(dest[0 * stride] + ((t1 + t3) >> 7));
	396	+ dest[1 * stride] = av_clip_uint8(dest[1 * stride] + ((t2 - t4) >> 7));
	397	+ dest[2 * stride] = av_clip_uint8(dest[2 * stride] + ((t2 + t4) >> 7));
	398	+ dest[3 * stride] = av_clip_uint8(dest[3 * stride] + ((t1 - t3) >> 7));
399	399
400	400	src++;
401	401	dest++;
@@ -403,7 +403,7 @@ static void vc1_inv_trans_8x4_c(uint8_t dest, int linesize, int16_t block) · 1 unmodified line
403	403	}
404	404
405	405	/* Do inverse transform on 4x8 parts of block */
406		−static void vc1_inv_trans_4x8_dc_c(uint8_t dest, int linesize, int16_t block)
	406	+static void vc1_inv_trans_4x8_dc_c(uint8_t dest, ptrdiff_t stride, int16_t block)
407	407	{
408	408	int i;
409	409	int dc = block[0];
@@ -416,11 +416,11 @@ static void vc1_inv_trans_4x8_dc_c(uint8_t dest, int linesize, int16_t block) · 6 unmodified lines
416	416	dest[1] = av_clip_uint8(dest[1] + dc);
417	417	dest[2] = av_clip_uint8(dest[2] + dc);
418	418	dest[3] = av_clip_uint8(dest[3] + dc);
419		− dest += linesize;
	419	+ dest += stride;
420	420	}
421	421	}
422	422
423		−static void vc1_inv_trans_4x8_c(uint8_t dest, int linesize, int16_t block)
	423	+static void vc1_inv_trans_4x8_c(uint8_t dest, ptrdiff_t stride, int16_t block)
424	424	{
425	425	int i;
426	426	register int t1, t2, t3, t4, t5, t6, t7, t8;
@@ -461,14 +461,14 @@ static void vc1_inv_trans_4x8_c(uint8_t dest, int linesize, int16_t block) · 34 unmodified lines
461	461	t3 = 9 * src[ 8] - 16 * src[24] + 4 * src[40] + 15 * src[56];
462	462	t4 = 4 * src[ 8] - 9 * src[24] + 15 * src[40] - 16 * src[56];
463	463
464		− dest[0 * linesize] = av_clip_uint8(dest[0 * linesize] + ((t5 + t1) >> 7));
465		− dest[1 * linesize] = av_clip_uint8(dest[1 * linesize] + ((t6 + t2) >> 7));
466		− dest[2 * linesize] = av_clip_uint8(dest[2 * linesize] + ((t7 + t3) >> 7));
467		− dest[3 * linesize] = av_clip_uint8(dest[3 * linesize] + ((t8 + t4) >> 7));
468		− dest[4 * linesize] = av_clip_uint8(dest[4 * linesize] + ((t8 - t4 + 1) >> 7));
469		− dest[5 * linesize] = av_clip_uint8(dest[5 * linesize] + ((t7 - t3 + 1) >> 7));
470		− dest[6 * linesize] = av_clip_uint8(dest[6 * linesize] + ((t6 - t2 + 1) >> 7));
471		− dest[7 * linesize] = av_clip_uint8(dest[7 * linesize] + ((t5 - t1 + 1) >> 7));
	464	+ dest[0 * stride] = av_clip_uint8(dest[0 * stride] + ((t5 + t1) >> 7));
	465	+ dest[1 * stride] = av_clip_uint8(dest[1 * stride] + ((t6 + t2) >> 7));
	466	+ dest[2 * stride] = av_clip_uint8(dest[2 * stride] + ((t7 + t3) >> 7));
	467	+ dest[3 * stride] = av_clip_uint8(dest[3 * stride] + ((t8 + t4) >> 7));
	468	+ dest[4 * stride] = av_clip_uint8(dest[4 * stride] + ((t8 - t4 + 1) >> 7));
	469	+ dest[5 * stride] = av_clip_uint8(dest[5 * stride] + ((t7 - t3 + 1) >> 7));
	470	+ dest[6 * stride] = av_clip_uint8(dest[6 * stride] + ((t6 - t2 + 1) >> 7));
	471	+ dest[7 * stride] = av_clip_uint8(dest[7 * stride] + ((t5 - t1 + 1) >> 7));
472	472
473	473	src++;
474	474	dest++;
@@ -476,7 +476,7 @@ static void vc1_inv_trans_4x8_c(uint8_t dest, int linesize, int16_t block) · 1 unmodified line
476	476	}
477	477
478	478	/* Do inverse transform on 4x4 part of block */
479		−static void vc1_inv_trans_4x4_dc_c(uint8_t dest, int linesize, int16_t block)
	479	+static void vc1_inv_trans_4x4_dc_c(uint8_t dest, ptrdiff_t stride, int16_t block)
480	480	{
481	481	int i;
482	482	int dc = block[0];
@@ -489,11 +489,11 @@ static void vc1_inv_trans_4x4_dc_c(uint8_t dest, int linesize, int16_t block) · 6 unmodified lines
489	489	dest[1] = av_clip_uint8(dest[1] + dc);
490	490	dest[2] = av_clip_uint8(dest[2] + dc);
491	491	dest[3] = av_clip_uint8(dest[3] + dc);
492		− dest += linesize;
	492	+ dest += stride;
493	493	}
494	494	}
495	495
496		−static void vc1_inv_trans_4x4_c(uint8_t dest, int linesize, int16_t block)
	496	+static void vc1_inv_trans_4x4_c(uint8_t dest, ptrdiff_t stride, int16_t block)
497	497	{
498	498	int i;
499	499	register int t1, t2, t3, t4;
@@ -523,10 +523,10 @@ static void vc1_inv_trans_4x4_c(uint8_t dest, int linesize, int16_t block) · 23 unmodified lines
523	523	t3 = 22 * src[8] + 10 * src[24];
524	524	t4 = 22 * src[24] - 10 * src[8];
525	525
526		− dest[0 * linesize] = av_clip_uint8(dest[0 * linesize] + ((t1 + t3) >> 7));
527		− dest[1 * linesize] = av_clip_uint8(dest[1 * linesize] + ((t2 - t4) >> 7));
528		− dest[2 * linesize] = av_clip_uint8(dest[2 * linesize] + ((t2 + t4) >> 7));
529		− dest[3 * linesize] = av_clip_uint8(dest[3 * linesize] + ((t1 - t3) >> 7));
	526	+ dest[0 * stride] = av_clip_uint8(dest[0 * stride] + ((t1 + t3) >> 7));
	527	+ dest[1 * stride] = av_clip_uint8(dest[1 * stride] + ((t2 - t4) >> 7));
	528	+ dest[2 * stride] = av_clip_uint8(dest[2 * stride] + ((t2 + t4) >> 7));
	529	+ dest[3 * stride] = av_clip_uint8(dest[3 * stride] + ((t1 - t3) >> 7));
530	530
531	531	src++;
532	532	dest++;

libavcodec/vc1dsp.h+7−7

@@ -33,13 +33,13 @@ · 32 unmodified lines
33	33	typedef struct VC1DSPContext {
34	34	/* vc1 functions */
35	35	void (vc1_inv_trans_8x8)(int16_t b);
36		− void (vc1_inv_trans_8x4)(uint8_t dest, int line_size, int16_t *block);
37		− void (vc1_inv_trans_4x8)(uint8_t dest, int line_size, int16_t *block);
38		− void (vc1_inv_trans_4x4)(uint8_t dest, int line_size, int16_t *block);
39		− void (vc1_inv_trans_8x8_dc)(uint8_t dest, int line_size, int16_t *block);
40		− void (vc1_inv_trans_8x4_dc)(uint8_t dest, int line_size, int16_t *block);
41		− void (vc1_inv_trans_4x8_dc)(uint8_t dest, int line_size, int16_t *block);
42		− void (vc1_inv_trans_4x4_dc)(uint8_t dest, int line_size, int16_t *block);
	36	+ void (vc1_inv_trans_8x4)(uint8_t dest, ptrdiff_t stride, int16_t *block);
	37	+ void (vc1_inv_trans_4x8)(uint8_t dest, ptrdiff_t stride, int16_t *block);
	38	+ void (vc1_inv_trans_4x4)(uint8_t dest, ptrdiff_t stride, int16_t *block);
	39	+ void (vc1_inv_trans_8x8_dc)(uint8_t dest, ptrdiff_t stride, int16_t *block);
	40	+ void (vc1_inv_trans_8x4_dc)(uint8_t dest, ptrdiff_t stride, int16_t *block);
	41	+ void (vc1_inv_trans_4x8_dc)(uint8_t dest, ptrdiff_t stride, int16_t *block);
	42	+ void (vc1_inv_trans_4x4_dc)(uint8_t dest, ptrdiff_t stride, int16_t *block);
43	43	void (vc1_v_overlap)(uint8_t src, int stride);
44	44	void (vc1_h_overlap)(uint8_t src, int stride);
45	45	void (vc1_v_s_overlap)(int16_t top, int16_t *bottom);

libavcodec/wmv2dsp.c+2−2

@@ -93,7 +93,7 @@ static void wmv2_idct_col(short * b) · 92 unmodified lines
93	93	b[8 * 7] = (a0 + a2 - a1 - a5 + (1 << 13)) >> 14;
94	94	}
95	95
96		−static void wmv2_idct_add_c(uint8_t dest, int line_size, int16_t block)
	96	+static void wmv2_idct_add_c(uint8_t dest, ptrdiff_t line_size, int16_t block)
97	97	{
98	98	int i;
99	99
@@ -116,7 +116,7 @@ static void wmv2_idct_add_c(uint8_t dest, int line_size, int16_t block) · 16 unmodified lines
116	116	}
117	117	}
118	118
119		−static void wmv2_idct_put_c(uint8_t dest, int line_size, int16_t block)
	119	+static void wmv2_idct_put_c(uint8_t dest, ptrdiff_t line_size, int16_t block)
120	120	{
121	121	int i;
122	122

libavcodec/wmv2dsp.h+2−2

@@ -24,8 +24,8 @@ · 23 unmodified lines
24	24	#include "qpeldsp.h"
25	25
26	26	typedef struct WMV2DSPContext {
27		− void (idct_add)(uint8_t dest, int line_size, int16_t *block);
28		− void (idct_put)(uint8_t dest, int line_size, int16_t *block);
	27	+ void (idct_add)(uint8_t dest, ptrdiff_t line_size, int16_t *block);
	28	+ void (idct_put)(uint8_t dest, ptrdiff_t line_size, int16_t *block);
29	29
30	30	qpel_mc_func put_mspel_pixels_tab[8];
31	31

libavcodec/x86/idctdsp.h+4−3

@@ -19,13 +19,14 @@ · 18 unmodified lines
19	19	#ifndef AVCODEC_X86_IDCTDSP_H
20	20	#define AVCODEC_X86_IDCTDSP_H
21	21
	22	+#include <stddef.h>
22	23	#include <stdint.h>
23	24
24	25	void ff_add_pixels_clamped_mmx(const int16_t block, uint8_t pixels,
25		− int line_size);
	26	+ ptrdiff_t line_size);
26	27	void ff_put_pixels_clamped_mmx(const int16_t block, uint8_t pixels,
27		− int line_size);
	28	+ ptrdiff_t line_size);
28	29	void ff_put_signed_pixels_clamped_mmx(const int16_t block, uint8_t pixels,
29		− int line_size);
	30	+ ptrdiff_t line_size);
30	31
31	32	#endif /* AVCODEC_X86_IDCTDSP_H */

libavcodec/x86/idctdsp_mmx.c+3−3

@@ -31,7 +31,7 @@ · 30 unmodified lines
31	31	#if HAVE_INLINE_ASM
32	32
33	33	void ff_put_pixels_clamped_mmx(const int16_t block, uint8_t pixels,
34		− int line_size)
	34	+ ptrdiff_t line_size)
35	35	{
36	36	const int16_t *p;
37	37	uint8_t *pix;
@@ -107,7 +107,7 @@ void ff_put_pixels_clamped_mmx(const int16_t block, uint8_t pixels, · 69 unmodified lines
107	107	"movq %%mm4, (%0, %1) \n\t"
108	108
109	109	void ff_put_signed_pixels_clamped_mmx(const int16_t block, uint8_t pixels,
110		− int line_size)
	110	+ ptrdiff_t line_size)
111	111	{
112	112	x86_reg line_skip = line_size;
113	113	x86_reg line_skip3;
@@ -124,7 +124,7 @@ void ff_put_signed_pixels_clamped_mmx(const int16_t block, uint8_t pixels, · 10 unmodified lines
124	124	}
125	125
126	126	void ff_add_pixels_clamped_mmx(const int16_t block, uint8_t pixels,
127		− int line_size)
	127	+ ptrdiff_t line_size)
128	128	{
129	129	const int16_t *p;
130	130	uint8_t *pix;

libavcodec/x86/simple_idct.c+2−2

@@ -904,12 +904,12 @@ void ff_simple_idct_mmx(int16_t *block) · 903 unmodified lines
904	904
905	905	//FIXME merge add/put into the idct
906	906
907		−void ff_simple_idct_put_mmx(uint8_t dest, int line_size, int16_t block)
	907	+void ff_simple_idct_put_mmx(uint8_t dest, ptrdiff_t line_size, int16_t block)
908	908	{
909	909	idct(block);
910	910	ff_put_pixels_clamped(block, dest, line_size);
911	911	}
912		−void ff_simple_idct_add_mmx(uint8_t dest, int line_size, int16_t block)
	912	+void ff_simple_idct_add_mmx(uint8_t dest, ptrdiff_t line_size, int16_t block)
913	913	{
914	914	idct(block);
915	915	ff_add_pixels_clamped(block, dest, line_size);

libavcodec/x86/simple_idct.h+3−2

@@ -19,10 +19,11 @@ · 18 unmodified lines
19	19	#ifndef AVCODEC_X86_SIMPLE_IDCT_H
20	20	#define AVCODEC_X86_SIMPLE_IDCT_H
21	21
	22	+#include <stddef.h>
22	23	#include <stdint.h>
23	24
24	25	void ff_simple_idct_mmx(int16_t *block);
25		−void ff_simple_idct_add_mmx(uint8_t dest, int line_size, int16_t block);
26		−void ff_simple_idct_put_mmx(uint8_t dest, int line_size, int16_t block);
	26	+void ff_simple_idct_add_mmx(uint8_t dest, ptrdiff_t line_size, int16_t block);
	27	+void ff_simple_idct_put_mmx(uint8_t dest, ptrdiff_t line_size, int16_t block);
27	28
28	29	#endif /* AVCODEC_X86_SIMPLE_IDCT_H */

libavcodec/x86/vc1dsp_mmx.c+30−30

@@ -498,7 +498,7 @@ DECLARE_FUNCTION(3, 1) · 497 unmodified lines
498	498	DECLARE_FUNCTION(3, 2)
499	499	DECLARE_FUNCTION(3, 3)
500	500
501		−static void vc1_inv_trans_4x4_dc_mmxext(uint8_t *dest, int linesize,
	501	+static void vc1_inv_trans_4x4_dc_mmxext(uint8_t *dest, ptrdiff_t stride,
502	502	int16_t *block)
503	503	{
504	504	int dc = block[0];
@@ -530,14 +530,14 @@ static void vc1_inv_trans_4x4_dc_mmxext(uint8_t *dest, int linesize, · 25 unmodified lines
530	530	"movd %%mm3, %1 \n\t"
531	531	"movd %%mm4, %2 \n\t"
532	532	"movd %%mm5, %3 \n\t"
533		− :"+m"((uint32_t)(dest+0*linesize)),
534		− "+m"((uint32_t)(dest+1*linesize)),
535		− "+m"((uint32_t)(dest+2*linesize)),
536		− "+m"((uint32_t)(dest+3*linesize))
	533	+ :"+m"((uint32_t )(dest + 0 * stride)),
	534	+ "+m"((uint32_t )(dest + 1 * stride)),
	535	+ "+m"((uint32_t )(dest + 2 * stride)),
	536	+ "+m"((uint32_t )(dest + 3 * stride))
537	537	);
538	538	}
539	539
540		−static void vc1_inv_trans_4x8_dc_mmxext(uint8_t *dest, int linesize,
	540	+static void vc1_inv_trans_4x8_dc_mmxext(uint8_t *dest, ptrdiff_t stride,
541	541	int16_t *block)
542	542	{
543	543	int dc = block[0];
@@ -569,12 +569,12 @@ static void vc1_inv_trans_4x8_dc_mmxext(uint8_t *dest, int linesize, · 25 unmodified lines
569	569	"movd %%mm3, %1 \n\t"
570	570	"movd %%mm4, %2 \n\t"
571	571	"movd %%mm5, %3 \n\t"
572		− :"+m"((uint32_t)(dest+0*linesize)),
573		− "+m"((uint32_t)(dest+1*linesize)),
574		− "+m"((uint32_t)(dest+2*linesize)),
575		− "+m"((uint32_t)(dest+3*linesize))
	572	+ :"+m"((uint32_t )(dest + 0 * stride)),
	573	+ "+m"((uint32_t )(dest + 1 * stride)),
	574	+ "+m"((uint32_t )(dest + 2 * stride)),
	575	+ "+m"((uint32_t )(dest + 3 * stride))
576	576	);
577		− dest += 4*linesize;
	577	+ dest += 4 * stride;
578	578	__asm__ volatile(
579	579	"movd %0, %%mm2 \n\t"
580	580	"movd %1, %%mm3 \n\t"
@@ -592,14 +592,14 @@ static void vc1_inv_trans_4x8_dc_mmxext(uint8_t *dest, int linesize, · 11 unmodified lines
592	592	"movd %%mm3, %1 \n\t"
593	593	"movd %%mm4, %2 \n\t"
594	594	"movd %%mm5, %3 \n\t"
595		− :"+m"((uint32_t)(dest+0*linesize)),
596		− "+m"((uint32_t)(dest+1*linesize)),
597		− "+m"((uint32_t)(dest+2*linesize)),
598		− "+m"((uint32_t)(dest+3*linesize))
	595	+ :"+m"((uint32_t )(dest + 0 * stride)),
	596	+ "+m"((uint32_t )(dest + 1 * stride)),
	597	+ "+m"((uint32_t )(dest + 2 * stride)),
	598	+ "+m"((uint32_t )(dest + 3 * stride))
599	599	);
600	600	}
601	601
602		−static void vc1_inv_trans_8x4_dc_mmxext(uint8_t *dest, int linesize,
	602	+static void vc1_inv_trans_8x4_dc_mmxext(uint8_t *dest, ptrdiff_t stride,
603	603	int16_t *block)
604	604	{
605	605	int dc = block[0];
@@ -631,14 +631,14 @@ static void vc1_inv_trans_8x4_dc_mmxext(uint8_t *dest, int linesize, · 25 unmodified lines
631	631	"movq %%mm3, %1 \n\t"
632	632	"movq %%mm4, %2 \n\t"
633	633	"movq %%mm5, %3 \n\t"
634		− :"+m"((uint32_t)(dest+0*linesize)),
635		− "+m"((uint32_t)(dest+1*linesize)),
636		− "+m"((uint32_t)(dest+2*linesize)),
637		− "+m"((uint32_t)(dest+3*linesize))
	634	+ :"+m"((uint32_t )(dest + 0 * stride)),
	635	+ "+m"((uint32_t )(dest + 1 * stride)),
	636	+ "+m"((uint32_t )(dest + 2 * stride)),
	637	+ "+m"((uint32_t )(dest + 3 * stride))
638	638	);
639	639	}
640	640
641		−static void vc1_inv_trans_8x8_dc_mmxext(uint8_t *dest, int linesize,
	641	+static void vc1_inv_trans_8x8_dc_mmxext(uint8_t *dest, ptrdiff_t stride,
642	642	int16_t *block)
643	643	{
644	644	int dc = block[0];
@@ -670,12 +670,12 @@ static void vc1_inv_trans_8x8_dc_mmxext(uint8_t *dest, int linesize, · 25 unmodified lines
670	670	"movq %%mm3, %1 \n\t"
671	671	"movq %%mm4, %2 \n\t"
672	672	"movq %%mm5, %3 \n\t"
673		− :"+m"((uint32_t)(dest+0*linesize)),
674		− "+m"((uint32_t)(dest+1*linesize)),
675		− "+m"((uint32_t)(dest+2*linesize)),
676		− "+m"((uint32_t)(dest+3*linesize))
	673	+ :"+m"((uint32_t )(dest + 0 * stride)),
	674	+ "+m"((uint32_t )(dest + 1 * stride)),
	675	+ "+m"((uint32_t )(dest + 2 * stride)),
	676	+ "+m"((uint32_t )(dest + 3 * stride))
677	677	);
678		− dest += 4*linesize;
	678	+ dest += 4 * stride;
679	679	__asm__ volatile(
680	680	"movq %0, %%mm2 \n\t"
681	681	"movq %1, %%mm3 \n\t"
@@ -693,10 +693,10 @@ static void vc1_inv_trans_8x8_dc_mmxext(uint8_t *dest, int linesize, · 11 unmodified lines
693	693	"movq %%mm3, %1 \n\t"
694	694	"movq %%mm4, %2 \n\t"
695	695	"movq %%mm5, %3 \n\t"
696		− :"+m"((uint32_t)(dest+0*linesize)),
697		− "+m"((uint32_t)(dest+1*linesize)),
698		− "+m"((uint32_t)(dest+2*linesize)),
699		− "+m"((uint32_t)(dest+3*linesize))
	696	+ :"+m"((uint32_t )(dest + 0 * stride)),
	697	+ "+m"((uint32_t )(dest + 1 * stride)),
	698	+ "+m"((uint32_t )(dest + 2 * stride)),
	699	+ "+m"((uint32_t )(dest + 3 * stride))
700	700	);
701	701	}
702	702

libavcodec/x86/xvididct.h+7−6

@@ -26,18 +26,19 @@ · 25 unmodified lines
26	26	#ifndef AVCODEC_X86_XVIDIDCT_H
27	27	#define AVCODEC_X86_XVIDIDCT_H
28	28
	29	+#include <stddef.h>
29	30	#include <stdint.h>
30	31
31	32	void ff_xvid_idct_mmx(short *block);
32		−void ff_xvid_idct_mmx_put(uint8_t dest, int line_size, int16_t block);
33		−void ff_xvid_idct_mmx_add(uint8_t dest, int line_size, int16_t block);
	33	+void ff_xvid_idct_mmx_put(uint8_t dest, ptrdiff_t line_size, int16_t block);
	34	+void ff_xvid_idct_mmx_add(uint8_t dest, ptrdiff_t line_size, int16_t block);
34	35
35	36	void ff_xvid_idct_mmxext(short *block);
36		−void ff_xvid_idct_mmxext_put(uint8_t dest, int line_size, int16_t block);
37		−void ff_xvid_idct_mmxext_add(uint8_t dest, int line_size, int16_t block);
	37	+void ff_xvid_idct_mmxext_put(uint8_t dest, ptrdiff_t line_size, int16_t block);
	38	+void ff_xvid_idct_mmxext_add(uint8_t dest, ptrdiff_t line_size, int16_t block);
38	39
39	40	void ff_xvid_idct_sse2(short *block);
40		−void ff_xvid_idct_sse2_put(uint8_t dest, int line_size, short block);
41		−void ff_xvid_idct_sse2_add(uint8_t dest, int line_size, short block);
	41	+void ff_xvid_idct_sse2_put(uint8_t dest, ptrdiff_t line_size, short block);
	42	+void ff_xvid_idct_sse2_add(uint8_t dest, ptrdiff_t line_size, short block);
42	43
43	44	#endif /* AVCODEC_X86_XVIDIDCT_H */

libavcodec/x86/xvididct_mmx.c+4−4

@@ -494,13 +494,13 @@ void ff_xvid_idct_mmx(short *block) · 493 unmodified lines
494	494	:: "r" (block), "r" (rounder_0), "r" (tab_i_04_mmx), "r" (tg_1_16));
495	495	}
496	496
497		−void ff_xvid_idct_mmx_put(uint8_t dest, int line_size, int16_t block)
	497	+void ff_xvid_idct_mmx_put(uint8_t dest, ptrdiff_t line_size, int16_t block)
498	498	{
499	499	ff_xvid_idct_mmx(block);
500	500	ff_put_pixels_clamped_mmx(block, dest, line_size);
501	501	}
502	502
503		−void ff_xvid_idct_mmx_add(uint8_t dest, int line_size, int16_t block)
	503	+void ff_xvid_idct_mmx_add(uint8_t dest, ptrdiff_t line_size, int16_t block)
504	504	{
505	505	ff_xvid_idct_mmx(block);
506	506	ff_add_pixels_clamped_mmx(block, dest, line_size);
@@ -533,13 +533,13 @@ void ff_xvid_idct_mmxext(short *block) · 26 unmodified lines
533	533	:: "r" (block), "r" (rounder_0), "r" (tab_i_04_xmm), "r" (tg_1_16));
534	534	}
535	535
536		−void ff_xvid_idct_mmxext_put(uint8_t dest, int line_size, int16_t block)
	536	+void ff_xvid_idct_mmxext_put(uint8_t dest, ptrdiff_t line_size, int16_t block)
537	537	{
538	538	ff_xvid_idct_mmxext(block);
539	539	ff_put_pixels_clamped_mmx(block, dest, line_size);
540	540	}
541	541
542		−void ff_xvid_idct_mmxext_add(uint8_t dest, int line_size, int16_t block)
	542	+void ff_xvid_idct_mmxext_add(uint8_t dest, ptrdiff_t line_size, int16_t block)
543	543	{
544	544	ff_xvid_idct_mmxext(block);
545	545	ff_add_pixels_clamped_mmx(block, dest, line_size);

libavcodec/x86/xvididct_sse2.c+2−2

@@ -390,13 +390,13 @@ inline void ff_xvid_idct_sse2(short *block) · 389 unmodified lines
390	390	"%eax", "%ecx", "%edx", "%esi", "memory");
391	391	}
392	392
393		−void ff_xvid_idct_sse2_put(uint8_t dest, int line_size, short block)
	393	+void ff_xvid_idct_sse2_put(uint8_t dest, ptrdiff_t line_size, short block)
394	394	{
395	395	ff_xvid_idct_sse2(block);
396	396	ff_put_pixels_clamped_mmx(block, dest, line_size);
397	397	}
398	398
399		−void ff_xvid_idct_sse2_add(uint8_t dest, int line_size, short block)
	399	+void ff_xvid_idct_sse2_add(uint8_t dest, ptrdiff_t line_size, short block)
400	400	{
401	401	ff_xvid_idct_sse2(block);
402	402	ff_add_pixels_clamped_mmx(block, dest, line_size);

libavcodec/xvididct.c+2−2

@@ -318,13 +318,13 @@ void ff_xvid_idct(int16_t *const in) · 317 unmodified lines
318	318	}
319	319	}
320	320
321		−static void xvid_idct_put(uint8_t dest, int line_size, int16_t block)
	321	+static void xvid_idct_put(uint8_t dest, ptrdiff_t line_size, int16_t block)
322	322	{
323	323	ff_xvid_idct(block);
324	324	ff_put_pixels_clamped(block, dest, line_size);
325	325	}
326	326
327		−static void xvid_idct_add(uint8_t dest, int line_size, int16_t block)
	327	+static void xvid_idct_add(uint8_t dest, ptrdiff_t line_size, int16_t block)
328	328	{
329	329	ff_xvid_idct(block);
330	330	ff_add_pixels_clamped(block, dest, line_size);

idct: Change type of array stride parameters to ptrdiff_t

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code