libavformat/asf.c

   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
  26 #undef NDEBUG
  27 #include <assert.h>
  28
  29 #define FRAME_HEADER_SIZE 17
  30 // Fix Me! FRAME_HEADER_SIZE may be different.
  31
  32 static const GUID index_guid = {
  33     0x33000890, 0xe5b1, 0x11cf, { 0x89, 0xf4, 0x00, 0xa0, 0xc9, 0x03, 0x49, 0xcb },
  34 };
  35
  36 /**********************************/
  37 /* decoding */
  38
  39 //#define DEBUG
  40
  41 #ifdef DEBUG
  42 #define PRINT_IF_GUID(g,cmp) \
  43 if (!memcmp(g, &cmp, sizeof(GUID))) \
  44     printf("(GUID: %s) ", #cmp)
  45
  46 static void print_guid(const GUID *g)
  47 {
  48     int i;
  49     PRINT_IF_GUID(g, asf_header);
  50     else PRINT_IF_GUID(g, file_header);
  51     else PRINT_IF_GUID(g, stream_header);
  52     else PRINT_IF_GUID(g, audio_stream);
  53     else PRINT_IF_GUID(g, audio_conceal_none);
  54     else PRINT_IF_GUID(g, video_stream);
  55     else PRINT_IF_GUID(g, video_conceal_none);
  56     else PRINT_IF_GUID(g, command_stream);
  57     else PRINT_IF_GUID(g, comment_header);
  58     else PRINT_IF_GUID(g, codec_comment_header);
  59     else PRINT_IF_GUID(g, codec_comment1_header);
  60     else PRINT_IF_GUID(g, data_header);
  61     else PRINT_IF_GUID(g, index_guid);
  62     else PRINT_IF_GUID(g, head1_guid);
  63     else PRINT_IF_GUID(g, head2_guid);
  64     else PRINT_IF_GUID(g, my_guid);
  65     else PRINT_IF_GUID(g, ext_stream_header);
  66     else PRINT_IF_GUID(g, extended_content_header);
  67     else PRINT_IF_GUID(g, ext_stream_embed_stream_header);
  68     else PRINT_IF_GUID(g, ext_stream_audio_stream);
  69     else
  70         printf("(GUID: unknown) ");
  71     printf("0x%08x, 0x%04x, 0x%04x, {", g->v1, g->v2, g->v3);
  72     for(i=0;i<8;i++)
  73         printf(" 0x%02x,", g->v4[i]);
  74     printf("}\n");
  75 }
  76 #undef PRINT_IF_GUID
  77 #endif
  78
  79 static void get_guid(ByteIOContext *s, GUID *g)
  80 {
  81     int i;
  82
  83     g->v1 = get_le32(s);
  84     g->v2 = get_le16(s);
  85     g->v3 = get_le16(s);
  86     for(i=0;i<8;i++)
  87         g->v4[i] = get_byte(s);
  88 }
  89
  90 #if 0
  91 static void get_str16(ByteIOContext *pb, char *buf, int buf_size)
  92 {
  93     int len, c;
  94     char *q;
  95
  96     len = get_le16(pb);
  97     q = buf;
  98     while (len > 0) {
  99         c = get_le16(pb);
 100         if ((q - buf) < buf_size - 1)
 101             *q++ = c;
 102         len--;
 103     }
 104     *q = '\0';
 105 }
 106 #endif
 107
 108 static void get_str16_nolen(ByteIOContext *pb, int len, char *buf, int buf_size)
 109 {
 110     int c;
 111     char *q;
 112
 113     q = buf;
 114     while (len > 0) {
 115         c = get_le16(pb);
 116         if ((q - buf) < buf_size - 1)
 117             *q++ = c;
 118         len-=2;
 119     }
 120     *q = '\0';
 121 }
 122
 123 static int asf_probe(AVProbeData *pd)
 124 {
 125     GUID g;
 126     const unsigned char *p;
 127     int i;
 128
 129     /* check file header */
 130     if (pd->buf_size <= 32)
 131         return 0;
 132     p = pd->buf;
 133     g.v1 = p[0] | (p[1] << 8) | (p[2] << 16) | (p[3] << 24);
 134     p += 4;
 135     g.v2 = p[0] | (p[1] << 8);
 136     p += 2;
 137     g.v3 = p[0] | (p[1] << 8);
 138     p += 2;
 139     for(i=0;i<8;i++)
 140         g.v4[i] = *p++;
 141
 142     if (!memcmp(&g, &asf_header, sizeof(GUID)))
 143         return AVPROBE_SCORE_MAX;
 144     else
 145         return 0;
 146 }
 147
 148 static int asf_read_header(AVFormatContext *s, AVFormatParameters *ap)
 149 {
 150     ASFContext *asf = s->priv_data;
 151     GUID g;
 152     ByteIOContext *pb = &s->pb;
 153     AVStream *st;
 154     ASFStream *asf_st;
 155     int size, i;
 156     int64_t gsize;
 157
 158     get_guid(pb, &g);
 159     if (memcmp(&g, &asf_header, sizeof(GUID)))
 160         goto fail;
 161     get_le64(pb);
 162     get_le32(pb);
 163     get_byte(pb);
 164     get_byte(pb);
 165     memset(&asf->asfid2avid, -1, sizeof(asf->asfid2avid));
 166     for(;;) {
 167         get_guid(pb, &g);
 168         gsize = get_le64(pb);
 169 #ifdef DEBUG
 170         printf("%08"PRIx64": ", url_ftell(pb) - 24);
 171         print_guid(&g);
 172         printf("  size=0x%"PRIx64"\n", gsize);
 173 #endif
 174         if (gsize < 24)
 175             goto fail;
 176         if (!memcmp(&g, &file_header, sizeof(GUID))) {
 177             get_guid(pb, &asf->hdr.guid);
 178             asf->hdr.file_size          = get_le64(pb);
 179             asf->hdr.create_time        = get_le64(pb);
 180             asf->hdr.packets_count      = get_le64(pb);
 181             asf->hdr.send_time          = get_le64(pb);
 182             asf->hdr.play_time          = get_le64(pb);
 183             asf->hdr.preroll            = get_le32(pb);
 184             asf->hdr.ignore             = get_le32(pb);
 185             asf->hdr.flags              = get_le32(pb);
 186             asf->hdr.min_pktsize        = get_le32(pb);
 187             asf->hdr.max_pktsize        = get_le32(pb);
 188             asf->hdr.max_bitrate        = get_le32(pb);
 189             asf->packet_size = asf->hdr.max_pktsize;
 190             asf->nb_packets = asf->hdr.packets_count;
 191         } else if (!memcmp(&g, &stream_header, sizeof(GUID))) {
 192             int type, type_specific_size, sizeX;
 193             uint64_t total_size;
 194             unsigned int tag1;
 195             int64_t pos1, pos2;
 196             int test_for_ext_stream_audio;
 197
 198             pos1 = url_ftell(pb);
 199
 200             st = av_new_stream(s, 0);
 201             if (!st)
 202                 goto fail;
 203             av_set_pts_info(st, 32, 1, 1000); /* 32 bit pts in ms */
 204             asf_st = av_mallocz(sizeof(ASFStream));
 205             if (!asf_st)
 206                 goto fail;
 207             st->priv_data = asf_st;
 208             st->start_time = asf->hdr.preroll;
 209             st->duration = asf->hdr.send_time /
 210                 (10000000 / 1000) - st->start_time;
 211             get_guid(pb, &g);
 212
 213             test_for_ext_stream_audio = 0;
 214             if (!memcmp(&g, &audio_stream, sizeof(GUID))) {
 215                 type = CODEC_TYPE_AUDIO;
 216             } else if (!memcmp(&g, &video_stream, sizeof(GUID))) {
 217                 type = CODEC_TYPE_VIDEO;
 218             } else if (!memcmp(&g, &command_stream, sizeof(GUID))) {
 219                 type = CODEC_TYPE_UNKNOWN;
 220             } else if (!memcmp(&g, &ext_stream_embed_stream_header, sizeof(GUID))) {
 221                 test_for_ext_stream_audio = 1;
 222                 type = CODEC_TYPE_UNKNOWN;
 223             } else {
 224                 goto fail;
 225             }
 226             get_guid(pb, &g);
 227             total_size = get_le64(pb);
 228             type_specific_size = get_le32(pb);
 229             get_le32(pb);
 230             st->id = get_le16(pb) & 0x7f; /* stream id */
 231             // mapping of asf ID to AV stream ID;
 232             asf->asfid2avid[st->id] = s->nb_streams - 1;
 233
 234             get_le32(pb);
 235
 236             if (test_for_ext_stream_audio) {
 237                 get_guid(pb, &g);
 238                 if (!memcmp(&g, &ext_stream_audio_stream, sizeof(GUID))) {
 239                     type = CODEC_TYPE_AUDIO;
 240                     get_guid(pb, &g);
 241                     get_le32(pb);
 242                     get_le32(pb);
 243                     get_le32(pb);
 244                     get_guid(pb, &g);
 245                     get_le32(pb);
 246                 }
 247             }
 248
 249             st->codec->codec_type = type;
 250             if (type == CODEC_TYPE_AUDIO) {
 251                 get_wav_header(pb, st->codec, type_specific_size);
 252                 st->need_parsing = 1;
 253                 /* We have to init the frame size at some point .... */
 254                 pos2 = url_ftell(pb);
 255                 if (gsize > (pos2 + 8 - pos1 + 24)) {
 256                     asf_st->ds_span = get_byte(pb);
 257                     asf_st->ds_packet_size = get_le16(pb);
 258                     asf_st->ds_chunk_size = get_le16(pb);
 259                     asf_st->ds_data_size = get_le16(pb);
 260                     asf_st->ds_silence_data = get_byte(pb);
 261                 }
 262                 //printf("Descrambling: ps:%d cs:%d ds:%d s:%d  sd:%d\n",
 263                 //       asf_st->ds_packet_size, asf_st->ds_chunk_size,
 264                 //       asf_st->ds_data_size, asf_st->ds_span, asf_st->ds_silence_data);
 265                 if (asf_st->ds_span > 1) {
 266                     if (!asf_st->ds_chunk_size
 267                         || (asf_st->ds_packet_size/asf_st->ds_chunk_size <= 1))
 268                         asf_st->ds_span = 0; // disable descrambling
 269                 }
 270                 switch (st->codec->codec_id) {
 271                 case CODEC_ID_MP3:
 272                     st->codec->frame_size = MPA_FRAME_SIZE;
 273                     break;
 274                 case CODEC_ID_PCM_S16LE:
 275                 case CODEC_ID_PCM_S16BE:
 276                 case CODEC_ID_PCM_U16LE:
 277                 case CODEC_ID_PCM_U16BE:
 278                 case CODEC_ID_PCM_S8:
 279                 case CODEC_ID_PCM_U8:
 280                 case CODEC_ID_PCM_ALAW:
 281                 case CODEC_ID_PCM_MULAW:
 282                     st->codec->frame_size = 1;
 283                     break;
 284                 default:
 285                     /* This is probably wrong, but it prevents a crash later */
 286                     st->codec->frame_size = 1;
 287                     break;
 288                 }
 289             } else if (type == CODEC_TYPE_VIDEO) {
 290                 get_le32(pb);
 291                 get_le32(pb);
 292                 get_byte(pb);
 293                 size = get_le16(pb); /* size */
 294                 sizeX= get_le32(pb); /* size */
 295                 st->codec->width = get_le32(pb);
 296                 st->codec->height = get_le32(pb);
 297                 /* not available for asf */
 298                 get_le16(pb); /* panes */
 299                 st->codec->bits_per_sample = get_le16(pb); /* depth */
 300                 tag1 = get_le32(pb);
 301                 url_fskip(pb, 20);
 302 //                av_log(NULL, AV_LOG_DEBUG, "size:%d tsize:%d sizeX:%d\n", size, total_size, sizeX);
 303                 size= sizeX;
 304                 if (size > 40) {
 305                     st->codec->extradata_size = size - 40;
 306                     st->codec->extradata = av_mallocz(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
 307                     get_buffer(pb, st->codec->extradata, st->codec->extradata_size);
 308                 }
 309
 310         /* Extract palette from extradata if bpp <= 8 */
 311         /* This code assumes that extradata contains only palette */
 312         /* This is true for all paletted codecs implemented in ffmpeg */
 313         if (st->codec->extradata_size && (st->codec->bits_per_sample <= 8)) {
 314             st->codec->palctrl = av_mallocz(sizeof(AVPaletteControl));
 315 #ifdef WORDS_BIGENDIAN
 316             for (i = 0; i < FFMIN(st->codec->extradata_size, AVPALETTE_SIZE)/4; i++)
 317                 st->codec->palctrl->palette[i] = bswap_32(((uint32_t*)st->codec->extradata)[i]);
 318 #else
 319             memcpy(st->codec->palctrl->palette, st->codec->extradata,
 320                    FFMIN(st->codec->extradata_size, AVPALETTE_SIZE));
 321 #endif
 322             st->codec->palctrl->palette_changed = 1;
 323         }
 324
 325                 st->codec->codec_tag = tag1;
 326                 st->codec->codec_id = codec_get_id(codec_bmp_tags, tag1);
 327                 if(tag1 == MKTAG('D', 'V', 'R', ' '))
 328                     st->need_parsing = 1;
 329             }
 330             pos2 = url_ftell(pb);
 331             url_fskip(pb, gsize - (pos2 - pos1 + 24));
 332         } else if (!memcmp(&g, &data_header, sizeof(GUID))) {
 333             asf->data_object_offset = url_ftell(pb);
 334             if (gsize != (uint64_t)-1 && gsize >= 24) {
 335                 asf->data_object_size = gsize - 24;
 336             } else {
 337                 asf->data_object_size = (uint64_t)-1;
 338             }
 339             break;
 340         } else if (!memcmp(&g, &comment_header, sizeof(GUID))) {
 341             int len1, len2, len3, len4, len5;
 342
 343             len1 = get_le16(pb);
 344             len2 = get_le16(pb);
 345             len3 = get_le16(pb);
 346             len4 = get_le16(pb);
 347             len5 = get_le16(pb);
 348             get_str16_nolen(pb, len1, s->title, sizeof(s->title));
 349             get_str16_nolen(pb, len2, s->author, sizeof(s->author));
 350             get_str16_nolen(pb, len3, s->copyright, sizeof(s->copyright));
 351             get_str16_nolen(pb, len4, s->comment, sizeof(s->comment));
 352             url_fskip(pb, len5);
 353        } else if (!memcmp(&g, &extended_content_header, sizeof(GUID))) {
 354                 int desc_count, i;
 355
 356                 desc_count = get_le16(pb);
 357                 for(i=0;i<desc_count;i++)
 358                 {
 359                         int name_len,value_type,value_len;
 360                         uint64_t value_num = 0;
 361                         char *name, *value;
 362
 363                         name_len = get_le16(pb);
 364                         name = (char *)av_mallocz(name_len);
 365                         get_str16_nolen(pb, name_len, name, name_len);
 366                         value_type = get_le16(pb);
 367                         value_len = get_le16(pb);
 368                         if ((value_type == 0) || (value_type == 1)) // unicode or byte
 369                         {
 370                                 value = (char *)av_mallocz(value_len);
 371                                 get_str16_nolen(pb, value_len, value, value_len);
 372                                 if (strcmp(name,"WM/AlbumTitle")==0) { pstrcpy(s->album, sizeof(s->album), value); }
 373                                 av_free(value);
 374                         }
 375                         if ((value_type >= 2) && (value_type <= 5)) // boolean or DWORD or QWORD or WORD
 376                         {
 377                                 if (value_type==2) value_num = get_le32(pb);
 378                                 if (value_type==3) value_num = get_le32(pb);
 379                                 if (value_type==4) value_num = get_le64(pb);
 380                                 if (value_type==5) value_num = get_le16(pb);
 381                                 if (strcmp(name,"WM/Track")==0) s->track = value_num + 1;
 382                                 if (strcmp(name,"WM/TrackNumber")==0) s->track = value_num;
 383                         }
 384                         av_free(name);
 385                 }
 386         } else if (!memcmp(&g, &ext_stream_header, sizeof(GUID))) {
 387             int ext_len, payload_ext_ct, stream_ct;
 388             uint32_t ext_d;
 389             int64_t pos_ex_st;
 390             pos_ex_st = url_ftell(pb);
 391
 392             get_le64(pb);
 393             get_le64(pb);
 394             get_le32(pb);
 395             get_le32(pb);
 396             get_le32(pb);
 397             get_le32(pb);
 398             get_le32(pb);
 399             get_le32(pb);
 400             get_le32(pb);
 401             get_le32(pb);
 402             get_le16(pb);
 403             get_le16(pb);
 404             get_le64(pb);
 405             stream_ct = get_le16(pb);
 406             payload_ext_ct = get_le16(pb);
 407
 408             for (i=0; i<stream_ct; i++){
 409                 get_le16(pb);
 410                 ext_len = get_le16(pb);
 411                 url_fseek(pb, ext_len, SEEK_CUR);
 412             }
 413
 414             for (i=0; i<payload_ext_ct; i++){
 415                 get_guid(pb, &g);
 416                 ext_d=get_le16(pb);
 417                 ext_len=get_le32(pb);
 418                 url_fseek(pb, ext_len, SEEK_CUR);
 419             }
 420
 421             // there could be a optional stream properties object to follow
 422             // if so the next iteration will pick it up
 423         } else if (!memcmp(&g, &head1_guid, sizeof(GUID))) {
 424             int v1, v2;
 425             get_guid(pb, &g);
 426             v1 = get_le32(pb);
 427             v2 = get_le16(pb);
 428 #if 0
 429         } else if (!memcmp(&g, &codec_comment_header, sizeof(GUID))) {
 430             int len, v1, n, num;
 431             char str[256], *q;
 432             char tag[16];
 433
 434             get_guid(pb, &g);
 435             print_guid(&g);
 436
 437             n = get_le32(pb);
 438             for(i=0;i<n;i++) {
 439                 num = get_le16(pb); /* stream number */
 440                 get_str16(pb, str, sizeof(str));
 441                 get_str16(pb, str, sizeof(str));
 442                 len = get_le16(pb);
 443                 q = tag;
 444                 while (len > 0) {
 445                     v1 = get_byte(pb);
 446                     if ((q - tag) < sizeof(tag) - 1)
 447                         *q++ = v1;
 448                     len--;
 449                 }
 450                 *q = '\0';
 451             }
 452 #endif
 453         } else if (url_feof(pb)) {
 454             goto fail;
 455         } else {
 456             url_fseek(pb, gsize - 24, SEEK_CUR);
 457         }
 458     }
 459     get_guid(pb, &g);
 460     get_le64(pb);
 461     get_byte(pb);
 462     get_byte(pb);
 463     if (url_feof(pb))
 464         goto fail;
 465     asf->data_offset = url_ftell(pb);
 466     asf->packet_size_left = 0;
 467
 468     return 0;
 469
 470  fail:
 471      for(i=0;i<s->nb_streams;i++) {
 472         AVStream *st = s->streams[i];
 473         if (st) {
 474             av_free(st->priv_data);
 475             av_free(st->codec->extradata);
 476         }
 477         av_free(st);
 478     }
 479     return -1;
 480 }
 481
 482 #define DO_2BITS(bits, var, defval) \
 483     switch (bits & 3) \
 484     { \
 485     case 3: var = get_le32(pb); rsize += 4; break; \
 486     case 2: var = get_le16(pb); rsize += 2; break; \
 487     case 1: var = get_byte(pb); rsize++; break; \
 488     default: var = defval; break; \
 489     }
 490
 491 static int asf_get_packet(AVFormatContext *s)
 492 {
 493     ASFContext *asf = s->priv_data;
 494     ByteIOContext *pb = &s->pb;
 495     uint32_t packet_length, padsize;
 496     int rsize = 9;
 497     int c;
 498
 499     assert((url_ftell(&s->pb) - s->data_offset) % asf->packet_size == 0);
 500
 501     c = get_byte(pb);
 502     if (c != 0x82) {
 503         if (!url_feof(pb))
 504             av_log(s, AV_LOG_ERROR, "ff asf bad header %x  at:%"PRId64"\n", c, url_ftell(pb));
 505     }
 506     if ((c & 0x0f) == 2) { // always true for now
 507         if (get_le16(pb) != 0) {
 508             if (!url_feof(pb))
 509                 av_log(s, AV_LOG_ERROR, "ff asf bad non zero\n");
 510             return AVERROR_IO;
 511         }
 512         rsize+=2;
 513 /*    }else{
 514         if (!url_feof(pb))
 515             printf("ff asf bad header %x  at:%"PRId64"\n", c, url_ftell(pb));
 516         return AVERROR_IO;*/
 517     }
 518
 519     asf->packet_flags = get_byte(pb);
 520     asf->packet_property = get_byte(pb);
 521
 522     DO_2BITS(asf->packet_flags >> 5, packet_length, asf->packet_size);
 523     DO_2BITS(asf->packet_flags >> 1, padsize, 0); // sequence ignored
 524     DO_2BITS(asf->packet_flags >> 3, padsize, 0); // padding length
 525
 526     //the following checks prevent overflows and infinite loops
 527     if(packet_length >= (1U<<29)){
 528         av_log(s, AV_LOG_ERROR, "invalid packet_length %d at:%"PRId64"\n", packet_length, url_ftell(pb));
 529         return 0; // FIXME this should be -1
 530     }
 531     if(padsize >= (1U<<29)){
 532         av_log(s, AV_LOG_ERROR, "invalid padsize %d at:%"PRId64"\n", padsize, url_ftell(pb));
 533         return 0; // FIXME this should be -1
 534     }
 535
 536     asf->packet_timestamp = get_le32(pb);
 537     get_le16(pb); /* duration */
 538     // rsize has at least 11 bytes which have to be present
 539
 540     if (asf->packet_flags & 0x01) {
 541         asf->packet_segsizetype = get_byte(pb); rsize++;
 542         asf->packet_segments = asf->packet_segsizetype & 0x3f;
 543     } else {
 544         asf->packet_segments = 1;
 545         asf->packet_segsizetype = 0x80;
 546     }
 547     asf->packet_size_left = packet_length - padsize - rsize;
 548     if (packet_length < asf->hdr.min_pktsize)
 549         padsize += asf->hdr.min_pktsize - packet_length;
 550     asf->packet_padsize = padsize;
 551 #ifdef DEBUG
 552     printf("packet: size=%d padsize=%d  left=%d\n", asf->packet_size, asf->packet_padsize, asf->packet_size_left);
 553 #endif
 554     return 0;
 555 }
 556
 557 static int asf_read_packet(AVFormatContext *s, AVPacket *pkt)
 558 {
 559     ASFContext *asf = s->priv_data;
 560     ASFStream *asf_st = 0;
 561     ByteIOContext *pb = &s->pb;
 562     //static int pc = 0;
 563     for (;;) {
 564         int rsize = 0;
 565         if (asf->packet_size_left < FRAME_HEADER_SIZE
 566             || asf->packet_segments < 1) {
 567             //asf->packet_size_left <= asf->packet_padsize) {
 568             int ret = asf->packet_size_left + asf->packet_padsize;
 569             //printf("PacketLeftSize:%d  Pad:%d Pos:%"PRId64"\n", asf->packet_size_left, asf->packet_padsize, url_ftell(pb));
 570             if((url_ftell(&s->pb) + ret - s->data_offset) % asf->packet_size)
 571                 ret += asf->packet_size - ((url_ftell(&s->pb) + ret - s->data_offset) % asf->packet_size);
 572             assert(ret>=0);
 573             /* fail safe */
 574             url_fskip(pb, ret);
 575             asf->packet_pos= url_ftell(&s->pb);
 576             if (asf->data_object_size != (uint64_t)-1 &&
 577                 (asf->packet_pos - asf->data_object_offset >= asf->data_object_size))
 578                 return AVERROR_IO; /* Do not exceed the size of the data object */
 579             ret = asf_get_packet(s);
 580             //printf("READ ASF PACKET  %d   r:%d   c:%d\n", ret, asf->packet_size_left, pc++);
 581             if (ret < 0 || url_feof(pb))
 582                 return AVERROR_IO;
 583             asf->packet_time_start = 0;
 584             continue;
 585         }
 586         if (asf->packet_time_start == 0) {
 587             /* read frame header */
 588             int num = get_byte(pb);
 589             asf->packet_segments--;
 590             rsize++;
 591             asf->packet_key_frame = (num & 0x80) >> 7;
 592             asf->stream_index = asf->asfid2avid[num & 0x7f];
 593             // sequence should be ignored!
 594             DO_2BITS(asf->packet_property >> 4, asf->packet_seq, 0);
 595             DO_2BITS(asf->packet_property >> 2, asf->packet_frag_offset, 0);
 596             DO_2BITS(asf->packet_property, asf->packet_replic_size, 0);
 597 //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);
 598             if (asf->packet_replic_size > 1) {
 599                 assert(asf->packet_replic_size >= 8);
 600                 // it should be always at least 8 bytes - FIXME validate
 601                 asf->packet_obj_size = get_le32(pb);
 602                 asf->packet_frag_timestamp = get_le32(pb); // timestamp
 603                 if (asf->packet_replic_size > 8)
 604                     url_fskip(pb, asf->packet_replic_size - 8);
 605                 rsize += asf->packet_replic_size; // FIXME - check validity
 606             } else if (asf->packet_replic_size==1){
 607                 // multipacket - frag_offset is begining timestamp
 608                 asf->packet_time_start = asf->packet_frag_offset;
 609                 asf->packet_frag_offset = 0;
 610                 asf->packet_frag_timestamp = asf->packet_timestamp;
 611
 612                 asf->packet_time_delta = get_byte(pb);
 613                 rsize++;
 614             }else{
 615                 assert(asf->packet_replic_size==0);
 616             }
 617             if (asf->packet_flags & 0x01) {
 618                 DO_2BITS(asf->packet_segsizetype >> 6, asf->packet_frag_size, 0); // 0 is illegal
 619 #undef DO_2BITS
 620                 //printf("Fragsize %d\n", asf->packet_frag_size);
 621             } else {
 622                 asf->packet_frag_size = asf->packet_size_left - rsize;
 623                 //printf("Using rest  %d %d %d\n", asf->packet_frag_size, asf->packet_size_left, rsize);
 624             }
 625             if (asf->packet_replic_size == 1) {
 626                 asf->packet_multi_size = asf->packet_frag_size;
 627                 if (asf->packet_multi_size > asf->packet_size_left) {
 628                     asf->packet_segments = 0;
 629                     continue;
 630                 }
 631             }
 632             asf->packet_size_left -= rsize;
 633             //printf("___objsize____  %d   %d    rs:%d\n", asf->packet_obj_size, asf->packet_frag_offset, rsize);
 634
 635             if (asf->stream_index < 0
 636                 || s->streams[asf->stream_index]->discard >= AVDISCARD_ALL
 637                 || (!asf->packet_key_frame && s->streams[asf->stream_index]->discard >= AVDISCARD_NONKEY)
 638                 ) {
 639                 asf->packet_time_start = 0;
 640                 /* unhandled packet (should not happen) */
 641                 url_fskip(pb, asf->packet_frag_size);
 642                 asf->packet_size_left -= asf->packet_frag_size;
 643                 if(asf->stream_index < 0)
 644                     av_log(s, AV_LOG_ERROR, "ff asf skip %d  %d\n", asf->packet_frag_size, num & 0x7f);
 645                 continue;
 646             }
 647             asf->asf_st = s->streams[asf->stream_index]->priv_data;
 648         }
 649         asf_st = asf->asf_st;
 650
 651         if ((asf->packet_frag_offset != asf_st->frag_offset
 652              || (asf->packet_frag_offset
 653                  && asf->packet_seq != asf_st->seq)) // seq should be ignored
 654            ) {
 655             /* cannot continue current packet: free it */
 656             // FIXME better check if packet was already allocated
 657             av_log(s, AV_LOG_INFO, "ff asf parser skips: %d - %d     o:%d - %d    %d %d   fl:%d\n",
 658                    asf_st->pkt.size,
 659                    asf->packet_obj_size,
 660                    asf->packet_frag_offset, asf_st->frag_offset,
 661                    asf->packet_seq, asf_st->seq, asf->packet_frag_size);
 662             if (asf_st->pkt.size)
 663                 av_free_packet(&asf_st->pkt);
 664             asf_st->frag_offset = 0;
 665             if (asf->packet_frag_offset != 0) {
 666                 url_fskip(pb, asf->packet_frag_size);
 667                 av_log(s, AV_LOG_INFO, "ff asf parser skipping %db\n", asf->packet_frag_size);
 668                 asf->packet_size_left -= asf->packet_frag_size;
 669                 continue;
 670             }
 671         }
 672         if (asf->packet_replic_size == 1) {
 673             // frag_offset is here used as the begining timestamp
 674             asf->packet_frag_timestamp = asf->packet_time_start;
 675             asf->packet_time_start += asf->packet_time_delta;
 676             asf->packet_obj_size = asf->packet_frag_size = get_byte(pb);
 677             asf->packet_size_left--;
 678             asf->packet_multi_size--;
 679             if (asf->packet_multi_size < asf->packet_obj_size)
 680             {
 681                 asf->packet_time_start = 0;
 682                 url_fskip(pb, asf->packet_multi_size);
 683                 asf->packet_size_left -= asf->packet_multi_size;
 684                 continue;
 685             }
 686             asf->packet_multi_size -= asf->packet_obj_size;
 687             //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);
 688         }
 689         if (asf_st->frag_offset == 0) {
 690             /* new packet */
 691             av_new_packet(&asf_st->pkt, asf->packet_obj_size);
 692             asf_st->seq = asf->packet_seq;
 693             asf_st->pkt.pts = asf->packet_frag_timestamp;
 694             asf_st->pkt.stream_index = asf->stream_index;
 695             asf_st->pkt.pos =
 696             asf_st->packet_pos= asf->packet_pos;
 697 //printf("new packet: stream:%d key:%d packet_key:%d audio:%d size:%d\n",
 698 //asf->stream_index, asf->packet_key_frame, asf_st->pkt.flags & PKT_FLAG_KEY,
 699 //s->streams[asf->stream_index]->codec->codec_type == CODEC_TYPE_AUDIO, asf->packet_obj_size);
 700             if (s->streams[asf->stream_index]->codec->codec_type == CODEC_TYPE_AUDIO)
 701                 asf->packet_key_frame = 1;
 702             if (asf->packet_key_frame)
 703                 asf_st->pkt.flags |= PKT_FLAG_KEY;
 704         }
 705
 706         /* read data */
 707         //printf("READ PACKET s:%d  os:%d  o:%d,%d  l:%d   DATA:%p\n",
 708         //       asf->packet_size, asf_st->pkt.size, asf->packet_frag_offset,
 709         //       asf_st->frag_offset, asf->packet_frag_size, asf_st->pkt.data);
 710         asf->packet_size_left -= asf->packet_frag_size;
 711         if (asf->packet_size_left < 0)
 712             continue;
 713         get_buffer(pb, asf_st->pkt.data + asf->packet_frag_offset,
 714                    asf->packet_frag_size);
 715         asf_st->frag_offset += asf->packet_frag_size;
 716         /* test if whole packet is read */
 717         if (asf_st->frag_offset == asf_st->pkt.size) {
 718             /* return packet */
 719             if (asf_st->ds_span > 1) {
 720                 /* packet descrambling */
 721                 uint8_t *newdata = av_malloc(asf_st->pkt.size);
 722                 if (newdata) {
 723                     int offset = 0;
 724                     while (offset < asf_st->pkt.size) {
 725                         int off = offset / asf_st->ds_chunk_size;
 726                         int row = off / asf_st->ds_span;
 727                         int col = off % asf_st->ds_span;
 728                         int idx = row + col * asf_st->ds_packet_size / asf_st->ds_chunk_size;
 729                         //printf("off:%d  row:%d  col:%d  idx:%d\n", off, row, col, idx);
 730                         memcpy(newdata + offset,
 731                                asf_st->pkt.data + idx * asf_st->ds_chunk_size,
 732                                asf_st->ds_chunk_size);
 733                         offset += asf_st->ds_chunk_size;
 734                     }
 735                     av_free(asf_st->pkt.data);
 736                     asf_st->pkt.data = newdata;
 737                 }
 738             }
 739             asf_st->frag_offset = 0;
 740             memcpy(pkt, &asf_st->pkt, sizeof(AVPacket));
 741             //printf("packet %d %d\n", asf_st->pkt.size, asf->packet_frag_size);
 742             asf_st->pkt.size = 0;
 743             asf_st->pkt.data = 0;
 744             break; // packet completed
 745         }
 746     }
 747     return 0;
 748 }
 749
 750 static int asf_read_close(AVFormatContext *s)
 751 {
 752     int i;
 753
 754     for(i=0;i<s->nb_streams;i++) {
 755         AVStream *st = s->streams[i];
 756         av_free(st->priv_data);
 757     av_free(st->codec->palctrl);
 758     }
 759     return 0;
 760 }
 761
 762 // Added to support seeking after packets have been read
 763 // If information is not reset, read_packet fails due to
 764 // leftover information from previous reads
 765 static void asf_reset_header(AVFormatContext *s)
 766 {
 767     ASFContext *asf = s->priv_data;
 768     ASFStream *asf_st;
 769     int i;
 770
 771     asf->packet_nb_frames = 0;
 772     asf->packet_timestamp_start = -1;
 773     asf->packet_timestamp_end = -1;
 774     asf->packet_size_left = 0;
 775     asf->packet_segments = 0;
 776     asf->packet_flags = 0;
 777     asf->packet_property = 0;
 778     asf->packet_timestamp = 0;
 779     asf->packet_segsizetype = 0;
 780     asf->packet_segments = 0;
 781     asf->packet_seq = 0;
 782     asf->packet_replic_size = 0;
 783     asf->packet_key_frame = 0;
 784     asf->packet_padsize = 0;
 785     asf->packet_frag_offset = 0;
 786     asf->packet_frag_size = 0;
 787     asf->packet_frag_timestamp = 0;
 788     asf->packet_multi_size = 0;
 789     asf->packet_obj_size = 0;
 790     asf->packet_time_delta = 0;
 791     asf->packet_time_start = 0;
 792
 793     for(i=0; i<s->nb_streams; i++){
 794         asf_st= s->streams[i]->priv_data;
 795         av_free_packet(&asf_st->pkt);
 796         asf_st->frag_offset=0;
 797         asf_st->seq=0;
 798     }
 799     asf->asf_st= NULL;
 800 }
 801
 802 static int64_t asf_read_pts(AVFormatContext *s, int stream_index, int64_t *ppos, int64_t pos_limit)
 803 {
 804     ASFContext *asf = s->priv_data;
 805     AVPacket pkt1, *pkt = &pkt1;
 806     ASFStream *asf_st;
 807     int64_t pts;
 808     int64_t pos= *ppos;
 809     int i;
 810     int64_t start_pos[s->nb_streams];
 811
 812     for(i=0; i<s->nb_streams; i++){
 813         start_pos[i]= pos;
 814     }
 815
 816     pos= (pos+asf->packet_size-1-s->data_offset)/asf->packet_size*asf->packet_size+ s->data_offset;
 817     *ppos= pos;
 818     url_fseek(&s->pb, pos, SEEK_SET);
 819
 820 //printf("asf_read_pts\n");
 821     asf_reset_header(s);
 822     for(;;){
 823         if (av_read_frame(s, pkt) < 0){
 824             av_log(s, AV_LOG_INFO, "seek failed\n");
 825             return AV_NOPTS_VALUE;
 826         }
 827
 828         pts= pkt->pts;
 829
 830         av_free_packet(pkt);
 831         if(pkt->flags&PKT_FLAG_KEY){
 832             i= pkt->stream_index;
 833
 834             asf_st= s->streams[i]->priv_data;
 835
 836             assert((asf_st->packet_pos - s->data_offset) % asf->packet_size == 0);
 837             pos= asf_st->packet_pos;
 838
 839             av_add_index_entry(s->streams[i], pos, pts, pkt->size, pos - start_pos[i] + 1, AVINDEX_KEYFRAME);
 840             start_pos[i]= asf_st->packet_pos + 1;
 841
 842             if(pkt->stream_index == stream_index)
 843                break;
 844         }
 845     }
 846
 847     *ppos= pos;
 848 //printf("found keyframe at %"PRId64" stream %d stamp:%"PRId64"\n", *ppos, stream_index, pts);
 849
 850     return pts;
 851 }
 852
 853 static void asf_build_simple_index(AVFormatContext *s, int stream_index)
 854 {
 855     GUID g;
 856     ASFContext *asf = s->priv_data;
 857     int64_t gsize, itime;
 858     int64_t pos, current_pos, index_pts;
 859     int i;
 860     int pct,ict;
 861
 862     current_pos = url_ftell(&s->pb);
 863
 864     url_fseek(&s->pb, asf->data_object_offset + asf->data_object_size, SEEK_SET);
 865     get_guid(&s->pb, &g);
 866     if (!memcmp(&g, &index_guid, sizeof(GUID))) {
 867         gsize = get_le64(&s->pb);
 868         get_guid(&s->pb, &g);
 869         itime=get_le64(&s->pb);
 870         pct=get_le32(&s->pb);
 871         ict=get_le32(&s->pb);
 872         av_log(NULL, AV_LOG_DEBUG, "itime:0x%"PRIx64", pct:%d, ict:%d\n",itime,pct,ict);
 873
 874         for (i=0;i<ict;i++){
 875             int pktnum=get_le32(&s->pb);
 876             int pktct =get_le16(&s->pb);
 877             av_log(NULL, AV_LOG_DEBUG, "pktnum:%d, pktct:%d\n", pktnum, pktct);
 878
 879             pos=s->data_offset + asf->packet_size*(int64_t)pktnum;
 880             index_pts=av_rescale(itime, i, 10000);
 881
 882             av_add_index_entry(s->streams[stream_index], pos, index_pts, asf->packet_size, 0, AVINDEX_KEYFRAME);
 883         }
 884         asf->index_read= 1;
 885     }
 886     url_fseek(&s->pb, current_pos, SEEK_SET);
 887 }
 888
 889 static int asf_read_seek(AVFormatContext *s, int stream_index, int64_t pts, int flags)
 890 {
 891     ASFContext *asf = s->priv_data;
 892     AVStream *st = s->streams[stream_index];
 893     int64_t pos;
 894     int index;
 895
 896     if (asf->packet_size <= 0)
 897         return -1;
 898
 899     if (!asf->index_read)
 900         asf_build_simple_index(s, stream_index);
 901
 902     if(!(asf->index_read && st->index_entries)){
 903         if(av_seek_frame_binary(s, stream_index, pts, flags)<0)
 904             return -1;
 905     }else{
 906         index= av_index_search_timestamp(st, pts, flags);
 907         if(index<0)
 908             return -1;
 909
 910         /* find the position */
 911         pos = st->index_entries[index].pos;
 912         pts = st->index_entries[index].timestamp;
 913
 914     // various attempts to find key frame have failed so far
 915     //    asf_reset_header(s);
 916     //    url_fseek(&s->pb, pos, SEEK_SET);
 917     //    key_pos = pos;
 918     //     for(i=0;i<16;i++){
 919     //         pos = url_ftell(&s->pb);
 920     //         if (av_read_frame(s, &pkt) < 0){
 921     //             av_log(s, AV_LOG_INFO, "seek failed\n");
 922     //             return -1;
 923     //         }
 924     //         asf_st = s->streams[stream_index]->priv_data;
 925     //         pos += st->parser->frame_offset;
 926     //
 927     //         if (pkt.size > b) {
 928     //             b = pkt.size;
 929     //             key_pos = pos;
 930     //         }
 931     //
 932     //         av_free_packet(&pkt);
 933     //     }
 934
 935         /* do the seek */
 936         av_log(NULL, AV_LOG_DEBUG, "SEEKTO: %"PRId64"\n", pos);
 937         url_fseek(&s->pb, pos, SEEK_SET);
 938     }
 939     asf_reset_header(s);
 940     return 0;
 941 }
 942
 943 AVInputFormat asf_demuxer = {
 944     "asf",
 945     "asf format",
 946     sizeof(ASFContext),
 947     asf_probe,
 948     asf_read_header,
 949     asf_read_packet,
 950     asf_read_close,
 951     asf_read_seek,
 952     asf_read_pts,
 953 };