FFmpeg
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 
37 static 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 
48 static 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 
66 static 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 
93 H264_MC(put_, snow, 2)
94 
95 static 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 
118 void 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 
157 void 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 
171 int 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 
186 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){
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 
379 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){
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)\
468 static 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 
473 mca( 0, 0,16)
474 mca( 8, 0,16)
475 mca( 0, 8,16)
476 mca( 8, 8,16)
477 mca( 0, 0,8)
478 mca( 8, 0,8)
479 mca( 0, 8,8)
480 mca( 8, 8,8)
481 
482 static av_cold void snow_static_init(void)
483 {
484  for (int i = 0; i < MAX_REF_FRAMES; i++)
485  for (int j = 0; j < MAX_REF_FRAMES; j++)
486  ff_scale_mv_ref[i][j] = 256 * (i + 1) / (j + 1);
487 }
488 
489 av_cold int ff_snow_common_init(AVCodecContext *avctx){
490  static AVOnce init_static_once = AV_ONCE_INIT;
491  SnowContext *s = avctx->priv_data;
492  int width, height;
493  int i;
494 
495  s->avctx= avctx;
496  s->max_ref_frames=1; //just make sure it's not an invalid value in case of no initial keyframe
497  s->spatial_decomposition_count = 1;
498 
499  ff_videodsp_init(&s->vdsp, 8);
500  ff_dwt_init(&s->dwt);
501 
502  init_qpel(s);
503 
504 #define mcfh(dx,dy)\
505  s->hdsp.put_pixels_tab [0][dy/4+dx/8]=\
506  s->hdsp.put_no_rnd_pixels_tab[0][dy/4+dx/8]=\
507  mc_block_hpel ## dx ## dy ## 16;\
508  s->hdsp.put_pixels_tab [1][dy/4+dx/8]=\
509  s->hdsp.put_no_rnd_pixels_tab[1][dy/4+dx/8]=\
510  mc_block_hpel ## dx ## dy ## 8;
511 
512  mcfh(0, 0)
513  mcfh(8, 0)
514  mcfh(0, 8)
515  mcfh(8, 8)
516 
517 // dec += FFMAX(s->chroma_h_shift, s->chroma_v_shift);
518 
519  width= s->avctx->width;
520  height= s->avctx->height;
521 
522  if (!FF_ALLOCZ_TYPED_ARRAY(s->spatial_idwt_buffer, width * height) ||
523  !FF_ALLOCZ_TYPED_ARRAY(s->spatial_dwt_buffer, width * height) || //FIXME this does not belong here
524  !FF_ALLOCZ_TYPED_ARRAY(s->temp_dwt_buffer, width) ||
525  !FF_ALLOCZ_TYPED_ARRAY(s->temp_idwt_buffer, width) ||
526  !FF_ALLOCZ_TYPED_ARRAY(s->run_buffer, ((width + 1) >> 1) * ((height + 1) >> 1) + 1))
527  return AVERROR(ENOMEM);
528 
529  for(i=0; i<MAX_REF_FRAMES; i++) {
530  s->last_picture[i] = av_frame_alloc();
531  if (!s->last_picture[i])
532  return AVERROR(ENOMEM);
533  }
534 
535  s->mconly_picture = av_frame_alloc();
536  s->current_picture = av_frame_alloc();
537  if (!s->mconly_picture || !s->current_picture)
538  return AVERROR(ENOMEM);
539 
540  ff_thread_once(&init_static_once, snow_static_init);
541 
542  return 0;
543 }
544 
545 int ff_snow_common_init_after_header(AVCodecContext *avctx) {
546  SnowContext *s = avctx->priv_data;
547  int plane_index, level, orientation;
548 
549  if(!s->scratchbuf) {
550  if (!FF_ALLOCZ_TYPED_ARRAY(s->scratchbuf, FFMAX(s->current_picture->linesize[0], 2*avctx->width+256) * 7 * MB_SIZE))
551  return AVERROR(ENOMEM);
552  }
553 
554  for(plane_index=0; plane_index < s->nb_planes; plane_index++){
555  int w= s->avctx->width;
556  int h= s->avctx->height;
557 
558  if(plane_index){
559  w = AV_CEIL_RSHIFT(w, s->chroma_h_shift);
560  h = AV_CEIL_RSHIFT(h, s->chroma_v_shift);
561  }
562  s->plane[plane_index].width = w;
563  s->plane[plane_index].height= h;
564 
565  for(level=s->spatial_decomposition_count-1; level>=0; level--){
566  for(orientation=level ? 1 : 0; orientation<4; orientation++){
567  SubBand *b= &s->plane[plane_index].band[level][orientation];
568 
569  b->buf= s->spatial_dwt_buffer;
570  b->level= level;
571  b->stride= s->plane[plane_index].width << (s->spatial_decomposition_count - level);
572  b->width = (w + !(orientation&1))>>1;
573  b->height= (h + !(orientation>1))>>1;
574 
575  b->stride_line = 1 << (s->spatial_decomposition_count - level);
576  b->buf_x_offset = 0;
577  b->buf_y_offset = 0;
578 
579  if(orientation&1){
580  b->buf += (w+1)>>1;
581  b->buf_x_offset = (w+1)>>1;
582  }
583  if(orientation>1){
584  b->buf += b->stride>>1;
585  b->buf_y_offset = b->stride_line >> 1;
586  }
587  b->ibuf= s->spatial_idwt_buffer + (b->buf - s->spatial_dwt_buffer);
588 
589  if(level)
590  b->parent= &s->plane[plane_index].band[level-1][orientation];
591  //FIXME avoid this realloc
592  av_freep(&b->x_coeff);
593  b->x_coeff = av_calloc((b->width + 1) * b->height + 1,
594  sizeof(*b->x_coeff));
595  if (!b->x_coeff)
596  return AVERROR(ENOMEM);
597  }
598  w= (w+1)>>1;
599  h= (h+1)>>1;
600  }
601  }
602 
603  return 0;
604 }
605 
606 int ff_snow_frames_prepare(SnowContext *s)
607 {
608  AVFrame *tmp;
609 
610  tmp= s->last_picture[s->max_ref_frames-1];
611  for (int i = s->max_ref_frames - 1; i > 0; i--)
612  s->last_picture[i] = s->last_picture[i-1];
613  s->last_picture[0] = s->current_picture;
614  s->current_picture = tmp;
615 
616  av_frame_unref(s->current_picture);
617 
618  if(s->keyframe){
619  s->ref_frames= 0;
620  s->current_picture->flags |= AV_FRAME_FLAG_KEY;
621  }else{
622  int i;
623  for(i=0; i<s->max_ref_frames && s->last_picture[i]->data[0]; i++)
624  if(i && (s->last_picture[i-1]->flags & AV_FRAME_FLAG_KEY))
625  break;
626  s->ref_frames= i;
627  if(s->ref_frames==0){
628  av_log(s->avctx,AV_LOG_ERROR, "No reference frames\n");
629  return AVERROR_INVALIDDATA;
630  }
631  s->current_picture->flags &= ~AV_FRAME_FLAG_KEY;
632  }
633 
634  return 0;
635 }
636 
637 av_cold void ff_snow_common_end(SnowContext *s)
638 {
639  int plane_index, level, orientation, i;
640 
641  av_freep(&s->spatial_dwt_buffer);
642  av_freep(&s->temp_dwt_buffer);
643  av_freep(&s->spatial_idwt_buffer);
644  av_freep(&s->temp_idwt_buffer);
645  av_freep(&s->run_buffer);
646 
647  av_freep(&s->block);
648  av_freep(&s->scratchbuf);
649 
650  for(i=0; i<MAX_REF_FRAMES; i++){
651  av_frame_free(&s->last_picture[i]);
652  }
653 
654  for(plane_index=0; plane_index < MAX_PLANES; plane_index++){
655  for(level=MAX_DECOMPOSITIONS-1; level>=0; level--){
656  for(orientation=level ? 1 : 0; orientation<4; orientation++){
657  SubBand *b= &s->plane[plane_index].band[level][orientation];
658 
659  av_freep(&b->x_coeff);
660  }
661  }
662  }
663  av_frame_free(&s->mconly_picture);
664  av_frame_free(&s->current_picture);
665 }
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:48
MC_STRIDE
#define MC_STRIDE(x)
level
uint8_t level
Definition: svq3.c:208
MAX_DECOMPOSITIONS
#define MAX_DECOMPOSITIONS
Definition: dirac_dwt.h:30
r
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:435
b
#define b
Definition: input.c:43
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:66
ff_snow_common_end
av_cold void ff_snow_common_end(SnowContext *s)
Definition: snow.c:637
mx
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:379
ff_h264qpel_init
av_cold void ff_h264qpel_init(H264QpelContext *c, int bit_depth)
Definition: h264qpel.c:50
a2
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:545
avassert.h
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:119
AV_FRAME_FLAG_KEY
#define AV_FRAME_FLAG_KEY
A flag to mark frames that are keyframes.
Definition: frame.h:650
s
#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:186
ff_snow_common_init
av_cold int ff_snow_common_init(AVCodecContext *avctx)
Definition: snow.c:489
tmp
static uint8_t tmp[40]
Definition: aes_ctr.c:52
my
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t my
Definition: dsp.h:57
av_assume
#define av_assume(cond)
Definition: avassert.h:119
AV_ONCE_INIT
#define AV_ONCE_INIT
Definition: thread.h:203
a3
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:95
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
i
#define i(width, name, range_min, range_max)
Definition: cbs_h264.c:63
obmc4
static const uint8_t obmc4[16]
Definition: snowdata.h:97
color
static const uint32_t color[16+AV_CLASS_CATEGORY_NB]
Definition: log.c:98
SubBand
Definition: cfhd.h:116
pixeltmp
#define pixeltmp
Definition: snow.c:32
a
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
a0
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:37
av_assert2
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:68
log.h
src2
const pixel * src2
Definition: h264pred_template.c:421
BLOCK_INTRA
#define BLOCK_INTRA
Intra block, inter otherwise.
Definition: snow.h:57
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
H264QpelContext
Definition: h264qpel.h:27
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:264
avcodec.h
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
H264_MC
#define H264_MC(OPNAME, NAME, SIZE)
Definition: h264qpel_template.c:307
ff_snow_reset_contexts
void ff_snow_reset_contexts(SnowContext *s)
Definition: snow.c:157
AVCodecContext
main external API structure.
Definition: avcodec.h:439
FRAC_BITS
#define FRAC_BITS
Definition: g729postfilter.c:36
Windows::Graphics::DirectX::Direct3D11::p
IDirect3DDxgiInterfaceAccess _COM_Outptr_ void ** p
Definition: vsrc_gfxcapture_winrt.hpp:53
Plane
Definition: cfhd.h:125
av_clip_uint8
#define av_clip_uint8
Definition: common.h:106
src0
const pixel *const src0
Definition: h264pred_template.c:419
mem.h
ff_scale_mv_ref
int ff_scale_mv_ref[MAX_REF_FRAMES][MAX_REF_FRAMES]
Definition: snowdata.h:136
w
uint8_t w
Definition: llvidencdsp.c:39
av_free
#define av_free(p)
Definition: tableprint_vlc.h:34
scale
static void scale(int *out, const int *in, const int w, const int h, const int shift)
Definition: intra.c:278
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:466
ff_snow_frames_prepare
int ff_snow_frames_prepare(SnowContext *s)
Definition: snow.c:606
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:600
HTAPS_MAX
#define HTAPS_MAX
Definition: snow.h:75
block
The exact code depends on how similar the blocks are and how related they are to the block
Definition: filter_design.txt:207
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
IDWTELEM
short IDWTELEM
Definition: dirac_dwt.h:27
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
a1
static double a1(void *priv, double x, double y)
Definition: vf_xfade.c:2029
h
h
Definition: vp9dsp_template.c:2070
stride
#define stride
Definition: h264pred_template.c:536
width
#define width
Definition: dsp.h:89
ff_snow_alloc_blocks
int ff_snow_alloc_blocks(SnowContext *s)
Definition: snow.c:171
mca
#define mca(dx, dy, b_w)
Definition: snow.c:467
src
#define src
Definition: vp8dsp.c:248
Generated on Fri May 1 2026 19:22:40 for FFmpeg by   doxygen 1.8.17