61 uint8_t *dest_cr,
int mb_x,
int mb_y)
63 int *linesize =
s->cur_pic.f->linesize;
64 int dc, dcu, dcv, y,
i;
65 for (
i = 0;
i < 4;
i++) {
66 dc =
s->dc_val[0][mb_x * 2 + (
i & 1) + (mb_y * 2 + (
i >> 1)) *
s->b8_stride];
71 for (y = 0; y < 8; y++) {
73 for (x = 0; x < 8; x++)
74 dest_y[x + (
i & 1) * 8 + (y + (
i >> 1) * 8) * linesize[0]] =
dc / 8;
77 dcu =
s->dc_val[1][mb_x + mb_y *
s->mb_stride];
78 dcv =
s->dc_val[2][mb_x + mb_y *
s->mb_stride];
89 for (y = 0; y < 8; y++) {
91 for (x = 0; x < 8; x++) {
92 dest_cb[x + y * linesize[1]] = dcu / 8;
93 dest_cr[x + y * linesize[2]] = dcv / 8;
103 for (y = 1; y <
height - 1; y++) {
106 for (x = 1; x <
width - 1; x++) {
111 dc = (
av_clip(
dc, INT_MIN/10923, INT_MAX/10923 - 32768) * 10923 + 32768) >> 16;
118 for (x = 1; x <
width - 1; x++) {
119 int prev_dc =
data[x];
121 for (y = 1; y <
height - 1; y++) {
127 dc = (
av_clip(
dc, INT_MIN/10923, INT_MAX/10923 - 32768) * 10923 + 32768) >> 16;
140 int h, ptrdiff_t
stride,
int is_luma)
151 for(b_y=0; b_y<
h; b_y++){
154 for(b_x=0; b_x<
w; b_x++){
155 int mb_index_j= (b_x>>is_luma) + (b_y>>is_luma)*
s->mb_stride;
156 int error_j=
s->error_status_table[mb_index_j];
157 int intra_j =
IS_INTRA(
s->cur_pic.mb_type[mb_index_j]);
167 for(b_x=
w-1; b_x>=0; b_x--){
168 int mb_index_j= (b_x>>is_luma) + (b_y>>is_luma)*
s->mb_stride;
169 int error_j=
s->error_status_table[mb_index_j];
170 int intra_j =
IS_INTRA(
s->cur_pic.mb_type[mb_index_j]);
179 for(b_x=0; b_x<
w; b_x++){
182 for(b_y=0; b_y<
h; b_y++){
183 int mb_index_j= (b_x>>is_luma) + (b_y>>is_luma)*
s->mb_stride;
184 int error_j=
s->error_status_table[mb_index_j];
185 int intra_j =
IS_INTRA(
s->cur_pic.mb_type[mb_index_j]);
195 for(b_y=
h-1; b_y>=0; b_y--){
196 int mb_index_j= (b_x>>is_luma) + (b_y>>is_luma)*
s->mb_stride;
197 int error_j=
s->error_status_table[mb_index_j];
198 int intra_j =
IS_INTRA(
s->cur_pic.mb_type[mb_index_j]);
208 for (b_y = 0; b_y <
h; b_y++) {
209 for (b_x = 0; b_x <
w; b_x++) {
210 int mb_index,
error, j;
212 mb_index = (b_x >> is_luma) + (b_y >> is_luma) *
s->mb_stride;
213 error =
s->error_status_table[mb_index];
215 if (
IS_INTER(
s->cur_pic.mb_type[mb_index]))
222 for (j = 0; j < 4; j++) {
227 guess = (guess + weight_sum / 2) / weight_sum;
243 int h, ptrdiff_t
stride,
int is_luma)
246 ptrdiff_t mvx_stride, mvy_stride;
249 mvx_stride >>= is_luma;
250 mvy_stride *= mvx_stride;
252 for (b_y = 0; b_y <
h; b_y++) {
253 for (b_x = 0; b_x <
w - 1; b_x++) {
255 int left_status =
s->error_status_table[( b_x >> is_luma) + (b_y >> is_luma) *
s->mb_stride];
256 int right_status =
s->error_status_table[((b_x + 1) >> is_luma) + (b_y >> is_luma) *
s->mb_stride];
257 int left_intra =
IS_INTRA(
s->cur_pic.mb_type[( b_x >> is_luma) + (b_y >> is_luma) *
s->mb_stride]);
258 int right_intra =
IS_INTRA(
s->cur_pic.mb_type[((b_x + 1) >> is_luma) + (b_y >> is_luma) *
s->mb_stride]);
262 int16_t *left_mv =
s->cur_pic.motion_val[0][mvy_stride * b_y + mvx_stride * b_x];
263 int16_t *right_mv =
s->cur_pic.motion_val[0][mvy_stride * b_y + mvx_stride * (b_x + 1)];
264 if (!(left_damage || right_damage))
266 if ((!left_intra) && (!right_intra) &&
267 FFABS(left_mv[0] - right_mv[0]) +
268 FFABS(left_mv[1] + right_mv[1]) < 2)
271 for (y = 0; y < 8; y++) {
286 if (!(left_damage && right_damage))
312 ptrdiff_t
stride,
int is_luma)
315 ptrdiff_t mvx_stride, mvy_stride;
318 mvx_stride >>= is_luma;
319 mvy_stride *= mvx_stride;
321 for (b_y = 0; b_y <
h - 1; b_y++) {
322 for (b_x = 0; b_x <
w; b_x++) {
324 int top_status =
s->error_status_table[(b_x >> is_luma) + (b_y >> is_luma) *
s->mb_stride];
325 int bottom_status =
s->error_status_table[(b_x >> is_luma) + ((b_y + 1) >> is_luma) *
s->mb_stride];
326 int top_intra =
IS_INTRA(
s->cur_pic.mb_type[(b_x >> is_luma) + ( b_y >> is_luma) *
s->mb_stride]);
327 int bottom_intra =
IS_INTRA(
s->cur_pic.mb_type[(b_x >> is_luma) + ((b_y + 1) >> is_luma) *
s->mb_stride]);
332 int16_t *top_mv =
s->cur_pic.motion_val[0][mvy_stride * b_y + mvx_stride * b_x];
333 int16_t *bottom_mv =
s->cur_pic.motion_val[0][mvy_stride * (b_y + 1) + mvx_stride * b_x];
335 if (!(top_damage || bottom_damage))
338 if ((!top_intra) && (!bottom_intra) &&
339 FFABS(top_mv[0] - bottom_mv[0]) +
340 FFABS(top_mv[1] + bottom_mv[1]) < 2)
343 for (x = 0; x < 8; x++) {
358 if (!(top_damage && bottom_damage))
380 #define MV_UNCHANGED 2
387 blocklist[ *blocklist_length ][0] = mb_x;
388 blocklist[(*blocklist_length)++][1] = mb_y;
393 int (*blocklist)[2], (*next_blocklist)[2];
395 const ptrdiff_t mb_stride =
s->mb_stride;
396 const int mb_width =
s->mb_width;
397 int mb_height =
s->mb_height;
400 ptrdiff_t mot_step, mot_stride;
401 int blocklist_length, next_blocklist_length;
403 if (
s->last_pic.f &&
s->last_pic.f->data[0])
404 mb_height =
FFMIN(mb_height, (
s->last_pic.f->height+15)>>4);
405 if (
s->next_pic.f &&
s->next_pic.f->data[0])
406 mb_height =
FFMIN(mb_height, (
s->next_pic.f->height+15)>>4);
408 blocklist = (int (*)[2])
s->er_temp_buffer;
409 next_blocklist = blocklist +
s->mb_stride *
s->mb_height;
410 fixed = (uint8_t *)(next_blocklist +
s->mb_stride *
s->mb_height);
415 if (
s->last_pic.motion_val[0]) {
421 for (
i = 0;
i < mb_width * mb_height;
i++) {
422 const int mb_xy =
s->mb_index2xy[
i];
424 int error =
s->error_status_table[mb_xy];
434 else if(
s->last_pic.f->data[0] &&
s->last_pic.motion_val[0]){
435 const int mb_y= mb_xy /
s->mb_stride;
436 const int mb_x= mb_xy %
s->mb_stride;
437 const int mot_index= (mb_x + mb_y*mot_stride) * mot_step;
438 s->cur_pic.motion_val[0][mot_index][0]=
s->last_pic.motion_val[0][mot_index][0];
439 s->cur_pic.motion_val[0][mot_index][1]=
s->last_pic.motion_val[0][mot_index][1];
440 s->cur_pic.ref_index[0][4*mb_xy] =
s->last_pic.ref_index[0][4*mb_xy];
445 num_avail <=
FFMAX(mb_width, mb_height) / 2) {
446 for (mb_y = 0; mb_y < mb_height; mb_y++) {
447 for (mb_x = 0; mb_x <
s->mb_width; mb_x++) {
448 const int mb_xy = mb_x + mb_y *
s->mb_stride;
465 blocklist_length = 0;
466 for (mb_y = 0; mb_y < mb_height; mb_y++) {
467 for (mb_x = 0; mb_x < mb_width; mb_x++) {
468 const int mb_xy = mb_x + mb_y * mb_stride;
470 if (mb_x)
add_blocklist(blocklist, &blocklist_length,
fixed, mb_x - 1, mb_y, mb_xy - 1);
471 if (mb_y)
add_blocklist(blocklist, &blocklist_length,
fixed, mb_x, mb_y - 1, mb_xy - mb_stride);
472 if (mb_x+1 < mb_width)
add_blocklist(blocklist, &blocklist_length,
fixed, mb_x + 1, mb_y, mb_xy + 1);
473 if (mb_y+1 < mb_height)
add_blocklist(blocklist, &blocklist_length,
fixed, mb_x, mb_y + 1, mb_xy + mb_stride);
479 int changed, pass, none_left;
484 for (pass = 0; (changed || pass < 2) && pass < 10; pass++) {
486 for (blocklist_index = 0; blocklist_index < blocklist_length; blocklist_index++) {
487 const int mb_x = blocklist[blocklist_index][0];
488 const int mb_y = blocklist[blocklist_index][1];
489 const int mb_xy = mb_x + mb_y * mb_stride;
490 int mv_predictor[8][2];
497 int prev_x, prev_y, prev_ref;
499 if ((mb_x ^ mb_y ^ pass) & 1)
509 j |=
fixed[mb_xy - 1];
510 if (mb_x + 1 < mb_width)
511 j |=
fixed[mb_xy + 1];
513 j |=
fixed[mb_xy - mb_stride];
514 if (mb_y + 1 < mb_height)
515 j |=
fixed[mb_xy + mb_stride];
524 mot_index = (mb_x + mb_y * mot_stride) * mot_step;
526 if (mb_x > 0 &&
fixed[mb_xy - 1] > 1) {
527 mv_predictor[pred_count][0] =
528 s->cur_pic.motion_val[0][mot_index - mot_step][0];
529 mv_predictor[pred_count][1] =
530 s->cur_pic.motion_val[0][mot_index - mot_step][1];
532 s->cur_pic.ref_index[0][4 * (mb_xy - 1)];
535 if (mb_x + 1 < mb_width &&
fixed[mb_xy + 1] > 1) {
536 mv_predictor[pred_count][0] =
537 s->cur_pic.motion_val[0][mot_index + mot_step][0];
538 mv_predictor[pred_count][1] =
539 s->cur_pic.motion_val[0][mot_index + mot_step][1];
541 s->cur_pic.ref_index[0][4 * (mb_xy + 1)];
544 if (mb_y > 0 &&
fixed[mb_xy - mb_stride] > 1) {
545 mv_predictor[pred_count][0] =
546 s->cur_pic.motion_val[0][mot_index - mot_stride * mot_step][0];
547 mv_predictor[pred_count][1] =
548 s->cur_pic.motion_val[0][mot_index - mot_stride * mot_step][1];
550 s->cur_pic.ref_index[0][4 * (mb_xy -
s->mb_stride)];
553 if (mb_y + 1<mb_height &&
fixed[mb_xy + mb_stride] > 1) {
554 mv_predictor[pred_count][0] =
555 s->cur_pic.motion_val[0][mot_index + mot_stride * mot_step][0];
556 mv_predictor[pred_count][1] =
557 s->cur_pic.motion_val[0][mot_index + mot_stride * mot_step][1];
559 s->cur_pic.ref_index[0][4 * (mb_xy +
s->mb_stride)];
565 if (pred_count > 1) {
566 int sum_x = 0, sum_y = 0, sum_r = 0;
567 int max_x, max_y, min_x, min_y, max_r, min_r;
569 for (j = 0; j < pred_count; j++) {
570 sum_x += mv_predictor[j][0];
571 sum_y += mv_predictor[j][1];
573 if (j &&
ref[j] !=
ref[j - 1])
574 goto skip_mean_and_median;
578 mv_predictor[pred_count][0] = sum_x / j;
579 mv_predictor[pred_count][1] = sum_y / j;
580 ref[pred_count] = sum_r / j;
583 if (pred_count >= 3) {
584 min_y = min_x = min_r = 99999;
585 max_y = max_x = max_r = -99999;
587 min_x = min_y = max_x = max_y = min_r = max_r = 0;
589 for (j = 0; j < pred_count; j++) {
590 max_x =
FFMAX(max_x, mv_predictor[j][0]);
591 max_y =
FFMAX(max_y, mv_predictor[j][1]);
593 min_x =
FFMIN(min_x, mv_predictor[j][0]);
594 min_y =
FFMIN(min_y, mv_predictor[j][1]);
597 mv_predictor[pred_count + 1][0] = sum_x - max_x - min_x;
598 mv_predictor[pred_count + 1][1] = sum_y - max_y - min_y;
599 ref[pred_count + 1] = sum_r - max_r - min_r;
601 if (pred_count == 4) {
602 mv_predictor[pred_count + 1][0] /= 2;
603 mv_predictor[pred_count + 1][1] /= 2;
604 ref[pred_count + 1] /= 2;
609 skip_mean_and_median:
611 mv_predictor[pred_count][0] =
612 mv_predictor[pred_count][1] =
616 prev_x =
s->cur_pic.motion_val[0][mot_index][0];
617 prev_y =
s->cur_pic.motion_val[0][mot_index][1];
618 prev_ref =
s->cur_pic.ref_index[0][4 * mb_xy];
621 mv_predictor[pred_count][0] = prev_x;
622 mv_predictor[pred_count][1] = prev_y;
623 ref[pred_count] = prev_ref;
627 best_score = 256 * 256 * 256 * 64;
628 for (j = 0; j < pred_count; j++) {
629 int *linesize =
s->cur_pic.f->linesize;
631 uint8_t *
src =
s->cur_pic.f->data[0] +
632 mb_x * 16 + mb_y * 16 * linesize[0];
634 s->cur_pic.motion_val[0][mot_index][0] =
635 s->mv[0][0][0] = mv_predictor[j][0];
636 s->cur_pic.motion_val[0][mot_index][1] =
637 s->mv[0][0][1] = mv_predictor[j][1];
646 if (mb_x > 0 &&
fixed[mb_xy - 1] > 1) {
648 for (k = 0; k < 16; k++)
649 score +=
FFABS(
src[k * linesize[0] - 1] -
650 src[k * linesize[0]]);
652 if (mb_x + 1 < mb_width &&
fixed[mb_xy + 1] > 1) {
654 for (k = 0; k < 16; k++)
655 score +=
FFABS(
src[k * linesize[0] + 15] -
656 src[k * linesize[0] + 16]);
658 if (mb_y > 0 &&
fixed[mb_xy - mb_stride] > 1) {
660 for (k = 0; k < 16; k++)
663 if (mb_y + 1 < mb_height &&
fixed[mb_xy + mb_stride] > 1) {
665 for (k = 0; k < 16; k++)
666 score +=
FFABS(
src[k + linesize[0] * 15] -
667 src[k + linesize[0] * 16]);
670 if (score <= best_score) {
675 s->mv[0][0][0] = mv_predictor[best_pred][0];
676 s->mv[0][0][1] = mv_predictor[best_pred][1];
678 for (
i = 0;
i < mot_step;
i++)
679 for (j = 0; j < mot_step; j++) {
680 s->cur_pic.motion_val[0][mot_index +
i + j * mot_stride][0] =
s->mv[0][0][0];
681 s->cur_pic.motion_val[0][mot_index +
i + j * mot_stride][1] =
s->mv[0][0][1];
688 if (
s->mv[0][0][0] != prev_x ||
s->mv[0][0][1] != prev_y) {
699 next_blocklist_length = 0;
701 for (blocklist_index = 0; blocklist_index < blocklist_length; blocklist_index++) {
702 const int mb_x = blocklist[blocklist_index][0];
703 const int mb_y = blocklist[blocklist_index][1];
704 const int mb_xy = mb_x + mb_y * mb_stride;
709 add_blocklist(next_blocklist, &next_blocklist_length,
fixed, mb_x - 1, mb_y, mb_xy - 1);
711 add_blocklist(next_blocklist, &next_blocklist_length,
fixed, mb_x, mb_y - 1, mb_xy - mb_stride);
712 if (mb_x + 1 < mb_width)
713 add_blocklist(next_blocklist, &next_blocklist_length,
fixed, mb_x + 1, mb_y, mb_xy + 1);
714 if (mb_y + 1 < mb_height)
715 add_blocklist(next_blocklist, &next_blocklist_length,
fixed, mb_x, mb_y + 1, mb_xy + mb_stride);
718 av_assert0(next_blocklist_length <= mb_height * mb_width);
719 FFSWAP(
int , blocklist_length, next_blocklist_length);
720 FFSWAP(
void*, blocklist, next_blocklist);
726 int is_intra_likely,
i, j, undamaged_count, skip_amount, mb_x, mb_y;
728 if (!
s->last_pic.f || !
s->last_pic.f->data[0])
735 for (
i = 0;
i <
s->mb_num;
i++) {
736 const int mb_xy =
s->mb_index2xy[
i];
737 const int error =
s->error_status_table[mb_xy];
742 if (undamaged_count < 5)
745 skip_amount =
FFMAX(undamaged_count / 50, 1);
749 for (mb_y = 0; mb_y <
s->mb_height - 1; mb_y++) {
750 for (mb_x = 0; mb_x <
s->mb_width; mb_x++) {
752 const int mb_xy = mb_x + mb_y *
s->mb_stride;
754 error =
s->error_status_table[mb_xy];
760 if ((j % skip_amount) != 0)
764 int *linesize =
s->cur_pic.f->linesize;
765 uint8_t *mb_ptr =
s->cur_pic.f->data[0] +
766 mb_x * 16 + mb_y * 16 * linesize[0];
767 uint8_t *last_mb_ptr =
s->last_pic.f->data[0] +
768 mb_x * 16 + mb_y * 16 * linesize[0];
775 is_intra_likely +=
s->sad(
NULL, last_mb_ptr, mb_ptr,
778 is_intra_likely -=
s->sad(
NULL, last_mb_ptr,
779 last_mb_ptr + linesize[0] * 16,
790 return is_intra_likely > 0;
795 if (!
s->avctx->error_concealment)
798 if (!
s->mecc_inited) {
801 s->sad = mecc.
sad[0];
806 s->mb_stride *
s->mb_height *
sizeof(uint8_t));
808 s->error_occurred = 0;
813 if (
s->avctx->hwaccel ||
815 s->cur_pic.field_picture
829 int endx,
int endy,
int status)
831 const int start_i =
av_clip(startx + starty *
s->mb_width, 0,
s->mb_num - 1);
832 const int end_i =
av_clip(endx + endy *
s->mb_width, 0,
s->mb_num);
833 const int start_xy =
s->mb_index2xy[start_i];
834 const int end_xy =
s->mb_index2xy[end_i];
837 if (
s->avctx->hwaccel)
840 if (start_i > end_i || start_xy > end_xy) {
842 "internal error, slice end before start\n");
846 if (!
s->avctx->error_concealment)
864 s->error_occurred = 1;
869 memset(&
s->error_status_table[start_xy], 0,
870 (end_xy - start_xy) *
sizeof(uint8_t));
873 for (
i = start_xy;
i < end_xy;
i++)
874 s->error_status_table[
i] &=
mask;
877 if (end_i ==
s->mb_num)
880 s->error_status_table[end_xy] &=
mask;
881 s->error_status_table[end_xy] |=
status;
884 s->error_status_table[start_xy] |=
VP_START;
888 int prev_status =
s->error_status_table[
s->mb_index2xy[start_i - 1]];
892 s->error_occurred = 1;
900 int *linesize =
NULL;
901 int i, mb_x, mb_y,
error, error_type, dc_error, mv_error, ac_error;
903 int threshold_part[4] = { 100, 100, 100 };
906 int size =
s->b8_stride * 2 *
s->mb_height;
911 if (!
s->avctx->error_concealment || !
atomic_load(&
s->error_count) ||
915 (
s->avctx->skip_top +
s->avctx->skip_bottom)) {
918 linesize =
s->cur_pic.f->linesize;
921 && (
FFALIGN(
s->avctx->height, 16)&16)
922 &&
atomic_load(&
s->error_count) == 3 *
s->mb_width * (
s->avctx->skip_top +
s->avctx->skip_bottom + 1)) {
923 for (mb_x = 0; mb_x <
s->mb_width; mb_x++) {
924 int status =
s->error_status_table[mb_x + (
s->mb_height - 1) *
s->mb_stride];
929 if (mb_x ==
s->mb_width) {
936 if (
s->last_pic.f->width !=
s->cur_pic.f->width ||
937 s->last_pic.f->height !=
s->cur_pic.f->height ||
938 s->last_pic.f->format !=
s->cur_pic.f->format) {
940 memset(&
s->last_pic, 0,
sizeof(
s->last_pic));
944 if (
s->next_pic.f->width !=
s->cur_pic.f->width ||
945 s->next_pic.f->height !=
s->cur_pic.f->height ||
946 s->next_pic.f->format !=
s->cur_pic.f->format) {
948 memset(&
s->next_pic, 0,
sizeof(
s->next_pic));
952 if (!
s->cur_pic.motion_val[0] || !
s->cur_pic.ref_index[0]) {
955 for (
i = 0;
i < 2;
i++) {
956 s->ref_index[
i] =
av_calloc(
s->mb_stride *
s->mb_height, 4 *
sizeof(uint8_t));
958 if (!
s->ref_index[
i] || !
s->motion_val_base[
i])
960 s->cur_pic.ref_index[
i] =
s->ref_index[
i];
961 s->cur_pic.motion_val[
i] =
s->motion_val_base[
i] + 4;
966 for (mb_y = 0; mb_y <
s->mb_height; mb_y++) {
967 for (mb_x = 0; mb_x <
s->mb_width; mb_x++) {
968 int status =
s->error_status_table[mb_x + mb_y *
s->mb_stride];
978 for (error_type = 1; error_type <= 3; error_type++) {
981 for (
i =
s->mb_num - 1;
i >= 0;
i--) {
982 const int mb_xy =
s->mb_index2xy[
i];
983 int error =
s->error_status_table[mb_xy];
985 if (
error & (1 << error_type))
987 if (
error & (8 << error_type))
991 s->error_status_table[mb_xy] |= 1 << error_type;
1000 if (
s->partitioned_frame) {
1003 for (
i =
s->mb_num - 1;
i >= 0;
i--) {
1004 const int mb_xy =
s->mb_index2xy[
i];
1005 int error =
s->error_status_table[mb_xy];
1027 for (
i =
s->mb_num - 2;
i >=
s->mb_width + 100;
i--) {
1028 const int mb_xy =
s->mb_index2xy[
i];
1029 int error1 =
s->error_status_table[mb_xy];
1030 int error2 =
s->error_status_table[
s->mb_index2xy[
i + 1]];
1051 for (error_type = 1; error_type <= 3; error_type++) {
1052 for (
i =
s->mb_num - 1;
i >= 0;
i--) {
1053 const int mb_xy =
s->mb_index2xy[
i];
1054 int error =
s->error_status_table[mb_xy];
1056 if (!
s->mbskip_table || !
s->mbskip_table[mb_xy])
1058 if (
error & (1 << error_type))
1061 if (
s->partitioned_frame) {
1062 if (
distance < threshold_part[error_type - 1])
1063 s->error_status_table[mb_xy] |= 1 << error_type;
1066 s->error_status_table[mb_xy] |= 1 << error_type;
1077 for (
i = 0;
i <
s->mb_num;
i++) {
1078 const int mb_xy =
s->mb_index2xy[
i];
1079 int old_error =
s->error_status_table[mb_xy];
1085 s->error_status_table[mb_xy] |=
error;
1090 if (!
s->partitioned_frame) {
1091 for (
i = 0;
i <
s->mb_num;
i++) {
1092 const int mb_xy =
s->mb_index2xy[
i];
1093 int error =
s->error_status_table[mb_xy];
1096 s->error_status_table[mb_xy] =
error;
1101 dc_error = ac_error = mv_error = 0;
1102 for (
i = 0;
i <
s->mb_num;
i++) {
1103 const int mb_xy =
s->mb_index2xy[
i];
1104 int error =
s->error_status_table[mb_xy];
1115 if (decode_error_flags)
1125 for (
i = 0;
i <
s->mb_num;
i++) {
1126 const int mb_xy =
s->mb_index2xy[
i];
1127 int error =
s->error_status_table[mb_xy];
1131 s->cur_pic.mb_type[mb_xy] = guessed_mb_type;
1135 if (!(
s->last_pic.f &&
s->last_pic.f->data[0]) &&
1136 !(
s->next_pic.f &&
s->next_pic.f->data[0]))
1137 for (
i = 0;
i <
s->mb_num;
i++) {
1138 const int mb_xy =
s->mb_index2xy[
i];
1139 if (!
IS_INTRA(
s->cur_pic.mb_type[mb_xy]))
1144 for (mb_y = 0; mb_y <
s->mb_height; mb_y++) {
1145 for (mb_x = 0; mb_x <
s->mb_width; mb_x++) {
1146 const int mb_xy = mb_x + mb_y *
s->mb_stride;
1147 const int mb_type =
s->cur_pic.mb_type[mb_xy];
1148 const int dir = !(
s->last_pic.f &&
s->last_pic.f->data[0]);
1152 int error =
s->error_status_table[mb_xy];
1162 int mb_index = mb_x * 2 + mb_y * 2 *
s->b8_stride;
1165 for (j = 0; j < 4; j++) {
1166 s->mv[0][j][0] =
s->cur_pic.motion_val[dir][mb_index + (j & 1) + (j >> 1) *
s->b8_stride][0];
1167 s->mv[0][j][1] =
s->cur_pic.motion_val[dir][mb_index + (j & 1) + (j >> 1) *
s->b8_stride][1];
1171 s->mv[0][0][0] =
s->cur_pic.motion_val[dir][mb_x * 2 + mb_y * 2 *
s->b8_stride][0];
1172 s->mv[0][0][1] =
s->cur_pic.motion_val[dir][mb_x * 2 + mb_y * 2 *
s->b8_stride][1];
1175 s->decode_mb(
s->opaque, 0 ,
1176 mv_dir, mv_type, &
s->mv, mb_x, mb_y, 0, 0);
1182 for (mb_y = 0; mb_y <
s->mb_height; mb_y++) {
1183 for (mb_x = 0; mb_x <
s->mb_width; mb_x++) {
1184 int xy = mb_x * 2 + mb_y * 2 *
s->b8_stride;
1185 const int mb_xy = mb_x + mb_y *
s->mb_stride;
1186 const int mb_type =
s->cur_pic.mb_type[mb_xy];
1189 int error =
s->error_status_table[mb_xy];
1198 if (!(
s->last_pic.f &&
s->last_pic.f->data[0]))
1200 if (!(
s->next_pic.f &&
s->next_pic.f->data[0]))
1204 int time_pp =
s->pp_time;
1205 int time_pb =
s->pb_time;
1210 s->mv[0][0][0] =
s->next_pic.motion_val[0][xy][0] * time_pb / time_pp;
1211 s->mv[0][0][1] =
s->next_pic.motion_val[0][xy][1] * time_pb / time_pp;
1212 s->mv[1][0][0] =
s->next_pic.motion_val[0][xy][0] * (time_pb - time_pp) / time_pp;
1213 s->mv[1][0][1] =
s->next_pic.motion_val[0][xy][1] * (time_pb - time_pp) / time_pp;
1229 for (mb_y = 0; mb_y <
s->mb_height; mb_y++) {
1230 for (mb_x = 0; mb_x <
s->mb_width; mb_x++) {
1231 int dc, dcu, dcv, y, n;
1233 uint8_t *dest_y, *dest_cb, *dest_cr;
1234 const int mb_xy = mb_x + mb_y *
s->mb_stride;
1235 const int mb_type =
s->cur_pic.mb_type[mb_xy];
1239 if (
IS_INTRA(mb_type) &&
s->partitioned_frame)
1244 dest_y =
s->cur_pic.f->data[0] + mb_x * 16 + mb_y * 16 * linesize[0];
1245 dest_cb =
s->cur_pic.f->data[1] + mb_x * 8 + mb_y * 8 * linesize[1];
1246 dest_cr =
s->cur_pic.f->data[2] + mb_x * 8 + mb_y * 8 * linesize[2];
1248 dc_ptr = &
s->dc_val[0][mb_x * 2 + mb_y * 2 *
s->b8_stride];
1249 for (n = 0; n < 4; n++) {
1251 for (y = 0; y < 8; y++) {
1253 for (x = 0; x < 8; x++)
1254 dc += dest_y[x + (n & 1) * 8 +
1255 (y + (n >> 1) * 8) * linesize[0]];
1257 dc_ptr[(n & 1) + (n >> 1) *
s->b8_stride] = (
dc + 4) >> 3;
1260 if (!
s->cur_pic.f->data[2])
1264 for (y = 0; y < 8; y++) {
1266 for (x = 0; x < 8; x++) {
1267 dcu += dest_cb[x + y * linesize[1]];
1268 dcv += dest_cr[x + y * linesize[2]];
1271 s->dc_val[1][mb_x + mb_y *
s->mb_stride] = (dcu + 4) >> 3;
1272 s->dc_val[2][mb_x + mb_y *
s->mb_stride] = (dcv + 4) >> 3;
1277 guess_dc(
s,
s->dc_val[0],
s->mb_width*2,
s->mb_height*2,
s->b8_stride, 1);
1278 guess_dc(
s,
s->dc_val[1],
s->mb_width ,
s->mb_height ,
s->mb_stride, 0);
1279 guess_dc(
s,
s->dc_val[2],
s->mb_width ,
s->mb_height ,
s->mb_stride, 0);
1283 filter181(
s->dc_val[0],
s->mb_width * 2,
s->mb_height * 2,
s->b8_stride);
1287 for (mb_y = 0; mb_y <
s->mb_height; mb_y++) {
1288 for (mb_x = 0; mb_x <
s->mb_width; mb_x++) {
1289 uint8_t *dest_y, *dest_cb, *dest_cr;
1290 const int mb_xy = mb_x + mb_y *
s->mb_stride;
1291 const int mb_type =
s->cur_pic.mb_type[mb_xy];
1293 int error =
s->error_status_table[mb_xy];
1300 dest_y =
s->cur_pic.f->data[0] + mb_x * 16 + mb_y * 16 * linesize[0];
1301 dest_cb =
s->cur_pic.f->data[1] + mb_x * 8 + mb_y * 8 * linesize[1];
1302 dest_cr =
s->cur_pic.f->data[2] + mb_x * 8 + mb_y * 8 * linesize[2];
1303 if (!
s->cur_pic.f->data[2])
1304 dest_cb = dest_cr =
NULL;
1306 put_dc(
s, dest_y, dest_cb, dest_cr, mb_x, mb_y);
1314 s->mb_height * 2, linesize[0], 1);
1318 s->mb_height * 2, linesize[0], 1);
1320 if (
s->cur_pic.f->data[2]) {
1322 s->mb_height, linesize[1], 0);
1324 s->mb_height, linesize[2], 0);
1326 s->mb_height, linesize[1], 0);
1328 s->mb_height, linesize[2], 0);
1333 for (
i = 0;
i <
s->mb_num;
i++) {
1334 const int mb_xy =
s->mb_index2xy[
i];
1335 int error =
s->error_status_table[mb_xy];
1339 s->mbskip_table[mb_xy] = 0;
1341 if (
s->mbintra_table)
1342 s->mbintra_table[mb_xy] = 1;
1350 for (
i = 0;
i < 2;
i++) {
1353 s->cur_pic.ref_index[
i] =
NULL;
1354 s->cur_pic.motion_val[
i] =
NULL;