Packman Build Service PMBS

avidemux3.changes Changed

avidemux3.spec Changed

avidemux2-2.8.2.git20260824.tar.xz/avidemux_plugins/ADM_demuxers/Matroska/ADM_mkv.cpp -> avidemux2-2.8.2.git20260826.tar.xz/avidemux_plugins/ADM_demuxers/Matroska/ADM_mkv.cpp Changed

avidemux2-2.8.2.git20260824.tar.xz/avidemux_plugins/ADM_demuxers/Matroska/ADM_mkv.h -> avidemux2-2.8.2.git20260826.tar.xz/avidemux_plugins/ADM_demuxers/Matroska/ADM_mkv.h Changed

@@ -169,7 +169,7 @@
 
     uint8_t                     goToBlock(uint32_t x);
     bool                        initLaces(uint32_t nbLaces,uint64_t time);
-     int              readAndRepeat(uint8_t *buffer, uint32_t len, uint32_t max)
+    uint32_t                    readAndRepeat(uint8_t *buffer, uint32_t len, uint32_t max)
                         {
                              uint32_t rpt=_track->headerRepeatSize;
                              if(rpt+len>max)
@@ -177,7 +177,8 @@
                                  ADM_error("Overflow in reading  mkv audio : %u (%u) max was %d\n",rpt+len,rpt,max);
                                  ADM_assert(0);
                                }
-                              _parser->readBin(buffer+rpt,len);
+                              if(len)
+                                _parser->readBin(buffer+rpt,len);
                               if(rpt)
                                 memcpy(buffer,_track->headerRepeat,rpt);
                               return len+rpt;
@@ -262,7 +263,7 @@
     void                    saveIndex(const std::string &idxName, uint64_t fileSize, bool overwrite);
     uint8_t                 indexClusters(ADM_ebml_file *parser);
     uint8_t                 indexLastCluster(ADM_ebml_file *parser);
-    uint8_t                 indexBlock(ADM_ebml_file *parser,uint32_t count,uint32_t timecodeMS);
+    uint8_t                 indexBlock(ADM_ebml_file *parser, uint64_t size, uint32_t timecodeMS);
 
     uint8_t                 rescaleTrack(mkvTrak *track,uint32_t durationMs);
 
@@ -287,14 +288,16 @@
 // AVI io
     virtual uint8_t  open(const char *name);
     virtual uint8_t  close(void) ;
-    int              readAndRepeat(int index,uint8_t *buffer, uint32_t len)
-                        {
-                             uint32_t rpt=_tracksindex.headerRepeatSize;
-                              _parser->readBin(buffer+rpt,len);
-                              if(rpt)
-                                memcpy(buffer,_tracksindex.headerRepeat,rpt);
-                              return len+rpt;
-                        }
+    uint32_t         readAndRepeat(int index, uint8_t *buffer, uint32_t len)
+                     {
+                        uint32_t rpt = _tracksindex.headerRepeatSize;
+                        ADM_assert((uint64_t)rpt + len <= UINT32_MAX);
+                        if (len)
+                            _parser->readBin(buffer+rpt,len);
+                        if (rpt)
+                            memcpy(buffer,_tracksindex.headerRepeat,rpt);
+                        return len+rpt;
+                     }
   //__________________________
   //  Info
   //__________________________
@@ -326,6 +329,6 @@
         // Temporary buffer for indexing
 private:
         uint8_t *readBuffer;
-        int     readBufferSize;
+        uint32_t readBufferSize;
 };
 #endif

avidemux2-2.8.2.git20260824.tar.xz/avidemux_plugins/ADM_demuxers/Matroska/ADM_mkvEntries.cpp -> avidemux2-2.8.2.git20260826.tar.xz/avidemux_plugins/ADM_demuxers/Matroska/ADM_mkvEntries.cpp Changed

@@ -712,14 +712,17 @@
         case MKV_LANGUAGE_IETF:
                 {
                  if(ietfLanguageTagFound) break;
-                 char s100;
-                 s99=0;
-                 father.readString(s,len);
+#define LANG_DESC_BUF_LEN 100
+                 char sLANG_DESC_BUF_LEN;
+                 sLANG_DESC_BUF_LEN - 1 = 0;
+                 uint64_t sublen = (len < LANG_DESC_BUF_LEN) ? len : LANG_DESC_BUF_LEN - 1;
+                 father.readString(s, sublen);
                  if(!strlen(s))
                      strcpy(s,"eng"); // english is default
                  if(!strcmp(s,"unknown")) // we were using "unknown", which is not a valid ISO 639 code
                  {
-                     memset(s,'\0',100);
+                     memset(s, 0, LANG_DESC_BUF_LEN);
+#undef LANG_DESC_BUF_LEN
                      std::string und=ADM_UNKNOWN_LANGUAGE;
                      strcpy(s,und.c_str());
                      ADM_info("Found 'unknown' as language code, replacing it with '%s'\n",und.c_str());

avidemux2-2.8.2.git20260824.tar.xz/avidemux_plugins/ADM_demuxers/Matroska/ADM_mkvIndexer.cpp -> avidemux2-2.8.2.git20260826.tar.xz/avidemux_plugins/ADM_demuxers/Matroska/ADM_mkvIndexer.cpp Changed

@@ -83,7 +83,7 @@
                 cluster.skip(len);
                 break;
             case MKV_SIMPLE_BLOCK:
-                indexBlock(parser,len,cdx->Dts);
+                res = indexBlock(parser,len,cdx->Dts);
                 break;
             case MKV_BLOCK_GROUP:
             {
@@ -107,13 +107,15 @@
                             break;
                         case MKV_BLOCK:
                         case MKV_SIMPLE_BLOCK:
-                            indexBlock(&blockGroup,len,cdx->Dts);
+                            res = indexBlock(&blockGroup,len,cdx->Dts);
                             break;
                     }
                 }
             }
             break; // Block Group
         }
+        if (!res)
+            break;
     }
     //printf("MKV ending cluster at 0x%" PRIx64"\n",parser->tell());
     return res;
@@ -122,7 +124,7 @@
       \fn indexBlock
       \brief index a block, identify it and update index
 */
-uint8_t mkvHeader::indexBlock(ADM_ebml_file *parser,uint32_t len,uint32_t clusterTimeCodeMs)
+uint8_t mkvHeader::indexBlock(ADM_ebml_file *parser, uint64_t len, uint32_t clusterTimeCodeMs)
 {
     uint64_t tail=parser->tell()+len;
     // Read Track id
@@ -145,9 +147,13 @@
 
     uint32_t entryFlags = (flags & 0x80)? AVI_KEY_FRAME : 0;
 
-    addIndexEntry(track,parser,blockBegin,tail-blockBegin,entryFlags,clusterTimeCodeMs+timecode);
+    uint8_t ret = 0;
+    if (tail - blockBegin > UINT32_MAX)
+        ADM_error("Block size %" PRIu64" exceeds max. supported, bailing out.\n", tail - blockBegin);
+    else
+        ret = addIndexEntry(track,parser,blockBegin,tail-blockBegin,entryFlags,clusterTimeCodeMs+timecode);
     parser->seek(tail);
-    return 1;
+    return ret;
 }
 /**
  *
@@ -199,24 +205,35 @@
     uint32_t rpt=_tracks0.headerRepeatSize;
     uint32_t frameNo = Track->index.size();
 
+    uint64_t want = (uint64_t)size + rpt;
+    if (want > UINT32_MAX)
+    {
+        ADM_error("Index entry size %" PRIu32" for track %" PRIu32" exceeds max. supported, bailing out.\n", size, track);
+        return 0;
+    }
+
     // expand buffer if needed
     if(size + rpt > readBufferSize)
     {
-        ADM_info("Expanding read buffer for frame %" PRIu32" of size %" PRIu32" in track %" PRIu32" from %" PRIu32" to %" PRIu32" bytes.\n",
-            frameNo, size, track, readBufferSize, rpt + size*2);
+        want = (uint64_t)size * 2 + rpt;
+        if (want > UINT32_MAX)
+            want = UINT32_MAX;
+        ADM_info("Expanding read buffer for frame %" PRIu32" of size %" PRIu32" in track %" PRIu32" from %" PRIu32" to %" PRIu64" bytes.\n",
+            frameNo, size, track, readBufferSize, want);
         delete  readBuffer;
-        readBufferSize = rpt + size*2;
+        readBufferSize = want & 0xFFFFFFFF;
         readBuffer=new uint8_treadBufferSize;
         memset(readBuffer,0,readBufferSize);
     }
     if(!track)
     {
         aprintf("adding image at 0x%llx , time = %d\n",where,timecodeMS);
-        if(Track->_needExtraData > 0 && (flags & AVI_KEY_FRAME))
+        if(Track->_needExtraData > 0 && (flags & AVI_KEY_FRAME) && size)
         {
             if(rpt)
                 memcpy(readBuffer,_tracks0.headerRepeat,rpt);
-            parser->readBin(readBuffer+rpt,size-3);
+            if(size > 3)
+                parser->readBin(readBuffer+rpt,size-3);
             uint8_t *dest = NULL;
             int l = ADM_extractVideoExtraData(_videostream.fccHandler, size, readBuffer, &dest);
             if(l < 0)
@@ -234,13 +251,14 @@
     // For the 2 most common cases : mp4 & h264.
     // Hackish, we already read the 3 bytes header
     // But they are already taken into account in the size part
-    if(!track && canRederiveFrameType(_videostream.fccHandler)) // Track 0 is video
+    if(!track && rpt + size > 3 && canRederiveFrameType(_videostream.fccHandler)) // Track 0 is video
     {
         if( isMpeg4Compatible(_videostream.fccHandler))
         {
             if(rpt)
                 memcpy(readBuffer,_tracks0.headerRepeat,rpt);
-            parser->readBin(readBuffer+rpt,size-3);
+            if(size > 3)
+                parser->readBin(readBuffer+rpt,size-3);
 
             // Search the frame type...
             uint32_t timeIncBits=0;
@@ -272,10 +290,11 @@
 
             if(rpt)
                 memcpy(readBuffer,_tracks0.headerRepeat,rpt);
-            parser->readBin(readBuffer+rpt,size-3);
+            if(size > 3)
+                parser->readBin(readBuffer+rpt,size-3);
             // Deal with Matroska files containing Annex-B type of H.264 stream
             bool AnnexB=false;
-            if(!_tracks0.extraDataLen && rpt+size > 3 && !readBuffer0 && !readBuffer1)
+            if(!_tracks0.extraDataLen && !readBuffer0 && !readBuffer1)
             {
                 uint32_t mark=(readBuffer2 << 8) + readBuffer3;
                 if(mark == 1 || (mark > 0xFF && mark < 0x200 && rpt+size-3 != mark+4))
@@ -379,11 +398,12 @@
 
             if(rpt)
                 memcpy(readBuffer,_tracks0.headerRepeat,rpt);
-            parser->readBin(readBuffer+rpt,size-3);
+            if(size > 3)
+                parser->readBin(readBuffer+rpt,size-3);
 
             // Deal with Matroska files containing Annex-B type of HEVC stream
             bool AnnexB=false;
-            if(!_tracks0.extraDataLen && rpt+size > 3 && !readBuffer0 && !readBuffer1)
+            if(!_tracks0.extraDataLen && !readBuffer0 && !readBuffer1)
             {
                 uint32_t mark=(readBuffer2 << 8) + readBuffer3;
                 if(mark == 1 || (mark > 0xFF && mark < 0x200 && rpt+size-3 != mark+4))
@@ -420,7 +440,8 @@
         {
             if(rpt)
                 memcpy(readBuffer,_tracks0.headerRepeat,rpt);
-            parser->readBin(readBuffer+rpt,size-3);
+            if(size > 3)
+                parser->readBin(readBuffer+rpt,size-3);
             uint8_t *begin=readBuffer;
             uint8_t *end=readBuffer+size-3+rpt;
             bool following=false;
@@ -493,7 +514,10 @@
             uint8_t *begin=readBuffer;
             uint8_t *end=readBuffer+size-3+rpt;
             int frameType;
-            if(ADM_VC1getFrameType(begin, (int)(end-begin),&frameType))
+            if(size + rpt > INT_MAX + 3)
+            {
+                ADM_warning("Index entry too large to determine VC1 frame type.\n");
+            } else if(ADM_VC1getFrameType(begin, (int)(end-begin), &frameType))
             {
                 ix.flags=frameType;
             }

avidemux2-2.8.2.git20260824.tar.xz/avidemux_plugins/ADM_demuxers/Matroska/ADM_mkv_audio.cpp -> avidemux2-2.8.2.git20260826.tar.xz/avidemux_plugins/ADM_demuxers/Matroska/ADM_mkv_audio.cpp Changed

@@ -21,6 +21,7 @@
 #include "ADM_dcainfo.h"
 
 #include "ADM_vidMisc.h"
+#include <climits>
 #if 0
 #define vprintf printf
 #else
@@ -244,7 +245,7 @@
     // Else we start a new lace (or no lacing at all)
     goToBlock(_currentBlock);
     mkvIndex *dex=&(_track->index_currentBlock);
-    uint64_t size=dex->size-3;
+    int64_t size = (dex->size > 3) ? dex->size - 3 : 0;
     uint64_t time=dex->Dts;
     if(!time && _currentBlock) time=ADM_AUDIO_NO_DTS;
     vprintf("MKV Time :%lu block:%u\n",time,_currentBlock);
@@ -283,7 +284,7 @@
                           size-=v;
                           _Lacesi=lce;
                         }
-
+                        ADM_assert(size > 0 && size < UINT32_MAX);
                         // The first one has Dts
                         *packlen= readAndRepeat(dest, _Laces0,maxSize);              
                         _LacesnbLaces-1=size;
@@ -297,6 +298,7 @@
                       {
                         int nbLaces=_parser->readu8()+1;
                         size--;
+                        ADM_assert(size > 0 && size / nbLaces < INT_MAX);
                         int bsize=size/nbLaces;
                         vprintf("NbLaces :%u lacesize:%u\n",nbLaces,bsize);
                         ADM_assert(nbLaces<MKV_MAX_LACES);
@@ -316,29 +318,29 @@
                 {
                         uint64_t head=_parser->tell();
                         int nbLaces=_parser->readu8()+1;
-                        int32_t curSize=_parser->readEBMCode();
-                        int32_t delta;
-                        uint32_t sum;
-
+                        uint64_t curSize = _parser->readEBMCode();
+                        int64_t delta;
+                        uint64_t sum;
 
-                        vprintf("Ebml nbLaces :%u lacesize(0):%u\n",nbLaces,curSize);
 
+                        vprintf("Ebml nbLaces :%u lacesize(0):%" PRIu64"\n",nbLaces,curSize);
+                        ADM_assert(curSize <= UINT32_MAX);
                         _Laces0=curSize;
                         sum=curSize;
                         ADM_assert(nbLaces<MKV_MAX_LACES);
                         for(int i=1;i<nbLaces-1;i++)
                         {
                           delta=_parser->readEBMCode_Signed();
-                          vprintf("Ebml delta :%d lacesize%d->:%d\n",delta,i,curSize+delta);
+                          vprintf("Ebml delta :%" PRId64" lacesize%d->:%" PRIu64"\n",delta,i,curSize+delta);
                           curSize+=delta;
-                          ADM_assert(curSize>0);
+                          ADM_assert(curSize > 0 && curSize <= UINT32_MAX);
                           _Lacesi=curSize;
                           sum+=curSize;
 
                         }
                         uint64_t tail=_parser->tell();
                         uint64_t consumed=head+size-tail;
-
+                        ADM_assert(consumed >= sum && consumed - sum <= UINT32_MAX);
                         _LacesnbLaces-1=consumed-sum;
 
                           // Take the 1st laces, it has timestamp

Changes of Revision 32