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