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