libmpdemux/demux_lavf.c

   1 /*
   2     Copyright (C) 2004 Michael Niedermayer <michaelni@gmx.at>
   3
   4     This program is free software; you can redistribute it and/or modify
   5     it under the terms of the GNU General Public License as published by
   6     the Free Software Foundation; either version 2 of the License, or
   7     (at your option) any later version.
   8
   9     This program is distributed in the hope that it will be useful,
  10     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12     GNU General Public License for more details.
  13
  14     You should have received a copy of the GNU General Public License
  15     along with this program; if not, write to the Free Software
  16     Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  17 */
  18
  19 // #include <stdio.h>
  20 #include <stdlib.h>
  21 // #include <unistd.h>
  22 #include <limits.h>
  23
  24 #include "config.h"
  25 #include "mp_msg.h"
  26 #include "help_mp.h"
  27
  28 #include "stream/stream.h"
  29 #include "demuxer.h"
  30 #include "stheader.h"
  31 #include "m_option.h"
  32
  33 #ifdef USE_LIBAVFORMAT_SO
  34 #include <ffmpeg/avformat.h>
  35 #include <ffmpeg/avutil.h>
  36 #include <ffmpeg/opt.h>
  37 #else
  38 #include "avformat.h"
  39 #include "avutil.h"
  40 #include "avi.h"
  41 #include "opt.h"
  42 #endif
  43 #include "riff.h"
  44
  45 #define PROBE_BUF_SIZE 2048
  46
  47 extern char *audio_lang;
  48 static unsigned int opt_probesize = 0;
  49 static char *opt_format;
  50
  51 m_option_t lavfdopts_conf[] = {
  52         {"probesize", &(opt_probesize), CONF_TYPE_INT, CONF_RANGE, 32, INT_MAX, NULL},
  53         {"format",    &(opt_format),    CONF_TYPE_STRING,       0,  0,       0, NULL},
  54         {NULL, NULL, 0, 0, 0, 0, NULL}
  55 };
  56
  57
  58 typedef struct lavf_priv_t{
  59     AVInputFormat *avif;
  60     AVFormatContext *avfc;
  61     ByteIOContext pb;
  62     int audio_streams;
  63     int video_streams;
  64     int64_t last_pts;
  65     int astreams[MAX_A_STREAMS];
  66     int vstreams[MAX_V_STREAMS];
  67 }lavf_priv_t;
  68
  69 extern void print_wave_header(WAVEFORMATEX *h, int verbose_level);
  70 extern void print_video_header(BITMAPINFOHEADER *h, int verbose_level);
  71
  72 static const AVCodecTag mp_wav_tags[] = {
  73     { CODEC_ID_ADPCM_4XM,         MKTAG('4', 'X', 'M', 'A')},
  74     { CODEC_ID_ADPCM_EA,          MKTAG('A', 'D', 'E', 'A')},
  75     { CODEC_ID_ADPCM_IMA_WS,      MKTAG('A', 'I', 'W', 'S')},
  76     { CODEC_ID_ADPCM_THP,         MKTAG('T', 'H', 'P', 'A')},
  77     { CODEC_ID_AMR_NB,            MKTAG('n', 'b',   0,   0)},
  78     { CODEC_ID_DSICINAUDIO,       MKTAG('D', 'C', 'I', 'A')},
  79     { CODEC_ID_INTERPLAY_DPCM,    MKTAG('I', 'N', 'P', 'A')},
  80     { CODEC_ID_MUSEPACK7,         MKTAG('M', 'P', 'C', ' ')},
  81     { CODEC_ID_PCM_S24BE,         MKTAG('i', 'n', '2', '4')},
  82     { CODEC_ID_PCM_S16BE,         MKTAG('t', 'w', 'o', 's')},
  83     { CODEC_ID_PCM_S8,            MKTAG('t', 'w', 'o', 's')},
  84     { CODEC_ID_ROQ_DPCM,          MKTAG('R', 'o', 'Q', 'A')},
  85     { CODEC_ID_SHORTEN,           MKTAG('s', 'h', 'r', 'n')},
  86     { CODEC_ID_TTA,               MKTAG('T', 'T', 'A', '1')},
  87     { CODEC_ID_WAVPACK,           MKTAG('W', 'V', 'P', 'K')},
  88     { CODEC_ID_WESTWOOD_SND1,     MKTAG('S', 'N', 'D', '1')},
  89     { CODEC_ID_XAN_DPCM,          MKTAG('A', 'x', 'a', 'n')},
  90     { 0, 0 },
  91 };
  92
  93 const struct AVCodecTag *mp_wav_taglists[] = {codec_wav_tags, mp_wav_tags, 0};
  94
  95 static const AVCodecTag mp_bmp_tags[] = {
  96     { CODEC_ID_BETHSOFTVID,       MKTAG('B', 'E', 'T', 'H')},
  97     { CODEC_ID_C93,               MKTAG('C', '9', '3', 'V')},
  98     { CODEC_ID_DSICINVIDEO,       MKTAG('D', 'C', 'I', 'V')},
  99     { CODEC_ID_DXA,               MKTAG('D', 'X', 'A', '1')},
 100     { CODEC_ID_FLIC,              MKTAG('F', 'L', 'I', 'C')},
 101     { CODEC_ID_IDCIN,             MKTAG('I', 'D', 'C', 'I')},
 102     { CODEC_ID_INTERPLAY_VIDEO,   MKTAG('I', 'N', 'P', 'V')},
 103     { CODEC_ID_ROQ,               MKTAG('R', 'o', 'Q', 'V')},
 104     { CODEC_ID_THP,               MKTAG('T', 'H', 'P', 'V')},
 105     { CODEC_ID_TIERTEXSEQVIDEO,   MKTAG('T', 'S', 'E', 'Q')},
 106     { CODEC_ID_TXD,               MKTAG('T', 'X', 'D', 'V')},
 107     { CODEC_ID_VMDVIDEO,          MKTAG('V', 'M', 'D', 'V')},
 108     { CODEC_ID_WS_VQA,            MKTAG('V', 'Q', 'A', 'V')},
 109     { CODEC_ID_XAN_WC3,           MKTAG('W', 'C', '3', 'V')},
 110     { 0, 0 },
 111 };
 112
 113 const struct AVCodecTag *mp_bmp_taglists[] = {codec_bmp_tags, mp_bmp_tags, 0};
 114
 115 static int mp_open(URLContext *h, const char *filename, int flags){
 116     return 0;
 117 }
 118
 119 static int mp_read(URLContext *h, unsigned char *buf, int size){
 120     stream_t *stream = (stream_t*)h->priv_data;
 121     int ret;
 122
 123     if(stream_eof(stream)) //needed?
 124         return -1;
 125     ret=stream_read(stream, buf, size);
 126
 127     mp_msg(MSGT_HEADER,MSGL_DBG2,"%d=mp_read(%p, %p, %d), eof:%d\n", ret, h, buf, size, stream->eof);
 128     return ret;
 129 }
 130
 131 static int mp_write(URLContext *h, unsigned char *buf, int size){
 132     return -1;
 133 }
 134
 135 static offset_t mp_seek(URLContext *h, offset_t pos, int whence){
 136     stream_t *stream = (stream_t*)h->priv_data;
 137
 138     mp_msg(MSGT_HEADER,MSGL_DBG2,"mp_seek(%p, %d, %d)\n", h, (int)pos, whence);
 139     if(whence == SEEK_CUR)
 140         pos +=stream_tell(stream);
 141     else if(whence == SEEK_END)
 142         pos += stream->end_pos;
 143     else if(whence == SEEK_SET)
 144         pos += stream->start_pos;
 145     else
 146         return -1;
 147
 148     if(pos<stream->end_pos && stream->eof)
 149         stream_reset(stream);
 150     if(stream_seek(stream, pos)==0)
 151         return -1;
 152
 153     return pos - stream->start_pos;
 154 }
 155
 156 static int mp_close(URLContext *h){
 157     return 0;
 158 }
 159
 160 static URLProtocol mp_protocol = {
 161     "mp",
 162     mp_open,
 163     mp_read,
 164     mp_write,
 165     mp_seek,
 166     mp_close,
 167 };
 168
 169 static void list_formats(void) {
 170     AVInputFormat *fmt;
 171     mp_msg(MSGT_DEMUX, MSGL_INFO, "Available lavf input formats:\n");
 172     for (fmt = first_iformat; fmt; fmt = fmt->next)
 173         mp_msg(MSGT_DEMUX, MSGL_INFO, "%15s : %s\n", fmt->name, fmt->long_name);
 174 }
 175
 176 static int lavf_check_file(demuxer_t *demuxer){
 177     AVProbeData avpd;
 178     uint8_t buf[PROBE_BUF_SIZE];
 179     lavf_priv_t *priv;
 180
 181     if(!demuxer->priv)
 182         demuxer->priv=calloc(sizeof(lavf_priv_t),1);
 183     priv= demuxer->priv;
 184
 185     av_register_all();
 186
 187     if(stream_read(demuxer->stream, buf, PROBE_BUF_SIZE)!=PROBE_BUF_SIZE)
 188         return 0;
 189     avpd.filename= demuxer->stream->url;
 190     avpd.buf= buf;
 191     avpd.buf_size= PROBE_BUF_SIZE;
 192
 193     if (opt_format) {
 194         if (strcmp(opt_format, "help") == 0) {
 195            list_formats();
 196            return 0;
 197         }
 198         priv->avif= av_find_input_format(opt_format);
 199         if (!priv->avif) {
 200             mp_msg(MSGT_DEMUX,MSGL_FATAL,"Unknown lavf format %s\n", opt_format);
 201             return 0;
 202         }
 203         mp_msg(MSGT_DEMUX,MSGL_INFO,"Forced lavf %s demuxer\n", priv->avif->long_name);
 204         return DEMUXER_TYPE_LAVF;
 205     }
 206     priv->avif= av_probe_input_format(&avpd, 1);
 207     if(!priv->avif){
 208         mp_msg(MSGT_HEADER,MSGL_V,"LAVF_check: no clue about this gibberish!\n");
 209         return 0;
 210     }else
 211         mp_msg(MSGT_HEADER,MSGL_V,"LAVF_check: %s\n", priv->avif->long_name);
 212
 213     return DEMUXER_TYPE_LAVF;
 214 }
 215
 216 static const char *preferred_list[] = {
 217     "dxa",
 218     "wv",
 219     "nuv",
 220     "nut",
 221     "gxf",
 222     "mxf",
 223     "flv",
 224     "swf",
 225     NULL
 226 };
 227
 228 static int lavf_check_preferred_file(demuxer_t *demuxer){
 229     if (lavf_check_file(demuxer)) {
 230         char **p = preferred_list;
 231         lavf_priv_t *priv = demuxer->priv;
 232         while (*p) {
 233             if (strcmp(*p, priv->avif->name) == 0)
 234                 return DEMUXER_TYPE_LAVF_PREFERRED;
 235             p++;
 236         }
 237     }
 238     return 0;
 239 }
 240
 241 static demuxer_t* demux_open_lavf(demuxer_t *demuxer){
 242     AVFormatContext *avfc;
 243     AVFormatParameters ap;
 244     AVOption *opt;
 245     lavf_priv_t *priv= demuxer->priv;
 246     int i,g;
 247     char mp_filename[256]="mp:";
 248
 249     memset(&ap, 0, sizeof(AVFormatParameters));
 250
 251     stream_seek(demuxer->stream, 0);
 252
 253     register_protocol(&mp_protocol);
 254
 255     avfc = av_alloc_format_context();
 256
 257     if (correct_pts)
 258         avfc->flags |= AVFMT_FLAG_GENPTS;
 259     if (index_mode == 0)
 260         avfc->flags |= AVFMT_FLAG_IGNIDX;
 261
 262     ap.prealloced_context = 1;
 263     if(opt_probesize) {
 264         double d = (double) opt_probesize;
 265         opt = av_set_double(avfc, "probesize", opt_probesize);
 266         if(!opt) mp_msg(MSGT_HEADER,MSGL_ERR, "demux_lavf, couldn't set option probesize to %.3f\r\n", d);
 267     }
 268
 269     if(demuxer->stream->url)
 270         strncpy(mp_filename + 3, demuxer->stream->url, sizeof(mp_filename)-3);
 271     else
 272         strncpy(mp_filename + 3, "foobar.dummy", sizeof(mp_filename)-3);
 273
 274     url_fopen(&priv->pb, mp_filename, URL_RDONLY);
 275
 276     ((URLContext*)(priv->pb.opaque))->priv_data= demuxer->stream;
 277
 278     if(av_open_input_stream(&avfc, &priv->pb, mp_filename, priv->avif, &ap)<0){
 279         mp_msg(MSGT_HEADER,MSGL_ERR,"LAVF_header: av_open_input_stream() failed\n");
 280         return NULL;
 281     }
 282
 283     priv->avfc= avfc;
 284
 285     if(av_find_stream_info(avfc) < 0){
 286         mp_msg(MSGT_HEADER,MSGL_ERR,"LAVF_header: av_find_stream_info() failed\n");
 287         return NULL;
 288     }
 289
 290     if(avfc->title    [0]) demux_info_add(demuxer, "name"     , avfc->title    );
 291     if(avfc->author   [0]) demux_info_add(demuxer, "author"   , avfc->author   );
 292     if(avfc->copyright[0]) demux_info_add(demuxer, "copyright", avfc->copyright);
 293     if(avfc->comment  [0]) demux_info_add(demuxer, "comments" , avfc->comment  );
 294     if(avfc->album    [0]) demux_info_add(demuxer, "album"    , avfc->album    );
 295 //    if(avfc->year        ) demux_info_add(demuxer, "year"     , avfc->year     );
 296 //    if(avfc->track       ) demux_info_add(demuxer, "track"    , avfc->track    );
 297     if(avfc->genre    [0]) demux_info_add(demuxer, "genre"    , avfc->genre    );
 298
 299     for(i=0; i<avfc->nb_streams; i++){
 300         AVStream *st= avfc->streams[i];
 301         AVCodecContext *codec= st->codec;
 302
 303         switch(codec->codec_type){
 304         case CODEC_TYPE_AUDIO:{
 305             WAVEFORMATEX *wf= calloc(sizeof(WAVEFORMATEX) + codec->extradata_size, 1);
 306             sh_audio_t* sh_audio;
 307             if(priv->audio_streams >= MAX_A_STREAMS)
 308                 break;
 309             sh_audio=new_sh_audio(demuxer, i);
 310             mp_msg(MSGT_DEMUX, MSGL_INFO, MSGTR_AudioID, "lavf", i);
 311             if(!sh_audio)
 312                 break;
 313             priv->astreams[priv->audio_streams] = i;
 314             priv->audio_streams++;
 315             // mp4a tag is used for all mp4 files no matter what they actually contain
 316             if(codec->codec_tag == MKTAG('m', 'p', '4', 'a'))
 317                 codec->codec_tag= 0;
 318             if(!codec->codec_tag)
 319                 codec->codec_tag= av_codec_get_tag(mp_wav_taglists, codec->codec_id);
 320             wf->wFormatTag= codec->codec_tag;
 321             wf->nChannels= codec->channels;
 322             wf->nSamplesPerSec= codec->sample_rate;
 323             wf->nAvgBytesPerSec= codec->bit_rate/8;
 324             wf->nBlockAlign= codec->block_align ? codec->block_align : 1;
 325             wf->wBitsPerSample= codec->bits_per_sample;
 326             wf->cbSize= codec->extradata_size;
 327             if(codec->extradata_size){
 328                 memcpy(
 329                     wf + 1,
 330                     codec->extradata,
 331                     codec->extradata_size);
 332             }
 333             sh_audio->wf= wf;
 334             sh_audio->audio.dwSampleSize= codec->block_align;
 335             if(codec->frame_size && codec->sample_rate){
 336                 sh_audio->audio.dwScale=codec->frame_size;
 337                 sh_audio->audio.dwRate= codec->sample_rate;
 338             }else{
 339                 sh_audio->audio.dwScale= codec->block_align ? codec->block_align*8 : 8;
 340                 sh_audio->audio.dwRate = codec->bit_rate;
 341             }
 342             g= ff_gcd(sh_audio->audio.dwScale, sh_audio->audio.dwRate);
 343             sh_audio->audio.dwScale /= g;
 344             sh_audio->audio.dwRate  /= g;
 345 //            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);
 346             sh_audio->ds= demuxer->audio;
 347             sh_audio->format= codec->codec_tag;
 348             sh_audio->channels= codec->channels;
 349             sh_audio->samplerate= codec->sample_rate;
 350             sh_audio->i_bps= codec->bit_rate/8;
 351             switch (codec->codec_id) {
 352               case CODEC_ID_PCM_S8:
 353               case CODEC_ID_PCM_U8:
 354                 sh_audio->samplesize = 1;
 355                 break;
 356               case CODEC_ID_PCM_S16LE:
 357               case CODEC_ID_PCM_S16BE:
 358               case CODEC_ID_PCM_U16LE:
 359               case CODEC_ID_PCM_U16BE:
 360                 sh_audio->samplesize = 2;
 361                 break;
 362               case CODEC_ID_PCM_ALAW:
 363                 sh_audio->format = 0x6;
 364                 break;
 365               case CODEC_ID_PCM_MULAW:
 366                 sh_audio->format = 0x7;
 367                 break;
 368             }
 369             if( mp_msg_test(MSGT_HEADER,MSGL_V) ) print_wave_header(sh_audio->wf, MSGL_V);
 370             if((audio_lang && st->language[0] && !strncmp(audio_lang, st->language, 3))
 371                 || (demuxer->audio->id == i || demuxer->audio->id == -1)
 372             ) {
 373                 demuxer->audio->id = i;
 374                 demuxer->audio->sh= demuxer->a_streams[i];
 375             }
 376             else
 377                 st->discard= AVDISCARD_ALL;
 378             break;}
 379         case CODEC_TYPE_VIDEO:{
 380             sh_video_t* sh_video;
 381             BITMAPINFOHEADER *bih;
 382             if(priv->video_streams >= MAX_V_STREAMS)
 383                 break;
 384             sh_video=new_sh_video(demuxer, i);
 385             mp_msg(MSGT_DEMUX, MSGL_INFO, MSGTR_VideoID, "lavf", i);
 386             if(!sh_video) break;
 387             priv->vstreams[priv->video_streams] = i;
 388             priv->video_streams++;
 389             bih=calloc(sizeof(BITMAPINFOHEADER) + codec->extradata_size,1);
 390
 391             if(!codec->codec_tag)
 392                 codec->codec_tag= av_codec_get_tag(mp_bmp_taglists, codec->codec_id);
 393             bih->biSize= sizeof(BITMAPINFOHEADER) + codec->extradata_size;
 394             bih->biWidth= codec->width;
 395             bih->biHeight= codec->height;
 396             bih->biBitCount= codec->bits_per_sample;
 397             bih->biSizeImage = bih->biWidth * bih->biHeight * bih->biBitCount/8;
 398             bih->biCompression= codec->codec_tag;
 399             sh_video->bih= bih;
 400             sh_video->disp_w= codec->width;
 401             sh_video->disp_h= codec->height;
 402             if (st->time_base.den) { /* if container has time_base, use that */
 403                 sh_video->video.dwRate= st->time_base.den;
 404                 sh_video->video.dwScale= st->time_base.num;
 405             } else {
 406             sh_video->video.dwRate= codec->time_base.den;
 407             sh_video->video.dwScale= codec->time_base.num;
 408             }
 409             sh_video->fps=av_q2d(st->r_frame_rate);
 410             sh_video->frametime=1/av_q2d(st->r_frame_rate);
 411             sh_video->format = bih->biCompression;
 412             sh_video->aspect=   codec->width * codec->sample_aspect_ratio.num
 413                               / (float)(codec->height * codec->sample_aspect_ratio.den);
 414             sh_video->i_bps= codec->bit_rate/8;
 415             mp_msg(MSGT_DEMUX,MSGL_DBG2,"aspect= %d*%d/(%d*%d)\n",
 416                 codec->width, codec->sample_aspect_ratio.num,
 417                 codec->height, codec->sample_aspect_ratio.den);
 418
 419             sh_video->ds= demuxer->video;
 420             if(codec->extradata_size)
 421                 memcpy(sh_video->bih + 1, codec->extradata, codec->extradata_size);
 422             if( mp_msg_test(MSGT_HEADER,MSGL_V) ) print_video_header(sh_video->bih, MSGL_V);
 423 /*    short     biPlanes;
 424     int         biXPelsPerMeter;
 425     int         biYPelsPerMeter;
 426     int         biClrUsed;
 427     int         biClrImportant;*/
 428             if(demuxer->video->id != i && demuxer->video->id != -1)
 429                 st->discard= AVDISCARD_ALL;
 430             else{
 431                 demuxer->video->id = i;
 432                 demuxer->video->sh= demuxer->v_streams[i];
 433             }
 434             break;}
 435         default:
 436             st->discard= AVDISCARD_ALL;
 437         }
 438     }
 439
 440     mp_msg(MSGT_HEADER,MSGL_V,"LAVF: %d audio and %d video streams found\n",priv->audio_streams,priv->video_streams);
 441     mp_msg(MSGT_HEADER,MSGL_V,"LAVF: build %d\n", LIBAVFORMAT_BUILD);
 442     if(!priv->audio_streams) demuxer->audio->id=-2;  // nosound
 443 //    else if(best_audio > 0 && demuxer->audio->id == -1) demuxer->audio->id=best_audio;
 444     if(!priv->video_streams){
 445         if(!priv->audio_streams){
 446             mp_msg(MSGT_HEADER,MSGL_ERR,"LAVF: no audio or video headers found - broken file?\n");
 447             return NULL;
 448         }
 449         demuxer->video->id=-2; // audio-only
 450     } //else if (best_video > 0 && demuxer->video->id == -1) demuxer->video->id = best_video;
 451
 452     return demuxer;
 453 }
 454
 455 static int demux_lavf_fill_buffer(demuxer_t *demux, demux_stream_t *dsds){
 456     lavf_priv_t *priv= demux->priv;
 457     AVPacket pkt;
 458     demux_packet_t *dp;
 459     demux_stream_t *ds;
 460     int id;
 461     mp_msg(MSGT_DEMUX,MSGL_DBG2,"demux_lavf_fill_buffer()\n");
 462
 463     demux->filepos=stream_tell(demux->stream);
 464
 465     if(av_read_frame(priv->avfc, &pkt) < 0)
 466         return 0;
 467
 468     id= pkt.stream_index;
 469
 470     if(id==demux->audio->id){
 471         // audio
 472         ds=demux->audio;
 473         if(!ds->sh){
 474             ds->sh=demux->a_streams[id];
 475             mp_msg(MSGT_DEMUX,MSGL_V,"Auto-selected LAVF audio ID = %d\n",ds->id);
 476         }
 477     } else if(id==demux->video->id){
 478         // video
 479         ds=demux->video;
 480         if(!ds->sh){
 481             ds->sh=demux->v_streams[id];
 482             mp_msg(MSGT_DEMUX,MSGL_V,"Auto-selected LAVF video ID = %d\n",ds->id);
 483         }
 484     } else {
 485         av_free_packet(&pkt);
 486         return 1;
 487     }
 488
 489     if(0/*pkt.destruct == av_destruct_packet*/){
 490         //ok kids, dont try this at home :)
 491         dp=malloc(sizeof(demux_packet_t));
 492         dp->len=pkt.size;
 493         dp->next=NULL;
 494         dp->refcount=1;
 495         dp->master=NULL;
 496         dp->buffer=pkt.data;
 497         pkt.destruct= NULL;
 498     }else{
 499         dp=new_demux_packet(pkt.size);
 500         memcpy(dp->buffer, pkt.data, pkt.size);
 501         av_free_packet(&pkt);
 502     }
 503
 504     if(pkt.pts != AV_NOPTS_VALUE){
 505         dp->pts=pkt.pts * av_q2d(priv->avfc->streams[id]->time_base);
 506         priv->last_pts= dp->pts * AV_TIME_BASE;
 507     }
 508     dp->pos=demux->filepos;
 509     dp->flags= !!(pkt.flags&PKT_FLAG_KEY);
 510     // append packet to DS stream:
 511     ds_add_packet(ds,dp);
 512     return 1;
 513 }
 514
 515 static void demux_seek_lavf(demuxer_t *demuxer, float rel_seek_secs, float audio_delay, int flags){
 516     lavf_priv_t *priv = demuxer->priv;
 517     int avsflags = 0;
 518     mp_msg(MSGT_DEMUX,MSGL_DBG2,"demux_seek_lavf(%p, %f, %f, %d)\n", demuxer, rel_seek_secs, audio_delay, flags);
 519
 520     if (flags & 1) // absolute seek
 521       priv->last_pts = priv->avfc->start_time;
 522     if (flags & 2) { // percent seek
 523       if (priv->avfc->duration == 0 || priv->avfc->duration == AV_NOPTS_VALUE)
 524         return;
 525       priv->last_pts += rel_seek_secs * priv->avfc->duration;
 526     } else {
 527       priv->last_pts += rel_seek_secs * AV_TIME_BASE;
 528       if (rel_seek_secs < 0) avsflags = AVSEEK_FLAG_BACKWARD;
 529     }
 530     av_seek_frame(priv->avfc, -1, priv->last_pts, avsflags);
 531 }
 532
 533 static int demux_lavf_control(demuxer_t *demuxer, int cmd, void *arg)
 534 {
 535     lavf_priv_t *priv = demuxer->priv;
 536
 537     switch (cmd) {
 538         case DEMUXER_CTRL_GET_TIME_LENGTH:
 539             if (priv->avfc->duration == 0 || priv->avfc->duration == AV_NOPTS_VALUE)
 540                 return DEMUXER_CTRL_DONTKNOW;
 541
 542             *((double *)arg) = (double)priv->avfc->duration / AV_TIME_BASE;
 543             return DEMUXER_CTRL_OK;
 544
 545         case DEMUXER_CTRL_GET_PERCENT_POS:
 546             if (priv->avfc->duration == 0 || priv->avfc->duration == AV_NOPTS_VALUE)
 547                 return DEMUXER_CTRL_DONTKNOW;
 548
 549             *((int *)arg) = (int)((priv->last_pts - priv->avfc->start_time)*100 / priv->avfc->duration);
 550             return DEMUXER_CTRL_OK;
 551         case DEMUXER_CTRL_SWITCH_AUDIO:
 552         case DEMUXER_CTRL_SWITCH_VIDEO:
 553         {
 554             int id = *((int*)arg);
 555             int newid = -2;
 556             int i, curridx = -2;
 557             int nstreams, *pstreams;
 558             demux_stream_t *ds;
 559
 560             if(cmd == DEMUXER_CTRL_SWITCH_VIDEO)
 561             {
 562                 ds = demuxer->video;
 563                 nstreams = priv->video_streams;
 564                 pstreams = priv->vstreams;
 565             }
 566             else
 567             {
 568                 ds = demuxer->audio;
 569                 nstreams = priv->audio_streams;
 570                 pstreams = priv->astreams;
 571             }
 572             if(ds->id == -2)
 573                 return DEMUXER_CTRL_NOTIMPL;
 574             for(i = 0; i < nstreams; i++)
 575             {
 576                 if(pstreams[i] == ds->id) //current stream id
 577                 {
 578                     curridx = i;
 579                     break;
 580                 }
 581             }
 582
 583             if(id < 0)
 584             {
 585                 i = (curridx + 1) % nstreams;
 586                 newid = pstreams[i];
 587             }
 588             else
 589             {
 590                 for(i = 0; i < nstreams; i++)
 591                 {
 592                     if(pstreams[i] == id)
 593                     {
 594                         newid = id;
 595                         break;
 596                     }
 597                 }
 598             }
 599             if(newid == -2 || i == curridx)
 600                 return DEMUXER_CTRL_NOTIMPL;
 601             else
 602             {
 603                 ds_free_packs(ds);
 604                 priv->avfc->streams[ds->id]->discard = AVDISCARD_ALL;
 605                 *((int*)arg) = ds->id = newid;
 606                 priv->avfc->streams[newid]->discard = AVDISCARD_NONE;
 607                 return DEMUXER_CTRL_OK;
 608             }
 609         }
 610         default:
 611             return DEMUXER_CTRL_NOTIMPL;
 612     }
 613 }
 614
 615 static void demux_close_lavf(demuxer_t *demuxer)
 616 {
 617     lavf_priv_t* priv = demuxer->priv;
 618     if (priv){
 619         if(priv->avfc)
 620        {
 621          av_close_input_file(priv->avfc); priv->avfc= NULL;
 622         }
 623         free(priv); demuxer->priv= NULL;
 624     }
 625 }
 626
 627
 628 demuxer_desc_t demuxer_desc_lavf = {
 629   "libavformat demuxer",
 630   "lavf",
 631   "libavformat",
 632   "Michael Niedermayer",
 633   "supports many formats, requires libavformat",
 634   DEMUXER_TYPE_LAVF,
 635   0, // Check after other demuxer
 636   lavf_check_file,
 637   demux_lavf_fill_buffer,
 638   demux_open_lavf,
 639   demux_close_lavf,
 640   demux_seek_lavf,
 641   demux_lavf_control
 642 };
 643
 644 demuxer_desc_t demuxer_desc_lavf_preferred = {
 645   "libavformat preferred demuxer",
 646   "lavfpref",
 647   "libavformat",
 648   "Michael Niedermayer",
 649   "supports many formats, requires libavformat",
 650   DEMUXER_TYPE_LAVF_PREFERRED,
 651   0, // Check after other demuxer
 652   lavf_check_preferred_file,
 653   demux_lavf_fill_buffer,
 654   demux_open_lavf,
 655   demux_close_lavf,
 656   demux_seek_lavf,
 657   demux_lavf_control
 658 };