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