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 "me_cmp.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 int ff_snow_get_buffer(SnowContext *s, AVFrame *frame)

70 {

71 int ret, i;

72 int edges_needed = av_codec_is_encoder(s->avctx->codec);

74 frame->width = s->avctx->width ;

75 frame->height = s->avctx->height;

76 if (edges_needed) {

77 frame->width += 2 * EDGE_WIDTH;

78 frame->height += 2 * EDGE_WIDTH;

79 }

80 if ((ret = ff_get_buffer(s->avctx, frame, AV_GET_BUFFER_FLAG_REF)) < 0)

81 return ret;

82 if (edges_needed) {

83 for (i = 0; frame->data[i]; i++) {

84 int offset = (EDGE_WIDTH >> (i ? s->chroma_v_shift : 0)) *

85 frame->linesize[i] +

86 (EDGE_WIDTH >> (i ? s->chroma_h_shift : 0));

87 frame->data[i] += offset;

88 }

89 frame->width = s->avctx->width;

90 frame->height = s->avctx->height;

91 }

93 return 0;

94 }

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

97 int plane_index, level, orientation;

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

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

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

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

103 }

104 }

105 }

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

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

108 }

109

110 int ff_snow_alloc_blocks(SnowContext *s){

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

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

113

114 s->b_width = w;

115 s->b_height= h;

116

117 av_free(s->block);

118 s->block= av_mallocz_array(w * h, sizeof(BlockNode) << (s->block_max_depth*2));

119 if (!s->block)

120 return AVERROR(ENOMEM);

121

122 return 0;

123 }

124

125 static av_cold void init_qexp(void){

126 int i;

127 double v=128;

128

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

130 ff_qexp[i]= lrintf(v);

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

132 }

133 }

134 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){

135 static const uint8_t weight[64]={

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

137 7,7,0,0,0,0,0,1,

138 6,0,6,0,0,0,2,0,

139 5,0,0,5,0,3,0,0,

140 4,0,0,0,4,0,0,0,

141 3,0,0,5,0,3,0,0,

142 2,0,6,0,0,0,2,0,

143 1,7,0,0,0,0,0,1,

144 };

145

146 static const uint8_t brane[256]={

147 0x00,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x11,0x12,0x12,0x12,0x12,0x12,0x12,0x12,

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

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

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

151 0x04,0xcc,0xcc,0xcc,0x41,0xcc,0xcc,0xcc,0x15,0xcc,0xcc,0xcc,0x16,0xcc,0xcc,0xcc,

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

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

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

155 0x44,0x45,0x45,0x45,0x45,0x45,0x45,0x45,0x55,0x56,0x56,0x56,0x56,0x56,0x56,0x56,

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

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

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

159 0x48,0xcc,0xcc,0xcc,0x49,0xcc,0xcc,0xcc,0x59,0xcc,0xcc,0xcc,0x96,0xcc,0xcc,0xcc,

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

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

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

163 };

164

165 static const uint8_t needs[16]={

166 0,1,0,0,

167 2,4,2,0,

168 0,1,0,0,

169 15

170 };

171

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

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

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

175 int16_t *tmpI= tmpIt;

176 uint8_t *tmp2= tmp2t[0];

177 const uint8_t *hpel[11];

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

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

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

181

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

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

184 b= 15;

185

186 if(b&5){

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

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

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

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

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

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

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

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

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

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

197 int am=0;

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

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

200 tmpI[x]= am;

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

202 }else{

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

204 tmpI[x]= am;

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

206 }

207

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

209 tmp2[x]= am;

210 }

211 tmpI+= 64;

212 tmp2+= 64;

213 src += stride;

214 }

215 src -= stride*y;

216 }

217 src += HTAPS_MAX/2 - 1;

218 tmp2= tmp2t[1];

219

220 if(b&2){

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

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

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

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

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

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

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

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

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

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

231 int am=0;

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

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

234 else

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

236

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

238 tmp2[x]= am;

239 }

240 src += stride;

241 tmp2+= 64;

242 }

243 src -= stride*y;

244 }

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

246 tmp2= tmp2t[2];

247 tmpI= tmpIt;

248 if(b&4){

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

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

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

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

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

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

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

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

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

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

259 int am=0;

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

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

262 else

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

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

265 tmp2[x]= am;

266 }

267 tmpI+= 64;

268 tmp2+= 64;

269 }

270 }

271

272 hpel[ 0]= src;

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

274 hpel[ 2]= src + 1;

275

276 hpel[ 4]= tmp2t[1];

277 hpel[ 5]= tmp2t[2];

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

279

280 hpel[ 8]= src + stride;

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

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

283

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

285

286 if(b==15){

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

288 const uint8_t *src1 = hpel[dxy ];

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

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

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

292 int stride1 = MC_STRIDE(dxy);

293 int stride2 = MC_STRIDE(dxy + 1);

294 int stride3 = MC_STRIDE(dxy + 4);

295 int stride4 = MC_STRIDE(dxy + 5);

296 dx&=7;

297 dy&=7;

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

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

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

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

302 }

303 src1+=stride1;

304 src2+=stride2;

305 src3+=stride3;

306 src4+=stride4;

307 dst +=stride;

308 }

309 }else{

310 const uint8_t *src1= hpel[l];

311 const uint8_t *src2= hpel[r];

312 int stride1 = MC_STRIDE(l);

313 int stride2 = MC_STRIDE(r);

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

315 int b= 8-a;

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

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

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

319 }

320 src1+=stride1;

321 src2+=stride2;

322 dst +=stride;

323 }

324 }

325 }

326

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

328 if(block->type & BLOCK_INTRA){

329 int x, y;

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

331 const unsigned color4 = color*0x01010101;

332 if(b_w==32){

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

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

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

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

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

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

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

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

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

342 }

343 }else if(b_w==16){

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

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

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

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

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

349 }

350 }else if(b_w==8){

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

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

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

354 }

355 }else if(b_w==4){

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

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

358 }

359 }else{

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

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

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

363 }

364 }

365 }

366 }else{

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

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

369 int mx= block->mx*scale;

370 int my= block->my*scale;

371 const int dx= mx&15;

372 const int dy= my&15;

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

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

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

376 src += sx + sy*stride;

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

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

379 s->vdsp.emulated_edge_mc(tmp + MB_SIZE, src,

380 stride, stride,

381 b_w+HTAPS_MAX-1, b_h+HTAPS_MAX-1,

382 sx, sy, w, h);

383 src= tmp + MB_SIZE;

384 }

385

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

387

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

389 if( (dx&3) || (dy&3)

390 || !(b_w == b_h || 2*b_w == b_h || b_w == 2*b_h)

391 || (b_w&(b_w-1))

392 || b_w == 1

393 || b_h == 1

394 || !s->plane[plane_index].fast_mc )

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

396 else if(b_w==32){

397 int y;

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

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

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

401 }

402 }else if(b_w==b_h)

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

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

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

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

407 }else{

408 av_assert2(2*b_w==b_h);

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

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

411 }

412 }

413 }

414

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

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

417 av_assert2(h==b_w);\

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

419 }

420

421 mca( 0, 0,16)

422 mca( 8, 0,16)

423 mca( 0, 8,16)

424 mca( 8, 8,16)

425 mca( 0, 0,8)

426 mca( 8, 0,8)

427 mca( 0, 8,8)

428 mca( 8, 8,8)

429

430 av_cold int ff_snow_common_init(AVCodecContext *avctx){

431 SnowContext *s = avctx->priv_data;

432 int width, height;

433 int i, j;

434

435 s->avctx= avctx;

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

437

438 ff_me_cmp_init(&s->mecc, avctx);

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

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

441 ff_dwt_init(&s->dwt);

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

443

444 #define mcf(dx,dy)\

445 s->qdsp.put_qpel_pixels_tab [0][dy+dx/4]=\

446 s->qdsp.put_no_rnd_qpel_pixels_tab[0][dy+dx/4]=\

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

448 s->qdsp.put_qpel_pixels_tab [1][dy+dx/4]=\

449 s->qdsp.put_no_rnd_qpel_pixels_tab[1][dy+dx/4]=\

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

451

452 mcf( 0, 0)

453 mcf( 4, 0)

454 mcf( 8, 0)

455 mcf(12, 0)

456 mcf( 0, 4)

457 mcf( 4, 4)

458 mcf( 8, 4)

459 mcf(12, 4)

460 mcf( 0, 8)

461 mcf( 4, 8)

462 mcf( 8, 8)

463 mcf(12, 8)

464 mcf( 0,12)

465 mcf( 4,12)

466 mcf( 8,12)

467 mcf(12,12)

468

469 #define mcfh(dx,dy)\

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

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

472 mc_block_hpel ## dx ## dy ## 16;\

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

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

475 mc_block_hpel ## dx ## dy ## 8;

476

477 mcfh(0, 0)

478 mcfh(8, 0)

479 mcfh(0, 8)

480 mcfh(8, 8)

481

482 init_qexp();

483

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

485

486 width= s->avctx->width;

487 height= s->avctx->height;

488

489 FF_ALLOCZ_ARRAY_OR_GOTO(avctx, s->spatial_idwt_buffer, width, height * sizeof(IDWTELEM), fail);

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

491 FF_ALLOCZ_ARRAY_OR_GOTO(avctx, s->temp_dwt_buffer, width, sizeof(DWTELEM), fail);

492 FF_ALLOCZ_ARRAY_OR_GOTO(avctx, s->temp_idwt_buffer, width, sizeof(IDWTELEM), fail);

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

494

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

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

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

498 s->last_picture[i] = av_frame_alloc();

499 if (!s->last_picture[i])

500 goto fail;

501 }

502

503 s->mconly_picture = av_frame_alloc();

504 s->current_picture = av_frame_alloc();

505 if (!s->mconly_picture || !s->current_picture)

506 goto fail;

507

508 return 0;

509 fail:

510 return AVERROR(ENOMEM);

511 }

512

513 int ff_snow_common_init_after_header(AVCodecContext *avctx) {

514 SnowContext *s = avctx->priv_data;

515 int plane_index, level, orientation;

516 int ret, emu_buf_size;

517

518 if(!s->scratchbuf) {

519 if ((ret = ff_get_buffer(s->avctx, s->mconly_picture,

520 AV_GET_BUFFER_FLAG_REF)) < 0)

521 return ret;

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

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

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

525 }

526

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

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

529 return AVERROR_INVALIDDATA;

530 }

531

532 for(plane_index=0; plane_index < s->nb_planes; plane_index++){

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

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

535

536 if(plane_index){

537 w>>= s->chroma_h_shift;

538 h>>= s->chroma_v_shift;

539 }

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

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

542

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

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

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

546

547 b->buf= s->spatial_dwt_buffer;

548 b->level= level;

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

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

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

552

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

554 b->buf_x_offset = 0;

555 b->buf_y_offset = 0;

556

557 if(orientation&1){

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

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

560 }

561 if(orientation>1){

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

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

564 }

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

566

567 if(level)

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

569 //FIXME avoid this realloc

570 av_freep(&b->x_coeff);

571 b->x_coeff=av_mallocz_array(((b->width+1) * b->height+1), sizeof(x_and_coeff));

572 if (!b->x_coeff)

573 goto fail;

574 }

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

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

577 }

578 }

579

580 return 0;

581 fail:

582 return AVERROR(ENOMEM);

583 }

584

585 #define USE_HALFPEL_PLANE 0

586

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

588 int p,x,y;

589

590 for(p=0; p < s->nb_planes; p++){

591 int is_chroma= !!p;

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

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

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

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

596

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

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

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

600 if (!halfpel[1][p] || !halfpel[2][p] || !halfpel[3][p])

601 return AVERROR(ENOMEM);

602

603 halfpel[0][p]= src;

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

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

606 int i= y*ls + x;

607

608 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;

609 }

610 }

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

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

613 int i= y*ls + x;

614

615 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;

616 }

617 }

618 src= halfpel[1][p];

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

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

621 int i= y*ls + x;

622

623 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;

624 }

625 }

626

627 //FIXME border!

628 }

629 return 0;

630 }

631

632 void ff_snow_release_buffer(AVCodecContext *avctx)

633 {

634 SnowContext *s = avctx->priv_data;

635 int i;

636

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

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

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

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

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

642 }

643 }

644

645 int ff_snow_frame_start(SnowContext *s){

646 AVFrame *tmp;

647 int i, ret;

648

649 ff_snow_release_buffer(s->avctx);

650

651 tmp= s->last_picture[s->max_ref_frames-1];

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

653 s->last_picture[i] = s->last_picture[i-1];

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

655 if(USE_HALFPEL_PLANE && s->current_picture->data[0]) {

656 if((ret = halfpel_interpol(s, s->halfpel_plane[0], s->current_picture)) < 0)

657 return ret;

658 }

659 s->last_picture[0] = s->current_picture;

660 s->current_picture = tmp;

661

662 if(s->keyframe){

663 s->ref_frames= 0;

664 }else{

665 int i;

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

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

668 break;

669 s->ref_frames= i;

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

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

672 return -1;

673 }

674 }

675 if ((ret = ff_snow_get_buffer(s, s->current_picture)) < 0)

676 return ret;

677

678 s->current_picture->key_frame= s->keyframe;

679

680 return 0;

681 }

682

683 av_cold void ff_snow_common_end(SnowContext *s)

684 {

685 int plane_index, level, orientation, i;

686

687 av_freep(&s->spatial_dwt_buffer);

688 av_freep(&s->temp_dwt_buffer);

689 av_freep(&s->spatial_idwt_buffer);

690 av_freep(&s->temp_idwt_buffer);

691 av_freep(&s->run_buffer);

692

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

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

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

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

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

698

699 av_freep(&s->block);

700 av_freep(&s->scratchbuf);

701 av_freep(&s->emu_edge_buffer);

702

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

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

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

706 if(s->last_picture[i] && s->last_picture[i]->data[0]) {

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

708 }

709 av_frame_free(&s->last_picture[i]);

710 }

711

712 for(plane_index=0; plane_index < s->nb_planes; plane_index++){

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

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

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

716

717 av_freep(&b->x_coeff);

718 }

719 }

720 }

721 av_frame_free(&s->mconly_picture);

722 av_frame_free(&s->current_picture);

723 }

Generated on Sun Sep 14 2014 18:56:03 for FFmpeg by doxygen 1.8.2