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/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 void caca_deinit(AVFormatContext *s)
45 {
46  CACAContext *c = s->priv_data;
47 
48  if (c->display) {
49  caca_free_display(c->display);
50  c->display = NULL;
51  }
52  if (c->dither) {
53  caca_free_dither(c->dither);
54  c->dither = NULL;
55  }
56  if (c->canvas) {
57  caca_free_canvas(c->canvas);
58  c->canvas = NULL;
59  }
60 }
61 
62 static void list_drivers(CACAContext *c)
63 {
64  const char *const *drivers = caca_get_display_driver_list();
65  int i;
66 
67  av_log(c->ctx, AV_LOG_INFO, "Available drivers:\n");
68  for (i = 0; drivers[i]; i += 2)
69  av_log(c->ctx, AV_LOG_INFO, "%s: %s\n", drivers[i], drivers[i + 1]);
70 }
71 
72 #define DEFINE_LIST_DITHER(thing, thing_str) \
73 static void list_dither_## thing(CACAContext *c) \
74 { \
75  const char *const *thing = caca_get_dither_## thing ##_list(c->dither); \
76  int i; \
77  \
78  av_log(c->ctx, AV_LOG_INFO, "Available %s:\n", thing_str); \
79  for (i = 0; thing[i]; i += 2) \
80  av_log(c->ctx, AV_LOG_INFO, "%s: %s\n", thing[i], thing[i + 1]); \
81 }
82 
83 DEFINE_LIST_DITHER(color, "colors");
84 DEFINE_LIST_DITHER(charset, "charsets");
85 DEFINE_LIST_DITHER(algorithm, "algorithms");
86 DEFINE_LIST_DITHER(antialias, "antialias");
87 
88 static int caca_write_header(AVFormatContext *s)
89 {
90  CACAContext *c = s->priv_data;
91  AVStream *st = s->streams[0];
92  AVCodecParameters *encctx = st->codecpar;
93  int ret, bpp;
94 
95  c->ctx = s;
96  if (c->list_drivers) {
97  list_drivers(c);
98  return AVERROR_EXIT;
99  }
100  if (c->list_dither) {
101  if (!strcmp(c->list_dither, "colors")) {
102  list_dither_color(c);
103  } else if (!strcmp(c->list_dither, "charsets")) {
104  list_dither_charset(c);
105  } else if (!strcmp(c->list_dither, "algorithms")) {
106  list_dither_algorithm(c);
107  } else if (!strcmp(c->list_dither, "antialiases")) {
108  list_dither_antialias(c);
109  } else {
110  av_log(s, AV_LOG_ERROR,
111  "Invalid argument '%s', for 'list_dither' option\n"
112  "Argument must be one of 'algorithms, 'antialiases', 'charsets', 'colors'\n",
113  c->list_dither);
114  return AVERROR(EINVAL);
115  }
116  return AVERROR_EXIT;
117  }
118 
119  if ( s->nb_streams > 1
120  || encctx->codec_type != AVMEDIA_TYPE_VIDEO
121  || encctx->codec_id != AV_CODEC_ID_RAWVIDEO) {
122  av_log(s, AV_LOG_ERROR, "Only supports one rawvideo stream\n");
123  return AVERROR(EINVAL);
124  }
125 
126  if (encctx->format != AV_PIX_FMT_RGB24) {
127  av_log(s, AV_LOG_ERROR,
128  "Unsupported pixel format '%s', choose rgb24\n",
129  av_get_pix_fmt_name(encctx->format));
130  return AVERROR(EINVAL);
131  }
132 
133  c->canvas = caca_create_canvas(c->window_width, c->window_height);
134  if (!c->canvas) {
135  ret = AVERROR(errno);
136  av_log(s, AV_LOG_ERROR, "Failed to create canvas\n");
137  return ret;
138  }
139 
140  bpp = av_get_bits_per_pixel(av_pix_fmt_desc_get(encctx->format));
141  c->dither = caca_create_dither(bpp, encctx->width, encctx->height,
142  bpp / 8 * encctx->width,
143  0x0000ff, 0x00ff00, 0xff0000, 0);
144  if (!c->dither) {
145  ret = AVERROR(errno);
146  av_log(s, AV_LOG_ERROR, "Failed to create dither\n");
147  return ret;
148  }
149 
150 #define CHECK_DITHER_OPT(opt) do { \
151  if (caca_set_dither_##opt(c->dither, c->opt) < 0) { \
152  ret = AVERROR(errno); \
153  av_log(s, AV_LOG_ERROR, "Failed to set value '%s' for option '%s'\n", \
154  c->opt, #opt); \
155  return ret; \
156  } \
157 } while (0)
158 
159  CHECK_DITHER_OPT(algorithm);
160  CHECK_DITHER_OPT(antialias);
161  CHECK_DITHER_OPT(charset);
162  CHECK_DITHER_OPT(color);
163 
164  c->display = caca_create_display_with_driver(c->canvas, c->driver);
165  if (!c->display) {
166  ret = AVERROR(errno);
167  av_log(s, AV_LOG_ERROR, "Failed to create display\n");
168  list_drivers(c);
169  return ret;
170  }
171 
172  if (!c->window_width || !c->window_height) {
173  c->window_width = caca_get_canvas_width(c->canvas);
174  c->window_height = caca_get_canvas_height(c->canvas);
175  }
176 
177  if (!c->window_title)
178  c->window_title = av_strdup(s->url);
179  caca_set_display_title(c->display, c->window_title);
180  caca_set_display_time(c->display, av_rescale_q(1, st->time_base, AV_TIME_BASE_Q));
181 
182  return 0;
183 }
184 
185 static int caca_write_packet(AVFormatContext *s, AVPacket *pkt)
186 {
187  CACAContext *c = s->priv_data;
188 
189  caca_dither_bitmap(c->canvas, 0, 0, c->window_width, c->window_height, c->dither, pkt->data);
190  caca_refresh_display(c->display);
191 
192  return 0;
193 }
194 
195 #define OFFSET(x) offsetof(CACAContext,x)
196 #define ENC AV_OPT_FLAG_ENCODING_PARAM
197 
198 static const AVOption options[] = {
199  { "window_size", "set window forced size", OFFSET(window_width), AV_OPT_TYPE_IMAGE_SIZE, {.str = NULL }, 0, 0, ENC},
200  { "window_title", "set window title", OFFSET(window_title), AV_OPT_TYPE_STRING, {.str = NULL }, 0, 0, ENC },
201  { "driver", "set display driver", OFFSET(driver), AV_OPT_TYPE_STRING, {.str = NULL }, 0, 0, ENC },
202  { "algorithm", "set dithering algorithm", OFFSET(algorithm), AV_OPT_TYPE_STRING, {.str = "default" }, 0, 0, ENC },
203  { "antialias", "set antialias method", OFFSET(antialias), AV_OPT_TYPE_STRING, {.str = "default" }, 0, 0, ENC },
204  { "charset", "set charset used to render output", OFFSET(charset), AV_OPT_TYPE_STRING, {.str = "default" }, 0, 0, ENC },
205  { "color", "set color used to render output", OFFSET(color), AV_OPT_TYPE_STRING, {.str = "default" }, 0, 0, ENC },
206  { "list_drivers", "list available drivers", OFFSET(list_drivers), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, ENC },
207  { "list_dither", "list available dither options", OFFSET(list_dither), AV_OPT_TYPE_STRING, {.str=NULL}, 0, 1, ENC, "list_dither" },
208  { "algorithms", NULL, 0, AV_OPT_TYPE_CONST, {.str = "algorithms"}, 0, 0, ENC, "list_dither" },
209  { "antialiases", NULL, 0, AV_OPT_TYPE_CONST, {.str = "antialiases"},0, 0, ENC, "list_dither" },
210  { "charsets", NULL, 0, AV_OPT_TYPE_CONST, {.str = "charsets"}, 0, 0, ENC, "list_dither" },
211  { "colors", NULL, 0, AV_OPT_TYPE_CONST, {.str = "colors"}, 0, 0, ENC, "list_dither" },
212  { NULL },
213 };
214 
215 static const AVClass caca_class = {
216  .class_name = "caca outdev",
217  .item_name = av_default_item_name,
218  .option = options,
219  .version = LIBAVUTIL_VERSION_INT,
220  .category = AV_CLASS_CATEGORY_DEVICE_VIDEO_OUTPUT,
221 };
222 
223 const AVOutputFormat ff_caca_muxer = {
224  .name = "caca",
225  .long_name = NULL_IF_CONFIG_SMALL("caca (color ASCII art) output device"),
226  .priv_data_size = sizeof(CACAContext),
227  .audio_codec = AV_CODEC_ID_NONE,
228  .video_codec = AV_CODEC_ID_RAWVIDEO,
229  .write_header = caca_write_header,
230  .write_packet = caca_write_packet,
231  .deinit = caca_deinit,
232  .flags = AVFMT_NOFILE,
233  .priv_class = &caca_class,
234 };
caca_write_header
static int caca_write_header(AVFormatContext *s)
Definition: caca.c:88
AVOutputFormat::name
const char * name
Definition: avformat.h:504
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:56
color
Definition: vf_paletteuse.c:599
AVCodecParameters
This struct describes the properties of an encoded stream.
Definition: codec_par.h:52
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2660
AV_TIME_BASE_Q
#define AV_TIME_BASE_Q
Internal time base represented as fractional value.
Definition: avutil.h:260
AV_CODEC_ID_RAWVIDEO
@ AV_CODEC_ID_RAWVIDEO
Definition: codec_id.h:63
pixdesc.h
deinit
static void deinit(AVFormatContext *s)
Definition: chromaprint.c:50
AVPacket::data
uint8_t * data
Definition: packet.h:373
AVOption
AVOption.
Definition: opt.h:247
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:2612
OFFSET
#define OFFSET(x)
Definition: caca.c:195
CACAContext::list_dither
char * list_dither
Definition: caca.c:40
CACAContext::ctx
AVFormatContext * ctx
Definition: caca.c:28
CACAContext::window_height
int window_height
Definition: caca.c:30
caca_class
static const AVClass caca_class
Definition: caca.c:215
ENC
#define ENC
Definition: caca.c:196
pkt
AVPacket * pkt
Definition: movenc.c:59
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
s
#define s(width, name)
Definition: cbs_vp9.c:257
AVCodecParameters::width
int width
Video only.
Definition: codec_par.h:126
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:141
CACAContext::charset
char * charset
Definition: caca.c:37
window_title
static const char * window_title
Definition: ffplay.c:311
AVFormatContext
Format I/O context.
Definition: avformat.h:1200
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1095
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:965
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:234
CACAContext::window_title
char * window_title
Definition: caca.c:29
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:235
AV_CLASS_CATEGORY_DEVICE_VIDEO_OUTPUT
@ AV_CLASS_CATEGORY_DEVICE_VIDEO_OUTPUT
Definition: log.h:40
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:34
AV_PIX_FMT_RGB24
@ AV_PIX_FMT_RGB24
packed RGB 8:8:8, 24bpp, RGBRGB...
Definition: pixfmt.h:68
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:117
CACAContext::display
caca_display_t * display
Definition: caca.c:33
AVFMT_NOFILE
#define AVFMT_NOFILE
Demuxer will use avio_open, no opened file should be provided by the caller.
Definition: avformat.h:464
avdevice.h
caca_deinit
static void caca_deinit(AVFormatContext *s)
Definition: caca.c:44
CACAContext::antialias
char * antialias
Definition: caca.c:36
CACAContext::color
char * color
Definition: caca.c:37
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:191
write_packet
static void write_packet(OutputFile *of, AVPacket *pkt, OutputStream *ost, int unqueue)
Definition: ffmpeg.c:727
DEFINE_LIST_DITHER
#define DEFINE_LIST_DITHER(thing, thing_str)
Definition: caca.c:72
CACAContext::driver
char * driver
Definition: caca.c:38
AV_CODEC_ID_NONE
@ AV_CODEC_ID_NONE
Definition: codec_id.h:48
AVOutputFormat
Definition: avformat.h:503
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:271
AVCodecParameters::height
int height
Definition: codec_par.h:127
CACAContext::algorithm
char * algorithm
Definition: caca.c:36
ret
ret
Definition: filter_design.txt:187
AVStream
Stream structure.
Definition: avformat.h:935
ff_caca_muxer
const AVOutputFormat ff_caca_muxer
Definition: caca.c:223
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:41
CACAContext::canvas
caca_canvas_t * canvas
Definition: caca.c:32
options
static const AVOption options[]
Definition: caca.c:198
av_strdup
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:279
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
CHECK_DITHER_OPT
#define CHECK_DITHER_OPT(opt)
AVCodecParameters::format
int format
Definition: codec_par.h:84
AVCodecParameters::codec_id
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:60
AVPacket
This structure stores compressed data.
Definition: packet.h:350
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Definition: opt.h:241
CACAContext::window_width
int window_width
Definition: caca.c:30
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:561
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
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:185
AV_OPT_TYPE_STRING
@ AV_OPT_TYPE_STRING
Definition: opt.h:228
write_header
static void write_header(FFV1Context *f)
Definition: ffv1enc.c:347
list_drivers
static void list_drivers(CACAContext *c)
Definition: caca.c:62
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Definition: opt.h:233
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:2580
CACAContext
Definition: caca.c:26
Generated on Wed Aug 24 2022 21:38:03 for FFmpeg by   doxygen 1.8.17