1 /* 2 * wrbmp.c 3 * 4 * This file was part of the Independent JPEG Group's software: 5 * Copyright (C) 1994-1996, Thomas G. Lane. 6 * libjpeg-turbo Modifications: 7 * Copyright (C) 2013, Linaro Limited. 8 * Copyright (C) 2014, D. R. Commander. 9 * For conditions of distribution and use, see the accompanying README file. 10 * 11 * This file contains routines to write output images in Microsoft "BMP" 12 * format (MS Windows 3.x and OS/2 1.x flavors). 13 * Either 8-bit colormapped or 24-bit full-color format can be written. 14 * No compression is supported. 15 * 16 * These routines may need modification for non-Unix environments or 17 * specialized applications. As they stand, they assume output to 18 * an ordinary stdio stream. 19 * 20 * This code contributed by James Arthur Boucher. 21 */ 22 23 #include "cdjpeg.h" /* Common decls for cjpeg/djpeg applications */ 24 #include "jconfigint.h" 25 26 #ifdef BMP_SUPPORTED 27 28 29 /* 30 * To support 12-bit JPEG data, we'd have to scale output down to 8 bits. 31 * This is not yet implemented. 32 */ 33 34 #if BITS_IN_JSAMPLE != 8 35 Sorry, this code only copes with 8-bit JSAMPLEs. /* deliberate syntax err */ 36 #endif 37 38 /* 39 * Since BMP stores scanlines bottom-to-top, we have to invert the image 40 * from JPEG's top-to-bottom order. To do this, we save the outgoing data 41 * in a virtual array during put_pixel_row calls, then actually emit the 42 * BMP file during finish_output. The virtual array contains one JSAMPLE per 43 * pixel if the output is grayscale or colormapped, three if it is full color. 44 */ 45 46 /* Private version of data destination object */ 47 48 typedef struct { 49 struct djpeg_dest_struct pub; /* public fields */ 50 51 boolean is_os2; /* saves the OS2 format request flag */ 52 53 jvirt_sarray_ptr whole_image; /* needed to reverse row order */ 54 JDIMENSION data_width; /* JSAMPLEs per row */ 55 JDIMENSION row_width; /* physical width of one row in the BMP file */ 56 int pad_bytes; /* number of padding bytes needed per row */ 57 JDIMENSION cur_output_row; /* next row# to write to virtual array */ 58 } bmp_dest_struct; 59 60 typedef bmp_dest_struct * bmp_dest_ptr; 61 62 63 /* Forward declarations */ 64 LOCAL(void) write_colormap 65 (j_decompress_ptr cinfo, bmp_dest_ptr dest, int map_colors, 66 int map_entry_size); 67 68 69 static INLINE boolean is_big_endian(void) 70 { 71 int test_value = 1; 72 if(*(char *)&test_value != 1) 73 return TRUE; 74 return FALSE; 75 } 76 77 78 /* 79 * Write some pixel data. 80 * In this module rows_supplied will always be 1. 81 */ 82 83 METHODDEF(void) 84 put_pixel_rows (j_decompress_ptr cinfo, djpeg_dest_ptr dinfo, 85 JDIMENSION rows_supplied) 86 /* This version is for writing 24-bit pixels */ 87 { 88 bmp_dest_ptr dest = (bmp_dest_ptr) dinfo; 89 JSAMPARRAY image_ptr; 90 register JSAMPROW inptr, outptr; 91 register JDIMENSION col; 92 int pad; 93 94 /* Access next row in virtual array */ 95 image_ptr = (*cinfo->mem->access_virt_sarray) 96 ((j_common_ptr) cinfo, dest->whole_image, 97 dest->cur_output_row, (JDIMENSION) 1, TRUE); 98 dest->cur_output_row++; 99 100 /* Transfer data. Note destination values must be in BGR order 101 * (even though Microsoft's own documents say the opposite). 102 */ 103 inptr = dest->pub.buffer[0]; 104 outptr = image_ptr[0]; 105 106 if(cinfo->out_color_space == JCS_RGB565) { 107 boolean big_endian = is_big_endian(); 108 unsigned short *inptr2 = (unsigned short *)inptr; 109 for (col = cinfo->output_width; col > 0; col--) { 110 if (big_endian) { 111 outptr[0] = (*inptr2 >> 5) & 0xF8; 112 outptr[1] = ((*inptr2 << 5) & 0xE0) | ((*inptr2 >> 11) & 0x1C); 113 outptr[2] = *inptr2 & 0xF8; 114 } else { 115 outptr[0] = (*inptr2 << 3) & 0xF8; 116 outptr[1] = (*inptr2 >> 3) & 0xFC; 117 outptr[2] = (*inptr2 >> 8) & 0xF8; 118 } 119 outptr += 3; 120 inptr2++; 121 } 122 } else { 123 for (col = cinfo->output_width; col > 0; col--) { 124 outptr[2] = *inptr++; /* can omit GETJSAMPLE() safely */ 125 outptr[1] = *inptr++; 126 outptr[0] = *inptr++; 127 outptr += 3; 128 } 129 } 130 131 /* Zero out the pad bytes. */ 132 pad = dest->pad_bytes; 133 while (--pad >= 0) 134 *outptr++ = 0; 135 } 136 137 METHODDEF(void) 138 put_gray_rows (j_decompress_ptr cinfo, djpeg_dest_ptr dinfo, 139 JDIMENSION rows_supplied) 140 /* This version is for grayscale OR quantized color output */ 141 { 142 bmp_dest_ptr dest = (bmp_dest_ptr) dinfo; 143 JSAMPARRAY image_ptr; 144 register JSAMPROW inptr, outptr; 145 register JDIMENSION col; 146 int pad; 147 148 /* Access next row in virtual array */ 149 image_ptr = (*cinfo->mem->access_virt_sarray) 150 ((j_common_ptr) cinfo, dest->whole_image, 151 dest->cur_output_row, (JDIMENSION) 1, TRUE); 152 dest->cur_output_row++; 153 154 /* Transfer data. */ 155 inptr = dest->pub.buffer[0]; 156 outptr = image_ptr[0]; 157 for (col = cinfo->output_width; col > 0; col--) { 158 *outptr++ = *inptr++; /* can omit GETJSAMPLE() safely */ 159 } 160 161 /* Zero out the pad bytes. */ 162 pad = dest->pad_bytes; 163 while (--pad >= 0) 164 *outptr++ = 0; 165 } 166 167 168 /* 169 * Startup: normally writes the file header. 170 * In this module we may as well postpone everything until finish_output. 171 */ 172 173 METHODDEF(void) 174 start_output_bmp (j_decompress_ptr cinfo, djpeg_dest_ptr dinfo) 175 { 176 /* no work here */ 177 } 178 179 180 /* 181 * Finish up at the end of the file. 182 * 183 * Here is where we really output the BMP file. 184 * 185 * First, routines to write the Windows and OS/2 variants of the file header. 186 */ 187 188 LOCAL(void) 189 write_bmp_header (j_decompress_ptr cinfo, bmp_dest_ptr dest) 190 /* Write a Windows-style BMP file header, including colormap if needed */ 191 { 192 char bmpfileheader[14]; 193 char bmpinfoheader[40]; 194 #define PUT_2B(array,offset,value) \ 195 (array[offset] = (char) ((value) & 0xFF), \ 196 array[offset+1] = (char) (((value) >> 8) & 0xFF)) 197 #define PUT_4B(array,offset,value) \ 198 (array[offset] = (char) ((value) & 0xFF), \ 199 array[offset+1] = (char) (((value) >> 8) & 0xFF), \ 200 array[offset+2] = (char) (((value) >> 16) & 0xFF), \ 201 array[offset+3] = (char) (((value) >> 24) & 0xFF)) 202 INT32 headersize, bfSize; 203 int bits_per_pixel, cmap_entries; 204 205 /* Compute colormap size and total file size */ 206 if (cinfo->out_color_space == JCS_RGB) { 207 if (cinfo->quantize_colors) { 208 /* Colormapped RGB */ 209 bits_per_pixel = 8; 210 cmap_entries = 256; 211 } else { 212 /* Unquantized, full color RGB */ 213 bits_per_pixel = 24; 214 cmap_entries = 0; 215 } 216 } else if (cinfo->out_color_space == JCS_RGB565) { 217 bits_per_pixel = 24; 218 cmap_entries = 0; 219 } else { 220 /* Grayscale output. We need to fake a 256-entry colormap. */ 221 bits_per_pixel = 8; 222 cmap_entries = 256; 223 } 224 /* File size */ 225 headersize = 14 + 40 + cmap_entries * 4; /* Header and colormap */ 226 bfSize = headersize + (INT32) dest->row_width * (INT32) cinfo->output_height; 227 228 /* Set unused fields of header to 0 */ 229 MEMZERO(bmpfileheader, sizeof(bmpfileheader)); 230 MEMZERO(bmpinfoheader, sizeof(bmpinfoheader)); 231 232 /* Fill the file header */ 233 bmpfileheader[0] = 0x42; /* first 2 bytes are ASCII 'B', 'M' */ 234 bmpfileheader[1] = 0x4D; 235 PUT_4B(bmpfileheader, 2, bfSize); /* bfSize */ 236 /* we leave bfReserved1 & bfReserved2 = 0 */ 237 PUT_4B(bmpfileheader, 10, headersize); /* bfOffBits */ 238 239 /* Fill the info header (Microsoft calls this a BITMAPINFOHEADER) */ 240 PUT_2B(bmpinfoheader, 0, 40); /* biSize */ 241 PUT_4B(bmpinfoheader, 4, cinfo->output_width); /* biWidth */ 242 PUT_4B(bmpinfoheader, 8, cinfo->output_height); /* biHeight */ 243 PUT_2B(bmpinfoheader, 12, 1); /* biPlanes - must be 1 */ 244 PUT_2B(bmpinfoheader, 14, bits_per_pixel); /* biBitCount */ 245 /* we leave biCompression = 0, for none */ 246 /* we leave biSizeImage = 0; this is correct for uncompressed data */ 247 if (cinfo->density_unit == 2) { /* if have density in dots/cm, then */ 248 PUT_4B(bmpinfoheader, 24, (INT32) (cinfo->X_density*100)); /* XPels/M */ 249 PUT_4B(bmpinfoheader, 28, (INT32) (cinfo->Y_density*100)); /* XPels/M */ 250 } 251 PUT_2B(bmpinfoheader, 32, cmap_entries); /* biClrUsed */ 252 /* we leave biClrImportant = 0 */ 253 254 if (JFWRITE(dest->pub.output_file, bmpfileheader, 14) != (size_t) 14) 255 ERREXIT(cinfo, JERR_FILE_WRITE); 256 if (JFWRITE(dest->pub.output_file, bmpinfoheader, 40) != (size_t) 40) 257 ERREXIT(cinfo, JERR_FILE_WRITE); 258 259 if (cmap_entries > 0) 260 write_colormap(cinfo, dest, cmap_entries, 4); 261 } 262 263 264 LOCAL(void) 265 write_os2_header (j_decompress_ptr cinfo, bmp_dest_ptr dest) 266 /* Write an OS2-style BMP file header, including colormap if needed */ 267 { 268 char bmpfileheader[14]; 269 char bmpcoreheader[12]; 270 INT32 headersize, bfSize; 271 int bits_per_pixel, cmap_entries; 272 273 /* Compute colormap size and total file size */ 274 if (cinfo->out_color_space == JCS_RGB) { 275 if (cinfo->quantize_colors) { 276 /* Colormapped RGB */ 277 bits_per_pixel = 8; 278 cmap_entries = 256; 279 } else { 280 /* Unquantized, full color RGB */ 281 bits_per_pixel = 24; 282 cmap_entries = 0; 283 } 284 } else if (cinfo->out_color_space == JCS_RGB565) { 285 bits_per_pixel = 24; 286 cmap_entries = 0; 287 } else { 288 /* Grayscale output. We need to fake a 256-entry colormap. */ 289 bits_per_pixel = 8; 290 cmap_entries = 256; 291 } 292 /* File size */ 293 headersize = 14 + 12 + cmap_entries * 3; /* Header and colormap */ 294 bfSize = headersize + (INT32) dest->row_width * (INT32) cinfo->output_height; 295 296 /* Set unused fields of header to 0 */ 297 MEMZERO(bmpfileheader, sizeof(bmpfileheader)); 298 MEMZERO(bmpcoreheader, sizeof(bmpcoreheader)); 299 300 /* Fill the file header */ 301 bmpfileheader[0] = 0x42; /* first 2 bytes are ASCII 'B', 'M' */ 302 bmpfileheader[1] = 0x4D; 303 PUT_4B(bmpfileheader, 2, bfSize); /* bfSize */ 304 /* we leave bfReserved1 & bfReserved2 = 0 */ 305 PUT_4B(bmpfileheader, 10, headersize); /* bfOffBits */ 306 307 /* Fill the info header (Microsoft calls this a BITMAPCOREHEADER) */ 308 PUT_2B(bmpcoreheader, 0, 12); /* bcSize */ 309 PUT_2B(bmpcoreheader, 4, cinfo->output_width); /* bcWidth */ 310 PUT_2B(bmpcoreheader, 6, cinfo->output_height); /* bcHeight */ 311 PUT_2B(bmpcoreheader, 8, 1); /* bcPlanes - must be 1 */ 312 PUT_2B(bmpcoreheader, 10, bits_per_pixel); /* bcBitCount */ 313 314 if (JFWRITE(dest->pub.output_file, bmpfileheader, 14) != (size_t) 14) 315 ERREXIT(cinfo, JERR_FILE_WRITE); 316 if (JFWRITE(dest->pub.output_file, bmpcoreheader, 12) != (size_t) 12) 317 ERREXIT(cinfo, JERR_FILE_WRITE); 318 319 if (cmap_entries > 0) 320 write_colormap(cinfo, dest, cmap_entries, 3); 321 } 322 323 324 /* 325 * Write the colormap. 326 * Windows uses BGR0 map entries; OS/2 uses BGR entries. 327 */ 328 329 LOCAL(void) 330 write_colormap (j_decompress_ptr cinfo, bmp_dest_ptr dest, 331 int map_colors, int map_entry_size) 332 { 333 JSAMPARRAY colormap = cinfo->colormap; 334 int num_colors = cinfo->actual_number_of_colors; 335 FILE * outfile = dest->pub.output_file; 336 int i; 337 338 if (colormap != NULL) { 339 if (cinfo->out_color_components == 3) { 340 /* Normal case with RGB colormap */ 341 for (i = 0; i < num_colors; i++) { 342 putc(GETJSAMPLE(colormap[2][i]), outfile); 343 putc(GETJSAMPLE(colormap[1][i]), outfile); 344 putc(GETJSAMPLE(colormap[0][i]), outfile); 345 if (map_entry_size == 4) 346 putc(0, outfile); 347 } 348 } else { 349 /* Grayscale colormap (only happens with grayscale quantization) */ 350 for (i = 0; i < num_colors; i++) { 351 putc(GETJSAMPLE(colormap[0][i]), outfile); 352 putc(GETJSAMPLE(colormap[0][i]), outfile); 353 putc(GETJSAMPLE(colormap[0][i]), outfile); 354 if (map_entry_size == 4) 355 putc(0, outfile); 356 } 357 } 358 } else { 359 /* If no colormap, must be grayscale data. Generate a linear "map". */ 360 for (i = 0; i < 256; i++) { 361 putc(i, outfile); 362 putc(i, outfile); 363 putc(i, outfile); 364 if (map_entry_size == 4) 365 putc(0, outfile); 366 } 367 } 368 /* Pad colormap with zeros to ensure specified number of colormap entries */ 369 if (i > map_colors) 370 ERREXIT1(cinfo, JERR_TOO_MANY_COLORS, i); 371 for (; i < map_colors; i++) { 372 putc(0, outfile); 373 putc(0, outfile); 374 putc(0, outfile); 375 if (map_entry_size == 4) 376 putc(0, outfile); 377 } 378 } 379 380 381 METHODDEF(void) 382 finish_output_bmp (j_decompress_ptr cinfo, djpeg_dest_ptr dinfo) 383 { 384 bmp_dest_ptr dest = (bmp_dest_ptr) dinfo; 385 register FILE * outfile = dest->pub.output_file; 386 JSAMPARRAY image_ptr; 387 register JSAMPROW data_ptr; 388 JDIMENSION row; 389 register JDIMENSION col; 390 cd_progress_ptr progress = (cd_progress_ptr) cinfo->progress; 391 392 /* Write the header and colormap */ 393 if (dest->is_os2) 394 write_os2_header(cinfo, dest); 395 else 396 write_bmp_header(cinfo, dest); 397 398 /* Write the file body from our virtual array */ 399 for (row = cinfo->output_height; row > 0; row--) { 400 if (progress != NULL) { 401 progress->pub.pass_counter = (long) (cinfo->output_height - row); 402 progress->pub.pass_limit = (long) cinfo->output_height; 403 (*progress->pub.progress_monitor) ((j_common_ptr) cinfo); 404 } 405 image_ptr = (*cinfo->mem->access_virt_sarray) 406 ((j_common_ptr) cinfo, dest->whole_image, row-1, (JDIMENSION) 1, FALSE); 407 data_ptr = image_ptr[0]; 408 for (col = dest->row_width; col > 0; col--) { 409 putc(GETJSAMPLE(*data_ptr), outfile); 410 data_ptr++; 411 } 412 } 413 if (progress != NULL) 414 progress->completed_extra_passes++; 415 416 /* Make sure we wrote the output file OK */ 417 fflush(outfile); 418 if (ferror(outfile)) 419 ERREXIT(cinfo, JERR_FILE_WRITE); 420 } 421 422 423 /* 424 * The module selection routine for BMP format output. 425 */ 426 427 GLOBAL(djpeg_dest_ptr) 428 jinit_write_bmp (j_decompress_ptr cinfo, boolean is_os2) 429 { 430 bmp_dest_ptr dest; 431 JDIMENSION row_width; 432 433 /* Create module interface object, fill in method pointers */ 434 dest = (bmp_dest_ptr) 435 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, 436 sizeof(bmp_dest_struct)); 437 dest->pub.start_output = start_output_bmp; 438 dest->pub.finish_output = finish_output_bmp; 439 dest->is_os2 = is_os2; 440 441 if (cinfo->out_color_space == JCS_GRAYSCALE) { 442 dest->pub.put_pixel_rows = put_gray_rows; 443 } else if (cinfo->out_color_space == JCS_RGB) { 444 if (cinfo->quantize_colors) 445 dest->pub.put_pixel_rows = put_gray_rows; 446 else 447 dest->pub.put_pixel_rows = put_pixel_rows; 448 } else if(cinfo->out_color_space == JCS_RGB565 ) { 449 dest->pub.put_pixel_rows = put_pixel_rows; 450 } else { 451 ERREXIT(cinfo, JERR_BMP_COLORSPACE); 452 } 453 454 /* Calculate output image dimensions so we can allocate space */ 455 jpeg_calc_output_dimensions(cinfo); 456 457 /* Determine width of rows in the BMP file (padded to 4-byte boundary). */ 458 if (cinfo->out_color_space == JCS_RGB565) { 459 row_width = cinfo->output_width * 2; 460 dest->row_width = dest->data_width = cinfo->output_width * 3; 461 } else { 462 row_width = cinfo->output_width * cinfo->output_components; 463 dest->row_width = dest->data_width = row_width; 464 } 465 while ((dest->row_width & 3) != 0) dest->row_width++; 466 dest->pad_bytes = (int) (dest->row_width - dest->data_width); 467 if (cinfo->out_color_space == JCS_RGB565) { 468 while ((row_width & 3) != 0) row_width++; 469 } else { 470 row_width = dest->row_width; 471 } 472 473 474 /* Allocate space for inversion array, prepare for write pass */ 475 dest->whole_image = (*cinfo->mem->request_virt_sarray) 476 ((j_common_ptr) cinfo, JPOOL_IMAGE, FALSE, 477 dest->row_width, cinfo->output_height, (JDIMENSION) 1); 478 dest->cur_output_row = 0; 479 if (cinfo->progress != NULL) { 480 cd_progress_ptr progress = (cd_progress_ptr) cinfo->progress; 481 progress->total_extra_passes++; /* count file input as separate pass */ 482 } 483 484 /* Create decompressor output buffer. */ 485 dest->pub.buffer = (*cinfo->mem->alloc_sarray) 486 ((j_common_ptr) cinfo, JPOOL_IMAGE, row_width, (JDIMENSION) 1); 487 dest->pub.buffer_height = 1; 488 489 return (djpeg_dest_ptr) dest; 490 } 491 492 #endif /* BMP_SUPPORTED */ 493
