Merge pull request #26211 from Kumataro:fix26207

Kumataro · web-flow · commit 35dbf3222754 · 2024-10-18T14:44:55.000+03:00
imgcodecs: implement imencodemulti() #26211 Close #26207 ### Pull Request Readiness Checklist See details at https://github.com/opencv/opencv/wiki/How_to_contribute#making-a-good-pull-request - [x] I agree to contribute to the project under Apache 2 License. - [x] To the best of my knowledge, the proposed patch is not based on a code under GPL or another license that is incompatible with OpenCV - [x] The PR is proposed to the proper branch - [x] There is a reference to the original bug report and related work - [x] There is accuracy test, performance test and test data in opencv_extra repository, if applicable Patch to opencv_extra has the same branch name. - [x] The feature is well documented and sample code can be built with the project CMake
diff --git a/modules/imgcodecs/include/opencv2/imgcodecs.hpp b/modules/imgcodecs/include/opencv2/imgcodecs.hpp
@@ -405,14 +405,28 @@ The function imencode compresses the image and stores it in the memory buffer th
 result. See cv::imwrite for the list of supported formats and flags description.
 
 @param ext File extension that defines the output format. Must include a leading period.
-@param img Image to be written.
+@param img Image to be compressed.
 @param buf Output buffer resized to fit the compressed image.
 @param params Format-specific parameters. See cv::imwrite and cv::ImwriteFlags.
 */
 CV_EXPORTS_W bool imencode( const String& ext, InputArray img,
                             CV_OUT std::vector<uchar>& buf,
                             const std::vector<int>& params = std::vector<int>());
 
+/** @brief Encodes array of images into a memory buffer.
+
+The function is analog to cv::imencode for in-memory multi-page image compression.
+See cv::imwrite for the list of supported formats and flags description.
+
+@param ext File extension that defines the output format. Must include a leading period.
+@param imgs Vector of images to be written.
+@param buf Output buffer resized to fit the compressed data.
+@param params Format-specific parameters. See cv::imwrite and cv::ImwriteFlags.
+*/
+CV_EXPORTS_W bool imencodemulti( const String& ext, InputArrayOfArrays imgs,
+                                 CV_OUT std::vector<uchar>& buf,
+                                 const std::vector<int>& params = std::vector<int>());
+
 /** @brief Checks if the specified image file can be decoded by OpenCV.
 
 The function haveImageReader checks if OpenCV is capable of reading the specified file.
diff --git a/modules/imgcodecs/src/grfmt_tiff.cpp b/modules/imgcodecs/src/grfmt_tiff.cpp
@@ -171,7 +171,7 @@ class TiffDecoderBufHelper
         {
             n = size - pos;
         }
-        memcpy(buffer, buf.ptr() + pos, n);
+        std::memcpy(buffer, buf.ptr() + pos, n);
         helper->m_buf_pos += n;
         return n;
     }
@@ -848,9 +848,9 @@ bool  TiffDecoder::readData( Mat& img )
                                     switch ( convert_flag )
                                     {
                                     case MAKE_FLAG( 1, 1 ): // GRAY to GRAY
-                                        memcpy( (void*) img_line_buffer,
-                                                (void*) bstart,
-                                                tile_width * sizeof(uchar) );
+                                        std::memcpy( (void*) img_line_buffer,
+                                                     (void*) bstart,
+                                                     tile_width * sizeof(uchar) );
                                         break;
 
                                     case MAKE_FLAG( 1, 3 ): // GRAY to BGR
@@ -867,9 +867,9 @@ bool  TiffDecoder::readData( Mat& img )
 
                                     case MAKE_FLAG( 3, 3 ): // RGB to BGR
                                         if (m_use_rgb)
-                                            memcpy( (void*) img_line_buffer,
-                                                    (void*) bstart,
-                                                    tile_width * sizeof(uchar) );
+                                            std::memcpy( (void*) img_line_buffer,
+                                                         (void*) bstart,
+                                                         tile_width * sizeof(uchar) );
                                         else
                                             icvCvt_BGR2RGB_8u_C3R( bstart, 0,
                                                     img_line_buffer, 0,
@@ -979,7 +979,7 @@ bool  TiffDecoder::readData( Mat& img )
                                     {
                                         CV_CheckEQ(wanted_channels, 3, "");
                                         if (m_use_rgb)
-                                            memcpy(buffer16, img.ptr<ushort>(img_y + i, x), tile_width * sizeof(ushort));
+                                            std::memcpy(buffer16, img.ptr<ushort>(img_y + i, x), tile_width * sizeof(ushort));
                                         else
                                             icvCvt_RGB2BGR_16u_C3R(buffer16, 0,
                                                     img.ptr<ushort>(img_y + i, x), 0,
@@ -1011,9 +1011,9 @@ bool  TiffDecoder::readData( Mat& img )
                                     CV_CheckEQ(wanted_channels, 1, "");
                                     if( ncn == 1 )
                                     {
-                                        memcpy(img.ptr<ushort>(img_y + i, x),
-                                               buffer16,
-                                               tile_width*sizeof(ushort));
+                                        std::memcpy(img.ptr<ushort>(img_y + i, x),
+                                                    buffer16,
+                                                    tile_width*sizeof(ushort));
                                     }
                                     else
                                     {
@@ -1118,10 +1118,16 @@ class TiffEncoderBufHelper
                                /*map=*/0, /*unmap=*/0 );
     }
 
-    static tmsize_t read( thandle_t /*handle*/, void* /*buffer*/, tmsize_t /*n*/ )
+    static tmsize_t read( thandle_t handle, void* buffer, tmsize_t n )
     {
-        // Not used for encoding.
-        return 0;
+        // Used for imencodemulti() to stores multi-images.
+        TiffEncoderBufHelper *helper = reinterpret_cast<TiffEncoderBufHelper*>(handle);
+        size_t begin = (size_t)helper->m_buf_pos;
+        size_t end = begin + n;
+        CV_CheckGT( helper->m_buf->size(), end , "do not be over-run buffer");
+        std::memcpy(buffer, &(*helper->m_buf)[begin], n);
+        helper->m_buf_pos = end;
+        return n;
     }
 
     static tmsize_t write( thandle_t handle, void* buffer, tmsize_t n )
@@ -1133,7 +1139,7 @@ class TiffEncoderBufHelper
         {
             helper->m_buf->resize(end);
         }
-        memcpy(&(*helper->m_buf)[begin], buffer, n);
+        std::memcpy(&(*helper->m_buf)[begin], buffer, n);
         helper->m_buf_pos = end;
         return n;
     }
@@ -1350,7 +1356,7 @@ bool TiffEncoder::writeLibTiff( const std::vector<Mat>& img_vec, const std::vect
             {
                 case 1:
                 {
-                    memcpy(buffer, img.ptr(y), scanlineSize);
+                    std::memcpy(buffer, img.ptr(y), scanlineSize);
                     break;
                 }
 
diff --git a/modules/imgcodecs/src/loadsave.cpp b/modules/imgcodecs/src/loadsave.cpp
@@ -723,6 +723,7 @@ static bool imwrite_( const String& filename, const std::vector<Mat>& img_vec,
         Mat temp;
         if( !encoder->isFormatSupported(image.depth()) )
         {
+            CV_LOG_ONCE_WARNING(NULL, "Unsupported depth image for selected encoder is fallbacked to CV_8U.");
             CV_Assert( encoder->isFormatSupported(CV_8U) );
             image.convertTo( temp, CV_8U );
             image = temp;
@@ -787,10 +788,12 @@ static bool imwrite_( const String& filename, const std::vector<Mat>& img_vec,
     catch (const cv::Exception& e)
     {
         CV_LOG_ERROR(NULL, "imwrite_('" << filename << "'): can't write data: " << e.what());
+        code = false;
     }
     catch (...)
     {
         CV_LOG_ERROR(NULL, "imwrite_('" << filename << "'): can't write data: unknown exception");
+        code = false;
     }
 
     return code;
@@ -978,7 +981,7 @@ imdecodemulti_(const Mat& buf, int flags, std::vector<Mat>& mats, int start, int
 
     ImageDecoder decoder = findDecoder(buf_row);
     if (!decoder)
-        return 0;
+        return false;
 
     // Try to decode image by RGB instead of BGR.
     if (flags & IMREAD_COLOR_RGB && flags != IMREAD_UNCHANGED)
@@ -995,7 +998,7 @@ imdecodemulti_(const Mat& buf, int flags, std::vector<Mat>& mats, int start, int
         filename = tempfile();
         FILE* f = fopen(filename.c_str(), "wb");
         if (!f)
-            return 0;
+            return false;
         size_t bufSize = buf_row.total() * buf.elemSize();
         if (fwrite(buf_row.ptr(), 1, bufSize, f) != bufSize)
         {
@@ -1121,27 +1124,44 @@ bool imdecodemulti(InputArray _buf, int flags, CV_OUT std::vector<Mat>& mats, co
     }
 }
 
-bool imencode( const String& ext, InputArray _image,
+bool imencode( const String& ext, InputArray _img,
                std::vector<uchar>& buf, const std::vector<int>& params_ )
 {
     CV_TRACE_FUNCTION();
 
-    Mat image = _image.getMat();
-    CV_Assert(!image.empty());
-
-    int channels = image.channels();
-    CV_Assert( channels == 1 || channels == 3 || channels == 4 );
-
     ImageEncoder encoder = findEncoder( ext );
     if( !encoder )
         CV_Error( Error::StsError, "could not find encoder for the specified extension" );
 
-    if( !encoder->isFormatSupported(image.depth()) )
+    std::vector<Mat> img_vec;
+    CV_Assert(!_img.empty());
+    if (_img.isMatVector() || _img.isUMatVector())
+        _img.getMatVector(img_vec);
+    else
+        img_vec.push_back(_img.getMat());
+
+    CV_Assert(!img_vec.empty());
+    const bool isMultiImg = img_vec.size() > 1;
+
+    std::vector<Mat> write_vec;
+    for (size_t page = 0; page < img_vec.size(); page++)
     {
-        CV_Assert( encoder->isFormatSupported(CV_8U) );
+        Mat image = img_vec[page];
+        CV_Assert(!image.empty());
+
+        const int channels = image.channels();
+        CV_Assert( channels == 1 || channels == 3 || channels == 4 );
+
         Mat temp;
-        image.convertTo(temp, CV_8U);
-        image = temp;
+        if( !encoder->isFormatSupported(image.depth()) )
+        {
+            CV_LOG_ONCE_WARNING(NULL, "Unsupported depth image for selected encoder is fallbacked to CV_8U.");
+            CV_Assert( encoder->isFormatSupported(CV_8U) );
+            image.convertTo( temp, CV_8U );
+            image = temp;
+        }
+
+        write_vec.push_back(image);
     }
 
 #if CV_VERSION_MAJOR < 5 && defined(HAVE_IMGCODEC_HDR)
@@ -1166,23 +1186,37 @@ bool imencode( const String& ext, InputArray _image,
     CV_Check(params.size(), (params.size() & 1) == 0, "Encoding 'params' must be key-value pairs");
     CV_CheckLE(params.size(), (size_t)(CV_IO_MAX_IMAGE_PARAMS*2), "");
 
-    bool code;
-    if( encoder->setDestination(buf) )
-    {
-        code = encoder->write(image, params);
-        encoder->throwOnEror();
-        CV_Assert( code );
-    }
-    else
+    bool code = false;
+    String filename;
+    if( !encoder->setDestination(buf) )
     {
-        String filename = tempfile();
+        filename = tempfile();
         code = encoder->setDestination(filename);
         CV_Assert( code );
+    }
+
+    try {
+        if (!isMultiImg)
+            code = encoder->write(write_vec[0], params);
+        else
+            code = encoder->writemulti(write_vec, params);
 
-        code = encoder->write(image, params);
         encoder->throwOnEror();
         CV_Assert( code );
+    }
+    catch (const cv::Exception& e)
+    {
+        CV_LOG_ERROR(NULL, "imencode(): can't encode data: " << e.what());
+        code = false;
+    }
+    catch (...)
+    {
+        CV_LOG_ERROR(NULL, "imencode(): can't encode data: unknown exception");
+        code = false;
+    }
 
+    if( !filename.empty() && code )
+    {
         FILE* f = fopen( filename.c_str(), "rb" );
         CV_Assert(f != 0);
         fseek( f, 0, SEEK_END );
@@ -1196,6 +1230,12 @@ bool imencode( const String& ext, InputArray _image,
     return code;
 }
 
+bool imencodemulti( const String& ext, InputArrayOfArrays imgs,
+                    std::vector<uchar>& buf, const std::vector<int>& params)
+{
+    return imencode(ext, imgs, buf, params);
+}
+
 bool haveImageReader( const String& filename )
 {
     ImageDecoder decoder = cv::findDecoder(filename);
diff --git a/modules/imgcodecs/test/test_avif.cpp b/modules/imgcodecs/test/test_avif.cpp
@@ -161,14 +161,14 @@ TEST_P(Imgcodecs_Avif_Image_EncodeDecodeSuite, imencode_imdecode) {
 
   // Encode.
   std::vector<unsigned char> buf;
-  if (!IsBitDepthValid()) {
-    EXPECT_THROW(cv::imencode(".avif", img_original, buf, encoding_params_),
-                 cv::Exception);
-    return;
-  }
   bool result = true;
   EXPECT_NO_THROW(
       result = cv::imencode(".avif", img_original, buf, encoding_params_););
+
+  if (!IsBitDepthValid()) {
+    EXPECT_FALSE(result);
+    return;
+  }
   EXPECT_TRUE(result);
 
   // Read back.
diff --git a/modules/imgcodecs/test/test_exr.impl.hpp b/modules/imgcodecs/test/test_exr.impl.hpp
@@ -314,4 +314,27 @@ TEST(Imgcodecs_EXR, read_RGBA_unchanged)
     EXPECT_EQ(0, remove(filenameOutput.c_str()));
 }
 
+// See https://github.com/opencv/opencv/pull/26211
+// ( related with https://github.com/opencv/opencv/issues/26207 )
+TEST(Imgcodecs_EXR, imencode_regression_26207_extra)
+{
+    // CV_8U is not supported depth for EXR Encoder.
+    const cv::Mat src(100, 100, CV_8UC1, cv::Scalar::all(0));
+    std::vector<uchar> buf;
+    bool ret = false;
+    EXPECT_ANY_THROW(ret = imencode(".exr", src, buf));
+    EXPECT_FALSE(ret);
+}
+TEST(Imgcodecs_EXR, imwrite_regression_26207_extra)
+{
+    // CV_8U is not supported depth for EXR Encoder.
+    const cv::Mat src(100, 100, CV_8UC1, cv::Scalar::all(0));
+    const string filename = cv::tempfile(".exr");
+    bool ret = false;
+    EXPECT_ANY_THROW(ret = imwrite(filename, src));
+    EXPECT_FALSE(ret);
+    remove(filename.c_str());
+}
+
+
 }} // namespace
diff --git a/modules/imgcodecs/test/test_read_write.cpp b/modules/imgcodecs/test/test_read_write.cpp

Original file line number	Diff line number	Diff line change
`@@ -171,7 +171,7 @@ class TiffDecoderBufHelper`
`171`	`171`	`{`
`172`	`172`	`n = size - pos;`
`173`	`173`	`}`
`174`		`- memcpy(buffer, buf.ptr() + pos, n);`
	`174`	`+ std::memcpy(buffer, buf.ptr() + pos, n);`
`175`	`175`	`helper->m_buf_pos += n;`
`176`	`176`	`return n;`
`177`	`177`	`}`
`@@ -848,9 +848,9 @@ bool TiffDecoder::readData( Mat& img )`
`848`	`848`	`switch ( convert_flag )`
`849`	`849`	`{`
`850`	`850`	`case MAKE_FLAG( 1, 1 ): // GRAY to GRAY`
`851`		`- memcpy( (void*) img_line_buffer,`
`852`		`- (void*) bstart,`
`853`		`- tile_width * sizeof(uchar) );`
	`851`	`+ std::memcpy( (void*) img_line_buffer,`
	`852`	`+ (void*) bstart,`
	`853`	`+ tile_width * sizeof(uchar) );`
`854`	`854`	`break;`
`855`	`855`
`856`	`856`	`case MAKE_FLAG( 1, 3 ): // GRAY to BGR`
`@@ -867,9 +867,9 @@ bool TiffDecoder::readData( Mat& img )`
`867`	`867`
`868`	`868`	`case MAKE_FLAG( 3, 3 ): // RGB to BGR`
`869`	`869`	`if (m_use_rgb)`
`870`		`- memcpy( (void*) img_line_buffer,`
`871`		`- (void*) bstart,`
`872`		`- tile_width * sizeof(uchar) );`
	`870`	`+ std::memcpy( (void*) img_line_buffer,`
	`871`	`+ (void*) bstart,`
	`872`	`+ tile_width * sizeof(uchar) );`
`873`	`873`	`else`
`874`	`874`	`icvCvt_BGR2RGB_8u_C3R( bstart, 0,`
`875`	`875`	`img_line_buffer, 0,`
`@@ -979,7 +979,7 @@ bool TiffDecoder::readData( Mat& img )`
`979`	`979`	`{`
`980`	`980`	`CV_CheckEQ(wanted_channels, 3, "");`
`981`	`981`	`if (m_use_rgb)`
`982`		`- memcpy(buffer16, img.ptr<ushort>(img_y + i, x), tile_width * sizeof(ushort));`
	`982`	`+ std::memcpy(buffer16, img.ptr<ushort>(img_y + i, x), tile_width * sizeof(ushort));`
`983`	`983`	`else`
`984`	`984`	`icvCvt_RGB2BGR_16u_C3R(buffer16, 0,`
`985`	`985`	`img.ptr<ushort>(img_y + i, x), 0,`
`@@ -1011,9 +1011,9 @@ bool TiffDecoder::readData( Mat& img )`
`1011`	`1011`	`CV_CheckEQ(wanted_channels, 1, "");`
`1012`	`1012`	`if( ncn == 1 )`
`1013`	`1013`	`{`
`1014`		`- memcpy(img.ptr<ushort>(img_y + i, x),`
`1015`		`- buffer16,`
`1016`		`- tile_width*sizeof(ushort));`
	`1014`	`+ std::memcpy(img.ptr<ushort>(img_y + i, x),`
	`1015`	`+ buffer16,`
	`1016`	`+ tile_width*sizeof(ushort));`
`1017`	`1017`	`}`
`1018`	`1018`	`else`
`1019`	`1019`	`{`
`@@ -1118,10 +1118,16 @@ class TiffEncoderBufHelper`
`1118`	`1118`	`/map=/0, /unmap=/0 );`
`1119`	`1119`	`}`
`1120`	`1120`
`1121`		`- static tmsize_t read( thandle_t /handle/, void* /buffer/, tmsize_t /n/ )`
	`1121`	`+ static tmsize_t read( thandle_t handle, void* buffer, tmsize_t n )`
`1122`	`1122`	`{`
`1123`		`- // Not used for encoding.`
`1124`		`- return 0;`
	`1123`	`+ // Used for imencodemulti() to stores multi-images.`
	`1124`	`+ TiffEncoderBufHelper helper = reinterpret_cast<TiffEncoderBufHelper>(handle);`
	`1125`	`+ size_t begin = (size_t)helper->m_buf_pos;`
	`1126`	`+ size_t end = begin + n;`
	`1127`	`+ CV_CheckGT( helper->m_buf->size(), end , "do not be over-run buffer");`
	`1128`	`+ std::memcpy(buffer, &(*helper->m_buf)[begin], n);`
	`1129`	`+ helper->m_buf_pos = end;`
	`1130`	`+ return n;`
`1125`	`1131`	`}`
`1126`	`1132`
`1127`	`1133`	`static tmsize_t write( thandle_t handle, void* buffer, tmsize_t n )`
`@@ -1133,7 +1139,7 @@ class TiffEncoderBufHelper`
`1133`	`1139`	`{`
`1134`	`1140`	`helper->m_buf->resize(end);`
`1135`	`1141`	`}`
`1136`		`- memcpy(&(*helper->m_buf)[begin], buffer, n);`
	`1142`	`+ std::memcpy(&(*helper->m_buf)[begin], buffer, n);`
`1137`	`1143`	`helper->m_buf_pos = end;`
`1138`	`1144`	`return n;`
`1139`	`1145`	`}`
`@@ -1350,7 +1356,7 @@ bool TiffEncoder::writeLibTiff( const std::vector<Mat>& img_vec, const std::vect`
`1350`	`1356`	`{`
`1351`	`1357`	`case 1:`
`1352`	`1358`	`{`
`1353`		`- memcpy(buffer, img.ptr(y), scanlineSize);`
	`1359`	`+ std::memcpy(buffer, img.ptr(y), scanlineSize);`
`1354`	`1360`	`break;`
`1355`	`1361`	`}`
`1356`	`1362`