108 uint8_t *dest_cr,
int mb_x,
int mb_y)
110 int dc, dcu, dcv, y, i;
111 for (i = 0; i < 4; i++) {
112 dc = s->
dc_val[0][mb_x * 2 + (i & 1) + (mb_y * 2 + (i >> 1)) * s->
b8_stride];
117 for (y = 0; y < 8; y++) {
119 for (x = 0; x < 8; x++)
120 dest_y[x + (i & 1) * 8 + (y + (i >> 1) * 8) * s->
linesize] = dc / 8;
133 for (y = 0; y < 8; y++) {
135 for (x = 0; x < 8; x++) {
147 for (y = 1; y < height - 1; y++) {
148 int prev_dc = data[0 + y *
stride];
150 for (x = 1; x < width - 1; x++) {
153 data[x + y *
stride] * 8 -
155 dc = (dc * 10923 + 32768) >> 16;
156 prev_dc = data[x + y *
stride];
157 data[x + y *
stride] = dc;
162 for (x = 1; x < width - 1; x++) {
163 int prev_dc = data[x];
165 for (y = 1; y < height - 1; y++) {
169 data[x + y *
stride] * 8 -
170 data[x + (y + 1) * stride];
171 dc = (dc * 10923 + 32768) >> 16;
172 prev_dc = data[x + y *
stride];
173 data[x + y *
stride] = dc;
184 int h,
int stride,
int is_luma)
187 int16_t (*col )[4] =
av_malloc(stride*h*
sizeof( int16_t)*4);
188 uint32_t (*dist)[4] =
av_malloc(stride*h*
sizeof(uint32_t)*4);
195 for(b_y=0; b_y<h; b_y++){
198 for(b_x=0; b_x<w; b_x++){
199 int mb_index_j= (b_x>>is_luma) + (b_y>>is_luma)*s->
mb_stride;
203 color= dc[b_x + b_y*
stride];
207 dist[b_x + b_y*
stride][1]= distance >= 0 ? b_x-distance : 9999;
211 for(b_x=w-1; b_x>=0; b_x--){
212 int mb_index_j= (b_x>>is_luma) + (b_y>>is_luma)*s->
mb_stride;
216 color= dc[b_x + b_y*
stride];
220 dist[b_x + b_y*
stride][0]= distance >= 0 ? distance-b_x : 9999;
223 for(b_x=0; b_x<w; b_x++){
226 for(b_y=0; b_y<h; b_y++){
227 int mb_index_j= (b_x>>is_luma) + (b_y>>is_luma)*s->
mb_stride;
231 color= dc[b_x + b_y*
stride];
235 dist[b_x + b_y*
stride][3]= distance >= 0 ? b_y-distance : 9999;
239 for(b_y=h-1; b_y>=0; b_y--){
240 int mb_index_j= (b_x>>is_luma) + (b_y>>is_luma)*s->
mb_stride;
244 color= dc[b_x + b_y*
stride];
248 dist[b_x + b_y*
stride][2]= distance >= 0 ? distance-b_y : 9999;
252 for (b_y = 0; b_y < h; b_y++) {
253 for (b_x = 0; b_x < w; b_x++) {
254 int mb_index, error, j;
255 int64_t guess, weight_sum;
256 mb_index = (b_x >> is_luma) + (b_y >> is_luma) * s->
mb_stride;
266 for (j = 0; j < 4; j++) {
267 int64_t
weight = 256 * 256 * 256 * 16 /
FFMAX(dist[b_x + b_y*stride][j], 1);
268 guess += weight*(int64_t)col[b_x + b_y*stride][j];
271 guess = (guess + weight_sum / 2) / weight_sum;
272 dc[b_x + b_y *
stride] = guess;
287 int h,
int stride,
int is_luma)
289 int b_x, b_y, mvx_stride, mvy_stride;
292 mvx_stride >>= is_luma;
293 mvy_stride *= mvx_stride;
295 for (b_y = 0; b_y < h; b_y++) {
296 for (b_x = 0; b_x < w - 1; b_x++) {
304 int offset = b_x * 8 + b_y * stride * 8;
307 if (!(left_damage || right_damage))
309 if ((!left_intra) && (!right_intra) &&
310 FFABS(left_mv[0] - right_mv[0]) +
311 FFABS(left_mv[1] + right_mv[1]) < 2)
314 for (y = 0; y < 8; y++) {
317 a = dst[offset + 7 + y *
stride] - dst[offset + 6 + y *
stride];
318 b = dst[offset + 8 + y *
stride] - dst[offset + 7 + y *
stride];
319 c = dst[offset + 9 + y *
stride] - dst[offset + 8 + y *
stride];
329 if (!(left_damage && right_damage))
333 dst[offset + 7 + y *
stride] = cm[dst[offset + 7 + y *
stride] + ((d * 7) >> 4)];
334 dst[offset + 6 + y *
stride] = cm[dst[offset + 6 + y *
stride] + ((d * 5) >> 4)];
335 dst[offset + 5 + y *
stride] = cm[dst[offset + 5 + y *
stride] + ((d * 3) >> 4)];
336 dst[offset + 4 + y *
stride] = cm[dst[offset + 4 + y *
stride] + ((d * 1) >> 4)];
339 dst[offset + 8 + y *
stride] = cm[dst[offset + 8 + y *
stride] - ((d * 7) >> 4)];
340 dst[offset + 9 + y *
stride] = cm[dst[offset + 9 + y *
stride] - ((d * 5) >> 4)];
341 dst[offset + 10+ y *
stride] = cm[dst[offset + 10 + y *
stride] - ((d * 3) >> 4)];
342 dst[offset + 11+ y *
stride] = cm[dst[offset + 11 + y *
stride] - ((d * 1) >> 4)];
357 int b_x, b_y, mvx_stride, mvy_stride;
360 mvx_stride >>= is_luma;
361 mvy_stride *= mvx_stride;
363 for (b_y = 0; b_y < h - 1; b_y++) {
364 for (b_x = 0; b_x < w; b_x++) {
372 int offset = b_x * 8 + b_y * stride * 8;
377 if (!(top_damage || bottom_damage))
380 if ((!top_intra) && (!bottom_intra) &&
381 FFABS(top_mv[0] - bottom_mv[0]) +
382 FFABS(top_mv[1] + bottom_mv[1]) < 2)
385 for (x = 0; x < 8; x++) {
388 a = dst[offset + x + 7 *
stride] - dst[offset + x + 6 *
stride];
389 b = dst[offset + x + 8 *
stride] - dst[offset + x + 7 *
stride];
390 c = dst[offset + x + 9 *
stride] - dst[offset + x + 8 *
stride];
400 if (!(top_damage && bottom_damage))
404 dst[offset + x + 7 *
stride] = cm[dst[offset + x + 7 *
stride] + ((d * 7) >> 4)];
405 dst[offset + x + 6 *
stride] = cm[dst[offset + x + 6 *
stride] + ((d * 5) >> 4)];
406 dst[offset + x + 5 *
stride] = cm[dst[offset + x + 5 *
stride] + ((d * 3) >> 4)];
407 dst[offset + x + 4 *
stride] = cm[dst[offset + x + 4 *
stride] + ((d * 1) >> 4)];
410 dst[offset + x + 8 *
stride] = cm[dst[offset + x + 8 *
stride] - ((d * 7) >> 4)];
411 dst[offset + x + 9 *
stride] = cm[dst[offset + x + 9 *
stride] - ((d * 5) >> 4)];
412 dst[offset + x + 10 *
stride] = cm[dst[offset + x + 10 *
stride] - ((d * 3) >> 4)];
413 dst[offset + x + 11 *
stride] = cm[dst[offset + x + 11 *
stride] - ((d * 1) >> 4)];
425 #define MV_UNCHANGED 1
429 int i,
depth, num_avail;
430 int mb_x, mb_y, mot_step, mot_stride;
435 for (i = 0; i < s->
mb_num; i++) {
451 const int mot_index= (mb_x + mb_y*mot_stride) * mot_step;
459 num_avail <= mb_width / 2) {
460 for (mb_y = 0; mb_y < s->
mb_height; mb_y++) {
461 for (mb_x = 0; mb_x < s->
mb_width; mb_x++) {
462 const int mb_xy = mb_x + mb_y * s->
mb_stride;
487 for (depth = 0; ; depth++) {
488 int changed,
pass, none_left;
492 for (pass = 0; (changed || pass < 2) && pass < 10; pass++) {
497 for (mb_y = 0; mb_y < s->
mb_height; mb_y++) {
498 for (mb_x = 0; mb_x < s->
mb_width; mb_x++) {
499 const int mb_xy = mb_x + mb_y * s->
mb_stride;
500 int mv_predictor[8][2] = { { 0 } };
504 int best_score = 256 * 256 * 256 * 64;
506 const int mot_index = (mb_x + mb_y * mot_stride) * mot_step;
507 int prev_x, prev_y, prev_ref;
509 if ((mb_x ^ mb_y ^ pass) & 1)
518 if (mb_x > 0 && fixed[mb_xy - 1] ==
MV_FROZEN)
520 if (mb_x + 1 < mb_width && fixed[mb_xy + 1] ==
MV_FROZEN)
522 if (mb_y > 0 && fixed[mb_xy - mb_stride] ==
MV_FROZEN)
524 if (mb_y + 1 < mb_height && fixed[mb_xy + mb_stride] ==
MV_FROZEN)
530 if (mb_x > 0 && fixed[mb_xy - 1 ] ==
MV_CHANGED)
532 if (mb_x + 1 < mb_width && fixed[mb_xy + 1 ] ==
MV_CHANGED)
534 if (mb_y > 0 && fixed[mb_xy - mb_stride] ==
MV_CHANGED)
536 if (mb_y + 1 < mb_height && fixed[mb_xy + mb_stride] ==
MV_CHANGED)
538 if (j == 0 && pass > 1)
543 if (mb_x > 0 && fixed[mb_xy - 1]) {
544 mv_predictor[pred_count][0] =
546 mv_predictor[pred_count][1] =
552 if (mb_x + 1 < mb_width && fixed[mb_xy + 1]) {
553 mv_predictor[pred_count][0] =
555 mv_predictor[pred_count][1] =
561 if (mb_y > 0 && fixed[mb_xy - mb_stride]) {
562 mv_predictor[pred_count][0] =
564 mv_predictor[pred_count][1] =
570 if (mb_y + 1<mb_height && fixed[mb_xy + mb_stride]) {
571 mv_predictor[pred_count][0] =
573 mv_predictor[pred_count][1] =
582 if (pred_count > 1) {
583 int sum_x = 0, sum_y = 0, sum_r = 0;
584 int max_x, max_y, min_x, min_y, max_r, min_r;
586 for (j = 0; j < pred_count; j++) {
587 sum_x += mv_predictor[j][0];
588 sum_y += mv_predictor[j][1];
590 if (j && ref[j] != ref[j - 1])
591 goto skip_mean_and_median;
595 mv_predictor[pred_count][0] = sum_x / j;
596 mv_predictor[pred_count][1] = sum_y / j;
597 ref[pred_count] = sum_r / j;
600 if (pred_count >= 3) {
601 min_y = min_x = min_r = 99999;
602 max_y = max_x = max_r = -99999;
604 min_x = min_y = max_x = max_y = min_r = max_r = 0;
606 for (j = 0; j < pred_count; j++) {
607 max_x =
FFMAX(max_x, mv_predictor[j][0]);
608 max_y =
FFMAX(max_y, mv_predictor[j][1]);
609 max_r =
FFMAX(max_r, ref[j]);
610 min_x =
FFMIN(min_x, mv_predictor[j][0]);
611 min_y =
FFMIN(min_y, mv_predictor[j][1]);
612 min_r =
FFMIN(min_r, ref[j]);
614 mv_predictor[pred_count + 1][0] = sum_x - max_x - min_x;
615 mv_predictor[pred_count + 1][1] = sum_y - max_y - min_y;
616 ref[pred_count + 1] = sum_r - max_r - min_r;
618 if (pred_count == 4) {
619 mv_predictor[pred_count + 1][0] /= 2;
620 mv_predictor[pred_count + 1][1] /= 2;
621 ref[pred_count + 1] /= 2;
626 skip_mean_and_median:
630 if (!fixed[mb_xy] && 0) {
650 mv_predictor[pred_count][0] = prev_x;
651 mv_predictor[pred_count][1] = prev_y;
652 ref[pred_count] = prev_ref;
666 for (j = 0; j < pred_count; j++) {
669 mb_x * 16 + mb_y * 16 * s->
linesize;
672 s->
mv[0][0][0] = mv_predictor[j][0];
674 s->
mv[0][0][1] = mv_predictor[j][1];
682 if (mb_x > 0 && fixed[mb_xy - 1]) {
684 for (k = 0; k < 16; k++)
688 if (mb_x + 1 < mb_width && fixed[mb_xy + 1]) {
690 for (k = 0; k < 16; k++)
694 if (mb_y > 0 && fixed[mb_xy - mb_stride]) {
696 for (k = 0; k < 16; k++)
699 if (mb_y + 1 < mb_height && fixed[mb_xy + mb_stride]) {
701 for (k = 0; k < 16; k++)
706 if (score <= best_score) {
711 score_sum += best_score;
712 s->
mv[0][0][0] = mv_predictor[best_pred][0];
713 s->
mv[0][0][1] = mv_predictor[best_pred][1];
715 for (i = 0; i < mot_step; i++)
716 for (j = 0; j < mot_step; j++) {
724 if (s->
mv[0][0][0] != prev_x || s->
mv[0][0][1] != prev_y) {
736 for (i = 0; i < s->
mb_num; i++) {
746 int is_intra_likely, i, j, undamaged_count, skip_amount, mb_x, mb_y;
752 for (i = 0; i < s->
mb_num; i++) {
766 if (undamaged_count < 5)
770 if (CONFIG_MPEG_XVMC_DECODER &&
775 skip_amount =
FFMAX(undamaged_count / 50, 1);
779 for (mb_y = 0; mb_y < s->
mb_height - 1; mb_y++) {
780 for (mb_x = 0; mb_x < s->
mb_width; mb_x++) {
782 const int mb_xy = mb_x + mb_y * s->
mb_stride;
790 if ((j % skip_amount) != 0)
795 mb_x * 16 + mb_y * 16 * s->
linesize;
797 mb_x * 16 + mb_y * 16 * s->
linesize;
817 return is_intra_likely > 0;
839 int endx,
int endy,
int status)
841 const int start_i = av_clip(startx + starty * s->
mb_width, 0, s->
mb_num - 1);
842 const int end_i = av_clip(endx + endy * s->
mb_width, 0, s->
mb_num);
850 if (start_i > end_i || start_xy > end_xy) {
852 "internal error, slice end before start\n");
880 (end_xy - start_xy) *
sizeof(
uint8_t));
883 for (i = start_xy; i < end_xy; i++)
908 int i, mb_x, mb_y, error, error_type, dc_error, mv_error, ac_error;
910 int threshold_part[4] = { 100, 100, 100 };
936 for (i = 0; i < 2; i++) {
946 for (mb_y = 0; mb_y < s->
mb_height; mb_y++) {
947 for (mb_x = 0; mb_x < s->
mb_width; mb_x++) {
958 for (error_type = 1; error_type <= 3; error_type++) {
961 for (i = s->
mb_num - 1; i >= 0; i--) {
965 if (error & (1 << error_type))
967 if (error & (8 << error_type))
983 for (i = s->
mb_num - 1; i >= 0; i--) {
1031 for (error_type = 1; error_type <= 3; error_type++) {
1032 for (i = s->
mb_num - 1; i >= 0; i--) {
1038 if (error & (1 << error_type))
1042 if (distance < threshold_part[error_type - 1])
1045 if (distance < threshold)
1057 for (i = 0; i < s->
mb_num; i++) {
1071 for (i = 0; i < s->
mb_num; i++) {
1081 dc_error = ac_error = mv_error = 0;
1082 for (i = 0; i < s->
mb_num; i++) {
1098 for (i = 0; i < s->
mb_num; i++) {
1104 if (is_intra_likely)
1112 for (i = 0; i < s->
mb_num; i++) {
1119 for (mb_y = 0; mb_y < s->
mb_height; mb_y++) {
1120 for (mb_x = 0; mb_x < s->
mb_width; mb_x++) {
1121 const int mb_xy = mb_x + mb_y * s->
mb_stride;
1138 int mb_index = mb_x * 2 + mb_y * 2 * s->
b8_stride;
1141 for (j = 0; j < 4; j++) {
1161 for (mb_y = 0; mb_y < s->
mb_height; mb_y++) {
1162 for (mb_x = 0; mb_x < s->
mb_width; mb_x++) {
1163 int xy = mb_x * 2 + mb_y * 2 * s->
b8_stride;
1164 const int mb_xy = mb_x + mb_y * s->
mb_stride;
1218 for (mb_y = 0; mb_y < s->
mb_height; mb_y++) {
1219 for (mb_x = 0; mb_x < s->
mb_width; mb_x++) {
1220 int dc, dcu, dcv, y, n;
1222 uint8_t *dest_y, *dest_cb, *dest_cr;
1223 const int mb_xy = mb_x + mb_y * s->
mb_stride;
1238 for (n = 0; n < 4; n++) {
1240 for (y = 0; y < 8; y++) {
1242 for (x = 0; x < 8; x++)
1243 dc += dest_y[x + (n & 1) * 8 +
1246 dc_ptr[(n & 1) + (n >> 1) * s->
b8_stride] = (dc + 4) >> 3;
1250 for (y = 0; y < 8; y++) {
1252 for (x = 0; x < 8; x++) {
1273 for (mb_y = 0; mb_y < s->
mb_height; mb_y++) {
1274 for (mb_x = 0; mb_x < s->
mb_width; mb_x++) {
1275 uint8_t *dest_y, *dest_cb, *dest_cr;
1276 const int mb_xy = mb_x + mb_y * s->
mb_stride;
1290 put_dc(s, dest_y, dest_cb, dest_cr, mb_x, mb_y);
1315 for (i = 0; i < s->
mb_num; i++) {