Mercurial > libavformat.hg
annotate asfdec.c @ 4874:5370b0c1653c libavformat
Increase the SDP buffer size (again!) and also increase the temporary
buffer size of the fmtp parameter buffer. For Vorbis RT(S)P, these
contain full Vorbis headers, which can be up to 12kb each, formatted
in base64, so 16kb total. Patch required for proper Vorbis/RTP playback,
submitted as GSoC qualification task in the thread "RTP/Vorbis payload
implementation (GSoC qual task)" by Colin McQuillan m.niloc googlemail
com.
author | rbultje |
---|---|
date | Tue, 14 Apr 2009 13:22:40 +0000 |
parents | 9145790397e6 |
children | 42e183e59515 |
rev | line source |
---|---|
0 | 1 /* |
1415
3b00fb8ef8e4
replace coder/decoder file description in libavformat by muxer/demuxer
aurel
parents:
1388
diff
changeset
|
2 * ASF compatible demuxer |
4251
77e0c7511d41
cosmetics: Remove pointless period after copyright statement non-sentences.
diego
parents:
4167
diff
changeset
|
3 * Copyright (c) 2000, 2001 Fabrice Bellard |
0 | 4 * |
1358
0899bfe4105c
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
1333
diff
changeset
|
5 * This file is part of FFmpeg. |
0899bfe4105c
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
1333
diff
changeset
|
6 * |
0899bfe4105c
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
1333
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:
1333
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:
1333
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:
1333
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 */ |
3286 | 21 |
22 #include "libavutil/common.h" | |
23 #include "libavcodec/mpegaudio.h" | |
0 | 24 #include "avformat.h" |
1172
6a5e58d2114b
move common stuff from avienc.c and wav.c to new file riff.c
mru
parents:
1169
diff
changeset
|
25 #include "riff.h" |
372
2e12cd1b68ed
split asf patch by (Konstantin Andreyev <kandreyev at bcsii dot com>)
michael
parents:
370
diff
changeset
|
26 #include "asf.h" |
2652 | 27 #include "asfcrypt.h" |
0 | 28 |
4058 | 29 void ff_mms_set_stream_selection(URLContext *h, AVFormatContext *format); |
2708
046577e618bd
Allow propagation of stream selection through the ASF demuxer to the
benoit
parents:
2652
diff
changeset
|
30 |
348 | 31 #undef NDEBUG |
32 #include <assert.h> | |
33 | |
373
e47d9c8e2054
asf patch by (Konstantin Andreyev <kandreyev at bcsii dot com>)
michael
parents:
372
diff
changeset
|
34 #define FRAME_HEADER_SIZE 17 |
885 | 35 // Fix Me! FRAME_HEADER_SIZE may be different. |
373
e47d9c8e2054
asf patch by (Konstantin Andreyev <kandreyev at bcsii dot com>)
michael
parents:
372
diff
changeset
|
36 |
4748
86dd0cab30d3
Rename GUID typedef to ff_asf_guid to fix MinGW compilation failure
reimar
parents:
4747
diff
changeset
|
37 static const ff_asf_guid index_guid = { |
1687 | 38 0x90, 0x08, 0x00, 0x33, 0xb1, 0xe5, 0xcf, 0x11, 0x89, 0xf4, 0x00, 0xa0, 0xc9, 0x03, 0x49, 0xcb |
0 | 39 }; |
40 | |
4748
86dd0cab30d3
Rename GUID typedef to ff_asf_guid to fix MinGW compilation failure
reimar
parents:
4747
diff
changeset
|
41 static const ff_asf_guid stream_bitrate_guid = { /* (http://get.to/sdp) */ |
1806
bf6a0dd6d7be
Add the stream_bitrate GUID to the asf parsing code, and set stream bitrate
takis
parents:
1776
diff
changeset
|
42 0xce, 0x75, 0xf8, 0x7b, 0x8d, 0x46, 0xd1, 0x11, 0x8d, 0x82, 0x00, 0x60, 0x97, 0xc9, 0xa2, 0xb2 |
bf6a0dd6d7be
Add the stream_bitrate GUID to the asf parsing code, and set stream bitrate
takis
parents:
1776
diff
changeset
|
43 }; |
0 | 44 /**********************************/ |
45 /* decoding */ | |
46 | |
47 //#define DEBUG | |
48 | |
49 #ifdef DEBUG | |
69 | 50 #define PRINT_IF_GUID(g,cmp) \ |
4747
0ad594176680
Add a special guidcmp function to compare ASF guids, to avoid the many
reimar
parents:
4743
diff
changeset
|
51 if (!guidcmp(g, &cmp)) \ |
3578 | 52 dprintf(NULL, "(GUID: %s) ", #cmp) |
69 | 53 |
4748
86dd0cab30d3
Rename GUID typedef to ff_asf_guid to fix MinGW compilation failure
reimar
parents:
4747
diff
changeset
|
54 static void print_guid(const ff_asf_guid *g) |
0 | 55 { |
56 int i; | |
4593
0d8b36d98ce2
move static tables from asf.h to non-static tables in asf.c
aurel
parents:
4592
diff
changeset
|
57 PRINT_IF_GUID(g, ff_asf_header); |
0d8b36d98ce2
move static tables from asf.h to non-static tables in asf.c
aurel
parents:
4592
diff
changeset
|
58 else PRINT_IF_GUID(g, ff_asf_file_header); |
0d8b36d98ce2
move static tables from asf.h to non-static tables in asf.c
aurel
parents:
4592
diff
changeset
|
59 else PRINT_IF_GUID(g, ff_asf_stream_header); |
0d8b36d98ce2
move static tables from asf.h to non-static tables in asf.c
aurel
parents:
4592
diff
changeset
|
60 else PRINT_IF_GUID(g, ff_asf_audio_stream); |
0d8b36d98ce2
move static tables from asf.h to non-static tables in asf.c
aurel
parents:
4592
diff
changeset
|
61 else PRINT_IF_GUID(g, ff_asf_audio_conceal_none); |
0d8b36d98ce2
move static tables from asf.h to non-static tables in asf.c
aurel
parents:
4592
diff
changeset
|
62 else PRINT_IF_GUID(g, ff_asf_video_stream); |
0d8b36d98ce2
move static tables from asf.h to non-static tables in asf.c
aurel
parents:
4592
diff
changeset
|
63 else PRINT_IF_GUID(g, ff_asf_video_conceal_none); |
0d8b36d98ce2
move static tables from asf.h to non-static tables in asf.c
aurel
parents:
4592
diff
changeset
|
64 else PRINT_IF_GUID(g, ff_asf_command_stream); |
0d8b36d98ce2
move static tables from asf.h to non-static tables in asf.c
aurel
parents:
4592
diff
changeset
|
65 else PRINT_IF_GUID(g, ff_asf_comment_header); |
0d8b36d98ce2
move static tables from asf.h to non-static tables in asf.c
aurel
parents:
4592
diff
changeset
|
66 else PRINT_IF_GUID(g, ff_asf_codec_comment_header); |
0d8b36d98ce2
move static tables from asf.h to non-static tables in asf.c
aurel
parents:
4592
diff
changeset
|
67 else PRINT_IF_GUID(g, ff_asf_codec_comment1_header); |
0d8b36d98ce2
move static tables from asf.h to non-static tables in asf.c
aurel
parents:
4592
diff
changeset
|
68 else PRINT_IF_GUID(g, ff_asf_data_header); |
69 | 69 else PRINT_IF_GUID(g, index_guid); |
4593
0d8b36d98ce2
move static tables from asf.h to non-static tables in asf.c
aurel
parents:
4592
diff
changeset
|
70 else PRINT_IF_GUID(g, ff_asf_head1_guid); |
0d8b36d98ce2
move static tables from asf.h to non-static tables in asf.c
aurel
parents:
4592
diff
changeset
|
71 else PRINT_IF_GUID(g, ff_asf_head2_guid); |
0d8b36d98ce2
move static tables from asf.h to non-static tables in asf.c
aurel
parents:
4592
diff
changeset
|
72 else PRINT_IF_GUID(g, ff_asf_my_guid); |
0d8b36d98ce2
move static tables from asf.h to non-static tables in asf.c
aurel
parents:
4592
diff
changeset
|
73 else PRINT_IF_GUID(g, ff_asf_ext_stream_header); |
0d8b36d98ce2
move static tables from asf.h to non-static tables in asf.c
aurel
parents:
4592
diff
changeset
|
74 else PRINT_IF_GUID(g, ff_asf_extended_content_header); |
0d8b36d98ce2
move static tables from asf.h to non-static tables in asf.c
aurel
parents:
4592
diff
changeset
|
75 else PRINT_IF_GUID(g, ff_asf_ext_stream_embed_stream_header); |
0d8b36d98ce2
move static tables from asf.h to non-static tables in asf.c
aurel
parents:
4592
diff
changeset
|
76 else PRINT_IF_GUID(g, ff_asf_ext_stream_audio_stream); |
0d8b36d98ce2
move static tables from asf.h to non-static tables in asf.c
aurel
parents:
4592
diff
changeset
|
77 else PRINT_IF_GUID(g, ff_asf_metadata_header); |
1806
bf6a0dd6d7be
Add the stream_bitrate GUID to the asf parsing code, and set stream bitrate
takis
parents:
1776
diff
changeset
|
78 else PRINT_IF_GUID(g, stream_bitrate_guid); |
69 | 79 else |
3578 | 80 dprintf(NULL, "(GUID: unknown) "); |
1687 | 81 for(i=0;i<16;i++) |
3578 | 82 dprintf(NULL, " 0x%02x,", (*g)[i]); |
83 dprintf(NULL, "}\n"); | |
0 | 84 } |
949 | 85 #undef PRINT_IF_GUID |
3578 | 86 #else |
87 #define print_guid(g) | |
0 | 88 #endif |
89 | |
4747
0ad594176680
Add a special guidcmp function to compare ASF guids, to avoid the many
reimar
parents:
4743
diff
changeset
|
90 static int guidcmp(const void *g1, const void *g2) |
0ad594176680
Add a special guidcmp function to compare ASF guids, to avoid the many
reimar
parents:
4743
diff
changeset
|
91 { |
4748
86dd0cab30d3
Rename GUID typedef to ff_asf_guid to fix MinGW compilation failure
reimar
parents:
4747
diff
changeset
|
92 return memcmp(g1, g2, sizeof(ff_asf_guid)); |
4747
0ad594176680
Add a special guidcmp function to compare ASF guids, to avoid the many
reimar
parents:
4743
diff
changeset
|
93 } |
0ad594176680
Add a special guidcmp function to compare ASF guids, to avoid the many
reimar
parents:
4743
diff
changeset
|
94 |
4748
86dd0cab30d3
Rename GUID typedef to ff_asf_guid to fix MinGW compilation failure
reimar
parents:
4747
diff
changeset
|
95 static void get_guid(ByteIOContext *s, ff_asf_guid *g) |
0 | 96 { |
1687 | 97 assert(sizeof(*g) == 16); |
2988
bc099b0e8b6f
typo, also fix warning: asf.c:90: warning: passing argument 2 of 'get_buffer' from incompatible pointer type
bcoudurier
parents:
2855
diff
changeset
|
98 get_buffer(s, *g, sizeof(*g)); |
0 | 99 } |
100 | |
101 #if 0 | |
102 static void get_str16(ByteIOContext *pb, char *buf, int buf_size) | |
103 { | |
104 int len, c; | |
105 char *q; | |
106 | |
107 len = get_le16(pb); | |
108 q = buf; | |
109 while (len > 0) { | |
110 c = get_le16(pb); | |
111 if ((q - buf) < buf_size - 1) | |
112 *q++ = c; | |
113 len--; | |
114 } | |
115 *q = '\0'; | |
116 } | |
117 #endif | |
118 | |
119 static void get_str16_nolen(ByteIOContext *pb, int len, char *buf, int buf_size) | |
120 { | |
1503 | 121 char* q = buf; |
122 len /= 2; | |
123 while (len--) { | |
124 uint8_t tmp; | |
125 PUT_UTF8(get_le16(pb), tmp, if (q - buf < buf_size - 1) *q++ = tmp;) | |
0 | 126 } |
127 *q = '\0'; | |
128 } | |
129 | |
130 static int asf_probe(AVProbeData *pd) | |
131 { | |
132 /* check file header */ | |
4747
0ad594176680
Add a special guidcmp function to compare ASF guids, to avoid the many
reimar
parents:
4743
diff
changeset
|
133 if (!guidcmp(pd->buf, &ff_asf_header)) |
0 | 134 return AVPROBE_SCORE_MAX; |
135 else | |
136 return 0; | |
137 } | |
138 | |
1750 | 139 static int get_value(ByteIOContext *pb, int type){ |
140 switch(type){ | |
141 case 2: return get_le32(pb); | |
142 case 3: return get_le32(pb); | |
143 case 4: return get_le64(pb); | |
144 case 5: return get_le16(pb); | |
145 default:return INT_MIN; | |
146 } | |
147 } | |
148 | |
4368 | 149 static void get_tag(AVFormatContext *s, const char *key, int type, int len) |
150 { | |
151 char value[1024]; | |
152 if (type <= 1) { // unicode or byte | |
153 get_str16_nolen(s->pb, len, value, sizeof(value)); | |
154 } else if (type <= 5) { // boolean or DWORD or QWORD or WORD | |
155 uint64_t num = get_value(s->pb, type); | |
156 snprintf(value, sizeof(value), "%"PRIu64, num); | |
157 } else { | |
158 url_fskip(s->pb, len); | |
159 return; | |
160 } | |
4797
9145790397e6
Don't strip the first three characters off of any metadata in ASF file.
rbultje
parents:
4748
diff
changeset
|
161 if (!strncmp(key, "WM/", 3)) |
4368 | 162 key += 3; |
163 av_metadata_set(&s->metadata, key, value); | |
164 } | |
165 | |
0 | 166 static int asf_read_header(AVFormatContext *s, AVFormatParameters *ap) |
167 { | |
168 ASFContext *asf = s->priv_data; | |
4748
86dd0cab30d3
Rename GUID typedef to ff_asf_guid to fix MinGW compilation failure
reimar
parents:
4747
diff
changeset
|
169 ff_asf_guid g; |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2737
diff
changeset
|
170 ByteIOContext *pb = s->pb; |
0 | 171 AVStream *st; |
172 ASFStream *asf_st; | |
173 int size, i; | |
65 | 174 int64_t gsize; |
1750 | 175 AVRational dar[128]; |
2064 | 176 uint32_t bitrate[128]; |
1750 | 177 |
178 memset(dar, 0, sizeof(dar)); | |
2064 | 179 memset(bitrate, 0, sizeof(bitrate)); |
0 | 180 |
181 get_guid(pb, &g); | |
4747
0ad594176680
Add a special guidcmp function to compare ASF guids, to avoid the many
reimar
parents:
4743
diff
changeset
|
182 if (guidcmp(&g, &ff_asf_header)) |
3486 | 183 return -1; |
0 | 184 get_le64(pb); |
185 get_le32(pb); | |
186 get_byte(pb); | |
187 get_byte(pb); | |
188 memset(&asf->asfid2avid, -1, sizeof(asf->asfid2avid)); | |
189 for(;;) { | |
190 get_guid(pb, &g); | |
191 gsize = get_le64(pb); | |
3578 | 192 dprintf(s, "%08"PRIx64": ", url_ftell(pb) - 24); |
0 | 193 print_guid(&g); |
3578 | 194 dprintf(s, " size=0x%"PRIx64"\n", gsize); |
4747
0ad594176680
Add a special guidcmp function to compare ASF guids, to avoid the many
reimar
parents:
4743
diff
changeset
|
195 if (!guidcmp(&g, &ff_asf_data_header)) { |
1896
6d2157d1fc93
fix gsize=0 / -1 case (if(<24) goto fail) before it is not a good idea
michael
parents:
1859
diff
changeset
|
196 asf->data_object_offset = url_ftell(pb); |
6d2157d1fc93
fix gsize=0 / -1 case (if(<24) goto fail) before it is not a good idea
michael
parents:
1859
diff
changeset
|
197 // if not streaming, gsize is not unlimited (how?), and there is enough space in the file.. |
6d2157d1fc93
fix gsize=0 / -1 case (if(<24) goto fail) before it is not a good idea
michael
parents:
1859
diff
changeset
|
198 if (!(asf->hdr.flags & 0x01) && gsize >= 100) { |
6d2157d1fc93
fix gsize=0 / -1 case (if(<24) goto fail) before it is not a good idea
michael
parents:
1859
diff
changeset
|
199 asf->data_object_size = gsize - 24; |
6d2157d1fc93
fix gsize=0 / -1 case (if(<24) goto fail) before it is not a good idea
michael
parents:
1859
diff
changeset
|
200 } else { |
6d2157d1fc93
fix gsize=0 / -1 case (if(<24) goto fail) before it is not a good idea
michael
parents:
1859
diff
changeset
|
201 asf->data_object_size = (uint64_t)-1; |
6d2157d1fc93
fix gsize=0 / -1 case (if(<24) goto fail) before it is not a good idea
michael
parents:
1859
diff
changeset
|
202 } |
6d2157d1fc93
fix gsize=0 / -1 case (if(<24) goto fail) before it is not a good idea
michael
parents:
1859
diff
changeset
|
203 break; |
6d2157d1fc93
fix gsize=0 / -1 case (if(<24) goto fail) before it is not a good idea
michael
parents:
1859
diff
changeset
|
204 } |
0 | 205 if (gsize < 24) |
3486 | 206 return -1; |
4747
0ad594176680
Add a special guidcmp function to compare ASF guids, to avoid the many
reimar
parents:
4743
diff
changeset
|
207 if (!guidcmp(&g, &ff_asf_file_header)) { |
0 | 208 get_guid(pb, &asf->hdr.guid); |
887 | 209 asf->hdr.file_size = get_le64(pb); |
210 asf->hdr.create_time = get_le64(pb); | |
1701 | 211 asf->nb_packets = get_le64(pb); |
3239 | 212 asf->hdr.play_time = get_le64(pb); |
887 | 213 asf->hdr.send_time = get_le64(pb); |
214 asf->hdr.preroll = get_le32(pb); | |
215 asf->hdr.ignore = get_le32(pb); | |
216 asf->hdr.flags = get_le32(pb); | |
217 asf->hdr.min_pktsize = get_le32(pb); | |
218 asf->hdr.max_pktsize = get_le32(pb); | |
219 asf->hdr.max_bitrate = get_le32(pb); | |
220 asf->packet_size = asf->hdr.max_pktsize; | |
4747
0ad594176680
Add a special guidcmp function to compare ASF guids, to avoid the many
reimar
parents:
4743
diff
changeset
|
221 } else if (!guidcmp(&g, &ff_asf_stream_header)) { |
3967 | 222 enum CodecType type; |
223 int type_specific_size, sizeX; | |
1263
cf88f6719743
total_size should be 64bit (1 hunk of the asf seeking patch from DrDivx / Steve Lhomme)
michael
parents:
1206
diff
changeset
|
224 uint64_t total_size; |
0 | 225 unsigned int tag1; |
2318
e5c3b6e7b6ef
ignore preroll, it is generally not what AVStream.start_time should contain
michael
parents:
2285
diff
changeset
|
226 int64_t pos1, pos2, start_time; |
2018 | 227 int test_for_ext_stream_audio, is_dvr_ms_audio=0; |
0 | 228 |
229 pos1 = url_ftell(pb); | |
230 | |
188
6c9d6422a2f6
update duration and start_time - add av_new_stream() usage
bellard
parents:
136
diff
changeset
|
231 st = av_new_stream(s, 0); |
0 | 232 if (!st) |
3486 | 233 return AVERROR(ENOMEM); |
462
b69898ffc92a
move time_base (pts_num/pts_den) from AVFormatContext -> AVStream
michael
parents:
437
diff
changeset
|
234 av_set_pts_info(st, 32, 1, 1000); /* 32 bit pts in ms */ |
0 | 235 asf_st = av_mallocz(sizeof(ASFStream)); |
236 if (!asf_st) | |
3486 | 237 return AVERROR(ENOMEM); |
0 | 238 st->priv_data = asf_st; |
2318
e5c3b6e7b6ef
ignore preroll, it is generally not what AVStream.start_time should contain
michael
parents:
2285
diff
changeset
|
239 start_time = asf->hdr.preroll; |
e5c3b6e7b6ef
ignore preroll, it is generally not what AVStream.start_time should contain
michael
parents:
2285
diff
changeset
|
240 |
1552 | 241 if(!(asf->hdr.flags & 0x01)) { // if we aren't streaming... |
242 st->duration = asf->hdr.send_time / | |
2318
e5c3b6e7b6ef
ignore preroll, it is generally not what AVStream.start_time should contain
michael
parents:
2285
diff
changeset
|
243 (10000000 / 1000) - start_time; |
1552 | 244 } |
0 | 245 get_guid(pb, &g); |
904
5d3dc3a6bbe7
audio in dvr-ms demuxing support by (John Donaghy <johnfdonaghy gmail com<)
michael
parents:
896
diff
changeset
|
246 |
5d3dc3a6bbe7
audio in dvr-ms demuxing support by (John Donaghy <johnfdonaghy gmail com<)
michael
parents:
896
diff
changeset
|
247 test_for_ext_stream_audio = 0; |
4747
0ad594176680
Add a special guidcmp function to compare ASF guids, to avoid the many
reimar
parents:
4743
diff
changeset
|
248 if (!guidcmp(&g, &ff_asf_audio_stream)) { |
0 | 249 type = CODEC_TYPE_AUDIO; |
4747
0ad594176680
Add a special guidcmp function to compare ASF guids, to avoid the many
reimar
parents:
4743
diff
changeset
|
250 } else if (!guidcmp(&g, &ff_asf_video_stream)) { |
0 | 251 type = CODEC_TYPE_VIDEO; |
4747
0ad594176680
Add a special guidcmp function to compare ASF guids, to avoid the many
reimar
parents:
4743
diff
changeset
|
252 } else if (!guidcmp(&g, &ff_asf_command_stream)) { |
3567 | 253 type = CODEC_TYPE_DATA; |
4747
0ad594176680
Add a special guidcmp function to compare ASF guids, to avoid the many
reimar
parents:
4743
diff
changeset
|
254 } else if (!guidcmp(&g, &ff_asf_ext_stream_embed_stream_header)) { |
904
5d3dc3a6bbe7
audio in dvr-ms demuxing support by (John Donaghy <johnfdonaghy gmail com<)
michael
parents:
896
diff
changeset
|
255 test_for_ext_stream_audio = 1; |
5d3dc3a6bbe7
audio in dvr-ms demuxing support by (John Donaghy <johnfdonaghy gmail com<)
michael
parents:
896
diff
changeset
|
256 type = CODEC_TYPE_UNKNOWN; |
0 | 257 } else { |
3486 | 258 return -1; |
0 | 259 } |
260 get_guid(pb, &g); | |
261 total_size = get_le64(pb); | |
84
0068a6902911
correct AUDIO strf parsing patch by (Roman Shaposhnick <rvs at sun dot com>)
michaelni
parents:
74
diff
changeset
|
262 type_specific_size = get_le32(pb); |
0 | 263 get_le32(pb); |
887 | 264 st->id = get_le16(pb) & 0x7f; /* stream id */ |
0 | 265 // mapping of asf ID to AV stream ID; |
188
6c9d6422a2f6
update duration and start_time - add av_new_stream() usage
bellard
parents:
136
diff
changeset
|
266 asf->asfid2avid[st->id] = s->nb_streams - 1; |
0 | 267 |
268 get_le32(pb); | |
904
5d3dc3a6bbe7
audio in dvr-ms demuxing support by (John Donaghy <johnfdonaghy gmail com<)
michael
parents:
896
diff
changeset
|
269 |
5d3dc3a6bbe7
audio in dvr-ms demuxing support by (John Donaghy <johnfdonaghy gmail com<)
michael
parents:
896
diff
changeset
|
270 if (test_for_ext_stream_audio) { |
5d3dc3a6bbe7
audio in dvr-ms demuxing support by (John Donaghy <johnfdonaghy gmail com<)
michael
parents:
896
diff
changeset
|
271 get_guid(pb, &g); |
4747
0ad594176680
Add a special guidcmp function to compare ASF guids, to avoid the many
reimar
parents:
4743
diff
changeset
|
272 if (!guidcmp(&g, &ff_asf_ext_stream_audio_stream)) { |
904
5d3dc3a6bbe7
audio in dvr-ms demuxing support by (John Donaghy <johnfdonaghy gmail com<)
michael
parents:
896
diff
changeset
|
273 type = CODEC_TYPE_AUDIO; |
2018 | 274 is_dvr_ms_audio=1; |
904
5d3dc3a6bbe7
audio in dvr-ms demuxing support by (John Donaghy <johnfdonaghy gmail com<)
michael
parents:
896
diff
changeset
|
275 get_guid(pb, &g); |
5d3dc3a6bbe7
audio in dvr-ms demuxing support by (John Donaghy <johnfdonaghy gmail com<)
michael
parents:
896
diff
changeset
|
276 get_le32(pb); |
5d3dc3a6bbe7
audio in dvr-ms demuxing support by (John Donaghy <johnfdonaghy gmail com<)
michael
parents:
896
diff
changeset
|
277 get_le32(pb); |
5d3dc3a6bbe7
audio in dvr-ms demuxing support by (John Donaghy <johnfdonaghy gmail com<)
michael
parents:
896
diff
changeset
|
278 get_le32(pb); |
5d3dc3a6bbe7
audio in dvr-ms demuxing support by (John Donaghy <johnfdonaghy gmail com<)
michael
parents:
896
diff
changeset
|
279 get_guid(pb, &g); |
5d3dc3a6bbe7
audio in dvr-ms demuxing support by (John Donaghy <johnfdonaghy gmail com<)
michael
parents:
896
diff
changeset
|
280 get_le32(pb); |
5d3dc3a6bbe7
audio in dvr-ms demuxing support by (John Donaghy <johnfdonaghy gmail com<)
michael
parents:
896
diff
changeset
|
281 } |
5d3dc3a6bbe7
audio in dvr-ms demuxing support by (John Donaghy <johnfdonaghy gmail com<)
michael
parents:
896
diff
changeset
|
282 } |
5d3dc3a6bbe7
audio in dvr-ms demuxing support by (John Donaghy <johnfdonaghy gmail com<)
michael
parents:
896
diff
changeset
|
283 |
887 | 284 st->codec->codec_type = type; |
0 | 285 if (type == CODEC_TYPE_AUDIO) { |
820
feca73904e67
changing AVCodecContext codec -> *codec in AVStream so additions to AVCodecContext dont randomize AVStream and break binary compatibility
michael
parents:
792
diff
changeset
|
286 get_wav_header(pb, st->codec, type_specific_size); |
2018 | 287 if (is_dvr_ms_audio) { |
288 // codec_id and codec_tag are unreliable in dvr_ms | |
289 // files. Set them later by probing stream. | |
3568 | 290 st->codec->codec_id = CODEC_ID_PROBE; |
2018 | 291 st->codec->codec_tag = 0; |
292 } | |
4545 | 293 if (st->codec->codec_id == CODEC_ID_AAC) { |
294 st->need_parsing = AVSTREAM_PARSE_NONE; | |
295 } else { | |
4546 | 296 st->need_parsing = AVSTREAM_PARSE_FULL; |
4545 | 297 } |
887 | 298 /* We have to init the frame size at some point .... */ |
299 pos2 = url_ftell(pb); | |
1859 | 300 if (gsize >= (pos2 + 8 - pos1 + 24)) { |
887 | 301 asf_st->ds_span = get_byte(pb); |
302 asf_st->ds_packet_size = get_le16(pb); | |
303 asf_st->ds_chunk_size = get_le16(pb); | |
1701 | 304 get_le16(pb); //ds_data_size |
305 get_byte(pb); //ds_silence_data | |
887 | 306 } |
307 //printf("Descrambling: ps:%d cs:%d ds:%d s:%d sd:%d\n", | |
308 // asf_st->ds_packet_size, asf_st->ds_chunk_size, | |
309 // asf_st->ds_data_size, asf_st->ds_span, asf_st->ds_silence_data); | |
310 if (asf_st->ds_span > 1) { | |
311 if (!asf_st->ds_chunk_size | |
1700
77bd711c0aed
adding a few checks to the audio packet descrambling, this should hopefully catch all related out of array accesses
michael
parents:
1699
diff
changeset
|
312 || (asf_st->ds_packet_size/asf_st->ds_chunk_size <= 1) |
77bd711c0aed
adding a few checks to the audio packet descrambling, this should hopefully catch all related out of array accesses
michael
parents:
1699
diff
changeset
|
313 || asf_st->ds_packet_size % asf_st->ds_chunk_size) |
887 | 314 asf_st->ds_span = 0; // disable descrambling |
315 } | |
820
feca73904e67
changing AVCodecContext codec -> *codec in AVStream so additions to AVCodecContext dont randomize AVStream and break binary compatibility
michael
parents:
792
diff
changeset
|
316 switch (st->codec->codec_id) { |
232 | 317 case CODEC_ID_MP3: |
820
feca73904e67
changing AVCodecContext codec -> *codec in AVStream so additions to AVCodecContext dont randomize AVStream and break binary compatibility
michael
parents:
792
diff
changeset
|
318 st->codec->frame_size = MPA_FRAME_SIZE; |
0 | 319 break; |
320 case CODEC_ID_PCM_S16LE: | |
321 case CODEC_ID_PCM_S16BE: | |
322 case CODEC_ID_PCM_U16LE: | |
323 case CODEC_ID_PCM_U16BE: | |
324 case CODEC_ID_PCM_S8: | |
325 case CODEC_ID_PCM_U8: | |
326 case CODEC_ID_PCM_ALAW: | |
327 case CODEC_ID_PCM_MULAW: | |
820
feca73904e67
changing AVCodecContext codec -> *codec in AVStream so additions to AVCodecContext dont randomize AVStream and break binary compatibility
michael
parents:
792
diff
changeset
|
328 st->codec->frame_size = 1; |
0 | 329 break; |
330 default: | |
331 /* This is probably wrong, but it prevents a crash later */ | |
820
feca73904e67
changing AVCodecContext codec -> *codec in AVStream so additions to AVCodecContext dont randomize AVStream and break binary compatibility
michael
parents:
792
diff
changeset
|
332 st->codec->frame_size = 1; |
0 | 333 break; |
334 } | |
904
5d3dc3a6bbe7
audio in dvr-ms demuxing support by (John Donaghy <johnfdonaghy gmail com<)
michael
parents:
896
diff
changeset
|
335 } else if (type == CODEC_TYPE_VIDEO) { |
887 | 336 get_le32(pb); |
0 | 337 get_le32(pb); |
338 get_byte(pb); | |
339 size = get_le16(pb); /* size */ | |
732 | 340 sizeX= 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:
792
diff
changeset
|
341 st->codec->width = get_le32(pb); |
887 | 342 st->codec->height = get_le32(pb); |
0 | 343 /* not available for asf */ |
344 get_le16(pb); /* panes */ | |
3908
1d3d17de20ba
Bump Major version, this commit is almost just renaming bits_per_sample to
michael
parents:
3759
diff
changeset
|
345 st->codec->bits_per_coded_sample = get_le16(pb); /* depth */ |
0 | 346 tag1 = get_le32(pb); |
887 | 347 url_fskip(pb, 20); |
4508 | 348 // av_log(s, AV_LOG_DEBUG, "size:%d tsize:%d sizeX:%d\n", size, total_size, sizeX); |
732 | 349 size= sizeX; |
887 | 350 if (size > 40) { |
351 st->codec->extradata_size = size - 40; | |
352 st->codec->extradata = av_mallocz(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE); | |
353 get_buffer(pb, st->codec->extradata, st->codec->extradata_size); | |
354 } | |
297
85d558a18134
Make avi and asf demuxer export palette in palctrl
rtognimp
parents:
277
diff
changeset
|
355 |
4743
5c65daa1c678
cosmetics: fix indentation, patch by avcoder, ffmpeg gmail com
diego
parents:
4618
diff
changeset
|
356 /* Extract palette from extradata if bpp <= 8 */ |
5c65daa1c678
cosmetics: fix indentation, patch by avcoder, ffmpeg gmail com
diego
parents:
4618
diff
changeset
|
357 /* This code assumes that extradata contains only palette */ |
5c65daa1c678
cosmetics: fix indentation, patch by avcoder, ffmpeg gmail com
diego
parents:
4618
diff
changeset
|
358 /* This is true for all paletted codecs implemented in ffmpeg */ |
5c65daa1c678
cosmetics: fix indentation, patch by avcoder, ffmpeg gmail com
diego
parents:
4618
diff
changeset
|
359 if (st->codec->extradata_size && (st->codec->bits_per_coded_sample <= 8)) { |
5c65daa1c678
cosmetics: fix indentation, patch by avcoder, ffmpeg gmail com
diego
parents:
4618
diff
changeset
|
360 st->codec->palctrl = av_mallocz(sizeof(AVPaletteControl)); |
297
85d558a18134
Make avi and asf demuxer export palette in palctrl
rtognimp
parents:
277
diff
changeset
|
361 #ifdef WORDS_BIGENDIAN |
4743
5c65daa1c678
cosmetics: fix indentation, patch by avcoder, ffmpeg gmail com
diego
parents:
4618
diff
changeset
|
362 for (i = 0; i < FFMIN(st->codec->extradata_size, AVPALETTE_SIZE)/4; i++) |
5c65daa1c678
cosmetics: fix indentation, patch by avcoder, ffmpeg gmail com
diego
parents:
4618
diff
changeset
|
363 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:
277
diff
changeset
|
364 #else |
4743
5c65daa1c678
cosmetics: fix indentation, patch by avcoder, ffmpeg gmail com
diego
parents:
4618
diff
changeset
|
365 memcpy(st->codec->palctrl->palette, st->codec->extradata, |
5c65daa1c678
cosmetics: fix indentation, patch by avcoder, ffmpeg gmail com
diego
parents:
4618
diff
changeset
|
366 FFMIN(st->codec->extradata_size, AVPALETTE_SIZE)); |
297
85d558a18134
Make avi and asf demuxer export palette in palctrl
rtognimp
parents:
277
diff
changeset
|
367 #endif |
4743
5c65daa1c678
cosmetics: fix indentation, patch by avcoder, ffmpeg gmail com
diego
parents:
4618
diff
changeset
|
368 st->codec->palctrl->palette_changed = 1; |
5c65daa1c678
cosmetics: fix indentation, patch by avcoder, ffmpeg gmail com
diego
parents:
4618
diff
changeset
|
369 } |
297
85d558a18134
Make avi and asf demuxer export palette in palctrl
rtognimp
parents:
277
diff
changeset
|
370 |
820
feca73904e67
changing AVCodecContext codec -> *codec in AVStream so additions to AVCodecContext dont randomize AVStream and break binary compatibility
michael
parents:
792
diff
changeset
|
371 st->codec->codec_tag = tag1; |
887 | 372 st->codec->codec_id = codec_get_id(codec_bmp_tags, tag1); |
573 | 373 if(tag1 == MKTAG('D', 'V', 'R', ' ')) |
2023 | 374 st->need_parsing = AVSTREAM_PARSE_FULL; |
0 | 375 } |
376 pos2 = url_ftell(pb); | |
377 url_fskip(pb, gsize - (pos2 - pos1 + 24)); | |
4747
0ad594176680
Add a special guidcmp function to compare ASF guids, to avoid the many
reimar
parents:
4743
diff
changeset
|
378 } else if (!guidcmp(&g, &ff_asf_comment_header)) { |
0 | 379 int len1, len2, len3, len4, len5; |
380 | |
381 len1 = get_le16(pb); | |
382 len2 = get_le16(pb); | |
383 len3 = get_le16(pb); | |
384 len4 = get_le16(pb); | |
385 len5 = get_le16(pb); | |
4368 | 386 get_tag(s, "title" , 0, len1); |
387 get_tag(s, "author" , 0, len2); | |
388 get_tag(s, "copyright", 0, len3); | |
389 get_tag(s, "comment" , 0, len4); | |
887 | 390 url_fskip(pb, len5); |
4747
0ad594176680
Add a special guidcmp function to compare ASF guids, to avoid the many
reimar
parents:
4743
diff
changeset
|
391 } else if (!guidcmp(&g, &stream_bitrate_guid)) { |
1806
bf6a0dd6d7be
Add the stream_bitrate GUID to the asf parsing code, and set stream bitrate
takis
parents:
1776
diff
changeset
|
392 int stream_count = get_le16(pb); |
bf6a0dd6d7be
Add the stream_bitrate GUID to the asf parsing code, and set stream bitrate
takis
parents:
1776
diff
changeset
|
393 int j; |
bf6a0dd6d7be
Add the stream_bitrate GUID to the asf parsing code, and set stream bitrate
takis
parents:
1776
diff
changeset
|
394 |
4508 | 395 // av_log(s, AV_LOG_ERROR, "stream bitrate properties\n"); |
396 // av_log(s, AV_LOG_ERROR, "streams %d\n", streams); | |
1806
bf6a0dd6d7be
Add the stream_bitrate GUID to the asf parsing code, and set stream bitrate
takis
parents:
1776
diff
changeset
|
397 for(j = 0; j < stream_count; j++) { |
bf6a0dd6d7be
Add the stream_bitrate GUID to the asf parsing code, and set stream bitrate
takis
parents:
1776
diff
changeset
|
398 int flags, bitrate, stream_id; |
bf6a0dd6d7be
Add the stream_bitrate GUID to the asf parsing code, and set stream bitrate
takis
parents:
1776
diff
changeset
|
399 |
bf6a0dd6d7be
Add the stream_bitrate GUID to the asf parsing code, and set stream bitrate
takis
parents:
1776
diff
changeset
|
400 flags= get_le16(pb); |
bf6a0dd6d7be
Add the stream_bitrate GUID to the asf parsing code, and set stream bitrate
takis
parents:
1776
diff
changeset
|
401 bitrate= get_le32(pb); |
bf6a0dd6d7be
Add the stream_bitrate GUID to the asf parsing code, and set stream bitrate
takis
parents:
1776
diff
changeset
|
402 stream_id= (flags & 0x7f); |
4508 | 403 // av_log(s, AV_LOG_ERROR, "flags: 0x%x stream id %d, bitrate %d\n", flags, stream_id, bitrate); |
2392 | 404 asf->stream_bitrates[stream_id]= bitrate; |
1806
bf6a0dd6d7be
Add the stream_bitrate GUID to the asf parsing code, and set stream bitrate
takis
parents:
1776
diff
changeset
|
405 } |
4747
0ad594176680
Add a special guidcmp function to compare ASF guids, to avoid the many
reimar
parents:
4743
diff
changeset
|
406 } else if (!guidcmp(&g, &ff_asf_extended_content_header)) { |
4743
5c65daa1c678
cosmetics: fix indentation, patch by avcoder, ffmpeg gmail com
diego
parents:
4618
diff
changeset
|
407 int desc_count, i; |
341
ad2a57c5467a
ASF extended header parsing patch by ("Kevin Kuphal" <kevin dot kuphal at sitecity dot net>)
michael
parents:
312
diff
changeset
|
408 |
4743
5c65daa1c678
cosmetics: fix indentation, patch by avcoder, ffmpeg gmail com
diego
parents:
4618
diff
changeset
|
409 desc_count = get_le16(pb); |
5c65daa1c678
cosmetics: fix indentation, patch by avcoder, ffmpeg gmail com
diego
parents:
4618
diff
changeset
|
410 for(i=0;i<desc_count;i++) { |
5c65daa1c678
cosmetics: fix indentation, patch by avcoder, ffmpeg gmail com
diego
parents:
4618
diff
changeset
|
411 int name_len,value_type,value_len; |
5c65daa1c678
cosmetics: fix indentation, patch by avcoder, ffmpeg gmail com
diego
parents:
4618
diff
changeset
|
412 char name[1024]; |
341
ad2a57c5467a
ASF extended header parsing patch by ("Kevin Kuphal" <kevin dot kuphal at sitecity dot net>)
michael
parents:
312
diff
changeset
|
413 |
4743
5c65daa1c678
cosmetics: fix indentation, patch by avcoder, ffmpeg gmail com
diego
parents:
4618
diff
changeset
|
414 name_len = get_le16(pb); |
5c65daa1c678
cosmetics: fix indentation, patch by avcoder, ffmpeg gmail com
diego
parents:
4618
diff
changeset
|
415 get_str16_nolen(pb, name_len, name, sizeof(name)); |
5c65daa1c678
cosmetics: fix indentation, patch by avcoder, ffmpeg gmail com
diego
parents:
4618
diff
changeset
|
416 value_type = get_le16(pb); |
5c65daa1c678
cosmetics: fix indentation, patch by avcoder, ffmpeg gmail com
diego
parents:
4618
diff
changeset
|
417 value_len = get_le16(pb); |
5c65daa1c678
cosmetics: fix indentation, patch by avcoder, ffmpeg gmail com
diego
parents:
4618
diff
changeset
|
418 get_tag(s, name, value_type, value_len); |
5c65daa1c678
cosmetics: fix indentation, patch by avcoder, ffmpeg gmail com
diego
parents:
4618
diff
changeset
|
419 } |
4747
0ad594176680
Add a special guidcmp function to compare ASF guids, to avoid the many
reimar
parents:
4743
diff
changeset
|
420 } else if (!guidcmp(&g, &ff_asf_metadata_header)) { |
1750 | 421 int n, stream_num, name_len, value_len, value_type, value_num; |
422 n = get_le16(pb); | |
423 | |
424 for(i=0;i<n;i++) { | |
425 char name[1024]; | |
426 | |
427 get_le16(pb); //lang_list_index | |
428 stream_num= get_le16(pb); | |
429 name_len= get_le16(pb); | |
430 value_type= get_le16(pb); | |
431 value_len= get_le32(pb); | |
432 | |
433 get_str16_nolen(pb, name_len, name, sizeof(name)); | |
4508 | 434 //av_log(s, AV_LOG_ERROR, "%d %d %d %d %d <%s>\n", i, stream_num, name_len, value_type, value_len, name); |
2164 | 435 value_num= get_le16(pb);//we should use get_value() here but it does not work 2 is le16 here but le32 elsewhere |
1750 | 436 url_fskip(pb, value_len - 2); |
437 | |
438 if(stream_num<128){ | |
439 if (!strcmp(name, "AspectRatioX")) dar[stream_num].num= value_num; | |
440 else if(!strcmp(name, "AspectRatioY")) dar[stream_num].den= value_num; | |
441 } | |
442 } | |
4747
0ad594176680
Add a special guidcmp function to compare ASF guids, to avoid the many
reimar
parents:
4743
diff
changeset
|
443 } else if (!guidcmp(&g, &ff_asf_ext_stream_header)) { |
904
5d3dc3a6bbe7
audio in dvr-ms demuxing support by (John Donaghy <johnfdonaghy gmail com<)
michael
parents:
896
diff
changeset
|
444 int ext_len, payload_ext_ct, stream_ct; |
2064 | 445 uint32_t ext_d, leak_rate, stream_num; |
972 | 446 int64_t pos_ex_st; |
904
5d3dc3a6bbe7
audio in dvr-ms demuxing support by (John Donaghy <johnfdonaghy gmail com<)
michael
parents:
896
diff
changeset
|
447 pos_ex_st = url_ftell(pb); |
5d3dc3a6bbe7
audio in dvr-ms demuxing support by (John Donaghy <johnfdonaghy gmail com<)
michael
parents:
896
diff
changeset
|
448 |
1740
5ebac013d792
stealing a few field names from mplayers asf demuxer
michael
parents:
1722
diff
changeset
|
449 get_le64(pb); // starttime |
5ebac013d792
stealing a few field names from mplayers asf demuxer
michael
parents:
1722
diff
changeset
|
450 get_le64(pb); // endtime |
2064 | 451 leak_rate = get_le32(pb); // leak-datarate |
1740
5ebac013d792
stealing a few field names from mplayers asf demuxer
michael
parents:
1722
diff
changeset
|
452 get_le32(pb); // bucket-datasize |
5ebac013d792
stealing a few field names from mplayers asf demuxer
michael
parents:
1722
diff
changeset
|
453 get_le32(pb); // init-bucket-fullness |
5ebac013d792
stealing a few field names from mplayers asf demuxer
michael
parents:
1722
diff
changeset
|
454 get_le32(pb); // alt-leak-datarate |
5ebac013d792
stealing a few field names from mplayers asf demuxer
michael
parents:
1722
diff
changeset
|
455 get_le32(pb); // alt-bucket-datasize |
5ebac013d792
stealing a few field names from mplayers asf demuxer
michael
parents:
1722
diff
changeset
|
456 get_le32(pb); // alt-init-bucket-fullness |
5ebac013d792
stealing a few field names from mplayers asf demuxer
michael
parents:
1722
diff
changeset
|
457 get_le32(pb); // max-object-size |
5ebac013d792
stealing a few field names from mplayers asf demuxer
michael
parents:
1722
diff
changeset
|
458 get_le32(pb); // flags (reliable,seekable,no_cleanpoints?,resend-live-cleanpoints, rest of bits reserved) |
2064 | 459 stream_num = get_le16(pb); // stream-num |
1740
5ebac013d792
stealing a few field names from mplayers asf demuxer
michael
parents:
1722
diff
changeset
|
460 get_le16(pb); // stream-language-id-index |
5ebac013d792
stealing a few field names from mplayers asf demuxer
michael
parents:
1722
diff
changeset
|
461 get_le64(pb); // avg frametime in 100ns units |
5ebac013d792
stealing a few field names from mplayers asf demuxer
michael
parents:
1722
diff
changeset
|
462 stream_ct = get_le16(pb); //stream-name-count |
5ebac013d792
stealing a few field names from mplayers asf demuxer
michael
parents:
1722
diff
changeset
|
463 payload_ext_ct = get_le16(pb); //payload-extension-system-count |
904
5d3dc3a6bbe7
audio in dvr-ms demuxing support by (John Donaghy <johnfdonaghy gmail com<)
michael
parents:
896
diff
changeset
|
464 |
2064 | 465 if (stream_num < 128) |
466 bitrate[stream_num] = leak_rate; | |
467 | |
904
5d3dc3a6bbe7
audio in dvr-ms demuxing support by (John Donaghy <johnfdonaghy gmail com<)
michael
parents:
896
diff
changeset
|
468 for (i=0; i<stream_ct; i++){ |
5d3dc3a6bbe7
audio in dvr-ms demuxing support by (John Donaghy <johnfdonaghy gmail com<)
michael
parents:
896
diff
changeset
|
469 get_le16(pb); |
5d3dc3a6bbe7
audio in dvr-ms demuxing support by (John Donaghy <johnfdonaghy gmail com<)
michael
parents:
896
diff
changeset
|
470 ext_len = get_le16(pb); |
5d3dc3a6bbe7
audio in dvr-ms demuxing support by (John Donaghy <johnfdonaghy gmail com<)
michael
parents:
896
diff
changeset
|
471 url_fseek(pb, ext_len, SEEK_CUR); |
5d3dc3a6bbe7
audio in dvr-ms demuxing support by (John Donaghy <johnfdonaghy gmail com<)
michael
parents:
896
diff
changeset
|
472 } |
5d3dc3a6bbe7
audio in dvr-ms demuxing support by (John Donaghy <johnfdonaghy gmail com<)
michael
parents:
896
diff
changeset
|
473 |
5d3dc3a6bbe7
audio in dvr-ms demuxing support by (John Donaghy <johnfdonaghy gmail com<)
michael
parents:
896
diff
changeset
|
474 for (i=0; i<payload_ext_ct; i++){ |
5d3dc3a6bbe7
audio in dvr-ms demuxing support by (John Donaghy <johnfdonaghy gmail com<)
michael
parents:
896
diff
changeset
|
475 get_guid(pb, &g); |
5d3dc3a6bbe7
audio in dvr-ms demuxing support by (John Donaghy <johnfdonaghy gmail com<)
michael
parents:
896
diff
changeset
|
476 ext_d=get_le16(pb); |
5d3dc3a6bbe7
audio in dvr-ms demuxing support by (John Donaghy <johnfdonaghy gmail com<)
michael
parents:
896
diff
changeset
|
477 ext_len=get_le32(pb); |
5d3dc3a6bbe7
audio in dvr-ms demuxing support by (John Donaghy <johnfdonaghy gmail com<)
michael
parents:
896
diff
changeset
|
478 url_fseek(pb, ext_len, SEEK_CUR); |
5d3dc3a6bbe7
audio in dvr-ms demuxing support by (John Donaghy <johnfdonaghy gmail com<)
michael
parents:
896
diff
changeset
|
479 } |
5d3dc3a6bbe7
audio in dvr-ms demuxing support by (John Donaghy <johnfdonaghy gmail com<)
michael
parents:
896
diff
changeset
|
480 |
5d3dc3a6bbe7
audio in dvr-ms demuxing support by (John Donaghy <johnfdonaghy gmail com<)
michael
parents:
896
diff
changeset
|
481 // there could be a optional stream properties object to follow |
5d3dc3a6bbe7
audio in dvr-ms demuxing support by (John Donaghy <johnfdonaghy gmail com<)
michael
parents:
896
diff
changeset
|
482 // if so the next iteration will pick it up |
4747
0ad594176680
Add a special guidcmp function to compare ASF guids, to avoid the many
reimar
parents:
4743
diff
changeset
|
483 } else if (!guidcmp(&g, &ff_asf_head1_guid)) { |
0 | 484 int v1, v2; |
485 get_guid(pb, &g); | |
486 v1 = get_le32(pb); | |
487 v2 = get_le16(pb); | |
904
5d3dc3a6bbe7
audio in dvr-ms demuxing support by (John Donaghy <johnfdonaghy gmail com<)
michael
parents:
896
diff
changeset
|
488 #if 0 |
4747
0ad594176680
Add a special guidcmp function to compare ASF guids, to avoid the many
reimar
parents:
4743
diff
changeset
|
489 } else if (!guidcmp(&g, &ff_asf_codec_comment_header)) { |
0 | 490 int len, v1, n, num; |
491 char str[256], *q; | |
492 char tag[16]; | |
493 | |
494 get_guid(pb, &g); | |
495 print_guid(&g); | |
496 | |
497 n = get_le32(pb); | |
498 for(i=0;i<n;i++) { | |
499 num = get_le16(pb); /* stream number */ | |
500 get_str16(pb, str, sizeof(str)); | |
501 get_str16(pb, str, sizeof(str)); | |
502 len = get_le16(pb); | |
503 q = tag; | |
504 while (len > 0) { | |
505 v1 = get_byte(pb); | |
506 if ((q - tag) < sizeof(tag) - 1) | |
507 *q++ = v1; | |
508 len--; | |
509 } | |
510 *q = '\0'; | |
511 } | |
512 #endif | |
513 } else if (url_feof(pb)) { | |
3486 | 514 return -1; |
0 | 515 } else { |
516 url_fseek(pb, gsize - 24, SEEK_CUR); | |
517 } | |
518 } | |
519 get_guid(pb, &g); | |
520 get_le64(pb); | |
521 get_byte(pb); | |
522 get_byte(pb); | |
523 if (url_feof(pb)) | |
3486 | 524 return -1; |
0 | 525 asf->data_offset = url_ftell(pb); |
526 asf->packet_size_left = 0; | |
527 | |
1750 | 528 |
529 for(i=0; i<128; i++){ | |
530 int stream_num= asf->asfid2avid[i]; | |
2064 | 531 if(stream_num>=0){ |
3759
27537074f2a9
convert every muxer/demuxer to write/read sample_aspect_ratio from/to
aurel
parents:
3578
diff
changeset
|
532 AVStream *st = s->streams[stream_num]; |
27537074f2a9
convert every muxer/demuxer to write/read sample_aspect_ratio from/to
aurel
parents:
3578
diff
changeset
|
533 if (!st->codec->bit_rate) |
27537074f2a9
convert every muxer/demuxer to write/read sample_aspect_ratio from/to
aurel
parents:
3578
diff
changeset
|
534 st->codec->bit_rate = bitrate[i]; |
2064 | 535 if (dar[i].num > 0 && dar[i].den > 0) |
3759
27537074f2a9
convert every muxer/demuxer to write/read sample_aspect_ratio from/to
aurel
parents:
3578
diff
changeset
|
536 av_reduce(&st->sample_aspect_ratio.num, |
27537074f2a9
convert every muxer/demuxer to write/read sample_aspect_ratio from/to
aurel
parents:
3578
diff
changeset
|
537 &st->sample_aspect_ratio.den, |
2069
42d459116315
cosmetics: Fix indentation after last commit, patch by Zuxy Meng.
diego
parents:
2064
diff
changeset
|
538 dar[i].num, dar[i].den, INT_MAX); |
4508 | 539 //av_log(s, AV_LOG_ERROR, "dar %d:%d sar=%d:%d\n", dar[i].num, dar[i].den, st->sample_aspect_ratio.num, st->sample_aspect_ratio.den); |
1750 | 540 } |
541 } | |
542 | |
0 | 543 return 0; |
544 } | |
545 | |
546 #define DO_2BITS(bits, var, defval) \ | |
547 switch (bits & 3) \ | |
548 { \ | |
549 case 3: var = get_le32(pb); rsize += 4; break; \ | |
550 case 2: var = get_le16(pb); rsize += 2; break; \ | |
551 case 1: var = get_byte(pb); rsize++; break; \ | |
552 default: var = defval; break; \ | |
553 } | |
554 | |
4121
55e94f2a8ac1
Make asf_get_packet() and asf_parse_packet() public for use in RTSP-MS and
rbultje
parents:
4120
diff
changeset
|
555 int ff_asf_get_packet(AVFormatContext *s, ByteIOContext *pb) |
0 | 556 { |
557 ASFContext *asf = s->priv_data; | |
558 uint32_t packet_length, padsize; | |
1967 | 559 int rsize = 8; |
1722
cb0dc6abf4d1
make the asf demuxer resistant against insertion/deletion errors
michael
parents:
1716
diff
changeset
|
560 int c, d, e, off; |
cb0dc6abf4d1
make the asf demuxer resistant against insertion/deletion errors
michael
parents:
1716
diff
changeset
|
561 |
4066
10f7232a3545
Do not access s->gb directly in functions that have a local copy of that
rbultje
parents:
4058
diff
changeset
|
562 off= (url_ftell(pb) - s->data_offset) % asf->packet_size + 3; |
885 | 563 |
1722
cb0dc6abf4d1
make the asf demuxer resistant against insertion/deletion errors
michael
parents:
1716
diff
changeset
|
564 c=d=e=-1; |
cb0dc6abf4d1
make the asf demuxer resistant against insertion/deletion errors
michael
parents:
1716
diff
changeset
|
565 while(off-- > 0){ |
cb0dc6abf4d1
make the asf demuxer resistant against insertion/deletion errors
michael
parents:
1716
diff
changeset
|
566 c=d; d=e; |
cb0dc6abf4d1
make the asf demuxer resistant against insertion/deletion errors
michael
parents:
1716
diff
changeset
|
567 e= get_byte(pb); |
cb0dc6abf4d1
make the asf demuxer resistant against insertion/deletion errors
michael
parents:
1716
diff
changeset
|
568 if(c == 0x82 && !d && !e) |
cb0dc6abf4d1
make the asf demuxer resistant against insertion/deletion errors
michael
parents:
1716
diff
changeset
|
569 break; |
cb0dc6abf4d1
make the asf demuxer resistant against insertion/deletion errors
michael
parents:
1716
diff
changeset
|
570 } |
cb0dc6abf4d1
make the asf demuxer resistant against insertion/deletion errors
michael
parents:
1716
diff
changeset
|
571 |
0 | 572 if (c != 0x82) { |
573 if (!url_feof(pb)) | |
887 | 574 av_log(s, AV_LOG_ERROR, "ff asf bad header %x at:%"PRId64"\n", c, url_ftell(pb)); |
0 | 575 } |
1967 | 576 if ((c & 0x8f) == 0x82) { |
1722
cb0dc6abf4d1
make the asf demuxer resistant against insertion/deletion errors
michael
parents:
1716
diff
changeset
|
577 if (d || e) { |
0 | 578 if (!url_feof(pb)) |
887 | 579 av_log(s, AV_LOG_ERROR, "ff asf bad non zero\n"); |
1716 | 580 return -1; |
887 | 581 } |
1967 | 582 c= get_byte(pb); |
1722
cb0dc6abf4d1
make the asf demuxer resistant against insertion/deletion errors
michael
parents:
1716
diff
changeset
|
583 d= get_byte(pb); |
1967 | 584 rsize+=3; |
585 }else{ | |
586 url_fseek(pb, -1, SEEK_CUR); //FIXME | |
0 | 587 } |
588 | |
1967 | 589 asf->packet_flags = c; |
590 asf->packet_property = d; | |
0 | 591 |
592 DO_2BITS(asf->packet_flags >> 5, packet_length, asf->packet_size); | |
593 DO_2BITS(asf->packet_flags >> 1, padsize, 0); // sequence ignored | |
594 DO_2BITS(asf->packet_flags >> 3, padsize, 0); // padding length | |
595 | |
1333 | 596 //the following checks prevent overflows and infinite loops |
597 if(packet_length >= (1U<<29)){ | |
598 av_log(s, AV_LOG_ERROR, "invalid packet_length %d at:%"PRId64"\n", packet_length, url_ftell(pb)); | |
1713 | 599 return -1; |
1333 | 600 } |
1715 | 601 if(padsize >= packet_length){ |
1333 | 602 av_log(s, AV_LOG_ERROR, "invalid padsize %d at:%"PRId64"\n", padsize, url_ftell(pb)); |
1713 | 603 return -1; |
1333 | 604 } |
605 | |
0 | 606 asf->packet_timestamp = get_le32(pb); |
607 get_le16(pb); /* duration */ | |
608 // rsize has at least 11 bytes which have to be present | |
609 | |
610 if (asf->packet_flags & 0x01) { | |
887 | 611 asf->packet_segsizetype = get_byte(pb); rsize++; |
0 | 612 asf->packet_segments = asf->packet_segsizetype & 0x3f; |
613 } else { | |
887 | 614 asf->packet_segments = 1; |
0 | 615 asf->packet_segsizetype = 0x80; |
616 } | |
617 asf->packet_size_left = packet_length - padsize - rsize; | |
618 if (packet_length < asf->hdr.min_pktsize) | |
619 padsize += asf->hdr.min_pktsize - packet_length; | |
620 asf->packet_padsize = padsize; | |
3578 | 621 dprintf(s, "packet: size=%d padsize=%d left=%d\n", asf->packet_size, asf->packet_padsize, asf->packet_size_left); |
0 | 622 return 0; |
623 } | |
624 | |
1708 | 625 /** |
626 * | |
627 * @return <0 if error | |
628 */ | |
4120
a22587bda6cf
Add a ByteIOContext argument to ASF functions that will be shared with the
rbultje
parents:
4095
diff
changeset
|
629 static int asf_read_frame_header(AVFormatContext *s, ByteIOContext *pb){ |
1708 | 630 ASFContext *asf = s->priv_data; |
631 int rsize = 1; | |
632 int num = get_byte(pb); | |
1776 | 633 int64_t ts0, ts1; |
1708 | 634 |
635 asf->packet_segments--; | |
636 asf->packet_key_frame = num >> 7; | |
637 asf->stream_index = asf->asfid2avid[num & 0x7f]; | |
638 // sequence should be ignored! | |
639 DO_2BITS(asf->packet_property >> 4, asf->packet_seq, 0); | |
640 DO_2BITS(asf->packet_property >> 2, asf->packet_frag_offset, 0); | |
641 DO_2BITS(asf->packet_property, asf->packet_replic_size, 0); | |
642 //printf("key:%d stream:%d seq:%d offset:%d replic_size:%d\n", asf->packet_key_frame, asf->stream_index, asf->packet_seq, //asf->packet_frag_offset, asf->packet_replic_size); | |
643 if (asf->packet_replic_size >= 8) { | |
644 asf->packet_obj_size = get_le32(pb); | |
645 if(asf->packet_obj_size >= (1<<24) || asf->packet_obj_size <= 0){ | |
646 av_log(s, AV_LOG_ERROR, "packet_obj_size invalid\n"); | |
647 return -1; | |
648 } | |
649 asf->packet_frag_timestamp = get_le32(pb); // timestamp | |
1776 | 650 if(asf->packet_replic_size >= 8+38+4){ |
651 // for(i=0; i<asf->packet_replic_size-8; i++) | |
652 // av_log(s, AV_LOG_DEBUG, "%02X ",get_byte(pb)); | |
653 // av_log(s, AV_LOG_DEBUG, "\n"); | |
654 url_fskip(pb, 10); | |
655 ts0= get_le64(pb); | |
656 ts1= get_le64(pb); | |
657 url_fskip(pb, 12); | |
658 get_le32(pb); | |
659 url_fskip(pb, asf->packet_replic_size - 8 - 38 - 4); | |
660 if(ts0!= -1) asf->packet_frag_timestamp= ts0/10000; | |
661 else asf->packet_frag_timestamp= AV_NOPTS_VALUE; | |
662 }else | |
663 url_fskip(pb, asf->packet_replic_size - 8); | |
1708 | 664 rsize += asf->packet_replic_size; // FIXME - check validity |
665 } else if (asf->packet_replic_size==1){ | |
2855 | 666 // multipacket - frag_offset is beginning timestamp |
1708 | 667 asf->packet_time_start = asf->packet_frag_offset; |
668 asf->packet_frag_offset = 0; | |
669 asf->packet_frag_timestamp = asf->packet_timestamp; | |
670 | |
671 asf->packet_time_delta = get_byte(pb); | |
672 rsize++; | |
673 }else if(asf->packet_replic_size!=0){ | |
674 av_log(s, AV_LOG_ERROR, "unexpected packet_replic_size of %d\n", asf->packet_replic_size); | |
675 return -1; | |
676 } | |
677 if (asf->packet_flags & 0x01) { | |
678 DO_2BITS(asf->packet_segsizetype >> 6, asf->packet_frag_size, 0); // 0 is illegal | |
1712 | 679 if(asf->packet_frag_size > asf->packet_size_left - rsize){ |
680 av_log(s, AV_LOG_ERROR, "packet_frag_size is invalid\n"); | |
681 return -1; | |
682 } | |
1708 | 683 //printf("Fragsize %d\n", asf->packet_frag_size); |
684 } else { | |
685 asf->packet_frag_size = asf->packet_size_left - rsize; | |
686 //printf("Using rest %d %d %d\n", asf->packet_frag_size, asf->packet_size_left, rsize); | |
687 } | |
688 if (asf->packet_replic_size == 1) { | |
689 asf->packet_multi_size = asf->packet_frag_size; | |
690 if (asf->packet_multi_size > asf->packet_size_left) | |
691 return -1; | |
692 } | |
693 asf->packet_size_left -= rsize; | |
694 //printf("___objsize____ %d %d rs:%d\n", asf->packet_obj_size, asf->packet_frag_offset, rsize); | |
695 | |
696 return 0; | |
697 } | |
698 | |
4121
55e94f2a8ac1
Make asf_get_packet() and asf_parse_packet() public for use in RTSP-MS and
rbultje
parents:
4120
diff
changeset
|
699 int ff_asf_parse_packet(AVFormatContext *s, ByteIOContext *pb, AVPacket *pkt) |
0 | 700 { |
701 ASFContext *asf = s->priv_data; | |
702 ASFStream *asf_st = 0; | |
703 for (;;) { | |
1713 | 704 if(url_feof(pb)) |
2274
b21c2af60bc9
Replace all occurrences of AVERROR_IO with AVERROR(EIO).
takis
parents:
2169
diff
changeset
|
705 return AVERROR(EIO); |
887 | 706 if (asf->packet_size_left < FRAME_HEADER_SIZE |
707 || asf->packet_segments < 1) { | |
708 //asf->packet_size_left <= asf->packet_padsize) { | |
709 int ret = asf->packet_size_left + asf->packet_padsize; | |
1443
404048ea11bc
Replace most of the %lld and %llx by their (cleaner) PRI*64 counterparts.
diego
parents:
1415
diff
changeset
|
710 //printf("PacketLeftSize:%d Pad:%d Pos:%"PRId64"\n", asf->packet_size_left, asf->packet_padsize, url_ftell(pb)); |
1333 | 711 assert(ret>=0); |
887 | 712 /* fail safe */ |
713 url_fskip(pb, ret); | |
1707
7e12a19c140f
more correct packet alignment check and correction
michael
parents:
1706
diff
changeset
|
714 |
4066
10f7232a3545
Do not access s->gb directly in functions that have a local copy of that
rbultje
parents:
4058
diff
changeset
|
715 asf->packet_pos= url_ftell(pb); |
1206
e60bf67d9bf8
The reader ignores the size of the ASF data object and keeps on
gpoirier
parents:
1172
diff
changeset
|
716 if (asf->data_object_size != (uint64_t)-1 && |
e60bf67d9bf8
The reader ignores the size of the ASF data object and keeps on
gpoirier
parents:
1172
diff
changeset
|
717 (asf->packet_pos - asf->data_object_offset >= asf->data_object_size)) |
2274
b21c2af60bc9
Replace all occurrences of AVERROR_IO with AVERROR(EIO).
takis
parents:
2169
diff
changeset
|
718 return AVERROR(EIO); /* Do not exceed the size of the data object */ |
4095
27f4b31bc790
Separate the packet fetching from the data reading, so that the data reading
rbultje
parents:
4068
diff
changeset
|
719 return 1; |
887 | 720 } |
721 if (asf->packet_time_start == 0) { | |
4167
81f64d590675
Don't use s->pb if a local ByteIOContext was already provided by the calling
rbultje
parents:
4121
diff
changeset
|
722 if(asf_read_frame_header(s, pb) < 0){ |
1708 | 723 asf->packet_segments= 0; |
1696 | 724 continue; |
352
c5ea5cdb5b58
replic_size==0 fix, needed so that G.726 asf file, so ffmpeg can at least decode the video without segfaulting
michael
parents:
351
diff
changeset
|
725 } |
887 | 726 if (asf->stream_index < 0 |
708 | 727 || s->streams[asf->stream_index]->discard >= AVDISCARD_ALL |
728 || (!asf->packet_key_frame && s->streams[asf->stream_index]->discard >= AVDISCARD_NONKEY) | |
729 ) { | |
0 | 730 asf->packet_time_start = 0; |
887 | 731 /* unhandled packet (should not happen) */ |
732 url_fskip(pb, asf->packet_frag_size); | |
733 asf->packet_size_left -= asf->packet_frag_size; | |
652 | 734 if(asf->stream_index < 0) |
1708 | 735 av_log(s, AV_LOG_ERROR, "ff asf skip %d (unknown stream)\n", asf->packet_frag_size); |
0 | 736 continue; |
887 | 737 } |
738 asf->asf_st = s->streams[asf->stream_index]->priv_data; | |
739 } | |
740 asf_st = asf->asf_st; | |
0 | 741 |
887 | 742 if (asf->packet_replic_size == 1) { |
2855 | 743 // frag_offset is here used as the beginning timestamp |
887 | 744 asf->packet_frag_timestamp = asf->packet_time_start; |
745 asf->packet_time_start += asf->packet_time_delta; | |
746 asf->packet_obj_size = asf->packet_frag_size = get_byte(pb); | |
747 asf->packet_size_left--; | |
0 | 748 asf->packet_multi_size--; |
887 | 749 if (asf->packet_multi_size < asf->packet_obj_size) |
750 { | |
751 asf->packet_time_start = 0; | |
752 url_fskip(pb, asf->packet_multi_size); | |
753 asf->packet_size_left -= asf->packet_multi_size; | |
0 | 754 continue; |
887 | 755 } |
756 asf->packet_multi_size -= asf->packet_obj_size; | |
757 //printf("COMPRESS size %d %d %d ms:%d\n", asf->packet_obj_size, asf->packet_frag_timestamp, asf->packet_size_left, asf->packet_multi_size); | |
758 } | |
2285 | 759 if( /*asf->packet_frag_size == asf->packet_obj_size*/ |
760 asf_st->frag_offset + asf->packet_frag_size <= asf_st->pkt.size | |
761 && asf_st->frag_offset + asf->packet_frag_size > asf->packet_obj_size){ | |
762 av_log(s, AV_LOG_INFO, "ignoring invalid packet_obj_size (%d %d %d %d)\n", | |
763 asf_st->frag_offset, asf->packet_frag_size, | |
764 asf->packet_obj_size, asf_st->pkt.size); | |
765 asf->packet_obj_size= asf_st->pkt.size; | |
766 } | |
767 | |
1744 | 768 if ( asf_st->pkt.size != asf->packet_obj_size |
769 || asf_st->frag_offset + asf->packet_frag_size > asf_st->pkt.size) { //FIXME is this condition sufficient? | |
1710
33a16d903dcc
replace nonsense code by something which makes at least some sense
michael
parents:
1709
diff
changeset
|
770 if(asf_st->pkt.data){ |
33a16d903dcc
replace nonsense code by something which makes at least some sense
michael
parents:
1709
diff
changeset
|
771 av_log(s, AV_LOG_INFO, "freeing incomplete packet size %d, new %d\n", asf_st->pkt.size, asf->packet_obj_size); |
33a16d903dcc
replace nonsense code by something which makes at least some sense
michael
parents:
1709
diff
changeset
|
772 asf_st->frag_offset = 0; |
33a16d903dcc
replace nonsense code by something which makes at least some sense
michael
parents:
1709
diff
changeset
|
773 av_free_packet(&asf_st->pkt); |
33a16d903dcc
replace nonsense code by something which makes at least some sense
michael
parents:
1709
diff
changeset
|
774 } |
887 | 775 /* new packet */ |
776 av_new_packet(&asf_st->pkt, asf->packet_obj_size); | |
777 asf_st->seq = asf->packet_seq; | |
4022 | 778 asf_st->pkt.dts = asf->packet_frag_timestamp; |
887 | 779 asf_st->pkt.stream_index = asf->stream_index; |
885 | 780 asf_st->pkt.pos = |
781 asf_st->packet_pos= asf->packet_pos; | |
782 //printf("new packet: stream:%d key:%d packet_key:%d audio:%d size:%d\n", | |
349 | 783 //asf->stream_index, asf->packet_key_frame, asf_st->pkt.flags & PKT_FLAG_KEY, |
820
feca73904e67
changing AVCodecContext codec -> *codec in AVStream so additions to AVCodecContext dont randomize AVStream and break binary compatibility
michael
parents:
792
diff
changeset
|
784 //s->streams[asf->stream_index]->codec->codec_type == CODEC_TYPE_AUDIO, asf->packet_obj_size); |
887 | 785 if (s->streams[asf->stream_index]->codec->codec_type == CODEC_TYPE_AUDIO) |
786 asf->packet_key_frame = 1; | |
787 if (asf->packet_key_frame) | |
788 asf_st->pkt.flags |= PKT_FLAG_KEY; | |
789 } | |
0 | 790 |
887 | 791 /* read data */ |
792 //printf("READ PACKET s:%d os:%d o:%d,%d l:%d DATA:%p\n", | |
793 // asf->packet_size, asf_st->pkt.size, asf->packet_frag_offset, | |
794 // asf_st->frag_offset, asf->packet_frag_size, asf_st->pkt.data); | |
795 asf->packet_size_left -= asf->packet_frag_size; | |
796 if (asf->packet_size_left < 0) | |
0 | 797 continue; |
1709 | 798 |
799 if( asf->packet_frag_offset >= asf_st->pkt.size | |
800 || asf->packet_frag_size > asf_st->pkt.size - asf->packet_frag_offset){ | |
801 av_log(s, AV_LOG_ERROR, "packet fragment position invalid %u,%u not in %u\n", | |
802 asf->packet_frag_offset, asf->packet_frag_size, asf_st->pkt.size); | |
803 continue; | |
804 } | |
805 | |
887 | 806 get_buffer(pb, asf_st->pkt.data + asf->packet_frag_offset, |
807 asf->packet_frag_size); | |
2652 | 808 if (s->key && s->keylen == 20) |
809 ff_asfcrypt_dec(s->key, asf_st->pkt.data + asf->packet_frag_offset, | |
810 asf->packet_frag_size); | |
887 | 811 asf_st->frag_offset += asf->packet_frag_size; |
812 /* test if whole packet is read */ | |
813 if (asf_st->frag_offset == asf_st->pkt.size) { | |
2416
1a2f353ac291
workaround ms (lack of) intelligence in their design of dvr-ms
michael
parents:
2392
diff
changeset
|
814 //workaround for macroshit radio DVR-MS files |
1a2f353ac291
workaround ms (lack of) intelligence in their design of dvr-ms
michael
parents:
2392
diff
changeset
|
815 if( s->streams[asf->stream_index]->codec->codec_id == CODEC_ID_MPEG2VIDEO |
1a2f353ac291
workaround ms (lack of) intelligence in their design of dvr-ms
michael
parents:
2392
diff
changeset
|
816 && asf_st->pkt.size > 100){ |
1a2f353ac291
workaround ms (lack of) intelligence in their design of dvr-ms
michael
parents:
2392
diff
changeset
|
817 int i; |
1a2f353ac291
workaround ms (lack of) intelligence in their design of dvr-ms
michael
parents:
2392
diff
changeset
|
818 for(i=0; i<asf_st->pkt.size && !asf_st->pkt.data[i]; i++); |
1a2f353ac291
workaround ms (lack of) intelligence in their design of dvr-ms
michael
parents:
2392
diff
changeset
|
819 if(i == asf_st->pkt.size){ |
1a2f353ac291
workaround ms (lack of) intelligence in their design of dvr-ms
michael
parents:
2392
diff
changeset
|
820 av_log(s, AV_LOG_DEBUG, "discarding ms fart\n"); |
1a2f353ac291
workaround ms (lack of) intelligence in their design of dvr-ms
michael
parents:
2392
diff
changeset
|
821 asf_st->frag_offset = 0; |
1a2f353ac291
workaround ms (lack of) intelligence in their design of dvr-ms
michael
parents:
2392
diff
changeset
|
822 av_free_packet(&asf_st->pkt); |
1a2f353ac291
workaround ms (lack of) intelligence in their design of dvr-ms
michael
parents:
2392
diff
changeset
|
823 continue; |
1a2f353ac291
workaround ms (lack of) intelligence in their design of dvr-ms
michael
parents:
2392
diff
changeset
|
824 } |
1a2f353ac291
workaround ms (lack of) intelligence in their design of dvr-ms
michael
parents:
2392
diff
changeset
|
825 } |
1a2f353ac291
workaround ms (lack of) intelligence in their design of dvr-ms
michael
parents:
2392
diff
changeset
|
826 |
887 | 827 /* return packet */ |
828 if (asf_st->ds_span > 1) { | |
1700
77bd711c0aed
adding a few checks to the audio packet descrambling, this should hopefully catch all related out of array accesses
michael
parents:
1699
diff
changeset
|
829 if(asf_st->pkt.size != asf_st->ds_packet_size * asf_st->ds_span){ |
2319 | 830 av_log(s, AV_LOG_ERROR, "pkt.size != ds_packet_size * ds_span (%d %d %d)\n", asf_st->pkt.size, asf_st->ds_packet_size, asf_st->ds_span); |
1700
77bd711c0aed
adding a few checks to the audio packet descrambling, this should hopefully catch all related out of array accesses
michael
parents:
1699
diff
changeset
|
831 }else{ |
887 | 832 /* packet descrambling */ |
1332 | 833 uint8_t *newdata = av_malloc(asf_st->pkt.size); |
887 | 834 if (newdata) { |
835 int offset = 0; | |
836 while (offset < asf_st->pkt.size) { | |
837 int off = offset / asf_st->ds_chunk_size; | |
838 int row = off / asf_st->ds_span; | |
839 int col = off % asf_st->ds_span; | |
840 int idx = row + col * asf_st->ds_packet_size / asf_st->ds_chunk_size; | |
841 //printf("off:%d row:%d col:%d idx:%d\n", off, row, col, idx); | |
1700
77bd711c0aed
adding a few checks to the audio packet descrambling, this should hopefully catch all related out of array accesses
michael
parents:
1699
diff
changeset
|
842 |
77bd711c0aed
adding a few checks to the audio packet descrambling, this should hopefully catch all related out of array accesses
michael
parents:
1699
diff
changeset
|
843 assert(offset + asf_st->ds_chunk_size <= asf_st->pkt.size); |
77bd711c0aed
adding a few checks to the audio packet descrambling, this should hopefully catch all related out of array accesses
michael
parents:
1699
diff
changeset
|
844 assert(idx+1 <= asf_st->pkt.size / asf_st->ds_chunk_size); |
887 | 845 memcpy(newdata + offset, |
846 asf_st->pkt.data + idx * asf_st->ds_chunk_size, | |
847 asf_st->ds_chunk_size); | |
848 offset += asf_st->ds_chunk_size; | |
849 } | |
850 av_free(asf_st->pkt.data); | |
851 asf_st->pkt.data = newdata; | |
852 } | |
1700
77bd711c0aed
adding a few checks to the audio packet descrambling, this should hopefully catch all related out of array accesses
michael
parents:
1699
diff
changeset
|
853 } |
887 | 854 } |
855 asf_st->frag_offset = 0; | |
1699 | 856 *pkt= asf_st->pkt; |
887 | 857 //printf("packet %d %d\n", asf_st->pkt.size, asf->packet_frag_size); |
858 asf_st->pkt.size = 0; | |
859 asf_st->pkt.data = 0; | |
860 break; // packet completed | |
861 } | |
0 | 862 } |
863 return 0; | |
864 } | |
865 | |
4095
27f4b31bc790
Separate the packet fetching from the data reading, so that the data reading
rbultje
parents:
4068
diff
changeset
|
866 static int asf_read_packet(AVFormatContext *s, AVPacket *pkt) |
27f4b31bc790
Separate the packet fetching from the data reading, so that the data reading
rbultje
parents:
4068
diff
changeset
|
867 { |
27f4b31bc790
Separate the packet fetching from the data reading, so that the data reading
rbultje
parents:
4068
diff
changeset
|
868 ASFContext *asf = s->priv_data; |
27f4b31bc790
Separate the packet fetching from the data reading, so that the data reading
rbultje
parents:
4068
diff
changeset
|
869 |
27f4b31bc790
Separate the packet fetching from the data reading, so that the data reading
rbultje
parents:
4068
diff
changeset
|
870 for (;;) { |
27f4b31bc790
Separate the packet fetching from the data reading, so that the data reading
rbultje
parents:
4068
diff
changeset
|
871 int ret; |
27f4b31bc790
Separate the packet fetching from the data reading, so that the data reading
rbultje
parents:
4068
diff
changeset
|
872 |
27f4b31bc790
Separate the packet fetching from the data reading, so that the data reading
rbultje
parents:
4068
diff
changeset
|
873 /* parse cached packets, if any */ |
4121
55e94f2a8ac1
Make asf_get_packet() and asf_parse_packet() public for use in RTSP-MS and
rbultje
parents:
4120
diff
changeset
|
874 if ((ret = ff_asf_parse_packet(s, s->pb, pkt)) <= 0) |
4095
27f4b31bc790
Separate the packet fetching from the data reading, so that the data reading
rbultje
parents:
4068
diff
changeset
|
875 return ret; |
4121
55e94f2a8ac1
Make asf_get_packet() and asf_parse_packet() public for use in RTSP-MS and
rbultje
parents:
4120
diff
changeset
|
876 if ((ret = ff_asf_get_packet(s, s->pb)) < 0) |
4095
27f4b31bc790
Separate the packet fetching from the data reading, so that the data reading
rbultje
parents:
4068
diff
changeset
|
877 assert(asf->packet_size_left < FRAME_HEADER_SIZE || asf->packet_segments < 1); |
27f4b31bc790
Separate the packet fetching from the data reading, so that the data reading
rbultje
parents:
4068
diff
changeset
|
878 asf->packet_time_start = 0; |
27f4b31bc790
Separate the packet fetching from the data reading, so that the data reading
rbultje
parents:
4068
diff
changeset
|
879 } |
27f4b31bc790
Separate the packet fetching from the data reading, so that the data reading
rbultje
parents:
4068
diff
changeset
|
880 |
27f4b31bc790
Separate the packet fetching from the data reading, so that the data reading
rbultje
parents:
4068
diff
changeset
|
881 return 0; |
27f4b31bc790
Separate the packet fetching from the data reading, so that the data reading
rbultje
parents:
4068
diff
changeset
|
882 } |
27f4b31bc790
Separate the packet fetching from the data reading, so that the data reading
rbultje
parents:
4068
diff
changeset
|
883 |
347
2b485a3c5cfb
seeking in single stream asf patch by ("Kevin Kuphal" <kevin dot kuphal at sitecity dot net>)
michael
parents:
341
diff
changeset
|
884 // Added to support seeking after packets have been read |
2b485a3c5cfb
seeking in single stream asf patch by ("Kevin Kuphal" <kevin dot kuphal at sitecity dot net>)
michael
parents:
341
diff
changeset
|
885 // If information is not reset, read_packet fails due to |
2b485a3c5cfb
seeking in single stream asf patch by ("Kevin Kuphal" <kevin dot kuphal at sitecity dot net>)
michael
parents:
341
diff
changeset
|
886 // leftover information from previous reads |
2b485a3c5cfb
seeking in single stream asf patch by ("Kevin Kuphal" <kevin dot kuphal at sitecity dot net>)
michael
parents:
341
diff
changeset
|
887 static void asf_reset_header(AVFormatContext *s) |
2b485a3c5cfb
seeking in single stream asf patch by ("Kevin Kuphal" <kevin dot kuphal at sitecity dot net>)
michael
parents:
341
diff
changeset
|
888 { |
2b485a3c5cfb
seeking in single stream asf patch by ("Kevin Kuphal" <kevin dot kuphal at sitecity dot net>)
michael
parents:
341
diff
changeset
|
889 ASFContext *asf = s->priv_data; |
349 | 890 ASFStream *asf_st; |
891 int i; | |
347
2b485a3c5cfb
seeking in single stream asf patch by ("Kevin Kuphal" <kevin dot kuphal at sitecity dot net>)
michael
parents:
341
diff
changeset
|
892 |
2b485a3c5cfb
seeking in single stream asf patch by ("Kevin Kuphal" <kevin dot kuphal at sitecity dot net>)
michael
parents:
341
diff
changeset
|
893 asf->packet_nb_frames = 0; |
2b485a3c5cfb
seeking in single stream asf patch by ("Kevin Kuphal" <kevin dot kuphal at sitecity dot net>)
michael
parents:
341
diff
changeset
|
894 asf->packet_size_left = 0; |
2b485a3c5cfb
seeking in single stream asf patch by ("Kevin Kuphal" <kevin dot kuphal at sitecity dot net>)
michael
parents:
341
diff
changeset
|
895 asf->packet_segments = 0; |
2b485a3c5cfb
seeking in single stream asf patch by ("Kevin Kuphal" <kevin dot kuphal at sitecity dot net>)
michael
parents:
341
diff
changeset
|
896 asf->packet_flags = 0; |
2b485a3c5cfb
seeking in single stream asf patch by ("Kevin Kuphal" <kevin dot kuphal at sitecity dot net>)
michael
parents:
341
diff
changeset
|
897 asf->packet_property = 0; |
2b485a3c5cfb
seeking in single stream asf patch by ("Kevin Kuphal" <kevin dot kuphal at sitecity dot net>)
michael
parents:
341
diff
changeset
|
898 asf->packet_timestamp = 0; |
2b485a3c5cfb
seeking in single stream asf patch by ("Kevin Kuphal" <kevin dot kuphal at sitecity dot net>)
michael
parents:
341
diff
changeset
|
899 asf->packet_segsizetype = 0; |
2b485a3c5cfb
seeking in single stream asf patch by ("Kevin Kuphal" <kevin dot kuphal at sitecity dot net>)
michael
parents:
341
diff
changeset
|
900 asf->packet_segments = 0; |
2b485a3c5cfb
seeking in single stream asf patch by ("Kevin Kuphal" <kevin dot kuphal at sitecity dot net>)
michael
parents:
341
diff
changeset
|
901 asf->packet_seq = 0; |
2b485a3c5cfb
seeking in single stream asf patch by ("Kevin Kuphal" <kevin dot kuphal at sitecity dot net>)
michael
parents:
341
diff
changeset
|
902 asf->packet_replic_size = 0; |
2b485a3c5cfb
seeking in single stream asf patch by ("Kevin Kuphal" <kevin dot kuphal at sitecity dot net>)
michael
parents:
341
diff
changeset
|
903 asf->packet_key_frame = 0; |
2b485a3c5cfb
seeking in single stream asf patch by ("Kevin Kuphal" <kevin dot kuphal at sitecity dot net>)
michael
parents:
341
diff
changeset
|
904 asf->packet_padsize = 0; |
2b485a3c5cfb
seeking in single stream asf patch by ("Kevin Kuphal" <kevin dot kuphal at sitecity dot net>)
michael
parents:
341
diff
changeset
|
905 asf->packet_frag_offset = 0; |
2b485a3c5cfb
seeking in single stream asf patch by ("Kevin Kuphal" <kevin dot kuphal at sitecity dot net>)
michael
parents:
341
diff
changeset
|
906 asf->packet_frag_size = 0; |
2b485a3c5cfb
seeking in single stream asf patch by ("Kevin Kuphal" <kevin dot kuphal at sitecity dot net>)
michael
parents:
341
diff
changeset
|
907 asf->packet_frag_timestamp = 0; |
2b485a3c5cfb
seeking in single stream asf patch by ("Kevin Kuphal" <kevin dot kuphal at sitecity dot net>)
michael
parents:
341
diff
changeset
|
908 asf->packet_multi_size = 0; |
2b485a3c5cfb
seeking in single stream asf patch by ("Kevin Kuphal" <kevin dot kuphal at sitecity dot net>)
michael
parents:
341
diff
changeset
|
909 asf->packet_obj_size = 0; |
2b485a3c5cfb
seeking in single stream asf patch by ("Kevin Kuphal" <kevin dot kuphal at sitecity dot net>)
michael
parents:
341
diff
changeset
|
910 asf->packet_time_delta = 0; |
2b485a3c5cfb
seeking in single stream asf patch by ("Kevin Kuphal" <kevin dot kuphal at sitecity dot net>)
michael
parents:
341
diff
changeset
|
911 asf->packet_time_start = 0; |
885 | 912 |
349 | 913 for(i=0; i<s->nb_streams; i++){ |
914 asf_st= s->streams[i]->priv_data; | |
915 av_free_packet(&asf_st->pkt); | |
916 asf_st->frag_offset=0; | |
917 asf_st->seq=0; | |
918 } | |
919 asf->asf_st= NULL; | |
347
2b485a3c5cfb
seeking in single stream asf patch by ("Kevin Kuphal" <kevin dot kuphal at sitecity dot net>)
michael
parents:
341
diff
changeset
|
920 } |
2b485a3c5cfb
seeking in single stream asf patch by ("Kevin Kuphal" <kevin dot kuphal at sitecity dot net>)
michael
parents:
341
diff
changeset
|
921 |
2603
4a3957734e85
cosmetics: Move asf_read_close() down to get rid of a forward declaration.
diego
parents:
2599
diff
changeset
|
922 static int asf_read_close(AVFormatContext *s) |
4a3957734e85
cosmetics: Move asf_read_close() down to get rid of a forward declaration.
diego
parents:
2599
diff
changeset
|
923 { |
4a3957734e85
cosmetics: Move asf_read_close() down to get rid of a forward declaration.
diego
parents:
2599
diff
changeset
|
924 int i; |
4a3957734e85
cosmetics: Move asf_read_close() down to get rid of a forward declaration.
diego
parents:
2599
diff
changeset
|
925 |
4a3957734e85
cosmetics: Move asf_read_close() down to get rid of a forward declaration.
diego
parents:
2599
diff
changeset
|
926 asf_reset_header(s); |
4a3957734e85
cosmetics: Move asf_read_close() down to get rid of a forward declaration.
diego
parents:
2599
diff
changeset
|
927 for(i=0;i<s->nb_streams;i++) { |
4a3957734e85
cosmetics: Move asf_read_close() down to get rid of a forward declaration.
diego
parents:
2599
diff
changeset
|
928 AVStream *st = s->streams[i]; |
4a3957734e85
cosmetics: Move asf_read_close() down to get rid of a forward declaration.
diego
parents:
2599
diff
changeset
|
929 av_free(st->codec->palctrl); |
4a3957734e85
cosmetics: Move asf_read_close() down to get rid of a forward declaration.
diego
parents:
2599
diff
changeset
|
930 } |
4a3957734e85
cosmetics: Move asf_read_close() down to get rid of a forward declaration.
diego
parents:
2599
diff
changeset
|
931 return 0; |
4a3957734e85
cosmetics: Move asf_read_close() down to get rid of a forward declaration.
diego
parents:
2599
diff
changeset
|
932 } |
4a3957734e85
cosmetics: Move asf_read_close() down to get rid of a forward declaration.
diego
parents:
2599
diff
changeset
|
933 |
437
50bae308f71e
moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents:
373
diff
changeset
|
934 static int64_t asf_read_pts(AVFormatContext *s, int stream_index, int64_t *ppos, int64_t pos_limit) |
347
2b485a3c5cfb
seeking in single stream asf patch by ("Kevin Kuphal" <kevin dot kuphal at sitecity dot net>)
michael
parents:
341
diff
changeset
|
935 { |
2b485a3c5cfb
seeking in single stream asf patch by ("Kevin Kuphal" <kevin dot kuphal at sitecity dot net>)
michael
parents:
341
diff
changeset
|
936 ASFContext *asf = s->priv_data; |
2b485a3c5cfb
seeking in single stream asf patch by ("Kevin Kuphal" <kevin dot kuphal at sitecity dot net>)
michael
parents:
341
diff
changeset
|
937 AVPacket pkt1, *pkt = &pkt1; |
349 | 938 ASFStream *asf_st; |
939 int64_t pts; | |
348 | 940 int64_t pos= *ppos; |
354
6770ca07abe2
store searched distance in index, so we dont waste time searching for keyframes where we already searched
michael
parents:
353
diff
changeset
|
941 int i; |
6770ca07abe2
store searched distance in index, so we dont waste time searching for keyframes where we already searched
michael
parents:
353
diff
changeset
|
942 int64_t start_pos[s->nb_streams]; |
885 | 943 |
354
6770ca07abe2
store searched distance in index, so we dont waste time searching for keyframes where we already searched
michael
parents:
353
diff
changeset
|
944 for(i=0; i<s->nb_streams; i++){ |
6770ca07abe2
store searched distance in index, so we dont waste time searching for keyframes where we already searched
michael
parents:
353
diff
changeset
|
945 start_pos[i]= pos; |
6770ca07abe2
store searched distance in index, so we dont waste time searching for keyframes where we already searched
michael
parents:
353
diff
changeset
|
946 } |
885 | 947 |
437
50bae308f71e
moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents:
373
diff
changeset
|
948 pos= (pos+asf->packet_size-1-s->data_offset)/asf->packet_size*asf->packet_size+ s->data_offset; |
50bae308f71e
moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents:
373
diff
changeset
|
949 *ppos= pos; |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2737
diff
changeset
|
950 url_fseek(s->pb, pos, SEEK_SET); |
885 | 951 |
349 | 952 //printf("asf_read_pts\n"); |
953 asf_reset_header(s); | |
354
6770ca07abe2
store searched distance in index, so we dont waste time searching for keyframes where we already searched
michael
parents:
353
diff
changeset
|
954 for(;;){ |
349 | 955 if (av_read_frame(s, pkt) < 0){ |
1714 | 956 av_log(s, AV_LOG_INFO, "asf_read_pts failed\n"); |
887 | 957 return AV_NOPTS_VALUE; |
349 | 958 } |
885 | 959 |
991 | 960 pts= pkt->pts; |
347
2b485a3c5cfb
seeking in single stream asf patch by ("Kevin Kuphal" <kevin dot kuphal at sitecity dot net>)
michael
parents:
341
diff
changeset
|
961 |
348 | 962 av_free_packet(pkt); |
354
6770ca07abe2
store searched distance in index, so we dont waste time searching for keyframes where we already searched
michael
parents:
353
diff
changeset
|
963 if(pkt->flags&PKT_FLAG_KEY){ |
6770ca07abe2
store searched distance in index, so we dont waste time searching for keyframes where we already searched
michael
parents:
353
diff
changeset
|
964 i= pkt->stream_index; |
6770ca07abe2
store searched distance in index, so we dont waste time searching for keyframes where we already searched
michael
parents:
353
diff
changeset
|
965 |
6770ca07abe2
store searched distance in index, so we dont waste time searching for keyframes where we already searched
michael
parents:
353
diff
changeset
|
966 asf_st= s->streams[i]->priv_data; |
6770ca07abe2
store searched distance in index, so we dont waste time searching for keyframes where we already searched
michael
parents:
353
diff
changeset
|
967 |
1722
cb0dc6abf4d1
make the asf demuxer resistant against insertion/deletion errors
michael
parents:
1716
diff
changeset
|
968 // assert((asf_st->packet_pos - s->data_offset) % asf->packet_size == 0); |
437
50bae308f71e
moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents:
373
diff
changeset
|
969 pos= asf_st->packet_pos; |
351
c072833fe7f4
use packet number instead of byte number internally for seeking
michael
parents:
350
diff
changeset
|
970 |
1266 | 971 av_add_index_entry(s->streams[i], pos, pts, pkt->size, pos - start_pos[i] + 1, AVINDEX_KEYFRAME); |
437
50bae308f71e
moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents:
373
diff
changeset
|
972 start_pos[i]= asf_st->packet_pos + 1; |
885 | 973 |
354
6770ca07abe2
store searched distance in index, so we dont waste time searching for keyframes where we already searched
michael
parents:
353
diff
changeset
|
974 if(pkt->stream_index == stream_index) |
6770ca07abe2
store searched distance in index, so we dont waste time searching for keyframes where we already searched
michael
parents:
353
diff
changeset
|
975 break; |
6770ca07abe2
store searched distance in index, so we dont waste time searching for keyframes where we already searched
michael
parents:
353
diff
changeset
|
976 } |
6770ca07abe2
store searched distance in index, so we dont waste time searching for keyframes where we already searched
michael
parents:
353
diff
changeset
|
977 } |
6770ca07abe2
store searched distance in index, so we dont waste time searching for keyframes where we already searched
michael
parents:
353
diff
changeset
|
978 |
6770ca07abe2
store searched distance in index, so we dont waste time searching for keyframes where we already searched
michael
parents:
353
diff
changeset
|
979 *ppos= pos; |
1443
404048ea11bc
Replace most of the %lld and %llx by their (cleaner) PRI*64 counterparts.
diego
parents:
1415
diff
changeset
|
980 //printf("found keyframe at %"PRId64" stream %d stamp:%"PRId64"\n", *ppos, stream_index, pts); |
348 | 981 |
982 return pts; | |
347
2b485a3c5cfb
seeking in single stream asf patch by ("Kevin Kuphal" <kevin dot kuphal at sitecity dot net>)
michael
parents:
341
diff
changeset
|
983 } |
2b485a3c5cfb
seeking in single stream asf patch by ("Kevin Kuphal" <kevin dot kuphal at sitecity dot net>)
michael
parents:
341
diff
changeset
|
984 |
1265
613fdf995af0
read and use index (based on a patch by John Donaghy on the 23-03-2006 '[Ffmpeg-devel] dvr-ms seek help request')
michael
parents:
1264
diff
changeset
|
985 static void asf_build_simple_index(AVFormatContext *s, int stream_index) |
613fdf995af0
read and use index (based on a patch by John Donaghy on the 23-03-2006 '[Ffmpeg-devel] dvr-ms seek help request')
michael
parents:
1264
diff
changeset
|
986 { |
4748
86dd0cab30d3
Rename GUID typedef to ff_asf_guid to fix MinGW compilation failure
reimar
parents:
4747
diff
changeset
|
987 ff_asf_guid g; |
1265
613fdf995af0
read and use index (based on a patch by John Donaghy on the 23-03-2006 '[Ffmpeg-devel] dvr-ms seek help request')
michael
parents:
1264
diff
changeset
|
988 ASFContext *asf = s->priv_data; |
613fdf995af0
read and use index (based on a patch by John Donaghy on the 23-03-2006 '[Ffmpeg-devel] dvr-ms seek help request')
michael
parents:
1264
diff
changeset
|
989 int64_t gsize, itime; |
613fdf995af0
read and use index (based on a patch by John Donaghy on the 23-03-2006 '[Ffmpeg-devel] dvr-ms seek help request')
michael
parents:
1264
diff
changeset
|
990 int64_t pos, current_pos, index_pts; |
613fdf995af0
read and use index (based on a patch by John Donaghy on the 23-03-2006 '[Ffmpeg-devel] dvr-ms seek help request')
michael
parents:
1264
diff
changeset
|
991 int i; |
613fdf995af0
read and use index (based on a patch by John Donaghy on the 23-03-2006 '[Ffmpeg-devel] dvr-ms seek help request')
michael
parents:
1264
diff
changeset
|
992 int pct,ict; |
613fdf995af0
read and use index (based on a patch by John Donaghy on the 23-03-2006 '[Ffmpeg-devel] dvr-ms seek help request')
michael
parents:
1264
diff
changeset
|
993 |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2737
diff
changeset
|
994 current_pos = url_ftell(s->pb); |
1265
613fdf995af0
read and use index (based on a patch by John Donaghy on the 23-03-2006 '[Ffmpeg-devel] dvr-ms seek help request')
michael
parents:
1264
diff
changeset
|
995 |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2737
diff
changeset
|
996 url_fseek(s->pb, asf->data_object_offset + asf->data_object_size, SEEK_SET); |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2737
diff
changeset
|
997 get_guid(s->pb, &g); |
4747
0ad594176680
Add a special guidcmp function to compare ASF guids, to avoid the many
reimar
parents:
4743
diff
changeset
|
998 if (!guidcmp(&g, &index_guid)) { |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2737
diff
changeset
|
999 gsize = get_le64(s->pb); |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2737
diff
changeset
|
1000 get_guid(s->pb, &g); |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2737
diff
changeset
|
1001 itime=get_le64(s->pb); |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2737
diff
changeset
|
1002 pct=get_le32(s->pb); |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2737
diff
changeset
|
1003 ict=get_le32(s->pb); |
4508 | 1004 av_log(s, AV_LOG_DEBUG, "itime:0x%"PRIx64", pct:%d, ict:%d\n",itime,pct,ict); |
1265
613fdf995af0
read and use index (based on a patch by John Donaghy on the 23-03-2006 '[Ffmpeg-devel] dvr-ms seek help request')
michael
parents:
1264
diff
changeset
|
1005 |
613fdf995af0
read and use index (based on a patch by John Donaghy on the 23-03-2006 '[Ffmpeg-devel] dvr-ms seek help request')
michael
parents:
1264
diff
changeset
|
1006 for (i=0;i<ict;i++){ |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2737
diff
changeset
|
1007 int pktnum=get_le32(s->pb); |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2737
diff
changeset
|
1008 int pktct =get_le16(s->pb); |
4508 | 1009 av_log(s, AV_LOG_DEBUG, "pktnum:%d, pktct:%d\n", pktnum, pktct); |
1265
613fdf995af0
read and use index (based on a patch by John Donaghy on the 23-03-2006 '[Ffmpeg-devel] dvr-ms seek help request')
michael
parents:
1264
diff
changeset
|
1010 |
613fdf995af0
read and use index (based on a patch by John Donaghy on the 23-03-2006 '[Ffmpeg-devel] dvr-ms seek help request')
michael
parents:
1264
diff
changeset
|
1011 pos=s->data_offset + asf->packet_size*(int64_t)pktnum; |
613fdf995af0
read and use index (based on a patch by John Donaghy on the 23-03-2006 '[Ffmpeg-devel] dvr-ms seek help request')
michael
parents:
1264
diff
changeset
|
1012 index_pts=av_rescale(itime, i, 10000); |
613fdf995af0
read and use index (based on a patch by John Donaghy on the 23-03-2006 '[Ffmpeg-devel] dvr-ms seek help request')
michael
parents:
1264
diff
changeset
|
1013 |
613fdf995af0
read and use index (based on a patch by John Donaghy on the 23-03-2006 '[Ffmpeg-devel] dvr-ms seek help request')
michael
parents:
1264
diff
changeset
|
1014 av_add_index_entry(s->streams[stream_index], pos, index_pts, asf->packet_size, 0, AVINDEX_KEYFRAME); |
613fdf995af0
read and use index (based on a patch by John Donaghy on the 23-03-2006 '[Ffmpeg-devel] dvr-ms seek help request')
michael
parents:
1264
diff
changeset
|
1015 } |
1266 | 1016 asf->index_read= 1; |
1265
613fdf995af0
read and use index (based on a patch by John Donaghy on the 23-03-2006 '[Ffmpeg-devel] dvr-ms seek help request')
michael
parents:
1264
diff
changeset
|
1017 } |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2737
diff
changeset
|
1018 url_fseek(s->pb, current_pos, SEEK_SET); |
1265
613fdf995af0
read and use index (based on a patch by John Donaghy on the 23-03-2006 '[Ffmpeg-devel] dvr-ms seek help request')
michael
parents:
1264
diff
changeset
|
1019 } |
613fdf995af0
read and use index (based on a patch by John Donaghy on the 23-03-2006 '[Ffmpeg-devel] dvr-ms seek help request')
michael
parents:
1264
diff
changeset
|
1020 |
555 | 1021 static int asf_read_seek(AVFormatContext *s, int stream_index, int64_t pts, int flags) |
0 | 1022 { |
312
8a04d2e1be2f
frame rate should be completely disabled in asf (closer now) - disabled seek
bellard
parents:
300
diff
changeset
|
1023 ASFContext *asf = s->priv_data; |
1265
613fdf995af0
read and use index (based on a patch by John Donaghy on the 23-03-2006 '[Ffmpeg-devel] dvr-ms seek help request')
michael
parents:
1264
diff
changeset
|
1024 AVStream *st = s->streams[stream_index]; |
613fdf995af0
read and use index (based on a patch by John Donaghy on the 23-03-2006 '[Ffmpeg-devel] dvr-ms seek help request')
michael
parents:
1264
diff
changeset
|
1025 int64_t pos; |
613fdf995af0
read and use index (based on a patch by John Donaghy on the 23-03-2006 '[Ffmpeg-devel] dvr-ms seek help request')
michael
parents:
1264
diff
changeset
|
1026 int index; |
885 | 1027 |
350 | 1028 if (asf->packet_size <= 0) |
347
2b485a3c5cfb
seeking in single stream asf patch by ("Kevin Kuphal" <kevin dot kuphal at sitecity dot net>)
michael
parents:
341
diff
changeset
|
1029 return -1; |
2b485a3c5cfb
seeking in single stream asf patch by ("Kevin Kuphal" <kevin dot kuphal at sitecity dot net>)
michael
parents:
341
diff
changeset
|
1030 |
2827
f717dd23fc23
Enable av_read_pause(), av_read_play() and the ASF demuxer's av_read_seek()
benoit
parents:
2771
diff
changeset
|
1031 /* Try using the protocol's read_seek if available */ |
2842 | 1032 if(s->pb) { |
2827
f717dd23fc23
Enable av_read_pause(), av_read_play() and the ASF demuxer's av_read_seek()
benoit
parents:
2771
diff
changeset
|
1033 int ret = av_url_read_fseek(s->pb, stream_index, pts, flags); |
f717dd23fc23
Enable av_read_pause(), av_read_play() and the ASF demuxer's av_read_seek()
benoit
parents:
2771
diff
changeset
|
1034 if(ret >= 0) |
f717dd23fc23
Enable av_read_pause(), av_read_play() and the ASF demuxer's av_read_seek()
benoit
parents:
2771
diff
changeset
|
1035 asf_reset_header(s); |
2842 | 1036 if (ret != AVERROR(ENOSYS)) |
2843 | 1037 return ret; |
2827
f717dd23fc23
Enable av_read_pause(), av_read_play() and the ASF demuxer's av_read_seek()
benoit
parents:
2771
diff
changeset
|
1038 } |
f717dd23fc23
Enable av_read_pause(), av_read_play() and the ASF demuxer's av_read_seek()
benoit
parents:
2771
diff
changeset
|
1039 |
1266 | 1040 if (!asf->index_read) |
1265
613fdf995af0
read and use index (based on a patch by John Donaghy on the 23-03-2006 '[Ffmpeg-devel] dvr-ms seek help request')
michael
parents:
1264
diff
changeset
|
1041 asf_build_simple_index(s, stream_index); |
613fdf995af0
read and use index (based on a patch by John Donaghy on the 23-03-2006 '[Ffmpeg-devel] dvr-ms seek help request')
michael
parents:
1264
diff
changeset
|
1042 |
1266 | 1043 if(!(asf->index_read && st->index_entries)){ |
1265
613fdf995af0
read and use index (based on a patch by John Donaghy on the 23-03-2006 '[Ffmpeg-devel] dvr-ms seek help request')
michael
parents:
1264
diff
changeset
|
1044 if(av_seek_frame_binary(s, stream_index, pts, flags)<0) |
613fdf995af0
read and use index (based on a patch by John Donaghy on the 23-03-2006 '[Ffmpeg-devel] dvr-ms seek help request')
michael
parents:
1264
diff
changeset
|
1045 return -1; |
613fdf995af0
read and use index (based on a patch by John Donaghy on the 23-03-2006 '[Ffmpeg-devel] dvr-ms seek help request')
michael
parents:
1264
diff
changeset
|
1046 }else{ |
613fdf995af0
read and use index (based on a patch by John Donaghy on the 23-03-2006 '[Ffmpeg-devel] dvr-ms seek help request')
michael
parents:
1264
diff
changeset
|
1047 index= av_index_search_timestamp(st, pts, flags); |
613fdf995af0
read and use index (based on a patch by John Donaghy on the 23-03-2006 '[Ffmpeg-devel] dvr-ms seek help request')
michael
parents:
1264
diff
changeset
|
1048 if(index<0) |
613fdf995af0
read and use index (based on a patch by John Donaghy on the 23-03-2006 '[Ffmpeg-devel] dvr-ms seek help request')
michael
parents:
1264
diff
changeset
|
1049 return -1; |
613fdf995af0
read and use index (based on a patch by John Donaghy on the 23-03-2006 '[Ffmpeg-devel] dvr-ms seek help request')
michael
parents:
1264
diff
changeset
|
1050 |
613fdf995af0
read and use index (based on a patch by John Donaghy on the 23-03-2006 '[Ffmpeg-devel] dvr-ms seek help request')
michael
parents:
1264
diff
changeset
|
1051 /* find the position */ |
613fdf995af0
read and use index (based on a patch by John Donaghy on the 23-03-2006 '[Ffmpeg-devel] dvr-ms seek help request')
michael
parents:
1264
diff
changeset
|
1052 pos = st->index_entries[index].pos; |
613fdf995af0
read and use index (based on a patch by John Donaghy on the 23-03-2006 '[Ffmpeg-devel] dvr-ms seek help request')
michael
parents:
1264
diff
changeset
|
1053 pts = st->index_entries[index].timestamp; |
347
2b485a3c5cfb
seeking in single stream asf patch by ("Kevin Kuphal" <kevin dot kuphal at sitecity dot net>)
michael
parents:
341
diff
changeset
|
1054 |
1265
613fdf995af0
read and use index (based on a patch by John Donaghy on the 23-03-2006 '[Ffmpeg-devel] dvr-ms seek help request')
michael
parents:
1264
diff
changeset
|
1055 // various attempts to find key frame have failed so far |
613fdf995af0
read and use index (based on a patch by John Donaghy on the 23-03-2006 '[Ffmpeg-devel] dvr-ms seek help request')
michael
parents:
1264
diff
changeset
|
1056 // asf_reset_header(s); |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2737
diff
changeset
|
1057 // url_fseek(s->pb, pos, SEEK_SET); |
1265
613fdf995af0
read and use index (based on a patch by John Donaghy on the 23-03-2006 '[Ffmpeg-devel] dvr-ms seek help request')
michael
parents:
1264
diff
changeset
|
1058 // key_pos = pos; |
613fdf995af0
read and use index (based on a patch by John Donaghy on the 23-03-2006 '[Ffmpeg-devel] dvr-ms seek help request')
michael
parents:
1264
diff
changeset
|
1059 // for(i=0;i<16;i++){ |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2737
diff
changeset
|
1060 // pos = url_ftell(s->pb); |
1265
613fdf995af0
read and use index (based on a patch by John Donaghy on the 23-03-2006 '[Ffmpeg-devel] dvr-ms seek help request')
michael
parents:
1264
diff
changeset
|
1061 // if (av_read_frame(s, &pkt) < 0){ |
613fdf995af0
read and use index (based on a patch by John Donaghy on the 23-03-2006 '[Ffmpeg-devel] dvr-ms seek help request')
michael
parents:
1264
diff
changeset
|
1062 // av_log(s, AV_LOG_INFO, "seek failed\n"); |
613fdf995af0
read and use index (based on a patch by John Donaghy on the 23-03-2006 '[Ffmpeg-devel] dvr-ms seek help request')
michael
parents:
1264
diff
changeset
|
1063 // return -1; |
613fdf995af0
read and use index (based on a patch by John Donaghy on the 23-03-2006 '[Ffmpeg-devel] dvr-ms seek help request')
michael
parents:
1264
diff
changeset
|
1064 // } |
613fdf995af0
read and use index (based on a patch by John Donaghy on the 23-03-2006 '[Ffmpeg-devel] dvr-ms seek help request')
michael
parents:
1264
diff
changeset
|
1065 // asf_st = s->streams[stream_index]->priv_data; |
613fdf995af0
read and use index (based on a patch by John Donaghy on the 23-03-2006 '[Ffmpeg-devel] dvr-ms seek help request')
michael
parents:
1264
diff
changeset
|
1066 // pos += st->parser->frame_offset; |
613fdf995af0
read and use index (based on a patch by John Donaghy on the 23-03-2006 '[Ffmpeg-devel] dvr-ms seek help request')
michael
parents:
1264
diff
changeset
|
1067 // |
613fdf995af0
read and use index (based on a patch by John Donaghy on the 23-03-2006 '[Ffmpeg-devel] dvr-ms seek help request')
michael
parents:
1264
diff
changeset
|
1068 // if (pkt.size > b) { |
613fdf995af0
read and use index (based on a patch by John Donaghy on the 23-03-2006 '[Ffmpeg-devel] dvr-ms seek help request')
michael
parents:
1264
diff
changeset
|
1069 // b = pkt.size; |
613fdf995af0
read and use index (based on a patch by John Donaghy on the 23-03-2006 '[Ffmpeg-devel] dvr-ms seek help request')
michael
parents:
1264
diff
changeset
|
1070 // key_pos = pos; |
613fdf995af0
read and use index (based on a patch by John Donaghy on the 23-03-2006 '[Ffmpeg-devel] dvr-ms seek help request')
michael
parents:
1264
diff
changeset
|
1071 // } |
613fdf995af0
read and use index (based on a patch by John Donaghy on the 23-03-2006 '[Ffmpeg-devel] dvr-ms seek help request')
michael
parents:
1264
diff
changeset
|
1072 // |
613fdf995af0
read and use index (based on a patch by John Donaghy on the 23-03-2006 '[Ffmpeg-devel] dvr-ms seek help request')
michael
parents:
1264
diff
changeset
|
1073 // av_free_packet(&pkt); |
613fdf995af0
read and use index (based on a patch by John Donaghy on the 23-03-2006 '[Ffmpeg-devel] dvr-ms seek help request')
michael
parents:
1264
diff
changeset
|
1074 // } |
613fdf995af0
read and use index (based on a patch by John Donaghy on the 23-03-2006 '[Ffmpeg-devel] dvr-ms seek help request')
michael
parents:
1264
diff
changeset
|
1075 |
613fdf995af0
read and use index (based on a patch by John Donaghy on the 23-03-2006 '[Ffmpeg-devel] dvr-ms seek help request')
michael
parents:
1264
diff
changeset
|
1076 /* do the seek */ |
4508 | 1077 av_log(s, AV_LOG_DEBUG, "SEEKTO: %"PRId64"\n", pos); |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2737
diff
changeset
|
1078 url_fseek(s->pb, pos, SEEK_SET); |
1265
613fdf995af0
read and use index (based on a patch by John Donaghy on the 23-03-2006 '[Ffmpeg-devel] dvr-ms seek help request')
michael
parents:
1264
diff
changeset
|
1079 } |
347
2b485a3c5cfb
seeking in single stream asf patch by ("Kevin Kuphal" <kevin dot kuphal at sitecity dot net>)
michael
parents:
341
diff
changeset
|
1080 asf_reset_header(s); |
2b485a3c5cfb
seeking in single stream asf patch by ("Kevin Kuphal" <kevin dot kuphal at sitecity dot net>)
michael
parents:
341
diff
changeset
|
1081 return 0; |
0 | 1082 } |
1083 | |
1169 | 1084 AVInputFormat asf_demuxer = { |
0 | 1085 "asf", |
3424
7a0230981402
Make long_names in lavf/lavdev optional depending on CONFIG_SMALL.
diego
parents:
3286
diff
changeset
|
1086 NULL_IF_CONFIG_SMALL("ASF format"), |
0 | 1087 sizeof(ASFContext), |
1088 asf_probe, | |
1089 asf_read_header, | |
1090 asf_read_packet, | |
1091 asf_read_close, | |
1092 asf_read_seek, | |
437
50bae308f71e
moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents:
373
diff
changeset
|
1093 asf_read_pts, |
4618
5b9eddbee9c4
Add some basic metadata conversion tables for matroska and asf.
aurel
parents:
4593
diff
changeset
|
1094 .metadata_conv = ff_asf_metadata_conv, |
0 | 1095 }; |