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