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