FFmpeg
caca.c
Go to the documentation of this file.
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/mem.h"
23 #include "libavutil/opt.h"
24 #include "libavutil/pixdesc.h"
25 #include "libavformat/mux.h"
26 #include "avdevice.h"
27 
28 enum {
29  LIST_ALGORITHMS = 1 << 0,
30  LIST_ANTIALIASES = 1 << 1,
31  LIST_CHARSETS = 1 << 2,
32  LIST_COLORS = 1 << 3,
33 };
34 
35 typedef struct CACAContext {
36  AVClass *class;
38  char *window_title;
40 
41  caca_canvas_t *canvas;
42  caca_display_t *display;
43  caca_dither_t *dither;
44 
46  char *charset, *color;
47  char *driver;
48 
51 } CACAContext;
52 
54 {
55  CACAContext *c = s->priv_data;
56 
57  if (c->display) {
58  caca_free_display(c->display);
59  c->display = NULL;
60  }
61  if (c->dither) {
62  caca_free_dither(c->dither);
63  c->dither = NULL;
64  }
65  if (c->canvas) {
66  caca_free_canvas(c->canvas);
67  c->canvas = NULL;
68  }
69 }
70 
71 static void list_drivers(CACAContext *c)
72 {
73  const char *const *drivers = caca_get_display_driver_list();
74  int i;
75 
76  av_log(c->ctx, AV_LOG_INFO, "Available drivers:\n");
77  for (i = 0; drivers[i]; i += 2)
78  av_log(c->ctx, AV_LOG_INFO, "%s: %s\n", drivers[i], drivers[i + 1]);
79 }
80 
81 #define DEFINE_LIST_DITHER(thing, thing_str) \
82 static void list_dither_## thing(CACAContext *c) \
83 { \
84  const char *const *thing = caca_get_dither_## thing ##_list(c->dither); \
85  int i; \
86  \
87  av_log(c->ctx, AV_LOG_INFO, "Available %s:\n", thing_str); \
88  for (i = 0; thing[i]; i += 2) \
89  av_log(c->ctx, AV_LOG_INFO, "%s: %s\n", thing[i], thing[i + 1]); \
90 }
91 
92 DEFINE_LIST_DITHER(color, "colors");
93 DEFINE_LIST_DITHER(charset, "charsets");
94 DEFINE_LIST_DITHER(algorithm, "algorithms");
95 DEFINE_LIST_DITHER(antialias, "antialias");
96 
98 {
99  CACAContext *c = s->priv_data;
100  AVStream *st = s->streams[0];
101  AVCodecParameters *encctx = st->codecpar;
102  int ret, bpp;
103 
104  c->ctx = s;
105  if (c->list_drivers) {
106  list_drivers(c);
107  return AVERROR_EXIT;
108  }
109  if (c->list_dither) {
110  if (c->list_dither & LIST_COLORS)
111  list_dither_color(c);
112  if (c->list_dither & LIST_CHARSETS)
113  list_dither_charset(c);
114  if (c->list_dither & LIST_ALGORITHMS)
115  list_dither_algorithm(c);
116  if (c->list_dither & LIST_ANTIALIASES)
117  list_dither_antialias(c);
118  return AVERROR_EXIT;
119  }
120 
121  if ( s->nb_streams > 1
122  || encctx->codec_type != AVMEDIA_TYPE_VIDEO
123  || encctx->codec_id != AV_CODEC_ID_RAWVIDEO) {
124  av_log(s, AV_LOG_ERROR, "Only supports one rawvideo stream\n");
125  return AVERROR(EINVAL);
126  }
127 
128  if (encctx->format != AV_PIX_FMT_RGB24) {
130  "Unsupported pixel format '%s', choose rgb24\n",
131  av_get_pix_fmt_name(encctx->format));
132  return AVERROR(EINVAL);
133  }
134 
135  c->canvas = caca_create_canvas(c->window_width, c->window_height);
136  if (!c->canvas) {
137  ret = AVERROR(errno);
138  av_log(s, AV_LOG_ERROR, "Failed to create canvas\n");
139  return ret;
140  }
141 
143  c->dither = caca_create_dither(bpp, encctx->width, encctx->height,
144  bpp / 8 * encctx->width,
145  0x0000ff, 0x00ff00, 0xff0000, 0);
146  if (!c->dither) {
147  ret = AVERROR(errno);
148  av_log(s, AV_LOG_ERROR, "Failed to create dither\n");
149  return ret;
150  }
151 
152 #define CHECK_DITHER_OPT(opt) do { \
153  if (caca_set_dither_##opt(c->dither, c->opt) < 0) { \
154  ret = AVERROR(errno); \
155  av_log(s, AV_LOG_ERROR, "Failed to set value '%s' for option '%s'\n", \
156  c->opt, #opt); \
157  return ret; \
158  } \
159 } while (0)
160 
161  CHECK_DITHER_OPT(algorithm);
162  CHECK_DITHER_OPT(antialias);
163  CHECK_DITHER_OPT(charset);
165 
166  c->display = caca_create_display_with_driver(c->canvas, c->driver);
167  if (!c->display) {
168  ret = AVERROR(errno);
169  av_log(s, AV_LOG_ERROR, "Failed to create display\n");
170  list_drivers(c);
171  return ret;
172  }
173 
174  if (!c->window_width || !c->window_height) {
175  c->window_width = caca_get_canvas_width(c->canvas);
176  c->window_height = caca_get_canvas_height(c->canvas);
177  }
178 
179  if (!c->window_title)
180  c->window_title = av_strdup(s->url);
181  caca_set_display_title(c->display, c->window_title);
182  caca_set_display_time(c->display, av_rescale_q(1, st->time_base, AV_TIME_BASE_Q));
183 
184  return 0;
185 }
186 
188 {
189  CACAContext *c = s->priv_data;
190 
191  caca_dither_bitmap(c->canvas, 0, 0, c->window_width, c->window_height, c->dither, pkt->data);
192  caca_refresh_display(c->display);
193 
194  return 0;
195 }
196 
197 #define OFFSET(x) offsetof(CACAContext,x)
198 #define ENC AV_OPT_FLAG_ENCODING_PARAM
199 
200 static const AVOption options[] = {
201  { "window_size", "set window forced size", OFFSET(window_width), AV_OPT_TYPE_IMAGE_SIZE, {.str = NULL }, 0, 0, ENC},
202  { "window_title", "set window title", OFFSET(window_title), AV_OPT_TYPE_STRING, {.str = NULL }, 0, 0, ENC },
203  { "driver", "set display driver", OFFSET(driver), AV_OPT_TYPE_STRING, {.str = NULL }, 0, 0, ENC },
204  { "algorithm", "set dithering algorithm", OFFSET(algorithm), AV_OPT_TYPE_STRING, {.str = "default" }, 0, 0, ENC },
205  { "antialias", "set antialias method", OFFSET(antialias), AV_OPT_TYPE_STRING, {.str = "default" }, 0, 0, ENC },
206  { "charset", "set charset used to render output", OFFSET(charset), AV_OPT_TYPE_STRING, {.str = "default" }, 0, 0, ENC },
207  { "color", "set color used to render output", OFFSET(color), AV_OPT_TYPE_STRING, {.str = "default" }, 0, 0, ENC },
208  { "list_drivers", "list available drivers", OFFSET(list_drivers), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, ENC },
209  { "list_dither", "list available dither options", OFFSET(list_dither), AV_OPT_TYPE_FLAGS, { .i64 = 0 }, 0, INT_MAX, ENC, .unit = "list_dither" },
210  { "algorithms", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = LIST_ALGORITHMS }, 0, 0, ENC, .unit = "list_dither" },
211  { "antialiases", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = LIST_ANTIALIASES }, 0, 0, ENC, .unit = "list_dither" },
212  { "charsets", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = LIST_CHARSETS }, 0, 0, ENC, .unit = "list_dither" },
213  { "colors", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = LIST_COLORS }, 0, 0, ENC, .unit = "list_dither" },
214  { NULL },
215 };
216 
217 static const AVClass caca_class = {
218  .class_name = "caca outdev",
219  .item_name = av_default_item_name,
220  .option = options,
221  .version = LIBAVUTIL_VERSION_INT,
223 };
224 
226  .p.name = "caca",
227  .p.long_name = NULL_IF_CONFIG_SMALL("caca (color ASCII art) output device"),
228  .priv_data_size = sizeof(CACAContext),
229  .p.audio_codec = AV_CODEC_ID_NONE,
230  .p.video_codec = AV_CODEC_ID_RAWVIDEO,
231  .write_header = caca_write_header,
232  .write_packet = caca_write_packet,
233  .deinit = caca_deinit,
234  .p.flags = AVFMT_NOFILE,
235  .p.priv_class = &caca_class,
236 };
caca_write_header
static int caca_write_header(AVFormatContext *s)
Definition: caca.c:97
ff_caca_muxer
const FFOutputFormat ff_caca_muxer
Definition: caca.c:225
AVOutputFormat::name
const char * name
Definition: avformat.h:510
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
opt.h
AVCodecParameters::codec_type
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:51
color
Definition: vf_paletteuse.c:512
AVCodecParameters
This struct describes the properties of an encoded stream.
Definition: codec_par.h:47
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2965
AV_TIME_BASE_Q
#define AV_TIME_BASE_Q
Internal time base represented as fractional value.
Definition: avutil.h:264
AV_CODEC_ID_RAWVIDEO
@ AV_CODEC_ID_RAWVIDEO
Definition: codec_id.h:65
pixdesc.h
AVPacket::data
uint8_t * data
Definition: packet.h:524
AVOption
AVOption.
Definition: opt.h:346
av_get_bits_per_pixel
int av_get_bits_per_pixel(const AVPixFmtDescriptor *pixdesc)
Return the number of bits per pixel used by the pixel format described by pixdesc.
Definition: pixdesc.c:2917
LIST_COLORS
@ LIST_COLORS
Definition: caca.c:32
OFFSET
#define OFFSET(x)
Definition: caca.c:197
CACAContext::ctx
AVFormatContext * ctx
Definition: caca.c:37
FFOutputFormat::p
AVOutputFormat p
The public AVOutputFormat.
Definition: mux.h:65
CACAContext::window_height
int window_height
Definition: caca.c:39
caca_class
static const AVClass caca_class
Definition: caca.c:217
ENC
#define ENC
Definition: caca.c:198
pkt
AVPacket * pkt
Definition: movenc.c:60
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
LIST_ALGORITHMS
@ LIST_ALGORITHMS
Definition: caca.c:29
s
#define s(width, name)
Definition: cbs_vp9.c:198
AVCodecParameters::width
int width
Video only.
Definition: codec_par.h:134
av_rescale_q
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
Definition: mathematics.c:142
CACAContext::charset
char * charset
Definition: caca.c:46
window_title
static const char * window_title
Definition: ffplay.c:307
AVFormatContext
Format I/O context.
Definition: avformat.h:1255
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:766
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
AVStream::time_base
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented.
Definition: avformat.h:782
NULL
#define NULL
Definition: coverity.c:32
AV_OPT_TYPE_IMAGE_SIZE
@ AV_OPT_TYPE_IMAGE_SIZE
offset must point to two consecutive integers
Definition: opt.h:245
CACAContext::window_title
char * window_title
Definition: caca.c:38
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:237
AV_CLASS_CATEGORY_DEVICE_VIDEO_OUTPUT
@ AV_CLASS_CATEGORY_DEVICE_VIDEO_OUTPUT
Definition: log.h:40
LIST_ANTIALIASES
@ LIST_ANTIALIASES
Definition: caca.c:30
FFOutputFormat
Definition: mux.h:61
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
CACAContext::dither
caca_dither_t * dither
Definition: caca.c:43
CACAContext::list_dither
int list_dither
Definition: caca.c:49
AV_PIX_FMT_RGB24
@ AV_PIX_FMT_RGB24
packed RGB 8:8:8, 24bpp, RGBRGB...
Definition: pixfmt.h:75
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:94
CACAContext::display
caca_display_t * display
Definition: caca.c:42
AVFMT_NOFILE
#define AVFMT_NOFILE
Demuxer will use avio_open, no opened file should be provided by the caller.
Definition: avformat.h:468
avdevice.h
caca_deinit
static void caca_deinit(AVFormatContext *s)
Definition: caca.c:53
CACAContext::antialias
char * antialias
Definition: caca.c:45
CACAContext::color
char * color
Definition: caca.c:46
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:191
DEFINE_LIST_DITHER
#define DEFINE_LIST_DITHER(thing, thing_str)
Definition: caca.c:81
CACAContext::driver
char * driver
Definition: caca.c:47
AV_CODEC_ID_NONE
@ AV_CODEC_ID_NONE
Definition: codec_id.h:50
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
AVCodecParameters::height
int height
Definition: codec_par.h:135
CACAContext::algorithm
char * algorithm
Definition: caca.c:45
ret
ret
Definition: filter_design.txt:187
AVStream
Stream structure.
Definition: avformat.h:743
AVClass::class_name
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:71
CACAContext::list_drivers
int list_drivers
Definition: caca.c:50
CACAContext::canvas
caca_canvas_t * canvas
Definition: caca.c:41
options
static const AVOption options[]
Definition: caca.c:200
av_strdup
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:272
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
mem.h
CHECK_DITHER_OPT
#define CHECK_DITHER_OPT(opt)
AVCodecParameters::format
int format
Definition: codec_par.h:92
AVCodecParameters::codec_id
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:55
AVPacket
This structure stores compressed data.
Definition: packet.h:501
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Definition: opt.h:251
CACAContext::window_width
int window_width
Definition: caca.c:39
AV_OPT_TYPE_FLAGS
@ AV_OPT_TYPE_FLAGS
Definition: opt.h:234
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AVERROR_EXIT
#define AVERROR_EXIT
Immediate exit was requested; the called function should not be restarted.
Definition: error.h:58
caca_write_packet
static int caca_write_packet(AVFormatContext *s, AVPacket *pkt)
Definition: caca.c:187
AV_OPT_TYPE_STRING
@ AV_OPT_TYPE_STRING
Definition: opt.h:239
list_drivers
static void list_drivers(CACAContext *c)
Definition: caca.c:71
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Definition: opt.h:244
LIST_CHARSETS
@ LIST_CHARSETS
Definition: caca.c:31
av_get_pix_fmt_name
const char * av_get_pix_fmt_name(enum AVPixelFormat pix_fmt)
Return the short name for a pixel format, NULL in case pix_fmt is unknown.
Definition: pixdesc.c:2885
CACAContext
Definition: caca.c:35
mux.h