1 /*****************************************************************************
2 * decoder.c: Functions for the management of decoders
3 *****************************************************************************
4 * Copyright (C) 1999-2004 VLC authors and VideoLAN
6 * Authors: Christophe Massiot <massiot@via.ecp.fr>
7 * Gildas Bazin <gbazin@videolan.org>
8 * Laurent Aimar <fenrir@via.ecp.fr>
10 * This program is free software; you can redistribute it and/or modify it
11 * under the terms of the GNU Lesser General Public License as published by
12 * the Free Software Foundation; either version 2.1 of the License, or
13 * (at your option) any later version.
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU Lesser General Public License for more details.
20 * You should have received a copy of the GNU Lesser General Public License
21 * along with this program; if not, write to the Free Software Foundation,
22 * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
23 *****************************************************************************/
25 /*****************************************************************************
27 *****************************************************************************/
32 #include <stdatomic.h>
34 #include <vlc_common.h>
35 #include <vlc_block.h>
39 #include <vlc_codec.h>
42 #include <vlc_dialog.h>
43 #include <vlc_modules.h>
45 #include "audio_output/aout_internal.h"
46 #include "stream_output/stream_output.h"
47 #include "input_internal.h"
48 #include "../clock/input_clock.h"
53 #include "../video_output/vout_internal.h"
56 * Possibles values set in p_owner->reload atomic
61 RELOAD_DECODER
, /* Reload the decoder module */
62 RELOAD_DECODER_AOUT
/* Stop the aout and reload the decoder module */
68 input_thread_t
*p_input
;
69 input_resource_t
*p_resource
;
70 input_clock_t
*p_clock
;
76 sout_instance_t
*p_sout
;
77 sout_packetizer_input_t
*p_sout_input
;
81 void (*pf_update_stat
)( struct decoder_owner
*, unsigned decoded
, unsigned lost
);
83 /* Some decoders require already packetized data (ie. not truncated) */
84 decoder_t
*p_packetizer
;
87 /* Current format in use by the output */
91 atomic_bool b_fmt_description
;
92 vlc_meta_t
*p_description
;
98 /* Lock for communication with decoder thread */
100 vlc_cond_t wait_request
;
101 vlc_cond_t wait_acknowledge
;
102 vlc_cond_t wait_fifo
; /* TODO: merge with wait_acknowledge */
103 vlc_cond_t wait_timed
;
105 /* -- These variables need locking on write(only) -- */
106 audio_output_t
*p_aout
;
108 vout_thread_t
*p_vout
;
110 /* -- Theses variables need locking on read *and* write -- */
112 vlc_tick_t i_preroll_end
;
114 bool reset_out_state
;
115 vlc_tick_t pause_date
;
117 unsigned frames_countdown
;
134 #define MAX_CC_DECODERS 64 /* The es_out only creates one type of es */
138 decoder_cc_desc_t desc
;
139 decoder_t
*pp_decoder
[MAX_CC_DECODERS
];
141 sout_packetizer_input_t
*p_sout_input
;
145 vlc_tick_t i_ts_delay
;
148 vlc_mutex_t mouse_lock
;
149 vlc_mouse_event mouse_event
;
153 /* Pictures which are DECODER_BOGUS_VIDEO_DELAY or more in advance probably have
154 * a bogus PTS and won't be displayed */
155 #define DECODER_BOGUS_VIDEO_DELAY ((vlc_tick_t)(DEFAULT_PTS_DELAY * 30))
158 #define DECODER_SPU_VOUT_WAIT_DURATION VLC_TICK_FROM_MS(200)
159 #define BLOCK_FLAG_CORE_PRIVATE_RELOADED (1 << BLOCK_FLAG_CORE_PRIVATE_SHIFT)
161 static inline struct decoder_owner
*dec_get_owner( decoder_t
*p_dec
)
163 return container_of( p_dec
, struct decoder_owner
, dec
);
167 * Load a decoder module
169 static int LoadDecoder( decoder_t
*p_dec
, bool b_packetizer
,
170 const es_format_t
*restrict p_fmt
)
172 p_dec
->b_frame_drop_allowed
= true;
173 p_dec
->i_extra_picture_buffers
= 0;
175 p_dec
->pf_decode
= NULL
;
176 p_dec
->pf_get_cc
= NULL
;
177 p_dec
->pf_packetize
= NULL
;
178 p_dec
->pf_flush
= NULL
;
180 es_format_Copy( &p_dec
->fmt_in
, p_fmt
);
181 es_format_Init( &p_dec
->fmt_out
, p_fmt
->i_cat
, 0 );
183 /* Find a suitable decoder/packetizer module */
186 static const char caps
[ES_CATEGORY_COUNT
][16] = {
187 [VIDEO_ES
] = "video decoder",
188 [AUDIO_ES
] = "audio decoder",
189 [SPU_ES
] = "spu decoder",
191 p_dec
->p_module
= module_need_var( p_dec
, caps
[p_dec
->fmt_in
.i_cat
],
195 p_dec
->p_module
= module_need_var( p_dec
, "packetizer", "packetizer" );
197 if( !p_dec
->p_module
)
199 es_format_Clean( &p_dec
->fmt_in
);
207 * Unload a decoder module
209 static void UnloadDecoder( decoder_t
*p_dec
)
211 if( p_dec
->p_module
)
213 module_unneed( p_dec
, p_dec
->p_module
);
214 p_dec
->p_module
= NULL
;
217 if( p_dec
->p_description
)
219 vlc_meta_Delete( p_dec
->p_description
);
220 p_dec
->p_description
= NULL
;
223 es_format_Clean( &p_dec
->fmt_in
);
224 es_format_Clean( &p_dec
->fmt_out
);
227 static int ReloadDecoder( decoder_t
*p_dec
, bool b_packetizer
,
228 const es_format_t
*restrict p_fmt
, enum reload reload
)
230 /* Copy p_fmt since it can be destroyed by UnloadDecoder */
231 struct decoder_owner
*p_owner
= dec_get_owner( p_dec
);
233 if( es_format_Copy( &fmt_in
, p_fmt
) != VLC_SUCCESS
)
235 p_owner
->error
= true;
239 /* Restart the decoder module */
240 UnloadDecoder( p_dec
);
241 p_owner
->error
= false;
243 if( reload
== RELOAD_DECODER_AOUT
)
245 assert( p_owner
->fmt
.i_cat
== AUDIO_ES
);
246 audio_output_t
*p_aout
= p_owner
->p_aout
;
248 vlc_mutex_lock( &p_owner
->lock
);
249 p_owner
->p_aout
= NULL
;
250 vlc_mutex_unlock( &p_owner
->lock
);
253 aout_DecDelete( p_aout
);
254 input_resource_PutAout( p_owner
->p_resource
, p_aout
);
258 if( LoadDecoder( p_dec
, b_packetizer
, &fmt_in
) )
260 p_owner
->error
= true;
261 es_format_Clean( &fmt_in
);
264 es_format_Clean( &fmt_in
);
268 static void DecoderUpdateFormatLocked( decoder_t
*p_dec
)
270 struct decoder_owner
*p_owner
= dec_get_owner( p_dec
);
272 vlc_mutex_assert( &p_owner
->lock
);
274 es_format_Clean( &p_owner
->fmt
);
275 es_format_Copy( &p_owner
->fmt
, &p_dec
->fmt_out
);
277 /* Move p_description */
278 if( p_dec
->p_description
!= NULL
)
280 if( p_owner
->p_description
!= NULL
)
281 vlc_meta_Delete( p_owner
->p_description
);
282 p_owner
->p_description
= p_dec
->p_description
;
283 p_dec
->p_description
= NULL
;
286 atomic_store_explicit( &p_owner
->b_fmt_description
, true,
287 memory_order_release
);
290 static void MouseEvent( const vlc_mouse_t
*newmouse
, void *user_data
)
292 decoder_t
*dec
= user_data
;
293 struct decoder_owner
*owner
= dec_get_owner( dec
);
295 vlc_mutex_lock( &owner
->mouse_lock
);
296 if( owner
->mouse_event
)
297 owner
->mouse_event( newmouse
, owner
->mouse_opaque
);
298 vlc_mutex_unlock( &owner
->mouse_lock
);
301 /*****************************************************************************
302 * Buffers allocation callbacks for the decoders
303 *****************************************************************************/
304 static bool aout_replaygain_changed( const audio_replay_gain_t
*a
,
305 const audio_replay_gain_t
*b
)
307 for( size_t i
=0; i
<AUDIO_REPLAY_GAIN_MAX
; i
++ )
309 if( a
->pb_gain
[i
] != b
->pb_gain
[i
] ||
310 a
->pb_peak
[i
] != b
->pb_peak
[i
] ||
311 a
->pb_gain
[i
] != b
->pb_gain
[i
] ||
312 a
->pb_peak
[i
] != b
->pb_peak
[i
] )
318 static int aout_update_format( decoder_t
*p_dec
)
320 struct decoder_owner
*p_owner
= dec_get_owner( p_dec
);
322 if( p_owner
->p_aout
&&
323 ( !AOUT_FMTS_IDENTICAL(&p_dec
->fmt_out
.audio
, &p_owner
->fmt
.audio
) ||
324 p_dec
->fmt_out
.i_codec
!= p_dec
->fmt_out
.audio
.i_format
||
325 p_dec
->fmt_out
.i_profile
!= p_owner
->fmt
.i_profile
) )
327 audio_output_t
*p_aout
= p_owner
->p_aout
;
329 /* Parameters changed, restart the aout */
330 vlc_mutex_lock( &p_owner
->lock
);
331 p_owner
->p_aout
= NULL
;
332 vlc_mutex_unlock( &p_owner
->lock
);
333 aout_DecDelete( p_aout
);
335 input_resource_PutAout( p_owner
->p_resource
, p_aout
);
338 /* Check if only replay gain has changed */
339 if( aout_replaygain_changed( &p_dec
->fmt_in
.audio_replay_gain
,
340 &p_owner
->fmt
.audio_replay_gain
) )
342 p_dec
->fmt_out
.audio_replay_gain
= p_dec
->fmt_in
.audio_replay_gain
;
343 if( p_owner
->p_aout
)
345 p_owner
->fmt
.audio_replay_gain
= p_dec
->fmt_in
.audio_replay_gain
;
346 var_TriggerCallback( p_owner
->p_aout
, "audio-replay-gain-mode" );
350 if( p_owner
->p_aout
== NULL
)
352 p_dec
->fmt_out
.audio
.i_format
= p_dec
->fmt_out
.i_codec
;
354 audio_sample_format_t format
= p_dec
->fmt_out
.audio
;
355 aout_FormatPrepare( &format
);
357 const int i_force_dolby
= var_InheritInteger( p_dec
, "force-dolby-surround" );
359 format
.i_physical_channels
== (AOUT_CHAN_LEFT
|AOUT_CHAN_RIGHT
) )
361 if( i_force_dolby
== 1 )
362 format
.i_chan_mode
|= AOUT_CHANMODE_DOLBYSTEREO
;
363 else /* i_force_dolby == 2 */
364 format
.i_chan_mode
&= ~AOUT_CHANMODE_DOLBYSTEREO
;
367 audio_output_t
*p_aout
;
369 p_aout
= input_resource_GetAout( p_owner
->p_resource
);
372 /* TODO: 3.0 HACK: we need to put i_profile inside audio_format_t
374 if( p_dec
->fmt_out
.i_codec
== VLC_CODEC_DTS
)
375 var_SetBool( p_aout
, "dtshd", p_dec
->fmt_out
.i_profile
> 0 );
377 if( aout_DecNew( p_aout
, &format
,
378 &p_dec
->fmt_out
.audio_replay_gain
) )
380 input_resource_PutAout( p_owner
->p_resource
, p_aout
);
385 vlc_mutex_lock( &p_owner
->lock
);
386 p_owner
->p_aout
= p_aout
;
388 DecoderUpdateFormatLocked( p_dec
);
389 aout_FormatPrepare( &p_owner
->fmt
.audio
);
390 vlc_mutex_unlock( &p_owner
->lock
);
394 msg_Err( p_dec
, "failed to create audio output" );
398 p_dec
->fmt_out
.audio
.i_bytes_per_frame
=
399 p_owner
->fmt
.audio
.i_bytes_per_frame
;
400 p_dec
->fmt_out
.audio
.i_frame_length
=
401 p_owner
->fmt
.audio
.i_frame_length
;
403 vlc_fifo_Lock( p_owner
->p_fifo
);
404 p_owner
->reset_out_state
= true;
405 vlc_fifo_Unlock( p_owner
->p_fifo
);
410 static int vout_update_format( decoder_t
*p_dec
)
412 struct decoder_owner
*p_owner
= dec_get_owner( p_dec
);
413 bool need_vout
= false;
414 bool need_format_update
= false;
416 if( p_owner
->p_vout
== NULL
)
418 msg_Dbg(p_dec
, "vout: none found");
421 if( p_dec
->fmt_out
.video
.i_width
!= p_owner
->fmt
.video
.i_width
422 || p_dec
->fmt_out
.video
.i_height
!= p_owner
->fmt
.video
.i_height
)
424 msg_Dbg(p_dec
, "vout change: decoder size");
427 if( p_dec
->fmt_out
.video
.i_visible_width
!= p_owner
->fmt
.video
.i_visible_width
428 || p_dec
->fmt_out
.video
.i_visible_height
!= p_owner
->fmt
.video
.i_visible_height
429 || p_dec
->fmt_out
.video
.i_x_offset
!= p_owner
->fmt
.video
.i_x_offset
430 || p_dec
->fmt_out
.video
.i_y_offset
!= p_owner
->fmt
.video
.i_y_offset
)
432 msg_Dbg(p_dec
, "vout change: visible size");
435 if( p_dec
->fmt_out
.i_codec
!= p_owner
->fmt
.video
.i_chroma
)
437 msg_Dbg(p_dec
, "vout change: chroma");
440 if( (int64_t)p_dec
->fmt_out
.video
.i_sar_num
* p_owner
->fmt
.video
.i_sar_den
!=
441 (int64_t)p_dec
->fmt_out
.video
.i_sar_den
* p_owner
->fmt
.video
.i_sar_num
)
443 msg_Dbg(p_dec
, "vout change: SAR");
446 if( p_dec
->fmt_out
.video
.orientation
!= p_owner
->fmt
.video
.orientation
)
448 msg_Dbg(p_dec
, "vout change: orientation");
451 if( p_dec
->fmt_out
.video
.multiview_mode
!= p_owner
->fmt
.video
.multiview_mode
)
453 msg_Dbg(p_dec
, "vout change: multiview");
457 if ( memcmp( &p_dec
->fmt_out
.video
.mastering
,
458 &p_owner
->fmt
.video
.mastering
,
459 sizeof(p_owner
->fmt
.video
.mastering
)) )
461 msg_Dbg(p_dec
, "vout update: mastering data");
462 need_format_update
= true;
464 if ( p_dec
->fmt_out
.video
.lighting
.MaxCLL
!=
465 p_owner
->fmt
.video
.lighting
.MaxCLL
||
466 p_dec
->fmt_out
.video
.lighting
.MaxFALL
!=
467 p_owner
->fmt
.video
.lighting
.MaxFALL
)
469 msg_Dbg(p_dec
, "vout update: lighting data");
470 need_format_update
= true;
475 vout_thread_t
*p_vout
;
477 if( !p_dec
->fmt_out
.video
.i_width
||
478 !p_dec
->fmt_out
.video
.i_height
||
479 p_dec
->fmt_out
.video
.i_width
< p_dec
->fmt_out
.video
.i_visible_width
||
480 p_dec
->fmt_out
.video
.i_height
< p_dec
->fmt_out
.video
.i_visible_height
)
482 /* Can't create a new vout without display size */
486 video_format_t fmt
= p_dec
->fmt_out
.video
;
487 fmt
.i_chroma
= p_dec
->fmt_out
.i_codec
;
489 if( vlc_fourcc_IsYUV( fmt
.i_chroma
) )
491 const vlc_chroma_description_t
*dsc
= vlc_fourcc_GetChromaDescription( fmt
.i_chroma
);
492 for( unsigned int i
= 0; dsc
&& i
< dsc
->plane_count
; i
++ )
494 while( fmt
.i_width
% dsc
->p
[i
].w
.den
)
496 while( fmt
.i_height
% dsc
->p
[i
].h
.den
)
501 if( !fmt
.i_visible_width
|| !fmt
.i_visible_height
)
503 if( p_dec
->fmt_in
.video
.i_visible_width
&&
504 p_dec
->fmt_in
.video
.i_visible_height
)
506 fmt
.i_visible_width
= p_dec
->fmt_in
.video
.i_visible_width
;
507 fmt
.i_visible_height
= p_dec
->fmt_in
.video
.i_visible_height
;
508 fmt
.i_x_offset
= p_dec
->fmt_in
.video
.i_x_offset
;
509 fmt
.i_y_offset
= p_dec
->fmt_in
.video
.i_y_offset
;
513 fmt
.i_visible_width
= fmt
.i_width
;
514 fmt
.i_visible_height
= fmt
.i_height
;
520 if( fmt
.i_visible_height
== 1088 &&
521 var_CreateGetBool( p_dec
, "hdtv-fix" ) )
523 fmt
.i_visible_height
= 1080;
524 if( !(fmt
.i_sar_num
% 136))
526 fmt
.i_sar_num
*= 135;
527 fmt
.i_sar_den
*= 136;
529 msg_Warn( p_dec
, "Fixing broken HDTV stream (display_height=1088)");
532 if( !fmt
.i_sar_num
|| !fmt
.i_sar_den
)
538 vlc_ureduce( &fmt
.i_sar_num
, &fmt
.i_sar_den
,
539 fmt
.i_sar_num
, fmt
.i_sar_den
, 50000 );
541 video_format_AdjustColorSpace( &fmt
);
543 vlc_mutex_lock( &p_owner
->lock
);
545 p_vout
= p_owner
->p_vout
;
546 p_owner
->p_vout
= NULL
;
547 vlc_mutex_unlock( &p_owner
->lock
);
550 switch( p_dec
->fmt_in
.i_codec
)
554 case VLC_CODEC_DIRAC
: /* FIXME valid ? */
570 p_vout
= input_resource_GetVout( p_owner
->p_resource
,
571 &(vout_configuration_t
) {
572 .vout
= p_vout
, .fmt
= &fmt
,
573 .dpb_size
= dpb_size
+ p_dec
->i_extra_picture_buffers
+ 1,
574 .mouse_event
= MouseEvent
, .mouse_opaque
= p_dec
577 vlc_mutex_lock( &p_owner
->lock
);
578 p_owner
->p_vout
= p_vout
;
580 DecoderUpdateFormatLocked( p_dec
);
581 p_owner
->fmt
.video
.i_chroma
= p_dec
->fmt_out
.i_codec
;
582 vlc_mutex_unlock( &p_owner
->lock
);
586 msg_Err( p_dec
, "failed to create video output" );
590 vlc_fifo_Lock( p_owner
->p_fifo
);
591 p_owner
->reset_out_state
= true;
592 vlc_fifo_Unlock( p_owner
->p_fifo
);
595 if ( need_format_update
)
597 /* the format has changed but we don't need a new vout */
598 vlc_mutex_lock( &p_owner
->lock
);
599 DecoderUpdateFormatLocked( p_dec
);
600 vlc_mutex_unlock( &p_owner
->lock
);
605 static picture_t
*vout_new_buffer( decoder_t
*p_dec
)
607 struct decoder_owner
*p_owner
= dec_get_owner( p_dec
);
608 assert( p_owner
->p_vout
);
610 return vout_GetPicture( p_owner
->p_vout
);
613 static subpicture_t
*spu_new_buffer( decoder_t
*p_dec
,
614 const subpicture_updater_t
*p_updater
)
616 struct decoder_owner
*p_owner
= dec_get_owner( p_dec
);
617 vout_thread_t
*p_vout
= NULL
;
618 subpicture_t
*p_subpic
;
621 while( i_attempts
-- )
626 p_vout
= input_resource_HoldVout( p_owner
->p_resource
);
630 vlc_tick_sleep( DECODER_SPU_VOUT_WAIT_DURATION
);
635 msg_Warn( p_dec
, "no vout found, dropping subpicture" );
636 if( p_owner
->p_vout
)
638 vlc_mutex_lock( &p_owner
->lock
);
639 vlc_object_release( p_owner
->p_vout
);
640 p_owner
->p_vout
= NULL
;
641 vlc_mutex_unlock( &p_owner
->lock
);
646 if( p_owner
->p_vout
!= p_vout
)
648 p_owner
->i_spu_channel
= vout_RegisterSubpictureChannel( p_vout
);
649 p_owner
->i_spu_order
= 0;
651 vlc_mutex_lock( &p_owner
->lock
);
652 if( p_owner
->p_vout
)
653 vlc_object_release( p_owner
->p_vout
);
654 p_owner
->p_vout
= p_vout
;
655 vlc_mutex_unlock( &p_owner
->lock
);
658 vlc_object_release( p_vout
);
660 p_subpic
= subpicture_New( p_updater
);
663 p_subpic
->i_channel
= p_owner
->i_spu_channel
;
664 p_subpic
->i_order
= p_owner
->i_spu_order
++;
665 p_subpic
->b_subtitle
= true;
671 static int DecoderGetInputAttachments( decoder_t
*p_dec
,
672 input_attachment_t
***ppp_attachment
,
675 struct decoder_owner
*p_owner
= dec_get_owner( p_dec
);
676 input_thread_t
*p_input
= p_owner
->p_input
;
678 if( unlikely(p_input
== NULL
) )
681 int ret
= input_GetAttachments( p_input
, ppp_attachment
);
684 *pi_attachment
= ret
;
688 static vlc_tick_t
DecoderGetDisplayDate( decoder_t
*p_dec
, vlc_tick_t i_ts
)
690 struct decoder_owner
*p_owner
= dec_get_owner( p_dec
);
692 vlc_mutex_lock( &p_owner
->lock
);
693 if( p_owner
->b_waiting
|| p_owner
->paused
)
694 i_ts
= VLC_TICK_INVALID
;
695 vlc_mutex_unlock( &p_owner
->lock
);
697 if( !p_owner
->p_clock
|| i_ts
== VLC_TICK_INVALID
)
700 if( input_clock_ConvertTS( VLC_OBJECT(p_dec
), p_owner
->p_clock
, NULL
, &i_ts
, NULL
, INT64_MAX
) ) {
701 msg_Err(p_dec
, "Could not get display date for timestamp %"PRId64
"", i_ts
);
702 return VLC_TICK_INVALID
;
708 static float DecoderGetDisplayRate( decoder_t
*p_dec
)
710 struct decoder_owner
*p_owner
= dec_get_owner( p_dec
);
712 if( !p_owner
->p_clock
)
714 return input_clock_GetRate( p_owner
->p_clock
);
717 /*****************************************************************************
719 *****************************************************************************/
720 block_t
*decoder_NewAudioBuffer( decoder_t
*dec
, int samples
)
722 assert( dec
->fmt_out
.audio
.i_frame_length
> 0
723 && dec
->fmt_out
.audio
.i_bytes_per_frame
> 0 );
725 size_t length
= samples
* dec
->fmt_out
.audio
.i_bytes_per_frame
726 / dec
->fmt_out
.audio
.i_frame_length
;
727 block_t
*block
= block_Alloc( length
);
728 if( likely(block
!= NULL
) )
730 block
->i_nb_samples
= samples
;
731 block
->i_pts
= block
->i_length
= 0;
736 static void RequestReload( decoder_t
* p_dec
)
738 struct decoder_owner
*p_owner
= dec_get_owner( p_dec
);
739 /* Don't override reload if it's RELOAD_DECODER_AOUT */
740 int expected
= RELOAD_NO_REQUEST
;
741 atomic_compare_exchange_strong( &p_owner
->reload
, &expected
, RELOAD_DECODER
);
744 void decoder_AbortPictures( decoder_t
*p_dec
, bool b_abort
)
746 struct decoder_owner
*p_owner
= dec_get_owner( p_dec
);
748 vlc_mutex_lock( &p_owner
->lock
);
749 if( p_owner
->p_vout
!= NULL
)
750 vout_Cancel( p_owner
->p_vout
, b_abort
);
751 vlc_mutex_unlock( &p_owner
->lock
);
754 static void DecoderWaitUnblock( decoder_t
*p_dec
)
756 struct decoder_owner
*p_owner
= dec_get_owner( p_dec
);
758 vlc_mutex_assert( &p_owner
->lock
);
762 if( !p_owner
->b_waiting
|| !p_owner
->b_has_data
)
764 vlc_cond_wait( &p_owner
->wait_request
, &p_owner
->lock
);
768 /* DecoderTimedWait: Interruptible wait
769 * Returns VLC_SUCCESS if wait was not interrupted, and VLC_EGENERIC otherwise */
770 static int DecoderTimedWait( decoder_t
*p_dec
, vlc_tick_t deadline
)
772 struct decoder_owner
*p_owner
= dec_get_owner( p_dec
);
774 if (deadline
<= vlc_tick_now())
777 vlc_fifo_Lock( p_owner
->p_fifo
);
778 while( !p_owner
->flushing
779 && vlc_fifo_TimedWaitCond( p_owner
->p_fifo
, &p_owner
->wait_timed
,
781 int ret
= p_owner
->flushing
? VLC_EGENERIC
: VLC_SUCCESS
;
782 vlc_fifo_Unlock( p_owner
->p_fifo
);
786 static inline void DecoderUpdatePreroll( vlc_tick_t
*pi_preroll
, const block_t
*p
)
788 if( p
->i_flags
& BLOCK_FLAG_PREROLL
)
789 *pi_preroll
= (vlc_tick_t
)INT64_MAX
;
790 /* Check if we can use the packet for end of preroll */
791 else if( (p
->i_flags
& BLOCK_FLAG_DISCONTINUITY
) &&
792 (p
->i_buffer
== 0 || (p
->i_flags
& BLOCK_FLAG_CORRUPTED
)) )
793 *pi_preroll
= (vlc_tick_t
)INT64_MAX
;
794 else if( p
->i_dts
!= VLC_TICK_INVALID
)
795 *pi_preroll
= __MIN( *pi_preroll
, p
->i_dts
);
796 else if( p
->i_pts
!= VLC_TICK_INVALID
)
797 *pi_preroll
= __MIN( *pi_preroll
, p
->i_pts
);
800 static void DecoderFixTs( decoder_t
*p_dec
, vlc_tick_t
*pi_ts0
, vlc_tick_t
*pi_ts1
,
801 vlc_tick_t
*pi_duration
, float *p_rate
, vlc_tick_t i_ts_bound
)
803 struct decoder_owner
*p_owner
= dec_get_owner( p_dec
);
804 input_clock_t
*p_clock
= p_owner
->p_clock
;
806 vlc_mutex_assert( &p_owner
->lock
);
808 const vlc_tick_t i_es_delay
= p_owner
->i_ts_delay
;
813 const bool b_ephemere
= pi_ts1
&& *pi_ts0
== *pi_ts1
;
816 if( *pi_ts0
!= VLC_TICK_INVALID
)
818 *pi_ts0
+= i_es_delay
;
819 if( pi_ts1
&& *pi_ts1
!= VLC_TICK_INVALID
)
820 *pi_ts1
+= i_es_delay
;
821 if( i_ts_bound
!= INT64_MAX
)
822 i_ts_bound
+= i_es_delay
;
823 if( input_clock_ConvertTS( VLC_OBJECT(p_dec
), p_clock
, &rate
, pi_ts0
, pi_ts1
, i_ts_bound
) ) {
824 const char *psz_name
= module_get_name( p_dec
->p_module
, false );
826 msg_Err(p_dec
, "Could not convert timestamps %"PRId64
827 ", %"PRId64
" for %s", *pi_ts0
, *pi_ts1
, psz_name
);
829 msg_Err(p_dec
, "Could not convert timestamp %"PRId64
" for %s", *pi_ts0
, psz_name
);
830 *pi_ts0
= VLC_TICK_INVALID
;
835 rate
= input_clock_GetRate( p_clock
);
838 /* Do not create ephemere data because of rounding errors */
839 if( !b_ephemere
&& pi_ts1
&& *pi_ts1
!= VLC_TICK_INVALID
&& *pi_ts0
== *pi_ts1
)
843 *pi_duration
= ( *pi_duration
/ rate
) + 0.999f
;
850 static int DecoderPlaySout( decoder_t
*p_dec
, block_t
*p_sout_block
)
852 struct decoder_owner
*p_owner
= dec_get_owner( p_dec
);
854 assert( p_owner
->p_clock
);
855 assert( !p_sout_block
->p_next
);
857 vlc_mutex_lock( &p_owner
->lock
);
859 if( p_owner
->b_waiting
)
861 p_owner
->b_has_data
= true;
862 vlc_cond_signal( &p_owner
->wait_acknowledge
);
865 DecoderWaitUnblock( p_dec
);
866 DecoderFixTs( p_dec
, &p_sout_block
->i_dts
, &p_sout_block
->i_pts
,
867 &p_sout_block
->i_length
, NULL
, INT64_MAX
);
869 vlc_mutex_unlock( &p_owner
->lock
);
871 /* FIXME --VLC_TICK_INVALID inspect stream_output*/
872 return sout_InputSendBuffer( p_owner
->p_sout_input
, p_sout_block
);
875 /* This function process a block for sout
877 static void DecoderProcessSout( decoder_t
*p_dec
, block_t
*p_block
)
879 struct decoder_owner
*p_owner
= dec_get_owner( p_dec
);
880 block_t
*p_sout_block
;
881 block_t
**pp_block
= p_block
? &p_block
: NULL
;
883 while( ( p_sout_block
=
884 p_dec
->pf_packetize( p_dec
, pp_block
) ) )
886 if( p_owner
->p_sout_input
== NULL
)
888 vlc_mutex_lock( &p_owner
->lock
);
889 DecoderUpdateFormatLocked( p_dec
);
891 p_owner
->fmt
.i_group
= p_dec
->fmt_in
.i_group
;
892 p_owner
->fmt
.i_id
= p_dec
->fmt_in
.i_id
;
893 if( p_dec
->fmt_in
.psz_language
)
895 free( p_owner
->fmt
.psz_language
);
896 p_owner
->fmt
.psz_language
=
897 strdup( p_dec
->fmt_in
.psz_language
);
899 vlc_mutex_unlock( &p_owner
->lock
);
901 p_owner
->p_sout_input
=
902 sout_InputNew( p_owner
->p_sout
, &p_owner
->fmt
);
904 if( p_owner
->p_sout_input
== NULL
)
906 msg_Err( p_dec
, "cannot create packetized sout output (%4.4s)",
907 (char *)&p_owner
->fmt
.i_codec
);
908 p_owner
->error
= true;
911 block_Release(p_block
);
913 block_ChainRelease(p_sout_block
);
918 while( p_sout_block
)
920 block_t
*p_next
= p_sout_block
->p_next
;
922 p_sout_block
->p_next
= NULL
;
924 if( p_owner
->p_sout
->b_wants_substreams
&& p_dec
->pf_get_cc
)
926 if( p_owner
->cc
.p_sout_input
||
927 !p_owner
->cc
.b_sout_created
)
929 decoder_cc_desc_t desc
;
930 block_t
*p_cc
= p_dec
->pf_get_cc( p_dec
, &desc
);
933 if(!p_owner
->cc
.b_sout_created
)
936 es_format_Init(&ccfmt
, SPU_ES
, VLC_CODEC_CEA608
);
937 ccfmt
.i_group
= p_owner
->fmt
.i_group
;
938 ccfmt
.subs
.cc
.i_reorder_depth
= desc
.i_reorder_depth
;
939 p_owner
->cc
.p_sout_input
= sout_InputNew( p_owner
->p_sout
, &ccfmt
);
940 es_format_Clean(&ccfmt
);
941 p_owner
->cc
.b_sout_created
= true;
944 if( !p_owner
->cc
.p_sout_input
||
945 sout_InputSendBuffer( p_owner
->cc
.p_sout_input
, p_cc
) )
947 block_Release( p_cc
);
953 if( DecoderPlaySout( p_dec
, p_sout_block
) == VLC_EGENERIC
)
955 msg_Err( p_dec
, "cannot continue streaming due to errors with codec %4.4s",
956 (char *)&p_owner
->fmt
.i_codec
);
958 p_owner
->error
= true;
963 block_Release( p_block
);
965 block_ChainRelease( p_next
);
969 p_sout_block
= p_next
;
975 static void DecoderPlayCc( decoder_t
*p_dec
, block_t
*p_cc
,
976 const decoder_cc_desc_t
*p_desc
)
978 struct decoder_owner
*p_owner
= dec_get_owner( p_dec
);
980 vlc_mutex_lock( &p_owner
->lock
);
982 p_owner
->cc
.desc
= *p_desc
;
984 /* Fanout data to all decoders. We do not know if es_out
985 selected 608 or 708. */
986 uint64_t i_bitmap
= p_owner
->cc
.desc
.i_608_channels
|
987 p_owner
->cc
.desc
.i_708_channels
;
989 for( int i
=0; i_bitmap
> 0; i_bitmap
>>= 1, i
++ )
991 decoder_t
*p_ccdec
= p_owner
->cc
.pp_decoder
[i
];
992 struct decoder_owner
*p_ccowner
= dec_get_owner( p_ccdec
);
998 block_FifoPut( p_ccowner
->p_fifo
, block_Duplicate(p_cc
) );
1002 block_FifoPut( p_ccowner
->p_fifo
, p_cc
);
1003 p_cc
= NULL
; /* was last dec */
1007 vlc_mutex_unlock( &p_owner
->lock
);
1009 if( p_cc
) /* can have bitmap set but no created decs */
1010 block_Release( p_cc
);
1013 static void PacketizerGetCc( decoder_t
*p_dec
, decoder_t
*p_dec_cc
)
1015 struct decoder_owner
*p_owner
= dec_get_owner( p_dec
);
1017 decoder_cc_desc_t desc
;
1019 /* Do not try retreiving CC if not wanted (sout) or cannot be retreived */
1020 if( !p_owner
->cc
.b_supported
)
1023 assert( p_dec_cc
->pf_get_cc
!= NULL
);
1025 p_cc
= p_dec_cc
->pf_get_cc( p_dec_cc
, &desc
);
1028 DecoderPlayCc( p_dec
, p_cc
, &desc
);
1031 static void DecoderQueueCc( decoder_t
*p_videodec
, block_t
*p_cc
,
1032 const decoder_cc_desc_t
*p_desc
)
1034 struct decoder_owner
*p_owner
= dec_get_owner( p_videodec
);
1036 if( unlikely( p_cc
!= NULL
) )
1038 if( p_owner
->cc
.b_supported
&&
1039 ( !p_owner
->p_packetizer
|| !p_owner
->p_packetizer
->pf_get_cc
) )
1040 DecoderPlayCc( p_videodec
, p_cc
, p_desc
);
1042 block_Release( p_cc
);
1046 static void DecoderPlayVideo( decoder_t
*p_dec
, picture_t
*p_picture
,
1047 unsigned *restrict pi_lost_sum
)
1049 struct decoder_owner
*p_owner
= dec_get_owner( p_dec
);
1050 vout_thread_t
*p_vout
= p_owner
->p_vout
;
1053 vlc_mutex_lock( &p_owner
->lock
);
1054 if( p_owner
->i_preroll_end
> p_picture
->date
)
1056 vlc_mutex_unlock( &p_owner
->lock
);
1057 picture_Release( p_picture
);
1061 prerolled
= p_owner
->i_preroll_end
> (vlc_tick_t
)INT64_MIN
;
1062 p_owner
->i_preroll_end
= (vlc_tick_t
)INT64_MIN
;
1063 vlc_mutex_unlock( &p_owner
->lock
);
1065 if( unlikely(prerolled
) )
1067 msg_Dbg( p_dec
, "end of video preroll" );
1070 vout_FlushAll( p_vout
);
1073 if( p_picture
->date
== VLC_TICK_INVALID
)
1075 msg_Warn( p_dec
, "non-dated video buffer received" );
1080 vlc_mutex_lock( &p_owner
->lock
);
1082 if( p_owner
->b_waiting
&& !p_owner
->b_first
)
1084 p_owner
->b_has_data
= true;
1085 vlc_cond_signal( &p_owner
->wait_acknowledge
);
1087 bool b_first_after_wait
= p_owner
->b_waiting
&& p_owner
->b_has_data
;
1089 DecoderWaitUnblock( p_dec
);
1091 if( p_owner
->b_waiting
)
1093 assert( p_owner
->b_first
);
1094 msg_Dbg( p_dec
, "Received first picture" );
1095 p_owner
->b_first
= false;
1096 p_picture
->b_force
= true;
1099 const bool b_dated
= p_picture
->date
!= VLC_TICK_INVALID
;
1101 DecoderFixTs( p_dec
, &p_picture
->date
, NULL
, NULL
,
1102 &rate
, DECODER_BOGUS_VIDEO_DELAY
);
1104 vlc_mutex_unlock( &p_owner
->lock
);
1106 /* FIXME: The *input* FIFO should not be locked here. This will not work
1107 * properly if/when pictures are queued asynchronously. */
1108 vlc_fifo_Lock( p_owner
->p_fifo
);
1109 if( unlikely(p_owner
->paused
) && likely(p_owner
->frames_countdown
> 0) )
1110 p_owner
->frames_countdown
--;
1111 vlc_fifo_Unlock( p_owner
->p_fifo
);
1114 if( p_vout
== NULL
)
1117 if( p_picture
->b_force
|| p_picture
->date
!= VLC_TICK_INVALID
)
1118 /* FIXME: VLC_TICK_INVALID -- verify video_output */
1120 if( rate
!= p_owner
->last_rate
|| b_first_after_wait
)
1122 /* Be sure to not display old picture after our own */
1123 vout_Flush( p_vout
, p_picture
->date
);
1124 p_owner
->last_rate
= rate
;
1126 else if( p_picture
->b_still
)
1128 /* Ensure no earlier higher pts breaks still state */
1129 vout_Flush( p_vout
, p_picture
->date
);
1131 vout_PutPicture( p_vout
, p_picture
);
1136 msg_Warn( p_dec
, "early picture skipped" );
1138 msg_Warn( p_dec
, "non-dated video buffer received" );
1145 picture_Release( p_picture
);
1148 static void DecoderUpdateStatVideo( struct decoder_owner
*p_owner
,
1149 unsigned decoded
, unsigned lost
)
1151 input_thread_t
*p_input
= p_owner
->p_input
;
1152 unsigned displayed
= 0;
1154 /* Update ugly stat */
1155 if( p_input
== NULL
)
1158 if( p_owner
->p_vout
!= NULL
)
1160 unsigned vout_lost
= 0;
1162 vout_GetResetStatistic( p_owner
->p_vout
, &displayed
, &vout_lost
);
1166 struct input_stats
*stats
= input_priv(p_input
)->stats
;
1170 atomic_fetch_add_explicit(&stats
->decoded_video
, decoded
,
1171 memory_order_relaxed
);
1172 atomic_fetch_add_explicit(&stats
->lost_pictures
, lost
,
1173 memory_order_relaxed
);
1174 atomic_fetch_add_explicit(&stats
->displayed_pictures
, displayed
,
1175 memory_order_relaxed
);
1179 static void DecoderQueueVideo( decoder_t
*p_dec
, picture_t
*p_pic
)
1182 unsigned i_lost
= 0;
1183 struct decoder_owner
*p_owner
= dec_get_owner( p_dec
);
1185 DecoderPlayVideo( p_dec
, p_pic
, &i_lost
);
1187 p_owner
->pf_update_stat( p_owner
, 1, i_lost
);
1190 static int thumbnailer_update_format( decoder_t
*p_dec
)
1196 static picture_t
*thumbnailer_buffer_new( decoder_t
*p_dec
)
1198 struct decoder_owner
*p_owner
= dec_get_owner( p_dec
);
1199 /* Avoid decoding more than one frame when a thumbnail was
1200 * already generated */
1201 if( !p_owner
->b_first
)
1203 return picture_NewFromFormat( &p_dec
->fmt_out
.video
);
1206 static void DecoderQueueThumbnail( decoder_t
*p_dec
, picture_t
*p_pic
)
1208 struct decoder_owner
*p_owner
= dec_get_owner( p_dec
);
1209 if( p_owner
->b_first
)
1211 input_SendEvent(p_owner
->p_input
, &(struct vlc_input_event
) {
1212 .type
= INPUT_EVENT_THUMBNAIL_READY
,
1215 p_owner
->b_first
= false;
1217 picture_Release( p_pic
);
1221 static void DecoderPlayAudio( decoder_t
*p_dec
, block_t
*p_audio
,
1222 unsigned *restrict pi_lost_sum
)
1224 struct decoder_owner
*p_owner
= dec_get_owner( p_dec
);
1227 assert( p_audio
!= NULL
);
1229 vlc_mutex_lock( &p_owner
->lock
);
1230 if( p_owner
->i_preroll_end
> p_audio
->i_pts
)
1232 vlc_mutex_unlock( &p_owner
->lock
);
1233 block_Release( p_audio
);
1237 prerolled
= p_owner
->i_preroll_end
> (vlc_tick_t
)INT64_MIN
;
1238 p_owner
->i_preroll_end
= (vlc_tick_t
)INT64_MIN
;
1239 vlc_mutex_unlock( &p_owner
->lock
);
1241 if( unlikely(prerolled
) )
1243 msg_Dbg( p_dec
, "end of audio preroll" );
1245 if( p_owner
->p_aout
)
1246 aout_DecFlush( p_owner
->p_aout
, false );
1250 if( p_audio
->i_pts
== VLC_TICK_INVALID
) // FIXME --VLC_TICK_INVALID verify audio_output/*
1252 msg_Warn( p_dec
, "non-dated audio buffer received" );
1254 block_Release( p_audio
);
1259 vlc_mutex_lock( &p_owner
->lock
);
1260 if( p_owner
->b_waiting
)
1262 p_owner
->b_has_data
= true;
1263 vlc_cond_signal( &p_owner
->wait_acknowledge
);
1269 DecoderWaitUnblock( p_dec
);
1270 DecoderFixTs( p_dec
, &p_audio
->i_pts
, NULL
, &p_audio
->i_length
,
1271 &rate
, AOUT_MAX_ADVANCE_TIME
);
1272 vlc_mutex_unlock( &p_owner
->lock
);
1274 audio_output_t
*p_aout
= p_owner
->p_aout
;
1276 if( p_aout
!= NULL
&& p_audio
->i_pts
!= VLC_TICK_INVALID
1277 && rate
>= 1 / (float) AOUT_MAX_INPUT_RATE
1278 && rate
<= AOUT_MAX_INPUT_RATE
1279 && !DecoderTimedWait( p_dec
, p_audio
->i_pts
- AOUT_MAX_PREPARE_TIME
) )
1281 int status
= aout_DecPlay( p_aout
, p_audio
);
1282 if( status
== AOUT_DEC_CHANGED
)
1284 /* Only reload the decoder */
1285 RequestReload( p_dec
);
1287 else if( status
== AOUT_DEC_FAILED
)
1289 /* If we reload because the aout failed, we should release it. That
1290 * way, a next call to aout_update_format() won't re-use the
1291 * previous (failing) aout but will try to create a new one. */
1292 atomic_store( &p_owner
->reload
, RELOAD_DECODER_AOUT
);
1297 msg_Dbg( p_dec
, "discarded audio buffer" );
1299 block_Release( p_audio
);
1304 static void DecoderUpdateStatAudio( struct decoder_owner
*p_owner
,
1305 unsigned decoded
, unsigned lost
)
1307 input_thread_t
*p_input
= p_owner
->p_input
;
1308 unsigned played
= 0;
1310 /* Update ugly stat */
1311 if( p_input
== NULL
)
1314 if( p_owner
->p_aout
!= NULL
)
1318 aout_DecGetResetStats( p_owner
->p_aout
, &aout_lost
, &played
);
1322 struct input_stats
*stats
= input_priv(p_input
)->stats
;
1326 atomic_fetch_add_explicit(&stats
->lost_abuffers
, lost
,
1327 memory_order_relaxed
);
1328 atomic_fetch_add_explicit(&stats
->played_abuffers
, played
,
1329 memory_order_relaxed
);
1330 atomic_fetch_add_explicit(&stats
->decoded_audio
, decoded
,
1331 memory_order_relaxed
);
1335 static void DecoderQueueAudio( decoder_t
*p_dec
, block_t
*p_aout_buf
)
1338 struct decoder_owner
*p_owner
= dec_get_owner( p_dec
);
1340 DecoderPlayAudio( p_dec
, p_aout_buf
, &lost
);
1342 p_owner
->pf_update_stat( p_owner
, 1, lost
);
1345 static void DecoderPlaySpu( decoder_t
*p_dec
, subpicture_t
*p_subpic
)
1347 struct decoder_owner
*p_owner
= dec_get_owner( p_dec
);
1348 vout_thread_t
*p_vout
= p_owner
->p_vout
;
1351 if( p_subpic
->i_start
== VLC_TICK_INVALID
)
1353 msg_Warn( p_dec
, "non-dated spu buffer received" );
1354 subpicture_Delete( p_subpic
);
1359 vlc_mutex_lock( &p_owner
->lock
);
1361 if( p_owner
->b_waiting
)
1363 p_owner
->b_has_data
= true;
1364 vlc_cond_signal( &p_owner
->wait_acknowledge
);
1367 DecoderWaitUnblock( p_dec
);
1368 DecoderFixTs( p_dec
, &p_subpic
->i_start
, &p_subpic
->i_stop
, NULL
,
1370 vlc_mutex_unlock( &p_owner
->lock
);
1372 if( p_subpic
->i_start
== VLC_TICK_INVALID
1373 || DecoderTimedWait( p_dec
, p_subpic
->i_start
- SPU_MAX_PREPARE_TIME
) )
1375 subpicture_Delete( p_subpic
);
1379 vout_PutSubpicture( p_vout
, p_subpic
);
1382 static void DecoderUpdateStatSpu( struct decoder_owner
*p_owner
,
1383 unsigned decoded
, unsigned lost
)
1385 (void) p_owner
; (void) decoded
; (void) lost
;
1388 static void DecoderQueueSpu( decoder_t
*p_dec
, subpicture_t
*p_spu
)
1391 struct decoder_owner
*p_owner
= dec_get_owner( p_dec
);
1393 /* The vout must be created from a previous decoder_NewSubpicture call. */
1394 assert( p_owner
->p_vout
);
1396 /* Preroll does not work very well with subtitle */
1397 vlc_mutex_lock( &p_owner
->lock
);
1398 if( p_spu
->i_start
!= VLC_TICK_INVALID
&&
1399 p_spu
->i_start
< p_owner
->i_preroll_end
&&
1400 ( p_spu
->i_stop
== VLC_TICK_INVALID
|| p_spu
->i_stop
< p_owner
->i_preroll_end
) )
1402 vlc_mutex_unlock( &p_owner
->lock
);
1403 subpicture_Delete( p_spu
);
1407 vlc_mutex_unlock( &p_owner
->lock
);
1408 DecoderPlaySpu( p_dec
, p_spu
);
1412 static void DecoderProcess( decoder_t
*p_dec
, block_t
*p_block
);
1413 static void DecoderDecode( decoder_t
*p_dec
, block_t
*p_block
)
1415 struct decoder_owner
*p_owner
= dec_get_owner( p_dec
);
1417 int ret
= p_dec
->pf_decode( p_dec
, p_block
);
1420 case VLCDEC_SUCCESS
:
1421 p_owner
->pf_update_stat( p_owner
, 1, 0 );
1423 case VLCDEC_ECRITICAL
:
1424 p_owner
->error
= true;
1427 RequestReload( p_dec
);
1428 if( unlikely( p_block
== NULL
) )
1430 if( !( p_block
->i_flags
& BLOCK_FLAG_CORE_PRIVATE_RELOADED
) )
1432 p_block
->i_flags
|= BLOCK_FLAG_CORE_PRIVATE_RELOADED
;
1433 DecoderProcess( p_dec
, p_block
);
1435 else /* We prefer loosing this block than an infinite recursion */
1436 block_Release( p_block
);
1439 vlc_assert_unreachable();
1446 * \param p_dec the decoder object
1447 * \param p_block the block to decode
1449 static void DecoderProcess( decoder_t
*p_dec
, block_t
*p_block
)
1451 struct decoder_owner
*p_owner
= dec_get_owner( p_dec
);
1453 if( p_owner
->error
)
1456 /* Here, the atomic doesn't prevent to miss a reload request.
1457 * DecoderProcess() can still be called after the decoder module or the
1458 * audio output requested a reload. This will only result in a drop of an
1459 * input block or an output buffer. */
1461 if( ( reload
= atomic_exchange( &p_owner
->reload
, RELOAD_NO_REQUEST
) ) )
1463 msg_Warn( p_dec
, "Reloading the decoder module%s",
1464 reload
== RELOAD_DECODER_AOUT
? " and the audio output" : "" );
1466 if( ReloadDecoder( p_dec
, false, &p_dec
->fmt_in
, reload
) != VLC_SUCCESS
)
1470 bool packetize
= p_owner
->p_packetizer
!= NULL
;
1473 if( p_block
->i_buffer
<= 0 )
1476 vlc_mutex_lock( &p_owner
->lock
);
1477 DecoderUpdatePreroll( &p_owner
->i_preroll_end
, p_block
);
1478 vlc_mutex_unlock( &p_owner
->lock
);
1479 if( unlikely( p_block
->i_flags
& BLOCK_FLAG_CORE_PRIVATE_RELOADED
) )
1481 /* This block has already been packetized */
1487 if( p_owner
->p_sout
!= NULL
)
1489 DecoderProcessSout( p_dec
, p_block
);
1495 block_t
*p_packetized_block
;
1496 block_t
**pp_block
= p_block
? &p_block
: NULL
;
1497 decoder_t
*p_packetizer
= p_owner
->p_packetizer
;
1499 while( (p_packetized_block
=
1500 p_packetizer
->pf_packetize( p_packetizer
, pp_block
) ) )
1502 if( !es_format_IsSimilar( &p_dec
->fmt_in
, &p_packetizer
->fmt_out
) )
1504 msg_Dbg( p_dec
, "restarting module due to input format change");
1506 /* Drain the decoder module */
1507 DecoderDecode( p_dec
, NULL
);
1509 if( ReloadDecoder( p_dec
, false, &p_packetizer
->fmt_out
,
1510 RELOAD_DECODER
) != VLC_SUCCESS
)
1512 block_ChainRelease( p_packetized_block
);
1517 if( p_packetizer
->pf_get_cc
)
1518 PacketizerGetCc( p_dec
, p_packetizer
);
1520 while( p_packetized_block
)
1522 block_t
*p_next
= p_packetized_block
->p_next
;
1523 p_packetized_block
->p_next
= NULL
;
1525 DecoderDecode( p_dec
, p_packetized_block
);
1526 if( p_owner
->error
)
1528 block_ChainRelease( p_next
);
1532 p_packetized_block
= p_next
;
1535 /* Drain the decoder after the packetizer is drained */
1537 DecoderDecode( p_dec
, NULL
);
1540 DecoderDecode( p_dec
, p_block
);
1545 block_Release( p_block
);
1548 static void DecoderProcessFlush( decoder_t
*p_dec
)
1550 struct decoder_owner
*p_owner
= dec_get_owner( p_dec
);
1551 decoder_t
*p_packetizer
= p_owner
->p_packetizer
;
1553 if( p_owner
->error
)
1556 if( p_packetizer
!= NULL
&& p_packetizer
->pf_flush
!= NULL
)
1557 p_packetizer
->pf_flush( p_packetizer
);
1559 if ( p_dec
->pf_flush
!= NULL
)
1560 p_dec
->pf_flush( p_dec
);
1562 /* flush CC sub decoders */
1563 if( p_owner
->cc
.b_supported
)
1565 for( int i
=0; i
<MAX_CC_DECODERS
; i
++ )
1567 decoder_t
*p_subdec
= p_owner
->cc
.pp_decoder
[i
];
1568 if( p_subdec
&& p_subdec
->pf_flush
)
1569 p_subdec
->pf_flush( p_subdec
);
1573 vlc_mutex_lock( &p_owner
->lock
);
1575 if ( p_owner
->p_sout_input
!= NULL
)
1577 sout_InputFlush( p_owner
->p_sout_input
);
1580 if( p_dec
->fmt_out
.i_cat
== AUDIO_ES
)
1582 if( p_owner
->p_aout
)
1583 aout_DecFlush( p_owner
->p_aout
, false );
1585 else if( p_dec
->fmt_out
.i_cat
== VIDEO_ES
)
1587 if( p_owner
->p_vout
)
1588 vout_FlushAll( p_owner
->p_vout
);
1590 else if( p_dec
->fmt_out
.i_cat
== SPU_ES
)
1592 if( p_owner
->p_vout
)
1593 vout_FlushSubpictureChannel( p_owner
->p_vout
, p_owner
->i_spu_channel
);
1596 p_owner
->i_preroll_end
= (vlc_tick_t
)INT64_MIN
;
1597 vlc_mutex_unlock( &p_owner
->lock
);
1600 static void OutputChangePause( decoder_t
*p_dec
, bool paused
, vlc_tick_t date
)
1602 struct decoder_owner
*p_owner
= dec_get_owner( p_dec
);
1604 msg_Dbg( p_dec
, "toggling %s", paused
? "resume" : "pause" );
1605 switch( p_dec
->fmt_out
.i_cat
)
1608 if( p_owner
->p_vout
!= NULL
)
1609 vout_ChangePause( p_owner
->p_vout
, paused
, date
);
1612 if( p_owner
->p_aout
!= NULL
)
1613 aout_DecChangePause( p_owner
->p_aout
, paused
, date
);
1618 vlc_assert_unreachable();
1622 static void OutputChangeRate( decoder_t
*p_dec
, float rate
)
1624 struct decoder_owner
*p_owner
= dec_get_owner( p_dec
);
1626 msg_Dbg( p_dec
, "changing rate: %f", rate
);
1627 switch( p_dec
->fmt_out
.i_cat
)
1632 if( p_owner
->p_aout
!= NULL
)
1633 aout_DecChangeRate( p_owner
->p_aout
, rate
);
1638 vlc_assert_unreachable();
1643 * The decoding main loop
1645 * \param p_dec the decoder
1647 static void *DecoderThread( void *p_data
)
1649 decoder_t
*p_dec
= (decoder_t
*)p_data
;
1650 struct decoder_owner
*p_owner
= dec_get_owner( p_dec
);
1652 bool paused
= false;
1654 /* The decoder's main loop */
1655 vlc_fifo_Lock( p_owner
->p_fifo
);
1656 vlc_fifo_CleanupPush( p_owner
->p_fifo
);
1660 if( p_owner
->flushing
)
1661 { /* Flush before/regardless of pause. We do not want to resume just
1662 * for the sake of flushing (glitches could otherwise happen). */
1663 int canc
= vlc_savecancel();
1665 vlc_fifo_Unlock( p_owner
->p_fifo
);
1667 /* Flush the decoder (and the output) */
1668 DecoderProcessFlush( p_dec
);
1670 vlc_fifo_Lock( p_owner
->p_fifo
);
1671 vlc_restorecancel( canc
);
1673 /* Reset flushing after DecoderProcess in case input_DecoderFlush
1674 * is called again. This will avoid a second useless flush (but
1676 p_owner
->flushing
= false;
1681 /* Reset the original pause/rate state when a new aout/vout is created:
1682 * this will trigger the OutputChangePause/OutputChangeRate code path
1684 if( p_owner
->reset_out_state
)
1688 p_owner
->reset_out_state
= false;
1691 if( paused
!= p_owner
->paused
)
1692 { /* Update playing/paused status of the output */
1693 int canc
= vlc_savecancel();
1694 vlc_tick_t date
= p_owner
->pause_date
;
1696 paused
= p_owner
->paused
;
1697 vlc_fifo_Unlock( p_owner
->p_fifo
);
1699 vlc_mutex_lock( &p_owner
->lock
);
1700 OutputChangePause( p_dec
, paused
, date
);
1701 vlc_mutex_unlock( &p_owner
->lock
);
1703 vlc_restorecancel( canc
);
1704 vlc_fifo_Lock( p_owner
->p_fifo
);
1708 if( rate
!= p_owner
->rate
)
1710 int canc
= vlc_savecancel();
1712 rate
= p_owner
->rate
;
1713 vlc_fifo_Unlock( p_owner
->p_fifo
);
1715 vlc_mutex_lock( &p_owner
->lock
);
1716 OutputChangeRate( p_dec
, rate
);
1717 vlc_mutex_unlock( &p_owner
->lock
);
1719 vlc_restorecancel( canc
);
1720 vlc_fifo_Lock( p_owner
->p_fifo
);
1723 if( p_owner
->paused
&& p_owner
->frames_countdown
== 0 )
1724 { /* Wait for resumption from pause */
1725 p_owner
->b_idle
= true;
1726 vlc_cond_signal( &p_owner
->wait_acknowledge
);
1727 vlc_fifo_Wait( p_owner
->p_fifo
);
1728 p_owner
->b_idle
= false;
1732 vlc_cond_signal( &p_owner
->wait_fifo
);
1733 vlc_testcancel(); /* forced expedited cancellation in case of stop */
1735 block_t
*p_block
= vlc_fifo_DequeueUnlocked( p_owner
->p_fifo
);
1736 if( p_block
== NULL
)
1738 if( likely(!p_owner
->b_draining
) )
1739 { /* Wait for a block to decode (or a request to drain) */
1740 p_owner
->b_idle
= true;
1741 vlc_cond_signal( &p_owner
->wait_acknowledge
);
1742 vlc_fifo_Wait( p_owner
->p_fifo
);
1743 p_owner
->b_idle
= false;
1746 /* We have emptied the FIFO and there is a pending request to
1747 * drain. Pass p_block = NULL to decoder just once. */
1750 vlc_fifo_Unlock( p_owner
->p_fifo
);
1752 int canc
= vlc_savecancel();
1753 DecoderProcess( p_dec
, p_block
);
1755 if( p_block
== NULL
&& p_dec
->fmt_out
.i_cat
== AUDIO_ES
)
1756 { /* Draining: the decoder is drained and all decoded buffers are
1757 * queued to the output at this point. Now drain the output. */
1758 if( p_owner
->p_aout
!= NULL
)
1759 aout_DecFlush( p_owner
->p_aout
, true );
1761 vlc_restorecancel( canc
);
1763 /* TODO? Wait for draining instead of polling. */
1764 vlc_mutex_lock( &p_owner
->lock
);
1765 vlc_fifo_Lock( p_owner
->p_fifo
);
1766 if( p_owner
->b_draining
&& (p_block
== NULL
) )
1768 p_owner
->b_draining
= false;
1769 p_owner
->drained
= true;
1771 vlc_cond_signal( &p_owner
->wait_acknowledge
);
1772 vlc_mutex_unlock( &p_owner
->lock
);
1775 vlc_assert_unreachable();
1778 static const struct decoder_owner_callbacks dec_video_cbs
=
1781 .format_update
= vout_update_format
,
1782 .buffer_new
= vout_new_buffer
,
1783 .queue
= DecoderQueueVideo
,
1784 .queue_cc
= DecoderQueueCc
,
1785 .get_display_date
= DecoderGetDisplayDate
,
1786 .get_display_rate
= DecoderGetDisplayRate
,
1788 .get_attachments
= DecoderGetInputAttachments
,
1790 static const struct decoder_owner_callbacks dec_thumbnailer_cbs
=
1793 .format_update
= thumbnailer_update_format
,
1794 .buffer_new
= thumbnailer_buffer_new
,
1795 .queue
= DecoderQueueThumbnail
,
1797 .get_attachments
= DecoderGetInputAttachments
,
1799 static const struct decoder_owner_callbacks dec_audio_cbs
=
1802 .format_update
= aout_update_format
,
1803 .queue
= DecoderQueueAudio
,
1805 .get_attachments
= DecoderGetInputAttachments
,
1807 static const struct decoder_owner_callbacks dec_spu_cbs
=
1810 .buffer_new
= spu_new_buffer
,
1811 .queue
= DecoderQueueSpu
,
1813 .get_attachments
= DecoderGetInputAttachments
,
1817 * Create a decoder object
1819 * \param p_input the input thread
1820 * \param p_es the es descriptor
1821 * \param b_packetizer instead of a decoder
1822 * \return the decoder object
1824 static decoder_t
* CreateDecoder( vlc_object_t
*p_parent
,
1825 input_thread_t
*p_input
,
1826 const es_format_t
*fmt
,
1827 input_resource_t
*p_resource
,
1828 sout_instance_t
*p_sout
)
1831 struct decoder_owner
*p_owner
;
1833 p_owner
= vlc_custom_create( p_parent
, sizeof( *p_owner
), "decoder" );
1834 if( p_owner
== NULL
)
1836 p_dec
= &p_owner
->dec
;
1838 p_owner
->i_preroll_end
= (vlc_tick_t
)INT64_MIN
;
1839 p_owner
->last_rate
= 1.f
;
1840 p_owner
->p_input
= p_input
;
1841 p_owner
->p_resource
= p_resource
;
1842 p_owner
->p_aout
= NULL
;
1843 p_owner
->p_vout
= NULL
;
1844 p_owner
->i_spu_channel
= 0;
1845 p_owner
->i_spu_order
= 0;
1846 p_owner
->p_sout
= p_sout
;
1847 p_owner
->p_sout_input
= NULL
;
1848 p_owner
->p_packetizer
= NULL
;
1850 atomic_init( &p_owner
->b_fmt_description
, false );
1851 p_owner
->p_description
= NULL
;
1853 p_owner
->reset_out_state
= false;
1854 p_owner
->rate
= 1.f
;
1855 p_owner
->paused
= false;
1856 p_owner
->pause_date
= VLC_TICK_INVALID
;
1857 p_owner
->frames_countdown
= 0;
1859 p_owner
->b_waiting
= false;
1860 p_owner
->b_first
= true;
1861 p_owner
->b_has_data
= false;
1863 p_owner
->error
= false;
1865 p_owner
->flushing
= false;
1866 p_owner
->b_draining
= false;
1867 p_owner
->drained
= false;
1868 atomic_init( &p_owner
->reload
, RELOAD_NO_REQUEST
);
1869 p_owner
->b_idle
= false;
1871 p_owner
->mouse_event
= NULL
;
1872 p_owner
->mouse_opaque
= NULL
;
1874 es_format_Init( &p_owner
->fmt
, fmt
->i_cat
, 0 );
1877 p_owner
->p_fifo
= block_FifoNew();
1878 if( unlikely(p_owner
->p_fifo
== NULL
) )
1880 vlc_object_release( p_dec
);
1884 vlc_mutex_init( &p_owner
->lock
);
1885 vlc_mutex_init( &p_owner
->mouse_lock
);
1886 vlc_cond_init( &p_owner
->wait_request
);
1887 vlc_cond_init( &p_owner
->wait_acknowledge
);
1888 vlc_cond_init( &p_owner
->wait_fifo
);
1889 vlc_cond_init( &p_owner
->wait_timed
);
1891 /* Load a packetizer module if the input is not already packetized */
1892 if( p_sout
== NULL
&& !fmt
->b_packetized
)
1894 p_owner
->p_packetizer
=
1895 vlc_custom_create( p_parent
, sizeof( decoder_t
), "packetizer" );
1896 if( p_owner
->p_packetizer
)
1898 if( LoadDecoder( p_owner
->p_packetizer
, true, fmt
) )
1900 vlc_object_release( p_owner
->p_packetizer
);
1901 p_owner
->p_packetizer
= NULL
;
1905 p_owner
->p_packetizer
->fmt_out
.b_packetized
= true;
1906 fmt
= &p_owner
->p_packetizer
->fmt_out
;
1911 switch( fmt
->i_cat
)
1914 if( !p_input
|| !input_priv( p_input
)->b_thumbnailing
)
1915 p_dec
->cbs
= &dec_video_cbs
;
1917 p_dec
->cbs
= &dec_thumbnailer_cbs
;
1918 p_owner
->pf_update_stat
= DecoderUpdateStatVideo
;
1921 p_dec
->cbs
= &dec_audio_cbs
;
1922 p_owner
->pf_update_stat
= DecoderUpdateStatAudio
;
1925 p_dec
->cbs
= &dec_spu_cbs
;
1926 p_owner
->pf_update_stat
= DecoderUpdateStatSpu
;
1929 msg_Err( p_dec
, "unknown ES format" );
1933 /* Find a suitable decoder/packetizer module */
1934 if( LoadDecoder( p_dec
, p_sout
!= NULL
, fmt
) )
1937 assert( p_dec
->fmt_in
.i_cat
== p_dec
->fmt_out
.i_cat
&& fmt
->i_cat
== p_dec
->fmt_in
.i_cat
);
1939 /* Copy ourself the input replay gain */
1940 if( fmt
->i_cat
== AUDIO_ES
)
1942 for( unsigned i
= 0; i
< AUDIO_REPLAY_GAIN_MAX
; i
++ )
1944 if( !p_dec
->fmt_out
.audio_replay_gain
.pb_peak
[i
] )
1946 p_dec
->fmt_out
.audio_replay_gain
.pb_peak
[i
] = fmt
->audio_replay_gain
.pb_peak
[i
];
1947 p_dec
->fmt_out
.audio_replay_gain
.pf_peak
[i
] = fmt
->audio_replay_gain
.pf_peak
[i
];
1949 if( !p_dec
->fmt_out
.audio_replay_gain
.pb_gain
[i
] )
1951 p_dec
->fmt_out
.audio_replay_gain
.pb_gain
[i
] = fmt
->audio_replay_gain
.pb_gain
[i
];
1952 p_dec
->fmt_out
.audio_replay_gain
.pf_gain
[i
] = fmt
->audio_replay_gain
.pf_gain
[i
];
1958 p_owner
->cc
.b_supported
= ( p_sout
== NULL
);
1960 p_owner
->cc
.desc
.i_608_channels
= 0;
1961 p_owner
->cc
.desc
.i_708_channels
= 0;
1962 for( unsigned i
= 0; i
< MAX_CC_DECODERS
; i
++ )
1963 p_owner
->cc
.pp_decoder
[i
] = NULL
;
1964 p_owner
->cc
.p_sout_input
= NULL
;
1965 p_owner
->cc
.b_sout_created
= false;
1966 p_owner
->i_ts_delay
= 0;
1971 * Destroys a decoder object
1973 * \param p_dec the decoder object
1976 static void DeleteDecoder( decoder_t
* p_dec
)
1978 struct decoder_owner
*p_owner
= dec_get_owner( p_dec
);
1980 msg_Dbg( p_dec
, "killing decoder fourcc `%4.4s'",
1981 (char*)&p_dec
->fmt_in
.i_codec
);
1983 const enum es_format_category_e i_cat
=p_dec
->fmt_in
.i_cat
;
1984 UnloadDecoder( p_dec
);
1986 /* Free all packets still in the decoder fifo. */
1987 block_FifoRelease( p_owner
->p_fifo
);
1991 if( p_owner
->p_sout_input
)
1993 sout_InputDelete( p_owner
->p_sout_input
);
1994 if( p_owner
->cc
.p_sout_input
)
1995 sout_InputDelete( p_owner
->cc
.p_sout_input
);
2002 if( p_owner
->p_aout
)
2004 /* TODO: REVISIT gap-less audio */
2005 aout_DecFlush( p_owner
->p_aout
, false );
2006 aout_DecDelete( p_owner
->p_aout
);
2007 input_resource_PutAout( p_owner
->p_resource
, p_owner
->p_aout
);
2011 if( p_owner
->p_vout
)
2013 /* Reset the cancel state that was set before joining the decoder
2015 vout_Cancel( p_owner
->p_vout
, false );
2017 input_resource_PutVout( p_owner
->p_resource
, p_owner
->p_vout
);
2022 if( p_owner
->p_vout
)
2024 vout_FlushSubpictureChannel( p_owner
->p_vout
,
2025 p_owner
->i_spu_channel
);
2026 vlc_object_release( p_owner
->p_vout
);
2034 vlc_assert_unreachable();
2037 es_format_Clean( &p_owner
->fmt
);
2039 if( p_owner
->p_description
)
2040 vlc_meta_Delete( p_owner
->p_description
);
2042 if( p_owner
->p_packetizer
)
2044 UnloadDecoder( p_owner
->p_packetizer
);
2045 vlc_object_release( p_owner
->p_packetizer
);
2048 vlc_cond_destroy( &p_owner
->wait_timed
);
2049 vlc_cond_destroy( &p_owner
->wait_fifo
);
2050 vlc_cond_destroy( &p_owner
->wait_acknowledge
);
2051 vlc_cond_destroy( &p_owner
->wait_request
);
2052 vlc_mutex_destroy( &p_owner
->lock
);
2053 vlc_mutex_destroy( &p_owner
->mouse_lock
);
2055 vlc_object_release( p_dec
);
2059 static void DecoderUnsupportedCodec( decoder_t
*p_dec
, const es_format_t
*fmt
, bool b_decoding
)
2061 if (fmt
->i_codec
!= VLC_CODEC_UNKNOWN
&& fmt
->i_codec
) {
2062 const char *desc
= vlc_fourcc_GetDescription(fmt
->i_cat
, fmt
->i_codec
);
2063 if (!desc
|| !*desc
)
2064 desc
= N_("No description for this codec");
2065 msg_Err( p_dec
, "Codec `%4.4s' (%s) is not supported.", (char*)&fmt
->i_codec
, desc
);
2066 vlc_dialog_display_error( p_dec
, _("Codec not supported"),
2067 _("VLC could not decode the format \"%4.4s\" (%s)"),
2068 (char*)&fmt
->i_codec
, desc
);
2069 } else if( b_decoding
){
2070 msg_Err( p_dec
, "could not identify codec" );
2071 vlc_dialog_display_error( p_dec
, _("Unidentified codec"),
2072 _("VLC could not identify the audio or video codec" ) );
2076 /* TODO: pass p_sout through p_resource? -- Courmisch */
2077 static decoder_t
*decoder_New( vlc_object_t
*p_parent
, input_thread_t
*p_input
,
2078 const es_format_t
*fmt
, input_clock_t
*p_clock
,
2079 input_resource_t
*p_resource
,
2080 sout_instance_t
*p_sout
)
2082 decoder_t
*p_dec
= NULL
;
2083 const char *psz_type
= p_sout
? N_("packetizer") : N_("decoder");
2086 /* Create the decoder configuration structure */
2087 p_dec
= CreateDecoder( p_parent
, p_input
, fmt
, p_resource
, p_sout
);
2090 msg_Err( p_parent
, "could not create %s", psz_type
);
2091 vlc_dialog_display_error( p_parent
, _("Streaming / Transcoding failed"),
2092 _("VLC could not open the %s module."), vlc_gettext( psz_type
) );
2096 if( !p_dec
->p_module
)
2098 DecoderUnsupportedCodec( p_dec
, fmt
, !p_sout
);
2100 DeleteDecoder( p_dec
);
2104 struct decoder_owner
*p_owner
= dec_get_owner( p_dec
);
2105 p_owner
->p_clock
= p_clock
;
2106 assert( p_dec
->fmt_in
.i_cat
!= UNKNOWN_ES
);
2108 if( p_dec
->fmt_in
.i_cat
== AUDIO_ES
)
2109 i_priority
= VLC_THREAD_PRIORITY_AUDIO
;
2111 i_priority
= VLC_THREAD_PRIORITY_VIDEO
;
2114 /* Do not delay sout creation for SPU or DATA. */
2115 if( p_sout
&& fmt
->b_packetized
&&
2116 (fmt
->i_cat
!= VIDEO_ES
&& fmt
->i_cat
!= AUDIO_ES
) )
2118 p_owner
->p_sout_input
= sout_InputNew( p_owner
->p_sout
, fmt
);
2119 if( p_owner
->p_sout_input
== NULL
)
2121 msg_Err( p_dec
, "cannot create sout input (%4.4s)",
2122 (char *)&fmt
->i_codec
);
2123 p_owner
->error
= true;
2128 /* Spawn the decoder thread */
2129 if( vlc_clone( &p_owner
->thread
, DecoderThread
, p_dec
, i_priority
) )
2131 msg_Err( p_dec
, "cannot spawn decoder thread" );
2132 DeleteDecoder( p_dec
);
2141 * Spawns a new decoder thread from the input thread
2143 * \param p_input the input thread
2144 * \param p_es the es descriptor
2145 * \return the spawned decoder object
2147 decoder_t
*input_DecoderNew( input_thread_t
*p_input
,
2148 es_format_t
*fmt
, input_clock_t
*p_clock
,
2149 sout_instance_t
*p_sout
)
2151 return decoder_New( VLC_OBJECT(p_input
), p_input
, fmt
, p_clock
,
2152 input_priv(p_input
)->p_resource
, p_sout
);
2156 * Spawn a decoder thread outside of the input thread.
2158 decoder_t
*input_DecoderCreate( vlc_object_t
*p_parent
, const es_format_t
*fmt
,
2159 input_resource_t
*p_resource
)
2161 return decoder_New( p_parent
, NULL
, fmt
, NULL
, p_resource
, NULL
);
2166 * Kills a decoder thread and waits until it's finished
2168 * \param p_input the input thread
2169 * \param p_es the es descriptor
2172 void input_DecoderDelete( decoder_t
*p_dec
)
2174 struct decoder_owner
*p_owner
= dec_get_owner( p_dec
);
2176 vlc_cancel( p_owner
->thread
);
2178 vlc_fifo_Lock( p_owner
->p_fifo
);
2179 /* Signal DecoderTimedWait */
2180 p_owner
->flushing
= true;
2181 vlc_cond_signal( &p_owner
->wait_timed
);
2182 vlc_fifo_Unlock( p_owner
->p_fifo
);
2184 /* Make sure we aren't waiting/decoding anymore */
2185 vlc_mutex_lock( &p_owner
->lock
);
2186 p_owner
->b_waiting
= false;
2187 vlc_cond_signal( &p_owner
->wait_request
);
2189 /* If the video output is paused or slow, or if the picture pool size was
2190 * under-estimated (e.g. greedy video filter, buggy decoder...), the
2191 * the picture pool may be empty, and the decoder thread or any decoder
2192 * module worker threads may be stuck waiting for free picture buffers.
2194 * This unblocks the thread, allowing the decoder module to join all its
2195 * worker threads (if any) and the decoder thread to terminate. */
2196 if( p_dec
->fmt_in
.i_cat
== VIDEO_ES
&& p_owner
->p_vout
!= NULL
)
2197 vout_Cancel( p_owner
->p_vout
, true );
2198 vlc_mutex_unlock( &p_owner
->lock
);
2200 vlc_join( p_owner
->thread
, NULL
);
2203 if( p_owner
->cc
.b_supported
)
2205 for( int i
= 0; i
< MAX_CC_DECODERS
; i
++ )
2206 input_DecoderSetCcState( p_dec
, VLC_CODEC_CEA608
, i
, false );
2209 /* Delete decoder */
2210 DeleteDecoder( p_dec
);
2214 * Put a block_t in the decoder's fifo.
2215 * Thread-safe w.r.t. the decoder. May be a cancellation point.
2217 * \param p_dec the decoder object
2218 * \param p_block the data block
2220 void input_DecoderDecode( decoder_t
*p_dec
, block_t
*p_block
, bool b_do_pace
)
2222 struct decoder_owner
*p_owner
= dec_get_owner( p_dec
);
2224 vlc_fifo_Lock( p_owner
->p_fifo
);
2227 /* FIXME: ideally we would check the time amount of data
2228 * in the FIFO instead of its size. */
2229 /* 400 MiB, i.e. ~ 50mb/s for 60s */
2230 if( vlc_fifo_GetBytes( p_owner
->p_fifo
) > 400*1024*1024 )
2232 msg_Warn( p_dec
, "decoder/packetizer fifo full (data not "
2233 "consumed quickly enough), resetting fifo!" );
2234 block_ChainRelease( vlc_fifo_DequeueAllUnlocked( p_owner
->p_fifo
) );
2235 p_block
->i_flags
|= BLOCK_FLAG_DISCONTINUITY
;
2239 if( !p_owner
->b_waiting
)
2240 { /* The FIFO is not consumed when waiting, so pacing would deadlock VLC.
2241 * Locking is not necessary as b_waiting is only read, not written by
2242 * the decoder thread. */
2243 while( vlc_fifo_GetCount( p_owner
->p_fifo
) >= 10 )
2244 vlc_fifo_WaitCond( p_owner
->p_fifo
, &p_owner
->wait_fifo
);
2247 vlc_fifo_QueueUnlocked( p_owner
->p_fifo
, p_block
);
2248 vlc_fifo_Unlock( p_owner
->p_fifo
);
2251 bool input_DecoderIsEmpty( decoder_t
* p_dec
)
2253 struct decoder_owner
*p_owner
= dec_get_owner( p_dec
);
2255 assert( !p_owner
->b_waiting
);
2257 vlc_fifo_Lock( p_owner
->p_fifo
);
2258 if( !vlc_fifo_IsEmpty( p_owner
->p_fifo
) || p_owner
->b_draining
)
2260 vlc_fifo_Unlock( p_owner
->p_fifo
);
2263 vlc_fifo_Unlock( p_owner
->p_fifo
);
2267 vlc_mutex_lock( &p_owner
->lock
);
2269 if( p_owner
->p_sout_input
!= NULL
)
2270 b_empty
= sout_InputIsEmpty( p_owner
->p_sout_input
);
2273 if( p_owner
->fmt
.i_cat
== VIDEO_ES
&& p_owner
->p_vout
!= NULL
)
2274 b_empty
= vout_IsEmpty( p_owner
->p_vout
);
2275 else if( p_owner
->fmt
.i_cat
== AUDIO_ES
)
2276 b_empty
= !p_owner
->b_draining
|| p_owner
->drained
;
2278 b_empty
= true; /* TODO subtitles support */
2279 vlc_mutex_unlock( &p_owner
->lock
);
2285 * Signals that there are no further blocks to decode, and requests that the
2286 * decoder drain all pending buffers. This is used to ensure that all
2287 * intermediate buffers empty and no samples get lost at the end of the stream.
2289 * @note The function does not actually wait for draining. It just signals that
2290 * draining should be performed once the decoder has emptied FIFO.
2292 void input_DecoderDrain( decoder_t
*p_dec
)
2294 struct decoder_owner
*p_owner
= dec_get_owner( p_dec
);
2296 vlc_fifo_Lock( p_owner
->p_fifo
);
2297 p_owner
->b_draining
= true;
2298 vlc_fifo_Signal( p_owner
->p_fifo
);
2299 vlc_fifo_Unlock( p_owner
->p_fifo
);
2303 * Requests that the decoder immediately discard all pending buffers.
2304 * This is useful when seeking or when deselecting a stream.
2306 void input_DecoderFlush( decoder_t
*p_dec
)
2308 struct decoder_owner
*p_owner
= dec_get_owner( p_dec
);
2310 vlc_fifo_Lock( p_owner
->p_fifo
);
2312 /* Empty the fifo */
2313 block_ChainRelease( vlc_fifo_DequeueAllUnlocked( p_owner
->p_fifo
) );
2315 /* Don't need to wait for the DecoderThread to flush. Indeed, if called a
2316 * second time, this function will clear the FIFO again before anything was
2317 * dequeued by DecoderThread and there is no need to flush a second time in
2319 p_owner
->flushing
= true;
2321 /* Flush video/spu decoder when paused: increment frames_countdown in order
2322 * to display one frame/subtitle */
2324 && ( p_owner
->fmt
.i_cat
== VIDEO_ES
|| p_owner
->fmt
.i_cat
== SPU_ES
)
2325 && p_owner
->frames_countdown
== 0 )
2326 p_owner
->frames_countdown
++;
2328 vlc_fifo_Signal( p_owner
->p_fifo
);
2329 vlc_cond_signal( &p_owner
->wait_timed
);
2331 vlc_fifo_Unlock( p_owner
->p_fifo
);
2334 void input_DecoderGetCcDesc( decoder_t
*p_dec
, decoder_cc_desc_t
*p_desc
)
2336 struct decoder_owner
*p_owner
= dec_get_owner( p_dec
);
2338 vlc_mutex_lock( &p_owner
->lock
);
2339 *p_desc
= p_owner
->cc
.desc
;
2340 vlc_mutex_unlock( &p_owner
->lock
);
2343 static bool input_DecoderHasCCChanFlag( decoder_t
*p_dec
,
2344 vlc_fourcc_t codec
, int i_channel
)
2346 struct decoder_owner
*p_owner
= dec_get_owner( p_dec
);
2350 if( codec
== VLC_CODEC_CEA608
)
2353 i_bitmap
= p_owner
->cc
.desc
.i_608_channels
;
2355 else if( codec
== VLC_CODEC_CEA708
)
2357 i_max_channels
= 64;
2358 i_bitmap
= p_owner
->cc
.desc
.i_708_channels
;
2362 return ( i_channel
>= 0 && i_channel
< i_max_channels
&&
2363 ( i_bitmap
& ((uint64_t)1 << i_channel
) ) );
2366 int input_DecoderSetCcState( decoder_t
*p_dec
, vlc_fourcc_t codec
,
2367 int i_channel
, bool b_decode
)
2369 struct decoder_owner
*p_owner
= dec_get_owner( p_dec
);
2371 //msg_Warn( p_dec, "input_DecoderSetCcState: %d @%x", b_decode, i_channel );
2373 if( !input_DecoderHasCCChanFlag( p_dec
, codec
, i_channel
) )
2374 return VLC_EGENERIC
;
2381 es_format_Init( &fmt
, SPU_ES
, codec
);
2382 fmt
.subs
.cc
.i_channel
= i_channel
;
2383 fmt
.subs
.cc
.i_reorder_depth
= p_owner
->cc
.desc
.i_reorder_depth
;
2384 p_cc
= input_DecoderNew( p_owner
->p_input
, &fmt
,
2385 p_owner
->p_clock
, p_owner
->p_sout
);
2388 msg_Err( p_dec
, "could not create decoder" );
2389 vlc_dialog_display_error( p_dec
,
2390 _("Streaming / Transcoding failed"), "%s",
2391 _("VLC could not open the decoder module.") );
2392 return VLC_EGENERIC
;
2394 else if( !p_cc
->p_module
)
2396 DecoderUnsupportedCodec( p_dec
, &fmt
, true );
2397 input_DecoderDelete(p_cc
);
2398 return VLC_EGENERIC
;
2400 struct decoder_owner
*p_ccowner
= dec_get_owner( p_cc
);
2401 p_ccowner
->p_clock
= p_owner
->p_clock
;
2403 vlc_mutex_lock( &p_owner
->lock
);
2404 p_owner
->cc
.pp_decoder
[i_channel
] = p_cc
;
2405 vlc_mutex_unlock( &p_owner
->lock
);
2411 vlc_mutex_lock( &p_owner
->lock
);
2412 p_cc
= p_owner
->cc
.pp_decoder
[i_channel
];
2413 p_owner
->cc
.pp_decoder
[i_channel
] = NULL
;
2414 vlc_mutex_unlock( &p_owner
->lock
);
2417 input_DecoderDelete(p_cc
);
2422 int input_DecoderGetCcState( decoder_t
*p_dec
, vlc_fourcc_t codec
,
2423 int i_channel
, bool *pb_decode
)
2425 struct decoder_owner
*p_owner
= dec_get_owner( p_dec
);
2427 if( !input_DecoderHasCCChanFlag( p_dec
, codec
, i_channel
) )
2428 return VLC_EGENERIC
;
2430 vlc_mutex_lock( &p_owner
->lock
);
2431 *pb_decode
= p_owner
->cc
.pp_decoder
[i_channel
] != NULL
;
2432 vlc_mutex_unlock( &p_owner
->lock
);
2436 void input_DecoderChangePause( decoder_t
*p_dec
, bool b_paused
, vlc_tick_t i_date
)
2438 struct decoder_owner
*p_owner
= dec_get_owner( p_dec
);
2440 /* Normally, p_owner->b_paused != b_paused here. But if a track is added
2441 * while the input is paused (e.g. add sub file), then b_paused is
2442 * (incorrectly) false. FIXME: This is a bug in the decoder owner. */
2443 vlc_fifo_Lock( p_owner
->p_fifo
);
2444 p_owner
->paused
= b_paused
;
2445 p_owner
->pause_date
= i_date
;
2446 p_owner
->frames_countdown
= 0;
2447 vlc_fifo_Signal( p_owner
->p_fifo
);
2448 vlc_fifo_Unlock( p_owner
->p_fifo
);
2451 void input_DecoderChangeRate( decoder_t
*dec
, float rate
)
2453 struct decoder_owner
*owner
= dec_get_owner( dec
);
2455 vlc_fifo_Lock( owner
->p_fifo
);
2457 vlc_fifo_Signal( owner
->p_fifo
);
2458 vlc_fifo_Unlock( owner
->p_fifo
);
2461 void input_DecoderChangeDelay( decoder_t
*p_dec
, vlc_tick_t i_delay
)
2463 struct decoder_owner
*p_owner
= dec_get_owner( p_dec
);
2465 vlc_mutex_lock( &p_owner
->lock
);
2466 p_owner
->i_ts_delay
= i_delay
;
2467 vlc_mutex_unlock( &p_owner
->lock
);
2470 void input_DecoderStartWait( decoder_t
*p_dec
)
2472 struct decoder_owner
*p_owner
= dec_get_owner( p_dec
);
2474 assert( !p_owner
->b_waiting
);
2476 vlc_mutex_lock( &p_owner
->lock
);
2477 p_owner
->b_first
= true;
2478 p_owner
->b_has_data
= false;
2479 p_owner
->b_waiting
= true;
2480 vlc_cond_signal( &p_owner
->wait_request
);
2481 vlc_mutex_unlock( &p_owner
->lock
);
2484 void input_DecoderStopWait( decoder_t
*p_dec
)
2486 struct decoder_owner
*p_owner
= dec_get_owner( p_dec
);
2488 assert( p_owner
->b_waiting
);
2490 vlc_mutex_lock( &p_owner
->lock
);
2491 p_owner
->b_waiting
= false;
2492 vlc_cond_signal( &p_owner
->wait_request
);
2493 vlc_mutex_unlock( &p_owner
->lock
);
2496 void input_DecoderWait( decoder_t
*p_dec
)
2498 struct decoder_owner
*p_owner
= dec_get_owner( p_dec
);
2500 assert( p_owner
->b_waiting
);
2502 vlc_mutex_lock( &p_owner
->lock
);
2503 while( !p_owner
->b_has_data
)
2505 /* Don't need to lock p_owner->paused since it's only modified by the
2507 if( p_owner
->paused
)
2509 vlc_fifo_Lock( p_owner
->p_fifo
);
2510 if( p_owner
->b_idle
&& vlc_fifo_IsEmpty( p_owner
->p_fifo
) )
2512 msg_Err( p_dec
, "buffer deadlock prevented" );
2513 vlc_fifo_Unlock( p_owner
->p_fifo
);
2516 vlc_fifo_Unlock( p_owner
->p_fifo
);
2517 vlc_cond_wait( &p_owner
->wait_acknowledge
, &p_owner
->lock
);
2519 vlc_mutex_unlock( &p_owner
->lock
);
2522 void input_DecoderFrameNext( decoder_t
*p_dec
, vlc_tick_t
*pi_duration
)
2524 struct decoder_owner
*p_owner
= dec_get_owner( p_dec
);
2526 assert( p_owner
->paused
);
2529 vlc_fifo_Lock( p_owner
->p_fifo
);
2530 p_owner
->frames_countdown
++;
2531 vlc_fifo_Signal( p_owner
->p_fifo
);
2532 vlc_fifo_Unlock( p_owner
->p_fifo
);
2534 vlc_mutex_lock( &p_owner
->lock
);
2535 if( p_owner
->fmt
.i_cat
== VIDEO_ES
)
2537 if( p_owner
->p_vout
)
2538 vout_NextPicture( p_owner
->p_vout
, pi_duration
);
2540 vlc_mutex_unlock( &p_owner
->lock
);
2543 bool input_DecoderHasFormatChanged( decoder_t
*p_dec
, es_format_t
*p_fmt
, vlc_meta_t
**pp_meta
)
2545 struct decoder_owner
*p_owner
= dec_get_owner( p_dec
);
2547 if( !atomic_exchange_explicit( &p_owner
->b_fmt_description
, false,
2548 memory_order_acquire
) )
2551 vlc_mutex_lock( &p_owner
->lock
);
2553 es_format_Copy( p_fmt
, &p_owner
->fmt
);
2558 if( p_owner
->p_description
)
2560 *pp_meta
= vlc_meta_New();
2562 vlc_meta_Merge( *pp_meta
, p_owner
->p_description
);
2565 vlc_mutex_unlock( &p_owner
->lock
);
2569 size_t input_DecoderGetFifoSize( decoder_t
*p_dec
)
2571 struct decoder_owner
*p_owner
= dec_get_owner( p_dec
);
2573 return block_FifoSize( p_owner
->p_fifo
);
2576 void input_DecoderGetObjects( decoder_t
*p_dec
,
2577 vout_thread_t
**pp_vout
, audio_output_t
**pp_aout
)
2579 struct decoder_owner
*p_owner
= dec_get_owner( p_dec
);
2581 vlc_mutex_lock( &p_owner
->lock
);
2583 *pp_vout
= p_dec
->fmt_in
.i_cat
== VIDEO_ES
&& p_owner
->p_vout
?
2584 vlc_object_hold( p_owner
->p_vout
) : NULL
;
2586 *pp_aout
= p_dec
->fmt_in
.i_cat
== AUDIO_ES
&& p_owner
->p_aout
?
2587 vlc_object_hold( p_owner
->p_aout
) : NULL
;
2588 vlc_mutex_unlock( &p_owner
->lock
);
2591 void input_DecoderSetVoutMouseEvent( decoder_t
*dec
, vlc_mouse_event mouse_event
,
2594 struct decoder_owner
*owner
= dec_get_owner( dec
);
2595 assert( dec
->fmt_in
.i_cat
== VIDEO_ES
);
2597 vlc_mutex_lock( &owner
->mouse_lock
);
2599 owner
->mouse_event
= mouse_event
;
2600 owner
->mouse_opaque
= user_data
;
2602 vlc_mutex_unlock( &owner
->mouse_lock
);
2605 int input_DecoderAddVoutOverlay( decoder_t
*dec
, subpicture_t
*sub
,
2608 struct decoder_owner
*owner
= dec_get_owner( dec
);
2609 assert( dec
->fmt_in
.i_cat
== VIDEO_ES
);
2610 assert( sub
&& channel
);
2612 vlc_mutex_lock( &owner
->lock
);
2614 if( !owner
->p_vout
)
2616 vlc_mutex_unlock( &owner
->lock
);
2617 return VLC_EGENERIC
;
2619 sub
->i_start
= sub
->i_stop
= vlc_tick_now();
2620 sub
->i_channel
= *channel
= vout_RegisterSubpictureChannel( owner
->p_vout
);
2622 sub
->b_ephemer
= true;
2623 vout_PutSubpicture( owner
->p_vout
, sub
);
2625 vlc_mutex_unlock( &owner
->lock
);
2629 int input_DecoderFlushVoutOverlay( decoder_t
*dec
, int channel
)
2631 struct decoder_owner
*owner
= dec_get_owner( dec
);
2632 assert( dec
->fmt_in
.i_cat
== VIDEO_ES
);
2634 vlc_mutex_lock( &owner
->lock
);
2636 if( !owner
->p_vout
)
2638 vlc_mutex_unlock( &owner
->lock
);
2639 return VLC_EGENERIC
;
2641 vout_FlushSubpictureChannel( owner
->p_vout
, channel
);
2643 vlc_mutex_unlock( &owner
->lock
);
2647 int input_DecoderSetSpuHighlight( decoder_t
*dec
,
2648 const vlc_spu_highlight_t
*spu_hl
)
2650 struct decoder_owner
*p_owner
= dec_get_owner( dec
);
2651 assert( dec
->fmt_in
.i_cat
== SPU_ES
);
2654 if( p_owner
->p_sout_input
)
2655 sout_InputControl( p_owner
->p_sout_input
, SOUT_INPUT_SET_SPU_HIGHLIGHT
, spu_hl
);
2658 vlc_mutex_lock( &p_owner
->lock
);
2659 if( !p_owner
->p_vout
)
2661 vlc_mutex_unlock( &p_owner
->lock
);
2662 return VLC_EGENERIC
;
2665 vout_SetSpuHighlight( p_owner
->p_vout
, spu_hl
);
2667 vlc_mutex_unlock( &p_owner
->lock
);