← Back to branch summary

~ubuntu-branches/ubuntu/wily/smplayer/wily

« back to all changes in this revision

Viewing changes to zlib-1.2.6/gzlib.c

  • Committer: Package Import Robot
  • Author(s): Maia Kozheva, Maia Kozheva, Alessio Treglia
  • Date: 2012-04-14 12:01:57 UTC
  • mfrom: (1.1.13)
  • mto: (20.2.1 sid)
  • mto: This revision was merged to the branch mainline in revision 23.
  • Revision ID: package-import@ubuntu.com-20120414120157-mndwobcslgisomso
http://bugs.debian.org/638279
[ Maia Kozheva ]
* New upstream release:
  - Changes since 0.7.1:
    + A toolbar editor has been added. Now it's possible to select the
      buttons and controls that want to appear in the toolbars.
    + New video filters: gradfun, blur and sharpen.
    + Now it's possible to change the GUI (default, mini, mpc) at runtime,
      no restart required.
    + sub files from opensubtitles should work again.
    + (Youtube) Recognize short urls (like this one:
      http://y2u.be/F5OcZBVPwOA)
    + Better support for chapters in video files.
    + Bug fix: remote m3u files work from the favorites menu or command line.
    + Internal changes in the single instance option (switch to 
      QtSingleApplication).
  - Fixes since 0.7.0:
    + SMPlayer took more than 10 seconds to show when running for the very
      first time.
    + The links to download subtitles from Opensubtitles were wrong.
    + SMPlayer crashed in the favorite editor when trying to select a file
      if the KDE open dialog was used.
  - Changes since 0.7.0:
    + By default the screenshots are saved in the user's pictures folder
      instead of the SMPlayer's config folder.
    + Now it's possible to change the opensubtitles server.
    + Youtube: seeking is slow with flv videos, so now flv videos have the
      lowest priority.
    + Youtube: now it's possible to search and download videos from youtube.
      This is provided by an external application (in linux you have to
      install an independent package: smtube).
* debian/copyright:
  - Rewrite according to DEP-5 specification.
* debian/control:
  - Depend on mplayer2 | mplayer. (Closes: #638279)
  - Update Standards-Version to 3.9.3.
* Remove debian/patches/handle_local_urls.diff, merged upstream.

[ Alessio Treglia ]
* Mention smplayer is also a front-end for MPlayer2.
* Fix small typo in the description.

Show diffs side-by-side

added added

removed removed

Lines of Context:
zlib-1.2.6/gzlib.c
 
1
/* gzlib.c -- zlib functions common to reading and writing gzip files
 
2
 * Copyright (C) 2004, 2010, 2011 Mark Adler
 
3
 * For conditions of distribution and use, see copyright notice in zlib.h
 
4
 */
 
5
 
 
6
#include "gzguts.h"
 
7
 
 
8
#if defined(_WIN32) && !defined(__BORLANDC__)
 
9
#  define LSEEK _lseeki64
 
10
#else
 
11
#if defined(_LARGEFILE64_SOURCE) && _LFS64_LARGEFILE-0
 
12
#  define LSEEK lseek64
 
13
#else
 
14
#  define LSEEK lseek
 
15
#endif
 
16
#endif
 
17
 
 
18
/* Local functions */
 
19
local void gz_reset OF((gz_statep));
 
20
local gzFile gz_open OF((const char *, int, const char *));
 
21
 
 
22
#if defined UNDER_CE
 
23
 
 
24
/* Map the Windows error number in ERROR to a locale-dependent error message
 
25
   string and return a pointer to it.  Typically, the values for ERROR come
 
26
   from GetLastError.
 
27
 
 
28
   The string pointed to shall not be modified by the application, but may be
 
29
   overwritten by a subsequent call to gz_strwinerror
 
30
 
 
31
   The gz_strwinerror function does not change the current setting of
 
32
   GetLastError. */
 
33
char ZLIB_INTERNAL *gz_strwinerror (error)
 
34
     DWORD error;
 
35
{
 
36
    static char buf[1024];
 
37
 
 
38
    wchar_t *msgbuf;
 
39
    DWORD lasterr = GetLastError();
 
40
    DWORD chars = FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM
 
41
        | FORMAT_MESSAGE_ALLOCATE_BUFFER,
 
42
        NULL,
 
43
        error,
 
44
        0, /* Default language */
 
45
        (LPVOID)&msgbuf,
 
46
        0,
 
47
        NULL);
 
48
    if (chars != 0) {
 
49
        /* If there is an \r\n appended, zap it.  */
 
50
        if (chars >= 2
 
51
            && msgbuf[chars - 2] == '\r' && msgbuf[chars - 1] == '\n') {
 
52
            chars -= 2;
 
53
            msgbuf[chars] = 0;
 
54
        }
 
55
 
 
56
        if (chars > sizeof (buf) - 1) {
 
57
            chars = sizeof (buf) - 1;
 
58
            msgbuf[chars] = 0;
 
59
        }
 
60
 
 
61
        wcstombs(buf, msgbuf, chars + 1);
 
62
        LocalFree(msgbuf);
 
63
    }
 
64
    else {
 
65
        sprintf(buf, "unknown win32 error (%ld)", error);
 
66
    }
 
67
 
 
68
    SetLastError(lasterr);
 
69
    return buf;
 
70
}
 
71
 
 
72
#endif /* UNDER_CE */
 
73
 
 
74
/* Reset gzip file state */
 
75
local void gz_reset(state)
 
76
    gz_statep state;
 
77
{
 
78
    state->x.have = 0;              /* no output data available */
 
79
    if (state->mode == GZ_READ) {   /* for reading ... */
 
80
        state->eof = 0;             /* not at end of file */
 
81
        state->past = 0;            /* have not read past end yet */
 
82
        state->how = LOOK;          /* look for gzip header */
 
83
    }
 
84
    state->seek = 0;                /* no seek request pending */
 
85
    gz_error(state, Z_OK, NULL);    /* clear error */
 
86
    state->x.pos = 0;               /* no uncompressed data yet */
 
87
    state->strm.avail_in = 0;       /* no input data yet */
 
88
}
 
89
 
 
90
/* Open a gzip file either by name or file descriptor. */
 
91
local gzFile gz_open(path, fd, mode)
 
92
    const char *path;
 
93
    int fd;
 
94
    const char *mode;
 
95
{
 
96
    gz_statep state;
 
97
 
 
98
    /* check input */
 
99
    if (path == NULL)
 
100
        return NULL;
 
101
 
 
102
    /* allocate gzFile structure to return */
 
103
    state = malloc(sizeof(gz_state));
 
104
    if (state == NULL)
 
105
        return NULL;
 
106
    state->size = 0;            /* no buffers allocated yet */
 
107
    state->want = GZBUFSIZE;    /* requested buffer size */
 
108
    state->msg = NULL;          /* no error message yet */
 
109
 
 
110
    /* interpret mode */
 
111
    state->mode = GZ_NONE;
 
112
    state->level = Z_DEFAULT_COMPRESSION;
 
113
    state->strategy = Z_DEFAULT_STRATEGY;
 
114
    state->direct = 0;
 
115
    while (*mode) {
 
116
        if (*mode >= '0' && *mode <= '9')
 
117
            state->level = *mode - '0';
 
118
        else
 
119
            switch (*mode) {
 
120
            case 'r':
 
121
                state->mode = GZ_READ;
 
122
                break;
 
123
#ifndef NO_GZCOMPRESS
 
124
            case 'w':
 
125
                state->mode = GZ_WRITE;
 
126
                break;
 
127
            case 'a':
 
128
                state->mode = GZ_APPEND;
 
129
                break;
 
130
#endif
 
131
            case '+':       /* can't read and write at the same time */
 
132
                free(state);
 
133
                return NULL;
 
134
            case 'b':       /* ignore -- will request binary anyway */
 
135
                break;
 
136
            case 'f':
 
137
                state->strategy = Z_FILTERED;
 
138
                break;
 
139
            case 'h':
 
140
                state->strategy = Z_HUFFMAN_ONLY;
 
141
                break;
 
142
            case 'R':
 
143
                state->strategy = Z_RLE;
 
144
                break;
 
145
            case 'F':
 
146
                state->strategy = Z_FIXED;
 
147
            case 'T':
 
148
                state->direct = 1;
 
149
            default:        /* could consider as an error, but just ignore */
 
150
                ;
 
151
            }
 
152
        mode++;
 
153
    }
 
154
 
 
155
    /* must provide an "r", "w", or "a" */
 
156
    if (state->mode == GZ_NONE) {
 
157
        free(state);
 
158
        return NULL;
 
159
    }
 
160
 
 
161
    /* can't force transparent read */
 
162
    if (state->mode == GZ_READ) {
 
163
        if (state->direct) {
 
164
            free(state);
 
165
            return NULL;
 
166
        }
 
167
        state->direct = 1;      /* for empty file */
 
168
    }
 
169
 
 
170
    /* save the path name for error messages */
 
171
    state->path = malloc(strlen(path) + 1);
 
172
    if (state->path == NULL) {
 
173
        free(state);
 
174
        return NULL;
 
175
    }
 
176
    strcpy(state->path, path);
 
177
 
 
178
    /* open the file with the appropriate mode (or just use fd) */
 
179
    state->fd = fd != -1 ? fd :
 
180
        open(path,
 
181
#ifdef O_LARGEFILE
 
182
            O_LARGEFILE |
 
183
#endif
 
184
#ifdef O_BINARY
 
185
            O_BINARY |
 
186
#endif
 
187
            (state->mode == GZ_READ ?
 
188
                O_RDONLY :
 
189
                (O_WRONLY | O_CREAT | (
 
190
                    state->mode == GZ_WRITE ?
 
191
                        O_TRUNC :
 
192
                        O_APPEND))),
 
193
            0666);
 
194
    if (state->fd == -1) {
 
195
        free(state->path);
 
196
        free(state);
 
197
        return NULL;
 
198
    }
 
199
    if (state->mode == GZ_APPEND)
 
200
        state->mode = GZ_WRITE;         /* simplify later checks */
 
201
 
 
202
    /* save the current position for rewinding (only if reading) */
 
203
    if (state->mode == GZ_READ) {
 
204
        state->start = LSEEK(state->fd, 0, SEEK_CUR);
 
205
        if (state->start == -1) state->start = 0;
 
206
    }
 
207
 
 
208
    /* initialize stream */
 
209
    gz_reset(state);
 
210
 
 
211
    /* return stream */
 
212
    return (gzFile)state;
 
213
}
 
214
 
 
215
/* -- see zlib.h -- */
 
216
gzFile ZEXPORT gzopen(path, mode)
 
217
    const char *path;
 
218
    const char *mode;
 
219
{
 
220
    return gz_open(path, -1, mode);
 
221
}
 
222
 
 
223
/* -- see zlib.h -- */
 
224
gzFile ZEXPORT gzopen64(path, mode)
 
225
    const char *path;
 
226
    const char *mode;
 
227
{
 
228
    return gz_open(path, -1, mode);
 
229
}
 
230
 
 
231
/* -- see zlib.h -- */
 
232
gzFile ZEXPORT gzdopen(fd, mode)
 
233
    int fd;
 
234
    const char *mode;
 
235
{
 
236
    char *path;         /* identifier for error messages */
 
237
    gzFile gz;
 
238
 
 
239
    if (fd == -1 || (path = malloc(7 + 3 * sizeof(int))) == NULL)
 
240
        return NULL;
 
241
    sprintf(path, "<fd:%d>", fd);   /* for debugging */
 
242
    gz = gz_open(path, fd, mode);
 
243
    free(path);
 
244
    return gz;
 
245
}
 
246
 
 
247
/* -- see zlib.h -- */
 
248
int ZEXPORT gzbuffer(file, size)
 
249
    gzFile file;
 
250
    unsigned size;
 
251
{
 
252
    gz_statep state;
 
253
 
 
254
    /* get internal structure and check integrity */
 
255
    if (file == NULL)
 
256
        return -1;
 
257
    state = (gz_statep)file;
 
258
    if (state->mode != GZ_READ && state->mode != GZ_WRITE)
 
259
        return -1;
 
260
 
 
261
    /* make sure we haven't already allocated memory */
 
262
    if (state->size != 0)
 
263
        return -1;
 
264
 
 
265
    /* check and set requested size */
 
266
    if (size < 2)
 
267
        size = 2;               /* need two bytes to check magic header */
 
268
    state->want = size;
 
269
    return 0;
 
270
}
 
271
 
 
272
/* -- see zlib.h -- */
 
273
int ZEXPORT gzrewind(file)
 
274
    gzFile file;
 
275
{
 
276
    gz_statep state;
 
277
 
 
278
    /* get internal structure */
 
279
    if (file == NULL)
 
280
        return -1;
 
281
    state = (gz_statep)file;
 
282
 
 
283
    /* check that we're reading and that there's no error */
 
284
    if (state->mode != GZ_READ ||
 
285
            (state->err != Z_OK && state->err != Z_BUF_ERROR))
 
286
        return -1;
 
287
 
 
288
    /* back up and start over */
 
289
    if (LSEEK(state->fd, state->start, SEEK_SET) == -1)
 
290
        return -1;
 
291
    gz_reset(state);
 
292
    return 0;
 
293
}
 
294
 
 
295
/* -- see zlib.h -- */
 
296
z_off64_t ZEXPORT gzseek64(file, offset, whence)
 
297
    gzFile file;
 
298
    z_off64_t offset;
 
299
    int whence;
 
300
{
 
301
    unsigned n;
 
302
    z_off64_t ret;
 
303
    gz_statep state;
 
304
 
 
305
    /* get internal structure and check integrity */
 
306
    if (file == NULL)
 
307
        return -1;
 
308
    state = (gz_statep)file;
 
309
    if (state->mode != GZ_READ && state->mode != GZ_WRITE)
 
310
        return -1;
 
311
 
 
312
    /* check that there's no error */
 
313
    if (state->err != Z_OK && state->err != Z_BUF_ERROR)
 
314
        return -1;
 
315
 
 
316
    /* can only seek from start or relative to current position */
 
317
    if (whence != SEEK_SET && whence != SEEK_CUR)
 
318
        return -1;
 
319
 
 
320
    /* normalize offset to a SEEK_CUR specification */
 
321
    if (whence == SEEK_SET)
 
322
        offset -= state->x.pos;
 
323
    else if (state->seek)
 
324
        offset += state->skip;
 
325
    state->seek = 0;
 
326
 
 
327
    /* if within raw area while reading, just go there */
 
328
    if (state->mode == GZ_READ && state->how == COPY &&
 
329
            state->x.pos + offset >= 0) {
 
330
        ret = LSEEK(state->fd, offset - state->x.have, SEEK_CUR);
 
331
        if (ret == -1)
 
332
            return -1;
 
333
        state->x.have = 0;
 
334
        state->eof = 0;
 
335
        state->past = 0;
 
336
        state->seek = 0;
 
337
        gz_error(state, Z_OK, NULL);
 
338
        state->strm.avail_in = 0;
 
339
        state->x.pos += offset;
 
340
        return state->x.pos;
 
341
    }
 
342
 
 
343
    /* calculate skip amount, rewinding if needed for back seek when reading */
 
344
    if (offset < 0) {
 
345
        if (state->mode != GZ_READ)         /* writing -- can't go backwards */
 
346
            return -1;
 
347
        offset += state->x.pos;
 
348
        if (offset < 0)                     /* before start of file! */
 
349
            return -1;
 
350
        if (gzrewind(file) == -1)           /* rewind, then skip to offset */
 
351
            return -1;
 
352
    }
 
353
 
 
354
    /* if reading, skip what's in output buffer (one less gzgetc() check) */
 
355
    if (state->mode == GZ_READ) {
 
356
        n = GT_OFF(state->x.have) || (z_off64_t)state->x.have > offset ?
 
357
            (unsigned)offset : state->x.have;
 
358
        state->x.have -= n;
 
359
        state->x.next += n;
 
360
        state->x.pos += n;
 
361
        offset -= n;
 
362
    }
 
363
 
 
364
    /* request skip (if not zero) */
 
365
    if (offset) {
 
366
        state->seek = 1;
 
367
        state->skip = offset;
 
368
    }
 
369
    return state->x.pos + offset;
 
370
}
 
371
 
 
372
/* -- see zlib.h -- */
 
373
z_off_t ZEXPORT gzseek(file, offset, whence)
 
374
    gzFile file;
 
375
    z_off_t offset;
 
376
    int whence;
 
377
{
 
378
    z_off64_t ret;
 
379
 
 
380
    ret = gzseek64(file, (z_off64_t)offset, whence);
 
381
    return ret == (z_off_t)ret ? (z_off_t)ret : -1;
 
382
}
 
383
 
 
384
/* -- see zlib.h -- */
 
385
z_off64_t ZEXPORT gztell64(file)
 
386
    gzFile file;
 
387
{
 
388
    gz_statep state;
 
389
 
 
390
    /* get internal structure and check integrity */
 
391
    if (file == NULL)
 
392
        return -1;
 
393
    state = (gz_statep)file;
 
394
    if (state->mode != GZ_READ && state->mode != GZ_WRITE)
 
395
        return -1;
 
396
 
 
397
    /* return position */
 
398
    return state->x.pos + (state->seek ? state->skip : 0);
 
399
}
 
400
 
 
401
/* -- see zlib.h -- */
 
402
z_off_t ZEXPORT gztell(file)
 
403
    gzFile file;
 
404
{
 
405
    z_off64_t ret;
 
406
 
 
407
    ret = gztell64(file);
 
408
    return ret == (z_off_t)ret ? (z_off_t)ret : -1;
 
409
}
 
410
 
 
411
/* -- see zlib.h -- */
 
412
z_off64_t ZEXPORT gzoffset64(file)
 
413
    gzFile file;
 
414
{
 
415
    z_off64_t offset;
 
416
    gz_statep state;
 
417
 
 
418
    /* get internal structure and check integrity */
 
419
    if (file == NULL)
 
420
        return -1;
 
421
    state = (gz_statep)file;
 
422
    if (state->mode != GZ_READ && state->mode != GZ_WRITE)
 
423
        return -1;
 
424
 
 
425
    /* compute and return effective offset in file */
 
426
    offset = LSEEK(state->fd, 0, SEEK_CUR);
 
427
    if (offset == -1)
 
428
        return -1;
 
429
    if (state->mode == GZ_READ)             /* reading */
 
430
        offset -= state->strm.avail_in;     /* don't count buffered input */
 
431
    return offset;
 
432
}
 
433
 
 
434
/* -- see zlib.h -- */
 
435
z_off_t ZEXPORT gzoffset(file)
 
436
    gzFile file;
 
437
{
 
438
    z_off64_t ret;
 
439
 
 
440
    ret = gzoffset64(file);
 
441
    return ret == (z_off_t)ret ? (z_off_t)ret : -1;
 
442
}
 
443
 
 
444
/* -- see zlib.h -- */
 
445
int ZEXPORT gzeof(file)
 
446
    gzFile file;
 
447
{
 
448
    gz_statep state;
 
449
 
 
450
    /* get internal structure and check integrity */
 
451
    if (file == NULL)
 
452
        return 0;
 
453
    state = (gz_statep)file;
 
454
    if (state->mode != GZ_READ && state->mode != GZ_WRITE)
 
455
        return 0;
 
456
 
 
457
    /* return end-of-file state */
 
458
    return state->mode == GZ_READ ? state->past : 0;
 
459
}
 
460
 
 
461
/* -- see zlib.h -- */
 
462
const char * ZEXPORT gzerror(file, errnum)
 
463
    gzFile file;
 
464
    int *errnum;
 
465
{
 
466
    gz_statep state;
 
467
 
 
468
    /* get internal structure and check integrity */
 
469
    if (file == NULL)
 
470
        return NULL;
 
471
    state = (gz_statep)file;
 
472
    if (state->mode != GZ_READ && state->mode != GZ_WRITE)
 
473
        return NULL;
 
474
 
 
475
    /* return error information */
 
476
    if (errnum != NULL)
 
477
        *errnum = state->err;
 
478
    return state->msg == NULL ? "" : state->msg;
 
479
}
 
480
 
 
481
/* -- see zlib.h -- */
 
482
void ZEXPORT gzclearerr(file)
 
483
    gzFile file;
 
484
{
 
485
    gz_statep state;
 
486
 
 
487
    /* get internal structure and check integrity */
 
488
    if (file == NULL)
 
489
        return;
 
490
    state = (gz_statep)file;
 
491
    if (state->mode != GZ_READ && state->mode != GZ_WRITE)
 
492
        return;
 
493
 
 
494
    /* clear error and end-of-file */
 
495
    if (state->mode == GZ_READ) {
 
496
        state->eof = 0;
 
497
        state->past = 0;
 
498
    }
 
499
    gz_error(state, Z_OK, NULL);
 
500
}
 
501
 
 
502
/* Create an error message in allocated memory and set state->err and
 
503
   state->msg accordingly.  Free any previous error message already there.  Do
 
504
   not try to free or allocate space if the error is Z_MEM_ERROR (out of
 
505
   memory).  Simply save the error message as a static string.  If there is an
 
506
   allocation failure constructing the error message, then convert the error to
 
507
   out of memory. */
 
508
void ZLIB_INTERNAL gz_error(state, err, msg)
 
509
    gz_statep state;
 
510
    int err;
 
511
    const char *msg;
 
512
{
 
513
    /* free previously allocated message and clear */
 
514
    if (state->msg != NULL) {
 
515
        if (state->err != Z_MEM_ERROR)
 
516
            free(state->msg);
 
517
        state->msg = NULL;
 
518
    }
 
519
 
 
520
    /* if fatal, set state->x.have to 0 so that the gzgetc() macro fails */
 
521
    if (err != Z_OK && err != Z_BUF_ERROR)
 
522
        state->x.have = 0;
 
523
 
 
524
    /* set error code, and if no message, then done */
 
525
    state->err = err;
 
526
    if (msg == NULL)
 
527
        return;
 
528
 
 
529
    /* for an out of memory error, save as static string */
 
530
    if (err == Z_MEM_ERROR) {
 
531
        state->msg = (char *)msg;
 
532
        return;
 
533
    }
 
534
 
 
535
    /* construct error message with path */
 
536
    if ((state->msg = malloc(strlen(state->path) + strlen(msg) + 3)) == NULL) {
 
537
        state->err = Z_MEM_ERROR;
 
538
        state->msg = (char *)"out of memory";
 
539
        return;
 
540
    }
 
541
    strcpy(state->msg, state->path);
 
542
    strcat(state->msg, ": ");
 
543
    strcat(state->msg, msg);
 
544
    return;
 
545
}
 
546
 
 
547
#ifndef INT_MAX
 
548
/* portably return maximum value for an int (when limits.h presumed not
 
549
   available) -- we need to do this to cover cases where 2's complement not
 
550
   used, since C standard permits 1's complement and sign-bit representations,
 
551
   otherwise we could just use ((unsigned)-1) >> 1 */
 
552
unsigned ZLIB_INTERNAL gz_intmax()
 
553
{
 
554
    unsigned p, q;
 
555
 
 
556
    p = 1;
 
557
    do {
 
558
        q = p;
 
559
        p <<= 1;
 
560
        p++;
 
561
    } while (p > q);
 
562
    return q >> 1;
 
563
}
 
564
#endif