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