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