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