Windows/UltimateToolbox
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
UltimateToolbox/UltimateToolbox93_src/Ultimate Toolbox/source/OXBMPFle.cpp
Raten fb064541d6 new
2025-11-27 16:46:48 +09:00

940 lines
24 KiB
C++
Raw Blame History

// ==========================================================================
// Class Implementation : COXBMPFile
// ==========================================================================
// Source file : OXBMPFle.cpp
// Version: 9.3
// This software along with its related components, documentation and files ("The Libraries")
// is © 1994-2007 The Code Project (1612916 Ontario Limited) and use of The Libraries is
// governed by a software license agreement ("Agreement"). Copies of the Agreement are
// available at The Code Project (www.codeproject.com), as part of the package you downloaded
// to obtain this file, or directly from our office. For a copy of the license governing
// this software, you may contact us at legalaffairs@codeproject.com, or by calling 416-849-8900.
// //////////////////////////////////////////////////////////////////////////
#include "stdafx.h"
#include "OXBMPFle.h"
#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
#define new DEBUG_NEW
#ifdef BMP_SUPPORTED
/* Macros to deal with unsigned chars as efficiently as compiler allows */
#ifdef HAVE_UNSIGNED_CHAR
typedef unsigned char U_CHAR;
#define UCH(x) ((int) (x))
#else /* !HAVE_UNSIGNED_CHAR */
#ifdef CHAR_IS_UNSIGNED
typedef char U_CHAR;
#define UCH(x) ((int) (x))
#else
typedef char U_CHAR;
#define UCH(x) ((int) (x) & 0xFF)
#endif
#endif /* HAVE_UNSIGNED_CHAR */
/////////////////////////////////////////////////////////////////////////////
// Definition of static members
// Data members -------------------------------------------------------------
// protected:
// j_compress_ptr m_cinfo;
// --- back link saves passing separate parm
// JSAMPARRAY m_Colormap;
// --- BMP colormap (converted to my format)
// jvirt_sarray_ptr m_WholeImage;
// --- Needed to reverse row order
// DIMENSION m_SourceRow;
// --- Current source row number
// JDIMENSION m_RowWidth;
// --- Physical width of scanlines in file
// int m_BitsPerPixel
// --- remembers 8- or 24-bit format
// BOOL m_bIsOS2;
// --- saves the OS2 format request flag
// JDIMENSION m_DataWidth;
// --- JSAMPLEs per row
// int m_nPadBytes;
// --- number of padding bytes needed per row
// JDIMENSION m_CurOutputRow;
// --- next row# to write to virtual array
// private:
// Member functions ---------------------------------------------------------
// public:
COXBMPFile::COXBMPFile(CString sFullPath)
: COXGraphicFile(sFullPath),
m_cinfo(NULL),
m_Colormap(NULL),
m_WholeImage(NULL),
m_SourceRow(0),
m_RowWidth(0),
m_BitsPerPixel(0),
m_bIsOS2(FALSE)
{
}
COXBMPFile::COXBMPFile(CFile* pGraphicFile)
: COXGraphicFile(pGraphicFile),
m_cinfo(NULL),
m_Colormap(NULL),
m_WholeImage(NULL),
m_SourceRow(0),
m_RowWidth(0),
m_BitsPerPixel(0),
m_bIsOS2(FALSE)
{
}
#ifdef _DEBUG
void COXBMPFile::Dump(CDumpContext& dc) const
{
COXGraphicFile::Dump(dc);
dc << TEXT("\nm_SourceRow : ") << m_SourceRow;
dc << TEXT("\nm_RowWidth : ") << m_RowWidth;
dc << TEXT("\nm_BitsPerPixel : ") << m_BitsPerPixel;
dc << TEXT("\nm_bIsOS2 ") << (WORD)m_bIsOS2;
dc << TEXT("\nm_cinfo ") << (void*)m_cinfo;
dc << TEXT("\nm_Colormap ") << (void*)m_Colormap;
dc << TEXT("\nm_WholeImage ") << (void*)m_WholeImage;
}
void COXBMPFile::AssertValid() const
{
COXGraphicFile::AssertValid();
}
#endif
COXBMPFile::~COXBMPFile()
{
}
// protected
int COXBMPFile::ReadByte()
/* Read next byte from BMP file */
{
BYTE b;
if ((ReadData(&b, 1)) == 0)
ERREXIT(m_cinfo, JERR_INPUT_EOF);
return b;
}
void COXBMPFile::ReadColorMap(int cmaplen, int mapentrysize)
/* Read the colormap from a BMP file */
{
int i;
switch (mapentrysize)
{
case 3:
/* BGR format (occurs in OS/2 files) */
for (i = 0; i < cmaplen; i++)
{
m_Colormap[2][i] = (JSAMPLE) ReadByte();
m_Colormap[1][i] = (JSAMPLE) ReadByte();
m_Colormap[0][i] = (JSAMPLE) ReadByte();
}
break;
case 4:
/* BGR0 format (occurs in MS Windows files) */
for (i = 0; i < cmaplen; i++)
{
m_Colormap[2][i] = (JSAMPLE) ReadByte();
m_Colormap[1][i] = (JSAMPLE) ReadByte();
m_Colormap[0][i] = (JSAMPLE) ReadByte();
(void) ReadByte();
}
break;
default:
ERREXIT(m_cinfo, JERR_BMP_BADCMAP);
break;
}
}
/*
* Read one row of pixels.
* The image has been read into the whole_image array, but is otherwise
* unprocessed. We must read it out in top-to-bottom row order, and if
* it is an 8-bit image, we must expand colormapped pixels to 24bit format.
*/
JDIMENSION COXBMPFile::Get8bitRow(j_compress_ptr cinfo)
/* This version is for reading 8-bit colormap indexes */
{
register JSAMPARRAY colormap = m_Colormap;
JSAMPARRAY image_ptr;
register int t;
register JSAMPROW inptr, outptr;
register JDIMENSION col;
/* Fetch next row from virtual array */
m_SourceRow--;
image_ptr = (*cinfo->mem->access_virt_sarray)((j_common_ptr) cinfo, m_WholeImage,
m_SourceRow, (JDIMENSION) 1, FALSE);
/* Expand the colormap indexes to real data */
inptr = image_ptr[0];
outptr = m_buffer[0];
for (col = cinfo->image_width; col > 0; col--)
{
t = GETJSAMPLE(*inptr++);
*outptr++ = colormap[0][t]; /* can omit GETJSAMPLE() safely */
*outptr++ = colormap[1][t];
*outptr++ = colormap[2][t];
}
return 1;
}
JDIMENSION COXBMPFile::Get24bitRow(j_compress_ptr cinfo)
/* This version is for reading 24-bit pixels */
{
JSAMPARRAY image_ptr;
register JSAMPROW inptr, outptr;
register JDIMENSION col;
/* Fetch next row from virtual array */
m_SourceRow--;
image_ptr = (*cinfo->mem->access_virt_sarray)((j_common_ptr) cinfo, m_WholeImage,
m_SourceRow, (JDIMENSION) 1, FALSE);
/* Transfer data. Note source values are in BGR order
* (even though Microsoft's own documents say the opposite).
*/
inptr = image_ptr[0];
outptr = m_buffer[0];
for (col = cinfo->image_width; col > 0; col--)
{
outptr[2] = *inptr++; /* can omit GETJSAMPLE() safely */
outptr[1] = *inptr++;
outptr[0] = *inptr++;
outptr += 3;
}
return 1;
}
JDIMENSION COXBMPFile::PreloadImage(j_compress_ptr cinfo)
{
register BYTE b;
register JSAMPROW out_ptr;
JSAMPARRAY image_ptr;
JDIMENSION row, col;
// cd_progress_ptr progress = (cd_progress_ptr) cinfo->progress;
/* Read the data into a virtual array in input-file row order. */
TRY
{
for (row = 0; row < cinfo->image_height; row++)
{
// if (progress != NULL)
// {
// progress->pub.pass_counter = (long) row;
// progress->pub.pass_limit = (long) cinfo->image_height;
// (*progress->pub.progress_monitor) ((j_common_ptr) cinfo);
// }
image_ptr = (*cinfo->mem->access_virt_sarray)((j_common_ptr) cinfo, m_WholeImage,
row, (JDIMENSION) 1, TRUE);
out_ptr = image_ptr[0];
if (sizeof(*out_ptr) == 1)
{
if (m_pGraphFile->Read(out_ptr, m_RowWidth) != m_RowWidth)
ERREXIT(cinfo, JERR_INPUT_EOF);
}
else
{
for (col = m_RowWidth; col > 0; col--)
{
/* inline copy of ReadData() for speed */
if (m_pGraphFile->Read(&b, 1) != 1)
ERREXIT(cinfo, JERR_INPUT_EOF);
*out_ptr++ = (JSAMPLE) b;
}
}
}
}
CATCH(CFileException, e)
{
TRACE(_T("COXBMPFile::PreloadImage : Catching CFileException\n"));
ERREXIT(m_cinfo, JERR_INPUT_EOF);
return 0;
}
END_CATCH
// if (progress != NULL)
// progress->completed_extra_passes++;
/* Set up to read from the virtual array in top-to-bottom order */
switch (m_BitsPerPixel)
{
case 8:
m_pfnGetPixelRows = &COXBMPFile::Get8bitRow;
break;
case 24:
m_pfnGetPixelRows = &COXBMPFile::Get24bitRow;
break;
default:
ERREXIT(cinfo, JERR_BMP_BADDEPTH);
}
m_SourceRow = cinfo->image_height;
/* And read the first row */
return (this->*m_pfnGetPixelRows)(cinfo);
}
void COXBMPFile::PutGrayRows (j_decompress_ptr cinfo, JDIMENSION rows_supplied)
/* This version is for grayscale OR quantized color output */
{
UNREFERENCED_PARAMETER(rows_supplied);
JSAMPARRAY image_ptr;
register JSAMPROW inptr, outptr;
register JDIMENSION col;
int pad;
/* Access next row in virtual array */
image_ptr = (*cinfo->mem->access_virt_sarray)((j_common_ptr) cinfo, m_WholeImage,
m_CurOutputRow, (JDIMENSION) 1, TRUE);
m_CurOutputRow++;
/* Transfer data. */
inptr = m_buffer[0];
outptr = image_ptr[0];
for (col = cinfo->output_width; col > 0; col--) {
*outptr++ = *inptr++; /* can omit GETJSAMPLE() safely */
}
/* Zero out the pad bytes. */
pad = m_nPadBytes;
while (--pad >= 0)
*outptr++ = 0;
}
void COXBMPFile::Put24PixelRows(j_decompress_ptr cinfo, JDIMENSION rows_supplied)
/* This version is for writing 24-bit pixels */
{
UNREFERENCED_PARAMETER(rows_supplied);
JSAMPARRAY image_ptr;
register JSAMPROW inptr, outptr;
register JDIMENSION col;
int pad;
/* Access next row in virtual array */
image_ptr = (*cinfo->mem->access_virt_sarray)((j_common_ptr) cinfo, m_WholeImage,
m_CurOutputRow, (JDIMENSION) 1, TRUE);
m_CurOutputRow++;
/* Transfer data. Note destination values must be in BGR order
* (even though Microsoft's own documents say the opposite).
*/
inptr = m_buffer[0];
outptr = image_ptr[0];
for (col = cinfo->output_width; col > 0; col--)
{
outptr[2] = *inptr++; /* can omit GETJSAMPLE() safely */
outptr[1] = *inptr++;
outptr[0] = *inptr++;
outptr += 3;
}
/* Zero out the pad bytes. */
pad = m_nPadBytes;
while (--pad >= 0)
*outptr++ = 0;
}
/*
* Finish up at the end of the file.
*
* Here is where we really output the BMP file.
*
* First, routines to write the Windows and OS/2 variants of the file header.
*/
void COXBMPFile::WriteBMPHeader(j_decompress_ptr cinfo)
/* Write a Windows-style BMP file header, including colormap if needed */
{
char bmpfileheader[14];
char bmpinfoheader[40];
#define PUT_2B(array,offset,value) \
(array[offset] = (char) ((value) & 0xFF), \
array[offset+1] = (char) (((value) >> 8) & 0xFF))
#define PUT_4B(array,offset,value) \
(array[offset] = (char) ((value) & 0xFF), \
array[offset+1] = (char) (((value) >> 8) & 0xFF), \
array[offset+2] = (char) (((value) >> 16) & 0xFF), \
array[offset+3] = (char) (((value) >> 24) & 0xFF))
INT32 headersize, bfSize;
int bits_per_pixel, cmap_entries;
/* Compute colormap size and total file size */
if (cinfo->out_color_space == JCS_RGB)
{
if (cinfo->quantize_colors)
{
/* Colormapped RGB */
bits_per_pixel = 8;
cmap_entries = 256;
}
else
{
/* Unquantized, full color RGB */
bits_per_pixel = 24;
cmap_entries = 0;
}
}
else
{
/* Grayscale output. We need to fake a 256-entry colormap. */
bits_per_pixel = 8;
cmap_entries = 256;
}
/* File size */
headersize = 14 + 40 + cmap_entries * 4; /* Header and colormap */
bfSize = headersize + (INT32) m_RowWidth * (INT32) cinfo->output_height;
/* Set UNREFERENCED_PARAMETER fields of header to 0 */
MEMZERO(bmpfileheader, SIZEOF(bmpfileheader));
MEMZERO(bmpinfoheader, SIZEOF(bmpinfoheader));
/* Fill the file header */
bmpfileheader[0] = 0x42; /* first 2 bytes are ASCII 'B', 'M' */
bmpfileheader[1] = 0x4D;
PUT_4B(bmpfileheader, 2, bfSize); /* bfSize */
/* we leave bfReserved1 & bfReserved2 = 0 */
PUT_4B(bmpfileheader, 10, headersize); /* bfOffBits */
/* Fill the info header (Microsoft calls this a BITMAPINFOHEADER) */
PUT_2B(bmpinfoheader, 0, 40); /* biSize */
PUT_4B(bmpinfoheader, 4, cinfo->output_width); /* biWidth */
PUT_4B(bmpinfoheader, 8, cinfo->output_height); /* biHeight */
PUT_2B(bmpinfoheader, 12, 1); /* biPlanes - must be 1 */
PUT_2B(bmpinfoheader, 14, bits_per_pixel); /* biBitCount */
/* we leave biCompression = 0, for none */
/* we leave biSizeImage = 0; this is correct for uncompressed data */
if (cinfo->density_unit == 2)
{
/* if have density in dots/cm, then */
PUT_4B(bmpinfoheader, 24, (INT32) (cinfo->X_density*100)); /* XPels/M */
PUT_4B(bmpinfoheader, 28, (INT32) (cinfo->Y_density*100)); /* XPels/M */
}
PUT_2B(bmpinfoheader, 32, cmap_entries); /* biClrUsed */
/* we leave biClrImportant = 0 */
if (WriteData(bmpfileheader, 14) == 0)
ERREXIT(cinfo, JERR_FILE_WRITE);
if (WriteData(bmpinfoheader, 40) == 0)
ERREXIT(cinfo, JERR_FILE_WRITE);
if (cmap_entries > 0)
WriteColorMap(cinfo, cmap_entries, 4);
}
void COXBMPFile::WriteOS2Header(j_decompress_ptr cinfo)
/* Write an OS2-style BMP file header, including colormap if needed */
{
char bmpfileheader[14];
char bmpcoreheader[12];
INT32 headersize, bfSize;
int bits_per_pixel, cmap_entries;
/* Compute colormap size and total file size */
if (cinfo->out_color_space == JCS_RGB)
{
if (cinfo->quantize_colors)
{
/* Colormapped RGB */
bits_per_pixel = 8;
cmap_entries = 256;
}
else
{
/* Unquantized, full color RGB */
bits_per_pixel = 24;
cmap_entries = 0;
}
}
else
{
/* Grayscale output. We need to fake a 256-entry colormap. */
bits_per_pixel = 8;
cmap_entries = 256;
}
/* File size */
headersize = 14 + 12 + cmap_entries * 3; /* Header and colormap */
bfSize = headersize + (INT32) m_RowWidth * (INT32) cinfo->output_height;
/* Set UNREFERENCED_PARAMETER fields of header to 0 */
MEMZERO(bmpfileheader, SIZEOF(bmpfileheader));
MEMZERO(bmpcoreheader, SIZEOF(bmpcoreheader));
/* Fill the file header */
bmpfileheader[0] = 0x42; /* first 2 bytes are ASCII 'B', 'M' */
bmpfileheader[1] = 0x4D;
PUT_4B(bmpfileheader, 2, bfSize); /* bfSize */
/* we leave bfReserved1 & bfReserved2 = 0 */
PUT_4B(bmpfileheader, 10, headersize); /* bfOffBits */
/* Fill the info header (Microsoft calls this a BITMAPCOREHEADER) */
PUT_2B(bmpcoreheader, 0, 12); /* bcSize */
PUT_2B(bmpcoreheader, 4, cinfo->output_width); /* bcWidth */
PUT_2B(bmpcoreheader, 6, cinfo->output_height); /* bcHeight */
PUT_2B(bmpcoreheader, 8, 1); /* bcPlanes - must be 1 */
PUT_2B(bmpcoreheader, 10, bits_per_pixel); /* bcBitCount */
if (WriteData(bmpfileheader, 14) == 0)
ERREXIT(cinfo, JERR_FILE_WRITE);
if (WriteData(bmpcoreheader, 12) == 0)
ERREXIT(cinfo, JERR_FILE_WRITE);
if (cmap_entries > 0)
WriteColorMap(cinfo, cmap_entries, 3);
}
/*
* Write the colormap.
* Windows uses BGR0 map entries; OS/2 uses BGR entries.
*/
void COXBMPFile::WriteColorMap (j_decompress_ptr cinfo, int map_colors, int map_entry_size)
{
JSAMPARRAY colormap = cinfo->colormap;
int num_colors = cinfo->actual_number_of_colors;
int i;
BYTE b;
if (colormap != NULL)
{
if (cinfo->out_color_components == 3)
{
/* Normal case with RGB colormap */
for (i = 0; i < num_colors; i++)
{
b = (BYTE)GETJSAMPLE(colormap[2][i]);
WriteData(&b, 1);
b = (BYTE)GETJSAMPLE(colormap[1][i]);
WriteData(&b, 1);
b = (BYTE)GETJSAMPLE(colormap[0][i]);
WriteData(&b, 1);
if (map_entry_size == 4)
{
b = 0;
WriteData(&b, 1);
}
}
}
else
{
/* Grayscale colormap (only happens with grayscale quantization) */
for (i = 0; i < num_colors; i++)
{
b = (BYTE)GETJSAMPLE(colormap[0][i]);
WriteData(&b, 1);
WriteData(&b, 1);
WriteData(&b, 1);
if (map_entry_size == 4)
{
b = 0;
WriteData(&b, 1);
}
}
}
}
else
{
/* If no colormap, must be grayscale data. Generate a linear "map". */
for (i = 0; i < 256; i++)
{
b = (BYTE)i;
WriteData(&b, 1);
WriteData(&b, 1);
WriteData(&b, 1);
if (map_entry_size == 4)
{
b = 0;
WriteData(&b, 1);
}
}
}
/* Pad colormap with zeros to ensure specified number of colormap entries */
if (i > map_colors)
ERREXIT1(cinfo, JERR_TOO_MANY_COLORS, i);
for (; i < map_colors; i++)
{
b = 0;
WriteData(&b, 1);
WriteData(&b, 1);
WriteData(&b, 1);
if (map_entry_size == 4)
WriteData(&b, 1);
}
}
BOOL COXBMPFile::StartInput(j_compress_ptr cinfo)
{
ASSERT(cinfo != NULL);
U_CHAR bmpfileheader[14];
U_CHAR bmpinfoheader[64];
#define GET_2B(array,offset) ((unsigned int) UCH(array[offset]) + \
(((unsigned int) UCH(array[offset+1])) << 8))
#define GET_4B(array,offset) ((INT32) UCH(array[offset]) + \
(((INT32) UCH(array[offset+1])) << 8) + \
(((INT32) UCH(array[offset+2])) << 16) + \
(((INT32) UCH(array[offset+3])) << 24))
INT32 bfOffBits;
INT32 headerSize;
INT32 biWidth = 0; /* initialize to avoid compiler warning */
INT32 biHeight = 0;
unsigned int biPlanes;
INT32 biCompression;
INT32 biXPelsPerMeter,biYPelsPerMeter;
INT32 biClrUsed = 0;
int mapentrysize = 0; /* 0 indicates no colormap */
INT32 bPad;
JDIMENSION row_width;
/* Read and verify the bitmap file header */
if (! ReadOK(bmpfileheader, 14))
ERREXIT(cinfo, JERR_INPUT_EOF);
if (GET_2B(bmpfileheader,0) != 0x4D42) /* 'BM' */
ERREXIT(cinfo, JERR_BMP_NOT);
bfOffBits = (INT32) GET_4B(bmpfileheader,10);
/* We ignore the remaining fileheader fields */
/* The infoheader might be 12 bytes (OS/2 1.x), 40 bytes (Windows),
* or 64 bytes (OS/2 2.x). Check the first 4 bytes to find out which.
*/
if (! ReadOK(bmpinfoheader, 4))
ERREXIT(cinfo, JERR_INPUT_EOF);
headerSize = (INT32) GET_4B(bmpinfoheader,0);
if (headerSize < 12 || headerSize > 64)
ERREXIT(cinfo, JERR_BMP_BADHEADER);
if (! ReadOK(bmpinfoheader+4, headerSize-4))
ERREXIT(cinfo, JERR_INPUT_EOF);
switch ((int) headerSize)
{
case 12:
/* Decode OS/2 1.x header (Microsoft calls this a BITMAPCOREHEADER) */
biWidth = (INT32) GET_2B(bmpinfoheader,4);
biHeight = (INT32) GET_2B(bmpinfoheader,6);
biPlanes = GET_2B(bmpinfoheader,8);
m_BitsPerPixel = (int) GET_2B(bmpinfoheader,10);
switch (m_BitsPerPixel)
{
case 8: /* colormapped image */
mapentrysize = 3; /* OS/2 uses RGBTRIPLE colormap */
TRACEMS2(cinfo, 1, JTRC_BMP_OS2_MAPPED, (int) biWidth, (int) biHeight);
break;
case 24: /* RGB image */
TRACEMS2(cinfo, 1, JTRC_BMP_OS2, (int) biWidth, (int) biHeight);
break;
default:
ERREXIT(cinfo, JERR_BMP_BADDEPTH);
break;
}
if (biPlanes != 1)
ERREXIT(cinfo, JERR_BMP_BADPLANES);
break;
case 40:
case 64:
/* Decode Windows 3.x header (Microsoft calls this a BITMAPINFOHEADER) */
/* or OS/2 2.x header, which has additional fields that we ignore */
biWidth = GET_4B(bmpinfoheader,4);
biHeight = GET_4B(bmpinfoheader,8);
biPlanes = GET_2B(bmpinfoheader,12);
m_BitsPerPixel = (int) GET_2B(bmpinfoheader,14);
biCompression = GET_4B(bmpinfoheader,16);
biXPelsPerMeter = GET_4B(bmpinfoheader,24);
biYPelsPerMeter = GET_4B(bmpinfoheader,28);
biClrUsed = GET_4B(bmpinfoheader,32);
/* biSizeImage, biClrImportant fields are ignored */
switch (m_BitsPerPixel)
{
case 8: /* colormapped image */
mapentrysize = 4; /* Windows uses RGBQUAD colormap */
TRACEMS2(cinfo, 1, JTRC_BMP_MAPPED, (int) biWidth, (int) biHeight);
break;
case 24: /* RGB image */
TRACEMS2(cinfo, 1, JTRC_BMP, (int) biWidth, (int) biHeight);
break;
default:
ERREXIT(cinfo, JERR_BMP_BADDEPTH);
break;
}
if (biPlanes != 1)
ERREXIT(cinfo, JERR_BMP_BADPLANES);
if (biCompression != 0)
ERREXIT(cinfo, JERR_BMP_COMPRESSED);
if (biXPelsPerMeter > 0 && biYPelsPerMeter > 0)
{
/* Set JFIF density parameters from the BMP data */
cinfo->X_density = (UINT16) (biXPelsPerMeter/100); /* 100 cm per meter */
cinfo->Y_density = (UINT16) (biYPelsPerMeter/100);
cinfo->density_unit = 2; /* dots/cm */
}
break;
default:
ERREXIT(cinfo, JERR_BMP_BADHEADER);
break;
}
/* Compute distance to bitmap data --- will adjust for colormap below */
bPad = bfOffBits - (headerSize + 14);
/* Read the colormap, if any */
if (mapentrysize > 0)
{
if (biClrUsed <= 0)
biClrUsed = 256; /* assume it's 256 */
else if (biClrUsed > 256)
ERREXIT(cinfo, JERR_BMP_BADCMAP);
/* Allocate space to store the colormap */
m_Colormap = (*cinfo->mem->alloc_sarray)((j_common_ptr) cinfo, JPOOL_IMAGE,
(JDIMENSION) biClrUsed, (JDIMENSION) 3);
/* and read it from the file */
ReadColorMap((int) biClrUsed, mapentrysize);
/* account for size of colormap */
bPad -= biClrUsed * mapentrysize;
}
/* Skip any remaining pad bytes */
if (bPad < 0) /* incorrect bfOffBits value? */
ERREXIT(cinfo, JERR_BMP_BADHEADER);
while (--bPad >= 0)
{
(void) ReadByte();
}
/* Compute row width in file, including padding to 4-byte boundary */
if (m_BitsPerPixel == 24)
row_width = (JDIMENSION) (biWidth * 3);
else
row_width = (JDIMENSION) biWidth;
while ((row_width & 3) != 0)
row_width++;
m_RowWidth = row_width;
/* Allocate space for inversion array, prepare for preload pass */
m_WholeImage = (*cinfo->mem->request_virt_sarray)((j_common_ptr) cinfo, JPOOL_IMAGE, FALSE,
row_width, (JDIMENSION) biHeight, (JDIMENSION) 1);
m_pfnGetPixelRows = &COXBMPFile::PreloadImage;
// if (cinfo->progress != NULL)
// {
// cd_progress_ptr progress = (cd_progress_ptr) cinfo->progress;
// progress->total_extra_passes++; /* count file input as separate pass */
// }
/* Allocate one-row buffer for returned data */
m_buffer = (*cinfo->mem->alloc_sarray)((j_common_ptr) cinfo, JPOOL_IMAGE,
(JDIMENSION) (biWidth * 3), (JDIMENSION) 1);
m_buffer_height = 1;
cinfo->in_color_space = JCS_RGB;
cinfo->input_components = 3;
cinfo->data_precision = 8;
cinfo->image_width = (JDIMENSION) biWidth;
cinfo->image_height = (JDIMENSION) biHeight;
return TRUE;
}
BOOL COXBMPFile::FinishInput(j_compress_ptr cinfo)
{
/* no work here */
UNREFERENCED_PARAMETER(cinfo);
return TRUE;
}
JDIMENSION COXBMPFile::GetPixelRows(j_compress_ptr cinfo)
{
return (this->*m_pfnGetPixelRows)(cinfo);
}
BOOL COXBMPFile::StartOutput(j_decompress_ptr dinfo)
{
/* no work here */
UNREFERENCED_PARAMETER(dinfo);
return TRUE;
}
BOOL COXBMPFile::FinishOutput(j_decompress_ptr cinfo)
{
JSAMPARRAY image_ptr;
register JSAMPROW data_ptr;
JDIMENSION row;
register JDIMENSION col;
// cd_progress_ptr progress = (cd_progress_ptr) cinfo->progress;
/* Write the header and colormap */
if (m_bIsOS2)
WriteOS2Header(cinfo);
else
WriteBMPHeader(cinfo);
TRY
{
/* Write the file body from our virtual array */
for (row = cinfo->output_height; row > 0; row--)
{
// if (progress != NULL)
// {
// progress->pub.pass_counter = (long) (cinfo->output_height - row);
// progress->pub.pass_limit = (long) cinfo->output_height;
// (*progress->pub.progress_monitor) ((j_common_ptr) cinfo);
// }
image_ptr = (*cinfo->mem->access_virt_sarray)
((j_common_ptr) cinfo, m_WholeImage, row - 1, (JDIMENSION) 1, FALSE);
data_ptr = image_ptr[0];
if (sizeof(*data_ptr) == 1)
{
m_pGraphFile->Write(data_ptr, m_RowWidth);
}
else
{
BYTE b;
for (col = m_RowWidth; col > 0; col--)
{
b = (BYTE)GETJSAMPLE(*data_ptr);
m_pGraphFile->Write(&b, 1);
data_ptr++;
}
}
}
}
CATCH(CFileException, e)
{
TRACE(_T("COXBMPFile::FinishOutput : Catching CFileException\n"));
return FALSE;
}
END_CATCH
// if (progress != NULL)
// progress->completed_extra_passes++;
return TRUE;
}
BOOL COXBMPFile::PutPixelRows(j_decompress_ptr cinfo, JDIMENSION rowsSupplied)
{
(this->*m_pfnPutPixelRows)(cinfo, rowsSupplied);
return TRUE;
}
BOOL COXBMPFile::InitRead(j_compress_ptr cinfo)
{
m_cinfo = cinfo;
return TRUE;
}
BOOL COXBMPFile::InitWrite(j_decompress_ptr cinfo, BOOL bExtra /* = FALSE */)
{
UNREFERENCED_PARAMETER(bExtra);
JDIMENSION row_width;
if (cinfo->out_color_space == JCS_GRAYSCALE)
{
m_pfnPutPixelRows = &COXBMPFile::PutGrayRows;
}
else if (cinfo->out_color_space == JCS_RGB)
{
if (cinfo->quantize_colors)
m_pfnPutPixelRows = &COXBMPFile::PutGrayRows;
else
m_pfnPutPixelRows = &COXBMPFile::Put24PixelRows;
}
else
{
ERREXIT(cinfo, JERR_BMP_COLORSPACE);
}
/* Calculate output image dimensions so we can allocate space */
jpeg_calc_output_dimensions(cinfo);
/* Determine width of rows in the BMP file (padded to 4-byte boundary). */
row_width = cinfo->output_width * cinfo->output_components;
m_DataWidth = row_width;
while ((row_width & 3) != 0)
row_width++;
m_RowWidth = row_width;
m_nPadBytes = (int) (row_width - m_DataWidth);
/* Allocate space for inversion array, prepare for write pass */
m_WholeImage = (*cinfo->mem->request_virt_sarray)((j_common_ptr) cinfo, JPOOL_IMAGE, FALSE,
row_width, cinfo->output_height, (JDIMENSION) 1);
m_CurOutputRow = 0;
// if (cinfo->progress != NULL)
// {
// cd_progress_ptr progress = (cd_progress_ptr) cinfo->progress;
// progress->total_extra_passes++; /* count file input as separate pass */
// }
/* Create decompressor output buffer. */
m_buffer = (*cinfo->mem->alloc_sarray)((j_common_ptr) cinfo, JPOOL_IMAGE, row_width, (JDIMENSION) 1);
m_buffer_height = 1;
return TRUE;
}
#endif /* BMP_SUPPORTED */
///////////////////////////////////////////////////////////////////////////
Reference in New Issue View Git Blame Copy Permalink