mirror of
https://github.com/FFmpeg/FFmpeg.git
synced 2024-12-23 12:43:46 +02:00
mpegvideo: drop vismv code
It has been broken for over a year without anyone complaining or noticing, thus proving that nobody ever uses it.
This commit is contained in:
Anton Khirnov
parent
2eba9087f3
commit
37045e4229
@ -1008,16 +1008,6 @@ static int init_context_frame(MpegEncContext *s)
|
||||
FF_ALLOCZ_OR_GOTO(s->avctx, s->mbskip_table, mb_array_size + 2, fail);
|
||||
// Note the + 1 is for a quicker mpeg4 slice_end detection
|
||||
|
||||
if ((s->avctx->debug & (FF_DEBUG_VIS_QP | FF_DEBUG_VIS_MB_TYPE)) ||
|
||||
s->avctx->debug_mv) {
|
||||
s->visualization_buffer[0] = av_malloc((s->mb_width * 16 +
|
||||
2 * EDGE_WIDTH) * s->mb_height * 16 + 2 * EDGE_WIDTH);
|
||||
s->visualization_buffer[1] = av_malloc((s->mb_width * 16 +
|
||||
2 * EDGE_WIDTH) * s->mb_height * 16 + 2 * EDGE_WIDTH);
|
||||
s->visualization_buffer[2] = av_malloc((s->mb_width * 16 +
|
||||
2 * EDGE_WIDTH) * s->mb_height * 16 + 2 * EDGE_WIDTH);
|
||||
}
|
||||
|
||||
return init_er(s);
|
||||
fail:
|
||||
return AVERROR(ENOMEM);
|
||||
@ -1213,9 +1203,6 @@ static int free_context_frame(MpegEncContext *s)
|
||||
|
||||
s->linesize = s->uvlinesize = 0;
|
||||
|
||||
for (i = 0; i < 3; i++)
|
||||
av_freep(&s->visualization_buffer[i]);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -1805,94 +1792,6 @@ void ff_MPV_frame_end(MpegEncContext *s)
|
||||
ff_thread_report_progress(&s->current_picture_ptr->tf, INT_MAX, 0);
|
||||
}
|
||||
|
||||
/**
|
||||
* Draw a line from (ex, ey) -> (sx, sy).
|
||||
* @param w width of the image
|
||||
* @param h height of the image
|
||||
* @param stride stride/linesize of the image
|
||||
* @param color color of the arrow
|
||||
*/
|
||||
static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey,
|
||||
int w, int h, int stride, int color)
|
||||
{
|
||||
int x, y, fr, f;
|
||||
|
||||
sx = av_clip(sx, 0, w - 1);
|
||||
sy = av_clip(sy, 0, h - 1);
|
||||
ex = av_clip(ex, 0, w - 1);
|
||||
ey = av_clip(ey, 0, h - 1);
|
||||
|
||||
buf[sy * stride + sx] += color;
|
||||
|
||||
if (FFABS(ex - sx) > FFABS(ey - sy)) {
|
||||
if (sx > ex) {
|
||||
FFSWAP(int, sx, ex);
|
||||
FFSWAP(int, sy, ey);
|
||||
}
|
||||
buf += sx + sy * stride;
|
||||
ex -= sx;
|
||||
f = ((ey - sy) << 16) / ex;
|
||||
for (x = 0; x <= ex; x++) {
|
||||
y = (x * f) >> 16;
|
||||
fr = (x * f) & 0xFFFF;
|
||||
buf[y * stride + x] += (color * (0x10000 - fr)) >> 16;
|
||||
buf[(y + 1) * stride + x] += (color * fr ) >> 16;
|
||||
}
|
||||
} else {
|
||||
if (sy > ey) {
|
||||
FFSWAP(int, sx, ex);
|
||||
FFSWAP(int, sy, ey);
|
||||
}
|
||||
buf += sx + sy * stride;
|
||||
ey -= sy;
|
||||
if (ey)
|
||||
f = ((ex - sx) << 16) / ey;
|
||||
else
|
||||
f = 0;
|
||||
for (y = 0; y = ey; y++) {
|
||||
x = (y * f) >> 16;
|
||||
fr = (y * f) & 0xFFFF;
|
||||
buf[y * stride + x] += (color * (0x10000 - fr)) >> 16;
|
||||
buf[y * stride + x + 1] += (color * fr ) >> 16;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Draw an arrow from (ex, ey) -> (sx, sy).
|
||||
* @param w width of the image
|
||||
* @param h height of the image
|
||||
* @param stride stride/linesize of the image
|
||||
* @param color color of the arrow
|
||||
*/
|
||||
static void draw_arrow(uint8_t *buf, int sx, int sy, int ex,
|
||||
int ey, int w, int h, int stride, int color)
|
||||
{
|
||||
int dx,dy;
|
||||
|
||||
sx = av_clip(sx, -100, w + 100);
|
||||
sy = av_clip(sy, -100, h + 100);
|
||||
ex = av_clip(ex, -100, w + 100);
|
||||
ey = av_clip(ey, -100, h + 100);
|
||||
|
||||
dx = ex - sx;
|
||||
dy = ey - sy;
|
||||
|
||||
if (dx * dx + dy * dy > 3 * 3) {
|
||||
int rx = dx + dy;
|
||||
int ry = -dx + dy;
|
||||
int length = ff_sqrt((rx * rx + ry * ry) << 8);
|
||||
|
||||
// FIXME subpixel accuracy
|
||||
rx = ROUNDED_DIV(rx * 3 << 4, length);
|
||||
ry = ROUNDED_DIV(ry * 3 << 4, length);
|
||||
|
||||
draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
|
||||
draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
|
||||
}
|
||||
draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
|
||||
}
|
||||
|
||||
/**
|
||||
* Print debugging info for the given picture.
|
||||
*/
|
||||
@ -1991,214 +1890,6 @@ void ff_print_debug_info(MpegEncContext *s, Picture *p)
|
||||
av_log(s->avctx, AV_LOG_DEBUG, "\n");
|
||||
}
|
||||
}
|
||||
|
||||
if ((s->avctx->debug & (FF_DEBUG_VIS_QP | FF_DEBUG_VIS_MB_TYPE)) ||
|
||||
(s->avctx->debug_mv)) {
|
||||
const int shift = 1 + s->quarter_sample;
|
||||
int mb_y;
|
||||
uint8_t *ptr;
|
||||
int i;
|
||||
int h_chroma_shift, v_chroma_shift, block_height;
|
||||
const int width = s->avctx->width;
|
||||
const int height = s->avctx->height;
|
||||
const int mv_sample_log2 = 4 - pict->motion_subsample_log2;
|
||||
const int mv_stride = (s->mb_width << mv_sample_log2) +
|
||||
(s->codec_id == AV_CODEC_ID_H264 ? 0 : 1);
|
||||
s->low_delay = 0; // needed to see the vectors without trashing the buffers
|
||||
|
||||
av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt,
|
||||
&h_chroma_shift, &v_chroma_shift);
|
||||
for (i = 0; i < 3; i++) {
|
||||
memcpy(s->visualization_buffer[i], pict->data[i],
|
||||
(i == 0) ? pict->linesize[i] * height:
|
||||
pict->linesize[i] * height >> v_chroma_shift);
|
||||
pict->data[i] = s->visualization_buffer[i];
|
||||
}
|
||||
ptr = pict->data[0];
|
||||
block_height = 16 >> v_chroma_shift;
|
||||
|
||||
for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
|
||||
int mb_x;
|
||||
for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
|
||||
const int mb_index = mb_x + mb_y * s->mb_stride;
|
||||
if ((s->avctx->debug_mv) && p->motion_val) {
|
||||
int type;
|
||||
for (type = 0; type < 3; type++) {
|
||||
int direction = 0;
|
||||
switch (type) {
|
||||
case 0:
|
||||
if ((!(s->avctx->debug_mv & FF_DEBUG_VIS_MV_P_FOR)) ||
|
||||
(pict->pict_type!= AV_PICTURE_TYPE_P))
|
||||
continue;
|
||||
direction = 0;
|
||||
break;
|
||||
case 1:
|
||||
if ((!(s->avctx->debug_mv & FF_DEBUG_VIS_MV_B_FOR)) ||
|
||||
(pict->pict_type!= AV_PICTURE_TYPE_B))
|
||||
continue;
|
||||
direction = 0;
|
||||
break;
|
||||
case 2:
|
||||
if ((!(s->avctx->debug_mv & FF_DEBUG_VIS_MV_B_BACK)) ||
|
||||
(pict->pict_type!= AV_PICTURE_TYPE_B))
|
||||
continue;
|
||||
direction = 1;
|
||||
break;
|
||||
}
|
||||
if (!USES_LIST(p->mb_type[mb_index], direction))
|
||||
continue;
|
||||
|
||||
if (IS_8X8(p->mb_type[mb_index])) {
|
||||
int i;
|
||||
for (i = 0; i < 4; i++) {
|
||||
int sx = mb_x * 16 + 4 + 8 * (i & 1);
|
||||
int sy = mb_y * 16 + 4 + 8 * (i >> 1);
|
||||
int xy = (mb_x * 2 + (i & 1) +
|
||||
(mb_y * 2 + (i >> 1)) * mv_stride) << (mv_sample_log2 - 1);
|
||||
int mx = (p->motion_val[direction][xy][0] >> shift) + sx;
|
||||
int my = (p->motion_val[direction][xy][1] >> shift) + sy;
|
||||
draw_arrow(ptr, sx, sy, mx, my, width,
|
||||
height, s->linesize, 100);
|
||||
}
|
||||
} else if (IS_16X8(p->mb_type[mb_index])) {
|
||||
int i;
|
||||
for (i = 0; i < 2; i++) {
|
||||
int sx = mb_x * 16 + 8;
|
||||
int sy = mb_y * 16 + 4 + 8 * i;
|
||||
int xy = (mb_x * 2 + (mb_y * 2 + i) * mv_stride) << (mv_sample_log2 - 1);
|
||||
int mx = (p->motion_val[direction][xy][0] >> shift);
|
||||
int my = (p->motion_val[direction][xy][1] >> shift);
|
||||
|
||||
if (IS_INTERLACED(p->mb_type[mb_index]))
|
||||
my *= 2;
|
||||
|
||||
draw_arrow(ptr, sx, sy, mx + sx, my + sy, width,
|
||||
height, s->linesize, 100);
|
||||
}
|
||||
} else if (IS_8X16(p->mb_type[mb_index])) {
|
||||
int i;
|
||||
for (i = 0; i < 2; i++) {
|
||||
int sx = mb_x * 16 + 4 + 8 * i;
|
||||
int sy = mb_y * 16 + 8;
|
||||
int xy = (mb_x * 2 + i + mb_y * 2 * mv_stride) << (mv_sample_log2 - 1);
|
||||
int mx = p->motion_val[direction][xy][0] >> shift;
|
||||
int my = p->motion_val[direction][xy][1] >> shift;
|
||||
|
||||
if (IS_INTERLACED(p->mb_type[mb_index]))
|
||||
my *= 2;
|
||||
|
||||
draw_arrow(ptr, sx, sy, mx + sx, my + sy, width,
|
||||
height, s->linesize, 100);
|
||||
}
|
||||
} else {
|
||||
int sx = mb_x * 16 + 8;
|
||||
int sy = mb_y * 16 + 8;
|
||||
int xy = (mb_x + mb_y * mv_stride) << mv_sample_log2;
|
||||
int mx = p->motion_val[direction][xy][0] >> shift + sx;
|
||||
int my = p->motion_val[direction][xy][1] >> shift + sy;
|
||||
draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
|
||||
}
|
||||
}
|
||||
}
|
||||
if ((s->avctx->debug & FF_DEBUG_VIS_QP) && p->motion_val) {
|
||||
uint64_t c = (p->qscale_table[mb_index] * 128 / 31) *
|
||||
0x0101010101010101ULL;
|
||||
int y;
|
||||
for (y = 0; y < block_height; y++) {
|
||||
*(uint64_t *)(pict->data[1] + 8 * mb_x +
|
||||
(block_height * mb_y + y) *
|
||||
pict->linesize[1]) = c;
|
||||
*(uint64_t *)(pict->data[2] + 8 * mb_x +
|
||||
(block_height * mb_y + y) *
|
||||
pict->linesize[2]) = c;
|
||||
}
|
||||
}
|
||||
if ((s->avctx->debug & FF_DEBUG_VIS_MB_TYPE) &&
|
||||
p->motion_val) {
|
||||
int mb_type = p->mb_type[mb_index];
|
||||
uint64_t u,v;
|
||||
int y;
|
||||
#define COLOR(theta, r) \
|
||||
u = (int)(128 + r * cos(theta * 3.141592 / 180)); \
|
||||
v = (int)(128 + r * sin(theta * 3.141592 / 180));
|
||||
|
||||
|
||||
u = v = 128;
|
||||
if (IS_PCM(mb_type)) {
|
||||
COLOR(120, 48)
|
||||
} else if ((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) ||
|
||||
IS_INTRA16x16(mb_type)) {
|
||||
COLOR(30, 48)
|
||||
} else if (IS_INTRA4x4(mb_type)) {
|
||||
COLOR(90, 48)
|
||||
} else if (IS_DIRECT(mb_type) && IS_SKIP(mb_type)) {
|
||||
// COLOR(120, 48)
|
||||
} else if (IS_DIRECT(mb_type)) {
|
||||
COLOR(150, 48)
|
||||
} else if (IS_GMC(mb_type) && IS_SKIP(mb_type)) {
|
||||
COLOR(170, 48)
|
||||
} else if (IS_GMC(mb_type)) {
|
||||
COLOR(190, 48)
|
||||
} else if (IS_SKIP(mb_type)) {
|
||||
// COLOR(180, 48)
|
||||
} else if (!USES_LIST(mb_type, 1)) {
|
||||
COLOR(240, 48)
|
||||
} else if (!USES_LIST(mb_type, 0)) {
|
||||
COLOR(0, 48)
|
||||
} else {
|
||||
assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
|
||||
COLOR(300,48)
|
||||
}
|
||||
|
||||
u *= 0x0101010101010101ULL;
|
||||
v *= 0x0101010101010101ULL;
|
||||
for (y = 0; y < block_height; y++) {
|
||||
*(uint64_t *)(pict->data[1] + 8 * mb_x +
|
||||
(block_height * mb_y + y) * pict->linesize[1]) = u;
|
||||
*(uint64_t *)(pict->data[2] + 8 * mb_x +
|
||||
(block_height * mb_y + y) * pict->linesize[2]) = v;
|
||||
}
|
||||
|
||||
// segmentation
|
||||
if (IS_8X8(mb_type) || IS_16X8(mb_type)) {
|
||||
*(uint64_t *)(pict->data[0] + 16 * mb_x + 0 +
|
||||
(16 * mb_y + 8) * pict->linesize[0]) ^= 0x8080808080808080ULL;
|
||||
*(uint64_t *)(pict->data[0] + 16 * mb_x + 8 +
|
||||
(16 * mb_y + 8) * pict->linesize[0]) ^= 0x8080808080808080ULL;
|
||||
}
|
||||
if (IS_8X8(mb_type) || IS_8X16(mb_type)) {
|
||||
for (y = 0; y < 16; y++)
|
||||
pict->data[0][16 * mb_x + 8 + (16 * mb_y + y) *
|
||||
pict->linesize[0]] ^= 0x80;
|
||||
}
|
||||
if (IS_8X8(mb_type) && mv_sample_log2 >= 2) {
|
||||
int dm = 1 << (mv_sample_log2 - 2);
|
||||
for (i = 0; i < 4; i++) {
|
||||
int sx = mb_x * 16 + 8 * (i & 1);
|
||||
int sy = mb_y * 16 + 8 * (i >> 1);
|
||||
int xy = (mb_x * 2 + (i & 1) +
|
||||
(mb_y * 2 + (i >> 1)) * mv_stride) << (mv_sample_log2 - 1);
|
||||
// FIXME bidir
|
||||
int32_t *mv = (int32_t *) &p->motion_val[0][xy];
|
||||
if (mv[0] != mv[dm] ||
|
||||
mv[dm * mv_stride] != mv[dm * (mv_stride + 1)])
|
||||
for (y = 0; y < 8; y++)
|
||||
pict->data[0][sx + 4 + (sy + y) * pict->linesize[0]] ^= 0x80;
|
||||
if (mv[0] != mv[dm * mv_stride] || mv[dm] != mv[dm * (mv_stride + 1)])
|
||||
*(uint64_t *)(pict->data[0] + sx + (sy + 4) *
|
||||
pict->linesize[0]) ^= 0x8080808080808080ULL;
|
||||
}
|
||||
}
|
||||
|
||||
if (IS_INTERLACED(mb_type) &&
|
||||
s->codec_id == AV_CODEC_ID_H264) {
|
||||
// hmm
|
||||
}
|
||||
}
|
||||
s->mbskip_table[mb_index] = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
|
||||
@ -340,7 +340,6 @@ typedef struct MpegEncContext {
|
||||
Picture *last_picture_ptr; ///< pointer to the previous picture.
|
||||
Picture *next_picture_ptr; ///< pointer to the next picture (for bidir pred)
|
||||
Picture *current_picture_ptr; ///< pointer to the current picture
|
||||
uint8_t *visualization_buffer[3]; ///< temporary buffer vor MV visualization
|
||||
int last_dc[3]; ///< last DC values for MPEG1
|
||||
int16_t *dc_val_base;
|
||||
int16_t *dc_val[3]; ///< used for mpeg4 DC prediction, all 3 arrays must be continuous
|
||||
|
||||
Loading…
Reference in New Issue
Block a user