Coverage Report

Created: 2025-08-24 06:52

/src/c-blosc2/blosc/delta.c
Line
Count
Source (jump to first uncovered line)
1
/*********************************************************************
2
  Blosc - Blocked Shuffling and Compression Library
3
4
  Copyright (c) 2021  Blosc Development Team <blosc@blosc.org>
5
  https://blosc.org
6
  License: BSD 3-Clause (see LICENSE.txt)
7
8
  See LICENSE.txt for details about copyright and rights to use.
9
**********************************************************************/
10
11
#include "delta.h"
12
13
#include <stdio.h>
14
#include <stdint.h>
15
16
17
/* Apply the delta filters to src.  This can never fail. */
18
void delta_encoder(const uint8_t* dref, int32_t offset, int32_t nbytes, int32_t typesize,
19
0
                   const uint8_t* src, uint8_t* dest) {
20
0
  int32_t i;
21
0
  if (offset == 0) {
22
    /* This is the reference block, use delta coding in elements */
23
0
    switch (typesize) {
24
0
      case 1:
25
0
        dest[0] = dref[0];
26
0
        for (i = 1; i < nbytes; i++) {
27
0
          dest[i] = src[i] ^ dref[i-1];
28
0
        }
29
0
        break;
30
0
      case 2:
31
0
        ((uint16_t *)dest)[0] = ((uint16_t *)dref)[0];
32
0
        for (i = 1; i < nbytes / 2; i++) {
33
0
          ((uint16_t *)dest)[i] =
34
0
                  ((uint16_t *)src)[i] ^ ((uint16_t *)dref)[i-1];
35
0
        }
36
0
        break;
37
0
      case 4:
38
0
        ((uint32_t *)dest)[0] = ((uint32_t *)dref)[0];
39
0
        for (i = 1; i < nbytes / 4; i++) {
40
0
          ((uint32_t *)dest)[i] =
41
0
                  ((uint32_t *)src)[i] ^ ((uint32_t *)dref)[i-1];
42
0
        }
43
0
        break;
44
0
      case 8:
45
0
        ((uint64_t *)dest)[0] = ((uint64_t *)dref)[0];
46
0
        for (i = 1; i < nbytes / 8; i++) {
47
0
          ((uint64_t *)dest)[i] =
48
0
                  ((uint64_t *)src)[i] ^ ((uint64_t *)dref)[i-1];
49
0
        }
50
0
        break;
51
0
      default:
52
0
        if ((typesize % 8) == 0) {
53
0
          delta_encoder(dref, offset, nbytes, 8, src, dest);
54
0
        } else {
55
0
          delta_encoder(dref, offset, nbytes, 1, src, dest);
56
0
        }
57
0
    }
58
0
  } else {
59
    /* Use delta coding wrt reference block */
60
0
    switch (typesize) {
61
0
      case 1:
62
0
        for (i = 0; i < nbytes; i++) {
63
0
          dest[i] = src[i] ^ dref[i];
64
0
        }
65
0
        break;
66
0
      case 2:
67
0
        for (i = 0; i < nbytes / 2; i++) {
68
0
          ((uint16_t *) dest)[i] =
69
0
                  ((uint16_t *) src)[i] ^ ((uint16_t *) dref)[i];
70
0
        }
71
0
        break;
72
0
      case 4:
73
0
        for (i = 0; i < nbytes / 4; i++) {
74
0
          ((uint32_t *) dest)[i] =
75
0
                  ((uint32_t *) src)[i] ^ ((uint32_t *) dref)[i];
76
0
        }
77
0
        break;
78
0
      case 8:
79
0
        for (i = 0; i < nbytes / 8; i++) {
80
0
          ((uint64_t *) dest)[i] =
81
0
                  ((uint64_t *) src)[i] ^ ((uint64_t *) dref)[i];
82
0
        }
83
0
        break;
84
0
      default:
85
0
        if ((typesize % 8) == 0) {
86
0
          delta_encoder(dref, offset, nbytes, 8, src, dest);
87
0
        } else {
88
0
          delta_encoder(dref, offset, nbytes, 1, src, dest);
89
0
        }
90
0
    }
91
0
  }
92
0
}
93
94
95
/* Undo the delta filter in dest.  This can never fail. */
96
void delta_decoder(const uint8_t* dref, int32_t offset, int32_t nbytes,
97
0
                   int32_t typesize, uint8_t* dest) {
98
0
  int32_t i;
99
100
0
  if (offset == 0) {
101
    /* Decode delta for the reference block */
102
0
    switch (typesize) {
103
0
      case 1:
104
0
        for (i = 1; i < nbytes; i++) {
105
0
          dest[i] ^= dref[i-1];
106
0
        }
107
0
        break;
108
0
      case 2:
109
0
        for (i = 1; i < nbytes / 2; i++) {
110
0
          ((uint16_t *)dest)[i] ^= ((uint16_t *)dref)[i-1];
111
0
        }
112
0
        break;
113
0
      case 4:
114
0
        for (i = 1; i < nbytes / 4; i++) {
115
0
          ((uint32_t *)dest)[i] ^= ((uint32_t *)dref)[i-1];
116
0
        }
117
0
        break;
118
0
      case 8:
119
0
        for (i = 1; i < nbytes / 8; i++) {
120
0
          ((uint64_t *)dest)[i] ^= ((uint64_t *)dref)[i-1];
121
0
        }
122
0
        break;
123
0
      default:
124
0
        if ((typesize % 8) == 0) {
125
0
          delta_decoder(dref, offset, nbytes, 8, dest);
126
0
        } else {
127
0
          delta_decoder(dref, offset, nbytes, 1, dest);
128
0
        }
129
0
    }
130
0
  } else {
131
    /* Decode delta for the non-reference blocks */
132
0
    switch (typesize) {
133
0
      case 1:
134
0
        for (i = 0; i < nbytes; i++) {
135
0
          dest[i] ^= dref[i];
136
0
        }
137
0
        break;
138
0
      case 2:
139
0
        for (i = 0; i < nbytes / 2; i++) {
140
0
          ((uint16_t *)dest)[i] ^= ((uint16_t *)dref)[i];
141
0
        }
142
0
        break;
143
0
      case 4:
144
0
        for (i = 0; i < nbytes / 4; i++) {
145
0
          ((uint32_t *)dest)[i] ^= ((uint32_t *)dref)[i];
146
0
        }
147
0
        break;
148
0
      case 8:
149
0
        for (i = 0; i < nbytes / 8; i++) {
150
0
          ((uint64_t *)dest)[i] ^= ((uint64_t *)dref)[i];
151
0
        }
152
0
        break;
153
0
      default:
154
0
        if ((typesize % 8) == 0) {
155
0
          delta_decoder(dref, offset, nbytes, 8, dest);
156
0
        } else {
157
0
          delta_decoder(dref, offset, nbytes, 1, dest);
158
0
        }
159
0
    }
160
0
  }
161
0
}