1 /* 2 * Raster file routines for CUPS. 3 * 4 * Copyright 2007-2016 by Apple Inc. 5 * Copyright 1997-2006 by Easy Software Products. 6 * 7 * This file is part of the CUPS Imaging library. 8 * 9 * These coded instructions, statements, and computer programs are the 10 * property of Apple Inc. and are protected by Federal copyright 11 * law. Distribution and use rights are outlined in the file "LICENSE.txt" 12 * which should have been included with this file. If this file is 13 * missing or damaged, see the license at "http://www.cups.org/". 14 * 15 * This file is subject to the Apple OS-Developed Software exception. 16 */ 17 18 /* 19 * Include necessary headers... 20 */ 21 22 #include <cups/raster-private.h> 23 #ifdef HAVE_STDINT_H 24 # include <stdint.h> 25 #endif /* HAVE_STDINT_H */ 26 27 28 /* 29 * Private structures... 30 */ 31 32 struct _cups_raster_s /**** Raster stream data ****/ 33 { 34 unsigned sync; /* Sync word from start of stream */ 35 void *ctx; /* File descriptor */ 36 cups_raster_iocb_t iocb; /* IO callback */ 37 cups_mode_t mode; /* Read/write mode */ 38 cups_page_header2_t header; /* Raster header for current page */ 39 unsigned rowheight, /* Row height in lines */ 40 count, /* Current row run-length count */ 41 remaining, /* Remaining rows in page image */ 42 bpp; /* Bytes per pixel/color */ 43 unsigned char *pixels, /* Pixels for current row */ 44 *pend, /* End of pixel buffer */ 45 *pcurrent; /* Current byte in pixel buffer */ 46 int compressed, /* Non-zero if data is compressed */ 47 swapped; /* Non-zero if data is byte-swapped */ 48 unsigned char *buffer, /* Read/write buffer */ 49 *bufptr, /* Current (read) position in buffer */ 50 *bufend; /* End of current (read) buffer */ 51 size_t bufsize; /* Buffer size */ 52 #ifdef DEBUG 53 size_t iocount; /* Number of bytes read/written */ 54 #endif /* DEBUG */ 55 unsigned apple_page_count;/* Apple raster page count */ 56 }; 57 58 59 /* 60 * Local functions... 61 */ 62 63 static ssize_t cups_raster_io(cups_raster_t *r, unsigned char *buf, size_t bytes); 64 static unsigned cups_raster_read_header(cups_raster_t *r); 65 static ssize_t cups_raster_read(cups_raster_t *r, unsigned char *buf, 66 size_t bytes); 67 static int cups_raster_update(cups_raster_t *r); 68 static ssize_t cups_raster_write(cups_raster_t *r, 69 const unsigned char *pixels); 70 static ssize_t cups_read_fd(void *ctx, unsigned char *buf, size_t bytes); 71 static void cups_swap(unsigned char *buf, size_t bytes); 72 static ssize_t cups_write_fd(void *ctx, unsigned char *buf, size_t bytes); 73 74 75 /* 76 * 'cupsRasterClose()' - Close a raster stream. 77 * 78 * The file descriptor associated with the raster stream must be closed 79 * separately as needed. 80 */ 81 82 void 83 cupsRasterClose(cups_raster_t *r) /* I - Stream to close */ 84 { 85 if (r != NULL) 86 { 87 if (r->buffer) 88 free(r->buffer); 89 90 if (r->pixels) 91 free(r->pixels); 92 93 free(r); 94 } 95 } 96 97 98 /* 99 * 'cupsRasterInitPWGHeader()' - Initialize a page header for PWG Raster output. 100 * 101 * The "media" argument specifies the media to use. 102 * 103 * The "type" argument specifies a "pwg-raster-document-type-supported" value 104 * that controls the color space and bit depth of the raster data. 105 * 106 * The "xres" and "yres" arguments specify the raster resolution in dots per 107 * inch. 108 * 109 * The "sheet_back" argument specifies a "pwg-raster-document-sheet-back" value 110 * to apply for the back side of a page. Pass @code NULL@ for the front side. 111 * 112 * @since CUPS 2.2/macOS 10.12@ 113 */ 114 115 int /* O - 1 on success, 0 on failure */ 116 cupsRasterInitPWGHeader( 117 cups_page_header2_t *h, /* I - Page header */ 118 pwg_media_t *media, /* I - PWG media information */ 119 const char *type, /* I - PWG raster type string */ 120 int xdpi, /* I - Cross-feed direction (horizontal) resolution */ 121 int ydpi, /* I - Feed direction (vertical) resolution */ 122 const char *sides, /* I - IPP "sides" option value */ 123 const char *sheet_back) /* I - Transform for back side or @code NULL@ for none */ 124 { 125 if (!h || !media || !type || xdpi <= 0 || ydpi <= 0) 126 { 127 _cupsRasterAddError("%s", strerror(EINVAL)); 128 return (0); 129 } 130 131 /* 132 * Initialize the page header... 133 */ 134 135 memset(h, 0, sizeof(cups_page_header2_t)); 136 137 strlcpy(h->cupsPageSizeName, media->pwg, sizeof(h->cupsPageSizeName)); 138 139 h->PageSize[0] = (unsigned)(72 * media->width / 2540); 140 h->PageSize[1] = (unsigned)(72 * media->length / 2540); 141 142 /* This never gets written but is needed for some applications */ 143 h->cupsPageSize[0] = 72.0f * media->width / 2540.0f; 144 h->cupsPageSize[1] = 72.0f * media->length / 2540.0f; 145 146 h->ImagingBoundingBox[2] = h->PageSize[0]; 147 h->ImagingBoundingBox[3] = h->PageSize[1]; 148 149 h->HWResolution[0] = (unsigned)xdpi; 150 h->HWResolution[1] = (unsigned)ydpi; 151 152 h->cupsWidth = (unsigned)(media->width * xdpi / 2540); 153 h->cupsHeight = (unsigned)(media->length * ydpi / 2540); 154 155 if (h->cupsWidth > 0x00ffffff || h->cupsHeight > 0x00ffffff) 156 { 157 _cupsRasterAddError("Raster dimensions too large."); 158 return (0); 159 } 160 161 h->cupsInteger[CUPS_RASTER_PWG_ImageBoxRight] = h->cupsWidth; 162 h->cupsInteger[CUPS_RASTER_PWG_ImageBoxBottom] = h->cupsHeight; 163 164 /* 165 * Colorspace and bytes per line... 166 */ 167 168 if (!strcmp(type, "adobe-rgb_8")) 169 { 170 h->cupsBitsPerColor = 8; 171 h->cupsBitsPerPixel = 24; 172 h->cupsColorSpace = CUPS_CSPACE_ADOBERGB; 173 } 174 else if (!strcmp(type, "adobe-rgb_16")) 175 { 176 h->cupsBitsPerColor = 16; 177 h->cupsBitsPerPixel = 48; 178 h->cupsColorSpace = CUPS_CSPACE_ADOBERGB; 179 } 180 else if (!strcmp(type, "black_1")) 181 { 182 h->cupsBitsPerColor = 1; 183 h->cupsBitsPerPixel = 1; 184 h->cupsColorSpace = CUPS_CSPACE_K; 185 } 186 else if (!strcmp(type, "black_8")) 187 { 188 h->cupsBitsPerColor = 8; 189 h->cupsBitsPerPixel = 8; 190 h->cupsColorSpace = CUPS_CSPACE_K; 191 } 192 else if (!strcmp(type, "black_16")) 193 { 194 h->cupsBitsPerColor = 16; 195 h->cupsBitsPerPixel = 16; 196 h->cupsColorSpace = CUPS_CSPACE_K; 197 } 198 else if (!strcmp(type, "cmyk_8")) 199 { 200 h->cupsBitsPerColor = 8; 201 h->cupsBitsPerPixel = 32; 202 h->cupsColorSpace = CUPS_CSPACE_CMYK; 203 } 204 else if (!strcmp(type, "cmyk_16")) 205 { 206 h->cupsBitsPerColor = 16; 207 h->cupsBitsPerPixel = 64; 208 h->cupsColorSpace = CUPS_CSPACE_CMYK; 209 } 210 else if (!strncmp(type, "device", 6) && type[6] >= '1' && type[6] <= '9') 211 { 212 int ncolors, bits; /* Number of colors and bits */ 213 214 215 if (sscanf(type, "device%d_%d", &ncolors, &bits) != 2 || ncolors > 15 || (bits != 8 && bits != 16)) 216 { 217 _cupsRasterAddError("Unsupported raster type \'%s\'.", type); 218 return (0); 219 } 220 221 h->cupsBitsPerColor = (unsigned)bits; 222 h->cupsBitsPerPixel = (unsigned)(ncolors * bits); 223 h->cupsColorSpace = (cups_cspace_t)(CUPS_CSPACE_DEVICE1 + ncolors - 1); 224 } 225 else if (!strcmp(type, "rgb_8")) 226 { 227 h->cupsBitsPerColor = 8; 228 h->cupsBitsPerPixel = 24; 229 h->cupsColorSpace = CUPS_CSPACE_RGB; 230 } 231 else if (!strcmp(type, "rgb_16")) 232 { 233 h->cupsBitsPerColor = 16; 234 h->cupsBitsPerPixel = 48; 235 h->cupsColorSpace = CUPS_CSPACE_RGB; 236 } 237 else if (!strcmp(type, "sgray_1")) 238 { 239 h->cupsBitsPerColor = 1; 240 h->cupsBitsPerPixel = 1; 241 h->cupsColorSpace = CUPS_CSPACE_SW; 242 } 243 else if (!strcmp(type, "sgray_8")) 244 { 245 h->cupsBitsPerColor = 8; 246 h->cupsBitsPerPixel = 8; 247 h->cupsColorSpace = CUPS_CSPACE_SW; 248 } 249 else if (!strcmp(type, "sgray_16")) 250 { 251 h->cupsBitsPerColor = 16; 252 h->cupsBitsPerPixel = 16; 253 h->cupsColorSpace = CUPS_CSPACE_SW; 254 } 255 else if (!strcmp(type, "srgb_8")) 256 { 257 h->cupsBitsPerColor = 8; 258 h->cupsBitsPerPixel = 24; 259 h->cupsColorSpace = CUPS_CSPACE_SRGB; 260 } 261 else if (!strcmp(type, "srgb_16")) 262 { 263 h->cupsBitsPerColor = 16; 264 h->cupsBitsPerPixel = 48; 265 h->cupsColorSpace = CUPS_CSPACE_SRGB; 266 } 267 else 268 { 269 _cupsRasterAddError("Unsupported raster type \'%s\'.", type); 270 return (0); 271 } 272 273 h->cupsColorOrder = CUPS_ORDER_CHUNKED; 274 h->cupsNumColors = h->cupsBitsPerPixel / h->cupsBitsPerColor; 275 h->cupsBytesPerLine = (h->cupsWidth * h->cupsBitsPerPixel + 7) / 8; 276 277 /* 278 * Duplex support... 279 */ 280 281 h->cupsInteger[CUPS_RASTER_PWG_CrossFeedTransform] = 1; 282 h->cupsInteger[CUPS_RASTER_PWG_FeedTransform] = 1; 283 284 if (sides) 285 { 286 if (!strcmp(sides, "two-sided-long-edge")) 287 { 288 h->Duplex = 1; 289 } 290 else if (!strcmp(sides, "two-sided-short-edge")) 291 { 292 h->Duplex = 1; 293 h->Tumble = 1; 294 } 295 else if (strcmp(sides, "one-sided")) 296 { 297 _cupsRasterAddError("Unsupported sides value \'%s\'.", sides); 298 return (0); 299 } 300 301 if (sheet_back) 302 { 303 if (!strcmp(sheet_back, "flipped")) 304 { 305 if (h->Tumble) 306 h->cupsInteger[CUPS_RASTER_PWG_CrossFeedTransform] = 0xffffffffU; 307 else 308 h->cupsInteger[CUPS_RASTER_PWG_FeedTransform] = 0xffffffffU; 309 } 310 else if (!strcmp(sheet_back, "manual-tumble")) 311 { 312 if (h->Tumble) 313 { 314 h->cupsInteger[CUPS_RASTER_PWG_CrossFeedTransform] = 0xffffffffU; 315 h->cupsInteger[CUPS_RASTER_PWG_FeedTransform] = 0xffffffffU; 316 } 317 } 318 else if (!strcmp(sheet_back, "rotated")) 319 { 320 if (!h->Tumble) 321 { 322 h->cupsInteger[CUPS_RASTER_PWG_CrossFeedTransform] = 0xffffffffU; 323 h->cupsInteger[CUPS_RASTER_PWG_FeedTransform] = 0xffffffffU; 324 } 325 } 326 else if (strcmp(sheet_back, "normal")) 327 { 328 _cupsRasterAddError("Unsupported sheet_back value \'%s\'.", sheet_back); 329 return (0); 330 } 331 } 332 } 333 334 return (1); 335 } 336 337 338 /* 339 * 'cupsRasterOpen()' - Open a raster stream using a file descriptor. 340 * 341 * This function associates a raster stream with the given file descriptor. 342 * For most printer driver filters, "fd" will be 0 (stdin). For most raster 343 * image processor (RIP) filters that generate raster data, "fd" will be 1 344 * (stdout). 345 * 346 * When writing raster data, the @code CUPS_RASTER_WRITE@, 347 * @code CUPS_RASTER_WRITE_COMPRESS@, or @code CUPS_RASTER_WRITE_PWG@ mode can 348 * be used - compressed and PWG output is generally 25-50% smaller but adds a 349 * 100-300% execution time overhead. 350 */ 351 352 cups_raster_t * /* O - New stream */ 353 cupsRasterOpen(int fd, /* I - File descriptor */ 354 cups_mode_t mode) /* I - Mode - @code CUPS_RASTER_READ@, 355 @code CUPS_RASTER_WRITE@, 356 @code CUPS_RASTER_WRITE_COMPRESSED@, 357 or @code CUPS_RASTER_WRITE_PWG@ */ 358 { 359 if (mode == CUPS_RASTER_READ) 360 return (cupsRasterOpenIO(cups_read_fd, (void *)((intptr_t)fd), mode)); 361 else 362 return (cupsRasterOpenIO(cups_write_fd, (void *)((intptr_t)fd), mode)); 363 } 364 365 366 /* 367 * 'cupsRasterOpenIO()' - Open a raster stream using a callback function. 368 * 369 * This function associates a raster stream with the given callback function and 370 * context pointer. 371 * 372 * When writing raster data, the @code CUPS_RASTER_WRITE@, 373 * @code CUPS_RASTER_WRITE_COMPRESS@, or @code CUPS_RASTER_WRITE_PWG@ mode can 374 * be used - compressed and PWG output is generally 25-50% smaller but adds a 375 * 100-300% execution time overhead. 376 */ 377 378 cups_raster_t * /* O - New stream */ 379 cupsRasterOpenIO( 380 cups_raster_iocb_t iocb, /* I - Read/write callback */ 381 void *ctx, /* I - Context pointer for callback */ 382 cups_mode_t mode) /* I - Mode - @code CUPS_RASTER_READ@, 383 @code CUPS_RASTER_WRITE@, 384 @code CUPS_RASTER_WRITE_COMPRESSED@, 385 or @code CUPS_RASTER_WRITE_PWG@ */ 386 { 387 cups_raster_t *r; /* New stream */ 388 389 390 _cupsRasterClearError(); 391 392 if ((r = calloc(sizeof(cups_raster_t), 1)) == NULL) 393 { 394 _cupsRasterAddError("Unable to allocate memory for raster stream: %s\n", 395 strerror(errno)); 396 return (NULL); 397 } 398 399 r->ctx = ctx; 400 r->iocb = iocb; 401 r->mode = mode; 402 403 if (mode == CUPS_RASTER_READ) 404 { 405 /* 406 * Open for read - get sync word... 407 */ 408 409 if (cups_raster_io(r, (unsigned char *)&(r->sync), sizeof(r->sync)) != 410 sizeof(r->sync)) 411 { 412 _cupsRasterAddError("Unable to read header from raster stream: %s\n", 413 strerror(errno)); 414 free(r); 415 return (NULL); 416 } 417 418 if (r->sync != CUPS_RASTER_SYNC && 419 r->sync != CUPS_RASTER_REVSYNC && 420 r->sync != CUPS_RASTER_SYNCv1 && 421 r->sync != CUPS_RASTER_REVSYNCv1 && 422 r->sync != CUPS_RASTER_SYNCv2 && 423 r->sync != CUPS_RASTER_REVSYNCv2 && 424 r->sync != CUPS_RASTER_SYNCapple && 425 r->sync != CUPS_RASTER_REVSYNCapple) 426 { 427 _cupsRasterAddError("Unknown raster format %08x!\n", r->sync); 428 free(r); 429 return (NULL); 430 } 431 432 if (r->sync == CUPS_RASTER_SYNCv2 || 433 r->sync == CUPS_RASTER_REVSYNCv2 || 434 r->sync == CUPS_RASTER_SYNCapple || 435 r->sync == CUPS_RASTER_REVSYNCapple) 436 r->compressed = 1; 437 438 if (r->sync == CUPS_RASTER_REVSYNC || 439 r->sync == CUPS_RASTER_REVSYNCv1 || 440 r->sync == CUPS_RASTER_REVSYNCv2 || 441 r->sync == CUPS_RASTER_REVSYNCapple) 442 r->swapped = 1; 443 444 if (r->sync == CUPS_RASTER_SYNCapple || 445 r->sync == CUPS_RASTER_REVSYNCapple) 446 { 447 unsigned char header[8]; /* File header */ 448 449 if (cups_raster_io(r, (unsigned char *)header, sizeof(header)) != 450 sizeof(header)) 451 { 452 _cupsRasterAddError("Unable to read header from raster stream: %s\n", 453 strerror(errno)); 454 free(r); 455 return (NULL); 456 } 457 458 } 459 460 DEBUG_printf(("1cupsRasterOpenIO: r->swapped=%d, r->sync=%08x\n", r->swapped, r->sync)); 461 } 462 else 463 { 464 /* 465 * Open for write - put sync word... 466 */ 467 468 switch (mode) 469 { 470 default : 471 case CUPS_RASTER_WRITE : 472 r->sync = CUPS_RASTER_SYNC; 473 break; 474 475 case CUPS_RASTER_WRITE_COMPRESSED : 476 r->compressed = 1; 477 r->sync = CUPS_RASTER_SYNCv2; 478 break; 479 480 case CUPS_RASTER_WRITE_PWG : 481 r->compressed = 1; 482 r->sync = htonl(CUPS_RASTER_SYNC_PWG); 483 r->swapped = r->sync != CUPS_RASTER_SYNC_PWG; 484 break; 485 486 case CUPS_RASTER_WRITE_APPLE : 487 r->compressed = 1; 488 r->sync = htonl(CUPS_RASTER_SYNCapple); 489 r->swapped = r->sync != CUPS_RASTER_SYNCapple; 490 r->apple_page_count = 0xffffffffU; 491 break; 492 } 493 494 if (cups_raster_io(r, (unsigned char *)&(r->sync), sizeof(r->sync)) < (ssize_t)sizeof(r->sync)) 495 { 496 _cupsRasterAddError("Unable to write raster stream header: %s\n", 497 strerror(errno)); 498 free(r); 499 return (NULL); 500 } 501 } 502 503 return (r); 504 } 505 506 507 /* 508 * 'cupsRasterReadHeader()' - Read a raster page header and store it in a 509 * version 1 page header structure. 510 * 511 * This function is deprecated. Use @link cupsRasterReadHeader2@ instead. 512 * 513 * Version 1 page headers were used in CUPS 1.0 and 1.1 and contain a subset 514 * of the version 2 page header data. This function handles reading version 2 515 * page headers and copying only the version 1 data into the provided buffer. 516 * 517 * @deprecated@ 518 */ 519 520 unsigned /* O - 1 on success, 0 on failure/end-of-file */ 521 cupsRasterReadHeader( 522 cups_raster_t *r, /* I - Raster stream */ 523 cups_page_header_t *h) /* I - Pointer to header data */ 524 { 525 /* 526 * Get the raster header... 527 */ 528 529 if (!cups_raster_read_header(r)) 530 { 531 memset(h, 0, sizeof(cups_page_header_t)); 532 return (0); 533 } 534 535 /* 536 * Copy the header to the user-supplied buffer... 537 */ 538 539 memcpy(h, &(r->header), sizeof(cups_page_header_t)); 540 541 return (1); 542 } 543 544 545 /* 546 * 'cupsRasterReadHeader2()' - Read a raster page header and store it in a 547 * version 2 page header structure. 548 * 549 * @since CUPS 1.2/macOS 10.5@ 550 */ 551 552 unsigned /* O - 1 on success, 0 on failure/end-of-file */ 553 cupsRasterReadHeader2( 554 cups_raster_t *r, /* I - Raster stream */ 555 cups_page_header2_t *h) /* I - Pointer to header data */ 556 { 557 /* 558 * Get the raster header... 559 */ 560 561 DEBUG_printf(("cupsRasterReadHeader2(r=%p, h=%p)", (void *)r, (void *)h)); 562 563 if (!cups_raster_read_header(r)) 564 { 565 memset(h, 0, sizeof(cups_page_header2_t)); 566 return (0); 567 } 568 569 /* 570 * Copy the header to the user-supplied buffer... 571 */ 572 573 memcpy(h, &(r->header), sizeof(cups_page_header2_t)); 574 575 return (1); 576 } 577 578 579 /* 580 * 'cupsRasterReadPixels()' - Read raster pixels. 581 * 582 * For best performance, filters should read one or more whole lines. 583 * The "cupsBytesPerLine" value from the page header can be used to allocate 584 * the line buffer and as the number of bytes to read. 585 */ 586 587 unsigned /* O - Number of bytes read */ 588 cupsRasterReadPixels(cups_raster_t *r, /* I - Raster stream */ 589 unsigned char *p, /* I - Pointer to pixel buffer */ 590 unsigned len) /* I - Number of bytes to read */ 591 { 592 ssize_t bytes; /* Bytes read */ 593 unsigned cupsBytesPerLine; /* cupsBytesPerLine value */ 594 unsigned remaining; /* Bytes remaining */ 595 unsigned char *ptr, /* Pointer to read buffer */ 596 byte, /* Byte from file */ 597 *temp; /* Pointer into buffer */ 598 unsigned count; /* Repetition count */ 599 600 601 DEBUG_printf(("cupsRasterReadPixels(r=%p, p=%p, len=%u)", (void *)r, (void *)p, len)); 602 603 if (r == NULL || r->mode != CUPS_RASTER_READ || r->remaining == 0 || 604 r->header.cupsBytesPerLine == 0) 605 { 606 DEBUG_puts("1cupsRasterReadPixels: Returning 0."); 607 return (0); 608 } 609 610 DEBUG_printf(("1cupsRasterReadPixels: compressed=%d, remaining=%u", r->compressed, r->remaining)); 611 612 if (!r->compressed) 613 { 614 /* 615 * Read without compression... 616 */ 617 618 r->remaining -= len / r->header.cupsBytesPerLine; 619 620 if (cups_raster_io(r, p, len) < (ssize_t)len) 621 { 622 DEBUG_puts("1cupsRasterReadPixels: Read error, returning 0."); 623 return (0); 624 } 625 626 /* 627 * Swap bytes as needed... 628 */ 629 630 if (r->swapped && 631 (r->header.cupsBitsPerColor == 16 || 632 r->header.cupsBitsPerPixel == 12 || 633 r->header.cupsBitsPerPixel == 16)) 634 cups_swap(p, len); 635 636 /* 637 * Return... 638 */ 639 640 DEBUG_printf(("1cupsRasterReadPixels: Returning %u", len)); 641 642 return (len); 643 } 644 645 /* 646 * Read compressed data... 647 */ 648 649 remaining = len; 650 cupsBytesPerLine = r->header.cupsBytesPerLine; 651 652 while (remaining > 0 && r->remaining > 0) 653 { 654 if (r->count == 0) 655 { 656 /* 657 * Need to read a new row... 658 */ 659 660 if (remaining == cupsBytesPerLine) 661 ptr = p; 662 else 663 ptr = r->pixels; 664 665 /* 666 * Read using a modified PackBits compression... 667 */ 668 669 if (!cups_raster_read(r, &byte, 1)) 670 { 671 DEBUG_puts("1cupsRasterReadPixels: Read error, returning 0."); 672 return (0); 673 } 674 675 r->count = (unsigned)byte + 1; 676 677 if (r->count > 1) 678 ptr = r->pixels; 679 680 temp = ptr; 681 bytes = (ssize_t)cupsBytesPerLine; 682 683 while (bytes > 0) 684 { 685 /* 686 * Get a new repeat count... 687 */ 688 689 if (!cups_raster_read(r, &byte, 1)) 690 { 691 DEBUG_puts("1cupsRasterReadPixels: Read error, returning 0."); 692 return (0); 693 } 694 695 if (byte == 128) 696 { 697 /* 698 * Clear to end of line... 699 */ 700 701 switch (r->header.cupsColorSpace) 702 { 703 case CUPS_CSPACE_W : 704 case CUPS_CSPACE_RGB : 705 case CUPS_CSPACE_SW : 706 case CUPS_CSPACE_SRGB : 707 case CUPS_CSPACE_RGBW : 708 case CUPS_CSPACE_ADOBERGB : 709 memset(temp, 0xff, (size_t)bytes); 710 break; 711 default : 712 memset(temp, 0x00, (size_t)bytes); 713 break; 714 } 715 716 temp += bytes; 717 bytes = 0; 718 } 719 else if (byte & 128) 720 { 721 /* 722 * Copy N literal pixels... 723 */ 724 725 count = (unsigned)(257 - byte) * r->bpp; 726 727 if (count > (unsigned)bytes) 728 count = (unsigned)bytes; 729 730 if (!cups_raster_read(r, temp, count)) 731 { 732 DEBUG_puts("1cupsRasterReadPixels: Read error, returning 0."); 733 return (0); 734 } 735 736 temp += count; 737 bytes -= (ssize_t)count; 738 } 739 else 740 { 741 /* 742 * Repeat the next N bytes... 743 */ 744 745 count = ((unsigned)byte + 1) * r->bpp; 746 if (count > (unsigned)bytes) 747 count = (unsigned)bytes; 748 749 if (count < r->bpp) 750 break; 751 752 bytes -= (ssize_t)count; 753 754 if (!cups_raster_read(r, temp, r->bpp)) 755 { 756 DEBUG_puts("1cupsRasterReadPixels: Read error, returning 0."); 757 return (0); 758 } 759 760 temp += r->bpp; 761 count -= r->bpp; 762 763 while (count > 0) 764 { 765 memcpy(temp, temp - r->bpp, r->bpp); 766 temp += r->bpp; 767 count -= r->bpp; 768 } 769 } 770 } 771 772 /* 773 * Swap bytes as needed... 774 */ 775 776 if ((r->header.cupsBitsPerColor == 16 || 777 r->header.cupsBitsPerPixel == 12 || 778 r->header.cupsBitsPerPixel == 16) && 779 r->swapped) 780 cups_swap(ptr, (size_t)bytes); 781 782 /* 783 * Update pointers... 784 */ 785 786 if (remaining >= cupsBytesPerLine) 787 { 788 bytes = (ssize_t)cupsBytesPerLine; 789 r->pcurrent = r->pixels; 790 r->count --; 791 r->remaining --; 792 } 793 else 794 { 795 bytes = (ssize_t)remaining; 796 r->pcurrent = r->pixels + bytes; 797 } 798 799 /* 800 * Copy data as needed... 801 */ 802 803 if (ptr != p) 804 memcpy(p, ptr, (size_t)bytes); 805 } 806 else 807 { 808 /* 809 * Copy fragment from buffer... 810 */ 811 812 if ((unsigned)(bytes = (int)(r->pend - r->pcurrent)) > remaining) 813 bytes = (ssize_t)remaining; 814 815 memcpy(p, r->pcurrent, (size_t)bytes); 816 r->pcurrent += bytes; 817 818 if (r->pcurrent >= r->pend) 819 { 820 r->pcurrent = r->pixels; 821 r->count --; 822 r->remaining --; 823 } 824 } 825 826 remaining -= (unsigned)bytes; 827 p += bytes; 828 } 829 830 DEBUG_printf(("1cupsRasterReadPixels: Returning %u", len)); 831 832 return (len); 833 } 834 835 836 /* 837 * 'cupsRasterWriteHeader()' - Write a raster page header from a version 1 page 838 * header structure. 839 * 840 * This function is deprecated. Use @link cupsRasterWriteHeader2@ instead. 841 * 842 * @deprecated@ 843 */ 844 845 unsigned /* O - 1 on success, 0 on failure */ 846 cupsRasterWriteHeader( 847 cups_raster_t *r, /* I - Raster stream */ 848 cups_page_header_t *h) /* I - Raster page header */ 849 { 850 if (r == NULL || r->mode == CUPS_RASTER_READ) 851 return (0); 852 853 /* 854 * Make a copy of the header, and compute the number of raster 855 * lines in the page image... 856 */ 857 858 memset(&(r->header), 0, sizeof(r->header)); 859 memcpy(&(r->header), h, sizeof(cups_page_header_t)); 860 861 if (!cups_raster_update(r)) 862 return (0); 863 864 /* 865 * Write the raster header... 866 */ 867 868 if (r->mode == CUPS_RASTER_WRITE_PWG) 869 { 870 /* 871 * PWG raster data is always network byte order with much of the page header 872 * zeroed. 873 */ 874 875 cups_page_header2_t fh; /* File page header */ 876 877 memset(&fh, 0, sizeof(fh)); 878 879 strlcpy(fh.MediaClass, "PwgRaster", sizeof(fh.MediaClass)); 880 /* PwgRaster */ 881 strlcpy(fh.MediaColor, r->header.MediaColor, sizeof(fh.MediaColor)); 882 strlcpy(fh.MediaType, r->header.MediaType, sizeof(fh.MediaType)); 883 strlcpy(fh.OutputType, r->header.OutputType, sizeof(fh.OutputType)); 884 /* PrintContentType */ 885 886 fh.CutMedia = htonl(r->header.CutMedia); 887 fh.Duplex = htonl(r->header.Duplex); 888 fh.HWResolution[0] = htonl(r->header.HWResolution[0]); 889 fh.HWResolution[1] = htonl(r->header.HWResolution[1]); 890 fh.ImagingBoundingBox[0] = htonl(r->header.ImagingBoundingBox[0]); 891 fh.ImagingBoundingBox[1] = htonl(r->header.ImagingBoundingBox[1]); 892 fh.ImagingBoundingBox[2] = htonl(r->header.ImagingBoundingBox[2]); 893 fh.ImagingBoundingBox[3] = htonl(r->header.ImagingBoundingBox[3]); 894 fh.InsertSheet = htonl(r->header.InsertSheet); 895 fh.Jog = htonl(r->header.Jog); 896 fh.LeadingEdge = htonl(r->header.LeadingEdge); 897 fh.ManualFeed = htonl(r->header.ManualFeed); 898 fh.MediaPosition = htonl(r->header.MediaPosition); 899 fh.MediaWeight = htonl(r->header.MediaWeight); 900 fh.NumCopies = htonl(r->header.NumCopies); 901 fh.Orientation = htonl(r->header.Orientation); 902 fh.PageSize[0] = htonl(r->header.PageSize[0]); 903 fh.PageSize[1] = htonl(r->header.PageSize[1]); 904 fh.Tumble = htonl(r->header.Tumble); 905 fh.cupsWidth = htonl(r->header.cupsWidth); 906 fh.cupsHeight = htonl(r->header.cupsHeight); 907 fh.cupsBitsPerColor = htonl(r->header.cupsBitsPerColor); 908 fh.cupsBitsPerPixel = htonl(r->header.cupsBitsPerPixel); 909 fh.cupsBytesPerLine = htonl(r->header.cupsBytesPerLine); 910 fh.cupsColorOrder = htonl(r->header.cupsColorOrder); 911 fh.cupsColorSpace = htonl(r->header.cupsColorSpace); 912 fh.cupsNumColors = htonl(r->header.cupsNumColors); 913 fh.cupsInteger[0] = htonl(r->header.cupsInteger[0]); 914 /* TotalPageCount */ 915 fh.cupsInteger[1] = htonl(r->header.cupsInteger[1]); 916 /* CrossFeedTransform */ 917 fh.cupsInteger[2] = htonl(r->header.cupsInteger[2]); 918 /* FeedTransform */ 919 fh.cupsInteger[3] = htonl(r->header.cupsInteger[3]); 920 /* ImageBoxLeft */ 921 fh.cupsInteger[4] = htonl(r->header.cupsInteger[4]); 922 /* ImageBoxTop */ 923 fh.cupsInteger[5] = htonl(r->header.cupsInteger[5]); 924 /* ImageBoxRight */ 925 fh.cupsInteger[6] = htonl(r->header.cupsInteger[6]); 926 /* ImageBoxBottom */ 927 fh.cupsInteger[7] = htonl(r->header.cupsInteger[7]); 928 /* BlackPrimary */ 929 fh.cupsInteger[8] = htonl(r->header.cupsInteger[8]); 930 /* PrintQuality */ 931 fh.cupsInteger[14] = htonl(r->header.cupsInteger[14]); 932 /* VendorIdentifier */ 933 fh.cupsInteger[15] = htonl(r->header.cupsInteger[15]); 934 /* VendorLength */ 935 936 void *dst = fh.cupsReal; /* Bypass bogus compiler warning */ 937 void *src = r->header.cupsReal; 938 memcpy(dst, src, sizeof(fh.cupsReal) + sizeof(fh.cupsString)); 939 /* VendorData */ 940 941 strlcpy(fh.cupsRenderingIntent, r->header.cupsRenderingIntent, 942 sizeof(fh.cupsRenderingIntent)); 943 strlcpy(fh.cupsPageSizeName, r->header.cupsPageSizeName, 944 sizeof(fh.cupsPageSizeName)); 945 946 return (cups_raster_io(r, (unsigned char *)&fh, sizeof(fh)) == sizeof(fh)); 947 } 948 else if (r->mode == CUPS_RASTER_WRITE_APPLE) 949 { 950 /* 951 * Raw raster data is always network byte order with most of the page header 952 * zeroed. 953 */ 954 955 unsigned char appleheader[32]; /* Raw page header */ 956 957 if (r->apple_page_count == 0xffffffffU) 958 { 959 /* 960 * Write raw page count from raster page header... 961 */ 962 963 r->apple_page_count = r->header.cupsInteger[0]; 964 965 appleheader[0] = 'A'; 966 appleheader[1] = 'S'; 967 appleheader[2] = 'T'; 968 appleheader[3] = 0; 969 appleheader[4] = (unsigned char)(r->apple_page_count >> 24); 970 appleheader[5] = (unsigned char)(r->apple_page_count >> 16); 971 appleheader[6] = (unsigned char)(r->apple_page_count >> 8); 972 appleheader[7] = (unsigned char)(r->apple_page_count); 973 974 if (cups_raster_io(r, appleheader, 8) != 8) 975 return (0); 976 } 977 978 memset(appleheader, 0, sizeof(appleheader)); 979 980 appleheader[0] = (unsigned char)r->header.cupsBitsPerPixel; 981 appleheader[1] = r->header.cupsColorSpace == CUPS_CSPACE_SRGB ? 1 : 982 r->header.cupsColorSpace == CUPS_CSPACE_RGBW ? 2 : 983 r->header.cupsColorSpace == CUPS_CSPACE_ADOBERGB ? 3 : 984 r->header.cupsColorSpace == CUPS_CSPACE_W ? 4 : 985 r->header.cupsColorSpace == CUPS_CSPACE_RGB ? 5 : 986 r->header.cupsColorSpace == CUPS_CSPACE_CMYK ? 6 : 0; 987 appleheader[12] = (unsigned char)(r->header.cupsWidth >> 24); 988 appleheader[13] = (unsigned char)(r->header.cupsWidth >> 16); 989 appleheader[14] = (unsigned char)(r->header.cupsWidth >> 8); 990 appleheader[15] = (unsigned char)(r->header.cupsWidth); 991 appleheader[16] = (unsigned char)(r->header.cupsHeight >> 24); 992 appleheader[17] = (unsigned char)(r->header.cupsHeight >> 16); 993 appleheader[18] = (unsigned char)(r->header.cupsHeight >> 8); 994 appleheader[19] = (unsigned char)(r->header.cupsHeight); 995 appleheader[20] = (unsigned char)(r->header.HWResolution[0] >> 24); 996 appleheader[21] = (unsigned char)(r->header.HWResolution[0] >> 16); 997 appleheader[22] = (unsigned char)(r->header.HWResolution[0] >> 8); 998 appleheader[23] = (unsigned char)(r->header.HWResolution[0]); 999 1000 return (cups_raster_io(r, appleheader, sizeof(appleheader)) == sizeof(appleheader)); 1001 } 1002 else 1003 return (cups_raster_io(r, (unsigned char *)&(r->header), sizeof(r->header)) 1004 == sizeof(r->header)); 1005 } 1006 1007 1008 /* 1009 * 'cupsRasterWriteHeader2()' - Write a raster page header from a version 2 1010 * page header structure. 1011 * 1012 * The page header can be initialized using @link cupsRasterInitPWGHeader@. 1013 * 1014 * @since CUPS 1.2/macOS 10.5@ 1015 */ 1016 1017 unsigned /* O - 1 on success, 0 on failure */ 1018 cupsRasterWriteHeader2( 1019 cups_raster_t *r, /* I - Raster stream */ 1020 cups_page_header2_t *h) /* I - Raster page header */ 1021 { 1022 if (r == NULL || r->mode == CUPS_RASTER_READ) 1023 return (0); 1024 1025 /* 1026 * Make a copy of the header, and compute the number of raster 1027 * lines in the page image... 1028 */ 1029 1030 memcpy(&(r->header), h, sizeof(cups_page_header2_t)); 1031 1032 if (!cups_raster_update(r)) 1033 return (0); 1034 1035 if (r->mode == CUPS_RASTER_WRITE_APPLE) 1036 { 1037 r->rowheight = h->HWResolution[0] / h->HWResolution[1]; 1038 1039 if (h->HWResolution[0] != (r->rowheight * h->HWResolution[1])) 1040 return (0); 1041 } 1042 else 1043 r->rowheight = 1; 1044 1045 /* 1046 * Write the raster header... 1047 */ 1048 1049 if (r->mode == CUPS_RASTER_WRITE_PWG) 1050 { 1051 /* 1052 * PWG raster data is always network byte order with most of the page header 1053 * zeroed. 1054 */ 1055 1056 cups_page_header2_t fh; /* File page header */ 1057 1058 memset(&fh, 0, sizeof(fh)); 1059 strlcpy(fh.MediaClass, "PwgRaster", sizeof(fh.MediaClass)); 1060 strlcpy(fh.MediaColor, r->header.MediaColor, sizeof(fh.MediaColor)); 1061 strlcpy(fh.MediaType, r->header.MediaType, sizeof(fh.MediaType)); 1062 strlcpy(fh.OutputType, r->header.OutputType, sizeof(fh.OutputType)); 1063 strlcpy(fh.cupsRenderingIntent, r->header.cupsRenderingIntent, 1064 sizeof(fh.cupsRenderingIntent)); 1065 strlcpy(fh.cupsPageSizeName, r->header.cupsPageSizeName, 1066 sizeof(fh.cupsPageSizeName)); 1067 1068 fh.CutMedia = htonl(r->header.CutMedia); 1069 fh.Duplex = htonl(r->header.Duplex); 1070 fh.HWResolution[0] = htonl(r->header.HWResolution[0]); 1071 fh.HWResolution[1] = htonl(r->header.HWResolution[1]); 1072 fh.ImagingBoundingBox[0] = htonl(r->header.ImagingBoundingBox[0]); 1073 fh.ImagingBoundingBox[1] = htonl(r->header.ImagingBoundingBox[1]); 1074 fh.ImagingBoundingBox[2] = htonl(r->header.ImagingBoundingBox[2]); 1075 fh.ImagingBoundingBox[3] = htonl(r->header.ImagingBoundingBox[3]); 1076 fh.InsertSheet = htonl(r->header.InsertSheet); 1077 fh.Jog = htonl(r->header.Jog); 1078 fh.LeadingEdge = htonl(r->header.LeadingEdge); 1079 fh.ManualFeed = htonl(r->header.ManualFeed); 1080 fh.MediaPosition = htonl(r->header.MediaPosition); 1081 fh.MediaWeight = htonl(r->header.MediaWeight); 1082 fh.NumCopies = htonl(r->header.NumCopies); 1083 fh.Orientation = htonl(r->header.Orientation); 1084 fh.PageSize[0] = htonl(r->header.PageSize[0]); 1085 fh.PageSize[1] = htonl(r->header.PageSize[1]); 1086 fh.Tumble = htonl(r->header.Tumble); 1087 fh.cupsWidth = htonl(r->header.cupsWidth); 1088 fh.cupsHeight = htonl(r->header.cupsHeight); 1089 fh.cupsBitsPerColor = htonl(r->header.cupsBitsPerColor); 1090 fh.cupsBitsPerPixel = htonl(r->header.cupsBitsPerPixel); 1091 fh.cupsBytesPerLine = htonl(r->header.cupsBytesPerLine); 1092 fh.cupsColorOrder = htonl(r->header.cupsColorOrder); 1093 fh.cupsColorSpace = htonl(r->header.cupsColorSpace); 1094 fh.cupsNumColors = htonl(r->header.cupsNumColors); 1095 fh.cupsInteger[0] = htonl(r->header.cupsInteger[0]); 1096 fh.cupsInteger[1] = htonl(r->header.cupsInteger[1]); 1097 fh.cupsInteger[2] = htonl(r->header.cupsInteger[2]); 1098 fh.cupsInteger[3] = htonl((unsigned)(r->header.cupsImagingBBox[0] * r->header.HWResolution[0] / 72.0)); 1099 fh.cupsInteger[4] = htonl((unsigned)(r->header.cupsImagingBBox[1] * r->header.HWResolution[1] / 72.0)); 1100 fh.cupsInteger[5] = htonl((unsigned)(r->header.cupsImagingBBox[2] * r->header.HWResolution[0] / 72.0)); 1101 fh.cupsInteger[6] = htonl((unsigned)(r->header.cupsImagingBBox[3] * r->header.HWResolution[1] / 72.0)); 1102 fh.cupsInteger[7] = htonl(0xffffff); 1103 1104 return (cups_raster_io(r, (unsigned char *)&fh, sizeof(fh)) == sizeof(fh)); 1105 } 1106 else if (r->mode == CUPS_RASTER_WRITE_APPLE) 1107 { 1108 /* 1109 * Raw raster data is always network byte order with most of the page header 1110 * zeroed. 1111 */ 1112 1113 unsigned char appleheader[32]; /* Raw page header */ 1114 unsigned height = r->header.cupsHeight * r->rowheight; 1115 /* Computed page height */ 1116 1117 if (r->apple_page_count == 0xffffffffU) 1118 { 1119 /* 1120 * Write raw page count from raster page header... 1121 */ 1122 1123 r->apple_page_count = r->header.cupsInteger[0]; 1124 1125 appleheader[0] = 'A'; 1126 appleheader[1] = 'S'; 1127 appleheader[2] = 'T'; 1128 appleheader[3] = 0; 1129 appleheader[4] = (unsigned char)(r->apple_page_count >> 24); 1130 appleheader[5] = (unsigned char)(r->apple_page_count >> 16); 1131 appleheader[6] = (unsigned char)(r->apple_page_count >> 8); 1132 appleheader[7] = (unsigned char)(r->apple_page_count); 1133 1134 if (cups_raster_io(r, appleheader, 8) != 8) 1135 return (0); 1136 } 1137 1138 memset(appleheader, 0, sizeof(appleheader)); 1139 1140 appleheader[0] = (unsigned char)r->header.cupsBitsPerPixel; 1141 appleheader[1] = r->header.cupsColorSpace == CUPS_CSPACE_SRGB ? 1 : 1142 r->header.cupsColorSpace == CUPS_CSPACE_RGBW ? 2 : 1143 r->header.cupsColorSpace == CUPS_CSPACE_ADOBERGB ? 3 : 1144 r->header.cupsColorSpace == CUPS_CSPACE_W ? 4 : 1145 r->header.cupsColorSpace == CUPS_CSPACE_RGB ? 5 : 1146 r->header.cupsColorSpace == CUPS_CSPACE_CMYK ? 6 : 0; 1147 appleheader[12] = (unsigned char)(r->header.cupsWidth >> 24); 1148 appleheader[13] = (unsigned char)(r->header.cupsWidth >> 16); 1149 appleheader[14] = (unsigned char)(r->header.cupsWidth >> 8); 1150 appleheader[15] = (unsigned char)(r->header.cupsWidth); 1151 appleheader[16] = (unsigned char)(height >> 24); 1152 appleheader[17] = (unsigned char)(height >> 16); 1153 appleheader[18] = (unsigned char)(height >> 8); 1154 appleheader[19] = (unsigned char)(height); 1155 appleheader[20] = (unsigned char)(r->header.HWResolution[0] >> 24); 1156 appleheader[21] = (unsigned char)(r->header.HWResolution[0] >> 16); 1157 appleheader[22] = (unsigned char)(r->header.HWResolution[0] >> 8); 1158 appleheader[23] = (unsigned char)(r->header.HWResolution[0]); 1159 1160 return (cups_raster_io(r, appleheader, sizeof(appleheader)) == sizeof(appleheader)); 1161 } 1162 else 1163 return (cups_raster_io(r, (unsigned char *)&(r->header), sizeof(r->header)) 1164 == sizeof(r->header)); 1165 } 1166 1167 1168 /* 1169 * 'cupsRasterWritePixels()' - Write raster pixels. 1170 * 1171 * For best performance, filters should write one or more whole lines. 1172 * The "cupsBytesPerLine" value from the page header can be used to allocate 1173 * the line buffer and as the number of bytes to write. 1174 */ 1175 1176 unsigned /* O - Number of bytes written */ 1177 cupsRasterWritePixels(cups_raster_t *r, /* I - Raster stream */ 1178 unsigned char *p, /* I - Bytes to write */ 1179 unsigned len)/* I - Number of bytes to write */ 1180 { 1181 ssize_t bytes; /* Bytes read */ 1182 unsigned remaining; /* Bytes remaining */ 1183 1184 1185 DEBUG_printf(("cupsRasterWritePixels(r=%p, p=%p, len=%u), remaining=%u", (void *)r, (void *)p, len, r->remaining)); 1186 1187 if (r == NULL || r->mode == CUPS_RASTER_READ || r->remaining == 0) 1188 return (0); 1189 1190 if (!r->compressed) 1191 { 1192 /* 1193 * Without compression, just write the raster data raw unless the data needs 1194 * to be swapped... 1195 */ 1196 1197 r->remaining -= len / r->header.cupsBytesPerLine; 1198 1199 if (r->swapped && 1200 (r->header.cupsBitsPerColor == 16 || 1201 r->header.cupsBitsPerPixel == 12 || 1202 r->header.cupsBitsPerPixel == 16)) 1203 { 1204 unsigned char *bufptr; /* Pointer into write buffer */ 1205 unsigned count; /* Remaining count */ 1206 1207 /* 1208 * Allocate a write buffer as needed... 1209 */ 1210 1211 if ((size_t)len > r->bufsize) 1212 { 1213 if (r->buffer) 1214 bufptr = realloc(r->buffer, len); 1215 else 1216 bufptr = malloc(len); 1217 1218 if (!bufptr) 1219 return (0); 1220 1221 r->buffer = bufptr; 1222 r->bufsize = len; 1223 } 1224 1225 /* 1226 * Byte swap the pixels... 1227 */ 1228 1229 for (bufptr = r->buffer, count = len; count > 1; count -= 2, bufptr += 2) 1230 { 1231 bufptr[1] = *p++; 1232 bufptr[0] = *p++; 1233 } 1234 1235 if (count) /* This should never happen... */ 1236 *bufptr = *p; 1237 1238 /* 1239 * Write the byte-swapped buffer... 1240 */ 1241 1242 bytes = cups_raster_io(r, r->buffer, len); 1243 } 1244 else 1245 bytes = cups_raster_io(r, p, len); 1246 1247 if (bytes < len) 1248 return (0); 1249 else 1250 return (len); 1251 } 1252 1253 /* 1254 * Otherwise, compress each line... 1255 */ 1256 1257 for (remaining = len; remaining > 0; remaining -= (unsigned)bytes, p += bytes) 1258 { 1259 /* 1260 * Figure out the number of remaining bytes on the current line... 1261 */ 1262 1263 if ((bytes = (ssize_t)remaining) > (ssize_t)(r->pend - r->pcurrent)) 1264 bytes = (ssize_t)(r->pend - r->pcurrent); 1265 1266 if (r->count > 0) 1267 { 1268 /* 1269 * Check to see if this line is the same as the previous line... 1270 */ 1271 1272 if (memcmp(p, r->pcurrent, (size_t)bytes)) 1273 { 1274 if (cups_raster_write(r, r->pixels) <= 0) 1275 return (0); 1276 1277 r->count = 0; 1278 } 1279 else 1280 { 1281 /* 1282 * Mark more bytes as the same... 1283 */ 1284 1285 r->pcurrent += bytes; 1286 1287 if (r->pcurrent >= r->pend) 1288 { 1289 /* 1290 * Increase the repeat count... 1291 */ 1292 1293 r->count += r->rowheight; 1294 r->pcurrent = r->pixels; 1295 1296 /* 1297 * Flush out this line if it is the last one... 1298 */ 1299 1300 r->remaining --; 1301 1302 if (r->remaining == 0) 1303 { 1304 if (cups_raster_write(r, r->pixels) <= 0) 1305 return (0); 1306 else 1307 return (len); 1308 } 1309 else if (r->count > (256 - r->rowheight)) 1310 { 1311 if (cups_raster_write(r, r->pixels) <= 0) 1312 return (0); 1313 1314 r->count = 0; 1315 } 1316 } 1317 1318 continue; 1319 } 1320 } 1321 1322 if (r->count == 0) 1323 { 1324 /* 1325 * Copy the raster data to the buffer... 1326 */ 1327 1328 memcpy(r->pcurrent, p, (size_t)bytes); 1329 1330 r->pcurrent += bytes; 1331 1332 if (r->pcurrent >= r->pend) 1333 { 1334 /* 1335 * Increase the repeat count... 1336 */ 1337 1338 r->count += r->rowheight; 1339 r->pcurrent = r->pixels; 1340 1341 /* 1342 * Flush out this line if it is the last one... 1343 */ 1344 1345 r->remaining --; 1346 1347 if (r->remaining == 0) 1348 { 1349 if (cups_raster_write(r, r->pixels) <= 0) 1350 return (0); 1351 } 1352 } 1353 } 1354 } 1355 1356 return (len); 1357 } 1358 1359 1360 /* 1361 * 'cups_raster_read_header()' - Read a raster page header. 1362 */ 1363 1364 static unsigned /* O - 1 on success, 0 on fail */ 1365 cups_raster_read_header( 1366 cups_raster_t *r) /* I - Raster stream */ 1367 { 1368 size_t len; /* Length for read/swap */ 1369 1370 1371 DEBUG_printf(("3cups_raster_read_header(r=%p), r->mode=%d", (void *)r, r ? r->mode : 0)); 1372 1373 if (r == NULL || r->mode != CUPS_RASTER_READ) 1374 return (0); 1375 1376 DEBUG_printf(("4cups_raster_read_header: r->iocount=" CUPS_LLFMT, CUPS_LLCAST r->iocount)); 1377 1378 memset(&(r->header), 0, sizeof(r->header)); 1379 1380 /* 1381 * Read the header... 1382 */ 1383 1384 switch (r->sync) 1385 { 1386 default : 1387 /* 1388 * Get the length of the raster header... 1389 */ 1390 1391 if (r->sync == CUPS_RASTER_SYNCv1 || r->sync == CUPS_RASTER_REVSYNCv1) 1392 len = sizeof(cups_page_header_t); 1393 else 1394 len = sizeof(cups_page_header2_t); 1395 1396 DEBUG_printf(("4cups_raster_read_header: len=%d", (int)len)); 1397 1398 /* 1399 * Read it... 1400 */ 1401 1402 if (cups_raster_read(r, (unsigned char *)&(r->header), len) < (ssize_t)len) 1403 { 1404 DEBUG_printf(("4cups_raster_read_header: EOF, r->iocount=" CUPS_LLFMT, CUPS_LLCAST r->iocount)); 1405 return (0); 1406 } 1407 1408 /* 1409 * Swap bytes as needed... 1410 */ 1411 1412 if (r->swapped) 1413 { 1414 unsigned *s, /* Current word */ 1415 temp; /* Temporary copy */ 1416 1417 1418 DEBUG_puts("4cups_raster_read_header: Swapping header bytes."); 1419 1420 for (len = 81, s = &(r->header.AdvanceDistance); 1421 len > 0; 1422 len --, s ++) 1423 { 1424 temp = *s; 1425 *s = ((temp & 0xff) << 24) | 1426 ((temp & 0xff00) << 8) | 1427 ((temp & 0xff0000) >> 8) | 1428 ((temp & 0xff000000) >> 24); 1429 1430 DEBUG_printf(("4cups_raster_read_header: %08x => %08x", temp, *s)); 1431 } 1432 } 1433 break; 1434 1435 case CUPS_RASTER_SYNCapple : 1436 case CUPS_RASTER_REVSYNCapple : 1437 { 1438 unsigned char appleheader[32]; /* Raw header */ 1439 static const unsigned rawcspace[] = 1440 { 1441 CUPS_CSPACE_SW, 1442 CUPS_CSPACE_SRGB, 1443 CUPS_CSPACE_RGBW, 1444 CUPS_CSPACE_ADOBERGB, 1445 CUPS_CSPACE_W, 1446 CUPS_CSPACE_RGB, 1447 CUPS_CSPACE_CMYK 1448 }; 1449 static const unsigned rawnumcolors[] = 1450 { 1451 1, 1452 3, 1453 4, 1454 3, 1455 1, 1456 3, 1457 4 1458 }; 1459 1460 if (cups_raster_read(r, appleheader, sizeof(appleheader)) < (ssize_t)sizeof(appleheader)) 1461 { 1462 DEBUG_printf(("4cups_raster_read_header: EOF, r->iocount=" CUPS_LLFMT, CUPS_LLCAST r->iocount)); 1463 return (0); 1464 } 1465 1466 strlcpy(r->header.MediaClass, "PwgRaster", sizeof(r->header.MediaClass)); 1467 /* PwgRaster */ 1468 r->header.cupsBitsPerPixel = appleheader[0]; 1469 r->header.cupsColorSpace = appleheader[1] >= (sizeof(rawcspace) / sizeof(rawcspace[0])) ? CUPS_CSPACE_DEVICE1 : rawcspace[appleheader[1]]; 1470 r->header.cupsNumColors = appleheader[1] >= (sizeof(rawnumcolors) / sizeof(rawnumcolors[0])) ? 1 : rawnumcolors[appleheader[1]]; 1471 r->header.cupsBitsPerColor = r->header.cupsBitsPerPixel / r->header.cupsNumColors; 1472 r->header.cupsWidth = ((((((unsigned)appleheader[12] << 8) | (unsigned)appleheader[13]) << 8) | (unsigned)appleheader[14]) << 8) | (unsigned)appleheader[15]; 1473 r->header.cupsHeight = ((((((unsigned)appleheader[16] << 8) | (unsigned)appleheader[17]) << 8) | (unsigned)appleheader[18]) << 8) | (unsigned)appleheader[19]; 1474 r->header.cupsBytesPerLine = r->header.cupsWidth * r->header.cupsBitsPerPixel / 8; 1475 r->header.cupsColorOrder = CUPS_ORDER_CHUNKED; 1476 r->header.HWResolution[0] = r->header.HWResolution[1] = ((((((unsigned)appleheader[20] << 8) | (unsigned)appleheader[21]) << 8) | (unsigned)appleheader[22]) << 8) | (unsigned)appleheader[23]; 1477 1478 if (r->header.HWResolution[0] > 0) 1479 { 1480 r->header.PageSize[0] = (unsigned)(r->header.cupsWidth * 72 / r->header.HWResolution[0]); 1481 r->header.PageSize[1] = (unsigned)(r->header.cupsHeight * 72 / r->header.HWResolution[1]); 1482 r->header.cupsPageSize[0] = (float)(r->header.cupsWidth * 72.0 / r->header.HWResolution[0]); 1483 r->header.cupsPageSize[1] = (float)(r->header.cupsHeight * 72.0 / r->header.HWResolution[1]); 1484 } 1485 1486 r->header.cupsInteger[0] = r->apple_page_count; 1487 r->header.cupsInteger[7] = 0xffffff; 1488 } 1489 break; 1490 } 1491 1492 /* 1493 * Update the header and row count... 1494 */ 1495 1496 if (!cups_raster_update(r)) 1497 return (0); 1498 1499 DEBUG_printf(("4cups_raster_read_header: cupsBitsPerPixel=%u, cupsBitsPerColor=%u, cupsBytesPerLine=%u, cupsWidth=%u, cupsHeight=%u, r->bpp=%d", r->header.cupsBitsPerPixel, r->header.cupsBitsPerColor, r->header.cupsBytesPerLine, r->header.cupsWidth, r->header.cupsHeight, r->bpp)); 1500 1501 return (r->header.cupsBitsPerPixel > 0 && r->header.cupsBitsPerPixel <= 240 && r->header.cupsBitsPerColor > 0 && r->header.cupsBitsPerColor <= 16 && r->header.cupsBytesPerLine > 0 && r->header.cupsBytesPerLine <= 0x7fffffff && r->header.cupsHeight != 0 && (r->header.cupsBytesPerLine % r->bpp) == 0); 1502 } 1503 1504 1505 /* 1506 * 'cups_raster_io()' - Read/write bytes from a context, handling interruptions. 1507 */ 1508 1509 static ssize_t /* O - Bytes read/write or -1 */ 1510 cups_raster_io(cups_raster_t *r, /* I - Raster stream */ 1511 unsigned char *buf, /* I - Buffer for read/write */ 1512 size_t bytes) /* I - Number of bytes to read/write */ 1513 { 1514 ssize_t count, /* Number of bytes read/written */ 1515 total; /* Total bytes read/written */ 1516 1517 1518 DEBUG_printf(("5cups_raster_io(r=%p, buf=%p, bytes=" CUPS_LLFMT ")", (void *)r, (void *)buf, CUPS_LLCAST bytes)); 1519 1520 for (total = 0; total < (ssize_t)bytes; total += count, buf += count) 1521 { 1522 count = (*r->iocb)(r->ctx, buf, bytes - (size_t)total); 1523 1524 DEBUG_printf(("6cups_raster_io: count=%d, total=%d", (int)count, (int)total)); 1525 if (count == 0) 1526 { 1527 DEBUG_puts("6cups_raster_io: Returning 0."); 1528 return (0); 1529 } 1530 else if (count < 0) 1531 { 1532 DEBUG_puts("6cups_raster_io: Returning -1 on error."); 1533 return (-1); 1534 } 1535 1536 #ifdef DEBUG 1537 r->iocount += (size_t)count; 1538 #endif /* DEBUG */ 1539 } 1540 1541 DEBUG_printf(("6cups_raster_io: Returning " CUPS_LLFMT ".", CUPS_LLCAST total)); 1542 1543 return (total); 1544 } 1545 1546 1547 /* 1548 * 'cups_raster_read()' - Read through the raster buffer. 1549 */ 1550 1551 static ssize_t /* O - Number of bytes read */ 1552 cups_raster_read(cups_raster_t *r, /* I - Raster stream */ 1553 unsigned char *buf, /* I - Buffer */ 1554 size_t bytes) /* I - Number of bytes to read */ 1555 { 1556 ssize_t count, /* Number of bytes read */ 1557 remaining, /* Remaining bytes in buffer */ 1558 total; /* Total bytes read */ 1559 1560 1561 DEBUG_printf(("5cups_raster_read(r=%p, buf=%p, bytes=" CUPS_LLFMT ")", (void *)r, (void *)buf, CUPS_LLCAST bytes)); 1562 1563 if (!r->compressed) 1564 return (cups_raster_io(r, buf, bytes)); 1565 1566 /* 1567 * Allocate a read buffer as needed... 1568 */ 1569 1570 count = (ssize_t)(2 * r->header.cupsBytesPerLine); 1571 if (count < 65536) 1572 count = 65536; 1573 1574 if ((size_t)count > r->bufsize) 1575 { 1576 ssize_t offset = r->bufptr - r->buffer; 1577 /* Offset to current start of buffer */ 1578 ssize_t end = r->bufend - r->buffer;/* Offset to current end of buffer */ 1579 unsigned char *rptr; /* Pointer in read buffer */ 1580 1581 if (r->buffer) 1582 rptr = realloc(r->buffer, (size_t)count); 1583 else 1584 rptr = malloc((size_t)count); 1585 1586 if (!rptr) 1587 return (0); 1588 1589 r->buffer = rptr; 1590 r->bufptr = rptr + offset; 1591 r->bufend = rptr + end; 1592 r->bufsize = (size_t)count; 1593 } 1594 1595 /* 1596 * Loop until we have read everything... 1597 */ 1598 1599 for (total = 0, remaining = (int)(r->bufend - r->bufptr); 1600 total < (ssize_t)bytes; 1601 total += count, buf += count) 1602 { 1603 count = (ssize_t)bytes - total; 1604 1605 DEBUG_printf(("6cups_raster_read: count=" CUPS_LLFMT ", remaining=" CUPS_LLFMT ", buf=%p, bufptr=%p, bufend=%p", CUPS_LLCAST count, CUPS_LLCAST remaining, (void *)buf, (void *)r->bufptr, (void *)r->bufend)); 1606 1607 if (remaining == 0) 1608 { 1609 if (count < 16) 1610 { 1611 /* 1612 * Read into the raster buffer and then copy... 1613 */ 1614 1615 remaining = (*r->iocb)(r->ctx, r->buffer, r->bufsize); 1616 if (remaining <= 0) 1617 return (0); 1618 1619 r->bufptr = r->buffer; 1620 r->bufend = r->buffer + remaining; 1621 1622 #ifdef DEBUG 1623 r->iocount += (size_t)remaining; 1624 #endif /* DEBUG */ 1625 } 1626 else 1627 { 1628 /* 1629 * Read directly into "buf"... 1630 */ 1631 1632 count = (*r->iocb)(r->ctx, buf, (size_t)count); 1633 1634 if (count <= 0) 1635 return (0); 1636 1637 #ifdef DEBUG 1638 r->iocount += (size_t)count; 1639 #endif /* DEBUG */ 1640 1641 continue; 1642 } 1643 } 1644 1645 /* 1646 * Copy bytes from raster buffer to "buf"... 1647 */ 1648 1649 if (count > remaining) 1650 count = remaining; 1651 1652 if (count == 1) 1653 { 1654 /* 1655 * Copy 1 byte... 1656 */ 1657 1658 *buf = *(r->bufptr)++; 1659 remaining --; 1660 } 1661 else if (count < 128) 1662 { 1663 /* 1664 * Copy up to 127 bytes without using memcpy(); this is 1665 * faster because it avoids an extra function call and is 1666 * often further optimized by the compiler... 1667 */ 1668 1669 unsigned char *bufptr; /* Temporary buffer pointer */ 1670 1671 remaining -= count; 1672 1673 for (bufptr = r->bufptr; count > 0; count --, total ++) 1674 *buf++ = *bufptr++; 1675 1676 r->bufptr = bufptr; 1677 } 1678 else 1679 { 1680 /* 1681 * Use memcpy() for a large read... 1682 */ 1683 1684 memcpy(buf, r->bufptr, (size_t)count); 1685 r->bufptr += count; 1686 remaining -= count; 1687 } 1688 } 1689 1690 DEBUG_printf(("6cups_raster_read: Returning %ld", (long)total)); 1691 1692 return (total); 1693 } 1694 1695 1696 /* 1697 * 'cups_raster_update()' - Update the raster header and row count for the 1698 * current page. 1699 */ 1700 1701 static int /* O - 1 on success, 0 on failure */ 1702 cups_raster_update(cups_raster_t *r) /* I - Raster stream */ 1703 { 1704 if (r->sync == CUPS_RASTER_SYNCv1 || r->sync == CUPS_RASTER_REVSYNCv1 || 1705 r->header.cupsNumColors == 0) 1706 { 1707 /* 1708 * Set the "cupsNumColors" field according to the colorspace... 1709 */ 1710 1711 switch (r->header.cupsColorSpace) 1712 { 1713 case CUPS_CSPACE_W : 1714 case CUPS_CSPACE_K : 1715 case CUPS_CSPACE_WHITE : 1716 case CUPS_CSPACE_GOLD : 1717 case CUPS_CSPACE_SILVER : 1718 case CUPS_CSPACE_SW : 1719 r->header.cupsNumColors = 1; 1720 break; 1721 1722 case CUPS_CSPACE_RGB : 1723 case CUPS_CSPACE_CMY : 1724 case CUPS_CSPACE_YMC : 1725 case CUPS_CSPACE_CIEXYZ : 1726 case CUPS_CSPACE_CIELab : 1727 case CUPS_CSPACE_SRGB : 1728 case CUPS_CSPACE_ADOBERGB : 1729 case CUPS_CSPACE_ICC1 : 1730 case CUPS_CSPACE_ICC2 : 1731 case CUPS_CSPACE_ICC3 : 1732 case CUPS_CSPACE_ICC4 : 1733 case CUPS_CSPACE_ICC5 : 1734 case CUPS_CSPACE_ICC6 : 1735 case CUPS_CSPACE_ICC7 : 1736 case CUPS_CSPACE_ICC8 : 1737 case CUPS_CSPACE_ICC9 : 1738 case CUPS_CSPACE_ICCA : 1739 case CUPS_CSPACE_ICCB : 1740 case CUPS_CSPACE_ICCC : 1741 case CUPS_CSPACE_ICCD : 1742 case CUPS_CSPACE_ICCE : 1743 case CUPS_CSPACE_ICCF : 1744 r->header.cupsNumColors = 3; 1745 break; 1746 1747 case CUPS_CSPACE_RGBA : 1748 case CUPS_CSPACE_RGBW : 1749 case CUPS_CSPACE_CMYK : 1750 case CUPS_CSPACE_YMCK : 1751 case CUPS_CSPACE_KCMY : 1752 case CUPS_CSPACE_GMCK : 1753 case CUPS_CSPACE_GMCS : 1754 r->header.cupsNumColors = 4; 1755 break; 1756 1757 case CUPS_CSPACE_KCMYcm : 1758 if (r->header.cupsBitsPerPixel < 8) 1759 r->header.cupsNumColors = 6; 1760 else 1761 r->header.cupsNumColors = 4; 1762 break; 1763 1764 case CUPS_CSPACE_DEVICE1 : 1765 case CUPS_CSPACE_DEVICE2 : 1766 case CUPS_CSPACE_DEVICE3 : 1767 case CUPS_CSPACE_DEVICE4 : 1768 case CUPS_CSPACE_DEVICE5 : 1769 case CUPS_CSPACE_DEVICE6 : 1770 case CUPS_CSPACE_DEVICE7 : 1771 case CUPS_CSPACE_DEVICE8 : 1772 case CUPS_CSPACE_DEVICE9 : 1773 case CUPS_CSPACE_DEVICEA : 1774 case CUPS_CSPACE_DEVICEB : 1775 case CUPS_CSPACE_DEVICEC : 1776 case CUPS_CSPACE_DEVICED : 1777 case CUPS_CSPACE_DEVICEE : 1778 case CUPS_CSPACE_DEVICEF : 1779 r->header.cupsNumColors = r->header.cupsColorSpace - 1780 CUPS_CSPACE_DEVICE1 + 1; 1781 break; 1782 1783 default : 1784 /* Unknown color space */ 1785 return (0); 1786 } 1787 } 1788 1789 /* 1790 * Set the number of bytes per pixel/color... 1791 */ 1792 1793 if (r->header.cupsColorOrder == CUPS_ORDER_CHUNKED) 1794 r->bpp = (r->header.cupsBitsPerPixel + 7) / 8; 1795 else 1796 r->bpp = (r->header.cupsBitsPerColor + 7) / 8; 1797 1798 if (r->bpp == 0) 1799 r->bpp = 1; 1800 1801 /* 1802 * Set the number of remaining rows... 1803 */ 1804 1805 if (r->header.cupsColorOrder == CUPS_ORDER_PLANAR) 1806 r->remaining = r->header.cupsHeight * r->header.cupsNumColors; 1807 else 1808 r->remaining = r->header.cupsHeight; 1809 1810 /* 1811 * Allocate the compression buffer... 1812 */ 1813 1814 if (r->compressed) 1815 { 1816 if (r->pixels != NULL) 1817 free(r->pixels); 1818 1819 if ((r->pixels = calloc(r->header.cupsBytesPerLine, 1)) == NULL) 1820 { 1821 r->pcurrent = NULL; 1822 r->pend = NULL; 1823 r->count = 0; 1824 1825 return (0); 1826 } 1827 1828 r->pcurrent = r->pixels; 1829 r->pend = r->pixels + r->header.cupsBytesPerLine; 1830 r->count = 0; 1831 } 1832 1833 return (1); 1834 } 1835 1836 1837 /* 1838 * 'cups_raster_write()' - Write a row of compressed raster data... 1839 */ 1840 1841 static ssize_t /* O - Number of bytes written */ 1842 cups_raster_write( 1843 cups_raster_t *r, /* I - Raster stream */ 1844 const unsigned char *pixels) /* I - Pixel data to write */ 1845 { 1846 const unsigned char *start, /* Start of sequence */ 1847 *ptr, /* Current pointer in sequence */ 1848 *pend, /* End of raster buffer */ 1849 *plast; /* Pointer to last pixel */ 1850 unsigned char *wptr; /* Pointer into write buffer */ 1851 unsigned bpp, /* Bytes per pixel */ 1852 count; /* Count */ 1853 1854 1855 DEBUG_printf(("3cups_raster_write(r=%p, pixels=%p)", (void *)r, (void *)pixels)); 1856 1857 /* 1858 * Allocate a write buffer as needed... 1859 */ 1860 1861 count = r->header.cupsBytesPerLine * 2; 1862 if (count < 65536) 1863 count = 65536; 1864 1865 if ((size_t)count > r->bufsize) 1866 { 1867 if (r->buffer) 1868 wptr = realloc(r->buffer, count); 1869 else 1870 wptr = malloc(count); 1871 1872 if (!wptr) 1873 { 1874 DEBUG_printf(("4cups_raster_write: Unable to allocate " CUPS_LLFMT " bytes for raster buffer: %s", CUPS_LLCAST count, strerror(errno))); 1875 return (-1); 1876 } 1877 1878 r->buffer = wptr; 1879 r->bufsize = count; 1880 } 1881 1882 /* 1883 * Write the row repeat count... 1884 */ 1885 1886 bpp = r->bpp; 1887 pend = pixels + r->header.cupsBytesPerLine; 1888 plast = pend - bpp; 1889 wptr = r->buffer; 1890 *wptr++ = (unsigned char)(r->count - 1); 1891 1892 /* 1893 * Write using a modified PackBits compression... 1894 */ 1895 1896 for (ptr = pixels; ptr < pend;) 1897 { 1898 start = ptr; 1899 ptr += bpp; 1900 1901 if (ptr == pend) 1902 { 1903 /* 1904 * Encode a single pixel at the end... 1905 */ 1906 1907 *wptr++ = 0; 1908 for (count = bpp; count > 0; count --) 1909 *wptr++ = *start++; 1910 } 1911 else if (!memcmp(start, ptr, bpp)) 1912 { 1913 /* 1914 * Encode a sequence of repeating pixels... 1915 */ 1916 1917 for (count = 2; count < 128 && ptr < plast; count ++, ptr += bpp) 1918 if (memcmp(ptr, ptr + bpp, bpp)) 1919 break; 1920 1921 *wptr++ = (unsigned char)(count - 1); 1922 for (count = bpp; count > 0; count --) 1923 *wptr++ = *ptr++; 1924 } 1925 else 1926 { 1927 /* 1928 * Encode a sequence of non-repeating pixels... 1929 */ 1930 1931 for (count = 1; count < 128 && ptr < plast; count ++, ptr += bpp) 1932 if (!memcmp(ptr, ptr + bpp, bpp)) 1933 break; 1934 1935 if (ptr >= plast && count < 128) 1936 { 1937 count ++; 1938 ptr += bpp; 1939 } 1940 1941 *wptr++ = (unsigned char)(257 - count); 1942 1943 count *= bpp; 1944 memcpy(wptr, start, count); 1945 wptr += count; 1946 } 1947 } 1948 1949 DEBUG_printf(("4cups_raster_write: Writing " CUPS_LLFMT " bytes.", CUPS_LLCAST (wptr - r->buffer))); 1950 1951 return (cups_raster_io(r, r->buffer, (size_t)(wptr - r->buffer))); 1952 } 1953 1954 1955 /* 1956 * 'cups_read_fd()' - Read bytes from a file. 1957 */ 1958 1959 static ssize_t /* O - Bytes read or -1 */ 1960 cups_read_fd(void *ctx, /* I - File descriptor as pointer */ 1961 unsigned char *buf, /* I - Buffer for read */ 1962 size_t bytes) /* I - Maximum number of bytes to read */ 1963 { 1964 int fd = (int)((intptr_t)ctx); 1965 /* File descriptor */ 1966 ssize_t count; /* Number of bytes read */ 1967 1968 1969 #ifdef WIN32 /* Sigh */ 1970 while ((count = read(fd, buf, (unsigned)bytes)) < 0) 1971 #else 1972 while ((count = read(fd, buf, bytes)) < 0) 1973 #endif /* WIN32 */ 1974 if (errno != EINTR && errno != EAGAIN) 1975 { 1976 DEBUG_printf(("4cups_read_fd: %s", strerror(errno))); 1977 return (-1); 1978 } 1979 1980 DEBUG_printf(("4cups_read_fd: Returning %d bytes.", (int)count)); 1981 1982 return (count); 1983 } 1984 1985 1986 /* 1987 * 'cups_swap()' - Swap bytes in raster data... 1988 */ 1989 1990 static void 1991 cups_swap(unsigned char *buf, /* I - Buffer to swap */ 1992 size_t bytes) /* I - Number of bytes to swap */ 1993 { 1994 unsigned char even, odd; /* Temporary variables */ 1995 1996 1997 bytes /= 2; 1998 1999 while (bytes > 0) 2000 { 2001 even = buf[0]; 2002 odd = buf[1]; 2003 buf[0] = odd; 2004 buf[1] = even; 2005 2006 buf += 2; 2007 bytes --; 2008 } 2009 } 2010 2011 2012 /* 2013 * 'cups_write_fd()' - Write bytes to a file. 2014 */ 2015 2016 static ssize_t /* O - Bytes written or -1 */ 2017 cups_write_fd(void *ctx, /* I - File descriptor pointer */ 2018 unsigned char *buf, /* I - Bytes to write */ 2019 size_t bytes) /* I - Number of bytes to write */ 2020 { 2021 int fd = (int)((intptr_t)ctx); 2022 /* File descriptor */ 2023 ssize_t count; /* Number of bytes written */ 2024 2025 2026 #ifdef WIN32 /* Sigh */ 2027 while ((count = write(fd, buf, (unsigned)bytes)) < 0) 2028 #else 2029 while ((count = write(fd, buf, bytes)) < 0) 2030 #endif /* WIN32 */ 2031 if (errno != EINTR && errno != EAGAIN) 2032 { 2033 DEBUG_printf(("4cups_write_fd: %s", strerror(errno))); 2034 return (-1); 2035 } 2036 2037 return (count); 2038 } 2039
