30 #include "config_components.h"
53 int16_t *
block,
int n,
int qscale)
56 const uint16_t *quant_matrix;
58 nCoeffs=
s->block_last_index[n];
60 block[0] *= n < 4 ?
s->y_dc_scale :
s->c_dc_scale;
62 quant_matrix =
s->intra_matrix;
63 for(
i=1;
i<=nCoeffs;
i++) {
64 int j=
s->intra_scantable.permutated[
i];
82 int16_t *
block,
int n,
int qscale)
85 const uint16_t *quant_matrix;
87 nCoeffs=
s->block_last_index[n];
89 quant_matrix =
s->inter_matrix;
90 for(
i=0;
i<=nCoeffs;
i++) {
91 int j=
s->intra_scantable.permutated[
i];
97 ((
int) (quant_matrix[j]))) >> 4;
102 ((
int) (quant_matrix[j]))) >> 4;
111 int16_t *
block,
int n,
int qscale)
114 const uint16_t *quant_matrix;
119 if(
s->alternate_scan) nCoeffs= 63;
120 else nCoeffs=
s->block_last_index[n];
122 block[0] *= n < 4 ?
s->y_dc_scale :
s->c_dc_scale;
123 quant_matrix =
s->intra_matrix;
124 for(
i=1;
i<=nCoeffs;
i++) {
125 int j=
s->intra_scantable.permutated[
i];
141 int16_t *
block,
int n,
int qscale)
144 const uint16_t *quant_matrix;
150 if(
s->alternate_scan) nCoeffs= 63;
151 else nCoeffs=
s->block_last_index[n];
153 block[0] *= n < 4 ?
s->y_dc_scale :
s->c_dc_scale;
155 quant_matrix =
s->intra_matrix;
156 for(
i=1;
i<=nCoeffs;
i++) {
157 int j=
s->intra_scantable.permutated[
i];
175 int16_t *
block,
int n,
int qscale)
178 const uint16_t *quant_matrix;
184 if(
s->alternate_scan) nCoeffs= 63;
185 else nCoeffs=
s->block_last_index[n];
187 quant_matrix =
s->inter_matrix;
188 for(
i=0;
i<=nCoeffs;
i++) {
189 int j=
s->intra_scantable.permutated[
i];
195 ((
int) (quant_matrix[j]))) >> 5;
199 ((
int) (quant_matrix[j]))) >> 5;
209 int16_t *
block,
int n,
int qscale)
219 block[0] *= n < 4 ?
s->y_dc_scale :
s->c_dc_scale;
220 qadd = (qscale - 1) | 1;
227 nCoeffs=
s->intra_scantable.raster_end[
s->block_last_index[n] ];
229 for(
i=1;
i<=nCoeffs;
i++) {
243 int16_t *
block,
int n,
int qscale)
250 qadd = (qscale - 1) | 1;
253 nCoeffs=
s->inter_scantable.raster_end[
s->block_last_index[n] ];
255 for(
i=0;
i<=nCoeffs;
i++) {
292 for (
i=0;
i<4;
i++) {
293 s->hdsp.avg_pixels_tab[0][
i] =
gray16;
294 s->hdsp.put_pixels_tab[0][
i] =
gray16;
295 s->hdsp.put_no_rnd_pixels_tab[0][
i] =
gray16;
297 s->hdsp.avg_pixels_tab[1][
i] =
gray8;
298 s->hdsp.put_pixels_tab[1][
i] =
gray8;
299 s->hdsp.put_no_rnd_pixels_tab[1][
i] =
gray8;
312 if (HAVE_INTRINSICS_NEON)
332 s->idsp.mpeg4_studio_profile =
s->studio_profile;
338 if (
s->alternate_scan) {
351 int y_size =
s->b8_stride * (2 *
s->mb_height + 1);
352 int c_size =
s->mb_stride * (
s->mb_height + 1);
353 int yc_size = y_size + 2 * c_size;
356 if (
s->mb_height & 1)
357 yc_size += 2*
s->b8_stride + 2*
s->mb_stride;
364 if (
s->noise_reduction) {
371 s->block =
s->blocks[0];
373 for (
i = 0;
i < 12;
i++) {
374 s->pblocks[
i] = &
s->block[
i];
377 if (
s->avctx->codec_tag ==
AV_RL32(
"VCR2")) {
379 FFSWAP(
void *,
s->pblocks[4],
s->pblocks[5]);
386 s->ac_val[0] =
s->ac_val_base +
s->b8_stride + 1;
387 s->ac_val[1] =
s->ac_val_base + y_size +
s->mb_stride + 1;
388 s->ac_val[2] =
s->ac_val[1] + c_size;
396 int nb_slices =
s->slice_context_count,
ret;
401 for (
int i = 1;
i < nb_slices;
i++) {
403 if (!
s->thread_context[
i])
407 s->thread_context[
i]->start_mb_y =
408 (
s->mb_height * (
i ) + nb_slices / 2) / nb_slices;
409 s->thread_context[
i]->end_mb_y =
410 (
s->mb_height * (
i + 1) + nb_slices / 2) / nb_slices;
413 s->end_mb_y = nb_slices > 1 ? (
s->mb_height + nb_slices / 2) / nb_slices
426 s->sc.rd_scratchpad =
428 s->sc.obmc_scratchpad =
NULL;
440 for (
int i = 1;
i <
s->slice_context_count;
i++) {
449 #define COPY(a) bak->a = src->a
450 COPY(sc.edge_emu_buffer);
453 COPY(sc.rd_scratchpad);
454 COPY(sc.b_scratchpad);
455 COPY(sc.obmc_scratchpad);
482 for (
i = 0;
i < 12;
i++) {
493 "scratch buffers.\n");
507 s->y_dc_scale_table =
510 s->progressive_frame = 1;
511 s->progressive_sequence = 1;
514 s->coded_picture_number = 0;
515 s->picture_number = 0;
520 s->slice_context_count = 1;
525 int y_size, c_size, yc_size,
i, mb_array_size, mv_table_size, x, y;
527 s->mb_width = (
s->width + 15) / 16;
528 s->mb_stride =
s->mb_width + 1;
529 s->b8_stride =
s->mb_width * 2 + 1;
530 mb_array_size =
s->mb_height *
s->mb_stride;
531 mv_table_size = (
s->mb_height + 2) *
s->mb_stride + 1;
535 s->h_edge_pos =
s->mb_width * 16;
536 s->v_edge_pos =
s->mb_height * 16;
538 s->mb_num =
s->mb_width *
s->mb_height;
543 s->block_wrap[3] =
s->b8_stride;
545 s->block_wrap[5] =
s->mb_stride;
547 y_size =
s->b8_stride * (2 *
s->mb_height + 1);
548 c_size =
s->mb_stride * (
s->mb_height + 1);
549 yc_size = y_size + 2 * c_size;
551 if (
s->mb_height & 1)
552 yc_size += 2*
s->b8_stride + 2*
s->mb_stride;
556 for (y = 0; y <
s->mb_height; y++)
557 for (x = 0; x <
s->mb_width; x++)
558 s->mb_index2xy[x + y *
s->mb_width] = x + y *
s->mb_stride;
560 s->mb_index2xy[
s->mb_height *
s->mb_width] = (
s->mb_height - 1) *
s->mb_stride +
s->mb_width;
571 s->p_mv_table =
s->p_mv_table_base +
s->mb_stride + 1;
572 s->b_forw_mv_table =
s->b_forw_mv_table_base +
s->mb_stride + 1;
573 s->b_back_mv_table =
s->b_back_mv_table_base +
s->mb_stride + 1;
574 s->b_bidir_forw_mv_table =
s->b_bidir_forw_mv_table_base +
s->mb_stride + 1;
575 s->b_bidir_back_mv_table =
s->b_bidir_back_mv_table_base +
s->mb_stride + 1;
576 s->b_direct_mv_table =
s->b_direct_mv_table_base +
s->mb_stride + 1;
585 #define ALLOCZ_ARRAYS(p, mult, numb) ((p) = av_calloc(numb, mult * sizeof(*(p))))
590 if (!(tmp1 =
ALLOCZ_ARRAYS(
s->b_field_mv_table_base, 8, mv_table_size)) ||
591 !(tmp2 =
ALLOCZ_ARRAYS(
s->b_field_select_table[0][0], 2 * 4, mv_table_size)) ||
595 s->p_field_select_table[1] =
s->p_field_select_table[0] + 2 * mv_table_size;
596 tmp1 +=
s->mb_stride + 1;
598 for (
int i = 0;
i < 2;
i++) {
599 for (
int j = 0; j < 2; j++) {
600 for (
int k = 0; k < 2; k++) {
601 s->b_field_mv_table[
i][j][k] = tmp1;
602 tmp1 += mv_table_size;
604 s->b_field_select_table[
i][j] = tmp2;
605 tmp2 += 2 * mv_table_size;
617 tmp +=
s->mb_stride + 1;
618 for (
int i = 0;
i < 2;
i++) {
619 for (
int j = 0; j < 2; j++) {
620 s->p_field_mv_table[
i][j] =
tmp;
621 tmp += mv_table_size;
628 if (!(
s->coded_block_base =
av_mallocz(y_size + (
s->mb_height&1)*2*
s->b8_stride)) ||
632 s->coded_block =
s->coded_block_base +
s->b8_stride + 1;
635 if (
s->h263_pred ||
s->h263_plus || !
s->encoding) {
640 s->dc_val[0] =
s->dc_val_base +
s->b8_stride + 1;
641 s->dc_val[1] =
s->dc_val_base + y_size +
s->mb_stride + 1;
642 s->dc_val[2] =
s->dc_val[1] + c_size;
643 for (
i = 0;
i < yc_size;
i++)
644 s->dc_val_base[
i] = 1024;
648 if (!(
s->mbintra_table =
av_mallocz(mb_array_size)) ||
650 !(
s->mbskip_table =
av_mallocz(mb_array_size + 2)))
652 memset(
s->mbintra_table, 1, mb_array_size);
661 memset(&
s->next_picture, 0,
sizeof(
s->next_picture));
662 memset(&
s->last_picture, 0,
sizeof(
s->last_picture));
663 memset(&
s->current_picture, 0,
sizeof(
s->current_picture));
664 memset(&
s->new_picture, 0,
sizeof(
s->new_picture));
666 memset(
s->thread_context, 0,
sizeof(
s->thread_context));
669 s->me.score_map =
NULL;
670 s->dct_error_sum =
NULL;
673 memset(
s->pblocks, 0,
sizeof(
s->pblocks));
674 s->ac_val_base =
NULL;
678 s->sc.edge_emu_buffer =
NULL;
679 s->me.scratchpad =
NULL;
681 s->sc.rd_scratchpad =
683 s->sc.obmc_scratchpad =
NULL;
686 s->bitstream_buffer =
NULL;
687 s->allocated_bitstream_buffer_size = 0;
690 s->p_mv_table_base =
NULL;
691 s->b_forw_mv_table_base =
NULL;
692 s->b_back_mv_table_base =
NULL;
693 s->b_bidir_forw_mv_table_base =
NULL;
694 s->b_bidir_back_mv_table_base =
NULL;
695 s->b_direct_mv_table_base =
NULL;
696 s->p_mv_table =
NULL;
697 s->b_forw_mv_table =
NULL;
698 s->b_back_mv_table =
NULL;
699 s->b_bidir_forw_mv_table =
NULL;
700 s->b_bidir_back_mv_table =
NULL;
701 s->b_direct_mv_table =
NULL;
702 s->b_field_mv_table_base =
NULL;
703 s->p_field_mv_table_base =
NULL;
704 for (
i = 0;
i < 2;
i++) {
705 for (j = 0; j < 2; j++) {
706 for (k = 0; k < 2; k++) {
707 s->b_field_mv_table[
i][j][k] =
NULL;
709 s->b_field_select_table[
i][j] =
NULL;
710 s->p_field_mv_table[
i][j] =
NULL;
712 s->p_field_select_table[
i] =
NULL;
715 s->dc_val_base =
NULL;
716 s->coded_block_base =
NULL;
717 s->mbintra_table =
NULL;
719 s->pred_dir_table =
NULL;
721 s->mbskip_table =
NULL;
723 s->er.error_status_table =
NULL;
724 s->er.er_temp_buffer =
NULL;
725 s->mb_index2xy =
NULL;
726 s->lambda_table =
NULL;
739 int nb_slices = (HAVE_THREADS &&
741 s->avctx->thread_count : 1;
745 if (
s->encoding &&
s->avctx->slices)
746 nb_slices =
s->avctx->slices;
749 s->mb_height = (
s->height + 31) / 32 * 2;
751 s->mb_height = (
s->height + 15) / 16;
755 "decoding to AV_PIX_FMT_NONE is not supported.\n");
759 if (nb_slices >
MAX_THREADS || (nb_slices >
s->mb_height &&
s->mb_height)) {
766 " reducing to %d\n", nb_slices, max_slices);
767 nb_slices = max_slices;
770 if ((
s->width ||
s->height) &&
787 if (!
s->picture[
i].f)
800 #if FF_API_FLAG_TRUNCATED
801 s->parse_context.state = -1;
804 s->context_initialized = 1;
805 memset(
s->thread_context, 0,
sizeof(
s->thread_context));
806 s->thread_context[0] =
s;
807 s->slice_context_count = nb_slices;
833 av_freep(&
s->b_bidir_forw_mv_table_base);
834 av_freep(&
s->b_bidir_back_mv_table_base);
836 s->p_mv_table =
NULL;
837 s->b_forw_mv_table =
NULL;
838 s->b_back_mv_table =
NULL;
839 s->b_bidir_forw_mv_table =
NULL;
840 s->b_bidir_back_mv_table =
NULL;
841 s->b_direct_mv_table =
NULL;
843 av_freep(&
s->b_field_select_table[0][0]);
846 for (
i = 0;
i < 2;
i++) {
847 for (j = 0; j < 2; j++) {
848 for (k = 0; k < 2; k++) {
849 s->b_field_mv_table[
i][j][k] =
NULL;
851 s->b_field_select_table[
i][j] =
NULL;
852 s->p_field_mv_table[
i][j] =
NULL;
854 s->p_field_select_table[
i] =
NULL;
873 s->linesize =
s->uvlinesize = 0;
883 if (
s->slice_context_count > 1)
884 s->slice_context_count = 1;
886 #if FF_API_FLAG_TRUNCATED
888 s->parse_context.buffer_size = 0;
892 s->allocated_bitstream_buffer_size = 0;
907 s->context_initialized = 0;
908 s->context_reinit = 0;
909 s->last_picture_ptr =
910 s->next_picture_ptr =
911 s->current_picture_ptr =
NULL;
912 s->linesize =
s->uvlinesize = 0;
917 uint8_t *dest, uint8_t *
src,
918 int field_based,
int field_select,
919 int src_x,
int src_y,
921 int h_edge_pos,
int v_edge_pos,
923 int motion_x,
int motion_y)
925 const int lowres =
s->avctx->lowres;
927 const int s_mask = (2 <<
lowres) - 1;
931 if (
s->quarter_sample) {
936 sx = motion_x & s_mask;
937 sy = motion_y & s_mask;
938 src_x += motion_x >>
lowres + 1;
939 src_y += motion_y >>
lowres + 1;
943 if ((
unsigned)src_x >
FFMAX( h_edge_pos - (!!sx) -
w, 0) ||
944 (unsigned)src_y >
FFMAX((v_edge_pos >> field_based) - (!!sy) -
h, 0)) {
945 s->vdsp.emulated_edge_mc(
s->sc.edge_emu_buffer,
src,
946 s->linesize,
s->linesize,
947 w + 1, (
h + 1) << field_based,
948 src_x, src_y << field_based,
949 h_edge_pos, v_edge_pos);
950 src =
s->sc.edge_emu_buffer;
958 pix_op[op_index](dest,
src,
stride,
h, sx, sy);
970 uint8_t **ref_picture,
972 int motion_x,
int motion_y,
975 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
976 int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, sx, sy, uvsx, uvsy;
978 const int lowres =
s->avctx->lowres;
979 const int op_index =
FFMIN(
lowres-1+
s->chroma_x_shift, 3);
980 const int block_s = 8>>
lowres;
981 const int s_mask = (2 <<
lowres) - 1;
982 const int h_edge_pos =
s->h_edge_pos >>
lowres;
983 const int v_edge_pos =
s->v_edge_pos >>
lowres;
984 linesize =
s->current_picture.f->linesize[0] << field_based;
985 uvlinesize =
s->current_picture.f->linesize[1] << field_based;
988 if (
s->quarter_sample) {
994 motion_y += (bottom_field - field_select)*((1 <<
lowres)-1);
997 sx = motion_x & s_mask;
998 sy = motion_y & s_mask;
999 src_x =
s->mb_x * 2 * block_s + (motion_x >>
lowres + 1);
1000 src_y = (mb_y * 2 * block_s >> field_based) + (motion_y >>
lowres + 1);
1003 uvsx = ((motion_x >> 1) & s_mask) | (sx & 1);
1004 uvsy = ((motion_y >> 1) & s_mask) | (sy & 1);
1005 uvsrc_x = src_x >> 1;
1006 uvsrc_y = src_y >> 1;
1011 uvsx = (2 * mx) & s_mask;
1012 uvsy = (2 * my) & s_mask;
1013 uvsrc_x =
s->mb_x * block_s + (mx >>
lowres);
1014 uvsrc_y = mb_y * block_s + (my >>
lowres);
1016 if(
s->chroma_y_shift){
1021 uvsrc_x =
s->mb_x * block_s + (mx >>
lowres + 1);
1022 uvsrc_y = (mb_y * block_s >> field_based) + (my >>
lowres + 1);
1024 if(
s->chroma_x_shift){
1028 uvsy = motion_y & s_mask;
1030 uvsrc_x =
s->mb_x*block_s + (mx >> (
lowres+1));
1033 uvsx = motion_x & s_mask;
1034 uvsy = motion_y & s_mask;
1041 ptr_y = ref_picture[0] + src_y *
linesize + src_x;
1042 ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
1043 ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
1045 if ((
unsigned) src_x >
FFMAX( h_edge_pos - (!!sx) - 2 * block_s, 0) || uvsrc_y<0 ||
1046 (
unsigned) src_y >
FFMAX((v_edge_pos >> field_based) - (!!sy) -
h, 0)) {
1047 s->vdsp.emulated_edge_mc(
s->sc.edge_emu_buffer, ptr_y,
1049 17, 17 + field_based,
1050 src_x, src_y << field_based, h_edge_pos,
1052 ptr_y =
s->sc.edge_emu_buffer;
1054 uint8_t *ubuf =
s->sc.edge_emu_buffer + 18 *
s->linesize;
1055 uint8_t *vbuf =ubuf + 10 *
s->uvlinesize;
1057 vbuf -=
s->uvlinesize;
1058 s->vdsp.emulated_edge_mc(ubuf, ptr_cb,
1059 uvlinesize >> field_based, uvlinesize >> field_based,
1061 uvsrc_x, uvsrc_y << field_based,
1062 h_edge_pos >> 1, v_edge_pos >> 1);
1063 s->vdsp.emulated_edge_mc(vbuf, ptr_cr,
1064 uvlinesize >> field_based,uvlinesize >> field_based,
1066 uvsrc_x, uvsrc_y << field_based,
1067 h_edge_pos >> 1, v_edge_pos >> 1);
1075 dest_y +=
s->linesize;
1076 dest_cb +=
s->uvlinesize;
1077 dest_cr +=
s->uvlinesize;
1081 ptr_y +=
s->linesize;
1082 ptr_cb +=
s->uvlinesize;
1083 ptr_cr +=
s->uvlinesize;
1086 sx = (sx << 2) >>
lowres;
1087 sy = (sy << 2) >>
lowres;
1091 int hc =
s->chroma_y_shift ? (
h+1-bottom_field)>>1 :
h;
1092 uvsx = (uvsx << 2) >>
lowres;
1093 uvsy = (uvsy << 2) >>
lowres;
1095 pix_op[op_index](dest_cb, ptr_cb, uvlinesize, hc, uvsx, uvsy);
1096 pix_op[op_index](dest_cr, ptr_cr, uvlinesize, hc, uvsx, uvsy);
1103 uint8_t *dest_cb, uint8_t *dest_cr,
1104 uint8_t **ref_picture,
1108 const int lowres =
s->avctx->lowres;
1110 const int block_s = 8 >>
lowres;
1111 const int s_mask = (2 <<
lowres) - 1;
1112 const int h_edge_pos =
s->h_edge_pos >>
lowres + 1;
1113 const int v_edge_pos =
s->v_edge_pos >>
lowres + 1;
1114 int emu = 0, src_x, src_y, sx, sy;
1118 if (
s->quarter_sample) {
1130 src_x =
s->mb_x * block_s + (mx >>
lowres + 1);
1131 src_y =
s->mb_y * block_s + (my >>
lowres + 1);
1133 offset = src_y *
s->uvlinesize + src_x;
1134 ptr = ref_picture[1] +
offset;
1135 if ((
unsigned) src_x >
FFMAX(h_edge_pos - (!!sx) - block_s, 0) ||
1136 (unsigned) src_y >
FFMAX(v_edge_pos - (!!sy) - block_s, 0)) {
1137 s->vdsp.emulated_edge_mc(
s->sc.edge_emu_buffer, ptr,
1138 s->uvlinesize,
s->uvlinesize,
1140 src_x, src_y, h_edge_pos, v_edge_pos);
1141 ptr =
s->sc.edge_emu_buffer;
1144 sx = (sx << 2) >>
lowres;
1145 sy = (sy << 2) >>
lowres;
1146 pix_op[op_index](dest_cb, ptr,
s->uvlinesize, block_s, sx, sy);
1148 ptr = ref_picture[2] +
offset;
1150 s->vdsp.emulated_edge_mc(
s->sc.edge_emu_buffer, ptr,
1151 s->uvlinesize,
s->uvlinesize,
1153 src_x, src_y, h_edge_pos, v_edge_pos);
1154 ptr =
s->sc.edge_emu_buffer;
1156 pix_op[op_index](dest_cr, ptr,
s->uvlinesize, block_s, sx, sy);
1171 uint8_t *dest_y, uint8_t *dest_cb,
1173 int dir, uint8_t **ref_picture,
1178 const int lowres =
s->avctx->lowres;
1179 const int block_s = 8 >>
lowres;
1184 switch (
s->mv_type) {
1188 ref_picture, pix_op,
1189 s->mv[dir][0][0],
s->mv[dir][0][1],
1195 for (
i = 0;
i < 4;
i++) {
1197 s->linesize) * block_s,
1198 ref_picture[0], 0, 0,
1199 (2 * mb_x + (
i & 1)) * block_s,
1200 (2 * mb_y + (
i >> 1)) * block_s,
1201 s->width,
s->height,
s->linesize,
1203 block_s, block_s, pix_op,
1204 s->mv[dir][
i][0],
s->mv[dir][
i][1]);
1206 mx +=
s->mv[dir][
i][0];
1207 my +=
s->mv[dir][
i][1];
1218 1, 0,
s->field_select[dir][0],
1219 ref_picture, pix_op,
1220 s->mv[dir][0][0],
s->mv[dir][0][1],
1224 1, 1,
s->field_select[dir][1],
1225 ref_picture, pix_op,
1226 s->mv[dir][1][0],
s->mv[dir][1][1],
1229 if (
s->picture_structure !=
s->field_select[dir][0] + 1 &&
1231 ref_picture =
s->current_picture_ptr->f->data;
1235 0, 0,
s->field_select[dir][0],
1236 ref_picture, pix_op,
1238 s->mv[dir][0][1], 2 * block_s, mb_y >> 1);
1242 for (
i = 0;
i < 2;
i++) {
1243 uint8_t **ref2picture;
1245 if (
s->picture_structure ==
s->field_select[dir][
i] + 1 ||
1247 ref2picture = ref_picture;
1249 ref2picture =
s->current_picture_ptr->f->data;
1253 0, 0,
s->field_select[dir][
i],
1254 ref2picture, pix_op,
1255 s->mv[dir][
i][0],
s->mv[dir][
i][1] +
1256 2 * block_s *
i, block_s, mb_y >> 1);
1258 dest_y += 2 * block_s *
s->linesize;
1259 dest_cb += (2 * block_s >>
s->chroma_y_shift) *
s->uvlinesize;
1260 dest_cr += (2 * block_s >>
s->chroma_y_shift) *
s->uvlinesize;
1265 for (
i = 0;
i < 2;
i++) {
1267 for (j = 0; j < 2; j++) {
1270 ref_picture, pix_op,
1271 s->mv[dir][2 *
i + j][0],
1272 s->mv[dir][2 *
i + j][1],
1275 pix_op =
s->h264chroma.avg_h264_chroma_pixels_tab;
1278 for (
i = 0;
i < 2;
i++) {
1280 0, 0,
s->picture_structure !=
i + 1,
1281 ref_picture, pix_op,
1282 s->mv[dir][2 *
i][0],
s->mv[dir][2 *
i][1],
1283 2 * block_s, mb_y >> 1);
1286 pix_op =
s->h264chroma.avg_h264_chroma_pixels_tab;
1290 if (!
s->first_field) {
1291 ref_picture =
s->current_picture_ptr->f->data;
1306 int my_max = INT_MIN, my_min = INT_MAX, qpel_shift = !
s->quarter_sample;
1307 int my, off,
i, mvs;
1312 switch (
s->mv_type) {
1326 for (
i = 0;
i < mvs;
i++) {
1327 my =
s->mv[dir][
i][1];
1328 my_max =
FFMAX(my_max, my);
1329 my_min =
FFMIN(my_min, my);
1332 off = ((
FFMAX(-my_min, my_max)<<qpel_shift) + 63) >> 6;
1334 return av_clip(
s->mb_y + off, 0,
s->mb_height - 1);
1336 return s->mb_height-1;
1341 int16_t *
block,
int i, uint8_t *dest,
int line_size,
int qscale)
1343 s->dct_unquantize_intra(
s,
block,
i, qscale);
1344 s->idsp.idct_put(dest, line_size,
block);
1349 int16_t *
block,
int i, uint8_t *dest,
int line_size)
1351 if (
s->block_last_index[
i] >= 0) {
1352 s->idsp.idct_add(dest, line_size,
block);
1357 int16_t *
block,
int i, uint8_t *dest,
int line_size,
int qscale)
1359 if (
s->block_last_index[
i] >= 0) {
1360 s->dct_unquantize_inter(
s,
block,
i, qscale);
1362 s->idsp.idct_add(dest, line_size,
block);
1371 int wrap =
s->b8_stride;
1372 int xy =
s->block_index[0];
1375 s->dc_val[0][xy + 1 ] =
1376 s->dc_val[0][xy +
wrap] =
1377 s->dc_val[0][xy + 1 +
wrap] = 1024;
1379 memset(
s->ac_val[0][xy ], 0, 32 *
sizeof(int16_t));
1380 memset(
s->ac_val[0][xy +
wrap], 0, 32 *
sizeof(int16_t));
1381 if (
s->msmpeg4_version>=3) {
1382 s->coded_block[xy ] =
1383 s->coded_block[xy + 1 ] =
1384 s->coded_block[xy +
wrap] =
1385 s->coded_block[xy + 1 +
wrap] = 0;
1388 wrap =
s->mb_stride;
1389 xy =
s->mb_x +
s->mb_y *
wrap;
1391 s->dc_val[2][xy] = 1024;
1393 memset(
s->ac_val[1][xy], 0, 16 *
sizeof(int16_t));
1394 memset(
s->ac_val[2][xy], 0, 16 *
sizeof(int16_t));
1396 s->mbintra_table[xy]= 0;
1411 int lowres_flag,
int is_mpeg12)
1413 #define IS_ENCODER(s) (CONFIG_MPEGVIDEOENC && !lowres_flag && (s)->encoding)
1414 #define IS_MPEG12(s) (CONFIG_SMALL ? ((s)->out_format == FMT_MPEG1) : is_mpeg12)
1415 const int mb_xy =
s->mb_y *
s->mb_stride +
s->mb_x;
1417 s->current_picture.qscale_table[mb_xy] =
s->qscale;
1421 if (!is_mpeg12 && (
s->h263_pred ||
s->h263_aic)) {
1422 if(
s->mbintra_table[mb_xy])
1427 s->last_dc[2] = 128 <<
s->intra_dc_precision;
1430 else if (!is_mpeg12 && (
s->h263_pred ||
s->h263_aic))
1431 s->mbintra_table[mb_xy]=1;
1436 uint8_t *dest_y, *dest_cb, *dest_cr;
1437 int dct_linesize, dct_offset;
1440 const int linesize =
s->current_picture.f->linesize[0];
1441 const int uvlinesize =
s->current_picture.f->linesize[1];
1443 const int block_size= lowres_flag ? 8>>
s->avctx->lowres : 8;
1448 uint8_t *mbskip_ptr = &
s->mbskip_table[mb_xy];
1450 if (
s->mb_skipped) {
1454 }
else if(!
s->current_picture.reference) {
1461 dct_linesize =
linesize <<
s->interlaced_dct;
1466 dest_cb=
s->dest[1];
1467 dest_cr=
s->dest[2];
1469 dest_y =
s->sc.b_scratchpad;
1470 dest_cb=
s->sc.b_scratchpad+16*
linesize;
1471 dest_cr=
s->sc.b_scratchpad+32*
linesize;
1497 op_pix =
s->h264chroma.avg_h264_chroma_pixels_tab;
1503 op_qpix =
s->me.qpel_put;
1505 op_pix =
s->hdsp.put_pixels_tab;
1507 op_pix =
s->hdsp.put_no_rnd_pixels_tab;
1510 ff_mpv_motion(
s, dest_y, dest_cb, dest_cr, 0,
s->last_picture.f->data, op_pix, op_qpix);
1511 op_pix =
s->hdsp.avg_pixels_tab;
1512 op_qpix=
s->me.qpel_avg;
1515 ff_mpv_motion(
s, dest_y, dest_cb, dest_cr, 1,
s->next_picture.f->data, op_pix, op_qpix);
1521 if(
s->avctx->skip_idct){
1537 if (
s->chroma_y_shift){
1552 add_dct(
s,
block[2], 2, dest_y + dct_offset , dct_linesize);
1553 add_dct(
s,
block[3], 3, dest_y + dct_offset + block_size, dct_linesize);
1556 if(
s->chroma_y_shift){
1561 dct_linesize = uvlinesize <<
s->interlaced_dct;
1562 dct_offset =
s->interlaced_dct ? uvlinesize : uvlinesize*block_size;
1568 if(!
s->chroma_x_shift){
1571 add_dct(
s,
block[10], 10, dest_cb+block_size+dct_offset, dct_linesize);
1572 add_dct(
s,
block[11], 11, dest_cr+block_size+dct_offset, dct_linesize);
1576 }
else if (CONFIG_WMV2_DECODER) {
1582 if (!is_mpeg12 && CONFIG_MPEG4_DECODER &&
1583 s->avctx->bits_per_raw_sample > 8) {
1585 uvlinesize, dct_linesize, dct_offset);
1590 put_dct(
s,
block[1], 1, dest_y + block_size, dct_linesize,
s->qscale);
1591 put_dct(
s,
block[2], 2, dest_y + dct_offset , dct_linesize,
s->qscale);
1592 put_dct(
s,
block[3], 3, dest_y + dct_offset + block_size, dct_linesize,
s->qscale);
1595 if(
s->chroma_y_shift){
1601 put_dct(
s,
block[4], 4, dest_cb, dct_linesize,
s->chroma_qscale);
1602 put_dct(
s,
block[5], 5, dest_cr, dct_linesize,
s->chroma_qscale);
1603 put_dct(
s,
block[6], 6, dest_cb + dct_offset, dct_linesize,
s->chroma_qscale);
1604 put_dct(
s,
block[7], 7, dest_cr + dct_offset, dct_linesize,
s->chroma_qscale);
1608 s->idsp.idct_put(dest_y, dct_linesize,
block[0]);
1609 s->idsp.idct_put(dest_y + block_size, dct_linesize,
block[1]);
1610 s->idsp.idct_put(dest_y + dct_offset, dct_linesize,
block[2]);
1611 s->idsp.idct_put(dest_y + dct_offset + block_size, dct_linesize,
block[3]);
1614 if(
s->chroma_y_shift){
1615 s->idsp.idct_put(dest_cb, uvlinesize,
block[4]);
1616 s->idsp.idct_put(dest_cr, uvlinesize,
block[5]);
1619 dct_linesize = uvlinesize <<
s->interlaced_dct;
1620 dct_offset =
s->interlaced_dct ? uvlinesize : uvlinesize*block_size;
1622 s->idsp.idct_put(dest_cb, dct_linesize,
block[4]);
1623 s->idsp.idct_put(dest_cr, dct_linesize,
block[5]);
1624 s->idsp.idct_put(dest_cb + dct_offset, dct_linesize,
block[6]);
1625 s->idsp.idct_put(dest_cr + dct_offset, dct_linesize,
block[7]);
1626 if(!
s->chroma_x_shift){
1627 s->idsp.idct_put(dest_cb + block_size, dct_linesize,
block[8]);
1628 s->idsp.idct_put(dest_cr + block_size, dct_linesize,
block[9]);
1629 s->idsp.idct_put(dest_cb + block_size + dct_offset, dct_linesize,
block[10]);
1630 s->idsp.idct_put(dest_cr + block_size + dct_offset, dct_linesize,
block[11]);
1638 s->hdsp.put_pixels_tab[0][0](
s->dest[0], dest_y ,
linesize,16);
1640 s->hdsp.put_pixels_tab[
s->chroma_x_shift][0](
s->dest[1], dest_cb, uvlinesize,16 >>
s->chroma_y_shift);
1641 s->hdsp.put_pixels_tab[
s->chroma_x_shift][0](
s->dest[2], dest_cr, uvlinesize,16 >>
s->chroma_y_shift);
1652 for (
int i = 0;
i < 6;
i++) {
1653 for (
int j = 0; j < 64; j++) {
1655 block[
i][
s->idsp.idct_permutation[j]]);
1672 const int linesize =
s->current_picture.f->linesize[0];
1673 const int uvlinesize =
s->current_picture.f->linesize[1];
1674 const int width_of_mb = (4 + (
s->avctx->bits_per_raw_sample > 8)) -
s->avctx->lowres;
1675 const int height_of_mb = 4 -
s->avctx->lowres;
1677 s->block_index[0]=
s->b8_stride*(
s->mb_y*2 ) - 2 +
s->mb_x*2;
1678 s->block_index[1]=
s->b8_stride*(
s->mb_y*2 ) - 1 +
s->mb_x*2;
1679 s->block_index[2]=
s->b8_stride*(
s->mb_y*2 + 1) - 2 +
s->mb_x*2;
1680 s->block_index[3]=
s->b8_stride*(
s->mb_y*2 + 1) - 1 +
s->mb_x*2;
1681 s->block_index[4]=
s->mb_stride*(
s->mb_y + 1) +
s->b8_stride*
s->mb_height*2 +
s->mb_x - 1;
1682 s->block_index[5]=
s->mb_stride*(
s->mb_y +
s->mb_height + 2) +
s->b8_stride*
s->mb_height*2 +
s->mb_x - 1;
1685 s->dest[0] =
s->current_picture.f->data[0] + (
int)((
s->mb_x - 1
U) << width_of_mb);
1686 s->dest[1] =
s->current_picture.f->data[1] + (
int)((
s->mb_x - 1
U) << (width_of_mb -
s->chroma_x_shift));
1687 s->dest[2] =
s->current_picture.f->data[2] + (
int)((
s->mb_x - 1
U) << (width_of_mb -
s->chroma_x_shift));
1692 s->dest[0] +=
s->mb_y *
linesize << height_of_mb;
1693 s->dest[1] +=
s->mb_y * uvlinesize << (height_of_mb -
s->chroma_y_shift);
1694 s->dest[2] +=
s->mb_y * uvlinesize << (height_of_mb -
s->chroma_y_shift);
1696 s->dest[0] += (
s->mb_y>>1) *
linesize << height_of_mb;
1697 s->dest[1] += (
s->mb_y>>1) * uvlinesize << (height_of_mb -
s->chroma_y_shift);
1698 s->dest[2] += (
s->mb_y>>1) * uvlinesize << (height_of_mb -
s->chroma_y_shift);
1711 else if (qscale > 31)
1715 s->chroma_qscale=
s->chroma_qscale_table[qscale];
1717 s->y_dc_scale=
s->y_dc_scale_table[ qscale ];
1718 s->c_dc_scale=
s->c_dc_scale_table[
s->chroma_qscale ];