?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Change return type of main function to int to avoid a warning.
[FFMpeg-mirror/ffmpeg-vdpau.git] / libavformat / utils.c
blob44299f9f60a85c6e26b7e40e23e96c3872c46a35
1 /*
2 * various utility functions for use within FFmpeg
3 * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
4 *
5 * This file is part of FFmpeg.
6 *
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * FFmpeg is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20 */
21 #include "avformat.h"
22 #include "libavcodec/opt.h"
23 #include "libavutil/avstring.h"
24 #include "riff.h"
25 #include <sys/time.h>
26 #include <time.h>
27
28 #undef NDEBUG
29 #include <assert.h>
30
31 /**
32 * @file libavformat/utils.c
33 * various utility functions for use within FFmpeg
34 */
35
36 static void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den);
37 static void av_frac_add(AVFrac *f, int64_t incr);
38
39 /** head of registered input format linked list */
40 AVInputFormat *first_iformat = NULL;
41 /** head of registered output format linked list */
42 AVOutputFormat *first_oformat = NULL;
43
44 AVInputFormat *av_iformat_next(AVInputFormat *f)
45 {
46 if(f) return f->next;
47 else return first_iformat;
48 }
49
50 AVOutputFormat *av_oformat_next(AVOutputFormat *f)
51 {
52 if(f) return f->next;
53 else return first_oformat;
54 }
55
56 void av_register_input_format(AVInputFormat *format)
57 {
58 AVInputFormat **p;
59 p = &first_iformat;
60 while (*p != NULL) p = &(*p)->next;
61 *p = format;
62 format->next = NULL;
63 }
64
65 void av_register_output_format(AVOutputFormat *format)
66 {
67 AVOutputFormat **p;
68 p = &first_oformat;
69 while (*p != NULL) p = &(*p)->next;
70 *p = format;
71 format->next = NULL;
72 }
73
74 int match_ext(const char *filename, const char *extensions)
75 {
76 const char *ext, *p;
77 char ext1[32], *q;
78
79 if(!filename)
80 return 0;
81
82 ext = strrchr(filename, '.');
83 if (ext) {
84 ext++;
85 p = extensions;
86 for(;;) {
87 q = ext1;
88 while (*p != '\0' && *p != ',' && q-ext1<sizeof(ext1)-1)
89 *q++ = *p++;
90 *q = '\0';
91 if (!strcasecmp(ext1, ext))
92 return 1;
93 if (*p == '\0')
94 break;
95 p++;
96 }
97 }
98 return 0;
99 }
100
101 AVOutputFormat *guess_format(const char *short_name, const char *filename,
102 const char *mime_type)
103 {
104 AVOutputFormat *fmt, *fmt_found;
105 int score_max, score;
106
107 /* specific test for image sequences */
108 #ifdef CONFIG_IMAGE2_MUXER
109 if (!short_name && filename &&
110 av_filename_number_test(filename) &&
111 av_guess_image2_codec(filename) != CODEC_ID_NONE) {
112 return guess_format("image2", NULL, NULL);
113 }
114 #endif
115 /* Find the proper file type. */
116 fmt_found = NULL;
117 score_max = 0;
118 fmt = first_oformat;
119 while (fmt != NULL) {
120 score = 0;
121 if (fmt->name && short_name && !strcmp(fmt->name, short_name))
122 score += 100;
123 if (fmt->mime_type && mime_type && !strcmp(fmt->mime_type, mime_type))
124 score += 10;
125 if (filename && fmt->extensions &&
126 match_ext(filename, fmt->extensions)) {
127 score += 5;
128 }
129 if (score > score_max) {
130 score_max = score;
131 fmt_found = fmt;
132 }
133 fmt = fmt->next;
134 }
135 return fmt_found;
136 }
137
138 AVOutputFormat *guess_stream_format(const char *short_name, const char *filename,
139 const char *mime_type)
140 {
141 AVOutputFormat *fmt = guess_format(short_name, filename, mime_type);
142
143 if (fmt) {
144 AVOutputFormat *stream_fmt;
145 char stream_format_name[64];
146
147 snprintf(stream_format_name, sizeof(stream_format_name), "%s_stream", fmt->name);
148 stream_fmt = guess_format(stream_format_name, NULL, NULL);
149
150 if (stream_fmt)
151 fmt = stream_fmt;
152 }
153
154 return fmt;
155 }
156
157 enum CodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name,
158 const char *filename, const char *mime_type, enum CodecType type){
159 if(type == CODEC_TYPE_VIDEO){
160 enum CodecID codec_id= CODEC_ID_NONE;
161
162 #ifdef CONFIG_IMAGE2_MUXER
163 if(!strcmp(fmt->name, "image2") || !strcmp(fmt->name, "image2pipe")){
164 codec_id= av_guess_image2_codec(filename);
165 }
166 #endif
167 if(codec_id == CODEC_ID_NONE)
168 codec_id= fmt->video_codec;
169 return codec_id;
170 }else if(type == CODEC_TYPE_AUDIO)
171 return fmt->audio_codec;
172 else
173 return CODEC_ID_NONE;
174 }
175
176 AVInputFormat *av_find_input_format(const char *short_name)
177 {
178 AVInputFormat *fmt;
179 for(fmt = first_iformat; fmt != NULL; fmt = fmt->next) {
180 if (!strcmp(fmt->name, short_name))
181 return fmt;
182 }
183 return NULL;
184 }
185
186 /* memory handling */
187
188 void av_destruct_packet(AVPacket *pkt)
189 {
190 av_free(pkt->data);
191 pkt->data = NULL; pkt->size = 0;
192 }
193
194 void av_init_packet(AVPacket *pkt)
195 {
196 pkt->pts = AV_NOPTS_VALUE;
197 pkt->dts = AV_NOPTS_VALUE;
198 pkt->pos = -1;
199 pkt->duration = 0;
200 pkt->flags = 0;
201 pkt->stream_index = 0;
202 pkt->destruct= av_destruct_packet_nofree;
203 }
204
205 int av_new_packet(AVPacket *pkt, int size)
206 {
207 uint8_t *data;
208 if((unsigned)size > (unsigned)size + FF_INPUT_BUFFER_PADDING_SIZE)
209 return AVERROR(ENOMEM);
210 data = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
211 if (!data)
212 return AVERROR(ENOMEM);
213 memset(data + size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
214
215 av_init_packet(pkt);
216 pkt->data = data;
217 pkt->size = size;
218 pkt->destruct = av_destruct_packet;
219 return 0;
220 }
221
222 int av_get_packet(ByteIOContext *s, AVPacket *pkt, int size)
223 {
224 int ret= av_new_packet(pkt, size);
225
226 if(ret<0)
227 return ret;
228
229 pkt->pos= url_ftell(s);
230
231 ret= get_buffer(s, pkt->data, size);
232 if(ret<=0)
233 av_free_packet(pkt);
234 else
235 pkt->size= ret;
236
237 return ret;
238 }
239
240 int av_dup_packet(AVPacket *pkt)
241 {
242 if (pkt->destruct != av_destruct_packet) {
243 uint8_t *data;
244 /* We duplicate the packet and don't forget to add the padding again. */
245 if((unsigned)pkt->size > (unsigned)pkt->size + FF_INPUT_BUFFER_PADDING_SIZE)
246 return AVERROR(ENOMEM);
247 data = av_malloc(pkt->size + FF_INPUT_BUFFER_PADDING_SIZE);
248 if (!data) {
249 return AVERROR(ENOMEM);
250 }
251 memcpy(data, pkt->data, pkt->size);
252 memset(data + pkt->size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
253 pkt->data = data;
254 pkt->destruct = av_destruct_packet;
255 }
256 return 0;
257 }
258
259 int av_filename_number_test(const char *filename)
260 {
261 char buf[1024];
262 return filename && (av_get_frame_filename(buf, sizeof(buf), filename, 1)>=0);
263 }
264
265 static AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max)
266 {
267 AVInputFormat *fmt1, *fmt;
268 int score;
269
270 fmt = NULL;
271 for(fmt1 = first_iformat; fmt1 != NULL; fmt1 = fmt1->next) {
272 if (!is_opened == !(fmt1->flags & AVFMT_NOFILE))
273 continue;
274 score = 0;
275 if (fmt1->read_probe) {
276 score = fmt1->read_probe(pd);
277 } else if (fmt1->extensions) {
278 if (match_ext(pd->filename, fmt1->extensions)) {
279 score = 50;
280 }
281 }
282 if (score > *score_max) {
283 *score_max = score;
284 fmt = fmt1;
285 }else if (score == *score_max)
286 fmt = NULL;
287 }
288 return fmt;
289 }
290
291 AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened){
292 int score=0;
293 return av_probe_input_format2(pd, is_opened, &score);
294 }
295
296 static int set_codec_from_probe_data(AVStream *st, AVProbeData *pd, int score)
297 {
298 AVInputFormat *fmt;
299 fmt = av_probe_input_format2(pd, 1, &score);
300
301 if (fmt) {
302 if (!strcmp(fmt->name, "mp3"))
303 st->codec->codec_id = CODEC_ID_MP3;
304 else if (!strcmp(fmt->name, "ac3"))
305 st->codec->codec_id = CODEC_ID_AC3;
306 else if (!strcmp(fmt->name, "mpegvideo"))
307 st->codec->codec_id = CODEC_ID_MPEG2VIDEO;
308 else if (!strcmp(fmt->name, "h264"))
309 st->codec->codec_id = CODEC_ID_H264;
310 }
311 return !!fmt;
312 }
313
314 /************************************************************/
315 /* input media file */
316
317 /**
318 * Open a media file from an IO stream. 'fmt' must be specified.
319 */
320 static const char* format_to_name(void* ptr)
321 {
322 AVFormatContext* fc = (AVFormatContext*) ptr;
323 if(fc->iformat) return fc->iformat->name;
324 else if(fc->oformat) return fc->oformat->name;
325 else return "NULL";
326 }
327
328 #define OFFSET(x) offsetof(AVFormatContext,x)
329 #define DEFAULT 0 //should be NAN but it does not work as it is not a constant in glibc as required by ANSI/ISO C
330 //these names are too long to be readable
331 #define E AV_OPT_FLAG_ENCODING_PARAM
332 #define D AV_OPT_FLAG_DECODING_PARAM
333
334 static const AVOption options[]={
335 {"probesize", NULL, OFFSET(probesize), FF_OPT_TYPE_INT, 32000, 32, INT_MAX, D}, /* 32000 from mpegts.c: 1.0 second at 24Mbit/s */
336 {"muxrate", "set mux rate", OFFSET(mux_rate), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},
337 {"packetsize", "set packet size", OFFSET(packet_size), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},
338 {"fflags", NULL, OFFSET(flags), FF_OPT_TYPE_FLAGS, DEFAULT, INT_MIN, INT_MAX, D|E, "fflags"},
339 {"ignidx", "ignore index", 0, FF_OPT_TYPE_CONST, AVFMT_FLAG_IGNIDX, INT_MIN, INT_MAX, D, "fflags"},
340 {"genpts", "generate pts", 0, FF_OPT_TYPE_CONST, AVFMT_FLAG_GENPTS, INT_MIN, INT_MAX, D, "fflags"},
341 {"track", " set the track number", OFFSET(track), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},
342 {"year", "set the year", OFFSET(year), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX, E},
343 {"analyzeduration", "how many microseconds are analyzed to estimate duration", OFFSET(max_analyze_duration), FF_OPT_TYPE_INT, 3*AV_TIME_BASE, 0, INT_MAX, D},
344 {"cryptokey", "decryption key", OFFSET(key), FF_OPT_TYPE_BINARY, 0, 0, 0, D},
345 {"indexmem", "max memory used for timestamp index (per stream)", OFFSET(max_index_size), FF_OPT_TYPE_INT, 1<<20, 0, INT_MAX, D},
346 {"rtbufsize", "max memory used for buffering real-time frames", OFFSET(max_picture_buffer), FF_OPT_TYPE_INT, 3041280, 0, INT_MAX, D}, /* defaults to 1s of 15fps 352x288 YUYV422 video */
347 {"fdebug", "print specific debug info", OFFSET(debug), FF_OPT_TYPE_FLAGS, DEFAULT, 0, INT_MAX, E|D, "fdebug"},
348 {"ts", NULL, 0, FF_OPT_TYPE_CONST, FF_FDEBUG_TS, INT_MIN, INT_MAX, E|D, "fdebug"},
349 {NULL},
350 };
351
352 #undef E
353 #undef D
354 #undef DEFAULT
355
356 static const AVClass av_format_context_class = { "AVFormatContext", format_to_name, options };
357
358 static void avformat_get_context_defaults(AVFormatContext *s)
359 {
360 memset(s, 0, sizeof(AVFormatContext));
361
362 s->av_class = &av_format_context_class;
363
364 av_opt_set_defaults(s);
365 }
366
367 AVFormatContext *av_alloc_format_context(void)
368 {
369 AVFormatContext *ic;
370 ic = av_malloc(sizeof(AVFormatContext));
371 if (!ic) return ic;
372 avformat_get_context_defaults(ic);
373 ic->av_class = &av_format_context_class;
374 return ic;
375 }
376
377 int av_open_input_stream(AVFormatContext **ic_ptr,
378 ByteIOContext *pb, const char *filename,
379 AVInputFormat *fmt, AVFormatParameters *ap)
380 {
381 int err;
382 AVFormatContext *ic;
383 AVFormatParameters default_ap;
384
385 if(!ap){
386 ap=&default_ap;
387 memset(ap, 0, sizeof(default_ap));
388 }
389
390 if(!ap->prealloced_context)
391 ic = av_alloc_format_context();
392 else
393 ic = *ic_ptr;
394 if (!ic) {
395 err = AVERROR(ENOMEM);
396 goto fail;
397 }
398 ic->iformat = fmt;
399 ic->pb = pb;
400 ic->duration = AV_NOPTS_VALUE;
401 ic->start_time = AV_NOPTS_VALUE;
402 av_strlcpy(ic->filename, filename, sizeof(ic->filename));
403
404 /* allocate private data */
405 if (fmt->priv_data_size > 0) {
406 ic->priv_data = av_mallocz(fmt->priv_data_size);
407 if (!ic->priv_data) {
408 err = AVERROR(ENOMEM);
409 goto fail;
410 }
411 } else {
412 ic->priv_data = NULL;
413 }
414
415 if (ic->iformat->read_header) {
416 err = ic->iformat->read_header(ic, ap);
417 if (err < 0)
418 goto fail;
419 }
420
421 if (pb && !ic->data_offset)
422 ic->data_offset = url_ftell(ic->pb);
423
424 *ic_ptr = ic;
425 return 0;
426 fail:
427 if (ic) {
428 int i;
429 av_freep(&ic->priv_data);
430 for(i=0;i<ic->nb_streams;i++) {
431 AVStream *st = ic->streams[i];
432 if (st) {
433 av_free(st->priv_data);
434 av_free(st->codec->extradata);
435 }
436 av_free(st);
437 }
438 }
439 av_free(ic);
440 *ic_ptr = NULL;
441 return err;
442 }
443
444 /** size of probe buffer, for guessing file type from file contents */
445 #define PROBE_BUF_MIN 2048
446 #define PROBE_BUF_MAX (1<<20)
447
448 int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
449 AVInputFormat *fmt,
450 int buf_size,
451 AVFormatParameters *ap)
452 {
453 int err, probe_size;
454 AVProbeData probe_data, *pd = &probe_data;
455 ByteIOContext *pb = NULL;
456
457 pd->filename = "";
458 if (filename)
459 pd->filename = filename;
460 pd->buf = NULL;
461 pd->buf_size = 0;
462
463 if (!fmt) {
464 /* guess format if no file can be opened */
465 fmt = av_probe_input_format(pd, 0);
466 }
467
468 /* Do not open file if the format does not need it. XXX: specific
469 hack needed to handle RTSP/TCP */
470 if (!fmt || !(fmt->flags & AVFMT_NOFILE)) {
471 /* if no file needed do not try to open one */
472 if ((err=url_fopen(&pb, filename, URL_RDONLY)) < 0) {
473 goto fail;
474 }
475 if (buf_size > 0) {
476 url_setbufsize(pb, buf_size);
477 }
478
479 for(probe_size= PROBE_BUF_MIN; probe_size<=PROBE_BUF_MAX && !fmt; probe_size<<=1){
480 int score= probe_size < PROBE_BUF_MAX ? AVPROBE_SCORE_MAX/4 : 0;
481 /* read probe data */
482 pd->buf= av_realloc(pd->buf, probe_size + AVPROBE_PADDING_SIZE);
483 pd->buf_size = get_buffer(pb, pd->buf, probe_size);
484 memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
485 if (url_fseek(pb, 0, SEEK_SET) < 0) {
486 url_fclose(pb);
487 if (url_fopen(&pb, filename, URL_RDONLY) < 0) {
488 pb = NULL;
489 err = AVERROR(EIO);
490 goto fail;
491 }
492 }
493 /* guess file format */
494 fmt = av_probe_input_format2(pd, 1, &score);
495 }
496 av_freep(&pd->buf);
497 }
498
499 /* if still no format found, error */
500 if (!fmt) {
501 err = AVERROR_NOFMT;
502 goto fail;
503 }
504
505 /* check filename in case an image number is expected */
506 if (fmt->flags & AVFMT_NEEDNUMBER) {
507 if (!av_filename_number_test(filename)) {
508 err = AVERROR_NUMEXPECTED;
509 goto fail;
510 }
511 }
512 err = av_open_input_stream(ic_ptr, pb, filename, fmt, ap);
513 if (err)
514 goto fail;
515 return 0;
516 fail:
517 av_freep(&pd->buf);
518 if (pb)
519 url_fclose(pb);
520 *ic_ptr = NULL;
521 return err;
522
523 }
524
525 /*******************************************************/
526
527 static AVPacket *add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt){
528 AVPacketList *pktl;
529 AVPacketList **plast_pktl= packet_buffer;
530
531 while(*plast_pktl) plast_pktl= &(*plast_pktl)->next; //FIXME maybe maintain pointer to the last?
532
533 pktl = av_mallocz(sizeof(AVPacketList));
534 if (!pktl)
535 return NULL;
536
537 /* add the packet in the buffered packet list */
538 *plast_pktl = pktl;
539 pktl->pkt= *pkt;
540 return &pktl->pkt;
541 }
542
543 int av_read_packet(AVFormatContext *s, AVPacket *pkt)
544 {
545 int ret;
546 AVStream *st;
547
548 for(;;){
549 AVPacketList *pktl = s->raw_packet_buffer;
550
551 if (pktl) {
552 *pkt = pktl->pkt;
553 if(s->streams[pkt->stream_index]->codec->codec_id != CODEC_ID_PROBE){
554 s->raw_packet_buffer = pktl->next;
555 av_free(pktl);
556 return 0;
557 }
558 }
559
560 av_init_packet(pkt);
561 ret= s->iformat->read_packet(s, pkt);
562 if (ret < 0)
563 return ret;
564 st= s->streams[pkt->stream_index];
565
566 switch(st->codec->codec_type){
567 case CODEC_TYPE_VIDEO:
568 if(s->video_codec_id) st->codec->codec_id= s->video_codec_id;
569 break;
570 case CODEC_TYPE_AUDIO:
571 if(s->audio_codec_id) st->codec->codec_id= s->audio_codec_id;
572 break;
573 case CODEC_TYPE_SUBTITLE:
574 if(s->subtitle_codec_id)st->codec->codec_id= s->subtitle_codec_id;
575 break;
576 }
577
578 if(!pktl && st->codec->codec_id!=CODEC_ID_PROBE)
579 return ret;
580
581 add_to_pktbuf(&s->raw_packet_buffer, pkt);
582
583 if(st->codec->codec_id == CODEC_ID_PROBE){
584 AVProbeData *pd = &st->probe_data;
585
586 pd->buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
587 memcpy(pd->buf+pd->buf_size, pkt->data, pkt->size);
588 pd->buf_size += pkt->size;
589 memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
590
591 if(av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)){
592 set_codec_from_probe_data(st, pd, 1);
593 if(st->codec->codec_id != CODEC_ID_PROBE){
594 pd->buf_size=0;
595 av_freep(&pd->buf);
596 }
597 }
598 }
599 }
600 }
601
602 /**********************************************************/
603
604 /**
605 * Get the number of samples of an audio frame. Return -1 on error.
606 */
607 static int get_audio_frame_size(AVCodecContext *enc, int size)
608 {
609 int frame_size;
610
611 if(enc->codec_id == CODEC_ID_VORBIS)
612 return -1;
613
614 if (enc->frame_size <= 1) {
615 int bits_per_sample = av_get_bits_per_sample(enc->codec_id);
616
617 if (bits_per_sample) {
618 if (enc->channels == 0)
619 return -1;
620 frame_size = (size << 3) / (bits_per_sample * enc->channels);
621 } else {
622 /* used for example by ADPCM codecs */
623 if (enc->bit_rate == 0)
624 return -1;
625 frame_size = (size * 8 * enc->sample_rate) / enc->bit_rate;
626 }
627 } else {
628 frame_size = enc->frame_size;
629 }
630 return frame_size;
631 }
632
633
634 /**
635 * Return the frame duration in seconds. Return 0 if not available.
636 */
637 static void compute_frame_duration(int *pnum, int *pden, AVStream *st,
638 AVCodecParserContext *pc, AVPacket *pkt)
639 {
640 int frame_size;
641
642 *pnum = 0;
643 *pden = 0;
644 switch(st->codec->codec_type) {
645 case CODEC_TYPE_VIDEO:
646 if(st->time_base.num*1000LL > st->time_base.den){
647 *pnum = st->time_base.num;
648 *pden = st->time_base.den;
649 }else if(st->codec->time_base.num*1000LL > st->codec->time_base.den){
650 *pnum = st->codec->time_base.num;
651 *pden = st->codec->time_base.den;
652 if (pc && pc->repeat_pict) {
653 *pden *= 2;
654 *pnum = (*pnum) * (2 + pc->repeat_pict);
655 }
656 }
657 break;
658 case CODEC_TYPE_AUDIO:
659 frame_size = get_audio_frame_size(st->codec, pkt->size);
660 if (frame_size < 0)
661 break;
662 *pnum = frame_size;
663 *pden = st->codec->sample_rate;
664 break;
665 default:
666 break;
667 }
668 }
669
670 static int is_intra_only(AVCodecContext *enc){
671 if(enc->codec_type == CODEC_TYPE_AUDIO){
672 return 1;
673 }else if(enc->codec_type == CODEC_TYPE_VIDEO){
674 switch(enc->codec_id){
675 case CODEC_ID_MJPEG:
676 case CODEC_ID_MJPEGB:
677 case CODEC_ID_LJPEG:
678 case CODEC_ID_RAWVIDEO:
679 case CODEC_ID_DVVIDEO:
680 case CODEC_ID_HUFFYUV:
681 case CODEC_ID_FFVHUFF:
682 case CODEC_ID_ASV1:
683 case CODEC_ID_ASV2:
684 case CODEC_ID_VCR1:
685 return 1;
686 default: break;
687 }
688 }
689 return 0;
690 }
691
692 static void update_initial_timestamps(AVFormatContext *s, int stream_index,
693 int64_t dts, int64_t pts)
694 {
695 AVStream *st= s->streams[stream_index];
696 AVPacketList *pktl= s->packet_buffer;
697
698 if(st->first_dts != AV_NOPTS_VALUE || dts == AV_NOPTS_VALUE || st->cur_dts == AV_NOPTS_VALUE)
699 return;
700
701 st->first_dts= dts - st->cur_dts;
702 st->cur_dts= dts;
703
704 for(; pktl; pktl= pktl->next){
705 if(pktl->pkt.stream_index != stream_index)
706 continue;
707 //FIXME think more about this check
708 if(pktl->pkt.pts != AV_NOPTS_VALUE && pktl->pkt.pts == pktl->pkt.dts)
709 pktl->pkt.pts += st->first_dts;
710
711 if(pktl->pkt.dts != AV_NOPTS_VALUE)
712 pktl->pkt.dts += st->first_dts;
713
714 if(st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
715 st->start_time= pktl->pkt.pts;
716 }
717 if (st->start_time == AV_NOPTS_VALUE)
718 st->start_time = pts;
719 }
720
721 static void update_initial_durations(AVFormatContext *s, AVStream *st, AVPacket *pkt)
722 {
723 AVPacketList *pktl= s->packet_buffer;
724 int64_t cur_dts= 0;
725
726 if(st->first_dts != AV_NOPTS_VALUE){
727 cur_dts= st->first_dts;
728 for(; pktl; pktl= pktl->next){
729 if(pktl->pkt.stream_index == pkt->stream_index){
730 if(pktl->pkt.pts != pktl->pkt.dts || pktl->pkt.dts != AV_NOPTS_VALUE || pktl->pkt.duration)
731 break;
732 cur_dts -= pkt->duration;
733 }
734 }
735 pktl= s->packet_buffer;
736 st->first_dts = cur_dts;
737 }else if(st->cur_dts)
738 return;
739
740 for(; pktl; pktl= pktl->next){
741 if(pktl->pkt.stream_index != pkt->stream_index)
742 continue;
743 if(pktl->pkt.pts == pktl->pkt.dts && pktl->pkt.dts == AV_NOPTS_VALUE
744 && !pktl->pkt.duration){
745 pktl->pkt.dts= cur_dts;
746 if(!st->codec->has_b_frames)
747 pktl->pkt.pts= cur_dts;
748 cur_dts += pkt->duration;
749 pktl->pkt.duration= pkt->duration;
750 }else
751 break;
752 }
753 if(st->first_dts == AV_NOPTS_VALUE)
754 st->cur_dts= cur_dts;
755 }
756
757 static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
758 AVCodecParserContext *pc, AVPacket *pkt)
759 {
760 int num, den, presentation_delayed, delay, i;
761 int64_t offset;
762
763 if(pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && pkt->dts > pkt->pts && st->pts_wrap_bits<63
764 /*&& pkt->dts-(1LL<<st->pts_wrap_bits) < pkt->pts*/){
765 pkt->dts -= 1LL<<st->pts_wrap_bits;
766 }
767
768 if (pkt->duration == 0) {
769 compute_frame_duration(&num, &den, st, pc, pkt);
770 if (den && num) {
771 pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
772
773 if(pkt->duration != 0 && s->packet_buffer)
774 update_initial_durations(s, st, pkt);
775 }
776 }
777
778 /* correct timestamps with byte offset if demuxers only have timestamps
779 on packet boundaries */
780 if(pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size){
781 /* this will estimate bitrate based on this frame's duration and size */
782 offset = av_rescale(pc->offset, pkt->duration, pkt->size);
783 if(pkt->pts != AV_NOPTS_VALUE)
784 pkt->pts += offset;
785 if(pkt->dts != AV_NOPTS_VALUE)
786 pkt->dts += offset;
787 }
788
789 /* do we have a video B-frame ? */
790 delay= st->codec->has_b_frames;
791 presentation_delayed = 0;
792 /* XXX: need has_b_frame, but cannot get it if the codec is
793 not initialized */
794 if (delay &&
795 pc && pc->pict_type != FF_B_TYPE)
796 presentation_delayed = 1;
797 /* This may be redundant, but it should not hurt. */
798 if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
799 presentation_delayed = 1;
800
801 // av_log(NULL, AV_LOG_DEBUG, "IN delayed:%d pts:%"PRId64", dts:%"PRId64" cur_dts:%"PRId64" st:%d pc:%p\n", presentation_delayed, pkt->pts, pkt->dts, st->cur_dts, pkt->stream_index, pc);
802 /* interpolate PTS and DTS if they are not present */
803 if(delay==0 || (delay==1 && pc)){
804 if (presentation_delayed) {
805 /* DTS = decompression timestamp */
806 /* PTS = presentation timestamp */
807 if (pkt->dts == AV_NOPTS_VALUE)
808 pkt->dts = st->last_IP_pts;
809 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts);
810 if (pkt->dts == AV_NOPTS_VALUE)
811 pkt->dts = st->cur_dts;
812
813 /* this is tricky: the dts must be incremented by the duration
814 of the frame we are displaying, i.e. the last I- or P-frame */
815 if (st->last_IP_duration == 0)
816 st->last_IP_duration = pkt->duration;
817 if(pkt->dts != AV_NOPTS_VALUE)
818 st->cur_dts = pkt->dts + st->last_IP_duration;
819 st->last_IP_duration = pkt->duration;
820 st->last_IP_pts= pkt->pts;
821 /* cannot compute PTS if not present (we can compute it only
822 by knowing the future */
823 } else if(pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE || pkt->duration){
824 if(pkt->pts != AV_NOPTS_VALUE && pkt->duration){
825 int64_t old_diff= FFABS(st->cur_dts - pkt->duration - pkt->pts);
826 int64_t new_diff= FFABS(st->cur_dts - pkt->pts);
827 if(old_diff < new_diff && old_diff < (pkt->duration>>3)){
828 pkt->pts += pkt->duration;
829 // av_log(NULL, AV_LOG_DEBUG, "id:%d old:%"PRId64" new:%"PRId64" dur:%d cur:%"PRId64" size:%d\n", pkt->stream_index, old_diff, new_diff, pkt->duration, st->cur_dts, pkt->size);
830 }
831 }
832
833 /* presentation is not delayed : PTS and DTS are the same */
834 if(pkt->pts == AV_NOPTS_VALUE)
835 pkt->pts = pkt->dts;
836 update_initial_timestamps(s, pkt->stream_index, pkt->pts, pkt->pts);
837 if(pkt->pts == AV_NOPTS_VALUE)
838 pkt->pts = st->cur_dts;
839 pkt->dts = pkt->pts;
840 if(pkt->pts != AV_NOPTS_VALUE)
841 st->cur_dts = pkt->pts + pkt->duration;
842 }
843 }
844
845 if(pkt->pts != AV_NOPTS_VALUE){
846 st->pts_buffer[0]= pkt->pts;
847 for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
848 st->pts_buffer[i]= (i-delay-1) * pkt->duration;
849 for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
850 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
851 if(pkt->dts == AV_NOPTS_VALUE)
852 pkt->dts= st->pts_buffer[0];
853 if(delay>1){
854 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts); // this should happen on the first packet
855 }
856 if(pkt->dts > st->cur_dts)
857 st->cur_dts = pkt->dts;
858 }
859
860 // av_log(NULL, AV_LOG_ERROR, "OUTdelayed:%d/%d pts:%"PRId64", dts:%"PRId64" cur_dts:%"PRId64"\n", presentation_delayed, delay, pkt->pts, pkt->dts, st->cur_dts);
861
862 /* update flags */
863 if(is_intra_only(st->codec))
864 pkt->flags |= PKT_FLAG_KEY;
865 else if (pc) {
866 pkt->flags = 0;
867 /* keyframe computation */
868 if (pc->pict_type == FF_I_TYPE)
869 pkt->flags |= PKT_FLAG_KEY;
870 }
871 }
872
873 void av_destruct_packet_nofree(AVPacket *pkt)
874 {
875 pkt->data = NULL; pkt->size = 0;
876 }
877
878 static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
879 {
880 AVStream *st;
881 int len, ret, i;
882
883 av_init_packet(pkt);
884
885 for(;;) {
886 /* select current input stream component */
887 st = s->cur_st;
888 if (st) {
889 if (!st->need_parsing || !st->parser) {
890 /* no parsing needed: we just output the packet as is */
891 /* raw data support */
892 *pkt = s->cur_pkt;
893 compute_pkt_fields(s, st, NULL, pkt);
894 s->cur_st = NULL;
895 break;
896 } else if (s->cur_len > 0 && st->discard < AVDISCARD_ALL) {
897 len = av_parser_parse(st->parser, st->codec, &pkt->data, &pkt->size,
898 s->cur_ptr, s->cur_len,
899 s->cur_pkt.pts, s->cur_pkt.dts);
900 s->cur_pkt.pts = AV_NOPTS_VALUE;
901 s->cur_pkt.dts = AV_NOPTS_VALUE;
902 /* increment read pointer */
903 s->cur_ptr += len;
904 s->cur_len -= len;
905
906 /* return packet if any */
907 if (pkt->size) {
908 got_packet:
909 pkt->pos = s->cur_pkt.pos; // Isn't quite accurate but close.
910 pkt->duration = 0;
911 pkt->stream_index = st->index;
912 pkt->pts = st->parser->pts;
913 pkt->dts = st->parser->dts;
914 pkt->destruct = av_destruct_packet_nofree;
915 compute_pkt_fields(s, st, st->parser, pkt);
916
917 if((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & PKT_FLAG_KEY){
918 ff_reduce_index(s, st->index);
919 av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
920 0, 0, AVINDEX_KEYFRAME);
921 }
922
923 break;
924 }
925 } else {
926 /* free packet */
927 av_free_packet(&s->cur_pkt);
928 s->cur_st = NULL;
929 }
930 } else {
931 /* read next packet */
932 ret = av_read_packet(s, &s->cur_pkt);
933 if (ret < 0) {
934 if (ret == AVERROR(EAGAIN))
935 return ret;
936 /* return the last frames, if any */
937 for(i = 0; i < s->nb_streams; i++) {
938 st = s->streams[i];
939 if (st->parser && st->need_parsing) {
940 av_parser_parse(st->parser, st->codec,
941 &pkt->data, &pkt->size,
942 NULL, 0,
943 AV_NOPTS_VALUE, AV_NOPTS_VALUE);
944 if (pkt->size)
945 goto got_packet;
946 }
947 }
948 /* no more packets: really terminate parsing */
949 return ret;
950 }
951
952 if(s->cur_pkt.pts != AV_NOPTS_VALUE &&
953 s->cur_pkt.dts != AV_NOPTS_VALUE &&
954 s->cur_pkt.pts < s->cur_pkt.dts){
955 av_log(s, AV_LOG_WARNING, "Invalid timestamps stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
956 s->cur_pkt.stream_index,
957 s->cur_pkt.pts,
958 s->cur_pkt.dts,
959 s->cur_pkt.size);
960 // av_free_packet(&s->cur_pkt);
961 // return -1;
962 }
963
964 st = s->streams[s->cur_pkt.stream_index];
965 if(s->debug & FF_FDEBUG_TS)
966 av_log(s, AV_LOG_DEBUG, "av_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, flags=%d\n",
967 s->cur_pkt.stream_index,
968 s->cur_pkt.pts,
969 s->cur_pkt.dts,
970 s->cur_pkt.size,
971 s->cur_pkt.flags);
972
973 s->cur_st = st;
974 s->cur_ptr = s->cur_pkt.data;
975 s->cur_len = s->cur_pkt.size;
976 if (st->need_parsing && !st->parser) {
977 st->parser = av_parser_init(st->codec->codec_id);
978 if (!st->parser) {
979 /* no parser available: just output the raw packets */
980 st->need_parsing = AVSTREAM_PARSE_NONE;
981 }else if(st->need_parsing == AVSTREAM_PARSE_HEADERS){
982 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
983 }
984 if(st->parser && (s->iformat->flags & AVFMT_GENERIC_INDEX)){
985 st->parser->next_frame_offset=
986 st->parser->cur_offset= s->cur_pkt.pos;
987 }
988 }
989 }
990 }
991 if(s->debug & FF_FDEBUG_TS)
992 av_log(s, AV_LOG_DEBUG, "av_read_frame_internal stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, flags=%d\n",
993 pkt->stream_index,
994 pkt->pts,
995 pkt->dts,
996 pkt->size,
997 pkt->flags);
998
999 return 0;
1000 }
1001
1002 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1003 {
1004 AVPacketList *pktl;
1005 int eof=0;
1006 const int genpts= s->flags & AVFMT_FLAG_GENPTS;
1007
1008 for(;;){
1009 pktl = s->packet_buffer;
1010 if (pktl) {
1011 AVPacket *next_pkt= &pktl->pkt;
1012
1013 if(genpts && next_pkt->dts != AV_NOPTS_VALUE){
1014 while(pktl && next_pkt->pts == AV_NOPTS_VALUE){
1015 if( pktl->pkt.stream_index == next_pkt->stream_index
1016 && next_pkt->dts < pktl->pkt.dts
1017 && pktl->pkt.pts != pktl->pkt.dts //not b frame
1018 /*&& pktl->pkt.dts != AV_NOPTS_VALUE*/){
1019 next_pkt->pts= pktl->pkt.dts;
1020 }
1021 pktl= pktl->next;
1022 }
1023 pktl = s->packet_buffer;
1024 }
1025
1026 if( next_pkt->pts != AV_NOPTS_VALUE
1027 || next_pkt->dts == AV_NOPTS_VALUE
1028 || !genpts || eof){
1029 /* read packet from packet buffer, if there is data */
1030 *pkt = *next_pkt;
1031 s->packet_buffer = pktl->next;
1032 av_free(pktl);
1033 return 0;
1034 }
1035 }
1036 if(genpts){
1037 int ret= av_read_frame_internal(s, pkt);
1038 if(ret<0){
1039 if(pktl && ret != AVERROR(EAGAIN)){
1040 eof=1;
1041 continue;
1042 }else
1043 return ret;
1044 }
1045
1046 if(av_dup_packet(add_to_pktbuf(&s->packet_buffer, pkt)) < 0)
1047 return AVERROR(ENOMEM);
1048 }else{
1049 assert(!s->packet_buffer);
1050 return av_read_frame_internal(s, pkt);
1051 }
1052 }
1053 }
1054
1055 /* XXX: suppress the packet queue */
1056 static void flush_packet_queue(AVFormatContext *s)
1057 {
1058 AVPacketList *pktl;
1059
1060 for(;;) {
1061 pktl = s->packet_buffer;
1062 if (!pktl)
1063 break;
1064 s->packet_buffer = pktl->next;
1065 av_free_packet(&pktl->pkt);
1066 av_free(pktl);
1067 }
1068 }
1069
1070 /*******************************************************/
1071 /* seek support */
1072
1073 int av_find_default_stream_index(AVFormatContext *s)
1074 {
1075 int first_audio_index = -1;
1076 int i;
1077 AVStream *st;
1078
1079 if (s->nb_streams <= 0)
1080 return -1;
1081 for(i = 0; i < s->nb_streams; i++) {
1082 st = s->streams[i];
1083 if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
1084 return i;
1085 }
1086 if (first_audio_index < 0 && st->codec->codec_type == CODEC_TYPE_AUDIO)
1087 first_audio_index = i;
1088 }
1089 return first_audio_index >= 0 ? first_audio_index : 0;
1090 }
1091
1092 /**
1093 * Flush the frame reader.
1094 */
1095 static void av_read_frame_flush(AVFormatContext *s)
1096 {
1097 AVStream *st;
1098 int i;
1099
1100 flush_packet_queue(s);
1101
1102 /* free previous packet */
1103 if (s->cur_st) {
1104 if (s->cur_st->parser)
1105 av_free_packet(&s->cur_pkt);
1106 s->cur_st = NULL;
1107 }
1108 /* fail safe */
1109 s->cur_ptr = NULL;
1110 s->cur_len = 0;
1111
1112 /* for each stream, reset read state */
1113 for(i = 0; i < s->nb_streams; i++) {
1114 st = s->streams[i];
1115
1116 if (st->parser) {
1117 av_parser_close(st->parser);
1118 st->parser = NULL;
1119 }
1120 st->last_IP_pts = AV_NOPTS_VALUE;
1121 st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
1122 }
1123 }
1124
1125 void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp){
1126 int i;
1127
1128 for(i = 0; i < s->nb_streams; i++) {
1129 AVStream *st = s->streams[i];
1130
1131 st->cur_dts = av_rescale(timestamp,
1132 st->time_base.den * (int64_t)ref_st->time_base.num,
1133 st->time_base.num * (int64_t)ref_st->time_base.den);
1134 }
1135 }
1136
1137 void ff_reduce_index(AVFormatContext *s, int stream_index)
1138 {
1139 AVStream *st= s->streams[stream_index];
1140 unsigned int max_entries= s->max_index_size / sizeof(AVIndexEntry);
1141
1142 if((unsigned)st->nb_index_entries >= max_entries){
1143 int i;
1144 for(i=0; 2*i<st->nb_index_entries; i++)
1145 st->index_entries[i]= st->index_entries[2*i];
1146 st->nb_index_entries= i;
1147 }
1148 }
1149
1150 int av_add_index_entry(AVStream *st,
1151 int64_t pos, int64_t timestamp, int size, int distance, int flags)
1152 {
1153 AVIndexEntry *entries, *ie;
1154 int index;
1155
1156 if((unsigned)st->nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1157 return -1;
1158
1159 entries = av_fast_realloc(st->index_entries,
1160 &st->index_entries_allocated_size,
1161 (st->nb_index_entries + 1) *
1162 sizeof(AVIndexEntry));
1163 if(!entries)
1164 return -1;
1165
1166 st->index_entries= entries;
1167
1168 index= av_index_search_timestamp(st, timestamp, AVSEEK_FLAG_ANY);
1169
1170 if(index<0){
1171 index= st->nb_index_entries++;
1172 ie= &entries[index];
1173 assert(index==0 || ie[-1].timestamp < timestamp);
1174 }else{
1175 ie= &entries[index];
1176 if(ie->timestamp != timestamp){
1177 if(ie->timestamp <= timestamp)
1178 return -1;
1179 memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(st->nb_index_entries - index));
1180 st->nb_index_entries++;
1181 }else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
1182 distance= ie->min_distance;
1183 }
1184
1185 ie->pos = pos;
1186 ie->timestamp = timestamp;
1187 ie->min_distance= distance;
1188 ie->size= size;
1189 ie->flags = flags;
1190
1191 return index;
1192 }
1193
1194 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1195 int flags)
1196 {
1197 AVIndexEntry *entries= st->index_entries;
1198 int nb_entries= st->nb_index_entries;
1199 int a, b, m;
1200 int64_t timestamp;
1201
1202 a = - 1;
1203 b = nb_entries;
1204
1205 while (b - a > 1) {
1206 m = (a + b) >> 1;
1207 timestamp = entries[m].timestamp;
1208 if(timestamp >= wanted_timestamp)
1209 b = m;
1210 if(timestamp <= wanted_timestamp)
1211 a = m;
1212 }
1213 m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1214
1215 if(!(flags & AVSEEK_FLAG_ANY)){
1216 while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1217 m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1218 }
1219 }
1220
1221 if(m == nb_entries)
1222 return -1;
1223 return m;
1224 }
1225
1226 #define DEBUG_SEEK
1227
1228 int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
1229 AVInputFormat *avif= s->iformat;
1230 int64_t pos_min, pos_max, pos, pos_limit;
1231 int64_t ts_min, ts_max, ts;
1232 int index;
1233 AVStream *st;
1234
1235 if (stream_index < 0)
1236 return -1;
1237
1238 #ifdef DEBUG_SEEK
1239 av_log(s, AV_LOG_DEBUG, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1240 #endif
1241
1242 ts_max=
1243 ts_min= AV_NOPTS_VALUE;
1244 pos_limit= -1; //gcc falsely says it may be uninitialized
1245
1246 st= s->streams[stream_index];
1247 if(st->index_entries){
1248 AVIndexEntry *e;
1249
1250 index= av_index_search_timestamp(st, target_ts, flags | AVSEEK_FLAG_BACKWARD); //FIXME whole func must be checked for non-keyframe entries in index case, especially read_timestamp()
1251 index= FFMAX(index, 0);
1252 e= &st->index_entries[index];
1253
1254 if(e->timestamp <= target_ts || e->pos == e->min_distance){
1255 pos_min= e->pos;
1256 ts_min= e->timestamp;
1257 #ifdef DEBUG_SEEK
1258 av_log(s, AV_LOG_DEBUG, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1259 pos_min,ts_min);
1260 #endif
1261 }else{
1262 assert(index==0);
1263 }
1264
1265 index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1266 assert(index < st->nb_index_entries);
1267 if(index >= 0){
1268 e= &st->index_entries[index];
1269 assert(e->timestamp >= target_ts);
1270 pos_max= e->pos;
1271 ts_max= e->timestamp;
1272 pos_limit= pos_max - e->min_distance;
1273 #ifdef DEBUG_SEEK
1274 av_log(s, AV_LOG_DEBUG, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
1275 pos_max,pos_limit, ts_max);
1276 #endif
1277 }
1278 }
1279
1280 pos= av_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1281 if(pos<0)
1282 return -1;
1283
1284 /* do the seek */
1285 url_fseek(s->pb, pos, SEEK_SET);
1286
1287 av_update_cur_dts(s, st, ts);
1288
1289 return 0;
1290 }
1291
1292 int64_t av_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts, int64_t pos_min, int64_t pos_max, int64_t pos_limit, int64_t ts_min, int64_t ts_max, int flags, int64_t *ts_ret, int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t )){
1293 int64_t pos, ts;
1294 int64_t start_pos, filesize;
1295 int no_change;
1296
1297 #ifdef DEBUG_SEEK
1298 av_log(s, AV_LOG_DEBUG, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1299 #endif
1300
1301 if(ts_min == AV_NOPTS_VALUE){
1302 pos_min = s->data_offset;
1303 ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1304 if (ts_min == AV_NOPTS_VALUE)
1305 return -1;
1306 }
1307
1308 if(ts_max == AV_NOPTS_VALUE){
1309 int step= 1024;
1310 filesize = url_fsize(s->pb);
1311 pos_max = filesize - 1;
1312 do{
1313 pos_max -= step;
1314 ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
1315 step += step;
1316 }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1317 if (ts_max == AV_NOPTS_VALUE)
1318 return -1;
1319
1320 for(;;){
1321 int64_t tmp_pos= pos_max + 1;
1322 int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1323 if(tmp_ts == AV_NOPTS_VALUE)
1324 break;
1325 ts_max= tmp_ts;
1326 pos_max= tmp_pos;
1327 if(tmp_pos >= filesize)
1328 break;
1329 }
1330 pos_limit= pos_max;
1331 }
1332
1333 if(ts_min > ts_max){
1334 return -1;
1335 }else if(ts_min == ts_max){
1336 pos_limit= pos_min;
1337 }
1338
1339 no_change=0;
1340 while (pos_min < pos_limit) {
1341 #ifdef DEBUG_SEEK
1342 av_log(s, AV_LOG_DEBUG, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1343 pos_min, pos_max,
1344 ts_min, ts_max);
1345 #endif
1346 assert(pos_limit <= pos_max);
1347
1348 if(no_change==0){
1349 int64_t approximate_keyframe_distance= pos_max - pos_limit;
1350 // interpolate position (better than dichotomy)
1351 pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1352 + pos_min - approximate_keyframe_distance;
1353 }else if(no_change==1){
1354 // bisection, if interpolation failed to change min or max pos last time
1355 pos = (pos_min + pos_limit)>>1;
1356 }else{
1357 /* linear search if bisection failed, can only happen if there
1358 are very few or no keyframes between min/max */
1359 pos=pos_min;
1360 }
1361 if(pos <= pos_min)
1362 pos= pos_min + 1;
1363 else if(pos > pos_limit)
1364 pos= pos_limit;
1365 start_pos= pos;
1366
1367 ts = read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1368 if(pos == pos_max)
1369 no_change++;
1370 else
1371 no_change=0;
1372 #ifdef DEBUG_SEEK
1373 av_log(s, AV_LOG_DEBUG, "%"PRId64" %"PRId64" %"PRId64" / %"PRId64" %"PRId64" %"PRId64" target:%"PRId64" limit:%"PRId64" start:%"PRId64" noc:%d\n", pos_min, pos, pos_max, ts_min, ts, ts_max, target_ts, pos_limit, start_pos, no_change);
1374 #endif
1375 if(ts == AV_NOPTS_VALUE){
1376 av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1377 return -1;
1378 }
1379 assert(ts != AV_NOPTS_VALUE);
1380 if (target_ts <= ts) {
1381 pos_limit = start_pos - 1;
1382 pos_max = pos;
1383 ts_max = ts;
1384 }
1385 if (target_ts >= ts) {
1386 pos_min = pos;
1387 ts_min = ts;
1388 }
1389 }
1390
1391 pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1392 ts = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min : ts_max;
1393 #ifdef DEBUG_SEEK
1394 pos_min = pos;
1395 ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1396 pos_min++;
1397 ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1398 av_log(s, AV_LOG_DEBUG, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1399 pos, ts_min, target_ts, ts_max);
1400 #endif
1401 *ts_ret= ts;
1402 return pos;
1403 }
1404
1405 static int av_seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1406 int64_t pos_min, pos_max;
1407 #if 0
1408 AVStream *st;
1409
1410 if (stream_index < 0)
1411 return -1;
1412
1413 st= s->streams[stream_index];
1414 #endif
1415
1416 pos_min = s->data_offset;
1417 pos_max = url_fsize(s->pb) - 1;
1418
1419 if (pos < pos_min) pos= pos_min;
1420 else if(pos > pos_max) pos= pos_max;
1421
1422 url_fseek(s->pb, pos, SEEK_SET);
1423
1424 #if 0
1425 av_update_cur_dts(s, st, ts);
1426 #endif
1427 return 0;
1428 }
1429
1430 static int av_seek_frame_generic(AVFormatContext *s,
1431 int stream_index, int64_t timestamp, int flags)
1432 {
1433 int index;
1434 AVStream *st;
1435 AVIndexEntry *ie;
1436
1437 st = s->streams[stream_index];
1438
1439 index = av_index_search_timestamp(st, timestamp, flags);
1440
1441 if(index < 0 || index==st->nb_index_entries-1){
1442 int i;
1443 AVPacket pkt;
1444
1445 if(st->nb_index_entries){
1446 assert(st->index_entries);
1447 ie= &st->index_entries[st->nb_index_entries-1];
1448 url_fseek(s->pb, ie->pos, SEEK_SET);
1449 av_update_cur_dts(s, st, ie->timestamp);
1450 }else
1451 url_fseek(s->pb, 0, SEEK_SET);
1452
1453 for(i=0;; i++) {
1454 int ret = av_read_frame(s, &pkt);
1455 if(ret<0)
1456 break;
1457 av_free_packet(&pkt);
1458 if(stream_index == pkt.stream_index){
1459 if((pkt.flags & PKT_FLAG_KEY) && pkt.dts > timestamp)
1460 break;
1461 }
1462 }
1463 index = av_index_search_timestamp(st, timestamp, flags);
1464 }
1465 if (index < 0)
1466 return -1;
1467
1468 av_read_frame_flush(s);
1469 if (s->iformat->read_seek){
1470 if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
1471 return 0;
1472 }
1473 ie = &st->index_entries[index];
1474 url_fseek(s->pb, ie->pos, SEEK_SET);
1475
1476 av_update_cur_dts(s, st, ie->timestamp);
1477
1478 return 0;
1479 }
1480
1481 int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1482 {
1483 int ret;
1484 AVStream *st;
1485
1486 av_read_frame_flush(s);
1487
1488 if(flags & AVSEEK_FLAG_BYTE)
1489 return av_seek_frame_byte(s, stream_index, timestamp, flags);
1490
1491 if(stream_index < 0){
1492 stream_index= av_find_default_stream_index(s);
1493 if(stream_index < 0)
1494 return -1;
1495
1496 st= s->streams[stream_index];
1497 /* timestamp for default must be expressed in AV_TIME_BASE units */
1498 timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1499 }
1500 st= s->streams[stream_index];
1501
1502 /* first, we try the format specific seek */
1503 if (s->iformat->read_seek)
1504 ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1505 else
1506 ret = -1;
1507 if (ret >= 0) {
1508 return 0;
1509 }
1510
1511 if(s->iformat->read_timestamp)
1512 return av_seek_frame_binary(s, stream_index, timestamp, flags);
1513 else
1514 return av_seek_frame_generic(s, stream_index, timestamp, flags);
1515 }
1516
1517 /*******************************************************/
1518
1519 /**
1520 * Returns TRUE if the stream has accurate duration in any stream.
1521 *
1522 * @return TRUE if the stream has accurate duration for at least one component.
1523 */
1524 static int av_has_duration(AVFormatContext *ic)
1525 {
1526 int i;
1527 AVStream *st;
1528
1529 for(i = 0;i < ic->nb_streams; i++) {
1530 st = ic->streams[i];
1531 if (st->duration != AV_NOPTS_VALUE)
1532 return 1;
1533 }
1534 return 0;
1535 }
1536
1537 /**
1538 * Estimate the stream timings from the one of each components.
1539 *
1540 * Also computes the global bitrate if possible.
1541 */
1542 static void av_update_stream_timings(AVFormatContext *ic)
1543 {
1544 int64_t start_time, start_time1, end_time, end_time1;
1545 int64_t duration, duration1;
1546 int i;
1547 AVStream *st;
1548
1549 start_time = INT64_MAX;
1550 end_time = INT64_MIN;
1551 duration = INT64_MIN;
1552 for(i = 0;i < ic->nb_streams; i++) {
1553 st = ic->streams[i];
1554 if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
1555 start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
1556 if (start_time1 < start_time)
1557 start_time = start_time1;
1558 if (st->duration != AV_NOPTS_VALUE) {
1559 end_time1 = start_time1
1560 + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1561 if (end_time1 > end_time)
1562 end_time = end_time1;
1563 }
1564 }
1565 if (st->duration != AV_NOPTS_VALUE) {
1566 duration1 = av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1567 if (duration1 > duration)
1568 duration = duration1;
1569 }
1570 }
1571 if (start_time != INT64_MAX) {
1572 ic->start_time = start_time;
1573 if (end_time != INT64_MIN) {
1574 if (end_time - start_time > duration)
1575 duration = end_time - start_time;
1576 }
1577 }
1578 if (duration != INT64_MIN) {
1579 ic->duration = duration;
1580 if (ic->file_size > 0) {
1581 /* compute the bitrate */
1582 ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE /
1583 (double)ic->duration;
1584 }
1585 }
1586 }
1587
1588 static void fill_all_stream_timings(AVFormatContext *ic)
1589 {
1590 int i;
1591 AVStream *st;
1592
1593 av_update_stream_timings(ic);
1594 for(i = 0;i < ic->nb_streams; i++) {
1595 st = ic->streams[i];
1596 if (st->start_time == AV_NOPTS_VALUE) {
1597 if(ic->start_time != AV_NOPTS_VALUE)
1598 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1599 if(ic->duration != AV_NOPTS_VALUE)
1600 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1601 }
1602 }
1603 }
1604
1605 static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1606 {
1607 int64_t filesize, duration;
1608 int bit_rate, i;
1609 AVStream *st;
1610
1611 /* if bit_rate is already set, we believe it */
1612 if (ic->bit_rate == 0) {
1613 bit_rate = 0;
1614 for(i=0;i<ic->nb_streams;i++) {
1615 st = ic->streams[i];
1616 bit_rate += st->codec->bit_rate;
1617 }
1618 ic->bit_rate = bit_rate;
1619 }
1620
1621 /* if duration is already set, we believe it */
1622 if (ic->duration == AV_NOPTS_VALUE &&
1623 ic->bit_rate != 0 &&
1624 ic->file_size != 0) {
1625 filesize = ic->file_size;
1626 if (filesize > 0) {
1627 for(i = 0; i < ic->nb_streams; i++) {
1628 st = ic->streams[i];
1629 duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
1630 if (st->duration == AV_NOPTS_VALUE)
1631 st->duration = duration;
1632 }
1633 }
1634 }
1635 }
1636
1637 #define DURATION_MAX_READ_SIZE 250000
1638
1639 /* only usable for MPEG-PS streams */
1640 static void av_estimate_timings_from_pts(AVFormatContext *ic, offset_t old_offset)
1641 {
1642 AVPacket pkt1, *pkt = &pkt1;
1643 AVStream *st;
1644 int read_size, i, ret;
1645 int64_t end_time;
1646 int64_t filesize, offset, duration;
1647
1648 /* free previous packet */
1649 if (ic->cur_st && ic->cur_st->parser)
1650 av_free_packet(&ic->cur_pkt);
1651 ic->cur_st = NULL;
1652
1653 /* flush packet queue */
1654 flush_packet_queue(ic);
1655
1656 for(i=0;i<ic->nb_streams;i++) {
1657 st = ic->streams[i];
1658 if (st->parser) {
1659 av_parser_close(st->parser);
1660 st->parser= NULL;
1661 }
1662 }
1663
1664 /* we read the first packets to get the first PTS (not fully
1665 accurate, but it is enough now) */
1666 url_fseek(ic->pb, 0, SEEK_SET);
1667 read_size = 0;
1668 for(;;) {
1669 if (read_size >= DURATION_MAX_READ_SIZE)
1670 break;
1671 /* if all info is available, we can stop */
1672 for(i = 0;i < ic->nb_streams; i++) {
1673 st = ic->streams[i];
1674 if (st->start_time == AV_NOPTS_VALUE)
1675 break;
1676 }
1677 if (i == ic->nb_streams)
1678 break;
1679
1680 ret = av_read_packet(ic, pkt);
1681 if (ret != 0)
1682 break;
1683 read_size += pkt->size;
1684 st = ic->streams[pkt->stream_index];
1685 if (pkt->pts != AV_NOPTS_VALUE) {
1686 if (st->start_time == AV_NOPTS_VALUE)
1687 st->start_time = pkt->pts;
1688 }
1689 av_free_packet(pkt);
1690 }
1691
1692 /* estimate the end time (duration) */
1693 /* XXX: may need to support wrapping */
1694 filesize = ic->file_size;
1695 offset = filesize - DURATION_MAX_READ_SIZE;
1696 if (offset < 0)
1697 offset = 0;
1698
1699 url_fseek(ic->pb, offset, SEEK_SET);
1700 read_size = 0;
1701 for(;;) {
1702 if (read_size >= DURATION_MAX_READ_SIZE)
1703 break;
1704
1705 ret = av_read_packet(ic, pkt);
1706 if (ret != 0)
1707 break;
1708 read_size += pkt->size;
1709 st = ic->streams[pkt->stream_index];
1710 if (pkt->pts != AV_NOPTS_VALUE &&
1711 st->start_time != AV_NOPTS_VALUE) {
1712 end_time = pkt->pts;
1713 duration = end_time - st->start_time;
1714 if (duration > 0) {
1715 if (st->duration == AV_NOPTS_VALUE ||
1716 st->duration < duration)
1717 st->duration = duration;
1718 }
1719 }
1720 av_free_packet(pkt);
1721 }
1722
1723 fill_all_stream_timings(ic);
1724
1725 url_fseek(ic->pb, old_offset, SEEK_SET);
1726 for(i=0; i<ic->nb_streams; i++){
1727 st= ic->streams[i];
1728 st->cur_dts= st->first_dts;
1729 st->last_IP_pts = AV_NOPTS_VALUE;
1730 }
1731 }
1732
1733 static void av_estimate_timings(AVFormatContext *ic, offset_t old_offset)
1734 {
1735 int64_t file_size;
1736
1737 /* get the file size, if possible */
1738 if (ic->iformat->flags & AVFMT_NOFILE) {
1739 file_size = 0;
1740 } else {
1741 file_size = url_fsize(ic->pb);
1742 if (file_size < 0)
1743 file_size = 0;
1744 }
1745 ic->file_size = file_size;
1746
1747 if ((!strcmp(ic->iformat->name, "mpeg") ||
1748 !strcmp(ic->iformat->name, "mpegts")) &&
1749 file_size && !url_is_streamed(ic->pb)) {
1750 /* get accurate estimate from the PTSes */
1751 av_estimate_timings_from_pts(ic, old_offset);
1752 } else if (av_has_duration(ic)) {
1753 /* at least one component has timings - we use them for all
1754 the components */
1755 fill_all_stream_timings(ic);
1756 } else {
1757 /* less precise: use bitrate info */
1758 av_estimate_timings_from_bit_rate(ic);
1759 }
1760 av_update_stream_timings(ic);
1761
1762 #if 0
1763 {
1764 int i;
1765 AVStream *st;
1766 for(i = 0;i < ic->nb_streams; i++) {
1767 st = ic->streams[i];
1768 printf("%d: start_time: %0.3f duration: %0.3f\n",
1769 i, (double)st->start_time / AV_TIME_BASE,
1770 (double)st->duration / AV_TIME_BASE);
1771 }
1772 printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
1773 (double)ic->start_time / AV_TIME_BASE,
1774 (double)ic->duration / AV_TIME_BASE,
1775 ic->bit_rate / 1000);
1776 }
1777 #endif
1778 }
1779
1780 static int has_codec_parameters(AVCodecContext *enc)
1781 {
1782 int val;
1783 switch(enc->codec_type) {
1784 case CODEC_TYPE_AUDIO:
1785 val = enc->sample_rate && enc->channels;
1786 if(!enc->frame_size &&
1787 (enc->codec_id == CODEC_ID_VORBIS ||
1788 enc->codec_id == CODEC_ID_AAC))
1789 return 0;
1790 break;
1791 case CODEC_TYPE_VIDEO:
1792 val = enc->width && enc->pix_fmt != PIX_FMT_NONE;
1793 break;
1794 default:
1795 val = 1;
1796 break;
1797 }
1798 return enc->codec_id != CODEC_ID_NONE && val != 0;
1799 }
1800
1801 static int try_decode_frame(AVStream *st, const uint8_t *data, int size)
1802 {
1803 int16_t *samples;
1804 AVCodec *codec;
1805 int got_picture, data_size, ret=0;
1806 AVFrame picture;
1807
1808 if(!st->codec->codec){
1809 codec = avcodec_find_decoder(st->codec->codec_id);
1810 if (!codec)
1811 return -1;
1812 ret = avcodec_open(st->codec, codec);
1813 if (ret < 0)
1814 return ret;
1815 }
1816
1817 if(!has_codec_parameters(st->codec)){
1818 switch(st->codec->codec_type) {
1819 case CODEC_TYPE_VIDEO:
1820 ret = avcodec_decode_video(st->codec, &picture,
1821 &got_picture, data, size);
1822 break;
1823 case CODEC_TYPE_AUDIO:
1824 data_size = FFMAX(size, AVCODEC_MAX_AUDIO_FRAME_SIZE);
1825 samples = av_malloc(data_size);
1826 if (!samples)
1827 goto fail;
1828 ret = avcodec_decode_audio2(st->codec, samples,
1829 &data_size, data, size);
1830 av_free(samples);
1831 break;
1832 default:
1833 break;
1834 }
1835 }
1836 fail:
1837 return ret;
1838 }
1839
1840 unsigned int codec_get_tag(const AVCodecTag *tags, int id)
1841 {
1842 while (tags->id != CODEC_ID_NONE) {
1843 if (tags->id == id)
1844 return tags->tag;
1845 tags++;
1846 }
1847 return 0;
1848 }
1849
1850 enum CodecID codec_get_id(const AVCodecTag *tags, unsigned int tag)
1851 {
1852 int i;
1853 for(i=0; tags[i].id != CODEC_ID_NONE;i++) {
1854 if(tag == tags[i].tag)
1855 return tags[i].id;
1856 }
1857 for(i=0; tags[i].id != CODEC_ID_NONE; i++) {
1858 if( toupper((tag >> 0)&0xFF) == toupper((tags[i].tag >> 0)&0xFF)
1859 && toupper((tag >> 8)&0xFF) == toupper((tags[i].tag >> 8)&0xFF)
1860 && toupper((tag >>16)&0xFF) == toupper((tags[i].tag >>16)&0xFF)
1861 && toupper((tag >>24)&0xFF) == toupper((tags[i].tag >>24)&0xFF))
1862 return tags[i].id;
1863 }
1864 return CODEC_ID_NONE;
1865 }
1866
1867 unsigned int av_codec_get_tag(const AVCodecTag *tags[4], enum CodecID id)
1868 {
1869 int i;
1870 for(i=0; tags && tags[i]; i++){
1871 int tag= codec_get_tag(tags[i], id);
1872 if(tag) return tag;
1873 }
1874 return 0;
1875 }
1876
1877 enum CodecID av_codec_get_id(const AVCodecTag *tags[4], unsigned int tag)
1878 {
1879 int i;
1880 for(i=0; tags && tags[i]; i++){
1881 enum CodecID id= codec_get_id(tags[i], tag);
1882 if(id!=CODEC_ID_NONE) return id;
1883 }
1884 return CODEC_ID_NONE;
1885 }
1886
1887 static void compute_chapters_end(AVFormatContext *s)
1888 {
1889 unsigned int i;
1890
1891 for (i=0; i+1<s->nb_chapters; i++)
1892 if (s->chapters[i]->end == AV_NOPTS_VALUE) {
1893 assert(s->chapters[i]->start <= s->chapters[i+1]->start);
1894 assert(!av_cmp_q(s->chapters[i]->time_base, s->chapters[i+1]->time_base));
1895 s->chapters[i]->end = s->chapters[i+1]->start;
1896 }
1897
1898 if (s->nb_chapters && s->chapters[i]->end == AV_NOPTS_VALUE) {
1899 assert(s->start_time != AV_NOPTS_VALUE);
1900 assert(s->duration > 0);
1901 s->chapters[i]->end = av_rescale_q(s->start_time + s->duration,
1902 AV_TIME_BASE_Q,
1903 s->chapters[i]->time_base);
1904 }
1905 }
1906
1907 /* absolute maximum size we read until we abort */
1908 #define MAX_READ_SIZE 5000000
1909
1910 #define MAX_STD_TIMEBASES (60*12+5)
1911 static int get_std_framerate(int i){
1912 if(i<60*12) return i*1001;
1913 else return ((int[]){24,30,60,12,15})[i-60*12]*1000*12;
1914 }
1915
1916 /*
1917 * Is the time base unreliable.
1918 * This is a heuristic to balance between quick acceptance of the values in
1919 * the headers vs. some extra checks.
1920 * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
1921 * MPEG-2 commonly misuses field repeat flags to store different framerates.
1922 * And there are "variable" fps files this needs to detect as well.
1923 */
1924 static int tb_unreliable(AVCodecContext *c){
1925 if( c->time_base.den >= 101L*c->time_base.num
1926 || c->time_base.den < 5L*c->time_base.num
1927 /* || c->codec_tag == ff_get_fourcc("DIVX")
1928 || c->codec_tag == ff_get_fourcc("XVID")*/
1929 || c->codec_id == CODEC_ID_MPEG2VIDEO)
1930 return 1;
1931 return 0;
1932 }
1933
1934 int av_find_stream_info(AVFormatContext *ic)
1935 {
1936 int i, count, ret, read_size, j;
1937 AVStream *st;
1938 AVPacket pkt1, *pkt;
1939 int64_t last_dts[MAX_STREAMS];
1940 int duration_count[MAX_STREAMS]={0};
1941 double (*duration_error)[MAX_STD_TIMEBASES];
1942 offset_t old_offset = url_ftell(ic->pb);
1943 int64_t codec_info_duration[MAX_STREAMS]={0};
1944 int codec_info_nb_frames[MAX_STREAMS]={0};
1945
1946 duration_error = av_mallocz(MAX_STREAMS * sizeof(*duration_error));
1947 if (!duration_error) return AVERROR(ENOMEM);
1948
1949 for(i=0;i<ic->nb_streams;i++) {
1950 st = ic->streams[i];
1951 if(st->codec->codec_type == CODEC_TYPE_VIDEO){
1952 /* if(!st->time_base.num)
1953 st->time_base= */
1954 if(!st->codec->time_base.num)
1955 st->codec->time_base= st->time_base;
1956 }
1957 //only for the split stuff
1958 if (!st->parser) {
1959 st->parser = av_parser_init(st->codec->codec_id);
1960 if(st->need_parsing == AVSTREAM_PARSE_HEADERS && st->parser){
1961 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1962 }
1963 }
1964 }
1965
1966 for(i=0;i<MAX_STREAMS;i++){
1967 last_dts[i]= AV_NOPTS_VALUE;
1968 }
1969
1970 count = 0;
1971 read_size = 0;
1972 for(;;) {
1973 /* check if one codec still needs to be handled */
1974 for(i=0;i<ic->nb_streams;i++) {
1975 st = ic->streams[i];
1976 if (!has_codec_parameters(st->codec))
1977 break;
1978 /* variable fps and no guess at the real fps */
1979 if( tb_unreliable(st->codec)
1980 && duration_count[i]<20 && st->codec->codec_type == CODEC_TYPE_VIDEO)
1981 break;
1982 if(st->parser && st->parser->parser->split && !st->codec->extradata)
1983 break;
1984 if(st->first_dts == AV_NOPTS_VALUE)
1985 break;
1986 }
1987 if (i == ic->nb_streams) {
1988 /* NOTE: if the format has no header, then we need to read
1989 some packets to get most of the streams, so we cannot
1990 stop here */
1991 if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
1992 /* if we found the info for all the codecs, we can stop */
1993 ret = count;
1994 break;
1995 }
1996 }
1997 /* we did not get all the codec info, but we read too much data */
1998 if (read_size >= MAX_READ_SIZE) {
1999 ret = count;
2000 break;
2001 }
2002
2003 /* NOTE: a new stream can be added there if no header in file
2004 (AVFMTCTX_NOHEADER) */
2005 ret = av_read_frame_internal(ic, &pkt1);
2006 if (ret < 0) {
2007 /* EOF or error */
2008 ret = -1; /* we could not have all the codec parameters before EOF */
2009 for(i=0;i<ic->nb_streams;i++) {
2010 st = ic->streams[i];
2011 if (!has_codec_parameters(st->codec)){
2012 char buf[256];
2013 avcodec_string(buf, sizeof(buf), st->codec, 0);
2014 av_log(ic, AV_LOG_INFO, "Could not find codec parameters (%s)\n", buf);
2015 } else {
2016 ret = 0;
2017 }
2018 }
2019 break;
2020 }
2021
2022 pkt= add_to_pktbuf(&ic->packet_buffer, &pkt1);
2023 if(av_dup_packet(pkt) < 0) {
2024 av_free(duration_error);
2025 return AVERROR(ENOMEM);
2026 }
2027
2028 read_size += pkt->size;
2029
2030 st = ic->streams[pkt->stream_index];
2031 if(codec_info_nb_frames[st->index]>1)
2032 codec_info_duration[st->index] += pkt->duration;
2033 if (pkt->duration != 0)
2034 codec_info_nb_frames[st->index]++;
2035
2036 {
2037 int index= pkt->stream_index;
2038 int64_t last= last_dts[index];
2039 int64_t duration= pkt->dts - last;
2040
2041 if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
2042 double dur= duration * av_q2d(st->time_base);
2043
2044 // if(st->codec->codec_type == CODEC_TYPE_VIDEO)
2045 // av_log(NULL, AV_LOG_ERROR, "%f\n", dur);
2046 if(duration_count[index] < 2)
2047 memset(duration_error[index], 0, sizeof(*duration_error));
2048 for(i=1; i<MAX_STD_TIMEBASES; i++){
2049 int framerate= get_std_framerate(i);
2050 int ticks= lrintf(dur*framerate/(1001*12));
2051 double error= dur - ticks*1001*12/(double)framerate;
2052 duration_error[index][i] += error*error;
2053 }
2054 duration_count[index]++;
2055 }
2056 if(last == AV_NOPTS_VALUE || duration_count[index]<=1)
2057 last_dts[pkt->stream_index]= pkt->dts;
2058 }
2059 if(st->parser && st->parser->parser->split && !st->codec->extradata){
2060 int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
2061 if(i){
2062 st->codec->extradata_size= i;
2063 st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
2064 memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
2065 memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2066 }
2067 }
2068
2069 /* if still no information, we try to open the codec and to
2070 decompress the frame. We try to avoid that in most cases as
2071 it takes longer and uses more memory. For MPEG-4, we need to
2072 decompress for QuickTime. */
2073 if (!has_codec_parameters(st->codec) /*&&
2074 (st->codec->codec_id == CODEC_ID_FLV1 ||
2075 st->codec->codec_id == CODEC_ID_H264 ||
2076 st->codec->codec_id == CODEC_ID_H263 ||
2077 st->codec->codec_id == CODEC_ID_H261 ||
2078 st->codec->codec_id == CODEC_ID_VORBIS ||
2079 st->codec->codec_id == CODEC_ID_MJPEG ||
2080 st->codec->codec_id == CODEC_ID_PNG ||
2081 st->codec->codec_id == CODEC_ID_PAM ||
2082 st->codec->codec_id == CODEC_ID_PGM ||
2083 st->codec->codec_id == CODEC_ID_PGMYUV ||
2084 st->codec->codec_id == CODEC_ID_PBM ||
2085 st->codec->codec_id == CODEC_ID_PPM ||
2086 st->codec->codec_id == CODEC_ID_SHORTEN ||
2087 (st->codec->codec_id == CODEC_ID_MPEG4 && !st->need_parsing))*/)
2088 try_decode_frame(st, pkt->data, pkt->size);
2089
2090 if (st->time_base.den > 0 && av_rescale_q(codec_info_duration[st->index], st->time_base, AV_TIME_BASE_Q) >= ic->max_analyze_duration) {
2091 break;
2092 }
2093 count++;
2094 }
2095
2096 // close codecs which were opened in try_decode_frame()
2097 for(i=0;i<ic->nb_streams;i++) {
2098 st = ic->streams[i];
2099 if(st->codec->codec)
2100 avcodec_close(st->codec);
2101 }
2102 for(i=0;i<ic->nb_streams;i++) {
2103 st = ic->streams[i];
2104 if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
2105 if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_sample)
2106 st->codec->codec_tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
2107
2108 if(duration_count[i]
2109 && tb_unreliable(st->codec) /*&&
2110 //FIXME we should not special-case MPEG-2, but this needs testing with non-MPEG-2 ...
2111 st->time_base.num*duration_sum[i]/duration_count[i]*101LL > st->time_base.den*/){
2112 double best_error= 2*av_q2d(st->time_base);
2113 best_error= best_error*best_error*duration_count[i]*1000*12*30;
2114
2115 for(j=1; j<MAX_STD_TIMEBASES; j++){
2116 double error= duration_error[i][j] * get_std_framerate(j);
2117 // if(st->codec->codec_type == CODEC_TYPE_VIDEO)
2118 // av_log(NULL, AV_LOG_ERROR, "%f %f\n", get_std_framerate(j) / 12.0/1001, error);
2119 if(error < best_error){
2120 best_error= error;
2121 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, get_std_framerate(j), 12*1001, INT_MAX);
2122 }
2123 }
2124 }
2125
2126 if (!st->r_frame_rate.num){
2127 if( st->codec->time_base.den * (int64_t)st->time_base.num
2128 <= st->codec->time_base.num * (int64_t)st->time_base.den){
2129 st->r_frame_rate.num = st->codec->time_base.den;
2130 st->r_frame_rate.den = st->codec->time_base.num;
2131 }else{
2132 st->r_frame_rate.num = st->time_base.den;
2133 st->r_frame_rate.den = st->time_base.num;
2134 }
2135 }
2136 }else if(st->codec->codec_type == CODEC_TYPE_AUDIO) {
2137 if(!st->codec->bits_per_sample)
2138 st->codec->bits_per_sample= av_get_bits_per_sample(st->codec->codec_id);
2139 }
2140 }
2141
2142 av_estimate_timings(ic, old_offset);
2143
2144 compute_chapters_end(ic);
2145
2146 #if 0
2147 /* correct DTS for B-frame streams with no timestamps */
2148 for(i=0;i<ic->nb_streams;i++) {
2149 st = ic->streams[i];
2150 if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
2151 if(b-frames){
2152 ppktl = &ic->packet_buffer;
2153 while(ppkt1){
2154 if(ppkt1->stream_index != i)
2155 continue;
2156 if(ppkt1->pkt->dts < 0)
2157 break;
2158 if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
2159 break;
2160 ppkt1->pkt->dts -= delta;
2161 ppkt1= ppkt1->next;
2162 }
2163 if(ppkt1)
2164 continue;
2165 st->cur_dts -= delta;
2166 }
2167 }
2168 }
2169 #endif
2170
2171 av_free(duration_error);
2172
2173 return ret;
2174 }
2175
2176 /*******************************************************/
2177
2178 int av_read_play(AVFormatContext *s)
2179 {
2180 if (s->iformat->read_play)
2181 return s->iformat->read_play(s);
2182 if (s->pb)
2183 return av_url_read_fpause(s->pb, 0);
2184 return AVERROR(ENOSYS);
2185 }
2186
2187 int av_read_pause(AVFormatContext *s)
2188 {
2189 if (s->iformat->read_pause)
2190 return s->iformat->read_pause(s);
2191 if (s->pb)
2192 return av_url_read_fpause(s->pb, 1);
2193 return AVERROR(ENOSYS);
2194 }
2195
2196 void av_close_input_stream(AVFormatContext *s)
2197 {
2198 int i;
2199 AVStream *st;
2200
2201 /* free previous packet */
2202 if (s->cur_st && s->cur_st->parser)
2203 av_free_packet(&s->cur_pkt);
2204
2205 if (s->iformat->read_close)
2206 s->iformat->read_close(s);
2207 for(i=0;i<s->nb_streams;i++) {
2208 /* free all data in a stream component */
2209 st = s->streams[i];
2210 if (st->parser) {
2211 av_parser_close(st->parser);
2212 }
2213 av_free(st->index_entries);
2214 av_free(st->codec->extradata);
2215 av_free(st->codec);
2216 av_free(st->filename);
2217 av_free(st->priv_data);
2218 av_free(st);
2219 }
2220 for(i=s->nb_programs-1; i>=0; i--) {
2221 av_freep(&s->programs[i]->provider_name);
2222 av_freep(&s->programs[i]->name);
2223 av_freep(&s->programs[i]->stream_index);
2224 av_freep(&s->programs[i]);
2225 }
2226 av_freep(&s->programs);
2227 flush_packet_queue(s);
2228 av_freep(&s->priv_data);
2229 while(s->nb_chapters--) {
2230 av_free(s->chapters[s->nb_chapters]->title);
2231 av_free(s->chapters[s->nb_chapters]);
2232 }
2233 av_freep(&s->chapters);
2234 av_free(s);
2235 }
2236
2237 void av_close_input_file(AVFormatContext *s)
2238 {
2239 ByteIOContext *pb = s->iformat->flags & AVFMT_NOFILE ? NULL : s->pb;
2240 av_close_input_stream(s);
2241 if (pb)
2242 url_fclose(pb);
2243 }
2244
2245 AVStream *av_new_stream(AVFormatContext *s, int id)
2246 {
2247 AVStream *st;
2248 int i;
2249
2250 if (s->nb_streams >= MAX_STREAMS)
2251 return NULL;
2252
2253 st = av_mallocz(sizeof(AVStream));
2254 if (!st)
2255 return NULL;
2256
2257 st->codec= avcodec_alloc_context();
2258 if (s->iformat) {
2259 /* no default bitrate if decoding */
2260 st->codec->bit_rate = 0;
2261 }
2262 st->index = s->nb_streams;
2263 st->id = id;
2264 st->start_time = AV_NOPTS_VALUE;
2265 st->duration = AV_NOPTS_VALUE;
2266 /* we set the current DTS to 0 so that formats without any timestamps
2267 but durations get some timestamps, formats with some unknown
2268 timestamps have their first few packets buffered and the
2269 timestamps corrected before they are returned to the user */
2270 st->cur_dts = 0;
2271 st->first_dts = AV_NOPTS_VALUE;
2272
2273 /* default pts setting is MPEG-like */
2274 av_set_pts_info(st, 33, 1, 90000);
2275 st->last_IP_pts = AV_NOPTS_VALUE;
2276 for(i=0; i<MAX_REORDER_DELAY+1; i++)
2277 st->pts_buffer[i]= AV_NOPTS_VALUE;
2278
2279 s->streams[s->nb_streams++] = st;
2280 return st;
2281 }
2282
2283 AVProgram *av_new_program(AVFormatContext *ac, int id)
2284 {
2285 AVProgram *program=NULL;
2286 int i;
2287
2288 #ifdef DEBUG_SI
2289 av_log(ac, AV_LOG_DEBUG, "new_program: id=0x%04x\n", id);
2290 #endif
2291
2292 for(i=0; i<ac->nb_programs; i++)
2293 if(ac->programs[i]->id == id)
2294 program = ac->programs[i];
2295
2296 if(!program){
2297 program = av_mallocz(sizeof(AVProgram));
2298 if (!program)
2299 return NULL;
2300 dynarray_add(&ac->programs, &ac->nb_programs, program);
2301 program->discard = AVDISCARD_NONE;
2302 }
2303 program->id = id;
2304
2305 return program;
2306 }
2307
2308 void av_set_program_name(AVProgram *program, char *provider_name, char *name)
2309 {
2310 assert(!provider_name == !name);
2311 if(name){
2312 av_free(program->provider_name);
2313 av_free(program-> name);
2314 program->provider_name = av_strdup(provider_name);
2315 program-> name = av_strdup( name);
2316 }
2317 }
2318
2319 AVChapter *ff_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
2320 {
2321 AVChapter *chapter = NULL;
2322 int i;
2323
2324 for(i=0; i<s->nb_chapters; i++)
2325 if(s->chapters[i]->id == id)
2326 chapter = s->chapters[i];
2327
2328 if(!chapter){
2329 chapter= av_mallocz(sizeof(AVChapter));
2330 if(!chapter)
2331 return NULL;
2332 dynarray_add(&s->chapters, &s->nb_chapters, chapter);
2333 }
2334 av_free(chapter->title);
2335 chapter->title = av_strdup(title);
2336 chapter->id = id;
2337 chapter->time_base= time_base;
2338 chapter->start = start;
2339 chapter->end = end;
2340
2341 return chapter;
2342 }
2343
2344 /************************************************************/
2345 /* output media file */
2346
2347 int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2348 {
2349 int ret;
2350
2351 if (s->oformat->priv_data_size > 0) {
2352 s->priv_data = av_mallocz(s->oformat->priv_data_size);
2353 if (!s->priv_data)
2354 return AVERROR(ENOMEM);
2355 } else
2356 s->priv_data = NULL;
2357
2358 if (s->oformat->set_parameters) {
2359 ret = s->oformat->set_parameters(s, ap);
2360 if (ret < 0)
2361 return ret;
2362 }
2363 return 0;
2364 }
2365
2366 int av_write_header(AVFormatContext *s)
2367 {
2368 int ret, i;
2369 AVStream *st;
2370
2371 // some sanity checks
2372 for(i=0;i<s->nb_streams;i++) {
2373 st = s->streams[i];
2374
2375 switch (st->codec->codec_type) {
2376 case CODEC_TYPE_AUDIO:
2377 if(st->codec->sample_rate<=0){
2378 av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2379 return -1;
2380 }
2381 break;
2382 case CODEC_TYPE_VIDEO:
2383 if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2384 av_log(s, AV_LOG_ERROR, "time base not set\n");
2385 return -1;
2386 }
2387 if(st->codec->width<=0 || st->codec->height<=0){
2388 av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2389 return -1;
2390 }
2391 break;
2392 }
2393
2394 if(s->oformat->codec_tag){
2395 if(st->codec->codec_tag){
2396 //FIXME
2397 //check that tag + id is in the table
2398 //if neither is in the table -> OK
2399 //if tag is in the table with another id -> FAIL
2400 //if id is in the table with another tag -> FAIL unless strict < ?
2401 }else
2402 st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2403 }
2404 }
2405
2406 if (!s->priv_data && s->oformat->priv_data_size > 0) {
2407 s->priv_data = av_mallocz(s->oformat->priv_data_size);
2408 if (!s->priv_data)
2409 return AVERROR(ENOMEM);
2410 }
2411
2412 if(s->oformat->write_header){
2413 ret = s->oformat->write_header(s);
2414 if (ret < 0)
2415 return ret;
2416 }
2417
2418 /* init PTS generation */
2419 for(i=0;i<s->nb_streams;i++) {
2420 int64_t den = AV_NOPTS_VALUE;
2421 st = s->streams[i];
2422
2423 switch (st->codec->codec_type) {
2424 case CODEC_TYPE_AUDIO:
2425 den = (int64_t)st->time_base.num * st->codec->sample_rate;
2426 break;
2427 case CODEC_TYPE_VIDEO:
2428 den = (int64_t)st->time_base.num * st->codec->time_base.den;
2429 break;
2430 default:
2431 break;
2432 }
2433 if (den != AV_NOPTS_VALUE) {
2434 if (den <= 0)
2435 return AVERROR_INVALIDDATA;
2436 av_frac_init(&st->pts, 0, 0, den);
2437 }
2438 }
2439 return 0;
2440 }
2441
2442 //FIXME merge with compute_pkt_fields
2443 static int compute_pkt_fields2(AVStream *st, AVPacket *pkt){
2444 int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2445 int num, den, frame_size, i;
2446
2447 // av_log(st->codec, AV_LOG_DEBUG, "av_write_frame: pts:%"PRId64" dts:%"PRId64" cur_dts:%"PRId64" b:%d size:%d st:%d\n", pkt->pts, pkt->dts, st->cur_dts, delay, pkt->size, pkt->stream_index);
2448
2449 /* if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2450 return -1;*/
2451
2452 /* duration field */
2453 if (pkt->duration == 0) {
2454 compute_frame_duration(&num, &den, st, NULL, pkt);
2455 if (den && num) {
2456 pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
2457 }
2458 }
2459
2460 if(pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay==0)
2461 pkt->pts= pkt->dts;
2462
2463 //XXX/FIXME this is a temporary hack until all encoders output pts
2464 if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
2465 pkt->dts=
2466 // pkt->pts= st->cur_dts;
2467 pkt->pts= st->pts.val;
2468 }
2469
2470 //calculate dts from pts
2471 if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE){
2472 st->pts_buffer[0]= pkt->pts;
2473 for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2474 st->pts_buffer[i]= (i-delay-1) * pkt->duration;
2475 for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
2476 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2477
2478 pkt->dts= st->pts_buffer[0];
2479 }
2480
2481 if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2482 av_log(st->codec, AV_LOG_ERROR, "error, non monotone timestamps %"PRId64" >= %"PRId64"\n", st->cur_dts, pkt->dts);
2483 return -1;
2484 }
2485 if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2486 av_log(st->codec, AV_LOG_ERROR, "error, pts < dts\n");
2487 return -1;
2488 }
2489
2490 // av_log(NULL, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
2491 st->cur_dts= pkt->dts;
2492 st->pts.val= pkt->dts;
2493
2494 /* update pts */
2495 switch (st->codec->codec_type) {
2496 case CODEC_TYPE_AUDIO:
2497 frame_size = get_audio_frame_size(st->codec, pkt->size);
2498
2499 /* HACK/FIXME, we skip the initial 0 size packets as they are most
2500 likely equal to the encoder delay, but it would be better if we
2501 had the real timestamps from the encoder */
2502 if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2503 av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
2504 }
2505 break;
2506 case CODEC_TYPE_VIDEO:
2507 av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
2508 break;
2509 default:
2510 break;
2511 }
2512 return 0;
2513 }
2514
2515 static void truncate_ts(AVStream *st, AVPacket *pkt){
2516 int64_t pts_mask = (2LL << (st->pts_wrap_bits-1)) - 1;
2517
2518 // if(pkt->dts < 0)
2519 // pkt->dts= 0; //this happens for low_delay=0 and B-frames, FIXME, needs further investigation about what we should do here
2520
2521 if (pkt->pts != AV_NOPTS_VALUE)
2522 pkt->pts &= pts_mask;
2523 if (pkt->dts != AV_NOPTS_VALUE)
2524 pkt->dts &= pts_mask;
2525 }
2526
2527 int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2528 {
2529 int ret = compute_pkt_fields2(s->streams[pkt->stream_index], pkt);
2530
2531 if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2532 return ret;
2533
2534 truncate_ts(s->streams[pkt->stream_index], pkt);
2535
2536 ret= s->oformat->write_packet(s, pkt);
2537 if(!ret)
2538 ret= url_ferror(s->pb);
2539 return ret;
2540 }
2541
2542 int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
2543 AVPacketList *pktl, **next_point, *this_pktl;
2544 int stream_count=0;
2545 int streams[MAX_STREAMS];
2546
2547 if(pkt){
2548 AVStream *st= s->streams[ pkt->stream_index];
2549
2550 // assert(pkt->destruct != av_destruct_packet); //FIXME
2551
2552 this_pktl = av_mallocz(sizeof(AVPacketList));
2553 this_pktl->pkt= *pkt;
2554 if(pkt->destruct == av_destruct_packet)
2555 pkt->destruct= NULL; // not shared -> must keep original from being freed
2556 else
2557 av_dup_packet(&this_pktl->pkt); //shared -> must dup
2558
2559 next_point = &s->packet_buffer;
2560 while(*next_point){
2561 AVStream *st2= s->streams[ (*next_point)->pkt.stream_index];
2562 int64_t left= st2->time_base.num * (int64_t)st ->time_base.den;
2563 int64_t right= st ->time_base.num * (int64_t)st2->time_base.den;
2564 if((*next_point)->pkt.dts * left > pkt->dts * right) //FIXME this can overflow
2565 break;
2566 next_point= &(*next_point)->next;
2567 }
2568 this_pktl->next= *next_point;
2569 *next_point= this_pktl;
2570 }
2571
2572 memset(streams, 0, sizeof(streams));
2573 pktl= s->packet_buffer;
2574 while(pktl){
2575 //av_log(s, AV_LOG_DEBUG, "show st:%d dts:%"PRId64"\n", pktl->pkt.stream_index, pktl->pkt.dts);
2576 if(streams[ pktl->pkt.stream_index ] == 0)
2577 stream_count++;
2578 streams[ pktl->pkt.stream_index ]++;
2579 pktl= pktl->next;
2580 }
2581
2582 if(stream_count && (s->nb_streams == stream_count || flush)){
2583 pktl= s->packet_buffer;
2584 *out= pktl->pkt;
2585
2586 s->packet_buffer= pktl->next;
2587 av_freep(&pktl);
2588 return 1;
2589 }else{
2590 av_init_packet(out);
2591 return 0;
2592 }
2593 }
2594
2595 /**
2596 * Interleaves an AVPacket correctly so it can be muxed.
2597 * @param out the interleaved packet will be output here
2598 * @param in the input packet
2599 * @param flush 1 if no further packets are available as input and all
2600 * remaining packets should be output
2601 * @return 1 if a packet was output, 0 if no packet could be output,
2602 * < 0 if an error occurred
2603 */
2604 static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
2605 if(s->oformat->interleave_packet)
2606 return s->oformat->interleave_packet(s, out, in, flush);
2607 else
2608 return av_interleave_packet_per_dts(s, out, in, flush);
2609 }
2610
2611 int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
2612 AVStream *st= s->streams[ pkt->stream_index];
2613
2614 //FIXME/XXX/HACK drop zero sized packets
2615 if(st->codec->codec_type == CODEC_TYPE_AUDIO && pkt->size==0)
2616 return 0;
2617
2618 //av_log(NULL, AV_LOG_DEBUG, "av_interleaved_write_frame %d %"PRId64" %"PRId64"\n", pkt->size, pkt->dts, pkt->pts);
2619 if(compute_pkt_fields2(st, pkt) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2620 return -1;
2621
2622 if(pkt->dts == AV_NOPTS_VALUE)
2623 return -1;
2624
2625 for(;;){
2626 AVPacket opkt;
2627 int ret= av_interleave_packet(s, &opkt, pkt, 0);
2628 if(ret<=0) //FIXME cleanup needed for ret<0 ?
2629 return ret;
2630
2631 truncate_ts(s->streams[opkt.stream_index], &opkt);
2632 ret= s->oformat->write_packet(s, &opkt);
2633
2634 av_free_packet(&opkt);
2635 pkt= NULL;
2636
2637 if(ret<0)
2638 return ret;
2639 if(url_ferror(s->pb))
2640 return url_ferror(s->pb);
2641 }
2642 }
2643
2644 int av_write_trailer(AVFormatContext *s)
2645 {
2646 int ret, i;
2647
2648 for(;;){
2649 AVPacket pkt;
2650 ret= av_interleave_packet(s, &pkt, NULL, 1);
2651 if(ret<0) //FIXME cleanup needed for ret<0 ?
2652 goto fail;
2653 if(!ret)
2654 break;
2655
2656 truncate_ts(s->streams[pkt.stream_index], &pkt);
2657 ret= s->oformat->write_packet(s, &pkt);
2658
2659 av_free_packet(&pkt);
2660
2661 if(ret<0)
2662 goto fail;
2663 if(url_ferror(s->pb))
2664 goto fail;
2665 }
2666
2667 if(s->oformat->write_trailer)
2668 ret = s->oformat->write_trailer(s);
2669 fail:
2670 if(ret == 0)
2671 ret=url_ferror(s->pb);
2672 for(i=0;i<s->nb_streams;i++)
2673 av_freep(&s->streams[i]->priv_data);
2674 av_freep(&s->priv_data);
2675 return ret;
2676 }
2677
2678 void av_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
2679 {
2680 int i, j;
2681 AVProgram *program=NULL;
2682 void *tmp;
2683
2684 for(i=0; i<ac->nb_programs; i++){
2685 if(ac->programs[i]->id != progid)
2686 continue;
2687 program = ac->programs[i];
2688 for(j=0; j<program->nb_stream_indexes; j++)
2689 if(program->stream_index[j] == idx)
2690 return;
2691
2692 tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
2693 if(!tmp)
2694 return;
2695 program->stream_index = tmp;
2696 program->stream_index[program->nb_stream_indexes++] = idx;
2697 return;
2698 }
2699 }
2700
2701 /* "user interface" functions */
2702 static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
2703 {
2704 char buf[256];
2705 int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
2706 AVStream *st = ic->streams[i];
2707 int g = ff_gcd(st->time_base.num, st->time_base.den);
2708 avcodec_string(buf, sizeof(buf), st->codec, is_output);
2709 av_log(NULL, AV_LOG_INFO, " Stream #%d.%d", index, i);
2710 /* the pid is an important information, so we display it */
2711 /* XXX: add a generic system */
2712 if (flags & AVFMT_SHOW_IDS)
2713 av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
2714 if (strlen(st->language) > 0)
2715 av_log(NULL, AV_LOG_INFO, "(%s)", st->language);
2716 av_log(NULL, AV_LOG_DEBUG, ", %d/%d", st->time_base.num/g, st->time_base.den/g);
2717 av_log(NULL, AV_LOG_INFO, ": %s", buf);
2718 if(st->codec->codec_type == CODEC_TYPE_VIDEO){
2719 if(st->r_frame_rate.den && st->r_frame_rate.num)
2720 av_log(NULL, AV_LOG_INFO, ", %5.2f tb(r)", av_q2d(st->r_frame_rate));
2721 /* else if(st->time_base.den && st->time_base.num)
2722 av_log(NULL, AV_LOG_INFO, ", %5.2f tb(m)", 1/av_q2d(st->time_base));*/
2723 else
2724 av_log(NULL, AV_LOG_INFO, ", %5.2f tb(c)", 1/av_q2d(st->codec->time_base));
2725 }
2726 av_log(NULL, AV_LOG_INFO, "\n");
2727 }
2728
2729 void dump_format(AVFormatContext *ic,
2730 int index,
2731 const char *url,
2732 int is_output)
2733 {
2734 int i;
2735
2736 av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
2737 is_output ? "Output" : "Input",
2738 index,
2739 is_output ? ic->oformat->name : ic->iformat->name,
2740 is_output ? "to" : "from", url);
2741 if (!is_output) {
2742 av_log(NULL, AV_LOG_INFO, " Duration: ");
2743 if (ic->duration != AV_NOPTS_VALUE) {
2744 int hours, mins, secs, us;
2745 secs = ic->duration / AV_TIME_BASE;
2746 us = ic->duration % AV_TIME_BASE;
2747 mins = secs / 60;
2748 secs %= 60;
2749 hours = mins / 60;
2750 mins %= 60;
2751 av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
2752 (100 * us) / AV_TIME_BASE);
2753 } else {
2754 av_log(NULL, AV_LOG_INFO, "N/A");
2755 }
2756 if (ic->start_time != AV_NOPTS_VALUE) {
2757 int secs, us;
2758 av_log(NULL, AV_LOG_INFO, ", start: ");
2759 secs = ic->start_time / AV_TIME_BASE;
2760 us = ic->start_time % AV_TIME_BASE;
2761 av_log(NULL, AV_LOG_INFO, "%d.%06d",
2762 secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
2763 }
2764 av_log(NULL, AV_LOG_INFO, ", bitrate: ");
2765 if (ic->bit_rate) {
2766 av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
2767 } else {
2768 av_log(NULL, AV_LOG_INFO, "N/A");
2769 }
2770 av_log(NULL, AV_LOG_INFO, "\n");
2771 }
2772 if(ic->nb_programs) {
2773 int j, k;
2774 for(j=0; j<ic->nb_programs; j++) {
2775 av_log(NULL, AV_LOG_INFO, " Program %d %s\n", ic->programs[j]->id,
2776 ic->programs[j]->name ? ic->programs[j]->name : "");
2777 for(k=0; k<ic->programs[j]->nb_stream_indexes; k++)
2778 dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
2779 }
2780 } else
2781 for(i=0;i<ic->nb_streams;i++)
2782 dump_stream_format(ic, i, index, is_output);
2783 }
2784
2785 int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
2786 {
2787 return av_parse_video_frame_size(width_ptr, height_ptr, str);
2788 }
2789
2790 int parse_frame_rate(int *frame_rate_num, int *frame_rate_den, const char *arg)
2791 {
2792 AVRational frame_rate;
2793 int ret = av_parse_video_frame_rate(&frame_rate, arg);
2794 *frame_rate_num= frame_rate.num;
2795 *frame_rate_den= frame_rate.den;
2796 return ret;
2797 }
2798
2799 /**
2800 * Gets the current time in microseconds.
2801 */
2802 int64_t av_gettime(void)
2803 {
2804 struct timeval tv;
2805 gettimeofday(&tv,NULL);
2806 return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
2807 }
2808
2809 int64_t parse_date(const char *datestr, int duration)
2810 {
2811 const char *p;
2812 int64_t t;
2813 struct tm dt;
2814 int i;
2815 static const char *date_fmt[] = {
2816 "%Y-%m-%d",
2817 "%Y%m%d",
2818 };
2819 static const char *time_fmt[] = {
2820 "%H:%M:%S",
2821 "%H%M%S",
2822 };
2823 const char *q;
2824 int is_utc, len;
2825 char lastch;
2826 int negative = 0;
2827
2828 #undef time
2829 time_t now = time(0);
2830
2831 len = strlen(datestr);
2832 if (len > 0)
2833 lastch = datestr[len - 1];
2834 else
2835 lastch = '\0';
2836 is_utc = (lastch == 'z' || lastch == 'Z');
2837
2838 memset(&dt, 0, sizeof(dt));
2839
2840 p = datestr;
2841 q = NULL;
2842 if (!duration) {
2843 /* parse the year-month-day part */
2844 for (i = 0; i < sizeof(date_fmt) / sizeof(date_fmt[0]); i++) {
2845 q = small_strptime(p, date_fmt[i], &dt);
2846 if (q) {
2847 break;
2848 }
2849 }
2850
2851 /* if the year-month-day part is missing, then take the
2852 * current year-month-day time */
2853 if (!q) {
2854 if (is_utc) {
2855 dt = *gmtime(&now);
2856 } else {
2857 dt = *localtime(&now);
2858 }
2859 dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
2860 } else {
2861 p = q;
2862 }
2863
2864 if (*p == 'T' || *p == 't' || *p == ' ')
2865 p++;
2866
2867 /* parse the hour-minute-second part */
2868 for (i = 0; i < sizeof(time_fmt) / sizeof(time_fmt[0]); i++) {
2869 q = small_strptime(p, time_fmt[i], &dt);
2870 if (q) {
2871 break;
2872 }
2873 }
2874 } else {
2875 /* parse datestr as a duration */
2876 if (p[0] == '-') {
2877 negative = 1;
2878 ++p;
2879 }
2880 /* parse datestr as HH:MM:SS */
2881 q = small_strptime(p, time_fmt[0], &dt);
2882 if (!q) {
2883 /* parse datestr as S+ */
2884 dt.tm_sec = strtol(p, (char **)&q, 10);
2885 if (q == p)
2886 /* the parsing didn't succeed */
2887 return INT64_MIN;
2888 dt.tm_min = 0;
2889 dt.tm_hour = 0;
2890 }
2891 }
2892
2893 /* Now we have all the fields that we can get */
2894 if (!q) {
2895 return INT64_MIN;
2896 }
2897
2898 if (duration) {
2899 t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
2900 } else {
2901 dt.tm_isdst = -1; /* unknown */
2902 if (is_utc) {
2903 t = mktimegm(&dt);
2904 } else {
2905 t = mktime(&dt);
2906 }
2907 }
2908
2909 t *= 1000000;
2910
2911 /* parse the .m... part */
2912 if (*q == '.') {
2913 int val, n;
2914 q++;
2915 for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
2916 if (!isdigit(*q))
2917 break;
2918 val += n * (*q - '0');
2919 }
2920 t += val;
2921 }
2922 return negative ? -t : t;
2923 }
2924
2925 int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
2926 {
2927 const char *p;
2928 char tag[128], *q;
2929
2930 p = info;
2931 if (*p == '?')
2932 p++;
2933 for(;;) {
2934 q = tag;
2935 while (*p != '\0' && *p != '=' && *p != '&') {
2936 if ((q - tag) < sizeof(tag) - 1)
2937 *q++ = *p;
2938 p++;
2939 }
2940 *q = '\0';
2941 q = arg;
2942 if (*p == '=') {
2943 p++;
2944 while (*p != '&' && *p != '\0') {
2945 if ((q - arg) < arg_size - 1) {
2946 if (*p == '+')
2947 *q++ = ' ';
2948 else
2949 *q++ = *p;
2950 }
2951 p++;
2952 }
2953 *q = '\0';
2954 }
2955 if (!strcmp(tag, tag1))
2956 return 1;
2957 if (*p != '&')
2958 break;
2959 p++;
2960 }
2961 return 0;
2962 }
2963
2964 int av_get_frame_filename(char *buf, int buf_size,
2965 const char *path, int number)
2966 {
2967 const char *p;
2968 char *q, buf1[20], c;
2969 int nd, len, percentd_found;
2970
2971 q = buf;
2972 p = path;
2973 percentd_found = 0;
2974 for(;;) {
2975 c = *p++;
2976 if (c == '\0')
2977 break;
2978 if (c == '%') {
2979 do {
2980 nd = 0;
2981 while (isdigit(*p)) {
2982 nd = nd * 10 + *p++ - '0';
2983 }
2984 c = *p++;
2985 } while (isdigit(c));
2986
2987 switch(c) {
2988 case '%':
2989 goto addchar;
2990 case 'd':
2991 if (percentd_found)
2992 goto fail;
2993 percentd_found = 1;
2994 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
2995 len = strlen(buf1);
2996 if ((q - buf + len) > buf_size - 1)
2997 goto fail;
2998 memcpy(q, buf1, len);
2999 q += len;
3000 break;
3001 default:
3002 goto fail;
3003 }
3004 } else {
3005 addchar:
3006 if ((q - buf) < buf_size - 1)
3007 *q++ = c;
3008 }
3009 }
3010 if (!percentd_found)
3011 goto fail;
3012 *q = '\0';
3013 return 0;
3014 fail:
3015 *q = '\0';
3016 return -1;
3017 }
3018
3019 static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
3020 {
3021 int len, i, j, c;
3022 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3023
3024 for(i=0;i<size;i+=16) {
3025 len = size - i;
3026 if (len > 16)
3027 len = 16;
3028 PRINT("%08x ", i);
3029 for(j=0;j<16;j++) {
3030 if (j < len)
3031 PRINT(" %02x", buf[i+j]);
3032 else
3033 PRINT(" ");
3034 }
3035 PRINT(" ");
3036 for(j=0;j<len;j++) {
3037 c = buf[i+j];
3038 if (c < ' ' || c > '~')
3039 c = '.';
3040 PRINT("%c", c);
3041 }
3042 PRINT("\n");
3043 }
3044 #undef PRINT
3045 }
3046
3047 void av_hex_dump(FILE *f, uint8_t *buf, int size)
3048 {
3049 hex_dump_internal(NULL, f, 0, buf, size);
3050 }
3051
3052 void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
3053 {
3054 hex_dump_internal(avcl, NULL, level, buf, size);
3055 }
3056
3057 //FIXME needs to know the time_base
3058 static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload)
3059 {
3060 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3061 PRINT("stream #%d:\n", pkt->stream_index);
3062 PRINT(" keyframe=%d\n", ((pkt->flags & PKT_FLAG_KEY) != 0));
3063 PRINT(" duration=%0.3f\n", (double)pkt->duration / AV_TIME_BASE);
3064 /* DTS is _always_ valid after av_read_frame() */
3065 PRINT(" dts=");
3066 if (pkt->dts == AV_NOPTS_VALUE)
3067 PRINT("N/A");
3068 else
3069 PRINT("%0.3f", (double)pkt->dts / AV_TIME_BASE);
3070 /* PTS may not be known if B-frames are present. */
3071 PRINT(" pts=");
3072 if (pkt->pts == AV_NOPTS_VALUE)
3073 PRINT("N/A");
3074 else
3075 PRINT("%0.3f", (double)pkt->pts / AV_TIME_BASE);
3076 PRINT("\n");
3077 PRINT(" size=%d\n", pkt->size);
3078 #undef PRINT
3079 if (dump_payload)
3080 av_hex_dump(f, pkt->data, pkt->size);
3081 }
3082
3083 void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
3084 {
3085 pkt_dump_internal(NULL, f, 0, pkt, dump_payload);
3086 }
3087
3088 void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
3089 {
3090 pkt_dump_internal(avcl, NULL, level, pkt, dump_payload);
3091 }
3092
3093 void url_split(char *proto, int proto_size,
3094 char *authorization, int authorization_size,
3095 char *hostname, int hostname_size,
3096 int *port_ptr,
3097 char *path, int path_size,
3098 const char *url)
3099 {
3100 const char *p, *ls, *at, *col, *brk;
3101
3102 if (port_ptr) *port_ptr = -1;
3103 if (proto_size > 0) proto[0] = 0;
3104 if (authorization_size > 0) authorization[0] = 0;
3105 if (hostname_size > 0) hostname[0] = 0;
3106 if (path_size > 0) path[0] = 0;
3107
3108 /* parse protocol */
3109 if ((p = strchr(url, ':'))) {
3110 av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3111 p++; /* skip ':' */
3112 if (*p == '/') p++;
3113 if (*p == '/') p++;
3114 } else {
3115 /* no protocol means plain filename */
3116 av_strlcpy(path, url, path_size);
3117 return;
3118 }
3119
3120 /* separate path from hostname */
3121 ls = strchr(p, '/');
3122 if(!ls)
3123 ls = strchr(p, '?');
3124 if(ls)
3125 av_strlcpy(path, ls, path_size);
3126 else
3127 ls = &p[strlen(p)]; // XXX
3128
3129 /* the rest is hostname, use that to parse auth/port */
3130 if (ls != p) {
3131 /* authorization (user[:pass]@hostname) */
3132 if ((at = strchr(p, '@')) && at < ls) {
3133 av_strlcpy(authorization, p,
3134 FFMIN(authorization_size, at + 1 - p));
3135 p = at + 1; /* skip '@' */
3136 }
3137
3138 if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3139 /* [host]:port */
3140 av_strlcpy(hostname, p + 1,
3141 FFMIN(hostname_size, brk - p));
3142 if (brk[1] == ':' && port_ptr)
3143 *port_ptr = atoi(brk + 2);
3144 } else if ((col = strchr(p, ':')) && col < ls) {
3145 av_strlcpy(hostname, p,
3146 FFMIN(col + 1 - p, hostname_size));
3147 if (port_ptr) *port_ptr = atoi(col + 1);
3148 } else
3149 av_strlcpy(hostname, p,
3150 FFMIN(ls + 1 - p, hostname_size));
3151 }
3152 }
3153
3154 void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3155 int pts_num, int pts_den)
3156 {
3157 unsigned int gcd= ff_gcd(pts_num, pts_den);
3158 s->pts_wrap_bits = pts_wrap_bits;
3159 s->time_base.num = pts_num/gcd;
3160 s->time_base.den = pts_den/gcd;
3161
3162 if(gcd>1)
3163 av_log(NULL, AV_LOG_DEBUG, "st:%d removing common factor %d from timebase\n", s->index, gcd);
3164 }
3165
3166 /* fraction handling */
3167
3168 /**
3169 * f = val + (num / den) + 0.5.
3170 *
3171 * 'num' is normalized so that it is such as 0 <= num < den.
3172 *
3173 * @param f fractional number
3174 * @param val integer value
3175 * @param num must be >= 0
3176 * @param den must be >= 1
3177 */
3178 static void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
3179 {
3180 num += (den >> 1);
3181 if (num >= den) {
3182 val += num / den;
3183 num = num % den;
3184 }
3185 f->val = val;
3186 f->num = num;
3187 f->den = den;
3188 }
3189
3190 /**
3191 * Fractional addition to f: f = f + (incr / f->den).
3192 *
3193 * @param f fractional number
3194 * @param incr increment, can be positive or negative
3195 */
3196 static void av_frac_add(AVFrac *f, int64_t incr)
3197 {
3198 int64_t num, den;
3199
3200 num = f->num + incr;
3201 den = f->den;
3202 if (num < 0) {
3203 f->val += num / den;
3204 num = num % den;
3205 if (num < 0) {
3206 num += den;
3207 f->val--;
3208 }
3209 } else if (num >= den) {
3210 f->val += num / den;
3211 num = num % den;
3212 }
3213 f->num = num;
3214 }
VDPAU for FFmpeg