FFmpeg: libavdevice/caca.c Source File

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 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 };
NULL
#define NULL
Definition: coverity.c:32
s
const char * s
Definition: avisynth_c.h:631
AV_CODEC_ID_NONE
Definition: avcodec.h:102
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2157
AVOption
AVOption.
Definition: opt.h:245
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:70
AV_PIX_FMT_RGB24
packed RGB 8:8:8, 24bpp, RGBRGB...
Definition: pixfmt.h:65
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:2109
CACAContext::canvas
caca_canvas_t * canvas
Definition: caca.c:32
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1752
pkt
static AVPacket pkt
Definition: demuxing_decoding.c:54
AVCodecContext::time_base
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
Definition: avcodec.h:1661
AVFormatContext
Format I/O context.
Definition: avformat.h:1314
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:72
CACAContext::dither
caca_dither_t * dither
Definition: caca.c:34
AV_OPT_TYPE_CONST
Definition: opt.h:231
caca_write_trailer
static int caca_write_trailer(AVFormatContext *s)
Definition: caca.c:44
opt.h
AVOptions.
list_drivers
static void list_drivers(CACAContext *c)
Definition: caca.c:65
AVFormatContext::streams
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1382
AV_OPT_TYPE_STRING
Definition: opt.h:227
AVPacket::data
uint8_t * data
Definition: avcodec.h:1467
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
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
avdevice.h
Main libavdevice API header.
CACAContext::window_title
char * window_title
Definition: caca.c:29
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
av_default_item_name
av_default_item_name
Definition: libopenh264enc.c:68
AVERROR
#define AVERROR(e)
Definition: error.h:43
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:176
CACAContext::window_width
int window_width
Definition: caca.c:30
fail
#define fail()
Definition: checkasm.h:80
CACAContext
Definition: caca.c:26
AVStream::codec
AVCodecContext * codec
Codec context associated with this stream.
Definition: avformat.h:896
AVFormatContext::nb_streams
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
Definition: avformat.h:1370
CACAContext::list_drivers
int list_drivers
Definition: caca.c:41
AVFormatContext::filename
char filename[1024]
input or output filename
Definition: avformat.h:1390
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:1711
write_trailer
static int write_trailer(AVFormatContext *s1)
Definition: v4l2enc.c:94
ff_caca_muxer
AVOutputFormat ff_caca_muxer
Definition: caca.c:230
CACAContext::display
caca_display_t * display
Definition: caca.c:33
AVOutputFormat::name
const char * name
Definition: avformat.h:523
AV_OPT_TYPE_BOOL
Definition: opt.h:239
CACAContext::algorithm
char * algorithm
Definition: caca.c:36
options
static const AVOption options[]
Definition: caca.c:205
CACAContext::window_height
int window_height
Definition: caca.c:30
CHECK_DITHER_OPT
#define CHECK_DITHER_OPT(opt)
CACAContext::color
char * color
Definition: caca.c:37
AVCodecContext::height
int height
Definition: avcodec.h:1711
AVERROR_EXIT
#define AVERROR_EXIT
Immediate exit was requested; the called function should not be restarted.
Definition: error.h:56
CACAContext::antialias
char * antialias
Definition: caca.c:36
AVStream
Stream structure.
Definition: avformat.h:877
DEFINE_LIST_DITHER
#define DEFINE_LIST_DITHER(thing, thing_str)
Definition: caca.c:75
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:187
AVCodecContext::codec_type
enum AVMediaType codec_type
Definition: avcodec.h:1540
AVCodecContext::codec_id
enum AVCodecID codec_id
Definition: avcodec.h:1549
AV_TIME_BASE_Q
#define AV_TIME_BASE_Q
Internal time base represented as fractional value.
Definition: avutil.h:252
av_strdup
char * av_strdup(const char *s)
Duplicate the string s.
Definition: mem.c:267
AVCodecContext
main external API structure.
Definition: avcodec.h:1532
ENC
#define ENC
Definition: caca.c:203
window_title
static const char * window_title
Definition: ffplay.c:315
CACAContext::charset
char * charset
Definition: caca.c:37
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:67
AV_OPT_TYPE_IMAGE_SIZE
offset must point to two consecutive integers
Definition: opt.h:232
caca_write_header
static int caca_write_header(AVFormatContext *s)
Definition: caca.c:91
flags
static int flags
Definition: cpu.c:47
CACAContext::ctx
AVFormatContext * ctx
Definition: caca.c:28
AVFMT_NOFILE
#define AVFMT_NOFILE
Demuxer will use avio_open, no opened file should be provided by the caller.
Definition: avformat.h:477
c
static double c[64]
Definition: vsrc_mptestsrc.c:87
caca_write_packet
static int caca_write_packet(AVFormatContext *s, AVPacket *pkt)
Definition: caca.c:192
OFFSET
#define OFFSET(x)
Definition: caca.c:202
AVFormatContext::priv_data
void * priv_data
Format private data.
Definition: avformat.h:1342
write_header
static void write_header(FFV1Context *f)
Definition: ffv1enc.c:497
CACAContext::list_dither
char * list_dither
Definition: caca.c:40
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
AVMEDIA_TYPE_VIDEO
Definition: avutil.h:193
AV_CODEC_ID_RAWVIDEO
Definition: avcodec.h:120
CACAContext::driver
char * driver
Definition: caca.c:38
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:2078
caca_class
static const AVClass caca_class
Definition: caca.c:222
AVPacket
This structure stores compressed data.
Definition: avcodec.h:1444
write_packet
static int write_packet(AVFormatContext *s1, AVPacket *pkt)
Definition: v4l2enc.c:86
Generated on Mon Feb 15 2016 15:20:43 for FFmpeg by   doxygen 1.8.6

AltStyle によって変換されたページ (->オリジナル) /