FFmpeg
snowenc.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/libm.h"
23 #include "libavutil/log.h"
24 #include "libavutil/opt.h"
25 #include "libavutil/pixdesc.h"
26 #include "avcodec.h"
27 #include "encode.h"
28 #include "internal.h"
29 #include "packet_internal.h"
30 #include "snow_dwt.h"
31 #include "snow.h"
32 
33 #include "rangecoder.h"
34 #include "mathops.h"
35 
36 #include "mpegvideo.h"
37 #include "h263.h"
38 
39 static av_cold int encode_init(AVCodecContext *avctx)
40 {
41  SnowContext *s = avctx->priv_data;
42  int plane_index, ret;
43  int i;
44 
45  if(s->pred == DWT_97
46  && (avctx->flags & AV_CODEC_FLAG_QSCALE)
47  && avctx->global_quality == 0){
48  av_log(avctx, AV_LOG_ERROR, "The 9/7 wavelet is incompatible with lossless mode.\n");
49  return AVERROR(EINVAL);
50  }
51 
52  s->spatial_decomposition_type= s->pred; //FIXME add decorrelator type r transform_type
53 
54  s->mv_scale = (avctx->flags & AV_CODEC_FLAG_QPEL) ? 2 : 4;
55  s->block_max_depth= (avctx->flags & AV_CODEC_FLAG_4MV ) ? 1 : 0;
56 
57  for(plane_index=0; plane_index<3; plane_index++){
58  s->plane[plane_index].diag_mc= 1;
59  s->plane[plane_index].htaps= 6;
60  s->plane[plane_index].hcoeff[0]= 40;
61  s->plane[plane_index].hcoeff[1]= -10;
62  s->plane[plane_index].hcoeff[2]= 2;
63  s->plane[plane_index].fast_mc= 1;
64  }
65 
66  if ((ret = ff_snow_common_init(avctx)) < 0) {
67  return ret;
68  }
69  ff_mpegvideoencdsp_init(&s->mpvencdsp, avctx);
70 
71  ff_snow_alloc_blocks(s);
72 
73  s->version=0;
74 
75  s->m.avctx = avctx;
76  s->m.bit_rate= avctx->bit_rate;
77  s->m.lmin = avctx->mb_lmin;
78  s->m.lmax = avctx->mb_lmax;
79  s->m.mb_num = (avctx->width * avctx->height + 255) / 256; // For ratecontrol
80 
81  s->m.me.temp =
82  s->m.me.scratchpad = av_calloc(avctx->width + 64, 2*16*2*sizeof(uint8_t));
83  s->m.me.map = av_mallocz(ME_MAP_SIZE*sizeof(uint32_t));
84  s->m.me.score_map = av_mallocz(ME_MAP_SIZE*sizeof(uint32_t));
85  s->m.sc.obmc_scratchpad= av_mallocz(MB_SIZE*MB_SIZE*12*sizeof(uint32_t));
86  if (!s->m.me.scratchpad || !s->m.me.map || !s->m.me.score_map || !s->m.sc.obmc_scratchpad)
87  return AVERROR(ENOMEM);
88 
89  ff_h263_encode_init(&s->m); //mv_penalty
90 
91  s->max_ref_frames = av_clip(avctx->refs, 1, MAX_REF_FRAMES);
92 
93  if(avctx->flags&AV_CODEC_FLAG_PASS1){
94  if(!avctx->stats_out)
95  avctx->stats_out = av_mallocz(256);
96 
97  if (!avctx->stats_out)
98  return AVERROR(ENOMEM);
99  }
100  if((avctx->flags&AV_CODEC_FLAG_PASS2) || !(avctx->flags&AV_CODEC_FLAG_QSCALE)){
101  ret = ff_rate_control_init(&s->m);
102  if(ret < 0)
103  return ret;
104  }
105  s->pass1_rc= !(avctx->flags & (AV_CODEC_FLAG_QSCALE|AV_CODEC_FLAG_PASS2));
106 
107  switch(avctx->pix_fmt){
108  case AV_PIX_FMT_YUV444P:
109 // case AV_PIX_FMT_YUV422P:
110  case AV_PIX_FMT_YUV420P:
111 // case AV_PIX_FMT_YUV411P:
112  case AV_PIX_FMT_YUV410P:
113  s->nb_planes = 3;
114  s->colorspace_type= 0;
115  break;
116  case AV_PIX_FMT_GRAY8:
117  s->nb_planes = 1;
118  s->colorspace_type = 1;
119  break;
120 /* case AV_PIX_FMT_RGB32:
121  s->colorspace= 1;
122  break;*/
123  }
124 
125  ret = av_pix_fmt_get_chroma_sub_sample(avctx->pix_fmt, &s->chroma_h_shift,
126  &s->chroma_v_shift);
127  if (ret)
128  return ret;
129 
130  ff_set_cmp(&s->mecc, s->mecc.me_cmp, s->avctx->me_cmp);
131  ff_set_cmp(&s->mecc, s->mecc.me_sub_cmp, s->avctx->me_sub_cmp);
132 
133  s->input_picture = av_frame_alloc();
134  if (!s->input_picture)
135  return AVERROR(ENOMEM);
136 
137  if ((ret = ff_snow_get_buffer(s, s->input_picture)) < 0)
138  return ret;
139 
140  if(s->motion_est == FF_ME_ITER){
141  int size= s->b_width * s->b_height << 2*s->block_max_depth;
142  for(i=0; i<s->max_ref_frames; i++){
143  s->ref_mvs[i] = av_calloc(size, sizeof(*s->ref_mvs[i]));
144  s->ref_scores[i] = av_calloc(size, sizeof(*s->ref_scores[i]));
145  if (!s->ref_mvs[i] || !s->ref_scores[i])
146  return AVERROR(ENOMEM);
147  }
148  }
149 
150  return 0;
151 }
152 
153 //near copy & paste from dsputil, FIXME
154 static int pix_sum(uint8_t * pix, int line_size, int w, int h)
155 {
156  int s, i, j;
157 
158  s = 0;
159  for (i = 0; i < h; i++) {
160  for (j = 0; j < w; j++) {
161  s += pix[0];
162  pix ++;
163  }
164  pix += line_size - w;
165  }
166  return s;
167 }
168 
169 //near copy & paste from dsputil, FIXME
170 static int pix_norm1(uint8_t * pix, int line_size, int w)
171 {
172  int s, i, j;
173  const uint32_t *sq = ff_square_tab + 256;
174 
175  s = 0;
176  for (i = 0; i < w; i++) {
177  for (j = 0; j < w; j ++) {
178  s += sq[pix[0]];
179  pix ++;
180  }
181  pix += line_size - w;
182  }
183  return s;
184 }
185 
186 static inline int get_penalty_factor(int lambda, int lambda2, int type){
187  switch(type&0xFF){
188  default:
189  case FF_CMP_SAD:
190  return lambda>>FF_LAMBDA_SHIFT;
191  case FF_CMP_DCT:
192  return (3*lambda)>>(FF_LAMBDA_SHIFT+1);
193  case FF_CMP_W53:
194  return (4*lambda)>>(FF_LAMBDA_SHIFT);
195  case FF_CMP_W97:
196  return (2*lambda)>>(FF_LAMBDA_SHIFT);
197  case FF_CMP_SATD:
198  case FF_CMP_DCT264:
199  return (2*lambda)>>FF_LAMBDA_SHIFT;
200  case FF_CMP_RD:
201  case FF_CMP_PSNR:
202  case FF_CMP_SSE:
203  case FF_CMP_NSSE:
204  return lambda2>>FF_LAMBDA_SHIFT;
205  case FF_CMP_BIT:
206  return 1;
207  }
208 }
209 
210 //FIXME copy&paste
211 #define P_LEFT P[1]
212 #define P_TOP P[2]
213 #define P_TOPRIGHT P[3]
214 #define P_MEDIAN P[4]
215 #define P_MV1 P[9]
216 #define FLAG_QPEL 1 //must be 1
217 
218 static int encode_q_branch(SnowContext *s, int level, int x, int y){
219  uint8_t p_buffer[1024];
220  uint8_t i_buffer[1024];
221  uint8_t p_state[sizeof(s->block_state)];
222  uint8_t i_state[sizeof(s->block_state)];
223  RangeCoder pc, ic;
224  uint8_t *pbbak= s->c.bytestream;
225  uint8_t *pbbak_start= s->c.bytestream_start;
226  int score, score2, iscore, i_len, p_len, block_s, sum, base_bits;
227  const int w= s->b_width << s->block_max_depth;
228  const int h= s->b_height << s->block_max_depth;
229  const int rem_depth= s->block_max_depth - level;
230  const int index= (x + y*w) << rem_depth;
231  const int block_w= 1<<(LOG2_MB_SIZE - level);
232  int trx= (x+1)<<rem_depth;
233  int try= (y+1)<<rem_depth;
234  const BlockNode *left = x ? &s->block[index-1] : &null_block;
235  const BlockNode *top = y ? &s->block[index-w] : &null_block;
236  const BlockNode *right = trx<w ? &s->block[index+1] : &null_block;
237  const BlockNode *bottom= try<h ? &s->block[index+w] : &null_block;
238  const BlockNode *tl = y && x ? &s->block[index-w-1] : left;
239  const BlockNode *tr = y && trx<w && ((x&1)==0 || level==0) ? &s->block[index-w+(1<<rem_depth)] : tl; //FIXME use lt
240  int pl = left->color[0];
241  int pcb= left->color[1];
242  int pcr= left->color[2];
243  int pmx, pmy;
244  int mx=0, my=0;
245  int l,cr,cb;
246  const int stride= s->current_picture->linesize[0];
247  const int uvstride= s->current_picture->linesize[1];
248  uint8_t *current_data[3]= { s->input_picture->data[0] + (x + y* stride)*block_w,
249  s->input_picture->data[1] + ((x*block_w)>>s->chroma_h_shift) + ((y*uvstride*block_w)>>s->chroma_v_shift),
250  s->input_picture->data[2] + ((x*block_w)>>s->chroma_h_shift) + ((y*uvstride*block_w)>>s->chroma_v_shift)};
251  int P[10][2];
252  int16_t last_mv[3][2];
253  int qpel= !!(s->avctx->flags & AV_CODEC_FLAG_QPEL); //unused
254  const int shift= 1+qpel;
255  MotionEstContext *c= &s->m.me;
256  int ref_context= av_log2(2*left->ref) + av_log2(2*top->ref);
257  int mx_context= av_log2(2*FFABS(left->mx - top->mx));
258  int my_context= av_log2(2*FFABS(left->my - top->my));
259  int s_context= 2*left->level + 2*top->level + tl->level + tr->level;
260  int ref, best_ref, ref_score, ref_mx, ref_my;
261 
262  av_assert0(sizeof(s->block_state) >= 256);
263  if(s->keyframe){
264  set_blocks(s, level, x, y, pl, pcb, pcr, 0, 0, 0, BLOCK_INTRA);
265  return 0;
266  }
267 
268 // clip predictors / edge ?
269 
270  P_LEFT[0]= left->mx;
271  P_LEFT[1]= left->my;
272  P_TOP [0]= top->mx;
273  P_TOP [1]= top->my;
274  P_TOPRIGHT[0]= tr->mx;
275  P_TOPRIGHT[1]= tr->my;
276 
277  last_mv[0][0]= s->block[index].mx;
278  last_mv[0][1]= s->block[index].my;
279  last_mv[1][0]= right->mx;
280  last_mv[1][1]= right->my;
281  last_mv[2][0]= bottom->mx;
282  last_mv[2][1]= bottom->my;
283 
284  s->m.mb_stride=2;
285  s->m.mb_x=
286  s->m.mb_y= 0;
287  c->skip= 0;
288 
289  av_assert1(c-> stride == stride);
290  av_assert1(c->uvstride == uvstride);
291 
292  c->penalty_factor = get_penalty_factor(s->lambda, s->lambda2, c->avctx->me_cmp);
293  c->sub_penalty_factor= get_penalty_factor(s->lambda, s->lambda2, c->avctx->me_sub_cmp);
294  c->mb_penalty_factor = get_penalty_factor(s->lambda, s->lambda2, c->avctx->mb_cmp);
295  c->current_mv_penalty= c->mv_penalty[s->m.f_code=1] + MAX_DMV;
296 
297  c->xmin = - x*block_w - 16+3;
298  c->ymin = - y*block_w - 16+3;
299  c->xmax = - (x+1)*block_w + (w<<(LOG2_MB_SIZE - s->block_max_depth)) + 16-3;
300  c->ymax = - (y+1)*block_w + (h<<(LOG2_MB_SIZE - s->block_max_depth)) + 16-3;
301 
302  if(P_LEFT[0] > (c->xmax<<shift)) P_LEFT[0] = (c->xmax<<shift);
303  if(P_LEFT[1] > (c->ymax<<shift)) P_LEFT[1] = (c->ymax<<shift);
304  if(P_TOP[0] > (c->xmax<<shift)) P_TOP[0] = (c->xmax<<shift);
305  if(P_TOP[1] > (c->ymax<<shift)) P_TOP[1] = (c->ymax<<shift);
306  if(P_TOPRIGHT[0] < (c->xmin * (1<<shift))) P_TOPRIGHT[0]= (c->xmin * (1<<shift));
307  if(P_TOPRIGHT[0] > (c->xmax<<shift)) P_TOPRIGHT[0]= (c->xmax<<shift); //due to pmx no clip
308  if(P_TOPRIGHT[1] > (c->ymax<<shift)) P_TOPRIGHT[1]= (c->ymax<<shift);
309 
310  P_MEDIAN[0]= mid_pred(P_LEFT[0], P_TOP[0], P_TOPRIGHT[0]);
311  P_MEDIAN[1]= mid_pred(P_LEFT[1], P_TOP[1], P_TOPRIGHT[1]);
312 
313  if (!y) {
314  c->pred_x= P_LEFT[0];
315  c->pred_y= P_LEFT[1];
316  } else {
317  c->pred_x = P_MEDIAN[0];
318  c->pred_y = P_MEDIAN[1];
319  }
320 
321  score= INT_MAX;
322  best_ref= 0;
323  for(ref=0; ref<s->ref_frames; ref++){
324  init_ref(c, current_data, s->last_picture[ref]->data, NULL, block_w*x, block_w*y, 0);
325 
326  ref_score= ff_epzs_motion_search(&s->m, &ref_mx, &ref_my, P, 0, /*ref_index*/ 0, last_mv,
327  (1<<16)>>shift, level-LOG2_MB_SIZE+4, block_w);
328 
329  av_assert2(ref_mx >= c->xmin);
330  av_assert2(ref_mx <= c->xmax);
331  av_assert2(ref_my >= c->ymin);
332  av_assert2(ref_my <= c->ymax);
333 
334  ref_score= c->sub_motion_search(&s->m, &ref_mx, &ref_my, ref_score, 0, 0, level-LOG2_MB_SIZE+4, block_w);
335  ref_score= ff_get_mb_score(&s->m, ref_mx, ref_my, 0, 0, level-LOG2_MB_SIZE+4, block_w, 0);
336  ref_score+= 2*av_log2(2*ref)*c->penalty_factor;
337  if(s->ref_mvs[ref]){
338  s->ref_mvs[ref][index][0]= ref_mx;
339  s->ref_mvs[ref][index][1]= ref_my;
340  s->ref_scores[ref][index]= ref_score;
341  }
342  if(score > ref_score){
343  score= ref_score;
344  best_ref= ref;
345  mx= ref_mx;
346  my= ref_my;
347  }
348  }
349  //FIXME if mb_cmp != SSE then intra cannot be compared currently and mb_penalty vs. lambda2
350 
351  // subpel search
352  base_bits= get_rac_count(&s->c) - 8*(s->c.bytestream - s->c.bytestream_start);
353  pc= s->c;
354  pc.bytestream_start=
355  pc.bytestream= p_buffer; //FIXME end/start? and at the other stoo
356  memcpy(p_state, s->block_state, sizeof(s->block_state));
357 
358  if(level!=s->block_max_depth)
359  put_rac(&pc, &p_state[4 + s_context], 1);
360  put_rac(&pc, &p_state[1 + left->type + top->type], 0);
361  if(s->ref_frames > 1)
362  put_symbol(&pc, &p_state[128 + 1024 + 32*ref_context], best_ref, 0);
363  pred_mv(s, &pmx, &pmy, best_ref, left, top, tr);
364  put_symbol(&pc, &p_state[128 + 32*(mx_context + 16*!!best_ref)], mx - pmx, 1);
365  put_symbol(&pc, &p_state[128 + 32*(my_context + 16*!!best_ref)], my - pmy, 1);
366  p_len= pc.bytestream - pc.bytestream_start;
367  score += (s->lambda2*(get_rac_count(&pc)-base_bits))>>FF_LAMBDA_SHIFT;
368 
369  block_s= block_w*block_w;
370  sum = pix_sum(current_data[0], stride, block_w, block_w);
371  l= (sum + block_s/2)/block_s;
372  iscore = pix_norm1(current_data[0], stride, block_w) - 2*l*sum + l*l*block_s;
373 
374  if (s->nb_planes > 2) {
375  block_s= block_w*block_w>>(s->chroma_h_shift + s->chroma_v_shift);
376  sum = pix_sum(current_data[1], uvstride, block_w>>s->chroma_h_shift, block_w>>s->chroma_v_shift);
377  cb= (sum + block_s/2)/block_s;
378  // iscore += pix_norm1(&current_mb[1][0], uvstride, block_w>>1) - 2*cb*sum + cb*cb*block_s;
379  sum = pix_sum(current_data[2], uvstride, block_w>>s->chroma_h_shift, block_w>>s->chroma_v_shift);
380  cr= (sum + block_s/2)/block_s;
381  // iscore += pix_norm1(&current_mb[2][0], uvstride, block_w>>1) - 2*cr*sum + cr*cr*block_s;
382  }else
383  cb = cr = 0;
384 
385  ic= s->c;
386  ic.bytestream_start=
387  ic.bytestream= i_buffer; //FIXME end/start? and at the other stoo
388  memcpy(i_state, s->block_state, sizeof(s->block_state));
389  if(level!=s->block_max_depth)
390  put_rac(&ic, &i_state[4 + s_context], 1);
391  put_rac(&ic, &i_state[1 + left->type + top->type], 1);
392  put_symbol(&ic, &i_state[32], l-pl , 1);
393  if (s->nb_planes > 2) {
394  put_symbol(&ic, &i_state[64], cb-pcb, 1);
395  put_symbol(&ic, &i_state[96], cr-pcr, 1);
396  }
397  i_len= ic.bytestream - ic.bytestream_start;
398  iscore += (s->lambda2*(get_rac_count(&ic)-base_bits))>>FF_LAMBDA_SHIFT;
399 
400  av_assert1(iscore < 255*255*256 + s->lambda2*10);
401  av_assert1(iscore >= 0);
402  av_assert1(l>=0 && l<=255);
403  av_assert1(pl>=0 && pl<=255);
404 
405  if(level==0){
406  int varc= iscore >> 8;
407  int vard= score >> 8;
408  if (vard <= 64 || vard < varc)
409  c->scene_change_score+= ff_sqrt(vard) - ff_sqrt(varc);
410  else
411  c->scene_change_score+= s->m.qscale;
412  }
413 
414  if(level!=s->block_max_depth){
415  put_rac(&s->c, &s->block_state[4 + s_context], 0);
416  score2 = encode_q_branch(s, level+1, 2*x+0, 2*y+0);
417  score2+= encode_q_branch(s, level+1, 2*x+1, 2*y+0);
418  score2+= encode_q_branch(s, level+1, 2*x+0, 2*y+1);
419  score2+= encode_q_branch(s, level+1, 2*x+1, 2*y+1);
420  score2+= s->lambda2>>FF_LAMBDA_SHIFT; //FIXME exact split overhead
421 
422  if(score2 < score && score2 < iscore)
423  return score2;
424  }
425 
426  if(iscore < score){
427  pred_mv(s, &pmx, &pmy, 0, left, top, tr);
428  memcpy(pbbak, i_buffer, i_len);
429  s->c= ic;
430  s->c.bytestream_start= pbbak_start;
431  s->c.bytestream= pbbak + i_len;
432  set_blocks(s, level, x, y, l, cb, cr, pmx, pmy, 0, BLOCK_INTRA);
433  memcpy(s->block_state, i_state, sizeof(s->block_state));
434  return iscore;
435  }else{
436  memcpy(pbbak, p_buffer, p_len);
437  s->c= pc;
438  s->c.bytestream_start= pbbak_start;
439  s->c.bytestream= pbbak + p_len;
440  set_blocks(s, level, x, y, pl, pcb, pcr, mx, my, best_ref, 0);
441  memcpy(s->block_state, p_state, sizeof(s->block_state));
442  return score;
443  }
444 }
445 
446 static void encode_q_branch2(SnowContext *s, int level, int x, int y){
447  const int w= s->b_width << s->block_max_depth;
448  const int rem_depth= s->block_max_depth - level;
449  const int index= (x + y*w) << rem_depth;
450  int trx= (x+1)<<rem_depth;
451  BlockNode *b= &s->block[index];
452  const BlockNode *left = x ? &s->block[index-1] : &null_block;
453  const BlockNode *top = y ? &s->block[index-w] : &null_block;
454  const BlockNode *tl = y && x ? &s->block[index-w-1] : left;
455  const BlockNode *tr = y && trx<w && ((x&1)==0 || level==0) ? &s->block[index-w+(1<<rem_depth)] : tl; //FIXME use lt
456  int pl = left->color[0];
457  int pcb= left->color[1];
458  int pcr= left->color[2];
459  int pmx, pmy;
460  int ref_context= av_log2(2*left->ref) + av_log2(2*top->ref);
461  int mx_context= av_log2(2*FFABS(left->mx - top->mx)) + 16*!!b->ref;
462  int my_context= av_log2(2*FFABS(left->my - top->my)) + 16*!!b->ref;
463  int s_context= 2*left->level + 2*top->level + tl->level + tr->level;
464 
465  if(s->keyframe){
466  set_blocks(s, level, x, y, pl, pcb, pcr, 0, 0, 0, BLOCK_INTRA);
467  return;
468  }
469 
470  if(level!=s->block_max_depth){
471  if(same_block(b,b+1) && same_block(b,b+w) && same_block(b,b+w+1)){
472  put_rac(&s->c, &s->block_state[4 + s_context], 1);
473  }else{
474  put_rac(&s->c, &s->block_state[4 + s_context], 0);
475  encode_q_branch2(s, level+1, 2*x+0, 2*y+0);
476  encode_q_branch2(s, level+1, 2*x+1, 2*y+0);
477  encode_q_branch2(s, level+1, 2*x+0, 2*y+1);
478  encode_q_branch2(s, level+1, 2*x+1, 2*y+1);
479  return;
480  }
481  }
482  if(b->type & BLOCK_INTRA){
483  pred_mv(s, &pmx, &pmy, 0, left, top, tr);
484  put_rac(&s->c, &s->block_state[1 + (left->type&1) + (top->type&1)], 1);
485  put_symbol(&s->c, &s->block_state[32], b->color[0]-pl , 1);
486  if (s->nb_planes > 2) {
487  put_symbol(&s->c, &s->block_state[64], b->color[1]-pcb, 1);
488  put_symbol(&s->c, &s->block_state[96], b->color[2]-pcr, 1);
489  }
490  set_blocks(s, level, x, y, b->color[0], b->color[1], b->color[2], pmx, pmy, 0, BLOCK_INTRA);
491  }else{
492  pred_mv(s, &pmx, &pmy, b->ref, left, top, tr);
493  put_rac(&s->c, &s->block_state[1 + (left->type&1) + (top->type&1)], 0);
494  if(s->ref_frames > 1)
495  put_symbol(&s->c, &s->block_state[128 + 1024 + 32*ref_context], b->ref, 0);
496  put_symbol(&s->c, &s->block_state[128 + 32*mx_context], b->mx - pmx, 1);
497  put_symbol(&s->c, &s->block_state[128 + 32*my_context], b->my - pmy, 1);
498  set_blocks(s, level, x, y, pl, pcb, pcr, b->mx, b->my, b->ref, 0);
499  }
500 }
501 
502 static int get_dc(SnowContext *s, int mb_x, int mb_y, int plane_index){
503  int i, x2, y2;
504  Plane *p= &s->plane[plane_index];
505  const int block_size = MB_SIZE >> s->block_max_depth;
506  const int block_w = plane_index ? block_size>>s->chroma_h_shift : block_size;
507  const int block_h = plane_index ? block_size>>s->chroma_v_shift : block_size;
508  const uint8_t *obmc = plane_index ? ff_obmc_tab[s->block_max_depth+s->chroma_h_shift] : ff_obmc_tab[s->block_max_depth];
509  const int obmc_stride= plane_index ? (2*block_size)>>s->chroma_h_shift : 2*block_size;
510  const int ref_stride= s->current_picture->linesize[plane_index];
511  uint8_t *src= s-> input_picture->data[plane_index];
512  IDWTELEM *dst= (IDWTELEM*)s->m.sc.obmc_scratchpad + plane_index*block_size*block_size*4; //FIXME change to unsigned
513  const int b_stride = s->b_width << s->block_max_depth;
514  const int w= p->width;
515  const int h= p->height;
516  int index= mb_x + mb_y*b_stride;
517  BlockNode *b= &s->block[index];
518  BlockNode backup= *b;
519  int ab=0;
520  int aa=0;
521 
522  av_assert2(s->chroma_h_shift == s->chroma_v_shift); //obmc stuff above
523 
524  b->type|= BLOCK_INTRA;
525  b->color[plane_index]= 0;
526  memset(dst, 0, obmc_stride*obmc_stride*sizeof(IDWTELEM));
527 
528  for(i=0; i<4; i++){
529  int mb_x2= mb_x + (i &1) - 1;
530  int mb_y2= mb_y + (i>>1) - 1;
531  int x= block_w*mb_x2 + block_w/2;
532  int y= block_h*mb_y2 + block_h/2;
533 
534  add_yblock(s, 0, NULL, dst + (i&1)*block_w + (i>>1)*obmc_stride*block_h, NULL, obmc,
535  x, y, block_w, block_h, w, h, obmc_stride, ref_stride, obmc_stride, mb_x2, mb_y2, 0, 0, plane_index);
536 
537  for(y2= FFMAX(y, 0); y2<FFMIN(h, y+block_h); y2++){
538  for(x2= FFMAX(x, 0); x2<FFMIN(w, x+block_w); x2++){
539  int index= x2-(block_w*mb_x - block_w/2) + (y2-(block_h*mb_y - block_h/2))*obmc_stride;
540  int obmc_v= obmc[index];
541  int d;
542  if(y<0) obmc_v += obmc[index + block_h*obmc_stride];
543  if(x<0) obmc_v += obmc[index + block_w];
544  if(y+block_h>h) obmc_v += obmc[index - block_h*obmc_stride];
545  if(x+block_w>w) obmc_v += obmc[index - block_w];
546  //FIXME precalculate this or simplify it somehow else
547 
548  d = -dst[index] + (1<<(FRAC_BITS-1));
549  dst[index] = d;
550  ab += (src[x2 + y2*ref_stride] - (d>>FRAC_BITS)) * obmc_v;
551  aa += obmc_v * obmc_v; //FIXME precalculate this
552  }
553  }
554  }
555  *b= backup;
556 
557  return av_clip_uint8( ROUNDED_DIV(ab<<LOG2_OBMC_MAX, aa) ); //FIXME we should not need clipping
558 }
559 
560 static inline int get_block_bits(SnowContext *s, int x, int y, int w){
561  const int b_stride = s->b_width << s->block_max_depth;
562  const int b_height = s->b_height<< s->block_max_depth;
563  int index= x + y*b_stride;
564  const BlockNode *b = &s->block[index];
565  const BlockNode *left = x ? &s->block[index-1] : &null_block;
566  const BlockNode *top = y ? &s->block[index-b_stride] : &null_block;
567  const BlockNode *tl = y && x ? &s->block[index-b_stride-1] : left;
568  const BlockNode *tr = y && x+w<b_stride ? &s->block[index-b_stride+w] : tl;
569  int dmx, dmy;
570 // int mx_context= av_log2(2*FFABS(left->mx - top->mx));
571 // int my_context= av_log2(2*FFABS(left->my - top->my));
572 
573  if(x<0 || x>=b_stride || y>=b_height)
574  return 0;
575 /*
576 1 0 0
577 01X 1-2 1
578 001XX 3-6 2-3
579 0001XXX 7-14 4-7
580 00001XXXX 15-30 8-15
581 */
582 //FIXME try accurate rate
583 //FIXME intra and inter predictors if surrounding blocks are not the same type
584  if(b->type & BLOCK_INTRA){
585  return 3+2*( av_log2(2*FFABS(left->color[0] - b->color[0]))
586  + av_log2(2*FFABS(left->color[1] - b->color[1]))
587  + av_log2(2*FFABS(left->color[2] - b->color[2])));
588  }else{
589  pred_mv(s, &dmx, &dmy, b->ref, left, top, tr);
590  dmx-= b->mx;
591  dmy-= b->my;
592  return 2*(1 + av_log2(2*FFABS(dmx)) //FIXME kill the 2* can be merged in lambda
593  + av_log2(2*FFABS(dmy))
594  + av_log2(2*b->ref));
595  }
596 }
597 
598 static int get_block_rd(SnowContext *s, int mb_x, int mb_y, int plane_index, uint8_t (*obmc_edged)[MB_SIZE * 2]){
599  Plane *p= &s->plane[plane_index];
600  const int block_size = MB_SIZE >> s->block_max_depth;
601  const int block_w = plane_index ? block_size>>s->chroma_h_shift : block_size;
602  const int block_h = plane_index ? block_size>>s->chroma_v_shift : block_size;
603  const int obmc_stride= plane_index ? (2*block_size)>>s->chroma_h_shift : 2*block_size;
604  const int ref_stride= s->current_picture->linesize[plane_index];
605  uint8_t *dst= s->current_picture->data[plane_index];
606  uint8_t *src= s-> input_picture->data[plane_index];
607  IDWTELEM *pred= (IDWTELEM*)s->m.sc.obmc_scratchpad + plane_index*block_size*block_size*4;
608  uint8_t *cur = s->scratchbuf;
609  uint8_t *tmp = s->emu_edge_buffer;
610  const int b_stride = s->b_width << s->block_max_depth;
611  const int b_height = s->b_height<< s->block_max_depth;
612  const int w= p->width;
613  const int h= p->height;
614  int distortion;
615  int rate= 0;
616  const int penalty_factor= get_penalty_factor(s->lambda, s->lambda2, s->avctx->me_cmp);
617  int sx= block_w*mb_x - block_w/2;
618  int sy= block_h*mb_y - block_h/2;
619  int x0= FFMAX(0,-sx);
620  int y0= FFMAX(0,-sy);
621  int x1= FFMIN(block_w*2, w-sx);
622  int y1= FFMIN(block_h*2, h-sy);
623  int i,x,y;
624 
625  av_assert2(s->chroma_h_shift == s->chroma_v_shift); //obmc and square assumtions below chckinhg only block_w
626 
627  ff_snow_pred_block(s, cur, tmp, ref_stride, sx, sy, block_w*2, block_h*2, &s->block[mb_x + mb_y*b_stride], plane_index, w, h);
628 
629  for(y=y0; y<y1; y++){
630  const uint8_t *obmc1= obmc_edged[y];
631  const IDWTELEM *pred1 = pred + y*obmc_stride;
632  uint8_t *cur1 = cur + y*ref_stride;
633  uint8_t *dst1 = dst + sx + (sy+y)*ref_stride;
634  for(x=x0; x<x1; x++){
635 #if FRAC_BITS >= LOG2_OBMC_MAX
636  int v = (cur1[x] * obmc1[x]) << (FRAC_BITS - LOG2_OBMC_MAX);
637 #else
638  int v = (cur1[x] * obmc1[x] + (1<<(LOG2_OBMC_MAX - FRAC_BITS-1))) >> (LOG2_OBMC_MAX - FRAC_BITS);
639 #endif
640  v = (v + pred1[x]) >> FRAC_BITS;
641  if(v&(~255)) v= ~(v>>31);
642  dst1[x] = v;
643  }
644  }
645 
646  /* copy the regions where obmc[] = (uint8_t)256 */
647  if(LOG2_OBMC_MAX == 8
648  && (mb_x == 0 || mb_x == b_stride-1)
649  && (mb_y == 0 || mb_y == b_height-1)){
650  if(mb_x == 0)
651  x1 = block_w;
652  else
653  x0 = block_w;
654  if(mb_y == 0)
655  y1 = block_h;
656  else
657  y0 = block_h;
658  for(y=y0; y<y1; y++)
659  memcpy(dst + sx+x0 + (sy+y)*ref_stride, cur + x0 + y*ref_stride, x1-x0);
660  }
661 
662  if(block_w==16){
663  /* FIXME rearrange dsputil to fit 32x32 cmp functions */
664  /* FIXME check alignment of the cmp wavelet vs the encoding wavelet */
665  /* FIXME cmps overlap but do not cover the wavelet's whole support.
666  * So improving the score of one block is not strictly guaranteed
667  * to improve the score of the whole frame, thus iterative motion
668  * estimation does not always converge. */
669  if(s->avctx->me_cmp == FF_CMP_W97)
670  distortion = ff_w97_32_c(&s->m, src + sx + sy*ref_stride, dst + sx + sy*ref_stride, ref_stride, 32);
671  else if(s->avctx->me_cmp == FF_CMP_W53)
672  distortion = ff_w53_32_c(&s->m, src + sx + sy*ref_stride, dst + sx + sy*ref_stride, ref_stride, 32);
673  else{
674  distortion = 0;
675  for(i=0; i<4; i++){
676  int off = sx+16*(i&1) + (sy+16*(i>>1))*ref_stride;
677  distortion += s->mecc.me_cmp[0](&s->m, src + off, dst + off, ref_stride, 16);
678  }
679  }
680  }else{
681  av_assert2(block_w==8);
682  distortion = s->mecc.me_cmp[0](&s->m, src + sx + sy*ref_stride, dst + sx + sy*ref_stride, ref_stride, block_w*2);
683  }
684 
685  if(plane_index==0){
686  for(i=0; i<4; i++){
687 /* ..RRr
688  * .RXx.
689  * rxx..
690  */
691  rate += get_block_bits(s, mb_x + (i&1) - (i>>1), mb_y + (i>>1), 1);
692  }
693  if(mb_x == b_stride-2)
694  rate += get_block_bits(s, mb_x + 1, mb_y + 1, 1);
695  }
696  return distortion + rate*penalty_factor;
697 }
698 
699 static int get_4block_rd(SnowContext *s, int mb_x, int mb_y, int plane_index){
700  int i, y2;
701  Plane *p= &s->plane[plane_index];
702  const int block_size = MB_SIZE >> s->block_max_depth;
703  const int block_w = plane_index ? block_size>>s->chroma_h_shift : block_size;
704  const int block_h = plane_index ? block_size>>s->chroma_v_shift : block_size;
705  const uint8_t *obmc = plane_index ? ff_obmc_tab[s->block_max_depth+s->chroma_h_shift] : ff_obmc_tab[s->block_max_depth];
706  const int obmc_stride= plane_index ? (2*block_size)>>s->chroma_h_shift : 2*block_size;
707  const int ref_stride= s->current_picture->linesize[plane_index];
708  uint8_t *dst= s->current_picture->data[plane_index];
709  uint8_t *src= s-> input_picture->data[plane_index];
710  //FIXME zero_dst is const but add_yblock changes dst if add is 0 (this is never the case for dst=zero_dst
711  // const has only been removed from zero_dst to suppress a warning
712  static IDWTELEM zero_dst[4096]; //FIXME
713  const int b_stride = s->b_width << s->block_max_depth;
714  const int w= p->width;
715  const int h= p->height;
716  int distortion= 0;
717  int rate= 0;
718  const int penalty_factor= get_penalty_factor(s->lambda, s->lambda2, s->avctx->me_cmp);
719 
720  av_assert2(s->chroma_h_shift == s->chroma_v_shift); //obmc and square assumtions below
721 
722  for(i=0; i<9; i++){
723  int mb_x2= mb_x + (i%3) - 1;
724  int mb_y2= mb_y + (i/3) - 1;
725  int x= block_w*mb_x2 + block_w/2;
726  int y= block_h*mb_y2 + block_h/2;
727 
728  add_yblock(s, 0, NULL, zero_dst, dst, obmc,
729  x, y, block_w, block_h, w, h, /*dst_stride*/0, ref_stride, obmc_stride, mb_x2, mb_y2, 1, 1, plane_index);
730 
731  //FIXME find a cleaner/simpler way to skip the outside stuff
732  for(y2= y; y2<0; y2++)
733  memcpy(dst + x + y2*ref_stride, src + x + y2*ref_stride, block_w);
734  for(y2= h; y2<y+block_h; y2++)
735  memcpy(dst + x + y2*ref_stride, src + x + y2*ref_stride, block_w);
736  if(x<0){
737  for(y2= y; y2<y+block_h; y2++)
738  memcpy(dst + x + y2*ref_stride, src + x + y2*ref_stride, -x);
739  }
740  if(x+block_w > w){
741  for(y2= y; y2<y+block_h; y2++)
742  memcpy(dst + w + y2*ref_stride, src + w + y2*ref_stride, x+block_w - w);
743  }
744 
745  av_assert1(block_w== 8 || block_w==16);
746  distortion += s->mecc.me_cmp[block_w==8](&s->m, src + x + y*ref_stride, dst + x + y*ref_stride, ref_stride, block_h);
747  }
748 
749  if(plane_index==0){
750  BlockNode *b= &s->block[mb_x+mb_y*b_stride];
751  int merged= same_block(b,b+1) && same_block(b,b+b_stride) && same_block(b,b+b_stride+1);
752 
753 /* ..RRRr
754  * .RXXx.
755  * .RXXx.
756  * rxxx.
757  */
758  if(merged)
759  rate = get_block_bits(s, mb_x, mb_y, 2);
760  for(i=merged?4:0; i<9; i++){
761  static const int dxy[9][2] = {{0,0},{1,0},{0,1},{1,1},{2,0},{2,1},{-1,2},{0,2},{1,2}};
762  rate += get_block_bits(s, mb_x + dxy[i][0], mb_y + dxy[i][1], 1);
763  }
764  }
765  return distortion + rate*penalty_factor;
766 }
767 
768 static int encode_subband_c0run(SnowContext *s, SubBand *b, const IDWTELEM *src, const IDWTELEM *parent, int stride, int orientation){
769  const int w= b->width;
770  const int h= b->height;
771  int x, y;
772 
773  if(1){
774  int run=0;
775  int *runs = s->run_buffer;
776  int run_index=0;
777  int max_index;
778 
779  for(y=0; y<h; y++){
780  for(x=0; x<w; x++){
781  int v, p=0;
782  int /*ll=0, */l=0, lt=0, t=0, rt=0;
783  v= src[x + y*stride];
784 
785  if(y){
786  t= src[x + (y-1)*stride];
787  if(x){
788  lt= src[x - 1 + (y-1)*stride];
789  }
790  if(x + 1 < w){
791  rt= src[x + 1 + (y-1)*stride];
792  }
793  }
794  if(x){
795  l= src[x - 1 + y*stride];
796  /*if(x > 1){
797  if(orientation==1) ll= src[y + (x-2)*stride];
798  else ll= src[x - 2 + y*stride];
799  }*/
800  }
801  if(parent){
802  int px= x>>1;
803  int py= y>>1;
804  if(px<b->parent->width && py<b->parent->height)
805  p= parent[px + py*2*stride];
806  }
807  if(!(/*ll|*/l|lt|t|rt|p)){
808  if(v){
809  runs[run_index++]= run;
810  run=0;
811  }else{
812  run++;
813  }
814  }
815  }
816  }
817  max_index= run_index;
818  runs[run_index++]= run;
819  run_index=0;
820  run= runs[run_index++];
821 
822  put_symbol2(&s->c, b->state[30], max_index, 0);
823  if(run_index <= max_index)
824  put_symbol2(&s->c, b->state[1], run, 3);
825 
826  for(y=0; y<h; y++){
827  if(s->c.bytestream_end - s->c.bytestream < w*40){
828  av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
829  return AVERROR(ENOMEM);
830  }
831  for(x=0; x<w; x++){
832  int v, p=0;
833  int /*ll=0, */l=0, lt=0, t=0, rt=0;
834  v= src[x + y*stride];
835 
836  if(y){
837  t= src[x + (y-1)*stride];
838  if(x){
839  lt= src[x - 1 + (y-1)*stride];
840  }
841  if(x + 1 < w){
842  rt= src[x + 1 + (y-1)*stride];
843  }
844  }
845  if(x){
846  l= src[x - 1 + y*stride];
847  /*if(x > 1){
848  if(orientation==1) ll= src[y + (x-2)*stride];
849  else ll= src[x - 2 + y*stride];
850  }*/
851  }
852  if(parent){
853  int px= x>>1;
854  int py= y>>1;
855  if(px<b->parent->width && py<b->parent->height)
856  p= parent[px + py*2*stride];
857  }
858  if(/*ll|*/l|lt|t|rt|p){
859  int context= av_log2(/*FFABS(ll) + */3*FFABS(l) + FFABS(lt) + 2*FFABS(t) + FFABS(rt) + FFABS(p));
860 
861  put_rac(&s->c, &b->state[0][context], !!v);
862  }else{
863  if(!run){
864  run= runs[run_index++];
865 
866  if(run_index <= max_index)
867  put_symbol2(&s->c, b->state[1], run, 3);
868  av_assert2(v);
869  }else{
870  run--;
871  av_assert2(!v);
872  }
873  }
874  if(v){
875  int context= av_log2(/*FFABS(ll) + */3*FFABS(l) + FFABS(lt) + 2*FFABS(t) + FFABS(rt) + FFABS(p));
876  int l2= 2*FFABS(l) + (l<0);
877  int t2= 2*FFABS(t) + (t<0);
878 
879  put_symbol2(&s->c, b->state[context + 2], FFABS(v)-1, context-4);
880  put_rac(&s->c, &b->state[0][16 + 1 + 3 + ff_quant3bA[l2&0xFF] + 3*ff_quant3bA[t2&0xFF]], v<0);
881  }
882  }
883  }
884  }
885  return 0;
886 }
887 
888 static int encode_subband(SnowContext *s, SubBand *b, const IDWTELEM *src, const IDWTELEM *parent, int stride, int orientation){
889 // encode_subband_qtree(s, b, src, parent, stride, orientation);
890 // encode_subband_z0run(s, b, src, parent, stride, orientation);
891  return encode_subband_c0run(s, b, src, parent, stride, orientation);
892 // encode_subband_dzr(s, b, src, parent, stride, orientation);
893 }
894 
895 static av_always_inline int check_block(SnowContext *s, int mb_x, int mb_y, int p[3], int intra, uint8_t (*obmc_edged)[MB_SIZE * 2], int *best_rd){
896  const int b_stride= s->b_width << s->block_max_depth;
897  BlockNode *block= &s->block[mb_x + mb_y * b_stride];
898  BlockNode backup= *block;
899  unsigned value;
900  int rd, index;
901 
902  av_assert2(mb_x>=0 && mb_y>=0);
903  av_assert2(mb_x<b_stride);
904 
905  if(intra){
906  block->color[0] = p[0];
907  block->color[1] = p[1];
908  block->color[2] = p[2];
909  block->type |= BLOCK_INTRA;
910  }else{
911  index= (p[0] + 31*p[1]) & (ME_CACHE_SIZE-1);
912  value= s->me_cache_generation + (p[0]>>10) + (p[1]<<6) + (block->ref<<12);
913  if(s->me_cache[index] == value)
914  return 0;
915  s->me_cache[index]= value;
916 
917  block->mx= p[0];
918  block->my= p[1];
919  block->type &= ~BLOCK_INTRA;
920  }
921 
922  rd= get_block_rd(s, mb_x, mb_y, 0, obmc_edged) + s->intra_penalty * !!intra;
923 
924 //FIXME chroma
925  if(rd < *best_rd){
926  *best_rd= rd;
927  return 1;
928  }else{
929  *block= backup;
930  return 0;
931  }
932 }
933 
934 /* special case for int[2] args we discard afterwards,
935  * fixes compilation problem with gcc 2.95 */
936 static av_always_inline int check_block_inter(SnowContext *s, int mb_x, int mb_y, int p0, int p1, uint8_t (*obmc_edged)[MB_SIZE * 2], int *best_rd){
937  int p[2] = {p0, p1};
938  return check_block(s, mb_x, mb_y, p, 0, obmc_edged, best_rd);
939 }
940 
941 static av_always_inline int check_4block_inter(SnowContext *s, int mb_x, int mb_y, int p0, int p1, int ref, int *best_rd){
942  const int b_stride= s->b_width << s->block_max_depth;
943  BlockNode *block= &s->block[mb_x + mb_y * b_stride];
944  BlockNode backup[4];
945  unsigned value;
946  int rd, index;
947 
948  /* We don't initialize backup[] during variable declaration, because
949  * that fails to compile on MSVC: "cannot convert from 'BlockNode' to
950  * 'int16_t'". */
951  backup[0] = block[0];
952  backup[1] = block[1];
953  backup[2] = block[b_stride];
954  backup[3] = block[b_stride + 1];
955 
956  av_assert2(mb_x>=0 && mb_y>=0);
957  av_assert2(mb_x<b_stride);
958  av_assert2(((mb_x|mb_y)&1) == 0);
959 
960  index= (p0 + 31*p1) & (ME_CACHE_SIZE-1);
961  value= s->me_cache_generation + (p0>>10) + (p1<<6) + (block->ref<<12);
962  if(s->me_cache[index] == value)
963  return 0;
964  s->me_cache[index]= value;
965 
966  block->mx= p0;
967  block->my= p1;
968  block->ref= ref;
969  block->type &= ~BLOCK_INTRA;
970  block[1]= block[b_stride]= block[b_stride+1]= *block;
971 
972  rd= get_4block_rd(s, mb_x, mb_y, 0);
973 
974 //FIXME chroma
975  if(rd < *best_rd){
976  *best_rd= rd;
977  return 1;
978  }else{
979  block[0]= backup[0];
980  block[1]= backup[1];
981  block[b_stride]= backup[2];
982  block[b_stride+1]= backup[3];
983  return 0;
984  }
985 }
986 
987 static void iterative_me(SnowContext *s){
988  int pass, mb_x, mb_y;
989  const int b_width = s->b_width << s->block_max_depth;
990  const int b_height= s->b_height << s->block_max_depth;
991  const int b_stride= b_width;
992  int color[3];
993 
994  {
995  RangeCoder r = s->c;
996  uint8_t state[sizeof(s->block_state)];
997  memcpy(state, s->block_state, sizeof(s->block_state));
998  for(mb_y= 0; mb_y<s->b_height; mb_y++)
999  for(mb_x= 0; mb_x<s->b_width; mb_x++)
1000  encode_q_branch(s, 0, mb_x, mb_y);
1001  s->c = r;
1002  memcpy(s->block_state, state, sizeof(s->block_state));
1003  }
1004 
1005  for(pass=0; pass<25; pass++){
1006  int change= 0;
1007 
1008  for(mb_y= 0; mb_y<b_height; mb_y++){
1009  for(mb_x= 0; mb_x<b_width; mb_x++){
1010  int dia_change, i, j, ref;
1011  int best_rd= INT_MAX, ref_rd;
1012  BlockNode backup, ref_b;
1013  const int index= mb_x + mb_y * b_stride;
1014  BlockNode *block= &s->block[index];
1015  BlockNode *tb = mb_y ? &s->block[index-b_stride ] : NULL;
1016  BlockNode *lb = mb_x ? &s->block[index -1] : NULL;
1017  BlockNode *rb = mb_x+1<b_width ? &s->block[index +1] : NULL;
1018  BlockNode *bb = mb_y+1<b_height ? &s->block[index+b_stride ] : NULL;
1019  BlockNode *tlb= mb_x && mb_y ? &s->block[index-b_stride-1] : NULL;
1020  BlockNode *trb= mb_x+1<b_width && mb_y ? &s->block[index-b_stride+1] : NULL;
1021  BlockNode *blb= mb_x && mb_y+1<b_height ? &s->block[index+b_stride-1] : NULL;
1022  BlockNode *brb= mb_x+1<b_width && mb_y+1<b_height ? &s->block[index+b_stride+1] : NULL;
1023  const int b_w= (MB_SIZE >> s->block_max_depth);
1024  uint8_t obmc_edged[MB_SIZE * 2][MB_SIZE * 2];
1025 
1026  if(pass && (block->type & BLOCK_OPT))
1027  continue;
1028  block->type |= BLOCK_OPT;
1029 
1030  backup= *block;
1031 
1032  if(!s->me_cache_generation)
1033  memset(s->me_cache, 0, sizeof(s->me_cache));
1034  s->me_cache_generation += 1<<22;
1035 
1036  //FIXME precalculate
1037  {
1038  int x, y;
1039  for (y = 0; y < b_w * 2; y++)
1040  memcpy(obmc_edged[y], ff_obmc_tab[s->block_max_depth] + y * b_w * 2, b_w * 2);
1041  if(mb_x==0)
1042  for(y=0; y<b_w*2; y++)
1043  memset(obmc_edged[y], obmc_edged[y][0] + obmc_edged[y][b_w-1], b_w);
1044  if(mb_x==b_stride-1)
1045  for(y=0; y<b_w*2; y++)
1046  memset(obmc_edged[y]+b_w, obmc_edged[y][b_w] + obmc_edged[y][b_w*2-1], b_w);
1047  if(mb_y==0){
1048  for(x=0; x<b_w*2; x++)
1049  obmc_edged[0][x] += obmc_edged[b_w-1][x];
1050  for(y=1; y<b_w; y++)
1051  memcpy(obmc_edged[y], obmc_edged[0], b_w*2);
1052  }
1053  if(mb_y==b_height-1){
1054  for(x=0; x<b_w*2; x++)
1055  obmc_edged[b_w*2-1][x] += obmc_edged[b_w][x];
1056  for(y=b_w; y<b_w*2-1; y++)
1057  memcpy(obmc_edged[y], obmc_edged[b_w*2-1], b_w*2);
1058  }
1059  }
1060 
1061  //skip stuff outside the picture
1062  if(mb_x==0 || mb_y==0 || mb_x==b_width-1 || mb_y==b_height-1){
1063  uint8_t *src= s-> input_picture->data[0];
1064  uint8_t *dst= s->current_picture->data[0];
1065  const int stride= s->current_picture->linesize[0];
1066  const int block_w= MB_SIZE >> s->block_max_depth;
1067  const int block_h= MB_SIZE >> s->block_max_depth;
1068  const int sx= block_w*mb_x - block_w/2;
1069  const int sy= block_h*mb_y - block_h/2;
1070  const int w= s->plane[0].width;
1071  const int h= s->plane[0].height;
1072  int y;
1073 
1074  for(y=sy; y<0; y++)
1075  memcpy(dst + sx + y*stride, src + sx + y*stride, block_w*2);
1076  for(y=h; y<sy+block_h*2; y++)
1077  memcpy(dst + sx + y*stride, src + sx + y*stride, block_w*2);
1078  if(sx<0){
1079  for(y=sy; y<sy+block_h*2; y++)
1080  memcpy(dst + sx + y*stride, src + sx + y*stride, -sx);
1081  }
1082  if(sx+block_w*2 > w){
1083  for(y=sy; y<sy+block_h*2; y++)
1084  memcpy(dst + w + y*stride, src + w + y*stride, sx+block_w*2 - w);
1085  }
1086  }
1087 
1088  // intra(black) = neighbors' contribution to the current block
1089  for(i=0; i < s->nb_planes; i++)
1090  color[i]= get_dc(s, mb_x, mb_y, i);
1091 
1092  // get previous score (cannot be cached due to OBMC)
1093  if(pass > 0 && (block->type&BLOCK_INTRA)){
1094  int color0[3]= {block->color[0], block->color[1], block->color[2]};
1095  check_block(s, mb_x, mb_y, color0, 1, obmc_edged, &best_rd);
1096  }else
1097  check_block_inter(s, mb_x, mb_y, block->mx, block->my, obmc_edged, &best_rd);
1098 
1099  ref_b= *block;
1100  ref_rd= best_rd;
1101  for(ref=0; ref < s->ref_frames; ref++){
1102  int16_t (*mvr)[2]= &s->ref_mvs[ref][index];
1103  if(s->ref_scores[ref][index] > s->ref_scores[ref_b.ref][index]*3/2) //FIXME tune threshold
1104  continue;
1105  block->ref= ref;
1106  best_rd= INT_MAX;
1107 
1108  check_block_inter(s, mb_x, mb_y, mvr[0][0], mvr[0][1], obmc_edged, &best_rd);
1109  check_block_inter(s, mb_x, mb_y, 0, 0, obmc_edged, &best_rd);
1110  if(tb)
1111  check_block_inter(s, mb_x, mb_y, mvr[-b_stride][0], mvr[-b_stride][1], obmc_edged, &best_rd);
1112  if(lb)
1113  check_block_inter(s, mb_x, mb_y, mvr[-1][0], mvr[-1][1], obmc_edged, &best_rd);
1114  if(rb)
1115  check_block_inter(s, mb_x, mb_y, mvr[1][0], mvr[1][1], obmc_edged, &best_rd);
1116  if(bb)
1117  check_block_inter(s, mb_x, mb_y, mvr[b_stride][0], mvr[b_stride][1], obmc_edged, &best_rd);
1118 
1119  /* fullpel ME */
1120  //FIXME avoid subpel interpolation / round to nearest integer
1121  do{
1122  int newx = block->mx;
1123  int newy = block->my;
1124  int dia_size = s->iterative_dia_size ? s->iterative_dia_size : FFMAX(s->avctx->dia_size, 1);
1125  dia_change=0;
1126  for(i=0; i < dia_size; i++){
1127  for(j=0; j<i; j++){
1128  dia_change |= check_block_inter(s, mb_x, mb_y, newx+4*(i-j), newy+(4*j), obmc_edged, &best_rd);
1129  dia_change |= check_block_inter(s, mb_x, mb_y, newx-4*(i-j), newy-(4*j), obmc_edged, &best_rd);
1130  dia_change |= check_block_inter(s, mb_x, mb_y, newx-(4*j), newy+4*(i-j), obmc_edged, &best_rd);
1131  dia_change |= check_block_inter(s, mb_x, mb_y, newx+(4*j), newy-4*(i-j), obmc_edged, &best_rd);
1132  }
1133  }
1134  }while(dia_change);
1135  /* subpel ME */
1136  do{
1137  static const int square[8][2]= {{+1, 0},{-1, 0},{ 0,+1},{ 0,-1},{+1,+1},{-1,-1},{+1,-1},{-1,+1},};
1138  dia_change=0;
1139  for(i=0; i<8; i++)
1140  dia_change |= check_block_inter(s, mb_x, mb_y, block->mx+square[i][0], block->my+square[i][1], obmc_edged, &best_rd);
1141  }while(dia_change);
1142  //FIXME or try the standard 2 pass qpel or similar
1143 
1144  mvr[0][0]= block->mx;
1145  mvr[0][1]= block->my;
1146  if(ref_rd > best_rd){
1147  ref_rd= best_rd;
1148  ref_b= *block;
1149  }
1150  }
1151  best_rd= ref_rd;
1152  *block= ref_b;
1153  check_block(s, mb_x, mb_y, color, 1, obmc_edged, &best_rd);
1154  //FIXME RD style color selection
1155  if(!same_block(block, &backup)){
1156  if(tb ) tb ->type &= ~BLOCK_OPT;
1157  if(lb ) lb ->type &= ~BLOCK_OPT;
1158  if(rb ) rb ->type &= ~BLOCK_OPT;
1159  if(bb ) bb ->type &= ~BLOCK_OPT;
1160  if(tlb) tlb->type &= ~BLOCK_OPT;
1161  if(trb) trb->type &= ~BLOCK_OPT;
1162  if(blb) blb->type &= ~BLOCK_OPT;
1163  if(brb) brb->type &= ~BLOCK_OPT;
1164  change ++;
1165  }
1166  }
1167  }
1168  av_log(s->avctx, AV_LOG_DEBUG, "pass:%d changed:%d\n", pass, change);
1169  if(!change)
1170  break;
1171  }
1172 
1173  if(s->block_max_depth == 1){
1174  int change= 0;
1175  for(mb_y= 0; mb_y<b_height; mb_y+=2){
1176  for(mb_x= 0; mb_x<b_width; mb_x+=2){
1177  int i;
1178  int best_rd, init_rd;
1179  const int index= mb_x + mb_y * b_stride;
1180  BlockNode *b[4];
1181 
1182  b[0]= &s->block[index];
1183  b[1]= b[0]+1;
1184  b[2]= b[0]+b_stride;
1185  b[3]= b[2]+1;
1186  if(same_block(b[0], b[1]) &&
1187  same_block(b[0], b[2]) &&
1188  same_block(b[0], b[3]))
1189  continue;
1190 
1191  if(!s->me_cache_generation)
1192  memset(s->me_cache, 0, sizeof(s->me_cache));
1193  s->me_cache_generation += 1<<22;
1194 
1195  init_rd= best_rd= get_4block_rd(s, mb_x, mb_y, 0);
1196 
1197  //FIXME more multiref search?
1198  check_4block_inter(s, mb_x, mb_y,
1199  (b[0]->mx + b[1]->mx + b[2]->mx + b[3]->mx + 2) >> 2,
1200  (b[0]->my + b[1]->my + b[2]->my + b[3]->my + 2) >> 2, 0, &best_rd);
1201 
1202  for(i=0; i<4; i++)
1203  if(!(b[i]->type&BLOCK_INTRA))
1204  check_4block_inter(s, mb_x, mb_y, b[i]->mx, b[i]->my, b[i]->ref, &best_rd);
1205 
1206  if(init_rd != best_rd)
1207  change++;
1208  }
1209  }
1210  av_log(s->avctx, AV_LOG_ERROR, "pass:4mv changed:%d\n", change*4);
1211  }
1212 }
1213 
1214 static void encode_blocks(SnowContext *s, int search){
1215  int x, y;
1216  int w= s->b_width;
1217  int h= s->b_height;
1218 
1219  if(s->motion_est == FF_ME_ITER && !s->keyframe && search)
1220  iterative_me(s);
1221 
1222  for(y=0; y<h; y++){
1223  if(s->c.bytestream_end - s->c.bytestream < w*MB_SIZE*MB_SIZE*3){ //FIXME nicer limit
1224  av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
1225  return;
1226  }
1227  for(x=0; x<w; x++){
1228  if(s->motion_est == FF_ME_ITER || !search)
1229  encode_q_branch2(s, 0, x, y);
1230  else
1231  encode_q_branch (s, 0, x, y);
1232  }
1233  }
1234 }
1235 
1236 static void quantize(SnowContext *s, SubBand *b, IDWTELEM *dst, DWTELEM *src, int stride, int bias){
1237  const int w= b->width;
1238  const int h= b->height;
1239  const int qlog= av_clip(s->qlog + b->qlog, 0, QROOT*16);
1240  const int qmul= ff_qexp[qlog&(QROOT-1)]<<((qlog>>QSHIFT) + ENCODER_EXTRA_BITS);
1241  int x,y, thres1, thres2;
1242 
1243  if(s->qlog == LOSSLESS_QLOG){
1244  for(y=0; y<h; y++)
1245  for(x=0; x<w; x++)
1246  dst[x + y*stride]= src[x + y*stride];
1247  return;
1248  }
1249 
1250  bias= bias ? 0 : (3*qmul)>>3;
1251  thres1= ((qmul - bias)>>QEXPSHIFT) - 1;
1252  thres2= 2*thres1;
1253 
1254  if(!bias){
1255  for(y=0; y<h; y++){
1256  for(x=0; x<w; x++){
1257  int i= src[x + y*stride];
1258 
1259  if((unsigned)(i+thres1) > thres2){
1260  if(i>=0){
1261  i<<= QEXPSHIFT;
1262  i/= qmul; //FIXME optimize
1263  dst[x + y*stride]= i;
1264  }else{
1265  i= -i;
1266  i<<= QEXPSHIFT;
1267  i/= qmul; //FIXME optimize
1268  dst[x + y*stride]= -i;
1269  }
1270  }else
1271  dst[x + y*stride]= 0;
1272  }
1273  }
1274  }else{
1275  for(y=0; y<h; y++){
1276  for(x=0; x<w; x++){
1277  int i= src[x + y*stride];
1278 
1279  if((unsigned)(i+thres1) > thres2){
1280  if(i>=0){
1281  i<<= QEXPSHIFT;
1282  i= (i + bias) / qmul; //FIXME optimize
1283  dst[x + y*stride]= i;
1284  }else{
1285  i= -i;
1286  i<<= QEXPSHIFT;
1287  i= (i + bias) / qmul; //FIXME optimize
1288  dst[x + y*stride]= -i;
1289  }
1290  }else
1291  dst[x + y*stride]= 0;
1292  }
1293  }
1294  }
1295 }
1296 
1297 static void dequantize(SnowContext *s, SubBand *b, IDWTELEM *src, int stride){
1298  const int w= b->width;
1299  const int h= b->height;
1300  const int qlog= av_clip(s->qlog + b->qlog, 0, QROOT*16);
1301  const int qmul= ff_qexp[qlog&(QROOT-1)]<<(qlog>>QSHIFT);
1302  const int qadd= (s->qbias*qmul)>>QBIAS_SHIFT;
1303  int x,y;
1304 
1305  if(s->qlog == LOSSLESS_QLOG) return;
1306 
1307  for(y=0; y<h; y++){
1308  for(x=0; x<w; x++){
1309  int i= src[x + y*stride];
1310  if(i<0){
1311  src[x + y*stride]= -((-i*qmul + qadd)>>(QEXPSHIFT)); //FIXME try different bias
1312  }else if(i>0){
1313  src[x + y*stride]= (( i*qmul + qadd)>>(QEXPSHIFT));
1314  }
1315  }
1316  }
1317 }
1318 
1319 static void decorrelate(SnowContext *s, SubBand *b, IDWTELEM *src, int stride, int inverse, int use_median){
1320  const int w= b->width;
1321  const int h= b->height;
1322  int x,y;
1323 
1324  for(y=h-1; y>=0; y--){
1325  for(x=w-1; x>=0; x--){
1326  int i= x + y*stride;
1327 
1328  if(x){
1329  if(use_median){
1330  if(y && x+1<w) src[i] -= mid_pred(src[i - 1], src[i - stride], src[i - stride + 1]);
1331  else src[i] -= src[i - 1];
1332  }else{
1333  if(y) src[i] -= mid_pred(src[i - 1], src[i - stride], src[i - 1] + src[i - stride] - src[i - 1 - stride]);
1334  else src[i] -= src[i - 1];
1335  }
1336  }else{
1337  if(y) src[i] -= src[i - stride];
1338  }
1339  }
1340  }
1341 }
1342 
1343 static void correlate(SnowContext *s, SubBand *b, IDWTELEM *src, int stride, int inverse, int use_median){
1344  const int w= b->width;
1345  const int h= b->height;
1346  int x,y;
1347 
1348  for(y=0; y<h; y++){
1349  for(x=0; x<w; x++){
1350  int i= x + y*stride;
1351 
1352  if(x){
1353  if(use_median){
1354  if(y && x+1<w) src[i] += mid_pred(src[i - 1], src[i - stride], src[i - stride + 1]);
1355  else src[i] += src[i - 1];
1356  }else{
1357  if(y) src[i] += mid_pred(src[i - 1], src[i - stride], src[i - 1] + src[i - stride] - src[i - 1 - stride]);
1358  else src[i] += src[i - 1];
1359  }
1360  }else{
1361  if(y) src[i] += src[i - stride];
1362  }
1363  }
1364  }
1365 }
1366 
1367 static void encode_qlogs(SnowContext *s){
1368  int plane_index, level, orientation;
1369 
1370  for(plane_index=0; plane_index<FFMIN(s->nb_planes, 2); plane_index++){
1371  for(level=0; level<s->spatial_decomposition_count; level++){
1372  for(orientation=level ? 1:0; orientation<4; orientation++){
1373  if(orientation==2) continue;
1374  put_symbol(&s->c, s->header_state, s->plane[plane_index].band[level][orientation].qlog, 1);
1375  }
1376  }
1377  }
1378 }
1379 
1380 static void encode_header(SnowContext *s){
1381  int plane_index, i;
1382  uint8_t kstate[32];
1383 
1384  memset(kstate, MID_STATE, sizeof(kstate));
1385 
1386  put_rac(&s->c, kstate, s->keyframe);
1387  if(s->keyframe || s->always_reset){
1388  ff_snow_reset_contexts(s);
1389  s->last_spatial_decomposition_type=
1390  s->last_qlog=
1391  s->last_qbias=
1392  s->last_mv_scale=
1393  s->last_block_max_depth= 0;
1394  for(plane_index=0; plane_index<2; plane_index++){
1395  Plane *p= &s->plane[plane_index];
1396  p->last_htaps=0;
1397  p->last_diag_mc=0;
1398  memset(p->last_hcoeff, 0, sizeof(p->last_hcoeff));
1399  }
1400  }
1401  if(s->keyframe){
1402  put_symbol(&s->c, s->header_state, s->version, 0);
1403  put_rac(&s->c, s->header_state, s->always_reset);
1404  put_symbol(&s->c, s->header_state, s->temporal_decomposition_type, 0);
1405  put_symbol(&s->c, s->header_state, s->temporal_decomposition_count, 0);
1406  put_symbol(&s->c, s->header_state, s->spatial_decomposition_count, 0);
1407  put_symbol(&s->c, s->header_state, s->colorspace_type, 0);
1408  if (s->nb_planes > 2) {
1409  put_symbol(&s->c, s->header_state, s->chroma_h_shift, 0);
1410  put_symbol(&s->c, s->header_state, s->chroma_v_shift, 0);
1411  }
1412  put_rac(&s->c, s->header_state, s->spatial_scalability);
1413 // put_rac(&s->c, s->header_state, s->rate_scalability);
1414  put_symbol(&s->c, s->header_state, s->max_ref_frames-1, 0);
1415 
1416  encode_qlogs(s);
1417  }
1418 
1419  if(!s->keyframe){
1420  int update_mc=0;
1421  for(plane_index=0; plane_index<FFMIN(s->nb_planes, 2); plane_index++){
1422  Plane *p= &s->plane[plane_index];
1423  update_mc |= p->last_htaps != p->htaps;
1424  update_mc |= p->last_diag_mc != p->diag_mc;
1425  update_mc |= !!memcmp(p->last_hcoeff, p->hcoeff, sizeof(p->hcoeff));
1426  }
1427  put_rac(&s->c, s->header_state, update_mc);
1428  if(update_mc){
1429  for(plane_index=0; plane_index<FFMIN(s->nb_planes, 2); plane_index++){
1430  Plane *p= &s->plane[plane_index];
1431  put_rac(&s->c, s->header_state, p->diag_mc);
1432  put_symbol(&s->c, s->header_state, p->htaps/2-1, 0);
1433  for(i= p->htaps/2; i; i--)
1434  put_symbol(&s->c, s->header_state, FFABS(p->hcoeff[i]), 0);
1435  }
1436  }
1437  if(s->last_spatial_decomposition_count != s->spatial_decomposition_count){
1438  put_rac(&s->c, s->header_state, 1);
1439  put_symbol(&s->c, s->header_state, s->spatial_decomposition_count, 0);
1440  encode_qlogs(s);
1441  }else
1442  put_rac(&s->c, s->header_state, 0);
1443  }
1444 
1445  put_symbol(&s->c, s->header_state, s->spatial_decomposition_type - s->last_spatial_decomposition_type, 1);
1446  put_symbol(&s->c, s->header_state, s->qlog - s->last_qlog , 1);
1447  put_symbol(&s->c, s->header_state, s->mv_scale - s->last_mv_scale, 1);
1448  put_symbol(&s->c, s->header_state, s->qbias - s->last_qbias , 1);
1449  put_symbol(&s->c, s->header_state, s->block_max_depth - s->last_block_max_depth, 1);
1450 
1451 }
1452 
1453 static void update_last_header_values(SnowContext *s){
1454  int plane_index;
1455 
1456  if(!s->keyframe){
1457  for(plane_index=0; plane_index<2; plane_index++){
1458  Plane *p= &s->plane[plane_index];
1459  p->last_diag_mc= p->diag_mc;
1460  p->last_htaps = p->htaps;
1461  memcpy(p->last_hcoeff, p->hcoeff, sizeof(p->hcoeff));
1462  }
1463  }
1464 
1465  s->last_spatial_decomposition_type = s->spatial_decomposition_type;
1466  s->last_qlog = s->qlog;
1467  s->last_qbias = s->qbias;
1468  s->last_mv_scale = s->mv_scale;
1469  s->last_block_max_depth = s->block_max_depth;
1470  s->last_spatial_decomposition_count = s->spatial_decomposition_count;
1471 }
1472 
1473 static int qscale2qlog(int qscale){
1474  return lrint(QROOT*log2(qscale / (float)FF_QP2LAMBDA))
1475  + 61*QROOT/8; ///< 64 > 60
1476 }
1477 
1478 static int ratecontrol_1pass(SnowContext *s, AVFrame *pict)
1479 {
1480  /* Estimate the frame's complexity as a sum of weighted dwt coefficients.
1481  * FIXME we know exact mv bits at this point,
1482  * but ratecontrol isn't set up to include them. */
1483  uint32_t coef_sum= 0;
1484  int level, orientation, delta_qlog;
1485 
1486  for(level=0; level<s->spatial_decomposition_count; level++){
1487  for(orientation=level ? 1 : 0; orientation<4; orientation++){
1488  SubBand *b= &s->plane[0].band[level][orientation];
1489  IDWTELEM *buf= b->ibuf;
1490  const int w= b->width;
1491  const int h= b->height;
1492  const int stride= b->stride;
1493  const int qlog= av_clip(2*QROOT + b->qlog, 0, QROOT*16);
1494  const int qmul= ff_qexp[qlog&(QROOT-1)]<<(qlog>>QSHIFT);
1495  const int qdiv= (1<<16)/qmul;
1496  int x, y;
1497  //FIXME this is ugly
1498  for(y=0; y<h; y++)
1499  for(x=0; x<w; x++)
1500  buf[x+y*stride]= b->buf[x+y*stride];
1501  if(orientation==0)
1502  decorrelate(s, b, buf, stride, 1, 0);
1503  for(y=0; y<h; y++)
1504  for(x=0; x<w; x++)
1505  coef_sum+= abs(buf[x+y*stride]) * qdiv >> 16;
1506  }
1507  }
1508 
1509  /* ugly, ratecontrol just takes a sqrt again */
1510  av_assert0(coef_sum < INT_MAX);
1511  coef_sum = (uint64_t)coef_sum * coef_sum >> 16;
1512 
1513  if(pict->pict_type == AV_PICTURE_TYPE_I){
1514  s->m.current_picture.mb_var_sum= coef_sum;
1515  s->m.current_picture.mc_mb_var_sum= 0;
1516  }else{
1517  s->m.current_picture.mc_mb_var_sum= coef_sum;
1518  s->m.current_picture.mb_var_sum= 0;
1519  }
1520 
1521  pict->quality= ff_rate_estimate_qscale(&s->m, 1);
1522  if (pict->quality < 0)
1523  return INT_MIN;
1524  s->lambda= pict->quality * 3/2;
1525  delta_qlog= qscale2qlog(pict->quality) - s->qlog;
1526  s->qlog+= delta_qlog;
1527  return delta_qlog;
1528 }
1529 
1530 static void calculate_visual_weight(SnowContext *s, Plane *p){
1531  int width = p->width;
1532  int height= p->height;
1533  int level, orientation, x, y;
1534 
1535  for(level=0; level<s->spatial_decomposition_count; level++){
1536  for(orientation=level ? 1 : 0; orientation<4; orientation++){
1537  SubBand *b= &p->band[level][orientation];
1538  IDWTELEM *ibuf= b->ibuf;
1539  int64_t error=0;
1540 
1541  memset(s->spatial_idwt_buffer, 0, sizeof(*s->spatial_idwt_buffer)*width*height);
1542  ibuf[b->width/2 + b->height/2*b->stride]= 256*16;
1543  ff_spatial_idwt(s->spatial_idwt_buffer, s->temp_idwt_buffer, width, height, width, s->spatial_decomposition_type, s->spatial_decomposition_count);
1544  for(y=0; y<height; y++){
1545  for(x=0; x<width; x++){
1546  int64_t d= s->spatial_idwt_buffer[x + y*width]*16;
1547  error += d*d;
1548  }
1549  }
1550 
1551  b->qlog= (int)(QROOT * log2(352256.0/sqrt(error)) + 0.5);
1552  }
1553  }
1554 }
1555 
1556 static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
1557  const AVFrame *pict, int *got_packet)
1558 {
1559  SnowContext *s = avctx->priv_data;
1560  RangeCoder * const c= &s->c;
1561  AVFrame *pic;
1562  const int width= s->avctx->width;
1563  const int height= s->avctx->height;
1564  int level, orientation, plane_index, i, y, ret;
1565  uint8_t rc_header_bak[sizeof(s->header_state)];
1566  uint8_t rc_block_bak[sizeof(s->block_state)];
1567 
1568  if ((ret = ff_alloc_packet(avctx, pkt, s->b_width*s->b_height*MB_SIZE*MB_SIZE*3 + AV_INPUT_BUFFER_MIN_SIZE)) < 0)
1569  return ret;
1570 
1571  ff_init_range_encoder(c, pkt->data, pkt->size);
1572  ff_build_rac_states(c, (1LL<<32)/20, 256-8);
1573 
1574  for(i=0; i < s->nb_planes; i++){
1575  int hshift= i ? s->chroma_h_shift : 0;
1576  int vshift= i ? s->chroma_v_shift : 0;
1577  for(y=0; y<AV_CEIL_RSHIFT(height, vshift); y++)
1578  memcpy(&s->input_picture->data[i][y * s->input_picture->linesize[i]],
1579  &pict->data[i][y * pict->linesize[i]],
1580  AV_CEIL_RSHIFT(width, hshift));
1581  s->mpvencdsp.draw_edges(s->input_picture->data[i], s->input_picture->linesize[i],
1582  AV_CEIL_RSHIFT(width, hshift), AV_CEIL_RSHIFT(height, vshift),
1583  EDGE_WIDTH >> hshift, EDGE_WIDTH >> vshift,
1584  EDGE_TOP | EDGE_BOTTOM);
1585 
1586  }
1587  emms_c();
1588  pic = s->input_picture;
1589  pic->pict_type = pict->pict_type;
1590  pic->quality = pict->quality;
1591 
1592  s->m.picture_number= avctx->frame_number;
1593  if(avctx->flags&AV_CODEC_FLAG_PASS2){
1594  s->m.pict_type = pic->pict_type = s->m.rc_context.entry[avctx->frame_number].new_pict_type;
1595  s->keyframe = pic->pict_type == AV_PICTURE_TYPE_I;
1596  if(!(avctx->flags&AV_CODEC_FLAG_QSCALE)) {
1597  pic->quality = ff_rate_estimate_qscale(&s->m, 0);
1598  if (pic->quality < 0)
1599  return -1;
1600  }
1601  }else{
1602  s->keyframe= avctx->gop_size==0 || avctx->frame_number % avctx->gop_size == 0;
1603  s->m.pict_type = pic->pict_type = s->keyframe ? AV_PICTURE_TYPE_I : AV_PICTURE_TYPE_P;
1604  }
1605 
1606  if(s->pass1_rc && avctx->frame_number == 0)
1607  pic->quality = 2*FF_QP2LAMBDA;
1608  if (pic->quality) {
1609  s->qlog = qscale2qlog(pic->quality);
1610  s->lambda = pic->quality * 3/2;
1611  }
1612  if (s->qlog < 0 || (!pic->quality && (avctx->flags & AV_CODEC_FLAG_QSCALE))) {
1613  s->qlog= LOSSLESS_QLOG;
1614  s->lambda = 0;
1615  }//else keep previous frame's qlog until after motion estimation
1616 
1617  if (s->current_picture->data[0]) {
1618  int w = s->avctx->width;
1619  int h = s->avctx->height;
1620 
1621  s->mpvencdsp.draw_edges(s->current_picture->data[0],
1622  s->current_picture->linesize[0], w , h ,
1623  EDGE_WIDTH , EDGE_WIDTH , EDGE_TOP | EDGE_BOTTOM);
1624  if (s->current_picture->data[2]) {
1625  s->mpvencdsp.draw_edges(s->current_picture->data[1],
1626  s->current_picture->linesize[1], w>>s->chroma_h_shift, h>>s->chroma_v_shift,
1627  EDGE_WIDTH>>s->chroma_h_shift, EDGE_WIDTH>>s->chroma_v_shift, EDGE_TOP | EDGE_BOTTOM);
1628  s->mpvencdsp.draw_edges(s->current_picture->data[2],
1629  s->current_picture->linesize[2], w>>s->chroma_h_shift, h>>s->chroma_v_shift,
1630  EDGE_WIDTH>>s->chroma_h_shift, EDGE_WIDTH>>s->chroma_v_shift, EDGE_TOP | EDGE_BOTTOM);
1631  }
1632  emms_c();
1633  }
1634 
1635  ff_snow_frame_start(s);
1636 
1637  s->m.current_picture_ptr= &s->m.current_picture;
1638  s->m.current_picture.f = s->current_picture;
1639  s->m.current_picture.f->pts = pict->pts;
1640  if(pic->pict_type == AV_PICTURE_TYPE_P){
1641  int block_width = (width +15)>>4;
1642  int block_height= (height+15)>>4;
1643  int stride= s->current_picture->linesize[0];
1644 
1645  av_assert0(s->current_picture->data[0]);
1646  av_assert0(s->last_picture[0]->data[0]);
1647 
1648  s->m.avctx= s->avctx;
1649  s->m. last_picture.f = s->last_picture[0];
1650  s->m. new_picture.f = s->input_picture;
1651  s->m. last_picture_ptr= &s->m. last_picture;
1652  s->m.linesize = stride;
1653  s->m.uvlinesize= s->current_picture->linesize[1];
1654  s->m.width = width;
1655  s->m.height= height;
1656  s->m.mb_width = block_width;
1657  s->m.mb_height= block_height;
1658  s->m.mb_stride= s->m.mb_width+1;
1659  s->m.b8_stride= 2*s->m.mb_width+1;
1660  s->m.f_code=1;
1661  s->m.pict_type = pic->pict_type;
1662  s->m.motion_est= s->motion_est;
1663  s->m.me.scene_change_score=0;
1664  s->m.me.dia_size = avctx->dia_size;
1665  s->m.quarter_sample= (s->avctx->flags & AV_CODEC_FLAG_QPEL)!=0;
1666  s->m.out_format= FMT_H263;
1667  s->m.unrestricted_mv= 1;
1668 
1669  s->m.lambda = s->lambda;
1670  s->m.qscale= (s->m.lambda*139 + FF_LAMBDA_SCALE*64) >> (FF_LAMBDA_SHIFT + 7);
1671  s->lambda2= s->m.lambda2= (s->m.lambda*s->m.lambda + FF_LAMBDA_SCALE/2) >> FF_LAMBDA_SHIFT;
1672 
1673  s->m.mecc= s->mecc; //move
1674  s->m.qdsp= s->qdsp; //move
1675  s->m.hdsp = s->hdsp;
1676  ff_init_me(&s->m);
1677  s->hdsp = s->m.hdsp;
1678  s->mecc= s->m.mecc;
1679  }
1680 
1681  if(s->pass1_rc){
1682  memcpy(rc_header_bak, s->header_state, sizeof(s->header_state));
1683  memcpy(rc_block_bak, s->block_state, sizeof(s->block_state));
1684  }
1685 
1686 redo_frame:
1687 
1688  s->spatial_decomposition_count= 5;
1689 
1690  while( !(width >>(s->chroma_h_shift + s->spatial_decomposition_count))
1691  || !(height>>(s->chroma_v_shift + s->spatial_decomposition_count)))
1692  s->spatial_decomposition_count--;
1693 
1694  if (s->spatial_decomposition_count <= 0) {
1695  av_log(avctx, AV_LOG_ERROR, "Resolution too low\n");
1696  return AVERROR(EINVAL);
1697  }
1698 
1699  s->m.pict_type = pic->pict_type;
1700  s->qbias = pic->pict_type == AV_PICTURE_TYPE_P ? 2 : 0;
1701 
1702  ff_snow_common_init_after_header(avctx);
1703 
1704  if(s->last_spatial_decomposition_count != s->spatial_decomposition_count){
1705  for(plane_index=0; plane_index < s->nb_planes; plane_index++){
1706  calculate_visual_weight(s, &s->plane[plane_index]);
1707  }
1708  }
1709 
1710  encode_header(s);
1711  s->m.misc_bits = 8*(s->c.bytestream - s->c.bytestream_start);
1712  encode_blocks(s, 1);
1713  s->m.mv_bits = 8*(s->c.bytestream - s->c.bytestream_start) - s->m.misc_bits;
1714 
1715  for(plane_index=0; plane_index < s->nb_planes; plane_index++){
1716  Plane *p= &s->plane[plane_index];
1717  int w= p->width;
1718  int h= p->height;
1719  int x, y;
1720 // int bits= put_bits_count(&s->c.pb);
1721 
1722  if (!s->memc_only) {
1723  //FIXME optimize
1724  if(pict->data[plane_index]) //FIXME gray hack
1725  for(y=0; y<h; y++){
1726  for(x=0; x<w; x++){
1727  s->spatial_idwt_buffer[y*w + x]= pict->data[plane_index][y*pict->linesize[plane_index] + x]<<FRAC_BITS;
1728  }
1729  }
1730  predict_plane(s, s->spatial_idwt_buffer, plane_index, 0);
1731 
1732  if( plane_index==0
1733  && pic->pict_type == AV_PICTURE_TYPE_P
1734  && !(avctx->flags&AV_CODEC_FLAG_PASS2)
1735  && s->m.me.scene_change_score > s->scenechange_threshold){
1736  ff_init_range_encoder(c, pkt->data, pkt->size);
1737  ff_build_rac_states(c, (1LL<<32)/20, 256-8);
1738  pic->pict_type= AV_PICTURE_TYPE_I;
1739  s->keyframe=1;
1740  s->current_picture->key_frame=1;
1741  goto redo_frame;
1742  }
1743 
1744  if(s->qlog == LOSSLESS_QLOG){
1745  for(y=0; y<h; y++){
1746  for(x=0; x<w; x++){
1747  s->spatial_dwt_buffer[y*w + x]= (s->spatial_idwt_buffer[y*w + x] + (1<<(FRAC_BITS-1))-1)>>FRAC_BITS;
1748  }
1749  }
1750  }else{
1751  for(y=0; y<h; y++){
1752  for(x=0; x<w; x++){
1753  s->spatial_dwt_buffer[y*w + x]= s->spatial_idwt_buffer[y*w + x] * (1 << ENCODER_EXTRA_BITS);
1754  }
1755  }
1756  }
1757 
1758  ff_spatial_dwt(s->spatial_dwt_buffer, s->temp_dwt_buffer, w, h, w, s->spatial_decomposition_type, s->spatial_decomposition_count);
1759 
1760  if(s->pass1_rc && plane_index==0){
1761  int delta_qlog = ratecontrol_1pass(s, pic);
1762  if (delta_qlog <= INT_MIN)
1763  return -1;
1764  if(delta_qlog){
1765  //reordering qlog in the bitstream would eliminate this reset
1766  ff_init_range_encoder(c, pkt->data, pkt->size);
1767  memcpy(s->header_state, rc_header_bak, sizeof(s->header_state));
1768  memcpy(s->block_state, rc_block_bak, sizeof(s->block_state));
1769  encode_header(s);
1770  encode_blocks(s, 0);
1771  }
1772  }
1773 
1774  for(level=0; level<s->spatial_decomposition_count; level++){
1775  for(orientation=level ? 1 : 0; orientation<4; orientation++){
1776  SubBand *b= &p->band[level][orientation];
1777 
1778  quantize(s, b, b->ibuf, b->buf, b->stride, s->qbias);
1779  if(orientation==0)
1780  decorrelate(s, b, b->ibuf, b->stride, pic->pict_type == AV_PICTURE_TYPE_P, 0);
1781  if (!s->no_bitstream)
1782  encode_subband(s, b, b->ibuf, b->parent ? b->parent->ibuf : NULL, b->stride, orientation);
1783  av_assert0(b->parent==NULL || b->parent->stride == b->stride*2);
1784  if(orientation==0)
1785  correlate(s, b, b->ibuf, b->stride, 1, 0);
1786  }
1787  }
1788 
1789  for(level=0; level<s->spatial_decomposition_count; level++){
1790  for(orientation=level ? 1 : 0; orientation<4; orientation++){
1791  SubBand *b= &p->band[level][orientation];
1792 
1793  dequantize(s, b, b->ibuf, b->stride);
1794  }
1795  }
1796 
1797  ff_spatial_idwt(s->spatial_idwt_buffer, s->temp_idwt_buffer, w, h, w, s->spatial_decomposition_type, s->spatial_decomposition_count);
1798  if(s->qlog == LOSSLESS_QLOG){
1799  for(y=0; y<h; y++){
1800  for(x=0; x<w; x++){
1801  s->spatial_idwt_buffer[y*w + x]<<=FRAC_BITS;
1802  }
1803  }
1804  }
1805  predict_plane(s, s->spatial_idwt_buffer, plane_index, 1);
1806  }else{
1807  //ME/MC only
1808  if(pic->pict_type == AV_PICTURE_TYPE_I){
1809  for(y=0; y<h; y++){
1810  for(x=0; x<w; x++){
1811  s->current_picture->data[plane_index][y*s->current_picture->linesize[plane_index] + x]=
1812  pict->data[plane_index][y*pict->linesize[plane_index] + x];
1813  }
1814  }
1815  }else{
1816  memset(s->spatial_idwt_buffer, 0, sizeof(IDWTELEM)*w*h);
1817  predict_plane(s, s->spatial_idwt_buffer, plane_index, 1);
1818  }
1819  }
1820  if(s->avctx->flags&AV_CODEC_FLAG_PSNR){
1821  int64_t error= 0;
1822 
1823  if(pict->data[plane_index]) //FIXME gray hack
1824  for(y=0; y<h; y++){
1825  for(x=0; x<w; x++){
1826  int d= s->current_picture->data[plane_index][y*s->current_picture->linesize[plane_index] + x] - pict->data[plane_index][y*pict->linesize[plane_index] + x];
1827  error += d*d;
1828  }
1829  }
1830  s->avctx->error[plane_index] += error;
1831  s->encoding_error[plane_index] = error;
1832  }
1833 
1834  }
1835  emms_c();
1836 
1837  update_last_header_values(s);
1838 
1839  ff_snow_release_buffer(avctx);
1840 
1841  s->current_picture->coded_picture_number = avctx->frame_number;
1842  s->current_picture->pict_type = pic->pict_type;
1843  s->current_picture->quality = pic->quality;
1844  s->m.frame_bits = 8*(s->c.bytestream - s->c.bytestream_start);
1845  s->m.p_tex_bits = s->m.frame_bits - s->m.misc_bits - s->m.mv_bits;
1846  s->m.current_picture.f->display_picture_number =
1847  s->m.current_picture.f->coded_picture_number = avctx->frame_number;
1848  s->m.current_picture.f->quality = pic->quality;
1849  s->m.total_bits += 8*(s->c.bytestream - s->c.bytestream_start);
1850  if(s->pass1_rc)
1851  if (ff_rate_estimate_qscale(&s->m, 0) < 0)
1852  return -1;
1853  if(avctx->flags&AV_CODEC_FLAG_PASS1)
1854  ff_write_pass1_stats(&s->m);
1855  s->m.last_pict_type = s->m.pict_type;
1856 
1857  emms_c();
1858 
1859  ff_side_data_set_encoder_stats(pkt, s->current_picture->quality,
1860  s->encoding_error,
1861  (s->avctx->flags&AV_CODEC_FLAG_PSNR) ? SNOW_MAX_PLANES : 0,
1862  s->current_picture->pict_type);
1863 
1864  pkt->size = ff_rac_terminate(c, 0);
1865  if (s->current_picture->key_frame)
1866  pkt->flags |= AV_PKT_FLAG_KEY;
1867  *got_packet = 1;
1868 
1869  return 0;
1870 }
1871 
1872 static av_cold int encode_end(AVCodecContext *avctx)
1873 {
1874  SnowContext *s = avctx->priv_data;
1875 
1876  ff_snow_common_end(s);
1877  ff_rate_control_uninit(&s->m);
1878  av_frame_free(&s->input_picture);
1879  av_freep(&avctx->stats_out);
1880 
1881  return 0;
1882 }
1883 
1884 #define OFFSET(x) offsetof(SnowContext, x)
1885 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1886 static const AVOption options[] = {
1887  {"motion_est", "motion estimation algorithm", OFFSET(motion_est), AV_OPT_TYPE_INT, {.i64 = FF_ME_EPZS }, FF_ME_ZERO, FF_ME_ITER, VE, "motion_est" },
1888  { "zero", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FF_ME_ZERO }, 0, 0, VE, "motion_est" },
1889  { "epzs", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FF_ME_EPZS }, 0, 0, VE, "motion_est" },
1890  { "xone", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FF_ME_XONE }, 0, 0, VE, "motion_est" },
1891  { "iter", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FF_ME_ITER }, 0, 0, VE, "motion_est" },
1892  { "memc_only", "Only do ME/MC (I frames -> ref, P frame -> ME+MC).", OFFSET(memc_only), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
1893  { "no_bitstream", "Skip final bitstream writeout.", OFFSET(no_bitstream), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
1894  { "intra_penalty", "Penalty for intra blocks in block decission", OFFSET(intra_penalty), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, VE },
1895  { "iterative_dia_size", "Dia size for the iterative ME", OFFSET(iterative_dia_size), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, VE },
1896  { "sc_threshold", "Scene change threshold", OFFSET(scenechange_threshold), AV_OPT_TYPE_INT, { .i64 = 0 }, INT_MIN, INT_MAX, VE },
1897  { "pred", "Spatial decomposition type", OFFSET(pred), AV_OPT_TYPE_INT, { .i64 = 0 }, DWT_97, DWT_53, VE, "pred" },
1898  { "dwt97", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 0 }, INT_MIN, INT_MAX, VE, "pred" },
1899  { "dwt53", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 1 }, INT_MIN, INT_MAX, VE, "pred" },
1900  { "rc_eq", "Set rate control equation. When computing the expression, besides the standard functions "
1901  "defined in the section 'Expression Evaluation', the following functions are available: "
1902  "bits2qp(bits), qp2bits(qp). Also the following constants are available: iTex pTex tex mv "
1903  "fCode iCount mcVar var isI isP isB avgQP qComp avgIITex avgPITex avgPPTex avgBPTex avgTex.",
1904  OFFSET(m.rc_eq), AV_OPT_TYPE_STRING, { .str = NULL }, 0, 0, VE },
1905  { NULL },
1906 };
1907 
1908 static const AVClass snowenc_class = {
1909  .class_name = "snow encoder",
1910  .item_name = av_default_item_name,
1911  .option = options,
1912  .version = LIBAVUTIL_VERSION_INT,
1913 };
1914 
1915 const AVCodec ff_snow_encoder = {
1916  .name = "snow",
1917  .long_name = NULL_IF_CONFIG_SMALL("Snow"),
1918  .type = AVMEDIA_TYPE_VIDEO,
1919  .id = AV_CODEC_ID_SNOW,
1920  .priv_data_size = sizeof(SnowContext),
1921  .init = encode_init,
1922  .encode2 = encode_frame,
1923  .close = encode_end,
1924  .pix_fmts = (const enum AVPixelFormat[]){
1925  AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV410P, AV_PIX_FMT_YUV444P,
1926  AV_PIX_FMT_GRAY8,
1927  AV_PIX_FMT_NONE
1928  },
1929  .priv_class = &snowenc_class,
1930  .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE |
1931  FF_CODEC_CAP_INIT_CLEANUP,
1932 };
error
static void error(const char *err)
Definition: target_bsf_fuzzer.c:31
AVCodec
AVCodec.
Definition: codec.h:202
encode_subband
static int encode_subband(SnowContext *s, SubBand *b, const IDWTELEM *src, const IDWTELEM *parent, int stride, int orientation)
Definition: snowenc.c:888
decorrelate
static void decorrelate(SnowContext *s, SubBand *b, IDWTELEM *src, int stride, int inverse, int use_median)
Definition: snowenc.c:1319
FF_CODEC_CAP_INIT_THREADSAFE
#define FF_CODEC_CAP_INIT_THREADSAFE
The codec does not modify any global variables in the init function, allowing to call the init functi...
Definition: internal.h:42
set_blocks
static void set_blocks(SnowContext *s, int level, int x, int y, int l, int cb, int cr, int mx, int my, int ref, int type)
Definition: snow.h:465
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
Plane::last_diag_mc
int last_diag_mc
Definition: snow.h:113
P_LEFT
#define P_LEFT
Definition: snowenc.c:211
level
uint8_t level
Definition: svq3.c:202
av_clip
#define av_clip
Definition: common.h:96
iterative_me
static void iterative_me(SnowContext *s)
Definition: snowenc.c:987
QEXPSHIFT
#define QEXPSHIFT
Definition: snow.h:510
FF_LAMBDA_SCALE
#define FF_LAMBDA_SCALE
Definition: avutil.h:226
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
libm.h
MID_STATE
#define MID_STATE
Definition: snow.h:42
color
Definition: vf_paletteuse.c:600
EDGE_BOTTOM
#define EDGE_BOTTOM
Definition: mpegvideoencdsp.h:30
cb
static double cb(void *priv, double x, double y)
Definition: vf_geq.c:215
state
static struct @322 state
FF_ME_EPZS
#define FF_ME_EPZS
Definition: motion_est.h:41
encode_end
static av_cold int encode_end(AVCodecContext *avctx)
Definition: snowenc.c:1872
ff_side_data_set_encoder_stats
int ff_side_data_set_encoder_stats(AVPacket *pkt, int quality, int64_t *error, int error_count, int pict_type)
Definition: avpacket.c:604
LOG2_MB_SIZE
#define LOG2_MB_SIZE
Definition: snow.h:75
AV_CODEC_FLAG_QSCALE
#define AV_CODEC_FLAG_QSCALE
Use fixed qscale.
Definition: avcodec.h:210
MotionEstContext
Motion estimation context.
Definition: motion_est.h:47
init_ref
static void init_ref(MotionEstContext *c, uint8_t *src[3], uint8_t *ref[3], uint8_t *ref2[3], int x, int y, int ref_index)
Definition: motion_est.c:83
QBIAS_SHIFT
#define QBIAS_SHIFT
Definition: snow.h:166
ff_w97_32_c
int ff_w97_32_c(struct MpegEncContext *v, uint8_t *pix1, uint8_t *pix2, ptrdiff_t line_size, int h)
Definition: snow_dwt.c:837
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
DWT_97
#define DWT_97
Definition: snow_dwt.h:68
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
pixdesc.h
AVFrame::pts
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:424
index
fg index
Definition: ffmpeg_filter.c:167
MAX_DMV
#define MAX_DMV
Definition: motion_est.h:37
update_last_header_values
static void update_last_header_values(SnowContext *s)
Definition: snowenc.c:1453
w
uint8_t w
Definition: llviddspenc.c:38
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:373
AVOption
AVOption.
Definition: opt.h:247
last_picture
enum AVPictureType last_picture
Definition: movenc.c:69
encode.h
b
#define b
Definition: input.c:40
DWT_53
#define DWT_53
Definition: snow_dwt.h:69
get_penalty_factor
static int get_penalty_factor(int lambda, int lambda2, int type)
Definition: snowenc.c:186
encode_subband_c0run
static int encode_subband_c0run(SnowContext *s, SubBand *b, const IDWTELEM *src, const IDWTELEM *parent, int stride, int orientation)
Definition: snowenc.c:768
rangecoder.h
mpegvideo.h
ff_rate_control_init
av_cold int ff_rate_control_init(MpegEncContext *s)
Definition: ratecontrol.c:472
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
AV_CODEC_FLAG_PSNR
#define AV_CODEC_FLAG_PSNR
error[?] variables will be set during encoding.
Definition: avcodec.h:247
FF_LAMBDA_SHIFT
#define FF_LAMBDA_SHIFT
Definition: avutil.h:225
SnowContext
Definition: snow.h:116
encode_frame
static int encode_frame(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *pict, int *got_packet)
Definition: snowenc.c:1556
QSHIFT
#define QSHIFT
Definition: snow.h:45
MAX_REF_FRAMES
#define MAX_REF_FRAMES
Definition: snow.h:49
AV_CODEC_FLAG_4MV
#define AV_CODEC_FLAG_4MV
4 MV per MB allowed / advanced prediction for H.263.
Definition: avcodec.h:214
ff_set_cmp
void ff_set_cmp(MECmpContext *c, me_cmp_func *cmp, int type)
Definition: me_cmp.c:475
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:428
put_symbol
static av_noinline void put_symbol(RangeCoder *c, uint8_t *state, int v, int is_signed)
Definition: ffv1enc.c:233
ff_snow_common_end
av_cold void ff_snow_common_end(SnowContext *s)
Definition: snow.c:689
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:338
ff_spatial_dwt
void ff_spatial_dwt(DWTELEM *buffer, DWTELEM *temp, int width, int height, int stride, int type, int decomposition_count)
Definition: snow_dwt.c:319
Plane::diag_mc
int diag_mc
Definition: snow.h:108
BlockNode::type
uint8_t type
Bitfield of BLOCK_*.
Definition: snow.h:58
init
static int init
Definition: av_tx.c:47
ff_mpegvideoencdsp_init
av_cold void ff_mpegvideoencdsp_init(MpegvideoEncDSPContext *c, AVCodecContext *avctx)
Definition: mpegvideoencdsp.c:232
ff_spatial_idwt
void ff_spatial_idwt(IDWTELEM *buffer, IDWTELEM *temp, int width, int height, int stride, int type, int decomposition_count)
Definition: snow_dwt.c:731
ff_init_range_encoder
av_cold void ff_init_range_encoder(RangeCoder *c, uint8_t *buf, int buf_size)
Definition: rangecoder.c:42
LOG2_OBMC_MAX
#define LOG2_OBMC_MAX
Definition: snow.h:51
BlockNode
Definition: snow.h:53
AVCodecContext::refs
int refs
number of reference frames
Definition: avcodec.h:932
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:463
av_pix_fmt_get_chroma_sub_sample
int av_pix_fmt_get_chroma_sub_sample(enum AVPixelFormat pix_fmt, int *h_shift, int *v_shift)
Utility function to access log2_chroma_w log2_chroma_h from the pixel format AVPixFmtDescriptor.
Definition: pixdesc.c:2688
OFFSET
#define OFFSET(x)
Definition: snowenc.c:1884
ff_snow_pred_block
void ff_snow_pred_block(SnowContext *s, uint8_t *dst, uint8_t *tmp, ptrdiff_t stride, int sx, int sy, int b_w, int b_h, const BlockNode *block, int plane_index, int w, int h)
Definition: snow.c:318
type
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 type
Definition: writing_filters.txt:86
FF_CMP_SSE
#define FF_CMP_SSE
Definition: avcodec.h:780
ff_sqrt
#define ff_sqrt
Definition: mathops.h:206
av_frame_alloc
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:97
ff_rate_estimate_qscale
float ff_rate_estimate_qscale(MpegEncContext *s, int dry_run)
Definition: ratecontrol.c:868
ff_snow_common_init_after_header
int ff_snow_common_init_after_header(AVCodecContext *avctx)
Definition: snow.c:510
lrint
#define lrint
Definition: tablegen.h:53
pkt
AVPacket * pkt
Definition: movenc.c:59
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_CMP_BIT
#define FF_CMP_BIT
Definition: avcodec.h:784
ff_snow_get_buffer
int ff_snow_get_buffer(SnowContext *s, AVFrame *frame)
Definition: snow.c:69
ff_h263_encode_init
void ff_h263_encode_init(MpegEncContext *s)
Definition: ituh263enc.c:811
width
#define width
s
#define s(width, name)
Definition: cbs_vp9.c:257
encode_blocks
static void encode_blocks(SnowContext *s, int search)
Definition: snowenc.c:1214
AVCodecContext::global_quality
int global_quality
Global quality for codecs which cannot change it per frame.
Definition: avcodec.h:449
AV_CEIL_RSHIFT
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:51
BLOCK_OPT
#define BLOCK_OPT
Block needs no checks in this round of iterative motion estiation.
Definition: snow.h:61
LOSSLESS_QLOG
#define LOSSLESS_QLOG
Definition: snow.h:47
calculate_visual_weight
static void calculate_visual_weight(SnowContext *s, Plane *p)
Definition: snowenc.c:1530
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
pix_fmts
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:296
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
add_yblock
static av_always_inline void add_yblock(SnowContext *s, int sliced, slice_buffer *sb, IDWTELEM *dst, uint8_t *dst8, const uint8_t *obmc, int src_x, int src_y, int b_w, int b_h, int w, int h, int dst_stride, int src_stride, int obmc_stride, int b_x, int b_y, int add, int offset_dst, int plane_index)
Definition: snow.h:283
AV_INPUT_BUFFER_MIN_SIZE
#define AV_INPUT_BUFFER_MIN_SIZE
Definition: avcodec.h:185
ff_snow_common_init
av_cold int ff_snow_common_init(AVCodecContext *avctx)
Definition: snow.c:428
AV_PIX_FMT_YUV420P
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
pass
#define pass
Definition: fft_template.c:601
FFABS
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:65
context
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 default minimum maximum flags name is the option keep it simple and lowercase description are in without and describe what they for example set the foo of the bar offset is the offset of the field in your context
Definition: writing_filters.txt:91
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
ff_write_pass1_stats
void ff_write_pass1_stats(MpegEncContext *s)
Definition: ratecontrol.c:38
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
check_block_inter
static av_always_inline int check_block_inter(SnowContext *s, int mb_x, int mb_y, int p0, int p1, uint8_t(*obmc_edged)[MB_SIZE *2], int *best_rd)
Definition: snowenc.c:936
NULL
#define NULL
Definition: coverity.c:32
run
uint8_t run
Definition: svq3.c:201
EDGE_WIDTH
#define EDGE_WIDTH
Definition: mpegpicture.h:34
snow.h
BlockNode::my
int16_t my
Motion vector component Y, see mv_scale.
Definition: snow.h:55
VE
#define VE
Definition: snowenc.c:1885
AVCodecContext::bit_rate
int64_t bit_rate
the average bitrate
Definition: avcodec.h:433
ff_rac_terminate
int ff_rac_terminate(RangeCoder *c, int version)
Terminates the range coder.
Definition: rangecoder.c:109
ROUNDED_DIV
#define ROUNDED_DIV(a, b)
Definition: common.h:49
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:235
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:274
ff_snow_release_buffer
void ff_snow_release_buffer(AVCodecContext *avctx)
Definition: snow.c:636
FF_ME_ITER
#define FF_ME_ITER
Definition: snow.h:40
mathops.h
get_dc
static int get_dc(SnowContext *s, int mb_x, int mb_y, int plane_index)
Definition: snowenc.c:502
abs
#define abs(x)
Definition: cuda_runtime.h:35
correlate
static void correlate(SnowContext *s, SubBand *b, IDWTELEM *src, int stride, int inverse, int use_median)
Definition: snowenc.c:1343
QROOT
#define QROOT
Definition: snow.h:46
AV_PIX_FMT_GRAY8
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
Definition: pixfmt.h:74
ME_MAP_SIZE
#define ME_MAP_SIZE
Definition: motion_est.h:38
FF_ME_XONE
#define FF_ME_XONE
Definition: motion_est.h:42
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
ff_epzs_motion_search
int ff_epzs_motion_search(struct MpegEncContext *s, int *mx_ptr, int *my_ptr, int P[10][2], int src_index, int ref_index, int16_t(*last_mv)[2], int ref_mv_scale, int size, int h)
Definition: motion_est_template.c:977
MB_SIZE
#define MB_SIZE
Definition: cinepakenc.c:55
AVCodecContext::stats_out
char * stats_out
pass1 encoding statistics output buffer
Definition: avcodec.h:1236
AV_CODEC_FLAG_QPEL
#define AV_CODEC_FLAG_QPEL
Use qpel MC.
Definition: avcodec.h:222
AVFrame::pict_type
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:414
AVPacket::size
int size
Definition: packet.h:374
SNOW_MAX_PLANES
#define SNOW_MAX_PLANES
Definition: snow.h:38
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:117
AVCodecContext::gop_size
int gop_size
the number of pictures in a group of pictures, or 0 for intra_only
Definition: avcodec.h:578
encode_header
static void encode_header(SnowContext *s)
Definition: snowenc.c:1380
FF_CMP_PSNR
#define FF_CMP_PSNR
Definition: avcodec.h:783
Plane::height
int height
Definition: cfhd.h:120
P
#define P
AVFrame::quality
int quality
quality (between 1 (good) and FF_LAMBDA_MAX (bad))
Definition: frame.h:453
FF_CMP_W53
#define FF_CMP_W53
Definition: avcodec.h:790
Plane::last_hcoeff
int8_t last_hcoeff[HTAPS_MAX/2]
Definition: snow.h:112
size
int size
Definition: twinvq_data.h:10344
ff_build_rac_states
void ff_build_rac_states(RangeCoder *c, int factor, int max_p)
Definition: rangecoder.c:68
encode_q_branch
static int encode_q_branch(SnowContext *s, int level, int x, int y)
Definition: snowenc.c:218
SubBand
Definition: cfhd.h:109
FF_CMP_SATD
#define FF_CMP_SATD
Definition: avcodec.h:781
AV_CODEC_FLAG_PASS2
#define AV_CODEC_FLAG_PASS2
Use internal 2pass ratecontrol in second pass mode.
Definition: avcodec.h:235
height
#define height
Plane::htaps
int htaps
Definition: snow.h:106
Plane::last_htaps
int last_htaps
Definition: snow.h:111
Plane::width
int width
Definition: cfhd.h:119
snow_dwt.h
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:379
FF_CMP_SAD
#define FF_CMP_SAD
Definition: avcodec.h:779
encode_q_branch2
static void encode_q_branch2(SnowContext *s, int level, int x, int y)
Definition: snowenc.c:446
ff_snow_encoder
const AVCodec ff_snow_encoder
Definition: snowenc.c:1915
ff_get_mb_score
int ff_get_mb_score(struct MpegEncContext *s, int mx, int my, int src_index, int ref_index, int size, int h, int add_rate)
Definition: motion_est_template.c:192
ff_quant3bA
const int8_t ff_quant3bA[256]
Definition: snowdata.h:104
Plane::hcoeff
int8_t hcoeff[HTAPS_MAX/2]
Definition: snow.h:107
DWTELEM
int DWTELEM
Definition: dirac_dwt.h:26
ff_obmc_tab
const uint8_t *const ff_obmc_tab[4]
Definition: snowdata.h:123
av_assert2
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:64
FMT_H263
@ FMT_H263
Definition: mpegutils.h:125
ENCODER_EXTRA_BITS
#define ENCODER_EXTRA_BITS
Definition: snow.h:77
log.h
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:271
pred_mv
static void pred_mv(DiracBlock *block, int stride, int x, int y, int ref)
Definition: diracdec.c:1390
FF_CMP_RD
#define FF_CMP_RD
Definition: avcodec.h:785
get_block_bits
static int get_block_bits(SnowContext *s, int x, int y, int w)
Definition: snowenc.c:560
FF_CODEC_CAP_INIT_CLEANUP
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: internal.h:50
ff_square_tab
const uint32_t ff_square_tab[512]
Definition: me_cmp.c:34
BLOCK_INTRA
#define BLOCK_INTRA
Intra block, inter otherwise.
Definition: snow.h:60
get_block_rd
static int get_block_rd(SnowContext *s, int mb_x, int mb_y, int plane_index, uint8_t(*obmc_edged)[MB_SIZE *2])
Definition: snowenc.c:598
av_assert1
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:53
qscale2qlog
static int qscale2qlog(int qscale)
Definition: snowenc.c:1473
av_always_inline
#define av_always_inline
Definition: attributes.h:49
value
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 default value
Definition: writing_filters.txt:86
AVCodecContext::dia_size
int dia_size
ME diamond size & shape.
Definition: avcodec.h:802
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
FF_CMP_NSSE
#define FF_CMP_NSSE
Definition: avcodec.h:789
AVCodecContext::mb_lmin
int mb_lmin
minimum MB Lagrange multiplier
Definition: avcodec.h:905
tb
#define tb
Definition: regdef.h:68
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:263
ff_qexp
const uint8_t ff_qexp[QROOT]
Definition: snowdata.h:128
predict_plane
static av_always_inline void predict_plane(SnowContext *s, IDWTELEM *buf, int plane_index, int add)
Definition: snow.h:458
pix_sum
static int pix_sum(uint8_t *pix, int line_size, int w, int h)
Definition: snowenc.c:154
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:209
ff_snow_frame_start
int ff_snow_frame_start(SnowContext *s)
Definition: snow.c:651
put_symbol2
static void put_symbol2(RangeCoder *c, uint8_t *state, int v, int log2)
Definition: snow.h:566
ff_init_me
int ff_init_me(MpegEncContext *s)
Definition: motion_est.c:306
AVCodecContext::height
int height
Definition: avcodec.h:556
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:593
ff_rate_control_uninit
av_cold void ff_rate_control_uninit(MpegEncContext *s)
Definition: ratecontrol.c:672
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:271
log2
#define log2(x)
Definition: libm.h:404
avcodec.h
stride
#define stride
Definition: h264pred_template.c:537
mid_pred
#define mid_pred
Definition: mathops.h:97
ret
ret
Definition: filter_design.txt:187
pred
static const float pred[4]
Definition: siprdata.h:259
search
static float search(FOCContext *foc, int pass, int maxpass, int xmin, int xmax, int ymin, int ymax, int *best_x, int *best_y, float best_score)
Definition: vf_find_rect.c:146
AVClass::class_name
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:71
encode_init
static av_cold int encode_init(AVCodecContext *avctx)
Definition: snowenc.c:39
options
static const AVOption options[]
Definition: snowenc.c:1886
square
static int square(int x)
Definition: roqvideoenc.c:195
left
Tag MUST be and< 10hcoeff half pel interpolation filter coefficients, hcoeff[0] are the 2 middle coefficients[1] are the next outer ones and so on, resulting in a filter like:...eff[2], hcoeff[1], hcoeff[0], hcoeff[0], hcoeff[1], hcoeff[2] ... the sign of the coefficients is not explicitly stored but alternates after each coeff and coeff[0] is positive, so ...,+,-,+,-,+,+,-,+,-,+,... hcoeff[0] is not explicitly stored but found by subtracting the sum of all stored coefficients with signs from 32 hcoeff[0]=32 - hcoeff[1] - hcoeff[2] - ... a good choice for hcoeff and htaps is htaps=6 hcoeff={40,-10, 2} an alternative which requires more computations at both encoder and decoder side and may or may not be better is htaps=8 hcoeff={42,-14, 6,-2}ref_frames minimum of the number of available reference frames and max_ref_frames for example the first frame after a key frame always has ref_frames=1spatial_decomposition_type wavelet type 0 is a 9/7 symmetric compact integer wavelet 1 is a 5/3 symmetric compact integer wavelet others are reserved stored as delta from last, last is reset to 0 if always_reset||keyframeqlog quality(logarithmic quantizer scale) stored as delta from last, last is reset to 0 if always_reset||keyframemv_scale stored as delta from last, last is reset to 0 if always_reset||keyframe FIXME check that everything works fine if this changes between framesqbias dequantization bias stored as delta from last, last is reset to 0 if always_reset||keyframeblock_max_depth maximum depth of the block tree stored as delta from last, last is reset to 0 if always_reset||keyframequant_table quantization tableHighlevel bitstream structure:==============================--------------------------------------------|Header|--------------------------------------------|------------------------------------|||Block0||||split?||||yes no||||......... intra?||||:Block01 :yes no||||:Block02 :....... ..........||||:Block03 ::y DC ::ref index:||||:Block04 ::cb DC ::motion x :||||......... :cr DC ::motion y :||||....... ..........|||------------------------------------||------------------------------------|||Block1|||...|--------------------------------------------|------------ ------------ ------------|||Y subbands||Cb subbands||Cr subbands||||--- ---||--- ---||--- ---|||||LL0||HL0||||LL0||HL0||||LL0||HL0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||LH0||HH0||||LH0||HH0||||LH0||HH0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HL1||LH1||||HL1||LH1||||HL1||LH1|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HH1||HL2||||HH1||HL2||||HH1||HL2|||||...||...||...|||------------ ------------ ------------|--------------------------------------------Decoding process:=================------------|||Subbands|------------||||------------|Intra DC||||LL0 subband prediction ------------|\ Dequantization ------------------- \||Reference frames|\ IDWT|------- -------|Motion \|||Frame 0||Frame 1||Compensation . OBMC v -------|------- -------|--------------. \------> Frame n output Frame Frame<----------------------------------/|...|------------------- Range Coder:============Binary Range Coder:------------------- The implemented range coder is an adapted version based upon "Range encoding: an algorithm for removing redundancy from a digitised message." by G. N. N. Martin. The symbols encoded by the Snow range coder are bits(0|1). The associated probabilities are not fix but change depending on the symbol mix seen so far. bit seen|new state ---------+----------------------------------------------- 0|256 - state_transition_table[256 - old_state];1|state_transition_table[old_state];state_transition_table={ 0, 0, 0, 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 190, 191, 192, 194, 194, 195, 196, 197, 198, 199, 200, 201, 202, 202, 204, 205, 206, 207, 208, 209, 209, 210, 211, 212, 213, 215, 215, 216, 217, 218, 219, 220, 220, 222, 223, 224, 225, 226, 227, 227, 229, 229, 230, 231, 232, 234, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 248, 0, 0, 0, 0, 0, 0, 0};FIXME Range Coding of integers:------------------------- FIXME Neighboring Blocks:===================left and top are set to the respective blocks unless they are outside of the image in which case they are set to the Null block top-left is set to the top left block unless it is outside of the image in which case it is set to the left block if this block has no larger parent block or it is at the left side of its parent block and the top right block is not outside of the image then the top right block is used for top-right else the top-left block is used Null block y, cb, cr are 128 level, ref, mx and my are 0 Motion Vector Prediction:=========================1. the motion vectors of all the neighboring blocks are scaled to compensate for the difference of reference frames scaled_mv=(mv *(256 *(current_reference+1)/(mv.reference+1))+128)> the median of the scaled left
Definition: snow.txt:386
put_rac
#define put_rac(C, S, B)
ff_snow_reset_contexts
void ff_snow_reset_contexts(SnowContext *s)
Definition: snow.c:96
encode_qlogs
static void encode_qlogs(SnowContext *s)
Definition: snowenc.c:1367
AVCodecContext
main external API structure.
Definition: avcodec.h:383
AV_CODEC_ID_SNOW
@ AV_CODEC_ID_SNOW
Definition: codec_id.h:262
EDGE_TOP
#define EDGE_TOP
Definition: mpegvideoencdsp.h:29
t2
#define t2
Definition: regdef.h:30
ME_CACHE_SIZE
#define ME_CACHE_SIZE
Definition: snow.h:174
FRAC_BITS
#define FRAC_BITS
Definition: g729postfilter.c:36
inverse
static int inverse(AudioFWTDNContext *s, double **in, int *in_length, double *out, int out_length, int ch, uint64_t sn)
Definition: af_afwtdn.c:762
check_4block_inter
static av_always_inline int check_4block_inter(SnowContext *s, int mb_x, int mb_y, int p0, int p1, int ref, int *best_rd)
Definition: snowenc.c:941
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:224
get_4block_rd
static int get_4block_rd(SnowContext *s, int mb_x, int mb_y, int plane_index)
Definition: snowenc.c:699
FF_CMP_DCT
#define FF_CMP_DCT
Definition: avcodec.h:782
ref
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:107
get_rac_count
static int get_rac_count(RangeCoder *c)
Definition: rangecoder.h:87
AVCodecContext::mb_lmax
int mb_lmax
maximum MB Lagrange multiplier
Definition: avcodec.h:912
Plane
Definition: cfhd.h:118
av_clip_uint8
#define av_clip_uint8
Definition: common.h:102
AV_PIX_FMT_YUV444P
@ AV_PIX_FMT_YUV444P
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:71
shift
static int shift(int a, int b)
Definition: sonic.c:84
BlockNode::level
uint8_t level
Definition: snow.h:63
AV_PICTURE_TYPE_P
@ AV_PICTURE_TYPE_P
Predicted.
Definition: avutil.h:275
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
same_block
static av_always_inline int same_block(BlockNode *a, BlockNode *b)
Definition: snow.h:273
packet_internal.h
Plane::band
SubBand band[DWT_LEVELS_3D][4]
Definition: cfhd.h:131
BlockNode::mx
int16_t mx
Motion vector component X, see mv_scale.
Definition: snow.h:54
AVCodecContext::frame_number
int frame_number
Frame counter, set by libavcodec.
Definition: avcodec.h:1023
AVPacket
This structure stores compressed data.
Definition: packet.h:350
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:410
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Definition: opt.h:241
cr
static double cr(void *priv, double x, double y)
Definition: vf_geq.c:216
FF_CMP_DCT264
#define FF_CMP_DCT264
Definition: avcodec.h:793
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
src
INIT_CLIP pixel * src
Definition: h264pred_template.c:418
quantize
static void quantize(SnowContext *s, SubBand *b, IDWTELEM *dst, DWTELEM *src, int stride, int bias)
Definition: snowenc.c:1236
dequantize
static void dequantize(SnowContext *s, SubBand *b, IDWTELEM *src, int stride)
Definition: snowenc.c:1297
ratecontrol_1pass
static int ratecontrol_1pass(SnowContext *s, AVFrame *pict)
Definition: snowenc.c:1478
d
d
Definition: ffmpeg_filter.c:153
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:556
null_block
static const BlockNode null_block
Definition: snow.h:66
AVFrame::linesize
int linesize[AV_NUM_DATA_POINTERS]
For video, a positive or negative value, which is typically indicating the size in bytes of each pict...
Definition: frame.h:362
AV_PIX_FMT_YUV410P
@ AV_PIX_FMT_YUV410P
planar YUV 4:1:0, 9bpp, (1 Cr & Cb sample per 4x4 Y samples)
Definition: pixfmt.h:72
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
ff_w53_32_c
int ff_w53_32_c(struct MpegEncContext *v, uint8_t *pix1, uint8_t *pix2, ptrdiff_t line_size, int h)
Definition: snow_dwt.c:832
IDWTELEM
short IDWTELEM
Definition: dirac_dwt.h:27
pix_norm1
static int pix_norm1(uint8_t *pix, int line_size, int w)
Definition: snowenc.c:170
h
h
Definition: vp9dsp_template.c:2038
RangeCoder
Definition: mss3.c:61
snowenc_class
static const AVClass snowenc_class
Definition: snowenc.c:1908
AV_OPT_TYPE_STRING
@ AV_OPT_TYPE_STRING
Definition: opt.h:228
FF_QP2LAMBDA
#define FF_QP2LAMBDA
factor to convert from H.263 QP to lambda
Definition: avutil.h:227
check_block
static av_always_inline int check_block(SnowContext *s, int mb_x, int mb_y, int p[3], int intra, uint8_t(*obmc_edged)[MB_SIZE *2], int *best_rd)
Definition: snowenc.c:895
int
int
Definition: ffmpeg_filter.c:153
P_TOP
#define P_TOP
Definition: snowenc.c:212
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Definition: opt.h:233
ff_snow_alloc_blocks
int ff_snow_alloc_blocks(SnowContext *s)
Definition: snow.c:110
av_log2
int av_log2(unsigned v)
Definition: intmath.c:26
ff_alloc_packet
int ff_alloc_packet(AVCodecContext *avctx, AVPacket *avpkt, int64_t size)
Check AVPacket size and allocate data.
Definition: encode.c:34
BlockNode::ref
uint8_t ref
Reference frame index.
Definition: snow.h:56
P_TOPRIGHT
#define P_TOPRIGHT
Definition: snowenc.c:213
AV_CODEC_FLAG_PASS1
#define AV_CODEC_FLAG_PASS1
Use internal 2pass ratecontrol in first pass mode.
Definition: avcodec.h:231
P_MEDIAN
#define P_MEDIAN
Definition: snowenc.c:214
FF_ME_ZERO
#define FF_ME_ZERO
Definition: motion_est.h:40
FF_CMP_W97
#define FF_CMP_W97
Definition: avcodec.h:791
h263.h
intmath.h
Generated on Mon Jan 24 2022 19:21:40 for FFmpeg by   doxygen 1.8.17