Script 'mail_helper' called by obssrc
Hello community,

here is the log from the commit of package dr_libs for openSUSE:Factory checked 
in at 2025-12-08 11:55:30
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Comparing /work/SRC/openSUSE:Factory/dr_libs (Old)
 and      /work/SRC/openSUSE:Factory/.dr_libs.new.1939 (New)
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

Package is "dr_libs"

Mon Dec  8 11:55:30 2025 rev:2 rq:1321382 version:20251202

Changes:
--------
--- /work/SRC/openSUSE:Factory/dr_libs/dr_libs.changes  2025-09-30 
18:24:41.024634742 +0200
+++ /work/SRC/openSUSE:Factory/.dr_libs.new.1939/dr_libs.changes        
2025-12-08 11:56:26.383735163 +0100
@@ -1,0 +2,17 @@
+Sat Dec  6 18:29:04 UTC 2025 - Richard Rahl <[email protected]>
+
+- Update to version 20251202:
+  * dr_flac: Fix a warning about an assigned by unused variable
+  * dr_mp3: make drmp3_cpuid clang compatible
+  * dr_mp3: Reduce stack space usage during decoding
+  * dr_flac: Make picture metadata parsing more robust
+  * dr_flac: Add a new metadata data offset member for metadata parsing
+  * dr_flac: Make unknown metadata block parsing more robust
+  * dr_flac: Add a compile time option to skip allocation of picture data
+  * dr_mp3: Silence a warning with GCC 13
+  * dr_flac: Try fixing a compilation error with ARM
+  * dr_mp3: Fix an error with APE tag parsing
+  * Fix a compilation warning
+  * dr_flac: Improvements to drflac_open_and_read_pcm_frames_*() and family
+
+-------------------------------------------------------------------

Old:
----
  dr_libs-20250916.tar.gz

New:
----
  dr_libs-20251202.tar.gz

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

Other differences:
------------------
++++++ dr_libs.spec ++++++
--- /var/tmp/diff_new_pack.5KqRyl/_old  2025-12-08 11:56:26.955759128 +0100
+++ /var/tmp/diff_new_pack.5KqRyl/_new  2025-12-08 11:56:26.955759128 +0100
@@ -16,11 +16,11 @@
 #
 
 
-%define         flacversion 0.13.1
-%define         mp3version 0.7.1
-%define         wavversion 0.14.1
+%define         flacversion 0.13.2
+%define         mp3version 0.7.2
+%define         wavversion 0.14.2
 Name:           dr_libs
-Version:        20250916
+Version:        20251202
 Release:        0
 Summary:        Audio decoding libraries for C/C++, each in a single source 
file
 License:        MIT-0 OR Unlicense

++++++ dr_libs-20250916.tar.gz -> dr_libs-20251202.tar.gz ++++++
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' 
'--exclude=.svnignore' old/dr_libs-20250916/dr_flac.h 
new/dr_libs-20251202/dr_flac.h
--- old/dr_libs-20250916/dr_flac.h      2025-09-16 07:13:22.000000000 +0200
+++ new/dr_libs-20251202/dr_flac.h      2025-12-01 20:29:09.000000000 +0100
@@ -1,6 +1,6 @@
 /*
 FLAC audio decoder. Choice of public domain or MIT-0. See license statements 
at the end of this file.
-dr_flac - v0.13.2 - TBD
+dr_flac - v0.13.2 - 2025-12-02
 
 David Reid - [email protected]
 
@@ -2732,7 +2732,7 @@
 
                 return r;
             }
-        #elif defined(DRFLAC_ARM) && (defined(__ARM_ARCH) && __ARM_ARCH >= 5) 
&& !defined(__ARM_ARCH_6M__) && !defined(DRFLAC_64BIT)   /* <-- I haven't 
tested 64-bit inline assembly, so only enabling this for the 32-bit build for 
now. */
+        #elif defined(DRFLAC_ARM) && (defined(__ARM_ARCH) && __ARM_ARCH >= 5) 
&& !defined(__ARM_ARCH_6M__) && !(defined(__thumb__) && !defined(__thumb2__)) 
&& !defined(DRFLAC_64BIT)   /* <-- I haven't tested 64-bit inline assembly, so 
only enabling this for the 32-bit build for now. */
             {
                 unsigned int r;
                 __asm__ __volatile__ (
@@ -11798,58 +11798,43 @@
 {                                                                              
                                                                                
     \
     type* pSampleData = NULL;                                                  
                                                                                
     \
     drflac_uint64 totalPCMFrameCount;                                          
                                                                                
     \
+    type buffer[4096];                                                         
                                                                                
     \
+    drflac_uint64 pcmFramesRead;                                               
                                                                                
     \
+    size_t sampleDataBufferSize = sizeof(buffer);                              
                                                                                
     \
                                                                                
                                                                                
     \
     DRFLAC_ASSERT(pFlac != NULL);                                              
                                                                                
     \
                                                                                
                                                                                
     \
-    totalPCMFrameCount = pFlac->totalPCMFrameCount;                            
                                                                                
     \
+    totalPCMFrameCount = 0;                                                    
                                                                                
     \
                                                                                
                                                                                
     \
-    if (totalPCMFrameCount == 0) {                                             
                                                                                
     \
-        type buffer[4096];                                                     
                                                                                
     \
-        drflac_uint64 pcmFramesRead;                                           
                                                                                
     \
-        size_t sampleDataBufferSize = sizeof(buffer);                          
                                                                                
     \
-                                                                               
                                                                                
     \
-        pSampleData = 
(type*)drflac__malloc_from_callbacks(sampleDataBufferSize, 
&pFlac->allocationCallbacks);                                                   
   \
-        if (pSampleData == NULL) {                                             
                                                                                
     \
-            goto on_error;                                                     
                                                                                
     \
-        }                                                                      
                                                                                
     \
-                                                                               
                                                                                
     \
-        while ((pcmFramesRead = 
(drflac_uint64)drflac_read_pcm_frames_##extension(pFlac, 
sizeof(buffer)/sizeof(buffer[0])/pFlac->channels, buffer)) > 0) {          \
-            if (((totalPCMFrameCount + pcmFramesRead) * pFlac->channels * 
sizeof(type)) > sampleDataBufferSize) {                                         
          \
-                type* pNewSampleData;                                          
                                                                                
     \
-                size_t newSampleDataBufferSize;                                
                                                                                
     \
+    pSampleData = (type*)drflac__malloc_from_callbacks(sampleDataBufferSize, 
&pFlac->allocationCallbacks);                                                   
       \
+    if (pSampleData == NULL) {                                                 
                                                                                
     \
+        goto on_error;                                                         
                                                                                
     \
+    }                                                                          
                                                                                
     \
                                                                                
                                                                                
     \
-                newSampleDataBufferSize = sampleDataBufferSize * 2;            
                                                                                
     \
-                pNewSampleData = 
(type*)drflac__realloc_from_callbacks(pSampleData, newSampleDataBufferSize, 
sampleDataBufferSize, &pFlac->allocationCallbacks);    \
-                if (pNewSampleData == NULL) {                                  
                                                                                
     \
-                    drflac__free_from_callbacks(pSampleData, 
&pFlac->allocationCallbacks);                                                   
                       \
-                    goto on_error;                                             
                                                                                
     \
-                }                                                              
                                                                                
     \
+    while ((pcmFramesRead = 
(drflac_uint64)drflac_read_pcm_frames_##extension(pFlac, 
sizeof(buffer)/sizeof(buffer[0])/pFlac->channels, buffer)) > 0) {              \
+        if (((totalPCMFrameCount + pcmFramesRead) * pFlac->channels * 
sizeof(type)) > sampleDataBufferSize) {                                         
              \
+            type* pNewSampleData;                                              
                                                                                
     \
+            size_t newSampleDataBufferSize;                                    
                                                                                
     \
                                                                                
                                                                                
     \
-                sampleDataBufferSize = newSampleDataBufferSize;                
                                                                                
     \
-                pSampleData = pNewSampleData;                                  
                                                                                
     \
+            newSampleDataBufferSize = sampleDataBufferSize * 2;                
                                                                                
     \
+            pNewSampleData = 
(type*)drflac__realloc_from_callbacks(pSampleData, newSampleDataBufferSize, 
sampleDataBufferSize, &pFlac->allocationCallbacks);        \
+            if (pNewSampleData == NULL) {                                      
                                                                                
     \
+                drflac__free_from_callbacks(pSampleData, 
&pFlac->allocationCallbacks);                                                   
                           \
+                goto on_error;                                                 
                                                                                
     \
             }                                                                  
                                                                                
     \
                                                                                
                                                                                
     \
-            DRFLAC_COPY_MEMORY(pSampleData + 
(totalPCMFrameCount*pFlac->channels), buffer, 
(size_t)(pcmFramesRead*pFlac->channels*sizeof(type)));                   \
-            totalPCMFrameCount += pcmFramesRead;                               
                                                                                
     \
+            sampleDataBufferSize = newSampleDataBufferSize;                    
                                                                                
     \
+            pSampleData = pNewSampleData;                                      
                                                                                
     \
         }                                                                      
                                                                                
     \
                                                                                
                                                                                
     \
-        /* At this point everything should be decoded, but we just want to 
fill the unused part buffer with silence - need to                              
         \
-           protect those ears from random noise! */                            
                                                                                
     \
-        DRFLAC_ZERO_MEMORY(pSampleData + (totalPCMFrameCount*pFlac->channels), 
(size_t)(sampleDataBufferSize - 
totalPCMFrameCount*pFlac->channels*sizeof(type)));   \
-    } else {                                                                   
                                                                                
     \
-        drflac_uint64 dataSize = 
totalPCMFrameCount*pFlac->channels*sizeof(type);                                
                                                   \
-        if (dataSize > (drflac_uint64)DRFLAC_SIZE_MAX) {                       
                                                                                
     \
-            goto on_error;  /* The decoded data is too big. */                 
                                                                                
     \
-        }                                                                      
                                                                                
     \
-                                                                               
                                                                                
     \
-        pSampleData = (type*)drflac__malloc_from_callbacks((size_t)dataSize, 
&pFlac->allocationCallbacks);    /* <-- Safe cast as per the check above. */    
       \
-        if (pSampleData == NULL) {                                             
                                                                                
     \
-            goto on_error;                                                     
                                                                                
     \
-        }                                                                      
                                                                                
     \
-                                                                               
                                                                                
     \
-        totalPCMFrameCount = drflac_read_pcm_frames_##extension(pFlac, 
pFlac->totalPCMFrameCount, pSampleData);                                        
             \
+        DRFLAC_COPY_MEMORY(pSampleData + (totalPCMFrameCount*pFlac->channels), 
buffer, (size_t)(pcmFramesRead*pFlac->channels*sizeof(type)));                  
     \
+        totalPCMFrameCount += pcmFramesRead;                                   
                                                                                
     \
     }                                                                          
                                                                                
     \
                                                                                
                                                                                
     \
+    /* At this point everything should be decoded, but we just want to fill 
the unused part buffer with silence - need to                                   
        \
+       protect those ears from random noise! */                                
                                                                                
     \
+    DRFLAC_ZERO_MEMORY(pSampleData + (totalPCMFrameCount*pFlac->channels), 
(size_t)(sampleDataBufferSize - 
totalPCMFrameCount*pFlac->channels*sizeof(type)));       \
+                                                                               
                                                                                
     \
     if (sampleRateOut) *sampleRateOut = pFlac->sampleRate;                     
                                                                                
     \
     if (channelsOut) *channelsOut = pFlac->channels;                           
                                                                                
     \
     if (totalPCMFrameCountOut) *totalPCMFrameCountOut = totalPCMFrameCount;    
                                                                                
     \
@@ -12173,9 +12158,10 @@
 /*
 REVISION HISTORY
 ================
-v0.13.2 - TBD
+v0.13.2 - 2025-12-02
   - Improve robustness of the parsing of picture metadata to improve support 
for memory constrained embedded devices.
   - Fix a warning about an assigned by unused variable.
+  - Improvements to drflac_open_and_read_pcm_frames_*() and family to avoid 
excessively large memory allocations from malformed files.
 
 v0.13.1 - 2025-09-10
   - Fix an error with the NXDK build.
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' 
'--exclude=.svnignore' old/dr_libs-20250916/dr_mp3.h 
new/dr_libs-20251202/dr_mp3.h
--- old/dr_libs-20250916/dr_mp3.h       2025-09-16 07:13:22.000000000 +0200
+++ new/dr_libs-20251202/dr_mp3.h       2025-12-01 20:29:09.000000000 +0100
@@ -1,6 +1,6 @@
 /*
 MP3 audio decoder. Choice of public domain or MIT-0. See license statements at 
the end of this file.
-dr_mp3 - v0.7.2 - TBD
+dr_mp3 - v0.7.2 - 2025-12-02
 
 David Reid - [email protected]
 
@@ -1234,7 +1234,7 @@
 I've had reports of GCC 14 throwing an incorrect -Wstringop-overflow warning 
here. This is an attempt
 to silence this warning.
 */
-#if (defined(__GNUC__) && (__GNUC__ >= 14)) && !defined(__clang__)
+#if (defined(__GNUC__) && (__GNUC__ >= 13)) && !defined(__clang__)
     #pragma GCC diagnostic push
     #pragma GCC diagnostic ignored "-Wstringop-overflow"
 #endif
@@ -1299,7 +1299,7 @@
         scf[i] = drmp3_L3_ldexp_q2(gain, iscf[i] << scf_shift);
     }
 }
-#if (defined(__GNUC__) && (__GNUC__ >= 14)) && !defined(__clang__)
+#if (defined(__GNUC__) && (__GNUC__ >= 13)) && !defined(__clang__)
     #pragma GCC diagnostic pop
 #endif
 
@@ -3018,23 +3018,27 @@
                                 ((drmp3_uint32)ape[26] << 16) |
                                 ((drmp3_uint32)ape[27] << 24);
 
-                            streamEndOffset -= 32 + tagSize;
-                            streamLen       -= 32 + tagSize;
-                            
-                            /* Fire a metadata callback for the APE data. Must 
include both the main content and footer. */
-                            if (onMeta != NULL) {
-                                /* We first need to seek to the start of the 
APE tag. */
-                                if (onSeek(pUserData, streamEndOffset, 
DRMP3_SEEK_END)) {
-                                    size_t apeTagSize = (size_t)tagSize + 32;
-                                    drmp3_uint8* pTagData = 
(drmp3_uint8*)drmp3_malloc(apeTagSize, pAllocationCallbacks);
-                                    if (pTagData != NULL) {
-                                        if (onRead(pUserData, pTagData, 
apeTagSize) == apeTagSize) {
-                                            drmp3__on_meta(pMP3, 
DRMP3_METADATA_TYPE_APE, pTagData, apeTagSize);
-                                        }
+                            if (32 + tagSize < streamLen) {
+                                streamEndOffset -= 32 + tagSize;
+                                streamLen       -= 32 + tagSize;
+                                
+                                /* Fire a metadata callback for the APE data. 
Must include both the main content and footer. */
+                                if (onMeta != NULL) {
+                                    /* We first need to seek to the start of 
the APE tag. */
+                                    if (onSeek(pUserData, streamEndOffset, 
DRMP3_SEEK_END)) {
+                                        size_t apeTagSize = (size_t)tagSize + 
32;
+                                        drmp3_uint8* pTagData = 
(drmp3_uint8*)drmp3_malloc(apeTagSize, pAllocationCallbacks);
+                                        if (pTagData != NULL) {
+                                            if (onRead(pUserData, pTagData, 
apeTagSize) == apeTagSize) {
+                                                drmp3__on_meta(pMP3, 
DRMP3_METADATA_TYPE_APE, pTagData, apeTagSize);
+                                            }
 
-                                        drmp3_free(pTagData, 
pAllocationCallbacks);
+                                            drmp3_free(pTagData, 
pAllocationCallbacks);
+                                        }
                                     }
                                 }
+                            } else {
+                                /* The tag size is larger than the stream. 
Invalid APE tag. */
                             }
                         }
                     }
@@ -5001,9 +5005,10 @@
 /*
 REVISION HISTORY
 ================
-v0.7.2 - TBD
+v0.7.2 - 2025-12-02
   - Reduce stack space to improve robustness on embedded systems.
   - Fix a compilation error with MSVC Clang toolset relating to cpuid.
+  - Fix an error with APE tag parsing.
 
 v0.7.1 - 2025-09-10
   - Silence a warning with GCC.
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' 
'--exclude=.svnignore' old/dr_libs-20250916/dr_wav.h 
new/dr_libs-20251202/dr_wav.h
--- old/dr_libs-20250916/dr_wav.h       2025-09-16 07:13:22.000000000 +0200
+++ new/dr_libs-20251202/dr_wav.h       2025-12-01 20:29:09.000000000 +0100
@@ -1,6 +1,6 @@
 /*
 WAV audio loader and writer. Choice of public domain or MIT-0. See license 
statements at the end of this file.
-dr_wav - v0.14.1 - 2025-09-10
+dr_wav - v0.14.2 - 2025-12-02
 
 David Reid - [email protected]
 
@@ -147,7 +147,7 @@
 
 #define DRWAV_VERSION_MAJOR     0
 #define DRWAV_VERSION_MINOR     14
-#define DRWAV_VERSION_REVISION  1
+#define DRWAV_VERSION_REVISION  2
 #define DRWAV_VERSION_STRING    DRWAV_XSTRINGIFY(DRWAV_VERSION_MAJOR) "." 
DRWAV_XSTRINGIFY(DRWAV_VERSION_MINOR) "." 
DRWAV_XSTRINGIFY(DRWAV_VERSION_REVISION)
 
 #include <stddef.h> /* For size_t. */
@@ -5576,7 +5576,7 @@
         newCursor = (drwav_int64)pWav->memoryStreamWrite.dataSize;
     } else {
         DRWAV_ASSERT(!"Invalid seek origin");
-        return DRWAV_INVALID_ARGS;
+        return DRWAV_FALSE;
     }
 
     newCursor += offset;
@@ -8517,6 +8517,9 @@
 /*
 REVISION HISTORY
 ================
+v0.14.2 - 2025-12-02
+  - Fix a compilation warning.
+
 v0.14.1 - 2025-09-10
   - Fix an error with the NXDK build.
 

Reply via email to