From 4d7b96107b6d8b3f71fe5fdc1c64c65153100c0b Mon Sep 17 00:00:00 2001 From: Chris Moeller Date: Thu, 10 Oct 2013 23:51:19 -0700 Subject: [PATCH] Added TrueAudio support --- .../FFMPEG/FFMPEG.xcodeproj/project.pbxproj | 16 + Frameworks/FFMPEG/ffmpeg-minimal/config.h | 4 +- .../FFMPEG/ffmpeg-minimal/libavcodec/tta.c | 457 ++++++++++++++++++ .../ffmpeg-minimal/libavcodec/ttadata.c | 52 ++ .../ffmpeg-minimal/libavcodec/ttadata.h | 50 ++ .../FFMPEG/ffmpeg-minimal/libavformat/tta.c | 193 ++++++++ Plugins/FFMPEG/FFMPEGDecoder.m | 4 +- Plugins/TagLib/TagLibMetadataReader.m | 4 +- 8 files changed, 774 insertions(+), 6 deletions(-) create mode 100644 Frameworks/FFMPEG/ffmpeg-minimal/libavcodec/tta.c create mode 100644 Frameworks/FFMPEG/ffmpeg-minimal/libavcodec/ttadata.c create mode 100644 Frameworks/FFMPEG/ffmpeg-minimal/libavcodec/ttadata.h create mode 100644 Frameworks/FFMPEG/ffmpeg-minimal/libavformat/tta.c diff --git a/Frameworks/FFMPEG/FFMPEG.xcodeproj/project.pbxproj b/Frameworks/FFMPEG/FFMPEG.xcodeproj/project.pbxproj index 9f3947a42..d292567a8 100644 --- a/Frameworks/FFMPEG/FFMPEG.xcodeproj/project.pbxproj +++ b/Frameworks/FFMPEG/FFMPEG.xcodeproj/project.pbxproj @@ -396,6 +396,10 @@ 8384910F1807CEC400E7332D /* lpc.c in Sources */ = {isa = PBXBuildFile; fileRef = 8384910E1807CEC400E7332D /* lpc.c */; }; 838491111807CEF400E7332D /* sbrdsp_init.c in Sources */ = {isa = PBXBuildFile; fileRef = 838491101807CEF400E7332D /* sbrdsp_init.c */; }; 838491131807D06100E7332D /* spdifdec.c in Sources */ = {isa = PBXBuildFile; fileRef = 838491121807D06100E7332D /* spdifdec.c */; }; + 838491151807D1D200E7332D /* tta.c in Sources */ = {isa = PBXBuildFile; fileRef = 838491141807D1D200E7332D /* tta.c */; }; + 838491191807D1D900E7332D /* tta.c in Sources */ = {isa = PBXBuildFile; fileRef = 838491161807D1D900E7332D /* tta.c */; }; + 8384911A1807D1D900E7332D /* ttadata.c in Sources */ = {isa = PBXBuildFile; fileRef = 838491171807D1D900E7332D /* ttadata.c */; }; + 8384911B1807D1D900E7332D /* ttadata.h in Headers */ = {isa = PBXBuildFile; fileRef = 838491181807D1D900E7332D /* ttadata.h */; }; 8393B7E218052BB000913C76 /* mp3dec.c in Sources */ = {isa = PBXBuildFile; fileRef = 8393B7DF18052BB000913C76 /* mp3dec.c */; }; 8393B7E318052BB000913C76 /* mpeg.c in Sources */ = {isa = PBXBuildFile; fileRef = 8393B7E018052BB000913C76 /* mpeg.c */; }; 8393B7E418052BB000913C76 /* mpeg.h in Headers */ = {isa = PBXBuildFile; fileRef = 8393B7E118052BB000913C76 /* mpeg.h */; }; @@ -823,6 +827,10 @@ 8384910E1807CEC400E7332D /* lpc.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = lpc.c; sourceTree = ""; }; 838491101807CEF400E7332D /* sbrdsp_init.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = sbrdsp_init.c; sourceTree = ""; }; 838491121807D06100E7332D /* spdifdec.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = spdifdec.c; sourceTree = ""; }; + 838491141807D1D200E7332D /* tta.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = tta.c; sourceTree = ""; }; + 838491161807D1D900E7332D /* tta.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = tta.c; sourceTree = ""; }; + 838491171807D1D900E7332D /* ttadata.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = ttadata.c; sourceTree = ""; }; + 838491181807D1D900E7332D /* ttadata.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ttadata.h; sourceTree = ""; }; 8393B7DF18052BB000913C76 /* mp3dec.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = mp3dec.c; sourceTree = ""; }; 8393B7E018052BB000913C76 /* mpeg.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = mpeg.c; sourceTree = ""; }; 8393B7E118052BB000913C76 /* mpeg.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = mpeg.h; sourceTree = ""; }; @@ -935,6 +943,9 @@ 830F0B8E17FC4FB900042E8F /* libavcodec */ = { isa = PBXGroup; children = ( + 838491161807D1D900E7332D /* tta.c */, + 838491171807D1D900E7332D /* ttadata.c */, + 838491181807D1D900E7332D /* ttadata.h */, 8384910C1807CEB600E7332D /* sbrdsp.c */, 838491041807CDEC00E7332D /* cbrt_tablegen.h */, 838491001807CDC000E7332D /* lpc.c */, @@ -1184,6 +1195,7 @@ 830F0BAD17FC4FB900042E8F /* libavformat */ = { isa = PBXGroup; children = ( + 838491141807D1D200E7332D /* tta.c */, 838491121807D06100E7332D /* spdifdec.c */, 838490FE1807C58500E7332D /* aacdec.c */, 838490961807BC9C00E7332D /* dtshddec.c */, @@ -1445,6 +1457,7 @@ 830F0C0317FC4FB900042E8F /* frame.h in Headers */, 830F0C0117FC4FB900042E8F /* dict.h in Headers */, 8393B80418052BC200913C76 /* mpegaudiodectab.h in Headers */, + 8384911B1807D1D900E7332D /* ttadata.h in Headers */, 830F0BFE17FC4FB900042E8F /* channel_layout.h in Headers */, 830F0C0017FC4FB900042E8F /* cpu.h in Headers */, 830F0C0217FC4FB900042E8F /* error.h in Headers */, @@ -1728,6 +1741,7 @@ 830F0DCD17FC933100042E8F /* w64.c in Sources */, 833C37D518032E7000CBA602 /* jrevdct.c in Sources */, 830F0BE217FC4FB900042E8F /* utils.c in Sources */, + 838491191807D1D900E7332D /* tta.c in Sources */, 838490741807B07000E7332D /* md5.c in Sources */, 8393B80E18052BD500913C76 /* mpegaudiodsp.c in Sources */, 8384909C1807BE1300E7332D /* synth_filter.c in Sources */, @@ -1748,6 +1762,7 @@ 830F0BF217FC4FB900042E8F /* avio.c in Sources */, 838490DC1807C47E00E7332D /* g723_1.c in Sources */, 830F0CE217FC7F1E00042E8F /* frame_thread_encoder.c in Sources */, + 838491151807D1D200E7332D /* tta.c in Sources */, 8393B80118052BC200913C76 /* mpegaudiodec.c in Sources */, 830F0C3817FC554D00042E8F /* buffer.c in Sources */, 8384905C1807AF0100E7332D /* ac3_parser.c in Sources */, @@ -1894,6 +1909,7 @@ 83BCB8E317FCA64400760340 /* timecode.c in Sources */, 8393B80B18052BC200913C76 /* mpegaudioenc.c in Sources */, 8384910D1807CEB600E7332D /* sbrdsp.c in Sources */, + 8384911A1807D1D900E7332D /* ttadata.c in Sources */, 838490B91807C1C300E7332D /* truespeech.c in Sources */, 830F0D3517FC841B00042E8F /* samplefmt.c in Sources */, 830F0BEA17FC4FB900042E8F /* wmaprodec.c in Sources */, diff --git a/Frameworks/FFMPEG/ffmpeg-minimal/config.h b/Frameworks/FFMPEG/ffmpeg-minimal/config.h index a4fd40d8e..1b3baa64a 100644 --- a/Frameworks/FFMPEG/ffmpeg-minimal/config.h +++ b/Frameworks/FFMPEG/ffmpeg-minimal/config.h @@ -455,7 +455,7 @@ #define CONFIG_TRUEHD_DECODER 0 #define CONFIG_TRUESPEECH_DECODER 0 #define CONFIG_TTA_ENCODER 0 -#define CONFIG_TTA_DECODER 0 +#define CONFIG_TTA_DECODER 1 #define CONFIG_TWINVQ_DECODER 0 #define CONFIG_VMDAUDIO_DECODER 0 #define CONFIG_VORBIS_ENCODER 0 @@ -1002,7 +1002,7 @@ #define CONFIG_TMV_DEMUXER 0 #define CONFIG_TRUEHD_MUXER 0 #define CONFIG_TRUEHD_DEMUXER 0 -#define CONFIG_TTA_DEMUXER 0 +#define CONFIG_TTA_DEMUXER 1 #define CONFIG_TXD_DEMUXER 0 #define CONFIG_TTY_DEMUXER 0 #define CONFIG_VC1_MUXER 0 diff --git a/Frameworks/FFMPEG/ffmpeg-minimal/libavcodec/tta.c b/Frameworks/FFMPEG/ffmpeg-minimal/libavcodec/tta.c new file mode 100644 index 000000000..062ed9662 --- /dev/null +++ b/Frameworks/FFMPEG/ffmpeg-minimal/libavcodec/tta.c @@ -0,0 +1,457 @@ +/* + * TTA (The Lossless True Audio) decoder + * Copyright (c) 2006 Alex Beregszaszi + * + * This file is part of FFmpeg. + * + * FFmpeg is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * FFmpeg is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with FFmpeg; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +/** + * @file + * TTA (The Lossless True Audio) decoder + * @see http://www.true-audio.com/ + * @see http://tta.corecodec.org/ + * @author Alex Beregszaszi + */ + +#define BITSTREAM_READER_LE +#include +#include "config.h" +#include "ttadata.h" +#include "avcodec.h" +#include "get_bits.h" +#include "thread.h" +#include "unary.h" +#include "internal.h" +#include "libavutil/crc.h" +#include "libavutil/intreadwrite.h" +#include "libavutil/opt.h" +#include "libavutil/internal.h" + +#define FORMAT_SIMPLE 1 +#define FORMAT_ENCRYPTED 2 + +typedef struct TTAContext { + AVClass *class; + AVCodecContext *avctx; + const AVCRC *crc_table; + + int format, channels, bps; + unsigned data_length; + int frame_length, last_frame_length; + + int32_t *decode_buffer; + + uint8_t crc_pass[8]; + uint8_t *pass; + TTAChannel *ch_ctx; +} TTAContext; + +static inline void ttafilter_process(TTAFilter *c, int32_t *in) +{ + register int32_t *dl = c->dl, *qm = c->qm, *dx = c->dx, sum = c->round; + + if (c->error < 0) { + qm[0] -= dx[0]; qm[1] -= dx[1]; qm[2] -= dx[2]; qm[3] -= dx[3]; + qm[4] -= dx[4]; qm[5] -= dx[5]; qm[6] -= dx[6]; qm[7] -= dx[7]; + } else if (c->error > 0) { + qm[0] += dx[0]; qm[1] += dx[1]; qm[2] += dx[2]; qm[3] += dx[3]; + qm[4] += dx[4]; qm[5] += dx[5]; qm[6] += dx[6]; qm[7] += dx[7]; + } + + sum += dl[0] * qm[0] + dl[1] * qm[1] + dl[2] * qm[2] + dl[3] * qm[3] + + dl[4] * qm[4] + dl[5] * qm[5] + dl[6] * qm[6] + dl[7] * qm[7]; + + dx[0] = dx[1]; dx[1] = dx[2]; dx[2] = dx[3]; dx[3] = dx[4]; + dl[0] = dl[1]; dl[1] = dl[2]; dl[2] = dl[3]; dl[3] = dl[4]; + + dx[4] = ((dl[4] >> 30) | 1); + dx[5] = ((dl[5] >> 30) | 2) & ~1; + dx[6] = ((dl[6] >> 30) | 2) & ~1; + dx[7] = ((dl[7] >> 30) | 4) & ~3; + + c->error = *in; + *in += (sum >> c->shift); + + dl[4] = -dl[5]; dl[5] = -dl[6]; + dl[6] = *in - dl[7]; dl[7] = *in; + dl[5] += dl[6]; dl[4] += dl[5]; +} + +static const int64_t tta_channel_layouts[7] = { + AV_CH_LAYOUT_STEREO, + AV_CH_LAYOUT_STEREO|AV_CH_LOW_FREQUENCY, + AV_CH_LAYOUT_QUAD, + 0, + AV_CH_LAYOUT_5POINT1_BACK, + AV_CH_LAYOUT_5POINT1_BACK|AV_CH_BACK_CENTER, + AV_CH_LAYOUT_7POINT1_WIDE +}; + +static int tta_check_crc(TTAContext *s, const uint8_t *buf, int buf_size) +{ + uint32_t crc, CRC; + + CRC = AV_RL32(buf + buf_size); + crc = av_crc(s->crc_table, 0xFFFFFFFFU, buf, buf_size); + if (CRC != (crc ^ 0xFFFFFFFFU)) { + av_log(s->avctx, AV_LOG_ERROR, "CRC error\n"); + return AVERROR_INVALIDDATA; + } + + return 0; +} + +static uint64_t tta_check_crc64(uint8_t *pass) +{ + uint64_t crc = UINT64_MAX, poly = 0x42F0E1EBA9EA3693U; + uint8_t *end = pass + strlen(pass); + int i; + + while (pass < end) { + crc ^= (uint64_t)*pass++ << 56; + for (i = 0; i < 8; i++) + crc = (crc << 1) ^ (poly & (((int64_t) crc) >> 63)); + } + + return crc ^ UINT64_MAX; +} + +static int allocate_buffers(AVCodecContext *avctx) +{ + TTAContext *s = avctx->priv_data; + + if (s->bps < 3) { + s->decode_buffer = av_mallocz(sizeof(int32_t)*s->frame_length*s->channels); + if (!s->decode_buffer) + return AVERROR(ENOMEM); + } else + s->decode_buffer = NULL; + s->ch_ctx = av_malloc(avctx->channels * sizeof(*s->ch_ctx)); + if (!s->ch_ctx) { + av_freep(&s->decode_buffer); + return AVERROR(ENOMEM); + } + + return 0; +} + +static av_cold int tta_decode_init(AVCodecContext * avctx) +{ + TTAContext *s = avctx->priv_data; + GetBitContext gb; + int total_frames; + + s->avctx = avctx; + + // 30bytes includes TTA1 header + if (avctx->extradata_size < 22) + return AVERROR_INVALIDDATA; + + s->crc_table = av_crc_get_table(AV_CRC_32_IEEE_LE); + init_get_bits8(&gb, avctx->extradata, avctx->extradata_size); + if (show_bits_long(&gb, 32) == AV_RL32("TTA1")) { + /* signature */ + skip_bits_long(&gb, 32); + + s->format = get_bits(&gb, 16); + if (s->format > 2) { + av_log(avctx, AV_LOG_ERROR, "Invalid format\n"); + return AVERROR_INVALIDDATA; + } + if (s->format == FORMAT_ENCRYPTED) { + if (!s->pass) { + av_log(avctx, AV_LOG_ERROR, "Missing password for encrypted stream. Please use the -password option\n"); + return AVERROR(EINVAL); + } + AV_WL64(s->crc_pass, tta_check_crc64(s->pass)); + } + avctx->channels = s->channels = get_bits(&gb, 16); + if (s->channels > 1 && s->channels < 9) + avctx->channel_layout = tta_channel_layouts[s->channels-2]; + avctx->bits_per_raw_sample = get_bits(&gb, 16); + s->bps = (avctx->bits_per_raw_sample + 7) / 8; + avctx->sample_rate = get_bits_long(&gb, 32); + s->data_length = get_bits_long(&gb, 32); + skip_bits_long(&gb, 32); // CRC32 of header + + if (s->channels == 0) { + av_log(avctx, AV_LOG_ERROR, "Invalid number of channels\n"); + return AVERROR_INVALIDDATA; + } else if (avctx->sample_rate == 0) { + av_log(avctx, AV_LOG_ERROR, "Invalid samplerate\n"); + return AVERROR_INVALIDDATA; + } + + switch(s->bps) { + case 1: avctx->sample_fmt = AV_SAMPLE_FMT_U8; break; + case 2: + avctx->sample_fmt = AV_SAMPLE_FMT_S16; + break; + case 3: + avctx->sample_fmt = AV_SAMPLE_FMT_S32; + break; + //case 4: avctx->sample_fmt = AV_SAMPLE_FMT_S32; break; + default: + av_log(avctx, AV_LOG_ERROR, "Invalid/unsupported sample format.\n"); + return AVERROR_INVALIDDATA; + } + + // prevent overflow + if (avctx->sample_rate > 0x7FFFFFu) { + av_log(avctx, AV_LOG_ERROR, "sample_rate too large\n"); + return AVERROR(EINVAL); + } + s->frame_length = 256 * avctx->sample_rate / 245; + + s->last_frame_length = s->data_length % s->frame_length; + total_frames = s->data_length / s->frame_length + + (s->last_frame_length ? 1 : 0); + + av_log(avctx, AV_LOG_DEBUG, "format: %d chans: %d bps: %d rate: %d block: %d\n", + s->format, avctx->channels, avctx->bits_per_coded_sample, avctx->sample_rate, + avctx->block_align); + av_log(avctx, AV_LOG_DEBUG, "data_length: %d frame_length: %d last: %d total: %d\n", + s->data_length, s->frame_length, s->last_frame_length, total_frames); + + if(s->frame_length >= UINT_MAX / (s->channels * sizeof(int32_t))){ + av_log(avctx, AV_LOG_ERROR, "frame_length too large\n"); + return AVERROR_INVALIDDATA; + } + } else { + av_log(avctx, AV_LOG_ERROR, "Wrong extradata present\n"); + return AVERROR_INVALIDDATA; + } + + return allocate_buffers(avctx); +} + +static int tta_decode_frame(AVCodecContext *avctx, void *data, + int *got_frame_ptr, AVPacket *avpkt) +{ + AVFrame *frame = data; + ThreadFrame tframe = { .f = data }; + const uint8_t *buf = avpkt->data; + int buf_size = avpkt->size; + TTAContext *s = avctx->priv_data; + GetBitContext gb; + int i, ret; + int cur_chan = 0, framelen = s->frame_length; + int32_t *p; + + if (avctx->err_recognition & AV_EF_CRCCHECK) { + if (buf_size < 4 || tta_check_crc(s, buf, buf_size - 4)) + return AVERROR_INVALIDDATA; + } + + if ((ret = init_get_bits8(&gb, avpkt->data, avpkt->size)) < 0) + return ret; + + /* get output buffer */ + frame->nb_samples = framelen; + if ((ret = ff_thread_get_buffer(avctx, &tframe, 0)) < 0) + return ret; + + // decode directly to output buffer for 24-bit sample format + if (s->bps == 3) + s->decode_buffer = (int32_t *)frame->data[0]; + + // init per channel states + for (i = 0; i < s->channels; i++) { + TTAFilter *filter = &s->ch_ctx[i].filter; + s->ch_ctx[i].predictor = 0; + ff_tta_filter_init(filter, ff_tta_filter_configs[s->bps-1]); + if (s->format == FORMAT_ENCRYPTED) { + int i; + for (i = 0; i < 8; i++) + filter->qm[i] = sign_extend(s->crc_pass[i], 8); + } + ff_tta_rice_init(&s->ch_ctx[i].rice, 10, 10); + } + + i = 0; + for (p = s->decode_buffer; p < s->decode_buffer + (framelen * s->channels); p++) { + int32_t *predictor = &s->ch_ctx[cur_chan].predictor; + TTAFilter *filter = &s->ch_ctx[cur_chan].filter; + TTARice *rice = &s->ch_ctx[cur_chan].rice; + uint32_t unary, depth, k; + int32_t value; + + unary = get_unary(&gb, 0, get_bits_left(&gb)); + + if (unary == 0) { + depth = 0; + k = rice->k0; + } else { + depth = 1; + k = rice->k1; + unary--; + } + + if (get_bits_left(&gb) < k) { + ret = AVERROR_INVALIDDATA; + goto error; + } + + if (k) { + if (k > MIN_CACHE_BITS) { + ret = AVERROR_INVALIDDATA; + goto error; + } + value = (unary << k) + get_bits(&gb, k); + } else + value = unary; + + // FIXME: copy paste from original + switch (depth) { + case 1: + rice->sum1 += value - (rice->sum1 >> 4); + if (rice->k1 > 0 && rice->sum1 < ff_tta_shift_16[rice->k1]) + rice->k1--; + else if(rice->sum1 > ff_tta_shift_16[rice->k1 + 1]) + rice->k1++; + value += ff_tta_shift_1[rice->k0]; + default: + rice->sum0 += value - (rice->sum0 >> 4); + if (rice->k0 > 0 && rice->sum0 < ff_tta_shift_16[rice->k0]) + rice->k0--; + else if(rice->sum0 > ff_tta_shift_16[rice->k0 + 1]) + rice->k0++; + } + + // extract coded value + *p = 1 + ((value >> 1) ^ ((value & 1) - 1)); + + // run hybrid filter + ttafilter_process(filter, p); + + // fixed order prediction +#define PRED(x, k) (int32_t)((((uint64_t)x << k) - x) >> k) + switch (s->bps) { + case 1: *p += PRED(*predictor, 4); break; + case 2: + case 3: *p += PRED(*predictor, 5); break; + case 4: *p += *predictor; break; + } + *predictor = *p; + + // flip channels + if (cur_chan < (s->channels-1)) + cur_chan++; + else { + // decorrelate in case of multiple channels + if (s->channels > 1) { + int32_t *r = p - 1; + for (*p += *r / 2; r > p - s->channels; r--) + *r = *(r + 1) - *r; + } + cur_chan = 0; + i++; + // check for last frame + if (i == s->last_frame_length && get_bits_left(&gb) / 8 == 4) { + frame->nb_samples = framelen = s->last_frame_length; + break; + } + } + } + + align_get_bits(&gb); + if (get_bits_left(&gb) < 32) { + ret = AVERROR_INVALIDDATA; + goto error; + } + skip_bits_long(&gb, 32); // frame crc + + // convert to output buffer + switch (s->bps) { + case 1: { + uint8_t *samples = (uint8_t *)frame->data[0]; + for (p = s->decode_buffer; p < s->decode_buffer + (framelen * s->channels); p++) + *samples++ = *p + 0x80; + break; + } + case 2: { + int16_t *samples = (int16_t *)frame->data[0]; + for (p = s->decode_buffer; p < s->decode_buffer + (framelen * s->channels); p++) + *samples++ = *p; + break; + } + case 3: { + // shift samples for 24-bit sample format + int32_t *samples = (int32_t *)frame->data[0]; + for (i = 0; i < framelen * s->channels; i++) + *samples++ <<= 8; + // reset decode buffer + s->decode_buffer = NULL; + break; + } + } + + *got_frame_ptr = 1; + + return buf_size; +error: + // reset decode buffer + if (s->bps == 3) + s->decode_buffer = NULL; + return ret; +} + +static int init_thread_copy(AVCodecContext *avctx) +{ + TTAContext *s = avctx->priv_data; + s->avctx = avctx; + return allocate_buffers(avctx); +} + +static av_cold int tta_decode_close(AVCodecContext *avctx) { + TTAContext *s = avctx->priv_data; + + if (s->bps < 3) + av_free(s->decode_buffer); + s->decode_buffer = NULL; + av_freep(&s->ch_ctx); + + return 0; +} + +#define OFFSET(x) offsetof(TTAContext, x) +#define DEC (AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM) +static const AVOption options[] = { + { "password", "Set decoding password", OFFSET(pass), AV_OPT_TYPE_STRING, { .str = NULL }, 0, 0, DEC }, + { NULL }, +}; + +static const AVClass tta_decoder_class = { + .class_name = "TTA Decoder", + .item_name = av_default_item_name, + .option = options, + .version = LIBAVUTIL_VERSION_INT, +}; + +AVCodec ff_tta_decoder = { + .name = "tta", + .long_name = NULL_IF_CONFIG_SMALL("TTA (True Audio)"), + .type = AVMEDIA_TYPE_AUDIO, + .id = AV_CODEC_ID_TTA, + .priv_data_size = sizeof(TTAContext), + .init = tta_decode_init, + .close = tta_decode_close, + .decode = tta_decode_frame, + .init_thread_copy = ONLY_IF_THREADS_ENABLED(init_thread_copy), + .capabilities = CODEC_CAP_DR1 | CODEC_CAP_FRAME_THREADS, + .priv_class = &tta_decoder_class, +}; diff --git a/Frameworks/FFMPEG/ffmpeg-minimal/libavcodec/ttadata.c b/Frameworks/FFMPEG/ffmpeg-minimal/libavcodec/ttadata.c new file mode 100644 index 000000000..bf793a4cc --- /dev/null +++ b/Frameworks/FFMPEG/ffmpeg-minimal/libavcodec/ttadata.c @@ -0,0 +1,52 @@ +/* + * TTA (The Lossless True Audio) data + * + * This file is part of FFmpeg. + * + * FFmpeg is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * FFmpeg is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with FFmpeg; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#include "ttadata.h" + +const uint32_t ff_tta_shift_1[] = { + 0x00000001, 0x00000002, 0x00000004, 0x00000008, + 0x00000010, 0x00000020, 0x00000040, 0x00000080, + 0x00000100, 0x00000200, 0x00000400, 0x00000800, + 0x00001000, 0x00002000, 0x00004000, 0x00008000, + 0x00010000, 0x00020000, 0x00040000, 0x00080000, + 0x00100000, 0x00200000, 0x00400000, 0x00800000, + 0x01000000, 0x02000000, 0x04000000, 0x08000000, + 0x10000000, 0x20000000, 0x40000000, 0x80000000, + 0x80000000, 0x80000000, 0x80000000, 0x80000000, + 0x80000000, 0x80000000, 0x80000000, 0x80000000 +}; + +const uint32_t * const ff_tta_shift_16 = ff_tta_shift_1 + 4; + +const uint8_t ff_tta_filter_configs[] = { 10, 9, 10, 12 }; + +void ff_tta_rice_init(TTARice *c, uint32_t k0, uint32_t k1) +{ + c->k0 = k0; + c->k1 = k1; + c->sum0 = ff_tta_shift_16[k0]; + c->sum1 = ff_tta_shift_16[k1]; +} + +void ff_tta_filter_init(TTAFilter *c, int32_t shift) { + memset(c, 0, sizeof(TTAFilter)); + c->shift = shift; + c->round = ff_tta_shift_1[shift-1]; +} diff --git a/Frameworks/FFMPEG/ffmpeg-minimal/libavcodec/ttadata.h b/Frameworks/FFMPEG/ffmpeg-minimal/libavcodec/ttadata.h new file mode 100644 index 000000000..48c4cd035 --- /dev/null +++ b/Frameworks/FFMPEG/ffmpeg-minimal/libavcodec/ttadata.h @@ -0,0 +1,50 @@ +/* + * TTA (The Lossless True Audio) data + * + * This file is part of FFmpeg. + * + * FFmpeg is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * FFmpeg is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with FFmpeg; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#ifndef AVCODEC_TTADATA_H +#define AVCODEC_TTADATA_H + +#include "internal.h" + +#define MAX_ORDER 16 +typedef struct TTAFilter { + int32_t shift, round, error; + int32_t qm[MAX_ORDER]; + int32_t dx[MAX_ORDER]; + int32_t dl[MAX_ORDER]; +} TTAFilter; + +typedef struct TTARice { + uint32_t k0, k1, sum0, sum1; +} TTARice; + +typedef struct TTAChannel { + int32_t predictor; + TTAFilter filter; + TTARice rice; +} TTAChannel; + +extern const uint32_t ff_tta_shift_1[]; +extern const uint32_t * const ff_tta_shift_16; +extern const uint8_t ff_tta_filter_configs[]; + +void ff_tta_rice_init(TTARice *c, uint32_t k0, uint32_t k1); +void ff_tta_filter_init(TTAFilter *c, int32_t shift); +#endif /* AVCODEC_TTADATA_H */ diff --git a/Frameworks/FFMPEG/ffmpeg-minimal/libavformat/tta.c b/Frameworks/FFMPEG/ffmpeg-minimal/libavformat/tta.c new file mode 100644 index 000000000..bbb6a2292 --- /dev/null +++ b/Frameworks/FFMPEG/ffmpeg-minimal/libavformat/tta.c @@ -0,0 +1,193 @@ +/* + * TTA demuxer + * Copyright (c) 2006 Alex Beregszaszi + * + * This file is part of FFmpeg. + * + * FFmpeg is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * FFmpeg is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with FFmpeg; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#include "libavcodec/get_bits.h" +#include "apetag.h" +#include "avformat.h" +#include "avio_internal.h" +#include "internal.h" +#include "id3v1.h" +#include "libavutil/crc.h" +#include "libavutil/dict.h" + +typedef struct { + int totalframes, currentframe; + int frame_size; + int last_frame_size; +} TTAContext; + +static unsigned long tta_check_crc(unsigned long checksum, const uint8_t *buf, + unsigned int len) +{ + return av_crc(av_crc_get_table(AV_CRC_32_IEEE_LE), checksum, buf, len); +} + +static int tta_probe(AVProbeData *p) +{ + if (AV_RL32(&p->buf[0]) == MKTAG('T', 'T', 'A', '1') && + (AV_RL16(&p->buf[4]) == 1 || AV_RL16(&p->buf[4]) == 2) && + AV_RL16(&p->buf[6]) > 0 && + AV_RL16(&p->buf[8]) > 0 && + AV_RL32(&p->buf[10]) > 0) + return AVPROBE_SCORE_EXTENSION + 30; + return 0; +} + +static int tta_read_header(AVFormatContext *s) +{ + TTAContext *c = s->priv_data; + AVStream *st; + int i, channels, bps, samplerate; + uint64_t framepos, start_offset; + uint32_t nb_samples, crc; + + ff_id3v1_read(s); + + start_offset = avio_tell(s->pb); + ffio_init_checksum(s->pb, tta_check_crc, UINT32_MAX); + if (avio_rl32(s->pb) != AV_RL32("TTA1")) + return AVERROR_INVALIDDATA; + + avio_skip(s->pb, 2); // FIXME: flags + channels = avio_rl16(s->pb); + bps = avio_rl16(s->pb); + samplerate = avio_rl32(s->pb); + if(samplerate <= 0 || samplerate > 1000000){ + av_log(s, AV_LOG_ERROR, "nonsense samplerate\n"); + return AVERROR_INVALIDDATA; + } + + nb_samples = avio_rl32(s->pb); + if (!nb_samples) { + av_log(s, AV_LOG_ERROR, "invalid number of samples\n"); + return AVERROR_INVALIDDATA; + } + + crc = ffio_get_checksum(s->pb) ^ UINT32_MAX; + if (crc != avio_rl32(s->pb)) { + av_log(s, AV_LOG_ERROR, "Header CRC error\n"); + return AVERROR_INVALIDDATA; + } + + c->frame_size = samplerate * 256 / 245; + c->last_frame_size = nb_samples % c->frame_size; + if (!c->last_frame_size) + c->last_frame_size = c->frame_size; + c->totalframes = nb_samples / c->frame_size + (c->last_frame_size < c->frame_size); + c->currentframe = 0; + + if(c->totalframes >= UINT_MAX/sizeof(uint32_t) || c->totalframes <= 0){ + av_log(s, AV_LOG_ERROR, "totalframes %d invalid\n", c->totalframes); + return AVERROR_INVALIDDATA; + } + + st = avformat_new_stream(s, NULL); + if (!st) + return AVERROR(ENOMEM); + + avpriv_set_pts_info(st, 64, 1, samplerate); + st->start_time = 0; + st->duration = nb_samples; + + framepos = avio_tell(s->pb) + 4*c->totalframes + 4; + + st->codec->extradata_size = avio_tell(s->pb) - start_offset; + st->codec->extradata = av_mallocz(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE); + if (!st->codec->extradata) { + st->codec->extradata_size = 0; + return AVERROR(ENOMEM); + } + + avio_seek(s->pb, start_offset, SEEK_SET); + avio_read(s->pb, st->codec->extradata, st->codec->extradata_size); + + ffio_init_checksum(s->pb, tta_check_crc, UINT32_MAX); + for (i = 0; i < c->totalframes; i++) { + uint32_t size = avio_rl32(s->pb); + av_add_index_entry(st, framepos, i * c->frame_size, size, 0, + AVINDEX_KEYFRAME); + framepos += size; + } + crc = ffio_get_checksum(s->pb) ^ UINT32_MAX; + if (crc != avio_rl32(s->pb)) { + av_log(s, AV_LOG_ERROR, "Seek table CRC error\n"); + return AVERROR_INVALIDDATA; + } + + st->codec->codec_type = AVMEDIA_TYPE_AUDIO; + st->codec->codec_id = AV_CODEC_ID_TTA; + st->codec->channels = channels; + st->codec->sample_rate = samplerate; + st->codec->bits_per_coded_sample = bps; + + if (s->pb->seekable) { + int64_t pos = avio_tell(s->pb); + ff_ape_parse_tag(s); + avio_seek(s->pb, pos, SEEK_SET); + } + + return 0; +} + +static int tta_read_packet(AVFormatContext *s, AVPacket *pkt) +{ + TTAContext *c = s->priv_data; + AVStream *st = s->streams[0]; + int size, ret; + + // FIXME! + if (c->currentframe >= c->totalframes) + return AVERROR_EOF; + + size = st->index_entries[c->currentframe].size; + + ret = av_get_packet(s->pb, pkt, size); + pkt->dts = st->index_entries[c->currentframe++].timestamp; + pkt->duration = c->currentframe == c->totalframes ? c->last_frame_size : + c->frame_size; + return ret; +} + +static int tta_read_seek(AVFormatContext *s, int stream_index, int64_t timestamp, int flags) +{ + TTAContext *c = s->priv_data; + AVStream *st = s->streams[stream_index]; + int index = av_index_search_timestamp(st, timestamp, flags); + if (index < 0) + return -1; + if (avio_seek(s->pb, st->index_entries[index].pos, SEEK_SET) < 0) + return -1; + + c->currentframe = index; + + return 0; +} + +AVInputFormat ff_tta_demuxer = { + .name = "tta", + .long_name = NULL_IF_CONFIG_SMALL("TTA (True Audio)"), + .priv_data_size = sizeof(TTAContext), + .read_probe = tta_probe, + .read_header = tta_read_header, + .read_packet = tta_read_packet, + .read_seek = tta_read_seek, + .extensions = "tta", +}; diff --git a/Plugins/FFMPEG/FFMPEGDecoder.m b/Plugins/FFMPEG/FFMPEGDecoder.m index 3fa214637..94475ad78 100644 --- a/Plugins/FFMPEG/FFMPEGDecoder.m +++ b/Plugins/FFMPEG/FFMPEGDecoder.m @@ -310,12 +310,12 @@ int lockmgr_callback(void ** mutex, enum AVLockOp op) + (NSArray *)fileTypes { - return [NSArray arrayWithObjects:@"wma", @"asf", @"xwma", @"tak", @"mp3", @"mp2", @"m2a", @"mpa", @"ape", @"ac3", @"dts", @"dtshd", @"at3", @"wav", nil]; + return [NSArray arrayWithObjects:@"wma", @"asf", @"xwma", @"tak", @"mp3", @"mp2", @"m2a", @"mpa", @"ape", @"ac3", @"dts", @"dtshd", @"at3", @"wav", @"tta", nil]; } + (NSArray *)mimeTypes { - return [NSArray arrayWithObjects:@"application/wma", @"application/x-wma", @"audio/x-wma", @"audio/x-ms-wma", @"audio/x-tak", @"audio/mpeg", @"audio/x-mp3", @"audio/x-mp2", @"audio/x-ape", @"audio/x-ac3", @"audio/x-dts", @"audio/x-dtshd", @"audio/x-at3", @"audio/wav", nil]; + return [NSArray arrayWithObjects:@"application/wma", @"application/x-wma", @"audio/x-wma", @"audio/x-ms-wma", @"audio/x-tak", @"audio/mpeg", @"audio/x-mp3", @"audio/x-mp2", @"audio/x-ape", @"audio/x-ac3", @"audio/x-dts", @"audio/x-dtshd", @"audio/x-at3", @"audio/wav", @"tta", nil]; } diff --git a/Plugins/TagLib/TagLibMetadataReader.m b/Plugins/TagLib/TagLibMetadataReader.m index b84ff817e..929c90a5c 100644 --- a/Plugins/TagLib/TagLibMetadataReader.m +++ b/Plugins/TagLib/TagLibMetadataReader.m @@ -130,12 +130,12 @@ + (NSArray *)fileTypes { //May be a way to get a list of supported formats - return [NSArray arrayWithObjects:@"ape", @"asf", @"wma", @"ogg", @"opus", @"mpc", @"flac", @"m4a", @"mp3", @"tak", @"ac3", @"apl", @"dts", @"dtshd", nil]; + return [NSArray arrayWithObjects:@"ape", @"asf", @"wma", @"ogg", @"opus", @"mpc", @"flac", @"m4a", @"mp3", @"tak", @"ac3", @"apl", @"dts", @"dtshd", @"tta", nil]; } + (NSArray *)mimeTypes { - return [NSArray arrayWithObjects:@"audio/x-ape", @"audio/x-ms-wma", @"application/ogg", @"application/x-ogg", @"audio/x-vorbis+ogg", @"audio/x-musepack", @"audio/x-flac", @"audio/x-m4a", @"audio/mpeg", @"audio/x-mp3", @"audio/x-tak", @"audio/x-ac3", @"audio/x-apl", @"audio/x-dts", @"audio/x-dtshd", nil]; + return [NSArray arrayWithObjects:@"audio/x-ape", @"audio/x-ms-wma", @"application/ogg", @"application/x-ogg", @"audio/x-vorbis+ogg", @"audio/x-musepack", @"audio/x-flac", @"audio/x-m4a", @"audio/mpeg", @"audio/x-mp3", @"audio/x-tak", @"audio/x-ac3", @"audio/x-apl", @"audio/x-dts", @"audio/x-dtshd", @"audio/x-tta", nil]; } @end