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