From f40bfc9267b13b54e6379dfe7539447662879d24 Mon Sep 17 00:00:00 2001 From: Sean Bartell Date: Sat, 25 Jun 2011 21:32:25 -0400 Subject: Add codecs to librbcodec. MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Change-Id: Id7f4717d51ed02d67cb9f9cb3c0ada4a81843f97 Reviewed-on: http://gerrit.rockbox.org/137 Reviewed-by: Nils Wallménius Tested-by: Nils Wallménius --- lib/rbcodec/codecs/libasf/SOURCES | 1 + lib/rbcodec/codecs/libasf/asf.c | 435 ++++++++++++++++++++++++++++++++++ lib/rbcodec/codecs/libasf/asf.h | 49 ++++ lib/rbcodec/codecs/libasf/libasf.make | 18 ++ 4 files changed, 503 insertions(+) create mode 100644 lib/rbcodec/codecs/libasf/SOURCES create mode 100644 lib/rbcodec/codecs/libasf/asf.c create mode 100644 lib/rbcodec/codecs/libasf/asf.h create mode 100644 lib/rbcodec/codecs/libasf/libasf.make (limited to 'lib/rbcodec/codecs/libasf') diff --git a/lib/rbcodec/codecs/libasf/SOURCES b/lib/rbcodec/codecs/libasf/SOURCES new file mode 100644 index 0000000000..1fee336990 --- /dev/null +++ b/lib/rbcodec/codecs/libasf/SOURCES @@ -0,0 +1 @@ +asf.c diff --git a/lib/rbcodec/codecs/libasf/asf.c b/lib/rbcodec/codecs/libasf/asf.c new file mode 100644 index 0000000000..4e3235a422 --- /dev/null +++ b/lib/rbcodec/codecs/libasf/asf.c @@ -0,0 +1,435 @@ +/*************************************************************************** + * __________ __ ___. + * Open \______ \ ____ ____ | | _\_ |__ _______ ___ + * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ / + * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < < + * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \ + * \/ \/ \/ \/ \/ + * $Id$ + * + * Copyright (C) 2007 Dave Chapman + * + * ASF parsing code based on libasf by Juho Vähä-Herttua + * http://code.google.com/p/libasf/ libasf itself was based on the ASF + * parser in VLC - http://www.videolan.org/ + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY + * KIND, either express or implied. + * + ****************************************************************************/ +#include +#include "codeclib.h" +#include "asf.h" + +/* Read an unaligned 32-bit little endian long from buffer. */ +static unsigned long get_long_le(void* buf) +{ + unsigned char* p = (unsigned char*) buf; + + return p[0] | (p[1] << 8) | (p[2] << 16) | (p[3] << 24); +} + +/* Read an unaligned 16-bit little endian short from buffer. */ +static unsigned short get_short_le(void* buf) +{ + unsigned char* p = (unsigned char*) buf; + + return p[0] | (p[1] << 8); +} + +#define GETLEN2b(bits) (((bits) == 0x03) ? 4 : bits) + +#define GETVALUE2b(bits, data) \ + (((bits) != 0x03) ? ((bits) != 0x02) ? ((bits) != 0x01) ? \ + 0 : *(data) : get_short_le(data) : get_long_le(data)) + +int asf_read_packet(uint8_t** audiobuf, int* audiobufsize, int* packetlength, + asf_waveformatex_t* wfx) +{ + uint8_t tmp8, packet_flags, packet_property; + int stream_id; + int ec_length, opaque_data, ec_length_type; + int datalen; + uint8_t data[18]; + uint8_t* datap; + uint32_t length; + uint32_t padding_length; + /* rockbox: comment 'set but unused' variables + uint32_t send_time; + uint16_t duration; + uint32_t media_object_number; + uint32_t media_object_offset; + */ + uint16_t payload_count; + int payload_length_type; + uint32_t payload_hdrlen; + int payload_datalen; + int multiple; + uint32_t replicated_length; + uint32_t bytesread = 0; + uint8_t* buf; + size_t bufsize; + int i; + /*DEBUGF("Reading new packet at %d bytes ", (int)ci->curpos);*/ + + if (ci->read_filebuf(&tmp8, 1) == 0) { + return ASF_ERROR_EOF; + } + bytesread++; + + /* TODO: We need a better way to detect endofstream */ + if (tmp8 != 0x82) { + DEBUGF("Read failed: packet did not sync\n"); + return -1; + } + + + if (tmp8 & 0x80) { + ec_length = tmp8 & 0x0f; + opaque_data = (tmp8 >> 4) & 0x01; + ec_length_type = (tmp8 >> 5) & 0x03; + + if (ec_length_type != 0x00 || opaque_data != 0 || ec_length != 0x02) { + DEBUGF("incorrect error correction flags\n"); + return ASF_ERROR_INVALID_VALUE; + } + + /* Skip ec_data */ + ci->advance_buffer(ec_length); + bytesread += ec_length; + } else { + ec_length = 0; + } + + if (ci->read_filebuf(&packet_flags, 1) == 0) { return ASF_ERROR_EOF; } + if (ci->read_filebuf(&packet_property, 1) == 0) { return ASF_ERROR_EOF; } + bytesread += 2; + + datalen = GETLEN2b((packet_flags >> 1) & 0x03) + + GETLEN2b((packet_flags >> 3) & 0x03) + + GETLEN2b((packet_flags >> 5) & 0x03) + 6; + +#if 0 + if (datalen > sizeof(data)) { + DEBUGF("Unexpectedly long datalen in data - %d\n",datalen); + return ASF_ERROR_OUTOFMEM; + } +#endif + + if (ci->read_filebuf(data, datalen) == 0) { + return ASF_ERROR_EOF; + } + + bytesread += datalen; + + datap = data; + length = GETVALUE2b((packet_flags >> 5) & 0x03, datap); + datap += GETLEN2b((packet_flags >> 5) & 0x03); + /* sequence value is not used */ + GETVALUE2b((packet_flags >> 1) & 0x03, datap); + datap += GETLEN2b((packet_flags >> 1) & 0x03); + padding_length = GETVALUE2b((packet_flags >> 3) & 0x03, datap); + datap += GETLEN2b((packet_flags >> 3) & 0x03); + /* send_time = get_long_le(datap); */ + datap += 4; + /* duration = get_short_le(datap); */ + datap += 2; + /*DEBUGF("and duration %d ms\n", duration);*/ + + /* this is really idiotic, packet length can (and often will) be + * undefined and we just have to use the header packet size as the size + * value */ + if (!((packet_flags >> 5) & 0x03)) { + length = wfx->packet_size; + } + + /* this is also really idiotic, if packet length is smaller than packet + * size, we need to manually add the additional bytes into padding length + */ + if (length < wfx->packet_size) { + padding_length += wfx->packet_size - length; + length = wfx->packet_size; + } + + if (length > wfx->packet_size) { + DEBUGF("packet with too big length value\n"); + return ASF_ERROR_INVALID_LENGTH; + } + + /* check if we have multiple payloads */ + if (packet_flags & 0x01) { + if (ci->read_filebuf(&tmp8, 1) == 0) { + return ASF_ERROR_EOF; + } + payload_count = tmp8 & 0x3f; + payload_length_type = (tmp8 >> 6) & 0x03; + bytesread++; + } else { + payload_count = 1; + payload_length_type = 0x02; /* not used */ + } + + if (length < bytesread) { + DEBUGF("header exceeded packet size, invalid file - length=%d, bytesread=%d\n",(int)length,(int)bytesread); + /* FIXME: should this be checked earlier? */ + return ASF_ERROR_INVALID_LENGTH; + } + + + /* We now parse the individual payloads, and move all payloads + belonging to our audio stream to a contiguous block, starting at + the location of the first payload. + */ + + *audiobuf = NULL; + *audiobufsize = 0; + *packetlength = length - bytesread; + + buf = ci->request_buffer(&bufsize, length); + datap = buf; + +#define ASF_MAX_REQUEST (1L<<15) /* 32KB */ + if (bufsize != length && length >= ASF_MAX_REQUEST) { + /* This should only happen with packets larger than 32KB (the + guard buffer size). All the streams I've seen have + relatively small packets less than about 8KB), but I don't + know what is expected. + */ + DEBUGF("Could not read packet (requested %d bytes, received %d), curpos=%d, aborting\n", + (int)length,(int)bufsize,(int)ci->curpos); + return -1; + } + + for (i=0; i> 2) & 0x03) + + GETLEN2b((packet_property >> 4) & 0x03); + + //DEBUGF("payload_hdrlen = %d\n",payload_hdrlen); +#if 0 + /* TODO */ + if (payload_hdrlen > size) { + return ASF_ERROR_INVALID_LENGTH; + } +#endif + if (payload_hdrlen > sizeof(data)) { + DEBUGF("Unexpectedly long datalen in data - %d\n",datalen); + return ASF_ERROR_OUTOFMEM; + } + + bytesread += payload_hdrlen; + /* media_object_number = GETVALUE2b((packet_property >> 4) & 0x03, datap); */ + datap += GETLEN2b((packet_property >> 4) & 0x03); + /* media_object_offset = GETVALUE2b((packet_property >> 2) & 0x03, datap); */ + datap += GETLEN2b((packet_property >> 2) & 0x03); + replicated_length = GETVALUE2b(packet_property & 0x03, datap); + datap += GETLEN2b(packet_property & 0x03); + + /* TODO: Validate replicated_length */ + /* TODO: Is the content of this important for us? */ + datap += replicated_length; + bytesread += replicated_length; + + multiple = packet_flags & 0x01; + + + if (multiple) { + int x; + + x = GETLEN2b(payload_length_type); + + if (x != 2) { + /* in multiple payloads datalen should be a word */ + return ASF_ERROR_INVALID_VALUE; + } + +#if 0 + if (skip + tmp > datalen) { + /* not enough data */ + return ASF_ERROR_INVALID_LENGTH; + } +#endif + payload_datalen = GETVALUE2b(payload_length_type, datap); + datap += x; + bytesread += x; + } else { + payload_datalen = length - bytesread - padding_length; + } + + if (replicated_length==1) + datap++; + + if (stream_id == wfx->audiostream) + { + if (*audiobuf == NULL) { + /* The first payload can stay where it is */ + *audiobuf = datap; + *audiobufsize = payload_datalen; + } else { + /* The second and subsequent payloads in this packet + that belong to the audio stream need to be moved to be + contiguous with the first payload. + */ + memmove(*audiobuf + *audiobufsize, datap, payload_datalen); + *audiobufsize += payload_datalen; + } + } + datap += payload_datalen; + bytesread += payload_datalen; + } + + if (*audiobuf != NULL) + return 1; + else + return 0; +} + + +int asf_get_timestamp(int *duration) +{ + uint8_t tmp8, packet_flags, packet_property; + int ec_length, opaque_data, ec_length_type; + int datalen; + uint8_t data[18]; + uint8_t* datap; + /* rockbox: comment 'set but unused' variables + uint32_t length; + uint32_t padding_length; + */ + uint32_t send_time; + static int packet_count = 0; + + uint32_t bytesread = 0; + packet_count++; + if (ci->read_filebuf(&tmp8, 1) == 0) { + DEBUGF("ASF ERROR (EOF?)\n"); + return ASF_ERROR_EOF; + } + bytesread++; + + /* TODO: We need a better way to detect endofstream */ + if (tmp8 != 0x82) { + DEBUGF("Get timestamp: Detected end of stream\n"); + return ASF_ERROR_EOF; + } + + + if (tmp8 & 0x80) { + ec_length = tmp8 & 0x0f; + opaque_data = (tmp8 >> 4) & 0x01; + ec_length_type = (tmp8 >> 5) & 0x03; + + if (ec_length_type != 0x00 || opaque_data != 0 || ec_length != 0x02) { + DEBUGF("incorrect error correction flags\n"); + return ASF_ERROR_INVALID_VALUE; + } + + /* Skip ec_data */ + ci->advance_buffer(ec_length); + bytesread += ec_length; + } else { + ec_length = 0; + } + + if (ci->read_filebuf(&packet_flags, 1) == 0) { + DEBUGF("Detected end of stream 2\n"); + return ASF_ERROR_EOF; + } + + if (ci->read_filebuf(&packet_property, 1) == 0) { + DEBUGF("Detected end of stream3\n"); + return ASF_ERROR_EOF; + } + bytesread += 2; + + datalen = GETLEN2b((packet_flags >> 1) & 0x03) + + GETLEN2b((packet_flags >> 3) & 0x03) + + GETLEN2b((packet_flags >> 5) & 0x03) + 6; + + if (ci->read_filebuf(data, datalen) == 0) { + DEBUGF("Detected end of stream4\n"); + return ASF_ERROR_EOF; + } + + bytesread += datalen; + + datap = data; + /* length = GETVALUE2b((packet_flags >> 5) & 0x03, datap); */ + datap += GETLEN2b((packet_flags >> 5) & 0x03); + + /* sequence value is not used */ + GETVALUE2b((packet_flags >> 1) & 0x03, datap); + datap += GETLEN2b((packet_flags >> 1) & 0x03); + /* padding_length = GETVALUE2b((packet_flags >> 3) & 0x03, datap); */ + datap += GETLEN2b((packet_flags >> 3) & 0x03); + send_time = get_long_le(datap); + datap += 4; + *duration = get_short_le(datap); + + /*the asf_get_timestamp function advances us 12-13 bytes past the packet start, + need to undo this here so that we stay synced with the packet*/ + ci->seek_buffer(ci->curpos-bytesread); + + return send_time; +} + +/*entry point for seeks*/ +int asf_seek(int ms, asf_waveformatex_t* wfx) +{ + int time, duration, delta, temp, count=0; + + /*estimate packet number from bitrate*/ + int initial_packet = ci->curpos/wfx->packet_size; + int packet_num = (((int64_t)ms)*(wfx->bitrate>>3))/wfx->packet_size/1000; + int last_packet = ci->id3->filesize / wfx->packet_size; + + if (packet_num > last_packet) { + packet_num = last_packet; + } + + /*calculate byte address of the start of that packet*/ + int packet_offset = packet_num*wfx->packet_size; + + /*seek to estimated packet*/ + ci->seek_buffer(ci->id3->first_frame_offset+packet_offset); + temp = ms; + while (1) + { + /*for very large files it can be difficult and unimportant to find the exact packet*/ + count++; + + /*check the time stamp of our packet*/ + time = asf_get_timestamp(&duration); + /*DEBUGF("seeked to %d ms with duration %d\n", time, duration);*/ + + if (time < 0) { + /*unknown error, try to recover*/ + DEBUGF("UKNOWN SEEK ERROR\n"); + ci->seek_buffer(ci->id3->first_frame_offset+initial_packet*wfx->packet_size); + /*seek failed so return time stamp of the initial packet*/ + return asf_get_timestamp(&duration); + } + + if ((time+duration>=ms && time<=ms) || count > 10) { + /*DEBUGF("Found our packet! Now at %d packet\n", packet_num);*/ + return time; + } else { + /*seek again*/ + delta = ms-time; + /*estimate new packet number from bitrate and our current position*/ + temp += delta; + packet_num = ((temp/1000)*(wfx->bitrate>>3) - (wfx->packet_size>>1))/wfx->packet_size; //round down! + packet_offset = packet_num*wfx->packet_size; + ci->seek_buffer(ci->id3->first_frame_offset+packet_offset); + } + } +} diff --git a/lib/rbcodec/codecs/libasf/asf.h b/lib/rbcodec/codecs/libasf/asf.h new file mode 100644 index 0000000000..a7d384cf3d --- /dev/null +++ b/lib/rbcodec/codecs/libasf/asf.h @@ -0,0 +1,49 @@ +#ifndef _ASF_H +#define _ASF_H + +#include + +/* ASF codec IDs */ +#define ASF_CODEC_ID_WMAV1 0x160 +#define ASF_CODEC_ID_WMAV2 0x161 +#define ASF_CODEC_ID_WMAPRO 0x162 +#define ASF_CODEC_ID_WMAVOICE 0x00A + +enum asf_error_e { + ASF_ERROR_INTERNAL = -1, /* incorrect input to API calls */ + ASF_ERROR_OUTOFMEM = -2, /* some malloc inside program failed */ + ASF_ERROR_EOF = -3, /* unexpected end of file */ + ASF_ERROR_IO = -4, /* error reading or writing to file */ + ASF_ERROR_INVALID_LENGTH = -5, /* length value conflict in input data */ + ASF_ERROR_INVALID_VALUE = -6, /* other value conflict in input data */ + ASF_ERROR_INVALID_OBJECT = -7, /* ASF object missing or in wrong place */ + ASF_ERROR_OBJECT_SIZE = -8, /* invalid ASF object size (too small) */ + ASF_ERROR_SEEKABLE = -9, /* file not seekable */ + ASF_ERROR_SEEK = -10, /* file is seekable but seeking failed */ + ASF_ERROR_ENCRYPTED = -11 /* file is encrypted */ +}; + +struct asf_waveformatex_s { + uint32_t packet_size; + int audiostream; + uint16_t codec_id; + uint16_t channels; + uint32_t rate; + uint32_t bitrate; + uint16_t blockalign; + uint16_t bitspersample; + uint16_t datalen; + uint16_t numpackets; + uint8_t data[46]; +}; +typedef struct asf_waveformatex_s asf_waveformatex_t; + +int asf_read_packet(uint8_t** audiobuf, int* audiobufsize, int* packetlength, + asf_waveformatex_t* wfx); + +int asf_get_timestamp(int *duration); + +int asf_seek(int ms, asf_waveformatex_t* wfx); + + +#endif /* _ASF_H */ diff --git a/lib/rbcodec/codecs/libasf/libasf.make b/lib/rbcodec/codecs/libasf/libasf.make new file mode 100644 index 0000000000..dad0570402 --- /dev/null +++ b/lib/rbcodec/codecs/libasf/libasf.make @@ -0,0 +1,18 @@ +# __________ __ ___. +# Open \______ \ ____ ____ | | _\_ |__ _______ ___ +# Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ / +# Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < < +# Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \ +# \/ \/ \/ \/ \/ +# $Id$ +# + +# libasf +ASFLIB := $(CODECDIR)/libasf.a +ASFLIB_SRC := $(call preprocess, $(RBCODECLIB_DIR)/codecs/libasf/SOURCES) +ASFLIB_OBJ := $(call c2obj, $(ASFLIB_SRC)) +OTHER_SRC += $(ASFLIB_SRC) + +$(ASFLIB): $(ASFLIB_OBJ) + $(SILENT)$(shell rm -f $@) + $(call PRINTS,AR $(@F))$(AR) rcs $@ $^ >/dev/null -- cgit v1.2.3