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