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