FFmpeg: libavcodec/intrax8dsp.c Source File

FFmpeg

[フレーム]

libavcodec

intrax8dsp.c

Go to the documentation of this file.

1 /*

2 * This file is part of FFmpeg.

3 *

4 * FFmpeg is free software; you can redistribute it and/or

5 * modify it under the terms of the GNU Lesser General Public

6 * License as published by the Free Software Foundation; either

7 * version 2.1 of the License, or (at your option) any later version.

8 *

9 * FFmpeg is distributed in the hope that it will be useful,

10 * but WITHOUT ANY WARRANTY; without even the implied warranty of

11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

12 * Lesser General Public License for more details.

13 *

14 * You should have received a copy of the GNU Lesser General Public

15 * License along with FFmpeg; if not, write to the Free Software

16 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

17 */

19 /**

20 * @file

21 *@brief IntraX8 frame subdecoder image manipulation routines

22 */

24 #include "intrax8dsp.h"

25 #include "libavutil/common.h"

27 /*

28 area positions, #3 is 1 pixel only, other are 8 pixels

29 |66666666|

30 3|44444444|55555555|

31 - -+--------+--------+

32 1 2|XXXXXXXX|

33 1 2|XXXXXXXX|

34 1 2|XXXXXXXX|

35 1 2|XXXXXXXX|

36 1 2|XXXXXXXX|

37 1 2|XXXXXXXX|

38 1 2|XXXXXXXX|

39 1 2|XXXXXXXX|

40 ^-start

41 */

43 #define area1 (0)

44 #define area2 (8)

45 #define area3 (8+8)

46 #define area4 (8+8+1)

47 #define area5 (8+8+1+8)

48 #define area6 (8+8+1+16)

50 /**

51 Collect statistics and prepare the edge pixels required by the other spatial compensation functions.

53 * @param src pointer to the beginning of the processed block

54 * @param dst pointer to emu_edge, edge pixels are stored the way other compensation routines do.

55 * @param linesize byte offset between 2 vertical pixels in the source image

56 * @param range pointer to the variable where the edge pixel range is to be stored (max-min values)

57 * @param psum pointer to the variable where the edge pixel sum is to be stored

58 * @param edges Informs this routine that the block is on an image border, so it has to interpolate the missing edge pixels.

59 and some of the edge pixels should be interpolated, the flag has the following meaning:

60 1 - mb_x==0 - first block in the row, interpolate area #1,#2,#3;

61 2 - mb_y==0 - first row, interpolate area #3,#4,#5,#6;

62 note: 1|2 - mb_x==mb_y==0 - first block, use 0x80 value for all areas;

63 4 - mb_x>= (mb_width-1) last block in the row, interpolate area #5;

64 */

65 static void x8_setup_spatial_compensation(uint8_t *src, uint8_t *dst, int linesize,

66 int * range, int * psum, int edges){

67 uint8_t * ptr;

68 int sum;

69 int i;

70 int min_pix,max_pix;

71 uint8_t c;

73 if((edges&3)==3){

74 *psum=0x80*(8+1+8+2);

75 *range=0;

76 memset(dst,0x80,16+1+16+8);

77 //this triggers flat_dc for sure.

78 //flat_dc avoids all (other) prediction modes, but requires dc_level decoding.

79 return;

80 }

82 min_pix=256;

83 max_pix=-1;

85 sum=0;

87 if(!(edges&1)){//(mb_x!=0)//there is previous block on this row

88 ptr=src-1;//left column, area 2

89 for(i=7;i>=0;i--){

90 c=*(ptr-1);//area1, same mb as area2, no need to check

91 dst[area1+i]=c;

92 c=*(ptr);

94 sum+=c;

95 min_pix=FFMIN(min_pix,c);

96 max_pix=FFMAX(max_pix,c);

97 dst[area2+i]=c;

99 ptr+=linesize;

100 }

101 }

102

103 if(!(edges&2)){ //(mb_y!=0)//there is row above

104 ptr=src-linesize;//top line

105 for(i=0;i<8;i++){

106 c=*(ptr+i);

107 sum+=c;

108 min_pix=FFMIN(min_pix, c);

109 max_pix=FFMAX(max_pix, c);

110 }

111 if(edges&4){//last block on the row?

112 memset(dst+area5,c,8);//set with last pixel fr

113 memcpy(dst+area4, ptr, 8);

114 }else{

115 memcpy(dst+area4, ptr, 16);//both area4 and 5

116 }

117 memcpy(dst+area6, ptr-linesize, 8);//area6 always present in the above block

118 }

119 //now calculate the stuff we need

120 if(edges&3){//mb_x==0 || mb_y==0){

121 int avg=(sum+4)>>3;

122 if(edges&1){ //(mb_x==0) {//implies mb_y!=0

123 memset(dst+area1,avg,8+8+1);//areas 1,2 and 3 are averaged

124 }else{//implies y==0 x!=0

125 memset(dst+area3,avg, 1+16+8);//areas 3, 4,5,6

126 }

127 sum+=avg*9;

128 }else{

129 uint8_t c=*(src-1-linesize);//the edge pixel, in the top line and left column

130 dst[area3]=c;

131 sum+=c;

132 //edge pixel is not part of min/max

133 }

134 (*range) = max_pix - min_pix;

135 sum += *(dst+area5) + *(dst+area5+1);

136 *psum = sum;

137 }

138

139

140 static const uint16_t zero_prediction_weights[64*2] = {

141 640, 640, 669, 480, 708, 354, 748, 257, 792, 198, 760, 143, 808, 101, 772, 72,

142 480, 669, 537, 537, 598, 416, 661, 316, 719, 250, 707, 185, 768, 134, 745, 97,

143 354, 708, 416, 598, 488, 488, 564, 388, 634, 317, 642, 241, 716, 179, 706, 132,

144 257, 748, 316, 661, 388, 564, 469, 469, 543, 395, 571, 311, 655, 238, 660, 180,

145 198, 792, 250, 719, 317, 634, 395, 543, 469, 469, 507, 380, 597, 299, 616, 231,

146 161, 855, 206, 788, 266, 710, 340, 623, 411, 548, 455, 455, 548, 366, 576, 288,

147 122, 972, 159, 914, 211, 842, 276, 758, 341, 682, 389, 584, 483, 483, 520, 390,

148 110, 1172, 144, 1107, 193, 1028, 254, 932, 317, 846, 366, 731, 458, 611, 499, 499

149 };

150

151 static void spatial_compensation_0(uint8_t *src , uint8_t *dst, int linesize){

152 int i,j;

153 int x,y;

154 unsigned int p;//power divided by 2

155 int a;

156 uint16_t left_sum[2][8] = { { 0 } };

157 uint16_t top_sum[2][8] = { { 0 } };

158

159 for(i=0;i<8;i++){

160 a=src[area2+7-i]<<4;

161 for(j=0;j<8;j++){

162 p=abs(i-j);

163 left_sum[p&1][j]+= a>>(p>>1);

164 }

165 }

166

167 for(i=0;i<8;i++){

168 a=src[area4+i]<<4;

169 for(j=0;j<8;j++){

170 p=abs(i-j);

171 top_sum[p&1][j]+= a>>(p>>1);

172 }

173 }

174 for(;i<10;i++){

175 a=src[area4+i]<<4;

176 for(j=5;j<8;j++){

177 p=abs(i-j);

178 top_sum[p&1][j]+= a>>(p>>1);

179 }

180 }

181 for(;i<12;i++){

182 a=src[area4+i]<<4;

183 for(j=7;j<8;j++){

184 p=abs(i-j);

185 top_sum[p&1][j]+= a>>(p>>1);

186 }

187 }

188

189 for(i=0;i<8;i++){

190 top_sum [0][i]+=(top_sum [1][i]*181 + 128 )>>8;//181 is sqrt(2)/2

191 left_sum[0][i]+=(left_sum[1][i]*181 + 128 )>>8;

192 }

193 for(y=0;y<8;y++){

194 for(x=0;x<8;x++){

195 dst[x] = (

196 (uint32_t)top_sum [0][x]*zero_prediction_weights[y*16+x*2+0] +

197 (uint32_t)left_sum[0][y]*zero_prediction_weights[y*16+x*2+1] +

198 0x8000

199 )>>16;

200 }

201 dst+=linesize;

202 }

203 }

204 static void spatial_compensation_1(uint8_t *src , uint8_t *dst, int linesize){

205 int x,y;

206

207 for(y=0;y<8;y++){

208 for(x=0;x<8;x++){

209 dst[x]=src[area4 + FFMIN(2*y+x+2, 15) ];

210 }

211 dst+=linesize;

212 }

213 }

214 static void spatial_compensation_2(uint8_t *src , uint8_t *dst, int linesize){

215 int x,y;

216

217 for(y=0;y<8;y++){

218 for(x=0;x<8;x++){

219 dst[x]=src[area4 +1+y+x];

220 }

221 dst+=linesize;

222 }

223 }

224 static void spatial_compensation_3(uint8_t *src , uint8_t *dst, int linesize){

225 int x,y;

226

227 for(y=0;y<8;y++){

228 for(x=0;x<8;x++){

229 dst[x]=src[area4 +((y+1)>>1)+x];

230 }

231 dst+=linesize;

232 }

233 }

234 static void spatial_compensation_4(uint8_t *src , uint8_t *dst, int linesize){

235 int x,y;

236

237 for(y=0;y<8;y++){

238 for(x=0;x<8;x++){

239 dst[x]=( src[area4+x] + src[area6+x] + 1 )>>1;

240 }

241 dst+=linesize;

242 }

243 }

244 static void spatial_compensation_5(uint8_t *src , uint8_t *dst, int linesize){

245 int x,y;

246

247 for(y=0;y<8;y++){

248 for(x=0;x<8;x++){

249 if(2*x-y<0){

250 dst[x]=src[area2+9+2*x-y];

251 }else{

252 dst[x]=src[area4 +x-((y+1)>>1)];

253 }

254 }

255 dst+=linesize;

256 }

257 }

258 static void spatial_compensation_6(uint8_t *src , uint8_t *dst, int linesize){

259 int x,y;

260

261 for(y=0;y<8;y++){

262 for(x=0;x<8;x++){

263 dst[x]=src[area3+x-y];

264 }

265 dst+=linesize;

266 }

267 }

268 static void spatial_compensation_7(uint8_t *src , uint8_t *dst, int linesize){

269 int x,y;

270

271 for(y=0;y<8;y++){

272 for(x=0;x<8;x++){

273 if(x-2*y>0){

274 dst[x]=( src[area3-1+x-2*y] + src[area3+x-2*y] + 1)>>1;

275 }else{

276 dst[x]=src[area2+8-y +(x>>1)];

277 }

278 }

279 dst+=linesize;

280 }

281 }

282 static void spatial_compensation_8(uint8_t *src , uint8_t *dst, int linesize){

283 int x,y;

284

285 for(y=0;y<8;y++){

286 for(x=0;x<8;x++){

287 dst[x]=( src[area1+7-y] + src[area2+7-y] + 1 )>>1;

288 }

289 dst+=linesize;

290 }

291 }

292 static void spatial_compensation_9(uint8_t *src , uint8_t *dst, int linesize){

293 int x,y;

294

295 for(y=0;y<8;y++){

296 for(x=0;x<8;x++){

297 dst[x]=src[area2+6-FFMIN(x+y,6)];

298 }

299 dst+=linesize;

300 }

301 }

302 static void spatial_compensation_10(uint8_t *src , uint8_t *dst, int linesize){

303 int x,y;

304

305 for(y=0;y<8;y++){

306 for(x=0;x<8;x++){

307 dst[x]=(src[area2+7-y]*(8-x)+src[area4+x]*x+4)>>3;

308 }

309 dst+=linesize;

310 }

311 }

312 static void spatial_compensation_11(uint8_t *src , uint8_t *dst, int linesize){

313 int x,y;

314

315 for(y=0;y<8;y++){

316 for(x=0;x<8;x++){

317 dst[x]=(src[area2+7-y]*y+src[area4+x]*(8-y)+4)>>3;

318 }

319 dst+=linesize;

320 }

321 }

322

323 static void x8_loop_filter(uint8_t * ptr, const int a_stride, const int b_stride, int quant){

324 int i,t;

325 int p0,p1,p2,p3,p4,p5,p6,p7,p8,p9;

326 int ql=(quant+10)>>3;

327

328 for(i=0; i<8; i++,ptr+=b_stride){

329 p0=ptr[-5*a_stride];

330 p1=ptr[-4*a_stride];

331 p2=ptr[-3*a_stride];

332 p3=ptr[-2*a_stride];

333 p4=ptr[-1*a_stride];

334 p5=ptr[ 0 ];

335 p6=ptr[ 1*a_stride];

336 p7=ptr[ 2*a_stride];

337 p8=ptr[ 3*a_stride];

338 p9=ptr[ 4*a_stride];

339

340 t=

341 (FFABS(p1-p2) <= ql) +

342 (FFABS(p2-p3) <= ql) +

343 (FFABS(p3-p4) <= ql) +

344 (FFABS(p4-p5) <= ql);

345 if(t>0){//You need at least 1 to be able to reach a total score of 6.

346 t+=

347 (FFABS(p5-p6) <= ql) +

348 (FFABS(p6-p7) <= ql) +

349 (FFABS(p7-p8) <= ql) +

350 (FFABS(p8-p9) <= ql) +

351 (FFABS(p0-p1) <= ql);

352 if(t>=6){

353 int min,max;

354

355 min=max=p1;

356 min=FFMIN(min,p3); max=FFMAX(max,p3);

357 min=FFMIN(min,p5); max=FFMAX(max,p5);

358 min=FFMIN(min,p8); max=FFMAX(max,p8);

359 if(max-min<2*quant){//early stop

360 min=FFMIN(min,p2); max=FFMAX(max,p2);

361 min=FFMIN(min,p4); max=FFMAX(max,p4);

362 min=FFMIN(min,p6); max=FFMAX(max,p6);

363 min=FFMIN(min,p7); max=FFMAX(max,p7);

364 if(max-min<2*quant){

365 ptr[-2*a_stride]=(4*p2 + 3*p3 + 1*p7 + 4)>>3;

366 ptr[-1*a_stride]=(3*p2 + 3*p4 + 2*p7 + 4)>>3;

367 ptr[ 0 ]=(2*p2 + 3*p5 + 3*p7 + 4)>>3;

368 ptr[ 1*a_stride]=(1*p2 + 3*p6 + 4*p7 + 4)>>3;

369 continue;

370 };

371 }

372 }

373 }

374 {

375 int x,x0,x1,x2;

376 int m;

377

378 x0 = (2*p3 - 5*p4 + 5*p5 - 2*p6 + 4)>>3;

379 if(FFABS(x0) < quant){

380 x1=(2*p1 - 5*p2 + 5*p3 - 2*p4 + 4)>>3;

381 x2=(2*p5 - 5*p6 + 5*p7 - 2*p8 + 4)>>3;

382

383 x=FFABS(x0) - FFMIN( FFABS(x1), FFABS(x2) );

384 m=p4-p5;

385

386 if( x > 0 && (m^x0) <0){

387 int32_t sign;

388

389 sign=m>>31;

390 m=(m^sign)-sign;//abs(m)

391 m>>=1;

392

393 x=(5*x)>>3;

394

395 if(x>m) x=m;

396

397 x=(x^sign)-sign;

398

399 ptr[-1*a_stride] -= x;

400 ptr[ 0] += x;

401 }

402 }

403 }

404 }

405 }

406

407 static void x8_h_loop_filter(uint8_t *src, int stride, int qscale){

408 x8_loop_filter(src, stride, 1, qscale);

409 }

410

411 static void x8_v_loop_filter(uint8_t *src, int stride, int qscale){

412 x8_loop_filter(src, 1, stride, qscale);

413 }

414

415 av_cold void ff_intrax8dsp_init(IntraX8DSPContext *dsp)

416 {

417 dsp->h_loop_filter=x8_h_loop_filter;

418 dsp->v_loop_filter=x8_v_loop_filter;

419 dsp->setup_spatial_compensation=x8_setup_spatial_compensation;

420 dsp->spatial_compensation[0]=spatial_compensation_0;

421 dsp->spatial_compensation[1]=spatial_compensation_1;

422 dsp->spatial_compensation[2]=spatial_compensation_2;

423 dsp->spatial_compensation[3]=spatial_compensation_3;

424 dsp->spatial_compensation[4]=spatial_compensation_4;

425 dsp->spatial_compensation[5]=spatial_compensation_5;

426 dsp->spatial_compensation[6]=spatial_compensation_6;

427 dsp->spatial_compensation[7]=spatial_compensation_7;

428 dsp->spatial_compensation[8]=spatial_compensation_8;

429 dsp->spatial_compensation[9]=spatial_compensation_9;

430 dsp->spatial_compensation[10]=spatial_compensation_10;

431 dsp->spatial_compensation[11]=spatial_compensation_11;

432 }

Generated on Sat Jan 25 2014 19:51:49 for FFmpeg by doxygen 1.8.2