Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

  1. /*
  2.  * BMP image format decoder
  3.  * Copyright (c) 2005 Mans Rullgard
  4.  *
  5.  * This file is part of FFmpeg.
  6.  *
  7.  * FFmpeg is free software; you can redistribute it and/or
  8.  * modify it under the terms of the GNU Lesser General Public
  9.  * License as published by the Free Software Foundation; either
  10.  * version 2.1 of the License, or (at your option) any later version.
  11.  *
  12.  * FFmpeg is distributed in the hope that it will be useful,
  13.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15.  * Lesser General Public License for more details.
  16.  *
  17.  * You should have received a copy of the GNU Lesser General Public
  18.  * License along with FFmpeg; if not, write to the Free Software
  19.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  20.  */
  21.  
  22. #include <inttypes.h>
  23.  
  24. #include "avcodec.h"
  25. #include "bytestream.h"
  26. #include "bmp.h"
  27. #include "internal.h"
  28. #include "msrledec.h"
  29.  
  30. static int bmp_decode_frame(AVCodecContext *avctx,
  31.                             void *data, int *got_frame,
  32.                             AVPacket *avpkt)
  33. {
  34.     const uint8_t *buf = avpkt->data;
  35.     int buf_size       = avpkt->size;
  36.     AVFrame *p         = data;
  37.     unsigned int fsize, hsize;
  38.     int width, height;
  39.     unsigned int depth;
  40.     BiCompression comp;
  41.     unsigned int ihsize;
  42.     int i, j, n, linesize, ret;
  43.     uint32_t rgb[3] = {0};
  44.     uint32_t alpha = 0;
  45.     uint8_t *ptr;
  46.     int dsize;
  47.     const uint8_t *buf0 = buf;
  48.     GetByteContext gb;
  49.  
  50.     if (buf_size < 14) {
  51.         av_log(avctx, AV_LOG_ERROR, "buf size too small (%d)\n", buf_size);
  52.         return AVERROR_INVALIDDATA;
  53.     }
  54.  
  55.     if (bytestream_get_byte(&buf) != 'B' ||
  56.         bytestream_get_byte(&buf) != 'M') {
  57.         av_log(avctx, AV_LOG_ERROR, "bad magic number\n");
  58.         return AVERROR_INVALIDDATA;
  59.     }
  60.  
  61.     fsize = bytestream_get_le32(&buf);
  62.     if (buf_size < fsize) {
  63.         av_log(avctx, AV_LOG_ERROR, "not enough data (%d < %u), trying to decode anyway\n",
  64.                buf_size, fsize);
  65.         fsize = buf_size;
  66.     }
  67.  
  68.     buf += 2; /* reserved1 */
  69.     buf += 2; /* reserved2 */
  70.  
  71.     hsize  = bytestream_get_le32(&buf); /* header size */
  72.     ihsize = bytestream_get_le32(&buf); /* more header size */
  73.     if (ihsize + 14LL > hsize) {
  74.         av_log(avctx, AV_LOG_ERROR, "invalid header size %u\n", hsize);
  75.         return AVERROR_INVALIDDATA;
  76.     }
  77.  
  78.     /* sometimes file size is set to some headers size, set a real size in that case */
  79.     if (fsize == 14 || fsize == ihsize + 14)
  80.         fsize = buf_size - 2;
  81.  
  82.     if (fsize <= hsize) {
  83.         av_log(avctx, AV_LOG_ERROR,
  84.                "Declared file size is less than header size (%u < %u)\n",
  85.                fsize, hsize);
  86.         return AVERROR_INVALIDDATA;
  87.     }
  88.  
  89.     switch (ihsize) {
  90.     case  40: // windib
  91.     case  56: // windib v3
  92.     case  64: // OS/2 v2
  93.     case 108: // windib v4
  94.     case 124: // windib v5
  95.         width  = bytestream_get_le32(&buf);
  96.         height = bytestream_get_le32(&buf);
  97.         break;
  98.     case  12: // OS/2 v1
  99.         width  = bytestream_get_le16(&buf);
  100.         height = bytestream_get_le16(&buf);
  101.         break;
  102.     default:
  103.         av_log(avctx, AV_LOG_ERROR, "unsupported BMP file, patch welcome\n");
  104.         return AVERROR_PATCHWELCOME;
  105.     }
  106.  
  107.     /* planes */
  108.     if (bytestream_get_le16(&buf) != 1) {
  109.         av_log(avctx, AV_LOG_ERROR, "invalid BMP header\n");
  110.         return AVERROR_INVALIDDATA;
  111.     }
  112.  
  113.     depth = bytestream_get_le16(&buf);
  114.  
  115.     if (ihsize >= 40)
  116.         comp = bytestream_get_le32(&buf);
  117.     else
  118.         comp = BMP_RGB;
  119.  
  120.     if (comp != BMP_RGB && comp != BMP_BITFIELDS && comp != BMP_RLE4 &&
  121.         comp != BMP_RLE8) {
  122.         av_log(avctx, AV_LOG_ERROR, "BMP coding %d not supported\n", comp);
  123.         return AVERROR_INVALIDDATA;
  124.     }
  125.  
  126.     if (comp == BMP_BITFIELDS) {
  127.         buf += 20;
  128.         rgb[0] = bytestream_get_le32(&buf);
  129.         rgb[1] = bytestream_get_le32(&buf);
  130.         rgb[2] = bytestream_get_le32(&buf);
  131.         if (ihsize > 40)
  132.         alpha = bytestream_get_le32(&buf);
  133.     }
  134.  
  135.     avctx->width  = width;
  136.     avctx->height = height > 0 ? height : -height;
  137.  
  138.     avctx->pix_fmt = AV_PIX_FMT_NONE;
  139.  
  140.     switch (depth) {
  141.     case 32:
  142.         if (comp == BMP_BITFIELDS) {
  143.             if (rgb[0] == 0xFF000000 && rgb[1] == 0x00FF0000 && rgb[2] == 0x0000FF00)
  144.                 avctx->pix_fmt = alpha ? AV_PIX_FMT_ABGR : AV_PIX_FMT_0BGR;
  145.             else if (rgb[0] == 0x00FF0000 && rgb[1] == 0x0000FF00 && rgb[2] == 0x000000FF)
  146.                 avctx->pix_fmt = alpha ? AV_PIX_FMT_BGRA : AV_PIX_FMT_BGR0;
  147.             else if (rgb[0] == 0x0000FF00 && rgb[1] == 0x00FF0000 && rgb[2] == 0xFF000000)
  148.                 avctx->pix_fmt = alpha ? AV_PIX_FMT_ARGB : AV_PIX_FMT_0RGB;
  149.             else if (rgb[0] == 0x000000FF && rgb[1] == 0x0000FF00 && rgb[2] == 0x00FF0000)
  150.                 avctx->pix_fmt = alpha ? AV_PIX_FMT_RGBA : AV_PIX_FMT_RGB0;
  151.             else {
  152.                 av_log(avctx, AV_LOG_ERROR, "Unknown bitfields %0X %0X %0X\n", rgb[0], rgb[1], rgb[2]);
  153.                 return AVERROR(EINVAL);
  154.             }
  155.         } else {
  156.             avctx->pix_fmt = AV_PIX_FMT_BGRA;
  157.         }
  158.         break;
  159.     case 24:
  160.         avctx->pix_fmt = AV_PIX_FMT_BGR24;
  161.         break;
  162.     case 16:
  163.         if (comp == BMP_RGB)
  164.             avctx->pix_fmt = AV_PIX_FMT_RGB555;
  165.         else if (comp == BMP_BITFIELDS) {
  166.             if (rgb[0] == 0xF800 && rgb[1] == 0x07E0 && rgb[2] == 0x001F)
  167.                avctx->pix_fmt = AV_PIX_FMT_RGB565;
  168.             else if (rgb[0] == 0x7C00 && rgb[1] == 0x03E0 && rgb[2] == 0x001F)
  169.                avctx->pix_fmt = AV_PIX_FMT_RGB555;
  170.             else if (rgb[0] == 0x0F00 && rgb[1] == 0x00F0 && rgb[2] == 0x000F)
  171.                avctx->pix_fmt = AV_PIX_FMT_RGB444;
  172.             else {
  173.                av_log(avctx, AV_LOG_ERROR,
  174.                       "Unknown bitfields %0"PRIX32" %0"PRIX32" %0"PRIX32"\n",
  175.                       rgb[0], rgb[1], rgb[2]);
  176.                return AVERROR(EINVAL);
  177.             }
  178.         }
  179.         break;
  180.     case 8:
  181.         if (hsize - ihsize - 14 > 0)
  182.             avctx->pix_fmt = AV_PIX_FMT_PAL8;
  183.         else
  184.             avctx->pix_fmt = AV_PIX_FMT_GRAY8;
  185.         break;
  186.     case 1:
  187.     case 4:
  188.         if (hsize - ihsize - 14 > 0) {
  189.             avctx->pix_fmt = AV_PIX_FMT_PAL8;
  190.         } else {
  191.             av_log(avctx, AV_LOG_ERROR, "Unknown palette for %u-colour BMP\n",
  192.                    1 << depth);
  193.             return AVERROR_INVALIDDATA;
  194.         }
  195.         break;
  196.     default:
  197.         av_log(avctx, AV_LOG_ERROR, "depth %u not supported\n", depth);
  198.         return AVERROR_INVALIDDATA;
  199.     }
  200.  
  201.     if (avctx->pix_fmt == AV_PIX_FMT_NONE) {
  202.         av_log(avctx, AV_LOG_ERROR, "unsupported pixel format\n");
  203.         return AVERROR_INVALIDDATA;
  204.     }
  205.  
  206.     if ((ret = ff_get_buffer(avctx, p, 0)) < 0)
  207.         return ret;
  208.     p->pict_type = AV_PICTURE_TYPE_I;
  209.     p->key_frame = 1;
  210.  
  211.     buf   = buf0 + hsize;
  212.     dsize = buf_size - hsize;
  213.  
  214.     /* Line size in file multiple of 4 */
  215.     n = ((avctx->width * depth + 31) / 8) & ~3;
  216.  
  217.     if (n * avctx->height > dsize && comp != BMP_RLE4 && comp != BMP_RLE8) {
  218.         n = (avctx->width * depth + 7) / 8;
  219.         if (n * avctx->height > dsize) {
  220.             av_log(avctx, AV_LOG_ERROR, "not enough data (%d < %d)\n",
  221.                    dsize, n * avctx->height);
  222.             return AVERROR_INVALIDDATA;
  223.         }
  224.         av_log(avctx, AV_LOG_ERROR, "data size too small, assuming missing line alignment\n");
  225.     }
  226.  
  227.     // RLE may skip decoding some picture areas, so blank picture before decoding
  228.     if (comp == BMP_RLE4 || comp == BMP_RLE8)
  229.         memset(p->data[0], 0, avctx->height * p->linesize[0]);
  230.  
  231.     if (height > 0) {
  232.         ptr      = p->data[0] + (avctx->height - 1) * p->linesize[0];
  233.         linesize = -p->linesize[0];
  234.     } else {
  235.         ptr      = p->data[0];
  236.         linesize = p->linesize[0];
  237.     }
  238.  
  239.     if (avctx->pix_fmt == AV_PIX_FMT_PAL8) {
  240.         int colors = 1 << depth;
  241.  
  242.         memset(p->data[1], 0, 1024);
  243.  
  244.         if (ihsize >= 36) {
  245.             int t;
  246.             buf = buf0 + 46;
  247.             t   = bytestream_get_le32(&buf);
  248.             if (t < 0 || t > (1 << depth)) {
  249.                 av_log(avctx, AV_LOG_ERROR,
  250.                        "Incorrect number of colors - %X for bitdepth %u\n",
  251.                        t, depth);
  252.             } else if (t) {
  253.                 colors = t;
  254.             }
  255.         } else {
  256.             colors = FFMIN(256, (hsize-ihsize-14) / 3);
  257.         }
  258.         buf = buf0 + 14 + ihsize; //palette location
  259.         // OS/2 bitmap, 3 bytes per palette entry
  260.         if ((hsize-ihsize-14) < (colors << 2)) {
  261.             if ((hsize-ihsize-14) < colors * 3) {
  262.                 av_log(avctx, AV_LOG_ERROR, "palette doesn't fit in packet\n");
  263.                 return AVERROR_INVALIDDATA;
  264.             }
  265.             for (i = 0; i < colors; i++)
  266.                 ((uint32_t*)p->data[1])[i] = (0xFFU<<24) | bytestream_get_le24(&buf);
  267.         } else {
  268.             for (i = 0; i < colors; i++)
  269.                 ((uint32_t*)p->data[1])[i] = 0xFFU << 24 | bytestream_get_le32(&buf);
  270.         }
  271.         buf = buf0 + hsize;
  272.     }
  273.     if (comp == BMP_RLE4 || comp == BMP_RLE8) {
  274.         if (comp == BMP_RLE8 && height < 0) {
  275.             p->data[0]    +=  p->linesize[0] * (avctx->height - 1);
  276.             p->linesize[0] = -p->linesize[0];
  277.         }
  278.         bytestream2_init(&gb, buf, dsize);
  279.         ff_msrle_decode(avctx, (AVPicture*)p, depth, &gb);
  280.         if (height < 0) {
  281.             p->data[0]    +=  p->linesize[0] * (avctx->height - 1);
  282.             p->linesize[0] = -p->linesize[0];
  283.         }
  284.     } else {
  285.         switch (depth) {
  286.         case 1:
  287.             for (i = 0; i < avctx->height; i++) {
  288.                 int j;
  289.                 for (j = 0; j < n; j++) {
  290.                     ptr[j*8+0] =  buf[j] >> 7;
  291.                     ptr[j*8+1] = (buf[j] >> 6) & 1;
  292.                     ptr[j*8+2] = (buf[j] >> 5) & 1;
  293.                     ptr[j*8+3] = (buf[j] >> 4) & 1;
  294.                     ptr[j*8+4] = (buf[j] >> 3) & 1;
  295.                     ptr[j*8+5] = (buf[j] >> 2) & 1;
  296.                     ptr[j*8+6] = (buf[j] >> 1) & 1;
  297.                     ptr[j*8+7] =  buf[j]       & 1;
  298.                 }
  299.                 buf += n;
  300.                 ptr += linesize;
  301.             }
  302.             break;
  303.         case 8:
  304.         case 24:
  305.         case 32:
  306.             for (i = 0; i < avctx->height; i++) {
  307.                 memcpy(ptr, buf, n);
  308.                 buf += n;
  309.                 ptr += linesize;
  310.             }
  311.             break;
  312.         case 4:
  313.             for (i = 0; i < avctx->height; i++) {
  314.                 int j;
  315.                 for (j = 0; j < n; j++) {
  316.                     ptr[j*2+0] = (buf[j] >> 4) & 0xF;
  317.                     ptr[j*2+1] = buf[j] & 0xF;
  318.                 }
  319.                 buf += n;
  320.                 ptr += linesize;
  321.             }
  322.             break;
  323.         case 16:
  324.             for (i = 0; i < avctx->height; i++) {
  325.                 const uint16_t *src = (const uint16_t *) buf;
  326.                 uint16_t *dst       = (uint16_t *) ptr;
  327.  
  328.                 for (j = 0; j < avctx->width; j++)
  329.                     *dst++ = av_le2ne16(*src++);
  330.  
  331.                 buf += n;
  332.                 ptr += linesize;
  333.             }
  334.             break;
  335.         default:
  336.             av_log(avctx, AV_LOG_ERROR, "BMP decoder is broken\n");
  337.             return AVERROR_INVALIDDATA;
  338.         }
  339.     }
  340.  
  341.     *got_frame = 1;
  342.  
  343.     return buf_size;
  344. }
  345.  
  346. AVCodec ff_bmp_decoder = {
  347.     .name           = "bmp",
  348.     .long_name      = NULL_IF_CONFIG_SMALL("BMP (Windows and OS/2 bitmap)"),
  349.     .type           = AVMEDIA_TYPE_VIDEO,
  350.     .id             = AV_CODEC_ID_BMP,
  351.     .decode         = bmp_decode_frame,
  352.     .capabilities   = AV_CODEC_CAP_DR1,
  353. };
  354.