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