Disc reading libs want ANSI rather than UTF-8 paths - fixes #1560
[vlc.git] / modules / access / dvdread.c
1 /*****************************************************************************
2  * dvdread.c : DvdRead input module for vlc
3  *****************************************************************************
4  * Copyright (C) 2001-2006 the VideoLAN team
5  * $Id$
6  *
7  * Authors: St├ęphane Borel <stef@via.ecp.fr>
8  *          Gildas Bazin <gbazin@videolan.org>
9  *
10  * This program is free software; you can redistribute it and/or modify
11  * it under the terms of the GNU General Public License as published by
12  * the Free Software Foundation; either version 2 of the License, or
13  * (at your option) any later version.
14  *
15  * This program is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  * GNU General Public License for more details.
19  *
20  * You should have received a copy of the GNU General Public License
21  * along with this program; if not, write to the Free Software
22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
23  *****************************************************************************/
24
25 /*****************************************************************************
26  * Preamble
27  *****************************************************************************/
28
29 #ifdef HAVE_CONFIG_H
30 # include "config.h"
31 #endif
32
33 #include <vlc/vlc.h>
34 #include <vlc_input.h>
35 #include <vlc_access.h>
36 #include <vlc_charset.h>
37
38 #include <vlc_interface.h>
39
40 #include "iso_lang.h"
41
42 #include "../demux/ps.h"
43
44 #ifdef HAVE_UNISTD_H
45 #   include <unistd.h>
46 #endif
47
48 #include <fcntl.h>
49 #include <sys/types.h>
50 #include <sys/stat.h>
51
52 #include <dvdread/dvd_reader.h>
53 #include <dvdread/ifo_types.h>
54 #include <dvdread/ifo_read.h>
55 #include <dvdread/nav_read.h>
56 #include <dvdread/nav_print.h>
57
58 /*****************************************************************************
59  * Module descriptor
60  *****************************************************************************/
61 #define ANGLE_TEXT N_("DVD angle")
62 #define ANGLE_LONGTEXT N_( \
63     "Default DVD angle." )
64
65 #define CACHING_TEXT N_("Caching value in ms")
66 #define CACHING_LONGTEXT N_( \
67     "Caching value for DVDs. " \
68     "This value should be set in milliseconds." )
69
70 #define CSSMETHOD_TEXT N_("Method used by libdvdcss for decryption")
71 #define CSSMETHOD_LONGTEXT N_( \
72     "Set the method used by libdvdcss for key decryption.\n" \
73     "title: decrypted title key is guessed from the encrypted sectors of " \
74            "the stream. Thus it should work with a file as well as the " \
75            "DVD device. But it sometimes takes much time to decrypt a title " \
76            "key and may even fail. With this method, the key is only checked "\
77            "at the beginning of each title, so it won't work if the key " \
78            "changes in the middle of a title.\n" \
79     "disc: the disc key is first cracked, then all title keys can be " \
80            "decrypted instantly, which allows us to check them often.\n" \
81     "key: the same as \"disc\" if you don't have a file with player keys " \
82            "at compilation time. If you do, the decryption of the disc key " \
83            "will be faster with this method. It is the one that was used by " \
84            "libcss.\n" \
85     "The default method is: key.")
86
87 static const char *psz_css_list[] = { "title", "disc", "key" };
88 static const char *psz_css_list_text[] = { N_("title"), N_("Disc"), N_("Key") };
89
90 static int  Open ( vlc_object_t * );
91 static void Close( vlc_object_t * );
92
93 vlc_module_begin();
94     set_shortname( _("DVD without menus") );
95     set_description( _("DVDRead Input (DVD without menu support)") );
96     set_category( CAT_INPUT );
97     set_subcategory( SUBCAT_INPUT_ACCESS );
98     add_integer( "dvdread-angle", 1, NULL, ANGLE_TEXT,
99         ANGLE_LONGTEXT, false );
100     add_integer( "dvdread-caching", DEFAULT_PTS_DELAY / 1000, NULL,
101         CACHING_TEXT, CACHING_LONGTEXT, true );
102     add_string( "dvdread-css-method", NULL, NULL, CSSMETHOD_TEXT,
103                 CSSMETHOD_LONGTEXT, true );
104         change_string_list( psz_css_list, psz_css_list_text, 0 );
105     set_capability( "access_demux", 0 );
106     add_shortcut( "dvd" );
107     add_shortcut( "dvdread" );
108     add_shortcut( "dvdsimple" );
109     set_callbacks( Open, Close );
110 vlc_module_end();
111
112 /* how many blocks DVDRead will read in each loop */
113 #define DVD_BLOCK_READ_ONCE 4
114
115 /*****************************************************************************
116  * Local prototypes
117  *****************************************************************************/
118
119 struct demux_sys_t
120 {
121     /* DVDRead state */
122     dvd_reader_t *p_dvdread;
123     dvd_file_t   *p_title;
124
125     ifo_handle_t *p_vmg_file;
126     ifo_handle_t *p_vts_file;
127
128     int i_title;
129     int i_chapter, i_chapters;
130     int i_angle, i_angles;
131
132     tt_srpt_t    *p_tt_srpt;
133     pgc_t        *p_cur_pgc;
134     dsi_t        dsi_pack;
135     int          i_ttn;
136
137     int i_pack_len;
138     int i_cur_block;
139     int i_next_vobu;
140
141     int i_mux_rate;
142
143     /* Current title start/end blocks */
144     int i_title_start_block;
145     int i_title_end_block;
146     int i_title_blocks;
147     int i_title_offset;
148     mtime_t i_title_cur_time;
149
150     int i_title_start_cell;
151     int i_title_end_cell;
152     int i_cur_cell;
153     int i_next_cell;
154     mtime_t i_cell_cur_time;
155     mtime_t i_cell_duration;
156
157     /* Track */
158     ps_track_t    tk[PS_TK_COUNT];
159
160     int           i_titles;
161     input_title_t **titles;
162
163     /* Video */
164     int i_aspect;
165
166     /* SPU */
167     uint32_t clut[16];
168 };
169
170 static int Control   ( demux_t *, int, va_list );
171 static int Demux     ( demux_t * );
172 static int DemuxBlock( demux_t *, uint8_t *, int );
173
174 static void DemuxTitles( demux_t *, int * );
175 static void ESNew( demux_t *, int, int );
176
177 static int  DvdReadSetArea  ( demux_t *, int, int, int );
178 static void DvdReadSeek     ( demux_t *, int );
179 static void DvdReadHandleDSI( demux_t *, uint8_t * );
180 static void DvdReadFindCell ( demux_t * );
181
182 /*****************************************************************************
183  * Open:
184  *****************************************************************************/
185 static int Open( vlc_object_t *p_this )
186 {
187     demux_t      *p_demux = (demux_t*)p_this;
188     demux_sys_t  *p_sys;
189     char         *psz_name;
190     char         *psz_dvdcss_env;
191     dvd_reader_t *p_dvdread;
192     ifo_handle_t *p_vmg_file;
193     vlc_value_t  val;
194
195     if( !p_demux->psz_path || !*p_demux->psz_path )
196     {
197         /* Only when selected */
198         if( !p_this->b_force ) return VLC_EGENERIC;
199
200         psz_name = var_CreateGetString( p_this, "dvd" );
201         if( !psz_name )
202         {
203             psz_name = strdup("");
204         }
205     }
206     else
207         psz_name = ToLocaleDup( p_demux->psz_path );
208
209 #ifdef WIN32
210     if( psz_name[0] && psz_name[1] == ':' &&
211         psz_name[2] == '\\' && psz_name[3] == '\0' ) psz_name[2] = '\0';
212 #endif
213
214     /* Override environment variable DVDCSS_METHOD with config option
215      * (FIXME: this creates a small memory leak) */
216     psz_dvdcss_env = config_GetPsz( p_demux, "dvdread-css-method" );
217     if( psz_dvdcss_env && *psz_dvdcss_env )
218     {
219         char *psz_env;
220
221         psz_env = malloc( strlen("DVDCSS_METHOD=") +
222                           strlen( psz_dvdcss_env ) + 1 );
223         if( !psz_env )
224         {
225             free( psz_dvdcss_env );
226             return VLC_ENOMEM;
227         }
228
229         sprintf( psz_env, "%s%s", "DVDCSS_METHOD=", psz_dvdcss_env );
230
231         putenv( psz_env );
232     }
233     free( psz_dvdcss_env );
234
235     /* Open dvdread */
236     if( !(p_dvdread = DVDOpen( psz_name )) )
237     {
238         msg_Err( p_demux, "DVDRead cannot open source: %s", psz_name );
239         intf_UserFatal( p_demux, false, _("Playback failure"),
240                         _("DVDRead could not open the disk \"%s\"."), psz_name );
241         free( psz_name );
242         return VLC_EGENERIC;
243     }
244     free( psz_name );
245
246     /* Ifo allocation & initialisation */
247     if( !( p_vmg_file = ifoOpen( p_dvdread, 0 ) ) )
248     {
249         msg_Warn( p_demux, "cannot open VMG info" );
250         return VLC_EGENERIC;
251     }
252     msg_Dbg( p_demux, "VMG opened" );
253
254     /* Fill p_demux field */
255     DEMUX_INIT_COMMON(); p_sys = p_demux->p_sys;
256
257     ps_track_init( p_sys->tk );
258     p_sys->i_aspect = -1;
259     p_sys->i_title_cur_time = (mtime_t) 0;
260     p_sys->i_cell_cur_time = (mtime_t) 0;
261     p_sys->i_cell_duration = (mtime_t) 0;
262
263     p_sys->p_dvdread = p_dvdread;
264     p_sys->p_vmg_file = p_vmg_file;
265     p_sys->p_title = NULL;
266     p_sys->p_vts_file = NULL;
267
268     p_sys->i_title = p_sys->i_chapter = -1;
269     p_sys->i_mux_rate = 0;
270
271     var_Create( p_demux, "dvdread-angle", VLC_VAR_INTEGER|VLC_VAR_DOINHERIT );
272     var_Get( p_demux, "dvdread-angle", &val );
273     p_sys->i_angle = val.i_int > 0 ? val.i_int : 1;
274
275     DemuxTitles( p_demux, &p_sys->i_angle );
276     if( DvdReadSetArea( p_demux, 0, 0, p_sys->i_angle ) != VLC_SUCCESS )
277     {
278         Close( p_this );
279         msg_Err( p_demux, "DvdReadSetArea(0,0,%i) failed (can't decrypt DVD?)",
280                  p_sys->i_angle );
281         return VLC_EGENERIC;
282     }
283
284     /* Update default_pts to a suitable value for dvdread access */
285     var_Create( p_demux, "dvdread-caching",
286                 VLC_VAR_INTEGER|VLC_VAR_DOINHERIT );
287
288     return VLC_SUCCESS;
289 }
290
291 /*****************************************************************************
292  * Close:
293  *****************************************************************************/
294 static void Close( vlc_object_t *p_this )
295 {
296     demux_t     *p_demux = (demux_t*)p_this;
297     demux_sys_t *p_sys = p_demux->p_sys;
298     int i;
299
300     for( i = 0; i < PS_TK_COUNT; i++ )
301     {
302         ps_track_t *tk = &p_sys->tk[i];
303         if( tk->b_seen )
304         {
305             es_format_Clean( &tk->fmt );
306             if( tk->es ) es_out_Del( p_demux->out, tk->es );
307         }
308     }
309
310     /* Close libdvdread */
311     if( p_sys->p_title ) DVDCloseFile( p_sys->p_title );
312     if( p_sys->p_vts_file ) ifoClose( p_sys->p_vts_file );
313     if( p_sys->p_vmg_file ) ifoClose( p_sys->p_vmg_file );
314     DVDClose( p_sys->p_dvdread );
315
316     free( p_sys );
317 }
318
319 static int64_t dvdtime_to_time( dvd_time_t *dtime, uint8_t still_time )
320 {
321 /* Macro to convert Binary Coded Decimal to Decimal */
322 #define BCD2D(__x__) (((__x__ & 0xf0) >> 4) * 10 + (__x__ & 0x0f))
323
324     double f_fps, f_ms;
325     int64_t i_micro_second = 0;
326
327     if (still_time == 0 || still_time == 0xFF)
328     {
329         i_micro_second += (int64_t)(BCD2D(dtime->hour)) * 60 * 60 * 1000000;
330         i_micro_second += (int64_t)(BCD2D(dtime->minute)) * 60 * 1000000;
331         i_micro_second += (int64_t)(BCD2D(dtime->second)) * 1000000;
332
333         switch((dtime->frame_u & 0xc0) >> 6)
334         {
335         case 1:
336             f_fps = 25.0;
337             break;
338         case 3:
339             f_fps = 29.97;
340             break;
341         default:
342             f_fps = 2500.0;
343             break;
344         }
345         f_ms = BCD2D(dtime->frame_u&0x3f) * 1000.0 / f_fps;
346         i_micro_second += (int64_t)(f_ms * 1000.0);
347     }
348     else
349     {
350         i_micro_second = still_time;
351         i_micro_second = (int64_t)((double)i_micro_second * 1000000.0);
352     }
353
354     return i_micro_second;
355 }
356
357 /*****************************************************************************
358  * Control:
359  *****************************************************************************/
360 static int Control( demux_t *p_demux, int i_query, va_list args )
361 {
362     demux_sys_t *p_sys = p_demux->p_sys;
363     double f, *pf;
364     bool *pb;
365     int64_t *pi64;
366     input_title_t ***ppp_title;
367     int *pi_int;
368     int i;
369
370     switch( i_query )
371     {
372         case DEMUX_GET_POSITION:
373         {
374             pf = (double*) va_arg( args, double* );
375
376             if( p_sys->i_title_blocks > 0 )
377                 *pf = (double)p_sys->i_title_offset / p_sys->i_title_blocks;
378             else
379                 *pf = 0.0;
380
381             return VLC_SUCCESS;
382         }
383         case DEMUX_SET_POSITION:
384         {
385             f = (double)va_arg( args, double );
386
387             DvdReadSeek( p_demux, f * p_sys->i_title_blocks );
388
389             return VLC_SUCCESS;
390         }
391         case DEMUX_GET_TIME:
392             pi64 = (int64_t*)va_arg( args, int64_t * );
393             if( p_demux->info.i_title >= 0 && p_demux->info.i_title < p_sys->i_titles )
394             {
395                 *pi64 = (int64_t) dvdtime_to_time( &p_sys->p_cur_pgc->playback_time, 0 ) /
396                         p_sys->i_title_blocks * p_sys->i_title_offset;
397                 return VLC_SUCCESS;
398             }
399             *pi64 = 0;
400             return VLC_EGENERIC;
401
402         case DEMUX_GET_LENGTH:
403             pi64 = (int64_t*)va_arg( args, int64_t * );
404             if( p_demux->info.i_title >= 0 && p_demux->info.i_title < p_sys->i_titles )
405             {
406                 *pi64 = (int64_t)dvdtime_to_time( &p_sys->p_cur_pgc->playback_time, 0 );
407                 return VLC_SUCCESS;
408             }
409             *pi64 = 0;
410             return VLC_EGENERIC;
411
412         /* Special for access_demux */
413         case DEMUX_CAN_PAUSE:
414         case DEMUX_CAN_SEEK:
415         case DEMUX_CAN_CONTROL_PACE:
416             /* TODO */
417             pb = (bool*)va_arg( args, bool * );
418             *pb = true;
419             return VLC_SUCCESS;
420
421         case DEMUX_SET_PAUSE_STATE:
422             return VLC_SUCCESS;
423
424         case DEMUX_GET_TITLE_INFO:
425             ppp_title = (input_title_t***)va_arg( args, input_title_t*** );
426             pi_int    = (int*)va_arg( args, int* );
427             *((int*)va_arg( args, int* )) = 1; /* Title offset */
428             *((int*)va_arg( args, int* )) = 1; /* Chapter offset */
429
430             /* Duplicate title infos */
431             *pi_int = p_sys->i_titles;
432             *ppp_title = malloc( sizeof(input_title_t **) * p_sys->i_titles );
433             for( i = 0; i < p_sys->i_titles; i++ )
434             {
435                 (*ppp_title)[i] = vlc_input_title_Duplicate(p_sys->titles[i]);
436             }
437             return VLC_SUCCESS;
438
439         case DEMUX_SET_TITLE:
440             i = (int)va_arg( args, int );
441             if( DvdReadSetArea( p_demux, i, 0, -1 ) != VLC_SUCCESS )
442             {
443                 msg_Warn( p_demux, "cannot set title/chapter" );
444                 return VLC_EGENERIC;
445             }
446             p_demux->info.i_update |=
447                 INPUT_UPDATE_TITLE | INPUT_UPDATE_SEEKPOINT;
448             p_demux->info.i_title = i;
449             p_demux->info.i_seekpoint = 0;
450             return VLC_SUCCESS;
451
452         case DEMUX_SET_SEEKPOINT:
453             i = (int)va_arg( args, int );
454             if( DvdReadSetArea( p_demux, -1, i, -1 ) != VLC_SUCCESS )
455             {
456                 msg_Warn( p_demux, "cannot set title/chapter" );
457                 return VLC_EGENERIC;
458             }
459             p_demux->info.i_update |= INPUT_UPDATE_SEEKPOINT;
460             p_demux->info.i_seekpoint = i;
461             return VLC_SUCCESS;
462
463         case DEMUX_GET_PTS_DELAY:
464             pi64 = (int64_t*)va_arg( args, int64_t * );
465             *pi64 = (int64_t)var_GetInteger( p_demux, "dvdread-caching" )*1000;
466             return VLC_SUCCESS;
467
468         /* TODO implement others */
469         default:
470             return VLC_EGENERIC;
471     }
472 }
473
474 /*****************************************************************************
475  * Demux:
476  *****************************************************************************/
477 static int Demux( demux_t *p_demux )
478 {
479     demux_sys_t *p_sys = p_demux->p_sys;
480
481     uint8_t p_buffer[DVD_VIDEO_LB_LEN * DVD_BLOCK_READ_ONCE];
482     int i_blocks_once, i_read;
483     int i;
484
485     /*
486      * Playback by cell in this pgc, starting at the cell for our chapter.
487      */
488
489     /*
490      * Check end of pack, and select the following one
491      */
492     if( !p_sys->i_pack_len )
493     {
494         /* Read NAV packet */
495         if( DVDReadBlocks( p_sys->p_title, p_sys->i_next_vobu,
496                            1, p_buffer ) != 1 )
497         {
498             msg_Err( p_demux, "read failed for block %d", p_sys->i_next_vobu );
499             intf_UserWarn( p_demux, _("Playback failure"),
500                             _("DVDRead could not read block %d."),
501                            p_sys->i_next_vobu );
502             return -1;
503         }
504
505         /* Basic check to be sure we don't have a empty title
506          * go to next title if so */
507         //assert( p_buffer[41] == 0xbf && p_buffer[1027] == 0xbf );
508
509         /* Parse the contained dsi packet */
510         DvdReadHandleDSI( p_demux, p_buffer );
511
512         /* End of title */
513         if( p_sys->i_cur_cell >= p_sys->p_cur_pgc->nr_of_cells )
514         {
515             if( p_sys->i_title + 1 >= p_sys->i_titles )
516             {
517                 return 0; /* EOF */
518             }
519
520             DvdReadSetArea( p_demux, p_sys->i_title + 1, 0, -1 );
521         }
522
523         if( p_sys->i_pack_len >= 1024 )
524         {
525             msg_Err( p_demux, "i_pack_len >= 1024 (%i). "
526                      "This shouldn't happen!", p_sys->i_pack_len );
527             return 0; /* EOF */
528         }
529
530         /* FIXME: Ugly kludge: we send the pack block to the input for it
531          * sometimes has a zero scr and restart the sync */
532         p_sys->i_cur_block++;
533         p_sys->i_title_offset++;
534
535         DemuxBlock( p_demux, p_buffer, DVD_VIDEO_LB_LEN );
536     }
537
538     if( p_sys->i_cur_cell >= p_sys->p_cur_pgc->nr_of_cells )
539     {
540         if( p_sys->i_title + 1 >= p_sys->i_titles )
541         {
542             return 0; /* EOF */
543         }
544
545         DvdReadSetArea( p_demux, p_sys->i_title + 1, 0, -1 );
546     }
547
548     /*
549      * Read actual data
550      */
551     i_blocks_once = __MIN( p_sys->i_pack_len, DVD_BLOCK_READ_ONCE );
552     p_sys->i_pack_len -= i_blocks_once;
553
554     /* Reads from DVD */
555     i_read = DVDReadBlocks( p_sys->p_title, p_sys->i_cur_block,
556                             i_blocks_once, p_buffer );
557     if( i_read != i_blocks_once )
558     {
559         msg_Err( p_demux, "read failed for %d/%d blocks at 0x%02x",
560                  i_read, i_blocks_once, p_sys->i_cur_block );
561         intf_UserFatal( p_demux, false, _("Playback failure"),
562                         _("DVDRead could not read %d/%d blocks at 0x%02x."),
563                         i_read, i_blocks_once, p_sys->i_cur_block );
564         return -1;
565     }
566
567     p_sys->i_cur_block += i_read;
568     p_sys->i_title_offset += i_read;
569
570 #if 0
571     msg_Dbg( p_demux, "i_blocks: %d len: %d current: 0x%02x",
572              i_read, p_sys->i_pack_len, p_sys->i_cur_block );
573 #endif
574
575     for( i = 0; i < i_read; i++ )
576     {
577         DemuxBlock( p_demux, p_buffer + i * DVD_VIDEO_LB_LEN,
578                     DVD_VIDEO_LB_LEN );
579     }
580
581 #undef p_pgc
582
583     return 1;
584 }
585
586 /*****************************************************************************
587  * DemuxBlock: demux a given block
588  *****************************************************************************/
589 static int DemuxBlock( demux_t *p_demux, uint8_t *pkt, int i_pkt )
590 {
591     demux_sys_t *p_sys = p_demux->p_sys;
592     uint8_t     *p = pkt;
593
594     while( p < &pkt[i_pkt] )
595     {
596         int i_size = ps_pkt_size( p, &pkt[i_pkt] - p );
597         block_t *p_pkt;
598         if( i_size <= 0 )
599         {
600             break;
601         }
602
603         /* Create a block */
604         p_pkt = block_New( p_demux, i_size );
605         memcpy( p_pkt->p_buffer, p, i_size);
606
607         /* Parse it and send it */
608         switch( 0x100 | p[3] )
609         {
610         case 0x1b9:
611         case 0x1bb:
612         case 0x1bc:
613
614 #ifdef DVDREAD_DEBUG
615             if( p[3] == 0xbc )
616             {
617                 msg_Warn( p_demux, "received a PSM packet" );
618             }
619             else if( p[3] == 0xbb )
620             {
621                 msg_Warn( p_demux, "received a SYSTEM packet" );
622             }
623 #endif
624             block_Release( p_pkt );
625             break;
626
627         case 0x1ba:
628         {
629             int64_t i_scr;
630             int i_mux_rate;
631             if( !ps_pkt_parse_pack( p_pkt, &i_scr, &i_mux_rate ) )
632             {
633                 es_out_Control( p_demux->out, ES_OUT_SET_PCR, i_scr );
634                 if( i_mux_rate > 0 ) p_sys->i_mux_rate = i_mux_rate;
635             }
636             block_Release( p_pkt );
637             break;
638         }
639         default:
640         {
641             int i_id = ps_pkt_id( p_pkt );
642             if( i_id >= 0xc0 )
643             {
644                 ps_track_t *tk = &p_sys->tk[PS_ID_TO_TK(i_id)];
645
646                 if( !tk->b_seen )
647                 {
648                     ESNew( p_demux, i_id, 0 );
649                 }
650                 if( tk->b_seen && tk->es &&
651                     !ps_pkt_parse_pes( p_pkt, tk->i_skip ) )
652                 {
653                     es_out_Send( p_demux->out, tk->es, p_pkt );
654                 }
655                 else
656                 {
657                     block_Release( p_pkt );
658                 }
659             }
660             else
661             {
662                 block_Release( p_pkt );
663             }
664             break;
665         }
666         }
667
668         p += i_size;
669     }
670
671     return VLC_SUCCESS;
672 }
673
674 /*****************************************************************************
675  * ESNew: register a new elementary stream
676  *****************************************************************************/
677 static void ESNew( demux_t *p_demux, int i_id, int i_lang )
678 {
679     demux_sys_t *p_sys = p_demux->p_sys;
680     ps_track_t  *tk = &p_sys->tk[PS_ID_TO_TK(i_id)];
681     char psz_language[3];
682
683     if( tk->b_seen ) return;
684
685     if( ps_track_fill( tk, 0, i_id ) )
686     {
687         msg_Warn( p_demux, "unknown codec for id=0x%x", i_id );
688         return;
689     }
690
691     psz_language[0] = psz_language[1] = psz_language[2] = 0;
692     if( i_lang && i_lang != 0xffff )
693     {
694         psz_language[0] = (i_lang >> 8)&0xff;
695         psz_language[1] = (i_lang     )&0xff;
696     }
697
698     /* Add a new ES */
699     if( tk->fmt.i_cat == VIDEO_ES )
700     {
701         if( p_sys->i_aspect >= 0 )
702         {
703             tk->fmt.video.i_aspect = p_sys->i_aspect;
704         }
705     }
706     else if( tk->fmt.i_cat == AUDIO_ES )
707     {
708         int i_audio = -1;
709         /* find the audio number PLEASE find another way */
710         if( (i_id&0xbdf8) == 0xbd88 )       /* dts */
711         {
712             i_audio = i_id&0x07;
713         }
714         else if( (i_id&0xbdf0) == 0xbd80 )  /* a52 */
715         {
716             i_audio = i_id&0xf;
717         }
718         else if( (i_id&0xbdf0) == 0xbda0 )  /* lpcm */
719         {
720             i_audio = i_id&0x1f;
721         }
722         else if( ( i_id&0xe0 ) == 0xc0 )    /* mpga */
723         {
724             i_audio = i_id&0x1f;
725         }
726
727         if( psz_language[0] ) tk->fmt.psz_language = strdup( psz_language );
728     }
729     else if( tk->fmt.i_cat == SPU_ES )
730     {
731         /* Palette */
732         tk->fmt.subs.spu.palette[0] = 0xBeef;
733         memcpy( &tk->fmt.subs.spu.palette[1], p_sys->clut,
734                 16 * sizeof( uint32_t ) );
735
736         if( psz_language[0] ) tk->fmt.psz_language = strdup( psz_language );
737     }
738
739     tk->es = es_out_Add( p_demux->out, &tk->fmt );
740     tk->b_seen = true;
741 }
742
743 /*****************************************************************************
744  * DvdReadSetArea: initialize input data for title x, chapter y.
745  * It should be called for each user navigation request.
746  *****************************************************************************
747  * Take care that i_title and i_chapter start from 0.
748  *****************************************************************************/
749 static int DvdReadSetArea( demux_t *p_demux, int i_title, int i_chapter,
750                            int i_angle )
751 {
752     demux_sys_t *p_sys = p_demux->p_sys;
753     int pgc_id = 0, pgn = 0;
754     int i;
755
756 #define p_pgc p_sys->p_cur_pgc
757 #define p_vmg p_sys->p_vmg_file
758 #define p_vts p_sys->p_vts_file
759
760     if( i_title >= 0 && i_title < p_sys->i_titles &&
761         i_title != p_sys->i_title )
762     {
763         int i_start_cell, i_end_cell;
764
765         if( p_sys->p_title != NULL ) DVDCloseFile( p_sys->p_title );
766         if( p_vts != NULL ) ifoClose( p_vts );
767         p_sys->i_title = i_title;
768
769         /*
770          *  We have to load all title information
771          */
772         msg_Dbg( p_demux, "open VTS %d, for title %d",
773                  p_vmg->tt_srpt->title[i_title].title_set_nr, i_title + 1 );
774
775         /* Ifo vts */
776         if( !( p_vts = ifoOpen( p_sys->p_dvdread,
777                p_vmg->tt_srpt->title[i_title].title_set_nr ) ) )
778         {
779             msg_Err( p_demux, "fatal error in vts ifo" );
780             return VLC_EGENERIC;
781         }
782
783         /* Title position inside the selected vts */
784         p_sys->i_ttn = p_vmg->tt_srpt->title[i_title].vts_ttn;
785
786         /* Find title start/end */
787         pgc_id = p_vts->vts_ptt_srpt->title[p_sys->i_ttn - 1].ptt[0].pgcn;
788         pgn = p_vts->vts_ptt_srpt->title[p_sys->i_ttn - 1].ptt[0].pgn;
789         p_pgc = p_vts->vts_pgcit->pgci_srp[pgc_id - 1].pgc;
790
791         p_sys->i_title_start_cell =
792             i_start_cell = p_pgc->program_map[pgn - 1] - 1;
793         p_sys->i_title_start_block =
794             p_pgc->cell_playback[i_start_cell].first_sector;
795
796         p_sys->i_title_end_cell =
797             i_end_cell = p_pgc->nr_of_cells - 1;
798         p_sys->i_title_end_block =
799             p_pgc->cell_playback[i_end_cell].last_sector;
800
801         p_sys->i_title_offset = 0;
802
803         p_sys->i_title_blocks = 0;
804         for( i = i_start_cell; i <= i_end_cell; i++ )
805         {
806             p_sys->i_title_blocks += p_pgc->cell_playback[i].last_sector -
807                 p_pgc->cell_playback[i].first_sector + 1;
808         }
809
810         msg_Dbg( p_demux, "title %d vts_title %d pgc %d pgn %d "
811                  "start %d end %d blocks: %d",
812                  i_title + 1, p_sys->i_ttn, pgc_id, pgn,
813                  p_sys->i_title_start_block, p_sys->i_title_end_block,
814                  p_sys->i_title_blocks );
815
816         /*
817          * Set properties for current chapter
818          */
819         p_sys->i_chapter = 0;
820         p_sys->i_chapters =
821             p_vts->vts_ptt_srpt->title[p_sys->i_ttn - 1].nr_of_ptts;
822
823         pgc_id = p_vts->vts_ptt_srpt->title[
824                     p_sys->i_ttn - 1].ptt[p_sys->i_chapter].pgcn;
825         pgn = p_vts->vts_ptt_srpt->title[
826                     p_sys->i_ttn - 1].ptt[p_sys->i_chapter].pgn;
827
828         p_pgc = p_vts->vts_pgcit->pgci_srp[pgc_id - 1].pgc;
829         p_sys->i_pack_len = 0;
830         p_sys->i_next_cell =
831             p_sys->i_cur_cell = p_pgc->program_map[pgn - 1] - 1;
832         DvdReadFindCell( p_demux );
833
834         p_sys->i_next_vobu = p_sys->i_cur_block =
835             p_pgc->cell_playback[p_sys->i_cur_cell].first_sector;
836
837         /*
838          * Angle management
839          */
840         p_sys->i_angles = p_vmg->tt_srpt->title[i_title].nr_of_angles;
841         if( p_sys->i_angle > p_sys->i_angles ) p_sys->i_angle = 1;
842
843         /*
844          * We've got enough info, time to open the title set data.
845          */
846         if( !( p_sys->p_title = DVDOpenFile( p_sys->p_dvdread,
847             p_vmg->tt_srpt->title[i_title].title_set_nr,
848             DVD_READ_TITLE_VOBS ) ) )
849         {
850             msg_Err( p_demux, "cannot open title (VTS_%02d_1.VOB)",
851                      p_vmg->tt_srpt->title[i_title].title_set_nr );
852             return VLC_EGENERIC;
853         }
854
855         //IfoPrintTitle( p_demux );
856
857         /*
858          * Destroy obsolete ES by reinitializing program 0
859          * and find all ES in title with ifo data
860          */
861         es_out_Control( p_demux->out, ES_OUT_RESET_PCR );
862
863         for( i = 0; i < PS_TK_COUNT; i++ )
864         {
865             ps_track_t *tk = &p_sys->tk[i];
866             if( tk->b_seen )
867             {
868                 es_format_Clean( &tk->fmt );
869                 if( tk->es ) es_out_Del( p_demux->out, tk->es );
870             }
871             tk->b_seen = false;
872         }
873
874         if( p_demux->info.i_title != i_title )
875         {
876             p_demux->info.i_update |=
877                 INPUT_UPDATE_TITLE | INPUT_UPDATE_SEEKPOINT;
878             p_demux->info.i_title = i_title;
879             p_demux->info.i_seekpoint = 0;
880         }
881
882         /* TODO: re-add angles */
883
884
885         ESNew( p_demux, 0xe0, 0 ); /* Video, FIXME ? */
886         p_sys->i_aspect = p_vts->vtsi_mat->vts_video_attr.display_aspect_ratio;
887
888 #define audio_control \
889     p_sys->p_vts_file->vts_pgcit->pgci_srp[pgc_id-1].pgc->audio_control[i-1]
890
891         /* Audio ES, in the order they appear in the .ifo */
892         for( i = 1; i <= p_vts->vtsi_mat->nr_of_vts_audio_streams; i++ )
893         {
894             int i_position = 0;
895             uint16_t i_id;
896
897             //IfoPrintAudio( p_demux, i );
898
899             /* Audio channel is active if first byte is 0x80 */
900             if( audio_control & 0x8000 )
901             {
902                 i_position = ( audio_control & 0x7F00 ) >> 8;
903
904                 msg_Dbg( p_demux, "audio position  %d", i_position );
905                 switch( p_vts->vtsi_mat->vts_audio_attr[i - 1].audio_format )
906                 {
907                 case 0x00: /* A52 */
908                     i_id = (0x80 + i_position) | 0xbd00;
909                     break;
910                 case 0x02:
911                 case 0x03: /* MPEG audio */
912                     i_id = 0xc000 + i_position;
913                     break;
914                 case 0x04: /* LPCM */
915                     i_id = (0xa0 + i_position) | 0xbd00;
916                     break;
917                 case 0x06: /* DTS */
918                     i_id = (0x88 + i_position) | 0xbd00;
919                     break;
920                 default:
921                     i_id = 0;
922                     msg_Err( p_demux, "unknown audio type %.2x",
923                         p_vts->vtsi_mat->vts_audio_attr[i - 1].audio_format );
924                 }
925
926                 ESNew( p_demux, i_id, p_sys->p_vts_file->vtsi_mat->
927                        vts_audio_attr[i - 1].lang_code );
928             }
929         }
930 #undef audio_control
931
932 #define spu_palette \
933     p_sys->p_vts_file->vts_pgcit->pgci_srp[pgc_id-1].pgc->palette
934
935         memcpy( p_sys->clut, spu_palette, 16 * sizeof( uint32_t ) );
936
937 #define spu_control \
938     p_sys->p_vts_file->vts_pgcit->pgci_srp[pgc_id-1].pgc->subp_control[i-1]
939
940         /* Sub Picture ES */
941         for( i = 1; i <= p_vts->vtsi_mat->nr_of_vts_subp_streams; i++ )
942         {
943             int i_position = 0;
944             uint16_t i_id;
945
946             //IfoPrintSpu( p_sys, i );
947             msg_Dbg( p_demux, "spu %d 0x%02x", i, spu_control );
948
949             if( spu_control & 0x80000000 )
950             {
951                 /*  there are several streams for one spu */
952                 if( p_vts->vtsi_mat->vts_video_attr.display_aspect_ratio )
953                 {
954                     /* 16:9 */
955                     switch( p_vts->vtsi_mat->vts_video_attr.permitted_df )
956                     {
957                     case 1: /* letterbox */
958                         i_position = spu_control & 0xff;
959                         break;
960                     case 2: /* pan&scan */
961                         i_position = ( spu_control >> 8 ) & 0xff;
962                         break;
963                     default: /* widescreen */
964                         i_position = ( spu_control >> 16 ) & 0xff;
965                         break;
966                     }
967                 }
968                 else
969                 {
970                     /* 4:3 */
971                     i_position = ( spu_control >> 24 ) & 0x7F;
972                 }
973
974                 i_id = (0x20 + i_position) | 0xbd00;
975
976                 ESNew( p_demux, i_id, p_sys->p_vts_file->vtsi_mat->
977                        vts_subp_attr[i - 1].lang_code );
978             }
979         }
980 #undef spu_control
981
982     }
983     else if( i_title != -1 && i_title != p_sys->i_title )
984
985     {
986         return VLC_EGENERIC; /* Couldn't set title */
987     }
988
989     /*
990      * Chapter selection
991      */
992
993     if( i_chapter >= 0 && i_chapter < p_sys->i_chapters )
994     {
995         pgc_id = p_vts->vts_ptt_srpt->title[
996                      p_sys->i_ttn - 1].ptt[i_chapter].pgcn;
997         pgn = p_vts->vts_ptt_srpt->title[
998                   p_sys->i_ttn - 1].ptt[i_chapter].pgn;
999
1000         p_pgc = p_vts->vts_pgcit->pgci_srp[pgc_id - 1].pgc;
1001
1002         p_sys->i_cur_cell = p_pgc->program_map[pgn - 1] - 1;
1003         p_sys->i_chapter = i_chapter;
1004         DvdReadFindCell( p_demux );
1005
1006         p_sys->i_title_offset = 0;
1007         for( i = p_sys->i_title_start_cell; i < p_sys->i_cur_cell; i++ )
1008         {
1009             p_sys->i_title_offset += p_pgc->cell_playback[i].last_sector -
1010                 p_pgc->cell_playback[i].first_sector + 1;
1011         }
1012
1013         p_sys->i_pack_len = 0;
1014         p_sys->i_next_vobu = p_sys->i_cur_block =
1015             p_pgc->cell_playback[p_sys->i_cur_cell].first_sector;
1016
1017         if( p_demux->info.i_seekpoint != i_chapter )
1018         {
1019             p_demux->info.i_update |= INPUT_UPDATE_SEEKPOINT;
1020             p_demux->info.i_seekpoint = i_chapter;
1021         }
1022     }
1023     else if( i_chapter != -1 )
1024
1025     {
1026         return VLC_EGENERIC; /* Couldn't set chapter */
1027     }
1028
1029 #undef p_pgc
1030 #undef p_vts
1031 #undef p_vmg
1032
1033     return VLC_SUCCESS;
1034 }
1035
1036 /*****************************************************************************
1037  * DvdReadSeek : Goes to a given position on the stream.
1038  *****************************************************************************
1039  * This one is used by the input and translate chronological position from
1040  * input to logical position on the device.
1041  *****************************************************************************/
1042 static void DvdReadSeek( demux_t *p_demux, int i_block_offset )
1043 {
1044     demux_sys_t *p_sys = p_demux->p_sys;
1045     int i_chapter = 0;
1046     int i_cell = 0;
1047     int i_vobu = 0;
1048     int i_sub_cell = 0;
1049     int i_block;
1050
1051 #define p_pgc p_sys->p_cur_pgc
1052 #define p_vts p_sys->p_vts_file
1053
1054     /* Find cell */
1055     i_block = i_block_offset;
1056     for( i_cell = p_sys->i_title_start_cell;
1057          i_cell <= p_sys->i_title_end_cell; i_cell++ )
1058     {
1059         if( i_block < (int)p_pgc->cell_playback[i_cell].last_sector -
1060             (int)p_pgc->cell_playback[i_cell].first_sector + 1 ) break;
1061
1062         i_block -= (p_pgc->cell_playback[i_cell].last_sector -
1063             p_pgc->cell_playback[i_cell].first_sector + 1);
1064     }
1065     if( i_cell > p_sys->i_title_end_cell )
1066     {
1067         msg_Err( p_demux, "couldn't find cell for block %i", i_block_offset );
1068         return;
1069     }
1070     i_block += p_pgc->cell_playback[i_cell].first_sector;
1071     p_sys->i_title_offset = i_block_offset;
1072
1073     /* Find chapter */
1074     for( i_chapter = 0; i_chapter < p_sys->i_chapters; i_chapter++ )
1075     {
1076         int pgc_id, pgn, i_tmp;
1077
1078         pgc_id = p_vts->vts_ptt_srpt->title[
1079                     p_sys->i_ttn - 1].ptt[i_chapter].pgcn;
1080         pgn = p_vts->vts_ptt_srpt->title[
1081                     p_sys->i_ttn - 1].ptt[i_chapter].pgn;
1082
1083         i_tmp = p_vts->vts_pgcit->pgci_srp[pgc_id - 1].pgc->program_map[pgn-1];
1084
1085         if( i_tmp > i_cell ) break;
1086     }
1087
1088     if( i_chapter < p_sys->i_chapters &&
1089         p_demux->info.i_seekpoint != i_chapter )
1090     {
1091         p_demux->info.i_update |= INPUT_UPDATE_SEEKPOINT;
1092         p_demux->info.i_seekpoint = i_chapter;
1093     }
1094
1095     /* Find vobu */
1096     while( (int)p_vts->vts_vobu_admap->vobu_start_sectors[i_vobu] <= i_block )
1097     {
1098         i_vobu++;
1099     }
1100
1101     /* Find sub_cell */
1102     while( p_vts->vts_c_adt->cell_adr_table[i_sub_cell].start_sector <
1103            p_vts->vts_vobu_admap->vobu_start_sectors[i_vobu-1] )
1104     {
1105         i_sub_cell++;
1106     }
1107
1108 #if 1
1109     msg_Dbg( p_demux, "cell %d i_sub_cell %d chapter %d vobu %d "
1110              "cell_sector %d vobu_sector %d sub_cell_sector %d",
1111              i_cell, i_sub_cell, i_chapter, i_vobu,
1112              p_sys->p_cur_pgc->cell_playback[i_cell].first_sector,
1113              p_vts->vts_vobu_admap->vobu_start_sectors[i_vobu],
1114              p_vts->vts_c_adt->cell_adr_table[i_sub_cell - 1].start_sector);
1115 #endif
1116
1117     p_sys->i_cur_block = i_block;
1118     p_sys->i_next_vobu = p_vts->vts_vobu_admap->vobu_start_sectors[i_vobu];
1119     p_sys->i_pack_len = p_sys->i_next_vobu - i_block;
1120     p_sys->i_cur_cell = i_cell;
1121     p_sys->i_chapter = i_chapter;
1122     DvdReadFindCell( p_demux );
1123
1124 #undef p_vts
1125 #undef p_pgc
1126
1127     return;
1128 }
1129
1130 /*****************************************************************************
1131  * DvdReadHandleDSI
1132  *****************************************************************************/
1133 static void DvdReadHandleDSI( demux_t *p_demux, uint8_t *p_data )
1134 {
1135     demux_sys_t *p_sys = p_demux->p_sys;
1136
1137     navRead_DSI( &p_sys->dsi_pack, &p_data[DSI_START_BYTE] );
1138
1139     /*
1140      * Determine where we go next.  These values are the ones we mostly
1141      * care about.
1142      */
1143     p_sys->i_cur_block = p_sys->dsi_pack.dsi_gi.nv_pck_lbn;
1144     p_sys->i_pack_len = p_sys->dsi_pack.dsi_gi.vobu_ea;
1145
1146     /*
1147      * Store the timecodes so we can get the current time
1148      */
1149     p_sys->i_title_cur_time = (mtime_t) (p_sys->dsi_pack.dsi_gi.nv_pck_scr / 90 * 1000);
1150     p_sys->i_cell_cur_time = (mtime_t) dvdtime_to_time( &p_sys->dsi_pack.dsi_gi.c_eltm, 0 );
1151
1152     /*
1153      * If we're not at the end of this cell, we can determine the next
1154      * VOBU to display using the VOBU_SRI information section of the
1155      * DSI.  Using this value correctly follows the current angle,
1156      * avoiding the doubled scenes in The Matrix, and makes our life
1157      * really happy.
1158      */
1159
1160     p_sys->i_next_vobu = p_sys->i_cur_block +
1161         ( p_sys->dsi_pack.vobu_sri.next_vobu & 0x7fffffff );
1162
1163     if( p_sys->dsi_pack.vobu_sri.next_vobu != SRI_END_OF_CELL
1164         && p_sys->i_angle > 1 )
1165     {
1166         switch( ( p_sys->dsi_pack.sml_pbi.category & 0xf000 ) >> 12 )
1167         {
1168         case 0x4:
1169             /* Interleaved unit with no angle */
1170             if( p_sys->dsi_pack.sml_pbi.ilvu_sa != 0 )
1171             {
1172                 p_sys->i_next_vobu = p_sys->i_cur_block +
1173                     p_sys->dsi_pack.sml_pbi.ilvu_sa;
1174                 p_sys->i_pack_len = p_sys->dsi_pack.sml_pbi.ilvu_ea;
1175             }
1176             else
1177             {
1178                 p_sys->i_next_vobu = p_sys->i_cur_block +
1179                     p_sys->dsi_pack.dsi_gi.vobu_ea + 1;
1180             }
1181             break;
1182         case 0x5:
1183             /* vobu is end of ilvu */
1184             if( p_sys->dsi_pack.sml_agli.data[p_sys->i_angle-1].address )
1185             {
1186                 p_sys->i_next_vobu = p_sys->i_cur_block +
1187                     p_sys->dsi_pack.sml_agli.data[p_sys->i_angle-1].address;
1188                 p_sys->i_pack_len = p_sys->dsi_pack.sml_pbi.ilvu_ea;
1189
1190                 break;
1191             }
1192         case 0x6:
1193             /* vobu is beginning of ilvu */
1194         case 0x9:
1195             /* next scr is 0 */
1196         case 0xa:
1197             /* entering interleaved section */
1198         case 0x8:
1199             /* non interleaved cells in interleaved section */
1200         default:
1201             p_sys->i_next_vobu = p_sys->i_cur_block +
1202                 ( p_sys->dsi_pack.vobu_sri.next_vobu & 0x7fffffff );
1203             break;
1204         }
1205     }
1206     else if( p_sys->dsi_pack.vobu_sri.next_vobu == SRI_END_OF_CELL )
1207     {
1208         p_sys->i_cur_cell = p_sys->i_next_cell;
1209
1210         /* End of title */
1211         if( p_sys->i_cur_cell >= p_sys->p_cur_pgc->nr_of_cells ) return;
1212
1213         DvdReadFindCell( p_demux );
1214
1215         p_sys->i_next_vobu =
1216             p_sys->p_cur_pgc->cell_playback[p_sys->i_cur_cell].first_sector;
1217
1218         p_sys->i_cell_duration = (mtime_t)dvdtime_to_time( &p_sys->p_cur_pgc->cell_playback[p_sys->i_cur_cell].playback_time, 0 );
1219     }
1220
1221
1222 #if 0
1223     msg_Dbg( p_demux, "scr %d lbn 0x%02x vobu_ea %d vob_id %d c_id %d c_time %lld",
1224              p_sys->dsi_pack.dsi_gi.nv_pck_scr,
1225              p_sys->dsi_pack.dsi_gi.nv_pck_lbn,
1226              p_sys->dsi_pack.dsi_gi.vobu_ea,
1227              p_sys->dsi_pack.dsi_gi.vobu_vob_idn,
1228              p_sys->dsi_pack.dsi_gi.vobu_c_idn,
1229              dvdtime_to_time( &p_sys->dsi_pack.dsi_gi.c_eltm, 0 ) );
1230
1231     msg_Dbg( p_demux, "cell duration: %lld",
1232              (mtime_t)dvdtime_to_time( &p_sys->p_cur_pgc->cell_playback[p_sys->i_cur_cell].playback_time, 0 ) );
1233
1234     msg_Dbg( p_demux, "cat 0x%02x ilvu_ea %d ilvu_sa %d size %d",
1235              p_sys->dsi_pack.sml_pbi.category,
1236              p_sys->dsi_pack.sml_pbi.ilvu_ea,
1237              p_sys->dsi_pack.sml_pbi.ilvu_sa,
1238              p_sys->dsi_pack.sml_pbi.size );
1239
1240     msg_Dbg( p_demux, "next_vobu %d next_ilvu1 %d next_ilvu2 %d",
1241              p_sys->dsi_pack.vobu_sri.next_vobu & 0x7fffffff,
1242              p_sys->dsi_pack.sml_agli.data[ p_sys->i_angle - 1 ].address,
1243              p_sys->dsi_pack.sml_agli.data[ p_sys->i_angle ].address);
1244 #endif
1245 }
1246
1247 /*****************************************************************************
1248  * DvdReadFindCell
1249  *****************************************************************************/
1250 static void DvdReadFindCell( demux_t *p_demux )
1251 {
1252     demux_sys_t *p_sys = p_demux->p_sys;
1253
1254     pgc_t *p_pgc;
1255     int   pgc_id, pgn;
1256     int   i = 0;
1257
1258 #define cell p_sys->p_cur_pgc->cell_playback
1259
1260     if( cell[p_sys->i_cur_cell].block_type == BLOCK_TYPE_ANGLE_BLOCK )
1261     {
1262         p_sys->i_cur_cell += p_sys->i_angle - 1;
1263
1264         while( cell[p_sys->i_cur_cell+i].block_mode != BLOCK_MODE_LAST_CELL )
1265         {
1266             i++;
1267         }
1268         p_sys->i_next_cell = p_sys->i_cur_cell + i + 1;
1269     }
1270     else
1271     {
1272         p_sys->i_next_cell = p_sys->i_cur_cell + 1;
1273     }
1274
1275 #undef cell
1276
1277     if( p_sys->i_chapter + 1 >= p_sys->i_chapters ) return;
1278
1279     pgc_id = p_sys->p_vts_file->vts_ptt_srpt->title[
1280                 p_sys->i_ttn - 1].ptt[p_sys->i_chapter + 1].pgcn;
1281     pgn = p_sys->p_vts_file->vts_ptt_srpt->title[
1282               p_sys->i_ttn - 1].ptt[p_sys->i_chapter + 1].pgn;
1283     p_pgc = p_sys->p_vts_file->vts_pgcit->pgci_srp[pgc_id - 1].pgc;
1284
1285     if( p_sys->i_cur_cell >= p_pgc->program_map[pgn - 1] - 1 )
1286     {
1287         p_sys->i_chapter++;
1288
1289         if( p_sys->i_chapter < p_sys->i_chapters &&
1290             p_demux->info.i_seekpoint != p_sys->i_chapter )
1291         {
1292             p_demux->info.i_update |= INPUT_UPDATE_SEEKPOINT;
1293             p_demux->info.i_seekpoint = p_sys->i_chapter;
1294         }
1295     }
1296 }
1297
1298 /*****************************************************************************
1299  * DemuxTitles: get the titles/chapters structure
1300  *****************************************************************************/
1301 static void DemuxTitles( demux_t *p_demux, int *pi_angle )
1302 {
1303     demux_sys_t *p_sys = p_demux->p_sys;
1304     input_title_t *t;
1305     seekpoint_t *s;
1306     int32_t i_titles;
1307     int i;
1308
1309     /* Find out number of titles/chapters */
1310 #define tt_srpt p_sys->p_vmg_file->tt_srpt
1311
1312     i_titles = tt_srpt->nr_of_srpts;
1313     msg_Dbg( p_demux, "number of titles: %d", i_titles );
1314
1315     for( i = 0; i < i_titles; i++ )
1316     {
1317         int32_t i_chapters = 0;
1318         int j;
1319
1320         i_chapters = tt_srpt->title[i].nr_of_ptts;
1321         msg_Dbg( p_demux, "title %d has %d chapters", i, i_chapters );
1322
1323         t = vlc_input_title_New();
1324
1325         for( j = 0; j < __MAX( i_chapters, 1 ); j++ )
1326         {
1327             s = vlc_seekpoint_New();
1328             TAB_APPEND( t->i_seekpoint, t->seekpoint, s );
1329         }
1330
1331         TAB_APPEND( p_sys->i_titles, p_sys->titles, t );
1332     }
1333
1334 #undef tt_srpt
1335 }