apps/codecs/libasf/asf.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2007 Dave Chapman
  11  *
  12  * ASF parsing code based on libasf by Juho Vähä-Herttua
  13  * http://code.google.com/p/libasf/  libasf itself was based on the ASF
  14  * parser in VLC - http://www.videolan.org/
  15  *
  16  * This program is free software; you can redistribute it and/or
  17  * modify it under the terms of the GNU General Public License
  18  * as published by the Free Software Foundation; either version 2
  19  * of the License, or (at your option) any later version.
  20  *
  21  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  22  * KIND, either express or implied.
  23  *
  24  ****************************************************************************/
  25 #include <inttypes.h>
  26 #include "codeclib.h"
  27 #include "asf.h"
  28
  29 /* Read an unaligned 32-bit little endian long from buffer. */
  30 static unsigned long get_long_le(void* buf)
  31 {
  32     unsigned char* p = (unsigned char*) buf;
  33
  34     return p[0] | (p[1] << 8) | (p[2] << 16) | (p[3] << 24);
  35 }
  36
  37 /* Read an unaligned 16-bit little endian short from buffer. */
  38 static unsigned short get_short_le(void* buf)
  39 {
  40     unsigned char* p = (unsigned char*) buf;
  41
  42     return p[0] | (p[1] << 8);
  43 }
  44
  45 #define GETLEN2b(bits) (((bits) == 0x03) ? 4 : bits)
  46
  47 #define GETVALUE2b(bits, data) \
  48         (((bits) != 0x03) ? ((bits) != 0x02) ? ((bits) != 0x01) ? \
  49          0 : *(data) : get_short_le(data) : get_long_le(data))
  50
  51 int asf_read_packet(uint8_t** audiobuf, int* audiobufsize, int* packetlength,
  52                     asf_waveformatex_t* wfx)
  53 {
  54     uint8_t tmp8, packet_flags, packet_property;
  55     int stream_id;
  56     int ec_length, opaque_data, ec_length_type;
  57     int datalen;
  58     uint8_t data[18];
  59     uint8_t* datap;
  60     uint32_t length;
  61     uint32_t padding_length;
  62     uint32_t send_time;
  63     uint16_t duration;
  64     uint16_t payload_count;
  65     int payload_length_type;
  66     uint32_t payload_hdrlen;
  67     int payload_datalen;
  68     int multiple;
  69     uint32_t replicated_length;
  70     uint32_t media_object_number;
  71     uint32_t media_object_offset;
  72     uint32_t bytesread = 0;
  73     uint8_t* buf;
  74     size_t bufsize;
  75     int i;
  76     /*DEBUGF("Reading new packet at %d bytes ", (int)ci->curpos);*/
  77
  78     if (ci->read_filebuf(&tmp8, 1) == 0) {
  79         return ASF_ERROR_EOF;
  80     }
  81     bytesread++;
  82
  83     /* TODO: We need a better way to detect endofstream */
  84     if (tmp8 != 0x82) {
  85     DEBUGF("Read failed:  packet did not sync\n");
  86     return -1;
  87     }
  88
  89
  90     if (tmp8 & 0x80) {
  91        ec_length = tmp8 & 0x0f;
  92        opaque_data = (tmp8 >> 4) & 0x01;
  93        ec_length_type = (tmp8 >> 5) & 0x03;
  94
  95        if (ec_length_type != 0x00 || opaque_data != 0 || ec_length != 0x02) {
  96             DEBUGF("incorrect error correction flags\n");
  97             return ASF_ERROR_INVALID_VALUE;
  98        }
  99
 100        /* Skip ec_data */
 101        ci->advance_buffer(ec_length);
 102        bytesread += ec_length;
 103     } else {
 104         ec_length = 0;
 105     }
 106
 107     if (ci->read_filebuf(&packet_flags, 1) == 0) { return ASF_ERROR_EOF; }
 108     if (ci->read_filebuf(&packet_property, 1) == 0) { return ASF_ERROR_EOF; }
 109     bytesread += 2;
 110
 111     datalen = GETLEN2b((packet_flags >> 1) & 0x03) +
 112               GETLEN2b((packet_flags >> 3) & 0x03) +
 113               GETLEN2b((packet_flags >> 5) & 0x03) + 6;
 114
 115 #if 0
 116     if (datalen > sizeof(data)) {
 117         DEBUGF("Unexpectedly long datalen in data - %d\n",datalen);
 118         return ASF_ERROR_OUTOFMEM;
 119     }
 120 #endif
 121
 122     if (ci->read_filebuf(data, datalen) == 0) {
 123         return ASF_ERROR_EOF;
 124     }
 125
 126     bytesread += datalen;
 127
 128     datap = data;
 129     length = GETVALUE2b((packet_flags >> 5) & 0x03, datap);
 130     datap += GETLEN2b((packet_flags >> 5) & 0x03);
 131     /* sequence value is not used */
 132     GETVALUE2b((packet_flags >> 1) & 0x03, datap);
 133     datap += GETLEN2b((packet_flags >> 1) & 0x03);
 134     padding_length = GETVALUE2b((packet_flags >> 3) & 0x03, datap);
 135     datap += GETLEN2b((packet_flags >> 3) & 0x03);
 136     send_time = get_long_le(datap);
 137     datap += 4;
 138     duration = get_short_le(datap);
 139     datap += 2;
 140     /*DEBUGF("and duration %d ms\n", duration);*/
 141
 142     /* this is really idiotic, packet length can (and often will) be
 143      * undefined and we just have to use the header packet size as the size
 144      * value */
 145     if (!((packet_flags >> 5) & 0x03)) {
 146          length = wfx->packet_size;
 147     }
 148
 149     /* this is also really idiotic, if packet length is smaller than packet
 150      * size, we need to manually add the additional bytes into padding length
 151      */
 152     if (length < wfx->packet_size) {
 153         padding_length += wfx->packet_size - length;
 154         length = wfx->packet_size;
 155     }
 156
 157     if (length > wfx->packet_size) {
 158         DEBUGF("packet with too big length value\n");
 159         return ASF_ERROR_INVALID_LENGTH;
 160     }
 161
 162     /* check if we have multiple payloads */
 163     if (packet_flags & 0x01) {
 164         if (ci->read_filebuf(&tmp8, 1) == 0) {
 165             return ASF_ERROR_EOF;
 166         }
 167         payload_count = tmp8 & 0x3f;
 168         payload_length_type = (tmp8 >> 6) & 0x03;
 169         bytesread++;
 170     } else {
 171         payload_count = 1;
 172         payload_length_type = 0x02; /* not used */
 173     }
 174
 175     if (length < bytesread) {
 176         DEBUGF("header exceeded packet size, invalid file - length=%d, bytesread=%d\n",(int)length,(int)bytesread);
 177         /* FIXME: should this be checked earlier? */
 178         return ASF_ERROR_INVALID_LENGTH;
 179     }
 180
 181
 182     /* We now parse the individual payloads, and move all payloads
 183        belonging to our audio stream to a contiguous block, starting at
 184        the location of the first payload.
 185     */
 186
 187     *audiobuf = NULL;
 188     *audiobufsize = 0;
 189     *packetlength = length - bytesread;
 190
 191     buf = ci->request_buffer(&bufsize, length);
 192     datap = buf;
 193
 194 #define ASF_MAX_REQUEST (1L<<15) /* 32KB */
 195     if (bufsize != length && length >= ASF_MAX_REQUEST) {
 196         /* This should only happen with packets larger than 32KB (the
 197            guard buffer size).  All the streams I've seen have
 198            relatively small packets less than about 8KB), but I don't
 199            know what is expected.
 200         */
 201         DEBUGF("Could not read packet (requested %d bytes, received %d), curpos=%d, aborting\n",
 202                (int)length,(int)bufsize,(int)ci->curpos);
 203         return -1;
 204     }
 205
 206     for (i=0; i<payload_count; i++) {
 207         stream_id = datap[0]&0x7f;
 208         datap++;
 209         bytesread++;
 210
 211         payload_hdrlen = GETLEN2b(packet_property & 0x03) +
 212                          GETLEN2b((packet_property >> 2) & 0x03) +
 213                          GETLEN2b((packet_property >> 4) & 0x03);
 214
 215         //DEBUGF("payload_hdrlen = %d\n",payload_hdrlen);
 216 #if 0
 217         /* TODO */
 218         if (payload_hdrlen > size) {
 219             return ASF_ERROR_INVALID_LENGTH;
 220         }
 221 #endif
 222         if (payload_hdrlen > sizeof(data)) {
 223             DEBUGF("Unexpectedly long datalen in data - %d\n",datalen);
 224             return ASF_ERROR_OUTOFMEM;
 225         }
 226
 227         bytesread += payload_hdrlen;
 228         media_object_number = GETVALUE2b((packet_property >> 4) & 0x03, datap);
 229         datap += GETLEN2b((packet_property >> 4) & 0x03);
 230         media_object_offset = GETVALUE2b((packet_property >> 2) & 0x03, datap);
 231         datap += GETLEN2b((packet_property >> 2) & 0x03);
 232         replicated_length = GETVALUE2b(packet_property & 0x03, datap);
 233         datap += GETLEN2b(packet_property & 0x03);
 234
 235         /* TODO: Validate replicated_length */
 236         /* TODO: Is the content of this important for us? */
 237         datap += replicated_length;
 238         bytesread += replicated_length;
 239
 240         multiple = packet_flags & 0x01;
 241
 242
 243         if (multiple) {
 244             int x;
 245
 246             x = GETLEN2b(payload_length_type);
 247
 248             if (x != 2) {
 249                 /* in multiple payloads datalen should be a word */
 250                 return ASF_ERROR_INVALID_VALUE;
 251             }
 252
 253 #if 0
 254             if (skip + tmp > datalen) {
 255                 /* not enough data */
 256                 return ASF_ERROR_INVALID_LENGTH;
 257             }
 258 #endif
 259             payload_datalen = GETVALUE2b(payload_length_type, datap);
 260             datap += x;
 261             bytesread += x;
 262         } else {
 263             payload_datalen = length - bytesread - padding_length;
 264         }
 265
 266         if (replicated_length==1)
 267             datap++;
 268
 269         if (stream_id == wfx->audiostream)
 270         {
 271             if (*audiobuf == NULL) {
 272                 /* The first payload can stay where it is */
 273                 *audiobuf = datap;
 274                 *audiobufsize = payload_datalen;
 275             } else {
 276                 /* The second and subsequent payloads in this packet
 277                    that belong to the audio stream need to be moved to be
 278                    contiguous with the first payload.
 279                 */
 280                 memmove(*audiobuf + *audiobufsize, datap, payload_datalen);
 281                 *audiobufsize += payload_datalen;
 282             }
 283         }
 284         datap += payload_datalen;
 285         bytesread += payload_datalen;
 286     }
 287
 288     if (*audiobuf != NULL)
 289         return 1;
 290     else
 291         return 0;
 292 }
 293
 294
 295 int asf_get_timestamp(int *duration)
 296 {
 297     uint8_t tmp8, packet_flags, packet_property;
 298     int ec_length, opaque_data, ec_length_type;
 299     int datalen;
 300     uint8_t data[18];
 301     uint8_t* datap;
 302     uint32_t length;
 303     uint32_t padding_length;
 304     uint32_t send_time;
 305     static int packet_count = 0;
 306
 307     uint32_t bytesread = 0;
 308     packet_count++;
 309     if (ci->read_filebuf(&tmp8, 1) == 0) {
 310         DEBUGF("ASF ERROR (EOF?)\n");
 311         return ASF_ERROR_EOF;
 312     }
 313     bytesread++;
 314
 315     /* TODO: We need a better way to detect endofstream */
 316     if (tmp8 != 0x82) {
 317         DEBUGF("Get timestamp:  Detected end of stream\n");
 318         return ASF_ERROR_EOF;
 319     }
 320
 321
 322     if (tmp8 & 0x80) {
 323         ec_length = tmp8 & 0x0f;
 324         opaque_data = (tmp8 >> 4) & 0x01;
 325         ec_length_type = (tmp8 >> 5) & 0x03;
 326
 327         if (ec_length_type != 0x00 || opaque_data != 0 || ec_length != 0x02) {
 328              DEBUGF("incorrect error correction flags\n");
 329              return ASF_ERROR_INVALID_VALUE;
 330         }
 331
 332         /* Skip ec_data */
 333         ci->advance_buffer(ec_length);
 334         bytesread += ec_length;
 335     } else {
 336         ec_length = 0;
 337     }
 338
 339     if (ci->read_filebuf(&packet_flags, 1) == 0) {
 340         DEBUGF("Detected end of stream 2\n");
 341         return ASF_ERROR_EOF;
 342     }
 343
 344     if (ci->read_filebuf(&packet_property, 1) == 0) {
 345         DEBUGF("Detected end of stream3\n");
 346         return ASF_ERROR_EOF;
 347     }
 348     bytesread += 2;
 349
 350     datalen = GETLEN2b((packet_flags >> 1) & 0x03) +
 351               GETLEN2b((packet_flags >> 3) & 0x03) +
 352               GETLEN2b((packet_flags >> 5) & 0x03) + 6;
 353
 354     if (ci->read_filebuf(data, datalen) == 0) {
 355         DEBUGF("Detected end of stream4\n");
 356         return ASF_ERROR_EOF;
 357     }
 358
 359     bytesread += datalen;
 360
 361     datap = data;
 362     length = GETVALUE2b((packet_flags >> 5) & 0x03, datap);
 363     datap += GETLEN2b((packet_flags >> 5) & 0x03);
 364
 365     /* sequence value is not used */
 366     GETVALUE2b((packet_flags >> 1) & 0x03, datap);
 367     datap += GETLEN2b((packet_flags >> 1) & 0x03);
 368     padding_length = GETVALUE2b((packet_flags >> 3) & 0x03, datap);
 369     datap += GETLEN2b((packet_flags >> 3) & 0x03);
 370     send_time = get_long_le(datap);
 371     datap += 4;
 372     *duration = get_short_le(datap);
 373
 374     /*the asf_get_timestamp function advances us 12-13 bytes past the packet start,
 375       need to undo this here so that we stay synced with the packet*/
 376     ci->seek_buffer(ci->curpos-bytesread);
 377
 378     return send_time;
 379 }
 380
 381 /*entry point for seeks*/
 382 int asf_seek(int ms, asf_waveformatex_t* wfx)
 383 {
 384     int time, duration, delta, temp, count=0;
 385
 386     /*estimate packet number from bitrate*/
 387     int initial_packet = ci->curpos/wfx->packet_size;
 388     int packet_num = (((int64_t)ms)*(wfx->bitrate>>3))/wfx->packet_size/1000;
 389     int last_packet = ci->id3->filesize / wfx->packet_size;
 390
 391     if (packet_num > last_packet) {
 392         packet_num = last_packet;
 393     }
 394
 395     /*calculate byte address of the start of that packet*/
 396     int packet_offset = packet_num*wfx->packet_size;
 397
 398     /*seek to estimated packet*/
 399     ci->seek_buffer(ci->id3->first_frame_offset+packet_offset);
 400     temp = ms;
 401     while (1)
 402     {
 403         /*for very large files it can be difficult and unimportant to find the exact packet*/
 404         count++;
 405
 406         /*check the time stamp of our packet*/
 407         time = asf_get_timestamp(&duration);
 408         /*DEBUGF("seeked to %d ms with duration %d\n", time, duration);*/
 409
 410         if (time < 0) {
 411             /*unknown error, try to recover*/
 412             DEBUGF("UKNOWN SEEK ERROR\n");
 413             ci->seek_buffer(ci->id3->first_frame_offset+initial_packet*wfx->packet_size);
 414             /*seek failed so return time stamp of the initial packet*/
 415             return asf_get_timestamp(&duration);
 416         }
 417
 418         if ((time+duration>=ms && time<=ms) || count > 10) {
 419             /*DEBUGF("Found our packet! Now at %d packet\n", packet_num);*/
 420             return time;
 421         } else {
 422             /*seek again*/
 423             delta = ms-time;
 424             /*estimate new packet number from bitrate and our current position*/
 425             temp += delta;
 426             packet_num = ((temp/1000)*(wfx->bitrate>>3) - (wfx->packet_size>>1))/wfx->packet_size;  //round down!
 427             packet_offset = packet_num*wfx->packet_size;
 428             ci->seek_buffer(ci->id3->first_frame_offset+packet_offset);
 429         }
 430     }
 431 }