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