projects / libav.git / blob
? search:


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