[deb_ffmpeg.git] / ffmpeg / libavcodec / alpha / simple_idct_alpha.c

/*
 * Simple IDCT (Alpha optimized)
 *
 * Copyright (c) 2001 Michael Niedermayer <michaelni@gmx.at>
 *
 * based upon some outcommented C code from mpeg2dec (idct_mmx.c
 * written by Aaron Holtzman <aholtzma@ess.engr.uvic.ca>)
 *
 * Alpha optimizations by Måns Rullgård <mans@mansr.com>
 *                     and Falk Hueffner <falk@debian.org>
 *
 * This file is part of FFmpeg.
 *
 * FFmpeg is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * FFmpeg is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with FFmpeg; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

#include "idctdsp_alpha.h"
#include "asm.h"

// cos(i * M_PI / 16) * sqrt(2) * (1 << 14)
// W4 is actually exactly 16384, but using 16383 works around
// accumulating rounding errors for some encoders
#define W1 22725
#define W2 21407
#define W3 19266
#define W4 16383
#define W5 12873
#define W6  8867
#define W7  4520
#define ROW_SHIFT 11
#define COL_SHIFT 20

/* 0: all entries 0, 1: only first entry nonzero, 2: otherwise  */
static inline int idct_row(int16_t *row)
{
    int a0, a1, a2, a3, b0, b1, b2, b3, t;
    uint64_t l, r, t2;
    l = ldq(row);
    r = ldq(row + 4);

    if (l == 0 && r == 0)
        return 0;

    a0 = W4 * sextw(l) + (1 << (ROW_SHIFT - 1));

    if (((l & ~0xffffUL) | r) == 0) {
        a0 >>= ROW_SHIFT;
        t2 = (uint16_t) a0;
        t2 |= t2 << 16;
        t2 |= t2 << 32;

        stq(t2, row);
        stq(t2, row + 4);
        return 1;
    }

    a1 = a0;
    a2 = a0;
    a3 = a0;

    t = extwl(l, 4);            /* row[2] */
    if (t != 0) {
        t = sextw(t);
        a0 += W2 * t;
        a1 += W6 * t;
        a2 -= W6 * t;
        a3 -= W2 * t;
    }

    t = extwl(r, 0);            /* row[4] */
    if (t != 0) {
        t = sextw(t);
        a0 += W4 * t;
        a1 -= W4 * t;
        a2 -= W4 * t;
        a3 += W4 * t;
    }

    t = extwl(r, 4);            /* row[6] */
    if (t != 0) {
        t = sextw(t);
        a0 += W6 * t;
        a1 -= W2 * t;
        a2 += W2 * t;
        a3 -= W6 * t;
    }

    t = extwl(l, 2);            /* row[1] */
    if (t != 0) {
        t = sextw(t);
        b0 = W1 * t;
        b1 = W3 * t;
        b2 = W5 * t;
        b3 = W7 * t;
    } else {
        b0 = 0;
        b1 = 0;
        b2 = 0;
        b3 = 0;
    }

    t = extwl(l, 6);            /* row[3] */
    if (t) {
        t = sextw(t);
        b0 += W3 * t;
        b1 -= W7 * t;
        b2 -= W1 * t;
        b3 -= W5 * t;
    }


    t = extwl(r, 2);            /* row[5] */
    if (t) {
        t = sextw(t);
        b0 += W5 * t;
        b1 -= W1 * t;
        b2 += W7 * t;
        b3 += W3 * t;
    }

    t = extwl(r, 6);            /* row[7] */
    if (t) {
        t = sextw(t);
        b0 += W7 * t;
        b1 -= W5 * t;
        b2 += W3 * t;
        b3 -= W1 * t;
    }

    row[0] = (a0 + b0) >> ROW_SHIFT;
    row[1] = (a1 + b1) >> ROW_SHIFT;
    row[2] = (a2 + b2) >> ROW_SHIFT;
    row[3] = (a3 + b3) >> ROW_SHIFT;
    row[4] = (a3 - b3) >> ROW_SHIFT;
    row[5] = (a2 - b2) >> ROW_SHIFT;
    row[6] = (a1 - b1) >> ROW_SHIFT;
    row[7] = (a0 - b0) >> ROW_SHIFT;

    return 2;
}

static inline void idct_col(int16_t *col)
{
    int a0, a1, a2, a3, b0, b1, b2, b3;

    col[0] += (1 << (COL_SHIFT - 1)) / W4;

    a0 = W4 * col[8 * 0];
    a1 = W4 * col[8 * 0];
    a2 = W4 * col[8 * 0];
    a3 = W4 * col[8 * 0];

    if (col[8 * 2]) {
        a0 += W2 * col[8 * 2];
        a1 += W6 * col[8 * 2];
        a2 -= W6 * col[8 * 2];
        a3 -= W2 * col[8 * 2];
    }

    if (col[8 * 4]) {
        a0 += W4 * col[8 * 4];
        a1 -= W4 * col[8 * 4];
        a2 -= W4 * col[8 * 4];
        a3 += W4 * col[8 * 4];
    }

    if (col[8 * 6]) {
        a0 += W6 * col[8 * 6];
        a1 -= W2 * col[8 * 6];
        a2 += W2 * col[8 * 6];
        a3 -= W6 * col[8 * 6];
    }

    if (col[8 * 1]) {
        b0 = W1 * col[8 * 1];
        b1 = W3 * col[8 * 1];
        b2 = W5 * col[8 * 1];
        b3 = W7 * col[8 * 1];
    } else {
        b0 = 0;
        b1 = 0;
        b2 = 0;
        b3 = 0;
    }

    if (col[8 * 3]) {
        b0 += W3 * col[8 * 3];
        b1 -= W7 * col[8 * 3];
        b2 -= W1 * col[8 * 3];
        b3 -= W5 * col[8 * 3];
    }

    if (col[8 * 5]) {
        b0 += W5 * col[8 * 5];
        b1 -= W1 * col[8 * 5];
        b2 += W7 * col[8 * 5];
        b3 += W3 * col[8 * 5];
    }

    if (col[8 * 7]) {
        b0 += W7 * col[8 * 7];
        b1 -= W5 * col[8 * 7];
        b2 += W3 * col[8 * 7];
        b3 -= W1 * col[8 * 7];
    }

    col[8 * 0] = (a0 + b0) >> COL_SHIFT;
    col[8 * 7] = (a0 - b0) >> COL_SHIFT;
    col[8 * 1] = (a1 + b1) >> COL_SHIFT;
    col[8 * 6] = (a1 - b1) >> COL_SHIFT;
    col[8 * 2] = (a2 + b2) >> COL_SHIFT;
    col[8 * 5] = (a2 - b2) >> COL_SHIFT;
    col[8 * 3] = (a3 + b3) >> COL_SHIFT;
    col[8 * 4] = (a3 - b3) >> COL_SHIFT;
}

/* If all rows but the first one are zero after row transformation,
   all rows will be identical after column transformation.  */
static inline void idct_col2(int16_t *col)
{
    int i;
    uint64_t l, r;

    for (i = 0; i < 8; ++i) {
        int a0 = col[i] + (1 << (COL_SHIFT - 1)) / W4;

        a0 *= W4;
        col[i] = a0 >> COL_SHIFT;
    }

    l = ldq(col + 0 * 4); r = ldq(col + 1 * 4);
    stq(l, col +  2 * 4); stq(r, col +  3 * 4);
    stq(l, col +  4 * 4); stq(r, col +  5 * 4);
    stq(l, col +  6 * 4); stq(r, col +  7 * 4);
    stq(l, col +  8 * 4); stq(r, col +  9 * 4);
    stq(l, col + 10 * 4); stq(r, col + 11 * 4);
    stq(l, col + 12 * 4); stq(r, col + 13 * 4);
    stq(l, col + 14 * 4); stq(r, col + 15 * 4);
}

void ff_simple_idct_axp(int16_t *block)
{

    int i;
    int rowsZero = 1;           /* all rows except row 0 zero */
    int rowsConstant = 1;       /* all rows consist of a constant value */

    for (i = 0; i < 8; i++) {
        int sparseness = idct_row(block + 8 * i);

        if (i > 0 && sparseness > 0)
            rowsZero = 0;
        if (sparseness == 2)
            rowsConstant = 0;
    }

    if (rowsZero) {
        idct_col2(block);
    } else if (rowsConstant) {
        idct_col(block);
        for (i = 0; i < 8; i += 2) {
            uint64_t v = (uint16_t) block[0];
            uint64_t w = (uint16_t) block[8];

            v |= v << 16;
            w |= w << 16;
            v |= v << 32;
            w |= w << 32;
            stq(v, block + 0 * 4);
            stq(v, block + 1 * 4);
            stq(w, block + 2 * 4);
            stq(w, block + 3 * 4);
            block += 4 * 4;
        }
    } else {
        for (i = 0; i < 8; i++)
            idct_col(block + i);
    }
}

void ff_simple_idct_put_axp(uint8_t *dest, int line_size, int16_t *block)
{
    ff_simple_idct_axp(block);
    put_pixels_clamped_axp_p(block, dest, line_size);
}

void ff_simple_idct_add_axp(uint8_t *dest, int line_size, int16_t *block)
{
    ff_simple_idct_axp(block);
    add_pixels_clamped_axp_p(block, dest, line_size);
}
Commit	Line	Data
2ba45a60 DM	1	/*
	2	* Simple IDCT (Alpha optimized)
	3	*
	4	* Copyright (c) 2001 Michael Niedermayer <michaelni@gmx.at>
	5	*
	6	* based upon some outcommented C code from mpeg2dec (idct_mmx.c
	7	* written by Aaron Holtzman <aholtzma@ess.engr.uvic.ca>)
	8	*
	9	* Alpha optimizations by Måns Rullgård <mans@mansr.com>
	10	* and Falk Hueffner <falk@debian.org>
	11	*
	12	* This file is part of FFmpeg.
	13	*
	14	* FFmpeg is free software; you can redistribute it and/or
	15	* modify it under the terms of the GNU Lesser General Public
	16	* License as published by the Free Software Foundation; either
	17	* version 2.1 of the License, or (at your option) any later version.
	18	*
	19	* FFmpeg is distributed in the hope that it will be useful,
	20	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	21	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	22	* Lesser General Public License for more details.
	23	*
	24	* You should have received a copy of the GNU Lesser General Public
	25	* License along with FFmpeg; if not, write to the Free Software
	26	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
	27	*/
	28
	29	#include "idctdsp_alpha.h"
	30	#include "asm.h"
	31
	32	// cos(i * M_PI / 16) * sqrt(2) * (1 << 14)
	33	// W4 is actually exactly 16384, but using 16383 works around
	34	// accumulating rounding errors for some encoders
	35	#define W1 22725
	36	#define W2 21407
	37	#define W3 19266
	38	#define W4 16383
	39	#define W5 12873
	40	#define W6 8867
	41	#define W7 4520
	42	#define ROW_SHIFT 11
	43	#define COL_SHIFT 20
	44
	45	/* 0: all entries 0, 1: only first entry nonzero, 2: otherwise */
	46	static inline int idct_row(int16_t *row)
	47	{
	48	int a0, a1, a2, a3, b0, b1, b2, b3, t;
	49	uint64_t l, r, t2;
	50	l = ldq(row);
	51	r = ldq(row + 4);
	52
	53	if (l == 0 && r == 0)
	54	return 0;
	55
	56	a0 = W4 * sextw(l) + (1 << (ROW_SHIFT - 1));
	57
	58	if (((l & ~0xffffUL) \| r) == 0) {
	59	a0 >>= ROW_SHIFT;
	60	t2 = (uint16_t) a0;
	61	t2 \|= t2 << 16;
	62	t2 \|= t2 << 32;
	63
	64	stq(t2, row);
65	stq(t2, row + 4);
66	return 1;
67	}
68
69	a1 = a0;
70	a2 = a0;
71	a3 = a0;
72
73	t = extwl(l, 4); /* row[2] */
74	if (t != 0) {
75	t = sextw(t);
76	a0 += W2 * t;
77	a1 += W6 * t;
78	a2 -= W6 * t;
79	a3 -= W2 * t;
80	}
81
82	t = extwl(r, 0); /* row[4] */
83	if (t != 0) {
84	t = sextw(t);
85	a0 += W4 * t;
86	a1 -= W4 * t;
87	a2 -= W4 * t;
88	a3 += W4 * t;
89	}
90
91	t = extwl(r, 4); /* row[6] */
92	if (t != 0) {
93	t = sextw(t);
94	a0 += W6 * t;
95	a1 -= W2 * t;
96	a2 += W2 * t;
97	a3 -= W6 * t;
98	}
99
100	t = extwl(l, 2); /* row[1] */
101	if (t != 0) {
102	t = sextw(t);
103	b0 = W1 * t;
104	b1 = W3 * t;
105	b2 = W5 * t;
106	b3 = W7 * t;
107	} else {
108	b0 = 0;
109	b1 = 0;
110	b2 = 0;
111	b3 = 0;
112	}
113
114	t = extwl(l, 6); /* row[3] */
115	if (t) {
116	t = sextw(t);
117	b0 += W3 * t;
118	b1 -= W7 * t;
119	b2 -= W1 * t;
120	b3 -= W5 * t;
121	}
122
123
124	t = extwl(r, 2); /* row[5] */
125	if (t) {
126	t = sextw(t);
127	b0 += W5 * t;
128	b1 -= W1 * t;
129	b2 += W7 * t;
130	b3 += W3 * t;
131	}
132
133	t = extwl(r, 6); /* row[7] */
134	if (t) {
135	t = sextw(t);
136	b0 += W7 * t;
137	b1 -= W5 * t;
138	b2 += W3 * t;
139	b3 -= W1 * t;
140	}
141
142	row[0] = (a0 + b0) >> ROW_SHIFT;
143	row[1] = (a1 + b1) >> ROW_SHIFT;
144	row[2] = (a2 + b2) >> ROW_SHIFT;
145	row[3] = (a3 + b3) >> ROW_SHIFT;
146	row[4] = (a3 - b3) >> ROW_SHIFT;
147	row[5] = (a2 - b2) >> ROW_SHIFT;
148	row[6] = (a1 - b1) >> ROW_SHIFT;
149	row[7] = (a0 - b0) >> ROW_SHIFT;
150
151	return 2;
152	}
153
154	static inline void idct_col(int16_t *col)
155	{
156	int a0, a1, a2, a3, b0, b1, b2, b3;
157
158	col[0] += (1 << (COL_SHIFT - 1)) / W4;
159
160	a0 = W4 * col[8 * 0];
161	a1 = W4 * col[8 * 0];
162	a2 = W4 * col[8 * 0];
163	a3 = W4 * col[8 * 0];
164
165	if (col[8 * 2]) {
166	a0 += W2 * col[8 * 2];
167	a1 += W6 * col[8 * 2];
168	a2 -= W6 * col[8 * 2];
169	a3 -= W2 * col[8 * 2];
170	}
171
172	if (col[8 * 4]) {
173	a0 += W4 * col[8 * 4];
174	a1 -= W4 * col[8 * 4];
175	a2 -= W4 * col[8 * 4];
176	a3 += W4 * col[8 * 4];
177	}
178
179	if (col[8 * 6]) {
180	a0 += W6 * col[8 * 6];
181	a1 -= W2 * col[8 * 6];
182	a2 += W2 * col[8 * 6];
183	a3 -= W6 * col[8 * 6];
184	}
185
186	if (col[8 * 1]) {
187	b0 = W1 * col[8 * 1];
188	b1 = W3 * col[8 * 1];
189	b2 = W5 * col[8 * 1];
190	b3 = W7 * col[8 * 1];
191	} else {
192	b0 = 0;
193	b1 = 0;
194	b2 = 0;
195	b3 = 0;
196	}
197
198	if (col[8 * 3]) {
199	b0 += W3 * col[8 * 3];
200	b1 -= W7 * col[8 * 3];
201	b2 -= W1 * col[8 * 3];
202	b3 -= W5 * col[8 * 3];
203	}
204
205	if (col[8 * 5]) {
206	b0 += W5 * col[8 * 5];
207	b1 -= W1 * col[8 * 5];
208	b2 += W7 * col[8 * 5];
209	b3 += W3 * col[8 * 5];
210	}
211
212	if (col[8 * 7]) {
213	b0 += W7 * col[8 * 7];
214	b1 -= W5 * col[8 * 7];
215	b2 += W3 * col[8 * 7];
216	b3 -= W1 * col[8 * 7];
217	}
218
219	col[8 * 0] = (a0 + b0) >> COL_SHIFT;
220	col[8 * 7] = (a0 - b0) >> COL_SHIFT;
221	col[8 * 1] = (a1 + b1) >> COL_SHIFT;
222	col[8 * 6] = (a1 - b1) >> COL_SHIFT;
223	col[8 * 2] = (a2 + b2) >> COL_SHIFT;
224	col[8 * 5] = (a2 - b2) >> COL_SHIFT;
225	col[8 * 3] = (a3 + b3) >> COL_SHIFT;
226	col[8 * 4] = (a3 - b3) >> COL_SHIFT;
227	}
228
229	/* If all rows but the first one are zero after row transformation,
230	all rows will be identical after column transformation. */
231	static inline void idct_col2(int16_t *col)
232	{
233	int i;
234	uint64_t l, r;
235
236	for (i = 0; i < 8; ++i) {
237	int a0 = col[i] + (1 << (COL_SHIFT - 1)) / W4;
238
239	a0 *= W4;
240	col[i] = a0 >> COL_SHIFT;
241	}
242
243	l = ldq(col + 0 * 4); r = ldq(col + 1 * 4);
244	stq(l, col + 2 * 4); stq(r, col + 3 * 4);
245	stq(l, col + 4 * 4); stq(r, col + 5 * 4);
246	stq(l, col + 6 * 4); stq(r, col + 7 * 4);
247	stq(l, col + 8 * 4); stq(r, col + 9 * 4);
248	stq(l, col + 10 * 4); stq(r, col + 11 * 4);
249	stq(l, col + 12 * 4); stq(r, col + 13 * 4);
250	stq(l, col + 14 * 4); stq(r, col + 15 * 4);
251	}
252
253	void ff_simple_idct_axp(int16_t *block)
254	{
255
256	int i;
257	int rowsZero = 1; /* all rows except row 0 zero */
258	int rowsConstant = 1; /* all rows consist of a constant value */
259
260	for (i = 0; i < 8; i++) {
261	int sparseness = idct_row(block + 8 * i);
262
263	if (i > 0 && sparseness > 0)
264	rowsZero = 0;
265	if (sparseness == 2)
266	rowsConstant = 0;
267	}
268
269	if (rowsZero) {
270	idct_col2(block);
271	} else if (rowsConstant) {
272	idct_col(block);
273	for (i = 0; i < 8; i += 2) {
274	uint64_t v = (uint16_t) block[0];
275	uint64_t w = (uint16_t) block[8];
276
277	v \|= v << 16;
278	w \|= w << 16;
279	v \|= v << 32;
280	w \|= w << 32;
281	stq(v, block + 0 * 4);
282	stq(v, block + 1 * 4);
283	stq(w, block + 2 * 4);
284	stq(w, block + 3 * 4);
285	block += 4 * 4;
286	}
287	} else {
288	for (i = 0; i < 8; i++)
289	idct_col(block + i);
290	}
291	}
292
293	void ff_simple_idct_put_axp(uint8_t dest, int line_size, int16_t block)
294	{
295	ff_simple_idct_axp(block);
296	put_pixels_clamped_axp_p(block, dest, line_size);
297	}
298
299	void ff_simple_idct_add_axp(uint8_t dest, int line_size, int16_t block)
300	{
301	ff_simple_idct_axp(block);
302	add_pixels_clamped_axp_p(block, dest, line_size);
303	}