libmpdemux/demuxer.c

   1 //=================== DEMUXER v2.5 =========================
   2
   3 #include <stdio.h>
   4 #include <stdlib.h>
   5 #include <string.h>
   6 #include <unistd.h>
   7
   8 #include <sys/types.h>
   9 #include <sys/stat.h>
  10
  11 #include "config.h"
  12 #include "mp_msg.h"
  13 #include "help_mp.h"
  14 #include "m_config.h"
  15
  16 #include "libvo/fastmemcpy.h"
  17
  18 #include "stream.h"
  19 #include "demuxer.h"
  20 #include "stheader.h"
  21 #include "mf.h"
  22
  23 #include "libaf/af_format.h"
  24
  25 extern void resync_video_stream(sh_video_t *sh_video);
  26 extern void resync_audio_stream(sh_audio_t *sh_audio);
  27
  28 // Demuxer list
  29 extern demuxer_desc_t demuxer_desc_rawaudio;
  30 extern demuxer_desc_t demuxer_desc_rawvideo;
  31 extern demuxer_desc_t demuxer_desc_tv;
  32 extern demuxer_desc_t demuxer_desc_mf;
  33 extern demuxer_desc_t demuxer_desc_avi;
  34 extern demuxer_desc_t demuxer_desc_y4m;
  35 extern demuxer_desc_t demuxer_desc_asf;
  36 extern demuxer_desc_t demuxer_desc_nuv;
  37 extern demuxer_desc_t demuxer_desc_real;
  38 extern demuxer_desc_t demuxer_desc_smjpeg;
  39 extern demuxer_desc_t demuxer_desc_matroska;
  40 extern demuxer_desc_t demuxer_desc_realaudio;
  41 extern demuxer_desc_t demuxer_desc_vqf;
  42 extern demuxer_desc_t demuxer_desc_mov;
  43 extern demuxer_desc_t demuxer_desc_vivo;
  44 extern demuxer_desc_t demuxer_desc_fli;
  45 extern demuxer_desc_t demuxer_desc_film;
  46 extern demuxer_desc_t demuxer_desc_roq;
  47 extern demuxer_desc_t demuxer_desc_gif;
  48 extern demuxer_desc_t demuxer_desc_ogg;
  49 extern demuxer_desc_t demuxer_desc_avs;
  50 extern demuxer_desc_t demuxer_desc_pva;
  51 extern demuxer_desc_t demuxer_desc_nsv;
  52 extern demuxer_desc_t demuxer_desc_mpeg_ts;
  53 extern demuxer_desc_t demuxer_desc_lmlm4;
  54 extern demuxer_desc_t demuxer_desc_mpeg_ps;
  55 extern demuxer_desc_t demuxer_desc_mpeg_pes;
  56 extern demuxer_desc_t demuxer_desc_mpeg_es;
  57 extern demuxer_desc_t demuxer_desc_mpeg_gxf;
  58 extern demuxer_desc_t demuxer_desc_mpeg4_es;
  59 extern demuxer_desc_t demuxer_desc_h264_es;
  60 extern demuxer_desc_t demuxer_desc_rawdv;
  61 extern demuxer_desc_t demuxer_desc_mpc;
  62 extern demuxer_desc_t demuxer_desc_audio;
  63 extern demuxer_desc_t demuxer_desc_xmms;
  64 extern demuxer_desc_t demuxer_desc_mpeg_ty;
  65 extern demuxer_desc_t demuxer_desc_rtp;
  66 extern demuxer_desc_t demuxer_desc_lavf;
  67 extern demuxer_desc_t demuxer_desc_aac;
  68 extern demuxer_desc_t demuxer_desc_nut;
  69
  70 demuxer_desc_t* demuxer_list[] = {
  71   &demuxer_desc_rawaudio,
  72   &demuxer_desc_rawvideo,
  73 #ifdef USE_TV
  74   &demuxer_desc_tv,
  75 #endif
  76   &demuxer_desc_mf,
  77   &demuxer_desc_avi,
  78   &demuxer_desc_y4m,
  79   &demuxer_desc_asf,
  80   &demuxer_desc_nsv,
  81   &demuxer_desc_nuv,
  82   &demuxer_desc_real,
  83   &demuxer_desc_smjpeg,
  84   &demuxer_desc_matroska,
  85   &demuxer_desc_realaudio,
  86   &demuxer_desc_vqf,
  87   &demuxer_desc_mov,
  88   &demuxer_desc_vivo,
  89   &demuxer_desc_fli,
  90   &demuxer_desc_film,
  91   &demuxer_desc_roq,
  92 #ifdef HAVE_GIF
  93   &demuxer_desc_gif,
  94 #endif
  95 #ifdef HAVE_OGGVORBIS
  96   &demuxer_desc_ogg,
  97 #endif
  98 #ifdef USE_WIN32DLL
  99   &demuxer_desc_avs,
 100 #endif
 101   &demuxer_desc_pva,
 102   &demuxer_desc_mpeg_ts,
 103   &demuxer_desc_lmlm4,
 104   &demuxer_desc_mpeg_ps,
 105   &demuxer_desc_mpeg_pes,
 106   &demuxer_desc_mpeg_es,
 107   &demuxer_desc_mpeg_gxf,
 108   &demuxer_desc_mpeg4_es,
 109   &demuxer_desc_h264_es,
 110 #ifdef MUSEPACK
 111   &demuxer_desc_mpc,
 112 #endif
 113   &demuxer_desc_audio,
 114   &demuxer_desc_mpeg_ty,
 115 #ifdef STREAMING_LIVE555
 116   &demuxer_desc_rtp,
 117 #endif
 118 #if defined(USE_LIBAVFORMAT) ||  defined(USE_LIBAVFORMAT_SO)
 119   &demuxer_desc_lavf,
 120 #endif
 121 #ifdef HAVE_LIBDV095
 122   &demuxer_desc_rawdv,
 123 #endif
 124   &demuxer_desc_aac,
 125 #ifdef HAVE_LIBNUT
 126   &demuxer_desc_nut,
 127 #endif
 128 #ifdef HAVE_XMMS
 129   &demuxer_desc_xmms,
 130 #endif
 131   NULL
 132 };
 133
 134 void free_demuxer_stream(demux_stream_t *ds){
 135     ds_free_packs(ds);
 136     free(ds);
 137 }
 138
 139 demux_stream_t* new_demuxer_stream(struct demuxer_st *demuxer,int id){
 140   demux_stream_t* ds=malloc(sizeof(demux_stream_t));
 141   ds->buffer_pos=ds->buffer_size=0;
 142   ds->buffer=NULL;
 143   ds->pts=0;
 144   ds->pts_bytes=0;
 145   ds->eof=0;
 146   ds->pos=0;
 147   ds->dpos=0;
 148   ds->pack_no=0;
 149 //---------------
 150   ds->packs=0;
 151   ds->bytes=0;
 152   ds->first=ds->last=ds->current=NULL;
 153   ds->id=id;
 154   ds->demuxer=demuxer;
 155 //----------------
 156   ds->asf_seq=-1;
 157   ds->asf_packet=NULL;
 158 //----------------
 159   ds->ss_mul=ds->ss_div=0;
 160 //----------------
 161   ds->sh=NULL;
 162   return ds;
 163 }
 164
 165
 166 /**
 167  * Get demuxer description structure for a given demuxer type
 168  *
 169  * @param file_format    type of the demuxer
 170  * @return               structure for the demuxer, NULL if not found
 171  */
 172 static demuxer_desc_t* get_demuxer_desc_from_type(int file_format)
 173 {
 174   int i;
 175
 176   for (i = 0; demuxer_list[i]; i++)
 177     if (file_format == demuxer_list[i]->type)
 178       return demuxer_list[i];
 179
 180   return NULL;
 181 }
 182
 183
 184 demuxer_t* new_demuxer(stream_t *stream,int type,int a_id,int v_id,int s_id,char *filename){
 185   demuxer_t *d=malloc(sizeof(demuxer_t));
 186   memset(d,0,sizeof(demuxer_t));
 187   d->stream=stream;
 188   d->stream_pts = MP_NOPTS_VALUE;
 189   d->movi_start=stream->start_pos;
 190   d->movi_end=stream->end_pos;
 191   d->seekable=1;
 192   d->synced=0;
 193   d->filepos=0;
 194   d->audio=new_demuxer_stream(d,a_id);
 195   d->video=new_demuxer_stream(d,v_id);
 196   d->sub=new_demuxer_stream(d,s_id);
 197   d->type=type;
 198   if(type)
 199     if (!(d->desc = get_demuxer_desc_from_type(type)))
 200       mp_msg(MSGT_DEMUXER,MSGL_ERR,"BUG! Invalid demuxer type in new_demuxer(), big troubles ahead.");
 201   if(filename) // Filename hack for avs_check_file
 202     d->filename=strdup(filename);
 203   stream_reset(stream);
 204   stream_seek(stream,stream->start_pos);
 205   return d;
 206 }
 207
 208 sh_sub_t *new_sh_sub_sid(demuxer_t *demuxer, int id, int sid) {
 209   if (id > MAX_S_STREAMS - 1 || id < 0) {
 210     mp_msg(MSGT_DEMUXER,MSGL_WARN,"Requested sub stream id overflow (%d > %d)\n",
 211            id, MAX_S_STREAMS);
 212     return NULL;
 213   }
 214   if (demuxer->s_streams[id])
 215     mp_msg(MSGT_DEMUXER, MSGL_WARN, "Sub stream %i redefined\n", id);
 216   else {
 217     sh_sub_t *sh = calloc(1, sizeof(sh_sub_t));
 218     demuxer->s_streams[id] = sh;
 219     sh->sid = sid;
 220     mp_msg(MSGT_IDENTIFY, MSGL_INFO, "ID_SUBTITLE_ID=%d\n", sid);
 221   }
 222   return demuxer->s_streams[id];
 223 }
 224
 225 sh_audio_t* new_sh_audio_aid(demuxer_t *demuxer,int id,int aid){
 226     if(id > MAX_A_STREAMS-1 || id < 0)
 227     {
 228         mp_msg(MSGT_DEMUXER,MSGL_WARN,"Requested audio stream id overflow (%d > %d)\n",
 229             id, MAX_A_STREAMS);
 230         return NULL;
 231     }
 232     if(demuxer->a_streams[id]){
 233         mp_msg(MSGT_DEMUXER,MSGL_WARN,MSGTR_AudioStreamRedefined,id);
 234     } else {
 235         sh_audio_t *sh;
 236         mp_msg(MSGT_DEMUXER,MSGL_V,MSGTR_FoundAudioStream,id);
 237         demuxer->a_streams[id]=calloc(1, sizeof(sh_audio_t));
 238         sh = demuxer->a_streams[id];
 239         // set some defaults
 240         sh->samplesize=2;
 241         sh->sample_format=AF_FORMAT_S16_NE;
 242         sh->audio_out_minsize=8192;/* default size, maybe not enough for Win32/ACM*/
 243         sh->pts=MP_NOPTS_VALUE;
 244           mp_msg(MSGT_IDENTIFY, MSGL_INFO, "ID_AUDIO_ID=%d\n", aid);
 245     }
 246     ((sh_audio_t *)demuxer->a_streams[id])->aid = aid;
 247     return demuxer->a_streams[id];
 248 }
 249
 250 void free_sh_audio(demuxer_t *demuxer, int id) {
 251     sh_audio_t *sh = demuxer->a_streams[id];
 252     demuxer->a_streams[id] = NULL;
 253     mp_msg(MSGT_DEMUXER,MSGL_DBG2,"DEMUXER: freeing sh_audio at %p\n",sh);
 254     if(sh->wf) free(sh->wf);
 255     free(sh);
 256 }
 257
 258 sh_video_t* new_sh_video_vid(demuxer_t *demuxer,int id,int vid){
 259     if(id > MAX_V_STREAMS-1 || id < 0)
 260     {
 261         mp_msg(MSGT_DEMUXER,MSGL_WARN,"Requested video stream id overflow (%d > %d)\n",
 262             id, MAX_V_STREAMS);
 263         return NULL;
 264     }
 265     if(demuxer->v_streams[id]){
 266         mp_msg(MSGT_DEMUXER,MSGL_WARN,MSGTR_VideoStreamRedefined,id);
 267     } else {
 268         mp_msg(MSGT_DEMUXER,MSGL_V,MSGTR_FoundVideoStream,id);
 269         demuxer->v_streams[id]=calloc(1, sizeof(sh_video_t));
 270           mp_msg(MSGT_IDENTIFY, MSGL_INFO, "ID_VIDEO_ID=%d\n", vid);
 271     }
 272     ((sh_video_t *)demuxer->v_streams[id])->vid = vid;
 273     return demuxer->v_streams[id];
 274 }
 275
 276 void free_sh_video(sh_video_t* sh){
 277     mp_msg(MSGT_DEMUXER,MSGL_DBG2,"DEMUXER: freeing sh_video at %p\n",sh);
 278     if(sh->bih) free(sh->bih);
 279     free(sh);
 280 }
 281
 282 void free_demuxer(demuxer_t *demuxer){
 283     int i;
 284     mp_msg(MSGT_DEMUXER,MSGL_DBG2,"DEMUXER: freeing demuxer at %p\n",demuxer);
 285     if(demuxer->desc->close)
 286       demuxer->desc->close(demuxer);
 287     // Very ugly hack to make it behave like old implementation
 288     if (demuxer->desc->type == DEMUXER_TYPE_DEMUXERS)
 289       goto skip_streamfree;
 290     // free streams:
 291     for(i = 0; i < MAX_A_STREAMS; i++)
 292         if(demuxer->a_streams[i]) free_sh_audio(demuxer, i);
 293     for(i = 0; i < MAX_V_STREAMS; i++)
 294         if(demuxer->v_streams[i]) free_sh_video(demuxer->v_streams[i]);
 295     // free demuxers:
 296     free_demuxer_stream(demuxer->audio);
 297     free_demuxer_stream(demuxer->video);
 298     free_demuxer_stream(demuxer->sub);
 299 skip_streamfree:
 300     if(demuxer->info) {
 301       for(i=0;demuxer->info[i] != NULL; i++)
 302         free(demuxer->info[i]);
 303       free(demuxer->info);
 304     }
 305     if(demuxer->filename)
 306       free(demuxer->filename);
 307     if (demuxer->chapters) {
 308       for (i=0; i<demuxer->num_chapters; i++)
 309         if (demuxer->chapters[i].name)
 310           free(demuxer->chapters[i].name);
 311       free(demuxer->chapters);
 312     }
 313     free(demuxer);
 314 }
 315
 316
 317 void ds_add_packet(demux_stream_t *ds,demux_packet_t* dp){
 318 //    demux_packet_t* dp=new_demux_packet(len);
 319 //    stream_read(stream,dp->buffer,len);
 320 //    dp->pts=pts; //(float)pts/90000.0f;
 321 //    dp->pos=pos;
 322     // append packet to DS stream:
 323     ++ds->packs;
 324     ds->bytes+=dp->len;
 325     if(ds->last){
 326       // next packet in stream
 327       ds->last->next=dp;
 328       ds->last=dp;
 329     } else {
 330       // first packet in stream
 331       ds->first=ds->last=dp;
 332     }
 333     mp_dbg(MSGT_DEMUXER,MSGL_DBG2,"DEMUX: Append packet to %s, len=%d  pts=%5.3f  pos=%u  [packs: A=%d V=%d]\n",
 334         (ds==ds->demuxer->audio)?"d_audio":"d_video",
 335         dp->len,dp->pts,(unsigned int)dp->pos,ds->demuxer->audio->packs,ds->demuxer->video->packs);
 336 }
 337
 338 void ds_read_packet(demux_stream_t *ds, stream_t *stream, int len, double pts, off_t pos, int flags) {
 339     demux_packet_t* dp=new_demux_packet(len);
 340     len = stream_read(stream,dp->buffer,len);
 341     resize_demux_packet(dp, len);
 342     dp->pts=pts; //(float)pts/90000.0f;
 343     dp->pos=pos;
 344     dp->flags=flags;
 345     // append packet to DS stream:
 346     ds_add_packet(ds,dp);
 347 }
 348
 349 // return value:
 350 //     0 = EOF or no stream found or invalid type
 351 //     1 = successfully read a packet
 352
 353 int demux_fill_buffer(demuxer_t *demux,demux_stream_t *ds){
 354   // Note: parameter 'ds' can be NULL!
 355 //  printf("demux->type=%d\n",demux->type);
 356   return demux->desc->fill_buffer(demux, ds);
 357 }
 358
 359 // return value:
 360 //     0 = EOF
 361 //     1 = succesfull
 362 int ds_fill_buffer(demux_stream_t *ds){
 363   demuxer_t *demux=ds->demuxer;
 364   if(ds->current) free_demux_packet(ds->current);
 365   if( mp_msg_test(MSGT_DEMUXER,MSGL_DBG3) ){
 366     if(ds==demux->audio) mp_dbg(MSGT_DEMUXER,MSGL_DBG3,"ds_fill_buffer(d_audio) called\n");else
 367     if(ds==demux->video) mp_dbg(MSGT_DEMUXER,MSGL_DBG3,"ds_fill_buffer(d_video) called\n");else
 368     if(ds==demux->sub)   mp_dbg(MSGT_DEMUXER,MSGL_DBG3,"ds_fill_buffer(d_sub) called\n");else
 369                          mp_dbg(MSGT_DEMUXER,MSGL_DBG3,"ds_fill_buffer(unknown 0x%X) called\n",(unsigned int)ds);
 370   }
 371   while(1){
 372     if(ds->packs){
 373       demux_packet_t *p=ds->first;
 374       // copy useful data:
 375       ds->buffer=p->buffer;
 376       ds->buffer_pos=0;
 377       ds->buffer_size=p->len;
 378       ds->pos=p->pos;
 379       ds->dpos+=p->len; // !!!
 380       ++ds->pack_no;
 381       if (p->pts != (correct_pts ? MP_NOPTS_VALUE : 0)) {
 382         ds->pts=p->pts;
 383         ds->pts_bytes=0;
 384       }
 385       ds->pts_bytes+=p->len; // !!!
 386       if(p->stream_pts != MP_NOPTS_VALUE) demux->stream_pts=p->stream_pts;
 387       ds->flags=p->flags;
 388       // unlink packet:
 389       ds->bytes-=p->len;
 390       ds->current=p;
 391       ds->first=p->next;
 392       if(!ds->first) ds->last=NULL;
 393       --ds->packs;
 394       return 1; //ds->buffer_size;
 395     }
 396     if(demux->audio->packs>=MAX_PACKS || demux->audio->bytes>=MAX_PACK_BYTES){
 397       mp_msg(MSGT_DEMUXER,MSGL_ERR,MSGTR_TooManyAudioInBuffer,demux->audio->packs,demux->audio->bytes);
 398       mp_msg(MSGT_DEMUXER,MSGL_HINT,MSGTR_MaybeNI);
 399       break;
 400     }
 401     if(demux->video->packs>=MAX_PACKS || demux->video->bytes>=MAX_PACK_BYTES){
 402       mp_msg(MSGT_DEMUXER,MSGL_ERR,MSGTR_TooManyVideoInBuffer,demux->video->packs,demux->video->bytes);
 403       mp_msg(MSGT_DEMUXER,MSGL_HINT,MSGTR_MaybeNI);
 404       break;
 405     }
 406     if(!demux_fill_buffer(demux,ds)){
 407        mp_dbg(MSGT_DEMUXER,MSGL_DBG2,"ds_fill_buffer()->demux_fill_buffer() failed\n");
 408        break; // EOF
 409     }
 410   }
 411   ds->buffer_pos=ds->buffer_size=0;
 412   ds->buffer=NULL;
 413   ds->current=NULL;
 414   mp_msg(MSGT_DEMUXER,MSGL_V,"ds_fill_buffer: EOF reached (stream: %s)  \n",ds==demux->audio?"audio":"video");
 415   ds->eof=1;
 416   return 0;
 417 }
 418
 419 int demux_read_data(demux_stream_t *ds,unsigned char* mem,int len){
 420 int x;
 421 int bytes=0;
 422 while(len>0){
 423   x=ds->buffer_size-ds->buffer_pos;
 424   if(x==0){
 425     if(!ds_fill_buffer(ds)) return bytes;
 426   } else {
 427     if(x>len) x=len;
 428     if(mem) memcpy(mem+bytes,&ds->buffer[ds->buffer_pos],x);
 429     bytes+=x;len-=x;ds->buffer_pos+=x;
 430   }
 431 }
 432 return bytes;
 433 }
 434
 435 int demux_read_data_pack(demux_stream_t *ds,unsigned char* mem,int len){
 436 int x;
 437 int bytes=0;
 438 while(len>0){
 439   x=ds->buffer_size-ds->buffer_pos;
 440   if(x==0){
 441     if(!ds_fill_buffer(ds)) return bytes;
 442   } else {
 443     if(x>len) x=len;
 444     if(mem) memcpy(mem+bytes,&ds->buffer[ds->buffer_pos],x);
 445     bytes+=x;len-=x;ds->buffer_pos+=x;
 446     return bytes; // stop at end of package! (for correct timestamping)
 447   }
 448 }
 449 return bytes;
 450 }
 451
 452 /**
 453  * \brief read data until the given 3-byte pattern is encountered, up to maxlen
 454  * \param mem memory to read data into, may be NULL to discard data
 455  * \param maxlen maximum number of bytes to read
 456  * \param read number of bytes actually read
 457  * \param pattern pattern to search for (lowest 8 bits are ignored)
 458  * \return whether pattern was found
 459  */
 460 int demux_pattern_3(demux_stream_t *ds, unsigned char *mem, int maxlen,
 461                     int *read, uint32_t pattern) {
 462   register uint32_t head = 0xffffff00;
 463   register uint32_t pat = pattern & 0xffffff00;
 464   int total_len = 0;
 465   do {
 466     register unsigned char *ds_buf = &ds->buffer[ds->buffer_size];
 467     int len = ds->buffer_size - ds->buffer_pos;
 468     register long pos = -len;
 469     if (unlikely(pos >= 0)) { // buffer is empty
 470       ds_fill_buffer(ds);
 471       continue;
 472     }
 473     do {
 474       head |= ds_buf[pos];
 475       head <<= 8;
 476     } while (++pos && head != pat);
 477     len += pos;
 478     if (total_len + len > maxlen)
 479       len = maxlen - total_len;
 480     len = demux_read_data(ds, mem ? &mem[total_len] : NULL, len);
 481     total_len += len;
 482   } while ((head != pat || total_len < 3) && total_len < maxlen && !ds->eof);
 483   if (read)
 484     *read = total_len;
 485   return total_len >= 3 && head == pat;
 486 }
 487
 488 void ds_free_packs(demux_stream_t *ds){
 489   demux_packet_t *dp=ds->first;
 490   while(dp){
 491     demux_packet_t *dn=dp->next;
 492     free_demux_packet(dp);
 493     dp=dn;
 494   }
 495   if(ds->asf_packet){
 496     // free unfinished .asf fragments:
 497     free(ds->asf_packet->buffer);
 498     free(ds->asf_packet);
 499     ds->asf_packet=NULL;
 500   }
 501   ds->first=ds->last=NULL;
 502   ds->packs=0; // !!!!!
 503   ds->bytes=0;
 504   if(ds->current) free_demux_packet(ds->current);
 505   ds->current=NULL;
 506   ds->buffer=NULL;
 507   ds->buffer_pos=ds->buffer_size;
 508   ds->pts=0; ds->pts_bytes=0;
 509 }
 510
 511 int ds_get_packet(demux_stream_t *ds,unsigned char **start){
 512     while(1){
 513         int len;
 514         if(ds->buffer_pos>=ds->buffer_size){
 515           if(!ds_fill_buffer(ds)){
 516             // EOF
 517             *start = NULL;
 518             return -1;
 519           }
 520         }
 521         len=ds->buffer_size-ds->buffer_pos;
 522         *start = &ds->buffer[ds->buffer_pos];
 523         ds->buffer_pos+=len;
 524         return len;
 525     }
 526 }
 527
 528 int ds_get_packet_pts(demux_stream_t *ds,unsigned char **start, double *pts)
 529 {
 530     int len;
 531     *pts = MP_NOPTS_VALUE;
 532     if(ds->buffer_pos>=ds->buffer_size){
 533         if (!ds_fill_buffer(ds)) {
 534             // EOF
 535             *start = NULL;
 536             return -1;
 537         }
 538     }
 539     // Should use MP_NOPTS_VALUE for "unknown pts" in the packets too
 540     // Return pts unless this read starts from the middle of a packet
 541     if (!ds->buffer_pos && (correct_pts || ds->current->pts))
 542         *pts = ds->current->pts;
 543     len=ds->buffer_size-ds->buffer_pos;
 544     *start = &ds->buffer[ds->buffer_pos];
 545     ds->buffer_pos+=len;
 546     return len;
 547 }
 548
 549 int ds_get_packet_sub(demux_stream_t *ds,unsigned char **start){
 550     while(1){
 551         int len;
 552         if(ds->buffer_pos>=ds->buffer_size){
 553           *start = NULL;
 554           if(!ds->packs) return -1; // no sub
 555           if(!ds_fill_buffer(ds)) return -1; // EOF
 556         }
 557         len=ds->buffer_size-ds->buffer_pos;
 558         *start = &ds->buffer[ds->buffer_pos];
 559         ds->buffer_pos+=len;
 560         return len;
 561     }
 562 }
 563
 564 double ds_get_next_pts(demux_stream_t *ds)
 565 {
 566   demuxer_t* demux = ds->demuxer;
 567   while(!ds->first) {
 568     if(demux->audio->packs>=MAX_PACKS || demux->audio->bytes>=MAX_PACK_BYTES){
 569       mp_msg(MSGT_DEMUXER,MSGL_ERR,MSGTR_TooManyAudioInBuffer,demux->audio->packs,demux->audio->bytes);
 570       mp_msg(MSGT_DEMUXER,MSGL_HINT,MSGTR_MaybeNI);
 571       return MP_NOPTS_VALUE;
 572     }
 573     if(demux->video->packs>=MAX_PACKS || demux->video->bytes>=MAX_PACK_BYTES){
 574       mp_msg(MSGT_DEMUXER,MSGL_ERR,MSGTR_TooManyVideoInBuffer,demux->video->packs,demux->video->bytes);
 575       mp_msg(MSGT_DEMUXER,MSGL_HINT,MSGTR_MaybeNI);
 576       return MP_NOPTS_VALUE;
 577     }
 578     if(!demux_fill_buffer(demux,ds))
 579       return MP_NOPTS_VALUE;
 580   }
 581   return ds->first->pts;
 582 }
 583
 584 // ====================================================================
 585
 586 // commandline options, flags:
 587 extern int force_ni;
 588 extern int pts_from_bps;
 589
 590 //extern int audio_id;
 591 //extern int video_id;
 592 //extern int dvdsub_id;
 593
 594 void demuxer_help(void)
 595 {
 596   int i;
 597
 598   mp_msg(MSGT_DEMUXER, MSGL_INFO, "Available demuxers:\n");
 599   mp_msg(MSGT_DEMUXER, MSGL_INFO, " demuxer:  type  info:  (comment)\n");
 600   mp_msg(MSGT_IDENTIFY, MSGL_INFO, "ID_DEMUXERS\n");
 601   for (i = 0; demuxer_list[i]; i++) {
 602     if (demuxer_list[i]->type > DEMUXER_TYPE_MAX) // Don't display special demuxers
 603       continue;
 604     if (demuxer_list[i]->comment && strlen(demuxer_list[i]->comment))
 605       mp_msg(MSGT_DEMUXER, MSGL_INFO, "%10s  %2d   %s (%s)\n",
 606              demuxer_list[i]->name, demuxer_list[i]->type, demuxer_list[i]->info, demuxer_list[i]->comment);
 607     else
 608       mp_msg(MSGT_DEMUXER, MSGL_INFO, "%10s  %2d   %s\n",
 609              demuxer_list[i]->name, demuxer_list[i]->type, demuxer_list[i]->info);
 610   }
 611 }
 612
 613
 614 /**
 615  * Get demuxer type for a given demuxer name
 616  *
 617  * @param demuxer_name    string with demuxer name of demuxer number
 618  * @param force           will be set if demuxer should be forced.
 619  *                        May be NULL.
 620  * @return                DEMUXER_TYPE_xxx, -1 if error or not found
 621  */
 622 int get_demuxer_type_from_name(char *demuxer_name, int *force)
 623 {
 624   int i;
 625   long type_int;
 626   char *endptr;
 627
 628   if (!demuxer_name || !demuxer_name[0])
 629     return DEMUXER_TYPE_UNKNOWN;
 630   if (force) *force = demuxer_name[0] == '+';
 631   if (demuxer_name[0] == '+')
 632     demuxer_name = &demuxer_name[1];
 633   for (i = 0; demuxer_list[i]; i++) {
 634     if (demuxer_list[i]->type > DEMUXER_TYPE_MAX) // Can't select special demuxers from commandline
 635       continue;
 636     if (strcmp(demuxer_name, demuxer_list[i]->name) == 0)
 637       return  demuxer_list[i]->type;
 638   }
 639
 640   // No match found, try to parse name as an integer (demuxer number)
 641   type_int = strtol(demuxer_name, &endptr, 0);
 642   if (*endptr) // Conversion failed
 643     return -1;
 644   if ((type_int > 0) && (type_int <= DEMUXER_TYPE_MAX))
 645     return (int)type_int;
 646
 647   return -1;
 648 }
 649
 650 int extension_parsing=1; // 0=off 1=mixed (used only for unstable formats)
 651
 652 int correct_pts=0;
 653
 654 /*
 655   NOTE : Several demuxers may be opened at the same time so
 656   demuxers should NEVER rely on an external var to enable them
 657   self. If a demuxer can't do any autodection it should only use
 658   file_format. The user can explictly set file_format with the -demuxer
 659   option so there is really no need for another extra var.
 660   For conivence an option can be added to set file_format directly
 661   to the right type (ex: rawaudio,rawvideo).
 662   Also the stream can override the file_format so a demuxer wich rely
 663   on a special stream type can set file_format at the stream level
 664   (ex: tv,mf).
 665 */
 666
 667 static demuxer_t* demux_open_stream(stream_t *stream, int file_format,
 668                     int force, int audio_id, int video_id, int dvdsub_id,
 669                     char* filename) {
 670
 671 //int file_format=(*file_format_ptr);
 672
 673 demuxer_t *demuxer=NULL;
 674
 675 sh_video_t *sh_video=NULL;
 676
 677 demuxer_desc_t *demuxer_desc;
 678 int fformat;
 679 int i;
 680
 681 //printf("demux_open(%p,%d,%d,%d,%d)  \n",stream,file_format,audio_id,video_id,dvdsub_id);
 682
 683 // If somebody requested a demuxer check it
 684 if (file_format) {
 685   if ((demuxer_desc = get_demuxer_desc_from_type(file_format))) {
 686     demuxer = new_demuxer(stream,demuxer_desc->type,audio_id,video_id,dvdsub_id,filename);
 687     if (demuxer_desc->check_file)
 688       fformat = demuxer_desc->check_file(demuxer);
 689     if (force || !demuxer_desc->check_file)
 690       fformat = demuxer_desc->type;
 691     if (fformat != 0) {
 692       if (fformat == demuxer_desc->type) {
 693         demuxer_t *demux2 = demuxer;
 694         // Move messages to demuxer detection code?
 695         mp_msg(MSGT_DEMUXER, MSGL_INFO, MSGTR_Detected_XXX_FileFormat, demuxer_desc->shortdesc);
 696         file_format = demuxer_desc->type = fformat;
 697         if (!demuxer->desc->open || (demux2 = demuxer->desc->open(demuxer))) {
 698           demuxer = demux2;
 699           goto dmx_open;
 700         }
 701       } else {
 702         // Format changed after check, recurse
 703         free_demuxer(demuxer);
 704         return demux_open_stream(stream, fformat, force,
 705                  audio_id, video_id, dvdsub_id, filename);
 706       }
 707     }
 708     // Check failed for forced demuxer, quit
 709     free_demuxer(demuxer);
 710     return NULL;
 711   }
 712 }
 713
 714 // Test demuxers with safe file checks
 715 for (i = 0; (demuxer_desc = demuxer_list[i]); i++) {
 716   if (demuxer_desc->safe_check) {
 717     demuxer = new_demuxer(stream,demuxer_desc->type,audio_id,video_id,dvdsub_id,filename);
 718     if ((fformat = demuxer_desc->check_file(demuxer)) != 0) {
 719       if (fformat == demuxer_desc->type) {
 720         demuxer_t *demux2 = demuxer;
 721         mp_msg(MSGT_DEMUXER, MSGL_INFO, MSGTR_Detected_XXX_FileFormat, demuxer_desc->shortdesc);
 722         file_format = fformat;
 723         if (!demuxer->desc->open || (demux2 = demuxer->desc->open(demuxer))) {
 724           demuxer = demux2;
 725           goto dmx_open;
 726         }
 727       } else {
 728         if (fformat == DEMUXER_TYPE_PLAYLIST)
 729           return demuxer; // handled in mplayer.c
 730         // Format changed after check, recurse
 731         free_demuxer(demuxer);
 732         demuxer=demux_open_stream(stream, fformat, force,
 733                   audio_id, video_id, dvdsub_id, filename);
 734         if(demuxer) return demuxer; // done!
 735         file_format = DEMUXER_TYPE_UNKNOWN;
 736       }
 737     }
 738     free_demuxer(demuxer);
 739     demuxer = NULL;
 740   }
 741 }
 742
 743 // If no forced demuxer perform file extension based detection
 744 // Ok. We're over the stable detectable fileformats, the next ones are a bit
 745 // fuzzy. So by default (extension_parsing==1) try extension-based detection
 746 // first:
 747 if(file_format==DEMUXER_TYPE_UNKNOWN && filename && extension_parsing==1){
 748   file_format=demuxer_type_by_filename(filename);
 749   if(file_format!=DEMUXER_TYPE_UNKNOWN){
 750     // we like recursion :)
 751     demuxer=demux_open_stream(stream, file_format, force,
 752               audio_id, video_id, dvdsub_id, filename);
 753     if(demuxer) return demuxer; // done!
 754     file_format=DEMUXER_TYPE_UNKNOWN; // continue fuzzy guessing...
 755     mp_msg(MSGT_DEMUXER,MSGL_V,"demuxer: continue fuzzy content-based format guessing...\n");
 756   }
 757 }
 758
 759 // Try detection for all other demuxers
 760 for (i = 0; (demuxer_desc = demuxer_list[i]); i++) {
 761   if (!demuxer_desc->safe_check && demuxer_desc->check_file) {
 762     demuxer = new_demuxer(stream,demuxer_desc->type,audio_id,video_id,dvdsub_id,filename);
 763     if ((fformat = demuxer_desc->check_file(demuxer)) != 0) {
 764       if (fformat == demuxer_desc->type) {
 765         demuxer_t *demux2 = demuxer;
 766         mp_msg(MSGT_DEMUXER, MSGL_INFO, MSGTR_Detected_XXX_FileFormat, demuxer_desc->shortdesc);
 767         file_format = fformat;
 768         if (!demuxer->desc->open || (demux2 = demuxer->desc->open(demuxer))) {
 769           demuxer = demux2;
 770           goto dmx_open;
 771         }
 772       } else {
 773         if (fformat == DEMUXER_TYPE_PLAYLIST)
 774           return demuxer; // handled in mplayer.c
 775         // Format changed after check, recurse
 776         free_demuxer(demuxer);
 777         demuxer=demux_open_stream(stream, fformat, force,
 778                   audio_id, video_id, dvdsub_id, filename);
 779         if(demuxer) return demuxer; // done!
 780         file_format = DEMUXER_TYPE_UNKNOWN;
 781       }
 782     }
 783     free_demuxer(demuxer);
 784     demuxer = NULL;
 785   }
 786 }
 787
 788 return NULL;
 789 //====== File format recognized, set up these for compatibility: =========
 790 dmx_open:
 791
 792 demuxer->file_format=file_format;
 793
 794 if ((sh_video=demuxer->video->sh) && sh_video->bih){
 795 int biComp=le2me_32(sh_video->bih->biCompression);
 796   mp_msg(MSGT_DEMUX,MSGL_INFO,"VIDEO:  [%.4s]  %dx%d  %dbpp  %5.3f fps  %5.1f kbps (%4.1f kbyte/s)\n",
 797     (char *)&biComp,
 798     sh_video->bih->biWidth,
 799     sh_video->bih->biHeight,
 800     sh_video->bih->biBitCount,
 801     sh_video->fps,
 802     sh_video->i_bps*0.008f,
 803     sh_video->i_bps/1024.0f );
 804 }
 805 return demuxer;
 806 }
 807
 808 char* audio_stream = NULL;
 809 char* sub_stream = NULL;
 810 int demuxer_type = 0; // used by rawaudio and rawvideo
 811 int audio_stream_cache = 0;
 812
 813 char *demuxer_name = NULL; // parameter from -demuxer
 814 char *audio_demuxer_name = NULL; // parameter from -audio-demuxer
 815 char *sub_demuxer_name = NULL; // parameter from -sub-demuxer
 816
 817 extern int hr_mp3_seek;
 818
 819 extern float stream_cache_min_percent;
 820 extern float stream_cache_seek_min_percent;
 821
 822 demuxer_t* demux_open(stream_t *vs,int file_format,int audio_id,int video_id,int dvdsub_id,char* filename){
 823   stream_t *as = NULL,*ss = NULL;
 824   demuxer_t *vd,*ad = NULL,*sd = NULL;
 825   int afmt =DEMUXER_TYPE_UNKNOWN,sfmt = DEMUXER_TYPE_UNKNOWN ;
 826   int audio_demuxer_type = 0, sub_demuxer_type = 0;
 827   int demuxer_force = 0, audio_demuxer_force = 0,
 828       sub_demuxer_force = 0;
 829
 830   if ((demuxer_type = get_demuxer_type_from_name(demuxer_name, &demuxer_force)) < 0) {
 831     mp_msg(MSGT_DEMUXER,MSGL_ERR,"-demuxer %s does not exist.\n",demuxer_name);
 832   }
 833   if ((audio_demuxer_type = get_demuxer_type_from_name(audio_demuxer_name, &audio_demuxer_force)) < 0) {
 834     mp_msg(MSGT_DEMUXER,MSGL_ERR,"-audio-demuxer %s does not exist.\n",audio_demuxer_name);
 835   }
 836   if ((sub_demuxer_type = get_demuxer_type_from_name(sub_demuxer_name, &sub_demuxer_force)) < 0) {
 837     mp_msg(MSGT_DEMUXER,MSGL_ERR,"-sub-demuxer %s does not exist.\n",sub_demuxer_name);
 838   }
 839
 840   if(audio_stream) {
 841     as = open_stream(audio_stream,0,&afmt);
 842     if(!as) {
 843       mp_msg(MSGT_DEMUXER,MSGL_ERR,MSGTR_CannotOpenAudioStream,audio_stream);
 844       return NULL;
 845     }
 846     if(audio_stream_cache) {
 847       if(!stream_enable_cache(as,audio_stream_cache*1024,audio_stream_cache*1024*(stream_cache_min_percent / 100.0),
 848                               audio_stream_cache*1024*(stream_cache_seek_min_percent / 100.0))) {
 849         free_stream(as);
 850         mp_msg(MSGT_DEMUXER,MSGL_ERR,"Can't enable audio stream cache\n");
 851         return NULL;
 852       }
 853     }
 854   }
 855   if(sub_stream) {
 856     ss = open_stream(sub_stream,0,&sfmt);
 857     if(!ss) {
 858       mp_msg(MSGT_DEMUXER,MSGL_ERR,MSGTR_CannotOpenSubtitlesStream,sub_stream);
 859       return NULL;
 860     }
 861   }
 862
 863   vd = demux_open_stream(vs, demuxer_type ? demuxer_type : file_format,
 864          demuxer_force, audio_stream ? -2 : audio_id, video_id,
 865          sub_stream ? -2 : dvdsub_id, filename);
 866   if(!vd) {
 867     if(as) free_stream(as);
 868     if(ss) free_stream(ss);
 869     return NULL;
 870   }
 871   if(as) {
 872     ad = demux_open_stream(as, audio_demuxer_type ? audio_demuxer_type : afmt,
 873            audio_demuxer_force, audio_id, -2, -2, audio_stream);
 874     if(!ad) {
 875       mp_msg(MSGT_DEMUXER,MSGL_WARN,MSGTR_OpeningAudioDemuxerFailed,audio_stream);
 876       free_stream(as);
 877     }
 878     else if(ad->audio->sh && ((sh_audio_t*)ad->audio->sh)->format == 0x55) // MP3
 879       hr_mp3_seek=1; // Enable high res seeking
 880   }
 881   if(ss) {
 882     sd = demux_open_stream(ss, sub_demuxer_type ? sub_demuxer_type : sfmt,
 883            sub_demuxer_force, -2, -2, dvdsub_id, sub_stream);
 884     if(!sd) {
 885       mp_msg(MSGT_DEMUXER,MSGL_WARN,MSGTR_OpeningSubtitlesDemuxerFailed,sub_stream);
 886       free_stream(ss);
 887     }
 888   }
 889
 890   if(ad && sd)
 891     return new_demuxers_demuxer(vd,ad,sd);
 892   else if(ad)
 893     return new_demuxers_demuxer(vd,ad,vd);
 894   else if(sd)
 895     return new_demuxers_demuxer(vd,vd,sd);
 896   else
 897     return vd;
 898 }
 899
 900
 901 int demux_seek(demuxer_t *demuxer,float rel_seek_secs,float audio_delay,int flags){
 902     demux_stream_t *d_audio=demuxer->audio;
 903     demux_stream_t *d_video=demuxer->video;
 904     sh_audio_t *sh_audio=d_audio->sh;
 905     sh_video_t *sh_video=d_video->sh;
 906     double tmp = 0;
 907     double pts;
 908
 909 if(!demuxer->seekable){
 910     if(demuxer->file_format==DEMUXER_TYPE_AVI)
 911         mp_msg(MSGT_SEEK,MSGL_WARN,MSGTR_CantSeekRawAVI);
 912 #ifdef USE_TV
 913     else if (demuxer->file_format==DEMUXER_TYPE_TV)
 914         mp_msg(MSGT_SEEK,MSGL_WARN,MSGTR_TVInputNotSeekable);
 915 #endif
 916     else
 917         mp_msg(MSGT_SEEK,MSGL_WARN,MSGTR_CantSeekFile);
 918     return 0;
 919 }
 920
 921     // clear demux buffers:
 922     if(sh_audio){ ds_free_packs(d_audio);sh_audio->a_buffer_len=0;}
 923     ds_free_packs(d_video);
 924
 925     demuxer->stream->eof=0; // clear eof flag
 926     demuxer->video->eof=0;
 927     demuxer->audio->eof=0;
 928
 929 #if 0
 930     if(sh_audio) sh_audio->timer=sh_video->timer;
 931 #else
 932     if(sh_audio) sh_audio->delay=0;
 933     if(sh_video) sh_video->timer=0; // !!!!!!
 934 #endif
 935
 936     if(flags & 1)  // absolute seek
 937       pts = 0.0f;
 938     else {
 939       if(demuxer->stream_pts == MP_NOPTS_VALUE)
 940         goto dmx_seek;
 941       pts = demuxer->stream_pts;
 942     }
 943
 944     if(flags & 2) {  // percent seek
 945       if(stream_control(demuxer->stream, STREAM_CTRL_GET_TIME_LENGTH, &tmp) == STREAM_UNSUPORTED)
 946         goto dmx_seek;
 947       pts += tmp * rel_seek_secs;
 948     } else
 949       pts += rel_seek_secs;
 950
 951     if(stream_control(demuxer->stream, STREAM_CTRL_SEEK_TO_TIME, &pts) != STREAM_UNSUPORTED) {
 952       demux_control(demuxer, DEMUXER_CTRL_RESYNC, NULL);
 953       return 1;
 954     }
 955
 956 dmx_seek:
 957 if (demuxer->desc->seek)
 958     demuxer->desc->seek(demuxer,rel_seek_secs,audio_delay,flags);
 959
 960     if (sh_audio) resync_audio_stream(sh_audio);
 961
 962 return 1;
 963 }
 964
 965 int demux_info_add(demuxer_t *demuxer, const char *opt, const char *param)
 966 {
 967     char **info = demuxer->info;
 968     int n = 0;
 969
 970
 971     for(n = 0; info && info[2*n] != NULL; n++)
 972       {
 973         if(!strcasecmp(opt,info[2*n]))
 974           {
 975             mp_msg(MSGT_DEMUX, MSGL_INFO,MSGTR_DemuxerInfoChanged,opt,param);
 976             free(info[2*n+1]);
 977             info[2*n+1] = strdup(param);
 978             return 0;
 979           }
 980       }
 981
 982     info = demuxer->info = (char**)realloc(info,(2*(n+2))*sizeof(char*));
 983     info[2*n] = strdup(opt);
 984     info[2*n+1] = strdup(param);
 985     memset(&info[2*(n+1)],0,2*sizeof(char*));
 986
 987     return 1;
 988 }
 989
 990 int demux_info_print(demuxer_t *demuxer)
 991 {
 992     char **info = demuxer->info;
 993     int n;
 994
 995     if(!info)
 996       return 0;
 997
 998     mp_msg(MSGT_DEMUX, MSGL_INFO,MSGTR_ClipInfo);
 999     for(n = 0; info[2*n] != NULL ; n++)
1000     {
1001       mp_msg(MSGT_DEMUX, MSGL_INFO, " %s: %s\n",info[2*n],info[2*n+1]);
1002       mp_msg(MSGT_IDENTIFY, MSGL_INFO, "ID_CLIP_INFO_NAME%d=%s\n", n, info[2*n]);
1003       mp_msg(MSGT_IDENTIFY, MSGL_INFO, "ID_CLIP_INFO_VALUE%d=%s\n", n, info[2*n+1]);
1004     }
1005     mp_msg(MSGT_IDENTIFY, MSGL_INFO, "ID_CLIP_INFO_N=%d\n", n);
1006
1007     return 0;
1008 }
1009
1010 char* demux_info_get(demuxer_t *demuxer, char *opt) {
1011   int i;
1012   char **info = demuxer->info;
1013
1014   for(i = 0; info && info[2*i] != NULL; i++) {
1015     if(!strcasecmp(opt,info[2*i]))
1016       return info[2*i+1];
1017   }
1018
1019   return NULL;
1020 }
1021
1022 int demux_control(demuxer_t *demuxer, int cmd, void *arg) {
1023
1024     if (demuxer->desc->control)
1025       return demuxer->desc->control(demuxer,cmd,arg);
1026
1027     return DEMUXER_CTRL_NOTIMPL;
1028 }
1029
1030
1031
1032 double demuxer_get_time_length(demuxer_t *demuxer){
1033     double get_time_ans;
1034     sh_video_t *sh_video = demuxer->video->sh;
1035     sh_audio_t *sh_audio = demuxer->audio->sh;
1036     // <= 0 means DEMUXER_CTRL_NOTIMPL or DEMUXER_CTRL_DONTKNOW
1037     if (demux_control(demuxer, DEMUXER_CTRL_GET_TIME_LENGTH,(void *)&get_time_ans)<=0)  {
1038       if (sh_video && sh_video->i_bps)
1039         get_time_ans = (double)(demuxer->movi_end-demuxer->movi_start)/sh_video->i_bps;
1040       else if (sh_audio && sh_audio->i_bps)
1041         get_time_ans = (double)(demuxer->movi_end-demuxer->movi_start)/sh_audio->i_bps;
1042       else
1043         get_time_ans=0;
1044     }
1045     return get_time_ans;
1046 }
1047
1048 /**
1049  * \brief demuxer_get_current_time() returns the time of the current play in three possible ways:
1050  *        either when the stream reader satisfies STREAM_CTRL_GET_CURRENT_TIME (e.g. dvd)
1051  *        or using sh_video->pts when the former method fails
1052  *        0 otherwise
1053  * \return the current play time
1054  */
1055 int demuxer_get_current_time(demuxer_t *demuxer){
1056     double get_time_ans = 0;
1057     sh_video_t *sh_video = demuxer->video->sh;
1058     if(demuxer->stream_pts != MP_NOPTS_VALUE)
1059         get_time_ans = demuxer->stream_pts;
1060     else if(sh_video) get_time_ans = sh_video->pts;
1061     return (int) get_time_ans;
1062 }
1063
1064 int demuxer_get_percent_pos(demuxer_t *demuxer){
1065     int ans = 0;
1066     int res = demux_control(demuxer, DEMUXER_CTRL_GET_PERCENT_POS, &ans);
1067     int len = (demuxer->movi_end - demuxer->movi_start) / 100;
1068     if (res <= 0) {
1069       if (len > 0)
1070       ans = (demuxer->filepos - demuxer->movi_start) / len;
1071       else
1072        ans = 0;
1073     }
1074     if (ans < 0) ans = 0;
1075     if (ans > 100) ans = 100;
1076     return ans;
1077 }
1078
1079 int demuxer_switch_audio(demuxer_t *demuxer, int index){
1080     int res = demux_control(demuxer, DEMUXER_CTRL_SWITCH_AUDIO, &index);
1081     if (res == DEMUXER_CTRL_NOTIMPL)
1082       index = demuxer->audio->id;
1083     return index;
1084 }
1085
1086 int demuxer_switch_video(demuxer_t *demuxer, int index){
1087     int res = demux_control(demuxer, DEMUXER_CTRL_SWITCH_VIDEO, &index);
1088     if (res == DEMUXER_CTRL_NOTIMPL)
1089       index = demuxer->video->id;
1090     return index;
1091 }
1092
1093 int demuxer_add_chapter(demuxer_t* demuxer, const char* name, uint64_t start, uint64_t end){
1094     if (demuxer->chapters == NULL)
1095         demuxer->chapters = malloc (32*sizeof(*demuxer->chapters));
1096     else if (!(demuxer->num_chapters % 32))
1097         demuxer->chapters = realloc (demuxer->chapters, (demuxer->num_chapters + 32) * sizeof(*demuxer->chapters));
1098
1099     demuxer->chapters[demuxer->num_chapters].start = start;
1100     demuxer->chapters[demuxer->num_chapters].end = end;
1101     demuxer->chapters[demuxer->num_chapters].name = strdup(name);
1102
1103     return demuxer->num_chapters ++;
1104 }
1105
1106 /**
1107  * \brief demuxer_seek_chapter() seeks to a chapter in two possible ways:
1108  *        either using the demuxer->chapters structure set by the demuxer
1109  *        or asking help to the stream layer (e.g. dvd)
1110  * \param chapter - chapter number wished - 0-based
1111  * \param mode 0: relative to current main pts, 1: absolute
1112  * \param seek_pts set by the function to the pts to seek to (if demuxer->chapters is set)
1113  * \param num_chapters number of chapters present (set by this function is param is not null)
1114  * \param chapter_name name of chapter found (set by this function is param is not null)
1115  * \return -1 on error, current chapter if successful
1116  */
1117
1118 int demuxer_seek_chapter(demuxer_t *demuxer, int chapter, int mode, float *seek_pts, int *num_chapters, char **chapter_name) {
1119     int ris;
1120     int current, total;
1121     sh_video_t *sh_video = demuxer->video->sh;
1122     sh_audio_t *sh_audio = demuxer->audio->sh;
1123
1124     if (!demuxer->num_chapters || !demuxer->chapters) {
1125         if(!mode) {
1126             ris = stream_control(demuxer->stream, STREAM_CTRL_GET_CURRENT_CHAPTER, &current);
1127             if(ris == STREAM_UNSUPORTED) return -1;
1128             chapter += current;
1129         }
1130
1131         if(demuxer->video->sh)
1132             ds_free_packs(demuxer->video);
1133
1134         if(demuxer->audio->sh)
1135             ds_free_packs(demuxer->audio);
1136
1137         if(demuxer->sub->id >= 0)
1138             ds_free_packs(demuxer->sub);
1139
1140         ris = stream_control(demuxer->stream, STREAM_CTRL_SEEK_TO_CHAPTER, &chapter);
1141         if(ris != STREAM_UNSUPORTED)
1142             demux_control(demuxer, DEMUXER_CTRL_RESYNC, NULL);
1143         if(sh_video) {
1144             ds_fill_buffer(demuxer->video);
1145             resync_video_stream(sh_video);
1146         }
1147
1148         if(sh_audio) {
1149             ds_fill_buffer(demuxer->audio);
1150             resync_audio_stream(sh_audio);
1151         }
1152
1153         //exit status may be ok, but main() doesn't have to seek itself (because e.g. dvds depend on sectors, not on pts)
1154         *seek_pts = -1.0;
1155
1156         if(num_chapters) {
1157             if(stream_control(demuxer->stream, STREAM_CTRL_GET_NUM_CHAPTERS, num_chapters) == STREAM_UNSUPORTED)
1158                 *num_chapters = 0;
1159         }
1160
1161         if(chapter_name) {
1162             char *tmp = malloc(16);
1163             *chapter_name = NULL;
1164             if(num_chapters  && *num_chapters && tmp) {
1165                 sprintf(tmp, " of %3d", *num_chapters);
1166                 *chapter_name = tmp;
1167             }
1168         }
1169
1170         return (ris != STREAM_UNSUPORTED ? chapter : -1);
1171     } else {  //chapters structure is set in the demuxer
1172         total = demuxer->num_chapters;
1173
1174         if (mode==1) {    //absolute seeking
1175             current = chapter;
1176         } else {         //relative seeking
1177             uint64_t now;
1178             now = (sh_video ? sh_video->pts : (sh_audio ? sh_audio->pts : 0.)) * 1000 + .5;
1179
1180             for (current = total - 1; current >= 0; --current) {
1181                 demux_chapter_t* chapter = demuxer->chapters + current;
1182                 if (chapter->start <= now)
1183                     break;
1184             }
1185             current += chapter;
1186         }
1187
1188         if (current >= total)
1189            return -1;
1190         if (current < 0) current = 0;
1191
1192         *seek_pts = demuxer->chapters[current].start / 1000.0;
1193
1194         if(num_chapters)
1195             *num_chapters = demuxer->num_chapters;
1196
1197         if(chapter_name) {
1198             if(demuxer->chapters[current].name)
1199                 *chapter_name = strdup(demuxer->chapters[current].name);
1200             else *chapter_name = NULL;
1201         }
1202
1203         return current;
1204     }
1205 }