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