libmpdemux/demuxer.c

   1 /*
   2  * DEMUXER v2.5
   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 <string.h>
  24 #include <unistd.h>
  25
  26 #include <sys/types.h>
  27 #include <sys/stat.h>
  28
  29 #include "config.h"
  30 #include "options.h"
  31 #include "talloc.h"
  32 #include "mp_msg.h"
  33 #include "m_config.h"
  34
  35 #include "libvo/fastmemcpy.h"
  36
  37 #include "stream/stream.h"
  38 #include "demuxer.h"
  39 #include "stheader.h"
  40 #include "mf.h"
  41
  42 #include "libaf/af_format.h"
  43 #include "libmpcodecs/dec_teletext.h"
  44
  45 #include "ass_mp.h"
  46
  47 #ifdef CONFIG_LIBAVCODEC
  48 #include "libavcodec/avcodec.h"
  49 #if MP_INPUT_BUFFER_PADDING_SIZE < FF_INPUT_BUFFER_PADDING_SIZE
  50 #error MP_INPUT_BUFFER_PADDING_SIZE is too small!
  51 #endif
  52 #endif
  53
  54 // This is quite experimental, in particular it will mess up the pts values
  55 // in the queue - on the other hand it might fix some issues like generating
  56 // broken files with mencoder and stream copy.
  57 // Better leave it disabled for now, if we find no use for it this code should
  58 // just be removed again.
  59 #define PARSE_ON_ADD 0
  60
  61 static void clear_parser(sh_common_t *sh);
  62
  63 // Demuxer list
  64 extern const demuxer_desc_t demuxer_desc_rawaudio;
  65 extern const demuxer_desc_t demuxer_desc_rawvideo;
  66 extern const demuxer_desc_t demuxer_desc_tv;
  67 extern const demuxer_desc_t demuxer_desc_mf;
  68 extern const demuxer_desc_t demuxer_desc_avi;
  69 extern const demuxer_desc_t demuxer_desc_y4m;
  70 extern const demuxer_desc_t demuxer_desc_asf;
  71 extern const demuxer_desc_t demuxer_desc_real;
  72 extern const demuxer_desc_t demuxer_desc_smjpeg;
  73 extern const demuxer_desc_t demuxer_desc_matroska;
  74 extern const demuxer_desc_t demuxer_desc_realaudio;
  75 extern const demuxer_desc_t demuxer_desc_vqf;
  76 extern const demuxer_desc_t demuxer_desc_mov;
  77 extern const demuxer_desc_t demuxer_desc_vivo;
  78 extern const demuxer_desc_t demuxer_desc_fli;
  79 extern const demuxer_desc_t demuxer_desc_film;
  80 extern const demuxer_desc_t demuxer_desc_roq;
  81 extern const demuxer_desc_t demuxer_desc_gif;
  82 extern const demuxer_desc_t demuxer_desc_ogg;
  83 extern const demuxer_desc_t demuxer_desc_avs;
  84 extern const demuxer_desc_t demuxer_desc_pva;
  85 extern const demuxer_desc_t demuxer_desc_nsv;
  86 extern const demuxer_desc_t demuxer_desc_mpeg_ts;
  87 extern const demuxer_desc_t demuxer_desc_lmlm4;
  88 extern const demuxer_desc_t demuxer_desc_mpeg_ps;
  89 extern const demuxer_desc_t demuxer_desc_mpeg_pes;
  90 extern const demuxer_desc_t demuxer_desc_mpeg_es;
  91 extern const demuxer_desc_t demuxer_desc_mpeg_gxf;
  92 extern const demuxer_desc_t demuxer_desc_mpeg4_es;
  93 extern const demuxer_desc_t demuxer_desc_h264_es;
  94 extern const demuxer_desc_t demuxer_desc_rawdv;
  95 extern const demuxer_desc_t demuxer_desc_mpc;
  96 extern const demuxer_desc_t demuxer_desc_audio;
  97 extern const demuxer_desc_t demuxer_desc_xmms;
  98 extern const demuxer_desc_t demuxer_desc_mpeg_ty;
  99 extern const demuxer_desc_t demuxer_desc_rtp;
 100 extern const demuxer_desc_t demuxer_desc_rtp_nemesi;
 101 extern const demuxer_desc_t demuxer_desc_lavf;
 102 extern const demuxer_desc_t demuxer_desc_lavf_preferred;
 103 extern const demuxer_desc_t demuxer_desc_aac;
 104 extern const demuxer_desc_t demuxer_desc_nut;
 105 extern const demuxer_desc_t demuxer_desc_mng;
 106
 107 /* Please do not add any new demuxers here. If you want to implement a new
 108  * demuxer, add it to libavformat, except for wrappers around external
 109  * libraries and demuxers requiring binary support. */
 110
 111 const demuxer_desc_t *const demuxer_list[] = {
 112     &demuxer_desc_rawaudio,
 113     &demuxer_desc_rawvideo,
 114 #ifdef CONFIG_TV
 115     &demuxer_desc_tv,
 116 #endif
 117     &demuxer_desc_mf,
 118 #ifdef CONFIG_LIBAVFORMAT
 119     &demuxer_desc_lavf_preferred,
 120 #endif
 121     &demuxer_desc_avi,
 122     &demuxer_desc_y4m,
 123     &demuxer_desc_asf,
 124     &demuxer_desc_nsv,
 125     &demuxer_desc_real,
 126     &demuxer_desc_smjpeg,
 127     &demuxer_desc_matroska,
 128     &demuxer_desc_realaudio,
 129     &demuxer_desc_vqf,
 130     &demuxer_desc_mov,
 131     &demuxer_desc_vivo,
 132     &demuxer_desc_fli,
 133     &demuxer_desc_film,
 134     &demuxer_desc_roq,
 135 #ifdef CONFIG_GIF
 136     &demuxer_desc_gif,
 137 #endif
 138 #ifdef CONFIG_OGGVORBIS
 139     &demuxer_desc_ogg,
 140 #endif
 141 #ifdef CONFIG_WIN32DLL
 142     &demuxer_desc_avs,
 143 #endif
 144     &demuxer_desc_pva,
 145     &demuxer_desc_mpeg_ts,
 146     &demuxer_desc_lmlm4,
 147     &demuxer_desc_mpeg_ps,
 148     &demuxer_desc_mpeg_pes,
 149     &demuxer_desc_mpeg_es,
 150     &demuxer_desc_mpeg_gxf,
 151     &demuxer_desc_mpeg4_es,
 152     &demuxer_desc_h264_es,
 153     &demuxer_desc_audio,
 154     &demuxer_desc_mpeg_ty,
 155 #ifdef CONFIG_LIVE555
 156     &demuxer_desc_rtp,
 157 #endif
 158 #ifdef CONFIG_LIBNEMESI
 159     &demuxer_desc_rtp_nemesi,
 160 #endif
 161 #ifdef CONFIG_LIBAVFORMAT
 162     &demuxer_desc_lavf,
 163 #endif
 164 #ifdef CONFIG_MUSEPACK
 165     &demuxer_desc_mpc,
 166 #endif
 167 #ifdef CONFIG_LIBDV095
 168     &demuxer_desc_rawdv,
 169 #endif
 170     &demuxer_desc_aac,
 171 #ifdef CONFIG_LIBNUT
 172     &demuxer_desc_nut,
 173 #endif
 174 #ifdef CONFIG_XMMS
 175     &demuxer_desc_xmms,
 176 #endif
 177 #ifdef CONFIG_MNG
 178     &demuxer_desc_mng,
 179 #endif
 180     /* Please do not add any new demuxers here. If you want to implement a new
 181      * demuxer, add it to libavformat, except for wrappers around external
 182      * libraries and demuxers requiring binary support. */
 183     NULL
 184 };
 185
 186 void free_demuxer_stream(demux_stream_t *ds)
 187 {
 188     ds_free_packs(ds);
 189     free(ds);
 190 }
 191
 192 demux_stream_t *new_demuxer_stream(struct demuxer *demuxer, int id)
 193 {
 194     demux_stream_t *ds = malloc(sizeof(demux_stream_t));
 195     *ds = (demux_stream_t){
 196         .id = id,
 197         .demuxer = demuxer,
 198         .asf_seq = -1,
 199     };
 200     return ds;
 201 }
 202
 203
 204 /**
 205  * Get demuxer description structure for a given demuxer type
 206  *
 207  * @param file_format    type of the demuxer
 208  * @return               structure for the demuxer, NULL if not found
 209  */
 210 static const demuxer_desc_t *get_demuxer_desc_from_type(int file_format)
 211 {
 212     int i;
 213
 214     for (i = 0; demuxer_list[i]; i++)
 215         if (file_format == demuxer_list[i]->type)
 216             return demuxer_list[i];
 217
 218     return NULL;
 219 }
 220
 221
 222 demuxer_t *new_demuxer(struct MPOpts *opts, stream_t *stream, int type,
 223                        int a_id, int v_id, int s_id, char *filename)
 224 {
 225     struct demuxer *d = talloc_zero(NULL, struct demuxer);
 226     d->stream = stream;
 227     d->stream_pts = MP_NOPTS_VALUE;
 228     d->reference_clock = MP_NOPTS_VALUE;
 229     d->movi_start = stream->start_pos;
 230     d->movi_end = stream->end_pos;
 231     d->seekable = 1;
 232     d->synced = 0;
 233     d->filepos = -1;
 234     d->audio = new_demuxer_stream(d, a_id);
 235     d->video = new_demuxer_stream(d, v_id);
 236     d->sub = new_demuxer_stream(d, s_id);
 237     d->type = type;
 238     d->opts = opts;
 239     if (type)
 240         if (!(d->desc = get_demuxer_desc_from_type(type)))
 241             mp_msg(MSGT_DEMUXER, MSGL_ERR,
 242                    "BUG! Invalid demuxer type in new_demuxer(), "
 243                    "big troubles ahead.");
 244     if (filename) // Filename hack for avs_check_file
 245         d->filename = strdup(filename);
 246     stream->eof = 0;
 247     stream_seek(stream, stream->start_pos);
 248     return d;
 249 }
 250
 251 sh_sub_t *new_sh_sub_sid(demuxer_t *demuxer, int id, int sid)
 252 {
 253     if (id > MAX_S_STREAMS - 1 || id < 0) {
 254         mp_msg(MSGT_DEMUXER, MSGL_WARN,
 255                "Requested sub stream id overflow (%d > %d)\n", id,
 256                MAX_S_STREAMS);
 257         return NULL;
 258     }
 259     if (demuxer->s_streams[id])
 260         mp_msg(MSGT_DEMUXER, MSGL_WARN, "Sub stream %i redefined\n", id);
 261     else {
 262         sh_sub_t *sh = calloc(1, sizeof(sh_sub_t));
 263         demuxer->s_streams[id] = sh;
 264         sh->sid = sid;
 265         sh->opts = demuxer->opts;
 266         mp_msg(MSGT_IDENTIFY, MSGL_INFO, "ID_SUBTITLE_ID=%d\n", sid);
 267     }
 268     if (sid == demuxer->opts->sub_id) {
 269         demuxer->sub->id = id;
 270         demuxer->sub->sh = demuxer->s_streams[id];
 271     }
 272     return demuxer->s_streams[id];
 273 }
 274
 275 static void free_sh_sub(sh_sub_t *sh)
 276 {
 277     mp_msg(MSGT_DEMUXER, MSGL_DBG2, "DEMUXER: freeing sh_sub at %p\n", sh);
 278     free(sh->extradata);
 279 #ifdef CONFIG_ASS
 280     if (sh->ass_track)
 281         ass_free_track(sh->ass_track);
 282 #endif
 283     free(sh->lang);
 284 #ifdef CONFIG_LIBAVCODEC
 285     clear_parser((sh_common_t *)sh);
 286 #endif
 287     free(sh);
 288 }
 289
 290 sh_audio_t *new_sh_audio_aid(demuxer_t *demuxer, int id, int aid)
 291 {
 292     if (id > MAX_A_STREAMS - 1 || id < 0) {
 293         mp_msg(MSGT_DEMUXER, MSGL_WARN,
 294                "Requested audio stream id overflow (%d > %d)\n", id,
 295                MAX_A_STREAMS);
 296         return NULL;
 297     }
 298     if (demuxer->a_streams[id]) {
 299         mp_tmsg(MSGT_DEMUXER, MSGL_WARN, "WARNING: Audio stream header %d redefined.\n", id);
 300     } else {
 301         mp_tmsg(MSGT_DEMUXER, MSGL_V, "==> Found audio stream: %d\n", id);
 302         sh_audio_t *sh = calloc(1, sizeof(sh_audio_t));
 303         demuxer->a_streams[id] = sh;
 304         sh->aid = aid;
 305         sh->ds = demuxer->audio;
 306         // set some defaults
 307         sh->samplesize = 2;
 308         sh->sample_format = AF_FORMAT_S16_NE;
 309         sh->opts = demuxer->opts;
 310         mp_msg(MSGT_IDENTIFY, MSGL_INFO, "ID_AUDIO_ID=%d\n", aid);
 311     }
 312     return demuxer->a_streams[id];
 313 }
 314
 315 void free_sh_audio(demuxer_t *demuxer, int id)
 316 {
 317     sh_audio_t *sh = demuxer->a_streams[id];
 318     demuxer->a_streams[id] = NULL;
 319     mp_msg(MSGT_DEMUXER, MSGL_DBG2, "DEMUXER: freeing sh_audio at %p\n", sh);
 320     free(sh->wf);
 321     free(sh->codecdata);
 322     free(sh->lang);
 323 #ifdef CONFIG_LIBAVCODEC
 324     clear_parser((sh_common_t *)sh);
 325 #endif
 326     free(sh);
 327 }
 328
 329 sh_video_t *new_sh_video_vid(demuxer_t *demuxer, int id, int vid)
 330 {
 331     if (id > MAX_V_STREAMS - 1 || id < 0) {
 332         mp_msg(MSGT_DEMUXER, MSGL_WARN,
 333                "Requested video stream id overflow (%d > %d)\n", id,
 334                MAX_V_STREAMS);
 335         return NULL;
 336     }
 337     if (demuxer->v_streams[id])
 338         mp_tmsg(MSGT_DEMUXER, MSGL_WARN, "WARNING: Video stream header %d redefined.\n", id);
 339     else {
 340         mp_tmsg(MSGT_DEMUXER, MSGL_V, "==> Found video stream: %d\n", id);
 341         sh_video_t *sh = calloc(1, sizeof *sh);
 342         demuxer->v_streams[id] = sh;
 343         sh->vid = vid;
 344         sh->ds = demuxer->video;
 345         sh->opts = demuxer->opts;
 346         mp_msg(MSGT_IDENTIFY, MSGL_INFO, "ID_VIDEO_ID=%d\n", vid);
 347     }
 348     return demuxer->v_streams[id];
 349 }
 350
 351 void free_sh_video(sh_video_t *sh)
 352 {
 353     mp_msg(MSGT_DEMUXER, MSGL_DBG2, "DEMUXER: freeing sh_video at %p\n", sh);
 354     free(sh->bih);
 355 #ifdef CONFIG_LIBAVCODEC
 356     clear_parser((sh_common_t *)sh);
 357 #endif
 358     free(sh);
 359 }
 360
 361 void free_demuxer(demuxer_t *demuxer)
 362 {
 363     int i;
 364     mp_msg(MSGT_DEMUXER, MSGL_DBG2, "DEMUXER: freeing %s demuxer at %p\n",
 365            demuxer->desc->shortdesc, demuxer);
 366     if (demuxer->desc->close)
 367         demuxer->desc->close(demuxer);
 368     // Very ugly hack to make it behave like old implementation
 369     if (demuxer->desc->type == DEMUXER_TYPE_DEMUXERS)
 370         goto skip_streamfree;
 371     // free streams:
 372     for (i = 0; i < MAX_A_STREAMS; i++)
 373         if (demuxer->a_streams[i])
 374             free_sh_audio(demuxer, i);
 375     for (i = 0; i < MAX_V_STREAMS; i++)
 376         if (demuxer->v_streams[i])
 377             free_sh_video(demuxer->v_streams[i]);
 378     for (i = 0; i < MAX_S_STREAMS; i++)
 379         if (demuxer->s_streams[i])
 380             free_sh_sub(demuxer->s_streams[i]);
 381     // free demuxers:
 382     free_demuxer_stream(demuxer->audio);
 383     free_demuxer_stream(demuxer->video);
 384     free_demuxer_stream(demuxer->sub);
 385  skip_streamfree:
 386     free(demuxer->filename);
 387     if (demuxer->teletext)
 388         teletext_control(demuxer->teletext, TV_VBI_CONTROL_STOP, NULL);
 389     talloc_free(demuxer);
 390 }
 391
 392
 393 static void ds_add_packet_internal(demux_stream_t *ds, demux_packet_t *dp)
 394 {
 395     // append packet to DS stream:
 396     ++ds->packs;
 397     ds->bytes += dp->len;
 398     if (ds->last) {
 399         // next packet in stream
 400         ds->last->next = dp;
 401         ds->last = dp;
 402     } else {
 403         // first packet in stream
 404         ds->first = ds->last = dp;
 405     }
 406     mp_dbg(MSGT_DEMUXER, MSGL_DBG2,
 407            "DEMUX: Append packet to %s, len=%d  pts=%5.3f  pos=%u  [packs: A=%d V=%d]\n",
 408            (ds == ds->demuxer->audio) ? "d_audio" : "d_video", dp->len,
 409            dp->pts, (unsigned int) dp->pos, ds->demuxer->audio->packs,
 410            ds->demuxer->video->packs);
 411 }
 412
 413 #ifdef CONFIG_LIBAVCODEC
 414 static void allocate_parser(AVCodecContext **avctx, AVCodecParserContext **parser, unsigned format)
 415 {
 416     enum CodecID codec_id = CODEC_ID_NONE;
 417     extern int avcodec_initialized;
 418     if (!avcodec_initialized) {
 419         avcodec_init();
 420         avcodec_register_all();
 421         avcodec_initialized = 1;
 422     }
 423     switch (format) {
 424     case 0x2000:
 425     case 0x332D6361:
 426     case 0x332D4341:
 427     case MKTAG('d', 'n', 'e', 't'):
 428     case MKTAG('s', 'a', 'c', '3'):
 429         codec_id = CODEC_ID_AC3;
 430         break;
 431     case MKTAG('E', 'A', 'C', '3'):
 432         codec_id = CODEC_ID_EAC3;
 433         break;
 434     case 0x2001:
 435     case 0x86:
 436         codec_id = CODEC_ID_DTS;
 437         break;
 438     case MKTAG('M', 'L', 'P', ' '):
 439         codec_id = CODEC_ID_MLP;
 440         break;
 441     case 0x55:
 442     case 0x5500736d:
 443     case MKTAG('.', 'm', 'p', '3'):
 444     case MKTAG('M', 'P', 'E', ' '):
 445     case MKTAG('L', 'A', 'M', 'E'):
 446         codec_id = CODEC_ID_MP3;
 447         break;
 448     case 0x50:
 449     case MKTAG('.', 'm', 'p', '2'):
 450     case MKTAG('.', 'm', 'p', '1'):
 451         codec_id = CODEC_ID_MP2;
 452         break;
 453     case MKTAG('T', 'R', 'H', 'D'):
 454         codec_id = CODEC_ID_TRUEHD;
 455         break;
 456     }
 457     if (codec_id != CODEC_ID_NONE) {
 458         *avctx = avcodec_alloc_context();
 459         if (!*avctx)
 460             return;
 461         *parser = av_parser_init(codec_id);
 462         if (!*parser)
 463             av_freep(avctx);
 464     }
 465 }
 466
 467 static void get_parser(sh_common_t *sh, AVCodecContext **avctx, AVCodecParserContext **parser)
 468 {
 469     *avctx  = NULL;
 470     *parser = NULL;
 471
 472     if (!sh || !sh->needs_parsing)
 473         return;
 474
 475     *avctx  = sh->avctx;
 476     *parser = sh->parser;
 477     if (*parser)
 478         return;
 479
 480     allocate_parser(avctx, parser, sh->format);
 481     sh->avctx  = *avctx;
 482     sh->parser = *parser;
 483 }
 484
 485 int ds_parse(demux_stream_t *ds, uint8_t **buffer, int *len, double pts, off_t pos)
 486 {
 487     AVCodecContext *avctx;
 488     AVCodecParserContext *parser;
 489     get_parser(ds->sh, &avctx, &parser);
 490     if (!parser)
 491         return *len;
 492     return av_parser_parse2(parser, avctx, buffer, len, *buffer, *len, pts, pts, pos);
 493 }
 494
 495 static void clear_parser(sh_common_t *sh)
 496 {
 497     av_parser_close(sh->parser);
 498     sh->parser = NULL;
 499     av_freep(&sh->avctx);
 500 }
 501
 502 void ds_clear_parser(demux_stream_t *ds)
 503 {
 504     if (!ds->sh)
 505         return;
 506     clear_parser(ds->sh);
 507 }
 508 #endif
 509
 510 void ds_add_packet(demux_stream_t *ds, demux_packet_t *dp)
 511 {
 512 #if PARSE_ON_ADD && defined(CONFIG_LIBAVCODEC)
 513     int len = dp->len;
 514     int pos = 0;
 515     while (len > 0) {
 516         uint8_t *parsed_start = dp->buffer + pos;
 517         int parsed_len = len;
 518         int consumed = ds_parse(ds->sh, &parsed_start, &parsed_len, dp->pts, dp->pos);
 519         pos += consumed;
 520         len -= consumed;
 521         if (parsed_start == dp->buffer && parsed_len == dp->len) {
 522             ds_add_packet_internal(ds, dp);
 523         } else if (parsed_len) {
 524             demux_packet_t *dp2 = new_demux_packet(parsed_len);
 525             dp2->pos = dp->pos;
 526             dp2->pts = dp->pts; // should be parser->pts but that works badly
 527             memcpy(dp2->buffer, parsed_start, parsed_len);
 528             ds_add_packet_internal(ds, dp2);
 529         }
 530     }
 531 #else
 532     ds_add_packet_internal(ds, dp);
 533 #endif
 534 }
 535
 536 void ds_read_packet(demux_stream_t *ds, stream_t *stream, int len,
 537                     double pts, off_t pos, int flags)
 538 {
 539     demux_packet_t *dp = new_demux_packet(len);
 540     len = stream_read(stream, dp->buffer, len);
 541     resize_demux_packet(dp, len);
 542     dp->pts = pts;
 543     dp->pos = pos;
 544     dp->flags = flags;
 545     // append packet to DS stream:
 546     ds_add_packet(ds, dp);
 547 }
 548
 549 // return value:
 550 //     0 = EOF or no stream found or invalid type
 551 //     1 = successfully read a packet
 552
 553 int demux_fill_buffer(demuxer_t *demux, demux_stream_t *ds)
 554 {
 555     // Note: parameter 'ds' can be NULL!
 556     return demux->desc->fill_buffer(demux, ds);
 557 }
 558
 559 // return value:
 560 //     0 = EOF
 561 //     1 = successful
 562 #define MAX_ACUMULATED_PACKETS 64
 563 int ds_fill_buffer(demux_stream_t *ds)
 564 {
 565     demuxer_t *demux = ds->demuxer;
 566     if (ds->current)
 567         free_demux_packet(ds->current);
 568     ds->current = NULL;
 569     if (mp_msg_test(MSGT_DEMUXER, MSGL_DBG3)) {
 570         if (ds == demux->audio)
 571             mp_dbg(MSGT_DEMUXER, MSGL_DBG3,
 572                    "ds_fill_buffer(d_audio) called\n");
 573         else if (ds == demux->video)
 574             mp_dbg(MSGT_DEMUXER, MSGL_DBG3,
 575                    "ds_fill_buffer(d_video) called\n");
 576         else if (ds == demux->sub)
 577             mp_dbg(MSGT_DEMUXER, MSGL_DBG3, "ds_fill_buffer(d_sub) called\n");
 578         else
 579             mp_dbg(MSGT_DEMUXER, MSGL_DBG3,
 580                    "ds_fill_buffer(unknown 0x%X) called\n", (unsigned int) ds);
 581     }
 582     while (1) {
 583         if (ds->packs) {
 584             demux_packet_t *p = ds->first;
 585 #if 0
 586             if (demux->reference_clock != MP_NOPTS_VALUE) {
 587                 if (   p->pts != MP_NOPTS_VALUE
 588                     && p->pts >  demux->reference_clock
 589                     && ds->packs < MAX_ACUMULATED_PACKETS) {
 590                     if (demux_fill_buffer(demux, ds))
 591                         continue;
 592                 }
 593             }
 594 #endif
 595             // copy useful data:
 596             ds->buffer = p->buffer;
 597             ds->buffer_pos = 0;
 598             ds->buffer_size = p->len;
 599             ds->pos = p->pos;
 600             ds->dpos += p->len; // !!!
 601             ++ds->pack_no;
 602             if (p->pts != MP_NOPTS_VALUE) {
 603                 ds->pts = p->pts;
 604                 ds->pts_bytes = 0;
 605             }
 606             ds->pts_bytes += p->len;    // !!!
 607             if (p->stream_pts != MP_NOPTS_VALUE)
 608                 demux->stream_pts = p->stream_pts;
 609             ds->flags = p->flags;
 610             // unlink packet:
 611             ds->bytes -= p->len;
 612             ds->current = p;
 613             ds->first = p->next;
 614             if (!ds->first)
 615                 ds->last = NULL;
 616             --ds->packs;
 617             /* The code below can set ds->eof to 1 when another stream runs
 618              * out of buffer space. That makes sense because in that situation
 619              * the calling code should not count on being able to demux more
 620              * packets from this stream.
 621              * If however the situation improves and we're called again
 622              * despite the eof flag then it's better to clear it to avoid
 623              * weird behavior. */
 624             ds->eof = 0;
 625             return 1;
 626         }
 627
 628 #define MaybeNI _("Maybe you are playing a non-interleaved stream/file or the codec failed?\n" \
 629                 "For AVI files, try to force non-interleaved mode with the -ni option.\n")
 630
 631         if (demux->audio->packs >= MAX_PACKS
 632             || demux->audio->bytes >= MAX_PACK_BYTES) {
 633             mp_tmsg(MSGT_DEMUXER, MSGL_ERR, "\nToo many audio packets in the buffer: (%d in %d bytes).\n",
 634                    demux->audio->packs, demux->audio->bytes);
 635             mp_tmsg(MSGT_DEMUXER, MSGL_HINT, MaybeNI);
 636             break;
 637         }
 638         if (demux->video->packs >= MAX_PACKS
 639             || demux->video->bytes >= MAX_PACK_BYTES) {
 640             mp_tmsg(MSGT_DEMUXER, MSGL_ERR, "\nToo many video packets in the buffer: (%d in %d bytes).\n",
 641                    demux->video->packs, demux->video->bytes);
 642             mp_tmsg(MSGT_DEMUXER, MSGL_HINT, MaybeNI);
 643             break;
 644         }
 645         if (!demux_fill_buffer(demux, ds)) {
 646 #if PARSE_ON_ADD && defined(CONFIG_LIBAVCODEC)
 647             uint8_t *parsed_start = NULL;
 648             int parsed_len = 0;
 649             ds_parse(ds->sh, &parsed_start, &parsed_len, MP_NOPTS_VALUE, 0);
 650             if (parsed_len) {
 651                 demux_packet_t *dp2 = new_demux_packet(parsed_len);
 652                 dp2->pts = MP_NOPTS_VALUE;
 653                 memcpy(dp2->buffer, parsed_start, parsed_len);
 654                 ds_add_packet_internal(ds, dp2);
 655                 continue;
 656             }
 657 #endif
 658             mp_dbg(MSGT_DEMUXER, MSGL_DBG2,
 659                    "ds_fill_buffer()->demux_fill_buffer() failed\n");
 660             break; // EOF
 661         }
 662     }
 663     ds->buffer_pos = ds->buffer_size = 0;
 664     ds->buffer = NULL;
 665     mp_msg(MSGT_DEMUXER, MSGL_V,
 666            "ds_fill_buffer: EOF reached (stream: %s)  \n",
 667            ds == demux->audio ? "audio" : "video");
 668     ds->eof = 1;
 669     return 0;
 670 }
 671
 672 int demux_read_data(demux_stream_t *ds, unsigned char *mem, int len)
 673 {
 674     int x;
 675     int bytes = 0;
 676     while (len > 0) {
 677         x = ds->buffer_size - ds->buffer_pos;
 678         if (x == 0) {
 679             if (!ds_fill_buffer(ds))
 680                 return bytes;
 681         } else {
 682             if (x > len)
 683                 x = len;
 684             if (mem)
 685                 fast_memcpy(mem + bytes, &ds->buffer[ds->buffer_pos], x);
 686             bytes += x;
 687             len -= x;
 688             ds->buffer_pos += x;
 689         }
 690     }
 691     return bytes;
 692 }
 693
 694 /**
 695  * \brief read data until the given 3-byte pattern is encountered, up to maxlen
 696  * \param mem memory to read data into, may be NULL to discard data
 697  * \param maxlen maximum number of bytes to read
 698  * \param read number of bytes actually read
 699  * \param pattern pattern to search for (lowest 8 bits are ignored)
 700  * \return whether pattern was found
 701  */
 702 int demux_pattern_3(demux_stream_t *ds, unsigned char *mem, int maxlen,
 703                     int *read, uint32_t pattern)
 704 {
 705     register uint32_t head = 0xffffff00;
 706     register uint32_t pat = pattern & 0xffffff00;
 707     int total_len = 0;
 708     do {
 709         register unsigned char *ds_buf = &ds->buffer[ds->buffer_size];
 710         int len = ds->buffer_size - ds->buffer_pos;
 711         register long pos = -len;
 712         if (unlikely(pos >= 0)) { // buffer is empty
 713             ds_fill_buffer(ds);
 714             continue;
 715         }
 716         do {
 717             head |= ds_buf[pos];
 718             head <<= 8;
 719         } while (++pos && head != pat);
 720         len += pos;
 721         if (total_len + len > maxlen)
 722             len = maxlen - total_len;
 723         len = demux_read_data(ds, mem ? &mem[total_len] : NULL, len);
 724         total_len += len;
 725     } while ((head != pat || total_len < 3) && total_len < maxlen && !ds->eof);
 726     if (read)
 727         *read = total_len;
 728     return total_len >= 3 && head == pat;
 729 }
 730
 731 void ds_free_packs(demux_stream_t *ds)
 732 {
 733     demux_packet_t *dp = ds->first;
 734     while (dp) {
 735         demux_packet_t *dn = dp->next;
 736         free_demux_packet(dp);
 737         dp = dn;
 738     }
 739     if (ds->asf_packet) {
 740         // free unfinished .asf fragments:
 741         free(ds->asf_packet->buffer);
 742         free(ds->asf_packet);
 743         ds->asf_packet = NULL;
 744     }
 745     ds->first = ds->last = NULL;
 746     ds->packs = 0; // !!!!!
 747     ds->bytes = 0;
 748     if (ds->current)
 749         free_demux_packet(ds->current);
 750     ds->current = NULL;
 751     ds->buffer = NULL;
 752     ds->buffer_pos = ds->buffer_size;
 753     ds->pts = 0;
 754     ds->pts_bytes = 0;
 755 }
 756
 757 int ds_get_packet(demux_stream_t *ds, unsigned char **start)
 758 {
 759     int len;
 760     if (ds->buffer_pos >= ds->buffer_size) {
 761         if (!ds_fill_buffer(ds)) {
 762             // EOF
 763             *start = NULL;
 764             return -1;
 765         }
 766     }
 767     len = ds->buffer_size - ds->buffer_pos;
 768     *start = &ds->buffer[ds->buffer_pos];
 769     ds->buffer_pos += len;
 770     return len;
 771 }
 772
 773 int ds_get_packet_pts(demux_stream_t *ds, unsigned char **start, double *pts)
 774 {
 775     int len;
 776     *pts = MP_NOPTS_VALUE;
 777     len = ds_get_packet(ds, start);
 778     if (len < 0)
 779         return len;
 780     // Return pts unless this read starts from the middle of a packet
 781     if (len == ds->buffer_pos)
 782         *pts = ds->current->pts;
 783     return len;
 784 }
 785
 786 int ds_get_packet_sub(demux_stream_t *ds, unsigned char **start)
 787 {
 788     int len;
 789     if (ds->buffer_pos >= ds->buffer_size) {
 790         *start = NULL;
 791         if (!ds->packs)
 792             return -1;  // no sub
 793         if (!ds_fill_buffer(ds))
 794             return -1;  // EOF
 795     }
 796     len = ds->buffer_size - ds->buffer_pos;
 797     *start = &ds->buffer[ds->buffer_pos];
 798     ds->buffer_pos += len;
 799     return len;
 800 }
 801
 802 double ds_get_next_pts(demux_stream_t *ds)
 803 {
 804     demuxer_t *demux = ds->demuxer;
 805     while (!ds->first) {
 806         if (demux->audio->packs >= MAX_PACKS
 807             || demux->audio->bytes >= MAX_PACK_BYTES) {
 808             mp_tmsg(MSGT_DEMUXER, MSGL_ERR, "\nToo many audio packets in the buffer: (%d in %d bytes).\n",
 809                    demux->audio->packs, demux->audio->bytes);
 810             mp_tmsg(MSGT_DEMUXER, MSGL_HINT, MaybeNI);
 811             return MP_NOPTS_VALUE;
 812         }
 813         if (demux->video->packs >= MAX_PACKS
 814             || demux->video->bytes >= MAX_PACK_BYTES) {
 815             mp_tmsg(MSGT_DEMUXER, MSGL_ERR, "\nToo many video packets in the buffer: (%d in %d bytes).\n",
 816                    demux->video->packs, demux->video->bytes);
 817             mp_tmsg(MSGT_DEMUXER, MSGL_HINT, MaybeNI);
 818             return MP_NOPTS_VALUE;
 819         }
 820         if (!demux_fill_buffer(demux, ds))
 821             return MP_NOPTS_VALUE;
 822     }
 823     return ds->first->pts;
 824 }
 825
 826 // ====================================================================
 827
 828 void demuxer_help(void)
 829 {
 830     int i;
 831
 832     mp_msg(MSGT_DEMUXER, MSGL_INFO, "Available demuxers:\n");
 833     mp_msg(MSGT_DEMUXER, MSGL_INFO, " demuxer:  type  info:  (comment)\n");
 834     mp_msg(MSGT_IDENTIFY, MSGL_INFO, "ID_DEMUXERS\n");
 835     for (i = 0; demuxer_list[i]; i++) {
 836         if (demuxer_list[i]->type > DEMUXER_TYPE_MAX)   // Don't display special demuxers
 837             continue;
 838         if (demuxer_list[i]->comment && strlen(demuxer_list[i]->comment))
 839             mp_msg(MSGT_DEMUXER, MSGL_INFO, "%10s  %2d   %s (%s)\n",
 840                    demuxer_list[i]->name, demuxer_list[i]->type,
 841                    demuxer_list[i]->info, demuxer_list[i]->comment);
 842         else
 843             mp_msg(MSGT_DEMUXER, MSGL_INFO, "%10s  %2d   %s\n",
 844                    demuxer_list[i]->name, demuxer_list[i]->type,
 845                    demuxer_list[i]->info);
 846     }
 847 }
 848
 849
 850 /**
 851  * Get demuxer type for a given demuxer name
 852  *
 853  * @param demuxer_name    string with demuxer name of demuxer number
 854  * @param force           will be set if demuxer should be forced.
 855  *                        May be NULL.
 856  * @return                DEMUXER_TYPE_xxx, -1 if error or not found
 857  */
 858 int get_demuxer_type_from_name(char *demuxer_name, int *force)
 859 {
 860     int i;
 861     long type_int;
 862     char *endptr;
 863
 864     if (!demuxer_name || !demuxer_name[0])
 865         return DEMUXER_TYPE_UNKNOWN;
 866     if (force)
 867         *force = demuxer_name[0] == '+';
 868     if (demuxer_name[0] == '+')
 869         demuxer_name = &demuxer_name[1];
 870     for (i = 0; demuxer_list[i]; i++) {
 871         if (demuxer_list[i]->type > DEMUXER_TYPE_MAX)   // Can't select special demuxers from commandline
 872             continue;
 873         if (strcmp(demuxer_name, demuxer_list[i]->name) == 0)
 874             return demuxer_list[i]->type;
 875     }
 876
 877     // No match found, try to parse name as an integer (demuxer number)
 878     type_int = strtol(demuxer_name, &endptr, 0);
 879     if (*endptr)  // Conversion failed
 880         return -1;
 881     if ((type_int > 0) && (type_int <= DEMUXER_TYPE_MAX))
 882         return (int) type_int;
 883
 884     return -1;
 885 }
 886
 887 int extension_parsing = 1; // 0=off 1=mixed (used only for unstable formats)
 888
 889 /*
 890   NOTE : Several demuxers may be opened at the same time so
 891   demuxers should NEVER rely on an external var to enable them
 892   self. If a demuxer can't do any auto-detection it should only use
 893   file_format. The user can explicitly set file_format with the -demuxer
 894   option so there is really no need for another extra var.
 895   For convenience an option can be added to set file_format directly
 896   to the right type (ex: rawaudio,rawvideo).
 897   Also the stream can override the file_format so a demuxer which rely
 898   on a special stream type can set file_format at the stream level
 899   (ex: tv,mf).
 900 */
 901
 902 static demuxer_t *demux_open_stream(struct MPOpts *opts, stream_t *stream,
 903                                     int file_format, int force, int audio_id,
 904                                     int video_id, int dvdsub_id,
 905                                     char *filename)
 906 {
 907     demuxer_t *demuxer = NULL;
 908
 909     sh_video_t *sh_video = NULL;
 910
 911     const demuxer_desc_t *demuxer_desc;
 912     int fformat = 0;
 913     int i;
 914
 915     // If somebody requested a demuxer check it
 916     if (file_format) {
 917         if ((demuxer_desc = get_demuxer_desc_from_type(file_format))) {
 918             demuxer = new_demuxer(opts, stream, demuxer_desc->type, audio_id,
 919                                   video_id, dvdsub_id, filename);
 920             if (demuxer_desc->check_file)
 921                 fformat = demuxer_desc->check_file(demuxer);
 922             if (force || !demuxer_desc->check_file)
 923                 fformat = demuxer_desc->type;
 924             if (fformat != 0) {
 925                 if (fformat == demuxer_desc->type) {
 926                     demuxer_t *demux2 = demuxer;
 927                     // Move messages to demuxer detection code?
 928                     mp_tmsg(MSGT_DEMUXER, MSGL_INFO,
 929                            "%s file format detected.\n",
 930                            demuxer_desc->shortdesc);
 931                     file_format = fformat;
 932                     if (!demuxer->desc->open
 933                         || (demux2 = demuxer->desc->open(demuxer))) {
 934                         demuxer = demux2;
 935                         goto dmx_open;
 936                     }
 937                 } else {
 938                     // Format changed after check, recurse
 939                     free_demuxer(demuxer);
 940                     return demux_open_stream(opts, stream, fformat, force,
 941                                              audio_id, video_id, dvdsub_id,
 942                                              filename);
 943                 }
 944             }
 945             // Check failed for forced demuxer, quit
 946             free_demuxer(demuxer);
 947             return NULL;
 948         }
 949     }
 950     // Test demuxers with safe file checks
 951     for (i = 0; (demuxer_desc = demuxer_list[i]); i++) {
 952         if (demuxer_desc->safe_check) {
 953             demuxer = new_demuxer(opts, stream, demuxer_desc->type, audio_id,
 954                                   video_id, dvdsub_id, filename);
 955             if ((fformat = demuxer_desc->check_file(demuxer)) != 0) {
 956                 if (fformat == demuxer_desc->type) {
 957                     demuxer_t *demux2 = demuxer;
 958                     mp_tmsg(MSGT_DEMUXER, MSGL_INFO,
 959                            "%s file format detected.\n",
 960                            demuxer_desc->shortdesc);
 961                     file_format = fformat;
 962                     if (!demuxer->desc->open
 963                         || (demux2 = demuxer->desc->open(demuxer))) {
 964                         demuxer = demux2;
 965                         goto dmx_open;
 966                     }
 967                 } else {
 968                     if (fformat == DEMUXER_TYPE_PLAYLIST)
 969                         return demuxer; // handled in mplayer.c
 970                     // Format changed after check, recurse
 971                     free_demuxer(demuxer);
 972                     demuxer = demux_open_stream(opts, stream, fformat, force,
 973                                                 audio_id, video_id,
 974                                                 dvdsub_id, filename);
 975                     if (demuxer)
 976                         return demuxer; // done!
 977                     file_format = DEMUXER_TYPE_UNKNOWN;
 978                 }
 979             }
 980             free_demuxer(demuxer);
 981             demuxer = NULL;
 982         }
 983     }
 984
 985     // If no forced demuxer perform file extension based detection
 986     // Ok. We're over the stable detectable fileformats, the next ones are
 987     // a bit fuzzy. So by default (extension_parsing==1) try extension-based
 988     // detection first:
 989     if (file_format == DEMUXER_TYPE_UNKNOWN && filename
 990         && extension_parsing == 1) {
 991         file_format = demuxer_type_by_filename(filename);
 992         if (file_format != DEMUXER_TYPE_UNKNOWN) {
 993             // we like recursion :)
 994             demuxer = demux_open_stream(opts, stream, file_format, force,
 995                                         audio_id, video_id, dvdsub_id,
 996                                         filename);
 997             if (demuxer)
 998                 return demuxer; // done!
 999             file_format = DEMUXER_TYPE_UNKNOWN; // continue fuzzy guessing...
1000             mp_msg(MSGT_DEMUXER, MSGL_V,
1001                    "demuxer: continue fuzzy content-based format guessing...\n");
1002         }
1003     }
1004     // Try detection for all other demuxers
1005     for (i = 0; (demuxer_desc = demuxer_list[i]); i++) {
1006         if (!demuxer_desc->safe_check && demuxer_desc->check_file) {
1007             demuxer = new_demuxer(opts, stream, demuxer_desc->type, audio_id,
1008                                   video_id, dvdsub_id, filename);
1009             if ((fformat = demuxer_desc->check_file(demuxer)) != 0) {
1010                 if (fformat == demuxer_desc->type) {
1011                     demuxer_t *demux2 = demuxer;
1012                     mp_tmsg(MSGT_DEMUXER, MSGL_INFO,
1013                            "%s file format detected.\n",
1014                            demuxer_desc->shortdesc);
1015                     file_format = fformat;
1016                     if (!demuxer->desc->open
1017                         || (demux2 = demuxer->desc->open(demuxer))) {
1018                         demuxer = demux2;
1019                         goto dmx_open;
1020                     }
1021                 } else {
1022                     if (fformat == DEMUXER_TYPE_PLAYLIST)
1023                         return demuxer; // handled in mplayer.c
1024                     // Format changed after check, recurse
1025                     free_demuxer(demuxer);
1026                     demuxer = demux_open_stream(opts, stream, fformat, force,
1027                                                 audio_id, video_id,
1028                                                 dvdsub_id, filename);
1029                     if (demuxer)
1030                         return demuxer; // done!
1031                     file_format = DEMUXER_TYPE_UNKNOWN;
1032                 }
1033             }
1034             free_demuxer(demuxer);
1035             demuxer = NULL;
1036         }
1037     }
1038
1039     return NULL;
1040     //====== File format recognized, set up these for compatibility: =========
1041  dmx_open:
1042
1043     demuxer->file_format = file_format;
1044
1045     if ((sh_video = demuxer->video->sh) && sh_video->bih) {
1046         int biComp = le2me_32(sh_video->bih->biCompression);
1047         mp_msg(MSGT_DEMUX, MSGL_INFO,
1048                "VIDEO:  [%.4s]  %dx%d  %dbpp  %5.3f fps  %5.1f kbps (%4.1f kbyte/s)\n",
1049                (char *) &biComp, sh_video->bih->biWidth,
1050                sh_video->bih->biHeight, sh_video->bih->biBitCount,
1051                sh_video->fps, sh_video->i_bps * 0.008f,
1052                sh_video->i_bps / 1024.0f);
1053     }
1054 #ifdef CONFIG_ASS
1055     if (opts->ass_enabled && ass_library) {
1056         for (i = 0; i < MAX_S_STREAMS; ++i) {
1057             sh_sub_t *sh = demuxer->s_streams[i];
1058             if (sh && sh->type == 'a') {
1059                 sh->ass_track = ass_new_track(ass_library);
1060                 if (sh->ass_track && sh->extradata)
1061                     ass_process_codec_private(sh->ass_track, sh->extradata,
1062                                               sh->extradata_len);
1063             } else if (sh && sh->type != 'v')
1064                 sh->ass_track = ass_default_track(ass_library);
1065         }
1066     }
1067 #endif
1068     return demuxer;
1069 }
1070
1071 char *audio_stream = NULL;
1072 char *sub_stream = NULL;
1073 int audio_stream_cache = 0;
1074
1075 char *demuxer_name = NULL;       // parameter from -demuxer
1076 char *audio_demuxer_name = NULL; // parameter from -audio-demuxer
1077 char *sub_demuxer_name = NULL;   // parameter from -sub-demuxer
1078
1079 extern int hr_mp3_seek;
1080
1081 extern float stream_cache_min_percent;
1082 extern float stream_cache_seek_min_percent;
1083
1084 demuxer_t *demux_open(struct MPOpts *opts, stream_t *vs, int file_format,
1085                       int audio_id, int video_id, int dvdsub_id,
1086                       char *filename)
1087 {
1088     stream_t *as = NULL, *ss = NULL;
1089     demuxer_t *vd, *ad = NULL, *sd = NULL;
1090     demuxer_t *res;
1091     int afmt = DEMUXER_TYPE_UNKNOWN, sfmt = DEMUXER_TYPE_UNKNOWN;
1092     int demuxer_type;
1093     int audio_demuxer_type = 0, sub_demuxer_type = 0;
1094     int demuxer_force = 0, audio_demuxer_force = 0, sub_demuxer_force = 0;
1095
1096     if ((demuxer_type =
1097          get_demuxer_type_from_name(demuxer_name, &demuxer_force)) < 0) {
1098         mp_msg(MSGT_DEMUXER, MSGL_ERR, "-demuxer %s does not exist.\n",
1099                demuxer_name);
1100     }
1101     if ((audio_demuxer_type =
1102          get_demuxer_type_from_name(audio_demuxer_name,
1103                                     &audio_demuxer_force)) < 0) {
1104         mp_msg(MSGT_DEMUXER, MSGL_ERR, "-audio-demuxer %s does not exist.\n",
1105                audio_demuxer_name);
1106     }
1107     if ((sub_demuxer_type =
1108          get_demuxer_type_from_name(sub_demuxer_name,
1109                                     &sub_demuxer_force)) < 0) {
1110         mp_msg(MSGT_DEMUXER, MSGL_ERR, "-sub-demuxer %s does not exist.\n",
1111                sub_demuxer_name);
1112     }
1113
1114     if (audio_stream) {
1115         as = open_stream(audio_stream, 0, &afmt);
1116         if (!as) {
1117             mp_tmsg(MSGT_DEMUXER, MSGL_ERR, "Cannot open audio stream: %s\n",
1118                    audio_stream);
1119             return NULL;
1120         }
1121         if (audio_stream_cache) {
1122             if (!stream_enable_cache
1123                 (as, audio_stream_cache * 1024,
1124                  audio_stream_cache * 1024 * (stream_cache_min_percent /
1125                                               100.0),
1126                  audio_stream_cache * 1024 * (stream_cache_seek_min_percent /
1127                                               100.0))) {
1128                 free_stream(as);
1129                 mp_msg(MSGT_DEMUXER, MSGL_ERR,
1130                        "Can't enable audio stream cache\n");
1131                 return NULL;
1132             }
1133         }
1134     }
1135     if (sub_stream) {
1136         ss = open_stream(sub_stream, 0, &sfmt);
1137         if (!ss) {
1138             mp_tmsg(MSGT_DEMUXER, MSGL_ERR, "Cannot open subtitle stream: %s\n",
1139                    sub_stream);
1140             return NULL;
1141         }
1142     }
1143
1144     vd = demux_open_stream(opts, vs, demuxer_type ? demuxer_type : file_format,
1145                            demuxer_force, audio_stream ? -2 : audio_id,
1146                            video_id, sub_stream ? -2 : dvdsub_id, filename);
1147     if (!vd) {
1148         if (as)
1149             free_stream(as);
1150         if (ss)
1151             free_stream(ss);
1152         return NULL;
1153     }
1154     if (as) {
1155         ad = demux_open_stream(opts, as,
1156                                audio_demuxer_type ? audio_demuxer_type : afmt,
1157                                audio_demuxer_force, audio_id, -2, -2,
1158                                audio_stream);
1159         if (!ad) {
1160             mp_tmsg(MSGT_DEMUXER, MSGL_WARN, "Failed to open audio demuxer: %s\n",
1161                    audio_stream);
1162             free_stream(as);
1163         } else if (ad->audio->sh
1164                    && ((sh_audio_t *) ad->audio->sh)->format == 0x55) // MP3
1165             hr_mp3_seek = 1;    // Enable high res seeking
1166     }
1167     if (ss) {
1168         sd = demux_open_stream(opts, ss,
1169                                sub_demuxer_type ? sub_demuxer_type : sfmt,
1170                                sub_demuxer_force, -2, -2, dvdsub_id,
1171                                sub_stream);
1172         if (!sd) {
1173             mp_tmsg(MSGT_DEMUXER, MSGL_WARN,
1174                    "Failed to open subtitle demuxer: %s\n", sub_stream);
1175             free_stream(ss);
1176         }
1177     }
1178
1179     if (ad && sd)
1180         res = new_demuxers_demuxer(vd, ad, sd);
1181     else if (ad)
1182         res = new_demuxers_demuxer(vd, ad, vd);
1183     else if (sd)
1184         res = new_demuxers_demuxer(vd, vd, sd);
1185     else
1186         res = vd;
1187
1188     opts->correct_pts = opts->user_correct_pts;
1189     if (opts->correct_pts < 0)
1190         opts->correct_pts =
1191             demux_control(res, DEMUXER_CTRL_CORRECT_PTS,
1192                           NULL) == DEMUXER_CTRL_OK;
1193     return res;
1194 }
1195
1196
1197 void demux_flush(demuxer_t *demuxer)
1198 {
1199 #if PARSE_ON_ADD
1200     ds_clear_parser(demuxer->video);
1201     ds_clear_parser(demuxer->audio);
1202     ds_clear_parser(demuxer->sub);
1203 #endif
1204     ds_free_packs(demuxer->video);
1205     ds_free_packs(demuxer->audio);
1206     ds_free_packs(demuxer->sub);
1207 }
1208
1209 int demux_seek(demuxer_t *demuxer, float rel_seek_secs, float audio_delay,
1210                int flags)
1211 {
1212     if (!demuxer->seekable) {
1213         if (demuxer->file_format == DEMUXER_TYPE_AVI)
1214             mp_tmsg(MSGT_SEEK, MSGL_WARN, "Cannot seek in raw AVI streams. (Index required, try with the -idx switch.)\n");
1215 #ifdef CONFIG_TV
1216         else if (demuxer->file_format == DEMUXER_TYPE_TV)
1217             mp_tmsg(MSGT_SEEK, MSGL_WARN, "TV input is not seekable! (Seeking will probably be for changing channels ;)\n");
1218 #endif
1219         else
1220             mp_tmsg(MSGT_SEEK, MSGL_WARN, "Cannot seek in this file.\n");
1221         return 0;
1222     }
1223     // clear demux buffers:
1224     demux_flush(demuxer);
1225     demuxer->video->eof = 0;
1226     demuxer->audio->eof = 0;
1227
1228     /* HACK: assume any demuxer used with these streams can cope with
1229      * the stream layer suddenly seeking to a different position under it
1230      * (nothing actually implements DEMUXER_CTRL_RESYNC now).
1231      */
1232     struct stream *stream = demuxer->stream;
1233     if (stream->type == STREAMTYPE_DVD || stream->type == STREAMTYPE_DVDNAV) {
1234         double pts;
1235
1236         if (flags & SEEK_ABSOLUTE)
1237             pts = 0.0f;
1238         else {
1239             if (demuxer->stream_pts == MP_NOPTS_VALUE)
1240                 goto dmx_seek;
1241             pts = demuxer->stream_pts;
1242         }
1243
1244         if (flags & SEEK_FACTOR) {
1245             double tmp = 0;
1246             if (stream_control(demuxer->stream, STREAM_CTRL_GET_TIME_LENGTH,
1247                                &tmp) == STREAM_UNSUPPORTED)
1248                 goto dmx_seek;
1249             pts += tmp * rel_seek_secs;
1250         } else
1251             pts += rel_seek_secs;
1252
1253         if (stream_control(demuxer->stream, STREAM_CTRL_SEEK_TO_TIME, &pts)
1254             != STREAM_UNSUPPORTED) {
1255             demux_control(demuxer, DEMUXER_CTRL_RESYNC, NULL);
1256             return 1;
1257         }
1258     }
1259
1260   dmx_seek:
1261     if (demuxer->desc->seek)
1262         demuxer->desc->seek(demuxer, rel_seek_secs, audio_delay, flags);
1263
1264     return 1;
1265 }
1266
1267 int demux_info_add(demuxer_t *demuxer, const char *opt, const char *param)
1268 {
1269     return demux_info_add_bstr(demuxer, BSTR(opt), BSTR(param));
1270 }
1271
1272 int demux_info_add_bstr(demuxer_t *demuxer, struct bstr opt, struct bstr param)
1273 {
1274     char **info = demuxer->info;
1275     int n = 0;
1276
1277
1278     for (n = 0; info && info[2 * n] != NULL; n++) {
1279         if (!bstrcasecmp(opt, BSTR(info[2*n]))) {
1280             if (!bstrcmp(param, BSTR(info[2*n + 1]))) {
1281                 mp_msg(MSGT_DEMUX, MSGL_V, "Demuxer info %.*s set to unchanged value %.*s\n",
1282                        BSTR_P(opt), BSTR_P(param));
1283                 return 0;
1284             }
1285             mp_tmsg(MSGT_DEMUX, MSGL_INFO, "Demuxer info %.*s changed to %.*s\n",
1286                     BSTR_P(opt), BSTR_P(param));
1287             talloc_free(info[2*n + 1]);
1288             info[2*n + 1] = talloc_strndup(demuxer->info, param.start, param.len);
1289             return 0;
1290         }
1291     }
1292
1293     info = demuxer->info = talloc_realloc(demuxer, info, char *, 2 * (n + 2));
1294     info[2*n]     = talloc_strndup(demuxer->info, opt.start,   opt.len);
1295     info[2*n + 1] = talloc_strndup(demuxer->info, param.start, param.len);
1296     memset(&info[2 * (n + 1)], 0, 2 * sizeof(char *));
1297
1298     return 1;
1299 }
1300
1301 int demux_info_print(demuxer_t *demuxer)
1302 {
1303     char **info = demuxer->info;
1304     int n;
1305
1306     if (!info)
1307         return 0;
1308
1309     mp_tmsg(MSGT_DEMUX, MSGL_INFO, "Clip info:\n");
1310     for (n = 0; info[2 * n] != NULL; n++) {
1311         mp_msg(MSGT_DEMUX, MSGL_INFO, " %s: %s\n", info[2 * n],
1312                info[2 * n + 1]);
1313         mp_msg(MSGT_IDENTIFY, MSGL_INFO, "ID_CLIP_INFO_NAME%d=%s\n", n,
1314                info[2 * n]);
1315         mp_msg(MSGT_IDENTIFY, MSGL_INFO, "ID_CLIP_INFO_VALUE%d=%s\n", n,
1316                info[2 * n + 1]);
1317     }
1318     mp_msg(MSGT_IDENTIFY, MSGL_INFO, "ID_CLIP_INFO_N=%d\n", n);
1319
1320     return 0;
1321 }
1322
1323 char *demux_info_get(demuxer_t *demuxer, const char *opt)
1324 {
1325     int i;
1326     char **info = demuxer->info;
1327
1328     for (i = 0; info && info[2 * i] != NULL; i++) {
1329         if (!strcasecmp(opt, info[2 * i]))
1330             return info[2 * i + 1];
1331     }
1332
1333     return NULL;
1334 }
1335
1336 int demux_control(demuxer_t *demuxer, int cmd, void *arg)
1337 {
1338
1339     if (demuxer->desc->control)
1340         return demuxer->desc->control(demuxer, cmd, arg);
1341
1342     return DEMUXER_CTRL_NOTIMPL;
1343 }
1344
1345
1346
1347 double demuxer_get_time_length(demuxer_t *demuxer)
1348 {
1349     double get_time_ans;
1350     sh_video_t *sh_video = demuxer->video->sh;
1351     sh_audio_t *sh_audio = demuxer->audio->sh;
1352     // <= 0 means DEMUXER_CTRL_NOTIMPL or DEMUXER_CTRL_DONTKNOW
1353     if (demux_control
1354         (demuxer, DEMUXER_CTRL_GET_TIME_LENGTH, (void *) &get_time_ans) <= 0) {
1355         if (sh_video && sh_video->i_bps && sh_audio && sh_audio->i_bps)
1356             get_time_ans = (double) (demuxer->movi_end -
1357                                      demuxer->movi_start) / (sh_video->i_bps +
1358                                                              sh_audio->i_bps);
1359         else if (sh_video && sh_video->i_bps)
1360             get_time_ans = (double) (demuxer->movi_end -
1361                                      demuxer->movi_start) / sh_video->i_bps;
1362         else if (sh_audio && sh_audio->i_bps)
1363             get_time_ans = (double) (demuxer->movi_end -
1364                                      demuxer->movi_start) / sh_audio->i_bps;
1365         else
1366             get_time_ans = 0;
1367     }
1368     return get_time_ans;
1369 }
1370
1371 /**
1372  * \brief demuxer_get_current_time() returns the time of the current play in three possible ways:
1373  *        either when the stream reader satisfies STREAM_CTRL_GET_CURRENT_TIME (e.g. dvd)
1374  *        or using sh_video->pts when the former method fails
1375  *        0 otherwise
1376  * \return the current play time
1377  */
1378 int demuxer_get_current_time(demuxer_t *demuxer)
1379 {
1380     double get_time_ans = 0;
1381     sh_video_t *sh_video = demuxer->video->sh;
1382     if (demuxer->stream_pts != MP_NOPTS_VALUE)
1383         get_time_ans = demuxer->stream_pts;
1384     else if (sh_video)
1385         get_time_ans = sh_video->pts;
1386     return (int) get_time_ans;
1387 }
1388
1389 int demuxer_get_percent_pos(demuxer_t *demuxer)
1390 {
1391     int ans = 0;
1392     int res = demux_control(demuxer, DEMUXER_CTRL_GET_PERCENT_POS, &ans);
1393     int len = (demuxer->movi_end - demuxer->movi_start) / 100;
1394     if (res <= 0) {
1395         off_t pos = demuxer->filepos > 0 ? demuxer->filepos : stream_tell(demuxer->stream);
1396         if (len > 0)
1397             ans = (pos - demuxer->movi_start) / len;
1398         else
1399             ans = 0;
1400     }
1401     if (ans < 0)
1402         ans = 0;
1403     if (ans > 100)
1404         ans = 100;
1405     return ans;
1406 }
1407
1408 int demuxer_switch_audio(demuxer_t *demuxer, int index)
1409 {
1410     int res = demux_control(demuxer, DEMUXER_CTRL_SWITCH_AUDIO, &index);
1411     if (res == DEMUXER_CTRL_NOTIMPL)
1412         index = demuxer->audio->id;
1413     if (demuxer->audio->id >= 0)
1414         demuxer->audio->sh = demuxer->a_streams[demuxer->audio->id];
1415     else
1416         demuxer->audio->sh = NULL;
1417     return index;
1418 }
1419
1420 int demuxer_switch_video(demuxer_t *demuxer, int index)
1421 {
1422     int res = demux_control(demuxer, DEMUXER_CTRL_SWITCH_VIDEO, &index);
1423     if (res == DEMUXER_CTRL_NOTIMPL)
1424         index = demuxer->video->id;
1425     if (demuxer->video->id >= 0)
1426         demuxer->video->sh = demuxer->v_streams[demuxer->video->id];
1427     else
1428         demuxer->video->sh = NULL;
1429     return index;
1430 }
1431
1432 int demuxer_add_attachment(demuxer_t *demuxer, const char *name,
1433                            int name_maxlen, const char *type, int type_maxlen,
1434                            const void *data, size_t size)
1435 {
1436     if (!(demuxer->num_attachments % 32))
1437         demuxer->attachments = talloc_realloc(demuxer, demuxer->attachments,
1438                                               struct demux_attachment,
1439                                               demuxer->num_attachments + 32);
1440
1441     struct demux_attachment *att =
1442         demuxer->attachments + demuxer->num_attachments;
1443     att->name = talloc_strndup(demuxer->attachments, name, name_maxlen);
1444     att->type = talloc_strndup(demuxer->attachments, type, type_maxlen);
1445     att->data = talloc_size(demuxer->attachments, size);
1446     memcpy(att->data, data, size);
1447     att->data_size = size;
1448
1449     return demuxer->num_attachments++;
1450 }
1451
1452 int demuxer_add_chapter(demuxer_t *demuxer, const char *name, int name_maxlen,
1453                         uint64_t start, uint64_t end)
1454 {
1455     if (!(demuxer->num_chapters % 32))
1456         demuxer->chapters = talloc_realloc(demuxer, demuxer->chapters,
1457                                            struct demux_chapter,
1458                                            demuxer->num_chapters + 32);
1459
1460     demuxer->chapters[demuxer->num_chapters].start = start;
1461     demuxer->chapters[demuxer->num_chapters].end = end;
1462     demuxer->chapters[demuxer->num_chapters].name = name ?
1463         talloc_strndup(demuxer->chapters, name, name_maxlen) :
1464         talloc_strdup(demuxer->chapters, mp_gtext("unknown"));
1465
1466     mp_msg(MSGT_IDENTIFY, MSGL_INFO, "ID_CHAPTER_ID=%d\n", demuxer->num_chapters);
1467     mp_msg(MSGT_IDENTIFY, MSGL_INFO, "ID_CHAPTER_%d_START=%"PRIu64"\n", demuxer->num_chapters, start);
1468     if (end)
1469         mp_msg(MSGT_IDENTIFY, MSGL_INFO, "ID_CHAPTER_%d_END=%"PRIu64"\n", demuxer->num_chapters, end);
1470     if (name)
1471         mp_msg(MSGT_IDENTIFY, MSGL_INFO, "ID_CHAPTER_%d_NAME=%.*s\n", demuxer->num_chapters, name_maxlen, name);
1472
1473     return demuxer->num_chapters++;
1474 }
1475
1476 /**
1477  * \brief demuxer_seek_chapter() seeks to a chapter in two possible ways:
1478  *        either using the demuxer->chapters structure set by the demuxer
1479  *        or asking help to the stream layer (e.g. dvd)
1480  * \param chapter - chapter number wished - 0-based
1481  * \param seek_pts set by the function to the pts to seek to (if demuxer->chapters is set)
1482  * \param chapter_name name of chapter found (set by this function is param is not null)
1483  * \return -1 on error, current chapter if successful
1484  */
1485
1486 int demuxer_seek_chapter(demuxer_t *demuxer, int chapter, double *seek_pts,
1487                          char **chapter_name)
1488 {
1489     int ris;
1490
1491     if (!demuxer->num_chapters || !demuxer->chapters) {
1492         demux_flush(demuxer);
1493
1494         ris = stream_control(demuxer->stream, STREAM_CTRL_SEEK_TO_CHAPTER,
1495                              &chapter);
1496         if (ris != STREAM_UNSUPPORTED)
1497             demux_control(demuxer, DEMUXER_CTRL_RESYNC, NULL);
1498
1499         // exit status may be ok, but main() doesn't have to seek itself
1500         // (because e.g. dvds depend on sectors, not on pts)
1501         *seek_pts = -1.0;
1502
1503         if (chapter_name) {
1504             *chapter_name = NULL;
1505             int num_chapters;
1506             if (stream_control(demuxer->stream, STREAM_CTRL_GET_NUM_CHAPTERS,
1507                                &num_chapters) == STREAM_UNSUPPORTED)
1508                 num_chapters = 0;
1509             if (num_chapters) {
1510                 *chapter_name = talloc_size(NULL, 16);
1511                 sprintf(*chapter_name, " of %3d", num_chapters);
1512             }
1513         }
1514
1515         return ris != STREAM_UNSUPPORTED ? chapter : -1;
1516     } else {  // chapters structure is set in the demuxer
1517         if (chapter >= demuxer->num_chapters)
1518             return -1;
1519         if (chapter < 0)
1520             chapter = 0;
1521
1522         *seek_pts = demuxer->chapters[chapter].start / 1000.0;
1523
1524         if (chapter_name)
1525             *chapter_name = talloc_strdup(NULL, demuxer->chapters[chapter].name);
1526
1527         return chapter;
1528     }
1529 }
1530
1531 int demuxer_get_current_chapter(demuxer_t *demuxer)
1532 {
1533     int chapter = -2;
1534     if (!demuxer->num_chapters || !demuxer->chapters) {
1535         if (stream_control(demuxer->stream, STREAM_CTRL_GET_CURRENT_CHAPTER,
1536                            &chapter) == STREAM_UNSUPPORTED)
1537             chapter = -2;
1538     } else {
1539         sh_video_t *sh_video = demuxer->video->sh;
1540         sh_audio_t *sh_audio = demuxer->audio->sh;
1541         uint64_t now;
1542         now = (sh_video ? sh_video->pts : (sh_audio ? sh_audio->pts : 0))
1543               * 1000 + 0.5;
1544         for (chapter = demuxer->num_chapters - 1; chapter >= 0; --chapter) {
1545             if (demuxer->chapters[chapter].start <= now)
1546                 break;
1547         }
1548     }
1549     return chapter;
1550 }
1551
1552 char *demuxer_chapter_name(demuxer_t *demuxer, int chapter)
1553 {
1554     if (demuxer->num_chapters && demuxer->chapters) {
1555         if (chapter >= 0 && chapter < demuxer->num_chapters
1556             && demuxer->chapters[chapter].name)
1557             return strdup(demuxer->chapters[chapter].name);
1558     }
1559     return NULL;
1560 }
1561
1562 char *demuxer_chapter_display_name(demuxer_t *demuxer, int chapter)
1563 {
1564     char *chapter_name = demuxer_chapter_name(demuxer, chapter);
1565     if (chapter_name) {
1566         char *tmp = malloc(strlen(chapter_name) + 14);
1567         snprintf(tmp, 63, "(%d) %s", chapter + 1, chapter_name);
1568         free(chapter_name);
1569         return tmp;
1570     } else {
1571         int chapter_num = demuxer_chapter_count(demuxer);
1572         char tmp[30];
1573         if (chapter_num <= 0)
1574             sprintf(tmp, "(%d)", chapter + 1);
1575         else
1576             sprintf(tmp, "(%d) of %d", chapter + 1, chapter_num);
1577         return strdup(tmp);
1578     }
1579 }
1580
1581 float demuxer_chapter_time(demuxer_t *demuxer, int chapter, float *end)
1582 {
1583     if (demuxer->num_chapters && demuxer->chapters && chapter >= 0
1584         && chapter < demuxer->num_chapters) {
1585         if (end)
1586             *end = demuxer->chapters[chapter].end / 1000.0;
1587         return demuxer->chapters[chapter].start / 1000.0;
1588     }
1589     return -1.0;
1590 }
1591
1592 int demuxer_chapter_count(demuxer_t *demuxer)
1593 {
1594     if (!demuxer->num_chapters || !demuxer->chapters) {
1595         int num_chapters = 0;
1596         if (stream_control(demuxer->stream, STREAM_CTRL_GET_NUM_CHAPTERS,
1597                            &num_chapters) == STREAM_UNSUPPORTED)
1598             num_chapters = 0;
1599         return num_chapters;
1600     } else
1601         return demuxer->num_chapters;
1602 }
1603
1604 int demuxer_angles_count(demuxer_t *demuxer)
1605 {
1606     int ris, angles = -1;
1607
1608     ris = stream_control(demuxer->stream, STREAM_CTRL_GET_NUM_ANGLES, &angles);
1609     if (ris == STREAM_UNSUPPORTED)
1610         return -1;
1611     return angles;
1612 }
1613
1614 int demuxer_get_current_angle(demuxer_t *demuxer)
1615 {
1616     int ris, curr_angle = -1;
1617     ris = stream_control(demuxer->stream, STREAM_CTRL_GET_ANGLE, &curr_angle);
1618     if (ris == STREAM_UNSUPPORTED)
1619         return -1;
1620     return curr_angle;
1621 }
1622
1623
1624 int demuxer_set_angle(demuxer_t *demuxer, int angle)
1625 {
1626     int ris, angles = -1;
1627
1628     angles = demuxer_angles_count(demuxer);
1629     if ((angles < 1) || (angle > angles))
1630         return -1;
1631
1632     demux_flush(demuxer);
1633
1634     ris = stream_control(demuxer->stream, STREAM_CTRL_SET_ANGLE, &angle);
1635     if (ris == STREAM_UNSUPPORTED)
1636         return -1;
1637
1638     demux_control(demuxer, DEMUXER_CTRL_RESYNC, NULL);
1639
1640     return angle;
1641 }
1642
1643 int demuxer_audio_track_by_lang(demuxer_t *d, char *lang)
1644 {
1645     int i, len;
1646     lang += strspn(lang, ",");
1647     while ((len = strcspn(lang, ",")) > 0) {
1648         for (i = 0; i < MAX_A_STREAMS; ++i) {
1649             sh_audio_t *sh = d->a_streams[i];
1650             if (sh && sh->lang && strncmp(sh->lang, lang, len) == 0)
1651                 return sh->aid;
1652         }
1653         lang += len;
1654         lang += strspn(lang, ",");
1655     }
1656     return -1;
1657 }
1658
1659 int demuxer_sub_track_by_lang(demuxer_t *d, char *lang)
1660 {
1661     int i, len;
1662     lang += strspn(lang, ",");
1663     while ((len = strcspn(lang, ",")) > 0) {
1664         for (i = 0; i < MAX_S_STREAMS; ++i) {
1665             sh_sub_t *sh = d->s_streams[i];
1666             if (sh && sh->lang && strncmp(sh->lang, lang, len) == 0)
1667                 return sh->sid;
1668         }
1669         lang += len;
1670         lang += strspn(lang, ",");
1671     }
1672     return -1;
1673 }
1674
1675 int demuxer_default_audio_track(demuxer_t *d)
1676 {
1677     int i;
1678     for (i = 0; i < MAX_A_STREAMS; ++i) {
1679         sh_audio_t *sh = d->a_streams[i];
1680         if (sh && sh->default_track)
1681             return sh->aid;
1682     }
1683     for (i = 0; i < MAX_A_STREAMS; ++i) {
1684         sh_audio_t *sh = d->a_streams[i];
1685         if (sh)
1686             return sh->aid;
1687     }
1688     return -1;
1689 }
1690
1691 int demuxer_default_sub_track(demuxer_t *d)
1692 {
1693     int i;
1694     for (i = 0; i < MAX_S_STREAMS; ++i) {
1695         sh_sub_t *sh = d->s_streams[i];
1696         if (sh && sh->default_track)
1697             return sh->sid;
1698     }
1699     return -1;
1700 }