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/log.h"
22 #include "libavutil/thread.h"
23 #include "avcodec.h"
24 #include "snow_dwt.h"
25 #include "snow.h"
26 #include "snowdata.h"
27 
28 
29 void ff_snow_inner_add_yblock(const uint8_t *obmc, const int obmc_stride, uint8_t * * block, int b_w, int b_h,
30  int src_x, int src_y, int src_stride, slice_buffer * sb, int add, uint8_t * dst8){
31  int y, x;
32  IDWTELEM * dst;
33  for(y=0; y<b_h; y++){
34  //FIXME ugly misuse of obmc_stride
35  const uint8_t *obmc1= obmc + y*obmc_stride;
36  const uint8_t *obmc2= obmc1+ (obmc_stride>>1);
37  const uint8_t *obmc3= obmc1+ obmc_stride*(obmc_stride>>1);
38  const uint8_t *obmc4= obmc3+ (obmc_stride>>1);
39  dst = slice_buffer_get_line(sb, src_y + y);
40  for(x=0; x<b_w; x++){
41  int v= obmc1[x] * block[3][x + y*src_stride]
42  +obmc2[x] * block[2][x + y*src_stride]
43  +obmc3[x] * block[1][x + y*src_stride]
44  +obmc4[x] * block[0][x + y*src_stride];
45 
46  v <<= 8 - LOG2_OBMC_MAX;
47  if(FRAC_BITS != 8){
48  v >>= 8 - FRAC_BITS;
49  }
50  if(add){
51  v += dst[x + src_x];
52  v = (v + (1<<(FRAC_BITS-1))) >> FRAC_BITS;
53  if(v&(~255)) v= ~(v>>31);
54  dst8[x + y*src_stride] = v;
55  }else{
56  dst[x + src_x] -= v;
57  }
58  }
59  }
60 }
61 
62 void ff_snow_reset_contexts(SnowContext *s){ //FIXME better initial contexts
63  int plane_index, level, orientation;
64 
65  for(plane_index=0; plane_index<3; plane_index++){
66  for(level=0; level<MAX_DECOMPOSITIONS; level++){
67  for(orientation=level ? 1:0; orientation<4; orientation++){
68  memset(s->plane[plane_index].band[level][orientation].state, MID_STATE, sizeof(s->plane[plane_index].band[level][orientation].state));
69  }
70  }
71  }
72  memset(s->header_state, MID_STATE, sizeof(s->header_state));
73  memset(s->block_state, MID_STATE, sizeof(s->block_state));
74 }
75 
76 int ff_snow_alloc_blocks(SnowContext *s){
77  int w= AV_CEIL_RSHIFT(s->avctx->width, LOG2_MB_SIZE);
78  int h= AV_CEIL_RSHIFT(s->avctx->height, LOG2_MB_SIZE);
79 
80  s->b_width = w;
81  s->b_height= h;
82 
83  av_free(s->block);
84  s->block = av_calloc(w * h, sizeof(*s->block) << (s->block_max_depth*2));
85  if (!s->block)
86  return AVERROR(ENOMEM);
87 
88  return 0;
89 }
90 
91 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){
92  static const uint8_t weight[64]={
93  8,7,6,5,4,3,2,1,
94  7,7,0,0,0,0,0,1,
95  6,0,6,0,0,0,2,0,
96  5,0,0,5,0,3,0,0,
97  4,0,0,0,4,0,0,0,
98  3,0,0,5,0,3,0,0,
99  2,0,6,0,0,0,2,0,
100  1,7,0,0,0,0,0,1,
101  };
102 
103  static const uint8_t brane[256]={
104  0x00,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x11,0x12,0x12,0x12,0x12,0x12,0x12,0x12,
105  0x04,0x05,0xcc,0xcc,0xcc,0xcc,0xcc,0x41,0x15,0x16,0xcc,0xcc,0xcc,0xcc,0xcc,0x52,
106  0x04,0xcc,0x05,0xcc,0xcc,0xcc,0x41,0xcc,0x15,0xcc,0x16,0xcc,0xcc,0xcc,0x52,0xcc,
107  0x04,0xcc,0xcc,0x05,0xcc,0x41,0xcc,0xcc,0x15,0xcc,0xcc,0x16,0xcc,0x52,0xcc,0xcc,
108  0x04,0xcc,0xcc,0xcc,0x41,0xcc,0xcc,0xcc,0x15,0xcc,0xcc,0xcc,0x16,0xcc,0xcc,0xcc,
109  0x04,0xcc,0xcc,0x41,0xcc,0x05,0xcc,0xcc,0x15,0xcc,0xcc,0x52,0xcc,0x16,0xcc,0xcc,
110  0x04,0xcc,0x41,0xcc,0xcc,0xcc,0x05,0xcc,0x15,0xcc,0x52,0xcc,0xcc,0xcc,0x16,0xcc,
111  0x04,0x41,0xcc,0xcc,0xcc,0xcc,0xcc,0x05,0x15,0x52,0xcc,0xcc,0xcc,0xcc,0xcc,0x16,
112  0x44,0x45,0x45,0x45,0x45,0x45,0x45,0x45,0x55,0x56,0x56,0x56,0x56,0x56,0x56,0x56,
113  0x48,0x49,0xcc,0xcc,0xcc,0xcc,0xcc,0x85,0x59,0x5A,0xcc,0xcc,0xcc,0xcc,0xcc,0x96,
114  0x48,0xcc,0x49,0xcc,0xcc,0xcc,0x85,0xcc,0x59,0xcc,0x5A,0xcc,0xcc,0xcc,0x96,0xcc,
115  0x48,0xcc,0xcc,0x49,0xcc,0x85,0xcc,0xcc,0x59,0xcc,0xcc,0x5A,0xcc,0x96,0xcc,0xcc,
116  0x48,0xcc,0xcc,0xcc,0x49,0xcc,0xcc,0xcc,0x59,0xcc,0xcc,0xcc,0x96,0xcc,0xcc,0xcc,
117  0x48,0xcc,0xcc,0x85,0xcc,0x49,0xcc,0xcc,0x59,0xcc,0xcc,0x96,0xcc,0x5A,0xcc,0xcc,
118  0x48,0xcc,0x85,0xcc,0xcc,0xcc,0x49,0xcc,0x59,0xcc,0x96,0xcc,0xcc,0xcc,0x5A,0xcc,
119  0x48,0x85,0xcc,0xcc,0xcc,0xcc,0xcc,0x49,0x59,0x96,0xcc,0xcc,0xcc,0xcc,0xcc,0x5A,
120  };
121 
122  static const uint8_t needs[16]={
123  0,1,0,0,
124  2,4,2,0,
125  0,1,0,0,
126  15
127  };
128 
129  int x, y, b, r, l;
130  int16_t tmpIt [64*(32+HTAPS_MAX)];
131  uint8_t tmp2t[3][64*(32+HTAPS_MAX)];
132  int16_t *tmpI= tmpIt;
133  uint8_t *tmp2= tmp2t[0];
134  const uint8_t *hpel[11];
135  av_assert2(dx<16 && dy<16);
136  r= brane[dx + 16*dy]&15;
137  l= brane[dx + 16*dy]>>4;
138 
139  b= needs[l] | needs[r];
140  if(p && !p->diag_mc)
141  b= 15;
142 
143  if(b&5){
144  for(y=0; y < b_h+HTAPS_MAX-1; y++){
145  for(x=0; x < b_w; x++){
146  int a_1=src[x + HTAPS_MAX/2-4];
147  int a0= src[x + HTAPS_MAX/2-3];
148  int a1= src[x + HTAPS_MAX/2-2];
149  int a2= src[x + HTAPS_MAX/2-1];
150  int a3= src[x + HTAPS_MAX/2+0];
151  int a4= src[x + HTAPS_MAX/2+1];
152  int a5= src[x + HTAPS_MAX/2+2];
153  int a6= src[x + HTAPS_MAX/2+3];
154  int am=0;
155  if(!p || p->fast_mc){
156  am= 20*(a2+a3) - 5*(a1+a4) + (a0+a5);
157  tmpI[x]= am;
158  am= (am+16)>>5;
159  }else{
160  am= p->hcoeff[0]*(a2+a3) + p->hcoeff[1]*(a1+a4) + p->hcoeff[2]*(a0+a5) + p->hcoeff[3]*(a_1+a6);
161  tmpI[x]= am;
162  am= (am+32)>>6;
163  }
164 
165  if(am&(~255)) am= ~(am>>31);
166  tmp2[x]= am;
167  }
168  tmpI+= 64;
169  tmp2+= 64;
170  src += stride;
171  }
172  src -= stride*y;
173  }
174  src += HTAPS_MAX/2 - 1;
175  tmp2= tmp2t[1];
176 
177  if(b&2){
178  for(y=0; y < b_h; y++){
179  for(x=0; x < b_w+1; x++){
180  int a_1=src[x + (HTAPS_MAX/2-4)*stride];
181  int a0= src[x + (HTAPS_MAX/2-3)*stride];
182  int a1= src[x + (HTAPS_MAX/2-2)*stride];
183  int a2= src[x + (HTAPS_MAX/2-1)*stride];
184  int a3= src[x + (HTAPS_MAX/2+0)*stride];
185  int a4= src[x + (HTAPS_MAX/2+1)*stride];
186  int a5= src[x + (HTAPS_MAX/2+2)*stride];
187  int a6= src[x + (HTAPS_MAX/2+3)*stride];
188  int am=0;
189  if(!p || p->fast_mc)
190  am= (20*(a2+a3) - 5*(a1+a4) + (a0+a5) + 16)>>5;
191  else
192  am= (p->hcoeff[0]*(a2+a3) + p->hcoeff[1]*(a1+a4) + p->hcoeff[2]*(a0+a5) + p->hcoeff[3]*(a_1+a6) + 32)>>6;
193 
194  if(am&(~255)) am= ~(am>>31);
195  tmp2[x]= am;
196  }
197  src += stride;
198  tmp2+= 64;
199  }
200  src -= stride*y;
201  }
202  src += stride*(HTAPS_MAX/2 - 1);
203  tmp2= tmp2t[2];
204  tmpI= tmpIt;
205  if(b&4){
206  for(y=0; y < b_h; y++){
207  for(x=0; x < b_w; x++){
208  int a_1=tmpI[x + (HTAPS_MAX/2-4)*64];
209  int a0= tmpI[x + (HTAPS_MAX/2-3)*64];
210  int a1= tmpI[x + (HTAPS_MAX/2-2)*64];
211  int a2= tmpI[x + (HTAPS_MAX/2-1)*64];
212  int a3= tmpI[x + (HTAPS_MAX/2+0)*64];
213  int a4= tmpI[x + (HTAPS_MAX/2+1)*64];
214  int a5= tmpI[x + (HTAPS_MAX/2+2)*64];
215  int a6= tmpI[x + (HTAPS_MAX/2+3)*64];
216  int am=0;
217  if(!p || p->fast_mc)
218  am= (20*(a2+a3) - 5*(a1+a4) + (a0+a5) + 512)>>10;
219  else
220  am= (p->hcoeff[0]*(a2+a3) + p->hcoeff[1]*(a1+a4) + p->hcoeff[2]*(a0+a5) + p->hcoeff[3]*(a_1+a6) + 2048)>>12;
221  if(am&(~255)) am= ~(am>>31);
222  tmp2[x]= am;
223  }
224  tmpI+= 64;
225  tmp2+= 64;
226  }
227  }
228 
229  hpel[ 0]= src;
230  hpel[ 1]= tmp2t[0] + 64*(HTAPS_MAX/2-1);
231  hpel[ 2]= src + 1;
232 
233  hpel[ 4]= tmp2t[1];
234  hpel[ 5]= tmp2t[2];
235  hpel[ 6]= tmp2t[1] + 1;
236 
237  hpel[ 8]= src + stride;
238  hpel[ 9]= hpel[1] + 64;
239  hpel[10]= hpel[8] + 1;
240 
241 #define MC_STRIDE(x) (needs[x] ? 64 : stride)
242 
243  if(b==15){
244  int dxy = dx / 8 + dy / 8 * 4;
245  const uint8_t *src1 = hpel[dxy ];
246  const uint8_t *src2 = hpel[dxy + 1];
247  const uint8_t *src3 = hpel[dxy + 4];
248  const uint8_t *src4 = hpel[dxy + 5];
249  int stride1 = MC_STRIDE(dxy);
250  int stride2 = MC_STRIDE(dxy + 1);
251  int stride3 = MC_STRIDE(dxy + 4);
252  int stride4 = MC_STRIDE(dxy + 5);
253  dx&=7;
254  dy&=7;
255  for(y=0; y < b_h; y++){
256  for(x=0; x < b_w; x++){
257  dst[x]= ((8-dx)*(8-dy)*src1[x] + dx*(8-dy)*src2[x]+
258  (8-dx)* dy *src3[x] + dx* dy *src4[x]+32)>>6;
259  }
260  src1+=stride1;
261  src2+=stride2;
262  src3+=stride3;
263  src4+=stride4;
264  dst +=stride;
265  }
266  }else{
267  const uint8_t *src1= hpel[l];
268  const uint8_t *src2= hpel[r];
269  int stride1 = MC_STRIDE(l);
270  int stride2 = MC_STRIDE(r);
271  int a= weight[((dx&7) + (8*(dy&7)))];
272  int b= 8-a;
273  for(y=0; y < b_h; y++){
274  for(x=0; x < b_w; x++){
275  dst[x]= (a*src1[x] + b*src2[x] + 4)>>3;
276  }
277  src1+=stride1;
278  src2+=stride2;
279  dst +=stride;
280  }
281  }
282 }
283 
284 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){
285  if(block->type & BLOCK_INTRA){
286  int x, y;
287  const unsigned color = block->color[plane_index];
288  const unsigned color4 = color*0x01010101;
289  if(b_w==32){
290  for(y=0; y < b_h; y++){
291  *(uint32_t*)&dst[0 + y*stride]= color4;
292  *(uint32_t*)&dst[4 + y*stride]= color4;
293  *(uint32_t*)&dst[8 + y*stride]= color4;
294  *(uint32_t*)&dst[12+ y*stride]= color4;
295  *(uint32_t*)&dst[16+ y*stride]= color4;
296  *(uint32_t*)&dst[20+ y*stride]= color4;
297  *(uint32_t*)&dst[24+ y*stride]= color4;
298  *(uint32_t*)&dst[28+ y*stride]= color4;
299  }
300  }else if(b_w==16){
301  for(y=0; y < b_h; y++){
302  *(uint32_t*)&dst[0 + y*stride]= color4;
303  *(uint32_t*)&dst[4 + y*stride]= color4;
304  *(uint32_t*)&dst[8 + y*stride]= color4;
305  *(uint32_t*)&dst[12+ y*stride]= color4;
306  }
307  }else if(b_w==8){
308  for(y=0; y < b_h; y++){
309  *(uint32_t*)&dst[0 + y*stride]= color4;
310  *(uint32_t*)&dst[4 + y*stride]= color4;
311  }
312  }else if(b_w==4){
313  for(y=0; y < b_h; y++){
314  *(uint32_t*)&dst[0 + y*stride]= color4;
315  }
316  }else{
317  for(y=0; y < b_h; y++){
318  for(x=0; x < b_w; x++){
319  dst[x + y*stride]= color;
320  }
321  }
322  }
323  }else{
324  const uint8_t *src = s->last_picture[block->ref]->data[plane_index];
325  const int scale= plane_index ? (2*s->mv_scale)>>s->chroma_h_shift : 2*s->mv_scale;
326  int mx= block->mx*scale;
327  int my= block->my*scale;
328  const int dx= mx&15;
329  const int dy= my&15;
330  const int tab_index= 3 - (b_w>>2) + (b_w>>4);
331  sx += (mx>>4) - (HTAPS_MAX/2-1);
332  sy += (my>>4) - (HTAPS_MAX/2-1);
333  src += sx + sy*stride;
334  if( (unsigned)sx >= FFMAX(w - b_w - (HTAPS_MAX-2), 0)
335  || (unsigned)sy >= FFMAX(h - b_h - (HTAPS_MAX-2), 0)){
336  s->vdsp.emulated_edge_mc(tmp + MB_SIZE, src,
337  stride, stride,
338  b_w+HTAPS_MAX-1, b_h+HTAPS_MAX-1,
339  sx, sy, w, h);
340  src= tmp + MB_SIZE;
341  }
342 
343  av_assert2(s->chroma_h_shift == s->chroma_v_shift); // only one mv_scale
344 
345  av_assert2((tab_index>=0 && tab_index<4) || b_w==32);
346  if( (dx&3) || (dy&3)
347  || !(b_w == b_h || 2*b_w == b_h || b_w == 2*b_h)
348  || (b_w&(b_w-1))
349  || b_w == 1
350  || b_h == 1
351  || !s->plane[plane_index].fast_mc )
352  mc_block(&s->plane[plane_index], dst, src, stride, b_w, b_h, dx, dy);
353  else if(b_w==32){
354  int y;
355  for(y=0; y<b_h; y+=16){
356  s->h264qpel.put_h264_qpel_pixels_tab[0][dy+(dx>>2)](dst + y*stride, src + 3 + (y+3)*stride,stride);
357  s->h264qpel.put_h264_qpel_pixels_tab[0][dy+(dx>>2)](dst + 16 + y*stride, src + 19 + (y+3)*stride,stride);
358  }
359  }else if(b_w==b_h)
360  s->h264qpel.put_h264_qpel_pixels_tab[tab_index ][dy+(dx>>2)](dst,src + 3 + 3*stride,stride);
361  else if(b_w==2*b_h){
362  s->h264qpel.put_h264_qpel_pixels_tab[tab_index+1][dy+(dx>>2)](dst ,src + 3 + 3*stride,stride);
363  s->h264qpel.put_h264_qpel_pixels_tab[tab_index+1][dy+(dx>>2)](dst+b_h,src + 3 + b_h + 3*stride,stride);
364  }else{
365  av_assert2(2*b_w==b_h);
366  s->h264qpel.put_h264_qpel_pixels_tab[tab_index ][dy+(dx>>2)](dst ,src + 3 + 3*stride ,stride);
367  s->h264qpel.put_h264_qpel_pixels_tab[tab_index ][dy+(dx>>2)](dst+b_w*stride,src + 3 + 3*stride+b_w*stride,stride);
368  }
369  }
370 }
371 
372 #define mca(dx,dy,b_w)\
373 static void mc_block_hpel ## dx ## dy ## b_w(uint8_t *dst, const uint8_t *src, ptrdiff_t stride, int h){\
374  av_assert2(h==b_w);\
375  mc_block(NULL, dst, src-(HTAPS_MAX/2-1)-(HTAPS_MAX/2-1)*stride, stride, b_w, b_w, dx, dy);\
376 }
377 
378 mca( 0, 0,16)
379 mca( 8, 0,16)
380 mca( 0, 8,16)
381 mca( 8, 8,16)
382 mca( 0, 0,8)
383 mca( 8, 0,8)
384 mca( 0, 8,8)
385 mca( 8, 8,8)
386 
387 static av_cold void snow_static_init(void)
388 {
389  for (int i = 0; i < MAX_REF_FRAMES; i++)
390  for (int j = 0; j < MAX_REF_FRAMES; j++)
391  ff_scale_mv_ref[i][j] = 256 * (i + 1) / (j + 1);
392 }
393 
394 av_cold int ff_snow_common_init(AVCodecContext *avctx){
395  static AVOnce init_static_once = AV_ONCE_INIT;
396  SnowContext *s = avctx->priv_data;
397  int width, height;
398  int i;
399 
400  s->avctx= avctx;
401  s->max_ref_frames=1; //just make sure it's not an invalid value in case of no initial keyframe
402  s->spatial_decomposition_count = 1;
403 
404  ff_videodsp_init(&s->vdsp, 8);
405  ff_dwt_init(&s->dwt);
406  ff_h264qpel_init(&s->h264qpel, 8);
407 
408 #define mcfh(dx,dy)\
409  s->hdsp.put_pixels_tab [0][dy/4+dx/8]=\
410  s->hdsp.put_no_rnd_pixels_tab[0][dy/4+dx/8]=\
411  mc_block_hpel ## dx ## dy ## 16;\
412  s->hdsp.put_pixels_tab [1][dy/4+dx/8]=\
413  s->hdsp.put_no_rnd_pixels_tab[1][dy/4+dx/8]=\
414  mc_block_hpel ## dx ## dy ## 8;
415 
416  mcfh(0, 0)
417  mcfh(8, 0)
418  mcfh(0, 8)
419  mcfh(8, 8)
420 
421 // dec += FFMAX(s->chroma_h_shift, s->chroma_v_shift);
422 
423  width= s->avctx->width;
424  height= s->avctx->height;
425 
426  if (!FF_ALLOCZ_TYPED_ARRAY(s->spatial_idwt_buffer, width * height) ||
427  !FF_ALLOCZ_TYPED_ARRAY(s->spatial_dwt_buffer, width * height) || //FIXME this does not belong here
428  !FF_ALLOCZ_TYPED_ARRAY(s->temp_dwt_buffer, width) ||
429  !FF_ALLOCZ_TYPED_ARRAY(s->temp_idwt_buffer, width) ||
430  !FF_ALLOCZ_TYPED_ARRAY(s->run_buffer, ((width + 1) >> 1) * ((height + 1) >> 1)))
431  return AVERROR(ENOMEM);
432 
433  for(i=0; i<MAX_REF_FRAMES; i++) {
434  s->last_picture[i] = av_frame_alloc();
435  if (!s->last_picture[i])
436  return AVERROR(ENOMEM);
437  }
438 
439  s->mconly_picture = av_frame_alloc();
440  s->current_picture = av_frame_alloc();
441  if (!s->mconly_picture || !s->current_picture)
442  return AVERROR(ENOMEM);
443 
444  ff_thread_once(&init_static_once, snow_static_init);
445 
446  return 0;
447 }
448 
449 int ff_snow_common_init_after_header(AVCodecContext *avctx) {
450  SnowContext *s = avctx->priv_data;
451  int plane_index, level, orientation;
452 
453  if(!s->scratchbuf) {
454  int emu_buf_size;
455  emu_buf_size = FFMAX(s->mconly_picture->linesize[0], 2*avctx->width+256) * (2 * MB_SIZE + HTAPS_MAX - 1);
456  if (!FF_ALLOCZ_TYPED_ARRAY(s->scratchbuf, FFMAX(s->mconly_picture->linesize[0], 2*avctx->width+256) * 7 * MB_SIZE) ||
457  !FF_ALLOCZ_TYPED_ARRAY(s->emu_edge_buffer, emu_buf_size))
458  return AVERROR(ENOMEM);
459  }
460 
461  for(plane_index=0; plane_index < s->nb_planes; plane_index++){
462  int w= s->avctx->width;
463  int h= s->avctx->height;
464 
465  if(plane_index){
466  w = AV_CEIL_RSHIFT(w, s->chroma_h_shift);
467  h = AV_CEIL_RSHIFT(h, s->chroma_v_shift);
468  }
469  s->plane[plane_index].width = w;
470  s->plane[plane_index].height= h;
471 
472  for(level=s->spatial_decomposition_count-1; level>=0; level--){
473  for(orientation=level ? 1 : 0; orientation<4; orientation++){
474  SubBand *b= &s->plane[plane_index].band[level][orientation];
475 
476  b->buf= s->spatial_dwt_buffer;
477  b->level= level;
478  b->stride= s->plane[plane_index].width << (s->spatial_decomposition_count - level);
479  b->width = (w + !(orientation&1))>>1;
480  b->height= (h + !(orientation>1))>>1;
481 
482  b->stride_line = 1 << (s->spatial_decomposition_count - level);
483  b->buf_x_offset = 0;
484  b->buf_y_offset = 0;
485 
486  if(orientation&1){
487  b->buf += (w+1)>>1;
488  b->buf_x_offset = (w+1)>>1;
489  }
490  if(orientation>1){
491  b->buf += b->stride>>1;
492  b->buf_y_offset = b->stride_line >> 1;
493  }
494  b->ibuf= s->spatial_idwt_buffer + (b->buf - s->spatial_dwt_buffer);
495 
496  if(level)
497  b->parent= &s->plane[plane_index].band[level-1][orientation];
498  //FIXME avoid this realloc
499  av_freep(&b->x_coeff);
500  b->x_coeff = av_calloc((b->width + 1) * b->height + 1,
501  sizeof(*b->x_coeff));
502  if (!b->x_coeff)
503  return AVERROR(ENOMEM);
504  }
505  w= (w+1)>>1;
506  h= (h+1)>>1;
507  }
508  }
509 
510  return 0;
511 }
512 
513 void ff_snow_release_buffer(AVCodecContext *avctx)
514 {
515  SnowContext *s = avctx->priv_data;
516 
517  if(s->last_picture[s->max_ref_frames-1]->data[0]){
518  av_frame_unref(s->last_picture[s->max_ref_frames-1]);
519  }
520 }
521 
522 int ff_snow_frames_prepare(SnowContext *s)
523 {
524  AVFrame *tmp;
525 
526  ff_snow_release_buffer(s->avctx);
527 
528  tmp= s->last_picture[s->max_ref_frames-1];
529  for (int i = s->max_ref_frames - 1; i > 0; i--)
530  s->last_picture[i] = s->last_picture[i-1];
531  s->last_picture[0] = s->current_picture;
532  s->current_picture = tmp;
533 
534  if(s->keyframe){
535  s->ref_frames= 0;
536  s->current_picture->flags |= AV_FRAME_FLAG_KEY;
537  }else{
538  int i;
539  for(i=0; i<s->max_ref_frames && s->last_picture[i]->data[0]; i++)
540  if(i && (s->last_picture[i-1]->flags & AV_FRAME_FLAG_KEY))
541  break;
542  s->ref_frames= i;
543  if(s->ref_frames==0){
544  av_log(s->avctx,AV_LOG_ERROR, "No reference frames\n");
545  return AVERROR_INVALIDDATA;
546  }
547  s->current_picture->flags &= ~AV_FRAME_FLAG_KEY;
548  }
549 
550  return 0;
551 }
552 
553 av_cold void ff_snow_common_end(SnowContext *s)
554 {
555  int plane_index, level, orientation, i;
556 
557  av_freep(&s->spatial_dwt_buffer);
558  av_freep(&s->temp_dwt_buffer);
559  av_freep(&s->spatial_idwt_buffer);
560  av_freep(&s->temp_idwt_buffer);
561  av_freep(&s->run_buffer);
562 
563  av_freep(&s->block);
564  av_freep(&s->scratchbuf);
565  av_freep(&s->emu_edge_buffer);
566 
567  for(i=0; i<MAX_REF_FRAMES; i++){
568  if(s->last_picture[i] && s->last_picture[i]->data[0]) {
569  av_assert0(s->last_picture[i]->data[0] != s->current_picture->data[0]);
570  }
571  av_frame_free(&s->last_picture[i]);
572  }
573 
574  for(plane_index=0; plane_index < MAX_PLANES; plane_index++){
575  for(level=MAX_DECOMPOSITIONS-1; level>=0; level--){
576  for(orientation=level ? 1 : 0; orientation<4; orientation++){
577  SubBand *b= &s->plane[plane_index].band[level][orientation];
578 
579  av_freep(&b->x_coeff);
580  }
581  }
582  }
583  av_frame_free(&s->mconly_picture);
584  av_frame_free(&s->current_picture);
585 }
FF_ALLOCZ_TYPED_ARRAY
#define FF_ALLOCZ_TYPED_ARRAY(p, nelem)
Definition: internal.h:88
MC_STRIDE
#define MC_STRIDE(x)
level
uint8_t level
Definition: svq3.c:204
MAX_DECOMPOSITIONS
#define MAX_DECOMPOSITIONS
Definition: dirac_dwt.h:30
r
const char * r
Definition: vf_curves.c:126
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
color
Definition: vf_paletteuse.c:511
Plane::fast_mc
int fast_mc
Definition: snow.h:106
MID_STATE
#define MID_STATE
Definition: snow.h:39
thread.h
src1
const pixel * src1
Definition: h264pred_template.c:421
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:100
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:340
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:28
w
uint8_t w
Definition: llviddspenc.c:38
b
#define b
Definition: input.c:41
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
ff_snow_common_end
av_cold void ff_snow_common_end(SnowContext *s)
Definition: snow.c:553
Plane::diag_mc
int diag_mc
Definition: snow.h:105
LOG2_OBMC_MAX
#define LOG2_OBMC_MAX
Definition: snow.h:48
BlockNode
Definition: snow.h:50
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:284
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:1389
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:88
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:449
ff_thread_once
static int ff_thread_once(char *control, void(*routine)(void))
Definition: thread.h:203
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
AV_FRAME_FLAG_KEY
#define AV_FRAME_FLAG_KEY
A flag to mark frames that are keyframes.
Definition: frame.h:628
width
#define width
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: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:91
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:40
a4
#define a4
Definition: regdef.h:50
ff_snow_common_init
av_cold int ff_snow_common_init(AVCodecContext *avctx)
Definition: snow.c:394
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:29
AV_ONCE_INIT
#define AV_ONCE_INIT
Definition: thread.h:201
snow.h
ff_snow_release_buffer
void ff_snow_release_buffer(AVCodecContext *avctx)
Definition: snow.c:513
snowdata.h
AVOnce
#define AVOnce
Definition: thread.h:200
weight
static int weight(int i, int blen, int offset)
Definition: diracdec.c:1562
MB_SIZE
#define MB_SIZE
Definition: cinepakenc.c:55
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:94
SubBand
Definition: cfhd.h:108
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
snow_dwt.h
a0
#define a0
Definition: regdef.h:46
Plane::hcoeff
int8_t hcoeff[HTAPS_MAX/2]
Definition: snow.h:104
av_assert2
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:67
log.h
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:255
src2
const pixel * src2
Definition: h264pred_template.c:422
BLOCK_INTRA
#define BLOCK_INTRA
Intra block, inter otherwise.
Definition: snow.h:57
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:622
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:262
avcodec.h
stride
#define stride
Definition: h264pred_template.c:537
ff_snow_reset_contexts
void ff_snow_reset_contexts(SnowContext *s)
Definition: snow.c:62
AVCodecContext
main external API structure.
Definition: avcodec.h:441
a5
#define a5
Definition: regdef.h:51
FRAC_BITS
#define FRAC_BITS
Definition: g729postfilter.c:36
Plane
Definition: cfhd.h:117
slice_buffer_get_line
#define slice_buffer_get_line(slice_buf, line_num)
Definition: snow_dwt.h:91
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:33
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:468
ff_snow_frames_prepare
int ff_snow_frames_prepare(SnowContext *s)
Definition: snow.c:522
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
src
INIT_CLIP pixel * src
Definition: h264pred_template.c:418
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:621
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
h
h
Definition: vp9dsp_template.c:2038
ff_snow_alloc_blocks
int ff_snow_alloc_blocks(SnowContext *s)
Definition: snow.c:76
a3
#define a3
Definition: regdef.h:49
mca
#define mca(dx, dy, b_w)
Definition: snow.c:372
Generated on Thu Apr 18 2024 22:42:09 for FFmpeg by   doxygen 1.8.17