FFmpeg
Loading...
Searching...
No Matches
snow.c
Go to the documentation of this file.
1/*
2 * Copyright (C) 2004 Michael Niedermayer <michaelni@gmx.at>
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 */
20
21#include <assert.h>
22
23#include "libavutil/avassert.h"
24#include "libavutil/log.h"
25#include "libavutil/mem.h"
26#include "libavutil/thread.h"
27#include "avcodec.h"
28#include "snow_dwt.h"
29#include "snow.h"
30#include "snowdata.h"
31
32#define pixeltmp int16_t
33#define BIT_DEPTH 8
34#define SNOW
35#include "h264qpel_template.c"
36
37static void put_snow_qpel2_h_lowpass_8(uint8_t *dst, const uint8_t *restrict src, int dstStride, int srcStride)
38{
39 const int h = 2;
40 for (int i = 0; i < h; ++i) {
41 dst[0] = av_clip_uint8(((src[0]+src[1])*20 - (src[-1]+src[2])*5 + (src[-2]+src[3]) + 16) >> 5);
42 dst[1] = av_clip_uint8(((src[1]+src[2])*20 - (src[0 ]+src[3])*5 + (src[-1]+src[4]) + 16) >> 5);
43 dst += dstStride;
44 src += srcStride;
45 }
46}
47
48static void put_snow_qpel2_v_lowpass_8(uint8_t *dst, const uint8_t *restrict src, int dstStride, int srcStride)
49{
50 const int w = 2;
51 for (int i = 0; i < w; ++i) {
52 const int srcB = src[-2*srcStride];
53 const int srcA = src[-1*srcStride];
54 const int src0 = src[0 *srcStride];
55 const int src1 = src[1 *srcStride];
56 const int src2 = src[2 *srcStride];
57 const int src3 = src[3 *srcStride];
58 const int src4 = src[4 *srcStride];
59 dst[0*dstStride] = av_clip_uint8(((src0+src1)*20 - (srcA+src2)*5 + (srcB+src3) + 16) >> 5);
60 dst[1*dstStride] = av_clip_uint8(((src1+src2)*20 - (src0+src3)*5 + (srcA+src4) + 16) >> 5);
61 dst++;
62 src++;
63 }
64}
65
66static void put_snow_qpel2_hv_lowpass_8(uint8_t *dst, pixeltmp *tmp, const uint8_t *restrict src, int dstStride, int tmpStride, int srcStride)
67{
68 const int h = 2;
69 const int w = 2;
70 src -= 2*srcStride;
71 for (int i = 0; i < h + 5; ++i) {
72 tmp[0] = (src[0]+src[1])*20 - (src[-1]+src[2])*5 + (src[-2]+src[3]);
73 tmp[1] = (src[1]+src[2])*20 - (src[0 ]+src[3])*5 + (src[-1]+src[4]);
74 tmp += tmpStride;
75 src += srcStride;
76 }
77 tmp -= tmpStride*(h+5-2);
78 for (int i = 0; i < w; ++i) {
79 const int tmpB = tmp[-2*tmpStride];
80 const int tmpA = tmp[-1*tmpStride];
81 const int tmp0 = tmp[0 *tmpStride];
82 const int tmp1 = tmp[1 *tmpStride];
83 const int tmp2 = tmp[2 *tmpStride];
84 const int tmp3 = tmp[3 *tmpStride];
85 const int tmp4 = tmp[4 *tmpStride];
86 dst[0*dstStride] = av_clip_uint8(((tmp0+tmp1)*20 - (tmpA+tmp2)*5 + (tmpB+tmp3) + 512) >> 10);
87 dst[1*dstStride] = av_clip_uint8(((tmp1+tmp2)*20 - (tmp0+tmp3)*5 + (tmpA+tmp4) + 512) >> 10);
88 dst++;
89 tmp++;
90 }
91}
92
93H264_QPEL(put_, snow, 2)
94
95static av_cold void init_qpel(SnowContext *const s)
96{
97 static_assert(offsetof(H264QpelContext, put_h264_qpel_pixels_tab) == 0,
98 "put_h264_qpel_pixels_tab not at start of H264QpelContext");
99 ff_h264qpel_init(&s->h264qpel, 8);
100 s->put_snow_qpel_pixels_tab[3][0] = put_snow_qpel2_mc00_8_c;
101 s->put_snow_qpel_pixels_tab[3][1] = put_snow_qpel2_mc10_8_c;
102 s->put_snow_qpel_pixels_tab[3][2] = put_snow_qpel2_mc20_8_c;
103 s->put_snow_qpel_pixels_tab[3][3] = put_snow_qpel2_mc30_8_c;
104 s->put_snow_qpel_pixels_tab[3][4] = put_snow_qpel2_mc01_8_c;
105 s->put_snow_qpel_pixels_tab[3][5] = put_snow_qpel2_mc11_8_c;
106 s->put_snow_qpel_pixels_tab[3][6] = put_snow_qpel2_mc21_8_c;
107 s->put_snow_qpel_pixels_tab[3][7] = put_snow_qpel2_mc31_8_c;
108 s->put_snow_qpel_pixels_tab[3][8] = put_snow_qpel2_mc02_8_c;
109 s->put_snow_qpel_pixels_tab[3][9] = put_snow_qpel2_mc12_8_c;
110 s->put_snow_qpel_pixels_tab[3][10] = put_snow_qpel2_mc22_8_c;
111 s->put_snow_qpel_pixels_tab[3][11] = put_snow_qpel2_mc32_8_c;
112 s->put_snow_qpel_pixels_tab[3][12] = put_snow_qpel2_mc03_8_c;
113 s->put_snow_qpel_pixels_tab[3][13] = put_snow_qpel2_mc13_8_c;
114 s->put_snow_qpel_pixels_tab[3][14] = put_snow_qpel2_mc23_8_c;
115 s->put_snow_qpel_pixels_tab[3][15] = put_snow_qpel2_mc33_8_c;
116}
117
118void ff_snow_inner_add_yblock_c(const uint8_t *obmc, const int obmc_stride, uint8_t **block, int b_w, int b_h,
119 int src_x, int src_stride, IDWTELEM *const *lines, int add, uint8_t *dst8)
120{
121 int y, x;
122
123 av_assume(add); // add == 0 is currently unused
124
125 for(y=0; y<b_h; y++){
126 //FIXME ugly misuse of obmc_stride
127 const uint8_t *obmc1= obmc + y*obmc_stride;
128 const uint8_t *obmc2= obmc1+ (obmc_stride>>1);
129 const uint8_t *obmc3= obmc1+ obmc_stride*(obmc_stride>>1);
130 const uint8_t *obmc4= obmc3+ (obmc_stride>>1);
131 IDWTELEM *dst = lines[y];
132 av_assert2(dst);
133
134 for(x=0; x<b_w; x++){
135 int v= obmc1[x] * block[3][x + y*src_stride]
136 +obmc2[x] * block[2][x + y*src_stride]
137 +obmc3[x] * block[1][x + y*src_stride]
138 +obmc4[x] * block[0][x + y*src_stride];
139
140#if FRAC_BITS > LOG2_OBMC_MAX
141 v <<= FRAC_BITS - LOG2_OBMC_MAX;
142#elif FRAC_BITS < LOG2_OBMC_MAX
143 v >>= LOG2_OBMC_MAX - FRAC_BITS;
144#endif
145 if(add){
146 v += dst[x + src_x];
147 v = (v + (1<<(FRAC_BITS-1))) >> FRAC_BITS;
148 if(v&(~255)) v= ~(v>>31);
149 dst8[x + y*src_stride] = v;
150 }else{
151 dst[x + src_x] -= v;
152 }
153 }
154 }
155}
156
157void ff_snow_reset_contexts(SnowContext *s){ //FIXME better initial contexts
158 int plane_index, level, orientation;
159
160 for(plane_index=0; plane_index<3; plane_index++){
161 for(level=0; level<MAX_DECOMPOSITIONS; level++){
162 for(orientation=level ? 1:0; orientation<4; orientation++){
163 memset(s->plane[plane_index].band[level][orientation].state, MID_STATE, sizeof(s->plane[plane_index].band[level][orientation].state));
164 }
165 }
166 }
167 memset(s->header_state, MID_STATE, sizeof(s->header_state));
168 memset(s->block_state, MID_STATE, sizeof(s->block_state));
169}
170
171int ff_snow_alloc_blocks(SnowContext *s){
172 int w= AV_CEIL_RSHIFT(s->avctx->width, LOG2_MB_SIZE);
173 int h= AV_CEIL_RSHIFT(s->avctx->height, LOG2_MB_SIZE);
174
175 s->b_width = w;
176 s->b_height= h;
177
178 av_free(s->block);
179 s->block = av_calloc(w * h, sizeof(*s->block) << (s->block_max_depth*2));
180 if (!s->block)
181 return AVERROR(ENOMEM);
182
183 return 0;
184}
185
186static void mc_block(Plane *p, uint8_t *dst, const uint8_t *src, int stride, int b_w, int b_h, int dx, int dy){
187 static const uint8_t weight[64]={
188 8,7,6,5,4,3,2,1,
189 7,7,0,0,0,0,0,1,
190 6,0,6,0,0,0,2,0,
191 5,0,0,5,0,3,0,0,
192 4,0,0,0,4,0,0,0,
193 3,0,0,5,0,3,0,0,
194 2,0,6,0,0,0,2,0,
195 1,7,0,0,0,0,0,1,
196 };
197
198 static const uint8_t brane[256]={
199 0x00,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x11,0x12,0x12,0x12,0x12,0x12,0x12,0x12,
200 0x04,0x05,0xcc,0xcc,0xcc,0xcc,0xcc,0x41,0x15,0x16,0xcc,0xcc,0xcc,0xcc,0xcc,0x52,
201 0x04,0xcc,0x05,0xcc,0xcc,0xcc,0x41,0xcc,0x15,0xcc,0x16,0xcc,0xcc,0xcc,0x52,0xcc,
202 0x04,0xcc,0xcc,0x05,0xcc,0x41,0xcc,0xcc,0x15,0xcc,0xcc,0x16,0xcc,0x52,0xcc,0xcc,
203 0x04,0xcc,0xcc,0xcc,0x41,0xcc,0xcc,0xcc,0x15,0xcc,0xcc,0xcc,0x16,0xcc,0xcc,0xcc,
204 0x04,0xcc,0xcc,0x41,0xcc,0x05,0xcc,0xcc,0x15,0xcc,0xcc,0x52,0xcc,0x16,0xcc,0xcc,
205 0x04,0xcc,0x41,0xcc,0xcc,0xcc,0x05,0xcc,0x15,0xcc,0x52,0xcc,0xcc,0xcc,0x16,0xcc,
206 0x04,0x41,0xcc,0xcc,0xcc,0xcc,0xcc,0x05,0x15,0x52,0xcc,0xcc,0xcc,0xcc,0xcc,0x16,
207 0x44,0x45,0x45,0x45,0x45,0x45,0x45,0x45,0x55,0x56,0x56,0x56,0x56,0x56,0x56,0x56,
208 0x48,0x49,0xcc,0xcc,0xcc,0xcc,0xcc,0x85,0x59,0x5A,0xcc,0xcc,0xcc,0xcc,0xcc,0x96,
209 0x48,0xcc,0x49,0xcc,0xcc,0xcc,0x85,0xcc,0x59,0xcc,0x5A,0xcc,0xcc,0xcc,0x96,0xcc,
210 0x48,0xcc,0xcc,0x49,0xcc,0x85,0xcc,0xcc,0x59,0xcc,0xcc,0x5A,0xcc,0x96,0xcc,0xcc,
211 0x48,0xcc,0xcc,0xcc,0x49,0xcc,0xcc,0xcc,0x59,0xcc,0xcc,0xcc,0x96,0xcc,0xcc,0xcc,
212 0x48,0xcc,0xcc,0x85,0xcc,0x49,0xcc,0xcc,0x59,0xcc,0xcc,0x96,0xcc,0x5A,0xcc,0xcc,
213 0x48,0xcc,0x85,0xcc,0xcc,0xcc,0x49,0xcc,0x59,0xcc,0x96,0xcc,0xcc,0xcc,0x5A,0xcc,
214 0x48,0x85,0xcc,0xcc,0xcc,0xcc,0xcc,0x49,0x59,0x96,0xcc,0xcc,0xcc,0xcc,0xcc,0x5A,
215 };
216
217 static const uint8_t needs[16]={
218 0,1,0,0,
219 2,4,2,0,
220 0,1,0,0,
221 15
222 };
223
224 int x, y, b, r, l;
225 int16_t tmpIt [64*(32+HTAPS_MAX)];
226 uint8_t tmp2t[3][64*(32+HTAPS_MAX)];
227 int16_t *tmpI= tmpIt;
228 uint8_t *tmp2= tmp2t[0];
229 const uint8_t *hpel[11];
230 av_assert2(dx<16 && dy<16);
231 r= brane[dx + 16*dy]&15;
232 l= brane[dx + 16*dy]>>4;
233
234 b= needs[l] | needs[r];
235 if(p && !p->diag_mc)
236 b= 15;
237
238 if(b&5){
239 for(y=0; y < b_h+HTAPS_MAX-1; y++){
240 for(x=0; x < b_w; x++){
241 int a_1=src[x + HTAPS_MAX/2-4];
242 int a0= src[x + HTAPS_MAX/2-3];
243 int a1= src[x + HTAPS_MAX/2-2];
244 int a2= src[x + HTAPS_MAX/2-1];
245 int a3= src[x + HTAPS_MAX/2+0];
246 int a4= src[x + HTAPS_MAX/2+1];
247 int a5= src[x + HTAPS_MAX/2+2];
248 int a6= src[x + HTAPS_MAX/2+3];
249 int am=0;
250 if(!p || p->fast_mc){
251 am= 20*(a2+a3) - 5*(a1+a4) + (a0+a5);
252 tmpI[x]= am;
253 am= (am+16)>>5;
254 }else{
255 am= p->hcoeff[0]*(a2+a3) + p->hcoeff[1]*(a1+a4) + p->hcoeff[2]*(a0+a5) + p->hcoeff[3]*(a_1+a6);
256 tmpI[x]= am;
257 am= (am+32)>>6;
258 }
259
260 if(am&(~255)) am= ~(am>>31);
261 tmp2[x]= am;
262 }
263 tmpI+= 64;
264 tmp2+= 64;
265 src += stride;
266 }
267 src -= stride*y;
268 }
269 src += HTAPS_MAX/2 - 1;
270 tmp2= tmp2t[1];
271
272 if(b&2){
273 for(y=0; y < b_h; y++){
274 for(x=0; x < b_w+1; x++){
275 int a_1=src[x + (HTAPS_MAX/2-4)*stride];
276 int a0= src[x + (HTAPS_MAX/2-3)*stride];
277 int a1= src[x + (HTAPS_MAX/2-2)*stride];
278 int a2= src[x + (HTAPS_MAX/2-1)*stride];
279 int a3= src[x + (HTAPS_MAX/2+0)*stride];
280 int a4= src[x + (HTAPS_MAX/2+1)*stride];
281 int a5= src[x + (HTAPS_MAX/2+2)*stride];
282 int a6= src[x + (HTAPS_MAX/2+3)*stride];
283 int am=0;
284 if(!p || p->fast_mc)
285 am= (20*(a2+a3) - 5*(a1+a4) + (a0+a5) + 16)>>5;
286 else
287 am= (p->hcoeff[0]*(a2+a3) + p->hcoeff[1]*(a1+a4) + p->hcoeff[2]*(a0+a5) + p->hcoeff[3]*(a_1+a6) + 32)>>6;
288
289 if(am&(~255)) am= ~(am>>31);
290 tmp2[x]= am;
291 }
292 src += stride;
293 tmp2+= 64;
294 }
295 src -= stride*y;
296 }
297 src += stride*(HTAPS_MAX/2 - 1);
298 tmp2= tmp2t[2];
299 tmpI= tmpIt;
300 if(b&4){
301 for(y=0; y < b_h; y++){
302 for(x=0; x < b_w; x++){
303 int a_1=tmpI[x + (HTAPS_MAX/2-4)*64];
304 int a0= tmpI[x + (HTAPS_MAX/2-3)*64];
305 int a1= tmpI[x + (HTAPS_MAX/2-2)*64];
306 int a2= tmpI[x + (HTAPS_MAX/2-1)*64];
307 int a3= tmpI[x + (HTAPS_MAX/2+0)*64];
308 int a4= tmpI[x + (HTAPS_MAX/2+1)*64];
309 int a5= tmpI[x + (HTAPS_MAX/2+2)*64];
310 int a6= tmpI[x + (HTAPS_MAX/2+3)*64];
311 int am=0;
312 if(!p || p->fast_mc)
313 am= (20*(a2+a3) - 5*(a1+a4) + (a0+a5) + 512)>>10;
314 else
315 am= (p->hcoeff[0]*(a2+a3) + p->hcoeff[1]*(a1+a4) + p->hcoeff[2]*(a0+a5) + p->hcoeff[3]*(a_1+a6) + 2048)>>12;
316 if(am&(~255)) am= ~(am>>31);
317 tmp2[x]= am;
318 }
319 tmpI+= 64;
320 tmp2+= 64;
321 }
322 }
323
324 hpel[ 0]= src;
325 hpel[ 1]= tmp2t[0] + 64*(HTAPS_MAX/2-1);
326 hpel[ 2]= src + 1;
327
328 hpel[ 4]= tmp2t[1];
329 hpel[ 5]= tmp2t[2];
330 hpel[ 6]= tmp2t[1] + 1;
331
332 hpel[ 8]= src + stride;
333 hpel[ 9]= hpel[1] + 64;
334 hpel[10]= hpel[8] + 1;
335
336#define MC_STRIDE(x) (needs[x] ? 64 : stride)
337
338 if(b==15){
339 int dxy = dx / 8 + dy / 8 * 4;
340 const uint8_t *src1 = hpel[dxy ];
341 const uint8_t *src2 = hpel[dxy + 1];
342 const uint8_t *src3 = hpel[dxy + 4];
343 const uint8_t *src4 = hpel[dxy + 5];
344 int stride1 = MC_STRIDE(dxy);
345 int stride2 = MC_STRIDE(dxy + 1);
346 int stride3 = MC_STRIDE(dxy + 4);
347 int stride4 = MC_STRIDE(dxy + 5);
348 dx&=7;
349 dy&=7;
350 for(y=0; y < b_h; y++){
351 for(x=0; x < b_w; x++){
352 dst[x]= ((8-dx)*(8-dy)*src1[x] + dx*(8-dy)*src2[x]+
353 (8-dx)* dy *src3[x] + dx* dy *src4[x]+32)>>6;
354 }
355 src1+=stride1;
356 src2+=stride2;
357 src3+=stride3;
358 src4+=stride4;
359 dst +=stride;
360 }
361 }else{
362 const uint8_t *src1= hpel[l];
363 const uint8_t *src2= hpel[r];
364 int stride1 = MC_STRIDE(l);
365 int stride2 = MC_STRIDE(r);
366 int a= weight[((dx&7) + (8*(dy&7)))];
367 int b= 8-a;
368 for(y=0; y < b_h; y++){
369 for(x=0; x < b_w; x++){
370 dst[x]= (a*src1[x] + b*src2[x] + 4)>>3;
371 }
372 src1+=stride1;
373 src2+=stride2;
374 dst +=stride;
375 }
376 }
377}
378
379void 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){
380 if(block->type & BLOCK_INTRA){
381 int x, y;
382 const unsigned color = block->color[plane_index];
383 const unsigned color4 = color*0x01010101;
384 if(b_w==32){
385 for(y=0; y < b_h; y++){
386 *(uint32_t*)&dst[0 + y*stride]= color4;
387 *(uint32_t*)&dst[4 + y*stride]= color4;
388 *(uint32_t*)&dst[8 + y*stride]= color4;
389 *(uint32_t*)&dst[12+ y*stride]= color4;
390 *(uint32_t*)&dst[16+ y*stride]= color4;
391 *(uint32_t*)&dst[20+ y*stride]= color4;
392 *(uint32_t*)&dst[24+ y*stride]= color4;
393 *(uint32_t*)&dst[28+ y*stride]= color4;
394 }
395 }else if(b_w==16){
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 *(uint32_t*)&dst[8 + y*stride]= color4;
400 *(uint32_t*)&dst[12+ y*stride]= color4;
401 }
402 }else if(b_w==8){
403 for(y=0; y < b_h; y++){
404 *(uint32_t*)&dst[0 + y*stride]= color4;
405 *(uint32_t*)&dst[4 + y*stride]= color4;
406 }
407 }else if(b_w==4){
408 for(y=0; y < b_h; y++){
409 *(uint32_t*)&dst[0 + y*stride]= color4;
410 }
411 }else{
412 for(y=0; y < b_h; y++){
413 for(x=0; x < b_w; x++){
414 dst[x + y*stride]= color;
415 }
416 }
417 }
418 }else{
419 const uint8_t *src = s->last_picture[block->ref]->data[plane_index];
420 const int scale= plane_index ? (2*s->mv_scale)>>s->chroma_h_shift : 2*s->mv_scale;
421 int mx= block->mx*scale;
422 int my= block->my*scale;
423 const int dx= mx&15;
424 const int dy= my&15;
425 const int tab_index= 3 - (b_w>>2) + (b_w>>4);
426 sx += (mx>>4) - (HTAPS_MAX/2-1);
427 sy += (my>>4) - (HTAPS_MAX/2-1);
428 src += sx + sy*stride;
429 if( (unsigned)sx >= FFMAX(w - b_w - (HTAPS_MAX-2), 0)
430 || (unsigned)sy >= FFMAX(h - b_h - (HTAPS_MAX-2), 0)){
431 s->vdsp.emulated_edge_mc(tmp + MB_SIZE, src,
432 stride, stride,
433 b_w+HTAPS_MAX-1, b_h+HTAPS_MAX-1,
434 sx, sy, w, h);
435 src= tmp + MB_SIZE;
436 }
437
438 av_assert2(s->chroma_h_shift == s->chroma_v_shift); // only one mv_scale
439
440 av_assert2((tab_index>=0 && tab_index<4) || b_w==32);
441 if( (dx&3) || (dy&3)
442 || !(b_w == b_h || 2*b_w == b_h || b_w == 2*b_h)
443 || (b_w&(b_w-1))
444 || b_w == 1
445 || b_h == 1
446 || !s->plane[plane_index].fast_mc )
447 mc_block(&s->plane[plane_index], dst, src, stride, b_w, b_h, dx, dy);
448 else if(b_w==32){
449 int y;
450 for(y=0; y<b_h; y+=16){
451 s->put_snow_qpel_pixels_tab[0][dy+(dx>>2)](dst + y*stride, src + 3 + (y+3)*stride,stride);
452 s->put_snow_qpel_pixels_tab[0][dy+(dx>>2)](dst + 16 + y*stride, src + 19 + (y+3)*stride,stride);
453 }
454 }else if(b_w==b_h)
455 s->put_snow_qpel_pixels_tab[tab_index ][dy+(dx>>2)](dst,src + 3 + 3*stride,stride);
456 else if(b_w==2*b_h){
457 s->put_snow_qpel_pixels_tab[tab_index+1][dy+(dx>>2)](dst ,src + 3 + 3*stride,stride);
458 s->put_snow_qpel_pixels_tab[tab_index+1][dy+(dx>>2)](dst+b_h,src + 3 + b_h + 3*stride,stride);
459 }else{
460 av_assert2(2*b_w==b_h);
461 s->put_snow_qpel_pixels_tab[tab_index ][dy+(dx>>2)](dst ,src + 3 + 3*stride ,stride);
462 s->put_snow_qpel_pixels_tab[tab_index ][dy+(dx>>2)](dst+b_w*stride,src + 3 + 3*stride+b_w*stride,stride);
463 }
464 }
465}
466
467#define mca(dx,dy,b_w)\
468static void mc_block_hpel ## dx ## dy ## b_w(uint8_t *dst, const uint8_t *src, ptrdiff_t stride, int h){\
469 av_assert2(h==b_w);\
470 mc_block(NULL, dst, src-(HTAPS_MAX/2-1)-(HTAPS_MAX/2-1)*stride, stride, b_w, b_w, dx, dy);\
471}
472
473mca( 8, 0,16)
474mca( 0, 8,16)
475mca( 8, 8,16)
476mca( 8, 0,8)
477mca( 0, 8,8)
478mca( 8, 8,8)
479
480static av_cold void snow_static_init(void)
481{
482 for (int i = 0; i < MAX_REF_FRAMES; i++)
483 for (int j = 0; j < MAX_REF_FRAMES; j++)
484 ff_scale_mv_ref[i][j] = 256 * (i + 1) / (j + 1);
485}
486
487av_cold int ff_snow_common_init(AVCodecContext *avctx){
488 static AVOnce init_static_once = AV_ONCE_INIT;
489 SnowContext *s = avctx->priv_data;
490 int width, height;
491 int i;
492
493 s->avctx= avctx;
494 s->max_ref_frames=1; //just make sure it's not an invalid value in case of no initial keyframe
495 s->spatial_decomposition_count = 1;
496
497 ff_videodsp_init(&s->vdsp, 8);
498 ff_dwt_init(&s->dwt);
499
500 init_qpel(s);
501
502#define mcfh(dx,dy)\
503 s->hdsp.put_pixels_tab [0][dy/4+dx/8]=\
504 s->hdsp.put_no_rnd_pixels_tab[0][dy/4+dx/8]=\
505 mc_block_hpel ## dx ## dy ## 16;\
506 s->hdsp.put_pixels_tab [1][dy/4+dx/8]=\
507 s->hdsp.put_no_rnd_pixels_tab[1][dy/4+dx/8]=\
508 mc_block_hpel ## dx ## dy ## 8;
509
510 mcfh(8, 0)
511 mcfh(0, 8)
512 mcfh(8, 8)
513
514// dec += FFMAX(s->chroma_h_shift, s->chroma_v_shift);
515
516 width= s->avctx->width;
517 height= s->avctx->height;
518
519 if (!FF_ALLOCZ_TYPED_ARRAY(s->spatial_idwt_buffer, width * height) ||
520 !FF_ALLOCZ_TYPED_ARRAY(s->spatial_dwt_buffer, width * height) || //FIXME this does not belong here
521 !FF_ALLOCZ_TYPED_ARRAY(s->temp_dwt_buffer, width) ||
522 !FF_ALLOCZ_TYPED_ARRAY(s->temp_idwt_buffer, width) ||
523 !FF_ALLOCZ_TYPED_ARRAY(s->run_buffer, ((width + 1) >> 1) * ((height + 1) >> 1) + 1))
524 return AVERROR(ENOMEM);
525
526 for(i=0; i<MAX_REF_FRAMES; i++) {
527 s->last_picture[i] = av_frame_alloc();
528 if (!s->last_picture[i])
529 return AVERROR(ENOMEM);
530 }
531
532 s->mconly_picture = av_frame_alloc();
533 s->current_picture = av_frame_alloc();
534 if (!s->mconly_picture || !s->current_picture)
535 return AVERROR(ENOMEM);
536
537 ff_thread_once(&init_static_once, snow_static_init);
538
539 return 0;
540}
541
542int ff_snow_common_init_after_header(AVCodecContext *avctx) {
543 SnowContext *s = avctx->priv_data;
544 int plane_index, level, orientation;
545
546 if(!s->scratchbuf) {
547 if (!FF_ALLOCZ_TYPED_ARRAY(s->scratchbuf, FFMAX(s->current_picture->linesize[0], 2*avctx->width+256) * 7 * MB_SIZE))
548 return AVERROR(ENOMEM);
549 }
550
551 for(plane_index=0; plane_index < s->nb_planes; plane_index++){
552 int w= s->avctx->width;
553 int h= s->avctx->height;
554
555 if(plane_index){
556 w = AV_CEIL_RSHIFT(w, s->chroma_h_shift);
557 h = AV_CEIL_RSHIFT(h, s->chroma_v_shift);
558 }
559 s->plane[plane_index].width = w;
560 s->plane[plane_index].height= h;
561
562 for(level=s->spatial_decomposition_count-1; level>=0; level--){
563 for(orientation=level ? 1 : 0; orientation<4; orientation++){
564 SubBand *b= &s->plane[plane_index].band[level][orientation];
565
566 b->buf= s->spatial_dwt_buffer;
567 b->level= level;
568 b->stride= s->plane[plane_index].width << (s->spatial_decomposition_count - level);
569 b->width = (w + !(orientation&1))>>1;
570 b->height= (h + !(orientation>1))>>1;
571
572 b->stride_line = 1 << (s->spatial_decomposition_count - level);
573 b->buf_x_offset = 0;
574 b->buf_y_offset = 0;
575
576 if(orientation&1){
577 b->buf += (w+1)>>1;
578 b->buf_x_offset = (w+1)>>1;
579 }
580 if(orientation>1){
581 b->buf += b->stride>>1;
582 b->buf_y_offset = b->stride_line >> 1;
583 }
584 b->ibuf= s->spatial_idwt_buffer + (b->buf - s->spatial_dwt_buffer);
585
586 if(level)
587 b->parent= &s->plane[plane_index].band[level-1][orientation];
588 //FIXME avoid this realloc
589 av_freep(&b->x_coeff);
590 b->x_coeff = av_calloc((b->width + 1) * b->height + 1,
591 sizeof(*b->x_coeff));
592 if (!b->x_coeff)
593 return AVERROR(ENOMEM);
594 }
595 w= (w+1)>>1;
596 h= (h+1)>>1;
597 }
598 }
599
600 return 0;
601}
602
603int ff_snow_frames_prepare(SnowContext *s)
604{
605 AVFrame *tmp;
606
607 tmp= s->last_picture[s->max_ref_frames-1];
608 for (int i = s->max_ref_frames - 1; i > 0; i--)
609 s->last_picture[i] = s->last_picture[i-1];
610 s->last_picture[0] = s->current_picture;
611 s->current_picture = tmp;
612
613 av_frame_unref(s->current_picture);
614
615 if(s->keyframe){
616 s->ref_frames= 0;
617 s->current_picture->flags |= AV_FRAME_FLAG_KEY;
618 }else{
619 int i;
620 for(i=0; i<s->max_ref_frames && s->last_picture[i]->data[0]; i++)
621 if(i && (s->last_picture[i-1]->flags & AV_FRAME_FLAG_KEY))
622 break;
623 s->ref_frames= i;
624 if(s->ref_frames==0){
625 av_log(s->avctx,AV_LOG_ERROR, "No reference frames\n");
626 return AVERROR_INVALIDDATA;
627 }
628 s->current_picture->flags &= ~AV_FRAME_FLAG_KEY;
629 }
630
631 return 0;
632}
633
634av_cold void ff_snow_common_end(SnowContext *s)
635{
636 int plane_index, level, orientation, i;
637
638 av_freep(&s->spatial_dwt_buffer);
639 av_freep(&s->temp_dwt_buffer);
640 av_freep(&s->spatial_idwt_buffer);
641 av_freep(&s->temp_idwt_buffer);
642 av_freep(&s->run_buffer);
643
644 av_freep(&s->block);
645 av_freep(&s->scratchbuf);
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}
my
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t my
Definition dsp.h:57
mx
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t mx
Definition dsp.h:57
dst
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t int int16_t * dst
Definition dsp.h:87
avassert.h
simple assert() macros that are a bit more flexible than ISO C assert().
av_assert2
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition avassert.h:68
av_assume
#define av_assume(cond)
Definition avassert.h:119
avcodec.h
Libavcodec external API header.
i
#define i(width, name, range_min, range_max)
Definition cbs_h264.c:63
s
#define s(width, name)
Definition cbs_vp9.c:198
MB_SIZE
#define MB_SIZE
Definition cinepakenc.c:54
AV_CEIL_RSHIFT
#define AV_CEIL_RSHIFT(a, b)
Definition common.h:60
av_clip_uint8
#define av_clip_uint8
Definition common.h:106
block
static int16_t block[64]
Definition dct.c:125
MAX_DECOMPOSITIONS
#define MAX_DECOMPOSITIONS
Definition dirac_dwt.h:31
IDWTELEM
short IDWTELEM
Definition dirac_dwt.h:28
MAX_PLANES
#define MAX_PLANES
Definition ffv1.h:44
FRAC_BITS
#define FRAC_BITS
Definition g729postfilter.c:36
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition error.h:61
AVERROR
#define AVERROR(e)
Definition error.h:45
AV_FRAME_FLAG_KEY
#define AV_FRAME_FLAG_KEY
A flag to mark frames that are keyframes.
Definition frame.h:687
av_frame_unref
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition frame.c:496
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
av_frame_alloc
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition frame.c:52
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition log.h:210
a
int a
Definition h264pred_template.c:416
src2
const pixel * src2
Definition h264pred_template.c:421
h264qpel_template.c
H264_QPEL
#define H264_QPEL(OPNAME, NAME, SIZE)
Definition h264qpel_template.c:473
r
#define r
Definition input.c:42
b
#define b
Definition input.c:43
scale
static void scale(int *out, const int *in, const int w, const int h, const int shift)
Definition intra.c:278
pixeltmp
#define pixeltmp
Definition h264qpel.c:26
ff_h264qpel_init
av_cold void ff_h264qpel_init(H264QpelContext *c, int bit_depth)
Definition h264qpel.c:50
ff_videodsp_init
av_cold void ff_videodsp_init(VideoDSPContext *ctx, int bpc)
Definition videodsp.c:39
av_cold
#define av_cold
Definition attributes.h:117
FF_ALLOCZ_TYPED_ARRAY
#define FF_ALLOCZ_TYPED_ARRAY(p, nelem)
Definition internal.h:72
AVOnce
#define AVOnce
Definition thread.h:202
ff_thread_once
static int ff_thread_once(char *control, void(*routine)(void))
Definition thread.h:205
AV_ONCE_INIT
#define AV_ONCE_INIT
Definition thread.h:203
w
uint8_t w
Definition llvidencdsp.c:39
FFMAX
#define FFMAX(a, b)
Definition macros.h:47
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition mem.c:264
mem.h
Memory handling functions.
weight
const h264_weight_func weight
Definition h264dsp_init.c:33
ff_snow_common_init
av_cold int ff_snow_common_init(AVCodecContext *avctx)
Definition snow.c:487
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:48
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:379
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:66
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:186
mcfh
#define mcfh(dx, dy)
ff_snow_reset_contexts
void ff_snow_reset_contexts(SnowContext *s)
Definition snow.c:157
ff_snow_common_init_after_header
int ff_snow_common_init_after_header(AVCodecContext *avctx)
Definition snow.c:542
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:37
mca
#define mca(dx, dy, b_w)
Definition snow.c:467
MC_STRIDE
#define MC_STRIDE(x)
init_qpel
static av_cold void init_qpel(SnowContext *const s)
Definition snow.c:95
ff_snow_frames_prepare
int ff_snow_frames_prepare(SnowContext *s)
Definition snow.c:603
ff_snow_inner_add_yblock_c
void ff_snow_inner_add_yblock_c(const uint8_t *obmc, const int obmc_stride, uint8_t **block, int b_w, int b_h, int src_x, int src_stride, IDWTELEM *const *lines, int add, uint8_t *dst8)
Definition snow.c:118
ff_snow_common_end
av_cold void ff_snow_common_end(SnowContext *s)
Definition snow.c:634
ff_snow_alloc_blocks
int ff_snow_alloc_blocks(SnowContext *s)
Definition snow.c:171
LOG2_MB_SIZE
#define LOG2_MB_SIZE
Definition snow.h:72
MID_STATE
#define MID_STATE
Definition snow.h:39
HTAPS_MAX
#define HTAPS_MAX
Definition snow.h:75
BLOCK_INTRA
#define BLOCK_INTRA
Intra block, inter otherwise.
Definition snow.h:57
MAX_REF_FRAMES
#define MAX_REF_FRAMES
Definition snow.h:46
LOG2_OBMC_MAX
#define LOG2_OBMC_MAX
Definition snow.h:48
ff_scale_mv_ref
int ff_scale_mv_ref[MAX_REF_FRAMES][MAX_REF_FRAMES]
Definition snowdata.h:136
ff_dwt_init
av_cold void ff_dwt_init(SnowDWTContext *c)
Definition snow_dwt.c:851
snow_dwt.h
obmc4
static const uint8_t obmc4[16]
Definition snowdata.h:97
AVCodecContext
main external API structure.
Definition avcodec.h:443
AVCodecContext::width
int width
picture width / height.
Definition avcodec.h:604
AVCodecContext::priv_data
void * priv_data
Definition avcodec.h:470
AVFrame
This structure describes decoded (raw) audio or video data.
Definition frame.h:472
Plane
Definition cfhd.h:125
level
uint8_t level
Definition svq3.c:208
stride
#define stride
Definition h264pred_template.c:536
av_free
#define av_free(p)
Definition tableprint_vlc.h:34
av_freep
#define av_freep(p)
Definition tableprint_vlc.h:35
av_log
#define av_log(a,...)
Definition tableprint_vlc.h:27
tmp
static uint8_t tmp[40]
Definition aes_ctr.c:52
src1
#define src1
Definition h264pred.c:141
src0
#define src0
Definition h264pred.c:140
src
#define src
Definition vp8dsp.c:248
height
#define height
Definition dsp.h:89
width
#define width
Definition dsp.h:89
a0
static double a0(void *priv, double x, double y)
Definition vf_xfade.c:2028
a3
static double a3(void *priv, double x, double y)
Definition vf_xfade.c:2031
a2
static double a2(void *priv, double x, double y)
Definition vf_xfade.c:2030
a1
static double a1(void *priv, double x, double y)
Definition vf_xfade.c:2029
h
h
Definition vp9dsp_template.c:2070
Generated on Sun Aug 16 2026 20:20:52 for FFmpeg by doxygen 1.13.2