25 #include "config_components.h"
90 if (
s->height != s1->
height ||
s->width != s1->
width ||
s->context_reinit) {
138 if (!
s->context_initialized)
147 if ((
s->width ||
s->height) &&
161 memset(
s->thread_context, 0,
sizeof(
s->thread_context));
162 s->thread_context[0] =
s;
164 if (
s->width &&
s->height) {
169 s->context_reinit = 0;
174 s->context_reinit = 1;
215 av_assert1(
s->mb_width ==
s->buffer_pools.alloc_mb_width);
216 av_assert1(
s->mb_height ==
s->buffer_pools.alloc_mb_height ||
217 FFALIGN(
s->mb_height, 2) ==
s->buffer_pools.alloc_mb_height);
218 av_assert1(
s->mb_stride ==
s->buffer_pools.alloc_mb_stride);
220 &
s->buffer_pools,
s->mb_height);
247 int h_chroma_shift, v_chroma_shift;
249 for (
int i = 0;
i <
frame->height;
i++)
268 av_assert1(!
s->last_pic.ptr ||
s->last_pic.ptr->f->buf[0]);
269 av_assert1(!
s->next_pic.ptr ||
s->next_pic.ptr->f->buf[0]);
273 "allocating dummy last picture for B frame\n");
277 "warning: first frame is no keyframe\n");
297 s->last_pic.ptr->f->buf[0]));
325 (!
s->progressive_frame && !
s->progressive_sequence);
326 s->cur_pic.ptr->field_picture =
s->picture_structure !=
PICT_FRAME;
328 s->cur_pic.ptr->f->pict_type =
s->pict_type;
339 ff_dlog(
s->avctx,
"L%p N%p C%p L%p N%p C%p type:%d drop:%d\n",
340 (
void*)
s->last_pic.ptr, (
void*)
s->next_pic.ptr, (
void*)
s->cur_pic.ptr,
341 s->last_pic.ptr ?
s->last_pic.ptr->f->data[0] :
NULL,
342 s->next_pic.ptr ?
s->next_pic.ptr->f->data[0] :
NULL,
343 s->cur_pic.ptr ?
s->cur_pic.ptr->f->data[0] :
NULL,
344 s->pict_type,
s->droppable);
361 if (
s->cur_pic.reference)
386 for (
unsigned y = 0; y < p->
mb_height; y++)
387 for (
unsigned x = 0; x < p->
mb_width; x++) {
388 const unsigned int block_idx = y * p->
mb_width + x;
389 const unsigned int mb_xy = y * p->
mb_stride + x;
406 s->last_pic.ptr ?
s->last_pic.ptr->f :
NULL,
407 y,
h,
s->picture_structure,
408 s->first_field,
s->low_delay);
419 s->mb_x =
s->mb_y = 0;
425 uint8_t *
dest,
const uint8_t *
src,
427 int src_x,
int src_y,
431 int motion_x,
int motion_y)
433 const int lowres =
s->avctx->lowres;
434 const int op_index =
lowres;
435 const int s_mask = (2 <<
lowres) - 1;
441 if (
s->quarter_sample) {
446 sx = motion_x & s_mask;
447 sy = motion_y & s_mask;
448 src_x += motion_x >>
lowres + 1;
449 src_y += motion_y >>
lowres + 1;
455 s->vdsp.emulated_edge_mc(
s->sc.edge_emu_buffer,
src,
456 s->linesize,
s->linesize,
457 w + 1, (
h + 1) << field_based,
458 src_x, src_y * (1 << field_based),
460 src =
s->sc.edge_emu_buffer;
480 uint8_t *
const *ref_picture,
482 int motion_x,
int motion_y,
485 const uint8_t *ptr_y, *ptr_cb, *ptr_cr;
486 int mx,
my, src_x, src_y, uvsrc_x, uvsrc_y, sx, sy, uvsx, uvsy;
488 const int lowres =
s->avctx->lowres;
489 const int op_index =
lowres - 1 +
s->chroma_x_shift;
490 const int block_s = 8 >>
lowres;
491 const int s_mask = (2 <<
lowres) - 1;
494 int hc =
s->chroma_y_shift ? (
h+1-bottom_field)>>1 :
h;
498 linesize =
s->cur_pic.linesize[0] << field_based;
499 uvlinesize =
s->cur_pic.linesize[1] << field_based;
502 if (
s->quarter_sample) {
511 sx = motion_x & s_mask;
512 sy = motion_y & s_mask;
513 src_x =
s->mb_x * 2 * block_s + (motion_x >>
lowres + 1);
514 src_y = (
mb_y * 2 * block_s >> field_based) + (motion_y >>
lowres + 1);
517 uvsx = ((motion_x >> 1) & s_mask) | (sx & 1);
518 uvsy = ((motion_y >> 1) & s_mask) | (sy & 1);
519 uvsrc_x = src_x >> 1;
520 uvsrc_y = src_y >> 1;
525 uvsx = (2 *
mx) & s_mask;
526 uvsy = (2 *
my) & s_mask;
527 uvsrc_x =
s->mb_x * block_s + (
mx >>
lowres);
530 if (
s->chroma_y_shift) {
535 uvsrc_x =
s->mb_x * block_s + (
mx >>
lowres + 1);
536 uvsrc_y = (
mb_y * block_s >> field_based) + (
my >>
lowres + 1);
538 if (
s->chroma_x_shift) {
542 uvsy = motion_y & s_mask;
544 uvsrc_x =
s->mb_x*block_s + (
mx >> (
lowres+1));
547 uvsx = motion_x & s_mask;
548 uvsy = motion_y & s_mask;
555 ptr_y = ref_picture[0] + src_y *
linesize + src_x;
556 ptr_cb = ref_picture[1] + uvsrc_y *
uvlinesize + uvsrc_x;
557 ptr_cr = ref_picture[2] + uvsrc_y *
uvlinesize + uvsrc_x;
559 if ((
unsigned) src_x >
FFMAX(
h_edge_pos - (!!sx) - 2 * block_s, 0) || uvsrc_y<0 ||
561 s->vdsp.emulated_edge_mc(
s->sc.edge_emu_buffer, ptr_y,
563 17, 17 + field_based,
564 src_x, src_y * (1 << field_based),
h_edge_pos,
566 ptr_y =
s->sc.edge_emu_buffer;
568 uint8_t *ubuf =
s->sc.edge_emu_buffer + 18 *
s->linesize;
569 uint8_t *vbuf =ubuf + 10 *
s->uvlinesize;
571 vbuf -=
s->uvlinesize;
572 s->vdsp.emulated_edge_mc(ubuf, ptr_cb,
575 uvsrc_x, uvsrc_y * (1 << field_based),
577 s->vdsp.emulated_edge_mc(vbuf, ptr_cr,
580 uvsrc_x, uvsrc_y * (1 << field_based),
589 dest_y +=
s->linesize;
590 dest_cb +=
s->uvlinesize;
591 dest_cr +=
s->uvlinesize;
595 ptr_y +=
s->linesize;
596 ptr_cb +=
s->uvlinesize;
597 ptr_cr +=
s->uvlinesize;
605 uvsx = (uvsx << 2) >>
lowres;
606 uvsy = (uvsy << 2) >>
lowres;
608 pix_op[op_index](dest_cb, ptr_cb,
uvlinesize, hc, uvsx, uvsy);
609 pix_op[op_index](dest_cr, ptr_cr,
uvlinesize, hc, uvsx, uvsy);
616 uint8_t *dest_cb, uint8_t *dest_cr,
617 uint8_t *
const *ref_picture,
621 const int lowres =
s->avctx->lowres;
622 const int op_index =
lowres;
623 const int block_s = 8 >>
lowres;
624 const int s_mask = (2 <<
lowres) - 1;
627 int emu = 0, src_x, src_y, sx, sy;
633 if (
s->quarter_sample) {
645 src_x =
s->mb_x * block_s + (
mx >>
lowres + 1);
646 src_y =
s->mb_y * block_s + (
my >>
lowres + 1);
648 offset = src_y *
s->uvlinesize + src_x;
649 ptr = ref_picture[1] +
offset;
652 s->vdsp.emulated_edge_mc(
s->sc.edge_emu_buffer, ptr,
653 s->uvlinesize,
s->uvlinesize,
656 ptr =
s->sc.edge_emu_buffer;
661 pix_op[op_index](dest_cb, ptr,
s->uvlinesize, block_s, sx, sy);
663 ptr = ref_picture[2] +
offset;
665 s->vdsp.emulated_edge_mc(
s->sc.edge_emu_buffer, ptr,
666 s->uvlinesize,
s->uvlinesize,
669 ptr =
s->sc.edge_emu_buffer;
671 pix_op[op_index](dest_cr, ptr,
s->uvlinesize, block_s, sx, sy);
686 uint8_t *dest_y, uint8_t *dest_cb,
688 int dir, uint8_t *
const *ref_picture,
693 const int lowres =
s->avctx->lowres;
694 const int block_s = 8 >>
lowres;
699 switch (
s->mv_type) {
704 s->mv[dir][0][0],
s->mv[dir][0][1],
710 for (
int i = 0;
i < 4;
i++) {
712 s->linesize) * block_s,
713 ref_picture[0], 0, 0,
714 (2 *
mb_x + (
i & 1)) * block_s,
715 (2 *
mb_y + (
i >> 1)) * block_s,
716 s->width,
s->height,
s->linesize,
718 block_s, block_s, pix_op,
719 s->mv[dir][
i][0],
s->mv[dir][
i][1]);
721 mx +=
s->mv[dir][
i][0];
722 my +=
s->mv[dir][
i][1];
733 1, 0,
s->field_select[dir][0],
735 s->mv[dir][0][0],
s->mv[dir][0][1],
739 1, 1,
s->field_select[dir][1],
741 s->mv[dir][1][0],
s->mv[dir][1][1],
744 if (
s->picture_structure !=
s->field_select[dir][0] + 1 &&
746 ref_picture =
s->cur_pic.ptr->f->data;
749 0, 0,
s->field_select[dir][0],
752 s->mv[dir][0][1], 2 * block_s,
mb_y >> 1);
756 for (
int i = 0;
i < 2;
i++) {
757 uint8_t *
const *ref2picture;
759 if (
s->picture_structure ==
s->field_select[dir][
i] + 1 ||
761 ref2picture = ref_picture;
763 ref2picture =
s->cur_pic.ptr->f->data;
767 0, 0,
s->field_select[dir][
i],
769 s->mv[dir][
i][0],
s->mv[dir][
i][1] +
770 2 * block_s *
i, block_s,
mb_y >> 1);
772 dest_y += 2 * block_s *
s->linesize;
773 dest_cb += (2 * block_s >>
s->chroma_y_shift) *
s->uvlinesize;
774 dest_cr += (2 * block_s >>
s->chroma_y_shift) *
s->uvlinesize;
779 for (
int i = 0;
i < 2;
i++) {
780 for (
int j = 0; j < 2; j++) {
784 s->mv[dir][2 *
i + j][0],
785 s->mv[dir][2 *
i + j][1],
788 pix_op =
s->h264chroma.avg_h264_chroma_pixels_tab;
791 for (
int i = 0;
i < 2;
i++) {
793 0, 0,
s->picture_structure !=
i + 1,
795 s->mv[dir][2 *
i][0],
s->mv[dir][2 *
i][1],
796 2 * block_s,
mb_y >> 1);
799 pix_op =
s->h264chroma.avg_h264_chroma_pixels_tab;
803 if (!
s->first_field) {
804 ref_picture =
s->cur_pic.ptr->f->data;
819 int my_max = INT_MIN, my_min = INT_MAX, qpel_shift = !
s->quarter_sample;
825 switch (
s->mv_type) {
839 for (
int i = 0;
i < mvs;
i++) {
840 int my =
s->mv[dir][
i][1];
845 off = ((
FFMAX(-my_min, my_max) << qpel_shift) + 63) >> 6;
847 return av_clip(
s->mb_y + off, 0,
s->mb_height - 1);
849 return s->mb_height - 1;
854 int16_t
block[][64],
int i, uint8_t *
dest,
int line_size)
856 if (
s->block_last_index[
i] >= 0) {
872 if (
s->block_last_index[
i] >= 0) {
879 #define NOT_MPEG12_H261 0
880 #define MAY_BE_MPEG12_H261 1
881 #define DEFINITELY_MPEG12_H261 2
894 int lowres_flag,
int is_mpeg12)
896 #define IS_MPEG12_H261(s) (is_mpeg12 == MAY_BE_MPEG12_H261 ? ((s)->out_format <= FMT_H261) : is_mpeg12)
897 uint8_t *dest_y =
s->dest[0], *dest_cb =
s->dest[1], *dest_cr =
s->dest[2];
898 int dct_linesize, dct_offset;
899 const int linesize =
s->cur_pic.linesize[0];
901 const int block_size = lowres_flag ? 8 >>
s->avctx->lowres : 8;
903 dct_linesize =
linesize <<
s->interlaced_dct;
925 op_pix =
s->h264chroma.avg_h264_chroma_pixels_tab;
935 op_pix =
s->hdsp.put_pixels_tab;
936 op_qpix =
s->qdsp.put_qpel_pixels_tab;
938 op_pix =
s->hdsp.put_no_rnd_pixels_tab;
939 op_qpix =
s->qdsp.put_no_rnd_qpel_pixels_tab;
942 ff_mpv_motion(
s, dest_y, dest_cb, dest_cr, 0,
s->last_pic.data, op_pix, op_qpix);
943 op_pix =
s->hdsp.avg_pixels_tab;
944 op_qpix =
s->qdsp.avg_qpel_pixels_tab;
947 ff_mpv_motion(
s, dest_y, dest_cb, dest_cr, 1,
s->next_pic.data, op_pix, op_qpix);
952 if (
s->avctx->skip_idct) {
980 add_dct(
s,
block, 3, dest_y + dct_offset + block_size, dct_linesize);
983 if (
s->chroma_y_shift) {
995 if (!
s->chroma_x_shift) {
998 add_dct(
s,
block, 10, dest_cb + block_size + dct_offset, dct_linesize);
999 add_dct(
s,
block, 11, dest_cr + block_size + dct_offset, dct_linesize);
1003 }
else if (CONFIG_WMV2_DECODER) {
1011 s->avctx->bits_per_raw_sample > 8) {
1017 put_dct(
s,
block[1], 1, dest_y + block_size, dct_linesize,
s->qscale);
1018 put_dct(
s,
block[2], 2, dest_y + dct_offset , dct_linesize,
s->qscale);
1019 put_dct(
s,
block[3], 3, dest_y + dct_offset + block_size, dct_linesize,
s->qscale);
1022 if (
s->chroma_y_shift) {
1028 put_dct(
s,
block[4], 4, dest_cb, dct_linesize,
s->chroma_qscale);
1029 put_dct(
s,
block[5], 5, dest_cr, dct_linesize,
s->chroma_qscale);
1030 put_dct(
s,
block[6], 6, dest_cb + dct_offset, dct_linesize,
s->chroma_qscale);
1031 put_dct(
s,
block[7], 7, dest_cr + dct_offset, dct_linesize,
s->chroma_qscale);
1035 s->idsp.idct_put(dest_y, dct_linesize,
block[0]);
1036 s->idsp.idct_put(dest_y + block_size, dct_linesize,
block[1]);
1037 s->idsp.idct_put(dest_y + dct_offset, dct_linesize,
block[2]);
1038 s->idsp.idct_put(dest_y + dct_offset + block_size, dct_linesize,
block[3]);
1041 if (
s->chroma_y_shift) {
1048 s->idsp.idct_put(dest_cb, dct_linesize,
block[4]);
1049 s->idsp.idct_put(dest_cr, dct_linesize,
block[5]);
1050 s->idsp.idct_put(dest_cb + dct_offset, dct_linesize,
block[6]);
1051 s->idsp.idct_put(dest_cr + dct_offset, dct_linesize,
block[7]);
1052 if (!
s->chroma_x_shift) {
1053 s->idsp.idct_put(dest_cb + block_size, dct_linesize,
block[8]);
1054 s->idsp.idct_put(dest_cr + block_size, dct_linesize,
block[9]);
1055 s->idsp.idct_put(dest_cb + block_size + dct_offset, dct_linesize,
block[10]);
1056 s->idsp.idct_put(dest_cr + block_size + dct_offset, dct_linesize,
block[11]);
1069 void *
const logctx =
s->avctx;
1070 const uint8_t *
const idct_permutation =
s->idsp.idct_permutation;
1074 for (
int i = 0;
i < 6;
i++) {
1075 for (
int j = 0; j < 64; j++) {
1077 block[
i][idct_permutation[j]]);
1085 const int mb_xy =
s->mb_y *
s->mb_stride +
s->mb_x;
1086 uint8_t *mbskip_ptr = &
s->mbskip_table[mb_xy];
1088 s->cur_pic.qscale_table[mb_xy] =
s->qscale;
1091 if (
s->mb_skipped) {
1095 }
else if (!
s->cur_pic.reference) {
1105 if (!
s->avctx->lowres) {