ffmpeg / libavformat / asf.c @ 11c55efa
History | View | Annotate | Download (40.3 KB)
| 1 |
/*
|
|---|---|
| 2 |
* ASF compatible demuxer
|
| 3 |
* Copyright (c) 2000, 2001 Fabrice Bellard.
|
| 4 |
*
|
| 5 |
* This file is part of FFmpeg.
|
| 6 |
*
|
| 7 |
* FFmpeg is free software; you can redistribute it and/or
|
| 8 |
* modify it under the terms of the GNU Lesser General Public
|
| 9 |
* License as published by the Free Software Foundation; either
|
| 10 |
* version 2.1 of the License, or (at your option) any later version.
|
| 11 |
*
|
| 12 |
* FFmpeg is distributed in the hope that it will be useful,
|
| 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
|
| 18 |
* License along with FFmpeg; if not, write to the Free Software
|
| 19 |
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
| 20 |
*/
|
| 21 |
#include "avformat.h" |
| 22 |
#include "riff.h" |
| 23 |
#include "mpegaudio.h" |
| 24 |
#include "asf.h" |
| 25 |
#include "common.h" |
| 26 |
#include "asfcrypt.h" |
| 27 |
|
| 28 |
extern void ff_mms_set_stream_selection(URLContext *h, AVFormatContext *format); |
| 29 |
|
| 30 |
#undef NDEBUG
|
| 31 |
#include <assert.h> |
| 32 |
|
| 33 |
#define FRAME_HEADER_SIZE 17 |
| 34 |
// Fix Me! FRAME_HEADER_SIZE may be different.
|
| 35 |
|
| 36 |
static const GUID index_guid = { |
| 37 |
0x90, 0x08, 0x00, 0x33, 0xb1, 0xe5, 0xcf, 0x11, 0x89, 0xf4, 0x00, 0xa0, 0xc9, 0x03, 0x49, 0xcb |
| 38 |
}; |
| 39 |
|
| 40 |
static const GUID stream_bitrate_guid = { /* (http://get.to/sdp) */ |
| 41 |
0xce, 0x75, 0xf8, 0x7b, 0x8d, 0x46, 0xd1, 0x11, 0x8d, 0x82, 0x00, 0x60, 0x97, 0xc9, 0xa2, 0xb2 |
| 42 |
}; |
| 43 |
/**********************************/
|
| 44 |
/* decoding */
|
| 45 |
|
| 46 |
//#define DEBUG
|
| 47 |
|
| 48 |
#ifdef DEBUG
|
| 49 |
#define PRINT_IF_GUID(g,cmp) \
|
| 50 |
if (!memcmp(g, &cmp, sizeof(GUID))) \ |
| 51 |
printf("(GUID: %s) ", #cmp) |
| 52 |
|
| 53 |
static void print_guid(const GUID *g) |
| 54 |
{
|
| 55 |
int i;
|
| 56 |
PRINT_IF_GUID(g, asf_header); |
| 57 |
else PRINT_IF_GUID(g, file_header);
|
| 58 |
else PRINT_IF_GUID(g, stream_header);
|
| 59 |
else PRINT_IF_GUID(g, audio_stream);
|
| 60 |
else PRINT_IF_GUID(g, audio_conceal_none);
|
| 61 |
else PRINT_IF_GUID(g, video_stream);
|
| 62 |
else PRINT_IF_GUID(g, video_conceal_none);
|
| 63 |
else PRINT_IF_GUID(g, command_stream);
|
| 64 |
else PRINT_IF_GUID(g, comment_header);
|
| 65 |
else PRINT_IF_GUID(g, codec_comment_header);
|
| 66 |
else PRINT_IF_GUID(g, codec_comment1_header);
|
| 67 |
else PRINT_IF_GUID(g, data_header);
|
| 68 |
else PRINT_IF_GUID(g, index_guid);
|
| 69 |
else PRINT_IF_GUID(g, head1_guid);
|
| 70 |
else PRINT_IF_GUID(g, head2_guid);
|
| 71 |
else PRINT_IF_GUID(g, my_guid);
|
| 72 |
else PRINT_IF_GUID(g, ext_stream_header);
|
| 73 |
else PRINT_IF_GUID(g, extended_content_header);
|
| 74 |
else PRINT_IF_GUID(g, ext_stream_embed_stream_header);
|
| 75 |
else PRINT_IF_GUID(g, ext_stream_audio_stream);
|
| 76 |
else PRINT_IF_GUID(g, metadata_header);
|
| 77 |
else PRINT_IF_GUID(g, stream_bitrate_guid);
|
| 78 |
else
|
| 79 |
printf("(GUID: unknown) ");
|
| 80 |
for(i=0;i<16;i++) |
| 81 |
printf(" 0x%02x,", (*g)[i]);
|
| 82 |
printf("}\n");
|
| 83 |
} |
| 84 |
#undef PRINT_IF_GUID
|
| 85 |
#endif
|
| 86 |
|
| 87 |
static void get_guid(ByteIOContext *s, GUID *g) |
| 88 |
{
|
| 89 |
assert(sizeof(*g) == 16); |
| 90 |
get_buffer(s, *g, sizeof(*g));
|
| 91 |
} |
| 92 |
|
| 93 |
#if 0
|
| 94 |
static void get_str16(ByteIOContext *pb, char *buf, int buf_size)
|
| 95 |
{
|
| 96 |
int len, c;
|
| 97 |
char *q;
|
| 98 |
|
| 99 |
len = get_le16(pb);
|
| 100 |
q = buf;
|
| 101 |
while (len > 0) {
|
| 102 |
c = get_le16(pb);
|
| 103 |
if ((q - buf) < buf_size - 1)
|
| 104 |
*q++ = c;
|
| 105 |
len--;
|
| 106 |
}
|
| 107 |
*q = '\0';
|
| 108 |
}
|
| 109 |
#endif
|
| 110 |
|
| 111 |
static void get_str16_nolen(ByteIOContext *pb, int len, char *buf, int buf_size) |
| 112 |
{
|
| 113 |
char* q = buf;
|
| 114 |
len /= 2;
|
| 115 |
while (len--) {
|
| 116 |
uint8_t tmp; |
| 117 |
PUT_UTF8(get_le16(pb), tmp, if (q - buf < buf_size - 1) *q++ = tmp;) |
| 118 |
} |
| 119 |
*q = '\0';
|
| 120 |
} |
| 121 |
|
| 122 |
static int asf_probe(AVProbeData *pd) |
| 123 |
{
|
| 124 |
/* check file header */
|
| 125 |
if (!memcmp(pd->buf, &asf_header, sizeof(GUID))) |
| 126 |
return AVPROBE_SCORE_MAX;
|
| 127 |
else
|
| 128 |
return 0; |
| 129 |
} |
| 130 |
|
| 131 |
static int get_value(ByteIOContext *pb, int type){ |
| 132 |
switch(type){
|
| 133 |
case 2: return get_le32(pb); |
| 134 |
case 3: return get_le32(pb); |
| 135 |
case 4: return get_le64(pb); |
| 136 |
case 5: return get_le16(pb); |
| 137 |
default:return INT_MIN; |
| 138 |
} |
| 139 |
} |
| 140 |
|
| 141 |
static int asf_read_header(AVFormatContext *s, AVFormatParameters *ap) |
| 142 |
{
|
| 143 |
ASFContext *asf = s->priv_data; |
| 144 |
GUID g; |
| 145 |
ByteIOContext *pb = s->pb; |
| 146 |
AVStream *st; |
| 147 |
ASFStream *asf_st; |
| 148 |
int size, i;
|
| 149 |
int64_t gsize; |
| 150 |
AVRational dar[128];
|
| 151 |
uint32_t bitrate[128];
|
| 152 |
|
| 153 |
memset(dar, 0, sizeof(dar)); |
| 154 |
memset(bitrate, 0, sizeof(bitrate)); |
| 155 |
|
| 156 |
get_guid(pb, &g); |
| 157 |
if (memcmp(&g, &asf_header, sizeof(GUID))) |
| 158 |
goto fail;
|
| 159 |
get_le64(pb); |
| 160 |
get_le32(pb); |
| 161 |
get_byte(pb); |
| 162 |
get_byte(pb); |
| 163 |
memset(&asf->asfid2avid, -1, sizeof(asf->asfid2avid)); |
| 164 |
for(;;) {
|
| 165 |
get_guid(pb, &g); |
| 166 |
gsize = get_le64(pb); |
| 167 |
#ifdef DEBUG
|
| 168 |
printf("%08"PRIx64": ", url_ftell(pb) - 24); |
| 169 |
print_guid(&g); |
| 170 |
printf(" size=0x%"PRIx64"\n", gsize); |
| 171 |
#endif
|
| 172 |
if (!memcmp(&g, &data_header, sizeof(GUID))) { |
| 173 |
asf->data_object_offset = url_ftell(pb); |
| 174 |
// if not streaming, gsize is not unlimited (how?), and there is enough space in the file..
|
| 175 |
if (!(asf->hdr.flags & 0x01) && gsize >= 100) { |
| 176 |
asf->data_object_size = gsize - 24;
|
| 177 |
} else {
|
| 178 |
asf->data_object_size = (uint64_t)-1;
|
| 179 |
} |
| 180 |
break;
|
| 181 |
} |
| 182 |
if (gsize < 24) |
| 183 |
goto fail;
|
| 184 |
if (!memcmp(&g, &file_header, sizeof(GUID))) { |
| 185 |
get_guid(pb, &asf->hdr.guid); |
| 186 |
asf->hdr.file_size = get_le64(pb); |
| 187 |
asf->hdr.create_time = get_le64(pb); |
| 188 |
asf->nb_packets = get_le64(pb); |
| 189 |
asf->hdr.send_time = get_le64(pb); |
| 190 |
asf->hdr.play_time = get_le64(pb); |
| 191 |
asf->hdr.preroll = get_le32(pb); |
| 192 |
asf->hdr.ignore = get_le32(pb); |
| 193 |
asf->hdr.flags = get_le32(pb); |
| 194 |
asf->hdr.min_pktsize = get_le32(pb); |
| 195 |
asf->hdr.max_pktsize = get_le32(pb); |
| 196 |
asf->hdr.max_bitrate = get_le32(pb); |
| 197 |
asf->packet_size = asf->hdr.max_pktsize; |
| 198 |
} else if (!memcmp(&g, &stream_header, sizeof(GUID))) { |
| 199 |
int type, type_specific_size, sizeX;
|
| 200 |
uint64_t total_size; |
| 201 |
unsigned int tag1; |
| 202 |
int64_t pos1, pos2, start_time; |
| 203 |
int test_for_ext_stream_audio, is_dvr_ms_audio=0; |
| 204 |
|
| 205 |
pos1 = url_ftell(pb); |
| 206 |
|
| 207 |
st = av_new_stream(s, 0);
|
| 208 |
if (!st)
|
| 209 |
goto fail;
|
| 210 |
av_set_pts_info(st, 32, 1, 1000); /* 32 bit pts in ms */ |
| 211 |
asf_st = av_mallocz(sizeof(ASFStream));
|
| 212 |
if (!asf_st)
|
| 213 |
goto fail;
|
| 214 |
st->priv_data = asf_st; |
| 215 |
start_time = asf->hdr.preroll; |
| 216 |
|
| 217 |
if(!(asf->hdr.flags & 0x01)) { // if we aren't streaming... |
| 218 |
st->duration = asf->hdr.send_time / |
| 219 |
(10000000 / 1000) - start_time; |
| 220 |
} |
| 221 |
get_guid(pb, &g); |
| 222 |
|
| 223 |
test_for_ext_stream_audio = 0;
|
| 224 |
if (!memcmp(&g, &audio_stream, sizeof(GUID))) { |
| 225 |
type = CODEC_TYPE_AUDIO; |
| 226 |
} else if (!memcmp(&g, &video_stream, sizeof(GUID))) { |
| 227 |
type = CODEC_TYPE_VIDEO; |
| 228 |
} else if (!memcmp(&g, &command_stream, sizeof(GUID))) { |
| 229 |
type = CODEC_TYPE_UNKNOWN; |
| 230 |
} else if (!memcmp(&g, &ext_stream_embed_stream_header, sizeof(GUID))) { |
| 231 |
test_for_ext_stream_audio = 1;
|
| 232 |
type = CODEC_TYPE_UNKNOWN; |
| 233 |
} else {
|
| 234 |
goto fail;
|
| 235 |
} |
| 236 |
get_guid(pb, &g); |
| 237 |
total_size = get_le64(pb); |
| 238 |
type_specific_size = get_le32(pb); |
| 239 |
get_le32(pb); |
| 240 |
st->id = get_le16(pb) & 0x7f; /* stream id */ |
| 241 |
// mapping of asf ID to AV stream ID;
|
| 242 |
asf->asfid2avid[st->id] = s->nb_streams - 1;
|
| 243 |
|
| 244 |
get_le32(pb); |
| 245 |
|
| 246 |
if (test_for_ext_stream_audio) {
|
| 247 |
get_guid(pb, &g); |
| 248 |
if (!memcmp(&g, &ext_stream_audio_stream, sizeof(GUID))) { |
| 249 |
type = CODEC_TYPE_AUDIO; |
| 250 |
is_dvr_ms_audio=1;
|
| 251 |
get_guid(pb, &g); |
| 252 |
get_le32(pb); |
| 253 |
get_le32(pb); |
| 254 |
get_le32(pb); |
| 255 |
get_guid(pb, &g); |
| 256 |
get_le32(pb); |
| 257 |
} |
| 258 |
} |
| 259 |
|
| 260 |
st->codec->codec_type = type; |
| 261 |
if (type == CODEC_TYPE_AUDIO) {
|
| 262 |
get_wav_header(pb, st->codec, type_specific_size); |
| 263 |
if (is_dvr_ms_audio) {
|
| 264 |
// codec_id and codec_tag are unreliable in dvr_ms
|
| 265 |
// files. Set them later by probing stream.
|
| 266 |
st->codec->codec_id = CODEC_ID_NONE; |
| 267 |
st->codec->codec_tag = 0;
|
| 268 |
} |
| 269 |
st->need_parsing = AVSTREAM_PARSE_FULL; |
| 270 |
/* We have to init the frame size at some point .... */
|
| 271 |
pos2 = url_ftell(pb); |
| 272 |
if (gsize >= (pos2 + 8 - pos1 + 24)) { |
| 273 |
asf_st->ds_span = get_byte(pb); |
| 274 |
asf_st->ds_packet_size = get_le16(pb); |
| 275 |
asf_st->ds_chunk_size = get_le16(pb); |
| 276 |
get_le16(pb); //ds_data_size
|
| 277 |
get_byte(pb); //ds_silence_data
|
| 278 |
} |
| 279 |
//printf("Descrambling: ps:%d cs:%d ds:%d s:%d sd:%d\n",
|
| 280 |
// asf_st->ds_packet_size, asf_st->ds_chunk_size,
|
| 281 |
// asf_st->ds_data_size, asf_st->ds_span, asf_st->ds_silence_data);
|
| 282 |
if (asf_st->ds_span > 1) { |
| 283 |
if (!asf_st->ds_chunk_size
|
| 284 |
|| (asf_st->ds_packet_size/asf_st->ds_chunk_size <= 1)
|
| 285 |
|| asf_st->ds_packet_size % asf_st->ds_chunk_size) |
| 286 |
asf_st->ds_span = 0; // disable descrambling |
| 287 |
} |
| 288 |
switch (st->codec->codec_id) {
|
| 289 |
case CODEC_ID_MP3:
|
| 290 |
st->codec->frame_size = MPA_FRAME_SIZE; |
| 291 |
break;
|
| 292 |
case CODEC_ID_PCM_S16LE:
|
| 293 |
case CODEC_ID_PCM_S16BE:
|
| 294 |
case CODEC_ID_PCM_U16LE:
|
| 295 |
case CODEC_ID_PCM_U16BE:
|
| 296 |
case CODEC_ID_PCM_S8:
|
| 297 |
case CODEC_ID_PCM_U8:
|
| 298 |
case CODEC_ID_PCM_ALAW:
|
| 299 |
case CODEC_ID_PCM_MULAW:
|
| 300 |
st->codec->frame_size = 1;
|
| 301 |
break;
|
| 302 |
default:
|
| 303 |
/* This is probably wrong, but it prevents a crash later */
|
| 304 |
st->codec->frame_size = 1;
|
| 305 |
break;
|
| 306 |
} |
| 307 |
} else if (type == CODEC_TYPE_VIDEO) { |
| 308 |
get_le32(pb); |
| 309 |
get_le32(pb); |
| 310 |
get_byte(pb); |
| 311 |
size = get_le16(pb); /* size */
|
| 312 |
sizeX= get_le32(pb); /* size */
|
| 313 |
st->codec->width = get_le32(pb); |
| 314 |
st->codec->height = get_le32(pb); |
| 315 |
/* not available for asf */
|
| 316 |
get_le16(pb); /* panes */
|
| 317 |
st->codec->bits_per_sample = get_le16(pb); /* depth */
|
| 318 |
tag1 = get_le32(pb); |
| 319 |
url_fskip(pb, 20);
|
| 320 |
// av_log(NULL, AV_LOG_DEBUG, "size:%d tsize:%d sizeX:%d\n", size, total_size, sizeX);
|
| 321 |
size= sizeX; |
| 322 |
if (size > 40) { |
| 323 |
st->codec->extradata_size = size - 40;
|
| 324 |
st->codec->extradata = av_mallocz(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE); |
| 325 |
get_buffer(pb, st->codec->extradata, st->codec->extradata_size); |
| 326 |
} |
| 327 |
|
| 328 |
/* Extract palette from extradata if bpp <= 8 */
|
| 329 |
/* This code assumes that extradata contains only palette */
|
| 330 |
/* This is true for all paletted codecs implemented in ffmpeg */
|
| 331 |
if (st->codec->extradata_size && (st->codec->bits_per_sample <= 8)) { |
| 332 |
st->codec->palctrl = av_mallocz(sizeof(AVPaletteControl));
|
| 333 |
#ifdef WORDS_BIGENDIAN
|
| 334 |
for (i = 0; i < FFMIN(st->codec->extradata_size, AVPALETTE_SIZE)/4; i++) |
| 335 |
st->codec->palctrl->palette[i] = bswap_32(((uint32_t*)st->codec->extradata)[i]); |
| 336 |
#else
|
| 337 |
memcpy(st->codec->palctrl->palette, st->codec->extradata, |
| 338 |
FFMIN(st->codec->extradata_size, AVPALETTE_SIZE)); |
| 339 |
#endif
|
| 340 |
st->codec->palctrl->palette_changed = 1;
|
| 341 |
} |
| 342 |
|
| 343 |
st->codec->codec_tag = tag1; |
| 344 |
st->codec->codec_id = codec_get_id(codec_bmp_tags, tag1); |
| 345 |
if(tag1 == MKTAG('D', 'V', 'R', ' ')) |
| 346 |
st->need_parsing = AVSTREAM_PARSE_FULL; |
| 347 |
} |
| 348 |
pos2 = url_ftell(pb); |
| 349 |
url_fskip(pb, gsize - (pos2 - pos1 + 24));
|
| 350 |
} else if (!memcmp(&g, &comment_header, sizeof(GUID))) { |
| 351 |
int len1, len2, len3, len4, len5;
|
| 352 |
|
| 353 |
len1 = get_le16(pb); |
| 354 |
len2 = get_le16(pb); |
| 355 |
len3 = get_le16(pb); |
| 356 |
len4 = get_le16(pb); |
| 357 |
len5 = get_le16(pb); |
| 358 |
get_str16_nolen(pb, len1, s->title , sizeof(s->title));
|
| 359 |
get_str16_nolen(pb, len2, s->author , sizeof(s->author));
|
| 360 |
get_str16_nolen(pb, len3, s->copyright, sizeof(s->copyright));
|
| 361 |
get_str16_nolen(pb, len4, s->comment , sizeof(s->comment));
|
| 362 |
url_fskip(pb, len5); |
| 363 |
} else if (!memcmp(&g, &stream_bitrate_guid, sizeof(GUID))) { |
| 364 |
int stream_count = get_le16(pb);
|
| 365 |
int j;
|
| 366 |
|
| 367 |
// av_log(NULL, AV_LOG_ERROR, "stream bitrate properties\n");
|
| 368 |
// av_log(NULL, AV_LOG_ERROR, "streams %d\n", streams);
|
| 369 |
for(j = 0; j < stream_count; j++) { |
| 370 |
int flags, bitrate, stream_id;
|
| 371 |
|
| 372 |
flags= get_le16(pb); |
| 373 |
bitrate= get_le32(pb); |
| 374 |
stream_id= (flags & 0x7f);
|
| 375 |
// av_log(NULL, AV_LOG_ERROR, "flags: 0x%x stream id %d, bitrate %d\n", flags, stream_id, bitrate);
|
| 376 |
asf->stream_bitrates[stream_id]= bitrate; |
| 377 |
} |
| 378 |
} else if (!memcmp(&g, &extended_content_header, sizeof(GUID))) { |
| 379 |
int desc_count, i;
|
| 380 |
|
| 381 |
desc_count = get_le16(pb); |
| 382 |
for(i=0;i<desc_count;i++) |
| 383 |
{
|
| 384 |
int name_len,value_type,value_len;
|
| 385 |
uint64_t value_num = 0;
|
| 386 |
char name[1024]; |
| 387 |
|
| 388 |
name_len = get_le16(pb); |
| 389 |
get_str16_nolen(pb, name_len, name, sizeof(name));
|
| 390 |
value_type = get_le16(pb); |
| 391 |
value_len = get_le16(pb); |
| 392 |
if (value_type <= 1) // unicode or byte |
| 393 |
{
|
| 394 |
if (!strcmp(name,"WM/AlbumTitle")) get_str16_nolen(pb, value_len, s->album, sizeof(s->album)); |
| 395 |
else if(!strcmp(name,"WM/Genre" )) get_str16_nolen(pb, value_len, s->genre, sizeof(s->genre)); |
| 396 |
else if(!strcmp(name,"WM/Year" )) { |
| 397 |
char year[8]; |
| 398 |
get_str16_nolen(pb, value_len, year, sizeof(year));
|
| 399 |
s->year = atoi(year); |
| 400 |
} |
| 401 |
else if(!strcmp(name,"WM/Track") && s->track == 0) { |
| 402 |
char track[8]; |
| 403 |
get_str16_nolen(pb, value_len, track, sizeof(track));
|
| 404 |
s->track = strtol(track, NULL, 10) + 1; |
| 405 |
} |
| 406 |
else if(!strcmp(name,"WM/TrackNumber")) { |
| 407 |
char track[8]; |
| 408 |
get_str16_nolen(pb, value_len, track, sizeof(track));
|
| 409 |
s->track = strtol(track, NULL, 10); |
| 410 |
} |
| 411 |
else url_fskip(pb, value_len);
|
| 412 |
} |
| 413 |
else if (value_type <= 5) // boolean or DWORD or QWORD or WORD |
| 414 |
{
|
| 415 |
value_num= get_value(pb, value_type); |
| 416 |
if (!strcmp(name,"WM/Track" ) && s->track == 0) s->track = value_num + 1; |
| 417 |
if (!strcmp(name,"WM/TrackNumber")) s->track = value_num; |
| 418 |
}else
|
| 419 |
url_fskip(pb, value_len); |
| 420 |
} |
| 421 |
} else if (!memcmp(&g, &metadata_header, sizeof(GUID))) { |
| 422 |
int n, stream_num, name_len, value_len, value_type, value_num;
|
| 423 |
n = get_le16(pb); |
| 424 |
|
| 425 |
for(i=0;i<n;i++) { |
| 426 |
char name[1024]; |
| 427 |
|
| 428 |
get_le16(pb); //lang_list_index
|
| 429 |
stream_num= get_le16(pb); |
| 430 |
name_len= get_le16(pb); |
| 431 |
value_type= get_le16(pb); |
| 432 |
value_len= get_le32(pb); |
| 433 |
|
| 434 |
get_str16_nolen(pb, name_len, name, sizeof(name));
|
| 435 |
//av_log(NULL, AV_LOG_ERROR, "%d %d %d %d %d <%s>\n", i, stream_num, name_len, value_type, value_len, name);
|
| 436 |
value_num= get_le16(pb);//we should use get_value() here but it does not work 2 is le16 here but le32 elsewhere
|
| 437 |
url_fskip(pb, value_len - 2);
|
| 438 |
|
| 439 |
if(stream_num<128){ |
| 440 |
if (!strcmp(name, "AspectRatioX")) dar[stream_num].num= value_num; |
| 441 |
else if(!strcmp(name, "AspectRatioY")) dar[stream_num].den= value_num; |
| 442 |
} |
| 443 |
} |
| 444 |
} else if (!memcmp(&g, &ext_stream_header, sizeof(GUID))) { |
| 445 |
int ext_len, payload_ext_ct, stream_ct;
|
| 446 |
uint32_t ext_d, leak_rate, stream_num; |
| 447 |
int64_t pos_ex_st; |
| 448 |
pos_ex_st = url_ftell(pb); |
| 449 |
|
| 450 |
get_le64(pb); // starttime
|
| 451 |
get_le64(pb); // endtime
|
| 452 |
leak_rate = get_le32(pb); // leak-datarate
|
| 453 |
get_le32(pb); // bucket-datasize
|
| 454 |
get_le32(pb); // init-bucket-fullness
|
| 455 |
get_le32(pb); // alt-leak-datarate
|
| 456 |
get_le32(pb); // alt-bucket-datasize
|
| 457 |
get_le32(pb); // alt-init-bucket-fullness
|
| 458 |
get_le32(pb); // max-object-size
|
| 459 |
get_le32(pb); // flags (reliable,seekable,no_cleanpoints?,resend-live-cleanpoints, rest of bits reserved)
|
| 460 |
stream_num = get_le16(pb); // stream-num
|
| 461 |
get_le16(pb); // stream-language-id-index
|
| 462 |
get_le64(pb); // avg frametime in 100ns units
|
| 463 |
stream_ct = get_le16(pb); //stream-name-count
|
| 464 |
payload_ext_ct = get_le16(pb); //payload-extension-system-count
|
| 465 |
|
| 466 |
if (stream_num < 128) |
| 467 |
bitrate[stream_num] = leak_rate; |
| 468 |
|
| 469 |
for (i=0; i<stream_ct; i++){ |
| 470 |
get_le16(pb); |
| 471 |
ext_len = get_le16(pb); |
| 472 |
url_fseek(pb, ext_len, SEEK_CUR); |
| 473 |
} |
| 474 |
|
| 475 |
for (i=0; i<payload_ext_ct; i++){ |
| 476 |
get_guid(pb, &g); |
| 477 |
ext_d=get_le16(pb); |
| 478 |
ext_len=get_le32(pb); |
| 479 |
url_fseek(pb, ext_len, SEEK_CUR); |
| 480 |
} |
| 481 |
|
| 482 |
// there could be a optional stream properties object to follow
|
| 483 |
// if so the next iteration will pick it up
|
| 484 |
} else if (!memcmp(&g, &head1_guid, sizeof(GUID))) { |
| 485 |
int v1, v2;
|
| 486 |
get_guid(pb, &g); |
| 487 |
v1 = get_le32(pb); |
| 488 |
v2 = get_le16(pb); |
| 489 |
#if 0
|
| 490 |
} else if (!memcmp(&g, &codec_comment_header, sizeof(GUID))) {
|
| 491 |
int len, v1, n, num;
|
| 492 |
char str[256], *q;
|
| 493 |
char tag[16];
|
| 494 |
|
| 495 |
get_guid(pb, &g);
|
| 496 |
print_guid(&g);
|
| 497 |
|
| 498 |
n = get_le32(pb);
|
| 499 |
for(i=0;i<n;i++) {
|
| 500 |
num = get_le16(pb); /* stream number */
|
| 501 |
get_str16(pb, str, sizeof(str));
|
| 502 |
get_str16(pb, str, sizeof(str));
|
| 503 |
len = get_le16(pb);
|
| 504 |
q = tag;
|
| 505 |
while (len > 0) {
|
| 506 |
v1 = get_byte(pb);
|
| 507 |
if ((q - tag) < sizeof(tag) - 1)
|
| 508 |
*q++ = v1;
|
| 509 |
len--;
|
| 510 |
}
|
| 511 |
*q = '\0';
|
| 512 |
}
|
| 513 |
#endif
|
| 514 |
} else if (url_feof(pb)) { |
| 515 |
goto fail;
|
| 516 |
} else {
|
| 517 |
url_fseek(pb, gsize - 24, SEEK_CUR);
|
| 518 |
} |
| 519 |
} |
| 520 |
get_guid(pb, &g); |
| 521 |
get_le64(pb); |
| 522 |
get_byte(pb); |
| 523 |
get_byte(pb); |
| 524 |
if (url_feof(pb))
|
| 525 |
goto fail;
|
| 526 |
asf->data_offset = url_ftell(pb); |
| 527 |
asf->packet_size_left = 0;
|
| 528 |
|
| 529 |
|
| 530 |
for(i=0; i<128; i++){ |
| 531 |
int stream_num= asf->asfid2avid[i];
|
| 532 |
if(stream_num>=0){ |
| 533 |
AVCodecContext *codec= s->streams[stream_num]->codec; |
| 534 |
if (!codec->bit_rate)
|
| 535 |
codec->bit_rate = bitrate[i]; |
| 536 |
if (dar[i].num > 0 && dar[i].den > 0) |
| 537 |
av_reduce(&codec->sample_aspect_ratio.num, |
| 538 |
&codec->sample_aspect_ratio.den, |
| 539 |
dar[i].num, dar[i].den, INT_MAX); |
| 540 |
//av_log(NULL, AV_LOG_ERROR, "dar %d:%d sar=%d:%d\n", dar[i].num, dar[i].den, codec->sample_aspect_ratio.num, codec->sample_aspect_ratio.den);
|
| 541 |
} |
| 542 |
} |
| 543 |
|
| 544 |
return 0; |
| 545 |
|
| 546 |
fail:
|
| 547 |
for(i=0;i<s->nb_streams;i++) { |
| 548 |
AVStream *st = s->streams[i]; |
| 549 |
if (st) {
|
| 550 |
av_free(st->priv_data); |
| 551 |
av_free(st->codec->extradata); |
| 552 |
} |
| 553 |
av_free(st); |
| 554 |
} |
| 555 |
return -1; |
| 556 |
} |
| 557 |
|
| 558 |
#define DO_2BITS(bits, var, defval) \
|
| 559 |
switch (bits & 3) \ |
| 560 |
{ \
|
| 561 |
case 3: var = get_le32(pb); rsize += 4; break; \ |
| 562 |
case 2: var = get_le16(pb); rsize += 2; break; \ |
| 563 |
case 1: var = get_byte(pb); rsize++; break; \ |
| 564 |
default: var = defval; break; \ |
| 565 |
} |
| 566 |
|
| 567 |
/**
|
| 568 |
*
|
| 569 |
* @return <0 in case of an error
|
| 570 |
*/
|
| 571 |
static int asf_get_packet(AVFormatContext *s) |
| 572 |
{
|
| 573 |
ASFContext *asf = s->priv_data; |
| 574 |
ByteIOContext *pb = s->pb; |
| 575 |
uint32_t packet_length, padsize; |
| 576 |
int rsize = 8; |
| 577 |
int c, d, e, off;
|
| 578 |
|
| 579 |
off= (url_ftell(s->pb) - s->data_offset) % asf->packet_size + 3;
|
| 580 |
|
| 581 |
c=d=e=-1;
|
| 582 |
while(off-- > 0){ |
| 583 |
c=d; d=e; |
| 584 |
e= get_byte(pb); |
| 585 |
if(c == 0x82 && !d && !e) |
| 586 |
break;
|
| 587 |
} |
| 588 |
|
| 589 |
if (c != 0x82) { |
| 590 |
if (!url_feof(pb))
|
| 591 |
av_log(s, AV_LOG_ERROR, "ff asf bad header %x at:%"PRId64"\n", c, url_ftell(pb)); |
| 592 |
} |
| 593 |
if ((c & 0x8f) == 0x82) { |
| 594 |
if (d || e) {
|
| 595 |
if (!url_feof(pb))
|
| 596 |
av_log(s, AV_LOG_ERROR, "ff asf bad non zero\n");
|
| 597 |
return -1; |
| 598 |
} |
| 599 |
c= get_byte(pb); |
| 600 |
d= get_byte(pb); |
| 601 |
rsize+=3;
|
| 602 |
}else{
|
| 603 |
url_fseek(pb, -1, SEEK_CUR); //FIXME |
| 604 |
} |
| 605 |
|
| 606 |
asf->packet_flags = c; |
| 607 |
asf->packet_property = d; |
| 608 |
|
| 609 |
DO_2BITS(asf->packet_flags >> 5, packet_length, asf->packet_size);
|
| 610 |
DO_2BITS(asf->packet_flags >> 1, padsize, 0); // sequence ignored |
| 611 |
DO_2BITS(asf->packet_flags >> 3, padsize, 0); // padding length |
| 612 |
|
| 613 |
//the following checks prevent overflows and infinite loops
|
| 614 |
if(packet_length >= (1U<<29)){ |
| 615 |
av_log(s, AV_LOG_ERROR, "invalid packet_length %d at:%"PRId64"\n", packet_length, url_ftell(pb)); |
| 616 |
return -1; |
| 617 |
} |
| 618 |
if(padsize >= packet_length){
|
| 619 |
av_log(s, AV_LOG_ERROR, "invalid padsize %d at:%"PRId64"\n", padsize, url_ftell(pb)); |
| 620 |
return -1; |
| 621 |
} |
| 622 |
|
| 623 |
asf->packet_timestamp = get_le32(pb); |
| 624 |
get_le16(pb); /* duration */
|
| 625 |
// rsize has at least 11 bytes which have to be present
|
| 626 |
|
| 627 |
if (asf->packet_flags & 0x01) { |
| 628 |
asf->packet_segsizetype = get_byte(pb); rsize++; |
| 629 |
asf->packet_segments = asf->packet_segsizetype & 0x3f;
|
| 630 |
} else {
|
| 631 |
asf->packet_segments = 1;
|
| 632 |
asf->packet_segsizetype = 0x80;
|
| 633 |
} |
| 634 |
asf->packet_size_left = packet_length - padsize - rsize; |
| 635 |
if (packet_length < asf->hdr.min_pktsize)
|
| 636 |
padsize += asf->hdr.min_pktsize - packet_length; |
| 637 |
asf->packet_padsize = padsize; |
| 638 |
#ifdef DEBUG
|
| 639 |
printf("packet: size=%d padsize=%d left=%d\n", asf->packet_size, asf->packet_padsize, asf->packet_size_left);
|
| 640 |
#endif
|
| 641 |
return 0; |
| 642 |
} |
| 643 |
|
| 644 |
/**
|
| 645 |
*
|
| 646 |
* @return <0 if error
|
| 647 |
*/
|
| 648 |
static int asf_read_frame_header(AVFormatContext *s){ |
| 649 |
ASFContext *asf = s->priv_data; |
| 650 |
ByteIOContext *pb = s->pb; |
| 651 |
int rsize = 1; |
| 652 |
int num = get_byte(pb);
|
| 653 |
int64_t ts0, ts1; |
| 654 |
|
| 655 |
asf->packet_segments--; |
| 656 |
asf->packet_key_frame = num >> 7;
|
| 657 |
asf->stream_index = asf->asfid2avid[num & 0x7f];
|
| 658 |
// sequence should be ignored!
|
| 659 |
DO_2BITS(asf->packet_property >> 4, asf->packet_seq, 0); |
| 660 |
DO_2BITS(asf->packet_property >> 2, asf->packet_frag_offset, 0); |
| 661 |
DO_2BITS(asf->packet_property, asf->packet_replic_size, 0);
|
| 662 |
//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);
|
| 663 |
if (asf->packet_replic_size >= 8) { |
| 664 |
asf->packet_obj_size = get_le32(pb); |
| 665 |
if(asf->packet_obj_size >= (1<<24) || asf->packet_obj_size <= 0){ |
| 666 |
av_log(s, AV_LOG_ERROR, "packet_obj_size invalid\n");
|
| 667 |
return -1; |
| 668 |
} |
| 669 |
asf->packet_frag_timestamp = get_le32(pb); // timestamp
|
| 670 |
if(asf->packet_replic_size >= 8+38+4){ |
| 671 |
// for(i=0; i<asf->packet_replic_size-8; i++)
|
| 672 |
// av_log(s, AV_LOG_DEBUG, "%02X ",get_byte(pb));
|
| 673 |
// av_log(s, AV_LOG_DEBUG, "\n");
|
| 674 |
url_fskip(pb, 10);
|
| 675 |
ts0= get_le64(pb); |
| 676 |
ts1= get_le64(pb); |
| 677 |
url_fskip(pb, 12);
|
| 678 |
get_le32(pb); |
| 679 |
url_fskip(pb, asf->packet_replic_size - 8 - 38 - 4); |
| 680 |
if(ts0!= -1) asf->packet_frag_timestamp= ts0/10000; |
| 681 |
else asf->packet_frag_timestamp= AV_NOPTS_VALUE;
|
| 682 |
}else
|
| 683 |
url_fskip(pb, asf->packet_replic_size - 8);
|
| 684 |
rsize += asf->packet_replic_size; // FIXME - check validity
|
| 685 |
} else if (asf->packet_replic_size==1){ |
| 686 |
// multipacket - frag_offset is beginning timestamp
|
| 687 |
asf->packet_time_start = asf->packet_frag_offset; |
| 688 |
asf->packet_frag_offset = 0;
|
| 689 |
asf->packet_frag_timestamp = asf->packet_timestamp; |
| 690 |
|
| 691 |
asf->packet_time_delta = get_byte(pb); |
| 692 |
rsize++; |
| 693 |
}else if(asf->packet_replic_size!=0){ |
| 694 |
av_log(s, AV_LOG_ERROR, "unexpected packet_replic_size of %d\n", asf->packet_replic_size);
|
| 695 |
return -1; |
| 696 |
} |
| 697 |
if (asf->packet_flags & 0x01) { |
| 698 |
DO_2BITS(asf->packet_segsizetype >> 6, asf->packet_frag_size, 0); // 0 is illegal |
| 699 |
if(asf->packet_frag_size > asf->packet_size_left - rsize){
|
| 700 |
av_log(s, AV_LOG_ERROR, "packet_frag_size is invalid\n");
|
| 701 |
return -1; |
| 702 |
} |
| 703 |
//printf("Fragsize %d\n", asf->packet_frag_size);
|
| 704 |
} else {
|
| 705 |
asf->packet_frag_size = asf->packet_size_left - rsize; |
| 706 |
//printf("Using rest %d %d %d\n", asf->packet_frag_size, asf->packet_size_left, rsize);
|
| 707 |
} |
| 708 |
if (asf->packet_replic_size == 1) { |
| 709 |
asf->packet_multi_size = asf->packet_frag_size; |
| 710 |
if (asf->packet_multi_size > asf->packet_size_left)
|
| 711 |
return -1; |
| 712 |
} |
| 713 |
asf->packet_size_left -= rsize; |
| 714 |
//printf("___objsize____ %d %d rs:%d\n", asf->packet_obj_size, asf->packet_frag_offset, rsize);
|
| 715 |
|
| 716 |
return 0; |
| 717 |
} |
| 718 |
|
| 719 |
static int asf_read_packet(AVFormatContext *s, AVPacket *pkt) |
| 720 |
{
|
| 721 |
ASFContext *asf = s->priv_data; |
| 722 |
ASFStream *asf_st = 0;
|
| 723 |
ByteIOContext *pb = s->pb; |
| 724 |
//static int pc = 0;
|
| 725 |
for (;;) {
|
| 726 |
if(url_feof(pb))
|
| 727 |
return AVERROR(EIO);
|
| 728 |
if (asf->packet_size_left < FRAME_HEADER_SIZE
|
| 729 |
|| asf->packet_segments < 1) {
|
| 730 |
//asf->packet_size_left <= asf->packet_padsize) {
|
| 731 |
int ret = asf->packet_size_left + asf->packet_padsize;
|
| 732 |
//printf("PacketLeftSize:%d Pad:%d Pos:%"PRId64"\n", asf->packet_size_left, asf->packet_padsize, url_ftell(pb));
|
| 733 |
assert(ret>=0);
|
| 734 |
/* fail safe */
|
| 735 |
url_fskip(pb, ret); |
| 736 |
|
| 737 |
asf->packet_pos= url_ftell(s->pb); |
| 738 |
if (asf->data_object_size != (uint64_t)-1 && |
| 739 |
(asf->packet_pos - asf->data_object_offset >= asf->data_object_size)) |
| 740 |
return AVERROR(EIO); /* Do not exceed the size of the data object */ |
| 741 |
ret = asf_get_packet(s); |
| 742 |
//printf("READ ASF PACKET %d r:%d c:%d\n", ret, asf->packet_size_left, pc++);
|
| 743 |
if (ret < 0) |
| 744 |
assert(asf->packet_size_left < FRAME_HEADER_SIZE || asf->packet_segments < 1);
|
| 745 |
asf->packet_time_start = 0;
|
| 746 |
continue;
|
| 747 |
} |
| 748 |
if (asf->packet_time_start == 0) { |
| 749 |
if(asf_read_frame_header(s) < 0){ |
| 750 |
asf->packet_segments= 0;
|
| 751 |
continue;
|
| 752 |
} |
| 753 |
if (asf->stream_index < 0 |
| 754 |
|| s->streams[asf->stream_index]->discard >= AVDISCARD_ALL |
| 755 |
|| (!asf->packet_key_frame && s->streams[asf->stream_index]->discard >= AVDISCARD_NONKEY) |
| 756 |
) {
|
| 757 |
asf->packet_time_start = 0;
|
| 758 |
/* unhandled packet (should not happen) */
|
| 759 |
url_fskip(pb, asf->packet_frag_size); |
| 760 |
asf->packet_size_left -= asf->packet_frag_size; |
| 761 |
if(asf->stream_index < 0) |
| 762 |
av_log(s, AV_LOG_ERROR, "ff asf skip %d (unknown stream)\n", asf->packet_frag_size);
|
| 763 |
continue;
|
| 764 |
} |
| 765 |
asf->asf_st = s->streams[asf->stream_index]->priv_data; |
| 766 |
} |
| 767 |
asf_st = asf->asf_st; |
| 768 |
|
| 769 |
if (asf->packet_replic_size == 1) { |
| 770 |
// frag_offset is here used as the beginning timestamp
|
| 771 |
asf->packet_frag_timestamp = asf->packet_time_start; |
| 772 |
asf->packet_time_start += asf->packet_time_delta; |
| 773 |
asf->packet_obj_size = asf->packet_frag_size = get_byte(pb); |
| 774 |
asf->packet_size_left--; |
| 775 |
asf->packet_multi_size--; |
| 776 |
if (asf->packet_multi_size < asf->packet_obj_size)
|
| 777 |
{
|
| 778 |
asf->packet_time_start = 0;
|
| 779 |
url_fskip(pb, asf->packet_multi_size); |
| 780 |
asf->packet_size_left -= asf->packet_multi_size; |
| 781 |
continue;
|
| 782 |
} |
| 783 |
asf->packet_multi_size -= asf->packet_obj_size; |
| 784 |
//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);
|
| 785 |
} |
| 786 |
if( /*asf->packet_frag_size == asf->packet_obj_size*/ |
| 787 |
asf_st->frag_offset + asf->packet_frag_size <= asf_st->pkt.size |
| 788 |
&& asf_st->frag_offset + asf->packet_frag_size > asf->packet_obj_size){
|
| 789 |
av_log(s, AV_LOG_INFO, "ignoring invalid packet_obj_size (%d %d %d %d)\n",
|
| 790 |
asf_st->frag_offset, asf->packet_frag_size, |
| 791 |
asf->packet_obj_size, asf_st->pkt.size); |
| 792 |
asf->packet_obj_size= asf_st->pkt.size; |
| 793 |
} |
| 794 |
|
| 795 |
if ( asf_st->pkt.size != asf->packet_obj_size
|
| 796 |
|| asf_st->frag_offset + asf->packet_frag_size > asf_st->pkt.size) { //FIXME is this condition sufficient?
|
| 797 |
if(asf_st->pkt.data){
|
| 798 |
av_log(s, AV_LOG_INFO, "freeing incomplete packet size %d, new %d\n", asf_st->pkt.size, asf->packet_obj_size);
|
| 799 |
asf_st->frag_offset = 0;
|
| 800 |
av_free_packet(&asf_st->pkt); |
| 801 |
} |
| 802 |
/* new packet */
|
| 803 |
av_new_packet(&asf_st->pkt, asf->packet_obj_size); |
| 804 |
asf_st->seq = asf->packet_seq; |
| 805 |
asf_st->pkt.pts = asf->packet_frag_timestamp; |
| 806 |
asf_st->pkt.stream_index = asf->stream_index; |
| 807 |
asf_st->pkt.pos = |
| 808 |
asf_st->packet_pos= asf->packet_pos; |
| 809 |
//printf("new packet: stream:%d key:%d packet_key:%d audio:%d size:%d\n",
|
| 810 |
//asf->stream_index, asf->packet_key_frame, asf_st->pkt.flags & PKT_FLAG_KEY,
|
| 811 |
//s->streams[asf->stream_index]->codec->codec_type == CODEC_TYPE_AUDIO, asf->packet_obj_size);
|
| 812 |
if (s->streams[asf->stream_index]->codec->codec_type == CODEC_TYPE_AUDIO)
|
| 813 |
asf->packet_key_frame = 1;
|
| 814 |
if (asf->packet_key_frame)
|
| 815 |
asf_st->pkt.flags |= PKT_FLAG_KEY; |
| 816 |
} |
| 817 |
|
| 818 |
/* read data */
|
| 819 |
//printf("READ PACKET s:%d os:%d o:%d,%d l:%d DATA:%p\n",
|
| 820 |
// asf->packet_size, asf_st->pkt.size, asf->packet_frag_offset,
|
| 821 |
// asf_st->frag_offset, asf->packet_frag_size, asf_st->pkt.data);
|
| 822 |
asf->packet_size_left -= asf->packet_frag_size; |
| 823 |
if (asf->packet_size_left < 0) |
| 824 |
continue;
|
| 825 |
|
| 826 |
if( asf->packet_frag_offset >= asf_st->pkt.size
|
| 827 |
|| asf->packet_frag_size > asf_st->pkt.size - asf->packet_frag_offset){
|
| 828 |
av_log(s, AV_LOG_ERROR, "packet fragment position invalid %u,%u not in %u\n",
|
| 829 |
asf->packet_frag_offset, asf->packet_frag_size, asf_st->pkt.size); |
| 830 |
continue;
|
| 831 |
} |
| 832 |
|
| 833 |
get_buffer(pb, asf_st->pkt.data + asf->packet_frag_offset, |
| 834 |
asf->packet_frag_size); |
| 835 |
if (s->key && s->keylen == 20) |
| 836 |
ff_asfcrypt_dec(s->key, asf_st->pkt.data + asf->packet_frag_offset, |
| 837 |
asf->packet_frag_size); |
| 838 |
asf_st->frag_offset += asf->packet_frag_size; |
| 839 |
/* test if whole packet is read */
|
| 840 |
if (asf_st->frag_offset == asf_st->pkt.size) {
|
| 841 |
//workaround for macroshit radio DVR-MS files
|
| 842 |
if( s->streams[asf->stream_index]->codec->codec_id == CODEC_ID_MPEG2VIDEO
|
| 843 |
&& asf_st->pkt.size > 100){
|
| 844 |
int i;
|
| 845 |
for(i=0; i<asf_st->pkt.size && !asf_st->pkt.data[i]; i++); |
| 846 |
if(i == asf_st->pkt.size){
|
| 847 |
av_log(s, AV_LOG_DEBUG, "discarding ms fart\n");
|
| 848 |
asf_st->frag_offset = 0;
|
| 849 |
av_free_packet(&asf_st->pkt); |
| 850 |
continue;
|
| 851 |
} |
| 852 |
} |
| 853 |
|
| 854 |
/* return packet */
|
| 855 |
if (asf_st->ds_span > 1) { |
| 856 |
if(asf_st->pkt.size != asf_st->ds_packet_size * asf_st->ds_span){
|
| 857 |
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);
|
| 858 |
}else{
|
| 859 |
/* packet descrambling */
|
| 860 |
uint8_t *newdata = av_malloc(asf_st->pkt.size); |
| 861 |
if (newdata) {
|
| 862 |
int offset = 0; |
| 863 |
while (offset < asf_st->pkt.size) {
|
| 864 |
int off = offset / asf_st->ds_chunk_size;
|
| 865 |
int row = off / asf_st->ds_span;
|
| 866 |
int col = off % asf_st->ds_span;
|
| 867 |
int idx = row + col * asf_st->ds_packet_size / asf_st->ds_chunk_size;
|
| 868 |
//printf("off:%d row:%d col:%d idx:%d\n", off, row, col, idx);
|
| 869 |
|
| 870 |
assert(offset + asf_st->ds_chunk_size <= asf_st->pkt.size); |
| 871 |
assert(idx+1 <= asf_st->pkt.size / asf_st->ds_chunk_size);
|
| 872 |
memcpy(newdata + offset, |
| 873 |
asf_st->pkt.data + idx * asf_st->ds_chunk_size, |
| 874 |
asf_st->ds_chunk_size); |
| 875 |
offset += asf_st->ds_chunk_size; |
| 876 |
} |
| 877 |
av_free(asf_st->pkt.data); |
| 878 |
asf_st->pkt.data = newdata; |
| 879 |
} |
| 880 |
} |
| 881 |
} |
| 882 |
asf_st->frag_offset = 0;
|
| 883 |
*pkt= asf_st->pkt; |
| 884 |
//printf("packet %d %d\n", asf_st->pkt.size, asf->packet_frag_size);
|
| 885 |
asf_st->pkt.size = 0;
|
| 886 |
asf_st->pkt.data = 0;
|
| 887 |
break; // packet completed |
| 888 |
} |
| 889 |
} |
| 890 |
return 0; |
| 891 |
} |
| 892 |
|
| 893 |
// Added to support seeking after packets have been read
|
| 894 |
// If information is not reset, read_packet fails due to
|
| 895 |
// leftover information from previous reads
|
| 896 |
static void asf_reset_header(AVFormatContext *s) |
| 897 |
{
|
| 898 |
ASFContext *asf = s->priv_data; |
| 899 |
ASFStream *asf_st; |
| 900 |
int i;
|
| 901 |
|
| 902 |
asf->packet_nb_frames = 0;
|
| 903 |
asf->packet_size_left = 0;
|
| 904 |
asf->packet_segments = 0;
|
| 905 |
asf->packet_flags = 0;
|
| 906 |
asf->packet_property = 0;
|
| 907 |
asf->packet_timestamp = 0;
|
| 908 |
asf->packet_segsizetype = 0;
|
| 909 |
asf->packet_segments = 0;
|
| 910 |
asf->packet_seq = 0;
|
| 911 |
asf->packet_replic_size = 0;
|
| 912 |
asf->packet_key_frame = 0;
|
| 913 |
asf->packet_padsize = 0;
|
| 914 |
asf->packet_frag_offset = 0;
|
| 915 |
asf->packet_frag_size = 0;
|
| 916 |
asf->packet_frag_timestamp = 0;
|
| 917 |
asf->packet_multi_size = 0;
|
| 918 |
asf->packet_obj_size = 0;
|
| 919 |
asf->packet_time_delta = 0;
|
| 920 |
asf->packet_time_start = 0;
|
| 921 |
|
| 922 |
for(i=0; i<s->nb_streams; i++){ |
| 923 |
asf_st= s->streams[i]->priv_data; |
| 924 |
av_free_packet(&asf_st->pkt); |
| 925 |
asf_st->frag_offset=0;
|
| 926 |
asf_st->seq=0;
|
| 927 |
} |
| 928 |
asf->asf_st= NULL;
|
| 929 |
} |
| 930 |
|
| 931 |
static int asf_read_close(AVFormatContext *s) |
| 932 |
{
|
| 933 |
int i;
|
| 934 |
|
| 935 |
asf_reset_header(s); |
| 936 |
for(i=0;i<s->nb_streams;i++) { |
| 937 |
AVStream *st = s->streams[i]; |
| 938 |
av_free(st->priv_data); |
| 939 |
av_free(st->codec->palctrl); |
| 940 |
} |
| 941 |
return 0; |
| 942 |
} |
| 943 |
|
| 944 |
static int64_t asf_read_pts(AVFormatContext *s, int stream_index, int64_t *ppos, int64_t pos_limit) |
| 945 |
{
|
| 946 |
ASFContext *asf = s->priv_data; |
| 947 |
AVPacket pkt1, *pkt = &pkt1; |
| 948 |
ASFStream *asf_st; |
| 949 |
int64_t pts; |
| 950 |
int64_t pos= *ppos; |
| 951 |
int i;
|
| 952 |
int64_t start_pos[s->nb_streams]; |
| 953 |
|
| 954 |
for(i=0; i<s->nb_streams; i++){ |
| 955 |
start_pos[i]= pos; |
| 956 |
} |
| 957 |
|
| 958 |
pos= (pos+asf->packet_size-1-s->data_offset)/asf->packet_size*asf->packet_size+ s->data_offset;
|
| 959 |
*ppos= pos; |
| 960 |
url_fseek(s->pb, pos, SEEK_SET); |
| 961 |
|
| 962 |
//printf("asf_read_pts\n");
|
| 963 |
asf_reset_header(s); |
| 964 |
for(;;){
|
| 965 |
if (av_read_frame(s, pkt) < 0){ |
| 966 |
av_log(s, AV_LOG_INFO, "asf_read_pts failed\n");
|
| 967 |
return AV_NOPTS_VALUE;
|
| 968 |
} |
| 969 |
|
| 970 |
pts= pkt->pts; |
| 971 |
|
| 972 |
av_free_packet(pkt); |
| 973 |
if(pkt->flags&PKT_FLAG_KEY){
|
| 974 |
i= pkt->stream_index; |
| 975 |
|
| 976 |
asf_st= s->streams[i]->priv_data; |
| 977 |
|
| 978 |
// assert((asf_st->packet_pos - s->data_offset) % asf->packet_size == 0);
|
| 979 |
pos= asf_st->packet_pos; |
| 980 |
|
| 981 |
av_add_index_entry(s->streams[i], pos, pts, pkt->size, pos - start_pos[i] + 1, AVINDEX_KEYFRAME);
|
| 982 |
start_pos[i]= asf_st->packet_pos + 1;
|
| 983 |
|
| 984 |
if(pkt->stream_index == stream_index)
|
| 985 |
break;
|
| 986 |
} |
| 987 |
} |
| 988 |
|
| 989 |
*ppos= pos; |
| 990 |
//printf("found keyframe at %"PRId64" stream %d stamp:%"PRId64"\n", *ppos, stream_index, pts);
|
| 991 |
|
| 992 |
return pts;
|
| 993 |
} |
| 994 |
|
| 995 |
static void asf_build_simple_index(AVFormatContext *s, int stream_index) |
| 996 |
{
|
| 997 |
GUID g; |
| 998 |
ASFContext *asf = s->priv_data; |
| 999 |
int64_t gsize, itime; |
| 1000 |
int64_t pos, current_pos, index_pts; |
| 1001 |
int i;
|
| 1002 |
int pct,ict;
|
| 1003 |
|
| 1004 |
current_pos = url_ftell(s->pb); |
| 1005 |
|
| 1006 |
url_fseek(s->pb, asf->data_object_offset + asf->data_object_size, SEEK_SET); |
| 1007 |
get_guid(s->pb, &g); |
| 1008 |
if (!memcmp(&g, &index_guid, sizeof(GUID))) { |
| 1009 |
gsize = get_le64(s->pb); |
| 1010 |
get_guid(s->pb, &g); |
| 1011 |
itime=get_le64(s->pb); |
| 1012 |
pct=get_le32(s->pb); |
| 1013 |
ict=get_le32(s->pb); |
| 1014 |
av_log(NULL, AV_LOG_DEBUG, "itime:0x%"PRIx64", pct:%d, ict:%d\n",itime,pct,ict); |
| 1015 |
|
| 1016 |
for (i=0;i<ict;i++){ |
| 1017 |
int pktnum=get_le32(s->pb);
|
| 1018 |
int pktct =get_le16(s->pb);
|
| 1019 |
av_log(NULL, AV_LOG_DEBUG, "pktnum:%d, pktct:%d\n", pktnum, pktct); |
| 1020 |
|
| 1021 |
pos=s->data_offset + asf->packet_size*(int64_t)pktnum; |
| 1022 |
index_pts=av_rescale(itime, i, 10000);
|
| 1023 |
|
| 1024 |
av_add_index_entry(s->streams[stream_index], pos, index_pts, asf->packet_size, 0, AVINDEX_KEYFRAME);
|
| 1025 |
} |
| 1026 |
asf->index_read= 1;
|
| 1027 |
} |
| 1028 |
url_fseek(s->pb, current_pos, SEEK_SET); |
| 1029 |
} |
| 1030 |
|
| 1031 |
static int asf_read_seek(AVFormatContext *s, int stream_index, int64_t pts, int flags) |
| 1032 |
{
|
| 1033 |
ASFContext *asf = s->priv_data; |
| 1034 |
AVStream *st = s->streams[stream_index]; |
| 1035 |
int64_t pos; |
| 1036 |
int index;
|
| 1037 |
|
| 1038 |
if (asf->packet_size <= 0) |
| 1039 |
return -1; |
| 1040 |
|
| 1041 |
/* Try using the protocol's read_seek if available */
|
| 1042 |
if(s->pb) {
|
| 1043 |
int ret = av_url_read_fseek(s->pb, stream_index, pts, flags);
|
| 1044 |
if(ret >= 0) |
| 1045 |
asf_reset_header(s); |
| 1046 |
if (ret != AVERROR(ENOSYS))
|
| 1047 |
return ret;
|
| 1048 |
} |
| 1049 |
|
| 1050 |
if (!asf->index_read)
|
| 1051 |
asf_build_simple_index(s, stream_index); |
| 1052 |
|
| 1053 |
if(!(asf->index_read && st->index_entries)){
|
| 1054 |
if(av_seek_frame_binary(s, stream_index, pts, flags)<0) |
| 1055 |
return -1; |
| 1056 |
}else{
|
| 1057 |
index= av_index_search_timestamp(st, pts, flags); |
| 1058 |
if(index<0) |
| 1059 |
return -1; |
| 1060 |
|
| 1061 |
/* find the position */
|
| 1062 |
pos = st->index_entries[index].pos; |
| 1063 |
pts = st->index_entries[index].timestamp; |
| 1064 |
|
| 1065 |
// various attempts to find key frame have failed so far
|
| 1066 |
// asf_reset_header(s);
|
| 1067 |
// url_fseek(s->pb, pos, SEEK_SET);
|
| 1068 |
// key_pos = pos;
|
| 1069 |
// for(i=0;i<16;i++){
|
| 1070 |
// pos = url_ftell(s->pb);
|
| 1071 |
// if (av_read_frame(s, &pkt) < 0){
|
| 1072 |
// av_log(s, AV_LOG_INFO, "seek failed\n");
|
| 1073 |
// return -1;
|
| 1074 |
// }
|
| 1075 |
// asf_st = s->streams[stream_index]->priv_data;
|
| 1076 |
// pos += st->parser->frame_offset;
|
| 1077 |
//
|
| 1078 |
// if (pkt.size > b) {
|
| 1079 |
// b = pkt.size;
|
| 1080 |
// key_pos = pos;
|
| 1081 |
// }
|
| 1082 |
//
|
| 1083 |
// av_free_packet(&pkt);
|
| 1084 |
// }
|
| 1085 |
|
| 1086 |
/* do the seek */
|
| 1087 |
av_log(NULL, AV_LOG_DEBUG, "SEEKTO: %"PRId64"\n", pos); |
| 1088 |
url_fseek(s->pb, pos, SEEK_SET); |
| 1089 |
} |
| 1090 |
asf_reset_header(s); |
| 1091 |
return 0; |
| 1092 |
} |
| 1093 |
|
| 1094 |
AVInputFormat asf_demuxer = {
|
| 1095 |
"asf",
|
| 1096 |
"asf format",
|
| 1097 |
sizeof(ASFContext),
|
| 1098 |
asf_probe, |
| 1099 |
asf_read_header, |
| 1100 |
asf_read_packet, |
| 1101 |
asf_read_close, |
| 1102 |
asf_read_seek, |
| 1103 |
asf_read_pts, |
| 1104 |
}; |