git.sesse.net Git - ffmpeg/blob - libavcodec/xpmdec.c

   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 const 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 };