git.sesse.net Git - vlc/blob - src/spu_decoder/spu_decoder.c

   1 /*****************************************************************************
   2  * spu_decoder.c : spu decoder thread
   3  *****************************************************************************
   4  * Copyright (C) 2000 VideoLAN
   5  *
   6  * Authors:
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public
  19  * License along with this program; if not, write to the
  20  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  21  * Boston, MA 02111-1307, USA.
  22  *****************************************************************************/
  23
  24 /* repompé sur video_decoder.c
  25  * FIXME: passer en terminate/destroy avec les signaux supplémentaires ?? */
  26
  27 /*****************************************************************************
  28  * Preamble
  29  *****************************************************************************/
  30 #include "defs.h"
  31
  32 #include <stdlib.h>                                      /* malloc(), free() */
  33 #include <sys/types.h>                        /* on BSD, uio.h needs types.h */
  34 #include <sys/uio.h>                                          /* for input.h */
  35 #include <unistd.h>                                              /* getpid() */
  36
  37 #include "config.h"
  38 #include "common.h"
  39 #include "threads.h"
  40 #include "mtime.h"
  41 #include "plugins.h"
  42
  43 #include "intf_msg.h"
  44 #include "debug.h"                                                 /* ASSERT */
  45
  46 #include "input.h"
  47 #include "input_netlist.h"
  48 #include "decoder_fifo.h"
  49
  50 #include "video.h"
  51 #include "video_output.h"
  52
  53 #include "spu_decoder.h"
  54
  55 /*
  56  * Local prototypes
  57  */
  58 static int      InitThread          ( spudec_thread_t *p_spudec );
  59 static void     RunThread           ( spudec_thread_t *p_spudec );
  60 static void     ErrorThread         ( spudec_thread_t *p_spudec );
  61 static void     EndThread           ( spudec_thread_t *p_spudec );
  62
  63 #define GetWord( i ) \
  64     i  = GetByte( &p_spudec->bit_stream ) << 8; \
  65     i += GetByte( &p_spudec->bit_stream ); \
  66     i_index += 2;
  67
  68 /*****************************************************************************
  69  * spudec_CreateThread: create a spu decoder thread
  70  *****************************************************************************/
  71 spudec_thread_t * spudec_CreateThread( input_thread_t * p_input )
  72 {
  73     spudec_thread_t *     p_spudec;
  74
  75     intf_DbgMsg("spudec debug: creating spu decoder thread\n");
  76
  77     /* Allocate the memory needed to store the thread's structure */
  78     if ( (p_spudec = (spudec_thread_t *)malloc( sizeof(spudec_thread_t) )) == NULL )
  79     {
  80         intf_ErrMsg("spudec error: not enough memory for spudec_CreateThread() to create the new thread\n");
  81         return( NULL );
  82     }
  83
  84     /*
  85      * Initialize the thread properties
  86      */
  87     p_spudec->b_die = 0;
  88     p_spudec->b_error = 0;
  89
  90     /*
  91      * Initialize the input properties
  92      */
  93     /* Initialize the decoder fifo's data lock and conditional variable and set
  94      * its buffer as empty */
  95     vlc_mutex_init( &p_spudec->fifo.data_lock );
  96     vlc_cond_init( &p_spudec->fifo.data_wait );
  97     p_spudec->fifo.i_start = 0;
  98     p_spudec->fifo.i_end = 0;
  99     /* Initialize the bit stream structure */
 100     p_spudec->bit_stream.p_input = p_input;
 101     p_spudec->bit_stream.p_decoder_fifo = &p_spudec->fifo;
 102     p_spudec->bit_stream.fifo.buffer = 0;
 103     p_spudec->bit_stream.fifo.i_available = 0;
 104
 105     /* Get the video output informations */
 106     p_spudec->p_vout = p_input->p_vout;
 107
 108     /* Spawn the spu decoder thread */
 109     if ( vlc_thread_create(&p_spudec->thread_id, "spu decoder",
 110          (vlc_thread_func_t)RunThread, (void *)p_spudec) )
 111     {
 112         intf_ErrMsg("spudec error: can't spawn spu decoder thread\n");
 113         free( p_spudec );
 114         return( NULL );
 115     }
 116
 117     intf_DbgMsg("spudec debug: spu decoder thread (%p) created\n", p_spudec);
 118     return( p_spudec );
 119 }
 120
 121 /*****************************************************************************
 122  * spudec_DestroyThread: destroy a spu decoder thread
 123  *****************************************************************************
 124  * Destroy and terminate thread. This function will return 0 if the thread could
 125  * be destroyed, and non 0 else. The last case probably means that the thread
 126  * was still active, and another try may succeed.
 127  *****************************************************************************/
 128 void spudec_DestroyThread( spudec_thread_t *p_spudec )
 129 {
 130     intf_DbgMsg("spudec debug: requesting termination of spu decoder thread %p\n", p_spudec);
 131
 132     /* Ask thread to kill itself */
 133     p_spudec->b_die = 1;
 134
 135     /* Warn the decoder that we're quitting */
 136     vlc_mutex_lock( &p_spudec->fifo.data_lock );
 137     vlc_cond_signal( &p_spudec->fifo.data_wait );
 138     vlc_mutex_unlock( &p_spudec->fifo.data_lock );
 139
 140     /* Waiting for the decoder thread to exit */
 141     /* Remove this as soon as the "status" flag is implemented */
 142     vlc_thread_join( p_spudec->thread_id );
 143 }
 144
 145 /* following functions are local */
 146
 147 /*****************************************************************************
 148  * InitThread: initialize spu decoder thread
 149  *****************************************************************************
 150  * This function is called from RunThread and performs the second step of the
 151  * initialization. It returns 0 on success. Note that the thread's flag are not
 152  * modified inside this function.
 153  *****************************************************************************/
 154 static int InitThread( spudec_thread_t *p_spudec )
 155 {
 156     intf_DbgMsg("spudec debug: initializing spu decoder thread %p\n", p_spudec);
 157
 158     /* Our first job is to initialize the bit stream structure with the
 159      * beginning of the input stream */
 160     vlc_mutex_lock( &p_spudec->fifo.data_lock );
 161     while ( DECODER_FIFO_ISEMPTY(p_spudec->fifo) )
 162     {
 163         if ( p_spudec->b_die )
 164         {
 165             vlc_mutex_unlock( &p_spudec->fifo.data_lock );
 166             return( 1 );
 167         }
 168         vlc_cond_wait( &p_spudec->fifo.data_wait, &p_spudec->fifo.data_lock );
 169     }
 170
 171     p_spudec->bit_stream.p_ts = DECODER_FIFO_START( p_spudec->fifo )->p_first_ts;
 172     p_spudec->bit_stream.p_byte = p_spudec->bit_stream.p_ts->buffer + p_spudec->bit_stream.p_ts->i_payload_start;
 173     p_spudec->bit_stream.p_end = p_spudec->bit_stream.p_ts->buffer + p_spudec->bit_stream.p_ts->i_payload_end;
 174     vlc_mutex_unlock( &p_spudec->fifo.data_lock );
 175
 176     /* Mark thread as running and return */
 177     intf_DbgMsg( "spudec debug: InitThread(%p) succeeded\n", p_spudec );
 178     return( 0 );
 179 }
 180
 181 /*****************************************************************************
 182  * RunThread: spu decoder thread
 183  *****************************************************************************
 184  * spu decoder thread. This function does only return when the thread is
 185  * terminated.
 186  *****************************************************************************/
 187 static void RunThread( spudec_thread_t *p_spudec )
 188 {
 189     intf_DbgMsg("spudec debug: running spu decoder thread (%p) (pid == %i)\n",
 190         p_spudec, getpid());
 191
 192     /*
 193      * Initialize thread and free configuration
 194      */
 195     p_spudec->b_error = InitThread( p_spudec );
 196
 197     p_spudec->b_run = 1;
 198
 199     /*
 200      * Main loop - it is not executed if an error occured during
 201      * initialization
 202      */
 203     while( (!p_spudec->b_die) && (!p_spudec->b_error) )
 204     {
 205         int i_spu_id;
 206         int i_packet_size;
 207         int i_rle_size;
 208         int i_index;
 209         int i_pes_size;
 210         boolean_t       b_finished;
 211         unsigned char * p_spu_data;
 212         subpicture_t  * p_spu;
 213
 214         while( !DECODER_FIFO_ISEMPTY(p_spudec->fifo) )
 215         {
 216             printf( "*** tracking next SPU PES\n" );
 217             do
 218             {
 219                 i_spu_id = GetByte( &p_spudec->bit_stream );
 220             }
 221             while( (i_spu_id & 0xe0) != 0x20 );
 222             i_pes_size = DECODER_FIFO_START(p_spudec->fifo)->i_pes_size;
 223             printf( "got it. size = 0x%.4x\n", i_pes_size );
 224
 225             printf( "SPU id: 0x%.2x\n", i_spu_id );
 226
 227             i_index = 0;
 228
 229             GetWord( i_packet_size );
 230             printf( "total size:  0x%.4x\n", i_packet_size );
 231
 232             GetWord( i_rle_size );
 233             printf( "RLE size:    0x%.4x\n", i_rle_size );
 234
 235             /* we already read 4 bytes for the total size and the RLE size */
 236
 237             p_spu = vout_CreateSubPicture( p_spudec->p_vout,
 238                                            DVD_SUBPICTURE, i_rle_size );
 239             p_spu_data = p_spu->p_data;
 240
 241             if( (i_rle_size < i_packet_size)
 242                 && ((i_spu_id & 0xe0) == 0x20) )
 243             {
 244                 printf( "doing RLE stuff (%i bytes)\n", i_rle_size );
 245                 printf( "index/size %i/%i\n", i_index, i_pes_size );
 246                 while( i_index++ <i_rle_size )
 247                 {
 248                     //*p_spu_data++ = GetByte( &p_spudec->bit_stream );
 249                     if (i_index == i_pes_size) printf ("\n **** \n");
 250                     /* kludge ??? */
 251                     if (i_index == i_pes_size) printf( "%.2x", *p_spu_data++ = GetByte( &p_spudec->bit_stream ) );
 252                     printf( "%.2x", *p_spu_data++ = GetByte( &p_spudec->bit_stream ) );
 253                 }
 254                 printf( "\nindex/size %i/%i\n", i_index, i_pes_size );
 255                 //printf( "\n" );
 256
 257                 b_finished = 0;
 258                 printf( "control stuff\n" );
 259                 do
 260                 {
 261                     unsigned char i_cmd;
 262                     unsigned int i_word;
 263
 264                     GetWord( i_word );
 265                     printf( "date: 0x%.4x\n", i_word );
 266
 267                     GetWord( i_word );
 268                     printf( "  next: 0x%.4x (i-5: %.4x)\n", i_word, i_index-5 );
 269                     b_finished = (i_index - 5 >= i_word );
 270
 271                     do
 272                     {
 273                         i_cmd = GetByte( &p_spudec->bit_stream );
 274                         i_index++;
 275
 276                         switch(i_cmd)
 277                         {
 278                             case 0x00:
 279                                 printf( "  00 (display now)\n" );
 280                                 break;
 281                             case 0x01:
 282                                 printf( "  01 (start displaying)\n" );
 283                                 break;
 284                             case 0x02:
 285                                 printf( "  02 (stop displaying)\n" );
 286                                 break;
 287                             case 0x03:
 288                                 GetWord( i_word );
 289                                 printf( "  03 (palette) - %.4x\n", i_word );
 290                                 break;
 291                             case 0x04:
 292                                 GetWord( i_word );
 293                                 printf( "  04 (alpha channel) - %.4x\n", i_word );
 294                                 break;
 295                             case 0x05:
 296                                 GetWord( i_word );
 297                                 printf( "  05 (coordinates) - %.4x", i_word );
 298                                 GetWord( i_word );
 299                                 printf( "%.4x", i_word );
 300                                 GetWord( i_word );
 301                                 printf( "%.4x\n", i_word );
 302                                 break;
 303                             case 0x06:
 304                                 GetWord( i_word );
 305                                 printf( "  06 (byte offsets) - %.4x", i_word );
 306                                 GetWord( i_word );
 307                                 printf( "%.4x\n", i_word );
 308                                 break;
 309                             case 0xff:
 310                                 printf( "  ff (end)\n" );
 311                                 break;
 312                             default:
 313                                 printf( "  %.2x (unknown command)\n", i_cmd );
 314                                 break;
 315                         }
 316
 317                     }
 318                     while( i_cmd != 0xff );
 319
 320                 }
 321                 while( !b_finished );
 322                 printf( "control stuff finished\n" );
 323                 printf( "*** end of PES !\n\n" );
 324             }
 325             else
 326             {
 327                 printf( "*** invalid PES !\n\n" );
 328                 /* trash the PES packet */
 329                 /*vlc_mutex_lock( &p_spudec->fifo.data_lock );
 330                 input_NetlistFreePES( p_spudec->bit_stream.p_input,
 331                                       DECODER_FIFO_START(p_spudec->fifo) );
 332                 DECODER_FIFO_INCSTART( p_spudec->fifo );
 333                 vlc_mutex_unlock( &p_spudec->fifo.data_lock );*/
 334             }
 335
 336         }
 337         /* Waiting for the input thread to put new PES packets in the fifo */
 338         printf( "decoder fifo is empty\n" );
 339         vlc_cond_wait( &p_spudec->fifo.data_wait, &p_spudec->fifo.data_lock );
 340     }
 341
 342     /*
 343      * Error loop
 344      */
 345     if( p_spudec->b_error )
 346     {
 347         ErrorThread( p_spudec );
 348     }
 349
 350     p_spudec->b_run = 0;
 351
 352     /* End of thread */
 353     EndThread( p_spudec );
 354 }
 355
 356 /*****************************************************************************
 357  * ErrorThread: RunThread() error loop
 358  *****************************************************************************
 359  * This function is called when an error occured during thread main's loop. The
 360  * thread can still receive feed, but must be ready to terminate as soon as
 361  * possible.
 362  *****************************************************************************/
 363 static void ErrorThread( spudec_thread_t *p_spudec )
 364 {
 365     /* We take the lock, because we are going to read/write the start/end
 366      * indexes of the decoder fifo */
 367     vlc_mutex_lock( &p_spudec->fifo.data_lock );
 368
 369     /* Wait until a `die' order is sent */
 370     while( !p_spudec->b_die )
 371     {
 372         /* Trash all received PES packets */
 373         while( !DECODER_FIFO_ISEMPTY(p_spudec->fifo) )
 374         {
 375             input_NetlistFreePES( p_spudec->bit_stream.p_input, DECODER_FIFO_START(p_spudec->fifo) );
 376             DECODER_FIFO_INCSTART( p_spudec->fifo );
 377         }
 378
 379         /* Waiting for the input thread to put new PES packets in the fifo */
 380         vlc_cond_wait( &p_spudec->fifo.data_wait, &p_spudec->fifo.data_lock );
 381     }
 382
 383     /* We can release the lock before leaving */
 384     vlc_mutex_unlock( &p_spudec->fifo.data_lock );
 385 }
 386
 387 /*****************************************************************************
 388  * EndThread: thread destruction
 389  *****************************************************************************
 390  * This function is called when the thread ends after a sucessful
 391  * initialization.
 392  *****************************************************************************/
 393 static void EndThread( spudec_thread_t *p_spudec )
 394 {
 395     intf_DbgMsg( "spudec debug: destroying spu decoder thread %p\n", p_spudec );
 396     free( p_spudec );
 397     intf_DbgMsg( "spudec debug: spu decoder thread %p destroyed\n", p_spudec);
 398 }