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= AV_CEIL_RSHIFT(s->avctx->width, LOG2_MB_SIZE);

112 int h= AV_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, const 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 s->spatial_decomposition_count = 1;

438

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

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

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

442 ff_dwt_init(&s->dwt);

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

444

445 #define mcf(dx,dy)\

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

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

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

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

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

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

452

453 mcf( 0, 0)

454 mcf( 4, 0)

455 mcf( 8, 0)

456 mcf(12, 0)

457 mcf( 0, 4)

458 mcf( 4, 4)

459 mcf( 8, 4)

460 mcf(12, 4)

461 mcf( 0, 8)

462 mcf( 4, 8)

463 mcf( 8, 8)

464 mcf(12, 8)

465 mcf( 0,12)

466 mcf( 4,12)

467 mcf( 8,12)

468 mcf(12,12)

469

470 #define mcfh(dx,dy)\

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

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

473 mc_block_hpel ## dx ## dy ## 16;\

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

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

476 mc_block_hpel ## dx ## dy ## 8;

477

478 mcfh(0, 0)

479 mcfh(8, 0)

480 mcfh(0, 8)

481 mcfh(8, 8)

482

483 init_qexp();

484

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

486

487 width= s->avctx->width;

488 height= s->avctx->height;

489

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

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

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

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

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

495

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

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

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

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

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

501 goto fail;

502 }

503

504 s->mconly_picture = av_frame_alloc();

505 s->current_picture = av_frame_alloc();

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

507 goto fail;

508

509 return 0;

510 fail:

511 return AVERROR(ENOMEM);

512 }

513

514 int ff_snow_common_init_after_header(AVCodecContext *avctx) {

515 SnowContext *s = avctx->priv_data;

516 int plane_index, level, orientation;

517 int ret, emu_buf_size;

518

519 if(!s->scratchbuf) {

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

521 AV_GET_BUFFER_FLAG_REF)) < 0)

522 return ret;

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

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

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

526 }

527

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

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

530 return AVERROR_INVALIDDATA;

531 }

532

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

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

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

536

537 if(plane_index){

538 w = AV_CEIL_RSHIFT(w, s->chroma_h_shift);

539 h = AV_CEIL_RSHIFT(h, s->chroma_v_shift);

540 }

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

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

543

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

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

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

547

548 b->buf= s->spatial_dwt_buffer;

549 b->level= level;

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

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

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

553

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

555 b->buf_x_offset = 0;

556 b->buf_y_offset = 0;

557

558 if(orientation&1){

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

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

561 }

562 if(orientation>1){

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

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

565 }

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

567

568 if(level)

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

570 //FIXME avoid this realloc

571 av_freep(&b->x_coeff);

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

573 if (!b->x_coeff)

574 goto fail;

575 }

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

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

578 }

579 }

580

581 return 0;

582 fail:

583 return AVERROR(ENOMEM);

584 }

585

586 #define USE_HALFPEL_PLANE 0

587

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

589 int p,x,y;

590

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

592 int is_chroma= !!p;

593 int w= is_chroma ? AV_CEIL_RSHIFT(s->avctx->width, s->chroma_h_shift) : s->avctx->width;

594 int h= is_chroma ? AV_CEIL_RSHIFT(s->avctx->height, s->chroma_v_shift) : s->avctx->height;

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

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

597

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

599 halfpel[2][p] = av_malloc_array(ls, (h + 2 * EDGE_WIDTH));

600 halfpel[3][p] = av_malloc_array(ls, (h + 2 * EDGE_WIDTH));

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

602 av_freep(&halfpel[1][p]);

603 av_freep(&halfpel[2][p]);

604 av_freep(&halfpel[3][p]);

605 return AVERROR(ENOMEM);

606 }

607 halfpel[1][p] += EDGE_WIDTH * (1 + ls);

608 halfpel[2][p] += EDGE_WIDTH * (1 + ls);

609 halfpel[3][p] += EDGE_WIDTH * (1 + ls);

610

611 halfpel[0][p]= src;

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

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

614 int i= y*ls + x;

615

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

617 }

618 }

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

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

621 int i= y*ls + x;

622

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

624 }

625 }

626 src= halfpel[1][p];

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

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

629 int i= y*ls + x;

630

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

632 }

633 }

634

635 //FIXME border!

636 }

637 return 0;

638 }

639

640 void ff_snow_release_buffer(AVCodecContext *avctx)

641 {

642 SnowContext *s = avctx->priv_data;

643 int i;

644

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

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

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

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

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

650 s->halfpel_plane[s->max_ref_frames-1][1+i/3][i%3] = NULL;

651 }

652 }

653 }

654

655 int ff_snow_frame_start(SnowContext *s){

656 AVFrame *tmp;

657 int i, ret;

658

659 ff_snow_release_buffer(s->avctx);

660

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

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

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

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

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

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

667 return ret;

668 }

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

670 s->current_picture = tmp;

671

672 if(s->keyframe){

673 s->ref_frames= 0;

674 }else{

675 int i;

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

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

678 break;

679 s->ref_frames= i;

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

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

682 return AVERROR_INVALIDDATA;

683 }

684 }

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

686 return ret;

687

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

689

690 return 0;

691 }

692

693 av_cold void ff_snow_common_end(SnowContext *s)

694 {

695 int plane_index, level, orientation, i;

696

697 av_freep(&s->spatial_dwt_buffer);

698 av_freep(&s->temp_dwt_buffer);

699 av_freep(&s->spatial_idwt_buffer);

700 av_freep(&s->temp_idwt_buffer);

701 av_freep(&s->run_buffer);

702

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

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

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

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

707 av_freep(&s->m.sc.obmc_scratchpad);

708

709 av_freep(&s->block);

710 av_freep(&s->scratchbuf);

711 av_freep(&s->emu_edge_buffer);

712

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

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

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

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

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

718 }

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

720 }

721

722 for(plane_index=0; plane_index < MAX_PLANES; plane_index++){

723 for(level=MAX_DECOMPOSITIONS-1; level>=0; level--){

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

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

726

727 av_freep(&b->x_coeff);

728 }

729 }

730 }

731 av_frame_free(&s->mconly_picture);

732 av_frame_free(&s->current_picture);

733 }

MotionEstContext::scratchpad

uint8_t * scratchpad

data area for the ME algo, so that the ME does not need to malloc/free.

Definition: motion_est.h:52

ff_me_cmp_init

av_cold void ff_me_cmp_init(MECmpContext *c, AVCodecContext *avctx)

Definition: me_cmp.c:1035

SnowContext::m

MpegEncContext m

Definition: snow.h:183

SnowContext::mv_scale

int mv_scale

Definition: snow.h:160

ff_videodsp_init

av_cold void ff_videodsp_init(VideoDSPContext *ctx, int bpc)

Definition: videodsp.c:38

NULL

#define NULL

Definition: coverity.c:32

AVCodecContext::codec

const struct AVCodec * codec

Definition: avcodec.h:1527

ff_snow_frame_start

int ff_snow_frame_start(SnowContext *s)

Definition: snow.c:655

const char * s

Definition: avisynth_c.h:768

AVERROR_INVALIDDATA

#define AVERROR_INVALIDDATA

Invalid data found when processing input.

Definition: error.h:59

SnowContext::avctx

AVCodecContext * avctx

Definition: snow.h:116

SnowContext::block_max_depth

int block_max_depth

Definition: snow.h:167

SnowContext::mconly_picture

AVFrame * mconly_picture

Definition: snow.h:129

SnowContext::chroma_v_shift

int chroma_v_shift

Definition: snow.h:153

AVFrame

This structure describes decoded (raw) audio or video data.

Definition: frame.h:218

FF_ALLOCZ_ARRAY_OR_GOTO

#define FF_ALLOCZ_ARRAY_OR_GOTO(ctx, p, nelem, elsize, label)

Definition: internal.h:167

ff_snow_inner_add_yblock

void ff_snow_inner_add_yblock(const uint8_t *obmc, const int obmc_stride, uint8_t **block, int b_w, int b_h, int src_x, int src_y, int src_stride, slice_buffer *sb, int add, uint8_t *dst8)

Definition: snow.c:36

Definition: vp9dsp_template.c:2038

SnowContext::run_buffer

int * run_buffer

Definition: snow.h:150

BLOCK_INTRA

#define BLOCK_INTRA

Intra block, inter otherwise.

Definition: snow.h:58

snow.h

#define a0

Definition: regdef.h:46

rangecoder.h

Range coder.

const char * b

Definition: vf_curves.c:113

AVCodecContext::pix_fmt

enum AVPixelFormat pix_fmt

Pixel format, see AV_PIX_FMT_xxx.

Definition: avcodec.h:1727

mcf

#define mcf(dx, dy)

#define a1

Definition: regdef.h:47

SnowContext::max_ref_frames

int max_ref_frames

Definition: snow.h:142

MotionEstContext::score_map

uint32_t * score_map

map to store the scores

Definition: motion_est.h:59

obmc4

static const uint8_t obmc4[16]

Definition: snowdata.h:96

ff_snow_common_init_after_header

int ff_snow_common_init_after_header(AVCodecContext *avctx)

Definition: snow.c:514

SubBand::stride

ptrdiff_t stride

Definition: cfhd.h:46

SnowContext::keyframe

int keyframe

Definition: snow.h:133

src

#define src

Definition: vp8dsp.c:254

color

Definition: vf_paletteuse.c:588

ff_snow_reset_contexts

void ff_snow_reset_contexts(SnowContext *s)

Definition: snow.c:96

IDWTELEM

short IDWTELEM

Definition: dirac_dwt.h:27

SnowContext::hdsp

HpelDSPContext hdsp

Definition: snow.h:119

SnowContext::mecc

MECmpContext mecc

Definition: snow.h:118

BlockNode

Definition: snow.h:51

SubBand::width

int width

Definition: cfhd.h:48

HTAPS_MAX

#define HTAPS_MAX

Definition: snow.h:76

av_codec_is_encoder

int av_codec_is_encoder(const AVCodec *codec)

Definition: utils.c:94

block

static int16_t block[64]

Definition: dct.c:115

BlockNode::ref

uint8_t ref

Reference frame index.

Definition: snow.h:54

av_assert0

#define av_assert0(cond)

assert() equivalent, that is always enabled.

Definition: avassert.h:37

VideoDSPContext::emulated_edge_mc

void(* emulated_edge_mc)(uint8_t *dst, const uint8_t *src, ptrdiff_t dst_linesize, ptrdiff_t src_linesize, int block_w, int block_h, int src_x, int src_y, int w, int h)

Copy a rectangular area of samples to a temporary buffer and replicate the border samples...

Definition: videodsp.h:63

ff_dwt_init

av_cold void ff_dwt_init(SnowDWTContext *c)

Definition: snow_dwt.c:850

#define a3

Definition: regdef.h:49

SnowContext::b_height

int b_height

Definition: snow.h:166

MpegEncContext::sc

ScratchpadContext sc

Definition: mpegvideo.h:202

uint8_t

Definition: audio_convert.c:194

BlockNode::mx

int16_t mx

Motion vector component X, see mv_scale.

Definition: snow.h:52

av_cold

#define av_cold

Definition: attributes.h:82

FRAC_BITS

#define FRAC_BITS

Definition: g729postfilter.c:33

av_frame_alloc

AVFrame * av_frame_alloc(void)

Allocate an AVFrame and set its fields to default values.

Definition: frame.c:189

av_assert2

#define av_assert2(cond)

assert() equivalent, that does lie in speed critical code.

Definition: avassert.h:64

opt.h

AVOptions.

color

static const uint32_t color[16+AV_CLASS_CATEGORY_NB]

Definition: log.c:92

SnowContext::ref_scores

uint32_t * ref_scores[MAX_REF_FRAMES]

Definition: snow.h:145

frame

static AVFrame * frame

Definition: demuxing_decoding.c:53

height

#define height

BlockNode::my

int16_t my

Motion vector component Y, see mv_scale.

Definition: snow.h:53

snow_dwt.h

SnowContext

Definition: snow.h:114

lrintf

#define lrintf(x)

Definition: libm_mips.h:70

ff_snow_release_buffer

void ff_snow_release_buffer(AVCodecContext *avctx)

Definition: snow.c:640

av_log

#define av_log(a,...)

Definition: tableprint_vlc.h:28

SubBand

Definition: cfhd.h:43

SnowContext::block

BlockNode * block

Definition: snow.h:171

EDGE_WIDTH

#define EDGE_WIDTH

Definition: mpegpicture.h:33

mca

#define mca(dx, dy, b_w)

Definition: snow.c:415

SnowContext::dwt

SnowDWTContext dwt

Definition: snow.h:124

AVFrame::width

int width

Definition: frame.h:276

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:176

SnowContext::ref_mvs

int16_t(*[MAX_REF_FRAMES] ref_mvs)[2]

Definition: snow.h:144

MB_SIZE

#define MB_SIZE

Definition: cinepakenc.c:54

halfpel_interpol

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

Definition: snow.c:588

AVERROR

#define AVERROR(e)

Definition: error.h:43

av_frame_free

void av_frame_free(AVFrame **frame)

Free the frame and any dynamically allocated objects in it, e.g.

Definition: frame.c:202

Plane::diag_mc

int diag_mc

Definition: snow.h:106

const char * r

Definition: vf_curves.c:111

mcfh

#define mcfh(dx, dy)

width

uint16_t width

Definition: gdv.c:47

h263.h

offset

static const uint8_t offset[127][2]

Definition: vf_spp.c:92

FFMAX

#define FFMAX(a, b)

Definition: common.h:94

fail

#define fail()

Definition: checkasm.h:116

H264QpelContext::put_h264_qpel_pixels_tab

qpel_mc_func put_h264_qpel_pixels_tab[4][16]

Definition: h264qpel.h:28

SnowContext::emu_edge_buffer

uint8_t * emu_edge_buffer

Definition: snow.h:186

BlockNode::color

uint8_t color[3]

Color for intra.

Definition: snow.h:55

SnowContext::ref_frames

int ref_frames

Definition: snow.h:143

ff_hpeldsp_init

av_cold void ff_hpeldsp_init(HpelDSPContext *c, int flags)

Definition: hpeldsp.c:338

SubBand::x_coeff

x_and_coeff * x_coeff

Definition: snow.h:94

USE_HALFPEL_PLANE

#define USE_HALFPEL_PLANE

Definition: snow.c:586

Plane::band

SubBand band[DWT_LEVELS][4]

Definition: cfhd.h:68

SubBand::ibuf

uint8_t * ibuf

Definition: cfhd.h:53

mc_block

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)

Definition: snow.c:134

init_qexp

static av_cold void init_qexp(void)

Definition: snow.c:125

AVCodecContext::width

int width

picture width / height.

Definition: avcodec.h:1690

uint8_t w

Definition: llviddspenc.c:38

mathops.h

SnowContext::scratchbuf

uint8_t * scratchbuf

Definition: snow.h:185

#define a2

Definition: regdef.h:48

SnowContext::plane

Plane plane[MAX_PLANES]

Definition: snow.h:170

MAX_PLANES

#define MAX_PLANES

Definition: ffv1.h:50

SnowContext::b_width

int b_width

Definition: snow.h:165

MpegEncContext::me

MotionEstContext me

Definition: mpegvideo.h:282

SnowContext::chroma_h_shift

int chroma_h_shift

Definition: snow.h:152

AVCodecContext::height

int height

Definition: avcodec.h:1690

SnowContext::vdsp

VideoDSPContext vdsp

Definition: snow.h:121

intmath.h

SnowContext::halfpel_plane

uint8_t * halfpel_plane[MAX_REF_FRAMES][4][4]

Definition: snow.h:128

me_cmp.h

AVFrame::format

int format

format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames...

Definition: frame.h:291

SnowContext::block_state

uint8_t block_state[128+32 *128]

Definition: snow.h:132

ff_scale_mv_ref

int ff_scale_mv_ref[MAX_REF_FRAMES][MAX_REF_FRAMES]

Definition: snowdata.h:129

src1

#define src1

Definition: h264pred.c:139

#define a5

Definition: regdef.h:51

ff_snow_get_buffer

int ff_snow_get_buffer(SnowContext *s, AVFrame *frame)

Definition: snow.c:69

avcodec.h

Libavcodec external API header.

LOG2_OBMC_MAX

#define LOG2_OBMC_MAX

Definition: snow.h:49

SnowContext::spatial_decomposition_count

int spatial_decomposition_count

Definition: snow.h:139

DWTELEM

int DWTELEM

Definition: dirac_dwt.h:26

AVFrame::linesize

int linesize[AV_NUM_DATA_POINTERS]

For video, size in bytes of each picture line.

Definition: frame.h:249

AVCodecContext

main external API structure.

Definition: avcodec.h:1518

Plane::hcoeff

int8_t hcoeff[HTAPS_MAX/2]

Definition: snow.h:105

QROOT

#define QROOT

Definition: snow.h:44

ff_snow_pred_block

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, const BlockNode *block, int plane_index, int w, int h)

Definition: snow.c:327

ff_snow_alloc_blocks

int ff_snow_alloc_blocks(SnowContext *s)

Definition: snow.c:110

ff_get_buffer

int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)

Get a buffer for a frame.

Definition: decode.c:1891

SubBand::parent

struct SubBand * parent

Definition: diracdec.c:99

SnowContext::nb_planes