opencv
diff --git a/‎modules/imgcodecs/src/bitstrm.cpp
Copy file name to clipboard
+37-17Lines changed: 37 additions & 17 deletions b/‎modules/imgcodecs/src/bitstrm.cpp
Copy file name to clipboard
+37-17Lines changed: 37 additions & 17 deletions
diff --git a/‎modules/imgcodecs/src/bitstrm.hpp
Copy file name to clipboard
+13-7Lines changed: 13 additions & 7 deletions b/‎modules/imgcodecs/src/bitstrm.hpp
Copy file name to clipboard
+13-7Lines changed: 13 additions & 7 deletions
diff --git a/‎modules/imgcodecs/src/grfmt_bmp.cpp
Copy file name to clipboard
+20-18Lines changed: 20 additions & 18 deletions b/‎modules/imgcodecs/src/grfmt_bmp.cpp
Copy file name to clipboard
+20-18Lines changed: 20 additions & 18 deletions
diff --git a/‎modules/imgcodecs/src/grfmt_pfm.cpp
Copy file name to clipboard
+16-18Lines changed: 16 additions & 18 deletions b/‎modules/imgcodecs/src/grfmt_pfm.cpp
Copy file name to clipboard
+16-18Lines changed: 16 additions & 18 deletions
diff --git a/‎modules/imgcodecs/src/grfmt_pxm.cpp
Copy file name to clipboard
+4-4Lines changed: 4 additions & 4 deletions b/‎modules/imgcodecs/src/grfmt_pxm.cpp
Copy file name to clipboard
+4-4Lines changed: 4 additions & 4 deletions
@@ -377,26 +377,30 @@ void  WBaseStream::allocate()
 }
 
 
-void  WBaseStream::writeBlock()
+bool  WBaseStream::writeBlock()
 {
     int size = (int)(m_current - m_start);
 
     CV_Assert(isOpened());
     if( size == 0 )
-        return;
+        return true;
 
     if( m_buf )
     {
         size_t sz = m_buf->size();
         m_buf->resize( sz + size );
         memcpy( &(*m_buf)[sz], m_start, size );
+        m_current = m_start;
+        m_block_pos += size;
+        return true;
     }
     else
     {
-        fwrite( m_start, 1, size, m_file );
+        size_t written = fwrite( m_start, 1, size, m_file );
+        m_current = m_start;
+        m_block_pos += size;
+        return written == (size_t)size;
     }
-    m_current = m_start;
-    m_block_pos += size;
 }
 
 
@@ -463,15 +467,17 @@ WLByteStream::~WLByteStream()
 {
 }
 
-void WLByteStream::putByte( int val )
+bool  WLByteStream::putByte( int val )
 {
     *m_current++ = (uchar)val;
     if( m_current >= m_end )
-        writeBlock();
+        return writeBlock();
+
+    return true;
 }
 
 
-void WLByteStream::putBytes( const void* buffer, int count )
+bool  WLByteStream::putBytes( const void* buffer, int count )
 {
     uchar* data = (uchar*)buffer;
 
@@ -492,12 +498,18 @@ void WLByteStream::putBytes( const void* buffer, int count )
             count -= l;
         }
         if( m_current == m_end )
-            writeBlock();
+        {
+            bool written = writeBlock();
+            if (!written)
+                return false;
+        }
     }
+
+    return true;
 }
 
 
-void WLByteStream::putWord( int val )
+bool  WLByteStream::putWord( int val )
 {
     uchar *current = m_current;
 
@@ -507,17 +519,19 @@ void WLByteStream::putWord( int val )
         current[1] = (uchar)(val >> 8);
         m_current = current + 2;
         if( m_current == m_end )
-            writeBlock();
+            return writeBlock();
     }
     else
     {
         putByte(val);
         putByte(val >> 8);
     }
+
+    return true;
 }
 
 
-void WLByteStream::putDWord( int val )
+bool  WLByteStream::putDWord( int val )
 {
     uchar *current = m_current;
 
@@ -529,7 +543,7 @@ void WLByteStream::putDWord( int val )
         current[3] = (uchar)(val >> 24);
         m_current = current + 4;
         if( m_current == m_end )
-            writeBlock();
+            return writeBlock();
     }
     else
     {
@@ -538,6 +552,8 @@ void WLByteStream::putDWord( int val )
         putByte(val >> 16);
         putByte(val >> 24);
     }
+
+    return true;
 }
 
 
@@ -548,7 +564,7 @@ WMByteStream::~WMByteStream()
 }
 
 
-void WMByteStream::putWord( int val )
+bool  WMByteStream::putWord( int val )
 {
     uchar *current = m_current;
 
@@ -558,17 +574,19 @@ void WMByteStream::putWord( int val )
         current[1] = (uchar)val;
         m_current = current + 2;
         if( m_current == m_end )
-            writeBlock();
+            return writeBlock();
     }
     else
     {
         putByte(val >> 8);
         putByte(val);
     }
+
+    return true;
 }
 
 
-void WMByteStream::putDWord( int val )
+bool  WMByteStream::putDWord( int val )
 {
     uchar *current = m_current;
 
@@ -580,7 +598,7 @@ void WMByteStream::putDWord( int val )
         current[3] = (uchar)val;
         m_current = current + 4;
         if( m_current == m_end )
-            writeBlock();
+            return writeBlock();
     }
     else
     {
@@ -589,6 +607,8 @@ void WMByteStream::putDWord( int val )
         putByte(val >> 8);
         putByte(val);
     }
+
+    return true;
 }
 
 }
@@ -63,6 +63,12 @@ DECLARE_RBS_EXCEPTION(THROW_FORB)
 DECLARE_RBS_EXCEPTION(BAD_HEADER)
 #define RBS_BAD_HEADER RBS_BAD_HEADER_Exception(cv::Error::StsError, "Invalid header", CV_Func, __FILE__, __LINE__)
 
+#define CHECK_WRITE(action) \
+if (!action) \
+{ \
+    return false; \
+}
+
 typedef unsigned long ulong;
 
 // class RBaseStream - base class for other reading streams.
@@ -147,7 +153,7 @@ class WBaseStream
     bool    m_is_opened;
     std::vector<uchar>* m_buf;
 
-    virtual void  writeBlock();
+    virtual bool  writeBlock();
     virtual void  release();
     virtual void  allocate();
 };
@@ -160,10 +166,10 @@ class WLByteStream : public WBaseStream
 public:
     virtual ~WLByteStream();
 
-    void  putByte( int val );
-    void  putBytes( const void* buffer, int count );
-    void  putWord( int val );
-    void  putDWord( int val );
+    bool putByte( int val );
+    bool putBytes( const void* buffer, int count );
+    bool putWord( int val );
+    bool putDWord( int val );
 };
 
 
@@ -173,8 +179,8 @@ class WMByteStream : public WLByteStream
 {
 public:
     virtual ~WMByteStream();
-    void  putWord( int val );
-    void  putDWord( int val );
+    bool putWord( int val );
+    bool putDWord( int val );
 };
 
 inline unsigned BSWAP(unsigned v)
 
@@ -635,38 +635,40 @@ bool  BmpEncoder::write( const Mat& img, const std::vector<int>& )
         m_buf->reserve( alignSize(fileSize + 16, 256) );
 
     // write signature 'BM'
-    strm.putBytes( fmtSignBmp, (int)strlen(fmtSignBmp) );
+    CHECK_WRITE(strm.putBytes( fmtSignBmp, (int)strlen(fmtSignBmp) ));
 
     // write file header
-    strm.putDWord( validateToInt(fileSize) ); // file size
-    strm.putDWord( 0 );
-    strm.putDWord( headerSize );
+    CHECK_WRITE(strm.putDWord( validateToInt(fileSize) )); // file size
+    CHECK_WRITE(strm.putDWord( 0 ));
+    CHECK_WRITE(strm.putDWord( headerSize ));
 
     // write bitmap header
-    strm.putDWord( bitmapHeaderSize );
-    strm.putDWord( width );
-    strm.putDWord( height );
-    strm.putWord( 1 );
-    strm.putWord( channels << 3 );
-    strm.putDWord( BMP_RGB );
-    strm.putDWord( 0 );
-    strm.putDWord( 0 );
-    strm.putDWord( 0 );
-    strm.putDWord( 0 );
-    strm.putDWord( 0 );
+    CHECK_WRITE(strm.putDWord( bitmapHeaderSize ));
+    CHECK_WRITE(strm.putDWord( width ));
+    CHECK_WRITE(strm.putDWord( height ));
+    CHECK_WRITE(strm.putWord( 1 ));
+    CHECK_WRITE(strm.putWord( channels << 3 ));
+    CHECK_WRITE(strm.putDWord( BMP_RGB ));
+    CHECK_WRITE(strm.putDWord( 0 ));
+    CHECK_WRITE(strm.putDWord( 0 ));
+    CHECK_WRITE(strm.putDWord( 0 ));
+    CHECK_WRITE(strm.putDWord( 0 ));
+    CHECK_WRITE(strm.putDWord( 0 ));
 
     if( channels == 1 )
     {
         FillGrayPalette( palette, 8 );
-        strm.putBytes( palette, sizeof(palette));
+        CHECK_WRITE(strm.putBytes( palette, sizeof(palette)));
     }
 
     width *= channels;
     for( int y = height - 1; y >= 0; y-- )
     {
-        strm.putBytes( img.ptr(y), width );
+        CHECK_WRITE(strm.putBytes( img.ptr(y), width ));
         if( fileStep > width )
-            strm.putBytes( zeropad, fileStep - width );
+        {
+            CHECK_WRITE(strm.putBytes( zeropad, fileStep - width ));
+        }
     }
 
     strm.close();
 
@@ -64,11 +64,11 @@ T read_number(cv::RLByteStream& strm)
   return atoT<T>(str);
 }
 
-template<typename T> void write_anything(cv::WLByteStream& strm, const T& t)
+template<typename T> bool write_anything(cv::WLByteStream& strm, const T& t)
 {
   std::ostringstream ss;
   ss << t;
-  strm.putBytes(ss.str().c_str(), static_cast<int>(ss.str().size()));
+  return strm.putBytes(ss.str().c_str(), static_cast<int>(ss.str().size()));
 }
 
 }
@@ -206,33 +206,33 @@ bool PFMEncoder::write(const Mat& img, const std::vector<int>& params)
   }
 
   Mat float_img;
-  strm.putByte('P');
+  CHECK_WRITE(strm.putByte('P'));
   switch (img.channels()) {
   case 1:
-    strm.putByte('f');
+    CHECK_WRITE(strm.putByte('f'));
     img.convertTo(float_img, CV_32FC1);
     break;
   case 3:
-    strm.putByte('F');
+    CHECK_WRITE(strm.putByte('F'));
     img.convertTo(float_img, CV_32FC3);
     break;
   default:
     CV_Error(Error::StsBadArg, "Expected 1 or 3 channel image.");
   }
-  strm.putByte('\n');
+  CHECK_WRITE(strm.putByte('\n'));
 
 
-  write_anything(strm, float_img.cols);
-  strm.putByte(' ');
-  write_anything(strm, float_img.rows);
-  strm.putByte('\n');
+  CHECK_WRITE(write_anything(strm, float_img.cols));
+  CHECK_WRITE(strm.putByte(' '));
+  CHECK_WRITE(write_anything(strm, float_img.rows));
+  CHECK_WRITE(strm.putByte('\n'));
 #ifdef WORDS_BIGENDIAN
-  write_anything(strm, 1.0);
+  CHECK_WRITE(write_anything(strm, 1.0));
 #else
-  write_anything(strm, -1.0);
+  CHECK_WRITE(write_anything(strm, -1.0));
 #endif
 
-  strm.putByte('\n');
+  CHECK_WRITE(strm.putByte('\n'));
 
   // Comments are not officially supported in this file format.
   // write_anything(strm, "# Generated by OpenCV " CV_VERSION "\n");
@@ -248,17 +248,15 @@ bool PFMEncoder::write(const Mat& img, const std::vector<int>& params)
         rgb_row[x*3+1] = bgr_row[x*3+1];
         rgb_row[x*3+2] = bgr_row[x*3+0];
       }
-      strm.putBytes( reinterpret_cast<const uchar*>(rgb_row.data()),
-                     static_cast<int>(sizeof(float) * row_size) );
+      CHECK_WRITE(strm.putBytes( reinterpret_cast<const uchar*>(rgb_row.data()),
+                     static_cast<int>(sizeof(float) * row_size) ));
     } else if (float_img.channels() == 1) {
-      strm.putBytes(float_img.ptr(y), sizeof(float) * float_img.cols);
+      CHECK_WRITE(strm.putBytes(float_img.ptr(y), sizeof(float) * float_img.cols));
     }
   }
   return true;
 }
 
-
 }
 
-
 #endif // HAVE_IMGCODEC_PFM
@@ -479,7 +479,7 @@ bool PxMEncoder::write(const Mat& img, const std::vector<int>& params)
         header_sz += sz;
     }
 
-    strm.putBytes(buffer, header_sz);
+    CHECK_WRITE(strm.putBytes(buffer, header_sz));
 
     for( y = 0; y < height; y++ )
     {
@@ -512,7 +512,7 @@ bool PxMEncoder::write(const Mat& img, const std::vector<int>& params)
                 {
                     *ptr++ = byte;
                 }
-                strm.putBytes(buffer, (int)(ptr - buffer));
+                CHECK_WRITE(strm.putBytes(buffer, (int)(ptr - buffer)));
                 continue;
             }
 
@@ -539,7 +539,7 @@ bool PxMEncoder::write(const Mat& img, const std::vector<int>& params)
                 }
             }
 
-            strm.putBytes( (channels > 1 || depth > 8) ? buffer : (const char*)data, fileStep);
+            CHECK_WRITE(strm.putBytes( (channels > 1 || depth > 8) ? buffer : (const char*)data, fileStep));
         }
         else
         {
@@ -610,7 +610,7 @@ bool PxMEncoder::write(const Mat& img, const std::vector<int>& params)
 
             *ptr++ = '\n';
 
-            strm.putBytes( buffer, (int)(ptr - buffer) );
+            CHECK_WRITE(strm.putBytes( buffer, (int)(ptr - buffer) ));
         }
     }
Original file line number	Diff line number	Diff line change
`@@ -377,26 +377,30 @@ void WBaseStream::allocate()`
`377`	`377`	`}`
`378`	`378`
`379`	`379`
`380`		`-void WBaseStream::writeBlock()`
	`380`	`+bool WBaseStream::writeBlock()`
`381`	`381`	`{`
`382`	`382`	`int size = (int)(m_current - m_start);`
`383`	`383`
`384`	`384`	`CV_Assert(isOpened());`
`385`	`385`	`if( size == 0 )`
`386`		`- return;`
	`386`	`+ return true;`
`387`	`387`
`388`	`388`	`if( m_buf )`
`389`	`389`	`{`
`390`	`390`	`size_t sz = m_buf->size();`
`391`	`391`	`m_buf->resize( sz + size );`
`392`	`392`	`memcpy( &(*m_buf)[sz], m_start, size );`
	`393`	`+ m_current = m_start;`
	`394`	`+ m_block_pos += size;`
	`395`	`+ return true;`
`393`	`396`	`}`
`394`	`397`	`else`
`395`	`398`	`{`
`396`		`- fwrite( m_start, 1, size, m_file );`
	`399`	`+ size_t written = fwrite( m_start, 1, size, m_file );`
	`400`	`+ m_current = m_start;`
	`401`	`+ m_block_pos += size;`
	`402`	`+ return written == (size_t)size;`
`397`	`403`	`}`
`398`		`- m_current = m_start;`
`399`		`- m_block_pos += size;`
`400`	`404`	`}`
`401`	`405`
`402`	`406`
`@@ -463,15 +467,17 @@ WLByteStream::~WLByteStream()`
`463`	`467`	`{`
`464`	`468`	`}`
`465`	`469`
`466`		`-void WLByteStream::putByte( int val )`
	`470`	`+bool WLByteStream::putByte( int val )`
`467`	`471`	`{`
`468`	`472`	`*m_current++ = (uchar)val;`
`469`	`473`	`if( m_current >= m_end )`
`470`		`- writeBlock();`
	`474`	`+ return writeBlock();`
	`475`	`+`
	`476`	`+ return true;`
`471`	`477`	`}`
`472`	`478`
`473`	`479`
`474`		`-void WLByteStream::putBytes( const void* buffer, int count )`
	`480`	`+bool WLByteStream::putBytes( const void* buffer, int count )`
`475`	`481`	`{`
`476`	`482`	`uchar* data = (uchar*)buffer;`
`477`	`483`
`@@ -492,12 +498,18 @@ void WLByteStream::putBytes( const void* buffer, int count )`
`492`	`498`	`count -= l;`
`493`	`499`	`}`
`494`	`500`	`if( m_current == m_end )`
`495`		`- writeBlock();`
	`501`	`+ {`
	`502`	`+ bool written = writeBlock();`
	`503`	`+ if (!written)`
	`504`	`+ return false;`
	`505`	`+ }`
`496`	`506`	`}`
	`507`	`+`
	`508`	`+ return true;`
`497`	`509`	`}`
`498`	`510`
`499`	`511`
`500`		`-void WLByteStream::putWord( int val )`
	`512`	`+bool WLByteStream::putWord( int val )`
`501`	`513`	`{`
`502`	`514`	`uchar *current = m_current;`
`503`	`515`
`@@ -507,17 +519,19 @@ void WLByteStream::putWord( int val )`
`507`	`519`	`current[1] = (uchar)(val >> 8);`
`508`	`520`	`m_current = current + 2;`
`509`	`521`	`if( m_current == m_end )`
`510`		`- writeBlock();`
	`522`	`+ return writeBlock();`
`511`	`523`	`}`
`512`	`524`	`else`
`513`	`525`	`{`
`514`	`526`	`putByte(val);`
`515`	`527`	`putByte(val >> 8);`
`516`	`528`	`}`
	`529`	`+`
	`530`	`+ return true;`
`517`	`531`	`}`
`518`	`532`
`519`	`533`
`520`		`-void WLByteStream::putDWord( int val )`
	`534`	`+bool WLByteStream::putDWord( int val )`
`521`	`535`	`{`
`522`	`536`	`uchar *current = m_current;`
`523`	`537`
`@@ -529,7 +543,7 @@ void WLByteStream::putDWord( int val )`
`529`	`543`	`current[3] = (uchar)(val >> 24);`
`530`	`544`	`m_current = current + 4;`
`531`	`545`	`if( m_current == m_end )`
`532`		`- writeBlock();`
	`546`	`+ return writeBlock();`
`533`	`547`	`}`
`534`	`548`	`else`
`535`	`549`	`{`
`@@ -538,6 +552,8 @@ void WLByteStream::putDWord( int val )`
`538`	`552`	`putByte(val >> 16);`
`539`	`553`	`putByte(val >> 24);`
`540`	`554`	`}`
	`555`	`+`
	`556`	`+ return true;`
`541`	`557`	`}`
`542`	`558`
`543`	`559`
`@@ -548,7 +564,7 @@ WMByteStream::~WMByteStream()`
`548`	`564`	`}`
`549`	`565`
`550`	`566`
`551`		`-void WMByteStream::putWord( int val )`
	`567`	`+bool WMByteStream::putWord( int val )`
`552`	`568`	`{`
`553`	`569`	`uchar *current = m_current;`
`554`	`570`
`@@ -558,17 +574,19 @@ void WMByteStream::putWord( int val )`
`558`	`574`	`current[1] = (uchar)val;`
`559`	`575`	`m_current = current + 2;`
`560`	`576`	`if( m_current == m_end )`
`561`		`- writeBlock();`
	`577`	`+ return writeBlock();`
`562`	`578`	`}`
`563`	`579`	`else`
`564`	`580`	`{`
`565`	`581`	`putByte(val >> 8);`
`566`	`582`	`putByte(val);`
`567`	`583`	`}`
	`584`	`+`
	`585`	`+ return true;`
`568`	`586`	`}`
`569`	`587`
`570`	`588`
`571`		`-void WMByteStream::putDWord( int val )`
	`589`	`+bool WMByteStream::putDWord( int val )`
`572`	`590`	`{`
`573`	`591`	`uchar *current = m_current;`
`574`	`592`
`@@ -580,7 +598,7 @@ void WMByteStream::putDWord( int val )`
`580`	`598`	`current[3] = (uchar)val;`
`581`	`599`	`m_current = current + 4;`
`582`	`600`	`if( m_current == m_end )`
`583`		`- writeBlock();`
	`601`	`+ return writeBlock();`
`584`	`602`	`}`
`585`	`603`	`else`
`586`	`604`	`{`
`@@ -589,6 +607,8 @@ void WMByteStream::putDWord( int val )`
`589`	`607`	`putByte(val >> 8);`
`590`	`608`	`putByte(val);`
`591`	`609`	`}`
	`610`	`+`
	`611`	`+ return true;`
`592`	`612`	`}`
`593`	`613`
`594`	`614`	`}`
Original file line number	Diff line number	Diff line change
`@@ -479,7 +479,7 @@ bool PxMEncoder::write(const Mat& img, const std::vector<int>& params)`
`479`	`479`	`header_sz += sz;`
`480`	`480`	`}`
`481`	`481`
`482`		`- strm.putBytes(buffer, header_sz);`
	`482`	`+ CHECK_WRITE(strm.putBytes(buffer, header_sz));`
`483`	`483`
`484`	`484`	`for( y = 0; y < height; y++ )`
`485`	`485`	`{`
`@@ -512,7 +512,7 @@ bool PxMEncoder::write(const Mat& img, const std::vector<int>& params)`
`512`	`512`	`{`
`513`	`513`	`*ptr++ = byte;`
`514`	`514`	`}`
`515`		`- strm.putBytes(buffer, (int)(ptr - buffer));`
	`515`	`+ CHECK_WRITE(strm.putBytes(buffer, (int)(ptr - buffer)));`
`516`	`516`	`continue;`
`517`	`517`	`}`
`518`	`518`
`@@ -539,7 +539,7 @@ bool PxMEncoder::write(const Mat& img, const std::vector<int>& params)`
`539`	`539`	`}`
`540`	`540`	`}`
`541`	`541`
`542`		`- strm.putBytes( (channels > 1 \|\| depth > 8) ? buffer : (const char*)data, fileStep);`
	`542`	`+ CHECK_WRITE(strm.putBytes( (channels > 1 \|\| depth > 8) ? buffer : (const char*)data, fileStep));`
`543`	`543`	`}`
`544`	`544`	`else`
`545`	`545`	`{`
`@@ -610,7 +610,7 @@ bool PxMEncoder::write(const Mat& img, const std::vector<int>& params)`
`610`	`610`
`611`	`611`	`*ptr++ = '\n';`
`612`	`612`
`613`		`- strm.putBytes( buffer, (int)(ptr - buffer) );`
	`613`	`+ CHECK_WRITE(strm.putBytes( buffer, (int)(ptr - buffer) ));`
`614`	`614`	`}`
`615`	`615`	`}`
`616`	`616`