44 #if FF_API_PRIVATE_OPT
58 s->spatial_decomposition_type=
s->pred;
63 for(plane_index=0; plane_index<3; plane_index++){
64 s->plane[plane_index].diag_mc= 1;
65 s->plane[plane_index].htaps= 6;
66 s->plane[plane_index].hcoeff[0]= 40;
67 s->plane[plane_index].hcoeff[1]= -10;
68 s->plane[plane_index].hcoeff[2]= 2;
69 s->plane[plane_index].fast_mc= 1;
85 s->m.mb_num = (avctx->
width * avctx->
height + 255) / 256;
92 if (!
s->m.me.scratchpad || !
s->m.me.map || !
s->m.me.score_map || !
s->m.sc.obmc_scratchpad)
120 s->colorspace_type= 0;
124 s->colorspace_type = 1;
142 ff_set_cmp(&
s->mecc,
s->mecc.me_sub_cmp,
s->avctx->me_sub_cmp);
145 if (!
s->input_picture)
152 int size=
s->b_width *
s->b_height << 2*
s->block_max_depth;
153 for(
i=0;
i<
s->max_ref_frames;
i++){
156 if (!
s->ref_mvs[
i] || !
s->ref_scores[
i])
170 for (
i = 0;
i <
h;
i++) {
171 for (j = 0; j <
w; j++) {
175 pix += line_size -
w;
187 for (
i = 0;
i <
w;
i++) {
188 for (j = 0; j <
w; j ++) {
192 pix += line_size -
w;
224 #define P_TOPRIGHT P[3]
225 #define P_MEDIAN P[4]
232 uint8_t p_state[
sizeof(
s->block_state)];
233 uint8_t i_state[
sizeof(
s->block_state)];
236 uint8_t *pbbak_start=
s->c.bytestream_start;
237 int score, score2, iscore, i_len, p_len, block_s, sum, base_bits;
238 const int w=
s->b_width <<
s->block_max_depth;
239 const int h=
s->b_height <<
s->block_max_depth;
240 const int rem_depth=
s->block_max_depth -
level;
241 const int index= (x + y*
w) << rem_depth;
243 int trx= (x+1)<<rem_depth;
244 int try= (y+1)<<rem_depth;
251 int pl = left->
color[0];
252 int pcb= left->
color[1];
253 int pcr= left->
color[2];
257 const int stride=
s->current_picture->linesize[0];
258 const int uvstride=
s->current_picture->linesize[1];
259 uint8_t *current_data[3]= {
s->input_picture->data[0] + (x + y*
stride)*block_w,
260 s->input_picture->data[1] + ((x*block_w)>>
s->chroma_h_shift) + ((y*uvstride*block_w)>>
s->chroma_v_shift),
261 s->input_picture->data[2] + ((x*block_w)>>
s->chroma_h_shift) + ((y*uvstride*block_w)>>
s->chroma_v_shift)};
263 int16_t last_mv[3][2];
265 const int shift= 1+qpel;
271 int ref, best_ref, ref_score, ref_mx, ref_my;
272 int range =
MAX_MV >> (1 + qpel);
276 set_blocks(
s,
level, x, y, pl, pcb, pcr, 0, 0, 0,
BLOCK_INTRA);
289 last_mv[0][0]=
s->block[
index].mx;
290 last_mv[0][1]=
s->block[
index].my;
291 last_mv[1][0]= right->
mx;
292 last_mv[1][1]= right->
my;
293 last_mv[2][0]= bottom->
mx;
294 last_mv[2][1]= bottom->
my;
307 c->current_mv_penalty=
c->mv_penalty[
s->m.f_code=1] +
MAX_DMV;
309 c->xmin = - x*block_w - 16+3;
310 c->ymin = - y*block_w - 16+3;
311 c->xmax = - (x+1)*block_w + (
w<<(
LOG2_MB_SIZE -
s->block_max_depth)) + 16-3;
312 c->ymax = - (y+1)*block_w + (
h<<(
LOG2_MB_SIZE -
s->block_max_depth)) + 16-3;
314 c->xmin =
FFMAX(
c->xmin,-range);
315 c->xmax =
FFMIN(
c->xmax, range);
316 c->ymin =
FFMAX(
c->ymin,-range);
317 c->ymax =
FFMIN(
c->ymax, range);
341 init_ref(
c, current_data,
s->last_picture[
ref]->data,
NULL, block_w*x, block_w*y, 0);
351 ref_score=
c->sub_motion_search(&
s->m, &ref_mx, &ref_my, ref_score, 0, 0,
level-
LOG2_MB_SIZE+4, block_w);
359 if(score > ref_score){
369 base_bits=
get_rac_count(&
s->c) - 8*(
s->c.bytestream -
s->c.bytestream_start);
372 pc.bytestream= p_buffer;
373 memcpy(p_state,
s->block_state,
sizeof(
s->block_state));
375 if(
level!=
s->block_max_depth)
376 put_rac(&pc, &p_state[4 + s_context], 1);
378 if(
s->ref_frames > 1)
379 put_symbol(&pc, &p_state[128 + 1024 + 32*ref_context], best_ref, 0);
380 pred_mv(
s, &pmx, &pmy, best_ref, left, top, tr);
381 put_symbol(&pc, &p_state[128 + 32*(mx_context + 16*!!best_ref)], mx - pmx, 1);
382 put_symbol(&pc, &p_state[128 + 32*(my_context + 16*!!best_ref)], my - pmy, 1);
383 p_len= pc.bytestream - pc.bytestream_start;
386 block_s= block_w*block_w;
388 l= (sum + block_s/2)/block_s;
389 iscore =
pix_norm1(current_data[0],
stride, block_w) - 2*l*sum + l*l*block_s;
391 if (
s->nb_planes > 2) {
392 block_s= block_w*block_w>>(
s->chroma_h_shift +
s->chroma_v_shift);
393 sum =
pix_sum(current_data[1], uvstride, block_w>>
s->chroma_h_shift, block_w>>
s->chroma_v_shift);
394 cb= (sum + block_s/2)/block_s;
396 sum =
pix_sum(current_data[2], uvstride, block_w>>
s->chroma_h_shift, block_w>>
s->chroma_v_shift);
397 cr= (sum + block_s/2)/block_s;
404 ic.bytestream= i_buffer;
405 memcpy(i_state,
s->block_state,
sizeof(
s->block_state));
406 if(
level!=
s->block_max_depth)
407 put_rac(&ic, &i_state[4 + s_context], 1);
410 if (
s->nb_planes > 2) {
414 i_len= ic.bytestream - ic.bytestream_start;
417 av_assert1(iscore < 255*255*256 + s->lambda2*10);
423 int varc= iscore >> 8;
424 int vard= score >> 8;
425 if (vard <= 64 || vard < varc)
428 c->scene_change_score+=
s->m.qscale;
431 if(
level!=
s->block_max_depth){
432 put_rac(&
s->c, &
s->block_state[4 + s_context], 0);
439 if(score2 < score && score2 < iscore)
444 pred_mv(
s, &pmx, &pmy, 0, left, top, tr);
445 memcpy(pbbak, i_buffer, i_len);
447 s->c.bytestream_start= pbbak_start;
448 s->c.bytestream= pbbak + i_len;
449 set_blocks(
s,
level, x, y, l,
cb,
cr, pmx, pmy, 0,
BLOCK_INTRA);
450 memcpy(
s->block_state, i_state,
sizeof(
s->block_state));
453 memcpy(pbbak, p_buffer, p_len);
455 s->c.bytestream_start= pbbak_start;
456 s->c.bytestream= pbbak + p_len;
457 set_blocks(
s,
level, x, y, pl, pcb, pcr, mx, my, best_ref, 0);
458 memcpy(
s->block_state, p_state,
sizeof(
s->block_state));
464 const int w=
s->b_width <<
s->block_max_depth;
465 const int rem_depth=
s->block_max_depth -
level;
466 const int index= (x + y*
w) << rem_depth;
467 int trx= (x+1)<<rem_depth;
473 int pl = left->
color[0];
474 int pcb= left->
color[1];
475 int pcr= left->
color[2];
483 set_blocks(
s,
level, x, y, pl, pcb, pcr, 0, 0, 0,
BLOCK_INTRA);
487 if(
level!=
s->block_max_depth){
489 put_rac(&
s->c, &
s->block_state[4 + s_context], 1);
491 put_rac(&
s->c, &
s->block_state[4 + s_context], 0);
500 pred_mv(
s, &pmx, &pmy, 0, left, top, tr);
503 if (
s->nb_planes > 2) {
507 set_blocks(
s,
level, x, y,
b->color[0],
b->color[1],
b->color[2], pmx, pmy, 0,
BLOCK_INTRA);
509 pred_mv(
s, &pmx, &pmy,
b->ref, left, top, tr);
511 if(
s->ref_frames > 1)
512 put_symbol(&
s->c, &
s->block_state[128 + 1024 + 32*ref_context],
b->ref, 0);
513 put_symbol(&
s->c, &
s->block_state[128 + 32*mx_context],
b->mx - pmx, 1);
514 put_symbol(&
s->c, &
s->block_state[128 + 32*my_context],
b->my - pmy, 1);
515 set_blocks(
s,
level, x, y, pl, pcb, pcr,
b->mx,
b->my,
b->ref, 0);
521 Plane *p= &
s->plane[plane_index];
522 const int block_size =
MB_SIZE >>
s->block_max_depth;
523 const int block_w = plane_index ? block_size>>
s->chroma_h_shift : block_size;
524 const int block_h = plane_index ? block_size>>
s->chroma_v_shift : block_size;
526 const int obmc_stride= plane_index ? (2*block_size)>>
s->chroma_h_shift : 2*block_size;
527 const int ref_stride=
s->current_picture->linesize[plane_index];
528 uint8_t *
src=
s-> input_picture->data[plane_index];
529 IDWTELEM *dst= (
IDWTELEM*)
s->m.sc.obmc_scratchpad + plane_index*block_size*block_size*4;
530 const int b_stride =
s->b_width <<
s->block_max_depth;
533 int index= mb_x + mb_y*b_stride;
542 b->color[plane_index]= 0;
543 memset(dst, 0, obmc_stride*obmc_stride*
sizeof(
IDWTELEM));
546 int mb_x2= mb_x + (
i &1) - 1;
547 int mb_y2= mb_y + (
i>>1) - 1;
548 int x= block_w*mb_x2 + block_w/2;
549 int y= block_h*mb_y2 + block_h/2;
552 x, y, block_w, block_h,
w,
h, obmc_stride, ref_stride, obmc_stride, mb_x2, mb_y2, 0, 0, plane_index);
554 for(y2=
FFMAX(y, 0); y2<
FFMIN(
h, y+block_h); y2++){
555 for(x2=
FFMAX(x, 0); x2<
FFMIN(
w, x+block_w); x2++){
556 int index= x2-(block_w*mb_x - block_w/2) + (y2-(block_h*mb_y - block_h/2))*obmc_stride;
557 int obmc_v= obmc[
index];
559 if(y<0) obmc_v += obmc[
index + block_h*obmc_stride];
560 if(x<0) obmc_v += obmc[
index + block_w];
561 if(y+block_h>
h) obmc_v += obmc[
index - block_h*obmc_stride];
562 if(x+block_w>
w) obmc_v += obmc[
index - block_w];
567 ab += (
src[x2 + y2*ref_stride] - (d>>
FRAC_BITS)) * obmc_v;
568 aa += obmc_v * obmc_v;
578 const int b_stride =
s->b_width <<
s->block_max_depth;
579 const int b_height =
s->b_height<<
s->block_max_depth;
580 int index= x + y*b_stride;
590 if(x<0 || x>=b_stride || y>=b_height)
606 pred_mv(
s, &dmx, &dmy,
b->ref, left, top, tr);
616 Plane *p= &
s->plane[plane_index];
617 const int block_size =
MB_SIZE >>
s->block_max_depth;
618 const int block_w = plane_index ? block_size>>
s->chroma_h_shift : block_size;
619 const int block_h = plane_index ? block_size>>
s->chroma_v_shift : block_size;
620 const int obmc_stride= plane_index ? (2*block_size)>>
s->chroma_h_shift : 2*block_size;
621 const int ref_stride=
s->current_picture->linesize[plane_index];
622 uint8_t *dst=
s->current_picture->data[plane_index];
623 uint8_t *
src=
s-> input_picture->data[plane_index];
627 const int b_stride =
s->b_width <<
s->block_max_depth;
628 const int b_height =
s->b_height<<
s->block_max_depth;
634 int sx= block_w*mb_x - block_w/2;
635 int sy= block_h*mb_y - block_h/2;
636 int x0=
FFMAX(0,-sx);
637 int y0=
FFMAX(0,-sy);
638 int x1=
FFMIN(block_w*2,
w-sx);
639 int y1=
FFMIN(block_h*2,
h-sy);
644 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);
646 for(y=y0; y<y1; y++){
647 const uint8_t *obmc1= obmc_edged[y];
649 uint8_t *cur1 = cur + y*ref_stride;
650 uint8_t *dst1 = dst + sx + (sy+y)*ref_stride;
651 for(x=x0; x<x1; x++){
652 #if FRAC_BITS >= LOG2_OBMC_MAX
658 if(v&(~255)) v= ~(v>>31);
665 && (mb_x == 0 || mb_x == b_stride-1)
666 && (mb_y == 0 || mb_y == b_height-1)){
676 memcpy(dst + sx+x0 + (sy+y)*ref_stride, cur + x0 + y*ref_stride, x1-x0);
687 distortion =
ff_w97_32_c(&
s->m,
src + sx + sy*ref_stride, dst + sx + sy*ref_stride, ref_stride, 32);
689 distortion =
ff_w53_32_c(&
s->m,
src + sx + sy*ref_stride, dst + sx + sy*ref_stride, ref_stride, 32);
693 int off = sx+16*(
i&1) + (sy+16*(
i>>1))*ref_stride;
694 distortion +=
s->mecc.me_cmp[0](&
s->m,
src + off, dst + off, ref_stride, 16);
699 distortion =
s->mecc.me_cmp[0](&
s->m,
src + sx + sy*ref_stride, dst + sx + sy*ref_stride, ref_stride, block_w*2);
710 if(mb_x == b_stride-2)
713 return distortion + rate*penalty_factor;
718 Plane *p= &
s->plane[plane_index];
719 const int block_size =
MB_SIZE >>
s->block_max_depth;
720 const int block_w = plane_index ? block_size>>
s->chroma_h_shift : block_size;
721 const int block_h = plane_index ? block_size>>
s->chroma_v_shift : block_size;
723 const int obmc_stride= plane_index ? (2*block_size)>>
s->chroma_h_shift : 2*block_size;
724 const int ref_stride=
s->current_picture->linesize[plane_index];
725 uint8_t *dst=
s->current_picture->data[plane_index];
726 uint8_t *
src=
s-> input_picture->data[plane_index];
730 const int b_stride =
s->b_width <<
s->block_max_depth;
740 int mb_x2= mb_x + (
i%3) - 1;
741 int mb_y2= mb_y + (
i/3) - 1;
742 int x= block_w*mb_x2 + block_w/2;
743 int y= block_h*mb_y2 + block_h/2;
746 x, y, block_w, block_h,
w,
h, 0, ref_stride, obmc_stride, mb_x2, mb_y2, 1, 1, plane_index);
749 for(y2= y; y2<0; y2++)
750 memcpy(dst + x + y2*ref_stride,
src + x + y2*ref_stride, block_w);
751 for(y2=
h; y2<y+block_h; y2++)
752 memcpy(dst + x + y2*ref_stride,
src + x + y2*ref_stride, block_w);
754 for(y2= y; y2<y+block_h; y2++)
755 memcpy(dst + x + y2*ref_stride,
src + x + y2*ref_stride, -x);
758 for(y2= y; y2<y+block_h; y2++)
759 memcpy(dst +
w + y2*ref_stride,
src +
w + y2*ref_stride, x+block_w -
w);
763 distortion +=
s->mecc.me_cmp[block_w==8](&
s->m,
src + x + y*ref_stride, dst + x + y*ref_stride, ref_stride, block_h);
777 for(
i=merged?4:0;
i<9;
i++){
778 static const int dxy[9][2] = {{0,0},{1,0},{0,1},{1,1},{2,0},{2,1},{-1,2},{0,2},{1,2}};
782 return distortion + rate*penalty_factor;
786 const int w=
b->width;
787 const int h=
b->height;
792 int *runs =
s->run_buffer;
799 int l=0, lt=0, t=0, rt=0;
821 if(px<b->parent->width && py<b->parent->height)
822 p= parent[px + py*2*
stride];
826 runs[run_index++]=
run;
834 max_index= run_index;
835 runs[run_index++]=
run;
837 run= runs[run_index++];
840 if(run_index <= max_index)
844 if(
s->c.bytestream_end -
s->c.bytestream <
w*40){
850 int l=0, lt=0, t=0, rt=0;
872 if(px<b->parent->width && py<b->parent->height)
873 p= parent[px + py*2*
stride];
878 put_rac(&
s->c, &
b->state[0][context], !!v);
881 run= runs[run_index++];
883 if(run_index <= max_index)
893 int l2= 2*
FFABS(l) + (l<0);
913 const int b_stride=
s->b_width <<
s->block_max_depth;
923 block->color[0] = p[0];
924 block->color[1] = p[1];
925 block->color[2] = p[2];
929 value=
s->me_cache_generation + (p[0]>>10) + (p[1]<<6) + (
block->ref<<12);
939 rd=
get_block_rd(
s, mb_x, mb_y, 0, obmc_edged) +
s->intra_penalty * !!intra;
955 return check_block(
s, mb_x, mb_y, p, 0, obmc_edged, best_rd);
959 const int b_stride=
s->b_width <<
s->block_max_depth;
968 backup[0] =
block[0];
969 backup[1] =
block[1];
970 backup[2] =
block[b_stride];
971 backup[3] =
block[b_stride + 1];
978 value=
s->me_cache_generation + (p0>>10) + (p1<<6) + (
block->ref<<12);
998 block[b_stride]= backup[2];
999 block[b_stride+1]= backup[3];
1005 int pass, mb_x, mb_y;
1006 const int b_width =
s->b_width <<
s->block_max_depth;
1007 const int b_height=
s->b_height <<
s->block_max_depth;
1008 const int b_stride= b_width;
1014 memcpy(
state,
s->block_state,
sizeof(
s->block_state));
1015 for(mb_y= 0; mb_y<
s->b_height; mb_y++)
1016 for(mb_x= 0; mb_x<
s->b_width; mb_x++)
1019 memcpy(
s->block_state,
state,
sizeof(
s->block_state));
1025 for(mb_y= 0; mb_y<b_height; mb_y++){
1026 for(mb_x= 0; mb_x<b_width; mb_x++){
1027 int dia_change,
i, j,
ref;
1028 int best_rd= INT_MAX, ref_rd;
1030 const int index= mb_x + mb_y * b_stride;
1040 const int b_w= (
MB_SIZE >>
s->block_max_depth);
1049 if(!
s->me_cache_generation)
1050 memset(
s->me_cache, 0,
sizeof(
s->me_cache));
1051 s->me_cache_generation += 1<<22;
1056 for (y = 0; y < b_w * 2; y++)
1057 memcpy(obmc_edged[y],
ff_obmc_tab[
s->block_max_depth] + y * b_w * 2, b_w * 2);
1059 for(y=0; y<b_w*2; y++)
1060 memset(obmc_edged[y], obmc_edged[y][0] + obmc_edged[y][b_w-1], b_w);
1061 if(mb_x==b_stride-1)
1062 for(y=0; y<b_w*2; y++)
1063 memset(obmc_edged[y]+b_w, obmc_edged[y][b_w] + obmc_edged[y][b_w*2-1], b_w);
1065 for(x=0; x<b_w*2; x++)
1066 obmc_edged[0][x] += obmc_edged[b_w-1][x];
1067 for(y=1; y<b_w; y++)
1068 memcpy(obmc_edged[y], obmc_edged[0], b_w*2);
1070 if(mb_y==b_height-1){
1071 for(x=0; x<b_w*2; x++)
1072 obmc_edged[b_w*2-1][x] += obmc_edged[b_w][x];
1073 for(y=b_w; y<b_w*2-1; y++)
1074 memcpy(obmc_edged[y], obmc_edged[b_w*2-1], b_w*2);
1079 if(mb_x==0 || mb_y==0 || mb_x==b_width-1 || mb_y==b_height-1){
1081 uint8_t *dst=
s->current_picture->data[0];
1082 const int stride=
s->current_picture->linesize[0];
1083 const int block_w=
MB_SIZE >>
s->block_max_depth;
1084 const int block_h=
MB_SIZE >>
s->block_max_depth;
1085 const int sx= block_w*mb_x - block_w/2;
1086 const int sy= block_h*mb_y - block_h/2;
1087 const int w=
s->plane[0].width;
1088 const int h=
s->plane[0].height;
1093 for(y=
h; y<sy+block_h*2; y++)
1096 for(y=sy; y<sy+block_h*2; y++)
1099 if(sx+block_w*2 >
w){
1100 for(y=sy; y<sy+block_h*2; y++)
1106 for(
i=0;
i <
s->nb_planes;
i++)
1112 check_block(
s, mb_x, mb_y, color0, 1, obmc_edged, &best_rd);
1119 int16_t (*mvr)[2]= &
s->ref_mvs[
ref][
index];
1128 check_block_inter(
s, mb_x, mb_y, mvr[-b_stride][0], mvr[-b_stride][1], obmc_edged, &best_rd);
1134 check_block_inter(
s, mb_x, mb_y, mvr[b_stride][0], mvr[b_stride][1], obmc_edged, &best_rd);
1139 int newx =
block->mx;
1140 int newy =
block->my;
1141 int dia_size =
s->iterative_dia_size ?
s->iterative_dia_size :
FFMAX(
s->avctx->dia_size, 1);
1143 for(
i=0;
i < dia_size;
i++){
1145 dia_change |=
check_block_inter(
s, mb_x, mb_y, newx+4*(
i-j), newy+(4*j), obmc_edged, &best_rd);
1146 dia_change |=
check_block_inter(
s, mb_x, mb_y, newx-4*(
i-j), newy-(4*j), obmc_edged, &best_rd);
1147 dia_change |=
check_block_inter(
s, mb_x, mb_y, newx-(4*j), newy+4*(
i-j), obmc_edged, &best_rd);
1148 dia_change |=
check_block_inter(
s, mb_x, mb_y, newx+(4*j), newy-4*(
i-j), obmc_edged, &best_rd);
1154 static const int square[8][2]= {{+1, 0},{-1, 0},{ 0,+1},{ 0,-1},{+1,+1},{-1,-1},{+1,-1},{-1,+1},};
1161 mvr[0][0]=
block->mx;
1162 mvr[0][1]=
block->my;
1163 if(ref_rd > best_rd){
1190 if(
s->block_max_depth == 1){
1192 for(mb_y= 0; mb_y<b_height; mb_y+=2){
1193 for(mb_x= 0; mb_x<b_width; mb_x+=2){
1195 int best_rd, init_rd;
1196 const int index= mb_x + mb_y * b_stride;
1201 b[2]=
b[0]+b_stride;
1208 if(!
s->me_cache_generation)
1209 memset(
s->me_cache, 0,
sizeof(
s->me_cache));
1210 s->me_cache_generation += 1<<22;
1216 (
b[0]->mx +
b[1]->mx +
b[2]->mx +
b[3]->mx + 2) >> 2,
1217 (
b[0]->my +
b[1]->my +
b[2]->my +
b[3]->my + 2) >> 2, 0, &best_rd);
1223 if(init_rd != best_rd)
1254 const int w=
b->width;
1255 const int h=
b->height;
1258 int x,y, thres1, thres2;
1267 bias= bias ? 0 : (3*qmul)>>3;
1276 if((
unsigned)(
i+thres1) > thres2){
1296 if((
unsigned)(
i+thres1) > thres2){
1299 i= (
i + bias) / qmul;
1304 i= (
i + bias) / qmul;
1315 const int w=
b->width;
1316 const int h=
b->height;
1337 const int w=
b->width;
1338 const int h=
b->height;
1341 for(y=
h-1; y>=0; y--){
1342 for(x=
w-1; x>=0; x--){
1361 const int w=
b->width;
1362 const int h=
b->height;
1385 int plane_index,
level, orientation;
1387 for(plane_index=0; plane_index<
FFMIN(
s->nb_planes, 2); plane_index++){
1389 for(orientation=
level ? 1:0; orientation<4; orientation++){
1390 if(orientation==2)
continue;
1391 put_symbol(&
s->c,
s->header_state,
s->plane[plane_index].band[
level][orientation].qlog, 1);
1401 memset(kstate,
MID_STATE,
sizeof(kstate));
1404 if(
s->keyframe ||
s->always_reset){
1406 s->last_spatial_decomposition_type=
1410 s->last_block_max_depth= 0;
1411 for(plane_index=0; plane_index<2; plane_index++){
1412 Plane *p= &
s->plane[plane_index];
1420 put_rac(&
s->c,
s->header_state,
s->always_reset);
1421 put_symbol(&
s->c,
s->header_state,
s->temporal_decomposition_type, 0);
1422 put_symbol(&
s->c,
s->header_state,
s->temporal_decomposition_count, 0);
1423 put_symbol(&
s->c,
s->header_state,
s->spatial_decomposition_count, 0);
1425 if (
s->nb_planes > 2) {
1429 put_rac(&
s->c,
s->header_state,
s->spatial_scalability);
1438 for(plane_index=0; plane_index<
FFMIN(
s->nb_planes, 2); plane_index++){
1439 Plane *p= &
s->plane[plane_index];
1444 put_rac(&
s->c,
s->header_state, update_mc);
1446 for(plane_index=0; plane_index<
FFMIN(
s->nb_planes, 2); plane_index++){
1447 Plane *p= &
s->plane[plane_index];
1454 if(
s->last_spatial_decomposition_count !=
s->spatial_decomposition_count){
1456 put_symbol(&
s->c,
s->header_state,
s->spatial_decomposition_count, 0);
1462 put_symbol(&
s->c,
s->header_state,
s->spatial_decomposition_type -
s->last_spatial_decomposition_type, 1);
1464 put_symbol(&
s->c,
s->header_state,
s->mv_scale -
s->last_mv_scale, 1);
1465 put_symbol(&
s->c,
s->header_state,
s->qbias -
s->last_qbias , 1);
1466 put_symbol(&
s->c,
s->header_state,
s->block_max_depth -
s->last_block_max_depth, 1);
1474 for(plane_index=0; plane_index<2; plane_index++){
1475 Plane *p= &
s->plane[plane_index];
1482 s->last_spatial_decomposition_type =
s->spatial_decomposition_type;
1483 s->last_qlog =
s->qlog;
1484 s->last_qbias =
s->qbias;
1485 s->last_mv_scale =
s->mv_scale;
1486 s->last_block_max_depth =
s->block_max_depth;
1487 s->last_spatial_decomposition_count =
s->spatial_decomposition_count;
1500 uint32_t coef_sum= 0;
1501 int level, orientation, delta_qlog;
1504 for(orientation=
level ? 1 : 0; orientation<4; orientation++){
1507 const int w=
b->width;
1508 const int h=
b->height;
1512 const int qdiv= (1<<16)/qmul;
1522 coef_sum+=
abs(buf[x+y*
stride]) * qdiv >> 16;
1528 coef_sum = (uint64_t)coef_sum * coef_sum >> 16;
1531 s->m.current_picture.mb_var_sum= coef_sum;
1532 s->m.current_picture.mc_mb_var_sum= 0;
1534 s->m.current_picture.mc_mb_var_sum= coef_sum;
1535 s->m.current_picture.mb_var_sum= 0;
1543 s->qlog+= delta_qlog;
1550 int level, orientation, x, y;
1554 for(orientation=
level ? 1 : 0; orientation<4; orientation++){
1558 memset(
s->spatial_idwt_buffer, 0,
sizeof(*
s->spatial_idwt_buffer)*
width*
height);
1559 ibuf[
b->width/2 +
b->height/2*
b->stride]= 256*16;
1562 for(x=0; x<
width; x++){
1567 if (orientation == 2)
1570 if (orientation != 1)
1578 const AVFrame *pict,
int *got_packet)
1583 const int width=
s->avctx->width;
1584 const int height=
s->avctx->height;
1585 int level, orientation, plane_index,
i, y, ret;
1586 uint8_t rc_header_bak[
sizeof(
s->header_state)];
1587 uint8_t rc_block_bak[
sizeof(
s->block_state)];
1595 for(
i=0;
i <
s->nb_planes;
i++){
1596 int hshift=
i ?
s->chroma_h_shift : 0;
1597 int vshift=
i ?
s->chroma_v_shift : 0;
1599 memcpy(&
s->input_picture->data[
i][y *
s->input_picture->linesize[
i]],
1602 s->mpvencdsp.draw_edges(
s->input_picture->data[
i],
s->input_picture->linesize[
i],
1609 pic =
s->input_picture;
1638 #if FF_API_CODED_FRAME
1644 if (
s->current_picture->data[0]) {
1645 int w =
s->avctx->width;
1646 int h =
s->avctx->height;
1648 #if FF_API_CODED_FRAME
1654 s->mpvencdsp.draw_edges(
s->current_picture->data[0],
1655 s->current_picture->linesize[0],
w ,
h ,
1657 if (
s->current_picture->data[2]) {
1658 s->mpvencdsp.draw_edges(
s->current_picture->data[1],
1659 s->current_picture->linesize[1],
w>>
s->chroma_h_shift,
h>>
s->chroma_v_shift,
1661 s->mpvencdsp.draw_edges(
s->current_picture->data[2],
1662 s->current_picture->linesize[2],
w>>
s->chroma_h_shift,
h>>
s->chroma_v_shift,
1669 #if FF_API_CODED_FRAME
1677 s->m.current_picture_ptr= &
s->m.current_picture;
1678 s->m.current_picture.f =
s->current_picture;
1679 s->m.current_picture.f->pts = pict->
pts;
1681 int block_width = (
width +15)>>4;
1682 int block_height= (
height+15)>>4;
1683 int stride=
s->current_picture->linesize[0];
1688 s->m.avctx=
s->avctx;
1690 s->m. new_picture.f =
s->input_picture;
1693 s->m.uvlinesize=
s->current_picture->linesize[1];
1696 s->m.mb_width = block_width;
1697 s->m.mb_height= block_height;
1698 s->m.mb_stride=
s->m.mb_width+1;
1699 s->m.b8_stride= 2*
s->m.mb_width+1;
1702 s->m.motion_est=
s->motion_est;
1703 s->m.me.scene_change_score=0;
1707 s->m.unrestricted_mv= 1;
1709 s->m.lambda =
s->lambda;
1715 s->m.hdsp =
s->hdsp;
1717 s->hdsp =
s->m.hdsp;
1722 memcpy(rc_header_bak,
s->header_state,
sizeof(
s->header_state));
1723 memcpy(rc_block_bak,
s->block_state,
sizeof(
s->block_state));
1728 s->spatial_decomposition_count= 5;
1730 while( !(
width >>(
s->chroma_h_shift +
s->spatial_decomposition_count))
1731 || !(
height>>(
s->chroma_v_shift +
s->spatial_decomposition_count)))
1732 s->spatial_decomposition_count--;
1734 if (
s->spatial_decomposition_count <= 0) {
1744 if(
s->last_spatial_decomposition_count !=
s->spatial_decomposition_count){
1745 for(plane_index=0; plane_index <
s->nb_planes; plane_index++){
1751 s->m.misc_bits = 8*(
s->c.bytestream -
s->c.bytestream_start);
1753 s->m.mv_bits = 8*(
s->c.bytestream -
s->c.bytestream_start) -
s->m.misc_bits;
1755 for(plane_index=0; plane_index < s->nb_planes; plane_index++){
1756 Plane *p= &
s->plane[plane_index];
1762 if (!
s->memc_only) {
1764 if(pict->
data[plane_index])
1772 #if FF_API_PRIVATE_OPT
1774 if(
s->avctx->scenechange_threshold)
1775 s->scenechange_threshold =
s->avctx->scenechange_threshold;
1782 &&
s->m.me.scene_change_score >
s->scenechange_threshold){
1787 s->current_picture->key_frame=1;
1805 ff_spatial_dwt(
s->spatial_dwt_buffer,
s->temp_dwt_buffer,
w,
h,
w,
s->spatial_decomposition_type,
s->spatial_decomposition_count);
1807 if(
s->pass1_rc && plane_index==0){
1809 if (delta_qlog <= INT_MIN)
1814 memcpy(
s->header_state, rc_header_bak,
sizeof(
s->header_state));
1815 memcpy(
s->block_state, rc_block_bak,
sizeof(
s->block_state));
1822 for(orientation=
level ? 1 : 0; orientation<4; orientation++){
1828 if (!
s->no_bitstream)
1837 for(orientation=
level ? 1 : 0; orientation<4; orientation++){
1844 ff_spatial_idwt(
s->spatial_idwt_buffer,
s->temp_idwt_buffer,
w,
h,
w,
s->spatial_decomposition_type,
s->spatial_decomposition_count);
1858 s->current_picture->data[plane_index][y*
s->current_picture->linesize[plane_index] + x]=
1859 pict->
data[plane_index][y*pict->
linesize[plane_index] + x];
1863 memset(
s->spatial_idwt_buffer, 0,
sizeof(
IDWTELEM)*
w*
h);
1870 if(pict->
data[plane_index])
1873 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];
1877 s->avctx->error[plane_index] +=
error;
1878 s->encoding_error[plane_index] =
error;
1888 s->current_picture->coded_picture_number = avctx->
frame_number;
1889 s->current_picture->pict_type = pic->
pict_type;
1890 s->current_picture->quality = pic->
quality;
1891 s->m.frame_bits = 8*(
s->c.bytestream -
s->c.bytestream_start);
1892 s->m.p_tex_bits =
s->m.frame_bits -
s->m.misc_bits -
s->m.mv_bits;
1893 s->m.current_picture.f->display_picture_number =
1894 s->m.current_picture.f->coded_picture_number = avctx->
frame_number;
1895 s->m.current_picture.f->quality = pic->
quality;
1896 s->m.total_bits += 8*(
s->c.bytestream -
s->c.bytestream_start);
1902 s->m.last_pict_type =
s->m.pict_type;
1903 #if FF_API_STAT_BITS
1917 s->current_picture->pict_type);
1919 #if FF_API_ERROR_FRAME
1921 memcpy(
s->current_picture->error,
s->encoding_error,
sizeof(
s->encoding_error));
1926 if (
s->current_picture->key_frame)
1945 #define OFFSET(x) offsetof(SnowContext, x)
1946 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1953 {
"memc_only",
"Only do ME/MC (I frames -> ref, P frame -> ME+MC).",
OFFSET(memc_only),
AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1,
VE },
1954 {
"no_bitstream",
"Skip final bitstream writeout.",
OFFSET(no_bitstream),
AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1,
VE },
1955 {
"intra_penalty",
"Penalty for intra blocks in block decission",
OFFSET(intra_penalty),
AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX,
VE },
1956 {
"iterative_dia_size",
"Dia size for the iterative ME",
OFFSET(iterative_dia_size),
AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX,
VE },
1957 {
"sc_threshold",
"Scene change threshold",
OFFSET(scenechange_threshold),
AV_OPT_TYPE_INT, { .i64 = 0 }, INT_MIN, INT_MAX,
VE },
1961 {
"rc_eq",
"Set rate control equation. When computing the expression, besides the standard functions "
1962 "defined in the section 'Expression Evaluation', the following functions are available: "
1963 "bits2qp(bits), qp2bits(qp). Also the following constants are available: iTex pTex tex mv "
1964 "fCode iCount mcVar var isI isP isB avgQP qComp avgIITex avgPITex avgPPTex avgBPTex avgTex.",
static uint32_t inverse(uint32_t v)
find multiplicative inverse modulo 2 ^ 32
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Libavcodec external API header.
int ff_side_data_set_encoder_stats(AVPacket *pkt, int quality, int64_t *error, int error_count, int pict_type)
static av_cold int init(AVCodecContext *avctx)
#define AV_CEIL_RSHIFT(a, b)
#define ROUNDED_DIV(a, b)
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
int ff_alloc_packet2(AVCodecContext *avctx, AVPacket *avpkt, int64_t size, int64_t min_size)
Check AVPacket size and/or allocate data.
static av_noinline void put_symbol(RangeCoder *c, uint8_t *state, int v, int is_signed)
#define AV_CODEC_FLAG_QPEL
Use qpel MC.
#define AV_CODEC_FLAG_PASS2
Use internal 2pass ratecontrol in second pass mode.
#define AV_CODEC_FLAG_QSCALE
Use fixed qscale.
#define AV_CODEC_FLAG_PASS1
Use internal 2pass ratecontrol in first pass mode.
#define AV_CODEC_FLAG_PSNR
error[?] variables will be set during encoding.
#define AV_CODEC_FLAG_4MV
4 MV per MB allowed / advanced prediction for H.263.
#define AV_INPUT_BUFFER_MIN_SIZE
minimum encoding buffer size Used to avoid some checks during header writing.
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
#define FF_QP2LAMBDA
factor to convert from H.263 QP to lambda
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
int av_frame_ref(AVFrame *dst, const AVFrame *src)
Set up a new reference to the data described by the source frame.
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
int av_frame_make_writable(AVFrame *frame)
Ensure that the frame data is writable, avoiding data copy if possible.
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
const char * av_default_item_name(void *ptr)
Return the context name.
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
void * av_mallocz_array(size_t nmemb, size_t size)
Allocate a memory block for an array with av_mallocz().
@ AV_PICTURE_TYPE_I
Intra.
@ AV_PICTURE_TYPE_P
Predicted.
#define LIBAVUTIL_VERSION_INT
void ff_h263_encode_init(MpegEncContext *s)
static void pred_mv(DiracBlock *block, int stride, int x, int y, int ref)
#define FF_CODEC_CAP_INIT_THREADSAFE
The codec does not modify any global variables in the init function, allowing to call the init functi...
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
common internal API header
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
#define FF_DISABLE_DEPRECATION_WARNINGS
#define FF_ENABLE_DEPRECATION_WARNINGS
static enum AVPixelFormat pix_fmts[]
Replacements for frequently missing libm functions.
const uint32_t ff_square_tab[512]
void ff_set_cmp(MECmpContext *c, me_cmp_func *cmp, int type)
int ff_init_me(MpegEncContext *s)
static void init_ref(MotionEstContext *c, uint8_t *src[3], uint8_t *ref[3], uint8_t *ref2[3], int x, int y, int ref_index)
int ff_epzs_motion_search(struct MpegEncContext *s, int *mx_ptr, int *my_ptr, int P[10][2], int src_index, int ref_index, int16_t(*last_mv)[2], int ref_mv_scale, int size, int h)
int ff_get_mb_score(struct MpegEncContext *s, int mx, int my, int src_index, int ref_index, int size, int h, int add_rate)
av_cold void ff_mpegvideoencdsp_init(MpegvideoEncDSPContext *c, AVCodecContext *avctx)
int av_pix_fmt_get_chroma_sub_sample(enum AVPixelFormat pix_fmt, int *h_shift, int *v_shift)
Utility function to access log2_chroma_w log2_chroma_h from the pixel format AVPixFmtDescriptor.
AVPixelFormat
Pixel format.
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
@ AV_PIX_FMT_YUV410P
planar YUV 4:1:0, 9bpp, (1 Cr & Cb sample per 4x4 Y samples)
@ AV_PIX_FMT_YUV444P
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
int ff_rac_terminate(RangeCoder *c, int version)
Terminates the range coder.
void ff_build_rac_states(RangeCoder *c, int factor, int max_p)
av_cold void ff_init_range_encoder(RangeCoder *c, uint8_t *buf, int buf_size)
static int get_rac_count(RangeCoder *c)
av_cold int ff_rate_control_init(MpegEncContext *s)
av_cold void ff_rate_control_uninit(MpegEncContext *s)
float ff_rate_estimate_qscale(MpegEncContext *s, int dry_run)
void ff_write_pass1_stats(MpegEncContext *s)
static const float pred[4]
av_cold int ff_snow_common_init(AVCodecContext *avctx)
void ff_snow_pred_block(SnowContext *s, uint8_t *dst, uint8_t *tmp, ptrdiff_t stride, int sx, int sy, int b_w, int b_h, const BlockNode *block, int plane_index, int w, int h)
int ff_snow_get_buffer(SnowContext *s, AVFrame *frame)
void ff_snow_release_buffer(AVCodecContext *avctx)
void ff_snow_reset_contexts(SnowContext *s)
int ff_snow_common_init_after_header(AVCodecContext *avctx)
int ff_snow_frame_start(SnowContext *s)
av_cold void ff_snow_common_end(SnowContext *s)
int ff_snow_alloc_blocks(SnowContext *s)
#define BLOCK_OPT
Block needs no checks in this round of iterative motion estiation.
static av_always_inline void predict_plane(SnowContext *s, IDWTELEM *buf, int plane_index, int add)
static void set_blocks(SnowContext *s, int level, int x, int y, int l, int cb, int cr, int mx, int my, int ref, int type)
const uint8_t *const ff_obmc_tab[4]
static void put_symbol2(RangeCoder *c, uint8_t *state, int v, int log2)
#define ENCODER_EXTRA_BITS
#define BLOCK_INTRA
Intra block, inter otherwise.
static av_always_inline int same_block(BlockNode *a, BlockNode *b)
const int8_t ff_quant3bA[256]
static av_always_inline void add_yblock(SnowContext *s, int sliced, slice_buffer *sb, IDWTELEM *dst, uint8_t *dst8, const uint8_t *obmc, int src_x, int src_y, int b_w, int b_h, int w, int h, int dst_stride, int src_stride, int obmc_stride, int b_x, int b_y, int add, int offset_dst, int plane_index)
static const BlockNode null_block
void ff_spatial_idwt(IDWTELEM *buffer, IDWTELEM *temp, int width, int height, int stride, int type, int decomposition_count)
int ff_w53_32_c(struct MpegEncContext *v, uint8_t *pix1, uint8_t *pix2, ptrdiff_t line_size, int h)
void ff_spatial_dwt(DWTELEM *buffer, DWTELEM *temp, int width, int height, int stride, int type, int decomposition_count)
int ff_w97_32_c(struct MpegEncContext *v, uint8_t *pix1, uint8_t *pix2, ptrdiff_t line_size, int h)
static int get_4block_rd(SnowContext *s, int mb_x, int mb_y, int plane_index)
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)
static int qscale2qlog(int qscale)
static const AVClass snowenc_class
static int get_penalty_factor(int lambda, int lambda2, int type)
static const AVOption options[]
static int get_block_rd(SnowContext *s, int mb_x, int mb_y, int plane_index, uint8_t(*obmc_edged)[MB_SIZE *2])
static int encode_subband_c0run(SnowContext *s, SubBand *b, const IDWTELEM *src, const IDWTELEM *parent, int stride, int orientation)
static void encode_q_branch2(SnowContext *s, int level, int x, int y)
static void calculate_visual_weight(SnowContext *s, Plane *p)
static void correlate(SnowContext *s, SubBand *b, IDWTELEM *src, int stride, int inverse, int use_median)
static int get_block_bits(SnowContext *s, int x, int y, int w)
static av_cold int encode_init(AVCodecContext *avctx)
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)
static int pix_sum(uint8_t *pix, int line_size, int w, int h)
static int ratecontrol_1pass(SnowContext *s, AVFrame *pict)
static int get_dc(SnowContext *s, int mb_x, int mb_y, int plane_index)
static int encode_frame(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *pict, int *got_packet)
static void encode_qlogs(SnowContext *s)
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)
static int encode_q_branch(SnowContext *s, int level, int x, int y)
static void decorrelate(SnowContext *s, SubBand *b, IDWTELEM *src, int stride, int inverse, int use_median)
static av_cold int encode_end(AVCodecContext *avctx)
static void encode_header(SnowContext *s)
static void dequantize(SnowContext *s, SubBand *b, IDWTELEM *src, int stride)
static void quantize(SnowContext *s, SubBand *b, IDWTELEM *dst, DWTELEM *src, int stride, int bias)
static void iterative_me(SnowContext *s)
static void update_last_header_values(SnowContext *s)
static int pix_norm1(uint8_t *pix, int line_size, int w)
static void encode_blocks(SnowContext *s, int search)
static int encode_subband(SnowContext *s, SubBand *b, const IDWTELEM *src, const IDWTELEM *parent, int stride, int orientation)
static int shift(int a, int b)
Describe the class of an AVClass context structure.
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
main external API structure.
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
int width
picture width / height.
char * stats_out
pass1 encoding statistics output buffer
int global_quality
Global quality for codecs which cannot change it per frame.
attribute_deprecated int frame_bits
attribute_deprecated int mv_bits
int mb_lmax
maximum MB Lagrange multiplier
int dia_size
ME diamond size & shape.
attribute_deprecated AVFrame * coded_frame
the picture in the bitstream
attribute_deprecated int misc_bits
int64_t bit_rate
the average bitrate
int gop_size
the number of pictures in a group of pictures, or 0 for intra_only
int frame_number
Frame counter, set by libavcodec.
int refs
number of reference frames
int mb_lmin
minimum MB Lagrange multiplier
int flags
AV_CODEC_FLAG_*.
attribute_deprecated int prediction_method
attribute_deprecated int p_tex_bits
const char * name
Name of the codec implementation.
This structure describes decoded (raw) audio or video data.
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
int quality
quality (between 1 (good) and FF_LAMBDA_MAX (bad))
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
enum AVPictureType pict_type
Picture type of the frame.
This structure stores compressed data.
int flags
A combination of AV_PKT_FLAG values.
uint8_t ref
Reference frame index.
int16_t mx
Motion vector component X, see mv_scale.
uint8_t color[3]
Color for intra.
int16_t my
Motion vector component Y, see mv_scale.
uint8_t type
Bitfield of BLOCK_*.
Motion estimation context.
SubBand band[DWT_LEVELS_3D][4]
int8_t last_hcoeff[HTAPS_MAX/2]
int8_t hcoeff[HTAPS_MAX/2]
int qlog
log(qscale)/log[2^(1/6)]
static void error(const char *err)
static int ref[MAX_W *MAX_W]
enum AVPictureType last_picture
static float search(FOCContext *foc, int pass, int maxpass, int xmin, int xmax, int ymin, int ymax, int *best_x, int *best_y, float best_score)
static double cr(void *priv, double x, double y)
static double cb(void *priv, double x, double y)