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, *colors;
  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     caca_free_dither(c->dither);
  51     caca_free_display(c->display);
  52     caca_free_canvas(c->canvas);
  53     return 0;
  54 }
  55
  56 static void list_drivers(CACAContext *c)
  57 {
  58     const char *const *drivers = caca_get_display_driver_list();
  59     int i;
  60
  61     av_log(c->ctx, AV_LOG_INFO, "Available drivers:\n");
  62     for (i = 0; drivers[i]; i += 2)
  63         av_log(c->ctx, AV_LOG_INFO, "%s : %s\n", drivers[i], drivers[i + 1]);
  64 }
  65
  66 #define DEFINE_LIST_DITHER(thing, thing_str)                                 \
  67 static void list_dither_## thing(CACAContext *c)                         \
  68 {                                                                            \
  69     const char *const *thing = caca_get_dither_## thing ##_list(c->dither);  \
  70     int i;                                                                   \
  71                                                                              \
  72     av_log(c->ctx, AV_LOG_INFO, "Available %s:\n", thing_str);               \
  73     for (i = 0; thing[i]; i += 2)                                            \
  74         av_log(c->ctx, AV_LOG_INFO, "%s : %s\n", thing[i], thing[i + 1]);    \
  75 }
  76
  77 DEFINE_LIST_DITHER(color, "colors");
  78 DEFINE_LIST_DITHER(charset, "charsets");
  79 DEFINE_LIST_DITHER(algorithm, "algorithms");
  80 DEFINE_LIST_DITHER(antialias, "antialias");
  81
  82 static int caca_write_header(AVFormatContext *s)
  83 {
  84     CACAContext *c = s->priv_data;
  85     AVStream *st = s->streams[0];
  86     AVCodecContext *encctx = st->codec;
  87     int ret, bpp;
  88
  89     c->ctx = s;
  90     if (c->list_drivers) {
  91         list_drivers(c);
  92         return AVERROR_EXIT;
  93     }
  94     if (c->list_dither) {
  95         if (!strcmp(c->list_dither, "colors")) {
  96             list_dither_color(c);
  97         } else if (!strcmp(c->list_dither, "charsets")) {
  98             list_dither_charset(c);
  99         } else if (!strcmp(c->list_dither, "algorithms")) {
 100             list_dither_algorithm(c);
 101         } else if (!strcmp(c->list_dither, "antialiases")) {
 102             list_dither_antialias(c);
 103         } else {
 104             av_log(s, AV_LOG_ERROR,
 105                    "Invalid value '%s', for 'list_dither' option\n",
 106                    c->list_dither);
 107             return AVERROR(EINVAL);
 108         }
 109         return AVERROR_EXIT;
 110     }
 111
 112     if (   s->nb_streams > 1
 113         || encctx->codec_type != AVMEDIA_TYPE_VIDEO
 114         || encctx->codec_id   != CODEC_ID_RAWVIDEO) {
 115         av_log(s, AV_LOG_ERROR, "Only supports one rawvideo stream\n");
 116         return AVERROR(EINVAL);
 117     }
 118
 119     if (encctx->pix_fmt != PIX_FMT_RGB24) {
 120         av_log(s, AV_LOG_ERROR,
 121                "Unsupported pixel format '%s', choose rgb24\n",
 122                av_get_pix_fmt_name(encctx->pix_fmt));
 123         return AVERROR(EINVAL);
 124     }
 125
 126     c->canvas = caca_create_canvas(c->window_width, c->window_height);
 127     if (!c->canvas) {
 128         av_log(s, AV_LOG_ERROR, "Failed to create canvas\n");
 129         return AVERROR(errno);
 130     }
 131
 132     c->display = caca_create_display_with_driver(c->canvas, c->driver);
 133     if (!c->display) {
 134         av_log(s, AV_LOG_ERROR, "Failed to create display\n");
 135         list_drivers(c);
 136         caca_free_canvas(c->canvas);
 137         return AVERROR(errno);
 138     }
 139
 140     if (!c->window_width || !c->window_height) {
 141         c->window_width  = caca_get_canvas_width(c->canvas);
 142         c->window_height = caca_get_canvas_height(c->canvas);
 143     }
 144
 145     bpp = av_get_bits_per_pixel(&av_pix_fmt_descriptors[encctx->pix_fmt]);
 146     c->dither = caca_create_dither(bpp, encctx->width, encctx->height,
 147                                    bpp / 8 * encctx->width,
 148                                    0x0000ff, 0x00ff00, 0xff0000, 0);
 149     if (!c->dither) {
 150         av_log(s, AV_LOG_ERROR, "Failed to create dither\n");
 151         ret =  AVERROR(errno);
 152         goto fail;
 153     }
 154
 155     ret  = caca_set_dither_algorithm(c->dither, c->algorithm);
 156     ret += caca_set_dither_antialias(c->dither, c->antialias);
 157     ret +=   caca_set_dither_charset(c->dither, c->charset);
 158     ret +=     caca_set_dither_color(c->dither, c->colors);
 159     if (ret) {
 160         av_log(s, AV_LOG_ERROR, "Invalid value given to one of options\n");
 161         ret = AVERROR(EINVAL);
 162         goto fail;
 163     }
 164
 165     if (!c->window_title)
 166         c->window_title = av_strdup(s->filename);
 167     caca_set_display_title(c->display, c->window_title);
 168     caca_set_display_time(c->display, av_rescale_q(1, st->codec->time_base, AV_TIME_BASE_Q));
 169
 170     return 0;
 171
 172 fail:
 173     caca_write_trailer(s);
 174     return ret;
 175 }
 176
 177 static int caca_write_packet(AVFormatContext *s, AVPacket *pkt)
 178 {
 179     CACAContext *c = s->priv_data;
 180
 181     caca_dither_bitmap(c->canvas, 0, 0, c->window_width, c->window_height, c->dither, pkt->data);
 182     caca_refresh_display(c->display);
 183
 184     return 0;
 185 }
 186
 187 #define OFFSET(x) offsetof(CACAContext,x)
 188 #define ENC AV_OPT_FLAG_ENCODING_PARAM
 189
 190 static const AVOption options[] = {
 191     { "window_size",  "set window forced size",  OFFSET(window_width), AV_OPT_TYPE_IMAGE_SIZE, {.str = NULL }, 0, 0, ENC},
 192     { "window_title", "set window title",        OFFSET(window_title), AV_OPT_TYPE_STRING,     {.str = NULL }, 0, 0, ENC },
 193     { "driver",       "set display driver",      OFFSET(driver),    AV_OPT_TYPE_STRING, {.str = NULL }, 0, 0, ENC },
 194     { "algorithm",    "set dithering algorithm", OFFSET(algorithm), AV_OPT_TYPE_STRING, {.str = "default" }, 0, 0, ENC },
 195     { "antialias",    "set antialias method",    OFFSET(antialias), AV_OPT_TYPE_STRING, {.str = "default" }, 0, 0, ENC },
 196     { "charset",      "set charset used to render output", OFFSET(charset), AV_OPT_TYPE_STRING, {.str = "default" }, 0, 0, ENC },
 197     { "colors",       "set colors used to render output",  OFFSET(colors),  AV_OPT_TYPE_STRING, {.str = "default" }, 0, 0, ENC },
 198     { "list_drivers", "list available drivers",  OFFSET(list_drivers), AV_OPT_TYPE_INT, {.dbl=0}, 0, 1, ENC, "list_drivers" },
 199     { "true",         NULL, 0, AV_OPT_TYPE_CONST, {.dbl = 1}, 0, 0, ENC, "list_drivers" },
 200     { "false",        NULL, 0, AV_OPT_TYPE_CONST, {.dbl = 0}, 0, 0, ENC, "list_drivers" },
 201     { "list_dither", "list available dither options", OFFSET(list_dither), AV_OPT_TYPE_STRING, {.dbl=0}, 0, 1, ENC, "list_dither" },
 202     { "colors",       NULL, 0, AV_OPT_TYPE_CONST, {.str = "colors"},     0, 0, ENC, "list_dither" },
 203     { "charsets",     NULL, 0, AV_OPT_TYPE_CONST, {.str = "charsets"},   0, 0, ENC, "list_dither" },
 204     { "antialiases",  NULL, 0, AV_OPT_TYPE_CONST, {.str = "antialiases"},0, 0, ENC, "list_dither" },
 205     { "algorithms",   NULL, 0, AV_OPT_TYPE_CONST, {.str = "algorithms"}, 0, 0, ENC, "list_dither" },
 206     { NULL },
 207 };
 208
 209 static const AVClass caca_class = {
 210     .class_name = "caca_outdev",
 211     .item_name  = av_default_item_name,
 212     .option     = options,
 213     .version    = LIBAVUTIL_VERSION_INT,
 214 };
 215
 216 AVOutputFormat ff_caca_muxer = {
 217     .name           = "caca",
 218     .long_name      = NULL_IF_CONFIG_SMALL("caca (color ASCII art) output device"),
 219     .priv_data_size = sizeof(CACAContext),
 220     .audio_codec    = CODEC_ID_NONE,
 221     .video_codec    = CODEC_ID_RAWVIDEO,
 222     .write_header   = caca_write_header,
 223     .write_packet   = caca_write_packet,
 224     .write_trailer  = caca_write_trailer,
 225     .flags          = AVFMT_NOFILE,
 226     .priv_class     = &caca_class,
 227 };