413 int _pixels; |
413 int _pixels; |
414 REGISTER int outcnt, bits, bit, mask, incnt; |
414 REGISTER int outcnt, bits, bit, mask, incnt; |
415 int shift; |
415 int shift; |
416 OBJ w = _INST(width); |
416 OBJ w = _INST(width); |
417 |
417 |
418 /* helper for two-plane magnification by 2 */ |
418 /* helper for two-plane magnification by 2 |
|
419 * 0000 -> 0000 0000 |
|
420 * 0001 -> 0000 0101 |
|
421 * ... |
|
422 * 1111 -> 1111 1111 |
|
423 */ |
419 static unsigned char mag2[16] = {0x00, 0x05, 0x0a, 0x0f, 0x50, 0x55, 0x5a, 0x5f, |
424 static unsigned char mag2[16] = {0x00, 0x05, 0x0a, 0x0f, 0x50, 0x55, 0x5a, 0x5f, |
420 0xa0, 0xa5, 0xaa, 0xaf, 0xf0, 0xf5, 0xfa, 0xff}; |
425 0xa0, 0xa5, 0xaa, 0xaf, 0xf0, 0xf5, 0xfa, 0xff}; |
|
426 /* helper for two-plane magnification by 4 */ |
|
427 static unsigned char mag4[16] = {0x00, 0x55, 0xaa, 0xff}; |
421 |
428 |
422 if (__bothSmallInteger(srcStart, dstStart) |
429 if (__bothSmallInteger(srcStart, dstStart) |
423 && __bothSmallInteger(w, mX) |
430 && __bothSmallInteger(w, mX) |
424 && __isByteArray(srcBytes) && __isByteArray(dstBytes)) { |
431 && __isByteArray(srcBytes) && __isByteArray(dstBytes)) { |
425 _mag = __intVal(mX); |
432 _mag = __intVal(mX); |
426 srcP = __ByteArrayInstPtr(srcBytes)->ba_element - 1 + __intVal(srcStart); |
433 srcP = __ByteArrayInstPtr(srcBytes)->ba_element - 1 + __intVal(srcStart); |
427 dstP = __ByteArrayInstPtr(dstBytes)->ba_element - 1 + __intVal(dstStart); |
434 dstP = __ByteArrayInstPtr(dstBytes)->ba_element - 1 + __intVal(dstStart); |
428 _pixels = __intVal(w); |
435 _pixels = __intVal(w); |
429 |
436 |
430 switch (_mag) { |
437 switch (_mag) { |
431 case 1: |
438 case 1: |
432 break; |
439 break; |
433 |
440 |
434 case 2: |
441 case 2: |
435 /* tuned for this common case */ |
442 /* tuned for this common case */ |
436 while (_pixels > 0) { |
443 while (_pixels > 0) { |
437 _byte = *srcP++; |
444 _byte = *srcP++; |
438 *dstP++ = mag2[ _byte >> 4 ]; |
445 *dstP++ = mag2[ _byte >> 4 ]; |
439 if (_pixels > 2) { |
446 if (_pixels > 2) { |
440 *dstP++ = mag2[ _byte & 0x0F ]; |
447 *dstP++ = mag2[ _byte & 0x0F ]; |
441 } |
448 } |
442 _pixels -= 4; |
449 _pixels -= 4; |
443 } |
450 } |
444 break; |
451 break; |
445 |
452 |
446 default: |
453 case3: |
447 bits = 0, incnt = 0, outcnt = 0; |
454 /* tuned for this common case */ |
448 shift = 6; |
455 bits = 0, incnt = 0, outcnt = 0; |
449 _byte = *srcP++; |
456 shift = 6; |
450 while (_pixels--) { |
457 _byte = *srcP++; |
451 bit = (_byte >> shift) & 3; |
458 while (_pixels--) { |
452 incnt++; |
459 bit = (_byte >> shift) & 3; |
453 if (incnt == 4) { |
460 incnt++; |
454 incnt = 0; |
461 if (incnt == 4) { |
455 shift = 6; |
462 incnt = 0; |
456 _byte = *srcP++; |
463 shift = 6; |
457 } else { |
464 _byte = *srcP++; |
458 shift -= 2; |
465 } else { |
459 } |
466 shift -= 2; |
460 |
467 } |
461 for (i=_mag; i>0; i--) { |
468 |
462 bits = (bits << 2) | bit; |
469 switch (outcnt) { |
463 outcnt++; |
470 case 0: |
464 if (outcnt == 4) { |
471 /* next three pixels */ |
465 *dstP++ = bits; |
472 bits = (((bit << 2) | bit) << 2) | bit; |
466 bits = 0; |
473 outcnt = 3; |
467 outcnt = 0; |
474 break; |
468 } |
475 |
469 } |
476 case 1: |
470 } |
477 /* next three pixels & store */ |
471 break; |
478 bits = (((((bits << 2) | bit) << 2) | bit) << 2) | bit; |
472 |
479 *dstP++ = bits; |
473 } |
480 outcnt = 0; |
474 RETURN (self); |
481 break; |
|
482 |
|
483 case 2: |
|
484 /* next two pixels & store */ |
|
485 bits = (((bits << 2) | bit) << 2) | bit; |
|
486 *dstP++ = bits; |
|
487 bits = bit; |
|
488 outcnt = 1; |
|
489 break; |
|
490 |
|
491 case 3: |
|
492 /* next pixel & store */ |
|
493 bits = (bits << 2) | bit; |
|
494 *dstP++ = bits; |
|
495 bits = (bit << 2) | bit; |
|
496 outcnt = 2; |
|
497 break; |
|
498 } |
|
499 } |
|
500 if (outcnt) { |
|
501 *dstP = bits << ((4-outcnt)*2); |
|
502 } |
|
503 break; |
|
504 |
|
505 case 4: |
|
506 /* tuned for this common case */ |
|
507 incnt = 0; |
|
508 shift = 6; |
|
509 _byte = *srcP++; |
|
510 while (_pixels--) { |
|
511 bit = (_byte >> shift) & 3; |
|
512 incnt++; |
|
513 if (incnt == 4) { |
|
514 incnt = 0; |
|
515 shift = 6; |
|
516 _byte = *srcP++; |
|
517 } else { |
|
518 shift -= 2; |
|
519 } |
|
520 *dstP++ = mag4[bit]; |
|
521 } |
|
522 break; |
|
523 |
|
524 default: |
|
525 bits = 0, incnt = 0, outcnt = 0; |
|
526 shift = 6; |
|
527 _byte = *srcP++; |
|
528 while (_pixels--) { |
|
529 bit = (_byte >> shift) & 3; |
|
530 incnt++; |
|
531 if (incnt == 4) { |
|
532 incnt = 0; |
|
533 shift = 6; |
|
534 _byte = *srcP++; |
|
535 } else { |
|
536 shift -= 2; |
|
537 } |
|
538 |
|
539 for (i=_mag; i>0; i--) { |
|
540 bits = (bits << 2) | bit; |
|
541 outcnt++; |
|
542 if (outcnt == 4) { |
|
543 *dstP++ = bits; |
|
544 bits = 0; |
|
545 outcnt = 0; |
|
546 } |
|
547 } |
|
548 } |
|
549 if (outcnt) { |
|
550 *dstP = bits << ((4-outcnt)*2); |
|
551 } |
|
552 break; |
|
553 |
|
554 } |
|
555 RETURN (self); |
475 } |
556 } |
476 %} |
557 %} |
477 . |
558 . |
478 self primitiveFailed |
559 self primitiveFailed |
479 ! ! |
560 ! ! |