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.31 2001/02/08 17:44:12 massiot Exp $
   6  *
   7  * Authors: Christophe Massiot <massiot@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., 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 int 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.pp_es = NULL;
  58     p_input->stream.pp_selected_es = NULL;
  59     p_input->stream.pp_programs = NULL;
  60
  61     if( i_data_len )
  62     {
  63         if ( (p_input->stream.p_demux_data = malloc( i_data_len )) == NULL )
  64         {
  65             intf_ErrMsg( "Unable to allocate memory in input_InitStream");
  66             return 1;
  67         }
  68         memset( p_input->stream.p_demux_data, 0, i_data_len );
  69     }
  70
  71     return 0;
  72 }
  73
  74 /*****************************************************************************
  75  * input_EndStream: free all stream descriptors
  76  *****************************************************************************/
  77 void input_EndStream( input_thread_t * p_input )
  78 {
  79     /* Free all programs and associated ES, and associated decoders. */
  80     while( p_input->stream.i_pgrm_number )
  81     {
  82         input_DelProgram( p_input, p_input->stream.pp_programs[0] );
  83     }
  84
  85     /* Free standalone ES */
  86     while( p_input->stream.i_es_number )
  87     {
  88         input_DelES( p_input, p_input->stream.pp_es[0] );
  89     }
  90 }
  91
  92 /*****************************************************************************
  93  * input_FindProgram: returns a pointer to a program described by its ID
  94  *****************************************************************************/
  95 pgrm_descriptor_t * input_FindProgram( input_thread_t * p_input, u16 i_pgrm_id )
  96 {
  97     int     i;
  98
  99     for( i = 0; i < p_input->stream.i_pgrm_number; i++ )
 100     {
 101         if( p_input->stream.pp_programs[i]->i_number == i_pgrm_id )
 102         {
 103             return p_input->stream.pp_programs[i];
 104         }
 105     }
 106
 107     return( NULL );
 108 }
 109
 110 /*****************************************************************************
 111  * input_AddProgram: add and init a program descriptor
 112  *****************************************************************************
 113  * This program descriptor will be referenced in the given stream descriptor
 114  *****************************************************************************/
 115 pgrm_descriptor_t * input_AddProgram( input_thread_t * p_input,
 116                                       u16 i_pgrm_id, size_t i_data_len )
 117 {
 118     /* Where to add the pgrm */
 119     int i_pgrm_index = p_input->stream.i_pgrm_number;
 120
 121     intf_DbgMsg("Adding description for pgrm %d", i_pgrm_id);
 122
 123     /* Add an entry to the list of program associated with the stream */
 124     p_input->stream.i_pgrm_number++;
 125     p_input->stream.pp_programs = realloc( p_input->stream.pp_programs,
 126                                            p_input->stream.i_pgrm_number
 127                                             * sizeof(pgrm_descriptor_t *) );
 128     if( p_input->stream.pp_programs == NULL )
 129     {
 130         intf_ErrMsg( "Unable to realloc memory in input_AddProgram" );
 131         return( NULL );
 132     }
 133
 134     /* Allocate the structure to store this description */
 135     p_input->stream.pp_programs[i_pgrm_index] =
 136                                         malloc( sizeof(pgrm_descriptor_t) );
 137     if( p_input->stream.pp_programs[i_pgrm_index] == NULL )
 138     {
 139         intf_ErrMsg( "Unable to allocate memory in input_AddProgram" );
 140         return( NULL );
 141     }
 142
 143     /* Init this entry */
 144     p_input->stream.pp_programs[i_pgrm_index]->i_number = i_pgrm_id;
 145     p_input->stream.pp_programs[i_pgrm_index]->b_is_ok = 0;
 146     p_input->stream.pp_programs[i_pgrm_index]->i_version = 0;
 147
 148     p_input->stream.pp_programs[i_pgrm_index]->i_es_number = 0;
 149     p_input->stream.pp_programs[i_pgrm_index]->pp_es = NULL;
 150
 151     input_ClockInit( p_input->stream.pp_programs[i_pgrm_index] );
 152
 153     p_input->stream.pp_programs[i_pgrm_index]->i_synchro_state
 154                                                 = SYNCHRO_START;
 155
 156     p_input->stream.pp_programs[i_pgrm_index]->p_vout
 157                                             = p_input->p_default_vout;
 158     p_input->stream.pp_programs[i_pgrm_index]->p_aout
 159                                             = p_input->p_default_aout;
 160
 161     if( i_data_len )
 162     {
 163         p_input->stream.pp_programs[i_pgrm_index]->p_demux_data =
 164             malloc( i_data_len );
 165         if( p_input->stream.pp_programs[i_pgrm_index]->p_demux_data == NULL )
 166         {
 167             intf_ErrMsg( "Unable to allocate memory in input_AddProgram" );
 168             return( NULL );
 169         }
 170         memset( p_input->stream.pp_programs[i_pgrm_index]->p_demux_data, 0,
 171                 i_data_len );
 172     }
 173
 174     return p_input->stream.pp_programs[i_pgrm_index];
 175 }
 176
 177 /*****************************************************************************
 178  * input_DelProgram: destroy a program descriptor
 179  *****************************************************************************
 180  * All ES descriptions referenced in the descriptor will be deleted.
 181  *****************************************************************************/
 182 void input_DelProgram( input_thread_t * p_input, pgrm_descriptor_t * p_pgrm )
 183 {
 184     int i_pgrm_index;
 185
 186     ASSERT( p_pgrm );
 187
 188     intf_DbgMsg("Deleting description for pgrm %d", p_pgrm->i_number);
 189
 190     /* Free the structures that describe the es that belongs to that program */
 191     while( p_pgrm->i_es_number )
 192     {
 193         input_DelES( p_input, p_pgrm->pp_es[0] );
 194     }
 195
 196     /* Free the demux data */
 197     if( p_pgrm->p_demux_data != NULL )
 198     {
 199         free( p_pgrm->p_demux_data );
 200     }
 201
 202     /* Find the program in the programs table */
 203     for( i_pgrm_index = 0; i_pgrm_index < p_input->stream.i_pgrm_number;
 204          i_pgrm_index++ )
 205     {
 206         if( p_input->stream.pp_programs[i_pgrm_index] == p_pgrm )
 207             break;
 208     }
 209
 210     /* Remove this program from the stream's list of programs */
 211     p_input->stream.i_pgrm_number--;
 212
 213     p_input->stream.pp_programs[i_pgrm_index] =
 214         p_input->stream.pp_programs[p_input->stream.i_pgrm_number];
 215     p_input->stream.pp_programs = realloc( p_input->stream.pp_programs,
 216                                            p_input->stream.i_pgrm_number
 217                                             * sizeof(pgrm_descriptor_t *) );
 218
 219     if( p_input->stream.i_pgrm_number && p_input->stream.pp_programs == NULL)
 220     {
 221         intf_ErrMsg( "input error: unable to realloc program list"
 222                      " in input_DelProgram" );
 223     }
 224
 225     /* Free the description of this program */
 226     free( p_pgrm );
 227 }
 228
 229 /*****************************************************************************
 230  * input_FindES: returns a pointer to an ES described by its ID
 231  *****************************************************************************/
 232 es_descriptor_t * input_FindES( input_thread_t * p_input, u16 i_es_id )
 233 {
 234     int     i;
 235
 236     for( i = 0; i < p_input->stream.i_es_number; i++ )
 237     {
 238         if( p_input->stream.pp_es[i]->i_id == i_es_id )
 239         {
 240             return p_input->stream.pp_es[i];
 241         }
 242     }
 243
 244     return( NULL );
 245 }
 246
 247 /*****************************************************************************
 248  * input_AddES:
 249  *****************************************************************************
 250  * Reserve a slot in the table of ES descriptors for the ES and add it to the
 251  * list of ES of p_pgrm. If p_pgrm if NULL, then the ES is considered as stand
 252  * alone (PSI ?)
 253  *****************************************************************************/
 254 es_descriptor_t * input_AddES( input_thread_t * p_input,
 255                                pgrm_descriptor_t * p_pgrm, u16 i_es_id,
 256                                size_t i_data_len )
 257 {
 258     es_descriptor_t * p_es;
 259
 260     intf_DbgMsg("Adding description for ES 0x%x", i_es_id);
 261
 262     p_es = (es_descriptor_t *)malloc( sizeof(es_descriptor_t) );
 263     if( p_es == NULL )
 264     {
 265         intf_ErrMsg( "Unable to allocate memory in input_AddES" );
 266         return( NULL);
 267     }
 268     p_input->stream.i_es_number++;
 269     p_input->stream.pp_es = realloc( p_input->stream.pp_es,
 270                                      p_input->stream.i_es_number
 271                                       * sizeof(es_descriptor_t *) );
 272     if( p_input->stream.pp_es == NULL )
 273     {
 274         intf_ErrMsg( "Unable to realloc memory in input_AddES" );
 275         return( NULL );
 276     }
 277     p_input->stream.pp_es[p_input->stream.i_es_number - 1] = p_es;
 278
 279     /* Init its values */
 280     p_es->i_id = i_es_id;
 281     p_es->p_pes = NULL;
 282     p_es->p_decoder_fifo = NULL;
 283     p_es->b_audio = 0;
 284
 285     if( i_data_len )
 286     {
 287         p_es->p_demux_data = malloc( i_data_len );
 288         if( p_es->p_demux_data == NULL )
 289         {
 290             intf_ErrMsg( "Unable to allocate memory in input_AddES" );
 291             return( NULL );
 292         }
 293         memset( p_es->p_demux_data, 0, i_data_len );
 294     }
 295     else
 296     {
 297         p_es->p_demux_data = NULL;
 298     }
 299
 300     /* Add this ES to the program definition if one is given */
 301     if( p_pgrm )
 302     {
 303         p_pgrm->i_es_number++;
 304         p_pgrm->pp_es = realloc( p_pgrm->pp_es,
 305                                  p_pgrm->i_es_number
 306                                   * sizeof(es_descriptor_t *) );
 307         if( p_pgrm->pp_es == NULL )
 308         {
 309             intf_ErrMsg( "Unable to realloc memory in input_AddES" );
 310             return( NULL );
 311         }
 312         p_pgrm->pp_es[p_pgrm->i_es_number - 1] = p_es;
 313         p_es->p_pgrm = p_pgrm;
 314     }
 315     else
 316     {
 317         p_es->p_pgrm = NULL;
 318     }
 319
 320     return p_es;
 321 }
 322
 323 /*****************************************************************************
 324  * input_DelES:
 325  *****************************************************************************/
 326 void input_DelES( input_thread_t * p_input, es_descriptor_t * p_es )
 327 {
 328     int                     i_index, i_es_index;
 329     pgrm_descriptor_t *     p_pgrm;
 330
 331     ASSERT( p_es );
 332     p_pgrm = p_es->p_pgrm;
 333
 334     /* Kill associated decoder, if any. */
 335     if( p_es->p_decoder_fifo != NULL )
 336     {
 337         input_EndDecoder( p_input, p_es );
 338     }
 339
 340     /* Remove this ES from the description of the program if it is associated to
 341      * one */
 342     if( p_pgrm )
 343     {
 344         for( i_index = 0; i_index < p_pgrm->i_es_number; i_index++ )
 345         {
 346             if( p_pgrm->pp_es[i_index] == p_es )
 347             {
 348                 p_pgrm->i_es_number--;
 349                 p_pgrm->pp_es[i_index] = p_pgrm->pp_es[p_pgrm->i_es_number];
 350                 p_pgrm->pp_es = realloc( p_pgrm->pp_es,
 351                                          p_pgrm->i_es_number
 352                                           * sizeof(es_descriptor_t *));
 353                 if( p_pgrm->i_es_number && p_pgrm->pp_es == NULL )
 354                 {
 355                     intf_ErrMsg( "Unable to realloc memory in input_DelES" );
 356                 }
 357                 break;
 358             }
 359         }
 360     }
 361
 362     /* Free the demux data */
 363     if( p_es->p_demux_data != NULL )
 364     {
 365         free( p_es->p_demux_data );
 366     }
 367
 368     /* Find the ES in the ES table */
 369     for( i_es_index = 0; i_es_index < p_input->stream.i_es_number;
 370          i_es_index++ )
 371     {
 372         if( p_input->stream.pp_es[i_es_index] == p_es )
 373             break;
 374     }
 375
 376     /* Free the ES */
 377     free( p_es );
 378     p_input->stream.i_es_number--;
 379     p_input->stream.pp_es[i_es_index] =
 380                     p_input->stream.pp_es[p_input->stream.i_es_number];
 381     p_input->stream.pp_es = realloc( p_input->stream.pp_es,
 382                                      p_input->stream.i_es_number
 383                                       * sizeof(es_descriptor_t *));
 384     if( p_input->stream.i_es_number && p_input->stream.pp_es == NULL )
 385     {
 386         intf_ErrMsg( "Unable to realloc memory in input_DelES" );
 387     }
 388
 389 }
 390
 391 #ifdef STATS
 392 /*****************************************************************************
 393  * input_DumpStream: dumps the contents of a stream descriptor
 394  *****************************************************************************/
 395 void input_DumpStream( input_thread_t * p_input )
 396 {
 397     int i, j;
 398 #define S   p_input->stream
 399     intf_Msg( "input info: Dumping stream ID 0x%x", S.i_stream_id );
 400     if( S.b_seekable )
 401         intf_Msg( "input info: seekable stream, position: %lld/%lld",
 402                   S.i_tell, S.i_size );
 403     else
 404         intf_Msg( "input info: %s", S.b_pace_control ? "pace controlled" :
 405                   "pace un-controlled" );
 406 #undef S
 407     for( i = 0; i < p_input->stream.i_pgrm_number; i++ )
 408     {
 409 #define P   p_input->stream.pp_programs[i]
 410         intf_Msg( "input info: Dumping program 0x%x, version %d (%s)",
 411                   P->i_number, P->i_version,
 412                   P->b_is_ok ? "complete" : "partial" );
 413 #undef P
 414         for( j = 0; j < p_input->stream.pp_programs[i]->i_es_number; j++ )
 415         {
 416 #define ES  p_input->stream.pp_programs[i]->pp_es[j]
 417             intf_Msg( "input info: ES 0x%x, stream 0x%x, type 0x%x, %s",
 418                       ES->i_id, ES->i_stream_id, ES->i_type,
 419                       ES->p_decoder_fifo != NULL ? "selected" : "not selected");
 420 #undef ES
 421         }
 422     }
 423 }
 424 #endif
 425
 426 /*****************************************************************************
 427  * InitDecConfig: initializes a decoder_config_t
 428  *****************************************************************************/
 429 static int InitDecConfig( input_thread_t * p_input, es_descriptor_t * p_es,
 430                           decoder_config_t * p_config )
 431 {
 432     p_config->i_id = p_es->i_id;
 433     p_config->i_type = p_es->i_type;
 434     p_config->p_stream_ctrl =
 435         &p_input->stream.control;
 436
 437     /* Decoder FIFO */
 438     if( (p_config->p_decoder_fifo =
 439             (decoder_fifo_t *)malloc( sizeof(decoder_fifo_t) )) == NULL )
 440     {
 441         intf_ErrMsg( "Out of memory" );
 442         return( -1 );
 443     }
 444
 445     vlc_mutex_init(&p_config->p_decoder_fifo->data_lock);
 446     vlc_cond_init(&p_config->p_decoder_fifo->data_wait);
 447     p_config->p_decoder_fifo->i_start = p_config->p_decoder_fifo->i_end = 0;
 448     p_config->p_decoder_fifo->b_die = p_config->p_decoder_fifo->b_error = 0;
 449     p_config->p_decoder_fifo->p_packets_mgt = p_input->p_method_data;
 450     p_config->p_decoder_fifo->pf_delete_pes = p_input->pf_delete_pes;
 451     p_es->p_decoder_fifo = p_config->p_decoder_fifo;
 452
 453     p_config->pf_init_bit_stream = InitBitstream;
 454
 455     return( 0 );
 456 }
 457
 458 /*****************************************************************************
 459  * GetVdecConfig: returns a valid vdec_config_t
 460  *****************************************************************************/
 461 static vdec_config_t * GetVdecConfig( input_thread_t * p_input,
 462                                       es_descriptor_t * p_es )
 463 {
 464     vdec_config_t *     p_config;
 465
 466     p_config = (vdec_config_t *)malloc( sizeof(vdec_config_t) );
 467     if( p_config == NULL )
 468     {
 469         intf_ErrMsg( "Unable to allocate memory in GetVdecConfig" );
 470         return( NULL );
 471     }
 472     p_config->p_vout = p_input->p_default_vout;
 473     if( InitDecConfig( p_input, p_es, &p_config->decoder_config ) == -1 )
 474     {
 475         free( p_config );
 476         return( NULL );
 477     }
 478
 479     return( p_config );
 480 }
 481
 482 /*****************************************************************************
 483  * GetAdecConfig: returns a valid adec_config_t
 484  *****************************************************************************/
 485 static adec_config_t * GetAdecConfig( input_thread_t * p_input,
 486                                       es_descriptor_t * p_es )
 487 {
 488     adec_config_t *     p_config;
 489
 490     p_config = (adec_config_t *)malloc( sizeof(adec_config_t));
 491     if( p_config == NULL )
 492     {
 493         intf_ErrMsg( "Unable to allocate memory in GetAdecConfig" );
 494         return( NULL );
 495     }
 496     p_config->p_aout = p_input->p_default_aout;
 497     if( InitDecConfig( p_input, p_es, &p_config->decoder_config ) == -1 )
 498     {
 499         free( p_config );
 500         return( NULL );
 501     }
 502
 503     return( p_config );
 504 }
 505
 506 /*****************************************************************************
 507  * input_SelectES: selects an ES and spawns the associated decoder
 508  *****************************************************************************/
 509 /* FIXME */
 510 vlc_thread_t adec_CreateThread( void * );
 511 vlc_thread_t ac3dec_CreateThread( void * );
 512 vlc_thread_t vpar_CreateThread( void * );
 513 vlc_thread_t spudec_CreateThread( void * );
 514
 515 int input_SelectES( input_thread_t * p_input, es_descriptor_t * p_es )
 516 {
 517     /* FIXME ! */
 518     decoder_capabilities_t  decoder;
 519
 520 #ifdef DEBUG_INPUT
 521     intf_DbgMsg( "Selecting ES 0x%x", p_es->i_id );
 522 #endif
 523
 524     if( p_es->p_decoder_fifo != NULL )
 525     {
 526         intf_ErrMsg( "ES %d is already selected", p_es->i_id );
 527         return( -1 );
 528     }
 529
 530     switch( p_es->i_type )
 531     {
 532     case MPEG1_AUDIO_ES:
 533     case MPEG2_AUDIO_ES:
 534         if( p_main->b_audio )
 535         {
 536             decoder.pf_create_thread = adec_CreateThread;
 537             p_es->thread_id = input_RunDecoder( &decoder,
 538                                     (void *)GetAdecConfig( p_input, p_es ) );
 539         }
 540         break;
 541
 542     case MPEG1_VIDEO_ES:
 543     case MPEG2_VIDEO_ES:
 544         if( p_main->b_video )
 545         {
 546             decoder.pf_create_thread = vpar_CreateThread;
 547             p_es->thread_id = input_RunDecoder( &decoder,
 548                                     (void *)GetVdecConfig( p_input, p_es ) );
 549         }
 550         break;
 551
 552     case AC3_AUDIO_ES:
 553         if( p_main->b_audio )
 554         {
 555             decoder.pf_create_thread = ac3dec_CreateThread;
 556             p_es->thread_id = input_RunDecoder( &decoder,
 557                                     (void *)GetAdecConfig( p_input, p_es ) );
 558         }
 559         break;
 560
 561     case DVD_SPU_ES:
 562         if( p_main->b_video )
 563         {
 564             decoder.pf_create_thread = spudec_CreateThread;
 565             p_es->thread_id = input_RunDecoder( &decoder,
 566                                     (void *)GetVdecConfig( p_input, p_es ) );
 567         }
 568         break;
 569
 570     default:
 571         intf_ErrMsg( "Unknown stream type %d", p_es->i_type );
 572         return( -1 );
 573         break;
 574     }
 575
 576     if( p_es->thread_id == 0 )
 577     {
 578         return( -1 );
 579     }
 580
 581     if( p_es->p_decoder_fifo != NULL )
 582     {
 583         p_input->stream.i_selected_es_number++;
 584         p_input->stream.pp_selected_es = realloc(
 585                                            p_input->stream.pp_selected_es,
 586                                            p_input->stream.i_selected_es_number
 587                                             * sizeof(es_descriptor_t *) );
 588         if( p_input->stream.pp_selected_es == NULL )
 589         {
 590             intf_ErrMsg( "Unable to realloc memory in input_SelectES" );
 591             return(-1);
 592         }
 593         p_input->stream.pp_selected_es[p_input->stream.i_selected_es_number - 1]
 594                 = p_es;
 595     }
 596     return( 0 );
 597 }