Added the togglemenu command for both menus and the chr builtin command (menu qc)
[divverent/darkplaces.git] / dpvsimpledecode.c
1
2 #include <stdlib.h>
3 #include <stdio.h>
4 #include <math.h>
5 #include <string.h>
6 #include "dpvsimpledecode.h"
7 #include "wavefile.h"
8
9 #define EMBEDDEDHZREAD 1
10
11 #ifndef EMBEDDEDHZREAD
12 #include "hz_read.h"
13 #include "hz_read.c"
14 #else
15 #define HZREADERROR_OK 0
16 #define HZREADERROR_EOF 1
17 #define HZREADERROR_MALLOCFAILED 2
18
19 #define HZREADBLOCKSIZE 16000
20
21 typedef struct
22 {
23         qfile_t *file;
24         int endoffile;
25 }
26 hz_bitstream_read_t;
27
28 typedef struct hz_bitstream_readblock_s
29 {
30         struct hz_bitstream_readblock_s *next;
31         unsigned int size;
32         unsigned char data[HZREADBLOCKSIZE];
33 }
34 hz_bitstream_readblock_t;
35
36 typedef struct
37 {
38         hz_bitstream_readblock_t *blocks;
39         hz_bitstream_readblock_t *current;
40         unsigned int position;
41         unsigned int store;
42         int count;
43 }
44 hz_bitstream_readblocks_t;
45
46 hz_bitstream_read_t *hz_bitstream_read_open(char *filename)
47 {
48         qfile_t *file;
49         hz_bitstream_read_t *stream;
50         if ((file = FS_Open (filename, "rb", false)))
51         {
52                 stream = malloc(sizeof(hz_bitstream_read_t));
53                 memset(stream, 0, sizeof(*stream));
54                 stream->file = file;
55                 return stream;
56         }
57         else
58                 return NULL;
59 }
60
61 void hz_bitstream_read_close(hz_bitstream_read_t *stream)
62 {
63         if (stream)
64         {
65                 FS_Close(stream->file);
66                 free(stream);
67         }
68 }
69
70 hz_bitstream_readblocks_t *hz_bitstream_read_blocks_new(void)
71 {
72         hz_bitstream_readblocks_t *blocks;
73         blocks = malloc(sizeof(hz_bitstream_readblocks_t));
74         if (blocks == NULL)
75                 return NULL;
76         memset(blocks, 0, sizeof(hz_bitstream_readblocks_t));
77         return blocks;
78 }
79
80 void hz_bitstream_read_blocks_free(hz_bitstream_readblocks_t *blocks)
81 {
82         hz_bitstream_readblock_t *b, *n;
83         if (blocks == NULL)
84                 return;
85         for (b = blocks->blocks;b;b = n)
86         {
87                 n = b->next;
88                 free(b);
89         }
90         free(blocks);
91 }
92
93 void hz_bitstream_read_flushbits(hz_bitstream_readblocks_t *blocks)
94 {
95         blocks->store = 0;
96         blocks->count = 0;
97 }
98
99 int hz_bitstream_read_blocks_read(hz_bitstream_readblocks_t *blocks, hz_bitstream_read_t *stream, unsigned int size)
100 {
101         int s;
102         hz_bitstream_readblock_t *b, *p;
103         s = size;
104         p = NULL;
105         b = blocks->blocks;
106         while (s > 0)
107         {
108                 if (b == NULL)
109                 {
110                         b = malloc(sizeof(hz_bitstream_readblock_t));
111                         if (b == NULL)
112                                 return HZREADERROR_MALLOCFAILED;
113                         b->next = NULL;
114                         b->size = 0;
115                         if (p != NULL)
116                                 p->next = b;
117                         else
118                                 blocks->blocks = b;
119                 }
120                 if (s > HZREADBLOCKSIZE)
121                         b->size = HZREADBLOCKSIZE;
122                 else
123                         b->size = s;
124                 s -= b->size;
125                 if (FS_Read(stream->file, b->data, b->size) != b->size)
126                 {
127                         stream->endoffile = 1;
128                         break;
129                 }
130                 p = b;
131                 b = b->next;
132         }
133         while (b)
134         {
135                 b->size = 0;
136                 b = b->next;
137         }
138         blocks->current = blocks->blocks;
139         blocks->position = 0;
140         hz_bitstream_read_flushbits(blocks);
141         if (stream->endoffile)
142                 return HZREADERROR_EOF;
143         return HZREADERROR_OK;
144 }
145
146 unsigned int hz_bitstream_read_blocks_getbyte(hz_bitstream_readblocks_t *blocks)
147 {
148         while (blocks->current != NULL && blocks->position >= blocks->current->size)
149         {
150                 blocks->position = 0;
151                 blocks->current = blocks->current->next;
152         }
153         if (blocks->current == NULL)
154                 return 0;
155         return blocks->current->data[blocks->position++];
156 }
157
158 int hz_bitstream_read_bit(hz_bitstream_readblocks_t *blocks)
159 {
160         if (!blocks->count)
161         {
162                 blocks->count += 8;
163                 blocks->store <<= 8;
164                 blocks->store |= hz_bitstream_read_blocks_getbyte(blocks) & 0xFF;
165         }
166         blocks->count--;
167         return (blocks->store >> blocks->count) & 1;
168 }
169
170 unsigned int hz_bitstream_read_bits(hz_bitstream_readblocks_t *blocks, int size)
171 {
172         unsigned int num = 0;
173         // we can only handle about 24 bits at a time safely
174         // (there might be up to 7 bits more than we need in the bit store)
175         if (size > 24)
176         {
177                 size -= 8;
178                 num |= hz_bitstream_read_bits(blocks, 8) << size;
179         }
180         while (blocks->count < size)
181         {
182                 blocks->count += 8;
183                 blocks->store <<= 8;
184                 blocks->store |= hz_bitstream_read_blocks_getbyte(blocks) & 0xFF;
185         }
186         blocks->count -= size;
187         num |= (blocks->store >> blocks->count) & ((1 << size) - 1);
188         return num;
189 }
190
191 unsigned int hz_bitstream_read_byte(hz_bitstream_readblocks_t *blocks)
192 {
193         return hz_bitstream_read_blocks_getbyte(blocks);
194 }
195
196 unsigned int hz_bitstream_read_short(hz_bitstream_readblocks_t *blocks)
197 {
198         return (hz_bitstream_read_byte(blocks) << 8)
199              | (hz_bitstream_read_byte(blocks));
200 }
201
202 unsigned int hz_bitstream_read_int(hz_bitstream_readblocks_t *blocks)
203 {
204         return (hz_bitstream_read_byte(blocks) << 24)
205              | (hz_bitstream_read_byte(blocks) << 16)
206              | (hz_bitstream_read_byte(blocks) << 8)
207              | (hz_bitstream_read_byte(blocks));
208 }
209
210 void hz_bitstream_read_bytes(hz_bitstream_readblocks_t *blocks, void *outdata, unsigned int size)
211 {
212         unsigned char *out;
213         out = outdata;
214         while (size--)
215                 *out++ = hz_bitstream_read_byte(blocks);
216 }
217 #endif
218
219 #define BLOCKSIZE 8
220
221 typedef struct dpvsimpledecodestream_s
222 {
223         hz_bitstream_read_t *bitstream;
224         hz_bitstream_readblocks_t *framedatablocks;
225
226         int error;
227
228         double info_framerate;
229         unsigned int info_frames;
230
231         unsigned int info_imagewidth;
232         unsigned int info_imageheight;
233         unsigned int info_imagebpp;
234         unsigned int info_imageRloss;
235         unsigned int info_imageRmask;
236         unsigned int info_imageRshift;
237         unsigned int info_imageGloss;
238         unsigned int info_imageGmask;
239         unsigned int info_imageGshift;
240         unsigned int info_imageBloss;
241         unsigned int info_imageBmask;
242         unsigned int info_imageBshift;
243         unsigned int info_imagesize;
244
245         // current video frame (needed because of delta compression)
246         int videoframenum;
247         // current video frame data (needed because of delta compression)
248         unsigned int *videopixels;
249
250         // wav file the sound is being read from
251         wavefile_t *wavefile;
252 }
253 dpvsimpledecodestream_t;
254
255 static int dpvsimpledecode_setpixelformat(dpvsimpledecodestream_t *s, unsigned int Rmask, unsigned int Gmask, unsigned int Bmask, unsigned int bytesperpixel)
256 {
257         int Rshift, Rbits, Gshift, Gbits, Bshift, Bbits;
258         if (!Rmask)
259         {
260                 s->error = DPVSIMPLEDECODEERROR_INVALIDRMASK;
261                 return s->error;
262         }
263         if (!Gmask)
264         {
265                 s->error = DPVSIMPLEDECODEERROR_INVALIDGMASK;
266                 return s->error;
267         }
268         if (!Bmask)
269         {
270                 s->error = DPVSIMPLEDECODEERROR_INVALIDBMASK;
271                 return s->error;
272         }
273         if (Rmask & Gmask || Rmask & Bmask || Gmask & Bmask)
274         {
275                 s->error = DPVSIMPLEDECODEERROR_COLORMASKSOVERLAP;
276                 return s->error;
277         }
278         switch (bytesperpixel)
279         {
280         case 2:
281                 if ((Rmask | Gmask | Bmask) > 65536)
282                 {
283                         s->error = DPVSIMPLEDECODEERROR_COLORMASKSEXCEEDBPP;
284                         return s->error;
285                 }
286                 break;
287         case 4:
288                 break;
289         default:
290                 s->error = DPVSIMPLEDECODEERROR_UNSUPPORTEDBPP;
291                 return s->error;
292                 break;
293         }
294         for (Rshift = 0;!(Rmask & 1);Rshift++, Rmask >>= 1);
295         for (Gshift = 0;!(Gmask & 1);Gshift++, Gmask >>= 1);
296         for (Bshift = 0;!(Bmask & 1);Bshift++, Bmask >>= 1);
297         if (((Rmask + 1) & Rmask) != 0)
298         {
299                 s->error = DPVSIMPLEDECODEERROR_INVALIDRMASK;
300                 return s->error;
301         }
302         if (((Gmask + 1) & Gmask) != 0)
303         {
304                 s->error = DPVSIMPLEDECODEERROR_INVALIDGMASK;
305                 return s->error;
306         }
307         if (((Bmask + 1) & Bmask) != 0)
308         {
309                 s->error = DPVSIMPLEDECODEERROR_INVALIDBMASK;
310                 return s->error;
311         }
312         for (Rbits = 0;Rmask & 1;Rbits++, Rmask >>= 1);
313         for (Gbits = 0;Gmask & 1;Gbits++, Gmask >>= 1);
314         for (Bbits = 0;Bmask & 1;Bbits++, Bmask >>= 1);
315         if (Rbits > 8)
316         {
317                 Rshift += (Rbits - 8);
318                 Rbits = 8;
319         }
320         if (Gbits > 8)
321         {
322                 Gshift += (Gbits - 8);
323                 Gbits = 8;
324         }
325         if (Bbits > 8)
326         {
327                 Bshift += (Bbits - 8);
328                 Bbits = 8;
329         }
330         s->info_imagebpp = bytesperpixel;
331         s->info_imageRloss = 16 + (8 - Rbits);
332         s->info_imageGloss =  8 + (8 - Gbits);
333         s->info_imageBloss =  0 + (8 - Bbits);
334         s->info_imageRmask = (1 << Rbits) - 1;
335         s->info_imageGmask = (1 << Gbits) - 1;
336         s->info_imageBmask = (1 << Bbits) - 1;
337         s->info_imageRshift = Rshift;
338         s->info_imageGshift = Gshift;
339         s->info_imageBshift = Bshift;
340         s->info_imagesize = s->info_imagewidth * s->info_imageheight * s->info_imagebpp;
341         return s->error;
342 }
343
344 // opening and closing streams
345
346 static void StripExtension(char *in, char *out)
347 {
348         char *dot, *c;
349         dot = NULL;
350         for (c = in;*c;c++)
351         {
352                 if (*c == ':' || *c == '\\' || *c == '/')
353                         dot = NULL;
354                 if (*c == '.')
355                         dot = c;
356         }
357         if (dot == NULL)
358         {
359                 // nothing to remove
360                 strcpy(out, in);
361                 return;
362         }
363         else
364         {
365                 memcpy(out, in, dot - in);
366                 out[dot - in] = 0;
367         }
368 }
369
370 // opens a stream
371 void *dpvsimpledecode_open(char *filename, char **errorstring)
372 {
373         dpvsimpledecodestream_t *s;
374         char t[8], *wavename;
375         if (errorstring != NULL)
376                 *errorstring = NULL;
377         s = malloc(sizeof(dpvsimpledecodestream_t));
378         if (s != NULL)
379         {
380                 s->bitstream = hz_bitstream_read_open(filename);
381                 if (s->bitstream != NULL)
382                 {
383                         // check file identification
384                         s->framedatablocks = hz_bitstream_read_blocks_new();
385                         if (s->framedatablocks != NULL)
386                         {
387                                 hz_bitstream_read_blocks_read(s->framedatablocks, s->bitstream, 8);
388                                 hz_bitstream_read_bytes(s->framedatablocks, t, 8);
389                                 if (!memcmp(t, "DPVideo", 8))
390                                 {
391                                         // check version number
392                                         hz_bitstream_read_blocks_read(s->framedatablocks, s->bitstream, 2);
393                                         if (hz_bitstream_read_short(s->framedatablocks) == 1)
394                                         {
395                                                 hz_bitstream_read_blocks_read(s->framedatablocks, s->bitstream, 12);
396                                                 s->info_imagewidth = hz_bitstream_read_short(s->framedatablocks);
397                                                 s->info_imageheight = hz_bitstream_read_short(s->framedatablocks);
398                                                 s->info_framerate = (double) hz_bitstream_read_int(s->framedatablocks) * (1.0 / 65536.0);
399
400                                                 if (s->info_framerate > 0.0)
401                                                 {
402                                                         s->videopixels = malloc(s->info_imagewidth * s->info_imageheight * sizeof(*s->videopixels));
403                                                         if (s->videopixels != NULL)
404                                                         {
405                                                                 wavename = malloc(strlen(filename) + 10);
406                                                                 if (wavename)
407                                                                 {
408                                                                         StripExtension(filename, wavename);
409                                                                         strcat(wavename, ".wav");
410                                                                         s->wavefile = waveopen(wavename, NULL);
411                                                                         free(wavename);
412                                                                 }
413                                                                 // all is well...
414                                                                 s->videoframenum = -10000;
415                                                                 return s;
416                                                         }
417                                                         else if (errorstring != NULL)
418                                                                 *errorstring = "unable to allocate video image buffer";
419                                                 }
420                                                 else if (errorstring != NULL)
421                                                         *errorstring = "error in video info chunk";
422                                         }
423                                         else if (errorstring != NULL)
424                                                 *errorstring = "read error";
425                                 }
426                                 else if (errorstring != NULL)
427                                         *errorstring = "not a dpvideo file";
428                                 hz_bitstream_read_blocks_free(s->framedatablocks);
429                         }
430                         else if (errorstring != NULL)
431                                 *errorstring = "unable to allocate memory for reading buffer";
432                         hz_bitstream_read_close(s->bitstream);
433                 }
434                 else if (errorstring != NULL)
435                         *errorstring = "unable to open file";
436                 free(s);
437         }
438         else if (errorstring != NULL)
439                 *errorstring = "unable to allocate memory for stream info structure";
440         return NULL;
441 }
442
443 // closes a stream
444 void dpvsimpledecode_close(void *stream)
445 {
446         dpvsimpledecodestream_t *s = stream;
447         if (s == NULL)
448                 return;
449         if (s->videopixels)
450                 free(s->videopixels);
451         if (s->wavefile)
452                 waveclose(s->wavefile);
453         if (s->framedatablocks)
454                 hz_bitstream_read_blocks_free(s->framedatablocks);
455         if (s->bitstream)
456                 hz_bitstream_read_close(s->bitstream);
457         free(s);
458 }
459
460 // utilitarian functions
461
462 // returns the current error number for the stream, and resets the error
463 // number to DPVSIMPLEDECODEERROR_NONE
464 // if the supplied string pointer variable is not NULL, it will be set to the
465 // error message
466 int dpvsimpledecode_error(void *stream, char **errorstring)
467 {
468         dpvsimpledecodestream_t *s = stream;
469         int e;
470         e = s->error;
471         s->error = 0;
472         if (errorstring)
473         {
474                 switch (e)
475                 {
476                         case DPVSIMPLEDECODEERROR_NONE:
477                                 *errorstring = "no error";
478                                 break;
479                         case DPVSIMPLEDECODEERROR_EOF:
480                                 *errorstring = "end of file reached (this is not an error)";
481                                 break;
482                         case DPVSIMPLEDECODEERROR_READERROR:
483                                 *errorstring = "read error (corrupt or incomplete file)";
484                                 break;
485                         case DPVSIMPLEDECODEERROR_SOUNDBUFFERTOOSMALL:
486                                 *errorstring = "sound buffer is too small for decoding frame (please allocate it as large as dpvsimpledecode_getneededsoundbufferlength suggests)";
487                                 break;
488                         case DPVSIMPLEDECODEERROR_INVALIDRMASK:
489                                 *errorstring = "invalid red bits mask";
490                                 break;
491                         case DPVSIMPLEDECODEERROR_INVALIDGMASK:
492                                 *errorstring = "invalid green bits mask";
493                                 break;
494                         case DPVSIMPLEDECODEERROR_INVALIDBMASK:
495                                 *errorstring = "invalid blue bits mask";
496                                 break;
497                         case DPVSIMPLEDECODEERROR_COLORMASKSOVERLAP:
498                                 *errorstring = "color bit masks overlap";
499                                 break;
500                         case DPVSIMPLEDECODEERROR_COLORMASKSEXCEEDBPP:
501                                 *errorstring = "color masks too big for specified bytes per pixel";
502                                 break;
503                         case DPVSIMPLEDECODEERROR_UNSUPPORTEDBPP:
504                                 *errorstring = "unsupported bytes per pixel (must be 2 for 16bit, or 4 for 32bit)";
505                                 break;
506                         default:
507                                 *errorstring = "unknown error";
508                                 break;
509                 }
510         }
511         return e;
512 }
513
514 // returns the width of the image data
515 unsigned int dpvsimpledecode_getwidth(void *stream)
516 {
517         dpvsimpledecodestream_t *s = stream;
518         return s->info_imagewidth;
519 }
520
521 // returns the height of the image data
522 unsigned int dpvsimpledecode_getheight(void *stream)
523 {
524         dpvsimpledecodestream_t *s = stream;
525         return s->info_imageheight;
526 }
527
528 // returns the sound sample rate of the stream
529 unsigned int dpvsimpledecode_getsoundrate(void *stream)
530 {
531         dpvsimpledecodestream_t *s = stream;
532         if (s->wavefile)
533                 return s->wavefile->info_rate;
534         else
535                 return 0;
536 }
537
538 // returns the framerate of the stream
539 double dpvsimpledecode_getframerate(void *stream)
540 {
541         dpvsimpledecodestream_t *s = stream;
542         return s->info_framerate;
543 }
544
545
546
547
548
549 static int dpvsimpledecode_convertpixels(dpvsimpledecodestream_t *s, void *imagedata, int imagebytesperrow)
550 {
551         unsigned int a, x, y, width, height;
552         unsigned int Rloss, Rmask, Rshift, Gloss, Gmask, Gshift, Bloss, Bmask, Bshift;
553         unsigned int *in;
554
555         width = s->info_imagewidth;
556         height = s->info_imageheight;
557
558         Rloss = s->info_imageRloss;
559         Rmask = s->info_imageRmask;
560         Rshift = s->info_imageRshift;
561         Gloss = s->info_imageGloss;
562         Gmask = s->info_imageGmask;
563         Gshift = s->info_imageGshift;
564         Bloss = s->info_imageBloss;
565         Bmask = s->info_imageBmask;
566         Bshift = s->info_imageBshift;
567
568         in = s->videopixels;
569         if (s->info_imagebpp == 4)
570         {
571                 unsigned int *outrow;
572                 for (y = 0;y < height;y++)
573                 {
574                         outrow = (void *)((unsigned char *)imagedata + y * imagebytesperrow);
575                         for (x = 0;x < width;x++)
576                         {
577                                 a = *in++;
578                                 outrow[x] = (((a >> Rloss) & Rmask) << Rshift) | (((a >> Gloss) & Gmask) << Gshift) | (((a >> Bloss) & Bmask) << Bshift);
579                         }
580                 }
581         }
582         else
583         {
584                 unsigned short *outrow;
585                 for (y = 0;y < height;y++)
586                 {
587                         outrow = (void *)((unsigned char *)imagedata + y * imagebytesperrow);
588                         if (Rloss == 19 && Gloss == 10 && Bloss == 3 && Rshift == 11 && Gshift == 5 && Bshift == 0)
589                         {
590                                 // optimized
591                                 for (x = 0;x < width;x++)
592                                 {
593                                         a = *in++;
594                                         outrow[x] = ((a >> 8) & 0xF800) | ((a >> 5) & 0x07E0) | ((a >> 3) & 0x001F);
595                                 }
596                         }
597                         else
598                         {
599                                 for (x = 0;x < width;x++)
600                                 {
601                                         a = *in++;
602                                         outrow[x] = (((a >> Rloss) & Rmask) << Rshift) | (((a >> Gloss) & Gmask) << Gshift) | (((a >> Bloss) & Bmask) << Bshift);
603                                 }
604                         }
605                 }
606         }
607         return s->error;
608 }
609
610 static int dpvsimpledecode_decompressimage(dpvsimpledecodestream_t *s)
611 {
612         int i, a, b, colors, g, x1, y1, bw, bh, width, height, palettebits;
613         unsigned int palette[256], *outrow, *out;
614         g = BLOCKSIZE;
615         width = s->info_imagewidth;
616         height = s->info_imageheight;
617         for (y1 = 0;y1 < height;y1 += g)
618         {
619                 outrow = s->videopixels + y1 * width;
620                 bh = g;
621                 if (y1 + bh > height)
622                         bh = height - y1;
623                 for (x1 = 0;x1 < width;x1 += g)
624                 {
625                         out = outrow + x1;
626                         bw = g;
627                         if (x1 + bw > width)
628                                 bw = width - x1;
629                         if (hz_bitstream_read_bit(s->framedatablocks))
630                         {
631                                 // updated block
632                                 palettebits = hz_bitstream_read_bits(s->framedatablocks, 3);
633                                 colors = 1 << palettebits;
634                                 for (i = 0;i < colors;i++)
635                                         palette[i] = hz_bitstream_read_bits(s->framedatablocks, 24);
636                                 if (palettebits)
637                                 {
638                                         for (b = 0;b < bh;b++, out += width)
639                                                 for (a = 0;a < bw;a++)
640                                                         out[a] = palette[hz_bitstream_read_bits(s->framedatablocks, palettebits)];
641                                 }
642                                 else
643                                 {
644                                         for (b = 0;b < bh;b++, out += width)
645                                                 for (a = 0;a < bw;a++)
646                                                         out[a] = palette[0];
647                                 }
648                         }
649                 }
650         }
651         return s->error;
652 }
653
654 // decodes a video frame to the supplied output pixels
655 int dpvsimpledecode_video(void *stream, void *imagedata, unsigned int Rmask, unsigned int Gmask, unsigned int Bmask, unsigned int bytesperpixel, int imagebytesperrow)
656 {
657         dpvsimpledecodestream_t *s = stream;
658         unsigned int framedatasize;
659         char t[4];
660         s->error = DPVSIMPLEDECODEERROR_NONE;
661         if (dpvsimpledecode_setpixelformat(s, Rmask, Gmask, Bmask, bytesperpixel))
662                 return s->error;
663
664         hz_bitstream_read_blocks_read(s->framedatablocks, s->bitstream, 8);
665         hz_bitstream_read_bytes(s->framedatablocks, t, 4);
666         if (memcmp(t, "VID0", 4))
667         {
668                 if (t[0] == 0)
669                         return (s->error = DPVSIMPLEDECODEERROR_EOF);
670                 else
671                         return (s->error = DPVSIMPLEDECODEERROR_READERROR);
672         }
673         framedatasize = hz_bitstream_read_int(s->framedatablocks);
674         hz_bitstream_read_blocks_read(s->framedatablocks, s->bitstream, framedatasize);
675         if (dpvsimpledecode_decompressimage(s))
676                 return s->error;
677
678         dpvsimpledecode_convertpixels(s, imagedata, imagebytesperrow);
679         return s->error;
680 }
681
682 // (note: sound is 16bit stereo native-endian, left channel first)
683 int dpvsimpledecode_audio(void *stream, short *soundbuffer, int requestedlength)
684 {
685         int samples;
686         dpvsimpledecodestream_t *s = stream;
687         s->error = DPVSIMPLEDECODEERROR_NONE;
688         if (requestedlength)
689         {
690                 samples = 0;
691                 if (s->wavefile && requestedlength)
692                         samples = waveread16stereo(s->wavefile, soundbuffer, requestedlength);
693                 if (samples < requestedlength)
694                         memset(soundbuffer + samples * 2, 0, (requestedlength - samples) * sizeof(short[2]));
695         }
696         return s->error;
697 }