60 uint8_t *dest_cr,
int mb_x,
int mb_y)
63 int dc, dcu, dcv,
y, i;
64 for (i = 0; i < 4; i++) {
65 dc = s->
dc_val[0][mb_x * 2 + (i & 1) + (mb_y * 2 + (i >> 1)) * s->
b8_stride];
70 for (y = 0; y < 8; y++) {
72 for (x = 0; x < 8; x++)
73 dest_y[x + (i & 1) * 8 + (y + (i >> 1) * 8) * linesize[0]] = dc / 8;
86 for (y = 0; y < 8; y++) {
88 for (x = 0; x < 8; x++) {
89 dest_cb[x + y * linesize[1]] = dcu / 8;
90 dest_cr[x + y * linesize[2]] = dcv / 8;
100 for (y = 1; y < height - 1; y++) {
101 int prev_dc = data[0 + y * stride];
103 for (x = 1; x < width - 1; x++) {
106 data[x + y * stride] * 8 -
107 data[x + 1 + y * stride];
108 dc = (dc * 10923 + 32768) >> 16;
109 prev_dc = data[x + y * stride];
110 data[x + y * stride] =
dc;
115 for (x = 1; x < width - 1; x++) {
116 int prev_dc = data[x];
118 for (y = 1; y < height - 1; y++) {
122 data[x + y * stride] * 8 -
123 data[x + (y + 1) * stride];
124 dc = (dc * 10923 + 32768) >> 16;
125 prev_dc = data[x + y * stride];
126 data[x + y * stride] =
dc;
137 int h,
int stride,
int is_luma)
148 for(b_y=0; b_y<h; b_y++){
151 for(b_x=0; b_x<w; b_x++){
152 int mb_index_j= (b_x>>is_luma) + (b_y>>is_luma)*s->
mb_stride;
156 color= dc[b_x + b_y*stride];
159 col [b_x + b_y*stride][1]=
color;
160 dist[b_x + b_y*stride][1]= distance >= 0 ? b_x-distance : 9999;
164 for(b_x=w-1; b_x>=0; b_x--){
165 int mb_index_j= (b_x>>is_luma) + (b_y>>is_luma)*s->
mb_stride;
169 color= dc[b_x + b_y*stride];
172 col [b_x + b_y*stride][0]=
color;
173 dist[b_x + b_y*stride][0]= distance >= 0 ? distance-b_x : 9999;
176 for(b_x=0; b_x<w; b_x++){
179 for(b_y=0; b_y<h; b_y++){
180 int mb_index_j= (b_x>>is_luma) + (b_y>>is_luma)*s->
mb_stride;
184 color= dc[b_x + b_y*stride];
187 col [b_x + b_y*stride][3]=
color;
188 dist[b_x + b_y*stride][3]= distance >= 0 ? b_y-distance : 9999;
192 for(b_y=h-1; b_y>=0; b_y--){
193 int mb_index_j= (b_x>>is_luma) + (b_y>>is_luma)*s->
mb_stride;
197 color= dc[b_x + b_y*stride];
200 col [b_x + b_y*stride][2]=
color;
201 dist[b_x + b_y*stride][2]= distance >= 0 ? distance-b_y : 9999;
205 for (b_y = 0; b_y < h; b_y++) {
206 for (b_x = 0; b_x < w; b_x++) {
207 int mb_index, error, j;
208 int64_t guess, weight_sum;
209 mb_index = (b_x >> is_luma) + (b_y >> is_luma) * s->
mb_stride;
219 for (j = 0; j < 4; j++) {
220 int64_t
weight = 256 * 256 * 256 * 16 /
FFMAX(dist[b_x + b_y*stride][j], 1);
221 guess += weight*(int64_t)col[b_x + b_y*stride][j];
224 guess = (guess + weight_sum / 2) / weight_sum;
225 dc[b_x + b_y * stride] = guess;
240 int h,
int stride,
int is_luma)
242 int b_x, b_y, mvx_stride, mvy_stride;
245 mvx_stride >>= is_luma;
246 mvy_stride *= mvx_stride;
248 for (b_y = 0; b_y < h; b_y++) {
249 for (b_x = 0; b_x < w - 1; b_x++) {
257 int offset = b_x * 8 + b_y * stride * 8;
258 int16_t *left_mv = s->
cur_pic.
motion_val[0][mvy_stride * b_y + mvx_stride * b_x];
259 int16_t *right_mv = s->
cur_pic.
motion_val[0][mvy_stride * b_y + mvx_stride * (b_x + 1)];
260 if (!(left_damage || right_damage))
262 if ((!left_intra) && (!right_intra) &&
263 FFABS(left_mv[0] - right_mv[0]) +
264 FFABS(left_mv[1] + right_mv[1]) < 2)
267 for (y = 0; y < 8; y++) {
270 a = dst[offset + 7 + y * stride] - dst[offset + 6 + y * stride];
271 b = dst[offset + 8 + y * stride] - dst[offset + 7 + y * stride];
272 c = dst[offset + 9 + y * stride] - dst[offset + 8 + y * stride];
282 if (!(left_damage && right_damage))
286 dst[offset + 7 + y * stride] = cm[dst[offset + 7 + y * stride] + ((d * 7) >> 4)];
287 dst[offset + 6 + y * stride] = cm[dst[offset + 6 + y * stride] + ((d * 5) >> 4)];
288 dst[offset + 5 + y * stride] = cm[dst[offset + 5 + y * stride] + ((d * 3) >> 4)];
289 dst[offset + 4 + y * stride] = cm[dst[offset + 4 + y * stride] + ((d * 1) >> 4)];
292 dst[offset + 8 + y * stride] = cm[dst[offset + 8 + y * stride] - ((d * 7) >> 4)];
293 dst[offset + 9 + y * stride] = cm[dst[offset + 9 + y * stride] - ((d * 5) >> 4)];
294 dst[offset + 10+ y * stride] = cm[dst[offset + 10 + y * stride] - ((d * 3) >> 4)];
295 dst[offset + 11+ y * stride] = cm[dst[offset + 11 + y * stride] - ((d * 1) >> 4)];
310 int b_x, b_y, mvx_stride, mvy_stride;
313 mvx_stride >>= is_luma;
314 mvy_stride *= mvx_stride;
316 for (b_y = 0; b_y < h - 1; b_y++) {
317 for (b_x = 0; b_x < w; b_x++) {
325 int offset = b_x * 8 + b_y * stride * 8;
328 int16_t *bottom_mv = s->
cur_pic.
motion_val[0][mvy_stride * (b_y + 1) + mvx_stride * b_x];
330 if (!(top_damage || bottom_damage))
333 if ((!top_intra) && (!bottom_intra) &&
334 FFABS(top_mv[0] - bottom_mv[0]) +
335 FFABS(top_mv[1] + bottom_mv[1]) < 2)
338 for (x = 0; x < 8; x++) {
341 a = dst[offset + x + 7 * stride] - dst[offset + x + 6 * stride];
342 b = dst[offset + x + 8 * stride] - dst[offset + x + 7 * stride];
343 c = dst[offset + x + 9 * stride] - dst[offset + x + 8 * stride];
353 if (!(top_damage && bottom_damage))
357 dst[offset + x + 7 * stride] = cm[dst[offset + x + 7 * stride] + ((d * 7) >> 4)];
358 dst[offset + x + 6 * stride] = cm[dst[offset + x + 6 * stride] + ((d * 5) >> 4)];
359 dst[offset + x + 5 * stride] = cm[dst[offset + x + 5 * stride] + ((d * 3) >> 4)];
360 dst[offset + x + 4 * stride] = cm[dst[offset + x + 4 * stride] + ((d * 1) >> 4)];
363 dst[offset + x + 8 * stride] = cm[dst[offset + x + 8 * stride] - ((d * 7) >> 4)];
364 dst[offset + x + 9 * stride] = cm[dst[offset + x + 9 * stride] - ((d * 5) >> 4)];
365 dst[offset + x + 10 * stride] = cm[dst[offset + x + 10 * stride] - ((d * 3) >> 4)];
366 dst[offset + x + 11 * stride] = cm[dst[offset + x + 11 * stride] - ((d * 1) >> 4)];
378 #define MV_UNCHANGED 1
382 int i,
depth, num_avail;
383 int mb_x, mb_y, mot_step, mot_stride;
393 for (i = 0; i < mb_width * mb_height; i++) {
409 const int mot_index= (mb_x + mb_y*mot_stride) * mot_step;
417 num_avail <= mb_width / 2) {
418 for (mb_y = 0; mb_y < mb_height; mb_y++) {
419 for (mb_x = 0; mb_x < s->
mb_width; mb_x++) {
420 const int mb_xy = mb_x + mb_y * s->
mb_stride;
437 for (depth = 0; ; depth++) {
438 int changed,
pass, none_left;
442 for (pass = 0; (changed || pass < 2) && pass < 10; pass++) {
447 for (mb_y = 0; mb_y < mb_height; mb_y++) {
448 for (mb_x = 0; mb_x < s->
mb_width; mb_x++) {
449 const int mb_xy = mb_x + mb_y * s->
mb_stride;
450 int mv_predictor[8][2] = { { 0 } };
454 int best_score = 256 * 256 * 256 * 64;
456 const int mot_index = (mb_x + mb_y * mot_stride) * mot_step;
457 int prev_x = 0, prev_y = 0, prev_ref = 0;
459 if ((mb_x ^ mb_y ^ pass) & 1)
468 if (mb_x > 0 && fixed[mb_xy - 1] ==
MV_FROZEN)
470 if (mb_x + 1 < mb_width && fixed[mb_xy + 1] ==
MV_FROZEN)
472 if (mb_y > 0 && fixed[mb_xy - mb_stride] ==
MV_FROZEN)
474 if (mb_y + 1 < mb_height && fixed[mb_xy + mb_stride] ==
MV_FROZEN)
480 if (mb_x > 0 && fixed[mb_xy - 1 ] ==
MV_CHANGED)
482 if (mb_x + 1 < mb_width && fixed[mb_xy + 1 ] ==
MV_CHANGED)
484 if (mb_y > 0 && fixed[mb_xy - mb_stride] ==
MV_CHANGED)
486 if (mb_y + 1 < mb_height && fixed[mb_xy + mb_stride] ==
MV_CHANGED)
488 if (j == 0 && pass > 1)
493 if (mb_x > 0 && fixed[mb_xy - 1]) {
494 mv_predictor[pred_count][0] =
496 mv_predictor[pred_count][1] =
502 if (mb_x + 1 < mb_width && fixed[mb_xy + 1]) {
503 mv_predictor[pred_count][0] =
505 mv_predictor[pred_count][1] =
511 if (mb_y > 0 && fixed[mb_xy - mb_stride]) {
512 mv_predictor[pred_count][0] =
514 mv_predictor[pred_count][1] =
520 if (mb_y + 1<mb_height && fixed[mb_xy + mb_stride]) {
521 mv_predictor[pred_count][0] =
523 mv_predictor[pred_count][1] =
532 if (pred_count > 1) {
533 int sum_x = 0, sum_y = 0, sum_r = 0;
534 int max_x, max_y, min_x, min_y, max_r, min_r;
536 for (j = 0; j < pred_count; j++) {
537 sum_x += mv_predictor[j][0];
538 sum_y += mv_predictor[j][1];
540 if (j && ref[j] != ref[j - 1])
541 goto skip_mean_and_median;
545 mv_predictor[pred_count][0] = sum_x / j;
546 mv_predictor[pred_count][1] = sum_y / j;
547 ref[pred_count] = sum_r / j;
550 if (pred_count >= 3) {
551 min_y = min_x = min_r = 99999;
552 max_y = max_x = max_r = -99999;
554 min_x = min_y = max_x = max_y = min_r = max_r = 0;
556 for (j = 0; j < pred_count; j++) {
557 max_x =
FFMAX(max_x, mv_predictor[j][0]);
558 max_y =
FFMAX(max_y, mv_predictor[j][1]);
559 max_r =
FFMAX(max_r, ref[j]);
560 min_x =
FFMIN(min_x, mv_predictor[j][0]);
561 min_y =
FFMIN(min_y, mv_predictor[j][1]);
562 min_r =
FFMIN(min_r, ref[j]);
564 mv_predictor[pred_count + 1][0] = sum_x - max_x - min_x;
565 mv_predictor[pred_count + 1][1] = sum_y - max_y - min_y;
566 ref[pred_count + 1] = sum_r - max_r - min_r;
568 if (pred_count == 4) {
569 mv_predictor[pred_count + 1][0] /= 2;
570 mv_predictor[pred_count + 1][1] /= 2;
571 ref[pred_count + 1] /= 2;
576 skip_mean_and_median:
580 if (!fixed[mb_xy] && 0) {
600 mv_predictor[pred_count][0] = prev_x;
601 mv_predictor[pred_count][1] = prev_y;
602 ref[pred_count] = prev_ref;
607 for (j = 0; j < pred_count; j++) {
611 mb_x * 16 + mb_y * 16 * linesize[0];
614 s->
mv[0][0][0] = mv_predictor[j][0];
616 s->
mv[0][0][1] = mv_predictor[j][1];
625 if (mb_x > 0 && fixed[mb_xy - 1]) {
627 for (k = 0; k < 16; k++)
628 score +=
FFABS(src[k * linesize[0] - 1] -
629 src[k * linesize[0]]);
631 if (mb_x + 1 < mb_width && fixed[mb_xy + 1]) {
633 for (k = 0; k < 16; k++)
634 score +=
FFABS(src[k * linesize[0] + 15] -
635 src[k * linesize[0] + 16]);
637 if (mb_y > 0 && fixed[mb_xy - mb_stride]) {
639 for (k = 0; k < 16; k++)
640 score +=
FFABS(src[k - linesize[0]] - src[k]);
642 if (mb_y + 1 < mb_height && fixed[mb_xy + mb_stride]) {
644 for (k = 0; k < 16; k++)
645 score +=
FFABS(src[k + linesize[0] * 15] -
646 src[k + linesize[0] * 16]);
649 if (score <= best_score) {
654 score_sum += best_score;
655 s->
mv[0][0][0] = mv_predictor[best_pred][0];
656 s->
mv[0][0][1] = mv_predictor[best_pred][1];
658 for (i = 0; i < mot_step; i++)
659 for (j = 0; j < mot_step; j++) {
668 if (s->
mv[0][0][0] != prev_x || s->
mv[0][0][1] != prev_y) {
680 for (i = 0; i < mb_width * mb_height; i++) {
690 int is_intra_likely, i, j, undamaged_count, skip_amount, mb_x, mb_y;
699 for (i = 0; i < s->
mb_num; i++) {
706 if (undamaged_count < 5)
715 skip_amount =
FFMAX(undamaged_count / 50, 1);
719 for (mb_y = 0; mb_y < s->
mb_height - 1; mb_y++) {
720 for (mb_x = 0; mb_x < s->
mb_width; mb_x++) {
722 const int mb_xy = mb_x + mb_y * s->
mb_stride;
730 if ((j % skip_amount) != 0)
736 mb_x * 16 + mb_y * 16 * linesize[0];
738 mb_x * 16 + mb_y * 16 * linesize[0];
745 is_intra_likely += s->
mecc.
sad[0](
NULL, last_mb_ptr, mb_ptr,
748 is_intra_likely -= s->
mecc.
sad[0](
NULL, last_mb_ptr,
749 last_mb_ptr + linesize[0] * 16,
760 return is_intra_likely > 0;
798 int endx,
int endy,
int status)
800 const int start_i = av_clip(startx + starty * s->
mb_width, 0, s->
mb_num - 1);
801 const int end_i = av_clip(endx + endy * s->
mb_width, 0, s->
mb_num);
809 if (start_i > end_i || start_xy > end_xy) {
811 "internal error, slice end before start\n");
839 (end_xy - start_xy) *
sizeof(
uint8_t));
842 for (i = start_xy; i < end_xy; i++)
869 int *linesize =
NULL;
870 int i, mb_x, mb_y, error, error_type, dc_error, mv_error, ac_error;
872 int threshold_part[4] = { 100, 100, 100 };
887 for (mb_x = 0; mb_x < s->
mb_width; mb_x++) {
922 for (i = 0; i < 2; i++) {
931 for (i = 0; i < 2; i++) {
942 for (mb_y = 0; mb_y < s->
mb_height; mb_y++) {
943 for (mb_x = 0; mb_x < s->
mb_width; mb_x++) {
954 for (error_type = 1; error_type <= 3; error_type++) {
957 for (i = s->
mb_num - 1; i >= 0; i--) {
961 if (error & (1 << error_type))
963 if (error & (8 << error_type))
979 for (i = s->
mb_num - 1; i >= 0; i--) {
1027 for (error_type = 1; error_type <= 3; error_type++) {
1028 for (i = s->
mb_num - 1; i >= 0; i--) {
1034 if (error & (1 << error_type))
1038 if (distance < threshold_part[error_type - 1])
1041 if (distance < threshold)
1053 for (i = 0; i < s->
mb_num; i++) {
1067 for (i = 0; i < s->
mb_num; i++) {
1077 dc_error = ac_error = mv_error = 0;
1078 for (i = 0; i < s->
mb_num; i++) {
1094 for (i = 0; i < s->
mb_num; i++) {
1100 if (is_intra_likely)
1109 for (i = 0; i < s->
mb_num; i++) {
1116 for (mb_y = 0; mb_y < s->
mb_height; mb_y++) {
1117 for (mb_x = 0; mb_x < s->
mb_width; mb_x++) {
1118 const int mb_xy = mb_x + mb_y * s->
mb_stride;
1134 int mb_index = mb_x * 2 + mb_y * 2 * s->
b8_stride;
1137 for (j = 0; j < 4; j++) {
1148 mv_dir, mv_type, &s->
mv, mb_x, mb_y, 0, 0);
1154 for (mb_y = 0; mb_y < s->
mb_height; mb_y++) {
1155 for (mb_x = 0; mb_x < s->
mb_width; mb_x++) {
1156 int xy = mb_x * 2 + mb_y * 2 * s->
b8_stride;
1157 const int mb_xy = mb_x + mb_y * s->
mb_stride;
1204 for (mb_y = 0; mb_y < s->
mb_height; mb_y++) {
1205 for (mb_x = 0; mb_x < s->
mb_width; mb_x++) {
1206 int dc, dcu, dcv,
y,
n;
1208 uint8_t *dest_y, *dest_cb, *dest_cr;
1209 const int mb_xy = mb_x + mb_y * s->
mb_stride;
1219 dest_y = s->
cur_pic.
f->
data[0] + mb_x * 16 + mb_y * 16 * linesize[0];
1220 dest_cb = s->
cur_pic.
f->
data[1] + mb_x * 8 + mb_y * 8 * linesize[1];
1221 dest_cr = s->
cur_pic.
f->
data[2] + mb_x * 8 + mb_y * 8 * linesize[2];
1224 for (n = 0; n < 4; n++) {
1226 for (y = 0; y < 8; y++) {
1228 for (x = 0; x < 8; x++)
1229 dc += dest_y[x + (n & 1) * 8 +
1230 (y + (n >> 1) * 8) * linesize[0]];
1232 dc_ptr[(n & 1) + (n >> 1) * s->
b8_stride] = (dc + 4) >> 3;
1236 for (y = 0; y < 8; y++) {
1238 for (x = 0; x < 8; x++) {
1239 dcu += dest_cb[x + y * linesize[1]];
1240 dcv += dest_cr[x + y * linesize[2]];
1259 for (mb_y = 0; mb_y < s->
mb_height; mb_y++) {
1260 for (mb_x = 0; mb_x < s->
mb_width; mb_x++) {
1261 uint8_t *dest_y, *dest_cb, *dest_cr;
1262 const int mb_xy = mb_x + mb_y * s->
mb_stride;
1272 dest_y = s->
cur_pic.
f->
data[0] + mb_x * 16 + mb_y * 16 * linesize[0];
1273 dest_cb = s->
cur_pic.
f->
data[1] + mb_x * 8 + mb_y * 8 * linesize[1];
1274 dest_cr = s->
cur_pic.
f->
data[2] + mb_x * 8 + mb_y * 8 * linesize[2];
1276 put_dc(s, dest_y, dest_cb, dest_cr, mb_x, mb_y);
1301 for (i = 0; i < s->
mb_num; i++) {
1312 for (i = 0; i < 2; i++) {