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