]> git.sesse.net Git - vlc/blob - modules/demux/avformat/demux.c
98d857cbbfb2d3030f2ac54c7f1b89be43b47957
[vlc] / modules / demux / avformat / demux.c
1 /*****************************************************************************
2  * demux.c: demuxer using ffmpeg (libavformat).
3  *****************************************************************************
4  * Copyright (C) 2004-2009 the VideoLAN team
5  * $Id$
6  *
7  * Authors: Laurent Aimar <fenrir@via.ecp.fr>
8  *          Gildas Bazin <gbazin@videolan.org>
9  *
10  * This program is free software; you can redistribute it and/or modify
11  * it under the terms of the GNU General Public License as published by
12  * the Free Software Foundation; either version 2 of the License, or
13  * (at your option) any later version.
14  *
15  * This program is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  * GNU General Public License for more details.
19  *
20  * You should have received a copy of the GNU General Public License
21  * along with this program; if not, write to the Free Software
22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
23  *****************************************************************************/
24
25 /*****************************************************************************
26  * Preamble
27  *****************************************************************************/
28
29 #ifdef HAVE_CONFIG_H
30 # include "config.h"
31 #endif
32
33 #include <vlc_common.h>
34 #include <vlc_demux.h>
35 #include <vlc_stream.h>
36 #include <vlc_meta.h>
37 #include <vlc_input.h>
38 #include <vlc_charset.h>
39 #include <vlc_avcodec.h>
40
41 /* ffmpeg header */
42 #if defined(HAVE_LIBAVFORMAT_AVFORMAT_H)
43 #   include <libavformat/avformat.h>
44 #elif defined(HAVE_FFMPEG_AVFORMAT_H)
45 #   include <ffmpeg/avformat.h>
46 #endif
47
48 #include "../../codec/avcodec/avcodec.h"
49 #include "avformat.h"
50 #include "../xiph.h"
51 #include "../vobsub.h"
52
53 //#define AVFORMAT_DEBUG 1
54
55 /* Version checking */
56 #if defined(HAVE_FFMPEG_AVFORMAT_H) || defined(HAVE_LIBAVFORMAT_AVFORMAT_H)
57
58 #if (LIBAVCODEC_VERSION_INT >= ((51<<16)+(50<<8)+0) )
59 #   define HAVE_FFMPEG_CODEC_ATTACHMENT 1
60 #endif
61
62 #if (LIBAVFORMAT_VERSION_INT >= ((52<<16)+(15<<8)+0) )
63 #   define HAVE_FFMPEG_CHAPTERS 1
64 #endif
65
66 /*****************************************************************************
67  * demux_sys_t: demux descriptor
68  *****************************************************************************/
69 struct demux_sys_t
70 {
71     ByteIOContext   io;
72     int             io_buffer_size;
73     uint8_t        *io_buffer;
74
75     AVInputFormat  *fmt;
76     AVFormatContext *ic;
77     URLContext     url;
78     URLProtocol    prot;
79
80     int             i_tk;
81     es_out_id_t     **tk;
82
83     int64_t     i_pcr;
84     int64_t     i_pcr_inc;
85     int         i_pcr_tk;
86
87     unsigned    i_ssa_order;
88
89     int                i_attachments;
90     input_attachment_t **attachments;
91
92     /* Only one title with seekpoints possible atm. */
93     input_title_t *p_title;
94 };
95
96 /*****************************************************************************
97  * Local prototypes
98  *****************************************************************************/
99 static int Demux  ( demux_t *p_demux );
100 static int Control( demux_t *p_demux, int i_query, va_list args );
101
102 static int IORead( void *opaque, uint8_t *buf, int buf_size );
103 static int64_t IOSeek( void *opaque, int64_t offset, int whence );
104
105 static block_t *BuildSsaFrame( const AVPacket *p_pkt, unsigned i_order );
106 static void UpdateSeekPoint( demux_t *p_demux, int64_t i_time );
107
108 /*****************************************************************************
109  * Open
110  *****************************************************************************/
111 int OpenDemux( vlc_object_t *p_this )
112 {
113     demux_t       *p_demux = (demux_t*)p_this;
114     demux_sys_t   *p_sys;
115     AVProbeData   pd;
116     AVInputFormat *fmt;
117     unsigned int  i;
118     int64_t       i_start_time = -1;
119     bool          b_can_seek;
120
121     /* Init Probe data */
122     pd.filename = p_demux->psz_path;
123     if( ( pd.buf_size = stream_Peek( p_demux->s, &pd.buf, 2048 + 213 ) ) <= 0 )
124     {
125         msg_Warn( p_demux, "cannot peek" );
126         return VLC_EGENERIC;
127     }
128
129     vlc_avcodec_lock();
130     av_register_all(); /* Can be called several times */
131     vlc_avcodec_unlock();
132
133     /* Guess format */
134     if( !( fmt = av_probe_input_format( &pd, 1 ) ) )
135     {
136         msg_Dbg( p_demux, "couldn't guess format" );
137         return VLC_EGENERIC;
138     }
139
140     /* Don't try to handle MPEG unless forced */
141     if( !p_demux->b_force &&
142         ( !strcmp( fmt->name, "mpeg" ) ||
143           !strcmp( fmt->name, "vcd" ) ||
144           !strcmp( fmt->name, "vob" ) ||
145           !strcmp( fmt->name, "mpegts" ) ||
146           /* libavformat's redirector won't work */
147           !strcmp( fmt->name, "redir" ) ||
148           !strcmp( fmt->name, "sdp" ) ) )
149     {
150         return VLC_EGENERIC;
151     }
152
153     /* Don't trigger false alarms on bin files */
154     if( !p_demux->b_force && !strcmp( fmt->name, "psxstr" ) )
155     {
156         int i_len;
157
158         if( !p_demux->psz_path ) return VLC_EGENERIC;
159
160         i_len = strlen( p_demux->psz_path );
161         if( i_len < 4 ) return VLC_EGENERIC;
162
163         if( strcasecmp( &p_demux->psz_path[i_len - 4], ".str" ) &&
164             strcasecmp( &p_demux->psz_path[i_len - 4], ".xai" ) &&
165             strcasecmp( &p_demux->psz_path[i_len - 3], ".xa" ) )
166         {
167             return VLC_EGENERIC;
168         }
169     }
170
171     msg_Dbg( p_demux, "detected format: %s", fmt->name );
172
173     /* Fill p_demux fields */
174     p_demux->pf_demux = Demux;
175     p_demux->pf_control = Control;
176     p_demux->p_sys = p_sys = malloc( sizeof( demux_sys_t ) );
177     p_sys->ic = 0;
178     p_sys->fmt = fmt;
179     p_sys->i_tk = 0;
180     p_sys->tk = NULL;
181     p_sys->i_pcr_tk = -1;
182     p_sys->i_pcr = -1;
183     p_sys->i_ssa_order = 0;
184     TAB_INIT( p_sys->i_attachments, p_sys->attachments);
185     p_sys->p_title = NULL;
186
187     /* Create I/O wrapper */
188     p_sys->io_buffer_size = 32768;  /* FIXME */
189     p_sys->io_buffer = malloc( p_sys->io_buffer_size );
190     p_sys->url.priv_data = p_demux;
191     p_sys->url.prot = &p_sys->prot;
192     p_sys->url.prot->name = "VLC I/O wrapper";
193     p_sys->url.prot->url_open = 0;
194     p_sys->url.prot->url_read =
195                     (int (*) (URLContext *, unsigned char *, int))IORead;
196     p_sys->url.prot->url_write = 0;
197     p_sys->url.prot->url_seek =
198                     (int64_t (*) (URLContext *, int64_t, int))IOSeek;
199     p_sys->url.prot->url_close = 0;
200     p_sys->url.prot->next = 0;
201     init_put_byte( &p_sys->io, p_sys->io_buffer, p_sys->io_buffer_size,
202                    0, &p_sys->url, IORead, NULL, IOSeek );
203
204     stream_Control( p_demux->s, STREAM_CAN_SEEK, &b_can_seek );
205     if( !b_can_seek )
206     {
207        /* Tell avformat that input is stream, so it doesn't get stuck
208        when trying av_find_stream_info() trying to seek all the wrong places
209        init_put_byte defaults io.is_streamed=0, so thats why we set them after it
210        */
211        p_sys->url.is_streamed = 1;
212        p_sys->io.is_streamed = 1;
213     }
214
215
216     /* Open it */
217     if( av_open_input_stream( &p_sys->ic, &p_sys->io, p_demux->psz_path,
218                               p_sys->fmt, NULL ) )
219     {
220         msg_Err( p_demux, "av_open_input_stream failed" );
221         CloseDemux( p_this );
222         return VLC_EGENERIC;
223     }
224
225     vlc_avcodec_lock(); /* avformat calls avcodec behind our back!!! */
226     if( av_find_stream_info( p_sys->ic ) < 0 )
227     {
228         msg_Warn( p_demux, "av_find_stream_info failed" );
229     }
230     vlc_avcodec_unlock();
231
232     for( i = 0; i < p_sys->ic->nb_streams; i++ )
233     {
234         AVStream *s = p_sys->ic->streams[i];
235         AVCodecContext *cc = s->codec;
236
237         es_out_id_t  *es;
238         es_format_t  fmt;
239         vlc_fourcc_t fcc;
240         const char *psz_type = "unknown";
241
242         if( !GetVlcFourcc( cc->codec_id, NULL, &fcc, NULL ) )
243             fcc = VLC_FOURCC( 'u', 'n', 'd', 'f' );
244
245         switch( cc->codec_type )
246         {
247         case CODEC_TYPE_AUDIO:
248             es_format_Init( &fmt, AUDIO_ES, fcc );
249             fmt.i_bitrate = cc->bit_rate;
250             fmt.audio.i_channels = cc->channels;
251             fmt.audio.i_rate = cc->sample_rate;
252 #if LIBAVCODEC_VERSION_INT < ((52<<16)+(0<<8)+0)
253             fmt.audio.i_bitspersample = cc->bits_per_sample;
254 #else
255             fmt.audio.i_bitspersample = cc->bits_per_coded_sample;
256 #endif
257             fmt.audio.i_blockalign = cc->block_align;
258             psz_type = "audio";
259             break;
260
261         case CODEC_TYPE_VIDEO:
262             es_format_Init( &fmt, VIDEO_ES, fcc );
263
264             /* Special case for raw video data */
265             if( cc->codec_id == CODEC_ID_RAWVIDEO )
266             {
267                 msg_Dbg( p_demux, "raw video, pixel format: %i", cc->pix_fmt );
268                 if( GetVlcChroma( &fmt.video, cc->pix_fmt ) != VLC_SUCCESS)
269                 {
270                     msg_Err( p_demux, "was unable to find a FourCC match for raw video" );
271                 }
272                 else
273                     fmt.i_codec = fmt.video.i_chroma;
274             }
275
276             fmt.video.i_width = cc->width;
277             fmt.video.i_height = cc->height;
278             if( cc->palctrl )
279             {
280                 fmt.video.p_palette = malloc( sizeof(video_palette_t) );
281                 *fmt.video.p_palette = *(video_palette_t *)cc->palctrl;
282             }
283             psz_type = "video";
284             fmt.video.i_frame_rate = cc->time_base.den;
285             fmt.video.i_frame_rate_base = cc->time_base.num;
286             break;
287
288         case CODEC_TYPE_SUBTITLE:
289             es_format_Init( &fmt, SPU_ES, fcc );
290             if( strncmp( p_sys->ic->iformat->name, "matroska", 8 ) == 0 &&
291                 cc->codec_id == CODEC_ID_DVD_SUBTITLE &&
292                 cc->extradata != NULL &&
293                 cc->extradata_size > 0 )
294             {
295                 char *psz_start;
296                 char *psz_buf = malloc( cc->extradata_size + 1);
297                 if( psz_buf != NULL )
298                 {
299                     memcpy( psz_buf, cc->extradata , cc->extradata_size );
300                     psz_buf[cc->extradata_size] = '\0';
301
302                     psz_start = strstr( psz_buf, "size:" );
303                     if( psz_start &&
304                         vobsub_size_parse( psz_start,
305                                            &fmt.subs.spu.i_original_frame_width,
306                                            &fmt.subs.spu.i_original_frame_height ) == VLC_SUCCESS )
307                     {
308                         msg_Dbg( p_demux, "original frame size: %dx%d",
309                                  fmt.subs.spu.i_original_frame_width,
310                                  fmt.subs.spu.i_original_frame_height );
311                     }
312                     else
313                     {
314                         msg_Warn( p_demux, "reading original frame size failed" );
315                     }
316
317                     psz_start = strstr( psz_buf, "palette:" );
318                     if( psz_start &&
319                         vobsub_palette_parse( psz_start, &fmt.subs.spu.palette[1] ) == VLC_SUCCESS )
320                     {
321                         fmt.subs.spu.palette[0] =  0xBeef;
322                         msg_Dbg( p_demux, "vobsub palette read" );
323                     }
324                     else
325                     {
326                         msg_Warn( p_demux, "reading original palette failed" );
327                     }
328                     free( psz_buf );
329                 }
330             }
331
332             psz_type = "subtitle";
333             break;
334
335         default:
336             es_format_Init( &fmt, UNKNOWN_ES, 0 );
337 #ifdef HAVE_FFMPEG_CODEC_ATTACHMENT
338             if( cc->codec_type == CODEC_TYPE_ATTACHMENT )
339             {
340                 input_attachment_t *p_attachment;
341                 psz_type = "attachment";
342                 if( cc->codec_id == CODEC_ID_TTF )
343                 {
344                     p_attachment = vlc_input_attachment_New( s->filename, "application/x-truetype-font", NULL,
345                                              cc->extradata, (int)cc->extradata_size );
346                     TAB_APPEND( p_sys->i_attachments, p_sys->attachments, p_attachment );
347                 }
348                 else msg_Warn( p_demux, "unsupported attachment type in ffmpeg demux" );
349             }
350             break;
351 #endif
352
353             if( cc->codec_type == CODEC_TYPE_DATA )
354                 psz_type = "data";
355
356             msg_Warn( p_demux, "unsupported track type in ffmpeg demux" );
357             break;
358         }
359         fmt.psz_language = strdup( s->language );
360         if( s->disposition & AV_DISPOSITION_DEFAULT )
361             fmt.i_priority = 1000;
362
363 #ifdef HAVE_FFMPEG_CODEC_ATTACHMENT
364         if( cc->codec_type != CODEC_TYPE_ATTACHMENT )
365 #endif
366         {
367             const bool    b_ogg = !strcmp( p_sys->fmt->name, "ogg" );
368             const uint8_t *p_extra = cc->extradata;
369             unsigned      i_extra  = cc->extradata_size;
370
371             if( cc->codec_id == CODEC_ID_THEORA && b_ogg )
372             {
373                 unsigned pi_size[3];
374                 void     *pp_data[3];
375                 unsigned i_count;
376                 for( i_count = 0; i_count < 3; i_count++ )
377                 {
378                     if( i_extra < 2 )
379                         break;
380                     pi_size[i_count] = GetWBE( p_extra );
381                     pp_data[i_count] = (uint8_t*)&p_extra[2];
382                     if( i_extra < pi_size[i_count] + 2 )
383                         break;
384
385                     p_extra += 2 + pi_size[i_count];
386                     i_extra -= 2 + pi_size[i_count];
387                 }
388                 if( i_count > 0 && xiph_PackHeaders( &fmt.i_extra, &fmt.p_extra,
389                                                      pi_size, pp_data, i_count ) )
390                 {
391                     fmt.i_extra = 0;
392                     fmt.p_extra = NULL;
393                 }
394             }
395             else if( cc->codec_id == CODEC_ID_SPEEX && b_ogg )
396             {
397                 uint8_t p_dummy_comment[] = {
398                     0, 0, 0, 0,
399                     0, 0, 0, 0,
400                 };
401                 unsigned pi_size[2];
402                 void     *pp_data[2];
403
404                 pi_size[0] = i_extra;
405                 pp_data[0] = (uint8_t*)p_extra;
406
407                 pi_size[1] = sizeof(p_dummy_comment);
408                 pp_data[1] = p_dummy_comment;
409
410                 if( pi_size[0] > 0 && xiph_PackHeaders( &fmt.i_extra, &fmt.p_extra,
411                                                         pi_size, pp_data, 2 ) )
412                 {
413                     fmt.i_extra = 0;
414                     fmt.p_extra = NULL;
415                 }
416             }
417             else if( cc->extradata_size > 0 )
418             {
419                 fmt.p_extra = malloc( i_extra );
420                 if( fmt.p_extra )
421                 {
422                     fmt.i_extra = i_extra;
423                     memcpy( fmt.p_extra, p_extra, i_extra );
424                 }
425             }
426         }
427         es = es_out_Add( p_demux->out, &fmt );
428         if( s->disposition & AV_DISPOSITION_DEFAULT )
429             es_out_Control( p_demux->out, ES_OUT_SET_ES_DEFAULT, es );
430         es_format_Clean( &fmt );
431
432         msg_Dbg( p_demux, "adding es: %s codec = %4.4s",
433                  psz_type, (char*)&fcc );
434         TAB_APPEND( p_sys->i_tk, p_sys->tk, es );
435     }
436     if( p_sys->ic->start_time != (int64_t)AV_NOPTS_VALUE )
437         i_start_time = p_sys->ic->start_time * 1000000 / AV_TIME_BASE;
438
439     msg_Dbg( p_demux, "AVFormat supported stream" );
440     msg_Dbg( p_demux, "    - format = %s (%s)",
441              p_sys->fmt->name, p_sys->fmt->long_name );
442     msg_Dbg( p_demux, "    - start time = %"PRId64, i_start_time );
443     msg_Dbg( p_demux, "    - duration = %"PRId64,
444              ( p_sys->ic->duration != (int64_t)AV_NOPTS_VALUE ) ?
445              p_sys->ic->duration * 1000000 / AV_TIME_BASE : -1 );
446
447 #ifdef HAVE_FFMPEG_CHAPTERS
448     if( p_sys->ic->nb_chapters > 0 )
449         p_sys->p_title = vlc_input_title_New();
450     for( i = 0; i < p_sys->ic->nb_chapters; i++ )
451     {
452         seekpoint_t *s = vlc_seekpoint_New();
453
454         if( p_sys->ic->chapters[i]->title )
455         {
456             s->psz_name = strdup( p_sys->ic->chapters[i]->title );
457             EnsureUTF8( s->psz_name );
458             msg_Dbg( p_demux, "    - chapter %d: %s", i, s->psz_name );
459         }
460         s->i_time_offset = p_sys->ic->chapters[i]->start * 1000000 *
461             p_sys->ic->chapters[i]->time_base.num /
462             p_sys->ic->chapters[i]->time_base.den -
463             (i_start_time != -1 ? i_start_time : 0 );
464         TAB_APPEND( p_sys->p_title->i_seekpoint, p_sys->p_title->seekpoint, s );
465     }
466 #endif
467
468     return VLC_SUCCESS;
469 }
470
471 /*****************************************************************************
472  * Close
473  *****************************************************************************/
474 void CloseDemux( vlc_object_t *p_this )
475 {
476     demux_t     *p_demux = (demux_t*)p_this;
477     demux_sys_t *p_sys = p_demux->p_sys;
478
479     FREENULL( p_sys->tk );
480
481     if( p_sys->ic ) av_close_input_stream( p_sys->ic );
482
483     for( int i = 0; i < p_sys->i_attachments; i++ )
484         free( p_sys->attachments[i] );
485     TAB_CLEAN( p_sys->i_attachments, p_sys->attachments);
486
487     if( p_sys->p_title )
488         vlc_input_title_Delete( p_sys->p_title );
489
490     free( p_sys->io_buffer );
491     free( p_sys );
492 }
493
494 /*****************************************************************************
495  * Demux:
496  *****************************************************************************/
497 static int Demux( demux_t *p_demux )
498 {
499     demux_sys_t *p_sys = p_demux->p_sys;
500     AVPacket    pkt;
501     block_t     *p_frame;
502     int64_t     i_start_time;
503
504     /* Read a frame */
505     if( av_read_frame( p_sys->ic, &pkt ) )
506     {
507         return 0;
508     }
509     if( pkt.stream_index < 0 || pkt.stream_index >= p_sys->i_tk )
510     {
511         av_free_packet( &pkt );
512         return 1;
513     }
514     const AVStream *p_stream = p_sys->ic->streams[pkt.stream_index];
515     if( p_stream->time_base.den <= 0 )
516     {
517         msg_Warn( p_demux, "Invalid time base for the stream %d", pkt.stream_index );
518         av_free_packet( &pkt );
519         return 1;
520     }
521     if( p_stream->codec->codec_id == CODEC_ID_SSA )
522     {
523         p_frame = BuildSsaFrame( &pkt, p_sys->i_ssa_order++ );
524         if( !p_frame )
525         {
526             av_free_packet( &pkt );
527             return 1;
528         }
529     }
530     else
531     {
532         if( ( p_frame = block_New( p_demux, pkt.size ) ) == NULL )
533         {
534             av_free_packet( &pkt );
535             return 0;
536         }
537         memcpy( p_frame->p_buffer, pkt.data, pkt.size );
538     }
539
540     if( pkt.flags & PKT_FLAG_KEY )
541         p_frame->i_flags |= BLOCK_FLAG_TYPE_I;
542
543     i_start_time = ( p_sys->ic->start_time != (int64_t)AV_NOPTS_VALUE ) ?
544         ( p_sys->ic->start_time * 1000000 / AV_TIME_BASE )  : 0;
545
546     p_frame->i_dts = ( pkt.dts == (int64_t)AV_NOPTS_VALUE ) ?
547         VLC_TS_INVALID : (pkt.dts) * 1000000 *
548         p_stream->time_base.num /
549         p_stream->time_base.den - i_start_time + VLC_TS_0;
550     p_frame->i_pts = ( pkt.pts == (int64_t)AV_NOPTS_VALUE ) ?
551         VLC_TS_INVALID : (pkt.pts) * 1000000 *
552         p_stream->time_base.num /
553         p_stream->time_base.den - i_start_time + VLC_TS_0;
554     if( pkt.duration > 0 && p_frame->i_length <= 0 )
555         p_frame->i_length = pkt.duration * 1000000 *
556             p_stream->time_base.num /
557             p_stream->time_base.den;
558
559     if( pkt.dts != AV_NOPTS_VALUE && pkt.dts == pkt.pts &&
560         p_stream->codec->codec_type == CODEC_TYPE_VIDEO )
561     {
562         /* Add here notoriously bugged file formats/samples regarding PTS */
563         if( !strcmp( p_sys->fmt->name, "flv" ) )
564             p_frame->i_pts = VLC_TS_INVALID;
565     }
566 #ifdef AVFORMAT_DEBUG
567     msg_Dbg( p_demux, "tk[%d] dts=%"PRId64" pts=%"PRId64,
568              pkt.stream_index, p_frame->i_dts, p_frame->i_pts );
569 #endif
570
571     if( p_frame->i_dts > VLC_TS_INVALID  &&
572         ( pkt.stream_index == p_sys->i_pcr_tk || p_sys->i_pcr_tk < 0 ) )
573     {
574         p_sys->i_pcr_tk = pkt.stream_index;
575         p_sys->i_pcr = p_frame->i_dts;
576
577         es_out_Control( p_demux->out, ES_OUT_SET_PCR, (int64_t)p_sys->i_pcr );
578     }
579
580     es_out_Send( p_demux->out, p_sys->tk[pkt.stream_index], p_frame );
581
582     UpdateSeekPoint( p_demux, p_sys->i_pcr);
583     av_free_packet( &pkt );
584     return 1;
585 }
586
587 static void UpdateSeekPoint( demux_t *p_demux, int64_t i_time )
588 {
589     demux_sys_t *p_sys = p_demux->p_sys;
590     int i;
591
592     if( !p_sys->p_title )
593         return;
594
595     for( i = 0; i < p_sys->p_title->i_seekpoint; i++ )
596     {
597         if( i_time < p_sys->p_title->seekpoint[i]->i_time_offset )
598             break;
599     }
600     i--;
601
602     if( i != p_demux->info.i_seekpoint && i >= 0 )
603     {
604         p_demux->info.i_seekpoint = i;
605         p_demux->info.i_update |= INPUT_UPDATE_SEEKPOINT;
606     }
607 }
608
609 static block_t *BuildSsaFrame( const AVPacket *p_pkt, unsigned i_order )
610 {
611     if( p_pkt->size <= 0 )
612         return NULL;
613
614     char buffer[256];
615     const size_t i_buffer_size = __MIN( sizeof(buffer) - 1, p_pkt->size );
616     memcpy( buffer, p_pkt->data, i_buffer_size );
617     buffer[i_buffer_size] = '\0';
618
619     /* */
620     int i_layer;
621     int h0, m0, s0, c0;
622     int h1, m1, s1, c1;
623     int i_position = 0;
624     if( sscanf( buffer, "Dialogue: %d,%d:%d:%d.%d,%d:%d:%d.%d,%n", &i_layer,
625                 &h0, &m0, &s0, &c0, &h1, &m1, &s1, &c1, &i_position ) < 9 )
626         return NULL;
627     if( i_position <= 0 || i_position >= i_buffer_size )
628         return NULL;
629
630     char *p;
631     if( asprintf( &p, "%u,%d,%.*s", i_order, i_layer, p_pkt->size - i_position, p_pkt->data + i_position ) < 0 )
632         return NULL;
633
634     block_t *p_frame = block_heap_Alloc( p, p, strlen(p) + 1 );
635     if( p_frame )
636         p_frame->i_length = CLOCK_FREQ * ((h1 - h1) * 3600 +
637                                           (m1-m0) * 60 +
638                                           (s1-s0) * 1) +
639                             CLOCK_FREQ * (c1-c0) / 100;
640     return p_frame;
641 }
642
643 /*****************************************************************************
644  * Control:
645  *****************************************************************************/
646 static int Control( demux_t *p_demux, int i_query, va_list args )
647 {
648     demux_sys_t *p_sys = p_demux->p_sys;
649     double f, *pf;
650     int64_t i64, *pi64;
651
652     switch( i_query )
653     {
654         case DEMUX_GET_POSITION:
655             pf = (double*) va_arg( args, double* ); *pf = 0.0;
656             i64 = stream_Size( p_demux->s );
657             if( i64 > 0 )
658             {
659                 double current = stream_Tell( p_demux->s );
660                 *pf = current / (double)i64;
661             }
662
663             if( (p_sys->ic->duration != (int64_t)AV_NOPTS_VALUE) && (p_sys->i_pcr > 0) )
664             {
665                 *pf = (double)p_sys->i_pcr / (double)p_sys->ic->duration;
666             }
667
668             return VLC_SUCCESS;
669
670         case DEMUX_SET_POSITION:
671             f = (double) va_arg( args, double );
672             if( p_sys->i_pcr > 0 )
673             {
674                 i64 = p_sys->ic->duration * f;
675                 if( p_sys->ic->start_time != (int64_t)AV_NOPTS_VALUE )
676                     i64 += p_sys->ic->start_time;
677
678                 msg_Warn( p_demux, "DEMUX_SET_POSITION: %"PRId64, i64 );
679
680                 /* If we have a duration, we prefer to seek by time
681                    but if we don't, or if the seek fails, try BYTE seeking */
682                 if( p_sys->ic->duration == (int64_t)AV_NOPTS_VALUE ||
683                     (av_seek_frame( p_sys->ic, -1, i64, 0 ) < 0) )
684                 {
685                     int64_t i_size = stream_Size( p_demux->s );
686                     i64 = (i_size * f);
687
688                     msg_Warn( p_demux, "DEMUX_SET_BYTE_POSITION: %"PRId64, i64 );
689                     if( av_seek_frame( p_sys->ic, -1, i64, AVSEEK_FLAG_BYTE ) < 0 )
690                         return VLC_EGENERIC;
691                 }
692                 else
693                 {
694                     UpdateSeekPoint( p_demux, i64 );
695                 }
696                 p_sys->i_pcr = -1; /* Invalidate time display */
697             }
698             return VLC_SUCCESS;
699
700         case DEMUX_GET_LENGTH:
701             pi64 = (int64_t*)va_arg( args, int64_t * );
702             if( p_sys->ic->duration != (int64_t)AV_NOPTS_VALUE )
703                 *pi64 = p_sys->ic->duration * 1000000 / AV_TIME_BASE;
704             else
705                 *pi64 = 0;
706             return VLC_SUCCESS;
707
708         case DEMUX_GET_TIME:
709             pi64 = (int64_t*)va_arg( args, int64_t * );
710             *pi64 = p_sys->i_pcr;
711             return VLC_SUCCESS;
712
713         case DEMUX_SET_TIME:
714             i64 = (int64_t)va_arg( args, int64_t );
715             i64 = i64 *AV_TIME_BASE / 1000000;
716             if( p_sys->ic->start_time != (int64_t)AV_NOPTS_VALUE )
717                 i64 += p_sys->ic->start_time;
718
719             msg_Warn( p_demux, "DEMUX_SET_TIME: %"PRId64, i64 );
720
721             if( av_seek_frame( p_sys->ic, -1, i64, 0 ) < 0 )
722             {
723                 return VLC_EGENERIC;
724             }
725             p_sys->i_pcr = -1; /* Invalidate time display */
726             UpdateSeekPoint( p_demux, i64 );
727             return VLC_SUCCESS;
728
729         case DEMUX_HAS_UNSUPPORTED_META:
730         {
731             bool *pb_bool = (bool*)va_arg( args, bool* );
732             *pb_bool = true;
733             return VLC_SUCCESS;
734         }
735
736
737         case DEMUX_GET_META:
738         {
739             vlc_meta_t *p_meta = (vlc_meta_t*)va_arg( args, vlc_meta_t* );
740
741             if( !p_sys->ic->title[0] || !p_sys->ic->author[0] ||
742                 !p_sys->ic->copyright[0] || !p_sys->ic->comment[0] ||
743                 /*!p_sys->ic->album[0] ||*/ !p_sys->ic->genre[0] )
744             {
745                 return VLC_EGENERIC;
746             }
747
748             if( p_sys->ic->title[0] )
749                 vlc_meta_SetTitle( p_meta, p_sys->ic->title );
750             if( p_sys->ic->author[0] )
751                 vlc_meta_SetArtist( p_meta, p_sys->ic->author );
752             if( p_sys->ic->copyright[0] )
753                 vlc_meta_SetCopyright( p_meta, p_sys->ic->copyright );
754             if( p_sys->ic->comment[0] )
755                 vlc_meta_SetDescription( p_meta, p_sys->ic->comment );
756             if( p_sys->ic->genre[0] )
757                 vlc_meta_SetGenre( p_meta, p_sys->ic->genre );
758             return VLC_SUCCESS;
759         }
760
761         case DEMUX_GET_ATTACHMENTS:
762         {
763             input_attachment_t ***ppp_attach =
764                 (input_attachment_t***)va_arg( args, input_attachment_t*** );
765             int *pi_int = (int*)va_arg( args, int * );
766             int i;
767
768             if( p_sys->i_attachments <= 0 )
769                 return VLC_EGENERIC;
770
771             *pi_int = p_sys->i_attachments;;
772             *ppp_attach = malloc( sizeof(input_attachment_t**) * p_sys->i_attachments );
773             for( i = 0; i < p_sys->i_attachments; i++ )
774                 (*ppp_attach)[i] = vlc_input_attachment_Duplicate( p_sys->attachments[i] );
775             return VLC_SUCCESS;
776         }
777
778         case DEMUX_GET_TITLE_INFO:
779         {
780             input_title_t ***ppp_title = (input_title_t***)va_arg( args, input_title_t*** );
781             int *pi_int    = (int*)va_arg( args, int* );
782             int *pi_title_offset = (int*)va_arg( args, int* );
783             int *pi_seekpoint_offset = (int*)va_arg( args, int* );
784
785             if( !p_sys->p_title )
786                 return VLC_EGENERIC;
787
788             *pi_int = 1;
789             *ppp_title = malloc( sizeof( input_title_t**) );
790             (*ppp_title)[0] = vlc_input_title_Duplicate( p_sys->p_title );
791             *pi_title_offset = 0;
792             *pi_seekpoint_offset = 0;
793             return VLC_SUCCESS;
794         }
795         case DEMUX_SET_TITLE:
796         {
797             const int i_title = (int)va_arg( args, int );
798             if( !p_sys->p_title || i_title != 0 )
799                 return VLC_EGENERIC;
800             return VLC_SUCCESS;
801         }
802         case DEMUX_SET_SEEKPOINT:
803         {
804             const int i_seekpoint = (int)va_arg( args, int );
805             if( !p_sys->p_title )
806                 return VLC_EGENERIC;
807
808             i64 = p_sys->p_title->seekpoint[i_seekpoint]->i_time_offset *AV_TIME_BASE / 1000000;
809             if( p_sys->ic->start_time != (int64_t)AV_NOPTS_VALUE )
810                 i64 += p_sys->ic->start_time;
811
812             msg_Warn( p_demux, "DEMUX_SET_TIME: %"PRId64, i64 );
813
814             if( av_seek_frame( p_sys->ic, -1, i64, 0 ) < 0 )
815             {
816                 return VLC_EGENERIC;
817             }
818             p_sys->i_pcr = -1; /* Invalidate time display */
819             UpdateSeekPoint( p_demux, i64 );
820             return VLC_SUCCESS;
821         }
822
823
824         default:
825             return VLC_EGENERIC;
826     }
827 }
828
829 /*****************************************************************************
830  * I/O wrappers for libavformat
831  *****************************************************************************/
832 static int IORead( void *opaque, uint8_t *buf, int buf_size )
833 {
834     URLContext *p_url = opaque;
835     demux_t *p_demux = p_url->priv_data;
836     if( buf_size < 0 ) return -1;
837     int i_ret = stream_Read( p_demux->s, buf, buf_size );
838     return i_ret ? i_ret : -1;
839 }
840
841 static int64_t IOSeek( void *opaque, int64_t offset, int whence )
842 {
843     URLContext *p_url = opaque;
844     demux_t *p_demux = p_url->priv_data;
845     int64_t i_absolute;
846     int64_t i_size = stream_Size( p_demux->s );
847
848 #ifdef AVFORMAT_DEBUG
849     msg_Warn( p_demux, "IOSeek offset: %"PRId64", whence: %i", offset, whence );
850 #endif
851
852     switch( whence )
853     {
854 #ifdef AVSEEK_SIZE
855         case AVSEEK_SIZE:
856             return i_size;
857 #endif
858         case SEEK_SET:
859             i_absolute = (int64_t)offset;
860             break;
861         case SEEK_CUR:
862             i_absolute = stream_Tell( p_demux->s ) + (int64_t)offset;
863             break;
864         case SEEK_END:
865             i_absolute = i_size + (int64_t)offset;
866             break;
867         default:
868             return -1;
869
870     }
871
872     if( i_absolute < 0 )
873     {
874         msg_Dbg( p_demux, "Trying to seek before the beginning" );
875         return -1;
876     }
877
878     if( i_size > 0 && i_absolute >= i_size )
879     {
880         msg_Dbg( p_demux, "Trying to seek too far : EOF?" );
881         return -1;
882     }
883
884     if( stream_Seek( p_demux->s, i_absolute ) )
885     {
886         msg_Warn( p_demux, "we were not allowed to seek, or EOF " );
887         return -1;
888     }
889
890     return stream_Tell( p_demux->s );
891 }
892
893 #endif /* HAVE_LIBAVFORMAT_AVFORMAT_H */