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