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