cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 1 | /* |
| 2 | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| 3 | % % |
| 4 | % % |
| 5 | % % |
| 6 | % PPPP DDDD BBBB % |
| 7 | % P P D D B B % |
| 8 | % PPPP D D BBBB % |
| 9 | % P D D B B % |
| 10 | % P DDDD BBBB % |
| 11 | % % |
| 12 | % % |
| 13 | % Read/Write Palm Database ImageViewer Image Format % |
| 14 | % % |
| 15 | % Software Design % |
cristy | de984cd | 2013-12-01 14:49:27 +0000 | [diff] [blame] | 16 | % Cristy % |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 17 | % July 1992 % |
| 18 | % % |
| 19 | % % |
Cristy | 7ce65e7 | 2015-12-12 18:03:16 -0500 | [diff] [blame] | 20 | % Copyright 1999-2016 ImageMagick Studio LLC, a non-profit organization % |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 21 | % dedicated to making software imaging solutions freely available. % |
| 22 | % % |
| 23 | % You may not use this file except in compliance with the License. You may % |
| 24 | % obtain a copy of the License at % |
| 25 | % % |
| 26 | % http://www.imagemagick.org/script/license.php % |
| 27 | % % |
| 28 | % Unless required by applicable law or agreed to in writing, software % |
| 29 | % distributed under the License is distributed on an "AS IS" BASIS, % |
| 30 | % WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. % |
| 31 | % See the License for the specific language governing permissions and % |
| 32 | % limitations under the License. % |
| 33 | % % |
| 34 | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| 35 | % |
| 36 | % |
cristy | 98cba56 | 2014-11-20 23:46:19 +0000 | [diff] [blame] | 37 | % 20071202 TS * rewrote RLE decoder - old version could cause buffer overflows |
| 38 | % * failure of RLE decoding now thows error RLEDecoderError |
| 39 | % * fixed bug in RLE decoding - now all rows are decoded, not just |
| 40 | % the first one |
| 41 | % * fixed bug in reader - record offsets now handled correctly |
| 42 | % * fixed bug in reader - only bits 0..2 indicate compression type |
| 43 | % * in writer: now using image color count instead of depth |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 44 | */ |
| 45 | |
| 46 | /* |
| 47 | Include declarations. |
| 48 | */ |
cristy | 4c08aed | 2011-07-01 19:47:50 +0000 | [diff] [blame] | 49 | #include "MagickCore/studio.h" |
| 50 | #include "MagickCore/attribute.h" |
| 51 | #include "MagickCore/blob.h" |
| 52 | #include "MagickCore/blob-private.h" |
| 53 | #include "MagickCore/cache.h" |
| 54 | #include "MagickCore/colormap-private.h" |
| 55 | #include "MagickCore/color-private.h" |
| 56 | #include "MagickCore/colormap.h" |
| 57 | #include "MagickCore/colorspace.h" |
cristy | 510d06a | 2011-07-06 23:43:54 +0000 | [diff] [blame] | 58 | #include "MagickCore/colorspace-private.h" |
cristy | 4c08aed | 2011-07-01 19:47:50 +0000 | [diff] [blame] | 59 | #include "MagickCore/constitute.h" |
| 60 | #include "MagickCore/exception.h" |
| 61 | #include "MagickCore/exception-private.h" |
| 62 | #include "MagickCore/image.h" |
| 63 | #include "MagickCore/image-private.h" |
| 64 | #include "MagickCore/list.h" |
| 65 | #include "MagickCore/magick.h" |
| 66 | #include "MagickCore/memory_.h" |
| 67 | #include "MagickCore/monitor.h" |
| 68 | #include "MagickCore/monitor-private.h" |
| 69 | #include "MagickCore/pixel-accessor.h" |
| 70 | #include "MagickCore/property.h" |
| 71 | #include "MagickCore/quantum-private.h" |
| 72 | #include "MagickCore/quantum-private.h" |
| 73 | #include "MagickCore/static.h" |
| 74 | #include "MagickCore/string_.h" |
| 75 | #include "MagickCore/module.h" |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 76 | |
| 77 | /* |
| 78 | Typedef declarations. |
| 79 | */ |
| 80 | typedef struct _PDBInfo |
| 81 | { |
| 82 | char |
| 83 | name[32]; |
| 84 | |
| 85 | short int |
| 86 | attributes, |
| 87 | version; |
| 88 | |
cristy | bb50337 | 2010-05-27 20:51:26 +0000 | [diff] [blame] | 89 | size_t |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 90 | create_time, |
| 91 | modify_time, |
| 92 | archive_time, |
| 93 | modify_number, |
| 94 | application_info, |
| 95 | sort_info; |
| 96 | |
| 97 | char |
| 98 | type[4], /* database type identifier "vIMG" */ |
| 99 | id[4]; /* database creator identifier "View" */ |
| 100 | |
cristy | bb50337 | 2010-05-27 20:51:26 +0000 | [diff] [blame] | 101 | size_t |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 102 | seed, |
| 103 | next_record; |
| 104 | |
| 105 | short int |
| 106 | number_records; |
| 107 | } PDBInfo; |
| 108 | |
| 109 | typedef struct _PDBImage |
| 110 | { |
| 111 | char |
| 112 | name[32], |
dirk | 93b02b7 | 2013-11-16 16:03:36 +0000 | [diff] [blame] | 113 | version; |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 114 | |
cristy | bb50337 | 2010-05-27 20:51:26 +0000 | [diff] [blame] | 115 | size_t |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 116 | reserved_1, |
| 117 | note; |
| 118 | |
| 119 | short int |
| 120 | x_last, |
| 121 | y_last; |
| 122 | |
cristy | bb50337 | 2010-05-27 20:51:26 +0000 | [diff] [blame] | 123 | size_t |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 124 | reserved_2; |
| 125 | |
| 126 | short int |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 127 | width, |
| 128 | height; |
dirk | 93b02b7 | 2013-11-16 16:03:36 +0000 | [diff] [blame] | 129 | |
| 130 | unsigned char |
| 131 | type; |
| 132 | |
| 133 | unsigned short |
| 134 | x_anchor, |
| 135 | y_anchor; |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 136 | } PDBImage; |
| 137 | /* |
| 138 | Forward declarations. |
| 139 | */ |
| 140 | static MagickBooleanType |
cristy | 1e178e7 | 2011-08-28 19:44:34 +0000 | [diff] [blame] | 141 | WritePDBImage(const ImageInfo *,Image *,ExceptionInfo *); |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 142 | |
| 143 | /* |
| 144 | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| 145 | % % |
| 146 | % % |
| 147 | % % |
| 148 | % D e c o d e I m a g e % |
| 149 | % % |
| 150 | % % |
| 151 | % % |
| 152 | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| 153 | % |
| 154 | % DecodeImage unpacks the packed image pixels into runlength-encoded |
| 155 | % pixel packets. |
| 156 | % |
| 157 | % The format of the DecodeImage method is: |
| 158 | % |
| 159 | % MagickBooleanType DecodeImage(Image *image,unsigned char *pixels, |
| 160 | % const size_t length) |
| 161 | % |
| 162 | % A description of each parameter follows: |
| 163 | % |
| 164 | % o image: the address of a structure of type Image. |
| 165 | % |
| 166 | % o pixels: The address of a byte (8 bits) array of pixel data created by |
| 167 | % the decoding process. |
| 168 | % |
| 169 | % o length: Number of bytes to read into buffer 'pixels'. |
| 170 | % |
| 171 | */ |
| 172 | static MagickBooleanType DecodeImage(Image *image, unsigned char *pixels, |
| 173 | const size_t length) |
| 174 | { |
| 175 | #define RLE_MODE_NONE -1 |
| 176 | #define RLE_MODE_COPY 0 |
| 177 | #define RLE_MODE_RUN 1 |
| 178 | |
cristy | c5de699 | 2009-10-06 19:19:48 +0000 | [diff] [blame] | 179 | int data = 0, count = 0; |
| 180 | unsigned char *p; |
| 181 | int mode = RLE_MODE_NONE; |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 182 | |
cristy | c5de699 | 2009-10-06 19:19:48 +0000 | [diff] [blame] | 183 | for (p = pixels; p < pixels + length; p++) { |
| 184 | if (0 == count) { |
| 185 | data = ReadBlobByte( image ); |
| 186 | if (-1 == data) return MagickFalse; |
| 187 | if (data > 128) { |
| 188 | mode = RLE_MODE_RUN; |
| 189 | count = data - 128 + 1; |
| 190 | data = ReadBlobByte( image ); |
| 191 | if (-1 == data) return MagickFalse; |
| 192 | } else { |
| 193 | mode = RLE_MODE_COPY; |
| 194 | count = data + 1; |
| 195 | } |
| 196 | } |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 197 | |
cristy | c5de699 | 2009-10-06 19:19:48 +0000 | [diff] [blame] | 198 | if (RLE_MODE_COPY == mode) { |
| 199 | data = ReadBlobByte( image ); |
| 200 | if (-1 == data) return MagickFalse; |
| 201 | } |
| 202 | *p = (unsigned char)data; |
| 203 | --count; |
| 204 | } |
| 205 | return MagickTrue; |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 206 | } |
| 207 | |
| 208 | /* |
| 209 | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| 210 | % % |
| 211 | % % |
| 212 | % % |
| 213 | % I s P D B % |
| 214 | % % |
| 215 | % % |
| 216 | % % |
| 217 | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| 218 | % |
| 219 | % IsPDB() returns MagickTrue if the image format type, identified by the |
| 220 | % magick string, is PDB. |
| 221 | % |
| 222 | % The format of the ReadPDBImage method is: |
| 223 | % |
| 224 | % MagickBooleanType IsPDB(const unsigned char *magick,const size_t length) |
| 225 | % |
| 226 | % A description of each parameter follows: |
| 227 | % |
| 228 | % o magick: compare image format pattern against these bytes. |
| 229 | % |
| 230 | % o length: Specifies the length of the magick string. |
| 231 | % |
| 232 | */ |
| 233 | static MagickBooleanType IsPDB(const unsigned char *magick,const size_t length) |
| 234 | { |
| 235 | if (length < 68) |
| 236 | return(MagickFalse); |
| 237 | if (memcmp(magick+60,"vIMGView",8) == 0) |
| 238 | return(MagickTrue); |
| 239 | return(MagickFalse); |
| 240 | } |
| 241 | |
| 242 | /* |
| 243 | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| 244 | % % |
| 245 | % % |
| 246 | % % |
| 247 | % R e a d P D B I m a g e % |
| 248 | % % |
| 249 | % % |
| 250 | % % |
| 251 | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| 252 | % |
| 253 | % ReadPDBImage() reads an Pilot image file and returns it. It |
| 254 | % allocates the memory necessary for the new Image structure and returns a |
| 255 | % pointer to the new image. |
| 256 | % |
| 257 | % The format of the ReadPDBImage method is: |
| 258 | % |
| 259 | % Image *ReadPDBImage(const ImageInfo *image_info,ExceptionInfo *exception) |
| 260 | % |
| 261 | % A description of each parameter follows: |
| 262 | % |
| 263 | % o image_info: the image info. |
| 264 | % |
| 265 | % o exception: return any errors or warnings in this structure. |
| 266 | % |
| 267 | */ |
| 268 | static Image *ReadPDBImage(const ImageInfo *image_info,ExceptionInfo *exception) |
| 269 | { |
| 270 | unsigned char |
cristy | 98cba56 | 2014-11-20 23:46:19 +0000 | [diff] [blame] | 271 | attributes, |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 272 | tag[3]; |
| 273 | |
| 274 | Image |
| 275 | *image; |
| 276 | |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 277 | MagickBooleanType |
| 278 | status; |
| 279 | |
| 280 | PDBImage |
| 281 | pdb_image; |
| 282 | |
| 283 | PDBInfo |
| 284 | pdb_info; |
| 285 | |
cristy | 4c08aed | 2011-07-01 19:47:50 +0000 | [diff] [blame] | 286 | Quantum |
| 287 | index; |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 288 | |
cristy | bb50337 | 2010-05-27 20:51:26 +0000 | [diff] [blame] | 289 | register ssize_t |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 290 | x; |
| 291 | |
cristy | 4c08aed | 2011-07-01 19:47:50 +0000 | [diff] [blame] | 292 | register Quantum |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 293 | *q; |
| 294 | |
| 295 | register unsigned char |
| 296 | *p; |
| 297 | |
cristy | bb50337 | 2010-05-27 20:51:26 +0000 | [diff] [blame] | 298 | size_t |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 299 | bits_per_pixel, |
cristy | 98cba56 | 2014-11-20 23:46:19 +0000 | [diff] [blame] | 300 | num_pad_bytes, |
cristy | eaedf06 | 2010-05-29 22:36:02 +0000 | [diff] [blame] | 301 | one, |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 302 | packets; |
| 303 | |
cristy | aff6d80 | 2011-04-26 01:46:31 +0000 | [diff] [blame] | 304 | ssize_t |
| 305 | count, |
cristy | 98cba56 | 2014-11-20 23:46:19 +0000 | [diff] [blame] | 306 | img_offset, |
cristy | aff6d80 | 2011-04-26 01:46:31 +0000 | [diff] [blame] | 307 | comment_offset = 0, |
| 308 | y; |
| 309 | |
| 310 | unsigned char |
| 311 | *pixels; |
| 312 | |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 313 | /* |
| 314 | Open image file. |
| 315 | */ |
| 316 | assert(image_info != (const ImageInfo *) NULL); |
cristy | e1c94d9 | 2015-06-28 12:16:33 +0000 | [diff] [blame] | 317 | assert(image_info->signature == MagickCoreSignature); |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 318 | if (image_info->debug != MagickFalse) |
| 319 | (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s", |
| 320 | image_info->filename); |
| 321 | assert(exception != (ExceptionInfo *) NULL); |
cristy | e1c94d9 | 2015-06-28 12:16:33 +0000 | [diff] [blame] | 322 | assert(exception->signature == MagickCoreSignature); |
cristy | 9950d57 | 2011-10-01 18:22:35 +0000 | [diff] [blame] | 323 | image=AcquireImage(image_info,exception); |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 324 | status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception); |
| 325 | if (status == MagickFalse) |
| 326 | { |
| 327 | image=DestroyImageList(image); |
| 328 | return((Image *) NULL); |
| 329 | } |
| 330 | /* |
| 331 | Determine if this a PDB image file. |
| 332 | */ |
cristy | ca793d7 | 2015-01-23 13:03:55 +0000 | [diff] [blame] | 333 | count=ReadBlob(image,sizeof(pdb_info.name),(unsigned char *) pdb_info.name); |
| 334 | if (count != sizeof(pdb_info.name)) |
| 335 | ThrowReaderException(CorruptImageError,"ImproperImageHeader"); |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 336 | pdb_info.attributes=(short) ReadBlobMSBShort(image); |
| 337 | pdb_info.version=(short) ReadBlobMSBShort(image); |
| 338 | pdb_info.create_time=ReadBlobMSBLong(image); |
| 339 | pdb_info.modify_time=ReadBlobMSBLong(image); |
| 340 | pdb_info.archive_time=ReadBlobMSBLong(image); |
| 341 | pdb_info.modify_number=ReadBlobMSBLong(image); |
| 342 | pdb_info.application_info=ReadBlobMSBLong(image); |
| 343 | pdb_info.sort_info=ReadBlobMSBLong(image); |
cristy | 7e5d1da | 2014-12-28 00:40:02 +0000 | [diff] [blame] | 344 | (void) ReadBlob(image,4,(unsigned char *) pdb_info.type); |
| 345 | (void) ReadBlob(image,4,(unsigned char *) pdb_info.id); |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 346 | pdb_info.seed=ReadBlobMSBLong(image); |
| 347 | pdb_info.next_record=ReadBlobMSBLong(image); |
| 348 | pdb_info.number_records=(short) ReadBlobMSBShort(image); |
cristy | 7e5d1da | 2014-12-28 00:40:02 +0000 | [diff] [blame] | 349 | if ((memcmp(pdb_info.type,"vIMG",4) != 0) || |
| 350 | (memcmp(pdb_info.id,"View",4) != 0)) |
| 351 | ThrowReaderException(CorruptImageError,"ImproperImageHeader"); |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 352 | if (pdb_info.next_record != 0) |
| 353 | ThrowReaderException(CoderError,"MultipleRecordListNotSupported"); |
| 354 | /* |
| 355 | Read record header. |
| 356 | */ |
cristy | 98cba56 | 2014-11-20 23:46:19 +0000 | [diff] [blame] | 357 | img_offset=(ssize_t) ((int) ReadBlobMSBLong(image)); |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 358 | attributes=(unsigned char) ReadBlobByte(image); |
cristy | da16f16 | 2011-02-19 23:52:17 +0000 | [diff] [blame] | 359 | (void) attributes; |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 360 | count=ReadBlob(image,3,(unsigned char *) tag); |
| 361 | if (count != 3 || memcmp(tag,"\x6f\x80\x00",3) != 0) |
| 362 | ThrowReaderException(CorruptImageError,"CorruptImage"); |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 363 | if (pdb_info.number_records > 1) |
| 364 | { |
cristy | 98cba56 | 2014-11-20 23:46:19 +0000 | [diff] [blame] | 365 | comment_offset=(ssize_t) ((int) ReadBlobMSBLong(image)); |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 366 | attributes=(unsigned char) ReadBlobByte(image); |
| 367 | count=ReadBlob(image,3,(unsigned char *) tag); |
| 368 | if (count != 3 || memcmp(tag,"\x6f\x80\x01",3) != 0) |
| 369 | ThrowReaderException(CorruptImageError,"CorruptImage"); |
| 370 | } |
cristy | bb50337 | 2010-05-27 20:51:26 +0000 | [diff] [blame] | 371 | num_pad_bytes = (size_t) (img_offset - TellBlob( image )); |
cristy | 89f839d | 2015-01-25 17:32:32 +0000 | [diff] [blame] | 372 | while (num_pad_bytes-- != 0) |
| 373 | { |
| 374 | int |
| 375 | c; |
| 376 | |
| 377 | c=ReadBlobByte(image); |
| 378 | if (c == EOF) |
| 379 | break; |
| 380 | } |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 381 | /* |
| 382 | Read image header. |
| 383 | */ |
cristy | ca793d7 | 2015-01-23 13:03:55 +0000 | [diff] [blame] | 384 | count=ReadBlob(image,sizeof(pdb_image.name),(unsigned char *) pdb_image.name); |
| 385 | if (count != sizeof(pdb_image.name)) |
| 386 | ThrowReaderException(CorruptImageError,"ImproperImageHeader"); |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 387 | pdb_image.version=ReadBlobByte(image); |
cristy | 98cba56 | 2014-11-20 23:46:19 +0000 | [diff] [blame] | 388 | pdb_image.type=(unsigned char) ((int) ReadBlobByte(image)); |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 389 | pdb_image.reserved_1=ReadBlobMSBLong(image); |
| 390 | pdb_image.note=ReadBlobMSBLong(image); |
| 391 | pdb_image.x_last=(short) ReadBlobMSBShort(image); |
| 392 | pdb_image.y_last=(short) ReadBlobMSBShort(image); |
| 393 | pdb_image.reserved_2=ReadBlobMSBLong(image); |
dirk | 93b02b7 | 2013-11-16 16:03:36 +0000 | [diff] [blame] | 394 | pdb_image.x_anchor=ReadBlobMSBShort(image); |
| 395 | pdb_image.y_anchor=ReadBlobMSBShort(image); |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 396 | pdb_image.width=(short) ReadBlobMSBShort(image); |
| 397 | pdb_image.height=(short) ReadBlobMSBShort(image); |
| 398 | /* |
| 399 | Initialize image structure. |
| 400 | */ |
cristy | bb50337 | 2010-05-27 20:51:26 +0000 | [diff] [blame] | 401 | image->columns=(size_t) pdb_image.width; |
| 402 | image->rows=(size_t) pdb_image.height; |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 403 | image->depth=8; |
cristy | acabb84 | 2014-12-14 23:36:33 +0000 | [diff] [blame] | 404 | status=SetImageExtent(image,image->columns,image->rows,exception); |
| 405 | if (status == MagickFalse) |
| 406 | return(DestroyImageList(image)); |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 407 | image->storage_class=PseudoClass; |
| 408 | bits_per_pixel=pdb_image.type == 0 ? 2UL : pdb_image.type == 2 ? 4UL : 1UL; |
cristy | eaedf06 | 2010-05-29 22:36:02 +0000 | [diff] [blame] | 409 | one=1; |
cristy | 018f07f | 2011-09-04 21:15:19 +0000 | [diff] [blame] | 410 | if (AcquireImageColormap(image,one << bits_per_pixel,exception) == MagickFalse) |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 411 | ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed"); |
| 412 | if (image_info->ping != MagickFalse) |
| 413 | { |
| 414 | (void) CloseBlob(image); |
| 415 | return(GetFirstImageInList(image)); |
| 416 | } |
cristy | 55a26ef | 2014-11-29 17:16:29 +0000 | [diff] [blame] | 417 | packets=(bits_per_pixel*image->columns+7)/8; |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 418 | pixels=(unsigned char *) AcquireQuantumMemory(packets+256UL,image->rows* |
| 419 | sizeof(*pixels)); |
| 420 | if (pixels == (unsigned char *) NULL) |
| 421 | ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed"); |
cristy | 98cba56 | 2014-11-20 23:46:19 +0000 | [diff] [blame] | 422 | switch (pdb_image.version & 0x07) |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 423 | { |
| 424 | case 0: |
| 425 | { |
| 426 | image->compression=NoCompression; |
| 427 | count=(ssize_t) ReadBlob(image, packets * image -> rows, pixels); |
| 428 | break; |
| 429 | } |
| 430 | case 1: |
| 431 | { |
| 432 | image->compression=RLECompression; |
| 433 | if (!DecodeImage(image, pixels, packets * image -> rows)) |
cristy | 98cba56 | 2014-11-20 23:46:19 +0000 | [diff] [blame] | 434 | ThrowReaderException( CorruptImageError, "RLEDecoderError" ); |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 435 | break; |
| 436 | } |
| 437 | default: |
| 438 | ThrowReaderException(CorruptImageError, |
cristy | c5de699 | 2009-10-06 19:19:48 +0000 | [diff] [blame] | 439 | "UnrecognizedImageCompressionType" ); |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 440 | } |
| 441 | p=pixels; |
| 442 | switch (bits_per_pixel) |
| 443 | { |
| 444 | case 1: |
| 445 | { |
| 446 | int |
| 447 | bit; |
| 448 | |
| 449 | /* |
| 450 | Read 1-bit PDB image. |
| 451 | */ |
cristy | bb50337 | 2010-05-27 20:51:26 +0000 | [diff] [blame] | 452 | for (y=0; y < (ssize_t) image->rows; y++) |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 453 | { |
| 454 | q=QueueAuthenticPixels(image,0,y,image->columns,1,exception); |
cristy | acd2ed2 | 2011-08-30 01:44:23 +0000 | [diff] [blame] | 455 | if (q == (Quantum *) NULL) |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 456 | break; |
cristy | bb50337 | 2010-05-27 20:51:26 +0000 | [diff] [blame] | 457 | for (x=0; x < ((ssize_t) image->columns-7); x+=8) |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 458 | { |
| 459 | for (bit=0; bit < 8; bit++) |
| 460 | { |
cristy | 4c08aed | 2011-07-01 19:47:50 +0000 | [diff] [blame] | 461 | index=(Quantum) (*p & (0x80 >> bit) ? 0x00 : 0x01); |
| 462 | SetPixelIndex(image,index,q); |
cristy | ed23157 | 2011-07-14 02:18:59 +0000 | [diff] [blame] | 463 | q+=GetPixelChannels(image); |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 464 | } |
| 465 | p++; |
| 466 | } |
| 467 | if (SyncAuthenticPixels(image,exception) == MagickFalse) |
| 468 | break; |
cristy | cee9711 | 2010-05-28 00:44:52 +0000 | [diff] [blame] | 469 | status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y, |
cristy | aff6d80 | 2011-04-26 01:46:31 +0000 | [diff] [blame] | 470 | image->rows); |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 471 | if (status == MagickFalse) |
| 472 | break; |
| 473 | } |
cristy | ea1a8aa | 2011-10-20 13:24:06 +0000 | [diff] [blame] | 474 | (void) SyncImage(image,exception); |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 475 | break; |
| 476 | } |
| 477 | case 2: |
| 478 | { |
| 479 | /* |
| 480 | Read 2-bit PDB image. |
| 481 | */ |
cristy | bb50337 | 2010-05-27 20:51:26 +0000 | [diff] [blame] | 482 | for (y=0; y < (ssize_t) image->rows; y++) |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 483 | { |
| 484 | q=QueueAuthenticPixels(image,0,y,image->columns,1,exception); |
cristy | acd2ed2 | 2011-08-30 01:44:23 +0000 | [diff] [blame] | 485 | if (q == (Quantum *) NULL) |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 486 | break; |
cristy | 29d4033 | 2014-12-30 23:48:22 +0000 | [diff] [blame] | 487 | for (x=0; x < (ssize_t) image->columns-3; x+=4) |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 488 | { |
cristy | c82a27b | 2011-10-21 01:07:16 +0000 | [diff] [blame] | 489 | index=ConstrainColormapIndex(image,3UL-((*p >> 6) & 0x03),exception); |
cristy | 4c08aed | 2011-07-01 19:47:50 +0000 | [diff] [blame] | 490 | SetPixelIndex(image,index,q); |
cristy | ed23157 | 2011-07-14 02:18:59 +0000 | [diff] [blame] | 491 | q+=GetPixelChannels(image); |
cristy | c82a27b | 2011-10-21 01:07:16 +0000 | [diff] [blame] | 492 | index=ConstrainColormapIndex(image,3UL-((*p >> 4) & 0x03),exception); |
cristy | 4c08aed | 2011-07-01 19:47:50 +0000 | [diff] [blame] | 493 | SetPixelIndex(image,index,q); |
cristy | ed23157 | 2011-07-14 02:18:59 +0000 | [diff] [blame] | 494 | q+=GetPixelChannels(image); |
cristy | c82a27b | 2011-10-21 01:07:16 +0000 | [diff] [blame] | 495 | index=ConstrainColormapIndex(image,3UL-((*p >> 2) & 0x03),exception); |
cristy | 4c08aed | 2011-07-01 19:47:50 +0000 | [diff] [blame] | 496 | SetPixelIndex(image,index,q); |
cristy | ed23157 | 2011-07-14 02:18:59 +0000 | [diff] [blame] | 497 | q+=GetPixelChannels(image); |
cristy | c82a27b | 2011-10-21 01:07:16 +0000 | [diff] [blame] | 498 | index=ConstrainColormapIndex(image,3UL-((*p) & 0x03),exception); |
cristy | 4c08aed | 2011-07-01 19:47:50 +0000 | [diff] [blame] | 499 | SetPixelIndex(image,index,q); |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 500 | p++; |
cristy | ed23157 | 2011-07-14 02:18:59 +0000 | [diff] [blame] | 501 | q+=GetPixelChannels(image); |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 502 | } |
| 503 | if (SyncAuthenticPixels(image,exception) == MagickFalse) |
| 504 | break; |
cristy | cee9711 | 2010-05-28 00:44:52 +0000 | [diff] [blame] | 505 | status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y, |
cristy | aff6d80 | 2011-04-26 01:46:31 +0000 | [diff] [blame] | 506 | image->rows); |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 507 | if (status == MagickFalse) |
| 508 | break; |
| 509 | } |
cristy | ea1a8aa | 2011-10-20 13:24:06 +0000 | [diff] [blame] | 510 | (void) SyncImage(image,exception); |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 511 | break; |
| 512 | } |
| 513 | case 4: |
| 514 | { |
| 515 | /* |
| 516 | Read 4-bit PDB image. |
| 517 | */ |
cristy | bb50337 | 2010-05-27 20:51:26 +0000 | [diff] [blame] | 518 | for (y=0; y < (ssize_t) image->rows; y++) |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 519 | { |
| 520 | q=QueueAuthenticPixels(image,0,y,image->columns,1,exception); |
cristy | acd2ed2 | 2011-08-30 01:44:23 +0000 | [diff] [blame] | 521 | if (q == (Quantum *) NULL) |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 522 | break; |
cristy | 29d4033 | 2014-12-30 23:48:22 +0000 | [diff] [blame] | 523 | for (x=0; x < (ssize_t) image->columns-1; x+=2) |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 524 | { |
cristy | c82a27b | 2011-10-21 01:07:16 +0000 | [diff] [blame] | 525 | index=ConstrainColormapIndex(image,15UL-((*p >> 4) & 0x0f),exception); |
cristy | 4c08aed | 2011-07-01 19:47:50 +0000 | [diff] [blame] | 526 | SetPixelIndex(image,index,q); |
cristy | ed23157 | 2011-07-14 02:18:59 +0000 | [diff] [blame] | 527 | q+=GetPixelChannels(image); |
cristy | c82a27b | 2011-10-21 01:07:16 +0000 | [diff] [blame] | 528 | index=ConstrainColormapIndex(image,15UL-((*p) & 0x0f),exception); |
cristy | 4c08aed | 2011-07-01 19:47:50 +0000 | [diff] [blame] | 529 | SetPixelIndex(image,index,q); |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 530 | p++; |
cristy | ed23157 | 2011-07-14 02:18:59 +0000 | [diff] [blame] | 531 | q+=GetPixelChannels(image); |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 532 | } |
| 533 | if (SyncAuthenticPixels(image,exception) == MagickFalse) |
| 534 | break; |
cristy | cee9711 | 2010-05-28 00:44:52 +0000 | [diff] [blame] | 535 | status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y, |
cristy | aff6d80 | 2011-04-26 01:46:31 +0000 | [diff] [blame] | 536 | image->rows); |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 537 | if (status == MagickFalse) |
| 538 | break; |
| 539 | } |
cristy | ea1a8aa | 2011-10-20 13:24:06 +0000 | [diff] [blame] | 540 | (void) SyncImage(image,exception); |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 541 | break; |
| 542 | } |
| 543 | default: |
| 544 | ThrowReaderException(CorruptImageError,"ImproperImageHeader"); |
| 545 | } |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 546 | pixels=(unsigned char *) RelinquishMagickMemory(pixels); |
| 547 | if (EOFBlob(image) != MagickFalse) |
| 548 | ThrowFileException(exception,CorruptImageError,"UnexpectedEndOfFile", |
| 549 | image->filename); |
cristy | 98cba56 | 2014-11-20 23:46:19 +0000 | [diff] [blame] | 550 | if (pdb_info.number_records > 1) |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 551 | { |
| 552 | char |
| 553 | *comment; |
| 554 | |
| 555 | int |
| 556 | c; |
| 557 | |
| 558 | register char |
| 559 | *p; |
| 560 | |
cristy | bb50337 | 2010-05-27 20:51:26 +0000 | [diff] [blame] | 561 | size_t |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 562 | length; |
| 563 | |
cristy | bb50337 | 2010-05-27 20:51:26 +0000 | [diff] [blame] | 564 | num_pad_bytes = (size_t) (comment_offset - TellBlob( image )); |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 565 | while (num_pad_bytes--) ReadBlobByte( image ); |
| 566 | |
| 567 | /* |
| 568 | Read comment. |
| 569 | */ |
| 570 | c=ReadBlobByte(image); |
cristy | 151b66d | 2015-04-15 10:50:31 +0000 | [diff] [blame] | 571 | length=MagickPathExtent; |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 572 | comment=AcquireString((char *) NULL); |
| 573 | for (p=comment; c != EOF; p++) |
| 574 | { |
cristy | 151b66d | 2015-04-15 10:50:31 +0000 | [diff] [blame] | 575 | if ((size_t) (p-comment+MagickPathExtent) >= length) |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 576 | { |
| 577 | *p='\0'; |
| 578 | length<<=1; |
cristy | 151b66d | 2015-04-15 10:50:31 +0000 | [diff] [blame] | 579 | length+=MagickPathExtent; |
| 580 | comment=(char *) ResizeQuantumMemory(comment,length+MagickPathExtent, |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 581 | sizeof(*comment)); |
| 582 | if (comment == (char *) NULL) |
| 583 | break; |
| 584 | p=comment+strlen(comment); |
| 585 | } |
| 586 | *p=c; |
| 587 | c=ReadBlobByte(image); |
| 588 | } |
| 589 | *p='\0'; |
| 590 | if (comment == (char *) NULL) |
| 591 | ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed"); |
cristy | d15e659 | 2011-10-15 00:13:06 +0000 | [diff] [blame] | 592 | (void) SetImageProperty(image,"comment",comment,exception); |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 593 | comment=DestroyString(comment); |
| 594 | } |
| 595 | (void) CloseBlob(image); |
| 596 | return(GetFirstImageInList(image)); |
| 597 | } |
| 598 | |
| 599 | /* |
| 600 | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| 601 | % % |
| 602 | % % |
| 603 | % % |
| 604 | % R e g i s t e r P D B I m a g e % |
| 605 | % % |
| 606 | % % |
| 607 | % % |
| 608 | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| 609 | % |
| 610 | % RegisterPDBImage() adds properties for the PDB image format to |
| 611 | % the list of supported formats. The properties include the image format |
| 612 | % tag, a method to read and/or write the format, whether the format |
| 613 | % supports the saving of more than one frame to the same file or blob, |
| 614 | % whether the format supports native in-memory I/O, and a brief |
| 615 | % description of the format. |
| 616 | % |
| 617 | % The format of the RegisterPDBImage method is: |
| 618 | % |
cristy | bb50337 | 2010-05-27 20:51:26 +0000 | [diff] [blame] | 619 | % size_t RegisterPDBImage(void) |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 620 | % |
| 621 | */ |
cristy | bb50337 | 2010-05-27 20:51:26 +0000 | [diff] [blame] | 622 | ModuleExport size_t RegisterPDBImage(void) |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 623 | { |
| 624 | MagickInfo |
| 625 | *entry; |
| 626 | |
dirk | 06b627a | 2015-04-06 18:59:17 +0000 | [diff] [blame] | 627 | entry=AcquireMagickInfo("PDB","PDB","Palm Database ImageViewer Format"); |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 628 | entry->decoder=(DecodeImageHandler *) ReadPDBImage; |
| 629 | entry->encoder=(EncodeImageHandler *) WritePDBImage; |
| 630 | entry->magick=(IsImageFormatHandler *) IsPDB; |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 631 | (void) RegisterMagickInfo(entry); |
| 632 | return(MagickImageCoderSignature); |
| 633 | } |
| 634 | |
| 635 | /* |
| 636 | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| 637 | % % |
| 638 | % % |
| 639 | % % |
| 640 | % U n r e g i s t e r P D B I m a g e % |
| 641 | % % |
| 642 | % % |
| 643 | % % |
| 644 | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| 645 | % |
| 646 | % UnregisterPDBImage() removes format registrations made by the |
| 647 | % PDB module from the list of supported formats. |
| 648 | % |
| 649 | % The format of the UnregisterPDBImage method is: |
| 650 | % |
| 651 | % UnregisterPDBImage(void) |
| 652 | % |
| 653 | */ |
| 654 | ModuleExport void UnregisterPDBImage(void) |
| 655 | { |
| 656 | (void) UnregisterMagickInfo("PDB"); |
| 657 | } |
| 658 | |
| 659 | /* |
| 660 | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| 661 | % % |
| 662 | % % |
| 663 | % % |
| 664 | % W r i t e P D B I m a g e % |
| 665 | % % |
| 666 | % % |
| 667 | % % |
| 668 | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| 669 | % |
| 670 | % WritePDBImage() writes an image |
| 671 | % |
| 672 | % The format of the WritePDBImage method is: |
| 673 | % |
cristy | 1e178e7 | 2011-08-28 19:44:34 +0000 | [diff] [blame] | 674 | % MagickBooleanType WritePDBImage(const ImageInfo *image_info, |
| 675 | % Image *image,ExceptionInfo *exception) |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 676 | % |
| 677 | % A description of each parameter follows. |
| 678 | % |
| 679 | % o image_info: the image info. |
| 680 | % |
| 681 | % o image: The image. |
| 682 | % |
cristy | 1e178e7 | 2011-08-28 19:44:34 +0000 | [diff] [blame] | 683 | % o exception: return any errors or warnings in this structure. |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 684 | % |
| 685 | */ |
| 686 | |
| 687 | static unsigned char *EncodeRLE(unsigned char *destination, |
cristy | bb50337 | 2010-05-27 20:51:26 +0000 | [diff] [blame] | 688 | unsigned char *source,size_t literal,size_t repeat) |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 689 | { |
| 690 | if (literal > 0) |
| 691 | *destination++=(unsigned char) (literal-1); |
| 692 | (void) CopyMagickMemory(destination,source,literal); |
| 693 | destination+=literal; |
| 694 | if (repeat > 0) |
| 695 | { |
| 696 | *destination++=(unsigned char) (0x80 | (repeat-1)); |
| 697 | *destination++=source[literal]; |
| 698 | } |
| 699 | return(destination); |
| 700 | } |
| 701 | |
cristy | 1e178e7 | 2011-08-28 19:44:34 +0000 | [diff] [blame] | 702 | static MagickBooleanType WritePDBImage(const ImageInfo *image_info,Image *image, |
| 703 | ExceptionInfo *exception) |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 704 | { |
| 705 | const char |
| 706 | *comment; |
| 707 | |
| 708 | int |
| 709 | bits; |
| 710 | |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 711 | MagickBooleanType |
| 712 | status; |
| 713 | |
| 714 | PDBImage |
| 715 | pdb_image; |
| 716 | |
| 717 | PDBInfo |
| 718 | pdb_info; |
| 719 | |
| 720 | QuantumInfo |
| 721 | *quantum_info; |
| 722 | |
cristy | 4c08aed | 2011-07-01 19:47:50 +0000 | [diff] [blame] | 723 | register const Quantum |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 724 | *p; |
| 725 | |
cristy | bb50337 | 2010-05-27 20:51:26 +0000 | [diff] [blame] | 726 | register ssize_t |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 727 | x; |
| 728 | |
| 729 | register unsigned char |
| 730 | *q; |
| 731 | |
| 732 | size_t |
cristy | aff6d80 | 2011-04-26 01:46:31 +0000 | [diff] [blame] | 733 | bits_per_pixel, |
| 734 | literal, |
| 735 | packets, |
| 736 | packet_size, |
| 737 | repeat; |
| 738 | |
| 739 | ssize_t |
| 740 | y; |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 741 | |
| 742 | unsigned char |
| 743 | *buffer, |
| 744 | *runlength, |
| 745 | *scanline; |
| 746 | |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 747 | /* |
| 748 | Open output image file. |
| 749 | */ |
| 750 | assert(image_info != (const ImageInfo *) NULL); |
cristy | e1c94d9 | 2015-06-28 12:16:33 +0000 | [diff] [blame] | 751 | assert(image_info->signature == MagickCoreSignature); |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 752 | assert(image != (Image *) NULL); |
cristy | e1c94d9 | 2015-06-28 12:16:33 +0000 | [diff] [blame] | 753 | assert(image->signature == MagickCoreSignature); |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 754 | if (image->debug != MagickFalse) |
| 755 | (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename); |
cristy | 3a37efd | 2011-08-28 20:31:03 +0000 | [diff] [blame] | 756 | assert(exception != (ExceptionInfo *) NULL); |
cristy | e1c94d9 | 2015-06-28 12:16:33 +0000 | [diff] [blame] | 757 | assert(exception->signature == MagickCoreSignature); |
cristy | 1e178e7 | 2011-08-28 19:44:34 +0000 | [diff] [blame] | 758 | status=OpenBlob(image_info,image,WriteBinaryBlobMode,exception); |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 759 | if (status == MagickFalse) |
| 760 | return(status); |
cristy | af8d391 | 2014-02-21 14:50:33 +0000 | [diff] [blame] | 761 | (void) TransformImageColorspace(image,sRGBColorspace,exception); |
dirk | ab4f0bb | 2015-07-25 11:46:32 +0000 | [diff] [blame] | 762 | if (SetImageMonochrome(image,exception) != MagickFalse) { |
cristy | 98cba56 | 2014-11-20 23:46:19 +0000 | [diff] [blame] | 763 | bits_per_pixel=1; |
| 764 | } else if (image->colors <= 4) { |
| 765 | bits_per_pixel=2; |
| 766 | } else if (image->colors <= 8) { |
| 767 | bits_per_pixel=3; |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 768 | } else { |
cristy | 98cba56 | 2014-11-20 23:46:19 +0000 | [diff] [blame] | 769 | bits_per_pixel=4; |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 770 | } |
cristy | 7243780 | 2015-03-23 00:42:27 +0000 | [diff] [blame] | 771 | (void) ResetMagickMemory(&pdb_info,0,sizeof(pdb_info)); |
cristy | ca793d7 | 2015-01-23 13:03:55 +0000 | [diff] [blame] | 772 | (void) CopyMagickString(pdb_info.name,image_info->filename, |
| 773 | sizeof(pdb_info.name)); |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 774 | pdb_info.attributes=0; |
| 775 | pdb_info.version=0; |
| 776 | pdb_info.create_time=time(NULL); |
| 777 | pdb_info.modify_time=pdb_info.create_time; |
| 778 | pdb_info.archive_time=0; |
| 779 | pdb_info.modify_number=0; |
| 780 | pdb_info.application_info=0; |
| 781 | pdb_info.sort_info=0; |
| 782 | (void) CopyMagickMemory(pdb_info.type,"vIMG",4); |
| 783 | (void) CopyMagickMemory(pdb_info.id,"View",4); |
| 784 | pdb_info.seed=0; |
| 785 | pdb_info.next_record=0; |
cristy | d15e659 | 2011-10-15 00:13:06 +0000 | [diff] [blame] | 786 | comment=GetImageProperty(image,"comment",exception); |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 787 | pdb_info.number_records=(comment == (const char *) NULL ? 1 : 2); |
cristy | ca793d7 | 2015-01-23 13:03:55 +0000 | [diff] [blame] | 788 | (void) WriteBlob(image,sizeof(pdb_info.name),(unsigned char *) pdb_info.name); |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 789 | (void) WriteBlobMSBShort(image,(unsigned short) pdb_info.attributes); |
| 790 | (void) WriteBlobMSBShort(image,(unsigned short) pdb_info.version); |
cristy | eaedf06 | 2010-05-29 22:36:02 +0000 | [diff] [blame] | 791 | (void) WriteBlobMSBLong(image,(unsigned int) pdb_info.create_time); |
| 792 | (void) WriteBlobMSBLong(image,(unsigned int) pdb_info.modify_time); |
| 793 | (void) WriteBlobMSBLong(image,(unsigned int) pdb_info.archive_time); |
| 794 | (void) WriteBlobMSBLong(image,(unsigned int) pdb_info.modify_number); |
| 795 | (void) WriteBlobMSBLong(image,(unsigned int) pdb_info.application_info); |
| 796 | (void) WriteBlobMSBLong(image,(unsigned int) pdb_info.sort_info); |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 797 | (void) WriteBlob(image,4,(unsigned char *) pdb_info.type); |
| 798 | (void) WriteBlob(image,4,(unsigned char *) pdb_info.id); |
cristy | eaedf06 | 2010-05-29 22:36:02 +0000 | [diff] [blame] | 799 | (void) WriteBlobMSBLong(image,(unsigned int) pdb_info.seed); |
| 800 | (void) WriteBlobMSBLong(image,(unsigned int) pdb_info.next_record); |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 801 | (void) WriteBlobMSBShort(image,(unsigned short) pdb_info.number_records); |
cristy | ca793d7 | 2015-01-23 13:03:55 +0000 | [diff] [blame] | 802 | (void) CopyMagickString(pdb_image.name,pdb_info.name,sizeof(pdb_image.name)); |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 803 | pdb_image.version=1; /* RLE Compressed */ |
| 804 | switch (bits_per_pixel) |
| 805 | { |
dirk | 93b02b7 | 2013-11-16 16:03:36 +0000 | [diff] [blame] | 806 | case 1: pdb_image.type=(unsigned char) 0xff; break; /* monochrome */ |
| 807 | case 2: pdb_image.type=(unsigned char) 0x00; break; /* 2 bit gray */ |
| 808 | default: pdb_image.type=(unsigned char) 0x02; /* 4 bit gray */ |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 809 | } |
| 810 | pdb_image.reserved_1=0; |
| 811 | pdb_image.note=0; |
| 812 | pdb_image.x_last=0; |
| 813 | pdb_image.y_last=0; |
| 814 | pdb_image.reserved_2=0; |
dirk | 93b02b7 | 2013-11-16 16:03:36 +0000 | [diff] [blame] | 815 | pdb_image.x_anchor=(unsigned short) 0xffff; |
| 816 | pdb_image.y_anchor=(unsigned short) 0xffff; |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 817 | pdb_image.width=(short) image->columns; |
| 818 | if (image->columns % 16) |
| 819 | pdb_image.width=(short) (16*(image->columns/16+1)); |
| 820 | pdb_image.height=(short) image->rows; |
cristy | 7e5d1da | 2014-12-28 00:40:02 +0000 | [diff] [blame] | 821 | packets=((bits_per_pixel*image->columns+7)/8); |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 822 | runlength=(unsigned char *) AcquireQuantumMemory(2UL*packets, |
cristy | 7e5d1da | 2014-12-28 00:40:02 +0000 | [diff] [blame] | 823 | image->rows*sizeof(*runlength)); |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 824 | if (runlength == (unsigned char *) NULL) |
| 825 | ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed"); |
| 826 | buffer=(unsigned char *) AcquireQuantumMemory(256UL,sizeof(*buffer)); |
| 827 | if (buffer == (unsigned char *) NULL) |
| 828 | ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed"); |
| 829 | packet_size=(size_t) (image->depth > 8 ? 2: 1); |
| 830 | scanline=(unsigned char *) AcquireQuantumMemory(image->columns,packet_size* |
| 831 | sizeof(*scanline)); |
| 832 | if (scanline == (unsigned char *) NULL) |
| 833 | ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed"); |
cristy | 3d9f5ba | 2012-06-26 13:37:31 +0000 | [diff] [blame] | 834 | if (IssRGBCompatibleColorspace(image->colorspace) == MagickFalse) |
cristy | 8d95109 | 2012-02-08 18:54:56 +0000 | [diff] [blame] | 835 | (void) TransformImageColorspace(image,sRGBColorspace,exception); |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 836 | /* |
| 837 | Convert to GRAY raster scanline. |
| 838 | */ |
cristy | 5f766ef | 2014-12-14 21:12:47 +0000 | [diff] [blame] | 839 | quantum_info=AcquireQuantumInfo(image_info,image); |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 840 | if (quantum_info == (QuantumInfo *) NULL) |
| 841 | ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed"); |
cristy | f9cca6a | 2010-06-04 23:49:28 +0000 | [diff] [blame] | 842 | bits=8/(int) bits_per_pixel-1; /* start at most significant bits */ |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 843 | literal=0; |
| 844 | repeat=0; |
| 845 | q=runlength; |
| 846 | buffer[0]=0x00; |
cristy | bb50337 | 2010-05-27 20:51:26 +0000 | [diff] [blame] | 847 | for (y=0; y < (ssize_t) image->rows; y++) |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 848 | { |
cristy | 1e178e7 | 2011-08-28 19:44:34 +0000 | [diff] [blame] | 849 | p=GetVirtualPixels(image,0,y,image->columns,1,exception); |
cristy | 4c08aed | 2011-07-01 19:47:50 +0000 | [diff] [blame] | 850 | if (p == (const Quantum *) NULL) |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 851 | break; |
cristy | 4c08aed | 2011-07-01 19:47:50 +0000 | [diff] [blame] | 852 | (void) ExportQuantumPixels(image,(CacheView *) NULL,quantum_info, |
cristy | 1e178e7 | 2011-08-28 19:44:34 +0000 | [diff] [blame] | 853 | GrayQuantum,scanline,exception); |
cristy | 98cba56 | 2014-11-20 23:46:19 +0000 | [diff] [blame] | 854 | for (x=0; x < (ssize_t) pdb_image.width; x++) |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 855 | { |
cristy | bb50337 | 2010-05-27 20:51:26 +0000 | [diff] [blame] | 856 | if (x < (ssize_t) image->columns) |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 857 | buffer[literal+repeat]|=(0xff-scanline[x*packet_size]) >> |
| 858 | (8-bits_per_pixel) << bits*bits_per_pixel; |
| 859 | bits--; |
| 860 | if (bits < 0) |
| 861 | { |
| 862 | if (((literal+repeat) > 0) && |
| 863 | (buffer[literal+repeat] == buffer[literal+repeat-1])) |
| 864 | { |
| 865 | if (repeat == 0) |
| 866 | { |
| 867 | literal--; |
| 868 | repeat++; |
| 869 | } |
| 870 | repeat++; |
| 871 | if (0x7f < repeat) |
| 872 | { |
| 873 | q=EncodeRLE(q,buffer,literal,repeat); |
| 874 | literal=0; |
| 875 | repeat=0; |
| 876 | } |
| 877 | } |
| 878 | else |
| 879 | { |
| 880 | if (repeat >= 2) |
| 881 | literal+=repeat; |
| 882 | else |
| 883 | { |
| 884 | q=EncodeRLE(q,buffer,literal,repeat); |
| 885 | buffer[0]=buffer[literal+repeat]; |
| 886 | literal=0; |
| 887 | } |
| 888 | literal++; |
| 889 | repeat=0; |
| 890 | if (0x7f < literal) |
| 891 | { |
| 892 | q=EncodeRLE(q,buffer,(literal < 0x80 ? literal : 0x80),0); |
| 893 | (void) CopyMagickMemory(buffer,buffer+literal+repeat,0x80); |
| 894 | literal-=0x80; |
| 895 | } |
| 896 | } |
cristy | f9cca6a | 2010-06-04 23:49:28 +0000 | [diff] [blame] | 897 | bits=8/(int) bits_per_pixel-1; |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 898 | buffer[literal+repeat]=0x00; |
| 899 | } |
| 900 | } |
cristy | cee9711 | 2010-05-28 00:44:52 +0000 | [diff] [blame] | 901 | status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y, |
cristy | 98cba56 | 2014-11-20 23:46:19 +0000 | [diff] [blame] | 902 | image->rows); |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 903 | if (status == MagickFalse) |
| 904 | break; |
| 905 | } |
| 906 | q=EncodeRLE(q,buffer,literal,repeat); |
| 907 | scanline=(unsigned char *) RelinquishMagickMemory(scanline); |
| 908 | buffer=(unsigned char *) RelinquishMagickMemory(buffer); |
| 909 | quantum_info=DestroyQuantumInfo(quantum_info); |
| 910 | /* |
| 911 | Write the Image record header. |
| 912 | */ |
cristy | f6fe0a1 | 2010-05-30 00:44:47 +0000 | [diff] [blame] | 913 | (void) WriteBlobMSBLong(image,(unsigned int) |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 914 | (TellBlob(image)+8*pdb_info.number_records)); |
| 915 | (void) WriteBlobByte(image,0x40); |
| 916 | (void) WriteBlobByte(image,0x6f); |
| 917 | (void) WriteBlobByte(image,0x80); |
| 918 | (void) WriteBlobByte(image,0); |
| 919 | if (pdb_info.number_records > 1) |
| 920 | { |
| 921 | /* |
| 922 | Write the comment record header. |
| 923 | */ |
cristy | f6fe0a1 | 2010-05-30 00:44:47 +0000 | [diff] [blame] | 924 | (void) WriteBlobMSBLong(image,(unsigned int) (TellBlob(image)+8+58+q- |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 925 | runlength)); |
| 926 | (void) WriteBlobByte(image,0x40); |
| 927 | (void) WriteBlobByte(image,0x6f); |
| 928 | (void) WriteBlobByte(image,0x80); |
| 929 | (void) WriteBlobByte(image,1); |
| 930 | } |
| 931 | /* |
| 932 | Write the Image data. |
| 933 | */ |
cristy | ca793d7 | 2015-01-23 13:03:55 +0000 | [diff] [blame] | 934 | (void) WriteBlob(image,sizeof(pdb_image.name),(unsigned char *) |
| 935 | pdb_image.name); |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 936 | (void) WriteBlobByte(image,(unsigned char) pdb_image.version); |
dirk | 93b02b7 | 2013-11-16 16:03:36 +0000 | [diff] [blame] | 937 | (void) WriteBlobByte(image,pdb_image.type); |
cristy | eaedf06 | 2010-05-29 22:36:02 +0000 | [diff] [blame] | 938 | (void) WriteBlobMSBLong(image,(unsigned int) pdb_image.reserved_1); |
| 939 | (void) WriteBlobMSBLong(image,(unsigned int) pdb_image.note); |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 940 | (void) WriteBlobMSBShort(image,(unsigned short) pdb_image.x_last); |
| 941 | (void) WriteBlobMSBShort(image,(unsigned short) pdb_image.y_last); |
cristy | eaedf06 | 2010-05-29 22:36:02 +0000 | [diff] [blame] | 942 | (void) WriteBlobMSBLong(image,(unsigned int) pdb_image.reserved_2); |
dirk | 93b02b7 | 2013-11-16 16:03:36 +0000 | [diff] [blame] | 943 | (void) WriteBlobMSBShort(image,pdb_image.x_anchor); |
| 944 | (void) WriteBlobMSBShort(image,pdb_image.y_anchor); |
cristy | 3ed852e | 2009-09-05 21:47:34 +0000 | [diff] [blame] | 945 | (void) WriteBlobMSBShort(image,(unsigned short) pdb_image.width); |
| 946 | (void) WriteBlobMSBShort(image,(unsigned short) pdb_image.height); |
| 947 | (void) WriteBlob(image,(size_t) (q-runlength),runlength); |
| 948 | runlength=(unsigned char *) RelinquishMagickMemory(runlength); |
| 949 | if (pdb_info.number_records > 1) |
| 950 | (void) WriteBlobString(image,comment); |
| 951 | (void) CloseBlob(image); |
| 952 | return(MagickTrue); |
| 953 | } |