35 #define ME_MODE_BIDIR 0 36 #define ME_MODE_BILAT 1 38 #define MC_MODE_OBMC 0 39 #define MC_MODE_AOBMC 1 41 #define SCD_METHOD_NONE 0 42 #define SCD_METHOD_FDIFF 1 45 #define NB_PIXEL_MVS 32 46 #define NB_CLUSTERS 128 48 #define ALPHA_MAX 1024 49 #define CLUSTER_THRESHOLD 4 50 #define PX_WEIGHT_MAX 255 51 #define COST_PRED_SCALE 64 54 0, 0, 0, 0, 4, 4, 4, 4, 4, 4, 4, 4, 8, 8, 8, 8, 8, 8, 8, 8, 4, 4, 4, 4, 4, 4, 4, 4, 0, 0, 0, 0,
55 0, 4, 4, 4, 8, 8, 8, 12, 12, 16, 16, 16, 20, 20, 20, 24, 24, 20, 20, 20, 16, 16, 16, 12, 12, 8, 8, 8, 4, 4, 4, 0,
56 0, 4, 8, 8, 12, 12, 16, 20, 20, 24, 28, 28, 32, 32, 36, 40, 40, 36, 32, 32, 28, 28, 24, 20, 20, 16, 12, 12, 8, 8, 4, 0,
57 0, 4, 8, 12, 16, 20, 24, 28, 28, 32, 36, 40, 44, 48, 52, 56, 56, 52, 48, 44, 40, 36, 32, 28, 28, 24, 20, 16, 12, 8, 4, 0,
58 4, 8, 12, 16, 20, 24, 28, 32, 40, 44, 48, 52, 56, 60, 64, 68, 68, 64, 60, 56, 52, 48, 44, 40, 32, 28, 24, 20, 16, 12, 8, 4,
59 4, 8, 12, 20, 24, 32, 36, 40, 48, 52, 56, 64, 68, 76, 80, 84, 84, 80, 76, 68, 64, 56, 52, 48, 40, 36, 32, 24, 20, 12, 8, 4,
60 4, 8, 16, 24, 28, 36, 44, 48, 56, 60, 68, 76, 80, 88, 96,100,100, 96, 88, 80, 76, 68, 60, 56, 48, 44, 36, 28, 24, 16, 8, 4,
61 4, 12, 20, 28, 32, 40, 48, 56, 64, 72, 80, 88, 92,100,108,116,116,108,100, 92, 88, 80, 72, 64, 56, 48, 40, 32, 28, 20, 12, 4,
62 4, 12, 20, 28, 40, 48, 56, 64, 72, 80, 88, 96,108,116,124,132,132,124,116,108, 96, 88, 80, 72, 64, 56, 48, 40, 28, 20, 12, 4,
63 4, 16, 24, 32, 44, 52, 60, 72, 80, 92,100,108,120,128,136,148,148,136,128,120,108,100, 92, 80, 72, 60, 52, 44, 32, 24, 16, 4,
64 4, 16, 28, 36, 48, 56, 68, 80, 88,100,112,120,132,140,152,164,164,152,140,132,120,112,100, 88, 80, 68, 56, 48, 36, 28, 16, 4,
65 4, 16, 28, 40, 52, 64, 76, 88, 96,108,120,132,144,156,168,180,180,168,156,144,132,120,108, 96, 88, 76, 64, 52, 40, 28, 16, 4,
66 8, 20, 32, 44, 56, 68, 80, 92,108,120,132,144,156,168,180,192,192,180,168,156,144,132,120,108, 92, 80, 68, 56, 44, 32, 20, 8,
67 8, 20, 32, 48, 60, 76, 88,100,116,128,140,156,168,184,196,208,208,196,184,168,156,140,128,116,100, 88, 76, 60, 48, 32, 20, 8,
68 8, 20, 36, 52, 64, 80, 96,108,124,136,152,168,180,196,212,224,224,212,196,180,168,152,136,124,108, 96, 80, 64, 52, 36, 20, 8,
69 8, 24, 40, 56, 68, 84,100,116,132,148,164,180,192,208,224,240,240,224,208,192,180,164,148,132,116,100, 84, 68, 56, 40, 24, 8,
70 8, 24, 40, 56, 68, 84,100,116,132,148,164,180,192,208,224,240,240,224,208,192,180,164,148,132,116,100, 84, 68, 56, 40, 24, 8,
71 8, 20, 36, 52, 64, 80, 96,108,124,136,152,168,180,196,212,224,224,212,196,180,168,152,136,124,108, 96, 80, 64, 52, 36, 20, 8,
72 8, 20, 32, 48, 60, 76, 88,100,116,128,140,156,168,184,196,208,208,196,184,168,156,140,128,116,100, 88, 76, 60, 48, 32, 20, 8,
73 8, 20, 32, 44, 56, 68, 80, 92,108,120,132,144,156,168,180,192,192,180,168,156,144,132,120,108, 92, 80, 68, 56, 44, 32, 20, 8,
74 4, 16, 28, 40, 52, 64, 76, 88, 96,108,120,132,144,156,168,180,180,168,156,144,132,120,108, 96, 88, 76, 64, 52, 40, 28, 16, 4,
75 4, 16, 28, 36, 48, 56, 68, 80, 88,100,112,120,132,140,152,164,164,152,140,132,120,112,100, 88, 80, 68, 56, 48, 36, 28, 16, 4,
76 4, 16, 24, 32, 44, 52, 60, 72, 80, 92,100,108,120,128,136,148,148,136,128,120,108,100, 92, 80, 72, 60, 52, 44, 32, 24, 16, 4,
77 4, 12, 20, 28, 40, 48, 56, 64, 72, 80, 88, 96,108,116,124,132,132,124,116,108, 96, 88, 80, 72, 64, 56, 48, 40, 28, 20, 12, 4,
78 4, 12, 20, 28, 32, 40, 48, 56, 64, 72, 80, 88, 92,100,108,116,116,108,100, 92, 88, 80, 72, 64, 56, 48, 40, 32, 28, 20, 12, 4,
79 4, 8, 16, 24, 28, 36, 44, 48, 56, 60, 68, 76, 80, 88, 96,100,100, 96, 88, 80, 76, 68, 60, 56, 48, 44, 36, 28, 24, 16, 8, 4,
80 4, 8, 12, 20, 24, 32, 36, 40, 48, 52, 56, 64, 68, 76, 80, 84, 84, 80, 76, 68, 64, 56, 52, 48, 40, 36, 32, 24, 20, 12, 8, 4,
81 4, 8, 12, 16, 20, 24, 28, 32, 40, 44, 48, 52, 56, 60, 64, 68, 68, 64, 60, 56, 52, 48, 44, 40, 32, 28, 24, 20, 16, 12, 8, 4,
82 0, 4, 8, 12, 16, 20, 24, 28, 28, 32, 36, 40, 44, 48, 52, 56, 56, 52, 48, 44, 40, 36, 32, 28, 28, 24, 20, 16, 12, 8, 4, 0,
83 0, 4, 8, 8, 12, 12, 16, 20, 20, 24, 28, 28, 32, 32, 36, 40, 40, 36, 32, 32, 28, 28, 24, 20, 20, 16, 12, 12, 8, 8, 4, 0,
84 0, 4, 4, 4, 8, 8, 8, 12, 12, 16, 16, 16, 20, 20, 20, 24, 24, 20, 20, 20, 16, 16, 16, 12, 12, 8, 8, 8, 4, 4, 4, 0,
85 0, 0, 0, 0, 4, 4, 4, 4, 4, 4, 4, 4, 8, 8, 8, 8, 8, 8, 8, 8, 4, 4, 4, 4, 4, 4, 4, 4, 0, 0, 0, 0,
89 0, 4, 4, 8, 8, 12, 12, 16, 16, 12, 12, 8, 8, 4, 4, 0,
90 4, 8, 16, 20, 28, 32, 40, 44, 44, 40, 32, 28, 20, 16, 8, 4,
91 4, 16, 24, 36, 44, 56, 64, 76, 76, 64, 56, 44, 36, 24, 16, 4,
92 8, 20, 36, 48, 64, 76, 92,104,104, 92, 76, 64, 48, 36, 20, 8,
93 8, 28, 44, 64, 80,100,116,136,136,116,100, 80, 64, 44, 28, 8,
94 12, 32, 56, 76,100,120,144,164,164,144,120,100, 76, 56, 32, 12,
95 12, 40, 64, 92,116,144,168,196,196,168,144,116, 92, 64, 40, 12,
96 16, 44, 76,104,136,164,196,224,224,196,164,136,104, 76, 44, 16,
97 16, 44, 76,104,136,164,196,224,224,196,164,136,104, 76, 44, 16,
98 12, 40, 64, 92,116,144,168,196,196,168,144,116, 92, 64, 40, 12,
99 12, 32, 56, 76,100,120,144,164,164,144,120,100, 76, 56, 32, 12,
100 8, 28, 44, 64, 80,100,116,136,136,116,100, 80, 64, 44, 28, 8,
101 8, 20, 36, 48, 64, 76, 92,104,104, 92, 76, 64, 48, 36, 20, 8,
102 4, 16, 24, 36, 44, 56, 64, 76, 76, 64, 56, 44, 36, 24, 16, 4,
103 4, 8, 16, 20, 28, 32, 40, 44, 44, 40, 32, 28, 20, 16, 8, 4,
104 0, 4, 4, 8, 8, 12, 12, 16, 16, 12, 12, 8, 8, 4, 4, 0,
108 4, 12, 20, 28, 28, 20, 12, 4,
109 12, 36, 60, 84, 84, 60, 36, 12,
110 20, 60,100,140,140,100, 60, 20,
111 28, 84,140,196,196,140, 84, 28,
112 28, 84,140,196,196,140, 84, 28,
113 20, 60,100,140,140,100, 60, 20,
114 12, 36, 60, 84, 84, 60, 36, 12,
115 4, 12, 20, 28, 28, 20, 12, 4,
140 typedef struct Block {
161 typedef struct Frame {
201 #define OFFSET(x) offsetof(MIContext, x) 202 #define FLAGS AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM 203 #define CONST(name, help, val, unit) { name, help, 0, AV_OPT_TYPE_CONST, {.i64=val}, 0, 0, FLAGS, unit } 213 CONST(
"aobmc",
"adaptive overlapped block motion compensation",
MC_MODE_AOBMC,
"mc_mode"),
228 {
"search_param",
"search parameter",
OFFSET(search_param),
AV_OPT_TYPE_INT, {.i64 = 32}, 4, INT_MAX, FLAGS },
229 {
"vsbmc",
"variable-size block motion compensation",
OFFSET(vsbmc),
AV_OPT_TYPE_INT, {.i64 = 0}, 0, 1, FLAGS },
233 {
"scd_threshold",
"scene change threshold",
OFFSET(scd_threshold),
AV_OPT_TYPE_DOUBLE, {.dbl = 10.}, 0, 100.0, FLAGS },
264 int mv_x1 = x_mv - x;
265 int mv_y1 = y_mv - y;
266 int mv_x, mv_y,
i, j;
274 data_cur += (y + mv_y) * linesize;
275 data_next += (y - mv_y) * linesize;
277 for (j = 0; j < me_ctx->
mb_size; j++)
278 for (i = 0; i < me_ctx->
mb_size; i++)
279 sbad +=
FFABS(data_cur[x + mv_x + i + j * linesize] - data_next[x - mv_x + i + j * linesize]);
293 int mv_x1 = x_mv - x;
294 int mv_y1 = y_mv - y;
295 int mv_x, mv_y,
i, j;
298 x = av_clip(x, x_min, x_max);
299 y = av_clip(y, y_min, y_max);
300 mv_x = av_clip(x_mv - x, -
FFMIN(x - x_min, x_max - x),
FFMIN(x - x_min, x_max - x));
301 mv_y = av_clip(y_mv - y, -
FFMIN(y - y_min, y_max - y),
FFMIN(y - y_min, y_max - y));
303 for (j = -me_ctx->
mb_size / 2; j < me_ctx->mb_size * 3 / 2; j++)
304 for (i = -me_ctx->
mb_size / 2; i < me_ctx->mb_size * 3 / 2; i++)
305 sbad +=
FFABS(data_cur[x + mv_x + i + (y + mv_y + j) * linesize] - data_next[x - mv_x + i + (y - mv_y + j) * linesize]);
324 x = av_clip(x, x_min, x_max);
325 y = av_clip(y, y_min, y_max);
326 x_mv = av_clip(x_mv, x_min, x_max);
327 y_mv = av_clip(y_mv, y_min, y_max);
329 for (j = -me_ctx->
mb_size / 2; j < me_ctx->mb_size * 3 / 2; j++)
330 for (i = -me_ctx->
mb_size / 2; i < me_ctx->mb_size * 3 / 2; i++)
331 sad +=
FFABS(data_ref[x_mv + i + (y_mv + j) * linesize] - data_cur[x + i + (y + j) * linesize]);
342 const int width = inlink->
w;
393 for (i = 0; i < 3; i++) {
427 #define ADD_PRED(preds, px, py)\ 429 preds.mvs[preds.nb][0] = px;\ 430 preds.mvs[preds.nb][1] = py;\ 442 const int mb_i = mb_x + mb_y * mi_ctx->
b_width;
443 int mv[2] = {x_mb, y_mb};
483 if (mb_y > 0 && mb_x + 1 < mi_ctx->
b_width)
487 if (preds[0].
nb == 4) {
488 me_ctx->
pred_x =
mid_pred(preds[0].mvs[1][0], preds[0].mvs[2][0], preds[0].mvs[3][0]);
489 me_ctx->
pred_y =
mid_pred(preds[0].mvs[1][1], preds[0].mvs[2][1], preds[0].mvs[3][1]);
490 }
else if (preds[0].
nb == 3) {
491 me_ctx->
pred_x =
mid_pred(0, preds[0].mvs[1][0], preds[0].mvs[2][0]);
492 me_ctx->
pred_y =
mid_pred(0, preds[0].mvs[1][1], preds[0].mvs[2][1]);
493 }
else if (preds[0].
nb == 2) {
517 if (mb_x + 1 < mi_ctx->
b_width)
526 mi_ctx->
mv_table[0][mb_i][dir][0] = mv[0] - x_mb;
527 mi_ctx->
mv_table[0][mb_i][dir][1] = mv[1] - y_mb;
538 ADD_PRED(preds[0], blocks[mb_i - 1].mvs[dir][0], blocks[mb_i - 1].mvs[dir][1]);
545 if (mb_x + 1 < mi_ctx->
b_width)
553 if (preds[0].
nb == 4) {
554 me_ctx->
pred_x =
mid_pred(preds[0].mvs[1][0], preds[0].mvs[2][0], preds[0].mvs[3][0]);
555 me_ctx->
pred_y =
mid_pred(preds[0].mvs[1][1], preds[0].mvs[2][1], preds[0].mvs[3][1]);
556 }
else if (preds[0].
nb == 3) {
557 me_ctx->
pred_x =
mid_pred(0, preds[0].mvs[1][0], preds[0].mvs[2][0]);
558 me_ctx->
pred_y =
mid_pred(0, preds[0].mvs[1][1], preds[0].mvs[2][1]);
559 }
else if (preds[0].
nb == 2) {
572 block->
mvs[dir][0] = mv[0] - x_mb;
573 block->
mvs[dir][1] = mv[1] - y_mb;
581 for (mb_y = 0; mb_y < mi_ctx->
b_height; mb_y++)
582 for (mb_x = 0; mb_x < mi_ctx->
b_width; mb_x++) {
588 block->
mvs[0][0] = 0;
589 block->
mvs[0][1] = 0;
592 for (mb_y = 0; mb_y < mi_ctx->
b_height; mb_y++)
593 for (mb_x = 0; mb_x < mi_ctx->
b_width; mb_x++)
600 uint64_t cost_sb, cost_old;
608 cost_old = me_ctx->
get_cost(me_ctx, x_mb, y_mb, x_mb + block->
mvs[0][0], y_mb + block->
mvs[0][1]);
624 for (y = 0; y < 2; y++)
625 for (x = 0; x < 2; x++) {
627 int mv[2] = {x_mb + block->
mvs[0][0], y_mb + block->
mvs[0][1]};
629 me_ctx->
mb_size = 1 << (n - 1);
641 if (cost_sb < cost_old / 4) {
642 sb->
mvs[0][0] = mv_x;
643 sb->
mvs[0][1] = mv_y;
646 if (ret =
var_size_bme(mi_ctx, sb, x_mb + (x << (n - 1)), y_mb + (y << (n - 1)), n - 1))
661 int changed,
c, c_max = 0;
662 int mb_x, mb_y, x, y;
663 int mv_x, mv_y, avg_x, avg_y, dx, dy;
666 Cluster *cluster, *cluster_new;
670 for (mb_y = 0; mb_y < mi_ctx->
b_height; mb_y++)
671 for (mb_x = 0; mb_x < mi_ctx->
b_width; mb_x++) {
675 mv_x = block->
mvs[0][0];
676 mv_y = block->
mvs[0][1];
681 avg_x = cluster->
sum[0] / cluster->
nb;
682 avg_y = cluster->
sum[1] / cluster->
nb;
688 for (d = 1; d < 5; d++)
692 if (nb->
cid > block->
cid) {
693 if (nb->
cid < c || c == block->
cid)
706 cluster_new->
sum[0] += mv_x;
707 cluster_new->
sum[1] += mv_y;
708 cluster->
sum[0] -= mv_x;
709 cluster->
sum[1] -= mv_y;
713 c_max =
FFMAX(c_max, c);
722 for (mb_y = 0; mb_y < mi_ctx->
b_height; mb_y++)
723 for (mb_x = 0; mb_x < mi_ctx->
b_width; mb_x++) {
730 if ((x - mb_x) && (y - mb_y) || !dx && !dy)
733 if (!mb_x || !mb_y || mb_x == mi_ctx->
b_width - 1 || mb_y == mi_ctx->
b_height - 1)
757 frame_tmp = mi_ctx->
frames[0];
772 for (dir = 0; dir < 2; dir++) {
777 for (mb_y = 0; mb_y < mi_ctx->
b_height; mb_y++)
778 for (mb_x = 0; mb_x < mi_ctx->
b_width; mb_x++)
798 for (mb_y = 0; mb_y < mi_ctx->
b_height; mb_y++)
799 for (mb_x = 0; mb_x < mi_ctx->
b_width; mb_x++) {
816 for (mb_y = 0; mb_y < mi_ctx->
b_height; mb_y++)
817 for (mb_x = 0; mb_x < mi_ctx->
b_width; mb_x++) {
845 double ret = 0, mafd,
diff;
847 mi_ctx->
sad(p1, linesize1, p2, linesize2, input->
w, input->
h, &sad);
849 mafd = (double) sad * 100.0 / (input->
h * input->
w) / (1 << mi_ctx->
bitdepth);
851 ret = av_clipf(
FFMIN(mafd, diff), 0, 100.0);
860 #define ADD_PIXELS(b_weight, mv_x, mv_y)\ 862 if (!b_weight || pixel_refs->nb + 1 >= NB_PIXEL_MVS)\ 864 pixel_refs->refs[pixel_refs->nb] = 1;\ 865 pixel_weights->weights[pixel_refs->nb] = b_weight * (ALPHA_MAX - alpha);\ 866 pixel_mvs->mvs[pixel_refs->nb][0] = av_clip((mv_x * alpha) / ALPHA_MAX, x_min, x_max);\ 867 pixel_mvs->mvs[pixel_refs->nb][1] = av_clip((mv_y * alpha) / ALPHA_MAX, y_min, y_max);\ 869 pixel_refs->refs[pixel_refs->nb] = 2;\ 870 pixel_weights->weights[pixel_refs->nb] = b_weight * alpha;\ 871 pixel_mvs->mvs[pixel_refs->nb][0] = av_clip(-mv_x * (ALPHA_MAX - alpha) / ALPHA_MAX, x_min, x_max);\ 872 pixel_mvs->mvs[pixel_refs->nb][1] = av_clip(-mv_y * (ALPHA_MAX - alpha) / ALPHA_MAX, y_min, y_max);\ 883 for (y = 0; y <
height; y++)
884 for (x = 0; x <
width; x++)
887 for (dir = 0; dir < 2; dir++)
888 for (mb_y = 0; mb_y < mi_ctx->
b_height; mb_y++)
889 for (mb_x = 0; mb_x < mi_ctx->
b_width; mb_x++) {
893 int start_x, start_y;
894 int startc_x, startc_y, endc_x, endc_y;
899 startc_x = av_clip(start_x, 0, width - 1);
900 startc_y = av_clip(start_y, 0, height - 1);
901 endc_x = av_clip(start_x + (2 << mi_ctx->
log2_mb_size), 0, width - 1);
902 endc_y = av_clip(start_y + (2 << mi_ctx->
log2_mb_size), 0, height - 1);
909 for (y = startc_y; y < endc_y; y++) {
911 int y_max = height - y - 1;
912 for (x = startc_x; x < endc_x; x++) {
914 int x_max = width - x - 1;
930 for (plane = 0; plane < mi_ctx->
nb_planes; plane++) {
933 int chroma = plane == 1 || plane == 2;
935 for (y = 0; y <
height; y++)
936 for (x = 0; x <
width; x++) {
944 for (i = 0; i < pixel_refs->
nb; i++)
945 weight_sum += pixel_weights->
weights[i];
947 if (!weight_sum || !pixel_refs->
nb) {
949 pixel_refs->
refs[0] = 1;
950 pixel_mvs->
mvs[0][0] = 0;
951 pixel_mvs->
mvs[0][1] = 0;
953 pixel_refs->
refs[1] = 2;
954 pixel_mvs->
mvs[1][0] = 0;
955 pixel_mvs->
mvs[1][1] = 0;
961 for (i = 0; i < pixel_refs->
nb; i++) {
967 x_mv = x + pixel_mvs->
mvs[
i][0];
968 y_mv = y + pixel_mvs->
mvs[
i][1];
990 for (sb_y = 0; sb_y < 2; sb_y++)
991 for (sb_x = 0; sb_x < 2; sb_x++) {
992 Block *sb = &block->
subs[sb_x + sb_y * 2];
995 var_size_bmc(mi_ctx, sb, x_mb + (sb_x << (n - 1)), y_mb + (sb_y << (n - 1)), n - 1, alpha);
998 int mv_x = sb->
mvs[0][0] * 2;
999 int mv_y = sb->
mvs[0][1] * 2;
1001 int start_x = x_mb + (sb_x << (n - 1));
1002 int start_y = y_mb + (sb_y << (n - 1));
1003 int end_x = start_x + (1 << (n - 1));
1004 int end_y = start_y + (1 << (n - 1));
1006 for (y = start_y; y < end_y; y++) {
1008 int y_max = height - y - 1;
1009 for (x = start_x; x < end_x; x++) {
1011 int x_max = width - x - 1;
1033 int mv_x = block->
mvs[0][0] * 2;
1034 int mv_y = block->
mvs[0][1] * 2;
1035 int start_x, start_y;
1036 int startc_x, startc_y, endc_x, endc_y;
1040 for (nb_x =
FFMAX(0, mb_x - 1); nb_x <
FFMIN(mb_x + 2, mi_ctx->
b_width); nb_x++) {
1044 if (nb_x - mb_x || nb_y - mb_y)
1045 sbads[nb_x - mb_x + 1 + (nb_y - mb_y + 1) * 3] =
get_sbad(&mi_ctx->
me_ctx, x_nb, y_nb, x_nb + block->
mvs[0][0], y_nb + block->
mvs[0][1]);
1051 startc_x = av_clip(start_x, 0, width - 1);
1052 startc_y = av_clip(start_y, 0, height - 1);
1053 endc_x = av_clip(start_x + (2 << mi_ctx->
log2_mb_size), 0, width - 1);
1054 endc_y = av_clip(start_y + (2 << mi_ctx->
log2_mb_size), 0, height - 1);
1056 for (y = startc_y; y < endc_y; y++) {
1058 int y_max = height - y - 1;
1059 for (x = startc_x; x < endc_x; x++) {
1061 int x_max = width - x - 1;
1068 nb_x = (((x - start_x) >> (mi_ctx->
log2_mb_size - 1)) * 2 - 3) / 2;
1069 nb_y = (((y - start_y) >> (mi_ctx->
log2_mb_size - 1)) * 2 - 3) / 2;
1072 uint64_t sbad = sbads[nb_x + 1 + (nb_y + 1) * 3];
1075 if (sbad && sbad != UINT64_MAX && nb->sbad != UINT64_MAX) {
1077 obmc_weight = obmc_weight * phi /
ALPHA_MAX;
1100 alpha = av_clip(alpha, 0, ALPHA_MAX);
1102 if (alpha == 0 || alpha == ALPHA_MAX) {
1120 for (plane = 0; plane < mi_ctx->
nb_planes; plane++) {
1124 if (plane == 1 || plane == 2) {
1129 for (y = 0; y <
height; y++) {
1130 for (x = 0; x <
width; x++) {
1131 avf_out->
data[plane][x + y * avf_out->
linesize[plane]] =
1153 for (mb_x = 0; mb_x < mi_ctx->
b_width; mb_x++) {
1237 for (m = 0; m < mi_ctx->
b_count; m++)
1247 for (i = 0; i < 3; i++)
1271 .
name =
"minterpolate",
1274 .priv_class = &minterpolate_class,
1277 .
inputs = minterpolate_inputs,
1278 .
outputs = minterpolate_outputs,
uint64_t ff_me_search_hexbs(AVMotionEstContext *me_ctx, int x_mb, int y_mb, int *mv)
static const uint8_t obmc_linear32[1024]
void(* ff_scene_sad_fn)(SCENE_SAD_PARAMS)
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
This structure describes decoded (raw) audio or video data.
int8_t refs[NB_PIXEL_MVS]
static const AVFilterPad minterpolate_outputs[]
static const uint8_t obmc_linear4[16]
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
int av_pix_fmt_count_planes(enum AVPixelFormat pix_fmt)
Main libavfilter public API header.
ff_scene_sad_fn ff_scene_sad_get_fn(int depth)
int h
agreed upon image height
int pred_y
median predictor y
#define AV_ME_METHOD_TDLS
static av_cold void free_blocks(Block *block, int sb)
uint64_t(* get_cost)(struct AVMotionEstContext *me_ctx, int x_mb, int y_mb, int mv_x, int mv_y)
static const AVOption minterpolate_options[]
static void bilateral_obmc(MIContext *mi_ctx, Block *block, int mb_x, int mb_y, int alpha)
AVFrame * ff_get_video_buffer(AVFilterLink *link, int w, int h)
Request a picture buffer with a specific set of permissions.
uint8_t log2_chroma_w
Amount to shift the luma width right to find the chroma width.
static int detect_scene_change(AVFilterContext *ctx)
AVMotionEstPredictor preds[2]
const char * name
Pad name.
AVFilterLink ** inputs
array of pointers to input links
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
uint64_t ff_me_search_fss(AVMotionEstContext *me_ctx, int x_mb, int y_mb, int *mv)
planar YUV 4:2:0, 20bpp, (1 Cr & Cb sample per 2x2 Y & A samples)
AVComponentDescriptor comp[4]
Parameters that describe how pixels are packed.
#define AV_ME_METHOD_NTSS
static void interpolate(AVFilterLink *inlink, AVFrame *avf_out)
uint32_t weights[NB_PIXEL_MVS]
int pred_x
median predictor x
uint64_t ff_me_search_ds(AVMotionEstContext *me_ctx, int x_mb, int y_mb, int *mv)
Cluster clusters[NB_CLUSTERS]
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
#define AV_ME_METHOD_EPZS
static uint64_t get_sbad(AVMotionEstContext *me_ctx, int x, int y, int x_mv, int y_mv)
uint64_t ff_me_search_umh(AVMotionEstContext *me_ctx, int x_mb, int y_mb, int *mv)
planar YUV 4:4:0 full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV440P and setting color_range...
planar YUV 4:2:2, 16bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV422P and setting col...
#define AV_LOG_VERBOSE
Detailed information.
#define CONST(name, help, val, unit)
static void set_frame_data(MIContext *mi_ctx, int alpha, AVFrame *avf_out)
static void bilateral_me(MIContext *mi_ctx)
#define ROUNDED_DIV(a, b)
static const uint8_t obmc_linear16[256]
#define AV_ME_METHOD_HEXBS
A filter pad used for either input or output.
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
A link between two filters.
static uint64_t get_sad_ob(AVMotionEstContext *me_ctx, int x, int y, int x_mv, int y_mv)
planar YUV 4:2:2 24bpp, (1 Cr & Cb sample per 2x1 Y & A samples)
#define i(width, name, range_min, range_max)
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
uint8_t log2_chroma_h
Amount to shift the luma height right to find the chroma height.
AVRational frame_rate
Frame rate of the stream on the link, or 1/0 if unknown or variable; if left to 0/0, will be automatically copied from the first input of the source filter if it exists.
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
void * priv
private data for use by the filter
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
uint64_t ff_me_search_epzs(AVMotionEstContext *me_ctx, int x_mb, int y_mb, int *mv)
static int var_size_bme(MIContext *mi_ctx, Block *block, int x_mb, int y_mb, int n)
AVRational time_base
Define the time base used by the PTS of the frames/samples which will pass through this link...
static int filter_frame(AVFilterLink *inlink, AVFrame *avf_in)
simple assert() macros that are a bit more flexible than ISO C assert().
static const uint8_t *const obmc_tab_linear[4]
int av_frame_copy(AVFrame *dst, const AVFrame *src)
Copy the frame data from src to dst.
int av_compare_ts(int64_t ts_a, AVRational tb_a, int64_t ts_b, AVRational tb_b)
Compare two timestamps each in its own time base.
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
int w
agreed upon image width
static int cluster_mvs(MIContext *mi_ctx)
AVFilter ff_vf_minterpolate
uint64_t ff_me_search_tdls(AVMotionEstContext *me_ctx, int x_mb, int y_mb, int *mv)
int64_t av_rescale(int64_t a, int64_t b, int64_t c)
Rescale a 64-bit integer with rounding to nearest.
planar YUV 4:2:0, 12bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV420P and setting col...
PixelWeights * pixel_weights
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
AVFilterContext * src
source filter
uint64_t ff_me_search_ntss(AVMotionEstContext *me_ctx, int x_mb, int y_mb, int *mv)
static const AVFilterPad inputs[]
AVFrame * av_frame_clone(const AVFrame *src)
Create a new frame that references the same data as src.
static const AVFilterPad outputs[]
int format
agreed upon media format
static const int8_t mv[256][2]
void ff_me_init_context(AVMotionEstContext *me_ctx, int mb_size, int search_param, int width, int height, int x_min, int x_max, int y_min, int y_max)
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
planar YUV 4:4:4 32bpp, (1 Cr & Cb sample per 1x1 Y & A samples)
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
static const int16_t alpha[]
static int config_input(AVFilterLink *inlink)
#define ME_MODE_BIDIR
Copyright (c) 2014-2015 Michael Niedermayer michaelni@gmx.at Copyright (c) 2016 Davinder Singh (DSM_)...
static void var_size_bmc(MIContext *mi_ctx, Block *block, int x_mb, int y_mb, int n, int alpha)
planar YUV 4:1:0, 9bpp, (1 Cr & Cb sample per 4x4 Y samples)
#define ADD_PIXELS(b_weight, mv_x, mv_y)
Describe the class of an AVClass context structure.
static const AVFilterPad minterpolate_inputs[]
Rational number (pair of numerator and denominator).
offset must point to AVRational
const char * name
Filter name.
uint64_t ff_me_search_esa(AVMotionEstContext *me_ctx, int x_mb, int y_mb, int *mv)
AVFilterLink ** outputs
array of pointers to output links
static enum AVPixelFormat pix_fmts[]
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
static int config_output(AVFilterLink *outlink)
static av_always_inline AVRational av_inv_q(AVRational q)
Invert a rational.
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
common internal and external API header
AVFILTER_DEFINE_CLASS(minterpolate)
AVMotionEstContext me_ctx
planar YUV 4:4:4, 24bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV444P and setting col...
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples)
#define AV_ME_METHOD_ESA
Copyright (c) 2016 Davinder Singh (DSM_) <ds.mudhar<.com>
uint64_t ff_me_search_tss(AVMotionEstContext *me_ctx, int x_mb, int y_mb, int *mv)
static int query_formats(AVFilterContext *ctx)
static void search_mv(MIContext *mi_ctx, Block *blocks, int mb_x, int mb_y, int dir)
#define ADD_PRED(preds, px, py)
static av_always_inline int diff(const uint32_t a, const uint32_t b)
AVFilterContext * dst
dest filter
int16_t mvs[NB_PIXEL_MVS][2]
#define CLUSTER_THRESHOLD
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples) full scale (JPEG), deprecated in favor ...
planar YUV 4:4:0 (1 Cr & Cb sample per 1x2 Y samples)
static int inject_frame(AVFilterLink *inlink, AVFrame *avf_in)
static void bidirectional_obmc(MIContext *mi_ctx, int alpha)
static av_always_inline av_const int av_ceil_log2_c(int x)
Compute ceil(log2(x)).
int depth
Number of bits in the component.
static const uint8_t obmc_linear8[64]
static uint64_t get_sbad_ob(AVMotionEstContext *me_ctx, int x, int y, int x_mv, int y_mv)
AVPixelFormat
Pixel format.
static double val(void *priv, double ch)
static av_cold void uninit(AVFilterContext *ctx)
int av_frame_copy_props(AVFrame *dst, const AVFrame *src)
Copy only "metadata" fields from src to dst.
#define AV_NOPTS_VALUE
Undefined timestamp value.
#define AV_CEIL_RSHIFT(a, b)
void * av_mallocz_array(size_t nmemb, size_t size)
Allocate a memory block for an array with av_mallocz().