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