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