git.sesse.net Git - vlc/blob - src/ac3_decoder/ac3_decoder_thread.c

   1 /*****************************************************************************
   2  * ac3_decoder_thread.c: ac3 decoder thread
   3  *****************************************************************************
   4  * Copyright (C) 1999, 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
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
  21  *****************************************************************************/
  22
  23 /*
  24  * TODO :
  25  *
  26  * - vérifier l'état de la fifo de sortie avant d'y stocker les samples
  27  *   décodés ;
  28  * - vlc_cond_signal() / vlc_cond_wait()
  29  *
  30  */
  31
  32 /*****************************************************************************
  33  * Preamble
  34  *****************************************************************************/
  35 #include "defs.h"
  36
  37 #include <unistd.h>                                              /* getpid() */
  38
  39 #include <stdio.h>                                           /* "intf_msg.h" */
  40 #include <stdlib.h>                                      /* malloc(), free() */
  41 #include <sys/types.h>                        /* on BSD, uio.h needs types.h */
  42 #include <sys/uio.h>                                            /* "input.h" */
  43
  44 #include "config.h"
  45 #include "common.h"
  46 #include "threads.h"
  47 #include "mtime.h"
  48 #include "plugins.h"
  49 #include "debug.h"                                      /* "input_netlist.h" */
  50
  51 #include "intf_msg.h"                        /* intf_DbgMsg(), intf_ErrMsg() */
  52
  53 #include "stream_control.h"
  54 #include "input_ext-dec.h"
  55
  56 #include "audio_output.h"
  57
  58 #include "ac3_decoder.h"
  59 #include "ac3_decoder_thread.h"
  60
  61 #define AC3DEC_FRAME_SIZE (2*1536)
  62
  63 /*****************************************************************************
  64  * Local prototypes
  65  *****************************************************************************/
  66 static int      InitThread              (ac3dec_thread_t * p_adec);
  67 static void     RunThread               (ac3dec_thread_t * p_adec);
  68 static void     ErrorThread             (ac3dec_thread_t * p_adec);
  69 static void     EndThread               (ac3dec_thread_t * p_adec);
  70
  71 /*****************************************************************************
  72  * ac3dec_CreateThread: creates an ac3 decoder thread
  73  *****************************************************************************/
  74 vlc_thread_t ac3dec_CreateThread( adec_config_t * p_config )
  75 {
  76     ac3dec_thread_t *   p_ac3dec;
  77
  78     intf_DbgMsg( "ac3dec debug: creating ac3 decoder thread\n" );
  79
  80     /* Allocate the memory needed to store the thread's structure */
  81     if ((p_ac3dec = (ac3dec_thread_t *)malloc (sizeof(ac3dec_thread_t))) == NULL)
  82     {
  83         intf_ErrMsg ( "ac3dec error: not enough memory "
  84                       "for ac3dec_CreateThread() to create the new thread\n");
  85         return 0;
  86     }
  87
  88     /*
  89      * Initialize the thread properties
  90      */
  91     p_ac3dec->b_die = 0;
  92     p_ac3dec->b_error = 0;
  93     p_ac3dec->p_config = p_config;
  94     p_ac3dec->p_fifo = p_config->decoder_config.p_decoder_fifo;
  95
  96     /* Initialize the ac3 decoder structures */
  97     ac3_init (&p_ac3dec->ac3_decoder);
  98
  99     /*
 100      * Initialize the output properties
 101      */
 102     p_ac3dec->p_aout = p_config->p_aout;
 103     p_ac3dec->p_aout_fifo = NULL;
 104
 105     /* Spawn the ac3 decoder thread */
 106     if (vlc_thread_create(&p_ac3dec->thread_id, "ac3 decoder", (vlc_thread_func_t)RunThread, (void *)p_ac3dec))
 107     {
 108         intf_ErrMsg( "ac3dec error: can't spawn ac3 decoder thread\n" );
 109         free (p_ac3dec);
 110         return 0;
 111     }
 112
 113     intf_DbgMsg ("ac3dec debug: ac3 decoder thread (%p) created\n", p_ac3dec);
 114     return p_ac3dec->thread_id;
 115 }
 116
 117 /* Following functions are local */
 118
 119 /*****************************************************************************
 120  * InitThread : initialize an ac3 decoder thread
 121  *****************************************************************************/
 122 static int InitThread (ac3dec_thread_t * p_ac3dec)
 123 {
 124     aout_fifo_t         aout_fifo;
 125     ac3_byte_stream_t * byte_stream;
 126
 127     intf_DbgMsg ("ac3dec debug: initializing ac3 decoder thread %p\n", p_ac3dec);
 128
 129     p_ac3dec->p_data = DECODER_FIFO_START(*p_ac3dec->p_fifo)->p_first;
 130     byte_stream = ac3_byte_stream (&p_ac3dec->ac3_decoder);
 131     byte_stream->p_byte = p_ac3dec->p_data->p_payload_start;
 132     byte_stream->p_end = p_ac3dec->p_data->p_payload_end;
 133     byte_stream->info = p_ac3dec;
 134     vlc_mutex_unlock (&p_ac3dec->p_fifo->data_lock);
 135
 136     aout_fifo.i_type = AOUT_ADEC_STEREO_FIFO;
 137     aout_fifo.i_channels = 2;
 138     aout_fifo.b_stereo = 1;
 139
 140     aout_fifo.l_frame_size = AC3DEC_FRAME_SIZE;
 141
 142     /* Creating the audio output fifo */
 143     if ((p_ac3dec->p_aout_fifo = aout_CreateFifo(p_ac3dec->p_aout, &aout_fifo)) == NULL)
 144     {
 145         return -1;
 146     }
 147
 148     intf_DbgMsg ("ac3dec debug: ac3 decoder thread %p initialized\n", p_ac3dec);
 149     return 0;
 150 }
 151
 152 /*****************************************************************************
 153  * RunThread : ac3 decoder thread
 154  *****************************************************************************/
 155 static void RunThread (ac3dec_thread_t * p_ac3dec)
 156 {
 157     int sync;
 158
 159     intf_DbgMsg ("ac3dec debug: running ac3 decoder thread (%p) (pid == %i)\n", p_ac3dec, getpid());
 160
 161     /* FIXME ! Qu'est-ce que c'est que ce bordel !?!?!?!? --Meuuh */
 162     //msleep (INPUT_PTS_DELAY);
 163
 164     /* Initializing the ac3 decoder thread */
 165     if (InitThread (p_ac3dec)) /* XXX?? */
 166     {
 167         p_ac3dec->b_error = 1;
 168     }
 169
 170     sync = 0;
 171     p_ac3dec->sync_ptr = 0;
 172
 173     /* ac3 decoder thread's main loop */
 174     /* FIXME : do we have enough room to store the decoded frames ?? */
 175     while ((!p_ac3dec->b_die) && (!p_ac3dec->b_error))
 176     {
 177         s16 * buffer;
 178         ac3_sync_info_t sync_info;
 179
 180         if (!sync) { /* have to find a synchro point */
 181             int ptr;
 182             ac3_byte_stream_t * p_byte_stream;
 183
 184             intf_DbgMsg ("ac3dec: sync\n");
 185
 186             p_byte_stream = ac3_byte_stream (&p_ac3dec->ac3_decoder);
 187
 188             /* first read till next ac3 magic header */
 189             do
 190             {
 191                 ac3_byte_stream_next (p_byte_stream);
 192             } while ((!p_ac3dec->sync_ptr) &&
 193                     (!p_ac3dec->b_die) &&
 194                     (!p_ac3dec->b_error));
 195             /* skip the specified number of bytes */
 196
 197             if( p_ac3dec->b_die || p_ac3dec->b_error )
 198             {
 199                 goto bad_frame;
 200             }
 201
 202             ptr = p_ac3dec->sync_ptr;
 203             while (--ptr && (!p_ac3dec->b_die) && (!p_ac3dec->b_error))
 204             {
 205                 if (p_byte_stream->p_byte >= p_byte_stream->p_end)
 206                 {
 207                     ac3_byte_stream_next (p_byte_stream);
 208                 }
 209                 p_byte_stream->p_byte++;
 210             }
 211
 212             if( p_ac3dec->b_die || p_ac3dec->b_error )
 213             {
 214                 goto bad_frame;
 215             }
 216
 217             /* we are in sync now */
 218             sync = 1;
 219             p_ac3dec->sync_ptr = 0;
 220         }
 221
 222         if (DECODER_FIFO_START(*p_ac3dec->p_fifo)->b_has_pts)
 223         {
 224             p_ac3dec->p_aout_fifo->date[p_ac3dec->p_aout_fifo->l_end_frame] = DECODER_FIFO_START(*p_ac3dec->p_fifo)->i_pts;
 225             DECODER_FIFO_START(*p_ac3dec->p_fifo)->b_has_pts = 0;
 226         }
 227         else
 228         {
 229             p_ac3dec->p_aout_fifo->date[p_ac3dec->p_aout_fifo->l_end_frame] = LAST_MDATE;
 230         }
 231
 232         if (ac3_sync_frame (&p_ac3dec->ac3_decoder, &sync_info))
 233         {
 234             sync = 0;
 235             goto bad_frame;
 236         }
 237
 238         p_ac3dec->p_aout_fifo->l_rate = sync_info.sample_rate;
 239
 240         buffer = ((s16 *)p_ac3dec->p_aout_fifo->buffer) + (p_ac3dec->p_aout_fifo->l_end_frame * AC3DEC_FRAME_SIZE);
 241
 242         if (ac3_decode_frame (&p_ac3dec->ac3_decoder, buffer))
 243         {
 244             sync = 0;
 245             goto bad_frame;
 246         }
 247
 248         vlc_mutex_lock (&p_ac3dec->p_aout_fifo->data_lock);
 249         p_ac3dec->p_aout_fifo->l_end_frame = (p_ac3dec->p_aout_fifo->l_end_frame + 1) & AOUT_FIFO_SIZE;
 250         vlc_cond_signal (&p_ac3dec->p_aout_fifo->data_wait);
 251         vlc_mutex_unlock (&p_ac3dec->p_aout_fifo->data_lock);
 252
 253     bad_frame:
 254     }
 255
 256     /* If b_error is set, the ac3 decoder thread enters the error loop */
 257     if (p_ac3dec->b_error)
 258     {
 259         ErrorThread (p_ac3dec);
 260     }
 261
 262     /* End of the ac3 decoder thread */
 263     EndThread (p_ac3dec);
 264 }
 265
 266 /*****************************************************************************
 267  * ErrorThread : ac3 decoder's RunThread() error loop
 268  *****************************************************************************/
 269 static void ErrorThread (ac3dec_thread_t * p_ac3dec)
 270 {
 271     /* We take the lock, because we are going to read/write the start/end
 272      * indexes of the decoder fifo */
 273     vlc_mutex_lock (&p_ac3dec->p_fifo->data_lock);
 274
 275     /* Wait until a `die' order is sent */
 276     while (!p_ac3dec->b_die)
 277     {
 278         /* Trash all received PES packets */
 279         while (!DECODER_FIFO_ISEMPTY(*p_ac3dec->p_fifo))
 280         {
 281             p_ac3dec->p_fifo->pf_delete_pes(p_ac3dec->p_fifo->p_packets_mgt,
 282                     DECODER_FIFO_START(*p_ac3dec->p_fifo));
 283             DECODER_FIFO_INCSTART (*p_ac3dec->p_fifo);
 284         }
 285
 286         /* Waiting for the input thread to put new PES packets in the fifo */
 287         vlc_cond_wait (&p_ac3dec->p_fifo->data_wait,
 288                        &p_ac3dec->p_fifo->data_lock);
 289     }
 290
 291     /* We can release the lock before leaving */
 292     vlc_mutex_unlock (&p_ac3dec->p_fifo->data_lock);
 293 }
 294
 295 /*****************************************************************************
 296  * EndThread : ac3 decoder thread destruction
 297  *****************************************************************************/
 298 static void EndThread (ac3dec_thread_t * p_ac3dec)
 299 {
 300     intf_DbgMsg ("ac3dec debug: destroying ac3 decoder thread %p\n", p_ac3dec);
 301
 302     /* If the audio output fifo was created, we destroy it */
 303     if (p_ac3dec->p_aout_fifo != NULL)
 304     {
 305         aout_DestroyFifo (p_ac3dec->p_aout_fifo);
 306
 307         /* Make sure the output thread leaves the NextFrame() function */
 308         vlc_mutex_lock (&(p_ac3dec->p_aout_fifo->data_lock));
 309         vlc_cond_signal (&(p_ac3dec->p_aout_fifo->data_wait));
 310         vlc_mutex_unlock (&(p_ac3dec->p_aout_fifo->data_lock));
 311     }
 312
 313     /* Destroy descriptor */
 314     free (p_ac3dec);
 315
 316     intf_DbgMsg ("ac3dec debug: ac3 decoder thread %p destroyed\n", p_ac3dec);
 317 }
 318
 319 void ac3_byte_stream_next (ac3_byte_stream_t * p_byte_stream)
 320 {
 321     ac3dec_thread_t * p_ac3dec = p_byte_stream->info;
 322
 323     /* We are looking for the next TS packet that contains real data,
 324      * and not just a PES header */
 325     do
 326     {
 327         /* We were reading the last TS packet of this PES packet... It's
 328          * time to jump to the next PES packet */
 329         if (p_ac3dec->p_data->p_next == NULL)
 330         {
 331             int ptr;
 332
 333             /* We are going to read/write the start and end indexes of the
 334              * decoder fifo and to use the fifo's conditional variable,
 335              * that's why we need to take the lock before */
 336             vlc_mutex_lock (&p_ac3dec->p_fifo->data_lock);
 337
 338             /* Is the input thread dying ? */
 339             if (p_ac3dec->p_fifo->b_die)
 340             {
 341                 vlc_mutex_unlock (&p_ac3dec->p_fifo->data_lock);
 342                 return;
 343             }
 344
 345             /* We should increase the start index of the decoder fifo, but
 346              * if we do this now, the input thread could overwrite the
 347              * pointer to the current PES packet, and we weren't able to
 348              * give it back to the netlist. That's why we free the PES
 349              * packet first. */
 350             p_ac3dec->p_fifo->pf_delete_pes(p_ac3dec->p_fifo->p_packets_mgt,
 351                     DECODER_FIFO_START(*p_ac3dec->p_fifo));
 352
 353             DECODER_FIFO_INCSTART (*p_ac3dec->p_fifo);
 354
 355             while (DECODER_FIFO_ISEMPTY(*p_ac3dec->p_fifo))
 356             {
 357                 vlc_cond_wait(&p_ac3dec->p_fifo->data_wait, &p_ac3dec->p_fifo->data_lock);
 358
 359                 if (p_ac3dec->p_fifo->b_die)
 360                 {
 361                     vlc_mutex_unlock (&p_ac3dec->p_fifo->data_lock);
 362                     return;
 363                 }
 364             }
 365
 366             /* The next byte could be found in the next PES packet */
 367             p_ac3dec->p_data = DECODER_FIFO_START(*p_ac3dec->p_fifo)->p_first;
 368
 369             /* parse ac3 magic header */
 370             ptr = *(p_ac3dec->p_data->p_payload_start + 2);
 371             ptr <<= 8;
 372             ptr |= *(p_ac3dec->p_data->p_payload_start + 3);
 373             p_ac3dec->sync_ptr = ptr;
 374             p_ac3dec->p_data->p_payload_start += 4;
 375
 376             /* We can release the fifo's data lock */
 377             vlc_mutex_unlock (&p_ac3dec->p_fifo->data_lock);
 378         }
 379         /* Perhaps the next TS packet of the current PES packet contains
 380          * real data (ie its payload's size is greater than 0) */
 381         else
 382         {
 383             p_ac3dec->p_data = p_ac3dec->p_data->p_next;
 384         }
 385     } while (p_ac3dec->p_data->p_payload_start == p_ac3dec->p_data->p_payload_end);
 386     p_byte_stream->p_byte = p_ac3dec->p_data->p_payload_start;
 387     p_byte_stream->p_end = p_ac3dec->p_data->p_payload_end;
 388 }