← Back to branch summary

~ubuntu-dev/mplayer/ubuntu-feisty

« back to all changes in this revision

Viewing changes to libmpdemux/demuxer.c

  • Committer: Reinhard Tartler
  • Date: 2006-07-08 08:45:33 UTC
  • Revision ID: siretart@tauware.de-20060708084533-dbc155bde7122e78
imported mplayer_0.99+1.0pre7try2+cvs20060117

Show diffs side-by-side

added added

removed removed

Lines of Context:
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_audio_stream(sh_audio_t *sh_audio);
 
26
 
 
27
// Demuxer list
 
28
extern demuxer_desc_t demuxer_desc_rawaudio;
 
29
extern demuxer_desc_t demuxer_desc_rawvideo;
 
30
extern demuxer_desc_t demuxer_desc_tv;
 
31
extern demuxer_desc_t demuxer_desc_mf;
 
32
extern demuxer_desc_t demuxer_desc_avi;
 
33
extern demuxer_desc_t demuxer_desc_y4m;
 
34
extern demuxer_desc_t demuxer_desc_asf;
 
35
extern demuxer_desc_t demuxer_desc_nsv;
 
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_mpeg_ts;
 
52
extern demuxer_desc_t demuxer_desc_lmlm4;
 
53
extern demuxer_desc_t demuxer_desc_mpeg_ps;
 
54
extern demuxer_desc_t demuxer_desc_mpeg_pes;
 
55
extern demuxer_desc_t demuxer_desc_mpeg_es;
 
56
extern demuxer_desc_t demuxer_desc_mpeg_gxf;
 
57
extern demuxer_desc_t demuxer_desc_mpeg4_es;
 
58
extern demuxer_desc_t demuxer_desc_h264_es;
 
59
extern demuxer_desc_t demuxer_desc_rawdv;
 
60
extern demuxer_desc_t demuxer_desc_mpc;
 
61
extern demuxer_desc_t demuxer_desc_audio;
 
62
extern demuxer_desc_t demuxer_desc_xmms;
 
63
extern demuxer_desc_t demuxer_desc_mpeg_ty;
 
64
extern demuxer_desc_t demuxer_desc_rtp;
 
65
#if defined(USE_LIBAVFORMAT) ||  defined(USE_LIBAVFORMAT_SO)
 
66
extern demuxer_desc_t demuxer_desc_lavf;
 
67
#endif
 
68
extern demuxer_desc_t demuxer_desc_aac;
 
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
#ifdef HAVE_MATROSKA
 
85
  &demuxer_desc_matroska,
 
86
#endif
 
87
  &demuxer_desc_realaudio,
 
88
  &demuxer_desc_vqf,
 
89
  &demuxer_desc_mov,
 
90
  &demuxer_desc_vivo,
 
91
  &demuxer_desc_fli,
 
92
  &demuxer_desc_film,
 
93
  &demuxer_desc_roq,
 
94
#ifdef HAVE_GIF
 
95
  &demuxer_desc_gif,
 
96
#endif
 
97
#ifdef HAVE_OGGVORBIS
 
98
  &demuxer_desc_ogg,
 
99
#endif
 
100
#ifdef USE_WIN32DLL
 
101
  &demuxer_desc_avs,
 
102
#endif
 
103
  &demuxer_desc_pva,
 
104
  &demuxer_desc_mpeg_ts,
 
105
  &demuxer_desc_lmlm4,
 
106
  &demuxer_desc_mpeg_ps,
 
107
  &demuxer_desc_mpeg_pes,
 
108
  &demuxer_desc_mpeg_es,
 
109
  &demuxer_desc_mpeg_gxf,
 
110
  &demuxer_desc_mpeg4_es,
 
111
  &demuxer_desc_h264_es,
 
112
#ifdef HAVE_LIBDV095
 
113
  &demuxer_desc_rawdv,
 
114
#endif
 
115
  &demuxer_desc_mpc,
 
116
  &demuxer_desc_audio,
 
117
#ifdef HAVE_XMMS
 
118
  &demuxer_desc_xmms,
 
119
#endif
 
120
  &demuxer_desc_mpeg_ty,
 
121
#ifdef STREAMING_LIVE555
 
122
  &demuxer_desc_rtp,
 
123
#endif
 
124
#if defined(USE_LIBAVFORMAT) ||  defined(USE_LIBAVFORMAT_SO)
 
125
  &demuxer_desc_lavf,
 
126
#endif
 
127
  &demuxer_desc_aac,
 
128
  NULL
 
129
};
 
130
 
 
131
// Should be set to 1 by demux module if ids it passes to new_sh_audio and
 
132
// new_sh_video don't match aids and vids it accepts from the command line
 
133
int demux_aid_vid_mismatch = 0;
 
134
 
 
135
void free_demuxer_stream(demux_stream_t *ds){
 
136
    ds_free_packs(ds);
 
137
    free(ds);
 
138
}
 
139
 
 
140
demux_stream_t* new_demuxer_stream(struct demuxer_st *demuxer,int id){
 
141
  demux_stream_t* ds=malloc(sizeof(demux_stream_t));
 
142
  ds->buffer_pos=ds->buffer_size=0;
 
143
  ds->buffer=NULL;
 
144
  ds->pts=0;
 
145
  ds->pts_bytes=0;
 
146
  ds->eof=0;
 
147
  ds->pos=0;
 
148
  ds->dpos=0;
 
149
  ds->pack_no=0;
 
150
//---------------
 
151
  ds->packs=0;
 
152
  ds->bytes=0;
 
153
  ds->first=ds->last=ds->current=NULL;
 
154
  ds->id=id;
 
155
  ds->demuxer=demuxer;
 
156
//----------------
 
157
  ds->asf_seq=-1;
 
158
  ds->asf_packet=NULL;
 
159
//----------------
 
160
  ds->ss_mul=ds->ss_div=0;
 
161
//----------------
 
162
  ds->sh=NULL;
 
163
  return ds;
 
164
}
 
165
 
 
166
 
 
167
/**
 
168
 * Get demuxer description structure for a given demuxer type
 
169
 *
 
170
 * @param file_format    type of the demuxer
 
171
 * @return               structure for the demuxer, NULL if not found
 
172
 */
 
173
static demuxer_desc_t* get_demuxer_desc_from_type(int file_format)
 
174
{
 
175
  int i;
 
176
 
 
177
  for (i = 0; demuxer_list[i]; i++)
 
178
    if (file_format == demuxer_list[i]->type)
 
179
      return demuxer_list[i];
 
180
 
 
181
  return NULL;
 
182
}
 
183
 
 
184
 
 
185
demuxer_t* new_demuxer(stream_t *stream,int type,int a_id,int v_id,int s_id,char *filename){
 
186
  demuxer_t *d=malloc(sizeof(demuxer_t));
 
187
  memset(d,0,sizeof(demuxer_t));
 
188
  d->stream=stream;
 
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_audio_t* new_sh_audio(demuxer_t *demuxer,int id){
 
209
    if(id > MAX_A_STREAMS-1 || id < 0)
 
210
    {
 
211
        mp_msg(MSGT_DEMUXER,MSGL_WARN,"Requested audio stream id overflow (%d > %d)\n",
 
212
            id, MAX_A_STREAMS);
 
213
        return NULL;
 
214
    }
 
215
    if(demuxer->a_streams[id]){
 
216
        mp_msg(MSGT_DEMUXER,MSGL_WARN,MSGTR_AudioStreamRedefined,id);
 
217
    } else {
 
218
        sh_audio_t *sh;
 
219
        mp_msg(MSGT_DEMUXER,MSGL_V,MSGTR_FoundAudioStream,id);
 
220
        demuxer->a_streams[id]=malloc(sizeof(sh_audio_t));
 
221
        memset(demuxer->a_streams[id],0,sizeof(sh_audio_t));
 
222
        sh = demuxer->a_streams[id];
 
223
        // set some defaults
 
224
        sh->samplesize=2;
 
225
        sh->sample_format=AF_FORMAT_S16_NE;
 
226
        sh->audio_out_minsize=8192;/* default size, maybe not enough for Win32/ACM*/
 
227
        if (identify && !demux_aid_vid_mismatch)
 
228
          mp_msg(MSGT_GLOBAL, MSGL_INFO, "ID_AUDIO_ID=%d\n", id);
 
229
    }
 
230
    return demuxer->a_streams[id];
 
231
}
 
232
 
 
233
void free_sh_audio(sh_audio_t* sh){
 
234
    mp_msg(MSGT_DEMUXER,MSGL_DBG2,"DEMUXER: freeing sh_audio at %p\n",sh);
 
235
    if(sh->wf) free(sh->wf);
 
236
    free(sh);
 
237
}
 
238
 
 
239
sh_video_t* new_sh_video(demuxer_t *demuxer,int id){
 
240
    if(id > MAX_V_STREAMS-1 || id < 0)
 
241
    {
 
242
        mp_msg(MSGT_DEMUXER,MSGL_WARN,"Requested video stream id overflow (%d > %d)\n",
 
243
            id, MAX_V_STREAMS);
 
244
        return NULL;
 
245
    }
 
246
    if(demuxer->v_streams[id]){
 
247
        mp_msg(MSGT_DEMUXER,MSGL_WARN,MSGTR_VideoStreamRedefined,id);
 
248
    } else {
 
249
        mp_msg(MSGT_DEMUXER,MSGL_V,MSGTR_FoundVideoStream,id);
 
250
        demuxer->v_streams[id]=malloc(sizeof(sh_video_t));
 
251
        memset(demuxer->v_streams[id],0,sizeof(sh_video_t));
 
252
        if (identify && !demux_aid_vid_mismatch)
 
253
          mp_msg(MSGT_GLOBAL, MSGL_INFO, "ID_VIDEO_ID=%d\n", id);
 
254
    }
 
255
    return demuxer->v_streams[id];
 
256
}
 
257
 
 
258
void free_sh_video(sh_video_t* sh){
 
259
    mp_msg(MSGT_DEMUXER,MSGL_DBG2,"DEMUXER: freeing sh_video at %p\n",sh);
 
260
    if(sh->bih) free(sh->bih);
 
261
    free(sh);
 
262
}
 
263
 
 
264
void free_demuxer(demuxer_t *demuxer){
 
265
    int i;
 
266
    mp_msg(MSGT_DEMUXER,MSGL_DBG2,"DEMUXER: freeing demuxer at %p\n",demuxer);
 
267
    if(demuxer->desc->close)
 
268
      demuxer->desc->close(demuxer);
 
269
    // Very ugly hack to make it behave like old implementation
 
270
    if (demuxer->desc->type == DEMUXER_TYPE_DEMUXERS)
 
271
      goto skip_streamfree;
 
272
    // free streams:
 
273
    for(i = 0; i < MAX_A_STREAMS; i++)
 
274
        if(demuxer->a_streams[i]) free_sh_audio(demuxer->a_streams[i]);
 
275
    for(i = 0; i < MAX_V_STREAMS; i++)
 
276
        if(demuxer->v_streams[i]) free_sh_video(demuxer->v_streams[i]);
 
277
    //if(sh_audio) free_sh_audio(sh_audio);
 
278
    //if(sh_video) free_sh_video(sh_video);
 
279
    // free demuxers:
 
280
    free_demuxer_stream(demuxer->audio);
 
281
    free_demuxer_stream(demuxer->video);
 
282
    free_demuxer_stream(demuxer->sub);
 
283
skip_streamfree:
 
284
    if(demuxer->info) {
 
285
      for(i=0;demuxer->info[i] != NULL; i++)
 
286
        free(demuxer->info[i]);
 
287
      free(demuxer->info);
 
288
    }
 
289
    if(demuxer->filename)
 
290
      free(demuxer->filename);
 
291
    free(demuxer);
 
292
}
 
293
 
 
294
 
 
295
void ds_add_packet(demux_stream_t *ds,demux_packet_t* dp){
 
296
//    demux_packet_t* dp=new_demux_packet(len);
 
297
//    stream_read(stream,dp->buffer,len);
 
298
//    dp->pts=pts; //(float)pts/90000.0f;
 
299
//    dp->pos=pos;
 
300
    // append packet to DS stream:
 
301
    ++ds->packs;
 
302
    ds->bytes+=dp->len;
 
303
    if(ds->last){
 
304
      // next packet in stream
 
305
      ds->last->next=dp;
 
306
      ds->last=dp;
 
307
    } else {
 
308
      // first packet in stream
 
309
      ds->first=ds->last=dp;
 
310
    }
 
311
    mp_dbg(MSGT_DEMUXER,MSGL_DBG2,"DEMUX: Append packet to %s, len=%d  pts=%5.3f  pos=%u  [packs: A=%d V=%d]\n",
 
312
        (ds==ds->demuxer->audio)?"d_audio":"d_video",
 
313
        dp->len,dp->pts,(unsigned int)dp->pos,ds->demuxer->audio->packs,ds->demuxer->video->packs);
 
314
}
 
315
 
 
316
void ds_read_packet(demux_stream_t *ds,stream_t *stream,int len,float pts,off_t pos,int flags){
 
317
    demux_packet_t* dp=new_demux_packet(len);
 
318
    len = stream_read(stream,dp->buffer,len);
 
319
    resize_demux_packet(dp, len);
 
320
    dp->pts=pts; //(float)pts/90000.0f;
 
321
    dp->pos=pos;
 
322
    dp->flags=flags;
 
323
    // append packet to DS stream:
 
324
    ds_add_packet(ds,dp);
 
325
}
 
326
 
 
327
// return value:
 
328
//     0 = EOF or no stream found or invalid type
 
329
//     1 = successfully read a packet
 
330
 
 
331
int demux_fill_buffer(demuxer_t *demux,demux_stream_t *ds){
 
332
  // Note: parameter 'ds' can be NULL!
 
333
//  printf("demux->type=%d\n",demux->type);
 
334
  return demux->desc->fill_buffer(demux, ds);
 
335
}
 
336
 
 
337
// return value:
 
338
//     0 = EOF
 
339
//     1 = succesfull
 
340
int ds_fill_buffer(demux_stream_t *ds){
 
341
  demuxer_t *demux=ds->demuxer;
 
342
  if(ds->current) free_demux_packet(ds->current);
 
343
  if(verbose>2){
 
344
    if(ds==demux->audio) mp_dbg(MSGT_DEMUXER,MSGL_DBG3,"ds_fill_buffer(d_audio) called\n");else
 
345
    if(ds==demux->video) mp_dbg(MSGT_DEMUXER,MSGL_DBG3,"ds_fill_buffer(d_video) called\n");else
 
346
    if(ds==demux->sub)   mp_dbg(MSGT_DEMUXER,MSGL_DBG3,"ds_fill_buffer(d_sub) called\n");else
 
347
                         mp_dbg(MSGT_DEMUXER,MSGL_DBG3,"ds_fill_buffer(unknown 0x%X) called\n",(unsigned int)ds);
 
348
  }
 
349
  while(1){
 
350
    if(ds->packs){
 
351
      demux_packet_t *p=ds->first;
 
352
      // copy useful data:
 
353
      ds->buffer=p->buffer;
 
354
      ds->buffer_pos=0;
 
355
      ds->buffer_size=p->len;
 
356
      ds->pos=p->pos;
 
357
      ds->dpos+=p->len; // !!!
 
358
      ++ds->pack_no;
 
359
      if(p->pts){
 
360
        ds->pts=p->pts;
 
361
        ds->pts_bytes=0;
 
362
      }
 
363
      ds->pts_bytes+=p->len; // !!!
 
364
      ds->flags=p->flags;
 
365
      // unlink packet:
 
366
      ds->bytes-=p->len;
 
367
      ds->current=p;
 
368
      ds->first=p->next;
 
369
      if(!ds->first) ds->last=NULL;
 
370
      --ds->packs;
 
371
      return 1; //ds->buffer_size;
 
372
    }
 
373
    if(demux->audio->packs>=MAX_PACKS || demux->audio->bytes>=MAX_PACK_BYTES){
 
374
      mp_msg(MSGT_DEMUXER,MSGL_ERR,MSGTR_TooManyAudioInBuffer,demux->audio->packs,demux->audio->bytes);
 
375
      mp_msg(MSGT_DEMUXER,MSGL_HINT,MSGTR_MaybeNI);
 
376
      break;
 
377
    }
 
378
    if(demux->video->packs>=MAX_PACKS || demux->video->bytes>=MAX_PACK_BYTES){
 
379
      mp_msg(MSGT_DEMUXER,MSGL_ERR,MSGTR_TooManyVideoInBuffer,demux->video->packs,demux->video->bytes);
 
380
      mp_msg(MSGT_DEMUXER,MSGL_HINT,MSGTR_MaybeNI);
 
381
      break;
 
382
    }
 
383
    if(!demux_fill_buffer(demux,ds)){
 
384
       mp_dbg(MSGT_DEMUXER,MSGL_DBG2,"ds_fill_buffer()->demux_fill_buffer() failed\n");
 
385
       break; // EOF
 
386
    }
 
387
  }
 
388
  ds->buffer_pos=ds->buffer_size=0;
 
389
  ds->buffer=NULL;
 
390
  ds->current=NULL;
 
391
  mp_msg(MSGT_DEMUXER,MSGL_V,"ds_fill_buffer: EOF reached (stream: %s)  \n",ds==demux->audio?"audio":"video");
 
392
  ds->eof=1;
 
393
  return 0;
 
394
}
 
395
 
 
396
int demux_read_data(demux_stream_t *ds,unsigned char* mem,int len){
 
397
int x;
 
398
int bytes=0;
 
399
while(len>0){
 
400
  x=ds->buffer_size-ds->buffer_pos;
 
401
  if(x==0){
 
402
    if(!ds_fill_buffer(ds)) return bytes;
 
403
  } else {
 
404
    if(x>len) x=len;
 
405
    if(mem) memcpy(mem+bytes,&ds->buffer[ds->buffer_pos],x);
 
406
    bytes+=x;len-=x;ds->buffer_pos+=x;
 
407
  }
 
408
}
 
409
return bytes;
 
410
}
 
411
 
 
412
int demux_read_data_pack(demux_stream_t *ds,unsigned char* mem,int len){
 
413
int x;
 
414
int bytes=0;
 
415
while(len>0){
 
416
  x=ds->buffer_size-ds->buffer_pos;
 
417
  if(x==0){
 
418
    if(!ds_fill_buffer(ds)) return bytes;
 
419
  } else {
 
420
    if(x>len) x=len;
 
421
    if(mem) memcpy(mem+bytes,&ds->buffer[ds->buffer_pos],x);
 
422
    bytes+=x;len-=x;ds->buffer_pos+=x;
 
423
    return bytes; // stop at end of package! (for correct timestamping)
 
424
  }
 
425
}
 
426
return bytes;
 
427
}
 
428
 
 
429
 
 
430
void ds_free_packs(demux_stream_t *ds){
 
431
  demux_packet_t *dp=ds->first;
 
432
  while(dp){
 
433
    demux_packet_t *dn=dp->next;
 
434
    free_demux_packet(dp);
 
435
    dp=dn;
 
436
  }
 
437
  if(ds->asf_packet){
 
438
    // free unfinished .asf fragments:
 
439
    free(ds->asf_packet->buffer);
 
440
    free(ds->asf_packet);
 
441
    ds->asf_packet=NULL;
 
442
  }
 
443
  ds->first=ds->last=NULL;
 
444
  ds->packs=0; // !!!!!
 
445
  ds->bytes=0;
 
446
  if(ds->current) free_demux_packet(ds->current);
 
447
  ds->current=NULL;
 
448
  ds->buffer=NULL;
 
449
  ds->buffer_pos=ds->buffer_size;
 
450
  ds->pts=0; ds->pts_bytes=0;
 
451
}
 
452
 
 
453
int ds_get_packet(demux_stream_t *ds,unsigned char **start){
 
454
    while(1){
 
455
        int len;
 
456
        if(ds->buffer_pos>=ds->buffer_size){
 
457
          if(!ds_fill_buffer(ds)){
 
458
            // EOF
 
459
            *start = NULL;
 
460
            return -1;
 
461
          }
 
462
        }
 
463
        len=ds->buffer_size-ds->buffer_pos;
 
464
        *start = &ds->buffer[ds->buffer_pos];
 
465
        ds->buffer_pos+=len;
 
466
        return len;
 
467
    }
 
468
}
 
469
 
 
470
int ds_get_packet_sub(demux_stream_t *ds,unsigned char **start){
 
471
    while(1){
 
472
        int len;
 
473
        if(ds->buffer_pos>=ds->buffer_size){
 
474
          *start = NULL;
 
475
          if(!ds->packs) return -1; // no sub
 
476
          if(!ds_fill_buffer(ds)) return -1; // EOF
 
477
        }
 
478
        len=ds->buffer_size-ds->buffer_pos;
 
479
        *start = &ds->buffer[ds->buffer_pos];
 
480
        ds->buffer_pos+=len;
 
481
        return len;
 
482
    }
 
483
}
 
484
 
 
485
float ds_get_next_pts(demux_stream_t *ds) {
 
486
  demuxer_t* demux = ds->demuxer;
 
487
  while(!ds->first) {
 
488
    if(demux->audio->packs>=MAX_PACKS || demux->audio->bytes>=MAX_PACK_BYTES){
 
489
      mp_msg(MSGT_DEMUXER,MSGL_ERR,MSGTR_TooManyAudioInBuffer,demux->audio->packs,demux->audio->bytes);
 
490
      mp_msg(MSGT_DEMUXER,MSGL_HINT,MSGTR_MaybeNI);
 
491
      return -1;
 
492
    }
 
493
    if(demux->video->packs>=MAX_PACKS || demux->video->bytes>=MAX_PACK_BYTES){
 
494
      mp_msg(MSGT_DEMUXER,MSGL_ERR,MSGTR_TooManyVideoInBuffer,demux->video->packs,demux->video->bytes);
 
495
      mp_msg(MSGT_DEMUXER,MSGL_HINT,MSGTR_MaybeNI);
 
496
      return -1;
 
497
    }
 
498
    if(!demux_fill_buffer(demux,ds))
 
499
      return -1;
 
500
  }
 
501
  return ds->first->pts;
 
502
}
 
503
 
 
504
// ====================================================================
 
505
 
 
506
// commandline options, flags:
 
507
extern int force_ni;
 
508
extern int pts_from_bps;
 
509
 
 
510
//extern int audio_id;
 
511
//extern int video_id;
 
512
//extern int dvdsub_id;
 
513
 
 
514
void demuxer_help(void)
 
515
{
 
516
  int i;
 
517
 
 
518
  mp_msg(MSGT_DEMUXER, MSGL_INFO, "Available demuxers:\n");
 
519
  mp_msg(MSGT_DEMUXER, MSGL_INFO, " demuxer:  type  info:  (comment)\n");
 
520
  if (identify)
 
521
    mp_msg(MSGT_GLOBAL, MSGL_INFO, "ID_DEMUXERS\n");
 
522
  for (i = 0; demuxer_list[i]; i++) {
 
523
    if (demuxer_list[i]->type > DEMUXER_TYPE_MAX) // Don't display special demuxers
 
524
      continue;
 
525
    if (demuxer_list[i]->comment && strlen(demuxer_list[i]->comment))
 
526
      mp_msg(MSGT_DEMUXER, MSGL_INFO, "%10s  %2d   %s (%s)\n",
 
527
             demuxer_list[i]->name, demuxer_list[i]->type, demuxer_list[i]->info, demuxer_list[i]->comment);
 
528
    else
 
529
      mp_msg(MSGT_DEMUXER, MSGL_INFO, "%10s  %2d   %s\n",
 
530
             demuxer_list[i]->name, demuxer_list[i]->type, demuxer_list[i]->info);
 
531
  }
 
532
}
 
533
 
 
534
 
 
535
/**
 
536
 * Get demuxer type for a given demuxer name
 
537
 *
 
538
 * @param demuxer_name    string with demuxer name of demuxer number
 
539
 * @param force           will be set if demuxer should be forced.
 
540
 *                        May be NULL.
 
541
 * @return                DEMUXER_TYPE_xxx, -1 if error or not found
 
542
 */
 
543
int get_demuxer_type_from_name(char *demuxer_name, int *force)
 
544
{
 
545
  int i;
 
546
  long type_int;
 
547
  char *endptr;
 
548
 
 
549
  if (!demuxer_name || !demuxer_name[0])
 
550
    return DEMUXER_TYPE_UNKNOWN;
 
551
  if (force) *force = demuxer_name[0] == '+';
 
552
  if (demuxer_name[0] == '+')
 
553
    demuxer_name = &demuxer_name[1];
 
554
  for (i = 0; demuxer_list[i]; i++) {
 
555
    if (demuxer_list[i]->type > DEMUXER_TYPE_MAX) // Can't select special demuxers from commandline
 
556
      continue;
 
557
    if (strcmp(demuxer_name, demuxer_list[i]->name) == 0)
 
558
      return  demuxer_list[i]->type;
 
559
  }
 
560
 
 
561
  // No match found, try to parse name as an integer (demuxer number)
 
562
  type_int = strtol(demuxer_name, &endptr, 0);
 
563
  if (*endptr) // Conversion failed
 
564
    return -1;
 
565
  if ((type_int > 0) && (type_int <= DEMUXER_TYPE_MAX))
 
566
    return (int)type_int;
 
567
 
 
568
  return -1;
 
569
}
 
570
 
 
571
int extension_parsing=1; // 0=off 1=mixed (used only for unstable formats)
 
572
 
 
573
/*
 
574
  NOTE : Several demuxers may be opened at the same time so
 
575
  demuxers should NEVER rely on an external var to enable them
 
576
  self. If a demuxer can't do any autodection it should only use
 
577
  file_format. The user can explictly set file_format with the -demuxer
 
578
  option so there is really no need for another extra var.
 
579
  For conivence an option can be added to set file_format directly
 
580
  to the right type (ex: rawaudio,rawvideo).
 
581
  Also the stream can override the file_format so a demuxer wich rely
 
582
  on a special stream type can set file_format at the stream level
 
583
  (ex: tv,mf).
 
584
*/
 
585
 
 
586
static demuxer_t* demux_open_stream(stream_t *stream, int file_format,
 
587
                    int force, int audio_id, int video_id, int dvdsub_id,
 
588
                    char* filename) {
 
589
 
 
590
//int file_format=(*file_format_ptr);
 
591
 
 
592
demuxer_t *demuxer=NULL;
 
593
 
 
594
sh_video_t *sh_video=NULL;
 
595
 
 
596
demuxer_desc_t *demuxer_desc;
 
597
int fformat;
 
598
int i;
 
599
 
 
600
//printf("demux_open(%p,%d,%d,%d,%d)  \n",stream,file_format,audio_id,video_id,dvdsub_id);
 
601
 
 
602
// If somebody requested a demuxer check it
 
603
if (file_format) {
 
604
  if ((demuxer_desc = get_demuxer_desc_from_type(file_format))) {
 
605
    demuxer = new_demuxer(stream,demuxer_desc->type,audio_id,video_id,dvdsub_id,filename);
 
606
    if (demuxer_desc->check_file) {
 
607
      fformat = demuxer_desc->check_file(demuxer);
 
608
      if (force)
 
609
        fformat = demuxer_desc->type;
 
610
      if (fformat != 0) {
 
611
        if (fformat == demuxer_desc->type) {
 
612
          // Move messages to demuxer detection code?
 
613
          mp_msg(MSGT_DEMUXER, MSGL_INFO, MSGTR_Detected_XXX_FileFormat, demuxer_desc->shortdesc);
 
614
          file_format = demuxer_desc->type = fformat;
 
615
        } else {
 
616
          // Format changed after check, recurse
 
617
          free_demuxer(demuxer);
 
618
          return demux_open_stream(stream, fformat, force,
 
619
                   audio_id, video_id, dvdsub_id, filename);
 
620
        }
 
621
      } else {
 
622
        // Check failed for forced demuxer, quit
 
623
        free_demuxer(demuxer);
 
624
        return NULL;
 
625
      }
 
626
    }
 
627
  }
 
628
}
 
629
 
 
630
if (demuxer)
 
631
  goto dmx_open;
 
632
 
 
633
// Test demuxers with safe file checks
 
634
for (i = 0; (demuxer_desc = demuxer_list[i]); i++) {
 
635
  if (demuxer_desc->safe_check) {
 
636
    demuxer = new_demuxer(stream,demuxer_desc->type,audio_id,video_id,dvdsub_id,filename);
 
637
    if ((fformat = demuxer_desc->check_file(demuxer)) != 0) {
 
638
      if (fformat == demuxer_desc->type) {
 
639
        mp_msg(MSGT_DEMUXER, MSGL_INFO, MSGTR_Detected_XXX_FileFormat, demuxer_desc->shortdesc);
 
640
        file_format = fformat;
 
641
        break;
 
642
      } else {
 
643
        if (fformat == DEMUXER_TYPE_PLAYLIST)
 
644
          return demuxer; // handled in mplayer.c
 
645
        // Format changed after check, recurse
 
646
        free_demuxer(demuxer);
 
647
        demuxer=demux_open_stream(stream, fformat, force,
 
648
                  audio_id, video_id, dvdsub_id, filename);
 
649
        if(demuxer) return demuxer; // done!
 
650
        file_format = DEMUXER_TYPE_UNKNOWN;
 
651
      }
 
652
    } else {
 
653
      free_demuxer(demuxer);
 
654
      demuxer = NULL;
 
655
    }
 
656
  }
 
657
}
 
658
 
 
659
if (demuxer)
 
660
  goto dmx_open;
 
661
 
 
662
// If no forced demuxer perform file extension based detection
 
663
// Ok. We're over the stable detectable fileformats, the next ones are a bit
 
664
// fuzzy. So by default (extension_parsing==1) try extension-based detection
 
665
// first:
 
666
if(file_format==DEMUXER_TYPE_UNKNOWN && filename && extension_parsing==1){
 
667
  file_format=demuxer_type_by_filename(filename);
 
668
  if(file_format!=DEMUXER_TYPE_UNKNOWN){
 
669
    // we like recursion :)
 
670
    demuxer=demux_open_stream(stream, file_format, force,
 
671
              audio_id, video_id, dvdsub_id, filename);
 
672
    if(demuxer) return demuxer; // done!
 
673
    file_format=DEMUXER_TYPE_UNKNOWN; // continue fuzzy guessing...
 
674
    mp_msg(MSGT_DEMUXER,MSGL_V,"demuxer: continue fuzzy content-based format guessing...\n");
 
675
  }
 
676
}
 
677
 
 
678
// Try detection for all other demuxers
 
679
for (i = 0; (demuxer_desc = demuxer_list[i]); i++) {
 
680
  if (!demuxer_desc->safe_check && demuxer_desc->check_file) {
 
681
    demuxer = new_demuxer(stream,demuxer_desc->type,audio_id,video_id,dvdsub_id,filename);
 
682
    if ((fformat = demuxer_desc->check_file(demuxer)) != 0) {
 
683
      if (fformat == demuxer_desc->type) {
 
684
        mp_msg(MSGT_DEMUXER, MSGL_INFO, MSGTR_Detected_XXX_FileFormat, demuxer_desc->shortdesc);
 
685
        file_format = fformat;
 
686
        break;
 
687
      } else {
 
688
        if (fformat == DEMUXER_TYPE_PLAYLIST)
 
689
          return demuxer; // handled in mplayer.c
 
690
        // Format changed after check, recurse
 
691
        free_demuxer(demuxer);
 
692
        demuxer=demux_open_stream(stream, fformat, force,
 
693
                  audio_id, video_id, dvdsub_id, filename);
 
694
        if(demuxer) return demuxer; // done!
 
695
        file_format = DEMUXER_TYPE_UNKNOWN;
 
696
      }
 
697
    } else {
 
698
      free_demuxer(demuxer);
 
699
      demuxer = NULL;
 
700
    }
 
701
  }
 
702
}
 
703
 
 
704
//=============== Unknown, exiting... ===========================
 
705
if(file_format==DEMUXER_TYPE_UNKNOWN || demuxer == NULL){
 
706
  //mp_msg(MSGT_DEMUXER,MSGL_ERR,MSGTR_FormatNotRecognized); // will be done by mplayer.c after fallback to playlist-parsing
 
707
  return NULL;
 
708
}
 
709
//====== File format recognized, set up these for compatibility: =========
 
710
dmx_open:
 
711
 
 
712
demuxer->file_format=file_format;
 
713
 
 
714
if (demuxer->desc->open)
 
715
  if (!(demuxer = demuxer->desc->open(demuxer)))
 
716
    return NULL;
 
717
 
 
718
if ((sh_video=demuxer->video->sh) && sh_video->bih){
 
719
int biComp=le2me_32(sh_video->bih->biCompression);
 
720
  mp_msg(MSGT_DEMUX,MSGL_INFO,"VIDEO:  [%.4s]  %dx%d  %dbpp  %5.3f fps  %5.1f kbps (%4.1f kbyte/s)\n",
 
721
    (char *)&biComp,
 
722
    sh_video->bih->biWidth,
 
723
    sh_video->bih->biHeight,
 
724
    sh_video->bih->biBitCount,
 
725
    sh_video->fps,
 
726
    sh_video->i_bps*0.008f,
 
727
    sh_video->i_bps/1024.0f );
 
728
}
 
729
return demuxer;
 
730
}
 
731
 
 
732
char* audio_stream = NULL;
 
733
char* sub_stream = NULL;
 
734
int demuxer_type = 0; // used by rawaudio and rawvideo
 
735
int audio_stream_cache = 0;
 
736
 
 
737
char *demuxer_name = NULL; // parameter from -demuxer
 
738
char *audio_demuxer_name = NULL; // parameter from -audio-demuxer
 
739
char *sub_demuxer_name = NULL; // parameter from -sub-demuxer
 
740
 
 
741
extern int hr_mp3_seek;
 
742
 
 
743
extern float stream_cache_min_percent;
 
744
extern float stream_cache_seek_min_percent;
 
745
 
 
746
demuxer_t* demux_open(stream_t *vs,int file_format,int audio_id,int video_id,int dvdsub_id,char* filename){
 
747
  stream_t *as = NULL,*ss = NULL;
 
748
  demuxer_t *vd,*ad = NULL,*sd = NULL;
 
749
  int afmt =DEMUXER_TYPE_UNKNOWN,sfmt = DEMUXER_TYPE_UNKNOWN ;
 
750
  int audio_demuxer_type = 0, sub_demuxer_type = 0;
 
751
  int demuxer_force = 0, audio_demuxer_force = 0,
 
752
      sub_demuxer_force = 0;
 
753
 
 
754
  demux_aid_vid_mismatch = 0;
 
755
 
 
756
  if ((demuxer_type = get_demuxer_type_from_name(demuxer_name, &demuxer_force)) < 0) {
 
757
    mp_msg(MSGT_DEMUXER,MSGL_ERR,"-demuxer %s does not exist.\n",demuxer_name);
 
758
  }
 
759
  if ((audio_demuxer_type = get_demuxer_type_from_name(audio_demuxer_name, &audio_demuxer_force)) < 0) {
 
760
    mp_msg(MSGT_DEMUXER,MSGL_ERR,"-audio-demuxer %s does not exist.\n",audio_demuxer_name);
 
761
  }
 
762
  if ((sub_demuxer_type = get_demuxer_type_from_name(sub_demuxer_name, &sub_demuxer_force)) < 0) {
 
763
    mp_msg(MSGT_DEMUXER,MSGL_ERR,"-sub-demuxer %s does not exist.\n",sub_demuxer_name);
 
764
  }
 
765
 
 
766
  if(audio_stream) {
 
767
    as = open_stream(audio_stream,0,&afmt);
 
768
    if(!as) {
 
769
      mp_msg(MSGT_DEMUXER,MSGL_ERR,MSGTR_CannotOpenAudioStream,audio_stream);
 
770
      return NULL;
 
771
    }
 
772
    if(audio_stream_cache) {
 
773
      if(!stream_enable_cache(as,audio_stream_cache*1024,audio_stream_cache*1024*(stream_cache_min_percent / 100.0),
 
774
                              audio_stream_cache*1024*(stream_cache_seek_min_percent / 100.0))) {
 
775
        free_stream(as);
 
776
        mp_msg(MSGT_DEMUXER,MSGL_ERR,"Can't enable audio stream cache\n");
 
777
        return NULL;
 
778
      }
 
779
    }
 
780
  }
 
781
  if(sub_stream) {
 
782
    ss = open_stream(sub_stream,0,&sfmt);
 
783
    if(!ss) {
 
784
      mp_msg(MSGT_DEMUXER,MSGL_ERR,MSGTR_CannotOpenSubtitlesStream,sub_stream);
 
785
      return NULL;
 
786
    }
 
787
  }
 
788
 
 
789
  vd = demux_open_stream(vs, demuxer_type ? demuxer_type : file_format,
 
790
         demuxer_force, audio_stream ? -2 : audio_id, video_id,
 
791
         sub_stream ? -2 : dvdsub_id, filename);
 
792
  if(!vd) {
 
793
    if(as) free_stream(as);
 
794
    if(ss) free_stream(ss);
 
795
    return NULL;
 
796
  }
 
797
  if(as) {
 
798
    ad = demux_open_stream(as, audio_demuxer_type ? audio_demuxer_type : afmt,
 
799
           audio_demuxer_force, audio_id, -2, -2, audio_stream);
 
800
    if(!ad) {
 
801
      mp_msg(MSGT_DEMUXER,MSGL_WARN,MSGTR_OpeningAudioDemuxerFailed,audio_stream);
 
802
      free_stream(as);
 
803
    }
 
804
    else if(ad->audio->sh && ((sh_audio_t*)ad->audio->sh)->format == 0x55) // MP3
 
805
      hr_mp3_seek=1; // Enable high res seeking
 
806
  }
 
807
  if(ss) {
 
808
    sd = demux_open_stream(ss, sub_demuxer_type ? sub_demuxer_type : sfmt,
 
809
           sub_demuxer_force, -2, -2, dvdsub_id, sub_stream);
 
810
    if(!sd) {
 
811
      mp_msg(MSGT_DEMUXER,MSGL_WARN,MSGTR_OpeningSubtitlesDemuxerFailed,sub_stream);
 
812
      free_stream(ss);
 
813
    }
 
814
  }
 
815
 
 
816
  if(ad && sd)
 
817
    return new_demuxers_demuxer(vd,ad,sd);
 
818
  else if(ad)
 
819
    return new_demuxers_demuxer(vd,ad,vd);
 
820
  else if(sd)
 
821
    return new_demuxers_demuxer(vd,vd,sd);
 
822
  else
 
823
    return vd;
 
824
}
 
825
 
 
826
 
 
827
int demux_seek(demuxer_t *demuxer,float rel_seek_secs,int flags){
 
828
    demux_stream_t *d_audio=demuxer->audio;
 
829
    demux_stream_t *d_video=demuxer->video;
 
830
    sh_audio_t *sh_audio=d_audio->sh;
 
831
    sh_video_t *sh_video=d_video->sh;
 
832
 
 
833
if(!demuxer->seekable){
 
834
    if(demuxer->file_format==DEMUXER_TYPE_AVI)
 
835
        mp_msg(MSGT_SEEK,MSGL_WARN,MSGTR_CantSeekRawAVI);
 
836
#ifdef USE_TV
 
837
    else if (demuxer->file_format==DEMUXER_TYPE_TV)
 
838
        mp_msg(MSGT_SEEK,MSGL_WARN,MSGTR_TVInputNotSeekable);
 
839
#endif
 
840
    else
 
841
        mp_msg(MSGT_SEEK,MSGL_WARN,MSGTR_CantSeekFile);
 
842
    return 0;
 
843
}
 
844
 
 
845
    // clear demux buffers:
 
846
    if(sh_audio){ ds_free_packs(d_audio);sh_audio->a_buffer_len=0;}
 
847
    ds_free_packs(d_video);
 
848
    
 
849
    demuxer->stream->eof=0; // clear eof flag
 
850
    demuxer->video->eof=0;
 
851
    demuxer->audio->eof=0;
 
852
 
 
853
#if 0
 
854
    if(sh_audio) sh_audio->timer=sh_video->timer;
 
855
#else
 
856
    if(sh_audio) sh_audio->delay=0;
 
857
    if(sh_video) sh_video->timer=0; // !!!!!!
 
858
#endif
 
859
 
 
860
if (demuxer->desc->seek)
 
861
    demuxer->desc->seek(demuxer,rel_seek_secs,flags);
 
862
 
 
863
    if (sh_audio) resync_audio_stream(sh_audio);
 
864
 
 
865
return 1;
 
866
}
 
867
 
 
868
int demux_info_add(demuxer_t *demuxer, char *opt, char *param)
 
869
{
 
870
    char **info = demuxer->info;
 
871
    int n = 0;
 
872
 
 
873
 
 
874
    for(n = 0; info && info[2*n] != NULL; n++) 
 
875
      {
 
876
        if(!strcasecmp(opt,info[2*n]))
 
877
          {
 
878
            mp_msg(MSGT_DEMUX, MSGL_WARN,MSGTR_DemuxerInfoAlreadyPresent,opt);
 
879
            return 0;
 
880
          }
 
881
      }
 
882
    
 
883
    info = demuxer->info = (char**)realloc(info,(2*(n+2))*sizeof(char*));
 
884
    info[2*n] = strdup(opt);
 
885
    info[2*n+1] = strdup(param);
 
886
    memset(&info[2*(n+1)],0,2*sizeof(char*));
 
887
 
 
888
    return 1;
 
889
}
 
890
 
 
891
int demux_info_print(demuxer_t *demuxer)
 
892
{
 
893
    char **info = demuxer->info;
 
894
    int n;
 
895
 
 
896
    if(!info)
 
897
      return 0;
 
898
 
 
899
    mp_msg(MSGT_DEMUX, MSGL_INFO,MSGTR_ClipInfo);
 
900
    for(n = 0; info[2*n] != NULL ; n++)
 
901
    {
 
902
      mp_msg(MSGT_DEMUX, MSGL_INFO, " %s: %s\n",info[2*n],info[2*n+1]);
 
903
      if (identify) {
 
904
        mp_msg(MSGT_GLOBAL, MSGL_INFO, "ID_CLIP_INFO_NAME%d=%s\n", n, info[2*n]);
 
905
        mp_msg(MSGT_GLOBAL, MSGL_INFO, "ID_CLIP_INFO_VALUE%d=%s\n", n, info[2*n+1]);
 
906
      }
 
907
    }
 
908
    if (identify)
 
909
      mp_msg(MSGT_GLOBAL, MSGL_INFO, "ID_CLIP_INFO_N=%d\n", n);
 
910
 
 
911
    return 0;
 
912
}
 
913
 
 
914
char* demux_info_get(demuxer_t *demuxer, char *opt) {
 
915
  int i;
 
916
  char **info = demuxer->info;
 
917
 
 
918
  for(i = 0; info && info[2*i] != NULL; i++) {
 
919
    if(!strcasecmp(opt,info[2*i]))
 
920
      return info[2*i+1];
 
921
  }
 
922
 
 
923
  return NULL;
 
924
}
 
925
 
 
926
int demux_control(demuxer_t *demuxer, int cmd, void *arg) {
 
927
 
 
928
    if (demuxer->desc->control)
 
929
      return demuxer->desc->control(demuxer,cmd,arg);
 
930
 
 
931
    return DEMUXER_CTRL_NOTIMPL;
 
932
}
 
933
 
 
934
 
 
935
 
 
936
double demuxer_get_time_length(demuxer_t *demuxer){
 
937
    double get_time_ans;
 
938
    sh_video_t *sh_video = demuxer->video->sh;
 
939
    sh_audio_t *sh_audio = demuxer->audio->sh;
 
940
    // <= 0 means DEMUXER_CTRL_NOTIMPL or DEMUXER_CTRL_DONTKNOW
 
941
    if (demux_control(demuxer, DEMUXER_CTRL_GET_TIME_LENGTH,(void *)&get_time_ans)<=0)  {
 
942
      if (sh_video && sh_video->i_bps)
 
943
        get_time_ans = (double)(demuxer->movi_end-demuxer->movi_start)/sh_video->i_bps;
 
944
      else if (sh_audio && sh_audio->i_bps)
 
945
        get_time_ans = (double)(demuxer->movi_end-demuxer->movi_start)/sh_audio->i_bps;
 
946
      else
 
947
        get_time_ans=0;     
 
948
    }
 
949
    return get_time_ans;
 
950
}
 
951
 
 
952
int demuxer_get_percent_pos(demuxer_t *demuxer){     
 
953
    int ans = 0;
 
954
    int res = demux_control(demuxer, DEMUXER_CTRL_GET_PERCENT_POS, &ans);
 
955
    int len = (demuxer->movi_end - demuxer->movi_start) / 100;
 
956
    if (res <= 0) {
 
957
      if (len > 0)
 
958
      ans = (demuxer->filepos - demuxer->movi_start) / len;
 
959
      else
 
960
       ans = 0;
 
961
    }
 
962
    if (ans < 0) ans = 0;
 
963
    if (ans > 100) ans = 100;
 
964
    return ans;
 
965
}
 
966
 
 
967
int demuxer_switch_audio(demuxer_t *demuxer, int index){     
 
968
    int res = demux_control(demuxer, DEMUXER_CTRL_SWITCH_AUDIO, &index);
 
969
    if (res == DEMUXER_CTRL_NOTIMPL)
 
970
      index = demuxer->audio->id;
 
971
    return index;
 
972
}