开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > midi > 查看源码
dvdnav.c
资源名称：vlc-1.0.5.zip　[点击查看]
上传用户：kjfoods
上传日期：2020-07-06
资源大小：29949k
文件大小：45k
源码类别：

midi

开发平台：

Unix_Linux

dvdnav.c：源码内容
  1. /*****************************************************************************
  2.  * dvdnav.c: DVD module using the dvdnav library.
  3.  *****************************************************************************
  4.  * Copyright (C) 2004-2009 the VideoLAN team
  5.  * $Id: b38852cf44c3fa2a2ef1fd0fdd1b116e3957b733 $
  6.  *
  7.  * Authors: Laurent Aimar <fenrir@via.ecp.fr>
  8.  *
  9.  * This program is free software; you can redistribute it and/or modify
  10.  * it under the terms of the GNU General Public License as published by
  11.  * the Free Software Foundation; either version 2 of the License, or
  12.  * (at your option) any later version.
  13.  *
  14.  * This program is distributed in the hope that it will be useful,
  15.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17.  * GNU General Public License for more details.
  18.  *
  19.  * You should have received a copy of the GNU General Public License
  20.  * along with this program; if not, write to the Free Software
  21.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  22.  *****************************************************************************/
  24. /*****************************************************************************
  25.  * Preamble
  26.  *****************************************************************************/
  28. #ifdef HAVE_CONFIG_H
  29. # include "config.h"
  30. #endif
  32. #include <assert.h>
  33. #include <vlc_common.h>
  34. #include <vlc_plugin.h>
  35. #include <vlc_input.h>
  36. #include <vlc_access.h>
  37. #include <vlc_demux.h>
  38. #include <vlc_charset.h>
  40. #include <vlc_dialog.h>
  42. #ifdef HAVE_UNISTD_H
  43. #   include <unistd.h>
  44. #endif
  45. #ifdef HAVE_SYS_TYPES_H
  46. #   include <sys/types.h>
  47. #endif
  48. #ifdef HAVE_SYS_STAT_H
  49. #   include <sys/stat.h>
  50. #endif
  51. #ifdef HAVE_FCNTL_H
  52. #   include <fcntl.h>
  53. #endif
  55. #include "vlc_keys.h"
  56. #include "vlc_iso_lang.h"
  58. /* FIXME we should find a better way than including that */
  59. #include "../../src/text/iso-639_def.h"
  62. #include <dvdnav/dvdnav.h>
  64. #include "../demux/ps.h"
  66. /*****************************************************************************
  67.  * Module descriptor
  68.  *****************************************************************************/
  69. #define ANGLE_TEXT N_("DVD angle")
  70. #define ANGLE_LONGTEXT N_( 
  71.      "Default DVD angle." )
  73. #define CACHING_TEXT N_("Caching value in ms")
  74. #define CACHING_LONGTEXT N_( 
  75.     "Caching value for DVDs. This "
  76.     "value should be set in milliseconds." )
  77. #define MENU_TEXT N_("Start directly in menu")
  78. #define MENU_LONGTEXT N_( 
  79.     "Start the DVD directly in the main menu. This "
  80.     "will try to skip all the useless warning introductions." )
  82. #define LANGUAGE_DEFAULT ("en")
  84. static int  Open ( vlc_object_t * );
  85. static void Close( vlc_object_t * );
  87. vlc_module_begin ()
  88.     set_shortname( N_("DVD with menus") )
  89.     set_description( N_("DVDnav Input") )
  90.     set_category( CAT_INPUT )
  91.     set_subcategory( SUBCAT_INPUT_ACCESS )
  92.     add_integer( "dvdnav-angle", 1, NULL, ANGLE_TEXT,
  93.         ANGLE_LONGTEXT, false )
  94.     add_integer( "dvdnav-caching", DEFAULT_PTS_DELAY / 1000, NULL,
  95.         CACHING_TEXT, CACHING_LONGTEXT, true )
  96.     add_bool( "dvdnav-menu", true, NULL,
  97.         MENU_TEXT, MENU_LONGTEXT, false )
  98.     set_capability( "access_demux", 5 )
  99.     add_shortcut( "dvd" )
  100.     add_shortcut( "dvdnav" )
  101.     add_shortcut( "file" )
  102.     set_callbacks( Open, Close )
  103. vlc_module_end ()
  105. /* Shall we use libdvdnav's read ahead cache? */
  106. #define DVD_READ_CACHE 1
  108. /*****************************************************************************
  109.  * Local prototypes
  110.  *****************************************************************************/
  111. struct demux_sys_t
  112. {
  113.     dvdnav_t    *dvdnav;
  115.     /* */
  116.     bool        b_reset_pcr;
  118.     struct
  119.     {
  120.         bool         b_created;
  121.         bool         b_enabled;
  122.         mtime_t      i_end;
  123.         vlc_mutex_t  lock;
  124.         vlc_cond_t   wait;
  125.         vlc_thread_t thread;
  126.     } still;
  128.     /* track */
  129.     ps_track_t  tk[PS_TK_COUNT];
  130.     int         i_mux_rate;
  132.     /* for spu variables */
  133.     input_thread_t *p_input;
  135.     /* event */
  136.     vlc_object_t *p_vout;
  138.     /* palette for menus */
  139.     uint32_t clut[16];
  140.     uint8_t  palette[4][4];
  141.     bool b_spu_change;
  143.     /* */
  144.     int i_aspect;
  146.     int           i_title;
  147.     input_title_t **title;
  149.     /* lenght of program group chain */
  150.     mtime_t     i_pgc_length;
  151. };
  153. static int Control( demux_t *, int, va_list );
  154. static int Demux( demux_t * );
  155. static int DemuxBlock( demux_t *, const uint8_t *, int );
  157. static void DemuxTitles( demux_t * );
  158. static void ESSubtitleUpdate( demux_t * );
  159. static void ButtonUpdate( demux_t *, bool );
  161. static void ESNew( demux_t *, int );
  162. static int ProbeDVD( demux_t *, char * );
  164. static char *DemuxGetLanguageCode( demux_t *p_demux, const char *psz_var );
  166. static int ControlInternal( demux_t *, int, ... );
  168. static void* StillThread( void * );
  170. static int EventKey( vlc_object_t *, char const *,
  171.                      vlc_value_t, vlc_value_t, void * );
  172. static int EventMouse( vlc_object_t *, char const *,
  173.                        vlc_value_t, vlc_value_t, void * );
  174. static int EventIntf( vlc_object_t *, char const *,
  175.                       vlc_value_t, vlc_value_t, void * );
  177. /*****************************************************************************
  178.  * DemuxOpen:
  179.  *****************************************************************************/
  180. static int Open( vlc_object_t *p_this )
  181. {
  182.     demux_t     *p_demux = (demux_t*)p_this;
  183.     demux_sys_t *p_sys;
  184.     dvdnav_t    *p_dvdnav;
  185.     int         i_angle;
  186.     char        *psz_name;
  187.     char        *psz_code;
  188.     vlc_value_t val;
  190.     if( !p_demux->psz_path || !*p_demux->psz_path )
  191.     {
  192.         /* Only when selected */
  193.         if( !p_this->b_force ) return VLC_EGENERIC;
  195.         psz_name = var_CreateGetString( p_this, "dvd" );
  196.         if( !psz_name )
  197.         {
  198.             psz_name = strdup("");
  199.         }
  200.     }
  201.     else
  202.         psz_name = ToLocaleDup( p_demux->psz_path );
  204. #ifdef WIN32
  205.     /* Remove trailing backslash, otherwise dvdnav_open will fail */
  206.     if( *psz_name && *(psz_name + strlen(psz_name) - 1) == '\' )
  207.     {
  208.         *(psz_name + strlen(psz_name) - 1) = '';
  209.     }
  210. #endif
  212.     /* Try some simple probing to avoid going through dvdnav_open too often */
  213.     if( ProbeDVD( p_demux, psz_name ) != VLC_SUCCESS )
  214.     {
  215.         free( psz_name );
  216.         return VLC_EGENERIC;
  217.     }
  219.     /* Open dvdnav */
  220.     if( dvdnav_open( &p_dvdnav, psz_name ) != DVDNAV_STATUS_OK )
  221.     {
  222.         msg_Warn( p_demux, "cannot open dvdnav" );
  223.         free( psz_name );
  224.         return VLC_EGENERIC;
  225.     }
  226.     free( psz_name );
  228.     /* Fill p_demux field */
  229.     DEMUX_INIT_COMMON(); p_sys = p_demux->p_sys;
  230.     p_sys->dvdnav = p_dvdnav;
  231.     p_sys->b_reset_pcr = false;
  233.     ps_track_init( p_sys->tk );
  234.     p_sys->i_aspect = -1;
  235.     p_sys->i_mux_rate = 0;
  236.     p_sys->i_pgc_length = 0;
  237.     p_sys->b_spu_change = false;
  239.     if( 1 )
  240.     {
  241.         // Hack for libdvdnav CVS.
  242.         // Without it dvdnav_get_number_of_titles() fails.
  243.         // Remove when fixed in libdvdnav CVS.
  244.         uint8_t buffer[DVD_VIDEO_LB_LEN];
  245.         int i_event, i_len;
  247.         if( dvdnav_get_next_block( p_sys->dvdnav, buffer, &i_event, &i_len )
  248.               == DVDNAV_STATUS_ERR )
  249.         {
  250.             msg_Warn( p_demux, "dvdnav_get_next_block failed" );
  251.         }
  253.         dvdnav_sector_search( p_sys->dvdnav, 0, SEEK_SET );
  254.     }
  256.     /* Configure dvdnav */
  257.     if( dvdnav_set_readahead_flag( p_sys->dvdnav, DVD_READ_CACHE ) !=
  258.           DVDNAV_STATUS_OK )
  259.     {
  260.         msg_Warn( p_demux, "cannot set read-a-head flag" );
  261.     }
  263.     if( dvdnav_set_PGC_positioning_flag( p_sys->dvdnav, 1 ) !=
  264.           DVDNAV_STATUS_OK )
  265.     {
  266.         msg_Warn( p_demux, "cannot set PGC positioning flag" );
  267.     }
  269.     /* Set menu language
  270.      * XXX A menu-language may be better than sub-language */
  271.     psz_code = DemuxGetLanguageCode( p_demux, "sub-language" );
  272.     if( dvdnav_menu_language_select( p_sys->dvdnav, psz_code ) !=
  273.         DVDNAV_STATUS_OK )
  274.     {
  275.         msg_Warn( p_demux, "can't set menu language to '%s' (%s)",
  276.                   psz_code, dvdnav_err_to_string( p_sys->dvdnav ) );
  277.         /* We try to fall back to 'en' */
  278.         if( strcmp( psz_code, LANGUAGE_DEFAULT ) )
  279.             dvdnav_menu_language_select( p_sys->dvdnav, (char*)LANGUAGE_DEFAULT );
  280.     }
  281.     free( psz_code );
  283.     /* Set audio language */
  284.     psz_code = DemuxGetLanguageCode( p_demux, "audio-language" );
  285.     if( dvdnav_audio_language_select( p_sys->dvdnav, psz_code ) !=
  286.         DVDNAV_STATUS_OK )
  287.     {
  288.         msg_Warn( p_demux, "can't set audio language to '%s' (%s)",
  289.                   psz_code, dvdnav_err_to_string( p_sys->dvdnav ) );
  290.         /* We try to fall back to 'en' */
  291.         if( strcmp( psz_code, LANGUAGE_DEFAULT ) )
  292.             dvdnav_audio_language_select( p_sys->dvdnav, (char*)LANGUAGE_DEFAULT );
  293.     }
  294.     free( psz_code );
  296.     /* Set spu language */
  297.     psz_code = DemuxGetLanguageCode( p_demux, "sub-language" );
  298.     if( dvdnav_spu_language_select( p_sys->dvdnav, psz_code ) !=
  299.         DVDNAV_STATUS_OK )
  300.     {
  301.         msg_Warn( p_demux, "can't set spu language to '%s' (%s)",
  302.                   psz_code, dvdnav_err_to_string( p_sys->dvdnav ) );
  303.         /* We try to fall back to 'en' */
  304.         if( strcmp( psz_code, LANGUAGE_DEFAULT ) )
  305.             dvdnav_spu_language_select(p_sys->dvdnav, (char*)LANGUAGE_DEFAULT );
  306.     }
  307.     free( psz_code );
  309.     DemuxTitles( p_demux );
  311.     var_Create( p_demux, "dvdnav-menu", VLC_VAR_BOOL|VLC_VAR_DOINHERIT );
  312.     var_Get( p_demux, "dvdnav-menu", &val );
  313.     if( val.b_bool )
  314.     {
  315.         msg_Dbg( p_demux, "trying to go to dvd menu" );
  317.         if( dvdnav_title_play( p_sys->dvdnav, 1 ) != DVDNAV_STATUS_OK )
  318.         {
  319.             msg_Err( p_demux, "cannot set title (can't decrypt DVD?)" );
  320.             dialog_Fatal( p_demux, _("Playback failure"), "%s",
  321.                             _("VLC cannot set the DVD's title. It possibly "
  322.                               "cannot decrypt the entire disc.") );
  323.             dvdnav_close( p_sys->dvdnav );
  324.             free( p_sys );
  325.             return VLC_EGENERIC;
  326.         }
  328.         if( dvdnav_menu_call( p_sys->dvdnav, DVD_MENU_Title ) !=
  329.             DVDNAV_STATUS_OK )
  330.         {
  331.             /* Try going to menu root */
  332.             if( dvdnav_menu_call( p_sys->dvdnav, DVD_MENU_Root ) !=
  333.                 DVDNAV_STATUS_OK )
  334.                     msg_Warn( p_demux, "cannot go to dvd menu" );
  335.         }
  336.     }
  338.     var_Create( p_demux, "dvdnav-angle", VLC_VAR_INTEGER|VLC_VAR_DOINHERIT );
  339.     var_Get( p_demux, "dvdnav-angle", &val );
  340.     i_angle = val.i_int > 0 ? val.i_int : 1;
  342.     /* Update default_pts to a suitable value for dvdnav access */
  343.     var_Create( p_demux, "dvdnav-caching", VLC_VAR_INTEGER|VLC_VAR_DOINHERIT );
  345.     /* FIXME hack hack hack hack FIXME */
  346.     /* Get p_input and create variable */
  347.     p_sys->p_input = vlc_object_find( p_demux, VLC_OBJECT_INPUT, FIND_PARENT );
  348.     var_Create( p_sys->p_input, "x-start", VLC_VAR_INTEGER );
  349.     var_Create( p_sys->p_input, "y-start", VLC_VAR_INTEGER );
  350.     var_Create( p_sys->p_input, "x-end", VLC_VAR_INTEGER );
  351.     var_Create( p_sys->p_input, "y-end", VLC_VAR_INTEGER );
  352.     var_Create( p_sys->p_input, "color", VLC_VAR_ADDRESS );
  353.     var_Create( p_sys->p_input, "menu-palette", VLC_VAR_ADDRESS );
  354.     var_Create( p_sys->p_input, "highlight", VLC_VAR_BOOL );
  355.     var_Create( p_sys->p_input, "highlight-mutex", VLC_VAR_MUTEX );
  357.     /* catch all key event */
  358.     var_AddCallback( p_demux->p_libvlc, "key-action", EventKey, p_demux );
  359.     /* catch vout creation event */
  360.     var_AddCallback( p_sys->p_input, "intf-event", EventIntf, p_demux );
  362.     p_sys->still.b_enabled = false;
  363.     vlc_mutex_init( &p_sys->still.lock );
  364.     return VLC_SUCCESS;
  365. }
  367. /*****************************************************************************
  368.  * Close:
  369.  *****************************************************************************/
  370. static void Close( vlc_object_t *p_this )
  371. {
  372.     demux_t     *p_demux = (demux_t*)p_this;
  373.     demux_sys_t *p_sys = p_demux->p_sys;
  374.     int i;
  376.     /* Stop vout event handler */
  377.     var_DelCallback( p_sys->p_input, "intf-event", EventIntf, p_demux );
  378.     if( p_sys->p_vout != NULL )
  379.     {   /* Should not happen, but better be safe than sorry. */
  380.         msg_Warn( p_sys->p_vout, "removing dangling mouse DVD callbacks" );
  381.         var_DelCallback( p_sys->p_vout, "mouse-moved", EventMouse, p_demux );
  382.         var_DelCallback( p_sys->p_vout, "mouse-clicked", EventMouse, p_demux );
  383.     }
  385.     /* Stop key event handler (FIXME: should really be per-vout too) */
  386.     var_DelCallback( p_demux->p_libvlc, "key-action", EventKey, p_demux );
  388.     /* Stop still image handler */
  389.     if( p_sys->still.b_created )
  390.     {
  391.         vlc_cancel( p_sys->still.thread );
  392.         vlc_join( p_sys->still.thread, NULL );
  393.         vlc_cond_destroy( &p_sys->still.wait );
  394.     }
  395.     vlc_mutex_destroy( &p_sys->still.lock );
  397.     var_Destroy( p_sys->p_input, "highlight-mutex" );
  398.     var_Destroy( p_sys->p_input, "highlight" );
  399.     var_Destroy( p_sys->p_input, "x-start" );
  400.     var_Destroy( p_sys->p_input, "x-end" );
  401.     var_Destroy( p_sys->p_input, "y-start" );
  402.     var_Destroy( p_sys->p_input, "y-end" );
  403.     var_Destroy( p_sys->p_input, "color" );
  404.     var_Destroy( p_sys->p_input, "menu-palette" );
  406.     vlc_object_release( p_sys->p_input );
  408.     for( i = 0; i < PS_TK_COUNT; i++ )
  409.     {
  410.         ps_track_t *tk = &p_sys->tk[i];
  411.         if( tk->b_seen )
  412.         {
  413.             es_format_Clean( &tk->fmt );
  414.             if( tk->es ) es_out_Del( p_demux->out, tk->es );
  415.         }
  416.     }
  418.     dvdnav_close( p_sys->dvdnav );
  419.     free( p_sys );
  420. }
  422. /*****************************************************************************
  423.  * Control:
  424.  *****************************************************************************/
  425. static int Control( demux_t *p_demux, int i_query, va_list args )
  426. {
  427.     demux_sys_t *p_sys = p_demux->p_sys;
  428.     double f, *pf;
  429.     bool *pb;
  430.     int64_t *pi64;
  431.     input_title_t ***ppp_title;
  432.     int          *pi_int;
  433.     int i;
  435.     switch( i_query )
  436.     {
  437.         case DEMUX_SET_POSITION:
  438.         case DEMUX_GET_POSITION:
  439.         case DEMUX_GET_TIME:
  440.         case DEMUX_GET_LENGTH:
  441.         {
  442.             uint32_t pos, len;
  443.             if( dvdnav_get_position( p_sys->dvdnav, &pos, &len ) !=
  444.                   DVDNAV_STATUS_OK || len == 0 )
  445.             {
  446.                 return VLC_EGENERIC;
  447.             }
  449.             if( i_query == DEMUX_GET_POSITION )
  450.             {
  451.                 pf = (double*)va_arg( args, double* );
  452.                 *pf = (double)pos / (double)len;
  453.                 return VLC_SUCCESS;
  454.             }
  455.             else if( i_query == DEMUX_SET_POSITION )
  456.             {
  457.                 f = (double)va_arg( args, double );
  458.                 pos = f * len;
  459.                 if( dvdnav_sector_search( p_sys->dvdnav, pos, SEEK_SET ) ==
  460.                       DVDNAV_STATUS_OK )
  461.                 {
  462.                     return VLC_SUCCESS;
  463.                 }
  464.             }
  465.             else if( i_query == DEMUX_GET_TIME )
  466.             {
  467.                 pi64 = (int64_t*)va_arg( args, int64_t * );
  468.                 if( p_sys->i_pgc_length > 0 )
  469.                 {
  470.                     *pi64 = p_sys->i_pgc_length * pos / len;
  471.                     return VLC_SUCCESS;
  472.                 }
  473.             }
  474.             else if( i_query == DEMUX_GET_LENGTH )
  475.             {
  476.                 pi64 = (int64_t*)va_arg( args, int64_t * );
  477.                 if( p_sys->i_pgc_length > 0 )
  478.                 {
  479.                     *pi64 = (int64_t)p_sys->i_pgc_length;
  480.                     return VLC_SUCCESS;
  481.                 }
  482.             }
  484.             return VLC_EGENERIC;
  485.         }
  487.         /* Special for access_demux */
  488.         case DEMUX_CAN_PAUSE:
  489.         case DEMUX_CAN_SEEK:
  490.         case DEMUX_CAN_CONTROL_PACE:
  491.             /* TODO */
  492.             pb = (bool*)va_arg( args, bool * );
  493.             *pb = true;
  494.             return VLC_SUCCESS;
  496.         case DEMUX_SET_PAUSE_STATE:
  497.             return VLC_SUCCESS;
  499.         case DEMUX_GET_TITLE_INFO:
  500.             ppp_title = (input_title_t***)va_arg( args, input_title_t*** );
  501.             pi_int    = (int*)va_arg( args, int* );
  502.             *((int*)va_arg( args, int* )) = 0; /* Title offset */
  503.             *((int*)va_arg( args, int* )) = 1; /* Chapter offset */
  505.             /* Duplicate title infos */
  506.             *pi_int = p_sys->i_title;
  507.             *ppp_title = malloc( sizeof( input_title_t ** ) * p_sys->i_title );
  508.             for( i = 0; i < p_sys->i_title; i++ )
  509.             {
  510.                 (*ppp_title)[i] = vlc_input_title_Duplicate( p_sys->title[i] );
  511.             }
  512.             return VLC_SUCCESS;
  514.         case DEMUX_SET_TITLE:
  515.             i = (int)va_arg( args, int );
  516.             if( ( i == 0 && dvdnav_menu_call( p_sys->dvdnav, DVD_MENU_Root )
  517.                   != DVDNAV_STATUS_OK ) ||
  518.                 ( i != 0 && dvdnav_title_play( p_sys->dvdnav, i )
  519.                   != DVDNAV_STATUS_OK ) )
  520.             {
  521.                 msg_Warn( p_demux, "cannot set title/chapter" );
  522.                 return VLC_EGENERIC;
  523.             }
  524.             p_demux->info.i_update |=
  525.                 INPUT_UPDATE_TITLE | INPUT_UPDATE_SEEKPOINT;
  526.             p_demux->info.i_title = i;
  527.             p_demux->info.i_seekpoint = 0;
  528.             return VLC_SUCCESS;
  530.         case DEMUX_SET_SEEKPOINT:
  531.             i = (int)va_arg( args, int );
  532.             if( p_demux->info.i_title == 0 )
  533.             {
  534.                 int i_ret;
  535.                 /* Special case */
  536.                 switch( i )
  537.                 {
  538.                 case 0:
  539.                     i_ret = dvdnav_menu_call( p_sys->dvdnav, DVD_MENU_Escape );
  540.                     break;
  541.                 case 1:
  542.                     i_ret = dvdnav_menu_call( p_sys->dvdnav, DVD_MENU_Root );
  543.                     break;
  544.                 case 2:
  545.                     i_ret = dvdnav_menu_call( p_sys->dvdnav, DVD_MENU_Title );
  546.                     break;
  547.                 case 3:
  548.                     i_ret = dvdnav_menu_call( p_sys->dvdnav, DVD_MENU_Part );
  549.                     break;
  550.                 case 4:
  551.                     i_ret = dvdnav_menu_call( p_sys->dvdnav,
  552.                                               DVD_MENU_Subpicture );
  553.                     break;
  554.                 case 5:
  555.                     i_ret = dvdnav_menu_call( p_sys->dvdnav, DVD_MENU_Audio );
  556.                     break;
  557.                 case 6:
  558.                     i_ret = dvdnav_menu_call( p_sys->dvdnav, DVD_MENU_Angle );
  559.                     break;
  560.                 default:
  561.                     return VLC_EGENERIC;
  562.                 }
  564.                 if( i_ret != DVDNAV_STATUS_OK )
  565.                     return VLC_EGENERIC;
  566.             }
  567.             else if( dvdnav_part_play( p_sys->dvdnav, p_demux->info.i_title,
  568.                                        i + 1 ) != DVDNAV_STATUS_OK )
  569.             {
  570.                 msg_Warn( p_demux, "cannot set title/chapter" );
  571.                 return VLC_EGENERIC;
  572.             }
  573.             p_demux->info.i_update |= INPUT_UPDATE_SEEKPOINT;
  574.             p_demux->info.i_seekpoint = i;
  575.             return VLC_SUCCESS;
  577.         case DEMUX_GET_PTS_DELAY:
  578.             pi64 = (int64_t*)va_arg( args, int64_t * );
  579.             *pi64 = (int64_t)var_GetInteger( p_demux, "dvdnav-caching" ) *1000;
  580.             return VLC_SUCCESS;
  582.         case DEMUX_GET_META:
  583.         {
  584.             const char *title_name = NULL;
  586.             dvdnav_get_title_string(p_sys->dvdnav, &title_name);
  587.             if( (NULL != title_name) && ('' != title_name[0]) )
  588.             {
  589.                 vlc_meta_t *p_meta = (vlc_meta_t*)va_arg( args, vlc_meta_t* );
  590.                 vlc_meta_Set( p_meta, vlc_meta_Title, title_name );
  591.                 return VLC_SUCCESS;
  592.             }
  593.             return VLC_EGENERIC;
  594.         }
  596.         /* TODO implement others */
  597.         default:
  598.             return VLC_EGENERIC;
  599.     }
  600. }
  602. static int ControlInternal( demux_t *p_demux, int i_query, ... )
  603. {
  604.     va_list args;
  605.     int     i_result;
  607.     va_start( args, i_query );
  608.     i_result = Control( p_demux, i_query, args );
  609.     va_end( args );
  611.     return i_result;
  612. }
  613. /*****************************************************************************
  614.  * Demux:
  615.  *****************************************************************************/
  616. static int Demux( demux_t *p_demux )
  617. {
  618.     demux_sys_t *p_sys = p_demux->p_sys;
  620.     uint8_t buffer[DVD_VIDEO_LB_LEN];
  621.     uint8_t *packet = buffer;
  622.     int i_event;
  623.     int i_len;
  625. #if DVD_READ_CACHE
  626.     if( dvdnav_get_next_cache_block( p_sys->dvdnav, &packet, &i_event, &i_len )
  627.         == DVDNAV_STATUS_ERR )
  628. #else
  629.     if( dvdnav_get_next_block( p_sys->dvdnav, packet, &i_event, &i_len )
  630.         == DVDNAV_STATUS_ERR )
  631. #endif
  632.     {
  633.         msg_Warn( p_demux, "cannot get next block (%s)",
  634.                   dvdnav_err_to_string( p_sys->dvdnav ) );
  635.         if( p_demux->info.i_title == 0 )
  636.         {
  637.             msg_Dbg( p_demux, "jumping to first title" );
  638.             return ControlInternal( p_demux, DEMUX_SET_TITLE, 1 ) == VLC_SUCCESS ? 1 : -1;
  639.         }
  640.         return -1;
  641.     }
  643.     switch( i_event )
  644.     {
  645.     case DVDNAV_BLOCK_OK:   /* mpeg block */
  646.         vlc_mutex_lock( &p_sys->still.lock );
  647.         p_sys->still.b_enabled = false;
  648.         vlc_mutex_unlock( &p_sys->still.lock );
  649.         if( p_sys->b_reset_pcr )
  650.         {
  651.             es_out_Control( p_demux->out, ES_OUT_RESET_PCR );
  652.             p_sys->b_reset_pcr = false;
  653.         }
  654.         DemuxBlock( p_demux, packet, i_len );
  655.         break;
  657.     case DVDNAV_NOP:    /* Nothing */
  658.         msg_Dbg( p_demux, "DVDNAV_NOP" );
  659.         break;
  661.     case DVDNAV_STILL_FRAME:
  662.     {
  663.         dvdnav_still_event_t *event = (dvdnav_still_event_t*)packet;
  664.         bool b_still_init = false;
  666.         vlc_mutex_lock( &p_sys->still.lock );
  667.         if( !p_sys->still.b_enabled )
  668.         {
  669.             msg_Dbg( p_demux, "DVDNAV_STILL_FRAME" );
  670.             msg_Dbg( p_demux, "     - length=0x%x", event->length );
  671.             /* FIXME: use vlc_timer_create() if it is ever invented */
  672.             p_sys->still.b_enabled = true;
  674.             if( !p_sys->still.b_created )
  675.             {
  676.                 vlc_cond_init( &p_sys->still.wait );
  677.                 p_sys->still.b_created =
  678.                     !vlc_clone( &p_sys->still.thread, StillThread, p_sys,
  679.                                 VLC_THREAD_PRIORITY_LOW );
  680.             }
  682.             b_still_init = true;
  683.             if( event->length == 0xff )
  684.                 p_sys->still.i_end = 0;
  685.             else
  686.                 p_sys->still.i_end = mdate() +
  687.                                      event->length * INT64_C(1000000);
  688.             vlc_cond_signal( &p_sys->still.wait );
  689.         }
  690.         vlc_mutex_unlock( &p_sys->still.lock );
  692.         if( b_still_init )
  693.         {
  694.             /* We send a dummy mpeg2 end of sequence to force still frame display */
  695.             static const uint8_t buffer[] = {
  696.                 0x00, 0x00, 0x01, 0xe0, 0x00, 0x07,
  697.                 0x80, 0x00, 0x00,
  698.                 0x00, 0x00, 0x01, 0xB7,
  699.             };
  700.             DemuxBlock( p_demux, buffer, sizeof(buffer) );
  702.             bool b_empty;
  703.             es_out_Control( p_demux->out, ES_OUT_GET_EMPTY, &b_empty );
  704.             p_sys->b_reset_pcr = true;
  705.         }
  706.         msleep( 40000 );
  707.         break;
  708.     }
  710.     case DVDNAV_SPU_CLUT_CHANGE:
  711.     {
  712.         int i;
  714.         msg_Dbg( p_demux, "DVDNAV_SPU_CLUT_CHANGE" );
  715.         /* Update color lookup table (16 *uint32_t in packet) */
  716.         memcpy( p_sys->clut, packet, 16 * sizeof( uint32_t ) );
  718.         /* HACK to get the SPU tracks registered in the right order */
  719.         for( i = 0; i < 0x1f; i++ )
  720.         {
  721.             if( dvdnav_spu_stream_to_lang( p_sys->dvdnav, i ) != 0xffff )
  722.                 ESNew( p_demux, 0xbd20 + i );
  723.         }
  724.         /* END HACK */
  725.         break;
  726.     }
  728.     case DVDNAV_SPU_STREAM_CHANGE:
  729.     {
  730.         dvdnav_spu_stream_change_event_t *event =
  731.             (dvdnav_spu_stream_change_event_t*)packet;
  732.         int i;
  734.         msg_Dbg( p_demux, "DVDNAV_SPU_STREAM_CHANGE" );
  735.         msg_Dbg( p_demux, "     - physical_wide=%d",
  736.                  event->physical_wide );
  737.         msg_Dbg( p_demux, "     - physical_letterbox=%d",
  738.                  event->physical_letterbox);
  739.         msg_Dbg( p_demux, "     - physical_pan_scan=%d",
  740.                  event->physical_pan_scan );
  742.         ESSubtitleUpdate( p_demux );
  743.         p_sys->b_spu_change = true;
  745.         /* HACK to get the SPU tracks registered in the right order */
  746.         for( i = 0; i < 0x1f; i++ )
  747.         {
  748.             if( dvdnav_spu_stream_to_lang( p_sys->dvdnav, i ) != 0xffff )
  749.                 ESNew( p_demux, 0xbd20 + i );
  750.         }
  751.         /* END HACK */
  752.         break;
  753.     }
  755.     case DVDNAV_AUDIO_STREAM_CHANGE:
  756.     {
  757.         dvdnav_audio_stream_change_event_t *event =
  758.             (dvdnav_audio_stream_change_event_t*)packet;
  759.         msg_Dbg( p_demux, "DVDNAV_AUDIO_STREAM_CHANGE" );
  760.         msg_Dbg( p_demux, "     - physical=%d", event->physical );
  761.         /* TODO */
  762.         break;
  763.     }
  765.     case DVDNAV_VTS_CHANGE:
  766.     {
  767.         int32_t i_title = 0;
  768.         int32_t i_part  = 0;
  769.         int i;
  771.         dvdnav_vts_change_event_t *event = (dvdnav_vts_change_event_t*)packet;
  772.         msg_Dbg( p_demux, "DVDNAV_VTS_CHANGE" );
  773.         msg_Dbg( p_demux, "     - vtsN=%d", event->new_vtsN );
  774.         msg_Dbg( p_demux, "     - domain=%d", event->new_domain );
  776.         /* dvdnav_get_video_aspect / dvdnav_get_video_scale_permission */
  777.         /* TODO check if we always have VTS and CELL */
  778.         p_sys->i_aspect = dvdnav_get_video_aspect( p_sys->dvdnav );
  780.         /* reset PCR */
  781.         es_out_Control( p_demux->out, ES_OUT_RESET_PCR );
  783.         for( i = 0; i < PS_TK_COUNT; i++ )
  784.         {
  785.             ps_track_t *tk = &p_sys->tk[i];
  786.             if( tk->b_seen )
  787.             {
  788.                 es_format_Clean( &tk->fmt );
  789.                 if( tk->es ) es_out_Del( p_demux->out, tk->es );
  790.             }
  791.             tk->b_seen = false;
  792.         }
  794.         if( dvdnav_current_title_info( p_sys->dvdnav, &i_title,
  795.                                        &i_part ) == DVDNAV_STATUS_OK )
  796.         {
  797.             if( i_title >= 0 && i_title < p_sys->i_title &&
  798.                 p_demux->info.i_title != i_title )
  799.             {
  800.                 p_demux->info.i_update |= INPUT_UPDATE_TITLE;
  801.                 p_demux->info.i_title = i_title;
  802.             }
  803.         }
  804.         break;
  805.     }
  807.     case DVDNAV_CELL_CHANGE:
  808.     {
  809.         int32_t i_title = 0;
  810.         int32_t i_part  = 0;
  812.         dvdnav_cell_change_event_t *event =
  813.             (dvdnav_cell_change_event_t*)packet;
  814.         msg_Dbg( p_demux, "DVDNAV_CELL_CHANGE" );
  815.         msg_Dbg( p_demux, "     - cellN=%d", event->cellN );
  816.         msg_Dbg( p_demux, "     - pgN=%d", event->pgN );
  817.         msg_Dbg( p_demux, "     - cell_length=%"PRId64, event->cell_length );
  818.         msg_Dbg( p_demux, "     - pg_length=%"PRId64, event->pg_length );
  819.         msg_Dbg( p_demux, "     - pgc_length=%"PRId64, event->pgc_length );
  820.         msg_Dbg( p_demux, "     - cell_start=%"PRId64, event->cell_start );
  821.         msg_Dbg( p_demux, "     - pg_start=%"PRId64, event->pg_start );
  823.         /* Store the lenght in time of the current PGC */
  824.         p_sys->i_pgc_length = event->pgc_length / 90 * 1000;
  826.         /* FIXME is it correct or there is better way to know chapter change */
  827.         if( dvdnav_current_title_info( p_sys->dvdnav, &i_title,
  828.                                        &i_part ) == DVDNAV_STATUS_OK )
  829.         {
  830.             if( i_title >= 0 && i_title < p_sys->i_title &&
  831.                 i_part >= 1 && i_part <= p_sys->title[i_title]->i_seekpoint &&
  832.                 p_demux->info.i_seekpoint != i_part - 1 )
  833.             {
  834.                 p_demux->info.i_update |= INPUT_UPDATE_SEEKPOINT;
  835.                 p_demux->info.i_seekpoint = i_part - 1;
  836.             }
  837.         }
  838.         break;
  839.     }
  841.     case DVDNAV_NAV_PACKET:
  842.     {
  843. #ifdef DVDNAV_DEBUG
  844.         msg_Dbg( p_demux, "DVDNAV_NAV_PACKET" );
  845. #endif
  846.         /* A lot of thing to do here :
  847.          *  - handle packet
  848.          *  - fetch pts (for time display)
  849.          *  - ...
  850.          */
  851.         DemuxBlock( p_demux, packet, i_len );
  852.         if( p_sys->b_spu_change )
  853.         {
  854.             ButtonUpdate( p_demux, false );
  855.             p_sys->b_spu_change = false;
  856.         }
  857.         break;
  858.     }
  860.     case DVDNAV_STOP:   /* EOF */
  861.         msg_Dbg( p_demux, "DVDNAV_STOP" );
  863. #if DVD_READ_CACHE
  864.         dvdnav_free_cache_block( p_sys->dvdnav, packet );
  865. #endif
  866.         return 0;
  868.     case DVDNAV_HIGHLIGHT:
  869.     {
  870.         dvdnav_highlight_event_t *event = (dvdnav_highlight_event_t*)packet;
  871.         msg_Dbg( p_demux, "DVDNAV_HIGHLIGHT" );
  872.         msg_Dbg( p_demux, "     - display=%d", event->display );
  873.         msg_Dbg( p_demux, "     - buttonN=%d", event->buttonN );
  874.         ButtonUpdate( p_demux, false );
  875.         break;
  876.     }
  878.     case DVDNAV_HOP_CHANNEL:
  879.         msg_Dbg( p_demux, "DVDNAV_HOP_CHANNEL" );
  880.         es_out_Control( p_demux->out, ES_OUT_RESET_PCR );
  881.         break;
  883.     case DVDNAV_WAIT:
  884.         msg_Dbg( p_demux, "DVDNAV_WAIT" );
  886.         bool b_empty;
  887.         es_out_Control( p_demux->out, ES_OUT_GET_EMPTY, &b_empty );
  888.         if( !b_empty )
  889.         {
  890.             msleep( 40*1000 );
  891.         }
  892.         else
  893.         {
  894.             dvdnav_wait_skip( p_sys->dvdnav );
  895.             p_sys->b_reset_pcr = true;
  896.         }
  897.         break;
  899.     default:
  900.         msg_Warn( p_demux, "Unknown event (0x%x)", i_event );
  901.         break;
  902.     }
  904. #if DVD_READ_CACHE
  905.     dvdnav_free_cache_block( p_sys->dvdnav, packet );
  906. #endif
  908.     return 1;
  909. }
  911. /* Get a 2 char code
  912.  * FIXME: partiallyy duplicated from src/input/es_out.c
  913.  */
  914. static char *DemuxGetLanguageCode( demux_t *p_demux, const char *psz_var )
  915. {
  916.     const iso639_lang_t *pl;
  917.     char *psz_lang;
  918.     char *p;
  920.     psz_lang = var_CreateGetString( p_demux, psz_var );
  921.     if( !psz_lang )
  922.         return strdup(LANGUAGE_DEFAULT);
  924.     /* XXX: we will use only the first value
  925.      * (and ignore other ones in case of a list) */
  926.     if( ( p = strchr( psz_lang, ',' ) ) )
  927.         *p = '';
  929.     for( pl = p_languages; pl->psz_iso639_1 != NULL; pl++ )
  930.     {
  931.         if( *psz_lang == '' )
  932.             continue;
  933.         if( !strcasecmp( pl->psz_eng_name, psz_lang ) ||
  934.             !strcasecmp( pl->psz_native_name, psz_lang ) ||
  935.             !strcasecmp( pl->psz_iso639_1, psz_lang ) ||
  936.             !strcasecmp( pl->psz_iso639_2T, psz_lang ) ||
  937.             !strcasecmp( pl->psz_iso639_2B, psz_lang ) )
  938.             break;
  939.     }
  941.     free( psz_lang );
  943.     if( pl->psz_iso639_1 != NULL )
  944.         return strdup( pl->psz_iso639_1 );
  946.     return strdup(LANGUAGE_DEFAULT);
  947. }
  949. static void DemuxTitles( demux_t *p_demux )
  950. {
  951.     demux_sys_t *p_sys = p_demux->p_sys;
  952.     input_title_t *t;
  953.     seekpoint_t *s;
  954.     int32_t i_titles;
  955.     int i;
  957.     /* Menu */
  958.     t = vlc_input_title_New();
  959.     t->b_menu = true;
  960.     t->psz_name = strdup( "DVD Menu" );
  962.     s = vlc_seekpoint_New();
  963.     s->psz_name = strdup( "Resume" );
  964.     TAB_APPEND( t->i_seekpoint, t->seekpoint, s );
  966.     s = vlc_seekpoint_New();
  967.     s->psz_name = strdup( "Root" );
  968.     TAB_APPEND( t->i_seekpoint, t->seekpoint, s );
  970.     s = vlc_seekpoint_New();
  971.     s->psz_name = strdup( "Title" );
  972.     TAB_APPEND( t->i_seekpoint, t->seekpoint, s );
  974.     s = vlc_seekpoint_New();
  975.     s->psz_name = strdup( "Chapter" );
  976.     TAB_APPEND( t->i_seekpoint, t->seekpoint, s );
  978.     s = vlc_seekpoint_New();
  979.     s->psz_name = strdup( "Subtitle" );
  980.     TAB_APPEND( t->i_seekpoint, t->seekpoint, s );
  982.     s = vlc_seekpoint_New();
  983.     s->psz_name = strdup( "Audio" );
  984.     TAB_APPEND( t->i_seekpoint, t->seekpoint, s );
  986.     s = vlc_seekpoint_New();
  987.     s->psz_name = strdup( "Angle" );
  988.     TAB_APPEND( t->i_seekpoint, t->seekpoint, s );
  990.     TAB_APPEND( p_sys->i_title, p_sys->title, t );
  992.     /* Find out number of titles/chapters */
  993.     dvdnav_get_number_of_titles( p_sys->dvdnav, &i_titles );
  994.     for( i = 1; i <= i_titles; i++ )
  995.     {
  996.         int32_t i_chapters = 0;
  997.         int j;
  999.         dvdnav_get_number_of_parts( p_sys->dvdnav, i, &i_chapters );
  1001.         t = vlc_input_title_New();
  1002.         for( j = 0; j < __MAX( i_chapters, 1 ); j++ )
  1003.         {
  1004.             s = vlc_seekpoint_New();
  1005.             TAB_APPEND( t->i_seekpoint, t->seekpoint, s );
  1006.         }
  1008.         TAB_APPEND( p_sys->i_title, p_sys->title, t );
  1009.     }
  1010. }
  1012. /*****************************************************************************
  1013.  * Update functions:
  1014.  *****************************************************************************/
  1015. static void ButtonUpdate( demux_t *p_demux, bool b_mode )
  1016. {
  1017.     demux_sys_t *p_sys = p_demux->p_sys;
  1018.     vlc_value_t val;
  1019.     int32_t i_title, i_part;
  1021.     dvdnav_current_title_info( p_sys->dvdnav, &i_title, &i_part );
  1023.     if( var_Get( p_sys->p_input, "highlight-mutex", &val ) == VLC_SUCCESS )
  1024.     {
  1025.         vlc_mutex_t *p_mutex = val.p_address;
  1026.         dvdnav_highlight_area_t hl;
  1027.         int32_t i_button;
  1028.         bool    b_button_ok;
  1030.         if( dvdnav_get_current_highlight( p_sys->dvdnav, &i_button )
  1031.             != DVDNAV_STATUS_OK )
  1032.         {
  1033.             msg_Err( p_demux, "dvdnav_get_current_highlight failed" );
  1034.             return;
  1035.         }
  1037.         b_button_ok = false;
  1038.         if( i_button > 0 && i_title ==  0 )
  1039.         {
  1040.             pci_t *pci = dvdnav_get_current_nav_pci( p_sys->dvdnav );
  1042.             b_button_ok = dvdnav_get_highlight_area( pci, i_button, b_mode, &hl ) == DVDNAV_STATUS_OK;
  1043.         }
  1044.         if( b_button_ok )
  1045.         {
  1046.             int i;
  1047.             for( i = 0; i < 4; i++ )
  1048.             {
  1049.                 uint32_t i_yuv = p_sys->clut[(hl.palette>>(16+i*4))&0x0f];
  1050.                 uint8_t i_alpha = ( (hl.palette>>(i*4))&0x0f ) * 0xff / 0xf;
  1052.                 p_sys->palette[i][0] = (i_yuv >> 16) & 0xff;
  1053.                 p_sys->palette[i][1] = (i_yuv >> 0) & 0xff;
  1054.                 p_sys->palette[i][2] = (i_yuv >> 8) & 0xff;
  1055.                 p_sys->palette[i][3] = i_alpha;
  1056.             }
  1058.             vlc_mutex_lock( p_mutex );
  1059.             val.i_int = hl.sx; var_Set( p_sys->p_input, "x-start", val );
  1060.             val.i_int = hl.ex; var_Set( p_sys->p_input, "x-end", val );
  1061.             val.i_int = hl.sy; var_Set( p_sys->p_input, "y-start", val );
  1062.             val.i_int = hl.ey; var_Set( p_sys->p_input, "y-end", val );
  1064.             val.p_address = (void *)p_sys->palette;
  1065.             var_Set( p_sys->p_input, "menu-palette", val );
  1067.             val.b_bool = true; var_Set( p_sys->p_input, "highlight", val );
  1068.             vlc_mutex_unlock( p_mutex );
  1070.             msg_Dbg( p_demux, "buttonUpdate %d", i_button );
  1071.         }
  1072.         else
  1073.         {
  1074.             msg_Dbg( p_demux, "buttonUpdate not done b=%d t=%d",
  1075.                      i_button, i_title );
  1077.             /* Show all */
  1078.             vlc_mutex_lock( p_mutex );
  1079.             val.b_bool = false;
  1080.             var_Set( p_sys->p_input, "highlight", val );
  1081.             vlc_mutex_unlock( p_mutex );
  1082.         }
  1083.     }
  1084. }
  1086. static void ESSubtitleUpdate( demux_t *p_demux )
  1087. {
  1088.     demux_sys_t *p_sys = p_demux->p_sys;
  1089.     int         i_spu = dvdnav_get_active_spu_stream( p_sys->dvdnav );
  1090.     int32_t i_title, i_part;
  1092.     ButtonUpdate( p_demux, false );
  1094.     dvdnav_current_title_info( p_sys->dvdnav, &i_title, &i_part );
  1095.     if( i_title > 0 ) return;
  1097.     if( i_spu >= 0 && i_spu <= 0x1f )
  1098.     {
  1099.         ps_track_t *tk = &p_sys->tk[PS_ID_TO_TK(0xbd20 + i_spu)];
  1101.         ESNew( p_demux, 0xbd20 + i_spu );
  1103.         /* be sure to unselect it (reset) */
  1104.         es_out_Control( p_demux->out, ES_OUT_SET_ES_STATE, tk->es,
  1105.                         (bool)false );
  1107.         /* now select it */
  1108.         es_out_Control( p_demux->out, ES_OUT_SET_ES, tk->es );
  1109.     }
  1110.     else
  1111.     {
  1112.         for( i_spu = 0; i_spu <= 0x1F; i_spu++ )
  1113.         {
  1114.             ps_track_t *tk = &p_sys->tk[PS_ID_TO_TK(0xbd20 + i_spu)];
  1115.             if( tk->b_seen )
  1116.             {
  1117.                 es_out_Control( p_demux->out, ES_OUT_SET_ES_STATE, tk->es,
  1118.                                 (bool)false );
  1119.             }
  1120.         }
  1121.     }
  1122. }
  1124. /*****************************************************************************
  1125.  * DemuxBlock: demux a given block
  1126.  *****************************************************************************/
  1127. static int DemuxBlock( demux_t *p_demux, const uint8_t *pkt, int i_pkt )
  1128. {
  1129.     demux_sys_t *p_sys = p_demux->p_sys;
  1130.     const uint8_t     *p = pkt;
  1132.     while( p < &pkt[i_pkt] )
  1133.     {
  1134.         int i_size = ps_pkt_size( p, &pkt[i_pkt] - p );
  1135.         block_t *p_pkt;
  1136.         if( i_size <= 0 )
  1137.         {
  1138.             break;
  1139.         }
  1141.         /* Create a block */
  1142.         p_pkt = block_New( p_demux, i_size );
  1143.         memcpy( p_pkt->p_buffer, p, i_size);
  1145.         /* Parse it and send it */
  1146.         switch( 0x100 | p[3] )
  1147.         {
  1148.         case 0x1b9:
  1149.         case 0x1bb:
  1150.         case 0x1bc:
  1151. #ifdef DVDNAV_DEBUG
  1152.             if( p[3] == 0xbc )
  1153.             {
  1154.                 msg_Warn( p_demux, "received a PSM packet" );
  1155.             }
  1156.             else if( p[3] == 0xbb )
  1157.             {
  1158.                 msg_Warn( p_demux, "received a SYSTEM packet" );
  1159.             }
  1160. #endif
  1161.             block_Release( p_pkt );
  1162.             break;
  1164.         case 0x1ba:
  1165.         {
  1166.             int64_t i_scr;
  1167.             int i_mux_rate;
  1168.             if( !ps_pkt_parse_pack( p_pkt, &i_scr, &i_mux_rate ) )
  1169.             {
  1170.                 es_out_Control( p_demux->out, ES_OUT_SET_PCR, i_scr + 1 );
  1171.                 if( i_mux_rate > 0 ) p_sys->i_mux_rate = i_mux_rate;
  1172.             }
  1173.             block_Release( p_pkt );
  1174.             break;
  1175.         }
  1176.         default:
  1177.         {
  1178.             int i_id = ps_pkt_id( p_pkt );
  1179.             if( i_id >= 0xc0 )
  1180.             {
  1181.                 ps_track_t *tk = &p_sys->tk[PS_ID_TO_TK(i_id)];
  1183.                 if( !tk->b_seen )
  1184.                 {
  1185.                     ESNew( p_demux, i_id );
  1186.                 }
  1187.                 if( tk->b_seen && tk->es &&
  1188.                     !ps_pkt_parse_pes( p_pkt, tk->i_skip ) )
  1189.                 {
  1190.                     es_out_Send( p_demux->out, tk->es, p_pkt );
  1191.                 }
  1192.                 else
  1193.                 {
  1194.                     block_Release( p_pkt );
  1195.                 }
  1196.             }
  1197.             else
  1198.             {
  1199.                 block_Release( p_pkt );
  1200.             }
  1201.             break;
  1202.         }
  1203.         }
  1205.         p += i_size;
  1206.     }
  1208.     return VLC_SUCCESS;
  1209. }
  1211. /*****************************************************************************
  1212.  * ESNew: register a new elementary stream
  1213.  *****************************************************************************/
  1214. static void ESNew( demux_t *p_demux, int i_id )
  1215. {
  1216.     demux_sys_t *p_sys = p_demux->p_sys;
  1217.     ps_track_t  *tk = &p_sys->tk[PS_ID_TO_TK(i_id)];
  1218.     bool  b_select = false;
  1220.     if( tk->b_seen ) return;
  1222.     if( ps_track_fill( tk, 0, i_id ) )
  1223.     {
  1224.         msg_Warn( p_demux, "unknown codec for id=0x%x", i_id );
  1225.         return;
  1226.     }
  1228.     /* Add a new ES */
  1229.     if( tk->fmt.i_cat == VIDEO_ES )
  1230.     {
  1231.         switch( p_sys->i_aspect )
  1232.         {
  1233.         case 1: tk->fmt.video.i_aspect = VOUT_ASPECT_FACTOR; break;
  1234.         case 2: tk->fmt.video.i_aspect = VOUT_ASPECT_FACTOR * 4 / 3; break;
  1235.         case 3: tk->fmt.video.i_aspect = VOUT_ASPECT_FACTOR * 16 / 9; break;
  1236.         case 4: tk->fmt.video.i_aspect = VOUT_ASPECT_FACTOR * 221 / 10; break;
  1237.         default:
  1238.             tk->fmt.video.i_aspect = 0;
  1239.             break;
  1240.         }
  1241.         b_select = true;
  1242.     }
  1243.     else if( tk->fmt.i_cat == AUDIO_ES )
  1244.     {
  1245.         int i_audio = -1;
  1246.         /* find the audio number PLEASE find another way */
  1247.         if( (i_id&0xbdf8) == 0xbd88 )       /* dts */
  1248.         {
  1249.             i_audio = i_id&0x07;
  1250.         }
  1251.         else if( (i_id&0xbdf0) == 0xbd80 )  /* a52 */
  1252.         {
  1253.             i_audio = i_id&0xf;
  1254.         }
  1255.         else if( (i_id&0xbdf0) == 0xbda0 )  /* lpcm */
  1256.         {
  1257.             i_audio = i_id&0x1f;
  1258.         }
  1259.         else if( ( i_id&0xe0 ) == 0xc0 )    /* mpga */
  1260.         {
  1261.             i_audio = i_id&0x1f;
  1262.         }
  1263.         if( i_audio >= 0 )
  1264.         {
  1265.             int i_lang = dvdnav_audio_stream_to_lang( p_sys->dvdnav, i_audio );
  1266.             if( i_lang != 0xffff )
  1267.             {
  1268.                 tk->fmt.psz_language = malloc( 3 );
  1269.                 tk->fmt.psz_language[0] = (i_lang >> 8)&0xff;
  1270.                 tk->fmt.psz_language[1] = (i_lang     )&0xff;
  1271.                 tk->fmt.psz_language[2] = 0;
  1272.             }
  1273.             if( dvdnav_get_active_audio_stream( p_sys->dvdnav ) == i_audio )
  1274.             {
  1275.                 b_select = true;
  1276.             }
  1277.         }
  1278.     }
  1279.     else if( tk->fmt.i_cat == SPU_ES )
  1280.     {
  1281.         int32_t i_title, i_part;
  1282.         int i_lang = dvdnav_spu_stream_to_lang( p_sys->dvdnav, i_id&0x1f );
  1283.         if( i_lang != 0xffff )
  1284.         {
  1285.             tk->fmt.psz_language = malloc( 3 );
  1286.             tk->fmt.psz_language[0] = (i_lang >> 8)&0xff;
  1287.             tk->fmt.psz_language[1] = (i_lang     )&0xff;
  1288.             tk->fmt.psz_language[2] = 0;
  1289.         }
  1291.         /* Palette */
  1292.         tk->fmt.subs.spu.palette[0] = 0xBeef;
  1293.         memcpy( &tk->fmt.subs.spu.palette[1], p_sys->clut,
  1294.                 16 * sizeof( uint32_t ) );
  1296.         /* We select only when we are not in the menu */
  1297.         dvdnav_current_title_info( p_sys->dvdnav, &i_title, &i_part );
  1298.         if( i_title > 0 &&
  1299.             dvdnav_get_active_spu_stream( p_sys->dvdnav ) == (i_id&0x1f) )
  1300.         {
  1301.             b_select = true;
  1302.         }
  1303.     }
  1305.     tk->es = es_out_Add( p_demux->out, &tk->fmt );
  1306.     if( b_select )
  1307.     {
  1308.         es_out_Control( p_demux->out, ES_OUT_SET_ES, tk->es );
  1309.     }
  1310.     tk->b_seen = true;
  1312.     if( tk->fmt.i_cat == VIDEO_ES ) ButtonUpdate( p_demux, false );
  1313. }
  1315. /*****************************************************************************
  1316.  * Event handler code
  1317.  *****************************************************************************/
  1318. static void* StillThread( void *p_data )
  1319. {
  1320.     demux_sys_t    *p_sys = p_data;
  1322.     vlc_mutex_lock( &p_sys->still.lock );
  1323.     mutex_cleanup_push( &p_sys->still.lock );
  1324.     for( ;; )
  1325.     {
  1326.         if( p_sys->still.b_enabled && p_sys->still.i_end )
  1327.         {
  1328.             if( vlc_cond_timedwait( &p_sys->still.wait, &p_sys->still.lock,
  1329.                                     p_sys->still.i_end ) )
  1330.             {   /* Still image time out */
  1331.                 int canc = vlc_savecancel();
  1332.                 p_sys->still.b_enabled = false;
  1333.                 dvdnav_still_skip( p_sys->dvdnav );
  1334.                 vlc_restorecancel( canc );
  1335.             }
  1336.         }
  1337.         else
  1338.             vlc_cond_wait( &p_sys->still.wait, &p_sys->still.lock );
  1339.     }
  1340.     vlc_cleanup_pop(  );
  1342.     assert( 0 );
  1343. }
  1345. static int EventMouse( vlc_object_t *p_vout, char const *psz_var,
  1346.                        vlc_value_t oldval, vlc_value_t val, void *p_data )
  1347. {
  1348.     demux_t *p_demux = p_data;
  1349.     demux_sys_t *p_sys = p_demux->p_sys;
  1351.     /* FIXME? PCI usage thread safe? */
  1352.     pci_t *pci = dvdnav_get_current_nav_pci( p_sys->dvdnav );
  1353.     int x = var_GetInteger( p_vout, "mouse-x" );
  1354.     int y = var_GetInteger( p_vout, "mouse-y" );
  1356.     if( psz_var[6] == 'm' ) /* mouse-moved */
  1357.         dvdnav_mouse_select( p_sys->dvdnav, pci, x, y );
  1358.     else
  1359.     {
  1360.         assert( psz_var[6] == 'c' ); /* mouse-clicked */
  1362.         ButtonUpdate( p_demux, true );
  1363.         dvdnav_mouse_activate( p_sys->dvdnav, pci, x, y );
  1364.     }
  1366.     (void)oldval; (void)val;
  1367.     return VLC_SUCCESS;
  1368. }
  1370. static int EventKey( vlc_object_t *p_this, char const *psz_var,
  1371.                      vlc_value_t oldval, vlc_value_t newval, void *p_data )
  1372. {
  1373.     demux_t *p_demux = p_data;
  1374.     demux_sys_t *p_sys = p_demux->p_sys;
  1376.     /* FIXME: thread-safe ? */
  1377.     pci_t *pci = dvdnav_get_current_nav_pci( p_sys->dvdnav );
  1379.     switch( newval.i_int )
  1380.     {
  1381.     case ACTIONID_NAV_LEFT:
  1382.         dvdnav_left_button_select( p_sys->dvdnav, pci );
  1383.         break;
  1384.     case ACTIONID_NAV_RIGHT:
  1385.         dvdnav_right_button_select( p_sys->dvdnav, pci );
  1386.         break;
  1387.     case ACTIONID_NAV_UP:
  1388.         dvdnav_upper_button_select( p_sys->dvdnav, pci );
  1389.         break;
  1390.     case ACTIONID_NAV_DOWN:
  1391.         dvdnav_lower_button_select( p_sys->dvdnav, pci );
  1392.         break;
  1393.     case ACTIONID_NAV_ACTIVATE:
  1394.         ButtonUpdate( p_demux, true );
  1395.         dvdnav_button_activate( p_sys->dvdnav, pci );
  1396.         break;
  1397.     }
  1399.     (void)p_this;    (void)psz_var;    (void)oldval;
  1400.     return VLC_SUCCESS;
  1401. }
  1403. static int EventIntf( vlc_object_t *p_input, char const *psz_var,
  1404.                       vlc_value_t oldval, vlc_value_t val, void *p_data )
  1405. {
  1406.     demux_t *p_demux = p_data;
  1407.     demux_sys_t *p_sys = p_demux->p_sys;
  1409.     if (val.i_int == INPUT_EVENT_VOUT)
  1410.     {
  1411.         vlc_object_t *p_vout;
  1413.         p_vout = p_sys->p_vout;
  1414.         if( p_vout != NULL )
  1415.         {
  1416.             var_DelCallback( p_vout, "mouse-moved", EventMouse, p_demux );
  1417.             var_DelCallback( p_vout, "mouse-clicked", EventMouse, p_demux );
  1418.             vlc_object_release( p_vout );
  1419.         }
  1421.         p_vout = (vlc_object_t *)input_GetVout( (input_thread_t *)p_input );
  1422.         p_sys->p_vout = p_vout;
  1423.         if( p_vout != NULL )
  1424.         {
  1425.             var_AddCallback( p_vout, "mouse-moved", EventMouse, p_demux );
  1426.             var_AddCallback( p_vout, "mouse-clicked", EventMouse, p_demux );
  1427.         }
  1428.     }
  1429.     (void) psz_var; (void) oldval;
  1430.     return VLC_SUCCESS;
  1431. }
  1433. /*****************************************************************************
  1434.  * ProbeDVD: very weak probing that avoids going too often into a dvdnav_open()
  1435.  *****************************************************************************/
  1436. static int ProbeDVD( demux_t *p_demux, char *psz_name )
  1437. {
  1438.     (void)p_demux;
  1439. #ifdef HAVE_SYS_STAT_H
  1440.     struct stat stat_info;
  1441.     uint8_t pi_anchor[2];
  1442.     int i_fd, i_ret;
  1444.     if( !*psz_name )
  1445.     {
  1446.         /* Triggers libdvdcss autodetection */
  1447.         return VLC_SUCCESS;
  1448.     }
  1450.     if( !strcmp( psz_name, "-" ) ) /* stdin -> file access */
  1451.         return VLC_EGENERIC;
  1453.     if( (i_fd = utf8_open( psz_name, O_RDONLY |O_NONBLOCK, 0666 )) == -1 )
  1454.     {
  1455.         return VLC_SUCCESS; /* Let dvdnav_open() do the probing */
  1456.     }
  1458.     if( fstat( i_fd, &stat_info ) || !S_ISREG( stat_info.st_mode ) )
  1459.     {
  1460.         close( i_fd );
  1462.         if( S_ISFIFO( stat_info.st_mode ) )
  1463.             return VLC_EGENERIC;
  1464.         return VLC_SUCCESS; /* Let dvdnav_open() do the probing */
  1465.     }
  1467.     /* Try to find the anchor (2 bytes at LBA 256) */
  1468.     i_ret = VLC_EGENERIC;
  1469.     if( lseek( i_fd, 256 * DVD_VIDEO_LB_LEN, SEEK_SET ) != -1
  1470.      && read( i_fd, pi_anchor, 2 ) == 2
  1471.      && GetWLE( pi_anchor ) == 2 )
  1472.         i_ret = VLC_SUCCESS; /* Found a potential anchor */
  1474.     close( i_fd );
  1476.     return i_ret;
  1477. #else
  1479.     return VLC_SUCCESS;
  1480. #endif
  1481. }