| /* |
| |
| * Copyright (c) 2012-2017 The Khronos Group Inc. |
| * |
| * 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 "test.h" |
| #include "test_bmp.h" |
| |
| #include <assert.h> |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <string.h> |
| |
| struct GrfmtReader; |
| typedef unsigned char uchar; |
| |
| typedef void (*GrfmtReleaseReader)(struct GrfmtReader* reader); |
| typedef struct GrfmtReader* (*GrfmtReadHeader)(const uchar* data, int size, int* width, int* height, int* iscolor); |
| typedef int (*GrfmtReadData)(struct GrfmtReader* reader, uchar* data, int step, int color); |
| |
| typedef struct GrfmtReader |
| { |
| GrfmtReleaseReader release; |
| GrfmtReadData read; |
| } |
| GrfmtReader; |
| |
| typedef struct PaletteEntry |
| { |
| uchar b, g, r, a; |
| } |
| PaletteEntry; |
| |
| typedef enum BmpCompression |
| { |
| BMP_RGB = 0, |
| BMP_RLE8 = 1, |
| BMP_RLE4 = 2, |
| BMP_BITFIELDS = 3 |
| } |
| BmpCompression; |
| |
| typedef struct GrfmtBmpReader |
| { |
| GrfmtReader base; |
| PaletteEntry m_palette[256]; |
| const uchar* m_data; |
| int m_datasize; |
| int m_offset; |
| int m_width; |
| int m_height; |
| int m_bpp; |
| int m_origin; |
| BmpCompression m_rle_code; |
| } |
| GrfmtBmpReader; |
| |
| |
| static void releaseBmpReader(struct GrfmtReader* reader) |
| { |
| if(reader) |
| ct_free_mem(reader); |
| } |
| |
| #define GET_DWORD(p) ((p) += 4, ((p)[-4] | ((p)[-3]<<8) | ((p)[-2]<<16) | ((p)[-1]<<24))) |
| |
| static int isColorPalette(const PaletteEntry* pal, int bpp) |
| { |
| int j, clrused = 1 << bpp; |
| for( j = 0; j < clrused; j++ ) |
| if( pal[j].b != pal[j].g || pal[j].b != pal[j].r ) |
| return 1; |
| return 0; |
| } |
| |
| |
| #define SCALE 14 |
| #define cR (int)(0.299*(1 << SCALE) + 0.5) |
| #define cG (int)(0.587*(1 << SCALE) + 0.5) |
| #define cB ((1 << SCALE) - cR - cG) |
| |
| static void cvtRGBToGray( const uchar* src, uchar* gray, int n, int scn, int blue_idx ) |
| { |
| int i; |
| for( i = 0; i < n; i++, src += scn ) |
| { |
| gray[i] = (uchar)((src[blue_idx]*cB + src[1]*cG + src[blue_idx^2]*cR + (1 << (SCALE-1))) >> SCALE); |
| } |
| } |
| |
| static void cvtRGBToRGB( const uchar* src, uchar* dst, int n, |
| int scn, int sblue_idx, int dcn, int dblue_idx ) |
| { |
| int i; |
| for( i = 0; i < n; i++, src += scn, dst += dcn ) |
| { |
| dst[dblue_idx] = src[sblue_idx]; |
| dst[1] = src[1]; |
| dst[dblue_idx^2] = src[sblue_idx^2]; |
| if( dcn == 4 ) |
| dst[3] = scn < 4 ? 255 : src[3]; |
| } |
| } |
| |
| static void fillColorRow8( uchar* data, const uchar* indices, int n, |
| const PaletteEntry* palette, int dcn, int dblue_idx ) |
| { |
| int i; |
| for( i = 0; i < n; i++, data += dcn ) |
| { |
| const PaletteEntry* p = palette + indices[i]; |
| data[dblue_idx] = p->b; |
| data[1] = p->g; |
| data[dblue_idx^2] = p->r; |
| if( dcn == 4 ) |
| data[3] = 255; |
| } |
| } |
| |
| |
| static void fillGrayRow8( uchar* data, const uchar* indices, int n, const uchar* palette ) |
| { |
| int i; |
| for( i = 0; i < n; i++ ) |
| { |
| data[i] = palette[indices[i]]; |
| } |
| } |
| |
| |
| static void fillColorRow4( uchar* data, const uchar* indices, int n, |
| const PaletteEntry* palette, int dcn, int dblue_idx ) |
| { |
| int i = 0; |
| for( ; i <= n - 2; i += 2, data += dcn*2 ) |
| { |
| int idx = *indices++; |
| const PaletteEntry* p0 = palette + (idx >> 4); |
| const PaletteEntry* p1 = palette + (idx & 15); |
| data[dblue_idx] = p0->b; |
| data[1] = p0->g; |
| data[dblue_idx^2] = p0->r; |
| data[dcn + dblue_idx] = p1->b; |
| data[dcn + 1] = p1->g; |
| data[dcn + (dblue_idx^2)] = p1->r; |
| if( dcn == 4 ) |
| data[3] = data[7] = 255; |
| } |
| |
| if( i < n ) |
| { |
| const PaletteEntry* p0 = palette + (indices[0] >> 4); |
| data[dblue_idx] = p0->b; |
| data[1] = p0->g; |
| data[dblue_idx^2] = p0->r; |
| if( dcn == 4 ) |
| data[3] = 255; |
| } |
| } |
| |
| |
| static void fillGrayRow4( uchar* data, const uchar* indices, int n, const uchar* palette ) |
| { |
| int i = 0; |
| for( ; i <= n - 2; i += 2 ) |
| { |
| int idx = *indices++; |
| data[i] = palette[idx >> 4]; |
| data[i+1] = palette[idx & 15]; |
| } |
| if( i < n ) |
| data[i] = palette[indices[0] >> 4]; |
| } |
| |
| |
| static void fillColorRow1( uchar* data, const uchar* indices, int n, |
| const PaletteEntry* palette, int dcn, int dblue_idx ) |
| { |
| int i = 0, mask = 0, idx = 0; |
| for( i = 0; i < n; i++, data += dcn, mask >>= 1 ) |
| { |
| const PaletteEntry* p; |
| if( mask == 0 ) |
| { |
| idx = *indices++; |
| mask = 128; |
| } |
| p = palette + ((idx & mask) != 0); |
| data[dblue_idx] = p->b; |
| data[1] = p->g; |
| data[dblue_idx^2] = p->r; |
| data[3] = 255; |
| } |
| } |
| |
| |
| static void fillGrayRow1( uchar* data, const uchar* indices, int n, const uchar* palette ) |
| { |
| int i = 0, mask = 0, idx = 0; |
| for( i = 0; i < n; i++, mask >>= 1 ) |
| { |
| if( mask == 0 ) |
| { |
| idx = *indices++; |
| mask = 128; |
| } |
| data[i] = palette[(idx & mask) != 0]; |
| } |
| } |
| |
| static int readBmpData(struct GrfmtReader* _reader, uchar* data, int step, int dcn ) |
| { |
| GrfmtBmpReader* reader = (GrfmtBmpReader*)_reader; |
| uchar gray_palette[256]; |
| int result = 0; |
| int color = dcn > 1; |
| int y, src_step, width, height, bpp; |
| const uchar* p; |
| const PaletteEntry* palette = 0; |
| |
| if( !reader || !reader->m_data || reader->m_offset <= 0 ) |
| return -1; |
| |
| width = reader->m_width; |
| height = reader->m_height; |
| bpp = reader->m_bpp; |
| palette = &reader->m_palette[0]; |
| |
| src_step = ((width*(bpp != 15 ? bpp : 16) + 7)/8 + 3) & -4; |
| p = reader->m_data + reader->m_offset; |
| |
| if( reader->m_offset + src_step*height > reader->m_datasize ) |
| return -1; |
| |
| if( reader->m_origin > 0 ) |
| { |
| data += (height - 1)*step; |
| step = -step; |
| } |
| |
| if( color == 0 && bpp <= 8 ) |
| { |
| cvtRGBToGray(&palette[0].b, &gray_palette[0], (1 << bpp), 4, 0); |
| } |
| |
| switch( bpp ) |
| { |
| /************************* 1 BPP ************************/ |
| case 1: |
| for( y = 0; y < height; y++, data += step, p += src_step ) |
| { |
| if( color ) |
| fillColorRow1( data, p, width, palette, dcn, 2 ); |
| else |
| fillGrayRow1( data, p, width, gray_palette ); |
| } |
| result = 0; |
| break; |
| |
| /************************* 4 BPP ************************/ |
| case 4: |
| for( y = 0; y < height; y++, data += step, p += src_step ) |
| { |
| if( color ) |
| fillColorRow4( data, p, width, palette, dcn, 2 ); |
| else |
| fillGrayRow4( data, p, width, gray_palette ); |
| } |
| result = 0; |
| break; |
| |
| /************************* 8 BPP ************************/ |
| case 8: |
| for( y = 0; y < height; y++, data += step, p += src_step ) |
| { |
| if( color ) |
| fillColorRow8( data, p, width, palette, dcn, 2 ); |
| else |
| fillGrayRow8( data, p, width, gray_palette ); |
| } |
| result = 0; |
| break; |
| /************************* 24 BPP ************************/ |
| case 24: |
| for( y = 0; y < height; y++, data += step, p += src_step ) |
| { |
| if( color ) |
| cvtRGBToRGB( p, data, width, 3, 0, dcn, 2 ); |
| else |
| cvtRGBToGray( p, data, width, 3, 0 ); |
| } |
| result = 0; |
| break; |
| /************************* 32 BPP ************************/ |
| case 32: |
| for( y = 0; y < height; y++, data += step, p += src_step ) |
| { |
| if( color ) |
| cvtRGBToRGB( p, data, width, 4, 0, dcn, 2 ); |
| else |
| cvtRGBToGray( p, data, width, 4, 0 ); |
| } |
| result = 0; |
| break; |
| default: |
| assert(0); |
| } |
| |
| return result; |
| } |
| |
| |
| static struct GrfmtReader* readBmpHeader(const uchar* data, int datasize, int* _width, int* _height, int* _iscolor) |
| { |
| GrfmtBmpReader* reader = 0; |
| int result = 0; |
| int iscolor = 0; |
| int width = 0, height = 0, bpp = 0; |
| BmpCompression rle_code = BMP_RGB; |
| PaletteEntry palette[256]; |
| int offset, size; |
| int j, clrused = 0; |
| const uchar* p = data + 10; |
| |
| if( !data || datasize < 56 || !_width || !_height || !_iscolor || data[0] != 'B' || data[1] != 'M' ) |
| return 0; |
| |
| offset = GET_DWORD(p); |
| size = GET_DWORD(p); |
| |
| ct_memset(&palette[0], 0, sizeof(palette)); |
| |
| if( size >= 36 ) |
| { |
| if( (int)((p - data) + size) >= datasize ) |
| return 0; |
| |
| width = GET_DWORD(p); |
| height = GET_DWORD(p); |
| bpp = GET_DWORD(p) >> 16; |
| rle_code = (BmpCompression)GET_DWORD(p); |
| p += 12; |
| clrused = GET_DWORD(p); |
| p += size - 36; |
| |
| if( width > 0 && height != 0 && |
| (((bpp == 1 || bpp == 4 || bpp == 8 || |
| bpp == 24 || bpp == 32 ) && rle_code == BMP_RGB) || |
| (bpp == 16 && (rle_code == BMP_RGB || rle_code == BMP_BITFIELDS)) || |
| (bpp == 4 && rle_code == BMP_RLE4) || |
| (bpp == 8 && rle_code == BMP_RLE8))) |
| { |
| iscolor = 1; |
| result = 1; |
| |
| if( bpp <= 8 ) |
| { |
| clrused = clrused == 0 ? (1 << bpp) : clrused; |
| memcpy(&palette[0], p, clrused*4); |
| p += clrused*4; |
| iscolor = isColorPalette( palette, clrused ); |
| } |
| else if( bpp == 16 && rle_code == BMP_BITFIELDS ) |
| { |
| int redmask = GET_DWORD(p); |
| int greenmask = GET_DWORD(p); |
| int bluemask = GET_DWORD(p); |
| |
| if( bluemask == 0x1f && greenmask == 0x3e0 && redmask == 0x7c00 ) |
| bpp = 15; |
| else if( bluemask == 0x1f && greenmask == 0x7e0 && redmask == 0xf800 ) |
| ; |
| else |
| result = 0; |
| } |
| else if( bpp == 16 && rle_code == BMP_RGB ) |
| bpp = 15; |
| } |
| } |
| else if( size == 12 ) |
| { |
| width = GET_DWORD(p); |
| height = GET_DWORD(p); |
| bpp = GET_DWORD(p) >> 16; |
| rle_code = BMP_RGB; |
| |
| if( width > 0 && height != 0 && |
| (bpp == 1 || bpp == 4 || bpp == 8 || bpp == 24 || bpp == 32 )) |
| { |
| if( bpp <= 8 ) |
| { |
| clrused = 1 << bpp; |
| for( j = 0; j < clrused; j++, p += 3 ) |
| { |
| palette[j].b = p[0]; |
| palette[j].g = p[1]; |
| palette[j].r = p[2]; |
| palette[j].a = 255; |
| } |
| iscolor = isColorPalette( palette, clrused ); |
| } |
| result = 1; |
| } |
| } |
| |
| if( result == 0 || (bpp == 15 || bpp == 16) || (rle_code != BMP_RGB && rle_code != BMP_BITFIELDS) ) |
| return 0; |
| |
| reader = (GrfmtBmpReader*)ct_alloc_mem(sizeof(*reader)); |
| if( !reader ) |
| return 0; |
| ct_memset(reader, 0, sizeof(*reader)); |
| reader->base.release = releaseBmpReader; |
| reader->base.read = readBmpData; |
| |
| reader->m_bpp = bpp; |
| reader->m_width = width; |
| reader->m_height = height; |
| reader->m_origin = height > 0 ? 1 : 0; |
| reader->m_offset = offset; |
| reader->m_rle_code = rle_code; |
| |
| reader->m_data = data; |
| reader->m_datasize = datasize; |
| reader->m_offset = offset; |
| |
| if( _width ) |
| *_width = width; |
| if( _height ) |
| *_height = height; |
| if( _iscolor ) |
| *_iscolor = iscolor; |
| |
| memcpy(&reader->m_palette[0], &palette[0], sizeof(palette)); |
| return (GrfmtReader*)reader; |
| } |
| |
| #define PUT_DWORD(p, val) \ |
| (((p)[0] = (uchar)(val)), \ |
| ((p)[1] = (uchar)((val) >> 8)), \ |
| ((p)[2] = (uchar)((val) >> 16)), \ |
| ((p)[3] = (uchar)((val) >> 24)), \ |
| (p) += 4) |
| |
| ////////////////////////////////////////////////////////////////////////////////////////// |
| static int writeBMP( const char* filename, const uchar* img, int step, int width, int height, int channels0 ) |
| { |
| int channels = channels0 == 4 ? 3 : channels0; |
| int width3 = width*channels; |
| int i, y, fileStep = (width3 + 3) & -4; |
| |
| int bitmapHeaderSize = 40; |
| int paletteSize = channels > 1 ? 0 : 1024; |
| int headerSize = 14 /* fileheader */ + bitmapHeaderSize + paletteSize; |
| int fileSize = fileStep*height + headerSize; |
| uchar* buf = 0, *p = 0; |
| |
| FILE* f = fopen(filename, "wb"); |
| if(!f) |
| return -1; |
| |
| buf = p = (uchar*)ct_alloc_mem(fileSize); |
| p[0] = 'B'; |
| p[1] = 'M'; |
| p += 2; |
| PUT_DWORD(p, fileSize); |
| PUT_DWORD(p, 0); |
| PUT_DWORD(p, headerSize); |
| PUT_DWORD(p, bitmapHeaderSize); |
| PUT_DWORD(p, width); |
| PUT_DWORD(p, height); |
| PUT_DWORD(p, 1 | (channels << 19)); |
| PUT_DWORD(p, BMP_RGB); |
| ct_memset(p, 0, 20); |
| p += 20; |
| |
| if( channels == 1 ) |
| { |
| for( i = 0; i < 256; i++, p += 4 ) |
| { |
| p[0] = p[1] = p[2] = (uchar)i; |
| p[3] = 255; |
| } |
| } |
| |
| for( y = height - 1; y >= 0; y--, p += fileStep ) |
| { |
| if( channels0 == 1 ) |
| memcpy(p, img + step*y, width); |
| else |
| { |
| const uchar* imgrow = img + step*y; |
| uchar* dst = p; |
| for( i = 0; i < width; i++, imgrow += channels0, dst += 3 ) |
| { |
| dst[0] = imgrow[2]; |
| dst[1] = imgrow[1]; |
| dst[2] = imgrow[0]; |
| } |
| } |
| if( fileStep > width3 ) |
| ct_memset(p + width3, 0, fileStep - width3); |
| } |
| |
| fwrite(buf, 1, fileSize, f); |
| fclose(f); |
| ct_free_mem(buf); |
| return 0; |
| } |
| |
| CT_Image ct_read_bmp(const unsigned char* data, int datasize, int dcn) |
| { |
| int w = 0, h = 0, iscolor = 0; |
| GrfmtReader* bmpreader = readBmpHeader(data, (int)datasize, &w, &h, &iscolor); |
| int ok = 0; |
| CT_Image image = 0; |
| |
| if( dcn <= 0 ) |
| dcn = iscolor ? 3 : 1; |
| |
| if( bmpreader ) |
| { |
| vx_uint32 width = w; |
| vx_uint32 height = h; |
| vx_df_image format = dcn == 1 ? VX_DF_IMAGE_U8 : dcn == 3 ? VX_DF_IMAGE_RGB : VX_DF_IMAGE_RGBX; |
| |
| image = ct_allocate_image(width, height, format); |
| |
| if( image ) |
| ok = bmpreader->read(bmpreader, image->data.y, (int)ct_stride_bytes(image), dcn) >= 0; |
| bmpreader->release(bmpreader); |
| } |
| |
| if( ok ) |
| return image; |
| |
| //ct_release_image(&image); |
| return 0; |
| } |
| |
| |
| int ct_write_bmp(const char* filename, CT_Image image) |
| { |
| if( image ) |
| { |
| CT_Image wrt_image; |
| if (image->format == VX_DF_IMAGE_U1) |
| { |
| wrt_image = ct_allocate_image(image->width, image->height, VX_DF_IMAGE_U8); |
| U1_ct_image_to_U8_ct_image(image, wrt_image); |
| } |
| else |
| { |
| wrt_image = image; |
| } |
| int channels = ct_channels(wrt_image->format); |
| return writeBMP(filename, wrt_image->data.y, (int)ct_stride_bytes(wrt_image), |
| (int)wrt_image->width, (int)wrt_image->height, channels); |
| } |
| return -1; |
| } |
