git.sesse.net Git - ffmpeg/blob - libavdevice/caca.c

   1 /*
   2  * Copyright (c) 2012 Paul B Mahol
   3  *
   4  * This file is part of FFmpeg.
   5  *
   6  * FFmpeg is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * FFmpeg is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with FFmpeg; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  19  */
  20
  21 #include <caca.h>
  22 #include "libavutil/opt.h"
  23 #include "libavutil/pixdesc.h"
  24 #include "avdevice.h"
  25
  26 typedef struct CACAContext {
  27     AVClass         *class;
  28     AVFormatContext *ctx;
  29     char            *window_title;
  30     int             window_width,  window_height;
  31
  32     caca_canvas_t   *canvas;
  33     caca_display_t  *display;
  34     caca_dither_t   *dither;
  35
  36     char            *algorithm, *antialias;
  37     char            *charset, *color;
  38     char            *driver;
  39
  40     char            *list_dither;
  41     int             list_drivers;
  42 } CACAContext;
  43
  44 static int caca_write_trailer(AVFormatContext *s)
  45 {
  46     CACAContext *c = s->priv_data;
  47
  48     av_freep(&c->window_title);
  49
  50     if (c->display) {
  51         caca_free_display(c->display);
  52         c->display = NULL;
  53     }
  54     if (c->dither) {
  55         caca_free_dither(c->dither);
  56         c->dither = NULL;
  57     }
  58     if (c->canvas) {
  59         caca_free_canvas(c->canvas);
  60         c->canvas = NULL;
  61     }
  62     return 0;
  63 }
  64
  65 static void list_drivers(CACAContext *c)
  66 {
  67     const char *const *drivers = caca_get_display_driver_list();
  68     int i;
  69
  70     av_log(c->ctx, AV_LOG_INFO, "Available drivers:\n");
  71     for (i = 0; drivers[i]; i += 2)
  72         av_log(c->ctx, AV_LOG_INFO, "%s: %s\n", drivers[i], drivers[i + 1]);
  73 }
  74
  75 #define DEFINE_LIST_DITHER(thing, thing_str)                                 \
  76 static void list_dither_## thing(CACAContext *c)                             \
  77 {                                                                            \
  78     const char *const *thing = caca_get_dither_## thing ##_list(c->dither);  \
  79     int i;                                                                   \
  80                                                                              \
  81     av_log(c->ctx, AV_LOG_INFO, "Available %s:\n", thing_str);               \
  82     for (i = 0; thing[i]; i += 2)                                            \
  83         av_log(c->ctx, AV_LOG_INFO, "%s: %s\n", thing[i], thing[i + 1]);     \
  84 }
  85
  86 DEFINE_LIST_DITHER(color, "colors");
  87 DEFINE_LIST_DITHER(charset, "charsets");
  88 DEFINE_LIST_DITHER(algorithm, "algorithms");
  89 DEFINE_LIST_DITHER(antialias, "antialias");
  90
  91 static int caca_write_header(AVFormatContext *s)
  92 {
  93     CACAContext *c = s->priv_data;
  94     AVStream *st = s->streams[0];
  95     AVCodecContext *encctx = st->codec;
  96     int ret, bpp;
  97
  98     c->ctx = s;
  99     if (c->list_drivers) {
 100         list_drivers(c);
 101         return AVERROR_EXIT;
 102     }
 103     if (c->list_dither) {
 104         if (!strcmp(c->list_dither, "colors")) {
 105             list_dither_color(c);
 106         } else if (!strcmp(c->list_dither, "charsets")) {
 107             list_dither_charset(c);
 108         } else if (!strcmp(c->list_dither, "algorithms")) {
 109             list_dither_algorithm(c);
 110         } else if (!strcmp(c->list_dither, "antialiases")) {
 111             list_dither_antialias(c);
 112         } else {
 113             av_log(s, AV_LOG_ERROR,
 114                    "Invalid argument '%s', for 'list_dither' option\n"
 115                    "Argument must be one of 'algorithms, 'antialiases', 'charsets', 'colors'\n",
 116                    c->list_dither);
 117             return AVERROR(EINVAL);
 118         }
 119         return AVERROR_EXIT;
 120     }
 121
 122     if (   s->nb_streams > 1
 123         || encctx->codec_type != AVMEDIA_TYPE_VIDEO
 124         || encctx->codec_id   != AV_CODEC_ID_RAWVIDEO) {
 125         av_log(s, AV_LOG_ERROR, "Only supports one rawvideo stream\n");
 126         return AVERROR(EINVAL);
 127     }
 128
 129     if (encctx->pix_fmt != AV_PIX_FMT_RGB24) {
 130         av_log(s, AV_LOG_ERROR,
 131                "Unsupported pixel format '%s', choose rgb24\n",
 132                av_get_pix_fmt_name(encctx->pix_fmt));
 133         return AVERROR(EINVAL);
 134     }
 135
 136     c->canvas = caca_create_canvas(c->window_width, c->window_height);
 137     if (!c->canvas) {
 138         ret = AVERROR(errno);
 139         av_log(s, AV_LOG_ERROR, "Failed to create canvas\n");
 140         goto fail;
 141     }
 142
 143     bpp = av_get_bits_per_pixel(av_pix_fmt_desc_get(encctx->pix_fmt));
 144     c->dither = caca_create_dither(bpp, encctx->width, encctx->height,
 145                                    bpp / 8 * encctx->width,
 146                                    0x0000ff, 0x00ff00, 0xff0000, 0);
 147     if (!c->dither) {
 148         ret =  AVERROR(errno);
 149         av_log(s, AV_LOG_ERROR, "Failed to create dither\n");
 150         goto fail;
 151     }
 152
 153 #define CHECK_DITHER_OPT(opt) do {                                              \
 154     if (caca_set_dither_##opt(c->dither, c->opt) < 0)  {                        \
 155         ret = AVERROR(errno);                                                   \
 156         av_log(s, AV_LOG_ERROR, "Failed to set value '%s' for option '%s'\n",   \
 157                c->opt, #opt);                                                   \
 158         goto fail;                                                              \
 159     }                                                                           \
 160 } while (0)
 161
 162     CHECK_DITHER_OPT(algorithm);
 163     CHECK_DITHER_OPT(antialias);
 164     CHECK_DITHER_OPT(charset);
 165     CHECK_DITHER_OPT(color);
 166
 167     c->display = caca_create_display_with_driver(c->canvas, c->driver);
 168     if (!c->display) {
 169         ret = AVERROR(errno);
 170         av_log(s, AV_LOG_ERROR, "Failed to create display\n");
 171         list_drivers(c);
 172         goto fail;
 173     }
 174
 175     if (!c->window_width || !c->window_height) {
 176         c->window_width  = caca_get_canvas_width(c->canvas);
 177         c->window_height = caca_get_canvas_height(c->canvas);
 178     }
 179
 180     if (!c->window_title)
 181         c->window_title = av_strdup(s->filename);
 182     caca_set_display_title(c->display, c->window_title);
 183     caca_set_display_time(c->display, av_rescale_q(1, st->codec->time_base, AV_TIME_BASE_Q));
 184
 185     return 0;
 186
 187 fail:
 188     caca_write_trailer(s);
 189     return ret;
 190 }
 191
 192 static int caca_write_packet(AVFormatContext *s, AVPacket *pkt)
 193 {
 194     CACAContext *c = s->priv_data;
 195
 196     caca_dither_bitmap(c->canvas, 0, 0, c->window_width, c->window_height, c->dither, pkt->data);
 197     caca_refresh_display(c->display);
 198
 199     return 0;
 200 }
 201
 202 #define OFFSET(x) offsetof(CACAContext,x)
 203 #define ENC AV_OPT_FLAG_ENCODING_PARAM
 204
 205 static const AVOption options[] = {
 206     { "window_size",  "set window forced size",  OFFSET(window_width), AV_OPT_TYPE_IMAGE_SIZE, {.str = NULL }, 0, 0, ENC},
 207     { "window_title", "set window title",        OFFSET(window_title), AV_OPT_TYPE_STRING,     {.str = NULL }, 0, 0, ENC },
 208     { "driver",       "set display driver",      OFFSET(driver),    AV_OPT_TYPE_STRING, {.str = NULL }, 0, 0, ENC },
 209     { "algorithm",    "set dithering algorithm", OFFSET(algorithm), AV_OPT_TYPE_STRING, {.str = "default" }, 0, 0, ENC },
 210     { "antialias",    "set antialias method",    OFFSET(antialias), AV_OPT_TYPE_STRING, {.str = "default" }, 0, 0, ENC },
 211     { "charset",      "set charset used to render output", OFFSET(charset), AV_OPT_TYPE_STRING, {.str = "default" }, 0, 0, ENC },
 212     { "color",        "set color used to render output",   OFFSET(color),   AV_OPT_TYPE_STRING, {.str = "default" }, 0, 0, ENC },
 213     { "list_drivers", "list available drivers",  OFFSET(list_drivers), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, ENC },
 214     { "list_dither", "list available dither options", OFFSET(list_dither), AV_OPT_TYPE_STRING, {.str=NULL}, 0, 1, ENC, "list_dither" },
 215     { "algorithms",   NULL, 0, AV_OPT_TYPE_CONST, {.str = "algorithms"}, 0, 0, ENC, "list_dither" },
 216     { "antialiases",  NULL, 0, AV_OPT_TYPE_CONST, {.str = "antialiases"},0, 0, ENC, "list_dither" },
 217     { "charsets",     NULL, 0, AV_OPT_TYPE_CONST, {.str = "charsets"},   0, 0, ENC, "list_dither" },
 218     { "colors",       NULL, 0, AV_OPT_TYPE_CONST, {.str = "colors"},     0, 0, ENC, "list_dither" },
 219     { NULL },
 220 };
 221
 222 static const AVClass caca_class = {
 223     .class_name = "caca_outdev",
 224     .item_name  = av_default_item_name,
 225     .option     = options,
 226     .version    = LIBAVUTIL_VERSION_INT,
 227     .category   = AV_CLASS_CATEGORY_DEVICE_VIDEO_OUTPUT,
 228 };
 229
 230 AVOutputFormat ff_caca_muxer = {
 231     .name           = "caca",
 232     .long_name      = NULL_IF_CONFIG_SMALL("caca (color ASCII art) output device"),
 233     .priv_data_size = sizeof(CACAContext),
 234     .audio_codec    = AV_CODEC_ID_NONE,
 235     .video_codec    = AV_CODEC_ID_RAWVIDEO,
 236     .write_header   = caca_write_header,
 237     .write_packet   = caca_write_packet,
 238     .write_trailer  = caca_write_trailer,
 239     .flags          = AVFMT_NOFILE,
 240     .priv_class     = &caca_class,
 241 };