?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
chromecast: demux: add deinit()
[vlc.git] / modules / stream_out / chromecast / chromecast_demux.cpp
blob472c47ca35e393e00b6b8fa50d489ba487c98518
1 /*****************************************************************************
2 * chromecast_demux.cpp: Chromecast demux filter module for vlc
3 *****************************************************************************
4 * Copyright © 2015-2016 VideoLAN
5 *
6 * Authors: Steve Lhomme <robux4@videolabs.io>
7 *
8 * This program is free software; you can redistribute it and/or modify it
9 * under the terms of the GNU Lesser General Public License as published by
10 * the Free Software Foundation; either version 2.1 of the License, or
11 * (at your option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU Lesser General Public License for more details.
17 *
18 * You should have received a copy of the GNU Lesser General Public License
19 * along with this program; if not, write to the Free Software Foundation,
20 * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
21 *****************************************************************************/
22
23 /*****************************************************************************
24 * Preamble
25 *****************************************************************************/
26
27 #ifdef HAVE_CONFIG_H
28 # include "config.h"
29 #endif
30
31 #include <vlc_common.h>
32 #include <vlc_plugin.h>
33 #include <vlc_demux.h>
34
35 #include "chromecast_common.h"
36
37 #include <assert.h>
38 #include <new>
39
40 static void on_paused_changed_cb(void *data, bool paused);
41
42 struct demux_cc
43 {
44 demux_cc(demux_t * const demux, chromecast_common * const renderer)
45 :p_demux(demux)
46 ,p_renderer(renderer)
47 ,m_enabled( true )
48 ,m_pause_date( VLC_TS_INVALID )
49 ,m_pause_delay( VLC_TS_INVALID )
50 {
51 init();
52 }
53
54 void init()
55 {
56 resetDemuxEof();
57
58 vlc_meta_t *p_meta = vlc_meta_New();
59 if( likely(p_meta != NULL) )
60 {
61 input_item_t *p_item = p_demux->p_next->p_input ?
62 input_GetItem( p_demux->p_next->p_input ) : NULL;
63 if( p_item )
64 {
65 /* Favor Meta from the input item of the input_thread since
66 * it's pre-processed by the meta fetcher */
67 for( int i = 0; i < VLC_META_TYPE_COUNT; ++i )
68 {
69 char *psz_meta = input_item_GetMeta( p_item, (vlc_meta_type_t)i );
70 if( psz_meta )
71 {
72 vlc_meta_Set( p_meta, (vlc_meta_type_t)i, psz_meta );
73 free( psz_meta );
74 }
75 }
76 if( vlc_meta_Get( p_meta, vlc_meta_Title ) == NULL )
77 {
78 char *psz_meta = input_item_GetName( p_item );
79 if( psz_meta )
80 {
81 vlc_meta_Set( p_meta, vlc_meta_Title, psz_meta );
82 free( psz_meta );
83 }
84 }
85 p_renderer->pf_set_meta( p_renderer->p_opaque, p_meta );
86 }
87 else if (demux_Control( p_demux->p_next, DEMUX_GET_META, p_meta) == VLC_SUCCESS)
88 p_renderer->pf_set_meta( p_renderer->p_opaque, p_meta );
89 else
90 vlc_meta_Delete( p_meta );
91 }
92
93 if (demux_Control( p_demux->p_next, DEMUX_CAN_SEEK, &m_can_seek ) != VLC_SUCCESS)
94 m_can_seek = false;
95 if (demux_Control( p_demux->p_next, DEMUX_GET_LENGTH, &m_length ) != VLC_SUCCESS)
96 m_length = -1;
97
98 int i_current_title;
99 if( demux_Control( p_demux->p_next, DEMUX_GET_TITLE,
100 &i_current_title ) == VLC_SUCCESS )
101 {
102 input_title_t** pp_titles;
103 int i_nb_titles, i_title_offset, i_chapter_offset;
104 if( demux_Control( p_demux->p_next, DEMUX_GET_TITLE_INFO, &pp_titles,
105 &i_nb_titles, &i_title_offset,
106 &i_chapter_offset ) == VLC_SUCCESS )
107 {
108 int64_t i_longest_duration = 0;
109 int i_longest_title = 0;
110 bool b_is_interactive = false;
111 for( int i = 0 ; i < i_nb_titles; ++i )
112 {
113 if( pp_titles[i]->i_length > i_longest_duration )
114 {
115 i_longest_duration = pp_titles[i]->i_length;
116 i_longest_title = i;
117 }
118 if( i_current_title == i &&
119 pp_titles[i]->i_flags & INPUT_TITLE_INTERACTIVE )
120 {
121 b_is_interactive = true;
122 }
123 vlc_input_title_Delete( pp_titles[i] );
124 }
125 free( pp_titles );
126
127 if( b_is_interactive == true )
128 {
129 demux_Control( p_demux->p_next, DEMUX_SET_TITLE,
130 i_longest_title );
131 }
132 }
133 }
134
135 es_out_Control( p_demux->p_next->out, ES_OUT_RESET_PCR );
136
137 p_renderer->pf_set_on_paused_changed_cb(p_renderer->p_opaque,
138 on_paused_changed_cb, p_demux);
139
140 resetTimes();
141 }
142
143 void deinit()
144 {
145 assert(p_renderer);
146 p_renderer->pf_set_meta( p_renderer->p_opaque, NULL );
147 p_renderer->pf_set_on_paused_changed_cb( p_renderer->p_opaque,
148 NULL, NULL );
149 }
150
151 void resetTimes()
152 {
153 m_start_time = m_last_time = -1;
154 m_start_pos = m_last_pos = -1.0f;
155 }
156
157 void initTimes()
158 {
159 if( demux_Control( p_demux->p_next, DEMUX_GET_TIME, &m_start_time ) != VLC_SUCCESS )
160 m_start_time = -1;
161
162 if( demux_Control( p_demux->p_next, DEMUX_GET_POSITION, &m_start_pos ) != VLC_SUCCESS )
163 m_start_pos = -1.0f;
164
165 m_last_time = m_start_time;
166 m_last_pos = m_start_pos;
167 }
168
169 ~demux_cc()
170 {
171 if( p_renderer )
172 deinit();
173 }
174
175 void resetDemuxEof()
176 {
177 m_demux_eof = false;
178 p_renderer->pf_send_input_event( p_renderer->p_opaque, CC_INPUT_EVENT_EOF,
179 cc_input_arg { false } );
180 }
181
182 void setPauseState(bool paused, mtime_t delay)
183 {
184 p_renderer->pf_set_pause_state( p_renderer->p_opaque, paused, delay );
185 }
186
187 mtime_t getCCTime()
188 {
189 mtime_t system, delay;
190 if( es_out_ControlGetPcrSystem( p_demux->p_next->out, &system, &delay ) )
191 return VLC_TS_INVALID;
192
193 mtime_t cc_time = p_renderer->pf_get_time( p_renderer->p_opaque );
194 if( cc_time != VLC_TS_INVALID )
195 return cc_time - system + m_pause_delay;
196 return VLC_TS_INVALID;
197 }
198
199 mtime_t getTime()
200 {
201 if( m_start_time < 0 )
202 return -1;
203
204 int64_t time = m_start_time;
205 mtime_t cc_time = getCCTime();
206
207 if( cc_time != VLC_TS_INVALID )
208 time += cc_time;
209 m_last_time = time;
210 return time;
211 }
212
213 double getPosition()
214 {
215 if( m_length >= 0 && m_start_pos >= 0 )
216 {
217 m_last_pos = ( getCCTime() / double( m_length ) ) + m_start_pos;
218 return m_last_pos;
219 }
220 else
221 return -1;
222 }
223
224 void seekBack( mtime_t time, double pos )
225 {
226 es_out_Control( p_demux->p_next->out, ES_OUT_RESET_PCR );
227
228 if( m_can_seek )
229 {
230 int ret = VLC_EGENERIC;
231 if( time >= 0 )
232 ret = demux_Control( p_demux->p_next, DEMUX_SET_TIME, time, false );
233
234 if( ret != VLC_SUCCESS && pos >= 0 )
235 demux_Control( p_demux->p_next, DEMUX_SET_POSITION, pos, false );
236 }
237 }
238
239 int Demux()
240 {
241 if ( !m_enabled )
242 return demux_Demux( p_demux->p_next );
243
244 /* The CC sout is not pacing, so we pace here */
245 int pace = p_renderer->pf_pace( p_renderer->p_opaque );
246 switch (pace)
247 {
248 case CC_PACE_ERR:
249 return VLC_DEMUXER_EGENERIC;
250 case CC_PACE_ERR_RETRY:
251 {
252 /* Seek back to started position */
253 seekBack(m_start_time, m_start_pos);
254
255 resetDemuxEof();
256 p_renderer->pf_send_input_event( p_renderer->p_opaque,
257 CC_INPUT_EVENT_RETRY,
258 cc_input_arg{false} );
259 break;
260 }
261 case CC_PACE_OK_WAIT:
262 /* Yeld: return to let the input thread doing controls */
263 return VLC_DEMUXER_SUCCESS;
264 case CC_PACE_OK:
265 case CC_PACE_OK_ENDED:
266 break;
267 default:
268 vlc_assert_unreachable();
269 }
270
271 int ret = VLC_DEMUXER_SUCCESS;
272 if( !m_demux_eof )
273 {
274 ret = demux_Demux( p_demux->p_next );
275 if( ret != VLC_DEMUXER_EGENERIC
276 && ( m_start_time < 0 || m_start_pos < 0.0f ) )
277 initTimes();
278 if( ret == VLC_DEMUXER_EOF )
279 m_demux_eof = true;
280 }
281
282 if( m_demux_eof )
283 {
284 /* Signal EOF to the sout when the es_out is empty (so when the
285 * DecoderThread fifo are empty) */
286 bool b_empty;
287 es_out_Control( p_demux->p_next->out, ES_OUT_GET_EMPTY, &b_empty );
288 if( b_empty )
289 p_renderer->pf_send_input_event( p_renderer->p_opaque,
290 CC_INPUT_EVENT_EOF,
291 cc_input_arg{ true } );
292
293 /* Don't return EOF until the chromecast is not EOF. This allows
294 * this demux filter to have more controls over the sout. Indeed,
295 * we still can seek or change tracks when the input is EOF and we
296 * should continue to handle CC errors. */
297 ret = pace == CC_PACE_OK ? VLC_DEMUXER_SUCCESS : VLC_DEMUXER_EOF;
298 }
299
300 return ret;
301 }
302
303 int Control( demux_t *p_demux_filter, int i_query, va_list args )
304 {
305 if( !m_enabled && i_query != DEMUX_FILTER_ENABLE )
306 return demux_vaControl( p_demux_filter->p_next, i_query, args );
307
308 switch (i_query)
309 {
310 case DEMUX_GET_POSITION:
311 {
312 double pos = getPosition();
313 if( pos >= 0 )
314 {
315 *va_arg( args, double * ) = pos;
316 return VLC_SUCCESS;
317 }
318 return VLC_EGENERIC;
319 }
320 case DEMUX_GET_TIME:
321 {
322 mtime_t time = getTime();
323 if( time >= 0 )
324 {
325 *va_arg(args, int64_t *) = time;
326 return VLC_SUCCESS;
327 }
328 return VLC_EGENERIC;
329 }
330 case DEMUX_GET_LENGTH:
331 {
332 int ret;
333 va_list ap;
334
335 va_copy( ap, args );
336 ret = demux_vaControl( p_demux_filter->p_next, i_query, args );
337 if( ret == VLC_SUCCESS )
338 m_length = *va_arg( ap, int64_t * );
339 va_end( ap );
340 return ret;
341 }
342
343 case DEMUX_CAN_SEEK:
344 {
345 int ret;
346 va_list ap;
347
348 va_copy( ap, args );
349 ret = demux_vaControl( p_demux_filter->p_next, i_query, args );
350 if( ret == VLC_SUCCESS )
351 m_can_seek = *va_arg( ap, bool* );
352 va_end( ap );
353 return ret;
354 }
355
356 case DEMUX_SET_POSITION:
357 {
358 m_pause_delay = m_pause_date = VLC_TS_INVALID;
359
360 double pos = va_arg( args, double );
361 /* Force unprecise seek */
362 int ret = demux_Control( p_demux->p_next, DEMUX_SET_POSITION, pos, false );
363 if( ret != VLC_SUCCESS )
364 return ret;
365
366 resetTimes();
367 resetDemuxEof();
368 return VLC_SUCCESS;
369 }
370 case DEMUX_SET_TIME:
371 {
372 m_pause_delay = m_pause_date = VLC_TS_INVALID;
373
374 mtime_t time = va_arg( args, int64_t );
375 /* Force unprecise seek */
376 int ret = demux_Control( p_demux->p_next, DEMUX_SET_TIME, time, false );
377 if( ret != VLC_SUCCESS )
378 return ret;
379
380 resetTimes();
381 resetDemuxEof();
382 return VLC_SUCCESS;
383 }
384 case DEMUX_SET_PAUSE_STATE:
385 {
386 va_list ap;
387
388 va_copy( ap, args );
389 int paused = va_arg( ap, int );
390 va_end( ap );
391
392 if (paused)
393 {
394 if (m_pause_date == VLC_TS_INVALID)
395 m_pause_date = mdate();
396 }
397 else
398 {
399 if (m_pause_date != VLC_TS_INVALID)
400 {
401 m_pause_delay += mdate() - m_pause_date;
402 m_pause_date = VLC_TS_INVALID;
403 }
404 }
405
406 setPauseState( paused != 0, m_pause_delay );
407 break;
408 }
409 case DEMUX_SET_ES:
410 /* Seek back to the last known pos when changing tracks. This will
411 * flush sout streams, make sout del/add called right away and
412 * clear CC buffers. */
413 seekBack(m_last_time, m_last_pos);
414 resetTimes();
415 resetDemuxEof();
416 break;
417 case DEMUX_FILTER_ENABLE:
418 p_renderer = static_cast<chromecast_common *>(
419 var_InheritAddress( p_demux, CC_SHARED_VAR_NAME ) );
420 assert(p_renderer != NULL);
421 m_enabled = true;
422 init();
423 return VLC_SUCCESS;
424
425 case DEMUX_FILTER_DISABLE:
426
427 deinit();
428
429 /* Seek back to last known position. Indeed we don't want to resume
430 * from the input position that can be more than 1 minutes forward
431 * (depending on the CC buffering policy). */
432 seekBack(m_last_time, m_last_pos);
433
434 m_enabled = false;
435 p_renderer = NULL;
436
437 return VLC_SUCCESS;
438 }
439
440 return demux_vaControl( p_demux_filter->p_next, i_query, args );
441 }
442
443 protected:
444 demux_t * const p_demux;
445 chromecast_common * p_renderer;
446 mtime_t m_length;
447 bool m_can_seek;
448 bool m_enabled;
449 bool m_demux_eof;
450 double m_start_pos;
451 double m_last_pos;
452 mtime_t m_start_time;
453 mtime_t m_last_time;
454 mtime_t m_pause_date;
455 mtime_t m_pause_delay;
456 };
457
458 static void on_paused_changed_cb( void *data, bool paused )
459 {
460 demux_t *p_demux = reinterpret_cast<demux_t*>(data);
461
462 input_thread_t *p_input = p_demux->p_next->p_input;
463 if( p_input )
464 input_Control( p_input, INPUT_SET_STATE, paused ? PAUSE_S : PLAYING_S );
465 }
466
467 static int Demux( demux_t *p_demux_filter )
468 {
469 demux_cc *p_sys = reinterpret_cast<demux_cc*>(p_demux_filter->p_sys);
470
471 return p_sys->Demux();
472 }
473
474 static int Control( demux_t *p_demux_filter, int i_query, va_list args)
475 {
476 demux_cc *p_sys = reinterpret_cast<demux_cc*>(p_demux_filter->p_sys);
477
478 return p_sys->Control( p_demux_filter, i_query, args );
479 }
480
481 int Open(vlc_object_t *p_this)
482 {
483 demux_t *p_demux = reinterpret_cast<demux_t*>(p_this);
484 chromecast_common *p_renderer = static_cast<chromecast_common *>(
485 var_InheritAddress( p_demux, CC_SHARED_VAR_NAME ) );
486 if ( p_renderer == NULL )
487 {
488 msg_Warn( p_this, "using Chromecast demuxer with no sout" );
489 return VLC_ENOOBJ;
490 }
491
492 demux_cc *p_sys = new(std::nothrow) demux_cc( p_demux, p_renderer );
493 if (unlikely(p_sys == NULL))
494 return VLC_ENOMEM;
495
496 p_demux->p_sys = p_sys;
497 p_demux->p_sys = reinterpret_cast<demux_sys_t*>(p_sys);
498 p_demux->pf_demux = Demux;
499 p_demux->pf_control = Control;
500
501 return VLC_SUCCESS;
502 }
503
504 void Close(vlc_object_t *p_this)
505 {
506 demux_t *p_demux = reinterpret_cast<demux_t*>(p_this);
507 demux_cc *p_sys = reinterpret_cast<demux_cc*>(p_demux->p_sys);
508
509 delete p_sys;
510 }
511
512 vlc_module_begin ()
513 set_shortname( "cc_demux" )
514 set_category( CAT_INPUT )
515 set_subcategory( SUBCAT_INPUT_DEMUX )
516 set_description( N_( "Chromecast demux wrapper" ) )
517 set_capability( "demux_filter", 0 )
518 add_shortcut( "cc_demux" )
519 set_callbacks( Open, Close )
520 vlc_module_end ()
VLC Development tree mirror