2 * Copyright (C) 2004 Michael Niedermayer <michaelni@gmx.at>
4 * This file is part of MPlayer.
6 * MPlayer is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
11 * MPlayer is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License along
17 * with MPlayer; if not, write to the Free Software Foundation, Inc.,
18 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
23 // #include <unistd.h>
34 #include "stream/stream.h"
41 #include "libavformat/avformat.h"
42 #include "libavformat/avio.h"
43 #include "libavutil/avutil.h"
44 #include "libavutil/avstring.h"
45 #include "libavcodec/opt.h"
47 #include "mp_taglists.h"
49 #define INITIAL_PROBE_SIZE STREAM_BUFFER_SIZE
50 #define SMALL_MAX_PROBE_SIZE (32 * 1024)
51 #define PROBE_BUF_SIZE (2*1024*1024)
53 const m_option_t lavfdopts_conf
[] = {
54 OPT_INTRANGE("probesize", lavfdopts
.probesize
, 0, 32, INT_MAX
),
55 OPT_STRING("format", lavfdopts
.format
, 0),
56 OPT_INTRANGE("analyzeduration", lavfdopts
.analyzeduration
, 0, 0, INT_MAX
),
57 OPT_STRING("cryptokey", lavfdopts
.cryptokey
, 0),
58 OPT_STRING("o", lavfdopts
.avopt
, 0),
59 {NULL
, NULL
, 0, 0, 0, 0, NULL
}
62 #define BIO_BUFFER_SIZE 32768
64 typedef struct lavf_priv
{
66 AVFormatContext
*avfc
;
68 uint8_t buffer
[BIO_BUFFER_SIZE
];
73 int astreams
[MAX_A_STREAMS
];
74 int vstreams
[MAX_V_STREAMS
];
75 int sstreams
[MAX_S_STREAMS
];
78 bool internet_radio_hack
;
84 static int mp_read(void *opaque
, uint8_t *buf
, int size
) {
85 struct demuxer
*demuxer
= opaque
;
86 struct stream
*stream
= demuxer
->stream
;
89 ret
=stream_read(stream
, buf
, size
);
91 mp_msg(MSGT_HEADER
,MSGL_DBG2
,"%d=mp_read(%p, %p, %d), pos: %"PRId64
", eof:%d\n",
92 ret
, stream
, buf
, size
, stream_tell(stream
), stream
->eof
);
96 static int64_t mp_seek(void *opaque
, int64_t pos
, int whence
) {
97 struct demuxer
*demuxer
= opaque
;
98 struct stream
*stream
= demuxer
->stream
;
100 mp_msg(MSGT_HEADER
,MSGL_DBG2
,"mp_seek(%p, %"PRId64
", %d)\n", stream
, pos
, whence
);
101 if(whence
== SEEK_CUR
)
102 pos
+=stream_tell(stream
);
103 else if(whence
== SEEK_END
&& stream
->end_pos
> 0)
104 pos
+= stream
->end_pos
;
105 else if(whence
== SEEK_SET
)
106 pos
+= stream
->start_pos
;
107 else if(whence
== AVSEEK_SIZE
&& stream
->end_pos
> 0)
108 return stream
->end_pos
- stream
->start_pos
;
114 current_pos
= stream_tell(stream
);
115 if(stream_seek(stream
, pos
)==0) {
116 stream_reset(stream
);
117 stream_seek(stream
, current_pos
);
121 return pos
- stream
->start_pos
;
124 static int64_t mp_read_seek(void *opaque
, int stream_idx
, int64_t ts
, int flags
)
126 struct demuxer
*demuxer
= opaque
;
127 struct stream
*stream
= demuxer
->stream
;
128 struct lavf_priv
*priv
= demuxer
->priv
;
130 AVStream
*st
= priv
->avfc
->streams
[stream_idx
];
131 double pts
= (double)ts
* st
->time_base
.num
/ st
->time_base
.den
;
132 int ret
= stream_control(stream
, STREAM_CTRL_SEEK_TO_TIME
, &pts
);
134 ret
= AVERROR(ENOSYS
);
138 static void list_formats(void) {
139 mp_msg(MSGT_DEMUX
, MSGL_INFO
, "Available lavf input formats:\n");
140 AVInputFormat
*fmt
= NULL
;
141 while (fmt
= av_iformat_next(fmt
))
142 mp_msg(MSGT_DEMUX
, MSGL_INFO
, "%15s : %s\n", fmt
->name
, fmt
->long_name
);
145 static int lavf_check_file(demuxer_t
*demuxer
){
146 struct MPOpts
*opts
= demuxer
->opts
;
147 struct lavfdopts
*lavfdopts
= &opts
->lavfdopts
;
150 int probe_data_size
= 0;
151 int read_size
= INITIAL_PROBE_SIZE
;
155 demuxer
->priv
=calloc(sizeof(lavf_priv_t
),1);
160 char *format
= lavfdopts
->format
;
162 format
= demuxer
->stream
->lavf_type
;
164 if (strcmp(format
, "help") == 0) {
168 priv
->avif
= av_find_input_format(format
);
170 mp_msg(MSGT_DEMUX
, MSGL_FATAL
, "Unknown lavf format %s\n", format
);
173 mp_msg(MSGT_DEMUX
,MSGL_INFO
,"Forced lavf %s demuxer\n", priv
->avif
->long_name
);
174 return DEMUXER_TYPE_LAVF
;
177 avpd
.buf
= av_mallocz(FFMAX(BIO_BUFFER_SIZE
, PROBE_BUF_SIZE
) +
178 FF_INPUT_BUFFER_PADDING_SIZE
);
180 read_size
= stream_read(demuxer
->stream
, avpd
.buf
+ probe_data_size
, read_size
);
185 probe_data_size
+= read_size
;
186 avpd
.filename
= demuxer
->stream
->url
;
187 if (!avpd
.filename
) {
188 mp_msg(MSGT_DEMUX
, MSGL_WARN
, "Stream url is not set!\n");
191 if (!strncmp(avpd
.filename
, "ffmpeg://", 9))
193 avpd
.buf_size
= probe_data_size
;
196 priv
->avif
= av_probe_input_format2(&avpd
, probe_data_size
> 0, &score
);
197 read_size
= FFMIN(2*read_size
, PROBE_BUF_SIZE
- probe_data_size
);
198 } while ((demuxer
->desc
->type
!= DEMUXER_TYPE_LAVF_PREFERRED
||
199 probe_data_size
< SMALL_MAX_PROBE_SIZE
) &&
200 score
<= AVPROBE_SCORE_MAX
/ 4 &&
201 read_size
> 0 && probe_data_size
< PROBE_BUF_SIZE
);
204 if (!priv
->avif
|| score
<= AVPROBE_SCORE_MAX
/ 4) {
205 mp_msg(MSGT_HEADER
,MSGL_V
,"LAVF_check: no clue about this gibberish!\n");
208 mp_msg(MSGT_HEADER
,MSGL_V
,"LAVF_check: %s\n", priv
->avif
->long_name
);
210 demuxer
->filetype
= priv
->avif
->long_name
;
211 if (!demuxer
->filetype
)
212 demuxer
->filetype
= priv
->avif
->name
;
214 return DEMUXER_TYPE_LAVF
;
217 static bool matches_avinputformat_name(struct lavf_priv
*priv
,
220 const char *avifname
= priv
->avif
->name
;
222 const char *next
= strchr(avifname
, ',');
224 return !strcmp(avifname
, name
);
225 int len
= next
- avifname
;
226 if (len
== strlen(name
) && !memcmp(avifname
, name
, len
))
232 /* formats for which an internal demuxer is preferred */
233 static const char * const preferred_internal
[] = {
234 /* lavf Matroska demuxer doesn't support ordered chapters and fails
237 #if LIBAVCODEC_VERSION_INT < AV_VERSION_INT(52, 99, 0)
238 /* Seeking doesn't work with lavf FLAC demuxer in FFmpeg versions
239 * without a FLAC parser. In principle this could use a runtime check to
240 * switch if a shared library is updated. */
243 /* lavf gives neither pts nor dts for some video frames in .rm */
248 static int lavf_check_preferred_file(demuxer_t
*demuxer
){
249 if (lavf_check_file(demuxer
)) {
250 const char * const *p
;
251 lavf_priv_t
*priv
= demuxer
->priv
;
252 for (p
= preferred_internal
; *p
; p
++)
253 if (matches_avinputformat_name(priv
, *p
))
255 return DEMUXER_TYPE_LAVF_PREFERRED
;
260 static uint8_t char2int(char c
) {
261 if (c
>= '0' && c
<= '9') return c
- '0';
262 if (c
>= 'a' && c
<= 'f') return c
- 'a' + 10;
263 if (c
>= 'A' && c
<= 'F') return c
- 'A' + 10;
267 static void parse_cryptokey(AVFormatContext
*avfc
, const char *str
) {
268 int len
= strlen(str
) / 2;
269 uint8_t *key
= av_mallocz(len
);
273 for (i
= 0; i
< len
; i
++, str
+= 2)
274 *key
++ = (char2int(str
[0]) << 4) | char2int(str
[1]);
277 static void handle_stream(demuxer_t
*demuxer
, AVFormatContext
*avfc
, int i
) {
278 lavf_priv_t
*priv
= demuxer
->priv
;
279 AVStream
*st
= avfc
->streams
[i
];
280 AVCodecContext
*codec
= st
->codec
;
281 char *stream_type
= NULL
;
283 AVMetadataTag
*lang
= av_metadata_get(st
->metadata
, "language", NULL
, 0);
284 AVMetadataTag
*title
= av_metadata_get(st
->metadata
, "title", NULL
, 0);
285 int g
, override_tag
= mp_av_codec_get_tag(mp_codecid_override_taglists
,
287 // For some formats (like PCM) always trust CODEC_ID_* more than codec_tag
289 codec
->codec_tag
= override_tag
;
291 switch(codec
->codec_type
){
292 case CODEC_TYPE_AUDIO
:{
294 sh_audio_t
* sh_audio
;
295 sh_audio
= new_sh_audio_aid(demuxer
, i
, priv
->audio_streams
);
298 stream_type
= "audio";
299 priv
->astreams
[priv
->audio_streams
] = i
;
300 wf
= calloc(sizeof(*wf
) + codec
->extradata_size
, 1);
301 // mp4a tag is used for all mp4 files no matter what they actually contain
302 if(codec
->codec_tag
== MKTAG('m', 'p', '4', 'a'))
304 if(!codec
->codec_tag
)
305 codec
->codec_tag
= mp_av_codec_get_tag(mp_wav_taglists
, codec
->codec_id
);
306 wf
->wFormatTag
= codec
->codec_tag
;
307 wf
->nChannels
= codec
->channels
;
308 wf
->nSamplesPerSec
= codec
->sample_rate
;
309 wf
->nAvgBytesPerSec
= codec
->bit_rate
/8;
310 wf
->nBlockAlign
= codec
->block_align
? codec
->block_align
: 1;
311 wf
->wBitsPerSample
= codec
->bits_per_coded_sample
;
312 wf
->cbSize
= codec
->extradata_size
;
313 if(codec
->extradata_size
)
314 memcpy(wf
+ 1, codec
->extradata
, codec
->extradata_size
);
316 sh_audio
->audio
.dwSampleSize
= codec
->block_align
;
317 if(codec
->frame_size
&& codec
->sample_rate
){
318 sh_audio
->audio
.dwScale
=codec
->frame_size
;
319 sh_audio
->audio
.dwRate
= codec
->sample_rate
;
321 sh_audio
->audio
.dwScale
= codec
->block_align
? codec
->block_align
*8 : 8;
322 sh_audio
->audio
.dwRate
= codec
->bit_rate
;
324 g
= av_gcd(sh_audio
->audio
.dwScale
, sh_audio
->audio
.dwRate
);
325 sh_audio
->audio
.dwScale
/= g
;
326 sh_audio
->audio
.dwRate
/= g
;
327 // 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);
328 sh_audio
->ds
= demuxer
->audio
;
329 sh_audio
->format
= codec
->codec_tag
;
330 sh_audio
->channels
= codec
->channels
;
331 sh_audio
->samplerate
= codec
->sample_rate
;
332 sh_audio
->i_bps
= codec
->bit_rate
/8;
333 switch (codec
->codec_id
) {
334 case CODEC_ID_PCM_S8
:
335 case CODEC_ID_PCM_U8
:
336 sh_audio
->samplesize
= 1;
338 case CODEC_ID_PCM_S16LE
:
339 case CODEC_ID_PCM_S16BE
:
340 case CODEC_ID_PCM_U16LE
:
341 case CODEC_ID_PCM_U16BE
:
342 sh_audio
->samplesize
= 2;
344 case CODEC_ID_PCM_ALAW
:
345 sh_audio
->format
= 0x6;
347 case CODEC_ID_PCM_MULAW
:
348 sh_audio
->format
= 0x7;
351 if (title
&& title
->value
)
352 mp_msg(MSGT_IDENTIFY
, MSGL_INFO
, "ID_AID_%d_NAME=%s\n", priv
->audio_streams
, title
->value
);
353 if (lang
&& lang
->value
) {
354 sh_audio
->lang
= strdup(lang
->value
);
355 mp_msg(MSGT_IDENTIFY
, MSGL_INFO
, "ID_AID_%d_LANG=%s\n", priv
->audio_streams
, sh_audio
->lang
);
357 if (st
->disposition
& AV_DISPOSITION_DEFAULT
)
358 sh_audio
->default_track
= 1;
359 if(mp_msg_test(MSGT_HEADER
,MSGL_V
) ) print_wave_header(sh_audio
->wf
, MSGL_V
);
360 // select the first audio stream
361 if (!demuxer
->audio
->sh
) {
362 demuxer
->audio
->id
= i
;
363 demuxer
->audio
->sh
= demuxer
->a_streams
[i
];
365 st
->discard
= AVDISCARD_ALL
;
366 stream_id
= priv
->audio_streams
++;
369 case CODEC_TYPE_VIDEO
:{
370 sh_video_t
* sh_video
;
371 BITMAPINFOHEADER
*bih
;
372 sh_video
=new_sh_video_vid(demuxer
, i
, priv
->video_streams
);
374 stream_type
= "video";
375 priv
->vstreams
[priv
->video_streams
] = i
;
376 bih
=calloc(sizeof(*bih
) + codec
->extradata_size
,1);
378 if(codec
->codec_id
== CODEC_ID_RAWVIDEO
) {
379 switch (codec
->pix_fmt
) {
381 codec
->codec_tag
= MKTAG(24, 'B', 'G', 'R');
383 codec
->codec_tag
= MKTAG(24, 'R', 'G', 'B');
386 if(!codec
->codec_tag
)
387 codec
->codec_tag
= mp_av_codec_get_tag(mp_bmp_taglists
, codec
->codec_id
);
388 bih
->biSize
= sizeof(*bih
) + codec
->extradata_size
;
389 bih
->biWidth
= codec
->width
;
390 bih
->biHeight
= codec
->height
;
391 bih
->biBitCount
= codec
->bits_per_coded_sample
;
392 bih
->biSizeImage
= bih
->biWidth
* bih
->biHeight
* bih
->biBitCount
/8;
393 bih
->biCompression
= codec
->codec_tag
;
395 sh_video
->disp_w
= codec
->width
;
396 sh_video
->disp_h
= codec
->height
;
397 if (st
->time_base
.den
) { /* if container has time_base, use that */
398 sh_video
->video
.dwRate
= st
->time_base
.den
;
399 sh_video
->video
.dwScale
= st
->time_base
.num
;
401 sh_video
->video
.dwRate
= codec
->time_base
.den
;
402 sh_video
->video
.dwScale
= codec
->time_base
.num
;
404 sh_video
->fps
=av_q2d(st
->r_frame_rate
);
405 sh_video
->frametime
=1/av_q2d(st
->r_frame_rate
);
406 sh_video
->format
=bih
->biCompression
;
407 if(st
->sample_aspect_ratio
.num
)
408 sh_video
->aspect
= codec
->width
* st
->sample_aspect_ratio
.num
409 / (float)(codec
->height
* st
->sample_aspect_ratio
.den
);
411 sh_video
->aspect
=codec
->width
* codec
->sample_aspect_ratio
.num
412 / (float)(codec
->height
* codec
->sample_aspect_ratio
.den
);
413 sh_video
->i_bps
=codec
->bit_rate
/8;
414 if (title
&& title
->value
)
415 mp_msg(MSGT_IDENTIFY
, MSGL_INFO
, "ID_VID_%d_NAME=%s\n", priv
->video_streams
, title
->value
);
416 mp_msg(MSGT_DEMUX
,MSGL_DBG2
,"aspect= %d*%d/(%d*%d)\n",
417 codec
->width
, codec
->sample_aspect_ratio
.num
,
418 codec
->height
, codec
->sample_aspect_ratio
.den
);
420 sh_video
->ds
= demuxer
->video
;
421 if(codec
->extradata_size
)
422 memcpy(sh_video
->bih
+ 1, codec
->extradata
, codec
->extradata_size
);
423 if( mp_msg_test(MSGT_HEADER
,MSGL_V
) ) print_video_header(sh_video
->bih
, MSGL_V
);
431 if(demuxer
->video
->id
!= i
&& demuxer
->video
->id
!= -1)
432 st
->discard
= AVDISCARD_ALL
;
434 demuxer
->video
->id
= i
;
435 demuxer
->video
->sh
= demuxer
->v_streams
[i
];
437 stream_id
= priv
->video_streams
++;
440 case CODEC_TYPE_SUBTITLE
:{
443 /* only support text subtitles for now */
444 if(codec
->codec_id
== CODEC_ID_TEXT
)
446 else if(codec
->codec_id
== CODEC_ID_MOV_TEXT
)
448 else if(codec
->codec_id
== CODEC_ID_SSA
)
450 else if(codec
->codec_id
== CODEC_ID_DVD_SUBTITLE
)
452 else if(codec
->codec_id
== CODEC_ID_XSUB
)
454 else if(codec
->codec_id
== CODEC_ID_DVB_SUBTITLE
)
456 else if(codec
->codec_id
== CODEC_ID_DVB_TELETEXT
)
458 else if(codec
->codec_id
== CODEC_ID_HDMV_PGS_SUBTITLE
)
462 sh_sub
= new_sh_sub_sid(demuxer
, i
, priv
->sub_streams
);
464 stream_type
= "subtitle";
465 priv
->sstreams
[priv
->sub_streams
] = i
;
467 if (codec
->extradata_size
) {
468 sh_sub
->extradata
= malloc(codec
->extradata_size
);
469 memcpy(sh_sub
->extradata
, codec
->extradata
, codec
->extradata_size
);
470 sh_sub
->extradata_len
= codec
->extradata_size
;
472 if (title
&& title
->value
)
473 mp_msg(MSGT_IDENTIFY
, MSGL_INFO
, "ID_SID_%d_NAME=%s\n", priv
->sub_streams
, title
->value
);
474 if (lang
&& lang
->value
) {
475 sh_sub
->lang
= strdup(lang
->value
);
476 mp_msg(MSGT_IDENTIFY
, MSGL_INFO
, "ID_SID_%d_LANG=%s\n", priv
->sub_streams
, sh_sub
->lang
);
478 if (st
->disposition
& AV_DISPOSITION_DEFAULT
)
479 sh_sub
->default_track
= 1;
480 stream_id
= priv
->sub_streams
++;
483 case CODEC_TYPE_ATTACHMENT
:{
484 if (st
->codec
->codec_id
== CODEC_ID_TTF
)
485 demuxer_add_attachment(demuxer
, BSTR(st
->filename
),
486 BSTR("application/x-truetype-font"),
487 (struct bstr
){codec
->extradata
,
488 codec
->extradata_size
});
492 st
->discard
= AVDISCARD_ALL
;
495 AVCodec
*avc
= avcodec_find_decoder(codec
->codec_id
);
496 const char *codec_name
= avc
? avc
->name
: "unknown";
497 if (!avc
&& *stream_type
== 's' && demuxer
->s_streams
[stream_id
])
498 codec_name
= sh_sub_type2str(((sh_sub_t
*)demuxer
->s_streams
[stream_id
])->type
);
499 mp_msg(MSGT_DEMUX
, MSGL_INFO
, "[lavf] stream %d: %s (%s), -%cid %d", i
, stream_type
, codec_name
, *stream_type
, stream_id
);
500 if (lang
&& lang
->value
&& *stream_type
!= 'v')
501 mp_msg(MSGT_DEMUX
, MSGL_INFO
, ", -%clang %s", *stream_type
, lang
->value
);
502 if (title
&& title
->value
)
503 mp_msg(MSGT_DEMUX
, MSGL_INFO
, ", %s", title
->value
);
504 mp_msg(MSGT_DEMUX
, MSGL_INFO
, "\n");
508 static demuxer_t
* demux_open_lavf(demuxer_t
*demuxer
){
509 struct MPOpts
*opts
= demuxer
->opts
;
510 struct lavfdopts
*lavfdopts
= &opts
->lavfdopts
;
511 AVFormatContext
*avfc
;
512 AVFormatParameters ap
;
514 AVMetadataTag
*t
= NULL
;
515 lavf_priv_t
*priv
= demuxer
->priv
;
517 char mp_filename
[256]="mp:";
519 memset(&ap
, 0, sizeof(AVFormatParameters
));
521 stream_seek(demuxer
->stream
, 0);
523 avfc
= avformat_alloc_context();
525 if (lavfdopts
->cryptokey
)
526 parse_cryptokey(avfc
, lavfdopts
->cryptokey
);
527 if (matches_avinputformat_name(priv
, "avi")) {
528 /* for avi libavformat returns the avi timestamps in .dts,
529 * some made-up stuff that's not really pts in .pts */
530 priv
->use_dts
= true;
531 demuxer
->timestamp_type
= TIMESTAMP_TYPE_SORT
;
533 if (opts
->user_correct_pts
!= 0)
534 avfc
->flags
|= AVFMT_FLAG_GENPTS
;
537 avfc
->flags
|= AVFMT_FLAG_IGNIDX
;
539 ap
.prealloced_context
= 1;
540 if (lavfdopts
->probesize
) {
541 opt
= av_set_int(avfc
, "probesize", lavfdopts
->probesize
);
542 if(!opt
) mp_msg(MSGT_HEADER
,MSGL_ERR
, "demux_lavf, couldn't set option probesize to %u\n", lavfdopts
->probesize
);
544 if (lavfdopts
->analyzeduration
) {
545 opt
= av_set_int(avfc
, "analyzeduration",
546 lavfdopts
->analyzeduration
* AV_TIME_BASE
);
548 mp_msg(MSGT_HEADER
, MSGL_ERR
, "demux_lavf, couldn't set option "
549 "analyzeduration to %u\n", lavfdopts
->analyzeduration
);
552 if (lavfdopts
->avopt
){
553 if(parse_avopts(avfc
, lavfdopts
->avopt
) < 0){
554 mp_msg(MSGT_HEADER
,MSGL_ERR
, "Your options /%s/ look like gibberish to me pal\n", lavfdopts
->avopt
);
559 if(demuxer
->stream
->url
) {
560 if (!strncmp(demuxer
->stream
->url
, "ffmpeg://rtsp:", 14))
561 av_strlcpy(mp_filename
, demuxer
->stream
->url
+ 9, sizeof(mp_filename
));
563 av_strlcat(mp_filename
, demuxer
->stream
->url
, sizeof(mp_filename
));
565 av_strlcat(mp_filename
, "foobar.dummy", sizeof(mp_filename
));
567 priv
->pb
= av_alloc_put_byte(priv
->buffer
, BIO_BUFFER_SIZE
, 0,
568 demuxer
, mp_read
, NULL
, mp_seek
);
569 priv
->pb
->read_seek
= mp_read_seek
;
570 priv
->pb
->is_streamed
= !demuxer
->stream
->end_pos
|| (demuxer
->stream
->flags
& MP_STREAM_SEEK
) != MP_STREAM_SEEK
;
572 if(av_open_input_stream(&avfc
, priv
->pb
, mp_filename
, priv
->avif
, &ap
)<0){
573 mp_msg(MSGT_HEADER
,MSGL_ERR
,"LAVF_header: av_open_input_stream() failed\n");
579 if(av_find_stream_info(avfc
) < 0){
580 mp_msg(MSGT_HEADER
,MSGL_ERR
,"LAVF_header: av_find_stream_info() failed\n");
585 av_metadata_conv(avfc
, NULL
, avfc
->iformat
->metadata_conv
);
586 while((t
= av_metadata_get(avfc
->metadata
, "", t
, AV_METADATA_IGNORE_SUFFIX
)))
587 demux_info_add(demuxer
, t
->key
, t
->value
);
589 for(i
=0; i
< avfc
->nb_chapters
; i
++) {
590 AVChapter
*c
= avfc
->chapters
[i
];
591 uint64_t start
= av_rescale_q(c
->start
, c
->time_base
, (AVRational
){1,1000000000});
592 uint64_t end
= av_rescale_q(c
->end
, c
->time_base
, (AVRational
){1,1000000000});
593 t
= av_metadata_get(c
->metadata
, "title", NULL
, 0);
594 demuxer_add_chapter(demuxer
, t
? BSTR(t
->value
) : BSTR(NULL
), start
, end
);
597 for(i
=0; i
<avfc
->nb_streams
; i
++)
598 handle_stream(demuxer
, avfc
, i
);
599 priv
->nb_streams_last
= avfc
->nb_streams
;
601 if(avfc
->nb_programs
) {
603 for (p
= 0; p
< avfc
->nb_programs
; p
++) {
604 AVProgram
*program
= avfc
->programs
[p
];
605 t
= av_metadata_get(program
->metadata
, "title", NULL
, 0);
606 mp_msg(MSGT_HEADER
,MSGL_INFO
,"LAVF: Program %d %s\n", program
->id
, t
? t
->value
: "");
607 mp_msg(MSGT_IDENTIFY
, MSGL_V
, "PROGRAM_ID=%d\n", program
->id
);
611 mp_msg(MSGT_HEADER
,MSGL_V
,"LAVF: %d audio and %d video streams found\n",priv
->audio_streams
,priv
->video_streams
);
612 mp_msg(MSGT_HEADER
,MSGL_V
,"LAVF: build %d\n", LIBAVFORMAT_BUILD
);
613 if(!priv
->audio_streams
) demuxer
->audio
->id
=-2; // nosound
614 // else if(best_audio > 0 && demuxer->audio->id == -1) demuxer->audio->id=best_audio;
615 if(!priv
->video_streams
){
616 if(!priv
->audio_streams
){
617 mp_msg(MSGT_HEADER
,MSGL_ERR
,"LAVF: no audio or video headers found - broken file?\n");
620 demuxer
->video
->id
=-2; // audio-only
621 } //else if (best_video > 0 && demuxer->video->id == -1) demuxer->video->id = best_video;
623 /* libavformat sets bitrate for mpeg based on pts at start and end
624 * of file, which fails for files with pts resets. So calculate our
625 * own bitrate estimate. */
626 if (priv
->avif
->flags
& AVFMT_TS_DISCONT
) {
627 for (int i
= 0; i
< avfc
->nb_streams
; i
++)
628 priv
->bitrate
+= avfc
->streams
[i
]->codec
->bit_rate
;
629 /* pts-based is more accurate if there are no resets; try to make
630 * a somewhat reasonable guess */
631 if (!avfc
->duration
|| avfc
->duration
== AV_NOPTS_VALUE
632 || priv
->bitrate
&& (avfc
->bit_rate
< priv
->bitrate
/ 2
633 || avfc
->bit_rate
> priv
->bitrate
* 2))
634 priv
->seek_by_bytes
= true;
636 priv
->bitrate
= 1440000;
638 demuxer
->accurate_seek
= !priv
->seek_by_bytes
;
643 static void check_internet_radio_hack(struct demuxer
*demuxer
)
645 struct lavf_priv
*priv
= demuxer
->priv
;
646 struct AVFormatContext
*avfc
= priv
->avfc
;
648 if (!matches_avinputformat_name(priv
, "ogg"))
650 if (priv
->nb_streams_last
== avfc
->nb_streams
)
652 if (avfc
->nb_streams
- priv
->nb_streams_last
== 1
653 && priv
->video_streams
== 0 && priv
->sub_streams
== 0
654 && demuxer
->a_streams
[priv
->audio_streams
-1]->format
== 0x566f // vorbis
655 && (priv
->audio_streams
== 2 || priv
->internet_radio_hack
)
656 && demuxer
->a_streams
[0]->format
== 0x566f) {
657 // extradata match could be checked but would require parsing
658 // headers, as the comment section will vary
659 if (!priv
->internet_radio_hack
) {
660 mp_msg(MSGT_DEMUX
, MSGL_V
,
661 "[lavf] enabling internet ogg radio hack\n");
662 #if LIBAVFORMAT_VERSION_MAJOR < 53
663 mp_tmsg(MSGT_DEMUX
, MSGL_WARN
, "[lavf] This looks like an "
664 "internet radio ogg stream with track changes.\n"
665 "Playback will likely fail after %d track changes "
666 "due to libavformat limitations.\n"
667 "You may be able to work around that limitation by "
668 "using -demuxer ogg.\n", MAX_STREAMS
);
671 #if LIBAVFORMAT_VERSION_MAJOR < 53
672 if (avfc
->nb_streams
== MAX_STREAMS
) {
673 mp_tmsg(MSGT_DEMUX
, MSGL_WARN
, "[lavf] This is the %dth "
674 "track.\nPlayback will likely fail at the next change.\n"
675 "You may be able to work around this limitation by "
676 "using -demuxer ogg.\n", MAX_STREAMS
);
679 priv
->internet_radio_hack
= true;
680 // use new per-track metadata as global metadata
681 AVMetadataTag
*t
= NULL
;
682 AVStream
*stream
= avfc
->streams
[avfc
->nb_streams
- 1];
683 while ((t
= av_metadata_get(stream
->metadata
, "", t
,
684 AV_METADATA_IGNORE_SUFFIX
)))
685 demux_info_add(demuxer
, t
->key
, t
->value
);
687 if (priv
->internet_radio_hack
)
688 mp_tmsg(MSGT_DEMUX
, MSGL_WARN
, "[lavf] Internet radio ogg hack "
689 "was enabled, but stream characteristics changed.\n"
690 "This may or may not work.\n");
691 priv
->internet_radio_hack
= false;
695 static int demux_lavf_fill_buffer(demuxer_t
*demux
, demux_stream_t
*dsds
){
696 lavf_priv_t
*priv
= demux
->priv
;
701 mp_msg(MSGT_DEMUX
,MSGL_DBG2
,"demux_lavf_fill_buffer()\n");
703 demux
->filepos
=stream_tell(demux
->stream
);
705 if(av_read_frame(priv
->avfc
, &pkt
) < 0)
708 // handle any new streams that might have been added
709 for (id
= priv
->nb_streams_last
; id
< priv
->avfc
->nb_streams
; id
++)
710 handle_stream(demux
, priv
->avfc
, id
);
711 check_internet_radio_hack(demux
);
713 priv
->nb_streams_last
= priv
->avfc
->nb_streams
;
715 id
= pkt
.stream_index
;
717 if (id
== demux
->audio
->id
|| priv
->internet_radio_hack
) {
721 ds
->sh
=demux
->a_streams
[id
];
722 mp_msg(MSGT_DEMUX
,MSGL_V
,"Auto-selected LAVF audio ID = %d\n",ds
->id
);
724 } else if(id
==demux
->video
->id
){
728 ds
->sh
=demux
->v_streams
[id
];
729 mp_msg(MSGT_DEMUX
,MSGL_V
,"Auto-selected LAVF video ID = %d\n",ds
->id
);
731 } else if(id
==demux
->sub
->id
){
736 av_free_packet(&pkt
);
740 if(0/*pkt.destruct == av_destruct_packet*/){
741 //ok kids, dont try this at home :)
742 dp
=malloc(sizeof(demux_packet_t
));
750 dp
=new_demux_packet(pkt
.size
);
751 memcpy(dp
->buffer
, pkt
.data
, pkt
.size
);
752 av_free_packet(&pkt
);
755 int64_t ts
= priv
->use_dts
? pkt
.dts
: pkt
.pts
;
756 if(ts
!= AV_NOPTS_VALUE
){
757 dp
->pts
= ts
* av_q2d(priv
->avfc
->streams
[id
]->time_base
);
758 priv
->last_pts
= dp
->pts
* AV_TIME_BASE
;
759 // always set duration for subtitles, even if PKT_FLAG_KEY is not set,
760 // otherwise they will stay on screen to long if e.g. ASS is demuxed from mkv
761 if((ds
== demux
->sub
|| (pkt
.flags
& PKT_FLAG_KEY
)) &&
762 pkt
.convergence_duration
> 0)
763 dp
->duration
= pkt
.convergence_duration
* av_q2d(priv
->avfc
->streams
[id
]->time_base
);
765 dp
->pos
=demux
->filepos
;
766 dp
->flags
= !!(pkt
.flags
&PKT_FLAG_KEY
);
767 // append packet to DS stream:
768 ds_add_packet(ds
,dp
);
772 static void demux_seek_lavf(demuxer_t
*demuxer
, float rel_seek_secs
, float audio_delay
, int flags
){
773 lavf_priv_t
*priv
= demuxer
->priv
;
775 mp_msg(MSGT_DEMUX
,MSGL_DBG2
,"demux_seek_lavf(%p, %f, %f, %d)\n", demuxer
, rel_seek_secs
, audio_delay
, flags
);
777 if (priv
->seek_by_bytes
) {
778 int64_t pos
= demuxer
->filepos
;
779 rel_seek_secs
*= priv
->bitrate
/ 8;
780 pos
+= rel_seek_secs
;
781 av_seek_frame(priv
->avfc
, -1, pos
, AVSEEK_FLAG_BYTE
);
785 if (flags
& SEEK_ABSOLUTE
) {
788 if (rel_seek_secs
< 0) avsflags
= AVSEEK_FLAG_BACKWARD
;
790 if (flags
& SEEK_FORWARD
)
792 else if (flags
& SEEK_BACKWARD
)
793 avsflags
= AVSEEK_FLAG_BACKWARD
;
794 if (flags
& SEEK_FACTOR
) {
795 if (priv
->avfc
->duration
== 0 || priv
->avfc
->duration
== AV_NOPTS_VALUE
)
797 priv
->last_pts
+= rel_seek_secs
* priv
->avfc
->duration
;
799 priv
->last_pts
+= rel_seek_secs
* AV_TIME_BASE
;
801 if (av_seek_frame(priv
->avfc
, -1, priv
->last_pts
, avsflags
) < 0) {
802 avsflags
^= AVSEEK_FLAG_BACKWARD
;
803 av_seek_frame(priv
->avfc
, -1, priv
->last_pts
, avsflags
);
807 static int demux_lavf_control(demuxer_t
*demuxer
, int cmd
, void *arg
)
809 lavf_priv_t
*priv
= demuxer
->priv
;
812 case DEMUXER_CTRL_CORRECT_PTS
:
813 return DEMUXER_CTRL_OK
;
814 case DEMUXER_CTRL_GET_TIME_LENGTH
:
815 if (priv
->seek_by_bytes
) {
816 /* Our bitrate estimate may be better than would be used in
817 * otherwise similar fallback code at higher level */
818 if (demuxer
->movi_end
<= 0)
819 return DEMUXER_CTRL_DONTKNOW
;
820 *(double *)arg
= (demuxer
->movi_end
- demuxer
->movi_start
) * 8 /
822 return DEMUXER_CTRL_GUESS
;
824 if (priv
->avfc
->duration
== 0 || priv
->avfc
->duration
== AV_NOPTS_VALUE
)
825 return DEMUXER_CTRL_DONTKNOW
;
827 *((double *)arg
) = (double)priv
->avfc
->duration
/ AV_TIME_BASE
;
828 return DEMUXER_CTRL_OK
;
830 case DEMUXER_CTRL_GET_PERCENT_POS
:
831 if (priv
->seek_by_bytes
)
832 return DEMUXER_CTRL_DONTKNOW
; // let it use the fallback code
833 if (priv
->avfc
->duration
== 0 || priv
->avfc
->duration
== AV_NOPTS_VALUE
)
834 return DEMUXER_CTRL_DONTKNOW
;
836 *((int *)arg
) = (int)((priv
->last_pts
- priv
->avfc
->start_time
)*100 / priv
->avfc
->duration
);
837 return DEMUXER_CTRL_OK
;
838 case DEMUXER_CTRL_SWITCH_AUDIO
:
839 case DEMUXER_CTRL_SWITCH_VIDEO
:
841 int id
= *((int*)arg
);
844 int nstreams
, *pstreams
;
847 if(cmd
== DEMUXER_CTRL_SWITCH_VIDEO
)
850 nstreams
= priv
->video_streams
;
851 pstreams
= priv
->vstreams
;
856 nstreams
= priv
->audio_streams
;
857 pstreams
= priv
->astreams
;
859 for(i
= 0; i
< nstreams
; i
++)
861 if(pstreams
[i
] == ds
->id
) //current stream id
868 if(id
== -2) { // no sound
870 } else if(id
== -1) { // next track
871 i
= (curridx
+ 2) % (nstreams
+ 1) - 1;
875 else // select track by id
877 if (id
>= 0 && id
< nstreams
) {
883 *(int *) arg
= curridx
;
884 return DEMUXER_CTRL_OK
;
888 priv
->avfc
->streams
[ds
->id
]->discard
= AVDISCARD_ALL
;
890 *(int *) arg
= i
< 0 ? -2 : i
;
892 priv
->avfc
->streams
[newid
]->discard
= AVDISCARD_NONE
;
893 return DEMUXER_CTRL_OK
;
896 case DEMUXER_CTRL_IDENTIFY_PROGRAM
:
898 demux_program_t
*prog
= arg
;
903 prog
->vid
= prog
->aid
= prog
->sid
= -2; //no audio and no video by default
904 if(priv
->avfc
->nb_programs
< 1)
905 return DEMUXER_CTRL_DONTKNOW
;
907 if(prog
->progid
== -1)
910 while(p
<priv
->avfc
->nb_programs
&& priv
->avfc
->programs
[p
]->id
!= priv
->cur_program
)
912 p
= (p
+ 1) % priv
->avfc
->nb_programs
;
916 for(i
=0; i
<priv
->avfc
->nb_programs
; i
++)
917 if(priv
->avfc
->programs
[i
]->id
== prog
->progid
)
919 if(i
==priv
->avfc
->nb_programs
)
920 return DEMUXER_CTRL_DONTKNOW
;
925 program
= priv
->avfc
->programs
[p
];
926 for(i
=0; i
<program
->nb_stream_indexes
; i
++)
928 switch(priv
->avfc
->streams
[program
->stream_index
[i
]]->codec
->codec_type
)
930 case CODEC_TYPE_VIDEO
:
932 prog
->vid
= program
->stream_index
[i
];
934 case CODEC_TYPE_AUDIO
:
936 prog
->aid
= program
->stream_index
[i
];
938 case CODEC_TYPE_SUBTITLE
:
939 if(prog
->sid
== -2 && priv
->avfc
->streams
[program
->stream_index
[i
]]->codec
->codec_id
== CODEC_ID_TEXT
)
940 prog
->sid
= program
->stream_index
[i
];
944 if (prog
->aid
>= 0 && prog
->aid
< MAX_A_STREAMS
&&
945 demuxer
->a_streams
[prog
->aid
]) {
946 sh_audio_t
*sh
= demuxer
->a_streams
[prog
->aid
];
950 if (prog
->vid
>= 0 && prog
->vid
< MAX_V_STREAMS
&&
951 demuxer
->v_streams
[prog
->vid
]) {
952 sh_video_t
*sh
= demuxer
->v_streams
[prog
->vid
];
956 if(prog
->progid
== -1 && prog
->vid
== -2 && prog
->aid
== -2)
958 p
= (p
+ 1) % priv
->avfc
->nb_programs
;
960 return DEMUXER_CTRL_DONTKNOW
;
963 priv
->cur_program
= prog
->progid
= program
->id
;
964 return DEMUXER_CTRL_OK
;
967 return DEMUXER_CTRL_NOTIMPL
;
971 static void demux_close_lavf(demuxer_t
*demuxer
)
973 lavf_priv_t
* priv
= demuxer
->priv
;
977 av_freep(&priv
->avfc
->key
);
978 av_close_input_stream(priv
->avfc
);
981 free(priv
); demuxer
->priv
= NULL
;
986 const demuxer_desc_t demuxer_desc_lavf
= {
987 "libavformat demuxer",
990 "Michael Niedermayer",
991 "supports many formats, requires libavformat",
993 0, // Check after other demuxer
995 demux_lavf_fill_buffer
,
1002 const demuxer_desc_t demuxer_desc_lavf_preferred
= {
1003 "libavformat preferred demuxer",
1006 "Michael Niedermayer",
1007 "supports many formats, requires libavformat",
1008 DEMUXER_TYPE_LAVF_PREFERRED
,
1010 lavf_check_preferred_file
,
1011 demux_lavf_fill_buffer
,