Mercurial > audlegacy
annotate Plugins/Input/wma/libffwma/futils.c @ 210:12004b385a96 trunk
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
author | chainsaw |
---|---|
date | Sat, 19 Nov 2005 14:42:28 -0800 |
parents | 5ce1d36e9ff5 |
children | 0bea7509d6ba |
rev | line source |
---|---|
137 | 1 /* |
2 * Various utilities for ffmpeg system | |
3 * Copyright (c) 2000, 2001, 2002 Fabrice Bellard | |
4 * | |
5 * This library is free software; you can redistribute it and/or | |
6 * modify it under the terms of the GNU Lesser General Public | |
7 * License as published by the Free Software Foundation; either | |
8 * version 2 of the License, or (at your option) any later version. | |
9 * | |
10 * This library is distributed in the hope that it will be useful, | |
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
13 * Lesser General Public License for more details. | |
14 * | |
15 * You should have received a copy of the GNU Lesser General Public | |
16 * License along with this library; if not, write to the Free Software | |
17 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | |
18 */ | |
19 #include "avformat.h" | |
20 | |
21 #undef NDEBUG | |
22 #include <assert.h> | |
23 | |
24 AVInputFormat *first_iformat; | |
25 AVOutputFormat *first_oformat; | |
26 AVImageFormat *first_image_format; | |
27 | |
28 void av_register_input_format(AVInputFormat *format) | |
29 { | |
30 AVInputFormat **p; | |
31 p = &first_iformat; | |
32 while (*p != NULL) p = &(*p)->next; | |
33 *p = format; | |
34 format->next = NULL; | |
35 } | |
36 | |
210
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
37 void av_register_output_format(AVOutputFormat *format) |
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
38 { |
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
39 AVOutputFormat **p; |
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
40 p = &first_oformat; |
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
41 while (*p != NULL) p = &(*p)->next; |
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
42 *p = format; |
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
43 format->next = NULL; |
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
44 } |
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
45 |
137 | 46 int match_ext(const char *filename, const char *extensions) |
47 { | |
48 const char *ext, *p; | |
49 char ext1[32], *q; | |
50 | |
51 ext = strrchr(filename, '.'); | |
52 if (ext) { | |
53 ext++; | |
54 p = extensions; | |
55 for(;;) { | |
56 q = ext1; | |
57 while (*p != '\0' && *p != ',') | |
58 *q++ = *p++; | |
59 *q = '\0'; | |
60 if (!strcasecmp(ext1, ext)) | |
61 return 1; | |
62 if (*p == '\0') | |
63 break; | |
64 p++; | |
65 } | |
66 } | |
67 return 0; | |
68 } | |
69 | |
70 AVOutputFormat *guess_format(const char *short_name, const char *filename, | |
71 const char *mime_type) | |
72 { | |
73 AVOutputFormat *fmt, *fmt_found; | |
74 int score_max, score; | |
75 | |
76 /* specific test for image sequences */ | |
77 if (!short_name && filename && | |
78 filename_number_test(filename) >= 0 && | |
79 guess_image_format(filename)) { | |
80 return guess_format("image", NULL, NULL); | |
81 } | |
82 | |
83 /* find the proper file type */ | |
84 fmt_found = NULL; | |
85 score_max = 0; | |
86 fmt = first_oformat; | |
87 while (fmt != NULL) { | |
88 score = 0; | |
89 if (fmt->name && short_name && !strcmp(fmt->name, short_name)) | |
90 score += 100; | |
91 if (fmt->mime_type && mime_type && !strcmp(fmt->mime_type, mime_type)) | |
92 score += 10; | |
93 if (filename && fmt->extensions && | |
94 match_ext(filename, fmt->extensions)) { | |
95 score += 5; | |
96 } | |
97 if (score > score_max) { | |
98 score_max = score; | |
99 fmt_found = fmt; | |
100 } | |
101 fmt = fmt->next; | |
102 } | |
103 return fmt_found; | |
104 } | |
105 | |
106 AVOutputFormat *guess_stream_format(const char *short_name, const char *filename, | |
107 const char *mime_type) | |
108 { | |
109 AVOutputFormat *fmt = guess_format(short_name, filename, mime_type); | |
110 | |
111 if (fmt) { | |
112 AVOutputFormat *stream_fmt; | |
113 char stream_format_name[64]; | |
114 | |
115 snprintf(stream_format_name, sizeof(stream_format_name), "%s_stream", fmt->name); | |
116 stream_fmt = guess_format(stream_format_name, NULL, NULL); | |
117 | |
118 if (stream_fmt) | |
119 fmt = stream_fmt; | |
120 } | |
121 | |
122 return fmt; | |
123 } | |
124 | |
125 AVInputFormat *av_find_input_format(const char *short_name) | |
126 { | |
127 AVInputFormat *fmt; | |
128 for(fmt = first_iformat; fmt != NULL; fmt = fmt->next) { | |
129 if (!strcmp(fmt->name, short_name)) | |
130 return fmt; | |
131 } | |
132 return NULL; | |
133 } | |
134 | |
135 /* memory handling */ | |
136 | |
137 /** | |
138 * Default packet destructor | |
139 */ | |
140 static void av_destruct_packet(AVPacket *pkt) | |
141 { | |
210
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
142 av_free(pkt->data); |
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
143 pkt->data = NULL; pkt->size = 0; |
137 | 144 } |
145 | |
146 /** | |
147 * Allocate the payload of a packet and intialized its fields to default values. | |
148 * | |
149 * @param pkt packet | |
150 * @param size wanted payload size | |
151 * @return 0 if OK. AVERROR_xxx otherwise. | |
152 */ | |
153 int av_new_packet(AVPacket *pkt, int size) | |
154 { | |
210
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
155 void *data = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE); |
137 | 156 if (!data) |
157 return AVERROR_NOMEM; | |
158 memset(data + size, 0, FF_INPUT_BUFFER_PADDING_SIZE); | |
159 | |
160 av_init_packet(pkt); | |
161 pkt->data = data; | |
162 pkt->size = size; | |
163 pkt->destruct = av_destruct_packet; | |
164 return 0; | |
165 } | |
166 | |
167 /* This is a hack - the packet memory allocation stuff is broken. The | |
168 packet is allocated if it was not really allocated */ | |
169 int av_dup_packet(AVPacket *pkt) | |
170 { | |
171 if (pkt->destruct != av_destruct_packet) { | |
172 uint8_t *data; | |
173 /* we duplicate the packet and don't forget to put the padding | |
174 again */ | |
210
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
175 data = av_malloc(pkt->size + FF_INPUT_BUFFER_PADDING_SIZE); |
137 | 176 if (!data) { |
177 return AVERROR_NOMEM; | |
178 } | |
179 memcpy(data, pkt->data, pkt->size); | |
180 memset(data + pkt->size, 0, FF_INPUT_BUFFER_PADDING_SIZE); | |
181 pkt->data = data; | |
182 pkt->destruct = av_destruct_packet; | |
183 } | |
184 return 0; | |
185 } | |
186 | |
187 /* fifo handling */ | |
188 | |
189 int fifo_init(FifoBuffer *f, int size) | |
190 { | |
210
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
191 f->buffer = av_malloc(size); |
137 | 192 if (!f->buffer) |
193 return -1; | |
194 f->end = f->buffer + size; | |
195 f->wptr = f->rptr = f->buffer; | |
196 return 0; | |
197 } | |
198 | |
199 void fifo_free(FifoBuffer *f) | |
200 { | |
210
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
201 av_free(f->buffer); |
137 | 202 } |
203 | |
204 int fifo_size(FifoBuffer *f, uint8_t *rptr) | |
205 { | |
206 int size; | |
207 | |
208 if (f->wptr >= rptr) { | |
209 size = f->wptr - rptr; | |
210 } else { | |
211 size = (f->end - rptr) + (f->wptr - f->buffer); | |
212 } | |
213 return size; | |
214 } | |
215 | |
216 /* get data from the fifo (return -1 if not enough data) */ | |
217 int fifo_read(FifoBuffer *f, uint8_t *buf, int buf_size, uint8_t **rptr_ptr) | |
218 { | |
219 uint8_t *rptr = *rptr_ptr; | |
220 int size, len; | |
221 | |
222 if (f->wptr >= rptr) { | |
223 size = f->wptr - rptr; | |
224 } else { | |
225 size = (f->end - rptr) + (f->wptr - f->buffer); | |
226 } | |
227 | |
228 if (size < buf_size) | |
229 return -1; | |
230 while (buf_size > 0) { | |
231 len = f->end - rptr; | |
232 if (len > buf_size) | |
233 len = buf_size; | |
234 memcpy(buf, rptr, len); | |
235 buf += len; | |
236 rptr += len; | |
237 if (rptr >= f->end) | |
238 rptr = f->buffer; | |
239 buf_size -= len; | |
240 } | |
241 *rptr_ptr = rptr; | |
242 return 0; | |
243 } | |
244 | |
245 void fifo_write(FifoBuffer *f, uint8_t *buf, int size, uint8_t **wptr_ptr) | |
246 { | |
247 int len; | |
248 uint8_t *wptr; | |
249 wptr = *wptr_ptr; | |
250 while (size > 0) { | |
251 len = f->end - wptr; | |
252 if (len > size) | |
253 len = size; | |
254 memcpy(wptr, buf, len); | |
255 wptr += len; | |
256 if (wptr >= f->end) | |
257 wptr = f->buffer; | |
258 buf += len; | |
259 size -= len; | |
260 } | |
261 *wptr_ptr = wptr; | |
262 } | |
263 | |
264 int filename_number_test(const char *filename) | |
265 { | |
266 char buf[1024]; | |
267 return get_frame_filename(buf, sizeof(buf), filename, 1); | |
268 } | |
269 | |
270 /* guess file format */ | |
271 AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened) | |
272 { | |
273 AVInputFormat *fmt1, *fmt; | |
274 int score, score_max; | |
275 | |
276 fmt = NULL; | |
277 score_max = 0; | |
278 for(fmt1 = first_iformat; fmt1 != NULL; fmt1 = fmt1->next) { | |
279 if (!is_opened && !(fmt1->flags & AVFMT_NOFILE)) | |
280 continue; | |
281 score = 0; | |
282 if (fmt1->read_probe) { | |
283 score = fmt1->read_probe(pd); | |
284 } else if (fmt1->extensions) { | |
285 if (match_ext(pd->filename, fmt1->extensions)) { | |
286 score = 50; | |
287 } | |
288 } | |
289 if (score > score_max) { | |
290 score_max = score; | |
291 fmt = fmt1; | |
292 } | |
293 } | |
294 return fmt; | |
295 } | |
296 | |
297 /************************************************************/ | |
298 /* input media file */ | |
299 | |
300 /** | |
301 * open a media file from an IO stream. 'fmt' must be specified. | |
302 */ | |
303 int av_open_input_stream(AVFormatContext **ic_ptr, | |
304 ByteIOContext *pb, const char *filename, | |
305 AVInputFormat *fmt, AVFormatParameters *ap) | |
306 { | |
307 int err; | |
308 AVFormatContext *ic; | |
309 | |
210
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
310 ic = av_mallocz(sizeof(AVFormatContext)); |
137 | 311 if (!ic) { |
312 err = AVERROR_NOMEM; | |
313 goto fail; | |
314 } | |
315 ic->iformat = fmt; | |
316 if (pb) | |
317 ic->pb = *pb; | |
318 ic->duration = AV_NOPTS_VALUE; | |
319 ic->start_time = AV_NOPTS_VALUE; | |
320 pstrcpy(ic->filename, sizeof(ic->filename), filename); | |
321 | |
322 /* allocate private data */ | |
323 if (fmt->priv_data_size > 0) { | |
210
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
324 ic->priv_data = av_mallocz(fmt->priv_data_size); |
137 | 325 if (!ic->priv_data) { |
326 err = AVERROR_NOMEM; | |
327 goto fail; | |
328 } | |
329 } else { | |
330 ic->priv_data = NULL; | |
331 } | |
332 | |
333 /* default pts settings is MPEG like */ | |
334 av_set_pts_info(ic, 33, 1, 90000); | |
335 ic->last_pkt_pts = AV_NOPTS_VALUE; | |
336 ic->last_pkt_dts = AV_NOPTS_VALUE; | |
337 ic->last_pkt_stream_pts = AV_NOPTS_VALUE; | |
338 ic->last_pkt_stream_dts = AV_NOPTS_VALUE; | |
339 | |
340 err = ic->iformat->read_header(ic, ap); | |
341 if (err < 0) | |
342 goto fail; | |
343 | |
344 if (pb) | |
345 ic->data_offset = url_ftell(&ic->pb); | |
346 | |
347 *ic_ptr = ic; | |
348 return 0; | |
349 fail: | |
350 if (ic) { | |
351 av_freep(&ic->priv_data); | |
352 } | |
210
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
353 av_free(ic); |
137 | 354 *ic_ptr = NULL; |
355 return err; | |
356 } | |
357 | |
358 #define PROBE_BUF_SIZE 2048 | |
359 | |
360 /** | |
361 * Open a media file as input. The codec are not opened. Only the file | |
362 * header (if present) is read. | |
363 * | |
364 * @param ic_ptr the opened media file handle is put here | |
365 * @param filename filename to open. | |
366 * @param fmt if non NULL, force the file format to use | |
367 * @param buf_size optional buffer size (zero if default is OK) | |
368 * @param ap additionnal parameters needed when opening the file (NULL if default) | |
369 * @return 0 if OK. AVERROR_xxx otherwise. | |
370 */ | |
371 int av_open_input_file(AVFormatContext **ic_ptr, const char *filename, | |
372 AVInputFormat *fmt, | |
373 int buf_size, | |
374 AVFormatParameters *ap) | |
375 { | |
376 int err, must_open_file, file_opened; | |
377 uint8_t buf[PROBE_BUF_SIZE]; | |
378 AVProbeData probe_data, *pd = &probe_data; | |
379 ByteIOContext pb1, *pb = &pb1; | |
380 | |
381 file_opened = 0; | |
382 pd->filename = ""; | |
383 if (filename) | |
384 pd->filename = filename; | |
385 pd->buf = buf; | |
386 pd->buf_size = 0; | |
387 | |
388 if (!fmt) { | |
389 /* guess format if no file can be opened */ | |
390 fmt = av_probe_input_format(pd, 0); | |
391 } | |
392 | |
393 /* do not open file if the format does not need it. XXX: specific | |
394 hack needed to handle RTSP/TCP */ | |
395 must_open_file = 1; | |
396 if (fmt && (fmt->flags & AVFMT_NOFILE)) { | |
397 must_open_file = 0; | |
398 } | |
399 | |
400 if (!fmt || must_open_file) { | |
401 /* if no file needed do not try to open one */ | |
402 if (url_fopen(pb, filename, URL_RDONLY) < 0) { | |
403 err = AVERROR_IO; | |
404 goto fail; | |
405 } | |
406 file_opened = 1; | |
407 if (buf_size > 0) { | |
408 url_setbufsize(pb, buf_size); | |
409 } | |
410 if (!fmt) { | |
411 /* read probe data */ | |
412 pd->buf_size = get_buffer(pb, buf, PROBE_BUF_SIZE); | |
413 url_fseek(pb, 0, SEEK_SET); | |
414 } | |
415 } | |
416 | |
417 /* guess file format */ | |
418 if (!fmt) { | |
419 fmt = av_probe_input_format(pd, 1); | |
420 } | |
421 | |
422 /* if still no format found, error */ | |
423 if (!fmt) { | |
424 err = AVERROR_NOFMT; | |
425 goto fail; | |
426 } | |
427 | |
210
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
428 /* XXX: suppress this hack for redirectors */ |
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
429 #ifdef CONFIG_NETWORK |
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
430 if (fmt == &redir_demux) { |
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
431 err = redir_open(ic_ptr, pb); |
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
432 url_fclose(pb); |
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
433 return err; |
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
434 } |
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
435 #endif |
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
436 |
137 | 437 /* check filename in case of an image number is expected */ |
438 if (fmt->flags & AVFMT_NEEDNUMBER) { | |
439 if (filename_number_test(filename) < 0) { | |
440 err = AVERROR_NUMEXPECTED; | |
441 goto fail; | |
442 } | |
443 } | |
444 err = av_open_input_stream(ic_ptr, pb, filename, fmt, ap); | |
445 if (err) | |
446 goto fail; | |
447 return 0; | |
448 fail: | |
449 if (file_opened) | |
450 url_fclose(pb); | |
451 *ic_ptr = NULL; | |
452 return err; | |
453 | |
454 } | |
455 | |
456 /*******************************************************/ | |
457 | |
458 /** | |
459 * Read a transport packet from a media file. This function is | |
460 * absolete and should never be used. Use av_read_frame() instead. | |
461 * | |
462 * @param s media file handle | |
463 * @param pkt is filled | |
464 * @return 0 if OK. AVERROR_xxx if error. | |
465 */ | |
466 int av_read_packet(AVFormatContext *s, AVPacket *pkt) | |
467 { | |
468 return s->iformat->read_packet(s, pkt); | |
469 } | |
470 | |
471 /**********************************************************/ | |
472 | |
473 /* convert the packet time stamp units and handle wrapping. The | |
474 wrapping is handled by considering the next PTS/DTS as a delta to | |
475 the previous value. We handle the delta as a fraction to avoid any | |
476 rounding errors. */ | |
477 static inline int64_t convert_timestamp_units(AVFormatContext *s, | |
478 int64_t *plast_pkt_pts, | |
479 int *plast_pkt_pts_frac, | |
480 int64_t *plast_pkt_stream_pts, | |
481 int64_t pts) | |
482 { | |
483 int64_t stream_pts; | |
484 int64_t delta_pts; | |
485 int shift, pts_frac; | |
486 | |
487 if (pts != AV_NOPTS_VALUE) { | |
488 stream_pts = pts; | |
489 if (*plast_pkt_stream_pts != AV_NOPTS_VALUE) { | |
490 shift = 64 - s->pts_wrap_bits; | |
491 delta_pts = ((stream_pts - *plast_pkt_stream_pts) << shift) >> shift; | |
492 /* XXX: overflow possible but very unlikely as it is a delta */ | |
493 delta_pts = delta_pts * AV_TIME_BASE * s->pts_num; | |
494 pts = *plast_pkt_pts + (delta_pts / s->pts_den); | |
495 pts_frac = *plast_pkt_pts_frac + (delta_pts % s->pts_den); | |
496 if (pts_frac >= s->pts_den) { | |
497 pts_frac -= s->pts_den; | |
498 pts++; | |
499 } | |
500 } else { | |
501 /* no previous pts, so no wrapping possible */ | |
502 pts = (int64_t)(((double)stream_pts * AV_TIME_BASE * s->pts_num) / | |
503 (double)s->pts_den); | |
504 pts_frac = 0; | |
505 } | |
506 *plast_pkt_stream_pts = stream_pts; | |
507 *plast_pkt_pts = pts; | |
508 *plast_pkt_pts_frac = pts_frac; | |
509 } | |
510 return pts; | |
511 } | |
512 | |
513 /* get the number of samples of an audio frame. Return (-1) if error */ | |
514 static int get_audio_frame_size(AVCodecContext *enc, int size) | |
515 { | |
516 int frame_size; | |
517 | |
518 if (enc->frame_size <= 1) { | |
519 /* specific hack for pcm codecs because no frame size is | |
520 provided */ | |
521 switch(enc->codec_id) { | |
522 case CODEC_ID_PCM_S16LE: | |
523 case CODEC_ID_PCM_S16BE: | |
524 case CODEC_ID_PCM_U16LE: | |
525 case CODEC_ID_PCM_U16BE: | |
526 if (enc->channels == 0) | |
527 return -1; | |
528 frame_size = size / (2 * enc->channels); | |
529 break; | |
530 case CODEC_ID_PCM_S8: | |
531 case CODEC_ID_PCM_U8: | |
532 case CODEC_ID_PCM_MULAW: | |
533 case CODEC_ID_PCM_ALAW: | |
534 if (enc->channels == 0) | |
535 return -1; | |
536 frame_size = size / (enc->channels); | |
537 break; | |
538 default: | |
539 /* used for example by ADPCM codecs */ | |
540 if (enc->bit_rate == 0) | |
541 return -1; | |
542 frame_size = (size * 8 * enc->sample_rate) / enc->bit_rate; | |
543 break; | |
544 } | |
545 } else { | |
546 frame_size = enc->frame_size; | |
547 } | |
548 return frame_size; | |
549 } | |
550 | |
551 | |
552 /* return the frame duration in seconds, return 0 if not available */ | |
553 static void compute_frame_duration(int *pnum, int *pden, | |
554 AVFormatContext *s, AVStream *st, | |
555 AVCodecParserContext *pc, AVPacket *pkt) | |
556 { | |
557 int frame_size; | |
558 | |
559 *pnum = 0; | |
560 *pden = 0; | |
561 switch(st->codec.codec_type) { | |
210
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
562 case CODEC_TYPE_VIDEO: |
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
563 *pnum = st->codec.frame_rate_base; |
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
564 *pden = st->codec.frame_rate; |
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
565 if (pc && pc->repeat_pict) { |
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
566 *pden *= 2; |
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
567 *pnum = (*pnum) * (2 + pc->repeat_pict); |
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
568 } |
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
569 break; |
137 | 570 case CODEC_TYPE_AUDIO: |
571 frame_size = get_audio_frame_size(&st->codec, pkt->size); | |
572 if (frame_size < 0) | |
573 break; | |
574 *pnum = frame_size; | |
575 *pden = st->codec.sample_rate; | |
576 break; | |
577 default: | |
578 break; | |
579 } | |
580 } | |
581 | |
582 static void compute_pkt_fields(AVFormatContext *s, AVStream *st, | |
583 AVCodecParserContext *pc, AVPacket *pkt) | |
584 { | |
585 int num, den, presentation_delayed; | |
586 | |
587 if (pkt->duration == 0) { | |
588 compute_frame_duration(&num, &den, s, st, pc, pkt); | |
589 if (den && num) { | |
590 pkt->duration = (num * (int64_t)AV_TIME_BASE) / den; | |
591 } | |
592 } | |
593 | |
594 /* do we have a video B frame ? */ | |
595 presentation_delayed = 0; | |
210
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
596 if (st->codec.codec_type == CODEC_TYPE_VIDEO) { |
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
597 /* XXX: need has_b_frame, but cannot get it if the codec is |
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
598 not initialized */ |
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
599 if ((st->codec.codec_id == CODEC_ID_MPEG1VIDEO || |
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
600 st->codec.codec_id == CODEC_ID_MPEG2VIDEO || |
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
601 st->codec.codec_id == CODEC_ID_MPEG4 || |
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
602 st->codec.codec_id == CODEC_ID_H264) && |
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
603 pc && pc->pict_type != FF_B_TYPE) |
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
604 presentation_delayed = 1; |
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
605 } |
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
606 |
137 | 607 /* interpolate PTS and DTS if they are not present */ |
608 if (presentation_delayed) { | |
609 /* DTS = decompression time stamp */ | |
610 /* PTS = presentation time stamp */ | |
611 if (pkt->dts == AV_NOPTS_VALUE) { | |
612 pkt->dts = st->cur_dts; | |
613 } else { | |
614 st->cur_dts = pkt->dts; | |
615 } | |
616 /* this is tricky: the dts must be incremented by the duration | |
617 of the frame we are displaying, i.e. the last I or P frame */ | |
618 if (st->last_IP_duration == 0) | |
619 st->cur_dts += pkt->duration; | |
620 else | |
621 st->cur_dts += st->last_IP_duration; | |
622 st->last_IP_duration = pkt->duration; | |
623 /* cannot compute PTS if not present (we can compute it only | |
624 by knowing the futur */ | |
625 } else { | |
626 /* presentation is not delayed : PTS and DTS are the same */ | |
627 if (pkt->pts == AV_NOPTS_VALUE) { | |
628 pkt->pts = st->cur_dts; | |
629 pkt->dts = st->cur_dts; | |
630 } else { | |
631 st->cur_dts = pkt->pts; | |
632 pkt->dts = pkt->pts; | |
633 } | |
634 st->cur_dts += pkt->duration; | |
635 } | |
636 | |
637 /* update flags */ | |
638 if (pc) { | |
639 pkt->flags = 0; | |
210
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
640 /* key frame computation */ |
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
641 switch(st->codec.codec_type) { |
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
642 case CODEC_TYPE_VIDEO: |
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
643 if (pc->pict_type == FF_I_TYPE) |
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
644 pkt->flags |= PKT_FLAG_KEY; |
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
645 break; |
137 | 646 case CODEC_TYPE_AUDIO: |
647 pkt->flags |= PKT_FLAG_KEY; | |
648 break; | |
649 default: | |
650 break; | |
651 } | |
652 } | |
653 | |
654 } | |
655 | |
656 static void av_destruct_packet_nofree(AVPacket *pkt) | |
657 { | |
658 pkt->data = NULL; pkt->size = 0; | |
659 } | |
660 | |
661 static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt) | |
662 { | |
663 AVStream *st; | |
664 int len, ret, i; | |
665 | |
666 for(;;) { | |
667 /* select current input stream component */ | |
668 st = s->cur_st; | |
669 if (st) { | |
670 if (!st->parser) { | |
671 /* no parsing needed: we just output the packet as is */ | |
672 /* raw data support */ | |
673 *pkt = s->cur_pkt; | |
674 compute_pkt_fields(s, st, NULL, pkt); | |
675 s->cur_st = NULL; | |
676 return 0; | |
677 } else if (s->cur_len > 0) { | |
678 len = av_parser_parse(st->parser, &st->codec, &pkt->data, &pkt->size, | |
679 s->cur_ptr, s->cur_len, | |
680 s->cur_pkt.pts, s->cur_pkt.dts); | |
681 s->cur_pkt.pts = AV_NOPTS_VALUE; | |
682 s->cur_pkt.dts = AV_NOPTS_VALUE; | |
683 /* increment read pointer */ | |
684 s->cur_ptr += len; | |
685 s->cur_len -= len; | |
686 | |
687 /* return packet if any */ | |
688 if (pkt->size) { | |
689 got_packet: | |
690 pkt->duration = 0; | |
691 pkt->stream_index = st->index; | |
692 pkt->pts = st->parser->pts; | |
693 pkt->dts = st->parser->dts; | |
694 pkt->destruct = av_destruct_packet_nofree; | |
695 compute_pkt_fields(s, st, st->parser, pkt); | |
696 return 0; | |
697 } | |
698 } else { | |
699 /* free packet */ | |
700 av_free_packet(&s->cur_pkt); | |
701 s->cur_st = NULL; | |
702 } | |
703 } else { | |
704 /* read next packet */ | |
705 ret = av_read_packet(s, &s->cur_pkt); | |
706 if (ret < 0) { | |
707 if (ret == -EAGAIN) | |
708 return ret; | |
709 /* return the last frames, if any */ | |
710 for(i = 0; i < s->nb_streams; i++) { | |
711 st = s->streams[i]; | |
712 if (st->parser) { | |
713 av_parser_parse(st->parser, &st->codec, | |
714 &pkt->data, &pkt->size, | |
715 NULL, 0, | |
716 AV_NOPTS_VALUE, AV_NOPTS_VALUE); | |
717 if (pkt->size) | |
718 goto got_packet; | |
719 } | |
720 } | |
721 /* no more packets: really terminates parsing */ | |
722 return ret; | |
723 } | |
724 | |
725 /* convert the packet time stamp units and handle wrapping */ | |
726 s->cur_pkt.pts = convert_timestamp_units(s, | |
727 &s->last_pkt_pts, &s->last_pkt_pts_frac, | |
728 &s->last_pkt_stream_pts, | |
729 s->cur_pkt.pts); | |
730 s->cur_pkt.dts = convert_timestamp_units(s, | |
731 &s->last_pkt_dts, &s->last_pkt_dts_frac, | |
732 &s->last_pkt_stream_dts, | |
733 s->cur_pkt.dts); | |
734 #if 0 | |
735 if (s->cur_pkt.stream_index == 0) { | |
736 if (s->cur_pkt.pts != AV_NOPTS_VALUE) | |
737 printf("PACKET pts=%0.3f\n", | |
738 (double)s->cur_pkt.pts / AV_TIME_BASE); | |
739 if (s->cur_pkt.dts != AV_NOPTS_VALUE) | |
740 printf("PACKET dts=%0.3f\n", | |
741 (double)s->cur_pkt.dts / AV_TIME_BASE); | |
742 } | |
743 #endif | |
744 | |
745 /* duration field */ | |
746 if (s->cur_pkt.duration != 0) { | |
747 s->cur_pkt.duration = ((int64_t)s->cur_pkt.duration * AV_TIME_BASE * s->pts_num) / | |
748 s->pts_den; | |
749 } | |
750 | |
751 st = s->streams[s->cur_pkt.stream_index]; | |
752 s->cur_st = st; | |
753 s->cur_ptr = s->cur_pkt.data; | |
754 s->cur_len = s->cur_pkt.size; | |
755 if (st->need_parsing && !st->parser) { | |
756 st->parser = av_parser_init(st->codec.codec_id); | |
757 if (!st->parser) { | |
758 /* no parser available : just output the raw packets */ | |
759 st->need_parsing = 0; | |
760 } | |
761 } | |
762 } | |
763 } | |
764 } | |
765 | |
766 /** | |
767 * Return the next frame of a stream. The returned packet is valid | |
768 * until the next av_read_frame() or until av_close_input_file() and | |
769 * must be freed with av_free_packet. For video, the packet contains | |
770 * exactly one frame. For audio, it contains an integer number of | |
771 * frames if each frame has a known fixed size (e.g. PCM or ADPCM | |
772 * data). If the audio frames have a variable size (e.g. MPEG audio), | |
773 * then it contains one frame. | |
774 * | |
775 * pkt->pts, pkt->dts and pkt->duration are always set to correct | |
776 * values in AV_TIME_BASE unit (and guessed if the format cannot | |
777 * provided them). pkt->pts can be AV_NOPTS_VALUE if the video format | |
778 * has B frames, so it is better to rely on pkt->dts if you do not | |
779 * decompress the payload. | |
780 * | |
781 * Return 0 if OK, < 0 if error or end of file. | |
782 */ | |
783 int av_read_frame(AVFormatContext *s, AVPacket *pkt) | |
784 { | |
785 AVPacketList *pktl; | |
786 | |
787 pktl = s->packet_buffer; | |
788 if (pktl) { | |
789 /* read packet from packet buffer, if there is data */ | |
790 *pkt = pktl->pkt; | |
791 s->packet_buffer = pktl->next; | |
210
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
792 av_free(pktl); |
137 | 793 return 0; |
794 } else { | |
795 return av_read_frame_internal(s, pkt); | |
796 } | |
797 } | |
798 | |
799 /* XXX: suppress the packet queue */ | |
800 static void flush_packet_queue(AVFormatContext *s) | |
801 { | |
802 AVPacketList *pktl; | |
803 | |
804 for(;;) { | |
805 pktl = s->packet_buffer; | |
806 if (!pktl) | |
807 break; | |
808 s->packet_buffer = pktl->next; | |
809 av_free_packet(&pktl->pkt); | |
210
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
810 av_free(pktl); |
137 | 811 } |
812 } | |
813 | |
814 /*******************************************************/ | |
815 /* seek support */ | |
816 | |
817 int av_find_default_stream_index(AVFormatContext *s) | |
818 { | |
819 int i; | |
820 AVStream *st; | |
821 | |
822 if (s->nb_streams <= 0) | |
823 return -1; | |
824 for(i = 0; i < s->nb_streams; i++) { | |
825 st = s->streams[i]; | |
210
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
826 if (st->codec.codec_type == CODEC_TYPE_VIDEO) { |
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
827 return i; |
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
828 } |
137 | 829 } |
830 return 0; | |
831 } | |
832 | |
833 /* flush the frame reader */ | |
834 static void av_read_frame_flush(AVFormatContext *s) | |
835 { | |
836 AVStream *st; | |
837 int i; | |
838 | |
839 flush_packet_queue(s); | |
840 | |
841 /* free previous packet */ | |
842 if (s->cur_st) { | |
843 if (s->cur_st->parser) | |
844 av_free_packet(&s->cur_pkt); | |
845 s->cur_st = NULL; | |
846 } | |
847 /* fail safe */ | |
848 s->cur_ptr = NULL; | |
849 s->cur_len = 0; | |
850 | |
851 /* for each stream, reset read state */ | |
852 for(i = 0; i < s->nb_streams; i++) { | |
853 st = s->streams[i]; | |
854 | |
855 if (st->parser) { | |
856 av_parser_close(st->parser); | |
857 st->parser = NULL; | |
858 } | |
859 st->cur_dts = 0; /* we set the current DTS to an unspecified origin */ | |
860 } | |
861 } | |
862 | |
863 /* add a index entry into a sorted list updateing if it is already there */ | |
864 int av_add_index_entry(AVStream *st, | |
865 int64_t pos, int64_t timestamp, int distance, int flags) | |
866 { | |
867 AVIndexEntry *entries, *ie; | |
868 int index; | |
869 | |
870 entries = av_fast_realloc(st->index_entries, | |
210
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
871 (unsigned int*)&st->index_entries_allocated_size, |
137 | 872 (st->nb_index_entries + 1) * |
873 sizeof(AVIndexEntry)); | |
874 st->index_entries= entries; | |
875 | |
876 if(st->nb_index_entries){ | |
877 index= av_index_search_timestamp(st, timestamp); | |
878 ie= &entries[index]; | |
879 | |
880 if(ie->timestamp != timestamp){ | |
881 if(ie->timestamp < timestamp){ | |
882 index++; //index points to next instead of previous entry, maybe nonexistant | |
883 ie= &st->index_entries[index]; | |
884 }else | |
885 assert(index==0); | |
886 | |
887 if(index != st->nb_index_entries){ | |
888 assert(index < st->nb_index_entries); | |
889 memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(st->nb_index_entries - index)); | |
890 } | |
891 st->nb_index_entries++; | |
892 } | |
893 }else{ | |
894 index= st->nb_index_entries++; | |
895 ie= &entries[index]; | |
896 } | |
897 | |
898 ie->pos = pos; | |
899 ie->timestamp = timestamp; | |
900 ie->min_distance= distance; | |
901 ie->flags = flags; | |
902 | |
903 return index; | |
904 } | |
905 | |
906 /* build an index for raw streams using a parser */ | |
907 static void av_build_index_raw(AVFormatContext *s) | |
908 { | |
909 AVPacket pkt1, *pkt = &pkt1; | |
910 int ret; | |
911 AVStream *st; | |
912 | |
913 st = s->streams[0]; | |
914 av_read_frame_flush(s); | |
915 url_fseek(&s->pb, s->data_offset, SEEK_SET); | |
916 | |
917 for(;;) { | |
918 ret = av_read_frame(s, pkt); | |
919 if (ret < 0) | |
920 break; | |
921 if (pkt->stream_index == 0 && st->parser && | |
922 (pkt->flags & PKT_FLAG_KEY)) { | |
923 av_add_index_entry(st, st->parser->frame_offset, pkt->dts, | |
924 0, AVINDEX_KEYFRAME); | |
925 } | |
926 av_free_packet(pkt); | |
927 } | |
928 } | |
929 | |
930 /* return TRUE if we deal with a raw stream (raw codec data and | |
931 parsing needed) */ | |
932 static int is_raw_stream(AVFormatContext *s) | |
933 { | |
934 AVStream *st; | |
935 | |
936 if (s->nb_streams != 1) | |
937 return 0; | |
938 st = s->streams[0]; | |
939 if (!st->need_parsing) | |
940 return 0; | |
941 return 1; | |
942 } | |
943 | |
944 /* return the largest index entry whose timestamp is <= | |
945 wanted_timestamp */ | |
946 int av_index_search_timestamp(AVStream *st, int wanted_timestamp) | |
947 { | |
948 AVIndexEntry *entries= st->index_entries; | |
949 int nb_entries= st->nb_index_entries; | |
950 int a, b, m; | |
951 int64_t timestamp; | |
952 | |
953 if (nb_entries <= 0) | |
954 return -1; | |
955 | |
956 a = 0; | |
957 b = nb_entries - 1; | |
958 | |
959 while (a < b) { | |
960 m = (a + b + 1) >> 1; | |
961 timestamp = entries[m].timestamp; | |
962 if (timestamp > wanted_timestamp) { | |
963 b = m - 1; | |
964 } else { | |
965 a = m; | |
966 } | |
967 } | |
968 return a; | |
969 } | |
970 | |
971 static int av_seek_frame_generic(AVFormatContext *s, | |
972 int stream_index, int64_t timestamp) | |
973 { | |
974 int index; | |
975 AVStream *st; | |
976 AVIndexEntry *ie; | |
977 | |
978 if (!s->index_built) { | |
979 if (is_raw_stream(s)) { | |
980 av_build_index_raw(s); | |
981 } else { | |
982 return -1; | |
983 } | |
984 s->index_built = 1; | |
985 } | |
986 | |
987 if (stream_index < 0) | |
988 stream_index = 0; | |
989 st = s->streams[stream_index]; | |
990 index = av_index_search_timestamp(st, timestamp); | |
991 if (index < 0) | |
992 return -1; | |
993 | |
994 /* now we have found the index, we can seek */ | |
995 ie = &st->index_entries[index]; | |
996 av_read_frame_flush(s); | |
997 url_fseek(&s->pb, ie->pos, SEEK_SET); | |
998 st->cur_dts = ie->timestamp; | |
999 return 0; | |
1000 } | |
1001 | |
1002 /** | |
1003 * Seek to the key frame just before the frame at timestamp | |
1004 * 'timestamp' in 'stream_index'. If stream_index is (-1), a default | |
1005 * stream is selected | |
1006 */ | |
1007 int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp) | |
1008 { | |
1009 int ret; | |
1010 | |
1011 av_read_frame_flush(s); | |
1012 | |
1013 /* first, we try the format specific seek */ | |
1014 if (s->iformat->read_seek) | |
1015 ret = s->iformat->read_seek(s, stream_index, timestamp); | |
1016 else | |
1017 ret = -1; | |
1018 if (ret >= 0) { | |
1019 return 0; | |
1020 } | |
1021 | |
1022 return av_seek_frame_generic(s, stream_index, timestamp); | |
1023 } | |
1024 | |
1025 /*******************************************************/ | |
1026 | |
1027 /* return TRUE if the stream has accurate timings for at least one component */ | |
1028 //#if 0 McMCC | |
1029 static int av_has_timings(AVFormatContext *ic) | |
1030 { | |
1031 int i; | |
1032 AVStream *st; | |
1033 | |
1034 for(i = 0;i < ic->nb_streams; i++) { | |
1035 st = ic->streams[i]; | |
1036 if (st->start_time != AV_NOPTS_VALUE && | |
1037 st->duration != AV_NOPTS_VALUE) | |
1038 return 1; | |
1039 } | |
1040 return 0; | |
1041 } | |
1042 | |
1043 /* estimate the stream timings from the one of each components. Also | |
1044 compute the global bitrate if possible */ | |
1045 static void av_update_stream_timings(AVFormatContext *ic) | |
1046 { | |
1047 int64_t start_time, end_time, end_time1; | |
1048 int i; | |
1049 AVStream *st; | |
1050 | |
1051 start_time = MAXINT64; | |
1052 end_time = MININT64; | |
1053 for(i = 0;i < ic->nb_streams; i++) { | |
1054 st = ic->streams[i]; | |
1055 if (st->start_time != AV_NOPTS_VALUE) { | |
1056 if (st->start_time < start_time) | |
1057 start_time = st->start_time; | |
1058 if (st->duration != AV_NOPTS_VALUE) { | |
1059 end_time1 = st->start_time + st->duration; | |
1060 if (end_time1 > end_time) | |
1061 end_time = end_time1; | |
1062 } | |
1063 } | |
1064 } | |
1065 if (start_time != MAXINT64) { | |
1066 ic->start_time = start_time; | |
1067 if (end_time != MAXINT64) { | |
1068 ic->duration = end_time - start_time; | |
1069 if (ic->file_size > 0) { | |
1070 /* compute the bit rate */ | |
1071 ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE / | |
1072 (double)ic->duration; | |
1073 } | |
1074 } | |
1075 } | |
1076 | |
1077 } | |
1078 | |
1079 static void fill_all_stream_timings(AVFormatContext *ic) | |
1080 { | |
1081 int i; | |
1082 AVStream *st; | |
1083 | |
1084 av_update_stream_timings(ic); | |
1085 for(i = 0;i < ic->nb_streams; i++) { | |
1086 st = ic->streams[i]; | |
1087 if (st->start_time == AV_NOPTS_VALUE) { | |
1088 st->start_time = ic->start_time; | |
1089 st->duration = ic->duration; | |
1090 } | |
1091 } | |
1092 } | |
1093 | |
1094 static void av_estimate_timings_from_bit_rate(AVFormatContext *ic) | |
1095 { | |
1096 int64_t filesize, duration; | |
1097 int bit_rate, i; | |
1098 AVStream *st; | |
1099 | |
1100 /* if bit_rate is already set, we believe it */ | |
1101 if (ic->bit_rate == 0) { | |
1102 bit_rate = 0; | |
1103 for(i=0;i<ic->nb_streams;i++) { | |
1104 st = ic->streams[i]; | |
1105 bit_rate += st->codec.bit_rate; | |
1106 } | |
1107 ic->bit_rate = bit_rate; | |
1108 } | |
1109 | |
1110 /* if duration is already set, we believe it */ | |
1111 if (ic->duration == AV_NOPTS_VALUE && | |
1112 ic->bit_rate != 0 && | |
1113 ic->file_size != 0) { | |
1114 filesize = ic->file_size; | |
1115 if (filesize > 0) { | |
1116 duration = (int64_t)((8 * AV_TIME_BASE * (double)filesize) / (double)ic->bit_rate); | |
1117 for(i = 0; i < ic->nb_streams; i++) { | |
1118 st = ic->streams[i]; | |
1119 if (st->start_time == AV_NOPTS_VALUE || | |
1120 st->duration == AV_NOPTS_VALUE) { | |
1121 st->start_time = 0; | |
1122 st->duration = duration; | |
1123 } | |
1124 } | |
1125 } | |
1126 } | |
1127 } | |
1128 | |
1129 #define DURATION_MAX_READ_SIZE 250000 | |
1130 #if 0 | |
1131 /* only usable for MPEG-PS streams */ | |
1132 static void av_estimate_timings_from_pts(AVFormatContext *ic) | |
1133 { | |
1134 AVPacket pkt1, *pkt = &pkt1; | |
1135 AVStream *st; | |
1136 int read_size, i, ret; | |
1137 int64_t start_time, end_time, end_time1; | |
1138 int64_t filesize, offset, duration; | |
1139 | |
1140 /* free previous packet */ | |
1141 if (ic->cur_st && ic->cur_st->parser) | |
1142 av_free_packet(&ic->cur_pkt); | |
1143 ic->cur_st = NULL; | |
1144 | |
1145 /* flush packet queue */ | |
1146 flush_packet_queue(ic); | |
1147 | |
1148 | |
1149 /* we read the first packets to get the first PTS (not fully | |
1150 accurate, but it is enough now) */ | |
1151 url_fseek(&ic->pb, 0, SEEK_SET); | |
1152 read_size = 0; | |
1153 for(;;) { | |
1154 if (read_size >= DURATION_MAX_READ_SIZE) | |
1155 break; | |
1156 /* if all info is available, we can stop */ | |
1157 for(i = 0;i < ic->nb_streams; i++) { | |
1158 st = ic->streams[i]; | |
1159 if (st->start_time == AV_NOPTS_VALUE) | |
1160 break; | |
1161 } | |
1162 if (i == ic->nb_streams) | |
1163 break; | |
1164 | |
1165 ret = av_read_packet(ic, pkt); | |
1166 if (ret != 0) | |
1167 break; | |
1168 read_size += pkt->size; | |
1169 st = ic->streams[pkt->stream_index]; | |
1170 if (pkt->pts != AV_NOPTS_VALUE) { | |
1171 if (st->start_time == AV_NOPTS_VALUE) | |
1172 st->start_time = (int64_t)((double)pkt->pts * ic->pts_num * (double)AV_TIME_BASE / ic->pts_den); | |
1173 } | |
1174 av_free_packet(pkt); | |
1175 } | |
1176 | |
1177 /* we compute the minimum start_time and use it as default */ | |
1178 start_time = MAXINT64; | |
1179 for(i = 0; i < ic->nb_streams; i++) { | |
1180 st = ic->streams[i]; | |
1181 if (st->start_time != AV_NOPTS_VALUE && | |
1182 st->start_time < start_time) | |
1183 start_time = st->start_time; | |
1184 } | |
1185 if (start_time != MAXINT64) | |
1186 ic->start_time = start_time; | |
1187 | |
1188 /* estimate the end time (duration) */ | |
1189 /* XXX: may need to support wrapping */ | |
1190 filesize = ic->file_size; | |
1191 offset = filesize - DURATION_MAX_READ_SIZE; | |
1192 if (offset < 0) | |
1193 offset = 0; | |
1194 | |
1195 url_fseek(&ic->pb, offset, SEEK_SET); | |
1196 read_size = 0; | |
1197 for(;;) { | |
1198 if (read_size >= DURATION_MAX_READ_SIZE) | |
1199 break; | |
1200 /* if all info is available, we can stop */ | |
1201 for(i = 0;i < ic->nb_streams; i++) { | |
1202 st = ic->streams[i]; | |
1203 if (st->duration == AV_NOPTS_VALUE) | |
1204 break; | |
1205 } | |
1206 if (i == ic->nb_streams) | |
1207 break; | |
1208 | |
1209 ret = av_read_packet(ic, pkt); | |
1210 if (ret != 0) | |
1211 break; | |
1212 read_size += pkt->size; | |
1213 st = ic->streams[pkt->stream_index]; | |
1214 if (pkt->pts != AV_NOPTS_VALUE) { | |
1215 end_time = (int64_t)((double)pkt->pts * ic->pts_num * (double)AV_TIME_BASE / ic->pts_den); | |
1216 duration = end_time - st->start_time; | |
1217 if (duration > 0) { | |
1218 if (st->duration == AV_NOPTS_VALUE || | |
1219 st->duration < duration) | |
1220 st->duration = duration; | |
1221 } | |
1222 } | |
1223 av_free_packet(pkt); | |
1224 } | |
1225 | |
1226 /* estimate total duration */ | |
1227 end_time = MININT64; | |
1228 for(i = 0;i < ic->nb_streams; i++) { | |
1229 st = ic->streams[i]; | |
1230 if (st->duration != AV_NOPTS_VALUE) { | |
1231 end_time1 = st->start_time + st->duration; | |
1232 if (end_time1 > end_time) | |
1233 end_time = end_time1; | |
1234 } | |
1235 } | |
1236 | |
1237 /* update start_time (new stream may have been created, so we do | |
1238 it at the end */ | |
1239 if (ic->start_time != AV_NOPTS_VALUE) { | |
1240 for(i = 0; i < ic->nb_streams; i++) { | |
1241 st = ic->streams[i]; | |
1242 if (st->start_time == AV_NOPTS_VALUE) | |
1243 st->start_time = ic->start_time; | |
1244 } | |
1245 } | |
1246 | |
1247 if (end_time != MININT64) { | |
1248 /* put dummy values for duration if needed */ | |
1249 for(i = 0;i < ic->nb_streams; i++) { | |
1250 st = ic->streams[i]; | |
1251 if (st->duration == AV_NOPTS_VALUE && | |
1252 st->start_time != AV_NOPTS_VALUE) | |
1253 st->duration = end_time - st->start_time; | |
1254 } | |
1255 ic->duration = end_time - ic->start_time; | |
1256 } | |
1257 | |
1258 url_fseek(&ic->pb, 0, SEEK_SET); | |
1259 } | |
1260 #endif | |
1261 static void av_estimate_timings(AVFormatContext *ic) | |
1262 { | |
1263 URLContext *h; | |
1264 int64_t file_size; | |
1265 | |
1266 /* get the file size, if possible */ | |
1267 if (ic->iformat->flags & AVFMT_NOFILE) { | |
1268 file_size = 0; | |
1269 } else { | |
1270 h = url_fileno(&ic->pb); | |
1271 file_size = url_filesize(h); | |
1272 if (file_size < 0) | |
1273 file_size = 0; | |
1274 } | |
1275 ic->file_size = file_size; | |
1276 | |
1277 #if 0 | |
1278 if (ic->iformat == &mpegps_demux) { | |
1279 /* get accurate estimate from the PTSes */ | |
1280 av_estimate_timings_from_pts(ic); | |
1281 } else | |
1282 #endif | |
1283 if (av_has_timings(ic)) { | |
1284 /* at least one components has timings - we use them for all | |
1285 the components */ | |
1286 fill_all_stream_timings(ic); | |
1287 } else { | |
1288 /* less precise: use bit rate info */ | |
1289 av_estimate_timings_from_bit_rate(ic); | |
1290 } | |
1291 av_update_stream_timings(ic); | |
1292 | |
1293 #if 0 | |
1294 { | |
1295 int i; | |
1296 AVStream *st; | |
1297 for(i = 0;i < ic->nb_streams; i++) { | |
1298 st = ic->streams[i]; | |
1299 printf("%d: start_time: %0.3f duration: %0.3f\n", | |
1300 i, (double)st->start_time / AV_TIME_BASE, | |
1301 (double)st->duration / AV_TIME_BASE); | |
1302 } | |
1303 printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n", | |
1304 (double)ic->start_time / AV_TIME_BASE, | |
1305 (double)ic->duration / AV_TIME_BASE, | |
1306 ic->bit_rate / 1000); | |
1307 } | |
1308 #endif | |
1309 } | |
1310 | |
1311 | |
1312 static int has_codec_parameters(AVCodecContext *enc) | |
1313 { | |
1314 int val; | |
1315 switch(enc->codec_type) { | |
1316 case CODEC_TYPE_AUDIO: | |
1317 val = enc->sample_rate; | |
1318 break; | |
210
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
1319 case CODEC_TYPE_VIDEO: |
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
1320 val = enc->width; |
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
1321 break; |
137 | 1322 default: |
1323 val = 1; | |
1324 break; | |
1325 } | |
1326 return (val != 0); | |
1327 } | |
1328 | |
1329 static int try_decode_frame(AVStream *st, const uint8_t *data, int size) | |
1330 { | |
1331 int16_t *samples; | |
1332 AVCodec *codec; | |
1333 int got_picture, ret; | |
210
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
1334 AVFrame picture; |
137 | 1335 |
1336 codec = avcodec_find_decoder(st->codec.codec_id); | |
1337 if (!codec) | |
1338 return -1; | |
1339 ret = avcodec_open(&st->codec, codec); | |
1340 if (ret < 0) | |
1341 return ret; | |
1342 switch(st->codec.codec_type) { | |
210
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
1343 case CODEC_TYPE_VIDEO: |
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
1344 ret = avcodec_decode_video(&st->codec, &picture, |
137 | 1345 &got_picture, (uint8_t *)data, size); |
210
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
1346 break; |
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
1347 case CODEC_TYPE_AUDIO: |
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
1348 samples = av_malloc(AVCODEC_MAX_AUDIO_FRAME_SIZE); |
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
1349 if (!samples) |
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
1350 goto fail; |
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
1351 ret = avcodec_decode_audio(&st->codec, samples, |
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
1352 &got_picture, (uint8_t *)data, size); |
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
1353 av_free(samples); |
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
1354 break; |
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
1355 default: |
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
1356 break; |
137 | 1357 } |
1358 fail: | |
1359 avcodec_close(&st->codec); | |
1360 return ret; | |
1361 } | |
1362 | |
1363 | |
1364 /* absolute maximum size we read until we abort */ | |
1365 #define MAX_READ_SIZE 5000000 | |
1366 | |
1367 /* maximum duration until we stop analysing the stream */ | |
1368 #define MAX_STREAM_DURATION ((int)(AV_TIME_BASE * 1.0)) | |
1369 | |
1370 /** | |
1371 * Read the beginning of a media file to get stream information. This | |
1372 * is useful for file formats with no headers such as MPEG. This | |
1373 * function also compute the real frame rate in case of mpeg2 repeat | |
1374 * frame mode. | |
1375 * | |
1376 * @param ic media file handle | |
1377 * @return >=0 if OK. AVERROR_xxx if error. | |
1378 */ | |
1379 int av_find_stream_info(AVFormatContext *ic) | |
1380 { | |
1381 int i, count, ret, read_size; | |
1382 AVStream *st; | |
1383 AVPacket pkt1, *pkt; | |
1384 AVPacketList *pktl=NULL, **ppktl; | |
1385 | |
1386 count = 0; | |
1387 read_size = 0; | |
1388 ppktl = &ic->packet_buffer; | |
1389 for(;;) { | |
1390 /* check if one codec still needs to be handled */ | |
1391 for(i=0;i<ic->nb_streams;i++) { | |
1392 st = ic->streams[i]; | |
1393 if (!has_codec_parameters(&st->codec)) | |
1394 break; | |
1395 } | |
1396 if (i == ic->nb_streams) { | |
1397 /* NOTE: if the format has no header, then we need to read | |
1398 some packets to get most of the streams, so we cannot | |
1399 stop here */ | |
1400 if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) { | |
1401 /* if we found the info for all the codecs, we can stop */ | |
1402 ret = count; | |
1403 break; | |
1404 } | |
1405 } else { | |
1406 /* we did not get all the codec info, but we read too much data */ | |
1407 if (read_size >= MAX_READ_SIZE) { | |
1408 ret = count; | |
1409 break; | |
1410 } | |
1411 } | |
1412 | |
1413 /* NOTE: a new stream can be added there if no header in file | |
1414 (AVFMTCTX_NOHEADER) */ | |
1415 ret = av_read_frame_internal(ic, &pkt1); | |
1416 if (ret < 0) { | |
1417 /* EOF or error */ | |
1418 ret = -1; /* we could not have all the codec parameters before EOF */ | |
1419 if ((ic->ctx_flags & AVFMTCTX_NOHEADER) && | |
1420 i == ic->nb_streams) | |
1421 ret = 0; | |
1422 break; | |
1423 } | |
1424 | |
210
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
1425 pktl = av_mallocz(sizeof(AVPacketList)); |
137 | 1426 if (!pktl) { |
1427 ret = AVERROR_NOMEM; | |
1428 break; | |
1429 } | |
1430 | |
1431 /* add the packet in the buffered packet list */ | |
1432 *ppktl = pktl; | |
1433 ppktl = &pktl->next; | |
1434 | |
1435 pkt = &pktl->pkt; | |
1436 *pkt = pkt1; | |
1437 | |
1438 /* duplicate the packet */ | |
1439 if (av_dup_packet(pkt) < 0) { | |
1440 ret = AVERROR_NOMEM; | |
1441 break; | |
1442 } | |
1443 | |
1444 read_size += pkt->size; | |
1445 | |
1446 st = ic->streams[pkt->stream_index]; | |
1447 st->codec_info_duration += pkt->duration; | |
1448 if (pkt->duration != 0) | |
1449 st->codec_info_nb_frames++; | |
1450 | |
1451 /* if still no information, we try to open the codec and to | |
1452 decompress the frame. We try to avoid that in most cases as | |
1453 it takes longer and uses more memory. For MPEG4, we need to | |
1454 decompress for Quicktime. */ | |
210
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
1455 if (!has_codec_parameters(&st->codec) && |
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
1456 (st->codec.codec_id == CODEC_ID_FLV1 || |
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
1457 st->codec.codec_id == CODEC_ID_H264 || |
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
1458 st->codec.codec_id == CODEC_ID_H263 || |
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
1459 (st->codec.codec_id == CODEC_ID_MPEG4 && !st->need_parsing))) |
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
1460 try_decode_frame(st, pkt->data, pkt->size); |
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
1461 |
137 | 1462 if (st->codec_info_duration >= MAX_STREAM_DURATION) { |
1463 break; | |
1464 } | |
1465 count++; | |
1466 } | |
1467 | |
1468 /* set real frame rate info */ | |
1469 for(i=0;i<ic->nb_streams;i++) { | |
1470 st = ic->streams[i]; | |
210
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
1471 if (st->codec.codec_type == CODEC_TYPE_VIDEO) { |
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
1472 /* compute the real frame rate for telecine */ |
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
1473 if ((st->codec.codec_id == CODEC_ID_MPEG1VIDEO || |
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
1474 st->codec.codec_id == CODEC_ID_MPEG2VIDEO) && |
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
1475 st->codec.sub_id == 2) { |
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
1476 if (st->codec_info_nb_frames >= 20) { |
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
1477 float coded_frame_rate, est_frame_rate; |
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
1478 est_frame_rate = ((double)st->codec_info_nb_frames * AV_TIME_BASE) / |
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
1479 (double)st->codec_info_duration ; |
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
1480 coded_frame_rate = (double)st->codec.frame_rate / |
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
1481 (double)st->codec.frame_rate_base; |
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
1482 #if 0 |
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
1483 printf("telecine: coded_frame_rate=%0.3f est_frame_rate=%0.3f\n", |
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
1484 coded_frame_rate, est_frame_rate); |
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
1485 #endif |
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
1486 /* if we detect that it could be a telecine, we |
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
1487 signal it. It would be better to do it at a |
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
1488 higher level as it can change in a film */ |
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
1489 if (coded_frame_rate >= 24.97 && |
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
1490 (est_frame_rate >= 23.5 && est_frame_rate < 24.5)) { |
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
1491 st->r_frame_rate = 24024; |
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
1492 st->r_frame_rate_base = 1001; |
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
1493 } |
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
1494 } |
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
1495 } |
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
1496 /* if no real frame rate, use the codec one */ |
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
1497 if (!st->r_frame_rate){ |
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
1498 st->r_frame_rate = st->codec.frame_rate; |
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
1499 st->r_frame_rate_base = st->codec.frame_rate_base; |
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
1500 } |
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
1501 } |
137 | 1502 } |
1503 | |
1504 av_estimate_timings(ic); | |
1505 return ret; | |
1506 } | |
1507 //McMCC | |
1508 /*******************************************************/ | |
1509 | |
1510 /** | |
1511 * start playing a network based stream (e.g. RTSP stream) at the | |
1512 * current position | |
1513 */ | |
1514 int av_read_play(AVFormatContext *s) | |
1515 { | |
1516 if (!s->iformat->read_play) | |
1517 return AVERROR_NOTSUPP; | |
1518 return s->iformat->read_play(s); | |
1519 } | |
1520 | |
1521 /** | |
1522 * pause a network based stream (e.g. RTSP stream). Use av_read_play() | |
1523 * to resume it. | |
1524 */ | |
1525 int av_read_pause(AVFormatContext *s) | |
1526 { | |
1527 if (!s->iformat->read_pause) | |
1528 return AVERROR_NOTSUPP; | |
1529 return s->iformat->read_pause(s); | |
1530 } | |
1531 | |
1532 /** | |
1533 * Close a media file (but not its codecs) | |
1534 * | |
1535 * @param s media file handle | |
1536 */ | |
1537 void av_close_input_file(AVFormatContext *s) | |
1538 { | |
1539 int i, must_open_file; | |
1540 AVStream *st; | |
1541 | |
1542 /* free previous packet */ | |
1543 if (s->cur_st && s->cur_st->parser) | |
1544 av_free_packet(&s->cur_pkt); | |
1545 | |
1546 if (s->iformat->read_close) | |
1547 s->iformat->read_close(s); | |
1548 for(i=0;i<s->nb_streams;i++) { | |
1549 /* free all data in a stream component */ | |
1550 st = s->streams[i]; | |
1551 if (st->parser) { | |
1552 av_parser_close(st->parser); | |
1553 } | |
210
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
1554 av_free(st->index_entries); |
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
1555 av_free(st); |
137 | 1556 } |
1557 flush_packet_queue(s); | |
1558 must_open_file = 1; | |
1559 if (s->iformat->flags & AVFMT_NOFILE) { | |
1560 must_open_file = 0; | |
1561 } | |
1562 if (must_open_file) { | |
1563 url_fclose(&s->pb); | |
1564 } | |
1565 av_freep(&s->priv_data); | |
210
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
1566 av_free(s); |
137 | 1567 } |
1568 | |
1569 /** | |
1570 * Add a new stream to a media file. Can only be called in the | |
1571 * read_header function. If the flag AVFMTCTX_NOHEADER is in the | |
1572 * format context, then new streams can be added in read_packet too. | |
1573 * | |
1574 * | |
1575 * @param s media file handle | |
1576 * @param id file format dependent stream id | |
1577 */ | |
1578 AVStream *av_new_stream(AVFormatContext *s, int id) | |
1579 { | |
1580 AVStream *st; | |
1581 | |
1582 if (s->nb_streams >= MAX_STREAMS) | |
1583 return NULL; | |
1584 | |
210
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
1585 st = av_mallocz(sizeof(AVStream)); |
137 | 1586 if (!st) |
1587 return NULL; | |
1588 avcodec_get_context_defaults(&st->codec); | |
1589 if (s->iformat) { | |
1590 /* no default bitrate if decoding */ | |
1591 st->codec.bit_rate = 0; | |
1592 } | |
1593 st->index = s->nb_streams; | |
1594 st->id = id; | |
1595 st->start_time = AV_NOPTS_VALUE; | |
1596 st->duration = AV_NOPTS_VALUE; | |
210
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
1597 s->streams[s->nb_streams++] = st; |
137 | 1598 return st; |
1599 } | |
1600 | |
1601 /************************************************************/ | |
1602 /* output media file */ | |
1603 | |
1604 int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap) | |
1605 { | |
1606 int ret; | |
1607 | |
1608 if (s->oformat->priv_data_size > 0) { | |
210
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
1609 s->priv_data = av_mallocz(s->oformat->priv_data_size); |
137 | 1610 if (!s->priv_data) |
1611 return AVERROR_NOMEM; | |
1612 } else | |
1613 s->priv_data = NULL; | |
1614 | |
1615 if (s->oformat->set_parameters) { | |
1616 ret = s->oformat->set_parameters(s, ap); | |
1617 if (ret < 0) | |
1618 return ret; | |
1619 } | |
1620 return 0; | |
1621 } | |
1622 | |
1623 /** | |
1624 * allocate the stream private data and write the stream header to an | |
1625 * output media file | |
1626 * | |
1627 * @param s media file handle | |
1628 * @return 0 if OK. AVERROR_xxx if error. | |
1629 */ | |
1630 int av_write_header(AVFormatContext *s) | |
1631 { | |
1632 int ret, i; | |
1633 AVStream *st; | |
1634 | |
1635 /* default pts settings is MPEG like */ | |
1636 av_set_pts_info(s, 33, 1, 90000); | |
1637 ret = s->oformat->write_header(s); | |
1638 if (ret < 0) | |
1639 return ret; | |
1640 | |
1641 /* init PTS generation */ | |
1642 for(i=0;i<s->nb_streams;i++) { | |
1643 st = s->streams[i]; | |
1644 | |
1645 switch (st->codec.codec_type) { | |
1646 case CODEC_TYPE_AUDIO: | |
1647 av_frac_init(&st->pts, 0, 0, | |
1648 (int64_t)s->pts_num * st->codec.sample_rate); | |
1649 break; | |
210
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
1650 case CODEC_TYPE_VIDEO: |
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
1651 av_frac_init(&st->pts, 0, 0, |
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
1652 (int64_t)s->pts_num * st->codec.frame_rate); |
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
1653 break; |
137 | 1654 default: |
1655 break; | |
1656 } | |
1657 } | |
1658 return 0; | |
1659 } | |
1660 | |
1661 /** | |
1662 * Write a packet to an output media file. The packet shall contain | |
1663 * one audio or video frame. | |
1664 * | |
1665 * @param s media file handle | |
1666 * @param stream_index stream index | |
1667 * @param buf buffer containing the frame data | |
1668 * @param size size of buffer | |
1669 * @return < 0 if error, = 0 if OK, 1 if end of stream wanted. | |
1670 */ | |
1671 int av_write_frame(AVFormatContext *s, int stream_index, const uint8_t *buf, | |
1672 int size) | |
1673 { | |
1674 AVStream *st; | |
1675 int64_t pts_mask; | |
1676 int ret, frame_size; | |
1677 | |
1678 st = s->streams[stream_index]; | |
1679 pts_mask = (1LL << s->pts_wrap_bits) - 1; | |
1680 ret = s->oformat->write_packet(s, stream_index, buf, size, | |
1681 st->pts.val & pts_mask); | |
1682 if (ret < 0) | |
1683 return ret; | |
1684 | |
1685 /* update pts */ | |
1686 switch (st->codec.codec_type) { | |
1687 case CODEC_TYPE_AUDIO: | |
1688 frame_size = get_audio_frame_size(&st->codec, size); | |
1689 if (frame_size >= 0) { | |
1690 av_frac_add(&st->pts, | |
1691 (int64_t)s->pts_den * frame_size); | |
1692 } | |
1693 break; | |
210
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
1694 case CODEC_TYPE_VIDEO: |
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
1695 av_frac_add(&st->pts, |
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
1696 (int64_t)s->pts_den * st->codec.frame_rate_base); |
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
1697 break; |
137 | 1698 default: |
1699 break; | |
1700 } | |
1701 return ret; | |
1702 } | |
1703 | |
1704 /** | |
1705 * write the stream trailer to an output media file and and free the | |
1706 * file private data. | |
1707 * | |
1708 * @param s media file handle | |
1709 * @return 0 if OK. AVERROR_xxx if error. */ | |
1710 int av_write_trailer(AVFormatContext *s) | |
1711 { | |
1712 int ret; | |
1713 ret = s->oformat->write_trailer(s); | |
1714 av_freep(&s->priv_data); | |
1715 return ret; | |
1716 } | |
1717 | |
1718 /* "user interface" functions */ | |
1719 | |
1720 void dump_format(AVFormatContext *ic, | |
1721 int index, | |
1722 const char *url, | |
1723 int is_output) | |
1724 { | |
1725 int i, flags; | |
1726 char buf[256]; | |
1727 | |
1728 fprintf(stderr, "%s #%d, %s, %s '%s':\n", | |
1729 is_output ? "Output" : "Input", | |
1730 index, | |
1731 is_output ? ic->oformat->name : ic->iformat->name, | |
1732 is_output ? "to" : "from", url); | |
1733 if (!is_output) { | |
1734 fprintf(stderr, " Duration: "); | |
1735 if (ic->duration != AV_NOPTS_VALUE) { | |
1736 int hours, mins, secs, us; | |
1737 secs = ic->duration / AV_TIME_BASE; | |
1738 us = ic->duration % AV_TIME_BASE; | |
1739 mins = secs / 60; | |
1740 secs %= 60; | |
1741 hours = mins / 60; | |
1742 mins %= 60; | |
1743 fprintf(stderr, "%02d:%02d:%02d.%01d", hours, mins, secs, | |
1744 (10 * us) / AV_TIME_BASE); | |
1745 } else { | |
1746 fprintf(stderr, "N/A"); | |
1747 } | |
1748 fprintf(stderr, ", bitrate: "); | |
1749 if (ic->bit_rate) { | |
1750 fprintf(stderr,"%d kb/s", ic->bit_rate / 1000); | |
1751 } else { | |
1752 fprintf(stderr, "N/A"); | |
1753 } | |
1754 fprintf(stderr, "\n"); | |
1755 } | |
1756 for(i=0;i<ic->nb_streams;i++) { | |
1757 AVStream *st = ic->streams[i]; | |
1758 avcodec_string(buf, sizeof(buf), &st->codec, is_output); | |
1759 fprintf(stderr, " Stream #%d.%d", index, i); | |
1760 /* the pid is an important information, so we display it */ | |
1761 /* XXX: add a generic system */ | |
1762 if (is_output) | |
1763 flags = ic->oformat->flags; | |
1764 else | |
1765 flags = ic->iformat->flags; | |
1766 if (flags & AVFMT_SHOW_IDS) { | |
1767 fprintf(stderr, "[0x%x]", st->id); | |
1768 } | |
1769 fprintf(stderr, ": %s\n", buf); | |
1770 } | |
1771 } | |
1772 | |
1773 typedef struct { | |
1774 const char *abv; | |
1775 int width, height; | |
1776 int frame_rate, frame_rate_base; | |
1777 } AbvEntry; | |
1778 | |
1779 static AbvEntry frame_abvs[] = { | |
1780 { "ntsc", 720, 480, 30000, 1001 }, | |
1781 { "pal", 720, 576, 25, 1 }, | |
1782 { "qntsc", 352, 240, 30000, 1001 }, /* VCD compliant ntsc */ | |
1783 { "qpal", 352, 288, 25, 1 }, /* VCD compliant pal */ | |
1784 { "sntsc", 640, 480, 30000, 1001 }, /* square pixel ntsc */ | |
1785 { "spal", 768, 576, 25, 1 }, /* square pixel pal */ | |
1786 { "film", 352, 240, 24, 1 }, | |
1787 { "ntsc-film", 352, 240, 24000, 1001 }, | |
1788 { "sqcif", 128, 96, 0, 0 }, | |
1789 { "qcif", 176, 144, 0, 0 }, | |
1790 { "cif", 352, 288, 0, 0 }, | |
1791 { "4cif", 704, 576, 0, 0 }, | |
1792 }; | |
1793 | |
1794 int parse_image_size(int *width_ptr, int *height_ptr, const char *str) | |
1795 { | |
1796 int i; | |
1797 int n = sizeof(frame_abvs) / sizeof(AbvEntry); | |
1798 const char *p; | |
1799 int frame_width = 0, frame_height = 0; | |
1800 | |
1801 for(i=0;i<n;i++) { | |
1802 if (!strcmp(frame_abvs[i].abv, str)) { | |
1803 frame_width = frame_abvs[i].width; | |
1804 frame_height = frame_abvs[i].height; | |
1805 break; | |
1806 } | |
1807 } | |
1808 if (i == n) { | |
1809 p = str; | |
1810 frame_width = strtol(p, (char **)&p, 10); | |
1811 if (*p) | |
1812 p++; | |
1813 frame_height = strtol(p, (char **)&p, 10); | |
1814 } | |
1815 if (frame_width <= 0 || frame_height <= 0) | |
1816 return -1; | |
1817 *width_ptr = frame_width; | |
1818 *height_ptr = frame_height; | |
1819 return 0; | |
1820 } | |
1821 | |
1822 int parse_frame_rate(int *frame_rate, int *frame_rate_base, const char *arg) | |
1823 { | |
1824 int i; | |
1825 char* cp; | |
1826 | |
1827 /* First, we check our abbreviation table */ | |
1828 for (i = 0; i < sizeof(frame_abvs)/sizeof(*frame_abvs); ++i) | |
1829 if (!strcmp(frame_abvs[i].abv, arg)) { | |
1830 *frame_rate = frame_abvs[i].frame_rate; | |
1831 *frame_rate_base = frame_abvs[i].frame_rate_base; | |
1832 return 0; | |
1833 } | |
1834 | |
1835 /* Then, we try to parse it as fraction */ | |
1836 cp = strchr(arg, '/'); | |
1837 if (cp) { | |
1838 char* cpp; | |
1839 *frame_rate = strtol(arg, &cpp, 10); | |
1840 if (cpp != arg || cpp == cp) | |
1841 *frame_rate_base = strtol(cp+1, &cpp, 10); | |
1842 else | |
1843 *frame_rate = 0; | |
1844 } | |
1845 else { | |
1846 /* Finally we give up and parse it as double */ | |
1847 *frame_rate_base = DEFAULT_FRAME_RATE_BASE; | |
1848 *frame_rate = (int)(strtod(arg, 0) * (*frame_rate_base) + 0.5); | |
1849 } | |
1850 if (!*frame_rate || !*frame_rate_base) | |
1851 return -1; | |
1852 else | |
1853 return 0; | |
1854 } | |
1855 | |
1856 /* Syntax: | |
1857 * - If not a duration: | |
1858 * [{YYYY-MM-DD|YYYYMMDD}]{T| }{HH[:MM[:SS[.m...]]][Z]|HH[MM[SS[.m...]]][Z]} | |
1859 * Time is localtime unless Z is suffixed to the end. In this case GMT | |
1860 * Return the date in micro seconds since 1970 | |
1861 * - If duration: | |
1862 * HH[:MM[:SS[.m...]]] | |
1863 * S+[.m...] | |
1864 */ | |
1865 int64_t parse_date(const char *datestr, int duration) | |
1866 { | |
1867 const char *p; | |
1868 int64_t t; | |
1869 struct tm dt; | |
1870 int i; | |
1871 static const char *date_fmt[] = { | |
1872 "%Y-%m-%d", | |
1873 "%Y%m%d", | |
1874 }; | |
1875 static const char *time_fmt[] = { | |
1876 "%H:%M:%S", | |
1877 "%H%M%S", | |
1878 }; | |
1879 const char *q; | |
1880 int is_utc, len; | |
1881 char lastch; | |
1882 time_t now = time(0); | |
1883 | |
1884 len = strlen(datestr); | |
1885 if (len > 0) | |
1886 lastch = datestr[len - 1]; | |
1887 else | |
1888 lastch = '\0'; | |
1889 is_utc = (lastch == 'z' || lastch == 'Z'); | |
1890 | |
1891 memset(&dt, 0, sizeof(dt)); | |
1892 | |
1893 p = datestr; | |
1894 q = NULL; | |
1895 if (!duration) { | |
1896 for (i = 0; i < sizeof(date_fmt) / sizeof(date_fmt[0]); i++) { | |
1897 q = small_strptime(p, date_fmt[i], &dt); | |
1898 if (q) { | |
1899 break; | |
1900 } | |
1901 } | |
1902 | |
1903 if (!q) { | |
1904 if (is_utc) { | |
1905 dt = *gmtime(&now); | |
1906 } else { | |
1907 dt = *localtime(&now); | |
1908 } | |
1909 dt.tm_hour = dt.tm_min = dt.tm_sec = 0; | |
1910 } else { | |
1911 p = q; | |
1912 } | |
1913 | |
1914 if (*p == 'T' || *p == 't' || *p == ' ') | |
1915 p++; | |
1916 | |
1917 for (i = 0; i < sizeof(time_fmt) / sizeof(time_fmt[0]); i++) { | |
1918 q = small_strptime(p, time_fmt[i], &dt); | |
1919 if (q) { | |
1920 break; | |
1921 } | |
1922 } | |
1923 } else { | |
1924 q = small_strptime(p, time_fmt[0], &dt); | |
1925 if (!q) { | |
1926 dt.tm_sec = strtol(p, (char **)&q, 10); | |
1927 dt.tm_min = 0; | |
1928 dt.tm_hour = 0; | |
1929 } | |
1930 } | |
1931 | |
1932 /* Now we have all the fields that we can get */ | |
1933 if (!q) { | |
1934 if (duration) | |
1935 return 0; | |
1936 else | |
1937 return now * int64_t_C(1000000); | |
1938 } | |
1939 | |
1940 if (duration) { | |
1941 t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec; | |
1942 } else { | |
1943 dt.tm_isdst = -1; /* unknown */ | |
1944 if (is_utc) { | |
1945 t = mktimegm(&dt); | |
1946 } else { | |
1947 t = mktime(&dt); | |
1948 } | |
1949 } | |
1950 | |
1951 t *= 1000000; | |
1952 | |
1953 if (*q == '.') { | |
1954 int val, n; | |
1955 q++; | |
1956 for (val = 0, n = 100000; n >= 1; n /= 10, q++) { | |
1957 if (!isdigit(*q)) | |
1958 break; | |
1959 val += n * (*q - '0'); | |
1960 } | |
1961 t += val; | |
1962 } | |
1963 return t; | |
1964 } | |
1965 | |
1966 /* syntax: '?tag1=val1&tag2=val2...'. Little URL decoding is done. Return | |
1967 1 if found */ | |
1968 int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info) | |
1969 { | |
1970 const char *p; | |
1971 char tag[128], *q; | |
1972 | |
1973 p = info; | |
1974 if (*p == '?') | |
1975 p++; | |
1976 for(;;) { | |
1977 q = tag; | |
1978 while (*p != '\0' && *p != '=' && *p != '&') { | |
1979 if ((q - tag) < sizeof(tag) - 1) | |
1980 *q++ = *p; | |
1981 p++; | |
1982 } | |
1983 *q = '\0'; | |
1984 q = arg; | |
1985 if (*p == '=') { | |
1986 p++; | |
1987 while (*p != '&' && *p != '\0') { | |
1988 if ((q - arg) < arg_size - 1) { | |
1989 if (*p == '+') | |
1990 *q++ = ' '; | |
1991 else | |
1992 *q++ = *p; | |
1993 } | |
1994 p++; | |
1995 } | |
1996 *q = '\0'; | |
1997 } | |
1998 if (!strcmp(tag, tag1)) | |
1999 return 1; | |
2000 if (*p != '&') | |
2001 break; | |
2002 p++; | |
2003 } | |
2004 return 0; | |
2005 } | |
2006 | |
2007 /* Return in 'buf' the path with '%d' replaced by number. Also handles | |
2008 the '%0nd' format where 'n' is the total number of digits and | |
2009 '%%'. Return 0 if OK, and -1 if format error */ | |
2010 int get_frame_filename(char *buf, int buf_size, | |
2011 const char *path, int number) | |
2012 { | |
2013 const char *p; | |
2014 char *q, buf1[20], c; | |
2015 int nd, len, percentd_found; | |
2016 | |
2017 q = buf; | |
2018 p = path; | |
2019 percentd_found = 0; | |
2020 for(;;) { | |
2021 c = *p++; | |
2022 if (c == '\0') | |
2023 break; | |
2024 if (c == '%') { | |
2025 do { | |
2026 nd = 0; | |
2027 while (isdigit(*p)) { | |
2028 nd = nd * 10 + *p++ - '0'; | |
2029 } | |
2030 c = *p++; | |
2031 } while (isdigit(c)); | |
2032 | |
2033 switch(c) { | |
2034 case '%': | |
2035 goto addchar; | |
2036 case 'd': | |
2037 if (percentd_found) | |
2038 goto fail; | |
2039 percentd_found = 1; | |
2040 snprintf(buf1, sizeof(buf1), "%0*d", nd, number); | |
2041 len = strlen(buf1); | |
2042 if ((q - buf + len) > buf_size - 1) | |
2043 goto fail; | |
2044 memcpy(q, buf1, len); | |
2045 q += len; | |
2046 break; | |
2047 default: | |
2048 goto fail; | |
2049 } | |
2050 } else { | |
2051 addchar: | |
2052 if ((q - buf) < buf_size - 1) | |
2053 *q++ = c; | |
2054 } | |
2055 } | |
2056 if (!percentd_found) | |
2057 goto fail; | |
2058 *q = '\0'; | |
2059 return 0; | |
2060 fail: | |
2061 *q = '\0'; | |
2062 return -1; | |
2063 } | |
2064 | |
2065 /** | |
2066 * Print nice hexa dump of a buffer | |
2067 * @param f stream for output | |
2068 * @param buf buffer | |
2069 * @param size buffer size | |
2070 */ | |
2071 void av_hex_dump(FILE *f, uint8_t *buf, int size) | |
2072 { | |
2073 int len, i, j, c; | |
2074 | |
2075 for(i=0;i<size;i+=16) { | |
2076 len = size - i; | |
2077 if (len > 16) | |
2078 len = 16; | |
2079 fprintf(f, "%08x ", i); | |
2080 for(j=0;j<16;j++) { | |
2081 if (j < len) | |
2082 fprintf(f, " %02x", buf[i+j]); | |
2083 else | |
2084 fprintf(f, " "); | |
2085 } | |
2086 fprintf(f, " "); | |
2087 for(j=0;j<len;j++) { | |
2088 c = buf[i+j]; | |
2089 if (c < ' ' || c > '~') | |
2090 c = '.'; | |
2091 fprintf(f, "%c", c); | |
2092 } | |
2093 fprintf(f, "\n"); | |
2094 } | |
2095 } | |
2096 | |
2097 /** | |
2098 * Print on 'f' a nice dump of a packet | |
2099 * @param f stream for output | |
2100 * @param pkt packet to dump | |
2101 * @param dump_payload true if the payload must be displayed too | |
2102 */ | |
2103 void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload) | |
2104 { | |
2105 fprintf(f, "stream #%d:\n", pkt->stream_index); | |
2106 fprintf(f, " keyframe=%d\n", ((pkt->flags & PKT_FLAG_KEY) != 0)); | |
2107 fprintf(f, " duration=%0.3f\n", (double)pkt->duration / AV_TIME_BASE); | |
2108 /* DTS is _always_ valid after av_read_frame() */ | |
2109 fprintf(f, " dts="); | |
2110 if (pkt->dts == AV_NOPTS_VALUE) | |
2111 fprintf(f, "N/A"); | |
2112 else | |
2113 fprintf(f, "%0.3f", (double)pkt->dts / AV_TIME_BASE); | |
2114 /* PTS may be not known if B frames are present */ | |
2115 fprintf(f, " pts="); | |
2116 if (pkt->pts == AV_NOPTS_VALUE) | |
2117 fprintf(f, "N/A"); | |
2118 else | |
2119 fprintf(f, "%0.3f", (double)pkt->pts / AV_TIME_BASE); | |
2120 fprintf(f, "\n"); | |
2121 fprintf(f, " size=%d\n", pkt->size); | |
2122 if (dump_payload) | |
2123 av_hex_dump(f, pkt->data, pkt->size); | |
2124 } | |
2125 | |
2126 void url_split(char *proto, int proto_size, | |
2127 char *hostname, int hostname_size, | |
2128 int *port_ptr, | |
2129 char *path, int path_size, | |
2130 const char *url) | |
2131 { | |
2132 const char *p; | |
2133 char *q; | |
2134 int port; | |
2135 | |
2136 port = -1; | |
2137 | |
2138 p = url; | |
2139 q = proto; | |
2140 while (*p != ':' && *p != '\0') { | |
2141 if ((q - proto) < proto_size - 1) | |
2142 *q++ = *p; | |
2143 p++; | |
2144 } | |
2145 if (proto_size > 0) | |
2146 *q = '\0'; | |
2147 if (*p == '\0') { | |
2148 if (proto_size > 0) | |
2149 proto[0] = '\0'; | |
2150 if (hostname_size > 0) | |
2151 hostname[0] = '\0'; | |
2152 p = url; | |
2153 } else { | |
2154 p++; | |
2155 if (*p == '/') | |
2156 p++; | |
2157 if (*p == '/') | |
2158 p++; | |
2159 q = hostname; | |
2160 while (*p != ':' && *p != '/' && *p != '?' && *p != '\0') { | |
2161 if ((q - hostname) < hostname_size - 1) | |
2162 *q++ = *p; | |
2163 p++; | |
2164 } | |
2165 if (hostname_size > 0) | |
2166 *q = '\0'; | |
2167 if (*p == ':') { | |
2168 p++; | |
2169 port = strtoul(p, (char **)&p, 10); | |
2170 } | |
2171 } | |
2172 if (port_ptr) | |
2173 *port_ptr = port; | |
2174 pstrcpy(path, path_size, p); | |
2175 } | |
2176 | |
2177 /** | |
2178 * Set the pts for a given stream | |
2179 * @param s stream | |
2180 * @param pts_wrap_bits number of bits effectively used by the pts | |
2181 * (used for wrap control, 33 is the value for MPEG) | |
2182 * @param pts_num numerator to convert to seconds (MPEG: 1) | |
2183 * @param pts_den denominator to convert to seconds (MPEG: 90000) | |
2184 */ | |
2185 void av_set_pts_info(AVFormatContext *s, int pts_wrap_bits, | |
2186 int pts_num, int pts_den) | |
2187 { | |
2188 s->pts_wrap_bits = pts_wrap_bits; | |
2189 s->pts_num = pts_num; | |
2190 s->pts_den = pts_den; | |
2191 } | |
2192 | |
2193 /* fraction handling */ | |
2194 | |
2195 /** | |
2196 * f = val + (num / den) + 0.5. 'num' is normalized so that it is such | |
2197 * as 0 <= num < den. | |
2198 * | |
2199 * @param f fractional number | |
2200 * @param val integer value | |
2201 * @param num must be >= 0 | |
2202 * @param den must be >= 1 | |
2203 */ | |
2204 void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den) | |
2205 { | |
2206 num += (den >> 1); | |
2207 if (num >= den) { | |
2208 val += num / den; | |
2209 num = num % den; | |
2210 } | |
2211 f->val = val; | |
2212 f->num = num; | |
2213 f->den = den; | |
2214 } | |
2215 | |
2216 /* set f to (val + 0.5) */ | |
2217 void av_frac_set(AVFrac *f, int64_t val) | |
2218 { | |
2219 f->val = val; | |
2220 f->num = f->den >> 1; | |
2221 } | |
2222 | |
2223 /** | |
2224 * Fractionnal addition to f: f = f + (incr / f->den) | |
2225 * | |
2226 * @param f fractional number | |
2227 * @param incr increment, can be positive or negative | |
2228 */ | |
2229 void av_frac_add(AVFrac *f, int64_t incr) | |
2230 { | |
2231 int64_t num, den; | |
2232 | |
2233 num = f->num + incr; | |
2234 den = f->den; | |
2235 if (num < 0) { | |
2236 f->val += num / den; | |
2237 num = num % den; | |
2238 if (num < 0) { | |
2239 num += den; | |
2240 f->val--; | |
2241 } | |
2242 } else if (num >= den) { | |
2243 f->val += num / den; | |
2244 num = num % den; | |
2245 } | |
2246 f->num = num; | |
2247 } | |
2248 | |
2249 /** | |
2250 * register a new image format | |
2251 * @param img_fmt Image format descriptor | |
2252 */ | |
2253 void av_register_image_format(AVImageFormat *img_fmt) | |
2254 { | |
2255 AVImageFormat **p; | |
2256 | |
2257 p = &first_image_format; | |
2258 while (*p != NULL) p = &(*p)->next; | |
2259 *p = img_fmt; | |
2260 img_fmt->next = NULL; | |
2261 } | |
2262 | |
2263 /* guess image format */ | |
2264 AVImageFormat *av_probe_image_format(AVProbeData *pd) | |
2265 { | |
2266 AVImageFormat *fmt1, *fmt; | |
2267 int score, score_max; | |
2268 | |
2269 fmt = NULL; | |
2270 score_max = 0; | |
2271 for(fmt1 = first_image_format; fmt1 != NULL; fmt1 = fmt1->next) { | |
2272 if (fmt1->img_probe) { | |
2273 score = fmt1->img_probe(pd); | |
2274 if (score > score_max) { | |
2275 score_max = score; | |
2276 fmt = fmt1; | |
2277 } | |
2278 } | |
2279 } | |
2280 return fmt; | |
2281 } | |
2282 | |
2283 AVImageFormat *guess_image_format(const char *filename) | |
2284 { | |
2285 AVImageFormat *fmt1; | |
2286 | |
2287 for(fmt1 = first_image_format; fmt1 != NULL; fmt1 = fmt1->next) { | |
2288 if (fmt1->extensions && match_ext(filename, fmt1->extensions)) | |
2289 return fmt1; | |
2290 } | |
2291 return NULL; | |
2292 } | |
2293 | |
2294 /** | |
2295 * Read an image from a stream. | |
2296 * @param gb byte stream containing the image | |
2297 * @param fmt image format, NULL if probing is required | |
2298 */ | |
2299 int av_read_image(ByteIOContext *pb, const char *filename, | |
2300 AVImageFormat *fmt, | |
2301 int (*alloc_cb)(void *, AVImageInfo *info), void *opaque) | |
2302 { | |
210
12004b385a96
[svn] Sync with xmms-wma instead of bmp-wma & GThreadify. Does not explode, but does not play either.
chainsaw
parents:
142
diff
changeset
|
2303 unsigned char buf[PROBE_BUF_SIZE]; |
137 | 2304 AVProbeData probe_data, *pd = &probe_data; |
2305 offset_t pos; | |
2306 int ret; | |
2307 | |
2308 if (!fmt) { | |
2309 pd->filename = filename; | |
2310 pd->buf = buf; | |
2311 pos = url_ftell(pb); | |
2312 pd->buf_size = get_buffer(pb, buf, PROBE_BUF_SIZE); | |
2313 url_fseek(pb, pos, SEEK_SET); | |
2314 fmt = av_probe_image_format(pd); | |
2315 } | |
2316 if (!fmt) | |
2317 return AVERROR_NOFMT; | |
2318 ret = fmt->img_read(pb, alloc_cb, opaque); | |
2319 return ret; | |
2320 } | |
2321 | |
2322 /** | |
2323 * Write an image to a stream. | |
2324 * @param pb byte stream for the image output | |
2325 * @param fmt image format | |
2326 * @param img image data and informations | |
2327 */ | |
2328 int av_write_image(ByteIOContext *pb, AVImageFormat *fmt, AVImageInfo *img) | |
2329 { | |
2330 return fmt->img_write(pb, img); | |
2331 } | |
2332 |