git.sesse.net Git - vlc/blob - modules/access/dvdread/input.c

   1 /*****************************************************************************
   2  * input.c: DvdRead plugin.
   3  *****************************************************************************
   4  * This plugins should handle all the known specificities of the DVD format,
   5  * especially the 2048 bytes logical block size.
   6  * It depends on: libdvdread for ifo files and block reading.
   7  *****************************************************************************
   8  * Copyright (C) 2001 VideoLAN
   9  * $Id: input.c,v 1.6 2002/10/26 15:24:19 gbazin Exp $
  10  *
  11  * Author: Stéphane Borel <stef@via.ecp.fr>
  12  *
  13  * Some code taken form the play_title.c by Billy Biggs <vektor@dumbterm.net>
  14  * in libdvdread.
  15  *
  16  * This program is free software; you can redistribute it and/or modify
  17  * it under the terms of the GNU General Public License as published by
  18  * the Free Software Foundation; either version 2 of the License, or
  19  * (at your option) any later version.
  20  *
  21  * This program is distributed in the hope that it will be useful,
  22  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  23  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  24  * GNU General Public License for more details.
  25  *
  26  * You should have received a copy of the GNU General Public License
  27  * along with this program; if not, write to the Free Software
  28  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
  29  *****************************************************************************/
  30
  31 /*****************************************************************************
  32  * Preamble
  33  *****************************************************************************/
  34 #include <stdio.h>
  35 #include <stdlib.h>
  36
  37 #include <vlc/vlc.h>
  38 #include <vlc/input.h>
  39
  40 #include "../../demux/mpeg/system.h"
  41
  42 #ifdef HAVE_UNISTD_H
  43 #   include <unistd.h>
  44 #endif
  45
  46 #include <fcntl.h>
  47 #include <sys/types.h>
  48 #include <sys/stat.h>
  49 #include <string.h>
  50 #include <errno.h>
  51 #include <assert.h>
  52
  53 #ifdef STRNCASECMP_IN_STRINGS_H
  54 #   include <strings.h>
  55 #endif
  56
  57 #if defined( WIN32 )
  58 #   include <io.h>                                                 /* read() */
  59 #endif
  60
  61 #include <dvdread/dvd_reader.h>
  62 #include <dvdread/ifo_types.h>
  63 #include <dvdread/ifo_read.h>
  64 #include <dvdread/nav_read.h>
  65 #include <dvdread/nav_print.h>
  66
  67 #include "input.h"
  68
  69 #include "iso_lang.h"
  70
  71 /* how many blocks DVDRead will read in each loop */
  72 #define DVD_BLOCK_READ_ONCE 64
  73
  74 /*****************************************************************************
  75  * Private structure
  76  *****************************************************************************/
  77 struct demux_sys_t
  78 {
  79     module_t *   p_module;
  80     mpeg_demux_t mpeg;
  81 };
  82
  83 /*****************************************************************************
  84  * Local prototypes
  85  *****************************************************************************/
  86 /* called from outside */
  87 static int  DvdReadDemux    ( input_thread_t * );
  88 static int  DvdReadRewind   ( input_thread_t * );
  89
  90 static int  DvdReadSetArea    ( input_thread_t *, input_area_t * );
  91 static int  DvdReadSetProgram ( input_thread_t *, pgrm_descriptor_t * );
  92 static int  DvdReadRead       ( input_thread_t *, byte_t *, size_t );
  93 static void DvdReadSeek       ( input_thread_t *, off_t );
  94
  95 /* called only from here */
  96 static void DvdReadLauchDecoders( input_thread_t * p_input );
  97 static void DvdReadHandleDSI( thread_dvd_data_t * p_dvd, u8 * p_data );
  98 static void DvdReadFindCell ( thread_dvd_data_t * p_dvd );
  99
 100 /*
 101  * Data demux functions
 102  */
 103
 104 /*****************************************************************************
 105  * InitDVD: initialize DVD structures
 106  *****************************************************************************/
 107 int E_(InitDVD) ( vlc_object_t *p_this )
 108 {
 109     input_thread_t *p_input = (input_thread_t *)p_this;
 110     demux_sys_t *   p_demux;
 111
 112     if( p_input->stream.i_method != INPUT_METHOD_DVD )
 113     {
 114         return -1;
 115     }
 116
 117     p_demux = p_input->p_demux_data = malloc( sizeof(demux_sys_t ) );
 118     if( p_demux == NULL )
 119     {
 120         return -1;
 121     }
 122
 123     p_input->p_private = (void*)&p_demux->mpeg;
 124     p_demux->p_module = module_Need( p_input, "mpeg-system", NULL );
 125     if( p_demux->p_module == NULL )
 126     {
 127         free( p_input->p_demux_data );
 128         return -1;
 129     }
 130
 131     p_input->pf_demux = DvdReadDemux;
 132     p_input->pf_rewind = NULL;
 133
 134     vlc_mutex_lock( &p_input->stream.stream_lock );
 135
 136     DvdReadLauchDecoders( p_input );
 137
 138     vlc_mutex_unlock( &p_input->stream.stream_lock );
 139
 140     return 0;
 141 }
 142
 143 /*****************************************************************************
 144  * EndDVD: end DVD structures
 145  *****************************************************************************/
 146 void E_(EndDVD) ( vlc_object_t *p_this )
 147 {
 148     input_thread_t *p_input = (input_thread_t *)p_this;
 149
 150     module_Unneed( p_input, p_input->p_demux_data->p_module );
 151     free( p_input->p_demux_data );
 152 }
 153
 154 /*****************************************************************************
 155  * DvdReadDemux
 156  *****************************************************************************/
 157 #define PEEK( SIZE )                                                        \
 158     i_result = input_Peek( p_input, &p_peek, SIZE );                        \
 159     if( i_result == -1 )                                                    \
 160     {                                                                       \
 161         return( -1 );                                                       \
 162     }                                                                       \
 163     else if( i_result < SIZE )                                              \
 164     {                                                                       \
 165         /* EOF */                                                           \
 166         return( 0 );                                                        \
 167     }
 168
 169 static int DvdReadDemux( input_thread_t * p_input )
 170 {
 171     int                 i;
 172     byte_t *            p_peek;
 173     data_packet_t *     p_data;
 174     ssize_t             i_result;
 175     int                 i_packet_size;
 176
 177
 178     /* Read headers to compute payload length */
 179     for( i = 0 ; i < DVD_BLOCK_READ_ONCE ; i++ )
 180     {
 181
 182         /* Read what we believe to be a packet header. */
 183         PEEK( 4 );
 184
 185         /* Default header */
 186         if( U32_AT( p_peek ) != 0x1BA )
 187         {
 188             /* That's the case for all packets, except pack header. */
 189             i_packet_size = U16_AT( p_peek + 4 );
 190         }
 191         else
 192         {
 193             /* MPEG-2 Pack header. */
 194             i_packet_size = 8;
 195         }
 196
 197         /* Fetch a packet of the appropriate size. */
 198         i_result = input_SplitBuffer( p_input, &p_data, i_packet_size + 6 );
 199         if( i_result <= 0 )
 200         {
 201             return( i_result );
 202         }
 203
 204         /* In MPEG-2 pack headers we still have to read stuffing bytes. */
 205         if( (p_data->p_demux_start[3] == 0xBA) && (i_packet_size == 8) )
 206         {
 207             size_t i_stuffing = (p_data->p_demux_start[13] & 0x7);
 208             /* Force refill of the input buffer - though we don't care
 209              * about p_peek. Please note that this is unoptimized. */
 210             PEEK( i_stuffing );
 211             p_input->p_current_data += i_stuffing;
 212         }
 213
 214         p_input->p_demux_data->mpeg.pf_demux_ps( p_input, p_data );
 215
 216     }
 217
 218     return i;
 219 }
 220
 221 /*****************************************************************************
 222  * DVDRewind : reads a stream backward
 223  *****************************************************************************/
 224 static int DvdReadRewind( input_thread_t * p_input )
 225 {
 226     return( -1 );
 227 }
 228
 229 /*
 230  * Data access functions
 231  */
 232
 233 /*****************************************************************************
 234  * OpenDVD: open libdvdread
 235  *****************************************************************************/
 236 int E_(OpenDVD) ( vlc_object_t *p_this )
 237 {
 238     input_thread_t *        p_input = (input_thread_t *)p_this;
 239     char *                  psz_parser;
 240     char *                  psz_source;
 241     char *                  psz_next;
 242     struct stat             stat_info;
 243     thread_dvd_data_t *     p_dvd;
 244     dvd_reader_t *          p_dvdread;
 245     input_area_t *          p_area;
 246     int                     i_title = 1;
 247     int                     i_chapter = 1;
 248     int                     i_angle = 1;
 249     int                     i;
 250
 251     psz_parser = psz_source = strdup( p_input->psz_name );
 252     if( !psz_source )
 253     {
 254         return( -1 );
 255     }
 256
 257     p_input->pf_read = DvdReadRead;
 258     p_input->pf_seek = DvdReadSeek;
 259     p_input->pf_set_area = DvdReadSetArea;
 260     p_input->pf_set_program = DvdReadSetProgram;
 261
 262     while( *psz_parser && *psz_parser != '@' )
 263     {
 264         psz_parser++;
 265     }
 266
 267     if( *psz_parser == '@' )
 268     {
 269         /* Found options */
 270         *psz_parser = '\0';
 271         ++psz_parser;
 272
 273         i_title = (int)strtol( psz_parser, &psz_next, 10 );
 274         if( *psz_next )
 275         {
 276             psz_parser = psz_next + 1;
 277             i_chapter = (int)strtol( psz_parser, &psz_next, 10 );
 278             if( *psz_next )
 279             {
 280                 i_angle = (int)strtol( psz_next + 1, NULL, 10 );
 281             }
 282         }
 283
 284         i_title = i_title ? i_title : 1;
 285         i_chapter = i_chapter ? i_chapter : 1;
 286         i_angle = i_angle ? i_angle : 1;
 287     }
 288
 289     if( !*psz_source )
 290     {
 291         free( psz_source );
 292         if( !p_input->psz_access )
 293         {
 294             return -1;
 295         }
 296         psz_source = config_GetPsz( p_input, "dvd" );
 297         if( !psz_source ) return -1;
 298     }
 299
 300     if( stat( psz_source, &stat_info ) == -1 )
 301     {
 302         msg_Err( p_input, "cannot stat() source `%s' (%s)",
 303                           psz_source, strerror(errno));
 304         free( psz_source );
 305         return( -1 );
 306     }
 307     if( !S_ISBLK(stat_info.st_mode) &&
 308         !S_ISCHR(stat_info.st_mode) &&
 309         !S_ISDIR(stat_info.st_mode) )
 310     {
 311         msg_Warn( p_input, "dvdread module discarded (not a valid source)" );
 312         free( psz_source );
 313         return -1;
 314     }
 315
 316     msg_Dbg( p_input, "dvdroot=%s title=%d chapter=%d angle=%d",
 317                       psz_source, i_title, i_chapter, i_angle );
 318
 319
 320     p_dvdread = DVDOpen( psz_source );
 321
 322     /* free allocated strings */
 323     free( psz_source );
 324
 325     if( ! p_dvdread )
 326     {
 327         msg_Err( p_input, "libdvdcss cannot open source" );
 328         return -1;
 329     }
 330
 331     /* set up input  */
 332     p_input->i_mtu = 0;
 333
 334     p_dvd = malloc( sizeof(thread_dvd_data_t) );
 335     if( p_dvd == NULL )
 336     {
 337         msg_Err( p_input, "out of memory" );
 338         return -1;
 339     }
 340
 341     p_dvd->p_dvdread = p_dvdread;
 342     p_dvd->p_title = NULL;
 343     p_dvd->p_vts_file = NULL;
 344
 345
 346     p_input->p_access_data = (void *)p_dvd;
 347
 348     /* Ifo allocation & initialisation */
 349     if( ! ( p_dvd->p_vmg_file = ifoOpen( p_dvd->p_dvdread, 0 ) ) )
 350     {
 351         msg_Err( p_input, "cannot open VMG info" );
 352         free( p_dvd );
 353         return -1;
 354     }
 355     msg_Dbg( p_input, "VMG opened" );
 356
 357     /* Set stream and area data */
 358     vlc_mutex_lock( &p_input->stream.stream_lock );
 359
 360     p_input->stream.i_method = INPUT_METHOD_DVD;
 361
 362     /* If we are here we can control the pace... */
 363     p_input->stream.b_pace_control = 1;
 364     p_input->stream.b_seekable = 1;
 365
 366     p_input->stream.p_selected_area->i_size = 0;
 367     p_input->stream.p_selected_area->i_tell = 0;
 368
 369     /* Initialize ES structures */
 370     input_InitStream( p_input, sizeof( stream_ps_data_t ) );
 371
 372     /* disc input method */
 373     p_input->stream.i_method = INPUT_METHOD_DVD;
 374
 375 #define tt_srpt p_dvd->p_vmg_file->tt_srpt
 376     msg_Dbg( p_input, "number of titles: %d", tt_srpt->nr_of_srpts );
 377
 378 #define area p_input->stream.pp_areas
 379     /* We start from 1 here since the default area 0
 380      * is reserved for video_ts.vob */
 381     for( i = 1 ; i <= tt_srpt->nr_of_srpts ; i++ )
 382     {
 383         input_AddArea( p_input );
 384
 385         /* Titles are Program Chains */
 386         area[i]->i_id = i;
 387
 388         /* Absolute start offset and size
 389          * We can only set that with vts ifo, so we do it during the
 390          * first call to DVDSetArea */
 391         area[i]->i_start = 0;
 392         area[i]->i_size = 0;
 393
 394         /* Number of chapters */
 395         area[i]->i_part_nb = tt_srpt->title[i-1].nr_of_ptts;
 396         area[i]->i_part = 1;
 397
 398         area[i]->i_plugin_data = tt_srpt->title[i-1].title_set_nr;
 399     }
 400 #undef area
 401
 402     p_dvd->i_title = i_title <= tt_srpt->nr_of_srpts ? i_title : 1;
 403 #undef tt_srpt
 404
 405     p_area = p_input->stream.pp_areas[p_dvd->i_title];
 406     p_dvd->i_chapter = i_chapter;
 407
 408     p_dvd->i_chapter = i_chapter < p_area->i_part_nb ? i_chapter : 1;
 409     p_area->i_part = p_dvd->i_chapter;
 410
 411     p_dvd->i_angle = i_angle;
 412
 413     /* set title, chapter, audio and subpic */
 414     if( DvdReadSetArea( p_input, p_area ) )
 415     {
 416         vlc_mutex_unlock( &p_input->stream.stream_lock );
 417         return -1;
 418     }
 419
 420     vlc_mutex_unlock( &p_input->stream.stream_lock );
 421
 422     p_input->psz_demux = "dvdread";
 423
 424     return 0;
 425 }
 426
 427 /*****************************************************************************
 428  * CloseDVD: close libdvdread
 429  *****************************************************************************/
 430 void E_(CloseDVD) ( vlc_object_t *p_this )
 431 {
 432     input_thread_t *    p_input = (input_thread_t *)p_this;
 433     thread_dvd_data_t * p_dvd = (thread_dvd_data_t *)p_input->p_access_data;
 434
 435     /* close libdvdread */
 436     DVDCloseFile( p_dvd->p_title );
 437     ifoClose( p_dvd->p_vts_file );
 438     ifoClose( p_dvd->p_vmg_file );
 439
 440     DVDClose( p_dvd->p_dvdread );
 441     free( p_dvd );
 442     p_input->p_access_data = NULL;
 443
 444 }
 445
 446 /*****************************************************************************
 447  * DvdReadSetProgram: Does nothing, a DVD is mono-program
 448  *****************************************************************************/
 449 static int DvdReadSetProgram( input_thread_t * p_input,
 450                               pgrm_descriptor_t * p_program )
 451 {
 452     if( p_input->stream.p_selected_program != p_program )
 453     {
 454         thread_dvd_data_t *  p_dvd;
 455
 456         p_dvd = (thread_dvd_data_t*)(p_input->p_access_data);
 457         p_dvd->i_angle = p_program->i_number;
 458
 459         memcpy( p_program, p_input->stream.p_selected_program,
 460                 sizeof(pgrm_descriptor_t) );
 461         p_program->i_number = p_dvd->i_angle;
 462         p_input->stream.p_selected_program = p_program;
 463
 464         msg_Dbg( p_input, "angle %d selected", p_dvd->i_angle );
 465     }
 466
 467     return 0;
 468 }
 469
 470 #define p_pgc         p_dvd->p_cur_pgc
 471
 472 /*****************************************************************************
 473  * DvdReadSetArea: initialize input data for title x, chapter y.
 474  * It should be called for each user navigation request.
 475  *****************************************************************************
 476  * Take care that i_title starts from 0 (vmg) and i_chapter start from 1.
 477  * Note that you have to take the lock before entering here.
 478  *****************************************************************************/
 479 static int DvdReadSetArea( input_thread_t * p_input, input_area_t * p_area )
 480 {
 481     thread_dvd_data_t *  p_dvd;
 482     int                  pgc_id = 0;
 483     int                  pgn = 0;
 484
 485     p_dvd = (thread_dvd_data_t*)p_input->p_access_data;
 486
 487     /* we can't use the interface slider until initilization is complete */
 488     p_input->stream.b_seekable = 0;
 489
 490     if( p_area != p_input->stream.p_selected_area )
 491     {
 492         es_descriptor_t *    p_es;
 493         int                  i_cell = 0;
 494         int                  i_audio_nb = 0;
 495         int                  i_spu_nb = 0;
 496         int                  i;
 497
 498 #define p_vmg         p_dvd->p_vmg_file
 499 #define p_vts         p_dvd->p_vts_file
 500         if( p_dvd->p_title != NULL )
 501         {
 502             DVDCloseFile( p_dvd->p_title );
 503         }
 504
 505         if( p_vts != NULL )
 506         {
 507             ifoClose( p_vts );
 508         }
 509
 510         /* Reset the Chapter position of the old title */
 511         p_input->stream.p_selected_area->i_part = 1;
 512
 513         /*
 514          *  We have to load all title information
 515          */
 516         /* Change the default area */
 517         p_input->stream.p_selected_area = p_area;
 518
 519         msg_Dbg( p_input, "open VTS %d, for title %d",
 520             p_vmg->tt_srpt->title[ p_area->i_id - 1 ].title_set_nr,
 521             p_area->i_id );
 522
 523         /* ifo vts */
 524         if( ! ( p_vts = ifoOpen( p_dvd->p_dvdread,
 525                 p_vmg->tt_srpt->title[ p_area->i_id - 1 ].title_set_nr ) ) )
 526         {
 527             msg_Err( p_input, "fatal error in vts ifo" );
 528             ifoClose( p_vmg );
 529             DVDClose( p_dvd->p_dvdread );
 530             return -1;
 531         }
 532
 533         /* title position inside the selected vts */
 534         p_dvd->i_ttn = p_vmg->tt_srpt->title[ p_area->i_id - 1 ].vts_ttn;
 535
 536         /*
 537          * Set selected title start
 538          */
 539         pgc_id = p_vts->vts_ptt_srpt->title[p_dvd->i_ttn-1].ptt[0].pgcn;
 540         pgn = p_vts->vts_ptt_srpt->title[p_dvd->i_ttn-1].ptt[0].pgn;
 541         p_pgc = p_vts->vts_pgcit->pgci_srp[ pgc_id - 1 ].pgc;
 542         i_cell = p_pgc->program_map[ pgn - 1 ] - 1;
 543
 544         p_area->i_start =
 545             LB2OFF( p_dvd->p_cur_pgc->cell_playback[ i_cell ].first_sector );
 546
 547         msg_Dbg( p_input, "start %d vts_title %d pgc %d pgn %d",
 548                   p_area->i_id, p_dvd->i_ttn, pgc_id, pgn );
 549
 550         /*
 551          * Find title end
 552          */
 553         i_cell = p_dvd->p_cur_pgc->nr_of_cells - 1;
 554
 555         p_dvd->i_end_block = p_pgc->cell_playback[ i_cell ].last_sector;
 556         p_area->i_size = LB2OFF( p_dvd->i_end_block )- p_area->i_start;
 557
 558         msg_Dbg( p_input, "start %lld size %lld end %d",
 559                   p_area->i_start , p_area->i_size, p_dvd->i_end_block );
 560
 561         /*
 562          * Set properties for current chapter
 563          */
 564         /* Remeber current chapter */
 565         p_dvd->i_chapter = p_area->i_part;
 566         p_dvd->b_eoc = 0;
 567
 568         pgc_id = p_vts->vts_ptt_srpt->title[
 569                     p_dvd->i_ttn-1].ptt[p_area->i_part-1].pgcn;
 570         pgn = p_vts->vts_ptt_srpt->title[
 571                     p_dvd->i_ttn-1].ptt[p_area->i_part-1].pgn;
 572
 573         p_pgc = p_vts->vts_pgcit->pgci_srp[pgc_id-1].pgc;
 574         p_dvd->i_pack_len = 0;
 575         p_dvd->i_next_cell = p_dvd->i_cur_cell = p_pgc->program_map[pgn-1] - 1;
 576         DvdReadFindCell( p_dvd );
 577
 578         p_dvd->i_next_vobu = p_dvd->i_cur_block =
 579             p_pgc->cell_playback[p_dvd->i_cur_cell].first_sector;
 580
 581         /*
 582          * Angle management
 583          */
 584         p_dvd->i_angle_nb = p_vmg->tt_srpt->title[p_area->i_id-1].nr_of_angles;
 585
 586         if( p_dvd->i_angle > p_dvd->i_angle_nb )
 587         {
 588             p_dvd->i_angle = 1;
 589         }
 590
 591         /*
 592          * We've got enough info, time to open the title set data.
 593          */
 594         if( ! ( p_dvd->p_title = DVDOpenFile( p_dvd->p_dvdread,
 595             p_vmg->tt_srpt->title[ p_area->i_id - 1 ].title_set_nr,
 596             DVD_READ_TITLE_VOBS ) ) )
 597         {
 598             msg_Err( p_input, "cannot open title (VTS_%02d_1.VOB)",
 599                      p_vmg->tt_srpt->title[p_area->i_id-1].title_set_nr );
 600             ifoClose( p_vts );
 601             ifoClose( p_vmg );
 602             DVDClose( p_dvd->p_dvdread );
 603             return -1;
 604         }
 605
 606 //        IfoPrintTitle( p_dvd );
 607
 608         /*
 609          * Destroy obsolete ES by reinitializing program 0
 610          * and find all ES in title with ifo data
 611          */
 612         if( p_input->stream.pp_programs != NULL )
 613         {
 614             /* We don't use input_EndStream here since
 615              * we keep area structures */
 616
 617             while( p_input->stream.i_es_number )
 618             {
 619                 input_DelES( p_input, p_input->stream.pp_es[0] );
 620             }
 621
 622             while( p_input->stream.i_pgrm_number )
 623             {
 624                 input_DelProgram( p_input, p_input->stream.pp_programs[0] );
 625             }
 626
 627             if( p_input->stream.pp_selected_es )
 628             {
 629                 free( p_input->stream.pp_selected_es );
 630                 p_input->stream.pp_selected_es = NULL;
 631             }
 632             p_input->stream.i_selected_es_number = 0;
 633         }
 634
 635         input_AddProgram( p_input, 1, sizeof( stream_ps_data_t ) );
 636         p_input->stream.p_selected_program = p_input->stream.pp_programs[0];
 637
 638         for( i = 1 ; i < p_dvd->i_angle_nb ; i++ )
 639         {
 640             input_AddProgram( p_input, i+1, 0 );
 641         }
 642
 643         DvdReadSetProgram( p_input,
 644                            p_input->stream.pp_programs[p_dvd->i_angle-1] );
 645
 646         /* No PSM to read in DVD mode, we already have all information */
 647         p_input->stream.p_selected_program->b_is_ok = 1;
 648
 649         p_es = NULL;
 650
 651         /* ES 0 -> video MPEG2 */
 652 //        IfoPrintVideo( p_dvd );
 653
 654         p_es = input_AddES( p_input, NULL, 0xe0, 0 );
 655         p_es->i_stream_id = 0xe0;
 656         p_es->i_fourcc = VLC_FOURCC('m','p','g','v');
 657         p_es->i_cat = VIDEO_ES;
 658
 659 #define audio_control \
 660     p_dvd->p_vts_file->vts_pgcit->pgci_srp[pgc_id-1].pgc->audio_control[i-1]
 661         /* Audio ES, in the order they appear in .ifo */
 662         for( i = 1 ; i <= p_vts->vtsi_mat->nr_of_vts_audio_streams ; i++ )
 663         {
 664             int i_position = 0;
 665             u16 i_id;
 666
 667 //            IfoPrintAudio( p_dvd, i );
 668
 669             /* audio channel is active if first byte is 0x80 */
 670             if( audio_control & 0x8000 )
 671             {
 672                 i_audio_nb++;
 673                 i_position = ( audio_control & 0x7F00 ) >> 8;
 674
 675             msg_Dbg( p_input, "audio position  %d", i_position );
 676                 switch( p_vts->vtsi_mat->vts_audio_attr[i-1].audio_format )
 677                 {
 678                 case 0x00:              /* A52 */
 679                     i_id = ( ( 0x80 + i_position ) << 8 ) | 0xbd;
 680                     p_es = input_AddES( p_input, NULL, i_id, 0 );
 681                     p_es->i_stream_id = 0xbd;
 682                     p_es->i_fourcc = VLC_FOURCC('a','5','2','b');
 683                     p_es->i_cat = AUDIO_ES;
 684                     strcpy( p_es->psz_desc, DecodeLanguage(
 685                         p_vts->vtsi_mat->vts_audio_attr[i-1].lang_code ) );
 686                     strcat( p_es->psz_desc, " (A52)" );
 687
 688                     break;
 689                 case 0x02:
 690                 case 0x03:              /* MPEG audio */
 691                     i_id = 0xc0 + i_position;
 692                     p_es = input_AddES( p_input, NULL, i_id, 0 );
 693                     p_es->i_stream_id = i_id;
 694                     p_es->i_fourcc = VLC_FOURCC('m','p','g','a');
 695                     p_es->i_cat = AUDIO_ES;
 696                     strcpy( p_es->psz_desc, DecodeLanguage(
 697                         p_vts->vtsi_mat->vts_audio_attr[i-1].lang_code ) );
 698                     strcat( p_es->psz_desc, " (mpeg)" );
 699
 700                     break;
 701                 case 0x04:              /* LPCM */
 702
 703                     i_id = ( ( 0xa0 + i_position ) << 8 ) | 0xbd;
 704                     p_es = input_AddES( p_input, NULL, i_id, 0 );
 705                     p_es->i_stream_id = i_id;
 706                     p_es->i_fourcc = VLC_FOURCC('l','p','c','b');
 707                     p_es->i_cat = AUDIO_ES;
 708                     strcpy( p_es->psz_desc, DecodeLanguage(
 709                         p_vts->vtsi_mat->vts_audio_attr[i-1].lang_code ) );
 710                     strcat( p_es->psz_desc, " (lpcm)" );
 711
 712                     break;
 713                 case 0x06:              /* DTS */
 714                     i_id = ( ( 0x88 + i_position ) << 8 ) | 0xbd;
 715                     msg_Err( p_input, "DTS audio not handled yet"
 716                                       "(0x%x)", i_id );
 717                     break;
 718                 default:
 719                     i_id = 0;
 720                     msg_Err( p_input, "unknown audio type %.2x",
 721                           p_vts->vtsi_mat->vts_audio_attr[i-1].audio_format );
 722                 }
 723             }
 724         }
 725 #undef audio_control
 726 #define spu_control \
 727     p_dvd->p_vts_file->vts_pgcit->pgci_srp[pgc_id-1].pgc->subp_control[i-1]
 728
 729         /* Sub Picture ES */
 730
 731         for( i = 1 ; i <= p_vts->vtsi_mat->nr_of_vts_subp_streams; i++ )
 732         {
 733             int i_position = 0;
 734             u16 i_id;
 735
 736 //            IfoPrintSpu( p_dvd, i );
 737             msg_Dbg( p_input, "spu %d 0x%02x", i, spu_control );
 738
 739             if( spu_control & 0x80000000 )
 740             {
 741                 i_spu_nb++;
 742
 743                 /*  there are several streams for one spu */
 744                 if(  p_vts->vtsi_mat->vts_video_attr.display_aspect_ratio )
 745                 {
 746                     /* 16:9 */
 747                     switch( p_vts->vtsi_mat->vts_video_attr.permitted_df )
 748                     {
 749                     case 1:
 750                         i_position = spu_control & 0xff;
 751                         break;
 752                     case 2:
 753                         i_position = ( spu_control >> 8 ) & 0xff;
 754                         break;
 755                     default:
 756                         i_position = ( spu_control >> 16 ) & 0xff;
 757                         break;
 758                     }
 759                 }
 760                 else
 761                 {
 762                     /* 4:3 */
 763                     i_position = ( spu_control >> 24 ) & 0x7F;
 764                 }
 765
 766                 i_id = ( ( 0x20 + i_position ) << 8 ) | 0xbd;
 767                 p_es = input_AddES( p_input, NULL, i_id, 0 );
 768                 p_es->i_stream_id = 0xbd;
 769                 p_es->i_fourcc = VLC_FOURCC('s','p','u','b');
 770                 p_es->i_cat = SPU_ES;
 771                 strcpy( p_es->psz_desc, DecodeLanguage(
 772                     p_vts->vtsi_mat->vts_subp_attr[i-1].lang_code ) );
 773             }
 774         }
 775 #undef spu_control
 776
 777         /* FIXME: hack to check that the demuxer is ready, and set
 778          * the decoders */
 779         if( p_input->p_demux )
 780         {
 781             DvdReadLauchDecoders( p_input );
 782         }
 783
 784     } /* i_title >= 0 */
 785     else
 786     {
 787         p_area = p_input->stream.p_selected_area;
 788     }
 789
 790     /*
 791      * Chapter selection
 792      */
 793
 794     if( p_area->i_part != p_dvd->i_chapter )
 795     {
 796         if( ( p_area->i_part > 0 ) &&
 797             ( p_area->i_part <= p_area->i_part_nb ))
 798         {
 799             p_dvd->i_ttn = p_vmg->tt_srpt->title[p_area->i_id-1].vts_ttn;
 800             pgc_id = p_vts->vts_ptt_srpt->title[
 801                         p_dvd->i_ttn-1].ptt[p_area->i_part-1].pgcn;
 802             pgn = p_vts->vts_ptt_srpt->title[
 803                         p_dvd->i_ttn-1].ptt[p_area->i_part-1].pgn;
 804
 805             p_pgc = p_vts->vts_pgcit->pgci_srp[ pgc_id - 1 ].pgc;
 806
 807             p_dvd->i_cur_cell = p_pgc->program_map[ pgn - 1 ] - 1;
 808             p_dvd->i_chapter = p_area->i_part;
 809             DvdReadFindCell( p_dvd );
 810
 811             p_dvd->i_pack_len = 0;
 812             p_dvd->i_next_vobu = p_dvd->i_cur_block =
 813                     p_pgc->cell_playback[p_dvd->i_cur_cell].first_sector;
 814         }
 815         else
 816         {
 817             p_area->i_part = p_dvd->i_chapter;
 818         }
 819     }
 820 #undef p_vts
 821 #undef p_vmg
 822
 823     /* warn interface that something has changed */
 824     p_area->i_tell = LB2OFF( p_dvd->i_next_vobu ) - p_area->i_start;
 825     p_input->stream.b_seekable = 1;
 826     p_input->stream.b_changed = 1;
 827
 828     return 0;
 829 }
 830
 831
 832 /*****************************************************************************
 833  * DvdReadRead: reads data packets into the netlist.
 834  *****************************************************************************
 835  * Returns -1 in case of error, 0 if everything went well, and 1 in case of
 836  * EOF.
 837  *****************************************************************************/
 838 static int DvdReadRead( input_thread_t * p_input,
 839                         byte_t * p_buffer, size_t i_count )
 840 {
 841     thread_dvd_data_t *     p_dvd;
 842     byte_t *                p_buf;
 843     int                     i_blocks_once;
 844     int                     i_blocks;
 845     int                     i_read;
 846     int                     i_read_total;
 847     vlc_bool_t              b_eot = 0;
 848
 849     p_dvd = (thread_dvd_data_t *)p_input->p_access_data;
 850     p_buf = p_buffer;
 851
 852     /*
 853      * Playback by cell in this pgc, starting at the cell for our chapter.
 854      */
 855     i_blocks = OFF2LB( i_count );
 856     i_read_total = 0;
 857     i_read = 0;
 858
 859     while( i_blocks )
 860     {
 861         /*
 862          * End of pack, we select the following one
 863          */
 864         if( ! p_dvd->i_pack_len )
 865         {
 866             /*
 867              * Read NAV packet.
 868              */
 869             if( ( i_read = DVDReadBlocks( p_dvd->p_title, p_dvd->i_next_vobu,
 870                            1, p_buf ) ) != 1 )
 871             {
 872                 msg_Err( p_input, "read failed for block %d",
 873                                   p_dvd->i_next_vobu );
 874                 return -1;
 875             }
 876
 877             /* basic check to be sure we don't have a empty title
 878              * go to next title if so */
 879             //assert( p_buffer[41] == 0xbf && p_buffer[1027] == 0xbf );
 880
 881             /*
 882              * Parse the contained dsi packet.
 883              */
 884
 885             DvdReadHandleDSI( p_dvd, p_buf );
 886
 887             /* End of File */
 888             if( p_dvd->i_next_vobu >= p_dvd->i_end_block + 1 )
 889             {
 890                 return 1;
 891             }
 892
 893             assert( p_dvd->i_pack_len < 1024 );
 894             /* FIXME: Ugly kludge: we send the pack block to the input for it
 895              * sometimes has a zero scr and restart the sync */
 896             p_dvd->i_cur_block ++;
 897             //p_dvd->i_pack_len++;
 898
 899             i_read_total++;
 900             p_buf += DVD_VIDEO_LB_LEN;
 901             i_blocks--;
 902         }
 903
 904         /*
 905          * Compute the number of blocks to read
 906          */
 907         i_blocks_once = p_dvd->i_pack_len >= i_blocks
 908                  ? i_blocks : p_dvd->i_pack_len;
 909         p_dvd->i_pack_len -= i_blocks_once;
 910
 911         /* Reads from DVD */
 912         i_read = DVDReadBlocks( p_dvd->p_title, p_dvd->i_cur_block,
 913                                 i_blocks_once, p_buf );
 914         if( i_read != i_blocks_once )
 915         {
 916             msg_Err( p_input, "read failed for %d/%d blocks at 0x%02x",
 917                               i_read, i_blocks_once, p_dvd->i_cur_block );
 918             return -1;
 919         }
 920
 921         i_blocks -= i_read;
 922         i_read_total += i_read;
 923         p_dvd->i_cur_block += i_read;
 924         p_buf += LB2OFF( i_read );
 925
 926     }
 927 /*
 928     msg_Dbg( p_input, "i_blocks: %d len: %d current: 0x%02x", i_read, p_dvd->i_pack_len, p_dvd->i_cur_block );
 929 */
 930
 931     vlc_mutex_lock( &p_input->stream.stream_lock );
 932
 933     if( p_dvd->b_eoc )
 934     {
 935         /* We modify i_part only at end of chapter not to erase
 936          * some modification from the interface */
 937         p_input->stream.p_selected_area->i_part = p_dvd->i_chapter;
 938         p_dvd->b_eoc = 0;
 939     }
 940
 941     if( ( LB2OFF( p_dvd->i_cur_block )
 942           - p_input->stream.p_selected_area->i_start )
 943             >= p_input->stream.p_selected_area->i_size || b_eot )
 944     {
 945         if( ( p_input->stream.p_selected_area->i_id + 1 ) >=
 946                         p_input->stream.i_area_nb )
 947         {
 948             /* EOF */
 949             vlc_mutex_unlock( &p_input->stream.stream_lock );
 950             return 1;
 951         }
 952
 953         /* EOT */
 954         msg_Dbg( p_input, "new title" );
 955         DvdReadSetArea( p_input, p_input->stream.pp_areas[
 956                         p_input->stream.p_selected_area->i_id+1] );
 957         vlc_mutex_unlock( &p_input->stream.stream_lock );
 958         return 0;
 959     }
 960
 961     vlc_mutex_unlock( &p_input->stream.stream_lock );
 962
 963     return LB2OFF( i_read_total );
 964 }
 965 #undef p_pgc
 966
 967 /*****************************************************************************
 968  * DvdReadSeek : Goes to a given position on the stream.
 969  *****************************************************************************
 970  * This one is used by the input and translate chronological position from
 971  * input to logical position on the device.
 972  * The lock should be taken before calling this function.
 973  *****************************************************************************/
 974 static void DvdReadSeek( input_thread_t * p_input, off_t i_off )
 975 {
 976     thread_dvd_data_t *     p_dvd;
 977     int                     i_lb;
 978     int                     i_tmp;
 979     int                     i_chapter = 0;
 980     int                     i_cell = 0;
 981     int                     i_vobu = 0;
 982     int                     i_sub_cell = 0;
 983
 984     vlc_mutex_lock( &p_input->stream.stream_lock );
 985     i_off += p_input->stream.p_selected_area->i_start;
 986     vlc_mutex_unlock( &p_input->stream.stream_lock );
 987
 988     i_lb = OFF2LB( i_off );
 989     p_dvd = ( thread_dvd_data_t * )p_input->p_access_data;
 990
 991     /* find cell */
 992     while( p_dvd->p_cur_pgc->cell_playback[i_cell].last_sector < i_lb )
 993     {
 994         i_cell++;
 995     }
 996
 997     /* find chapter */
 998     do
 999     {
1000         pgc_t *     p_pgc;
1001         int         pgc_id, pgn;
1002
1003         i_chapter++;
1004         pgc_id = p_dvd->p_vts_file->vts_ptt_srpt->title[
1005                     p_dvd->i_ttn-1].ptt[i_chapter-1].pgcn;
1006         pgn = p_dvd->p_vts_file->vts_ptt_srpt->title[
1007                     p_dvd->i_ttn-1].ptt[i_chapter-1].pgn;
1008
1009         p_pgc = p_dvd->p_vts_file->vts_pgcit->pgci_srp[pgc_id-1].pgc;
1010         i_tmp = p_pgc->program_map[pgn-1];
1011
1012     } while( i_tmp <= i_cell );
1013
1014     /* find vobu */
1015     while( p_dvd->p_vts_file->vts_vobu_admap->vobu_start_sectors[i_vobu]
1016             <= i_lb )
1017     {
1018         i_vobu++;
1019     }
1020
1021     /* find sub_cell */
1022     while( p_dvd->p_vts_file->vts_c_adt->cell_adr_table[i_sub_cell].start_sector <
1023             p_dvd->p_vts_file->vts_vobu_admap->vobu_start_sectors[i_vobu-1] )
1024     {
1025         i_sub_cell++;
1026     }
1027
1028 /*
1029     msg_Dbg( p_input, "cell %d i_sub_cell %d chapter %d vobu %d cell_sector %d vobu_sector %d sub_cell_sector %d",
1030             i_cell, i_sub_cell,i_chapter, i_vobu,
1031             p_dvd->p_cur_pgc->cell_playback[i_cell].first_sector,
1032             p_dvd->p_vts_file->vts_vobu_admap->vobu_start_sectors[i_vobu],
1033             p_dvd->p_vts_file->vts_c_adt->cell_adr_table[i_sub_cell-1].start_sector);
1034 */
1035     p_dvd->i_cur_block = i_lb;
1036     p_dvd->i_next_vobu =
1037         p_dvd->p_vts_file->vts_vobu_admap->vobu_start_sectors[i_vobu];
1038     p_dvd->i_pack_len = p_dvd->i_next_vobu - i_lb;
1039     p_dvd->i_cur_cell = i_cell;
1040     p_dvd->i_chapter = i_chapter;
1041     DvdReadFindCell( p_dvd );
1042
1043     vlc_mutex_lock( &p_input->stream.stream_lock );
1044     p_input->stream.p_selected_area->i_tell =
1045         LB2OFF ( p_dvd->i_cur_block )
1046          - p_input->stream.p_selected_area->i_start;
1047     p_input->stream.p_selected_area->i_part = p_dvd->i_chapter;
1048     vlc_mutex_unlock( &p_input->stream.stream_lock );
1049
1050     return;
1051 }
1052
1053 /*****************************************************************************
1054  * DvdReadHandleDSI
1055  *****************************************************************************/
1056 static void DvdReadHandleDSI( thread_dvd_data_t * p_dvd, u8 * p_data )
1057 {
1058     navRead_DSI( &(p_dvd->dsi_pack), &(p_data[ DSI_START_BYTE ]) );
1059
1060     /*
1061      * Determine where we go next.  These values are the ones we mostly
1062      * care about.
1063      */
1064     p_dvd->i_cur_block = p_dvd->dsi_pack.dsi_gi.nv_pck_lbn;
1065
1066     /*
1067      * If we're not at the end of this cell, we can determine the next
1068      * VOBU to display using the VOBU_SRI information section of the
1069      * DSI.  Using this value correctly follows the current angle,
1070      * avoiding the doubled scenes in The Matrix, and makes our life
1071      * really happy.
1072      */
1073     if( p_dvd->dsi_pack.vobu_sri.next_vobu != SRI_END_OF_CELL )
1074     {
1075 #if 1
1076         switch( ( p_dvd->dsi_pack.sml_pbi.category & 0xf000 ) >> 12 )
1077         {
1078             case 0x4:
1079                 /* interleaved unit with no angle */
1080                 if( p_dvd->dsi_pack.sml_pbi.ilvu_sa != -1 )
1081                 {
1082                     p_dvd->i_next_vobu = p_dvd->i_cur_block +
1083                         p_dvd->dsi_pack.sml_pbi.ilvu_sa;
1084                     p_dvd->i_pack_len = p_dvd->dsi_pack.sml_pbi.ilvu_ea;
1085                 }
1086                 else
1087                 {
1088                     p_dvd->i_next_vobu = p_dvd->i_cur_block +
1089                         p_dvd->dsi_pack.dsi_gi.vobu_ea + 1;
1090                     p_dvd->i_pack_len = p_dvd->dsi_pack.dsi_gi.vobu_ea;
1091                 }
1092                 break;
1093             case 0x5:
1094                 /* vobu is end of ilvu */
1095                 if( p_dvd->dsi_pack.sml_agli.data[p_dvd->i_angle-1].address )
1096                 {
1097                     p_dvd->i_next_vobu = p_dvd->i_cur_block +
1098                         p_dvd->dsi_pack.sml_agli.data[p_dvd->i_angle-1].address;
1099                     p_dvd->i_pack_len = p_dvd->dsi_pack.sml_pbi.ilvu_ea;
1100
1101                     break;
1102                 }
1103             case 0x6:
1104                 /* vobu is beginning of ilvu */
1105             case 0x9:
1106                 /* next scr is 0 */
1107             case 0xa:
1108                 /* entering interleaved section */
1109             case 0x8:
1110                 /* non interleaved cells in interleaved section */
1111             default:
1112                 p_dvd->i_next_vobu = p_dvd->i_cur_block +
1113                     ( p_dvd->dsi_pack.vobu_sri.next_vobu & 0x7fffffff );
1114                 p_dvd->i_pack_len = p_dvd->dsi_pack.dsi_gi.vobu_ea;
1115                 break;
1116         }
1117 #else
1118         p_dvd->i_next_vobu = p_dvd->i_cur_block +
1119             ( p_dvd->dsi_pack.vobu_sri.next_vobu & 0x7fffffff );
1120         p_dvd->i_pack_len = p_dvd->dsi_pack.dsi_gi.vobu_ea;
1121 #endif
1122     }
1123     else
1124     {
1125         p_dvd->i_cur_cell = p_dvd->i_next_cell;
1126         DvdReadFindCell( p_dvd );
1127
1128         p_dvd->i_pack_len = p_dvd->dsi_pack.dsi_gi.vobu_ea;
1129         p_dvd->i_next_vobu =
1130             p_dvd->p_cur_pgc->cell_playback[p_dvd->i_cur_cell].first_sector;
1131     }
1132
1133 #if 0
1134     msg_Dbg( p_input, 12, "scr %d lbn 0x%02x vobu_ea %d vob_id %d c_id %d",
1135              p_dvd->dsi_pack.dsi_gi.nv_pck_scr,
1136              p_dvd->dsi_pack.dsi_gi.nv_pck_lbn,
1137              p_dvd->dsi_pack.dsi_gi.vobu_ea,
1138              p_dvd->dsi_pack.dsi_gi.vobu_vob_idn,
1139              p_dvd->dsi_pack.dsi_gi.vobu_c_idn );
1140
1141     msg_Dbg( p_input, 12, "cat 0x%02x ilvu_ea %d ilvu_sa %d size %d",
1142              p_dvd->dsi_pack.sml_pbi.category,
1143              p_dvd->dsi_pack.sml_pbi.ilvu_ea,
1144              p_dvd->dsi_pack.sml_pbi.ilvu_sa,
1145              p_dvd->dsi_pack.sml_pbi.size );
1146
1147     msg_Dbg( p_input, 12, "next_vobu %d next_ilvu1 %d next_ilvu2 %d",
1148              p_dvd->dsi_pack.vobu_sri.next_vobu & 0x7fffffff,
1149              p_dvd->dsi_pack.sml_agli.data[ p_dvd->i_angle - 1 ].address,
1150              p_dvd->dsi_pack.sml_agli.data[ p_dvd->i_angle ].address);
1151 #endif
1152 }
1153
1154 /*****************************************************************************
1155  * DvdReadFindCell
1156  *****************************************************************************/
1157 static void DvdReadFindCell( thread_dvd_data_t * p_dvd )
1158 {
1159     int         pgc_id, pgn;
1160     int         i = 0;
1161     pgc_t *     p_pgc;
1162 #define cell p_dvd->p_cur_pgc->cell_playback
1163     if( cell[p_dvd->i_cur_cell].block_type == BLOCK_TYPE_ANGLE_BLOCK )
1164     {
1165 #if 0
1166         p_dvd->i_next_cell = p_dvd->i_cur_cell + p_dvd->i_angle_nb;
1167         p_dvd->i_cur_cell += p_dvd->i_angle - 1;
1168 #else
1169         p_dvd->i_cur_cell += p_dvd->i_angle - 1;
1170
1171         while( cell[p_dvd->i_cur_cell+i].block_mode != BLOCK_MODE_LAST_CELL )
1172         {
1173             i++;
1174         }
1175         p_dvd->i_next_cell = p_dvd->i_cur_cell + i + 1;
1176 #endif
1177     }
1178     else
1179     {
1180         p_dvd->i_next_cell = p_dvd->i_cur_cell + 1;
1181     }
1182 #undef cell
1183     pgc_id = p_dvd->p_vts_file->vts_ptt_srpt->title[
1184                 p_dvd->i_ttn-1].ptt[p_dvd->i_chapter-1].pgcn;
1185     pgn = p_dvd->p_vts_file->vts_ptt_srpt->title[
1186                 p_dvd->i_ttn-1].ptt[p_dvd->i_chapter-1].pgn;
1187     p_pgc = p_dvd->p_vts_file->vts_pgcit->pgci_srp[pgc_id-1].pgc;
1188
1189     if( p_pgc->program_map[pgn-1] <= p_dvd->i_cur_cell )
1190     {
1191         p_dvd->i_chapter++;
1192         p_dvd->b_eoc = 1;
1193     }
1194 }
1195
1196 /*****************************************************************************
1197  * DvdReadLaunchDecoders
1198  *****************************************************************************/
1199 static void DvdReadLauchDecoders( input_thread_t * p_input )
1200 {
1201     thread_dvd_data_t *  p_dvd;
1202
1203     p_dvd = (thread_dvd_data_t*)(p_input->p_access_data);
1204
1205     if( config_GetInt( p_input, "video" ) )
1206     {
1207         input_SelectES( p_input, p_input->stream.pp_es[0] );
1208     }
1209
1210     if( config_GetInt( p_input, "audio" ) )
1211     {
1212         /* For audio: first one if none or a not existing one specified */
1213         int i_audio = config_GetInt( p_input, "audio-channel" );
1214         if( i_audio < 0 /*|| i_audio > i_audio_nb*/ )
1215         {
1216             config_PutInt( p_input, "audio-channel", 1 );
1217             i_audio = 1;
1218         }
1219         if( i_audio > 0/* && i_audio_nb > 0*/ )
1220         {
1221             if( config_GetInt( p_input, "audio-type" )
1222                  == REQUESTED_A52 )
1223             {
1224                 int     i_a52 = i_audio;
1225                 while( ( p_input->stream.pp_es[i_a52]->i_fourcc !=
1226                        VLC_FOURCC('a','5','2','b') ) && ( i_a52 <=
1227                        p_dvd->p_vts_file->vtsi_mat->nr_of_vts_audio_streams ) )
1228                 {
1229                     i_a52++;
1230                 }
1231                 if( p_input->stream.pp_es[i_a52]->i_fourcc
1232                      == VLC_FOURCC('a','5','2','b') )
1233                 {
1234                     input_SelectES( p_input,
1235                                     p_input->stream.pp_es[i_a52] );
1236                 }
1237             }
1238             else
1239             {
1240                 input_SelectES( p_input,
1241                                 p_input->stream.pp_es[i_audio] );
1242             }
1243         }
1244     }
1245
1246     if( config_GetInt( p_input, "video" ) )
1247     {
1248         /* for spu, default is none */
1249         int i_spu = config_GetInt( p_input, "spu-channel" );
1250         if( i_spu < 0 /*|| i_spu > i_spu_nb*/ )
1251         {
1252             config_PutInt( p_input, "spu-channel", 0 );
1253             i_spu = 0;
1254         }
1255         if( i_spu > 0 /*&& i_spu_nb > 0*/ )
1256         {
1257             i_spu += p_dvd->p_vts_file->vtsi_mat->nr_of_vts_audio_streams;
1258             input_SelectES( p_input, p_input->stream.pp_es[i_spu] );
1259         }
1260     }
1261 }