1 /*
2 * ttaenc.c
3 *
4 * Description: TTAv1 lossless audio encoder/decoder.
5 * Copyright (c) 2007, Aleksander Djuric (ald@true-audio.com)
6 * Distributed under the GNU General Public License (GPL).
7 * The complete text of the license can be found in the
8 * COPYING file included in the distribution.
9 *
10 */
11
12 #include "ttaenc.h"
13
14 /******************* static variables and structures *******************/
15
16 static unsigned char BIT_BUFFER[BIT_BUFFER_SIZE + 8];
17 static unsigned char *BIT_BUFFER_END = BIT_BUFFER + BIT_BUFFER_SIZE;
18 static unsigned char *WAVE_BUFFER;
19
20 static struct {
21 unsigned int TTAid;
22 unsigned short AudioFormat;
23 unsigned short NumChannels;
24 unsigned short BitsPerSample;
25 unsigned int SampleRate;
26 unsigned int DataLength;
27 unsigned int CRC32;
28 } __ATTRIBUTE_PACKED__ tta_hdr;
29
30 static unsigned int *seek_table;
31
32 static struct {
33 unsigned char id[3];
34 unsigned short version;
35 unsigned char flags;
36 unsigned char size[4];
37 } __ATTRIBUTE_PACKED__ id3v2;
38
39 static struct {
40 unsigned int ChunkID;
41 unsigned int ChunkSize;
42 unsigned int Format;
43 unsigned int Subchunk1ID;
44 unsigned int Subchunk1Size;
45 unsigned short AudioFormat;
46 unsigned short NumChannels;
47 unsigned int SampleRate;
48 unsigned int ByteRate;
49 unsigned short BlockAlign;
50 unsigned short BitsPerSample;
51 } __ATTRIBUTE_PACKED__ wave_hdr;
52
53 static struct {
54 unsigned int SubchunkID;
55 unsigned int SubchunkSize;
56 } subchunk_hdr;
57
58 typedef struct {
59 unsigned int f1;
60 unsigned short f2;
61 unsigned short f3;
62 char f4[8];
63 } EXT_SUBFORMAT;
64
65 typedef struct {
66 unsigned short cbSize;
67 unsigned short validBits;
68 unsigned int chMask;
69 EXT_SUBFORMAT est;
70 } EXTENSIBLE_WAV_HDR;
71
72 static uint32 frame_crc32;
73 static uint32 bit_cache;
74 static uint32 bit_count;
75
76 static unsigned char *bitpos;
77 static unsigned int lastpos;
78
79 static struct flist *files_list = NULL;
80 static struct flist *files_list_tail = NULL;
81
82 static FILE *fdin, *fdout;
83 static wchar_t file_in[_MAX_FNAME];
84 static wchar_t file_out[_MAX_FNAME];
85 static wchar_t out_path[_MAX_FNAME];
86
87 static unsigned int fixed_out = 0;
88 static unsigned int clean_src = 0;
89 static unsigned int wave_ext = 0;
90
91 static uint64 total_input_bytes;
92 static uint64 total_output_bytes;
93
94 static unsigned int input_byte_count;
95 static unsigned int output_byte_count;
96
97 const uint32 crc32_table[256] = {
98 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba,
99 0x076dc419, 0x706af48f, 0xe963a535, 0x9e6495a3,
100 0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988,
101 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91,
102 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
103 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7,
104 0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec,
105 0x14015c4f, 0x63066cd9, 0xfa0f3d63, 0x8d080df5,
106 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172,
107 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
108 0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940,
109 0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59,
110 0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116,
111 0x21b4f4b5, 0x56b3c423, 0xcfba9599, 0xb8bda50f,
112 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
113 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d,
114 0x76dc4190, 0x01db7106, 0x98d220bc, 0xefd5102a,
115 0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433,
116 0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818,
117 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
118 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e,
119 0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457,
120 0x65b0d9c6, 0x12b7e950, 0x8bbeb8ea, 0xfcb9887c,
121 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65,
122 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
123 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb,
124 0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0,
125 0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9,
126 0x5005713c, 0x270241aa, 0xbe0b1010, 0xc90c2086,
127 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
128 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4,
129 0x59b33d17, 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad,
130 0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a,
131 0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683,
132 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
133 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1,
134 0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe,
135 0xf762575d, 0x806567cb, 0x196c3671, 0x6e6b06e7,
136 0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc,
137 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
138 0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252,
139 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b,
140 0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60,
141 0xdf60efc3, 0xa867df55, 0x316e8eef, 0x4669be79,
142 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
143 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f,
144 0xc5ba3bbe, 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04,
145 0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d,
146 0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a,
147 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
148 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38,
149 0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21,
150 0x86d3d2d4, 0xf1d4e242, 0x68ddb3f8, 0x1fda836e,
151 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777,
152 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
153 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45,
154 0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2,
155 0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db,
156 0xaed16a4a, 0xd9d65adc, 0x40df0b66, 0x37d83bf0,
157 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
158 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6,
159 0xbad03605, 0xcdd70693, 0x54de5729, 0x23d967bf,
160 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94,
161 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d
162 };
163
164 const uint32 bit_mask[] = {
165 0x00000000, 0x00000001, 0x00000003, 0x00000007,
166 0x0000000f, 0x0000001f, 0x0000003f, 0x0000007f,
167 0x000000ff, 0x000001ff, 0x000003ff, 0x000007ff,
168 0x00000fff, 0x00001fff, 0x00003fff, 0x00007fff,
169 0x0000ffff, 0x0001ffff, 0x0003ffff, 0x0007ffff,
170 0x000fffff, 0x001fffff, 0x003fffff, 0x007fffff,
171 0x00ffffff, 0x01ffffff, 0x03ffffff, 0x07ffffff,
172 0x0fffffff, 0x1fffffff, 0x3fffffff, 0x7fffffff,
173 0xffffffff
174 };
175
176 const uint32 bit_shift[] = {
177 0x00000001, 0x00000002, 0x00000004, 0x00000008,
178 0x00000010, 0x00000020, 0x00000040, 0x00000080,
179 0x00000100, 0x00000200, 0x00000400, 0x00000800,
180 0x00001000, 0x00002000, 0x00004000, 0x00008000,
181 0x00010000, 0x00020000, 0x00040000, 0x00080000,
182 0x00100000, 0x00200000, 0x00400000, 0x00800000,
183 0x01000000, 0x02000000, 0x04000000, 0x08000000,
184 0x10000000, 0x20000000, 0x40000000, 0x80000000,
185 0x80000000, 0x80000000, 0x80000000, 0x80000000,
186 0x80000000, 0x80000000, 0x80000000, 0x80000000
187 };
188
189 const uint32 *shift_16 = bit_shift + 4;
190
191 struct flist;
192 struct flist {
193 wchar_t fname[_MAX_FNAME];
194 struct flist *next;
195 };
196
197 /************************* common functions ****************************/
198
print_path(wchar_t * filename,int mode)199 wchar_t *print_path(wchar_t *filename, int mode)
200 {
201 static wchar_t showname[_MAX_FNAME];
202 wchar_t *p;
203
204 if (!mode && (p = wcsrchr(filename, _SEP))) p++;
205 else p = filename;
206 wcsncpy(showname, p, _MAX_FNAME - 1);
207
208 return showname;
209 }
210
tta_error(int error,wchar_t * name)211 void tta_error(int error, wchar_t *name)
212 {
213 ERASE_STDERR;
214 switch (error) {
215 case COMMAND_ERROR:
216 fwprintf(stderr, L"Error:\tunknown command '%ls'\n%hs\n", name, LINE); break;
217 case FORMAT_ERROR:
218 fwprintf(stderr, L"Error:\tnot compatible file format\n%hs\n", LINE); break;
219 case FILE_ERROR:
220 fwprintf(stderr, L"Error:\tfile is corrupted\n%hs\n", LINE); break;
221 case FIND_ERROR:
222 fwprintf(stderr, L"Error:\tfile(s) not found '%ls'\n%hs\n\n", name, LINE); exit(1);
223 case CREATE_ERROR:
224 fwprintf(stderr, L"Error:\tproblem creating directory '%ls'\n%hs\n\n", name, LINE); exit(1);
225 case OPENR_ERROR:
226 fwprintf(stderr, L"Error:\tcan't open input file '%ls'\n%hs\n\n", name, LINE); exit(1);
227 case OPENW_ERROR:
228 fwprintf(stderr, L"Error:\tcan't open output file '%ls'\n%hs\n\n", name, LINE); exit(1);
229 case MEMORY_ERROR:
230 fwprintf(stderr, L"Error:\tinsufficient memory available\n%hs\n\n", LINE); exit(1);
231 case WRITE_ERROR:
232 fwprintf(stderr, L"Error:\tcan't write to output file\n%hs\n\n", LINE); exit(1);
233 case READ_ERROR:
234 fwprintf(stderr, L"Error:\tcan't read from input file\n%hs\n\n", LINE); exit(1);
235 }
236 }
237
tta_malloc(size_t num,size_t size)238 void *tta_malloc(size_t num, size_t size)
239 {
240 void *array;
241
242 if ((array = calloc(num, size)) == NULL)
243 tta_error(MEMORY_ERROR, NULL);
244
245 return (array);
246 }
247
248 /************************** crc32 functions ****************************/
249
250 #define UPDATE_CRC32(x, crc) crc = \
251 (((crc>>8) & 0x00FFFFFF) ^ crc32_table[(crc^x) & 0xFF])
252
253 static uint32
crc32(unsigned char * buffer,unsigned int len)254 crc32 (unsigned char *buffer, unsigned int len) {
255 unsigned int i;
256 uint32 crc = 0xFFFFFFFF;
257
258 for (i = 0; i < len; i++) UPDATE_CRC32(buffer[i], crc);
259
260 return (crc ^ 0xFFFFFFFF);
261 }
262
263 /************************* bit operations ******************************/
264
init_buffer_read(unsigned int pos)265 void init_buffer_read(unsigned int pos) {
266 frame_crc32 = 0xFFFFFFFFUL;
267 bit_count = bit_cache = lastpos = 0;
268 bitpos = BIT_BUFFER_END;
269 lastpos = pos;
270 }
271
init_buffer_write(unsigned int pos)272 void init_buffer_write(unsigned int pos) {
273 frame_crc32 = 0xFFFFFFFFUL;
274 bit_count = bit_cache = 0;
275 bitpos = BIT_BUFFER;
276 lastpos = pos;
277 }
278
get_binary(unsigned int * value,unsigned int bits)279 static __inline void get_binary(unsigned int *value, unsigned int bits) {
280 while (bit_count < bits) {
281 if (bitpos == BIT_BUFFER_END) {
282 int res = fread(BIT_BUFFER, 1,
283 BIT_BUFFER_SIZE, fdin);
284 if (!res) {
285 tta_error(READ_ERROR, NULL);
286 return;
287 }
288 input_byte_count += res;
289 bitpos = BIT_BUFFER;
290 }
291
292 UPDATE_CRC32(*bitpos, frame_crc32);
293 bit_cache |= *bitpos << bit_count;
294 bit_count += 8;
295 bitpos++;
296 }
297
298 *value = bit_cache & bit_mask[bits];
299 bit_cache >>= bits;
300 bit_count -= bits;
301 bit_cache &= bit_mask[bit_count];
302 }
303
get_unary(unsigned int * value)304 static __inline void get_unary(unsigned int *value) {
305 *value = 0;
306
307 while (!(bit_cache ^ bit_mask[bit_count])) {
308 if (bitpos == BIT_BUFFER_END) {
309 int res = fread(BIT_BUFFER, 1,
310 BIT_BUFFER_SIZE, fdin);
311 if (!res) {
312 tta_error(READ_ERROR, NULL);
313 return;
314 }
315 input_byte_count += res;
316 bitpos = BIT_BUFFER;
317 }
318
319 *value += bit_count;
320 bit_cache = *bitpos++;
321 UPDATE_CRC32(bit_cache, frame_crc32);
322 bit_count = 8;
323 }
324
325 while (bit_cache & 1) {
326 (*value)++;
327 bit_cache >>= 1;
328 bit_count--;
329 }
330
331 bit_cache >>= 1;
332 bit_count--;
333 }
334
put_binary(unsigned int value,unsigned int bits)335 static __inline void put_binary(unsigned int value, unsigned int bits) {
336 while (bit_count >= 8) {
337 if (bitpos == BIT_BUFFER_END) {
338 int res = fwrite(BIT_BUFFER, 1,
339 BIT_BUFFER_SIZE, fdout);
340 if (!res) {
341 tta_error(WRITE_ERROR, NULL);
342 return;
343 }
344 output_byte_count += res;
345 bitpos = BIT_BUFFER;
346 }
347
348 *bitpos = (unsigned char) (bit_cache & 0xFF);
349 UPDATE_CRC32(*bitpos, frame_crc32);
350 bit_cache >>= 8;
351 bit_count -= 8;
352 bitpos++;
353 }
354
355 bit_cache |= (value & bit_mask[bits]) << bit_count;
356 bit_count += bits;
357 }
358
put_unary(unsigned int value)359 static __inline void put_unary(unsigned int value) {
360 do {
361 while (bit_count >= 8) {
362 if (bitpos == BIT_BUFFER_END) {
363 int res = fwrite(BIT_BUFFER, 1,
364 BIT_BUFFER_SIZE, fdout);
365 if (!res) {
366 tta_error(WRITE_ERROR, NULL);
367 return;
368 }
369 output_byte_count += res;
370 bitpos = BIT_BUFFER;
371 }
372
373 *bitpos = (unsigned char) (bit_cache & 0xFF);
374 UPDATE_CRC32(*bitpos, frame_crc32);
375 bit_cache >>= 8;
376 bit_count -= 8;
377 bitpos++;
378 }
379
380 if (value > 23) {
381 bit_cache |= bit_mask[23] << bit_count;
382 bit_count += 23;
383 value -= 23;
384 } else {
385 bit_cache |= bit_mask[value] << bit_count;
386 bit_count += value + 1;
387 value = 0;
388 }
389 } while (value);
390 }
391
done_buffer_write()392 int done_buffer_write() {
393 unsigned int res, bytes_to_write;
394
395 while (bit_count) {
396 *bitpos = (unsigned char) (bit_cache & 0xFF);
397 UPDATE_CRC32(*bitpos, frame_crc32);
398 bit_cache >>= 8;
399 bit_count = (bit_count > 8) ? (bit_count - 8) : 0;
400 bitpos++;
401 }
402
403 frame_crc32 ^= 0xFFFFFFFFUL;
404 frame_crc32 = ENDSWAP_INT32(frame_crc32);
405 memcpy(bitpos, &frame_crc32, 4);
406 bytes_to_write = bitpos + sizeof(int) - BIT_BUFFER;
407 res = fwrite(BIT_BUFFER, 1, bytes_to_write, fdout);
408 if (!res) {
409 tta_error(WRITE_ERROR, NULL);
410 return 0;
411 }
412
413 output_byte_count += res;
414 bitpos = BIT_BUFFER;
415 frame_crc32 = 0xFFFFFFFFUL;
416
417 res = output_byte_count - lastpos;
418 lastpos = output_byte_count;
419
420 return res;
421 }
422
done_buffer_read()423 int done_buffer_read() {
424 unsigned int crc32, rbytes, res;
425 frame_crc32 ^= 0xFFFFFFFFUL;
426
427 rbytes = BIT_BUFFER_END - bitpos;
428 if (rbytes < sizeof(int)) {
429 memcpy(BIT_BUFFER, bitpos, 4);
430 res = fread(BIT_BUFFER + rbytes, 1,
431 BIT_BUFFER_SIZE - rbytes, fdin);
432 if (!res) {
433 tta_error(READ_ERROR, NULL);
434 return 1;
435 }
436 input_byte_count += res;
437 bitpos = BIT_BUFFER;
438 }
439
440 memcpy(&crc32, bitpos, 4);
441 crc32 = ENDSWAP_INT32(crc32);
442 bitpos += sizeof(int);
443 res = (crc32 != frame_crc32);
444
445 bit_cache = bit_count = 0;
446 frame_crc32 = 0xFFFFFFFFUL;
447
448 return res;
449 }
450
451 /************************** WAV functions ******************************/
452
read_wave(int * data,int byte_size,unsigned int len,FILE * fdin)453 int read_wave(int *data, int byte_size, unsigned int len, FILE *fdin) {
454 unsigned int res;
455 unsigned char *src, *end;
456 int *dst = data;
457
458 src = WAVE_BUFFER;
459 if (!(res = fread(WAVE_BUFFER, byte_size, len, fdin)))
460 tta_error(READ_ERROR, NULL);
461 end = WAVE_BUFFER + res * byte_size;
462
463 switch (byte_size) {
464 case 1: for (; src < end; dst++)
465 *dst = (signed int) *src++ - 0x80;
466 break;
467 case 2: for (; src < end; dst++) {
468 *dst = (unsigned char) *src++;
469 *dst |= (signed char) *src++ << 8;
470 }
471 break;
472 case 3: for (; src < end; dst++) {
473 *dst = (unsigned char) *src++;
474 *dst |= (unsigned char) *src++ << 8;
475 *dst |= (signed char) *src++ << 16;
476 }
477 break;
478 }
479
480 return res;
481 }
482
483 int
write_wave(int * data,int byte_size,int num_chan,unsigned int len,FILE * fdout)484 write_wave(int *data, int byte_size, int num_chan, unsigned int len, FILE *fdout) {
485 unsigned int res;
486 int *src = data, *end;
487 unsigned char *dst;
488
489 dst = WAVE_BUFFER;
490 end = data + len;
491
492 switch (byte_size) {
493 case 1: for (; src < end; src++)
494 *dst++ = (unsigned char) (*src + 0x80);
495 break;
496 case 2: for (; src < end; src++) {
497 *dst++ = (unsigned char) *src;
498 *dst++ = (unsigned char) (*src >> 8);
499 }
500 break;
501 case 3: for (; src < end; src++) {
502 *dst++ = (unsigned char) *src;
503 *dst++ = (unsigned char) (*src >> 8);
504 *dst++ = (unsigned char) (*src >> 16);
505 }
506 break;
507 }
508
509 if (!(res = fwrite(WAVE_BUFFER, byte_size, len, fdout)))
510 tta_error(WRITE_ERROR, NULL);
511
512 return res;
513 }
514
515 /************************* filter functions ****************************/
516
memshl(register int * pA,register int * pB)517 static __inline void memshl (register int *pA, register int *pB) {
518 *pA++ = *pB++;
519 *pA++ = *pB++;
520 *pA++ = *pB++;
521 *pA++ = *pB++;
522 *pA++ = *pB++;
523 *pA++ = *pB++;
524 *pA++ = *pB++;
525 *pA = *pB;
526 }
527
hybrid_filter(fltst * fs,int * in,int mode)528 static __inline void hybrid_filter (fltst *fs, int *in, int mode) {
529 register int *pA = fs->dl;
530 register int *pB = fs->qm;
531 register int *pM = fs->dx;
532 register int sum = fs->round;
533
534 if (!fs->error) {
535 sum += *pA++ * *pB, pB++;
536 sum += *pA++ * *pB, pB++;
537 sum += *pA++ * *pB, pB++;
538 sum += *pA++ * *pB, pB++;
539 sum += *pA++ * *pB, pB++;
540 sum += *pA++ * *pB, pB++;
541 sum += *pA++ * *pB, pB++;
542 sum += *pA++ * *pB, pB++; pM += 8;
543 } else if (fs->error < 0) {
544 sum += *pA++ * (*pB -= *pM++), pB++;
545 sum += *pA++ * (*pB -= *pM++), pB++;
546 sum += *pA++ * (*pB -= *pM++), pB++;
547 sum += *pA++ * (*pB -= *pM++), pB++;
548 sum += *pA++ * (*pB -= *pM++), pB++;
549 sum += *pA++ * (*pB -= *pM++), pB++;
550 sum += *pA++ * (*pB -= *pM++), pB++;
551 sum += *pA++ * (*pB -= *pM++), pB++;
552 } else {
553 sum += *pA++ * (*pB += *pM++), pB++;
554 sum += *pA++ * (*pB += *pM++), pB++;
555 sum += *pA++ * (*pB += *pM++), pB++;
556 sum += *pA++ * (*pB += *pM++), pB++;
557 sum += *pA++ * (*pB += *pM++), pB++;
558 sum += *pA++ * (*pB += *pM++), pB++;
559 sum += *pA++ * (*pB += *pM++), pB++;
560 sum += *pA++ * (*pB += *pM++), pB++;
561 }
562
563 *(pM-0) = ((*(pA-1) >> 30) | 1) << 2;
564 *(pM-1) = ((*(pA-2) >> 30) | 1) << 1;
565 *(pM-2) = ((*(pA-3) >> 30) | 1) << 1;
566 *(pM-3) = ((*(pA-4) >> 30) | 1);
567
568 if (mode) {
569 *pA = *in;
570 *in -= (sum >> fs->shift);
571 fs->error = *in;
572 } else {
573 fs->error = *in;
574 *in += (sum >> fs->shift);
575 *pA = *in;
576 }
577
578 *(pA-1) = *(pA-0) - *(pA-1);
579 *(pA-2) = *(pA-1) - *(pA-2);
580 *(pA-3) = *(pA-2) - *(pA-3);
581
582 memshl (fs->dl, fs->dl + 1);
583 memshl (fs->dx, fs->dx + 1);
584 }
585
filter_init(fltst * fs,int shift)586 void filter_init (fltst *fs, int shift) {
587 memset (fs, 0, sizeof(fltst));
588 fs->shift = shift;
589 fs->round = 1 << (shift - 1);
590 }
591
592 /************************* basic functions *****************************/
593
rice_init(adapt * rice,unsigned int k0,unsigned int k1)594 void rice_init(adapt *rice, unsigned int k0, unsigned int k1) {
595 rice->k0 = k0;
596 rice->k1 = k1;
597 rice->sum0 = shift_16[k0];
598 rice->sum1 = shift_16[k1];
599 }
600
encoder_init(encoder * tta,int nch,int byte_size)601 void encoder_init(encoder *tta, int nch, int byte_size) {
602 int flt_set [3] = { 10, 9, 10 };
603 int i;
604
605 for (i = 0; i < nch; i++) {
606 filter_init(&tta[i].fst, flt_set[byte_size - 1]);
607 rice_init(&tta[i].rice, 10, 10);
608 tta[i].last = 0;
609 }
610 }
611
compress(FILE * fdin,FILE * fdout)612 int compress(FILE *fdin, FILE *fdout)
613 {
614 int *p, *data, tmp, prev;
615 unsigned int num_chan, data_size, byte_size, data_len;
616 unsigned int buffer_len, framelen, lastlen, fframes;
617 unsigned int value, k, unary, binary;
618 unsigned int st_size, *st, offset = 0;
619 unsigned int def_subchunk_size = 16;
620 encoder *tta, *enc;
621 time_t stime = time(NULL);
622
623 // clear statistics
624 input_byte_count = output_byte_count = 0;
625
626 // print process banner
627 fwprintf(stderr, L"Encode:\t..\r");
628
629 // copy ID3V2 header if present
630 if (!fread(&id3v2, sizeof(id3v2), 1, fdin))
631 tta_error(READ_ERROR, NULL);
632
633 if (!memcmp(id3v2.id, "ID3", 3)) {
634 char buffer[512];
635
636 if (id3v2.size[0] & 0x80) {
637 tta_error(FILE_ERROR, NULL);
638 return 1;
639 }
640
641 offset = (id3v2.size[0] & 0x7f);
642 offset = (offset << 7) | (id3v2.size[1] & 0x7f);
643 offset = (offset << 7) | (id3v2.size[2] & 0x7f);
644 offset = (offset << 7) | (id3v2.size[3] & 0x7f);
645 if (id3v2.flags & (1 << 4)) offset += 10;
646 data_len = offset, offset += 10;
647
648 // write ID3V2 header
649 if (!fwrite(&id3v2, sizeof(id3v2), 1, fdout))
650 tta_error(WRITE_ERROR, NULL);
651
652 while (data_len > 0) {
653 int len = (data_len > sizeof(buffer))? sizeof(buffer):data_len;
654 if (!fread(buffer, len, 1, fdin)) tta_error(READ_ERROR, NULL);
655 if (!fwrite(buffer, len, 1, fdout)) tta_error(WRITE_ERROR, NULL);
656 input_byte_count += len;
657 output_byte_count += len;
658 data_len -= len;
659 }
660
661 input_byte_count = output_byte_count = offset;
662 } else {
663 fseek(fdin, 0, SEEK_SET);
664 if (ferror(fdin)) tta_error(READ_ERROR, NULL);
665 }
666
667 // read WAVE header
668 if (!fread(&wave_hdr, sizeof(wave_hdr), 1, fdin))
669 tta_error(READ_ERROR, NULL);
670 input_byte_count += sizeof(wave_hdr);
671
672 wave_hdr.ChunkID = ENDSWAP_INT32(wave_hdr.ChunkID);
673 wave_hdr.ChunkSize = ENDSWAP_INT32(wave_hdr.ChunkSize);
674 wave_hdr.Format = ENDSWAP_INT32(wave_hdr.Format);
675 wave_hdr.Subchunk1ID = ENDSWAP_INT32(wave_hdr.Subchunk1ID);
676 wave_hdr.Subchunk1Size = ENDSWAP_INT32(wave_hdr.Subchunk1Size);
677 wave_hdr.AudioFormat = ENDSWAP_INT16(wave_hdr.AudioFormat);
678 wave_hdr.NumChannels = ENDSWAP_INT16(wave_hdr.NumChannels);
679 wave_hdr.SampleRate = ENDSWAP_INT32(wave_hdr.SampleRate);
680 wave_hdr.ByteRate = ENDSWAP_INT32(wave_hdr.ByteRate);
681 wave_hdr.BlockAlign = ENDSWAP_INT16(wave_hdr.BlockAlign);
682 wave_hdr.BitsPerSample = ENDSWAP_INT16(wave_hdr.BitsPerSample);
683
684 // check for supported formats
685 if ((wave_hdr.ChunkID != RIFF_SIGN) ||
686 (wave_hdr.Format != WAVE_SIGN) ||
687 (wave_hdr.Subchunk1ID != fmt_SIGN) ||
688 (wave_hdr.Subchunk1Size > wave_hdr.ChunkSize) ||
689 (wave_hdr.NumChannels == 0) ||
690 (wave_hdr.BitsPerSample > MAX_BPS)) {
691
692 tta_error(FORMAT_ERROR, NULL);
693 return 1;
694 }
695
696 if (wave_hdr.AudioFormat == WAVE_FORMAT_EXTENSIBLE) {
697 EXTENSIBLE_WAV_HDR wave_hdr_ex;
698
699 if (!fread(&wave_hdr_ex, sizeof(wave_hdr_ex), 1, fdin))
700 tta_error(READ_ERROR, NULL);
701 input_byte_count += sizeof(wave_hdr_ex);
702
703 def_subchunk_size += sizeof(wave_hdr_ex);
704 wave_hdr.AudioFormat = ENDSWAP_INT32(wave_hdr_ex.est.f1);
705 }
706
707 if (wave_hdr.AudioFormat != WAVE_FORMAT_PCM ||
708 wave_hdr.BitsPerSample > MAX_BPS) {
709 tta_error(FORMAT_ERROR, NULL);
710 return 1;
711 }
712
713 // skip extra format bytes
714 if (wave_hdr.Subchunk1Size > def_subchunk_size) {
715 unsigned int extra_len = wave_hdr.Subchunk1Size - def_subchunk_size;
716
717 fseek(fdin, extra_len, SEEK_CUR);
718 if (ferror(fdin)) tta_error(READ_ERROR, NULL);
719 input_byte_count += extra_len;
720
721 fwprintf(stderr, L"Encode:\tskiped %ld extra format bytes\n", extra_len);
722 }
723
724 // skip unsupported chunks
725 while (1) {
726 char chunk_id[5];
727
728 if (!fread(&subchunk_hdr, sizeof(subchunk_hdr), 1, fdin))
729 tta_error(READ_ERROR, NULL);
730 input_byte_count += sizeof(subchunk_hdr);
731
732 subchunk_hdr.SubchunkSize = ENDSWAP_INT32(subchunk_hdr.SubchunkSize);
733 subchunk_hdr.SubchunkID = ENDSWAP_INT32(subchunk_hdr.SubchunkID);
734 if (subchunk_hdr.SubchunkID == data_SIGN) break;
735
736 if (subchunk_hdr.SubchunkSize & 0x80000000UL) {
737 tta_error(FILE_ERROR, NULL);
738 return 1;
739 }
740
741 fseek(fdin, subchunk_hdr.SubchunkSize, SEEK_CUR);
742 if (ferror(fdin)) tta_error(READ_ERROR, NULL);
743 input_byte_count += subchunk_hdr.SubchunkSize;
744
745 memcpy(chunk_id, &subchunk_hdr.SubchunkID, 4);
746 chunk_id[4] = 0;
747
748 fwprintf(stderr, L"Encode:\tskiped unsupported '%hs' chunk\n", chunk_id);
749 }
750
751 framelen = (int) (FRAME_TIME * wave_hdr.SampleRate);
752 num_chan = wave_hdr.NumChannels;
753 data_size = subchunk_hdr.SubchunkSize;
754 byte_size = (wave_hdr.BitsPerSample + 7) / 8;
755 data_len = data_size / (byte_size * num_chan);
756
757 lastlen = data_len % framelen;
758 fframes = data_len / framelen + (lastlen ? 1 : 0);
759 st_size = (fframes + 1);
760 buffer_len = num_chan * framelen;
761
762 tta_hdr.TTAid = ENDSWAP_INT32(TTA1_SIGN);
763 tta_hdr.AudioFormat = ENDSWAP_INT16(wave_hdr.AudioFormat);
764 tta_hdr.NumChannels = ENDSWAP_INT16(wave_hdr.NumChannels);
765 tta_hdr.BitsPerSample = ENDSWAP_INT16(wave_hdr.BitsPerSample);
766 tta_hdr.SampleRate = ENDSWAP_INT32(wave_hdr.SampleRate);
767 tta_hdr.DataLength = ENDSWAP_INT32(data_len);
768 tta_hdr.CRC32 = crc32((unsigned char *) &tta_hdr,
769 sizeof(tta_hdr) - sizeof(int));
770 tta_hdr.CRC32 = ENDSWAP_INT32(tta_hdr.CRC32);
771
772 // grab some space for an encoder buffers
773 data = (int *) tta_malloc(buffer_len, sizeof(int));
774 st = seek_table = (unsigned int *) tta_malloc(st_size, sizeof(int));
775 enc = tta = tta_malloc(num_chan, sizeof(encoder));
776 WAVE_BUFFER = (unsigned char *) tta_malloc(buffer_len, byte_size);
777
778 // write TTA header
779 if (!fwrite(&tta_hdr, sizeof(tta_hdr), 1, fdout))
780 tta_error(WRITE_ERROR, NULL);
781 else output_byte_count += sizeof(tta_hdr);
782
783 // allocate space for a seek table
784 if (!fwrite(seek_table, st_size, sizeof(int), fdout))
785 tta_error(WRITE_ERROR, NULL);
786 else output_byte_count += st_size * sizeof(int);
787
788 // init bit writer
789 init_buffer_write(output_byte_count);
790
791 while (fframes--) {
792 if (!fframes && lastlen)
793 buffer_len = num_chan * (framelen = lastlen);
794
795 read_wave(data, byte_size, buffer_len, fdin);
796 encoder_init(tta, num_chan, byte_size);
797
798 for (p = data, prev = 0; p < data + buffer_len; p++) {
799 fltst *fst = &enc->fst;
800 adapt *rice = &enc->rice;
801 int *last = &enc->last;
802
803 // transform data
804 if (enc < tta + num_chan - 1)
805 *p = prev = *(p + 1) - *p;
806 else *p -= prev / 2;
807
808 // compress stage 1: fixed order 1 prediction
809 tmp = *p;
810 switch (byte_size) {
811 case 1: *p -= PREDICTOR1(*last, 4); break; // bps 8
812 case 2: *p -= PREDICTOR1(*last, 5); break; // bps 16
813 case 3: *p -= PREDICTOR1(*last, 5); break; // bps 24
814 } *last = tmp;
815
816 // compress stage 2: adaptive hybrid filter
817 hybrid_filter(fst, p, 1);
818
819 value = ENC(*p);
820
821 // encode Rice unsigned
822 k = rice->k0;
823
824 rice->sum0 += value - (rice->sum0 >> 4);
825 if (rice->k0 > 0 && rice->sum0 < shift_16[rice->k0])
826 rice->k0--;
827 else if (rice->sum0 > shift_16[rice->k0 + 1])
828 rice->k0++;
829
830 if (value >= bit_shift[k]) {
831 value -= bit_shift[k];
832 k = rice->k1;
833
834 rice->sum1 += value - (rice->sum1 >> 4);
835 if (rice->k1 > 0 && rice->sum1 < shift_16[rice->k1])
836 rice->k1--;
837 else if (rice->sum1 > shift_16[rice->k1 + 1])
838 rice->k1++;
839
840 unary = 1 + (value >> k);
841 } else unary = 0;
842
843 put_unary(unary);
844 if (k) {
845 binary = value & bit_mask[k];
846 put_binary(binary, k);
847 }
848
849 if (enc < tta + num_chan - 1) enc++;
850 else enc = tta;
851 }
852
853 *st++ = done_buffer_write();
854
855 input_byte_count += byte_size * buffer_len;
856 }
857
858 // update the seek table
859 fseek(fdout, sizeof(tta_hdr) + offset, SEEK_SET);
860 if (ferror(fdout)) tta_error(WRITE_ERROR, NULL);
861
862 for (st = seek_table; st < (seek_table + st_size - 1); st++)
863 *st = ENDSWAP_INT32(*st);
864 seek_table[st_size - 1] = crc32((unsigned char *) seek_table,
865 (st_size - 1) * sizeof(int));
866 seek_table[st_size - 1] = ENDSWAP_INT32(seek_table[st_size - 1]);
867 if (!fwrite(seek_table, st_size, sizeof(int), fdout))
868 tta_error(WRITE_ERROR, NULL);
869
870 free(WAVE_BUFFER);
871 free(seek_table);
872 free(data);
873 free(tta);
874
875 fwprintf(stderr, L"Encode:\tcomplete, wrote %ld bytes, ratio: %.2f, time: %d\n",
876 (int) output_byte_count,
877 (float) output_byte_count / (input_byte_count + 1),
878 (int) (time(NULL) - stime));
879 fwprintf(stderr, L"%hs\n", LINE);
880
881 return 0;
882 }
883
test_file(FILE * fdin)884 int test_file(FILE *fdin) {
885 unsigned int byte_size, data_size, checksum, errors;
886 unsigned int framelen, lastlen, fframes;
887 unsigned int framesize, st_size, *st;
888 unsigned char *data;
889
890 // clear statistics
891 input_byte_count = output_byte_count = 0;
892
893 // print process banner
894 fwprintf(stderr, L"Test:\t..\r");
895
896 // skip ID3V2 header
897 if (!fread(&id3v2, sizeof(id3v2), 1, fdin))
898 tta_error(READ_ERROR, NULL);
899
900 if (!memcmp(id3v2.id, "ID3", 3)) {
901 int len;
902
903 if (id3v2.size[0] & 0x80) {
904 fwprintf(stderr, L"Error:\tID3 header is corrupted\n");
905 return 1;
906 }
907
908 len = (id3v2.size[0] & 0x7f);
909 len = (len << 7) | (id3v2.size[1] & 0x7f);
910 len = (len << 7) | (id3v2.size[2] & 0x7f);
911 len = (len << 7) | (id3v2.size[3] & 0x7f);
912 len += 10;
913 if (id3v2.flags & (1 << 4)) len += 10;
914
915 fseek(fdin, len, SEEK_SET);
916 input_byte_count += len;
917 } else fseek(fdin, 0, SEEK_SET);
918
919 // read TTA header
920 if (!fread(&tta_hdr, sizeof(tta_hdr), 1, fdin))
921 tta_error(READ_ERROR, NULL);
922 else input_byte_count += sizeof(tta_hdr);
923
924 // check for supported formats
925 if (ENDSWAP_INT32(tta_hdr.TTAid) != TTA1_SIGN) {
926 fwprintf(stderr, L"Error:\tTTA ID is not found\n");
927 return 1;
928 }
929
930 tta_hdr.AudioFormat = ENDSWAP_INT16(tta_hdr.AudioFormat);
931 tta_hdr.NumChannels = ENDSWAP_INT16(tta_hdr.NumChannels);
932 tta_hdr.BitsPerSample = ENDSWAP_INT16(tta_hdr.BitsPerSample);
933 tta_hdr.SampleRate = ENDSWAP_INT32(tta_hdr.SampleRate);
934 tta_hdr.DataLength = ENDSWAP_INT32(tta_hdr.DataLength);
935
936 tta_hdr.CRC32 = ENDSWAP_INT32(tta_hdr.CRC32);
937 checksum = crc32((unsigned char *) &tta_hdr,
938 sizeof(tta_hdr) - sizeof(int));
939 if (checksum != tta_hdr.CRC32) {
940 fwprintf(stderr, L"Error:\tHeader checksum failed\n");
941 return 1;
942 }
943
944 byte_size = (tta_hdr.BitsPerSample + 7) / 8;
945 framelen = (int) (FRAME_TIME * tta_hdr.SampleRate);
946 data_size = tta_hdr.DataLength * byte_size * tta_hdr.NumChannels;
947 framesize = framelen * tta_hdr.NumChannels * byte_size + 4;
948 lastlen = tta_hdr.DataLength % framelen;
949 fframes = tta_hdr.DataLength / framelen + (lastlen ? 1 : 0);
950 st_size = (fframes + 1);
951
952 // grab some space for a buffer
953 data = (unsigned char *) tta_malloc(framesize, 1);
954 seek_table = (unsigned int *) tta_malloc(st_size, sizeof(int));
955
956 // read seek table
957 if (!fread(seek_table, st_size, sizeof(int), fdin))
958 tta_error(READ_ERROR, NULL);
959 else input_byte_count += st_size * sizeof(int);
960
961 checksum = crc32((unsigned char *) seek_table,
962 (st_size - 1) * sizeof(int));
963 if (checksum != ENDSWAP_INT32(seek_table[st_size - 1])) {
964 fwprintf(stderr, L"Error:\tseek table corrupted\n");
965 free(seek_table);
966 free(data);
967 return 1;
968 }
969
970 // check frames
971 for (st = seek_table, errors = 0;
972 st < (seek_table + st_size - 1); st++) {
973 int ret = 0;
974
975 *st = ENDSWAP_INT32(*st);
976 ret = fread(data, 1, *st, fdin);
977 if (!ret) tta_error(READ_ERROR, NULL);
978 input_byte_count += ret;
979
980 memcpy(&frame_crc32, data + (ret - 4), 4);
981 checksum = crc32(data, *st - 4);
982
983 if (checksum != ENDSWAP_INT32(frame_crc32))
984 errors++;
985 }
986
987 free(seek_table);
988 free(data);
989
990 if (errors) {
991 fwprintf(stderr, L"Test:\tfailed, %d frame(s) corrupted\n", (int)errors);
992 return 1;
993 }
994
995 fwprintf(stderr, L"Test:\tcomplete\n");
996
997 return 0;
998 }
999
decompress(FILE * fdin,FILE * fdout)1000 int decompress(FILE *fdin, FILE *fdout) {
1001 int *p, *data, value;
1002 unsigned int num_chan, data_size, byte_size, checksum;
1003 unsigned int buffer_len, framelen, lastlen, fframes;
1004 unsigned int k, depth, unary, binary = 0;
1005 unsigned int st_size, st_state, *st;
1006 unsigned int def_subchunk_size = 16;
1007 encoder *tta, *enc;
1008 time_t stime = time(NULL);
1009
1010 // clear statistics
1011 input_byte_count = output_byte_count = 0;
1012
1013 // print process banner
1014 fwprintf(stderr, L"Decode:\t..\r");
1015
1016 // skip ID3V2 header
1017 if (!fread(&id3v2, sizeof(id3v2), 1, fdin))
1018 tta_error(READ_ERROR, NULL);
1019 if (!memcmp(id3v2.id, "ID3", 3)) {
1020 int len;
1021
1022 if (id3v2.size[0] & 0x80) {
1023 tta_error(FILE_ERROR, NULL);
1024 return 1;
1025 }
1026
1027 len = (id3v2.size[0] & 0x7f);
1028 len = (len << 7) | (id3v2.size[1] & 0x7f);
1029 len = (len << 7) | (id3v2.size[2] & 0x7f);
1030 len = (len << 7) | (id3v2.size[3] & 0x7f);
1031 len += 10;
1032 if (id3v2.flags & (1 << 4)) len += 10;
1033
1034 fseek(fdin, len, SEEK_SET);
1035 input_byte_count += len;
1036 } else fseek(fdin, 0, SEEK_SET);
1037
1038 // read TTA header
1039 if (!fread(&tta_hdr, sizeof(tta_hdr), 1, fdin))
1040 tta_error(READ_ERROR, NULL);
1041 else input_byte_count += sizeof(tta_hdr);
1042
1043 // check for supported formats
1044 if (ENDSWAP_INT32(tta_hdr.TTAid) != TTA1_SIGN) {
1045 tta_error(FORMAT_ERROR, NULL);
1046 return 1;
1047 }
1048
1049 tta_hdr.CRC32 = ENDSWAP_INT32(tta_hdr.CRC32);
1050 checksum = crc32((unsigned char *) &tta_hdr,
1051 sizeof(tta_hdr) - sizeof(int));
1052 if (checksum != tta_hdr.CRC32) {
1053 tta_error(FILE_ERROR, NULL);
1054 return 1;
1055 }
1056
1057 tta_hdr.AudioFormat = ENDSWAP_INT16(tta_hdr.AudioFormat);
1058 tta_hdr.NumChannels = ENDSWAP_INT16(tta_hdr.NumChannels);
1059 tta_hdr.BitsPerSample = ENDSWAP_INT16(tta_hdr.BitsPerSample);
1060 tta_hdr.SampleRate = ENDSWAP_INT32(tta_hdr.SampleRate);
1061 tta_hdr.DataLength = ENDSWAP_INT32(tta_hdr.DataLength);
1062
1063 if (tta_hdr.AudioFormat != WAVE_FORMAT_PCM ||
1064 tta_hdr.BitsPerSample > MAX_BPS) {
1065 tta_error(FORMAT_ERROR, NULL);
1066 return 1;
1067 }
1068
1069 byte_size = (tta_hdr.BitsPerSample + 7) / 8;
1070 framelen = (int) (FRAME_TIME * tta_hdr.SampleRate);
1071 num_chan = tta_hdr.NumChannels;
1072 data_size = tta_hdr.DataLength * byte_size * num_chan;
1073
1074 if (wave_ext) {
1075 def_subchunk_size += sizeof(EXTENSIBLE_WAV_HDR);
1076 wave_hdr.AudioFormat = ENDSWAP_INT16(WAVE_FORMAT_EXTENSIBLE);
1077 } else wave_hdr.AudioFormat = ENDSWAP_INT16(tta_hdr.AudioFormat);
1078
1079 wave_hdr.ChunkID = ENDSWAP_INT32(RIFF_SIGN);
1080 wave_hdr.ChunkSize = ENDSWAP_INT32(data_size + 36);
1081 wave_hdr.Format = ENDSWAP_INT32(WAVE_SIGN);
1082 wave_hdr.Subchunk1ID = ENDSWAP_INT32(fmt_SIGN);
1083 wave_hdr.Subchunk1Size = ENDSWAP_INT32(def_subchunk_size);
1084 wave_hdr.NumChannels = ENDSWAP_INT16((unsigned short) num_chan);
1085 wave_hdr.SampleRate = ENDSWAP_INT32(tta_hdr.SampleRate);
1086 wave_hdr.BitsPerSample = ENDSWAP_INT16(tta_hdr.BitsPerSample);
1087 wave_hdr.ByteRate = tta_hdr.SampleRate * byte_size * num_chan;
1088 wave_hdr.ByteRate = ENDSWAP_INT32(wave_hdr.ByteRate);
1089 wave_hdr.BlockAlign = (unsigned short) (num_chan * byte_size);
1090 wave_hdr.BlockAlign = ENDSWAP_INT16(wave_hdr.BlockAlign);
1091 subchunk_hdr.SubchunkID = ENDSWAP_INT32(data_SIGN);
1092 subchunk_hdr.SubchunkSize = ENDSWAP_INT32(data_size);
1093
1094 lastlen = tta_hdr.DataLength % framelen;
1095 fframes = tta_hdr.DataLength / framelen + (lastlen ? 1 : 0);
1096 st_size = (fframes + 1);
1097 st_state = 0;
1098 buffer_len = num_chan * framelen;
1099
1100 // grab some space for a buffer
1101 data = (int *) tta_malloc(buffer_len, sizeof(int));
1102 enc = tta = tta_malloc(num_chan, sizeof(encoder));
1103 seek_table = (unsigned int *) tta_malloc(st_size, sizeof(int));
1104 WAVE_BUFFER = (unsigned char *) tta_malloc(buffer_len, byte_size);
1105
1106 // read seek table
1107 if (!fread(seek_table, st_size, sizeof(int), fdin))
1108 tta_error(READ_ERROR, NULL);
1109 else input_byte_count += st_size * sizeof(int);
1110
1111 checksum = crc32((unsigned char *) seek_table,
1112 (st_size - 1) * sizeof(int));
1113 if (checksum != ENDSWAP_INT32(seek_table[st_size - 1]))
1114 fwprintf(stderr, L"Decode:\twarning, seek table corrupted\n");
1115 else st_state = 1;
1116
1117 for (st = seek_table; st < (seek_table + st_size); st++)
1118 *st = ENDSWAP_INT32(*st);
1119
1120 // write WAVE header
1121 if (!fwrite(&wave_hdr, sizeof(wave_hdr), 1, fdout))
1122 tta_error(WRITE_ERROR, NULL);
1123 else output_byte_count += sizeof(wave_hdr);
1124
1125 if (wave_ext) {
1126 EXTENSIBLE_WAV_HDR wave_hdr_ex;
1127 unsigned int chMask = 0;
1128
1129 switch (tta_hdr.NumChannels) {
1130 case 2: chMask = 0x00000003; break;
1131 case 3: chMask = 0x0000000B; break;
1132 case 4: chMask = 0x00000033; break;
1133 case 6: chMask = 0x0000003F; break;
1134 case 7: chMask = 0x0000013F; break;
1135 case 8: chMask = 0x000000FF; break;
1136 };
1137
1138 wave_hdr_ex.cbSize = ENDSWAP_INT16(22);
1139 wave_hdr_ex.validBits = ENDSWAP_INT16(wave_hdr.BitsPerSample);
1140 wave_hdr_ex.chMask = ENDSWAP_INT32(chMask);
1141 wave_hdr_ex.est.f1 = ENDSWAP_INT32(tta_hdr.AudioFormat);
1142 wave_hdr_ex.est.f2 = 0;
1143 wave_hdr_ex.est.f3 = ENDSWAP_INT16(0x10);
1144 wave_hdr_ex.est.f4[0] = 0x80;
1145 wave_hdr_ex.est.f4[1] = 0x00;
1146 wave_hdr_ex.est.f4[2] = 0x00;
1147 wave_hdr_ex.est.f4[3] = 0xaa;
1148 wave_hdr_ex.est.f4[4] = 0x00;
1149 wave_hdr_ex.est.f4[5] = 0x38;
1150 wave_hdr_ex.est.f4[6] = 0x9b;
1151 wave_hdr_ex.est.f4[7] = 0x71;
1152
1153 if (!fwrite(&wave_hdr_ex, sizeof(wave_hdr_ex), 1, fdout))
1154 tta_error(WRITE_ERROR, NULL);
1155 else output_byte_count += sizeof(wave_hdr_ex);
1156 }
1157
1158 // write Subchunk header
1159 if (!fwrite(&subchunk_hdr, sizeof(subchunk_hdr), 1, fdout))
1160 tta_error(WRITE_ERROR, NULL);
1161 else output_byte_count += sizeof(subchunk_hdr);
1162
1163 // init bit reader
1164 init_buffer_read(input_byte_count);
1165
1166 st = seek_table;
1167 while (fframes--) {
1168 if (!fframes && lastlen)
1169 buffer_len = num_chan * (framelen = lastlen);
1170
1171 encoder_init(tta, num_chan, byte_size);
1172 for (p = data; p < data + buffer_len; p++) {
1173 fltst *fst = &enc->fst;
1174 adapt *rice = &enc->rice;
1175 int *last = &enc->last;
1176
1177 // decode Rice unsigned
1178 get_unary(&unary);
1179
1180 switch (unary) {
1181 case 0: depth = 0; k = rice->k0; break;
1182 default:
1183 depth = 1; k = rice->k1;
1184 unary--;
1185 }
1186
1187 if (k) {
1188 get_binary(&binary, k);
1189 value = (unary << k) + binary;
1190 } else value = unary;
1191
1192 switch (depth) {
1193 case 1:
1194 rice->sum1 += value - (rice->sum1 >> 4);
1195 if (rice->k1 > 0 && rice->sum1 < shift_16[rice->k1])
1196 rice->k1--;
1197 else if (rice->sum1 > shift_16[rice->k1 + 1])
1198 rice->k1++;
1199 value += bit_shift[rice->k0];
1200 default:
1201 rice->sum0 += value - (rice->sum0 >> 4);
1202 if (rice->k0 > 0 && rice->sum0 < shift_16[rice->k0])
1203 rice->k0--;
1204 else if (rice->sum0 > shift_16[rice->k0 + 1])
1205 rice->k0++;
1206 }
1207
1208 *p = DEC(value);
1209
1210 // decompress stage 1: adaptive hybrid filter
1211 hybrid_filter(fst, p, 0);
1212
1213 // decompress stage 2: fixed order 1 prediction
1214 switch (byte_size) {
1215 case 1: *p += PREDICTOR1(*last, 4); break; // bps 8
1216 case 2: *p += PREDICTOR1(*last, 5); break; // bps 16
1217 case 3: *p += PREDICTOR1(*last, 5); break; // bps 24
1218 } *last = *p;
1219
1220 if (enc < tta + num_chan - 1) enc++;
1221 else {
1222 if (num_chan > 1) {
1223 int *r = p - 1;
1224 for (*p += *r/2; r > p - num_chan; r--)
1225 *r = *(r + 1) - *r;
1226 }
1227 enc = tta;
1228 }
1229 }
1230
1231 lastpos += *st++;
1232
1233 if (done_buffer_read()) {
1234 if (st_state) {
1235 ERASE_STDERR;
1236 fwprintf(stderr, L"Decode:\tchecksum error, %ld samples wiped\n", framelen);
1237 memset(data, 0, buffer_len * sizeof(int));
1238 fseek(fdin, lastpos, SEEK_SET);
1239 init_buffer_read(lastpos);
1240 } else {
1241 tta_error(FILE_ERROR, NULL);
1242 goto done;
1243 }
1244 fflush(stderr);
1245 }
1246
1247 output_byte_count +=
1248 write_wave(data, byte_size, num_chan, buffer_len, fdout) * byte_size;
1249 }
1250
1251 done:
1252
1253 free(WAVE_BUFFER);
1254 free(seek_table);
1255 free(data);
1256 free(tta);
1257
1258 fwprintf(stderr, L"Decode:\tcomplete, wrote %ld bytes, ratio: %.2f, time: %d\n",
1259 (int) (output_byte_count),
1260 (float) output_byte_count / (input_byte_count + 1),
1261 (int) (time(NULL) - stime));
1262 fwprintf(stderr, L"%hs\n", LINE);
1263
1264 return 0;
1265 }
1266
path_strcat(wchar_t * pstr1,wchar_t * pstr2)1267 void path_strcat(wchar_t *pstr1, wchar_t *pstr2) {
1268 int len;
1269
1270 len = wcslen(pstr1);
1271 if (len && (pstr1[len] != _SEP))
1272 pstr1[len++] = _SEP;
1273
1274 wcsncat(pstr1, pstr2, _MAX_FNAME - len - 1);
1275 }
1276
add_to_files_list(wchar_t * path,struct flist ** head,struct flist ** tail)1277 void add_to_files_list(wchar_t *path, struct flist **head, struct flist **tail) {
1278 struct flist *new_item;
1279
1280 new_item = (struct flist *) tta_malloc(1, sizeof(struct flist));
1281 wcscpy(new_item->fname, path);
1282 new_item->next = NULL;
1283
1284 if (*head == NULL) *head = *tail = new_item;
1285 else *tail = (*tail)->next = new_item;
1286 }
1287
clear_files_list(void)1288 void clear_files_list(void) {
1289 struct flist *item;
1290
1291 while (files_list != NULL) {
1292 item = files_list;
1293 files_list = files_list->next;
1294 free(item);
1295 }
1296 }
1297
usage(void)1298 void usage(void) {
1299 fwprintf(stderr, L"usage:\t%hs [command] [options] file(s).. <output path/>\n\n", MYNAME);
1300 fwprintf(stderr, L"%hs\n", LINE);
1301 fwprintf(stderr, L"commands:\n");
1302 fwprintf(stderr, L"%hs\n", LINE);
1303 fwprintf(stderr, L"\t-e\tencode file(s)\n");
1304 fwprintf(stderr, L"\t-d\tdecode file(s)\n");
1305 fwprintf(stderr, L"\t-t\ttest file(s)\n");
1306 fwprintf(stderr, L"\t-o name\tspecify output file name\n");
1307 fwprintf(stderr, L"\t-v\tshow codec version\n");
1308 fwprintf(stderr, L"\t-h\tthis help\n");
1309 fwprintf(stderr, L"%hs\n", LINE);
1310 fwprintf(stderr, L"options:\n");
1311 fwprintf(stderr, L"%hs\n", LINE);
1312 fwprintf(stderr, L"\t-x\twave-extensible output file format\n");
1313 fwprintf(stderr, L"\t-u\tdelete source file if successful\n");
1314 fwprintf(stderr, L"%hs\n", LINE);
1315 fwprintf(stderr, L"when file is '-', use standard input/output.\n\n");
1316
1317 exit(0);
1318 }
1319
fill_out_name_with_extention(wchar_t * ext)1320 void fill_out_name_with_extention(wchar_t *ext) {
1321 int len;
1322 wchar_t *p, *filename;
1323
1324 len = wcslen(file_out);
1325 if (len && (file_out[len] != _SEP))
1326 file_out[len++] = _SEP;
1327
1328 filename = wcsrchr(file_in, _SEP);
1329 filename = (!filename) ? file_in : (filename + 1);
1330
1331 wcscat(file_out, filename);
1332 p = wcsrchr(file_out, '.');
1333 if (p) *p = L'\0';
1334
1335 wcscat(file_out, ext);
1336 }
1337
process_files(int act,int files)1338 void process_files(int act, int files) {
1339 struct flist *item;
1340 time_t ftime = time(NULL);
1341 int count = 0;
1342 int processed = 0;
1343 int ret = 0;
1344 #ifdef _MSC
1345 char status[256];
1346 #endif
1347
1348 for (item = files_list; item != NULL; item = item->next) {
1349
1350 #ifdef _MSC
1351 sprintf(status, "TTA: %d/%d - %d file(s) processed",
1352 count + 1, files, processed);
1353 SetConsoleTitle(status);
1354 #endif
1355
1356 memset(file_in, 0, sizeof(file_in));
1357 memset(file_out, 0, sizeof(file_out));
1358
1359 wcscpy(file_in, item->fname);
1360 wcscpy(file_out, out_path);
1361
1362 if (!fixed_out) switch (act) {
1363 case 1: fill_out_name_with_extention(L".tta"); break;
1364 case 2: fill_out_name_with_extention(L".wav"); break;
1365 }
1366
1367 // print file banner
1368 fwprintf(stderr, L"File:\t[%ls]\n", print_path(file_in, 0));
1369
1370 fdin = stdin;
1371 if (wcscmp(file_in, L"-")) fdin = wfopen(file_in, "rb");
1372 #ifdef _WIN32
1373 else setmode(fileno(stdin), O_BINARY);
1374 #endif
1375 if (!fdin) tta_error(OPENR_ERROR, file_in);
1376
1377 fdout = stdout;
1378 if (wcscmp(file_out, L"-")) {
1379 if (!wcscmp(file_in, file_out)) fdout = NULL;
1380 else fdout = wfopen(file_out, "wb");
1381 }
1382 #ifdef _WIN32
1383 else setmode(fileno(stdout), O_BINARY);
1384 #endif
1385 if (!fdout) tta_error(OPENW_ERROR, file_out);
1386
1387 switch (act) {
1388 case 1: ret = compress(fdin, fdout); break;
1389 case 2: ret = decompress(fdin, fdout); break;
1390 }
1391
1392 if (wcscmp(file_in, L"-")) fclose(fdin);
1393 if (wcscmp(file_out, L"-")) fclose(fdout);
1394
1395 if (!ret) {
1396 total_input_bytes += input_byte_count;
1397 total_output_bytes += output_byte_count;
1398 if (clean_src) wunlink(file_in);
1399 processed++;
1400 }
1401
1402 count++;
1403 }
1404
1405 #ifdef _MSC
1406 sprintf(status, "TTA: %d/%d - %d file(s) processed",
1407 count, files, processed);
1408 SetConsoleTitle(status);
1409 #endif
1410
1411 ftime = (int) (time(NULL) - ftime);
1412 fwprintf(stderr, L"Total:\t[%d/%ld, %.1f/%.1f Mb], ratio: %.3f, time: %ld'%02ld\n",
1413 processed, files, (float) total_output_bytes / 1048576,
1414 (float) total_input_bytes / 1048576,
1415 (float) total_output_bytes / (total_input_bytes + 1),
1416 ftime / 60, ftime % 60);
1417 fwprintf(stderr, L"%hs\n\n", LINE);
1418 }
1419
test_files(int act,int files)1420 void test_files(int act, int files) {
1421 struct flist *item;
1422 time_t ftime = time(NULL);
1423 int count = 0;
1424 int processed = 0;
1425 int ret = 0;
1426 #ifdef _MSC
1427 char status[256];
1428 #endif
1429
1430 for (item = files_list; item != NULL; item = item->next) {
1431
1432 #ifdef _MSC
1433 sprintf(status, "TTA: %d/%d - %d file(s) processed",
1434 count + 1, files, processed);
1435 SetConsoleTitle(status);
1436 #endif
1437 wcscpy(file_in, item->fname);
1438
1439 fdin = stdin;
1440 if (wcscmp(file_in, L"-")) fdin = wfopen(file_in, "rb");
1441 if (!fdin) tta_error(OPENR_ERROR, file_in);
1442
1443 // print file banner
1444 fwprintf(stderr, L"File:\t[%ls]\n", print_path(file_in, 0));
1445
1446 ret = test_file(fdin);
1447
1448 if (wcscmp(file_in, L"-")) fclose(fdin);
1449 if (!ret) processed++;
1450
1451 count++;
1452 }
1453
1454 #ifdef _MSC
1455 sprintf(status, "TTA: %d/%d - %d file(s) processed",
1456 count, files, processed);
1457 SetConsoleTitle(status);
1458 #endif
1459
1460 ftime = (int) (time(NULL) - ftime);
1461 fwprintf(stderr, L"%hs\nTotal:\t[%d/%ld] succeeded, time: %ld'%02ld\n",
1462 LINE, processed, files, ftime / 60, ftime % 60);
1463 fwprintf(stderr, L"%hs\n\n", LINE);
1464 }
1465
1466 /******************************* main **********************************/
1467
1468 int
1469 #ifdef _MSC
wmain(int argc,wchar_t ** argv)1470 __cdecl wmain(int argc, wchar_t **argv)
1471 #else
1472 main(int argc, char **argv)
1473 #endif
1474 {
1475 int i;
1476 unsigned int j;
1477 int farg = 0, parg = 0, act = 0;
1478 wchar_t *p;
1479 #ifdef _MSC
1480 struct _wfinddata_t fdata;
1481 int hFile;
1482 #else
1483 struct stat st;
1484 int ret;
1485 #endif
1486
1487 #ifdef _MSC
1488 setlocale(LC_ALL, ".OCP");
1489 #else
1490 setlocale(LC_ALL, "");
1491 #endif
1492
1493 fwprintf(stderr, L"TTA1 lossless audio encoder/decoder, release %hs\n%hs\n", VERSION, COPYRIGHT);
1494 fwprintf(stderr, L"For more information see %hs\n%hs\n", PROJECT_URL, LINE);
1495
1496 total_input_bytes = total_output_bytes = 0;
1497 *out_path = *file_in = *file_out = L'\0';
1498
1499 if (argc) {
1500 for (i = 1; i < argc; i++) {
1501 if (argv[i][0] == '-') {
1502 if (argv[i][1] == L'\0') {
1503 wcscpy(file_in, L"-");
1504 if (!fixed_out) {
1505 wcscpy(file_out, L"-");
1506 fixed_out = 1;
1507 }
1508 add_to_files_list(file_in, &files_list, &files_list_tail);
1509 farg++;
1510 continue;
1511 }
1512 for (j = 1; j < strlen(argv[i]); j++) {
1513 switch (argv[i][j]) {
1514 case 'e':
1515 act = 1;
1516 break;
1517 case 'd':
1518 act = 2;
1519 break;
1520 case 'x':
1521 wave_ext = 1;
1522 break;
1523 case 't':
1524 act = 3;
1525 break;
1526 case 'u':
1527 clean_src = 1;
1528 break;
1529 case 'o':
1530 fixed_out = 1;
1531 i++;
1532 wstrncpy(file_out, argv[i], _MAX_FNAME-1);
1533 goto next;
1534 case 'v':
1535 fwprintf(stderr, L"%hs: version %hs build %hs\n\n", MYNAME, VERSION, BUILD);
1536 exit(0);
1537 case 'h':
1538 usage();
1539 default:
1540 wstrncpy(file_in, argv[i], _MAX_FNAME-1);
1541 tta_error(COMMAND_ERROR, file_in);
1542 usage();
1543 }
1544 }
1545 next: continue;
1546 }
1547 else
1548 {
1549 wstrncpy(file_in, argv[i], _MAX_FNAME-1);
1550
1551 if (!act && (p = wcsrchr(file_in, '.'))) {
1552 if (!wcsicmp(p, L".wav")) act = 1;
1553 if (!wcsicmp(p, L".tta")) act = 2;
1554 }
1555 #ifdef _MSC
1556 if ((hFile = _wfindfirst(file_in, &fdata)) == -1) {
1557 if (i == argc - 1 && farg) {
1558 wcscpy(out_path, file_in);
1559 parg = 1;
1560 if (_wmkdir(out_path) && errno != EEXIST)
1561 tta_error(CREATE_ERROR, out_path);
1562 continue;
1563 } else tta_error(FIND_ERROR, file_in);
1564 }
1565
1566 switch (fdata.attrib) {
1567 case _A_SUBDIR:
1568 if (i == argc - 1 && farg) {
1569 wcscpy(out_path, file_in);
1570 parg = 1;
1571 } else tta_error(FIND_ERROR, file_in);
1572 break;
1573 default:
1574 p = wcsrchr(file_in, _SEP);
1575 p = (!p) ? file_in : (p + 1);
1576 *p = L'\0';
1577 wcscat(file_in, fdata.name);
1578 add_to_files_list(file_in, &files_list, &files_list_tail);
1579 farg++;
1580 while (_wfindnext(hFile, &fdata) == 0) {
1581 *p = L'\0';
1582 wcscat(file_in, fdata.name);
1583 add_to_files_list(file_in, &files_list, &files_list_tail);
1584 farg++;
1585 }
1586 }
1587 _findclose(hFile);
1588
1589 #else
1590 ret = stat(argv[i], &st);
1591 if (ret && errno == ENOENT) {
1592 if (i == argc - 1 && farg) {
1593 wcscpy(out_path, file_in);
1594 parg = 1;
1595 if (mkdir(argv[i], S_IRUSR | S_IWUSR | S_IXUSR))
1596 tta_error(CREATE_ERROR, out_path);
1597 continue;
1598 } else tta_error(FIND_ERROR, file_in);
1599 }
1600
1601 if (!ret && S_ISDIR(st.st_mode)) {
1602 if (i == argc - 1 && farg) {
1603 wcscpy(out_path, file_in);
1604 parg = 1;
1605 continue;
1606 } else tta_error(FIND_ERROR, file_in);
1607 }
1608
1609 add_to_files_list(file_in, &files_list, &files_list_tail);
1610 farg++;
1611 #endif
1612 }
1613 }
1614 } else usage();
1615
1616 if (!act || !farg) usage();
1617 if (act == 3) {
1618 test_files(act, farg);
1619 goto done;
1620 }
1621
1622 if (fixed_out)
1623 path_strcat(out_path, file_out);
1624 process_files(act, farg);
1625 done:
1626 clear_files_list();
1627 return 0;
1628 }
1629
1630 /* eof */
1631