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