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