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 <assert.h>

23 #include "libavutil/log.h"

24 #include "libavutil/mem.h"

25 #include "libavutil/thread.h"

26 #include "avcodec.h"

27 #include "snow_dwt.h"

28 #include "snow.h"

29 #include "snowdata.h"

31 #define pixeltmp int16_t

32 #define BIT_DEPTH 8

33 #define SNOW

34 #include "h264qpel_template.c"

36 static void put_snow_qpel2_h_lowpass_8(uint8_t *dst, const uint8_t *restrict src, int dstStride, int srcStride)

37 {

38 const int h = 2;

39 for (int i = 0; i < h; ++i) {

40 dst[0] = av_clip_uint8(((src[0]+src[1])*20 - (src[-1]+src[2])*5 + (src[-2]+src[3]) + 16) >> 5);

41 dst[1] = av_clip_uint8(((src[1]+src[2])*20 - (src[0 ]+src[3])*5 + (src[-1]+src[4]) + 16) >> 5);

42 dst += dstStride;

43 src += srcStride;

44 }

45 }

47 static void put_snow_qpel2_v_lowpass_8(uint8_t *dst, const uint8_t *restrict src, int dstStride, int srcStride)

48 {

49 const int w = 2;

50 for (int i = 0; i < w; ++i) {

51 const int srcB = src[-2*srcStride];

52 const int srcA = src[-1*srcStride];

53 const int src0 = src[0 *srcStride];

54 const int src1 = src[1 *srcStride];

55 const int src2 = src[2 *srcStride];

56 const int src3 = src[3 *srcStride];

57 const int src4 = src[4 *srcStride];

58 dst[0*dstStride] = av_clip_uint8(((src0+src1)*20 - (srcA+src2)*5 + (srcB+src3) + 16) >> 5);

59 dst[1*dstStride] = av_clip_uint8(((src1+src2)*20 - (src0+src3)*5 + (srcA+src4) + 16) >> 5);

60 dst++;

61 src++;

62 }

63 }

65 static void put_snow_qpel2_hv_lowpass_8(uint8_t *dst, pixeltmp *tmp, const uint8_t *restrict src, int dstStride, int tmpStride, int srcStride)

66 {

67 const int h = 2;

68 const int w = 2;

69 src -= 2*srcStride;

70 for (int i = 0; i < h + 5; ++i) {

71 tmp[0] = (src[0]+src[1])*20 - (src[-1]+src[2])*5 + (src[-2]+src[3]);

72 tmp[1] = (src[1]+src[2])*20 - (src[0 ]+src[3])*5 + (src[-1]+src[4]);

73 tmp += tmpStride;

74 src += srcStride;

75 }

76 tmp -= tmpStride*(h+5-2);

77 for (int i = 0; i < w; ++i) {

78 const int tmpB = tmp[-2*tmpStride];

79 const int tmpA = tmp[-1*tmpStride];

80 const int tmp0 = tmp[0 *tmpStride];

81 const int tmp1 = tmp[1 *tmpStride];

82 const int tmp2 = tmp[2 *tmpStride];

83 const int tmp3 = tmp[3 *tmpStride];

84 const int tmp4 = tmp[4 *tmpStride];

85 dst[0*dstStride] = av_clip_uint8(((tmp0+tmp1)*20 - (tmpA+tmp2)*5 + (tmpB+tmp3) + 512) >> 10);

86 dst[1*dstStride] = av_clip_uint8(((tmp1+tmp2)*20 - (tmp0+tmp3)*5 + (tmpA+tmp4) + 512) >> 10);

87 dst++;

88 tmp++;

89 }

90 }

92 H264_MC(put_, snow, 2)

94 static av_cold void init_qpel(SnowContext *const s)

95 {

96 static_assert(offsetof(H264QpelContext, put_h264_qpel_pixels_tab) == 0,

97 "put_h264_qpel_pixels_tab not at start of H264QpelContext");

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

99 s->put_snow_qpel_pixels_tab[3][0] = put_snow_qpel2_mc00_8_c;

100 s->put_snow_qpel_pixels_tab[3][1] = put_snow_qpel2_mc10_8_c;

101 s->put_snow_qpel_pixels_tab[3][2] = put_snow_qpel2_mc20_8_c;

102 s->put_snow_qpel_pixels_tab[3][3] = put_snow_qpel2_mc30_8_c;

103 s->put_snow_qpel_pixels_tab[3][4] = put_snow_qpel2_mc01_8_c;

104 s->put_snow_qpel_pixels_tab[3][5] = put_snow_qpel2_mc11_8_c;

105 s->put_snow_qpel_pixels_tab[3][6] = put_snow_qpel2_mc21_8_c;

106 s->put_snow_qpel_pixels_tab[3][7] = put_snow_qpel2_mc31_8_c;

107 s->put_snow_qpel_pixels_tab[3][8] = put_snow_qpel2_mc02_8_c;

108 s->put_snow_qpel_pixels_tab[3][9] = put_snow_qpel2_mc12_8_c;

109 s->put_snow_qpel_pixels_tab[3][10] = put_snow_qpel2_mc22_8_c;

110 s->put_snow_qpel_pixels_tab[3][11] = put_snow_qpel2_mc32_8_c;

111 s->put_snow_qpel_pixels_tab[3][12] = put_snow_qpel2_mc03_8_c;

112 s->put_snow_qpel_pixels_tab[3][13] = put_snow_qpel2_mc13_8_c;

113 s->put_snow_qpel_pixels_tab[3][14] = put_snow_qpel2_mc23_8_c;

114 s->put_snow_qpel_pixels_tab[3][15] = put_snow_qpel2_mc33_8_c;

115 }

116

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

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

119 int y, x;

120 IDWTELEM * dst;

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

122 //FIXME ugly misuse of obmc_stride

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

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

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

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

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

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

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

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

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

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

133

134 v <<= 8 - LOG2_OBMC_MAX;

135 if(FRAC_BITS != 8){

136 v >>= 8 - FRAC_BITS;

137 }

138 if(add){

139 v += dst[x + src_x];

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

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

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

143 }else{

144 dst[x + src_x] -= v;

145 }

146 }

147 }

148 }

149

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

151 int plane_index, level, orientation;

152

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

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

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

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

157 }

158 }

159 }

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

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

162 }

163

164 int ff_snow_alloc_blocks(SnowContext *s){

165 int w= AV_CEIL_RSHIFT(s->avctx->width, LOG2_MB_SIZE);

166 int h= AV_CEIL_RSHIFT(s->avctx->height, LOG2_MB_SIZE);

167

168 s->b_width = w;

169 s->b_height= h;

170

171 av_free(s->block);

172 s->block = av_calloc(w * h, sizeof(*s->block) << (s->block_max_depth*2));

173 if (!s->block)

174 return AVERROR(ENOMEM);

175

176 return 0;

177 }

178

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

180 static const uint8_t weight[64]={

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

182 7,7,0,0,0,0,0,1,

183 6,0,6,0,0,0,2,0,

184 5,0,0,5,0,3,0,0,

185 4,0,0,0,4,0,0,0,

186 3,0,0,5,0,3,0,0,

187 2,0,6,0,0,0,2,0,

188 1,7,0,0,0,0,0,1,

189 };

190

191 static const uint8_t brane[256]={

192 0x00,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x11,0x12,0x12,0x12,0x12,0x12,0x12,0x12,

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

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

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

196 0x04,0xcc,0xcc,0xcc,0x41,0xcc,0xcc,0xcc,0x15,0xcc,0xcc,0xcc,0x16,0xcc,0xcc,0xcc,

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

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

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

200 0x44,0x45,0x45,0x45,0x45,0x45,0x45,0x45,0x55,0x56,0x56,0x56,0x56,0x56,0x56,0x56,

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

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

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

204 0x48,0xcc,0xcc,0xcc,0x49,0xcc,0xcc,0xcc,0x59,0xcc,0xcc,0xcc,0x96,0xcc,0xcc,0xcc,

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

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

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

208 };

209

210 static const uint8_t needs[16]={

211 0,1,0,0,

212 2,4,2,0,

213 0,1,0,0,

214 15

215 };

216

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

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

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

220 int16_t *tmpI= tmpIt;

221 uint8_t *tmp2= tmp2t[0];

222 const uint8_t *hpel[11];

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

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

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

226

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

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

229 b= 15;

230

231 if(b&5){

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

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

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

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

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

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

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

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

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

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

242 int am=0;

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

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

245 tmpI[x]= am;

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

247 }else{

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

249 tmpI[x]= am;

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

251 }

252

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

254 tmp2[x]= am;

255 }

256 tmpI+= 64;

257 tmp2+= 64;

258 src += stride;

259 }

260 src -= stride*y;

261 }

262 src += HTAPS_MAX/2 - 1;

263 tmp2= tmp2t[1];

264

265 if(b&2){

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

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

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

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

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

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

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

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

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

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

276 int am=0;

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

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

279 else

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

281

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

283 tmp2[x]= am;

284 }

285 src += stride;

286 tmp2+= 64;

287 }

288 src -= stride*y;

289 }

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

291 tmp2= tmp2t[2];

292 tmpI= tmpIt;

293 if(b&4){

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

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

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

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

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

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

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

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

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

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

304 int am=0;

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

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

307 else

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

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

310 tmp2[x]= am;

311 }

312 tmpI+= 64;

313 tmp2+= 64;

314 }

315 }

316

317 hpel[ 0]= src;

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

319 hpel[ 2]= src + 1;

320

321 hpel[ 4]= tmp2t[1];

322 hpel[ 5]= tmp2t[2];

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

324

325 hpel[ 8]= src + stride;

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

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

328

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

330

331 if(b==15){

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

333 const uint8_t *src1 = hpel[dxy ];

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

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

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

337 int stride1 = MC_STRIDE(dxy);

338 int stride2 = MC_STRIDE(dxy + 1);

339 int stride3 = MC_STRIDE(dxy + 4);

340 int stride4 = MC_STRIDE(dxy + 5);

341 dx&=7;

342 dy&=7;

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

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

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

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

347 }

348 src1+=stride1;

349 src2+=stride2;

350 src3+=stride3;

351 src4+=stride4;

352 dst +=stride;

353 }

354 }else{

355 const uint8_t *src1= hpel[l];

356 const uint8_t *src2= hpel[r];

357 int stride1 = MC_STRIDE(l);

358 int stride2 = MC_STRIDE(r);

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

360 int b= 8-a;

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

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

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

364 }

365 src1+=stride1;

366 src2+=stride2;

367 dst +=stride;

368 }

369 }

370 }

371

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

373 if(block->type & BLOCK_INTRA){

374 int x, y;

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

376 const unsigned color4 = color*0x01010101;

377 if(b_w==32){

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

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

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

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

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

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

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

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

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

387 }

388 }else if(b_w==16){

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

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

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

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

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

394 }

395 }else if(b_w==8){

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

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

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

399 }

400 }else if(b_w==4){

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

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

403 }

404 }else{

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

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

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

408 }

409 }

410 }

411 }else{

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

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

414 int mx= block->mx*scale;

415 int my= block->my*scale;

416 const int dx= mx&15;

417 const int dy= my&15;

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

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

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

421 src += sx + sy*stride;

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

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

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

425 stride, stride,

426 b_w+HTAPS_MAX-1, b_h+HTAPS_MAX-1,

427 sx, sy, w, h);

428 src= tmp + MB_SIZE;

429 }

430

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

432

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

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

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

436 || (b_w&(b_w-1))

437 || b_w == 1

438 || b_h == 1

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

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

441 else if(b_w==32){

442 int y;

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

444 s->put_snow_qpel_pixels_tab[0][dy+(dx>>2)](dst + y*stride, src + 3 + (y+3)*stride,stride);

445 s->put_snow_qpel_pixels_tab[0][dy+(dx>>2)](dst + 16 + y*stride, src + 19 + (y+3)*stride,stride);

446 }

447 }else if(b_w==b_h)

448 s->put_snow_qpel_pixels_tab[tab_index ][dy+(dx>>2)](dst,src + 3 + 3*stride,stride);

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

450 s->put_snow_qpel_pixels_tab[tab_index+1][dy+(dx>>2)](dst ,src + 3 + 3*stride,stride);

451 s->put_snow_qpel_pixels_tab[tab_index+1][dy+(dx>>2)](dst+b_h,src + 3 + b_h + 3*stride,stride);

452 }else{

453 av_assert2(2*b_w==b_h);

454 s->put_snow_qpel_pixels_tab[tab_index ][dy+(dx>>2)](dst ,src + 3 + 3*stride ,stride);

455 s->put_snow_qpel_pixels_tab[tab_index ][dy+(dx>>2)](dst+b_w*stride,src + 3 + 3*stride+b_w*stride,stride);

456 }

457 }

458 }

459

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

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

462 av_assert2(h==b_w);\

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

464 }

465

466 mca( 0, 0,16)

467 mca( 8, 0,16)

468 mca( 0, 8,16)

469 mca( 8, 8,16)

470 mca( 0, 0,8)

471 mca( 8, 0,8)

472 mca( 0, 8,8)

473 mca( 8, 8,8)

474

475 static av_cold void snow_static_init(void)

476 {

477 for (int i = 0; i < MAX_REF_FRAMES; i++)

478 for (int j = 0; j < MAX_REF_FRAMES; j++)

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

480 }

481

482 av_cold int ff_snow_common_init(AVCodecContext *avctx){

483 static AVOnce init_static_once = AV_ONCE_INIT;

484 SnowContext *s = avctx->priv_data;

485 int width, height;

486 int i;

487

488 s->avctx= avctx;

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

490 s->spatial_decomposition_count = 1;

491

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

493 ff_dwt_init(&s->dwt);

494

495 init_qpel(s);

496

497 #define mcfh(dx,dy)\

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

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

500 mc_block_hpel ## dx ## dy ## 16;\

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

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

503 mc_block_hpel ## dx ## dy ## 8;

504

505 mcfh(0, 0)

506 mcfh(8, 0)

507 mcfh(0, 8)

508 mcfh(8, 8)

509

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

511

512 width= s->avctx->width;

513 height= s->avctx->height;

514

515 if (!FF_ALLOCZ_TYPED_ARRAY(s->spatial_idwt_buffer, width * height) ||

516 !FF_ALLOCZ_TYPED_ARRAY(s->spatial_dwt_buffer, width * height) || //FIXME this does not belong here

517 !FF_ALLOCZ_TYPED_ARRAY(s->temp_dwt_buffer, width) ||

518 !FF_ALLOCZ_TYPED_ARRAY(s->temp_idwt_buffer, width) ||

519 !FF_ALLOCZ_TYPED_ARRAY(s->run_buffer, ((width + 1) >> 1) * ((height + 1) >> 1) + 1))

520 return AVERROR(ENOMEM);

521

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

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

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

525 return AVERROR(ENOMEM);

526 }

527

528 s->mconly_picture = av_frame_alloc();

529 s->current_picture = av_frame_alloc();

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

531 return AVERROR(ENOMEM);

532

533 ff_thread_once(&init_static_once, snow_static_init);

534

535 return 0;

536 }

537

538 int ff_snow_common_init_after_header(AVCodecContext *avctx) {

539 SnowContext *s = avctx->priv_data;

540 int plane_index, level, orientation;

541

542 if(!s->scratchbuf) {

543 int emu_buf_size;

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

545 if (!FF_ALLOCZ_TYPED_ARRAY(s->scratchbuf, FFMAX(s->mconly_picture->linesize[0], 2*avctx->width+256) * 7 * MB_SIZE) ||

546 !FF_ALLOCZ_TYPED_ARRAY(s->emu_edge_buffer, emu_buf_size))

547 return AVERROR(ENOMEM);

548 }

549

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

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

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

553

554 if(plane_index){

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

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

557 }

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

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

560

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

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

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

564

565 b->buf= s->spatial_dwt_buffer;

566 b->level= level;

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

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

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

570

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

572 b->buf_x_offset = 0;

573 b->buf_y_offset = 0;

574

575 if(orientation&1){

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

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

578 }

579 if(orientation>1){

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

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

582 }

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

584

585 if(level)

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

587 //FIXME avoid this realloc

588 av_freep(&b->x_coeff);

589 b->x_coeff = av_calloc((b->width + 1) * b->height + 1,

590 sizeof(*b->x_coeff));

591 if (!b->x_coeff)

592 return AVERROR(ENOMEM);

593 }

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

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

596 }

597 }

598

599 return 0;

600 }

601

602 int ff_snow_frames_prepare(SnowContext *s)

603 {

604 AVFrame *tmp;

605

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

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

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

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

610 s->current_picture = tmp;

611

612 av_frame_unref(s->current_picture);

613

614 if(s->keyframe){

615 s->ref_frames= 0;

616 s->current_picture->flags |= AV_FRAME_FLAG_KEY;

617 }else{

618 int i;

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

620 if(i && (s->last_picture[i-1]->flags & AV_FRAME_FLAG_KEY))

621 break;

622 s->ref_frames= i;

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

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

625 return AVERROR_INVALIDDATA;

626 }

627 s->current_picture->flags &= ~AV_FRAME_FLAG_KEY;

628 }

629

630 return 0;

631 }

632

633 av_cold void ff_snow_common_end(SnowContext *s)

634 {

635 int plane_index, level, orientation, i;

636

637 av_freep(&s->spatial_dwt_buffer);

638 av_freep(&s->temp_dwt_buffer);

639 av_freep(&s->spatial_idwt_buffer);

640 av_freep(&s->temp_idwt_buffer);

641 av_freep(&s->run_buffer);

642

643 av_freep(&s->block);

644 av_freep(&s->scratchbuf);

645 av_freep(&s->emu_edge_buffer);

646

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

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

649 }

650

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

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

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

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

655

656 av_freep(&b->x_coeff);

657 }

658 }

659 }

660 av_frame_free(&s->mconly_picture);

661 av_frame_free(&s->current_picture);

662 }

FF_ALLOCZ_TYPED_ARRAY

#define FF_ALLOCZ_TYPED_ARRAY(p, nelem)

Definition: internal.h:78

put_snow_qpel2_v_lowpass_8

static void put_snow_qpel2_v_lowpass_8(uint8_t *dst, const uint8_t *restrict src, int dstStride, int srcStride)

Definition: snow.c:47

MC_STRIDE

#define MC_STRIDE(x)

level

uint8_t level

Definition: svq3.c:208

MAX_DECOMPOSITIONS

#define MAX_DECOMPOSITIONS

Definition: dirac_dwt.h:30

const char * r

Definition: vf_curves.c:127

AVERROR

Filter the word "frame" indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions

h264qpel_template.c

color

Definition: vf_paletteuse.c:513

MID_STATE

#define MID_STATE

Definition: snow.h:39

thread.h

src1

const pixel * src1

Definition: h264pred_template.c:420

LOG2_MB_SIZE

#define LOG2_MB_SIZE

Definition: snow.h:72

av_frame_free

void av_frame_free(AVFrame **frame)

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

Definition: frame.c:64

AVFrame

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

Definition: frame.h:427

uint8_t w

Definition: llviddspenc.c:38

#define b

Definition: input.c:42

mcfh

#define mcfh(dx, dy)

FFMAX

#define FFMAX(a, b)

Definition: macros.h:47

SnowContext

Definition: snow.h:113

MAX_REF_FRAMES

#define MAX_REF_FRAMES

Definition: snow.h:46

put_snow_qpel2_hv_lowpass_8

static void put_snow_qpel2_hv_lowpass_8(uint8_t *dst, pixeltmp *tmp, const uint8_t *restrict src, int dstStride, int tmpStride, int srcStride)

Definition: snow.c:65

ff_snow_common_end

av_cold void ff_snow_common_end(SnowContext *s)

Definition: snow.c:633

uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t mx

Definition: dsp.h:57

LOG2_OBMC_MAX

#define LOG2_OBMC_MAX

Definition: snow.h:48

BlockNode

Definition: snow.h:50

weight

const h264_weight_func weight

Definition: h264dsp_init.c:33

ff_videodsp_init

av_cold void ff_videodsp_init(VideoDSPContext *ctx, int bpc)

Definition: videodsp.c:39

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:372

ff_h264qpel_init

av_cold void ff_h264qpel_init(H264QpelContext *c, int bit_depth)

Definition: h264qpel.c:50

static double a2(void *priv, double x, double y)

Definition: vf_xfade.c:2030

ff_dwt_init

av_cold void ff_dwt_init(SnowDWTContext *c)

Definition: snow_dwt.c:851

av_frame_alloc

AVFrame * av_frame_alloc(void)

Allocate an AVFrame and set its fields to default values.

Definition: frame.c:52

ff_snow_common_init_after_header

int ff_snow_common_init_after_header(AVCodecContext *avctx)

Definition: snow.c:538

ff_thread_once

static int ff_thread_once(char *control, void(*routine)(void))

Definition: thread.h:205

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:210

av_cold

#define av_cold

Definition: attributes.h:106

AV_FRAME_FLAG_KEY

#define AV_FRAME_FLAG_KEY

A flag to mark frames that are keyframes.

Definition: frame.h:642

#define s(width, name)

Definition: cbs_vp9.c:198

MAX_PLANES

#define MAX_PLANES

Definition: ffv1.h:44

AV_CEIL_RSHIFT

#define AV_CEIL_RSHIFT(a, b)

Definition: common.h:60

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:179

ff_snow_common_init

av_cold int ff_snow_common_init(AVCodecContext *avctx)

Definition: snow.c:482

tmp

static uint8_t tmp[40]

Definition: aes_ctr.c:52

uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t my

Definition: dsp.h:57

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:117

AV_ONCE_INIT

#define AV_ONCE_INIT

Definition: thread.h:203

static double a3(void *priv, double x, double y)

Definition: vf_xfade.c:2031

snow.h

snowdata.h

AVOnce

#define AVOnce

Definition: thread.h:202

init_qpel

static av_cold void init_qpel(SnowContext *const s)

Definition: snow.c:94

MB_SIZE

#define MB_SIZE

Definition: cinepakenc.c:54

height

#define height

Definition: dsp.h:89

dst

uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t int int16_t * dst

Definition: dsp.h:87

obmc4

static const uint8_t obmc4[16]

Definition: snowdata.h:96

color

static const uint32_t color[16+AV_CLASS_CATEGORY_NB]

Definition: log.c:97

SubBand

Definition: cfhd.h:107

pixeltmp

#define pixeltmp

Definition: snow.c:31

The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a

Definition: undefined.txt:41

static double a0(void *priv, double x, double y)

Definition: vf_xfade.c:2028

snow_dwt.h

put_snow_qpel2_h_lowpass_8

static void put_snow_qpel2_h_lowpass_8(uint8_t *dst, const uint8_t *restrict src, int dstStride, int srcStride)

Definition: snow.c:36

av_assert2

#define av_assert2(cond)

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

Definition: avassert.h:68

log.h