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