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         mp_msg(MSGT_DEMUX, MSGL_INFO, "[lavf] stream %d: %s (%s), -%cid %d", i, stream_type, avc ? avc->name : "unknown", *stream_type, stream_id);
 473         if (lang && lang->value && *stream_type != 'v')
 474             mp_msg(MSGT_DEMUX, MSGL_INFO, ", -%clang %s", *stream_type, lang->value);
 475         if (title && title->value)
 476             mp_msg(MSGT_DEMUX, MSGL_INFO, ", %s", title->value);
 477         mp_msg(MSGT_DEMUX, MSGL_INFO, "\n");
 478     }
 479 }
 480
 481 static demuxer_t* demux_open_lavf(demuxer_t *demuxer){
 482     struct MPOpts *opts = demuxer->opts;
 483     struct lavfdopts *lavfdopts = &opts->lavfdopts;
 484     AVFormatContext *avfc;
 485     AVFormatParameters ap;
 486     const AVOption *opt;
 487     AVMetadataTag *t = NULL;
 488     lavf_priv_t *priv= demuxer->priv;
 489     int i;
 490     char mp_filename[256]="mp:";
 491
 492     memset(&ap, 0, sizeof(AVFormatParameters));
 493
 494     stream_seek(demuxer->stream, 0);
 495
 496     avfc = avformat_alloc_context();
 497
 498     if (lavfdopts->cryptokey)
 499         parse_cryptokey(avfc, lavfdopts->cryptokey);
 500     if (opts->user_correct_pts != 0)
 501         avfc->flags |= AVFMT_FLAG_GENPTS;
 502     if (index_mode == 0)
 503         avfc->flags |= AVFMT_FLAG_IGNIDX;
 504
 505     ap.prealloced_context = 1;
 506     if (lavfdopts->probesize) {
 507         opt = av_set_int(avfc, "probesize", lavfdopts->probesize);
 508         if(!opt) mp_msg(MSGT_HEADER,MSGL_ERR, "demux_lavf, couldn't set option probesize to %u\n", lavfdopts->probesize);
 509     }
 510     if (lavfdopts->analyzeduration) {
 511         opt = av_set_int(avfc, "analyzeduration",
 512                          lavfdopts->analyzeduration * AV_TIME_BASE);
 513         if (!opt)
 514             mp_msg(MSGT_HEADER, MSGL_ERR, "demux_lavf, couldn't set option "
 515                    "analyzeduration to %u\n", lavfdopts->analyzeduration);
 516     }
 517
 518     if (lavfdopts->avopt){
 519         if(parse_avopts(avfc, lavfdopts->avopt) < 0){
 520             mp_msg(MSGT_HEADER,MSGL_ERR, "Your options /%s/ look like gibberish to me pal\n", lavfdopts->avopt);
 521             return NULL;
 522         }
 523     }
 524
 525     if(demuxer->stream->url) {
 526         if (!strncmp(demuxer->stream->url, "ffmpeg://rtsp:", 14))
 527             av_strlcpy(mp_filename, demuxer->stream->url + 9, sizeof(mp_filename));
 528         else
 529             av_strlcat(mp_filename, demuxer->stream->url, sizeof(mp_filename));
 530     } else
 531         av_strlcat(mp_filename, "foobar.dummy", sizeof(mp_filename));
 532
 533     priv->pb = av_alloc_put_byte(priv->buffer, BIO_BUFFER_SIZE, 0,
 534                                  demuxer, mp_read, NULL, mp_seek);
 535     priv->pb->read_seek = mp_read_seek;
 536     priv->pb->is_streamed = !demuxer->stream->end_pos || (demuxer->stream->flags & MP_STREAM_SEEK) != MP_STREAM_SEEK;
 537
 538     if(av_open_input_stream(&avfc, priv->pb, mp_filename, priv->avif, &ap)<0){
 539         mp_msg(MSGT_HEADER,MSGL_ERR,"LAVF_header: av_open_input_stream() failed\n");
 540         return NULL;
 541     }
 542
 543     priv->avfc= avfc;
 544
 545     if(av_find_stream_info(avfc) < 0){
 546         mp_msg(MSGT_HEADER,MSGL_ERR,"LAVF_header: av_find_stream_info() failed\n");
 547         return NULL;
 548     }
 549
 550     /* Add metadata. */
 551     av_metadata_conv(avfc, NULL, avfc->iformat->metadata_conv);
 552     while((t = av_metadata_get(avfc->metadata, "", t, AV_METADATA_IGNORE_SUFFIX)))
 553         demux_info_add(demuxer, t->key, t->value);
 554
 555     for(i=0; i < avfc->nb_chapters; i++) {
 556         AVChapter *c = avfc->chapters[i];
 557         uint64_t start = av_rescale_q(c->start, c->time_base, (AVRational){1,1000});
 558         uint64_t end   = av_rescale_q(c->end, c->time_base, (AVRational){1,1000});
 559         t = av_metadata_get(c->metadata, "title", NULL, 0);
 560         demuxer_add_chapter(demuxer, t ? BSTR(t->value) : BSTR(NULL), start, end);
 561     }
 562
 563     for(i=0; i<avfc->nb_streams; i++)
 564         handle_stream(demuxer, avfc, i);
 565     if(avfc->nb_programs) {
 566         int p;
 567         for (p = 0; p < avfc->nb_programs; p++) {
 568             AVProgram *program = avfc->programs[p];
 569             t = av_metadata_get(program->metadata, "title", NULL, 0);
 570             mp_msg(MSGT_HEADER,MSGL_INFO,"LAVF: Program %d %s\n", program->id, t ? t->value : "");
 571         }
 572     }
 573
 574     mp_msg(MSGT_HEADER,MSGL_V,"LAVF: %d audio and %d video streams found\n",priv->audio_streams,priv->video_streams);
 575     mp_msg(MSGT_HEADER,MSGL_V,"LAVF: build %d\n", LIBAVFORMAT_BUILD);
 576     if(!priv->audio_streams) demuxer->audio->id=-2;  // nosound
 577 //    else if(best_audio > 0 && demuxer->audio->id == -1) demuxer->audio->id=best_audio;
 578     if(!priv->video_streams){
 579         if(!priv->audio_streams){
 580             mp_msg(MSGT_HEADER,MSGL_ERR,"LAVF: no audio or video headers found - broken file?\n");
 581             return NULL;
 582         }
 583         demuxer->video->id=-2; // audio-only
 584     } //else if (best_video > 0 && demuxer->video->id == -1) demuxer->video->id = best_video;
 585
 586     demuxer->accurate_seek = true;
 587
 588     return demuxer;
 589 }
 590
 591 static int demux_lavf_fill_buffer(demuxer_t *demux, demux_stream_t *dsds){
 592     lavf_priv_t *priv= demux->priv;
 593     AVPacket pkt;
 594     demux_packet_t *dp;
 595     demux_stream_t *ds;
 596     int id;
 597     mp_msg(MSGT_DEMUX,MSGL_DBG2,"demux_lavf_fill_buffer()\n");
 598
 599     demux->filepos=stream_tell(demux->stream);
 600
 601     if(av_read_frame(priv->avfc, &pkt) < 0)
 602         return 0;
 603
 604     id= pkt.stream_index;
 605
 606     if(id==demux->audio->id){
 607         // audio
 608         ds=demux->audio;
 609         if(!ds->sh){
 610             ds->sh=demux->a_streams[id];
 611             mp_msg(MSGT_DEMUX,MSGL_V,"Auto-selected LAVF audio ID = %d\n",ds->id);
 612         }
 613     } else if(id==demux->video->id){
 614         // video
 615         ds=demux->video;
 616         if(!ds->sh){
 617             ds->sh=demux->v_streams[id];
 618             mp_msg(MSGT_DEMUX,MSGL_V,"Auto-selected LAVF video ID = %d\n",ds->id);
 619         }
 620     } else if(id==demux->sub->id){
 621         // subtitle
 622         ds=demux->sub;
 623         sub_utf8=1;
 624     } else {
 625         av_free_packet(&pkt);
 626         return 1;
 627     }
 628
 629     if(0/*pkt.destruct == av_destruct_packet*/){
 630         //ok kids, dont try this at home :)
 631         dp=malloc(sizeof(demux_packet_t));
 632         dp->len=pkt.size;
 633         dp->next=NULL;
 634         dp->refcount=1;
 635         dp->master=NULL;
 636         dp->buffer=pkt.data;
 637         pkt.destruct= NULL;
 638     }else{
 639         dp=new_demux_packet(pkt.size);
 640         memcpy(dp->buffer, pkt.data, pkt.size);
 641         av_free_packet(&pkt);
 642     }
 643
 644     if(pkt.pts != AV_NOPTS_VALUE){
 645         dp->pts=pkt.pts * av_q2d(priv->avfc->streams[id]->time_base);
 646         priv->last_pts= dp->pts * AV_TIME_BASE;
 647         if(pkt.flags & PKT_FLAG_KEY && pkt.convergence_duration > 0)
 648             dp->endpts = dp->pts + pkt.convergence_duration * av_q2d(priv->avfc->streams[id]->time_base);
 649     }
 650     dp->pos=demux->filepos;
 651     dp->flags= !!(pkt.flags&PKT_FLAG_KEY);
 652     // append packet to DS stream:
 653     ds_add_packet(ds,dp);
 654     return 1;
 655 }
 656
 657 static void demux_seek_lavf(demuxer_t *demuxer, float rel_seek_secs, float audio_delay, int flags){
 658     lavf_priv_t *priv = demuxer->priv;
 659     int avsflags = 0;
 660     mp_msg(MSGT_DEMUX,MSGL_DBG2,"demux_seek_lavf(%p, %f, %f, %d)\n", demuxer, rel_seek_secs, audio_delay, flags);
 661
 662     if (flags & SEEK_ABSOLUTE) {
 663       priv->last_pts = 0;
 664     } else {
 665       if (rel_seek_secs < 0) avsflags = AVSEEK_FLAG_BACKWARD;
 666     }
 667     if (flags & SEEK_FORWARD)
 668         avsflags = 0;
 669     else if (flags & SEEK_BACKWARD)
 670         avsflags = AVSEEK_FLAG_BACKWARD;
 671     if (flags & SEEK_FACTOR) {
 672       if (priv->avfc->duration == 0 || priv->avfc->duration == AV_NOPTS_VALUE)
 673         return;
 674       priv->last_pts += rel_seek_secs * priv->avfc->duration;
 675     } else {
 676       priv->last_pts += rel_seek_secs * AV_TIME_BASE;
 677     }
 678     if (av_seek_frame(priv->avfc, -1, priv->last_pts, avsflags) < 0) {
 679         avsflags ^= AVSEEK_FLAG_BACKWARD;
 680         av_seek_frame(priv->avfc, -1, priv->last_pts, avsflags);
 681     }
 682 }
 683
 684 static int demux_lavf_control(demuxer_t *demuxer, int cmd, void *arg)
 685 {
 686     lavf_priv_t *priv = demuxer->priv;
 687
 688     switch (cmd) {
 689         case DEMUXER_CTRL_CORRECT_PTS:
 690             return DEMUXER_CTRL_OK;
 691         case DEMUXER_CTRL_GET_TIME_LENGTH:
 692             if (priv->avfc->duration == 0 || priv->avfc->duration == AV_NOPTS_VALUE)
 693                 return DEMUXER_CTRL_DONTKNOW;
 694
 695             *((double *)arg) = (double)priv->avfc->duration / AV_TIME_BASE;
 696             return DEMUXER_CTRL_OK;
 697
 698         case DEMUXER_CTRL_GET_PERCENT_POS:
 699             if (priv->avfc->duration == 0 || priv->avfc->duration == AV_NOPTS_VALUE)
 700                 return DEMUXER_CTRL_DONTKNOW;
 701
 702             *((int *)arg) = (int)((priv->last_pts - priv->avfc->start_time)*100 / priv->avfc->duration);
 703             return DEMUXER_CTRL_OK;
 704         case DEMUXER_CTRL_SWITCH_AUDIO:
 705         case DEMUXER_CTRL_SWITCH_VIDEO:
 706         {
 707             int id = *((int*)arg);
 708             int newid = -2;
 709             int i, curridx = -1;
 710             int nstreams, *pstreams;
 711             demux_stream_t *ds;
 712
 713             if(cmd == DEMUXER_CTRL_SWITCH_VIDEO)
 714             {
 715                 ds = demuxer->video;
 716                 nstreams = priv->video_streams;
 717                 pstreams = priv->vstreams;
 718             }
 719             else
 720             {
 721                 ds = demuxer->audio;
 722                 nstreams = priv->audio_streams;
 723                 pstreams = priv->astreams;
 724             }
 725             for(i = 0; i < nstreams; i++)
 726             {
 727                 if(pstreams[i] == ds->id) //current stream id
 728                 {
 729                     curridx = i;
 730                     break;
 731                 }
 732             }
 733
 734             if(id == -2) { // no sound
 735                 i = -1;
 736             } else if(id == -1) { // next track
 737                 i = (curridx + 2) % (nstreams + 1) - 1;
 738                 if (i >= 0)
 739                     newid = pstreams[i];
 740             }
 741             else // select track by id
 742             {
 743                 if (id >= 0 && id < nstreams) {
 744                     i = id;
 745                     newid = pstreams[i];
 746                 }
 747             }
 748             if (i == curridx) {
 749                 *(int *) arg = curridx;
 750                 return DEMUXER_CTRL_OK;
 751             } else {
 752                 ds_free_packs(ds);
 753                 if(ds->id >= 0)
 754                     priv->avfc->streams[ds->id]->discard = AVDISCARD_ALL;
 755                 ds->id = newid;
 756                 *(int *) arg = i < 0 ? -2 : i;
 757                 if(newid >= 0)
 758                     priv->avfc->streams[newid]->discard = AVDISCARD_NONE;
 759                 return DEMUXER_CTRL_OK;
 760             }
 761         }
 762         case DEMUXER_CTRL_IDENTIFY_PROGRAM:
 763         {
 764             demux_program_t *prog = arg;
 765             AVProgram *program;
 766             int p, i;
 767             int start;
 768
 769             prog->vid = prog->aid = prog->sid = -2;     //no audio and no video by default
 770             if(priv->avfc->nb_programs < 1)
 771                 return DEMUXER_CTRL_DONTKNOW;
 772
 773             if(prog->progid == -1)
 774             {
 775                 p = 0;
 776                 while(p<priv->avfc->nb_programs && priv->avfc->programs[p]->id != priv->cur_program)
 777                     p++;
 778                 p = (p + 1) % priv->avfc->nb_programs;
 779             }
 780             else
 781             {
 782                 for(i=0; i<priv->avfc->nb_programs; i++)
 783                     if(priv->avfc->programs[i]->id == prog->progid)
 784                         break;
 785                 if(i==priv->avfc->nb_programs)
 786                     return DEMUXER_CTRL_DONTKNOW;
 787                 p = i;
 788             }
 789             start = p;
 790 redo:
 791             program = priv->avfc->programs[p];
 792             for(i=0; i<program->nb_stream_indexes; i++)
 793             {
 794                 switch(priv->avfc->streams[program->stream_index[i]]->codec->codec_type)
 795                 {
 796                     case CODEC_TYPE_VIDEO:
 797                         if(prog->vid == -2)
 798                             prog->vid = program->stream_index[i];
 799                         break;
 800                     case CODEC_TYPE_AUDIO:
 801                         if(prog->aid == -2)
 802                             prog->aid = program->stream_index[i];
 803                         break;
 804                     case CODEC_TYPE_SUBTITLE:
 805                         if(prog->sid == -2 && priv->avfc->streams[program->stream_index[i]]->codec->codec_id == CODEC_ID_TEXT)
 806                             prog->sid = program->stream_index[i];
 807                         break;
 808                 }
 809             }
 810             if(prog->progid == -1 && prog->vid == -2 && prog->aid == -2)
 811             {
 812                 p = (p + 1) % priv->avfc->nb_programs;
 813                 if (p == start)
 814                     return DEMUXER_CTRL_DONTKNOW;
 815                 goto redo;
 816             }
 817             priv->cur_program = prog->progid = program->id;
 818             return DEMUXER_CTRL_OK;
 819         }
 820         default:
 821             return DEMUXER_CTRL_NOTIMPL;
 822     }
 823 }
 824
 825 static void demux_close_lavf(demuxer_t *demuxer)
 826 {
 827     lavf_priv_t* priv = demuxer->priv;
 828     if (priv){
 829         if(priv->avfc)
 830        {
 831          av_freep(&priv->avfc->key);
 832          av_close_input_stream(priv->avfc);
 833         }
 834         av_freep(&priv->pb);
 835         free(priv); demuxer->priv= NULL;
 836     }
 837 }
 838
 839
 840 const demuxer_desc_t demuxer_desc_lavf = {
 841   "libavformat demuxer",
 842   "lavf",
 843   "libavformat",
 844   "Michael Niedermayer",
 845   "supports many formats, requires libavformat",
 846   DEMUXER_TYPE_LAVF,
 847   0, // Check after other demuxer
 848   lavf_check_file,
 849   demux_lavf_fill_buffer,
 850   demux_open_lavf,
 851   demux_close_lavf,
 852   demux_seek_lavf,
 853   demux_lavf_control
 854 };
 855
 856 const demuxer_desc_t demuxer_desc_lavf_preferred = {
 857   "libavformat preferred demuxer",
 858   "lavfpref",
 859   "libavformat",
 860   "Michael Niedermayer",
 861   "supports many formats, requires libavformat",
 862   DEMUXER_TYPE_LAVF_PREFERRED,
 863   1,
 864   lavf_check_preferred_file,
 865   demux_lavf_fill_buffer,
 866   demux_open_lavf,
 867   demux_close_lavf,
 868   demux_seek_lavf,
 869   demux_lavf_control
 870 };