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