tests/check_code_options.c

   1 #include <stdio.h>
   2 #include <stdlib.h>
   3 #include <string.h>
   4 #include "check_aec.h"
   5
   6 #define BUF_SIZE 1024 * 3
   7
   8 int check_block_sizes(struct test_state *state, int id, int id_len)
   9 {
  10     state->id = id;
  11     for (int bs = 8; bs <= 64; bs *= 2) {
  12         int max_rsi;
  13
  14         state->strm->block_size = bs;
  15         max_rsi = (int)(state->buf_len / (bs * state->bytes_per_sample));
  16         if (max_rsi > 4096)
  17             max_rsi = 4096;
  18
  19         for (int rsi = 1; rsi <= max_rsi; rsi++) {
  20             int status;
  21             state->strm->rsi = rsi;
  22             status = state->codec(state);
  23             if (status)
  24                 return status;
  25
  26             if ((state->cbuf[0] >> (8 - id_len)) != id) {
  27                 printf(
  28                     "%s: block of size %i created with ID:%x, expected %x.\n",
  29                     CHECK_FAIL, bs, state->cbuf[0] >> (8 - id_len), id
  30                     );
  31                 return 99;
  32             }
  33         }
  34     }
  35     return 0;
  36 }
  37
  38 int check_zero(struct test_state *state)
  39 {
  40     int status;
  41
  42     if (state->strm->flags & AEC_DATA_PREPROCESS)
  43         memset(state->ubuf, 0x55, state->buf_len);
  44     else
  45         memset(state->ubuf, 0, state->buf_len);
  46
  47     printf("Checking zero blocks ... ");
  48     status = check_block_sizes(state, 0, state->id_len + 1);
  49     if (status)
  50         return status;
  51
  52     printf ("%s\n", CHECK_PASS);
  53     return 0;
  54 }
  55
  56 int check_splitting(struct test_state *state, int k)
  57 {
  58     int status;
  59     unsigned char *tmp;
  60
  61     int size = state->bytes_per_sample;
  62
  63     if (state->strm->flags & AEC_DATA_PREPROCESS) {
  64         for (tmp = state->ubuf;
  65              tmp < state->ubuf + state->buf_len;
  66              tmp += 4 * size) {
  67             state->out(tmp, state->xmin + (1ULL << (k - 1)) - 1, size);
  68             state->out(tmp + size, state->xmin, size);
  69             state->out(tmp + 2 * size, state->xmin
  70                        + (1ULL << (k + 1)) - 1, size);
  71             state->out(tmp + 3 * size, state->xmin, size);
  72         }
  73     } else {
  74         for (tmp = state->ubuf;
  75              tmp < state->ubuf + state->buf_len;
  76              tmp += 4 * size) {
  77             state->out(tmp, 0, size);
  78             state->out(tmp + size, (1ULL << k) - 1, size);
  79             state->out(tmp + 2 * size, 0, size);
  80             state->out(tmp + 3 * size, (1ULL << (k + 2)) - 1, size);
  81         }
  82     }
  83
  84     printf("Checking splitting with k=%i ... ", k);
  85     status = check_block_sizes(state, k + 1, state->id_len);
  86     if (status)
  87         return status;
  88
  89     printf ("%s\n", CHECK_PASS);
  90     return 0;
  91 }
  92
  93 int check_uncompressed(struct test_state *state)
  94 {
  95     int status;
  96     unsigned char *tmp;
  97
  98     int size = state->bytes_per_sample;
  99
 100     for (tmp = state->ubuf;
 101          tmp < state->ubuf + state->buf_len;
 102          tmp += 2 * size) {
 103         state->out(tmp, state->xmax, size);
 104         state->out(tmp + size, state->xmin, size);
 105     }
 106
 107     printf("Checking uncompressed ... ");
 108     status = check_block_sizes(state,
 109                                (1ULL << state->id_len) - 1,
 110                                state->id_len);
 111     if (status)
 112         return status;
 113
 114     printf ("%s\n", CHECK_PASS);
 115     return 0;
 116 }
 117
 118 int check_fs(struct test_state *state)
 119 {
 120     int status;
 121     unsigned char *tmp;
 122
 123     int size = state->bytes_per_sample;
 124
 125     if (state->strm->flags & AEC_DATA_PREPROCESS) {
 126         for (tmp = state->ubuf;
 127              tmp < state->ubuf + state->buf_len;
 128              tmp += 4 * size) {
 129             state->out(tmp, state->xmin + 2, size);
 130             state->out(tmp + size, state->xmin, size);
 131             state->out(tmp + 2 * size, state->xmin, size);
 132             state->out(tmp + 3 * size, state->xmin, size);
 133         }
 134     } else {
 135         for (tmp = state->ubuf;
 136              tmp < state->ubuf + state->buf_len;
 137              tmp += 4 * size) {
 138             state->out(tmp, 0, size);
 139             state->out(tmp + size, 0, size);
 140             state->out(tmp + 2 * size, 0, size);
 141             state->out(tmp + 3 * size, 4, size);
 142         }
 143     }
 144
 145     printf("Checking FS ... ");
 146     status = check_block_sizes(state, 1, state->id_len);
 147     if (status)
 148         return status;
 149
 150     printf ("%s\n", CHECK_PASS);
 151     return 0;
 152 }
 153
 154 int check_se(struct test_state *state)
 155 {
 156     int status;
 157     unsigned char *tmp;
 158
 159     int size = state->bytes_per_sample;
 160
 161     if (state->strm->flags & AEC_DATA_PREPROCESS) {
 162         for (tmp = state->ubuf;
 163              tmp < state->ubuf + state->buf_len;
 164              tmp += 8 * size) {
 165             state->out(tmp, state->xmax - 1, size);
 166             state->out(tmp + size, state->xmax - 1, size);
 167             state->out(tmp + 2 * size, state->xmax - 1, size);
 168             state->out(tmp + 3 * size, state->xmax - 1, size);
 169             state->out(tmp + 4 * size, state->xmax, size);
 170             state->out(tmp + 5 * size, state->xmax, size);
 171             state->out(tmp + 6 * size, state->xmax, size);
 172             state->out(tmp + 7 * size, state->xmax, size);
 173         }
 174     } else {
 175         for (tmp = state->ubuf;
 176              tmp < state->ubuf + state->buf_len;
 177              tmp += 8 * size) {
 178             state->out(tmp, 0, size);
 179             state->out(tmp + size, 0, size);
 180             state->out(tmp + 2 * size, 0, size);
 181             state->out(tmp + 3 * size, 0, size);
 182             state->out(tmp + 4 * size, 1, size);
 183             state->out(tmp + 5 * size, 0, size);
 184             state->out(tmp + 6 * size, 0, size);
 185             state->out(tmp + 7 * size, 2, size);
 186         }
 187     }
 188
 189     printf("Checking Second Extension ... ");
 190     status = check_block_sizes(state, 1, state->id_len + 1);
 191     if (status)
 192         return status;
 193
 194     printf ("%s\n", CHECK_PASS);
 195     return 0;
 196 }
 197
 198 int check_bps(struct test_state *state)
 199 {
 200     int status;
 201
 202     for (int bps = 8; bps <= 32; bps += 8) {
 203         state->strm->bits_per_sample = bps;
 204         if (bps == 24)
 205             state->strm->flags |= AEC_DATA_3BYTE;
 206         else
 207             state->strm->flags &= ~AEC_DATA_3BYTE;
 208
 209         update_state(state);
 210
 211         status = check_zero(state);
 212         if (status)
 213             return status;
 214
 215         status = check_se(state);
 216         if (status)
 217             return status;
 218
 219         status = check_uncompressed(state);
 220         if (status)
 221             return status;
 222
 223         status = check_fs(state);
 224         if (status)
 225             return status;
 226
 227         for (int k = 1; k < bps - 2; k++) {
 228             status = check_splitting(state, k);
 229             if (status)
 230                 return status;
 231         }
 232         printf("All checks with %i bit per sample passed.\n", bps);
 233     }
 234     return 0;
 235 }
 236
 237 int check_byte_orderings(struct test_state *state)
 238 {
 239     int status;
 240
 241     printf("-----------------------------------\n");
 242     printf("Checking no PP, LSB first, unsigned\n");
 243     printf("-----------------------------------\n");
 244     status = check_bps(state);
 245     if (status)
 246         return status;
 247
 248     printf("-----------------------------------\n");
 249     printf("Checking PP, LSB first, unsigned\n");
 250     printf("-----------------------------------\n");
 251     state->strm->flags |= AEC_DATA_PREPROCESS;
 252     status = check_bps(state);
 253     if (status)
 254         return status;
 255
 256     printf("-----------------------------------\n");
 257     printf("Checking PP, LSB first, signed\n");
 258     printf("-----------------------------------\n");
 259     state->strm->flags |= AEC_DATA_SIGNED;
 260
 261     status = check_bps(state);
 262     if (status)
 263         return status;
 264
 265     state->strm->flags &= ~AEC_DATA_SIGNED;
 266     state->strm->flags |= AEC_DATA_MSB;
 267
 268     printf("-----------------------------------\n");
 269     printf("Checking PP, MSB first, unsigned\n");
 270     printf("-----------------------------------\n");
 271     status = check_bps(state);
 272     if (status)
 273         return status;
 274
 275     printf("-----------------------------------\n");
 276     printf("Checking PP, MSB first, signed\n");
 277     printf("-----------------------------------\n");
 278     state->strm->flags |= AEC_DATA_SIGNED;
 279
 280     status = check_bps(state);
 281     if (status)
 282         return status;
 283     return 0;
 284 }
 285
 286 int main(int argc, char *argv[])
 287 {
 288     int status;
 289     struct aec_stream strm;
 290     struct test_state state;
 291
 292     if (argc > 1 && strncmp(argv[1], "-d", 2) == 0)
 293         state.dump = 1;
 294     else
 295         state.dump = 0;
 296
 297     state.buf_len = state.ibuf_len = BUF_SIZE;
 298     state.cbuf_len = 2 * BUF_SIZE;
 299
 300     state.ubuf = (unsigned char *)malloc(state.buf_len);
 301     state.cbuf = (unsigned char *)malloc(state.cbuf_len);
 302     state.obuf = (unsigned char *)malloc(state.buf_len);
 303
 304     if (!state.ubuf || !state.cbuf || !state.obuf) {
 305         printf("Not enough memory.\n");
 306         return 99;
 307     }
 308
 309     strm.flags = 0;
 310     state.strm = &strm;
 311
 312     printf("***************************\n");
 313     printf("Checking with small buffers\n");
 314     printf("***************************\n");
 315     state.codec = encode_decode_small;
 316     status = check_byte_orderings(&state);
 317     if (status)
 318         goto DESTRUCT;
 319
 320     printf("***************************\n");
 321     printf("Checking with large buffers\n");
 322     printf("***************************\n");
 323     state.codec = encode_decode_large;
 324     status = check_byte_orderings(&state);
 325
 326 DESTRUCT:
 327     free(state.ubuf);
 328     free(state.cbuf);
 329     free(state.obuf);
 330
 331     return status;
 332 }