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 "libavutil/mem.h"
26 #include "avcodec.h"
27 #include "codec_internal.h"
28 #include "decode.h"
29 
30 #define MIN_ELEMENT ' '
31 #define MAX_ELEMENT 0xfe
32 #define NB_ELEMENTS (MAX_ELEMENT - MIN_ELEMENT + 1)
33 
34 typedef struct XPMContext {
35  uint32_t *pixels;
37  uint8_t *buf;
38  int buf_size;
39 } XPMDecContext;
40 
41 typedef struct ColorEntry {
42  const char *name; ///< a string representing the name of the color
43  uint32_t rgb_color; ///< RGB values for the color
44 } ColorEntry;
45 
46 static int color_table_compare(const void *lhs, const void *rhs)
47 {
48  return av_strcasecmp(lhs, ((const ColorEntry *)rhs)->name);
49 }
50 
51 static const ColorEntry color_table[] = {
52  { "AliceBlue", 0xFFF0F8FF },
53  { "AntiqueWhite", 0xFFFAEBD7 },
54  { "Aqua", 0xFF00FFFF },
55  { "Aquamarine", 0xFF7FFFD4 },
56  { "Azure", 0xFFF0FFFF },
57  { "Beige", 0xFFF5F5DC },
58  { "Bisque", 0xFFFFE4C4 },
59  { "Black", 0xFF000000 },
60  { "BlanchedAlmond", 0xFFFFEBCD },
61  { "Blue", 0xFF0000FF },
62  { "BlueViolet", 0xFF8A2BE2 },
63  { "Brown", 0xFFA52A2A },
64  { "BurlyWood", 0xFFDEB887 },
65  { "CadetBlue", 0xFF5F9EA0 },
66  { "Chartreuse", 0xFF7FFF00 },
67  { "Chocolate", 0xFFD2691E },
68  { "Coral", 0xFFFF7F50 },
69  { "CornflowerBlue", 0xFF6495ED },
70  { "Cornsilk", 0xFFFFF8DC },
71  { "Crimson", 0xFFDC143C },
72  { "Cyan", 0xFF00FFFF },
73  { "DarkBlue", 0xFF00008B },
74  { "DarkCyan", 0xFF008B8B },
75  { "DarkGoldenRod", 0xFFB8860B },
76  { "DarkGray", 0xFFA9A9A9 },
77  { "DarkGreen", 0xFF006400 },
78  { "DarkKhaki", 0xFFBDB76B },
79  { "DarkMagenta", 0xFF8B008B },
80  { "DarkOliveGreen", 0xFF556B2F },
81  { "Darkorange", 0xFFFF8C00 },
82  { "DarkOrchid", 0xFF9932CC },
83  { "DarkRed", 0xFF8B0000 },
84  { "DarkSalmon", 0xFFE9967A },
85  { "DarkSeaGreen", 0xFF8FBC8F },
86  { "DarkSlateBlue", 0xFF483D8B },
87  { "DarkSlateGray", 0xFF2F4F4F },
88  { "DarkTurquoise", 0xFF00CED1 },
89  { "DarkViolet", 0xFF9400D3 },
90  { "DeepPink", 0xFFFF1493 },
91  { "DeepSkyBlue", 0xFF00BFFF },
92  { "DimGray", 0xFF696969 },
93  { "DodgerBlue", 0xFF1E90FF },
94  { "FireBrick", 0xFFB22222 },
95  { "FloralWhite", 0xFFFFFAF0 },
96  { "ForestGreen", 0xFF228B22 },
97  { "Fuchsia", 0xFFFF00FF },
98  { "Gainsboro", 0xFFDCDCDC },
99  { "GhostWhite", 0xFFF8F8FF },
100  { "Gold", 0xFFFFD700 },
101  { "GoldenRod", 0xFFDAA520 },
102  { "Gray", 0xFFBEBEBE },
103  { "Green", 0xFF00FF00 },
104  { "GreenYellow", 0xFFADFF2F },
105  { "HoneyDew", 0xFFF0FFF0 },
106  { "HotPink", 0xFFFF69B4 },
107  { "IndianRed", 0xFFCD5C5C },
108  { "Indigo", 0xFF4B0082 },
109  { "Ivory", 0xFFFFFFF0 },
110  { "Khaki", 0xFFF0E68C },
111  { "Lavender", 0xFFE6E6FA },
112  { "LavenderBlush", 0xFFFFF0F5 },
113  { "LawnGreen", 0xFF7CFC00 },
114  { "LemonChiffon", 0xFFFFFACD },
115  { "LightBlue", 0xFFADD8E6 },
116  { "LightCoral", 0xFFF08080 },
117  { "LightCyan", 0xFFE0FFFF },
118  { "LightGoldenRodYellow", 0xFFFAFAD2 },
119  { "LightGreen", 0xFF90EE90 },
120  { "LightGrey", 0xFFD3D3D3 },
121  { "LightPink", 0xFFFFB6C1 },
122  { "LightSalmon", 0xFFFFA07A },
123  { "LightSeaGreen", 0xFF20B2AA },
124  { "LightSkyBlue", 0xFF87CEFA },
125  { "LightSlateGray", 0xFF778899 },
126  { "LightSteelBlue", 0xFFB0C4DE },
127  { "LightYellow", 0xFFFFFFE0 },
128  { "Lime", 0xFF00FF00 },
129  { "LimeGreen", 0xFF32CD32 },
130  { "Linen", 0xFFFAF0E6 },
131  { "Magenta", 0xFFFF00FF },
132  { "Maroon", 0xFFB03060 },
133  { "MediumAquaMarine", 0xFF66CDAA },
134  { "MediumBlue", 0xFF0000CD },
135  { "MediumOrchid", 0xFFBA55D3 },
136  { "MediumPurple", 0xFF9370D8 },
137  { "MediumSeaGreen", 0xFF3CB371 },
138  { "MediumSlateBlue", 0xFF7B68EE },
139  { "MediumSpringGreen", 0xFF00FA9A },
140  { "MediumTurquoise", 0xFF48D1CC },
141  { "MediumVioletRed", 0xFFC71585 },
142  { "MidnightBlue", 0xFF191970 },
143  { "MintCream", 0xFFF5FFFA },
144  { "MistyRose", 0xFFFFE4E1 },
145  { "Moccasin", 0xFFFFE4B5 },
146  { "NavajoWhite", 0xFFFFDEAD },
147  { "Navy", 0xFF000080 },
148  { "None", 0x00000000 },
149  { "OldLace", 0xFFFDF5E6 },
150  { "Olive", 0xFF808000 },
151  { "OliveDrab", 0xFF6B8E23 },
152  { "Orange", 0xFFFFA500 },
153  { "OrangeRed", 0xFFFF4500 },
154  { "Orchid", 0xFFDA70D6 },
155  { "PaleGoldenRod", 0xFFEEE8AA },
156  { "PaleGreen", 0xFF98FB98 },
157  { "PaleTurquoise", 0xFFAFEEEE },
158  { "PaleVioletRed", 0xFFD87093 },
159  { "PapayaWhip", 0xFFFFEFD5 },
160  { "PeachPuff", 0xFFFFDAB9 },
161  { "Peru", 0xFFCD853F },
162  { "Pink", 0xFFFFC0CB },
163  { "Plum", 0xFFDDA0DD },
164  { "PowderBlue", 0xFFB0E0E6 },
165  { "Purple", 0xFFA020F0 },
166  { "Red", 0xFFFF0000 },
167  { "RosyBrown", 0xFFBC8F8F },
168  { "RoyalBlue", 0xFF4169E1 },
169  { "SaddleBrown", 0xFF8B4513 },
170  { "Salmon", 0xFFFA8072 },
171  { "SandyBrown", 0xFFF4A460 },
172  { "SeaGreen", 0xFF2E8B57 },
173  { "SeaShell", 0xFFFFF5EE },
174  { "Sienna", 0xFFA0522D },
175  { "Silver", 0xFFC0C0C0 },
176  { "SkyBlue", 0xFF87CEEB },
177  { "SlateBlue", 0xFF6A5ACD },
178  { "SlateGray", 0xFF708090 },
179  { "Snow", 0xFFFFFAFA },
180  { "SpringGreen", 0xFF00FF7F },
181  { "SteelBlue", 0xFF4682B4 },
182  { "Tan", 0xFFD2B48C },
183  { "Teal", 0xFF008080 },
184  { "Thistle", 0xFFD8BFD8 },
185  { "Tomato", 0xFFFF6347 },
186  { "Turquoise", 0xFF40E0D0 },
187  { "Violet", 0xFFEE82EE },
188  { "Wheat", 0xFFF5DEB3 },
189  { "White", 0xFFFFFFFF },
190  { "WhiteSmoke", 0xFFF5F5F5 },
191  { "Yellow", 0xFFFFFF00 },
192  { "YellowGreen", 0xFF9ACD32 }
193 };
194 
195 static unsigned hex_char_to_number(uint8_t x)
196 {
197 #define TIMES256(idx) \
198 TIMES64(4 * (idx)) TIMES64(4 * (idx) + 1) TIMES64(4 * (idx) + 2) TIMES64(4 * (idx) + 3)
199 #define TIMES64(idx) \
200 TIMES16(4 * (idx)) TIMES16(4 * (idx) + 1) TIMES16(4 * (idx) + 2) TIMES16(4 * (idx) + 3)
201 #define TIMES16(idx) \
202 TIMES4(4 * (idx)) TIMES4(4 * (idx) + 1) TIMES4(4 * (idx) + 2) TIMES4(4 * (idx) + 3)
203 #define TIMES4(idx) \
204 ENTRY(4 * (idx)) ENTRY(4 * (idx) + 1) ENTRY(4 * (idx) + 2) ENTRY(4 * (idx) + 3)
205 #define ENTRY(x) [x] = ((x) >= 'a' && (x) <= 'f') ? (x) - ('a' - 10) : \
206  ((x) >= 'A' && (x) <= 'F') ? (x) - ('A' - 10) : \
207  ((x) >= '0' && (x) <= '9') ? (x) - '0' : 0,
208 
209  static const uint8_t lut[] = {
210  TIMES256(0)
211  };
212  return lut[x];
213 }
214 
215 /*
216  * Function same as strcspn but ignores characters if they are inside a C style comments
217  */
218 static size_t mod_strcspn(const char *string, const char *reject)
219 {
220  int i, j;
221 
222  for (i = 0; string && string[i]; i++) {
223  if (string[i] == '/' && string[i+1] == '*') {
224  i += 2;
225  while ( string && string[i] && (string[i] != '*' || string[i+1] != '/') )
226  i++;
227  i++;
228  } else if (string[i] == '/' && string[i+1] == '/') {
229  i += 2;
230  while ( string && string[i] && string[i] != '\n' )
231  i++;
232  } else {
233  for (j = 0; reject && reject[j]; j++) {
234  if (string[i] == reject[j])
235  break;
236  }
237  if (reject && reject[j])
238  break;
239  }
240  }
241  return i;
242 }
243 
244 static uint32_t color_string_to_rgba(const char *p, size_t len)
245 {
246  uint32_t ret = 0xFF000000;
247  const ColorEntry *entry;
248  char color_name[100];
249 
250  if (*p == '#') {
251  p++;
252  len--;
253  if (len == 3) {
254  ret |= (hex_char_to_number(p[2]) << 4) |
255  (hex_char_to_number(p[1]) << 12) |
256  (hex_char_to_number(p[0]) << 20);
257  } else if (len == 4) {
258  ret = (hex_char_to_number(p[3]) << 4) |
259  (hex_char_to_number(p[2]) << 12) |
260  (hex_char_to_number(p[1]) << 20) |
261  (hex_char_to_number(p[0]) << 28);
262  } else if (len == 6) {
263  ret |= hex_char_to_number(p[5]) |
264  (hex_char_to_number(p[4]) << 4) |
265  (hex_char_to_number(p[3]) << 8) |
266  (hex_char_to_number(p[2]) << 12) |
267  (hex_char_to_number(p[1]) << 16) |
268  (hex_char_to_number(p[0]) << 20);
269  } else if (len == 8) {
270  ret = hex_char_to_number(p[7]) |
271  (hex_char_to_number(p[6]) << 4) |
272  (hex_char_to_number(p[5]) << 8) |
273  (hex_char_to_number(p[4]) << 12) |
274  (hex_char_to_number(p[3]) << 16) |
275  (hex_char_to_number(p[2]) << 20) |
276  (hex_char_to_number(p[1]) << 24) |
277  (hex_char_to_number(p[0]) << 28);
278  }
279  } else {
280  len = FFMIN(len, sizeof(color_name) - 1);
281  strncpy(color_name, p, len);
282  color_name[len] = '\0';
283 
284  entry = bsearch(color_name,
285  color_table,
287  sizeof(ColorEntry),
289 
290  if (!entry)
291  return ret;
292 
293  ret = entry->rgb_color;
294  }
295  return ret;
296 }
297 
298 static int ascii2index(const uint8_t *cpixel, int cpp)
299 {
300  const uint8_t *p = cpixel;
301  int n = 0, m = 1, i;
302 
303  for (i = 0; i < cpp; i++) {
304  if (*p < MIN_ELEMENT || *p > MAX_ELEMENT)
305  return AVERROR_INVALIDDATA;
306  n += (*p++ - MIN_ELEMENT) * m;
307  m *= NB_ELEMENTS;
308  }
309  return n;
310 }
311 
313  int *got_frame, AVPacket *avpkt)
314 {
315  XPMDecContext *x = avctx->priv_data;
316  const uint8_t *end, *ptr;
317  int ncolors, cpp, ret, i, j;
318  int64_t size;
319  uint32_t *dst;
320  int width, height;
321 
322  avctx->pix_fmt = AV_PIX_FMT_BGRA;
323 
324  av_fast_padded_malloc(&x->buf, &x->buf_size, avpkt->size);
325  if (!x->buf)
326  return AVERROR(ENOMEM);
327  memcpy(x->buf, avpkt->data, avpkt->size);
328  x->buf[avpkt->size] = 0;
329 
330  ptr = x->buf;
331  end = x->buf + avpkt->size;
332  while (end - ptr > 9 && memcmp(ptr, "/* XPM */", 9))
333  ptr++;
334 
335  if (end - ptr <= 9) {
336  av_log(avctx, AV_LOG_ERROR, "missing signature\n");
337  return AVERROR_INVALIDDATA;
338  }
339 
340  ptr += mod_strcspn(ptr, "\"");
341  if (sscanf(ptr, "\"%u %u %u %u\",",
342  &width, &height, &ncolors, &cpp) != 4) {
343  av_log(avctx, AV_LOG_ERROR, "missing image parameters\n");
344  return AVERROR_INVALIDDATA;
345  }
346 
347  if ((ret = ff_set_dimensions(avctx, width, height)) < 0)
348  return ret;
349 
350  if (cpp <= 0 || cpp >= 5) {
351  av_log(avctx, AV_LOG_ERROR, "unsupported/invalid number of chars per pixel: %d\n", cpp);
352  return AVERROR_INVALIDDATA;
353  }
354 
355  size = 1;
356  for (i = 0; i < cpp; i++)
357  size *= NB_ELEMENTS;
358 
359  if (ncolors <= 0 || ncolors > size) {
360  av_log(avctx, AV_LOG_ERROR, "invalid number of colors: %d\n", ncolors);
361  return AVERROR_INVALIDDATA;
362  }
363 
364  if (size > SIZE_MAX / 4)
365  return AVERROR(ENOMEM);
366 
367  size *= 4;
368 
369  ptr += mod_strcspn(ptr, ",") + 1;
370  if (end - ptr < 1)
371  return AVERROR_INVALIDDATA;
372 
373  if (avctx->skip_frame >= AVDISCARD_ALL)
374  return avpkt->size;
375 
376  if ((ret = ff_get_buffer(avctx, p, 0)) < 0)
377  return ret;
378 
379  av_fast_padded_malloc(&x->pixels, &x->pixels_size, size);
380  if (!x->pixels)
381  return AVERROR(ENOMEM);
382 
383  for (i = 0; i < ncolors; i++) {
384  const uint8_t *index;
385  size_t len;
386 
387  ptr += mod_strcspn(ptr, "\"") + 1;
388  if (end - ptr < cpp)
389  return AVERROR_INVALIDDATA;
390  index = ptr;
391  ptr += cpp;
392 
393  ptr = strstr(ptr, "c ");
394  if (ptr) {
395  ptr += 2;
396  } else {
397  return AVERROR_INVALIDDATA;
398  }
399 
400  len = strcspn(ptr, "\" ");
401 
402  if ((ret = ascii2index(index, cpp)) < 0)
403  return ret;
404 
405  x->pixels[ret] = color_string_to_rgba(ptr, len);
406  ptr += mod_strcspn(ptr, ",") + 1;
407  if (end - ptr < 1)
408  return AVERROR_INVALIDDATA;
409  }
410 
411  for (i = 0; i < avctx->height; i++) {
412  dst = (uint32_t *)(p->data[0] + i * p->linesize[0]);
413  if (end - ptr < 1)
414  return AVERROR_INVALIDDATA;
415  ptr += mod_strcspn(ptr, "\"") + 1;
416  if (end - ptr < 1)
417  return AVERROR_INVALIDDATA;
418 
419  for (j = 0; j < avctx->width; j++) {
420  if (end - ptr < cpp)
421  return AVERROR_INVALIDDATA;
422 
423  if ((ret = ascii2index(ptr, cpp)) < 0)
424  return ret;
425 
426  *dst++ = x->pixels[ret];
427  ptr += cpp;
428  }
429  ptr += mod_strcspn(ptr, ",") + 1;
430  }
431 
432  *got_frame = 1;
433 
434  return avpkt->size;
435 }
436 
438 {
439  XPMDecContext *x = avctx->priv_data;
440  av_freep(&x->pixels);
441 
442  av_freep(&x->buf);
443  x->buf_size = 0;
444 
445  return 0;
446 }
447 
449  .p.name = "xpm",
450  CODEC_LONG_NAME("XPM (X PixMap) image"),
451  .p.type = AVMEDIA_TYPE_VIDEO,
452  .p.id = AV_CODEC_ID_XPM,
453  .p.capabilities = AV_CODEC_CAP_DR1,
454  .priv_data_size = sizeof(XPMDecContext),
455  .close = xpm_decode_close,
456  .caps_internal = FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM,
458 };
NB_ELEMENTS
#define NB_ELEMENTS
Definition: xpmdec.c:32
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:437
entry
#define entry
Definition: aom_film_grain_template.c:66
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:30
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:374
AVPacket::data
uint8_t * data
Definition: packet.h:524
FFCodec
Definition: codec_internal.h:126
MAX_ELEMENT
#define MAX_ELEMENT
Definition: xpmdec.c:31
AV_PIX_FMT_BGRA
@ AV_PIX_FMT_BGRA
packed BGRA 8:8:8:8, 32bpp, BGRABGRA...
Definition: pixfmt.h:102
XPMContext::buf_size
int buf_size
Definition: xpmdec.c:38
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:35
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:395
ff_xpm_decoder
const FFCodec ff_xpm_decoder
Definition: xpmdec.c:448
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:130
AVCodecContext::skip_frame
enum AVDiscard skip_frame
Skip decoding for selected frames.
Definition: avcodec.h:1820
color_table_compare
static int color_table_compare(const void *lhs, const void *rhs)
Definition: xpmdec.c:46
ascii2index
static int ascii2index(const uint8_t *cpixel, int cpp)
Definition: xpmdec.c:298
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
XPMContext::buf
uint8_t * buf
Definition: xpmdec.c:37
width
#define width
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:286
decode.h
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:271
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:218
XPMContext
Definition: xpmdec.c:34
xpm_decode_frame
static int xpm_decode_frame(AVCodecContext *avctx, AVFrame *p, int *got_frame, AVPacket *avpkt)
Definition: xpmdec.c:312
ColorEntry::rgb_color
uint32_t rgb_color
RGB values for the color.
Definition: xpmdec.c:43
index
int index
Definition: gxfenc.c:90
XPMContext::pixels_size
int pixels_size
Definition: xpmdec.c:36
hex_char_to_number
static unsigned hex_char_to_number(uint8_t x)
Definition: xpmdec.c:195
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1575
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:525
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:279
ColorEntry
Definition: xpmdec.c:41
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
TIMES256
#define TIMES256(idx)
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:618
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:657
avcodec.h
ret
ret
Definition: filter_design.txt:187
AVCodecContext
main external API structure.
Definition: avcodec.h:445
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
mem.h
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:472
AVPacket
This structure stores compressed data.
Definition: packet.h:501
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:618
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:419
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:51
ColorEntry::name
const char * name
a string representing the name of the color
Definition: xpmdec.c:42
color_string_to_rgba
static uint32_t color_string_to_rgba(const char *p, size_t len)
Definition: xpmdec.c:244