mirror of https://github.com/FFmpeg/FFmpeg.git
Vesselin Bontchev
10 years ago
parent
45f3d4e63e
commit
e32a99264b
6 changed files with 314 additions and 0 deletions
@ -0,0 +1,303 @@ |
||||
/*
|
||||
* Audible AA demuxer |
||||
* Copyright (c) 2015 Vesselin Bontchev |
||||
* |
||||
* Header parsing is borrowed from https://github.com/jteeuwen/audible project.
|
||||
* Copyright (c) 2001-2014, Jim Teeuwen |
||||
* |
||||
* Redistribution and use in source and binary forms, with or without modification, |
||||
* are permitted provided that the following conditions are met: |
||||
* |
||||
* 1. Redistributions of source code must retain the above copyright notice, this |
||||
* list of conditions and the following disclaimer. |
||||
* |
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND |
||||
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED |
||||
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
||||
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR |
||||
* ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES |
||||
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
||||
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON |
||||
* ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS |
||||
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
*/ |
||||
|
||||
#include "avformat.h" |
||||
#include "internal.h" |
||||
#include "libavutil/intreadwrite.h" |
||||
#include "libavutil/tea.h" |
||||
#include "libavutil/opt.h" |
||||
|
||||
#define AA_MAGIC 1469084982 /* this identifies an audible .aa file */ |
||||
#define MAX_CODEC_SECOND_SIZE 3982 |
||||
#define MAX_TOC_ENTRIES 16 |
||||
#define MAX_DICTIONARY_ENTRIES 128 |
||||
#define TEA_BLOCK_SIZE 8 |
||||
|
||||
typedef struct AADemuxContext { |
||||
AVClass *class; |
||||
uint8_t *aa_fixed_key; |
||||
int aa_fixed_key_len; |
||||
int codec_second_size; |
||||
int current_codec_second_size; |
||||
int chapter_idx; |
||||
struct AVTEA *tea_ctx; |
||||
uint8_t file_key[16]; |
||||
int64_t current_chapter_size; |
||||
} AADemuxContext; |
||||
|
||||
static int get_second_size(char *codec_name) |
||||
{ |
||||
int result = -1; |
||||
|
||||
if (!strcmp(codec_name, "mp332")) { |
||||
result = 3982; |
||||
} else if (!strcmp(codec_name, "acelp16")) { |
||||
result = 2000; |
||||
} else if (!strcmp(codec_name, "acelp85")) { |
||||
result = 1045; |
||||
} |
||||
|
||||
return result; |
||||
} |
||||
|
||||
static int aa_read_header(AVFormatContext *s) |
||||
{ |
||||
int i, j, idx, largest_idx = -1; |
||||
uint32_t nkey, nval, toc_size, npairs, header_seed, start; |
||||
char key[128], val[128], codec_name[64] = {0}; |
||||
uint8_t output[24], dst[8], src[8]; |
||||
int64_t largest_size = -1, current_size = -1; |
||||
struct toc_entry { |
||||
uint32_t offset; |
||||
uint32_t size; |
||||
} TOC[MAX_TOC_ENTRIES]; |
||||
uint32_t header_key_part[4]; |
||||
uint8_t header_key[16]; |
||||
AADemuxContext *c = s->priv_data; |
||||
AVIOContext *pb = s->pb; |
||||
AVStream *st; |
||||
|
||||
/* parse .aa header */ |
||||
avio_skip(pb, 4); // file size
|
||||
avio_skip(pb, 4); // magic string
|
||||
toc_size = avio_rb32(pb); // TOC size
|
||||
avio_skip(pb, 4); // unidentified integer
|
||||
if (toc_size > MAX_TOC_ENTRIES) |
||||
return AVERROR_INVALIDDATA; |
||||
for (i = 0; i < toc_size; i++) { // read TOC
|
||||
avio_skip(pb, 4); // TOC entry index
|
||||
TOC[i].offset = avio_rb32(pb); // block offset
|
||||
TOC[i].size = avio_rb32(pb); // block size
|
||||
} |
||||
avio_skip(pb, 24); // header termination block (ignored)
|
||||
npairs = avio_rb32(pb); // read dictionary entries
|
||||
if (npairs > MAX_DICTIONARY_ENTRIES) |
||||
return AVERROR_INVALIDDATA; |
||||
for (i = 0; i < npairs; i++) { |
||||
memset(val, 0, sizeof(val)); |
||||
memset(key, 0, sizeof(key)); |
||||
avio_skip(pb, 1); // unidentified integer
|
||||
nkey = avio_rb32(pb); // key string length
|
||||
nval = avio_rb32(pb); // value string length
|
||||
if (nkey > sizeof(key)) { |
||||
avio_skip(pb, nkey); |
||||
} else { |
||||
avio_read(pb, key, nkey); // key string
|
||||
} |
||||
if (nval > sizeof(val)) { |
||||
avio_skip(pb, nval); |
||||
} else { |
||||
avio_read(pb, val, nval); // value string
|
||||
} |
||||
if (!strcmp(key, "codec")) { |
||||
strncpy(codec_name, val, sizeof(codec_name) - 1); |
||||
} |
||||
if (!strcmp(key, "HeaderSeed")) { |
||||
header_seed = atoi(val); |
||||
} |
||||
if (!strcmp(key, "HeaderKey")) { // this looks like "1234567890 1234567890 1234567890 1234567890"
|
||||
sscanf(val, "%d%d%d%d", &header_key_part[0], &header_key_part[1], &header_key_part[2], &header_key_part[3]); |
||||
for (idx = 0; idx < 4; idx++) { |
||||
AV_WB32(&header_key[idx * 4], header_key_part[idx]); // convert each part to BE!
|
||||
} |
||||
} |
||||
} |
||||
|
||||
/* verify fixed key */ |
||||
if (c->aa_fixed_key_len != 16) { |
||||
av_log(s, AV_LOG_ERROR, "aa_fixed_key value needs to be 16 bytes!\n"); |
||||
return AVERROR(EINVAL); |
||||
} |
||||
|
||||
/* verify codec */ |
||||
if ((c->codec_second_size = get_second_size(codec_name)) == -1) { |
||||
av_log(s, AV_LOG_ERROR, "unknown codec <%s>!\n", codec_name); |
||||
return AVERROR(EINVAL); |
||||
} |
||||
|
||||
/* decryption key derivation */ |
||||
c->tea_ctx = av_tea_alloc(); |
||||
if (!c->tea_ctx) |
||||
return AVERROR(ENOMEM); |
||||
av_tea_init(c->tea_ctx, c->aa_fixed_key, 16); |
||||
output[0] = output[1] = 0; // purely for padding purposes
|
||||
memcpy(output + 2, &header_key, 16); |
||||
idx = 0; |
||||
for (i = 0; i < 3; i++) { // TEA CBC with weird mixed endianness
|
||||
AV_WB32(src, header_seed); |
||||
AV_WB32(src + 4, header_seed + 1); |
||||
header_seed += 2; |
||||
av_tea_crypt(c->tea_ctx, dst, src, 1, NULL, 0); // TEA ECB encrypt
|
||||
for (j = 0; j < TEA_BLOCK_SIZE && idx < 18; j+=1, idx+=1) { |
||||
output[idx] = output[idx] ^ dst[j]; |
||||
} |
||||
} |
||||
memcpy(c->file_key, output + 2, 16); // skip first 2 bytes of output
|
||||
|
||||
/* decoder setup */ |
||||
st = avformat_new_stream(s, NULL); |
||||
if (!st) { |
||||
av_freep(&c->tea_ctx); |
||||
return AVERROR(ENOMEM); |
||||
} |
||||
st->codec->codec_type = AVMEDIA_TYPE_AUDIO; |
||||
if (!strcmp(codec_name, "mp332")) { |
||||
st->codec->codec_id = AV_CODEC_ID_MP3; |
||||
st->codec->sample_rate = 22050; |
||||
st->need_parsing = AVSTREAM_PARSE_FULL_RAW; |
||||
st->start_time = 0; |
||||
} else if (!strcmp(codec_name, "acelp85")) { |
||||
st->codec->codec_id = AV_CODEC_ID_SIPR; |
||||
st->codec->block_align = 19; |
||||
st->codec->channels = 1; |
||||
st->codec->sample_rate = 8500; |
||||
} else if (!strcmp(codec_name, "acelp16")) { |
||||
st->codec->codec_id = AV_CODEC_ID_SIPR; |
||||
st->codec->block_align = 20; |
||||
st->codec->channels = 1; |
||||
st->codec->sample_rate = 16000; |
||||
} |
||||
|
||||
/* determine, and jump to audio start offset */ |
||||
for (i = 1; i < toc_size; i++) { // skip the first entry!
|
||||
current_size = TOC[i].size; |
||||
if (current_size > largest_size) { |
||||
largest_idx = i; |
||||
largest_size = current_size; |
||||
} |
||||
} |
||||
start = TOC[largest_idx].offset; |
||||
avio_seek(pb, start, SEEK_SET); |
||||
c->current_chapter_size = 0; |
||||
|
||||
return 0; |
||||
} |
||||
|
||||
static int aa_read_packet(AVFormatContext *s, AVPacket *pkt) |
||||
{ |
||||
uint8_t dst[TEA_BLOCK_SIZE]; |
||||
uint8_t src[TEA_BLOCK_SIZE]; |
||||
int i; |
||||
int trailing_bytes; |
||||
int blocks; |
||||
uint8_t buf[MAX_CODEC_SECOND_SIZE * 2]; |
||||
int written = 0; |
||||
int ret; |
||||
AADemuxContext *c = s->priv_data; |
||||
|
||||
// are we at the start of a chapter?
|
||||
if (c->current_chapter_size == 0) { |
||||
c->current_chapter_size = avio_rb32(s->pb); |
||||
if (c->current_chapter_size == 0) { |
||||
return AVERROR_EOF; |
||||
} |
||||
av_log(s, AV_LOG_DEBUG, "Chapter %d (%" PRId64 " bytes)\n", c->chapter_idx, c->current_chapter_size); |
||||
c->chapter_idx = c->chapter_idx + 1; |
||||
avio_skip(s->pb, 4); // data start offset
|
||||
c->current_codec_second_size = c->codec_second_size; |
||||
} |
||||
|
||||
// is this the last block in this chapter?
|
||||
if (c->current_chapter_size / c->current_codec_second_size == 0) { |
||||
c->current_codec_second_size = c->current_chapter_size % c->current_codec_second_size; |
||||
} |
||||
|
||||
// decrypt c->current_codec_second_size bytes
|
||||
blocks = c->current_codec_second_size / TEA_BLOCK_SIZE; |
||||
for (i = 0; i < blocks; i++) { |
||||
avio_read(s->pb, src, TEA_BLOCK_SIZE); |
||||
av_tea_init(c->tea_ctx, c->file_key, 16); |
||||
av_tea_crypt(c->tea_ctx, dst, src, 1, NULL, 1); |
||||
memcpy(buf + written, dst, TEA_BLOCK_SIZE); |
||||
written = written + TEA_BLOCK_SIZE; |
||||
} |
||||
trailing_bytes = c->current_codec_second_size % TEA_BLOCK_SIZE; |
||||
if (trailing_bytes != 0) { // trailing bytes are left unencrypted!
|
||||
avio_read(s->pb, src, trailing_bytes); |
||||
memcpy(buf + written, src, trailing_bytes); |
||||
written = written + trailing_bytes; |
||||
} |
||||
|
||||
// update state
|
||||
c->current_chapter_size = c->current_chapter_size - c->current_codec_second_size; |
||||
if (c->current_chapter_size <= 0) |
||||
c->current_chapter_size = 0; |
||||
|
||||
ret = av_new_packet(pkt, written); |
||||
if (ret < 0) |
||||
return ret; |
||||
memcpy(pkt->data, buf, written); |
||||
|
||||
return 0; |
||||
} |
||||
|
||||
static int aa_probe(AVProbeData *p) |
||||
{ |
||||
uint8_t *buf = p->buf; |
||||
|
||||
// first 4 bytes are file size, next 4 bytes are the magic
|
||||
if (AV_RB32(buf+4) != AA_MAGIC) |
||||
return 0; |
||||
|
||||
return AVPROBE_SCORE_MAX / 2; |
||||
} |
||||
|
||||
static int aa_read_close(AVFormatContext *s) |
||||
{ |
||||
AADemuxContext *c = s->priv_data; |
||||
|
||||
av_freep(&c->tea_ctx); |
||||
|
||||
return 0; |
||||
} |
||||
|
||||
#define OFFSET(x) offsetof(AADemuxContext, x) |
||||
static const AVOption aa_options[] = { |
||||
{ "aa_fixed_key", // extracted from libAAX_SDK.so and AAXSDKWin.dll files!
|
||||
"Fixed key used for handling Audible AA files", OFFSET(aa_fixed_key), |
||||
AV_OPT_TYPE_BINARY, {.str="77214d4b196a87cd520045fd2a51d673"}, |
||||
.flags = AV_OPT_FLAG_DECODING_PARAM }, |
||||
{ NULL }, |
||||
}; |
||||
|
||||
static const AVClass aa_class = { |
||||
.class_name = "aa", |
||||
.item_name = av_default_item_name, |
||||
.option = aa_options, |
||||
.version = LIBAVUTIL_VERSION_INT, |
||||
}; |
||||
|
||||
AVInputFormat ff_aa_demuxer = { |
||||
.name = "aa", |
||||
.long_name = NULL_IF_CONFIG_SMALL("Audible AA format files"), |
||||
.priv_class = &aa_class, |
||||
.priv_data_size = sizeof(AADemuxContext), |
||||
.extensions = "aa", |
||||
.read_probe = aa_probe, |
||||
.read_header = aa_read_header, |
||||
.read_packet = aa_read_packet, |
||||
.read_close = aa_read_close, |
||||
.flags = AVFMT_GENERIC_INDEX, |
||||
}; |
||||
Loading…
Reference in new issue