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