1 /*****************************************************************************
2 * video_output.c : video output thread
4 * This module describes the programming interface for video output threads.
5 * It includes functions allowing to open a new thread, send pictures to a
6 * thread, and destroy a previously oppened video output thread.
7 *****************************************************************************
8 * Copyright (C) 2000-2007 the VideoLAN team
11 * Authors: Vincent Seguin <seguin@via.ecp.fr>
12 * Gildas Bazin <gbazin@videolan.org>
14 * This program is free software; you can redistribute it and/or modify
15 * it under the terms of the GNU General Public License as published by
16 * the Free Software Foundation; either version 2 of the License, or
17 * (at your option) any later version.
19 * This program is distributed in the hope that it will be useful,
20 * but WITHOUT ANY WARRANTY; without even the implied warranty of
21 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22 * GNU General Public License for more details.
24 * You should have received a copy of the GNU General Public License
25 * along with this program; if not, write to the Free Software
26 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
27 *****************************************************************************/
29 /*****************************************************************************
31 *****************************************************************************/
36 #include <vlc_common.h>
38 #include <stdlib.h> /* free() */
42 #ifdef HAVE_SYS_TIMES_H
43 # include <sys/times.h>
48 #include <vlc_filter.h>
52 #if defined( __APPLE__ )
53 /* Include darwin_specific.h here if needed */
56 /** FIXME This is quite ugly but needed while we don't have counters
58 //#include "input/input_internal.h"
61 #include <vlc_input.h>
62 #include "vout_pictures.h"
63 #include "vout_internal.h"
65 /*****************************************************************************
67 *****************************************************************************/
68 static int InitThread ( vout_thread_t
* );
69 static void* RunThread ( void * );
70 static void ErrorThread ( vout_thread_t
* );
71 static void CleanThread ( vout_thread_t
* );
72 static void EndThread ( vout_thread_t
* );
74 static void AspectRatio ( int, int *, int * );
76 static void VideoFormatImportRgb( video_format_t
*, const picture_heap_t
* );
77 static void PictureHeapFixRgb( picture_heap_t
* );
79 static void vout_Destructor ( vlc_object_t
* p_this
);
81 /* Object variables callbacks */
82 static int FilterCallback( vlc_object_t
*, char const *,
83 vlc_value_t
, vlc_value_t
, void * );
84 static int VideoFilter2Callback( vlc_object_t
*, char const *,
85 vlc_value_t
, vlc_value_t
, void * );
88 static void PostProcessEnable( vout_thread_t
* );
89 static void PostProcessDisable( vout_thread_t
* );
90 static void PostProcessSetFilterQuality( vout_thread_t
*p_vout
);
91 static int PostProcessCallback( vlc_object_t
*, char const *,
92 vlc_value_t
, vlc_value_t
, void * );
94 static void DeinterlaceEnable( vout_thread_t
* );
96 /* From vout_intf.c */
97 int vout_Snapshot( vout_thread_t
*, picture_t
* );
99 /* Display media title in OSD */
100 static void DisplayTitleOnOSD( vout_thread_t
*p_vout
);
102 /* Time during which the thread will sleep if it has nothing to
103 * display (in micro-seconds) */
104 #define VOUT_IDLE_SLEEP ((int)(0.020*CLOCK_FREQ))
106 /* Maximum lap of time allowed between the beginning of rendering and
107 * display. If, compared to the current date, the next image is too
108 * late, the thread will perform an idle loop. This time should be
109 * at least VOUT_IDLE_SLEEP plus the time required to render a few
110 * images, to avoid trashing of decoded images */
111 #define VOUT_DISPLAY_DELAY ((int)(0.200*CLOCK_FREQ))
113 /* Better be in advance when awakening than late... */
114 #define VOUT_MWAIT_TOLERANCE ((mtime_t)(0.020*CLOCK_FREQ))
116 /* Minimum number of direct pictures the video output will accept without
117 * creating additional pictures in system memory */
118 #ifdef OPTIMIZE_MEMORY
119 # define VOUT_MIN_DIRECT_PICTURES (VOUT_MAX_PICTURES/2)
121 # define VOUT_MIN_DIRECT_PICTURES (3*VOUT_MAX_PICTURES/4)
124 /*****************************************************************************
125 * Video Filter2 functions
126 *****************************************************************************/
127 static picture_t
*video_new_buffer_filter( filter_t
*p_filter
)
129 vout_thread_t
*p_vout
= (vout_thread_t
*)p_filter
->p_owner
;
130 picture_t
*p_picture
= vout_CreatePicture( p_vout
, 0, 0, 0 );
132 p_picture
->i_status
= READY_PICTURE
;
137 static void video_del_buffer_filter( filter_t
*p_filter
, picture_t
*p_pic
)
139 vout_thread_t
*p_vout
= (vout_thread_t
*)p_filter
->p_owner
;
141 vlc_mutex_lock( &p_vout
->picture_lock
);
142 vout_UsePictureLocked( p_vout
, p_pic
);
143 vlc_mutex_unlock( &p_vout
->picture_lock
);
146 static int video_filter_buffer_allocation_init( filter_t
*p_filter
, void *p_data
)
148 p_filter
->pf_vout_buffer_new
= video_new_buffer_filter
;
149 p_filter
->pf_vout_buffer_del
= video_del_buffer_filter
;
150 p_filter
->p_owner
= p_data
; /* p_vout */
154 /*****************************************************************************
155 * vout_Request: find a video output thread, create one, or destroy one.
156 *****************************************************************************
157 * This function looks for a video output thread matching the current
158 * properties. If not found, it spawns a new one.
159 *****************************************************************************/
160 vout_thread_t
*__vout_Request( vlc_object_t
*p_this
, vout_thread_t
*p_vout
,
161 video_format_t
*p_fmt
)
165 /* Video output is no longer used.
166 * TODO: support for reusing video outputs with proper _thread-safe_
167 * reference handling. */
169 vout_CloseAndRelease( p_vout
);
173 /* If a video output was provided, lock it, otherwise look for one. */
176 vlc_object_hold( p_vout
);
179 /* TODO: find a suitable unused video output */
181 /* If we now have a video output, check it has the right properties */
184 vlc_mutex_lock( &p_vout
->change_lock
);
186 /* We don't directly check for the "vout-filter" variable for obvious
187 * performance reasons. */
188 if( p_vout
->p
->b_filter_change
)
190 char *psz_filter_chain
= var_GetString( p_vout
, "vout-filter" );
192 if( psz_filter_chain
&& !*psz_filter_chain
)
194 free( psz_filter_chain
);
195 psz_filter_chain
= NULL
;
197 if( p_vout
->p
->psz_filter_chain
&& !*p_vout
->p
->psz_filter_chain
)
199 free( p_vout
->p
->psz_filter_chain
);
200 p_vout
->p
->psz_filter_chain
= NULL
;
203 if( !psz_filter_chain
&& !p_vout
->p
->psz_filter_chain
)
205 p_vout
->p
->b_filter_change
= false;
208 free( psz_filter_chain
);
211 if( p_vout
->fmt_render
.i_chroma
!= vlc_fourcc_GetCodec( VIDEO_ES
, p_fmt
->i_chroma
) ||
212 p_vout
->fmt_render
.i_width
!= p_fmt
->i_width
||
213 p_vout
->fmt_render
.i_height
!= p_fmt
->i_height
||
214 p_vout
->p
->b_filter_change
)
216 vlc_mutex_unlock( &p_vout
->change_lock
);
218 /* We are not interested in this format, close this vout */
219 vout_CloseAndRelease( p_vout
);
220 vlc_object_release( p_vout
);
225 /* This video output is cool! Hijack it. */
226 if( p_vout
->fmt_render
.i_aspect
!= p_fmt
->i_aspect
)
228 /* Correct aspect ratio on change
229 * FIXME factorize this code with other aspect ration related code */
230 unsigned int i_sar_num
;
231 unsigned int i_sar_den
;
232 unsigned int i_aspect
;
234 i_aspect
= p_fmt
->i_aspect
;
235 vlc_ureduce( &i_sar_num
, &i_sar_den
,
236 p_fmt
->i_sar_num
, p_fmt
->i_sar_den
, 50000 );
238 /* What's that, it does not seems to be used correcly everywhere
239 * beside the previous p_vout->fmt_render.i_aspect != p_fmt->i_aspect
240 * should be fixed to use it too then */
241 if( p_vout
->i_par_num
> 0 && p_vout
->i_par_den
> 0 )
243 i_sar_num
*= p_vout
->i_par_den
;
244 i_sar_den
*= p_vout
->i_par_num
;
245 i_aspect
= i_aspect
* p_vout
->i_par_den
/ p_vout
->i_par_num
;
249 if( i_sar_num
> 0 && i_sar_den
> 0 && i_aspect
> 0 )
251 p_vout
->fmt_in
.i_sar_num
= i_sar_num
;
252 p_vout
->fmt_in
.i_sar_den
= i_sar_den
;
253 p_vout
->fmt_in
.i_aspect
= i_aspect
;
255 p_vout
->fmt_render
.i_sar_num
= i_sar_num
;
256 p_vout
->fmt_render
.i_sar_den
= i_sar_den
;
257 p_vout
->fmt_render
.i_aspect
= i_aspect
;
259 p_vout
->render
.i_aspect
= i_aspect
;
261 p_vout
->i_changes
|= VOUT_ASPECT_CHANGE
;
265 vlc_mutex_unlock( &p_vout
->change_lock
);
267 vlc_object_release( p_vout
);
272 msg_Dbg( p_this
, "reusing provided vout" );
274 spu_Attach( p_vout
->p_spu
, VLC_OBJECT(p_vout
), false );
275 vlc_object_detach( p_vout
);
277 vlc_object_attach( p_vout
, p_this
);
278 spu_Attach( p_vout
->p_spu
, VLC_OBJECT(p_vout
), true );
284 msg_Dbg( p_this
, "no usable vout present, spawning one" );
286 p_vout
= vout_Create( p_this
, p_fmt
);
292 /*****************************************************************************
293 * vout_Create: creates a new video output thread
294 *****************************************************************************
295 * This function creates a new video output thread, and returns a pointer
296 * to its description. On error, it returns NULL.
297 *****************************************************************************/
298 vout_thread_t
* __vout_Create( vlc_object_t
*p_parent
, video_format_t
*p_fmt
)
300 vout_thread_t
* p_vout
; /* thread descriptor */
301 int i_index
; /* loop variable */
304 unsigned int i_width
= p_fmt
->i_width
;
305 unsigned int i_height
= p_fmt
->i_height
;
306 vlc_fourcc_t i_chroma
= vlc_fourcc_GetCodec( VIDEO_ES
, p_fmt
->i_chroma
);
307 unsigned int i_aspect
= p_fmt
->i_aspect
;
309 config_chain_t
*p_cfg
;
313 if( i_width
<= 0 || i_height
<= 0 || i_aspect
<= 0 )
316 vlc_ureduce( &p_fmt
->i_sar_num
, &p_fmt
->i_sar_den
,
317 p_fmt
->i_sar_num
, p_fmt
->i_sar_den
, 50000 );
318 if( p_fmt
->i_sar_num
<= 0 || p_fmt
->i_sar_den
<= 0 )
321 /* Allocate descriptor */
322 static const char typename
[] = "video output";
323 p_vout
= vlc_custom_create( p_parent
, sizeof( *p_vout
), VLC_OBJECT_VOUT
,
329 p_vout
->p
= calloc( 1, sizeof(*p_vout
->p
) );
332 vlc_object_release( p_vout
);
336 /* Initialize pictures - translation tables and functions
337 * will be initialized later in InitThread */
338 for( i_index
= 0; i_index
< 2 * VOUT_MAX_PICTURES
+ 1; i_index
++)
340 p_vout
->p_picture
[i_index
].pf_lock
= NULL
;
341 p_vout
->p_picture
[i_index
].pf_unlock
= NULL
;
342 p_vout
->p_picture
[i_index
].i_status
= FREE_PICTURE
;
343 p_vout
->p_picture
[i_index
].i_type
= EMPTY_PICTURE
;
344 p_vout
->p_picture
[i_index
].b_slow
= 0;
347 /* No images in the heap */
348 p_vout
->i_heap_size
= 0;
350 /* Initialize the rendering heap */
351 I_RENDERPICTURES
= 0;
353 p_vout
->fmt_render
= *p_fmt
; /* FIXME palette */
354 p_vout
->fmt_in
= *p_fmt
; /* FIXME palette */
356 p_vout
->render
.i_width
= i_width
;
357 p_vout
->render
.i_height
= i_height
;
358 p_vout
->render
.i_chroma
= i_chroma
;
359 p_vout
->render
.i_aspect
= i_aspect
;
361 p_vout
->render
.i_rmask
= p_fmt
->i_rmask
;
362 p_vout
->render
.i_gmask
= p_fmt
->i_gmask
;
363 p_vout
->render
.i_bmask
= p_fmt
->i_bmask
;
365 p_vout
->render
.i_last_used_pic
= -1;
366 p_vout
->render
.b_allow_modify_pics
= 1;
368 /* Zero the output heap */
369 I_OUTPUTPICTURES
= 0;
370 p_vout
->output
.i_width
= 0;
371 p_vout
->output
.i_height
= 0;
372 p_vout
->output
.i_chroma
= 0;
373 p_vout
->output
.i_aspect
= 0;
375 p_vout
->output
.i_rmask
= 0;
376 p_vout
->output
.i_gmask
= 0;
377 p_vout
->output
.i_bmask
= 0;
379 /* Initialize misc stuff */
380 p_vout
->i_changes
= 0;
381 p_vout
->b_autoscale
= 1;
382 p_vout
->i_zoom
= ZOOM_FP_FACTOR
;
383 p_vout
->b_fullscreen
= 0;
384 p_vout
->i_alignment
= 0;
385 p_vout
->p
->render_time
= 10;
386 p_vout
->p
->c_fps_samples
= 0;
387 vout_statistic_Init( &p_vout
->p
->statistic
);
388 p_vout
->p
->b_filter_change
= 0;
389 p_vout
->p
->b_paused
= false;
390 p_vout
->p
->i_pause_date
= 0;
391 p_vout
->pf_control
= NULL
;
392 p_vout
->p
->i_par_num
=
393 p_vout
->p
->i_par_den
= 1;
394 p_vout
->p
->p_picture_displayed
= NULL
;
395 p_vout
->p
->i_picture_displayed_date
= 0;
396 p_vout
->p
->b_picture_displayed
= false;
397 p_vout
->p
->b_picture_empty
= false;
398 p_vout
->p
->i_picture_qtype
= QTYPE_NONE
;
400 vlc_mouse_Init( &p_vout
->p
->mouse
);
402 vout_snapshot_Init( &p_vout
->p
->snapshot
);
404 /* Initialize locks */
405 vlc_mutex_init( &p_vout
->picture_lock
);
406 vlc_cond_init( &p_vout
->p
->picture_wait
);
407 vlc_mutex_init( &p_vout
->change_lock
);
408 vlc_mutex_init( &p_vout
->p
->vfilter_lock
);
410 /* Mouse coordinates */
411 var_Create( p_vout
, "mouse-x", VLC_VAR_INTEGER
);
412 var_Create( p_vout
, "mouse-y", VLC_VAR_INTEGER
);
413 var_Create( p_vout
, "mouse-button-down", VLC_VAR_INTEGER
);
414 var_Create( p_vout
, "mouse-moved", VLC_VAR_BOOL
);
415 var_Create( p_vout
, "mouse-clicked", VLC_VAR_BOOL
);
417 /* Initialize subpicture unit */
418 p_vout
->p_spu
= spu_Create( p_vout
);
420 /* Attach the new object now so we can use var inheritance below */
421 vlc_object_attach( p_vout
, p_parent
);
424 spu_Init( p_vout
->p_spu
);
426 spu_Attach( p_vout
->p_spu
, VLC_OBJECT(p_vout
), true );
428 /* Take care of some "interface/control" related initialisations */
429 vout_IntfInit( p_vout
);
431 /* If the parent is not a VOUT object, that means we are at the start of
432 * the video output pipe */
433 if( vlc_internals( p_parent
)->i_object_type
!= VLC_OBJECT_VOUT
)
435 /* Look for the default filter configuration */
436 p_vout
->p
->psz_filter_chain
=
437 var_CreateGetStringCommand( p_vout
, "vout-filter" );
439 /* Apply video filter2 objects on the first vout */
441 var_CreateGetStringCommand( p_vout
, "video-filter" );
443 p_vout
->p
->b_first_vout
= true;
447 /* continue the parent's filter chain */
450 /* Ugly hack to jump to our configuration chain */
451 p_vout
->p
->psz_filter_chain
452 = ((vout_thread_t
*)p_parent
)->p
->psz_filter_chain
;
453 p_vout
->p
->psz_filter_chain
454 = config_ChainCreate( &psz_tmp
, &p_cfg
, p_vout
->p
->psz_filter_chain
);
455 config_ChainDestroy( p_cfg
);
458 /* Create a video filter2 var ... but don't inherit values */
459 var_Create( p_vout
, "video-filter",
460 VLC_VAR_STRING
| VLC_VAR_ISCOMMAND
);
461 p_vout
->p
->psz_vf2
= var_GetString( p_vout
, "video-filter" );
464 p_vout
->p
->b_first_vout
= false;
467 var_AddCallback( p_vout
, "video-filter", VideoFilter2Callback
, NULL
);
468 p_vout
->p
->p_vf2_chain
= filter_chain_New( p_vout
, "video filter2",
469 false, video_filter_buffer_allocation_init
, NULL
, p_vout
);
471 /* Choose the video output module */
472 if( !p_vout
->p
->psz_filter_chain
|| !*p_vout
->p
->psz_filter_chain
)
474 psz_parser
= var_CreateGetString( p_vout
, "vout" );
478 psz_parser
= strdup( p_vout
->p
->psz_filter_chain
);
479 p_vout
->p
->b_title_show
= false;
482 /* Create the vout thread */
483 char* psz_tmp
= config_ChainCreate( &psz_name
, &p_cfg
, psz_parser
);
486 p_vout
->p_cfg
= p_cfg
;
488 /* Create a few object variables for interface interaction */
489 var_Create( p_vout
, "vout-filter", VLC_VAR_STRING
| VLC_VAR_DOINHERIT
);
490 text
.psz_string
= _("Filters");
491 var_Change( p_vout
, "vout-filter", VLC_VAR_SETTEXT
, &text
, NULL
);
492 var_AddCallback( p_vout
, "vout-filter", FilterCallback
, NULL
);
495 DeinterlaceEnable( p_vout
);
497 if( p_vout
->p
->psz_filter_chain
&& *p_vout
->p
->psz_filter_chain
)
498 p_vout
->p
->psz_module_type
= "video filter";
500 p_vout
->p
->psz_module_type
= "video output";
501 p_vout
->p
->psz_module_name
= psz_name
;
502 p_vout
->p_module
= NULL
;
505 vlc_object_set_destructor( p_vout
, vout_Destructor
);
508 vlc_cond_init( &p_vout
->p
->change_wait
);
509 if( vlc_clone( &p_vout
->p
->thread
, RunThread
, p_vout
,
510 VLC_THREAD_PRIORITY_OUTPUT
) )
512 spu_Attach( p_vout
->p_spu
, VLC_OBJECT(p_vout
), false );
513 spu_Destroy( p_vout
->p_spu
);
514 p_vout
->p_spu
= NULL
;
515 vlc_object_release( p_vout
);
519 vlc_mutex_lock( &p_vout
->change_lock
);
520 while( !p_vout
->p
->b_ready
)
521 { /* We are (ab)using the same condition in opposite directions for
522 * b_ready and b_done. This works because of the strict ordering. */
523 assert( !p_vout
->p
->b_done
);
524 vlc_cond_wait( &p_vout
->p
->change_wait
, &p_vout
->change_lock
);
526 vlc_mutex_unlock( &p_vout
->change_lock
);
528 if( p_vout
->b_error
)
530 msg_Err( p_vout
, "video output creation failed" );
531 vout_CloseAndRelease( p_vout
);
538 /*****************************************************************************
539 * vout_Close: Close a vout created by vout_Create.
540 *****************************************************************************
541 * You HAVE to call it on vout created by vout_Create before vlc_object_release.
542 * You should NEVER call it on vout not obtained through vout_Create
543 * (like with vout_Request or vlc_object_find.)
544 * You can use vout_CloseAndRelease() as a convenience method.
545 *****************************************************************************/
546 void vout_Close( vout_thread_t
*p_vout
)
550 vlc_mutex_lock( &p_vout
->change_lock
);
551 p_vout
->p
->b_done
= true;
552 vlc_cond_signal( &p_vout
->p
->change_wait
);
553 vlc_mutex_unlock( &p_vout
->change_lock
);
555 vout_snapshot_End( &p_vout
->p
->snapshot
);
557 vlc_join( p_vout
->p
->thread
, NULL
);
561 static void vout_Destructor( vlc_object_t
* p_this
)
563 vout_thread_t
*p_vout
= (vout_thread_t
*)p_this
;
565 /* Make sure the vout was stopped first */
566 assert( !p_vout
->p_module
);
568 free( p_vout
->p
->psz_module_name
);
572 spu_Destroy( p_vout
->p_spu
);
574 /* Destroy the locks */
575 vlc_cond_destroy( &p_vout
->p
->change_wait
);
576 vlc_cond_destroy( &p_vout
->p
->picture_wait
);
577 vlc_mutex_destroy( &p_vout
->picture_lock
);
578 vlc_mutex_destroy( &p_vout
->change_lock
);
579 vlc_mutex_destroy( &p_vout
->p
->vfilter_lock
);
582 vout_statistic_Clean( &p_vout
->p
->statistic
);
585 vout_snapshot_Clean( &p_vout
->p
->snapshot
);
588 free( p_vout
->p
->psz_filter_chain
);
589 free( p_vout
->p
->psz_title
);
591 config_ChainDestroy( p_vout
->p_cfg
);
596 vout_thread_t
*p_another_vout
;
598 /* This is a dirty hack mostly for Linux, where there is no way to get the
599 * GUI back if you closed it while playing video. This is solved in
600 * Mac OS X, where we have this novelty called menubar, that will always
601 * allow you access to the applications main functionality. They should try
602 * that on linux sometime. */
603 p_another_vout
= vlc_object_find( p_this
->p_libvlc
,
604 VLC_OBJECT_VOUT
, FIND_ANYWHERE
);
605 if( p_another_vout
== NULL
)
606 var_SetBool( p_this
->p_libvlc
, "intf-show", true );
608 vlc_object_release( p_another_vout
);
613 void vout_ChangePause( vout_thread_t
*p_vout
, bool b_paused
, mtime_t i_date
)
615 vlc_mutex_lock( &p_vout
->change_lock
);
617 assert( !p_vout
->p
->b_paused
|| !b_paused
);
619 vlc_mutex_lock( &p_vout
->picture_lock
);
621 p_vout
->p
->i_picture_displayed_date
= 0;
623 if( p_vout
->p
->b_paused
)
625 const mtime_t i_duration
= i_date
- p_vout
->p
->i_pause_date
;
627 for( int i_index
= 0; i_index
< I_RENDERPICTURES
; i_index
++ )
629 picture_t
*p_pic
= PP_RENDERPICTURE
[i_index
];
631 if( p_pic
->i_status
== READY_PICTURE
)
632 p_pic
->date
+= i_duration
;
634 vlc_cond_signal( &p_vout
->p
->picture_wait
);
635 vlc_mutex_unlock( &p_vout
->picture_lock
);
637 spu_OffsetSubtitleDate( p_vout
->p_spu
, i_duration
);
641 vlc_mutex_unlock( &p_vout
->picture_lock
);
643 p_vout
->p
->b_paused
= b_paused
;
644 p_vout
->p
->i_pause_date
= i_date
;
646 vlc_mutex_unlock( &p_vout
->change_lock
);
649 void vout_GetResetStatistic( vout_thread_t
*p_vout
, int *pi_displayed
, int *pi_lost
)
651 vout_statistic_GetReset( &p_vout
->p
->statistic
,
652 pi_displayed
, pi_lost
);
655 void vout_Flush( vout_thread_t
*p_vout
, mtime_t i_date
)
657 vlc_mutex_lock( &p_vout
->picture_lock
);
658 p_vout
->p
->i_picture_displayed_date
= 0;
659 for( int i
= 0; i
< p_vout
->render
.i_pictures
; i
++ )
661 picture_t
*p_pic
= p_vout
->render
.pp_picture
[i
];
663 if( p_pic
->i_status
== READY_PICTURE
||
664 p_pic
->i_status
== DISPLAYED_PICTURE
)
666 /* We cannot change picture status if it is in READY_PICTURE state,
667 * Just make sure they won't be displayed */
668 if( p_pic
->date
> i_date
)
669 p_pic
->date
= i_date
;
672 vlc_cond_signal( &p_vout
->p
->picture_wait
);
673 vlc_mutex_unlock( &p_vout
->picture_lock
);
676 void vout_FixLeaks( vout_thread_t
*p_vout
, bool b_forced
)
678 int i_pic
, i_ready_pic
;
680 vlc_mutex_lock( &p_vout
->picture_lock
);
682 for( i_pic
= 0, i_ready_pic
= 0; i_pic
< p_vout
->render
.i_pictures
&& !b_forced
; i_pic
++ )
684 const picture_t
*p_pic
= p_vout
->render
.pp_picture
[i_pic
];
686 if( p_pic
->i_status
== READY_PICTURE
)
689 /* If we have at least 2 ready pictures, wait for the vout thread to
691 if( i_ready_pic
>= 2 )
697 if( p_pic
->i_status
== DISPLAYED_PICTURE
)
699 /* If at least one displayed picture is not referenced
700 * let vout free it */
701 if( p_pic
->i_refcount
== 0 )
705 if( i_pic
< p_vout
->render
.i_pictures
&& !b_forced
)
707 vlc_mutex_unlock( &p_vout
->picture_lock
);
711 /* Too many pictures are still referenced, there is probably a bug
712 * with the decoder */
714 msg_Err( p_vout
, "pictures leaked, resetting the heap" );
716 /* Just free all the pictures */
717 for( i_pic
= 0; i_pic
< p_vout
->render
.i_pictures
; i_pic
++ )
719 picture_t
*p_pic
= p_vout
->render
.pp_picture
[i_pic
];
721 msg_Dbg( p_vout
, "[%d] %d %d", i_pic
, p_pic
->i_status
, p_pic
->i_refcount
);
722 p_pic
->i_refcount
= 0;
724 switch( p_pic
->i_status
)
727 case DISPLAYED_PICTURE
:
728 case RESERVED_PICTURE
:
729 if( p_pic
!= p_vout
->p
->p_picture_displayed
)
730 vout_UsePictureLocked( p_vout
, p_pic
);
734 vlc_cond_signal( &p_vout
->p
->picture_wait
);
735 vlc_mutex_unlock( &p_vout
->picture_lock
);
737 void vout_NextPicture( vout_thread_t
*p_vout
, mtime_t
*pi_duration
)
739 vlc_mutex_lock( &p_vout
->picture_lock
);
741 const mtime_t i_displayed_date
= p_vout
->p
->i_picture_displayed_date
;
743 p_vout
->p
->b_picture_displayed
= false;
744 p_vout
->p
->b_picture_empty
= false;
745 if( p_vout
->p
->p_picture_displayed
)
747 p_vout
->p
->p_picture_displayed
->date
= 1;
748 vlc_cond_signal( &p_vout
->p
->picture_wait
);
751 while( !p_vout
->p
->b_picture_displayed
&& !p_vout
->p
->b_picture_empty
)
752 vlc_cond_wait( &p_vout
->p
->picture_wait
, &p_vout
->picture_lock
);
754 *pi_duration
= __MAX( p_vout
->p
->i_picture_displayed_date
- i_displayed_date
, 0 );
756 /* TODO advance subpicture by the duration ... */
758 vlc_mutex_unlock( &p_vout
->picture_lock
);
761 void vout_DisplayTitle( vout_thread_t
*p_vout
, const char *psz_title
)
765 if( !config_GetInt( p_vout
, "osd" ) )
768 vlc_mutex_lock( &p_vout
->change_lock
);
769 free( p_vout
->p
->psz_title
);
770 p_vout
->p
->psz_title
= strdup( psz_title
);
771 vlc_mutex_unlock( &p_vout
->change_lock
);
774 spu_t
*vout_GetSpu( vout_thread_t
*p_vout
)
776 return p_vout
->p_spu
;
779 /*****************************************************************************
780 * InitThread: initialize video output thread
781 *****************************************************************************
782 * This function is called from RunThread and performs the second step of the
783 * initialization. It returns 0 on success. Note that the thread's flag are not
784 * modified inside this function.
785 * XXX You have to enter it with change_lock taken.
786 *****************************************************************************/
787 static int ChromaCreate( vout_thread_t
*p_vout
);
788 static void ChromaDestroy( vout_thread_t
*p_vout
);
790 static bool ChromaIsEqual( const picture_heap_t
*p_output
, const picture_heap_t
*p_render
)
792 if( !vout_ChromaCmp( p_output
->i_chroma
, p_render
->i_chroma
) )
795 if( p_output
->i_chroma
!= VLC_CODEC_RGB15
&&
796 p_output
->i_chroma
!= VLC_CODEC_RGB16
&&
797 p_output
->i_chroma
!= VLC_CODEC_RGB24
&&
798 p_output
->i_chroma
!= VLC_CODEC_RGB32
)
801 return p_output
->i_rmask
== p_render
->i_rmask
&&
802 p_output
->i_gmask
== p_render
->i_gmask
&&
803 p_output
->i_bmask
== p_render
->i_bmask
;
806 static int InitThread( vout_thread_t
*p_vout
)
808 int i
, i_aspect_x
, i_aspect_y
;
810 /* Initialize output method, it allocates direct buffers for us */
811 if( p_vout
->pf_init( p_vout
) )
814 p_vout
->p
->p_picture_displayed
= NULL
;
816 if( !I_OUTPUTPICTURES
)
818 msg_Err( p_vout
, "plugin was unable to allocate at least "
819 "one direct buffer" );
820 p_vout
->pf_end( p_vout
);
824 if( I_OUTPUTPICTURES
> VOUT_MAX_PICTURES
)
826 msg_Err( p_vout
, "plugin allocated too many direct buffers, "
827 "our internal buffers must have overflown." );
828 p_vout
->pf_end( p_vout
);
832 msg_Dbg( p_vout
, "got %i direct buffer(s)", I_OUTPUTPICTURES
);
834 AspectRatio( p_vout
->fmt_render
.i_aspect
, &i_aspect_x
, &i_aspect_y
);
836 AspectRatio( p_vout
->fmt_in
.i_aspect
, &i_aspect_x
, &i_aspect_y
);
838 if( !p_vout
->fmt_out
.i_width
|| !p_vout
->fmt_out
.i_height
)
840 p_vout
->fmt_out
.i_width
= p_vout
->fmt_out
.i_visible_width
=
841 p_vout
->output
.i_width
;
842 p_vout
->fmt_out
.i_height
= p_vout
->fmt_out
.i_visible_height
=
843 p_vout
->output
.i_height
;
844 p_vout
->fmt_out
.i_x_offset
= p_vout
->fmt_out
.i_y_offset
= 0;
846 p_vout
->fmt_out
.i_aspect
= p_vout
->output
.i_aspect
;
847 p_vout
->fmt_out
.i_chroma
= p_vout
->output
.i_chroma
;
849 if( !p_vout
->fmt_out
.i_sar_num
|| !p_vout
->fmt_out
.i_sar_num
)
851 p_vout
->fmt_out
.i_sar_num
= p_vout
->fmt_out
.i_aspect
*
852 p_vout
->fmt_out
.i_height
;
853 p_vout
->fmt_out
.i_sar_den
= VOUT_ASPECT_FACTOR
*
854 p_vout
->fmt_out
.i_width
;
857 vlc_ureduce( &p_vout
->fmt_out
.i_sar_num
, &p_vout
->fmt_out
.i_sar_den
,
858 p_vout
->fmt_out
.i_sar_num
, p_vout
->fmt_out
.i_sar_den
, 0 );
860 AspectRatio( p_vout
->fmt_out
.i_aspect
, &i_aspect_x
, &i_aspect_y
);
862 /* FIXME removed the need of both fmt_* and heap infos */
863 /* Calculate shifts from system-updated masks */
864 PictureHeapFixRgb( &p_vout
->render
);
865 VideoFormatImportRgb( &p_vout
->fmt_render
, &p_vout
->render
);
867 PictureHeapFixRgb( &p_vout
->output
);
868 VideoFormatImportRgb( &p_vout
->fmt_out
, &p_vout
->output
);
870 /* print some usefull debug info about different vout formats
872 msg_Dbg( p_vout
, "pic render sz %ix%i, of (%i,%i), vsz %ix%i, 4cc %4.4s, ar %i:%i, sar %i:%i, msk r0x%x g0x%x b0x%x",
873 p_vout
->fmt_render
.i_width
, p_vout
->fmt_render
.i_height
,
874 p_vout
->fmt_render
.i_x_offset
, p_vout
->fmt_render
.i_y_offset
,
875 p_vout
->fmt_render
.i_visible_width
,
876 p_vout
->fmt_render
.i_visible_height
,
877 (char*)&p_vout
->fmt_render
.i_chroma
,
878 i_aspect_x
, i_aspect_y
,
879 p_vout
->fmt_render
.i_sar_num
, p_vout
->fmt_render
.i_sar_den
,
880 p_vout
->fmt_render
.i_rmask
, p_vout
->fmt_render
.i_gmask
, p_vout
->fmt_render
.i_bmask
);
882 msg_Dbg( p_vout
, "pic in sz %ix%i, of (%i,%i), vsz %ix%i, 4cc %4.4s, ar %i:%i, sar %i:%i, msk r0x%x g0x%x b0x%x",
883 p_vout
->fmt_in
.i_width
, p_vout
->fmt_in
.i_height
,
884 p_vout
->fmt_in
.i_x_offset
, p_vout
->fmt_in
.i_y_offset
,
885 p_vout
->fmt_in
.i_visible_width
,
886 p_vout
->fmt_in
.i_visible_height
,
887 (char*)&p_vout
->fmt_in
.i_chroma
,
888 i_aspect_x
, i_aspect_y
,
889 p_vout
->fmt_in
.i_sar_num
, p_vout
->fmt_in
.i_sar_den
,
890 p_vout
->fmt_in
.i_rmask
, p_vout
->fmt_in
.i_gmask
, p_vout
->fmt_in
.i_bmask
);
892 msg_Dbg( p_vout
, "pic out sz %ix%i, of (%i,%i), vsz %ix%i, 4cc %4.4s, ar %i:%i, sar %i:%i, msk r0x%x g0x%x b0x%x",
893 p_vout
->fmt_out
.i_width
, p_vout
->fmt_out
.i_height
,
894 p_vout
->fmt_out
.i_x_offset
, p_vout
->fmt_out
.i_y_offset
,
895 p_vout
->fmt_out
.i_visible_width
,
896 p_vout
->fmt_out
.i_visible_height
,
897 (char*)&p_vout
->fmt_out
.i_chroma
,
898 i_aspect_x
, i_aspect_y
,
899 p_vout
->fmt_out
.i_sar_num
, p_vout
->fmt_out
.i_sar_den
,
900 p_vout
->fmt_out
.i_rmask
, p_vout
->fmt_out
.i_gmask
, p_vout
->fmt_out
.i_bmask
);
902 /* Check whether we managed to create direct buffers similar to
903 * the render buffers, ie same size and chroma */
904 if( ( p_vout
->output
.i_width
== p_vout
->render
.i_width
)
905 && ( p_vout
->output
.i_height
== p_vout
->render
.i_height
)
906 && ( ChromaIsEqual( &p_vout
->output
, &p_vout
->render
) ) )
908 /* Cool ! We have direct buffers, we can ask the decoder to
909 * directly decode into them ! Map the first render buffers to
910 * the first direct buffers, but keep the first direct buffer
911 * for memcpy operations */
912 p_vout
->p
->b_direct
= true;
914 for( i
= 1; i
< VOUT_MAX_PICTURES
; i
++ )
916 if( p_vout
->p_picture
[ i
].i_type
!= DIRECT_PICTURE
&&
917 I_RENDERPICTURES
>= VOUT_MIN_DIRECT_PICTURES
- 1 &&
918 p_vout
->p_picture
[ i
- 1 ].i_type
== DIRECT_PICTURE
)
920 /* We have enough direct buffers so there's no need to
921 * try to use system memory buffers. */
924 PP_RENDERPICTURE
[ I_RENDERPICTURES
] = &p_vout
->p_picture
[ i
];
928 msg_Dbg( p_vout
, "direct render, mapping "
929 "render pictures 0-%i to system pictures 1-%i",
930 VOUT_MAX_PICTURES
- 2, VOUT_MAX_PICTURES
- 1 );
934 /* Rats... Something is wrong here, we could not find an output
935 * plugin able to directly render what we decode. See if we can
936 * find a chroma plugin to do the conversion */
937 p_vout
->p
->b_direct
= false;
939 if( ChromaCreate( p_vout
) )
941 p_vout
->pf_end( p_vout
);
945 msg_Dbg( p_vout
, "indirect render, mapping "
946 "render pictures 0-%i to system pictures %i-%i",
947 VOUT_MAX_PICTURES
- 1, I_OUTPUTPICTURES
,
948 I_OUTPUTPICTURES
+ VOUT_MAX_PICTURES
- 1 );
950 /* Append render buffers after the direct buffers */
951 for( i
= I_OUTPUTPICTURES
; i
< 2 * VOUT_MAX_PICTURES
; i
++ )
953 PP_RENDERPICTURE
[ I_RENDERPICTURES
] = &p_vout
->p_picture
[ i
];
956 /* Check if we have enough render pictures */
957 if( I_RENDERPICTURES
== VOUT_MAX_PICTURES
)
965 /*****************************************************************************
966 * RunThread: video output thread
967 *****************************************************************************
968 * Video output thread. This function does only returns when the thread is
969 * terminated. It handles the pictures arriving in the video heap and the
970 * display device events.
971 *****************************************************************************/
972 static void* RunThread( void *p_this
)
974 vout_thread_t
*p_vout
= p_this
;
975 int i_idle_loops
= 0; /* loops without displaying a picture */
976 int i_picture_qtype_last
= QTYPE_NONE
;
979 vlc_mutex_lock( &p_vout
->change_lock
);
984 p_vout
->p_module
= module_need( p_vout
,
985 p_vout
->p
->psz_module_type
,
986 p_vout
->p
->psz_module_name
,
987 !strcmp(p_vout
->p
->psz_module_type
, "video filter") );
988 if( p_vout
->p_module
)
989 p_vout
->b_error
= InitThread( p_vout
);
991 p_vout
->b_error
= true;
993 /* signal the creation of the vout */
994 p_vout
->p
->b_ready
= true;
995 vlc_cond_signal( &p_vout
->p
->change_wait
);
997 if( p_vout
->b_error
)
1001 const bool b_drop_late
= var_CreateGetBool( p_vout
, "drop-late-frames" );
1004 * Main loop - it is not executed if an error occurred during
1007 while( !p_vout
->p
->b_done
&& !p_vout
->b_error
)
1009 /* Initialize loop variables */
1010 const mtime_t current_date
= mdate();
1011 picture_t
*p_picture
;
1012 picture_t
*p_filtered_picture
;
1013 mtime_t display_date
;
1014 picture_t
*p_directbuffer
;
1017 if( p_vout
->p
->b_title_show
&& p_vout
->p
->psz_title
)
1018 DisplayTitleOnOSD( p_vout
);
1020 vlc_mutex_lock( &p_vout
->picture_lock
);
1022 /* Look for the earliest picture but after the last displayed one */
1023 picture_t
*p_last
= p_vout
->p
->p_picture_displayed
;;
1026 for( i_index
= 0; i_index
< I_RENDERPICTURES
; i_index
++ )
1028 picture_t
*p_pic
= PP_RENDERPICTURE
[i_index
];
1030 if( p_pic
->i_status
!= READY_PICTURE
)
1033 if( p_vout
->p
->b_paused
&& p_last
&& p_last
->date
> 1 )
1036 if( p_last
&& p_pic
!= p_last
&& p_pic
->date
<= p_last
->date
)
1038 /* Drop old picture */
1039 vout_UsePictureLocked( p_vout
, p_pic
);
1041 else if( !p_vout
->p
->b_paused
&& !p_pic
->b_force
&& p_pic
!= p_last
&&
1042 p_pic
->date
< current_date
+ p_vout
->p
->render_time
&&
1045 /* Picture is late: it will be destroyed and the thread
1046 * will directly choose the next picture */
1047 vout_UsePictureLocked( p_vout
, p_pic
);
1048 vout_statistic_Update( &p_vout
->p
->statistic
, 0, 1 );
1050 msg_Warn( p_vout
, "late picture skipped (%"PRId64
" > %d)",
1051 current_date
- p_pic
->date
, - p_vout
->p
->render_time
);
1053 else if( ( !p_last
|| p_last
->date
< p_pic
->date
) &&
1054 ( p_picture
== NULL
|| p_pic
->date
< p_picture
->date
) )
1063 if( !p_vout
->p
->b_picture_empty
)
1065 p_vout
->p
->b_picture_empty
= true;
1066 vlc_cond_signal( &p_vout
->p
->picture_wait
);
1073 display_date
= p_picture
->date
;
1075 /* If we found better than the last picture, destroy it */
1076 if( p_last
&& p_picture
!= p_last
)
1078 vout_UsePictureLocked( p_vout
, p_last
);
1079 p_vout
->p
->p_picture_displayed
= p_last
= NULL
;
1082 /* Compute FPS rate */
1083 p_vout
->p
->p_fps_sample
[ p_vout
->p
->c_fps_samples
++ % VOUT_FPS_SAMPLES
] = display_date
;
1085 if( !p_vout
->p
->b_paused
&& display_date
> current_date
+ VOUT_DISPLAY_DELAY
)
1087 /* A picture is ready to be rendered, but its rendering date
1088 * is far from the current one so the thread will perform an
1089 * empty loop as if no picture were found. The picture state
1094 else if( p_picture
== p_last
)
1096 /* We are asked to repeat the previous picture, but we first
1097 * wait for a couple of idle loops */
1098 if( i_idle_loops
< 4 )
1105 /* We set the display date to something high, otherwise
1106 * we'll have lots of problems with late pictures */
1107 display_date
= current_date
+ p_vout
->p
->render_time
;
1110 else if( p_vout
->p
->b_paused
&& display_date
> current_date
+ VOUT_DISPLAY_DELAY
)
1112 display_date
= current_date
+ VOUT_DISPLAY_DELAY
;
1117 if( p_picture
->date
> 1 )
1119 p_vout
->p
->i_picture_displayed_date
= p_picture
->date
;
1120 if( p_picture
!= p_last
&& !p_vout
->p
->b_picture_displayed
)
1122 p_vout
->p
->b_picture_displayed
= true;
1123 vlc_cond_signal( &p_vout
->p
->picture_wait
);
1126 p_vout
->p
->p_picture_displayed
= p_picture
;
1131 const int i_postproc_type
= p_vout
->p
->i_picture_qtype
;
1132 const int i_postproc_state
= (p_vout
->p
->i_picture_qtype
!= QTYPE_NONE
) - (i_picture_qtype_last
!= QTYPE_NONE
);
1134 vlc_mutex_unlock( &p_vout
->picture_lock
);
1136 if( p_picture
== NULL
)
1139 p_filtered_picture
= NULL
;
1141 p_filtered_picture
= filter_chain_VideoFilter( p_vout
->p
->p_vf2_chain
,
1144 const bool b_snapshot
= vout_snapshot_IsRequested( &p_vout
->p
->snapshot
);
1147 * Check for subpictures to display
1149 mtime_t spu_render_time
;
1150 if( p_vout
->p
->b_paused
)
1151 spu_render_time
= p_vout
->p
->i_pause_date
;
1152 else if( p_picture
)
1153 spu_render_time
= p_picture
->date
> 1 ? p_picture
->date
: mdate();
1155 spu_render_time
= 0;
1157 subpicture_t
*p_subpic
= spu_SortSubpictures( p_vout
->p_spu
,
1163 vout_statistic_Update( &p_vout
->p
->statistic
, 1, 0 );
1164 p_directbuffer
= vout_RenderPicture( p_vout
,
1165 p_filtered_picture
, p_subpic
,
1169 * Take a snapshot if requested
1171 if( p_directbuffer
&& b_snapshot
)
1172 vout_snapshot_Set( &p_vout
->p
->snapshot
,
1173 &p_vout
->fmt_out
, p_directbuffer
);
1176 * Call the plugin-specific rendering method if there is one
1178 if( p_filtered_picture
!= NULL
&& p_directbuffer
!= NULL
&& p_vout
->pf_render
)
1180 /* Render the direct buffer returned by vout_RenderPicture */
1181 p_vout
->pf_render( p_vout
, p_directbuffer
);
1187 if( display_date
!= 0 && p_directbuffer
!= NULL
)
1189 mtime_t current_render_time
= mdate() - current_date
;
1190 /* if render time is very large we don't include it in the mean */
1191 if( current_render_time
< p_vout
->p
->render_time
+
1192 VOUT_DISPLAY_DELAY
)
1194 /* Store render time using a sliding mean weighting to
1195 * current value in a 3 to 1 ratio*/
1196 p_vout
->p
->render_time
*= 3;
1197 p_vout
->p
->render_time
+= current_render_time
;
1198 p_vout
->p
->render_time
>>= 2;
1201 msg_Dbg( p_vout
, "skipped big render time %d > %d", (int) current_render_time
,
1202 (int) (p_vout
->p
->render_time
+VOUT_DISPLAY_DELAY
) ) ;
1205 /* Give back change lock */
1206 vlc_mutex_unlock( &p_vout
->change_lock
);
1208 /* Sleep a while or until a given date */
1209 if( display_date
!= 0 )
1211 /* If there are *vout* filters in the chain, better give them the picture
1213 if( !p_vout
->p
->psz_filter_chain
|| !*p_vout
->p
->psz_filter_chain
)
1215 mwait( display_date
- VOUT_MWAIT_TOLERANCE
);
1220 /* Wait until a frame is being sent or a spurious wakeup (not a problem here) */
1221 vlc_mutex_lock( &p_vout
->picture_lock
);
1222 vlc_cond_timedwait( &p_vout
->p
->picture_wait
, &p_vout
->picture_lock
, current_date
+ VOUT_IDLE_SLEEP
);
1223 vlc_mutex_unlock( &p_vout
->picture_lock
);
1226 /* On awakening, take back lock and send immediately picture
1228 /* Note: p_vout->p->b_done could be true here and now */
1229 vlc_mutex_lock( &p_vout
->change_lock
);
1232 * Display the previously rendered picture
1234 if( p_filtered_picture
!= NULL
&& p_directbuffer
!= NULL
)
1236 /* Display the direct buffer returned by vout_RenderPicture */
1237 if( p_vout
->pf_display
)
1238 p_vout
->pf_display( p_vout
, p_directbuffer
);
1240 /* Tell the vout this was the last picture and that it does not
1241 * need to be forced anymore. */
1242 p_picture
->b_force
= false;
1245 /* Drop the filtered picture if created by video filters */
1246 if( p_filtered_picture
!= NULL
&& p_filtered_picture
!= p_picture
)
1248 vlc_mutex_lock( &p_vout
->picture_lock
);
1249 vout_UsePictureLocked( p_vout
, p_filtered_picture
);
1250 vlc_mutex_unlock( &p_vout
->picture_lock
);
1253 if( p_picture
!= NULL
)
1255 /* Reinitialize idle loop count */
1260 * Check events and manage thread
1262 if( p_vout
->pf_manage
&& p_vout
->pf_manage( p_vout
) )
1264 /* A fatal error occurred, and the thread must terminate
1265 * immediately, without displaying anything - setting b_error to 1
1266 * causes the immediate end of the main while() loop. */
1268 p_vout
->b_error
= 1;
1272 while( p_vout
->i_changes
& VOUT_ON_TOP_CHANGE
)
1274 p_vout
->i_changes
&= ~VOUT_ON_TOP_CHANGE
;
1275 vlc_mutex_unlock( &p_vout
->change_lock
);
1276 vout_Control( p_vout
, VOUT_SET_STAY_ON_TOP
, p_vout
->b_on_top
);
1277 vlc_mutex_lock( &p_vout
->change_lock
);
1280 if( p_vout
->i_changes
& VOUT_SIZE_CHANGE
)
1282 /* this must only happen when the vout plugin is incapable of
1283 * rescaling the picture itself. In this case we need to destroy
1284 * the current picture buffers and recreate new ones with the right
1288 p_vout
->i_changes
&= ~VOUT_SIZE_CHANGE
;
1290 assert( !p_vout
->p
->b_direct
);
1292 ChromaDestroy( p_vout
);
1294 vlc_mutex_lock( &p_vout
->picture_lock
);
1296 p_vout
->pf_end( p_vout
);
1298 p_vout
->p
->p_picture_displayed
= NULL
;
1299 for( i
= 0; i
< I_OUTPUTPICTURES
; i
++ )
1300 p_vout
->p_picture
[ i
].i_status
= FREE_PICTURE
;
1301 vlc_cond_signal( &p_vout
->p
->picture_wait
);
1303 I_OUTPUTPICTURES
= 0;
1305 if( p_vout
->pf_init( p_vout
) )
1307 msg_Err( p_vout
, "cannot resize display" );
1308 /* FIXME: pf_end will be called again in CleanThread()? */
1309 p_vout
->b_error
= 1;
1312 vlc_mutex_unlock( &p_vout
->picture_lock
);
1314 /* Need to reinitialise the chroma plugin. Since we might need
1315 * resizing too and it's not sure that we already had it,
1316 * recreate the chroma plugin chain from scratch. */
1318 if( ChromaCreate( p_vout
) )
1320 msg_Err( p_vout
, "WOW THIS SUCKS BIG TIME!!!!!" );
1321 p_vout
->b_error
= 1;
1323 if( p_vout
->b_error
)
1327 if( p_vout
->i_changes
& VOUT_PICTURE_BUFFERS_CHANGE
)
1329 /* This happens when the picture buffers need to be recreated.
1330 * This is useful on multimonitor displays for instance.
1332 * Warning: This only works when the vout creates only 1 picture
1334 p_vout
->i_changes
&= ~VOUT_PICTURE_BUFFERS_CHANGE
;
1336 if( !p_vout
->p
->b_direct
)
1337 ChromaDestroy( p_vout
);
1339 vlc_mutex_lock( &p_vout
->picture_lock
);
1341 p_vout
->pf_end( p_vout
);
1343 I_OUTPUTPICTURES
= I_RENDERPICTURES
= 0;
1345 p_vout
->b_error
= InitThread( p_vout
);
1346 if( p_vout
->b_error
)
1347 msg_Err( p_vout
, "InitThread after VOUT_PICTURE_BUFFERS_CHANGE failed" );
1349 vlc_cond_signal( &p_vout
->p
->picture_wait
);
1350 vlc_mutex_unlock( &p_vout
->picture_lock
);
1352 if( p_vout
->b_error
)
1356 /* Post processing */
1357 if( i_postproc_state
== 1 )
1358 PostProcessEnable( p_vout
);
1359 else if( i_postproc_state
== -1 )
1360 PostProcessDisable( p_vout
);
1361 if( i_postproc_state
!= 0 )
1362 i_picture_qtype_last
= i_postproc_type
;
1364 /* Check for "video filter2" changes */
1365 vlc_mutex_lock( &p_vout
->p
->vfilter_lock
);
1366 if( p_vout
->p
->psz_vf2
)
1370 es_format_Init( &fmt
, VIDEO_ES
, p_vout
->fmt_render
.i_chroma
);
1371 fmt
.video
= p_vout
->fmt_render
;
1372 filter_chain_Reset( p_vout
->p
->p_vf2_chain
, &fmt
, &fmt
);
1374 if( filter_chain_AppendFromString( p_vout
->p
->p_vf2_chain
,
1375 p_vout
->p
->psz_vf2
) < 0 )
1376 msg_Err( p_vout
, "Video filter chain creation failed" );
1378 free( p_vout
->p
->psz_vf2
);
1379 p_vout
->p
->psz_vf2
= NULL
;
1381 if( i_picture_qtype_last
!= QTYPE_NONE
)
1382 PostProcessSetFilterQuality( p_vout
);
1384 vlc_mutex_unlock( &p_vout
->p
->vfilter_lock
);
1388 * Error loop - wait until the thread destruction is requested
1390 if( p_vout
->b_error
)
1391 ErrorThread( p_vout
);
1394 CleanThread( p_vout
);
1398 EndThread( p_vout
);
1399 vlc_mutex_unlock( &p_vout
->change_lock
);
1401 if( p_vout
->p_module
)
1402 module_unneed( p_vout
, p_vout
->p_module
);
1403 p_vout
->p_module
= NULL
;
1408 /*****************************************************************************
1409 * ErrorThread: RunThread() error loop
1410 *****************************************************************************
1411 * This function is called when an error occurred during thread main's loop.
1412 * The thread can still receive feed, but must be ready to terminate as soon
1414 *****************************************************************************/
1415 static void ErrorThread( vout_thread_t
*p_vout
)
1417 /* Wait until a `close' order */
1418 while( !p_vout
->p
->b_done
)
1419 vlc_cond_wait( &p_vout
->p
->change_wait
, &p_vout
->change_lock
);
1422 /*****************************************************************************
1423 * CleanThread: clean up after InitThread
1424 *****************************************************************************
1425 * This function is called after a sucessful
1426 * initialization. It frees all resources allocated by InitThread.
1427 * XXX You have to enter it with change_lock taken.
1428 *****************************************************************************/
1429 static void CleanThread( vout_thread_t
*p_vout
)
1431 int i_index
; /* index in heap */
1433 if( !p_vout
->p
->b_direct
)
1434 ChromaDestroy( p_vout
);
1436 /* Destroy all remaining pictures */
1437 for( i_index
= 0; i_index
< 2 * VOUT_MAX_PICTURES
+ 1; i_index
++ )
1439 if ( p_vout
->p_picture
[i_index
].i_type
== MEMORY_PICTURE
)
1441 free( p_vout
->p_picture
[i_index
].p_data_orig
);
1445 /* Destroy translation tables */
1446 if( !p_vout
->b_error
)
1447 p_vout
->pf_end( p_vout
);
1450 /*****************************************************************************
1451 * EndThread: thread destruction
1452 *****************************************************************************
1453 * This function is called when the thread ends.
1454 * It frees all resources not allocated by InitThread.
1455 * XXX You have to enter it with change_lock taken.
1456 *****************************************************************************/
1457 static void EndThread( vout_thread_t
*p_vout
)
1461 struct tms cpu_usage
;
1462 times( &cpu_usage
);
1464 msg_Dbg( p_vout
, "cpu usage (user: %d, system: %d)",
1465 cpu_usage
.tms_utime
, cpu_usage
.tms_stime
);
1469 /* FIXME does that function *really* need to be called inside the thread ? */
1471 /* Detach subpicture unit from both input and vout */
1472 spu_Attach( p_vout
->p_spu
, VLC_OBJECT(p_vout
), false );
1473 vlc_object_detach( p_vout
->p_spu
);
1475 /* Destroy the video filters2 */
1476 filter_chain_Delete( p_vout
->p
->p_vf2_chain
);
1479 /* Thread helpers */
1480 static picture_t
*ChromaGetPicture( filter_t
*p_filter
)
1482 picture_t
*p_pic
= (picture_t
*)p_filter
->p_owner
;
1483 p_filter
->p_owner
= NULL
;
1487 static int ChromaCreate( vout_thread_t
*p_vout
)
1489 static const char typename
[] = "chroma";
1492 /* Choose the best module */
1493 p_chroma
= p_vout
->p
->p_chroma
=
1494 vlc_custom_create( p_vout
, sizeof(filter_t
), VLC_OBJECT_GENERIC
,
1497 vlc_object_attach( p_chroma
, p_vout
);
1499 /* TODO: Set the fmt_in and fmt_out stuff here */
1500 p_chroma
->fmt_in
.video
= p_vout
->fmt_render
;
1501 p_chroma
->fmt_out
.video
= p_vout
->fmt_out
;
1502 VideoFormatImportRgb( &p_chroma
->fmt_in
.video
, &p_vout
->render
);
1503 VideoFormatImportRgb( &p_chroma
->fmt_out
.video
, &p_vout
->output
);
1505 p_chroma
->p_module
= module_need( p_chroma
, "video filter2", NULL
, false );
1507 if( p_chroma
->p_module
== NULL
)
1509 msg_Err( p_vout
, "no chroma module for %4.4s to %4.4s i=%dx%d o=%dx%d",
1510 (char*)&p_vout
->render
.i_chroma
,
1511 (char*)&p_vout
->output
.i_chroma
,
1512 p_chroma
->fmt_in
.video
.i_width
, p_chroma
->fmt_in
.video
.i_height
,
1513 p_chroma
->fmt_out
.video
.i_width
, p_chroma
->fmt_out
.video
.i_height
1516 vlc_object_release( p_vout
->p
->p_chroma
);
1517 p_vout
->p
->p_chroma
= NULL
;
1519 return VLC_EGENERIC
;
1521 p_chroma
->pf_vout_buffer_new
= ChromaGetPicture
;
1525 static void ChromaDestroy( vout_thread_t
*p_vout
)
1527 assert( !p_vout
->p
->b_direct
);
1529 if( !p_vout
->p
->p_chroma
)
1532 module_unneed( p_vout
->p
->p_chroma
, p_vout
->p
->p_chroma
->p_module
);
1533 vlc_object_release( p_vout
->p
->p_chroma
);
1534 p_vout
->p
->p_chroma
= NULL
;
1537 /* following functions are local */
1538 static void AspectRatio( int i_aspect
, int *i_aspect_x
, int *i_aspect_y
)
1540 const int i_pgcd
= i_aspect
? GCD( i_aspect
, VOUT_ASPECT_FACTOR
) : 1;
1541 *i_aspect_x
= i_aspect
/ i_pgcd
;
1542 *i_aspect_y
= VOUT_ASPECT_FACTOR
/ i_pgcd
;
1546 * This function copies all RGB informations from a picture_heap_t into
1549 static void VideoFormatImportRgb( video_format_t
*p_fmt
, const picture_heap_t
*p_heap
)
1551 p_fmt
->i_rmask
= p_heap
->i_rmask
;
1552 p_fmt
->i_gmask
= p_heap
->i_gmask
;
1553 p_fmt
->i_bmask
= p_heap
->i_bmask
;
1554 p_fmt
->i_rrshift
= p_heap
->i_rrshift
;
1555 p_fmt
->i_lrshift
= p_heap
->i_lrshift
;
1556 p_fmt
->i_rgshift
= p_heap
->i_rgshift
;
1557 p_fmt
->i_lgshift
= p_heap
->i_lgshift
;
1558 p_fmt
->i_rbshift
= p_heap
->i_rbshift
;
1559 p_fmt
->i_lbshift
= p_heap
->i_lbshift
;
1563 * This funtion copes all RGB informations from a video_format_t into
1566 static void VideoFormatExportRgb( const video_format_t
*p_fmt
, picture_heap_t
*p_heap
)
1568 p_heap
->i_rmask
= p_fmt
->i_rmask
;
1569 p_heap
->i_gmask
= p_fmt
->i_gmask
;
1570 p_heap
->i_bmask
= p_fmt
->i_bmask
;
1571 p_heap
->i_rrshift
= p_fmt
->i_rrshift
;
1572 p_heap
->i_lrshift
= p_fmt
->i_lrshift
;
1573 p_heap
->i_rgshift
= p_fmt
->i_rgshift
;
1574 p_heap
->i_lgshift
= p_fmt
->i_lgshift
;
1575 p_heap
->i_rbshift
= p_fmt
->i_rbshift
;
1576 p_heap
->i_lbshift
= p_fmt
->i_lbshift
;
1580 * This function computes rgb shifts from masks
1582 static void PictureHeapFixRgb( picture_heap_t
*p_heap
)
1587 fmt
.i_chroma
= p_heap
->i_chroma
;
1588 VideoFormatImportRgb( &fmt
, p_heap
);
1591 video_format_FixRgb( &fmt
);
1593 VideoFormatExportRgb( &fmt
, p_heap
);
1596 /*****************************************************************************
1597 * object variables callbacks: a bunch of object variables are used by the
1598 * interfaces to interact with the vout.
1599 *****************************************************************************/
1600 static int FilterCallback( vlc_object_t
*p_this
, char const *psz_cmd
,
1601 vlc_value_t oldval
, vlc_value_t newval
, void *p_data
)
1603 vout_thread_t
*p_vout
= (vout_thread_t
*)p_this
;
1604 input_thread_t
*p_input
;
1605 (void)psz_cmd
; (void)oldval
; (void)p_data
;
1607 p_input
= (input_thread_t
*)vlc_object_find( p_this
, VLC_OBJECT_INPUT
,
1611 msg_Err( p_vout
, "Input not found" );
1612 return VLC_EGENERIC
;
1615 var_SetBool( p_vout
, "intf-change", true );
1617 /* Modify input as well because the vout might have to be restarted */
1618 var_Create( p_input
, "vout-filter", VLC_VAR_STRING
);
1619 var_SetString( p_input
, "vout-filter", newval
.psz_string
);
1621 /* Now restart current video stream */
1622 input_Control( p_input
, INPUT_RESTART_ES
, -VIDEO_ES
);
1623 vlc_object_release( p_input
);
1628 /*****************************************************************************
1629 * Video Filter2 stuff
1630 *****************************************************************************/
1631 static int VideoFilter2Callback( vlc_object_t
*p_this
, char const *psz_cmd
,
1632 vlc_value_t oldval
, vlc_value_t newval
, void *p_data
)
1634 vout_thread_t
*p_vout
= (vout_thread_t
*)p_this
;
1635 (void)psz_cmd
; (void)oldval
; (void)p_data
;
1637 vlc_mutex_lock( &p_vout
->p
->vfilter_lock
);
1638 p_vout
->p
->psz_vf2
= strdup( newval
.psz_string
);
1639 vlc_mutex_unlock( &p_vout
->p
->vfilter_lock
);
1644 /*****************************************************************************
1646 *****************************************************************************/
1647 static bool PostProcessIsPresent( const char *psz_filter
)
1649 const char *psz_pp
= "postproc";
1650 const size_t i_pp
= strlen(psz_pp
);
1651 return psz_filter
&&
1652 !strncmp( psz_filter
, psz_pp
, strlen(psz_pp
) ) &&
1653 ( psz_filter
[i_pp
] == '\0' || psz_filter
[i_pp
] == ':' );
1656 static int PostProcessCallback( vlc_object_t
*p_this
, char const *psz_cmd
,
1657 vlc_value_t oldval
, vlc_value_t newval
, void *p_data
)
1659 vout_thread_t
*p_vout
= (vout_thread_t
*)p_this
;
1660 VLC_UNUSED(psz_cmd
); VLC_UNUSED(oldval
); VLC_UNUSED(p_data
);
1662 static const char *psz_pp
= "postproc";
1664 char *psz_vf2
= var_GetString( p_vout
, "video-filter" );
1666 if( newval
.i_int
<= 0 )
1668 if( PostProcessIsPresent( psz_vf2
) )
1670 strcpy( psz_vf2
, &psz_vf2
[strlen(psz_pp
)] );
1671 if( *psz_vf2
== ':' )
1672 strcpy( psz_vf2
, &psz_vf2
[1] );
1677 if( !PostProcessIsPresent( psz_vf2
) )
1681 char *psz_tmp
= psz_vf2
;
1682 if( asprintf( &psz_vf2
, "%s:%s", psz_pp
, psz_tmp
) < 0 )
1689 psz_vf2
= strdup( psz_pp
);
1695 var_SetString( p_vout
, "video-filter", psz_vf2
);
1701 static void PostProcessEnable( vout_thread_t
*p_vout
)
1704 msg_Dbg( p_vout
, "Post-processing available" );
1705 var_Create( p_vout
, "postprocess", VLC_VAR_INTEGER
| VLC_VAR_HASCHOICE
);
1706 text
.psz_string
= _("Post processing");
1707 var_Change( p_vout
, "postprocess", VLC_VAR_SETTEXT
, &text
, NULL
);
1709 for( int i
= 0; i
<= 6; i
++ )
1716 snprintf( psz_text
, sizeof(psz_text
), "%d", i
);
1718 text
.psz_string
= _("Disable");
1720 text
.psz_string
= psz_text
;
1721 var_Change( p_vout
, "postprocess", VLC_VAR_ADDCHOICE
, &val
, &text
);
1723 var_AddCallback( p_vout
, "postprocess", PostProcessCallback
, NULL
);
1726 char *psz_filter
= var_GetNonEmptyString( p_vout
, "video-filter" );
1727 int i_postproc_q
= 0;
1728 if( PostProcessIsPresent( psz_filter
) )
1729 i_postproc_q
= var_CreateGetInteger( p_vout
, "postproc-q" );
1731 var_SetInteger( p_vout
, "postprocess", i_postproc_q
);
1735 static void PostProcessDisable( vout_thread_t
*p_vout
)
1737 msg_Dbg( p_vout
, "Post-processing no more available" );
1738 var_Destroy( p_vout
, "postprocess" );
1740 static void PostProcessSetFilterQuality( vout_thread_t
*p_vout
)
1742 vlc_object_t
*p_pp
= vlc_object_find_name( p_vout
, "postproc", FIND_CHILD
);
1746 var_SetInteger( p_pp
, "postproc-q", var_GetInteger( p_vout
, "postprocess" ) );
1747 vlc_object_release( p_pp
);
1751 static void DisplayTitleOnOSD( vout_thread_t
*p_vout
)
1753 const mtime_t i_start
= mdate();
1754 const mtime_t i_stop
= i_start
+ INT64_C(1000) * p_vout
->p
->i_title_timeout
;
1756 if( i_stop
<= i_start
)
1759 vlc_assert_locked( &p_vout
->change_lock
);
1761 vout_ShowTextAbsolute( p_vout
, DEFAULT_CHAN
,
1762 p_vout
->p
->psz_title
, NULL
,
1763 p_vout
->p
->i_title_position
,
1764 30 + p_vout
->fmt_in
.i_width
1765 - p_vout
->fmt_in
.i_visible_width
1766 - p_vout
->fmt_in
.i_x_offset
,
1767 20 + p_vout
->fmt_in
.i_y_offset
,
1770 free( p_vout
->p
->psz_title
);
1772 p_vout
->p
->psz_title
= NULL
;
1775 /*****************************************************************************
1777 *****************************************************************************/
1780 const char *psz_mode
;
1782 } deinterlace_mode_t
;
1785 * You can use the non vout filter if and only if the video properties stay the
1786 * same (width/height/chroma/fps), at least for now.
1788 static const deinterlace_mode_t p_deinterlace_mode
[] = {
1790 { "discard", true },
1797 { "yadif2x", true },
1801 static char *FilterFind( char *psz_filter_base
, const char *psz_module
)
1803 const size_t i_module
= strlen( psz_module
);
1804 const char *psz_filter
= psz_filter_base
;
1806 if( !psz_filter
|| i_module
<= 0 )
1811 char *psz_find
= strstr( psz_filter
, psz_module
);
1814 if( psz_find
[i_module
] == '\0' || psz_find
[i_module
] == ':' )
1816 psz_filter
= &psz_find
[i_module
];
1820 static bool DeinterlaceIsPresent( vout_thread_t
*p_vout
, bool b_vout_filter
)
1822 char *psz_filter
= var_GetNonEmptyString( p_vout
, b_vout_filter
? "vout-filter" : "video-filter" );
1824 bool b_found
= FilterFind( psz_filter
, "deinterlace" ) != NULL
;
1831 static void DeinterlaceRemove( vout_thread_t
*p_vout
, bool b_vout_filter
)
1833 const char *psz_variable
= b_vout_filter
? "vout-filter" : "video-filter";
1834 char *psz_filter
= var_GetNonEmptyString( p_vout
, psz_variable
);
1836 char *psz
= FilterFind( psz_filter
, "deinterlace" );
1844 strcpy( &psz
[0], &psz
[strlen("deinterlace")] );
1846 strcpy( &psz
[0], &psz
[1] );
1848 var_SetString( p_vout
, psz_variable
, psz_filter
);
1851 static void DeinterlaceAdd( vout_thread_t
*p_vout
, bool b_vout_filter
)
1853 const char *psz_variable
= b_vout_filter
? "vout-filter" : "video-filter";
1855 char *psz_filter
= var_GetNonEmptyString( p_vout
, psz_variable
);
1857 if( FilterFind( psz_filter
, "deinterlace" ) )
1866 char *psz_tmp
= psz_filter
;
1867 if( asprintf( &psz_filter
, "%s:%s", psz_tmp
, "deinterlace" ) < 0 )
1868 psz_filter
= psz_tmp
;
1874 psz_filter
= strdup( "deinterlace" );
1879 var_SetString( p_vout
, psz_variable
, psz_filter
);
1884 static int DeinterlaceCallback( vlc_object_t
*p_this
, char const *psz_cmd
,
1885 vlc_value_t oldval
, vlc_value_t newval
, void *p_data
)
1887 vout_thread_t
*p_vout
= (vout_thread_t
*)p_this
;
1890 const deinterlace_mode_t
*p_mode
;
1891 for( p_mode
= &p_deinterlace_mode
[0]; p_mode
->psz_mode
; p_mode
++ )
1893 if( !strcmp( p_mode
->psz_mode
,
1894 newval
.psz_string
? newval
.psz_string
: "" ) )
1897 if( !p_mode
->psz_mode
)
1899 msg_Err( p_this
, "Invalid value (%s) ignored", newval
.psz_string
);
1900 return VLC_EGENERIC
;
1903 /* We have to set input variable to ensure restart support
1904 * XXX it is only needed because of vout-filter but must be done
1905 * for non video filter anyway */
1906 input_thread_t
*p_input
= (input_thread_t
*)vlc_object_find( p_this
, VLC_OBJECT_INPUT
, FIND_PARENT
);
1909 var_Create( p_input
, "deinterlace", VLC_VAR_STRING
);
1910 var_SetString( p_input
, "deinterlace", *p_mode
->psz_mode
? p_mode
->psz_mode
: "disable" );
1912 var_Create( p_input
, "deinterlace-mode", VLC_VAR_STRING
);
1913 var_SetString( p_input
, "deinterlace-mode", p_mode
->psz_mode
);
1915 var_Create( p_input
, "sout-deinterlace-mode", VLC_VAR_STRING
);
1916 var_SetString( p_input
, "sout-deinterlace-mode", p_mode
->psz_mode
);
1918 vlc_object_release( p_input
);
1923 if( p_mode
->b_vout_filter
)
1925 psz_old
= var_CreateGetString( p_vout
, "deinterlace-mode" );
1929 psz_old
= var_CreateGetString( p_vout
, "sout-deinterlace-mode" );
1930 var_SetString( p_vout
, "sout-deinterlace-mode", p_mode
->psz_mode
);
1934 if( !strcmp( p_mode
->psz_mode
, "" ) )
1936 DeinterlaceRemove( p_vout
, false );
1937 DeinterlaceRemove( p_vout
, true );
1939 else if( !DeinterlaceIsPresent( p_vout
, p_mode
->b_vout_filter
) )
1941 DeinterlaceRemove( p_vout
, !p_mode
->b_vout_filter
);
1942 DeinterlaceAdd( p_vout
, p_mode
->b_vout_filter
);
1946 DeinterlaceRemove( p_vout
, !p_mode
->b_vout_filter
);
1947 if( psz_old
&& strcmp( psz_old
, p_mode
->psz_mode
) )
1948 var_TriggerCallback( p_vout
, p_mode
->b_vout_filter
? "vout-filter" : "video-filter" );
1952 (void)psz_cmd
; (void) oldval
; (void) p_data
;
1956 static void DeinterlaceEnable( vout_thread_t
*p_vout
)
1958 vlc_value_t val
, text
;
1960 if( !p_vout
->p
->b_first_vout
)
1963 msg_Dbg( p_vout
, "Deinterlacing available" );
1965 /* Create the configuration variable */
1966 var_Create( p_vout
, "deinterlace", VLC_VAR_STRING
| VLC_VAR_DOINHERIT
| VLC_VAR_HASCHOICE
);
1967 char *psz_deinterlace
= var_GetNonEmptyString( p_vout
, "deinterlace" );
1969 text
.psz_string
= _("Deinterlace");
1970 var_Change( p_vout
, "deinterlace", VLC_VAR_SETTEXT
, &text
, NULL
);
1972 const module_config_t
*p_opt
= config_FindConfig( VLC_OBJECT(p_vout
), "deinterlace" );
1973 var_Change( p_vout
, "deinterlace", VLC_VAR_CLEARCHOICES
, NULL
, NULL
);
1974 for( int i
= 0; p_opt
&& i
< p_opt
->i_list
; i
++ )
1976 val
.psz_string
= p_opt
->ppsz_list
[i
];
1977 text
.psz_string
= (char*)vlc_gettext(p_opt
->ppsz_list_text
[i
]);
1978 var_Change( p_vout
, "deinterlace", VLC_VAR_ADDCHOICE
, &val
, &text
);
1980 var_AddCallback( p_vout
, "deinterlace", DeinterlaceCallback
, NULL
);
1983 char *psz_mode
= psz_deinterlace
;
1984 if( psz_mode
&& !strcmp( psz_mode
, "disable" ) )
1987 psz_mode
= strdup( "" );
1991 /* Get the initial value from filters if present */
1992 if( DeinterlaceIsPresent( p_vout
, true ) )
1993 psz_mode
= var_CreateGetNonEmptyString( p_vout
, "deinterlace-mode" );
1994 else if( DeinterlaceIsPresent( p_vout
, false ) )
1995 psz_mode
= var_CreateGetNonEmptyString( p_vout
, "sout-deinterlace-mode" );
1997 var_SetString( p_vout
, "deinterlace", psz_mode
? psz_mode
: "" );