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