catch nullptr in const char*

Author: schreibfaul1

src/Audio.cpp

@@ -5186,7 +5186,7 @@ void Audio::setDecoderItems() {
     setChannels(m_decoder->getChannels());
     setSampleRate(m_decoder->getSampleRate());
     setBitsPerSample(m_decoder->getBitsPerSample());
-    info(*this, evt_info, "%s", m_decoder->arg1());
+    if(m_decoder->arg1()) info(*this, evt_info, "%s", m_decoder->arg1());
 
     if (m_decoder->getAudioDataStart() > 0) { // only flac-ogg, native flac sets audioDataStart in readFlacHeader()
         m_audioDataStart = m_decoder->getAudioDataStart();

src/Audio.h

@@ -510,33 +510,27 @@ class Audio {
 
     // —————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————
   public:
-    template <typename T> static auto safe_arg(T&& v) -> decltype(auto) {
-        using U = std::decay_t<T>;
+    // 🎯 overload for char*-Pointer (maybe nullptr)
+    static const char* safe_arg(const char* v) { return v ? v : "(null)"; }
+    static char*       safe_arg(char* v) { return v ? v : (char*)"(null)"; }
 
-        // case 2: char arrays (string literals, fixed buffers)
-        if constexpr (std::is_array_v<U> && std::is_same_v<std::remove_cv_t<std::remove_extent_t<U>>, char>) {
-            return v; // Arrays sind niemals nullptr
-        }
-        // case 3: std::string
-        else if constexpr (std::is_same_v<U, std::string>) {
-            if (!v) v = (char*)"(null)";
-            return v.c_str();
-        }
-        // case 4: std::string_view
-        else if constexpr (std::is_same_v<U, std::string_view>) {
-            return v.data(); // Attention: not zero -terminated!
-        }
-        // default: everything else unchanged
-        else {
-            return std::forward<T>(v);
-        }
-    }
+    // 🎯 overload for char-Arrays (necer nullptr)
+    template <size_t N> static const char* safe_arg(const char (&v)[N]) { return v; }
+
+    // 🎯 overload for string
+    static const char* safe_arg(const std::string& v) { return v.c_str(); }
 
-    template <size_t N> static const char* safe_arg(const char (&v)[N]) {
-        // Arrays sind niemals null → direkter Pointer
-        return v;
+    // 🎯 overload for string_view
+    static const char* safe_arg(std::string_view v) {
+        return v.data(); // Achtung: evtl. nicht nullterminiert
     }
 
+    // 🎯 Catch-all for all other types
+    template <typename T> static auto safe_arg(T&& v) -> decltype(auto) { return std::forward<T>(v); }
+
+    // specialization für nullptr / NULL
+    static const char* safe_arg(std::nullptr_t) { return "(null)"; }
+
     template <typename... Args> static bool info(Audio& instance, event_t e, const char* fmt, Args&&... args) {
         std::lock_guard<std::mutex> lock(instance.mutex_info); // lock mutex
         // -------------------------------------------------------------------------------------------------------------------
@@ -557,7 +551,7 @@ class Audio {
             return -1; // no number found
         };
         // -------------------------------------------------------------------------------------------------------------------
-        if(!fmt) return false;
+        if (!fmt) return false;
         if (!audio_info_callback) return false;
         ps_ptr<char> result(__LINE__);
         // First run: determine size

src/flac_decoder/flac_decoder.cpp

@@ -110,7 +110,9 @@ const uint32_t mask[33] = {0x00000000, 0x00000001, 0x00000003, 0x00000007, 0x000
         uint8_t temp = *(m_flacInptr + m_rIndex);
         m_rIndex++;
         (*bytesLeft)--;
-        if(*bytesLeft < 0) { FLAC_LOG_ERROR("error in bitreader"); m_f_bitReaderError = true; break;}
+        if(*bytesLeft < 0) {
+            FLAC_LOG_ERROR("error in bitreader"); m_f_bitReaderError = true; break;
+        }
         m_flac_bitBuffer = (m_flac_bitBuffer << 8) | temp;
         m_flacBitBufferLen += 8;
     }
@@ -527,12 +529,13 @@ int32_t FlacDecoder::decode(uint8_t *inbuf, int32_t *bytesLeft, int16_t *outbuf)
 
     int32_t                ret = 0;
     uint32_t           segmLen = 0;
-    static uint32_t segmLenTmp = 0;
+
+    m_segmLenTmp = 0;
 
     if(m_f_flacFirstCall){ // determine if ogg or flag
         m_f_flacFirstCall = false;
         m_nBytes = 0;
-        segmLenTmp = 0;
+        m_segmLenTmp = 0;
         if(specialIndexOf(inbuf, "OggS", 5) == 0){
             m_f_oggWrapper = true;
             m_f_flacParseOgg = true;
@@ -541,16 +544,16 @@ int32_t FlacDecoder::decode(uint8_t *inbuf, int32_t *bytesLeft, int16_t *outbuf)
 
     if(m_f_oggWrapper){
 
-        if(segmLenTmp){ // can't skip more than 16K
-            if(segmLenTmp > FLAC_MAX_BLOCKSIZE){
+        if(m_segmLenTmp){ // can't skip more than 16K
+            if(m_segmLenTmp > FLAC_MAX_BLOCKSIZE){
                 m_flacCurrentFilePos += FLAC_MAX_BLOCKSIZE;
                 *bytesLeft -= FLAC_MAX_BLOCKSIZE;
-                segmLenTmp -= FLAC_MAX_BLOCKSIZE;
+                m_segmLenTmp -= FLAC_MAX_BLOCKSIZE;
             }
             else{
-                m_flacCurrentFilePos += segmLenTmp;
-                *bytesLeft -= segmLenTmp;
-                segmLenTmp  = 0;
+                m_flacCurrentFilePos += m_segmLenTmp;
+                *bytesLeft -= m_segmLenTmp;
+                m_segmLenTmp  = 0;
             }
             return FLAC_PARSE_OGG_DONE;
         }
@@ -628,7 +631,7 @@ int32_t FlacDecoder::decode(uint8_t *inbuf, int32_t *bytesLeft, int16_t *outbuf)
                 break;
         }
         if(segmLen > FLAC_MAX_BLOCKSIZE){
-            segmLenTmp = segmLen;
+            m_segmLenTmp = segmLen;
             return FLAC_PARSE_OGG_DONE;
         }
         *bytesLeft -= segmLen;
@@ -1024,5 +1027,5 @@ int32_t FlacDecoder::specialIndexOf(uint8_t* base, const char* str, int32_t base
     return result;
 }
 // —————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————
-const char* FlacDecoder::arg1() {return "";} // virtual method
+const char* FlacDecoder::arg1() {return nullptr;} // virtual method
 const char* FlacDecoder::arg2() {return "";} // virtual method

src/flac_decoder/flac_decoder.h

@@ -184,6 +184,7 @@ class FlacDecoder : public Decoder {
     uint32_t         m_flacBlockPicLen = 0;
     uint32_t         m_flacAudioDataStart = 0;
     int32_t          m_flacRemainBlockPicLen = 0;
+    uint32_t         m_segmLenTmp = 0;
     const uint16_t   m_flacOutBuffSize = 2048;
     uint16_t         m_numOfOutSamples = 0;
     uint16_t         m_flacValidSamples = 0;