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/log.h"
23 #include "libavutil/opt.h"
24 #include "avcodec.h"
25 #include "internal.h"
26 #include "dsputil.h"
27 #include "internal.h"
28 #include "snow_dwt.h"
29 #include "snow.h"
30 
31 #include "rangecoder.h"
32 #include "mathops.h"
33 
34 #include "mpegvideo.h"
35 #include "h263.h"
36 
37 #undef NDEBUG
38 #include <assert.h>
39 
40 #define QUANTIZE2 0
41 
42 #if QUANTIZE2==1
43 #define Q2_STEP 8
44 
45 static void find_sse(SnowContext *s, Plane *p, int *score, int score_stride, IDWTELEM *r0, IDWTELEM *r1, int level, int orientation){
46  SubBand *b= &p->band[level][orientation];
47  int x, y;
48  int xo=0;
49  int yo=0;
50  int step= 1 << (s->spatial_decomposition_count - level);
51 
52  if(orientation&1)
53  xo= step>>1;
54  if(orientation&2)
55  yo= step>>1;
56 
57  //FIXME bias for nonzero ?
58  //FIXME optimize
59  memset(score, 0, sizeof(*score)*score_stride*((p->height + Q2_STEP-1)/Q2_STEP));
60  for(y=0; y<p->height; y++){
61  for(x=0; x<p->width; x++){
62  int sx= (x-xo + step/2) / step / Q2_STEP;
63  int sy= (y-yo + step/2) / step / Q2_STEP;
64  int v= r0[x + y*p->width] - r1[x + y*p->width];
65  assert(sx>=0 && sy>=0 && sx < score_stride);
66  v= ((v+8)>>4)<<4;
67  score[sx + sy*score_stride] += v*v;
68  assert(score[sx + sy*score_stride] >= 0);
69  }
70  }
71 }
72 
73 static void dequantize_all(SnowContext *s, Plane *p, IDWTELEM *buffer, int width, int height){
74  int level, orientation;
75 
76  for(level=0; level<s->spatial_decomposition_count; level++){
77  for(orientation=level ? 1 : 0; orientation<4; orientation++){
78  SubBand *b= &p->band[level][orientation];
79  IDWTELEM *dst= buffer + (b->ibuf - s->spatial_idwt_buffer);
80 
81  dequantize(s, b, dst, b->stride);
82  }
83  }
84 }
85 
86 static void dwt_quantize(SnowContext *s, Plane *p, DWTELEM *buffer, int width, int height, int stride, int type){
87  int level, orientation, ys, xs, x, y, pass;
88  IDWTELEM best_dequant[height * stride];
89  IDWTELEM idwt2_buffer[height * stride];
90  const int score_stride= (width + 10)/Q2_STEP;
91  int best_score[(width + 10)/Q2_STEP * (height + 10)/Q2_STEP]; //FIXME size
92  int score[(width + 10)/Q2_STEP * (height + 10)/Q2_STEP]; //FIXME size
93  int threshold= (s->m.lambda * s->m.lambda) >> 6;
94 
95  //FIXME pass the copy cleanly ?
96 
97 // memcpy(dwt_buffer, buffer, height * stride * sizeof(DWTELEM));
98  ff_spatial_dwt(buffer, s->temp_dwt_buffer, width, height, stride, type, s->spatial_decomposition_count);
99 
100  for(level=0; level<s->spatial_decomposition_count; level++){
101  for(orientation=level ? 1 : 0; orientation<4; orientation++){
102  SubBand *b= &p->band[level][orientation];
103  IDWTELEM *dst= best_dequant + (b->ibuf - s->spatial_idwt_buffer);
104  DWTELEM *src= buffer + (b-> buf - s->spatial_dwt_buffer);
105  assert(src == b->buf); // code does not depend on this but it is true currently
106 
107  quantize(s, b, dst, src, b->stride, s->qbias);
108  }
109  }
110  for(pass=0; pass<1; pass++){
111  if(s->qbias == 0) //keyframe
112  continue;
113  for(level=0; level<s->spatial_decomposition_count; level++){
114  for(orientation=level ? 1 : 0; orientation<4; orientation++){
115  SubBand *b= &p->band[level][orientation];
116  IDWTELEM *dst= idwt2_buffer + (b->ibuf - s->spatial_idwt_buffer);
117  IDWTELEM *best_dst= best_dequant + (b->ibuf - s->spatial_idwt_buffer);
118 
119  for(ys= 0; ys<Q2_STEP; ys++){
120  for(xs= 0; xs<Q2_STEP; xs++){
121  memcpy(idwt2_buffer, best_dequant, height * stride * sizeof(IDWTELEM));
122  dequantize_all(s, p, idwt2_buffer, width, height);
123  ff_spatial_idwt(idwt2_buffer, s->temp_idwt_buffer, width, height, stride, type, s->spatial_decomposition_count);
124  find_sse(s, p, best_score, score_stride, idwt2_buffer, s->spatial_idwt_buffer, level, orientation);
125  memcpy(idwt2_buffer, best_dequant, height * stride * sizeof(IDWTELEM));
126  for(y=ys; y<b->height; y+= Q2_STEP){
127  for(x=xs; x<b->width; x+= Q2_STEP){
128  if(dst[x + y*b->stride]<0) dst[x + y*b->stride]++;
129  if(dst[x + y*b->stride]>0) dst[x + y*b->stride]--;
130  //FIXME try more than just --
131  }
132  }
133  dequantize_all(s, p, idwt2_buffer, width, height);
134  ff_spatial_idwt(idwt2_buffer, s->temp_idwt_buffer, width, height, stride, type, s->spatial_decomposition_count);
135  find_sse(s, p, score, score_stride, idwt2_buffer, s->spatial_idwt_buffer, level, orientation);
136  for(y=ys; y<b->height; y+= Q2_STEP){
137  for(x=xs; x<b->width; x+= Q2_STEP){
138  int score_idx= x/Q2_STEP + (y/Q2_STEP)*score_stride;
139  if(score[score_idx] <= best_score[score_idx] + threshold){
140  best_score[score_idx]= score[score_idx];
141  if(best_dst[x + y*b->stride]<0) best_dst[x + y*b->stride]++;
142  if(best_dst[x + y*b->stride]>0) best_dst[x + y*b->stride]--;
143  //FIXME copy instead
144  }
145  }
146  }
147  }
148  }
149  }
150  }
151  }
152  memcpy(s->spatial_idwt_buffer, best_dequant, height * stride * sizeof(IDWTELEM)); //FIXME work with that directly instead of copy at the end
153 }
154 
155 #endif /* QUANTIZE2==1 */
156 
157 static av_cold int encode_init(AVCodecContext *avctx)
158 {
159  SnowContext *s = avctx->priv_data;
160  int plane_index, ret;
161 
162  if(avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL){
163  av_log(avctx, AV_LOG_ERROR, "This codec is under development, files encoded with it may not be decodable with future versions!!!\n"
164  "Use vstrict=-2 / -strict -2 to use it anyway.\n");
165  return -1;
166  }
167 
168  if(avctx->prediction_method == DWT_97
169  && (avctx->flags & CODEC_FLAG_QSCALE)
170  && avctx->global_quality == 0){
171  av_log(avctx, AV_LOG_ERROR, "The 9/7 wavelet is incompatible with lossless mode.\n");
172  return -1;
173  }
174 
175  s->spatial_decomposition_type= avctx->prediction_method; //FIXME add decorrelator type r transform_type
176 
177  s->mv_scale = (avctx->flags & CODEC_FLAG_QPEL) ? 2 : 4;
178  s->block_max_depth= (avctx->flags & CODEC_FLAG_4MV ) ? 1 : 0;
179 
180  for(plane_index=0; plane_index<3; plane_index++){
181  s->plane[plane_index].diag_mc= 1;
182  s->plane[plane_index].htaps= 6;
183  s->plane[plane_index].hcoeff[0]= 40;
184  s->plane[plane_index].hcoeff[1]= -10;
185  s->plane[plane_index].hcoeff[2]= 2;
186  s->plane[plane_index].fast_mc= 1;
187  }
188 
189  if ((ret = ff_snow_common_init(avctx)) < 0) {
190  ff_snow_common_end(avctx->priv_data);
191  return ret;
192  }
193  ff_snow_alloc_blocks(s);
194 
195  s->version=0;
196 
197  s->m.avctx = avctx;
198  s->m.flags = avctx->flags;
199  s->m.bit_rate= avctx->bit_rate;
200 
201  s->m.me.temp =
202  s->m.me.scratchpad= av_mallocz((avctx->width+64)*2*16*2*sizeof(uint8_t));
203  s->m.me.map = av_mallocz(ME_MAP_SIZE*sizeof(uint32_t));
204  s->m.me.score_map = av_mallocz(ME_MAP_SIZE*sizeof(uint32_t));
205  s->m.obmc_scratchpad= av_mallocz(MB_SIZE*MB_SIZE*12*sizeof(uint32_t));
206  ff_h263_encode_init(&s->m); //mv_penalty
207 
208  s->max_ref_frames = FFMAX(FFMIN(avctx->refs, MAX_REF_FRAMES), 1);
209 
210  if(avctx->flags&CODEC_FLAG_PASS1){
211  if(!avctx->stats_out)
212  avctx->stats_out = av_mallocz(256);
213  }
214  if((avctx->flags&CODEC_FLAG_PASS2) || !(avctx->flags&CODEC_FLAG_QSCALE)){
215  if(ff_rate_control_init(&s->m) < 0)
216  return -1;
217  }
218  s->pass1_rc= !(avctx->flags & (CODEC_FLAG_QSCALE|CODEC_FLAG_PASS2));
219 
220  avctx->coded_frame= &s->current_picture;
221  switch(avctx->pix_fmt){
222  case AV_PIX_FMT_YUV444P:
223 // case AV_PIX_FMT_YUV422P:
224  case AV_PIX_FMT_YUV420P:
225 // case AV_PIX_FMT_GRAY8:
226 // case AV_PIX_FMT_YUV411P:
227  case AV_PIX_FMT_YUV410P:
228  s->colorspace_type= 0;
229  break;
230 /* case AV_PIX_FMT_RGB32:
231  s->colorspace= 1;
232  break;*/
233  default:
234  av_log(avctx, AV_LOG_ERROR, "pixel format not supported\n");
235  return -1;
236  }
237  avcodec_get_chroma_sub_sample(avctx->pix_fmt, &s->chroma_h_shift, &s->chroma_v_shift);
238 
239  ff_set_cmp(&s->dsp, s->dsp.me_cmp, s->avctx->me_cmp);
240  ff_set_cmp(&s->dsp, s->dsp.me_sub_cmp, s->avctx->me_sub_cmp);
241 
242  if ((ret = ff_get_buffer(s->avctx, &s->input_picture, AV_GET_BUFFER_FLAG_REF)) < 0)
243  return ret;
244 
245  if(s->avctx->me_method == ME_ITER){
246  int i;
247  int size= s->b_width * s->b_height << 2*s->block_max_depth;
248  for(i=0; i<s->max_ref_frames; i++){
249  s->ref_mvs[i]= av_mallocz(size*sizeof(int16_t[2]));
250  s->ref_scores[i]= av_mallocz(size*sizeof(uint32_t));
251  }
252  }
253 
254  return 0;
255 }
256 
257 //near copy & paste from dsputil, FIXME
258 static int pix_sum(uint8_t * pix, int line_size, int w, int h)
259 {
260  int s, i, j;
261 
262  s = 0;
263  for (i = 0; i < h; i++) {
264  for (j = 0; j < w; j++) {
265  s += pix[0];
266  pix ++;
267  }
268  pix += line_size - w;
269  }
270  return s;
271 }
272 
273 //near copy & paste from dsputil, FIXME
274 static int pix_norm1(uint8_t * pix, int line_size, int w)
275 {
276  int s, i, j;
277  uint32_t *sq = ff_squareTbl + 256;
278 
279  s = 0;
280  for (i = 0; i < w; i++) {
281  for (j = 0; j < w; j ++) {
282  s += sq[pix[0]];
283  pix ++;
284  }
285  pix += line_size - w;
286  }
287  return s;
288 }
289 
290 static inline int get_penalty_factor(int lambda, int lambda2, int type){
291  switch(type&0xFF){
292  default:
293  case FF_CMP_SAD:
294  return lambda>>FF_LAMBDA_SHIFT;
295  case FF_CMP_DCT:
296  return (3*lambda)>>(FF_LAMBDA_SHIFT+1);
297  case FF_CMP_W53:
298  return (4*lambda)>>(FF_LAMBDA_SHIFT);
299  case FF_CMP_W97:
300  return (2*lambda)>>(FF_LAMBDA_SHIFT);
301  case FF_CMP_SATD:
302  case FF_CMP_DCT264:
303  return (2*lambda)>>FF_LAMBDA_SHIFT;
304  case FF_CMP_RD:
305  case FF_CMP_PSNR:
306  case FF_CMP_SSE:
307  case FF_CMP_NSSE:
308  return lambda2>>FF_LAMBDA_SHIFT;
309  case FF_CMP_BIT:
310  return 1;
311  }
312 }
313 
314 //FIXME copy&paste
315 #define P_LEFT P[1]
316 #define P_TOP P[2]
317 #define P_TOPRIGHT P[3]
318 #define P_MEDIAN P[4]
319 #define P_MV1 P[9]
320 #define FLAG_QPEL 1 //must be 1
321 
322 static int encode_q_branch(SnowContext *s, int level, int x, int y){
323  uint8_t p_buffer[1024];
324  uint8_t i_buffer[1024];
325  uint8_t p_state[sizeof(s->block_state)];
326  uint8_t i_state[sizeof(s->block_state)];
327  RangeCoder pc, ic;
328  uint8_t *pbbak= s->c.bytestream;
329  uint8_t *pbbak_start= s->c.bytestream_start;
330  int score, score2, iscore, i_len, p_len, block_s, sum, base_bits;
331  const int w= s->b_width << s->block_max_depth;
332  const int h= s->b_height << s->block_max_depth;
333  const int rem_depth= s->block_max_depth - level;
334  const int index= (x + y*w) << rem_depth;
335  const int block_w= 1<<(LOG2_MB_SIZE - level);
336  int trx= (x+1)<<rem_depth;
337  int try= (y+1)<<rem_depth;
338  const BlockNode *left = x ? &s->block[index-1] : &null_block;
339  const BlockNode *top = y ? &s->block[index-w] : &null_block;
340  const BlockNode *right = trx<w ? &s->block[index+1] : &null_block;
341  const BlockNode *bottom= try<h ? &s->block[index+w] : &null_block;
342  const BlockNode *tl = y && x ? &s->block[index-w-1] : left;
343  const BlockNode *tr = y && trx<w && ((x&1)==0 || level==0) ? &s->block[index-w+(1<<rem_depth)] : tl; //FIXME use lt
344  int pl = left->color[0];
345  int pcb= left->color[1];
346  int pcr= left->color[2];
347  int pmx, pmy;
348  int mx=0, my=0;
349  int l,cr,cb;
350  const int stride= s->current_picture.linesize[0];
351  const int uvstride= s->current_picture.linesize[1];
352  uint8_t *current_data[3]= { s->input_picture.data[0] + (x + y* stride)*block_w,
353  s->input_picture.data[1] + ((x*block_w)>>s->chroma_h_shift) + ((y*uvstride*block_w)>>s->chroma_v_shift),
354  s->input_picture.data[2] + ((x*block_w)>>s->chroma_h_shift) + ((y*uvstride*block_w)>>s->chroma_v_shift)};
355  int P[10][2];
356  int16_t last_mv[3][2];
357  int qpel= !!(s->avctx->flags & CODEC_FLAG_QPEL); //unused
358  const int shift= 1+qpel;
359  MotionEstContext *c= &s->m.me;
360  int ref_context= av_log2(2*left->ref) + av_log2(2*top->ref);
361  int mx_context= av_log2(2*FFABS(left->mx - top->mx));
362  int my_context= av_log2(2*FFABS(left->my - top->my));
363  int s_context= 2*left->level + 2*top->level + tl->level + tr->level;
364  int ref, best_ref, ref_score, ref_mx, ref_my;
365 
366  assert(sizeof(s->block_state) >= 256);
367  if(s->keyframe){
368  set_blocks(s, level, x, y, pl, pcb, pcr, 0, 0, 0, BLOCK_INTRA);
369  return 0;
370  }
371 
372 // clip predictors / edge ?
373 
374  P_LEFT[0]= left->mx;
375  P_LEFT[1]= left->my;
376  P_TOP [0]= top->mx;
377  P_TOP [1]= top->my;
378  P_TOPRIGHT[0]= tr->mx;
379  P_TOPRIGHT[1]= tr->my;
380 
381  last_mv[0][0]= s->block[index].mx;
382  last_mv[0][1]= s->block[index].my;
383  last_mv[1][0]= right->mx;
384  last_mv[1][1]= right->my;
385  last_mv[2][0]= bottom->mx;
386  last_mv[2][1]= bottom->my;
387 
388  s->m.mb_stride=2;
389  s->m.mb_x=
390  s->m.mb_y= 0;
391  c->skip= 0;
392 
393  assert(c-> stride == stride);
394  assert(c->uvstride == uvstride);
395 
396  c->penalty_factor = get_penalty_factor(s->lambda, s->lambda2, c->avctx->me_cmp);
397  c->sub_penalty_factor= get_penalty_factor(s->lambda, s->lambda2, c->avctx->me_sub_cmp);
398  c->mb_penalty_factor = get_penalty_factor(s->lambda, s->lambda2, c->avctx->mb_cmp);
399  c->current_mv_penalty= c->mv_penalty[s->m.f_code=1] + MAX_MV;
400 
401  c->xmin = - x*block_w - 16+3;
402  c->ymin = - y*block_w - 16+3;
403  c->xmax = - (x+1)*block_w + (w<<(LOG2_MB_SIZE - s->block_max_depth)) + 16-3;
404  c->ymax = - (y+1)*block_w + (h<<(LOG2_MB_SIZE - s->block_max_depth)) + 16-3;
405 
406  if(P_LEFT[0] > (c->xmax<<shift)) P_LEFT[0] = (c->xmax<<shift);
407  if(P_LEFT[1] > (c->ymax<<shift)) P_LEFT[1] = (c->ymax<<shift);
408  if(P_TOP[0] > (c->xmax<<shift)) P_TOP[0] = (c->xmax<<shift);
409  if(P_TOP[1] > (c->ymax<<shift)) P_TOP[1] = (c->ymax<<shift);
410  if(P_TOPRIGHT[0] < (c->xmin<<shift)) P_TOPRIGHT[0]= (c->xmin<<shift);
411  if(P_TOPRIGHT[0] > (c->xmax<<shift)) P_TOPRIGHT[0]= (c->xmax<<shift); //due to pmx no clip
412  if(P_TOPRIGHT[1] > (c->ymax<<shift)) P_TOPRIGHT[1]= (c->ymax<<shift);
413 
414  P_MEDIAN[0]= mid_pred(P_LEFT[0], P_TOP[0], P_TOPRIGHT[0]);
415  P_MEDIAN[1]= mid_pred(P_LEFT[1], P_TOP[1], P_TOPRIGHT[1]);
416 
417  if (!y) {
418  c->pred_x= P_LEFT[0];
419  c->pred_y= P_LEFT[1];
420  } else {
421  c->pred_x = P_MEDIAN[0];
422  c->pred_y = P_MEDIAN[1];
423  }
424 
425  score= INT_MAX;
426  best_ref= 0;
427  for(ref=0; ref<s->ref_frames; ref++){
428  init_ref(c, current_data, s->last_picture[ref].data, NULL, block_w*x, block_w*y, 0);
429 
430  ref_score= ff_epzs_motion_search(&s->m, &ref_mx, &ref_my, P, 0, /*ref_index*/ 0, last_mv,
431  (1<<16)>>shift, level-LOG2_MB_SIZE+4, block_w);
432 
433  assert(ref_mx >= c->xmin);
434  assert(ref_mx <= c->xmax);
435  assert(ref_my >= c->ymin);
436  assert(ref_my <= c->ymax);
437 
438  ref_score= c->sub_motion_search(&s->m, &ref_mx, &ref_my, ref_score, 0, 0, level-LOG2_MB_SIZE+4, block_w);
439  ref_score= ff_get_mb_score(&s->m, ref_mx, ref_my, 0, 0, level-LOG2_MB_SIZE+4, block_w, 0);
440  ref_score+= 2*av_log2(2*ref)*c->penalty_factor;
441  if(s->ref_mvs[ref]){
442  s->ref_mvs[ref][index][0]= ref_mx;
443  s->ref_mvs[ref][index][1]= ref_my;
444  s->ref_scores[ref][index]= ref_score;
445  }
446  if(score > ref_score){
447  score= ref_score;
448  best_ref= ref;
449  mx= ref_mx;
450  my= ref_my;
451  }
452  }
453  //FIXME if mb_cmp != SSE then intra cannot be compared currently and mb_penalty vs. lambda2
454 
455  // subpel search
456  base_bits= get_rac_count(&s->c) - 8*(s->c.bytestream - s->c.bytestream_start);
457  pc= s->c;
458  pc.bytestream_start=
459  pc.bytestream= p_buffer; //FIXME end/start? and at the other stoo
460  memcpy(p_state, s->block_state, sizeof(s->block_state));
461 
462  if(level!=s->block_max_depth)
463  put_rac(&pc, &p_state[4 + s_context], 1);
464  put_rac(&pc, &p_state[1 + left->type + top->type], 0);
465  if(s->ref_frames > 1)
466  put_symbol(&pc, &p_state[128 + 1024 + 32*ref_context], best_ref, 0);
467  pred_mv(s, &pmx, &pmy, best_ref, left, top, tr);
468  put_symbol(&pc, &p_state[128 + 32*(mx_context + 16*!!best_ref)], mx - pmx, 1);
469  put_symbol(&pc, &p_state[128 + 32*(my_context + 16*!!best_ref)], my - pmy, 1);
470  p_len= pc.bytestream - pc.bytestream_start;
471  score += (s->lambda2*(get_rac_count(&pc)-base_bits))>>FF_LAMBDA_SHIFT;
472 
473  block_s= block_w*block_w;
474  sum = pix_sum(current_data[0], stride, block_w, block_w);
475  l= (sum + block_s/2)/block_s;
476  iscore = pix_norm1(current_data[0], stride, block_w) - 2*l*sum + l*l*block_s;
477 
478  block_s= block_w*block_w>>(s->chroma_h_shift + s->chroma_v_shift);
479  sum = pix_sum(current_data[1], uvstride, block_w>>s->chroma_h_shift, block_w>>s->chroma_v_shift);
480  cb= (sum + block_s/2)/block_s;
481 // iscore += pix_norm1(&current_mb[1][0], uvstride, block_w>>1) - 2*cb*sum + cb*cb*block_s;
482  sum = pix_sum(current_data[2], uvstride, block_w>>s->chroma_h_shift, block_w>>s->chroma_v_shift);
483  cr= (sum + block_s/2)/block_s;
484 // iscore += pix_norm1(&current_mb[2][0], uvstride, block_w>>1) - 2*cr*sum + cr*cr*block_s;
485 
486  ic= s->c;
487  ic.bytestream_start=
488  ic.bytestream= i_buffer; //FIXME end/start? and at the other stoo
489  memcpy(i_state, s->block_state, sizeof(s->block_state));
490  if(level!=s->block_max_depth)
491  put_rac(&ic, &i_state[4 + s_context], 1);
492  put_rac(&ic, &i_state[1 + left->type + top->type], 1);
493  put_symbol(&ic, &i_state[32], l-pl , 1);
494  put_symbol(&ic, &i_state[64], cb-pcb, 1);
495  put_symbol(&ic, &i_state[96], cr-pcr, 1);
496  i_len= ic.bytestream - ic.bytestream_start;
497  iscore += (s->lambda2*(get_rac_count(&ic)-base_bits))>>FF_LAMBDA_SHIFT;
498 
499 // assert(score==256*256*256*64-1);
500  assert(iscore < 255*255*256 + s->lambda2*10);
501  assert(iscore >= 0);
502  assert(l>=0 && l<=255);
503  assert(pl>=0 && pl<=255);
504 
505  if(level==0){
506  int varc= iscore >> 8;
507  int vard= score >> 8;
508  if (vard <= 64 || vard < varc)
509  c->scene_change_score+= ff_sqrt(vard) - ff_sqrt(varc);
510  else
511  c->scene_change_score+= s->m.qscale;
512  }
513 
514  if(level!=s->block_max_depth){
515  put_rac(&s->c, &s->block_state[4 + s_context], 0);
516  score2 = encode_q_branch(s, level+1, 2*x+0, 2*y+0);
517  score2+= encode_q_branch(s, level+1, 2*x+1, 2*y+0);
518  score2+= encode_q_branch(s, level+1, 2*x+0, 2*y+1);
519  score2+= encode_q_branch(s, level+1, 2*x+1, 2*y+1);
520  score2+= s->lambda2>>FF_LAMBDA_SHIFT; //FIXME exact split overhead
521 
522  if(score2 < score && score2 < iscore)
523  return score2;
524  }
525 
526  if(iscore < score){
527  pred_mv(s, &pmx, &pmy, 0, left, top, tr);
528  memcpy(pbbak, i_buffer, i_len);
529  s->c= ic;
530  s->c.bytestream_start= pbbak_start;
531  s->c.bytestream= pbbak + i_len;
532  set_blocks(s, level, x, y, l, cb, cr, pmx, pmy, 0, BLOCK_INTRA);
533  memcpy(s->block_state, i_state, sizeof(s->block_state));
534  return iscore;
535  }else{
536  memcpy(pbbak, p_buffer, p_len);
537  s->c= pc;
538  s->c.bytestream_start= pbbak_start;
539  s->c.bytestream= pbbak + p_len;
540  set_blocks(s, level, x, y, pl, pcb, pcr, mx, my, best_ref, 0);
541  memcpy(s->block_state, p_state, sizeof(s->block_state));
542  return score;
543  }
544 }
545 
546 static void encode_q_branch2(SnowContext *s, int level, int x, int y){
547  const int w= s->b_width << s->block_max_depth;
548  const int rem_depth= s->block_max_depth - level;
549  const int index= (x + y*w) << rem_depth;
550  int trx= (x+1)<<rem_depth;
551  BlockNode *b= &s->block[index];
552  const BlockNode *left = x ? &s->block[index-1] : &null_block;
553  const BlockNode *top = y ? &s->block[index-w] : &null_block;
554  const BlockNode *tl = y && x ? &s->block[index-w-1] : left;
555  const BlockNode *tr = y && trx<w && ((x&1)==0 || level==0) ? &s->block[index-w+(1<<rem_depth)] : tl; //FIXME use lt
556  int pl = left->color[0];
557  int pcb= left->color[1];
558  int pcr= left->color[2];
559  int pmx, pmy;
560  int ref_context= av_log2(2*left->ref) + av_log2(2*top->ref);
561  int mx_context= av_log2(2*FFABS(left->mx - top->mx)) + 16*!!b->ref;
562  int my_context= av_log2(2*FFABS(left->my - top->my)) + 16*!!b->ref;
563  int s_context= 2*left->level + 2*top->level + tl->level + tr->level;
564 
565  if(s->keyframe){
566  set_blocks(s, level, x, y, pl, pcb, pcr, 0, 0, 0, BLOCK_INTRA);
567  return;
568  }
569 
570  if(level!=s->block_max_depth){
571  if(same_block(b,b+1) && same_block(b,b+w) && same_block(b,b+w+1)){
572  put_rac(&s->c, &s->block_state[4 + s_context], 1);
573  }else{
574  put_rac(&s->c, &s->block_state[4 + s_context], 0);
575  encode_q_branch2(s, level+1, 2*x+0, 2*y+0);
576  encode_q_branch2(s, level+1, 2*x+1, 2*y+0);
577  encode_q_branch2(s, level+1, 2*x+0, 2*y+1);
578  encode_q_branch2(s, level+1, 2*x+1, 2*y+1);
579  return;
580  }
581  }
582  if(b->type & BLOCK_INTRA){
583  pred_mv(s, &pmx, &pmy, 0, left, top, tr);
584  put_rac(&s->c, &s->block_state[1 + (left->type&1) + (top->type&1)], 1);
585  put_symbol(&s->c, &s->block_state[32], b->color[0]-pl , 1);
586  put_symbol(&s->c, &s->block_state[64], b->color[1]-pcb, 1);
587  put_symbol(&s->c, &s->block_state[96], b->color[2]-pcr, 1);
588  set_blocks(s, level, x, y, b->color[0], b->color[1], b->color[2], pmx, pmy, 0, BLOCK_INTRA);
589  }else{
590  pred_mv(s, &pmx, &pmy, b->ref, left, top, tr);
591  put_rac(&s->c, &s->block_state[1 + (left->type&1) + (top->type&1)], 0);
592  if(s->ref_frames > 1)
593  put_symbol(&s->c, &s->block_state[128 + 1024 + 32*ref_context], b->ref, 0);
594  put_symbol(&s->c, &s->block_state[128 + 32*mx_context], b->mx - pmx, 1);
595  put_symbol(&s->c, &s->block_state[128 + 32*my_context], b->my - pmy, 1);
596  set_blocks(s, level, x, y, pl, pcb, pcr, b->mx, b->my, b->ref, 0);
597  }
598 }
599 
600 static int get_dc(SnowContext *s, int mb_x, int mb_y, int plane_index){
601  int i, x2, y2;
602  Plane *p= &s->plane[plane_index];
603  const int block_size = MB_SIZE >> s->block_max_depth;
604  const int block_w = plane_index ? block_size>>s->chroma_h_shift : block_size;
605  const int block_h = plane_index ? block_size>>s->chroma_v_shift : block_size;
606  const uint8_t *obmc = plane_index ? ff_obmc_tab[s->block_max_depth+s->chroma_h_shift] : ff_obmc_tab[s->block_max_depth];
607  const int obmc_stride= plane_index ? (2*block_size)>>s->chroma_h_shift : 2*block_size;
608  const int ref_stride= s->current_picture.linesize[plane_index];
609  uint8_t *src= s-> input_picture.data[plane_index];
610  IDWTELEM *dst= (IDWTELEM*)s->m.obmc_scratchpad + plane_index*block_size*block_size*4; //FIXME change to unsigned
611  const int b_stride = s->b_width << s->block_max_depth;
612  const int w= p->width;
613  const int h= p->height;
614  int index= mb_x + mb_y*b_stride;
615  BlockNode *b= &s->block[index];
616  BlockNode backup= *b;
617  int ab=0;
618  int aa=0;
619 
620  av_assert2(s->chroma_h_shift == s->chroma_v_shift); //obmc stuff above
621 
622  b->type|= BLOCK_INTRA;
623  b->color[plane_index]= 0;
624  memset(dst, 0, obmc_stride*obmc_stride*sizeof(IDWTELEM));
625 
626  for(i=0; i<4; i++){
627  int mb_x2= mb_x + (i &1) - 1;
628  int mb_y2= mb_y + (i>>1) - 1;
629  int x= block_w*mb_x2 + block_w/2;
630  int y= block_h*mb_y2 + block_h/2;
631 
632  add_yblock(s, 0, NULL, dst + (i&1)*block_w + (i>>1)*obmc_stride*block_h, NULL, obmc,
633  x, y, block_w, block_h, w, h, obmc_stride, ref_stride, obmc_stride, mb_x2, mb_y2, 0, 0, plane_index);
634 
635  for(y2= FFMAX(y, 0); y2<FFMIN(h, y+block_h); y2++){
636  for(x2= FFMAX(x, 0); x2<FFMIN(w, x+block_w); x2++){
637  int index= x2-(block_w*mb_x - block_w/2) + (y2-(block_h*mb_y - block_h/2))*obmc_stride;
638  int obmc_v= obmc[index];
639  int d;
640  if(y<0) obmc_v += obmc[index + block_h*obmc_stride];
641  if(x<0) obmc_v += obmc[index + block_w];
642  if(y+block_h>h) obmc_v += obmc[index - block_h*obmc_stride];
643  if(x+block_w>w) obmc_v += obmc[index - block_w];
644  //FIXME precalculate this or simplify it somehow else
645 
646  d = -dst[index] + (1<<(FRAC_BITS-1));
647  dst[index] = d;
648  ab += (src[x2 + y2*ref_stride] - (d>>FRAC_BITS)) * obmc_v;
649  aa += obmc_v * obmc_v; //FIXME precalculate this
650  }
651  }
652  }
653  *b= backup;
654 
655  return av_clip( ROUNDED_DIV(ab<<LOG2_OBMC_MAX, aa), 0, 255); //FIXME we should not need clipping
656 }
657 
658 static inline int get_block_bits(SnowContext *s, int x, int y, int w){
659  const int b_stride = s->b_width << s->block_max_depth;
660  const int b_height = s->b_height<< s->block_max_depth;
661  int index= x + y*b_stride;
662  const BlockNode *b = &s->block[index];
663  const BlockNode *left = x ? &s->block[index-1] : &null_block;
664  const BlockNode *top = y ? &s->block[index-b_stride] : &null_block;
665  const BlockNode *tl = y && x ? &s->block[index-b_stride-1] : left;
666  const BlockNode *tr = y && x+w<b_stride ? &s->block[index-b_stride+w] : tl;
667  int dmx, dmy;
668 // int mx_context= av_log2(2*FFABS(left->mx - top->mx));
669 // int my_context= av_log2(2*FFABS(left->my - top->my));
670 
671  if(x<0 || x>=b_stride || y>=b_height)
672  return 0;
673 /*
674 1 0 0
675 01X 1-2 1
676 001XX 3-6 2-3
677 0001XXX 7-14 4-7
678 00001XXXX 15-30 8-15
679 */
680 //FIXME try accurate rate
681 //FIXME intra and inter predictors if surrounding blocks are not the same type
682  if(b->type & BLOCK_INTRA){
683  return 3+2*( av_log2(2*FFABS(left->color[0] - b->color[0]))
684  + av_log2(2*FFABS(left->color[1] - b->color[1]))
685  + av_log2(2*FFABS(left->color[2] - b->color[2])));
686  }else{
687  pred_mv(s, &dmx, &dmy, b->ref, left, top, tr);
688  dmx-= b->mx;
689  dmy-= b->my;
690  return 2*(1 + av_log2(2*FFABS(dmx)) //FIXME kill the 2* can be merged in lambda
691  + av_log2(2*FFABS(dmy))
692  + av_log2(2*b->ref));
693  }
694 }
695 
696 static int get_block_rd(SnowContext *s, int mb_x, int mb_y, int plane_index, uint8_t (*obmc_edged)[MB_SIZE * 2]){
697  Plane *p= &s->plane[plane_index];
698  const int block_size = MB_SIZE >> s->block_max_depth;
699  const int block_w = plane_index ? block_size>>s->chroma_h_shift : block_size;
700  const int block_h = plane_index ? block_size>>s->chroma_v_shift : block_size;
701  const int obmc_stride= plane_index ? (2*block_size)>>s->chroma_h_shift : 2*block_size;
702  const int ref_stride= s->current_picture.linesize[plane_index];
703  uint8_t *dst= s->current_picture.data[plane_index];
704  uint8_t *src= s-> input_picture.data[plane_index];
705  IDWTELEM *pred= (IDWTELEM*)s->m.obmc_scratchpad + plane_index*block_size*block_size*4;
706  uint8_t *cur = s->scratchbuf;
707  uint8_t *tmp = s->emu_edge_buffer;
708  const int b_stride = s->b_width << s->block_max_depth;
709  const int b_height = s->b_height<< s->block_max_depth;
710  const int w= p->width;
711  const int h= p->height;
712  int distortion;
713  int rate= 0;
714  const int penalty_factor= get_penalty_factor(s->lambda, s->lambda2, s->avctx->me_cmp);
715  int sx= block_w*mb_x - block_w/2;
716  int sy= block_h*mb_y - block_h/2;
717  int x0= FFMAX(0,-sx);
718  int y0= FFMAX(0,-sy);
719  int x1= FFMIN(block_w*2, w-sx);
720  int y1= FFMIN(block_h*2, h-sy);
721  int i,x,y;
722 
723  av_assert2(s->chroma_h_shift == s->chroma_v_shift); //obmc and square assumtions below chckinhg only block_w
724 
725  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);
726 
727  for(y=y0; y<y1; y++){
728  const uint8_t *obmc1= obmc_edged[y];
729  const IDWTELEM *pred1 = pred + y*obmc_stride;
730  uint8_t *cur1 = cur + y*ref_stride;
731  uint8_t *dst1 = dst + sx + (sy+y)*ref_stride;
732  for(x=x0; x<x1; x++){
733 #if FRAC_BITS >= LOG2_OBMC_MAX
734  int v = (cur1[x] * obmc1[x]) << (FRAC_BITS - LOG2_OBMC_MAX);
735 #else
736  int v = (cur1[x] * obmc1[x] + (1<<(LOG2_OBMC_MAX - FRAC_BITS-1))) >> (LOG2_OBMC_MAX - FRAC_BITS);
737 #endif
738  v = (v + pred1[x]) >> FRAC_BITS;
739  if(v&(~255)) v= ~(v>>31);
740  dst1[x] = v;
741  }
742  }
743 
744  /* copy the regions where obmc[] = (uint8_t)256 */
745  if(LOG2_OBMC_MAX == 8
746  && (mb_x == 0 || mb_x == b_stride-1)
747  && (mb_y == 0 || mb_y == b_height-1)){
748  if(mb_x == 0)
749  x1 = block_w;
750  else
751  x0 = block_w;
752  if(mb_y == 0)
753  y1 = block_h;
754  else
755  y0 = block_h;
756  for(y=y0; y<y1; y++)
757  memcpy(dst + sx+x0 + (sy+y)*ref_stride, cur + x0 + y*ref_stride, x1-x0);
758  }
759 
760  if(block_w==16){
761  /* FIXME rearrange dsputil to fit 32x32 cmp functions */
762  /* FIXME check alignment of the cmp wavelet vs the encoding wavelet */
763  /* FIXME cmps overlap but do not cover the wavelet's whole support.
764  * So improving the score of one block is not strictly guaranteed
765  * to improve the score of the whole frame, thus iterative motion
766  * estimation does not always converge. */
767  if(s->avctx->me_cmp == FF_CMP_W97)
768  distortion = ff_w97_32_c(&s->m, src + sx + sy*ref_stride, dst + sx + sy*ref_stride, ref_stride, 32);
769  else if(s->avctx->me_cmp == FF_CMP_W53)
770  distortion = ff_w53_32_c(&s->m, src + sx + sy*ref_stride, dst + sx + sy*ref_stride, ref_stride, 32);
771  else{
772  distortion = 0;
773  for(i=0; i<4; i++){
774  int off = sx+16*(i&1) + (sy+16*(i>>1))*ref_stride;
775  distortion += s->dsp.me_cmp[0](&s->m, src + off, dst + off, ref_stride, 16);
776  }
777  }
778  }else{
779  assert(block_w==8);
780  distortion = s->dsp.me_cmp[0](&s->m, src + sx + sy*ref_stride, dst + sx + sy*ref_stride, ref_stride, block_w*2);
781  }
782 
783  if(plane_index==0){
784  for(i=0; i<4; i++){
785 /* ..RRr
786  * .RXx.
787  * rxx..
788  */
789  rate += get_block_bits(s, mb_x + (i&1) - (i>>1), mb_y + (i>>1), 1);
790  }
791  if(mb_x == b_stride-2)
792  rate += get_block_bits(s, mb_x + 1, mb_y + 1, 1);
793  }
794  return distortion + rate*penalty_factor;
795 }
796 
797 static int get_4block_rd(SnowContext *s, int mb_x, int mb_y, int plane_index){
798  int i, y2;
799  Plane *p= &s->plane[plane_index];
800  const int block_size = MB_SIZE >> s->block_max_depth;
801  const int block_w = plane_index ? block_size>>s->chroma_h_shift : block_size;
802  const int block_h = plane_index ? block_size>>s->chroma_v_shift : block_size;
803  const uint8_t *obmc = plane_index ? ff_obmc_tab[s->block_max_depth+s->chroma_h_shift] : ff_obmc_tab[s->block_max_depth];
804  const int obmc_stride= plane_index ? (2*block_size)>>s->chroma_h_shift : 2*block_size;
805  const int ref_stride= s->current_picture.linesize[plane_index];
806  uint8_t *dst= s->current_picture.data[plane_index];
807  uint8_t *src= s-> input_picture.data[plane_index];
808  //FIXME zero_dst is const but add_yblock changes dst if add is 0 (this is never the case for dst=zero_dst
809  // const has only been removed from zero_dst to suppress a warning
810  static IDWTELEM zero_dst[4096]; //FIXME
811  const int b_stride = s->b_width << s->block_max_depth;
812  const int w= p->width;
813  const int h= p->height;
814  int distortion= 0;
815  int rate= 0;
816  const int penalty_factor= get_penalty_factor(s->lambda, s->lambda2, s->avctx->me_cmp);
817 
818  av_assert2(s->chroma_h_shift == s->chroma_v_shift); //obmc and square assumtions below
819 
820  for(i=0; i<9; i++){
821  int mb_x2= mb_x + (i%3) - 1;
822  int mb_y2= mb_y + (i/3) - 1;
823  int x= block_w*mb_x2 + block_w/2;
824  int y= block_h*mb_y2 + block_h/2;
825 
826  add_yblock(s, 0, NULL, zero_dst, dst, obmc,
827  x, y, block_w, block_h, w, h, /*dst_stride*/0, ref_stride, obmc_stride, mb_x2, mb_y2, 1, 1, plane_index);
828 
829  //FIXME find a cleaner/simpler way to skip the outside stuff
830  for(y2= y; y2<0; y2++)
831  memcpy(dst + x + y2*ref_stride, src + x + y2*ref_stride, block_w);
832  for(y2= h; y2<y+block_h; y2++)
833  memcpy(dst + x + y2*ref_stride, src + x + y2*ref_stride, block_w);
834  if(x<0){
835  for(y2= y; y2<y+block_h; y2++)
836  memcpy(dst + x + y2*ref_stride, src + x + y2*ref_stride, -x);
837  }
838  if(x+block_w > w){
839  for(y2= y; y2<y+block_h; y2++)
840  memcpy(dst + w + y2*ref_stride, src + w + y2*ref_stride, x+block_w - w);
841  }
842 
843  assert(block_w== 8 || block_w==16);
844  distortion += s->dsp.me_cmp[block_w==8](&s->m, src + x + y*ref_stride, dst + x + y*ref_stride, ref_stride, block_h);
845  }
846 
847  if(plane_index==0){
848  BlockNode *b= &s->block[mb_x+mb_y*b_stride];
849  int merged= same_block(b,b+1) && same_block(b,b+b_stride) && same_block(b,b+b_stride+1);
850 
851 /* ..RRRr
852  * .RXXx.
853  * .RXXx.
854  * rxxx.
855  */
856  if(merged)
857  rate = get_block_bits(s, mb_x, mb_y, 2);
858  for(i=merged?4:0; i<9; i++){
859  static const int dxy[9][2] = {{0,0},{1,0},{0,1},{1,1},{2,0},{2,1},{-1,2},{0,2},{1,2}};
860  rate += get_block_bits(s, mb_x + dxy[i][0], mb_y + dxy[i][1], 1);
861  }
862  }
863  return distortion + rate*penalty_factor;
864 }
865 
866 static int encode_subband_c0run(SnowContext *s, SubBand *b, const IDWTELEM *src, const IDWTELEM *parent, int stride, int orientation){
867  const int w= b->width;
868  const int h= b->height;
869  int x, y;
870 
871  if(1){
872  int run=0;
873  int *runs = s->run_buffer;
874  int run_index=0;
875  int max_index;
876 
877  for(y=0; y<h; y++){
878  for(x=0; x<w; x++){
879  int v, p=0;
880  int /*ll=0, */l=0, lt=0, t=0, rt=0;
881  v= src[x + y*stride];
882 
883  if(y){
884  t= src[x + (y-1)*stride];
885  if(x){
886  lt= src[x - 1 + (y-1)*stride];
887  }
888  if(x + 1 < w){
889  rt= src[x + 1 + (y-1)*stride];
890  }
891  }
892  if(x){
893  l= src[x - 1 + y*stride];
894  /*if(x > 1){
895  if(orientation==1) ll= src[y + (x-2)*stride];
896  else ll= src[x - 2 + y*stride];
897  }*/
898  }
899  if(parent){
900  int px= x>>1;
901  int py= y>>1;
902  if(px<b->parent->width && py<b->parent->height)
903  p= parent[px + py*2*stride];
904  }
905  if(!(/*ll|*/l|lt|t|rt|p)){
906  if(v){
907  runs[run_index++]= run;
908  run=0;
909  }else{
910  run++;
911  }
912  }
913  }
914  }
915  max_index= run_index;
916  runs[run_index++]= run;
917  run_index=0;
918  run= runs[run_index++];
919 
920  put_symbol2(&s->c, b->state[30], max_index, 0);
921  if(run_index <= max_index)
922  put_symbol2(&s->c, b->state[1], run, 3);
923 
924  for(y=0; y<h; y++){
925  if(s->c.bytestream_end - s->c.bytestream < w*40){
926  av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
927  return -1;
928  }
929  for(x=0; x<w; x++){
930  int v, p=0;
931  int /*ll=0, */l=0, lt=0, t=0, rt=0;
932  v= src[x + y*stride];
933 
934  if(y){
935  t= src[x + (y-1)*stride];
936  if(x){
937  lt= src[x - 1 + (y-1)*stride];
938  }
939  if(x + 1 < w){
940  rt= src[x + 1 + (y-1)*stride];
941  }
942  }
943  if(x){
944  l= src[x - 1 + y*stride];
945  /*if(x > 1){
946  if(orientation==1) ll= src[y + (x-2)*stride];
947  else ll= src[x - 2 + y*stride];
948  }*/
949  }
950  if(parent){
951  int px= x>>1;
952  int py= y>>1;
953  if(px<b->parent->width && py<b->parent->height)
954  p= parent[px + py*2*stride];
955  }
956  if(/*ll|*/l|lt|t|rt|p){
957  int context= av_log2(/*FFABS(ll) + */3*FFABS(l) + FFABS(lt) + 2*FFABS(t) + FFABS(rt) + FFABS(p));
958 
959  put_rac(&s->c, &b->state[0][context], !!v);
960  }else{
961  if(!run){
962  run= runs[run_index++];
963 
964  if(run_index <= max_index)
965  put_symbol2(&s->c, b->state[1], run, 3);
966  assert(v);
967  }else{
968  run--;
969  assert(!v);
970  }
971  }
972  if(v){
973  int context= av_log2(/*FFABS(ll) + */3*FFABS(l) + FFABS(lt) + 2*FFABS(t) + FFABS(rt) + FFABS(p));
974  int l2= 2*FFABS(l) + (l<0);
975  int t2= 2*FFABS(t) + (t<0);
976 
977  put_symbol2(&s->c, b->state[context + 2], FFABS(v)-1, context-4);
978  put_rac(&s->c, &b->state[0][16 + 1 + 3 + ff_quant3bA[l2&0xFF] + 3*ff_quant3bA[t2&0xFF]], v<0);
979  }
980  }
981  }
982  }
983  return 0;
984 }
985 
986 static int encode_subband(SnowContext *s, SubBand *b, const IDWTELEM *src, const IDWTELEM *parent, int stride, int orientation){
987 // encode_subband_qtree(s, b, src, parent, stride, orientation);
988 // encode_subband_z0run(s, b, src, parent, stride, orientation);
989  return encode_subband_c0run(s, b, src, parent, stride, orientation);
990 // encode_subband_dzr(s, b, src, parent, stride, orientation);
991 }
992 
993 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){
994  const int b_stride= s->b_width << s->block_max_depth;
995  BlockNode *block= &s->block[mb_x + mb_y * b_stride];
996  BlockNode backup= *block;
997  unsigned value;
998  int rd, index;
999 
1000  assert(mb_x>=0 && mb_y>=0);
1001  assert(mb_x<b_stride);
1002 
1003  if(intra){
1004  block->color[0] = p[0];
1005  block->color[1] = p[1];
1006  block->color[2] = p[2];
1007  block->type |= BLOCK_INTRA;
1008  }else{
1009  index= (p[0] + 31*p[1]) & (ME_CACHE_SIZE-1);
1010  value= s->me_cache_generation + (p[0]>>10) + (p[1]<<6) + (block->ref<<12);
1011  if(s->me_cache[index] == value)
1012  return 0;
1013  s->me_cache[index]= value;
1014 
1015  block->mx= p[0];
1016  block->my= p[1];
1017  block->type &= ~BLOCK_INTRA;
1018  }
1019 
1020  rd= get_block_rd(s, mb_x, mb_y, 0, obmc_edged);
1021 
1022 //FIXME chroma
1023  if(rd < *best_rd){
1024  *best_rd= rd;
1025  return 1;
1026  }else{
1027  *block= backup;
1028  return 0;
1029  }
1030 }
1031 
1032 /* special case for int[2] args we discard afterwards,
1033  * fixes compilation problem with gcc 2.95 */
1034 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){
1035  int p[2] = {p0, p1};
1036  return check_block(s, mb_x, mb_y, p, 0, obmc_edged, best_rd);
1037 }
1038 
1039 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){
1040  const int b_stride= s->b_width << s->block_max_depth;
1041  BlockNode *block= &s->block[mb_x + mb_y * b_stride];
1042  BlockNode backup[4];
1043  unsigned value;
1044  int rd, index;
1045 
1046  /* We don't initialize backup[] during variable declaration, because
1047  * that fails to compile on MSVC: "cannot convert from 'BlockNode' to
1048  * 'int16_t'". */
1049  backup[0] = block[0];
1050  backup[1] = block[1];
1051  backup[2] = block[b_stride];
1052  backup[3] = block[b_stride + 1];
1053 
1054  assert(mb_x>=0 && mb_y>=0);
1055  assert(mb_x<b_stride);
1056  assert(((mb_x|mb_y)&1) == 0);
1057 
1058  index= (p0 + 31*p1) & (ME_CACHE_SIZE-1);
1059  value= s->me_cache_generation + (p0>>10) + (p1<<6) + (block->ref<<12);
1060  if(s->me_cache[index] == value)
1061  return 0;
1062  s->me_cache[index]= value;
1063 
1064  block->mx= p0;
1065  block->my= p1;
1066  block->ref= ref;
1067  block->type &= ~BLOCK_INTRA;
1068  block[1]= block[b_stride]= block[b_stride+1]= *block;
1069 
1070  rd= get_4block_rd(s, mb_x, mb_y, 0);
1071 
1072 //FIXME chroma
1073  if(rd < *best_rd){
1074  *best_rd= rd;
1075  return 1;
1076  }else{
1077  block[0]= backup[0];
1078  block[1]= backup[1];
1079  block[b_stride]= backup[2];
1080  block[b_stride+1]= backup[3];
1081  return 0;
1082  }
1083 }
1084 
1085 static void iterative_me(SnowContext *s){
1086  int pass, mb_x, mb_y;
1087  const int b_width = s->b_width << s->block_max_depth;
1088  const int b_height= s->b_height << s->block_max_depth;
1089  const int b_stride= b_width;
1090  int color[3];
1091 
1092  {
1093  RangeCoder r = s->c;
1094  uint8_t state[sizeof(s->block_state)];
1095  memcpy(state, s->block_state, sizeof(s->block_state));
1096  for(mb_y= 0; mb_y<s->b_height; mb_y++)
1097  for(mb_x= 0; mb_x<s->b_width; mb_x++)
1098  encode_q_branch(s, 0, mb_x, mb_y);
1099  s->c = r;
1100  memcpy(s->block_state, state, sizeof(s->block_state));
1101  }
1102 
1103  for(pass=0; pass<25; pass++){
1104  int change= 0;
1105 
1106  for(mb_y= 0; mb_y<b_height; mb_y++){
1107  for(mb_x= 0; mb_x<b_width; mb_x++){
1108  int dia_change, i, j, ref;
1109  int best_rd= INT_MAX, ref_rd;
1110  BlockNode backup, ref_b;
1111  const int index= mb_x + mb_y * b_stride;
1112  BlockNode *block= &s->block[index];
1113  BlockNode *tb = mb_y ? &s->block[index-b_stride ] : NULL;
1114  BlockNode *lb = mb_x ? &s->block[index -1] : NULL;
1115  BlockNode *rb = mb_x+1<b_width ? &s->block[index +1] : NULL;
1116  BlockNode *bb = mb_y+1<b_height ? &s->block[index+b_stride ] : NULL;
1117  BlockNode *tlb= mb_x && mb_y ? &s->block[index-b_stride-1] : NULL;
1118  BlockNode *trb= mb_x+1<b_width && mb_y ? &s->block[index-b_stride+1] : NULL;
1119  BlockNode *blb= mb_x && mb_y+1<b_height ? &s->block[index+b_stride-1] : NULL;
1120  BlockNode *brb= mb_x+1<b_width && mb_y+1<b_height ? &s->block[index+b_stride+1] : NULL;
1121  const int b_w= (MB_SIZE >> s->block_max_depth);
1122  uint8_t obmc_edged[MB_SIZE * 2][MB_SIZE * 2];
1123 
1124  if(pass && (block->type & BLOCK_OPT))
1125  continue;
1126  block->type |= BLOCK_OPT;
1127 
1128  backup= *block;
1129 
1130  if(!s->me_cache_generation)
1131  memset(s->me_cache, 0, sizeof(s->me_cache));
1132  s->me_cache_generation += 1<<22;
1133 
1134  //FIXME precalculate
1135  {
1136  int x, y;
1137  for (y = 0; y < b_w * 2; y++)
1138  memcpy(obmc_edged[y], ff_obmc_tab[s->block_max_depth] + y * b_w * 2, b_w * 2);
1139  if(mb_x==0)
1140  for(y=0; y<b_w*2; y++)
1141  memset(obmc_edged[y], obmc_edged[y][0] + obmc_edged[y][b_w-1], b_w);
1142  if(mb_x==b_stride-1)
1143  for(y=0; y<b_w*2; y++)
1144  memset(obmc_edged[y]+b_w, obmc_edged[y][b_w] + obmc_edged[y][b_w*2-1], b_w);
1145  if(mb_y==0){
1146  for(x=0; x<b_w*2; x++)
1147  obmc_edged[0][x] += obmc_edged[b_w-1][x];
1148  for(y=1; y<b_w; y++)
1149  memcpy(obmc_edged[y], obmc_edged[0], b_w*2);
1150  }
1151  if(mb_y==b_height-1){
1152  for(x=0; x<b_w*2; x++)
1153  obmc_edged[b_w*2-1][x] += obmc_edged[b_w][x];
1154  for(y=b_w; y<b_w*2-1; y++)
1155  memcpy(obmc_edged[y], obmc_edged[b_w*2-1], b_w*2);
1156  }
1157  }
1158 
1159  //skip stuff outside the picture
1160  if(mb_x==0 || mb_y==0 || mb_x==b_width-1 || mb_y==b_height-1){
1161  uint8_t *src= s-> input_picture.data[0];
1162  uint8_t *dst= s->current_picture.data[0];
1163  const int stride= s->current_picture.linesize[0];
1164  const int block_w= MB_SIZE >> s->block_max_depth;
1165  const int block_h= MB_SIZE >> s->block_max_depth;
1166  const int sx= block_w*mb_x - block_w/2;
1167  const int sy= block_h*mb_y - block_h/2;
1168  const int w= s->plane[0].width;
1169  const int h= s->plane[0].height;
1170  int y;
1171 
1172  for(y=sy; y<0; y++)
1173  memcpy(dst + sx + y*stride, src + sx + y*stride, block_w*2);
1174  for(y=h; y<sy+block_h*2; y++)
1175  memcpy(dst + sx + y*stride, src + sx + y*stride, block_w*2);
1176  if(sx<0){
1177  for(y=sy; y<sy+block_h*2; y++)
1178  memcpy(dst + sx + y*stride, src + sx + y*stride, -sx);
1179  }
1180  if(sx+block_w*2 > w){
1181  for(y=sy; y<sy+block_h*2; y++)
1182  memcpy(dst + w + y*stride, src + w + y*stride, sx+block_w*2 - w);
1183  }
1184  }
1185 
1186  // intra(black) = neighbors' contribution to the current block
1187  for(i=0; i<3; i++)
1188  color[i]= get_dc(s, mb_x, mb_y, i);
1189 
1190  // get previous score (cannot be cached due to OBMC)
1191  if(pass > 0 && (block->type&BLOCK_INTRA)){
1192  int color0[3]= {block->color[0], block->color[1], block->color[2]};
1193  check_block(s, mb_x, mb_y, color0, 1, obmc_edged, &best_rd);
1194  }else
1195  check_block_inter(s, mb_x, mb_y, block->mx, block->my, obmc_edged, &best_rd);
1196 
1197  ref_b= *block;
1198  ref_rd= best_rd;
1199  for(ref=0; ref < s->ref_frames; ref++){
1200  int16_t (*mvr)[2]= &s->ref_mvs[ref][index];
1201  if(s->ref_scores[ref][index] > s->ref_scores[ref_b.ref][index]*3/2) //FIXME tune threshold
1202  continue;
1203  block->ref= ref;
1204  best_rd= INT_MAX;
1205 
1206  check_block_inter(s, mb_x, mb_y, mvr[0][0], mvr[0][1], obmc_edged, &best_rd);
1207  check_block_inter(s, mb_x, mb_y, 0, 0, obmc_edged, &best_rd);
1208  if(tb)
1209  check_block_inter(s, mb_x, mb_y, mvr[-b_stride][0], mvr[-b_stride][1], obmc_edged, &best_rd);
1210  if(lb)
1211  check_block_inter(s, mb_x, mb_y, mvr[-1][0], mvr[-1][1], obmc_edged, &best_rd);
1212  if(rb)
1213  check_block_inter(s, mb_x, mb_y, mvr[1][0], mvr[1][1], obmc_edged, &best_rd);
1214  if(bb)
1215  check_block_inter(s, mb_x, mb_y, mvr[b_stride][0], mvr[b_stride][1], obmc_edged, &best_rd);
1216 
1217  /* fullpel ME */
1218  //FIXME avoid subpel interpolation / round to nearest integer
1219  do{
1220  dia_change=0;
1221  for(i=0; i<FFMAX(s->avctx->dia_size, 1); i++){
1222  for(j=0; j<i; j++){
1223  dia_change |= check_block_inter(s, mb_x, mb_y, block->mx+4*(i-j), block->my+(4*j), obmc_edged, &best_rd);
1224  dia_change |= check_block_inter(s, mb_x, mb_y, block->mx-4*(i-j), block->my-(4*j), obmc_edged, &best_rd);
1225  dia_change |= check_block_inter(s, mb_x, mb_y, block->mx+4*(i-j), block->my-(4*j), obmc_edged, &best_rd);
1226  dia_change |= check_block_inter(s, mb_x, mb_y, block->mx-4*(i-j), block->my+(4*j), obmc_edged, &best_rd);
1227  }
1228  }
1229  }while(dia_change);
1230  /* subpel ME */
1231  do{
1232  static const int square[8][2]= {{+1, 0},{-1, 0},{ 0,+1},{ 0,-1},{+1,+1},{-1,-1},{+1,-1},{-1,+1},};
1233  dia_change=0;
1234  for(i=0; i<8; i++)
1235  dia_change |= check_block_inter(s, mb_x, mb_y, block->mx+square[i][0], block->my+square[i][1], obmc_edged, &best_rd);
1236  }while(dia_change);
1237  //FIXME or try the standard 2 pass qpel or similar
1238 
1239  mvr[0][0]= block->mx;
1240  mvr[0][1]= block->my;
1241  if(ref_rd > best_rd){
1242  ref_rd= best_rd;
1243  ref_b= *block;
1244  }
1245  }
1246  best_rd= ref_rd;
1247  *block= ref_b;
1248  check_block(s, mb_x, mb_y, color, 1, obmc_edged, &best_rd);
1249  //FIXME RD style color selection
1250  if(!same_block(block, &backup)){
1251  if(tb ) tb ->type &= ~BLOCK_OPT;
1252  if(lb ) lb ->type &= ~BLOCK_OPT;
1253  if(rb ) rb ->type &= ~BLOCK_OPT;
1254  if(bb ) bb ->type &= ~BLOCK_OPT;
1255  if(tlb) tlb->type &= ~BLOCK_OPT;
1256  if(trb) trb->type &= ~BLOCK_OPT;
1257  if(blb) blb->type &= ~BLOCK_OPT;
1258  if(brb) brb->type &= ~BLOCK_OPT;
1259  change ++;
1260  }
1261  }
1262  }
1263  av_log(s->avctx, AV_LOG_ERROR, "pass:%d changed:%d\n", pass, change);
1264  if(!change)
1265  break;
1266  }
1267 
1268  if(s->block_max_depth == 1){
1269  int change= 0;
1270  for(mb_y= 0; mb_y<b_height; mb_y+=2){
1271  for(mb_x= 0; mb_x<b_width; mb_x+=2){
1272  int i;
1273  int best_rd, init_rd;
1274  const int index= mb_x + mb_y * b_stride;
1275  BlockNode *b[4];
1276 
1277  b[0]= &s->block[index];
1278  b[1]= b[0]+1;
1279  b[2]= b[0]+b_stride;
1280  b[3]= b[2]+1;
1281  if(same_block(b[0], b[1]) &&
1282  same_block(b[0], b[2]) &&
1283  same_block(b[0], b[3]))
1284  continue;
1285 
1286  if(!s->me_cache_generation)
1287  memset(s->me_cache, 0, sizeof(s->me_cache));
1288  s->me_cache_generation += 1<<22;
1289 
1290  init_rd= best_rd= get_4block_rd(s, mb_x, mb_y, 0);
1291 
1292  //FIXME more multiref search?
1293  check_4block_inter(s, mb_x, mb_y,
1294  (b[0]->mx + b[1]->mx + b[2]->mx + b[3]->mx + 2) >> 2,
1295  (b[0]->my + b[1]->my + b[2]->my + b[3]->my + 2) >> 2, 0, &best_rd);
1296 
1297  for(i=0; i<4; i++)
1298  if(!(b[i]->type&BLOCK_INTRA))
1299  check_4block_inter(s, mb_x, mb_y, b[i]->mx, b[i]->my, b[i]->ref, &best_rd);
1300 
1301  if(init_rd != best_rd)
1302  change++;
1303  }
1304  }
1305  av_log(s->avctx, AV_LOG_ERROR, "pass:4mv changed:%d\n", change*4);
1306  }
1307 }
1308 
1309 static void encode_blocks(SnowContext *s, int search){
1310  int x, y;
1311  int w= s->b_width;
1312  int h= s->b_height;
1313 
1314  if(s->avctx->me_method == ME_ITER && !s->keyframe && search)
1315  iterative_me(s);
1316 
1317  for(y=0; y<h; y++){
1318  if(s->c.bytestream_end - s->c.bytestream < w*MB_SIZE*MB_SIZE*3){ //FIXME nicer limit
1319  av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
1320  return;
1321  }
1322  for(x=0; x<w; x++){
1323  if(s->avctx->me_method == ME_ITER || !search)
1324  encode_q_branch2(s, 0, x, y);
1325  else
1326  encode_q_branch (s, 0, x, y);
1327  }
1328  }
1329 }
1330 
1331 static void quantize(SnowContext *s, SubBand *b, IDWTELEM *dst, DWTELEM *src, int stride, int bias){
1332  const int w= b->width;
1333  const int h= b->height;
1334  const int qlog= av_clip(s->qlog + b->qlog, 0, QROOT*16);
1335  const int qmul= ff_qexp[qlog&(QROOT-1)]<<((qlog>>QSHIFT) + ENCODER_EXTRA_BITS);
1336  int x,y, thres1, thres2;
1337 
1338  if(s->qlog == LOSSLESS_QLOG){
1339  for(y=0; y<h; y++)
1340  for(x=0; x<w; x++)
1341  dst[x + y*stride]= src[x + y*stride];
1342  return;
1343  }
1344 
1345  bias= bias ? 0 : (3*qmul)>>3;
1346  thres1= ((qmul - bias)>>QEXPSHIFT) - 1;
1347  thres2= 2*thres1;
1348 
1349  if(!bias){
1350  for(y=0; y<h; y++){
1351  for(x=0; x<w; x++){
1352  int i= src[x + y*stride];
1353 
1354  if((unsigned)(i+thres1) > thres2){
1355  if(i>=0){
1356  i<<= QEXPSHIFT;
1357  i/= qmul; //FIXME optimize
1358  dst[x + y*stride]= i;
1359  }else{
1360  i= -i;
1361  i<<= QEXPSHIFT;
1362  i/= qmul; //FIXME optimize
1363  dst[x + y*stride]= -i;
1364  }
1365  }else
1366  dst[x + y*stride]= 0;
1367  }
1368  }
1369  }else{
1370  for(y=0; y<h; y++){
1371  for(x=0; x<w; x++){
1372  int i= src[x + y*stride];
1373 
1374  if((unsigned)(i+thres1) > thres2){
1375  if(i>=0){
1376  i<<= QEXPSHIFT;
1377  i= (i + bias) / qmul; //FIXME optimize
1378  dst[x + y*stride]= i;
1379  }else{
1380  i= -i;
1381  i<<= QEXPSHIFT;
1382  i= (i + bias) / qmul; //FIXME optimize
1383  dst[x + y*stride]= -i;
1384  }
1385  }else
1386  dst[x + y*stride]= 0;
1387  }
1388  }
1389  }
1390 }
1391 
1392 static void dequantize(SnowContext *s, SubBand *b, IDWTELEM *src, int stride){
1393  const int w= b->width;
1394  const int h= b->height;
1395  const int qlog= av_clip(s->qlog + b->qlog, 0, QROOT*16);
1396  const int qmul= ff_qexp[qlog&(QROOT-1)]<<(qlog>>QSHIFT);
1397  const int qadd= (s->qbias*qmul)>>QBIAS_SHIFT;
1398  int x,y;
1399 
1400  if(s->qlog == LOSSLESS_QLOG) return;
1401 
1402  for(y=0; y<h; y++){
1403  for(x=0; x<w; x++){
1404  int i= src[x + y*stride];
1405  if(i<0){
1406  src[x + y*stride]= -((-i*qmul + qadd)>>(QEXPSHIFT)); //FIXME try different bias
1407  }else if(i>0){
1408  src[x + y*stride]= (( i*qmul + qadd)>>(QEXPSHIFT));
1409  }
1410  }
1411  }
1412 }
1413 
1414 static void decorrelate(SnowContext *s, SubBand *b, IDWTELEM *src, int stride, int inverse, int use_median){
1415  const int w= b->width;
1416  const int h= b->height;
1417  int x,y;
1418 
1419  for(y=h-1; y>=0; y--){
1420  for(x=w-1; x>=0; x--){
1421  int i= x + y*stride;
1422 
1423  if(x){
1424  if(use_median){
1425  if(y && x+1<w) src[i] -= mid_pred(src[i - 1], src[i - stride], src[i - stride + 1]);
1426  else src[i] -= src[i - 1];
1427  }else{
1428  if(y) src[i] -= mid_pred(src[i - 1], src[i - stride], src[i - 1] + src[i - stride] - src[i - 1 - stride]);
1429  else src[i] -= src[i - 1];
1430  }
1431  }else{
1432  if(y) src[i] -= src[i - stride];
1433  }
1434  }
1435  }
1436 }
1437 
1438 static void correlate(SnowContext *s, SubBand *b, IDWTELEM *src, int stride, int inverse, int use_median){
1439  const int w= b->width;
1440  const int h= b->height;
1441  int x,y;
1442 
1443  for(y=0; y<h; y++){
1444  for(x=0; x<w; x++){
1445  int i= x + y*stride;
1446 
1447  if(x){
1448  if(use_median){
1449  if(y && x+1<w) src[i] += mid_pred(src[i - 1], src[i - stride], src[i - stride + 1]);
1450  else src[i] += src[i - 1];
1451  }else{
1452  if(y) src[i] += mid_pred(src[i - 1], src[i - stride], src[i - 1] + src[i - stride] - src[i - 1 - stride]);
1453  else src[i] += src[i - 1];
1454  }
1455  }else{
1456  if(y) src[i] += src[i - stride];
1457  }
1458  }
1459  }
1460 }
1461 
1462 static void encode_qlogs(SnowContext *s){
1463  int plane_index, level, orientation;
1464 
1465  for(plane_index=0; plane_index<2; plane_index++){
1466  for(level=0; level<s->spatial_decomposition_count; level++){
1467  for(orientation=level ? 1:0; orientation<4; orientation++){
1468  if(orientation==2) continue;
1469  put_symbol(&s->c, s->header_state, s->plane[plane_index].band[level][orientation].qlog, 1);
1470  }
1471  }
1472  }
1473 }
1474 
1475 static void encode_header(SnowContext *s){
1476  int plane_index, i;
1477  uint8_t kstate[32];
1478 
1479  memset(kstate, MID_STATE, sizeof(kstate));
1480 
1481  put_rac(&s->c, kstate, s->keyframe);
1482  if(s->keyframe || s->always_reset){
1483  ff_snow_reset_contexts(s);
1484  s->last_spatial_decomposition_type=
1485  s->last_qlog=
1486  s->last_qbias=
1487  s->last_mv_scale=
1488  s->last_block_max_depth= 0;
1489  for(plane_index=0; plane_index<2; plane_index++){
1490  Plane *p= &s->plane[plane_index];
1491  p->last_htaps=0;
1492  p->last_diag_mc=0;
1493  memset(p->last_hcoeff, 0, sizeof(p->last_hcoeff));
1494  }
1495  }
1496  if(s->keyframe){
1497  put_symbol(&s->c, s->header_state, s->version, 0);
1498  put_rac(&s->c, s->header_state, s->always_reset);
1499  put_symbol(&s->c, s->header_state, s->temporal_decomposition_type, 0);
1500  put_symbol(&s->c, s->header_state, s->temporal_decomposition_count, 0);
1501  put_symbol(&s->c, s->header_state, s->spatial_decomposition_count, 0);
1502  put_symbol(&s->c, s->header_state, s->colorspace_type, 0);
1503  put_symbol(&s->c, s->header_state, s->chroma_h_shift, 0);
1504  put_symbol(&s->c, s->header_state, s->chroma_v_shift, 0);
1505  put_rac(&s->c, s->header_state, s->spatial_scalability);
1506 // put_rac(&s->c, s->header_state, s->rate_scalability);
1507  put_symbol(&s->c, s->header_state, s->max_ref_frames-1, 0);
1508 
1509  encode_qlogs(s);
1510  }
1511 
1512  if(!s->keyframe){
1513  int update_mc=0;
1514  for(plane_index=0; plane_index<2; plane_index++){
1515  Plane *p= &s->plane[plane_index];
1516  update_mc |= p->last_htaps != p->htaps;
1517  update_mc |= p->last_diag_mc != p->diag_mc;
1518  update_mc |= !!memcmp(p->last_hcoeff, p->hcoeff, sizeof(p->hcoeff));
1519  }
1520  put_rac(&s->c, s->header_state, update_mc);
1521  if(update_mc){
1522  for(plane_index=0; plane_index<2; plane_index++){
1523  Plane *p= &s->plane[plane_index];
1524  put_rac(&s->c, s->header_state, p->diag_mc);
1525  put_symbol(&s->c, s->header_state, p->htaps/2-1, 0);
1526  for(i= p->htaps/2; i; i--)
1527  put_symbol(&s->c, s->header_state, FFABS(p->hcoeff[i]), 0);
1528  }
1529  }
1530  if(s->last_spatial_decomposition_count != s->spatial_decomposition_count){
1531  put_rac(&s->c, s->header_state, 1);
1532  put_symbol(&s->c, s->header_state, s->spatial_decomposition_count, 0);
1533  encode_qlogs(s);
1534  }else
1535  put_rac(&s->c, s->header_state, 0);
1536  }
1537 
1538  put_symbol(&s->c, s->header_state, s->spatial_decomposition_type - s->last_spatial_decomposition_type, 1);
1539  put_symbol(&s->c, s->header_state, s->qlog - s->last_qlog , 1);
1540  put_symbol(&s->c, s->header_state, s->mv_scale - s->last_mv_scale, 1);
1541  put_symbol(&s->c, s->header_state, s->qbias - s->last_qbias , 1);
1542  put_symbol(&s->c, s->header_state, s->block_max_depth - s->last_block_max_depth, 1);
1543 
1544 }
1545 
1546 static void update_last_header_values(SnowContext *s){
1547  int plane_index;
1548 
1549  if(!s->keyframe){
1550  for(plane_index=0; plane_index<2; plane_index++){
1551  Plane *p= &s->plane[plane_index];
1552  p->last_diag_mc= p->diag_mc;
1553  p->last_htaps = p->htaps;
1554  memcpy(p->last_hcoeff, p->hcoeff, sizeof(p->hcoeff));
1555  }
1556  }
1557 
1558  s->last_spatial_decomposition_type = s->spatial_decomposition_type;
1559  s->last_qlog = s->qlog;
1560  s->last_qbias = s->qbias;
1561  s->last_mv_scale = s->mv_scale;
1562  s->last_block_max_depth = s->block_max_depth;
1563  s->last_spatial_decomposition_count = s->spatial_decomposition_count;
1564 }
1565 
1566 static int qscale2qlog(int qscale){
1567  return rint(QROOT*log2(qscale / (float)FF_QP2LAMBDA))
1568  + 61*QROOT/8; ///< 64 > 60
1569 }
1570 
1571 static int ratecontrol_1pass(SnowContext *s, AVFrame *pict)
1572 {
1573  /* Estimate the frame's complexity as a sum of weighted dwt coefficients.
1574  * FIXME we know exact mv bits at this point,
1575  * but ratecontrol isn't set up to include them. */
1576  uint32_t coef_sum= 0;
1577  int level, orientation, delta_qlog;
1578 
1579  for(level=0; level<s->spatial_decomposition_count; level++){
1580  for(orientation=level ? 1 : 0; orientation<4; orientation++){
1581  SubBand *b= &s->plane[0].band[level][orientation];
1582  IDWTELEM *buf= b->ibuf;
1583  const int w= b->width;
1584  const int h= b->height;
1585  const int stride= b->stride;
1586  const int qlog= av_clip(2*QROOT + b->qlog, 0, QROOT*16);
1587  const int qmul= ff_qexp[qlog&(QROOT-1)]<<(qlog>>QSHIFT);
1588  const int qdiv= (1<<16)/qmul;
1589  int x, y;
1590  //FIXME this is ugly
1591  for(y=0; y<h; y++)
1592  for(x=0; x<w; x++)
1593  buf[x+y*stride]= b->buf[x+y*stride];
1594  if(orientation==0)
1595  decorrelate(s, b, buf, stride, 1, 0);
1596  for(y=0; y<h; y++)
1597  for(x=0; x<w; x++)
1598  coef_sum+= abs(buf[x+y*stride]) * qdiv >> 16;
1599  }
1600  }
1601 
1602  /* ugly, ratecontrol just takes a sqrt again */
1603  coef_sum = (uint64_t)coef_sum * coef_sum >> 16;
1604  assert(coef_sum < INT_MAX);
1605 
1606  if(pict->pict_type == AV_PICTURE_TYPE_I){
1607  s->m.current_picture.mb_var_sum= coef_sum;
1608  s->m.current_picture.mc_mb_var_sum= 0;
1609  }else{
1610  s->m.current_picture.mc_mb_var_sum= coef_sum;
1611  s->m.current_picture.mb_var_sum= 0;
1612  }
1613 
1614  pict->quality= ff_rate_estimate_qscale(&s->m, 1);
1615  if (pict->quality < 0)
1616  return INT_MIN;
1617  s->lambda= pict->quality * 3/2;
1618  delta_qlog= qscale2qlog(pict->quality) - s->qlog;
1619  s->qlog+= delta_qlog;
1620  return delta_qlog;
1621 }
1622 
1623 static void calculate_visual_weight(SnowContext *s, Plane *p){
1624  int width = p->width;
1625  int height= p->height;
1626  int level, orientation, x, y;
1627 
1628  for(level=0; level<s->spatial_decomposition_count; level++){
1629  for(orientation=level ? 1 : 0; orientation<4; orientation++){
1630  SubBand *b= &p->band[level][orientation];
1631  IDWTELEM *ibuf= b->ibuf;
1632  int64_t error=0;
1633 
1634  memset(s->spatial_idwt_buffer, 0, sizeof(*s->spatial_idwt_buffer)*width*height);
1635  ibuf[b->width/2 + b->height/2*b->stride]= 256*16;
1636  ff_spatial_idwt(s->spatial_idwt_buffer, s->temp_idwt_buffer, width, height, width, s->spatial_decomposition_type, s->spatial_decomposition_count);
1637  for(y=0; y<height; y++){
1638  for(x=0; x<width; x++){
1639  int64_t d= s->spatial_idwt_buffer[x + y*width]*16;
1640  error += d*d;
1641  }
1642  }
1643 
1644  b->qlog= (int)(log(352256.0/sqrt(error)) / log(pow(2.0, 1.0/QROOT))+0.5);
1645  }
1646  }
1647 }
1648 
1649 static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
1650  const AVFrame *pict, int *got_packet)
1651 {
1652  SnowContext *s = avctx->priv_data;
1653  RangeCoder * const c= &s->c;
1654  AVFrame *pic = &s->new_picture;
1655  const int width= s->avctx->width;
1656  const int height= s->avctx->height;
1657  int level, orientation, plane_index, i, y, ret;
1658  uint8_t rc_header_bak[sizeof(s->header_state)];
1659  uint8_t rc_block_bak[sizeof(s->block_state)];
1660 
1661  if ((ret = ff_alloc_packet2(avctx, pkt, s->b_width*s->b_height*MB_SIZE*MB_SIZE*3 + FF_MIN_BUFFER_SIZE)) < 0)
1662  return ret;
1663 
1664  ff_init_range_encoder(c, pkt->data, pkt->size);
1665  ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
1666 
1667  for(i=0; i<3; i++){
1668  int hshift= i ? s->chroma_h_shift : 0;
1669  int vshift= i ? s->chroma_v_shift : 0;
1670  for(y=0; y<(height>>vshift); y++)
1671  memcpy(&s->input_picture.data[i][y * s->input_picture.linesize[i]],
1672  &pict->data[i][y * pict->linesize[i]],
1673  width>>hshift);
1674  s->dsp.draw_edges(s->input_picture.data[i], s->input_picture.linesize[i],
1675  width >> hshift, height >> vshift,
1676  EDGE_WIDTH >> hshift, EDGE_WIDTH >> vshift,
1677  EDGE_TOP | EDGE_BOTTOM);
1678 
1679  }
1680  emms_c();
1681  s->new_picture = *pict;
1682 
1683  s->m.picture_number= avctx->frame_number;
1684  if(avctx->flags&CODEC_FLAG_PASS2){
1685  s->m.pict_type = pic->pict_type = s->m.rc_context.entry[avctx->frame_number].new_pict_type;
1686  s->keyframe = pic->pict_type == AV_PICTURE_TYPE_I;
1687  if(!(avctx->flags&CODEC_FLAG_QSCALE)) {
1688  pic->quality = ff_rate_estimate_qscale(&s->m, 0);
1689  if (pic->quality < 0)
1690  return -1;
1691  }
1692  }else{
1693  s->keyframe= avctx->gop_size==0 || avctx->frame_number % avctx->gop_size == 0;
1694  s->m.pict_type = pic->pict_type = s->keyframe ? AV_PICTURE_TYPE_I : AV_PICTURE_TYPE_P;
1695  }
1696 
1697  if(s->pass1_rc && avctx->frame_number == 0)
1698  pic->quality = 2*FF_QP2LAMBDA;
1699  if (pic->quality) {
1700  s->qlog = qscale2qlog(pic->quality);
1701  s->lambda = pic->quality * 3/2;
1702  }
1703  if (s->qlog < 0 || (!pic->quality && (avctx->flags & CODEC_FLAG_QSCALE))) {
1704  s->qlog= LOSSLESS_QLOG;
1705  s->lambda = 0;
1706  }//else keep previous frame's qlog until after motion estimation
1707 
1708  ff_snow_frame_start(s);
1709 
1710  s->m.current_picture_ptr= &s->m.current_picture;
1711  s->m.last_picture.f.pts = s->m.current_picture.f.pts;
1712  s->m.current_picture.f.pts = pict->pts;
1713  if(pic->pict_type == AV_PICTURE_TYPE_P){
1714  int block_width = (width +15)>>4;
1715  int block_height= (height+15)>>4;
1716  int stride= s->current_picture.linesize[0];
1717 
1718  assert(s->current_picture.data[0]);
1719  assert(s->last_picture[0].data[0]);
1720 
1721  s->m.avctx= s->avctx;
1722  s->m.current_picture.f.data[0] = s->current_picture.data[0];
1723  s->m. last_picture.f.data[0] = s->last_picture[0].data[0];
1724  s->m. new_picture.f.data[0] = s-> input_picture.data[0];
1725  s->m. last_picture_ptr= &s->m. last_picture;
1726  s->m.linesize=
1727  s->m. last_picture.f.linesize[0] =
1728  s->m. new_picture.f.linesize[0] =
1729  s->m.current_picture.f.linesize[0] = stride;
1730  s->m.uvlinesize= s->current_picture.linesize[1];
1731  s->m.width = width;
1732  s->m.height= height;
1733  s->m.mb_width = block_width;
1734  s->m.mb_height= block_height;
1735  s->m.mb_stride= s->m.mb_width+1;
1736  s->m.b8_stride= 2*s->m.mb_width+1;
1737  s->m.f_code=1;
1738  s->m.pict_type = pic->pict_type;
1739  s->m.me_method= s->avctx->me_method;
1740  s->m.me.scene_change_score=0;
1741  s->m.flags= s->avctx->flags;
1742  s->m.quarter_sample= (s->avctx->flags & CODEC_FLAG_QPEL)!=0;
1743  s->m.out_format= FMT_H263;
1744  s->m.unrestricted_mv= 1;
1745 
1746  s->m.lambda = s->lambda;
1747  s->m.qscale= (s->m.lambda*139 + FF_LAMBDA_SCALE*64) >> (FF_LAMBDA_SHIFT + 7);
1748  s->lambda2= s->m.lambda2= (s->m.lambda*s->m.lambda + FF_LAMBDA_SCALE/2) >> FF_LAMBDA_SHIFT;
1749 
1750  s->m.dsp= s->dsp; //move
1751  s->m.hdsp = s->hdsp;
1752  ff_init_me(&s->m);
1753  s->hdsp = s->m.hdsp;
1754  s->dsp= s->m.dsp;
1755  }
1756 
1757  if(s->pass1_rc){
1758  memcpy(rc_header_bak, s->header_state, sizeof(s->header_state));
1759  memcpy(rc_block_bak, s->block_state, sizeof(s->block_state));
1760  }
1761 
1762 redo_frame:
1763 
1764  if (pic->pict_type == AV_PICTURE_TYPE_I)
1765  s->spatial_decomposition_count= 5;
1766  else
1767  s->spatial_decomposition_count= 5;
1768 
1769  while( !(width >>(s->chroma_h_shift + s->spatial_decomposition_count))
1770  || !(height>>(s->chroma_v_shift + s->spatial_decomposition_count)))
1771  s->spatial_decomposition_count--;
1772 
1773  s->m.pict_type = pic->pict_type;
1774  s->qbias = pic->pict_type == AV_PICTURE_TYPE_P ? 2 : 0;
1775 
1776  ff_snow_common_init_after_header(avctx);
1777 
1778  if(s->last_spatial_decomposition_count != s->spatial_decomposition_count){
1779  for(plane_index=0; plane_index<3; plane_index++){
1780  calculate_visual_weight(s, &s->plane[plane_index]);
1781  }
1782  }
1783 
1784  encode_header(s);
1785  s->m.misc_bits = 8*(s->c.bytestream - s->c.bytestream_start);
1786  encode_blocks(s, 1);
1787  s->m.mv_bits = 8*(s->c.bytestream - s->c.bytestream_start) - s->m.misc_bits;
1788 
1789  for(plane_index=0; plane_index<3; plane_index++){
1790  Plane *p= &s->plane[plane_index];
1791  int w= p->width;
1792  int h= p->height;
1793  int x, y;
1794 // int bits= put_bits_count(&s->c.pb);
1795 
1796  if (!s->memc_only) {
1797  //FIXME optimize
1798  if(pict->data[plane_index]) //FIXME gray hack
1799  for(y=0; y<h; y++){
1800  for(x=0; x<w; x++){
1801  s->spatial_idwt_buffer[y*w + x]= pict->data[plane_index][y*pict->linesize[plane_index] + x]<<FRAC_BITS;
1802  }
1803  }
1804  predict_plane(s, s->spatial_idwt_buffer, plane_index, 0);
1805 
1806  if( plane_index==0
1807  && pic->pict_type == AV_PICTURE_TYPE_P
1808  && !(avctx->flags&CODEC_FLAG_PASS2)
1809  && s->m.me.scene_change_score > s->avctx->scenechange_threshold){
1810  ff_init_range_encoder(c, pkt->data, pkt->size);
1811  ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
1812  pic->pict_type= AV_PICTURE_TYPE_I;
1813  s->keyframe=1;
1814  s->current_picture.key_frame=1;
1815  goto redo_frame;
1816  }
1817 
1818  if(s->qlog == LOSSLESS_QLOG){
1819  for(y=0; y<h; y++){
1820  for(x=0; x<w; x++){
1821  s->spatial_dwt_buffer[y*w + x]= (s->spatial_idwt_buffer[y*w + x] + (1<<(FRAC_BITS-1))-1)>>FRAC_BITS;
1822  }
1823  }
1824  }else{
1825  for(y=0; y<h; y++){
1826  for(x=0; x<w; x++){
1827  s->spatial_dwt_buffer[y*w + x]=s->spatial_idwt_buffer[y*w + x]<<ENCODER_EXTRA_BITS;
1828  }
1829  }
1830  }
1831 
1832  /* if(QUANTIZE2)
1833  dwt_quantize(s, p, s->spatial_dwt_buffer, w, h, w, s->spatial_decomposition_type);
1834  else*/
1835  ff_spatial_dwt(s->spatial_dwt_buffer, s->temp_dwt_buffer, w, h, w, s->spatial_decomposition_type, s->spatial_decomposition_count);
1836 
1837  if(s->pass1_rc && plane_index==0){
1838  int delta_qlog = ratecontrol_1pass(s, pic);
1839  if (delta_qlog <= INT_MIN)
1840  return -1;
1841  if(delta_qlog){
1842  //reordering qlog in the bitstream would eliminate this reset
1843  ff_init_range_encoder(c, pkt->data, pkt->size);
1844  memcpy(s->header_state, rc_header_bak, sizeof(s->header_state));
1845  memcpy(s->block_state, rc_block_bak, sizeof(s->block_state));
1846  encode_header(s);
1847  encode_blocks(s, 0);
1848  }
1849  }
1850 
1851  for(level=0; level<s->spatial_decomposition_count; level++){
1852  for(orientation=level ? 1 : 0; orientation<4; orientation++){
1853  SubBand *b= &p->band[level][orientation];
1854 
1855  if(!QUANTIZE2)
1856  quantize(s, b, b->ibuf, b->buf, b->stride, s->qbias);
1857  if(orientation==0)
1858  decorrelate(s, b, b->ibuf, b->stride, pic->pict_type == AV_PICTURE_TYPE_P, 0);
1859  if (!s->no_bitstream)
1860  encode_subband(s, b, b->ibuf, b->parent ? b->parent->ibuf : NULL, b->stride, orientation);
1861  assert(b->parent==NULL || b->parent->stride == b->stride*2);
1862  if(orientation==0)
1863  correlate(s, b, b->ibuf, b->stride, 1, 0);
1864  }
1865  }
1866 
1867  for(level=0; level<s->spatial_decomposition_count; level++){
1868  for(orientation=level ? 1 : 0; orientation<4; orientation++){
1869  SubBand *b= &p->band[level][orientation];
1870 
1871  dequantize(s, b, b->ibuf, b->stride);
1872  }
1873  }
1874 
1875  ff_spatial_idwt(s->spatial_idwt_buffer, s->temp_idwt_buffer, w, h, w, s->spatial_decomposition_type, s->spatial_decomposition_count);
1876  if(s->qlog == LOSSLESS_QLOG){
1877  for(y=0; y<h; y++){
1878  for(x=0; x<w; x++){
1879  s->spatial_idwt_buffer[y*w + x]<<=FRAC_BITS;
1880  }
1881  }
1882  }
1883  predict_plane(s, s->spatial_idwt_buffer, plane_index, 1);
1884  }else{
1885  //ME/MC only
1886  if(pic->pict_type == AV_PICTURE_TYPE_I){
1887  for(y=0; y<h; y++){
1888  for(x=0; x<w; x++){
1889  s->current_picture.data[plane_index][y*s->current_picture.linesize[plane_index] + x]=
1890  pict->data[plane_index][y*pict->linesize[plane_index] + x];
1891  }
1892  }
1893  }else{
1894  memset(s->spatial_idwt_buffer, 0, sizeof(IDWTELEM)*w*h);
1895  predict_plane(s, s->spatial_idwt_buffer, plane_index, 1);
1896  }
1897  }
1898  if(s->avctx->flags&CODEC_FLAG_PSNR){
1899  int64_t error= 0;
1900 
1901  if(pict->data[plane_index]) //FIXME gray hack
1902  for(y=0; y<h; y++){
1903  for(x=0; x<w; x++){
1904  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];
1905  error += d*d;
1906  }
1907  }
1908  s->avctx->error[plane_index] += error;
1909  s->current_picture.error[plane_index] = error;
1910  }
1911 
1912  }
1913 
1914  update_last_header_values(s);
1915 
1916  ff_snow_release_buffer(avctx);
1917 
1918  s->current_picture.coded_picture_number = avctx->frame_number;
1919  s->current_picture.pict_type = pict->pict_type;
1920  s->current_picture.quality = pict->quality;
1921  s->m.frame_bits = 8*(s->c.bytestream - s->c.bytestream_start);
1922  s->m.p_tex_bits = s->m.frame_bits - s->m.misc_bits - s->m.mv_bits;
1923  s->m.current_picture.f.display_picture_number =
1924  s->m.current_picture.f.coded_picture_number = avctx->frame_number;
1925  s->m.current_picture.f.quality = pic->quality;
1926  s->m.total_bits += 8*(s->c.bytestream - s->c.bytestream_start);
1927  if(s->pass1_rc)
1928  if (ff_rate_estimate_qscale(&s->m, 0) < 0)
1929  return -1;
1930  if(avctx->flags&CODEC_FLAG_PASS1)
1931  ff_write_pass1_stats(&s->m);
1932  s->m.last_pict_type = s->m.pict_type;
1933  avctx->frame_bits = s->m.frame_bits;
1934  avctx->mv_bits = s->m.mv_bits;
1935  avctx->misc_bits = s->m.misc_bits;
1936  avctx->p_tex_bits = s->m.p_tex_bits;
1937 
1938  emms_c();
1939 
1940  pkt->size = ff_rac_terminate(c);
1941  if (avctx->coded_frame->key_frame)
1942  pkt->flags |= AV_PKT_FLAG_KEY;
1943  *got_packet = 1;
1944 
1945  return 0;
1946 }
1947 
1948 static av_cold int encode_end(AVCodecContext *avctx)
1949 {
1950  SnowContext *s = avctx->priv_data;
1951 
1952  ff_snow_common_end(s);
1953  av_frame_unref(&s->input_picture);
1954  av_free(avctx->stats_out);
1955 
1956  return 0;
1957 }
1958 
1959 #define OFFSET(x) offsetof(SnowContext, x)
1960 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1961 static const AVOption options[] = {
1962  { "memc_only", "Only do ME/MC (I frames -> ref, P frame -> ME+MC).", OFFSET(memc_only), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE },
1963  { "no_bitstream", "Skip final bitstream writeout.", OFFSET(no_bitstream), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE },
1964  { NULL },
1965 };
1966 
1967 static const AVClass snowenc_class = {
1968  .class_name = "snow encoder",
1969  .item_name = av_default_item_name,
1970  .option = options,
1971  .version = LIBAVUTIL_VERSION_INT,
1972 };
1973 
1974 AVCodec ff_snow_encoder = {
1975  .name = "snow",
1976  .type = AVMEDIA_TYPE_VIDEO,
1977  .id = AV_CODEC_ID_SNOW,
1978  .priv_data_size = sizeof(SnowContext),
1979  .init = encode_init,
1980  .encode2 = encode_frame,
1981  .close = encode_end,
1982  .pix_fmts = (const enum AVPixelFormat[]){
1983  AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV410P, AV_PIX_FMT_YUV444P,
1984  AV_PIX_FMT_NONE
1985  },
1986  .long_name = NULL_IF_CONFIG_SMALL("Snow"),
1987  .priv_class = &snowenc_class,
1988 };
1989 
1990 
1991 #ifdef TEST
1992 #undef malloc
1993 #undef free
1994 #undef printf
1995 
1996 #include "libavutil/lfg.h"
1997 #include "libavutil/mathematics.h"
1998 
1999 int main(void){
2000 #define width 256
2001 #define height 256
2002  int buffer[2][width*height];
2003  SnowContext s;
2004  int i;
2005  AVLFG prng;
2006  s.spatial_decomposition_count=6;
2007  s.spatial_decomposition_type=1;
2008 
2009  s.temp_dwt_buffer = av_mallocz(width * sizeof(DWTELEM));
2010  s.temp_idwt_buffer = av_mallocz(width * sizeof(IDWTELEM));
2011 
2012  av_lfg_init(&prng, 1);
2013 
2014  printf("testing 5/3 DWT\n");
2015  for(i=0; i<width*height; i++)
2016  buffer[0][i] = buffer[1][i] = av_lfg_get(&prng) % 54321 - 12345;
2017 
2018  ff_spatial_dwt(buffer[0], s.temp_dwt_buffer, width, height, width, s.spatial_decomposition_type, s.spatial_decomposition_count);
2019  ff_spatial_idwt((IDWTELEM*)buffer[0], s.temp_idwt_buffer, width, height, width, s.spatial_decomposition_type, s.spatial_decomposition_count);
2020 
2021  for(i=0; i<width*height; i++)
2022  if(buffer[0][i]!= buffer[1][i]) printf("fsck: %6d %12d %7d\n",i, buffer[0][i], buffer[1][i]);
2023 
2024  printf("testing 9/7 DWT\n");
2025  s.spatial_decomposition_type=0;
2026  for(i=0; i<width*height; i++)
2027  buffer[0][i] = buffer[1][i] = av_lfg_get(&prng) % 54321 - 12345;
2028 
2029  ff_spatial_dwt(buffer[0], s.temp_dwt_buffer, width, height, width, s.spatial_decomposition_type, s.spatial_decomposition_count);
2030  ff_spatial_idwt((IDWTELEM*)buffer[0], s.temp_idwt_buffer, width, height, width, s.spatial_decomposition_type, s.spatial_decomposition_count);
2031 
2032  for(i=0; i<width*height; i++)
2033  if(FFABS(buffer[0][i] - buffer[1][i])>20) printf("fsck: %6d %12d %7d\n",i, buffer[0][i], buffer[1][i]);
2034 
2035  {
2036  int level, orientation, x, y;
2037  int64_t errors[8][4];
2038  int64_t g=0;
2039 
2040  memset(errors, 0, sizeof(errors));
2041  s.spatial_decomposition_count=3;
2042  s.spatial_decomposition_type=0;
2043  for(level=0; level<s.spatial_decomposition_count; level++){
2044  for(orientation=level ? 1 : 0; orientation<4; orientation++){
2045  int w= width >> (s.spatial_decomposition_count-level);
2046  int h= height >> (s.spatial_decomposition_count-level);
2047  int stride= width << (s.spatial_decomposition_count-level);
2048  DWTELEM *buf= buffer[0];
2049  int64_t error=0;
2050 
2051  if(orientation&1) buf+=w;
2052  if(orientation>1) buf+=stride>>1;
2053 
2054  memset(buffer[0], 0, sizeof(int)*width*height);
2055  buf[w/2 + h/2*stride]= 256*256;
2056  ff_spatial_idwt((IDWTELEM*)buffer[0], s.temp_idwt_buffer, width, height, width, s.spatial_decomposition_type, s.spatial_decomposition_count);
2057  for(y=0; y<height; y++){
2058  for(x=0; x<width; x++){
2059  int64_t d= buffer[0][x + y*width];
2060  error += d*d;
2061  if(FFABS(width/2-x)<9 && FFABS(height/2-y)<9 && level==2) printf("%8"PRId64" ", d);
2062  }
2063  if(FFABS(height/2-y)<9 && level==2) printf("\n");
2064  }
2065  error= (int)(sqrt(error)+0.5);
2066  errors[level][orientation]= error;
2067  if(g) g=av_gcd(g, error);
2068  else g= error;
2069  }
2070  }
2071  printf("static int const visual_weight[][4]={\n");
2072  for(level=0; level<s.spatial_decomposition_count; level++){
2073  printf(" {");
2074  for(orientation=0; orientation<4; orientation++){
2075  printf("%8"PRId64",", errors[level][orientation]/g);
2076  }
2077  printf("},\n");
2078  }
2079  printf("};\n");
2080  {
2081  int level=2;
2082  int w= width >> (s.spatial_decomposition_count-level);
2083  //int h= height >> (s.spatial_decomposition_count-level);
2084  int stride= width << (s.spatial_decomposition_count-level);
2085  DWTELEM *buf= buffer[0];
2086  int64_t error=0;
2087 
2088  buf+=w;
2089  buf+=stride>>1;
2090 
2091  memset(buffer[0], 0, sizeof(int)*width*height);
2092  for(y=0; y<height; y++){
2093  for(x=0; x<width; x++){
2094  int tab[4]={0,2,3,1};
2095  buffer[0][x+width*y]= 256*256*tab[(x&1) + 2*(y&1)];
2096  }
2097  }
2098  ff_spatial_dwt(buffer[0], s.temp_dwt_buffer, width, height, width, s.spatial_decomposition_type, s.spatial_decomposition_count);
2099  for(y=0; y<height; y++){
2100  for(x=0; x<width; x++){
2101  int64_t d= buffer[0][x + y*width];
2102  error += d*d;
2103  if(FFABS(width/2-x)<9 && FFABS(height/2-y)<9) printf("%8"PRId64" ", d);
2104  }
2105  if(FFABS(height/2-y)<9) printf("\n");
2106  }
2107  }
2108 
2109  }
2110  return 0;
2111 }
2112 #endif /* TEST */
SnowContext::last_block_max_depth
int last_block_max_depth
Definition: snow.h:161
MotionEstContext::scratchpad
uint8_t * scratchpad
data area for the ME algo, so that the ME does not need to malloc/free
Definition: mpegvideo.h:190
snowenc_class
static const AVClass snowenc_class
Definition: snowenc.c:1967
AVLFG
Definition: lfg.h:25
QUANTIZE2
#define QUANTIZE2
Definition: snowenc.c:40
SnowContext::version
int version
Definition: snow.h:128
ys
output sine component ys
Definition: code Kat/hpsmodel.m:22
encode_end
static av_cold int encode_end(AVCodecContext *avctx)
Definition: snowenc.c:1948
SnowContext::m
MpegEncContext m
Definition: snow.h:171
MpegEncContext::frame_bits
int frame_bits
bits used for the current frame
Definition: mpegvideo.h:509
SnowContext::mv_scale
int mv_scale
Definition: snow.h:153
av_mallocz
void * av_mallocz(size_t size)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
Definition: mem.c:205
MpegEncContext::rc_context
RateControlContext rc_context
contains stuff only accessed in ratecontrol.c
Definition: mpegvideo.h:512
predict_plane
static av_always_inline void predict_plane(SnowContext *s, IDWTELEM *buf, int plane_index, int add)
Definition: snow.h:458
ff_snow_frame_start
int ff_snow_frame_start(SnowContext *s)
Definition: snow.c:599
QSHIFT
#define QSHIFT
Definition: snow.h:37
v
float v
Definition: avf_showspectrum.c:88
P_MEDIAN
#define P_MEDIAN
Definition: snowenc.c:318
MpegEncContext::picture_number
int picture_number
Definition: mpegvideo.h:275
s
const char * s
Definition: avisynth_c.h:668
SnowContext::new_picture
AVFrame new_picture
Definition: snow.h:117
P_TOPRIGHT
#define P_TOPRIGHT
Definition: snowenc.c:317
SnowContext::avctx
AVCodecContext * avctx
Definition: snow.h:110
SnowContext::block_max_depth
int block_max_depth
Definition: snow.h:160
SnowContext::last_spatial_decomposition_count
int last_spatial_decomposition_count
Definition: snow.h:133
shift
static int shift(int a, int b)
Definition: sonic.c:86
SnowContext::chroma_v_shift
int chroma_v_shift
Definition: snow.h:146
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:76
ref
FIXME Range Coding of cr are ref
Definition: snow.txt:367
MotionEstContext::skip
int skip
set if ME is skipped for the current MB
Definition: mpegvideo.h:187
rint
static double rint(double x)
Definition: libm.h:141
ff_init_range_encoder
void ff_init_range_encoder(RangeCoder *c, uint8_t *buf, int buf_size)
Definition: rangecoder.c:41
AVOption
AVOption.
Definition: opt.h:251
SnowContext::pass1_rc
int pass1_rc
Definition: snow.h:152
AVCodecContext::error
uint64_t error[AV_NUM_DATA_POINTERS]
error
Definition: libavcodec/avcodec.h:2503
CODEC_FLAG_PASS2
#define CODEC_FLAG_PASS2
Use internal 2pass ratecontrol in second pass mode.
Definition: libavcodec/avcodec.h:705
av_default_item_name
av_default_item_name
Definition: libvo-amrwbenc.c:49
AV_PIX_FMT_YUV444P
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:73
FF_CMP_NSSE
#define FF_CMP_NSSE
Definition: libavcodec/avcodec.h:1541
RateControlContext::entry
RateControlEntry * entry
Definition: ratecontrol.h:65
SnowContext::run_buffer
int * run_buffer
Definition: snow.h:143
P_LEFT
#define P_LEFT
Definition: snowenc.c:315
EDGE_TOP
#define EDGE_TOP
Definition: dsputil.h:265
CODEC_FLAG_PASS1
#define CODEC_FLAG_PASS1
Use internal 2pass ratecontrol in first pass mode.
Definition: libavcodec/avcodec.h:704
ff_h263_encode_init
void ff_h263_encode_init(MpegEncContext *s)
Definition: ituh263enc.c:767
AVCodecContext::coded_frame
AVFrame * coded_frame
the picture in the bitstream
Definition: libavcodec/avcodec.h:2567
init
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
AV_OPT_TYPE_INT
Definition: opt.h:222
SnowContext::always_reset
int always_reset
Definition: snow.h:127
SnowContext::no_bitstream
int no_bitstream
Definition: snow.h:169
MotionEstContext::current_mv_penalty
uint8_t * current_mv_penalty
Definition: mpegvideo.h:231
BLOCK_INTRA
#define BLOCK_INTRA
Definition: snow.h:52
MotionEstContext::sub_motion_search
int(* sub_motion_search)(struct MpegEncContext *s, int *mx_ptr, int *my_ptr, int dmin, int src_index, int ref_index, int size, int h)
Definition: mpegvideo.h:232
rangecoder.h
Range coder.
RangeCoder::bytestream_end
uint8_t * bytestream_end
Definition: rangecoder.h:44
y1
y1
Definition: lab5.m:33
FF_CMP_SSE
#define FF_CMP_SSE
Definition: libavcodec/avcodec.h:1532
MotionEstContext::sub_penalty_factor
int sub_penalty_factor
Definition: mpegvideo.h:204
pass
#define pass
Definition: fft.c:335
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: libavcodec/avcodec.h:1330
SnowContext::max_ref_frames
int max_ref_frames
Definition: snow.h:135
x1
x1
Definition: genspecsines3.m:7
MotionEstContext::score_map
uint32_t * score_map
map to store the scores
Definition: mpegvideo.h:196
mpegvideo.h
mpegvideo header.
Plane::last_hcoeff
int8_t last_hcoeff[HTAPS_MAX/2]
Definition: snow.h:104
MotionEstContext::scene_change_score
int scene_change_score
Definition: mpegvideo.h:224
ff_snow_common_init_after_header
int ff_snow_common_init_after_header(AVCodecContext *avctx)
Definition: snow.c:472
update_last_header_values
static void update_last_header_values(SnowContext *s)
Definition: snowenc.c:1546
SnowContext::keyframe
int keyframe
Definition: snow.h:126
run
uint8_t run
Definition: svq3.c:136
FF_LAMBDA_SHIFT
#define FF_LAMBDA_SHIFT
Definition: avutil.h:167
stride
int stride
Definition: mace.c:144
MpegEncContext::qscale
int qscale
QP.
Definition: mpegvideo.h:369
ff_snow_reset_contexts
void ff_snow_reset_contexts(SnowContext *s)
Definition: snow.c:69
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
IDWTELEM
short IDWTELEM
Definition: dirac_dwt.h:27
FF_CMP_RD
#define FF_CMP_RD
Definition: libavcodec/avcodec.h:1537
w
output residual component w
Definition: code Kat/hpsmodel.m:23
SnowContext::hdsp
HpelDSPContext hdsp
Definition: snow.h:113
CODEC_FLAG_QPEL
#define CODEC_FLAG_QPEL
Use qpel MC.
Definition: libavcodec/avcodec.h:695
AVCodecContext::scenechange_threshold
int scenechange_threshold
scene change detection threshold 0 is default, larger means fewer detected scene changes.
Definition: libavcodec/avcodec.h:1678
ff_snow_encoder
AVCodec ff_snow_encoder
Definition: snowenc.c:1974
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:866
OFFSET
#define OFFSET(x)
Definition: snowenc.c:1959
SubBand::qlog
int qlog
log(qscale)/log[2^(1/6)]
Definition: snow.h:82
d
set threshold d
Definition: extra/f0detectionyin.m:6
ff_rac_terminate
int ff_rac_terminate(RangeCoder *c)
Definition: rangecoder.c:101
BlockNode
Definition: snow.h:45
get_penalty_factor
static int get_penalty_factor(int lambda, int lambda2, int type)
Definition: snowenc.c:290
CODEC_FLAG_PSNR
#define CODEC_FLAG_PSNR
error[?] variables will be set during encoding.
Definition: libavcodec/avcodec.h:708
BlockNode::level
uint8_t level
Definition: snow.h:55
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:55
BlockNode::ref
uint8_t ref
Definition: snow.h:48
FF_CMP_W53
#define FF_CMP_W53
Definition: libavcodec/avcodec.h:1542
SnowContext::b_height
int b_height
Definition: snow.h:159
encode_frame
static int encode_frame(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *pict, int *got_packet)
Definition: snowenc.c:1649
uint8_t
uint8_t
Definition: audio_convert.c:194
BlockNode::mx
int16_t mx
Definition: snow.h:46
av_cold
#define av_cold
Definition: attributes.h:78
FRAC_BITS
#define FRAC_BITS
Definition: g729postfilter.c:33
put_symbol
static av_noinline void put_symbol(RangeCoder *c, uint8_t *state, int v, int is_signed)
Definition: ffv1enc.c:227
av_assert2
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:63
opt.h
AVOptions.
MpegEncContext::out_format
enum OutputFormat out_format
output format
Definition: mpegvideo.h:249
color
static const uint32_t color[16+AV_CLASS_CATEGORY_NB]
Definition: log.c:77
SnowContext::ref_scores
uint32_t * ref_scores[MAX_REF_FRAMES]
Definition: snow.h:138
pkt
static AVPacket pkt
Definition: demuxing.c:56
b
#define b
Definition: input.c:42
MB_SIZE
#define MB_SIZE
Definition: snow.h:68
MotionEstContext
Motion estimation context.
Definition: mpegvideo.h:185
emms_c
#define emms_c()
Definition: libavutil/internal.h:48
AVFrame::pts
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:159
MpegEncContext::misc_bits
int misc_bits
cbp, mb_type
Definition: mpegvideo.h:523
AVCodecContext::me_cmp
int me_cmp
motion estimation comparison function
Definition: libavcodec/avcodec.h:1512
SnowContext::current_picture
AVFrame current_picture
Definition: snow.h:119
MpegEncContext::current_picture
Picture current_picture
copy of the current picture structure.
Definition: mpegvideo.h:343
DSPContext::me_cmp
me_cmp_func me_cmp[6]
Definition: dsputil.h:167
ENCODER_EXTRA_BITS
#define ENCODER_EXTRA_BITS
Definition: snow.h:69
calculate_visual_weight
static void calculate_visual_weight(SnowContext *s, Plane *p)
Definition: snowenc.c:1623
BlockNode::my
int16_t my
Definition: snow.h:47
AVPacket::data
uint8_t * data
Definition: libavcodec/avcodec.h:1051
MotionEstContext::mv_penalty
uint8_t(* mv_penalty)[MAX_MV *2+1]
amount of bits needed to encode a MV
Definition: mpegvideo.h:230
snow_dwt.h
ff_set_cmp
void ff_set_cmp(DSPContext *c, me_cmp_func *cmp, int type)
Definition: dsputil.c:1869
null_block
static const BlockNode null_block
Definition: snow.h:58
sqrt
integer sqrt
Definition: avutil.txt:2
encode_blocks
static void encode_blocks(SnowContext *s, int search)
Definition: snowenc.c:1309
ff_epzs_motion_search
int ff_epzs_motion_search(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:972
MpegEncContext::mb_height
int mb_height
number of MBs horizontally & vertically
Definition: mpegvideo.h:277
ff_snow_release_buffer
void ff_snow_release_buffer(AVCodecContext *avctx)
Definition: snow.c:586
QEXPSHIFT
#define QEXPSHIFT
Definition: snow.h:510
AVCodecContext::stats_out
char * stats_out
pass1 encoding statistics output buffer
Definition: libavcodec/avcodec.h:2359
put_symbol2
static void put_symbol2(RangeCoder *c, uint8_t *state, int v, int log2)
Definition: snow.h:563
ROUNDED_DIV
#define ROUNDED_DIV(a, b)
Definition: common.h:50
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: libavcodec/avcodec.h:1101
DWT_97
#define DWT_97
Definition: snow_dwt.h:65
SnowContext::block
BlockNode * block
Definition: snow.h:163
Plane::last_diag_mc
int last_diag_mc
Definition: snow.h:105
x
Discrete Time axis x
Definition: FFT of a Simple Sinusoid.m:10
av_free
void av_free(void *ptr)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc(). ...
Definition: mem.c:183
ff_get_mb_score
int ff_get_mb_score(MpegEncContext *s, int mx, int my, int src_index, int ref_index, int size, int h, int add_rate)
Definition: motion_est_template.c:190
SnowContext::ref_mvs
int16_t(*[MAX_REF_FRAMES] ref_mvs)[2]
Definition: snow.h:137
MpegEncContext::total_bits
int64_t total_bits
Definition: mpegvideo.h:508
SnowContext::me_cache_generation
unsigned me_cache_generation
Definition: snow.h:166
FF_CMP_W97
#define FF_CMP_W97
Definition: libavcodec/avcodec.h:1543
AVCodecContext::me_sub_cmp
int me_sub_cmp
subpixel motion estimation comparison function
Definition: libavcodec/avcodec.h:1518
FF_CMP_BIT
#define FF_CMP_BIT
Definition: libavcodec/avcodec.h:1536
FF_CMP_DCT
#define FF_CMP_DCT
Definition: libavcodec/avcodec.h:1534
ff_write_pass1_stats
void ff_write_pass1_stats(MpegEncContext *s)
Definition: ratecontrol.c:44
MpegEncContext::unrestricted_mv
int unrestricted_mv
mv can point outside of the coded picture
Definition: mpegvideo.h:388
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: libavutil/internal.h:123
Plane::diag_mc
int diag_mc
Definition: snow.h:100
r
const char * r
Definition: vf_curves.c:94
pred_mv
static void pred_mv(DiracBlock *block, int stride, int x, int y, int ref)
Definition: libavcodec/diracdec.c:1081
change
About Git write you should know how to use GIT properly Luckily Git comes with excellent documentation git help man git shows you the available git< command > help man git< command > shows information about the subcommand< command > The most comprehensive manual is the website Git Reference visit they are quite exhaustive You do not need a special username or password All you need is to provide a ssh public key to the Git server admin What follows now is a basic introduction to Git and some FFmpeg specific guidelines Read it at least if you are granted commit privileges to the FFmpeg project you are expected to be familiar with these rules I if not You can get git from etc no matter how small Every one of them has been saved from looking like a fool by this many times It s very easy for stray debug output or cosmetic modifications to slip please avoid problems through this extra level of scrutiny For cosmetics only commits you should e g by running git config global user name My Name git config global user email my email which is either set in your personal configuration file through git config core editor or set by one of the following environment VISUAL or EDITOR Log messages should be concise but descriptive Explain why you made a change
Definition: git-howto.txt:153
SnowContext::dsp
DSPContext dsp
Definition: snow.h:112
ff_obmc_tab
const uint8_t *const ff_obmc_tab[4]
Definition: snowdata.h:123
AVCodecContext::flags
int flags
CODEC_FLAG_*.
Definition: libavcodec/avcodec.h:1222
get_dc
static int get_dc(SnowContext *s, int mb_x, int mb_y, int plane_index)
Definition: snowenc.c:600
CODEC_FLAG_QSCALE
#define CODEC_FLAG_QSCALE
Use fixed qscale.
Definition: libavcodec/avcodec.h:693
av_gcd
int64_t av_gcd(int64_t a, int64_t b)
Return the greatest common divisor of a and b.
Definition: mathematics.c:55
av_log
void av_log(void *avcl, int level, const char *fmt,...)
Definition: log.c:246
AVCodec::name
const char * name
Name of the codec implementation.
Definition: libavcodec/avcodec.h:2861
correlate
static void correlate(SnowContext *s, SubBand *b, IDWTELEM *src, int stride, int inverse, int use_median)
Definition: snowenc.c:1438
MpegEncContext::quarter_sample
int quarter_sample
1->qpel, 0->half pel ME/MC
Definition: mpegvideo.h:579
square
static int square(int x)
Definition: roqvideoenc.c:111
SnowContext::lambda
int lambda
Definition: snow.h:150
FFMAX
#define FFMAX(a, b)
Definition: common.h:56
FF_CMP_PSNR
#define FF_CMP_PSNR
Definition: libavcodec/avcodec.h:1535
avcodec.h
external API header
SnowContext::emu_edge_buffer
uint8_t * emu_edge_buffer
Definition: snow.h:174
RangeCoder::bytestream
uint8_t * bytestream
Definition: rangecoder.h:43
size
int size
Definition: twinvq_data.h:11127
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: libavcodec/avcodec.h:1057
ff_w97_32_c
int ff_w97_32_c(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)
Definition: snow_dwt.c:842
BlockNode::color
uint8_t color[3]
Definition: snow.h:49
SnowContext::ref_frames
int ref_frames
Definition: snow.h:136
Plane::htaps
int htaps
Definition: snow.h:98
SnowContext::qlog
int qlog
Definition: snow.h:148
AVCodecContext::refs
int refs
number of reference frames
Definition: libavcodec/avcodec.h:1779
FF_COMPLIANCE_EXPERIMENTAL
#define FF_COMPLIANCE_EXPERIMENTAL
Allow nonstandardized experimental things.
Definition: libavcodec/avcodec.h:2409
g
FFT buffer for g
Definition: stft_peak.m:17
ff_squareTbl
uint32_t ff_squareTbl[512]
Definition: dsputil.c:45
AVCodecContext::bit_rate
int bit_rate
the average bitrate
Definition: libavcodec/avcodec.h:1192
AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:216
ff_quant3bA
const int8_t ff_quant3bA[256]
Definition: snowdata.h:104
AVFrame::pict_type
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:144
FFMIN
#define FFMIN(a, b)
Definition: common.h:58
AVFrame::display_picture_number
int display_picture_number
picture number in display order
Definition: frame.h:180
FF_MIN_BUFFER_SIZE
#define FF_MIN_BUFFER_SIZE
minimum encoding buffer size Used to avoid some checks during header writing.
Definition: libavcodec/avcodec.h:568
ME_ITER
iterative search
Definition: libavcodec/avcodec.h:585
MpegEncContext::me_method
int me_method
ME algorithm.
Definition: mpegvideo.h:415
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:1034
ME_CACHE_SIZE
#define ME_CACHE_SIZE
Definition: snow.h:164
LOSSLESS_QLOG
#define LOSSLESS_QLOG
Definition: snow.h:39
DSPContext::draw_edges
void(* draw_edges)(uint8_t *buf, int wrap, int width, int height, int w, int h, int sides)
Definition: dsputil.h:263
ret
ret
Definition: avfilter.c:821
AVCodecContext::width
int width
picture width / height.
Definition: libavcodec/avcodec.h:1302
MpegEncContext::current_picture_ptr
Picture * current_picture_ptr
pointer to the current picture
Definition: mpegvideo.h:347
VE
#define VE
Definition: snowenc.c:1960
SnowContext::scratchbuf
uint8_t * scratchbuf
Definition: snow.h:173
t
t
Definition: genspecsines3.m:6
encode_q_branch
static int encode_q_branch(SnowContext *s, int level, int x, int y)
Definition: snowenc.c:322
SnowContext::plane
Plane plane[MAX_PLANES]
Definition: snow.h:162
ff_rate_estimate_qscale
float ff_rate_estimate_qscale(MpegEncContext *s, int dry_run)
Definition: ratecontrol.c:737
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:285
SnowContext::b_width
int b_width
Definition: snow.h:158
ff_build_rac_states
void ff_build_rac_states(RangeCoder *c, int factor, int max_p)
Definition: rangecoder.c:60
FFABS
#define FFABS(a)
Definition: common.h:53
AVFrame::quality
int quality
quality (between 1 (good) and FF_LAMBDA_MAX (bad))
Definition: frame.h:185
MpegEncContext::me
MotionEstContext me
Definition: mpegvideo.h:437
SnowContext::last_mv_scale
int last_mv_scale
Definition: snow.h:154
EDGE_BOTTOM
#define EDGE_BOTTOM
Definition: dsputil.h:266
SnowContext
struct SnowContext SnowContext
level
FIXME Range Coding of cr are level
Definition: snow.txt:367
y2
y2
Definition: lab5.m:34
avcodec_get_chroma_sub_sample
void avcodec_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: imgconvert.c:65
SnowContext::chroma_h_shift
int chroma_h_shift
Definition: snow.h:145
ME_MAP_SIZE
#define ME_MAP_SIZE
Definition: mpegvideo.h:68
LIBAVUTIL_VERSION_INT
LIBAVUTIL_VERSION_INT
Definition: eval.c:55
ff_alloc_packet2
int ff_alloc_packet2(AVCodecContext *avctx, AVPacket *avpkt, int size)
Check AVPacket size and/or allocate data.
Definition: libavcodec/utils.c:1377
MotionEstContext::penalty_factor
int penalty_factor
an estimate of the bits required to code a given mv value, e.g.
Definition: mpegvideo.h:199
pred
static const float pred[4]
Definition: siprdata.h:259
Plane::band
SubBand band[MAX_DWT_LEVELS][4]
Definition: libavcodec/diracdec.c:134
same_block
static av_always_inline int same_block(BlockNode *a, BlockNode *b)
Definition: snow.h:275
SnowContext::block_state
uint8_t block_state[128+32 *128]
Definition: snow.h:125
NULL
NULL
Definition: eval.c:55
SnowContext::qbias
int qbias
Definition: snow.h:155
AVFrame::coded_picture_number
int coded_picture_number
picture number in bitstream order
Definition: frame.h:176
width
static int width
Definition: tests/utils.c:158
FF_LAMBDA_SCALE
#define FF_LAMBDA_SCALE
Definition: avutil.h:168
AVFrame::error
uint64_t error[AV_NUM_DATA_POINTERS]
error
Definition: frame.h:254
src
AVS_Value src
Definition: avisynth_c.h:523
MpegEncContext::lambda2
unsigned int lambda2
(lambda*lambda) >> FF_LAMBDA_SHIFT
Definition: mpegvideo.h:372
encode_header
static void encode_header(SnowContext *s)
Definition: snowenc.c:1475
MotionEstContext::avctx
AVCodecContext * avctx
Definition: mpegvideo.h:186
LOG2_OBMC_MAX
#define LOG2_OBMC_MAX
Definition: snow.h:43
SnowContext::spatial_decomposition_count
int spatial_decomposition_count
Definition: snow.h:132
ff_sqrt
static av_const unsigned int ff_sqrt(unsigned int a)
Definition: mathops.h:198
DWTELEM
int DWTELEM
Definition: dirac_dwt.h:26
AVFrame::linesize
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:101
AVCodecContext::frame_bits
int frame_bits
number of bits used for the previously encoded frame
Definition: libavcodec/avcodec.h:2352
cb
FIXME Range Coding of cb
Definition: snow.txt:367
AVCodecContext
main external API structure.
Definition: libavcodec/avcodec.h:1134
Plane::hcoeff
int8_t hcoeff[HTAPS_MAX/2]
Definition: snow.h:99
close
static void close(AVCodecParserContext *s)
Definition: h264_parser.c:375
AV_CODEC_ID_SNOW
Definition: libavcodec/avcodec.h:294
QROOT
#define QROOT
Definition: snow.h:38
MpegEncContext::height
int height
picture size. must be a multiple of 16
Definition: mpegvideo.h:245
ff_snow_alloc_blocks
int ff_snow_alloc_blocks(SnowContext *s)
Definition: snow.c:83
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: libavcodec/utils.c:823
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:148
av_lfg_get
static unsigned int av_lfg_get(AVLFG *c)
Get the next random unsigned 32-bit number using an ALFG.
Definition: lfg.h:38
SubBand::parent
struct SubBand * parent
Definition: libavcodec/diracdec.c:105
buf
void * buf
Definition: avisynth_c.h:594
get_rac_count
static int get_rac_count(RangeCoder *c)
Definition: rangecoder.h:77
encode_q_branch2
static void encode_q_branch2(SnowContext *s, int level, int x, int y)
Definition: snowenc.c:546
SnowContext::me_cache
unsigned me_cache[ME_CACHE_SIZE]
Definition: snow.h:165
height
BYTE int const BYTE int int int height
Definition: avisynth_c.h:713
AV_PIX_FMT_YUV410P
planar YUV 4:1:0, 9bpp, (1 Cr & Cb sample per 4x4 Y samples)
Definition: pixfmt.h:74
value
double value
Definition: eval.c:82
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:50
x2
x2
Definition: genspecsines3.m:8
index
int index
Definition: gxfenc.c:89
ff_w53_32_c
int ff_w53_32_c(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)
Definition: snow_dwt.c:837
i
synthesis window for stochastic i
Definition: code Kat/hpsmodel.m:34
get_block_bits
static int get_block_bits(SnowContext *s, int x, int y, int w)
Definition: snowenc.c:658
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:736
mid_pred
#define mid_pred
Definition: mathops.h:94
MpegEncContext::dsp
DSPContext dsp
pointers for accelerated dsp functions
Definition: mpegvideo.h:391
av_lfg_init
av_cold void av_lfg_init(AVLFG *c, unsigned int seed)
Definition: lfg.c:30
SnowContext::temp_dwt_buffer
DWTELEM * temp_dwt_buffer
Definition: snow.h:140
av_frame_unref
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:330
MAX_MV
#define MAX_MV
Definition: mpegvideo.h:63
SnowContext::header_state
uint8_t header_state[32]
Definition: snow.h:124
MpegEncContext::f_code
int f_code
forward MV resolution
Definition: mpegvideo.h:395
type
#define type
SnowContext::last_qlog
int last_qlog
Definition: snow.h:149
MpegEncContext::pict_type
int pict_type
AV_PICTURE_TYPE_I, AV_PICTURE_TYPE_P, AV_PICTURE_TYPE_B, ...
Definition: mpegvideo.h:377
SnowContext::spatial_scalability
int spatial_scalability
Definition: snow.h:147
MpegEncContext::bit_rate
int bit_rate
wanted bit rate
Definition: mpegvideo.h:248
qscale2qlog
static int qscale2qlog(int qscale)
Definition: snowenc.c:1566
pix_sum
static int pix_sum(uint8_t *pix, int line_size, int w, int h)
Definition: snowenc.c:258
ff_snow_common_init
int ff_snow_common_init(AVCodecContext *avctx)
encode_qlogs
static void encode_qlogs(SnowContext *s)
Definition: snowenc.c:1462
AVCodecContext::global_quality
int global_quality
Global quality for codecs which cannot change it per frame.
Definition: libavcodec/avcodec.h:1208
state
static uint32_t state
Definition: trasher.c:27
ff_init_me
int ff_init_me(MpegEncContext *s)
Definition: motion_est.c:295
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:87
SnowContext::spatial_decomposition_type
int spatial_decomposition_type
Definition: snow.h:129
SnowContext::memc_only
int memc_only
Definition: snow.h:168
ff_snow_pred_block
void ff_snow_pred_block(SnowContext *s, uint8_t *dst, uint8_t *tmp, int stride, int sx, int sy, int b_w, int b_h, BlockNode *block, int plane_index, int w, int h)
Definition: snow.c:297
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:696
MpegEncContext::b8_stride
int b8_stride
2*mb_width+1 used for some 8x8 block arrays to allow simple addressing
Definition: mpegvideo.h:279
MpegEncContext::avctx
struct AVCodecContext * avctx
Definition: mpegvideo.h:243
AVCodecContext::gop_size
int gop_size
the number of pictures in a group of pictures, or 0 for intra_only
Definition: libavcodec/avcodec.h:1321
FF_CMP_DCT264
#define FF_CMP_DCT264
Definition: libavcodec/avcodec.h:1545
FF_CMP_SAD
#define FF_CMP_SAD
Definition: libavcodec/avcodec.h:1531
get_4block_rd
static int get_4block_rd(SnowContext *s, int mb_x, int mb_y, int plane_index)
Definition: snowenc.c:797
AVCodecContext::mb_cmp
int mb_cmp
macroblock comparison function (not supported yet)
Definition: libavcodec/avcodec.h:1524
AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:68
MID_STATE
#define MID_STATE
Definition: snow.h:34
SnowContext::temporal_decomposition_type
int temporal_decomposition_type
Definition: snow.h:131
QBIAS_SHIFT
#define QBIAS_SHIFT
Definition: snow.h:157
errors
total errors[f0error, f0index]
Definition: extra/TWM.m:54
internal.h
common internal api header.
MpegEncContext::mb_stride
int mb_stride
mb_width+1 used for some arrays to allow simple addressing of left & top MBs without sig11 ...
Definition: mpegvideo.h:278
SnowContext::temp_idwt_buffer
IDWTELEM * temp_idwt_buffer
Definition: snow.h:142
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:324
c
static double c[64]
Definition: vsrc_mptestsrc.c:88
MpegEncContext::last_pict_type
int last_pict_type
Definition: mpegvideo.h:379
MpegEncContext::last_picture
Picture last_picture
copy of the previous picture structure.
Definition: mpegvideo.h:325
MpegEncContext::obmc_scratchpad
uint8_t * obmc_scratchpad
Definition: mpegvideo.h:366
LOG2_MB_SIZE
#define LOG2_MB_SIZE
Definition: snow.h:67
AVCodecContext::prediction_method
int prediction_method
prediction method (needed for huffyuv)
Definition: libavcodec/avcodec.h:1486
put_rac
#define put_rac(C, S, B)
SnowContext::spatial_dwt_buffer
DWTELEM * spatial_dwt_buffer
Definition: snow.h:139
ff_rate_control_init
int ff_rate_control_init(MpegEncContext *s)
Definition: ratecontrol.c:86
buffer
the buffer and buffer reference mechanism is intended to as much as expensive copies of that data while still allowing the filters to produce correct results The data is stored in buffers represented by AVFilterBuffer structures They must not be accessed but through references stored in AVFilterBufferRef structures Several references can point to the same buffer
Definition: filter_design.txt:45
encode_init
static av_cold int encode_init(AVCodecContext *avctx)
Definition: snowenc.c:157
y
function y
Definition: D.m:1
SnowContext::lambda2
int lambda2
Definition: snow.h:151
SubBand::state
uint8_t state[7+512][32]
Definition: snow.h:90
options
static const AVOption options[]
Definition: snowenc.c:1961
MotionEstContext::map
uint32_t * map
map to avoid duplicate evaluations
Definition: mpegvideo.h:195
SnowContext::spatial_idwt_buffer
IDWTELEM * spatial_idwt_buffer
Definition: snow.h:141
dsputil.h
DSP utils.
RangeCoder::bytestream_start
uint8_t * bytestream_start
Definition: rangecoder.h:42
SnowContext::input_picture
AVFrame input_picture
new_picture with the internal linesizes
Definition: snow.h:118
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:1039
dequantize
static void dequantize(SnowContext *s, SubBand *b, IDWTELEM *src, int stride)
Definition: snowenc.c:1392
AVCodecContext::dia_size
int dia_size
ME diamond size & shape.
Definition: libavcodec/avcodec.h:1553
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:80
SnowContext::colorspace_type
int colorspace_type
Definition: snow.h:144
av_log2
#define av_log2
Definition: intmath.h:89
printf
printf("static const uint8_t my_array[100] = {\n")
dst
else dst[i][x+y *dst_stride[i]]
Definition: vf_mcdeint.c:160
Plane::last_htaps
int last_htaps
Definition: snow.h:103
EDGE_WIDTH
#define EDGE_WIDTH
Definition: dsputil.h:264
AVFrame::key_frame
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:139
SubBand::ibuf
IDWTELEM * ibuf
Definition: libavcodec/diracdec.c:104
FF_QP2LAMBDA
#define FF_QP2LAMBDA
factor to convert from H.263 QP to lambda
Definition: avutil.h:169
MpegEncContext::linesize
int linesize
line size, in bytes, may be different from width
Definition: mpegvideo.h:283
Plane::fast_mc
int fast_mc
Definition: snow.h:101
tab
static const struct twinvq_data tab
Definition: twinvq_data.h:11128
ff_snow_common_end
av_cold void ff_snow_common_end(SnowContext *s)
Definition: snow.c:650
FF_CMP_SATD
#define FF_CMP_SATD
Definition: libavcodec/avcodec.h:1533
Picture::f
struct AVFrame f
Definition: mpegvideo.h:98
SnowContext::c
RangeCoder c
Definition: snow.h:111
Picture::mb_var_sum
int mb_var_sum
sum of MB variance for current frame
Definition: mpegvideo.h:172
ff_qexp
uint8_t ff_qexp[QROOT]
Definition: snowdata.h:128
AVCodecContext::frame_number
int frame_number
Frame counter, set by libavcodec.
Definition: libavcodec/avcodec.h:1892
SubBand::buf
DWTELEM * buf
Definition: snow.h:83
MpegEncContext::flags
int flags
AVCodecContext.flags (HQ, MV4, ...)
Definition: mpegvideo.h:260
Picture::mc_mb_var_sum
int mc_mb_var_sum
motion compensated MB variance for current frame
Definition: mpegvideo.h:173
P_TOP
#define P_TOP
Definition: snowenc.c:316
MAX_REF_FRAMES
#define MAX_REF_FRAMES
Definition: snow.h:41
AVMEDIA_TYPE_VIDEO
Definition: avutil.h:143
thres2
static int thres2[99][16]
Definition: vf_pp7.c:216
av_always_inline
#define av_always_inline
Definition: attributes.h:41
MotionEstContext::temp
uint8_t * temp
Definition: mpegvideo.h:193
inverse
static uint32_t inverse(uint32_t v)
find multiplicative inverse modulo 2 ^ 32
Definition: asfcrypt.c:35
log2
integer integer log2
Definition: avutil.txt:2
BlockNode::type
uint8_t type
Definition: snow.h:50
AVCodecContext::me_method
int me_method
Motion estimation algorithm used for video coding.
Definition: libavcodec/avcodec.h:1339
DSPContext::me_sub_cmp
me_cmp_func me_sub_cmp[6]
Definition: dsputil.h:168
main
int main(int argc, char **argv)
Definition: main.c:22
ratecontrol_1pass
static int ratecontrol_1pass(SnowContext *s, AVFrame *pict)
Definition: snowenc.c:1571
SnowContext::last_qbias
int last_qbias
Definition: snow.h:156
cr
static double cr(void *priv, double x, double y)
Definition: vf_geq.c:85
CODEC_FLAG_4MV
#define CODEC_FLAG_4MV
4 MV per MB allowed / advanced prediction for H.263.
Definition: libavcodec/avcodec.h:694
pix_norm1
static int pix_norm1(uint8_t *pix, int line_size, int w)
Definition: snowenc.c:274
SnowContext::temporal_decomposition_count
int temporal_decomposition_count
Definition: snow.h:134
MpegEncContext::uvlinesize
int uvlinesize
line size, for chroma in bytes, may be different from width
Definition: mpegvideo.h:284
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:66
AVPacket
This structure stores compressed data.
Definition: libavcodec/avcodec.h:1028
decorrelate
static void decorrelate(SnowContext *s, SubBand *b, IDWTELEM *src, int stride, int inverse, int use_median)
Definition: snowenc.c:1414
BLOCK_OPT
#define BLOCK_OPT
Definition: snow.h:53
AV_GET_BUFFER_FLAG_REF
#define AV_GET_BUFFER_FLAG_REF
The decoder will keep a reference to the frame and may reuse it later.
Definition: libavcodec/avcodec.h:909
quantize
static void quantize(SnowContext *s, SubBand *b, IDWTELEM *dst, DWTELEM *src, int stride, int bias)
Definition: snowenc.c:1331
AVCodecContext::strict_std_compliance
int strict_std_compliance
strictly follow the standard (MPEG4, ...).
Definition: libavcodec/avcodec.h:2404
encode_subband
static int encode_subband(SnowContext *s, SubBand *b, const IDWTELEM *src, const IDWTELEM *parent, int stride, int orientation)
Definition: snowenc.c:986
SnowContext::last_spatial_decomposition_type
int last_spatial_decomposition_type
Definition: snow.h:130
t2
#define t2
Definition: regdef.h:30
AV_PICTURE_TYPE_P
Predicted.
Definition: avutil.h:217
MpegEncContext::lambda
unsigned int lambda
lagrange multipler used in rate distortion
Definition: mpegvideo.h:371
tb
#define tb
Definition: regdef.h:68
step
trying all byte sequences megabyte in length and selecting the best looking sequence will yield cases to try But a word about which is also called distortion Distortion can be quantified by almost any quality measurement one chooses the sum of squared differences is used but more complex methods that consider psychovisual effects can be used as well It makes no difference in this discussion First step
Definition: rate_distortion.txt:12
MpegEncContext::hdsp
HpelDSPContext hdsp
Definition: mpegvideo.h:393
iterative_me
static void iterative_me(SnowContext *s)
Definition: snowenc.c:1085
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:993
SnowContext::last_picture
AVFrame last_picture[MAX_REF_FRAMES]
Definition: snow.h:120
Generated on Fri Dec 20 2024 06:56:07 for FFmpeg by   doxygen 1.8.11