falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
56097 Commits
32 Branches
283MB
Tree: ea538b0d64
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'ea538b0d64'
${ noResults }
FFmpeg/libavcodec/snowenc.c

2020 lines
77KB
Raw Blame History 

  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. static av_cold int encode_init(AVCodecContext *avctx)

  38. {

  39.     SnowContext *s = avctx->priv_data;

  40.     int plane_index, ret;

  41. 

  42.     if(avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL){

  43.         av_log(avctx, AV_LOG_ERROR, "This codec is under development, files encoded with it may not be decodable with future versions!!!\n"

  44.                "Use vstrict=-2 / -strict -2 to use it anyway.\n");

  45.         return -1;

  46.     }

  47. 

  48.     if(avctx->prediction_method == DWT_97

  49.        && (avctx->flags & CODEC_FLAG_QSCALE)

  50.        && avctx->global_quality == 0){

  51.         av_log(avctx, AV_LOG_ERROR, "The 9/7 wavelet is incompatible with lossless mode.\n");

  52.         return -1;

  53.     }

  54. 

  55.     s->spatial_decomposition_type= avctx->prediction_method; //FIXME add decorrelator type r transform_type

  56. 

  57.     s->mv_scale       = (avctx->flags & CODEC_FLAG_QPEL) ? 2 : 4;

  58.     s->block_max_depth= (avctx->flags & CODEC_FLAG_4MV ) ? 1 : 0;

  59. 

  60.     for(plane_index=0; plane_index<3; plane_index++){

  61.         s->plane[plane_index].diag_mc= 1;

  62.         s->plane[plane_index].htaps= 6;

  63.         s->plane[plane_index].hcoeff[0]=  40;

  64.         s->plane[plane_index].hcoeff[1]= -10;

  65.         s->plane[plane_index].hcoeff[2]=   2;

  66.         s->plane[plane_index].fast_mc= 1;

  67.     }

  68. 

  69.     if ((ret = ff_snow_common_init(avctx)) < 0) {

  70.         ff_snow_common_end(avctx->priv_data);

  71.         return ret;

  72.     }

  73.     ff_snow_alloc_blocks(s);

  74. 

  75.     s->version=0;

  76. 

  77.     s->m.avctx   = avctx;

  78.     s->m.flags   = avctx->flags;

  79.     s->m.bit_rate= avctx->bit_rate;

  80. 

  81.     s->m.me.temp      =

  82.     s->m.me.scratchpad= av_mallocz((avctx->width+64)*2*16*2*sizeof(uint8_t));

  83.     s->m.me.map       = av_mallocz(ME_MAP_SIZE*sizeof(uint32_t));

  84.     s->m.me.score_map = av_mallocz(ME_MAP_SIZE*sizeof(uint32_t));

  85.     s->m.obmc_scratchpad= av_mallocz(MB_SIZE*MB_SIZE*12*sizeof(uint32_t));

  86.     if (!s->m.me.scratchpad || !s->m.me.map || !s->m.me.score_map || !s->m.obmc_scratchpad)

  87.         return AVERROR(ENOMEM);

  88. 

  89.     ff_h263_encode_init(&s->m); //mv_penalty

  90. 

  91.     s->max_ref_frames = FFMAX(FFMIN(avctx->refs, MAX_REF_FRAMES), 1);

  92. 

  93.     if(avctx->flags&CODEC_FLAG_PASS1){

  94.         if(!avctx->stats_out)

  95.             avctx->stats_out = av_mallocz(256);

  96. 

  97.         if (!avctx->stats_out)

  98.             return AVERROR(ENOMEM);

  99.     }

  100.     if((avctx->flags&CODEC_FLAG_PASS2) || !(avctx->flags&CODEC_FLAG_QSCALE)){

  101.         if(ff_rate_control_init(&s->m) < 0)

  102.             return -1;

  103.     }

  104.     s->pass1_rc= !(avctx->flags & (CODEC_FLAG_QSCALE|CODEC_FLAG_PASS2));

  105. 

  106.     switch(avctx->pix_fmt){

  107.     case AV_PIX_FMT_YUV444P:

  108. //    case AV_PIX_FMT_YUV422P:

  109.     case AV_PIX_FMT_YUV420P:

  110. //    case AV_PIX_FMT_YUV411P:

  111.     case AV_PIX_FMT_YUV410P:

  112.         s->nb_planes = 3;

  113.         s->colorspace_type= 0;

  114.         break;

  115.     case AV_PIX_FMT_GRAY8:

  116.         s->nb_planes = 1;

  117.         s->colorspace_type = 1;

  118.         break;

  119. /*    case AV_PIX_FMT_RGB32:

  120.         s->colorspace= 1;

  121.         break;*/

  122.     default:

  123.         av_log(avctx, AV_LOG_ERROR, "pixel format not supported\n");

  124.         return -1;

  125.     }

  126.     avcodec_get_chroma_sub_sample(avctx->pix_fmt, &s->chroma_h_shift, &s->chroma_v_shift);

  127. 

  128.     ff_set_cmp(&s->dsp, s->dsp.me_cmp, s->avctx->me_cmp);

  129.     ff_set_cmp(&s->dsp, s->dsp.me_sub_cmp, s->avctx->me_sub_cmp);

  130. 

  131.     s->input_picture = av_frame_alloc();

  132.     if (!s->input_picture)

  133.         return AVERROR(ENOMEM);

  134.     if ((ret = ff_get_buffer(s->avctx, s->input_picture, AV_GET_BUFFER_FLAG_REF)) < 0)

  135.         return ret;

  136. 

  137.     if(s->avctx->me_method == ME_ITER){

  138.         int i;

  139.         int size= s->b_width * s->b_height << 2*s->block_max_depth;

  140.         for(i=0; i<s->max_ref_frames; i++){

  141.             s->ref_mvs[i]= av_mallocz(size*sizeof(int16_t[2]));

  142.             s->ref_scores[i]= av_mallocz(size*sizeof(uint32_t));

  143.             if (!s->ref_mvs[i] || !s->ref_scores[i])

  144.                 return AVERROR(ENOMEM);

  145.         }

  146.     }

  147. 

  148.     return 0;

  149. }

  150. 

  151. //near copy & paste from dsputil, FIXME

  152. static int pix_sum(uint8_t * pix, int line_size, int w, int h)

  153. {

  154.     int s, i, j;

  155. 

  156.     s = 0;

  157.     for (i = 0; i < h; i++) {

  158.         for (j = 0; j < w; j++) {

  159.             s += pix[0];

  160.             pix ++;

  161.         }

  162.         pix += line_size - w;

  163.     }

  164.     return s;

  165. }

  166. 

  167. //near copy & paste from dsputil, FIXME

  168. static int pix_norm1(uint8_t * pix, int line_size, int w)

  169. {

  170.     int s, i, j;

  171.     uint32_t *sq = ff_squareTbl + 256;

  172. 

  173.     s = 0;

  174.     for (i = 0; i < w; i++) {

  175.         for (j = 0; j < w; j ++) {

  176.             s += sq[pix[0]];

  177.             pix ++;

  178.         }

  179.         pix += line_size - w;

  180.     }

  181.     return s;

  182. }

  183. 

  184. static inline int get_penalty_factor(int lambda, int lambda2, int type){

  185.     switch(type&0xFF){

  186.     default:

  187.     case FF_CMP_SAD:

  188.         return lambda>>FF_LAMBDA_SHIFT;

  189.     case FF_CMP_DCT:

  190.         return (3*lambda)>>(FF_LAMBDA_SHIFT+1);

  191.     case FF_CMP_W53:

  192.         return (4*lambda)>>(FF_LAMBDA_SHIFT);

  193.     case FF_CMP_W97:

  194.         return (2*lambda)>>(FF_LAMBDA_SHIFT);

  195.     case FF_CMP_SATD:

  196.     case FF_CMP_DCT264:

  197.         return (2*lambda)>>FF_LAMBDA_SHIFT;

  198.     case FF_CMP_RD:

  199.     case FF_CMP_PSNR:

  200.     case FF_CMP_SSE:

  201.     case FF_CMP_NSSE:

  202.         return lambda2>>FF_LAMBDA_SHIFT;

  203.     case FF_CMP_BIT:

  204.         return 1;

  205.     }

  206. }

  207. 

  208. //FIXME copy&paste

  209. #define P_LEFT P[1]

  210. #define P_TOP P[2]

  211. #define P_TOPRIGHT P[3]

  212. #define P_MEDIAN P[4]

  213. #define P_MV1 P[9]

  214. #define FLAG_QPEL   1 //must be 1

  215. 

  216. static int encode_q_branch(SnowContext *s, int level, int x, int y){

  217.     uint8_t p_buffer[1024];

  218.     uint8_t i_buffer[1024];

  219.     uint8_t p_state[sizeof(s->block_state)];

  220.     uint8_t i_state[sizeof(s->block_state)];

  221.     RangeCoder pc, ic;

  222.     uint8_t *pbbak= s->c.bytestream;

  223.     uint8_t *pbbak_start= s->c.bytestream_start;

  224.     int score, score2, iscore, i_len, p_len, block_s, sum, base_bits;

  225.     const int w= s->b_width  << s->block_max_depth;

  226.     const int h= s->b_height << s->block_max_depth;

  227.     const int rem_depth= s->block_max_depth - level;

  228.     const int index= (x + y*w) << rem_depth;

  229.     const int block_w= 1<<(LOG2_MB_SIZE - level);

  230.     int trx= (x+1)<<rem_depth;

  231.     int try= (y+1)<<rem_depth;

  232.     const BlockNode *left  = x ? &s->block[index-1] : &null_block;

  233.     const BlockNode *top   = y ? &s->block[index-w] : &null_block;

  234.     const BlockNode *right = trx<w ? &s->block[index+1] : &null_block;

  235.     const BlockNode *bottom= try<h ? &s->block[index+w] : &null_block;

  236.     const BlockNode *tl    = y && x ? &s->block[index-w-1] : left;

  237.     const BlockNode *tr    = y && trx<w && ((x&1)==0 || level==0) ? &s->block[index-w+(1<<rem_depth)] : tl; //FIXME use lt

  238.     int pl = left->color[0];

  239.     int pcb= left->color[1];

  240.     int pcr= left->color[2];

  241.     int pmx, pmy;

  242.     int mx=0, my=0;

  243.     int l,cr,cb;

  244.     const int stride= s->current_picture->linesize[0];

  245.     const int uvstride= s->current_picture->linesize[1];

  246.     uint8_t *current_data[3]= { s->input_picture->data[0] + (x + y*  stride)*block_w,

  247.                                 s->input_picture->data[1] + ((x*block_w)>>s->chroma_h_shift) + ((y*uvstride*block_w)>>s->chroma_v_shift),

  248.                                 s->input_picture->data[2] + ((x*block_w)>>s->chroma_h_shift) + ((y*uvstride*block_w)>>s->chroma_v_shift)};

  249.     int P[10][2];

  250.     int16_t last_mv[3][2];

  251.     int qpel= !!(s->avctx->flags & CODEC_FLAG_QPEL); //unused

  252.     const int shift= 1+qpel;

  253.     MotionEstContext *c= &s->m.me;

  254.     int ref_context= av_log2(2*left->ref) + av_log2(2*top->ref);

  255.     int mx_context= av_log2(2*FFABS(left->mx - top->mx));

  256.     int my_context= av_log2(2*FFABS(left->my - top->my));

  257.     int s_context= 2*left->level + 2*top->level + tl->level + tr->level;

  258.     int ref, best_ref, ref_score, ref_mx, ref_my;

  259. 

  260.     av_assert0(sizeof(s->block_state) >= 256);

  261.     if(s->keyframe){

  262.         set_blocks(s, level, x, y, pl, pcb, pcr, 0, 0, 0, BLOCK_INTRA);

  263.         return 0;

  264.     }

  265. 

  266. //    clip predictors / edge ?

  267. 

  268.     P_LEFT[0]= left->mx;

  269.     P_LEFT[1]= left->my;

  270.     P_TOP [0]= top->mx;

  271.     P_TOP [1]= top->my;

  272.     P_TOPRIGHT[0]= tr->mx;

  273.     P_TOPRIGHT[1]= tr->my;

  274. 

  275.     last_mv[0][0]= s->block[index].mx;

  276.     last_mv[0][1]= s->block[index].my;

  277.     last_mv[1][0]= right->mx;

  278.     last_mv[1][1]= right->my;

  279.     last_mv[2][0]= bottom->mx;

  280.     last_mv[2][1]= bottom->my;

  281. 

  282.     s->m.mb_stride=2;

  283.     s->m.mb_x=

  284.     s->m.mb_y= 0;

  285.     c->skip= 0;

  286. 

  287.     av_assert1(c->  stride ==   stride);

  288.     av_assert1(c->uvstride == uvstride);

  289. 

  290.     c->penalty_factor    = get_penalty_factor(s->lambda, s->lambda2, c->avctx->me_cmp);

  291.     c->sub_penalty_factor= get_penalty_factor(s->lambda, s->lambda2, c->avctx->me_sub_cmp);

  292.     c->mb_penalty_factor = get_penalty_factor(s->lambda, s->lambda2, c->avctx->mb_cmp);

  293.     c->current_mv_penalty= c->mv_penalty[s->m.f_code=1] + MAX_MV;

  294. 

  295.     c->xmin = - x*block_w - 16+3;

  296.     c->ymin = - y*block_w - 16+3;

  297.     c->xmax = - (x+1)*block_w + (w<<(LOG2_MB_SIZE - s->block_max_depth)) + 16-3;

  298.     c->ymax = - (y+1)*block_w + (h<<(LOG2_MB_SIZE - s->block_max_depth)) + 16-3;

  299. 

  300.     if(P_LEFT[0]     > (c->xmax<<shift)) P_LEFT[0]    = (c->xmax<<shift);

  301.     if(P_LEFT[1]     > (c->ymax<<shift)) P_LEFT[1]    = (c->ymax<<shift);

  302.     if(P_TOP[0]      > (c->xmax<<shift)) P_TOP[0]     = (c->xmax<<shift);

  303.     if(P_TOP[1]      > (c->ymax<<shift)) P_TOP[1]     = (c->ymax<<shift);

  304.     if(P_TOPRIGHT[0] < (c->xmin<<shift)) P_TOPRIGHT[0]= (c->xmin<<shift);

  305.     if(P_TOPRIGHT[0] > (c->xmax<<shift)) P_TOPRIGHT[0]= (c->xmax<<shift); //due to pmx no clip

  306.     if(P_TOPRIGHT[1] > (c->ymax<<shift)) P_TOPRIGHT[1]= (c->ymax<<shift);

  307. 

  308.     P_MEDIAN[0]= mid_pred(P_LEFT[0], P_TOP[0], P_TOPRIGHT[0]);

  309.     P_MEDIAN[1]= mid_pred(P_LEFT[1], P_TOP[1], P_TOPRIGHT[1]);

  310. 

  311.     if (!y) {

  312.         c->pred_x= P_LEFT[0];

  313.         c->pred_y= P_LEFT[1];

  314.     } else {

  315.         c->pred_x = P_MEDIAN[0];

  316.         c->pred_y = P_MEDIAN[1];

  317.     }

  318. 

  319.     score= INT_MAX;

  320.     best_ref= 0;

  321.     for(ref=0; ref<s->ref_frames; ref++){

  322.         init_ref(c, current_data, s->last_picture[ref]->data, NULL, block_w*x, block_w*y, 0);

  323. 

  324.         ref_score= ff_epzs_motion_search(&s->m, &ref_mx, &ref_my, P, 0, /*ref_index*/ 0, last_mv,

  325.                                          (1<<16)>>shift, level-LOG2_MB_SIZE+4, block_w);

  326. 

  327.         av_assert2(ref_mx >= c->xmin);

  328.         av_assert2(ref_mx <= c->xmax);

  329.         av_assert2(ref_my >= c->ymin);

  330.         av_assert2(ref_my <= c->ymax);

  331. 

  332.         ref_score= c->sub_motion_search(&s->m, &ref_mx, &ref_my, ref_score, 0, 0, level-LOG2_MB_SIZE+4, block_w);

  333.         ref_score= ff_get_mb_score(&s->m, ref_mx, ref_my, 0, 0, level-LOG2_MB_SIZE+4, block_w, 0);

  334.         ref_score+= 2*av_log2(2*ref)*c->penalty_factor;

  335.         if(s->ref_mvs[ref]){

  336.             s->ref_mvs[ref][index][0]= ref_mx;

  337.             s->ref_mvs[ref][index][1]= ref_my;

  338.             s->ref_scores[ref][index]= ref_score;

  339.         }

  340.         if(score > ref_score){

  341.             score= ref_score;

  342.             best_ref= ref;

  343.             mx= ref_mx;

  344.             my= ref_my;

  345.         }

  346.     }

  347.     //FIXME if mb_cmp != SSE then intra cannot be compared currently and mb_penalty vs. lambda2

  348. 

  349.   //  subpel search

  350.     base_bits= get_rac_count(&s->c) - 8*(s->c.bytestream - s->c.bytestream_start);

  351.     pc= s->c;

  352.     pc.bytestream_start=

  353.     pc.bytestream= p_buffer; //FIXME end/start? and at the other stoo

  354.     memcpy(p_state, s->block_state, sizeof(s->block_state));

  355. 

  356.     if(level!=s->block_max_depth)

  357.         put_rac(&pc, &p_state[4 + s_context], 1);

  358.     put_rac(&pc, &p_state[1 + left->type + top->type], 0);

  359.     if(s->ref_frames > 1)

  360.         put_symbol(&pc, &p_state[128 + 1024 + 32*ref_context], best_ref, 0);

  361.     pred_mv(s, &pmx, &pmy, best_ref, left, top, tr);

  362.     put_symbol(&pc, &p_state[128 + 32*(mx_context + 16*!!best_ref)], mx - pmx, 1);

  363.     put_symbol(&pc, &p_state[128 + 32*(my_context + 16*!!best_ref)], my - pmy, 1);

  364.     p_len= pc.bytestream - pc.bytestream_start;

  365.     score += (s->lambda2*(get_rac_count(&pc)-base_bits))>>FF_LAMBDA_SHIFT;

  366. 

  367.     block_s= block_w*block_w;

  368.     sum = pix_sum(current_data[0], stride, block_w, block_w);

  369.     l= (sum + block_s/2)/block_s;

  370.     iscore = pix_norm1(current_data[0], stride, block_w) - 2*l*sum + l*l*block_s;

  371. 

  372.     if (s->nb_planes > 2) {

  373.         block_s= block_w*block_w>>(s->chroma_h_shift + s->chroma_v_shift);

  374.         sum = pix_sum(current_data[1], uvstride, block_w>>s->chroma_h_shift, block_w>>s->chroma_v_shift);

  375.         cb= (sum + block_s/2)/block_s;

  376.     //    iscore += pix_norm1(&current_mb[1][0], uvstride, block_w>>1) - 2*cb*sum + cb*cb*block_s;

  377.         sum = pix_sum(current_data[2], uvstride, block_w>>s->chroma_h_shift, block_w>>s->chroma_v_shift);

  378.         cr= (sum + block_s/2)/block_s;

  379.     //    iscore += pix_norm1(&current_mb[2][0], uvstride, block_w>>1) - 2*cr*sum + cr*cr*block_s;

  380.     }else

  381.         cb = cr = 0;

  382. 

  383.     ic= s->c;

  384.     ic.bytestream_start=

  385.     ic.bytestream= i_buffer; //FIXME end/start? and at the other stoo

  386.     memcpy(i_state, s->block_state, sizeof(s->block_state));

  387.     if(level!=s->block_max_depth)

  388.         put_rac(&ic, &i_state[4 + s_context], 1);

  389.     put_rac(&ic, &i_state[1 + left->type + top->type], 1);

  390.     put_symbol(&ic, &i_state[32],  l-pl , 1);

  391.     if (s->nb_planes > 2) {

  392.         put_symbol(&ic, &i_state[64], cb-pcb, 1);

  393.         put_symbol(&ic, &i_state[96], cr-pcr, 1);

  394.     }

  395.     i_len= ic.bytestream - ic.bytestream_start;

  396.     iscore += (s->lambda2*(get_rac_count(&ic)-base_bits))>>FF_LAMBDA_SHIFT;

  397. 

  398. //    assert(score==256*256*256*64-1);

  399.     av_assert1(iscore < 255*255*256 + s->lambda2*10);

  400.     av_assert1(iscore >= 0);

  401.     av_assert1(l>=0 && l<=255);

  402.     av_assert1(pl>=0 && pl<=255);

  403. 

  404.     if(level==0){

  405.         int varc= iscore >> 8;

  406.         int vard= score >> 8;

  407.         if (vard <= 64 || vard < varc)

  408.             c->scene_change_score+= ff_sqrt(vard) - ff_sqrt(varc);

  409.         else

  410.             c->scene_change_score+= s->m.qscale;

  411.     }

  412. 

  413.     if(level!=s->block_max_depth){

  414.         put_rac(&s->c, &s->block_state[4 + s_context], 0);

  415.         score2 = encode_q_branch(s, level+1, 2*x+0, 2*y+0);

  416.         score2+= encode_q_branch(s, level+1, 2*x+1, 2*y+0);

  417.         score2+= encode_q_branch(s, level+1, 2*x+0, 2*y+1);

  418.         score2+= encode_q_branch(s, level+1, 2*x+1, 2*y+1);

  419.         score2+= s->lambda2>>FF_LAMBDA_SHIFT; //FIXME exact split overhead

  420. 

  421.         if(score2 < score && score2 < iscore)

  422.             return score2;

  423.     }

  424. 

  425.     if(iscore < score){

  426.         pred_mv(s, &pmx, &pmy, 0, left, top, tr);

  427.         memcpy(pbbak, i_buffer, i_len);

  428.         s->c= ic;

  429.         s->c.bytestream_start= pbbak_start;

  430.         s->c.bytestream= pbbak + i_len;

  431.         set_blocks(s, level, x, y, l, cb, cr, pmx, pmy, 0, BLOCK_INTRA);

  432.         memcpy(s->block_state, i_state, sizeof(s->block_state));

  433.         return iscore;

  434.     }else{

  435.         memcpy(pbbak, p_buffer, p_len);

  436.         s->c= pc;

  437.         s->c.bytestream_start= pbbak_start;

  438.         s->c.bytestream= pbbak + p_len;

  439.         set_blocks(s, level, x, y, pl, pcb, pcr, mx, my, best_ref, 0);

  440.         memcpy(s->block_state, p_state, sizeof(s->block_state));

  441.         return score;

  442.     }

  443. }

  444. 

  445. static void encode_q_branch2(SnowContext *s, int level, int x, int y){

  446.     const int w= s->b_width  << s->block_max_depth;

  447.     const int rem_depth= s->block_max_depth - level;

  448.     const int index= (x + y*w) << rem_depth;

  449.     int trx= (x+1)<<rem_depth;

  450.     BlockNode *b= &s->block[index];

  451.     const BlockNode *left  = x ? &s->block[index-1] : &null_block;

  452.     const BlockNode *top   = y ? &s->block[index-w] : &null_block;

  453.     const BlockNode *tl    = y && x ? &s->block[index-w-1] : left;

  454.     const BlockNode *tr    = y && trx<w && ((x&1)==0 || level==0) ? &s->block[index-w+(1<<rem_depth)] : tl; //FIXME use lt

  455.     int pl = left->color[0];

  456.     int pcb= left->color[1];

  457.     int pcr= left->color[2];

  458.     int pmx, pmy;

  459.     int ref_context= av_log2(2*left->ref) + av_log2(2*top->ref);

  460.     int mx_context= av_log2(2*FFABS(left->mx - top->mx)) + 16*!!b->ref;

  461.     int my_context= av_log2(2*FFABS(left->my - top->my)) + 16*!!b->ref;

  462.     int s_context= 2*left->level + 2*top->level + tl->level + tr->level;

  463. 

  464.     if(s->keyframe){

  465.         set_blocks(s, level, x, y, pl, pcb, pcr, 0, 0, 0, BLOCK_INTRA);

  466.         return;

  467.     }

  468. 

  469.     if(level!=s->block_max_depth){

  470.         if(same_block(b,b+1) && same_block(b,b+w) && same_block(b,b+w+1)){

  471.             put_rac(&s->c, &s->block_state[4 + s_context], 1);

  472.         }else{

  473.             put_rac(&s->c, &s->block_state[4 + s_context], 0);

  474.             encode_q_branch2(s, level+1, 2*x+0, 2*y+0);

  475.             encode_q_branch2(s, level+1, 2*x+1, 2*y+0);

  476.             encode_q_branch2(s, level+1, 2*x+0, 2*y+1);

  477.             encode_q_branch2(s, level+1, 2*x+1, 2*y+1);

  478.             return;

  479.         }

  480.     }

  481.     if(b->type & BLOCK_INTRA){

  482.         pred_mv(s, &pmx, &pmy, 0, left, top, tr);

  483.         put_rac(&s->c, &s->block_state[1 + (left->type&1) + (top->type&1)], 1);

  484.         put_symbol(&s->c, &s->block_state[32], b->color[0]-pl , 1);

  485.         if (s->nb_planes > 2) {

  486.             put_symbol(&s->c, &s->block_state[64], b->color[1]-pcb, 1);

  487.             put_symbol(&s->c, &s->block_state[96], b->color[2]-pcr, 1);

  488.         }

  489.         set_blocks(s, level, x, y, b->color[0], b->color[1], b->color[2], pmx, pmy, 0, BLOCK_INTRA);

  490.     }else{

  491.         pred_mv(s, &pmx, &pmy, b->ref, left, top, tr);

  492.         put_rac(&s->c, &s->block_state[1 + (left->type&1) + (top->type&1)], 0);

  493.         if(s->ref_frames > 1)

  494.             put_symbol(&s->c, &s->block_state[128 + 1024 + 32*ref_context], b->ref, 0);

  495.         put_symbol(&s->c, &s->block_state[128 + 32*mx_context], b->mx - pmx, 1);

  496.         put_symbol(&s->c, &s->block_state[128 + 32*my_context], b->my - pmy, 1);

  497.         set_blocks(s, level, x, y, pl, pcb, pcr, b->mx, b->my, b->ref, 0);

  498.     }

  499. }

  500. 

  501. static int get_dc(SnowContext *s, int mb_x, int mb_y, int plane_index){

  502.     int i, x2, y2;

  503.     Plane *p= &s->plane[plane_index];

  504.     const int block_size = MB_SIZE >> s->block_max_depth;

  505.     const int block_w    = plane_index ? block_size>>s->chroma_h_shift : block_size;

  506.     const int block_h    = plane_index ? block_size>>s->chroma_v_shift : block_size;

  507.     const uint8_t *obmc  = plane_index ? ff_obmc_tab[s->block_max_depth+s->chroma_h_shift] : ff_obmc_tab[s->block_max_depth];

  508.     const int obmc_stride= plane_index ? (2*block_size)>>s->chroma_h_shift : 2*block_size;

  509.     const int ref_stride= s->current_picture->linesize[plane_index];

  510.     uint8_t *src= s-> input_picture->data[plane_index];

  511.     IDWTELEM *dst= (IDWTELEM*)s->m.obmc_scratchpad + plane_index*block_size*block_size*4; //FIXME change to unsigned

  512.     const int b_stride = s->b_width << s->block_max_depth;

  513.     const int w= p->width;

  514.     const int h= p->height;

  515.     int index= mb_x + mb_y*b_stride;

  516.     BlockNode *b= &s->block[index];

  517.     BlockNode backup= *b;

  518.     int ab=0;

  519.     int aa=0;

  520. 

  521.     av_assert2(s->chroma_h_shift == s->chroma_v_shift); //obmc stuff above

  522. 

  523.     b->type|= BLOCK_INTRA;

  524.     b->color[plane_index]= 0;

  525.     memset(dst, 0, obmc_stride*obmc_stride*sizeof(IDWTELEM));

  526. 

  527.     for(i=0; i<4; i++){

  528.         int mb_x2= mb_x + (i &1) - 1;

  529.         int mb_y2= mb_y + (i>>1) - 1;

  530.         int x= block_w*mb_x2 + block_w/2;

  531.         int y= block_h*mb_y2 + block_h/2;

  532. 

  533.         add_yblock(s, 0, NULL, dst + (i&1)*block_w + (i>>1)*obmc_stride*block_h, NULL, obmc,

  534.                     x, y, block_w, block_h, w, h, obmc_stride, ref_stride, obmc_stride, mb_x2, mb_y2, 0, 0, plane_index);

  535. 

  536.         for(y2= FFMAX(y, 0); y2<FFMIN(h, y+block_h); y2++){

  537.             for(x2= FFMAX(x, 0); x2<FFMIN(w, x+block_w); x2++){

  538.                 int index= x2-(block_w*mb_x - block_w/2) + (y2-(block_h*mb_y - block_h/2))*obmc_stride;

  539.                 int obmc_v= obmc[index];

  540.                 int d;

  541.                 if(y<0) obmc_v += obmc[index + block_h*obmc_stride];

  542.                 if(x<0) obmc_v += obmc[index + block_w];

  543.                 if(y+block_h>h) obmc_v += obmc[index - block_h*obmc_stride];

  544.                 if(x+block_w>w) obmc_v += obmc[index - block_w];

  545.                 //FIXME precalculate this or simplify it somehow else

  546. 

  547.                 d = -dst[index] + (1<<(FRAC_BITS-1));

  548.                 dst[index] = d;

  549.                 ab += (src[x2 + y2*ref_stride] - (d>>FRAC_BITS)) * obmc_v;

  550.                 aa += obmc_v * obmc_v; //FIXME precalculate this

  551.             }

  552.         }

  553.     }

  554.     *b= backup;

  555. 

  556.     return av_clip( ROUNDED_DIV(ab<<LOG2_OBMC_MAX, aa), 0, 255); //FIXME we should not need clipping

  557. }

  558. 

  559. static inline int get_block_bits(SnowContext *s, int x, int y, int w){

  560.     const int b_stride = s->b_width << s->block_max_depth;

  561.     const int b_height = s->b_height<< s->block_max_depth;

  562.     int index= x + y*b_stride;

  563.     const BlockNode *b     = &s->block[index];

  564.     const BlockNode *left  = x ? &s->block[index-1] : &null_block;

  565.     const BlockNode *top   = y ? &s->block[index-b_stride] : &null_block;

  566.     const BlockNode *tl    = y && x ? &s->block[index-b_stride-1] : left;

  567.     const BlockNode *tr    = y && x+w<b_stride ? &s->block[index-b_stride+w] : tl;

  568.     int dmx, dmy;

  569. //  int mx_context= av_log2(2*FFABS(left->mx - top->mx));

  570. //  int my_context= av_log2(2*FFABS(left->my - top->my));

  571. 

  572.     if(x<0 || x>=b_stride || y>=b_height)

  573.         return 0;

  574. /*

  575. 1            0      0

  576. 01X          1-2    1

  577. 001XX        3-6    2-3

  578. 0001XXX      7-14   4-7

  579. 00001XXXX   15-30   8-15

  580. */

  581. //FIXME try accurate rate

  582. //FIXME intra and inter predictors if surrounding blocks are not the same type

  583.     if(b->type & BLOCK_INTRA){

  584.         return 3+2*( av_log2(2*FFABS(left->color[0] - b->color[0]))

  585.                    + av_log2(2*FFABS(left->color[1] - b->color[1]))

  586.                    + av_log2(2*FFABS(left->color[2] - b->color[2])));

  587.     }else{

  588.         pred_mv(s, &dmx, &dmy, b->ref, left, top, tr);

  589.         dmx-= b->mx;

  590.         dmy-= b->my;

  591.         return 2*(1 + av_log2(2*FFABS(dmx)) //FIXME kill the 2* can be merged in lambda

  592.                     + av_log2(2*FFABS(dmy))

  593.                     + av_log2(2*b->ref));

  594.     }

  595. }

  596. 

  597. static int get_block_rd(SnowContext *s, int mb_x, int mb_y, int plane_index, uint8_t (*obmc_edged)[MB_SIZE * 2]){

  598.     Plane *p= &s->plane[plane_index];

  599.     const int block_size = MB_SIZE >> s->block_max_depth;

  600.     const int block_w    = plane_index ? block_size>>s->chroma_h_shift : block_size;

  601.     const int block_h    = plane_index ? block_size>>s->chroma_v_shift : block_size;

  602.     const int obmc_stride= plane_index ? (2*block_size)>>s->chroma_h_shift : 2*block_size;

  603.     const int ref_stride= s->current_picture->linesize[plane_index];

  604.     uint8_t *dst= s->current_picture->data[plane_index];

  605.     uint8_t *src= s->  input_picture->data[plane_index];

  606.     IDWTELEM *pred= (IDWTELEM*)s->m.obmc_scratchpad + plane_index*block_size*block_size*4;

  607.     uint8_t *cur = s->scratchbuf;

  608.     uint8_t *tmp = s->emu_edge_buffer;

  609.     const int b_stride = s->b_width << s->block_max_depth;

  610.     const int b_height = s->b_height<< s->block_max_depth;

  611.     const int w= p->width;

  612.     const int h= p->height;

  613.     int distortion;

  614.     int rate= 0;

  615.     const int penalty_factor= get_penalty_factor(s->lambda, s->lambda2, s->avctx->me_cmp);

  616.     int sx= block_w*mb_x - block_w/2;

  617.     int sy= block_h*mb_y - block_h/2;

  618.     int x0= FFMAX(0,-sx);

  619.     int y0= FFMAX(0,-sy);

  620.     int x1= FFMIN(block_w*2, w-sx);

  621.     int y1= FFMIN(block_h*2, h-sy);

  622.     int i,x,y;

  623. 

  624.     av_assert2(s->chroma_h_shift == s->chroma_v_shift); //obmc and square assumtions below chckinhg only block_w

  625. 

  626.     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);

  627. 

  628.     for(y=y0; y<y1; y++){

  629.         const uint8_t *obmc1= obmc_edged[y];

  630.         const IDWTELEM *pred1 = pred + y*obmc_stride;

  631.         uint8_t *cur1 = cur + y*ref_stride;

  632.         uint8_t *dst1 = dst + sx + (sy+y)*ref_stride;

  633.         for(x=x0; x<x1; x++){

  634. #if FRAC_BITS >= LOG2_OBMC_MAX

  635.             int v = (cur1[x] * obmc1[x]) << (FRAC_BITS - LOG2_OBMC_MAX);

  636. #else

  637.             int v = (cur1[x] * obmc1[x] + (1<<(LOG2_OBMC_MAX - FRAC_BITS-1))) >> (LOG2_OBMC_MAX - FRAC_BITS);

  638. #endif

  639.             v = (v + pred1[x]) >> FRAC_BITS;

  640.             if(v&(~255)) v= ~(v>>31);

  641.             dst1[x] = v;

  642.         }

  643.     }

  644. 

  645.     /* copy the regions where obmc[] = (uint8_t)256 */

  646.     if(LOG2_OBMC_MAX == 8

  647.         && (mb_x == 0 || mb_x == b_stride-1)

  648.         && (mb_y == 0 || mb_y == b_height-1)){

  649.         if(mb_x == 0)

  650.             x1 = block_w;

  651.         else

  652.             x0 = block_w;

  653.         if(mb_y == 0)

  654.             y1 = block_h;

  655.         else

  656.             y0 = block_h;

  657.         for(y=y0; y<y1; y++)

  658.             memcpy(dst + sx+x0 + (sy+y)*ref_stride, cur + x0 + y*ref_stride, x1-x0);

  659.     }

  660. 

  661.     if(block_w==16){

  662.         /* FIXME rearrange dsputil to fit 32x32 cmp functions */

  663.         /* FIXME check alignment of the cmp wavelet vs the encoding wavelet */

  664.         /* FIXME cmps overlap but do not cover the wavelet's whole support.

  665.          * So improving the score of one block is not strictly guaranteed

  666.          * to improve the score of the whole frame, thus iterative motion

  667.          * estimation does not always converge. */

  668.         if(s->avctx->me_cmp == FF_CMP_W97)

  669.             distortion = ff_w97_32_c(&s->m, src + sx + sy*ref_stride, dst + sx + sy*ref_stride, ref_stride, 32);

  670.         else if(s->avctx->me_cmp == FF_CMP_W53)

  671.             distortion = ff_w53_32_c(&s->m, src + sx + sy*ref_stride, dst + sx + sy*ref_stride, ref_stride, 32);

  672.         else{

  673.             distortion = 0;

  674.             for(i=0; i<4; i++){

  675.                 int off = sx+16*(i&1) + (sy+16*(i>>1))*ref_stride;

  676.                 distortion += s->dsp.me_cmp[0](&s->m, src + off, dst + off, ref_stride, 16);

  677.             }

  678.         }

  679.     }else{

  680.         av_assert2(block_w==8);

  681.         distortion = s->dsp.me_cmp[0](&s->m, src + sx + sy*ref_stride, dst + sx + sy*ref_stride, ref_stride, block_w*2);

  682.     }

  683. 

  684.     if(plane_index==0){

  685.         for(i=0; i<4; i++){

  686. /* ..RRr

  687.  * .RXx.

  688.  * rxx..

  689.  */

  690.             rate += get_block_bits(s, mb_x + (i&1) - (i>>1), mb_y + (i>>1), 1);

  691.         }

  692.         if(mb_x == b_stride-2)

  693.             rate += get_block_bits(s, mb_x + 1, mb_y + 1, 1);

  694.     }

  695.     return distortion + rate*penalty_factor;

  696. }

  697. 

  698. static int get_4block_rd(SnowContext *s, int mb_x, int mb_y, int plane_index){

  699.     int i, y2;

  700.     Plane *p= &s->plane[plane_index];

  701.     const int block_size = MB_SIZE >> s->block_max_depth;

  702.     const int block_w    = plane_index ? block_size>>s->chroma_h_shift : block_size;

  703.     const int block_h    = plane_index ? block_size>>s->chroma_v_shift : block_size;

  704.     const uint8_t *obmc  = plane_index ? ff_obmc_tab[s->block_max_depth+s->chroma_h_shift] : ff_obmc_tab[s->block_max_depth];

  705.     const int obmc_stride= plane_index ? (2*block_size)>>s->chroma_h_shift : 2*block_size;

  706.     const int ref_stride= s->current_picture->linesize[plane_index];

  707.     uint8_t *dst= s->current_picture->data[plane_index];

  708.     uint8_t *src= s-> input_picture->data[plane_index];

  709.     //FIXME zero_dst is const but add_yblock changes dst if add is 0 (this is never the case for dst=zero_dst

  710.     // const has only been removed from zero_dst to suppress a warning

  711.     static IDWTELEM zero_dst[4096]; //FIXME

  712.     const int b_stride = s->b_width << s->block_max_depth;

  713.     const int w= p->width;

  714.     const int h= p->height;

  715.     int distortion= 0;

  716.     int rate= 0;

  717.     const int penalty_factor= get_penalty_factor(s->lambda, s->lambda2, s->avctx->me_cmp);

  718. 

  719.     av_assert2(s->chroma_h_shift == s->chroma_v_shift); //obmc and square assumtions below

  720. 

  721.     for(i=0; i<9; i++){

  722.         int mb_x2= mb_x + (i%3) - 1;

  723.         int mb_y2= mb_y + (i/3) - 1;

  724.         int x= block_w*mb_x2 + block_w/2;

  725.         int y= block_h*mb_y2 + block_h/2;

  726. 

  727.         add_yblock(s, 0, NULL, zero_dst, dst, obmc,

  728.                    x, y, block_w, block_h, w, h, /*dst_stride*/0, ref_stride, obmc_stride, mb_x2, mb_y2, 1, 1, plane_index);

  729. 

  730.         //FIXME find a cleaner/simpler way to skip the outside stuff

  731.         for(y2= y; y2<0; y2++)

  732.             memcpy(dst + x + y2*ref_stride, src + x + y2*ref_stride, block_w);

  733.         for(y2= h; y2<y+block_h; y2++)

  734.             memcpy(dst + x + y2*ref_stride, src + x + y2*ref_stride, block_w);

  735.         if(x<0){

  736.             for(y2= y; y2<y+block_h; y2++)

  737.                 memcpy(dst + x + y2*ref_stride, src + x + y2*ref_stride, -x);

  738.         }

  739.         if(x+block_w > w){

  740.             for(y2= y; y2<y+block_h; y2++)

  741.                 memcpy(dst + w + y2*ref_stride, src + w + y2*ref_stride, x+block_w - w);

  742.         }

  743. 

  744.         av_assert1(block_w== 8 || block_w==16);

  745.         distortion += s->dsp.me_cmp[block_w==8](&s->m, src + x + y*ref_stride, dst + x + y*ref_stride, ref_stride, block_h);

  746.     }

  747. 

  748.     if(plane_index==0){

  749.         BlockNode *b= &s->block[mb_x+mb_y*b_stride];

  750.         int merged= same_block(b,b+1) && same_block(b,b+b_stride) && same_block(b,b+b_stride+1);

  751. 

  752. /* ..RRRr

  753.  * .RXXx.

  754.  * .RXXx.

  755.  * rxxx.

  756.  */

  757.         if(merged)

  758.             rate = get_block_bits(s, mb_x, mb_y, 2);

  759.         for(i=merged?4:0; i<9; i++){

  760.             static const int dxy[9][2] = {{0,0},{1,0},{0,1},{1,1},{2,0},{2,1},{-1,2},{0,2},{1,2}};

  761.             rate += get_block_bits(s, mb_x + dxy[i][0], mb_y + dxy[i][1], 1);

  762.         }

  763.     }

  764.     return distortion + rate*penalty_factor;

  765. }

  766. 

  767. static int encode_subband_c0run(SnowContext *s, SubBand *b, const IDWTELEM *src, const IDWTELEM *parent, int stride, int orientation){

  768.     const int w= b->width;

  769.     const int h= b->height;

  770.     int x, y;

  771. 

  772.     if(1){

  773.         int run=0;

  774.         int *runs = s->run_buffer;

  775.         int run_index=0;

  776.         int max_index;

  777. 

  778.         for(y=0; y<h; y++){

  779.             for(x=0; x<w; x++){

  780.                 int v, p=0;

  781.                 int /*ll=0, */l=0, lt=0, t=0, rt=0;

  782.                 v= src[x + y*stride];

  783. 

  784.                 if(y){

  785.                     t= src[x + (y-1)*stride];

  786.                     if(x){

  787.                         lt= src[x - 1 + (y-1)*stride];

  788.                     }

  789.                     if(x + 1 < w){

  790.                         rt= src[x + 1 + (y-1)*stride];

  791.                     }

  792.                 }

  793.                 if(x){

  794.                     l= src[x - 1 + y*stride];

  795.                     /*if(x > 1){

  796.                         if(orientation==1) ll= src[y + (x-2)*stride];

  797.                         else               ll= src[x - 2 + y*stride];

  798.                     }*/

  799.                 }

  800.                 if(parent){

  801.                     int px= x>>1;

  802.                     int py= y>>1;

  803.                     if(px<b->parent->width && py<b->parent->height)

  804.                         p= parent[px + py*2*stride];

  805.                 }

  806.                 if(!(/*ll|*/l|lt|t|rt|p)){

  807.                     if(v){

  808.                         runs[run_index++]= run;

  809.                         run=0;

  810.                     }else{

  811.                         run++;

  812.                     }

  813.                 }

  814.             }

  815.         }

  816.         max_index= run_index;

  817.         runs[run_index++]= run;

  818.         run_index=0;

  819.         run= runs[run_index++];

  820. 

  821.         put_symbol2(&s->c, b->state[30], max_index, 0);

  822.         if(run_index <= max_index)

  823.             put_symbol2(&s->c, b->state[1], run, 3);

  824. 

  825.         for(y=0; y<h; y++){

  826.             if(s->c.bytestream_end - s->c.bytestream < w*40){

  827.                 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");

  828.                 return -1;

  829.             }

  830.             for(x=0; x<w; x++){

  831.                 int v, p=0;

  832.                 int /*ll=0, */l=0, lt=0, t=0, rt=0;

  833.                 v= src[x + y*stride];

  834. 

  835.                 if(y){

  836.                     t= src[x + (y-1)*stride];

  837.                     if(x){

  838.                         lt= src[x - 1 + (y-1)*stride];

  839.                     }

  840.                     if(x + 1 < w){

  841.                         rt= src[x + 1 + (y-1)*stride];

  842.                     }

  843.                 }

  844.                 if(x){

  845.                     l= src[x - 1 + y*stride];

  846.                     /*if(x > 1){

  847.                         if(orientation==1) ll= src[y + (x-2)*stride];

  848.                         else               ll= src[x - 2 + y*stride];

  849.                     }*/

  850.                 }

  851.                 if(parent){

  852.                     int px= x>>1;

  853.                     int py= y>>1;

  854.                     if(px<b->parent->width && py<b->parent->height)

  855.                         p= parent[px + py*2*stride];

  856.                 }

  857.                 if(/*ll|*/l|lt|t|rt|p){

  858.                     int context= av_log2(/*FFABS(ll) + */3*FFABS(l) + FFABS(lt) + 2*FFABS(t) + FFABS(rt) + FFABS(p));

  859. 

  860.                     put_rac(&s->c, &b->state[0][context], !!v);

  861.                 }else{

  862.                     if(!run){

  863.                         run= runs[run_index++];

  864. 

  865.                         if(run_index <= max_index)

  866.                             put_symbol2(&s->c, b->state[1], run, 3);

  867.                         av_assert2(v);

  868.                     }else{

  869.                         run--;

  870.                         av_assert2(!v);

  871.                     }

  872.                 }

  873.                 if(v){

  874.                     int context= av_log2(/*FFABS(ll) + */3*FFABS(l) + FFABS(lt) + 2*FFABS(t) + FFABS(rt) + FFABS(p));

  875.                     int l2= 2*FFABS(l) + (l<0);

  876.                     int t2= 2*FFABS(t) + (t<0);

  877. 

  878.                     put_symbol2(&s->c, b->state[context + 2], FFABS(v)-1, context-4);

  879.                     put_rac(&s->c, &b->state[0][16 + 1 + 3 + ff_quant3bA[l2&0xFF] + 3*ff_quant3bA[t2&0xFF]], v<0);

  880.                 }

  881.             }

  882.         }

  883.     }

  884.     return 0;

  885. }

  886. 

  887. static int encode_subband(SnowContext *s, SubBand *b, const IDWTELEM *src, const IDWTELEM *parent, int stride, int orientation){

  888. //    encode_subband_qtree(s, b, src, parent, stride, orientation);

  889. //    encode_subband_z0run(s, b, src, parent, stride, orientation);

  890.     return encode_subband_c0run(s, b, src, parent, stride, orientation);

  891. //    encode_subband_dzr(s, b, src, parent, stride, orientation);

  892. }

  893. 

  894. 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){

  895.     const int b_stride= s->b_width << s->block_max_depth;

  896.     BlockNode *block= &s->block[mb_x + mb_y * b_stride];

  897.     BlockNode backup= *block;

  898.     unsigned value;

  899.     int rd, index;

  900. 

  901.     av_assert2(mb_x>=0 && mb_y>=0);

  902.     av_assert2(mb_x<b_stride);

  903. 

  904.     if(intra){

  905.         block->color[0] = p[0];

  906.         block->color[1] = p[1];

  907.         block->color[2] = p[2];

  908.         block->type |= BLOCK_INTRA;

  909.     }else{

  910.         index= (p[0] + 31*p[1]) & (ME_CACHE_SIZE-1);

  911.         value= s->me_cache_generation + (p[0]>>10) + (p[1]<<6) + (block->ref<<12);

  912.         if(s->me_cache[index] == value)

  913.             return 0;

  914.         s->me_cache[index]= value;

  915. 

  916.         block->mx= p[0];

  917.         block->my= p[1];

  918.         block->type &= ~BLOCK_INTRA;

  919.     }

  920. 

  921.     rd= get_block_rd(s, mb_x, mb_y, 0, obmc_edged);

  922. 

  923. //FIXME chroma

  924.     if(rd < *best_rd){

  925.         *best_rd= rd;

  926.         return 1;

  927.     }else{

  928.         *block= backup;

  929.         return 0;

  930.     }

  931. }

  932. 

  933. /* special case for int[2] args we discard afterwards,

  934.  * fixes compilation problem with gcc 2.95 */

  935. 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){

  936.     int p[2] = {p0, p1};

  937.     return check_block(s, mb_x, mb_y, p, 0, obmc_edged, best_rd);

  938. }

  939. 

  940. 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){

  941.     const int b_stride= s->b_width << s->block_max_depth;

  942.     BlockNode *block= &s->block[mb_x + mb_y * b_stride];

  943.     BlockNode backup[4];

  944.     unsigned value;

  945.     int rd, index;

  946. 

  947.     /* We don't initialize backup[] during variable declaration, because

  948.      * that fails to compile on MSVC: "cannot convert from 'BlockNode' to

  949.      * 'int16_t'". */

  950.     backup[0] = block[0];

  951.     backup[1] = block[1];

  952.     backup[2] = block[b_stride];

  953.     backup[3] = block[b_stride + 1];

  954. 

  955.     av_assert2(mb_x>=0 && mb_y>=0);

  956.     av_assert2(mb_x<b_stride);

  957.     av_assert2(((mb_x|mb_y)&1) == 0);

  958. 

  959.     index= (p0 + 31*p1) & (ME_CACHE_SIZE-1);

  960.     value= s->me_cache_generation + (p0>>10) + (p1<<6) + (block->ref<<12);

  961.     if(s->me_cache[index] == value)

  962.         return 0;

  963.     s->me_cache[index]= value;

  964. 

  965.     block->mx= p0;

  966.     block->my= p1;

  967.     block->ref= ref;

  968.     block->type &= ~BLOCK_INTRA;

  969.     block[1]= block[b_stride]= block[b_stride+1]= *block;

  970. 

  971.     rd= get_4block_rd(s, mb_x, mb_y, 0);

  972. 

  973. //FIXME chroma

  974.     if(rd < *best_rd){

  975.         *best_rd= rd;

  976.         return 1;

  977.     }else{

  978.         block[0]= backup[0];

  979.         block[1]= backup[1];

  980.         block[b_stride]= backup[2];

  981.         block[b_stride+1]= backup[3];

  982.         return 0;

  983.     }

  984. }

  985. 

  986. static void iterative_me(SnowContext *s){

  987.     int pass, mb_x, mb_y;

  988.     const int b_width = s->b_width  << s->block_max_depth;

  989.     const int b_height= s->b_height << s->block_max_depth;

  990.     const int b_stride= b_width;

  991.     int color[3];

  992. 

  993.     {

  994.         RangeCoder r = s->c;

  995.         uint8_t state[sizeof(s->block_state)];

  996.         memcpy(state, s->block_state, sizeof(s->block_state));

  997.         for(mb_y= 0; mb_y<s->b_height; mb_y++)

  998.             for(mb_x= 0; mb_x<s->b_width; mb_x++)

  999.                 encode_q_branch(s, 0, mb_x, mb_y);

  1000.         s->c = r;

  1001.         memcpy(s->block_state, state, sizeof(s->block_state));

  1002.     }

  1003. 

  1004.     for(pass=0; pass<25; pass++){

  1005.         int change= 0;

  1006. 

  1007.         for(mb_y= 0; mb_y<b_height; mb_y++){

  1008.             for(mb_x= 0; mb_x<b_width; mb_x++){

  1009.                 int dia_change, i, j, ref;

  1010.                 int best_rd= INT_MAX, ref_rd;

  1011.                 BlockNode backup, ref_b;

  1012.                 const int index= mb_x + mb_y * b_stride;

  1013.                 BlockNode *block= &s->block[index];

  1014.                 BlockNode *tb =                   mb_y            ? &s->block[index-b_stride  ] : NULL;

  1015.                 BlockNode *lb = mb_x                              ? &s->block[index         -1] : NULL;

  1016.                 BlockNode *rb = mb_x+1<b_width                    ? &s->block[index         +1] : NULL;

  1017.                 BlockNode *bb =                   mb_y+1<b_height ? &s->block[index+b_stride  ] : NULL;

  1018.                 BlockNode *tlb= mb_x           && mb_y            ? &s->block[index-b_stride-1] : NULL;

  1019.                 BlockNode *trb= mb_x+1<b_width && mb_y            ? &s->block[index-b_stride+1] : NULL;

  1020.                 BlockNode *blb= mb_x           && mb_y+1<b_height ? &s->block[index+b_stride-1] : NULL;

  1021.                 BlockNode *brb= mb_x+1<b_width && mb_y+1<b_height ? &s->block[index+b_stride+1] : NULL;

  1022.                 const int b_w= (MB_SIZE >> s->block_max_depth);

  1023.                 uint8_t obmc_edged[MB_SIZE * 2][MB_SIZE * 2];

  1024. 

  1025.                 if(pass && (block->type & BLOCK_OPT))

  1026.                     continue;

  1027.                 block->type |= BLOCK_OPT;

  1028. 

  1029.                 backup= *block;

  1030. 

  1031.                 if(!s->me_cache_generation)

  1032.                     memset(s->me_cache, 0, sizeof(s->me_cache));

  1033.                 s->me_cache_generation += 1<<22;

  1034. 

  1035.                 //FIXME precalculate

  1036.                 {

  1037.                     int x, y;

  1038.                     for (y = 0; y < b_w * 2; y++)

  1039.                         memcpy(obmc_edged[y], ff_obmc_tab[s->block_max_depth] + y * b_w * 2, b_w * 2);

  1040.                     if(mb_x==0)

  1041.                         for(y=0; y<b_w*2; y++)

  1042.                             memset(obmc_edged[y], obmc_edged[y][0] + obmc_edged[y][b_w-1], b_w);

  1043.                     if(mb_x==b_stride-1)

  1044.                         for(y=0; y<b_w*2; y++)

  1045.                             memset(obmc_edged[y]+b_w, obmc_edged[y][b_w] + obmc_edged[y][b_w*2-1], b_w);

  1046.                     if(mb_y==0){

  1047.                         for(x=0; x<b_w*2; x++)

  1048.                             obmc_edged[0][x] += obmc_edged[b_w-1][x];

  1049.                         for(y=1; y<b_w; y++)

  1050.                             memcpy(obmc_edged[y], obmc_edged[0], b_w*2);

  1051.                     }

  1052.                     if(mb_y==b_height-1){

  1053.                         for(x=0; x<b_w*2; x++)

  1054.                             obmc_edged[b_w*2-1][x] += obmc_edged[b_w][x];

  1055.                         for(y=b_w; y<b_w*2-1; y++)

  1056.                             memcpy(obmc_edged[y], obmc_edged[b_w*2-1], b_w*2);

  1057.                     }

  1058.                 }

  1059. 

  1060.                 //skip stuff outside the picture

  1061.                 if(mb_x==0 || mb_y==0 || mb_x==b_width-1 || mb_y==b_height-1){

  1062.                     uint8_t *src= s->  input_picture->data[0];

  1063.                     uint8_t *dst= s->current_picture->data[0];

  1064.                     const int stride= s->current_picture->linesize[0];

  1065.                     const int block_w= MB_SIZE >> s->block_max_depth;

  1066.                     const int block_h= MB_SIZE >> s->block_max_depth;

  1067.                     const int sx= block_w*mb_x - block_w/2;

  1068.                     const int sy= block_h*mb_y - block_h/2;

  1069.                     const int w= s->plane[0].width;

  1070.                     const int h= s->plane[0].height;

  1071.                     int y;

  1072. 

  1073.                     for(y=sy; y<0; y++)

  1074.                         memcpy(dst + sx + y*stride, src + sx + y*stride, block_w*2);

  1075.                     for(y=h; y<sy+block_h*2; y++)

  1076.                         memcpy(dst + sx + y*stride, src + sx + y*stride, block_w*2);

  1077.                     if(sx<0){

  1078.                         for(y=sy; y<sy+block_h*2; y++)

  1079.                             memcpy(dst + sx + y*stride, src + sx + y*stride, -sx);

  1080.                     }

  1081.                     if(sx+block_w*2 > w){

  1082.                         for(y=sy; y<sy+block_h*2; y++)

  1083.                             memcpy(dst + w + y*stride, src + w + y*stride, sx+block_w*2 - w);

  1084.                     }

  1085.                 }

  1086. 

  1087.                 // intra(black) = neighbors' contribution to the current block

  1088.                 for(i=0; i < s->nb_planes; i++)

  1089.                     color[i]= get_dc(s, mb_x, mb_y, i);

  1090. 

  1091.                 // get previous score (cannot be cached due to OBMC)

  1092.                 if(pass > 0 && (block->type&BLOCK_INTRA)){

  1093.                     int color0[3]= {block->color[0], block->color[1], block->color[2]};

  1094.                     check_block(s, mb_x, mb_y, color0, 1, obmc_edged, &best_rd);

  1095.                 }else

  1096.                     check_block_inter(s, mb_x, mb_y, block->mx, block->my, obmc_edged, &best_rd);

  1097. 

  1098.                 ref_b= *block;

  1099.                 ref_rd= best_rd;

  1100.                 for(ref=0; ref < s->ref_frames; ref++){

  1101.                     int16_t (*mvr)[2]= &s->ref_mvs[ref][index];

  1102.                     if(s->ref_scores[ref][index] > s->ref_scores[ref_b.ref][index]*3/2) //FIXME tune threshold

  1103.                         continue;

  1104.                     block->ref= ref;

  1105.                     best_rd= INT_MAX;

  1106. 

  1107.                     check_block_inter(s, mb_x, mb_y, mvr[0][0], mvr[0][1], obmc_edged, &best_rd);

  1108.                     check_block_inter(s, mb_x, mb_y, 0, 0, obmc_edged, &best_rd);

  1109.                     if(tb)

  1110.                         check_block_inter(s, mb_x, mb_y, mvr[-b_stride][0], mvr[-b_stride][1], obmc_edged, &best_rd);

  1111.                     if(lb)

  1112.                         check_block_inter(s, mb_x, mb_y, mvr[-1][0], mvr[-1][1], obmc_edged, &best_rd);

  1113.                     if(rb)

  1114.                         check_block_inter(s, mb_x, mb_y, mvr[1][0], mvr[1][1], obmc_edged, &best_rd);

  1115.                     if(bb)

  1116.                         check_block_inter(s, mb_x, mb_y, mvr[b_stride][0], mvr[b_stride][1], obmc_edged, &best_rd);

  1117. 

  1118.                     /* fullpel ME */

  1119.                     //FIXME avoid subpel interpolation / round to nearest integer

  1120.                     do{

  1121.                         dia_change=0;

  1122.                         for(i=0; i<FFMAX(s->avctx->dia_size, 1); i++){

  1123.                             for(j=0; j<i; j++){

  1124.                                 dia_change |= check_block_inter(s, mb_x, mb_y, block->mx+4*(i-j), block->my+(4*j), obmc_edged, &best_rd);

  1125.                                 dia_change |= check_block_inter(s, mb_x, mb_y, block->mx-4*(i-j), block->my-(4*j), obmc_edged, &best_rd);

  1126.                                 dia_change |= check_block_inter(s, mb_x, mb_y, block->mx+4*(i-j), block->my-(4*j), obmc_edged, &best_rd);

  1127.                                 dia_change |= check_block_inter(s, mb_x, mb_y, block->mx-4*(i-j), block->my+(4*j), obmc_edged, &best_rd);

  1128.                             }

  1129.                         }

  1130.                     }while(dia_change);

  1131.                     /* subpel ME */

  1132.                     do{

  1133.                         static const int square[8][2]= {{+1, 0},{-1, 0},{ 0,+1},{ 0,-1},{+1,+1},{-1,-1},{+1,-1},{-1,+1},};

  1134.                         dia_change=0;

  1135.                         for(i=0; i<8; i++)

  1136.                             dia_change |= check_block_inter(s, mb_x, mb_y, block->mx+square[i][0], block->my+square[i][1], obmc_edged, &best_rd);

  1137.                     }while(dia_change);

  1138.                     //FIXME or try the standard 2 pass qpel or similar

  1139. 

  1140.                     mvr[0][0]= block->mx;

  1141.                     mvr[0][1]= block->my;

  1142.                     if(ref_rd > best_rd){

  1143.                         ref_rd= best_rd;

  1144.                         ref_b= *block;

  1145.                     }

  1146.                 }

  1147.                 best_rd= ref_rd;

  1148.                 *block= ref_b;

  1149.                 check_block(s, mb_x, mb_y, color, 1, obmc_edged, &best_rd);

  1150.                 //FIXME RD style color selection

  1151.                 if(!same_block(block, &backup)){

  1152.                     if(tb ) tb ->type &= ~BLOCK_OPT;

  1153.                     if(lb ) lb ->type &= ~BLOCK_OPT;

  1154.                     if(rb ) rb ->type &= ~BLOCK_OPT;

  1155.                     if(bb ) bb ->type &= ~BLOCK_OPT;

  1156.                     if(tlb) tlb->type &= ~BLOCK_OPT;

  1157.                     if(trb) trb->type &= ~BLOCK_OPT;

  1158.                     if(blb) blb->type &= ~BLOCK_OPT;

  1159.                     if(brb) brb->type &= ~BLOCK_OPT;

  1160.                     change ++;

  1161.                 }

  1162.             }

  1163.         }

  1164.         av_log(s->avctx, AV_LOG_ERROR, "pass:%d changed:%d\n", pass, change);

  1165.         if(!change)

  1166.             break;

  1167.     }

  1168. 

  1169.     if(s->block_max_depth == 1){

  1170.         int change= 0;

  1171.         for(mb_y= 0; mb_y<b_height; mb_y+=2){

  1172.             for(mb_x= 0; mb_x<b_width; mb_x+=2){

  1173.                 int i;

  1174.                 int best_rd, init_rd;

  1175.                 const int index= mb_x + mb_y * b_stride;

  1176.                 BlockNode *b[4];

  1177. 

  1178.                 b[0]= &s->block[index];

  1179.                 b[1]= b[0]+1;

  1180.                 b[2]= b[0]+b_stride;

  1181.                 b[3]= b[2]+1;

  1182.                 if(same_block(b[0], b[1]) &&

  1183.                    same_block(b[0], b[2]) &&

  1184.                    same_block(b[0], b[3]))

  1185.                     continue;

  1186. 

  1187.                 if(!s->me_cache_generation)

  1188.                     memset(s->me_cache, 0, sizeof(s->me_cache));

  1189.                 s->me_cache_generation += 1<<22;

  1190. 

  1191.                 init_rd= best_rd= get_4block_rd(s, mb_x, mb_y, 0);

  1192. 

  1193.                 //FIXME more multiref search?

  1194.                 check_4block_inter(s, mb_x, mb_y,

  1195.                                    (b[0]->mx + b[1]->mx + b[2]->mx + b[3]->mx + 2) >> 2,

  1196.                                    (b[0]->my + b[1]->my + b[2]->my + b[3]->my + 2) >> 2, 0, &best_rd);

  1197. 

  1198.                 for(i=0; i<4; i++)

  1199.                     if(!(b[i]->type&BLOCK_INTRA))

  1200.                         check_4block_inter(s, mb_x, mb_y, b[i]->mx, b[i]->my, b[i]->ref, &best_rd);

  1201. 

  1202.                 if(init_rd != best_rd)

  1203.                     change++;

  1204.             }

  1205.         }

  1206.         av_log(s->avctx, AV_LOG_ERROR, "pass:4mv changed:%d\n", change*4);

  1207.     }

  1208. }

  1209. 

  1210. static void encode_blocks(SnowContext *s, int search){

  1211.     int x, y;

  1212.     int w= s->b_width;

  1213.     int h= s->b_height;

  1214. 

  1215.     if(s->avctx->me_method == ME_ITER && !s->keyframe && search)

  1216.         iterative_me(s);

  1217. 

  1218.     for(y=0; y<h; y++){

  1219.         if(s->c.bytestream_end - s->c.bytestream < w*MB_SIZE*MB_SIZE*3){ //FIXME nicer limit

  1220.             av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");

  1221.             return;

  1222.         }

  1223.         for(x=0; x<w; x++){

  1224.             if(s->avctx->me_method == ME_ITER || !search)

  1225.                 encode_q_branch2(s, 0, x, y);

  1226.             else

  1227.                 encode_q_branch (s, 0, x, y);

  1228.         }

  1229.     }

  1230. }

  1231. 

  1232. static void quantize(SnowContext *s, SubBand *b, IDWTELEM *dst, DWTELEM *src, int stride, int bias){

  1233.     const int w= b->width;

  1234.     const int h= b->height;

  1235.     const int qlog= av_clip(s->qlog + b->qlog, 0, QROOT*16);

  1236.     const int qmul= ff_qexp[qlog&(QROOT-1)]<<((qlog>>QSHIFT) + ENCODER_EXTRA_BITS);

  1237.     int x,y, thres1, thres2;

  1238. 

  1239.     if(s->qlog == LOSSLESS_QLOG){

  1240.         for(y=0; y<h; y++)

  1241.             for(x=0; x<w; x++)

  1242.                 dst[x + y*stride]= src[x + y*stride];

  1243.         return;

  1244.     }

  1245. 

  1246.     bias= bias ? 0 : (3*qmul)>>3;

  1247.     thres1= ((qmul - bias)>>QEXPSHIFT) - 1;

  1248.     thres2= 2*thres1;

  1249. 

  1250.     if(!bias){

  1251.         for(y=0; y<h; y++){

  1252.             for(x=0; x<w; x++){

  1253.                 int i= src[x + y*stride];

  1254. 

  1255.                 if((unsigned)(i+thres1) > thres2){

  1256.                     if(i>=0){

  1257.                         i<<= QEXPSHIFT;

  1258.                         i/= qmul; //FIXME optimize

  1259.                         dst[x + y*stride]=  i;

  1260.                     }else{

  1261.                         i= -i;

  1262.                         i<<= QEXPSHIFT;

  1263.                         i/= qmul; //FIXME optimize

  1264.                         dst[x + y*stride]= -i;

  1265.                     }

  1266.                 }else

  1267.                     dst[x + y*stride]= 0;

  1268.             }

  1269.         }

  1270.     }else{

  1271.         for(y=0; y<h; y++){

  1272.             for(x=0; x<w; x++){

  1273.                 int i= src[x + y*stride];

  1274. 

  1275.                 if((unsigned)(i+thres1) > thres2){

  1276.                     if(i>=0){

  1277.                         i<<= QEXPSHIFT;

  1278.                         i= (i + bias) / qmul; //FIXME optimize

  1279.                         dst[x + y*stride]=  i;

  1280.                     }else{

  1281.                         i= -i;

  1282.                         i<<= QEXPSHIFT;

  1283.                         i= (i + bias) / qmul; //FIXME optimize

  1284.                         dst[x + y*stride]= -i;

  1285.                     }

  1286.                 }else

  1287.                     dst[x + y*stride]= 0;

  1288.             }

  1289.         }

  1290.     }

  1291. }

  1292. 

  1293. static void dequantize(SnowContext *s, SubBand *b, IDWTELEM *src, int stride){

  1294.     const int w= b->width;

  1295.     const int h= b->height;

  1296.     const int qlog= av_clip(s->qlog + b->qlog, 0, QROOT*16);

  1297.     const int qmul= ff_qexp[qlog&(QROOT-1)]<<(qlog>>QSHIFT);

  1298.     const int qadd= (s->qbias*qmul)>>QBIAS_SHIFT;

  1299.     int x,y;

  1300. 

  1301.     if(s->qlog == LOSSLESS_QLOG) return;

  1302. 

  1303.     for(y=0; y<h; y++){

  1304.         for(x=0; x<w; x++){

  1305.             int i= src[x + y*stride];

  1306.             if(i<0){

  1307.                 src[x + y*stride]= -((-i*qmul + qadd)>>(QEXPSHIFT)); //FIXME try different bias

  1308.             }else if(i>0){

  1309.                 src[x + y*stride]=  (( i*qmul + qadd)>>(QEXPSHIFT));

  1310.             }

  1311.         }

  1312.     }

  1313. }

  1314. 

  1315. static void decorrelate(SnowContext *s, SubBand *b, IDWTELEM *src, int stride, int inverse, int use_median){

  1316.     const int w= b->width;

  1317.     const int h= b->height;

  1318.     int x,y;

  1319. 

  1320.     for(y=h-1; y>=0; y--){

  1321.         for(x=w-1; x>=0; x--){

  1322.             int i= x + y*stride;

  1323. 

  1324.             if(x){

  1325.                 if(use_median){

  1326.                     if(y && x+1<w) src[i] -= mid_pred(src[i - 1], src[i - stride], src[i - stride + 1]);

  1327.                     else  src[i] -= src[i - 1];

  1328.                 }else{

  1329.                     if(y) src[i] -= mid_pred(src[i - 1], src[i - stride], src[i - 1] + src[i - stride] - src[i - 1 - stride]);

  1330.                     else  src[i] -= src[i - 1];

  1331.                 }

  1332.             }else{

  1333.                 if(y) src[i] -= src[i - stride];

  1334.             }

  1335.         }

  1336.     }

  1337. }

  1338. 

  1339. static void correlate(SnowContext *s, SubBand *b, IDWTELEM *src, int stride, int inverse, int use_median){

  1340.     const int w= b->width;

  1341.     const int h= b->height;

  1342.     int x,y;

  1343. 

  1344.     for(y=0; y<h; y++){

  1345.         for(x=0; x<w; x++){

  1346.             int i= x + y*stride;

  1347. 

  1348.             if(x){

  1349.                 if(use_median){

  1350.                     if(y && x+1<w) src[i] += mid_pred(src[i - 1], src[i - stride], src[i - stride + 1]);

  1351.                     else  src[i] += src[i - 1];

  1352.                 }else{

  1353.                     if(y) src[i] += mid_pred(src[i - 1], src[i - stride], src[i - 1] + src[i - stride] - src[i - 1 - stride]);

  1354.                     else  src[i] += src[i - 1];

  1355.                 }

  1356.             }else{

  1357.                 if(y) src[i] += src[i - stride];

  1358.             }

  1359.         }

  1360.     }

  1361. }

  1362. 

  1363. static void encode_qlogs(SnowContext *s){

  1364.     int plane_index, level, orientation;

  1365. 

  1366.     for(plane_index=0; plane_index<FFMIN(s->nb_planes, 2); plane_index++){

  1367.         for(level=0; level<s->spatial_decomposition_count; level++){

  1368.             for(orientation=level ? 1:0; orientation<4; orientation++){

  1369.                 if(orientation==2) continue;

  1370.                 put_symbol(&s->c, s->header_state, s->plane[plane_index].band[level][orientation].qlog, 1);

  1371.             }

  1372.         }

  1373.     }

  1374. }

  1375. 

  1376. static void encode_header(SnowContext *s){

  1377.     int plane_index, i;

  1378.     uint8_t kstate[32];

  1379. 

  1380.     memset(kstate, MID_STATE, sizeof(kstate));

  1381. 

  1382.     put_rac(&s->c, kstate, s->keyframe);

  1383.     if(s->keyframe || s->always_reset){

  1384.         ff_snow_reset_contexts(s);

  1385.         s->last_spatial_decomposition_type=

  1386.         s->last_qlog=

  1387.         s->last_qbias=

  1388.         s->last_mv_scale=

  1389.         s->last_block_max_depth= 0;

  1390.         for(plane_index=0; plane_index<2; plane_index++){

  1391.             Plane *p= &s->plane[plane_index];

  1392.             p->last_htaps=0;

  1393.             p->last_diag_mc=0;

  1394.             memset(p->last_hcoeff, 0, sizeof(p->last_hcoeff));

  1395.         }

  1396.     }

  1397.     if(s->keyframe){

  1398.         put_symbol(&s->c, s->header_state, s->version, 0);

  1399.         put_rac(&s->c, s->header_state, s->always_reset);

  1400.         put_symbol(&s->c, s->header_state, s->temporal_decomposition_type, 0);

  1401.         put_symbol(&s->c, s->header_state, s->temporal_decomposition_count, 0);

  1402.         put_symbol(&s->c, s->header_state, s->spatial_decomposition_count, 0);

  1403.         put_symbol(&s->c, s->header_state, s->colorspace_type, 0);

  1404.         if (s->nb_planes > 2) {

  1405.             put_symbol(&s->c, s->header_state, s->chroma_h_shift, 0);

  1406.             put_symbol(&s->c, s->header_state, s->chroma_v_shift, 0);

  1407.         }

  1408.         put_rac(&s->c, s->header_state, s->spatial_scalability);

  1409. //        put_rac(&s->c, s->header_state, s->rate_scalability);

  1410.         put_symbol(&s->c, s->header_state, s->max_ref_frames-1, 0);

  1411. 

  1412.         encode_qlogs(s);

  1413.     }

  1414. 

  1415.     if(!s->keyframe){

  1416.         int update_mc=0;

  1417.         for(plane_index=0; plane_index<FFMIN(s->nb_planes, 2); plane_index++){

  1418.             Plane *p= &s->plane[plane_index];

  1419.             update_mc |= p->last_htaps   != p->htaps;

  1420.             update_mc |= p->last_diag_mc != p->diag_mc;

  1421.             update_mc |= !!memcmp(p->last_hcoeff, p->hcoeff, sizeof(p->hcoeff));

  1422.         }

  1423.         put_rac(&s->c, s->header_state, update_mc);

  1424.         if(update_mc){

  1425.             for(plane_index=0; plane_index<FFMIN(s->nb_planes, 2); plane_index++){

  1426.                 Plane *p= &s->plane[plane_index];

  1427.                 put_rac(&s->c, s->header_state, p->diag_mc);

  1428.                 put_symbol(&s->c, s->header_state, p->htaps/2-1, 0);

  1429.                 for(i= p->htaps/2; i; i--)

  1430.                     put_symbol(&s->c, s->header_state, FFABS(p->hcoeff[i]), 0);

  1431.             }

  1432.         }

  1433.         if(s->last_spatial_decomposition_count != s->spatial_decomposition_count){

  1434.             put_rac(&s->c, s->header_state, 1);

  1435.             put_symbol(&s->c, s->header_state, s->spatial_decomposition_count, 0);

  1436.             encode_qlogs(s);

  1437.         }else

  1438.             put_rac(&s->c, s->header_state, 0);

  1439.     }

  1440. 

  1441.     put_symbol(&s->c, s->header_state, s->spatial_decomposition_type - s->last_spatial_decomposition_type, 1);

  1442.     put_symbol(&s->c, s->header_state, s->qlog            - s->last_qlog    , 1);

  1443.     put_symbol(&s->c, s->header_state, s->mv_scale        - s->last_mv_scale, 1);

  1444.     put_symbol(&s->c, s->header_state, s->qbias           - s->last_qbias   , 1);

  1445.     put_symbol(&s->c, s->header_state, s->block_max_depth - s->last_block_max_depth, 1);

  1446. 

  1447. }

  1448. 

  1449. static void update_last_header_values(SnowContext *s){

  1450.     int plane_index;

  1451. 

  1452.     if(!s->keyframe){

  1453.         for(plane_index=0; plane_index<2; plane_index++){

  1454.             Plane *p= &s->plane[plane_index];

  1455.             p->last_diag_mc= p->diag_mc;

  1456.             p->last_htaps  = p->htaps;

  1457.             memcpy(p->last_hcoeff, p->hcoeff, sizeof(p->hcoeff));

  1458.         }

  1459.     }

  1460. 

  1461.     s->last_spatial_decomposition_type  = s->spatial_decomposition_type;

  1462.     s->last_qlog                        = s->qlog;

  1463.     s->last_qbias                       = s->qbias;

  1464.     s->last_mv_scale                    = s->mv_scale;

  1465.     s->last_block_max_depth             = s->block_max_depth;

  1466.     s->last_spatial_decomposition_count = s->spatial_decomposition_count;

  1467. }

  1468. 

  1469. static int qscale2qlog(int qscale){

  1470.     return rint(QROOT*log2(qscale / (float)FF_QP2LAMBDA))

  1471.            + 61*QROOT/8; ///< 64 > 60

  1472. }

  1473. 

  1474. static int ratecontrol_1pass(SnowContext *s, AVFrame *pict)

  1475. {

  1476.     /* Estimate the frame's complexity as a sum of weighted dwt coefficients.

  1477.      * FIXME we know exact mv bits at this point,

  1478.      * but ratecontrol isn't set up to include them. */

  1479.     uint32_t coef_sum= 0;

  1480.     int level, orientation, delta_qlog;

  1481. 

  1482.     for(level=0; level<s->spatial_decomposition_count; level++){

  1483.         for(orientation=level ? 1 : 0; orientation<4; orientation++){

  1484.             SubBand *b= &s->plane[0].band[level][orientation];

  1485.             IDWTELEM *buf= b->ibuf;

  1486.             const int w= b->width;

  1487.             const int h= b->height;

  1488.             const int stride= b->stride;

  1489.             const int qlog= av_clip(2*QROOT + b->qlog, 0, QROOT*16);

  1490.             const int qmul= ff_qexp[qlog&(QROOT-1)]<<(qlog>>QSHIFT);

  1491.             const int qdiv= (1<<16)/qmul;

  1492.             int x, y;

  1493.             //FIXME this is ugly

  1494.             for(y=0; y<h; y++)

  1495.                 for(x=0; x<w; x++)

  1496.                     buf[x+y*stride]= b->buf[x+y*stride];

  1497.             if(orientation==0)

  1498.                 decorrelate(s, b, buf, stride, 1, 0);

  1499.             for(y=0; y<h; y++)

  1500.                 for(x=0; x<w; x++)

  1501.                     coef_sum+= abs(buf[x+y*stride]) * qdiv >> 16;

  1502.         }

  1503.     }

  1504. 

  1505.     /* ugly, ratecontrol just takes a sqrt again */

  1506.     coef_sum = (uint64_t)coef_sum * coef_sum >> 16;

  1507.     av_assert0(coef_sum < INT_MAX);

  1508. 

  1509.     if(pict->pict_type == AV_PICTURE_TYPE_I){

  1510.         s->m.current_picture.mb_var_sum= coef_sum;

  1511.         s->m.current_picture.mc_mb_var_sum= 0;

  1512.     }else{

  1513.         s->m.current_picture.mc_mb_var_sum= coef_sum;

  1514.         s->m.current_picture.mb_var_sum= 0;

  1515.     }

  1516. 

  1517.     pict->quality= ff_rate_estimate_qscale(&s->m, 1);

  1518.     if (pict->quality < 0)

  1519.         return INT_MIN;

  1520.     s->lambda= pict->quality * 3/2;

  1521.     delta_qlog= qscale2qlog(pict->quality) - s->qlog;

  1522.     s->qlog+= delta_qlog;

  1523.     return delta_qlog;

  1524. }

  1525. 

  1526. static void calculate_visual_weight(SnowContext *s, Plane *p){

  1527.     int width = p->width;

  1528.     int height= p->height;

  1529.     int level, orientation, x, y;

  1530. 

  1531.     for(level=0; level<s->spatial_decomposition_count; level++){

  1532.         for(orientation=level ? 1 : 0; orientation<4; orientation++){

  1533.             SubBand *b= &p->band[level][orientation];

  1534.             IDWTELEM *ibuf= b->ibuf;

  1535.             int64_t error=0;

  1536. 

  1537.             memset(s->spatial_idwt_buffer, 0, sizeof(*s->spatial_idwt_buffer)*width*height);

  1538.             ibuf[b->width/2 + b->height/2*b->stride]= 256*16;

  1539.             ff_spatial_idwt(s->spatial_idwt_buffer, s->temp_idwt_buffer, width, height, width, s->spatial_decomposition_type, s->spatial_decomposition_count);

  1540.             for(y=0; y<height; y++){

  1541.                 for(x=0; x<width; x++){

  1542.                     int64_t d= s->spatial_idwt_buffer[x + y*width]*16;

  1543.                     error += d*d;

  1544.                 }

  1545.             }

  1546. 

  1547.             b->qlog= (int)(log(352256.0/sqrt(error)) / log(pow(2.0, 1.0/QROOT))+0.5);

  1548.         }

  1549.     }

  1550. }

  1551. 

  1552. static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,

  1553.                         AVFrame *pict, int *got_packet)

  1554. {

  1555.     SnowContext *s = avctx->priv_data;

  1556.     RangeCoder * const c= &s->c;

  1557.     AVFrame *pic = pict;

  1558.     const int width= s->avctx->width;

  1559.     const int height= s->avctx->height;

  1560.     int level, orientation, plane_index, i, y, ret;

  1561.     uint8_t rc_header_bak[sizeof(s->header_state)];

  1562.     uint8_t rc_block_bak[sizeof(s->block_state)];

  1563. 

  1564.     if ((ret = ff_alloc_packet2(avctx, pkt, s->b_width*s->b_height*MB_SIZE*MB_SIZE*3 + FF_MIN_BUFFER_SIZE)) < 0)

  1565.         return ret;

  1566. 

  1567.     ff_init_range_encoder(c, pkt->data, pkt->size);

  1568.     ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);

  1569. 

  1570.     for(i=0; i < s->nb_planes; i++){

  1571.         int hshift= i ? s->chroma_h_shift : 0;

  1572.         int vshift= i ? s->chroma_v_shift : 0;

  1573.         for(y=0; y<(height>>vshift); y++)

  1574.             memcpy(&s->input_picture->data[i][y * s->input_picture->linesize[i]],

  1575.                    &pict->data[i][y * pict->linesize[i]],

  1576.                    width>>hshift);

  1577.         s->dsp.draw_edges(s->input_picture->data[i], s->input_picture->linesize[i],

  1578.                             width >> hshift, height >> vshift,

  1579.                             EDGE_WIDTH >> hshift, EDGE_WIDTH >> vshift,

  1580.                             EDGE_TOP | EDGE_BOTTOM);

  1581. 

  1582.     }

  1583.     emms_c();

  1584.     s->new_picture = pict;

  1585. 

  1586.     s->m.picture_number= avctx->frame_number;

  1587.     if(avctx->flags&CODEC_FLAG_PASS2){

  1588.         s->m.pict_type = pic->pict_type = s->m.rc_context.entry[avctx->frame_number].new_pict_type;

  1589.         s->keyframe = pic->pict_type == AV_PICTURE_TYPE_I;

  1590.         if(!(avctx->flags&CODEC_FLAG_QSCALE)) {

  1591.             pic->quality = ff_rate_estimate_qscale(&s->m, 0);

  1592.             if (pic->quality < 0)

  1593.                 return -1;

  1594.         }

  1595.     }else{

  1596.         s->keyframe= avctx->gop_size==0 || avctx->frame_number % avctx->gop_size == 0;

  1597.         s->m.pict_type = pic->pict_type = s->keyframe ? AV_PICTURE_TYPE_I : AV_PICTURE_TYPE_P;

  1598.     }

  1599. 

  1600.     if(s->pass1_rc && avctx->frame_number == 0)

  1601.         pic->quality = 2*FF_QP2LAMBDA;

  1602.     if (pic->quality) {

  1603.         s->qlog   = qscale2qlog(pic->quality);

  1604.         s->lambda = pic->quality * 3/2;

  1605.     }

  1606.     if (s->qlog < 0 || (!pic->quality && (avctx->flags & CODEC_FLAG_QSCALE))) {

  1607.         s->qlog= LOSSLESS_QLOG;

  1608.         s->lambda = 0;

  1609.     }//else keep previous frame's qlog until after motion estimation

  1610. 

  1611.     ff_snow_frame_start(s);

  1612.     avctx->coded_frame= s->current_picture;

  1613. 

  1614.     s->m.current_picture_ptr= &s->m.current_picture;

  1615.     s->m.last_picture.f.pts = s->m.current_picture.f.pts;

  1616.     s->m.current_picture.f.pts = pict->pts;

  1617.     if(pic->pict_type == AV_PICTURE_TYPE_P){

  1618.         int block_width = (width +15)>>4;

  1619.         int block_height= (height+15)>>4;

  1620.         int stride= s->current_picture->linesize[0];

  1621. 

  1622.         av_assert0(s->current_picture->data[0]);

  1623.         av_assert0(s->last_picture[0]->data[0]);

  1624. 

  1625.         s->m.avctx= s->avctx;

  1626.         s->m.current_picture.f.data[0] = s->current_picture->data[0];

  1627.         s->m.   last_picture.f.data[0] = s->last_picture[0]->data[0];

  1628.         s->m.    new_picture.f.data[0] = s->  input_picture->data[0];

  1629.         s->m.   last_picture_ptr= &s->m.   last_picture;

  1630.         s->m.linesize=

  1631.         s->m.   last_picture.f.linesize[0] =

  1632.         s->m.    new_picture.f.linesize[0] =

  1633.         s->m.current_picture.f.linesize[0] = stride;

  1634.         s->m.uvlinesize= s->current_picture->linesize[1];

  1635.         s->m.width = width;

  1636.         s->m.height= height;

  1637.         s->m.mb_width = block_width;

  1638.         s->m.mb_height= block_height;

  1639.         s->m.mb_stride=   s->m.mb_width+1;

  1640.         s->m.b8_stride= 2*s->m.mb_width+1;

  1641.         s->m.f_code=1;

  1642.         s->m.pict_type = pic->pict_type;

  1643.         s->m.me_method= s->avctx->me_method;

  1644.         s->m.me.scene_change_score=0;

  1645.         s->m.flags= s->avctx->flags;

  1646.         s->m.quarter_sample= (s->avctx->flags & CODEC_FLAG_QPEL)!=0;

  1647.         s->m.out_format= FMT_H263;

  1648.         s->m.unrestricted_mv= 1;

  1649. 

  1650.         s->m.lambda = s->lambda;

  1651.         s->m.qscale= (s->m.lambda*139 + FF_LAMBDA_SCALE*64) >> (FF_LAMBDA_SHIFT + 7);

  1652.         s->lambda2= s->m.lambda2= (s->m.lambda*s->m.lambda + FF_LAMBDA_SCALE/2) >> FF_LAMBDA_SHIFT;

  1653. 

  1654.         s->m.dsp= s->dsp; //move

  1655.         s->m.hdsp = s->hdsp;

  1656.         ff_init_me(&s->m);

  1657.         s->hdsp = s->m.hdsp;

  1658.         s->dsp= s->m.dsp;

  1659.     }

  1660. 

  1661.     if(s->pass1_rc){

  1662.         memcpy(rc_header_bak, s->header_state, sizeof(s->header_state));

  1663.         memcpy(rc_block_bak, s->block_state, sizeof(s->block_state));

  1664.     }

  1665. 

  1666. redo_frame:

  1667. 

  1668.     if (pic->pict_type == AV_PICTURE_TYPE_I)

  1669.         s->spatial_decomposition_count= 5;

  1670.     else

  1671.         s->spatial_decomposition_count= 5;

  1672. 

  1673.     while(   !(width >>(s->chroma_h_shift + s->spatial_decomposition_count))

  1674.           || !(height>>(s->chroma_v_shift + s->spatial_decomposition_count)))

  1675.         s->spatial_decomposition_count--;

  1676. 

  1677.     if (s->spatial_decomposition_count <= 0) {

  1678.         av_log(avctx, AV_LOG_ERROR, "Resolution too low\n");

  1679.         return AVERROR(EINVAL);

  1680.     }

  1681. 

  1682.     s->m.pict_type = pic->pict_type;

  1683.     s->qbias = pic->pict_type == AV_PICTURE_TYPE_P ? 2 : 0;

  1684. 

  1685.     ff_snow_common_init_after_header(avctx);

  1686. 

  1687.     if(s->last_spatial_decomposition_count != s->spatial_decomposition_count){

  1688.         for(plane_index=0; plane_index < s->nb_planes; plane_index++){

  1689.             calculate_visual_weight(s, &s->plane[plane_index]);

  1690.         }

  1691.     }

  1692. 

  1693.     encode_header(s);

  1694.     s->m.misc_bits = 8*(s->c.bytestream - s->c.bytestream_start);

  1695.     encode_blocks(s, 1);

  1696.     s->m.mv_bits = 8*(s->c.bytestream - s->c.bytestream_start) - s->m.misc_bits;

  1697. 

  1698.     for(plane_index=0; plane_index < s->nb_planes; plane_index++){

  1699.         Plane *p= &s->plane[plane_index];

  1700.         int w= p->width;

  1701.         int h= p->height;

  1702.         int x, y;

  1703. //        int bits= put_bits_count(&s->c.pb);

  1704. 

  1705.         if (!s->memc_only) {

  1706.             //FIXME optimize

  1707.             if(pict->data[plane_index]) //FIXME gray hack

  1708.                 for(y=0; y<h; y++){

  1709.                     for(x=0; x<w; x++){

  1710.                         s->spatial_idwt_buffer[y*w + x]= pict->data[plane_index][y*pict->linesize[plane_index] + x]<<FRAC_BITS;

  1711.                     }

  1712.                 }

  1713.             predict_plane(s, s->spatial_idwt_buffer, plane_index, 0);

  1714. 

  1715.             if(   plane_index==0

  1716.                && pic->pict_type == AV_PICTURE_TYPE_P

  1717.                && !(avctx->flags&CODEC_FLAG_PASS2)

  1718.                && s->m.me.scene_change_score > s->avctx->scenechange_threshold){

  1719.                 ff_init_range_encoder(c, pkt->data, pkt->size);

  1720.                 ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);

  1721.                 pic->pict_type= AV_PICTURE_TYPE_I;

  1722.                 s->keyframe=1;

  1723.                 s->current_picture->key_frame=1;

  1724.                 goto redo_frame;

  1725.             }

  1726. 

  1727.             if(s->qlog == LOSSLESS_QLOG){

  1728.                 for(y=0; y<h; y++){

  1729.                     for(x=0; x<w; x++){

  1730.                         s->spatial_dwt_buffer[y*w + x]= (s->spatial_idwt_buffer[y*w + x] + (1<<(FRAC_BITS-1))-1)>>FRAC_BITS;

  1731.                     }

  1732.                 }

  1733.             }else{

  1734.                 for(y=0; y<h; y++){

  1735.                     for(x=0; x<w; x++){

  1736.                         s->spatial_dwt_buffer[y*w + x]=s->spatial_idwt_buffer[y*w + x]<<ENCODER_EXTRA_BITS;

  1737.                     }

  1738.                 }

  1739.             }

  1740. 

  1741.             ff_spatial_dwt(s->spatial_dwt_buffer, s->temp_dwt_buffer, w, h, w, s->spatial_decomposition_type, s->spatial_decomposition_count);

  1742. 

  1743.             if(s->pass1_rc && plane_index==0){

  1744.                 int delta_qlog = ratecontrol_1pass(s, pic);

  1745.                 if (delta_qlog <= INT_MIN)

  1746.                     return -1;

  1747.                 if(delta_qlog){

  1748.                     //reordering qlog in the bitstream would eliminate this reset

  1749.                     ff_init_range_encoder(c, pkt->data, pkt->size);

  1750.                     memcpy(s->header_state, rc_header_bak, sizeof(s->header_state));

  1751.                     memcpy(s->block_state, rc_block_bak, sizeof(s->block_state));

  1752.                     encode_header(s);

  1753.                     encode_blocks(s, 0);

  1754.                 }

  1755.             }

  1756. 

  1757.             for(level=0; level<s->spatial_decomposition_count; level++){

  1758.                 for(orientation=level ? 1 : 0; orientation<4; orientation++){

  1759.                     SubBand *b= &p->band[level][orientation];

  1760. 

  1761.                     quantize(s, b, b->ibuf, b->buf, b->stride, s->qbias);

  1762.                     if(orientation==0)

  1763.                         decorrelate(s, b, b->ibuf, b->stride, pic->pict_type == AV_PICTURE_TYPE_P, 0);

  1764.                     if (!s->no_bitstream)

  1765.                     encode_subband(s, b, b->ibuf, b->parent ? b->parent->ibuf : NULL, b->stride, orientation);

  1766.                     av_assert0(b->parent==NULL || b->parent->stride == b->stride*2);

  1767.                     if(orientation==0)

  1768.                         correlate(s, b, b->ibuf, b->stride, 1, 0);

  1769.                 }

  1770.             }

  1771. 

  1772.             for(level=0; level<s->spatial_decomposition_count; level++){

  1773.                 for(orientation=level ? 1 : 0; orientation<4; orientation++){

  1774.                     SubBand *b= &p->band[level][orientation];

  1775. 

  1776.                     dequantize(s, b, b->ibuf, b->stride);

  1777.                 }

  1778.             }

  1779. 

  1780.             ff_spatial_idwt(s->spatial_idwt_buffer, s->temp_idwt_buffer, w, h, w, s->spatial_decomposition_type, s->spatial_decomposition_count);

  1781.             if(s->qlog == LOSSLESS_QLOG){

  1782.                 for(y=0; y<h; y++){

  1783.                     for(x=0; x<w; x++){

  1784.                         s->spatial_idwt_buffer[y*w + x]<<=FRAC_BITS;

  1785.                     }

  1786.                 }

  1787.             }

  1788.             predict_plane(s, s->spatial_idwt_buffer, plane_index, 1);

  1789.         }else{

  1790.             //ME/MC only

  1791.             if(pic->pict_type == AV_PICTURE_TYPE_I){

  1792.                 for(y=0; y<h; y++){

  1793.                     for(x=0; x<w; x++){

  1794.                         s->current_picture->data[plane_index][y*s->current_picture->linesize[plane_index] + x]=

  1795.                             pict->data[plane_index][y*pict->linesize[plane_index] + x];

  1796.                     }

  1797.                 }

  1798.             }else{

  1799.                 memset(s->spatial_idwt_buffer, 0, sizeof(IDWTELEM)*w*h);

  1800.                 predict_plane(s, s->spatial_idwt_buffer, plane_index, 1);

  1801.             }

  1802.         }

  1803.         if(s->avctx->flags&CODEC_FLAG_PSNR){

  1804.             int64_t error= 0;

  1805. 

  1806.             if(pict->data[plane_index]) //FIXME gray hack

  1807.                 for(y=0; y<h; y++){

  1808.                     for(x=0; x<w; x++){

  1809.                         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];

  1810.                         error += d*d;

  1811.                     }

  1812.                 }

  1813.             s->avctx->error[plane_index] += error;

  1814.             s->current_picture->error[plane_index] = error;

  1815.         }

  1816. 

  1817.     }

  1818. 

  1819.     update_last_header_values(s);

  1820. 

  1821.     ff_snow_release_buffer(avctx);

  1822. 

  1823.     s->current_picture->coded_picture_number = avctx->frame_number;

  1824.     s->current_picture->pict_type = pict->pict_type;

  1825.     s->current_picture->quality = pict->quality;

  1826.     s->m.frame_bits = 8*(s->c.bytestream - s->c.bytestream_start);

  1827.     s->m.p_tex_bits = s->m.frame_bits - s->m.misc_bits - s->m.mv_bits;

  1828.     s->m.current_picture.f.display_picture_number =

  1829.     s->m.current_picture.f.coded_picture_number   = avctx->frame_number;

  1830.     s->m.current_picture.f.quality                = pic->quality;

  1831.     s->m.total_bits += 8*(s->c.bytestream - s->c.bytestream_start);

  1832.     if(s->pass1_rc)

  1833.         if (ff_rate_estimate_qscale(&s->m, 0) < 0)

  1834.             return -1;

  1835.     if(avctx->flags&CODEC_FLAG_PASS1)

  1836.         ff_write_pass1_stats(&s->m);

  1837.     s->m.last_pict_type = s->m.pict_type;

  1838.     avctx->frame_bits = s->m.frame_bits;

  1839.     avctx->mv_bits = s->m.mv_bits;

  1840.     avctx->misc_bits = s->m.misc_bits;

  1841.     avctx->p_tex_bits = s->m.p_tex_bits;

  1842. 

  1843.     emms_c();

  1844. 

  1845.     pkt->size = ff_rac_terminate(c);

  1846.     if (avctx->coded_frame->key_frame)

  1847.         pkt->flags |= AV_PKT_FLAG_KEY;

  1848.     *got_packet = 1;

  1849. 

  1850.     return 0;

  1851. }

  1852. 

  1853. static av_cold int encode_end(AVCodecContext *avctx)

  1854. {

  1855.     SnowContext *s = avctx->priv_data;

  1856. 

  1857.     ff_snow_common_end(s);

  1858.     ff_rate_control_uninit(&s->m);

  1859.     av_frame_free(&s->input_picture);

  1860.     av_free(avctx->stats_out);

  1861. 

  1862.     return 0;

  1863. }

  1864. 

  1865. #define OFFSET(x) offsetof(SnowContext, x)

  1866. #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM

  1867. static const AVOption options[] = {

  1868.     { "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 },

  1869.     { "no_bitstream",   "Skip final bitstream writeout.",                    OFFSET(no_bitstream), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE },

  1870.     { NULL },

  1871. };

  1872. 

  1873. static const AVClass snowenc_class = {

  1874.     .class_name = "snow encoder",

  1875.     .item_name  = av_default_item_name,

  1876.     .option     = options,

  1877.     .version    = LIBAVUTIL_VERSION_INT,

  1878. };

  1879. 

  1880. AVCodec ff_snow_encoder = {

  1881.     .name           = "snow",

  1882.     .type           = AVMEDIA_TYPE_VIDEO,

  1883.     .id             = AV_CODEC_ID_SNOW,

  1884.     .priv_data_size = sizeof(SnowContext),

  1885.     .init           = encode_init,

  1886.     .encode2        = encode_frame,

  1887.     .close          = encode_end,

  1888.     .pix_fmts       = (const enum AVPixelFormat[]){

  1889.         AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV410P, AV_PIX_FMT_YUV444P,

  1890.         AV_PIX_FMT_GRAY8,

  1891.         AV_PIX_FMT_NONE

  1892.     },

  1893.     .long_name      = NULL_IF_CONFIG_SMALL("Snow"),

  1894.     .priv_class     = &snowenc_class,

  1895. };

  1896. 

  1897. 

  1898. #ifdef TEST

  1899. #undef malloc

  1900. #undef free

  1901. #undef printf

  1902. 

  1903. #include "libavutil/lfg.h"

  1904. #include "libavutil/mathematics.h"

  1905. 

  1906. int main(void){

  1907. #define width  256

  1908. #define height 256

  1909.     int buffer[2][width*height];

  1910.     SnowContext s;

  1911.     int i;

  1912.     AVLFG prng;

  1913.     s.spatial_decomposition_count=6;

  1914.     s.spatial_decomposition_type=1;

  1915. 

  1916.     s.temp_dwt_buffer  = av_mallocz(width * sizeof(DWTELEM));

  1917.     s.temp_idwt_buffer = av_mallocz(width * sizeof(IDWTELEM));

  1918. 

  1919.     av_lfg_init(&prng, 1);

  1920. 

  1921.     printf("testing 5/3 DWT\n");

  1922.     for(i=0; i<width*height; i++)

  1923.         buffer[0][i] = buffer[1][i] = av_lfg_get(&prng) % 54321 - 12345;

  1924. 

  1925.     ff_spatial_dwt(buffer[0], s.temp_dwt_buffer, width, height, width, s.spatial_decomposition_type, s.spatial_decomposition_count);

  1926.     ff_spatial_idwt((IDWTELEM*)buffer[0], s.temp_idwt_buffer, width, height, width, s.spatial_decomposition_type, s.spatial_decomposition_count);

  1927. 

  1928.     for(i=0; i<width*height; i++)

  1929.         if(buffer[0][i]!= buffer[1][i]) printf("fsck: %6d %12d %7d\n",i, buffer[0][i], buffer[1][i]);

  1930. 

  1931.     printf("testing 9/7 DWT\n");

  1932.     s.spatial_decomposition_type=0;

  1933.     for(i=0; i<width*height; i++)

  1934.         buffer[0][i] = buffer[1][i] = av_lfg_get(&prng) % 54321 - 12345;

  1935. 

  1936.     ff_spatial_dwt(buffer[0], s.temp_dwt_buffer, width, height, width, s.spatial_decomposition_type, s.spatial_decomposition_count);

  1937.     ff_spatial_idwt((IDWTELEM*)buffer[0], s.temp_idwt_buffer, width, height, width, s.spatial_decomposition_type, s.spatial_decomposition_count);

  1938. 

  1939.     for(i=0; i<width*height; i++)

  1940.         if(FFABS(buffer[0][i] - buffer[1][i])>20) printf("fsck: %6d %12d %7d\n",i, buffer[0][i], buffer[1][i]);

  1941. 

  1942.     {

  1943.     int level, orientation, x, y;

  1944.     int64_t errors[8][4];

  1945.     int64_t g=0;

  1946. 

  1947.         memset(errors, 0, sizeof(errors));

  1948.         s.spatial_decomposition_count=3;

  1949.         s.spatial_decomposition_type=0;

  1950.         for(level=0; level<s.spatial_decomposition_count; level++){

  1951.             for(orientation=level ? 1 : 0; orientation<4; orientation++){

  1952.                 int w= width  >> (s.spatial_decomposition_count-level);

  1953.                 int h= height >> (s.spatial_decomposition_count-level);

  1954.                 int stride= width  << (s.spatial_decomposition_count-level);

  1955.                 DWTELEM *buf= buffer[0];

  1956.                 int64_t error=0;

  1957. 

  1958.                 if(orientation&1) buf+=w;

  1959.                 if(orientation>1) buf+=stride>>1;

  1960. 

  1961.                 memset(buffer[0], 0, sizeof(int)*width*height);

  1962.                 buf[w/2 + h/2*stride]= 256*256;

  1963.                 ff_spatial_idwt((IDWTELEM*)buffer[0], s.temp_idwt_buffer, width, height, width, s.spatial_decomposition_type, s.spatial_decomposition_count);

  1964.                 for(y=0; y<height; y++){

  1965.                     for(x=0; x<width; x++){

  1966.                         int64_t d= buffer[0][x + y*width];

  1967.                         error += d*d;

  1968.                         if(FFABS(width/2-x)<9 && FFABS(height/2-y)<9 && level==2) printf("%8"PRId64" ", d);

  1969.                     }

  1970.                     if(FFABS(height/2-y)<9 && level==2) printf("\n");

  1971.                 }

  1972.                 error= (int)(sqrt(error)+0.5);

  1973.                 errors[level][orientation]= error;

  1974.                 if(g) g=av_gcd(g, error);

  1975.                 else g= error;

  1976.             }

  1977.         }

  1978.         printf("static int const visual_weight[][4]={\n");

  1979.         for(level=0; level<s.spatial_decomposition_count; level++){

  1980.             printf("  {");

  1981.             for(orientation=0; orientation<4; orientation++){

  1982.                 printf("%8"PRId64",", errors[level][orientation]/g);

  1983.             }

  1984.             printf("},\n");

  1985.         }

  1986.         printf("};\n");

  1987.         {

  1988.             int level=2;

  1989.             int w= width  >> (s.spatial_decomposition_count-level);

  1990.             //int h= height >> (s.spatial_decomposition_count-level);

  1991.             int stride= width  << (s.spatial_decomposition_count-level);

  1992.             DWTELEM *buf= buffer[0];

  1993.             int64_t error=0;

  1994. 

  1995.             buf+=w;

  1996.             buf+=stride>>1;

  1997. 

  1998.             memset(buffer[0], 0, sizeof(int)*width*height);

  1999.             for(y=0; y<height; y++){

  2000.                 for(x=0; x<width; x++){

  2001.                     int tab[4]={0,2,3,1};

  2002.                     buffer[0][x+width*y]= 256*256*tab[(x&1) + 2*(y&1)];

  2003.                 }

  2004.             }

  2005.             ff_spatial_dwt(buffer[0], s.temp_dwt_buffer, width, height, width, s.spatial_decomposition_type, s.spatial_decomposition_count);

  2006.             for(y=0; y<height; y++){

  2007.                 for(x=0; x<width; x++){

  2008.                     int64_t d= buffer[0][x + y*width];

  2009.                     error += d*d;

  2010.                     if(FFABS(width/2-x)<9 && FFABS(height/2-y)<9) printf("%8"PRId64" ", d);

  2011.                 }

  2012.                 if(FFABS(height/2-y)<9) printf("\n");

  2013.             }

  2014.         }

  2015. 

  2016.     }

  2017.     return 0;

  2018. }

  2019. #endif /* TEST */