FFmpeg
xpmdec.c
Go to the documentation of this file.
1 /*
2  * XPM image format
3  *
4  * Copyright (c) 2012 Paul B Mahol
5  * Copyright (c) 2017 Paras Chadha
6  *
7  * This file is part of FFmpeg.
8  *
9  * FFmpeg is free software; you can redistribute it and/or
10  * modify it under the terms of the GNU Lesser General Public
11  * License as published by the Free Software Foundation; either
12  * version 2.1 of the License, or (at your option) any later version.
13  *
14  * FFmpeg is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17  * Lesser General Public License for more details.
18  *
19  * You should have received a copy of the GNU Lesser General Public
20  * License along with FFmpeg; if not, write to the Free Software
21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22  */
23 
24 #include "libavutil/avstring.h"
25 #include "avcodec.h"
26 #include "codec_internal.h"
27 #include "decode.h"
28 
29 #define MIN_ELEMENT ' '
30 #define MAX_ELEMENT 0xfe
31 #define NB_ELEMENTS (MAX_ELEMENT - MIN_ELEMENT + 1)
32 
33 typedef struct XPMContext {
34  uint32_t *pixels;
36  uint8_t *buf;
37  int buf_size;
38 } XPMDecContext;
39 
40 typedef struct ColorEntry {
41  const char *name; ///< a string representing the name of the color
42  uint32_t rgb_color; ///< RGB values for the color
43 } ColorEntry;
44 
45 static int color_table_compare(const void *lhs, const void *rhs)
46 {
47  return av_strcasecmp(lhs, ((const ColorEntry *)rhs)->name);
48 }
49 
50 static const ColorEntry color_table[] = {
51  { "AliceBlue", 0xFFF0F8FF },
52  { "AntiqueWhite", 0xFFFAEBD7 },
53  { "Aqua", 0xFF00FFFF },
54  { "Aquamarine", 0xFF7FFFD4 },
55  { "Azure", 0xFFF0FFFF },
56  { "Beige", 0xFFF5F5DC },
57  { "Bisque", 0xFFFFE4C4 },
58  { "Black", 0xFF000000 },
59  { "BlanchedAlmond", 0xFFFFEBCD },
60  { "Blue", 0xFF0000FF },
61  { "BlueViolet", 0xFF8A2BE2 },
62  { "Brown", 0xFFA52A2A },
63  { "BurlyWood", 0xFFDEB887 },
64  { "CadetBlue", 0xFF5F9EA0 },
65  { "Chartreuse", 0xFF7FFF00 },
66  { "Chocolate", 0xFFD2691E },
67  { "Coral", 0xFFFF7F50 },
68  { "CornflowerBlue", 0xFF6495ED },
69  { "Cornsilk", 0xFFFFF8DC },
70  { "Crimson", 0xFFDC143C },
71  { "Cyan", 0xFF00FFFF },
72  { "DarkBlue", 0xFF00008B },
73  { "DarkCyan", 0xFF008B8B },
74  { "DarkGoldenRod", 0xFFB8860B },
75  { "DarkGray", 0xFFA9A9A9 },
76  { "DarkGreen", 0xFF006400 },
77  { "DarkKhaki", 0xFFBDB76B },
78  { "DarkMagenta", 0xFF8B008B },
79  { "DarkOliveGreen", 0xFF556B2F },
80  { "Darkorange", 0xFFFF8C00 },
81  { "DarkOrchid", 0xFF9932CC },
82  { "DarkRed", 0xFF8B0000 },
83  { "DarkSalmon", 0xFFE9967A },
84  { "DarkSeaGreen", 0xFF8FBC8F },
85  { "DarkSlateBlue", 0xFF483D8B },
86  { "DarkSlateGray", 0xFF2F4F4F },
87  { "DarkTurquoise", 0xFF00CED1 },
88  { "DarkViolet", 0xFF9400D3 },
89  { "DeepPink", 0xFFFF1493 },
90  { "DeepSkyBlue", 0xFF00BFFF },
91  { "DimGray", 0xFF696969 },
92  { "DodgerBlue", 0xFF1E90FF },
93  { "FireBrick", 0xFFB22222 },
94  { "FloralWhite", 0xFFFFFAF0 },
95  { "ForestGreen", 0xFF228B22 },
96  { "Fuchsia", 0xFFFF00FF },
97  { "Gainsboro", 0xFFDCDCDC },
98  { "GhostWhite", 0xFFF8F8FF },
99  { "Gold", 0xFFFFD700 },
100  { "GoldenRod", 0xFFDAA520 },
101  { "Gray", 0xFFBEBEBE },
102  { "Green", 0xFF00FF00 },
103  { "GreenYellow", 0xFFADFF2F },
104  { "HoneyDew", 0xFFF0FFF0 },
105  { "HotPink", 0xFFFF69B4 },
106  { "IndianRed", 0xFFCD5C5C },
107  { "Indigo", 0xFF4B0082 },
108  { "Ivory", 0xFFFFFFF0 },
109  { "Khaki", 0xFFF0E68C },
110  { "Lavender", 0xFFE6E6FA },
111  { "LavenderBlush", 0xFFFFF0F5 },
112  { "LawnGreen", 0xFF7CFC00 },
113  { "LemonChiffon", 0xFFFFFACD },
114  { "LightBlue", 0xFFADD8E6 },
115  { "LightCoral", 0xFFF08080 },
116  { "LightCyan", 0xFFE0FFFF },
117  { "LightGoldenRodYellow", 0xFFFAFAD2 },
118  { "LightGreen", 0xFF90EE90 },
119  { "LightGrey", 0xFFD3D3D3 },
120  { "LightPink", 0xFFFFB6C1 },
121  { "LightSalmon", 0xFFFFA07A },
122  { "LightSeaGreen", 0xFF20B2AA },
123  { "LightSkyBlue", 0xFF87CEFA },
124  { "LightSlateGray", 0xFF778899 },
125  { "LightSteelBlue", 0xFFB0C4DE },
126  { "LightYellow", 0xFFFFFFE0 },
127  { "Lime", 0xFF00FF00 },
128  { "LimeGreen", 0xFF32CD32 },
129  { "Linen", 0xFFFAF0E6 },
130  { "Magenta", 0xFFFF00FF },
131  { "Maroon", 0xFFB03060 },
132  { "MediumAquaMarine", 0xFF66CDAA },
133  { "MediumBlue", 0xFF0000CD },
134  { "MediumOrchid", 0xFFBA55D3 },
135  { "MediumPurple", 0xFF9370D8 },
136  { "MediumSeaGreen", 0xFF3CB371 },
137  { "MediumSlateBlue", 0xFF7B68EE },
138  { "MediumSpringGreen", 0xFF00FA9A },
139  { "MediumTurquoise", 0xFF48D1CC },
140  { "MediumVioletRed", 0xFFC71585 },
141  { "MidnightBlue", 0xFF191970 },
142  { "MintCream", 0xFFF5FFFA },
143  { "MistyRose", 0xFFFFE4E1 },
144  { "Moccasin", 0xFFFFE4B5 },
145  { "NavajoWhite", 0xFFFFDEAD },
146  { "Navy", 0xFF000080 },
147  { "None", 0x00000000 },
148  { "OldLace", 0xFFFDF5E6 },
149  { "Olive", 0xFF808000 },
150  { "OliveDrab", 0xFF6B8E23 },
151  { "Orange", 0xFFFFA500 },
152  { "OrangeRed", 0xFFFF4500 },
153  { "Orchid", 0xFFDA70D6 },
154  { "PaleGoldenRod", 0xFFEEE8AA },
155  { "PaleGreen", 0xFF98FB98 },
156  { "PaleTurquoise", 0xFFAFEEEE },
157  { "PaleVioletRed", 0xFFD87093 },
158  { "PapayaWhip", 0xFFFFEFD5 },
159  { "PeachPuff", 0xFFFFDAB9 },
160  { "Peru", 0xFFCD853F },
161  { "Pink", 0xFFFFC0CB },
162  { "Plum", 0xFFDDA0DD },
163  { "PowderBlue", 0xFFB0E0E6 },
164  { "Purple", 0xFFA020F0 },
165  { "Red", 0xFFFF0000 },
166  { "RosyBrown", 0xFFBC8F8F },
167  { "RoyalBlue", 0xFF4169E1 },
168  { "SaddleBrown", 0xFF8B4513 },
169  { "Salmon", 0xFFFA8072 },
170  { "SandyBrown", 0xFFF4A460 },
171  { "SeaGreen", 0xFF2E8B57 },
172  { "SeaShell", 0xFFFFF5EE },
173  { "Sienna", 0xFFA0522D },
174  { "Silver", 0xFFC0C0C0 },
175  { "SkyBlue", 0xFF87CEEB },
176  { "SlateBlue", 0xFF6A5ACD },
177  { "SlateGray", 0xFF708090 },
178  { "Snow", 0xFFFFFAFA },
179  { "SpringGreen", 0xFF00FF7F },
180  { "SteelBlue", 0xFF4682B4 },
181  { "Tan", 0xFFD2B48C },
182  { "Teal", 0xFF008080 },
183  { "Thistle", 0xFFD8BFD8 },
184  { "Tomato", 0xFFFF6347 },
185  { "Turquoise", 0xFF40E0D0 },
186  { "Violet", 0xFFEE82EE },
187  { "Wheat", 0xFFF5DEB3 },
188  { "White", 0xFFFFFFFF },
189  { "WhiteSmoke", 0xFFF5F5F5 },
190  { "Yellow", 0xFFFFFF00 },
191  { "YellowGreen", 0xFF9ACD32 }
192 };
193 
194 static unsigned hex_char_to_number(uint8_t x)
195 {
196  if (x >= 'a' && x <= 'f')
197  x -= 'a' - 10;
198  else if (x >= 'A' && x <= 'F')
199  x -= 'A' - 10;
200  else if (x >= '0' && x <= '9')
201  x -= '0';
202  else
203  x = 0;
204  return x;
205 }
206 
207 /*
208  * Function same as strcspn but ignores characters if they are inside a C style comments
209  */
210 static size_t mod_strcspn(const char *string, const char *reject)
211 {
212  int i, j;
213 
214  for (i = 0; string && string[i]; i++) {
215  if (string[i] == '/' && string[i+1] == '*') {
216  i += 2;
217  while ( string && string[i] && (string[i] != '*' || string[i+1] != '/') )
218  i++;
219  i++;
220  } else if (string[i] == '/' && string[i+1] == '/') {
221  i += 2;
222  while ( string && string[i] && string[i] != '\n' )
223  i++;
224  } else {
225  for (j = 0; reject && reject[j]; j++) {
226  if (string[i] == reject[j])
227  break;
228  }
229  if (reject && reject[j])
230  break;
231  }
232  }
233  return i;
234 }
235 
236 static uint32_t color_string_to_rgba(const char *p, int len)
237 {
238  uint32_t ret = 0xFF000000;
239  const ColorEntry *entry;
240  char color_name[100];
241 
242  len = FFMIN(FFMAX(len, 0), sizeof(color_name) - 1);
243 
244  if (*p == '#') {
245  p++;
246  len--;
247  if (len == 3) {
248  ret |= (hex_char_to_number(p[2]) << 4) |
249  (hex_char_to_number(p[1]) << 12) |
250  (hex_char_to_number(p[0]) << 20);
251  } else if (len == 4) {
252  ret = (hex_char_to_number(p[3]) << 4) |
253  (hex_char_to_number(p[2]) << 12) |
254  (hex_char_to_number(p[1]) << 20) |
255  (hex_char_to_number(p[0]) << 28);
256  } else if (len == 6) {
257  ret |= hex_char_to_number(p[5]) |
258  (hex_char_to_number(p[4]) << 4) |
259  (hex_char_to_number(p[3]) << 8) |
260  (hex_char_to_number(p[2]) << 12) |
261  (hex_char_to_number(p[1]) << 16) |
262  (hex_char_to_number(p[0]) << 20);
263  } else if (len == 8) {
264  ret = hex_char_to_number(p[7]) |
265  (hex_char_to_number(p[6]) << 4) |
266  (hex_char_to_number(p[5]) << 8) |
267  (hex_char_to_number(p[4]) << 12) |
268  (hex_char_to_number(p[3]) << 16) |
269  (hex_char_to_number(p[2]) << 20) |
270  (hex_char_to_number(p[1]) << 24) |
271  (hex_char_to_number(p[0]) << 28);
272  }
273  } else {
274  strncpy(color_name, p, len);
275  color_name[len] = '\0';
276 
277  entry = bsearch(color_name,
278  color_table,
280  sizeof(ColorEntry),
282 
283  if (!entry)
284  return ret;
285 
286  ret = entry->rgb_color;
287  }
288  return ret;
289 }
290 
291 static int ascii2index(const uint8_t *cpixel, int cpp)
292 {
293  const uint8_t *p = cpixel;
294  int n = 0, m = 1, i;
295 
296  for (i = 0; i < cpp; i++) {
297  if (*p < MIN_ELEMENT || *p > MAX_ELEMENT)
298  return AVERROR_INVALIDDATA;
299  n += (*p++ - MIN_ELEMENT) * m;
300  m *= NB_ELEMENTS;
301  }
302  return n;
303 }
304 
306  int *got_frame, AVPacket *avpkt)
307 {
308  XPMDecContext *x = avctx->priv_data;
309  const uint8_t *end, *ptr;
310  int ncolors, cpp, ret, i, j;
311  int64_t size;
312  uint32_t *dst;
313  int width, height;
314 
315  avctx->pix_fmt = AV_PIX_FMT_BGRA;
316 
317  av_fast_padded_malloc(&x->buf, &x->buf_size, avpkt->size);
318  if (!x->buf)
319  return AVERROR(ENOMEM);
320  memcpy(x->buf, avpkt->data, avpkt->size);
321  x->buf[avpkt->size] = 0;
322 
323  ptr = x->buf;
324  end = x->buf + avpkt->size;
325  while (end - ptr > 9 && memcmp(ptr, "/* XPM */", 9))
326  ptr++;
327 
328  if (end - ptr <= 9) {
329  av_log(avctx, AV_LOG_ERROR, "missing signature\n");
330  return AVERROR_INVALIDDATA;
331  }
332 
333  ptr += mod_strcspn(ptr, "\"");
334  if (sscanf(ptr, "\"%u %u %u %u\",",
335  &width, &height, &ncolors, &cpp) != 4) {
336  av_log(avctx, AV_LOG_ERROR, "missing image parameters\n");
337  return AVERROR_INVALIDDATA;
338  }
339 
340  if ((ret = ff_set_dimensions(avctx, width, height)) < 0)
341  return ret;
342 
343  if (cpp <= 0 || cpp >= 5) {
344  av_log(avctx, AV_LOG_ERROR, "unsupported/invalid number of chars per pixel: %d\n", cpp);
345  return AVERROR_INVALIDDATA;
346  }
347 
348  size = 1;
349  for (i = 0; i < cpp; i++)
350  size *= NB_ELEMENTS;
351 
352  if (ncolors <= 0 || ncolors > size) {
353  av_log(avctx, AV_LOG_ERROR, "invalid number of colors: %d\n", ncolors);
354  return AVERROR_INVALIDDATA;
355  }
356 
357  if (size > SIZE_MAX / 4)
358  return AVERROR(ENOMEM);
359 
360  size *= 4;
361 
362  ptr += mod_strcspn(ptr, ",") + 1;
363  if (end - ptr < 1)
364  return AVERROR_INVALIDDATA;
365 
366  if (avctx->skip_frame >= AVDISCARD_ALL)
367  return avpkt->size;
368 
369  if ((ret = ff_get_buffer(avctx, p, 0)) < 0)
370  return ret;
371 
372  av_fast_padded_malloc(&x->pixels, &x->pixels_size, size);
373  if (!x->pixels)
374  return AVERROR(ENOMEM);
375 
376  for (i = 0; i < ncolors; i++) {
377  const uint8_t *index;
378  int len;
379 
380  ptr += mod_strcspn(ptr, "\"") + 1;
381  if (end - ptr < cpp)
382  return AVERROR_INVALIDDATA;
383  index = ptr;
384  ptr += cpp;
385 
386  ptr = strstr(ptr, "c ");
387  if (ptr) {
388  ptr += 2;
389  } else {
390  return AVERROR_INVALIDDATA;
391  }
392 
393  len = strcspn(ptr, "\" ");
394 
395  if ((ret = ascii2index(index, cpp)) < 0)
396  return ret;
397 
398  x->pixels[ret] = color_string_to_rgba(ptr, len);
399  ptr += mod_strcspn(ptr, ",") + 1;
400  if (end - ptr < 1)
401  return AVERROR_INVALIDDATA;
402  }
403 
404  for (i = 0; i < avctx->height; i++) {
405  dst = (uint32_t *)(p->data[0] + i * p->linesize[0]);
406  if (end - ptr < 1)
407  return AVERROR_INVALIDDATA;
408  ptr += mod_strcspn(ptr, "\"") + 1;
409  if (end - ptr < 1)
410  return AVERROR_INVALIDDATA;
411 
412  for (j = 0; j < avctx->width; j++) {
413  if (end - ptr < cpp)
414  return AVERROR_INVALIDDATA;
415 
416  if ((ret = ascii2index(ptr, cpp)) < 0)
417  return ret;
418 
419  *dst++ = x->pixels[ret];
420  ptr += cpp;
421  }
422  ptr += mod_strcspn(ptr, ",") + 1;
423  }
424 
425  p->flags |= AV_FRAME_FLAG_KEY;
427 
428  *got_frame = 1;
429 
430  return avpkt->size;
431 }
432 
434 {
435  XPMDecContext *x = avctx->priv_data;
436  av_freep(&x->pixels);
437 
438  av_freep(&x->buf);
439  x->buf_size = 0;
440 
441  return 0;
442 }
443 
445  .p.name = "xpm",
446  CODEC_LONG_NAME("XPM (X PixMap) image"),
447  .p.type = AVMEDIA_TYPE_VIDEO,
448  .p.id = AV_CODEC_ID_XPM,
449  .p.capabilities = AV_CODEC_CAP_DR1,
450  .priv_data_size = sizeof(XPMDecContext),
451  .close = xpm_decode_close,
452  .caps_internal = FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM,
454 };
NB_ELEMENTS
#define NB_ELEMENTS
Definition: xpmdec.c:31
name
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default minimum maximum flags name is the option name
Definition: writing_filters.txt:88
xpm_decode_close
static av_cold int xpm_decode_close(AVCodecContext *avctx)
Definition: xpmdec.c:433
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
MIN_ELEMENT
#define MIN_ELEMENT
Definition: xpmdec.c:29
av_strcasecmp
int av_strcasecmp(const char *a, const char *b)
Locale-independent case-insensitive compare.
Definition: avstring.c:207
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:340
AVPacket::data
uint8_t * data
Definition: packet.h:491
FFCodec
Definition: codec_internal.h:127
MAX_ELEMENT
#define MAX_ELEMENT
Definition: xpmdec.c:30
AV_PIX_FMT_BGRA
@ AV_PIX_FMT_BGRA
packed BGRA 8:8:8:8, 32bpp, BGRABGRA...
Definition: pixfmt.h:95
XPMContext::buf_size
int buf_size
Definition: xpmdec.c:37
AVFrame::flags
int flags
Frame flags, a combination of AV_FRAME_FLAGS.
Definition: frame.h:649
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
cpixel
#define cpixel
Definition: colorchannelmixer_template.c:37
ff_set_dimensions
int ff_set_dimensions(AVCodecContext *s, int width, int height)
Check that the provided frame dimensions are valid and set them on the codec context.
Definition: utils.c:94
XPMContext::pixels
uint32_t * pixels
Definition: xpmdec.c:34
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:361
ff_xpm_decoder
const FFCodec ff_xpm_decoder
Definition: xpmdec.c:444
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:131
AVCodecContext::skip_frame
enum AVDiscard skip_frame
Skip decoding for selected frames.
Definition: avcodec.h:1766
color_table_compare
static int color_table_compare(const void *lhs, const void *rhs)
Definition: xpmdec.c:45
ascii2index
static int ascii2index(const uint8_t *cpixel, int cpp)
Definition: xpmdec.c:291
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
av_cold
#define av_cold
Definition: attributes.h:90
AV_FRAME_FLAG_KEY
#define AV_FRAME_FLAG_KEY
A flag to mark frames that are keyframes.
Definition: frame.h:628
XPMContext::buf
uint8_t * buf
Definition: xpmdec.c:36
width
#define width
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:306
decode.h
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:272
AVDISCARD_ALL
@ AVDISCARD_ALL
discard all
Definition: defs.h:219
mod_strcspn
static size_t mod_strcspn(const char *string, const char *reject)
Definition: xpmdec.c:210
XPMContext
Definition: xpmdec.c:33
xpm_decode_frame
static int xpm_decode_frame(AVCodecContext *avctx, AVFrame *p, int *got_frame, AVPacket *avpkt)
Definition: xpmdec.c:305
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:279
ColorEntry::rgb_color
uint32_t rgb_color
RGB values for the color.
Definition: xpmdec.c:42
index
int index
Definition: gxfenc.c:89
XPMContext::pixels_size
int pixels_size
Definition: xpmdec.c:35
hex_char_to_number
static unsigned hex_char_to_number(uint8_t x)
Definition: xpmdec.c:194
AVFrame::pict_type
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:442
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1617
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
AVPacket::size
int size
Definition: packet.h:492
codec_internal.h
size
int size
Definition: twinvq_data.h:10344
FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM
#define FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM
The decoder extracts and fills its parameters even if the frame is skipped due to the skip_frame sett...
Definition: codec_internal.h:54
height
#define height
AV_CODEC_ID_XPM
@ AV_CODEC_ID_XPM
Definition: codec_id.h:282
ColorEntry
Definition: xpmdec.c:40
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:255
av_fast_padded_malloc
void av_fast_padded_malloc(void *ptr, unsigned int *size, size_t min_size)
Same behaviour av_fast_malloc but the buffer has additional AV_INPUT_BUFFER_PADDING_SIZE at the end w...
Definition: utils.c:52
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:194
len
int len
Definition: vorbis_enc_data.h:426
AVCodecContext::height
int height
Definition: avcodec.h:621
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:658
avcodec.h
ret
ret
Definition: filter_design.txt:187
color_string_to_rgba
static uint32_t color_string_to_rgba(const char *p, int len)
Definition: xpmdec.c:236
AVCodecContext
main external API structure.
Definition: avcodec.h:441
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:468
AVPacket
This structure stores compressed data.
Definition: packet.h:468
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:621
AVFrame::linesize
int linesize[AV_NUM_DATA_POINTERS]
For video, a positive or negative value, which is typically indicating the size in bytes of each pict...
Definition: frame.h:385
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
avstring.h
color_table
static const ColorEntry color_table[]
Definition: xpmdec.c:50
ColorEntry::name
const char * name
a string representing the name of the color
Definition: xpmdec.c:41