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