2 Copyright (C) 2004 Michael Niedermayer <michaelni@gmx.at>
4 This program is free software; you can redistribute it and/or modify
5 it under the terms of the GNU General Public License as published by
6 the Free Software Foundation; either version 2 of the License, or
7 (at your option) any later version.
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 GNU General Public License for more details.
14 You should have received a copy of the GNU General Public License
15 along with this program; if not, write to the Free Software
16 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
21 // #include <unistd.h>
28 #include "stream/stream.h"
32 #include "libvo/sub.h"
34 #ifdef USE_LIBAVFORMAT_SO
35 #include <ffmpeg/avformat.h>
36 #include <ffmpeg/avutil.h>
37 #include <ffmpeg/opt.h>
46 #define PROBE_BUF_SIZE 2048
48 extern char *audio_lang
;
49 static unsigned int opt_probesize
= 0;
50 static unsigned int opt_analyzeduration
= 0;
51 static char *opt_format
;
52 static char *opt_cryptokey
;
55 m_option_t lavfdopts_conf
[] = {
56 {"probesize", &(opt_probesize
), CONF_TYPE_INT
, CONF_RANGE
, 32, INT_MAX
, NULL
},
57 {"format", &(opt_format
), CONF_TYPE_STRING
, 0, 0, 0, NULL
},
58 {"analyzeduration", &(opt_analyzeduration
), CONF_TYPE_INT
, CONF_RANGE
, 0, INT_MAX
, NULL
},
59 {"cryptokey", &(opt_cryptokey
), CONF_TYPE_STRING
, 0, 0, 0, NULL
},
60 {NULL
, NULL
, 0, 0, 0, 0, NULL
}
64 typedef struct lavf_priv_t
{
66 AVFormatContext
*avfc
;
72 int astreams
[MAX_A_STREAMS
];
73 int vstreams
[MAX_V_STREAMS
];
74 int sstreams
[MAX_S_STREAMS
];
78 extern void print_wave_header(WAVEFORMATEX
*h
, int verbose_level
);
79 extern void print_video_header(BITMAPINFOHEADER
*h
, int verbose_level
);
81 static const AVCodecTag mp_wav_tags
[] = {
82 { CODEC_ID_ADPCM_4XM
, MKTAG('4', 'X', 'M', 'A')},
83 { CODEC_ID_ADPCM_EA
, MKTAG('A', 'D', 'E', 'A')},
84 { CODEC_ID_ADPCM_IMA_WS
, MKTAG('A', 'I', 'W', 'S')},
85 { CODEC_ID_ADPCM_THP
, MKTAG('T', 'H', 'P', 'A')},
86 { CODEC_ID_AMR_NB
, MKTAG('n', 'b', 0, 0)},
87 { CODEC_ID_COOK
, MKTAG('c', 'o', 'o', 'k')},
88 { CODEC_ID_DSICINAUDIO
, MKTAG('D', 'C', 'I', 'A')},
89 { CODEC_ID_INTERPLAY_DPCM
, MKTAG('I', 'N', 'P', 'A')},
90 { CODEC_ID_MUSEPACK7
, MKTAG('M', 'P', 'C', ' ')},
91 { CODEC_ID_MUSEPACK8
, MKTAG('M', 'P', 'C', '8')},
92 { CODEC_ID_NELLYMOSER
, MKTAG('N', 'E', 'L', 'L')},
93 { CODEC_ID_PCM_S24BE
, MKTAG('i', 'n', '2', '4')},
94 { CODEC_ID_PCM_S16BE
, MKTAG('t', 'w', 'o', 's')},
95 { CODEC_ID_PCM_S8
, MKTAG('t', 'w', 'o', 's')},
96 { CODEC_ID_ROQ_DPCM
, MKTAG('R', 'o', 'Q', 'A')},
97 { CODEC_ID_SHORTEN
, MKTAG('s', 'h', 'r', 'n')},
98 { CODEC_ID_TTA
, MKTAG('T', 'T', 'A', '1')},
99 { CODEC_ID_WAVPACK
, MKTAG('W', 'V', 'P', 'K')},
100 { CODEC_ID_WESTWOOD_SND1
, MKTAG('S', 'N', 'D', '1')},
101 { CODEC_ID_XAN_DPCM
, MKTAG('A', 'x', 'a', 'n')},
105 const struct AVCodecTag
*mp_wav_taglists
[] = {codec_wav_tags
, mp_wav_tags
, 0};
107 static const AVCodecTag mp_bmp_tags
[] = {
108 { CODEC_ID_AMV
, MKTAG('A', 'M', 'V', 'V')},
109 { CODEC_ID_BETHSOFTVID
, MKTAG('B', 'E', 'T', 'H')},
110 { CODEC_ID_C93
, MKTAG('C', '9', '3', 'V')},
111 { CODEC_ID_DSICINVIDEO
, MKTAG('D', 'C', 'I', 'V')},
112 { CODEC_ID_DXA
, MKTAG('D', 'X', 'A', '1')},
113 { CODEC_ID_FLIC
, MKTAG('F', 'L', 'I', 'C')},
114 { CODEC_ID_IDCIN
, MKTAG('I', 'D', 'C', 'I')},
115 { CODEC_ID_INTERPLAY_VIDEO
, MKTAG('I', 'N', 'P', 'V')},
116 { CODEC_ID_ROQ
, MKTAG('R', 'o', 'Q', 'V')},
117 { CODEC_ID_THP
, MKTAG('T', 'H', 'P', 'V')},
118 { CODEC_ID_TIERTEXSEQVIDEO
, MKTAG('T', 'S', 'E', 'Q')},
119 { CODEC_ID_TXD
, MKTAG('T', 'X', 'D', 'V')},
120 { CODEC_ID_VMDVIDEO
, MKTAG('V', 'M', 'D', 'V')},
121 { CODEC_ID_WS_VQA
, MKTAG('V', 'Q', 'A', 'V')},
122 { CODEC_ID_XAN_WC3
, MKTAG('W', 'C', '3', 'V')},
123 { CODEC_ID_NUV
, MKTAG('N', 'U', 'V', '1')},
127 const struct AVCodecTag
*mp_bmp_taglists
[] = {codec_bmp_tags
, mp_bmp_tags
, 0};
129 static int mp_open(URLContext
*h
, const char *filename
, int flags
){
133 static int mp_read(URLContext
*h
, unsigned char *buf
, int size
){
134 stream_t
*stream
= (stream_t
*)h
->priv_data
;
137 if(stream_eof(stream
)) //needed?
139 ret
=stream_read(stream
, buf
, size
);
141 mp_msg(MSGT_HEADER
,MSGL_DBG2
,"%d=mp_read(%p, %p, %d), eof:%d\n", ret
, h
, buf
, size
, stream
->eof
);
145 static int mp_write(URLContext
*h
, unsigned char *buf
, int size
){
149 static offset_t
mp_seek(URLContext
*h
, offset_t pos
, int whence
){
150 stream_t
*stream
= (stream_t
*)h
->priv_data
;
152 mp_msg(MSGT_HEADER
,MSGL_DBG2
,"mp_seek(%p, %d, %d)\n", h
, (int)pos
, whence
);
153 if(whence
== SEEK_CUR
)
154 pos
+=stream_tell(stream
);
155 else if(whence
== SEEK_END
&& stream
->end_pos
> 0)
156 pos
+= stream
->end_pos
;
157 else if(whence
== SEEK_SET
)
158 pos
+= stream
->start_pos
;
159 else if(whence
== AVSEEK_SIZE
&& stream
->end_pos
> 0)
160 return stream
->end_pos
- stream
->start_pos
;
166 if(pos
<stream
->end_pos
&& stream
->eof
)
167 stream_reset(stream
);
168 if(stream_seek(stream
, pos
)==0)
171 return pos
- stream
->start_pos
;
174 static int mp_close(URLContext
*h
){
178 static URLProtocol mp_protocol
= {
187 static void list_formats(void) {
189 mp_msg(MSGT_DEMUX
, MSGL_INFO
, "Available lavf input formats:\n");
190 for (fmt
= first_iformat
; fmt
; fmt
= fmt
->next
)
191 mp_msg(MSGT_DEMUX
, MSGL_INFO
, "%15s : %s\n", fmt
->name
, fmt
->long_name
);
194 static int lavf_check_file(demuxer_t
*demuxer
){
196 uint8_t buf
[PROBE_BUF_SIZE
];
200 demuxer
->priv
=calloc(sizeof(lavf_priv_t
),1);
205 if(stream_read(demuxer
->stream
, buf
, PROBE_BUF_SIZE
)!=PROBE_BUF_SIZE
)
207 avpd
.filename
= demuxer
->stream
->url
;
209 avpd
.buf_size
= PROBE_BUF_SIZE
;
212 if (strcmp(opt_format
, "help") == 0) {
216 priv
->avif
= av_find_input_format(opt_format
);
218 mp_msg(MSGT_DEMUX
,MSGL_FATAL
,"Unknown lavf format %s\n", opt_format
);
221 mp_msg(MSGT_DEMUX
,MSGL_INFO
,"Forced lavf %s demuxer\n", priv
->avif
->long_name
);
222 return DEMUXER_TYPE_LAVF
;
224 priv
->avif
= av_probe_input_format(&avpd
, 1);
226 mp_msg(MSGT_HEADER
,MSGL_V
,"LAVF_check: no clue about this gibberish!\n");
229 mp_msg(MSGT_HEADER
,MSGL_V
,"LAVF_check: %s\n", priv
->avif
->long_name
);
231 return DEMUXER_TYPE_LAVF
;
234 static const char *preferred_list
[] = {
246 static int lavf_check_preferred_file(demuxer_t
*demuxer
){
247 if (lavf_check_file(demuxer
)) {
248 char **p
= preferred_list
;
249 lavf_priv_t
*priv
= demuxer
->priv
;
251 if (strcmp(*p
, priv
->avif
->name
) == 0)
252 return DEMUXER_TYPE_LAVF_PREFERRED
;
259 static uint8_t char2int(char c
) {
260 if (c
>= '0' && c
<= '9') return c
- '0';
261 if (c
>= 'a' && c
<= 'f') return c
- 'a' + 10;
262 if (c
>= 'A' && c
<= 'F') return c
- 'A' + 10;
266 static void parse_cryptokey(AVFormatContext
*avfc
, const char *str
) {
267 int len
= strlen(str
) / 2;
268 uint8_t *key
= av_mallocz(len
);
272 for (i
= 0; i
< len
; i
++, str
+= 2)
273 *key
++ = (char2int(str
[0]) << 4) | char2int(str
[1]);
276 static void handle_stream(demuxer_t
*demuxer
, AVFormatContext
*avfc
, int i
) {
277 lavf_priv_t
*priv
= demuxer
->priv
;
278 AVStream
*st
= avfc
->streams
[i
];
279 AVCodecContext
*codec
= st
->codec
;
282 switch(codec
->codec_type
){
283 case CODEC_TYPE_AUDIO
:{
284 WAVEFORMATEX
*wf
= calloc(sizeof(WAVEFORMATEX
) + codec
->extradata_size
, 1);
285 sh_audio_t
* sh_audio
;
286 if(priv
->audio_streams
>= MAX_A_STREAMS
)
288 sh_audio
=new_sh_audio(demuxer
, i
);
289 mp_msg(MSGT_DEMUX
, MSGL_INFO
, MSGTR_AudioID
, "lavf", i
);
292 priv
->astreams
[priv
->audio_streams
] = i
;
293 priv
->audio_streams
++;
294 // mp4a tag is used for all mp4 files no matter what they actually contain
295 if(codec
->codec_tag
== MKTAG('m', 'p', '4', 'a'))
297 if(codec
->codec_id
== CODEC_ID_ADPCM_IMA_AMV
)
298 codec
->codec_tag
= MKTAG('A','M','V','A');
299 if(!codec
->codec_tag
)
300 codec
->codec_tag
= av_codec_get_tag(mp_wav_taglists
, codec
->codec_id
);
301 wf
->wFormatTag
= codec
->codec_tag
;
302 wf
->nChannels
= codec
->channels
;
303 wf
->nSamplesPerSec
= codec
->sample_rate
;
304 wf
->nAvgBytesPerSec
= codec
->bit_rate
/8;
305 wf
->nBlockAlign
= codec
->block_align
? codec
->block_align
: 1;
306 wf
->wBitsPerSample
= codec
->bits_per_sample
;
307 wf
->cbSize
= codec
->extradata_size
;
308 if(codec
->extradata_size
)
309 memcpy(wf
+ 1, codec
->extradata
, codec
->extradata_size
);
311 sh_audio
->audio
.dwSampleSize
= codec
->block_align
;
312 if(codec
->frame_size
&& codec
->sample_rate
){
313 sh_audio
->audio
.dwScale
=codec
->frame_size
;
314 sh_audio
->audio
.dwRate
= codec
->sample_rate
;
316 sh_audio
->audio
.dwScale
= codec
->block_align
? codec
->block_align
*8 : 8;
317 sh_audio
->audio
.dwRate
= codec
->bit_rate
;
319 g
= ff_gcd(sh_audio
->audio
.dwScale
, sh_audio
->audio
.dwRate
);
320 sh_audio
->audio
.dwScale
/= g
;
321 sh_audio
->audio
.dwRate
/= g
;
322 // printf("sca:%d rat:%d fs:%d sr:%d ba:%d\n", sh_audio->audio.dwScale, sh_audio->audio.dwRate, codec->frame_size, codec->sample_rate, codec->block_align);
323 sh_audio
->ds
= demuxer
->audio
;
324 sh_audio
->format
= codec
->codec_tag
;
325 sh_audio
->channels
= codec
->channels
;
326 sh_audio
->samplerate
= codec
->sample_rate
;
327 sh_audio
->i_bps
= codec
->bit_rate
/8;
328 switch (codec
->codec_id
) {
329 case CODEC_ID_PCM_S8
:
330 case CODEC_ID_PCM_U8
:
331 sh_audio
->samplesize
= 1;
333 case CODEC_ID_PCM_S16LE
:
334 case CODEC_ID_PCM_S16BE
:
335 case CODEC_ID_PCM_U16LE
:
336 case CODEC_ID_PCM_U16BE
:
337 sh_audio
->samplesize
= 2;
339 case CODEC_ID_PCM_ALAW
:
340 sh_audio
->format
= 0x6;
342 case CODEC_ID_PCM_MULAW
:
343 sh_audio
->format
= 0x7;
346 if(mp_msg_test(MSGT_HEADER
,MSGL_V
) ) print_wave_header(sh_audio
->wf
, MSGL_V
);
347 if((audio_lang
&& st
->language
[0] && !strncmp(audio_lang
, st
->language
, 3))
348 || (demuxer
->audio
->id
== i
|| demuxer
->audio
->id
== -1)) {
349 demuxer
->audio
->id
= i
;
350 demuxer
->audio
->sh
= demuxer
->a_streams
[i
];
352 st
->discard
= AVDISCARD_ALL
;
355 case CODEC_TYPE_VIDEO
:{
356 sh_video_t
* sh_video
;
357 BITMAPINFOHEADER
*bih
;
358 if(priv
->video_streams
>= MAX_V_STREAMS
)
360 sh_video
=new_sh_video(demuxer
, i
);
361 mp_msg(MSGT_DEMUX
, MSGL_INFO
, MSGTR_VideoID
, "lavf", i
);
363 priv
->vstreams
[priv
->video_streams
] = i
;
364 priv
->video_streams
++;
365 bih
=calloc(sizeof(BITMAPINFOHEADER
) + codec
->extradata_size
,1);
367 if(!codec
->codec_tag
)
368 codec
->codec_tag
= av_codec_get_tag(mp_bmp_taglists
, codec
->codec_id
);
369 bih
->biSize
= sizeof(BITMAPINFOHEADER
) + codec
->extradata_size
;
370 bih
->biWidth
= codec
->width
;
371 bih
->biHeight
= codec
->height
;
372 bih
->biBitCount
= codec
->bits_per_sample
;
373 bih
->biSizeImage
= bih
->biWidth
* bih
->biHeight
* bih
->biBitCount
/8;
374 bih
->biCompression
= codec
->codec_tag
;
376 sh_video
->disp_w
= codec
->width
;
377 sh_video
->disp_h
= codec
->height
;
378 if (st
->time_base
.den
) { /* if container has time_base, use that */
379 sh_video
->video
.dwRate
= st
->time_base
.den
;
380 sh_video
->video
.dwScale
= st
->time_base
.num
;
382 sh_video
->video
.dwRate
= codec
->time_base
.den
;
383 sh_video
->video
.dwScale
= codec
->time_base
.num
;
385 sh_video
->fps
=av_q2d(st
->r_frame_rate
);
386 sh_video
->frametime
=1/av_q2d(st
->r_frame_rate
);
387 sh_video
->format
=bih
->biCompression
;
388 sh_video
->aspect
=codec
->width
* codec
->sample_aspect_ratio
.num
389 / (float)(codec
->height
* codec
->sample_aspect_ratio
.den
);
390 sh_video
->i_bps
=codec
->bit_rate
/8;
391 mp_msg(MSGT_DEMUX
,MSGL_DBG2
,"aspect= %d*%d/(%d*%d)\n",
392 codec
->width
, codec
->sample_aspect_ratio
.num
,
393 codec
->height
, codec
->sample_aspect_ratio
.den
);
395 sh_video
->ds
= demuxer
->video
;
396 if(codec
->extradata_size
)
397 memcpy(sh_video
->bih
+ 1, codec
->extradata
, codec
->extradata_size
);
398 if( mp_msg_test(MSGT_HEADER
,MSGL_V
) ) print_video_header(sh_video
->bih
, MSGL_V
);
406 if(demuxer
->video
->id
!= i
&& demuxer
->video
->id
!= -1)
407 st
->discard
= AVDISCARD_ALL
;
409 demuxer
->video
->id
= i
;
410 demuxer
->video
->sh
= demuxer
->v_streams
[i
];
414 case CODEC_TYPE_SUBTITLE
:{
416 if(priv
->sub_streams
>= MAX_S_STREAMS
)
418 /* only support text subtitles for now */
419 if(codec
->codec_id
!= CODEC_ID_TEXT
)
421 sh_sub
= new_sh_sub_sid(demuxer
, i
, priv
->sub_streams
);
422 mp_msg(MSGT_DEMUX
, MSGL_INFO
, MSGTR_SubtitleID
, "lavf", priv
->sub_streams
);
424 priv
->sstreams
[priv
->sub_streams
] = i
;
426 demuxer
->sub
->sh
= demuxer
->s_streams
[priv
->sub_streams
++];
430 st
->discard
= AVDISCARD_ALL
;
434 static demuxer_t
* demux_open_lavf(demuxer_t
*demuxer
){
435 AVFormatContext
*avfc
;
436 AVFormatParameters ap
;
438 lavf_priv_t
*priv
= demuxer
->priv
;
440 char mp_filename
[256]="mp:";
442 memset(&ap
, 0, sizeof(AVFormatParameters
));
444 stream_seek(demuxer
->stream
, 0);
446 register_protocol(&mp_protocol
);
448 avfc
= av_alloc_format_context();
451 parse_cryptokey(avfc
, opt_cryptokey
);
453 avfc
->flags
|= AVFMT_FLAG_GENPTS
;
455 avfc
->flags
|= AVFMT_FLAG_IGNIDX
;
457 ap
.prealloced_context
= 1;
459 opt
= av_set_int(avfc
, "probesize", opt_probesize
);
460 if(!opt
) mp_msg(MSGT_HEADER
,MSGL_ERR
, "demux_lavf, couldn't set option probesize to %u\n", opt_probesize
);
462 if(opt_analyzeduration
) {
463 opt
= av_set_int(avfc
, "analyzeduration", opt_analyzeduration
* AV_TIME_BASE
);
464 if(!opt
) mp_msg(MSGT_HEADER
,MSGL_ERR
, "demux_lavf, couldn't set option analyzeduration to %u\n", opt_analyzeduration
);
467 if(demuxer
->stream
->url
)
468 strncpy(mp_filename
+ 3, demuxer
->stream
->url
, sizeof(mp_filename
)-3);
470 strncpy(mp_filename
+ 3, "foobar.dummy", sizeof(mp_filename
)-3);
472 url_fopen(&priv
->pb
, mp_filename
, URL_RDONLY
);
474 ((URLContext
*)(priv
->pb
.opaque
))->priv_data
= demuxer
->stream
;
476 if(av_open_input_stream(&avfc
, &priv
->pb
, mp_filename
, priv
->avif
, &ap
)<0){
477 mp_msg(MSGT_HEADER
,MSGL_ERR
,"LAVF_header: av_open_input_stream() failed\n");
483 if(av_find_stream_info(avfc
) < 0){
484 mp_msg(MSGT_HEADER
,MSGL_ERR
,"LAVF_header: av_find_stream_info() failed\n");
488 if(avfc
->title
[0]) demux_info_add(demuxer
, "name" , avfc
->title
);
489 if(avfc
->author
[0]) demux_info_add(demuxer
, "author" , avfc
->author
);
490 if(avfc
->copyright
[0]) demux_info_add(demuxer
, "copyright", avfc
->copyright
);
491 if(avfc
->comment
[0]) demux_info_add(demuxer
, "comments" , avfc
->comment
);
492 if(avfc
->album
[0]) demux_info_add(demuxer
, "album" , avfc
->album
);
493 // if(avfc->year ) demux_info_add(demuxer, "year" , avfc->year );
494 // if(avfc->track ) demux_info_add(demuxer, "track" , avfc->track );
495 if(avfc
->genre
[0]) demux_info_add(demuxer
, "genre" , avfc
->genre
);
497 if(avfc
->nb_programs
) {
498 int p
, start
=0, found
=0;
501 for(p
=0; p
<avfc
->nb_programs
; p
++) {
502 if(avfc
->programs
[p
]->id
== ts_prog
) {
509 mp_msg(MSGT_HEADER
,MSGL_ERR
,"DEMUX_LAVF: program %d doesn't seem to be present\n", ts_prog
);
515 AVProgram
*program
= avfc
->programs
[p
];
516 mp_msg(MSGT_HEADER
,MSGL_INFO
,"LAVF: Program %d %s\n", program
->id
, (program
->name
? program
->name
: ""));
517 for(i
=0; i
<program
->nb_stream_indexes
; i
++)
518 handle_stream(demuxer
, avfc
, program
->stream_index
[i
]);
519 if(!priv
->cur_program
&& (demuxer
->video
->sh
|| demuxer
->audio
->sh
))
520 priv
->cur_program
= program
->id
;
521 p
= (p
+ 1) % avfc
->nb_programs
;
524 for(i
=0; i
<avfc
->nb_streams
; i
++)
525 handle_stream(demuxer
, avfc
, i
);
527 mp_msg(MSGT_HEADER
,MSGL_V
,"LAVF: %d audio and %d video streams found\n",priv
->audio_streams
,priv
->video_streams
);
528 mp_msg(MSGT_HEADER
,MSGL_V
,"LAVF: build %d\n", LIBAVFORMAT_BUILD
);
529 if(!priv
->audio_streams
) demuxer
->audio
->id
=-2; // nosound
530 // else if(best_audio > 0 && demuxer->audio->id == -1) demuxer->audio->id=best_audio;
531 if(!priv
->video_streams
){
532 if(!priv
->audio_streams
){
533 mp_msg(MSGT_HEADER
,MSGL_ERR
,"LAVF: no audio or video headers found - broken file?\n");
536 demuxer
->video
->id
=-2; // audio-only
537 } //else if (best_video > 0 && demuxer->video->id == -1) demuxer->video->id = best_video;
542 static int demux_lavf_fill_buffer(demuxer_t
*demux
, demux_stream_t
*dsds
){
543 lavf_priv_t
*priv
= demux
->priv
;
548 mp_msg(MSGT_DEMUX
,MSGL_DBG2
,"demux_lavf_fill_buffer()\n");
550 demux
->filepos
=stream_tell(demux
->stream
);
552 if(av_read_frame(priv
->avfc
, &pkt
) < 0)
555 id
= pkt
.stream_index
;
557 if(id
==demux
->audio
->id
){
561 ds
->sh
=demux
->a_streams
[id
];
562 mp_msg(MSGT_DEMUX
,MSGL_V
,"Auto-selected LAVF audio ID = %d\n",ds
->id
);
564 } else if(id
==demux
->video
->id
){
568 ds
->sh
=demux
->v_streams
[id
];
569 mp_msg(MSGT_DEMUX
,MSGL_V
,"Auto-selected LAVF video ID = %d\n",ds
->id
);
571 } else if(id
==demux
->sub
->id
){
576 av_free_packet(&pkt
);
580 if(0/*pkt.destruct == av_destruct_packet*/){
581 //ok kids, dont try this at home :)
582 dp
=malloc(sizeof(demux_packet_t
));
590 dp
=new_demux_packet(pkt
.size
);
591 memcpy(dp
->buffer
, pkt
.data
, pkt
.size
);
592 av_free_packet(&pkt
);
595 if(pkt
.pts
!= AV_NOPTS_VALUE
){
596 dp
->pts
=pkt
.pts
* av_q2d(priv
->avfc
->streams
[id
]->time_base
);
597 priv
->last_pts
= dp
->pts
* AV_TIME_BASE
;
599 dp
->endpts
= dp
->pts
+ pkt
.duration
* av_q2d(priv
->avfc
->streams
[id
]->time_base
);
601 dp
->pos
=demux
->filepos
;
602 dp
->flags
= !!(pkt
.flags
&PKT_FLAG_KEY
);
603 // append packet to DS stream:
604 ds_add_packet(ds
,dp
);
608 static void demux_seek_lavf(demuxer_t
*demuxer
, float rel_seek_secs
, float audio_delay
, int flags
){
609 lavf_priv_t
*priv
= demuxer
->priv
;
611 mp_msg(MSGT_DEMUX
,MSGL_DBG2
,"demux_seek_lavf(%p, %f, %f, %d)\n", demuxer
, rel_seek_secs
, audio_delay
, flags
);
613 if (flags
& 1) // absolute seek
614 priv
->last_pts
= priv
->avfc
->start_time
;
615 if (flags
& 2) { // percent seek
616 if (priv
->avfc
->duration
== 0 || priv
->avfc
->duration
== AV_NOPTS_VALUE
)
618 priv
->last_pts
+= rel_seek_secs
* priv
->avfc
->duration
;
620 priv
->last_pts
+= rel_seek_secs
* AV_TIME_BASE
;
621 if (rel_seek_secs
< 0) avsflags
= AVSEEK_FLAG_BACKWARD
;
623 av_seek_frame(priv
->avfc
, -1, priv
->last_pts
, avsflags
);
626 static int demux_lavf_control(demuxer_t
*demuxer
, int cmd
, void *arg
)
628 lavf_priv_t
*priv
= demuxer
->priv
;
631 case DEMUXER_CTRL_GET_TIME_LENGTH
:
632 if (priv
->avfc
->duration
== 0 || priv
->avfc
->duration
== AV_NOPTS_VALUE
)
633 return DEMUXER_CTRL_DONTKNOW
;
635 *((double *)arg
) = (double)priv
->avfc
->duration
/ AV_TIME_BASE
;
636 return DEMUXER_CTRL_OK
;
638 case DEMUXER_CTRL_GET_PERCENT_POS
:
639 if (priv
->avfc
->duration
== 0 || priv
->avfc
->duration
== AV_NOPTS_VALUE
)
640 return DEMUXER_CTRL_DONTKNOW
;
642 *((int *)arg
) = (int)((priv
->last_pts
- priv
->avfc
->start_time
)*100 / priv
->avfc
->duration
);
643 return DEMUXER_CTRL_OK
;
644 case DEMUXER_CTRL_SWITCH_AUDIO
:
645 case DEMUXER_CTRL_SWITCH_VIDEO
:
647 int id
= *((int*)arg
);
650 int nstreams
, *pstreams
;
653 if(cmd
== DEMUXER_CTRL_SWITCH_VIDEO
)
656 nstreams
= priv
->video_streams
;
657 pstreams
= priv
->vstreams
;
662 nstreams
= priv
->audio_streams
;
663 pstreams
= priv
->astreams
;
668 priv
->avfc
->streams
[ds
->id
]->discard
= AVDISCARD_ALL
;
670 *((int*)arg
) = ds
->id
= -2;
671 return DEMUXER_CTRL_OK
;
673 for(i
= 0; i
< nstreams
; i
++)
675 if(pstreams
[i
] == ds
->id
) //current stream id
684 i
= (curridx
+ 1) % nstreams
;
689 for(i
= 0; i
< nstreams
; i
++)
691 if(pstreams
[i
] == id
)
699 return DEMUXER_CTRL_NOTIMPL
;
704 priv
->avfc
->streams
[ds
->id
]->discard
= AVDISCARD_ALL
;
705 *((int*)arg
) = ds
->id
= newid
;
707 priv
->avfc
->streams
[newid
]->discard
= AVDISCARD_NONE
;
708 return DEMUXER_CTRL_OK
;
711 case DEMUXER_CTRL_IDENTIFY_PROGRAM
:
713 demux_program_t
*prog
= arg
;
717 if(priv
->avfc
->nb_programs
< 2)
718 return DEMUXER_CTRL_NOTIMPL
;
720 if(prog
->progid
== -1)
723 while(p
<priv
->avfc
->nb_programs
&& priv
->avfc
->programs
[p
]->id
!= priv
->cur_program
)
725 p
= (p
+ 1) % priv
->avfc
->nb_programs
;
729 for(i
=0; i
<priv
->avfc
->nb_programs
; i
++)
730 if(priv
->avfc
->programs
[i
]->id
== prog
->progid
)
732 if(i
==priv
->avfc
->nb_programs
)
733 return DEMUXER_CTRL_NOTIMPL
;
736 prog
->vid
= prog
->aid
= prog
->sid
= -2; //no audio and no video by default
738 program
= priv
->avfc
->programs
[p
];
739 for(i
=0; i
<program
->nb_stream_indexes
; i
++)
741 switch(priv
->avfc
->streams
[program
->stream_index
[i
]]->codec
->codec_type
)
743 case CODEC_TYPE_VIDEO
:
745 prog
->vid
= program
->stream_index
[i
];
747 case CODEC_TYPE_AUDIO
:
749 prog
->aid
= program
->stream_index
[i
];
751 case CODEC_TYPE_SUBTITLE
:
752 if(prog
->sid
== -2 && priv
->avfc
->streams
[program
->stream_index
[i
]]->codec
->codec_id
== CODEC_ID_TEXT
)
753 prog
->sid
= program
->stream_index
[i
];
757 if(prog
->progid
== -1 && prog
->vid
== -2 && prog
->aid
== -2)
759 p
= (p
+ 1) % priv
->avfc
->nb_programs
;
762 priv
->cur_program
= prog
->progid
= program
->id
;
763 return DEMUXER_CTRL_OK
;
766 return DEMUXER_CTRL_NOTIMPL
;
770 /** \brief Get the language code for a subtitle track.
772 Retrieves the language code for a subtitle track.
774 \param demuxer The demuxer to work on
775 \param track_num The subtitle track number to get the language from
777 char *demux_lavf_sub_lang(demuxer_t
*demuxer
, int track_num
)
779 lavf_priv_t
*priv
= demuxer
->priv
;
780 return priv
->avfc
->streams
[priv
->sstreams
[track_num
]]->language
;
783 static void demux_close_lavf(demuxer_t
*demuxer
)
785 lavf_priv_t
* priv
= demuxer
->priv
;
789 av_freep(&priv
->avfc
->key
);
790 av_close_input_file(priv
->avfc
); priv
->avfc
= NULL
;
792 free(priv
); demuxer
->priv
= NULL
;
797 demuxer_desc_t demuxer_desc_lavf
= {
798 "libavformat demuxer",
801 "Michael Niedermayer",
802 "supports many formats, requires libavformat",
804 0, // Check after other demuxer
806 demux_lavf_fill_buffer
,
813 demuxer_desc_t demuxer_desc_lavf_preferred
= {
814 "libavformat preferred demuxer",
817 "Michael Niedermayer",
818 "supports many formats, requires libavformat",
819 DEMUXER_TYPE_LAVF_PREFERRED
,
821 lavf_check_preferred_file
,
822 demux_lavf_fill_buffer
,