?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Remove the file:// URI decode hack
[vlc/asuraparaju-public.git] / modules / access / bd / bd.c
blob20b78b06f1f4d51155344851812802b8dea192eb
1 /*****************************************************************************
2 * bd.c: BluRay Disc support (uncrypted)
3 *****************************************************************************
4 * Copyright (C) 2009 the VideoLAN team
5 * $Id$
6 *
7 * Authors: Laurent Aimar <fenrir _AT_ videolan _DOT_ org>
8 *
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
13 *
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
22 *****************************************************************************/
23
24 /*****************************************************************************
25 * Preamble
26 *****************************************************************************/
27
28 #ifdef HAVE_CONFIG_H
29 # include "config.h"
30 #endif
31
32 #ifdef HAVE_SYS_STAT_H
33 # include <sys/stat.h>
34 #endif
35 #include <limits.h>
36
37 #include <vlc_common.h>
38 #include <vlc_plugin.h>
39 #include <vlc_input.h>
40 #include <vlc_access.h>
41 #include <vlc_demux.h>
42 #include <vlc_fs.h>
43 #include <vlc_bits.h>
44 #include <assert.h>
45
46 #include "mpls.h"
47 #include "clpi.h"
48
49 /*****************************************************************************
50 * Module descriptor
51 *****************************************************************************/
52 #define CACHING_TEXT N_("Caching value in ms")
53 #define CACHING_LONGTEXT N_( \
54 "Caching value for BDs. This "\
55 "value should be set in milliseconds." )
56
57 static int Open ( vlc_object_t * );
58 static void Close( vlc_object_t * );
59
60 vlc_module_begin ()
61 set_shortname( N_("BD") )
62 set_description( N_("Blu-Ray Disc Input") )
63 set_category( CAT_INPUT )
64 set_subcategory( SUBCAT_INPUT_ACCESS )
65 add_integer( "bd-caching", DEFAULT_PTS_DELAY / 1000, NULL,
66 CACHING_TEXT, CACHING_LONGTEXT, true )
67 set_capability( "access_demux", 60 )
68 add_shortcut( "bd" )
69 add_shortcut( "file" )
70 set_callbacks( Open, Close )
71 vlc_module_end ()
72
73 /*****************************************************************************
74 * Documentation
75 * I have used:
76 * - http://www.stebbins.biz/source/bdtools.tgz
77 * - hdcookbook java code
78 * - BDInfo source code
79 *****************************************************************************/
80
81 /*****************************************************************************
82 * Local prototypes
83 *****************************************************************************/
84 struct demux_sys_t
85 {
86 char *psz_base;
87 bool b_shortname;
88
89 /* */
90 int i_mpls;
91 bd_mpls_t **pp_mpls;
92
93 /* */
94 int i_clpi;
95 bd_clpi_t **pp_clpi;
96
97 /* */
98 int i_title;
99 input_title_t **pp_title;
100
101 /* */
102 es_out_t *p_out;
103
104 /* Current state */
105 const bd_clpi_t *p_clpi;
106 int i_clpi_ep;
107 stream_t *p_parser;
108 stream_t *p_m2ts;
109 int i_play_item;
110 int i_packet;
111 int i_packet_start;
112 int i_packet_stop;
113 int i_packet_headers;
114 int64_t i_atc_initial;
115 int64_t i_atc_current;
116 int64_t i_atc_wrap;
117 int64_t i_atc_last;
118 };
119
120 static int Control( demux_t *, int, va_list );
121 static int Demux( demux_t * );
122
123 static char *FindPathBase( const char *, bool *pb_shortname );
124
125 static int LoadPlaylist( demux_t * );
126 static int LoadClip( demux_t * );
127
128 static void ReorderPlaylist( demux_t * );
129
130 static void InitTitles( demux_t * );
131 static int SetTitle( demux_t *, int );
132 static int SetChapter( demux_t *, int );
133 static int64_t GetTime( demux_t * );
134 static double GetPosition( demux_t * );
135 static int SetTime( demux_t *, int64_t );
136 static int SetPosition( demux_t *, double );
137
138 static int SetPlayItem( demux_t *p_demux, int i_mpls, int i_play_item );
139 static void ClosePlayItem( demux_t * );
140
141 /* */
142 static int64_t GetClpiPacket( demux_t *p_demux, int *pi_ep, const bd_mpls_clpi_t *p_mpls_clpi, int64_t i_time /* in 45kHz */ );
143
144 static es_out_t *EsOutNew( demux_t *p_demux );
145
146 //#define BD_DEBUG
147
148 /*****************************************************************************
149 * Open:
150 *****************************************************************************/
151 static int Open( vlc_object_t *p_this )
152 {
153 demux_t *p_demux = (demux_t*)p_this;
154 demux_sys_t *p_sys;
155
156 if( *p_demux->psz_access &&
157 strcmp( p_demux->psz_access, "bd" ) &&
158 strcmp( p_demux->psz_access, "file" ) )
159 return VLC_EGENERIC;
160
161 /* */
162 bool b_shortname;
163 char *psz_base = FindPathBase( p_demux->psz_path, &b_shortname );
164 if( !psz_base )
165 return VLC_EGENERIC;
166
167 msg_Dbg( p_demux, "Using path '%s'", psz_base );
168
169 /* Fill p_demux field */
170 p_demux->p_sys = p_sys = malloc( sizeof(*p_sys) );
171 if( !p_sys )
172 return VLC_EGENERIC;
173 p_sys->psz_base = psz_base;
174 p_sys->b_shortname = b_shortname;
175 TAB_INIT( p_sys->i_mpls, p_sys->pp_mpls );
176 TAB_INIT( p_sys->i_clpi, p_sys->pp_clpi );
177 TAB_INIT( p_sys->i_title, p_sys->pp_title );
178 p_demux->info.i_title = -1;
179 p_sys->p_clpi = NULL;
180 p_sys->i_clpi_ep = -1;
181 p_sys->p_parser = NULL;
182 p_sys->p_m2ts = NULL;
183 p_sys->i_play_item = -1;
184 p_sys->i_packet = -1;
185 p_sys->i_packet_start = -1;
186 p_sys->i_packet_stop = -1;
187 p_sys->i_packet_headers = -1;
188 p_sys->p_out = EsOutNew( p_demux );
189 if( !p_sys->p_out )
190 goto error;
191
192 p_demux->pf_control = Control;
193 p_demux->pf_demux = Demux;
194
195 /* Load all clip/playlist files */
196 LoadClip( p_demux );
197 LoadPlaylist( p_demux );
198
199 /* Reorder playlist to have the most significant first
200 * (as we don't have menu support, no idea how to find the main title */
201 ReorderPlaylist( p_demux );
202
203 /* Setup variables (for TS demuxer) */
204 var_Create( p_demux, "ts-es-id-pid", VLC_VAR_BOOL );
205 var_SetBool( p_demux, "ts-es-id-pid", true );
206
207 /* */
208 InitTitles( p_demux );
209 if( SetTitle( p_demux, 0 ) )
210 goto error;
211
212 return VLC_SUCCESS;
213
214 error:
215 Close( VLC_OBJECT(p_demux) );
216 return VLC_EGENERIC;
217 }
218
219 /*****************************************************************************
220 * Close:
221 *****************************************************************************/
222 static void Close( vlc_object_t *p_this )
223 {
224 demux_t *p_demux = (demux_t*)p_this;
225 demux_sys_t *p_sys = p_demux->p_sys;
226
227 /* */
228 ClosePlayItem( p_demux );
229
230 /* */
231 es_out_Delete( p_sys->p_out );
232
233 /* Titles */
234 for( int i = 0; i < p_sys->i_title; i++ )
235 vlc_input_title_Delete( p_sys->pp_title[i] );
236 TAB_CLEAN( p_sys->i_title, p_sys->pp_title );
237
238 /* CLPI */
239 for( int i = 0; i < p_sys->i_clpi; i++ )
240 {
241 bd_clpi_t *p_clpi = p_sys->pp_clpi[i];
242
243 bd_clpi_Clean( p_clpi );
244 free( p_clpi );
245 }
246 TAB_CLEAN( p_sys->i_clpi, p_sys->pp_clpi );
247
248 /* MPLS */
249 for( int i = 0; i < p_sys->i_mpls; i++ )
250 {
251 bd_mpls_t *p_mpls = p_sys->pp_mpls[i];
252
253 bd_mpls_Clean( p_mpls );
254 free( p_mpls );
255 }
256 TAB_CLEAN( p_sys->i_mpls, p_sys->pp_mpls );
257
258 free( p_sys->psz_base );
259 free( p_sys );
260 }
261
262 /*****************************************************************************
263 * Control:
264 *****************************************************************************/
265 static int Control( demux_t *p_demux, int i_query, va_list args )
266 {
267 demux_sys_t *p_sys = p_demux->p_sys;
268
269 switch( i_query )
270 {
271 case DEMUX_GET_TIME:
272 {
273 int64_t *pi_time = (int64_t*)va_arg( args, int64_t * );
274 *pi_time = GetTime( p_demux );
275 return VLC_SUCCESS;;
276 }
277
278 case DEMUX_GET_POSITION:
279 {
280 double *pf_position = (double*)va_arg( args, double * );
281 *pf_position = GetPosition( p_demux );
282 return VLC_SUCCESS;
283 }
284
285 case DEMUX_SET_TIME:
286 {
287 int64_t i_time = (int64_t)va_arg( args, int64_t );
288 return SetTime( p_demux, i_time );
289 }
290 case DEMUX_SET_POSITION:
291 {
292 double f_position = (double)va_arg( args, double );
293 return SetPosition( p_demux, f_position );
294 }
295
296 case DEMUX_GET_LENGTH:
297 {
298 int64_t *pi_length = (int64_t*)va_arg( args, int64_t * );
299 *pi_length = p_sys->pp_title[p_demux->info.i_title]->i_length;
300 return VLC_SUCCESS;
301 }
302
303 /* Special for access_demux */
304 case DEMUX_CAN_PAUSE:
305 case DEMUX_CAN_SEEK:
306 case DEMUX_CAN_CONTROL_PACE:
307 {
308 bool *pb_bool = (bool*)va_arg( args, bool * );
309 *pb_bool = true;
310 return VLC_SUCCESS;
311 }
312
313 case DEMUX_SET_PAUSE_STATE:
314 return VLC_SUCCESS;
315
316 case DEMUX_GET_TITLE_INFO:
317 {
318 input_title_t ***ppp_title = (input_title_t***)va_arg( args, input_title_t*** );
319 int *pi_int = (int*)va_arg( args, int* );
320 int *pi_title_offset = (int*)va_arg( args, int* );
321 int *pi_chapter_offset = (int*)va_arg( args, int* );
322
323 /* */
324 *pi_title_offset = 0;
325 *pi_chapter_offset = 0;
326
327 /* Duplicate title infos */
328 *pi_int = p_sys->i_title;
329 *ppp_title = calloc( p_sys->i_title, sizeof(input_title_t **) );
330 for( int i = 0; i < p_sys->i_title; i++ )
331 (*ppp_title)[i] = vlc_input_title_Duplicate( p_sys->pp_title[i] );
332
333 return VLC_SUCCESS;
334 }
335
336 case DEMUX_SET_TITLE:
337 {
338 int i_title = (int)va_arg( args, int );
339
340 if( SetTitle( p_demux, i_title ) )
341 return VLC_EGENERIC;
342 return VLC_SUCCESS;
343 }
344 case DEMUX_SET_SEEKPOINT:
345 {
346 int i_chapter = (int)va_arg( args, int );
347
348 if( SetChapter( p_demux, i_chapter ) )
349 return VLC_EGENERIC;
350 return VLC_SUCCESS;
351 }
352
353 case DEMUX_GET_PTS_DELAY:
354 {
355 int64_t *pi_delay = (int64_t*)va_arg( args, int64_t * );
356 *pi_delay = var_GetInteger( p_demux, "bd-caching" ) * INT64_C(1000);
357 return VLC_SUCCESS;
358 }
359
360 case DEMUX_GET_META:
361
362 default:
363 return VLC_EGENERIC;
364 }
365 }
366
367 /*****************************************************************************
368 * Demux:
369 *****************************************************************************/
370 #define BD_TS_PACKET_HEADER (4)
371 #define BD_TS_PACKET_SIZE (192)
372 static int Demux( demux_t *p_demux )
373 {
374 demux_sys_t *p_sys = p_demux->p_sys;
375 if( !p_sys->p_m2ts )
376 return -1;
377
378 /* */
379 if( p_sys->i_packet == p_sys->i_packet_start )
380 {
381 stream_Seek( p_sys->p_m2ts, 0 );
382
383 block_t *p_block = stream_Block( p_sys->p_m2ts,
384 p_sys->i_packet_headers * (int64_t)BD_TS_PACKET_SIZE + BD_TS_PACKET_HEADER );
385 if( p_block )
386 {
387 p_block->i_buffer -= BD_TS_PACKET_HEADER;
388 p_block->p_buffer += BD_TS_PACKET_HEADER;
389 stream_DemuxSend( p_sys->p_parser, p_block );
390 }
391
392 stream_Seek( p_sys->p_m2ts, p_sys->i_packet_start * (int64_t)BD_TS_PACKET_SIZE );
393 }
394
395 /* */
396 const int i_packets = __MIN( 5, p_sys->i_packet_stop - p_sys->i_packet );
397 if( i_packets <= 0 )
398 {
399 const int i_title = p_demux->info.i_title;
400 const bd_mpls_t *p_mpls = p_sys->pp_mpls[i_title];
401
402 if( p_sys->i_play_item < p_mpls->i_play_item )
403 {
404 if( !SetPlayItem( p_demux, i_title, p_sys->i_play_item + 1 ) )
405 return 1;
406 msg_Warn( p_demux, "Failed to switch to the next play item" );
407 }
408
409 /* */
410 if( SetTitle( p_demux, i_title + 1 ) )
411 return 0; /* EOF */
412 return 1;
413 }
414
415 /* XXX
416 * we ensure that the TS packet start at the begining of the buffer,
417 * it ensure proper TS parsing */
418 block_t *p_block = block_New( p_demux, i_packets * BD_TS_PACKET_SIZE + BD_TS_PACKET_HEADER );
419 if( !p_block )
420 return -1;
421
422 const int i_read = stream_Read( p_sys->p_m2ts, p_block->p_buffer, p_block->i_buffer - BD_TS_PACKET_HEADER );
423 if( i_read <= 0 )
424 {
425 msg_Err( p_demux, "Error reading current title" );
426 return -1;
427 }
428
429 if( i_read > 4 )
430 {
431 const int64_t i_atc = GetDWBE( p_block->p_buffer ) & ( (1 << 30) - 1 );
432
433 if( i_atc < p_sys->i_atc_last )
434 p_sys->i_atc_wrap += 1 << 30;
435 p_sys->i_atc_last = i_atc;
436
437 if( p_sys->i_atc_initial < 0 )
438 p_sys->i_atc_initial = i_atc + p_sys->i_atc_wrap;
439
440 p_sys->i_atc_current = i_atc + p_sys->i_atc_wrap;
441 }
442
443 p_block->i_buffer = i_read;
444 p_block->p_buffer += BD_TS_PACKET_HEADER;
445 stream_DemuxSend( p_sys->p_parser, p_block );
446
447 p_sys->i_packet += i_read / BD_TS_PACKET_SIZE;
448
449 /* Update EP */
450 if( p_sys->p_clpi->i_ep_map > 0 )
451 {
452 const int i_old_clpi_ep = p_sys->i_clpi_ep;
453
454 const bd_clpi_ep_map_t *p_ep_map = &p_sys->p_clpi->p_ep_map[0];
455 for( ; p_sys->i_clpi_ep+1 < p_ep_map->i_ep; p_sys->i_clpi_ep++ )
456 {
457 const bd_clpi_ep_t *p_ep = &p_ep_map->p_ep[p_sys->i_clpi_ep+1];
458
459 if( p_ep->i_packet > p_sys->i_packet )
460 break;
461 }
462 if( i_old_clpi_ep != p_sys->i_clpi_ep )
463 {
464 /* We have changed of EP */
465 p_sys->i_atc_initial = p_sys->i_atc_current; /* FIXME not exact */
466
467 /* Update seekpoint */
468 const input_title_t *p_title = p_sys->pp_title[p_demux->info.i_title];
469 const int64_t i_time = GetTime( p_demux );
470
471 for( ; p_demux->info.i_seekpoint+1 < p_title->i_seekpoint; p_demux->info.i_seekpoint++ )
472 {
473 const seekpoint_t *p_seekpoint = p_title->seekpoint[p_demux->info.i_seekpoint+1];
474 if( p_seekpoint->i_time_offset > i_time )
475 break;
476 p_demux->info.i_update |= INPUT_UPDATE_SEEKPOINT;
477 }
478 }
479 }
480 return 1;
481 }
482
483 /*****************************************************************************
484 *
485 *****************************************************************************/
486 #define BD_45KHZ INT64_C(45000)
487 static void InitTitles( demux_t *p_demux )
488 {
489 demux_sys_t *p_sys = p_demux->p_sys;
490
491 /* */
492 for( int i = 0; i < p_sys->i_mpls; i++ )
493 {
494 const bd_mpls_t *p_mpls = p_sys->pp_mpls[i];
495
496 input_title_t *t = vlc_input_title_New();
497 if( !t )
498 break;
499
500 /* */
501 t->i_length = 0;
502 for( int j = 0; j < p_mpls->i_play_item; j++ )
503 {
504 const bd_mpls_play_item_t *p_item = &p_mpls->p_play_item[j];
505
506 t->i_length += ( p_item->i_out_time - p_item->i_in_time ) * CLOCK_FREQ / BD_45KHZ;
507 }
508
509 #ifdef BD_DEBUG
510 {
511 char psz_length[MSTRTIME_MAX_SIZE];
512 msg_Warn( p_demux, "TITLE[%d] %s", i, secstotimestr( psz_length, t->i_length / CLOCK_FREQ ) );
513 }
514 #endif
515
516 /* Seekpoint */
517 for( int j = 0; j < p_mpls->i_mark; j++ )
518 {
519 bd_mpls_mark_t *p_mark = &p_mpls->p_mark[j];
520
521 if( p_mark->i_type == BD_MPLS_MARK_TYPE_BOOKMARK &&
522 p_mark->i_play_item_id >= 0 && p_mark->i_play_item_id < p_mpls->i_play_item )
523 {
524 seekpoint_t *s = vlc_seekpoint_New();
525 if( !s )
526 break;
527
528 for( int k = 0; k <= p_mark->i_play_item_id; k++ )
529 {
530 const bd_mpls_play_item_t *p_item = &p_mpls->p_play_item[k];
531 int64_t i_out_time;
532
533 if( k == p_mark->i_play_item_id )
534 i_out_time = p_mark->i_time;
535 else
536 i_out_time = p_item->i_out_time;
537 s->i_time_offset += ( i_out_time - p_item->i_in_time ) * CLOCK_FREQ / BD_45KHZ;
538 }
539 #ifdef BD_DEBUG
540 {
541 char psz_time[MSTRTIME_MAX_SIZE];
542 msg_Warn( p_demux, " SEEKPOINT[%d] %s", j, secstotimestr( psz_time, s->i_time_offset / CLOCK_FREQ ) );
543 }
544 #endif
545 TAB_APPEND( t->i_seekpoint, t->seekpoint, s );
546 }
547 }
548 if( t->i_seekpoint <= 0 )
549 {
550 seekpoint_t *s = vlc_seekpoint_New();
551 if( s )
552 TAB_APPEND( t->i_seekpoint, t->seekpoint, s );
553 }
554
555 TAB_APPEND( p_sys->i_title, p_sys->pp_title, t );
556 }
557 }
558 static int SetTitle( demux_t *p_demux, int i_title )
559 {
560 demux_sys_t *p_sys = p_demux->p_sys;
561
562 if( i_title < 0 || i_title >= p_sys->i_title )
563 return VLC_EGENERIC;
564
565
566 if( SetPlayItem( p_demux, i_title, 0 ) )
567 return VLC_EGENERIC;
568
569 /* */
570 p_demux->info.i_update |= INPUT_UPDATE_TITLE | INPUT_UPDATE_SEEKPOINT;
571 p_demux->info.i_title = i_title;
572 p_demux->info.i_seekpoint = 0;
573
574 return VLC_SUCCESS;
575 }
576 static int SetChapter( demux_t *p_demux, int i_chapter )
577 {
578 demux_sys_t *p_sys = p_demux->p_sys;
579 const int i_title = p_demux->info.i_title;
580 const input_title_t *p_title = p_sys->pp_title[i_title];
581
582 if( i_chapter < 0 || i_chapter > p_title->i_seekpoint )
583 return VLC_EGENERIC;
584
585 if( SetTime( p_demux, p_title->seekpoint[i_chapter]->i_time_offset ) )
586 return VLC_EGENERIC;
587
588 return VLC_SUCCESS;
589 }
590 static int SetPlayItem( demux_t *p_demux, int i_mpls, int i_play_item )
591 {
592 demux_sys_t *p_sys = p_demux->p_sys;
593
594 /* FIXME TODO do not reopen everything when avoidable
595 * XXX becarefull that then the es_out wrapper need some sort of
596 * locking !!! */
597
598 /* */
599 const bool b_same_mpls = i_mpls == p_demux->info.i_title;
600 //const bool b_same_play_item = b_same_mpls &&
601 // i_play_item == p_sys->i_play_item;
602
603 /* */
604 const bd_mpls_t *p_mpls = p_sys->pp_mpls[i_mpls];
605
606 /* */
607 if( i_play_item < 0 || i_play_item >= p_mpls->i_play_item )
608 return VLC_EGENERIC;
609
610 const bd_mpls_play_item_t *p_item = &p_mpls->p_play_item[i_play_item];
611 const bd_mpls_clpi_t *p_mpls_clpi = &p_item->clpi;
612
613 const bd_clpi_t *p_clpi = NULL;
614 for( int i_clpi = 0; i_clpi < p_sys->i_clpi && !p_clpi; i_clpi++ )
615 {
616 if( p_sys->pp_clpi[i_clpi]->i_id == p_mpls_clpi->i_id )
617 p_clpi = p_sys->pp_clpi[i_clpi];
618 }
619
620 const bool b_same_clpi = b_same_mpls && p_sys->p_clpi->i_id == p_clpi->i_id;
621 stream_t *p_m2ts = NULL;
622 if( !b_same_clpi )
623 {
624 char *psz_m2ts;
625 if( asprintf( &psz_m2ts, "%s/STREAM/%05d.%s",
626 p_sys->psz_base, p_mpls_clpi->i_id, p_sys->b_shortname ? "MTS" : "m2ts" ) < 0 )
627 return VLC_EGENERIC;
628
629 p_m2ts = stream_UrlNew( p_demux, psz_m2ts );
630 if( !p_m2ts )
631 {
632 msg_Err( p_demux, "Failed to open %s", psz_m2ts );
633 free( psz_m2ts );
634 return VLC_EGENERIC;
635 }
636 free( psz_m2ts );
637 }
638
639 /* TODO avoid reopenning the parser when unneeded.
640 * - b_same_play_item is too strict, we should check the play_items connection.
641 * - a way to completely flush the demuxer is also needed !
642 */
643 //const bool b_same_parser = b_same_play_item && false;
644 stream_t *p_parser = stream_DemuxNew( p_demux, "ts", p_sys->p_out );
645 if( !p_parser )
646 {
647 msg_Err( p_demux, "Failed to create TS demuxer" );
648 if( p_m2ts )
649 stream_Delete( p_m2ts );
650 return VLC_EGENERIC;
651 }
652
653 /* */
654 if( !p_m2ts )
655 {
656 msg_Dbg( p_demux, "Reusing stream file" );
657 p_m2ts = p_sys->p_m2ts;
658 p_sys->p_m2ts = NULL;
659 }
660
661 /* */
662 ClosePlayItem( p_demux );
663
664 /* */
665 p_sys->p_clpi = p_clpi;
666 p_sys->p_parser = p_parser;
667 p_sys->p_m2ts = p_m2ts;
668 p_sys->i_play_item = i_play_item;
669
670 p_sys->i_packet_start = GetClpiPacket( p_demux, &p_sys->i_clpi_ep, p_mpls_clpi, p_item->i_in_time );
671 if( p_sys->i_packet_start < 0 )
672 {
673 p_sys->i_packet_start = 0;
674 p_sys->i_clpi_ep = 0;
675 }
676
677 p_sys->i_packet_stop = GetClpiPacket( p_demux, NULL, p_mpls_clpi, p_item->i_out_time );
678 if( p_sys->i_packet_stop < 0 )
679 p_sys->i_packet_stop = stream_Size( p_m2ts ) / BD_TS_PACKET_SIZE;
680 p_sys->i_packet = p_sys->i_packet_start;
681
682 /* This is a hack to detect the number of packet to send before any data
683 * to have the PAT/PMT. I have no idea if it is the right, but seems to work.
684 * I used a limits of 10 packets, sufficient if it is really only headers */
685 p_sys->i_packet_headers = 0;
686 if( p_clpi->i_ep_map > 0 )
687 {
688 const bd_clpi_ep_map_t *p_ep_map = &p_clpi->p_ep_map[0];
689 if( p_ep_map->i_ep > 0 )
690 p_sys->i_packet_headers = __MIN( p_ep_map->p_ep[0].i_packet, 10 );
691 }
692
693 p_sys->i_atc_initial = -1;
694 p_sys->i_atc_current = -1;
695 p_sys->i_atc_last = -1;
696 p_sys->i_atc_wrap = 0;
697
698 return VLC_SUCCESS;
699 }
700 static void ClosePlayItem( demux_t *p_demux )
701 {
702 demux_sys_t *p_sys = p_demux->p_sys;
703
704 if( p_sys->p_m2ts )
705 stream_Delete( p_sys->p_m2ts );
706 if( p_sys->p_parser )
707 stream_Delete( p_sys->p_parser );
708
709 es_out_Control( p_demux->out, ES_OUT_RESET_PCR );
710 }
711
712 static int64_t GetClpiPacket( demux_t *p_demux, int *pi_ep, const bd_mpls_clpi_t *p_mpls_clpi, int64_t i_time /* in 45kHz */ )
713 {
714 demux_sys_t *p_sys = p_demux->p_sys;
715
716 const bd_clpi_t *p_clpi = p_sys->p_clpi;
717 assert( p_clpi );
718
719 if( p_clpi->i_ep_map <= 0 )
720 return -1;
721 const bd_clpi_ep_map_t *p_ep_map = &p_clpi->p_ep_map[0];
722
723 if( p_mpls_clpi->i_stc_id < 0 || p_mpls_clpi->i_stc_id >= p_clpi->i_stc )
724 return -1;
725
726 const bd_clpi_stc_t *p_stc = &p_clpi->p_stc[p_mpls_clpi->i_stc_id];
727 #if 0
728 /* Not sure it is right */
729 if( i_time < p_stc->i_start || i_time > p_stc->i_end )
730 return -1;
731 #endif
732
733 const int64_t i_packet = p_stc->i_packet;
734 int i_ep;
735 for( i_ep = 0; i_ep < p_ep_map->i_ep; i_ep++ )
736 {
737 if( p_ep_map->p_ep[i_ep].i_packet >= i_packet )
738 break;
739 }
740 if( i_ep >= p_ep_map->i_ep )
741 return -1;
742
743 for( ; i_ep < p_ep_map->i_ep; i_ep++ )
744 {
745 const bd_clpi_ep_t *p_ep = &p_ep_map->p_ep[i_ep];
746 const bd_clpi_ep_t *p_ep_next = &p_ep_map->p_ep[i_ep+1];
747
748 if( i_ep+1 < p_ep_map->i_ep && p_ep_next->i_pts / 2 > i_time )
749 break;
750 if( p_ep->i_pts / 2 >= i_time )
751 break;
752 }
753 if( i_ep >= p_ep_map->i_ep )
754 return -1;
755
756 /* */
757 if( pi_ep )
758 *pi_ep = i_ep;
759 return p_ep_map->p_ep[i_ep].i_packet;
760 }
761
762 /**
763 * Retreive the current time using current EP + ATC delta
764 */
765 static int64_t GetTime( demux_t *p_demux )
766 {
767 demux_sys_t *p_sys = p_demux->p_sys;
768 const int i_mpls = p_demux->info.i_title;
769
770 const bd_mpls_t *p_mpls = p_sys->pp_mpls[i_mpls];
771 const bd_mpls_play_item_t *p_item = &p_mpls->p_play_item[p_sys->i_play_item];
772
773 const bd_clpi_t *p_clpi = p_sys->p_clpi;
774 if( !p_clpi || p_clpi->i_ep_map <= 0 )
775 return 0;
776
777 /* */
778 const bd_clpi_ep_map_t *p_ep_map = &p_clpi->p_ep_map[0];
779 if( p_sys->i_clpi_ep < 0 || p_sys->i_clpi_ep >= p_ep_map->i_ep )
780 return 0;
781
782 const bd_clpi_ep_t *p_ep = &p_ep_map->p_ep[p_sys->i_clpi_ep];
783 int64_t i_time = p_ep->i_pts / 2 - p_item->i_in_time +
784 ( p_sys->i_atc_current - p_sys->i_atc_initial ) / 300 / 2;
785
786 for( int j = 0; j < p_sys->i_play_item; j++ )
787 {
788 const bd_mpls_play_item_t *p_item = &p_mpls->p_play_item[j];
789 i_time += ( p_item->i_out_time - p_item->i_in_time );
790 }
791
792 return i_time * CLOCK_FREQ / BD_45KHZ;
793 }
794
795 static double GetPosition( demux_t *p_demux )
796 {
797 demux_sys_t *p_sys = p_demux->p_sys;
798
799 const int64_t i_time = GetTime( p_demux );
800 const input_title_t *p_title = p_sys->pp_title[p_demux->info.i_title];
801
802 if( p_title->i_length <= 0 )
803 return 0.0;
804
805 return (double)i_time / p_title->i_length;
806 }
807
808 static int SetTime( demux_t *p_demux, int64_t i_time )
809 {
810 demux_sys_t *p_sys = p_demux->p_sys;
811 const int i_mpls = p_demux->info.i_title;
812 const input_title_t *p_title = p_sys->pp_title[i_mpls];
813 const bd_mpls_t *p_mpls = p_sys->pp_mpls[i_mpls];
814
815 /* Find the play item */
816 int i_item;
817 int64_t i_play_item_time = 0;
818 for( i_item = 0; i_item < p_mpls->i_play_item; i_item++ )
819 {
820 const bd_mpls_play_item_t *p_item = &p_mpls->p_play_item[i_item];
821 const int64_t i_duration = ( p_item->i_out_time - p_item->i_in_time ) * CLOCK_FREQ / BD_45KHZ;
822
823 if( i_time >= i_play_item_time && i_time < i_play_item_time + i_duration )
824 break;
825
826 i_play_item_time += i_duration;
827 }
828
829 if( i_item >= p_mpls->i_play_item )
830 return VLC_EGENERIC;
831
832 if( SetPlayItem( p_demux, i_mpls, i_item ) )
833 return VLC_EGENERIC;
834
835
836 /* Find the right entry point */
837 if( p_sys->p_clpi->i_ep_map <= 0 )
838 goto update;
839
840 const bd_clpi_ep_map_t *p_ep_map = &p_sys->p_clpi->p_ep_map[0];
841 if( p_ep_map->i_ep <= 0 )
842 goto update;
843
844 int64_t i_next_display_date = -1;
845 for( ; p_sys->i_clpi_ep+1 < p_ep_map->i_ep; p_sys->i_clpi_ep++ )
846 {
847 const bd_clpi_ep_t *p_next = &p_ep_map->p_ep[p_sys->i_clpi_ep+1];
848 const int64_t i_next_time = i_play_item_time + ( ( p_next->i_pts / 2 - p_mpls->p_play_item[i_item].i_in_time ) * CLOCK_FREQ / BD_45KHZ );
849
850 if( i_next_time > i_time )
851 {
852 const bd_clpi_ep_t *p_ep = &p_ep_map->p_ep[p_sys->i_clpi_ep];
853 const int64_t i_ep_time = i_play_item_time + ( ( p_ep->i_pts / 2 - p_mpls->p_play_item[i_item].i_in_time ) * CLOCK_FREQ / BD_45KHZ );
854
855
856 i_next_display_date = p_ep->i_pts * CLOCK_FREQ / 90000 + ( i_time - i_ep_time );
857 break;
858 }
859 }
860
861 const bd_clpi_ep_t *p_ep = &p_ep_map->p_ep[p_sys->i_clpi_ep];
862 p_sys->i_packet_start =
863 p_sys->i_packet = p_ep->i_packet;
864
865 if( i_next_display_date >= 0 )
866 es_out_Control( p_demux->out, ES_OUT_SET_NEXT_DISPLAY_TIME, i_next_display_date );
867
868 update:
869 /* Update seekpoint */
870 for( p_demux->info.i_seekpoint = 0; p_demux->info.i_seekpoint+1 < p_title->i_seekpoint; p_demux->info.i_seekpoint++ )
871 {
872 const seekpoint_t *p_seekpoint = p_title->seekpoint[p_demux->info.i_seekpoint+1];
873 if( p_seekpoint->i_time_offset > i_time )
874 break;
875 }
876 p_demux->info.i_update |= INPUT_UPDATE_SEEKPOINT;
877 return VLC_SUCCESS;
878 }
879
880 static int SetPosition( demux_t *p_demux, double f_position )
881 {
882 demux_sys_t *p_sys = p_demux->p_sys;
883 const input_title_t *p_title = p_sys->pp_title[p_demux->info.i_title];
884
885 if( p_title->i_length <= 0 )
886 return VLC_EGENERIC;
887
888 return SetTime( p_demux, f_position * p_title->i_length );
889 }
890
891 /*****************************************************************************
892 * Mpls ordering
893 *****************************************************************************/
894 static int64_t GetMplsUniqueDuration( const bd_mpls_t *p_mpls )
895 {
896 int64_t i_length = 0;
897
898 for( int i = 0; i < p_mpls->i_play_item; i++ )
899 {
900 const bd_mpls_play_item_t *p_item0 = &p_mpls->p_play_item[i];
901 int j;
902 for( j = i+1; j < p_mpls->i_play_item; j++ )
903 {
904 const bd_mpls_play_item_t *p_item1 = &p_mpls->p_play_item[j];
905 if( p_item0->clpi.i_id == p_item1->clpi.i_id &&
906 p_item0->clpi.i_stc_id == p_item1->clpi.i_stc_id &&
907 p_item0->i_in_time == p_item1->i_in_time &&
908 p_item0->i_out_time == p_item1->i_out_time )
909 break;
910 }
911 if( j >= p_mpls->i_play_item )
912 i_length += p_item0->i_out_time - p_item0->i_in_time;
913 }
914 return i_length;
915 }
916 static int SortMpls( const void *a, const void *b )
917 {
918 const bd_mpls_t * const *pp_mpls_a = a;
919 const bd_mpls_t * const *pp_mpls_b = b;
920
921 const int64_t i_length_a = GetMplsUniqueDuration( *pp_mpls_a );
922 const int64_t i_length_b = GetMplsUniqueDuration( *pp_mpls_b );
923
924 if( i_length_a == i_length_b )
925 return 0;
926 return i_length_a < i_length_b ? 1 : -1;
927 }
928
929 static void ReorderPlaylist( demux_t *p_demux )
930 {
931 demux_sys_t *p_sys = p_demux->p_sys;
932 qsort( p_sys->pp_mpls, p_sys->i_mpls, sizeof(*p_sys->pp_mpls), SortMpls );
933 }
934 /*****************************************************************************
935 * Helpers:
936 *****************************************************************************/
937 static int CheckFileList( const char *psz_base, const char *ppsz_name[] )
938 {
939 for( int i = 0; ppsz_name[i] != NULL ; i++ )
940 {
941 struct stat s;
942 char *psz_tmp;
943
944 if( asprintf( &psz_tmp, "%s/%s", psz_base, ppsz_name[i] ) < 0 )
945 return VLC_EGENERIC;
946
947 bool b_ok = vlc_stat( psz_tmp, &s ) == 0 && S_ISREG( s.st_mode );
948
949 free( psz_tmp );
950 if( !b_ok )
951 return VLC_EGENERIC;
952 }
953 return VLC_SUCCESS;
954 }
955 /* */
956 static char *FindPathBase( const char *psz_path, bool *pb_shortname )
957 {
958 struct stat s;
959 char *psz_tmp;
960
961 /* */
962 char *psz_base = strdup( psz_path );
963 if( !psz_base )
964 return NULL;
965
966 /* */
967 while( *psz_base && psz_base[strlen(psz_base)-1] == '/' )
968 psz_base[strlen(psz_base)-1] = '\0';
969
970 /* */
971 if( vlc_stat( psz_base, &s ) || !S_ISDIR( s.st_mode ) )
972 goto error;
973
974 /* Check BDMV */
975 if( asprintf( &psz_tmp, "%s/BDMV", psz_base ) < 0 )
976 goto error;
977 if( !vlc_stat( psz_tmp, &s ) && S_ISDIR( s.st_mode ) )
978 {
979 free( psz_base );
980 psz_base = psz_tmp;
981 }
982 else
983 {
984 free( psz_tmp );
985 }
986
987 /* Check presence of mandatory files */
988 static const char *ppsz_name_long[] = {
989 "index.bdmv",
990 "MovieObject.bdmv",
991 NULL
992 };
993 static const char *ppsz_name_short[] = {
994 "INDEX.BDM",
995 "MOVIEOBJ.BDM",
996 NULL
997 };
998 *pb_shortname = false;
999 if( CheckFileList( psz_base, ppsz_name_long ) )
1000 {
1001 if( CheckFileList( psz_base, ppsz_name_short ) )
1002 goto error;
1003 *pb_shortname = true;
1004 }
1005 return psz_base;
1006
1007 error:
1008 free( psz_base );
1009 return NULL;
1010 }
1011
1012 /* */
1013 static block_t *LoadBlock( demux_t *p_demux, const char *psz_name )
1014 {
1015 stream_t *s = stream_UrlNew( p_demux, psz_name );
1016 if( !s )
1017 return NULL;
1018
1019 const int64_t i_size = stream_Size( s );
1020 block_t *p_block = NULL;
1021
1022 if( i_size > 0 && i_size < INT_MAX )
1023 p_block = stream_Block( s, i_size );
1024
1025 stream_Delete( s );
1026
1027 return p_block;
1028 }
1029
1030 /* */
1031 static int FilterMplsLong( const char *psz_name )
1032 {
1033 return strlen( psz_name ) == strlen( "xxxxx.mpls" ) &&
1034 !strcmp( &psz_name[5], ".mpls" );
1035 }
1036 static int FilterMplsShort( const char *psz_name )
1037 {
1038 return strlen( psz_name ) == strlen( "xxxxx.MPL" ) &&
1039 !strcmp( &psz_name[5], ".MPL" );
1040 }
1041
1042 static void LoadMpls( demux_t *p_demux, const char *psz_name, int i_id )
1043 {
1044 demux_sys_t *p_sys = p_demux->p_sys;
1045
1046 #if defined(BD_DEBUG)
1047 msg_Err( p_demux, "Loading %s", psz_name );
1048 #endif
1049
1050 block_t *p_block = LoadBlock( p_demux, psz_name );
1051 if( !p_block )
1052 goto error;
1053
1054 /* */
1055 bd_mpls_t *p_mpls = malloc( sizeof(*p_mpls) );
1056 if( !p_mpls )
1057 goto error;
1058
1059 /* */
1060 bs_t s;
1061 bs_init( &s, p_block->p_buffer, p_block->i_buffer );
1062
1063 if( bd_mpls_Parse( p_mpls, &s, i_id ) )
1064 goto error;
1065
1066 #if defined(BD_DEBUG)
1067 msg_Err( p_demux, "MPLS: id=%d", p_mpls->i_id );
1068 msg_Err( p_demux, "MPLS: play_item=%d sub_path=%d",
1069 p_mpls->i_play_item, p_mpls->i_sub_path );
1070
1071 for( int i = 0; i < p_mpls->i_play_item; i++ )
1072 {
1073 bd_mpls_play_item_t *p_item = &p_mpls->p_play_item[i];
1074
1075 msg_Err( p_demux, "PLAY_ITEM[%d] connection=%d in=%d out=%d still=%d(%d)",
1076 i, p_item->i_connection,
1077 (int)p_item->i_in_time, (int)p_item->i_out_time,
1078 p_item->i_still, p_item->i_still_time );
1079 msg_Err( p_demux, " clpi_default: id=%d stc_id=%d",
1080 p_item->clpi.i_id, p_item->clpi.i_stc_id );
1081 for( int j = 0; j < p_item->i_clpi; j++ )
1082 msg_Err( p_demux, " clpi[%d]: id=%d stc_id=%d",
1083 j, p_item->p_clpi[j].i_id, p_item->p_clpi[j].i_stc_id );
1084 for( int j = 0; j < p_item->i_stream; j++ )
1085 msg_Err( p_demux, " stream[%d]: type=%d class=%d stream_type=0x%x lang=%s charset=%d",
1086 j,
1087 p_item->p_stream[j].i_type,
1088 p_item->p_stream[j].i_class,
1089 p_item->p_stream[j].i_stream_type,
1090 p_item->p_stream[j].psz_language,
1091 p_item->p_stream[j].i_charset );
1092 }
1093
1094 for( int i = 0; i < p_mpls->i_sub_path; i++ )
1095 {
1096 bd_mpls_sub_path_t *p_sub = &p_mpls->p_sub_path[i];
1097
1098 msg_Err( p_demux, "SUB_PATH[%d] type=%d repeat=%d item=%d",
1099 i, p_sub->i_type, p_sub->b_repeat, p_sub->i_item );
1100 }
1101
1102 for( int i = 0; i < p_mpls->i_mark; i++ )
1103 {
1104 bd_mpls_mark_t *p_mark = &p_mpls->p_mark[i];
1105
1106 msg_Err( p_demux, "M[%d] t=%d play_item_id=%d time=%d entry_es_pid=%d",
1107 i, p_mark->i_type, p_mark->i_play_item_id, (int)p_mark->i_time, p_mark->i_entry_es_pid );
1108 }
1109 #endif
1110
1111 /* */
1112 TAB_APPEND( p_sys->i_mpls, p_sys->pp_mpls, p_mpls );
1113
1114 /* */
1115 block_Release( p_block );
1116 return;
1117
1118 error:
1119 msg_Err( p_demux, "Failed loading %s", psz_name );
1120 if( p_block )
1121 block_Release( p_block );
1122 }
1123
1124 /* */
1125 static int FilterClpiLong( const char *psz_name )
1126 {
1127 return strlen( psz_name ) == strlen( "xxxxx.clpi" ) &&
1128 !strcmp( &psz_name[5], ".clpi" );
1129 }
1130 static int FilterClpiShort( const char *psz_name )
1131 {
1132 return strlen( psz_name ) == strlen( "xxxxx.CPI" ) &&
1133 !strcmp( &psz_name[5], ".CPI" );
1134 }
1135
1136 static void LoadClpi( demux_t *p_demux, const char *psz_name, int i_id )
1137 {
1138 demux_sys_t *p_sys = p_demux->p_sys;
1139
1140 #if defined(BD_DEBUG)
1141 msg_Err( p_demux, "Loading %s", psz_name );
1142 #endif
1143
1144 block_t *p_block = LoadBlock( p_demux, psz_name );
1145 if( !p_block )
1146 goto error;
1147
1148 /* */
1149 bd_clpi_t *p_clpi = malloc( sizeof(*p_clpi) );
1150 if( !p_clpi )
1151 goto error;
1152
1153 /* */
1154 bs_t s;
1155 bs_init( &s, p_block->p_buffer, p_block->i_buffer );
1156
1157 if( bd_clpi_Parse( p_clpi, &s, i_id ) )
1158 goto error;
1159
1160 #if defined(BD_DEBUG)
1161 msg_Err( p_demux, "CLPI: id=%d", p_clpi->i_id );
1162 msg_Err( p_demux, "CLPI: STC=%d", p_clpi->i_stc );
1163 for( int i = 0; i < p_clpi->i_stc; i++ )
1164 msg_Err( p_demux, " STC[%d] pcr_pid=%d packet=%d start=%d end=%d",
1165 i, p_clpi->p_stc[i].i_pcr_pid, (int)p_clpi->p_stc[i].i_packet,
1166 (int)p_clpi->p_stc[i].i_start, (int)p_clpi->p_stc[i].i_end );
1167 msg_Err( p_demux, "CLPI: Stream=%d", p_clpi->i_stream );
1168 for( int i = 0; i < p_clpi->i_stream; i++ )
1169 msg_Err( p_demux, " Stream[%d] pid=%d type=0x%x",
1170 i, p_clpi->p_stream[i].i_pid, p_clpi->p_stream[i].i_type );
1171 msg_Err( p_demux, "CLPI: Ep Map=%d", p_clpi->i_ep_map );
1172 for( int i = 0; i < p_clpi->i_ep_map; i++ )
1173 {
1174 const bd_clpi_ep_map_t *p_ep_map = &p_clpi->p_ep_map[i];
1175 msg_Err( p_demux, " Ep Map[%d] pid=%d type=0x%x entry_point=%d",
1176 i, p_ep_map->i_pid, p_ep_map->i_type, p_ep_map->i_ep );
1177 for( int j = 0; j < p_ep_map->i_ep; j++ )
1178 {
1179 msg_Err( p_demux, " Ep[%d] packet=%d pts=%d",
1180 j, (int)p_ep_map->p_ep[j].i_packet, (int)p_ep_map->p_ep[j].i_pts );
1181 }
1182 }
1183 #endif
1184
1185 /* */
1186 TAB_APPEND( p_sys->i_clpi, p_sys->pp_clpi, p_clpi );
1187
1188 /* */
1189 block_Release( p_block );
1190 return;
1191
1192 error:
1193 msg_Err( p_demux, "Failed loading %s", psz_name );
1194 if( p_block )
1195 block_Release( p_block );
1196 }
1197
1198 /* */
1199 static int ScanSort( const char **ppsz_a, const char **ppsz_b )
1200 {
1201 return strcmp( *ppsz_a, *ppsz_b );
1202 }
1203
1204 static int Load( demux_t *p_demux,
1205 const char *psz_dir,
1206 int (*pf_filter)( const char * ),
1207 void (*pf_load)( demux_t *p_demux, const char *psz_name, int i_id ) )
1208 {
1209 char *psz_playlist;
1210 if( asprintf( &psz_playlist, "%s/%s", p_demux->p_sys->psz_base, psz_dir ) < 0 )
1211 return VLC_EGENERIC;
1212
1213 char **ppsz_list;
1214
1215 int i_list = vlc_scandir( psz_playlist, &ppsz_list, pf_filter, ScanSort );
1216
1217 for( int i = 0; i < i_list; i++ )
1218 {
1219 char *psz_file = ppsz_list[i];
1220 if( !psz_file )
1221 break;
1222
1223 char *psz_name;
1224 if( asprintf( &psz_name, "%s/%s/%s", p_demux->p_sys->psz_base, psz_dir, psz_file ) >= 0)
1225 {
1226 const int i_id = strtol( psz_file, NULL, 10 );
1227 pf_load( p_demux, psz_name, i_id );
1228 free( psz_name );
1229 }
1230 free( psz_file );
1231 }
1232 free( ppsz_list );
1233
1234 free( psz_playlist );
1235 return VLC_SUCCESS;
1236 }
1237
1238 static int LoadPlaylist( demux_t *p_demux )
1239 {
1240 return Load( p_demux, "PLAYLIST",
1241 p_demux->p_sys->b_shortname ? FilterMplsShort : FilterMplsLong, LoadMpls );
1242 }
1243 static int LoadClip( demux_t *p_demux )
1244 {
1245 return Load( p_demux, "CLIPINF",
1246 p_demux->p_sys->b_shortname ? FilterClpiShort : FilterClpiLong, LoadClpi );
1247 }
1248
1249 /* */
1250 struct es_out_sys_t
1251 {
1252 demux_t *p_demux;
1253 };
1254
1255 static es_out_id_t *EsOutAdd( es_out_t *p_out, const es_format_t *p_fmt )
1256 {
1257 demux_t *p_demux = p_out->p_sys->p_demux;
1258 const bd_mpls_t *p_mpls = p_demux->p_sys->pp_mpls[p_demux->info.i_title];
1259 const bd_mpls_play_item_t *p_item = &p_mpls->p_play_item[p_demux->p_sys->i_play_item];
1260
1261 es_format_t fmt;
1262
1263 es_format_Copy( &fmt, p_fmt );
1264 fmt.i_priority = -2;
1265
1266 for( int i = 0; i < p_item->i_stream; i++ )
1267 {
1268 const bd_mpls_stream_t *p_stream = &p_item->p_stream[i];
1269 if( p_stream->i_type != BD_MPLS_STREAM_TYPE_PLAY_ITEM ||
1270 p_stream->play_item.i_pid != fmt.i_id )
1271 continue;
1272
1273 /* TODO improved priority for higher quality stream ?
1274 * if so, extending stream attributes parsing might be a good idea
1275 */
1276 fmt.i_priority = 0;
1277
1278 #if 0
1279 /* Useless, and beside not sure it is the right thing to do */
1280 free( fmt.psz_description );
1281 switch( p_stream->i_class )
1282 {
1283 case BD_MPLS_STREAM_CLASS_SECONDARY_AUDIO:
1284 fmt.psz_description = strdup( "Secondary audio" );
1285 break;
1286 default:
1287 fmt.psz_description = NULL;
1288 break;
1289 }
1290 #endif
1291
1292 //msg_Err( p_demux, "Found ref for stream pid %d", fmt.i_id );
1293 if( *p_stream->psz_language && ( !fmt.psz_language || *fmt.psz_language == '\0' ) )
1294 {
1295 free( fmt.psz_language );
1296 fmt.psz_language = strdup( p_stream->psz_language );
1297 }
1298 switch( p_stream->i_charset )
1299 {
1300 /* TODO add all values */
1301 default:
1302 break;
1303 }
1304 break;
1305 }
1306 if( fmt.i_priority < 0 )
1307 msg_Dbg( p_demux, "Hidding one stream (pid=%d)", fmt.i_id );
1308
1309 /* */
1310 es_out_id_t *p_es = es_out_Add( p_demux->out, &fmt );
1311
1312 es_format_Clean( &fmt );
1313 return p_es;
1314 }
1315 static int EsOutSend( es_out_t *p_out, es_out_id_t *p_es, block_t *p_block )
1316 {
1317 return es_out_Send( p_out->p_sys->p_demux->out, p_es, p_block );
1318 }
1319 static void EsOutDel( es_out_t *p_out, es_out_id_t *p_es )
1320 {
1321 es_out_Del( p_out->p_sys->p_demux->out, p_es );
1322 }
1323 static int EsOutControl( es_out_t *p_out, int i_query, va_list args )
1324 {
1325 return es_out_vaControl( p_out->p_sys->p_demux->out, i_query, args );
1326 }
1327 static void EsOutDestroy( es_out_t *p_out )
1328 {
1329 free( p_out->p_sys );
1330 free( p_out );
1331 }
1332
1333 static es_out_t *EsOutNew( demux_t *p_demux )
1334 {
1335 es_out_t *p_out = malloc( sizeof(*p_out) );
1336 es_out_sys_t *p_sys;
1337
1338 if( !p_out )
1339 return NULL;
1340
1341 p_out->pf_add = EsOutAdd;
1342 p_out->pf_send = EsOutSend;
1343 p_out->pf_del = EsOutDel;
1344 p_out->pf_control = EsOutControl;
1345 p_out->pf_destroy = EsOutDestroy;
1346
1347 p_out->p_sys = p_sys = malloc( sizeof(*p_sys) );
1348 if( !p_sys )
1349 {
1350 free( p_out );
1351 return NULL;
1352 }
1353 p_sys->p_demux = p_demux;
1354
1355 return p_out;
1356 }
1357