Request 2245 (accepted)

Overview

Request 2245 (accepted)

Update to stable (0.1.0) version and switched to shared library.

Created by Aloysius over 8 years ago
In state accepted

Submit dcadec

Submit package home:Aloysius:branches:Essentials / dcadec to package Essentials / dcadec

dcadec.changes Changed

dcadec.spec Changed

@@ -15,19 +15,20 @@
 # Please submit bugfixes or comments via http://bugs.links2linux.org/
 #
 
-
+%define libmaj  0
 Name:           dcadec
-Version:        20151114.57012a4
+Version:        0.1.0
 Release:        0
 Summary:        DTS Coherent Acoustics decoder with support for HD extensions
 License:        LGPL-2.1
 Group:          Productivity/Multimedia/Video/Editors and Convertors
 Url:            https://github.com/foo86/dcadec
-Source0:        %{name}-%{version}.tar.xz
+Source0:        https://github.com/foo86/dcadec/archive/v%{version}.tar.gz#/%{name}-%{version}.tar.gz
 BuildRequires:  make
 BuildRequires:  pkg-config
 BuildRequires:  xz
 BuildRoot:      %{_tmppath}/%{name}-%{version}-build
+Requires:       lib%{name}%{libmaj} = %{version}
 
 %description
 Free DTS Coherent Acoustics decoder with support for HD extensions.
@@ -44,9 +45,17 @@
     Decoding of DTS Express streams
     Applying dynamic range compression and dialog normalization
 
+%package     -n lib%{name}%{libmaj}
+Summary:        Shared library for dcadec
+Group:          System/Libraries
+
+%description -n lib%{name}%{libmaj}
+DTS Coherent Acoustics decoder with support for HD extensions
+
 %package     -n lib%{name}-devel
 Summary:        Header files and static library for lib%{name}
 Group:          Development/Libraries/C and C++
+Requires:       lib%{name}%{libmaj} = %{version}
 
 %description -n lib%{name}-devel
 DTS Coherent Acoustics decoder with support for HD extensions
@@ -56,21 +65,29 @@
 
 %build
 export CFLAGS="-fPIC %{optflags}"
-make %{?_smp_mflags}
+make CONFIG_SHARED=1 %{?_smp_mflags}
 
 %install
-make PREFIX=%{_prefix} LIBDIR=%{_libdir} DESTDIR=%{buildroot} install %{?_smp_mflags}
+make CONFIG_SHARED=1 PREFIX=%{_prefix} LIBDIR=%{_libdir} DESTDIR=%{buildroot} install %{?_smp_mflags}
+
+%post   -n lib%{name}%{libmaj} -p /sbin/ldconfig
+%postun -n lib%{name}%{libmaj} -p /sbin/ldconfig
 
 %files
 %defattr(-,root,root)
 %doc COPYING.LGPLv2.1 README.md
 %{_bindir}/%{name}
 
+%files -n lib%{name}%{libmaj}
+%defattr(-,root,root)
+%doc COPYING.LGPLv2.1 README.md
+%{_libdir}/lib%{name}.so.0.0.0
+
 %files -n lib%{name}-devel
 %defattr(-,root,root)
 %doc COPYING.LGPLv2.1 README.md
 %{_includedir}/lib%{name}/
+%{_libdir}/lib%{name}.so
 %{_libdir}/pkgconfig/%{name}.pc
-%{_libdir}/lib%{name}.a
 
 %changelog

dcadec-0.1.0.tar.gz/.gitignore Added

dcadec-0.1.0.tar.gz/.gitmodules Added

dcadec-20151114.57012a4.tar.xz/Makefile -> dcadec-0.1.0.tar.gz/Makefile Changed

@@ -1,4 +1,8 @@
-VERSION = 0.0.0
+VERSION = 0.1.0
+
+API_MAJOR = 0
+API_MINOR = 0
+API_PATCH = 0
 
 CFLAGS := -std=gnu99 -D_FILE_OFFSET_BITS=64 -Wall -Wextra -O3 -ffast-math -g -MMD $(CFLAGS)
 
@@ -24,16 +28,19 @@
     EXESUF ?= .exe
     DLLSUF ?= .dll
     LIBSUF ?= .a
-    LIBS ?=
 else
-    EXESUF ?=
     DLLSUF ?= .so
     LIBSUF ?= .a
     LIBS ?= -lm
+    ifdef CONFIG_SHARED
+        SONAMESUF ?= .$(API_MAJOR).$(API_MINOR).$(API_PATCH)
+        SONAMESUF_MAJOR ?= .$(API_MAJOR)
+        SONAME ?= libdcadec$(DLLSUF)$(SONAMESUF_MAJOR)
+    endif
 endif
 
 ifdef CONFIG_SHARED
-    OUT_LIB ?= libdcadec/libdcadec$(DLLSUF)
+    OUT_LIB ?= libdcadec/libdcadec$(DLLSUF)$(SONAMESUF)
 else
     OUT_LIB ?= libdcadec/libdcadec$(LIBSUF)
 endif
@@ -110,6 +117,11 @@
         LDFLAGS_DLL += -Wl,--out-implib,$(IMP_LIB)
     else
         CFLAGS_DLL += -fPIC -fvisibility=hidden
+        ifdef SONAME
+            LDFLAGS_DLL += -Wl,-soname,$(SONAME)
+            EXTRA_LIB += libdcadec/libdcadec$(DLLSUF)
+            EXTRA_LIB += libdcadec/libdcadec$(DLLSUF)$(SONAMESUF_MAJOR)
+        endif
         IMP_LIB = -Llibdcadec -ldcadec
     endif
 
@@ -118,6 +130,10 @@
 
 $(OUT_LIB): $(OBJ_LIB)
 	$(CC) $(LDFLAGS_DLL) -o $@ $(OBJ_LIB) $(LIBS)
+ifdef SONAME
+	ln -sf $(@F) libdcadec/libdcadec$(DLLSUF)
+	ln -sf $(@F) libdcadec/libdcadec$(DLLSUF)$(SONAMESUF_MAJOR)
+endif
 
 $(OUT_DEC): $(OBJ_DEC) $(OUT_LIB)
 	$(CC) $(LDFLAGS) -o $@ $(OBJ_DEC) $(IMP_LIB) $(LIBS)
@@ -161,6 +177,9 @@
 	install -m 644 $(OUT_LIB) $(DESTDIR)$(LIBDIR)
 	install -m 644 $(addprefix $(SRC_DIR)/, $(INC_LIB)) $(DESTDIR)$(INCLUDEDIR)/libdcadec
 	install -m 644 dcadec.pc $(DESTDIR)$(LIBDIR)/pkgconfig
+ifdef SONAME
+	ln -sf libdcadec$(DLLSUF)$(SONAMESUF) $(DESTDIR)$(LIBDIR)/libdcadec$(DLLSUF)
+endif
 
 install-dec: $(OUT_DEC)
 	install -d -m 755 $(DESTDIR)$(BINDIR)

dcadec-20151114.57012a4.tar.xz/dcadec.c -> dcadec-0.1.0.tar.gz/dcadec.c Changed

@@ -177,6 +177,28 @@
 }
 #endif
 
+static void my_log_cb(int level, const char *file, int line,
+                      const char *message, void *cbarg)
+{
+    (void)cbarg;
+
+    if (level > DCADEC_LOG_WARNING)
+        return;
+
+    const char *prefix = "UNKNOWN";
+
+    switch (level) {
+    case DCADEC_LOG_ERROR:
+        prefix = "ERROR";
+        break;
+    case DCADEC_LOG_WARNING:
+        prefix = "WARNING";
+        break;
+    }
+
+    fprintf(stderr, "%s: %s+%d: %s\n", prefix, file, line, message);
+}
+
 int main(int argc, char **argv)
 {
     int flags = DCADEC_FLAG_STRICT;
@@ -272,6 +294,8 @@
         return 1;
     }
 
+    dcadec_context_set_log_cb(context, my_log_cb, NULL);
+
     if ((ret = dcadec_context_parse(context, packet, size)) < 0) {
         fprintf(stderr, "Error parsing packet: %s\n", dcadec_strerror(ret));
         dcadec_context_destroy(context);
@@ -364,8 +388,7 @@
             }
 
             if (ret > 0) {
-                if (ntotalframes)
-                    fprintf(stderr, "WARNING: %s at frame %" PRIu64 "\n", dcadec_strerror(ret), ntotalframes);
+                fprintf(stderr, "WARNING: %s at frame %" PRIu64 "\n", dcadec_strerror(ret), ntotalframes);
                 nlossyframes++;
             }
 
@@ -429,8 +452,8 @@
             fprintf(stderr, "Completed.\n");
         if (nskippedframes)
             fprintf(stderr, "*** %" PRIu64 " frames skipped ***\n", nskippedframes);
-        if (nlossyframes > 1)
-            fprintf(stderr, "*** %" PRIu64 " frames possibly not lossless ***\n", nlossyframes);
+        if (nlossyframes)
+            fprintf(stderr, "*** %" PRIu64 " frames not lossless ***\n", nlossyframes);
     }
 
     dcadec_waveout_close(waveout);

dcadec-20151114.57012a4.tar.xz/libdcadec/common.h -> dcadec-0.1.0.tar.gz/libdcadec/common.h Changed

@@ -165,24 +165,28 @@
     return res;
 }
 
-#ifdef _DEBUG
-#define DCA_DEBUG(m) \
-    fprintf(stderr, "%s+%d: %s\n", __FILE__, __LINE__, m)
-#else
-#define DCA_DEBUG(m)
+void dca_format_log(dcadec_log_cb cb, void *cbarg, int level,
+                    const char *file, int line, const char *fmt, ...)
+#ifdef __GNUC__
+    __attribute__((format(printf, 6, 7)))
 #endif
-
-#define enforce3(x, m, e) \
-    do {                        \
-        if (!(x)) {             \
-            DCA_DEBUG(m);       \
-            return -(e);        \
-        }                       \
-    } while (false)
-
-#define enforce(x, m)   enforce3(x, m, DCADEC_EBADDATA)
-#define enforce2(x, m)  enforce3(x, m, DCADEC_ENOSYNC)
-#define require(x, m)   enforce3(x, m, DCADEC_ENOSUP)
+;
+
+#define dca_log(lvl, obj, ...) \
+    do { \
+        if (obj->log_cb) \
+            dca_format_log(obj->log_cb, obj->log_cbarg, DCADEC_LOG_##lvl, \
+                           __FILE__, __LINE__, __VA_ARGS__); \
+    } while (0)
+
+#define dca_log_once(lvl, obj, flag, ...) \
+    do { \
+        if (obj->log_cb && !obj->flag) { \
+            dca_format_log(obj->log_cb, obj->log_cbarg, DCADEC_LOG_##lvl, \
+                           __FILE__, __LINE__, __VA_ARGS__); \
+            obj->flag = true; \
+        } \
+    } while (0)
 
 #define DCADEC_FLAG_KEEP_DMIX_MASK  \
     (DCADEC_FLAG_KEEP_DMIX_2CH | DCADEC_FLAG_KEEP_DMIX_6CH)

dcadec-20151114.57012a4.tar.xz/libdcadec/core_decoder.c -> dcadec-0.1.0.tar.gz/libdcadec/core_decoder.c Changed

@@ -93,35 +93,52 @@
 static int parse_frame_header(struct core_decoder *core)
 {
     // Frame type
-    core->normal_frame = bits_get1(&core->bits);
+    bool normal_frame = bits_get1(&core->bits);
 
     // Deficit sample count
-    core->deficit_samples = bits_get(&core->bits, 5) + 1;
-    enforce(core->deficit_samples == 32 || core->normal_frame == false,
-            "Invalid deficit sample count");
+    int deficit_samples = bits_get(&core->bits, 5) + 1;
+    if (deficit_samples < NUM_PCMBLOCK_SAMPLES && normal_frame) {
+        core_err("Invalid deficit sample count");
+        return -DCADEC_EBADDATA;
+    }
 
     // CRC present flag
     core->crc_present = bits_get1(&core->bits);
 
     // Number of PCM sample blocks
     core->npcmblocks = bits_get(&core->bits, 7) + 1;
-    enforce(core->npcmblocks >= 8, "Invalid number of PCM sample blocks");
+    if (core->npcmblocks & (NUM_SUBBAND_SAMPLES - 1)) {
+        core_err("Invalid number of PCM sample blocks (%d)", core->npcmblocks);
+        return (core->npcmblocks < 6 || normal_frame) ? -DCADEC_EBADDATA : -DCADEC_ENOSUP;
+    }
 
     // Primary frame byte size
     core->frame_size = bits_get(&core->bits, 14) + 1;
-    enforce(core->frame_size >= 96, "Invalid frame size");
+    if (core->frame_size < 96) {
+        core_err("Invalid frame size");
+        return -DCADEC_EBADDATA;
+    }
 
     // Audio channel arrangement
     core->audio_mode = bits_get(&core->bits, 6);
-    require(core->audio_mode < AMODE_COUNT, "Unsupported audio channel arrangement");
+    if (core->audio_mode >= AMODE_COUNT) {
+        core_err("Unsupported audio channel arrangement (%d)", core->audio_mode);
+        return -DCADEC_ENOSUP;
+    }
 
     // Core audio sampling frequency
     core->sample_rate = sample_rates[bits_get(&core->bits, 4)];
-    enforce(core->sample_rate != 0, "Invalid core audio sampling frequency");
+    if (!core->sample_rate) {
+        core_err("Invalid core audio sampling frequency");
+        return -DCADEC_EBADDATA;
+    }
 
     // Transmission bit rate
     core->bit_rate = bit_rates[bits_get(&core->bits, 5)];
-    enforce(core->bit_rate != -1, "Invalid transmission bit rate");
+    if (core->bit_rate == -1) {
+        core_err("Invalid transmission bit rate");
+        return -DCADEC_EBADDATA;
+    }
 
     // Reserved field
     bits_skip1(&core->bits);
@@ -149,7 +166,10 @@
 
     // Low frequency effects flag
     core->lfe_present = bits_get(&core->bits, 2);
-    enforce(core->lfe_present < 3, "Invalid low frequency effects flag");
+    if (core->lfe_present == 3) {
+        core_err("Invalid low frequency effects flag");
+        return -DCADEC_EBADDATA;
+    }
 
     // Predictor history flag switch
     core->predictor_history = bits_get1(&core->bits);
@@ -170,7 +190,10 @@
     // Source PCM resolution
     int pcmr_index = bits_get(&core->bits, 3);
     core->source_pcm_res = sample_res[pcmr_index];
-    enforce(core->source_pcm_res != 0, "Invalid source PCM resolution");
+    if (!core->source_pcm_res) {
+        core_err("Invalid source PCM resolution");
+        return -DCADEC_EBADDATA;
+    }
     core->es_format = !!(pcmr_index & 1);
 
     // Front sum/difference flag
@@ -200,8 +223,11 @@
 
         // Number of primary audio channels
         core->nchannels = bits_get(&core->bits, 3) + 1;
-        enforce(core->nchannels == audio_mode_nch[core->audio_mode],
-                "Invalid number of primary audio channels");
+        if (core->nchannels != audio_mode_nch[core->audio_mode]) {
+            core_err("Invalid number of primary audio channels (%d) for audio "
+                     "channel arrangement (%d)", core->nchannels, core->audio_mode);
+            return -DCADEC_EBADDATA;
+        }
         assert(core->nchannels <= MAX_CHANNELS - 2);
 
         core->ch_mask = audio_mode_ch_mask[core->audio_mode];
@@ -224,13 +250,17 @@
         header_size = bits_get(&core->bits, 7) + 1;
 
         // Check CRC
-        if (core->xxch_crc_present)
-            if ((ret = bits_check_crc(&core->bits, header_pos, header_pos + header_size * 8)) < 0)
-                return ret;
+        if (core->xxch_crc_present && (ret = bits_check_crc(&core->bits, header_pos, header_pos + header_size * 8)) < 0) {
+            core_err("Invalid XXCH channel set header checksum");
+            return ret;
+        }
 
         // Number of channels in a channel set
         n = bits_get(&core->bits, 3) + 1;
-        require(n < 3, "Too many XXCH audio channels");
+        if (n > 2) {
+            core_err_once("Unsupported number of XXCH channels (%d)", n);
+            return -DCADEC_ENOSUP;
+        }
         core->nchannels = audio_mode_nch[core->audio_mode] + n;
         assert(core->nchannels <= MAX_CHANNELS);
 
@@ -238,11 +268,16 @@
         unsigned int mask = bits_get(&core->bits, core->xxch_mask_nbits - SPEAKER_Cs);
         core->xxch_spkr_mask = mask << SPEAKER_Cs;
 
-        enforce(dca_popcount(core->xxch_spkr_mask) == n,
-                "Invalid XXCH speaker layout mask");
+        if (dca_popcount(core->xxch_spkr_mask) != n) {
+            core_err("Invalid XXCH speaker layout mask (%#x)", core->xxch_spkr_mask);
+            return -DCADEC_EBADDATA;
+        }
 
-        enforce(!(core->xxch_core_mask & core->xxch_spkr_mask),
-                "XXCH speaker layout mask overlaps with core");
+        if (core->xxch_core_mask & core->xxch_spkr_mask) {
+            core_err("XXCH speaker layout mask (%#x) overlaps with core (%#x)",
+                     core->xxch_spkr_mask, core->xxch_core_mask);
+            return -DCADEC_EBADDATA;
+        }
 
         // Combine core and XXCH masks together
         core->ch_mask = core->xxch_core_mask | core->xxch_spkr_mask;
@@ -258,8 +293,10 @@
             int code = bits_get(&core->bits, 6);
             if (code) {
                 unsigned int index = code * 4 - 44;
-                enforce(index < dca_countof(dmix_table_inv),
-                        "Invalid downmix scale index");
+                if (index >= dca_countof(dmix_table_inv)) {
+                    core_err("Invalid downmix scale index");
+                    return -DCADEC_EBADDATA;
+                }
                 core->dmix_scale_inv = dmix_table_inv[index];
             } else {
                 core->dmix_scale_inv = 0;
@@ -278,8 +315,10 @@
                         int sign = (code >> 6) - 1; code &= 63;
                         if (code) {
                             unsigned int index = code * 4 - 4;
-                            enforce(index < dca_countof(dmix_table),
-                                    "Invalid downmix coefficient index");
+                            if (index >= dca_countof(dmix_table)) {
+                                core_err("Invalid downmix coefficient index");
+                                return -DCADEC_EBADDATA;
+                            }
                             *coeff_ptr++ = (dmix_table[index] ^ sign) - sign;
                         } else {
                             *coeff_ptr++ = 0;
@@ -297,7 +336,10 @@
     // Subband activity count
     for (ch = xch_base; ch < core->nchannels; ch++) {
         core->nsubbands[ch] = bits_get(&core->bits, 5) + 2;
-        enforce(core->nsubbands[ch] <= MAX_SUBBANDS, "Invalid subband activity count");
+        if (core->nsubbands[ch] > MAX_SUBBANDS) {
+            core_err("Invalid subband activity count");
+            return -DCADEC_EBADDATA;
+        }
     }
 
     // High frequency VQ start subband
@@ -308,7 +350,10 @@
     for (ch = xch_base; ch < core->nchannels; ch++) {
         if ((n = bits_get(&core->bits, 3)) && header == HEADER_XXCH)
             n += xch_base - 1;
-        enforce(n <= core->nchannels, "Invalid joint intensity coding index");
+        if (n > core->nchannels) {
+            core_err("Invalid joint intensity coding index");
+            return -DCADEC_EBADDATA;
+        }
         core->joint_intensity_index[ch] = n;
     }
 
@@ -319,13 +364,19 @@
     // Scale factor code book
     for (ch = xch_base; ch < core->nchannels; ch++) {
         core->scale_factor_sel[ch] = bits_get(&core->bits, 3);
-        enforce(core->scale_factor_sel[ch] < 7, "Invalid scale factor code book");
+        if (core->scale_factor_sel[ch] == 7) {
+            core_err("Invalid scale factor code book");
+            return -DCADEC_EBADDATA;
+        }
     }
 
     // Bit allocation quantizer select
     for (ch = xch_base; ch < core->nchannels; ch++) {
         core->bit_allocation_sel[ch] = bits_get(&core->bits, 3);
-        enforce(core->bit_allocation_sel[ch] < 7, "Invalid bit allocation quantizer select");
+        if (core->bit_allocation_sel[ch] == 7) {
+            core_err("Invalid bit allocation quantizer select");
+            return -DCADEC_EBADDATA;
+        }
     }
 
     // Quantization index codebook select
@@ -343,8 +394,10 @@
         // Reserved
         // Byte align
         // CRC16 of channel set header
-        if ((ret = bits_seek(&core->bits, header_pos + header_size * 8)) < 0)
+        if ((ret = bits_seek(&core->bits, header_pos + header_size * 8)) < 0) {
+            core_err("Read past end of XXCH channel set header");
             return ret;
+        }
     } else {
         // Audio header CRC check word
         if (core->crc_present)
@@ -374,7 +427,11 @@
         *scale_index = bits_get(&core->bits, sel + 1);
 
     // Look up scale factor from the root square table
-    enforce((unsigned int)*scale_index < scale_size, "Invalid scale factor index");
+    if ((unsigned int)*scale_index >= scale_size) {
+        core_err("Invalid scale factor index");
+        return -DCADEC_EBADDATA;
+    }
+
     return scale_table[*scale_index];
 }
 
@@ -390,7 +447,12 @@
     // Bias by 64
     scale_index += 64;
 
-    enforce((unsigned int)scale_index < dca_countof(joint_scale_factors), "Invalid joint scale factor index");
+    // Look up joint scale factor
+    if ((unsigned int)scale_index >= dca_countof(joint_scale_factors)) {
+        core_err("Invalid joint scale factor index");
+        return -DCADEC_EBADDATA;
+    }
+
     return joint_scale_factors[scale_index];
 }
 
@@ -429,7 +491,10 @@
                 abits = bits_get_unsigned_vlc(&core->bits, &bit_allocation_huff[sel]) + 1;
             else
                 abits = bits_get(&core->bits, sel - 1);
-            enforce(abits < 27, "Invalid bit allocation index");
+            if (abits >= 27) {
+                core_err("Invalid bit allocation index");
+                return -DCADEC_EBADDATA;
+            }
             core->bit_allocation[ch][band] = abits;
         }
     }
@@ -449,7 +514,10 @@
                     int sel = core->transition_mode_sel[ch];
                     const struct huffman *huff = &transition_mode_huff[sel];
                     int trans_ssf = bits_get_unsigned_vlc(&core->bits, huff);
-                    enforce(trans_ssf < 4, "Invalid transition mode index");
+                    if (trans_ssf >= 4) {
+                        core_err("Invalid transition mode index");
+                        return -DCADEC_EBADDATA;
+                    }
                     core->transition_mode[sf][ch][band] = trans_ssf;
                 }
             }
@@ -497,7 +565,10 @@
         // Only if joint subband coding is enabled
         if (core->joint_intensity_index[ch]) {
             core->joint_scale_sel[ch] = bits_get(&core->bits, 3);
-            enforce(core->joint_scale_sel[ch] < 7, "Invalid joint scale factor code book");
+            if (core->joint_scale_sel[ch] == 7) {
+                core_err("Invalid joint scale factor code book");
+                return -DCADEC_EBADDATA;
+            }
         }
     }
 
@@ -542,7 +613,11 @@
         code /= levels;
     }
 
-    enforce(code == 0, "Failed to decode block code");
+    if (code) {
+        core_err("Failed to decode block code");
+        return -DCADEC_EBADDATA;
+    }
+
     return 0;
 }
 
@@ -599,8 +674,10 @@
         memset(audio, 0, NUM_SUBBAND_SAMPLES * sizeof(*audio));
         break;
     case HUFFMAN_CODE:
-        if ((ret = bits_get_signed_vlc_array(&core->bits, audio, NUM_SUBBAND_SAMPLES, huff)) < 0)
+        if ((ret = bits_get_signed_vlc_array(&core->bits, audio, NUM_SUBBAND_SAMPLES, huff)) < 0) {
+            core_err("Failed to decode huffman code");
             return ret;
+        }
         break;
     case BLOCK_CODE:
         if ((ret = parse_block_code(core, audio + 0, abits)) < 0)
@@ -662,7 +739,10 @@
 
     // Number of subband samples in this subframe
     int nsamples = core->nsubsubframes[sf] * NUM_SUBBAND_SAMPLES;
-    enforce(*sub_pos + nsamples <= core->npcmblocks, "Subband sample buffer overflow");
+    if (*sub_pos + nsamples > core->npcmblocks) {
+        core_err("Subband sample buffer overflow");
+        return -DCADEC_EBADDATA;
+    }
 
     // VQ encoded subbands
     for (ch = xch_base; ch < core->nchannels; ch++) {
@@ -695,8 +775,10 @@
 
         // Extract scale factor index from the bit stream
         unsigned int scale_index = bits_get(&core->bits, 8);
-        enforce(scale_index < dca_countof(scale_factors_7bit),
-                "Invalid LFE scale factor index");
+        if (scale_index >= dca_countof(scale_factors_7bit)) {
+            core_err("Invalid LFE scale factor index");
+            return -DCADEC_EBADDATA;
+        }
 
         // Look up the 7-bit root square quantization table
         int scale = scale_factors_7bit[scale_index];
@@ -724,8 +806,11 @@
                     return ret;
 
         // DSYNC
-        if (ssf == core->nsubsubframes[sf] - 1 || core->sync_ssf)
-            enforce(bits_get(&core->bits, 16) == 0xffff, "DSYNC check failed");
+        if ((ssf == core->nsubsubframes[sf] - 1 || core->sync_ssf)
+            && bits_get(&core->bits, 16) != 0xffff) {
+            core_err("DSYNC check failed");
+            return -DCADEC_EBADDATA;
+        }
     }
 
     // Inverse ADPCM
@@ -968,7 +1053,8 @@
     // Filter LFE channel
     if (core->lfe_present) {
         // Select LFE DSP
-        interpolate_lfe_t interpolate;
+        interpolate_lfe_cb interpolate;
+
         if (flags & DCADEC_FLAG_CORE_BIT_EXACT)
             interpolate = interpolate_lfe_fixed_fir;
         else if (flags & DCADEC_FLAG_CORE_LFE_FIR)
@@ -1095,7 +1181,10 @@
 
 static int parse_xch_frame(struct core_decoder *core)
 {
-    enforce(!(core->ch_mask & SPEAKER_MASK_Cs), "XCH with Cs speaker already present");
+    if (core->ch_mask & SPEAKER_MASK_Cs) {
+        core_err("XCH with Cs speaker already present");
+        return -DCADEC_EBADDATA;
+    }
 
     int ret;
     if ((ret = parse_frame_data(core, HEADER_XCH, core->nchannels)) < 0)
@@ -1110,7 +1199,10 @@
     size_t header_pos = core->bits.index;
 
     // XXCH sync word
-    enforce2(bits_get(&core->bits, 32) == SYNC_WORD_XXCH, "Invalid XXCH sync word");
+    if (bits_get(&core->bits, 32) != SYNC_WORD_XXCH) {
+        core_err("Invalid XXCH sync word");
+        return -DCADEC_ENOSYNC;
+    }
 
     // XXCH frame header length
     size_t header_size = bits_get(&core->bits, 6) + 1;
@@ -1118,19 +1210,27 @@
 
     // Check XXCH frame header CRC
     int ret;
-    if ((ret = bits_check_crc(&core->bits, header_pos + 32, header_end)) < 0)
+    if ((ret = bits_check_crc(&core->bits, header_pos + 32, header_end)) < 0) {
+        core_err("Invalid XXCH frame header checksum");
         return ret;
+    }
 
     // CRC presence flag for channel set header
     core->xxch_crc_present = bits_get1(&core->bits);
 
     // Number of bits for loudspeaker mask
     core->xxch_mask_nbits = bits_get(&core->bits, 5) + 1;
-    enforce(core->xxch_mask_nbits > SPEAKER_Cs, "Invalid number of bits for XXCH speaker mask");
+    if (core->xxch_mask_nbits <= SPEAKER_Cs) {
+        core_err("Invalid number of bits for XXCH speaker mask (%d)", core->xxch_mask_nbits);
+        return -DCADEC_EBADDATA;
+    }
 
     // Number of channel sets
     int xxch_nchsets = bits_get(&core->bits, 2) + 1;
-    require(xxch_nchsets == 1, "Unsupported number of XXCH channel sets");
+    if (xxch_nchsets > 1) {
+        core_err_once("Unsupported number of XXCH channel sets (%d)", xxch_nchsets);
+        return -DCADEC_ENOSUP;
+    }
 
     // Channel set 0 data byte size
     int xxch_frame_size = bits_get(&core->bits, 14) + 1;
@@ -1147,19 +1247,27 @@
     if ((mask & SPEAKER_MASK_Rs) && (core->xxch_core_mask & SPEAKER_MASK_Rss))
         mask = (mask & ~SPEAKER_MASK_Rs) | SPEAKER_MASK_Rss;
 
-    enforce(mask == core->xxch_core_mask, "Invalid XXCH core speaker activity mask");
+    if (mask != core->xxch_core_mask) {
+        core_err("XXCH core speaker activity mask (%#x) disagrees "
+                 "with core (%#x)", core->xxch_core_mask, mask);
+        return -DCADEC_EBADDATA;
+    }
 
     // Reserved
     // Byte align
     // CRC16 of XXCH frame header
-    if ((ret = bits_seek(&core->bits, header_end)) < 0)
+    if ((ret = bits_seek(&core->bits, header_end)) < 0) {
+        core_err("Read past end of XXCH frame header");
         return ret;
+    }
 
     // Parse XXCH channel set 0
     if ((ret = parse_frame_data(core, HEADER_XXCH, core->nchannels)) < 0)
         return ret;
 
-    return bits_seek(&core->bits, header_end + xxch_frame_size * 8);
+    if ((ret = bits_seek(&core->bits, header_end + xxch_frame_size * 8)) < 0)
+        core_err("Read past end of XXCH channel set");
+    return ret;
 }
 
 static int parse_xbr_subframe(struct core_decoder *core, int xbr_base_ch, int xbr_nchannels,
@@ -1173,7 +1281,10 @@
 
     // Number of subband samples in this subframe
     int nsamples = core->nsubsubframes[sf] * NUM_SUBBAND_SAMPLES;
-    enforce(*sub_pos + nsamples <= core->npcmblocks, "Subband sample buffer overflow");
+    if (*sub_pos + nsamples > core->npcmblocks) {
+        core_err("Subband sample buffer overflow");
+        return -DCADEC_EBADDATA;
+    }
 
     // Number of bits for XBR bit allocation index
     for (ch = xbr_base_ch; ch < xbr_nchannels; ch++)
@@ -1187,7 +1298,10 @@
     // Number of bits for scale indices
     for (ch = xbr_base_ch; ch < xbr_nchannels; ch++) {
         xbr_scale_nbits[ch] = bits_get(&core->bits, 3);
-        enforce(xbr_scale_nbits[ch] > 0, "Invalid number of bits for XBR scale factor index");
+        if (!xbr_scale_nbits[ch]) {
+            core_err("Invalid number of bits for XBR scale factor index");
+            return -DCADEC_EBADDATA;
+        }
     }
 
     // XBR scale factors
@@ -1208,11 +1322,17 @@
         for (band = 0; band < xbr_nsubbands[ch]; band++) {
             if (xbr_bit_allocation[ch][band] > 0) {
                 unsigned int scale_index = bits_get(&core->bits, xbr_scale_nbits[ch]);
-                enforce(scale_index < scale_size, "Invalid XBR scale factor index");
+                if (scale_index >= scale_size) {
+                    core_err("Invalid XBR scale factor index");
+                    return -DCADEC_EBADDATA;
+                }
                 xbr_scale_factors[ch][band][0] = scale_table[scale_index];
                 if (xbr_transition_mode && core->transition_mode[sf][ch][band]) {
                     scale_index = bits_get(&core->bits, xbr_scale_nbits[ch]);
-                    enforce(scale_index < scale_size, "Invalid XBR scale factor index");
+                    if (scale_index >= scale_size) {
+                        core_err("Invalid XBR scale factor index");
+                        return -DCADEC_EBADDATA;
+                    }
                     xbr_scale_factors[ch][band][1] = scale_table[scale_index];
                 }
             }
@@ -1266,8 +1386,11 @@
         }
 
         // DSYNC
-        if (ssf == core->nsubsubframes[sf] - 1 || core->sync_ssf)
-            enforce(bits_get(&core->bits, 16) == 0xffff, "DSYNC check failed");
+        if ((ssf == core->nsubsubframes[sf] - 1 || core->sync_ssf)
+            && bits_get(&core->bits, 16) != 0xffff) {
+            core_err("DSYNC check failed");
+            return -DCADEC_EBADDATA;
+        }
     }
 
     // Advance subband sample pointer for the next subframe
@@ -1284,7 +1407,10 @@
     size_t header_pos = core->bits.index;
 
     // XBR sync word
-    enforce2(bits_get(&core->bits, 32) == SYNC_WORD_XBR, "Invalid XBR sync word");
+    if (bits_get(&core->bits, 32) != SYNC_WORD_XBR) {
+        core_err("Invalid XBR sync word");
+        return -DCADEC_ENOSYNC;
+    }
 
     // XBR frame header length
     size_t header_size = bits_get(&core->bits, 6) + 1;
@@ -1292,8 +1418,10 @@
 
     // Check XBR frame header CRC
     int ret;
-    if ((ret = bits_check_crc(&core->bits, header_pos + 32, header_end)) < 0)
+    if ((ret = bits_check_crc(&core->bits, header_pos + 32, header_end)) < 0) {
+        core_err("Invalid XBR frame header checksum");
         return ret;
+    }
 
     // Number of channel sets
     int xbr_nchsets = bits_get(&core->bits, 2) + 1;
@@ -1311,16 +1439,20 @@
         int xbr_band_nbits = bits_get(&core->bits, 2) + 5;
         for (int ch1 = 0; ch1 < xbr_nchannels[i]; ch1++, ch2++) {
             xbr_nsubbands[ch2] = bits_get(&core->bits, xbr_band_nbits) + 1;
-            enforce(xbr_nsubbands[ch2] <= MAX_SUBBANDS,
-                    "Invalid number of active XBR subbands");
+            if (xbr_nsubbands[ch2] > MAX_SUBBANDS) {
+                core_err("Invalid number of active XBR subbands (%d)", xbr_nsubbands[ch2]);
+                return -DCADEC_EBADDATA;
+            }
         }
     }
 
     // Reserved
     // Byte align
     // CRC16 of XBR frame header
-    if ((ret = bits_seek(&core->bits, header_end)) < 0)
+    if ((ret = bits_seek(&core->bits, header_end)) < 0) {
+        core_err("Read past end of XBR frame header");
         return ret;
+    }
 
     // Channel set data
     int xbr_base_ch = 0;
@@ -1340,8 +1472,10 @@
 
         xbr_base_ch += xbr_nchannels[i];
 
-        if ((ret = bits_seek(&core->bits, header_pos + xbr_frame_size[i] * 8)) < 0)
+        if ((ret = bits_seek(&core->bits, header_pos + xbr_frame_size[i] * 8)) < 0) {
+            core_err("Read past end of XBR channel set");
             return ret;
+        }
     }
 
     return 0;
@@ -1391,7 +1525,10 @@
 
     // Number of subband samples in this subframe
     int nsamples = core->nsubsubframes[sf] * NUM_SUBBAND_SAMPLES;
-    enforce(*sub_pos + nsamples <= core->npcmblocks, "Subband sample buffer overflow");
+    if (*sub_pos + nsamples > core->npcmblocks) {
+        core_err("Subband sample buffer overflow");
+        return -DCADEC_EBADDATA;
+    }
 
     // Number of VQ lookup iterations for this subframe
     int n_ssf_iter = core->nsubsubframes[sf] / 2;
@@ -1450,8 +1587,11 @@
                         return ret;
 
         // DSYNC
-        if (ssf == core->nsubsubframes[sf] - 1 || core->sync_ssf)
-            enforce(bits_get(&core->bits, 16) == 0xffff, "DSYNC check failed");
+        if ((ssf == core->nsubsubframes[sf] - 1 || core->sync_ssf)
+            && bits_get(&core->bits, 16) != 0xffff) {
+            core_err("DSYNC check failed");
+            return -DCADEC_EBADDATA;
+        }
     }
 
     // Inverse ADPCM
@@ -1575,7 +1715,12 @@
                 abits += bits_get_signed_vlc(&core->bits, huff);
             else
                 abits = bits_get(&core->bits, 3 + x96->high_res);
-            enforce((unsigned int)abits <= abits_max, "Invalid bit allocation index");
+
+            if ((unsigned int)abits > abits_max) {
+                core_err("Invalid bit allocation index");
+                return -DCADEC_EBADDATA;
+            }
+
             x96->bit_allocation[ch][band] = abits;
         }
     }
@@ -1599,7 +1744,10 @@
         // Only if joint subband coding is enabled
         if (x96->joint_intensity_index[ch]) {
             x96->joint_scale_sel[ch] = bits_get(&core->bits, 3);
-            enforce(x96->joint_scale_sel[ch] < 7, "Invalid joint scale factor code book");
+            if (x96->joint_scale_sel[ch] == 7) {
+                core_err("Invalid joint scale factor code book");
+                return -DCADEC_EBADDATA;
+            }
         }
     }
 
@@ -1638,9 +1786,10 @@
         header_size = bits_get(&core->bits, 7) + 1;
 
         // Check CRC
-        if (x96->crc_present)
-            if ((ret = bits_check_crc(&core->bits, header_pos, header_pos + header_size * 8)) < 0)
-                return ret;
+        if (x96->crc_present && (ret = bits_check_crc(&core->bits, header_pos, header_pos + header_size * 8)) < 0) {
+            core_err("Invalid X96 channel set header checksum");
+            return ret;
+        }
     }
 
     // High resolution flag
@@ -1649,7 +1798,10 @@
     // First encoded subband
     if (x96->rev_no < 8) {
         x96->subband_start = bits_get(&core->bits, 5);
-        enforce(x96->subband_start <= 27, "Invalid X96 subband start index");
+        if (x96->subband_start > 27) {
+            core_err("Invalid X96 subband start index (%d)", x96->subband_start);
+            return -DCADEC_EBADDATA;
+        }
     } else {
         x96->subband_start = MAX_SUBBANDS;
     }
@@ -1657,21 +1809,30 @@
     // Subband activity count
     for (ch = xch_base; ch < x96->nchannels; ch++) {
         x96->nsubbands[ch] = bits_get(&core->bits, 6) + 1;
-        enforce(x96->nsubbands[ch] >= MAX_SUBBANDS, "Invalid X96 subband activity count");
+        if (x96->nsubbands[ch] < MAX_SUBBANDS) {
+            core_err("Invalid X96 subband activity count (%d)", x96->nsubbands[ch]);
+            return -DCADEC_EBADDATA;
+        }
     }
 
     // Joint intensity coding index
     for (ch = xch_base; ch < x96->nchannels; ch++) {
         if ((n = bits_get(&core->bits, 3)) && xch_base)
             n += xch_base - 1;
-        enforce(n <= x96->nchannels, "Invalid joint intensity coding index");
+        if (n > x96->nchannels) {
+            core_err("Invalid joint intensity coding index");
+            return -DCADEC_EBADDATA;
+        }
         x96->joint_intensity_index[ch] = n;
     }
 
     // Scale factor code book
     for (ch = xch_base; ch < x96->nchannels; ch++) {
         x96->scale_factor_sel[ch] = bits_get(&core->bits, 3);
-        enforce(x96->scale_factor_sel[ch] < 6, "Invalid scale factor code book");
+        if (x96->scale_factor_sel[ch] >= 6) {
+            core_err("Invalid scale factor code book");
+            return -DCADEC_EBADDATA;
+        }
     }
 
     // Bit allocation quantizer select
@@ -1687,8 +1848,10 @@
         // Reserved
         // Byte align
         // CRC16 of channel set header
-        if ((ret = bits_seek(&core->bits, header_pos + header_size * 8)) < 0)
+        if ((ret = bits_seek(&core->bits, header_pos + header_size * 8)) < 0) {
+            core_err("Read past end of X96 channel set header");
             return ret;
+        }
     } else {
         if (core->crc_present)
             bits_skip(&core->bits, 16);
@@ -1741,7 +1904,10 @@
 
     // Revision number
     x96->rev_no = bits_get(&core->bits, 4);
-    require(x96->rev_no >= 1 && x96->rev_no <= 8, "Unsupported X96 revision");
+    if (x96->rev_no < 1 || x96->rev_no > 8) {
+        core_err_once("Unsupported X96 revision (%d)", x96->rev_no);
+        return -DCADEC_ENOSUP;
+    }
 
     x96->crc_present = false;
     x96->nchannels = core->nchannels;
@@ -1766,7 +1932,10 @@
     size_t header_pos = core->bits.index;
 
     // X96 sync word
-    enforce2(bits_get(&core->bits, 32) == SYNC_WORD_X96, "Invalid X96 sync word");
+    if (bits_get(&core->bits, 32) != SYNC_WORD_X96) {
+        core_err("Invalid X96 sync word");
+        return -DCADEC_ENOSYNC;
+    }
 
     // X96 frame header length
     size_t header_size = bits_get(&core->bits, 6) + 1;
@@ -1774,12 +1943,17 @@
 
     // Check X96 frame header CRC
     int ret;
-    if ((ret = bits_check_crc(&core->bits, header_pos + 32, header_end)) < 0)
+    if ((ret = bits_check_crc(&core->bits, header_pos + 32, header_end)) < 0) {
+        core_err("Invalid X96 frame header checksum");
         return ret;
+    }
 
     // Revision number
     x96->rev_no = bits_get(&core->bits, 4);
-    require(x96->rev_no >= 1 && x96->rev_no <= 8, "Unsupported X96 revision");
+    if (x96->rev_no < 1 || x96->rev_no > 8) {
+        core_err_once("Unsupported X96 revision (%d)", x96->rev_no);
+        return -DCADEC_ENOSUP;
+    }
 
     // CRC presence flag for channel set header
     x96->crc_present = bits_get1(&core->bits);
@@ -1798,8 +1972,10 @@
     // Reserved
     // Byte align
     // CRC16 of X96 frame header
-    if ((ret = bits_seek(&core->bits, header_end)) < 0)
+    if ((ret = bits_seek(&core->bits, header_end)) < 0) {
+        core_err("Read past end of X96 frame header");
         return ret;
+    }
 
     if ((ret = alloc_x96_sample_buffer(x96)) < 0)
         return ret;
@@ -1817,8 +1993,10 @@
 
         x96_base_ch += x96_nchannels[i];
 
-        if ((ret = bits_seek(&core->bits, header_pos + x96_frame_size[i] * 8)) < 0)
+        if ((ret = bits_seek(&core->bits, header_pos + x96_frame_size[i] * 8)) < 0) {
+            core_err("Read past end of X96 channel set");
             return ret;
+        }
     }
 
     return 0;
@@ -1856,7 +2034,10 @@
 
     // Auxiliary data sync word
     uint32_t sync = bits_get(&core->bits, 32);
-    enforce2(sync == SYNC_WORD_REV1AUX, "Invalid auxiliary data sync word");
+    if (sync != SYNC_WORD_REV1AUX) {
+        core_err("Invalid auxiliary data sync word (%#x)", sync);
+        return -DCADEC_ENOSYNC;
+    }
 
     // Auxiliary decode time stamp flag
     if (bits_get1(&core->bits)) {
@@ -1873,8 +2054,10 @@
     if (core->prim_dmix_embedded) {
         // Auxiliary primary channel downmix type
         core->prim_dmix_type = bits_get(&core->bits, 3);
-        enforce(core->prim_dmix_type < DMIX_TYPE_COUNT,
-                "Invalid primary channel set downmix type");
+        if (core->prim_dmix_type >= DMIX_TYPE_COUNT) {
+            core_err("Invalid primary channel set downmix type");
+            return -DCADEC_EBADDATA;
+        }
 
         // Size of downmix coefficients matrix
         int m = dmix_primary_nch[core->prim_dmix_type];
@@ -1887,8 +2070,10 @@
             int sign = (code >> 8) - 1; code &= 0xff;
             if (code) {
                 unsigned int index = code - 1;
-                enforce(index < dca_countof(dmix_table),
-                        "Invalid downmix coefficient index");
+                if (index >= dca_countof(dmix_table)) {
+                    core_err("Invalid downmix coefficient index");
+                    return -DCADEC_EBADDATA;
+                }
                 *coeff_ptr++ = (dmix_table[index] ^ sign) - sign;
             } else {
                 *coeff_ptr++ = 0;
@@ -1903,7 +2088,10 @@
     bits_skip(&core->bits, 16);
 
     // Check CRC
-    return bits_check_crc(&core->bits, aux_pos + 32, core->bits.index);
+    int ret;
+    if ((ret = bits_check_crc(&core->bits, aux_pos + 32, core->bits.index)) < 0)
+        core_err("Invalid auxiliary data checksum");
+    return ret;
 }
 
 static int parse_optional_info(struct core_decoder *core, int flags)
@@ -1929,9 +2117,10 @@
 
     // Core extensions
     if (core->ext_audio_present && !(flags & DCADEC_FLAG_CORE_ONLY)) {
-        size_t buf_size = (core->bits.total + 31) / 32;
-        size_t sync_pos = (core->bits.index + 31) / 32;
-        size_t last_pos = DCA_MIN(core->frame_size / 4, buf_size);
+        size_t sync_pos = DCA_MIN(core->frame_size / 4, core->bits.total / 32);
+        size_t last_pos = core->bits.index / 32;
+
+        assert(last_pos);
 
         // Search for extension sync words aligned on 4-byte boundary
         switch (core->ext_audio_type) {
@@ -1944,7 +2133,7 @@
             // compatibility with legacy bitstreams. Minimum XCH frame size is
             // 96 bytes. AMODE and PCHS are further checked to reduce
             // probability of alias sync detection.
-            for (; sync_pos < last_pos; sync_pos++) {
+            for (; sync_pos >= last_pos; sync_pos--) {
                 if (core->bits.data[sync_pos] == DCA_32BE_C(SYNC_WORD_XCH)) {
                     core->bits.index = (sync_pos + 1) * 32;
                     size_t frame_size = bits_get(&core->bits, 10) + 1;
@@ -1959,7 +2148,7 @@
             }
 
             if (!core->xch_pos) {
-                DCA_DEBUG("XCH sync word not found");
+                core_warn("XCH sync word not found");
                 if (flags & DCADEC_FLAG_STRICT)
                     return -DCADEC_ENOSYNC;
                 status = DCADEC_WCOREEXTFAILED;
@@ -1970,7 +2159,7 @@
             // The distance between X96 sync word and end of the core frame
             // must be equal to X96 frame size. Minimum X96 frame size is 96
             // bytes.
-            for (; sync_pos < last_pos; sync_pos++) {
+            for (; sync_pos >= last_pos; sync_pos--) {
                 if (core->bits.data[sync_pos] == DCA_32BE_C(SYNC_WORD_X96)) {
                     core->bits.index = (sync_pos + 1) * 32;
                     size_t frame_size = bits_get(&core->bits, 12) + 1;
@@ -1983,7 +2172,7 @@
             }
 
             if (!core->x96_pos) {
-                DCA_DEBUG("X96 sync word not found");
+                core_warn("X96 sync word not found");
                 if (flags & DCADEC_FLAG_STRICT)
                     return -DCADEC_ENOSYNC;
                 status = DCADEC_WCOREEXTFAILED;
@@ -1996,7 +2185,7 @@
 
             // XXCH frame header CRC must be valid. Minimum XXCH frame header
             // size is 11 bytes.
-            for (; sync_pos < last_pos; sync_pos++) {
+            for (; sync_pos >= last_pos; sync_pos--) {
                 if (core->bits.data[sync_pos] == DCA_32BE_C(SYNC_WORD_XXCH)) {
                     core->bits.index = (sync_pos + 1) * 32;
                     size_t hdr_size = bits_get(&core->bits, 6) + 1;
@@ -2010,12 +2199,17 @@
             }
 
             if (!core->xxch_pos) {
-                DCA_DEBUG("XXCH sync word not found");
+                core_warn("XXCH sync word not found");
                 if (flags & DCADEC_FLAG_STRICT)
                     return -DCADEC_ENOSYNC;
                 status = DCADEC_WCOREEXTFAILED;
             }
             break;
+
+        default:
+            core_warn_once("Stream with unknown extended audio type (%d)",
+                           core->ext_audio_type);
+            break;
         }
     }
 
@@ -2025,17 +2219,13 @@
 int core_parse(struct core_decoder *core, uint8_t *data, size_t size,
                int flags, struct exss_asset *asset)
 {
-    core->ext_audio_mask    = 0;
-
-    core->xch_pos   = 0;
-    core->xxch_pos  = 0;
-    core->x96_pos   = 0;
+    core->ext_audio_mask = 0;
+    core->xch_pos = core->xxch_pos = core->x96_pos = 0;
 
     if (asset) {
         bits_init(&core->bits, data + asset->core_offset, asset->core_size);
         if (bits_get(&core->bits, 32) != SYNC_WORD_CORE_EXSS)
             return -DCADEC_ENOSYNC;
-        size = asset->core_size;
     } else {
         bits_init(&core->bits, data, size);
         bits_skip(&core->bits, 32);
@@ -2052,8 +2242,13 @@
         return ret;
     if (ret > 0)
         status = ret;
-    if (core->frame_size > size)
+
+    // Workaround for DTS in WAV
+    if (!asset && core->frame_size > size && core->frame_size < size + 4) {
+        core_warn_once("Stream with excessive core frame size");
         core->frame_size = size;
+    }
+
     if ((ret = bits_seek(&core->bits, core->frame_size * 8)) < 0)
         return ret;
     return status;
@@ -2219,8 +2414,6 @@
     else
         info->profile = DCADEC_PROFILE_DS;
 
-    info->embedded_stereo = (core->prim_dmix_embedded &&
-                             core->prim_dmix_type == DMIX_TYPE_LoRo);
     info->embedded_6ch = !!(core->ext_audio_mask & (CSS_XXCH | CSS_XCH));
     info->spkr_mask = make_spkr_pair_mask(core->ch_mask);

dcadec-20151114.57012a4.tar.xz/libdcadec/core_decoder.h -> dcadec-0.1.0.tar.gz/libdcadec/core_decoder.h Changed

dcadec-20151114.57012a4.tar.xz/libdcadec/dca_context.c -> dcadec-0.1.0.tar.gz/libdcadec/dca_context.c Changed

@@ -30,6 +30,9 @@
 #define DCADEC_PACKET_RECOVERY  0x200
 
 struct dcadec_context {
+    dcadec_log_cb log_cb;
+    void *log_cbarg;
+
     int flags;
     int packet;
     int status;
@@ -79,6 +82,19 @@
 #define DCADEC_LAYOUT_7POINT1_WIDE  \
     (DCADEC_LAYOUT_7POINT0_WIDE | SPEAKER_MASK_LFE1)
 
+void dca_format_log(dcadec_log_cb cb, void *cbarg, int level,
+                    const char *file, int line, const char *fmt, ...)
+{
+    char buffer[1024];
+    va_list ap;
+
+    va_start(ap, fmt);
+    vsnprintf(buffer, sizeof(buffer), fmt, ap);
+    va_end(ap);
+
+    cb(level, file, line, buffer, cbarg);
+}
+
 static int reorder_samples(struct dcadec_context *dca, int **dca_samples, int dca_mask)
 {
     int nchannels = 0;
@@ -244,12 +260,14 @@
 {
     struct core_decoder *core = dca->core;
 
-    dca->core_residual_valid = false;
-
     // Filter core frame
     int ret;
-    if ((ret = core_filter(core, dca->flags)) < 0)
+    if ((ret = core_filter(core, dca->flags)) < 0) {
+        dca->core_residual_valid = false;
         return ret;
+    }
+
+    dca->core_residual_valid = !!(dca->flags & DCADEC_FLAG_CORE_BIT_EXACT);
 
     // Downmix core channels to Lo/Ro
     if (dca->flags & DCADEC_FLAG_KEEP_DMIX_2CH) {
@@ -297,13 +315,9 @@
     return -1;
 }
 
-static struct xll_chset *find_first_hier_dmix_chset(struct xll_decoder *xll)
+static bool is_hier_dmix_chset(struct xll_chset *c)
 {
-    for_each_chset(xll, c)
-        if (!c->primary_chset && c->dmix_embedded && c->hier_chset)
-            return c;
-
-    return NULL;
+    return !c->primary_chset && c->dmix_embedded && c->hier_chset;
 }
 
 static struct xll_chset *find_next_hier_dmix_chset(struct xll_chset *c)
@@ -312,113 +326,102 @@
 
     if (c->hier_chset)
         while (++c < &xll->chset[xll->nchsets])
-            if (!c->primary_chset && c->dmix_embedded && c->hier_chset)
+            if (is_hier_dmix_chset(c))
                 return c;
 
     return NULL;
 }
 
+static void prescale_down_mix(struct xll_chset *c, struct xll_chset *o)
+{
+    int *coeff_ptr = c->dmix_coeff_cur;
+    for (int i = 0; i < c->dmix_m; i++) {
+        int scale = o->dmix_scale_cur[i];
+        int scale_inv = o->dmix_scale_inv_cur[i];
+        c->dmix_scale_cur[i] = mul15(c->dmix_scale_cur[i], scale);
+        c->dmix_scale_inv_cur[i] = mul16(c->dmix_scale_inv_cur[i], scale_inv);
+        for (int j = 0; j < c->nchannels; j++) {
+            int coeff = mul16(*coeff_ptr, scale_inv);
+            *coeff_ptr++ = mul15(coeff, o->dmix_scale_cur[c->dmix_m + j]);
+        }
+    }
+}
+
 struct downmix {
-    int *samples[XLL_MAX_BANDS][XLL_MAX_CHSETS * XLL_MAX_CHANNELS];
-    int *deci_history[XLL_MAX_CHSETS * XLL_MAX_CHANNELS];
+    int *samples[XLL_MAX_BANDS][SPEAKER_COUNT];
+    int *deci_history[SPEAKER_COUNT];
 };
 
-static void undo_down_mix(struct xll_chset *c, struct downmix *dmix)
+static void undo_down_mix(struct xll_chset *c, struct downmix *dmix, int band)
 {
     struct xll_decoder *xll = c->decoder;
     int nsamples = xll->nframesamples;
+    int nsamples_log2 = xll->nframesamples_log2;
 
-    // Pre-scale by next channel set in hierarchy
-    struct xll_chset *o = find_next_hier_dmix_chset(c);
-    if (o) {
-        int *coeff_ptr = c->dmix_coeff;
-        for (int i = 0; i < c->dmix_m; i++) {
-            int scale_inv = o->dmix_scale_inv[i];
-            for (int j = 0; j < c->nchannels; j++) {
-                int coeff = mul16(*coeff_ptr, scale_inv);
-                *coeff_ptr++ = mul15(coeff, o->dmix_scale[c->dmix_m + j]);
-            }
-        }
-    }
+    if (!c->band_dmix_embedded[band])
+        return;
 
-    // Undo downmix of preceding channels in frequency band 0
-    int *coeff_ptr = c->dmix_coeff;
     for (int i = 0; i < c->dmix_m; i++) {
         for (int j = 0; j < c->nchannels; j++) {
-            int coeff = *coeff_ptr++;
-            if (coeff) {
-                int *src = c->msb_sample_buffer[XLL_BAND_0][j];
-                int *dst = dmix->samples[XLL_BAND_0][i];
+            int coeff_cur = c->dmix_coeff_cur[i * c->nchannels + j];
+            int coeff_pre = c->dmix_coeff_pre[i * c->nchannels + j];
+            int delta = coeff_cur - coeff_pre;
+
+            // Undo downmix of channel samples
+            int *src = c->msb_sample_buffer[band][j];
+            int *dst = dmix->samples[band][i];
+
+            if (delta) {
+                // Downmix coefficient interpolation
+                int ramp = 1 << (nsamples_log2 - 1);
+                for (int k = 0; k < nsamples; k++, ramp += delta)
+                    dst[k] -= mul15(src[k], coeff_pre + (ramp >> nsamples_log2));
+            } else if (coeff_cur) {
                 for (int k = 0; k < nsamples; k++)
-                    dst[k] -= mul15(src[k], coeff);
+                    dst[k] -= mul15(src[k], coeff_cur);
             }
-        }
-    }
 
-    // Undo downmix of preceding channels in frequency band 1
-    if (c->nfreqbands > 1 && c->band_dmix_embedded[XLL_BAND_1]) {
-        int *coeff_ptr = c->dmix_coeff;
-        for (int i = 0; i < c->dmix_m; i++) {
-            for (int j = 0; j < c->nchannels; j++) {
-                int coeff = *coeff_ptr++;
-                if (coeff) {
-                    // Undo downmix of channel samples
-                    int *src = c->msb_sample_buffer[XLL_BAND_1][j];
-                    int *dst = dmix->samples[XLL_BAND_1][i];
-                    for (int k = 0; k < nsamples; k++)
-                        dst[k] -= mul15(src[k], coeff);
-
-                    // Undo downmix of decimator history
-                    src = c->deci_history[j];
-                    dst = dmix->deci_history[i];
-                    for (int k = 1; k < XLL_DECI_HISTORY; k++)
-                        dst[k] -= mul15(src[k], coeff);
-                }
-            }
+            // Undo downmix of decimator history
+            if (band == XLL_BAND_1 && coeff_pre)
+                for (int k = 1; k < XLL_DECI_HISTORY; k++)
+                    dmix->deci_history[i][k] -=
+                        mul15(c->deci_history[j][k], coeff_pre);
         }
     }
 }
 
-static void scale_down_mix(struct xll_chset *c, struct downmix *dmix)
+static void scale_down_mix(struct xll_chset *c, struct downmix *dmix, int band)
 {
     struct xll_decoder *xll = c->decoder;
     int nsamples = xll->nframesamples;
+    int nsamples_log2 = xll->nframesamples_log2;
 
-    // Pre-scale by next channel set in hierarchy
-    struct xll_chset *o = find_next_hier_dmix_chset(c);
-    if (o) {
-        for (int i = 0; i < c->dmix_m; i++) {
-            int scale = o->dmix_scale[i];
-            c->dmix_scale[i] = mul15(c->dmix_scale[i], scale);
-        }
-    }
+    if (!c->band_dmix_embedded[band])
+        return;
 
-    // Scale down preceding channels in frequency band 0
     for (int i = 0; i < c->dmix_m; i++) {
-        int scale = c->dmix_scale[i];
-        if (scale != (1 << 15)) {
-            int *buf = dmix->samples[XLL_BAND_0][i];
+        int scale_cur = c->dmix_scale_cur[i];
+        int scale_pre = c->dmix_scale_pre[i];
+        int delta = scale_cur - scale_pre;
+
+        // Scale down channel samples
+        int *buf = dmix->samples[band][i];
+
+        if (delta) {
+            // Scaling coefficient interpolation
+            int ramp = 1 << (nsamples_log2 - 1);
+            for (int k = 0; k < nsamples; k++, ramp += delta)
+                buf[k] = mul15(buf[k], scale_pre + (ramp >> nsamples_log2));
+        } else if (scale_cur != (1 << 15)) {
             for (int k = 0; k < nsamples; k++)
-                buf[k] = mul15(buf[k], scale);
+                buf[k] = mul15(buf[k], scale_cur);
         }
-    }
-
-    // Scale down preceding channels in frequency band 1
-    if (c->nfreqbands > 1 && c->band_dmix_embedded[XLL_BAND_1]) {
-        for (int i = 0; i < c->dmix_m; i++) {
-            int scale = c->dmix_scale[i];
-            if (scale != (1 << 15)) {
-                // Scale down channel samples
-                int *buf = dmix->samples[XLL_BAND_1][i];
-                for (int k = 0; k < nsamples; k++)
-                    buf[k] = mul15(buf[k], scale);
 
-                // Scale down decimator history
-                buf = dmix->deci_history[i];
-                for (int k = 1; k < XLL_DECI_HISTORY; k++)
-                    buf[k] = mul15(buf[k], scale);
-            }
-        }
+        // Scale down decimator history
+        if (band == XLL_BAND_1 && scale_pre != (1 << 15))
+            for (int k = 1; k < XLL_DECI_HISTORY; k++)
+                dmix->deci_history[i][k] =
+                    mul15(dmix->deci_history[i][k], scale_pre);
     }
 }
 
@@ -428,63 +431,93 @@
     struct xll_chset *p = &xll->chset[0];
 
     // Validate the first (primary) channel set
-    if (!p->primary_chset)
+    if (!p->primary_chset) {
+        xll_err_once("The first channel set must be primary");
         return -DCADEC_ENOSUP;
+    }
 
-    if (!p->ch_mask_enabled && p->nchannels != 2)
+    if (!p->ch_mask_enabled && p->nchannels != 2) {
+        xll_err_once("Unsupported number of channels with channel mask "
+                     "disabled for primary channel set (%d)", p->nchannels);
         return -DCADEC_ENOSUP;
+    }
 
-    if (p->storage_bit_res != 16 && p->storage_bit_res != 24)
+    if (p->storage_bit_res != 16 && p->storage_bit_res != 24) {
+        xll_err_once("Unsupported storage bit resolution for "
+                     "primary channel set (%d)", p->storage_bit_res);
         return -DCADEC_ENOSUP;
+    }
 
-    if (p->pcm_bit_res > p->storage_bit_res)
+    if (p->pcm_bit_res > p->storage_bit_res) {
+        xll_err("Invalid PCM bit resolution for primary channel set (%d > %d)",
+                p->pcm_bit_res, p->storage_bit_res);
         return -DCADEC_EINVAL;
+    }
 
     // Validate channel sets
     dca->has_residual_encoded = false;
     for_each_active_chset(xll, c) {
-        // Reject multiple primary channel sets
-        if (c->primary_chset && c != p)
-            return -DCADEC_ENOSUP;
-
-        // Reject non-primary channel sets w/o channel mask
-        if (!c->ch_mask_enabled && c != p)
-            return -DCADEC_ENOSUP;
-
-        // Reject parallel downmix
-        if (!c->primary_chset && c->dmix_embedded && !c->hier_chset)
-            return -DCADEC_ENOSUP;
-
-        // For now, PCM characteristics of all channel sets must be the same
-        if (c->freq != p->freq)
+        if (c->primary_chset && c != p) {
+            xll_err_once("Multiple primary channel sets are not supported");
             return -DCADEC_ENOSUP;
+        }
 
-        if (c->pcm_bit_res != p->pcm_bit_res)
+        if (!c->ch_mask_enabled && c != p) {
+            xll_err_once("Secondary channel sets with channel mask disabled "
+                         "are not supported");
             return -DCADEC_ENOSUP;
+        }
 
-        if (c->storage_bit_res != p->storage_bit_res)
+        if (!c->primary_chset && c->dmix_embedded && !c->hier_chset) {
+            xll_err_once("Channel sets with embedded parallel downmix "
+                         "are not supported");
             return -DCADEC_ENOSUP;
+        }
 
-        if (c->nfreqbands != p->nfreqbands)
+        if (c->freq != p->freq || c->pcm_bit_res != p->pcm_bit_res
+            || c->storage_bit_res != p->storage_bit_res
+            || c->nfreqbands != p->nfreqbands) {
+            xll_err_once("Channel sets with different audio "
+                         "characteristics are not supported");
             return -DCADEC_ENOSUP;
+        }
 
-        // Reject sampling frequency modifier
-        if (c->interpolate)
+        if (c->interpolate) {
+            xll_err_once("Channel sets with sampling frequency modifier "
+                         "are not supported");
             return -DCADEC_ENOSUP;
+        }
 
         dca->has_residual_encoded |= c->residual_encode != (1 << c->nchannels) - 1;
     }
 
     // Verify that core is compatible if there are residual encoded channel sets
     if (dca->has_residual_encoded) {
-        if (!(dca->packet & DCADEC_PACKET_CORE))
+        if (!(dca->packet & DCADEC_PACKET_CORE)) {
+            xll_err("Residual encoded channels are present without core");
             return -DCADEC_EINVAL;
-        if (p->freq != dca->core->sample_rate &&
-            p->freq != dca->core->sample_rate * 2)
+        }
+
+        int rate = dca->core->sample_rate;
+        int nsamples = dca->core->npcmblocks * NUM_PCMBLOCK_SAMPLES;
+
+        // Double sampling frequency if needed
+        if (p->freq == 96000 && rate == 48000) {
+            rate *= 2;
+            nsamples *= 2;
+        }
+
+        if (p->freq != rate) {
+            xll_err_once("Sample rate mismatch between core (%d) and XLL (%d)",
+                         rate, p->freq);
             return -DCADEC_ENOSUP;
-        if (xll->nframesamples != dca->core->npcmblocks * NUM_PCMBLOCK_SAMPLES &&
-            xll->nframesamples != dca->core->npcmblocks * NUM_PCMBLOCK_SAMPLES * 2)
+        }
+
+        if (xll->nframesamples != nsamples) {
+            xll_err("Number of samples per frame mismatch between core (%d) "
+                    "and XLL (%d)", nsamples, xll->nframesamples);
             return -DCADEC_EINVAL;
+        }
     }
 
     return 0;
@@ -527,12 +560,14 @@
 
     // Filter core frame
     int ret;
-    if ((ret = core_filter(core, flags)) < 0)
+    if ((ret = core_filter(core, flags)) < 0) {
+        dca->core_residual_valid = false;
         return ret;
+    }
 
     // Force lossy downmixed output if this is the first core frame since
     // the last time history was cleared, or XLL decoder is recovering from sync loss
-    if ((dca->core_residual_valid == false && xll->nchsets > 1) ||
+    if ((dca->has_residual_encoded && !dca->core_residual_valid && xll->nchsets > 1) ||
         (dca->packet & DCADEC_PACKET_RECOVERY)) {
         for_each_chset(xll, c) {
             if (c < &xll->chset[xll->nactivechsets])
@@ -554,9 +589,10 @@
     struct core_decoder *core = dca->core;
     struct xll_decoder *xll = dca->xll;
     int nsamples = xll->nframesamples;
+    int nsamples_log2 = xll->nframesamples_log2;
 
     if (c->freq != core->output_rate)
-        return -DCADEC_ENOSUP;
+        return -DCADEC_EINVAL;
 
     if (nsamples != core->npcmsamples)
         return -DCADEC_EINVAL;
@@ -589,9 +625,21 @@
         int *src = core->output_samples[core_spkr];
         if (o) {
             // Undo embedded core downmix pre-scaling
-            int scale_inv = o->dmix_scale_inv[c->dmix_m + ch];
-            for (int n = 0; n < nsamples; n++)
-                dst[n] += clip23((mul16(src[n], scale_inv) + round) >> shift);
+            int scale_inv_cur = o->dmix_scale_inv_cur[c->dmix_m + ch];
+            int scale_inv_pre = o->dmix_scale_inv_pre[c->dmix_m + ch];
+            int delta = scale_inv_cur - scale_inv_pre;
+
+            if (delta) {
+                // Scaling coefficient interpolation
+                int ramp = 1 << (nsamples_log2 - 1);
+                for (int n = 0; n < nsamples; n++, ramp += delta) {
+                    int scale_inv = scale_inv_pre + (ramp >> nsamples_log2);
+                    dst[n] += clip23((mul16(src[n], scale_inv) + round) >> shift);
+                }
+            } else {
+                for (int n = 0; n < nsamples; n++)
+                    dst[n] += clip23((mul16(src[n], scale_inv_cur) + round) >> shift);
+            }
         } else {
             // No downmix scaling
             for (int n = 0; n < nsamples; n++)
@@ -609,8 +657,7 @@
     int status = 0, ret;
 
     // Status indicating if this frame has not been decoded losslessly
-    if ((dca->has_residual_encoded && !dca->core_residual_valid)
-        || (dca->packet & DCADEC_PACKET_RECOVERY) || xll->nfailedsegs > 0)
+    if ((dca->packet & DCADEC_PACKET_RECOVERY) || xll->nfailedsegs > 0)
         status = DCADEC_WXLLLOSSY;
 
     // Filter core frame if present
@@ -618,6 +665,20 @@
         if ((ret = filter_residual_core_frame(dca)) < 0)
             return ret;
 
+    // Prepare downmixing coefficients for all channel sets
+    for_each_chset_reverse(xll, c) {
+        // Pre-scale by next channel set in hierarchy
+        if (is_hier_dmix_chset(c)) {
+            struct xll_chset *o = find_next_hier_dmix_chset(c);
+            if (o)
+                prescale_down_mix(c, o);
+        }
+
+        // Flip buffers and mark downmix coefficients valid for the next frame
+        c->dmix_coeffs_signature = XLL_DMIX_SIGNATURE(c);
+        c->dmix_coeffs_parity ^= true;
+    }
+
     // Process frequency band 0 for active channel sets
     for_each_active_chset(xll, c) {
         xll_filter_band_data(c, XLL_BAND_0);
@@ -647,28 +708,41 @@
 
         // Build channel vectors for all active channel sets
         for_each_active_chset(xll, c) {
-            if (c->hier_chset) {
-                for (int ch = 0; ch < c->nchannels; ch++) {
-                    dmix.samples[XLL_BAND_0][nchannels] =
-                        c->msb_sample_buffer[XLL_BAND_0][ch];
-                    dmix.samples[XLL_BAND_1][nchannels] =
-                        c->msb_sample_buffer[XLL_BAND_1][ch];
-                    dmix.deci_history[nchannels] = c->deci_history[ch];
-                    nchannels++;
-                }
+            if (!c->hier_chset)
+                continue;
+
+            if (nchannels + c->nchannels > SPEAKER_COUNT)
+                return -DCADEC_EINVAL;
+
+            for (int ch = 0; ch < c->nchannels; ch++) {
+                dmix.samples[XLL_BAND_0][nchannels] =
+                    c->msb_sample_buffer[XLL_BAND_0][ch];
+                dmix.samples[XLL_BAND_1][nchannels] =
+                    c->msb_sample_buffer[XLL_BAND_1][ch];
+                dmix.deci_history[nchannels] = c->deci_history[ch];
+                nchannels++;
             }
         }
 
         // Walk through downmix embedded channel sets
-        for (struct xll_chset *o = find_first_hier_dmix_chset(xll);
-             o != NULL; o = find_next_hier_dmix_chset(o)) {
+        for_each_chset(xll, o) {
+            if (!is_hier_dmix_chset(o))
+                continue;
+
             if (o->dmix_m > nchannels)
                 o->dmix_m = nchannels;
             if (o->dmix_m == nchannels) {
-                scale_down_mix(o, &dmix);
+                // Scale down preceding channels in all frequency bands
+                scale_down_mix(o, &dmix, XLL_BAND_0);
+                if (o->nfreqbands > 1)
+                    scale_down_mix(o, &dmix, XLL_BAND_1);
                 break;
             }
-            undo_down_mix(o, &dmix);
+
+            // Undo downmix of preceding channels in all frequency bands
+            undo_down_mix(o, &dmix, XLL_BAND_0);
+            if (o->nfreqbands > 1)
+                undo_down_mix(o, &dmix, XLL_BAND_1);
         }
     }
 
@@ -691,7 +765,7 @@
         if (p->nchannels == 2)
             p->ch_mask = SPEAKER_MASK_L | SPEAKER_MASK_R;
         else
-            return -DCADEC_ENOSUP;
+            return -DCADEC_EINVAL;
     }
 
     // Build the output speaker map
@@ -723,7 +797,7 @@
     if (dca->flags & DCADEC_FLAG_KEEP_DMIX_2CH) {
         int *coeff = NULL;
         if (p->dmix_embedded && p->dmix_type == DMIX_TYPE_LoRo)
-            coeff = p->dmix_coeff;
+            coeff = p->dmix_coeff_cur;
         if ((ret = down_mix_prim_chset(dca, spkr_map, xll->nframesamples,
                                        &ch_mask, coeff)) < 0)
             return ret;
@@ -754,6 +828,40 @@
     return status;
 }
 
+static int alloc_core_decoder(struct dcadec_context *dca)
+{
+    if (!dca->core) {
+        if (!(dca->core = ta_znew(dca, struct core_decoder)))
+            return -DCADEC_ENOMEM;
+        dca->core->log_cb = dca->log_cb;
+        dca->core->log_cbarg = dca->log_cbarg;
+    }
+    return 0;
+}
+
+static int alloc_exss_parser(struct dcadec_context *dca)
+{
+    if (!dca->exss) {
+        if (!(dca->exss = ta_znew(dca, struct exss_parser)))
+            return -DCADEC_ENOMEM;
+        dca->exss->log_cb = dca->log_cb;
+        dca->exss->log_cbarg = dca->log_cbarg;
+    }
+    return 0;
+}
+
+static int alloc_xll_decoder(struct dcadec_context *dca)
+{
+    if (!dca->xll) {
+        if (!(dca->xll = ta_znew(dca, struct xll_decoder)))
+            return -DCADEC_ENOMEM;
+        dca->xll->log_cb = dca->log_cb;
+        dca->xll->log_cbarg = dca->log_cbarg;
+        dca->xll->flags = dca->flags;
+    }
+    return 0;
+}
+
 DCADEC_API int dcadec_context_parse(struct dcadec_context *dca, uint8_t *data, size_t size)
 {
     int status = 0, ret;
@@ -766,12 +874,12 @@
 
     // Parse backward compatible core sub-stream
     if (DCA_MEM32NE(data) == DCA_32BE_C(SYNC_WORD_CORE)) {
-        if (!dca->core)
-            if (!(dca->core = ta_znew(dca, struct core_decoder)))
-                return -DCADEC_ENOMEM;
-
-        if ((ret = core_parse(dca->core, data, size, dca->flags, NULL)) < 0)
+        if ((ret = alloc_core_decoder(dca)) < 0)
+            return ret;
+        if ((ret = core_parse(dca->core, data, size, dca->flags, NULL)) < 0) {
+            dca->core_residual_valid = false;
             return ret;
+        }
         if (ret > status)
             status = ret;
 
@@ -785,33 +893,32 @@
         }
     }
 
+    struct exss_asset *asset = NULL;
+
     // Parse extension sub-stream (EXSS)
     if (DCA_MEM32NE(data) == DCA_32BE_C(SYNC_WORD_EXSS)) {
-        if (!dca->exss)
-            if (!(dca->exss = ta_znew(dca, struct exss_parser)))
-                return -DCADEC_ENOMEM;
-
+        if ((ret = alloc_exss_parser(dca)) < 0)
+            return ret;
         if ((ret = exss_parse(dca->exss, data, size)) < 0) {
             if (dca->flags & DCADEC_FLAG_STRICT)
                 return ret;
             status = DCADEC_WEXSSFAILED;
         } else {
             dca->packet |= DCADEC_PACKET_EXSS;
+            asset = &dca->exss->assets[0];
         }
     }
 
     // Parse coding components in the first EXSS asset
     if (dca->packet & DCADEC_PACKET_EXSS) {
-        struct exss_asset *asset = &dca->exss->assets[0];
-
         // Parse core component in EXSS
         if (!(dca->packet & DCADEC_PACKET_CORE) && (asset->extension_mask & EXSS_CORE)) {
-            if (!dca->core)
-                if (!(dca->core = ta_znew(dca, struct core_decoder)))
-                    return -DCADEC_ENOMEM;
-
-            if ((ret = core_parse(dca->core, data, size, dca->flags, asset)) < 0)
+            if ((ret = alloc_core_decoder(dca)) < 0)
                 return ret;
+            if ((ret = core_parse(dca->core, data, size, dca->flags, asset)) < 0) {
+                dca->core_residual_valid = false;
+                return ret;
+            }
             if (ret > status)
                 status = ret;
 
@@ -820,12 +927,8 @@
 
         // Parse XLL component in EXSS
         if (!(dca->flags & DCADEC_FLAG_CORE_ONLY) && (asset->extension_mask & EXSS_XLL)) {
-            if (!dca->xll) {
-                if (!(dca->xll = ta_znew(dca, struct xll_decoder)))
-                    return -DCADEC_ENOMEM;
-                dca->xll->flags = dca->flags;
-            }
-
+            if ((ret = alloc_xll_decoder(dca)) < 0)
+                return ret;
             if ((ret = xll_parse(dca->xll, data, size, asset)) < 0) {
                 // Conceal XLL synchronization error
                 if (ret == -DCADEC_ENOSYNC &&
@@ -851,9 +954,6 @@
 
     // Parse core extensions in EXSS or backward compatible core sub-stream
     if (!(dca->flags & DCADEC_FLAG_CORE_ONLY) && (dca->packet & DCADEC_PACKET_CORE)) {
-        struct exss_asset *asset = NULL;
-        if (dca->packet & DCADEC_PACKET_EXSS)
-            asset = &dca->exss->assets[0];
         if ((ret = core_parse_exss(dca->core, data, size, dca->flags, asset)) < 0)
             return ret;
         if (ret > status)
@@ -962,6 +1062,28 @@
     ta_free(dca);
 }
 
+DCADEC_API void dcadec_context_set_log_cb(struct dcadec_context *dca,
+                                          dcadec_log_cb log_cb,
+                                          void *log_cbarg)
+{
+    if (dca) {
+        dca->log_cb = log_cb;
+        dca->log_cbarg = log_cbarg;
+        if (dca->core) {
+            dca->core->log_cb = log_cb;
+            dca->core->log_cbarg = log_cbarg;
+        }
+        if (dca->exss) {
+            dca->exss->log_cb = log_cb;
+            dca->exss->log_cbarg = log_cbarg;
+        }
+        if (dca->xll) {
+            dca->xll->log_cb = log_cb;
+            dca->xll->log_cbarg = log_cbarg;
+        }
+    }
+}
+
 DCADEC_API const char *dcadec_strerror(int errnum)
 {
     static const char * const errors[] = {
@@ -1008,5 +1130,5 @@
 
 DCADEC_API unsigned int dcadec_version(void)
 {
-    return DCADEC_VERSION;
+    return DCADEC_API_VERSION;
 }

dcadec-20151114.57012a4.tar.xz/libdcadec/dca_context.h -> dcadec-0.1.0.tar.gz/libdcadec/dca_context.h Changed

@@ -29,20 +29,18 @@
     (((major) << 24) | ((minor) << 12) | (patch) | 0U)
 
 /**
- * Version of libdcadec. Major number gets bumped at each API change that
+ * Version of libdcadec API. Major number gets bumped at each API change that
  * breaks backward compatibility. Minor number gets bumped at each API change
  * that remains compatible. Patch is reserved for non-API related changes.
- *
- * THE LIBRARY IS NOT YET RELEASED, DON'T CHECK THESE NUMBERS YET.
  */
-#define DCADEC_VERSION_MAJOR 0
-#define DCADEC_VERSION_MINOR 0
-#define DCADEC_VERSION_PATCH 0
-
-#define DCADEC_VERSION  \
-    DCADEC_VERSION_CODE(DCADEC_VERSION_MAJOR, \
-                        DCADEC_VERSION_MINOR, \
-                        DCADEC_VERSION_PATCH)
+#define DCADEC_API_VERSION_MAJOR    0
+#define DCADEC_API_VERSION_MINOR    0
+#define DCADEC_API_VERSION_PATCH    0
+
+#define DCADEC_API_VERSION \
+    DCADEC_VERSION_CODE(DCADEC_API_VERSION_MAJOR, \
+                        DCADEC_API_VERSION_MINOR, \
+                        DCADEC_API_VERSION_PATCH)
 /**@}*/
 
 /**@{*/
@@ -111,13 +109,16 @@
 /** Reserved flag, don't use */
 #define DCADEC_FLAG_CORE_RESERVED       0x08
 
-/* Use FIR filter for floating point DTS core LFE channel interpolation */
+/** Use FIR filter for floating point DTS core LFE channel interpolation */
 #define DCADEC_FLAG_CORE_LFE_FIR        0x10
 
-/** Extract embedded 2.0 downmix if present, otherwise extract 5.1 downmix */
+/**
+ * Extract embedded 2.0 downmix if present (or perform 5.1 to 2.0 downmix if
+ * custom downmixing coefficients are present), otherwise extract 5.1 downmix.
+ */
 #define DCADEC_FLAG_KEEP_DMIX_2CH       0x20
 
-/** Extract embedded 5.1 downmix */
+/** Extract embedded 5.1 downmix (always present for 6.1 and 7.1 content) */
 #define DCADEC_FLAG_KEEP_DMIX_6CH       0x40
 
 /** Output native DTS channel layout, not WAVEFORMATEXTENSIBLE layout */
@@ -151,6 +152,14 @@
 #define DCADEC_MATRIX_ENCODING_HEADPHONE    2
 /**@}*/
 
+/**@{*/
+#define DCADEC_LOG_ERROR    0
+#define DCADEC_LOG_WARNING  1
+#define DCADEC_LOG_INFO     2
+#define DCADEC_LOG_VERBOSE  3
+#define DCADEC_LOG_DEBUG    4
+/**@}*/
+
 /**
  * Size in bytes of empty padding that must be present after the end of input
  * buffer. libdcadec may overread the input buffer up to this number of bytes.
@@ -186,6 +195,9 @@
     int matrix_encoding;    /**< Matrix encoding type */
 };
 
+typedef void (*dcadec_log_cb)(int level, const char *file, int line,
+                              const char *message, void *cbarg);
+
 /**
  * Parse DTS packet. Packet data must be already converted into 16-bit
  * big-endian format. Caller must have already established byte stream
@@ -316,6 +328,21 @@
 DCADEC_API void dcadec_context_destroy(struct dcadec_context *dca);
 
 /**
+ * Set or clear logging callback for decoder context.
+ *
+ * @param dca       Pointer to decoder context.
+ *
+ * @param log_cb    Pointer to logging callback function. Pass NULL to disable
+ *                  logging.
+ *
+ * @param log_cbarg Opaque pointer that will be passed through to callback
+ *                  function.
+ */
+DCADEC_API void dcadec_context_set_log_cb(struct dcadec_context *dca,
+                                          dcadec_log_cb log_cb,
+                                          void *log_cbarg);
+
+/**
  * Convert negative libdcadec error code or positive warning code into string.
  *
  * @param errnum    Error or warning code returned by libdcadec function.
@@ -325,9 +352,9 @@
 DCADEC_API const char *dcadec_strerror(int errnum);
 
 /**
- * Get libdcadec version.
+ * Get libdcadec API version.
  *
- * @return  Version code of the currently running libdcadec.
+ * @return  API version code of the currently running libdcadec.
  */
 DCADEC_API unsigned int dcadec_version(void);

dcadec-20151114.57012a4.tar.xz/libdcadec/exss_parser.c -> dcadec-0.1.0.tar.gz/libdcadec/exss_parser.c Changed

@@ -70,7 +70,7 @@
 static int parse_descriptor(struct exss_asset *asset)
 {
     struct exss_parser *exss = asset->parser;
-    int i, j;
+    int i, j, ret;
 
     size_t descr_pos = exss->bits.index;
 
@@ -136,8 +136,10 @@
 
             // Number of speaker remapping sets
             int spkr_remap_nsets = bits_get(&exss->bits, 3);
-            enforce(!spkr_remap_nsets || spkr_mask_nbits,
-                    "Speaker mask disabled yet there are remapping sets");
+            if (spkr_remap_nsets && !spkr_mask_nbits) {
+                exss_err("Speaker mask disabled yet there are remapping sets");
+                return -DCADEC_EBADDATA;
+            }
 
             // Standard loudspeaker layout mask
             int nspeakers[8];
@@ -298,7 +300,9 @@
     // Revision 2 DRC metadata
     // Reserved
     // Zero pad
-    return bits_seek(&exss->bits, descr_pos + descr_size * 8);
+    if ((ret = bits_seek(&exss->bits, descr_pos + descr_size * 8)) < 0)
+        exss_err("Read past end of asset descriptor");
+    return ret;
 }
 
 static int set_exss_offsets(struct exss_asset *asset)
@@ -379,14 +383,19 @@
     size_t header_size = bits_get(&exss->bits, 8 + 4 * wide_hdr) + 1;
 
     // Check CRC
-    if ((ret = bits_check_crc(&exss->bits, 32 + 8, header_size * 8)) < 0)
+    if ((ret = bits_check_crc(&exss->bits, 32 + 8, header_size * 8)) < 0) {
+        exss_err("Invalid header checksum");
         return ret;
+    }
 
     exss->exss_size_nbits = 16 + 4 * wide_hdr;
 
     // Number of bytes of extension substream
     exss->exss_size = bits_get(&exss->bits, exss->exss_size_nbits) + 1;
-    enforce(exss->exss_size <= size, "Invalid EXSS size");
+    if (exss->exss_size > size) {
+        exss_err("Packet too short");
+        return -DCADEC_EBADDATA;
+    }
 
     // Per stream static fields presence flag
     exss->static_fields_present = bits_get1(&exss->bits);
@@ -443,8 +452,11 @@
     }
 
     // Reject unsupported features for now
-    if (exss->exss_index > 0 || exss->npresents != 1 || exss->nassets != 1)
+    if (exss->exss_index > 0 || exss->npresents != 1 || exss->nassets != 1) {
+        exss_err_once("Multiple sub-streams, audio presentations "
+                      "and/or assets are not supported");
         return -DCADEC_ENOSUP;
+    }
 
     // Reallocate assets
     if (ta_zalloc_fast(exss, &exss->assets, exss->nassets, sizeof(struct exss_asset)) < 0)
@@ -456,7 +468,10 @@
         exss->assets[i].asset_offset = offset;
         exss->assets[i].asset_size = bits_get(&exss->bits, exss->exss_size_nbits) + 1;
         offset += exss->assets[i].asset_size;
-        enforce(offset <= exss->exss_size, "EXSS asset out of bounds");
+        if (offset > exss->exss_size) {
+            exss_err("Asset out of bounds");
+            return -DCADEC_EBADDATA;
+        }
     }
 
     // Audio asset descriptor
@@ -464,8 +479,10 @@
         exss->assets[i].parser = exss;
         if ((ret = parse_descriptor(&exss->assets[i])) < 0)
             return ret;
-        if ((ret = set_exss_offsets(&exss->assets[i])) < 0)
+        if ((ret = set_exss_offsets(&exss->assets[i])) < 0) {
+            exss_err("Invalid extension size in asset descriptor");
             return ret;
+        }
     }
 
     // Backward compatible core present
@@ -474,7 +491,9 @@
     // Reserved
     // Byte align
     // CRC16 of extension substream header
-    return bits_seek(&exss->bits, header_size * 8);
+    if ((ret = bits_seek(&exss->bits, header_size * 8)) < 0)
+        exss_err("Read past end of header");
+    return ret;
 }
 
 struct dcadec_exss_info *exss_get_info(struct exss_parser *exss)

dcadec-20151114.57012a4.tar.xz/libdcadec/exss_parser.h -> dcadec-0.1.0.tar.gz/libdcadec/exss_parser.h Changed

dcadec-20151114.57012a4.tar.xz/libdcadec/interpolator.h -> dcadec-0.1.0.tar.gz/libdcadec/interpolator.h Changed

@@ -24,19 +24,19 @@
 struct interpolator;
 struct idct_context;
 
-typedef void (*interpolate_lfe_t)(int *pcm_samples, int *lfe_samples,
-                                  int nsamples, bool dec_select,
-                                  bool synth_x96);
+typedef void (*interpolate_lfe_cb)(int *pcm_samples, int *lfe_samples,
+                                   int nsamples, bool dec_select,
+                                   bool synth_x96);
 
-typedef void (*interpolate_sub_t)(struct interpolator *dsp, int *pcm_samples,
-                                  int **subband_samples_lo,
-                                  int **subband_samples_hi,
-                                  int nsamples, bool perfect);
+typedef void (*interpolate_sub_cb)(struct interpolator *dsp, int *pcm_samples,
+                                   int **subband_samples_lo,
+                                   int **subband_samples_hi,
+                                   int nsamples, bool perfect);
 
 struct interpolator {
     struct idct_context *idct;
     void *history;
-    interpolate_sub_t interpolate;
+    interpolate_sub_cb interpolate;
 };
 
 struct interpolator *interpolator_create(struct idct_context *parent, int flags);

dcadec-20151114.57012a4.tar.xz/libdcadec/xll_decoder.c -> dcadec-0.1.0.tar.gz/libdcadec/xll_decoder.c Changed

@@ -40,19 +40,26 @@
         n = chs->nchannels + 2; // Two extra columns for scales
     }
 
-    // Reallocate downmix coefficients matrix
-    if (ta_zalloc_fast(xll->chset, &chs->dmix_coeff, m * n, sizeof(int)) < 0)
+    // Reallocate downmix coefficients buffer
+    if (ta_zalloc_fast(xll->chset, &chs->dmix_coeff, m * n * 2, sizeof(int)) < 0)
         return -DCADEC_ENOMEM;
 
+    // Setup buffer pointers for current and previous frame
+    bool valid = (chs->dmix_coeffs_signature == XLL_DMIX_SIGNATURE(chs));
+    chs->dmix_coeff_cur = chs->dmix_coeff + m * n * chs->dmix_coeffs_parity;
+    chs->dmix_coeff_pre = chs->dmix_coeff + m * n * (chs->dmix_coeffs_parity ^ valid);
+
     if (chs->primary_chset) {
-        chs->dmix_scale = NULL;
-        chs->dmix_scale_inv = NULL;
+        chs->dmix_scale_cur = chs->dmix_scale_pre = NULL;
+        chs->dmix_scale_inv_cur = chs->dmix_scale_inv_pre = NULL;
     } else {
-        chs->dmix_scale = chs->dmix_coeff + m * chs->nchannels;
-        chs->dmix_scale_inv = chs->dmix_coeff + m * (chs->nchannels + 1);
+        chs->dmix_scale_cur = chs->dmix_coeff_cur + m * chs->nchannels;
+        chs->dmix_scale_pre = chs->dmix_coeff_pre + m * chs->nchannels;
+        chs->dmix_scale_inv_cur = chs->dmix_coeff_cur + m * (chs->nchannels + 1);
+        chs->dmix_scale_inv_pre = chs->dmix_coeff_pre + m * (chs->nchannels + 1);
     }
 
-    int *coeff_ptr = chs->dmix_coeff;
+    int *coeff_ptr = chs->dmix_coeff_cur;
     for (int i = 0; i < m; i++) {
         int scale_inv = 0;
 
@@ -63,14 +70,17 @@
             int sign = (code >> 8) - 1; code &= 0xff;
             if (code > 0) {
                 unsigned int index = code - 1;
-                enforce(index >= 40 && index < dca_countof(dmix_table), "Invalid downmix scale index");
+                if (index < 40 || index >= dca_countof(dmix_table)) {
+                    xll_err("Invalid downmix scale index");
+                    return -DCADEC_EBADDATA;
+                }
                 int scale = dmix_table[index];
                 scale_inv = dmix_table_inv[index - 40];
-                chs->dmix_scale[i] = (scale ^ sign) - sign;
-                chs->dmix_scale_inv[i] = (scale_inv ^ sign) - sign;
+                chs->dmix_scale_cur[i] = (scale ^ sign) - sign;
+                chs->dmix_scale_inv_cur[i] = (scale_inv ^ sign) - sign;
             } else {
-                chs->dmix_scale[i] = 0;
-                chs->dmix_scale_inv[i] = 0;
+                chs->dmix_scale_cur[i] = 0;
+                chs->dmix_scale_inv_cur[i] = 0;
             }
         }
 
@@ -80,7 +90,10 @@
             int sign = (code >> 8) - 1; code &= 0xff;
             if (code > 0) {
                 unsigned int index = code - 1;
-                enforce(index < dca_countof(dmix_table), "Invalid downmix coefficient index");
+                if (index >= dca_countof(dmix_table)) {
+                    xll_err("Invalid downmix coefficient index");
+                    return -DCADEC_EBADDATA;
+                }
                 int coeff = dmix_table[index];
                 if (!chs->primary_chset)
                     // Multiply by |InvDmixScale| to get |UndoDmixScale|
@@ -106,12 +119,17 @@
     size_t header_size = bits_get(&xll->bits, 10) + 1;
 
     // Check CRC
-    if ((ret = bits_check_crc(&xll->bits, header_pos, header_pos + header_size * 8)) < 0)
+    if ((ret = bits_check_crc(&xll->bits, header_pos, header_pos + header_size * 8)) < 0) {
+        xll_err("Invalid sub-header checksum");
         return ret;
+    }
 
     // Number of channels in the channel set
     chs->nchannels = bits_get(&xll->bits, 4) + 1;
-    require(chs->nchannels <= XLL_MAX_CHANNELS, "Too many channels");
+    if (chs->nchannels > XLL_MAX_CHANNELS) {
+        xll_err_once("Unsupported number of channels (%d)", chs->nchannels);
+        return -DCADEC_ENOSUP;
+    }
 
     // Residual type
     chs->residual_encode = bits_get(&xll->bits, chs->nchannels);
@@ -124,14 +142,20 @@
 
     // Original sampling frequency
     chs->freq = exss_sample_rates[bits_get(&xll->bits, 4)];
-    require(chs->freq <= 192000, "Too high sampling frequency");
+    if (chs->freq > 192000) {
+        xll_err_once("Unsupported sampling frequency");
+        return -DCADEC_ENOSUP;
+    }
 
     // Sampling frequency modifier
     chs->interpolate = bits_get(&xll->bits, 2);
 
     // Which replacement set this channel set is member of
     chs->replace_set_index = bits_get(&xll->bits, 2);
-    require(chs->replace_set_index == 0, "Replacement sets are not supported");
+    if (chs->replace_set_index) {
+        xll_err_once("Replacement sets are not supported");
+        return -DCADEC_ENOSUP;
+    }
 
     // Default replacement set flag
     if (chs->replace_set_index)
@@ -150,8 +174,10 @@
         // Downmix type
         if (chs->dmix_coeffs_present && chs->primary_chset) {
             chs->dmix_type = bits_get(&xll->bits, 3);
-            enforce(chs->dmix_type < DMIX_TYPE_COUNT,
-                    "Invalid primary channel set downmix type");
+            if (chs->dmix_type >= DMIX_TYPE_COUNT) {
+                xll_err("Invalid primary channel set downmix type");
+                return -DCADEC_EBADDATA;
+            }
         }
 
         // Whether the channel set is part of a hierarchy
@@ -166,7 +192,10 @@
         if (chs->ch_mask_enabled) {
             // Channel mask for set
             chs->ch_mask = bits_get(&xll->bits, xll->ch_mask_nbits);
-            enforce(dca_popcount(chs->ch_mask) == chs->nchannels, "Invalid channel mask");
+            if (dca_popcount(chs->ch_mask) != chs->nchannels) {
+                xll_err("Invalid channel mask");
+                return -DCADEC_EBADDATA;
+            }
         } else {
             chs->ch_mask = 0;
             // Angular speaker position table
@@ -186,6 +215,8 @@
 
         // Mapping coeffs present flag
         if (bits_get1(&xll->bits)) {
+            xll_warn_once("Stream with speaker mapping coefficients");
+
             // Number of bits used to pack each
             // channel-to-speaker mapping coefficient
             int nchspkrcoefbits = 6 + 2 * bits_get(&xll->bits, 3);
@@ -221,14 +252,19 @@
         }
     }
 
+    // Mark downmix coefficients invalid until filtering
+    chs->dmix_coeffs_signature = 0;
+
     if (chs->freq > 96000)
         // Extra frequency bands flag
         chs->nfreqbands = 2 * (1 + bits_get1(&xll->bits));
     else
         chs->nfreqbands = 1;
 
-    // Extra frequency bands are not supported
-    require(chs->nfreqbands <= XLL_MAX_BANDS, "Too many frequency bands");
+    if (chs->nfreqbands > XLL_MAX_BANDS) {
+        xll_err_once("Extra frequency bands are not supported");
+        return -DCADEC_ENOSUP;
+    }
 
     // Clamp the sampling frequency to 96 kHz. The rest of the code will use
     // the number of bands to determine maximum frequency.
@@ -251,7 +287,10 @@
             // Original channel order
             for (i = 0; i < chs->nchannels; i++) {
                 chs->orig_order[band][i] = bits_get(&xll->bits, ch_nbits[chs->nchannels - 1]);
-                enforce(chs->orig_order[band][i] < chs->nchannels, "Invalid original channel order");
+                if (chs->orig_order[band][i] >= chs->nchannels) {
+                    xll_err("Invalid original channel order");
+                    return -DCADEC_EBADDATA;
+                }
             }
             // Pairwise channel coefficients
             for (i = 0; i < chs->nchannels / 2; i++) {
@@ -274,8 +313,10 @@
             if (chs->adapt_pred_order[band][i] > chs->highest_pred_order[band])
                 chs->highest_pred_order[band] = chs->adapt_pred_order[band][i];
         }
-        enforce(chs->highest_pred_order[band] <= xll->nsegsamples,
-                "Invalid adaptive predicition order");
+        if (chs->highest_pred_order[band] > xll->nsegsamples) {
+            xll_err("Invalid adaptive predicition order");
+            return -DCADEC_EBADDATA;
+        }
 
         // Fixed predictor order
         for (i = 0; i < chs->nchannels; i++) {
@@ -289,7 +330,10 @@
         for (i = 0; i < chs->nchannels; i++) {
             for (j = 0; j < chs->adapt_pred_order[band][i]; j++) {
                 k = bits_get_signed_linear(&xll->bits, 8);
-                enforce(k > -128, "Invalid reflection coefficient index");
+                if (k == -128) {
+                    xll_err("Invalid reflection coefficient index");
+                    return -DCADEC_EBADDATA;
+                }
                 if (k < 0)
                     chs->adapt_refl_coeff[band][i][j] = -(int)refl_coeff_table[-k];
                 else
@@ -311,11 +355,13 @@
                 chs->lsb_section_size[band] += 2;
 
             // Number of bits to represent the samples in LSB part
-            int tmp = 0;
-            for (i = 0; i < chs->nchannels; i++)
-                tmp |= (chs->nscalablelsbs[band][i] = bits_get(&xll->bits, 4));
-            enforce(!tmp || chs->lsb_section_size[band],
-                    "LSB section missing with non-zero LSB width");
+            for (i = 0; i < chs->nchannels; i++) {
+                chs->nscalablelsbs[band][i] = bits_get(&xll->bits, 4);
+                if (chs->nscalablelsbs[band][i] && !chs->lsb_section_size[band]) {
+                    xll_err("LSB section missing with non-zero LSB width");
+                    return -DCADEC_EBADDATA;
+                }
+            }
         } else {
             chs->lsb_section_size[band] = 0;
             for (i = 0; i < chs->nchannels; i++)
@@ -336,7 +382,9 @@
     // Reserved
     // Byte align
     // CRC16 of channel set sub-header
-    return bits_seek(&xll->bits, header_pos + header_size * 8);
+    if ((ret = bits_seek(&xll->bits, header_pos + header_size * 8)) < 0)
+        xll_err("Read past end of sub-header");
+    return ret;
 }
 
 static int chs_alloc_msb_band_data(struct xll_chset *chs)
@@ -503,7 +551,10 @@
                 // Extract the locations of isolated samples and flag by -1
                 for (j = 0; j < nisosamples; j++) {
                     int loc = bits_get(&xll->bits, xll->nsegsamples_log2);
-                    enforce(loc < nsamples_part_b, "Invalid isolated sample location");
+                    if (loc >= nsamples_part_b) {
+                        xll_err("Invalid isolated sample location");
+                        return -DCADEC_EBADDATA;
+                    }
                     part_b[loc] = -1;
                 }
 
@@ -536,13 +587,17 @@
 
     // Start unpacking LSB portion of the segment
     if (chs->lsb_section_size[band]) {
-        enforce(chs->lsb_section_size[band] <= band_data_nbytes,
-                "Invalid LSB section size");
+        if (chs->lsb_section_size[band] > band_data_nbytes) {
+            xll_err("Invalid LSB section size");
+            return -DCADEC_EBADDATA;
+        }
 
         // Skip to the start of LSB portion
         if ((ret = bits_seek(&xll->bits, band_data_end -
-                             chs->lsb_section_size[band] * 8)) < 0)
+                             chs->lsb_section_size[band] * 8)) < 0) {
+            xll_err("Read past end of band data");
             return ret;
+        }
 
         // Unpack all LSB parts of residuals of this segment
         for (i = 0; i < chs->nchannels; i++) {
@@ -557,7 +612,9 @@
     }
 
     // Skip to the end of band data
-    return bits_seek(&xll->bits, band_data_end);
+    if ((ret = bits_seek(&xll->bits, band_data_end)) < 0)
+        xll_err("Read past end of band data");
+    return ret;
 }
 
 static void chs_clear_band_data(struct xll_chset *chs, int band, int seg)
@@ -785,45 +842,72 @@
     int ret;
 
     // XLL extension sync word
-    if (bits_get(&xll->bits, 32) != SYNC_WORD_XLL)
+    if (bits_get(&xll->bits, 32) != SYNC_WORD_XLL) {
+        xll_verbose("Invalid sync word");
         return -DCADEC_ENOSYNC;
+    }
 
     // Version number
     int stream_ver = bits_get(&xll->bits, 4) + 1;
-    require(stream_ver == 1, "Unsupported XLL stream version");
+    if (stream_ver > 1) {
+        xll_err_once("Unsupported stream version (%d)", stream_ver);
+        return -DCADEC_ENOSUP;
+    }
 
     // Lossless frame header length
     size_t header_size = bits_get(&xll->bits, 8) + 1;
 
     // Check CRC
-    if ((ret = bits_check_crc(&xll->bits, 32, header_size * 8)) < 0)
+    if ((ret = bits_check_crc(&xll->bits, 32, header_size * 8)) < 0) {
+        xll_err("Invalid common header checksum");
         return ret;
+    }
 
     // Number of bits used to read frame size
     int frame_size_nbits = bits_get(&xll->bits, 5) + 1;
 
     // Number of bytes in a lossless frame
     xll->frame_size = bits_get(&xll->bits, frame_size_nbits);
-    enforce(xll->frame_size < XLL_PBR_SIZE, "Invalid XLL frame size");
+    if (xll->frame_size >= XLL_PBR_SIZE) {
+        xll_err("Invalid frame size");
+        return -DCADEC_EBADDATA;
+    }
     xll->frame_size++;
 
     // Number of channels sets per frame
     xll->nchsets = bits_get(&xll->bits, 4) + 1;
+    if (xll->nchsets > 3)
+        xll_warn_once("Stream with %d channel sets", xll->nchsets);
 
     // Number of segments per frame
-    xll->nframesegs = 1 << bits_get(&xll->bits, 4);
-    enforce(xll->nframesegs <= 1024, "Too many segments per XLL frame");
+    int nframesegs_log2 = bits_get(&xll->bits, 4);
+    xll->nframesegs = 1 << nframesegs_log2;
+    if (xll->nframesegs > 1024) {
+        xll_err("Too many segments per frame");
+        return -DCADEC_EBADDATA;
+    }
 
     // Samples in segment per one frequency band for the first channel set
     // Maximum value is 256 for sampling frequencies <= 48 kHz
     // Maximum value is 512 for sampling frequencies > 48 kHz
     xll->nsegsamples_log2 = bits_get(&xll->bits, 4);
+    if (!xll->nsegsamples_log2) {
+        xll_err("Too few samples per segment");
+        return -DCADEC_EBADDATA;
+    }
     xll->nsegsamples = 1 << xll->nsegsamples_log2;
-    enforce(xll->nsegsamples <= 512, "Too many samples per XLL segment");
+    if (xll->nsegsamples > 512) {
+        xll_err("Too many samples per segment");
+        return -DCADEC_EBADDATA;
+    }
 
     // Samples in frame per one frequency band for the first channel set
-    xll->nframesamples = xll->nframesegs * xll->nsegsamples;
-    enforce(xll->nframesamples <= 65536, "Too many samples per XLL frame");
+    xll->nframesamples_log2 = xll->nsegsamples_log2 + nframesegs_log2;
+    xll->nframesamples = 1 << xll->nframesamples_log2;
+    if (xll->nframesamples > 65536) {
+        xll_err("Too many samples per frame");
+        return -DCADEC_EBADDATA;
+    }
 
     // Number of bits used to read segment size
     xll->seg_size_nbits = bits_get(&xll->bits, 5) + 1;
@@ -834,6 +918,8 @@
     // 2 - CRC16 placed at the end of MSB0 and LSB0
     // 3 - CRC16 placed at the end of MSB0 and LSB0 and other frequency bands
     xll->band_crc_present = bits_get(&xll->bits, 2);
+    if (xll->band_crc_present)
+        xll_warn_once("Stream with band CRC present (%d)", xll->band_crc_present);
 
     // MSB/LSB split flag
     xll->scalable_lsbs = bits_get1(&xll->bits);
@@ -846,11 +932,15 @@
         xll->fixed_lsb_width = bits_get(&xll->bits, 4);
     else
         xll->fixed_lsb_width = 0;
+    if (xll->fixed_lsb_width)
+        xll_warn_once("Stream with fixed LSB width (%d)", xll->fixed_lsb_width);
 
     // Reserved
     // Byte align
     // Header CRC16 protection
-    return bits_seek(&xll->bits, header_size * 8);
+    if ((ret = bits_seek(&xll->bits, header_size * 8)) < 0)
+        xll_err("Read past end of common header");
+    return ret;
 }
 
 static int parse_sub_headers(struct xll_decoder *xll, struct exss_asset *asset)
@@ -904,7 +994,10 @@
                 size_t size = 0;
                 if (chs->nfreqbands > band) {
                     size = bits_get(&xll->bits, xll->seg_size_nbits);
-                    enforce(size < xll->frame_size, "Invalid NAVI size");
+                    if (size >= xll->frame_size) {
+                        xll_err("Invalid NAVI size");
+                        return -DCADEC_EBADDATA;
+                    }
                     size++;
                 }
                 *navi_ptr++ = size;
@@ -913,13 +1006,21 @@
         }
     }
 
-    enforce(navi_size <= xll->frame_size, "Invalid NAVI size");
+    if (navi_size > xll->frame_size) {
+        xll_err("Invalid NAVI size");
+        return -DCADEC_EBADDATA;
+    }
 
     // Byte align
     // CRC16
     bits_align1(&xll->bits);
     bits_skip(&xll->bits, 16);
-    return bits_check_crc(&xll->bits, navi_pos, xll->bits.index);
+
+    // Check CRC
+    int ret;
+    if ((ret = bits_check_crc(&xll->bits, navi_pos, xll->bits.index)) < 0)
+        xll_err("Invalid NAVI checksum");
+    return ret;
 }
 
 static int parse_band_data(struct xll_decoder *xll)
@@ -972,15 +1073,24 @@
     if ((ret = parse_band_data(xll)) < 0)
         return ret;
     if ((ret = bits_seek(&xll->bits, xll->frame_size * 8)) < 0)
-        return ret;
+        xll_err("Read past end of frame");
+    return ret;
+}
 
-    return 0;
+static void clear_pbr(struct xll_decoder *xll)
+{
+    ta_free(xll->pbr_buffer);
+    xll->pbr_buffer = NULL;
+    xll->pbr_length = 0;
+    xll->pbr_delay = 0;
 }
 
 static int copy_to_pbr(struct xll_decoder *xll, uint8_t *data, size_t size, int delay)
 {
-    if (size > XLL_PBR_SIZE)
+    if (size > XLL_PBR_SIZE) {
+        xll_err("PBR smoothing buffer overflow");
         return -DCADEC_EINVAL;
+    }
     if (!(xll->pbr_buffer = ta_zalloc_size(xll, XLL_PBR_SIZE + DCADEC_BUFFER_PADDING)))
         return -DCADEC_ENOMEM;
     memcpy(xll->pbr_buffer, data, size);
@@ -996,8 +1106,10 @@
     // If XLL packet data didn't start with a sync word, we must have jumped
     // right into the middle of PBR smoothing period
     if (ret == -DCADEC_ENOSYNC && asset->xll_sync_present) {
-        if (asset->xll_sync_offset > size)
+        if (asset->xll_sync_offset > size) {
+            xll_err("Invalid sync word offset");
             return -DCADEC_EINVAL;
+        }
 
         // Skip to the next sync word in this packet
         data += asset->xll_sync_offset;
@@ -1037,6 +1149,7 @@
     assert(xll->pbr_length <= XLL_PBR_SIZE);
 
     if (size > XLL_PBR_SIZE - xll->pbr_length) {
+        xll_err("PBR smoothing buffer overflow");
         ret = -DCADEC_EINVAL;
         goto fail;
     }
@@ -1045,9 +1158,12 @@
     xll->pbr_length += size;
 
     // Respect decoding delay after synchronization error
-    if (xll->pbr_delay > 0)
-        if (--xll->pbr_delay > 0)
+    if (xll->pbr_delay > 0) {
+        if (--xll->pbr_delay > 0) {
+            xll_verbose("Waiting until decoding delay expires (%d)", xll->pbr_delay);
             return -DCADEC_ENOSYNC;
+        }
+    }
 
     if ((ret = parse_frame(xll, xll->pbr_buffer, xll->pbr_length, asset)) < 0)
         goto fail;
@@ -1059,7 +1175,7 @@
 
     if (xll->frame_size == xll->pbr_length) {
         // End of PBR smoothing period
-        xll_clear(xll);
+        clear_pbr(xll);
     } else {
         xll->pbr_length -= xll->frame_size;
         memmove(xll->pbr_buffer, xll->pbr_buffer + xll->frame_size, xll->pbr_length);
@@ -1070,10 +1186,20 @@
 fail:
     // For now, throw out all PBR state on failure.
     // Perhaps we can be smarter and try to at least resync.
-    xll_clear(xll);
+    clear_pbr(xll);
     return ret;
 }
 
+static void clear_chs(struct xll_decoder *xll)
+{
+    if (xll->chset) {
+        for_each_chset(xll, chs) {
+            chs->dmix_coeffs_signature = 0;
+            chs->dmix_coeffs_parity = false;
+        }
+    }
+}
+
 int xll_parse(struct xll_decoder *xll, uint8_t *data, size_t size, struct exss_asset *asset)
 {
     int ret;
@@ -1091,15 +1217,16 @@
     else
         ret = parse_frame_no_pbr(xll, data, size, asset);
 
+    if (ret < 0)
+        clear_chs(xll);
+
     return ret;
 }
 
 void xll_clear(struct xll_decoder *xll)
 {
     if (xll) {
-        ta_free(xll->pbr_buffer);
-        xll->pbr_buffer = NULL;
-        xll->pbr_length = 0;
-        xll->pbr_delay = 0;
+        clear_pbr(xll);
+        clear_chs(xll);
     }
 }

dcadec-20151114.57012a4.tar.xz/libdcadec/xll_decoder.h -> dcadec-0.1.0.tar.gz/libdcadec/xll_decoder.h Changed

@@ -30,14 +30,28 @@
 #define XLL_BAND_0  0
 #define XLL_BAND_1  1
 
+#define XLL_DMIX_SIGNATURE(chs) \
+    ((chs)->nchannels | ((chs)->dmix_m << 4) | ((chs)->primary_chset << 12) \
+     | ((chs)->dmix_embedded << 13) | ((chs)->hier_chset << 14) | ((chs)->dmix_type << 15))
+
 #define for_each_chset(xll, chs) \
     for (struct xll_chset *(chs) = (xll)->chset; \
          (chs) != &(xll)->chset[(xll)->nchsets]; (chs)++)
 
+#define for_each_chset_reverse(xll, chs) \
+    for (struct xll_chset *(chs) = &(xll)->chset[(xll)->nchsets - 1]; \
+         (chs) >= (xll)->chset; (chs)--)
+
 #define for_each_active_chset(xll, chs) \
     for (struct xll_chset *(chs) = (xll)->chset; \
          (chs) != &(xll)->chset[(xll)->nactivechsets]; (chs)++)
 
+#define xll_err(...)        dca_log(ERROR, xll, __VA_ARGS__)
+#define xll_verbose(...)    dca_log(VERBOSE, xll, __VA_ARGS__)
+
+#define xll_err_once(...)     dca_log_once(ERROR, xll, err_shown, __VA_ARGS__)
+#define xll_warn_once(...)    dca_log_once(WARNING, xll, warn_shown, __VA_ARGS__)
+
 struct xll_decoder;
 struct exss_asset;
 
@@ -59,8 +73,14 @@
     bool    hier_chset;
     int     dmix_m;
     int     *dmix_coeff;
-    int     *dmix_scale;
-    int     *dmix_scale_inv;
+    int     *dmix_coeff_cur;
+    int     *dmix_coeff_pre;
+    int     *dmix_scale_cur;
+    int     *dmix_scale_pre;
+    int     *dmix_scale_inv_cur;
+    int     *dmix_scale_inv_pre;
+    int     dmix_coeffs_signature;
+    bool    dmix_coeffs_parity;
     bool    ch_mask_enabled;
     int     ch_mask;
 
@@ -103,6 +123,11 @@
 struct xll_decoder {
     struct bitstream    bits;
 
+    dcadec_log_cb   log_cb;
+    void            *log_cbarg;
+    bool    err_shown;
+    bool    warn_shown;
+
     int     flags;
 
     size_t  frame_size;
@@ -110,6 +135,7 @@
     int     nframesegs;
     int     nsegsamples_log2;
     int     nsegsamples;
+    int     nframesamples_log2;
     int     nframesamples;
     int     seg_size_nbits;
     int     band_crc_present;

dcadec-20151114.57012a4.tar.xz/test/test.sh -> dcadec-0.1.0.tar.gz/test/test.sh Changed

dcadec-20151114.57012a4.tar.xz/test/samples/README Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/core_51_24_48_768_0.dtshd Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/core_51_24_48_768_1.dtshd Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/original Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/original/noise_24_48_0.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/original/noise_24_48_1.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/original/noise_24_48_2.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/original/noise_24_48_3.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/original/noise_24_48_4.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/original/noise_24_48_5.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/original/sine_16_192_0.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/original/sine_16_192_1.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/original/sine_16_192_2.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/original/sine_16_192_3.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/original/sine_24_48_0.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/original/sine_24_48_1.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/original/sine_24_48_2.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/original/sine_24_48_3.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/original/sine_24_48_4.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/original/sine_24_96_0.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/original/sine_24_96_1.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/original/sine_24_96_2.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/original/sine_24_96_3.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/original/sine_24_96_4.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/core_51_24_48_768_0_C.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/core_51_24_48_768_0_L.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/core_51_24_48_768_0_LFE.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/core_51_24_48_768_0_Ls.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/core_51_24_48_768_0_R.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/core_51_24_48_768_0_Rs.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/core_51_24_48_768_1_C.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/core_51_24_48_768_1_L.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/core_51_24_48_768_1_LFE.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/core_51_24_48_768_1_Ls.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/core_51_24_48_768_1_R.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/core_51_24_48_768_1_Rs.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/x96_51_24_96_1509_C.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/x96_51_24_96_1509_L.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/x96_51_24_96_1509_LFE.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/x96_51_24_96_1509_Ls.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/x96_51_24_96_1509_R.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/x96_51_24_96_1509_Rs.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/x96_xch_61_24_96_3840_C.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/x96_xch_61_24_96_3840_Cs.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/x96_xch_61_24_96_3840_L.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/x96_xch_61_24_96_3840_LFE.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/x96_xch_61_24_96_3840_Ls.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/x96_xch_61_24_96_3840_R.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/x96_xch_61_24_96_3840_Rs.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/x96_xxch_71_24_96_3840_C.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/x96_xxch_71_24_96_3840_L.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/x96_xxch_71_24_96_3840_LFE.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/x96_xxch_71_24_96_3840_Lsr.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/x96_xxch_71_24_96_3840_Lss.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/x96_xxch_71_24_96_3840_R.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/x96_xxch_71_24_96_3840_Rsr.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/x96_xxch_71_24_96_3840_Rss.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/xbr_51_24_48_3840_C.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/xbr_51_24_48_3840_L.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/xbr_51_24_48_3840_LFE.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/xbr_51_24_48_3840_Ls.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/xbr_51_24_48_3840_R.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/xbr_51_24_48_3840_Rs.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/xbr_xch_61_24_48_3840_C.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/xbr_xch_61_24_48_3840_Cs.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/xbr_xch_61_24_48_3840_L.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/xbr_xch_61_24_48_3840_LFE.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/xbr_xch_61_24_48_3840_Ls.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/xbr_xch_61_24_48_3840_R.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/xbr_xch_61_24_48_3840_Rs.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/xbr_xxch_71_24_48_3840_C.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/xbr_xxch_71_24_48_3840_L.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/xbr_xxch_71_24_48_3840_LFE.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/xbr_xxch_71_24_48_3840_Lsr.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/xbr_xxch_71_24_48_3840_Lss.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/xbr_xxch_71_24_48_3840_R.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/xbr_xxch_71_24_48_3840_Rsr.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/xbr_xxch_71_24_48_3840_Rss.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/xch_61_24_48_768_C.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/xch_61_24_48_768_Cs.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/xch_61_24_48_768_L.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/xch_61_24_48_768_LFE.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/xch_61_24_48_768_Ls.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/xch_61_24_48_768_R.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/xch_61_24_48_768_Rs.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/xll_51_16_192_768_0_C.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/xll_51_16_192_768_0_L.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/xll_51_16_192_768_0_LFE.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/xll_51_16_192_768_0_Ls.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/xll_51_16_192_768_0_R.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/xll_51_16_192_768_0_Rs.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/xll_51_16_192_768_1_C.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/xll_51_16_192_768_1_L.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/xll_51_16_192_768_1_LFE.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/xll_51_16_192_768_1_Ls.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/xll_51_16_192_768_1_R.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/xll_51_16_192_768_1_Rs.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/xll_51_24_48_768_C.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/xll_51_24_48_768_L.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/xll_51_24_48_768_LFE.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/xll_51_24_48_768_Ls.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/xll_51_24_48_768_R.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/xll_51_24_48_768_Rs.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/xll_51_24_48_none_C.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/xll_51_24_48_none_L.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/xll_51_24_48_none_LFE.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/xll_51_24_48_none_Ls.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/xll_51_24_48_none_R.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/xll_51_24_48_none_Rs.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/xll_71_24_48_768_0_C.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/xll_71_24_48_768_0_L.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/xll_71_24_48_768_0_LFE.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/xll_71_24_48_768_0_Lsr.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/xll_71_24_48_768_0_Lss.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/xll_71_24_48_768_0_R.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/xll_71_24_48_768_0_Rsr.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/xll_71_24_48_768_0_Rss.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/xll_71_24_48_768_1_C.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/xll_71_24_48_768_1_L.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/xll_71_24_48_768_1_LFE.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/xll_71_24_48_768_1_Lsr.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/xll_71_24_48_768_1_Lss.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/xll_71_24_48_768_1_R.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/xll_71_24_48_768_1_Rsr.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/xll_71_24_48_768_1_Rss.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/xll_71_24_96_768_C.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/xll_71_24_96_768_L.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/xll_71_24_96_768_LFE.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/xll_71_24_96_768_Lsr.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/xll_71_24_96_768_Lss.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/xll_71_24_96_768_R.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/xll_71_24_96_768_Rsr.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/xll_71_24_96_768_Rss.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/xll_x96_51_24_96_1509_C.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/xll_x96_51_24_96_1509_L.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/xll_x96_51_24_96_1509_LFE.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/xll_x96_51_24_96_1509_Ls.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/xll_x96_51_24_96_1509_R.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/xll_x96_51_24_96_1509_Rs.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/xll_xch_61_24_48_768_C.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/xll_xch_61_24_48_768_Cs.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/xll_xch_61_24_48_768_L.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/xll_xch_61_24_48_768_LFE.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/xll_xch_61_24_48_768_Ls.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/xll_xch_61_24_48_768_R.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/xll_xch_61_24_48_768_Rs.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/xxch_71_24_48_2046_C.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/xxch_71_24_48_2046_L.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/xxch_71_24_48_2046_LFE.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/xxch_71_24_48_2046_Lsr.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/xxch_71_24_48_2046_Lss.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/xxch_71_24_48_2046_R.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/xxch_71_24_48_2046_Rsr.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/reference/xxch_71_24_48_2046_Rss.wav Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/x96_51_24_96_1509.dtshd Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/x96_xch_61_24_96_3840.dtshd Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/x96_xxch_71_24_96_3840.dtshd Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/xbr_51_24_48_3840.dtshd Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/xbr_xch_61_24_48_3840.dtshd Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/xbr_xxch_71_24_48_3840.dtshd Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/xch_61_24_48_768.dtshd Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/xll_51_16_192_768_0.dtshd Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/xll_51_16_192_768_1.dtshd Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/xll_51_24_48_768.dtshd Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/xll_51_24_48_none.dtshd Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/xll_71_24_48_768_0.dtshd Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/xll_71_24_48_768_1.dtshd Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/xll_71_24_96_768.dtshd Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/xll_x96_51_24_96_1509.dtshd Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/xll_xch_61_24_48_768.dtshd Deleted

dcadec-20151114.57012a4.tar.xz/test/samples/xxch_71_24_48_2046.dtshd Deleted

Build Results
RPM Lint

Refresh

Comments for request 2245 0

Request History

Aloysius created request over 8 years ago

Update to stable (0.1.0) version and switched to shared library.

olh accepted request over 8 years ago