GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/xpmdec.c Lines: 0 157 0.0 %
Date: 2020-08-14 10:39:37 Branches: 0 116 0.0 %

Line Branch Exec Source
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;
35
    int        pixels_size;
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,
279
                        FF_ARRAY_ELEMS(color_table),
280
                        sizeof(ColorEntry),
281
                        color_table_compare);
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
    int width, height;
315
316
    avctx->pix_fmt = AV_PIX_FMT_BGRA;
317
318
    av_fast_padded_malloc(&x->buf, &x->buf_size, avpkt->size);
319
    if (!x->buf)
320
        return AVERROR(ENOMEM);
321
    memcpy(x->buf, avpkt->data, avpkt->size);
322
    x->buf[avpkt->size] = 0;
323
324
    ptr = x->buf;
325
    end = x->buf + avpkt->size;
326
    while (end - ptr > 9 && memcmp(ptr, "/* XPM */", 9))
327
        ptr++;
328
329
    if (end - ptr <= 9) {
330
        av_log(avctx, AV_LOG_ERROR, "missing signature\n");
331
        return AVERROR_INVALIDDATA;
332
    }
333
334
    ptr += mod_strcspn(ptr, "\"");
335
    if (sscanf(ptr, "\"%u %u %u %u\",",
336
               &width, &height, &ncolors, &cpp) != 4) {
337
        av_log(avctx, AV_LOG_ERROR, "missing image parameters\n");
338
        return AVERROR_INVALIDDATA;
339
    }
340
341
    if ((ret = ff_set_dimensions(avctx, width, height)) < 0)
342
        return ret;
343
344
    if ((ret = ff_get_buffer(avctx, p, 0)) < 0)
345
        return ret;
346
347
    if (cpp <= 0 || cpp >= 5) {
348
        av_log(avctx, AV_LOG_ERROR, "unsupported/invalid number of chars per pixel: %d\n", cpp);
349
        return AVERROR_INVALIDDATA;
350
    }
351
352
    size = 1;
353
    for (i = 0; i < cpp; i++)
354
        size *= NB_ELEMENTS;
355
356
    if (ncolors <= 0 || ncolors > size) {
357
        av_log(avctx, AV_LOG_ERROR, "invalid number of colors: %d\n", ncolors);
358
        return AVERROR_INVALIDDATA;
359
    }
360
361
    size *= 4;
362
363
    av_fast_padded_malloc(&x->pixels, &x->pixels_size, size);
364
    if (!x->pixels)
365
        return AVERROR(ENOMEM);
366
367
    ptr += mod_strcspn(ptr, ",") + 1;
368
    if (end - ptr < 1)
369
        return AVERROR_INVALIDDATA;
370
371
    for (i = 0; i < ncolors; i++) {
372
        const uint8_t *index;
373
        int len;
374
375
        ptr += mod_strcspn(ptr, "\"") + 1;
376
        if (end - ptr < cpp)
377
            return AVERROR_INVALIDDATA;
378
        index = ptr;
379
        ptr += cpp;
380
381
        ptr = strstr(ptr, "c ");
382
        if (ptr) {
383
            ptr += 2;
384
        } else {
385
            return AVERROR_INVALIDDATA;
386
        }
387
388
        len = strcspn(ptr, "\" ");
389
390
        if ((ret = ascii2index(index, cpp)) < 0)
391
            return ret;
392
393
        x->pixels[ret] = color_string_to_rgba(ptr, len);
394
        ptr += mod_strcspn(ptr, ",") + 1;
395
        if (end - ptr < 1)
396
            return AVERROR_INVALIDDATA;
397
    }
398
399
    for (i = 0; i < avctx->height; i++) {
400
        dst = (uint32_t *)(p->data[0] + i * p->linesize[0]);
401
        if (end - ptr < 1)
402
            return AVERROR_INVALIDDATA;
403
        ptr += mod_strcspn(ptr, "\"") + 1;
404
        if (end - ptr < 1)
405
            return AVERROR_INVALIDDATA;
406
407
        for (j = 0; j < avctx->width; j++) {
408
            if (end - ptr < cpp)
409
                return AVERROR_INVALIDDATA;
410
411
            if ((ret = ascii2index(ptr, cpp)) < 0)
412
                return ret;
413
414
            *dst++ = x->pixels[ret];
415
            ptr += cpp;
416
        }
417
        ptr += mod_strcspn(ptr, ",") + 1;
418
    }
419
420
    p->key_frame = 1;
421
    p->pict_type = AV_PICTURE_TYPE_I;
422
423
    *got_frame = 1;
424
425
    return avpkt->size;
426
}
427
428
static av_cold int xpm_decode_close(AVCodecContext *avctx)
429
{
430
    XPMDecContext *x = avctx->priv_data;
431
    av_freep(&x->pixels);
432
433
    av_freep(&x->buf);
434
    x->buf_size = 0;
435
436
    return 0;
437
}
438
439
AVCodec ff_xpm_decoder = {
440
    .name           = "xpm",
441
    .type           = AVMEDIA_TYPE_VIDEO,
442
    .id             = AV_CODEC_ID_XPM,
443
    .priv_data_size = sizeof(XPMDecContext),
444
    .close          = xpm_decode_close,
445
    .decode         = xpm_decode_frame,
446
    .capabilities   = AV_CODEC_CAP_DR1,
447
    .long_name      = NULL_IF_CONFIG_SMALL("XPM (X PixMap) image")
448
};