libmpdemux/demux_lavf.c

   1 /*
   2  * Copyright (C) 2004 Michael Niedermayer <michaelni@gmx.at>
   3  *
   4  * This file is part of MPlayer.
   5  *
   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.
  10  *
  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.
  15  *
  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.
  19  */
  20
  21 // #include <stdio.h>
  22 #include <stdlib.h>
  23 // #include <unistd.h>
  24 #include <limits.h>
  25 #include <stdbool.h>
  26
  27 #include "config.h"
  28 #include "options.h"
  29 #include "mp_msg.h"
  30 #include "av_opts.h"
  31 #include "bstr.h"
  32
  33 #include "stream/stream.h"
  34 #include "aviprint.h"
  35 #include "demuxer.h"
  36 #include "stheader.h"
  37 #include "m_option.h"
  38 #include "libvo/sub.h"
  39
  40 #include "libavformat/avformat.h"
  41 #include "libavformat/avio.h"
  42 #include "libavutil/avutil.h"
  43 #include "libavutil/avstring.h"
  44 #include "libavcodec/opt.h"
  45
  46 #include "mp_taglists.h"
  47
  48 #define INITIAL_PROBE_SIZE STREAM_BUFFER_SIZE
  49 #define SMALL_MAX_PROBE_SIZE (32 * 1024)
  50 #define PROBE_BUF_SIZE (2*1024*1024)
  51
  52 const m_option_t lavfdopts_conf[] = {
  53     OPT_INTRANGE("probesize", lavfdopts.probesize, 0, 32, INT_MAX),
  54     OPT_STRING("format", lavfdopts.format, 0),
  55     OPT_INTRANGE("analyzeduration", lavfdopts.analyzeduration, 0, 0, INT_MAX),
  56     OPT_STRING("cryptokey", lavfdopts.cryptokey, 0),
  57     OPT_STRING("o", lavfdopts.avopt, 0),
  58     {NULL, NULL, 0, 0, 0, 0, NULL}
  59 };
  60
  61 #define BIO_BUFFER_SIZE 32768
  62
  63 typedef struct lavf_priv {
  64     AVInputFormat *avif;
  65     AVFormatContext *avfc;
  66     ByteIOContext *pb;
  67     uint8_t buffer[BIO_BUFFER_SIZE];
  68     int audio_streams;
  69     int video_streams;
  70     int sub_streams;
  71     int64_t last_pts;
  72     int astreams[MAX_A_STREAMS];
  73     int vstreams[MAX_V_STREAMS];
  74     int sstreams[MAX_S_STREAMS];
  75     int cur_program;
  76 }lavf_priv_t;
  77
  78 static int mp_read(void *opaque, uint8_t *buf, int size) {
  79     struct demuxer *demuxer = opaque;
  80     struct stream *stream = demuxer->stream;
  81     int ret;
  82
  83     ret=stream_read(stream, buf, size);
  84
  85     mp_msg(MSGT_HEADER,MSGL_DBG2,"%d=mp_read(%p, %p, %d), pos: %"PRId64", eof:%d\n",
  86            ret, stream, buf, size, stream_tell(stream), stream->eof);
  87     return ret;
  88 }
  89
  90 static int64_t mp_seek(void *opaque, int64_t pos, int whence) {
  91     struct demuxer *demuxer = opaque;
  92     struct stream *stream = demuxer->stream;
  93     int64_t current_pos;
  94     mp_msg(MSGT_HEADER,MSGL_DBG2,"mp_seek(%p, %"PRId64", %d)\n", stream, pos, whence);
  95     if(whence == SEEK_CUR)
  96         pos +=stream_tell(stream);
  97     else if(whence == SEEK_END && stream->end_pos > 0)
  98         pos += stream->end_pos;
  99     else if(whence == SEEK_SET)
 100         pos += stream->start_pos;
 101     else if(whence == AVSEEK_SIZE && stream->end_pos > 0)
 102         return stream->end_pos - stream->start_pos;
 103     else
 104         return -1;
 105
 106     if(pos<0)
 107         return -1;
 108     current_pos = stream_tell(stream);
 109     if(stream_seek(stream, pos)==0) {
 110         stream_reset(stream);
 111         stream_seek(stream, current_pos);
 112         return -1;
 113     }
 114
 115     return pos - stream->start_pos;
 116 }
 117
 118 static int64_t mp_read_seek(void *opaque, int stream_idx, int64_t ts, int flags)
 119 {
 120     struct demuxer *demuxer = opaque;
 121     struct stream *stream = demuxer->stream;
 122     struct lavf_priv *priv = demuxer->priv;
 123
 124     AVStream *st = priv->avfc->streams[stream_idx];
 125     double pts = (double)ts * st->time_base.num / st->time_base.den;
 126     int ret = stream_control(stream, STREAM_CTRL_SEEK_TO_TIME, &pts);
 127     if (ret < 0)
 128         ret = AVERROR(ENOSYS);
 129     return ret;
 130 }
 131
 132 static void list_formats(void) {
 133     AVInputFormat *fmt;
 134     mp_msg(MSGT_DEMUX, MSGL_INFO, "Available lavf input formats:\n");
 135     for (fmt = first_iformat; fmt; fmt = fmt->next)
 136         mp_msg(MSGT_DEMUX, MSGL_INFO, "%15s : %s\n", fmt->name, fmt->long_name);
 137 }
 138
 139 static int lavf_check_file(demuxer_t *demuxer){
 140     struct MPOpts *opts = demuxer->opts;
 141     struct lavfdopts *lavfdopts = &opts->lavfdopts;
 142     AVProbeData avpd;
 143     lavf_priv_t *priv;
 144     int probe_data_size = 0;
 145     int read_size = INITIAL_PROBE_SIZE;
 146     int score;
 147
 148     if(!demuxer->priv)
 149         demuxer->priv=calloc(sizeof(lavf_priv_t),1);
 150     priv= demuxer->priv;
 151
 152     av_register_all();
 153
 154     char *format = lavfdopts->format;
 155     if (!format)
 156         format = demuxer->stream->lavf_type;
 157     if (format) {
 158         if (strcmp(format, "help") == 0) {
 159            list_formats();
 160            return 0;
 161         }
 162         priv->avif = av_find_input_format(format);
 163         if (!priv->avif) {
 164             mp_msg(MSGT_DEMUX, MSGL_FATAL, "Unknown lavf format %s\n", format);
 165             return 0;
 166         }
 167         mp_msg(MSGT_DEMUX,MSGL_INFO,"Forced lavf %s demuxer\n", priv->avif->long_name);
 168         return DEMUXER_TYPE_LAVF;
 169     }
 170
 171     avpd.buf = av_mallocz(FFMAX(BIO_BUFFER_SIZE, PROBE_BUF_SIZE) +
 172                           FF_INPUT_BUFFER_PADDING_SIZE);
 173     do {
 174         read_size = stream_read(demuxer->stream, avpd.buf + probe_data_size, read_size);
 175         if(read_size < 0) {
 176             av_free(avpd.buf);
 177             return 0;
 178         }
 179         probe_data_size += read_size;
 180         avpd.filename= demuxer->stream->url;
 181         if (!avpd.filename) {
 182             mp_msg(MSGT_DEMUX, MSGL_WARN, "Stream url is not set!\n");
 183             avpd.filename = "";
 184         }
 185         if (!strncmp(avpd.filename, "ffmpeg://", 9))
 186             avpd.filename += 9;
 187         avpd.buf_size= probe_data_size;
 188
 189         score = 0;
 190         priv->avif= av_probe_input_format2(&avpd, probe_data_size > 0, &score);
 191         read_size = FFMIN(2*read_size, PROBE_BUF_SIZE - probe_data_size);
 192     } while ((demuxer->desc->type != DEMUXER_TYPE_LAVF_PREFERRED ||
 193               probe_data_size < SMALL_MAX_PROBE_SIZE) &&
 194              score <= AVPROBE_SCORE_MAX / 4 &&
 195              read_size > 0 && probe_data_size < PROBE_BUF_SIZE);
 196     av_free(avpd.buf);
 197
 198     if(!priv->avif){
 199         mp_msg(MSGT_HEADER,MSGL_V,"LAVF_check: no clue about this gibberish!\n");
 200         return 0;
 201     }else
 202         mp_msg(MSGT_HEADER,MSGL_V,"LAVF_check: %s\n", priv->avif->long_name);
 203
 204     return DEMUXER_TYPE_LAVF;
 205 }
 206
 207 static const char * const preferred_list[] = {
 208     "dxa",
 209     "flv",
 210     "gxf",
 211     "nut",
 212     "nuv",
 213     "mov,mp4,m4a,3gp,3g2,mj2",
 214     "mpc",
 215     "mpc8",
 216     "mxf",
 217     "ogg",
 218     "swf",
 219     "vqf",
 220     "w64",
 221     "wv",
 222     NULL
 223 };
 224
 225 static int lavf_check_preferred_file(demuxer_t *demuxer){
 226     if (lavf_check_file(demuxer)) {
 227         const char * const *p = preferred_list;
 228         lavf_priv_t *priv = demuxer->priv;
 229         while (*p) {
 230             if (strcmp(*p, priv->avif->name) == 0)
 231                 return DEMUXER_TYPE_LAVF_PREFERRED;
 232             p++;
 233         }
 234     }
 235     return 0;
 236 }
 237
 238 static uint8_t char2int(char c) {
 239     if (c >= '0' && c <= '9') return c - '0';
 240     if (c >= 'a' && c <= 'f') return c - 'a' + 10;
 241     if (c >= 'A' && c <= 'F') return c - 'A' + 10;
 242     return 0;
 243 }
 244
 245 static void parse_cryptokey(AVFormatContext *avfc, const char *str) {
 246     int len = strlen(str) / 2;
 247     uint8_t *key = av_mallocz(len);
 248     int i;
 249     avfc->keylen = len;
 250     avfc->key = key;
 251     for (i = 0; i < len; i++, str += 2)
 252         *key++ = (char2int(str[0]) << 4) | char2int(str[1]);
 253 }
 254
 255 static void handle_stream(demuxer_t *demuxer, AVFormatContext *avfc, int i) {
 256     lavf_priv_t *priv= demuxer->priv;
 257     AVStream *st= avfc->streams[i];
 258     AVCodecContext *codec= st->codec;
 259     char *stream_type = NULL;
 260     int stream_id;
 261     AVMetadataTag *lang = av_metadata_get(st->metadata, "language", NULL, 0);
 262     AVMetadataTag *title= av_metadata_get(st->metadata, "title",    NULL, 0);
 263     int g, override_tag = mp_av_codec_get_tag(mp_codecid_override_taglists,
 264                                               codec->codec_id);
 265     // For some formats (like PCM) always trust CODEC_ID_* more than codec_tag
 266     if (override_tag)
 267         codec->codec_tag = override_tag;
 268
 269     switch(codec->codec_type){
 270         case CODEC_TYPE_AUDIO:{
 271             WAVEFORMATEX *wf;
 272             sh_audio_t* sh_audio;
 273             sh_audio = new_sh_audio_aid(demuxer, i, priv->audio_streams);
 274             if(!sh_audio)
 275                 break;
 276             stream_type = "audio";
 277             priv->astreams[priv->audio_streams] = i;
 278             wf= calloc(sizeof(WAVEFORMATEX) + codec->extradata_size, 1);
 279             // mp4a tag is used for all mp4 files no matter what they actually contain
 280             if(codec->codec_tag == MKTAG('m', 'p', '4', 'a'))
 281                 codec->codec_tag= 0;
 282             if(!codec->codec_tag)
 283                 codec->codec_tag= mp_av_codec_get_tag(mp_wav_taglists, codec->codec_id);
 284             wf->wFormatTag= codec->codec_tag;
 285             wf->nChannels= codec->channels;
 286             wf->nSamplesPerSec= codec->sample_rate;
 287             wf->nAvgBytesPerSec= codec->bit_rate/8;
 288             wf->nBlockAlign= codec->block_align ? codec->block_align : 1;
 289             wf->wBitsPerSample= codec->bits_per_coded_sample;
 290             wf->cbSize= codec->extradata_size;
 291             if(codec->extradata_size)
 292                 memcpy(wf + 1, codec->extradata, codec->extradata_size);
 293             sh_audio->wf= wf;
 294             sh_audio->audio.dwSampleSize= codec->block_align;
 295             if(codec->frame_size && codec->sample_rate){
 296                 sh_audio->audio.dwScale=codec->frame_size;
 297                 sh_audio->audio.dwRate= codec->sample_rate;
 298             }else{
 299                 sh_audio->audio.dwScale= codec->block_align ? codec->block_align*8 : 8;
 300                 sh_audio->audio.dwRate = codec->bit_rate;
 301             }
 302             g= av_gcd(sh_audio->audio.dwScale, sh_audio->audio.dwRate);
 303             sh_audio->audio.dwScale /= g;
 304             sh_audio->audio.dwRate  /= g;
 305 //          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);
 306             sh_audio->ds= demuxer->audio;
 307             sh_audio->format= codec->codec_tag;
 308             sh_audio->channels= codec->channels;
 309             sh_audio->samplerate= codec->sample_rate;
 310             sh_audio->i_bps= codec->bit_rate/8;
 311             switch (codec->codec_id) {
 312                 case CODEC_ID_PCM_S8:
 313                 case CODEC_ID_PCM_U8:
 314                     sh_audio->samplesize = 1;
 315                     break;
 316                 case CODEC_ID_PCM_S16LE:
 317                 case CODEC_ID_PCM_S16BE:
 318                 case CODEC_ID_PCM_U16LE:
 319                 case CODEC_ID_PCM_U16BE:
 320                     sh_audio->samplesize = 2;
 321                     break;
 322                 case CODEC_ID_PCM_ALAW:
 323                     sh_audio->format = 0x6;
 324                     break;
 325                 case CODEC_ID_PCM_MULAW:
 326                     sh_audio->format = 0x7;
 327                     break;
 328             }
 329             if (title && title->value)
 330                 mp_msg(MSGT_IDENTIFY, MSGL_INFO, "ID_AID_%d_NAME=%s\n", priv->audio_streams, title->value);
 331             if (lang && lang->value) {
 332               sh_audio->lang = strdup(lang->value);
 333               mp_msg(MSGT_IDENTIFY, MSGL_INFO, "ID_AID_%d_LANG=%s\n", priv->audio_streams, sh_audio->lang);
 334             }
 335             if (st->disposition & AV_DISPOSITION_DEFAULT)
 336               sh_audio->default_track = 1;
 337             if(mp_msg_test(MSGT_HEADER,MSGL_V) ) print_wave_header(sh_audio->wf, MSGL_V);
 338             // select the first audio stream
 339             if (!demuxer->audio->sh) {
 340                 demuxer->audio->id = i;
 341                 demuxer->audio->sh= demuxer->a_streams[i];
 342             } else
 343                 st->discard= AVDISCARD_ALL;
 344             stream_id = priv->audio_streams++;
 345             break;
 346         }
 347         case CODEC_TYPE_VIDEO:{
 348             sh_video_t* sh_video;
 349             BITMAPINFOHEADER *bih;
 350             sh_video=new_sh_video_vid(demuxer, i, priv->video_streams);
 351             if(!sh_video) break;
 352             stream_type = "video";
 353             priv->vstreams[priv->video_streams] = i;
 354             bih=calloc(sizeof(BITMAPINFOHEADER) + codec->extradata_size,1);
 355
 356             if(codec->codec_id == CODEC_ID_RAWVIDEO) {
 357                 switch (codec->pix_fmt) {
 358                     case PIX_FMT_RGB24:
 359                         codec->codec_tag= MKTAG(24, 'B', 'G', 'R');
 360                 }
 361             }
 362             if(!codec->codec_tag)
 363                 codec->codec_tag= mp_av_codec_get_tag(mp_bmp_taglists, codec->codec_id);
 364             bih->biSize= sizeof(BITMAPINFOHEADER) + codec->extradata_size;
 365             bih->biWidth= codec->width;
 366             bih->biHeight= codec->height;
 367             bih->biBitCount= codec->bits_per_coded_sample;
 368             bih->biSizeImage = bih->biWidth * bih->biHeight * bih->biBitCount/8;
 369             bih->biCompression= codec->codec_tag;
 370             sh_video->bih= bih;
 371             sh_video->disp_w= codec->width;
 372             sh_video->disp_h= codec->height;
 373             if (st->time_base.den) { /* if container has time_base, use that */
 374                 sh_video->video.dwRate= st->time_base.den;
 375                 sh_video->video.dwScale= st->time_base.num;
 376             } else {
 377                 sh_video->video.dwRate= codec->time_base.den;
 378                 sh_video->video.dwScale= codec->time_base.num;
 379             }
 380             sh_video->fps=av_q2d(st->r_frame_rate);
 381             sh_video->frametime=1/av_q2d(st->r_frame_rate);
 382             sh_video->format=bih->biCompression;
 383             if(st->sample_aspect_ratio.num)
 384                 sh_video->aspect = codec->width  * st->sample_aspect_ratio.num
 385                          / (float)(codec->height * st->sample_aspect_ratio.den);
 386             else
 387                 sh_video->aspect=codec->width  * codec->sample_aspect_ratio.num
 388                        / (float)(codec->height * codec->sample_aspect_ratio.den);
 389             sh_video->i_bps=codec->bit_rate/8;
 390             if (title && title->value)
 391                 mp_msg(MSGT_IDENTIFY, MSGL_INFO, "ID_VID_%d_NAME=%s\n", priv->video_streams, title->value);
 392             mp_msg(MSGT_DEMUX,MSGL_DBG2,"aspect= %d*%d/(%d*%d)\n",
 393                 codec->width, codec->sample_aspect_ratio.num,
 394                 codec->height, codec->sample_aspect_ratio.den);
 395
 396             sh_video->ds= demuxer->video;
 397             if(codec->extradata_size)
 398                 memcpy(sh_video->bih + 1, codec->extradata, codec->extradata_size);
 399             if( mp_msg_test(MSGT_HEADER,MSGL_V) ) print_video_header(sh_video->bih, MSGL_V);
 400             /*
 401                 short biPlanes;
 402                 int  biXPelsPerMeter;
 403                 int  biYPelsPerMeter;
 404                 int biClrUsed;
 405                 int biClrImportant;
 406             */
 407             if(demuxer->video->id != i && demuxer->video->id != -1)
 408                 st->discard= AVDISCARD_ALL;
 409             else{
 410                 demuxer->video->id = i;
 411                 demuxer->video->sh= demuxer->v_streams[i];
 412             }
 413             stream_id = priv->video_streams++;
 414             break;
 415         }
 416         case CODEC_TYPE_SUBTITLE:{
 417             sh_sub_t* sh_sub;
 418             char type;
 419             /* only support text subtitles for now */
 420             if(codec->codec_id == CODEC_ID_TEXT)
 421                 type = 't';
 422             else if(codec->codec_id == CODEC_ID_MOV_TEXT)
 423                 type = 'm';
 424             else if(codec->codec_id == CODEC_ID_SSA)
 425                 type = 'a';
 426             else if(codec->codec_id == CODEC_ID_DVD_SUBTITLE)
 427                 type = 'v';
 428             else if(codec->codec_id == CODEC_ID_XSUB)
 429                 type = 'x';
 430             else if(codec->codec_id == CODEC_ID_DVB_SUBTITLE)
 431                 type = 'b';
 432             else if(codec->codec_id == CODEC_ID_DVB_TELETEXT)
 433                 type = 'd';
 434             else if(codec->codec_id == CODEC_ID_HDMV_PGS_SUBTITLE)
 435                 type = 'p';
 436             else
 437                 break;
 438             sh_sub = new_sh_sub_sid(demuxer, i, priv->sub_streams);
 439             if(!sh_sub) break;
 440             stream_type = "subtitle";
 441             priv->sstreams[priv->sub_streams] = i;
 442             sh_sub->type = type;
 443             if (codec->extradata_size) {
 444                 sh_sub->extradata = malloc(codec->extradata_size);
 445                 memcpy(sh_sub->extradata, codec->extradata, codec->extradata_size);
 446                 sh_sub->extradata_len = codec->extradata_size;
 447             }
 448             if (title && title->value)
 449                 mp_msg(MSGT_IDENTIFY, MSGL_INFO, "ID_SID_%d_NAME=%s\n", priv->sub_streams, title->value);
 450             if (lang && lang->value) {
 451               sh_sub->lang = strdup(lang->value);
 452               mp_msg(MSGT_IDENTIFY, MSGL_INFO, "ID_SID_%d_LANG=%s\n", priv->sub_streams, sh_sub->lang);
 453             }
 454             if (st->disposition & AV_DISPOSITION_DEFAULT)
 455               sh_sub->default_track = 1;
 456             stream_id = priv->sub_streams++;
 457             break;
 458         }
 459         case CODEC_TYPE_ATTACHMENT:{
 460             if (st->codec->codec_id == CODEC_ID_TTF)
 461                 demuxer_add_attachment(demuxer, BSTR(st->filename),
 462                                        BSTR("application/x-truetype-font"),
 463                                        (struct bstr){codec->extradata,
 464                                                      codec->extradata_size});
 465             break;
 466         }
 467         default:
 468             st->discard= AVDISCARD_ALL;
 469     }
 470     if (stream_type) {
 471         AVCodec *avc = avcodec_find_decoder(codec->codec_id);
 472         const char *codec_name = avc ? avc->name : "unknown";
 473         if (!avc && *stream_type == 's' && demuxer->s_streams[stream_id])
 474             codec_name = sh_sub_type2str(((sh_sub_t *)demuxer->s_streams[stream_id])->type);
 475         mp_msg(MSGT_DEMUX, MSGL_INFO, "[lavf] stream %d: %s (%s), -%cid %d", i, stream_type, codec_name, *stream_type, stream_id);
 476         if (lang && lang->value && *stream_type != 'v')
 477             mp_msg(MSGT_DEMUX, MSGL_INFO, ", -%clang %s", *stream_type, lang->value);
 478         if (title && title->value)
 479             mp_msg(MSGT_DEMUX, MSGL_INFO, ", %s", title->value);
 480         mp_msg(MSGT_DEMUX, MSGL_INFO, "\n");
 481     }
 482 }
 483
 484 static demuxer_t* demux_open_lavf(demuxer_t *demuxer){
 485     struct MPOpts *opts = demuxer->opts;
 486     struct lavfdopts *lavfdopts = &opts->lavfdopts;
 487     AVFormatContext *avfc;
 488     AVFormatParameters ap;
 489     const AVOption *opt;
 490     AVMetadataTag *t = NULL;
 491     lavf_priv_t *priv= demuxer->priv;
 492     int i;
 493     char mp_filename[256]="mp:";
 494
 495     memset(&ap, 0, sizeof(AVFormatParameters));
 496
 497     stream_seek(demuxer->stream, 0);
 498
 499     avfc = avformat_alloc_context();
 500
 501     if (lavfdopts->cryptokey)
 502         parse_cryptokey(avfc, lavfdopts->cryptokey);
 503     if (opts->user_correct_pts != 0)
 504         avfc->flags |= AVFMT_FLAG_GENPTS;
 505     if (index_mode == 0)
 506         avfc->flags |= AVFMT_FLAG_IGNIDX;
 507
 508     ap.prealloced_context = 1;
 509     if (lavfdopts->probesize) {
 510         opt = av_set_int(avfc, "probesize", lavfdopts->probesize);
 511         if(!opt) mp_msg(MSGT_HEADER,MSGL_ERR, "demux_lavf, couldn't set option probesize to %u\n", lavfdopts->probesize);
 512     }
 513     if (lavfdopts->analyzeduration) {
 514         opt = av_set_int(avfc, "analyzeduration",
 515                          lavfdopts->analyzeduration * AV_TIME_BASE);
 516         if (!opt)
 517             mp_msg(MSGT_HEADER, MSGL_ERR, "demux_lavf, couldn't set option "
 518                    "analyzeduration to %u\n", lavfdopts->analyzeduration);
 519     }
 520
 521     if (lavfdopts->avopt){
 522         if(parse_avopts(avfc, lavfdopts->avopt) < 0){
 523             mp_msg(MSGT_HEADER,MSGL_ERR, "Your options /%s/ look like gibberish to me pal\n", lavfdopts->avopt);
 524             return NULL;
 525         }
 526     }
 527
 528     if(demuxer->stream->url) {
 529         if (!strncmp(demuxer->stream->url, "ffmpeg://rtsp:", 14))
 530             av_strlcpy(mp_filename, demuxer->stream->url + 9, sizeof(mp_filename));
 531         else
 532             av_strlcat(mp_filename, demuxer->stream->url, sizeof(mp_filename));
 533     } else
 534         av_strlcat(mp_filename, "foobar.dummy", sizeof(mp_filename));
 535
 536     priv->pb = av_alloc_put_byte(priv->buffer, BIO_BUFFER_SIZE, 0,
 537                                  demuxer, mp_read, NULL, mp_seek);
 538     priv->pb->read_seek = mp_read_seek;
 539     priv->pb->is_streamed = !demuxer->stream->end_pos || (demuxer->stream->flags & MP_STREAM_SEEK) != MP_STREAM_SEEK;
 540
 541     if(av_open_input_stream(&avfc, priv->pb, mp_filename, priv->avif, &ap)<0){
 542         mp_msg(MSGT_HEADER,MSGL_ERR,"LAVF_header: av_open_input_stream() failed\n");
 543         return NULL;
 544     }
 545
 546     priv->avfc= avfc;
 547
 548     if(av_find_stream_info(avfc) < 0){
 549         mp_msg(MSGT_HEADER,MSGL_ERR,"LAVF_header: av_find_stream_info() failed\n");
 550         return NULL;
 551     }
 552
 553     /* Add metadata. */
 554     av_metadata_conv(avfc, NULL, avfc->iformat->metadata_conv);
 555     while((t = av_metadata_get(avfc->metadata, "", t, AV_METADATA_IGNORE_SUFFIX)))
 556         demux_info_add(demuxer, t->key, t->value);
 557
 558     for(i=0; i < avfc->nb_chapters; i++) {
 559         AVChapter *c = avfc->chapters[i];
 560         uint64_t start = av_rescale_q(c->start, c->time_base, (AVRational){1,1000});
 561         uint64_t end   = av_rescale_q(c->end, c->time_base, (AVRational){1,1000});
 562         t = av_metadata_get(c->metadata, "title", NULL, 0);
 563         demuxer_add_chapter(demuxer, t ? BSTR(t->value) : BSTR(NULL), start, end);
 564     }
 565
 566     for(i=0; i<avfc->nb_streams; i++)
 567         handle_stream(demuxer, avfc, i);
 568     if(avfc->nb_programs) {
 569         int p;
 570         for (p = 0; p < avfc->nb_programs; p++) {
 571             AVProgram *program = avfc->programs[p];
 572             t = av_metadata_get(program->metadata, "title", NULL, 0);
 573             mp_msg(MSGT_HEADER,MSGL_INFO,"LAVF: Program %d %s\n", program->id, t ? t->value : "");
 574         }
 575     }
 576
 577     mp_msg(MSGT_HEADER,MSGL_V,"LAVF: %d audio and %d video streams found\n",priv->audio_streams,priv->video_streams);
 578     mp_msg(MSGT_HEADER,MSGL_V,"LAVF: build %d\n", LIBAVFORMAT_BUILD);
 579     if(!priv->audio_streams) demuxer->audio->id=-2;  // nosound
 580 //    else if(best_audio > 0 && demuxer->audio->id == -1) demuxer->audio->id=best_audio;
 581     if(!priv->video_streams){
 582         if(!priv->audio_streams){
 583             mp_msg(MSGT_HEADER,MSGL_ERR,"LAVF: no audio or video headers found - broken file?\n");
 584             return NULL;
 585         }
 586         demuxer->video->id=-2; // audio-only
 587     } //else if (best_video > 0 && demuxer->video->id == -1) demuxer->video->id = best_video;
 588
 589     demuxer->accurate_seek = true;
 590
 591     return demuxer;
 592 }
 593
 594 static int demux_lavf_fill_buffer(demuxer_t *demux, demux_stream_t *dsds){
 595     lavf_priv_t *priv= demux->priv;
 596     AVPacket pkt;
 597     demux_packet_t *dp;
 598     demux_stream_t *ds;
 599     int id;
 600     mp_msg(MSGT_DEMUX,MSGL_DBG2,"demux_lavf_fill_buffer()\n");
 601
 602     demux->filepos=stream_tell(demux->stream);
 603
 604     if(av_read_frame(priv->avfc, &pkt) < 0)
 605         return 0;
 606
 607     id= pkt.stream_index;
 608
 609     if(id==demux->audio->id){
 610         // audio
 611         ds=demux->audio;
 612         if(!ds->sh){
 613             ds->sh=demux->a_streams[id];
 614             mp_msg(MSGT_DEMUX,MSGL_V,"Auto-selected LAVF audio ID = %d\n",ds->id);
 615         }
 616     } else if(id==demux->video->id){
 617         // video
 618         ds=demux->video;
 619         if(!ds->sh){
 620             ds->sh=demux->v_streams[id];
 621             mp_msg(MSGT_DEMUX,MSGL_V,"Auto-selected LAVF video ID = %d\n",ds->id);
 622         }
 623     } else if(id==demux->sub->id){
 624         // subtitle
 625         ds=demux->sub;
 626         sub_utf8=1;
 627     } else {
 628         av_free_packet(&pkt);
 629         return 1;
 630     }
 631
 632     if(0/*pkt.destruct == av_destruct_packet*/){
 633         //ok kids, dont try this at home :)
 634         dp=malloc(sizeof(demux_packet_t));
 635         dp->len=pkt.size;
 636         dp->next=NULL;
 637         dp->refcount=1;
 638         dp->master=NULL;
 639         dp->buffer=pkt.data;
 640         pkt.destruct= NULL;
 641     }else{
 642         dp=new_demux_packet(pkt.size);
 643         memcpy(dp->buffer, pkt.data, pkt.size);
 644         av_free_packet(&pkt);
 645     }
 646
 647     if(pkt.pts != AV_NOPTS_VALUE){
 648         dp->pts=pkt.pts * av_q2d(priv->avfc->streams[id]->time_base);
 649         priv->last_pts= dp->pts * AV_TIME_BASE;
 650         // always set endpts for subtitles, even if PKT_FLAG_KEY is not set,
 651         // otherwise they will stay on screen to long if e.g. ASS is demuxed from mkv
 652         if((ds == demux->sub || (pkt.flags & PKT_FLAG_KEY)) &&
 653            pkt.convergence_duration > 0)
 654             dp->endpts = dp->pts + pkt.convergence_duration * av_q2d(priv->avfc->streams[id]->time_base);
 655     }
 656     dp->pos=demux->filepos;
 657     dp->flags= !!(pkt.flags&PKT_FLAG_KEY);
 658     // append packet to DS stream:
 659     ds_add_packet(ds,dp);
 660     return 1;
 661 }
 662
 663 static void demux_seek_lavf(demuxer_t *demuxer, float rel_seek_secs, float audio_delay, int flags){
 664     lavf_priv_t *priv = demuxer->priv;
 665     int avsflags = 0;
 666     mp_msg(MSGT_DEMUX,MSGL_DBG2,"demux_seek_lavf(%p, %f, %f, %d)\n", demuxer, rel_seek_secs, audio_delay, flags);
 667
 668     if (flags & SEEK_ABSOLUTE) {
 669       priv->last_pts = 0;
 670     } else {
 671       if (rel_seek_secs < 0) avsflags = AVSEEK_FLAG_BACKWARD;
 672     }
 673     if (flags & SEEK_FORWARD)
 674         avsflags = 0;
 675     else if (flags & SEEK_BACKWARD)
 676         avsflags = AVSEEK_FLAG_BACKWARD;
 677     if (flags & SEEK_FACTOR) {
 678       if (priv->avfc->duration == 0 || priv->avfc->duration == AV_NOPTS_VALUE)
 679         return;
 680       priv->last_pts += rel_seek_secs * priv->avfc->duration;
 681     } else {
 682       priv->last_pts += rel_seek_secs * AV_TIME_BASE;
 683     }
 684     if (av_seek_frame(priv->avfc, -1, priv->last_pts, avsflags) < 0) {
 685         avsflags ^= AVSEEK_FLAG_BACKWARD;
 686         av_seek_frame(priv->avfc, -1, priv->last_pts, avsflags);
 687     }
 688 }
 689
 690 static int demux_lavf_control(demuxer_t *demuxer, int cmd, void *arg)
 691 {
 692     lavf_priv_t *priv = demuxer->priv;
 693
 694     switch (cmd) {
 695         case DEMUXER_CTRL_CORRECT_PTS:
 696             return DEMUXER_CTRL_OK;
 697         case DEMUXER_CTRL_GET_TIME_LENGTH:
 698             if (priv->avfc->duration == 0 || priv->avfc->duration == AV_NOPTS_VALUE)
 699                 return DEMUXER_CTRL_DONTKNOW;
 700
 701             *((double *)arg) = (double)priv->avfc->duration / AV_TIME_BASE;
 702             return DEMUXER_CTRL_OK;
 703
 704         case DEMUXER_CTRL_GET_PERCENT_POS:
 705             if (priv->avfc->duration == 0 || priv->avfc->duration == AV_NOPTS_VALUE)
 706                 return DEMUXER_CTRL_DONTKNOW;
 707
 708             *((int *)arg) = (int)((priv->last_pts - priv->avfc->start_time)*100 / priv->avfc->duration);
 709             return DEMUXER_CTRL_OK;
 710         case DEMUXER_CTRL_SWITCH_AUDIO:
 711         case DEMUXER_CTRL_SWITCH_VIDEO:
 712         {
 713             int id = *((int*)arg);
 714             int newid = -2;
 715             int i, curridx = -1;
 716             int nstreams, *pstreams;
 717             demux_stream_t *ds;
 718
 719             if(cmd == DEMUXER_CTRL_SWITCH_VIDEO)
 720             {
 721                 ds = demuxer->video;
 722                 nstreams = priv->video_streams;
 723                 pstreams = priv->vstreams;
 724             }
 725             else
 726             {
 727                 ds = demuxer->audio;
 728                 nstreams = priv->audio_streams;
 729                 pstreams = priv->astreams;
 730             }
 731             for(i = 0; i < nstreams; i++)
 732             {
 733                 if(pstreams[i] == ds->id) //current stream id
 734                 {
 735                     curridx = i;
 736                     break;
 737                 }
 738             }
 739
 740             if(id == -2) { // no sound
 741                 i = -1;
 742             } else if(id == -1) { // next track
 743                 i = (curridx + 2) % (nstreams + 1) - 1;
 744                 if (i >= 0)
 745                     newid = pstreams[i];
 746             }
 747             else // select track by id
 748             {
 749                 if (id >= 0 && id < nstreams) {
 750                     i = id;
 751                     newid = pstreams[i];
 752                 }
 753             }
 754             if (i == curridx) {
 755                 *(int *) arg = curridx;
 756                 return DEMUXER_CTRL_OK;
 757             } else {
 758                 ds_free_packs(ds);
 759                 if(ds->id >= 0)
 760                     priv->avfc->streams[ds->id]->discard = AVDISCARD_ALL;
 761                 ds->id = newid;
 762                 *(int *) arg = i < 0 ? -2 : i;
 763                 if(newid >= 0)
 764                     priv->avfc->streams[newid]->discard = AVDISCARD_NONE;
 765                 return DEMUXER_CTRL_OK;
 766             }
 767         }
 768         case DEMUXER_CTRL_IDENTIFY_PROGRAM:
 769         {
 770             demux_program_t *prog = arg;
 771             AVProgram *program;
 772             int p, i;
 773             int start;
 774
 775             prog->vid = prog->aid = prog->sid = -2;     //no audio and no video by default
 776             if(priv->avfc->nb_programs < 1)
 777                 return DEMUXER_CTRL_DONTKNOW;
 778
 779             if(prog->progid == -1)
 780             {
 781                 p = 0;
 782                 while(p<priv->avfc->nb_programs && priv->avfc->programs[p]->id != priv->cur_program)
 783                     p++;
 784                 p = (p + 1) % priv->avfc->nb_programs;
 785             }
 786             else
 787             {
 788                 for(i=0; i<priv->avfc->nb_programs; i++)
 789                     if(priv->avfc->programs[i]->id == prog->progid)
 790                         break;
 791                 if(i==priv->avfc->nb_programs)
 792                     return DEMUXER_CTRL_DONTKNOW;
 793                 p = i;
 794             }
 795             start = p;
 796 redo:
 797             program = priv->avfc->programs[p];
 798             for(i=0; i<program->nb_stream_indexes; i++)
 799             {
 800                 switch(priv->avfc->streams[program->stream_index[i]]->codec->codec_type)
 801                 {
 802                     case CODEC_TYPE_VIDEO:
 803                         if(prog->vid == -2)
 804                             prog->vid = program->stream_index[i];
 805                         break;
 806                     case CODEC_TYPE_AUDIO:
 807                         if(prog->aid == -2)
 808                             prog->aid = program->stream_index[i];
 809                         break;
 810                     case CODEC_TYPE_SUBTITLE:
 811                         if(prog->sid == -2 && priv->avfc->streams[program->stream_index[i]]->codec->codec_id == CODEC_ID_TEXT)
 812                             prog->sid = program->stream_index[i];
 813                         break;
 814                 }
 815             }
 816             if(prog->progid == -1 && prog->vid == -2 && prog->aid == -2)
 817             {
 818                 p = (p + 1) % priv->avfc->nb_programs;
 819                 if (p == start)
 820                     return DEMUXER_CTRL_DONTKNOW;
 821                 goto redo;
 822             }
 823             priv->cur_program = prog->progid = program->id;
 824             return DEMUXER_CTRL_OK;
 825         }
 826         default:
 827             return DEMUXER_CTRL_NOTIMPL;
 828     }
 829 }
 830
 831 static void demux_close_lavf(demuxer_t *demuxer)
 832 {
 833     lavf_priv_t* priv = demuxer->priv;
 834     if (priv){
 835         if(priv->avfc)
 836        {
 837          av_freep(&priv->avfc->key);
 838          av_close_input_stream(priv->avfc);
 839         }
 840         av_freep(&priv->pb);
 841         free(priv); demuxer->priv= NULL;
 842     }
 843 }
 844
 845
 846 const demuxer_desc_t demuxer_desc_lavf = {
 847   "libavformat demuxer",
 848   "lavf",
 849   "libavformat",
 850   "Michael Niedermayer",
 851   "supports many formats, requires libavformat",
 852   DEMUXER_TYPE_LAVF,
 853   0, // Check after other demuxer
 854   lavf_check_file,
 855   demux_lavf_fill_buffer,
 856   demux_open_lavf,
 857   demux_close_lavf,
 858   demux_seek_lavf,
 859   demux_lavf_control
 860 };
 861
 862 const demuxer_desc_t demuxer_desc_lavf_preferred = {
 863   "libavformat preferred demuxer",
 864   "lavfpref",
 865   "libavformat",
 866   "Michael Niedermayer",
 867   "supports many formats, requires libavformat",
 868   DEMUXER_TYPE_LAVF_PREFERRED,
 869   1,
 870   lavf_check_preferred_file,
 871   demux_lavf_fill_buffer,
 872   demux_open_lavf,
 873   demux_close_lavf,
 874   demux_seek_lavf,
 875   demux_lavf_control
 876 };