Mercurial > libavformat.hg
annotate avidec.c @ 5565:befe2f0f9a00 libavformat
Use the configure check from r21351 and use it to properly define struct
sockaddr (in case it's not missing) so it always works on the system that
we are defining it for, in a RFC-2553/3493-compliant way (i.e. containing
a ss_family field). which is used in udp.c. Patch by Martin Storsj
<$firstname $firstname st>.
author | rbultje |
---|---|
date | Wed, 20 Jan 2010 17:26:14 +0000 |
parents | 7698da6e1f0a |
children | d8bfadee68a0 |
rev | line source |
---|---|
0 | 1 /* |
1415
3b00fb8ef8e4
replace coder/decoder file description in libavformat by muxer/demuxer
aurel
parents:
1358
diff
changeset
|
2 * AVI demuxer |
3538 | 3 * Copyright (c) 2001 Fabrice Bellard |
0 | 4 * |
1358
0899bfe4105c
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
1298
diff
changeset
|
5 * This file is part of FFmpeg. |
0899bfe4105c
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
1298
diff
changeset
|
6 * |
0899bfe4105c
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
1298
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:
1298
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:
1298
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:
1298
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 */ |
4203 | 21 |
4956
95ea72d4e51d
move DEBUG define before include to get dprintf and change printf to dprintf
bcoudurier
parents:
4753
diff
changeset
|
22 //#define DEBUG |
95ea72d4e51d
move DEBUG define before include to get dprintf and change printf to dprintf
bcoudurier
parents:
4753
diff
changeset
|
23 //#define DEBUG_SEEK |
95ea72d4e51d
move DEBUG define before include to get dprintf and change printf to dprintf
bcoudurier
parents:
4753
diff
changeset
|
24 |
4243 | 25 #include "libavutil/intreadwrite.h" |
4203 | 26 #include "libavutil/bswap.h" |
0 | 27 #include "avformat.h" |
28 #include "avi.h" | |
262
f174d9c00bce
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
227
diff
changeset
|
29 #include "dv.h" |
1172
6a5e58d2114b
move common stuff from avienc.c and wav.c to new file riff.c
mru
parents:
1169
diff
changeset
|
30 #include "riff.h" |
0 | 31 |
700
a5e6e0e61e24
use libavformats index system instead of the half duplicated mess in avidec.c
michael
parents:
673
diff
changeset
|
32 #undef NDEBUG |
a5e6e0e61e24
use libavformats index system instead of the half duplicated mess in avidec.c
michael
parents:
673
diff
changeset
|
33 #include <assert.h> |
a5e6e0e61e24
use libavformats index system instead of the half duplicated mess in avidec.c
michael
parents:
673
diff
changeset
|
34 |
311 | 35 typedef struct AVIStream { |
701 | 36 int64_t frame_offset; /* current frame (video) or byte (audio) counter |
311 | 37 (used to compute the pts) */ |
701 | 38 int remaining; |
39 int packet_size; | |
40 | |
311 | 41 int scale; |
885 | 42 int rate; |
982 | 43 int sample_size; /* size of one sample (or packet) (in the rate/scale sense) in bytes */ |
885 | 44 |
977 | 45 int64_t cum_len; /* temporary storage (used during seek) */ |
885 | 46 |
519 | 47 int prefix; ///< normally 'd'<<8 + 'c' or 'w'<<8 + 'b' |
48 int prefix_count; | |
3157
27c5bc69a1f9
One non functional AVPalette chunk less, one heap overflow less.
michael
parents:
3105
diff
changeset
|
49 uint32_t pal[256]; |
27c5bc69a1f9
One non functional AVPalette chunk less, one heap overflow less.
michael
parents:
3105
diff
changeset
|
50 int has_pal; |
311 | 51 } AVIStream; |
0 | 52 |
53 typedef struct { | |
262
f174d9c00bce
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
227
diff
changeset
|
54 int64_t riff_end; |
f174d9c00bce
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
227
diff
changeset
|
55 int64_t movi_end; |
2383 | 56 int64_t fsize; |
3973
549a09cf23fe
Remove offset_t typedef and use int64_t directly instead.
diego
parents:
3908
diff
changeset
|
57 int64_t movi_list; |
3984 | 58 int64_t last_pkt_pos; |
311 | 59 int index_loaded; |
510 | 60 int is_odml; |
701 | 61 int non_interleaved; |
62 int stream_index; | |
296
252946de6d3f
* DV demuxer is now capable of decoding auxilary audio stream. So,
romansh
parents:
262
diff
changeset
|
63 DVDemuxContext* dv_demux; |
0 | 64 } AVIContext; |
65 | |
2578 | 66 static const char avi_headers[][8] = { |
67 { 'R', 'I', 'F', 'F', 'A', 'V', 'I', ' ' }, | |
68 { 'R', 'I', 'F', 'F', 'A', 'V', 'I', 'X' }, | |
69 { 'R', 'I', 'F', 'F', 'A', 'V', 'I', 0x19}, | |
2579 | 70 { 'O', 'N', '2', ' ', 'O', 'N', '2', 'f' }, |
2584 | 71 { 'R', 'I', 'F', 'F', 'A', 'M', 'V', ' ' }, |
2578 | 72 { 0 } |
73 }; | |
74 | |
469
6a4cc19e8d9b
exporting keyframe flags, fixes keyframe stuff with streamcopy
michael
parents:
466
diff
changeset
|
75 static int avi_load_index(AVFormatContext *s); |
979 | 76 static int guess_ni_flag(AVFormatContext *s); |
469
6a4cc19e8d9b
exporting keyframe flags, fixes keyframe stuff with streamcopy
michael
parents:
466
diff
changeset
|
77 |
0 | 78 #ifdef DEBUG |
79 static void print_tag(const char *str, unsigned int tag, int size) | |
80 { | |
4956
95ea72d4e51d
move DEBUG define before include to get dprintf and change printf to dprintf
bcoudurier
parents:
4753
diff
changeset
|
81 dprintf(NULL, "%s: tag=%c%c%c%c size=0x%x\n", |
0 | 82 str, tag & 0xff, |
83 (tag >> 8) & 0xff, | |
84 (tag >> 16) & 0xff, | |
85 (tag >> 24) & 0xff, | |
86 size); | |
87 } | |
88 #endif | |
89 | |
4515
1d9ace1dec78
Add a context to av_log() calls and modify a function prototype to allow it.
benoit
parents:
4353
diff
changeset
|
90 static int get_riff(AVFormatContext *s, ByteIOContext *pb) |
92
5a4b5f03d13e
OpenDML AVI > 2Gb support patch by (Roman Shaposhnick <rvs at sun dot com>)
michaelni
parents:
91
diff
changeset
|
91 { |
4515
1d9ace1dec78
Add a context to av_log() calls and modify a function prototype to allow it.
benoit
parents:
4353
diff
changeset
|
92 AVIContext *avi = s->priv_data; |
2578 | 93 char header[8]; |
94 int i; | |
95 | |
92
5a4b5f03d13e
OpenDML AVI > 2Gb support patch by (Roman Shaposhnick <rvs at sun dot com>)
michaelni
parents:
91
diff
changeset
|
96 /* check RIFF header */ |
2578 | 97 get_buffer(pb, header, 4); |
92
5a4b5f03d13e
OpenDML AVI > 2Gb support patch by (Roman Shaposhnick <rvs at sun dot com>)
michaelni
parents:
91
diff
changeset
|
98 avi->riff_end = get_le32(pb); /* RIFF chunk size */ |
5a4b5f03d13e
OpenDML AVI > 2Gb support patch by (Roman Shaposhnick <rvs at sun dot com>)
michaelni
parents:
91
diff
changeset
|
99 avi->riff_end += url_ftell(pb); /* RIFF chunk end */ |
2578 | 100 get_buffer(pb, header+4, 4); |
101 | |
102 for(i=0; avi_headers[i][0]; i++) | |
103 if(!memcmp(header, avi_headers[i], 8)) | |
104 break; | |
105 if(!avi_headers[i][0]) | |
106 return -1; | |
107 | |
108 if(header[7] == 0x19) | |
4515
1d9ace1dec78
Add a context to av_log() calls and modify a function prototype to allow it.
benoit
parents:
4353
diff
changeset
|
109 av_log(s, AV_LOG_INFO, "This file has been generated by a totally broken muxer.\n"); |
885 | 110 |
92
5a4b5f03d13e
OpenDML AVI > 2Gb support patch by (Roman Shaposhnick <rvs at sun dot com>)
michaelni
parents:
91
diff
changeset
|
111 return 0; |
5a4b5f03d13e
OpenDML AVI > 2Gb support patch by (Roman Shaposhnick <rvs at sun dot com>)
michaelni
parents:
91
diff
changeset
|
112 } |
5a4b5f03d13e
OpenDML AVI > 2Gb support patch by (Roman Shaposhnick <rvs at sun dot com>)
michaelni
parents:
91
diff
changeset
|
113 |
977 | 114 static int read_braindead_odml_indx(AVFormatContext *s, int frame_num){ |
984
b644fe79f7a2
fixing av sync in videotest.avi (index doesnt match chunks, header doesnt indicate that)
michael
parents:
983
diff
changeset
|
115 AVIContext *avi = s->priv_data; |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2584
diff
changeset
|
116 ByteIOContext *pb = s->pb; |
977 | 117 int longs_pre_entry= get_le16(pb); |
118 int index_sub_type = get_byte(pb); | |
119 int index_type = get_byte(pb); | |
120 int entries_in_use = get_le32(pb); | |
121 int chunk_id = get_le32(pb); | |
122 int64_t base = get_le64(pb); | |
123 int stream_id= 10*((chunk_id&0xFF) - '0') + (((chunk_id>>8)&0xFF) - '0'); | |
124 AVStream *st; | |
125 AVIStream *ast; | |
126 int i; | |
984
b644fe79f7a2
fixing av sync in videotest.avi (index doesnt match chunks, header doesnt indicate that)
michael
parents:
983
diff
changeset
|
127 int64_t last_pos= -1; |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2584
diff
changeset
|
128 int64_t filesize= url_fsize(s->pb); |
977 | 129 |
1277 | 130 #ifdef DEBUG_SEEK |
1443
404048ea11bc
Replace most of the %lld and %llx by their (cleaner) PRI*64 counterparts.
diego
parents:
1441
diff
changeset
|
131 av_log(s, AV_LOG_ERROR, "longs_pre_entry:%d index_type:%d entries_in_use:%d chunk_id:%X base:%16"PRIX64"\n", |
1277 | 132 longs_pre_entry,index_type, entries_in_use, chunk_id, base); |
133 #endif | |
977 | 134 |
135 if(stream_id > s->nb_streams || stream_id < 0) | |
136 return -1; | |
137 st= s->streams[stream_id]; | |
138 ast = st->priv_data; | |
139 | |
140 if(index_sub_type) | |
141 return -1; | |
142 | |
143 get_le32(pb); | |
144 | |
145 if(index_type && longs_pre_entry != 2) | |
146 return -1; | |
147 if(index_type>1) | |
148 return -1; | |
149 | |
1277 | 150 if(filesize > 0 && base >= filesize){ |
151 av_log(s, AV_LOG_ERROR, "ODML index invalid\n"); | |
152 if(base>>32 == (base & 0xFFFFFFFF) && (base & 0xFFFFFFFF) < filesize && filesize <= 0xFFFFFFFF) | |
153 base &= 0xFFFFFFFF; | |
154 else | |
155 return -1; | |
156 } | |
157 | |
977 | 158 for(i=0; i<entries_in_use; i++){ |
159 if(index_type){ | |
979 | 160 int64_t pos= get_le32(pb) + base - 8; |
977 | 161 int len = get_le32(pb); |
979 | 162 int key= len >= 0; |
163 len &= 0x7FFFFFFF; | |
977 | 164 |
1277 | 165 #ifdef DEBUG_SEEK |
1443
404048ea11bc
Replace most of the %lld and %llx by their (cleaner) PRI*64 counterparts.
diego
parents:
1441
diff
changeset
|
166 av_log(s, AV_LOG_ERROR, "pos:%"PRId64", len:%X\n", pos, len); |
1277 | 167 #endif |
4554 | 168 if(url_feof(pb)) |
169 return -1; | |
170 | |
984
b644fe79f7a2
fixing av sync in videotest.avi (index doesnt match chunks, header doesnt indicate that)
michael
parents:
983
diff
changeset
|
171 if(last_pos == pos || pos == base - 8) |
b644fe79f7a2
fixing av sync in videotest.avi (index doesnt match chunks, header doesnt indicate that)
michael
parents:
983
diff
changeset
|
172 avi->non_interleaved= 1; |
5327
a8e26981c104
Fix infinite loop with size==0 && sample_size!=0 in non interleaved avis.
michael
parents:
5326
diff
changeset
|
173 if(last_pos != pos && (len || !ast->sample_size)) |
5326
4e1e9ab777a1
Support non interleaved avi files that have 0<size<sample_size.
michael
parents:
5243
diff
changeset
|
174 av_add_index_entry(st, pos, ast->cum_len, len, 0, key ? AVINDEX_KEYFRAME : 0); |
977 | 175 |
176 if(ast->sample_size) | |
1522
68620a6be643
fix support for avis with sample_size > packet size
michael
parents:
1489
diff
changeset
|
177 ast->cum_len += len; |
977 | 178 else |
179 ast->cum_len ++; | |
984
b644fe79f7a2
fixing av sync in videotest.avi (index doesnt match chunks, header doesnt indicate that)
michael
parents:
983
diff
changeset
|
180 last_pos= pos; |
977 | 181 }else{ |
1144 | 182 int64_t offset, pos; |
183 int duration; | |
184 offset = get_le64(pb); | |
185 get_le32(pb); /* size */ | |
186 duration = get_le32(pb); | |
4554 | 187 |
188 if(url_feof(pb)) | |
189 return -1; | |
190 | |
1144 | 191 pos = url_ftell(pb); |
977 | 192 |
193 url_fseek(pb, offset+8, SEEK_SET); | |
194 read_braindead_odml_indx(s, frame_num); | |
195 frame_num += duration; | |
196 | |
197 url_fseek(pb, pos, SEEK_SET); | |
198 } | |
199 } | |
1277 | 200 avi->index_loaded=1; |
977 | 201 return 0; |
202 } | |
203 | |
983
558381bf97d2
support seeking in RenderAvi.avi (audio stream == single huge chunk)
michael
parents:
982
diff
changeset
|
204 static void clean_index(AVFormatContext *s){ |
1277 | 205 int i; |
206 int64_t j; | |
983
558381bf97d2
support seeking in RenderAvi.avi (audio stream == single huge chunk)
michael
parents:
982
diff
changeset
|
207 |
558381bf97d2
support seeking in RenderAvi.avi (audio stream == single huge chunk)
michael
parents:
982
diff
changeset
|
208 for(i=0; i<s->nb_streams; i++){ |
558381bf97d2
support seeking in RenderAvi.avi (audio stream == single huge chunk)
michael
parents:
982
diff
changeset
|
209 AVStream *st = s->streams[i]; |
558381bf97d2
support seeking in RenderAvi.avi (audio stream == single huge chunk)
michael
parents:
982
diff
changeset
|
210 AVIStream *ast = st->priv_data; |
558381bf97d2
support seeking in RenderAvi.avi (audio stream == single huge chunk)
michael
parents:
982
diff
changeset
|
211 int n= st->nb_index_entries; |
558381bf97d2
support seeking in RenderAvi.avi (audio stream == single huge chunk)
michael
parents:
982
diff
changeset
|
212 int max= ast->sample_size; |
558381bf97d2
support seeking in RenderAvi.avi (audio stream == single huge chunk)
michael
parents:
982
diff
changeset
|
213 int64_t pos, size, ts; |
558381bf97d2
support seeking in RenderAvi.avi (audio stream == single huge chunk)
michael
parents:
982
diff
changeset
|
214 |
558381bf97d2
support seeking in RenderAvi.avi (audio stream == single huge chunk)
michael
parents:
982
diff
changeset
|
215 if(n != 1 || ast->sample_size==0) |
558381bf97d2
support seeking in RenderAvi.avi (audio stream == single huge chunk)
michael
parents:
982
diff
changeset
|
216 continue; |
558381bf97d2
support seeking in RenderAvi.avi (audio stream == single huge chunk)
michael
parents:
982
diff
changeset
|
217 |
558381bf97d2
support seeking in RenderAvi.avi (audio stream == single huge chunk)
michael
parents:
982
diff
changeset
|
218 while(max < 1024) max+=max; |
558381bf97d2
support seeking in RenderAvi.avi (audio stream == single huge chunk)
michael
parents:
982
diff
changeset
|
219 |
558381bf97d2
support seeking in RenderAvi.avi (audio stream == single huge chunk)
michael
parents:
982
diff
changeset
|
220 pos= st->index_entries[0].pos; |
558381bf97d2
support seeking in RenderAvi.avi (audio stream == single huge chunk)
michael
parents:
982
diff
changeset
|
221 size= st->index_entries[0].size; |
558381bf97d2
support seeking in RenderAvi.avi (audio stream == single huge chunk)
michael
parents:
982
diff
changeset
|
222 ts= st->index_entries[0].timestamp; |
558381bf97d2
support seeking in RenderAvi.avi (audio stream == single huge chunk)
michael
parents:
982
diff
changeset
|
223 |
558381bf97d2
support seeking in RenderAvi.avi (audio stream == single huge chunk)
michael
parents:
982
diff
changeset
|
224 for(j=0; j<size; j+=max){ |
5326
4e1e9ab777a1
Support non interleaved avi files that have 0<size<sample_size.
michael
parents:
5243
diff
changeset
|
225 av_add_index_entry(st, pos+j, ts+j, FFMIN(max, size-j), 0, AVINDEX_KEYFRAME); |
983
558381bf97d2
support seeking in RenderAvi.avi (audio stream == single huge chunk)
michael
parents:
982
diff
changeset
|
226 } |
558381bf97d2
support seeking in RenderAvi.avi (audio stream == single huge chunk)
michael
parents:
982
diff
changeset
|
227 } |
558381bf97d2
support seeking in RenderAvi.avi (audio stream == single huge chunk)
michael
parents:
982
diff
changeset
|
228 } |
558381bf97d2
support seeking in RenderAvi.avi (audio stream == single huge chunk)
michael
parents:
982
diff
changeset
|
229 |
4149 | 230 static int avi_read_tag(AVFormatContext *s, const char *key, unsigned int size) |
1256 | 231 { |
4149 | 232 ByteIOContext *pb = s->pb; |
5446
4211f91f69b1
Use AV_METADATA_DONT_STRDUP* / use av_malloced metadata instead of strduped
michael
parents:
5327
diff
changeset
|
233 char *value; |
4149 | 234 |
1256 | 235 size += (size & 1); |
4149 | 236 |
5446
4211f91f69b1
Use AV_METADATA_DONT_STRDUP* / use av_malloced metadata instead of strduped
michael
parents:
5327
diff
changeset
|
237 if (size == UINT_MAX) |
4211f91f69b1
Use AV_METADATA_DONT_STRDUP* / use av_malloced metadata instead of strduped
michael
parents:
5327
diff
changeset
|
238 return -1; |
4211f91f69b1
Use AV_METADATA_DONT_STRDUP* / use av_malloced metadata instead of strduped
michael
parents:
5327
diff
changeset
|
239 value = av_malloc(size+1); |
4211f91f69b1
Use AV_METADATA_DONT_STRDUP* / use av_malloced metadata instead of strduped
michael
parents:
5327
diff
changeset
|
240 if (!value) |
4211f91f69b1
Use AV_METADATA_DONT_STRDUP* / use av_malloced metadata instead of strduped
michael
parents:
5327
diff
changeset
|
241 return -1; |
4211f91f69b1
Use AV_METADATA_DONT_STRDUP* / use av_malloced metadata instead of strduped
michael
parents:
5327
diff
changeset
|
242 get_strz(pb, value, size); |
4211f91f69b1
Use AV_METADATA_DONT_STRDUP* / use av_malloced metadata instead of strduped
michael
parents:
5327
diff
changeset
|
243 |
4211f91f69b1
Use AV_METADATA_DONT_STRDUP* / use av_malloced metadata instead of strduped
michael
parents:
5327
diff
changeset
|
244 return av_metadata_set2(&s->metadata, key, value, |
4211f91f69b1
Use AV_METADATA_DONT_STRDUP* / use av_malloced metadata instead of strduped
michael
parents:
5327
diff
changeset
|
245 AV_METADATA_DONT_STRDUP_VAL); |
1256 | 246 } |
247 | |
0 | 248 static int avi_read_header(AVFormatContext *s, AVFormatParameters *ap) |
249 { | |
250 AVIContext *avi = s->priv_data; | |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2584
diff
changeset
|
251 ByteIOContext *pb = s->pb; |
4230
de3cb095285c
Make unsigned int a variable that does not need to be explicitely 32 bits.
benoit
parents:
4210
diff
changeset
|
252 unsigned int tag, tag1, handler; |
703 | 253 int codec_type, stream_index, frame_period, bit_rate; |
188
6c9d6422a2f6
update duration and start_time - add av_new_stream() usage
bellard
parents:
149
diff
changeset
|
254 unsigned int size, nb_frames; |
1785
2376ab11ea73
support yet another broken avi (filedoesitbetter.avi) which has a wrong stream count
michael
parents:
1761
diff
changeset
|
255 int i; |
0 | 256 AVStream *st; |
1144 | 257 AVIStream *ast = NULL; |
2584 | 258 int avih_width=0, avih_height=0; |
259 int amv_file_format=0; | |
5087
5de39afaca2e
Check size of "strf" header against size of enclosing "LIST" if there is one.
reimar
parents:
5058
diff
changeset
|
260 uint64_t list_end = 0; |
0 | 261 |
701 | 262 avi->stream_index= -1; |
885 | 263 |
4516 | 264 if (get_riff(s, pb) < 0) |
0 | 265 return -1; |
266 | |
2383 | 267 avi->fsize = url_fsize(pb); |
268 if(avi->fsize<=0) | |
4753
290a386de8d4
set avi fsize to INT64_MAX if riff tag end is not set and file size is not available
bcoudurier
parents:
4555
diff
changeset
|
269 avi->fsize= avi->riff_end == 8 ? INT64_MAX : avi->riff_end; |
2383 | 270 |
0 | 271 /* first list tag */ |
272 stream_index = -1; | |
273 codec_type = -1; | |
274 frame_period = 0; | |
275 for(;;) { | |
276 if (url_feof(pb)) | |
277 goto fail; | |
278 tag = get_le32(pb); | |
279 size = get_le32(pb); | |
280 #ifdef DEBUG | |
281 print_tag("tag", tag, size); | |
282 #endif | |
283 | |
284 switch(tag) { | |
285 case MKTAG('L', 'I', 'S', 'T'): | |
5087
5de39afaca2e
Check size of "strf" header against size of enclosing "LIST" if there is one.
reimar
parents:
5058
diff
changeset
|
286 list_end = url_ftell(pb) + size; |
3538 | 287 /* Ignored, except at start of video packets. */ |
0 | 288 tag1 = get_le32(pb); |
289 #ifdef DEBUG | |
290 print_tag("list", tag1, 0); | |
291 #endif | |
292 if (tag1 == MKTAG('m', 'o', 'v', 'i')) { | |
311 | 293 avi->movi_list = url_ftell(pb) - 4; |
1286 | 294 if(size) avi->movi_end = avi->movi_list + size + (size & 1); |
764
cdb845a57ae4
drop most url_fileno() calls (allows to use ByteIOContext directly in caller apps instead of URLProtocol)
aurel
parents:
743
diff
changeset
|
295 else avi->movi_end = url_fsize(pb); |
4956
95ea72d4e51d
move DEBUG define before include to get dprintf and change printf to dprintf
bcoudurier
parents:
4753
diff
changeset
|
296 dprintf(NULL, "movi end=%"PRIx64"\n", avi->movi_end); |
0 | 297 goto end_of_header; |
298 } | |
299 break; | |
510 | 300 case MKTAG('d', 'm', 'l', 'h'): |
887 | 301 avi->is_odml = 1; |
302 url_fskip(pb, size + (size & 1)); | |
303 break; | |
2584 | 304 case MKTAG('a', 'm', 'v', 'h'): |
305 amv_file_format=1; | |
0 | 306 case MKTAG('a', 'v', 'i', 'h'): |
3538 | 307 /* AVI header */ |
0 | 308 /* using frame_period is bad idea */ |
309 frame_period = get_le32(pb); | |
310 bit_rate = get_le32(pb) * 8; | |
981
55519fa957c3
fix demuxing of XviD_with_3_AAC-HE_audio_streams.avi
michael
parents:
980
diff
changeset
|
311 get_le32(pb); |
55519fa957c3
fix demuxing of XviD_with_3_AAC-HE_audio_streams.avi
michael
parents:
980
diff
changeset
|
312 avi->non_interleaved |= get_le32(pb) & AVIF_MUSTUSEINDEX; |
55519fa957c3
fix demuxing of XviD_with_3_AAC-HE_audio_streams.avi
michael
parents:
980
diff
changeset
|
313 |
55519fa957c3
fix demuxing of XviD_with_3_AAC-HE_audio_streams.avi
michael
parents:
980
diff
changeset
|
314 url_fskip(pb, 2 * 4); |
1785
2376ab11ea73
support yet another broken avi (filedoesitbetter.avi) which has a wrong stream count
michael
parents:
1761
diff
changeset
|
315 get_le32(pb); |
2584 | 316 get_le32(pb); |
317 avih_width=get_le32(pb); | |
318 avih_height=get_le32(pb); | |
1785
2376ab11ea73
support yet another broken avi (filedoesitbetter.avi) which has a wrong stream count
michael
parents:
1761
diff
changeset
|
319 |
2584 | 320 url_fskip(pb, size - 10 * 4); |
1785
2376ab11ea73
support yet another broken avi (filedoesitbetter.avi) which has a wrong stream count
michael
parents:
1761
diff
changeset
|
321 break; |
2376ab11ea73
support yet another broken avi (filedoesitbetter.avi) which has a wrong stream count
michael
parents:
1761
diff
changeset
|
322 case MKTAG('s', 't', 'r', 'h'): |
2376ab11ea73
support yet another broken avi (filedoesitbetter.avi) which has a wrong stream count
michael
parents:
1761
diff
changeset
|
323 /* stream header */ |
2376ab11ea73
support yet another broken avi (filedoesitbetter.avi) which has a wrong stream count
michael
parents:
1761
diff
changeset
|
324 |
2376ab11ea73
support yet another broken avi (filedoesitbetter.avi) which has a wrong stream count
michael
parents:
1761
diff
changeset
|
325 tag1 = get_le32(pb); |
2376ab11ea73
support yet another broken avi (filedoesitbetter.avi) which has a wrong stream count
michael
parents:
1761
diff
changeset
|
326 handler = get_le32(pb); /* codec tag */ |
2376ab11ea73
support yet another broken avi (filedoesitbetter.avi) which has a wrong stream count
michael
parents:
1761
diff
changeset
|
327 |
2376ab11ea73
support yet another broken avi (filedoesitbetter.avi) which has a wrong stream count
michael
parents:
1761
diff
changeset
|
328 if(tag1 == MKTAG('p', 'a', 'd', 's')){ |
2376ab11ea73
support yet another broken avi (filedoesitbetter.avi) which has a wrong stream count
michael
parents:
1761
diff
changeset
|
329 url_fskip(pb, size - 8); |
2376ab11ea73
support yet another broken avi (filedoesitbetter.avi) which has a wrong stream count
michael
parents:
1761
diff
changeset
|
330 break; |
2376ab11ea73
support yet another broken avi (filedoesitbetter.avi) which has a wrong stream count
michael
parents:
1761
diff
changeset
|
331 }else{ |
2376ab11ea73
support yet another broken avi (filedoesitbetter.avi) which has a wrong stream count
michael
parents:
1761
diff
changeset
|
332 stream_index++; |
2376ab11ea73
support yet another broken avi (filedoesitbetter.avi) which has a wrong stream count
michael
parents:
1761
diff
changeset
|
333 st = av_new_stream(s, stream_index); |
0 | 334 if (!st) |
335 goto fail; | |
462
b69898ffc92a
move time_base (pts_num/pts_den) from AVFormatContext -> AVStream
michael
parents:
457
diff
changeset
|
336 |
311 | 337 ast = av_mallocz(sizeof(AVIStream)); |
338 if (!ast) | |
339 goto fail; | |
340 st->priv_data = ast; | |
887 | 341 } |
2584 | 342 if(amv_file_format) |
343 tag1 = stream_index ? MKTAG('a','u','d','s') : MKTAG('v','i','d','s'); | |
1785
2376ab11ea73
support yet another broken avi (filedoesitbetter.avi) which has a wrong stream count
michael
parents:
1761
diff
changeset
|
344 |
471 | 345 #ifdef DEBUG |
1441
ad3b03b7b142
reindentation, patch by From: Steve Lhomme, slhomme divxcorp com
diego
parents:
1415
diff
changeset
|
346 print_tag("strh", tag1, -1); |
471 | 347 #endif |
703 | 348 if(tag1 == MKTAG('i', 'a', 'v', 's') || tag1 == MKTAG('i', 'v', 'a', 's')){ |
1629
aedce96c28ff
* Fixing seeking with DV-AVI (by Jeff Downs <heydowns at borg dot com>)
romansh
parents:
1527
diff
changeset
|
349 int64_t dv_dur; |
aedce96c28ff
* Fixing seeking with DV-AVI (by Jeff Downs <heydowns at borg dot com>)
romansh
parents:
1527
diff
changeset
|
350 |
885 | 351 /* |
887 | 352 * After some consideration -- I don't think we |
3538 | 353 * have to support anything but DV in type1 AVIs. |
887 | 354 */ |
355 if (s->nb_streams != 1) | |
356 goto fail; | |
885 | 357 |
887 | 358 if (handler != MKTAG('d', 'v', 's', 'd') && |
359 handler != MKTAG('d', 'v', 'h', 'd') && | |
360 handler != MKTAG('d', 'v', 's', 'l')) | |
361 goto fail; | |
885 | 362 |
887 | 363 ast = s->streams[0]->priv_data; |
364 av_freep(&s->streams[0]->codec->extradata); | |
365 av_freep(&s->streams[0]); | |
366 s->nb_streams = 0; | |
4210
ec95366371ba
replace all occurrence of ENABLE_ by the corresponding CONFIG_, HAVE_ or ARCH_
aurel
parents:
4203
diff
changeset
|
367 if (CONFIG_DV_DEMUXER) { |
1489 | 368 avi->dv_demux = dv_init_demux(s); |
369 if (!avi->dv_demux) | |
370 goto fail; | |
1488
41a7ed2b064a
Fix avidec.c compilation when dv demuxer is disabled.
aurel
parents:
1472
diff
changeset
|
371 } |
887 | 372 s->streams[0]->priv_data = ast; |
373 url_fskip(pb, 3 * 4); | |
374 ast->scale = get_le32(pb); | |
375 ast->rate = get_le32(pb); | |
1629
aedce96c28ff
* Fixing seeking with DV-AVI (by Jeff Downs <heydowns at borg dot com>)
romansh
parents:
1527
diff
changeset
|
376 url_fskip(pb, 4); /* start time */ |
aedce96c28ff
* Fixing seeking with DV-AVI (by Jeff Downs <heydowns at borg dot com>)
romansh
parents:
1527
diff
changeset
|
377 |
aedce96c28ff
* Fixing seeking with DV-AVI (by Jeff Downs <heydowns at borg dot com>)
romansh
parents:
1527
diff
changeset
|
378 dv_dur = get_le32(pb); |
aedce96c28ff
* Fixing seeking with DV-AVI (by Jeff Downs <heydowns at borg dot com>)
romansh
parents:
1527
diff
changeset
|
379 if (ast->scale > 0 && ast->rate > 0 && dv_dur > 0) { |
aedce96c28ff
* Fixing seeking with DV-AVI (by Jeff Downs <heydowns at borg dot com>)
romansh
parents:
1527
diff
changeset
|
380 dv_dur *= AV_TIME_BASE; |
aedce96c28ff
* Fixing seeking with DV-AVI (by Jeff Downs <heydowns at borg dot com>)
romansh
parents:
1527
diff
changeset
|
381 s->duration = av_rescale(dv_dur, ast->scale, ast->rate); |
aedce96c28ff
* Fixing seeking with DV-AVI (by Jeff Downs <heydowns at borg dot com>)
romansh
parents:
1527
diff
changeset
|
382 } |
aedce96c28ff
* Fixing seeking with DV-AVI (by Jeff Downs <heydowns at borg dot com>)
romansh
parents:
1527
diff
changeset
|
383 /* |
aedce96c28ff
* Fixing seeking with DV-AVI (by Jeff Downs <heydowns at borg dot com>)
romansh
parents:
1527
diff
changeset
|
384 * else, leave duration alone; timing estimation in utils.c |
3538 | 385 * will make a guess based on bitrate. |
1629
aedce96c28ff
* Fixing seeking with DV-AVI (by Jeff Downs <heydowns at borg dot com>)
romansh
parents:
1527
diff
changeset
|
386 */ |
aedce96c28ff
* Fixing seeking with DV-AVI (by Jeff Downs <heydowns at borg dot com>)
romansh
parents:
1527
diff
changeset
|
387 |
887 | 388 stream_index = s->nb_streams - 1; |
1629
aedce96c28ff
* Fixing seeking with DV-AVI (by Jeff Downs <heydowns at borg dot com>)
romansh
parents:
1527
diff
changeset
|
389 url_fskip(pb, size - 9*4); |
703 | 390 break; |
391 } | |
392 | |
1785
2376ab11ea73
support yet another broken avi (filedoesitbetter.avi) which has a wrong stream count
michael
parents:
1761
diff
changeset
|
393 assert(stream_index < s->nb_streams); |
820
feca73904e67
changing AVCodecContext codec -> *codec in AVStream so additions to AVCodecContext dont randomize AVStream and break binary compatibility
michael
parents:
775
diff
changeset
|
394 st->codec->stream_codec_tag= handler; |
703 | 395 |
396 get_le32(pb); /* flags */ | |
397 get_le16(pb); /* priority */ | |
398 get_le16(pb); /* language */ | |
399 get_le32(pb); /* initial frame */ | |
400 ast->scale = get_le32(pb); | |
401 ast->rate = get_le32(pb); | |
3210 | 402 if(!(ast->scale && ast->rate)){ |
3538 | 403 av_log(s, AV_LOG_WARNING, "scale/rate is %u/%u which is invalid. (This file has been generated by broken software.)\n", ast->scale, ast->rate); |
3211 | 404 if(frame_period){ |
405 ast->rate = 1000000; | |
406 ast->scale = frame_period; | |
407 }else{ | |
408 ast->rate = 25; | |
409 ast->scale = 1; | |
410 } | |
3210 | 411 } |
703 | 412 av_set_pts_info(st, 64, ast->scale, ast->rate); |
885 | 413 |
989 | 414 ast->cum_len=get_le32(pb); /* start */ |
703 | 415 nb_frames = get_le32(pb); |
416 | |
417 st->start_time = 0; | |
743 | 418 st->duration = nb_frames; |
703 | 419 get_le32(pb); /* buffer size */ |
420 get_le32(pb); /* quality */ | |
421 ast->sample_size = get_le32(pb); /* sample ssize */ | |
1522
68620a6be643
fix support for avis with sample_size > packet size
michael
parents:
1489
diff
changeset
|
422 ast->cum_len *= FFMAX(1, ast->sample_size); |
4515
1d9ace1dec78
Add a context to av_log() calls and modify a function prototype to allow it.
benoit
parents:
4353
diff
changeset
|
423 // av_log(s, AV_LOG_DEBUG, "%d %d %d %d\n", ast->rate, ast->scale, ast->start, ast->sample_size); |
703 | 424 |
425 switch(tag1) { | |
887 | 426 case MKTAG('v', 'i', 'd', 's'): |
0 | 427 codec_type = CODEC_TYPE_VIDEO; |
75
78bec272ce3a
read BITMAPINFOHEADER extra stuff (huffyuv decoding fixed)
michaelni
parents:
73
diff
changeset
|
428 |
703 | 429 ast->sample_size = 0; |
0 | 430 break; |
431 case MKTAG('a', 'u', 'd', 's'): | |
703 | 432 codec_type = CODEC_TYPE_AUDIO; |
73
d40ddc73858a
reversing not yet reversed changes from r1.7 -> r1.8 except the static/const stuff
michaelni
parents:
65
diff
changeset
|
433 break; |
471 | 434 case MKTAG('t', 'x', 't', 's'): |
885 | 435 //FIXME |
471 | 436 codec_type = CODEC_TYPE_DATA; //CODEC_TYPE_SUB ? FIXME |
437 break; | |
3479 | 438 case MKTAG('d', 'a', 't', 's'): |
439 codec_type = CODEC_TYPE_DATA; | |
440 break; | |
73
d40ddc73858a
reversing not yet reversed changes from r1.7 -> r1.8 except the static/const stuff
michaelni
parents:
65
diff
changeset
|
441 default: |
534 | 442 av_log(s, AV_LOG_ERROR, "unknown stream type %X\n", tag1); |
73
d40ddc73858a
reversing not yet reversed changes from r1.7 -> r1.8 except the static/const stuff
michaelni
parents:
65
diff
changeset
|
443 goto fail; |
0 | 444 } |
1522
68620a6be643
fix support for avis with sample_size > packet size
michael
parents:
1489
diff
changeset
|
445 ast->frame_offset= ast->cum_len; |
703 | 446 url_fskip(pb, size - 12 * 4); |
0 | 447 break; |
448 case MKTAG('s', 't', 'r', 'f'): | |
449 /* stream header */ | |
1785
2376ab11ea73
support yet another broken avi (filedoesitbetter.avi) which has a wrong stream count
michael
parents:
1761
diff
changeset
|
450 if (stream_index >= (unsigned)s->nb_streams || avi->dv_demux) { |
0 | 451 url_fskip(pb, size); |
452 } else { | |
5087
5de39afaca2e
Check size of "strf" header against size of enclosing "LIST" if there is one.
reimar
parents:
5058
diff
changeset
|
453 uint64_t cur_pos = url_ftell(pb); |
5de39afaca2e
Check size of "strf" header against size of enclosing "LIST" if there is one.
reimar
parents:
5058
diff
changeset
|
454 if (cur_pos < list_end) |
5de39afaca2e
Check size of "strf" header against size of enclosing "LIST" if there is one.
reimar
parents:
5058
diff
changeset
|
455 size = FFMIN(size, list_end - cur_pos); |
0 | 456 st = s->streams[stream_index]; |
457 switch(codec_type) { | |
458 case CODEC_TYPE_VIDEO: | |
2584 | 459 if(amv_file_format){ |
460 st->codec->width=avih_width; | |
461 st->codec->height=avih_height; | |
462 st->codec->codec_type = CODEC_TYPE_VIDEO; | |
463 st->codec->codec_id = CODEC_ID_AMV; | |
464 url_fskip(pb, size); | |
465 break; | |
466 } | |
0 | 467 get_le32(pb); /* size */ |
820
feca73904e67
changing AVCodecContext codec -> *codec in AVStream so additions to AVCodecContext dont randomize AVStream and break binary compatibility
michael
parents:
775
diff
changeset
|
468 st->codec->width = get_le32(pb); |
4550
a36f9f2eefcb
Fix raw rgb/bgr vertical flip in avi based on info from http://www.fourcc.org/fccbihgt.php.
michael
parents:
4541
diff
changeset
|
469 st->codec->height = (int32_t)get_le32(pb); |
0 | 470 get_le16(pb); /* panes */ |
3908
1d3d17de20ba
Bump Major version, this commit is almost just renaming bits_per_sample to
michael
parents:
3759
diff
changeset
|
471 st->codec->bits_per_coded_sample= get_le16(pb); /* depth */ |
0 | 472 tag1 = get_le32(pb); |
75
78bec272ce3a
read BITMAPINFOHEADER extra stuff (huffyuv decoding fixed)
michaelni
parents:
73
diff
changeset
|
473 get_le32(pb); /* ImageSize */ |
78bec272ce3a
read BITMAPINFOHEADER extra stuff (huffyuv decoding fixed)
michaelni
parents:
73
diff
changeset
|
474 get_le32(pb); /* XPelsPerMeter */ |
78bec272ce3a
read BITMAPINFOHEADER extra stuff (huffyuv decoding fixed)
michaelni
parents:
73
diff
changeset
|
475 get_le32(pb); /* YPelsPerMeter */ |
78bec272ce3a
read BITMAPINFOHEADER extra stuff (huffyuv decoding fixed)
michaelni
parents:
73
diff
changeset
|
476 get_le32(pb); /* ClrUsed */ |
78bec272ce3a
read BITMAPINFOHEADER extra stuff (huffyuv decoding fixed)
michaelni
parents:
73
diff
changeset
|
477 get_le32(pb); /* ClrImportant */ |
78bec272ce3a
read BITMAPINFOHEADER extra stuff (huffyuv decoding fixed)
michaelni
parents:
73
diff
changeset
|
478 |
2315 | 479 if (tag1 == MKTAG('D', 'X', 'S', 'B')) { |
480 st->codec->codec_type = CODEC_TYPE_SUBTITLE; | |
481 st->codec->codec_tag = tag1; | |
482 st->codec->codec_id = CODEC_ID_XSUB; | |
483 break; | |
484 } | |
485 | |
1441
ad3b03b7b142
reindentation, patch by From: Steve Lhomme, slhomme divxcorp com
diego
parents:
1415
diff
changeset
|
486 if(size > 10*4 && size<(1<<30)){ |
ad3b03b7b142
reindentation, patch by From: Steve Lhomme, slhomme divxcorp com
diego
parents:
1415
diff
changeset
|
487 st->codec->extradata_size= size - 10*4; |
ad3b03b7b142
reindentation, patch by From: Steve Lhomme, slhomme divxcorp com
diego
parents:
1415
diff
changeset
|
488 st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE); |
5088
5da0e7ccc3c4
Check for failed extradata malloc, fixes a crash in out-of-memory conditions
reimar
parents:
5087
diff
changeset
|
489 if (!st->codec->extradata) { |
5da0e7ccc3c4
Check for failed extradata malloc, fixes a crash in out-of-memory conditions
reimar
parents:
5087
diff
changeset
|
490 st->codec->extradata_size= 0; |
5da0e7ccc3c4
Check for failed extradata malloc, fixes a crash in out-of-memory conditions
reimar
parents:
5087
diff
changeset
|
491 return AVERROR(ENOMEM); |
5da0e7ccc3c4
Check for failed extradata malloc, fixes a crash in out-of-memory conditions
reimar
parents:
5087
diff
changeset
|
492 } |
1441
ad3b03b7b142
reindentation, patch by From: Steve Lhomme, slhomme divxcorp com
diego
parents:
1415
diff
changeset
|
493 get_buffer(pb, st->codec->extradata, st->codec->extradata_size); |
ad3b03b7b142
reindentation, patch by From: Steve Lhomme, slhomme divxcorp com
diego
parents:
1415
diff
changeset
|
494 } |
885 | 495 |
820
feca73904e67
changing AVCodecContext codec -> *codec in AVStream so additions to AVCodecContext dont randomize AVStream and break binary compatibility
michael
parents:
775
diff
changeset
|
496 if(st->codec->extradata_size & 1) //FIXME check if the encoder really did this correctly |
76 | 497 get_byte(pb); |
75
78bec272ce3a
read BITMAPINFOHEADER extra stuff (huffyuv decoding fixed)
michaelni
parents:
73
diff
changeset
|
498 |
3538 | 499 /* Extract palette from extradata if bpp <= 8. */ |
500 /* This code assumes that extradata contains only palette. */ | |
501 /* This is true for all paletted codecs implemented in FFmpeg. */ | |
3908
1d3d17de20ba
Bump Major version, this commit is almost just renaming bits_per_sample to
michael
parents:
3759
diff
changeset
|
502 if (st->codec->extradata_size && (st->codec->bits_per_coded_sample <= 8)) { |
820
feca73904e67
changing AVCodecContext codec -> *codec in AVStream so additions to AVCodecContext dont randomize AVStream and break binary compatibility
michael
parents:
775
diff
changeset
|
503 st->codec->palctrl = av_mallocz(sizeof(AVPaletteControl)); |
5108 | 504 #if HAVE_BIGENDIAN |
820
feca73904e67
changing AVCodecContext codec -> *codec in AVStream so additions to AVCodecContext dont randomize AVStream and break binary compatibility
michael
parents:
775
diff
changeset
|
505 for (i = 0; i < FFMIN(st->codec->extradata_size, AVPALETTE_SIZE)/4; i++) |
feca73904e67
changing AVCodecContext codec -> *codec in AVStream so additions to AVCodecContext dont randomize AVStream and break binary compatibility
michael
parents:
775
diff
changeset
|
506 st->codec->palctrl->palette[i] = bswap_32(((uint32_t*)st->codec->extradata)[i]); |
297
85d558a18134
Make avi and asf demuxer export palette in palctrl
rtognimp
parents:
296
diff
changeset
|
507 #else |
820
feca73904e67
changing AVCodecContext codec -> *codec in AVStream so additions to AVCodecContext dont randomize AVStream and break binary compatibility
michael
parents:
775
diff
changeset
|
508 memcpy(st->codec->palctrl->palette, st->codec->extradata, |
feca73904e67
changing AVCodecContext codec -> *codec in AVStream so additions to AVCodecContext dont randomize AVStream and break binary compatibility
michael
parents:
775
diff
changeset
|
509 FFMIN(st->codec->extradata_size, AVPALETTE_SIZE)); |
297
85d558a18134
Make avi and asf demuxer export palette in palctrl
rtognimp
parents:
296
diff
changeset
|
510 #endif |
820
feca73904e67
changing AVCodecContext codec -> *codec in AVStream so additions to AVCodecContext dont randomize AVStream and break binary compatibility
michael
parents:
775
diff
changeset
|
511 st->codec->palctrl->palette_changed = 1; |
297
85d558a18134
Make avi and asf demuxer export palette in palctrl
rtognimp
parents:
296
diff
changeset
|
512 } |
85d558a18134
Make avi and asf demuxer export palette in palctrl
rtognimp
parents:
296
diff
changeset
|
513 |
0 | 514 #ifdef DEBUG |
515 print_tag("video", tag1, 0); | |
516 #endif | |
820
feca73904e67
changing AVCodecContext codec -> *codec in AVStream so additions to AVCodecContext dont randomize AVStream and break binary compatibility
michael
parents:
775
diff
changeset
|
517 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:
775
diff
changeset
|
518 st->codec->codec_tag = tag1; |
5058
33a244b7ca65
Add ff_ prefixes to exported symbols in libavformat/riff.h.
diego
parents:
4957
diff
changeset
|
519 st->codec->codec_id = ff_codec_get_id(ff_codec_bmp_tags, tag1); |
3538 | 520 st->need_parsing = AVSTREAM_PARSE_HEADERS; // This is needed to get the pict type which is necessary for generating correct pts. |
5522
7698da6e1f0a
Support uncompressed ("Resolution 1:1") Avid AVI Codec, (partially) fixes issue 1474.
cehoyos
parents:
5446
diff
changeset
|
521 // Support "Resolution 1:1" for Avid AVI Codec |
7698da6e1f0a
Support uncompressed ("Resolution 1:1") Avid AVI Codec, (partially) fixes issue 1474.
cehoyos
parents:
5446
diff
changeset
|
522 if(tag1 == MKTAG('A', 'V', 'R', 'n') && |
7698da6e1f0a
Support uncompressed ("Resolution 1:1") Avid AVI Codec, (partially) fixes issue 1474.
cehoyos
parents:
5446
diff
changeset
|
523 st->codec->extradata_size >= 31 && |
7698da6e1f0a
Support uncompressed ("Resolution 1:1") Avid AVI Codec, (partially) fixes issue 1474.
cehoyos
parents:
5446
diff
changeset
|
524 !memcmp(&st->codec->extradata[28], "1:1", 3)) |
7698da6e1f0a
Support uncompressed ("Resolution 1:1") Avid AVI Codec, (partially) fixes issue 1474.
cehoyos
parents:
5446
diff
changeset
|
525 st->codec->codec_id = CODEC_ID_RAWVIDEO; |
4550
a36f9f2eefcb
Fix raw rgb/bgr vertical flip in avi based on info from http://www.fourcc.org/fccbihgt.php.
michael
parents:
4541
diff
changeset
|
526 |
a36f9f2eefcb
Fix raw rgb/bgr vertical flip in avi based on info from http://www.fourcc.org/fccbihgt.php.
michael
parents:
4541
diff
changeset
|
527 if(st->codec->codec_tag==0 && st->codec->height > 0 && st->codec->extradata_size < 1U<<30){ |
a36f9f2eefcb
Fix raw rgb/bgr vertical flip in avi based on info from http://www.fourcc.org/fccbihgt.php.
michael
parents:
4541
diff
changeset
|
528 st->codec->extradata_size+= 9; |
a36f9f2eefcb
Fix raw rgb/bgr vertical flip in avi based on info from http://www.fourcc.org/fccbihgt.php.
michael
parents:
4541
diff
changeset
|
529 st->codec->extradata= av_realloc(st->codec->extradata, st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE); |
a36f9f2eefcb
Fix raw rgb/bgr vertical flip in avi based on info from http://www.fourcc.org/fccbihgt.php.
michael
parents:
4541
diff
changeset
|
530 if(st->codec->extradata) |
a36f9f2eefcb
Fix raw rgb/bgr vertical flip in avi based on info from http://www.fourcc.org/fccbihgt.php.
michael
parents:
4541
diff
changeset
|
531 memcpy(st->codec->extradata + st->codec->extradata_size - 9, "BottomUp", 9); |
a36f9f2eefcb
Fix raw rgb/bgr vertical flip in avi based on info from http://www.fourcc.org/fccbihgt.php.
michael
parents:
4541
diff
changeset
|
532 } |
a36f9f2eefcb
Fix raw rgb/bgr vertical flip in avi based on info from http://www.fourcc.org/fccbihgt.php.
michael
parents:
4541
diff
changeset
|
533 st->codec->height= FFABS(st->codec->height); |
a36f9f2eefcb
Fix raw rgb/bgr vertical flip in avi based on info from http://www.fourcc.org/fccbihgt.php.
michael
parents:
4541
diff
changeset
|
534 |
75
78bec272ce3a
read BITMAPINFOHEADER extra stuff (huffyuv decoding fixed)
michaelni
parents:
73
diff
changeset
|
535 // url_fskip(pb, size - 5 * 4); |
0 | 536 break; |
73
d40ddc73858a
reversing not yet reversed changes from r1.7 -> r1.8 except the static/const stuff
michaelni
parents:
65
diff
changeset
|
537 case CODEC_TYPE_AUDIO: |
5058
33a244b7ca65
Add ff_ prefixes to exported symbols in libavformat/riff.h.
diego
parents:
4957
diff
changeset
|
538 ff_get_wav_header(pb, st->codec, size); |
3105 | 539 if(ast->sample_size && st->codec->block_align && ast->sample_size != st->codec->block_align){ |
3104 | 540 av_log(s, AV_LOG_WARNING, "sample size (%d) != block align (%d)\n", ast->sample_size, st->codec->block_align); |
3105 | 541 ast->sample_size= st->codec->block_align; |
542 } | |
13
8a5285a0ca2f
Fix for odd strf tag in Stargate SG-1 - 3x18 - Shades of Grey.avi
mmu_man
parents:
5
diff
changeset
|
543 if (size%2) /* 2-aligned (fix for Stargate SG-1 - 3x18 - Shades of Grey.avi) */ |
8a5285a0ca2f
Fix for odd strf tag in Stargate SG-1 - 3x18 - Shades of Grey.avi
mmu_man
parents:
5
diff
changeset
|
544 url_fskip(pb, 1); |
1527 | 545 /* Force parsing as several audio frames can be in |
3538 | 546 * one packet and timestamps refer to packet start. */ |
2020 | 547 st->need_parsing = AVSTREAM_PARSE_TIMESTAMPS; |
3538 | 548 /* ADTS header is in extradata, AAC without header must be |
549 * stored as exact frames. Parser not needed and it will | |
550 * fail. */ | |
1472
49d5a5ca2987
get rid of CODEC_ID_MPEG4AAC after next version bump, and change it to CODEC_ID_AAC where used
bcoudurier
parents:
1443
diff
changeset
|
551 if (st->codec->codec_id == CODEC_ID_AAC && st->codec->extradata_size) |
2023 | 552 st->need_parsing = AVSTREAM_PARSE_NONE; |
1526
135565ec768d
Clean up XAN DPCM hack and set codec_tag to 0 for XAN DPCM, AVI files
diego
parents:
1522
diff
changeset
|
553 /* AVI files with Xan DPCM audio (wrongly) declare PCM |
135565ec768d
Clean up XAN DPCM hack and set codec_tag to 0 for XAN DPCM, AVI files
diego
parents:
1522
diff
changeset
|
554 * audio in the header but have Axan as stream_code_tag. */ |
4243 | 555 if (st->codec->stream_codec_tag == AV_RL32("Axan")){ |
1526
135565ec768d
Clean up XAN DPCM hack and set codec_tag to 0 for XAN DPCM, AVI files
diego
parents:
1522
diff
changeset
|
556 st->codec->codec_id = CODEC_ID_XAN_DPCM; |
135565ec768d
Clean up XAN DPCM hack and set codec_tag to 0 for XAN DPCM, AVI files
diego
parents:
1522
diff
changeset
|
557 st->codec->codec_tag = 0; |
135565ec768d
Clean up XAN DPCM hack and set codec_tag to 0 for XAN DPCM, AVI files
diego
parents:
1522
diff
changeset
|
558 } |
2584 | 559 if (amv_file_format) |
560 st->codec->codec_id = CODEC_ID_ADPCM_IMA_AMV; | |
0 | 561 break; |
562 default: | |
820
feca73904e67
changing AVCodecContext codec -> *codec in AVStream so additions to AVCodecContext dont randomize AVStream and break binary compatibility
michael
parents:
775
diff
changeset
|
563 st->codec->codec_type = CODEC_TYPE_DATA; |
feca73904e67
changing AVCodecContext codec -> *codec in AVStream so additions to AVCodecContext dont randomize AVStream and break binary compatibility
michael
parents:
775
diff
changeset
|
564 st->codec->codec_id= CODEC_ID_NONE; |
feca73904e67
changing AVCodecContext codec -> *codec in AVStream so additions to AVCodecContext dont randomize AVStream and break binary compatibility
michael
parents:
775
diff
changeset
|
565 st->codec->codec_tag= 0; |
0 | 566 url_fskip(pb, size); |
567 break; | |
568 } | |
569 } | |
570 break; | |
977 | 571 case MKTAG('i', 'n', 'd', 'x'): |
572 i= url_ftell(pb); | |
1294
12398b868e18
ignore index parameter to ignore the ODML index in avi
michael
parents:
1286
diff
changeset
|
573 if(!url_is_streamed(pb) && !(s->flags & AVFMT_FLAG_IGNIDX)){ |
1115 | 574 read_braindead_odml_indx(s, 0); |
575 } | |
977 | 576 url_fseek(pb, i+size, SEEK_SET); |
577 break; | |
2877 | 578 case MKTAG('v', 'p', 'r', 'p'): |
579 if(stream_index < (unsigned)s->nb_streams && size > 9*4){ | |
580 AVRational active, active_aspect; | |
581 | |
582 st = s->streams[stream_index]; | |
583 get_le32(pb); | |
584 get_le32(pb); | |
585 get_le32(pb); | |
586 get_le32(pb); | |
587 get_le32(pb); | |
588 | |
3177 | 589 active_aspect.den= get_le16(pb); |
2877 | 590 active_aspect.num= get_le16(pb); |
591 active.num = get_le32(pb); | |
592 active.den = get_le32(pb); | |
593 get_le32(pb); //nbFieldsPerFrame | |
594 | |
595 if(active_aspect.num && active_aspect.den && active.num && active.den){ | |
3759
27537074f2a9
convert every muxer/demuxer to write/read sample_aspect_ratio from/to
aurel
parents:
3610
diff
changeset
|
596 st->sample_aspect_ratio= av_div_q(active_aspect, active); |
2877 | 597 //av_log(s, AV_LOG_ERROR, "vprp %d/%d %d/%d\n", active_aspect.num, active_aspect.den, active.num, active.den); |
598 } | |
599 size -= 9*4; | |
600 } | |
601 url_fseek(pb, size, SEEK_CUR); | |
602 break; | |
1256 | 603 case MKTAG('I', 'N', 'A', 'M'): |
4149 | 604 avi_read_tag(s, "Title", size); |
1256 | 605 break; |
606 case MKTAG('I', 'A', 'R', 'T'): | |
4149 | 607 avi_read_tag(s, "Artist", size); |
1256 | 608 break; |
609 case MKTAG('I', 'C', 'O', 'P'): | |
4149 | 610 avi_read_tag(s, "Copyright", size); |
1256 | 611 break; |
612 case MKTAG('I', 'C', 'M', 'T'): | |
4149 | 613 avi_read_tag(s, "Comment", size); |
1256 | 614 break; |
615 case MKTAG('I', 'G', 'N', 'R'): | |
4149 | 616 avi_read_tag(s, "Genre", size); |
1256 | 617 break; |
1296 | 618 case MKTAG('I', 'P', 'R', 'D'): |
4149 | 619 avi_read_tag(s, "Album", size); |
1296 | 620 break; |
1298
29fba975df47
Allow to get the the track number in the IPRT (part) tag in AVI.
gpoirier
parents:
1296
diff
changeset
|
621 case MKTAG('I', 'P', 'R', 'T'): |
4149 | 622 avi_read_tag(s, "Track", size); |
1298
29fba975df47
Allow to get the the track number in the IPRT (part) tag in AVI.
gpoirier
parents:
1296
diff
changeset
|
623 break; |
0 | 624 default: |
1894 | 625 if(size > 1000000){ |
3538 | 626 av_log(s, AV_LOG_ERROR, "Something went wrong during header parsing, " |
627 "I will ignore it and try to continue anyway.\n"); | |
1894 | 628 avi->movi_list = url_ftell(pb) - 4; |
629 avi->movi_end = url_fsize(pb); | |
630 goto end_of_header; | |
631 } | |
0 | 632 /* skip tag */ |
633 size += (size & 1); | |
634 url_fskip(pb, size); | |
635 break; | |
636 } | |
637 } | |
638 end_of_header: | |
639 /* check stream number */ | |
640 if (stream_index != s->nb_streams - 1) { | |
641 fail: | |
642 return -1; | |
643 } | |
644 | |
1115 | 645 if(!avi->index_loaded && !url_is_streamed(pb)) |
977 | 646 avi_load_index(s); |
469
6a4cc19e8d9b
exporting keyframe flags, fixes keyframe stuff with streamcopy
michael
parents:
466
diff
changeset
|
647 avi->index_loaded = 1; |
979 | 648 avi->non_interleaved |= guess_ni_flag(s); |
3383 | 649 if(avi->non_interleaved) { |
3538 | 650 av_log(s, AV_LOG_INFO, "non-interleaved AVI\n"); |
983
558381bf97d2
support seeking in RenderAvi.avi (audio stream == single huge chunk)
michael
parents:
982
diff
changeset
|
651 clean_index(s); |
3383 | 652 } |
885 | 653 |
0 | 654 return 0; |
655 } | |
656 | |
3983 | 657 static int get_stream_idx(int *d){ |
658 if( d[0] >= '0' && d[0] <= '9' | |
659 && d[1] >= '0' && d[1] <= '9'){ | |
660 return (d[0] - '0') * 10 + (d[1] - '0'); | |
661 }else{ | |
662 return 100; //invalid stream ID | |
663 } | |
664 } | |
665 | |
0 | 666 static int avi_read_packet(AVFormatContext *s, AVPacket *pkt) |
667 { | |
668 AVIContext *avi = s->priv_data; | |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2584
diff
changeset
|
669 ByteIOContext *pb = s->pb; |
4552
da2be12b7b4b
Handle chunks with the MSB in size set correctly that is unsigned.
michael
parents:
4550
diff
changeset
|
670 int n, d[8]; |
da2be12b7b4b
Handle chunks with the MSB in size set correctly that is unsigned.
michael
parents:
4550
diff
changeset
|
671 unsigned int size; |
3973
549a09cf23fe
Remove offset_t typedef and use int64_t directly instead.
diego
parents:
3908
diff
changeset
|
672 int64_t i, sync; |
262
f174d9c00bce
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
227
diff
changeset
|
673 void* dstr; |
885 | 674 |
4210
ec95366371ba
replace all occurrence of ENABLE_ by the corresponding CONFIG_, HAVE_ or ARCH_
aurel
parents:
4203
diff
changeset
|
675 if (CONFIG_DV_DEMUXER && avi->dv_demux) { |
4552
da2be12b7b4b
Handle chunks with the MSB in size set correctly that is unsigned.
michael
parents:
4550
diff
changeset
|
676 int size = dv_get_packet(avi->dv_demux, pkt); |
887 | 677 if (size >= 0) |
678 return size; | |
149 | 679 } |
885 | 680 |
701 | 681 if(avi->non_interleaved){ |
851
62e66722e9bb
Kill some compiler warnings. Compiled code verified identical after changes.
mru
parents:
842
diff
changeset
|
682 int best_stream_index = 0; |
701 | 683 AVStream *best_st= NULL; |
684 AVIStream *best_ast; | |
685 int64_t best_ts= INT64_MAX; | |
686 int i; | |
885 | 687 |
701 | 688 for(i=0; i<s->nb_streams; i++){ |
689 AVStream *st = s->streams[i]; | |
690 AVIStream *ast = st->priv_data; | |
691 int64_t ts= ast->frame_offset; | |
5167
00fcfe0596e8
Fix a bug with reading non-interleaved AVI if one the streams is
cehoyos
parents:
5166
diff
changeset
|
692 int64_t last_ts; |
569 | 693 |
5166 | 694 if(!st->nb_index_entries) |
695 continue; | |
696 | |
5167
00fcfe0596e8
Fix a bug with reading non-interleaved AVI if one the streams is
cehoyos
parents:
5166
diff
changeset
|
697 last_ts = st->index_entries[st->nb_index_entries - 1].timestamp; |
00fcfe0596e8
Fix a bug with reading non-interleaved AVI if one the streams is
cehoyos
parents:
5166
diff
changeset
|
698 if(!ast->remaining && ts > last_ts) |
00fcfe0596e8
Fix a bug with reading non-interleaved AVI if one the streams is
cehoyos
parents:
5166
diff
changeset
|
699 continue; |
00fcfe0596e8
Fix a bug with reading non-interleaved AVI if one the streams is
cehoyos
parents:
5166
diff
changeset
|
700 |
5326
4e1e9ab777a1
Support non interleaved avi files that have 0<size<sample_size.
michael
parents:
5243
diff
changeset
|
701 ts = av_rescale_q(ts, st->time_base, (AVRational){FFMAX(1, ast->sample_size), AV_TIME_BASE}); |
701 | 702 |
4515
1d9ace1dec78
Add a context to av_log() calls and modify a function prototype to allow it.
benoit
parents:
4353
diff
changeset
|
703 // av_log(s, AV_LOG_DEBUG, "%"PRId64" %d/%d %"PRId64"\n", ts, st->time_base.num, st->time_base.den, ast->frame_offset); |
5166 | 704 if(ts < best_ts){ |
701 | 705 best_ts= ts; |
706 best_st= st; | |
707 best_stream_index= i; | |
708 } | |
709 } | |
3384 | 710 if(!best_st) |
711 return -1; | |
712 | |
701 | 713 best_ast = best_st->priv_data; |
5326
4e1e9ab777a1
Support non interleaved avi files that have 0<size<sample_size.
michael
parents:
5243
diff
changeset
|
714 best_ts = av_rescale_q(best_ts, (AVRational){FFMAX(1, best_ast->sample_size), AV_TIME_BASE}, best_st->time_base); |
701 | 715 if(best_ast->remaining) |
716 i= av_index_search_timestamp(best_st, best_ts, AVSEEK_FLAG_ANY | AVSEEK_FLAG_BACKWARD); | |
4104 | 717 else{ |
701 | 718 i= av_index_search_timestamp(best_st, best_ts, AVSEEK_FLAG_ANY); |
4104 | 719 if(i>=0) |
5326
4e1e9ab777a1
Support non interleaved avi files that have 0<size<sample_size.
michael
parents:
5243
diff
changeset
|
720 best_ast->frame_offset= best_st->index_entries[i].timestamp; |
4104 | 721 } |
701 | 722 |
4515
1d9ace1dec78
Add a context to av_log() calls and modify a function prototype to allow it.
benoit
parents:
4353
diff
changeset
|
723 // av_log(s, AV_LOG_DEBUG, "%d\n", i); |
701 | 724 if(i>=0){ |
725 int64_t pos= best_st->index_entries[i].pos; | |
980 | 726 pos += best_ast->packet_size - best_ast->remaining; |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2584
diff
changeset
|
727 url_fseek(s->pb, pos + 8, SEEK_SET); |
4515
1d9ace1dec78
Add a context to av_log() calls and modify a function prototype to allow it.
benoit
parents:
4353
diff
changeset
|
728 // av_log(s, AV_LOG_DEBUG, "pos=%"PRId64"\n", pos); |
885 | 729 |
982 | 730 assert(best_ast->remaining <= best_ast->packet_size); |
731 | |
981
55519fa957c3
fix demuxing of XviD_with_3_AAC-HE_audio_streams.avi
michael
parents:
980
diff
changeset
|
732 avi->stream_index= best_stream_index; |
55519fa957c3
fix demuxing of XviD_with_3_AAC-HE_audio_streams.avi
michael
parents:
980
diff
changeset
|
733 if(!best_ast->remaining) |
982 | 734 best_ast->packet_size= |
981
55519fa957c3
fix demuxing of XviD_with_3_AAC-HE_audio_streams.avi
michael
parents:
980
diff
changeset
|
735 best_ast->remaining= best_st->index_entries[i].size; |
701 | 736 } |
737 } | |
885 | 738 |
569 | 739 resync: |
701 | 740 if(avi->stream_index >= 0){ |
741 AVStream *st= s->streams[ avi->stream_index ]; | |
742 AVIStream *ast= st->priv_data; | |
4555 | 743 int size, err; |
885 | 744 |
988 | 745 if(ast->sample_size <= 1) // minorityreport.AVI block_align=1024 sample_size=1 IMA-ADPCM |
701 | 746 size= INT_MAX; |
885 | 747 else if(ast->sample_size < 32) |
701 | 748 size= 64*ast->sample_size; |
749 else | |
750 size= ast->sample_size; | |
751 | |
752 if(size > ast->remaining) | |
753 size= ast->remaining; | |
3984 | 754 avi->last_pkt_pos= url_ftell(pb); |
4555 | 755 err= av_get_packet(pb, pkt, size); |
756 if(err<0) | |
757 return err; | |
885 | 758 |
3157
27c5bc69a1f9
One non functional AVPalette chunk less, one heap overflow less.
michael
parents:
3105
diff
changeset
|
759 if(ast->has_pal && pkt->data && pkt->size<(unsigned)INT_MAX/2){ |
4555 | 760 void *ptr= av_realloc(pkt->data, pkt->size + 4*256 + FF_INPUT_BUFFER_PADDING_SIZE); |
761 if(ptr){ | |
3157
27c5bc69a1f9
One non functional AVPalette chunk less, one heap overflow less.
michael
parents:
3105
diff
changeset
|
762 ast->has_pal=0; |
27c5bc69a1f9
One non functional AVPalette chunk less, one heap overflow less.
michael
parents:
3105
diff
changeset
|
763 pkt->size += 4*256; |
4555 | 764 pkt->data= ptr; |
3157
27c5bc69a1f9
One non functional AVPalette chunk less, one heap overflow less.
michael
parents:
3105
diff
changeset
|
765 memcpy(pkt->data + pkt->size - 4*256, ast->pal, 4*256); |
4555 | 766 }else |
767 av_log(s, AV_LOG_ERROR, "Failed to append palette\n"); | |
3157
27c5bc69a1f9
One non functional AVPalette chunk less, one heap overflow less.
michael
parents:
3105
diff
changeset
|
768 } |
27c5bc69a1f9
One non functional AVPalette chunk less, one heap overflow less.
michael
parents:
3105
diff
changeset
|
769 |
4210
ec95366371ba
replace all occurrence of ENABLE_ by the corresponding CONFIG_, HAVE_ or ARCH_
aurel
parents:
4203
diff
changeset
|
770 if (CONFIG_DV_DEMUXER && avi->dv_demux) { |
701 | 771 dstr = pkt->destruct; |
772 size = dv_produce_packet(avi->dv_demux, pkt, | |
773 pkt->data, pkt->size); | |
774 pkt->destruct = dstr; | |
775 pkt->flags |= PKT_FLAG_KEY; | |
776 } else { | |
3538 | 777 /* XXX: How to handle B-frames in AVI? */ |
701 | 778 pkt->dts = ast->frame_offset; |
779 // pkt->dts += ast->start; | |
780 if(ast->sample_size) | |
781 pkt->dts /= ast->sample_size; | |
4515
1d9ace1dec78
Add a context to av_log() calls and modify a function prototype to allow it.
benoit
parents:
4353
diff
changeset
|
782 //av_log(s, AV_LOG_DEBUG, "dts:%"PRId64" offset:%"PRId64" %d/%d smpl_siz:%d base:%d st:%d size:%d\n", pkt->dts, ast->frame_offset, ast->scale, ast->rate, ast->sample_size, AV_TIME_BASE, avi->stream_index, size); |
701 | 783 pkt->stream_index = avi->stream_index; |
784 | |
820
feca73904e67
changing AVCodecContext codec -> *codec in AVStream so additions to AVCodecContext dont randomize AVStream and break binary compatibility
michael
parents:
775
diff
changeset
|
785 if (st->codec->codec_type == CODEC_TYPE_VIDEO) { |
1758 | 786 AVIndexEntry *e; |
787 int index; | |
1757
9d217a18aa49
dynamic index building so forward and backward seeking in avi without an index is possible
michael
parents:
1721
diff
changeset
|
788 assert(st->index_entries); |
701 | 789 |
5326
4e1e9ab777a1
Support non interleaved avi files that have 0<size<sample_size.
michael
parents:
5243
diff
changeset
|
790 index= av_index_search_timestamp(st, ast->frame_offset, 0); |
1758 | 791 e= &st->index_entries[index]; |
885 | 792 |
1758 | 793 if(index >= 0 && e->timestamp == ast->frame_offset){ |
794 if (e->flags & AVINDEX_KEYFRAME) | |
795 pkt->flags |= PKT_FLAG_KEY; | |
796 } | |
701 | 797 } else { |
885 | 798 pkt->flags |= PKT_FLAG_KEY; |
701 | 799 } |
800 if(ast->sample_size) | |
801 ast->frame_offset += pkt->size; | |
802 else | |
803 ast->frame_offset++; | |
804 } | |
805 ast->remaining -= size; | |
806 if(!ast->remaining){ | |
807 avi->stream_index= -1; | |
808 ast->packet_size= 0; | |
809 } | |
810 | |
811 return size; | |
812 } | |
813 | |
569 | 814 memset(d, -1, sizeof(int)*8); |
815 for(i=sync=url_ftell(pb); !url_feof(pb); i++) { | |
82 | 816 int j; |
817 | |
818 for(j=0; j<7; j++) | |
819 d[j]= d[j+1]; | |
820 d[7]= get_byte(pb); | |
885 | 821 |
82 | 822 size= d[4] + (d[5]<<8) + (d[6]<<16) + (d[7]<<24); |
885 | 823 |
3983 | 824 n= get_stream_idx(d+2); |
4515
1d9ace1dec78
Add a context to av_log() calls and modify a function prototype to allow it.
benoit
parents:
4353
diff
changeset
|
825 //av_log(s, AV_LOG_DEBUG, "%X %X %X %X %X %X %X %X %"PRId64" %d %d\n", d[0], d[1], d[2], d[3], d[4], d[5], d[6], d[7], i, size, n); |
4552
da2be12b7b4b
Handle chunks with the MSB in size set correctly that is unsigned.
michael
parents:
4550
diff
changeset
|
826 if(i + (uint64_t)size > avi->fsize || d[0]<0) |
519 | 827 continue; |
885 | 828 |
82 | 829 //parse ix## |
519 | 830 if( (d[0] == 'i' && d[1] == 'x' && n < s->nb_streams) |
887 | 831 //parse JUNK |
2384 | 832 ||(d[0] == 'J' && d[1] == 'U' && d[2] == 'N' && d[3] == 'K') |
833 ||(d[0] == 'i' && d[1] == 'd' && d[2] == 'x' && d[3] == '1')){ | |
82 | 834 url_fskip(pb, size); |
4515
1d9ace1dec78
Add a context to av_log() calls and modify a function prototype to allow it.
benoit
parents:
4353
diff
changeset
|
835 //av_log(s, AV_LOG_DEBUG, "SKIP\n"); |
569 | 836 goto resync; |
82 | 837 } |
510 | 838 |
5243 | 839 //parse stray LIST |
840 if(d[0] == 'L' && d[1] == 'I' && d[2] == 'S' && d[3] == 'T'){ | |
841 url_fskip(pb, 4); | |
842 goto resync; | |
843 } | |
844 | |
3983 | 845 n= get_stream_idx(d); |
885 | 846 |
3984 | 847 if(!((i-avi->last_pkt_pos)&1) && get_stream_idx(d+1) < s->nb_streams) |
848 continue; | |
849 | |
5146
b0706c2efb78
Do not read index chunks as audio/video data; closes issue 1336.
diego
parents:
5131
diff
changeset
|
850 //detect ##ix chunk and skip |
b0706c2efb78
Do not read index chunks as audio/video data; closes issue 1336.
diego
parents:
5131
diff
changeset
|
851 if(d[2] == 'i' && d[3] == 'x' && n < s->nb_streams){ |
b0706c2efb78
Do not read index chunks as audio/video data; closes issue 1336.
diego
parents:
5131
diff
changeset
|
852 url_fskip(pb, size); |
b0706c2efb78
Do not read index chunks as audio/video data; closes issue 1336.
diego
parents:
5131
diff
changeset
|
853 goto resync; |
b0706c2efb78
Do not read index chunks as audio/video data; closes issue 1336.
diego
parents:
5131
diff
changeset
|
854 } |
b0706c2efb78
Do not read index chunks as audio/video data; closes issue 1336.
diego
parents:
5131
diff
changeset
|
855 |
82 | 856 //parse ##dc/##wb |
705 | 857 if(n < s->nb_streams){ |
3185 | 858 AVStream *st; |
859 AVIStream *ast; | |
860 st = s->streams[n]; | |
861 ast = st->priv_data; | |
3183 | 862 |
3184
de03f6b32914
1000l to myself, dereferencing uninitalized pointer.
michael
parents:
3183
diff
changeset
|
863 if(s->nb_streams>=2){ |
de03f6b32914
1000l to myself, dereferencing uninitalized pointer.
michael
parents:
3183
diff
changeset
|
864 AVStream *st1 = s->streams[1]; |
de03f6b32914
1000l to myself, dereferencing uninitalized pointer.
michael
parents:
3183
diff
changeset
|
865 AVIStream *ast1= st1->priv_data; |
3185 | 866 //workaround for broken small-file-bug402.avi |
867 if( d[2] == 'w' && d[3] == 'b' | |
868 && n==0 | |
869 && st ->codec->codec_type == CODEC_TYPE_VIDEO | |
870 && st1->codec->codec_type == CODEC_TYPE_AUDIO | |
871 && ast->prefix == 'd'*256+'c' | |
872 && (d[2]*256+d[3] == ast1->prefix || !ast1->prefix_count) | |
873 ){ | |
874 n=1; | |
875 st = st1; | |
876 ast = ast1; | |
3538 | 877 av_log(s, AV_LOG_WARNING, "Invalid stream + prefix combination, assuming audio.\n"); |
3185 | 878 } |
3184
de03f6b32914
1000l to myself, dereferencing uninitalized pointer.
michael
parents:
3183
diff
changeset
|
879 } |
3183 | 880 |
881 | |
3185 | 882 if( (st->discard >= AVDISCARD_DEFAULT && size==0) |
883 /*|| (st->discard >= AVDISCARD_NONKEY && !(pkt->flags & PKT_FLAG_KEY))*/ //FIXME needs a little reordering | |
884 || st->discard >= AVDISCARD_ALL){ | |
708 | 885 if(ast->sample_size) ast->frame_offset += pkt->size; |
886 else ast->frame_offset++; | |
650 | 887 url_fskip(pb, size); |
888 goto resync; | |
3185 | 889 } |
519 | 890 |
3185 | 891 if (d[2] == 'p' && d[3] == 'c' && size<=4*256+4) { |
3157
27c5bc69a1f9
One non functional AVPalette chunk less, one heap overflow less.
michael
parents:
3105
diff
changeset
|
892 int k = get_byte(pb); |
27c5bc69a1f9
One non functional AVPalette chunk less, one heap overflow less.
michael
parents:
3105
diff
changeset
|
893 int last = (k + get_byte(pb) - 1) & 0xFF; |
27c5bc69a1f9
One non functional AVPalette chunk less, one heap overflow less.
michael
parents:
3105
diff
changeset
|
894 |
27c5bc69a1f9
One non functional AVPalette chunk less, one heap overflow less.
michael
parents:
3105
diff
changeset
|
895 get_le16(pb); //flags |
27c5bc69a1f9
One non functional AVPalette chunk less, one heap overflow less.
michael
parents:
3105
diff
changeset
|
896 |
27c5bc69a1f9
One non functional AVPalette chunk less, one heap overflow less.
michael
parents:
3105
diff
changeset
|
897 for (; k <= last; k++) |
27c5bc69a1f9
One non functional AVPalette chunk less, one heap overflow less.
michael
parents:
3105
diff
changeset
|
898 ast->pal[k] = get_be32(pb)>>8;// b + (g << 8) + (r << 16); |
27c5bc69a1f9
One non functional AVPalette chunk less, one heap overflow less.
michael
parents:
3105
diff
changeset
|
899 ast->has_pal= 1; |
27c5bc69a1f9
One non functional AVPalette chunk less, one heap overflow less.
michael
parents:
3105
diff
changeset
|
900 goto resync; |
3185 | 901 } else if( ((ast->prefix_count<5 || sync+9 > i) && d[2]<128 && d[3]<128) || |
902 d[2]*256+d[3] == ast->prefix /*|| | |
903 (d[2] == 'd' && d[3] == 'c') || | |
904 (d[2] == 'w' && d[3] == 'b')*/) { | |
519 | 905 |
4515
1d9ace1dec78
Add a context to av_log() calls and modify a function prototype to allow it.
benoit
parents:
4353
diff
changeset
|
906 //av_log(s, AV_LOG_DEBUG, "OK\n"); |
3185 | 907 if(d[2]*256+d[3] == ast->prefix) |
908 ast->prefix_count++; | |
909 else{ | |
910 ast->prefix= d[2]*256+d[3]; | |
911 ast->prefix_count= 0; | |
912 } | |
519 | 913 |
3185 | 914 avi->stream_index= n; |
915 ast->packet_size= size + 8; | |
916 ast->remaining= size; | |
1757
9d217a18aa49
dynamic index building so forward and backward seeking in avi without an index is possible
michael
parents:
1721
diff
changeset
|
917 |
5327
a8e26981c104
Fix infinite loop with size==0 && sample_size!=0 in non interleaved avis.
michael
parents:
5326
diff
changeset
|
918 if(size || !ast->sample_size){ |
3185 | 919 uint64_t pos= url_ftell(pb) - 8; |
920 if(!st->index_entries || !st->nb_index_entries || st->index_entries[st->nb_index_entries - 1].pos < pos){ | |
5326
4e1e9ab777a1
Support non interleaved avi files that have 0<size<sample_size.
michael
parents:
5243
diff
changeset
|
921 av_add_index_entry(st, pos, ast->frame_offset, size, 0, AVINDEX_KEYFRAME); |
3185 | 922 } |
1757
9d217a18aa49
dynamic index building so forward and backward seeking in avi without an index is possible
michael
parents:
1721
diff
changeset
|
923 } |
3185 | 924 goto resync; |
1757
9d217a18aa49
dynamic index building so forward and backward seeking in avi without an index is possible
michael
parents:
1721
diff
changeset
|
925 } |
82 | 926 } |
927 } | |
519 | 928 |
4541
a65e3b37f87e
AVI demuxer: return AVERROR_EOF upon detection of end of file.
pross
parents:
4516
diff
changeset
|
929 return AVERROR_EOF; |
0 | 930 } |
931 | |
3538 | 932 /* XXX: We make the implicit supposition that the positions are sorted |
933 for each stream. */ | |
311 | 934 static int avi_read_idx1(AVFormatContext *s, int size) |
935 { | |
701 | 936 AVIContext *avi = s->priv_data; |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2584
diff
changeset
|
937 ByteIOContext *pb = s->pb; |
311 | 938 int nb_index_entries, i; |
939 AVStream *st; | |
940 AVIStream *ast; | |
941 unsigned int index, tag, flags, pos, len; | |
701 | 942 unsigned last_pos= -1; |
885 | 943 |
311 | 944 nb_index_entries = size / 16; |
945 if (nb_index_entries <= 0) | |
946 return -1; | |
947 | |
3538 | 948 /* Read the entries and sort them in each stream component. */ |
311 | 949 for(i = 0; i < nb_index_entries; i++) { |
950 tag = get_le32(pb); | |
951 flags = get_le32(pb); | |
952 pos = get_le32(pb); | |
953 len = get_le32(pb); | |
700
a5e6e0e61e24
use libavformats index system instead of the half duplicated mess in avidec.c
michael
parents:
673
diff
changeset
|
954 #if defined(DEBUG_SEEK) |
4515
1d9ace1dec78
Add a context to av_log() calls and modify a function prototype to allow it.
benoit
parents:
4353
diff
changeset
|
955 av_log(s, AV_LOG_DEBUG, "%d: tag=0x%x flags=0x%x pos=0x%x len=%d/", |
311 | 956 i, tag, flags, pos, len); |
957 #endif | |
701 | 958 if(i==0 && pos > avi->movi_list) |
959 avi->movi_list= 0; //FIXME better check | |
980 | 960 pos += avi->movi_list; |
701 | 961 |
311 | 962 index = ((tag & 0xff) - '0') * 10; |
963 index += ((tag >> 8) & 0xff) - '0'; | |
964 if (index >= s->nb_streams) | |
965 continue; | |
966 st = s->streams[index]; | |
967 ast = st->priv_data; | |
885 | 968 |
700
a5e6e0e61e24
use libavformats index system instead of the half duplicated mess in avidec.c
michael
parents:
673
diff
changeset
|
969 #if defined(DEBUG_SEEK) |
4515
1d9ace1dec78
Add a context to av_log() calls and modify a function prototype to allow it.
benoit
parents:
4353
diff
changeset
|
970 av_log(s, AV_LOG_DEBUG, "%d cum_len=%"PRId64"\n", len, ast->cum_len); |
700
a5e6e0e61e24
use libavformats index system instead of the half duplicated mess in avidec.c
michael
parents:
673
diff
changeset
|
971 #endif |
4554 | 972 if(url_feof(pb)) |
973 return -1; | |
974 | |
705 | 975 if(last_pos == pos) |
976 avi->non_interleaved= 1; | |
5327
a8e26981c104
Fix infinite loop with size==0 && sample_size!=0 in non interleaved avis.
michael
parents:
5326
diff
changeset
|
977 else if(len || !ast->sample_size) |
5326
4e1e9ab777a1
Support non interleaved avi files that have 0<size<sample_size.
michael
parents:
5243
diff
changeset
|
978 av_add_index_entry(st, pos, ast->cum_len, len, 0, (flags&AVIIF_INDEX) ? AVINDEX_KEYFRAME : 0); |
701 | 979 if(ast->sample_size) |
1522
68620a6be643
fix support for avis with sample_size > packet size
michael
parents:
1489
diff
changeset
|
980 ast->cum_len += len; |
701 | 981 else |
982 ast->cum_len ++; | |
983 last_pos= pos; | |
311 | 984 } |
985 return 0; | |
986 } | |
987 | |
701 | 988 static int guess_ni_flag(AVFormatContext *s){ |
989 int i; | |
990 int64_t last_start=0; | |
991 int64_t first_end= INT64_MAX; | |
4957 | 992 int64_t oldpos= url_ftell(s->pb); |
885 | 993 |
701 | 994 for(i=0; i<s->nb_streams; i++){ |
995 AVStream *st = s->streams[i]; | |
996 int n= st->nb_index_entries; | |
4957 | 997 unsigned int size; |
701 | 998 |
999 if(n <= 0) | |
1000 continue; | |
1001 | |
4957 | 1002 if(n >= 2){ |
1003 int64_t pos= st->index_entries[0].pos; | |
1004 url_fseek(s->pb, pos + 4, SEEK_SET); | |
1005 size= get_le32(s->pb); | |
1006 if(pos + size > st->index_entries[1].pos) | |
1007 last_start= INT64_MAX; | |
1008 } | |
1009 | |
701 | 1010 if(st->index_entries[0].pos > last_start) |
1011 last_start= st->index_entries[0].pos; | |
1012 if(st->index_entries[n-1].pos < first_end) | |
1013 first_end= st->index_entries[n-1].pos; | |
1014 } | |
4957 | 1015 url_fseek(s->pb, oldpos, SEEK_SET); |
701 | 1016 return last_start > first_end; |
1017 } | |
1018 | |
311 | 1019 static int avi_load_index(AVFormatContext *s) |
1020 { | |
1021 AVIContext *avi = s->priv_data; | |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2584
diff
changeset
|
1022 ByteIOContext *pb = s->pb; |
311 | 1023 uint32_t tag, size; |
3973
549a09cf23fe
Remove offset_t typedef and use int64_t directly instead.
diego
parents:
3908
diff
changeset
|
1024 int64_t pos= url_ftell(pb); |
5149
4a53fcd622ea
Check for seek failures in avi_load_index, otherwise if the index offset
reimar
parents:
5146
diff
changeset
|
1025 int ret = -1; |
885 | 1026 |
5149
4a53fcd622ea
Check for seek failures in avi_load_index, otherwise if the index offset
reimar
parents:
5146
diff
changeset
|
1027 if (url_fseek(pb, avi->movi_end, SEEK_SET) < 0) |
4a53fcd622ea
Check for seek failures in avi_load_index, otherwise if the index offset
reimar
parents:
5146
diff
changeset
|
1028 goto the_end; // maybe truncated file |
311 | 1029 #ifdef DEBUG_SEEK |
1443
404048ea11bc
Replace most of the %lld and %llx by their (cleaner) PRI*64 counterparts.
diego
parents:
1441
diff
changeset
|
1030 printf("movi_end=0x%"PRIx64"\n", avi->movi_end); |
311 | 1031 #endif |
1032 for(;;) { | |
1033 if (url_feof(pb)) | |
1034 break; | |
1035 tag = get_le32(pb); | |
1036 size = get_le32(pb); | |
1037 #ifdef DEBUG_SEEK | |
1038 printf("tag=%c%c%c%c size=0x%x\n", | |
1039 tag & 0xff, | |
1040 (tag >> 8) & 0xff, | |
1041 (tag >> 16) & 0xff, | |
1042 (tag >> 24) & 0xff, | |
1043 size); | |
1044 #endif | |
1045 switch(tag) { | |
1046 case MKTAG('i', 'd', 'x', '1'): | |
1047 if (avi_read_idx1(s, size) < 0) | |
1048 goto skip; | |
5149
4a53fcd622ea
Check for seek failures in avi_load_index, otherwise if the index offset
reimar
parents:
5146
diff
changeset
|
1049 ret = 0; |
311 | 1050 goto the_end; |
1051 break; | |
1052 default: | |
1053 skip: | |
1054 size += (size & 1); | |
5149
4a53fcd622ea
Check for seek failures in avi_load_index, otherwise if the index offset
reimar
parents:
5146
diff
changeset
|
1055 if (url_fseek(pb, size, SEEK_CUR) < 0) |
4a53fcd622ea
Check for seek failures in avi_load_index, otherwise if the index offset
reimar
parents:
5146
diff
changeset
|
1056 goto the_end; // something is wrong here |
311 | 1057 break; |
1058 } | |
1059 } | |
1060 the_end: | |
343 | 1061 url_fseek(pb, pos, SEEK_SET); |
5149
4a53fcd622ea
Check for seek failures in avi_load_index, otherwise if the index offset
reimar
parents:
5146
diff
changeset
|
1062 return ret; |
311 | 1063 } |
1064 | |
558 | 1065 static int avi_read_seek(AVFormatContext *s, int stream_index, int64_t timestamp, int flags) |
311 | 1066 { |
1067 AVIContext *avi = s->priv_data; | |
1068 AVStream *st; | |
700
a5e6e0e61e24
use libavformats index system instead of the half duplicated mess in avidec.c
michael
parents:
673
diff
changeset
|
1069 int i, index; |
311 | 1070 int64_t pos; |
5326
4e1e9ab777a1
Support non interleaved avi files that have 0<size<sample_size.
michael
parents:
5243
diff
changeset
|
1071 AVIStream *ast; |
311 | 1072 |
1073 if (!avi->index_loaded) { | |
1074 /* we only load the index on demand */ | |
1075 avi_load_index(s); | |
1076 avi->index_loaded = 1; | |
1077 } | |
700
a5e6e0e61e24
use libavformats index system instead of the half duplicated mess in avidec.c
michael
parents:
673
diff
changeset
|
1078 assert(stream_index>= 0); |
311 | 1079 |
1080 st = s->streams[stream_index]; | |
5326
4e1e9ab777a1
Support non interleaved avi files that have 0<size<sample_size.
michael
parents:
5243
diff
changeset
|
1081 ast= st->priv_data; |
4e1e9ab777a1
Support non interleaved avi files that have 0<size<sample_size.
michael
parents:
5243
diff
changeset
|
1082 index= av_index_search_timestamp(st, timestamp * FFMAX(ast->sample_size, 1), flags); |
700
a5e6e0e61e24
use libavformats index system instead of the half duplicated mess in avidec.c
michael
parents:
673
diff
changeset
|
1083 if(index<0) |
311 | 1084 return -1; |
885 | 1085 |
311 | 1086 /* find the position */ |
700
a5e6e0e61e24
use libavformats index system instead of the half duplicated mess in avidec.c
michael
parents:
673
diff
changeset
|
1087 pos = st->index_entries[index].pos; |
5326
4e1e9ab777a1
Support non interleaved avi files that have 0<size<sample_size.
michael
parents:
5243
diff
changeset
|
1088 timestamp = st->index_entries[index].timestamp / FFMAX(ast->sample_size, 1); |
311 | 1089 |
4515
1d9ace1dec78
Add a context to av_log() calls and modify a function prototype to allow it.
benoit
parents:
4353
diff
changeset
|
1090 // av_log(s, AV_LOG_DEBUG, "XX %"PRId64" %d %"PRId64"\n", timestamp, index, st->index_entries[index].timestamp); |
700
a5e6e0e61e24
use libavformats index system instead of the half duplicated mess in avidec.c
michael
parents:
673
diff
changeset
|
1091 |
4210
ec95366371ba
replace all occurrence of ENABLE_ by the corresponding CONFIG_, HAVE_ or ARCH_
aurel
parents:
4203
diff
changeset
|
1092 if (CONFIG_DV_DEMUXER && avi->dv_demux) { |
1629
aedce96c28ff
* Fixing seeking with DV-AVI (by Jeff Downs <heydowns at borg dot com>)
romansh
parents:
1527
diff
changeset
|
1093 /* One and only one real stream for DV in AVI, and it has video */ |
3365 | 1094 /* offsets. Calling with other stream indexes should have failed */ |
1629
aedce96c28ff
* Fixing seeking with DV-AVI (by Jeff Downs <heydowns at borg dot com>)
romansh
parents:
1527
diff
changeset
|
1095 /* the av_index_search_timestamp call above. */ |
aedce96c28ff
* Fixing seeking with DV-AVI (by Jeff Downs <heydowns at borg dot com>)
romansh
parents:
1527
diff
changeset
|
1096 assert(stream_index == 0); |
aedce96c28ff
* Fixing seeking with DV-AVI (by Jeff Downs <heydowns at borg dot com>)
romansh
parents:
1527
diff
changeset
|
1097 |
aedce96c28ff
* Fixing seeking with DV-AVI (by Jeff Downs <heydowns at borg dot com>)
romansh
parents:
1527
diff
changeset
|
1098 /* Feed the DV video stream version of the timestamp to the */ |
3538 | 1099 /* DV demux so it can synthesize correct timestamps. */ |
1629
aedce96c28ff
* Fixing seeking with DV-AVI (by Jeff Downs <heydowns at borg dot com>)
romansh
parents:
1527
diff
changeset
|
1100 dv_offset_reset(avi->dv_demux, timestamp); |
aedce96c28ff
* Fixing seeking with DV-AVI (by Jeff Downs <heydowns at borg dot com>)
romansh
parents:
1527
diff
changeset
|
1101 |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2584
diff
changeset
|
1102 url_fseek(s->pb, pos, SEEK_SET); |
1629
aedce96c28ff
* Fixing seeking with DV-AVI (by Jeff Downs <heydowns at borg dot com>)
romansh
parents:
1527
diff
changeset
|
1103 avi->stream_index= -1; |
aedce96c28ff
* Fixing seeking with DV-AVI (by Jeff Downs <heydowns at borg dot com>)
romansh
parents:
1527
diff
changeset
|
1104 return 0; |
aedce96c28ff
* Fixing seeking with DV-AVI (by Jeff Downs <heydowns at borg dot com>)
romansh
parents:
1527
diff
changeset
|
1105 } |
aedce96c28ff
* Fixing seeking with DV-AVI (by Jeff Downs <heydowns at borg dot com>)
romansh
parents:
1527
diff
changeset
|
1106 |
311 | 1107 for(i = 0; i < s->nb_streams; i++) { |
700
a5e6e0e61e24
use libavformats index system instead of the half duplicated mess in avidec.c
michael
parents:
673
diff
changeset
|
1108 AVStream *st2 = s->streams[i]; |
a5e6e0e61e24
use libavformats index system instead of the half duplicated mess in avidec.c
michael
parents:
673
diff
changeset
|
1109 AVIStream *ast2 = st2->priv_data; |
701 | 1110 |
1111 ast2->packet_size= | |
1112 ast2->remaining= 0; | |
1113 | |
700
a5e6e0e61e24
use libavformats index system instead of the half duplicated mess in avidec.c
michael
parents:
673
diff
changeset
|
1114 if (st2->nb_index_entries <= 0) |
a5e6e0e61e24
use libavformats index system instead of the half duplicated mess in avidec.c
michael
parents:
673
diff
changeset
|
1115 continue; |
885 | 1116 |
988 | 1117 // assert(st2->codec->block_align); |
3610
71ce7d228291
change assert test due to the new reducing of time_base in av_set_pts_info, fix #561
bcoudurier
parents:
3538
diff
changeset
|
1118 assert((int64_t)st2->time_base.num*ast2->rate == (int64_t)st2->time_base.den*ast2->scale); |
700
a5e6e0e61e24
use libavformats index system instead of the half duplicated mess in avidec.c
michael
parents:
673
diff
changeset
|
1119 index = av_index_search_timestamp( |
885 | 1120 st2, |
5326
4e1e9ab777a1
Support non interleaved avi files that have 0<size<sample_size.
michael
parents:
5243
diff
changeset
|
1121 av_rescale_q(timestamp, st->time_base, st2->time_base) * FFMAX(ast2->sample_size, 1), |
700
a5e6e0e61e24
use libavformats index system instead of the half duplicated mess in avidec.c
michael
parents:
673
diff
changeset
|
1122 flags | AVSEEK_FLAG_BACKWARD); |
a5e6e0e61e24
use libavformats index system instead of the half duplicated mess in avidec.c
michael
parents:
673
diff
changeset
|
1123 if(index<0) |
a5e6e0e61e24
use libavformats index system instead of the half duplicated mess in avidec.c
michael
parents:
673
diff
changeset
|
1124 index=0; |
885 | 1125 |
701 | 1126 if(!avi->non_interleaved){ |
1127 while(index>0 && st2->index_entries[index].pos > pos) | |
1128 index--; | |
1129 while(index+1 < st2->nb_index_entries && st2->index_entries[index].pos < pos) | |
1130 index++; | |
1131 } | |
1132 | |
4515
1d9ace1dec78
Add a context to av_log() calls and modify a function prototype to allow it.
benoit
parents:
4353
diff
changeset
|
1133 // av_log(s, AV_LOG_DEBUG, "%"PRId64" %d %"PRId64"\n", timestamp, index, st2->index_entries[index].timestamp); |
700
a5e6e0e61e24
use libavformats index system instead of the half duplicated mess in avidec.c
michael
parents:
673
diff
changeset
|
1134 /* extract the current frame number */ |
a5e6e0e61e24
use libavformats index system instead of the half duplicated mess in avidec.c
michael
parents:
673
diff
changeset
|
1135 ast2->frame_offset = st2->index_entries[index].timestamp; |
311 | 1136 } |
700
a5e6e0e61e24
use libavformats index system instead of the half duplicated mess in avidec.c
michael
parents:
673
diff
changeset
|
1137 |
311 | 1138 /* do the seek */ |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2584
diff
changeset
|
1139 url_fseek(s->pb, pos, SEEK_SET); |
701 | 1140 avi->stream_index= -1; |
311 | 1141 return 0; |
1142 } | |
1143 | |
0 | 1144 static int avi_read_close(AVFormatContext *s) |
1145 { | |
110 | 1146 int i; |
1147 AVIContext *avi = s->priv_data; | |
1148 | |
1149 for(i=0;i<s->nb_streams;i++) { | |
1150 AVStream *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:
775
diff
changeset
|
1151 av_free(st->codec->palctrl); |
110 | 1152 } |
1153 | |
262
f174d9c00bce
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
227
diff
changeset
|
1154 if (avi->dv_demux) |
f174d9c00bce
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
227
diff
changeset
|
1155 av_free(avi->dv_demux); |
f174d9c00bce
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
227
diff
changeset
|
1156 |
0 | 1157 return 0; |
1158 } | |
1159 | |
1160 static int avi_probe(AVProbeData *p) | |
1161 { | |
2578 | 1162 int i; |
1163 | |
0 | 1164 /* check file header */ |
2578 | 1165 for(i=0; avi_headers[i][0]; i++) |
1166 if(!memcmp(p->buf , avi_headers[i] , 4) && | |
1167 !memcmp(p->buf+8, avi_headers[i]+4, 4)) | |
1168 return AVPROBE_SCORE_MAX; | |
1169 | |
1170 return 0; | |
0 | 1171 } |
1172 | |
1169 | 1173 AVInputFormat avi_demuxer = { |
0 | 1174 "avi", |
3424
7a0230981402
Make long_names in lavf/lavdev optional depending on CONFIG_SMALL.
diego
parents:
3384
diff
changeset
|
1175 NULL_IF_CONFIG_SMALL("AVI format"), |
0 | 1176 sizeof(AVIContext), |
1177 avi_probe, | |
1178 avi_read_header, | |
1179 avi_read_packet, | |
1180 avi_read_close, | |
311 | 1181 avi_read_seek, |
0 | 1182 }; |