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