FFmpeg: libavcodec/snow.c Source File

FFmpeg

[フレーム]

libavcodec

snow.c

Go to the documentation of this file.

1 /*

3 *

4 * This file is part of FFmpeg.

5 *

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

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

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

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

10 *

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

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

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

14 * Lesser General Public License for more details.

15 *

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

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

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

19 */

21 #include "libavutil/intmath.h"

22 #include "libavutil/log.h"

23 #include "libavutil/opt.h"

24 #include "avcodec.h"

25 #include "dsputil.h"

26 #include "snow_dwt.h"

27 #include "internal.h"

28 #include "snow.h"

29 #include "snowdata.h"

31 #include "rangecoder.h"

32 #include "mathops.h"

33 #include "h263.h"

36 void ff_snow_inner_add_yblock(const uint8_t *obmc, const int obmc_stride, uint8_t * * block, int b_w, int b_h,

37 int src_x, int src_y, int src_stride, slice_buffer * sb, int add, uint8_t * dst8){

38 int y, x;

39 IDWTELEM * dst;

40 for(y=0; y<b_h; y++){

41 //FIXME ugly misuse of obmc_stride

42 const uint8_t *obmc1= obmc + y*obmc_stride;

43 const uint8_t *obmc2= obmc1+ (obmc_stride>>1);

44 const uint8_t *obmc3= obmc1+ obmc_stride*(obmc_stride>>1);

45 const uint8_t *obmc4= obmc3+ (obmc_stride>>1);

46 dst = slice_buffer_get_line(sb, src_y + y);

47 for(x=0; x<b_w; x++){

48 int v= obmc1[x] * block[3][x + y*src_stride]

49 +obmc2[x] * block[2][x + y*src_stride]

50 +obmc3[x] * block[1][x + y*src_stride]

51 +obmc4[x] * block[0][x + y*src_stride];

53 v <<= 8 - LOG2_OBMC_MAX;

54 if(FRAC_BITS != 8){

55 v >>= 8 - FRAC_BITS;

56 }

57 if(add){

58 v += dst[x + src_x];

59 v = (v + (1<<(FRAC_BITS-1))) >> FRAC_BITS;

60 if(v&(~255)) v= ~(v>>31);

61 dst8[x + y*src_stride] = v;

62 }else{

63 dst[x + src_x] -= v;

64 }

65 }

66 }

67 }

69 void ff_snow_reset_contexts(SnowContext *s){ //FIXME better initial contexts

70 int plane_index, level, orientation;

72 for(plane_index=0; plane_index<3; plane_index++){

73 for(level=0; level<MAX_DECOMPOSITIONS; level++){

74 for(orientation=level ? 1:0; orientation<4; orientation++){

75 memset(s->plane[plane_index].band[level][orientation].state, MID_STATE, sizeof(s->plane[plane_index].band[level][orientation].state));

76 }

77 }

78 }

79 memset(s->header_state, MID_STATE, sizeof(s->header_state));

80 memset(s->block_state, MID_STATE, sizeof(s->block_state));

81 }

83 int ff_snow_alloc_blocks(SnowContext *s){

84 int w= FF_CEIL_RSHIFT(s->avctx->width, LOG2_MB_SIZE);

85 int h= FF_CEIL_RSHIFT(s->avctx->height, LOG2_MB_SIZE);

87 s->b_width = w;

88 s->b_height= h;

90 av_free(s->block);

91 s->block= av_mallocz(w * h * sizeof(BlockNode) << (s->block_max_depth*2));

92 return 0;

93 }

95 static av_cold void init_qexp(void){

96 int i;

97 double v=128;

99 for(i=0; i<QROOT; i++){

100 ff_qexp[i]= lrintf(v);

101 v *= pow(2, 1.0 / QROOT);

102 }

103 }

104 static void mc_block(Plane *p, uint8_t *dst, const uint8_t *src, int stride, int b_w, int b_h, int dx, int dy){

105 static const uint8_t weight[64]={

106 8,7,6,5,4,3,2,1,

107 7,7,0,0,0,0,0,1,

108 6,0,6,0,0,0,2,0,

109 5,0,0,5,0,3,0,0,

110 4,0,0,0,4,0,0,0,

111 3,0,0,5,0,3,0,0,

112 2,0,6,0,0,0,2,0,

113 1,7,0,0,0,0,0,1,

114 };

115

116 static const uint8_t brane[256]={

117 0x00,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x11,0x12,0x12,0x12,0x12,0x12,0x12,0x12,

118 0x04,0x05,0xcc,0xcc,0xcc,0xcc,0xcc,0x41,0x15,0x16,0xcc,0xcc,0xcc,0xcc,0xcc,0x52,

119 0x04,0xcc,0x05,0xcc,0xcc,0xcc,0x41,0xcc,0x15,0xcc,0x16,0xcc,0xcc,0xcc,0x52,0xcc,

120 0x04,0xcc,0xcc,0x05,0xcc,0x41,0xcc,0xcc,0x15,0xcc,0xcc,0x16,0xcc,0x52,0xcc,0xcc,

121 0x04,0xcc,0xcc,0xcc,0x41,0xcc,0xcc,0xcc,0x15,0xcc,0xcc,0xcc,0x16,0xcc,0xcc,0xcc,

122 0x04,0xcc,0xcc,0x41,0xcc,0x05,0xcc,0xcc,0x15,0xcc,0xcc,0x52,0xcc,0x16,0xcc,0xcc,

123 0x04,0xcc,0x41,0xcc,0xcc,0xcc,0x05,0xcc,0x15,0xcc,0x52,0xcc,0xcc,0xcc,0x16,0xcc,

124 0x04,0x41,0xcc,0xcc,0xcc,0xcc,0xcc,0x05,0x15,0x52,0xcc,0xcc,0xcc,0xcc,0xcc,0x16,

125 0x44,0x45,0x45,0x45,0x45,0x45,0x45,0x45,0x55,0x56,0x56,0x56,0x56,0x56,0x56,0x56,

126 0x48,0x49,0xcc,0xcc,0xcc,0xcc,0xcc,0x85,0x59,0x5A,0xcc,0xcc,0xcc,0xcc,0xcc,0x96,

127 0x48,0xcc,0x49,0xcc,0xcc,0xcc,0x85,0xcc,0x59,0xcc,0x5A,0xcc,0xcc,0xcc,0x96,0xcc,

128 0x48,0xcc,0xcc,0x49,0xcc,0x85,0xcc,0xcc,0x59,0xcc,0xcc,0x5A,0xcc,0x96,0xcc,0xcc,

129 0x48,0xcc,0xcc,0xcc,0x49,0xcc,0xcc,0xcc,0x59,0xcc,0xcc,0xcc,0x96,0xcc,0xcc,0xcc,

130 0x48,0xcc,0xcc,0x85,0xcc,0x49,0xcc,0xcc,0x59,0xcc,0xcc,0x96,0xcc,0x5A,0xcc,0xcc,

131 0x48,0xcc,0x85,0xcc,0xcc,0xcc,0x49,0xcc,0x59,0xcc,0x96,0xcc,0xcc,0xcc,0x5A,0xcc,

132 0x48,0x85,0xcc,0xcc,0xcc,0xcc,0xcc,0x49,0x59,0x96,0xcc,0xcc,0xcc,0xcc,0xcc,0x5A,

133 };

134

135 static const uint8_t needs[16]={

136 0,1,0,0,

137 2,4,2,0,

138 0,1,0,0,

139 15

140 };

141

142 int x, y, b, r, l;

143 int16_t tmpIt [64*(32+HTAPS_MAX)];

144 uint8_t tmp2t[3][64*(32+HTAPS_MAX)];

145 int16_t *tmpI= tmpIt;

146 uint8_t *tmp2= tmp2t[0];

147 const uint8_t *hpel[11];

148 av_assert2(dx<16 && dy<16);

149 r= brane[dx + 16*dy]&15;

150 l= brane[dx + 16*dy]>>4;

151

152 b= needs[l] | needs[r];

153 if(p && !p->diag_mc)

154 b= 15;

155

156 if(b&5){

157 for(y=0; y < b_h+HTAPS_MAX-1; y++){

158 for(x=0; x < b_w; x++){

159 int a_1=src[x + HTAPS_MAX/2-4];

160 int a0= src[x + HTAPS_MAX/2-3];

161 int a1= src[x + HTAPS_MAX/2-2];

162 int a2= src[x + HTAPS_MAX/2-1];

163 int a3= src[x + HTAPS_MAX/2+0];

164 int a4= src[x + HTAPS_MAX/2+1];

165 int a5= src[x + HTAPS_MAX/2+2];

166 int a6= src[x + HTAPS_MAX/2+3];

167 int am=0;

168 if(!p || p->fast_mc){

169 am= 20*(a2+a3) - 5*(a1+a4) + (a0+a5);

170 tmpI[x]= am;

171 am= (am+16)>>5;

172 }else{

173 am= p->hcoeff[0]*(a2+a3) + p->hcoeff[1]*(a1+a4) + p->hcoeff[2]*(a0+a5) + p->hcoeff[3]*(a_1+a6);

174 tmpI[x]= am;

175 am= (am+32)>>6;

176 }

177

178 if(am&(~255)) am= ~(am>>31);

179 tmp2[x]= am;

180 }

181 tmpI+= 64;

182 tmp2+= 64;

183 src += stride;

184 }

185 src -= stride*y;

186 }

187 src += HTAPS_MAX/2 - 1;

188 tmp2= tmp2t[1];

189

190 if(b&2){

191 for(y=0; y < b_h; y++){

192 for(x=0; x < b_w+1; x++){

193 int a_1=src[x + (HTAPS_MAX/2-4)*stride];

194 int a0= src[x + (HTAPS_MAX/2-3)*stride];

195 int a1= src[x + (HTAPS_MAX/2-2)*stride];

196 int a2= src[x + (HTAPS_MAX/2-1)*stride];

197 int a3= src[x + (HTAPS_MAX/2+0)*stride];

198 int a4= src[x + (HTAPS_MAX/2+1)*stride];

199 int a5= src[x + (HTAPS_MAX/2+2)*stride];

200 int a6= src[x + (HTAPS_MAX/2+3)*stride];

201 int am=0;

202 if(!p || p->fast_mc)

203 am= (20*(a2+a3) - 5*(a1+a4) + (a0+a5) + 16)>>5;

204 else

205 am= (p->hcoeff[0]*(a2+a3) + p->hcoeff[1]*(a1+a4) + p->hcoeff[2]*(a0+a5) + p->hcoeff[3]*(a_1+a6) + 32)>>6;

206

207 if(am&(~255)) am= ~(am>>31);

208 tmp2[x]= am;

209 }

210 src += stride;

211 tmp2+= 64;

212 }

213 src -= stride*y;

214 }

215 src += stride*(HTAPS_MAX/2 - 1);

216 tmp2= tmp2t[2];

217 tmpI= tmpIt;

218 if(b&4){

219 for(y=0; y < b_h; y++){

220 for(x=0; x < b_w; x++){

221 int a_1=tmpI[x + (HTAPS_MAX/2-4)*64];

222 int a0= tmpI[x + (HTAPS_MAX/2-3)*64];

223 int a1= tmpI[x + (HTAPS_MAX/2-2)*64];

224 int a2= tmpI[x + (HTAPS_MAX/2-1)*64];

225 int a3= tmpI[x + (HTAPS_MAX/2+0)*64];

226 int a4= tmpI[x + (HTAPS_MAX/2+1)*64];

227 int a5= tmpI[x + (HTAPS_MAX/2+2)*64];

228 int a6= tmpI[x + (HTAPS_MAX/2+3)*64];

229 int am=0;

230 if(!p || p->fast_mc)

231 am= (20*(a2+a3) - 5*(a1+a4) + (a0+a5) + 512)>>10;

232 else

233 am= (p->hcoeff[0]*(a2+a3) + p->hcoeff[1]*(a1+a4) + p->hcoeff[2]*(a0+a5) + p->hcoeff[3]*(a_1+a6) + 2048)>>12;

234 if(am&(~255)) am= ~(am>>31);

235 tmp2[x]= am;

236 }

237 tmpI+= 64;

238 tmp2+= 64;

239 }

240 }

241

242 hpel[ 0]= src;

243 hpel[ 1]= tmp2t[0] + 64*(HTAPS_MAX/2-1);

244 hpel[ 2]= src + 1;

245

246 hpel[ 4]= tmp2t[1];

247 hpel[ 5]= tmp2t[2];

248 hpel[ 6]= tmp2t[1] + 1;

249

250 hpel[ 8]= src + stride;

251 hpel[ 9]= hpel[1] + 64;

252 hpel[10]= hpel[8] + 1;

253

254 #define MC_STRIDE(x) (needs[x] ? 64 : stride)

255

256 if(b==15){

257 int dxy = dx / 8 + dy / 8 * 4;

258 const uint8_t *src1 = hpel[dxy ];

259 const uint8_t *src2 = hpel[dxy + 1];

260 const uint8_t *src3 = hpel[dxy + 4];

261 const uint8_t *src4 = hpel[dxy + 5];

262 int stride1 = MC_STRIDE(dxy);

263 int stride2 = MC_STRIDE(dxy + 1);

264 int stride3 = MC_STRIDE(dxy + 4);

265 int stride4 = MC_STRIDE(dxy + 5);

266 dx&=7;

267 dy&=7;

268 for(y=0; y < b_h; y++){

269 for(x=0; x < b_w; x++){

270 dst[x]= ((8-dx)*(8-dy)*src1[x] + dx*(8-dy)*src2[x]+

271 (8-dx)* dy *src3[x] + dx* dy *src4[x]+32)>>6;

272 }

273 src1+=stride1;

274 src2+=stride2;

275 src3+=stride3;

276 src4+=stride4;

277 dst +=stride;

278 }

279 }else{

280 const uint8_t *src1= hpel[l];

281 const uint8_t *src2= hpel[r];

282 int stride1 = MC_STRIDE(l);

283 int stride2 = MC_STRIDE(r);

284 int a= weight[((dx&7) + (8*(dy&7)))];

285 int b= 8-a;

286 for(y=0; y < b_h; y++){

287 for(x=0; x < b_w; x++){

288 dst[x]= (a*src1[x] + b*src2[x] + 4)>>3;

289 }

290 src1+=stride1;

291 src2+=stride2;

292 dst +=stride;

293 }

294 }

295 }

296

297 void ff_snow_pred_block(SnowContext *s, uint8_t *dst, uint8_t *tmp, int stride, int sx, int sy, int b_w, int b_h, BlockNode *block, int plane_index, int w, int h){

298 if(block->type & BLOCK_INTRA){

299 int x, y;

300 const unsigned color = block->color[plane_index];

301 const unsigned color4 = color*0x01010101;

302 if(b_w==32){

303 for(y=0; y < b_h; y++){

304 *(uint32_t*)&dst[0 + y*stride]= color4;

305 *(uint32_t*)&dst[4 + y*stride]= color4;

306 *(uint32_t*)&dst[8 + y*stride]= color4;

307 *(uint32_t*)&dst[12+ y*stride]= color4;

308 *(uint32_t*)&dst[16+ y*stride]= color4;

309 *(uint32_t*)&dst[20+ y*stride]= color4;

310 *(uint32_t*)&dst[24+ y*stride]= color4;

311 *(uint32_t*)&dst[28+ y*stride]= color4;

312 }

313 }else if(b_w==16){

314 for(y=0; y < b_h; y++){

315 *(uint32_t*)&dst[0 + y*stride]= color4;

316 *(uint32_t*)&dst[4 + y*stride]= color4;

317 *(uint32_t*)&dst[8 + y*stride]= color4;

318 *(uint32_t*)&dst[12+ y*stride]= color4;

319 }

320 }else if(b_w==8){

321 for(y=0; y < b_h; y++){

322 *(uint32_t*)&dst[0 + y*stride]= color4;

323 *(uint32_t*)&dst[4 + y*stride]= color4;

324 }

325 }else if(b_w==4){

326 for(y=0; y < b_h; y++){

327 *(uint32_t*)&dst[0 + y*stride]= color4;

328 }

329 }else{

330 for(y=0; y < b_h; y++){

331 for(x=0; x < b_w; x++){

332 dst[x + y*stride]= color;

333 }

334 }

335 }

336 }else{

337 uint8_t *src= s->last_picture[block->ref].data[plane_index];

338 const int scale= plane_index ? (2*s->mv_scale)>>s->chroma_h_shift : 2*s->mv_scale;

339 int mx= block->mx*scale;

340 int my= block->my*scale;

341 const int dx= mx&15;

342 const int dy= my&15;

343 const int tab_index= 3 - (b_w>>2) + (b_w>>4);

344 sx += (mx>>4) - (HTAPS_MAX/2-1);

345 sy += (my>>4) - (HTAPS_MAX/2-1);

346 src += sx + sy*stride;

347 if( (unsigned)sx >= FFMAX(w - b_w - (HTAPS_MAX-2), 0)

348 || (unsigned)sy >= FFMAX(h - b_h - (HTAPS_MAX-2), 0)){

349 s->vdsp.emulated_edge_mc(tmp + MB_SIZE, src, stride, b_w+HTAPS_MAX-1, b_h+HTAPS_MAX-1, sx, sy, w, h);

350 src= tmp + MB_SIZE;

351 }

352

353 av_assert2(s->chroma_h_shift == s->chroma_v_shift); // only one mv_scale

354

355 av_assert2(b_w>1 && b_h>1);

356 av_assert2((tab_index>=0 && tab_index<4) || b_w==32);

357 if((dx&3) || (dy&3) || !(b_w == b_h || 2*b_w == b_h || b_w == 2*b_h) || (b_w&(b_w-1)) || !s->plane[plane_index].fast_mc )

358 mc_block(&s->plane[plane_index], dst, src, stride, b_w, b_h, dx, dy);

359 else if(b_w==32){

360 int y;

361 for(y=0; y<b_h; y+=16){

362 s->h264qpel.put_h264_qpel_pixels_tab[0][dy+(dx>>2)](dst + y*stride, src + 3 + (y+3)*stride,stride);

363 s->h264qpel.put_h264_qpel_pixels_tab[0][dy+(dx>>2)](dst + 16 + y*stride, src + 19 + (y+3)*stride,stride);

364 }

365 }else if(b_w==b_h)

366 s->h264qpel.put_h264_qpel_pixels_tab[tab_index ][dy+(dx>>2)](dst,src + 3 + 3*stride,stride);

367 else if(b_w==2*b_h){

368 s->h264qpel.put_h264_qpel_pixels_tab[tab_index+1][dy+(dx>>2)](dst ,src + 3 + 3*stride,stride);

369 s->h264qpel.put_h264_qpel_pixels_tab[tab_index+1][dy+(dx>>2)](dst+b_h,src + 3 + b_h + 3*stride,stride);

370 }else{

371 av_assert2(2*b_w==b_h);

372 s->h264qpel.put_h264_qpel_pixels_tab[tab_index ][dy+(dx>>2)](dst ,src + 3 + 3*stride ,stride);

373 s->h264qpel.put_h264_qpel_pixels_tab[tab_index ][dy+(dx>>2)](dst+b_w*stride,src + 3 + 3*stride+b_w*stride,stride);

374 }

375 }

376 }

377

378 #define mca(dx,dy,b_w)\

379 static void mc_block_hpel ## dx ## dy ## b_w(uint8_t *dst, const uint8_t *src, ptrdiff_t stride, int h){\

380 av_assert2(h==b_w);\

381 mc_block(NULL, dst, src-(HTAPS_MAX/2-1)-(HTAPS_MAX/2-1)*stride, stride, b_w, b_w, dx, dy);\

382 }

383

384 mca( 0, 0,16)

385 mca( 8, 0,16)

386 mca( 0, 8,16)

387 mca( 8, 8,16)

388 mca( 0, 0,8)

389 mca( 8, 0,8)

390 mca( 0, 8,8)

391 mca( 8, 8,8)

392

393 av_cold int ff_snow_common_init(AVCodecContext *avctx){

394 SnowContext *s = avctx->priv_data;

395 int width, height;

396 int i, j;

397

398 s->avctx= avctx;

399 s->max_ref_frames=1; //just make sure it's not an invalid value in case of no initial keyframe

400

401 ff_dsputil_init(&s->dsp, avctx);

402 ff_hpeldsp_init(&s->hdsp, avctx->flags);

403 ff_videodsp_init(&s->vdsp, 8);

404 ff_dwt_init(&s->dwt);

405 ff_h264qpel_init(&s->h264qpel, 8);

406

407 #define mcf(dx,dy)\

408 s->dsp.put_qpel_pixels_tab [0][dy+dx/4]=\

409 s->dsp.put_no_rnd_qpel_pixels_tab[0][dy+dx/4]=\

410 s->h264qpel.put_h264_qpel_pixels_tab[0][dy+dx/4];\

411 s->dsp.put_qpel_pixels_tab [1][dy+dx/4]=\

412 s->dsp.put_no_rnd_qpel_pixels_tab[1][dy+dx/4]=\

413 s->h264qpel.put_h264_qpel_pixels_tab[1][dy+dx/4];

414

415 mcf( 0, 0)

416 mcf( 4, 0)

417 mcf( 8, 0)

418 mcf(12, 0)

419 mcf( 0, 4)

420 mcf( 4, 4)

421 mcf( 8, 4)

422 mcf(12, 4)

423 mcf( 0, 8)

424 mcf( 4, 8)

425 mcf( 8, 8)

426 mcf(12, 8)

427 mcf( 0,12)

428 mcf( 4,12)

429 mcf( 8,12)

430 mcf(12,12)

431

432 #define mcfh(dx,dy)\

433 s->hdsp.put_pixels_tab [0][dy/4+dx/8]=\

434 s->hdsp.put_no_rnd_pixels_tab[0][dy/4+dx/8]=\

435 mc_block_hpel ## dx ## dy ## 16;\

436 s->hdsp.put_pixels_tab [1][dy/4+dx/8]=\

437 s->hdsp.put_no_rnd_pixels_tab[1][dy/4+dx/8]=\

438 mc_block_hpel ## dx ## dy ## 8;

439

440 mcfh(0, 0)

441 mcfh(8, 0)

442 mcfh(0, 8)

443 mcfh(8, 8)

444

445 init_qexp();

446

447 // dec += FFMAX(s->chroma_h_shift, s->chroma_v_shift);

448

449 width= s->avctx->width;

450 height= s->avctx->height;

451

452 FF_ALLOCZ_OR_GOTO(avctx, s->spatial_idwt_buffer, width * height * sizeof(IDWTELEM), fail);

453 FF_ALLOCZ_OR_GOTO(avctx, s->spatial_dwt_buffer, width * height * sizeof(DWTELEM), fail); //FIXME this does not belong here

454 FF_ALLOCZ_OR_GOTO(avctx, s->temp_dwt_buffer, width * sizeof(DWTELEM), fail);

455 FF_ALLOCZ_OR_GOTO(avctx, s->temp_idwt_buffer, width * sizeof(IDWTELEM), fail);

456 FF_ALLOC_OR_GOTO(avctx, s->run_buffer, ((width + 1) >> 1) * ((height + 1) >> 1) * sizeof(*s->run_buffer), fail);

457

458 for(i=0; i<MAX_REF_FRAMES; i++) {

459 for(j=0; j<MAX_REF_FRAMES; j++)

460 ff_scale_mv_ref[i][j] = 256*(i+1)/(j+1);

461 avcodec_get_frame_defaults(&s->last_picture[i]);

462 }

463

464 avcodec_get_frame_defaults(&s->mconly_picture);

465 avcodec_get_frame_defaults(&s->current_picture);

466

467 return 0;

468 fail:

469 return AVERROR(ENOMEM);

470 }

471

472 int ff_snow_common_init_after_header(AVCodecContext *avctx) {

473 SnowContext *s = avctx->priv_data;

474 int plane_index, level, orientation;

475 int ret, emu_buf_size;

476

477 if(!s->scratchbuf) {

478 if ((ret = ff_get_buffer(s->avctx, &s->mconly_picture,

479 AV_GET_BUFFER_FLAG_REF)) < 0)

480 return ret;

481 FF_ALLOCZ_OR_GOTO(avctx, s->scratchbuf, FFMAX(s->mconly_picture.linesize[0], 2*avctx->width+256)*7*MB_SIZE, fail);

482 emu_buf_size = FFMAX(s->mconly_picture.linesize[0], 2*avctx->width+256) * (2 * MB_SIZE + HTAPS_MAX - 1);

483 FF_ALLOC_OR_GOTO(avctx, s->emu_edge_buffer, emu_buf_size, fail);

484 }

485

486 if(s->mconly_picture.format != avctx->pix_fmt) {

487 av_log(avctx, AV_LOG_ERROR, "pixel format changed\n");

488 return AVERROR_INVALIDDATA;

489 }

490

491 for(plane_index=0; plane_index<3; plane_index++){

492 int w= s->avctx->width;

493 int h= s->avctx->height;

494

495 if(plane_index){

496 w>>= s->chroma_h_shift;

497 h>>= s->chroma_v_shift;

498 }

499 s->plane[plane_index].width = w;

500 s->plane[plane_index].height= h;

501

502 for(level=s->spatial_decomposition_count-1; level>=0; level--){

503 for(orientation=level ? 1 : 0; orientation<4; orientation++){

504 SubBand *b= &s->plane[plane_index].band[level][orientation];

505

506 b->buf= s->spatial_dwt_buffer;

507 b->level= level;

508 b->stride= s->plane[plane_index].width << (s->spatial_decomposition_count - level);

509 b->width = (w + !(orientation&1))>>1;

510 b->height= (h + !(orientation>1))>>1;

511

512 b->stride_line = 1 << (s->spatial_decomposition_count - level);

513 b->buf_x_offset = 0;

514 b->buf_y_offset = 0;

515

516 if(orientation&1){

517 b->buf += (w+1)>>1;

518 b->buf_x_offset = (w+1)>>1;

519 }

520 if(orientation>1){

521 b->buf += b->stride>>1;

522 b->buf_y_offset = b->stride_line >> 1;

523 }

524 b->ibuf= s->spatial_idwt_buffer + (b->buf - s->spatial_dwt_buffer);

525

526 if(level)

527 b->parent= &s->plane[plane_index].band[level-1][orientation];

528 //FIXME avoid this realloc

529 av_freep(&b->x_coeff);

530 b->x_coeff=av_mallocz(((b->width+1) * b->height+1)*sizeof(x_and_coeff));

531 }

532 w= (w+1)>>1;

533 h= (h+1)>>1;

534 }

535 }

536

537 return 0;

538 fail:

539 return AVERROR(ENOMEM);

540 }

541

542 #define USE_HALFPEL_PLANE 0

543

544 static void halfpel_interpol(SnowContext *s, uint8_t *halfpel[4][4], AVFrame *frame){

545 int p,x,y;

546

547 for(p=0; p<3; p++){

548 int is_chroma= !!p;

549 int w= is_chroma ? s->avctx->width >>s->chroma_h_shift : s->avctx->width;

550 int h= is_chroma ? s->avctx->height>>s->chroma_v_shift : s->avctx->height;

551 int ls= frame->linesize[p];

552 uint8_t *src= frame->data[p];

553

554 halfpel[1][p] = (uint8_t*) av_malloc(ls * (h + 2 * EDGE_WIDTH)) + EDGE_WIDTH * (1 + ls);

555 halfpel[2][p] = (uint8_t*) av_malloc(ls * (h + 2 * EDGE_WIDTH)) + EDGE_WIDTH * (1 + ls);

556 halfpel[3][p] = (uint8_t*) av_malloc(ls * (h + 2 * EDGE_WIDTH)) + EDGE_WIDTH * (1 + ls);

557

558 halfpel[0][p]= src;

559 for(y=0; y<h; y++){

560 for(x=0; x<w; x++){

561 int i= y*ls + x;

562

563 halfpel[1][p][i]= (20*(src[i] + src[i+1]) - 5*(src[i-1] + src[i+2]) + (src[i-2] + src[i+3]) + 16 )>>5;

564 }

565 }

566 for(y=0; y<h; y++){

567 for(x=0; x<w; x++){

568 int i= y*ls + x;

569

570 halfpel[2][p][i]= (20*(src[i] + src[i+ls]) - 5*(src[i-ls] + src[i+2*ls]) + (src[i-2*ls] + src[i+3*ls]) + 16 )>>5;

571 }

572 }

573 src= halfpel[1][p];

574 for(y=0; y<h; y++){

575 for(x=0; x<w; x++){

576 int i= y*ls + x;

577

578 halfpel[3][p][i]= (20*(src[i] + src[i+ls]) - 5*(src[i-ls] + src[i+2*ls]) + (src[i-2*ls] + src[i+3*ls]) + 16 )>>5;

579 }

580 }

581

582 //FIXME border!

583 }

584 }

585

586 void ff_snow_release_buffer(AVCodecContext *avctx)

587 {

588 SnowContext *s = avctx->priv_data;

589 int i;

590

591 if(s->last_picture[s->max_ref_frames-1].data[0]){

592 av_frame_unref(&s->last_picture[s->max_ref_frames-1]);

593 for(i=0; i<9; i++)

594 if(s->halfpel_plane[s->max_ref_frames-1][1+i/3][i%3])

595 av_free(s->halfpel_plane[s->max_ref_frames-1][1+i/3][i%3] - EDGE_WIDTH*(1+s->current_picture.linesize[i%3]));

596 }

597 }

598

599 int ff_snow_frame_start(SnowContext *s){

600 AVFrame tmp;

601 int i, ret;

602 int w= s->avctx->width; //FIXME round up to x16 ?

603 int h= s->avctx->height;

604

605 if (s->current_picture.data[0] && !(s->avctx->flags&CODEC_FLAG_EMU_EDGE)) {

606 s->dsp.draw_edges(s->current_picture.data[0],

607 s->current_picture.linesize[0], w , h ,

608 EDGE_WIDTH , EDGE_WIDTH , EDGE_TOP | EDGE_BOTTOM);

609 s->dsp.draw_edges(s->current_picture.data[1],

610 s->current_picture.linesize[1], w>>s->chroma_h_shift, h>>s->chroma_v_shift,

611 EDGE_WIDTH>>s->chroma_h_shift, EDGE_WIDTH>>s->chroma_v_shift, EDGE_TOP | EDGE_BOTTOM);

612 s->dsp.draw_edges(s->current_picture.data[2],

613 s->current_picture.linesize[2], w>>s->chroma_h_shift, h>>s->chroma_v_shift,

614 EDGE_WIDTH>>s->chroma_h_shift, EDGE_WIDTH>>s->chroma_v_shift, EDGE_TOP | EDGE_BOTTOM);

615 }

616

617 ff_snow_release_buffer(s->avctx);

618

619 av_frame_move_ref(&tmp, &s->last_picture[s->max_ref_frames-1]);

620 for(i=s->max_ref_frames-1; i>0; i--)

621 av_frame_move_ref(&s->last_picture[i], &s->last_picture[i-1]);

622 memmove(s->halfpel_plane+1, s->halfpel_plane, (s->max_ref_frames-1)*sizeof(void*)*4*4);

623 if(USE_HALFPEL_PLANE && s->current_picture.data[0])

624 halfpel_interpol(s, s->halfpel_plane[0], &s->current_picture);

625 av_frame_move_ref(&s->last_picture[0], &s->current_picture);

626 av_frame_move_ref(&s->current_picture, &tmp);

627

628 if(s->keyframe){

629 s->ref_frames= 0;

630 }else{

631 int i;

632 for(i=0; i<s->max_ref_frames && s->last_picture[i].data[0]; i++)

633 if(i && s->last_picture[i-1].key_frame)

634 break;

635 s->ref_frames= i;

636 if(s->ref_frames==0){

637 av_log(s->avctx,AV_LOG_ERROR, "No reference frames\n");

638 return -1;

639 }

640 }

641

642 if ((ret = ff_get_buffer(s->avctx, &s->current_picture, AV_GET_BUFFER_FLAG_REF)) < 0)

643 return ret;

644

645 s->current_picture.key_frame= s->keyframe;

646

647 return 0;

648 }

649

650 av_cold void ff_snow_common_end(SnowContext *s)

651 {

652 int plane_index, level, orientation, i;

653

654 av_freep(&s->spatial_dwt_buffer);

655 av_freep(&s->temp_dwt_buffer);

656 av_freep(&s->spatial_idwt_buffer);

657 av_freep(&s->temp_idwt_buffer);

658 av_freep(&s->run_buffer);

659

660 s->m.me.temp= NULL;

661 av_freep(&s->m.me.scratchpad);

662 av_freep(&s->m.me.map);

663 av_freep(&s->m.me.score_map);

664 av_freep(&s->m.obmc_scratchpad);

665

666 av_freep(&s->block);

667 av_freep(&s->scratchbuf);

668 av_freep(&s->emu_edge_buffer);

669

670 for(i=0; i<MAX_REF_FRAMES; i++){

671 av_freep(&s->ref_mvs[i]);

672 av_freep(&s->ref_scores[i]);

673 if(s->last_picture[i].data[0]) {

674 av_assert0(s->last_picture[i].data[0] != s->current_picture.data[0]);

675 av_frame_unref(&s->last_picture[i]);

676 }

677 }

678

679 for(plane_index=0; plane_index<3; plane_index++){

680 for(level=s->spatial_decomposition_count-1; level>=0; level--){

681 for(orientation=level ? 1 : 0; orientation<4; orientation++){

682 SubBand *b= &s->plane[plane_index].band[level][orientation];

683

684 av_freep(&b->x_coeff);

685 }

686 }

687 }

688 av_frame_unref(&s->mconly_picture);

689 av_frame_unref(&s->current_picture);

690 }

Generated on Wed Jul 10 2013 23:48:05 for FFmpeg by doxygen 1.8.2