1 /*****************************************************************************
2 * decoder.c: Functions for the management of decoders
3 *****************************************************************************
4 * Copyright (C) 1999-2004 the VideoLAN team
7 * Authors: Christophe Massiot <massiot@via.ecp.fr>
8 * Gildas Bazin <gbazin@videolan.org>
9 * Laurent Aimar <fenrir@via.ecp.fr>
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License as published by
13 * the Free Software Foundation; either version 2 of the License, or
14 * (at your option) any later version.
16 * This program is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 * GNU General Public License for more details.
21 * You should have received a copy of the GNU General Public License
22 * along with this program; if not, write to the Free Software
23 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
24 *****************************************************************************/
26 /*****************************************************************************
28 *****************************************************************************/
34 #include <vlc_common.h>
36 #include <vlc_block.h>
40 #include <vlc_codec.h>
43 #include <vlc_interface.h>
44 #include "audio_output/aout_internal.h"
45 #include "stream_output/stream_output.h"
46 #include "input_internal.h"
47 #include "input_clock.h"
48 #include "input_decoder.h"
50 #include "../video_output/vout_internal.h"
52 static decoder_t *CreateDecoder( input_thread_t *, es_format_t *, int, sout_instance_t *p_sout );
53 static void DeleteDecoder( decoder_t * );
55 static void *DecoderThread( vlc_object_t * );
56 static int DecoderProcess( decoder_t * p_dec, block_t *p_block );
57 static void DecoderOutputChangePause( decoder_t *p_dec, bool b_paused, mtime_t i_date );
59 /* Buffers allocation callbacks for the decoders */
60 static aout_buffer_t *aout_new_buffer( decoder_t *, int );
61 static void aout_del_buffer( decoder_t *, aout_buffer_t * );
63 static picture_t *vout_new_buffer( decoder_t * );
64 static void vout_del_buffer( decoder_t *, picture_t * );
65 static void vout_link_picture( decoder_t *, picture_t * );
66 static void vout_unlink_picture( decoder_t *, picture_t * );
68 static subpicture_t *spu_new_buffer( decoder_t * );
69 static void spu_del_buffer( decoder_t *, subpicture_t * );
71 static es_format_t null_es_format;
73 struct decoder_owner_sys_t
77 int64_t i_preroll_end;
79 input_thread_t *p_input;
80 input_clock_t *p_clock;
83 vout_thread_t *p_spu_vout;
87 sout_instance_t *p_sout;
88 sout_packetizer_input_t *p_sout_input;
90 /* Some decoders require already packetized data (ie. not truncated) */
91 decoder_t *p_packetizer;
93 /* Current format in use by the output */
101 /* Lock for communication with decoder thread */
105 /* -- These variables need locking on write(only) -- */
106 aout_instance_t *p_aout;
107 aout_input_t *p_aout_input;
109 vout_thread_t *p_vout;
111 /* -- Theses variables need locking on read *and* write -- */
115 mtime_t i_pause_date;
122 decoder_t *pp_decoder[4];
130 static void DecoderUnsupportedCodec( decoder_t *p_dec, vlc_fourcc_t codec )
132 msg_Err( p_dec, "no suitable decoder module for fourcc `%4.4s'.\n"
133 "VLC probably does not support this sound or video format.",
135 intf_UserFatal( p_dec, false, _("No suitable decoder module"),
136 _("VLC does not support the audio or video format \"%4.4s\". "
137 "Unfortunately there is no way for you to fix this."), (char*)&codec );
140 /* decoder_GetInputAttachment:
142 input_attachment_t *decoder_GetInputAttachment( decoder_t *p_dec,
143 const char *psz_name )
145 input_attachment_t *p_attachment;
146 if( input_Control( p_dec->p_owner->p_input, INPUT_GET_ATTACHMENT, &p_attachment, psz_name ) )
150 /* decoder_GetInputAttachments:
152 int decoder_GetInputAttachments( decoder_t *p_dec,
153 input_attachment_t ***ppp_attachment,
156 return input_Control( p_dec->p_owner->p_input, INPUT_GET_ATTACHMENTS,
157 ppp_attachment, pi_attachment );
159 /* decoder_GetDisplayDate:
161 mtime_t decoder_GetDisplayDate( decoder_t *p_dec, mtime_t i_ts )
163 decoder_owner_sys_t *p_owner = p_dec->p_owner;
165 if( !p_owner->p_clock )
167 return input_clock_GetTS( p_owner->p_clock, NULL, p_owner->p_input->i_pts_delay, i_ts );
169 /* decoder_GetDisplayRate:
171 int decoder_GetDisplayRate( decoder_t *p_dec )
173 decoder_owner_sys_t *p_owner = p_dec->p_owner;
175 if( !p_owner->p_clock )
176 return INPUT_RATE_DEFAULT;
177 return input_clock_GetRate( p_owner->p_clock );
181 * Spawns a new decoder thread
183 * \param p_input the input thread
184 * \param p_es the es descriptor
185 * \return the spawned decoder object
187 decoder_t *input_DecoderNew( input_thread_t *p_input,
188 es_format_t *fmt, input_clock_t *p_clock, sout_instance_t *p_sout )
190 decoder_t *p_dec = NULL;
194 (void)b_force_decoder;
196 /* If we are in sout mode, search for packetizer module */
199 /* Create the decoder configuration structure */
200 p_dec = CreateDecoder( p_input, fmt, VLC_OBJECT_PACKETIZER, p_sout );
203 msg_Err( p_input, "could not create packetizer" );
204 intf_UserFatal( p_input, false, _("Streaming / Transcoding failed"),
205 _("VLC could not open the packetizer module.") );
212 /* Create the decoder configuration structure */
213 p_dec = CreateDecoder( p_input, fmt, VLC_OBJECT_DECODER, p_sout );
216 msg_Err( p_input, "could not create decoder" );
217 intf_UserFatal( p_input, false, _("Streaming / Transcoding failed"),
218 _("VLC could not open the decoder module.") );
223 if( !p_dec->p_module )
225 DecoderUnsupportedCodec( p_dec, fmt->i_codec );
227 DeleteDecoder( p_dec );
228 vlc_object_release( p_dec );
232 p_dec->p_owner->p_clock = p_clock;
234 if( p_sout && p_sout == p_input->p->p_sout && p_input->p->input.b_can_pace_control )
236 msg_Dbg( p_input, "stream out mode -> no decoder thread" );
237 p_dec->p_owner->b_own_thread = false;
241 var_Get( p_input, "minimize-threads", &val );
242 p_dec->p_owner->b_own_thread = !val.b_bool;
245 if( p_dec->p_owner->b_own_thread )
248 if( fmt->i_cat == AUDIO_ES )
249 i_priority = VLC_THREAD_PRIORITY_AUDIO;
251 i_priority = VLC_THREAD_PRIORITY_VIDEO;
253 /* Spawn the decoder thread */
254 if( vlc_thread_create( p_dec, "decoder", DecoderThread,
255 i_priority, false ) )
257 msg_Err( p_dec, "cannot spawn decoder thread" );
258 module_unneed( p_dec, p_dec->p_module );
259 DeleteDecoder( p_dec );
260 vlc_object_release( p_dec );
269 * Kills a decoder thread and waits until it's finished
271 * \param p_input the input thread
272 * \param p_es the es descriptor
275 void input_DecoderDelete( decoder_t *p_dec )
277 decoder_owner_sys_t *p_owner = p_dec->p_owner;
279 vlc_object_kill( p_dec );
281 if( p_owner->b_own_thread )
283 /* Make sure we aren't paused anymore */
284 vlc_mutex_lock( &p_owner->lock );
285 if( p_owner->b_paused )
287 p_owner->b_paused = false;
288 vlc_cond_signal( &p_owner->wait );
290 vlc_mutex_unlock( &p_owner->lock );
292 /* Make sure the thread leaves the function by
293 * sending it an empty block. */
294 block_t *p_block = block_New( p_dec, 0 );
295 input_DecoderDecode( p_dec, p_block );
297 vlc_thread_join( p_dec );
299 /* Don't module_unneed() here because of the dll loader that wants
300 * close() in the same thread than open()/decode() */
305 input_DecoderDecode( p_dec, NULL );
307 module_unneed( p_dec, p_dec->p_module );
311 if( p_dec->p_owner->cc.b_supported )
314 for( i = 0; i < 4; i++ )
315 input_DecoderSetCcState( p_dec, false, i );
318 /* Delete decoder configuration */
319 DeleteDecoder( p_dec );
321 /* Delete the decoder */
322 vlc_object_release( p_dec );
326 * Put a block_t in the decoder's fifo.
328 * \param p_dec the decoder object
329 * \param p_block the data block
331 void input_DecoderDecode( decoder_t * p_dec, block_t *p_block )
333 decoder_owner_sys_t *p_owner = p_dec->p_owner;
335 if( p_owner->b_own_thread )
337 if( p_owner->p_input->p->b_out_pace_control )
340 while( !p_dec->b_die && !p_dec->b_error &&
341 block_FifoCount( p_owner->p_fifo ) > 10 )
346 else if( block_FifoSize( p_owner->p_fifo ) > 50000000 /* 50 MB */ )
348 /* FIXME: ideally we would check the time amount of data
349 * in the fifo instead of its size. */
350 msg_Warn( p_dec, "decoder/packetizer fifo full (data not "
351 "consumed quickly enough), resetting fifo!" );
352 block_FifoEmpty( p_owner->p_fifo );
355 block_FifoPut( p_owner->p_fifo, p_block );
359 if( p_dec->b_error || ( p_block && p_block->i_buffer <= 0 ) )
362 block_Release( p_block );
366 DecoderProcess( p_dec, p_block );
371 bool input_DecoderIsEmpty( decoder_t * p_dec )
373 if( p_dec->p_owner->b_own_thread &&
374 block_FifoCount( p_dec->p_owner->p_fifo ) > 0 )
381 void input_DecoderIsCcPresent( decoder_t *p_dec, bool pb_present[4] )
383 decoder_owner_sys_t *p_owner = p_dec->p_owner;
386 vlc_mutex_lock( &p_owner->lock );
387 for( i = 0; i < 4; i++ )
388 pb_present[i] = p_owner->cc.pb_present[i];
389 vlc_mutex_unlock( &p_owner->lock );
391 int input_DecoderSetCcState( decoder_t *p_dec, bool b_decode, int i_channel )
393 decoder_owner_sys_t *p_owner = p_dec->p_owner;
395 //msg_Warn( p_dec, "input_DecoderSetCcState: %d @%d", b_decode, i_channel );
397 if( i_channel < 0 || i_channel >= 4 || !p_owner->cc.pb_present[i_channel] )
402 static const vlc_fourcc_t fcc[4] = {
403 VLC_FOURCC('c', 'c', '1', ' '),
404 VLC_FOURCC('c', 'c', '2', ' '),
405 VLC_FOURCC('c', 'c', '3', ' '),
406 VLC_FOURCC('c', 'c', '4', ' '),
411 es_format_Init( &fmt, SPU_ES, fcc[i_channel] );
412 p_cc = CreateDecoder( p_owner->p_input, &fmt, VLC_OBJECT_DECODER, p_owner->p_sout );
415 msg_Err( p_dec, "could not create decoder" );
416 intf_UserFatal( p_dec, false, _("Streaming / Transcoding failed"),
417 _("VLC could not open the decoder module.") );
420 else if( !p_cc->p_module )
422 DecoderUnsupportedCodec( p_dec, fcc[i_channel] );
423 DeleteDecoder( p_cc );
424 vlc_object_release( p_cc );
427 p_cc->p_owner->p_clock = p_owner->p_clock;
429 vlc_mutex_lock( &p_owner->lock );
430 p_owner->cc.pp_decoder[i_channel] = p_cc;
431 vlc_mutex_unlock( &p_owner->lock );
437 vlc_mutex_lock( &p_owner->lock );
438 p_cc = p_owner->cc.pp_decoder[i_channel];
439 p_owner->cc.pp_decoder[i_channel] = NULL;
440 vlc_mutex_unlock( &p_owner->lock );
444 vlc_object_kill( p_cc );
445 module_unneed( p_cc, p_cc->p_module );
446 DeleteDecoder( p_cc );
447 vlc_object_release( p_cc );
452 int input_DecoderGetCcState( decoder_t *p_dec, bool *pb_decode, int i_channel )
454 decoder_owner_sys_t *p_owner = p_dec->p_owner;
457 if( i_channel < 0 || i_channel >= 4 || !p_owner->cc.pb_present[i_channel] )
460 vlc_mutex_lock( &p_owner->lock );
461 *pb_decode = p_owner->cc.pp_decoder[i_channel] != NULL;
462 vlc_mutex_unlock( &p_owner->lock );
466 void input_DecoderChangePause( decoder_t *p_dec, bool b_paused, mtime_t i_date )
468 decoder_owner_sys_t *p_owner = p_dec->p_owner;
470 vlc_mutex_lock( &p_owner->lock );
472 assert( !p_owner->b_paused || !b_paused );
473 p_owner->b_paused = b_paused;
474 p_owner->i_pause_date = i_date;
475 if( p_owner->b_own_thread )
476 vlc_cond_signal( &p_owner->wait );
478 DecoderOutputChangePause( p_dec, b_paused, i_date );
479 vlc_mutex_unlock( &p_owner->lock );
482 void input_DecoderChangeDelay( decoder_t *p_dec, mtime_t i_delay )
484 decoder_owner_sys_t *p_owner = p_dec->p_owner;
486 vlc_mutex_lock( &p_owner->lock );
487 p_owner->i_ts_delay = i_delay;
488 vlc_mutex_unlock( &p_owner->lock );
491 void input_DecoderFlush( decoder_t *p_dec )
493 decoder_owner_sys_t *p_owner = p_dec->p_owner;
497 if( p_owner->b_own_thread )
498 block_FifoEmpty( p_owner->p_fifo );
500 /* Send a special block */
501 p_null = block_New( p_dec, 128 );
502 p_null->i_flags |= BLOCK_FLAG_DISCONTINUITY;
503 p_null->i_flags |= BLOCK_FLAG_CORE_FLUSH;
504 if( !p_dec->fmt_in.b_packetized )
505 p_null->i_flags |= BLOCK_FLAG_CORRUPTED;
506 memset( p_null->p_buffer, 0, p_null->i_buffer );
508 input_DecoderDecode( p_dec, p_null );
512 * Create a decoder object
514 * \param p_input the input thread
515 * \param p_es the es descriptor
516 * \param i_object_type Object type as define in include/vlc_objects.h
517 * \return the decoder object
519 static decoder_t * CreateDecoder( input_thread_t *p_input,
520 es_format_t *fmt, int i_object_type, sout_instance_t *p_sout )
523 decoder_owner_sys_t *p_owner;
526 p_dec = vlc_object_create( p_input, i_object_type );
530 p_dec->pf_decode_audio = NULL;
531 p_dec->pf_decode_video = NULL;
532 p_dec->pf_decode_sub = NULL;
533 p_dec->pf_get_cc = NULL;
534 p_dec->pf_packetize = NULL;
536 /* Initialize the decoder fifo */
537 p_dec->p_module = NULL;
539 memset( &null_es_format, 0, sizeof(es_format_t) );
540 es_format_Copy( &p_dec->fmt_in, fmt );
541 es_format_Copy( &p_dec->fmt_out, &null_es_format );
543 /* Allocate our private structure for the decoder */
544 p_dec->p_owner = p_owner = malloc( sizeof( decoder_owner_sys_t ) );
545 if( p_dec->p_owner == NULL )
547 vlc_object_release( p_dec );
550 p_dec->p_owner->b_own_thread = true;
551 p_dec->p_owner->i_preroll_end = -1;
552 p_dec->p_owner->i_last_rate = INPUT_RATE_DEFAULT;
553 p_dec->p_owner->p_input = p_input;
554 p_dec->p_owner->p_aout = NULL;
555 p_dec->p_owner->p_aout_input = NULL;
556 p_dec->p_owner->p_vout = NULL;
557 p_dec->p_owner->p_spu_vout = NULL;
558 p_dec->p_owner->i_spu_channel = 0;
559 p_dec->p_owner->i_spu_order = 0;
560 p_dec->p_owner->p_sout = p_sout;
561 p_dec->p_owner->p_sout_input = NULL;
562 p_dec->p_owner->p_packetizer = NULL;
565 if( ( p_dec->p_owner->p_fifo = block_FifoNew() ) == NULL )
567 free( p_dec->p_owner );
568 vlc_object_release( p_dec );
572 /* Set buffers allocation callbacks for the decoders */
573 p_dec->pf_aout_buffer_new = aout_new_buffer;
574 p_dec->pf_aout_buffer_del = aout_del_buffer;
575 p_dec->pf_vout_buffer_new = vout_new_buffer;
576 p_dec->pf_vout_buffer_del = vout_del_buffer;
577 p_dec->pf_picture_link = vout_link_picture;
578 p_dec->pf_picture_unlink = vout_unlink_picture;
579 p_dec->pf_spu_buffer_new = spu_new_buffer;
580 p_dec->pf_spu_buffer_del = spu_del_buffer;
582 vlc_object_attach( p_dec, p_input );
584 /* Find a suitable decoder/packetizer module */
585 if( i_object_type == VLC_OBJECT_DECODER )
586 p_dec->p_module = module_need( p_dec, "decoder", "$codec", 0 );
588 p_dec->p_module = module_need( p_dec, "packetizer", "$packetizer", 0 );
590 /* Check if decoder requires already packetized data */
591 if( i_object_type == VLC_OBJECT_DECODER &&
592 p_dec->b_need_packetized && !p_dec->fmt_in.b_packetized )
594 p_dec->p_owner->p_packetizer =
595 vlc_object_create( p_input, VLC_OBJECT_PACKETIZER );
596 if( p_dec->p_owner->p_packetizer )
598 es_format_Copy( &p_dec->p_owner->p_packetizer->fmt_in,
601 es_format_Copy( &p_dec->p_owner->p_packetizer->fmt_out,
604 vlc_object_attach( p_dec->p_owner->p_packetizer, p_input );
606 p_dec->p_owner->p_packetizer->p_module =
607 module_need( p_dec->p_owner->p_packetizer,
608 "packetizer", "$packetizer", 0 );
610 if( !p_dec->p_owner->p_packetizer->p_module )
612 es_format_Clean( &p_dec->p_owner->p_packetizer->fmt_in );
613 vlc_object_detach( p_dec->p_owner->p_packetizer );
614 vlc_object_release( p_dec->p_owner->p_packetizer );
619 /* Copy ourself the input replay gain */
620 if( fmt->i_cat == AUDIO_ES )
622 for( i = 0; i < AUDIO_REPLAY_GAIN_MAX; i++ )
624 if( !p_dec->fmt_out.audio_replay_gain.pb_peak[i] )
626 p_dec->fmt_out.audio_replay_gain.pb_peak[i] = fmt->audio_replay_gain.pb_peak[i];
627 p_dec->fmt_out.audio_replay_gain.pf_peak[i] = fmt->audio_replay_gain.pf_peak[i];
629 if( !p_dec->fmt_out.audio_replay_gain.pb_gain[i] )
631 p_dec->fmt_out.audio_replay_gain.pb_gain[i] = fmt->audio_replay_gain.pb_gain[i];
632 p_dec->fmt_out.audio_replay_gain.pf_gain[i] = fmt->audio_replay_gain.pf_gain[i];
637 p_owner->cc.b_supported = false;
638 if( i_object_type == VLC_OBJECT_DECODER )
640 if( p_owner->p_packetizer && p_owner->p_packetizer->pf_get_cc )
641 p_owner->cc.b_supported = true;
642 if( p_dec->pf_get_cc )
643 p_owner->cc.b_supported = true;
646 vlc_mutex_init( &p_owner->lock );
647 vlc_cond_init( &p_owner->wait );
648 p_owner->b_paused = false;
649 p_owner->i_pause_date = 0;
650 for( i = 0; i < 4; i++ )
652 p_owner->cc.pb_present[i] = false;
653 p_owner->cc.pp_decoder[i] = NULL;
655 p_owner->i_ts_delay = 0;
660 * The decoding main loop
662 * \param p_dec the decoder
664 static void *DecoderThread( vlc_object_t *p_this )
666 decoder_t *p_dec = (decoder_t *)p_this;
667 decoder_owner_sys_t *p_owner = p_dec->p_owner;
670 int canc = vlc_savecancel();
672 /* The decoder's main loop */
673 while( vlc_object_alive( p_dec ) && !p_dec->b_error )
675 if( ( p_block = block_FifoGet( p_owner->p_fifo ) ) == NULL )
677 p_dec->b_error = true;
681 if( DecoderProcess( p_dec, p_block ) != VLC_SUCCESS )
685 while( vlc_object_alive( p_dec ) )
687 /* Trash all received PES packets */
688 p_block = block_FifoGet( p_owner->p_fifo );
690 block_Release( p_block );
693 /* We do it here because of the dll loader that wants close() in the
694 * same thread than open()/decode() */
695 module_unneed( p_dec, p_dec->p_module );
696 vlc_restorecancel( canc );
700 static void DecoderWaitUnpause( decoder_t *p_dec )
702 decoder_owner_sys_t *p_owner = p_dec->p_owner;
704 vlc_mutex_lock( &p_owner->lock );
706 while( p_owner->b_paused )
707 vlc_cond_wait( &p_owner->wait, &p_owner->lock );
709 vlc_mutex_unlock( &p_owner->lock );
712 static void DecoderGetDelays( decoder_t *p_dec, mtime_t *pi_ts_delay, mtime_t *pi_es_delay )
714 decoder_owner_sys_t *p_owner = p_dec->p_owner;
716 *pi_ts_delay = p_owner->p_input->i_pts_delay;
718 vlc_mutex_lock( &p_owner->lock );
720 *pi_es_delay = p_owner->i_ts_delay;
722 vlc_mutex_unlock( &p_owner->lock );
725 static void DecoderOutputChangePause( decoder_t *p_dec, bool b_paused, mtime_t i_date )
727 decoder_owner_sys_t *p_owner = p_dec->p_owner;
729 vlc_assert_locked( &p_owner->lock );
731 /* XXX only audio and video output have to be paused.
732 * - for sout it is useless
733 * - for subs, it is done by the vout
735 if( p_dec->fmt_in.i_cat == AUDIO_ES )
737 if( p_owner->p_aout && p_owner->p_aout_input )
738 aout_DecChangePause( p_owner->p_aout, p_owner->p_aout_input,
741 else if( p_dec->fmt_in.i_cat == VIDEO_ES )
743 if( p_owner->p_vout )
744 vout_ChangePause( p_owner->p_vout, b_paused, i_date );
747 static inline void DecoderUpdatePreroll( int64_t *pi_preroll, const block_t *p )
749 if( p->i_flags & (BLOCK_FLAG_PREROLL|BLOCK_FLAG_DISCONTINUITY) )
750 *pi_preroll = INT64_MAX;
751 else if( p->i_pts > 0 )
752 *pi_preroll = __MIN( *pi_preroll, p->i_pts );
753 else if( p->i_dts > 0 )
754 *pi_preroll = __MIN( *pi_preroll, p->i_dts );
757 static mtime_t DecoderTeletextFixTs( mtime_t i_ts, mtime_t i_ts_delay )
759 mtime_t current_date = mdate();
761 /* FIXME I don't really like that, es_out SHOULD do it using the video pts */
762 if( !i_ts || i_ts > current_date + 10000000 || i_ts < current_date )
764 /* ETSI EN 300 472 Annex A : do not take into account the PTS
765 * for teletext streams. */
766 return current_date + 400000 + i_ts_delay;
771 static void DecoderSoutBufferFixTs( block_t *p_block,
772 input_clock_t *p_clock,
773 mtime_t i_ts_delay, mtime_t i_es_delay,
778 if( !p_block->i_dts && !p_block->i_pts )
779 p_block->i_rate = input_clock_GetRate( p_clock );
781 if( p_block->i_dts > 0 )
782 p_block->i_dts = input_clock_GetTS( p_clock, &p_block->i_rate,
783 i_ts_delay, p_block->i_dts + i_es_delay);
785 if( p_block->i_pts > 0 )
786 p_block->i_pts = input_clock_GetTS( p_clock, &p_block->i_rate,
787 i_ts_delay, p_block->i_pts + i_es_delay );
789 if( p_block->i_length > 0 )
790 p_block->i_length = ( p_block->i_length * p_block->i_rate +
791 INPUT_RATE_DEFAULT-1 ) / INPUT_RATE_DEFAULT;
794 p_block->i_pts = DecoderTeletextFixTs( p_block->i_pts, i_ts_delay );
796 static void DecoderAoutBufferFixTs( aout_buffer_t *p_buffer, int *pi_rate,
797 input_clock_t *p_clock,
798 mtime_t i_ts_delay, mtime_t i_es_delay )
800 /* sout display module does not set clock */
804 if( !p_buffer->start_date && !p_buffer->end_date )
805 *pi_rate = input_clock_GetRate( p_clock );
807 if( p_buffer->start_date > 0 )
808 p_buffer->start_date =
809 input_clock_GetTS( p_clock, pi_rate,
810 i_ts_delay, p_buffer->start_date + i_es_delay );
812 if( p_buffer->end_date > 0 )
814 input_clock_GetTS( p_clock, pi_rate,
815 i_ts_delay, p_buffer->end_date + i_es_delay );
817 static void DecoderVoutBufferFixTs( picture_t *p_picture, int *pi_rate,
818 input_clock_t *p_clock,
819 mtime_t i_ts_delay, mtime_t i_es_delay )
821 /* sout display module does not set clock */
825 if( p_picture->date > 0 )
827 input_clock_GetTS( p_clock, pi_rate,
828 i_ts_delay, p_picture->date + i_es_delay );
830 static void DecoderSpuBufferFixTs( subpicture_t *p_subpic,
831 input_clock_t *p_clock,
832 mtime_t i_ts_delay, mtime_t i_es_delay,
835 bool b_ephemere = p_subpic->i_start == p_subpic->i_stop;
837 /* sout display module does not set clock */
841 if( p_subpic->i_start > 0 )
843 input_clock_GetTS( p_clock, NULL,
844 i_ts_delay, p_subpic->i_start + i_es_delay );
846 if( p_subpic->i_stop > 0 )
848 input_clock_GetTS( p_clock, NULL,
849 i_ts_delay, p_subpic->i_stop + i_es_delay );
851 /* Do not create ephemere picture because of rounding errors */
852 if( !b_ephemere && p_subpic->i_start == p_subpic->i_stop )
856 p_subpic->i_start = DecoderTeletextFixTs( p_subpic->i_start, i_ts_delay );
859 static void DecoderDecodeAudio( decoder_t *p_dec, block_t *p_block )
861 decoder_owner_sys_t *p_owner = p_dec->p_owner;
862 input_thread_t *p_input = p_owner->p_input;
863 input_clock_t *p_clock = p_owner->p_clock;
864 aout_buffer_t *p_aout_buf;
869 while( (p_aout_buf = p_dec->pf_decode_audio( p_dec, &p_block )) )
871 aout_instance_t *p_aout = p_owner->p_aout;
872 aout_input_t *p_aout_input = p_owner->p_aout_input;
878 /* It prevent freezing VLC in case of broken decoder */
879 aout_DecDeleteBuffer( p_aout, p_aout_input, p_aout_buf );
881 block_Release( p_block );
886 if( p_aout_buf->start_date < p_owner->i_preroll_end )
888 aout_DecDeleteBuffer( p_aout, p_aout_input, p_aout_buf );
892 if( p_owner->i_preroll_end > 0 )
894 /* FIXME TODO flush audio output (don't know how to do that) */
895 msg_Dbg( p_dec, "End of audio preroll" );
896 p_owner->i_preroll_end = -1;
899 DecoderWaitUnpause( p_dec );
901 int i_rate = INPUT_RATE_DEFAULT;
904 DecoderGetDelays( p_dec, &i_ts_delay, &i_es_delay );
906 DecoderAoutBufferFixTs( p_aout_buf, &i_rate, p_clock, i_ts_delay, i_es_delay );
908 if( !p_clock && p_block && p_block->i_rate > 0 )
909 i_rate = p_block->i_rate;
911 /* FIXME TODO take care of audio-delay for mdate check */
912 const mtime_t i_max_date = mdate() + i_ts_delay +
913 i_es_delay * i_rate / INPUT_RATE_DEFAULT + AOUT_MAX_ADVANCE_TIME;
915 if( p_aout_buf->start_date > 0 &&
916 p_aout_buf->start_date <= i_max_date &&
917 i_rate >= INPUT_RATE_DEFAULT/AOUT_MAX_INPUT_RATE &&
918 i_rate <= INPUT_RATE_DEFAULT*AOUT_MAX_INPUT_RATE )
920 /* Wait if we are too early
921 * FIXME that's plain ugly to do it here */
922 mwait( p_aout_buf->start_date - AOUT_MAX_PREPARE_TIME );
924 if( !aout_DecPlay( p_aout, p_aout_input, p_aout_buf, i_rate ) )
926 i_lost += aout_DecGetResetLost( p_aout, p_aout_input );
930 if( p_aout_buf->start_date <= 0 )
932 msg_Warn( p_dec, "non-dated audio buffer received" );
934 else if( p_aout_buf->start_date > i_max_date )
936 msg_Warn( p_aout, "received buffer in the future (%"PRId64")",
937 p_aout_buf->start_date - mdate() );
940 aout_DecDeleteBuffer( p_aout, p_aout_input, p_aout_buf );
945 /* Update ugly stat */
946 if( i_decoded > 0 || i_lost > 0 || i_played > 0 )
948 vlc_mutex_lock( &p_input->p->counters.counters_lock);
950 stats_UpdateInteger( p_dec, p_input->p->counters.p_lost_abuffers,
952 stats_UpdateInteger( p_dec, p_input->p->counters.p_played_abuffers,
954 stats_UpdateInteger( p_dec, p_input->p->counters.p_decoded_audio,
957 vlc_mutex_unlock( &p_input->p->counters.counters_lock);
960 static void DecoderGetCc( decoder_t *p_dec, decoder_t *p_dec_cc )
962 decoder_owner_sys_t *p_owner = p_dec->p_owner;
968 assert( p_dec_cc->pf_get_cc != NULL );
970 /* Do not try retreiving CC if not wanted (sout) or cannot be retreived */
971 if( !p_owner->cc.b_supported )
974 p_cc = p_dec_cc->pf_get_cc( p_dec_cc, pb_present );
978 vlc_mutex_lock( &p_owner->lock );
979 for( i = 0, i_cc_decoder = 0; i < 4; i++ )
981 p_owner->cc.pb_present[i] |= pb_present[i];
982 if( p_owner->cc.pp_decoder[i] )
986 for( i = 0; i < 4; i++ )
988 if( !p_owner->cc.pp_decoder[i] )
991 if( i_cc_decoder > 1 )
992 DecoderProcess( p_owner->cc.pp_decoder[i], block_Duplicate( p_cc ) );
994 DecoderProcess( p_owner->cc.pp_decoder[i], p_cc );
997 vlc_mutex_unlock( &p_owner->lock );
999 static void VoutDisplayedPicture( vout_thread_t *p_vout, picture_t *p_pic )
1001 vlc_mutex_lock( &p_vout->picture_lock );
1003 if( p_pic->i_status == READY_PICTURE )
1005 /* Grr cannot destroy ready picture by myself so be sure vout won't like it */
1008 else if( p_pic->i_refcount > 0 )
1010 p_pic->i_status = DISPLAYED_PICTURE;
1014 p_pic->i_status = DESTROYED_PICTURE;
1015 picture_CleanupQuant( p_pic );
1016 p_vout->i_heap_size--;
1019 vlc_mutex_unlock( &p_vout->picture_lock );
1021 static void VoutFlushPicture( vout_thread_t *p_vout, mtime_t i_max_date )
1024 vlc_mutex_lock( &p_vout->picture_lock );
1025 for( i = 0; i < p_vout->render.i_pictures; i++ )
1027 picture_t *p_pic = p_vout->render.pp_picture[i];
1029 if( p_pic->i_status == READY_PICTURE ||
1030 p_pic->i_status == DISPLAYED_PICTURE )
1032 /* We cannot change picture status if it is in READY_PICTURE state,
1033 * Just make sure they won't be displayed */
1034 if( p_pic->date > i_max_date )
1035 p_pic->date = i_max_date;
1038 vlc_mutex_unlock( &p_vout->picture_lock );
1042 static void DecoderOptimizePtsDelay( decoder_t *p_dec )
1044 input_thread_t *p_input = p_dec->p_owner->p_input;
1045 vout_thread_t *p_vout = p_dec->p_owner->p_vout;
1046 input_thread_private_t *p_priv = p_input->p;
1048 picture_t *p_old = NULL;
1049 picture_t *p_young = NULL;
1052 /* Enable with --auto-adjust-pts-delay */
1053 if( !p_priv->pts_adjust.b_auto_adjust )
1056 for( i = 0; i < I_RENDERPICTURES; i++ )
1058 picture_t *p_pic = PP_RENDERPICTURE[i];
1060 if( p_pic->i_status != READY_PICTURE )
1063 if( !p_old || p_pic->date < p_old->date )
1065 if( !p_young || p_pic->date > p_young->date )
1069 if( !p_young || !p_old )
1072 /* Try to find if we can reduce the pts
1073 * This first draft is way too simple, and we can't say if the
1074 * algo will converge. It's also full of constants.
1075 * But this simple algo allows to reduce the latency
1077 * The whole point of this, is to bypass the pts_delay set
1078 * by the access but also the delay arbitraly set by
1079 * the remote server.
1080 * Actually the remote server's muxer may set up a
1081 * pts<->dts delay in the muxed stream. That is
1082 * why we may end up in having a negative pts_delay,
1083 * to compensate that artificial delay. */
1084 const mtime_t i_buffer_length = p_young->date - p_old->date;
1085 int64_t i_pts_slide = 0;
1086 if( i_buffer_length < 10000 )
1088 if( p_priv->pts_adjust.i_num_faulty > 10 )
1090 i_pts_slide = __MAX(p_input->i_pts_delay *3 / 2, 10000);
1091 p_priv->pts_adjust.i_num_faulty = 0;
1093 if( p_priv->pts_adjust.b_to_high )
1095 p_priv->pts_adjust.b_to_high = !p_priv->pts_adjust.b_to_high;
1096 p_priv->pts_adjust.i_num_faulty = 0;
1098 p_priv->pts_adjust.i_num_faulty++;
1100 else if( i_buffer_length > 100000 )
1102 if( p_priv->pts_adjust.i_num_faulty > 25 )
1104 i_pts_slide = -i_buffer_length/2;
1105 p_priv->pts_adjust.i_num_faulty = 0;
1107 if( p_priv->pts_adjust.b_to_high )
1109 p_priv->pts_adjust.b_to_high = !p_priv->pts_adjust.b_to_high;
1110 p_priv->pts_adjust.i_num_faulty = 0;
1112 p_priv->pts_adjust.i_num_faulty++;
1114 if( i_pts_slide != 0 )
1116 const mtime_t i_pts_delay_org = p_input->i_pts_delay;
1118 p_input->i_pts_delay += i_pts_slide;
1120 /* Don't play with the pts delay for more than -2<->3sec */
1121 if( p_input->i_pts_delay < -2000000 )
1122 p_input->i_pts_delay = -2000000;
1123 else if( p_input->i_pts_delay > 3000000 )
1124 p_input->i_pts_delay = 3000000;
1125 i_pts_slide = p_input->i_pts_delay - i_pts_delay_org;
1127 msg_Dbg( p_input, "Sliding the pts by %dms pts delay at %dms picture buffer was %dms",
1128 (int)i_pts_slide/1000, (int)p_input->i_pts_delay/1000, (int)i_buffer_length/1000);
1130 vlc_mutex_lock( &p_vout->picture_lock );
1131 /* Slide all the picture */
1132 for( i = 0; i < I_RENDERPICTURES; i++ )
1133 PP_RENDERPICTURE[i]->date += i_pts_slide;
1134 /* FIXME: slide aout/spu */
1135 vlc_mutex_unlock( &p_vout->picture_lock );
1140 static void DecoderDecodeVideo( decoder_t *p_dec, block_t *p_block )
1142 decoder_owner_sys_t *p_owner = p_dec->p_owner;
1143 input_thread_t *p_input = p_owner->p_input;
1147 int i_displayed = 0;
1149 while( (p_pic = p_dec->pf_decode_video( p_dec, &p_block )) )
1151 vout_thread_t *p_vout = p_owner->p_vout;
1154 /* It prevent freezing VLC in case of broken decoder */
1155 VoutDisplayedPicture( p_vout, p_pic );
1157 block_Release( p_block );
1163 if( p_pic->date < p_owner->i_preroll_end )
1165 VoutDisplayedPicture( p_vout, p_pic );
1169 if( p_owner->i_preroll_end > 0 )
1171 msg_Dbg( p_dec, "End of video preroll" );
1173 VoutFlushPicture( p_vout, 1 );
1175 p_owner->i_preroll_end = -1;
1178 if( p_dec->pf_get_cc &&
1179 ( !p_owner->p_packetizer || !p_owner->p_packetizer->pf_get_cc ) )
1180 DecoderGetCc( p_dec, p_dec );
1182 DecoderWaitUnpause( p_dec );
1186 DecoderGetDelays( p_dec, &i_ts_delay, &i_es_delay );
1187 int i_rate = INPUT_RATE_DEFAULT;
1189 DecoderVoutBufferFixTs( p_pic, &i_rate, p_owner->p_clock, i_ts_delay, i_es_delay );
1192 const mtime_t i_max_date = mdate() + i_ts_delay +
1193 i_es_delay * i_rate / INPUT_RATE_DEFAULT + VOUT_BOGUS_DELAY;
1195 if( p_pic->date > 0 && p_pic->date < i_max_date )
1197 if( i_rate != p_owner->i_last_rate )
1199 /* Be sure to not display old picture after our own */
1200 VoutFlushPicture( p_vout, p_pic->date );
1201 p_owner->i_last_rate = i_rate;
1204 vout_DatePicture( p_vout, p_pic, p_pic->date );
1206 /* Re-enable it but do it right this time */
1207 //DecoderOptimizePtsDelay( p_dec );
1208 vout_DisplayPicture( p_vout, p_pic );
1212 if( p_pic->date <= 0 )
1214 msg_Warn( p_vout, "non-dated video buffer received" );
1218 msg_Warn( p_vout, "early picture skipped (%"PRId64")",
1219 p_pic->date - mdate() );
1222 VoutDisplayedPicture( p_vout, p_pic );
1226 vout_GetResetStatistic( p_vout, &i_tmp_display, &i_tmp_lost );
1228 i_displayed += i_tmp_display;
1229 i_lost += i_tmp_lost;
1231 if( i_decoded > 0 || i_lost > 0 || i_displayed > 0 )
1233 vlc_mutex_lock( &p_input->p->counters.counters_lock );
1235 stats_UpdateInteger( p_dec, p_input->p->counters.p_decoded_video,
1237 stats_UpdateInteger( p_dec, p_input->p->counters.p_lost_pictures,
1240 stats_UpdateInteger( p_dec, p_input->p->counters.p_displayed_pictures,
1243 vlc_mutex_unlock( &p_input->p->counters.counters_lock );
1247 /* This function process a block for sout
1249 static void DecoderProcessSout( decoder_t *p_dec, block_t *p_block )
1251 decoder_owner_sys_t *p_owner = (decoder_owner_sys_t *)p_dec->p_owner;
1252 const bool b_telx = p_dec->fmt_in.i_codec == VLC_FOURCC('t','e','l','x');
1253 block_t *p_sout_block;
1255 while( ( p_sout_block =
1256 p_dec->pf_packetize( p_dec, p_block ? &p_block : NULL ) ) )
1258 if( !p_owner->p_sout_input )
1260 es_format_Copy( &p_owner->sout, &p_dec->fmt_out );
1262 p_owner->sout.i_group = p_dec->fmt_in.i_group;
1263 p_owner->sout.i_id = p_dec->fmt_in.i_id;
1264 if( p_dec->fmt_in.psz_language )
1266 if( p_owner->sout.psz_language )
1267 free( p_owner->sout.psz_language );
1268 p_owner->sout.psz_language =
1269 strdup( p_dec->fmt_in.psz_language );
1272 p_owner->p_sout_input =
1273 sout_InputNew( p_owner->p_sout,
1276 if( p_owner->p_sout_input == NULL )
1278 msg_Err( p_dec, "cannot create packetizer output (%4.4s)",
1279 (char *)&p_owner->sout.i_codec );
1280 p_dec->b_error = true;
1282 while( p_sout_block )
1284 block_t *p_next = p_sout_block->p_next;
1285 block_Release( p_sout_block );
1286 p_sout_block = p_next;
1292 while( p_sout_block )
1294 block_t *p_next = p_sout_block->p_next;
1296 p_sout_block->p_next = NULL;
1298 DecoderWaitUnpause( p_dec );
1302 DecoderGetDelays( p_dec, &i_ts_delay, &i_es_delay );
1304 DecoderSoutBufferFixTs( p_sout_block, p_owner->p_clock,
1305 i_ts_delay, i_es_delay, b_telx );
1307 sout_InputSendBuffer( p_owner->p_sout_input,
1310 p_sout_block = p_next;
1313 /* For now it's enough, as only sout impact on this flag */
1314 if( p_owner->p_sout->i_out_pace_nocontrol > 0 &&
1315 p_owner->p_input->p->b_out_pace_control )
1317 msg_Dbg( p_dec, "switching to sync mode" );
1318 p_owner->p_input->p->b_out_pace_control = false;
1320 else if( p_owner->p_sout->i_out_pace_nocontrol <= 0 &&
1321 !p_owner->p_input->p->b_out_pace_control )
1323 msg_Dbg( p_dec, "switching to async mode" );
1324 p_owner->p_input->p->b_out_pace_control = true;
1329 /* This function process a video block
1331 static void DecoderProcessVideo( decoder_t *p_dec, block_t *p_block, bool b_flush )
1333 decoder_owner_sys_t *p_owner = (decoder_owner_sys_t *)p_dec->p_owner;
1335 if( b_flush && p_owner->p_vout )
1336 VoutFlushPicture( p_owner->p_vout, 1 );
1338 if( p_owner->p_packetizer )
1340 block_t *p_packetized_block;
1341 decoder_t *p_packetizer = p_owner->p_packetizer;
1343 while( (p_packetized_block =
1344 p_packetizer->pf_packetize( p_packetizer, p_block ? &p_block : NULL )) )
1346 if( p_packetizer->fmt_out.i_extra && !p_dec->fmt_in.i_extra )
1348 es_format_Clean( &p_dec->fmt_in );
1349 es_format_Copy( &p_dec->fmt_in, &p_packetizer->fmt_out );
1351 if( p_packetizer->pf_get_cc )
1352 DecoderGetCc( p_dec, p_packetizer );
1354 while( p_packetized_block )
1356 block_t *p_next = p_packetized_block->p_next;
1357 p_packetized_block->p_next = NULL;
1359 DecoderDecodeVideo( p_dec, p_packetized_block );
1361 p_packetized_block = p_next;
1367 DecoderDecodeVideo( p_dec, p_block );
1371 /* This function process a audio block
1373 static void DecoderProcessAudio( decoder_t *p_dec, block_t *p_block, bool b_flush )
1375 decoder_owner_sys_t *p_owner = (decoder_owner_sys_t *)p_dec->p_owner;
1377 if( b_flush && p_owner->p_aout && p_owner->p_aout_input )
1382 if( p_owner->p_packetizer )
1384 block_t *p_packetized_block;
1385 decoder_t *p_packetizer = p_owner->p_packetizer;
1387 while( (p_packetized_block =
1388 p_packetizer->pf_packetize( p_packetizer, p_block ? &p_block : NULL )) )
1390 if( p_packetizer->fmt_out.i_extra && !p_dec->fmt_in.i_extra )
1392 es_format_Clean( &p_dec->fmt_in );
1393 es_format_Copy( &p_dec->fmt_in, &p_packetizer->fmt_out );
1396 while( p_packetized_block )
1398 block_t *p_next = p_packetized_block->p_next;
1399 p_packetized_block->p_next = NULL;
1401 DecoderDecodeAudio( p_dec, p_packetized_block );
1403 p_packetized_block = p_next;
1409 DecoderDecodeAudio( p_dec, p_block );
1413 /* This function process a subtitle block
1415 static void DecoderProcessSpu( decoder_t *p_dec, block_t *p_block, bool b_flush )
1417 decoder_owner_sys_t *p_owner = (decoder_owner_sys_t *)p_dec->p_owner;
1418 const bool b_telx = p_dec->fmt_in.i_codec == VLC_FOURCC('t','e','l','x');
1420 input_thread_t *p_input = p_owner->p_input;
1421 vout_thread_t *p_vout;
1422 subpicture_t *p_spu;
1424 if( b_flush && p_owner->p_spu_vout )
1426 p_vout = vlc_object_find( p_dec, VLC_OBJECT_VOUT, FIND_ANYWHERE );
1428 if( p_vout && p_owner->p_spu_vout == p_vout )
1429 spu_Control( p_vout->p_spu, SPU_CHANNEL_CLEAR,
1430 p_owner->i_spu_channel );
1433 vlc_object_release( p_vout );
1436 while( (p_spu = p_dec->pf_decode_sub( p_dec, p_block ? &p_block : NULL ) ) )
1438 vlc_mutex_lock( &p_input->p->counters.counters_lock );
1439 stats_UpdateInteger( p_dec, p_input->p->counters.p_decoded_sub, 1, NULL );
1440 vlc_mutex_unlock( &p_input->p->counters.counters_lock );
1442 p_vout = vlc_object_find( p_dec, VLC_OBJECT_VOUT, FIND_ANYWHERE );
1443 if( p_vout && p_owner->p_spu_vout == p_vout )
1445 /* Preroll does not work very well with subtitle */
1446 if( p_spu->i_start > 0 &&
1447 p_spu->i_start < p_owner->i_preroll_end &&
1448 ( p_spu->i_stop <= 0 || p_spu->i_stop < p_owner->i_preroll_end ) )
1450 subpicture_Delete( p_spu );
1454 DecoderWaitUnpause( p_dec );
1458 DecoderGetDelays( p_dec, &i_ts_delay, &i_es_delay );
1460 DecoderSpuBufferFixTs( p_spu, p_owner->p_clock, i_ts_delay, i_es_delay, b_telx );
1461 spu_DisplaySubpicture( p_vout->p_spu, p_spu );
1466 msg_Warn( p_dec, "no vout found, leaking subpicture" );
1469 vlc_object_release( p_vout );
1476 * \param p_dec the decoder object
1477 * \param p_block the block to decode
1478 * \return VLC_SUCCESS or an error code
1480 static int DecoderProcess( decoder_t *p_dec, block_t *p_block )
1482 decoder_owner_sys_t *p_owner = (decoder_owner_sys_t *)p_dec->p_owner;
1484 if( p_block && p_block->i_buffer <= 0 )
1486 block_Release( p_block );
1491 if( p_dec->i_object_type == VLC_OBJECT_PACKETIZER )
1493 DecoderProcessSout( p_dec, p_block );
1498 bool b_flush = false;
1502 const bool b_flushing = p_owner->i_preroll_end == INT64_MAX;
1503 DecoderUpdatePreroll( &p_owner->i_preroll_end, p_block );
1505 b_flush = !b_flushing && (p_block->i_flags & BLOCK_FLAG_CORE_FLUSH) != 0;
1507 p_block->i_flags &= ~BLOCK_FLAG_CORE_PRIVATE_MASK;
1510 if( p_dec->fmt_in.i_cat == AUDIO_ES )
1512 DecoderProcessAudio( p_dec, p_block, b_flush );
1514 else if( p_dec->fmt_in.i_cat == VIDEO_ES )
1516 DecoderProcessVideo( p_dec, p_block, b_flush );
1518 else if( p_dec->fmt_in.i_cat == SPU_ES )
1520 DecoderProcessSpu( p_dec, p_block, b_flush );
1524 msg_Err( p_dec, "unknown ES format" );
1525 p_dec->b_error = true;
1529 return p_dec->b_error ? VLC_EGENERIC : VLC_SUCCESS;
1533 * Destroys a decoder object
1535 * \param p_dec the decoder object
1538 static void DeleteDecoder( decoder_t * p_dec )
1540 decoder_owner_sys_t *p_owner = p_dec->p_owner;
1542 msg_Dbg( p_dec, "killing decoder fourcc `%4.4s', %u PES in FIFO",
1543 (char*)&p_dec->fmt_in.i_codec,
1544 (unsigned)block_FifoCount( p_owner->p_fifo ) );
1546 /* Free all packets still in the decoder fifo. */
1547 block_FifoEmpty( p_owner->p_fifo );
1548 block_FifoRelease( p_owner->p_fifo );
1551 if( p_owner->p_aout_input )
1552 aout_DecDelete( p_owner->p_aout, p_owner->p_aout_input );
1553 if( p_owner->p_aout )
1555 vlc_object_release( p_owner->p_aout );
1556 p_owner->p_aout = NULL;
1558 if( p_owner->p_vout )
1562 #define p_pic p_owner->p_vout->render.pp_picture[i_pic]
1563 /* Hack to make sure all the the pictures are freed by the decoder */
1564 for( i_pic = 0; i_pic < p_owner->p_vout->render.i_pictures;
1567 if( p_pic->i_status == RESERVED_PICTURE )
1568 vout_DestroyPicture( p_owner->p_vout, p_pic );
1569 if( p_pic->i_refcount > 0 )
1570 vout_UnlinkPicture( p_owner->p_vout, p_pic );
1574 /* We are about to die. Reattach video output to p_vlc. */
1575 vout_Request( p_dec, p_owner->p_vout, NULL );
1576 var_SetBool( p_owner->p_input, "intf-change-vout", true );
1580 if( p_owner->p_sout_input )
1582 sout_InputDelete( p_owner->p_sout_input );
1583 es_format_Clean( &p_owner->sout );
1587 if( p_dec->fmt_in.i_cat == SPU_ES )
1589 vout_thread_t *p_vout;
1591 p_vout = vlc_object_find( p_dec, VLC_OBJECT_VOUT, FIND_ANYWHERE );
1592 if( p_vout && p_owner->p_spu_vout == p_vout )
1594 spu_Control( p_vout->p_spu, SPU_CHANNEL_CLEAR,
1595 p_owner->i_spu_channel );
1596 vlc_object_release( p_vout );
1600 es_format_Clean( &p_dec->fmt_in );
1601 es_format_Clean( &p_dec->fmt_out );
1603 if( p_owner->p_packetizer )
1605 module_unneed( p_owner->p_packetizer,
1606 p_owner->p_packetizer->p_module );
1607 es_format_Clean( &p_owner->p_packetizer->fmt_in );
1608 es_format_Clean( &p_owner->p_packetizer->fmt_out );
1609 vlc_object_detach( p_owner->p_packetizer );
1610 vlc_object_release( p_owner->p_packetizer );
1613 vlc_cond_destroy( &p_owner->wait );
1614 vlc_mutex_destroy( &p_owner->lock );
1616 vlc_object_detach( p_dec );
1621 /*****************************************************************************
1622 * Buffers allocation callbacks for the decoders
1623 *****************************************************************************/
1624 static aout_buffer_t *aout_new_buffer( decoder_t *p_dec, int i_samples )
1626 decoder_owner_sys_t *p_owner = p_dec->p_owner;
1627 aout_buffer_t *p_buffer;
1629 if( p_owner->p_aout_input != NULL &&
1630 ( p_dec->fmt_out.audio.i_rate != p_owner->audio.i_rate ||
1631 p_dec->fmt_out.audio.i_original_channels !=
1632 p_owner->audio.i_original_channels ||
1633 p_dec->fmt_out.audio.i_bytes_per_frame !=
1634 p_owner->audio.i_bytes_per_frame ) )
1636 aout_input_t *p_aout_input = p_owner->p_aout_input;
1638 /* Parameters changed, restart the aout */
1639 vlc_mutex_lock( &p_owner->lock );
1641 p_owner->p_aout_input = NULL;
1642 aout_DecDelete( p_owner->p_aout, p_aout_input );
1644 vlc_mutex_unlock( &p_owner->lock );
1647 if( p_owner->p_aout_input == NULL )
1649 const int i_force_dolby = config_GetInt( p_dec, "force-dolby-surround" );
1650 audio_sample_format_t format;
1651 aout_input_t *p_aout_input;
1652 aout_instance_t *p_aout;
1654 p_dec->fmt_out.audio.i_format = p_dec->fmt_out.i_codec;
1655 p_owner->audio = p_dec->fmt_out.audio;
1657 memcpy( &format, &p_owner->audio, sizeof( audio_sample_format_t ) );
1658 if ( i_force_dolby && (format.i_original_channels&AOUT_CHAN_PHYSMASK)
1659 == (AOUT_CHAN_LEFT|AOUT_CHAN_RIGHT) )
1661 if ( i_force_dolby == 1 )
1663 format.i_original_channels = format.i_original_channels |
1664 AOUT_CHAN_DOLBYSTEREO;
1666 else /* i_force_dolby == 2 */
1668 format.i_original_channels = format.i_original_channels &
1669 ~AOUT_CHAN_DOLBYSTEREO;
1673 p_aout = p_owner->p_aout;
1674 p_aout_input = aout_DecNew( p_dec, &p_aout,
1675 &format, &p_dec->fmt_out.audio_replay_gain );
1677 vlc_mutex_lock( &p_owner->lock );
1678 p_owner->p_aout = p_aout;
1679 p_owner->p_aout_input = p_aout_input;
1680 vlc_mutex_unlock( &p_owner->lock );
1682 if( p_owner->p_aout_input == NULL )
1684 msg_Err( p_dec, "failed to create audio output" );
1685 p_dec->b_error = true;
1688 p_dec->fmt_out.audio.i_bytes_per_frame =
1689 p_owner->audio.i_bytes_per_frame;
1692 p_buffer = aout_DecNewBuffer( p_owner->p_aout_input, i_samples );
1697 static void aout_del_buffer( decoder_t *p_dec, aout_buffer_t *p_buffer )
1699 decoder_owner_sys_t *p_owner = p_dec->p_owner;
1701 aout_DecDeleteBuffer( p_owner->p_aout,
1702 p_owner->p_aout_input, p_buffer );
1706 int vout_CountPictureAvailable( vout_thread_t *p_vout );
1708 static picture_t *vout_new_buffer( decoder_t *p_dec )
1710 decoder_owner_sys_t *p_owner = p_dec->p_owner;
1713 if( p_owner->p_vout == NULL ||
1714 p_dec->fmt_out.video.i_width != p_owner->video.i_width ||
1715 p_dec->fmt_out.video.i_height != p_owner->video.i_height ||
1716 p_dec->fmt_out.video.i_chroma != p_owner->video.i_chroma ||
1717 p_dec->fmt_out.video.i_aspect != p_owner->video.i_aspect )
1719 vout_thread_t *p_vout;
1721 if( !p_dec->fmt_out.video.i_width ||
1722 !p_dec->fmt_out.video.i_height )
1724 /* Can't create a new vout without display size */
1728 if( !p_dec->fmt_out.video.i_visible_width ||
1729 !p_dec->fmt_out.video.i_visible_height )
1731 if( p_dec->fmt_in.video.i_visible_width &&
1732 p_dec->fmt_in.video.i_visible_height )
1734 p_dec->fmt_out.video.i_visible_width =
1735 p_dec->fmt_in.video.i_visible_width;
1736 p_dec->fmt_out.video.i_visible_height =
1737 p_dec->fmt_in.video.i_visible_height;
1741 p_dec->fmt_out.video.i_visible_width =
1742 p_dec->fmt_out.video.i_width;
1743 p_dec->fmt_out.video.i_visible_height =
1744 p_dec->fmt_out.video.i_height;
1748 if( p_dec->fmt_out.video.i_visible_height == 1088 &&
1749 var_CreateGetBool( p_dec, "hdtv-fix" ) )
1751 p_dec->fmt_out.video.i_visible_height = 1080;
1752 p_dec->fmt_out.video.i_sar_num *= 135;
1753 p_dec->fmt_out.video.i_sar_den *= 136;
1754 msg_Warn( p_dec, "Fixing broken HDTV stream (display_height=1088)");
1757 if( !p_dec->fmt_out.video.i_sar_num ||
1758 !p_dec->fmt_out.video.i_sar_den )
1760 p_dec->fmt_out.video.i_sar_num = p_dec->fmt_out.video.i_aspect *
1761 p_dec->fmt_out.video.i_visible_height;
1763 p_dec->fmt_out.video.i_sar_den = VOUT_ASPECT_FACTOR *
1764 p_dec->fmt_out.video.i_visible_width;
1767 vlc_ureduce( &p_dec->fmt_out.video.i_sar_num,
1768 &p_dec->fmt_out.video.i_sar_den,
1769 p_dec->fmt_out.video.i_sar_num,
1770 p_dec->fmt_out.video.i_sar_den, 50000 );
1772 p_dec->fmt_out.video.i_chroma = p_dec->fmt_out.i_codec;
1773 p_owner->video = p_dec->fmt_out.video;
1775 vlc_mutex_lock( &p_owner->lock );
1776 p_vout = p_owner->p_vout;
1777 p_owner->p_vout = NULL;
1778 vlc_mutex_unlock( &p_owner->lock );
1780 p_vout = vout_Request( p_dec, p_vout, &p_dec->fmt_out.video );
1782 vlc_mutex_lock( &p_owner->lock );
1783 p_owner->p_vout = p_vout;
1784 vlc_mutex_unlock( &p_owner->lock );
1786 var_SetBool( p_owner->p_input, "intf-change-vout", true );
1787 if( p_vout == NULL )
1789 msg_Err( p_dec, "failed to create video output" );
1790 p_dec->b_error = true;
1794 if( p_owner->video.i_rmask )
1795 p_owner->p_vout->render.i_rmask = p_owner->video.i_rmask;
1796 if( p_owner->video.i_gmask )
1797 p_owner->p_vout->render.i_gmask = p_owner->video.i_gmask;
1798 if( p_owner->video.i_bmask )
1799 p_owner->p_vout->render.i_bmask = p_owner->video.i_bmask;
1802 /* Get a new picture
1804 for( p_pic = NULL; ; )
1806 int i_pic, i_ready_pic;
1808 if( p_dec->b_die || p_dec->b_error )
1811 /* The video filter chain required that there is always 1 free buffer
1812 * that it will use as temporary one. It will release the temporary
1813 * buffer once its work is done, so this check is safe even if we don't
1814 * lock around both count() and create().
1816 if( vout_CountPictureAvailable( p_owner->p_vout ) >= 2 )
1818 p_pic = vout_CreatePicture( p_owner->p_vout, 0, 0, 0 );
1823 #define p_pic p_owner->p_vout->render.pp_picture[i_pic]
1824 /* Check the decoder doesn't leak pictures */
1825 for( i_pic = 0, i_ready_pic = 0; i_pic < p_owner->p_vout->render.i_pictures; i_pic++ )
1827 if( p_pic->i_status == READY_PICTURE )
1830 /* If we have at least 2 ready pictures, wait for the vout thread to
1832 if( i_ready_pic >= 2 )
1838 if( p_pic->i_status == DISPLAYED_PICTURE )
1840 /* If at least one displayed picture is not referenced
1841 * let vout free it */
1842 if( p_pic->i_refcount == 0 )
1846 if( i_pic == p_owner->p_vout->render.i_pictures )
1848 /* Too many pictures are still referenced, there is probably a bug
1849 * with the decoder */
1850 msg_Err( p_dec, "decoder is leaking pictures, resetting the heap" );
1852 /* Just free all the pictures */
1853 for( i_pic = 0; i_pic < p_owner->p_vout->render.i_pictures;
1856 if( p_pic->i_status == RESERVED_PICTURE )
1857 vout_DestroyPicture( p_owner->p_vout, p_pic );
1858 if( p_pic->i_refcount > 0 )
1859 vout_UnlinkPicture( p_owner->p_vout, p_pic );
1864 msleep( VOUT_OUTMEM_SLEEP );
1870 static void vout_del_buffer( decoder_t *p_dec, picture_t *p_pic )
1872 VoutDisplayedPicture( p_dec->p_owner->p_vout, p_pic );
1875 static void vout_link_picture( decoder_t *p_dec, picture_t *p_pic )
1877 vout_LinkPicture( p_dec->p_owner->p_vout, p_pic );
1880 static void vout_unlink_picture( decoder_t *p_dec, picture_t *p_pic )
1882 vout_UnlinkPicture( p_dec->p_owner->p_vout, p_pic );
1885 static subpicture_t *spu_new_buffer( decoder_t *p_dec )
1887 decoder_owner_sys_t *p_owner = p_dec->p_owner;
1888 vout_thread_t *p_vout = NULL;
1889 subpicture_t *p_subpic;
1890 int i_attempts = 30;
1892 while( i_attempts-- )
1894 if( p_dec->b_die || p_dec->b_error )
1897 p_vout = vlc_object_find( p_dec, VLC_OBJECT_VOUT, FIND_ANYWHERE );
1901 msleep( VOUT_DISPLAY_DELAY );
1906 msg_Warn( p_dec, "no vout found, dropping subpicture" );
1910 if( p_owner->p_spu_vout != p_vout )
1912 spu_Control( p_vout->p_spu, SPU_CHANNEL_REGISTER,
1913 &p_owner->i_spu_channel );
1914 p_owner->i_spu_order = 0;
1915 p_owner->p_spu_vout = p_vout;
1918 p_subpic = subpicture_New();
1921 p_subpic->i_channel = p_owner->i_spu_channel;
1922 p_subpic->i_order = p_owner->i_spu_order++;
1923 p_subpic->b_subtitle = true;
1926 vlc_object_release( p_vout );
1931 static void spu_del_buffer( decoder_t *p_dec, subpicture_t *p_subpic )
1933 decoder_owner_sys_t *p_owner = p_dec->p_owner;
1934 vout_thread_t *p_vout = NULL;
1936 p_vout = vlc_object_find( p_dec, VLC_OBJECT_VOUT, FIND_ANYWHERE );
1937 if( !p_vout || p_owner->p_spu_vout != p_vout )
1940 vlc_object_release( p_vout );
1941 msg_Warn( p_dec, "no vout found, leaking subpicture" );
1945 subpicture_Delete( p_subpic );
1947 vlc_object_release( p_vout );