|
|
/**
|
|
|
* xrdp: A Remote Desktop Protocol server.
|
|
|
*
|
|
|
* Copyright (C) Laxmikant Rashinkar 2004-2012
|
|
|
*
|
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
|
* you may not use this file except in compliance with the License.
|
|
|
* You may obtain a copy of the License at
|
|
|
*
|
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
|
*
|
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
|
* See the License for the specific language governing permissions and
|
|
|
* limitations under the License.
|
|
|
*/
|
|
|
|
|
|
#include <stdio.h>
|
|
|
#include <stdlib.h>
|
|
|
#include <sys/types.h>
|
|
|
#include <unistd.h>
|
|
|
#include <fcntl.h>
|
|
|
#include <stdint.h>
|
|
|
#include "common.h"
|
|
|
|
|
|
// multi byte values are stored in little endian
|
|
|
|
|
|
struct bmp_magic
|
|
|
{
|
|
|
char magic[2];
|
|
|
};
|
|
|
|
|
|
struct bmp_hdr
|
|
|
{
|
|
|
uint32_t size; // file size in bytes
|
|
|
uint16_t reserved1;
|
|
|
uint16_t reserved2;
|
|
|
uint32_t offset; // offset to image data, in bytes
|
|
|
};
|
|
|
|
|
|
struct dib_hdr
|
|
|
{
|
|
|
uint32_t hdr_size;
|
|
|
int32_t width;
|
|
|
int32_t height;
|
|
|
uint16_t nplanes;
|
|
|
uint16_t bpp;
|
|
|
uint32_t compress_type;
|
|
|
uint32_t image_size;
|
|
|
int32_t hres;
|
|
|
int32_t vres;
|
|
|
uint32_t ncolors;
|
|
|
uint32_t nimpcolors;
|
|
|
};
|
|
|
|
|
|
// forward declarations
|
|
|
int parse_bmp(char *filename, struct pic_info *pic_info);
|
|
|
int parse_bmp_24(struct bmp_hdr *bmp_hdr, struct dib_hdr *dib_hdr, int fd, struct pic_info *pic_info);
|
|
|
|
|
|
int parse_bmp(char *filename, struct pic_info *pic_info)
|
|
|
{
|
|
|
int got_magic;
|
|
|
int fd;
|
|
|
int rval;
|
|
|
|
|
|
struct bmp_magic magic;
|
|
|
struct bmp_hdr bmp_hdr;
|
|
|
struct dib_hdr dib_hdr;
|
|
|
|
|
|
if ((fd = open(filename, O_RDONLY)) < 0)
|
|
|
{
|
|
|
printf("error opening %s\n", filename);
|
|
|
return -1;
|
|
|
}
|
|
|
|
|
|
// read BMP magic...
|
|
|
if ((rval = read(fd, magic.magic, 2)) != 2)
|
|
|
{
|
|
|
fprintf(stderr, "error reading BMP signature from file %s\n", filename);
|
|
|
return -1;
|
|
|
}
|
|
|
|
|
|
got_magic = 0;
|
|
|
|
|
|
// ...and confirm that this is indeed a BMP file
|
|
|
if ((magic.magic[0] == 'B') && (magic.magic[1] == 'M'))
|
|
|
{
|
|
|
// BM – Windows 3.1x, 95, NT, ... etc
|
|
|
got_magic = 1;
|
|
|
}
|
|
|
else if ((magic.magic[0] == 'B') && (magic.magic[1] == 'A'))
|
|
|
{
|
|
|
// BA – OS/2 struct Bitmap Array
|
|
|
got_magic = 1;
|
|
|
}
|
|
|
else if ((magic.magic[0] == 'C') && (magic.magic[1] == 'I'))
|
|
|
{
|
|
|
// CI – OS/2 struct Color Icon
|
|
|
got_magic = 1;
|
|
|
}
|
|
|
else if ((magic.magic[0] == 'C') && (magic.magic[1] == 'P'))
|
|
|
{
|
|
|
// CP – OS/2 const Color Pointer
|
|
|
got_magic = 1;
|
|
|
}
|
|
|
else if ((magic.magic[0] == 'I') && (magic.magic[1] == 'C'))
|
|
|
{
|
|
|
// IC – OS/2 struct Icon
|
|
|
got_magic = 1;
|
|
|
}
|
|
|
else if ((magic.magic[0] == 'P') && (magic.magic[1] == 'T'))
|
|
|
{
|
|
|
// PT – OS/2 Pointer
|
|
|
got_magic = 1;
|
|
|
}
|
|
|
|
|
|
if (!got_magic)
|
|
|
{
|
|
|
fprintf(stderr, "%s is not a valid BMP file\n", filename);
|
|
|
return -1;
|
|
|
}
|
|
|
|
|
|
// read BMP header
|
|
|
if ((rval = read(fd, &bmp_hdr, sizeof(bmp_hdr))) < sizeof(bmp_hdr))
|
|
|
{
|
|
|
fprintf(stderr, "error BMP header from file %s\n", filename);
|
|
|
return -1;
|
|
|
}
|
|
|
|
|
|
// read DIB header
|
|
|
if ((rval = read(fd, &dib_hdr, sizeof(dib_hdr))) < sizeof(dib_hdr))
|
|
|
{
|
|
|
fprintf(stderr, "error reading DIB header from file %s\n", filename);
|
|
|
return -1;
|
|
|
}
|
|
|
|
|
|
#if 0
|
|
|
printf("header size: %d\n", dib_hdr.hdr_size);
|
|
|
printf("width: %d\n", dib_hdr.width);
|
|
|
printf("height: %d\n", dib_hdr.height);
|
|
|
printf("num planes: %d\n", dib_hdr.nplanes);
|
|
|
printf("bpp: %d\n", dib_hdr.bpp);
|
|
|
printf("comp type: %d\n", dib_hdr.compress_type);
|
|
|
printf("image size: %d\n", dib_hdr.image_size);
|
|
|
printf("hres: %d\n", dib_hdr.hres);
|
|
|
printf("vres: %d\n", dib_hdr.vres);
|
|
|
printf("ncolors: %d\n", dib_hdr.ncolors);
|
|
|
printf("nimpcolors: %d\n", dib_hdr.nimpcolors);
|
|
|
#endif
|
|
|
|
|
|
if (dib_hdr.compress_type)
|
|
|
{
|
|
|
printf("TODO: compressed images not yet supported\n");
|
|
|
return -1;
|
|
|
}
|
|
|
|
|
|
pic_info->width = dib_hdr.width;
|
|
|
pic_info->height = dib_hdr.height;
|
|
|
|
|
|
if (dib_hdr.bpp == 24)
|
|
|
{
|
|
|
rval = parse_bmp_24(&bmp_hdr, &dib_hdr, fd, pic_info);
|
|
|
}
|
|
|
|
|
|
close(fd);
|
|
|
return rval;
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* extract 24bit BMP data from image file
|
|
|
*
|
|
|
* @return 0 on success
|
|
|
* @return -1 on failure
|
|
|
*/
|
|
|
|
|
|
int parse_bmp_24(
|
|
|
struct bmp_hdr *bmp_hdr,
|
|
|
struct dib_hdr *dib_hdr,
|
|
|
int fd,
|
|
|
struct pic_info *pic_info
|
|
|
)
|
|
|
{
|
|
|
char *file_data;
|
|
|
char *ptr_file_data;
|
|
|
char *mem_data;
|
|
|
char *ptr_mem_data;
|
|
|
char *cptr;
|
|
|
|
|
|
int w = dib_hdr->width; // picture width
|
|
|
int h = dib_hdr->height; // picture height
|
|
|
int bpl; // bytes per line
|
|
|
int bytes;
|
|
|
int i;
|
|
|
int j;
|
|
|
|
|
|
// bytes per image line = width x bytes_per_pixel + padding
|
|
|
i = (w * 3) % 4;
|
|
|
j = (i == 0) ? 0 : 4 - i;
|
|
|
bpl = w * 3 + j;
|
|
|
|
|
|
// 24 bit depth, no alpha channel
|
|
|
file_data = (char *) malloc(h * bpl);
|
|
|
|
|
|
// point to first line in image data, which is stored in reverse order
|
|
|
ptr_file_data = (file_data + dib_hdr->image_size) - bpl;
|
|
|
|
|
|
// 24 bit depth, with alpha channel
|
|
|
mem_data = (char *) malloc(w * h * 4);
|
|
|
ptr_mem_data = mem_data;
|
|
|
|
|
|
pic_info->pixel_data = ptr_mem_data;
|
|
|
|
|
|
// seek to beginning of pixel data
|
|
|
lseek(fd, bmp_hdr->offset, SEEK_SET);
|
|
|
|
|
|
// read all pixel data
|
|
|
bytes = read(fd, file_data, dib_hdr->image_size);
|
|
|
|
|
|
// convert 24bit to 24 bit with alpha and store in reverse
|
|
|
for (i = 0; i < h; i ++)
|
|
|
{
|
|
|
cptr = ptr_file_data;
|
|
|
|
|
|
for (j = 0; j < w; j++)
|
|
|
{
|
|
|
*ptr_mem_data++ = *cptr++; // blue value
|
|
|
*ptr_mem_data++ = *cptr++; // green value
|
|
|
*ptr_mem_data++ = *cptr++; // red value
|
|
|
*ptr_mem_data++ = 0; // alpha channel
|
|
|
}
|
|
|
|
|
|
ptr_file_data -= bpl;
|
|
|
}
|
|
|
|
|
|
free(file_data);
|
|
|
return 0;
|
|
|
}
|