Revision efb6836f
libavcodec/mpegidct.c  

1 
/* idct.c, inverse fast discrete cosine transform */ 

2  
3 
/* Copyright (C) 1996, MPEG Software Simulation Group. All Rights Reserved. */ 

4  
5 
/* 

6 
* Disclaimer of Warranty 

7 
* 

8 
* These software programs are available to the user without any license fee or 

9 
* royalty on an "as is" basis. The MPEG Software Simulation Group disclaims 

10 
* any and all warranties, whether express, implied, or statuary, including any 

11 
* implied warranties or merchantability or of fitness for a particular 

12 
* purpose. In no event shall the copyrightholder be liable for any 

13 
* incidental, punitive, or consequential damages of any kind whatsoever 

14 
* arising from the use of these programs. 

15 
* 

16 
* This disclaimer of warranty extends to the user of these programs and user's 

17 
* customers, employees, agents, transferees, successors, and assigns. 

18 
* 

19 
* The MPEG Software Simulation Group does not represent or warrant that the 

20 
* programs furnished hereunder are free of infringement of any thirdparty 

21 
* patents. 

22 
* 

23 
* Commercial implementations of MPEG1 and MPEG2 video, including shareware, 

24 
* are subject to royalty fees to patent holders. Many of these patents are 

25 
* general enough such that they are unavoidable regardless of implementation 

26 
* design. 

27 
* 

28 
*/ 

29  
30 
/**********************************************************/ 

31 
/* inverse two dimensional DCT, ChenWang algorithm */ 

32 
/* (cf. IEEE ASSP32, pp. 803816, Aug. 1984) */ 

33 
/* 32bit integer arithmetic (8 bit coefficients) */ 

34 
/* 11 mults, 29 adds per DCT */ 

35 
/* sE, 18.8.91 */ 

36 
/**********************************************************/ 

37 
/* coefficients extended to 12 bit for IEEE11801990 */ 

38 
/* compliance sE, 2.1.94 */ 

39 
/**********************************************************/ 

40  
41 
/* this code assumes >> to be a two'scomplement arithmetic */ 

42 
/* right shift: (2)>>1 == 1 , (3)>>1 == 2 */ 

43  
44 
#include "config.h" 

45  
46 
#define W1 2841 /* 2048*sqrt(2)*cos(1*pi/16) */ 

47 
#define W2 2676 /* 2048*sqrt(2)*cos(2*pi/16) */ 

48 
#define W3 2408 /* 2048*sqrt(2)*cos(3*pi/16) */ 

49 
#define W5 1609 /* 2048*sqrt(2)*cos(5*pi/16) */ 

50 
#define W6 1108 /* 2048*sqrt(2)*cos(6*pi/16) */ 

51 
#define W7 565 /* 2048*sqrt(2)*cos(7*pi/16) */ 

52  
53 
/* global declarations */ 

54 
void Initialize_Fast_IDCT _ANSI_ARGS_((void)); 

55 
void Fast_IDCT _ANSI_ARGS_((short *block)); 

56  
57 
/* private data */ 

58 
static short iclip[1024]; /* clipping table */ 

59 
static short *iclp; 

60  
61 
/* private prototypes */ 

62 
static void idctrow _ANSI_ARGS_((short *blk)); 

63 
static void idctcol _ANSI_ARGS_((short *blk)); 

64  
65 
/* row (horizontal) IDCT 

66 
* 

67 
* 7 pi 1 

68 
* dst[k] = sum c[l] * src[l] * cos(  * ( k +  ) * l ) 

69 
* l=0 8 2 

70 
* 

71 
* where: c[0] = 128 

72 
* c[1..7] = 128*sqrt(2) 

73 
*/ 

74  
75 
static void idctrow(blk) 

76 
short *blk; 

77 
{ 

78 
int x0, x1, x2, x3, x4, x5, x6, x7, x8; 

79  
80 
/* shortcut */ 

81 
if (!((x1 = blk[4]<<11)  (x2 = blk[6])  (x3 = blk[2])  

82 
(x4 = blk[1])  (x5 = blk[7])  (x6 = blk[5])  (x7 = blk[3]))) 

83 
{ 

84 
blk[0]=blk[1]=blk[2]=blk[3]=blk[4]=blk[5]=blk[6]=blk[7]=blk[0]<<3; 

85 
return; 

86 
} 

87  
88 
x0 = (blk[0]<<11) + 128; /* for proper rounding in the fourth stage */ 

89  
90 
/* first stage */ 

91 
x8 = W7*(x4+x5); 

92 
x4 = x8 + (W1W7)*x4; 

93 
x5 = x8  (W1+W7)*x5; 

94 
x8 = W3*(x6+x7); 

95 
x6 = x8  (W3W5)*x6; 

96 
x7 = x8  (W3+W5)*x7; 

97  
98 
/* second stage */ 

99 
x8 = x0 + x1; 

100 
x0 = x1; 

101 
x1 = W6*(x3+x2); 

102 
x2 = x1  (W2+W6)*x2; 

103 
x3 = x1 + (W2W6)*x3; 

104 
x1 = x4 + x6; 

105 
x4 = x6; 

106 
x6 = x5 + x7; 

107 
x5 = x7; 

108  
109 
/* third stage */ 

110 
x7 = x8 + x3; 

111 
x8 = x3; 

112 
x3 = x0 + x2; 

113 
x0 = x2; 

114 
x2 = (181*(x4+x5)+128)>>8; 

115 
x4 = (181*(x4x5)+128)>>8; 

116  
117 
/* fourth stage */ 

118 
blk[0] = (x7+x1)>>8; 

119 
blk[1] = (x3+x2)>>8; 

120 
blk[2] = (x0+x4)>>8; 

121 
blk[3] = (x8+x6)>>8; 

122 
blk[4] = (x8x6)>>8; 

123 
blk[5] = (x0x4)>>8; 

124 
blk[6] = (x3x2)>>8; 

125 
blk[7] = (x7x1)>>8; 

126 
} 

127  
128 
/* column (vertical) IDCT 

129 
* 

130 
* 7 pi 1 

131 
* dst[8*k] = sum c[l] * src[8*l] * cos(  * ( k +  ) * l ) 

132 
* l=0 8 2 

133 
* 

134 
* where: c[0] = 1/1024 

135 
* c[1..7] = (1/1024)*sqrt(2) 

136 
*/ 

137 
static void idctcol(blk) 

138 
short *blk; 

139 
{ 

140 
int x0, x1, x2, x3, x4, x5, x6, x7, x8; 

141  
142 
/* shortcut */ 

143 
if (!((x1 = (blk[8*4]<<8))  (x2 = blk[8*6])  (x3 = blk[8*2])  

144 
(x4 = blk[8*1])  (x5 = blk[8*7])  (x6 = blk[8*5])  (x7 = blk[8*3]))) 

145 
{ 

146 
blk[8*0]=blk[8*1]=blk[8*2]=blk[8*3]=blk[8*4]=blk[8*5]=blk[8*6]=blk[8*7]= 

147 
iclp[(blk[8*0]+32)>>6]; 

148 
return; 

149 
} 

150  
151 
x0 = (blk[8*0]<<8) + 8192; 

152  
153 
/* first stage */ 

154 
x8 = W7*(x4+x5) + 4; 

155 
x4 = (x8+(W1W7)*x4)>>3; 

156 
x5 = (x8(W1+W7)*x5)>>3; 

157 
x8 = W3*(x6+x7) + 4; 

158 
x6 = (x8(W3W5)*x6)>>3; 

159 
x7 = (x8(W3+W5)*x7)>>3; 

160  
161 
/* second stage */ 

162 
x8 = x0 + x1; 

163 
x0 = x1; 

164 
x1 = W6*(x3+x2) + 4; 

165 
x2 = (x1(W2+W6)*x2)>>3; 

166 
x3 = (x1+(W2W6)*x3)>>3; 

167 
x1 = x4 + x6; 

168 
x4 = x6; 

169 
x6 = x5 + x7; 

170 
x5 = x7; 

171  
172 
/* third stage */ 

173 
x7 = x8 + x3; 

174 
x8 = x3; 

175 
x3 = x0 + x2; 

176 
x0 = x2; 

177 
x2 = (181*(x4+x5)+128)>>8; 

178 
x4 = (181*(x4x5)+128)>>8; 

179  
180 
/* fourth stage */ 

181 
blk[8*0] = iclp[(x7+x1)>>14]; 

182 
blk[8*1] = iclp[(x3+x2)>>14]; 

183 
blk[8*2] = iclp[(x0+x4)>>14]; 

184 
blk[8*3] = iclp[(x8+x6)>>14]; 

185 
blk[8*4] = iclp[(x8x6)>>14]; 

186 
blk[8*5] = iclp[(x0x4)>>14]; 

187 
blk[8*6] = iclp[(x3x2)>>14]; 

188 
blk[8*7] = iclp[(x7x1)>>14]; 

189 
} 

190  
191 
/* two dimensional inverse discrete cosine transform */ 

192 
void Fast_IDCT(block) 

193 
short *block; 

194 
{ 

195 
int i; 

196  
197 
for (i=0; i<8; i++) 

198 
idctrow(block+8*i); 

199  
200 
for (i=0; i<8; i++) 

201 
idctcol(block+i); 

202 
} 

203  
204 
void Initialize_Fast_IDCT() 

205 
{ 

206 
int i; 

207  
208 
iclp = iclip+512; 

209 
for (i= 512; i<512; i++) 

210 
iclp[i] = (i<256) ? 256 : ((i>255) ? 255 : i); 

211 
} 
Also available in: Unified diff