Merged revision(s) 24797 from trunk/OpenMPT:

[Var] Opus: Update to v1.6.1 (2026-01-14).
........


git-svn-id: https://source.openmpt.org/svn/openmpt/branches/OpenMPT-1.32@24798 56274372-70c3-4bfc-bfc3-4c3a0b034d27

Author: manxorist

include/opus/OpenMPT.txt

@@ -1,11 +1,5 @@
-libopus library version 1.6 (2025-12-15).
+libopus library version 1.6.1 (2026-01-15).
 The following changes have been made:
- *  Commits
-    <https://gitlab.xiph.org/xiph/opus/-/commit/ae5f6927893c752b43e56ab8f768759387959f14>,
-    <https://gitlab.xiph.org/xiph/opus/-/commit/206eeee0ebb3cccb67ff69e5afa5ef6ecf7e43d3>,
-    and
-    <https://gitlab.xiph.org/xiph/opus/-/commit/516feba5f56fb0682f9c7f727fda4b88e2be99b1>
-    have been applied.
  *  Obviously, unnecessary folders and files have been removed.
  *  celt/float_cast.h has been modified to compile on ARM64EC.
  *  celt/x86/vq_sse2.c has been modified to check for OPUS_X86_MAY_HAVE_SSE2.

include/opus/celt/_kiss_fft_guts.h

@@ -55,8 +55,8 @@
 #define SAMP_MIN -SAMP_MAX
 
 #ifdef ENABLE_QEXT
-#   define S_MUL(a,b) MULT32_32_P31(b, a)
-#   define S_MUL2(a,b) MULT32_32_P31(b, a)
+#   define S_MUL(a,b) MULT32_32_P31_ovflw(b, a)
+#   define S_MUL2(a,b) MULT32_32_P31_ovflw(b, a)
 #else
 #   define S_MUL(a,b) MULT16_32_Q15(b, a)
 #   define S_MUL2(a,b) MULT16_32_Q16(b, a)

include/opus/celt/arch.h

@@ -177,7 +177,6 @@ typedef opus_val16 opus_res;
 #endif
 
 #define RES2VAL16(a)    RES2INT16(a)
-#define FLOAT2SIG(a)    float2int(((opus_int32)32768<<SIG_SHIFT)*(a))
 #define INT16TOSIG(a)   SHL32(EXTEND32(a), SIG_SHIFT)
 #define INT24TOSIG(a)   SHL32(a, SIG_SHIFT-8)
 
@@ -348,6 +347,7 @@ static OPUS_INLINE int celt_isnan(float x)
 #define MULT32_32_Q16(a,b)     ((a)*(b))
 #define MULT32_32_Q31(a,b)     ((a)*(b))
 #define MULT32_32_P31(a,b)     ((a)*(b))
+#define MULT32_32_P31_ovflw(a,b) ((a)*(b))
 
 #define MAC16_32_Q15(c,a,b)     ((c)+(a)*(b))
 #define MAC16_32_Q16(c,a,b)     ((c)+(a)*(b))

include/opus/celt/celt.h

@@ -54,10 +54,6 @@
 #include "lpcnet.h"
 #endif
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
 #define CELTEncoder OpusCustomEncoder
 #define CELTDecoder OpusCustomDecoder
 #define CELTMode OpusCustomMode
@@ -275,8 +271,4 @@ void celt_synthesis(const CELTMode *mode, celt_norm *X, celt_sig * out_syn[],
 #define QEXT_SCALE2(x, qext_scale) (x)
 #endif
 
-#ifdef __cplusplus
-}
-#endif
-
 #endif /* CELT_H */

include/opus/celt/celt_encoder.c

@@ -595,6 +595,13 @@ void celt_preemphasis(const opus_res * OPUS_RESTRICT pcmp, celt_sig * OPUS_RESTR
       for (i=0;i<Nu;i++)
          inp[i*upsample] = MAX32(-65536.f, MIN32(65536.f,inp[i*upsample]));
    }
+#elif defined(ENABLE_RES24)
+   if (clip)
+   {
+      /* Clip input to avoid encoding non-portable files */
+      for (i=0;i<Nu;i++)
+         inp[i*upsample] = MAX32(-(65536<<SIG_SHIFT), MIN32(65536<<SIG_SHIFT,inp[i*upsample]));
+   }
 #else
    (void)clip; /* Avoids a warning about clip being unused. */
 #endif
@@ -1363,7 +1370,7 @@ static opus_val16 tone_detect(const celt_sig *in, int CC, int N, opus_val32 *ton
    ALLOC(x, N, opus_val16);
    /* Shift by SIG_SHIFT+2 (+3 for stereo) to account for HF gain of the preemphasis filter. */
    if (CC==2) {
-      for (i=0;i<N;i++) x[i] = PSHR32(ADD32(in[i], in[i+N]), SIG_SHIFT+3);
+      for (i=0;i<N;i++) x[i] = PSHR32(ADD32(SHR32(in[i], 1), SHR32(in[i+N], 1)), SIG_SHIFT+2);
    } else {
       for (i=0;i<N;i++) x[i] = PSHR32(in[i], SIG_SHIFT+2);
    }
@@ -2000,7 +2007,9 @@ int celt_encode_with_ec(CELTEncoder * OPUS_RESTRICT st, const opus_res * pcm, in
    }
    c=0; do {
       int need_clip=0;
-#ifndef FIXED_POINT
+#ifdef FIXED_POINT
+      need_clip = st->clip && sample_max>65536<<RES_SHIFT;
+#else
       need_clip = st->clip && sample_max>65536.f;
 #endif
       celt_preemphasis(pcm+c, in+c*(N+overlap)+overlap, N, CC, st->upsample,

include/opus/celt/fixed_debug.h

@@ -45,6 +45,7 @@ extern opus_int64 celt_mips;
 #define MULT16_16SU(a,b) ((opus_val32)(opus_val16)(a)*(opus_val32)(opus_uint16)(b))
 #define MULT32_32_Q31(a,b) ADD32(ADD32(SHL32(MULT16_16(SHR32((a),16),SHR((b),16)),1), SHR32(MULT16_16SU(SHR32((a),16),((b)&0x0000ffff)),15)), SHR32(MULT16_16SU(SHR32((b),16),((a)&0x0000ffff)),15))
 #define MULT32_32_P31(a,b) ADD32(SHL32(MULT16_16(SHR((a),16),SHR((b),16)),1), SHR32(128+(opus_int32)(MULT16_16U(((a)&0x0000ffff),((b)&0x0000ffff))>>(16+7)) + SHR32(MULT16_16SU(SHR((a),16),((b)&0x0000ffff)),7) + SHR32(MULT16_16SU(SHR((b),16),((a)&0x0000ffff)),7), 8) )
+#define MULT32_32_P31_ovflw(a,b) ADD32_ovflw(SHL32(MULT16_16(SHR((a),16),SHR((b),16)),1), SHR32(128+(opus_int32)(MULT16_16U(((a)&0x0000ffff),((b)&0x0000ffff))>>(16+7)) + SHR32(MULT16_16SU(SHR((a),16),((b)&0x0000ffff)),7) + SHR32(MULT16_16SU(SHR((b),16),((a)&0x0000ffff)),7), 8) )
 #define MULT32_32_Q32(a,b) ADD32(ADD32(MULT16_16(SHR((a),16),SHR((b),16)), SHR(MULT16_16SU(SHR((a),16),((b)&0x0000ffff)),16)), SHR(MULT16_16SU(SHR((b),16),((a)&0x0000ffff)),16))
 
 /** 16x32 multiplication, followed by a 16-bit shift right. Results fits in 32 bits */

include/opus/celt/fixed_generic.h

@@ -74,9 +74,11 @@
 /** 32x32 multiplication, followed by a 31-bit shift right (with rounding). Results fits in 32 bits */
 #if OPUS_FAST_INT64
 #define MULT32_32_P31(a,b) ((opus_val32)SHR(1073741824+(opus_int64)(a)*(opus_int64)(b),31))
+#define MULT32_32_P31_ovflw(a,b) MULT32_32_P31(a,b)
 #else
 #define MULT16_16U(a,b) ((opus_uint32)(a)*(opus_uint32)(b))
 #define MULT32_32_P31(a,b) ADD32(SHL(MULT16_16(SHR((a),16),SHR((b),16)),1), SHR32(128+(opus_int32)SHR(MULT16_16U(((a)&0x0000ffff),((b)&0x0000ffff)),16+7) + SHR32(MULT16_16SU(SHR((a),16),((b)&0x0000ffff)),7) + SHR32(MULT16_16SU(SHR((b),16),((a)&0x0000ffff)),7), 8) )
+#define MULT32_32_P31_ovflw(a,b) ADD32_ovflw(SHL(MULT16_16(SHR((a),16),SHR((b),16)),1), SHR32(128+(opus_int32)SHR(MULT16_16U(((a)&0x0000ffff),((b)&0x0000ffff)),16+7) + SHR32(MULT16_16SU(SHR((a),16),((b)&0x0000ffff)),7) + SHR32(MULT16_16SU(SHR((b),16),((a)&0x0000ffff)),7), 8) )
 #endif
 
 /** 32x32 multiplication, followed by a 32-bit shift right. Results fits in 32 bits */

include/opus/celt/float_cast.h

@@ -163,6 +163,15 @@ static OPUS_INLINE opus_int32 FLOAT2INT24(float x)
    x = MIN32(x, 16777216);
    return float2int(x);
 }
+#ifdef FIXED_POINT
+static OPUS_INLINE opus_int32 FLOAT2SIG(float x)
+{
+   x = x*((opus_int32)32768<<SIG_SHIFT);
+   x = MAX32(x, -(65536<<SIG_SHIFT));
+   x = MIN32(x, 65536<<SIG_SHIFT);
+   return float2int(x);
+}
+#endif
 #endif /* DISABLE_FLOAT_API */
 
 #endif /* FLOAT_CAST_H */

include/opus/celt/kiss_fft.h

@@ -34,10 +34,6 @@
 #include "arch.h"
 #include "cpu_support.h"
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
 #ifdef USE_SIMD
 # include <xmmintrin.h>
 # define kiss_fft_scalar __m128
@@ -210,8 +206,4 @@ extern void (*const OPUS_IFFT[OPUS_ARCHMASK+1])(const kiss_fft_state *cfg,
 #endif /* end if defined(OPUS_HAVE_RTCD) && (defined(HAVE_ARM_NE10)) */
 #endif /* end if !defined(OVERRIDE_OPUS_FFT) */
 
-#ifdef __cplusplus
-}
-#endif
-
 #endif

include/opus/celt/stack_alloc.h

@@ -123,6 +123,25 @@ extern char *global_stack;
 extern char *scratch_ptr;
 #endif /* CELT_C */
 
+#if __STDC_VERSION__ >= 201112L
+#  include <stdalign.h>
+#  define ALIGNOF(T) alignof(T)
+#elif defined(__GNUC__) || defined(__clang__)
+#  define ALIGNOF(T) __alignof__(T)
+#else
+# include <stddef.h>
+# ifdef __cplusplus
+template <typename T>
+struct alignment_helper {
+    char c;
+    T member;
+};
+# define ALIGNOF(T) (offsetof(alignment_helper<T>, member))
+# else
+# define ALIGNOF(T) (offsetof(struct { char c; T member; }, member))
+# endif
+#endif
+
 #ifdef ENABLE_VALGRIND
 
 #include <valgrind/memcheck.h>
@@ -134,26 +153,26 @@ extern char *global_stack_top;
 #endif /* CELT_C */
 
 #define ALIGN(stack, size) ((stack) += ((size) - (long)(stack)) & ((size) - 1))
-#define PUSH(stack, size, type) (VALGRIND_MAKE_MEM_NOACCESS(stack, global_stack_top-stack),ALIGN((stack),sizeof(type)/sizeof(char)),VALGRIND_MAKE_MEM_UNDEFINED(stack, ((size)*sizeof(type)/sizeof(char))),(stack)+=(2*(size)*sizeof(type)/sizeof(char)),(type*)((stack)-(2*(size)*sizeof(type)/sizeof(char))))
+#define PUSH(stack, size, type) (VALGRIND_MAKE_MEM_NOACCESS(stack, global_stack_top-stack),ALIGN((stack),ALIGNOF(type)),VALGRIND_MAKE_MEM_UNDEFINED(stack, ((size)*sizeof(type)/sizeof(char))),(stack)+=(2*(size)*sizeof(type)/sizeof(char)),(type*)((stack)-(2*(size)*sizeof(type)/sizeof(char))))
 #define RESTORE_STACK ((global_stack = _saved_stack),VALGRIND_MAKE_MEM_NOACCESS(global_stack, global_stack_top-global_stack))
-#define ALLOC_STACK char *_saved_stack; ((global_stack = (global_stack==0) ? ((global_stack_top=opus_alloc_scratch(GLOBAL_STACK_SIZE*2)+(GLOBAL_STACK_SIZE*2))-(GLOBAL_STACK_SIZE*2)) : global_stack),VALGRIND_MAKE_MEM_NOACCESS(global_stack, global_stack_top-global_stack)); _saved_stack = global_stack;
+#define ALLOC_STACK char *_saved_stack; ((global_stack = (global_stack==0) ? ((global_stack_top=(char*)opus_alloc_scratch(GLOBAL_STACK_SIZE*2)+(GLOBAL_STACK_SIZE*2))-(GLOBAL_STACK_SIZE*2)) : global_stack),VALGRIND_MAKE_MEM_NOACCESS(global_stack, global_stack_top-global_stack)); _saved_stack = global_stack;
 
 #else
 
 #define ALIGN(stack, size) ((stack) += ((size) - (long)(stack)) & ((size) - 1))
 #ifdef ENABLE_HARDENING
 #include "arch.h"
-#define PUSH(stack, size, type) (ALIGN((stack),sizeof(type)/(sizeof(char))),(void)(((int)((size)*(sizeof(type)/(sizeof(char)))) <= (scratch_ptr)+GLOBAL_STACK_SIZE-(stack))?0:CELT_FATAL("pseudostack overflow")),(stack)+=(size)*(sizeof(type)/(sizeof(char))),(type*)(void*)((stack)-(size)*(sizeof(type)/(sizeof(char)))))
+#define PUSH(stack, size, type) (ALIGN((stack),ALIGNOF(type)),(void)(((int)((size)*(sizeof(type)/(sizeof(char)))) <= (scratch_ptr)+GLOBAL_STACK_SIZE-(stack))?0:CELT_FATAL("pseudostack overflow")),(stack)+=(size)*(sizeof(type)/(sizeof(char))),(type*)(void*)((stack)-(size)*(sizeof(type)/(sizeof(char)))))
 #else
-#define PUSH(stack, size, type) (ALIGN((stack),sizeof(type)/(sizeof(char))),(stack)+=(size)*(sizeof(type)/(sizeof(char))),(type*)(void*)((stack)-(size)*(sizeof(type)/(sizeof(char)))))
+#define PUSH(stack, size, type) (ALIGN((stack),ALIGNOF(type)),(stack)+=(size)*(sizeof(type)/(sizeof(char))),(type*)(void*)((stack)-(size)*(sizeof(type)/(sizeof(char)))))
 #endif
 
 #if 0 /* Set this to 1 to instrument pseudostack usage */
 #define RESTORE_STACK (printf("%ld %s:%d\n", global_stack-scratch_ptr, __FILE__, __LINE__),global_stack = _saved_stack)
 #else
 #define RESTORE_STACK (global_stack = _saved_stack)
 #endif
-#define ALLOC_STACK char *_saved_stack; (global_stack = (global_stack==0) ? (scratch_ptr=opus_alloc_scratch(GLOBAL_STACK_SIZE)) : global_stack); _saved_stack = global_stack;
+#define ALLOC_STACK char *_saved_stack; (global_stack = (global_stack==0) ? (scratch_ptr=(char*)opus_alloc_scratch(GLOBAL_STACK_SIZE)) : global_stack); _saved_stack = global_stack;
 
 #endif /* ENABLE_VALGRIND */