Mercurial > hg > dmlib

comparison tools/lib64gfx.c @ 2606:92909caccc9e

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Rename various compression related internal constants.
author Matti Hamalainen <ccr@tnsp.org>
date Sat, 25 Nov 2023 15:56:18 +0200
parents d3bdaaae624f
children 8315e713c35e
comparison
equal deleted inserted replaced
2605:f5f03c5d9fd5 2606:92909caccc9e
299 stats[buf->data[offs]]++; 299 stats[buf->data[offs]]++;
300 300
301 // According to compression type .. 301 // According to compression type ..
302 switch (cfg->type) 302 switch (cfg->type)
303 { 303 {
304 case DM_COMP_RLE_MARKER: 304 case DM_COMP_TYPE_RLE_MARKER:
305 { 305 {
306 size_t selected = 0, 306 size_t selected = 0,
307 smallest = buf->len; 307 smallest = buf->len;
308 308
309 // Find least used byte value 309 // Find least used byte value
310 for (size_t n = 0; n < DM_STAT_MAX; n++) 310 for (size_t n = 0; n < DM_STAT_MAX; n++)
311 if (stats[n] < smallest) 311 if (stats[n] < smallest)
312 { 312 {
313 switch (cfg->flags & DM_RLE_RUNS_MASK) 313 switch (cfg->flags & DM_COMP_RLE_RUNS_MASK)
314 { 314 {
315 case DM_RLE_BYTE_RUNS | DM_RLE_WORD_RUNS: 315 case DM_COMP_RLE_BYTE_RUNS | DM_COMP_RLE_WORD_RUNS:
316 cfg->rleMarkerW = selected; 316 cfg->rleMarkerW = selected;
317 cfg->rleMarkerB = selected = n; 317 cfg->rleMarkerB = selected = n;
318 break; 318 break;
319 319
320 case DM_RLE_BYTE_RUNS: 320 case DM_COMP_RLE_BYTE_RUNS:
321 cfg->rleMarkerB = selected = n; 321 cfg->rleMarkerB = selected = n;
322 break; 322 break;
323 323
324 case DM_RLE_WORD_RUNS: 324 case DM_COMP_RLE_WORD_RUNS:
325 cfg->rleMarkerW = selected = n; 325 cfg->rleMarkerW = selected = n;
326 break; 326 break;
327 } 327 }
328 smallest = stats[n]; 328 smallest = stats[n];
329 } 329 }
330 } 330 }
331 break; 331 break;
332 332
333 case DM_COMP_RLE_MASK: 333 case DM_COMP_TYPE_RLE_MASK:
334 cfg->rleMarkerMask = 0xC0; 334 cfg->rleMarkerMask = 0xC0;
335 cfg->rleMarkerBits = 0xC0; 335 cfg->rleMarkerBits = 0xC0;
336 cfg->rleCountMask = 0x3f; 336 cfg->rleCountMask = 0x3f;
337 break; 337 break;
338 } 338 }
344 344
345 //#define RLE_DEBUG 345 //#define RLE_DEBUG
346 346
347 void dmSetupRLEBuffers(DMGrowBuf *dst, DMGrowBuf *src, const DMCompParams *cfg) 347 void dmSetupRLEBuffers(DMGrowBuf *dst, DMGrowBuf *src, const DMCompParams *cfg)
348 { 348 {
349 if (src != NULL && (cfg->flags & DM_RLE_BACKWARDS_INPUT)) 349 if (src != NULL && (cfg->flags & DM_COMP_INPUT_BACKWARDS))
350 { 350 {
351 src->offs = src->len; 351 src->offs = src->len;
352 src->backwards = true; 352 src->backwards = true;
353 } 353 }
354 354
355 if (dst != NULL && (cfg->flags & DM_RLE_BACKWARDS_OUTPUT)) 355 if (dst != NULL && (cfg->flags & DM_COMP_OUTPUT_BACKWARDS))
356 { 356 {
357 dst->backwards = true; 357 dst->backwards = true;
358 dst->offs = dst->size; 358 dst->offs = dst->size;
359 } 359 }
360 360
382 fprintf(stderr, " dst.len=%" DM_PRIx_SIZE_T ", dst.size=%" DM_PRIx_SIZE_T ", dst.offs=%" DM_PRIx_SIZE_T "\n", dst->len, dst->size, dst->offs); 382 fprintf(stderr, " dst.len=%" DM_PRIx_SIZE_T ", dst.size=%" DM_PRIx_SIZE_T ", dst.offs=%" DM_PRIx_SIZE_T "\n", dst->len, dst->size, dst->offs);
383 #endif 383 #endif
384 384
385 if (dst != NULL) 385 if (dst != NULL)
386 { 386 {
387 if (cfg->flags & DM_RLE_BACKWARDS_OUTPUT) 387 if (cfg->flags & DM_COMP_OUTPUT_BACKWARDS)
388 { 388 {
389 memmove(dst->data, dst->data + dst->offs, dst->len); 389 memmove(dst->data, dst->data + dst->offs, dst->len);
390 dst->offs = 0; 390 dst->offs = 0;
391 } 391 }
392 392
393 switch (cfg->flags & DM_OUT_CROP_MASK) 393 switch (cfg->flags & DM_COMP_OUTPUT_CROP_MASK)
394 { 394 {
395 case DM_OUT_CROP_END: 395 case DM_COMP_OUTPUT_CROP_END:
396 if (cfg->cropOutLen < dst->len) 396 if (cfg->cropOutLen < dst->len)
397 { 397 {
398 memmove(dst->data, dst->data + dst->len - cfg->cropOutLen, cfg->cropOutLen); 398 memmove(dst->data, dst->data + dst->len - cfg->cropOutLen, cfg->cropOutLen);
399 dst->len = cfg->cropOutLen; 399 dst->len = cfg->cropOutLen;
400 } 400 }
401 break; 401 break;
402 402
403 case DM_OUT_CROP_START: 403 case DM_COMP_OUTPUT_CROP_START:
404 if (cfg->cropOutLen <= dst->len) 404 if (cfg->cropOutLen <= dst->len)
405 dst->len = cfg->cropOutLen; 405 dst->len = cfg->cropOutLen;
406 break; 406 break;
407 } 407 }
408 } 408 }
446 446
447 while (dmGrowBufGetU8(&src, &data)) 447 while (dmGrowBufGetU8(&src, &data))
448 { 448 {
449 unsigned int count = 1; 449 unsigned int count = 1;
450 450
451 if (cfg->type == DM_COMP_RLE_MARKER) 451 if (cfg->type == DM_COMP_TYPE_RLE_MARKER)
452 { 452 {
453 // A simple marker byte RLE variant: [Marker] [count] [data] 453 // A simple marker byte RLE variant: [Marker] [count] [data]
454 if ((cfg->flags & DM_RLE_BYTE_RUNS) && data == cfg->rleMarkerB) 454 if ((cfg->flags & DM_COMP_RLE_BYTE_RUNS) && data == cfg->rleMarkerB)
455 { 455 {
456 if (!dmGrowBufGetU8(&src, &tmp1)) 456 if (!dmGrowBufGetU8(&src, &tmp1))
457 { 457 {
458 #ifdef RLE_DEBUG 458 #ifdef RLE_DEBUG
459 fprintf(stderr, " marker=$%02x\n", cfg->rleMarkerB); 459 fprintf(stderr, " marker=$%02x\n", cfg->rleMarkerB);
475 res = dmError(DMERR_INVALID_DATA, 475 res = dmError(DMERR_INVALID_DATA,
476 "%s: RLE: Invalid data/out of data for byte length run sequence (2).\n", 476 "%s: RLE: Invalid data/out of data for byte length run sequence (2).\n",
477 cfg->func); 477 cfg->func);
478 goto out; 478 goto out;
479 } 479 }
480 switch (cfg->flags & DM_RLE_ORDER_MASK) 480 switch (cfg->flags & DM_COMP_RLE_ORDER_MASK)
481 { 481 {
482 case DM_RLE_ORDER_1: 482 case DM_COMP_RLE_ORDER_1:
483 count = tmp1; 483 count = tmp1;
484 data = tmp2; 484 data = tmp2;
485 break; 485 break;
486 486
487 case DM_RLE_ORDER_2: 487 case DM_COMP_RLE_ORDER_2:
488 count = tmp2; 488 count = tmp2;
489 data = tmp1; 489 data = tmp1;
490 break; 490 break;
491 } 491 }
492 492
493 if (count == 0 && (cfg->flags & DM_RLE_ZERO_COUNT_MAX)) 493 if (count == 0 && (cfg->flags & DM_COMP_RLE_ZERO_COUNT_MAX))
494 count = 256; 494 count = 256;
495 } 495 }
496 else 496 else
497 if ((cfg->flags & DM_RLE_WORD_RUNS) && data == cfg->rleMarkerW) 497 if ((cfg->flags & DM_COMP_RLE_WORD_RUNS) && data == cfg->rleMarkerW)
498 { 498 {
499 if (!dmGrowBufGetU8(&src, &tmp1) || 499 if (!dmGrowBufGetU8(&src, &tmp1) ||
500 !dmGrowBufGetU8(&src, &tmp2) || 500 !dmGrowBufGetU8(&src, &tmp2) ||
501 !dmGrowBufGetU8(&src, &tmp3)) 501 !dmGrowBufGetU8(&src, &tmp3))
502 { 502 {
503 res = dmError(DMERR_INVALID_DATA, 503 res = dmError(DMERR_INVALID_DATA,
504 "%s: RLE: Invalid data/out of data for word length run sequence.\n", 504 "%s: RLE: Invalid data/out of data for word length run sequence.\n",
505 cfg->func); 505 cfg->func);
506 goto out; 506 goto out;
507 } 507 }
508 switch (cfg->flags & DM_RLE_ORDER_MASK) 508 switch (cfg->flags & DM_COMP_RLE_ORDER_MASK)
509 { 509 {
510 case DM_RLE_ORDER_1: 510 case DM_COMP_RLE_ORDER_1:
511 count = (tmp2 << 8) | tmp1; 511 count = (tmp2 << 8) | tmp1;
512 data = tmp3; 512 data = tmp3;
513 break; 513 break;
514 514
515 case DM_RLE_ORDER_2: 515 case DM_COMP_RLE_ORDER_2:
516 data = tmp1; 516 data = tmp1;
517 count = (tmp3 << 8) | tmp2; 517 count = (tmp3 << 8) | tmp2;
518 break; 518 break;
519 } 519 }
520 520
521 if (count == 0 && (cfg->flags & DM_RLE_ZERO_COUNT_MAX)) 521 if (count == 0 && (cfg->flags & DM_COMP_RLE_ZERO_COUNT_MAX))
522 count = 65536; 522 count = 65536;
523 } 523 }
524 } 524 }
525 else 525 else
526 if (cfg->type == DM_COMP_RLE_MASK) 526 if (cfg->type == DM_COMP_TYPE_RLE_MASK)
527 { 527 {
528 // Mask marker RLE: usually high bit(s) of byte mark RLE sequence 528 // Mask marker RLE: usually high bit(s) of byte mark RLE sequence
529 // and the lower bits contain the count: [Mask + count] [data] 529 // and the lower bits contain the count: [Mask + count] [data]
530 if ((data & cfg->rleMarkerMask) == cfg->rleMarkerBits) 530 if ((data & cfg->rleMarkerMask) == cfg->rleMarkerBits)
531 { 531 {
569 bool copyOnly = false; 569 bool copyOnly = false;
570 int res; 570 int res;
571 571
572 switch (cfg->type) 572 switch (cfg->type)
573 { 573 {
574 case DM_COMP_RLE_MARKER: 574 case DM_COMP_TYPE_RLE_MARKER:
575 if ((cfg->flags & DM_RLE_WORD_RUNS) && 575 if ((cfg->flags & DM_COMP_RLE_WORD_RUNS) &&
576 (count >= cfg->rleMinCountW || data == cfg->rleMarkerW)) 576 (count >= cfg->rleMinCountW || data == cfg->rleMarkerW))
577 { 577 {
578 if (count == 65536 && (cfg->flags & DM_RLE_ZERO_COUNT_MAX)) 578 if (count == 65536 && (cfg->flags & DM_COMP_RLE_ZERO_COUNT_MAX))
579 count = 0; 579 count = 0;
580 580
581 if (!dmGrowBufPutU8(dst, cfg->rleMarkerW)) 581 if (!dmGrowBufPutU8(dst, cfg->rleMarkerW))
582 goto out; 582 goto out;
583 583
584 switch (cfg->flags & DM_RLE_ORDER_MASK) 584 switch (cfg->flags & DM_COMP_RLE_ORDER_MASK)
585 { 585 {
586 case DM_RLE_ORDER_1: 586 case DM_COMP_RLE_ORDER_1:
587 if (!dmGrowBufPutU16LE(dst, count) || 587 if (!dmGrowBufPutU16LE(dst, count) ||
588 !dmGrowBufPutU8(dst, data)) 588 !dmGrowBufPutU8(dst, data))
589 goto out; 589 goto out;
590 break; 590 break;
591 591
592 case DM_RLE_ORDER_2: 592 case DM_COMP_RLE_ORDER_2:
593 if (!dmGrowBufPutU8(dst, data) || 593 if (!dmGrowBufPutU8(dst, data) ||
594 !dmGrowBufPutU16LE(dst, count)) 594 !dmGrowBufPutU16LE(dst, count))
595 goto out; 595 goto out;
596 break; 596 break;
597 } 597 }
598 } 598 }
599 else 599 else
600 if ((cfg->flags & DM_RLE_BYTE_RUNS) && 600 if ((cfg->flags & DM_COMP_RLE_BYTE_RUNS) &&
601 (count >= cfg->rleMinCountB || data == cfg->rleMarkerB)) 601 (count >= cfg->rleMinCountB || data == cfg->rleMarkerB))
602 { 602 {
603 if (count == 256 && (cfg->flags & DM_RLE_ZERO_COUNT_MAX)) 603 if (count == 256 && (cfg->flags & DM_COMP_RLE_ZERO_COUNT_MAX))
604 count = 0; 604 count = 0;
605 605
606 if (!dmGrowBufPutU8(dst, cfg->rleMarkerB)) 606 if (!dmGrowBufPutU8(dst, cfg->rleMarkerB))
607 goto out; 607 goto out;
608 608
609 switch (cfg->flags & DM_RLE_ORDER_MASK) 609 switch (cfg->flags & DM_COMP_RLE_ORDER_MASK)
610 { 610 {
611 case DM_RLE_ORDER_1: 611 case DM_COMP_RLE_ORDER_1:
612 if (!dmGrowBufPutU8(dst, count) || 612 if (!dmGrowBufPutU8(dst, count) ||
613 !dmGrowBufPutU8(dst, data)) 613 !dmGrowBufPutU8(dst, data))
614 goto out; 614 goto out;
615 break; 615 break;
616 616
617 case DM_RLE_ORDER_2: 617 case DM_COMP_RLE_ORDER_2:
618 if (!dmGrowBufPutU8(dst, data) || 618 if (!dmGrowBufPutU8(dst, data) ||
619 !dmGrowBufPutU8(dst, count)) 619 !dmGrowBufPutU8(dst, count))
620 goto out; 620 goto out;
621 break; 621 break;
622 } 622 }
623 } 623 }
624 else 624 else
625 copyOnly = true; 625 copyOnly = true;
626 break; 626 break;
627 627
628 case DM_COMP_RLE_MASK: 628 case DM_COMP_TYPE_RLE_MASK:
629 if (count >= cfg->rleMinCountB || (data & cfg->rleMarkerMask) == cfg->rleMarkerBits) 629 if (count >= cfg->rleMinCountB || (data & cfg->rleMarkerMask) == cfg->rleMarkerBits)
630 { 630 {
631 // Mask marker RLE: usually high bit(s) of byte mark RLE sequence 631 // Mask marker RLE: usually high bit(s) of byte mark RLE sequence
632 // and the lower bits contain the count: [Mask + count] [data] 632 // and the lower bits contain the count: [Mask + count] [data]
633 if (!dmGrowBufPutU8(dst, cfg->rleMarkerBits | count) || 633 if (!dmGrowBufPutU8(dst, cfg->rleMarkerBits | count) ||
666 while (dmGrowBufGetU8(&src, &data)) 666 while (dmGrowBufGetU8(&src, &data))
667 { 667 {
668 // If new data byte is different, or we exceed the rleMaxCount 668 // If new data byte is different, or we exceed the rleMaxCount
669 // for the active runs mode(s) .. then encode the run. 669 // for the active runs mode(s) .. then encode the run.
670 if ((data != prev && prev != -1) || 670 if ((data != prev && prev != -1) ||
671 ((cfg->flags & DM_RLE_WORD_RUNS) && count >= cfg->rleMaxCountW) || 671 ((cfg->flags & DM_COMP_RLE_WORD_RUNS) && count >= cfg->rleMaxCountW) ||
672 (((cfg->flags & DM_RLE_RUNS_MASK) == DM_RLE_BYTE_RUNS) && count >= cfg->rleMaxCountB)) 672 (((cfg->flags & DM_COMP_RLE_RUNS_MASK) == DM_COMP_RLE_BYTE_RUNS) && count >= cfg->rleMaxCountB))
673 { 673 {
674 if ((res = dmEncodeGenericRLESequence(dst, prev, count, cfg)) != DMERR_OK) 674 if ((res = dmEncodeGenericRLESequence(dst, prev, count, cfg)) != DMERR_OK)
675 goto out; 675 goto out;
676 676
677 count = 1; 677 count = 1;