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