Change implementation for ff_data_to_hex(), this is faster. See discussion on
[libav.git] / libavformat / utils.c
CommitLineData
de6d9b64 1/*
a85736f2 2 * various utility functions for use within FFmpeg
19720f15 3 * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
de6d9b64 4 *
b78e7197
DB
5 * This file is part of FFmpeg.
6 *
7 * FFmpeg is free software; you can redistribute it and/or
19720f15
FB
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
b78e7197 10 * version 2.1 of the License, or (at your option) any later version.
de6d9b64 11 *
b78e7197 12 * FFmpeg is distributed in the hope that it will be useful,
de6d9b64 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19720f15
FB
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
de6d9b64 16 *
19720f15 17 * You should have received a copy of the GNU Lesser General Public
b78e7197 18 * License along with FFmpeg; if not, write to the Free Software
5509bffa 19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
de6d9b64 20 */
8be1c656 21#include "avformat.h"
f1c80e35 22#include "internal.h"
245976da
DB
23#include "libavcodec/opt.h"
24#include "libavutil/avstring.h"
45da8124 25#include "riff.h"
82e4ac2c
RP
26#include <sys/time.h>
27#include <time.h>
ea452b54 28#include <strings.h>
c5510dd6 29
b754978a
MN
30#undef NDEBUG
31#include <assert.h>
32
e36bdf8b
DK
33/**
34 * @file libavformat/utils.c
a85736f2 35 * various utility functions for use within FFmpeg
e36bdf8b
DK
36 */
37
c97429e2
SS
38unsigned avformat_version(void)
39{
40 return LIBAVFORMAT_VERSION_INT;
41}
42
8163c870
SS
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 */
55static 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 */
73static 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}
f3a30e3a 92
a85736f2 93/** head of registered input format linked list */
8b69867f 94AVInputFormat *first_iformat = NULL;
a85736f2 95/** head of registered output format linked list */
8b69867f 96AVOutputFormat *first_oformat = NULL;
de6d9b64 97
84be6e72
MN
98AVInputFormat *av_iformat_next(AVInputFormat *f)
99{
100 if(f) return f->next;
101 else return first_iformat;
102}
103
104AVOutputFormat *av_oformat_next(AVOutputFormat *f)
105{
106 if(f) return f->next;
107 else return first_oformat;
108}
109
b9a281db 110void av_register_input_format(AVInputFormat *format)
de6d9b64 111{
b9a281db
FB
112 AVInputFormat **p;
113 p = &first_iformat;
114 while (*p != NULL) p = &(*p)->next;
115 *p = format;
116 format->next = NULL;
117}
118
119void av_register_output_format(AVOutputFormat *format)
120{
121 AVOutputFormat **p;
122 p = &first_oformat;
de6d9b64
FB
123 while (*p != NULL) p = &(*p)->next;
124 *p = format;
125 format->next = NULL;
126}
127
5b25dfa7 128int match_ext(const char *filename, const char *extensions)
de6d9b64
FB
129{
130 const char *ext, *p;
131 char ext1[32], *q;
132
293ed23f
MN
133 if(!filename)
134 return 0;
115329f1 135
de6d9b64
FB
136 ext = strrchr(filename, '.');
137 if (ext) {
138 ext++;
139 p = extensions;
140 for(;;) {
141 q = ext1;
115329f1 142 while (*p != '\0' && *p != ',' && q-ext1<sizeof(ext1)-1)
de6d9b64
FB
143 *q++ = *p++;
144 *q = '\0';
115329f1 145 if (!strcasecmp(ext1, ext))
de6d9b64 146 return 1;
115329f1 147 if (*p == '\0')
de6d9b64
FB
148 break;
149 p++;
150 }
151 }
152 return 0;
153}
154
115329f1 155AVOutputFormat *guess_format(const char *short_name, const char *filename,
b9a281db 156 const char *mime_type)
de6d9b64 157{
b9a281db 158 AVOutputFormat *fmt, *fmt_found;
de6d9b64
FB
159 int score_max, score;
160
87a0a681 161 /* specific test for image sequences */
ff70e601 162#ifdef CONFIG_IMAGE2_MUXER
115329f1 163 if (!short_name && filename &&
5c07cf53 164 av_filename_number_test(filename) &&
5b6d5596
MN
165 av_guess_image2_codec(filename) != CODEC_ID_NONE) {
166 return guess_format("image2", NULL, NULL);
167 }
ff70e601 168#endif
a85736f2 169 /* Find the proper file type. */
de6d9b64
FB
170 fmt_found = NULL;
171 score_max = 0;
b9a281db 172 fmt = first_oformat;
de6d9b64
FB
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;
115329f1 179 if (filename && fmt->extensions &&
de6d9b64
FB
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;
115329f1 190}
de6d9b64 191
115329f1 192AVOutputFormat *guess_stream_format(const char *short_name, const char *filename,
c5510dd6
PG
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
115329f1 211enum CodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name,
5b6d5596
MN
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
ff70e601 216#ifdef CONFIG_IMAGE2_MUXER
ae214ac3 217 if(!strcmp(fmt->name, "image2") || !strcmp(fmt->name, "image2pipe")){
5b6d5596
MN
218 codec_id= av_guess_image2_codec(filename);
219 }
ff70e601 220#endif
5b6d5596
MN
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
b9a281db
FB
230AVInputFormat *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
de6d9b64
FB
240/* memory handling */
241
90ad92b3 242void av_destruct_packet(AVPacket *pkt)
6fa5a56c
FB
243{
244 av_free(pkt->data);
245 pkt->data = NULL; pkt->size = 0;
246}
247
659596f0
RP
248void 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
de6d9b64
FB
259int av_new_packet(AVPacket *pkt, int size)
260{
55bdd34d 261 uint8_t *data;
568e18b1 262 if((unsigned)size > (unsigned)size + FF_INPUT_BUFFER_PADDING_SIZE)
769e10f0 263 return AVERROR(ENOMEM);
568e18b1 264 data = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
6fa5a56c 265 if (!data)
769e10f0 266 return AVERROR(ENOMEM);
6fa5a56c 267 memset(data + size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
8cd5be98 268
6fa5a56c 269 av_init_packet(pkt);
115329f1 270 pkt->data = data;
6fa5a56c
FB
271 pkt->size = size;
272 pkt->destruct = av_destruct_packet;
de6d9b64
FB
273 return 0;
274}
275
2692067a
MN
276int 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
fb2758c8
FB
294int av_dup_packet(AVPacket *pkt)
295{
296 if (pkt->destruct != av_destruct_packet) {
297 uint8_t *data;
a85736f2 298 /* We duplicate the packet and don't forget to add the padding again. */
568e18b1 299 if((unsigned)pkt->size > (unsigned)pkt->size + FF_INPUT_BUFFER_PADDING_SIZE)
769e10f0 300 return AVERROR(ENOMEM);
8a56ac7b 301 data = av_malloc(pkt->size + FF_INPUT_BUFFER_PADDING_SIZE);
fb2758c8 302 if (!data) {
769e10f0 303 return AVERROR(ENOMEM);
fb2758c8
FB
304 }
305 memcpy(data, pkt->data, pkt->size);
8a56ac7b 306 memset(data + pkt->size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
fb2758c8
FB
307 pkt->data = data;
308 pkt->destruct = av_destruct_packet;
309 }
310 return 0;
311}
312
5c07cf53 313int av_filename_number_test(const char *filename)
b9a281db
FB
314{
315 char buf[1024];
5c07cf53 316 return filename && (av_get_frame_filename(buf, sizeof(buf), filename, 1)>=0);
b9a281db
FB
317}
318
79750486 319static AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max)
b9a281db
FB
320{
321 AVInputFormat *fmt1, *fmt;
79750486 322 int score;
b9a281db
FB
323
324 fmt = NULL;
b9a281db 325 for(fmt1 = first_iformat; fmt1 != NULL; fmt1 = fmt1->next) {
b8e705ec 326 if (!is_opened == !(fmt1->flags & AVFMT_NOFILE))
b9a281db
FB
327 continue;
328 score = 0;
a8dbe951
PG
329 if (fmt1->read_probe) {
330 score = fmt1->read_probe(pd);
331 } else if (fmt1->extensions) {
b9a281db
FB
332 if (match_ext(pd->filename, fmt1->extensions)) {
333 score = 50;
334 }
115329f1 335 }
79750486
MN
336 if (score > *score_max) {
337 *score_max = score;
b9a281db 338 fmt = fmt1;
4b3cca36
MN
339 }else if (score == *score_max)
340 fmt = NULL;
b9a281db
FB
341 }
342 return fmt;
343}
344
79750486
MN
345AVInputFormat *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
64cd3108
MN
350static 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) {
f1588ed5 356 if (!strcmp(fmt->name, "mp3")) {
64cd3108 357 st->codec->codec_id = CODEC_ID_MP3;
f1588ed5
358 st->codec->codec_type = CODEC_TYPE_AUDIO;
359 } else if (!strcmp(fmt->name, "ac3")) {
64cd3108 360 st->codec->codec_id = CODEC_ID_AC3;
f1588ed5
361 st->codec->codec_type = CODEC_TYPE_AUDIO;
362 } else if (!strcmp(fmt->name, "mpegvideo")) {
312d24d5 363 st->codec->codec_id = CODEC_ID_MPEG2VIDEO;
f1588ed5
364 st->codec->codec_type = CODEC_TYPE_VIDEO;
365 } else if (!strcmp(fmt->name, "h264")) {
312d24d5 366 st->codec->codec_id = CODEC_ID_H264;
f1588ed5
367 st->codec->codec_type = CODEC_TYPE_VIDEO;
368 }
64cd3108
MN
369 }
370 return !!fmt;
371}
372
b9a281db
FB
373/************************************************************/
374/* input media file */
96baaa6a 375
da24c5e3 376/**
e36bdf8b 377 * Open a media file from an IO stream. 'fmt' must be specified.
da24c5e3 378 */
43465395 379static const char* format_to_name(void* ptr)
bc874dae 380{
43465395 381 AVFormatContext* fc = (AVFormatContext*) ptr;
bc874dae
MB
382 if(fc->iformat) return fc->iformat->name;
383 else if(fc->oformat) return fc->oformat->name;
384 else return "NULL";
385}
386
66acccf0 387#define OFFSET(x) offsetof(AVFormatContext,x)
755bfeab 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
4eb72c6b
NS
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
393static const AVOption options[]={
8c3dd5dc 394{"probesize", NULL, OFFSET(probesize), FF_OPT_TYPE_INT, 32000, 32, INT_MAX, D}, /* 32000 from mpegts.c: 1.0 second at 24Mbit/s */
09a45576 395{"muxrate", "set mux rate", OFFSET(mux_rate), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},
4ff8fcef 396{"packetsize", "set packet size", OFFSET(packet_size), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},
18de0b81 397{"fflags", NULL, OFFSET(flags), FF_OPT_TYPE_FLAGS, DEFAULT, INT_MIN, INT_MAX, D|E, "fflags"},
2c00106c
MN
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"},
8c3dd5dc 400{"track", " set the track number", OFFSET(track), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},
ec1b10f4 401{"year", "set the year", OFFSET(year), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX, E},
e19fbbec 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},
841f39a7 403{"cryptokey", "decryption key", OFFSET(key), FF_OPT_TYPE_BINARY, 0, 0, 0, D},
ac6f1330 404{"indexmem", "max memory used for timestamp index (per stream)", OFFSET(max_index_size), FF_OPT_TYPE_INT, 1<<20, 0, INT_MAX, D},
ab8ab30c 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 */
45b2b05f
MN
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"},
4eb72c6b
NS
408{NULL},
409};
410
5e89b50b
PI
411#undef E
412#undef D
413#undef DEFAULT
414
4eb72c6b
NS
415static const AVClass av_format_context_class = { "AVFormatContext", format_to_name, options };
416
702dfe01
BC
417static void avformat_get_context_defaults(AVFormatContext *s)
418{
4eb72c6b 419 memset(s, 0, sizeof(AVFormatContext));
9e6c9470 420
73a8ceaa
PI
421 s->av_class = &av_format_context_class;
422
423 av_opt_set_defaults(s);
4eb72c6b 424}
bc874dae
MB
425
426AVFormatContext *av_alloc_format_context(void)
427{
428 AVFormatContext *ic;
5894991f 429 ic = av_malloc(sizeof(AVFormatContext));
bc874dae 430 if (!ic) return ic;
4eb72c6b 431 avformat_get_context_defaults(ic);
43465395 432 ic->av_class = &av_format_context_class;
bc874dae
MB
433 return ic;
434}
435
115329f1
DB
436int av_open_input_stream(AVFormatContext **ic_ptr,
437 ByteIOContext *pb, const char *filename,
da24c5e3
FB
438 AVInputFormat *fmt, AVFormatParameters *ap)
439{
440 int err;
441 AVFormatContext *ic;
c04c3282
MN
442 AVFormatParameters default_ap;
443
444 if(!ap){
445 ap=&default_ap;
446 memset(ap, 0, sizeof(default_ap));
447 }
da24c5e3 448
4eb72c6b
NS
449 if(!ap->prealloced_context)
450 ic = av_alloc_format_context();
451 else
452 ic = *ic_ptr;
da24c5e3 453 if (!ic) {
769e10f0 454 err = AVERROR(ENOMEM);
da24c5e3
FB
455 goto fail;
456 }
457 ic->iformat = fmt;
899681cd 458 ic->pb = pb;
da24c5e3
FB
459 ic->duration = AV_NOPTS_VALUE;
460 ic->start_time = AV_NOPTS_VALUE;
75e61b0e 461 av_strlcpy(ic->filename, filename, sizeof(ic->filename));
da24c5e3
FB
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) {
769e10f0 467 err = AVERROR(ENOMEM);
da24c5e3
FB
468 goto fail;
469 }
470 } else {
471 ic->priv_data = NULL;
472 }
473
e145ce20 474 if (ic->iformat->read_header) {
1e2802c5
RB
475 err = ic->iformat->read_header(ic, ap);
476 if (err < 0)
477 goto fail;
e145ce20 478 }
fb2758c8 479
faf7cbf1 480 if (pb && !ic->data_offset)
899681cd 481 ic->data_offset = url_ftell(ic->pb);
fb2758c8 482
da24c5e3
FB
483 *ic_ptr = ic;
484 return 0;
485 fail:
486 if (ic) {
ccafd472 487 int i;
da24c5e3 488 av_freep(&ic->priv_data);
ccafd472
BC
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 }
da24c5e3
FB
497 }
498 av_free(ic);
499 *ic_ptr = NULL;
500 return err;
501}
502
a85736f2 503/** size of probe buffer, for guessing file type from file contents */
a877eedc 504#define PROBE_BUF_MIN 2048
329b1e75 505#define PROBE_BUF_MAX (1<<20)
b9a281db 506
115329f1 507int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
b9a281db
FB
508 AVInputFormat *fmt,
509 int buf_size,
510 AVFormatParameters *ap)
de6d9b64 511{
17acc63a 512 int err, probe_size;
b9a281db 513 AVProbeData probe_data, *pd = &probe_data;
17acc63a 514 ByteIOContext *pb = NULL;
115329f1 515
da24c5e3
FB
516 pd->filename = "";
517 if (filename)
518 pd->filename = filename;
a877eedc 519 pd->buf = NULL;
b9a281db
FB
520 pd->buf_size = 0;
521
522 if (!fmt) {
a85736f2 523 /* guess format if no file can be opened */
a25e098d 524 fmt = av_probe_input_format(pd, 0);
de6d9b64 525 }
de6d9b64 526
a85736f2 527 /* Do not open file if the format does not need it. XXX: specific
b6892136 528 hack needed to handle RTSP/TCP */
17acc63a 529 if (!fmt || !(fmt->flags & AVFMT_NOFILE)) {
87a0a681 530 /* if no file needed do not try to open one */
899681cd 531 if ((err=url_fopen(&pb, filename, URL_RDONLY)) < 0) {
96baaa6a 532 goto fail;
b9a281db 533 }
96baaa6a 534 if (buf_size > 0) {
da24c5e3 535 url_setbufsize(pb, buf_size);
96baaa6a 536 }
a877eedc
MN
537
538 for(probe_size= PROBE_BUF_MIN; probe_size<=PROBE_BUF_MAX && !fmt; probe_size<<=1){
79750486 539 int score= probe_size < PROBE_BUF_MAX ? AVPROBE_SCORE_MAX/4 : 0;
5b25dfa7 540 /* read probe data */
87e87886 541 pd->buf= av_realloc(pd->buf, probe_size + AVPROBE_PADDING_SIZE);
a877eedc 542 pd->buf_size = get_buffer(pb, pd->buf, probe_size);
9be51815 543 memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
497244a8 544 if (url_fseek(pb, 0, SEEK_SET) < 0) {
53e2f9ca 545 url_fclose(pb);
899681cd 546 if (url_fopen(&pb, filename, URL_RDONLY) < 0) {
17acc63a 547 pb = NULL;
6f3e0b21 548 err = AVERROR(EIO);
53e2f9ca
MN
549 goto fail;
550 }
551 }
a877eedc 552 /* guess file format */
79750486 553 fmt = av_probe_input_format2(pd, 1, &score);
5b25dfa7 554 }
a877eedc 555 av_freep(&pd->buf);
b9a281db
FB
556 }
557
558 /* if still no format found, error */
559 if (!fmt) {
560 err = AVERROR_NOFMT;
da24c5e3 561 goto fail;
de6d9b64 562 }
115329f1 563
a85736f2 564 /* check filename in case an image number is expected */
da24c5e3 565 if (fmt->flags & AVFMT_NEEDNUMBER) {
5c07cf53 566 if (!av_filename_number_test(filename)) {
87a0a681 567 err = AVERROR_NUMEXPECTED;
da24c5e3 568 goto fail;
87a0a681
FB
569 }
570 }
da24c5e3
FB
571 err = av_open_input_stream(ic_ptr, pb, filename, fmt, ap);
572 if (err)
573 goto fail;
b9a281db 574 return 0;
de6d9b64 575 fail:
a877eedc 576 av_freep(&pd->buf);
17acc63a 577 if (pb)
da24c5e3 578 url_fclose(pb);
b9a281db
FB
579 *ic_ptr = NULL;
580 return err;
115329f1 581
de6d9b64
FB
582}
583
da24c5e3
FB
584/*******************************************************/
585
5c5b1731
MR
586static AVPacket *add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt,
587 AVPacketList **plast_pktl){
588 AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
9d3b9f2c
MN
589 if (!pktl)
590 return NULL;
591
5c5b1731
MR
592 if (*packet_buffer)
593 (*plast_pktl)->next = pktl;
594 else
595 *packet_buffer = pktl;
596
9d3b9f2c
MN
597 /* add the packet in the buffered packet list */
598 *plast_pktl = pktl;
599 pktl->pkt= *pkt;
600 return &pktl->pkt;
601}
602
de6d9b64
FB
603int av_read_packet(AVFormatContext *s, AVPacket *pkt)
604{
62600469
MN
605 int ret;
606 AVStream *st;
0bef08e5
MN
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
55823964
MN
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];
62600469 625
55823964
MN
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 }
62600469 637
744b4c02
MN
638 if(!pktl && st->codec->codec_id!=CODEC_ID_PROBE)
639 return ret;
640
5c5b1731 641 add_to_pktbuf(&s->raw_packet_buffer, pkt, &s->raw_packet_buffer_end);
744b4c02 642
0bef08e5
MN
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
942de2f4 651 if(av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)){
25d3fb73
MN
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 }
942de2f4 657 }
0bef08e5
MN
658 }
659 }
fb2758c8
FB
660}
661
662/**********************************************************/
663
e36bdf8b 664/**
a85736f2 665 * Get the number of samples of an audio frame. Return -1 on error.
e36bdf8b 666 */
fb2758c8
FB
667static int get_audio_frame_size(AVCodecContext *enc, int size)
668{
669 int frame_size;
670
c924ca78
MN
671 if(enc->codec_id == CODEC_ID_VORBIS)
672 return -1;
673
fb2758c8 674 if (enc->frame_size <= 1) {
ac3e1834
BC
675 int bits_per_sample = av_get_bits_per_sample(enc->codec_id);
676
677 if (bits_per_sample) {
fb2758c8
FB
678 if (enc->channels == 0)
679 return -1;
f1b163e0 680 frame_size = (size << 3) / (bits_per_sample * enc->channels);
ac3e1834 681 } else {
fb2758c8
FB
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;
fb2758c8
FB
686 }
687 } else {
688 frame_size = enc->frame_size;
689 }
690 return frame_size;
691}
692
693
e36bdf8b 694/**
a85736f2 695 * Return the frame duration in seconds. Return 0 if not available.
e36bdf8b 696 */
115329f1 697static void compute_frame_duration(int *pnum, int *pden, AVStream *st,
fb2758c8
FB
698 AVCodecParserContext *pc, AVPacket *pkt)
699{
700 int frame_size;
701
702 *pnum = 0;
703 *pden = 0;
01f4895c 704 switch(st->codec->codec_type) {
fb2758c8 705 case CODEC_TYPE_VIDEO:
1677155d 706 if(st->time_base.num*1000LL > st->time_base.den){
c0df9d75
MN
707 *pnum = st->time_base.num;
708 *pden = st->time_base.den;
01f4895c
MN
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;
327c4076
MN
712 if (pc && pc->repeat_pict) {
713 *pden *= 2;
714 *pnum = (*pnum) * (2 + pc->repeat_pict);
715 }
fb2758c8
FB
716 }
717 break;
718 case CODEC_TYPE_AUDIO:
01f4895c 719 frame_size = get_audio_frame_size(st->codec, pkt->size);
fb2758c8
FB
720 if (frame_size < 0)
721 break;
722 *pnum = frame_size;
01f4895c 723 *pden = st->codec->sample_rate;
fb2758c8
FB
724 break;
725 default:
726 break;
727 }
728}
729
5ba7c3d7
MN
730static 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:
f37b9768 741 case CODEC_ID_FFVHUFF:
5ba7c3d7
MN
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
9fcbcca6
NB
752static void update_initial_timestamps(AVFormatContext *s, int stream_index,
753 int64_t dts, int64_t pts)
754{
82583548
MN
755 AVStream *st= s->streams[stream_index];
756 AVPacketList *pktl= s->packet_buffer;
757
7efeb73a 758 if(st->first_dts != AV_NOPTS_VALUE || dts == AV_NOPTS_VALUE || st->cur_dts == AV_NOPTS_VALUE)
82583548
MN
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;
48a59dfe
MN
773
774 if(st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
775 st->start_time= pktl->pkt.pts;
82583548 776 }
9fcbcca6
NB
777 if (st->start_time == AV_NOPTS_VALUE)
778 st->start_time = pts;
82583548
MN
779}
780
83a9db42
MN
781static void update_initial_durations(AVFormatContext *s, AVStream *st, AVPacket *pkt)
782{
783 AVPacketList *pktl= s->packet_buffer;
820ad60c
MN
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;
83a9db42
MN
799
800 for(; pktl; pktl= pktl->next){
801 if(pktl->pkt.stream_index != pkt->stream_index)
802 continue;
91acf9a8
MN
803 if(pktl->pkt.pts == pktl->pkt.dts && pktl->pkt.dts == AV_NOPTS_VALUE
804 && !pktl->pkt.duration){
820ad60c 805 pktl->pkt.dts= cur_dts;
5853423c 806 if(!st->codec->has_b_frames)
820ad60c
MN
807 pktl->pkt.pts= cur_dts;
808 cur_dts += pkt->duration;
83a9db42
MN
809 pktl->pkt.duration= pkt->duration;
810 }else
811 break;
812 }
820ad60c
MN
813 if(st->first_dts == AV_NOPTS_VALUE)
814 st->cur_dts= cur_dts;
83a9db42
MN
815}
816
115329f1 817static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
fb2758c8
FB
818 AVCodecParserContext *pc, AVPacket *pkt)
819{
d9e1efb7 820 int num, den, presentation_delayed, delay, i;
a74008a4 821 int64_t offset;
115329f1 822
10a7571b
MN
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
fb2758c8 828 if (pkt->duration == 0) {
3c895fc0 829 compute_frame_duration(&num, &den, st, pc, pkt);
fb2758c8 830 if (den && num) {
77405fc8 831 pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
83a9db42 832
820ad60c 833 if(pkt->duration != 0 && s->packet_buffer)
83a9db42 834 update_initial_durations(s, st, pkt);
fb2758c8
FB
835 }
836 }
837
a85736f2
DB
838 /* correct timestamps with byte offset if demuxers only have timestamps
839 on packet boundaries */
a74008a4
JP
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
a85736f2 849 /* do we have a video B-frame ? */
befe3b05 850 delay= st->codec->has_b_frames;
fb2758c8 851 presentation_delayed = 0;
7e4baa66
MN
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;
755bfeab 857 /* This may be redundant, but it should not hurt. */
7e4baa66
MN
858 if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
859 presentation_delayed = 1;
115329f1 860
949b1a13 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);
fb2758c8 862 /* interpolate PTS and DTS if they are not present */
406a0fdc 863 if(delay==0 || (delay==1 && pc)){
7e4baa66 864 if (presentation_delayed) {
a85736f2
DB
865 /* DTS = decompression timestamp */
866 /* PTS = presentation timestamp */
7e4baa66 867 if (pkt->dts == AV_NOPTS_VALUE)
635fbcb1 868 pkt->dts = st->last_IP_pts;
9fcbcca6 869 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts);
7e4baa66
MN
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
a85736f2 874 of the frame we are displaying, i.e. the last I- or P-frame */
635fbcb1
MN
875 if (st->last_IP_duration == 0)
876 st->last_IP_duration = pkt->duration;
7efeb73a 877 if(pkt->dts != AV_NOPTS_VALUE)
cdb5af79 878 st->cur_dts = pkt->dts + st->last_IP_duration;
635fbcb1
MN
879 st->last_IP_duration = pkt->duration;
880 st->last_IP_pts= pkt->pts;
7e4baa66 881 /* cannot compute PTS if not present (we can compute it only
a85736f2 882 by knowing the future */
028d6f3e 883 } else if(pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE || pkt->duration){
7e4baa66
MN
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 }
90bb394d 891 }
115329f1 892
7e4baa66
MN
893 /* presentation is not delayed : PTS and DTS are the same */
894 if(pkt->pts == AV_NOPTS_VALUE)
895 pkt->pts = pkt->dts;
9fcbcca6 896 update_initial_timestamps(s, pkt->stream_index, pkt->pts, pkt->pts);
7e4baa66
MN
897 if(pkt->pts == AV_NOPTS_VALUE)
898 pkt->pts = st->cur_dts;
899 pkt->dts = pkt->pts;
7efeb73a 900 if(pkt->pts != AV_NOPTS_VALUE)
cdb5af79 901 st->cur_dts = pkt->pts + pkt->duration;
7e4baa66 902 }
fb2758c8 903 }
d9e1efb7 904
cb5b96cd 905 if(pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
d9e1efb7 906 st->pts_buffer[0]= pkt->pts;
d9e1efb7
MN
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];
82583548 911 if(delay>1){
9fcbcca6 912 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts); // this should happen on the first packet
82583548 913 }
d9e1efb7
MN
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);
115329f1 919
fb2758c8 920 /* update flags */
3a1d3588
JD
921 if(is_intra_only(st->codec))
922 pkt->flags |= PKT_FLAG_KEY;
923 else if (pc) {
fb2758c8 924 pkt->flags = 0;
a85736f2 925 /* keyframe computation */
fb2758c8
FB
926 if (pc->pict_type == FF_I_TYPE)
927 pkt->flags |= PKT_FLAG_KEY;
fb2758c8 928 }
fb2758c8
FB
929}
930
63dd1377 931void av_destruct_packet_nofree(AVPacket *pkt)
fb2758c8
FB
932{
933 pkt->data = NULL; pkt->size = 0;
934}
935
936static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
937{
938 AVStream *st;
37353960 939 int len, ret, i;
fb2758c8 940
b237eb80
MN
941 av_init_packet(pkt);
942
fb2758c8
FB
943 for(;;) {
944 /* select current input stream component */
945 st = s->cur_st;
946 if (st) {
90ad92b3 947 if (!st->need_parsing || !st->parser) {
fb2758c8
FB
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;
434cab9e 953 break;
f3356e9c 954 } else if (s->cur_len > 0 && st->discard < AVDISCARD_ALL) {
115329f1 955 len = av_parser_parse(st->parser, st->codec, &pkt->data, &pkt->size,
6ec87caa
FB
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;
fb2758c8
FB
960 /* increment read pointer */
961 s->cur_ptr += len;
962 s->cur_len -= len;
115329f1 963
fb2758c8
FB
964 /* return packet if any */
965 if (pkt->size) {
37353960 966 got_packet:
711737af 967 pkt->pos = s->cur_pkt.pos; // Isn't quite accurate but close.
fb2758c8
FB
968 pkt->duration = 0;
969 pkt->stream_index = st->index;
6ec87caa
FB
970 pkt->pts = st->parser->pts;
971 pkt->dts = st->parser->dts;
fb2758c8
FB
972 pkt->destruct = av_destruct_packet_nofree;
973 compute_pkt_fields(s, st, st->parser, pkt);
e9b78eeb
MN
974
975 if((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & PKT_FLAG_KEY){
3dea63bd 976 ff_reduce_index(s, st->index);
e9b78eeb
MN
977 av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
978 0, 0, AVINDEX_KEYFRAME);
979 }
980
434cab9e 981 break;
fb2758c8
FB
982 }
983 } else {
bcbecff1 984 /* free packet */
115329f1 985 av_free_packet(&s->cur_pkt);
fb2758c8
FB
986 s->cur_st = NULL;
987 }
988 } else {
fb2758c8
FB
989 /* read next packet */
990 ret = av_read_packet(s, &s->cur_pkt);
37353960 991 if (ret < 0) {
8fa36ae0 992 if (ret == AVERROR(EAGAIN))
37353960
FB
993 return ret;
994 /* return the last frames, if any */
995 for(i = 0; i < s->nb_streams; i++) {
996 st = s->streams[i];
90ad92b3 997 if (st->parser && st->need_parsing) {
115329f1
DB
998 av_parser_parse(st->parser, st->codec,
999 &pkt->data, &pkt->size,
1000 NULL, 0,
6ec87caa 1001 AV_NOPTS_VALUE, AV_NOPTS_VALUE);
37353960
FB
1002 if (pkt->size)
1003 goto got_packet;
1004 }
1005 }
a85736f2 1006 /* no more packets: really terminate parsing */
fb2758c8 1007 return ret;
37353960 1008 }
115329f1 1009
b18a4ab2
MN
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
9ee91c2f 1022 st = s->streams[s->cur_pkt.stream_index];
45b2b05f 1023 if(s->debug & FF_FDEBUG_TS)
3041a4a1 1024 av_log(s, AV_LOG_DEBUG, "av_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, flags=%d\n",
434cab9e
MN
1025 s->cur_pkt.stream_index,
1026 s->cur_pkt.pts,
1027 s->cur_pkt.dts,
3041a4a1
MN
1028 s->cur_pkt.size,
1029 s->cur_pkt.flags);
fb2758c8 1030
fb2758c8
FB
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) {
01f4895c 1035 st->parser = av_parser_init(st->codec->codec_id);
fb2758c8 1036 if (!st->parser) {
a85736f2 1037 /* no parser available: just output the raw packets */
57004ff1
AJ
1038 st->need_parsing = AVSTREAM_PARSE_NONE;
1039 }else if(st->need_parsing == AVSTREAM_PARSE_HEADERS){
7cbaa7ba 1040 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
fb2758c8 1041 }
e9b78eeb 1042 if(st->parser && (s->iformat->flags & AVFMT_GENERIC_INDEX)){
c5577c40 1043 st->parser->next_frame_offset=
e9b78eeb
MN
1044 st->parser->cur_offset= s->cur_pkt.pos;
1045 }
fb2758c8
FB
1046 }
1047 }
1048 }
45b2b05f 1049 if(s->debug & FF_FDEBUG_TS)
3041a4a1 1050 av_log(s, AV_LOG_DEBUG, "av_read_frame_internal stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, flags=%d\n",
434cab9e
MN
1051 pkt->stream_index,
1052 pkt->pts,
1053 pkt->dts,
3041a4a1
MN
1054 pkt->size,
1055 pkt->flags);
434cab9e
MN
1056
1057 return 0;
fb2758c8
FB
1058}
1059
fb2758c8
FB
1060int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1061{
de6d9b64 1062 AVPacketList *pktl;
30bc6613
MN
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;
30bc6613
MN
1070
1071 if(genpts && next_pkt->dts != AV_NOPTS_VALUE){
1072 while(pktl && next_pkt->pts == AV_NOPTS_VALUE){
115329f1 1073 if( pktl->pkt.stream_index == next_pkt->stream_index
30bc6613
MN
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 }
115329f1
DB
1083
1084 if( next_pkt->pts != AV_NOPTS_VALUE
1085 || next_pkt->dts == AV_NOPTS_VALUE
30bc6613
MN
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){
30bc6613
MN
1095 int ret= av_read_frame_internal(s, pkt);
1096 if(ret<0){
8fa36ae0 1097 if(pktl && ret != AVERROR(EAGAIN)){
30bc6613
MN
1098 eof=1;
1099 continue;
1100 }else
1101 return ret;
1102 }
115329f1 1103
5c5b1731
MR
1104 if(av_dup_packet(add_to_pktbuf(&s->packet_buffer, pkt,
1105 &s->packet_buffer_end)) < 0)
769e10f0 1106 return AVERROR(ENOMEM);
30bc6613
MN
1107 }else{
1108 assert(!s->packet_buffer);
1109 return av_read_frame_internal(s, pkt);
1110 }
fb2758c8
FB
1111 }
1112}
1113
1114/* XXX: suppress the packet queue */
1115static void flush_packet_queue(AVFormatContext *s)
1116{
1117 AVPacketList *pktl;
1118
1119 for(;;) {
1120 pktl = s->packet_buffer;
115329f1 1121 if (!pktl)
fb2758c8
FB
1122 break;
1123 s->packet_buffer = pktl->next;
1124 av_free_packet(&pktl->pkt);
1125 av_free(pktl);
b9a281db
FB
1126 }
1127}
1128
da24c5e3 1129/*******************************************************/
fb2758c8
FB
1130/* seek support */
1131
b754978a
MN
1132int av_find_default_stream_index(AVFormatContext *s)
1133{
ca162a50 1134 int first_audio_index = -1;
b754978a
MN
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];
01f4895c 1142 if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
b754978a
MN
1143 return i;
1144 }
ca162a50
AJ
1145 if (first_audio_index < 0 && st->codec->codec_type == CODEC_TYPE_AUDIO)
1146 first_audio_index = i;
b754978a 1147 }
ca162a50 1148 return first_audio_index >= 0 ? first_audio_index : 0;
b754978a
MN
1149}
1150
e36bdf8b
DK
1151/**
1152 * Flush the frame reader.
1153 */
fb2758c8
FB
1154static 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;
115329f1 1170
fb2758c8
FB
1171 /* for each stream, reset read state */
1172 for(i = 0; i < s->nb_streams; i++) {
1173 st = s->streams[i];
115329f1 1174
fb2758c8
FB
1175 if (st->parser) {
1176 av_parser_close(st->parser);
1177 st->parser = NULL;
1178 }
635fbcb1 1179 st->last_IP_pts = AV_NOPTS_VALUE;
a843d1ff 1180 st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
fb2758c8
FB
1181 }
1182}
1183
22ffac70 1184void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp){
8bcb147f
MN
1185 int i;
1186
1187 for(i = 0; i < s->nb_streams; i++) {
1a1dc611 1188 AVStream *st = s->streams[i];
8bcb147f 1189
115329f1 1190 st->cur_dts = av_rescale(timestamp,
1a1dc611
NK
1191 st->time_base.den * (int64_t)ref_st->time_base.num,
1192 st->time_base.num * (int64_t)ref_st->time_base.den);
8bcb147f
MN
1193 }
1194}
1195
3dea63bd
PK
1196void 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
3e9245a9 1209int av_add_index_entry(AVStream *st,
30a43f2d 1210 int64_t pos, int64_t timestamp, int size, int distance, int flags)
fb2758c8
FB
1211{
1212 AVIndexEntry *entries, *ie;
b754978a 1213 int index;
115329f1 1214
568e18b1
MN
1215 if((unsigned)st->nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1216 return -1;
115329f1 1217
fb2758c8
FB
1218 entries = av_fast_realloc(st->index_entries,
1219 &st->index_entries_allocated_size,
115329f1 1220 (st->nb_index_entries + 1) *
fb2758c8 1221 sizeof(AVIndexEntry));
568e18b1
MN
1222 if(!entries)
1223 return -1;
1224
b754978a
MN
1225 st->index_entries= entries;
1226
27a5fe5f 1227 index= av_index_search_timestamp(st, timestamp, AVSEEK_FLAG_ANY);
b754978a 1228
3ba1438d 1229 if(index<0){
3e9245a9
MN
1230 index= st->nb_index_entries++;
1231 ie= &entries[index];
3ba1438d
MN
1232 assert(index==0 || ie[-1].timestamp < timestamp);
1233 }else{
1234 ie= &entries[index];
1235 if(ie->timestamp != timestamp){
528c2c73
MN
1236 if(ie->timestamp <= timestamp)
1237 return -1;
3ba1438d
MN
1238 memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(st->nb_index_entries - index));
1239 st->nb_index_entries++;
755bfeab 1240 }else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
3ba1438d 1241 distance= ie->min_distance;
3e9245a9 1242 }
3ba1438d 1243
b754978a
MN
1244 ie->pos = pos;
1245 ie->timestamp = timestamp;
3e9245a9 1246 ie->min_distance= distance;
30a43f2d 1247 ie->size= size;
b754978a 1248 ie->flags = flags;
115329f1 1249
3e9245a9 1250 return index;
fb2758c8
FB
1251}
1252
dc56fc38 1253int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
27a5fe5f 1254 int flags)
fb2758c8 1255{
b754978a
MN
1256 AVIndexEntry *entries= st->index_entries;
1257 int nb_entries= st->nb_index_entries;
fb2758c8
FB
1258 int a, b, m;
1259 int64_t timestamp;
1260
3ba1438d
MN
1261 a = - 1;
1262 b = nb_entries;
b754978a 1263
3ba1438d
MN
1264 while (b - a > 1) {
1265 m = (a + b) >> 1;
fb2758c8 1266 timestamp = entries[m].timestamp;
3ba1438d
MN
1267 if(timestamp >= wanted_timestamp)
1268 b = m;
1269 if(timestamp <= wanted_timestamp)
b754978a 1270 a = m;
fb2758c8 1271 }
27a5fe5f 1272 m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
115329f1 1273
27a5fe5f
MN
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 }
3ba1438d 1279
115329f1 1280 if(m == nb_entries)
3ba1438d
MN
1281 return -1;
1282 return m;
fb2758c8
FB
1283}
1284
0f652a8e 1285#define DEBUG_SEEK
8d14a25c 1286
3ba1438d 1287int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
8d14a25c
MN
1288 AVInputFormat *avif= s->iformat;
1289 int64_t pos_min, pos_max, pos, pos_limit;
1290 int64_t ts_min, ts_max, ts;
89ddd2a9 1291 int index;
8d14a25c
MN
1292 AVStream *st;
1293
cdd5034f
MN
1294 if (stream_index < 0)
1295 return -1;
115329f1 1296
8d14a25c 1297#ifdef DEBUG_SEEK
4733abcb 1298 av_log(s, AV_LOG_DEBUG, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
8d14a25c
MN
1299#endif
1300
1301 ts_max=
1302 ts_min= AV_NOPTS_VALUE;
90b5b51e 1303 pos_limit= -1; //gcc falsely says it may be uninitialized
8d14a25c
MN
1304
1305 st= s->streams[stream_index];
1306 if(st->index_entries){
1307 AVIndexEntry *e;
1308
a85736f2 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()
3ba1438d 1310 index= FFMAX(index, 0);
8d14a25c
MN
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
115329f1 1317 av_log(s, AV_LOG_DEBUG, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
8d14a25c
MN
1318 pos_min,ts_min);
1319#endif
1320 }else{
1321 assert(index==0);
1322 }
115329f1
DB
1323
1324 index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
27a5fe5f
MN
1325 assert(index < st->nb_index_entries);
1326 if(index >= 0){
8d14a25c
MN
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
115329f1 1333 av_log(s, AV_LOG_DEBUG, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
8d14a25c
MN
1334 pos_max,pos_limit, ts_max);
1335#endif
1336 }
1337 }
1338
89ddd2a9
MN
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 */
899681cd 1344 url_fseek(s->pb, pos, SEEK_SET);
89ddd2a9
MN
1345
1346 av_update_cur_dts(s, st, ts);
1347
1348 return 0;
1349}
1350
89ddd2a9
MN
1351int64_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
8d14a25c
MN
1360 if(ts_min == AV_NOPTS_VALUE){
1361 pos_min = s->data_offset;
89ddd2a9 1362 ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
8d14a25c
MN
1363 if (ts_min == AV_NOPTS_VALUE)
1364 return -1;
1365 }
1366
1367 if(ts_max == AV_NOPTS_VALUE){
1368 int step= 1024;
899681cd 1369 filesize = url_fsize(s->pb);
6fd93ce2 1370 pos_max = filesize - 1;
8d14a25c
MN
1371 do{
1372 pos_max -= step;
89ddd2a9 1373 ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
8d14a25c
MN
1374 step += step;
1375 }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1376 if (ts_max == AV_NOPTS_VALUE)
1377 return -1;
115329f1 1378
8d14a25c
MN
1379 for(;;){
1380 int64_t tmp_pos= pos_max + 1;
89ddd2a9 1381 int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
8d14a25c
MN
1382 if(tmp_ts == AV_NOPTS_VALUE)
1383 break;
1384 ts_max= tmp_ts;
1385 pos_max= tmp_pos;
6fd93ce2
KA
1386 if(tmp_pos >= filesize)
1387 break;
8d14a25c
MN
1388 }
1389 pos_limit= pos_max;
1390 }
1391
53f7c43f
MN
1392 if(ts_min > ts_max){
1393 return -1;
1394 }else if(ts_min == ts_max){
1395 pos_limit= pos_min;
1396 }
1397
8d14a25c
MN
1398 no_change=0;
1399 while (pos_min < pos_limit) {
1400#ifdef DEBUG_SEEK
115329f1 1401 av_log(s, AV_LOG_DEBUG, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
8d14a25c
MN
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)
3ba1438d
MN
1410 pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1411 + pos_min - approximate_keyframe_distance;
8d14a25c
MN
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{
a85736f2
DB
1416 /* linear search if bisection failed, can only happen if there
1417 are very few or no keyframes between min/max */
8d14a25c
MN
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
89ddd2a9 1426 ts = read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
8d14a25c
MN
1427 if(pos == pos_max)
1428 no_change++;
1429 else
1430 no_change=0;
1431#ifdef DEBUG_SEEK
4733abcb 1432av_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);
8d14a25c 1433#endif
db2a0e22
MN
1434 if(ts == AV_NOPTS_VALUE){
1435 av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1436 return -1;
1437 }
8d14a25c 1438 assert(ts != AV_NOPTS_VALUE);
3ba1438d 1439 if (target_ts <= ts) {
8d14a25c
MN
1440 pos_limit = start_pos - 1;
1441 pos_max = pos;
1442 ts_max = ts;
3ba1438d
MN
1443 }
1444 if (target_ts >= ts) {
8d14a25c
MN
1445 pos_min = pos;
1446 ts_min = ts;
8d14a25c
MN
1447 }
1448 }
115329f1 1449
3ba1438d
MN
1450 pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1451 ts = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min : ts_max;
8d14a25c
MN
1452#ifdef DEBUG_SEEK
1453 pos_min = pos;
89ddd2a9 1454 ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
8d14a25c 1455 pos_min++;
89ddd2a9 1456 ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
115329f1 1457 av_log(s, AV_LOG_DEBUG, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
8d14a25c
MN
1458 pos, ts_min, target_ts, ts_max);
1459#endif
89ddd2a9
MN
1460 *ts_ret= ts;
1461 return pos;
8d14a25c
MN
1462}
1463
3ba1438d 1464static int av_seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
3ba1438d
MN
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;
899681cd 1476 pos_max = url_fsize(s->pb) - 1;
3ba1438d
MN
1477
1478 if (pos < pos_min) pos= pos_min;
1479 else if(pos > pos_max) pos= pos_max;
1480
899681cd 1481 url_fseek(s->pb, pos, SEEK_SET);
3ba1438d
MN
1482
1483#if 0
8bcb147f 1484 av_update_cur_dts(s, st, ts);
3ba1438d
MN
1485#endif
1486 return 0;
1487}
1488
115329f1 1489static int av_seek_frame_generic(AVFormatContext *s,
3ba1438d 1490 int stream_index, int64_t timestamp, int flags)
fb2758c8 1491{
aaec4e03 1492 int index, ret;
fb2758c8
FB
1493 AVStream *st;
1494 AVIndexEntry *ie;
1495
fb2758c8 1496 st = s->streams[stream_index];
e9b78eeb 1497
27a5fe5f 1498 index = av_index_search_timestamp(st, timestamp, flags);
e9b78eeb 1499
b5a3541d 1500 if(index < 0 || index==st->nb_index_entries-1){
e9b78eeb
MN
1501 int i;
1502 AVPacket pkt;
1503
5e5c9086
MN
1504 if(st->nb_index_entries){
1505 assert(st->index_entries);
e9b78eeb 1506 ie= &st->index_entries[st->nb_index_entries-1];
aaec4e03
BC
1507 if ((ret = url_fseek(s->pb, ie->pos, SEEK_SET)) < 0)
1508 return ret;
e9b78eeb 1509 av_update_cur_dts(s, st, ie->timestamp);
aaec4e03
BC
1510 }else{
1511 if ((ret = url_fseek(s->pb, 0, SEEK_SET)) < 0)
1512 return ret;
1513 }
e9b78eeb
MN
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 }
fb2758c8
FB
1526 if (index < 0)
1527 return -1;
1528
fb2758c8 1529 av_read_frame_flush(s);
e9b78eeb
MN
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];
aaec4e03
BC
1535 if ((ret = url_fseek(s->pb, ie->pos, SEEK_SET)) < 0)
1536 return ret;
8bcb147f 1537 av_update_cur_dts(s, st, ie->timestamp);
cdd5034f 1538
fb2758c8
FB
1539 return 0;
1540}
1541
3ba1438d 1542int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
fb2758c8
FB
1543{
1544 int ret;
cdd5034f 1545 AVStream *st;
115329f1 1546
fb2758c8 1547 av_read_frame_flush(s);
115329f1 1548
3ba1438d
MN
1549 if(flags & AVSEEK_FLAG_BYTE)
1550 return av_seek_frame_byte(s, stream_index, timestamp, flags);
115329f1 1551
cdd5034f
MN
1552 if(stream_index < 0){
1553 stream_index= av_find_default_stream_index(s);
1554 if(stream_index < 0)
1555 return -1;
115329f1 1556
3ba1438d 1557 st= s->streams[stream_index];
eb497825 1558 /* timestamp for default must be expressed in AV_TIME_BASE units */
3ba1438d 1559 timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
cdd5034f 1560 }
cdd5034f 1561
fb2758c8
FB
1562 /* first, we try the format specific seek */
1563 if (s->iformat->read_seek)
3ba1438d 1564 ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
fb2758c8
FB
1565 else
1566 ret = -1;
1567 if (ret >= 0) {
1568 return 0;
1569 }
8d14a25c
MN
1570
1571 if(s->iformat->read_timestamp)
3ba1438d 1572 return av_seek_frame_binary(s, stream_index, timestamp, flags);
8d14a25c 1573 else
3ba1438d 1574 return av_seek_frame_generic(s, stream_index, timestamp, flags);
fb2758c8
FB
1575}
1576
1577/*******************************************************/
12f996ed 1578
e36bdf8b 1579/**
c1e8b678 1580 * Returns TRUE if the stream has accurate duration in any stream.
e36bdf8b 1581 *
c1e8b678 1582 * @return TRUE if the stream has accurate duration for at least one component.
e36bdf8b 1583 */
c1e8b678 1584static int av_has_duration(AVFormatContext *ic)
12f996ed
FB
1585{
1586 int i;
1587 AVStream *st;
1588
1589 for(i = 0;i < ic->nb_streams; i++) {
1590 st = ic->streams[i];
c1e8b678 1591 if (st->duration != AV_NOPTS_VALUE)
12f996ed
FB
1592 return 1;
1593 }
1594 return 0;
1595}
1596
e36bdf8b
DK
1597/**
1598 * Estimate the stream timings from the one of each components.
1599 *
1600 * Also computes the global bitrate if possible.
1601 */
12f996ed
FB
1602static void av_update_stream_timings(AVFormatContext *ic)
1603{
c0df9d75 1604 int64_t start_time, start_time1, end_time, end_time1;
c1e8b678 1605 int64_t duration, duration1;
12f996ed
FB
1606 int i;
1607 AVStream *st;
1608
f27a7268
MR
1609 start_time = INT64_MAX;
1610 end_time = INT64_MIN;
c1e8b678 1611 duration = INT64_MIN;
12f996ed
FB
1612 for(i = 0;i < ic->nb_streams; i++) {
1613 st = ic->streams[i];
7f938dd3 1614 if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
c0df9d75
MN
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;
12f996ed 1618 if (st->duration != AV_NOPTS_VALUE) {
c0df9d75
MN
1619 end_time1 = start_time1
1620 + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
12f996ed
FB
1621 if (end_time1 > end_time)
1622 end_time = end_time1;
1623 }
1624 }
c1e8b678
NB
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 }
12f996ed 1630 }
f27a7268 1631 if (start_time != INT64_MAX) {
12f996ed 1632 ic->start_time = start_time;
f27a7268 1633 if (end_time != INT64_MIN) {
c1e8b678
NB
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) {
a85736f2 1641 /* compute the bitrate */
c1e8b678
NB
1642 ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE /
1643 (double)ic->duration;
12f996ed
FB
1644 }
1645 }
12f996ed
FB
1646}
1647
1648static 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) {
c0df9d75
MN
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);
12f996ed
FB
1661 }
1662 }
1663}
1664
1665static 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];
01f4895c 1676 bit_rate += st->codec->bit_rate;
12f996ed
FB
1677 }
1678 ic->bit_rate = bit_rate;
1679 }
1680
1681 /* if duration is already set, we believe it */
115329f1
DB
1682 if (ic->duration == AV_NOPTS_VALUE &&
1683 ic->bit_rate != 0 &&
12f996ed
FB
1684 ic->file_size != 0) {
1685 filesize = ic->file_size;
1686 if (filesize > 0) {
12f996ed
FB
1687 for(i = 0; i < ic->nb_streams; i++) {
1688 st = ic->streams[i];
c0df9d75 1689 duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
9f32041d 1690 if (st->duration == AV_NOPTS_VALUE)
12f996ed 1691 st->duration = duration;
12f996ed
FB
1692 }
1693 }
1694 }
1695}
1696
12f996ed
FB
1697#define DURATION_MAX_READ_SIZE 250000
1698
1699/* only usable for MPEG-PS streams */
9ecf7fad 1700static void av_estimate_timings_from_pts(AVFormatContext *ic, offset_t old_offset)
12f996ed
FB
1701{
1702 AVPacket pkt1, *pkt = &pkt1;
1703 AVStream *st;
1704 int read_size, i, ret;
bf4e3bd2 1705 int64_t end_time;
12f996ed 1706 int64_t filesize, offset, duration;
115329f1 1707
578688fa
LA
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 }
115329f1 1723
12f996ed
FB
1724 /* we read the first packets to get the first PTS (not fully
1725 accurate, but it is enough now) */
899681cd 1726 url_fseek(ic->pb, 0, SEEK_SET);
12f996ed
FB
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)
c0df9d75 1747 st->start_time = pkt->pts;
0a5f92a1
MN
1748 }
1749 av_free_packet(pkt);
1750 }
12f996ed 1751
12f996ed
FB
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
899681cd 1759 url_fseek(ic->pb, offset, SEEK_SET);
12f996ed
FB
1760 read_size = 0;
1761 for(;;) {
1762 if (read_size >= DURATION_MAX_READ_SIZE)
1763 break;
115329f1 1764
12f996ed
FB
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];
bf494092
NB
1770 if (pkt->pts != AV_NOPTS_VALUE &&
1771 st->start_time != AV_NOPTS_VALUE) {
c0df9d75 1772 end_time = pkt->pts;
12f996ed
FB
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 }
115329f1 1782
c0df9d75 1783 fill_all_stream_timings(ic);
12f996ed 1784
899681cd 1785 url_fseek(ic->pb, old_offset, SEEK_SET);
df886e7e
MN
1786 for(i=0; i<ic->nb_streams; i++){
1787 st= ic->streams[i];
1788 st->cur_dts= st->first_dts;
635fbcb1 1789 st->last_IP_pts = AV_NOPTS_VALUE;
df886e7e 1790 }
12f996ed
FB
1791}
1792
9ecf7fad 1793static void av_estimate_timings(AVFormatContext *ic, offset_t old_offset)
12f996ed 1794{
12f996ed
FB
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 {
899681cd 1801 file_size = url_fsize(ic->pb);
12f996ed
FB
1802 if (file_size < 0)
1803 file_size = 0;
1804 }
1805 ic->file_size = file_size;
1806
ff70e601
MR
1807 if ((!strcmp(ic->iformat->name, "mpeg") ||
1808 !strcmp(ic->iformat->name, "mpegts")) &&
ceeacce6 1809 file_size && !url_is_streamed(ic->pb)) {
12f996ed 1810 /* get accurate estimate from the PTSes */
9ecf7fad 1811 av_estimate_timings_from_pts(ic, old_offset);
c1e8b678 1812 } else if (av_has_duration(ic)) {
a85736f2 1813 /* at least one component has timings - we use them for all
12f996ed
FB
1814 the components */
1815 fill_all_stream_timings(ic);
1816 } else {
a85736f2 1817 /* less precise: use bitrate info */
12f996ed
FB
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];
115329f1
DB
1828 printf("%d: start_time: %0.3f duration: %0.3f\n",
1829 i, (double)st->start_time / AV_TIME_BASE,
12f996ed
FB
1830 (double)st->duration / AV_TIME_BASE);
1831 }
115329f1
DB
1832 printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
1833 (double)ic->start_time / AV_TIME_BASE,
12f996ed
FB
1834 (double)ic->duration / AV_TIME_BASE,
1835 ic->bit_rate / 1000);
1836 }
1837#endif
1838}
1839
b9a281db
FB
1840static int has_codec_parameters(AVCodecContext *enc)
1841{
1842 int val;
1843 switch(enc->codec_type) {
1844 case CODEC_TYPE_AUDIO:
1686cce6 1845 val = enc->sample_rate && enc->channels;
f3b5a1a2
BC
1846 if(!enc->frame_size &&
1847 (enc->codec_id == CODEC_ID_VORBIS ||
1848 enc->codec_id == CODEC_ID_AAC))
4d35bf74 1849 return 0;
b9a281db
FB
1850 break;
1851 case CODEC_TYPE_VIDEO:
644a9262 1852 val = enc->width && enc->pix_fmt != PIX_FMT_NONE;
b9a281db
FB
1853 break;
1854 default:
1855 val = 1;
1856 break;
1857 }
ccd425e7 1858 return enc->codec_id != CODEC_ID_NONE && val != 0;
b9a281db
FB
1859}
1860
fb2758c8
FB
1861static int try_decode_frame(AVStream *st, const uint8_t *data, int size)
1862{
1863 int16_t *samples;
1864 AVCodec *codec;
3fdb6af9 1865 int got_picture, data_size, ret=0;
fb2758c8 1866 AVFrame picture;
115329f1 1867
01f4895c
MN
1868 if(!st->codec->codec){
1869 codec = avcodec_find_decoder(st->codec->codec_id);
fb2758c8
FB
1870 if (!codec)
1871 return -1;
01f4895c 1872 ret = avcodec_open(st->codec, codec);
fb2758c8
FB
1873 if (ret < 0)
1874 return ret;
43c0040a 1875 }
644a9262 1876
01f4895c
MN
1877 if(!has_codec_parameters(st->codec)){
1878 switch(st->codec->codec_type) {
fb2758c8 1879 case CODEC_TYPE_VIDEO:
115329f1 1880 ret = avcodec_decode_video(st->codec, &picture,
dc296223 1881 &got_picture, data, size);
fb2758c8
FB
1882 break;
1883 case CODEC_TYPE_AUDIO:
3fdb6af9
BC
1884 data_size = FFMAX(size, AVCODEC_MAX_AUDIO_FRAME_SIZE);
1885 samples = av_malloc(data_size);
fb2758c8
FB
1886 if (!samples)
1887 goto fail;
3fdb6af9 1888 ret = avcodec_decode_audio2(st->codec, samples,
dc296223 1889 &data_size, data, size);
fb2758c8
FB
1890 av_free(samples);
1891 break;
1892 default:
1893 break;
1894 }
644a9262 1895 }
fb2758c8 1896 fail:
fb2758c8
FB
1897 return ret;
1898}
1899
45da8124
AJ
1900unsigned 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
1910enum CodecID codec_get_id(const AVCodecTag *tags, unsigned int tag)
1911{
41415d28
MN
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;
45da8124
AJ
1923 }
1924 return CODEC_ID_NONE;
1925}
1926
1927unsigned 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
1937enum 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
c2c3dedf
AJ
1947static 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
fb2758c8
FB
1967/* absolute maximum size we read until we abort */
1968#define MAX_READ_SIZE 5000000
1969
fd97f6a2 1970#define MAX_STD_TIMEBASES (60*12+5)
4d43cbcc
MN
1971static int get_std_framerate(int i){
1972 if(i<60*12) return i*1001;
aecf157e 1973 else return ((const int[]){24,30,60,12,15})[i-60*12]*1000*12;
4d43cbcc
MN
1974}
1975
945208ca
MN
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.
a85736f2
DB
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.
945208ca
MN
1982 * And there are "variable" fps files this needs to detect as well.
1983 */
1984static 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
b9a281db
FB
1994int av_find_stream_info(AVFormatContext *ic)
1995{
9f75260e 1996 int i, count, ret, read_size, j;
b9a281db 1997 AVStream *st;
fb2758c8 1998 AVPacket pkt1, *pkt;
15bc38e5 1999 int64_t last_dts[MAX_STREAMS];
3c150d16 2000 int duration_count[MAX_STREAMS]={0};
0cbff027 2001 double (*duration_error)[MAX_STD_TIMEBASES];
899681cd 2002 offset_t old_offset = url_ftell(ic->pb);
ea486ab3
BC
2003 int64_t codec_info_duration[MAX_STREAMS]={0};
2004 int codec_info_nb_frames[MAX_STREAMS]={0};
b9a281db 2005
0cbff027 2006 duration_error = av_mallocz(MAX_STREAMS * sizeof(*duration_error));
769e10f0 2007 if (!duration_error) return AVERROR(ENOMEM);
0cbff027 2008
c0df9d75
MN
2009 for(i=0;i<ic->nb_streams;i++) {
2010 st = ic->streams[i];
01f4895c 2011 if(st->codec->codec_type == CODEC_TYPE_VIDEO){
c0df9d75
MN
2012/* if(!st->time_base.num)
2013 st->time_base= */
01f4895c
MN
2014 if(!st->codec->time_base.num)
2015 st->codec->time_base= st->time_base;
c0df9d75 2016 }
90ad92b3
MN
2017 //only for the split stuff
2018 if (!st->parser) {
01f4895c 2019 st->parser = av_parser_init(st->codec->codec_id);
57004ff1 2020 if(st->need_parsing == AVSTREAM_PARSE_HEADERS && st->parser){
7cbaa7ba
MN
2021 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
2022 }
90ad92b3 2023 }
c0df9d75
MN
2024 }
2025
15bc38e5
MN
2026 for(i=0;i<MAX_STREAMS;i++){
2027 last_dts[i]= AV_NOPTS_VALUE;
15bc38e5 2028 }
115329f1 2029
b9a281db
FB
2030 count = 0;
2031 read_size = 0;
b9a281db
FB
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];
01f4895c 2036 if (!has_codec_parameters(st->codec))
b9a281db 2037 break;
3e76d1b5 2038 /* variable fps and no guess at the real fps */
945208ca 2039 if( tb_unreliable(st->codec)
01f4895c 2040 && duration_count[i]<20 && st->codec->codec_type == CODEC_TYPE_VIDEO)
3e76d1b5 2041 break;
01f4895c 2042 if(st->parser && st->parser->parser->split && !st->codec->extradata)
90ad92b3 2043 break;
82583548
MN
2044 if(st->first_dts == AV_NOPTS_VALUE)
2045 break;
b9a281db
FB
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 */
fb2758c8 2051 if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
b9a281db
FB
2052 /* if we found the info for all the codecs, we can stop */
2053 ret = count;
2054 break;
2055 }
5fb83c38 2056 }
35eab0c0
MN
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 }
b9a281db 2062
fb2758c8
FB
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 */
e19456e3
MN
2069 for(i=0;i<ic->nb_streams;i++) {
2070 st = ic->streams[i];
305ee50f
MN
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);
344a18c3
MR
2075 } else {
2076 ret = 0;
305ee50f 2077 }
e19456e3 2078 }
fb2758c8
FB
2079 break;
2080 }
2081
5c5b1731 2082 pkt= add_to_pktbuf(&ic->packet_buffer, &pkt1, &ic->packet_buffer_end);
be390a4e
EH
2083 if(av_dup_packet(pkt) < 0) {
2084 av_free(duration_error);
02b15cc8 2085 return AVERROR(ENOMEM);
be390a4e 2086 }
b9a281db 2087
fb2758c8 2088 read_size += pkt->size;
b9a281db
FB
2089
2090 st = ic->streams[pkt->stream_index];
ea486ab3
BC
2091 if(codec_info_nb_frames[st->index]>1)
2092 codec_info_duration[st->index] += pkt->duration;
fb2758c8 2093 if (pkt->duration != 0)
ea486ab3 2094 codec_info_nb_frames[st->index]++;
fb2758c8 2095
cefe0607 2096 {
3c150d16
MN
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){
4d43cbcc
MN
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);
1694118b 2106 if(duration_count[index] < 2)
4c7981ba 2107 memset(duration_error[index], 0, sizeof(*duration_error));
69c262d1
MN
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 }
4d43cbcc 2114 duration_count[index]++;
15bc38e5 2115 }
fd97f6a2
MN
2116 if(last == AV_NOPTS_VALUE || duration_count[index]<=1)
2117 last_dts[pkt->stream_index]= pkt->dts;
15bc38e5 2118 }
01f4895c
MN
2119 if(st->parser && st->parser->parser->split && !st->codec->extradata){
2120 int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
90ad92b3 2121 if(i){
01f4895c 2122 st->codec->extradata_size= i;
62c52121 2123 st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
01f4895c 2124 memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
62c52121 2125 memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
90ad92b3
MN
2126 }
2127 }
115329f1 2128
fb2758c8
FB
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
a85736f2
DB
2131 it takes longer and uses more memory. For MPEG-4, we need to
2132 decompress for QuickTime. */
01f4895c
MN
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))*/)
fb2758c8 2148 try_decode_frame(st, pkt->data, pkt->size);
115329f1 2149
b3fc0925 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) {
fb2758c8 2151 break;
b9a281db
FB
2152 }
2153 count++;
2154 }
2155
bd107136 2156 // close codecs which were opened in try_decode_frame()
43c0040a
MN
2157 for(i=0;i<ic->nb_streams;i++) {
2158 st = ic->streams[i];
01f4895c
MN
2159 if(st->codec->codec)
2160 avcodec_close(st->codec);
43c0040a 2161 }
b9a281db
FB
2162 for(i=0;i<ic->nb_streams;i++) {
2163 st = ic->streams[i];
01f4895c
MN
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);
15bc38e5 2167
1694118b 2168 if(duration_count[i]
945208ca 2169 && tb_unreliable(st->codec) /*&&
a85736f2 2170 //FIXME we should not special-case MPEG-2, but this needs testing with non-MPEG-2 ...
4d43cbcc
MN
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);
9f75260e
MN
2179 if(error < best_error){
2180 best_error= error;
4d43cbcc 2181 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, get_std_framerate(j), 12*1001, INT_MAX);
9f75260e 2182 }
3c150d16 2183 }
15bc38e5
MN
2184 }
2185
c0df9d75 2186 if (!st->r_frame_rate.num){
5523d5f4
MN
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 }
14bea432 2195 }
a185f52a
MN
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);
b9a281db 2199 }
de6d9b64 2200 }
b9a281db 2201
9ecf7fad 2202 av_estimate_timings(ic, old_offset);
6fea687e 2203
c2c3dedf
AJ
2204 compute_chapters_end(ic);
2205
e928649b 2206#if 0
a85736f2 2207 /* correct DTS for B-frame streams with no timestamps */
e928649b
MN
2208 for(i=0;i<ic->nb_streams;i++) {
2209 st = ic->streams[i];
01f4895c 2210 if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
e928649b
MN
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
0cbff027
KA
2230
2231 av_free(duration_error);
2232
b9a281db 2233 return ret;
de6d9b64
FB
2234}
2235
fb2758c8
FB
2236/*******************************************************/
2237
fb2758c8
FB
2238int av_read_play(AVFormatContext *s)
2239{
fa13095a
BA
2240 if (s->iformat->read_play)
2241 return s->iformat->read_play(s);
fd2982a0 2242 if (s->pb)
502bdf68 2243 return av_url_read_fpause(s->pb, 0);
fa13095a 2244 return AVERROR(ENOSYS);
fb2758c8
FB
2245}
2246
fb2758c8
FB
2247int av_read_pause(AVFormatContext *s)
2248{
fa13095a
BA
2249 if (s->iformat->read_pause)
2250 return s->iformat->read_pause(s);
fd2982a0 2251 if (s->pb)
502bdf68 2252 return av_url_read_fpause(s->pb, 1);
fa13095a 2253 return AVERROR(ENOSYS);
fb2758c8
FB
2254}
2255
2506fd54 2256void av_close_input_stream(AVFormatContext *s)
de6d9b64 2257{
ca75a923 2258 int i;
da24c5e3 2259 AVStream *st;
de6d9b64 2260
fb2758c8
FB
2261 /* free previous packet */
2262 if (s->cur_st && s->cur_st->parser)
115329f1 2263 av_free_packet(&s->cur_pkt);
fb2758c8 2264
b9a281db
FB
2265 if (s->iformat->read_close)
2266 s->iformat->read_close(s);
de6d9b64 2267 for(i=0;i<s->nb_streams;i++) {
da24c5e3
FB
2268 /* free all data in a stream component */
2269 st = s->streams[i];
fb2758c8
FB
2270 if (st->parser) {
2271 av_parser_close(st->parser);
de6d9b64 2272 }
fb2758c8 2273 av_free(st->index_entries);
a5e9102b 2274 av_free(st->codec->extradata);
01f4895c 2275 av_free(st->codec);
f8d7c9d3 2276 av_free(st->filename);
ade8d8b9 2277 av_free(st->priv_data);
fb2758c8 2278 av_free(st);
de6d9b64 2279 }
15afa396
NS
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);
526efa10 2283 av_freep(&s->programs[i]->stream_index);
15afa396
NS
2284 av_freep(&s->programs[i]);
2285 }
ceedda75 2286 av_freep(&s->programs);
fb2758c8 2287 flush_packet_queue(s);
a8dbe951 2288 av_freep(&s->priv_data);
7c8202cc
MN
2289 while(s->nb_chapters--) {
2290 av_free(s->chapters[s->nb_chapters]->title);
2291 av_free(s->chapters[s->nb_chapters]);
79d7836a
AK
2292 }
2293 av_freep(&s->chapters);
1ea4f593 2294 av_free(s);
de6d9b64
FB
2295}
2296
2506fd54
RD
2297void 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
b9a281db
FB
2305AVStream *av_new_stream(AVFormatContext *s, int id)
2306{
2307 AVStream *st;
504ee036 2308 int i;
b9a281db
FB
2309
2310 if (s->nb_streams >= MAX_STREAMS)
2311 return NULL;
2312
2313 st = av_mallocz(sizeof(AVStream));
2314 if (!st)
2315 return NULL;
115329f1 2316
01f4895c 2317 st->codec= avcodec_alloc_context();
48091512
FB
2318 if (s->iformat) {
2319 /* no default bitrate if decoding */
01f4895c 2320 st->codec->bit_rate = 0;
48091512 2321 }
b9a281db
FB
2322 st->index = s->nb_streams;
2323 st->id = id;
12f996ed
FB
2324 st->start_time = AV_NOPTS_VALUE;
2325 st->duration = AV_NOPTS_VALUE;
6d77d9ac
MN
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;
82583548 2331 st->first_dts = AV_NOPTS_VALUE;
9ee91c2f 2332
a85736f2 2333 /* default pts setting is MPEG-like */
9ee91c2f 2334 av_set_pts_info(st, 33, 1, 90000);
635fbcb1 2335 st->last_IP_pts = AV_NOPTS_VALUE;
504ee036
MN
2336 for(i=0; i<MAX_REORDER_DELAY+1; i++)
2337 st->pts_buffer[i]= AV_NOPTS_VALUE;
9ee91c2f 2338
c30a4489
AJ
2339 st->sample_aspect_ratio = (AVRational){0,1};
2340
b9a281db
FB
2341 s->streams[s->nb_streams++] = st;
2342 return st;
2343}
2344
15afa396
NS
2345AVProgram *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
2370void 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
abd2256d 2381AVChapter *ff_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
79d7836a 2382{
7a2a3e8e
MN
2383 AVChapter *chapter = NULL;
2384 int i;
2385
7c8202cc 2386 for(i=0; i<s->nb_chapters; i++)
7a2a3e8e
MN
2387 if(s->chapters[i]->id == id)
2388 chapter = s->chapters[i];
2389
2390 if(!chapter){
2391 chapter= av_mallocz(sizeof(AVChapter));
6b43e2c7 2392 if(!chapter)
5c37f43a 2393 return NULL;
7c8202cc 2394 dynarray_add(&s->chapters, &s->nb_chapters, chapter);
7a2a3e8e 2395 }
ebea1d76 2396 av_free(chapter->title);
42720ee4 2397 chapter->title = av_strdup(title);
7a2a3e8e 2398 chapter->id = id;
abd2256d 2399 chapter->time_base= time_base;
79d7836a 2400 chapter->start = start;
747fb6c6 2401 chapter->end = end;
79d7836a 2402
5c37f43a 2403 return chapter;
79d7836a 2404}
15afa396 2405
b9a281db
FB
2406/************************************************************/
2407/* output media file */
de6d9b64 2408
87a0a681
FB
2409int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2410{
2411 int ret;
115329f1 2412
98486a6b
RS
2413 if (s->oformat->priv_data_size > 0) {
2414 s->priv_data = av_mallocz(s->oformat->priv_data_size);
2415 if (!s->priv_data)
769e10f0 2416 return AVERROR(ENOMEM);
98486a6b
RS
2417 } else
2418 s->priv_data = NULL;
115329f1 2419
87a0a681
FB
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
b9a281db
FB
2428int av_write_header(AVFormatContext *s)
2429{
1e51d801
FB
2430 int ret, i;
2431 AVStream *st;
2432
9450118b
MN
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 }
5ecfa9f5
MN
2455
2456 if(s->oformat->codec_tag){
2457 if(st->codec->codec_tag){
2458 //FIXME
2459 //check that tag + id is in the table
a85736f2 2460 //if neither is in the table -> OK
5ecfa9f5
MN
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 }
9450118b
MN
2466 }
2467
8fae2df5 2468 if (!s->priv_data && s->oformat->priv_data_size > 0) {
c6efa4b5
BC
2469 s->priv_data = av_mallocz(s->oformat->priv_data_size);
2470 if (!s->priv_data)
769e10f0 2471 return AVERROR(ENOMEM);
8fae2df5 2472 }
c6efa4b5 2473
31e11451
MN
2474 if(s->oformat->write_header){
2475 ret = s->oformat->write_header(s);
2476 if (ret < 0)
2477 return ret;
2478 }
1e51d801
FB
2479
2480 /* init PTS generation */
2481 for(i=0;i<s->nb_streams;i++) {
f0ff20a1 2482 int64_t den = AV_NOPTS_VALUE;
1e51d801
FB
2483 st = s->streams[i];
2484
01f4895c 2485 switch (st->codec->codec_type) {
1e51d801 2486 case CODEC_TYPE_AUDIO:
f0ff20a1 2487 den = (int64_t)st->time_base.num * st->codec->sample_rate;
1e51d801
FB
2488 break;
2489 case CODEC_TYPE_VIDEO:
f0ff20a1 2490 den = (int64_t)st->time_base.num * st->codec->time_base.den;
1e51d801
FB
2491 break;
2492 default:
2493 break;
2494 }
f0ff20a1
WG
2495 if (den != AV_NOPTS_VALUE) {
2496 if (den <= 0)
2497 return AVERROR_INVALIDDATA;
2498 av_frac_init(&st->pts, 0, 0, den);
2499 }
1e51d801
FB
2500 }
2501 return 0;
b9a281db
FB
2502}
2503
3c895fc0 2504//FIXME merge with compute_pkt_fields
5edea431 2505static int compute_pkt_fields2(AVStream *st, AVPacket *pkt){
504ee036
MN
2506 int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2507 int num, den, frame_size, i;
b0c7f5a9 2508
949b1a13 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);
115329f1 2510
e928649b
MN
2511/* if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2512 return -1;*/
115329f1 2513
e928649b 2514 /* duration field */
3c895fc0
MN
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 }
e928649b 2521
6e1aa0f3
MN
2522 if(pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay==0)
2523 pkt->pts= pkt->dts;
2524
e928649b 2525 //XXX/FIXME this is a temporary hack until all encoders output pts
504ee036 2526 if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
e928649b
MN
2527 pkt->dts=
2528// pkt->pts= st->cur_dts;
2529 pkt->pts= st->pts.val;
2530 }
2531
115329f1 2532 //calculate dts from pts
cb5b96cd 2533 if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
504ee036
MN
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++)
1345f4ed 2538 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
504ee036
MN
2539
2540 pkt->dts= st->pts_buffer[0];
e928649b 2541 }
115329f1 2542
5edea431 2543 if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
15061147 2544 av_log(st->codec, AV_LOG_ERROR, "error, non monotone timestamps %"PRId64" >= %"PRId64"\n", st->cur_dts, pkt->dts);
5edea431
MN
2545 return -1;
2546 }
2547 if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
15061147 2548 av_log(st->codec, AV_LOG_ERROR, "error, pts < dts\n");
5edea431
MN
2549 return -1;
2550 }
2551
949b1a13 2552// av_log(NULL, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
e928649b
MN
2553 st->cur_dts= pkt->dts;
2554 st->pts.val= pkt->dts;
2555
1e51d801 2556 /* update pts */
01f4895c 2557 switch (st->codec->codec_type) {
1e51d801 2558 case CODEC_TYPE_AUDIO:
01f4895c 2559 frame_size = get_audio_frame_size(st->codec, pkt->size);
6d8f985e 2560
a85736f2
DB
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 */
e928649b 2564 if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
9ee91c2f 2565 av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
7feb950a 2566 }
1e51d801
FB
2567 break;
2568 case CODEC_TYPE_VIDEO:
01f4895c 2569 av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
1e51d801
FB
2570 break;
2571 default:
2572 break;
2573 }
5edea431 2574 return 0;
3c895fc0
MN
2575}
2576
2577static void truncate_ts(AVStream *st, AVPacket *pkt){
2578 int64_t pts_mask = (2LL << (st->pts_wrap_bits-1)) - 1;
115329f1 2579
e0c91bc2 2580// if(pkt->dts < 0)
a85736f2 2581// pkt->dts= 0; //this happens for low_delay=0 and B-frames, FIXME, needs further investigation about what we should do here
115329f1 2582
68a432cf 2583 if (pkt->pts != AV_NOPTS_VALUE)
8533284d 2584 pkt->pts &= pts_mask;
68a432cf 2585 if (pkt->dts != AV_NOPTS_VALUE)
8533284d 2586 pkt->dts &= pts_mask;
3c895fc0
MN
2587}
2588
3c895fc0
MN
2589int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2590{
fc9c2d53 2591 int ret = compute_pkt_fields2(s->streams[pkt->stream_index], pkt);
576ae256 2592
494bbf58 2593 if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
5edea431 2594 return ret;
115329f1 2595
3c895fc0
MN
2596 truncate_ts(s->streams[pkt->stream_index], pkt);
2597
576ae256
MN
2598 ret= s->oformat->write_packet(s, pkt);
2599 if(!ret)
899681cd 2600 ret= url_ferror(s->pb);
576ae256 2601 return ret;
3c895fc0
MN
2602}
2603
f21c0b4c 2604int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
fe2d6fe2
MN
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
2577897d 2612// assert(pkt->destruct != av_destruct_packet); //FIXME
fe2d6fe2
MN
2613
2614 this_pktl = av_mallocz(sizeof(AVPacketList));
2615 this_pktl->pkt= *pkt;
2577897d 2616 if(pkt->destruct == av_destruct_packet)
a85736f2 2617 pkt->destruct= NULL; // not shared -> must keep original from being freed
2577897d
MN
2618 else
2619 av_dup_packet(&this_pktl->pkt); //shared -> must dup
fe2d6fe2
MN
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 }
115329f1 2633
fe2d6fe2
MN
2634 memset(streams, 0, sizeof(streams));
2635 pktl= s->packet_buffer;
2636 while(pktl){
949b1a13 2637//av_log(s, AV_LOG_DEBUG, "show st:%d dts:%"PRId64"\n", pktl->pkt.stream_index, pktl->pkt.dts);
fe2d6fe2
MN
2638 if(streams[ pktl->pkt.stream_index ] == 0)
2639 stream_count++;
2640 streams[ pktl->pkt.stream_index ]++;
2641 pktl= pktl->next;
2642 }
115329f1 2643
6919e54c 2644 if(stream_count && (s->nb_streams == stream_count || flush)){
fe2d6fe2
MN
2645 pktl= s->packet_buffer;
2646 *out= pktl->pkt;
115329f1
DB
2647
2648 s->packet_buffer= pktl->next;
fe2d6fe2
MN
2649 av_freep(&pktl);
2650 return 1;
2651 }else{
2652 av_init_packet(out);
2653 return 0;
2654 }
2655}
2656
2657/**
a85736f2 2658 * Interleaves an AVPacket correctly so it can be muxed.
fe2d6fe2
MN
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
115329f1 2663 * @return 1 if a packet was output, 0 if no packet could be output,
d9526386 2664 * < 0 if an error occurred
fe2d6fe2
MN
2665 */
2666static 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
3c895fc0 2673int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
3c895fc0
MN
2674 AVStream *st= s->streams[ pkt->stream_index];
2675
6f824977 2676 //FIXME/XXX/HACK drop zero sized packets
01f4895c 2677 if(st->codec->codec_type == CODEC_TYPE_AUDIO && pkt->size==0)
6f824977 2678 return 0;
3ce16b30 2679
949b1a13 2680//av_log(NULL, AV_LOG_DEBUG, "av_interleaved_write_frame %d %"PRId64" %"PRId64"\n", pkt->size, pkt->dts, pkt->pts);
494bbf58 2681 if(compute_pkt_fields2(st, pkt) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3ce16b30 2682 return -1;
115329f1 2683
3c895fc0
MN
2684 if(pkt->dts == AV_NOPTS_VALUE)
2685 return -1;
3c895fc0 2686
fe2d6fe2
MN
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;
115329f1 2692
fe2d6fe2
MN
2693 truncate_ts(s->streams[opkt.stream_index], &opkt);
2694 ret= s->oformat->write_packet(s, &opkt);
115329f1 2695
fe2d6fe2
MN
2696 av_free_packet(&opkt);
2697 pkt= NULL;
115329f1 2698
3c895fc0
MN
2699 if(ret<0)
2700 return ret;
899681cd
BA
2701 if(url_ferror(s->pb))
2702 return url_ferror(s->pb);
3c895fc0 2703 }
b9a281db
FB
2704}
2705
b9a281db
FB
2706int av_write_trailer(AVFormatContext *s)
2707{
c40a3a42 2708 int ret, i;
115329f1 2709
fe2d6fe2
MN
2710 for(;;){
2711 AVPacket pkt;
2712 ret= av_interleave_packet(s, &pkt, NULL, 1);
2713 if(ret<0) //FIXME cleanup needed for ret<0 ?
c40a3a42 2714 goto fail;
fe2d6fe2
MN
2715 if(!ret)
2716 break;
115329f1 2717
fe2d6fe2
MN
2718 truncate_ts(s->streams[pkt.stream_index], &pkt);
2719 ret= s->oformat->write_packet(s, &pkt);
115329f1 2720
fe2d6fe2 2721 av_free_packet(&pkt);
115329f1 2722
3c895fc0 2723 if(ret<0)
c40a3a42 2724 goto fail;
899681cd 2725 if(url_ferror(s->pb))
576ae256 2726 goto fail;
3c895fc0
MN
2727 }
2728
31e11451
MN
2729 if(s->oformat->write_trailer)
2730 ret = s->oformat->write_trailer(s);
c40a3a42 2731fail:
576ae256 2732 if(ret == 0)
899681cd 2733 ret=url_ferror(s->pb);
c40a3a42
MN
2734 for(i=0;i<s->nb_streams;i++)
2735 av_freep(&s->streams[i]->priv_data);
b9a281db
FB
2736 av_freep(&s->priv_data);
2737 return ret;
de6d9b64
FB
2738}
2739
526efa10
NS
2740void 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
de6d9b64 2763/* "user interface" functions */
4e745a3b 2764static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
fad0e030 2765{
4e745a3b 2766 char buf[256];
fad0e030
NS
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)
5fba300d 2782 av_log(NULL, AV_LOG_INFO, ", %5.2f tb(r)", av_q2d(st->r_frame_rate));
fad0e030 2783/* else if(st->time_base.den && st->time_base.num)
5fba300d 2784 av_log(NULL, AV_LOG_INFO, ", %5.2f tb(m)", 1/av_q2d(st->time_base));*/
fad0e030 2785 else
5fba300d 2786 av_log(NULL, AV_LOG_INFO, ", %5.2f tb(c)", 1/av_q2d(st->codec->time_base));
fad0e030
NS
2787 }
2788 av_log(NULL, AV_LOG_INFO, "\n");
2789}
de6d9b64
FB
2790
2791void dump_format(AVFormatContext *ic,
115329f1 2792 int index,
de6d9b64
FB
2793 const char *url,
2794 int is_output)
2795{
63bb42fb 2796 int i;
de6d9b64 2797
115329f1 2798 av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
de6d9b64 2799 is_output ? "Output" : "Input",
115329f1
DB
2800 index,
2801 is_output ? ic->oformat->name : ic->iformat->name,
de6d9b64 2802 is_output ? "to" : "from", url);
12f996ed 2803 if (!is_output) {
2143116d 2804 av_log(NULL, AV_LOG_INFO, " Duration: ");
12f996ed
FB
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;
d965c3e7
DB
2813 av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
2814 (100 * us) / AV_TIME_BASE);
12f996ed 2815 } else {
2143116d 2816 av_log(NULL, AV_LOG_INFO, "N/A");
12f996ed 2817 }
d0f3f159
WG
2818 if (ic->start_time != AV_NOPTS_VALUE) {
2819 int secs, us;
2143116d 2820 av_log(NULL, AV_LOG_INFO, ", start: ");
d0f3f159
WG
2821 secs = ic->start_time / AV_TIME_BASE;
2822 us = ic->start_time % AV_TIME_BASE;
2143116d 2823 av_log(NULL, AV_LOG_INFO, "%d.%06d",
d0f3f159
WG
2824 secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
2825 }
2143116d 2826 av_log(NULL, AV_LOG_INFO, ", bitrate: ");
12f996ed 2827 if (ic->bit_rate) {
2143116d 2828 av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
12f996ed 2829 } else {
2143116d 2830 av_log(NULL, AV_LOG_INFO, "N/A");
12f996ed 2831 }
2143116d 2832 av_log(NULL, AV_LOG_INFO, "\n");
12f996ed 2833 }
526efa10
NS
2834 if(ic->nb_programs) {
2835 int j, k;
2836 for(j=0; j<ic->nb_programs; j++) {
f473666f
NS
2837 av_log(NULL, AV_LOG_INFO, " Program %d %s\n", ic->programs[j]->id,
2838 ic->programs[j]->name ? ic->programs[j]->name : "");
526efa10 2839 for(k=0; k<ic->programs[j]->nb_stream_indexes; k++)
4e745a3b 2840 dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
526efa10
NS
2841 }
2842 } else
fad0e030 2843 for(i=0;i<ic->nb_streams;i++)
4e745a3b 2844 dump_stream_format(ic, i, index, is_output);
de6d9b64
FB
2845}
2846
de6d9b64
FB
2847int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
2848{
26ef3220 2849 return av_parse_video_frame_size(width_ptr, height_ptr, str);
de6d9b64
FB
2850}
2851
26ef3220 2852int parse_frame_rate(int *frame_rate_num, int *frame_rate_den, const char *arg)
445f1b83 2853{
26ef3220
SS
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;
445f1b83
RS
2859}
2860
82e4ac2c 2861/**
a85736f2 2862 * Gets the current time in microseconds.
82e4ac2c
RP
2863 */
2864int64_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
0c1a9eda 2871int64_t parse_date(const char *datestr, int duration)
de6d9b64
FB
2872{
2873 const char *p;
0c1a9eda 2874 int64_t t;
2dbceb9f 2875 struct tm dt;
c5510dd6 2876 int i;
aecf157e 2877 static const char * const date_fmt[] = {
c5510dd6
PG
2878 "%Y-%m-%d",
2879 "%Y%m%d",
2880 };
aecf157e 2881 static const char * const time_fmt[] = {
c5510dd6
PG
2882 "%H:%M:%S",
2883 "%H%M%S",
2884 };
2885 const char *q;
916c80e9 2886 int is_utc, len;
c5510dd6 2887 char lastch;
a6a92a9a 2888 int negative = 0;
6d8f985e
MN
2889
2890#undef time
c5510dd6
PG
2891 time_t now = time(0);
2892
916c80e9
FB
2893 len = strlen(datestr);
2894 if (len > 0)
2895 lastch = datestr[len - 1];
2896 else
2897 lastch = '\0';
c5510dd6 2898 is_utc = (lastch == 'z' || lastch == 'Z');
2dbceb9f
PG
2899
2900 memset(&dt, 0, sizeof(dt));
de6d9b64
FB
2901
2902 p = datestr;
916c80e9 2903 q = NULL;
de6d9b64 2904 if (!duration) {
a8f70d72 2905 /* parse the year-month-day part */
c5510dd6 2906 for (i = 0; i < sizeof(date_fmt) / sizeof(date_fmt[0]); i++) {
f71869a4 2907 q = small_strptime(p, date_fmt[i], &dt);
c5510dd6
PG
2908 if (q) {
2909 break;
2910 }
2911 }
2912
a8f70d72
SS
2913 /* if the year-month-day part is missing, then take the
2914 * current year-month-day time */
c5510dd6
PG
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;
de6d9b64 2922 } else {
c5510dd6 2923 p = q;
de6d9b64 2924 }
c5510dd6
PG
2925
2926 if (*p == 'T' || *p == 't' || *p == ' ')
2927 p++;
c5510dd6 2928
a8f70d72 2929 /* parse the hour-minute-second part */
916c80e9 2930 for (i = 0; i < sizeof(time_fmt) / sizeof(time_fmt[0]); i++) {
f71869a4 2931 q = small_strptime(p, time_fmt[i], &dt);
916c80e9
FB
2932 if (q) {
2933 break;
2934 }
2935 }
2936 } else {
a8f70d72 2937 /* parse datestr as a duration */
bb270c08
DB
2938 if (p[0] == '-') {
2939 negative = 1;
2940 ++p;
2941 }
a8f70d72 2942 /* parse datestr as HH:MM:SS */
f71869a4 2943 q = small_strptime(p, time_fmt[0], &dt);
916c80e9 2944 if (!q) {
a8f70d72 2945 /* parse datestr as S+ */
916c80e9 2946 dt.tm_sec = strtol(p, (char **)&q, 10);
f9436161
SS
2947 if (q == p)
2948 /* the parsing didn't succeed */
2949 return INT64_MIN;
916c80e9
FB
2950 dt.tm_min = 0;
2951 dt.tm_hour = 0;
c5510dd6
PG
2952 }
2953 }
2954
2955 /* Now we have all the fields that we can get */
2956 if (!q) {
f9436161 2957 return INT64_MIN;
de6d9b64 2958 }
2dbceb9f
PG
2959
2960 if (duration) {
c5510dd6 2961 t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
2dbceb9f 2962 } else {
c5510dd6
PG
2963 dt.tm_isdst = -1; /* unknown */
2964 if (is_utc) {
2965 t = mktimegm(&dt);
2966 } else {
2967 t = mktime(&dt);
2968 }
de6d9b64 2969 }
2dbceb9f 2970
c5510dd6
PG
2971 t *= 1000000;
2972
a8f70d72 2973 /* parse the .m... part */
c5510dd6 2974 if (*q == '.') {
de6d9b64 2975 int val, n;
c5510dd6
PG
2976 q++;
2977 for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
115329f1 2978 if (!isdigit(*q))
c5510dd6
PG
2979 break;
2980 val += n * (*q - '0');
de6d9b64
FB
2981 }
2982 t += val;
2983 }
a6a92a9a 2984 return negative ? -t : t;
de6d9b64
FB
2985}
2986
de6d9b64
FB
2987int 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') {
2dbceb9f
PG
3007 if ((q - arg) < arg_size - 1) {
3008 if (*p == '+')
3009 *q++ = ' ';
3010 else
3011 *q++ = *p;
3012 }
de6d9b64
FB
3013 p++;
3014 }
3015 *q = '\0';
3016 }
115329f1 3017 if (!strcmp(tag, tag1))
de6d9b64
FB
3018 return 1;
3019 if (*p != '&')
3020 break;
8d1335ea 3021 p++;
de6d9b64
FB
3022 }
3023 return 0;
3024}
3025
5c07cf53
MB
3026int av_get_frame_filename(char *buf, int buf_size,
3027 const char *path, int number)
9150f42e
FB
3028{
3029 const char *p;
0bf92f79
PI
3030 char *q, buf1[20], c;
3031 int nd, len, percentd_found;
9150f42e
FB
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 == '%') {
c9646fda
PG
3041 do {
3042 nd = 0;
3043 while (isdigit(*p)) {
3044 nd = nd * 10 + *p++ - '0';
3045 }
3046 c = *p++;
c9646fda
PG
3047 } while (isdigit(c));
3048
9150f42e
FB
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
750f0e1f 3081static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
b9a281db
FB
3082{
3083 int len, i, j, c;
750f0e1f 3084#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
b9a281db
FB
3085
3086 for(i=0;i<size;i+=16) {
3087 len = size - i;
3088 if (len > 16)
3089 len = 16;
750f0e1f 3090 PRINT("%08x ", i);
b9a281db
FB
3091 for(j=0;j<16;j++) {
3092 if (j < len)
750f0e1f 3093 PRINT(" %02x", buf[i+j]);
b9a281db 3094 else
750f0e1f 3095 PRINT(" ");
b9a281db 3096 }
750f0e1f 3097 PRINT(" ");
b9a281db
FB
3098 for(j=0;j<len;j++) {
3099 c = buf[i+j];
3100 if (c < ' ' || c > '~')
3101 c = '.';
750f0e1f 3102 PRINT("%c", c);
b9a281db 3103 }
750f0e1f 3104 PRINT("\n");
b9a281db 3105 }
750f0e1f
PI
3106#undef PRINT
3107}
3108
3109void av_hex_dump(FILE *f, uint8_t *buf, int size)
3110{
3111 hex_dump_internal(NULL, f, 0, buf, size);
3112}
3113
3114void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
3115{
3116 hex_dump_internal(avcl, NULL, level, buf, size);
b9a281db
FB
3117}
3118
c0df9d75 3119 //FIXME needs to know the time_base
750f0e1f 3120static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload)
fb2758c8 3121{
750f0e1f
PI
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);
37353960 3126 /* DTS is _always_ valid after av_read_frame() */
750f0e1f 3127 PRINT(" dts=");
37353960 3128 if (pkt->dts == AV_NOPTS_VALUE)
750f0e1f 3129 PRINT("N/A");
37353960 3130 else
750f0e1f 3131 PRINT("%0.3f", (double)pkt->dts / AV_TIME_BASE);
a85736f2 3132 /* PTS may not be known if B-frames are present. */
750f0e1f 3133 PRINT(" pts=");
fb2758c8 3134 if (pkt->pts == AV_NOPTS_VALUE)
750f0e1f 3135 PRINT("N/A");
fb2758c8 3136 else
750f0e1f
PI
3137 PRINT("%0.3f", (double)pkt->pts / AV_TIME_BASE);
3138 PRINT("\n");
3139 PRINT(" size=%d\n", pkt->size);
3140#undef PRINT
fb2758c8
FB
3141 if (dump_payload)
3142 av_hex_dump(f, pkt->data, pkt->size);
3143}
3144
750f0e1f
PI
3145void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
3146{
3147 pkt_dump_internal(NULL, f, 0, pkt, dump_payload);
3148}
3149
3150void 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
a9a721da 3155void url_split(char *proto, int proto_size,
6ba5cbc6 3156 char *authorization, int authorization_size,
a9a721da
FB
3157 char *hostname, int hostname_size,
3158 int *port_ptr,
3159 char *path, int path_size,
3160 const char *url)
3161{
7ef55085 3162 const char *p, *ls, *at, *col, *brk;
7e1e297e
RB
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++;
a9a721da 3176 } else {
7e1e297e
RB
3177 /* no protocol means plain filename */
3178 av_strlcpy(path, url, path_size);
3179 return;
3180 }
6ba5cbc6 3181
7e1e297e 3182 /* separate path from hostname */
7ef55085
MN
3183 ls = strchr(p, '/');
3184 if(!ls)
3185 ls = strchr(p, '?');
3186 if(ls)
5cc9253f 3187 av_strlcpy(path, ls, path_size);
7ef55085 3188 else
7e1e297e
RB
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 '@' */
a9a721da 3198 }
7e1e297e 3199
f8f88a42
RB
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));
a9a721da 3213 }
a9a721da
FB
3214}
3215
f1c80e35
RB
3216char *ff_data_to_hex(char *buff, const uint8_t *src, int s)
3217{
3218 int i;
452d3edb
RB
3219 static const char hex_table[16] = { '0', '1', '2', '3',
3220 '4', '5', '6', '7',
3221 '8', '9', 'A', 'B',
3222 'C', 'D', 'E', 'F' };
f1c80e35
RB
3223
3224 for(i = 0; i < s; i++) {
452d3edb
RB
3225 buff[i * 2] = hex_table[src[i] >> 4];
3226 buff[i * 2 + 1] = hex_table[src[i] & 0xF];
f1c80e35
RB
3227 }
3228
3229 return buff;
3230}
3231
9ee91c2f 3232void av_set_pts_info(AVStream *s, int pts_wrap_bits,
916c80e9
FB
3233 int pts_num, int pts_den)
3234{
283c0619 3235 unsigned int gcd= ff_gcd(pts_num, pts_den);
916c80e9