Mercurial > audlegacy-plugins

comparison src/shnplug/shn.c @ 1305:51bf0e431e02

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Add SHNplug.
author William Pitcock <nenolod@atheme-project.org>
date Fri, 20 Jul 2007 10:29:54 -0500
parents
children 761e17b23e0c
comparison
equal deleted inserted replaced
1300:c198ae31bb74 1305:51bf0e431e02
1 /* shn.c - main functions for xmms-shn
2 * Copyright (C) 2000-2007 Jason Jordan <shnutils@freeshell.org>
3 *
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; either version 2 of the License, or
7 * (at your option) any later version.
8 *
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write to the Free Software
16 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
17 */
18
19 /*
20 * $Id: shn.c,v 1.38 2007/03/23 05:49:48 jason Exp $
21 */
22
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <math.h>
26 #include <glib.h>
27 #include <audacious/util.h>
28 #include <audacious/configdb.h>
29 #include "shorten.h"
30
31 #ifdef HAVE_CONFIG_H
32 #include "config.h"
33 #endif
34
35 static void shn_about(void);
36 static void shn_configure(void);
37 static void shn_init(void);
38 static int shn_is_our_fd(char *, VFSFile *fd);
39 static void shn_play(InputPlayback *);
40 static void shn_stop(InputPlayback *);
41 static void shn_seek(InputPlayback *, int);
42 static void shn_pause(InputPlayback *, short);
43 static void shn_get_file_info(char *,char **,int *);
44 static void shn_display_file_info(char *);
45
46 gchar *shn_fmts[] = { "shn", NULL };
47
48 InputPlugin shn_ip =
49 {
50 NULL,
51 NULL,
52 "SHN Player " VERSION,
53 shn_init,
54 shn_about,
55 shn_configure,
56 NULL,
57 NULL,
58 shn_play,
59 shn_stop,
60 shn_pause,
61 shn_seek,
62 NULL,
63 NULL,
64 NULL,
65 NULL,
66 NULL,
67 NULL,
68 NULL,
69 NULL,
70 NULL,
71 shn_get_file_info,
72 shn_display_file_info,
73 NULL,
74 NULL,
75 NULL,
76 NULL,
77 shn_is_our_fd,
78 shn_fmts,
79 };
80
81 InputPlugin *shn_iplist[] = { &shn_ip, NULL };
82
83 DECLARE_PLUGIN(shnplug, NULL, NULL, shn_iplist, NULL, NULL, NULL, NULL);
84
85 shn_file *shnfile;
86 shn_config shn_cfg;
87
88 static pthread_t decode_thread;
89 static gboolean audio_error = FALSE;
90
91 static void shn_init()
92 {
93 ConfigDb *cfg;
94
95 shn_cfg.error_output_method = ERROR_OUTPUT_DEVNULL;
96 shn_cfg.error_output_method_config_name = "error_output_method";
97 shn_cfg.seek_tables_path = NULL;
98 shn_cfg.seek_tables_path_config_name = "seek_tables_path";
99 shn_cfg.relative_seek_tables_path = NULL;
100 shn_cfg.relative_seek_tables_path_config_name = "relative_seek_tables_path";
101 shn_cfg.verbose = 0;
102 shn_cfg.verbose_config_name = "verbose";
103 shn_cfg.swap_bytes = 0;
104 shn_cfg.swap_bytes_config_name = "swap_bytes";
105 shn_cfg.load_textfiles = FALSE;
106 shn_cfg.load_textfiles_config_name = "load_textfiles";
107 shn_cfg.textfile_extensions = NULL;
108 shn_cfg.textfile_extensions_config_name = "textfile_extensions";
109
110 if ((cfg = bmp_cfg_db_open()) != 0)
111 {
112 bmp_cfg_db_get_int(cfg, XMMS_SHN_VERSION_TAG, shn_cfg.error_output_method_config_name, &shn_cfg.error_output_method);
113 bmp_cfg_db_get_bool(cfg, XMMS_SHN_VERSION_TAG, shn_cfg.verbose_config_name, &shn_cfg.verbose);
114 if (!bmp_cfg_db_get_string(cfg, XMMS_SHN_VERSION_TAG, shn_cfg.seek_tables_path_config_name, &shn_cfg.seek_tables_path))
115 shn_cfg.seek_tables_path = g_strdup(g_get_home_dir());
116 if (!bmp_cfg_db_get_string(cfg, XMMS_SHN_VERSION_TAG, shn_cfg.relative_seek_tables_path_config_name, &shn_cfg.relative_seek_tables_path))
117 shn_cfg.relative_seek_tables_path = g_strdup("");
118 bmp_cfg_db_get_bool(cfg, XMMS_SHN_VERSION_TAG, shn_cfg.swap_bytes_config_name, &shn_cfg.swap_bytes);
119 bmp_cfg_db_get_bool(cfg, XMMS_SHN_VERSION_TAG, shn_cfg.load_textfiles_config_name, &shn_cfg.load_textfiles);
120 if (!bmp_cfg_db_get_string(cfg, XMMS_SHN_VERSION_TAG, shn_cfg.textfile_extensions_config_name, &shn_cfg.textfile_extensions))
121 shn_cfg.textfile_extensions = g_strdup("txt,nfo");
122 bmp_cfg_db_close(cfg);
123 }
124 }
125
126 static void shn_about()
127 {
128 shn_display_about();
129 }
130
131 static void shn_configure()
132 {
133 shn_display_configure();
134 }
135
136 int init_decode_state(shn_file *this_shn)
137 {
138 if (this_shn->decode_state)
139 {
140 if (this_shn->decode_state->getbuf)
141 {
142 free(this_shn->decode_state->getbuf);
143 this_shn->decode_state->getbuf = NULL;
144 }
145
146 if (this_shn->decode_state->writebuf)
147 {
148 free(this_shn->decode_state->writebuf);
149 this_shn->decode_state->writebuf = NULL;
150 }
151
152 if (this_shn->decode_state->writefub)
153 {
154 free(this_shn->decode_state->writefub);
155 this_shn->decode_state->writefub = NULL;
156 }
157
158 free(this_shn->decode_state);
159 this_shn->decode_state = NULL;
160 }
161
162 if (!(this_shn->decode_state = malloc(sizeof(shn_decode_state))))
163 {
164 shn_debug("Could not allocate memory for decode state data structure");
165 return 0;
166 }
167
168 this_shn->decode_state->getbuf = NULL;
169 this_shn->decode_state->getbufp = NULL;
170 this_shn->decode_state->nbitget = 0;
171 this_shn->decode_state->nbyteget = 0;
172 this_shn->decode_state->gbuffer = 0;
173 this_shn->decode_state->writebuf = NULL;
174 this_shn->decode_state->writefub = NULL;
175 this_shn->decode_state->nwritebuf = 0;
176
177 this_shn->vars.bytes_in_buf = 0;
178
179 return 1;
180 }
181
182 int get_wave_header(shn_file *this_shn)
183 {
184 slong **buffer = NULL, **offset = NULL;
185 slong lpcqoffset = 0;
186 int version = FORMAT_VERSION, bitshift = 0;
187 int ftype = TYPE_EOF;
188 char *magic = MAGIC;
189 int blocksize = DEFAULT_BLOCK_SIZE, nchan = DEFAULT_NCHAN;
190 int i, chan, nwrap, nskip = DEFAULT_NSKIP;
191 int *qlpc = NULL, maxnlpc = DEFAULT_MAXNLPC, nmean = UNDEFINED_UINT;
192 int cmd;
193 int internal_ftype;
194 int cklen;
195 int retval = 0;
196
197 if (!init_decode_state(this_shn))
198 return 0;
199
200 /***********************/
201 /* EXTRACT starts here */
202 /***********************/
203
204 /* read magic number */
205 #ifdef STRICT_FORMAT_COMPATABILITY
206 if(FORMAT_VERSION < 2)
207 {
208 for(i = 0; i < strlen(magic); i++) {
209 if(getc_exit(this_shn->vars.fd) != magic[i])
210 return 0;
211 this_shn->vars.bytes_read++;
212 }
213
214 /* get version number */
215 version = getc_exit(this_shn->vars.fd);
216 this_shn->vars.bytes_read++;
217 }
218 else
219 #endif /* STRICT_FORMAT_COMPATABILITY */
220 {
221 int nscan = 0;
222
223 version = MAX_VERSION + 1;
224 while(version > MAX_VERSION)
225 {
226 int byte = vfs_getc(this_shn->vars.fd);
227 this_shn->vars.bytes_read++;
228 if(byte == EOF)
229 return 0;
230 if(magic[nscan] != '\0' && byte == magic[nscan])
231 nscan++;
232 else
233 if(magic[nscan] == '\0' && byte <= MAX_VERSION)
234 version = byte;
235 else
236 {
237 if(byte == magic[0])
238 nscan = 1;
239 else
240 {
241 nscan = 0;
242 }
243 version = MAX_VERSION + 1;
244 }
245 }
246 }
247
248 /* check version number */
249 if(version > MAX_SUPPORTED_VERSION)
250 return 0;
251
252 /* set up the default nmean, ignoring the command line state */
253 nmean = (version < 2) ? DEFAULT_V0NMEAN : DEFAULT_V2NMEAN;
254
255 /* initialise the variable length file read for the compressed stream */
256 var_get_init(this_shn);
257 if (this_shn->vars.fatal_error)
258 return 0;
259
260 /* initialise the fixed length file write for the uncompressed stream */
261 fwrite_type_init(this_shn);
262
263 /* get the internal file type */
264 internal_ftype = UINT_GET(TYPESIZE, this_shn);
265
266 /* has the user requested a change in file type? */
267 if(internal_ftype != ftype) {
268 if(ftype == TYPE_EOF) {
269 ftype = internal_ftype; /* no problems here */
270 }
271 else { /* check that the requested conversion is valid */
272 if(internal_ftype == TYPE_AU1 || internal_ftype == TYPE_AU2 ||
273 internal_ftype == TYPE_AU3 || ftype == TYPE_AU1 ||ftype == TYPE_AU2 || ftype == TYPE_AU3)
274 {
275 retval = 0;
276 goto got_enough_data;
277 }
278 }
279 }
280
281 nchan = UINT_GET(CHANSIZE, this_shn);
282 this_shn->vars.actual_nchan = nchan;
283
284 /* get blocksize if version > 0 */
285 if(version > 0)
286 {
287 int byte;
288 blocksize = UINT_GET((int) (log((double) DEFAULT_BLOCK_SIZE) / M_LN2),this_shn);
289 maxnlpc = UINT_GET(LPCQSIZE, this_shn);
290 this_shn->vars.actual_maxnlpc = maxnlpc;
291 nmean = UINT_GET(0, this_shn);
292 this_shn->vars.actual_nmean = nmean;
293 nskip = UINT_GET(NSKIPSIZE, this_shn);
294 for(i = 0; i < nskip; i++)
295 {
296 byte = uvar_get(XBYTESIZE,this_shn);
297 }
298 }
299 else
300 blocksize = DEFAULT_BLOCK_SIZE;
301
302 nwrap = MAX(NWRAP, maxnlpc);
303
304 /* grab some space for the input buffer */
305 buffer = long2d((ulong) nchan, (ulong) (blocksize + nwrap),this_shn);
306 if (this_shn->vars.fatal_error)
307 return 0;
308 offset = long2d((ulong) nchan, (ulong) MAX(1, nmean),this_shn);
309 if (this_shn->vars.fatal_error) {
310 if (buffer) {
311 free(buffer);
312 buffer = NULL;
313 }
314 return 0;
315 }
316
317 for(chan = 0; chan < nchan; chan++)
318 {
319 for(i = 0; i < nwrap; i++)
320 buffer[chan][i] = 0;
321 buffer[chan] += nwrap;
322 }
323
324 if(maxnlpc > 0) {
325 qlpc = (int*) pmalloc((ulong) (maxnlpc * sizeof(*qlpc)),this_shn);
326 if (this_shn->vars.fatal_error) {
327 if (buffer) {
328 free(buffer);
329 buffer = NULL;
330 }
331 if (offset) {
332 free(offset);
333 buffer = NULL;
334 }
335 return 0;
336 }
337 }
338
339 if(version > 1)
340 lpcqoffset = V2LPCQOFFSET;
341
342 init_offset(offset, nchan, MAX(1, nmean), internal_ftype);
343
344 /* get commands from file and execute them */
345 chan = 0;
346 while(1)
347 {
348 this_shn->vars.reading_function_code = 1;
349 cmd = uvar_get(FNSIZE,this_shn);
350 this_shn->vars.reading_function_code = 0;
351
352 switch(cmd)
353 {
354 case FN_ZERO:
355 case FN_DIFF0:
356 case FN_DIFF1:
357 case FN_DIFF2:
358 case FN_DIFF3:
359 case FN_QLPC:
360 {
361 slong coffset, *cbuffer = buffer[chan];
362 int resn = 0, nlpc, j;
363
364 if(cmd != FN_ZERO)
365 {
366 resn = uvar_get(ENERGYSIZE,this_shn);
367 if (this_shn->vars.fatal_error) {
368 retval = 0;
369 goto got_enough_data;
370 }
371 /* this is a hack as version 0 differed in definition of var_get */
372 if(version == 0)
373 resn--;
374 }
375
376 /* find mean offset : N.B. this code duplicated */
377 if(nmean == 0)
378 coffset = offset[chan][0];
379 else
380 {
381 slong sum = (version < 2) ? 0 : nmean / 2;
382 for(i = 0; i < nmean; i++)
383 sum += offset[chan][i];
384 if(version < 2)
385 coffset = sum / nmean;
386 else
387 coffset = ROUNDEDSHIFTDOWN(sum / nmean, bitshift);
388 }
389
390 switch(cmd)
391 {
392 case FN_ZERO:
393 for(i = 0; i < blocksize; i++)
394 cbuffer[i] = 0;
395 break;
396 case FN_DIFF0:
397 for(i = 0; i < blocksize; i++) {
398 cbuffer[i] = var_get(resn,this_shn) + coffset;
399 if (this_shn->vars.fatal_error) {
400 retval = 0;
401 goto got_enough_data;
402 }
403 }
404 break;
405 case FN_DIFF1:
406 for(i = 0; i < blocksize; i++) {
407 cbuffer[i] = var_get(resn,this_shn) + cbuffer[i - 1];
408 if (this_shn->vars.fatal_error) {
409 retval = 0;
410 goto got_enough_data;
411 }
412 }
413 break;
414 case FN_DIFF2:
415 for(i = 0; i < blocksize; i++) {
416 cbuffer[i] = var_get(resn,this_shn) + (2 * cbuffer[i - 1] - cbuffer[i - 2]);
417 if (this_shn->vars.fatal_error) {
418 retval = 0;
419 goto got_enough_data;
420 }
421 }
422 break;
423 case FN_DIFF3:
424 for(i = 0; i < blocksize; i++) {
425 cbuffer[i] = var_get(resn,this_shn) + 3 * (cbuffer[i - 1] - cbuffer[i - 2]) + cbuffer[i - 3];
426 if (this_shn->vars.fatal_error) {
427 retval = 0;
428 goto got_enough_data;
429 }
430 }
431 break;
432 case FN_QLPC:
433 nlpc = uvar_get(LPCQSIZE,this_shn);
434 if (this_shn->vars.fatal_error) {
435 retval = 0;
436 goto got_enough_data;
437 }
438
439 for(i = 0; i < nlpc; i++) {
440 qlpc[i] = var_get(LPCQUANT,this_shn);
441 if (this_shn->vars.fatal_error) {
442 retval = 0;
443 goto got_enough_data;
444 }
445 }
446 for(i = 0; i < nlpc; i++)
447 cbuffer[i - nlpc] -= coffset;
448 for(i = 0; i < blocksize; i++)
449 {
450 slong sum = lpcqoffset;
451
452 for(j = 0; j < nlpc; j++)
453 sum += qlpc[j] * cbuffer[i - j - 1];
454 cbuffer[i] = var_get(resn,this_shn) + (sum >> LPCQUANT);
455 if (this_shn->vars.fatal_error) {
456 retval = 0;
457 goto got_enough_data;
458 }
459 }
460 if(coffset != 0)
461 for(i = 0; i < blocksize; i++)
462 cbuffer[i] += coffset;
463 break;
464 }
465
466 /* store mean value if appropriate : N.B. Duplicated code */
467 if(nmean > 0)
468 {
469 slong sum = (version < 2) ? 0 : blocksize / 2;
470
471 for(i = 0; i < blocksize; i++)
472 sum += cbuffer[i];
473
474 for(i = 1; i < nmean; i++)
475 offset[chan][i - 1] = offset[chan][i];
476 if(version < 2)
477 offset[chan][nmean - 1] = sum / blocksize;
478 else
479 offset[chan][nmean - 1] = (sum / blocksize) << bitshift;
480 }
481
482 if (0 == chan) {
483 this_shn->vars.initial_file_position = this_shn->vars.last_file_position_no_really;
484 goto got_enough_data;
485 }
486
487 /* do the wrap */
488 for(i = -nwrap; i < 0; i++)
489 cbuffer[i] = cbuffer[i + blocksize];
490
491 fix_bitshift(cbuffer, blocksize, bitshift, internal_ftype);
492
493 if(chan == nchan - 1)
494 {
495 fwrite_type(buffer, ftype, nchan, blocksize, this_shn);
496 this_shn->vars.bytes_in_buf = 0;
497 }
498
499 chan = (chan + 1) % nchan;
500 break;
501 }
502 break;
503
504 case FN_BLOCKSIZE:
505 UINT_GET((int) (log((double) blocksize) / M_LN2), this_shn);
506 break;
507
508 case FN_VERBATIM:
509 cklen = uvar_get(VERBATIM_CKSIZE_SIZE,this_shn);
510
511 while (cklen--) {
512 if (this_shn->vars.bytes_in_header >= OUT_BUFFER_SIZE) {
513 shn_debug("Unexpectedly large header - " PACKAGE " can only handle a maximum of %d bytes",OUT_BUFFER_SIZE);
514 goto got_enough_data;
515 }
516 this_shn->vars.bytes_in_buf = 0;
517 this_shn->vars.header[this_shn->vars.bytes_in_header++] = (char)uvar_get(VERBATIM_BYTE_SIZE,this_shn);
518 }
519 retval = 1;
520 break;
521
522 case FN_BITSHIFT:
523 bitshift = uvar_get(BITSHIFTSIZE,this_shn);
524 this_shn->vars.actual_bitshift = bitshift;
525 break;
526
527 default:
528 goto got_enough_data;
529 }
530 }
531
532 got_enough_data:
533
534 /* wind up */
535 var_get_quit(this_shn);
536 fwrite_type_quit(this_shn);
537
538 if (buffer) free((void *) buffer);
539 if (offset) free((void *) offset);
540 if(maxnlpc > 0 && qlpc)
541 free((void *) qlpc);
542
543 this_shn->vars.bytes_in_buf = 0;
544
545 return retval;
546 }
547
548 void shn_unload(shn_file *this_shn)
549 {
550 int this_shn_is_shnfile = (this_shn == shnfile) ? 1 : 0;
551
552 if (this_shn)
553 {
554 if (this_shn->vars.fd)
555 {
556 vfs_fclose(this_shn->vars.fd);
557 this_shn->vars.fd = NULL;
558 }
559
560 if (this_shn->decode_state)
561 {
562 if (this_shn->decode_state->getbuf)
563 {
564 free(this_shn->decode_state->getbuf);
565 this_shn->decode_state->getbuf = NULL;
566 }
567
568 if (this_shn->decode_state->writebuf)
569 {
570 free(this_shn->decode_state->writebuf);
571 this_shn->decode_state->writebuf = NULL;
572 }
573
574 if (this_shn->decode_state->writefub)
575 {
576 free(this_shn->decode_state->writefub);
577 this_shn->decode_state->writefub = NULL;
578 }
579
580 free(this_shn->decode_state);
581 this_shn->decode_state = NULL;
582 }
583
584 if (this_shn->seek_table)
585 {
586 free(this_shn->seek_table);
587 this_shn->seek_table = NULL;
588 }
589
590 free(this_shn);
591 this_shn = NULL;
592 if (this_shn_is_shnfile)
593 shnfile = NULL;
594 }
595 }
596
597 shn_file *load_shn(InputPlayback *playback, char *filename, VFSFile *fd)
598 {
599 shn_file *tmp_file;
600 shn_seek_entry *first_seek_table;
601
602 shn_debug("Loading file: '%s'", filename);
603
604 if (!(tmp_file = malloc(sizeof(shn_file))))
605 {
606 shn_debug("Could not allocate memory for SHN data structure");
607 return NULL;
608 }
609
610 memset(tmp_file, 0, sizeof(shn_file));
611
612 tmp_file->vars.fd = NULL;
613 tmp_file->vars.seek_to = -1;
614 tmp_file->vars.eof = 0;
615 tmp_file->vars.going = 0;
616 tmp_file->vars.playback = playback;
617 tmp_file->vars.seek_table_entries = NO_SEEK_TABLE;
618 tmp_file->vars.bytes_in_buf = 0;
619 tmp_file->vars.bytes_in_header = 0;
620 tmp_file->vars.reading_function_code = 0;
621 tmp_file->vars.initial_file_position = 0;
622 tmp_file->vars.last_file_position = 0;
623 tmp_file->vars.last_file_position_no_really = 0;
624 tmp_file->vars.bytes_read = 0;
625 tmp_file->vars.actual_bitshift = 0;
626 tmp_file->vars.actual_maxnlpc = 0;
627 tmp_file->vars.actual_nmean = 0;
628 tmp_file->vars.actual_nchan = 0;
629 tmp_file->vars.seek_offset = 0;
630
631 tmp_file->decode_state = NULL;
632
633 tmp_file->wave_header.filename = filename;
634 tmp_file->wave_header.wave_format = 0;
635 tmp_file->wave_header.channels = 0;
636 tmp_file->wave_header.block_align = 0;
637 tmp_file->wave_header.bits_per_sample = 0;
638 tmp_file->wave_header.samples_per_sec = 0;
639 tmp_file->wave_header.avg_bytes_per_sec = 0;
640 tmp_file->wave_header.rate = 0;
641 tmp_file->wave_header.header_size = 0;
642 tmp_file->wave_header.data_size = 0;
643 tmp_file->wave_header.file_has_id3v2_tag = 0;
644 tmp_file->wave_header.id3v2_tag_size = 0;
645
646 tmp_file->seek_header.version = NO_SEEK_TABLE;
647 tmp_file->seek_header.shnFileSize = 0;
648
649 tmp_file->seek_trailer.seekTableSize = 0;
650
651 tmp_file->seek_table = NULL;
652
653 if (!fd)
654 {
655 if (!(tmp_file->vars.fd = shn_open_and_discard_id3v2_tag(filename,&tmp_file->wave_header.file_has_id3v2_tag,&tmp_file->wave_header.id3v2_tag_size)))
656 {
657 shn_debug("Could not open file: '%s'",filename);
658 shn_unload(tmp_file);
659 return NULL;
660 }
661 }
662 else
663 tmp_file->vars.fd = fd;
664
665 if (0 == get_wave_header(tmp_file))
666 {
667 shn_debug("Unable to read WAVE header from file '%s'",filename);
668 shn_unload(tmp_file);
669 return NULL;
670 }
671
672 if (tmp_file->wave_header.file_has_id3v2_tag)
673 {
674 vfs_fseek(tmp_file->vars.fd,tmp_file->wave_header.id3v2_tag_size,SEEK_SET);
675 tmp_file->vars.bytes_read += tmp_file->wave_header.id3v2_tag_size;
676 tmp_file->vars.seek_offset = tmp_file->wave_header.id3v2_tag_size;
677 }
678 else
679 {
680 vfs_fseek(tmp_file->vars.fd,0,SEEK_SET);
681 }
682
683 if (0 == shn_verify_header(tmp_file))
684 {
685 shn_debug("Invalid WAVE header in file: '%s'",filename);
686 shn_unload(tmp_file);
687 return NULL;
688 }
689
690 if (tmp_file->decode_state)
691 {
692 free(tmp_file->decode_state);
693 tmp_file->decode_state = NULL;
694 }
695
696 shn_load_seek_table(tmp_file,filename);
697
698 if (NO_SEEK_TABLE != tmp_file->vars.seek_table_entries)
699 {
700 /* verify seek tables */
701
702 first_seek_table = (shn_seek_entry *)tmp_file->seek_table;
703
704 if (tmp_file->vars.actual_bitshift != shn_uchar_to_ushort_le(first_seek_table->data+22))
705 {
706 /* initial bitshift value in the file does not match the first bitshift value of the first seektable entry - seeking is broken */
707 shn_debug("Broken seek table detected (invalid bitshift) - seeking disabled for this file.");
708 tmp_file->vars.seek_table_entries = NO_SEEK_TABLE;
709 }
710 else if (tmp_file->vars.actual_nchan > 2)
711 {
712 /* nchan is greater than the number of such entries stored in a seek table entry - seeking won't work */
713 shn_debug("Broken seek table detected (nchan %d not in range [1 .. 2]) - seeking disabled for this file.",tmp_file->vars.actual_nchan);
714 tmp_file->vars.seek_table_entries = NO_SEEK_TABLE;
715 }
716 else if (tmp_file->vars.actual_maxnlpc > 3)
717 {
718 /* maxnlpc is greater than the number of such entries stored in a seek table entry - seeking won't work */
719 shn_debug("Broken seek table detected (maxnlpc %d not in range [0 .. 3]) - seeking disabled for this file.",tmp_file->vars.actual_maxnlpc);
720 tmp_file->vars.seek_table_entries = NO_SEEK_TABLE;
721 }
722 else if (tmp_file->vars.actual_nmean > 4)
723 {
724 /* nmean is greater than the number of such entries stored in a seek table entry - seeking won't work */
725 shn_debug("Broken seek table detected (nmean %d not in range [0 .. 4]) - seeking disabled for this file.",tmp_file->vars.actual_nmean);
726 tmp_file->vars.seek_table_entries = NO_SEEK_TABLE;
727 }
728 else
729 {
730 /* seek table appears to be valid - now adjust byte offsets in seek table to match the file */
731 tmp_file->vars.seek_offset += tmp_file->vars.initial_file_position - shn_uchar_to_ulong_le(first_seek_table->data+8);
732
733 if (0 != tmp_file->vars.seek_offset)
734 {
735 shn_debug("Adjusting seek table offsets by %ld bytes due to mismatch between seek table values and input file - seeking might not work correctly.",
736 tmp_file->vars.seek_offset);
737 }
738 }
739 }
740
741 shn_debug("Successfully loaded file: '%s'",filename);
742
743 return tmp_file;
744 }
745
746 static int shn_is_our_fd(char *fn, VFSFile *fd)
747 {
748 char data[4];
749
750 if (vfs_fread((void *)data,1,4,fd) != 4)
751 return FALSE;
752
753 if (memcmp(data,MAGIC,4))
754 return FALSE;
755
756 #if 0
757 if (!(tmp_file = load_shn(NULL, filename, fd)))
758 return FALSE;
759
760 shn_unload(tmp_file);
761 #endif
762
763 return TRUE;
764 }
765
766 void swap_bytes(shn_file *this_shn,int bytes)
767 {
768 int i;
769 uchar tmp;
770
771 for (i=0;i<bytes;i=i+2) {
772 tmp = this_shn->vars.buffer[i+1];
773 this_shn->vars.buffer[i+1] = this_shn->vars.buffer[i];
774 this_shn->vars.buffer[i] = tmp;
775 }
776 }
777
778 void write_and_wait(shn_file *this_shn,int block_size)
779 {
780 int bytes_to_write,bytes_in_block,i;
781 InputPlayback *playback = this_shn->vars.playback;
782
783 if (this_shn->vars.bytes_in_buf < block_size)
784 return;
785
786 bytes_in_block = min(this_shn->vars.bytes_in_buf, block_size);
787
788 if (bytes_in_block <= 0)
789 return;
790
791 bytes_to_write = bytes_in_block;
792 while ((bytes_to_write + bytes_in_block) <= this_shn->vars.bytes_in_buf)
793 bytes_to_write += bytes_in_block;
794
795 shn_ip.add_vis_pcm(shn_ip.output->written_time(), (this_shn->wave_header.bits_per_sample == 16) ? FMT_S16_LE : FMT_U8,
796 this_shn->wave_header.channels, bytes_to_write, this_shn->vars.buffer);
797
798 while(shn_ip.output->buffer_free() < bytes_to_write && playback->playing && this_shn->vars.seek_to == -1)
799 xmms_usleep(10000);
800
801 if(playback->playing && this_shn->vars.seek_to == -1) {
802 if (shn_cfg.swap_bytes)
803 swap_bytes(this_shn, bytes_to_write);
804 shn_ip.output->write_audio(this_shn->vars.buffer, bytes_to_write);
805 } else
806 return;
807
808 /* shift data from end of buffer to the front */
809 this_shn->vars.bytes_in_buf -= bytes_to_write;
810
811 for(i=0;i<this_shn->vars.bytes_in_buf;i++)
812 this_shn->vars.buffer[i] = this_shn->vars.buffer[i+bytes_to_write];
813 }
814
815 static void *play_loop_shn(void *arg)
816 {
817 slong **buffer = NULL, **offset = NULL;
818 slong lpcqoffset = 0;
819 int version = FORMAT_VERSION, bitshift = 0;
820 int ftype = TYPE_EOF;
821 char *magic = MAGIC;
822 int blocksize = DEFAULT_BLOCK_SIZE, nchan = DEFAULT_NCHAN;
823 int i, chan, nwrap, nskip = DEFAULT_NSKIP;
824 int *qlpc = NULL, maxnlpc = DEFAULT_MAXNLPC, nmean = UNDEFINED_UINT;
825 int cmd;
826 int internal_ftype;
827 shn_file *this_shn = shnfile;
828 int blk_size;
829 int cklen;
830 uchar tmp;
831 ulong seekto_offset;
832 InputPlayback *playback = this_shn->vars.playback;
833
834 restart:
835
836 this_shn->vars.bytes_in_buf = 0;
837
838 if (!init_decode_state(this_shn))
839 goto exit_thread;
840
841 blk_size = 512 * (this_shn->wave_header.bits_per_sample / 8) * this_shn->wave_header.channels;
842
843 /***********************/
844 /* EXTRACT starts here */
845 /***********************/
846
847 /* read magic number */
848 #ifdef STRICT_FORMAT_COMPATABILITY
849 if(FORMAT_VERSION < 2)
850 {
851 for(i = 0; i < strlen(magic); i++)
852 if(getc_exit(this_shn->vars.fd) != magic[i]) {
853 shn_error_fatal(this_shn,"Bad magic number");
854 goto exit_thread;
855 }
856
857 /* get version number */
858 version = getc_exit(this_shn->vars.fd);
859 }
860 else
861 #endif /* STRICT_FORMAT_COMPATABILITY */
862 {
863 int nscan = 0;
864
865 version = MAX_VERSION + 1;
866 while(version > MAX_VERSION)
867 {
868 int byte = vfs_getc(this_shn->vars.fd);
869 if(byte == EOF) {
870 shn_error_fatal(this_shn,"No magic number");
871 goto exit_thread;
872 }
873 if(magic[nscan] != '\0' && byte == magic[nscan])
874 nscan++;
875 else
876 if(magic[nscan] == '\0' && byte <= MAX_VERSION)
877 version = byte;
878 else
879 {
880 if(byte == magic[0])
881 nscan = 1;
882 else
883 {
884 nscan = 0;
885 }
886 version = MAX_VERSION + 1;
887 }
888 }
889 }
890
891 /* check version number */
892 if(version > MAX_SUPPORTED_VERSION) {
893 shn_error_fatal(this_shn,"Can't decode version %d", version);
894 goto exit_thread;
895 }
896
897 /* set up the default nmean, ignoring the command line state */
898 nmean = (version < 2) ? DEFAULT_V0NMEAN : DEFAULT_V2NMEAN;
899
900 /* initialise the variable length file read for the compressed stream */
901 var_get_init(this_shn);
902 if (this_shn->vars.fatal_error)
903 goto exit_thread;
904
905 /* initialise the fixed length file write for the uncompressed stream */
906 fwrite_type_init(this_shn);
907
908 /* get the internal file type */
909 internal_ftype = UINT_GET(TYPESIZE, this_shn);
910
911 /* has the user requested a change in file type? */
912 if(internal_ftype != ftype) {
913 if(ftype == TYPE_EOF)
914 ftype = internal_ftype; /* no problems here */
915 else /* check that the requested conversion is valid */
916 if(internal_ftype == TYPE_AU1 || internal_ftype == TYPE_AU2 ||
917 internal_ftype == TYPE_AU3 || ftype == TYPE_AU1 ||ftype == TYPE_AU2 || ftype == TYPE_AU3) {
918 shn_error_fatal(this_shn,"Not able to perform requested output format conversion");
919 goto cleanup;
920 }
921 }
922
923 nchan = UINT_GET(CHANSIZE, this_shn);
924
925 /* get blocksize if version > 0 */
926 if(version > 0)
927 {
928 int byte;
929 blocksize = UINT_GET((int) (log((double) DEFAULT_BLOCK_SIZE) / M_LN2),this_shn);
930 maxnlpc = UINT_GET(LPCQSIZE, this_shn);
931 nmean = UINT_GET(0, this_shn);
932 nskip = UINT_GET(NSKIPSIZE, this_shn);
933 for(i = 0; i < nskip; i++)
934 {
935 byte = uvar_get(XBYTESIZE,this_shn);
936 }
937 }
938 else
939 blocksize = DEFAULT_BLOCK_SIZE;
940
941 nwrap = MAX(NWRAP, maxnlpc);
942
943 /* grab some space for the input buffer */
944 buffer = long2d((ulong) nchan, (ulong) (blocksize + nwrap),this_shn);
945 if (this_shn->vars.fatal_error)
946 goto exit_thread;
947 offset = long2d((ulong) nchan, (ulong) MAX(1, nmean),this_shn);
948 if (this_shn->vars.fatal_error) {
949 if (buffer) {
950 free(buffer);
951 buffer = NULL;
952 }
953 goto exit_thread;
954 }
955
956 for(chan = 0; chan < nchan; chan++)
957 {
958 for(i = 0; i < nwrap; i++)
959 buffer[chan][i] = 0;
960 buffer[chan] += nwrap;
961 }
962
963 if(maxnlpc > 0) {
964 qlpc = (int*) pmalloc((ulong) (maxnlpc * sizeof(*qlpc)),this_shn);
965 if (this_shn->vars.fatal_error) {
966 if (buffer) {
967 free(buffer);
968 buffer = NULL;
969 }
970 if (offset) {
971 free(offset);
972 buffer = NULL;
973 }
974 goto exit_thread;
975 }
976 }
977
978 if(version > 1)
979 lpcqoffset = V2LPCQOFFSET;
980
981 init_offset(offset, nchan, MAX(1, nmean), internal_ftype);
982
983 /* get commands from file and execute them */
984 chan = 0;
985 while(1)
986 {
987 cmd = uvar_get(FNSIZE,this_shn);
988 if (this_shn->vars.fatal_error)
989 goto cleanup;
990
991 switch(cmd)
992 {
993 case FN_ZERO:
994 case FN_DIFF0:
995 case FN_DIFF1:
996 case FN_DIFF2:
997 case FN_DIFF3:
998 case FN_QLPC:
999 {
1000 slong coffset, *cbuffer = buffer[chan];
1001 int resn = 0, nlpc, j;
1002
1003 if(cmd != FN_ZERO)
1004 {
1005 resn = uvar_get(ENERGYSIZE,this_shn);
1006 if (this_shn->vars.fatal_error)
1007 goto cleanup;
1008 /* this is a hack as version 0 differed in definition of var_get */
1009 if(version == 0)
1010 resn--;
1011 }
1012
1013 /* find mean offset : N.B. this code duplicated */
1014 if(nmean == 0)
1015 coffset = offset[chan][0];
1016 else
1017 {
1018 slong sum = (version < 2) ? 0 : nmean / 2;
1019 for(i = 0; i < nmean; i++)
1020 sum += offset[chan][i];
1021 if(version < 2)
1022 coffset = sum / nmean;
1023 else
1024 coffset = ROUNDEDSHIFTDOWN(sum / nmean, bitshift);
1025 }
1026
1027 switch(cmd)
1028 {
1029 case FN_ZERO:
1030 for(i = 0; i < blocksize; i++)
1031 cbuffer[i] = 0;
1032 break;
1033 case FN_DIFF0:
1034 for(i = 0; i < blocksize; i++) {
1035 cbuffer[i] = var_get(resn,this_shn) + coffset;
1036 if (this_shn->vars.fatal_error)
1037 goto cleanup;
1038 }
1039 break;
1040 case FN_DIFF1:
1041 for(i = 0; i < blocksize; i++) {
1042 cbuffer[i] = var_get(resn,this_shn) + cbuffer[i - 1];
1043 if (this_shn->vars.fatal_error)
1044 goto cleanup;
1045 }
1046 break;
1047 case FN_DIFF2:
1048 for(i = 0; i < blocksize; i++) {
1049 cbuffer[i] = var_get(resn,this_shn) + (2 * cbuffer[i - 1] - cbuffer[i - 2]);
1050 if (this_shn->vars.fatal_error)
1051 goto cleanup;
1052 }
1053 break;
1054 case FN_DIFF3:
1055 for(i = 0; i < blocksize; i++) {
1056 cbuffer[i] = var_get(resn,this_shn) + 3 * (cbuffer[i - 1] - cbuffer[i - 2]) + cbuffer[i - 3];
1057 if (this_shn->vars.fatal_error)
1058 goto cleanup;
1059 }
1060 break;
1061 case FN_QLPC:
1062 nlpc = uvar_get(LPCQSIZE,this_shn);
1063 if (this_shn->vars.fatal_error)
1064 goto cleanup;
1065
1066 for(i = 0; i < nlpc; i++) {
1067 qlpc[i] = var_get(LPCQUANT,this_shn);
1068 if (this_shn->vars.fatal_error)
1069 goto cleanup;
1070 }
1071 for(i = 0; i < nlpc; i++)
1072 cbuffer[i - nlpc] -= coffset;
1073 for(i = 0; i < blocksize; i++)
1074 {
1075 slong sum = lpcqoffset;
1076
1077 for(j = 0; j < nlpc; j++)
1078 sum += qlpc[j] * cbuffer[i - j - 1];
1079 cbuffer[i] = var_get(resn,this_shn) + (sum >> LPCQUANT);
1080 if (this_shn->vars.fatal_error)
1081 goto cleanup;
1082 }
1083 if(coffset != 0)
1084 for(i = 0; i < blocksize; i++)
1085 cbuffer[i] += coffset;
1086 break;
1087 }
1088
1089 /* store mean value if appropriate : N.B. Duplicated code */
1090 if(nmean > 0)
1091 {
1092 slong sum = (version < 2) ? 0 : blocksize / 2;
1093
1094 for(i = 0; i < blocksize; i++)
1095 sum += cbuffer[i];
1096
1097 for(i = 1; i < nmean; i++)
1098 offset[chan][i - 1] = offset[chan][i];
1099 if(version < 2)
1100 offset[chan][nmean - 1] = sum / blocksize;
1101 else
1102 offset[chan][nmean - 1] = (sum / blocksize) << bitshift;
1103 }
1104
1105 /* do the wrap */
1106 for(i = -nwrap; i < 0; i++)
1107 cbuffer[i] = cbuffer[i + blocksize];
1108
1109 fix_bitshift(cbuffer, blocksize, bitshift, internal_ftype);
1110
1111 if(chan == nchan - 1)
1112 {
1113 if (!playback->playing || this_shn->vars.fatal_error)
1114 goto cleanup;
1115
1116 fwrite_type(buffer, ftype, nchan, blocksize, this_shn);
1117
1118 write_and_wait(this_shn,blk_size);
1119
1120 if (this_shn->vars.seek_to != -1)
1121 {
1122 shn_seek_entry *seek_info;
1123 int j;
1124
1125 shn_debug("Seeking to %d:%02d",this_shn->vars.seek_to/60,this_shn->vars.seek_to%60);
1126
1127 seek_info = shn_seek_entry_search(this_shn->seek_table,this_shn->vars.seek_to * (ulong)this_shn->wave_header.samples_per_sec,0,
1128 (ulong)(this_shn->vars.seek_table_entries - 1),this_shn->vars.seek_resolution);
1129
1130 /* loop through number of channels in this file */
1131 for (i=0;i<nchan;i++) {
1132 /* load the three sample buffer values for this channel */
1133 for (j=0;j<3;j++)
1134 buffer[i][j-3] = shn_uchar_to_slong_le(seek_info->data+32+12*i-4*j);
1135
1136 /* load the variable number of offset history values for this channel */
1137 for (j=0;j<MAX(1,nmean);j++)
1138 offset[i][j] = shn_uchar_to_slong_le(seek_info->data+48+16*i+4*j);
1139 }
1140
1141 bitshift = shn_uchar_to_ushort_le(seek_info->data+22);
1142
1143 seekto_offset = shn_uchar_to_ulong_le(seek_info->data+8) + this_shn->vars.seek_offset;
1144
1145 vfs_fseek(this_shn->vars.fd,(slong)seekto_offset,SEEK_SET);
1146 vfs_fread((uchar*) this_shn->decode_state->getbuf, 1, BUFSIZ, this_shn->vars.fd);
1147
1148 this_shn->decode_state->getbufp = this_shn->decode_state->getbuf + shn_uchar_to_ushort_le(seek_info->data+14);
1149 this_shn->decode_state->nbitget = shn_uchar_to_ushort_le(seek_info->data+16);
1150 this_shn->decode_state->nbyteget = shn_uchar_to_ushort_le(seek_info->data+12);
1151 this_shn->decode_state->gbuffer = shn_uchar_to_ulong_le(seek_info->data+18);
1152
1153 this_shn->vars.bytes_in_buf = 0;
1154
1155 shn_ip.output->flush(this_shn->vars.seek_to * 1000);
1156 this_shn->vars.seek_to = -1;
1157 }
1158
1159 }
1160 chan = (chan + 1) % nchan;
1161 break;
1162 }
1163
1164 break;
1165
1166 case FN_QUIT:
1167 /* empty out last of buffer */
1168 write_and_wait(this_shn,this_shn->vars.bytes_in_buf);
1169
1170 playback->eof = TRUE;
1171
1172 while (1)
1173 {
1174 if (!playback->playing)
1175 goto finish;
1176 if (this_shn->vars.seek_to != -1)
1177 {
1178 var_get_quit(this_shn);
1179 fwrite_type_quit(this_shn);
1180
1181 if (buffer) free((void *) buffer);
1182 if (offset) free((void *) offset);
1183 if(maxnlpc > 0 && qlpc)
1184 free((void *) qlpc);
1185
1186 vfs_fseek(this_shn->vars.fd,0,SEEK_SET);
1187 goto restart;
1188 }
1189 else
1190 xmms_usleep(10000);
1191 }
1192
1193 goto cleanup;
1194 break;
1195
1196 case FN_BLOCKSIZE:
1197 blocksize = UINT_GET((int) (log((double) blocksize) / M_LN2), this_shn);
1198 if (this_shn->vars.fatal_error)
1199 goto cleanup;
1200 break;
1201 case FN_BITSHIFT:
1202 bitshift = uvar_get(BITSHIFTSIZE,this_shn);
1203 if (this_shn->vars.fatal_error)
1204 goto cleanup;
1205 break;
1206 case FN_VERBATIM:
1207 cklen = uvar_get(VERBATIM_CKSIZE_SIZE,this_shn);
1208 if (this_shn->vars.fatal_error)
1209 goto cleanup;
1210
1211 while (cklen--) {
1212 tmp = (uchar)uvar_get(VERBATIM_BYTE_SIZE,this_shn);
1213 if (this_shn->vars.fatal_error)
1214 goto cleanup;
1215 }
1216
1217 break;
1218
1219 default:
1220 shn_error_fatal(this_shn,"Sanity check fails trying to decode function: %d",cmd);
1221 goto cleanup;
1222 }
1223 }
1224
1225 cleanup:
1226
1227 write_and_wait(this_shn,this_shn->vars.bytes_in_buf);
1228 shn_ip.output->buffer_free();
1229 shn_ip.output->buffer_free();
1230 xmms_usleep(10000);
1231
1232 finish:
1233
1234 this_shn->vars.seek_to = -1;
1235 playback->eof = TRUE;
1236
1237 /* wind up */
1238 var_get_quit(this_shn);
1239 fwrite_type_quit(this_shn);
1240
1241 if (buffer) free((void *) buffer);
1242 if (offset) free((void *) offset);
1243 if(maxnlpc > 0 && qlpc)
1244 free((void *) qlpc);
1245
1246 exit_thread:
1247
1248 pthread_exit(NULL);
1249 }
1250
1251 static void shn_play(InputPlayback *playback)
1252 {
1253 char *name, *temp;
1254 char *filename = playback->filename;
1255
1256 audio_error = FALSE;
1257
1258 if (!(shnfile = load_shn(playback, playback->filename, NULL)))
1259 {
1260 shn_debug("Could not load file for playing: '%s'", playback->filename);
1261 return;
1262 }
1263
1264 vfs_fseek(shnfile->vars.fd,0,SEEK_SET);
1265
1266 playback->playing = TRUE;
1267
1268 if (shn_ip.output->open_audio((shnfile->wave_header.bits_per_sample == 16) ? FMT_S16_LE : FMT_U8, shnfile->wave_header.samples_per_sec, shnfile->wave_header.channels) == 0)
1269 {
1270 audio_error = TRUE;
1271 shn_debug("Could not open audio device for playback (check your output plugin configuration)");
1272 return;
1273 }
1274 temp = strrchr(filename, '/');
1275 if (!temp)
1276 temp = filename;
1277 else
1278 temp++;
1279 name = malloc(strlen(temp) + 1);
1280 strcpy(name, temp);
1281 if (shn_filename_contains_a_dot(name))
1282 *(strrchr(name,'.')) = '\0';
1283 shn_ip.set_info(name, 1000 * shnfile->wave_header.length, 8 * shnfile->wave_header.rate, shnfile->wave_header.samples_per_sec, shnfile->wave_header.channels);
1284 free(name);
1285 shnfile->vars.seek_to = -1;
1286 pthread_create(&decode_thread, NULL, play_loop_shn, NULL);
1287 }
1288
1289 static void shn_stop(InputPlayback *playback)
1290 {
1291 int was_fatal;
1292 char error_msg[BUF_SIZE];
1293
1294 if (!shnfile)
1295 return;
1296
1297 if ((was_fatal = shnfile->vars.fatal_error))
1298 shn_snprintf(error_msg,BUF_SIZE,"%s.\nAffected file was:\n%s",shnfile->vars.fatal_error_msg,shnfile->wave_header.filename);
1299
1300 if (playback->playing || was_fatal)
1301 {
1302 playback->playing = FALSE;
1303 pthread_join(decode_thread, NULL);
1304 shn_ip.output->close_audio();
1305 shn_unload(shnfile);
1306 }
1307
1308 if (was_fatal)
1309 shn_error(error_msg);
1310 }
1311
1312 static void shn_pause(InputPlayback *playback, short p)
1313 {
1314 playback->output->pause(p);
1315 }
1316
1317 static void shn_seek(InputPlayback *playback, int time)
1318 {
1319 if (NULL == shnfile)
1320 return;
1321
1322 if (shnfile->vars.seek_table_entries == NO_SEEK_TABLE)
1323 {
1324 shn_error("Cannot seek to %d:%02d because there is no seek information for this file.",time/60,time%60);
1325 return;
1326 }
1327
1328 shnfile->vars.seek_to = time;
1329
1330 while (shnfile->vars.seek_to != -1)
1331 xmms_usleep(10000);
1332 }
1333
1334 static void shn_get_file_info(char *filename, char **title, int *length)
1335 {
1336 char *name, *temp;
1337 shn_file *tmp_file;
1338
1339 temp = strrchr(filename, '/');
1340 if (!temp)
1341 temp = filename;
1342 else
1343 temp++;
1344
1345 name = g_malloc(strlen(temp) + 1);
1346 strcpy(name, temp);
1347
1348 if (shn_filename_contains_a_dot(name))
1349 *(strrchr(name,'.')) = '\0';
1350
1351 *title = name;
1352
1353 *length = 0;
1354
1355 if (!(tmp_file = load_shn(NULL, filename, NULL)))
1356 {
1357 shn_debug("Could not get information from file: '%s'",filename);
1358 return;
1359 }
1360
1361 *length = 1000 * tmp_file->wave_header.length;
1362
1363 shn_unload(tmp_file);
1364 }
1365
1366 static void shn_display_file_info(char *filename)
1367 {
1368 shn_file *tmp_file;
1369
1370 if (!(tmp_file = load_shn(NULL, filename, NULL)))
1371 {
1372 shn_debug("Could not get information from file: '%s'",filename);
1373 return;
1374 }
1375
1376 shn_display_info(tmp_file);
1377
1378 shn_unload(tmp_file);
1379 }