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/parseutils.h"
25 #include "libavutil/avstring.h"
26 #include "avcodec.h"
27 #include "internal.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;
37  int buf_size;
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,
279  FF_ARRAY_ELEMS(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 
305 static int xpm_decode_frame(AVCodecContext *avctx, void *data,
306  int *got_frame, AVPacket *avpkt)
307 {
308  XPMDecContext *x = avctx->priv_data;
309  AVFrame *p=data;
310  const uint8_t *end, *ptr;
311  int ncolors, cpp, ret, i, j;
312  int64_t size;
313  uint32_t *dst;
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  &avctx->width, &avctx->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, avctx->width, avctx->height)) < 0)
341  return ret;
342 
343  if ((ret = ff_get_buffer(avctx, p, 0)) < 0)
344  return ret;
345 
346  if (cpp <= 0 || cpp >= 5) {
347  av_log(avctx, AV_LOG_ERROR, "unsupported/invalid number of chars per pixel: %d\n", cpp);
348  return AVERROR_INVALIDDATA;
349  }
350 
351  size = 1;
352  for (i = 0; i < cpp; i++)
353  size *= NB_ELEMENTS;
354 
355  if (ncolors <= 0 || ncolors > size) {
356  av_log(avctx, AV_LOG_ERROR, "invalid number of colors: %d\n", ncolors);
357  return AVERROR_INVALIDDATA;
358  }
359 
360  size *= 4;
361 
362  av_fast_padded_malloc(&x->pixels, &x->pixels_size, size);
363  if (!x->pixels)
364  return AVERROR(ENOMEM);
365 
366  ptr += mod_strcspn(ptr, ",") + 1;
367  if (end - ptr < 1)
368  return AVERROR_INVALIDDATA;
369 
370  for (i = 0; i < ncolors; i++) {
371  const uint8_t *index;
372  int len;
373 
374  ptr += mod_strcspn(ptr, "\"") + 1;
375  if (end - ptr < cpp)
376  return AVERROR_INVALIDDATA;
377  index = ptr;
378  ptr += cpp;
379 
380  ptr = strstr(ptr, "c ");
381  if (ptr) {
382  ptr += 2;
383  } else {
384  return AVERROR_INVALIDDATA;
385  }
386 
387  len = strcspn(ptr, "\" ");
388 
389  if ((ret = ascii2index(index, cpp)) < 0)
390  return ret;
391 
392  x->pixels[ret] = color_string_to_rgba(ptr, len);
393  ptr += mod_strcspn(ptr, ",") + 1;
394  if (end - ptr < 1)
395  return AVERROR_INVALIDDATA;
396  }
397 
398  for (i = 0; i < avctx->height; i++) {
399  dst = (uint32_t *)(p->data[0] + i * p->linesize[0]);
400  if (end - ptr < 1)
401  return AVERROR_INVALIDDATA;
402  ptr += mod_strcspn(ptr, "\"") + 1;
403  if (end - ptr < 1)
404  return AVERROR_INVALIDDATA;
405 
406  for (j = 0; j < avctx->width; j++) {
407  if (end - ptr < cpp)
408  return AVERROR_INVALIDDATA;
409 
410  if ((ret = ascii2index(ptr, cpp)) < 0)
411  return ret;
412 
413  *dst++ = x->pixels[ret];
414  ptr += cpp;
415  }
416  ptr += mod_strcspn(ptr, ",") + 1;
417  }
418 
419  p->key_frame = 1;
421 
422  *got_frame = 1;
423 
424  return avpkt->size;
425 }
426 
428 {
429  XPMDecContext *x = avctx->priv_data;
430  av_freep(&x->pixels);
431 
432  av_freep(&x->buf);
433  x->buf_size = 0;
434 
435  return 0;
436 }
437 
439  .name = "xpm",
440  .type = AVMEDIA_TYPE_VIDEO,
441  .id = AV_CODEC_ID_XPM,
442  .priv_data_size = sizeof(XPMDecContext),
443  .close = xpm_decode_close,
445  .capabilities = AV_CODEC_CAP_DR1,
446  .long_name = NULL_IF_CONFIG_SMALL("XPM (X PixMap) image")
447 };
static int xpm_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: xpmdec.c:305
static int color_table_compare(const void *lhs, const void *rhs)
Definition: xpmdec.c:45
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
This structure describes decoded (raw) audio or video data.
Definition: frame.h:268
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
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:104
int size
Definition: avcodec.h:1478
const char * name
a string representing the name of the color
Definition: xpmdec.c:41
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1775
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:70
int buf_size
Definition: xpmdec.c:37
AVCodec.
Definition: avcodec.h:3477
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:42
AVCodec ff_xpm_decoder
Definition: xpmdec.c:438
uint8_t
#define av_cold
Definition: attributes.h:82
static uint32_t color_string_to_rgba(const char *p, int len)
Definition: xpmdec.c:236
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:90
uint8_t * data
Definition: avcodec.h:1477
ptrdiff_t size
Definition: opengl_enc.c:100
#define av_log(a,...)
uint32_t rgb_color
RGB values for the color.
Definition: xpmdec.c:42
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:260
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
static av_cold int xpm_decode_close(AVCodecContext *avctx)
Definition: xpmdec.c:427
static const ColorEntry color_table[]
Definition: xpmdec.c:50
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:186
packed BGRA 8:8:8:8, 32bpp, BGRABGRA...
Definition: pixfmt.h:95
const char * name
Name of the codec implementation.
Definition: avcodec.h:3484
#define FFMAX(a, b)
Definition: common.h:94
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:351
#define FFMIN(a, b)
Definition: common.h:96
int av_strcasecmp(const char *a, const char *b)
Locale-independent case-insensitive compare.
Definition: avstring.c:213
int width
picture width / height.
Definition: avcodec.h:1738
int n
Definition: avisynth_c.h:760
#define FF_ARRAY_ELEMS(a)
Libavcodec external API header.
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:299
main external API structure.
Definition: avcodec.h:1565
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1964
int index
Definition: gxfenc.c:89
int pixels_size
Definition: xpmdec.c:35
misc parsing utilities
#define NB_ELEMENTS
Definition: xpmdec.c:31
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:282
static size_t mod_strcspn(const char *string, const char *reject)
Definition: xpmdec.c:210
common internal api header.
void * priv_data
Definition: avcodec.h:1592
int len
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:346
#define MAX_ELEMENT
Definition: xpmdec.c:30
#define MIN_ELEMENT
Definition: xpmdec.c:29
uint8_t * buf
Definition: xpmdec.c:36
#define av_freep(p)
static int ascii2index(const uint8_t *cpixel, int cpp)
Definition: xpmdec.c:291
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
uint32_t * pixels
Definition: xpmdec.c:34
This structure stores compressed data.
Definition: avcodec.h:1454
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:981
static unsigned hex_char_to_number(uint8_t x)
Definition: xpmdec.c:194
const char * name
Definition: opengl_enc.c:102