← Back to branch summary

~vanvugt/ubuntu/oneiric/mediatomb/fix-770964-784431

« back to all changes in this revision

Viewing changes to src/mpegdemux/mpeg_parse.c

  • Committer: Bazaar Package Importer
  • Author(s): Andres Mejia
  • Date: 2009-04-22 21:39:19 UTC
  • mto: (4.2.1 sid)
  • mto: This revision was merged to the branch mainline in revision 9.
  • Revision ID: james.westby@ubuntu.com-20090422213919-52m015y6gcpv1m1g
Tags: upstream-0.12.0~svn2018
Import upstream version 0.12.0~svn2018

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/mpegdemux/mpeg_parse.c
 
1
/*****************************************************************************
 
2
 * mpegdemux                                                                 *
 
3
 *****************************************************************************/
 
4
 
 
5
/*****************************************************************************
 
6
 * File name:     mpeg_parse.c                                               *
 
7
 * Created:       2003-02-01 by Hampa Hug <hampa@hampa.ch>                   *
 
8
 * Last modified: 2003-09-10 by Hampa Hug <hampa@hampa.ch>                   *
 
9
 * Copyright:     (C) 2003 by Hampa Hug <hampa@hampa.ch>                     *
 
10
 *****************************************************************************/
 
11
 
 
12
/*****************************************************************************
 
13
 * This program is free software. You can redistribute it and / or modify it *
 
14
 * under the terms of the GNU General Public License version 2 as  published *
 
15
 * by the Free Software Foundation.                                          *
 
16
 *                                                                           *
 
17
 * This program is distributed in the hope  that  it  will  be  useful,  but *
 
18
 * WITHOUT  ANY   WARRANTY,   without   even   the   implied   warranty   of *
 
19
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU  General *
 
20
 * Public License for more details.                                          *
 
21
 *****************************************************************************/
 
22
 
 
23
/* $Id: mpeg_parse.c 67 2004-01-02 18:20:15Z hampa $ */
 
24
 
 
25
// The code has been modified to use file descriptors instead of FILE streams.
 
26
// Only functionality needed in MediaTomb remains, all extra features are
 
27
// stripped out.
 
28
 
 
29
 
 
30
#ifdef HAVE_CONFIG_H
 
31
    #include "autoconfig.h"
 
32
#endif
 
33
 
 
34
#ifdef HAVE_LIBDVDNAV
 
35
 
 
36
#include <stdlib.h>
 
37
#include <string.h>
 
38
#include <unistd.h>
 
39
#include <sys/types.h>
 
40
#include <sys/stat.h>
 
41
#include <fcntl.h>
 
42
 
 
43
#include "mpeg_parse.h"
 
44
 
 
45
 
 
46
mpeg_demux_t *mpegd_open_fd (mpeg_demux_t *mpeg, int fd, int close_file)
 
47
{
 
48
  if (mpeg == NULL) {
 
49
    mpeg = (mpeg_demux_t *) malloc (sizeof (mpeg_demux_t));
 
50
    if (mpeg == NULL) {
 
51
      return (NULL);
 
52
    }
 
53
    mpeg->free = 1;
 
54
  }
 
55
  else {
 
56
    mpeg->free = 0;
 
57
  }
 
58
 
 
59
  mpeg->fd = fd;
 
60
  mpeg->close = close_file;
 
61
 
 
62
  mpeg->ofs = 0;
 
63
 
 
64
  mpeg->buf_i = 0;
 
65
  mpeg->buf_n = 0;
 
66
 
 
67
  mpeg->ext = -1;
 
68
 
 
69
  mpeg->mpeg_skip = NULL;
 
70
  mpeg->mpeg_system_header = NULL;
 
71
  mpeg->mpeg_packet = NULL;
 
72
  mpeg->mpeg_packet_check = NULL;
 
73
  mpeg->mpeg_pack = NULL;
 
74
  mpeg->mpeg_end = NULL;
 
75
 
 
76
  mpegd_reset_stats (mpeg);
 
77
 
 
78
  return (mpeg);
 
79
}
 
80
 
 
81
mpeg_demux_t *mpegd_open (mpeg_demux_t *mpeg, const char *fname)
 
82
{
 
83
  int fd;
 
84
 
 
85
  fd = open (fname, O_RDONLY);
 
86
  if (fd == -1) {
 
87
    return (NULL);
 
88
  }
 
89
 
 
90
  mpeg = mpegd_open_fd (mpeg, fd, 1);
 
91
 
 
92
  return (mpeg);
 
93
}
 
94
 
 
95
void mpegd_close (mpeg_demux_t *mpeg)
 
96
{
 
97
  if (mpeg->close) {
 
98
    close (mpeg->fd);
 
99
  }
 
100
 
 
101
  if (mpeg->free) {
 
102
    free (mpeg);
 
103
  }
 
104
}
 
105
 
 
106
void mpegd_reset_stats (mpeg_demux_t *mpeg)
 
107
{
 
108
  unsigned i;
 
109
 
 
110
  mpeg->shdr_cnt = 0;
 
111
  mpeg->pack_cnt = 0;
 
112
  mpeg->packet_cnt = 0;
 
113
  mpeg->end_cnt = 0;
 
114
  mpeg->skip_cnt = 0;
 
115
 
 
116
  for (i = 0; i < 256; i++) {
 
117
    mpeg->streams[i].packet_cnt = 0;
 
118
    mpeg->streams[i].size = 0;
 
119
    mpeg->substreams[i].packet_cnt = 0;
 
120
    mpeg->substreams[i].size = 0;
 
121
  }
 
122
}
 
123
 
 
124
static
 
125
int mpegd_buffer_fill (mpeg_demux_t *mpeg)
 
126
{
 
127
  unsigned i, n;
 
128
  size_t   r;
 
129
 
 
130
  if ((mpeg->buf_i > 0) && (mpeg->buf_n > 0)) {
 
131
    for (i = 0; i < mpeg->buf_n; i++) {
 
132
      mpeg->buf[i] = mpeg->buf[mpeg->buf_i + i];
 
133
    }
 
134
  }
 
135
 
 
136
  mpeg->buf_i = 0;
 
137
 
 
138
  n = MPEG_DEMUX_BUFFER - mpeg->buf_n;
 
139
 
 
140
  if (n > 0) {
 
141
    r = read (mpeg->fd, mpeg->buf + mpeg->buf_n, n);
 
142
    if (r < 0) {
 
143
      return (1);
 
144
    }
 
145
 
 
146
    mpeg->buf_n += (unsigned) r;
 
147
  }
 
148
 
 
149
  return (0);
 
150
}
 
151
 
 
152
static
 
153
int mpegd_need_bits (mpeg_demux_t *mpeg, unsigned n)
 
154
{
 
155
  n = (n + 7) / 8;
 
156
 
 
157
  if (n > mpeg->buf_n) {
 
158
    mpegd_buffer_fill (mpeg);
 
159
  }
 
160
 
 
161
  if (n > mpeg->buf_n) {
 
162
    return (1);
 
163
  }
 
164
 
 
165
  return (0);
 
166
}
 
167
 
 
168
unsigned long mpegd_get_bits (mpeg_demux_t *mpeg, unsigned i, unsigned n)
 
169
{
 
170
  unsigned long r;
 
171
  unsigned long v, m;
 
172
  unsigned      b_i, b_n;
 
173
  unsigned char *buf;
 
174
 
 
175
  if (mpegd_need_bits (mpeg, i + n)) {
 
176
    return (0);
 
177
  }
 
178
 
 
179
  buf = mpeg->buf + mpeg->buf_i;
 
180
 
 
181
  r = 0;
 
182
 
 
183
  /* aligned bytes */
 
184
  if (((i | n) & 7) == 0) {
 
185
    i = i / 8;
 
186
    n = n / 8;
 
187
    while (n > 0) {
 
188
      r = (r << 8) | buf[i];
 
189
      i += 1;
 
190
      n -= 1;
 
191
    }
 
192
    return (r);
 
193
  }
 
194
 
 
195
 
 
196
  while (n > 0) {
 
197
    b_n = 8 - (i & 7);
 
198
    if (b_n > n) {
 
199
      b_n = n;
 
200
    }
 
201
 
 
202
    b_i = 8 - (i & 7) - b_n;
 
203
 
 
204
    m = (1 << b_n) - 1;
 
205
    v = (buf[i >> 3] >> b_i) & m;
 
206
 
 
207
    r = (r << b_n) | v;
 
208
 
 
209
    i += b_n;
 
210
    n -= b_n;
 
211
  }
 
212
 
 
213
  return (r);
 
214
}
 
215
 
 
216
int mpegd_skip (mpeg_demux_t *mpeg, unsigned n)
 
217
{
 
218
  size_t r;
 
219
 
 
220
  mpeg->ofs += n;
 
221
 
 
222
  if (n <= mpeg->buf_n) {
 
223
    mpeg->buf_i += n;
 
224
    mpeg->buf_n -= n;
 
225
    return (0);
 
226
  }
 
227
 
 
228
  n -= mpeg->buf_n;
 
229
  mpeg->buf_i = 0;
 
230
  mpeg->buf_n = 0;
 
231
 
 
232
  while (n > 0) {
 
233
    if (n <= MPEG_DEMUX_BUFFER) {
 
234
      r = read (mpeg->fd ,mpeg->buf, n);
 
235
    }
 
236
    else {
 
237
      r = read (mpeg->fd, mpeg->buf, MPEG_DEMUX_BUFFER);
 
238
    }
 
239
 
 
240
    if (r <= 0) {
 
241
      return (1);
 
242
    }
 
243
 
 
244
    n -= (unsigned) r;
 
245
  }
 
246
 
 
247
  return (0);
 
248
}
 
249
 
 
250
unsigned mpegd_read (mpeg_demux_t *mpeg, void *buf, unsigned n)
 
251
{
 
252
  unsigned      ret;
 
253
  unsigned      i;
 
254
  unsigned char *tmp;
 
255
 
 
256
  tmp = (unsigned char *) buf;
 
257
 
 
258
  i = (n < mpeg->buf_n) ? n : mpeg->buf_n;
 
259
 
 
260
  ret = i;
 
261
 
 
262
  if (i > 0) {
 
263
    memcpy (tmp, &mpeg->buf[mpeg->buf_i], i);
 
264
 
 
265
    tmp += i;
 
266
    mpeg->buf_i += i;
 
267
    mpeg->buf_n -= i;
 
268
    n -= i;
 
269
  }
 
270
 
 
271
  if (n > 0) {
 
272
    ret += read (mpeg->fd, tmp, n);
 
273
  }
 
274
 
 
275
  mpeg->ofs += ret;
 
276
 
 
277
  return (ret);
 
278
}
 
279
 
 
280
int mpegd_set_offset (mpeg_demux_t *mpeg, unsigned long long ofs)
 
281
{
 
282
  if (ofs == mpeg->ofs) {
 
283
    return (0);
 
284
  }
 
285
 
 
286
  if (ofs > mpeg->ofs) {
 
287
    return (mpegd_skip (mpeg, (unsigned long) (ofs - mpeg->ofs)));
 
288
  }
 
289
 
 
290
  return (1);
 
291
}
 
292
 
 
293
static
 
294
int mpegd_seek_header (mpeg_demux_t *mpeg)
 
295
{
 
296
  unsigned long long ofs;
 
297
 
 
298
  while (mpegd_get_bits (mpeg, 0, 24) != 1) {
 
299
    ofs = mpeg->ofs + 1;
 
300
 
 
301
    if (mpeg->mpeg_skip != NULL) {
 
302
      if (mpeg->mpeg_skip (mpeg)) {
 
303
        return (1);
 
304
      }
 
305
    }
 
306
 
 
307
    if (mpegd_set_offset (mpeg, ofs)) {
 
308
      return (1);
 
309
    }
 
310
 
 
311
    mpeg->skip_cnt += 1;
 
312
  }
 
313
 
 
314
  return (0);
 
315
}
 
316
 
 
317
static
 
318
int mpegd_parse_system_header (mpeg_demux_t *mpeg)
 
319
{
 
320
  unsigned long long ofs;
 
321
 
 
322
  mpeg->shdr.size = mpegd_get_bits (mpeg, 32, 16) + 6;
 
323
 
 
324
  mpeg->shdr.fixed = mpegd_get_bits (mpeg, 78, 1);
 
325
  mpeg->shdr.csps = mpegd_get_bits (mpeg, 79, 1);
 
326
 
 
327
  mpeg->shdr_cnt += 1;
 
328
 
 
329
  ofs = mpeg->ofs + mpeg->shdr.size;
 
330
 
 
331
  if (mpeg->mpeg_system_header != NULL) {
 
332
    if (mpeg->mpeg_system_header (mpeg)) {
 
333
      return (1);
 
334
    }
 
335
  }
 
336
 
 
337
  mpegd_set_offset (mpeg, ofs);
 
338
 
 
339
  return (0);
 
340
}
 
341
 
 
342
static
 
343
int mpegd_parse_packet1 (mpeg_demux_t *mpeg, unsigned i)
 
344
{
 
345
  unsigned           val;
 
346
  unsigned long long tmp;
 
347
 
 
348
  mpeg->packet.type = 1;
 
349
 
 
350
  if (mpegd_get_bits (mpeg, i, 2) == 0x01) {
 
351
    i += 16;
 
352
  }
 
353
 
 
354
  val = mpegd_get_bits (mpeg, i, 8);
 
355
 
 
356
  if ((val & 0xf0) == 0x20) {
 
357
    tmp = mpegd_get_bits (mpeg, i + 4, 3);
 
358
    tmp = (tmp << 15) | mpegd_get_bits (mpeg, i + 8, 15);
 
359
    tmp = (tmp << 15) | mpegd_get_bits (mpeg, i + 24, 15);
 
360
 
 
361
    mpeg->packet.have_pts = 1;
 
362
    mpeg->packet.pts = tmp;
 
363
 
 
364
    i += 40;
 
365
  }
 
366
  else if ((val & 0xf0) == 0x30) {
 
367
    tmp = mpegd_get_bits (mpeg, i + 4, 3);
 
368
    tmp = (tmp << 15) | mpegd_get_bits (mpeg, i + 8, 15);
 
369
    tmp = (tmp << 15) | mpegd_get_bits (mpeg, i + 24, 15);
 
370
 
 
371
    mpeg->packet.have_pts = 1;
 
372
    mpeg->packet.pts = tmp;
 
373
 
 
374
    tmp = mpegd_get_bits (mpeg, i + 44, 3);
 
375
    tmp = (tmp << 15) | mpegd_get_bits (mpeg, i + 48, 15);
 
376
    tmp = (tmp << 15) | mpegd_get_bits (mpeg, i + 64, 15);
 
377
 
 
378
    mpeg->packet.have_dts = 1;
 
379
    mpeg->packet.dts = tmp;
 
380
 
 
381
    i += 80;
 
382
  }
 
383
  else if (val == 0x0f) {
 
384
    i += 8;
 
385
  }
 
386
 
 
387
  mpeg->packet.offset = i / 8;
 
388
 
 
389
  return (0);
 
390
}
 
391
 
 
392
static
 
393
int mpegd_parse_packet2 (mpeg_demux_t *mpeg, unsigned i)
 
394
{
 
395
  unsigned           pts_dts_flag;
 
396
  unsigned           cnt;
 
397
  unsigned long long tmp;
 
398
 
 
399
  mpeg->packet.type = 2;
 
400
 
 
401
  pts_dts_flag = mpegd_get_bits (mpeg, i + 8, 2);
 
402
  cnt = mpegd_get_bits (mpeg, i + 16, 8);
 
403
 
 
404
  if (pts_dts_flag == 0x02) {
 
405
    if (mpegd_get_bits (mpeg, i + 24, 4) == 0x02) {
 
406
      tmp = mpegd_get_bits (mpeg, i + 28, 3);
 
407
      tmp = (tmp << 15) | mpegd_get_bits (mpeg, i + 32, 15);
 
408
      tmp = (tmp << 15) | mpegd_get_bits (mpeg, i + 48, 15);
 
409
 
 
410
      mpeg->packet.have_pts = 1;
 
411
      mpeg->packet.pts = tmp;
 
412
    }
 
413
  }
 
414
  else if ((pts_dts_flag & 0x03) == 0x03) {
 
415
    if (mpegd_get_bits (mpeg, i + 24, 4) == 0x03) {
 
416
      tmp = mpegd_get_bits (mpeg, i + 28, 3);
 
417
      tmp = (tmp << 15) | mpegd_get_bits (mpeg, i + 32, 15);
 
418
      tmp = (tmp << 15) | mpegd_get_bits (mpeg, i + 48, 15);
 
419
 
 
420
      mpeg->packet.have_pts = 1;
 
421
      mpeg->packet.pts = tmp;
 
422
    }
 
423
 
 
424
    if (mpegd_get_bits (mpeg, i + 64, 4) == 0x01) {
 
425
      tmp = mpegd_get_bits (mpeg, i + 68, 3);
 
426
      tmp = (tmp << 15) | mpegd_get_bits (mpeg, i + 72, 15);
 
427
      tmp = (tmp << 15) | mpegd_get_bits (mpeg, i + 88, 15);
 
428
 
 
429
      mpeg->packet.have_dts = 1;
 
430
      mpeg->packet.dts = tmp;
 
431
    }
 
432
  }
 
433
 
 
434
  i += 8 * (cnt + 3);
 
435
 
 
436
  mpeg->packet.offset = i / 8;
 
437
 
 
438
  return (0);
 
439
}
 
440
 
 
441
static
 
442
int mpegd_parse_packet (mpeg_demux_t *mpeg)
 
443
{
 
444
  unsigned           i;
 
445
  unsigned           sid, ssid;
 
446
  unsigned long long ofs;
 
447
 
 
448
  mpeg->packet.type = 0;
 
449
 
 
450
  sid = mpegd_get_bits (mpeg, 24, 8);
 
451
  ssid = 0;
 
452
 
 
453
  mpeg->packet.sid = sid;
 
454
  mpeg->packet.ssid = ssid;
 
455
 
 
456
  mpeg->packet.size = mpegd_get_bits (mpeg, 32, 16) + 6;
 
457
  mpeg->packet.offset = 6;
 
458
 
 
459
  mpeg->packet.have_pts = 0;
 
460
  mpeg->packet.pts = 0;
 
461
 
 
462
  mpeg->packet.have_dts = 0;
 
463
  mpeg->packet.dts = 0;
 
464
 
 
465
  i = 48;
 
466
 
 
467
  if (((sid >= 0xc0) && (sid < 0xf0)) || (sid == 0xbd)) {
 
468
    while (mpegd_get_bits (mpeg, i, 8) == 0xff) {
 
469
      if (i > (48 + 16 * 8)) {
 
470
        break;
 
471
      }
 
472
      i += 8;
 
473
    }
 
474
 
 
475
    if (mpegd_get_bits (mpeg, i, 2) == 0x02) {
 
476
      if (mpegd_parse_packet2 (mpeg, i)) {
 
477
        return (1);
 
478
      }
 
479
    }
 
480
    else {
 
481
      if (mpegd_parse_packet1 (mpeg, i)) {
 
482
        return (1);
 
483
      }
 
484
    }
 
485
  }
 
486
  else if (sid == 0xbe) {
 
487
    mpeg->packet.type = 1;
 
488
  }
 
489
 
 
490
  if (sid == 0xbd) {
 
491
    ssid = mpegd_get_bits (mpeg, 8 * mpeg->packet.offset, 8);
 
492
    mpeg->packet.ssid = ssid;
 
493
  }
 
494
 
 
495
  if ((mpeg->mpeg_packet_check != NULL) && mpeg->mpeg_packet_check (mpeg)) {
 
496
    if (mpegd_skip (mpeg, 1)) {
 
497
      return (1);
 
498
    }
 
499
  }
 
500
  else {
 
501
    mpeg->packet_cnt += 1;
 
502
    mpeg->streams[sid].packet_cnt += 1;
 
503
    mpeg->streams[sid].size += mpeg->packet.size - mpeg->packet.offset;
 
504
 
 
505
    if (sid == 0xbd) {
 
506
      mpeg->substreams[ssid].packet_cnt += 1;
 
507
      mpeg->substreams[ssid].size += mpeg->packet.size - mpeg->packet.offset;
 
508
    }
 
509
 
 
510
    ofs = mpeg->ofs + mpeg->packet.size;
 
511
 
 
512
    if (mpeg->mpeg_packet != NULL) {
 
513
      if (mpeg->mpeg_packet (mpeg)) {
 
514
        return (1);
 
515
      }
 
516
    }
 
517
 
 
518
    mpegd_set_offset (mpeg, ofs);
 
519
  }
 
520
 
 
521
  return (0);
 
522
}
 
523
 
 
524
static
 
525
int mpegd_parse_pack (mpeg_demux_t *mpeg)
 
526
{
 
527
  unsigned           sid;
 
528
  unsigned long long ofs;
 
529
 
 
530
  if (mpegd_get_bits (mpeg, 32, 4) == 0x02) {
 
531
    mpeg->pack.type = 1;
 
532
    mpeg->pack.scr = mpegd_get_bits (mpeg, 36, 3);
 
533
    mpeg->pack.scr = (mpeg->pack.scr << 15) | mpegd_get_bits (mpeg, 40, 15);
 
534
    mpeg->pack.scr = (mpeg->pack.scr << 15) | mpegd_get_bits (mpeg, 56, 15);
 
535
    mpeg->pack.mux_rate = mpegd_get_bits (mpeg, 73, 22);
 
536
    mpeg->pack.stuff = 0;
 
537
    mpeg->pack.size = 12;
 
538
  }
 
539
  else if (mpegd_get_bits (mpeg, 32, 2) == 0x01) {
 
540
    mpeg->pack.type = 2;
 
541
    mpeg->pack.scr = mpegd_get_bits (mpeg, 34, 3);
 
542
    mpeg->pack.scr = (mpeg->pack.scr << 15) | mpegd_get_bits (mpeg, 38, 15);
 
543
    mpeg->pack.scr = (mpeg->pack.scr << 15) | mpegd_get_bits (mpeg, 54, 15);
 
544
    mpeg->pack.mux_rate = mpegd_get_bits (mpeg, 80, 22);
 
545
    mpeg->pack.stuff = mpegd_get_bits (mpeg, 109, 3);
 
546
    mpeg->pack.size = 14 + mpeg->pack.stuff;
 
547
  }
 
548
  else {
 
549
    mpeg->pack.type = 0;
 
550
    mpeg->pack.scr = 0;
 
551
    mpeg->pack.mux_rate = 0;
 
552
    mpeg->pack.size = 4;
 
553
  }
 
554
 
 
555
  ofs = mpeg->ofs + mpeg->pack.size;
 
556
 
 
557
  mpeg->pack_cnt += 1;
 
558
 
 
559
  if (mpeg->mpeg_pack != NULL) {
 
560
    if (mpeg->mpeg_pack (mpeg)) {
 
561
      return (1);
 
562
    }
 
563
  }
 
564
 
 
565
  mpegd_set_offset (mpeg, ofs);
 
566
 
 
567
  mpegd_seek_header (mpeg);
 
568
 
 
569
  if (mpegd_get_bits (mpeg, 0, 32) == MPEG_SYSTEM_HEADER) {
 
570
    if (mpegd_parse_system_header (mpeg)) {
 
571
      return (1);
 
572
    }
 
573
 
 
574
    mpegd_seek_header (mpeg);
 
575
  }
 
576
 
 
577
  while (mpegd_get_bits (mpeg, 0, 24) == MPEG_PACKET_START) {
 
578
    sid = mpegd_get_bits (mpeg, 24, 8);
 
579
 
 
580
    if ((sid == 0xba) || (sid == 0xb9) || (sid == 0xbb)) {
 
581
      break;
 
582
    }
 
583
    else {
 
584
      mpegd_parse_packet (mpeg);
 
585
    }
 
586
 
 
587
    mpegd_seek_header (mpeg);
 
588
  }
 
589
 
 
590
  return (0);
 
591
}
 
592
 
 
593
int mpegd_parse (mpeg_demux_t *mpeg)
 
594
{
 
595
  unsigned long long ofs;
 
596
 
 
597
  while (1) {
 
598
    if (mpegd_seek_header (mpeg)) {
 
599
      return (0);
 
600
    }
 
601
 
 
602
    switch (mpegd_get_bits (mpeg, 0, 32)) {
 
603
      case MPEG_PACK_START:
 
604
        if (mpegd_parse_pack (mpeg)) {
 
605
          return (1);
 
606
        }
 
607
        break;
 
608
 
 
609
      case MPEG_END_CODE:
 
610
        mpeg->end_cnt += 1;
 
611
 
 
612
        ofs = mpeg->ofs + 4;
 
613
 
 
614
        if (mpeg->mpeg_end != NULL) {
 
615
          if (mpeg->mpeg_end (mpeg)) {
 
616
            return (1);
 
617
          }
 
618
        }
 
619
 
 
620
        if (mpegd_set_offset (mpeg, ofs)) {
 
621
          return (1);
 
622
        }
 
623
        break;
 
624
 
 
625
      default:
 
626
        ofs = mpeg->ofs + 1;
 
627
 
 
628
        if (mpeg->mpeg_skip != NULL) {
 
629
          if (mpeg->mpeg_skip (mpeg)) {
 
630
            return (1);
 
631
          }
 
632
        }
 
633
 
 
634
        if (mpegd_set_offset (mpeg, ofs)) {
 
635
          return (0);
 
636
        }
 
637
 
 
638
        break;
 
639
    }
 
640
  }
 
641
 
 
642
  return (0);
 
643
}
 
644
 
 
645
#endif//HAVE_LIBDVDNAV
 
646