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 "libavutil/intmath.h"
22 #include "libavutil/log.h"
23 #include "libavutil/opt.h"
24 #include "libavutil/thread.h"
25 #include "avcodec.h"
26 #include "me_cmp.h"
27 #include "snow_dwt.h"
28 #include "internal.h"
29 #include "snow.h"
30 #include "snowdata.h"
31 
32 #include "rangecoder.h"
33 #include "mathops.h"
34 
35 
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];
52 
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 }
68 
70 {
71  int ret, i;
72  int edges_needed = av_codec_is_encoder(s->avctx->codec);
73 
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  }
92 
93  return 0;
94 }
95 
96 void ff_snow_reset_contexts(SnowContext *s){ //FIXME better initial contexts
97  int plane_index, level, orientation;
98 
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 
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_calloc(w * h, sizeof(*s->block) << (s->block_max_depth*2));
119  if (!s->block)
120  return AVERROR(ENOMEM);
121 
122  return 0;
123 }
124 
125 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){
126  static const uint8_t weight[64]={
127  8,7,6,5,4,3,2,1,
128  7,7,0,0,0,0,0,1,
129  6,0,6,0,0,0,2,0,
130  5,0,0,5,0,3,0,0,
131  4,0,0,0,4,0,0,0,
132  3,0,0,5,0,3,0,0,
133  2,0,6,0,0,0,2,0,
134  1,7,0,0,0,0,0,1,
135  };
136 
137  static const uint8_t brane[256]={
138  0x00,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x11,0x12,0x12,0x12,0x12,0x12,0x12,0x12,
139  0x04,0x05,0xcc,0xcc,0xcc,0xcc,0xcc,0x41,0x15,0x16,0xcc,0xcc,0xcc,0xcc,0xcc,0x52,
140  0x04,0xcc,0x05,0xcc,0xcc,0xcc,0x41,0xcc,0x15,0xcc,0x16,0xcc,0xcc,0xcc,0x52,0xcc,
141  0x04,0xcc,0xcc,0x05,0xcc,0x41,0xcc,0xcc,0x15,0xcc,0xcc,0x16,0xcc,0x52,0xcc,0xcc,
142  0x04,0xcc,0xcc,0xcc,0x41,0xcc,0xcc,0xcc,0x15,0xcc,0xcc,0xcc,0x16,0xcc,0xcc,0xcc,
143  0x04,0xcc,0xcc,0x41,0xcc,0x05,0xcc,0xcc,0x15,0xcc,0xcc,0x52,0xcc,0x16,0xcc,0xcc,
144  0x04,0xcc,0x41,0xcc,0xcc,0xcc,0x05,0xcc,0x15,0xcc,0x52,0xcc,0xcc,0xcc,0x16,0xcc,
145  0x04,0x41,0xcc,0xcc,0xcc,0xcc,0xcc,0x05,0x15,0x52,0xcc,0xcc,0xcc,0xcc,0xcc,0x16,
146  0x44,0x45,0x45,0x45,0x45,0x45,0x45,0x45,0x55,0x56,0x56,0x56,0x56,0x56,0x56,0x56,
147  0x48,0x49,0xcc,0xcc,0xcc,0xcc,0xcc,0x85,0x59,0x5A,0xcc,0xcc,0xcc,0xcc,0xcc,0x96,
148  0x48,0xcc,0x49,0xcc,0xcc,0xcc,0x85,0xcc,0x59,0xcc,0x5A,0xcc,0xcc,0xcc,0x96,0xcc,
149  0x48,0xcc,0xcc,0x49,0xcc,0x85,0xcc,0xcc,0x59,0xcc,0xcc,0x5A,0xcc,0x96,0xcc,0xcc,
150  0x48,0xcc,0xcc,0xcc,0x49,0xcc,0xcc,0xcc,0x59,0xcc,0xcc,0xcc,0x96,0xcc,0xcc,0xcc,
151  0x48,0xcc,0xcc,0x85,0xcc,0x49,0xcc,0xcc,0x59,0xcc,0xcc,0x96,0xcc,0x5A,0xcc,0xcc,
152  0x48,0xcc,0x85,0xcc,0xcc,0xcc,0x49,0xcc,0x59,0xcc,0x96,0xcc,0xcc,0xcc,0x5A,0xcc,
153  0x48,0x85,0xcc,0xcc,0xcc,0xcc,0xcc,0x49,0x59,0x96,0xcc,0xcc,0xcc,0xcc,0xcc,0x5A,
154  };
155 
156  static const uint8_t needs[16]={
157  0,1,0,0,
158  2,4,2,0,
159  0,1,0,0,
160  15
161  };
162 
163  int x, y, b, r, l;
164  int16_t tmpIt [64*(32+HTAPS_MAX)];
165  uint8_t tmp2t[3][64*(32+HTAPS_MAX)];
166  int16_t *tmpI= tmpIt;
167  uint8_t *tmp2= tmp2t[0];
168  const uint8_t *hpel[11];
169  av_assert2(dx<16 && dy<16);
170  r= brane[dx + 16*dy]&15;
171  l= brane[dx + 16*dy]>>4;
172 
173  b= needs[l] | needs[r];
174  if(p && !p->diag_mc)
175  b= 15;
176 
177  if(b&5){
178  for(y=0; y < b_h+HTAPS_MAX-1; y++){
179  for(x=0; x < b_w; x++){
180  int a_1=src[x + HTAPS_MAX/2-4];
181  int a0= src[x + HTAPS_MAX/2-3];
182  int a1= src[x + HTAPS_MAX/2-2];
183  int a2= src[x + HTAPS_MAX/2-1];
184  int a3= src[x + HTAPS_MAX/2+0];
185  int a4= src[x + HTAPS_MAX/2+1];
186  int a5= src[x + HTAPS_MAX/2+2];
187  int a6= src[x + HTAPS_MAX/2+3];
188  int am=0;
189  if(!p || p->fast_mc){
190  am= 20*(a2+a3) - 5*(a1+a4) + (a0+a5);
191  tmpI[x]= am;
192  am= (am+16)>>5;
193  }else{
194  am= p->hcoeff[0]*(a2+a3) + p->hcoeff[1]*(a1+a4) + p->hcoeff[2]*(a0+a5) + p->hcoeff[3]*(a_1+a6);
195  tmpI[x]= am;
196  am= (am+32)>>6;
197  }
198 
199  if(am&(~255)) am= ~(am>>31);
200  tmp2[x]= am;
201  }
202  tmpI+= 64;
203  tmp2+= 64;
204  src += stride;
205  }
206  src -= stride*y;
207  }
208  src += HTAPS_MAX/2 - 1;
209  tmp2= tmp2t[1];
210 
211  if(b&2){
212  for(y=0; y < b_h; y++){
213  for(x=0; x < b_w+1; x++){
214  int a_1=src[x + (HTAPS_MAX/2-4)*stride];
215  int a0= src[x + (HTAPS_MAX/2-3)*stride];
216  int a1= src[x + (HTAPS_MAX/2-2)*stride];
217  int a2= src[x + (HTAPS_MAX/2-1)*stride];
218  int a3= src[x + (HTAPS_MAX/2+0)*stride];
219  int a4= src[x + (HTAPS_MAX/2+1)*stride];
220  int a5= src[x + (HTAPS_MAX/2+2)*stride];
221  int a6= src[x + (HTAPS_MAX/2+3)*stride];
222  int am=0;
223  if(!p || p->fast_mc)
224  am= (20*(a2+a3) - 5*(a1+a4) + (a0+a5) + 16)>>5;
225  else
226  am= (p->hcoeff[0]*(a2+a3) + p->hcoeff[1]*(a1+a4) + p->hcoeff[2]*(a0+a5) + p->hcoeff[3]*(a_1+a6) + 32)>>6;
227 
228  if(am&(~255)) am= ~(am>>31);
229  tmp2[x]= am;
230  }
231  src += stride;
232  tmp2+= 64;
233  }
234  src -= stride*y;
235  }
236  src += stride*(HTAPS_MAX/2 - 1);
237  tmp2= tmp2t[2];
238  tmpI= tmpIt;
239  if(b&4){
240  for(y=0; y < b_h; y++){
241  for(x=0; x < b_w; x++){
242  int a_1=tmpI[x + (HTAPS_MAX/2-4)*64];
243  int a0= tmpI[x + (HTAPS_MAX/2-3)*64];
244  int a1= tmpI[x + (HTAPS_MAX/2-2)*64];
245  int a2= tmpI[x + (HTAPS_MAX/2-1)*64];
246  int a3= tmpI[x + (HTAPS_MAX/2+0)*64];
247  int a4= tmpI[x + (HTAPS_MAX/2+1)*64];
248  int a5= tmpI[x + (HTAPS_MAX/2+2)*64];
249  int a6= tmpI[x + (HTAPS_MAX/2+3)*64];
250  int am=0;
251  if(!p || p->fast_mc)
252  am= (20*(a2+a3) - 5*(a1+a4) + (a0+a5) + 512)>>10;
253  else
254  am= (p->hcoeff[0]*(a2+a3) + p->hcoeff[1]*(a1+a4) + p->hcoeff[2]*(a0+a5) + p->hcoeff[3]*(a_1+a6) + 2048)>>12;
255  if(am&(~255)) am= ~(am>>31);
256  tmp2[x]= am;
257  }
258  tmpI+= 64;
259  tmp2+= 64;
260  }
261  }
262 
263  hpel[ 0]= src;
264  hpel[ 1]= tmp2t[0] + 64*(HTAPS_MAX/2-1);
265  hpel[ 2]= src + 1;
266 
267  hpel[ 4]= tmp2t[1];
268  hpel[ 5]= tmp2t[2];
269  hpel[ 6]= tmp2t[1] + 1;
270 
271  hpel[ 8]= src + stride;
272  hpel[ 9]= hpel[1] + 64;
273  hpel[10]= hpel[8] + 1;
274 
275 #define MC_STRIDE(x) (needs[x] ? 64 : stride)
276 
277  if(b==15){
278  int dxy = dx / 8 + dy / 8 * 4;
279  const uint8_t *src1 = hpel[dxy ];
280  const uint8_t *src2 = hpel[dxy + 1];
281  const uint8_t *src3 = hpel[dxy + 4];
282  const uint8_t *src4 = hpel[dxy + 5];
283  int stride1 = MC_STRIDE(dxy);
284  int stride2 = MC_STRIDE(dxy + 1);
285  int stride3 = MC_STRIDE(dxy + 4);
286  int stride4 = MC_STRIDE(dxy + 5);
287  dx&=7;
288  dy&=7;
289  for(y=0; y < b_h; y++){
290  for(x=0; x < b_w; x++){
291  dst[x]= ((8-dx)*(8-dy)*src1[x] + dx*(8-dy)*src2[x]+
292  (8-dx)* dy *src3[x] + dx* dy *src4[x]+32)>>6;
293  }
294  src1+=stride1;
295  src2+=stride2;
296  src3+=stride3;
297  src4+=stride4;
298  dst +=stride;
299  }
300  }else{
301  const uint8_t *src1= hpel[l];
302  const uint8_t *src2= hpel[r];
303  int stride1 = MC_STRIDE(l);
304  int stride2 = MC_STRIDE(r);
305  int a= weight[((dx&7) + (8*(dy&7)))];
306  int b= 8-a;
307  for(y=0; y < b_h; y++){
308  for(x=0; x < b_w; x++){
309  dst[x]= (a*src1[x] + b*src2[x] + 4)>>3;
310  }
311  src1+=stride1;
312  src2+=stride2;
313  dst +=stride;
314  }
315  }
316 }
317 
318 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){
319  if(block->type & BLOCK_INTRA){
320  int x, y;
321  const unsigned color = block->color[plane_index];
322  const unsigned color4 = color*0x01010101;
323  if(b_w==32){
324  for(y=0; y < b_h; y++){
325  *(uint32_t*)&dst[0 + y*stride]= color4;
326  *(uint32_t*)&dst[4 + y*stride]= color4;
327  *(uint32_t*)&dst[8 + y*stride]= color4;
328  *(uint32_t*)&dst[12+ y*stride]= color4;
329  *(uint32_t*)&dst[16+ y*stride]= color4;
330  *(uint32_t*)&dst[20+ y*stride]= color4;
331  *(uint32_t*)&dst[24+ y*stride]= color4;
332  *(uint32_t*)&dst[28+ y*stride]= color4;
333  }
334  }else if(b_w==16){
335  for(y=0; y < b_h; y++){
336  *(uint32_t*)&dst[0 + y*stride]= color4;
337  *(uint32_t*)&dst[4 + y*stride]= color4;
338  *(uint32_t*)&dst[8 + y*stride]= color4;
339  *(uint32_t*)&dst[12+ y*stride]= color4;
340  }
341  }else if(b_w==8){
342  for(y=0; y < b_h; y++){
343  *(uint32_t*)&dst[0 + y*stride]= color4;
344  *(uint32_t*)&dst[4 + y*stride]= color4;
345  }
346  }else if(b_w==4){
347  for(y=0; y < b_h; y++){
348  *(uint32_t*)&dst[0 + y*stride]= color4;
349  }
350  }else{
351  for(y=0; y < b_h; y++){
352  for(x=0; x < b_w; x++){
353  dst[x + y*stride]= color;
354  }
355  }
356  }
357  }else{
358  uint8_t *src= s->last_picture[block->ref]->data[plane_index];
359  const int scale= plane_index ? (2*s->mv_scale)>>s->chroma_h_shift : 2*s->mv_scale;
360  int mx= block->mx*scale;
361  int my= block->my*scale;
362  const int dx= mx&15;
363  const int dy= my&15;
364  const int tab_index= 3 - (b_w>>2) + (b_w>>4);
365  sx += (mx>>4) - (HTAPS_MAX/2-1);
366  sy += (my>>4) - (HTAPS_MAX/2-1);
367  src += sx + sy*stride;
368  if( (unsigned)sx >= FFMAX(w - b_w - (HTAPS_MAX-2), 0)
369  || (unsigned)sy >= FFMAX(h - b_h - (HTAPS_MAX-2), 0)){
370  s->vdsp.emulated_edge_mc(tmp + MB_SIZE, src,
371  stride, stride,
372  b_w+HTAPS_MAX-1, b_h+HTAPS_MAX-1,
373  sx, sy, w, h);
374  src= tmp + MB_SIZE;
375  }
376 
377  av_assert2(s->chroma_h_shift == s->chroma_v_shift); // only one mv_scale
378 
379  av_assert2((tab_index>=0 && tab_index<4) || b_w==32);
380  if( (dx&3) || (dy&3)
381  || !(b_w == b_h || 2*b_w == b_h || b_w == 2*b_h)
382  || (b_w&(b_w-1))
383  || b_w == 1
384  || b_h == 1
385  || !s->plane[plane_index].fast_mc )
386  mc_block(&s->plane[plane_index], dst, src, stride, b_w, b_h, dx, dy);
387  else if(b_w==32){
388  int y;
389  for(y=0; y<b_h; y+=16){
390  s->h264qpel.put_h264_qpel_pixels_tab[0][dy+(dx>>2)](dst + y*stride, src + 3 + (y+3)*stride,stride);
391  s->h264qpel.put_h264_qpel_pixels_tab[0][dy+(dx>>2)](dst + 16 + y*stride, src + 19 + (y+3)*stride,stride);
392  }
393  }else if(b_w==b_h)
394  s->h264qpel.put_h264_qpel_pixels_tab[tab_index ][dy+(dx>>2)](dst,src + 3 + 3*stride,stride);
395  else if(b_w==2*b_h){
396  s->h264qpel.put_h264_qpel_pixels_tab[tab_index+1][dy+(dx>>2)](dst ,src + 3 + 3*stride,stride);
397  s->h264qpel.put_h264_qpel_pixels_tab[tab_index+1][dy+(dx>>2)](dst+b_h,src + 3 + b_h + 3*stride,stride);
398  }else{
399  av_assert2(2*b_w==b_h);
400  s->h264qpel.put_h264_qpel_pixels_tab[tab_index ][dy+(dx>>2)](dst ,src + 3 + 3*stride ,stride);
401  s->h264qpel.put_h264_qpel_pixels_tab[tab_index ][dy+(dx>>2)](dst+b_w*stride,src + 3 + 3*stride+b_w*stride,stride);
402  }
403  }
404 }
405 
406 #define mca(dx,dy,b_w)\
407 static void mc_block_hpel ## dx ## dy ## b_w(uint8_t *dst, const uint8_t *src, ptrdiff_t stride, int h){\
408  av_assert2(h==b_w);\
409  mc_block(NULL, dst, src-(HTAPS_MAX/2-1)-(HTAPS_MAX/2-1)*stride, stride, b_w, b_w, dx, dy);\
410 }
411 
412 mca( 0, 0,16)
413 mca( 8, 0,16)
414 mca( 0, 8,16)
415 mca( 8, 8,16)
416 mca( 0, 0,8)
417 mca( 8, 0,8)
418 mca( 0, 8,8)
419 mca( 8, 8,8)
420 
421 static av_cold void snow_static_init(void)
422 {
423  for (int i = 0; i < MAX_REF_FRAMES; i++)
424  for (int j = 0; j < MAX_REF_FRAMES; j++)
425  ff_scale_mv_ref[i][j] = 256 * (i + 1) / (j + 1);
426 }
427 
429  static AVOnce init_static_once = AV_ONCE_INIT;
430  SnowContext *s = avctx->priv_data;
431  int width, height;
432  int i;
433 
434  s->avctx= avctx;
435  s->max_ref_frames=1; //just make sure it's not an invalid value in case of no initial keyframe
436  s->spatial_decomposition_count = 1;
437 
438  ff_me_cmp_init(&s->mecc, avctx);
439  ff_hpeldsp_init(&s->hdsp, avctx->flags);
440  ff_videodsp_init(&s->vdsp, 8);
441  ff_dwt_init(&s->dwt);
442  ff_h264qpel_init(&s->h264qpel, 8);
443 
444 #define mcf(dx,dy)\
445  s->qdsp.put_qpel_pixels_tab [0][dy+dx/4]=\
446  s->qdsp.put_no_rnd_qpel_pixels_tab[0][dy+dx/4]=\
447  s->h264qpel.put_h264_qpel_pixels_tab[0][dy+dx/4];\
448  s->qdsp.put_qpel_pixels_tab [1][dy+dx/4]=\
449  s->qdsp.put_no_rnd_qpel_pixels_tab[1][dy+dx/4]=\
450  s->h264qpel.put_h264_qpel_pixels_tab[1][dy+dx/4];
451 
452  mcf( 0, 0)
453  mcf( 4, 0)
454  mcf( 8, 0)
455  mcf(12, 0)
456  mcf( 0, 4)
457  mcf( 4, 4)
458  mcf( 8, 4)
459  mcf(12, 4)
460  mcf( 0, 8)
461  mcf( 4, 8)
462  mcf( 8, 8)
463  mcf(12, 8)
464  mcf( 0,12)
465  mcf( 4,12)
466  mcf( 8,12)
467  mcf(12,12)
468 
469 #define mcfh(dx,dy)\
470  s->hdsp.put_pixels_tab [0][dy/4+dx/8]=\
471  s->hdsp.put_no_rnd_pixels_tab[0][dy/4+dx/8]=\
472  mc_block_hpel ## dx ## dy ## 16;\
473  s->hdsp.put_pixels_tab [1][dy/4+dx/8]=\
474  s->hdsp.put_no_rnd_pixels_tab[1][dy/4+dx/8]=\
475  mc_block_hpel ## dx ## dy ## 8;
476 
477  mcfh(0, 0)
478  mcfh(8, 0)
479  mcfh(0, 8)
480  mcfh(8, 8)
481 
482 // dec += FFMAX(s->chroma_h_shift, s->chroma_v_shift);
483 
484  width= s->avctx->width;
485  height= s->avctx->height;
486 
487  if (!FF_ALLOCZ_TYPED_ARRAY(s->spatial_idwt_buffer, width * height) ||
488  !FF_ALLOCZ_TYPED_ARRAY(s->spatial_dwt_buffer, width * height) || //FIXME this does not belong here
489  !FF_ALLOCZ_TYPED_ARRAY(s->temp_dwt_buffer, width) ||
490  !FF_ALLOCZ_TYPED_ARRAY(s->temp_idwt_buffer, width) ||
491  !FF_ALLOCZ_TYPED_ARRAY(s->run_buffer, ((width + 1) >> 1) * ((height + 1) >> 1)))
492  return AVERROR(ENOMEM);
493 
494  for(i=0; i<MAX_REF_FRAMES; i++) {
495  s->last_picture[i] = av_frame_alloc();
496  if (!s->last_picture[i])
497  return AVERROR(ENOMEM);
498  }
499 
500  s->mconly_picture = av_frame_alloc();
501  s->current_picture = av_frame_alloc();
502  if (!s->mconly_picture || !s->current_picture)
503  return AVERROR(ENOMEM);
504 
505  ff_thread_once(&init_static_once, snow_static_init);
506 
507  return 0;
508 }
509 
511  SnowContext *s = avctx->priv_data;
512  int plane_index, level, orientation;
513  int ret, emu_buf_size;
514 
515  if(!s->scratchbuf) {
516  if ((ret = ff_get_buffer(s->avctx, s->mconly_picture,
518  return ret;
519  emu_buf_size = FFMAX(s->mconly_picture->linesize[0], 2*avctx->width+256) * (2 * MB_SIZE + HTAPS_MAX - 1);
520  if (!FF_ALLOCZ_TYPED_ARRAY(s->scratchbuf, FFMAX(s->mconly_picture->linesize[0], 2*avctx->width+256) * 7 * MB_SIZE) ||
521  !FF_ALLOCZ_TYPED_ARRAY(s->emu_edge_buffer, emu_buf_size))
522  return AVERROR(ENOMEM);
523  }
524 
525  if(s->mconly_picture->format != avctx->pix_fmt) {
526  av_log(avctx, AV_LOG_ERROR, "pixel format changed\n");
527  return AVERROR_INVALIDDATA;
528  }
529 
530  for(plane_index=0; plane_index < s->nb_planes; plane_index++){
531  int w= s->avctx->width;
532  int h= s->avctx->height;
533 
534  if(plane_index){
535  w = AV_CEIL_RSHIFT(w, s->chroma_h_shift);
536  h = AV_CEIL_RSHIFT(h, s->chroma_v_shift);
537  }
538  s->plane[plane_index].width = w;
539  s->plane[plane_index].height= h;
540 
541  for(level=s->spatial_decomposition_count-1; level>=0; level--){
542  for(orientation=level ? 1 : 0; orientation<4; orientation++){
543  SubBand *b= &s->plane[plane_index].band[level][orientation];
544 
545  b->buf= s->spatial_dwt_buffer;
546  b->level= level;
547  b->stride= s->plane[plane_index].width << (s->spatial_decomposition_count - level);
548  b->width = (w + !(orientation&1))>>1;
549  b->height= (h + !(orientation>1))>>1;
550 
551  b->stride_line = 1 << (s->spatial_decomposition_count - level);
552  b->buf_x_offset = 0;
553  b->buf_y_offset = 0;
554 
555  if(orientation&1){
556  b->buf += (w+1)>>1;
557  b->buf_x_offset = (w+1)>>1;
558  }
559  if(orientation>1){
560  b->buf += b->stride>>1;
561  b->buf_y_offset = b->stride_line >> 1;
562  }
563  b->ibuf= s->spatial_idwt_buffer + (b->buf - s->spatial_dwt_buffer);
564 
565  if(level)
566  b->parent= &s->plane[plane_index].band[level-1][orientation];
567  //FIXME avoid this realloc
568  av_freep(&b->x_coeff);
569  b->x_coeff = av_calloc((b->width + 1) * b->height + 1,
570  sizeof(*b->x_coeff));
571  if (!b->x_coeff)
572  return AVERROR(ENOMEM);
573  }
574  w= (w+1)>>1;
575  h= (h+1)>>1;
576  }
577  }
578 
579  return 0;
580 }
581 
582 #define USE_HALFPEL_PLANE 0
583 
584 static int halfpel_interpol(SnowContext *s, uint8_t *halfpel[4][4], AVFrame *frame){
585  int p,x,y;
586 
587  for(p=0; p < s->nb_planes; p++){
588  int is_chroma= !!p;
589  int w= is_chroma ? AV_CEIL_RSHIFT(s->avctx->width, s->chroma_h_shift) : s->avctx->width;
590  int h= is_chroma ? AV_CEIL_RSHIFT(s->avctx->height, s->chroma_v_shift) : s->avctx->height;
591  int ls= frame->linesize[p];
592  uint8_t *src= frame->data[p];
593 
594  halfpel[1][p] = av_malloc_array(ls, (h + 2 * EDGE_WIDTH));
595  halfpel[2][p] = av_malloc_array(ls, (h + 2 * EDGE_WIDTH));
596  halfpel[3][p] = av_malloc_array(ls, (h + 2 * EDGE_WIDTH));
597  if (!halfpel[1][p] || !halfpel[2][p] || !halfpel[3][p]) {
598  av_freep(&halfpel[1][p]);
599  av_freep(&halfpel[2][p]);
600  av_freep(&halfpel[3][p]);
601  return AVERROR(ENOMEM);
602  }
603  halfpel[1][p] += EDGE_WIDTH * (1 + ls);
604  halfpel[2][p] += EDGE_WIDTH * (1 + ls);
605  halfpel[3][p] += EDGE_WIDTH * (1 + ls);
606 
607  halfpel[0][p]= src;
608  for(y=0; y<h; y++){
609  for(x=0; x<w; x++){
610  int i= y*ls + x;
611 
612  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;
613  }
614  }
615  for(y=0; y<h; y++){
616  for(x=0; x<w; x++){
617  int i= y*ls + x;
618 
619  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;
620  }
621  }
622  src= halfpel[1][p];
623  for(y=0; y<h; y++){
624  for(x=0; x<w; x++){
625  int i= y*ls + x;
626 
627  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;
628  }
629  }
630 
631 //FIXME border!
632  }
633  return 0;
634 }
635 
637 {
638  SnowContext *s = avctx->priv_data;
639  int i;
640 
641  if(s->last_picture[s->max_ref_frames-1]->data[0]){
642  av_frame_unref(s->last_picture[s->max_ref_frames-1]);
643  for(i=0; i<9; i++)
644  if(s->halfpel_plane[s->max_ref_frames-1][1+i/3][i%3]) {
645  av_free(s->halfpel_plane[s->max_ref_frames-1][1+i/3][i%3] - EDGE_WIDTH*(1+s->current_picture->linesize[i%3]));
646  s->halfpel_plane[s->max_ref_frames-1][1+i/3][i%3] = NULL;
647  }
648  }
649 }
650 
652  AVFrame *tmp;
653  int i, ret;
654 
655  ff_snow_release_buffer(s->avctx);
656 
657  tmp= s->last_picture[s->max_ref_frames-1];
658  for(i=s->max_ref_frames-1; i>0; i--)
659  s->last_picture[i] = s->last_picture[i-1];
660  memmove(s->halfpel_plane+1, s->halfpel_plane, (s->max_ref_frames-1)*sizeof(void*)*4*4);
661  if(USE_HALFPEL_PLANE && s->current_picture->data[0]) {
662  if((ret = halfpel_interpol(s, s->halfpel_plane[0], s->current_picture)) < 0)
663  return ret;
664  }
665  s->last_picture[0] = s->current_picture;
666  s->current_picture = tmp;
667 
668  if(s->keyframe){
669  s->ref_frames= 0;
670  }else{
671  int i;
672  for(i=0; i<s->max_ref_frames && s->last_picture[i]->data[0]; i++)
673  if(i && s->last_picture[i-1]->key_frame)
674  break;
675  s->ref_frames= i;
676  if(s->ref_frames==0){
677  av_log(s->avctx,AV_LOG_ERROR, "No reference frames\n");
678  return AVERROR_INVALIDDATA;
679  }
680  }
681  if ((ret = ff_snow_get_buffer(s, s->current_picture)) < 0)
682  return ret;
683 
684  s->current_picture->key_frame= s->keyframe;
685 
686  return 0;
687 }
688 
690 {
691  int plane_index, level, orientation, i;
692 
693  av_freep(&s->spatial_dwt_buffer);
694  av_freep(&s->temp_dwt_buffer);
695  av_freep(&s->spatial_idwt_buffer);
696  av_freep(&s->temp_idwt_buffer);
697  av_freep(&s->run_buffer);
698 
699  s->m.me.temp= NULL;
700  av_freep(&s->m.me.scratchpad);
701  av_freep(&s->m.me.map);
702  av_freep(&s->m.me.score_map);
703  av_freep(&s->m.sc.obmc_scratchpad);
704 
705  av_freep(&s->block);
706  av_freep(&s->scratchbuf);
707  av_freep(&s->emu_edge_buffer);
708 
709  for(i=0; i<MAX_REF_FRAMES; i++){
710  av_freep(&s->ref_mvs[i]);
711  av_freep(&s->ref_scores[i]);
712  if(s->last_picture[i] && s->last_picture[i]->data[0]) {
713  av_assert0(s->last_picture[i]->data[0] != s->current_picture->data[0]);
714  }
715  av_frame_free(&s->last_picture[i]);
716  }
717 
718  for(plane_index=0; plane_index < MAX_PLANES; plane_index++){
719  for(level=MAX_DECOMPOSITIONS-1; level>=0; level--){
720  for(orientation=level ? 1 : 0; orientation<4; orientation++){
721  SubBand *b= &s->plane[plane_index].band[level][orientation];
722 
723  av_freep(&b->x_coeff);
724  }
725  }
726  }
727  av_frame_free(&s->mconly_picture);
728  av_frame_free(&s->current_picture);
729 }
FF_ALLOCZ_TYPED_ARRAY
#define FF_ALLOCZ_TYPED_ARRAY(p, nelem)
Definition: internal.h:98
MC_STRIDE
#define MC_STRIDE(x)
level
uint8_t level
Definition: svq3.c:202
MAX_DECOMPOSITIONS
#define MAX_DECOMPOSITIONS
Definition: dirac_dwt.h:30
r
const char * r
Definition: vf_curves.c:116
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
opt.h
color
Definition: vf_paletteuse.c:600
Plane::fast_mc
int fast_mc
Definition: snow.h:109
MID_STATE
#define MID_STATE
Definition: snow.h:42
thread.h
src1
const pixel * src1
Definition: h264pred_template.c:421
LOG2_MB_SIZE
#define LOG2_MB_SIZE
Definition: snow.h:75
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:109
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:317
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:26
w
uint8_t w
Definition: llviddspenc.c:38
internal.h
b
#define b
Definition: input.c:40
rangecoder.h
mcfh
#define mcfh(dx, dy)
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
SnowContext
Definition: snow.h:116
MAX_REF_FRAMES
#define MAX_REF_FRAMES
Definition: snow.h:49
ff_snow_common_end
av_cold void ff_snow_common_end(SnowContext *s)
Definition: snow.c:689
Plane::diag_mc
int diag_mc
Definition: snow.h:108
LOG2_OBMC_MAX
#define LOG2_OBMC_MAX
Definition: snow.h:51
BlockNode
Definition: snow.h:53
ff_me_cmp_init
av_cold void ff_me_cmp_init(MECmpContext *c, AVCodecContext *avctx)
Definition: me_cmp.c:1015
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:463
ff_videodsp_init
av_cold void ff_videodsp_init(VideoDSPContext *ctx, int bpc)
Definition: videodsp.c:38
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:318
ff_h264qpel_init
av_cold void ff_h264qpel_init(H264QpelContext *c, int bit_depth)
Definition: h264qpel.c:49
scale
static av_always_inline float scale(float x, float s)
Definition: vf_v360.c:1388
ff_dwt_init
av_cold void ff_dwt_init(SnowDWTContext *c)
Definition: snow_dwt.c:850
av_frame_alloc
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:97
a1
#define a1
Definition: regdef.h:47
ff_snow_common_init_after_header
int ff_snow_common_init_after_header(AVCodecContext *avctx)
Definition: snow.c:510
ff_thread_once
static int ff_thread_once(char *control, void(*routine)(void))
Definition: thread.h:175
USE_HALFPEL_PLANE
#define USE_HALFPEL_PLANE
Definition: snow.c:582
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
av_cold
#define av_cold
Definition: attributes.h:90
ff_snow_get_buffer
int ff_snow_get_buffer(SnowContext *s, AVFrame *frame)
Definition: snow.c:69
width
#define width
s
#define s(width, name)
Definition: cbs_vp9.c:257
MAX_PLANES
#define MAX_PLANES
Definition: ffv1.h:48
AV_CEIL_RSHIFT
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:51
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:125
AV_GET_BUFFER_FLAG_REF
#define AV_GET_BUFFER_FLAG_REF
The decoder will keep a reference to the frame and may reuse it later.
Definition: avcodec.h:361
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
a4
#define a4
Definition: regdef.h:50
ff_snow_common_init
av_cold int ff_snow_common_init(AVCodecContext *avctx)
Definition: snow.c:428
ff_hpeldsp_init
av_cold void ff_hpeldsp_init(HpelDSPContext *c, int flags)
Definition: hpeldsp.c:338
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
AV_ONCE_INIT
#define AV_ONCE_INIT
Definition: thread.h:173
NULL
#define NULL
Definition: coverity.c:32
EDGE_WIDTH
#define EDGE_WIDTH
Definition: mpegpicture.h:34
snow.h
ff_snow_release_buffer
void ff_snow_release_buffer(AVCodecContext *avctx)
Definition: snow.c:636
mathops.h
snowdata.h
AVOnce
#define AVOnce
Definition: thread.h:172
weight
static int weight(int i, int blen, int offset)
Definition: diracdec.c:1561
MB_SIZE
#define MB_SIZE
Definition: cinepakenc.c:55
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1652
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:92
SubBand
Definition: cfhd.h:109
height
#define height
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
offset
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
Definition: writing_filters.txt:86
snow_dwt.h
a0
#define a0
Definition: regdef.h:46
Plane::hcoeff
int8_t hcoeff[HTAPS_MAX/2]
Definition: snow.h:107
av_codec_is_encoder
int av_codec_is_encoder(const AVCodec *codec)
Definition: utils.c:76
av_assert2
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:64
log.h
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:271
src2
const pixel * src2
Definition: h264pred_template.c:422
av_malloc_array
#define av_malloc_array(a, b)
Definition: tableprint_vlc.h:32
BLOCK_INTRA
#define BLOCK_INTRA
Intra block, inter otherwise.
Definition: snow.h:60
a2
#define a2
Definition: regdef.h:48
av_frame_unref
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:435
ff_snow_frame_start
int ff_snow_frame_start(SnowContext *s)
Definition: snow.c:651
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:593
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:271
avcodec.h
stride
#define stride
Definition: h264pred_template.c:537
ret
ret
Definition: filter_design.txt:187
frame
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:264
halfpel_interpol
static int halfpel_interpol(SnowContext *s, uint8_t *halfpel[4][4], AVFrame *frame)
Definition: snow.c:584
ff_snow_reset_contexts
void ff_snow_reset_contexts(SnowContext *s)
Definition: snow.c:96
me_cmp.h
AVCodecContext
main external API structure.
Definition: avcodec.h:383
a5
#define a5
Definition: regdef.h:51
FRAC_BITS
#define FRAC_BITS
Definition: g729postfilter.c:36
mcf
#define mcf(dx, dy)
Plane
Definition: cfhd.h:118
slice_buffer_get_line
#define slice_buffer_get_line(slice_buf, line_num)
Definition: snow_dwt.h:89
add
static float add(float src0, float src1)
Definition: dnn_backend_native_layer_mathbinary.c:35
ff_scale_mv_ref
int ff_scale_mv_ref[MAX_REF_FRAMES][MAX_REF_FRAMES]
Definition: snowdata.h:135
av_free
#define av_free(p)
Definition: tableprint_vlc.h:34
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:410
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
src
INIT_CLIP pixel * src
Definition: h264pred_template.c:418
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:556
HTAPS_MAX
#define HTAPS_MAX
Definition: snow.h:78
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:28
IDWTELEM
short IDWTELEM
Definition: dirac_dwt.h:27
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
h
h
Definition: vp9dsp_template.c:2038
ff_snow_alloc_blocks
int ff_snow_alloc_blocks(SnowContext *s)
Definition: snow.c:110
a3
#define a3
Definition: regdef.h:49
mca
#define mca(dx, dy, b_w)
Definition: snow.c:406
intmath.h