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