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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 查看源码
es_out.c
资源名称：vlc-0.8.1.tar.gz　[点击查看]
上传用户：riyaled888
上传日期：2009-03-27
资源大小：7338k
文件大小：33k
源码类别：

多媒体

开发平台：

MultiPlatform

es_out.c：源码内容
  2. /*****************************************************************************
  3.  * es_out.c: Es Out handler for input.
  4.  *****************************************************************************
  5.  * Copyright (C) 2003-2004 VideoLAN
  6.  * $Id: es_out.c 9139 2004-11-04 21:05:57Z hartman $
  7.  *
  8.  * Authors: Laurent Aimar <fenrir@via.ecp.fr>
  9.  *
  10.  * This program is free software; you can redistribute it and/or modify
  11.  * it under the terms of the GNU General Public License as published by
  12.  * the Free Software Foundation; either version 2 of the License, or
  13.  * (at your option) any later version.
  14.  *
  15.  * This program is distributed in the hope that it will be useful,
  16.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18.  * GNU General Public License for more details.
  19.  *
  20.  * You should have received a copy of the GNU General Public License
  21.  * along with this program; if not, write to the Free Software
  22.  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
  23.  *****************************************************************************/
  25. /*****************************************************************************
  26.  * Preamble
  27.  *****************************************************************************/
  28. #include <stdlib.h>
  30. #include <vlc/vlc.h>
  31. #include <vlc/input.h>
  32. #include <vlc/decoder.h>
  34. #include "input_internal.h"
  36. #include "vlc_playlist.h"
  37. #include "iso_lang.h"
  39. /*****************************************************************************
  40.  * Local prototypes
  41.  *****************************************************************************/
  42. typedef struct
  43. {
  44.     /* Program ID */
  45.     int i_id;
  47.     /* Number of es for this pgrm */
  48.     int i_es;
  50.     vlc_bool_t b_selected;
  52.     /* Clock for this program */
  53.     input_clock_t clock;
  55. } es_out_pgrm_t;
  57. struct es_out_id_t
  58. {
  59.     /* ES ID */
  60.     int       i_id;
  61.     es_out_pgrm_t *p_pgrm;
  63.     /* Channel in the track type */
  64.     int         i_channel;
  65.     es_format_t fmt;
  66.     char        *psz_language;
  67.     decoder_t   *p_dec;
  68. };
  70. struct es_out_sys_t
  71. {
  72.     input_thread_t *p_input;
  74.     /* all programs */
  75.     int           i_pgrm;
  76.     es_out_pgrm_t **pgrm;
  77.     es_out_pgrm_t **pp_selected_pgrm; /* --programs */
  78.     es_out_pgrm_t *p_pgrm;  /* Master program */
  80.     /* all es */
  81.     int         i_id;
  82.     int         i_es;
  83.     es_out_id_t **es;
  85.     /* mode gestion */
  86.     vlc_bool_t  b_active;
  87.     int         i_mode;
  89.     /* es count */
  90.     int         i_audio;
  91.     int         i_video;
  92.     int         i_sub;
  94.     /* es to select */
  95.     int         i_audio_last;
  96.     int         i_sub_last;
  98.     /* current main es */
  99.     es_out_id_t *p_es_audio;
  100.     es_out_id_t *p_es_video;
  101.     es_out_id_t *p_es_sub;
  103.     /* delay */
  104.     int64_t i_audio_delay;
  105.     int64_t i_spu_delay;
  106. };
  108. static es_out_id_t *EsOutAdd    ( es_out_t *, es_format_t * );
  109. static int          EsOutSend   ( es_out_t *, es_out_id_t *, block_t * );
  110. static void         EsOutDel    ( es_out_t *, es_out_id_t * );
  111. static void         EsOutSelect( es_out_t *out, es_out_id_t *es, vlc_bool_t b_force );
  112. static int          EsOutControl( es_out_t *, int i_query, va_list );
  114. static void         EsOutAddInfo( es_out_t *, es_out_id_t *es );
  116. static void EsSelect( es_out_t *out, es_out_id_t *es );
  117. static void EsUnselect( es_out_t *out, es_out_id_t *es, vlc_bool_t b_update );
  118. static char *LanguageGetName( const char *psz_code );
  120. /*****************************************************************************
  121.  * input_EsOutNew:
  122.  *****************************************************************************/
  123. es_out_t *input_EsOutNew( input_thread_t *p_input )
  124. {
  125.     es_out_t     *out = malloc( sizeof( es_out_t ) );
  126.     es_out_sys_t *p_sys = malloc( sizeof( es_out_sys_t ) );
  127.     vlc_value_t  val;
  129.     out->pf_add     = EsOutAdd;
  130.     out->pf_send    = EsOutSend;
  131.     out->pf_del     = EsOutDel;
  132.     out->pf_control = EsOutControl;
  133.     out->p_sys      = p_sys;
  135.     p_sys->p_input = p_input;
  137.     p_sys->b_active = VLC_FALSE;
  138.     p_sys->i_mode   = ES_OUT_MODE_AUTO;
  141.     p_sys->i_pgrm   = 0;
  142.     p_sys->pgrm     = NULL;
  143.     p_sys->p_pgrm   = NULL;
  145.     p_sys->i_id    = 0;
  146.     p_sys->i_es    = 0;
  147.     p_sys->es      = NULL;
  149.     p_sys->i_audio = 0;
  150.     p_sys->i_video = 0;
  151.     p_sys->i_sub   = 0;
  153.     var_Get( p_input, "audio-channel", &val );
  154.     p_sys->i_audio_last = val.i_int;
  156.     var_Get( p_input, "spu-channel", &val );
  157.     p_sys->i_sub_last = val.i_int;
  159.     p_sys->p_es_audio = NULL;
  160.     p_sys->p_es_video = NULL;
  161.     p_sys->p_es_sub   = NULL;
  163.     p_sys->i_audio_delay= 0;
  164.     p_sys->i_spu_delay  = 0;
  166.     return out;
  167. }
  169. /*****************************************************************************
  170.  * input_EsOutDelete:
  171.  *****************************************************************************/
  172. void input_EsOutDelete( es_out_t *out )
  173. {
  174.     es_out_sys_t *p_sys = out->p_sys;
  175.     int i;
  177.     for( i = 0; i < p_sys->i_es; i++ )
  178.     {
  179.         if( p_sys->es[i]->p_dec )
  180.         {
  181.             input_DecoderDelete( p_sys->es[i]->p_dec );
  182.         }
  183.         if( p_sys->es[i]->psz_language )
  184.             free( p_sys->es[i]->psz_language );
  185.         es_format_Clean( &p_sys->es[i]->fmt );
  187.         free( p_sys->es[i] );
  188.     }
  189.     if( p_sys->es )
  190.         free( p_sys->es );
  192.     for( i = 0; i < p_sys->i_pgrm; i++ )
  193.     {
  194.         free( p_sys->pgrm[i] );
  195.     }
  196.     if( p_sys->pgrm )
  197.         free( p_sys->pgrm );
  199.     free( p_sys );
  200.     free( out );
  201. }
  203. es_out_id_t *input_EsOutGetFromID( es_out_t *out, int i_id )
  204. {
  205.     int i;
  206.     if( i_id < 0 )
  207.     {
  208.         /* Special HACK, -i_id is tha cat of the stream */
  209.         return (es_out_id_t*)((uint8_t*)NULL-i_id);
  210.     }
  212.     for( i = 0; i < out->p_sys->i_es; i++ )
  213.     {
  214.         if( out->p_sys->es[i]->i_id == i_id )
  215.             return out->p_sys->es[i];
  216.     }
  217.     return NULL;
  218. }
  220. void input_EsOutDiscontinuity( es_out_t *out, vlc_bool_t b_audio )
  221. {
  222.     es_out_sys_t      *p_sys = out->p_sys;
  223.     int i;
  225.     for( i = 0; i < p_sys->i_es; i++ )
  226.     {
  227.         es_out_id_t *es = p_sys->es[i];
  229.         /* Send a dummy block to let decoder know that
  230.          * there is a discontinuity */
  231.         if( es->p_dec && ( !b_audio || es->fmt.i_cat == AUDIO_ES ) )
  232.         {
  233.             input_DecoderDiscontinuity( es->p_dec );
  234.         }
  235.     }
  236. }
  238. void input_EsOutSetDelay( es_out_t *out, int i_cat, int64_t i_delay )
  239. {
  240.     es_out_sys_t *p_sys = out->p_sys;
  242.     if( i_cat == AUDIO_ES )
  243.         p_sys->i_audio_delay = i_delay;
  244.     else if( i_cat == SPU_ES )
  245.         p_sys->i_spu_delay = i_delay;
  246. }
  248. vlc_bool_t input_EsOutDecodersEmpty( es_out_t *out )
  249. {
  250.     es_out_sys_t      *p_sys = out->p_sys;
  251.     int i;
  253.     for( i = 0; i < p_sys->i_es; i++ )
  254.     {
  255.         es_out_id_t *es = p_sys->es[i];
  257.         if( es->p_dec && !input_DecoderEmpty( es->p_dec ) )
  258.             return VLC_FALSE;
  259.     }
  260.     return VLC_TRUE;
  261. }
  263. /*****************************************************************************
  264.  *
  265.  *****************************************************************************/
  266. static void EsOutESVarUpdate( es_out_t *out, es_out_id_t *es,
  267.                               vlc_bool_t b_delete )
  268. {
  269.     es_out_sys_t      *p_sys = out->p_sys;
  270.     input_thread_t    *p_input = p_sys->p_input;
  271.     vlc_value_t       val, text;
  273.     char *psz_var;
  275.     if( es->fmt.i_cat == AUDIO_ES )
  276.         psz_var = "audio-es";
  277.     else if( es->fmt.i_cat == VIDEO_ES )
  278.         psz_var = "video-es";
  279.     else if( es->fmt.i_cat == SPU_ES )
  280.         psz_var = "spu-es";
  281.     else
  282.         return;
  284.     if( b_delete )
  285.     {
  286.         val.i_int = es->i_id;
  287.         var_Change( p_input, psz_var, VLC_VAR_DELCHOICE, &val, NULL );
  288.         var_SetBool( p_sys->p_input, "intf-change", VLC_TRUE );
  289.         return;
  290.     }
  292.     /* Get the number of ES already added */
  293.     var_Change( p_input, psz_var, VLC_VAR_CHOICESCOUNT, &val, NULL );
  294.     if( val.i_int == 0 )
  295.     {
  296.         vlc_value_t val2;
  298.         /* First one, we need to add the "Disable" choice */
  299.         val2.i_int = -1; text.psz_string = _("Disable");
  300.         var_Change( p_input, psz_var, VLC_VAR_ADDCHOICE, &val2, &text );
  301.         val.i_int++;
  302.     }
  304.     /* Take care of the ES description */
  305.     if( es->fmt.psz_description && *es->fmt.psz_description )
  306.     {
  307.         if( es->psz_language && *es->psz_language )
  308. {
  309.     text.psz_string = malloc( strlen( es->fmt.psz_description) + strlen( es->psz_language ) + 10 );
  310.     sprintf( text.psz_string, "%s - [%s]", es->fmt.psz_description, es->psz_language );
  311. }
  312. else text.psz_string = strdup( es->fmt.psz_description );
  313.     }
  314.     else
  315.     {
  316.         if( es->psz_language && *es->psz_language )
  317.         {
  318.             char *temp;
  319.             text.psz_string = malloc( strlen( _("Track %i") )+ strlen( es->psz_language ) + 30 );
  320.             asprintf( &temp,  _("Track %i"), val.i_int );
  321.             sprintf( text.psz_string, "%s - [%s]", temp, es->psz_language );
  322.             free( temp );
  323.         }
  324.         else
  325.         {
  326.             text.psz_string = malloc( strlen( _("Track %i") ) + 20 );
  327.             sprintf( text.psz_string, _("Track %i"), val.i_int );
  328.         }
  329.     }
  331.     val.i_int = es->i_id;
  332.     var_Change( p_input, psz_var, VLC_VAR_ADDCHOICE, &val, &text );
  334.     free( text.psz_string );
  336.     var_SetBool( p_sys->p_input, "intf-change", VLC_TRUE );
  337. }
  339. /* EsOutProgramSelect:
  340.  *  Select a program and update the object variable
  341.  */
  342. static void EsOutProgramSelect( es_out_t *out, es_out_pgrm_t *p_pgrm )
  343. {
  344.     es_out_sys_t      *p_sys = out->p_sys;
  345.     input_thread_t    *p_input = p_sys->p_input;
  346.     vlc_value_t       val;
  347.     int               i;
  349.     if( p_sys->p_pgrm == p_pgrm )
  350.         return; /* Nothing to do */
  352.     if( p_sys->p_pgrm )
  353.     {
  354.         es_out_pgrm_t *old = p_sys->p_pgrm;
  355.         msg_Dbg( p_input, "Unselecting program id=%d", old->i_id );
  357.         for( i = 0; i < p_sys->i_es; i++ )
  358.         {
  359.             if( p_sys->es[i]->p_pgrm == old && p_sys->es[i]->p_dec &&
  360.                 p_sys->i_mode != ES_OUT_MODE_ALL )
  361.                 EsUnselect( out, p_sys->es[i], VLC_TRUE );
  362.         }
  363.     }
  365.     msg_Dbg( p_input, "Selecting program id=%d", p_pgrm->i_id );
  367.     /* Mark it selected */
  368.     p_pgrm->b_selected = VLC_TRUE;
  370.     /* Switch master stream */
  371.     if( p_sys->p_pgrm && p_sys->p_pgrm->clock.b_master )
  372.     {
  373.         p_sys->p_pgrm->clock.b_master = VLC_FALSE;
  374.     }
  375.     p_pgrm->clock.b_master = VLC_TRUE;
  376.     p_sys->p_pgrm = p_pgrm;
  378.     /* Update "program" */
  379.     val.i_int = p_pgrm->i_id;
  380.     var_Change( p_input, "program", VLC_VAR_SETVALUE, &val, NULL );
  382.     /* Update "es-*" */
  383.     var_Change( p_input, "audio-es", VLC_VAR_CLEARCHOICES, NULL, NULL );
  384.     var_Change( p_input, "video-es", VLC_VAR_CLEARCHOICES, NULL, NULL );
  385.     var_Change( p_input, "spu-es",   VLC_VAR_CLEARCHOICES, NULL, NULL );
  386.     for( i = 0; i < p_sys->i_es; i++ )
  387.     {
  388.         EsOutESVarUpdate( out, p_sys->es[i], VLC_FALSE );
  389.         EsOutSelect( out, p_sys->es[i], VLC_FALSE );
  390.     }
  392.     var_SetBool( p_sys->p_input, "intf-change", VLC_TRUE );
  393. }
  395. /* EsOutAddProgram:
  396.  *  Add a program
  397.  */
  398. static es_out_pgrm_t *EsOutProgramAdd( es_out_t *out, int i_group )
  399. {
  400.     es_out_sys_t      *p_sys = out->p_sys;
  401.     input_thread_t    *p_input = p_sys->p_input;
  402.     vlc_value_t       val;
  404.     es_out_pgrm_t *p_pgrm = malloc( sizeof( es_out_pgrm_t ) );
  406.     /* Init */
  407.     p_pgrm->i_id = i_group;
  408.     p_pgrm->i_es = 0;
  409.     p_pgrm->b_selected = VLC_FALSE;
  410.     input_ClockInit( &p_pgrm->clock, VLC_FALSE, p_input->input.i_cr_average );
  412.     /* Append it */
  413.     TAB_APPEND( p_sys->i_pgrm, p_sys->pgrm, p_pgrm );
  415.     /* Update "program" variable */
  416.     val.i_int = i_group;
  417.     var_Change( p_input, "program", VLC_VAR_ADDCHOICE, &val, NULL );
  419.     if( i_group == var_GetInteger( p_input, "program" ) )
  420.     {
  421.         EsOutProgramSelect( out, p_pgrm );
  422.     }
  423.     else
  424.     {
  425.         var_SetBool( p_sys->p_input, "intf-change", VLC_TRUE );
  426.     }
  427.     return p_pgrm;
  428. }
  430. /* EsOutAdd:
  431.  *  Add an es_out
  432.  */
  433. static es_out_id_t *EsOutAdd( es_out_t *out, es_format_t *fmt )
  434. {
  435.     es_out_sys_t      *p_sys = out->p_sys;
  436.     input_thread_t    *p_input = p_sys->p_input;
  438.     es_out_id_t       *es = malloc( sizeof( es_out_id_t ) );
  439.     es_out_pgrm_t     *p_pgrm = NULL;
  440.     int i;
  442.     if( fmt->i_group < 0 )
  443.     {
  444.         msg_Err( p_input, "invalid group number" );
  445.         return NULL;
  446.     }
  448.     /* Search the program */
  449.     for( i = 0; i < p_sys->i_pgrm; i++ )
  450.     {
  451.         if( fmt->i_group == p_sys->pgrm[i]->i_id )
  452.         {
  453.             p_pgrm = p_sys->pgrm[i];
  454.             break;
  455.         }
  456.     }
  457.     if( p_pgrm == NULL )
  458.     {
  459.         /* Create a new one */
  460.         p_pgrm = EsOutProgramAdd( out, fmt->i_group );
  461.     }
  463.     /* Increase ref count for program */
  464.     p_pgrm->i_es++;
  466.     /* Set up ES */
  467.     if( fmt->i_id < 0 )
  468.         fmt->i_id = out->p_sys->i_id;
  469.     es->i_id = fmt->i_id;
  470.     es->p_pgrm = p_pgrm;
  471.     es_format_Copy( &es->fmt, fmt );
  472.     switch( fmt->i_cat )
  473.     {
  474.     case AUDIO_ES:
  475.         es->i_channel = p_sys->i_audio;
  476.         break;
  478.     case VIDEO_ES:
  479.         es->i_channel = p_sys->i_video;
  480.         break;
  482.     case SPU_ES:
  483.         es->i_channel = p_sys->i_sub;
  484.         break;
  486.     default:
  487.         es->i_channel = 0;
  488.         break;
  489.     }
  490.     es->psz_language = LanguageGetName( fmt->psz_language ); /* remember so we only need to do it once */
  491.     es->p_dec = NULL;
  493.     if( es->p_pgrm == p_sys->p_pgrm )
  494.         EsOutESVarUpdate( out, es, VLC_FALSE );
  496.     /* Select it if needed */
  497.     EsOutSelect( out, es, VLC_FALSE );
  500.     TAB_APPEND( out->p_sys->i_es, out->p_sys->es, es );
  501.     p_sys->i_id++;  /* always incremented */
  502.     switch( fmt->i_cat )
  503.     {
  504.         case AUDIO_ES:
  505.             p_sys->i_audio++;
  506.             break;
  507.         case SPU_ES:
  508.             p_sys->i_sub++;
  509.             break;
  510.         case VIDEO_ES:
  511.             p_sys->i_video++;
  512.             break;
  513.     }
  515.     EsOutAddInfo( out, es );
  517.     return es;
  518. }
  520. static void EsSelect( es_out_t *out, es_out_id_t *es )
  521. {
  522.     es_out_sys_t   *p_sys = out->p_sys;
  523.     input_thread_t *p_input = p_sys->p_input;
  524.     vlc_value_t    val;
  525.     char           *psz_var;
  527.     if( es->p_dec )
  528.     {
  529.         msg_Warn( p_input, "ES 0x%x is already selected", es->i_id );
  530.         return;
  531.     }
  533.     if( es->fmt.i_cat == VIDEO_ES || es->fmt.i_cat == SPU_ES )
  534.     {
  535.         if( !var_GetBool( p_input, "video" ) ||
  536.             ( p_input->p_sout && !var_GetBool( p_input, "sout-video" ) ) )
  537.         {
  538.             msg_Dbg( p_input, "video is disabled, not selecting ES 0x%x",
  539.                      es->i_id );
  540.             return;
  541.         }
  542.     }
  543.     else if( es->fmt.i_cat == AUDIO_ES )
  544.     {
  545.         var_Get( p_input, "audio", &val );
  546.         if( !var_GetBool( p_input, "audio" ) ||
  547.             ( p_input->p_sout && !var_GetBool( p_input, "sout-audio" ) ) )
  548.         {
  549.             msg_Dbg( p_input, "audio is disabled, not selecting ES 0x%x",
  550.                      es->i_id );
  551.             return;
  552.         }
  553.     }
  555.     es->p_dec = input_DecoderNew( p_input, &es->fmt, VLC_FALSE );
  556.     if( es->p_dec == NULL || es->p_pgrm != p_sys->p_pgrm )
  557.         return;
  559.     if( es->fmt.i_cat == VIDEO_ES )
  560.         psz_var = "video-es";
  561.     else if( es->fmt.i_cat == AUDIO_ES )
  562.         psz_var = "audio-es";
  563.     else if( es->fmt.i_cat == SPU_ES )
  564.         psz_var = "spu-es";
  565.     else
  566.         return;
  568.     /* Mark it as selected */
  569.     val.i_int = es->i_id;
  570.     var_Change( p_input, psz_var, VLC_VAR_SETVALUE, &val, NULL );
  573.     var_SetBool( p_sys->p_input, "intf-change", VLC_TRUE );
  574. }
  576. static void EsUnselect( es_out_t *out, es_out_id_t *es, vlc_bool_t b_update )
  577. {
  578.     es_out_sys_t   *p_sys = out->p_sys;
  579.     input_thread_t *p_input = p_sys->p_input;
  580.     vlc_value_t    val;
  581.     char           *psz_var;
  583.     if( es->p_dec == NULL )
  584.     {
  585.         msg_Warn( p_input, "ES 0x%x is already unselected", es->i_id );
  586.         return;
  587.     }
  589.     input_DecoderDelete( es->p_dec );
  590.     es->p_dec = NULL;
  592.     if( !b_update )
  593.         return;
  595.     /* Update var */
  596.     if( es->p_dec == NULL )
  597.         return;
  598.     if( es->fmt.i_cat == VIDEO_ES )
  599.         psz_var = "video-es";
  600.     else if( es->fmt.i_cat == AUDIO_ES )
  601.         psz_var = "audio-es";
  602.     else if( es->fmt.i_cat == SPU_ES )
  603.         psz_var = "spu-es";
  604.     else
  605.         return;
  607.     /* Mark it as selected */
  608.     val.i_int = -1;
  609.     var_Change( p_input, psz_var, VLC_VAR_SETVALUE, &val, NULL );
  611.     var_SetBool( p_sys->p_input, "intf-change", VLC_TRUE );
  612. }
  614. /**
  615.  * Select an ES given the current mode
  616.  * XXX: you need to take a the lock before (stream.stream_lock)
  617.  *
  618.  * param out The es_out structure
  619.  * param es es_out_id structure
  620.  * param b_force ...
  621.  * return nothing
  622.  */
  623. static void EsOutSelect( es_out_t *out, es_out_id_t *es, vlc_bool_t b_force )
  624. {
  625.     es_out_sys_t      *p_sys = out->p_sys;
  627.     int i_cat = es->fmt.i_cat;
  629.     if( !p_sys->b_active ||
  630.         ( !b_force && es->fmt.i_priority < 0 ) )
  631.     {
  632.         return;
  633.     }
  635.     if( p_sys->i_mode == ES_OUT_MODE_ALL || b_force )
  636.     {
  637.         if( !es->p_dec )
  638.             EsSelect( out, es );
  639.     }
  640.     else if( p_sys->i_mode == ES_OUT_MODE_PARTIAL )
  641.     {
  642.         vlc_value_t val;
  643.         int i;
  644.         var_Get( p_sys->p_input, "programs", &val );
  645.         for ( i = 0; i < val.p_list->i_count; i++ )
  646.         {
  647.             if ( val.p_list->p_values[i].i_int == es->p_pgrm->i_id || b_force )
  648.             {
  649.                 if( !es->p_dec )
  650.                     EsSelect( out, es );
  651.                 break;
  652.             }
  653.         }
  654.         var_Change( p_sys->p_input, "programs", VLC_VAR_FREELIST, &val, NULL );
  655.     }
  656.     else if( p_sys->i_mode == ES_OUT_MODE_AUTO )
  657.     {
  658.         int i_wanted  = -1;
  660.         if( es->p_pgrm != p_sys->p_pgrm )
  661.             return;
  663.         if( i_cat == AUDIO_ES )
  664.         {
  665.             if( p_sys->p_es_audio &&
  666.                 p_sys->p_es_audio->fmt.i_priority >= es->fmt.i_priority )
  667.             {
  668.                 return;
  669.             }
  670.             i_wanted  = p_sys->i_audio_last >= 0 ?
  671.                             p_sys->i_audio_last : es->i_channel;
  672.         }
  673.         else if( i_cat == SPU_ES )
  674.         {
  675.             if( p_sys->p_es_sub &&
  676.                 p_sys->p_es_sub->fmt.i_priority >=
  677.                     es->fmt.i_priority )
  678.             {
  679.                 return;
  680.             }
  681.             i_wanted  = p_sys->i_sub_last;
  682.         }
  683.         else if( i_cat == VIDEO_ES )
  684.         {
  685.             i_wanted  = es->i_channel;
  686.         }
  688.         if( i_wanted == es->i_channel && es->p_dec == NULL )
  689.             EsSelect( out, es );
  690.     }
  692.     /* FIXME TODO handle priority here */
  693.     if( es->p_dec )
  694.     {
  695.         if( i_cat == AUDIO_ES )
  696.         {
  697.             if( p_sys->i_mode == ES_OUT_MODE_AUTO &&
  698.                 p_sys->p_es_audio &&
  699.                 p_sys->p_es_audio != es &&
  700.                 p_sys->p_es_audio->p_dec )
  701.             {
  702.                 EsUnselect( out, p_sys->p_es_audio, VLC_FALSE );
  703.             }
  704.             p_sys->p_es_audio = es;
  705.         }
  706.         else if( i_cat == SPU_ES )
  707.         {
  708.             if( p_sys->i_mode == ES_OUT_MODE_AUTO &&
  709.                 p_sys->p_es_sub &&
  710.                 p_sys->p_es_sub != es &&
  711.                 p_sys->p_es_sub->p_dec )
  712.             {
  713.                 EsUnselect( out, p_sys->p_es_sub, VLC_FALSE );
  714.             }
  715.             p_sys->p_es_sub = es;
  716.         }
  717.         else if( i_cat == VIDEO_ES )
  718.         {
  719.             p_sys->p_es_video = es;
  720.         }
  721.     }
  722. }
  724. /**
  725.  * Send a block for the given es_out
  726.  *
  727.  * param out the es_out to send from
  728.  * param es the es_out_id
  729.  * param p_block the data block to send
  730.  */
  731. static int EsOutSend( es_out_t *out, es_out_id_t *es, block_t *p_block )
  732. {
  733.     es_out_sys_t *p_sys = out->p_sys;
  734.     input_thread_t    *p_input = p_sys->p_input;
  735.     es_out_pgrm_t *p_pgrm = es->p_pgrm;
  736.     int64_t i_delay;
  738.     if( es->fmt.i_cat == AUDIO_ES )
  739.         i_delay = p_sys->i_audio_delay;
  740.     else if( es->fmt.i_cat == SPU_ES )
  741.         i_delay = p_sys->i_spu_delay;
  742.     else
  743.         i_delay = 0;
  745.     /* +11 -> avoid null value with non null dts/pts */
  746.     if( p_block->i_dts > 0 )
  747.     {
  748.         p_block->i_dts =
  749.             input_ClockGetTS( p_input, &p_pgrm->clock,
  750.                               ( p_block->i_dts + 11 ) * 9 / 100 ) + i_delay;
  751.     }
  752.     if( p_block->i_pts > 0 )
  753.     {
  754.         p_block->i_pts =
  755.             input_ClockGetTS( p_input, &p_pgrm->clock,
  756.                               ( p_block->i_pts + 11 ) * 9 / 100 ) + i_delay;
  757.     }
  759.     p_block->i_rate = p_input->i_rate;
  761.     /* TODO handle mute */
  762.     if( es->p_dec && ( es->fmt.i_cat != AUDIO_ES ||
  763.         p_input->i_rate == INPUT_RATE_DEFAULT ) )
  764.     {
  765.         input_DecoderDecode( es->p_dec, p_block );
  766.     }
  767.     else
  768.     {
  769.         block_Release( p_block );
  770.     }
  772.     return VLC_SUCCESS;
  773. }
  775. /*****************************************************************************
  776.  * EsOutDel:
  777.  *****************************************************************************/
  778. static void EsOutDel( es_out_t *out, es_out_id_t *es )
  779. {
  780.     es_out_sys_t *p_sys = out->p_sys;
  782.     /* We don't try to reselect */
  783.     if( es->p_dec )
  784.         EsUnselect( out, es, es->p_pgrm == p_sys->p_pgrm );
  786.     if( es->p_pgrm == p_sys->p_pgrm )
  787.         EsOutESVarUpdate( out, es, VLC_TRUE );
  789.     TAB_REMOVE( p_sys->i_es, p_sys->es, es );
  791.     es->p_pgrm->i_es--;
  792.     if( es->p_pgrm->i_es == 0 )
  793.     {
  794.         msg_Warn( p_sys->p_input, "Program doesn't contain anymore ES, "
  795.                   "TODO cleaning ?" );
  796.     }
  798.     if( p_sys->p_es_audio == es ) p_sys->p_es_audio = NULL;
  799.     if( p_sys->p_es_video == es ) p_sys->p_es_video = NULL;
  800.     if( p_sys->p_es_sub   == es ) p_sys->p_es_sub   = NULL;
  802.     switch( es->fmt.i_cat )
  803.     {
  804.         case AUDIO_ES:
  805.             p_sys->i_audio--;
  806.             break;
  807.         case SPU_ES:
  808.             p_sys->i_sub--;
  809.             break;
  810.         case VIDEO_ES:
  811.             p_sys->i_video--;
  812.             break;
  813.     }
  815.     if( es->psz_language )
  816.         free( es->psz_language );
  818.     es_format_Clean( &es->fmt );
  820.     free( es );
  821. }
  823. /**
  824.  * Control query handler
  825.  *
  826.  * param out the es_out to control
  827.  * param i_query A es_out query as defined in include/ninput.h
  828.  * param args a variable list of arguments for the query
  829.  * return VLC_SUCCESS or an error code
  830.  */
  831. static int EsOutControl( es_out_t *out, int i_query, va_list args )
  832. {
  833.     es_out_sys_t *p_sys = out->p_sys;
  834.     vlc_bool_t  b, *pb;
  835.     int         i, *pi;
  837.     es_out_id_t *es;
  839.     switch( i_query )
  840.     {
  841.         case ES_OUT_SET_ES_STATE:
  842.             es = (es_out_id_t*) va_arg( args, es_out_id_t * );
  843.             b = (vlc_bool_t) va_arg( args, vlc_bool_t );
  844.             if( b && es->p_dec == NULL )
  845.             {
  846.                 EsSelect( out, es );
  847.                 return es->p_dec ? VLC_SUCCESS : VLC_EGENERIC;
  848.             }
  849.             else if( !b && es->p_dec )
  850.             {
  851.                 EsUnselect( out, es, es->p_pgrm == p_sys->p_pgrm );
  852.                 return VLC_SUCCESS;
  853.             }
  854.             return VLC_SUCCESS;
  856.         case ES_OUT_GET_ES_STATE:
  857.             es = (es_out_id_t*) va_arg( args, es_out_id_t * );
  858.             pb = (vlc_bool_t*) va_arg( args, vlc_bool_t * );
  860.             *pb = es->p_dec ? VLC_TRUE : VLC_FALSE;
  861.             return VLC_SUCCESS;
  863.         case ES_OUT_SET_ACTIVE:
  864.         {
  865.             b = (vlc_bool_t) va_arg( args, vlc_bool_t );
  866.             p_sys->b_active = b;
  867.             /* Needed ? */
  868.             if( b )
  869.                 var_SetBool( p_sys->p_input, "intf-change", VLC_TRUE );
  870.             return VLC_SUCCESS;
  871.         }
  873.         case ES_OUT_GET_ACTIVE:
  874.             pb = (vlc_bool_t*) va_arg( args, vlc_bool_t * );
  875.             *pb = p_sys->b_active;
  876.             return VLC_SUCCESS;
  878.         case ES_OUT_SET_MODE:
  879.             i = (int) va_arg( args, int );
  880.             if( i == ES_OUT_MODE_NONE || i == ES_OUT_MODE_ALL ||
  881.                 i == ES_OUT_MODE_AUTO || i == ES_OUT_MODE_PARTIAL )
  882.             {
  883.                 p_sys->i_mode = i;
  885.                 /* Reapply policy mode */
  886.                 for( i = 0; i < p_sys->i_es; i++ )
  887.                 {
  888.                     if( p_sys->es[i]->p_dec )
  889.                     {
  890.                         EsUnselect( out, p_sys->es[i],
  891.                                     p_sys->es[i]->p_pgrm == p_sys->p_pgrm );
  892.                     }
  893.                 }
  894.                 for( i = 0; i < p_sys->i_es; i++ )
  895.                 {
  896.                     EsOutSelect( out, p_sys->es[i], VLC_FALSE );
  897.                 }
  898.                 return VLC_SUCCESS;
  899.             }
  900.             return VLC_EGENERIC;
  902.         case ES_OUT_GET_MODE:
  903.             pi = (int*) va_arg( args, int* );
  904.             *pi = p_sys->i_mode;
  905.             return VLC_SUCCESS;
  907.         case ES_OUT_SET_ES:
  908.             es = (es_out_id_t*) va_arg( args, es_out_id_t * );
  909.             /* Special case NULL, NULL+i_cat */
  910.             if( es == NULL )
  911.             {
  912.                 for( i = 0; i < p_sys->i_es; i++ )
  913.                 {
  914.                     if( p_sys->es[i]->p_dec )
  915.                         EsUnselect( out, p_sys->es[i],
  916.                                     p_sys->es[i]->p_pgrm == p_sys->p_pgrm );
  917.                 }
  918.             }
  919.             else if( es == (es_out_id_t*)((uint8_t*)NULL+AUDIO_ES) )
  920.             {
  921.                 for( i = 0; i < p_sys->i_es; i++ )
  922.                 {
  923.                     if( p_sys->es[i]->p_dec &&
  924.                         p_sys->es[i]->fmt.i_cat == AUDIO_ES )
  925.                         EsUnselect( out, p_sys->es[i],
  926.                                     p_sys->es[i]->p_pgrm == p_sys->p_pgrm );
  927.                 }
  928.             }
  929.             else if( es == (es_out_id_t*)((uint8_t*)NULL+VIDEO_ES) )
  930.             {
  931.                 for( i = 0; i < p_sys->i_es; i++ )
  932.                 {
  933.                     if( p_sys->es[i]->p_dec &&
  934.                         p_sys->es[i]->fmt.i_cat == VIDEO_ES )
  935.                         EsUnselect( out, p_sys->es[i],
  936.                                     p_sys->es[i]->p_pgrm == p_sys->p_pgrm );
  937.                 }
  938.             }
  939.             else if( es == (es_out_id_t*)((uint8_t*)NULL+SPU_ES) )
  940.             {
  941.                 for( i = 0; i < p_sys->i_es; i++ )
  942.                 {
  943.                     if( p_sys->es[i]->p_dec &&
  944.                         p_sys->es[i]->fmt.i_cat == SPU_ES )
  945.                         EsUnselect( out, p_sys->es[i],
  946.                                     p_sys->es[i]->p_pgrm == p_sys->p_pgrm );
  947.                 }
  948.             }
  949.             else
  950.             {
  951.                 for( i = 0; i < p_sys->i_es; i++ )
  952.                 {
  953.                     if( es == p_sys->es[i] )
  954.                     {
  955.                         EsOutSelect( out, es, VLC_TRUE );
  956.                         break;
  957.                     }
  958.                 }
  959.             }
  960.             return VLC_SUCCESS;
  962.         case ES_OUT_SET_PCR:
  963.         case ES_OUT_SET_GROUP_PCR:
  964.         {
  965.             es_out_pgrm_t *p_pgrm = NULL;
  966.             int            i_group = 0;
  967.             int64_t        i_pcr;
  969.             if( i_query == ES_OUT_SET_PCR )
  970.             {
  971.                 p_pgrm = p_sys->p_pgrm;
  972.             }
  973.             else
  974.             {
  975.                 int i;
  976.                 i_group = (int)va_arg( args, int );
  977.                 for( i = 0; i < p_sys->i_pgrm; i++ )
  978.                 {
  979.                     if( p_sys->pgrm[i]->i_id == i_group )
  980.                     {
  981.                         p_pgrm = p_sys->pgrm[i];
  982.                         break;
  983.                     }
  984.                 }
  985.             }
  986.             if( p_pgrm == NULL )
  987.                 p_pgrm = EsOutProgramAdd( out, i_group );   /* Create it */
  989.             i_pcr = (int64_t)va_arg( args, int64_t );
  990.             /* search program */
  991.             /* 11 is a vodoo trick to avoid non_pcr*9/100 to be null */
  992.             input_ClockSetPCR( p_sys->p_input, &p_pgrm->clock,
  993.                                (i_pcr + 11 ) * 9 / 100);
  994.             return VLC_SUCCESS;
  995.         }
  997.         case ES_OUT_RESET_PCR:
  998.             for( i = 0; i < p_sys->i_pgrm; i++ )
  999.             {
  1000.                 p_sys->pgrm[i]->clock.i_synchro_state =  SYNCHRO_REINIT;
  1001.                 p_sys->pgrm[i]->clock.last_pts = 0;
  1002.             }
  1003.             return VLC_SUCCESS;
  1005.         case ES_OUT_GET_TS:
  1006.             if( p_sys->p_pgrm )
  1007.             {
  1008.                 int64_t i_ts = (int64_t)va_arg( args, int64_t );
  1009.                 int64_t *pi_ts = (int64_t *)va_arg( args, int64_t * );
  1010.                 *pi_ts = input_ClockGetTS( p_sys->p_input,
  1011.                                            &p_sys->p_pgrm->clock,
  1012.                                            ( i_ts + 11 ) * 9 / 100 );
  1013.                 return VLC_SUCCESS;
  1014.             }
  1015.             return VLC_EGENERIC;
  1017.         case ES_OUT_GET_GROUP:
  1018.             pi = (int*) va_arg( args, int* );
  1019.             if( p_sys->p_pgrm )
  1020.                 *pi = p_sys->p_pgrm->i_id;
  1021.             else
  1022.                 *pi = -1;    /* FIXME */
  1023.             return VLC_SUCCESS;
  1025.         case ES_OUT_SET_GROUP:
  1026.         {
  1027.             int j;
  1028.             i = (int) va_arg( args, int );
  1029.             for( j = 0; j < p_sys->i_pgrm; j++ )
  1030.             {
  1031.                 es_out_pgrm_t *p_pgrm = p_sys->pgrm[j];
  1032.                 if( p_pgrm->i_id == i )
  1033.                 {
  1034.                     EsOutProgramSelect( out, p_pgrm );
  1035.                     return VLC_SUCCESS;
  1036.                 }
  1037.             }
  1038.             return VLC_EGENERIC;
  1039.         }
  1041.         case ES_OUT_SET_FMT:
  1042.         {
  1043.             /* This ain't pretty but is need by some demuxers (eg. Ogg )
  1044.              * to update the p_extra data */
  1045.             es_format_t *p_fmt;
  1046.             es = (es_out_id_t*) va_arg( args, es_out_id_t * );
  1047.             p_fmt = (es_format_t*) va_arg( args, es_format_t * );
  1048.             if( es == NULL ) return VLC_EGENERIC;
  1050.             if( p_fmt->i_extra )
  1051.             {
  1052.                 es->fmt.i_extra = p_fmt->i_extra;
  1053.                 es->fmt.p_extra = realloc( es->fmt.p_extra, p_fmt->i_extra );
  1054.                 memcpy( es->fmt.p_extra, p_fmt->p_extra, p_fmt->i_extra );
  1056.                 if( !es->p_dec ) return VLC_SUCCESS;
  1058.                 es->p_dec->fmt_in.i_extra = p_fmt->i_extra;
  1059.                 es->p_dec->fmt_in.p_extra =
  1060.                     realloc( es->p_dec->fmt_in.p_extra, p_fmt->i_extra );
  1061.                 memcpy( es->p_dec->fmt_in.p_extra,
  1062.                         p_fmt->p_extra, p_fmt->i_extra );
  1063.             }
  1065.             return VLC_SUCCESS;
  1066.         }
  1068.         default:
  1069.             msg_Err( p_sys->p_input, "unknown query in es_out_Control" );
  1070.             return VLC_EGENERIC;
  1071.     }
  1072. }
  1074. /****************************************************************************
  1075.  * LanguageGetName: try to expend iso639 into plain name
  1076.  ****************************************************************************/
  1077. static char *LanguageGetName( const char *psz_code )
  1078. {
  1079.     const iso639_lang_t *pl;
  1081.     if( psz_code == NULL )
  1082.     {
  1083.         return strdup( "" );
  1084.     }
  1086.     if( strlen( psz_code ) == 2 )
  1087.     {
  1088.         pl = GetLang_1( psz_code );
  1089.     }
  1090.     else if( strlen( psz_code ) == 3 )
  1091.     {
  1092.         pl = GetLang_2B( psz_code );
  1093.         if( !strcmp( pl->psz_iso639_1, "??" ) )
  1094.         {
  1095.             pl = GetLang_2T( psz_code );
  1096.         }
  1097.     }
  1098.     else
  1099.     {
  1100.         return strdup( psz_code );
  1101.     }
  1103.     if( !strcmp( pl->psz_iso639_1, "??" ) )
  1104.     {
  1105.        return strdup( psz_code );
  1106.     }
  1107.     else
  1108.     {
  1109.         if( *pl->psz_native_name )
  1110.         {
  1111.             return strdup( pl->psz_native_name );
  1112.         }
  1113.         return strdup( pl->psz_eng_name );
  1114.     }
  1115. }
  1117. /****************************************************************************
  1118.  * EsOutAddInfo:
  1119.  * - add meta info to the playlist item
  1120.  ****************************************************************************/
  1121. static void EsOutAddInfo( es_out_t *out, es_out_id_t *es )
  1122. {
  1123.     es_out_sys_t   *p_sys = out->p_sys;
  1124.     input_thread_t *p_input = p_sys->p_input;
  1125.     es_format_t    *fmt = &es->fmt;
  1126.     char           *psz_cat;
  1128.     /* Add stream info */
  1129.     asprintf( &psz_cat, _("Stream %d"), out->p_sys->i_id - 1 );
  1131.     input_Control( p_input, INPUT_ADD_INFO, psz_cat, _("Codec"),
  1132.                    "%.4s", (char*)&fmt->i_codec );
  1134.     input_Control( p_input, INPUT_ADD_INFO, psz_cat, _("Language"),
  1135.                    "%s", es->psz_language );
  1137.     /* Add information */
  1138.     switch( fmt->i_cat )
  1139.     {
  1140.     case AUDIO_ES:
  1141.         input_Control( p_input, INPUT_ADD_INFO, psz_cat,
  1142.                        _("Type"), _("Audio") );
  1144.         if( fmt->audio.i_channels > 0 )
  1145.             input_Control( p_input, INPUT_ADD_INFO, psz_cat, _("Channels"),
  1146.                            "%d", fmt->audio.i_channels );
  1148.         if( fmt->audio.i_rate > 0 )
  1149.             input_Control( p_input, INPUT_ADD_INFO, psz_cat, _("Sample rate"),
  1150.                            _("%d Hz"), fmt->audio.i_rate );
  1152.         if( fmt->audio.i_bitspersample > 0 )
  1153.             input_Control( p_input, INPUT_ADD_INFO, psz_cat,
  1154.                            _("Bits per sample"), "%d",
  1155.                            fmt->audio.i_bitspersample );
  1157.         if( fmt->i_bitrate > 0 )
  1158.             input_Control( p_input, INPUT_ADD_INFO, psz_cat, _("Bitrate"),
  1159.                            _("%d kb/s"), fmt->i_bitrate / 1000 );
  1160.         break;
  1162.     case VIDEO_ES:
  1163.         input_Control( p_input, INPUT_ADD_INFO, psz_cat,
  1164.                        _("Type"), _("Video") );
  1166.         if( fmt->video.i_width > 0 && fmt->video.i_height > 0 )
  1167.             input_Control( p_input, INPUT_ADD_INFO, psz_cat,
  1168.                            _("Resolution"), "%dx%d",
  1169.                            fmt->video.i_width, fmt->video.i_height );
  1171.         if( fmt->video.i_visible_width > 0 &&
  1172.             fmt->video.i_visible_height > 0 )
  1173.             input_Control( p_input, INPUT_ADD_INFO, psz_cat,
  1174.                            _("Display resolution"), "%dx%d",
  1175.                            fmt->video.i_visible_width,
  1176.                            fmt->video.i_visible_height);
  1177.         break;
  1179.     case SPU_ES:
  1180.         input_Control( p_input, INPUT_ADD_INFO, psz_cat,
  1181.                        _("Type"), _("Subtitle") );
  1182.         break;
  1184.     default:
  1185.         break;
  1186.     }
  1188.     free( psz_cat );
  1189. }