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_dialog.h>
44 #include <vlc_modules.h>
46 #include "audio_output/aout_internal.h"
47 #include "stream_output/stream_output.h"
48 #include "input_internal.h"
54 #include "../video_output/vout_control.h"
56 static decoder_t
*CreateDecoder( input_thread_t
*, es_format_t
*, bool,
57 sout_instance_t
*p_sout
);
58 static void DeleteDecoder( decoder_t
* );
60 static void *DecoderThread( vlc_object_t
* );
61 static void DecoderProcess( decoder_t
*, block_t
* );
62 static void DecoderError( decoder_t
*p_dec
, block_t
*p_block
);
63 static void DecoderOutputChangePause( decoder_t
*, bool b_paused
, mtime_t i_date
);
64 static void DecoderFlush( decoder_t
* );
65 static void DecoderSignalBuffering( decoder_t
*, bool );
66 static void DecoderFlushBuffering( decoder_t
* );
68 static void DecoderUnsupportedCodec( decoder_t
*, vlc_fourcc_t
);
70 /* Buffers allocation callbacks for the decoders */
71 static aout_buffer_t
*aout_new_buffer( decoder_t
*, int );
72 static void aout_del_buffer( decoder_t
*, aout_buffer_t
* );
74 static picture_t
*vout_new_buffer( decoder_t
* );
75 static void vout_del_buffer( decoder_t
*, picture_t
* );
76 static void vout_link_picture( decoder_t
*, picture_t
* );
77 static void vout_unlink_picture( decoder_t
*, picture_t
* );
79 static subpicture_t
*spu_new_buffer( decoder_t
*, const subpicture_updater_t
* );
80 static void spu_del_buffer( decoder_t
*, subpicture_t
* );
82 struct decoder_owner_sys_t
84 int64_t i_preroll_end
;
86 input_thread_t
*p_input
;
87 input_clock_t
*p_clock
;
90 vout_thread_t
*p_spu_vout
;
94 sout_instance_t
*p_sout
;
95 sout_packetizer_input_t
*p_sout_input
;
97 /* Some decoders require already packetized data (ie. not truncated) */
98 decoder_t
*p_packetizer
;
101 /* Current format in use by the output */
102 video_format_t video
;
103 audio_format_t audio
;
107 bool b_fmt_description
;
108 es_format_t fmt_description
;
109 vlc_meta_t
*p_description
;
112 block_fifo_t
*p_fifo
;
114 /* Lock for communication with decoder thread */
116 vlc_cond_t wait_request
;
117 vlc_cond_t wait_acknowledge
;
119 /* -- These variables need locking on write(only) -- */
120 aout_instance_t
*p_aout
;
121 aout_input_t
*p_aout_input
;
123 vout_thread_t
*p_vout
;
125 /* -- Theses variables need locking on read *and* write -- */
143 picture_t
*p_picture
;
144 picture_t
**pp_picture_next
;
146 subpicture_t
*p_subpic
;
147 subpicture_t
**pp_subpic_next
;
149 aout_buffer_t
*p_audio
;
150 aout_buffer_t
**pp_audio_next
;
153 block_t
**pp_block_next
;
164 decoder_t
*pp_decoder
[4];
171 #define DECODER_MAX_BUFFERING_COUNT (4)
172 #define DECODER_MAX_BUFFERING_AUDIO_DURATION (AOUT_MAX_PREPARE_TIME)
173 #define DECODER_MAX_BUFFERING_VIDEO_DURATION (1*CLOCK_FREQ)
175 /* Pictures which are DECODER_BOGUS_VIDEO_DELAY or more in advance probably have
176 * a bogus PTS and won't be displayed */
177 #define DECODER_BOGUS_VIDEO_DELAY ((mtime_t)(DEFAULT_PTS_DELAY * 30))
180 #define DECODER_SPU_VOUT_WAIT_DURATION ((int)(0.200*CLOCK_FREQ))
183 /*****************************************************************************
185 *****************************************************************************/
186 picture_t
*decoder_NewPicture( decoder_t
*p_decoder
)
188 picture_t
*p_picture
= p_decoder
->pf_vout_buffer_new( p_decoder
);
190 msg_Warn( p_decoder
, "can't get output picture" );
193 void decoder_DeletePicture( decoder_t
*p_decoder
, picture_t
*p_picture
)
195 p_decoder
->pf_vout_buffer_del( p_decoder
, p_picture
);
197 void decoder_LinkPicture( decoder_t
*p_decoder
, picture_t
*p_picture
)
199 p_decoder
->pf_picture_link( p_decoder
, p_picture
);
201 void decoder_UnlinkPicture( decoder_t
*p_decoder
, picture_t
*p_picture
)
203 p_decoder
->pf_picture_unlink( p_decoder
, p_picture
);
206 aout_buffer_t
*decoder_NewAudioBuffer( decoder_t
*p_decoder
, int i_size
)
208 if( !p_decoder
->pf_aout_buffer_new
)
210 return p_decoder
->pf_aout_buffer_new( p_decoder
, i_size
);
212 void decoder_DeleteAudioBuffer( decoder_t
*p_decoder
, aout_buffer_t
*p_buffer
)
214 p_decoder
->pf_aout_buffer_del( p_decoder
, p_buffer
);
217 subpicture_t
*decoder_NewSubpicture( decoder_t
*p_decoder
,
218 const subpicture_updater_t
*p_dyn
)
220 subpicture_t
*p_subpicture
= p_decoder
->pf_spu_buffer_new( p_decoder
, p_dyn
);
222 msg_Warn( p_decoder
, "can't get output subpicture" );
226 void decoder_DeleteSubpicture( decoder_t
*p_decoder
, subpicture_t
*p_subpicture
)
228 p_decoder
->pf_spu_buffer_del( p_decoder
, p_subpicture
);
231 /* decoder_GetInputAttachments:
233 int decoder_GetInputAttachments( decoder_t
*p_dec
,
234 input_attachment_t
***ppp_attachment
,
237 if( !p_dec
->pf_get_attachments
)
240 return p_dec
->pf_get_attachments( p_dec
, ppp_attachment
, pi_attachment
);
242 /* decoder_GetDisplayDate:
244 mtime_t
decoder_GetDisplayDate( decoder_t
*p_dec
, mtime_t i_ts
)
246 if( !p_dec
->pf_get_display_date
)
247 return VLC_TS_INVALID
;
249 return p_dec
->pf_get_display_date( p_dec
, i_ts
);
251 /* decoder_GetDisplayRate:
253 int decoder_GetDisplayRate( decoder_t
*p_dec
)
255 if( !p_dec
->pf_get_display_rate
)
256 return INPUT_RATE_DEFAULT
;
258 return p_dec
->pf_get_display_rate( p_dec
);
262 * Spawns a new decoder thread
264 * \param p_input the input thread
265 * \param p_es the es descriptor
266 * \return the spawned decoder object
268 decoder_t
*input_DecoderNew( input_thread_t
*p_input
,
269 es_format_t
*fmt
, input_clock_t
*p_clock
,
270 sout_instance_t
*p_sout
)
272 decoder_t
*p_dec
= NULL
;
273 const char *psz_type
= p_sout
? N_("packetizer") : N_("decoder");
276 /* Create the decoder configuration structure */
277 p_dec
= CreateDecoder( p_input
, fmt
, p_sout
!= NULL
, p_sout
);
280 msg_Err( p_input
, "could not create %s", psz_type
);
281 dialog_Fatal( p_input
, _("Streaming / Transcoding failed"),
282 _("VLC could not open the %s module."),
283 vlc_gettext( psz_type
) );
287 if( !p_dec
->p_module
)
289 DecoderUnsupportedCodec( p_dec
, fmt
->i_codec
);
291 DeleteDecoder( p_dec
);
295 p_dec
->p_owner
->p_clock
= p_clock
;
296 assert( p_dec
->fmt_out
.i_cat
!= UNKNOWN_ES
);
298 if( p_dec
->fmt_out
.i_cat
== AUDIO_ES
)
299 i_priority
= VLC_THREAD_PRIORITY_AUDIO
;
301 i_priority
= VLC_THREAD_PRIORITY_VIDEO
;
303 /* Spawn the decoder thread */
304 if( vlc_thread_create( p_dec
, "decoder", DecoderThread
, i_priority
) )
306 msg_Err( p_dec
, "cannot spawn decoder thread" );
307 module_unneed( p_dec
, p_dec
->p_module
);
308 DeleteDecoder( p_dec
);
316 * Kills a decoder thread and waits until it's finished
318 * \param p_input the input thread
319 * \param p_es the es descriptor
322 void input_DecoderDelete( decoder_t
*p_dec
)
324 decoder_owner_sys_t
*p_owner
= p_dec
->p_owner
;
326 vlc_object_kill( p_dec
);
328 /* Make sure we aren't paused/buffering/waiting anymore */
329 vlc_mutex_lock( &p_owner
->lock
);
330 const bool b_was_paused
= p_owner
->b_paused
;
331 p_owner
->b_paused
= false;
332 p_owner
->b_buffering
= false;
333 p_owner
->b_flushing
= true;
334 vlc_cond_signal( &p_owner
->wait_request
);
335 vlc_mutex_unlock( &p_owner
->lock
);
337 vlc_thread_join( p_dec
);
338 p_owner
->b_paused
= b_was_paused
;
340 module_unneed( p_dec
, p_dec
->p_module
);
343 if( p_dec
->p_owner
->cc
.b_supported
)
346 for( i
= 0; i
< 4; i
++ )
347 input_DecoderSetCcState( p_dec
, false, i
);
351 DeleteDecoder( p_dec
);
355 * Put a block_t in the decoder's fifo.
356 * Thread-safe w.r.t. the decoder. May be a cancellation point.
358 * \param p_dec the decoder object
359 * \param p_block the data block
361 void input_DecoderDecode( decoder_t
*p_dec
, block_t
*p_block
, bool b_do_pace
)
363 decoder_owner_sys_t
*p_owner
= p_dec
->p_owner
;
367 /* The fifo is not consummed when buffering and so will
369 * There is no need to lock as b_buffering is never modify
370 * inside decoder thread. */
371 if( !p_owner
->b_buffering
)
372 block_FifoPace( p_owner
->p_fifo
, 10, SIZE_MAX
);
375 else if( block_FifoSize( p_owner
->p_fifo
) > 50*1024*1024 /* 50 MiB */ )
377 else if( block_FifoSize( p_owner
->p_fifo
) > 400*1024*1024 /* 400 MiB, ie ~ 50mb/s for 60s */ )
380 /* FIXME: ideally we would check the time amount of data
381 * in the FIFO instead of its size. */
382 msg_Warn( p_dec
, "decoder/packetizer fifo full (data not "
383 "consumed quickly enough), resetting fifo!" );
384 block_FifoEmpty( p_owner
->p_fifo
);
387 block_FifoPut( p_owner
->p_fifo
, p_block
);
390 bool input_DecoderIsEmpty( decoder_t
* p_dec
)
392 decoder_owner_sys_t
*p_owner
= p_dec
->p_owner
;
393 assert( !p_owner
->b_buffering
);
395 bool b_empty
= block_FifoCount( p_dec
->p_owner
->p_fifo
) <= 0;
398 vlc_mutex_lock( &p_owner
->lock
);
399 /* TODO audio support */
400 if( p_dec
->fmt_out
.i_cat
== VIDEO_ES
&& p_owner
->p_vout
)
401 b_empty
= vout_IsEmpty( p_owner
->p_vout
);
402 vlc_mutex_unlock( &p_owner
->lock
);
407 void input_DecoderIsCcPresent( decoder_t
*p_dec
, bool pb_present
[4] )
409 decoder_owner_sys_t
*p_owner
= p_dec
->p_owner
;
412 vlc_mutex_lock( &p_owner
->lock
);
413 for( i
= 0; i
< 4; i
++ )
414 pb_present
[i
] = p_owner
->cc
.pb_present
[i
];
415 vlc_mutex_unlock( &p_owner
->lock
);
417 int input_DecoderSetCcState( decoder_t
*p_dec
, bool b_decode
, int i_channel
)
419 decoder_owner_sys_t
*p_owner
= p_dec
->p_owner
;
421 //msg_Warn( p_dec, "input_DecoderSetCcState: %d @%d", b_decode, i_channel );
423 if( i_channel
< 0 || i_channel
>= 4 || !p_owner
->cc
.pb_present
[i_channel
] )
428 static const vlc_fourcc_t fcc
[4] = {
429 VLC_FOURCC('c', 'c', '1', ' '),
430 VLC_FOURCC('c', 'c', '2', ' '),
431 VLC_FOURCC('c', 'c', '3', ' '),
432 VLC_FOURCC('c', 'c', '4', ' '),
437 es_format_Init( &fmt
, SPU_ES
, fcc
[i_channel
] );
438 p_cc
= CreateDecoder( p_owner
->p_input
, &fmt
, false, p_owner
->p_sout
);
441 msg_Err( p_dec
, "could not create decoder" );
442 dialog_Fatal( p_dec
, _("Streaming / Transcoding failed"), "%s",
443 _("VLC could not open the decoder module.") );
446 else if( !p_cc
->p_module
)
448 DecoderUnsupportedCodec( p_dec
, fcc
[i_channel
] );
449 DeleteDecoder( p_cc
);
452 p_cc
->p_owner
->p_clock
= p_owner
->p_clock
;
454 vlc_mutex_lock( &p_owner
->lock
);
455 p_owner
->cc
.pp_decoder
[i_channel
] = p_cc
;
456 vlc_mutex_unlock( &p_owner
->lock
);
462 vlc_mutex_lock( &p_owner
->lock
);
463 p_cc
= p_owner
->cc
.pp_decoder
[i_channel
];
464 p_owner
->cc
.pp_decoder
[i_channel
] = NULL
;
465 vlc_mutex_unlock( &p_owner
->lock
);
469 vlc_object_kill( p_cc
);
470 module_unneed( p_cc
, p_cc
->p_module
);
471 DeleteDecoder( p_cc
);
476 int input_DecoderGetCcState( decoder_t
*p_dec
, bool *pb_decode
, int i_channel
)
478 decoder_owner_sys_t
*p_owner
= p_dec
->p_owner
;
481 if( i_channel
< 0 || i_channel
>= 4 || !p_owner
->cc
.pb_present
[i_channel
] )
484 vlc_mutex_lock( &p_owner
->lock
);
485 *pb_decode
= p_owner
->cc
.pp_decoder
[i_channel
] != NULL
;
486 vlc_mutex_unlock( &p_owner
->lock
);
490 void input_DecoderChangePause( decoder_t
*p_dec
, bool b_paused
, mtime_t i_date
)
492 decoder_owner_sys_t
*p_owner
= p_dec
->p_owner
;
494 vlc_mutex_lock( &p_owner
->lock
);
496 assert( !p_owner
->b_paused
|| !b_paused
);
498 p_owner
->b_paused
= b_paused
;
499 p_owner
->pause
.i_date
= i_date
;
500 p_owner
->pause
.i_ignore
= 0;
501 vlc_cond_signal( &p_owner
->wait_request
);
503 DecoderOutputChangePause( p_dec
, b_paused
, i_date
);
505 vlc_mutex_unlock( &p_owner
->lock
);
508 void input_DecoderChangeDelay( decoder_t
*p_dec
, mtime_t i_delay
)
510 decoder_owner_sys_t
*p_owner
= p_dec
->p_owner
;
512 vlc_mutex_lock( &p_owner
->lock
);
513 p_owner
->i_ts_delay
= i_delay
;
514 vlc_mutex_unlock( &p_owner
->lock
);
517 void input_DecoderStartBuffering( decoder_t
*p_dec
)
519 decoder_owner_sys_t
*p_owner
= p_dec
->p_owner
;
521 vlc_mutex_lock( &p_owner
->lock
);
523 DecoderFlush( p_dec
);
525 p_owner
->buffer
.b_first
= true;
526 p_owner
->buffer
.b_full
= false;
527 p_owner
->buffer
.i_count
= 0;
529 assert( !p_owner
->buffer
.p_picture
&& !p_owner
->buffer
.p_subpic
&&
530 !p_owner
->buffer
.p_audio
&& !p_owner
->buffer
.p_block
);
532 p_owner
->buffer
.p_picture
= NULL
;
533 p_owner
->buffer
.pp_picture_next
= &p_owner
->buffer
.p_picture
;
535 p_owner
->buffer
.p_subpic
= NULL
;
536 p_owner
->buffer
.pp_subpic_next
= &p_owner
->buffer
.p_subpic
;
538 p_owner
->buffer
.p_audio
= NULL
;
539 p_owner
->buffer
.pp_audio_next
= &p_owner
->buffer
.p_audio
;
541 p_owner
->buffer
.p_block
= NULL
;
542 p_owner
->buffer
.pp_block_next
= &p_owner
->buffer
.p_block
;
545 p_owner
->b_buffering
= true;
547 vlc_cond_signal( &p_owner
->wait_request
);
549 vlc_mutex_unlock( &p_owner
->lock
);
552 void input_DecoderStopBuffering( decoder_t
*p_dec
)
554 decoder_owner_sys_t
*p_owner
= p_dec
->p_owner
;
556 vlc_mutex_lock( &p_owner
->lock
);
558 p_owner
->b_buffering
= false;
560 vlc_cond_signal( &p_owner
->wait_request
);
562 vlc_mutex_unlock( &p_owner
->lock
);
565 void input_DecoderWaitBuffering( decoder_t
*p_dec
)
567 decoder_owner_sys_t
*p_owner
= p_dec
->p_owner
;
569 vlc_mutex_lock( &p_owner
->lock
);
571 while( vlc_object_alive( p_dec
) && p_owner
->b_buffering
&& !p_owner
->buffer
.b_full
)
573 block_FifoWake( p_owner
->p_fifo
);
574 vlc_cond_wait( &p_owner
->wait_acknowledge
, &p_owner
->lock
);
577 vlc_mutex_unlock( &p_owner
->lock
);
580 void input_DecoderFrameNext( decoder_t
*p_dec
, mtime_t
*pi_duration
)
582 decoder_owner_sys_t
*p_owner
= p_dec
->p_owner
;
586 vlc_mutex_lock( &p_owner
->lock
);
587 if( p_dec
->fmt_out
.i_cat
== VIDEO_ES
)
589 if( p_owner
->b_paused
&& p_owner
->p_vout
)
591 vout_NextPicture( p_owner
->p_vout
, pi_duration
);
592 p_owner
->pause
.i_ignore
++;
593 vlc_cond_signal( &p_owner
->wait_request
);
598 /* TODO subtitle should not be flushed */
599 DecoderFlush( p_dec
);
601 vlc_mutex_unlock( &p_owner
->lock
);
604 bool input_DecoderHasFormatChanged( decoder_t
*p_dec
, es_format_t
*p_fmt
, vlc_meta_t
**pp_meta
)
606 decoder_owner_sys_t
*p_owner
= p_dec
->p_owner
;
609 vlc_mutex_lock( &p_owner
->lock
);
610 b_changed
= p_owner
->b_fmt_description
;
614 es_format_Copy( p_fmt
, &p_owner
->fmt_description
);
619 if( p_owner
->p_description
)
621 *pp_meta
= vlc_meta_New();
623 vlc_meta_Merge( *pp_meta
, p_owner
->p_description
);
626 p_owner
->b_fmt_description
= false;
628 vlc_mutex_unlock( &p_owner
->lock
);
632 size_t input_DecoderGetFifoSize( decoder_t
*p_dec
)
634 decoder_owner_sys_t
*p_owner
= p_dec
->p_owner
;
636 return block_FifoSize( p_owner
->p_fifo
);
639 void input_DecoderGetObjects( decoder_t
*p_dec
,
640 vout_thread_t
**pp_vout
, aout_instance_t
**pp_aout
)
642 decoder_owner_sys_t
*p_owner
= p_dec
->p_owner
;
644 vlc_mutex_lock( &p_owner
->lock
);
646 *pp_vout
= p_owner
->p_vout
? vlc_object_hold( p_owner
->p_vout
) : NULL
;
648 *pp_aout
= p_owner
->p_aout
? vlc_object_hold( p_owner
->p_aout
) : NULL
;
649 vlc_mutex_unlock( &p_owner
->lock
);
652 /*****************************************************************************
654 *****************************************************************************/
655 static int DecoderGetInputAttachments( decoder_t
*p_dec
,
656 input_attachment_t
***ppp_attachment
,
659 return input_Control( p_dec
->p_owner
->p_input
, INPUT_GET_ATTACHMENTS
,
660 ppp_attachment
, pi_attachment
);
662 static mtime_t
DecoderGetDisplayDate( decoder_t
*p_dec
, mtime_t i_ts
)
664 decoder_owner_sys_t
*p_owner
= p_dec
->p_owner
;
666 vlc_mutex_lock( &p_owner
->lock
);
667 if( p_owner
->b_buffering
|| p_owner
->b_paused
)
668 i_ts
= VLC_TS_INVALID
;
669 vlc_mutex_unlock( &p_owner
->lock
);
671 if( !p_owner
->p_clock
|| i_ts
<= VLC_TS_INVALID
)
674 if( input_clock_ConvertTS( p_owner
->p_clock
, NULL
, &i_ts
, NULL
, INT64_MAX
) )
675 return VLC_TS_INVALID
;
679 static int DecoderGetDisplayRate( decoder_t
*p_dec
)
681 decoder_owner_sys_t
*p_owner
= p_dec
->p_owner
;
683 if( !p_owner
->p_clock
)
684 return INPUT_RATE_DEFAULT
;
685 return input_clock_GetRate( p_owner
->p_clock
);
689 static void DecoderUnsupportedCodec( decoder_t
*p_dec
, vlc_fourcc_t codec
)
691 msg_Err( p_dec
, "no suitable decoder module for fourcc `%4.4s'. "
692 "VLC probably does not support this sound or video format.",
694 dialog_Fatal( p_dec
, _("No suitable decoder module"),
695 _("VLC does not support the audio or video format \"%4.4s\". "
696 "Unfortunately there is no way for you to fix this."),
702 * Create a decoder object
704 * \param p_input the input thread
705 * \param p_es the es descriptor
706 * \param b_packetizer instead of a decoder
707 * \return the decoder object
709 static decoder_t
* CreateDecoder( input_thread_t
*p_input
,
710 es_format_t
*fmt
, bool b_packetizer
,
711 sout_instance_t
*p_sout
)
714 decoder_owner_sys_t
*p_owner
;
715 es_format_t null_es_format
;
717 p_dec
= vlc_custom_create( p_input
, sizeof( *p_dec
), VLC_OBJECT_DECODER
,
722 p_dec
->pf_decode_audio
= NULL
;
723 p_dec
->pf_decode_video
= NULL
;
724 p_dec
->pf_decode_sub
= NULL
;
725 p_dec
->pf_get_cc
= NULL
;
726 p_dec
->pf_packetize
= NULL
;
728 /* Initialize the decoder */
729 p_dec
->p_module
= NULL
;
731 memset( &null_es_format
, 0, sizeof(es_format_t
) );
732 es_format_Copy( &p_dec
->fmt_in
, fmt
);
733 es_format_Copy( &p_dec
->fmt_out
, &null_es_format
);
735 p_dec
->p_description
= NULL
;
737 /* Allocate our private structure for the decoder */
738 p_dec
->p_owner
= p_owner
= malloc( sizeof( decoder_owner_sys_t
) );
739 if( p_dec
->p_owner
== NULL
)
741 vlc_object_release( p_dec
);
744 p_dec
->p_owner
->i_preroll_end
= VLC_TS_INVALID
;
745 p_dec
->p_owner
->i_last_rate
= INPUT_RATE_DEFAULT
;
746 p_dec
->p_owner
->p_input
= p_input
;
747 p_dec
->p_owner
->p_aout
= NULL
;
748 p_dec
->p_owner
->p_aout_input
= NULL
;
749 p_dec
->p_owner
->p_vout
= NULL
;
750 p_dec
->p_owner
->p_spu_vout
= NULL
;
751 p_dec
->p_owner
->i_spu_channel
= 0;
752 p_dec
->p_owner
->i_spu_order
= 0;
753 p_dec
->p_owner
->p_sout
= p_sout
;
754 p_dec
->p_owner
->p_sout_input
= NULL
;
755 p_dec
->p_owner
->p_packetizer
= NULL
;
756 p_dec
->p_owner
->b_packetizer
= b_packetizer
;
759 if( ( p_dec
->p_owner
->p_fifo
= block_FifoNew() ) == NULL
)
761 free( p_dec
->p_owner
);
762 vlc_object_release( p_dec
);
766 /* Set buffers allocation callbacks for the decoders */
767 p_dec
->pf_aout_buffer_new
= aout_new_buffer
;
768 p_dec
->pf_aout_buffer_del
= aout_del_buffer
;
769 p_dec
->pf_vout_buffer_new
= vout_new_buffer
;
770 p_dec
->pf_vout_buffer_del
= vout_del_buffer
;
771 p_dec
->pf_picture_link
= vout_link_picture
;
772 p_dec
->pf_picture_unlink
= vout_unlink_picture
;
773 p_dec
->pf_spu_buffer_new
= spu_new_buffer
;
774 p_dec
->pf_spu_buffer_del
= spu_del_buffer
;
776 p_dec
->pf_get_attachments
= DecoderGetInputAttachments
;
777 p_dec
->pf_get_display_date
= DecoderGetDisplayDate
;
778 p_dec
->pf_get_display_rate
= DecoderGetDisplayRate
;
780 vlc_object_attach( p_dec
, p_input
);
782 /* Find a suitable decoder/packetizer module */
784 p_dec
->p_module
= module_need( p_dec
, "decoder", "$codec", false );
786 p_dec
->p_module
= module_need( p_dec
, "packetizer", "$packetizer", false );
788 /* Check if decoder requires already packetized data */
790 p_dec
->b_need_packetized
&& !p_dec
->fmt_in
.b_packetized
)
792 p_dec
->p_owner
->p_packetizer
=
793 vlc_custom_create( p_input
, sizeof( decoder_t
),
794 VLC_OBJECT_DECODER
, "packetizer" );
795 if( p_dec
->p_owner
->p_packetizer
)
797 es_format_Copy( &p_dec
->p_owner
->p_packetizer
->fmt_in
,
800 es_format_Copy( &p_dec
->p_owner
->p_packetizer
->fmt_out
,
803 vlc_object_attach( p_dec
->p_owner
->p_packetizer
, p_input
);
805 p_dec
->p_owner
->p_packetizer
->p_module
=
806 module_need( p_dec
->p_owner
->p_packetizer
,
807 "packetizer", "$packetizer", false );
809 if( !p_dec
->p_owner
->p_packetizer
->p_module
)
811 es_format_Clean( &p_dec
->p_owner
->p_packetizer
->fmt_in
);
812 vlc_object_release( p_dec
->p_owner
->p_packetizer
);
817 /* Copy ourself the input replay gain */
818 if( fmt
->i_cat
== AUDIO_ES
)
820 for( unsigned i
= 0; i
< AUDIO_REPLAY_GAIN_MAX
; i
++ )
822 if( !p_dec
->fmt_out
.audio_replay_gain
.pb_peak
[i
] )
824 p_dec
->fmt_out
.audio_replay_gain
.pb_peak
[i
] = fmt
->audio_replay_gain
.pb_peak
[i
];
825 p_dec
->fmt_out
.audio_replay_gain
.pf_peak
[i
] = fmt
->audio_replay_gain
.pf_peak
[i
];
827 if( !p_dec
->fmt_out
.audio_replay_gain
.pb_gain
[i
] )
829 p_dec
->fmt_out
.audio_replay_gain
.pb_gain
[i
] = fmt
->audio_replay_gain
.pb_gain
[i
];
830 p_dec
->fmt_out
.audio_replay_gain
.pf_gain
[i
] = fmt
->audio_replay_gain
.pf_gain
[i
];
836 vlc_mutex_init( &p_owner
->lock
);
837 vlc_cond_init( &p_owner
->wait_request
);
838 vlc_cond_init( &p_owner
->wait_acknowledge
);
840 p_owner
->b_fmt_description
= false;
841 es_format_Init( &p_owner
->fmt_description
, UNKNOWN_ES
, 0 );
842 p_owner
->p_description
= NULL
;
844 p_owner
->b_paused
= false;
845 p_owner
->pause
.i_date
= VLC_TS_INVALID
;
846 p_owner
->pause
.i_ignore
= 0;
848 p_owner
->b_buffering
= false;
849 p_owner
->buffer
.b_first
= true;
850 p_owner
->buffer
.b_full
= false;
851 p_owner
->buffer
.i_count
= 0;
852 p_owner
->buffer
.p_picture
= NULL
;
853 p_owner
->buffer
.p_subpic
= NULL
;
854 p_owner
->buffer
.p_audio
= NULL
;
855 p_owner
->buffer
.p_block
= NULL
;
857 p_owner
->b_flushing
= false;
860 p_owner
->cc
.b_supported
= false;
863 if( p_owner
->p_packetizer
&& p_owner
->p_packetizer
->pf_get_cc
)
864 p_owner
->cc
.b_supported
= true;
865 if( p_dec
->pf_get_cc
)
866 p_owner
->cc
.b_supported
= true;
869 for( unsigned i
= 0; i
< 4; i
++ )
871 p_owner
->cc
.pb_present
[i
] = false;
872 p_owner
->cc
.pp_decoder
[i
] = NULL
;
874 p_owner
->i_ts_delay
= 0;
879 * The decoding main loop
881 * \param p_dec the decoder
883 static void *DecoderThread( vlc_object_t
*p_this
)
885 decoder_t
*p_dec
= (decoder_t
*)p_this
;
886 decoder_owner_sys_t
*p_owner
= p_dec
->p_owner
;
888 /* The decoder's main loop */
891 block_t
*p_block
= block_FifoGet( p_owner
->p_fifo
);
893 /* Make sure there is no cancellation point other than this one^^.
894 * If you need one, be sure to push cleanup of p_block. */
895 DecoderSignalBuffering( p_dec
, p_block
== NULL
);
899 int canc
= vlc_savecancel();
902 DecoderError( p_dec
, p_block
);
904 DecoderProcess( p_dec
, p_block
);
906 vlc_restorecancel( canc
);
912 static block_t
*DecoderBlockFlushNew()
914 block_t
*p_null
= block_Alloc( 128 );
918 p_null
->i_flags
|= BLOCK_FLAG_DISCONTINUITY
|
919 BLOCK_FLAG_CORRUPTED
|
920 BLOCK_FLAG_CORE_FLUSH
;
921 memset( p_null
->p_buffer
, 0, p_null
->i_buffer
);
926 static void DecoderFlush( decoder_t
*p_dec
)
928 decoder_owner_sys_t
*p_owner
= p_dec
->p_owner
;
930 vlc_assert_locked( &p_owner
->lock
);
933 block_FifoEmpty( p_owner
->p_fifo
);
935 /* Monitor for flush end */
936 p_owner
->b_flushing
= true;
937 vlc_cond_signal( &p_owner
->wait_request
);
939 /* Send a special block */
940 block_t
*p_null
= DecoderBlockFlushNew();
943 input_DecoderDecode( p_dec
, p_null
, false );
946 while( vlc_object_alive( p_dec
) && p_owner
->b_flushing
)
947 vlc_cond_wait( &p_owner
->wait_acknowledge
, &p_owner
->lock
);
950 static void DecoderSignalBuffering( decoder_t
*p_dec
, bool b_full
)
952 decoder_owner_sys_t
*p_owner
= p_dec
->p_owner
;
954 vlc_mutex_lock( &p_owner
->lock
);
956 if( p_owner
->b_buffering
)
959 p_owner
->buffer
.b_full
= true;
960 vlc_cond_signal( &p_owner
->wait_acknowledge
);
963 vlc_mutex_unlock( &p_owner
->lock
);
966 static bool DecoderIsFlushing( decoder_t
*p_dec
)
968 decoder_owner_sys_t
*p_owner
= p_dec
->p_owner
;
971 vlc_mutex_lock( &p_owner
->lock
);
973 b_flushing
= p_owner
->b_flushing
;
975 vlc_mutex_unlock( &p_owner
->lock
);
980 static void DecoderWaitUnblock( decoder_t
*p_dec
, bool *pb_reject
)
982 decoder_owner_sys_t
*p_owner
= p_dec
->p_owner
;
984 vlc_assert_locked( &p_owner
->lock
);
986 while( !p_owner
->b_flushing
)
988 if( p_owner
->b_paused
)
990 if( p_owner
->b_buffering
&& !p_owner
->buffer
.b_full
)
992 if( p_owner
->pause
.i_ignore
> 0 )
994 p_owner
->pause
.i_ignore
--;
1000 if( !p_owner
->b_buffering
|| !p_owner
->buffer
.b_full
)
1003 vlc_cond_wait( &p_owner
->wait_request
, &p_owner
->lock
);
1007 *pb_reject
= p_owner
->b_flushing
;
1010 static void DecoderOutputChangePause( decoder_t
*p_dec
, bool b_paused
, mtime_t i_date
)
1012 decoder_owner_sys_t
*p_owner
= p_dec
->p_owner
;
1014 vlc_assert_locked( &p_owner
->lock
);
1016 /* XXX only audio and video output have to be paused.
1017 * - for sout it is useless
1018 * - for subs, it is done by the vout
1020 if( p_dec
->fmt_out
.i_cat
== AUDIO_ES
)
1022 if( p_owner
->p_aout
&& p_owner
->p_aout_input
)
1023 aout_DecChangePause( p_owner
->p_aout
, p_owner
->p_aout_input
,
1026 else if( p_dec
->fmt_out
.i_cat
== VIDEO_ES
)
1028 if( p_owner
->p_vout
)
1029 vout_ChangePause( p_owner
->p_vout
, b_paused
, i_date
);
1032 static inline void DecoderUpdatePreroll( int64_t *pi_preroll
, const block_t
*p
)
1034 if( p
->i_flags
& (BLOCK_FLAG_PREROLL
|BLOCK_FLAG_DISCONTINUITY
) )
1035 *pi_preroll
= INT64_MAX
;
1036 else if( p
->i_dts
> VLC_TS_INVALID
)
1037 *pi_preroll
= __MIN( *pi_preroll
, p
->i_dts
);
1038 else if( p
->i_pts
> VLC_TS_INVALID
)
1039 *pi_preroll
= __MIN( *pi_preroll
, p
->i_pts
);
1042 static mtime_t
DecoderTeletextFixTs( mtime_t i_ts
)
1044 mtime_t current_date
= mdate();
1046 /* FIXME I don't really like that, es_out SHOULD do it using the video pts */
1047 if( i_ts
<= VLC_TS_INVALID
|| i_ts
> current_date
+ 10000000 || i_ts
< current_date
)
1049 /* ETSI EN 300 472 Annex A : do not take into account the PTS
1050 * for teletext streams. */
1051 return current_date
+ 400000;
1056 static void DecoderFixTs( decoder_t
*p_dec
, mtime_t
*pi_ts0
, mtime_t
*pi_ts1
,
1057 mtime_t
*pi_duration
, int *pi_rate
, mtime_t i_ts_bound
, bool b_telx
)
1059 decoder_owner_sys_t
*p_owner
= p_dec
->p_owner
;
1060 input_clock_t
*p_clock
= p_owner
->p_clock
;
1062 vlc_assert_locked( &p_owner
->lock
);
1064 const mtime_t i_es_delay
= p_owner
->i_ts_delay
;
1068 const bool b_ephemere
= pi_ts1
&& *pi_ts0
== *pi_ts1
;
1071 if( *pi_ts0
> VLC_TS_INVALID
)
1073 *pi_ts0
+= i_es_delay
;
1074 if( pi_ts1
&& *pi_ts1
> VLC_TS_INVALID
)
1075 *pi_ts1
+= i_es_delay
;
1076 if( input_clock_ConvertTS( p_clock
, &i_rate
, pi_ts0
, pi_ts1
, i_ts_bound
) )
1077 *pi_ts0
= VLC_TS_INVALID
;
1081 i_rate
= input_clock_GetRate( p_clock
);
1084 /* Do not create ephemere data because of rounding errors */
1085 if( !b_ephemere
&& pi_ts1
&& *pi_ts0
== *pi_ts1
)
1089 *pi_duration
= ( *pi_duration
* i_rate
+
1090 INPUT_RATE_DEFAULT
-1 ) / INPUT_RATE_DEFAULT
;
1097 *pi_ts0
= DecoderTeletextFixTs( *pi_ts0
);
1098 if( pi_ts1
&& *pi_ts1
<= VLC_TS_INVALID
)
1105 * If *pb_reject, it does nothing, otherwise it waits for the given
1106 * deadline or a flush request (in which case it set *pi_reject to true.
1108 static void DecoderWaitDate( decoder_t
*p_dec
,
1109 bool *pb_reject
, mtime_t i_deadline
)
1111 decoder_owner_sys_t
*p_owner
= p_dec
->p_owner
;
1113 if( *pb_reject
|| i_deadline
< 0 )
1118 vlc_mutex_lock( &p_owner
->lock
);
1119 if( p_owner
->b_flushing
|| p_dec
->b_die
)
1122 vlc_mutex_unlock( &p_owner
->lock
);
1125 int i_ret
= vlc_cond_timedwait( &p_owner
->wait_request
, &p_owner
->lock
,
1127 vlc_mutex_unlock( &p_owner
->lock
);
1133 static void DecoderPlayAudio( decoder_t
*p_dec
, aout_buffer_t
*p_audio
,
1134 int *pi_played_sum
, int *pi_lost_sum
)
1136 decoder_owner_sys_t
*p_owner
= p_dec
->p_owner
;
1137 aout_instance_t
*p_aout
= p_owner
->p_aout
;
1138 aout_input_t
*p_aout_input
= p_owner
->p_aout_input
;
1141 if( p_audio
->i_pts
<= VLC_TS_INVALID
) // FIXME --VLC_TS_INVALID verify audio_output/*
1143 msg_Warn( p_dec
, "non-dated audio buffer received" );
1145 aout_BufferFree( p_audio
);
1150 vlc_mutex_lock( &p_owner
->lock
);
1152 if( p_owner
->b_buffering
|| p_owner
->buffer
.p_audio
)
1154 p_audio
->p_next
= NULL
;
1156 *p_owner
->buffer
.pp_audio_next
= p_audio
;
1157 p_owner
->buffer
.pp_audio_next
= &p_audio
->p_next
;
1159 p_owner
->buffer
.i_count
++;
1160 if( p_owner
->buffer
.i_count
> DECODER_MAX_BUFFERING_COUNT
||
1161 p_audio
->i_pts
- p_owner
->buffer
.p_audio
->i_pts
> DECODER_MAX_BUFFERING_AUDIO_DURATION
)
1163 p_owner
->buffer
.b_full
= true;
1164 vlc_cond_signal( &p_owner
->wait_acknowledge
);
1170 bool b_has_more
= false;
1172 DecoderWaitUnblock( p_dec
, &b_reject
);
1174 if( p_owner
->b_buffering
)
1176 vlc_mutex_unlock( &p_owner
->lock
);
1181 if( p_owner
->buffer
.p_audio
)
1183 p_audio
= p_owner
->buffer
.p_audio
;
1185 p_owner
->buffer
.p_audio
= p_audio
->p_next
;
1186 p_owner
->buffer
.i_count
--;
1188 b_has_more
= p_owner
->buffer
.p_audio
!= NULL
;
1190 p_owner
->buffer
.pp_audio_next
= &p_owner
->buffer
.p_audio
;
1194 const bool b_dated
= p_audio
->i_pts
> VLC_TS_INVALID
;
1195 int i_rate
= INPUT_RATE_DEFAULT
;
1197 DecoderFixTs( p_dec
, &p_audio
->i_pts
, NULL
, &p_audio
->i_length
,
1198 &i_rate
, AOUT_MAX_ADVANCE_TIME
, false );
1200 vlc_mutex_unlock( &p_owner
->lock
);
1202 if( !p_aout
|| !p_aout_input
||
1203 p_audio
->i_pts
<= VLC_TS_INVALID
||
1204 i_rate
< INPUT_RATE_DEFAULT
/AOUT_MAX_INPUT_RATE
||
1205 i_rate
> INPUT_RATE_DEFAULT
*AOUT_MAX_INPUT_RATE
)
1208 DecoderWaitDate( p_dec
, &b_reject
,
1209 p_audio
->i_pts
- AOUT_MAX_PREPARE_TIME
);
1213 if( !aout_DecPlay( p_aout
, p_aout_input
, p_audio
, i_rate
) )
1214 *pi_played_sum
+= 1;
1215 *pi_lost_sum
+= aout_DecGetResetLost( p_aout
, p_aout_input
);
1220 msg_Warn( p_aout
, "received buffer in the future" );
1222 msg_Warn( p_dec
, "non-dated audio buffer received" );
1225 aout_BufferFree( p_audio
);
1231 vlc_mutex_lock( &p_owner
->lock
);
1232 if( !p_owner
->buffer
.p_audio
)
1234 vlc_mutex_unlock( &p_owner
->lock
);
1240 static void DecoderDecodeAudio( decoder_t
*p_dec
, block_t
*p_block
)
1242 decoder_owner_sys_t
*p_owner
= p_dec
->p_owner
;
1243 input_thread_t
*p_input
= p_owner
->p_input
;
1244 aout_buffer_t
*p_aout_buf
;
1249 while( (p_aout_buf
= p_dec
->pf_decode_audio( p_dec
, &p_block
)) )
1251 aout_instance_t
*p_aout
= p_owner
->p_aout
;
1252 aout_input_t
*p_aout_input
= p_owner
->p_aout_input
;
1256 /* It prevent freezing VLC in case of broken decoder */
1257 aout_DecDeleteBuffer( p_aout
, p_aout_input
, p_aout_buf
);
1259 block_Release( p_block
);
1264 if( p_owner
->i_preroll_end
> VLC_TS_INVALID
&&
1265 p_aout_buf
->i_pts
< p_owner
->i_preroll_end
)
1267 aout_DecDeleteBuffer( p_aout
, p_aout_input
, p_aout_buf
);
1271 if( p_owner
->i_preroll_end
> VLC_TS_INVALID
)
1273 msg_Dbg( p_dec
, "End of audio preroll" );
1274 if( p_owner
->p_aout
&& p_owner
->p_aout_input
)
1275 aout_DecFlush( p_owner
->p_aout
, p_owner
->p_aout_input
);
1277 p_owner
->i_preroll_end
= VLC_TS_INVALID
;
1280 DecoderPlayAudio( p_dec
, p_aout_buf
, &i_played
, &i_lost
);
1283 /* Update ugly stat */
1284 if( i_decoded
> 0 || i_lost
> 0 || i_played
> 0 )
1286 vlc_mutex_lock( &p_input
->p
->counters
.counters_lock
);
1288 stats_UpdateInteger( p_dec
, p_input
->p
->counters
.p_lost_abuffers
,
1290 stats_UpdateInteger( p_dec
, p_input
->p
->counters
.p_played_abuffers
,
1292 stats_UpdateInteger( p_dec
, p_input
->p
->counters
.p_decoded_audio
,
1295 vlc_mutex_unlock( &p_input
->p
->counters
.counters_lock
);
1298 static void DecoderGetCc( decoder_t
*p_dec
, decoder_t
*p_dec_cc
)
1300 decoder_owner_sys_t
*p_owner
= p_dec
->p_owner
;
1303 bool b_processed
= false;
1307 assert( p_dec_cc
->pf_get_cc
!= NULL
);
1309 /* Do not try retreiving CC if not wanted (sout) or cannot be retreived */
1310 if( !p_owner
->cc
.b_supported
)
1313 p_cc
= p_dec_cc
->pf_get_cc( p_dec_cc
, pb_present
);
1317 vlc_mutex_lock( &p_owner
->lock
);
1318 for( i
= 0, i_cc_decoder
= 0; i
< 4; i
++ )
1320 p_owner
->cc
.pb_present
[i
] |= pb_present
[i
];
1321 if( p_owner
->cc
.pp_decoder
[i
] )
1325 for( i
= 0; i
< 4; i
++ )
1327 if( !p_owner
->cc
.pp_decoder
[i
] )
1330 if( i_cc_decoder
> 1 )
1331 DecoderProcess( p_owner
->cc
.pp_decoder
[i
], block_Duplicate( p_cc
) );
1333 DecoderProcess( p_owner
->cc
.pp_decoder
[i
], p_cc
);
1337 vlc_mutex_unlock( &p_owner
->lock
);
1340 block_Release( p_cc
);
1343 static void DecoderPlayVideo( decoder_t
*p_dec
, picture_t
*p_picture
,
1344 int *pi_played_sum
, int *pi_lost_sum
)
1346 decoder_owner_sys_t
*p_owner
= p_dec
->p_owner
;
1347 vout_thread_t
*p_vout
= p_owner
->p_vout
;
1348 bool b_first_buffered
;
1350 if( p_picture
->date
<= VLC_TS_INVALID
)
1352 msg_Warn( p_vout
, "non-dated video buffer received" );
1354 vout_ReleasePicture( p_vout
, p_picture
);
1359 vlc_mutex_lock( &p_owner
->lock
);
1361 if( ( p_owner
->b_buffering
&& !p_owner
->buffer
.b_first
) || p_owner
->buffer
.p_picture
)
1363 p_picture
->p_next
= NULL
;
1365 *p_owner
->buffer
.pp_picture_next
= p_picture
;
1366 p_owner
->buffer
.pp_picture_next
= &p_picture
->p_next
;
1368 p_owner
->buffer
.i_count
++;
1369 if( p_owner
->buffer
.i_count
> DECODER_MAX_BUFFERING_COUNT
||
1370 p_picture
->date
- p_owner
->buffer
.p_picture
->date
> DECODER_MAX_BUFFERING_VIDEO_DURATION
)
1372 p_owner
->buffer
.b_full
= true;
1373 vlc_cond_signal( &p_owner
->wait_acknowledge
);
1376 b_first_buffered
= p_owner
->buffer
.p_picture
!= NULL
;
1378 for( ;; b_first_buffered
= false )
1380 bool b_has_more
= false;
1384 DecoderWaitUnblock( p_dec
, &b_reject
);
1386 if( p_owner
->b_buffering
&& !p_owner
->buffer
.b_first
)
1388 vlc_mutex_unlock( &p_owner
->lock
);
1391 bool b_buffering_first
= p_owner
->b_buffering
;
1394 if( p_owner
->buffer
.p_picture
)
1396 p_picture
= p_owner
->buffer
.p_picture
;
1398 p_owner
->buffer
.p_picture
= p_picture
->p_next
;
1399 p_owner
->buffer
.i_count
--;
1401 b_has_more
= p_owner
->buffer
.p_picture
!= NULL
;
1403 p_owner
->buffer
.pp_picture_next
= &p_owner
->buffer
.p_picture
;
1407 if( b_buffering_first
)
1409 assert( p_owner
->buffer
.b_first
);
1410 assert( !p_owner
->buffer
.i_count
);
1411 msg_Dbg( p_dec
, "Received first picture" );
1412 p_owner
->buffer
.b_first
= false;
1413 p_picture
->b_force
= true;
1416 const bool b_dated
= p_picture
->date
> VLC_TS_INVALID
;
1417 int i_rate
= INPUT_RATE_DEFAULT
;
1418 DecoderFixTs( p_dec
, &p_picture
->date
, NULL
, NULL
,
1419 &i_rate
, DECODER_BOGUS_VIDEO_DELAY
, false );
1421 vlc_mutex_unlock( &p_owner
->lock
);
1424 if( !p_picture
->b_force
&& p_picture
->date
<= VLC_TS_INVALID
) // FIXME --VLC_TS_INVALID verify video_output/*
1429 if( i_rate
!= p_owner
->i_last_rate
|| b_first_buffered
)
1431 /* Be sure to not display old picture after our own */
1432 vout_Flush( p_vout
, p_picture
->date
);
1433 p_owner
->i_last_rate
= i_rate
;
1435 vout_PutPicture( p_vout
, p_picture
);
1440 msg_Warn( p_vout
, "early picture skipped" );
1442 msg_Warn( p_vout
, "non-dated video buffer received" );
1445 vout_ReleasePicture( p_vout
, p_picture
);
1449 vout_GetResetStatistic( p_vout
, &i_tmp_display
, &i_tmp_lost
);
1451 *pi_played_sum
+= i_tmp_display
;
1452 *pi_lost_sum
+= i_tmp_lost
;
1454 if( !b_has_more
|| b_buffering_first
)
1457 vlc_mutex_lock( &p_owner
->lock
);
1458 if( !p_owner
->buffer
.p_picture
)
1460 vlc_mutex_unlock( &p_owner
->lock
);
1466 static void DecoderDecodeVideo( decoder_t
*p_dec
, block_t
*p_block
)
1468 decoder_owner_sys_t
*p_owner
= p_dec
->p_owner
;
1469 input_thread_t
*p_input
= p_owner
->p_input
;
1473 int i_displayed
= 0;
1475 while( (p_pic
= p_dec
->pf_decode_video( p_dec
, &p_block
)) )
1477 vout_thread_t
*p_vout
= p_owner
->p_vout
;
1480 /* It prevent freezing VLC in case of broken decoder */
1481 vout_ReleasePicture( p_vout
, p_pic
);
1483 block_Release( p_block
);
1489 if( p_owner
->i_preroll_end
> VLC_TS_INVALID
&& p_pic
->date
< p_owner
->i_preroll_end
)
1491 vout_ReleasePicture( p_vout
, p_pic
);
1495 if( p_owner
->i_preroll_end
> VLC_TS_INVALID
)
1497 msg_Dbg( p_dec
, "End of video preroll" );
1499 vout_Flush( p_vout
, VLC_TS_INVALID
+1 );
1501 p_owner
->i_preroll_end
= VLC_TS_INVALID
;
1504 if( p_dec
->pf_get_cc
&&
1505 ( !p_owner
->p_packetizer
|| !p_owner
->p_packetizer
->pf_get_cc
) )
1506 DecoderGetCc( p_dec
, p_dec
);
1508 DecoderPlayVideo( p_dec
, p_pic
, &i_displayed
, &i_lost
);
1510 if( i_decoded
> 0 || i_lost
> 0 || i_displayed
> 0 )
1512 vlc_mutex_lock( &p_input
->p
->counters
.counters_lock
);
1514 stats_UpdateInteger( p_dec
, p_input
->p
->counters
.p_decoded_video
,
1516 stats_UpdateInteger( p_dec
, p_input
->p
->counters
.p_lost_pictures
,
1519 stats_UpdateInteger( p_dec
, p_input
->p
->counters
.p_displayed_pictures
,
1522 vlc_mutex_unlock( &p_input
->p
->counters
.counters_lock
);
1526 static void DecoderPlaySpu( decoder_t
*p_dec
, subpicture_t
*p_subpic
,
1529 decoder_owner_sys_t
*p_owner
= p_dec
->p_owner
;
1530 vout_thread_t
*p_vout
= p_owner
->p_spu_vout
;
1533 if( p_subpic
->i_start
<= VLC_TS_INVALID
&& !b_telx
)
1535 msg_Warn( p_dec
, "non-dated spu buffer received" );
1536 subpicture_Delete( p_subpic
);
1541 vlc_mutex_lock( &p_owner
->lock
);
1543 if( p_owner
->b_buffering
|| p_owner
->buffer
.p_subpic
)
1545 p_subpic
->p_next
= NULL
;
1547 *p_owner
->buffer
.pp_subpic_next
= p_subpic
;
1548 p_owner
->buffer
.pp_subpic_next
= &p_subpic
->p_next
;
1550 p_owner
->buffer
.i_count
++;
1551 /* XXX it is important to be full after the first one */
1552 if( p_owner
->buffer
.i_count
> 0 )
1554 p_owner
->buffer
.b_full
= true;
1555 vlc_cond_signal( &p_owner
->wait_acknowledge
);
1561 bool b_has_more
= false;
1563 DecoderWaitUnblock( p_dec
, &b_reject
);
1565 if( p_owner
->b_buffering
)
1567 vlc_mutex_unlock( &p_owner
->lock
);
1572 if( p_owner
->buffer
.p_subpic
)
1574 p_subpic
= p_owner
->buffer
.p_subpic
;
1576 p_owner
->buffer
.p_subpic
= p_subpic
->p_next
;
1577 p_owner
->buffer
.i_count
--;
1579 b_has_more
= p_owner
->buffer
.p_subpic
!= NULL
;
1581 p_owner
->buffer
.pp_subpic_next
= &p_owner
->buffer
.p_subpic
;
1585 DecoderFixTs( p_dec
, &p_subpic
->i_start
, &p_subpic
->i_stop
, NULL
,
1586 NULL
, INT64_MAX
, b_telx
);
1588 vlc_mutex_unlock( &p_owner
->lock
);
1590 if( p_subpic
->i_start
<= VLC_TS_INVALID
)
1593 DecoderWaitDate( p_dec
, &b_reject
,
1594 p_subpic
->i_start
- SPU_MAX_PREPARE_TIME
);
1597 vout_PutSubpicture( p_vout
, p_subpic
);
1599 subpicture_Delete( p_subpic
);
1603 vlc_mutex_lock( &p_owner
->lock
);
1604 if( !p_owner
->buffer
.p_subpic
)
1606 vlc_mutex_unlock( &p_owner
->lock
);
1612 static void DecoderPlaySout( decoder_t
*p_dec
, block_t
*p_sout_block
,
1615 decoder_owner_sys_t
*p_owner
= p_dec
->p_owner
;
1617 assert( p_owner
->p_clock
);
1618 assert( !p_sout_block
->p_next
);
1620 vlc_mutex_lock( &p_owner
->lock
);
1622 if( p_owner
->b_buffering
|| p_owner
->buffer
.p_block
)
1624 block_ChainLastAppend( &p_owner
->buffer
.pp_block_next
, p_sout_block
);
1626 p_owner
->buffer
.i_count
++;
1627 /* XXX it is important to be full after the first one */
1628 if( p_owner
->buffer
.i_count
> 0 )
1630 p_owner
->buffer
.b_full
= true;
1631 vlc_cond_signal( &p_owner
->wait_acknowledge
);
1637 bool b_has_more
= false;
1639 DecoderWaitUnblock( p_dec
, &b_reject
);
1641 if( p_owner
->b_buffering
)
1643 vlc_mutex_unlock( &p_owner
->lock
);
1648 if( p_owner
->buffer
.p_block
)
1650 p_sout_block
= p_owner
->buffer
.p_block
;
1652 p_owner
->buffer
.p_block
= p_sout_block
->p_next
;
1653 p_owner
->buffer
.i_count
--;
1655 b_has_more
= p_owner
->buffer
.p_block
!= NULL
;
1657 p_owner
->buffer
.pp_block_next
= &p_owner
->buffer
.p_block
;
1659 p_sout_block
->p_next
= NULL
;
1661 DecoderFixTs( p_dec
, &p_sout_block
->i_dts
, &p_sout_block
->i_pts
,
1662 &p_sout_block
->i_length
,
1663 &p_sout_block
->i_rate
, INT64_MAX
, b_telx
);
1665 vlc_mutex_unlock( &p_owner
->lock
);
1668 sout_InputSendBuffer( p_owner
->p_sout_input
, p_sout_block
); // FIXME --VLC_TS_INVALID inspect stream_output/*
1670 block_Release( p_sout_block
);
1674 vlc_mutex_lock( &p_owner
->lock
);
1675 if( !p_owner
->buffer
.p_block
)
1677 vlc_mutex_unlock( &p_owner
->lock
);
1684 static void DecoderFlushBuffering( decoder_t
*p_dec
)
1686 decoder_owner_sys_t
*p_owner
= p_dec
->p_owner
;
1688 vlc_assert_locked( &p_owner
->lock
);
1690 while( p_owner
->buffer
.p_picture
)
1692 picture_t
*p_picture
= p_owner
->buffer
.p_picture
;
1694 p_owner
->buffer
.p_picture
= p_picture
->p_next
;
1695 p_owner
->buffer
.i_count
--;
1697 if( p_owner
->p_vout
)
1699 vout_ReleasePicture( p_owner
->p_vout
, p_picture
);
1702 if( !p_owner
->buffer
.p_picture
)
1703 p_owner
->buffer
.pp_picture_next
= &p_owner
->buffer
.p_picture
;
1705 while( p_owner
->buffer
.p_audio
)
1707 aout_buffer_t
*p_audio
= p_owner
->buffer
.p_audio
;
1709 p_owner
->buffer
.p_audio
= p_audio
->p_next
;
1710 p_owner
->buffer
.i_count
--;
1712 aout_BufferFree( p_audio
);
1714 if( !p_owner
->buffer
.p_audio
)
1715 p_owner
->buffer
.pp_audio_next
= &p_owner
->buffer
.p_audio
;
1717 while( p_owner
->buffer
.p_subpic
)
1719 subpicture_t
*p_subpic
= p_owner
->buffer
.p_subpic
;
1721 p_owner
->buffer
.p_subpic
= p_subpic
->p_next
;
1722 p_owner
->buffer
.i_count
--;
1724 subpicture_Delete( p_subpic
);
1726 if( !p_owner
->buffer
.p_subpic
)
1727 p_owner
->buffer
.pp_subpic_next
= &p_owner
->buffer
.p_subpic
;
1729 if( p_owner
->buffer
.p_block
)
1731 block_ChainRelease( p_owner
->buffer
.p_block
);
1733 p_owner
->buffer
.i_count
= 0;
1734 p_owner
->buffer
.p_block
= NULL
;
1735 p_owner
->buffer
.pp_block_next
= &p_owner
->buffer
.p_block
;
1739 /* This function process a block for sout
1741 static void DecoderProcessSout( decoder_t
*p_dec
, block_t
*p_block
)
1743 decoder_owner_sys_t
*p_owner
= (decoder_owner_sys_t
*)p_dec
->p_owner
;
1744 const bool b_telx
= p_dec
->fmt_in
.i_codec
== VLC_CODEC_TELETEXT
;
1745 block_t
*p_sout_block
;
1747 while( ( p_sout_block
=
1748 p_dec
->pf_packetize( p_dec
, p_block
? &p_block
: NULL
) ) )
1750 if( !p_owner
->p_sout_input
)
1752 es_format_Copy( &p_owner
->sout
, &p_dec
->fmt_out
);
1754 p_owner
->sout
.i_group
= p_dec
->fmt_in
.i_group
;
1755 p_owner
->sout
.i_id
= p_dec
->fmt_in
.i_id
;
1756 if( p_dec
->fmt_in
.psz_language
)
1758 free( p_owner
->sout
.psz_language
);
1759 p_owner
->sout
.psz_language
=
1760 strdup( p_dec
->fmt_in
.psz_language
);
1763 p_owner
->p_sout_input
=
1764 sout_InputNew( p_owner
->p_sout
,
1767 if( p_owner
->p_sout_input
== NULL
)
1769 msg_Err( p_dec
, "cannot create packetizer output (%4.4s)",
1770 (char *)&p_owner
->sout
.i_codec
);
1771 p_dec
->b_error
= true;
1773 while( p_sout_block
)
1775 block_t
*p_next
= p_sout_block
->p_next
;
1776 block_Release( p_sout_block
);
1777 p_sout_block
= p_next
;
1783 while( p_sout_block
)
1785 block_t
*p_next
= p_sout_block
->p_next
;
1787 p_sout_block
->p_next
= NULL
;
1789 DecoderPlaySout( p_dec
, p_sout_block
, b_telx
);
1791 p_sout_block
= p_next
;
1796 /* This function process a video block
1798 static void DecoderProcessVideo( decoder_t
*p_dec
, block_t
*p_block
, bool b_flush
)
1800 decoder_owner_sys_t
*p_owner
= (decoder_owner_sys_t
*)p_dec
->p_owner
;
1802 if( p_owner
->p_packetizer
)
1804 block_t
*p_packetized_block
;
1805 decoder_t
*p_packetizer
= p_owner
->p_packetizer
;
1807 while( (p_packetized_block
=
1808 p_packetizer
->pf_packetize( p_packetizer
, p_block
? &p_block
: NULL
)) )
1810 if( p_packetizer
->fmt_out
.i_extra
&& !p_dec
->fmt_in
.i_extra
)
1812 es_format_Clean( &p_dec
->fmt_in
);
1813 es_format_Copy( &p_dec
->fmt_in
, &p_packetizer
->fmt_out
);
1815 if( p_packetizer
->pf_get_cc
)
1816 DecoderGetCc( p_dec
, p_packetizer
);
1818 while( p_packetized_block
)
1820 block_t
*p_next
= p_packetized_block
->p_next
;
1821 p_packetized_block
->p_next
= NULL
;
1823 DecoderDecodeVideo( p_dec
, p_packetized_block
);
1825 p_packetized_block
= p_next
;
1828 /* The packetizer does not output a block that tell the decoder to flush
1832 block_t
*p_null
= DecoderBlockFlushNew();
1834 DecoderDecodeVideo( p_dec
, p_null
);
1839 DecoderDecodeVideo( p_dec
, p_block
);
1842 if( b_flush
&& p_owner
->p_vout
)
1843 vout_Flush( p_owner
->p_vout
, VLC_TS_INVALID
+1 );
1846 /* This function process a audio block
1848 static void DecoderProcessAudio( decoder_t
*p_dec
, block_t
*p_block
, bool b_flush
)
1850 decoder_owner_sys_t
*p_owner
= (decoder_owner_sys_t
*)p_dec
->p_owner
;
1852 if( p_owner
->p_packetizer
)
1854 block_t
*p_packetized_block
;
1855 decoder_t
*p_packetizer
= p_owner
->p_packetizer
;
1857 while( (p_packetized_block
=
1858 p_packetizer
->pf_packetize( p_packetizer
, p_block
? &p_block
: NULL
)) )
1860 if( p_packetizer
->fmt_out
.i_extra
&& !p_dec
->fmt_in
.i_extra
)
1862 es_format_Clean( &p_dec
->fmt_in
);
1863 es_format_Copy( &p_dec
->fmt_in
, &p_packetizer
->fmt_out
);
1866 while( p_packetized_block
)
1868 block_t
*p_next
= p_packetized_block
->p_next
;
1869 p_packetized_block
->p_next
= NULL
;
1871 DecoderDecodeAudio( p_dec
, p_packetized_block
);
1873 p_packetized_block
= p_next
;
1876 /* The packetizer does not output a block that tell the decoder to flush
1880 block_t
*p_null
= DecoderBlockFlushNew();
1882 DecoderDecodeAudio( p_dec
, p_null
);
1887 DecoderDecodeAudio( p_dec
, p_block
);
1890 if( b_flush
&& p_owner
->p_aout
&& p_owner
->p_aout_input
)
1891 aout_DecFlush( p_owner
->p_aout
, p_owner
->p_aout_input
);
1894 /* This function process a subtitle block
1896 static void DecoderProcessSpu( decoder_t
*p_dec
, block_t
*p_block
, bool b_flush
)
1898 decoder_owner_sys_t
*p_owner
= p_dec
->p_owner
;
1899 const bool b_telx
= p_dec
->fmt_in
.i_codec
== VLC_CODEC_TELETEXT
;
1901 input_thread_t
*p_input
= p_owner
->p_input
;
1902 vout_thread_t
*p_vout
;
1903 subpicture_t
*p_spu
;
1905 while( (p_spu
= p_dec
->pf_decode_sub( p_dec
, p_block
? &p_block
: NULL
) ) )
1907 vlc_mutex_lock( &p_input
->p
->counters
.counters_lock
);
1908 stats_UpdateInteger( p_dec
, p_input
->p
->counters
.p_decoded_sub
, 1, NULL
);
1909 vlc_mutex_unlock( &p_input
->p
->counters
.counters_lock
);
1911 p_vout
= input_resource_HoldVout( p_input
->p
->p_resource
);
1912 if( p_vout
&& p_owner
->p_spu_vout
== p_vout
)
1914 /* Preroll does not work very well with subtitle */
1915 if( p_spu
->i_start
> VLC_TS_INVALID
&&
1916 p_spu
->i_start
< p_owner
->i_preroll_end
&&
1917 ( p_spu
->i_stop
<= VLC_TS_INVALID
|| p_spu
->i_stop
< p_owner
->i_preroll_end
) )
1919 subpicture_Delete( p_spu
);
1923 DecoderPlaySpu( p_dec
, p_spu
, b_telx
);
1928 subpicture_Delete( p_spu
);
1931 vlc_object_release( p_vout
);
1934 if( b_flush
&& p_owner
->p_spu_vout
)
1936 p_vout
= input_resource_HoldVout( p_input
->p
->p_resource
);
1938 if( p_vout
&& p_owner
->p_spu_vout
== p_vout
)
1939 vout_FlushSubpictureChannel( p_vout
, p_owner
->i_spu_channel
);
1942 vlc_object_release( p_vout
);
1947 static void DecoderProcessOnFlush( decoder_t
*p_dec
)
1949 decoder_owner_sys_t
*p_owner
= p_dec
->p_owner
;
1951 vlc_mutex_lock( &p_owner
->lock
);
1952 DecoderFlushBuffering( p_dec
);
1954 if( p_owner
->b_flushing
)
1956 p_owner
->b_flushing
= false;
1957 vlc_cond_signal( &p_owner
->wait_acknowledge
);
1959 vlc_mutex_unlock( &p_owner
->lock
);
1965 * \param p_dec the decoder object
1966 * \param p_block the block to decode
1967 * \return VLC_SUCCESS or an error code
1969 static void DecoderProcess( decoder_t
*p_dec
, block_t
*p_block
)
1971 decoder_owner_sys_t
*p_owner
= (decoder_owner_sys_t
*)p_dec
->p_owner
;
1972 const bool b_flush_request
= p_block
&& (p_block
->i_flags
& BLOCK_FLAG_CORE_FLUSH
);
1974 if( p_block
&& p_block
->i_buffer
<= 0 )
1976 assert( !b_flush_request
);
1977 block_Release( p_block
);
1982 if( p_owner
->b_packetizer
)
1985 p_block
->i_flags
&= ~BLOCK_FLAG_CORE_PRIVATE_MASK
;
1987 DecoderProcessSout( p_dec
, p_block
);
1992 bool b_flush
= false;
1996 const bool b_flushing
= p_owner
->i_preroll_end
== INT64_MAX
;
1997 DecoderUpdatePreroll( &p_owner
->i_preroll_end
, p_block
);
1999 b_flush
= !b_flushing
&& b_flush_request
;
2001 p_block
->i_flags
&= ~BLOCK_FLAG_CORE_PRIVATE_MASK
;
2004 if( p_dec
->fmt_out
.i_cat
== AUDIO_ES
)
2006 DecoderProcessAudio( p_dec
, p_block
, b_flush
);
2008 else if( p_dec
->fmt_out
.i_cat
== VIDEO_ES
)
2010 DecoderProcessVideo( p_dec
, p_block
, b_flush
);
2012 else if( p_dec
->fmt_out
.i_cat
== SPU_ES
)
2014 DecoderProcessSpu( p_dec
, p_block
, b_flush
);
2018 msg_Err( p_dec
, "unknown ES format" );
2019 p_dec
->b_error
= true;
2024 if( b_flush_request
)
2025 DecoderProcessOnFlush( p_dec
);
2028 static void DecoderError( decoder_t
*p_dec
, block_t
*p_block
)
2030 const bool b_flush_request
= p_block
&& (p_block
->i_flags
& BLOCK_FLAG_CORE_FLUSH
);
2034 block_Release( p_block
);
2036 if( b_flush_request
)
2037 DecoderProcessOnFlush( p_dec
);
2042 * Destroys a decoder object
2044 * \param p_dec the decoder object
2047 static void DeleteDecoder( decoder_t
* p_dec
)
2049 decoder_owner_sys_t
*p_owner
= p_dec
->p_owner
;
2051 msg_Dbg( p_dec
, "killing decoder fourcc `%4.4s', %u PES in FIFO",
2052 (char*)&p_dec
->fmt_in
.i_codec
,
2053 (unsigned)block_FifoCount( p_owner
->p_fifo
) );
2055 /* Free all packets still in the decoder fifo. */
2056 block_FifoEmpty( p_owner
->p_fifo
);
2057 block_FifoRelease( p_owner
->p_fifo
);
2060 vlc_mutex_lock( &p_owner
->lock
);
2061 DecoderFlushBuffering( p_dec
);
2062 vlc_mutex_unlock( &p_owner
->lock
);
2065 if( p_owner
->p_aout_input
)
2066 aout_DecDelete( p_owner
->p_aout
, p_owner
->p_aout_input
);
2067 if( p_owner
->p_aout
)
2069 input_resource_RequestAout( p_owner
->p_input
->p
->p_resource
,
2071 input_SendEventAout( p_owner
->p_input
);
2072 p_owner
->p_aout
= NULL
;
2074 if( p_owner
->p_vout
)
2076 /* Hack to make sure all the the pictures are freed by the decoder
2077 * and that the vout is not paused anymore */
2078 vout_Reset( p_owner
->p_vout
);
2081 input_resource_RequestVout( p_owner
->p_input
->p
->p_resource
, p_owner
->p_vout
, NULL
, 0, true );
2082 input_SendEventVout( p_owner
->p_input
);
2086 if( p_owner
->p_sout_input
)
2088 sout_InputDelete( p_owner
->p_sout_input
);
2089 es_format_Clean( &p_owner
->sout
);
2093 if( p_dec
->fmt_out
.i_cat
== SPU_ES
)
2095 vout_thread_t
*p_vout
;
2097 p_vout
= input_resource_HoldVout( p_owner
->p_input
->p
->p_resource
);
2100 if( p_owner
->p_spu_vout
== p_vout
)
2101 vout_FlushSubpictureChannel( p_vout
, p_owner
->i_spu_channel
);
2102 vlc_object_release( p_vout
);
2106 es_format_Clean( &p_dec
->fmt_in
);
2107 es_format_Clean( &p_dec
->fmt_out
);
2108 if( p_dec
->p_description
)
2109 vlc_meta_Delete( p_dec
->p_description
);
2110 es_format_Clean( &p_owner
->fmt_description
);
2111 if( p_owner
->p_description
)
2112 vlc_meta_Delete( p_owner
->p_description
);
2114 if( p_owner
->p_packetizer
)
2116 module_unneed( p_owner
->p_packetizer
,
2117 p_owner
->p_packetizer
->p_module
);
2118 es_format_Clean( &p_owner
->p_packetizer
->fmt_in
);
2119 es_format_Clean( &p_owner
->p_packetizer
->fmt_out
);
2120 if( p_owner
->p_packetizer
->p_description
)
2121 vlc_meta_Delete( p_owner
->p_packetizer
->p_description
);
2122 vlc_object_release( p_owner
->p_packetizer
);
2125 vlc_cond_destroy( &p_owner
->wait_acknowledge
);
2126 vlc_cond_destroy( &p_owner
->wait_request
);
2127 vlc_mutex_destroy( &p_owner
->lock
);
2129 vlc_object_release( p_dec
);
2134 /*****************************************************************************
2135 * Buffers allocation callbacks for the decoders
2136 *****************************************************************************/
2137 static void DecoderUpdateFormatLocked( decoder_t
*p_dec
)
2139 decoder_owner_sys_t
*p_owner
= p_dec
->p_owner
;
2141 vlc_assert_locked( &p_owner
->lock
);
2143 p_owner
->b_fmt_description
= true;
2145 /* Copy es_format */
2146 es_format_Clean( &p_owner
->fmt_description
);
2147 es_format_Copy( &p_owner
->fmt_description
, &p_dec
->fmt_out
);
2149 /* Move p_description */
2150 if( p_owner
->p_description
&& p_dec
->p_description
)
2151 vlc_meta_Delete( p_owner
->p_description
);
2152 p_owner
->p_description
= p_dec
->p_description
;
2153 p_dec
->p_description
= NULL
;
2155 static vout_thread_t
*aout_request_vout( void *p_private
,
2156 vout_thread_t
*p_vout
, video_format_t
*p_fmt
, bool b_recyle
)
2158 decoder_t
*p_dec
= p_private
;
2159 input_thread_t
*p_input
= p_dec
->p_owner
->p_input
;
2161 p_vout
= input_resource_RequestVout( p_input
->p
->p_resource
, p_vout
, p_fmt
, 1, b_recyle
);
2162 input_SendEventVout( p_input
);
2167 static aout_buffer_t
*aout_new_buffer( decoder_t
*p_dec
, int i_samples
)
2169 decoder_owner_sys_t
*p_owner
= p_dec
->p_owner
;
2170 aout_buffer_t
*p_buffer
;
2172 if( p_owner
->p_aout_input
!= NULL
&&
2173 ( p_dec
->fmt_out
.audio
.i_rate
!= p_owner
->audio
.i_rate
||
2174 p_dec
->fmt_out
.audio
.i_original_channels
!=
2175 p_owner
->audio
.i_original_channels
||
2176 p_dec
->fmt_out
.audio
.i_bytes_per_frame
!=
2177 p_owner
->audio
.i_bytes_per_frame
) )
2179 aout_input_t
*p_aout_input
= p_owner
->p_aout_input
;
2181 /* Parameters changed, restart the aout */
2182 vlc_mutex_lock( &p_owner
->lock
);
2184 DecoderFlushBuffering( p_dec
);
2186 p_owner
->p_aout_input
= NULL
;
2187 aout_DecDelete( p_owner
->p_aout
, p_aout_input
);
2189 vlc_mutex_unlock( &p_owner
->lock
);
2192 if( p_owner
->p_aout_input
== NULL
)
2194 const int i_force_dolby
= var_InheritInteger( p_dec
, "force-dolby-surround" );
2195 audio_sample_format_t format
;
2196 aout_input_t
*p_aout_input
;
2197 aout_instance_t
*p_aout
;
2198 aout_request_vout_t request_vout
;
2200 p_dec
->fmt_out
.audio
.i_format
= p_dec
->fmt_out
.i_codec
;
2201 p_owner
->audio
= p_dec
->fmt_out
.audio
;
2203 memcpy( &format
, &p_owner
->audio
, sizeof( audio_sample_format_t
) );
2204 if( i_force_dolby
&&
2205 (format
.i_original_channels
&AOUT_CHAN_PHYSMASK
) ==
2206 (AOUT_CHAN_LEFT
|AOUT_CHAN_RIGHT
) )
2208 if( i_force_dolby
== 1 )
2210 format
.i_original_channels
= format
.i_original_channels
|
2211 AOUT_CHAN_DOLBYSTEREO
;
2213 else /* i_force_dolby == 2 */
2215 format
.i_original_channels
= format
.i_original_channels
&
2216 ~AOUT_CHAN_DOLBYSTEREO
;
2220 request_vout
.pf_request_vout
= aout_request_vout
;
2221 request_vout
.p_private
= p_dec
;
2223 p_aout
= p_owner
->p_aout
;
2225 p_aout
= input_resource_RequestAout( p_owner
->p_input
->p
->p_resource
, NULL
);
2226 p_aout_input
= aout_DecNew( p_dec
, &p_aout
,
2227 &format
, &p_dec
->fmt_out
.audio_replay_gain
, &request_vout
);
2229 vlc_mutex_lock( &p_owner
->lock
);
2231 p_owner
->p_aout
= p_aout
;
2232 p_owner
->p_aout_input
= p_aout_input
;
2233 DecoderUpdateFormatLocked( p_dec
);
2235 vlc_mutex_unlock( &p_owner
->lock
);
2237 input_SendEventAout( p_owner
->p_input
);
2239 if( p_owner
->p_aout_input
== NULL
)
2241 msg_Err( p_dec
, "failed to create audio output" );
2242 p_dec
->b_error
= true;
2245 p_dec
->fmt_out
.audio
.i_bytes_per_frame
=
2246 p_owner
->audio
.i_bytes_per_frame
;
2249 p_buffer
= aout_DecNewBuffer( p_owner
->p_aout_input
, i_samples
);
2254 static void aout_del_buffer( decoder_t
*p_dec
, aout_buffer_t
*p_buffer
)
2256 decoder_owner_sys_t
*p_owner
= p_dec
->p_owner
;
2258 aout_DecDeleteBuffer( p_owner
->p_aout
,
2259 p_owner
->p_aout_input
, p_buffer
);
2262 static picture_t
*vout_new_buffer( decoder_t
*p_dec
)
2264 decoder_owner_sys_t
*p_owner
= p_dec
->p_owner
;
2266 if( p_owner
->p_vout
== NULL
||
2267 p_dec
->fmt_out
.video
.i_width
!= p_owner
->video
.i_width
||
2268 p_dec
->fmt_out
.video
.i_height
!= p_owner
->video
.i_height
||
2269 p_dec
->fmt_out
.video
.i_visible_width
!= p_owner
->video
.i_visible_width
||
2270 p_dec
->fmt_out
.video
.i_visible_height
!= p_owner
->video
.i_visible_height
||
2271 p_dec
->fmt_out
.video
.i_x_offset
!= p_owner
->video
.i_x_offset
||
2272 p_dec
->fmt_out
.video
.i_y_offset
!= p_owner
->video
.i_y_offset
||
2273 p_dec
->fmt_out
.i_codec
!= p_owner
->video
.i_chroma
||
2274 (int64_t)p_dec
->fmt_out
.video
.i_sar_num
* p_owner
->video
.i_sar_den
!=
2275 (int64_t)p_dec
->fmt_out
.video
.i_sar_den
* p_owner
->video
.i_sar_num
)
2277 vout_thread_t
*p_vout
;
2279 if( !p_dec
->fmt_out
.video
.i_width
||
2280 !p_dec
->fmt_out
.video
.i_height
)
2282 /* Can't create a new vout without display size */
2286 video_format_t fmt
= p_dec
->fmt_out
.video
;
2287 fmt
.i_chroma
= p_dec
->fmt_out
.i_codec
;
2288 p_owner
->video
= fmt
;
2290 if( !fmt
.i_visible_width
|| !fmt
.i_visible_height
)
2292 if( p_dec
->fmt_in
.video
.i_visible_width
&&
2293 p_dec
->fmt_in
.video
.i_visible_height
)
2295 fmt
.i_visible_width
= p_dec
->fmt_in
.video
.i_visible_width
;
2296 fmt
.i_visible_height
= p_dec
->fmt_in
.video
.i_visible_height
;
2300 fmt
.i_visible_width
= fmt
.i_width
;
2301 fmt
.i_visible_height
= fmt
.i_height
;
2305 if( fmt
.i_visible_height
== 1088 &&
2306 var_CreateGetBool( p_dec
, "hdtv-fix" ) )
2308 fmt
.i_visible_height
= 1080;
2309 if( !(fmt
.i_sar_num
% 136))
2311 fmt
.i_sar_num
*= 135;
2312 fmt
.i_sar_den
*= 136;
2314 msg_Warn( p_dec
, "Fixing broken HDTV stream (display_height=1088)");
2317 if( !fmt
.i_sar_num
|| !fmt
.i_sar_den
)
2323 vlc_ureduce( &fmt
.i_sar_num
, &fmt
.i_sar_den
,
2324 fmt
.i_sar_num
, fmt
.i_sar_den
, 50000 );
2326 vlc_mutex_lock( &p_owner
->lock
);
2328 DecoderFlushBuffering( p_dec
);
2330 p_vout
= p_owner
->p_vout
;
2331 p_owner
->p_vout
= NULL
;
2332 vlc_mutex_unlock( &p_owner
->lock
);
2335 switch( p_dec
->fmt_in
.i_codec
)
2337 case VLC_CODEC_H264
:
2338 case VLC_CODEC_DIRAC
: /* FIXME valid ? */
2343 case VLC_CODEC_VP6F
:
2351 p_vout
= input_resource_RequestVout( p_owner
->p_input
->p
->p_resource
,
2353 dpb_size
+ 1 + DECODER_MAX_BUFFERING_COUNT
,
2355 vlc_mutex_lock( &p_owner
->lock
);
2356 p_owner
->p_vout
= p_vout
;
2358 DecoderUpdateFormatLocked( p_dec
);
2360 vlc_mutex_unlock( &p_owner
->lock
);
2362 input_SendEventVout( p_owner
->p_input
);
2363 if( p_vout
== NULL
)
2365 msg_Err( p_dec
, "failed to create video output" );
2366 p_dec
->b_error
= true;
2371 /* Get a new picture
2375 if( p_dec
->b_die
|| p_dec
->b_error
)
2378 picture_t
*p_picture
= vout_GetPicture( p_owner
->p_vout
);
2382 if( DecoderIsFlushing( p_dec
) )
2386 DecoderSignalBuffering( p_dec
, true );
2388 /* Check the decoder doesn't leak pictures */
2389 vout_FixLeaks( p_owner
->p_vout
);
2391 /* FIXME add a vout_WaitPictureAvailable (timedwait) */
2392 msleep( VOUT_OUTMEM_SLEEP
);
2396 static void vout_del_buffer( decoder_t
*p_dec
, picture_t
*p_pic
)
2398 vout_ReleasePicture( p_dec
->p_owner
->p_vout
, p_pic
);
2401 static void vout_link_picture( decoder_t
*p_dec
, picture_t
*p_pic
)
2403 vout_HoldPicture( p_dec
->p_owner
->p_vout
, p_pic
);
2406 static void vout_unlink_picture( decoder_t
*p_dec
, picture_t
*p_pic
)
2408 vout_ReleasePicture( p_dec
->p_owner
->p_vout
, p_pic
);
2411 static subpicture_t
*spu_new_buffer( decoder_t
*p_dec
,
2412 const subpicture_updater_t
*p_updater
)
2414 decoder_owner_sys_t
*p_owner
= p_dec
->p_owner
;
2415 vout_thread_t
*p_vout
= NULL
;
2416 subpicture_t
*p_subpic
;
2417 int i_attempts
= 30;
2419 while( i_attempts
-- )
2421 if( p_dec
->b_die
|| p_dec
->b_error
)
2424 p_vout
= input_resource_HoldVout( p_owner
->p_input
->p
->p_resource
);
2428 msleep( DECODER_SPU_VOUT_WAIT_DURATION
);
2433 msg_Warn( p_dec
, "no vout found, dropping subpicture" );
2437 if( p_owner
->p_spu_vout
!= p_vout
)
2439 vlc_mutex_lock( &p_owner
->lock
);
2441 DecoderFlushBuffering( p_dec
);
2443 vlc_mutex_unlock( &p_owner
->lock
);
2445 p_owner
->i_spu_channel
= vout_RegisterSubpictureChannel( p_vout
);
2446 p_owner
->i_spu_order
= 0;
2447 p_owner
->p_spu_vout
= p_vout
;
2450 p_subpic
= subpicture_New( p_updater
);
2453 p_subpic
->i_channel
= p_owner
->i_spu_channel
;
2454 p_subpic
->i_order
= p_owner
->i_spu_order
++;
2455 p_subpic
->b_subtitle
= true;
2458 vlc_object_release( p_vout
);
2463 static void spu_del_buffer( decoder_t
*p_dec
, subpicture_t
*p_subpic
)
2465 decoder_owner_sys_t
*p_owner
= p_dec
->p_owner
;
2466 vout_thread_t
*p_vout
= NULL
;
2468 p_vout
= input_resource_HoldVout( p_owner
->p_input
->p
->p_resource
);
2469 if( !p_vout
|| p_owner
->p_spu_vout
!= p_vout
)
2472 vlc_object_release( p_vout
);
2473 msg_Warn( p_dec
, "no vout found, leaking subpicture" );
2477 subpicture_Delete( p_subpic
);
2479 vlc_object_release( p_vout
);