projects / libav.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
lavf: simplify handling of offset in av_probe_input_buuffer()
[libav.git] / libavformat / utils.c
1 /*
2 * various utility functions for use within Libav
3 * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
4 *
5 * This file is part of Libav.
6 *
7 * Libav 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 * Libav 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 Libav; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20 */
21
22 #include <stdint.h>
23
24 #include "avformat.h"
25 #include "avio_internal.h"
26 #include "internal.h"
27 #include "libavcodec/internal.h"
28 #include "libavcodec/bytestream.h"
29 #include "libavutil/opt.h"
30 #include "libavutil/dict.h"
31 #include "libavutil/internal.h"
32 #include "libavutil/pixdesc.h"
33 #include "metadata.h"
34 #include "id3v2.h"
35 #include "libavutil/avassert.h"
36 #include "libavutil/avstring.h"
37 #include "libavutil/mathematics.h"
38 #include "libavutil/parseutils.h"
39 #include "libavutil/time.h"
40 #include "riff.h"
41 #include "audiointerleave.h"
42 #include "url.h"
43 #include <stdarg.h>
44 #if CONFIG_NETWORK
45 #include "network.h"
46 #endif
47
48 #undef NDEBUG
49 #include <assert.h>
50
51 /**
52 * @file
53 * various utility functions for use within Libav
54 */
55
56 unsigned avformat_version(void)
57 {
58 return LIBAVFORMAT_VERSION_INT;
59 }
60
61 const char *avformat_configuration(void)
62 {
63 return LIBAV_CONFIGURATION;
64 }
65
66 const char *avformat_license(void)
67 {
68 #define LICENSE_PREFIX "libavformat license: "
69 return LICENSE_PREFIX LIBAV_LICENSE + sizeof(LICENSE_PREFIX) - 1;
70 }
71
72 /* an arbitrarily chosen "sane" max packet size -- 50M */
73 #define SANE_CHUNK_SIZE (50000000)
74
75 /*
76 * Read the data in sane-sized chunks and append to pkt.
77 * Return the number of bytes read or an error.
78 */
79 static int append_packet_chunked(AVIOContext *s, AVPacket *pkt, int size)
80 {
81 int64_t chunk_size = size;
82 int64_t orig_pos = pkt->pos; // av_grow_packet might reset pos
83 int orig_size = pkt->size;
84 int ret = 0;
85
86 do {
87 int prev_size = pkt->size;
88 int read_size;
89
90 /*
91 * When the caller requests a lot of data, limit it to the amount left
92 * in file or SANE_CHUNK_SIZE when it is not known
93 */
94 if (size > SANE_CHUNK_SIZE) {
95 int64_t filesize = avio_size(s) - avio_tell(s);
96 chunk_size = FFMAX(filesize, SANE_CHUNK_SIZE);
97 }
98 read_size = FFMIN(size, chunk_size);
99
100 ret = av_grow_packet(pkt, read_size);
101 if (ret < 0)
102 break;
103
104 ret = avio_read(s, pkt->data + prev_size, read_size);
105 if (ret != read_size) {
106 av_shrink_packet(pkt, prev_size + FFMAX(ret, 0));
107 break;
108 }
109
110 size -= read_size;
111 } while (size > 0);
112
113 pkt->pos = orig_pos;
114 if (!pkt->size)
115 av_free_packet(pkt);
116 return pkt->size > orig_size ? pkt->size - orig_size : ret;
117 }
118
119 int av_get_packet(AVIOContext *s, AVPacket *pkt, int size)
120 {
121 av_init_packet(pkt);
122 pkt->data = NULL;
123 pkt->size = 0;
124 pkt->pos = avio_tell(s);
125
126 return append_packet_chunked(s, pkt, size);
127 }
128
129 int av_append_packet(AVIOContext *s, AVPacket *pkt, int size)
130 {
131 if (!pkt->size)
132 return av_get_packet(s, pkt, size);
133 return append_packet_chunked(s, pkt, size);
134 }
135
136
137 int av_filename_number_test(const char *filename)
138 {
139 char buf[1024];
140 return filename && (av_get_frame_filename(buf, sizeof(buf), filename, 1)>=0);
141 }
142
143 AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max)
144 {
145 AVProbeData lpd = *pd;
146 AVInputFormat *fmt1 = NULL, *fmt;
147 int score, id3 = 0;
148
149 if (lpd.buf_size > 10 && ff_id3v2_match(lpd.buf, ID3v2_DEFAULT_MAGIC)) {
150 int id3len = ff_id3v2_tag_len(lpd.buf);
151 if (lpd.buf_size > id3len + 16) {
152 lpd.buf += id3len;
153 lpd.buf_size -= id3len;
154 }
155 id3 = 1;
156 }
157
158 fmt = NULL;
159 while ((fmt1 = av_iformat_next(fmt1))) {
160 if (!is_opened == !(fmt1->flags & AVFMT_NOFILE))
161 continue;
162 score = 0;
163 if (fmt1->read_probe) {
164 score = fmt1->read_probe(&lpd);
165 } else if (fmt1->extensions) {
166 if (av_match_ext(lpd.filename, fmt1->extensions)) {
167 score = AVPROBE_SCORE_EXTENSION;
168 }
169 }
170 if (score > *score_max) {
171 *score_max = score;
172 fmt = fmt1;
173 }else if (score == *score_max)
174 fmt = NULL;
175 }
176
177 /* a hack for files with huge id3v2 tags -- try to guess by file extension. */
178 if (!fmt && is_opened && *score_max < AVPROBE_SCORE_EXTENSION / 2) {
179 while ((fmt = av_iformat_next(fmt)))
180 if (fmt->extensions && av_match_ext(lpd.filename, fmt->extensions)) {
181 *score_max = AVPROBE_SCORE_EXTENSION / 2;
182 break;
183 }
184 }
185
186 if (!fmt && id3 && *score_max < AVPROBE_SCORE_EXTENSION / 2 - 1) {
187 while ((fmt = av_iformat_next(fmt)))
188 if (fmt->extensions && av_match_ext("mp3", fmt->extensions)) {
189 *score_max = AVPROBE_SCORE_EXTENSION / 2 - 1;
190 break;
191 }
192 }
193
194 return fmt;
195 }
196
197 AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened){
198 int score=0;
199 return av_probe_input_format2(pd, is_opened, &score);
200 }
201
202 static int set_codec_from_probe_data(AVFormatContext *s, AVStream *st, AVProbeData *pd, int score)
203 {
204 static const struct {
205 const char *name; enum AVCodecID id; enum AVMediaType type;
206 } fmt_id_type[] = {
207 { "aac" , AV_CODEC_ID_AAC , AVMEDIA_TYPE_AUDIO },
208 { "ac3" , AV_CODEC_ID_AC3 , AVMEDIA_TYPE_AUDIO },
209 { "dts" , AV_CODEC_ID_DTS , AVMEDIA_TYPE_AUDIO },
210 { "eac3" , AV_CODEC_ID_EAC3 , AVMEDIA_TYPE_AUDIO },
211 { "h264" , AV_CODEC_ID_H264 , AVMEDIA_TYPE_VIDEO },
212 { "m4v" , AV_CODEC_ID_MPEG4 , AVMEDIA_TYPE_VIDEO },
213 { "mp3" , AV_CODEC_ID_MP3 , AVMEDIA_TYPE_AUDIO },
214 { "mpegvideo", AV_CODEC_ID_MPEG2VIDEO, AVMEDIA_TYPE_VIDEO },
215 { 0 }
216 };
217 AVInputFormat *fmt = av_probe_input_format2(pd, 1, &score);
218
219 if (fmt) {
220 int i;
221 av_log(s, AV_LOG_DEBUG, "Probe with size=%d, packets=%d detected %s with score=%d\n",
222 pd->buf_size, MAX_PROBE_PACKETS - st->probe_packets, fmt->name, score);
223 for (i = 0; fmt_id_type[i].name; i++) {
224 if (!strcmp(fmt->name, fmt_id_type[i].name)) {
225 st->codec->codec_id = fmt_id_type[i].id;
226 st->codec->codec_type = fmt_id_type[i].type;
227 break;
228 }
229 }
230 }
231 return !!fmt;
232 }
233
234 /************************************************************/
235 /* input media file */
236
237 /** size of probe buffer, for guessing file type from file contents */
238 #define PROBE_BUF_MIN 2048
239 #define PROBE_BUF_MAX (1<<20)
240
241 int av_probe_input_buffer(AVIOContext *pb, AVInputFormat **fmt,
242 const char *filename, void *logctx,
243 unsigned int offset, unsigned int max_probe_size)
244 {
245 AVProbeData pd = { filename ? filename : "" };
246 unsigned char *buf = NULL;
247 int ret = 0, probe_size;
248
249 if (!max_probe_size) {
250 max_probe_size = PROBE_BUF_MAX;
251 } else if (max_probe_size > PROBE_BUF_MAX) {
252 max_probe_size = PROBE_BUF_MAX;
253 } else if (max_probe_size < PROBE_BUF_MIN) {
254 return AVERROR(EINVAL);
255 }
256
257 if (offset >= max_probe_size) {
258 return AVERROR(EINVAL);
259 }
260 avio_skip(pb, offset);
261 max_probe_size -= offset;
262
263 for(probe_size= PROBE_BUF_MIN; probe_size<=max_probe_size && !*fmt;
264 probe_size = FFMIN(probe_size<<1, FFMAX(max_probe_size, probe_size+1))) {
265 int score = probe_size < max_probe_size ? AVPROBE_SCORE_MAX/4 : 0;
266 int buf_offset = (probe_size == PROBE_BUF_MIN) ? 0 : probe_size>>1;
267
268 /* read probe data */
269 if ((ret = av_reallocp(&buf, probe_size + AVPROBE_PADDING_SIZE)) < 0)
270 return ret;
271 if ((ret = avio_read(pb, buf + buf_offset, probe_size - buf_offset)) < 0) {
272 /* fail if error was not end of file, otherwise, lower score */
273 if (ret != AVERROR_EOF) {
274 av_free(buf);
275 return ret;
276 }
277 score = 0;
278 ret = 0; /* error was end of file, nothing read */
279 }
280 pd.buf_size += ret;
281 pd.buf = buf;
282
283 memset(pd.buf + pd.buf_size, 0, AVPROBE_PADDING_SIZE);
284
285 /* guess file format */
286 *fmt = av_probe_input_format2(&pd, 1, &score);
287 if(*fmt){
288 if(score <= AVPROBE_SCORE_MAX/4){ //this can only be true in the last iteration
289 av_log(logctx, AV_LOG_WARNING, "Format detected only with low score of %d, misdetection possible!\n", score);
290 }else
291 av_log(logctx, AV_LOG_DEBUG, "Probed with size=%d and score=%d\n", probe_size, score);
292 }
293 }
294
295 if (!*fmt) {
296 av_free(buf);
297 return AVERROR_INVALIDDATA;
298 }
299
300 /* rewind. reuse probe buffer to avoid seeking */
301 if ((ret = ffio_rewind_with_probe_data(pb, buf, pd.buf_size)) < 0)
302 av_free(buf);
303
304 return ret;
305 }
306
307 /* open input file and probe the format if necessary */
308 static int init_input(AVFormatContext *s, const char *filename, AVDictionary **options)
309 {
310 int ret;
311 AVProbeData pd = {filename, NULL, 0};
312
313 if (s->pb) {
314 s->flags |= AVFMT_FLAG_CUSTOM_IO;
315 if (!s->iformat)
316 return av_probe_input_buffer(s->pb, &s->iformat, filename, s, 0, s->probesize);
317 else if (s->iformat->flags & AVFMT_NOFILE)
318 return AVERROR(EINVAL);
319 return 0;
320 }
321
322 if ( (s->iformat && s->iformat->flags & AVFMT_NOFILE) ||
323 (!s->iformat && (s->iformat = av_probe_input_format(&pd, 0))))
324 return 0;
325
326 if ((ret = avio_open2(&s->pb, filename, AVIO_FLAG_READ,
327 &s->interrupt_callback, options)) < 0)
328 return ret;
329 if (s->iformat)
330 return 0;
331 return av_probe_input_buffer(s->pb, &s->iformat, filename, s, 0, s->probesize);
332 }
333
334 static AVPacket *add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt,
335 AVPacketList **plast_pktl){
336 AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
337 if (!pktl)
338 return NULL;
339
340 if (*packet_buffer)
341 (*plast_pktl)->next = pktl;
342 else
343 *packet_buffer = pktl;
344
345 /* add the packet in the buffered packet list */
346 *plast_pktl = pktl;
347 pktl->pkt= *pkt;
348 return &pktl->pkt;
349 }
350
351 static int queue_attached_pictures(AVFormatContext *s)
352 {
353 int i;
354 for (i = 0; i < s->nb_streams; i++)
355 if (s->streams[i]->disposition & AV_DISPOSITION_ATTACHED_PIC &&
356 s->streams[i]->discard < AVDISCARD_ALL) {
357 AVPacket copy = s->streams[i]->attached_pic;
358 copy.buf = av_buffer_ref(copy.buf);
359 if (!copy.buf)
360 return AVERROR(ENOMEM);
361
362 add_to_pktbuf(&s->raw_packet_buffer, &copy, &s->raw_packet_buffer_end);
363 }
364 return 0;
365 }
366
367 int avformat_open_input(AVFormatContext **ps, const char *filename, AVInputFormat *fmt, AVDictionary **options)
368 {
369 AVFormatContext *s = *ps;
370 int ret = 0;
371 AVDictionary *tmp = NULL;
372 ID3v2ExtraMeta *id3v2_extra_meta = NULL;
373
374 if (!s && !(s = avformat_alloc_context()))
375 return AVERROR(ENOMEM);
376 if (fmt)
377 s->iformat = fmt;
378
379 if (options)
380 av_dict_copy(&tmp, *options, 0);
381
382 if ((ret = av_opt_set_dict(s, &tmp)) < 0)
383 goto fail;
384
385 if ((ret = init_input(s, filename, &tmp)) < 0)
386 goto fail;
387
388 /* check filename in case an image number is expected */
389 if (s->iformat->flags & AVFMT_NEEDNUMBER) {
390 if (!av_filename_number_test(filename)) {
391 ret = AVERROR(EINVAL);
392 goto fail;
393 }
394 }
395
396 s->duration = s->start_time = AV_NOPTS_VALUE;
397 av_strlcpy(s->filename, filename ? filename : "", sizeof(s->filename));
398
399 /* allocate private data */
400 if (s->iformat->priv_data_size > 0) {
401 if (!(s->priv_data = av_mallocz(s->iformat->priv_data_size))) {
402 ret = AVERROR(ENOMEM);
403 goto fail;
404 }
405 if (s->iformat->priv_class) {
406 *(const AVClass**)s->priv_data = s->iformat->priv_class;
407 av_opt_set_defaults(s->priv_data);
408 if ((ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
409 goto fail;
410 }
411 }
412
413 /* e.g. AVFMT_NOFILE formats will not have a AVIOContext */
414 if (s->pb)
415 ff_id3v2_read(s, ID3v2_DEFAULT_MAGIC, &id3v2_extra_meta);
416
417 if (s->iformat->read_header)
418 if ((ret = s->iformat->read_header(s)) < 0)
419 goto fail;
420
421 if (id3v2_extra_meta &&
422 (ret = ff_id3v2_parse_apic(s, &id3v2_extra_meta)) < 0)
423 goto fail;
424 ff_id3v2_free_extra_meta(&id3v2_extra_meta);
425
426 if ((ret = queue_attached_pictures(s)) < 0)
427 goto fail;
428
429 if (s->pb && !s->data_offset)
430 s->data_offset = avio_tell(s->pb);
431
432 s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
433
434 if (options) {
435 av_dict_free(options);
436 *options = tmp;
437 }
438 *ps = s;
439 return 0;
440
441 fail:
442 ff_id3v2_free_extra_meta(&id3v2_extra_meta);
443 av_dict_free(&tmp);
444 if (s->pb && !(s->flags & AVFMT_FLAG_CUSTOM_IO))
445 avio_close(s->pb);
446 avformat_free_context(s);
447 *ps = NULL;
448 return ret;
449 }
450
451 /*******************************************************/
452
453 static int probe_codec(AVFormatContext *s, AVStream *st, const AVPacket *pkt)
454 {
455 if(st->codec->codec_id == AV_CODEC_ID_PROBE){
456 AVProbeData *pd = &st->probe_data;
457 av_log(s, AV_LOG_DEBUG, "probing stream %d\n", st->index);
458 --st->probe_packets;
459
460 if (pkt) {
461 int err;
462 if ((err = av_reallocp(&pd->buf, pd->buf_size + pkt->size +
463 AVPROBE_PADDING_SIZE)) < 0)
464 return err;
465 memcpy(pd->buf+pd->buf_size, pkt->data, pkt->size);
466 pd->buf_size += pkt->size;
467 memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
468 } else {
469 st->probe_packets = 0;
470 if (!pd->buf_size) {
471 av_log(s, AV_LOG_ERROR, "nothing to probe for stream %d\n",
472 st->index);
473 return 0;
474 }
475 }
476
477 if (!st->probe_packets ||
478 av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)) {
479 set_codec_from_probe_data(s, st, pd, st->probe_packets > 0 ? AVPROBE_SCORE_MAX/4 : 0);
480 if(st->codec->codec_id != AV_CODEC_ID_PROBE){
481 pd->buf_size=0;
482 av_freep(&pd->buf);
483 av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
484 }
485 }
486 }
487 return 0;
488 }
489
490 int ff_read_packet(AVFormatContext *s, AVPacket *pkt)
491 {
492 int ret, i, err;
493 AVStream *st;
494
495 for(;;){
496 AVPacketList *pktl = s->raw_packet_buffer;
497
498 if (pktl) {
499 *pkt = pktl->pkt;
500 st = s->streams[pkt->stream_index];
501 if (st->codec->codec_id != AV_CODEC_ID_PROBE || !st->probe_packets ||
502 s->raw_packet_buffer_remaining_size < pkt->size) {
503 AVProbeData *pd;
504 if (st->probe_packets) {
505 if ((err = probe_codec(s, st, NULL)) < 0)
506 return err;
507 }
508 pd = &st->probe_data;
509 av_freep(&pd->buf);
510 pd->buf_size = 0;
511 s->raw_packet_buffer = pktl->next;
512 s->raw_packet_buffer_remaining_size += pkt->size;
513 av_free(pktl);
514 return 0;
515 }
516 }
517
518 pkt->data = NULL;
519 pkt->size = 0;
520 av_init_packet(pkt);
521 ret= s->iformat->read_packet(s, pkt);
522 if (ret < 0) {
523 if (!pktl || ret == AVERROR(EAGAIN))
524 return ret;
525 for (i = 0; i < s->nb_streams; i++) {
526 st = s->streams[i];
527 if (st->probe_packets) {
528 if ((err = probe_codec(s, st, NULL)) < 0)
529 return err;
530 }
531 }
532 continue;
533 }
534
535 if ((s->flags & AVFMT_FLAG_DISCARD_CORRUPT) &&
536 (pkt->flags & AV_PKT_FLAG_CORRUPT)) {
537 av_log(s, AV_LOG_WARNING,
538 "Dropped corrupted packet (stream = %d)\n",
539 pkt->stream_index);
540 av_free_packet(pkt);
541 continue;
542 }
543
544 st= s->streams[pkt->stream_index];
545
546 switch(st->codec->codec_type){
547 case AVMEDIA_TYPE_VIDEO:
548 if(s->video_codec_id) st->codec->codec_id= s->video_codec_id;
549 break;
550 case AVMEDIA_TYPE_AUDIO:
551 if(s->audio_codec_id) st->codec->codec_id= s->audio_codec_id;
552 break;
553 case AVMEDIA_TYPE_SUBTITLE:
554 if(s->subtitle_codec_id)st->codec->codec_id= s->subtitle_codec_id;
555 break;
556 }
557
558 if(!pktl && (st->codec->codec_id != AV_CODEC_ID_PROBE ||
559 !st->probe_packets))
560 return ret;
561
562 add_to_pktbuf(&s->raw_packet_buffer, pkt, &s->raw_packet_buffer_end);
563 s->raw_packet_buffer_remaining_size -= pkt->size;
564
565 if ((err = probe_codec(s, st, pkt)) < 0)
566 return err;
567 }
568 }
569
570 /**********************************************************/
571
572 /**
573 * Get the number of samples of an audio frame. Return -1 on error.
574 */
575 int ff_get_audio_frame_size(AVCodecContext *enc, int size, int mux)
576 {
577 int frame_size;
578
579 /* give frame_size priority if demuxing */
580 if (!mux && enc->frame_size > 1)
581 return enc->frame_size;
582
583 if ((frame_size = av_get_audio_frame_duration(enc, size)) > 0)
584 return frame_size;
585
586 /* Fall back on using frame_size if muxing. */
587 if (enc->frame_size > 1)
588 return enc->frame_size;
589
590 return -1;
591 }
592
593
594 /**
595 * Return the frame duration in seconds. Return 0 if not available.
596 */
597 void ff_compute_frame_duration(int *pnum, int *pden, AVStream *st,
598 AVCodecParserContext *pc, AVPacket *pkt)
599 {
600 int frame_size;
601
602 *pnum = 0;
603 *pden = 0;
604 switch(st->codec->codec_type) {
605 case AVMEDIA_TYPE_VIDEO:
606 if (st->avg_frame_rate.num) {
607 *pnum = st->avg_frame_rate.den;
608 *pden = st->avg_frame_rate.num;
609 } else if(st->time_base.num*1000LL > st->time_base.den) {
610 *pnum = st->time_base.num;
611 *pden = st->time_base.den;
612 }else if(st->codec->time_base.num*1000LL > st->codec->time_base.den){
613 *pnum = st->codec->time_base.num;
614 *pden = st->codec->time_base.den;
615 if (pc && pc->repeat_pict) {
616 if (*pnum > INT_MAX / (1 + pc->repeat_pict))
617 *pden /= 1 + pc->repeat_pict;
618 else
619 *pnum *= 1 + pc->repeat_pict;
620 }
621 //If this codec can be interlaced or progressive then we need a parser to compute duration of a packet
622 //Thus if we have no parser in such case leave duration undefined.
623 if(st->codec->ticks_per_frame>1 && !pc){
624 *pnum = *pden = 0;
625 }
626 }
627 break;
628 case AVMEDIA_TYPE_AUDIO:
629 frame_size = ff_get_audio_frame_size(st->codec, pkt->size, 0);
630 if (frame_size <= 0 || st->codec->sample_rate <= 0)
631 break;
632 *pnum = frame_size;
633 *pden = st->codec->sample_rate;
634 break;
635 default:
636 break;
637 }
638 }
639
640 static int is_intra_only(enum AVCodecID id)
641 {
642 const AVCodecDescriptor *d = avcodec_descriptor_get(id);
643 if (!d)
644 return 0;
645 if (d->type == AVMEDIA_TYPE_VIDEO && !(d->props & AV_CODEC_PROP_INTRA_ONLY))
646 return 0;
647 return 1;
648 }
649
650 static void update_initial_timestamps(AVFormatContext *s, int stream_index,
651 int64_t dts, int64_t pts)
652 {
653 AVStream *st= s->streams[stream_index];
654 AVPacketList *pktl= s->packet_buffer;
655
656 if(st->first_dts != AV_NOPTS_VALUE || dts == AV_NOPTS_VALUE || st->cur_dts == AV_NOPTS_VALUE)
657 return;
658
659 st->first_dts= dts - st->cur_dts;
660 st->cur_dts= dts;
661
662 for(; pktl; pktl= pktl->next){
663 if(pktl->pkt.stream_index != stream_index)
664 continue;
665 //FIXME think more about this check
666 if(pktl->pkt.pts != AV_NOPTS_VALUE && pktl->pkt.pts == pktl->pkt.dts)
667 pktl->pkt.pts += st->first_dts;
668
669 if(pktl->pkt.dts != AV_NOPTS_VALUE)
670 pktl->pkt.dts += st->first_dts;
671
672 if(st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
673 st->start_time= pktl->pkt.pts;
674 }
675 if (st->start_time == AV_NOPTS_VALUE)
676 st->start_time = pts;
677 }
678
679 static void update_initial_durations(AVFormatContext *s, AVStream *st,
680 int stream_index, int duration)
681 {
682 AVPacketList *pktl= s->packet_buffer;
683 int64_t cur_dts= 0;
684
685 if(st->first_dts != AV_NOPTS_VALUE){
686 cur_dts= st->first_dts;
687 for(; pktl; pktl= pktl->next){
688 if(pktl->pkt.stream_index == stream_index){
689 if(pktl->pkt.pts != pktl->pkt.dts || pktl->pkt.dts != AV_NOPTS_VALUE || pktl->pkt.duration)
690 break;
691 cur_dts -= duration;
692 }
693 }
694 pktl= s->packet_buffer;
695 st->first_dts = cur_dts;
696 }else if(st->cur_dts)
697 return;
698
699 for(; pktl; pktl= pktl->next){
700 if(pktl->pkt.stream_index != stream_index)
701 continue;
702 if(pktl->pkt.pts == pktl->pkt.dts && pktl->pkt.dts == AV_NOPTS_VALUE
703 && !pktl->pkt.duration){
704 pktl->pkt.dts= cur_dts;
705 if(!st->codec->has_b_frames)
706 pktl->pkt.pts= cur_dts;
707 cur_dts += duration;
708 if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO)
709 pktl->pkt.duration = duration;
710 }else
711 break;
712 }
713 if(st->first_dts == AV_NOPTS_VALUE)
714 st->cur_dts= cur_dts;
715 }
716
717 static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
718 AVCodecParserContext *pc, AVPacket *pkt)
719 {
720 int num, den, presentation_delayed, delay, i;
721 int64_t offset;
722
723 if (s->flags & AVFMT_FLAG_NOFILLIN)
724 return;
725
726 if((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
727 pkt->dts= AV_NOPTS_VALUE;
728
729 /* do we have a video B-frame ? */
730 delay= st->codec->has_b_frames;
731 presentation_delayed = 0;
732
733 /* XXX: need has_b_frame, but cannot get it if the codec is
734 not initialized */
735 if (delay &&
736 pc && pc->pict_type != AV_PICTURE_TYPE_B)
737 presentation_delayed = 1;
738
739 if (pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE &&
740 st->pts_wrap_bits < 63 &&
741 pkt->dts - (1LL << (st->pts_wrap_bits - 1)) > pkt->pts) {
742 pkt->dts -= 1LL<<st->pts_wrap_bits;
743 }
744
745 // some mpeg2 in mpeg-ps lack dts (issue171 / input_file.mpg)
746 // we take the conservative approach and discard both
747 // Note, if this is misbehaving for a H.264 file then possibly presentation_delayed is not set correctly.
748 if(delay==1 && pkt->dts == pkt->pts && pkt->dts != AV_NOPTS_VALUE && presentation_delayed){
749 av_log(s, AV_LOG_DEBUG, "invalid dts/pts combination\n");
750 pkt->dts= pkt->pts= AV_NOPTS_VALUE;
751 }
752
753 if (pkt->duration == 0 && st->codec->codec_type != AVMEDIA_TYPE_AUDIO) {
754 ff_compute_frame_duration(&num, &den, st, pc, pkt);
755 if (den && num) {
756 pkt->duration = av_rescale_rnd(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num, AV_ROUND_DOWN);
757
758 if(pkt->duration != 0 && s->packet_buffer)
759 update_initial_durations(s, st, pkt->stream_index, pkt->duration);
760 }
761 }
762
763 /* correct timestamps with byte offset if demuxers only have timestamps
764 on packet boundaries */
765 if(pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size){
766 /* this will estimate bitrate based on this frame's duration and size */
767 offset = av_rescale(pc->offset, pkt->duration, pkt->size);
768 if(pkt->pts != AV_NOPTS_VALUE)
769 pkt->pts += offset;
770 if(pkt->dts != AV_NOPTS_VALUE)
771 pkt->dts += offset;
772 }
773
774 /* This may be redundant, but it should not hurt. */
775 if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
776 presentation_delayed = 1;
777
778 av_dlog(NULL,
779 "IN delayed:%d pts:%"PRId64", dts:%"PRId64" cur_dts:%"PRId64" st:%d pc:%p\n",
780 presentation_delayed, pkt->pts, pkt->dts, st->cur_dts,
781 pkt->stream_index, pc);
782 /* interpolate PTS and DTS if they are not present */
783 //We skip H264 currently because delay and has_b_frames are not reliably set
784 if((delay==0 || (delay==1 && pc)) && st->codec->codec_id != AV_CODEC_ID_H264){
785 if (presentation_delayed) {
786 /* DTS = decompression timestamp */
787 /* PTS = presentation timestamp */
788 if (pkt->dts == AV_NOPTS_VALUE)
789 pkt->dts = st->last_IP_pts;
790 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts);
791 if (pkt->dts == AV_NOPTS_VALUE)
792 pkt->dts = st->cur_dts;
793
794 /* this is tricky: the dts must be incremented by the duration
795 of the frame we are displaying, i.e. the last I- or P-frame */
796 if (st->last_IP_duration == 0)
797 st->last_IP_duration = pkt->duration;
798 if(pkt->dts != AV_NOPTS_VALUE)
799 st->cur_dts = pkt->dts + st->last_IP_duration;
800 st->last_IP_duration = pkt->duration;
801 st->last_IP_pts= pkt->pts;
802 /* cannot compute PTS if not present (we can compute it only
803 by knowing the future */
804 } else if (pkt->pts != AV_NOPTS_VALUE ||
805 pkt->dts != AV_NOPTS_VALUE ||
806 pkt->duration ||
807 st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
808 int duration = pkt->duration;
809 if (!duration && st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
810 ff_compute_frame_duration(&num, &den, st, pc, pkt);
811 if (den && num) {
812 duration = av_rescale_rnd(1, num * (int64_t)st->time_base.den,
813 den * (int64_t)st->time_base.num,
814 AV_ROUND_DOWN);
815 if (duration != 0 && s->packet_buffer) {
816 update_initial_durations(s, st, pkt->stream_index,
817 duration);
818 }
819 }
820 }
821
822 if (pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE ||
823 duration) {
824 /* presentation is not delayed : PTS and DTS are the same */
825 if (pkt->pts == AV_NOPTS_VALUE)
826 pkt->pts = pkt->dts;
827 update_initial_timestamps(s, pkt->stream_index, pkt->pts,
828 pkt->pts);
829 if (pkt->pts == AV_NOPTS_VALUE)
830 pkt->pts = st->cur_dts;
831 pkt->dts = pkt->pts;
832 if (pkt->pts != AV_NOPTS_VALUE)
833 st->cur_dts = pkt->pts + duration;
834 }
835 }
836 }
837
838 if(pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
839 st->pts_buffer[0]= pkt->pts;
840 for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
841 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
842 if(pkt->dts == AV_NOPTS_VALUE)
843 pkt->dts= st->pts_buffer[0];
844 if(st->codec->codec_id == AV_CODEC_ID_H264){ // we skipped it above so we try here
845 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts); // this should happen on the first packet
846 }
847 if(pkt->dts > st->cur_dts)
848 st->cur_dts = pkt->dts;
849 }
850
851 av_dlog(NULL,
852 "OUTdelayed:%d/%d pts:%"PRId64", dts:%"PRId64" cur_dts:%"PRId64"\n",
853 presentation_delayed, delay, pkt->pts, pkt->dts, st->cur_dts);
854
855 /* update flags */
856 if (is_intra_only(st->codec->codec_id))
857 pkt->flags |= AV_PKT_FLAG_KEY;
858 if (pc)
859 pkt->convergence_duration = pc->convergence_duration;
860 }
861
862 static void free_packet_buffer(AVPacketList **pkt_buf, AVPacketList **pkt_buf_end)
863 {
864 while (*pkt_buf) {
865 AVPacketList *pktl = *pkt_buf;
866 *pkt_buf = pktl->next;
867 av_free_packet(&pktl->pkt);
868 av_freep(&pktl);
869 }
870 *pkt_buf_end = NULL;
871 }
872
873 /**
874 * Parse a packet, add all split parts to parse_queue
875 *
876 * @param pkt packet to parse, NULL when flushing the parser at end of stream
877 */
878 static int parse_packet(AVFormatContext *s, AVPacket *pkt, int stream_index)
879 {
880 AVPacket out_pkt = { 0 }, flush_pkt = { 0 };
881 AVStream *st = s->streams[stream_index];
882 uint8_t *data = pkt ? pkt->data : NULL;
883 int size = pkt ? pkt->size : 0;
884 int ret = 0, got_output = 0;
885
886 if (!pkt) {
887 av_init_packet(&flush_pkt);
888 pkt = &flush_pkt;
889 got_output = 1;
890 }
891
892 while (size > 0 || (pkt == &flush_pkt && got_output)) {
893 int len;
894
895 av_init_packet(&out_pkt);
896 len = av_parser_parse2(st->parser, st->codec,
897 &out_pkt.data, &out_pkt.size, data, size,
898 pkt->pts, pkt->dts, pkt->pos);
899
900 pkt->pts = pkt->dts = AV_NOPTS_VALUE;
901 /* increment read pointer */
902 data += len;
903 size -= len;
904
905 got_output = !!out_pkt.size;
906
907 if (!out_pkt.size)
908 continue;
909
910 if (pkt->side_data) {
911 out_pkt.side_data = pkt->side_data;
912 out_pkt.side_data_elems = pkt->side_data_elems;
913 pkt->side_data = NULL;
914 pkt->side_data_elems = 0;
915 }
916
917 /* set the duration */
918 out_pkt.duration = 0;
919 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
920 if (st->codec->sample_rate > 0) {
921 out_pkt.duration = av_rescale_q_rnd(st->parser->duration,
922 (AVRational){ 1, st->codec->sample_rate },
923 st->time_base,
924 AV_ROUND_DOWN);
925 }
926 } else if (st->codec->time_base.num != 0 &&
927 st->codec->time_base.den != 0) {
928 out_pkt.duration = av_rescale_q_rnd(st->parser->duration,
929 st->codec->time_base,
930 st->time_base,
931 AV_ROUND_DOWN);
932 }
933
934 out_pkt.stream_index = st->index;
935 out_pkt.pts = st->parser->pts;
936 out_pkt.dts = st->parser->dts;
937 out_pkt.pos = st->parser->pos;
938
939 if (st->parser->key_frame == 1 ||
940 (st->parser->key_frame == -1 &&
941 st->parser->pict_type == AV_PICTURE_TYPE_I))
942 out_pkt.flags |= AV_PKT_FLAG_KEY;
943
944 compute_pkt_fields(s, st, st->parser, &out_pkt);
945
946 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
947 out_pkt.flags & AV_PKT_FLAG_KEY) {
948 ff_reduce_index(s, st->index);
949 av_add_index_entry(st, st->parser->frame_offset, out_pkt.dts,
950 0, 0, AVINDEX_KEYFRAME);
951 }
952
953 if (out_pkt.data == pkt->data && out_pkt.size == pkt->size) {
954 out_pkt.buf = pkt->buf;
955 pkt->buf = NULL;
956 #if FF_API_DESTRUCT_PACKET
957 FF_DISABLE_DEPRECATION_WARNINGS
958 out_pkt.destruct = pkt->destruct;
959 pkt->destruct = NULL;
960 FF_ENABLE_DEPRECATION_WARNINGS
961 #endif
962 }
963 if ((ret = av_dup_packet(&out_pkt)) < 0)
964 goto fail;
965
966 if (!add_to_pktbuf(&s->parse_queue, &out_pkt, &s->parse_queue_end)) {
967 av_free_packet(&out_pkt);
968 ret = AVERROR(ENOMEM);
969 goto fail;
970 }
971 }
972
973
974 /* end of the stream => close and free the parser */
975 if (pkt == &flush_pkt) {
976 av_parser_close(st->parser);
977 st->parser = NULL;
978 }
979
980 fail:
981 av_free_packet(pkt);
982 return ret;
983 }
984
985 static int read_from_packet_buffer(AVPacketList **pkt_buffer,
986 AVPacketList **pkt_buffer_end,
987 AVPacket *pkt)
988 {
989 AVPacketList *pktl;
990 av_assert0(*pkt_buffer);
991 pktl = *pkt_buffer;
992 *pkt = pktl->pkt;
993 *pkt_buffer = pktl->next;
994 if (!pktl->next)
995 *pkt_buffer_end = NULL;
996 av_freep(&pktl);
997 return 0;
998 }
999
1000 static int read_frame_internal(AVFormatContext *s, AVPacket *pkt)
1001 {
1002 int ret = 0, i, got_packet = 0;
1003
1004 av_init_packet(pkt);
1005
1006 while (!got_packet && !s->parse_queue) {
1007 AVStream *st;
1008 AVPacket cur_pkt;
1009
1010 /* read next packet */
1011 ret = ff_read_packet(s, &cur_pkt);
1012 if (ret < 0) {
1013 if (ret == AVERROR(EAGAIN))
1014 return ret;
1015 /* flush the parsers */
1016 for(i = 0; i < s->nb_streams; i++) {
1017 st = s->streams[i];
1018 if (st->parser && st->need_parsing)
1019 parse_packet(s, NULL, st->index);
1020 }
1021 /* all remaining packets are now in parse_queue =>
1022 * really terminate parsing */
1023 break;
1024 }
1025 ret = 0;
1026 st = s->streams[cur_pkt.stream_index];
1027
1028 if (cur_pkt.pts != AV_NOPTS_VALUE &&
1029 cur_pkt.dts != AV_NOPTS_VALUE &&
1030 cur_pkt.pts < cur_pkt.dts) {
1031 av_log(s, AV_LOG_WARNING, "Invalid timestamps stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
1032 cur_pkt.stream_index,
1033 cur_pkt.pts,
1034 cur_pkt.dts,
1035 cur_pkt.size);
1036 }
1037 if (s->debug & FF_FDEBUG_TS)
1038 av_log(s, AV_LOG_DEBUG, "ff_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, duration=%d, flags=%d\n",
1039 cur_pkt.stream_index,
1040 cur_pkt.pts,
1041 cur_pkt.dts,
1042 cur_pkt.size,
1043 cur_pkt.duration,
1044 cur_pkt.flags);
1045
1046 if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1047 st->parser = av_parser_init(st->codec->codec_id);
1048 if (!st->parser) {
1049 /* no parser available: just output the raw packets */
1050 st->need_parsing = AVSTREAM_PARSE_NONE;
1051 } else if(st->need_parsing == AVSTREAM_PARSE_HEADERS) {
1052 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1053 } else if(st->need_parsing == AVSTREAM_PARSE_FULL_ONCE) {
1054 st->parser->flags |= PARSER_FLAG_ONCE;
1055 }
1056 }
1057
1058 if (!st->need_parsing || !st->parser) {
1059 /* no parsing needed: we just output the packet as is */
1060 *pkt = cur_pkt;
1061 compute_pkt_fields(s, st, NULL, pkt);
1062 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1063 (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
1064 ff_reduce_index(s, st->index);
1065 av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1066 }
1067 got_packet = 1;
1068 } else if (st->discard < AVDISCARD_ALL) {
1069 if ((ret = parse_packet(s, &cur_pkt, cur_pkt.stream_index)) < 0)
1070 return ret;
1071 } else {
1072 /* free packet */
1073 av_free_packet(&cur_pkt);
1074 }
1075 }
1076
1077 if (!got_packet && s->parse_queue)
1078 ret = read_from_packet_buffer(&s->parse_queue, &s->parse_queue_end, pkt);
1079
1080 if(s->debug & FF_FDEBUG_TS)
1081 av_log(s, AV_LOG_DEBUG, "read_frame_internal stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, duration=%d, flags=%d\n",
1082 pkt->stream_index,
1083 pkt->pts,
1084 pkt->dts,
1085 pkt->size,
1086 pkt->duration,
1087 pkt->flags);
1088
1089 return ret;
1090 }
1091
1092 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1093 {
1094 const int genpts = s->flags & AVFMT_FLAG_GENPTS;
1095 int eof = 0;
1096
1097 if (!genpts)
1098 return s->packet_buffer ? read_from_packet_buffer(&s->packet_buffer,
1099 &s->packet_buffer_end,
1100 pkt) :
1101 read_frame_internal(s, pkt);
1102
1103 for (;;) {
1104 int ret;
1105 AVPacketList *pktl = s->packet_buffer;
1106
1107 if (pktl) {
1108 AVPacket *next_pkt = &pktl->pkt;
1109
1110 if (next_pkt->dts != AV_NOPTS_VALUE) {
1111 int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1112 while (pktl && next_pkt->pts == AV_NOPTS_VALUE) {
1113 if (pktl->pkt.stream_index == next_pkt->stream_index &&
1114 (av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2LL << (wrap_bits - 1)) < 0) &&
1115 av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2LL << (wrap_bits - 1))) { //not b frame
1116 next_pkt->pts = pktl->pkt.dts;
1117 }
1118 pktl = pktl->next;
1119 }
1120 pktl = s->packet_buffer;
1121 }
1122
1123 /* read packet from packet buffer, if there is data */
1124 if (!(next_pkt->pts == AV_NOPTS_VALUE &&
1125 next_pkt->dts != AV_NOPTS_VALUE && !eof))
1126 return read_from_packet_buffer(&s->packet_buffer,
1127 &s->packet_buffer_end, pkt);
1128 }
1129
1130 ret = read_frame_internal(s, pkt);
1131 if (ret < 0) {
1132 if (pktl && ret != AVERROR(EAGAIN)) {
1133 eof = 1;
1134 continue;
1135 } else
1136 return ret;
1137 }
1138
1139 if (av_dup_packet(add_to_pktbuf(&s->packet_buffer, pkt,
1140 &s->packet_buffer_end)) < 0)
1141 return AVERROR(ENOMEM);
1142 }
1143 }
1144
1145 /* XXX: suppress the packet queue */
1146 static void flush_packet_queue(AVFormatContext *s)
1147 {
1148 free_packet_buffer(&s->parse_queue, &s->parse_queue_end);
1149 free_packet_buffer(&s->packet_buffer, &s->packet_buffer_end);
1150 free_packet_buffer(&s->raw_packet_buffer, &s->raw_packet_buffer_end);
1151
1152 s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1153 }
1154
1155 /*******************************************************/
1156 /* seek support */
1157
1158 int av_find_default_stream_index(AVFormatContext *s)
1159 {
1160 int first_audio_index = -1;
1161 int i;
1162 AVStream *st;
1163
1164 if (s->nb_streams <= 0)
1165 return -1;
1166 for(i = 0; i < s->nb_streams; i++) {
1167 st = s->streams[i];
1168 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1169 !(st->disposition & AV_DISPOSITION_ATTACHED_PIC)) {
1170 return i;
1171 }
1172 if (first_audio_index < 0 && st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1173 first_audio_index = i;
1174 }
1175 return first_audio_index >= 0 ? first_audio_index : 0;
1176 }
1177
1178 /**
1179 * Flush the frame reader.
1180 */
1181 void ff_read_frame_flush(AVFormatContext *s)
1182 {
1183 AVStream *st;
1184 int i, j;
1185
1186 flush_packet_queue(s);
1187
1188 /* for each stream, reset read state */
1189 for(i = 0; i < s->nb_streams; i++) {
1190 st = s->streams[i];
1191
1192 if (st->parser) {
1193 av_parser_close(st->parser);
1194 st->parser = NULL;
1195 }
1196 st->last_IP_pts = AV_NOPTS_VALUE;
1197 st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
1198
1199 st->probe_packets = MAX_PROBE_PACKETS;
1200
1201 for(j=0; j<MAX_REORDER_DELAY+1; j++)
1202 st->pts_buffer[j]= AV_NOPTS_VALUE;
1203 }
1204 }
1205
1206 void ff_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp)
1207 {
1208 int i;
1209
1210 for(i = 0; i < s->nb_streams; i++) {
1211 AVStream *st = s->streams[i];
1212
1213 st->cur_dts = av_rescale(timestamp,
1214 st->time_base.den * (int64_t)ref_st->time_base.num,
1215 st->time_base.num * (int64_t)ref_st->time_base.den);
1216 }
1217 }
1218
1219 void ff_reduce_index(AVFormatContext *s, int stream_index)
1220 {
1221 AVStream *st= s->streams[stream_index];
1222 unsigned int max_entries= s->max_index_size / sizeof(AVIndexEntry);
1223
1224 if((unsigned)st->nb_index_entries >= max_entries){
1225 int i;
1226 for(i=0; 2*i<st->nb_index_entries; i++)
1227 st->index_entries[i]= st->index_entries[2*i];
1228 st->nb_index_entries= i;
1229 }
1230 }
1231
1232 int ff_add_index_entry(AVIndexEntry **index_entries,
1233 int *nb_index_entries,
1234 unsigned int *index_entries_allocated_size,
1235 int64_t pos, int64_t timestamp, int size, int distance, int flags)
1236 {
1237 AVIndexEntry *entries, *ie;
1238 int index;
1239
1240 if((unsigned)*nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1241 return -1;
1242
1243 entries = av_fast_realloc(*index_entries,
1244 index_entries_allocated_size,
1245 (*nb_index_entries + 1) *
1246 sizeof(AVIndexEntry));
1247 if(!entries)
1248 return -1;
1249
1250 *index_entries= entries;
1251
1252 index= ff_index_search_timestamp(*index_entries, *nb_index_entries, timestamp, AVSEEK_FLAG_ANY);
1253
1254 if(index<0){
1255 index= (*nb_index_entries)++;
1256 ie= &entries[index];
1257 assert(index==0 || ie[-1].timestamp < timestamp);
1258 }else{
1259 ie= &entries[index];
1260 if(ie->timestamp != timestamp){
1261 if(ie->timestamp <= timestamp)
1262 return -1;
1263 memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(*nb_index_entries - index));
1264 (*nb_index_entries)++;
1265 }else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
1266 distance= ie->min_distance;
1267 }
1268
1269 ie->pos = pos;
1270 ie->timestamp = timestamp;
1271 ie->min_distance= distance;
1272 ie->size= size;
1273 ie->flags = flags;
1274
1275 return index;
1276 }
1277
1278 int av_add_index_entry(AVStream *st,
1279 int64_t pos, int64_t timestamp, int size, int distance, int flags)
1280 {
1281 return ff_add_index_entry(&st->index_entries, &st->nb_index_entries,
1282 &st->index_entries_allocated_size, pos,
1283 timestamp, size, distance, flags);
1284 }
1285
1286 int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
1287 int64_t wanted_timestamp, int flags)
1288 {
1289 int a, b, m;
1290 int64_t timestamp;
1291
1292 a = - 1;
1293 b = nb_entries;
1294
1295 //optimize appending index entries at the end
1296 if(b && entries[b-1].timestamp < wanted_timestamp)
1297 a= b-1;
1298
1299 while (b - a > 1) {
1300 m = (a + b) >> 1;
1301 timestamp = entries[m].timestamp;
1302 if(timestamp >= wanted_timestamp)
1303 b = m;
1304 if(timestamp <= wanted_timestamp)
1305 a = m;
1306 }
1307 m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1308
1309 if(!(flags & AVSEEK_FLAG_ANY)){
1310 while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1311 m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1312 }
1313 }
1314
1315 if(m == nb_entries)
1316 return -1;
1317 return m;
1318 }
1319
1320 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1321 int flags)
1322 {
1323 return ff_index_search_timestamp(st->index_entries, st->nb_index_entries,
1324 wanted_timestamp, flags);
1325 }
1326
1327 int ff_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags)
1328 {
1329 AVInputFormat *avif= s->iformat;
1330 int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
1331 int64_t ts_min, ts_max, ts;
1332 int index;
1333 int64_t ret;
1334 AVStream *st;
1335
1336 if (stream_index < 0)
1337 return -1;
1338
1339 av_dlog(s, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1340
1341 ts_max=
1342 ts_min= AV_NOPTS_VALUE;
1343 pos_limit= -1; //gcc falsely says it may be uninitialized
1344
1345 st= s->streams[stream_index];
1346 if(st->index_entries){
1347 AVIndexEntry *e;
1348
1349 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()
1350 index= FFMAX(index, 0);
1351 e= &st->index_entries[index];
1352
1353 if(e->timestamp <= target_ts || e->pos == e->min_distance){
1354 pos_min= e->pos;
1355 ts_min= e->timestamp;
1356 av_dlog(s, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1357 pos_min,ts_min);
1358 }else{
1359 assert(index==0);
1360 }
1361
1362 index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1363 assert(index < st->nb_index_entries);
1364 if(index >= 0){
1365 e= &st->index_entries[index];
1366 assert(e->timestamp >= target_ts);
1367 pos_max= e->pos;
1368 ts_max= e->timestamp;
1369 pos_limit= pos_max - e->min_distance;
1370 av_dlog(s, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
1371 pos_max,pos_limit, ts_max);
1372 }
1373 }
1374
1375 pos= ff_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1376 if(pos<0)
1377 return -1;
1378
1379 /* do the seek */
1380 if ((ret = avio_seek(s->pb, pos, SEEK_SET)) < 0)
1381 return ret;
1382
1383 ff_update_cur_dts(s, st, ts);
1384
1385 return 0;
1386 }
1387
1388 int64_t ff_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts,
1389 int64_t pos_min, int64_t pos_max, int64_t pos_limit,
1390 int64_t ts_min, int64_t ts_max, int flags, int64_t *ts_ret,
1391 int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
1392 {
1393 int64_t pos, ts;
1394 int64_t start_pos, filesize;
1395 int no_change;
1396
1397 av_dlog(s, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1398
1399 if(ts_min == AV_NOPTS_VALUE){
1400 pos_min = s->data_offset;
1401 ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1402 if (ts_min == AV_NOPTS_VALUE)
1403 return -1;
1404 }
1405
1406 if(ts_max == AV_NOPTS_VALUE){
1407 int step= 1024;
1408 filesize = avio_size(s->pb);
1409 pos_max = filesize - 1;
1410 do{
1411 pos_max -= step;
1412 ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
1413 step += step;
1414 }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1415 if (ts_max == AV_NOPTS_VALUE)
1416 return -1;
1417
1418 for(;;){
1419 int64_t tmp_pos= pos_max + 1;
1420 int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1421 if(tmp_ts == AV_NOPTS_VALUE)
1422 break;
1423 ts_max= tmp_ts;
1424 pos_max= tmp_pos;
1425 if(tmp_pos >= filesize)
1426 break;
1427 }
1428 pos_limit= pos_max;
1429 }
1430
1431 if(ts_min > ts_max){
1432 return -1;
1433 }else if(ts_min == ts_max){
1434 pos_limit= pos_min;
1435 }
1436
1437 no_change=0;
1438 while (pos_min < pos_limit) {
1439 av_dlog(s, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1440 pos_min, pos_max, ts_min, ts_max);
1441 assert(pos_limit <= pos_max);
1442
1443 if(no_change==0){
1444 int64_t approximate_keyframe_distance= pos_max - pos_limit;
1445 // interpolate position (better than dichotomy)
1446 pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1447 + pos_min - approximate_keyframe_distance;
1448 }else if(no_change==1){
1449 // bisection, if interpolation failed to change min or max pos last time
1450 pos = (pos_min + pos_limit)>>1;
1451 }else{
1452 /* linear search if bisection failed, can only happen if there
1453 are very few or no keyframes between min/max */
1454 pos=pos_min;
1455 }
1456 if(pos <= pos_min)
1457 pos= pos_min + 1;
1458 else if(pos > pos_limit)
1459 pos= pos_limit;
1460 start_pos= pos;
1461
1462 ts = read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1463 if(pos == pos_max)
1464 no_change++;
1465 else
1466 no_change=0;
1467 av_dlog(s, "%"PRId64" %"PRId64" %"PRId64" / %"PRId64" %"PRId64" %"PRId64" target:%"PRId64" limit:%"PRId64" start:%"PRId64" noc:%d\n",
1468 pos_min, pos, pos_max, ts_min, ts, ts_max, target_ts,
1469 pos_limit, start_pos, no_change);
1470 if(ts == AV_NOPTS_VALUE){
1471 av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1472 return -1;
1473 }
1474 assert(ts != AV_NOPTS_VALUE);
1475 if (target_ts <= ts) {
1476 pos_limit = start_pos - 1;
1477 pos_max = pos;
1478 ts_max = ts;
1479 }
1480 if (target_ts >= ts) {
1481 pos_min = pos;
1482 ts_min = ts;
1483 }
1484 }
1485
1486 pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1487 ts = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min : ts_max;
1488 pos_min = pos;
1489 ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1490 pos_min++;
1491 ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1492 av_dlog(s, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1493 pos, ts_min, target_ts, ts_max);
1494 *ts_ret= ts;
1495 return pos;
1496 }
1497
1498 static int seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1499 int64_t pos_min, pos_max;
1500
1501 pos_min = s->data_offset;
1502 pos_max = avio_size(s->pb) - 1;
1503
1504 if (pos < pos_min) pos= pos_min;
1505 else if(pos > pos_max) pos= pos_max;
1506
1507 avio_seek(s->pb, pos, SEEK_SET);
1508
1509 return 0;
1510 }
1511
1512 static int seek_frame_generic(AVFormatContext *s,
1513 int stream_index, int64_t timestamp, int flags)
1514 {
1515 int index;
1516 int64_t ret;
1517 AVStream *st;
1518 AVIndexEntry *ie;
1519
1520 st = s->streams[stream_index];
1521
1522 index = av_index_search_timestamp(st, timestamp, flags);
1523
1524 if(index < 0 && st->nb_index_entries && timestamp < st->index_entries[0].timestamp)
1525 return -1;
1526
1527 if(index < 0 || index==st->nb_index_entries-1){
1528 AVPacket pkt;
1529
1530 if(st->nb_index_entries){
1531 assert(st->index_entries);
1532 ie= &st->index_entries[st->nb_index_entries-1];
1533 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
1534 return ret;
1535 ff_update_cur_dts(s, st, ie->timestamp);
1536 }else{
1537 if ((ret = avio_seek(s->pb, s->data_offset, SEEK_SET)) < 0)
1538 return ret;
1539 }
1540 for (;;) {
1541 int read_status;
1542 do{
1543 read_status = av_read_frame(s, &pkt);
1544 } while (read_status == AVERROR(EAGAIN));
1545 if (read_status < 0)
1546 break;
1547 av_free_packet(&pkt);
1548 if(stream_index == pkt.stream_index){
1549 if((pkt.flags & AV_PKT_FLAG_KEY) && pkt.dts > timestamp)
1550 break;
1551 }
1552 }
1553 index = av_index_search_timestamp(st, timestamp, flags);
1554 }
1555 if (index < 0)
1556 return -1;
1557
1558 ff_read_frame_flush(s);
1559 if (s->iformat->read_seek){
1560 if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
1561 return 0;
1562 }
1563 ie = &st->index_entries[index];
1564 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
1565 return ret;
1566 ff_update_cur_dts(s, st, ie->timestamp);
1567
1568 return 0;
1569 }
1570
1571 static int seek_frame_internal(AVFormatContext *s, int stream_index,
1572 int64_t timestamp, int flags)
1573 {
1574 int ret;
1575 AVStream *st;
1576
1577 if (flags & AVSEEK_FLAG_BYTE) {
1578 if (s->iformat->flags & AVFMT_NO_BYTE_SEEK)
1579 return -1;
1580 ff_read_frame_flush(s);
1581 return seek_frame_byte(s, stream_index, timestamp, flags);
1582 }
1583
1584 if(stream_index < 0){
1585 stream_index= av_find_default_stream_index(s);
1586 if(stream_index < 0)
1587 return -1;
1588
1589 st= s->streams[stream_index];
1590 /* timestamp for default must be expressed in AV_TIME_BASE units */
1591 timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1592 }
1593
1594 /* first, we try the format specific seek */
1595 if (s->iformat->read_seek) {
1596 ff_read_frame_flush(s);
1597 ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1598 } else
1599 ret = -1;
1600 if (ret >= 0) {
1601 return 0;
1602 }
1603
1604 if (s->iformat->read_timestamp && !(s->iformat->flags & AVFMT_NOBINSEARCH)) {
1605 ff_read_frame_flush(s);
1606 return ff_seek_frame_binary(s, stream_index, timestamp, flags);
1607 } else if (!(s->iformat->flags & AVFMT_NOGENSEARCH)) {
1608 ff_read_frame_flush(s);
1609 return seek_frame_generic(s, stream_index, timestamp, flags);
1610 }
1611 else
1612 return -1;
1613 }
1614
1615 int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1616 {
1617 int ret = seek_frame_internal(s, stream_index, timestamp, flags);
1618
1619 if (ret >= 0)
1620 ret = queue_attached_pictures(s);
1621
1622 return ret;
1623 }
1624
1625 int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
1626 {
1627 if(min_ts > ts || max_ts < ts)
1628 return -1;
1629
1630 if (s->iformat->read_seek2) {
1631 int ret;
1632 ff_read_frame_flush(s);
1633 ret = s->iformat->read_seek2(s, stream_index, min_ts, ts, max_ts, flags);
1634
1635 if (ret >= 0)
1636 ret = queue_attached_pictures(s);
1637 return ret;
1638 }
1639
1640 if(s->iformat->read_timestamp){
1641 //try to seek via read_timestamp()
1642 }
1643
1644 // Fall back on old API if new is not implemented but old is.
1645 // Note the old API has somewhat different semantics.
1646 if(s->iformat->read_seek || 1)
1647 return av_seek_frame(s, stream_index, ts, flags | ((uint64_t)ts - min_ts > (uint64_t)max_ts - ts ? AVSEEK_FLAG_BACKWARD : 0));
1648
1649 // try some generic seek like seek_frame_generic() but with new ts semantics
1650 }
1651
1652 /*******************************************************/
1653
1654 /**
1655 * Return TRUE if the stream has accurate duration in any stream.
1656 *
1657 * @return TRUE if the stream has accurate duration for at least one component.
1658 */
1659 static int has_duration(AVFormatContext *ic)
1660 {
1661 int i;
1662 AVStream *st;
1663
1664 for(i = 0;i < ic->nb_streams; i++) {
1665 st = ic->streams[i];
1666 if (st->duration != AV_NOPTS_VALUE)
1667 return 1;
1668 }
1669 if (ic->duration != AV_NOPTS_VALUE)
1670 return 1;
1671 return 0;
1672 }
1673
1674 /**
1675 * Estimate the stream timings from the one of each components.
1676 *
1677 * Also computes the global bitrate if possible.
1678 */
1679 static void update_stream_timings(AVFormatContext *ic)
1680 {
1681 int64_t start_time, start_time1, end_time, end_time1;
1682 int64_t duration, duration1, filesize;
1683 int i;
1684 AVStream *st;
1685
1686 start_time = INT64_MAX;
1687 end_time = INT64_MIN;
1688 duration = INT64_MIN;
1689 for(i = 0;i < ic->nb_streams; i++) {
1690 st = ic->streams[i];
1691 if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
1692 start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
1693 start_time = FFMIN(start_time, start_time1);
1694 if (st->duration != AV_NOPTS_VALUE) {
1695 end_time1 = start_time1
1696 + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1697 end_time = FFMAX(end_time, end_time1);
1698 }
1699 }
1700 if (st->duration != AV_NOPTS_VALUE) {
1701 duration1 = av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1702 duration = FFMAX(duration, duration1);
1703 }
1704 }
1705 if (start_time != INT64_MAX) {
1706 ic->start_time = start_time;
1707 if (end_time != INT64_MIN)
1708 duration = FFMAX(duration, end_time - start_time);
1709 }
1710 if (duration != INT64_MIN) {
1711 ic->duration = duration;
1712 if (ic->pb && (filesize = avio_size(ic->pb)) > 0) {
1713 /* compute the bitrate */
1714 ic->bit_rate = (double)filesize * 8.0 * AV_TIME_BASE /
1715 (double)ic->duration;
1716 }
1717 }
1718 }
1719
1720 static void fill_all_stream_timings(AVFormatContext *ic)
1721 {
1722 int i;
1723 AVStream *st;
1724
1725 update_stream_timings(ic);
1726 for(i = 0;i < ic->nb_streams; i++) {
1727 st = ic->streams[i];
1728 if (st->start_time == AV_NOPTS_VALUE) {
1729 if(ic->start_time != AV_NOPTS_VALUE)
1730 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1731 if(ic->duration != AV_NOPTS_VALUE)
1732 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1733 }
1734 }
1735 }
1736
1737 static void estimate_timings_from_bit_rate(AVFormatContext *ic)
1738 {
1739 int64_t filesize, duration;
1740 int i;
1741 AVStream *st;
1742
1743 /* if bit_rate is already set, we believe it */
1744 if (ic->bit_rate <= 0) {
1745 int bit_rate = 0;
1746 for(i=0;i<ic->nb_streams;i++) {
1747 st = ic->streams[i];
1748 if (st->codec->bit_rate > 0) {
1749 if (INT_MAX - st->codec->bit_rate < bit_rate) {
1750 bit_rate = 0;
1751 break;
1752 }
1753 bit_rate += st->codec->bit_rate;
1754 }
1755 }
1756 ic->bit_rate = bit_rate;
1757 }
1758
1759 /* if duration is already set, we believe it */
1760 if (ic->duration == AV_NOPTS_VALUE &&
1761 ic->bit_rate != 0) {
1762 filesize = ic->pb ? avio_size(ic->pb) : 0;
1763 if (filesize > 0) {
1764 for(i = 0; i < ic->nb_streams; i++) {
1765 st = ic->streams[i];
1766 duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
1767 if (st->duration == AV_NOPTS_VALUE)
1768 st->duration = duration;
1769 }
1770 }
1771 }
1772 }
1773
1774 #define DURATION_MAX_READ_SIZE 250000
1775 #define DURATION_MAX_RETRY 3
1776
1777 /* only usable for MPEG-PS streams */
1778 static void estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
1779 {
1780 AVPacket pkt1, *pkt = &pkt1;
1781 AVStream *st;
1782 int read_size, i, ret;
1783 int64_t end_time;
1784 int64_t filesize, offset, duration;
1785 int retry=0;
1786
1787 /* flush packet queue */
1788 flush_packet_queue(ic);
1789
1790 for (i=0; i<ic->nb_streams; i++) {
1791 st = ic->streams[i];
1792 if (st->start_time == AV_NOPTS_VALUE && st->first_dts == AV_NOPTS_VALUE)
1793 av_log(st->codec, AV_LOG_WARNING, "start time is not set in estimate_timings_from_pts\n");
1794
1795 if (st->parser) {
1796 av_parser_close(st->parser);
1797 st->parser= NULL;
1798 }
1799 }
1800
1801 /* estimate the end time (duration) */
1802 /* XXX: may need to support wrapping */
1803 filesize = ic->pb ? avio_size(ic->pb) : 0;
1804 end_time = AV_NOPTS_VALUE;
1805 do{
1806 offset = filesize - (DURATION_MAX_READ_SIZE<<retry);
1807 if (offset < 0)
1808 offset = 0;
1809
1810 avio_seek(ic->pb, offset, SEEK_SET);
1811 read_size = 0;
1812 for(;;) {
1813 if (read_size >= DURATION_MAX_READ_SIZE<<(FFMAX(retry-1,0)))
1814 break;
1815
1816 do {
1817 ret = ff_read_packet(ic, pkt);
1818 } while(ret == AVERROR(EAGAIN));
1819 if (ret != 0)
1820 break;
1821 read_size += pkt->size;
1822 st = ic->streams[pkt->stream_index];
1823 if (pkt->pts != AV_NOPTS_VALUE &&
1824 (st->start_time != AV_NOPTS_VALUE ||
1825 st->first_dts != AV_NOPTS_VALUE)) {
1826 duration = end_time = pkt->pts;
1827 if (st->start_time != AV_NOPTS_VALUE)
1828 duration -= st->start_time;
1829 else
1830 duration -= st->first_dts;
1831 if (duration < 0)
1832 duration += 1LL<<st->pts_wrap_bits;
1833 if (duration > 0) {
1834 if (st->duration == AV_NOPTS_VALUE || st->duration < duration)
1835 st->duration = duration;
1836 }
1837 }
1838 av_free_packet(pkt);
1839 }
1840 }while( end_time==AV_NOPTS_VALUE
1841 && filesize > (DURATION_MAX_READ_SIZE<<retry)
1842 && ++retry <= DURATION_MAX_RETRY);
1843
1844 fill_all_stream_timings(ic);
1845
1846 avio_seek(ic->pb, old_offset, SEEK_SET);
1847 for (i=0; i<ic->nb_streams; i++) {
1848 st= ic->streams[i];
1849 st->cur_dts= st->first_dts;
1850 st->last_IP_pts = AV_NOPTS_VALUE;
1851 }
1852 }
1853
1854 static void estimate_timings(AVFormatContext *ic, int64_t old_offset)
1855 {
1856 int64_t file_size;
1857
1858 /* get the file size, if possible */
1859 if (ic->iformat->flags & AVFMT_NOFILE) {
1860 file_size = 0;
1861 } else {
1862 file_size = avio_size(ic->pb);
1863 file_size = FFMAX(0, file_size);
1864 }
1865
1866 if ((!strcmp(ic->iformat->name, "mpeg") ||
1867 !strcmp(ic->iformat->name, "mpegts")) &&
1868 file_size && ic->pb->seekable) {
1869 /* get accurate estimate from the PTSes */
1870 estimate_timings_from_pts(ic, old_offset);
1871 } else if (has_duration(ic)) {
1872 /* at least one component has timings - we use them for all
1873 the components */
1874 fill_all_stream_timings(ic);
1875 } else {
1876 av_log(ic, AV_LOG_WARNING, "Estimating duration from bitrate, this may be inaccurate\n");
1877 /* less precise: use bitrate info */
1878 estimate_timings_from_bit_rate(ic);
1879 }
1880 update_stream_timings(ic);
1881
1882 {
1883 int i;
1884 AVStream av_unused *st;
1885 for(i = 0;i < ic->nb_streams; i++) {
1886 st = ic->streams[i];
1887 av_dlog(ic, "%d: start_time: %0.3f duration: %0.3f\n", i,
1888 (double) st->start_time / AV_TIME_BASE,
1889 (double) st->duration / AV_TIME_BASE);
1890 }
1891 av_dlog(ic, "stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
1892 (double) ic->start_time / AV_TIME_BASE,
1893 (double) ic->duration / AV_TIME_BASE,
1894 ic->bit_rate / 1000);
1895 }
1896 }
1897
1898 static int has_codec_parameters(AVStream *st)
1899 {
1900 AVCodecContext *avctx = st->codec;
1901 int val;
1902 switch (avctx->codec_type) {
1903 case AVMEDIA_TYPE_AUDIO:
1904 val = avctx->sample_rate && avctx->channels;
1905 if (st->info->found_decoder >= 0 && avctx->sample_fmt == AV_SAMPLE_FMT_NONE)
1906 return 0;
1907 break;
1908 case AVMEDIA_TYPE_VIDEO:
1909 val = avctx->width;
1910 if (st->info->found_decoder >= 0 && avctx->pix_fmt == AV_PIX_FMT_NONE)
1911 return 0;
1912 break;
1913 default:
1914 val = 1;
1915 break;
1916 }
1917 return avctx->codec_id != AV_CODEC_ID_NONE && val != 0;
1918 }
1919
1920 static int has_decode_delay_been_guessed(AVStream *st)
1921 {
1922 return st->codec->codec_id != AV_CODEC_ID_H264 ||
1923 st->info->nb_decoded_frames >= 6;
1924 }
1925
1926 /* returns 1 or 0 if or if not decoded data was returned, or a negative error */
1927 static int try_decode_frame(AVStream *st, AVPacket *avpkt, AVDictionary **options)
1928 {
1929 const AVCodec *codec;
1930 int got_picture = 1, ret = 0;
1931 AVFrame *frame = av_frame_alloc();
1932 AVPacket pkt = *avpkt;
1933
1934 if (!frame)
1935 return AVERROR(ENOMEM);
1936
1937 if (!avcodec_is_open(st->codec) && !st->info->found_decoder) {
1938 AVDictionary *thread_opt = NULL;
1939
1940 codec = st->codec->codec ? st->codec->codec :
1941 avcodec_find_decoder(st->codec->codec_id);
1942
1943 if (!codec) {
1944 st->info->found_decoder = -1;
1945 ret = -1;
1946 goto fail;
1947 }
1948
1949 /* force thread count to 1 since the h264 decoder will not extract SPS
1950 * and PPS to extradata during multi-threaded decoding */
1951 av_dict_set(options ? options : &thread_opt, "threads", "1", 0);
1952 ret = avcodec_open2(st->codec, codec, options ? options : &thread_opt);
1953 if (!options)
1954 av_dict_free(&thread_opt);
1955 if (ret < 0) {
1956 st->info->found_decoder = -1;
1957 goto fail;
1958 }
1959 st->info->found_decoder = 1;
1960 } else if (!st->info->found_decoder)
1961 st->info->found_decoder = 1;
1962
1963 if (st->info->found_decoder < 0) {
1964 ret = -1;
1965 goto fail;
1966 }
1967
1968 while ((pkt.size > 0 || (!pkt.data && got_picture)) &&
1969 ret >= 0 &&
1970 (!has_codec_parameters(st) ||
1971 !has_decode_delay_been_guessed(st) ||
1972 (!st->codec_info_nb_frames && st->codec->codec->capabilities & CODEC_CAP_CHANNEL_CONF))) {
1973 got_picture = 0;
1974 switch(st->codec->codec_type) {
1975 case AVMEDIA_TYPE_VIDEO:
1976 ret = avcodec_decode_video2(st->codec, frame,
1977 &got_picture, &pkt);
1978 break;
1979 case AVMEDIA_TYPE_AUDIO:
1980 ret = avcodec_decode_audio4(st->codec, frame, &got_picture, &pkt);
1981 break;
1982 default:
1983 break;
1984 }
1985 if (ret >= 0) {
1986 if (got_picture)
1987 st->info->nb_decoded_frames++;
1988 pkt.data += ret;
1989 pkt.size -= ret;
1990 ret = got_picture;
1991 }
1992 }
1993
1994 fail:
1995 av_frame_free(&frame);
1996 return ret;
1997 }
1998
1999 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id)
2000 {
2001 while (tags->id != AV_CODEC_ID_NONE) {
2002 if (tags->id == id)
2003 return tags->tag;
2004 tags++;
2005 }
2006 return 0;
2007 }
2008
2009 enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
2010 {
2011 int i;
2012 for(i=0; tags[i].id != AV_CODEC_ID_NONE;i++) {
2013 if(tag == tags[i].tag)
2014 return tags[i].id;
2015 }
2016 for(i=0; tags[i].id != AV_CODEC_ID_NONE; i++) {
2017 if (avpriv_toupper4(tag) == avpriv_toupper4(tags[i].tag))
2018 return tags[i].id;
2019 }
2020 return AV_CODEC_ID_NONE;
2021 }
2022
2023 enum AVCodecID ff_get_pcm_codec_id(int bps, int flt, int be, int sflags)
2024 {
2025 if (flt) {
2026 switch (bps) {
2027 case 32: return be ? AV_CODEC_ID_PCM_F32BE : AV_CODEC_ID_PCM_F32LE;
2028 case 64: return be ? AV_CODEC_ID_PCM_F64BE : AV_CODEC_ID_PCM_F64LE;
2029 default: return AV_CODEC_ID_NONE;
2030 }
2031 } else {
2032 bps >>= 3;
2033 if (sflags & (1 << (bps - 1))) {
2034 switch (bps) {
2035 case 1: return AV_CODEC_ID_PCM_S8;
2036 case 2: return be ? AV_CODEC_ID_PCM_S16BE : AV_CODEC_ID_PCM_S16LE;
2037 case 3: return be ? AV_CODEC_ID_PCM_S24BE : AV_CODEC_ID_PCM_S24LE;
2038 case 4: return be ? AV_CODEC_ID_PCM_S32BE : AV_CODEC_ID_PCM_S32LE;
2039 default: return AV_CODEC_ID_NONE;
2040 }
2041 } else {
2042 switch (bps) {
2043 case 1: return AV_CODEC_ID_PCM_U8;
2044 case 2: return be ? AV_CODEC_ID_PCM_U16BE : AV_CODEC_ID_PCM_U16LE;
2045 case 3: return be ? AV_CODEC_ID_PCM_U24BE : AV_CODEC_ID_PCM_U24LE;
2046 case 4: return be ? AV_CODEC_ID_PCM_U32BE : AV_CODEC_ID_PCM_U32LE;
2047 default: return AV_CODEC_ID_NONE;
2048 }
2049 }
2050 }
2051 }
2052
2053 unsigned int av_codec_get_tag(const AVCodecTag * const *tags, enum AVCodecID id)
2054 {
2055 int i;
2056 for(i=0; tags && tags[i]; i++){
2057 int tag= ff_codec_get_tag(tags[i], id);
2058 if(tag) return tag;
2059 }
2060 return 0;
2061 }
2062
2063 enum AVCodecID av_codec_get_id(const AVCodecTag * const *tags, unsigned int tag)
2064 {
2065 int i;
2066 for(i=0; tags && tags[i]; i++){
2067 enum AVCodecID id= ff_codec_get_id(tags[i], tag);
2068 if(id!=AV_CODEC_ID_NONE) return id;
2069 }
2070 return AV_CODEC_ID_NONE;
2071 }
2072
2073 static void compute_chapters_end(AVFormatContext *s)
2074 {
2075 unsigned int i, j;
2076 int64_t max_time = s->duration + ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time);
2077
2078 for (i = 0; i < s->nb_chapters; i++)
2079 if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2080 AVChapter *ch = s->chapters[i];
2081 int64_t end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q, ch->time_base)
2082 : INT64_MAX;
2083
2084 for (j = 0; j < s->nb_chapters; j++) {
2085 AVChapter *ch1 = s->chapters[j];
2086 int64_t next_start = av_rescale_q(ch1->start, ch1->time_base, ch->time_base);
2087 if (j != i && next_start > ch->start && next_start < end)
2088 end = next_start;
2089 }
2090 ch->end = (end == INT64_MAX) ? ch->start : end;
2091 }
2092 }
2093
2094 static int get_std_framerate(int i){
2095 if(i<60*12) return i*1001;
2096 else return ((const int[]){24,30,60,12,15})[i-60*12]*1000*12;
2097 }
2098
2099 /*
2100 * Is the time base unreliable.
2101 * This is a heuristic to balance between quick acceptance of the values in
2102 * the headers vs. some extra checks.
2103 * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
2104 * MPEG-2 commonly misuses field repeat flags to store different framerates.
2105 * And there are "variable" fps files this needs to detect as well.
2106 */
2107 static int tb_unreliable(AVCodecContext *c){
2108 if( c->time_base.den >= 101L*c->time_base.num
2109 || c->time_base.den < 5L*c->time_base.num
2110 /* || c->codec_tag == AV_RL32("DIVX")
2111 || c->codec_tag == AV_RL32("XVID")*/
2112 || c->codec_id == AV_CODEC_ID_MPEG2VIDEO
2113 || c->codec_id == AV_CODEC_ID_H264
2114 )
2115 return 1;
2116 return 0;
2117 }
2118
2119 int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
2120 {
2121 int i, count, ret, read_size, j;
2122 AVStream *st;
2123 AVPacket pkt1, *pkt;
2124 int64_t old_offset = avio_tell(ic->pb);
2125 int orig_nb_streams = ic->nb_streams; // new streams might appear, no options for those
2126
2127 for(i=0;i<ic->nb_streams;i++) {
2128 const AVCodec *codec;
2129 AVDictionary *thread_opt = NULL;
2130 st = ic->streams[i];
2131
2132 //only for the split stuff
2133 if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE)) {
2134 st->parser = av_parser_init(st->codec->codec_id);
2135 if(st->need_parsing == AVSTREAM_PARSE_HEADERS && st->parser){
2136 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
2137 }
2138 }
2139 codec = st->codec->codec ? st->codec->codec :
2140 avcodec_find_decoder(st->codec->codec_id);
2141
2142 /* force thread count to 1 since the h264 decoder will not extract SPS
2143 * and PPS to extradata during multi-threaded decoding */
2144 av_dict_set(options ? &options[i] : &thread_opt, "threads", "1", 0);
2145
2146 /* Ensure that subtitle_header is properly set. */
2147 if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE
2148 && codec && !st->codec->codec)
2149 avcodec_open2(st->codec, codec, options ? &options[i]
2150 : &thread_opt);
2151
2152 //try to just open decoders, in case this is enough to get parameters
2153 if (!has_codec_parameters(st)) {
2154 if (codec && !st->codec->codec)
2155 avcodec_open2(st->codec, codec, options ? &options[i]
2156 : &thread_opt);
2157 }
2158 if (!options)
2159 av_dict_free(&thread_opt);
2160 }
2161
2162 for (i=0; i<ic->nb_streams; i++) {
2163 ic->streams[i]->info->fps_first_dts = AV_NOPTS_VALUE;
2164 ic->streams[i]->info->fps_last_dts = AV_NOPTS_VALUE;
2165 }
2166
2167 count = 0;
2168 read_size = 0;
2169 for(;;) {
2170 if (ff_check_interrupt(&ic->interrupt_callback)){
2171 ret= AVERROR_EXIT;
2172 av_log(ic, AV_LOG_DEBUG, "interrupted\n");
2173 break;
2174 }
2175
2176 /* check if one codec still needs to be handled */
2177 for(i=0;i<ic->nb_streams;i++) {
2178 int fps_analyze_framecount = 20;
2179
2180 st = ic->streams[i];
2181 if (!has_codec_parameters(st))
2182 break;
2183 /* if the timebase is coarse (like the usual millisecond precision
2184 of mkv), we need to analyze more frames to reliably arrive at
2185 the correct fps */
2186 if (av_q2d(st->time_base) > 0.0005)
2187 fps_analyze_framecount *= 2;
2188 if (ic->fps_probe_size >= 0)
2189 fps_analyze_framecount = ic->fps_probe_size;
2190 /* variable fps and no guess at the real fps */
2191 if( tb_unreliable(st->codec) && !st->avg_frame_rate.num
2192 && st->codec_info_nb_frames < fps_analyze_framecount
2193 && st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2194 break;
2195 if(st->parser && st->parser->parser->split && !st->codec->extradata)
2196 break;
2197 if (st->first_dts == AV_NOPTS_VALUE &&
2198 (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
2199 st->codec->codec_type == AVMEDIA_TYPE_AUDIO))
2200 break;
2201 }
2202 if (i == ic->nb_streams) {
2203 /* NOTE: if the format has no header, then we need to read
2204 some packets to get most of the streams, so we cannot
2205 stop here */
2206 if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
2207 /* if we found the info for all the codecs, we can stop */
2208 ret = count;
2209 av_log(ic, AV_LOG_DEBUG, "All info found\n");
2210 break;
2211 }
2212 }
2213 /* we did not get all the codec info, but we read too much data */
2214 if (read_size >= ic->probesize) {
2215 ret = count;
2216 av_log(ic, AV_LOG_DEBUG, "Probe buffer size limit %d reached\n", ic->probesize);
2217 break;
2218 }
2219
2220 /* NOTE: a new stream can be added there if no header in file
2221 (AVFMTCTX_NOHEADER) */
2222 ret = read_frame_internal(ic, &pkt1);
2223 if (ret == AVERROR(EAGAIN))
2224 continue;
2225
2226 if (ret < 0) {
2227 /* EOF or error*/
2228 AVPacket empty_pkt = { 0 };
2229 int err = 0;
2230 av_init_packet(&empty_pkt);
2231
2232 ret = -1; /* we could not have all the codec parameters before EOF */
2233 for(i=0;i<ic->nb_streams;i++) {
2234 st = ic->streams[i];
2235
2236 /* flush the decoders */
2237 if (st->info->found_decoder == 1) {
2238 do {
2239 err = try_decode_frame(st, &empty_pkt,
2240 (options && i < orig_nb_streams) ?
2241 &options[i] : NULL);
2242 } while (err > 0 && !has_codec_parameters(st));
2243 }
2244
2245 if (err < 0) {
2246 av_log(ic, AV_LOG_WARNING,
2247 "decoding for stream %d failed\n", st->index);
2248 } else if (!has_codec_parameters(st)) {
2249 char buf[256];
2250 avcodec_string(buf, sizeof(buf), st->codec, 0);
2251 av_log(ic, AV_LOG_WARNING,
2252 "Could not find codec parameters (%s)\n", buf);
2253 } else {
2254 ret = 0;
2255 }
2256 }
2257 break;
2258 }
2259
2260 if (ic->flags & AVFMT_FLAG_NOBUFFER) {
2261 pkt = &pkt1;
2262 } else {
2263 pkt = add_to_pktbuf(&ic->packet_buffer, &pkt1,
2264 &ic->packet_buffer_end);
2265 if ((ret = av_dup_packet(pkt)) < 0)
2266 goto find_stream_info_err;
2267 }
2268
2269 read_size += pkt->size;
2270
2271 st = ic->streams[pkt->stream_index];
2272 if (pkt->dts != AV_NOPTS_VALUE && st->codec_info_nb_frames > 1) {
2273 /* check for non-increasing dts */
2274 if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
2275 st->info->fps_last_dts >= pkt->dts) {
2276 av_log(ic, AV_LOG_WARNING, "Non-increasing DTS in stream %d: "
2277 "packet %d with DTS %"PRId64", packet %d with DTS "
2278 "%"PRId64"\n", st->index, st->info->fps_last_dts_idx,
2279 st->info->fps_last_dts, st->codec_info_nb_frames, pkt->dts);
2280 st->info->fps_first_dts = st->info->fps_last_dts = AV_NOPTS_VALUE;
2281 }
2282 /* check for a discontinuity in dts - if the difference in dts
2283 * is more than 1000 times the average packet duration in the sequence,
2284 * we treat it as a discontinuity */
2285 if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
2286 st->info->fps_last_dts_idx > st->info->fps_first_dts_idx &&
2287 (pkt->dts - st->info->fps_last_dts) / 1000 >
2288 (st->info->fps_last_dts - st->info->fps_first_dts) / (st->info->fps_last_dts_idx - st->info->fps_first_dts_idx)) {
2289 av_log(ic, AV_LOG_WARNING, "DTS discontinuity in stream %d: "
2290 "packet %d with DTS %"PRId64", packet %d with DTS "
2291 "%"PRId64"\n", st->index, st->info->fps_last_dts_idx,
2292 st->info->fps_last_dts, st->codec_info_nb_frames, pkt->dts);
2293 st->info->fps_first_dts = st->info->fps_last_dts = AV_NOPTS_VALUE;
2294 }
2295
2296 /* update stored dts values */
2297 if (st->info->fps_first_dts == AV_NOPTS_VALUE) {
2298 st->info->fps_first_dts = pkt->dts;
2299 st->info->fps_first_dts_idx = st->codec_info_nb_frames;
2300 }
2301 st->info->fps_last_dts = pkt->dts;
2302 st->info->fps_last_dts_idx = st->codec_info_nb_frames;
2303
2304 /* check max_analyze_duration */
2305 if (av_rescale_q(pkt->dts - st->info->fps_first_dts, st->time_base,
2306 AV_TIME_BASE_Q) >= ic->max_analyze_duration) {
2307 av_log(ic, AV_LOG_WARNING, "max_analyze_duration reached\n");
2308 break;
2309 }
2310 }
2311 if(st->parser && st->parser->parser->split && !st->codec->extradata){
2312 int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
2313 if (i > 0 && i < FF_MAX_EXTRADATA_SIZE) {
2314 st->codec->extradata_size= i;
2315 st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
2316 if (!st->codec->extradata)
2317 return AVERROR(ENOMEM);
2318 memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
2319 memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2320 }
2321 }
2322
2323 /* if still no information, we try to open the codec and to
2324 decompress the frame. We try to avoid that in most cases as
2325 it takes longer and uses more memory. For MPEG-4, we need to
2326 decompress for QuickTime.
2327
2328 If CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
2329 least one frame of codec data, this makes sure the codec initializes
2330 the channel configuration and does not only trust the values from the container.
2331 */
2332 try_decode_frame(st, pkt, (options && i < orig_nb_streams ) ? &options[i] : NULL);
2333
2334 st->codec_info_nb_frames++;
2335 count++;
2336 }
2337
2338 // close codecs which were opened in try_decode_frame()
2339 for(i=0;i<ic->nb_streams;i++) {
2340 st = ic->streams[i];
2341 avcodec_close(st->codec);
2342 }
2343 for(i=0;i<ic->nb_streams;i++) {
2344 st = ic->streams[i];
2345 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2346 /* estimate average framerate if not set by demuxer */
2347 if (!st->avg_frame_rate.num && st->info->fps_last_dts != st->info->fps_first_dts) {
2348 int64_t delta_dts = st->info->fps_last_dts - st->info->fps_first_dts;
2349 int delta_packets = st->info->fps_last_dts_idx - st->info->fps_first_dts_idx;
2350 int best_fps = 0;
2351 double best_error = 0.01;
2352
2353 if (delta_dts >= INT64_MAX / st->time_base.num ||
2354 delta_packets >= INT64_MAX / st->time_base.den ||
2355 delta_dts < 0)
2356 continue;
2357 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
2358 delta_packets*(int64_t)st->time_base.den,
2359 delta_dts*(int64_t)st->time_base.num, 60000);
2360
2361 /* round guessed framerate to a "standard" framerate if it's
2362 * within 1% of the original estimate*/
2363 for (j = 1; j < MAX_STD_TIMEBASES; j++) {
2364 AVRational std_fps = { get_std_framerate(j), 12*1001 };
2365 double error = fabs(av_q2d(st->avg_frame_rate) / av_q2d(std_fps) - 1);
2366
2367 if (error < best_error) {
2368 best_error = error;
2369 best_fps = std_fps.num;
2370 }
2371 }
2372 if (best_fps) {
2373 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
2374 best_fps, 12*1001, INT_MAX);
2375 }
2376 }
2377 }else if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2378 if(!st->codec->bits_per_coded_sample)
2379 st->codec->bits_per_coded_sample= av_get_bits_per_sample(st->codec->codec_id);
2380 // set stream disposition based on audio service type
2381 switch (st->codec->audio_service_type) {
2382 case AV_AUDIO_SERVICE_TYPE_EFFECTS:
2383 st->disposition = AV_DISPOSITION_CLEAN_EFFECTS; break;
2384 case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
2385 st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED; break;
2386 case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
2387 st->disposition = AV_DISPOSITION_HEARING_IMPAIRED; break;
2388 case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
2389 st->disposition = AV_DISPOSITION_COMMENT; break;
2390 case AV_AUDIO_SERVICE_TYPE_KARAOKE:
2391 st->disposition = AV_DISPOSITION_KARAOKE; break;
2392 }
2393 }
2394 }
2395
2396 estimate_timings(ic, old_offset);
2397
2398 compute_chapters_end(ic);
2399
2400 find_stream_info_err:
2401 for (i=0; i < ic->nb_streams; i++) {
2402 ic->streams[i]->codec->thread_count = 0;
2403 av_freep(&ic->streams[i]->info);
2404 }
2405 return ret;
2406 }
2407
2408 static AVProgram *find_program_from_stream(AVFormatContext *ic, int s)
2409 {
2410 int i, j;
2411
2412 for (i = 0; i < ic->nb_programs; i++)
2413 for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
2414 if (ic->programs[i]->stream_index[j] == s)
2415 return ic->programs[i];
2416 return NULL;
2417 }
2418
2419 int av_find_best_stream(AVFormatContext *ic,
2420 enum AVMediaType type,
2421 int wanted_stream_nb,
2422 int related_stream,
2423 AVCodec **decoder_ret,
2424 int flags)
2425 {
2426 int i, nb_streams = ic->nb_streams;
2427 int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1;
2428 unsigned *program = NULL;
2429 AVCodec *decoder = NULL, *best_decoder = NULL;
2430
2431 if (related_stream >= 0 && wanted_stream_nb < 0) {
2432 AVProgram *p = find_program_from_stream(ic, related_stream);
2433 if (p) {
2434 program = p->stream_index;
2435 nb_streams = p->nb_stream_indexes;
2436 }
2437 }
2438 for (i = 0; i < nb_streams; i++) {
2439 int real_stream_index = program ? program[i] : i;
2440 AVStream *st = ic->streams[real_stream_index];
2441 AVCodecContext *avctx = st->codec;
2442 if (avctx->codec_type != type)
2443 continue;
2444 if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
2445 continue;
2446 if (st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED|AV_DISPOSITION_VISUAL_IMPAIRED))
2447 continue;
2448 if (decoder_ret) {
2449 decoder = avcodec_find_decoder(st->codec->codec_id);
2450 if (!decoder) {
2451 if (ret < 0)
2452 ret = AVERROR_DECODER_NOT_FOUND;
2453 continue;
2454 }
2455 }
2456 if (best_count >= st->codec_info_nb_frames)
2457 continue;
2458 best_count = st->codec_info_nb_frames;
2459 ret = real_stream_index;
2460 best_decoder = decoder;
2461 if (program && i == nb_streams - 1 && ret < 0) {
2462 program = NULL;
2463 nb_streams = ic->nb_streams;
2464 i = 0; /* no related stream found, try again with everything */
2465 }
2466 }
2467 if (decoder_ret)
2468 *decoder_ret = best_decoder;
2469 return ret;
2470 }
2471
2472 /*******************************************************/
2473
2474 int av_read_play(AVFormatContext *s)
2475 {
2476 if (s->iformat->read_play)
2477 return s->iformat->read_play(s);
2478 if (s->pb)
2479 return avio_pause(s->pb, 0);
2480 return AVERROR(ENOSYS);
2481 }
2482
2483 int av_read_pause(AVFormatContext *s)
2484 {
2485 if (s->iformat->read_pause)
2486 return s->iformat->read_pause(s);
2487 if (s->pb)
2488 return avio_pause(s->pb, 1);
2489 return AVERROR(ENOSYS);
2490 }
2491
2492 void avformat_free_context(AVFormatContext *s)
2493 {
2494 int i;
2495 AVStream *st;
2496
2497 av_opt_free(s);
2498 if (s->iformat && s->iformat->priv_class && s->priv_data)
2499 av_opt_free(s->priv_data);
2500
2501 for(i=0;i<s->nb_streams;i++) {
2502 /* free all data in a stream component */
2503 st = s->streams[i];
2504 if (st->parser) {
2505 av_parser_close(st->parser);
2506 }
2507 if (st->attached_pic.data)
2508 av_free_packet(&st->attached_pic);
2509 av_dict_free(&st->metadata);
2510 av_freep(&st->probe_data.buf);
2511 av_free(st->index_entries);
2512 av_free(st->codec->extradata);
2513 av_free(st->codec->subtitle_header);
2514 av_free(st->codec);
2515 av_free(st->priv_data);
2516 av_free(st->info);
2517 av_free(st);
2518 }
2519 for(i=s->nb_programs-1; i>=0; i--) {
2520 av_dict_free(&s->programs[i]->metadata);
2521 av_freep(&s->programs[i]->stream_index);
2522 av_freep(&s->programs[i]);
2523 }
2524 av_freep(&s->programs);
2525 av_freep(&s->priv_data);
2526 while(s->nb_chapters--) {
2527 av_dict_free(&s->chapters[s->nb_chapters]->metadata);
2528 av_free(s->chapters[s->nb_chapters]);
2529 }
2530 av_freep(&s->chapters);
2531 av_dict_free(&s->metadata);
2532 av_freep(&s->streams);
2533 av_free(s);
2534 }
2535
2536 void avformat_close_input(AVFormatContext **ps)
2537 {
2538 AVFormatContext *s = *ps;
2539 AVIOContext *pb = s->pb;
2540
2541 if ((s->iformat && s->iformat->flags & AVFMT_NOFILE) ||
2542 (s->flags & AVFMT_FLAG_CUSTOM_IO))
2543 pb = NULL;
2544
2545 flush_packet_queue(s);
2546
2547 if (s->iformat) {
2548 if (s->iformat->read_close)
2549 s->iformat->read_close(s);
2550 }
2551
2552 avformat_free_context(s);
2553
2554 *ps = NULL;
2555
2556 avio_close(pb);
2557 }
2558
2559 AVStream *avformat_new_stream(AVFormatContext *s, AVCodec *c)
2560 {
2561 AVStream *st;
2562 int i;
2563
2564 if (av_reallocp_array(&s->streams, s->nb_streams + 1, sizeof(*s->streams)) < 0) {
2565 s->nb_streams = 0;
2566 return NULL;
2567 }
2568
2569 st = av_mallocz(sizeof(AVStream));
2570 if (!st)
2571 return NULL;
2572 if (!(st->info = av_mallocz(sizeof(*st->info)))) {
2573 av_free(st);
2574 return NULL;
2575 }
2576
2577 st->codec = avcodec_alloc_context3(c);
2578 if (s->iformat) {
2579 /* no default bitrate if decoding */
2580 st->codec->bit_rate = 0;
2581 }
2582 st->index = s->nb_streams;
2583 st->start_time = AV_NOPTS_VALUE;
2584 st->duration = AV_NOPTS_VALUE;
2585 /* we set the current DTS to 0 so that formats without any timestamps
2586 but durations get some timestamps, formats with some unknown
2587 timestamps have their first few packets buffered and the
2588 timestamps corrected before they are returned to the user */
2589 st->cur_dts = 0;
2590 st->first_dts = AV_NOPTS_VALUE;
2591 st->probe_packets = MAX_PROBE_PACKETS;
2592
2593 /* default pts setting is MPEG-like */
2594 avpriv_set_pts_info(st, 33, 1, 90000);
2595 st->last_IP_pts = AV_NOPTS_VALUE;
2596 for(i=0; i<MAX_REORDER_DELAY+1; i++)
2597 st->pts_buffer[i]= AV_NOPTS_VALUE;
2598
2599 st->sample_aspect_ratio = (AVRational){0,1};
2600
2601 st->info->fps_first_dts = AV_NOPTS_VALUE;
2602 st->info->fps_last_dts = AV_NOPTS_VALUE;
2603
2604 s->streams[s->nb_streams++] = st;
2605 return st;
2606 }
2607
2608 AVProgram *av_new_program(AVFormatContext *ac, int id)
2609 {
2610 AVProgram *program=NULL;
2611 int i;
2612
2613 av_dlog(ac, "new_program: id=0x%04x\n", id);
2614
2615 for(i=0; i<ac->nb_programs; i++)
2616 if(ac->programs[i]->id == id)
2617 program = ac->programs[i];
2618
2619 if(!program){
2620 program = av_mallocz(sizeof(AVProgram));
2621 if (!program)
2622 return NULL;
2623 dynarray_add(&ac->programs, &ac->nb_programs, program);
2624 program->discard = AVDISCARD_NONE;
2625 }
2626 program->id = id;
2627
2628 return program;
2629 }
2630
2631 AVChapter *avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
2632 {
2633 AVChapter *chapter = NULL;
2634 int i;
2635
2636 for(i=0; i<s->nb_chapters; i++)
2637 if(s->chapters[i]->id == id)
2638 chapter = s->chapters[i];
2639
2640 if(!chapter){
2641 chapter= av_mallocz(sizeof(AVChapter));
2642 if(!chapter)
2643 return NULL;
2644 dynarray_add(&s->chapters, &s->nb_chapters, chapter);
2645 }
2646 av_dict_set(&chapter->metadata, "title", title, 0);
2647 chapter->id = id;
2648 chapter->time_base= time_base;
2649 chapter->start = start;
2650 chapter->end = end;
2651
2652 return chapter;
2653 }
2654
2655 void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
2656 {
2657 int i, j;
2658 AVProgram *program=NULL;
2659
2660 if (idx >= ac->nb_streams) {
2661 av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
2662 return;
2663 }
2664
2665 for(i=0; i<ac->nb_programs; i++){
2666 if(ac->programs[i]->id != progid)
2667 continue;
2668 program = ac->programs[i];
2669 for(j=0; j<program->nb_stream_indexes; j++)
2670 if(program->stream_index[j] == idx)
2671 return;
2672
2673 if (av_reallocp_array(&program->stream_index,
2674 program->nb_stream_indexes + 1,
2675 sizeof(*program->stream_index)) < 0) {
2676 program->nb_stream_indexes = 0;
2677 return;
2678 }
2679 program->stream_index[program->nb_stream_indexes++] = idx;
2680 return;
2681 }
2682 }
2683
2684 static void print_fps(double d, const char *postfix){
2685 uint64_t v= lrintf(d*100);
2686 if (v% 100 ) av_log(NULL, AV_LOG_INFO, ", %3.2f %s", d, postfix);
2687 else if(v%(100*1000)) av_log(NULL, AV_LOG_INFO, ", %1.0f %s", d, postfix);
2688 else av_log(NULL, AV_LOG_INFO, ", %1.0fk %s", d/1000, postfix);
2689 }
2690
2691 static void dump_metadata(void *ctx, AVDictionary *m, const char *indent)
2692 {
2693 if(m && !(av_dict_count(m) == 1 && av_dict_get(m, "language", NULL, 0))){
2694 AVDictionaryEntry *tag=NULL;
2695
2696 av_log(ctx, AV_LOG_INFO, "%sMetadata:\n", indent);
2697 while((tag=av_dict_get(m, "", tag, AV_DICT_IGNORE_SUFFIX))) {
2698 if(strcmp("language", tag->key))
2699 av_log(ctx, AV_LOG_INFO, "%s %-16s: %s\n", indent, tag->key, tag->value);
2700 }
2701 }
2702 }
2703
2704 /* "user interface" functions */
2705 static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
2706 {
2707 char buf[256];
2708 int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
2709 AVStream *st = ic->streams[i];
2710 int g = av_gcd(st->time_base.num, st->time_base.den);
2711 AVDictionaryEntry *lang = av_dict_get(st->metadata, "language", NULL, 0);
2712 avcodec_string(buf, sizeof(buf), st->codec, is_output);
2713 av_log(NULL, AV_LOG_INFO, " Stream #%d.%d", index, i);
2714 /* the pid is an important information, so we display it */
2715 /* XXX: add a generic system */
2716 if (flags & AVFMT_SHOW_IDS)
2717 av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
2718 if (lang)
2719 av_log(NULL, AV_LOG_INFO, "(%s)", lang->value);
2720 av_log(NULL, AV_LOG_DEBUG, ", %d, %d/%d", st->codec_info_nb_frames, st->time_base.num/g, st->time_base.den/g);
2721 av_log(NULL, AV_LOG_INFO, ": %s", buf);
2722 if (st->sample_aspect_ratio.num && // default
2723 av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)) {
2724 AVRational display_aspect_ratio;
2725 av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
2726 st->codec->width*st->sample_aspect_ratio.num,
2727 st->codec->height*st->sample_aspect_ratio.den,
2728 1024*1024);
2729 av_log(NULL, AV_LOG_INFO, ", PAR %d:%d DAR %d:%d",
2730 st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
2731 display_aspect_ratio.num, display_aspect_ratio.den);
2732 }
2733 if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO){
2734 if(st->avg_frame_rate.den && st->avg_frame_rate.num)
2735 print_fps(av_q2d(st->avg_frame_rate), "fps");
2736 if(st->time_base.den && st->time_base.num)
2737 print_fps(1/av_q2d(st->time_base), "tbn");
2738 if(st->codec->time_base.den && st->codec->time_base.num)
2739 print_fps(1/av_q2d(st->codec->time_base), "tbc");
2740 }
2741 if (st->disposition & AV_DISPOSITION_DEFAULT)
2742 av_log(NULL, AV_LOG_INFO, " (default)");
2743 if (st->disposition & AV_DISPOSITION_DUB)
2744 av_log(NULL, AV_LOG_INFO, " (dub)");
2745 if (st->disposition & AV_DISPOSITION_ORIGINAL)
2746 av_log(NULL, AV_LOG_INFO, " (original)");
2747 if (st->disposition & AV_DISPOSITION_COMMENT)
2748 av_log(NULL, AV_LOG_INFO, " (comment)");
2749 if (st->disposition & AV_DISPOSITION_LYRICS)
2750 av_log(NULL, AV_LOG_INFO, " (lyrics)");
2751 if (st->disposition & AV_DISPOSITION_KARAOKE)
2752 av_log(NULL, AV_LOG_INFO, " (karaoke)");
2753 if (st->disposition & AV_DISPOSITION_FORCED)
2754 av_log(NULL, AV_LOG_INFO, " (forced)");
2755 if (st->disposition & AV_DISPOSITION_HEARING_IMPAIRED)
2756 av_log(NULL, AV_LOG_INFO, " (hearing impaired)");
2757 if (st->disposition & AV_DISPOSITION_VISUAL_IMPAIRED)
2758 av_log(NULL, AV_LOG_INFO, " (visual impaired)");
2759 if (st->disposition & AV_DISPOSITION_CLEAN_EFFECTS)
2760 av_log(NULL, AV_LOG_INFO, " (clean effects)");
2761 av_log(NULL, AV_LOG_INFO, "\n");
2762 dump_metadata(NULL, st->metadata, " ");
2763 }
2764
2765 void av_dump_format(AVFormatContext *ic,
2766 int index,
2767 const char *url,
2768 int is_output)
2769 {
2770 int i;
2771 uint8_t *printed = ic->nb_streams ? av_mallocz(ic->nb_streams) : NULL;
2772 if (ic->nb_streams && !printed)
2773 return;
2774
2775 av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
2776 is_output ? "Output" : "Input",
2777 index,
2778 is_output ? ic->oformat->name : ic->iformat->name,
2779 is_output ? "to" : "from", url);
2780 dump_metadata(NULL, ic->metadata, " ");
2781 if (!is_output) {
2782 av_log(NULL, AV_LOG_INFO, " Duration: ");
2783 if (ic->duration != AV_NOPTS_VALUE) {
2784 int hours, mins, secs, us;
2785 secs = ic->duration / AV_TIME_BASE;
2786 us = ic->duration % AV_TIME_BASE;
2787 mins = secs / 60;
2788 secs %= 60;
2789 hours = mins / 60;
2790 mins %= 60;
2791 av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
2792 (100 * us) / AV_TIME_BASE);
2793 } else {
2794 av_log(NULL, AV_LOG_INFO, "N/A");
2795 }
2796 if (ic->start_time != AV_NOPTS_VALUE) {
2797 int secs, us;
2798 av_log(NULL, AV_LOG_INFO, ", start: ");
2799 secs = ic->start_time / AV_TIME_BASE;
2800 us = abs(ic->start_time % AV_TIME_BASE);
2801 av_log(NULL, AV_LOG_INFO, "%d.%06d",
2802 secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
2803 }
2804 av_log(NULL, AV_LOG_INFO, ", bitrate: ");
2805 if (ic->bit_rate) {
2806 av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
2807 } else {
2808 av_log(NULL, AV_LOG_INFO, "N/A");
2809 }
2810 av_log(NULL, AV_LOG_INFO, "\n");
2811 }
2812 for (i = 0; i < ic->nb_chapters; i++) {
2813 AVChapter *ch = ic->chapters[i];
2814 av_log(NULL, AV_LOG_INFO, " Chapter #%d.%d: ", index, i);
2815 av_log(NULL, AV_LOG_INFO, "start %f, ", ch->start * av_q2d(ch->time_base));
2816 av_log(NULL, AV_LOG_INFO, "end %f\n", ch->end * av_q2d(ch->time_base));
2817
2818 dump_metadata(NULL, ch->metadata, " ");
2819 }
2820 if(ic->nb_programs) {
2821 int j, k, total = 0;
2822 for(j=0; j<ic->nb_programs; j++) {
2823 AVDictionaryEntry *name = av_dict_get(ic->programs[j]->metadata,
2824 "name", NULL, 0);
2825 av_log(NULL, AV_LOG_INFO, " Program %d %s\n", ic->programs[j]->id,
2826 name ? name->value : "");
2827 dump_metadata(NULL, ic->programs[j]->metadata, " ");
2828 for(k=0; k<ic->programs[j]->nb_stream_indexes; k++) {
2829 dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
2830 printed[ic->programs[j]->stream_index[k]] = 1;
2831 }
2832 total += ic->programs[j]->nb_stream_indexes;
2833 }
2834 if (total < ic->nb_streams)
2835 av_log(NULL, AV_LOG_INFO, " No Program\n");
2836 }
2837 for(i=0;i<ic->nb_streams;i++)
2838 if (!printed[i])
2839 dump_stream_format(ic, i, index, is_output);
2840
2841 av_free(printed);
2842 }
2843
2844 uint64_t ff_ntp_time(void)
2845 {
2846 return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
2847 }
2848
2849 int av_get_frame_filename(char *buf, int buf_size,
2850 const char *path, int number)
2851 {
2852 const char *p;
2853 char *q, buf1[20], c;
2854 int nd, len, percentd_found;
2855
2856 q = buf;
2857 p = path;
2858 percentd_found = 0;
2859 for(;;) {
2860 c = *p++;
2861 if (c == '\0')
2862 break;
2863 if (c == '%') {
2864 do {
2865 nd = 0;
2866 while (av_isdigit(*p)) {
2867 nd = nd * 10 + *p++ - '0';
2868 }
2869 c = *p++;
2870 } while (av_isdigit(c));
2871
2872 switch(c) {
2873 case '%':
2874 goto addchar;
2875 case 'd':
2876 if (percentd_found)
2877 goto fail;
2878 percentd_found = 1;
2879 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
2880 len = strlen(buf1);
2881 if ((q - buf + len) > buf_size - 1)
2882 goto fail;
2883 memcpy(q, buf1, len);
2884 q += len;
2885 break;
2886 default:
2887 goto fail;
2888 }
2889 } else {
2890 addchar:
2891 if ((q - buf) < buf_size - 1)
2892 *q++ = c;
2893 }
2894 }
2895 if (!percentd_found)
2896 goto fail;
2897 *q = '\0';
2898 return 0;
2899 fail:
2900 *q = '\0';
2901 return -1;
2902 }
2903
2904 static void hex_dump_internal(void *avcl, FILE *f, int level,
2905 const uint8_t *buf, int size)
2906 {
2907 int len, i, j, c;
2908 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
2909
2910 for(i=0;i<size;i+=16) {
2911 len = size - i;
2912 if (len > 16)
2913 len = 16;
2914 PRINT("%08x ", i);
2915 for(j=0;j<16;j++) {
2916 if (j < len)
2917 PRINT(" %02x", buf[i+j]);
2918 else
2919 PRINT(" ");
2920 }
2921 PRINT(" ");
2922 for(j=0;j<len;j++) {
2923 c = buf[i+j];
2924 if (c < ' ' || c > '~')
2925 c = '.';
2926 PRINT("%c", c);
2927 }
2928 PRINT("\n");
2929 }
2930 #undef PRINT
2931 }
2932
2933 void av_hex_dump(FILE *f, const uint8_t *buf, int size)
2934 {
2935 hex_dump_internal(NULL, f, 0, buf, size);
2936 }
2937
2938 void av_hex_dump_log(void *avcl, int level, const uint8_t *buf, int size)
2939 {
2940 hex_dump_internal(avcl, NULL, level, buf, size);
2941 }
2942
2943 static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload, AVRational time_base)
2944 {
2945 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
2946 PRINT("stream #%d:\n", pkt->stream_index);
2947 PRINT(" keyframe=%d\n", ((pkt->flags & AV_PKT_FLAG_KEY) != 0));
2948 PRINT(" duration=%0.3f\n", pkt->duration * av_q2d(time_base));
2949 /* DTS is _always_ valid after av_read_frame() */
2950 PRINT(" dts=");
2951 if (pkt->dts == AV_NOPTS_VALUE)
2952 PRINT("N/A");
2953 else
2954 PRINT("%0.3f", pkt->dts * av_q2d(time_base));
2955 /* PTS may not be known if B-frames are present. */
2956 PRINT(" pts=");
2957 if (pkt->pts == AV_NOPTS_VALUE)
2958 PRINT("N/A");
2959 else
2960 PRINT("%0.3f", pkt->pts * av_q2d(time_base));
2961 PRINT("\n");
2962 PRINT(" size=%d\n", pkt->size);
2963 #undef PRINT
2964 if (dump_payload)
2965 av_hex_dump(f, pkt->data, pkt->size);
2966 }
2967
2968 void av_pkt_dump2(FILE *f, AVPacket *pkt, int dump_payload, AVStream *st)
2969 {
2970 pkt_dump_internal(NULL, f, 0, pkt, dump_payload, st->time_base);
2971 }
2972
2973 void av_pkt_dump_log2(void *avcl, int level, AVPacket *pkt, int dump_payload,
2974 AVStream *st)
2975 {
2976 pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, st->time_base);
2977 }
2978
2979 void av_url_split(char *proto, int proto_size,
2980 char *authorization, int authorization_size,
2981 char *hostname, int hostname_size,
2982 int *port_ptr,
2983 char *path, int path_size,
2984 const char *url)
2985 {
2986 const char *p, *ls, *at, *col, *brk;
2987
2988 if (port_ptr) *port_ptr = -1;
2989 if (proto_size > 0) proto[0] = 0;
2990 if (authorization_size > 0) authorization[0] = 0;
2991 if (hostname_size > 0) hostname[0] = 0;
2992 if (path_size > 0) path[0] = 0;
2993
2994 /* parse protocol */
2995 if ((p = strchr(url, ':'))) {
2996 av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
2997 p++; /* skip ':' */
2998 if (*p == '/') p++;
2999 if (*p == '/') p++;
3000 } else {
3001 /* no protocol means plain filename */
3002 av_strlcpy(path, url, path_size);
3003 return;
3004 }
3005
3006 /* separate path from hostname */
3007 ls = strchr(p, '/');
3008 if(!ls)
3009 ls = strchr(p, '?');
3010 if(ls)
3011 av_strlcpy(path, ls, path_size);
3012 else
3013 ls = &p[strlen(p)]; // XXX
3014
3015 /* the rest is hostname, use that to parse auth/port */
3016 if (ls != p) {
3017 /* authorization (user[:pass]@hostname) */
3018 if ((at = strchr(p, '@')) && at < ls) {
3019 av_strlcpy(authorization, p,
3020 FFMIN(authorization_size, at + 1 - p));
3021 p = at + 1; /* skip '@' */
3022 }
3023
3024 if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3025 /* [host]:port */
3026 av_strlcpy(hostname, p + 1,
3027 FFMIN(hostname_size, brk - p));
3028 if (brk[1] == ':' && port_ptr)
3029 *port_ptr = atoi(brk + 2);
3030 } else if ((col = strchr(p, ':')) && col < ls) {
3031 av_strlcpy(hostname, p,
3032 FFMIN(col + 1 - p, hostname_size));
3033 if (port_ptr) *port_ptr = atoi(col + 1);
3034 } else
3035 av_strlcpy(hostname, p,
3036 FFMIN(ls + 1 - p, hostname_size));
3037 }
3038 }
3039
3040 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
3041 {
3042 int i;
3043 static const char hex_table_uc[16] = { '0', '1', '2', '3',
3044 '4', '5', '6', '7',
3045 '8', '9', 'A', 'B',
3046 'C', 'D', 'E', 'F' };
3047 static const char hex_table_lc[16] = { '0', '1', '2', '3',
3048 '4', '5', '6', '7',
3049 '8', '9', 'a', 'b',
3050 'c', 'd', 'e', 'f' };
3051 const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
3052
3053 for(i = 0; i < s; i++) {
3054 buff[i * 2] = hex_table[src[i] >> 4];
3055 buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3056 }
3057
3058 return buff;
3059 }
3060
3061 int ff_hex_to_data(uint8_t *data, const char *p)
3062 {
3063 int c, len, v;
3064
3065 len = 0;
3066 v = 1;
3067 for (;;) {