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