mpv/video/out/vo_sixel.c

636 lines
20 KiB
C
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

/*
* Sixel mpv output device implementation based on ffmpeg libavdevice implementation
* by Hayaki Saito
* https://github.com/saitoha/FFmpeg-SIXEL/blob/sixel/libavdevice/sixel.c
*
* Copyright (c) 2014 Hayaki Saito
*
* This file is part of mpv.
*
* mpv is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* mpv is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with mpv. If not, see <http://www.gnu.org/licenses/>.
*/
#include <stdio.h>
#include <stdlib.h>
#include <libswscale/swscale.h>
#include <sixel.h>
#include "config.h"
#include "options/m_config.h"
#include "osdep/terminal.h"
#include "sub/osd.h"
#include "vo.h"
#include "video/sws_utils.h"
#include "video/mp_image.h"
#if HAVE_POSIX
#include <unistd.h>
#endif
#define IMGFMT IMGFMT_RGB24
#define TERM_ESC_USE_GLOBAL_COLOR_REG "\033[?1070l"
#define TERMINAL_FALLBACK_COLS 80
#define TERMINAL_FALLBACK_ROWS 25
#define TERMINAL_FALLBACK_PX_WIDTH 320
#define TERMINAL_FALLBACK_PX_HEIGHT 240
struct vo_sixel_opts {
int diffuse;
int reqcolors;
int fixedpal;
int threshold;
int width, height, top, left;
int pad_y, pad_x;
int rows, cols;
int config_clear, alt_screen;
int buffered;
};
struct priv {
// User specified options
struct vo_sixel_opts opts;
// Internal data
sixel_output_t *output;
sixel_dither_t *dither;
sixel_dither_t *testdither;
uint8_t *buffer;
char *sixel_output_buf;
bool skip_frame_draw;
int left, top; // image origin cell (1 based)
int width, height; // actual image px size - always reflects dst_rect.
int num_cols, num_rows; // terminal size in cells
int canvas_ok; // whether canvas vo->dwidth and vo->dheight are positive
int previous_histgram_colors;
struct mp_rect src_rect;
struct mp_rect dst_rect;
struct mp_osd_res osd;
struct mp_image *frame;
struct mp_sws_context *sws;
};
static const unsigned int depth = 3;
static int detect_scene_change(struct vo* vo)
{
struct priv* priv = vo->priv;
int previous_histgram_colors = priv->previous_histgram_colors;
int histgram_colors = 0;
// If threshold is set negative, then every frame must be a scene change
if (priv->dither == NULL || priv->opts.threshold < 0)
return 1;
histgram_colors = sixel_dither_get_num_of_histogram_colors(priv->testdither);
int color_difference_count = previous_histgram_colors - histgram_colors;
color_difference_count = (color_difference_count > 0) ? // abs value
color_difference_count : -color_difference_count;
if (100 * color_difference_count >
priv->opts.threshold * previous_histgram_colors)
{
priv->previous_histgram_colors = histgram_colors; // update history
return 1;
} else {
return 0;
}
}
static void dealloc_dithers_and_buffers(struct vo* vo)
{
struct priv* priv = vo->priv;
if (priv->buffer) {
talloc_free(priv->buffer);
priv->buffer = NULL;
}
if (priv->frame) {
talloc_free(priv->frame);
priv->frame = NULL;
}
if (priv->dither) {
sixel_dither_unref(priv->dither);
priv->dither = NULL;
}
if (priv->testdither) {
sixel_dither_unref(priv->testdither);
priv->testdither = NULL;
}
}
static SIXELSTATUS prepare_static_palette(struct vo* vo)
{
struct priv* priv = vo->priv;
if (!priv->dither) {
priv->dither = sixel_dither_get(BUILTIN_XTERM256);
if (priv->dither == NULL)
return SIXEL_FALSE;
sixel_dither_set_diffusion_type(priv->dither, priv->opts.diffuse);
}
sixel_dither_set_body_only(priv->dither, 0);
return SIXEL_OK;
}
static SIXELSTATUS prepare_dynamic_palette(struct vo *vo)
{
SIXELSTATUS status = SIXEL_FALSE;
struct priv *priv = vo->priv;
/* create histgram and construct color palette
* with median cut algorithm. */
status = sixel_dither_initialize(priv->testdither, priv->buffer,
priv->width, priv->height,
SIXEL_PIXELFORMAT_RGB888,
LARGE_NORM, REP_CENTER_BOX,
QUALITY_LOW);
if (SIXEL_FAILED(status))
return status;
if (detect_scene_change(vo)) {
if (priv->dither) {
sixel_dither_unref(priv->dither);
priv->dither = NULL;
}
priv->dither = priv->testdither;
status = sixel_dither_new(&priv->testdither, priv->opts.reqcolors, NULL);
if (SIXEL_FAILED(status))
return status;
sixel_dither_set_diffusion_type(priv->dither, priv->opts.diffuse);
} else {
if (priv->dither == NULL)
return SIXEL_FALSE;
}
sixel_dither_set_body_only(priv->dither, 0);
return status;
}
static void update_canvas_dimensions(struct vo *vo)
{
// this function sets the vo canvas size in pixels vo->dwidth, vo->dheight,
// and the number of rows and columns available in priv->num_rows/cols
struct priv *priv = vo->priv;
int num_rows = TERMINAL_FALLBACK_ROWS;
int num_cols = TERMINAL_FALLBACK_COLS;
int total_px_width = 0;
int total_px_height = 0;
terminal_get_size2(&num_rows, &num_cols, &total_px_width, &total_px_height);
// If the user has specified rows/cols use them for further calculations
num_rows = (priv->opts.rows > 0) ? priv->opts.rows : num_rows;
num_cols = (priv->opts.cols > 0) ? priv->opts.cols : num_cols;
// If the pad value is set in between 0 and width/2 - 1, then we
// subtract from the detected width. Otherwise, we assume that the width
// output must be a integer multiple of num_cols and accordingly set
// total_width to be an integer multiple of num_cols. So in case the padding
// added by terminal is less than the number of cells in that axis, then rounding
// down will take care of correcting the detected width and remove padding.
if (priv->opts.width > 0) {
// option - set by the user, hard truth
total_px_width = priv->opts.width;
} else {
if (total_px_width <= 0) {
// ioctl failed to read terminal width
total_px_width = TERMINAL_FALLBACK_PX_WIDTH;
} else {
if (priv->opts.pad_x >= 0 && priv->opts.pad_x < total_px_width / 2) {
// explicit padding set by the user
total_px_width -= (2 * priv->opts.pad_x);
} else {
// rounded "auto padding"
total_px_width = total_px_width / num_cols * num_cols;
}
}
}
if (priv->opts.height > 0) {
total_px_height = priv->opts.height;
} else {
if (total_px_height <= 0) {
total_px_height = TERMINAL_FALLBACK_PX_HEIGHT;
} else {
if (priv->opts.pad_y >= 0 && priv->opts.pad_y < total_px_height / 2) {
total_px_height -= (2 * priv->opts.pad_y);
} else {
total_px_height = total_px_height / num_rows * num_rows;
}
}
}
// use n-1 rows for height
// The last row can't be used for encoding image, because after sixel encode
// the terminal moves the cursor to next line below the image, causing the
// last line to be empty instead of displaying image data.
// TODO: Confirm if the output height must be a multiple of 6, if not, remove
// the / 6 * 6 part which is setting the height to be a multiple of 6.
vo->dheight = total_px_height * (num_rows - 1) / num_rows / 6 * 6;
vo->dwidth = total_px_width;
priv->num_rows = num_rows;
priv->num_cols = num_cols;
priv->canvas_ok = vo->dwidth > 0 && vo->dheight > 0;
}
static void set_sixel_output_parameters(struct vo *vo)
{
// This function sets output scaled size in priv->width, priv->height
// and the scaling rectangles in pixels priv->src_rect, priv->dst_rect
// as well as image positioning in cells priv->top, priv->left.
struct priv *priv = vo->priv;
vo_get_src_dst_rects(vo, &priv->src_rect, &priv->dst_rect, &priv->osd);
// priv->width and priv->height are the width and height of dst_rect
// and they are not changed anywhere else outside this function.
// It is the sixel image output dimension which is output by libsixel.
priv->width = priv->dst_rect.x1 - priv->dst_rect.x0;
priv->height = priv->dst_rect.y1 - priv->dst_rect.y0;
// top/left values must be greater than 1. If it is set, then
// the image will be rendered from there and no further centering is done.
priv->top = (priv->opts.top > 0) ? priv->opts.top :
priv->num_rows * priv->dst_rect.y0 / vo->dheight + 1;
priv->left = (priv->opts.left > 0) ? priv->opts.left :
priv->num_cols * priv->dst_rect.x0 / vo->dwidth + 1;
}
static int update_sixel_swscaler(struct vo *vo, struct mp_image_params *params)
{
struct priv *priv = vo->priv;
priv->sws->src = *params;
priv->sws->src.w = mp_rect_w(priv->src_rect);
priv->sws->src.h = mp_rect_h(priv->src_rect);
priv->sws->dst = (struct mp_image_params) {
.imgfmt = IMGFMT,
.w = priv->width,
.h = priv->height,
.p_w = 1,
.p_h = 1,
};
dealloc_dithers_and_buffers(vo);
priv->frame = mp_image_alloc(IMGFMT, priv->width, priv->height);
if (!priv->frame)
return -1;
if (mp_sws_reinit(priv->sws) < 0)
return -1;
// create testdither only if dynamic palette mode is set
if (!priv->opts.fixedpal) {
SIXELSTATUS status = sixel_dither_new(&priv->testdither,
priv->opts.reqcolors, NULL);
if (SIXEL_FAILED(status)) {
MP_ERR(vo, "update_sixel_swscaler: Failed to create new dither: %s\n",
sixel_helper_format_error(status));
return -1;
}
}
priv->buffer =
talloc_array(NULL, uint8_t, depth * priv->width * priv->height);
return 0;
}
static inline int sixel_buffer(char *data, int size, void *priv) {
char **out = (char **)priv;
*out = talloc_strndup_append_buffer(*out, data, size);
return size;
}
static inline int sixel_write(char *data, int size, void *priv)
{
FILE *p = (FILE *)priv;
// On POSIX platforms, write() is the fastest method. It also is the only
// one that allows atomic writes so mpvs output will not be interrupted
// by other processes or threads that write to stdout, which would cause
// screen corruption. POSIX does not guarantee atomicity for writes
// exceeding PIPE_BUF, but at least Linux does seem to implement it that
// way.
#if HAVE_POSIX
int remain = size;
while (remain > 0) {
ssize_t written = write(fileno(p), data, remain);
if (written < 0)
return written;
remain -= written;
data += written;
}
return size;
#else
int ret = fwrite(data, 1, size, p);
fflush(p);
return ret;
#endif
}
static inline void sixel_strwrite(char *s)
{
sixel_write(s, strlen(s), stdout);
}
static int reconfig(struct vo *vo, struct mp_image_params *params)
{
struct priv *priv = vo->priv;
int ret = 0;
update_canvas_dimensions(vo);
if (priv->canvas_ok) { // if too small - succeed but skip the rendering
set_sixel_output_parameters(vo);
ret = update_sixel_swscaler(vo, params);
}
if (priv->opts.config_clear)
sixel_strwrite(TERM_ESC_CLEAR_SCREEN);
vo->want_redraw = true;
return ret;
}
static void draw_frame(struct vo *vo, struct vo_frame *frame)
{
struct priv *priv = vo->priv;
SIXELSTATUS status;
struct mp_image *mpi = NULL;
int prev_rows = priv->num_rows;
int prev_cols = priv->num_cols;
int prev_height = vo->dheight;
int prev_width = vo->dwidth;
bool resized = false;
update_canvas_dimensions(vo);
if (!priv->canvas_ok)
return;
if (prev_rows != priv->num_rows || prev_cols != priv->num_cols ||
prev_width != vo->dwidth || prev_height != vo->dheight)
{
set_sixel_output_parameters(vo);
// Not checking for vo->config_ok because draw_frame is never called
// with a failed reconfig.
update_sixel_swscaler(vo, vo->params);
if (priv->opts.config_clear)
sixel_strwrite(TERM_ESC_CLEAR_SCREEN);
resized = true;
}
if (frame->repeat && !frame->redraw && !resized) {
// Frame is repeated, and no need to update OSD either
priv->skip_frame_draw = true;
return;
} else {
// Either frame is new, or OSD has to be redrawn
priv->skip_frame_draw = false;
}
// Normal case where we have to draw the frame and the image is not NULL
if (frame->current) {
mpi = mp_image_new_ref(frame->current);
struct mp_rect src_rc = priv->src_rect;
src_rc.x0 = MP_ALIGN_DOWN(src_rc.x0, mpi->fmt.align_x);
src_rc.y0 = MP_ALIGN_DOWN(src_rc.y0, mpi->fmt.align_y);
mp_image_crop_rc(mpi, src_rc);
// scale/pan to our dest rect
mp_sws_scale(priv->sws, priv->frame, mpi);
} else {
// Image is NULL, so need to clear image and draw OSD
mp_image_clear(priv->frame, 0, 0, priv->width, priv->height);
}
struct mp_osd_res dim = {
.w = priv->width,
.h = priv->height
};
osd_draw_on_image(vo->osd, dim, mpi ? mpi->pts : 0, 0, priv->frame);
// Copy from mpv to RGB format as required by libsixel
memcpy_pic(priv->buffer, priv->frame->planes[0], priv->width * depth,
priv->height, priv->width * depth, priv->frame->stride[0]);
// Even if either of these prepare palette functions fail, on re-running them
// they should try to re-initialize the dithers, so it shouldn't dereference
// any NULL pointers. flip_page also has a check to make sure dither is not
// NULL before drawing, so failure in these functions should still be okay.
if (priv->opts.fixedpal) {
status = prepare_static_palette(vo);
} else {
status = prepare_dynamic_palette(vo);
}
if (SIXEL_FAILED(status)) {
MP_WARN(vo, "draw_frame: prepare_palette returned error: %s\n",
sixel_helper_format_error(status));
}
if (mpi)
talloc_free(mpi);
}
static void flip_page(struct vo *vo)
{
struct priv* priv = vo->priv;
if (!priv->canvas_ok)
return;
// If frame is repeated and no update required, then we skip encoding
if (priv->skip_frame_draw)
return;
// Make sure that image and dither are valid before drawing
if (priv->buffer == NULL || priv->dither == NULL)
return;
// Go to the offset row and column, then display the image
priv->sixel_output_buf = talloc_asprintf(NULL, TERM_ESC_GOTO_YX,
priv->top, priv->left);
if (!priv->opts.buffered)
sixel_strwrite(priv->sixel_output_buf);
sixel_encode(priv->buffer, priv->width, priv->height,
depth, priv->dither, priv->output);
if (priv->opts.buffered)
sixel_write(priv->sixel_output_buf,
ta_get_size(priv->sixel_output_buf), stdout);
talloc_free(priv->sixel_output_buf);
}
static int preinit(struct vo *vo)
{
struct priv *priv = vo->priv;
SIXELSTATUS status = SIXEL_FALSE;
// Parse opts set by CLI or conf
priv->sws = mp_sws_alloc(vo);
priv->sws->log = vo->log;
mp_sws_enable_cmdline_opts(priv->sws, vo->global);
if (priv->opts.buffered)
status = sixel_output_new(&priv->output, sixel_buffer,
&priv->sixel_output_buf, NULL);
else
status = sixel_output_new(&priv->output, sixel_write, stdout, NULL);
if (SIXEL_FAILED(status)) {
MP_ERR(vo, "preinit: Failed to create output file: %s\n",
sixel_helper_format_error(status));
return -1;
}
sixel_output_set_encode_policy(priv->output, SIXEL_ENCODEPOLICY_FAST);
if (priv->opts.alt_screen)
sixel_strwrite(TERM_ESC_ALT_SCREEN);
sixel_strwrite(TERM_ESC_HIDE_CURSOR);
/* don't use private color registers for each frame. */
sixel_strwrite(TERM_ESC_USE_GLOBAL_COLOR_REG);
priv->dither = NULL;
// create testdither only if dynamic palette mode is set
if (!priv->opts.fixedpal) {
status = sixel_dither_new(&priv->testdither, priv->opts.reqcolors, NULL);
if (SIXEL_FAILED(status)) {
MP_ERR(vo, "preinit: Failed to create new dither: %s\n",
sixel_helper_format_error(status));
return -1;
}
}
priv->previous_histgram_colors = 0;
return 0;
}
static int query_format(struct vo *vo, int format)
{
return format == IMGFMT;
}
static int control(struct vo *vo, uint32_t request, void *data)
{
if (request == VOCTRL_SET_PANSCAN)
return (vo->config_ok && !reconfig(vo, vo->params)) ? VO_TRUE : VO_FALSE;
return VO_NOTIMPL;
}
static void uninit(struct vo *vo)
{
struct priv *priv = vo->priv;
sixel_strwrite(TERM_ESC_RESTORE_CURSOR);
if (priv->opts.alt_screen)
sixel_strwrite(TERM_ESC_NORMAL_SCREEN);
fflush(stdout);
if (priv->output) {
sixel_output_unref(priv->output);
priv->output = NULL;
}
dealloc_dithers_and_buffers(vo);
}
#define OPT_BASE_STRUCT struct priv
const struct vo_driver video_out_sixel = {
.name = "sixel",
.description = "terminal graphics using sixels",
.preinit = preinit,
.query_format = query_format,
.reconfig = reconfig,
.control = control,
.draw_frame = draw_frame,
.flip_page = flip_page,
.uninit = uninit,
.priv_size = sizeof(struct priv),
.priv_defaults = &(const struct priv) {
.opts.diffuse = DIFFUSE_AUTO,
.opts.width = 0,
.opts.height = 0,
.opts.reqcolors = 256,
.opts.threshold = -1,
.opts.fixedpal = 1,
.opts.top = 0,
.opts.left = 0,
.opts.pad_y = -1,
.opts.pad_x = -1,
.opts.rows = 0,
.opts.cols = 0,
.opts.config_clear = 1,
.opts.alt_screen = 1,
.opts.buffered = 0,
},
.options = (const m_option_t[]) {
{"dither", OPT_CHOICE(opts.diffuse,
{"auto", DIFFUSE_AUTO},
{"none", DIFFUSE_NONE},
{"atkinson", DIFFUSE_ATKINSON},
{"fs", DIFFUSE_FS},
{"jajuni", DIFFUSE_JAJUNI},
{"stucki", DIFFUSE_STUCKI},
{"burkes", DIFFUSE_BURKES},
{"arithmetic", DIFFUSE_A_DITHER},
{"xor", DIFFUSE_X_DITHER})},
{"width", OPT_INT(opts.width)},
{"height", OPT_INT(opts.height)},
{"reqcolors", OPT_INT(opts.reqcolors)},
{"fixedpalette", OPT_FLAG(opts.fixedpal)},
{"threshold", OPT_INT(opts.threshold)},
{"top", OPT_INT(opts.top)},
{"left", OPT_INT(opts.left)},
{"pad-y", OPT_INT(opts.pad_y)},
{"pad-x", OPT_INT(opts.pad_x)},
{"rows", OPT_INT(opts.rows)},
{"cols", OPT_INT(opts.cols)},
{"config-clear", OPT_FLAG(opts.config_clear), },
{"exit-clear", OPT_FLAG(opts.alt_screen),
.deprecation_message = "replaced by --vo-sixel-alt-screen"},
{"alt-screen", OPT_FLAG(opts.alt_screen), },
{"buffered", OPT_FLAG(opts.buffered), },
{0}
},
.options_prefix = "vo-sixel",
};