ffmpeg / libavcodec / armv4l / mpegvideo_armv5te.c @ be449fca
History  View  Annotate  Download (7.62 KB)
1 
/*


2 
* Optimization of some functions from mpegvideo.c for armv5te

3 
* Copyright (c) 2007 Siarhei Siamashka <ssvb@users.sourceforge.net>

4 
*

5 
* This file is part of FFmpeg.

6 
*

7 
* FFmpeg 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 
* FFmpeg 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 FFmpeg; if not, write to the Free Software

19 
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 021101301 USA

20 
*/

21  
22 
#include "libavcodec/avcodec.h" 
23 
#include "libavcodec/dsputil.h" 
24 
#include "libavcodec/mpegvideo.h" 
25  
26  
27 
#ifdef ENABLE_ARM_TESTS

28 
/**

29 
* h263 dequantizer supplementary function, it is performance critical and needs to

30 
* have optimized implementations for each architecture. Is also used as a reference

31 
* implementation in regression tests

32 
*/

33 
static inline void dct_unquantize_h263_helper_c(DCTELEM *block, int qmul, int qadd, int count) 
34 
{ 
35 
int i, level;

36 
for (i = 0; i < count; i++) { 
37 
level = block[i]; 
38 
if (level) {

39 
if (level < 0) { 
40 
level = level * qmul  qadd; 
41 
} else {

42 
level = level * qmul + qadd; 
43 
} 
44 
block[i] = level; 
45 
} 
46 
} 
47 
} 
48 
#endif

49  
50 
/* GCC 3.1 or higher is required to support symbolic names in assembly code */

51 
#if (__GNUC__ > 3)  ((__GNUC__ == 3) && (__GNUC_MINOR__ >= 1)) 
52  
53 
/**

54 
* Special optimized version of dct_unquantize_h263_helper_c, it requires the block

55 
* to be at least 8 bytes aligned, and may process more elements than requested.

56 
* But it is guaranteed to never process more than 64 elements provided that

57 
* xxcount argument is <= 64, so it is safe. This macro is optimized for a common

58 
* distribution of values for nCoeffs (they are mostly multiple of 8 plus one or

59 
* two extra elements). So this macro processes data as 8 elements per loop iteration

60 
* and contains optional 2 elements processing in the end.

61 
*

62 
* Inner loop should take 6 cycles per element on arm926ejs (Nokia 770)

63 
*/

64 
#define dct_unquantize_h263_special_helper_armv5te(xxblock, xxqmul, xxqadd, xxcount) \

65 
({ DCTELEM *xblock = xxblock; \ 
66 
int xqmul = xxqmul, xqadd = xxqadd, xcount = xxcount, xtmp; \

67 
int xdata1, xdata2; \

68 
__asm__ volatile( \

69 
"subs %[count], %[count], #2 \n\t" \

70 
"ble 2f \n\t" \

71 
"ldrd r4, [%[block], #0] \n\t" \

72 
"1: \n\t" \

73 
"ldrd r6, [%[block], #8] \n\t" \

74 
\ 
75 
"rsbs %[data1], %[zero], r4, asr #16 \n\t" \

76 
"addgt %[data1], %[qadd], #0 \n\t" \

77 
"rsblt %[data1], %[qadd], #0 \n\t" \

78 
"smlatbne %[data1], r4, %[qmul], %[data1] \n\t" \

79 
\ 
80 
"rsbs %[data2], %[zero], r5, asr #16 \n\t" \

81 
"addgt %[data2], %[qadd], #0 \n\t" \

82 
"rsblt %[data2], %[qadd], #0 \n\t" \

83 
"smlatbne %[data2], r5, %[qmul], %[data2] \n\t" \

84 
\ 
85 
"rsbs %[tmp], %[zero], r4, asl #16 \n\t" \

86 
"addgt %[tmp], %[qadd], #0 \n\t" \

87 
"rsblt %[tmp], %[qadd], #0 \n\t" \

88 
"smlabbne r4, r4, %[qmul], %[tmp] \n\t" \

89 
\ 
90 
"rsbs %[tmp], %[zero], r5, asl #16 \n\t" \

91 
"addgt %[tmp], %[qadd], #0 \n\t" \

92 
"rsblt %[tmp], %[qadd], #0 \n\t" \

93 
"smlabbne r5, r5, %[qmul], %[tmp] \n\t" \

94 
\ 
95 
"strh r4, [%[block]], #2 \n\t" \

96 
"strh %[data1], [%[block]], #2 \n\t" \

97 
"strh r5, [%[block]], #2 \n\t" \

98 
"strh %[data2], [%[block]], #2 \n\t" \

99 
\ 
100 
"rsbs %[data1], %[zero], r6, asr #16 \n\t" \

101 
"addgt %[data1], %[qadd], #0 \n\t" \

102 
"rsblt %[data1], %[qadd], #0 \n\t" \

103 
"smlatbne %[data1], r6, %[qmul], %[data1] \n\t" \

104 
\ 
105 
"rsbs %[data2], %[zero], r7, asr #16 \n\t" \

106 
"addgt %[data2], %[qadd], #0 \n\t" \

107 
"rsblt %[data2], %[qadd], #0 \n\t" \

108 
"smlatbne %[data2], r7, %[qmul], %[data2] \n\t" \

109 
\ 
110 
"rsbs %[tmp], %[zero], r6, asl #16 \n\t" \

111 
"addgt %[tmp], %[qadd], #0 \n\t" \

112 
"rsblt %[tmp], %[qadd], #0 \n\t" \

113 
"smlabbne r6, r6, %[qmul], %[tmp] \n\t" \

114 
\ 
115 
"rsbs %[tmp], %[zero], r7, asl #16 \n\t" \

116 
"addgt %[tmp], %[qadd], #0 \n\t" \

117 
"rsblt %[tmp], %[qadd], #0 \n\t" \

118 
"smlabbne r7, r7, %[qmul], %[tmp] \n\t" \

119 
\ 
120 
"strh r6, [%[block]], #2 \n\t" \

121 
"strh %[data1], [%[block]], #2 \n\t" \

122 
"strh r7, [%[block]], #2 \n\t" \

123 
"strh %[data2], [%[block]], #2 \n\t" \

124 
\ 
125 
"subs %[count], %[count], #8 \n\t" \

126 
"ldrgtd r4, [%[block], #0] \n\t" /* load data early to avoid load/use pipeline stall */ \ 
127 
"bgt 1b \n\t" \

128 
\ 
129 
"adds %[count], %[count], #2 \n\t" \

130 
"ble 3f \n\t" \

131 
"2: \n\t" \

132 
"ldrsh %[data1], [%[block], #0] \n\t" \

133 
"ldrsh %[data2], [%[block], #2] \n\t" \

134 
"mov %[tmp], %[qadd] \n\t" \

135 
"cmp %[data1], #0 \n\t" \

136 
"rsblt %[tmp], %[qadd], #0 \n\t" \

137 
"smlabbne %[data1], %[data1], %[qmul], %[tmp] \n\t" \

138 
"mov %[tmp], %[qadd] \n\t" \

139 
"cmp %[data2], #0 \n\t" \

140 
"rsblt %[tmp], %[qadd], #0 \n\t" \

141 
"smlabbne %[data2], %[data2], %[qmul], %[tmp] \n\t" \

142 
"strh %[data1], [%[block]], #2 \n\t" \

143 
"strh %[data2], [%[block]], #2 \n\t" \

144 
"3: \n\t" \

145 
: [block] "+&r" (xblock), [count] "+&r" (xcount), [tmp] "=&r" (xtmp), \ 
146 
[data1] "=&r" (xdata1), [data2] "=&r" (xdata2) \ 
147 
: [qmul] "r" (xqmul), [qadd] "r" (xqadd), [zero] "r" (0) \ 
148 
: "r4", "r5", "r6", "r7", "cc", "memory" \ 
149 
); \ 
150 
}) 
151  
152 
static void dct_unquantize_h263_intra_armv5te(MpegEncContext *s, 
153 
DCTELEM *block, int n, int qscale) 
154 
{ 
155 
int level, qmul, qadd;

156 
int nCoeffs;

157  
158 
assert(s>block_last_index[n]>=0);

159  
160 
qmul = qscale << 1;

161  
162 
if (!s>h263_aic) {

163 
if (n < 4) 
164 
level = block[0] * s>y_dc_scale;

165 
else

166 
level = block[0] * s>c_dc_scale;

167 
qadd = (qscale  1)  1; 
168 
}else{

169 
qadd = 0;

170 
level = block[0];

171 
} 
172 
if(s>ac_pred)

173 
nCoeffs=63;

174 
else

175 
nCoeffs= s>inter_scantable.raster_end[ s>block_last_index[n] ]; 
176  
177 
dct_unquantize_h263_special_helper_armv5te(block, qmul, qadd, nCoeffs + 1);

178 
block[0] = level;

179 
} 
180  
181 
static void dct_unquantize_h263_inter_armv5te(MpegEncContext *s, 
182 
DCTELEM *block, int n, int qscale) 
183 
{ 
184 
int qmul, qadd;

185 
int nCoeffs;

186  
187 
assert(s>block_last_index[n]>=0);

188  
189 
qadd = (qscale  1)  1; 
190 
qmul = qscale << 1;

191  
192 
nCoeffs= s>inter_scantable.raster_end[ s>block_last_index[n] ]; 
193  
194 
dct_unquantize_h263_special_helper_armv5te(block, qmul, qadd, nCoeffs + 1);

195 
} 
196  
197 
#define HAVE_DCT_UNQUANTIZE_H263_ARMV5TE_OPTIMIZED

198  
199 
#endif

200  
201 
void MPV_common_init_armv5te(MpegEncContext *s)

202 
{ 
203 
#ifdef HAVE_DCT_UNQUANTIZE_H263_ARMV5TE_OPTIMIZED

204 
s>dct_unquantize_h263_intra = dct_unquantize_h263_intra_armv5te; 
205 
s>dct_unquantize_h263_inter = dct_unquantize_h263_inter_armv5te; 
206 
#endif

207 
} 