VC1: merge idct8x8, coeff adjustments and put_pixels.

Merging these functions allows merging some loops, which makes the results (particularly after SIMD optimizations) much faster. (cherry picked from commit f8bed30d8b176fa030f6737765338bb4a2bcabc9)

Ronald S. Bultje committed 15 years ago

Commit 6a786b11 parent 90ed2775 files · +170 −40Browse files

Unified · Split

5 files

libavcodec/ppc/vc1dsp_altivec.c +61 −3
libavcodec/vc1.c +27 −1
libavcodec/vc1dec.c +33 −25
libavcodec/vc1dsp.c +44 −10
libavcodec/vc1dsp.h +5 −1

libavcodec/ppc/vc1dsp_altivec.c+61−3

@@ -130,7 +130,8 @@ do { \ · 129 unmodified lines
130	130
131	131	/** Do inverse transform on 8x8 block
132	132	*/
133		−static void vc1_inv_trans_8x8_altivec(DCTELEM block[64])
	133	+static void vc1_inv_trans_8x8_altivec(DCTELEM block[64],
	134	+ int sign, int rangered)
134	135	{
135	136	vector signed short src0, src1, src2, src3, src4, src5, src6, src7;
136	137	vector signed int s0, s1, s2, s3, s4, s5, s6, s7;
@@ -144,7 +145,9 @@ static void vc1_inv_trans_8x8_altivec(DCTELEM block[64]) · 7 unmodified lines
144	145	const vector unsigned int vec_2 = vec_splat_u32(2);
145	146	const vector signed int vec_1s = vec_splat_s32(1);
146	147	const vector unsigned int vec_1 = vec_splat_u32(1);
147		−
	148	+ const vector unsigned short rangered_shift = vec_splat_u16(1);
	149	+ const vector signed short signed_bias = vec_sl(vec_splat_u16(4),
	150	+ vec_splat_u16(4));
148	151
149	152	src0 = vec_ld( 0, block);
150	153	src1 = vec_ld( 16, block);
@@ -214,6 +217,27 @@ static void vc1_inv_trans_8x8_altivec(DCTELEM block[64]) · 63 unmodified lines
214	217	src6 = vec_pack(sE, s6);
215	218	src7 = vec_pack(sF, s7);
216	219
	220	+ if (rangered) {
	221	+ if (!sign) {
	222	+ vec_sub(src0, signed_bias);
	223	+ vec_sub(src1, signed_bias);
	224	+ vec_sub(src2, signed_bias);
	225	+ vec_sub(src3, signed_bias);
	226	+ vec_sub(src4, signed_bias);
	227	+ vec_sub(src5, signed_bias);
	228	+ vec_sub(src6, signed_bias);
	229	+ vec_sub(src7, signed_bias);
	230	+ }
	231	+ vec_sl(src0, rangered_shift);
	232	+ vec_sl(src1, rangered_shift);
	233	+ vec_sl(src2, rangered_shift);
	234	+ vec_sl(src3, rangered_shift);
	235	+ vec_sl(src4, rangered_shift);
	236	+ vec_sl(src5, rangered_shift);
	237	+ vec_sl(src6, rangered_shift);
	238	+ vec_sl(src7, rangered_shift);
	239	+ }
	240	+
217	241	vec_st(src0, 0, block);
218	242	vec_st(src1, 16, block);
219	243	vec_st(src2, 32, block);
@@ -224,6 +248,36 @@ static void vc1_inv_trans_8x8_altivec(DCTELEM block[64]) · 4 unmodified lines
224	248	vec_st(src7,112, block);
225	249	}
226	250
	251	+static void vc1_inv_trans_8x8_add_altivec(uint8_t dest, int stride, DCTELEM b)
	252	+{
	253	+ vc1_inv_trans_8x8_altivec(b, 0, 0);
	254	+ ff_add_pixels_clamped_c(b, dest, stride);
	255	+}
	256	+
	257	+static void vc1_inv_trans_8x8_put_signed_altivec(uint8_t dest, int stride, DCTELEM b)
	258	+{
	259	+ vc1_inv_trans_8x8_altivec(b, 1, 0);
	260	+ ff_put_signed_pixels_clamped_c(b, dest, stride);
	261	+}
	262	+
	263	+static void vc1_inv_trans_8x8_put_signed_rangered_altivec(uint8_t dest, int stride, DCTELEM b)
	264	+{
	265	+ vc1_inv_trans_8x8_altivec(b, 1, 1);
	266	+ ff_put_signed_pixels_clamped_c(b, dest, stride);
	267	+}
	268	+
	269	+static void vc1_inv_trans_8x8_put_altivec(uint8_t dest, int stride, DCTELEM b)
	270	+{
	271	+ vc1_inv_trans_8x8_altivec(b, 0, 0);
	272	+ ff_put_pixels_clamped_c(b, dest, stride);
	273	+}
	274	+
	275	+static void vc1_inv_trans_8x8_put_rangered_altivec(uint8_t dest, int stride, DCTELEM b)
	276	+{
	277	+ vc1_inv_trans_8x8_altivec(b, 0, 1);
	278	+ ff_put_pixels_clamped_c(b, dest, stride);
	279	+}
	280	+
227	281	/** Do inverse transform on 8x4 part of block
228	282	*/
229	283	static void vc1_inv_trans_8x4_altivec(uint8_t dest, int stride, DCTELEM block)
@@ -342,7 +396,11 @@ void ff_vc1dsp_init_altivec(VC1DSPContext* dsp) · 112 unmodified lines
342	396	if (!(av_get_cpu_flags() & AV_CPU_FLAG_ALTIVEC))
343	397	return;
344	398
345		− dsp->vc1_inv_trans_8x8 = vc1_inv_trans_8x8_altivec;
	399	+ dsp->vc1_inv_trans_8x8_add = vc1_inv_trans_8x8_add_altivec;
	400	+ dsp->vc1_inv_trans_8x8_put_signed[0] = vc1_inv_trans_8x8_put_signed_altivec;
	401	+ dsp->vc1_inv_trans_8x8_put_signed[1] = vc1_inv_trans_8x8_put_signed_rangered_altivec;
	402	+ dsp->vc1_inv_trans_8x8_put[0] = vc1_inv_trans_8x8_put_altivec;
	403	+ dsp->vc1_inv_trans_8x8_put[1] = vc1_inv_trans_8x8_put_rangered_altivec;
346	404	dsp->vc1_inv_trans_8x4 = vc1_inv_trans_8x4_altivec;
347	405	dsp->put_no_rnd_vc1_chroma_pixels_tab[0] = put_no_rnd_vc1_chroma_mc8_altivec;
348	406	dsp->avg_no_rnd_vc1_chroma_pixels_tab[0] = avg_no_rnd_vc1_chroma_mc8_altivec;

libavcodec/vc1.c+27−1

@@ -280,6 +280,28 @@ static int vop_dquant_decoding(VC1Context *v) · 279 unmodified lines
280	280
281	281	static int decode_sequence_header_adv(VC1Context v, GetBitContext gb);
282	282
	283	+static void simple_idct_put_rangered(uint8_t dest, int line_size, DCTELEM block)
	284	+{
	285	+ int i;
	286	+ ff_simple_idct(block);
	287	+ for (i = 0; i < 64; i++) block[i] = (block[i] - 64) << 1;
	288	+ ff_put_pixels_clamped_c(block, dest, line_size);
	289	+}
	290	+
	291	+static void simple_idct_put_signed(uint8_t dest, int line_size, DCTELEM block)
	292	+{
	293	+ ff_simple_idct(block);
	294	+ ff_put_signed_pixels_clamped_c(block, dest, line_size);
	295	+}
	296	+
	297	+static void simple_idct_put_signed_rangered(uint8_t dest, int line_size, DCTELEM block)
	298	+{
	299	+ int i;
	300	+ ff_simple_idct(block);
	301	+ for (i = 0; i < 64; i++) block[i] <<= 1;
	302	+ ff_put_signed_pixels_clamped_c(block, dest, line_size);
	303	+}
	304	+
283	305	/**
284	306	* Decode Simple/Main Profiles sequence header
285	307	* @see Figure 7-8, p16-17
@@ -337,7 +359,11 @@ int vc1_decode_sequence_header(AVCodecContext avctx, VC1Context v, GetBitConte · 51 unmodified lines
337	359	v->res_fasttx = get_bits1(gb);
338	360	if (!v->res_fasttx)
339	361	{
340		− v->vc1dsp.vc1_inv_trans_8x8 = ff_simple_idct;
	362	+ v->vc1dsp.vc1_inv_trans_8x8_add = ff_simple_idct_add;
	363	+ v->vc1dsp.vc1_inv_trans_8x8_put[0] = ff_simple_idct_put;
	364	+ v->vc1dsp.vc1_inv_trans_8x8_put[1] = simple_idct_put_rangered;
	365	+ v->vc1dsp.vc1_inv_trans_8x8_put_signed[0] = simple_idct_put_signed;
	366	+ v->vc1dsp.vc1_inv_trans_8x8_put_signed[1] = simple_idct_put_signed_rangered;
341	367	v->vc1dsp.vc1_inv_trans_8x4 = ff_simple_idct84_add;
342	368	v->vc1dsp.vc1_inv_trans_4x8 = ff_simple_idct48_add;
343	369	v->vc1dsp.vc1_inv_trans_4x4 = ff_simple_idct44_add;

libavcodec/vc1dec.c+33−25

@@ -2009,8 +2009,7 @@ static int vc1_decode_p_block(VC1Context *v, DCTELEM block[64], int n, int mquan · 2008 unmodified lines
2009	2009	if(i==1)
2010	2010	v->vc1dsp.vc1_inv_trans_8x8_dc(dst, linesize, block);
2011	2011	else{
2012		− v->vc1dsp.vc1_inv_trans_8x8(block);
2013		− s->dsp.add_pixels_clamped(block, dst, linesize);
	2012	+ v->vc1dsp.vc1_inv_trans_8x8_add(dst, linesize, block);
2014	2013	}
2015	2014	if(apply_filter && cbp_top & 0xC)
2016	2015	v->vc1dsp.vc1_v_loop_filter8(dst, linesize, v->pq);
@@ -2117,7 +2116,7 @@ static int vc1_decode_p_mb(VC1Context *v) · 100 unmodified lines
2117	2116	{
2118	2117	MpegEncContext *s = &v->s;
2119	2118	GetBitContext *gb = &s->gb;
2120		− int i, j;
	2119	+ int i;
2121	2120	int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
2122	2121	int cbp; /* cbp decoding stuff */
2123	2122	int mqdiff, mquant; /* MB quantization */
@@ -2149,6 +2148,8 @@ static int vc1_decode_p_mb(VC1Context *v) · 25 unmodified lines
2149	2148	{
2150	2149	if (!skipped)
2151	2150	{
	2151	+ vc1_idct_func idct8x8_fn;
	2152	+
2152	2153	GET_MVDATA(dmv_x, dmv_y);
2153	2154
2154	2155	if (s->mb_intra) {
@@ -2183,6 +2184,7 @@ static int vc1_decode_p_mb(VC1Context *v) · 28 unmodified lines
2183	2184	VC1_TTMB_VLC_BITS, 2);
2184	2185	if(!s->mb_intra) vc1_mc_1mv(v, 0);
2185	2186	dst_idx = 0;
	2187	+ idct8x8_fn = v->vc1dsp.vc1_inv_trans_8x8_put_signed[!!v->rangeredfrm];
2186	2188	for (i=0; i<6; i++)
2187	2189	{
2188	2190	s->dc_val[0][s->block_index[i]] = 0;
@@ -2200,9 +2202,9 @@ static int vc1_decode_p_mb(VC1Context *v) · 11 unmodified lines
2200	2202
2201	2203	vc1_decode_intra_block(v, s->block[i], i, val, mquant, (i&4)?v->codingset2:v->codingset);
2202	2204	if((i>3) && (s->flags & CODEC_FLAG_GRAY)) continue;
2203		− v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
2204		− if(v->rangeredfrm) for(j = 0; j < 64; j++) s->block[i][j] <<= 1;
2205		− s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
	2205	+ idct8x8_fn(s->dest[dst_idx] + off,
	2206	+ i & 4 ? s->uvlinesize : s->linesize,
	2207	+ s->block[i]);
2206	2208	if(v->pq >= 9 && v->overlap) {
2207	2209	if(v->c_avail)
2208	2210	v->vc1dsp.vc1_h_overlap(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
@@ -2267,6 +2269,7 @@ static int vc1_decode_p_mb(VC1Context *v) · 58 unmodified lines
2267	2269	{
2268	2270	int intra_count = 0, coded_inter = 0;
2269	2271	int is_intra[6], is_coded[6];
	2272	+ vc1_idct_func idct8x8_fn;
2270	2273	/* Get CBPCY */
2271	2274	cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
2272	2275	for (i=0; i<6; i++)
@@ -2316,6 +2319,7 @@ static int vc1_decode_p_mb(VC1Context *v) · 43 unmodified lines
2316	2319	}
2317	2320	if (!v->ttmbf && coded_inter)
2318	2321	ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
	2322	+ idct8x8_fn = v->vc1dsp.vc1_inv_trans_8x8_put_signed[!!v->rangeredfrm];
2319	2323	for (i=0; i<6; i++)
2320	2324	{
2321	2325	dst_idx += i >> 2;
@@ -2331,9 +2335,9 @@ static int vc1_decode_p_mb(VC1Context *v) · 9 unmodified lines
2331	2335
2332	2336	vc1_decode_intra_block(v, s->block[i], i, is_coded[i], mquant, (i&4)?v->codingset2:v->codingset);
2333	2337	if((i>3) && (s->flags & CODEC_FLAG_GRAY)) continue;
2334		− v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
2335		− if(v->rangeredfrm) for(j = 0; j < 64; j++) s->block[i][j] <<= 1;
2336		− s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, (i&4)?s->uvlinesize:s->linesize);
	2338	+ idct8x8_fn(s->dest[dst_idx] + off,
	2339	+ (i&4)?s->uvlinesize:s->linesize,
	2340	+ s->block[i]);
2337	2341	if(v->pq >= 9 && v->overlap) {
2338	2342	if(v->c_avail)
2339	2343	v->vc1dsp.vc1_h_overlap(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
@@ -2409,7 +2413,7 @@ static void vc1_decode_b_mb(VC1Context *v) · 69 unmodified lines
2409	2413	{
2410	2414	MpegEncContext *s = &v->s;
2411	2415	GetBitContext *gb = &s->gb;
2412		− int i, j;
	2416	+ int i;
2413	2417	int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
2414	2418	int cbp = 0; /* cbp decoding stuff */
2415	2419	int mqdiff, mquant; /* MB quantization */
@@ -2422,6 +2426,7 @@ static void vc1_decode_b_mb(VC1Context *v) · 6 unmodified lines
2422	2426	int skipped, direct;
2423	2427	int dmv_x[2], dmv_y[2];
2424	2428	int bmvtype = BMV_TYPE_BACKWARD;
	2429	+ vc1_idct_func idct8x8_fn;
2425	2430
2426	2431	mquant = v->pq; /* Loosy initialization */
2427	2432	s->mb_intra = 0;
@@ -2519,6 +2524,7 @@ static void vc1_decode_b_mb(VC1Context *v) · 91 unmodified lines
2519	2524	}
2520	2525	}
2521	2526	dst_idx = 0;
	2527	+ idct8x8_fn = v->vc1dsp.vc1_inv_trans_8x8_put_signed[!!v->rangeredfrm];
2522	2528	for (i=0; i<6; i++)
2523	2529	{
2524	2530	s->dc_val[0][s->block_index[i]] = 0;
@@ -2536,9 +2542,9 @@ static void vc1_decode_b_mb(VC1Context *v) · 11 unmodified lines
2536	2542
2537	2543	vc1_decode_intra_block(v, s->block[i], i, val, mquant, (i&4)?v->codingset2:v->codingset);
2538	2544	if((i>3) && (s->flags & CODEC_FLAG_GRAY)) continue;
2539		− v->vc1dsp.vc1_inv_trans_8x8(s->block[i]);
2540		− if(v->rangeredfrm) for(j = 0; j < 64; j++) s->block[i][j] <<= 1;
2541		− s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize);
	2545	+ idct8x8_fn(s->dest[dst_idx] + off,
	2546	+ i & 4 ? s->uvlinesize : s->linesize,
	2547	+ s->block[i]);
2542	2548	} else if(val) {
2543	2549	vc1_decode_p_block(v, s->block[i], i, mquant, ttmb, first_block, s->dest[dst_idx] + off, (i&4)?s->uvlinesize:s->linesize, (i&4) && (s->flags & CODEC_FLAG_GRAY), 0, 0, 0);
2544	2550	if(!v->ttmbf && ttmb < 8) ttmb = -1;
@@ -2551,11 +2557,12 @@ static void vc1_decode_b_mb(VC1Context *v) · 6 unmodified lines
2551	2557	*/
2552	2558	static void vc1_decode_i_blocks(VC1Context *v)
2553	2559	{
2554		− int k, j;
	2560	+ int k;
2555	2561	MpegEncContext *s = &v->s;
2556	2562	int cbp, val;
2557	2563	uint8_t *coded_val;
2558	2564	int mb_pos;
	2565	+ vc1_idct_func idct8x8_fn;
2559	2566
2560	2567	/* select codingmode used for VLC tables selection */
2561	2568	switch(v->y_ac_table_index){
@@ -2590,6 +2597,10 @@ static void vc1_decode_i_blocks(VC1Context *v) · 28 unmodified lines
2590	2597	s->mb_x = s->mb_y = 0;
2591	2598	s->mb_intra = 1;
2592	2599	s->first_slice_line = 1;
	2600	+ if(v->pq >= 9 && v->overlap) {
	2601	+ idct8x8_fn = v->vc1dsp.vc1_inv_trans_8x8_put_signed[!!v->rangeredfrm];
	2602	+ } else
	2603	+ idct8x8_fn = v->vc1dsp.vc1_inv_trans_8x8_put[!!v->rangeredfrm];
2593	2604	for(s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
2594	2605	s->mb_x = 0;
2595	2606	ff_init_block_index(s);
@@ -2626,14 +2637,9 @@ static void vc1_decode_i_blocks(VC1Context *v) · 30 unmodified lines
2626	2637	vc1_decode_i_block(v, s->block[k], k, val, (k<4)? v->codingset : v->codingset2);
2627	2638
2628	2639	if (k > 3 && (s->flags & CODEC_FLAG_GRAY)) continue;
2629		− v->vc1dsp.vc1_inv_trans_8x8(s->block[k]);
2630		− if(v->pq >= 9 && v->overlap) {
2631		− if (v->rangeredfrm) for(j = 0; j < 64; j++) s->block[k][j] <<= 1;
2632		− s->dsp.put_signed_pixels_clamped(s->block[k], dst[k], k & 4 ? s->uvlinesize : s->linesize);
2633		− } else {
2634		− if (v->rangeredfrm) for(j = 0; j < 64; j++) s->block[k][j] = (s->block[k][j] - 64) << 1;
2635		− s->dsp.put_pixels_clamped(s->block[k], dst[k], k & 4 ? s->uvlinesize : s->linesize);
2636		− }
	2640	+ idct8x8_fn(dst[k],
	2641	+ k & 4 ? s->uvlinesize : s->linesize,
	2642	+ s->block[k]);
2637	2643	}
2638	2644
2639	2645	if(v->pq >= 9 && v->overlap) {
@@ -2691,6 +2697,7 @@ static void vc1_decode_i_blocks_adv(VC1Context *v) · 51 unmodified lines
2691	2697	int mqdiff;
2692	2698	int overlap;
2693	2699	GetBitContext *gb = &s->gb;
	2700	+ vc1_idct_func idct8x8_fn;
2694	2701
2695	2702	/* select codingmode used for VLC tables selection */
2696	2703	switch(v->y_ac_table_index){
@@ -2721,6 +2728,7 @@ static void vc1_decode_i_blocks_adv(VC1Context *v) · 24 unmodified lines
2721	2728	s->mb_x = s->mb_y = 0;
2722	2729	s->mb_intra = 1;
2723	2730	s->first_slice_line = 1;
	2731	+ idct8x8_fn = v->vc1dsp.vc1_inv_trans_8x8_put_signed[0];
2724	2732	for(s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
2725	2733	s->mb_x = 0;
2726	2734	ff_init_block_index(s);
@@ -2777,9 +2785,9 @@ static void vc1_decode_i_blocks_adv(VC1Context *v) · 50 unmodified lines
2777	2785	vc1_decode_i_block_adv(v, s->block[k], k, val, (k<4)? v->codingset : v->codingset2, mquant);
2778	2786
2779	2787	if (k > 3 && (s->flags & CODEC_FLAG_GRAY)) continue;
2780		− v->vc1dsp.vc1_inv_trans_8x8(s->block[k]);
2781		− s->dsp.put_signed_pixels_clamped(s->block[k], dst[k],
2782		− k & 4 ? s->uvlinesize : s->linesize);
	2788	+ idct8x8_fn(dst[k],
	2789	+ k & 4 ? s->uvlinesize : s->linesize,
	2790	+ s->block[k]);
2783	2791	}
2784	2792
2785	2793	if(overlap) {

libavcodec/vc1dsp.c+44−10

@@ -199,7 +199,7 @@ static void vc1_inv_trans_8x8_dc_c(uint8_t dest, int linesize, DCTELEM block) · 198 unmodified lines
199	199	}
200	200	}
201	201
202		−static void vc1_inv_trans_8x8_c(DCTELEM block[64])
	202	+static av_always_inline void vc1_inv_trans_8x8_c(DCTELEM block[64], int shl, int sub)
203	203	{
204	204	int i;
205	205	register int t1,t2,t3,t4,t5,t6,t7,t8;
@@ -254,20 +254,50 @@ static void vc1_inv_trans_8x8_c(DCTELEM block[64]) · 48 unmodified lines
254	254	t3 = 9 * src[ 8] - 16 * src[24] + 4 * src[40] + 15 * src[56];
255	255	t4 = 4 * src[ 8] - 9 * src[24] + 15 * src[40] - 16 * src[56];
256	256
257		− dst[ 0] = (t5 + t1) >> 7;
258		− dst[ 8] = (t6 + t2) >> 7;
259		− dst[16] = (t7 + t3) >> 7;
260		− dst[24] = (t8 + t4) >> 7;
261		− dst[32] = (t8 - t4 + 1) >> 7;
262		− dst[40] = (t7 - t3 + 1) >> 7;
263		− dst[48] = (t6 - t2 + 1) >> 7;
264		− dst[56] = (t5 - t1 + 1) >> 7;
	257	+ dst[ 0] = (((t5 + t1 ) >> 7) - sub) << shl;
	258	+ dst[ 8] = (((t6 + t2 ) >> 7) - sub) << shl;
	259	+ dst[16] = (((t7 + t3 ) >> 7) - sub) << shl;
	260	+ dst[24] = (((t8 + t4 ) >> 7) - sub) << shl;
	261	+ dst[32] = (((t8 - t4 + 1) >> 7) - sub) << shl;
	262	+ dst[40] = (((t7 - t3 + 1) >> 7) - sub) << shl;
	263	+ dst[48] = (((t6 - t2 + 1) >> 7) - sub) << shl;
	264	+ dst[56] = (((t5 - t1 + 1) >> 7) - sub) << shl;
265	265
266	266	src++;
267	267	dst++;
268	268	}
269	269	}
270	270
	271	+static void vc1_inv_trans_8x8_add_c(uint8_t dest, int linesize, DCTELEM block)
	272	+{
	273	+ vc1_inv_trans_8x8_c(block, 0, 0);
	274	+ ff_add_pixels_clamped_c(block, dest, linesize);
	275	+}
	276	+
	277	+static void vc1_inv_trans_8x8_put_signed_c(uint8_t dest, int linesize, DCTELEM block)
	278	+{
	279	+ vc1_inv_trans_8x8_c(block, 0, 0);
	280	+ ff_put_signed_pixels_clamped_c(block, dest, linesize);
	281	+}
	282	+
	283	+static void vc1_inv_trans_8x8_put_signed_rangered_c(uint8_t dest, int linesize, DCTELEM block)
	284	+{
	285	+ vc1_inv_trans_8x8_c(block, 1, 0);
	286	+ ff_put_signed_pixels_clamped_c(block, dest, linesize);
	287	+}
	288	+
	289	+static void vc1_inv_trans_8x8_put_c(uint8_t dest, int linesize, DCTELEM block)
	290	+{
	291	+ vc1_inv_trans_8x8_c(block, 0, 0);
	292	+ ff_put_pixels_clamped_c(block, dest, linesize);
	293	+}
	294	+
	295	+static void vc1_inv_trans_8x8_put_rangered_c(uint8_t dest, int linesize, DCTELEM block)
	296	+{
	297	+ vc1_inv_trans_8x8_c(block, 1, 64);
	298	+ ff_put_pixels_clamped_c(block, dest, linesize);
	299	+}
	300	+
271	301	/** Do inverse transform on 8x4 part of block
272	302	*/
273	303	static void vc1_inv_trans_8x4_dc_c(uint8_t dest, int linesize, DCTELEM block)
@@ -662,7 +692,11 @@ static void avg_no_rnd_vc1_chroma_mc8_c(uint8_t dst/align 8/, uint8_t src/*a · 388 unmodified lines
662	692	}
663	693
664	694	av_cold void ff_vc1dsp_init(VC1DSPContext* dsp) {
665		− dsp->vc1_inv_trans_8x8 = vc1_inv_trans_8x8_c;
	695	+ dsp->vc1_inv_trans_8x8_add = vc1_inv_trans_8x8_add_c;
	696	+ dsp->vc1_inv_trans_8x8_put_signed[0] = vc1_inv_trans_8x8_put_signed_c;
	697	+ dsp->vc1_inv_trans_8x8_put_signed[1] = vc1_inv_trans_8x8_put_signed_rangered_c;
	698	+ dsp->vc1_inv_trans_8x8_put[0] = vc1_inv_trans_8x8_put_c;
	699	+ dsp->vc1_inv_trans_8x8_put[1] = vc1_inv_trans_8x8_put_rangered_c;
666	700	dsp->vc1_inv_trans_4x8 = vc1_inv_trans_4x8_c;
667	701	dsp->vc1_inv_trans_8x4 = vc1_inv_trans_8x4_c;
668	702	dsp->vc1_inv_trans_4x4 = vc1_inv_trans_4x4_c;

libavcodec/vc1dsp.h+5−1

@@ -30,9 +30,13 @@ · 29 unmodified lines
30	30
31	31	#include "dsputil.h"
32	32
	33	+typedef void (vc1_idct_func)(uint8_t dest, int line_size, DCTELEM *block);
	34	+
33	35	typedef struct VC1DSPContext {
34	36	/* vc1 functions */
35		− void (vc1_inv_trans_8x8)(DCTELEM b);
	37	+ vc1_idct_func vc1_inv_trans_8x8_add;
	38	+ vc1_idct_func vc1_inv_trans_8x8_put_signed[2];
	39	+ vc1_idct_func vc1_inv_trans_8x8_put[2];
36	40	void (vc1_inv_trans_8x4)(uint8_t dest, int line_size, DCTELEM *block);
37	41	void (vc1_inv_trans_4x8)(uint8_t dest, int line_size, DCTELEM *block);
38	42	void (vc1_inv_trans_4x4)(uint8_t dest, int line_size, DCTELEM *block);

VC1: merge idct8x8, coeff adjustments and put_pixels.

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code