git.sesse.net Git - vlc/blob - src/input/input_programs.c

   1 /*****************************************************************************
   2  * input_programs.c: es_descriptor_t, pgrm_descriptor_t management
   3  *****************************************************************************
   4  * Copyright (C) 1999, 2000 VideoLAN
   5  * $Id: input_programs.c,v 1.7 2000/12/20 22:23:23 reno Exp $
   6  *
   7  * Authors:
   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., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
  22  *****************************************************************************/
  23
  24 /*****************************************************************************
  25  * Preamble
  26  *****************************************************************************/
  27 #include "defs.h"
  28
  29 #include <stdlib.h>
  30
  31 #include "config.h"
  32 #include "common.h"
  33 #include "threads.h"
  34 #include "mtime.h"
  35 #include "debug.h"
  36
  37 #include "intf_msg.h"
  38
  39 #include "stream_control.h"
  40 #include "input_ext-intf.h"
  41 #include "input_ext-dec.h"
  42 #include "input.h"
  43
  44 #include "main.h"                                     /* --noaudio --novideo */
  45
  46 /*
  47  * NOTICE : all of these functions expect you to have taken the lock on
  48  * p_input->stream.lock
  49  */
  50
  51 /*****************************************************************************
  52  * input_InitStream: init the stream descriptor of the given input
  53  *****************************************************************************/
  54 void input_InitStream( input_thread_t * p_input, size_t i_data_len )
  55 {
  56     p_input->stream.i_stream_id = 0;
  57     p_input->stream.i_pgrm_number = 0;
  58     p_input->stream.pp_programs = NULL;
  59
  60     if( i_data_len )
  61     {
  62         p_input->stream.p_demux_data = malloc( i_data_len );
  63         memset( p_input->stream.p_demux_data, 0, i_data_len );
  64     }
  65 }
  66
  67 /*****************************************************************************
  68  * input_AddProgram: add and init a program descriptor
  69  *****************************************************************************
  70  * This program descriptor will be referenced in the given stream descriptor
  71  *****************************************************************************/
  72 pgrm_descriptor_t * input_AddProgram( input_thread_t * p_input,
  73                                       u16 i_pgrm_id, size_t i_data_len )
  74 {
  75     /* Where to add the pgrm */
  76     int i_pgrm_index = p_input->stream.i_pgrm_number;
  77
  78     intf_DbgMsg("Adding description for pgrm %d", i_pgrm_id);
  79
  80     /* Add an entry to the list of program associated with the stream */
  81     p_input->stream.i_pgrm_number++;
  82     p_input->stream.pp_programs = realloc( p_input->stream.pp_programs,
  83                                            p_input->stream.i_pgrm_number
  84                                             * sizeof(pgrm_descriptor_t *) );
  85
  86     /* Allocate the structure to store this description */
  87     p_input->stream.pp_programs[i_pgrm_index] =
  88                                         malloc( sizeof(pgrm_descriptor_t) );
  89
  90     /* Init this entry */
  91     p_input->stream.pp_programs[i_pgrm_index]->i_number = i_pgrm_id;
  92     p_input->stream.pp_programs[i_pgrm_index]->b_is_ok = 0;
  93     p_input->stream.pp_programs[i_pgrm_index]->i_version = 0;
  94
  95     p_input->stream.pp_programs[i_pgrm_index]->i_es_number = 0;
  96     p_input->stream.pp_programs[i_pgrm_index]->pp_es = NULL;
  97
  98     p_input->stream.pp_programs[i_pgrm_index]->delta_cr = 0;
  99     p_input->stream.pp_programs[i_pgrm_index]->delta_absolute = 0;
 100     p_input->stream.pp_programs[i_pgrm_index]->last_cr = 0;
 101     p_input->stream.pp_programs[i_pgrm_index]->c_average_count = 0;
 102     p_input->stream.pp_programs[i_pgrm_index]->i_synchro_state
 103                                                 = SYNCHRO_NOT_STARTED;
 104     p_input->stream.pp_programs[i_pgrm_index]->b_discontinuity = 0;
 105
 106     p_input->stream.pp_programs[i_pgrm_index]->p_vout
 107                                             = p_input->p_default_vout;
 108     p_input->stream.pp_programs[i_pgrm_index]->p_aout
 109                                             = p_input->p_default_aout;
 110
 111     if( i_data_len )
 112     {
 113         p_input->stream.pp_programs[i_pgrm_index]->p_demux_data =
 114             malloc( i_data_len );
 115         memset( p_input->stream.pp_programs[i_pgrm_index]->p_demux_data, 0,
 116                 i_data_len );
 117     }
 118
 119     return p_input->stream.pp_programs[i_pgrm_index];
 120 }
 121
 122 /*****************************************************************************
 123  * input_DelProgram: destroy a program descriptor
 124  *****************************************************************************
 125  * All ES descriptions referenced in the descriptor will be deleted.
 126  *****************************************************************************/
 127 void input_DelProgram( input_thread_t * p_input, u16 i_pgrm_id )
 128 {
 129     int i_index, i_pgrm_index = -1;
 130     pgrm_descriptor_t * p_pgrm = NULL;
 131
 132     intf_DbgMsg("Deleting description for pgrm %d", i_pgrm_id);
 133
 134     /* Find where this program is described */
 135     for( i_index = 0; i_index < p_input->stream.i_pgrm_number; i_index++ )
 136     {
 137         if( p_input->stream.pp_programs[i_index]->i_number == i_pgrm_id )
 138         {
 139             i_pgrm_index = i_index;
 140             p_pgrm = p_input->stream.pp_programs[ i_pgrm_index ];
 141             break;
 142         }
 143     }
 144
 145     /* Make sure that the pgrm exists */
 146     ASSERT(i_pgrm_index >= 0);
 147     ASSERT(p_pgrm);
 148
 149     /* Free the structures that describe the es that belongs to that program */
 150     for( i_index = 0; i_index < p_pgrm->i_es_number; i_index++ )
 151     {
 152         input_DelES( p_input, p_pgrm->pp_es[i_index]->i_id );
 153     }
 154
 155     /* Free the table of es descriptors */
 156     free( p_pgrm->pp_es );
 157
 158     /* Free the demux data */
 159     if( p_pgrm->p_demux_data != NULL )
 160     {
 161         free( p_pgrm->p_demux_data );
 162     }
 163
 164     /* Free the description of this stream */
 165     free( p_pgrm );
 166
 167     /* Remove this program from the stream's list of programs */
 168     p_input->stream.i_pgrm_number--;
 169     p_input->stream.pp_programs[i_pgrm_index] =
 170         p_input->stream.pp_programs[p_input->stream.i_pgrm_number];
 171     p_input->stream.pp_programs = realloc( p_input->stream.pp_programs,
 172                                            p_input->stream.i_pgrm_number
 173                                             * sizeof(pgrm_descriptor_t *) );
 174 }
 175
 176 /*****************************************************************************
 177  * input_AddES:
 178  *****************************************************************************
 179  * Reserve a slot in the table of ES descriptors for the ES and add it to the
 180  * list of ES of p_pgrm. If p_pgrm if NULL, then the ES is considered as stand
 181  * alone (PSI ?)
 182  *****************************************************************************/
 183 es_descriptor_t * input_AddES( input_thread_t * p_input,
 184                                pgrm_descriptor_t * p_pgrm, u16 i_es_id,
 185                                size_t i_data_len )
 186 {
 187     int i_index;
 188     es_descriptor_t * p_es = NULL;
 189
 190     intf_DbgMsg("Adding description for ES %d", i_es_id);
 191
 192     /* Find an empty slot to store the description of that es */
 193     for( i_index = 0; i_index < INPUT_MAX_ES &&
 194          p_input->p_es[i_index].i_id != EMPTY_ID; i_index++ );
 195
 196     if( i_index >= INPUT_MAX_ES )
 197     {
 198         /* No slot is empty */
 199         intf_ErrMsg("Stream carries too many ES for our decoder");
 200         input_DumpStream( p_input );
 201     }
 202     else
 203     {
 204         /* Reserve the slot for that ES */
 205         p_es = &p_input->p_es[i_index];
 206         p_es->i_id = i_es_id;
 207         intf_DbgMsg("Slot %d in p_es table assigned to ES %d",
 208                     i_index, i_es_id);
 209
 210         /* Init its values */
 211         p_es->b_discontinuity = 0;
 212         p_es->p_pes = NULL;
 213         p_es->p_decoder_fifo = NULL;
 214
 215         if( i_data_len )
 216         {
 217             p_es->p_demux_data = malloc( i_data_len );
 218             memset( p_es->p_demux_data, 0, i_data_len );
 219         }
 220
 221         /* Add this ES to the program definition if one is given */
 222         if( p_pgrm )
 223         {
 224             p_pgrm->i_es_number++;
 225             p_pgrm->pp_es = realloc( p_pgrm->pp_es,
 226                                      p_pgrm->i_es_number
 227                                       * sizeof(es_descriptor_t *) );
 228             p_pgrm->pp_es[p_pgrm->i_es_number - 1] = p_es;
 229             p_es->p_pgrm = p_pgrm;
 230         }
 231         else
 232         {
 233             p_es->p_pgrm = NULL;
 234         }
 235     }
 236
 237     return p_es;
 238 }
 239
 240 /*****************************************************************************
 241  * input_DelES:
 242  *****************************************************************************/
 243 void input_DelES( input_thread_t * p_input, u16 i_id )
 244 {
 245     int                     i_index;
 246     pgrm_descriptor_t *     p_pgrm = NULL;
 247     es_descriptor_t *       p_es = NULL;
 248
 249     /* Look for the description of the ES */
 250     for( i_index = 0; i_index < INPUT_MAX_ES; i_index++ )
 251     {
 252         if( p_input->p_es[i_index].i_id == i_id )
 253         {
 254             p_es = &p_input->p_es[i_index];
 255             p_pgrm = p_input->p_es[i_index].p_pgrm;
 256             break;
 257         }
 258     }
 259
 260     ASSERT( p_es );
 261
 262     /* Remove this ES from the description of the program if it is associated to
 263      * one */
 264     if( p_pgrm )
 265     {
 266         for( i_index = 0; ; i_index++ )
 267         {
 268             if( p_pgrm->pp_es[i_index]->i_id == i_id )
 269             {
 270                 p_pgrm->i_es_number--;
 271                 p_pgrm->pp_es[i_index] = p_pgrm->pp_es[p_pgrm->i_es_number];
 272                 p_pgrm->pp_es = realloc( p_pgrm->pp_es,
 273                                          p_pgrm->i_es_number
 274                                           * sizeof(es_descriptor_t *));
 275                 break;
 276             }
 277         }
 278     }
 279
 280     /* The table of stream descriptors is static, so don't free memory
 281      * but just mark the slot as unused */
 282     p_es->i_id = EMPTY_ID;
 283
 284     /* Free the demux data */
 285     if( p_es->p_demux_data != NULL )
 286     {
 287         free( p_es->p_demux_data );
 288     }
 289 }
 290
 291 #ifdef STATS
 292 /*****************************************************************************
 293  * input_DumpStream: dumps the contents of a stream descriptor
 294  *****************************************************************************/
 295 void input_DumpStream( input_thread_t * p_input )
 296 {
 297     int i, j;
 298 #define S   p_input->stream
 299     intf_Msg( "input info: Dumping stream ID 0x%x\n", S.i_stream_id );
 300     if( S.b_seekable )
 301         intf_Msg( "input info: seekable stream, position: %d/%d\n",
 302                   S.i_tell, S.i_size );
 303     else
 304         intf_Msg( "input info: %s\n", S.b_pace_control ? "pace controlled" :
 305                   "pace un-controlled" );
 306 #undef S
 307     for( i = 0; i < p_input->stream.i_pgrm_number; i++ )
 308     {
 309 #define P   p_input->stream.pp_programs[i]
 310         intf_Msg( "input info: Dumping program 0x%x, version %d (%s)\n",
 311                   P->i_number, P->i_version,
 312                   P->b_is_ok ? "complete" : "partial" );
 313         if( P->i_synchro_state == SYNCHRO_OK )
 314             intf_Msg( "input info: synchro absolute delta : %lld (jitter : %lld)\n",
 315                       P->delta_absolute, P->delta_cr );
 316 #undef P
 317         for( j = 0; j < p_input->stream.pp_programs[i]->i_es_number; j++ )
 318         {
 319 #define ES  p_input->stream.pp_programs[i]->pp_es[j]
 320             intf_Msg( "input info: ES 0x%x, stream 0x%x, type 0x%x, %s\n",
 321                       ES->i_id, ES->i_stream_id, ES->i_type,
 322                       ES->p_decoder_fifo != NULL ? "selected" : "not selected");
 323 #undef ES
 324         }
 325     }
 326 }
 327 #endif
 328
 329 /*****************************************************************************
 330  * InitDecConfig: initializes a decoder_config_t
 331  *****************************************************************************/
 332 static int InitDecConfig( input_thread_t * p_input, es_descriptor_t * p_es,
 333                           decoder_config_t * p_config )
 334 {
 335     p_config->i_stream_id = p_es->i_stream_id;
 336     p_config->i_type = p_es->i_type;
 337     p_config->p_stream_ctrl =
 338         &p_input->stream.control;
 339
 340     /* Decoder FIFO */
 341     if( (p_config->p_decoder_fifo =
 342             (decoder_fifo_t *)malloc( sizeof(decoder_fifo_t) )) == NULL )
 343     {
 344         intf_ErrMsg( "Out of memory" );
 345         return( -1 );
 346     }
 347
 348     vlc_mutex_init(&p_config->p_decoder_fifo->data_lock);
 349     vlc_cond_init(&p_config->p_decoder_fifo->data_wait);
 350     p_config->p_decoder_fifo->i_start = p_config->p_decoder_fifo->i_end = 0;
 351     p_config->p_decoder_fifo->b_die = 0;
 352     p_config->p_decoder_fifo->p_packets_mgt = p_input->p_method_data;
 353     p_config->p_decoder_fifo->pf_delete_pes =
 354         p_input->p_plugin->pf_delete_pes;
 355     p_es->p_decoder_fifo = p_config->p_decoder_fifo;
 356
 357     p_config->pf_init_bit_stream = InitBitstream;
 358
 359     return( 0 );
 360 }
 361
 362 /*****************************************************************************
 363  * GetVdecConfig: returns a valid vdec_config_t
 364  *****************************************************************************/
 365 static vdec_config_t * GetVdecConfig( input_thread_t * p_input,
 366                                       es_descriptor_t * p_es )
 367 {
 368     vdec_config_t *     p_config;
 369
 370     p_config = (vdec_config_t *)malloc( sizeof(vdec_config_t) );
 371     p_config->p_vout = p_input->p_default_vout;
 372     if( InitDecConfig( p_input, p_es, &p_config->decoder_config ) == -1 )
 373     {
 374         free( p_config );
 375         return NULL;
 376     }
 377
 378     return( p_config );
 379 }
 380
 381 /*****************************************************************************
 382  * GetAdecConfig: returns a valid adec_config_t
 383  *****************************************************************************/
 384 static adec_config_t * GetAdecConfig( input_thread_t * p_input,
 385                                       es_descriptor_t * p_es )
 386 {
 387     adec_config_t *     p_config;
 388
 389     p_config = (adec_config_t *)malloc( sizeof(adec_config_t) );
 390     p_config->p_aout = p_input->p_default_aout;
 391     if( InitDecConfig( p_input, p_es, &p_config->decoder_config ) == -1 )
 392     {
 393         free( p_config );
 394         return NULL;
 395     }
 396
 397     return( p_config );
 398 }
 399
 400 /*****************************************************************************
 401  * input_SelectES: selects an ES and spawns the associated decoder
 402  *****************************************************************************/
 403 int input_SelectES( input_thread_t * p_input, es_descriptor_t * p_es )
 404 {
 405     int                 i;
 406     es_descriptor_t **  p_spot = NULL;
 407
 408 #ifdef DEBUG_INPUT
 409     intf_DbgMsg( "Selecting ES %d", p_es->i_id );
 410 #endif
 411
 412     if( p_es->p_decoder_fifo != NULL )
 413     {
 414         intf_ErrMsg( "ES %d is already selected", p_es->i_id );
 415         return( -1 );
 416     }
 417
 418     /* Find a free spot in pp_selected_es. */
 419     for( i = 0; i < INPUT_MAX_SELECTED_ES; i++ )
 420     {
 421         if( p_input->pp_selected_es[i] == NULL )
 422         {
 423             p_spot = &p_input->pp_selected_es[i];
 424             break;
 425         }
 426     }
 427
 428     if( p_spot == NULL )
 429     {
 430         intf_ErrMsg( "Too many ES selected" );
 431         return( -1 );
 432     }
 433
 434     switch( p_es->i_type )
 435     {
 436     case MPEG1_AUDIO_ES:
 437     case MPEG2_AUDIO_ES:
 438         if( p_main->b_audio )
 439         {
 440             p_es->thread_id = adec_CreateThread( GetAdecConfig( p_input,
 441                                                                 p_es ) );
 442         }
 443         break;
 444
 445     case MPEG1_VIDEO_ES:
 446     case MPEG2_VIDEO_ES:
 447         if( p_main->b_video )
 448         {
 449             p_es->thread_id = vpar_CreateThread( GetVdecConfig( p_input,
 450                                                                 p_es ) );
 451         }
 452         break;
 453
 454     case AC3_AUDIO_ES:
 455         if( p_main->b_audio )
 456         {
 457             p_es->thread_id = ac3dec_CreateThread( GetAdecConfig( p_input,
 458                                                                   p_es ) );
 459         }
 460         break;
 461
 462     case DVD_SPU_ES:
 463         if( p_main->b_video )
 464         {
 465             p_es->thread_id = spudec_CreateThread( GetVdecConfig( p_input,
 466                                                                   p_es ) );
 467         }
 468         break;
 469
 470     default:
 471         intf_ErrMsg( "Unknown stream type %d", p_es->i_type );
 472         return( -1 );
 473         break;
 474     }
 475
 476     *p_spot = p_es;
 477     return( 0 );
 478 }