Hello, I believe there is a way to know if decoding succeeded or not.

there appears to be no (reliable) way to know if decoding succeeded,

Is this specification not enough to this requirements ?

https://docs.opencv.org/4.x/d4/da8/group__imgcodecs.html#ga26a67788faa58ade337f8d28ba0eb19e

The function imdecode reads an image from the specified buffer in the memory. If the buffer is too short or contains invalid data, the function returns an empty matrix ( Mat::data==NULL ).

In source code, following lines drops destination mat if decoding is failed,

Maybe we can determine it with mat.empty().

Mat src = imdecode(Mat(buf));
if(src.empty()){
  // decoding is failed.
}else{
  // decoding is succeeded.
}    

Hello @Kumataro, thank you for your comments.

Is this specification not enough to this requirements ?

That specification alone seems to be accurate, but do note that I'm interested in the overload of imdecode that allows me to pass dst, so that I can re-use memory that has already been allocated.

In source code, following lines drops destination mat if decoding is failed,

Yes, but not if we return from here or here or here.

Also do note that in my original post, I already mentioned as a third alternative solution that we do mat.release() in all these cases (and not only in the case that you point out).

Mat src = imdecode(Mat(buf));

Yes, this would work, but again do note that I'm interested in the overload of imdecode that allows me to pass dst, so that I can re-use memory that has already been allocated.

@reunanen Thank you for your comment, it is cleared.
I worry that more function overloading may confuse OpenCV users.
To keep back-compatibility, I suggests new idea to use cv::ImreadModes.(Extend 2nd idea).
I would be happy if you could include this as one of your options.

Mat imdecode( InputArray _buf, int flags, Mat* dst )
{
    CV_TRACE_FUNCTION();

    Mat buf = _buf.getMat(), img;
    dst = dst ? dst : &img;
-   imdecode_( buf, flags, *dst );
+   bool result = imdecode_( buf, flags, *dst );
+   if ( (result == false) && ( (flags & IMREAD_XXXX) != 0 )) 
+   {
+     return Mat() ;
+   }
    return *dst;
}

Hello, @reunanen

imdecode() extends with default-argument

We can extend imdecode() function using default-argument to keep backward compatibility for currently users.

diff --git a/modules/imgcodecs/include/opencv2/imgcodecs.hpp b/modules/imgcodecs/include/opencv2/imgcodecs.hpp
index 89bd6e1c1b..132df213c9 100644
--- a/modules/imgcodecs/include/opencv2/imgcodecs.hpp
+++ b/modules/imgcodecs/include/opencv2/imgcodecs.hpp
@@ -323,8 +323,10 @@ CV_EXPORTS_W Mat imdecode( InputArray buf, int flags );
 @param flags The same flags as in cv::imread, see cv::ImreadModes.
 @param dst The optional output placeholder for the decoded matrix. It can save the image
 reallocations when the function is called repeatedly for images of the same size.
+@param result if non-null, the decode result.
+@note When dst is not empty, dst will not be empty if failed. Refer result arguments.
 */
-CV_EXPORTS Mat imdecode( InputArray buf, int flags, Mat* dst);
+CV_EXPORTS Mat imdecode( InputArray buf, int flags, Mat* dst, bool* result = nullptr);

 /** @brief Reads a multi-page image from a buffer in memory.

diff --git a/modules/imgcodecs/src/loadsave.cpp b/modules/imgcodecs/src/loadsave.cpp
index 734f7b516c..93b6ffcde6 100644
--- a/modules/imgcodecs/src/loadsave.cpp
+++ b/modules/imgcodecs/src/loadsave.cpp
@@ -941,13 +941,17 @@ Mat imdecode( InputArray _buf, int flags )
     return img;
 }

-Mat imdecode( InputArray _buf, int flags, Mat* dst )
+Mat imdecode( InputArray _buf, int flags, Mat* dst, bool* result)
 {
     CV_TRACE_FUNCTION();

     Mat buf = _buf.getMat(), img;
     dst = dst ? dst : &img;
-    imdecode_( buf, flags, *dst );
+    bool decode_result = imdecode_( buf, flags, *dst );
+
+    if(result != nullptr) {
+        *result = decode_result;
+    }

     return *dst;
 }

Is this backward compatibility is necessary ?

Conventional users may use the previous image in memory because it does not become empty when decoding fails.

However, since no problems occur when decoding is successful, the impact is limited and has not been considered a problem until now.

These "backward compatibility" are "implementations that do not match the documentation", One aspect, it may not need to be maintained. Rather, it can be said that specifications and implementation should match.

I think the option to always return an empty Mat if decoding fails is less likely to cause problems.

I would like to leave the decision up to the maintainer.

Hello @Kumataro, thank you for your additional comments.

CV_EXPORTS Mat imdecode( InputArray buf, int flags, Mat* dst, bool* result = nullptr);

This is what I was thinking too (basically the first alternative solution in my original post), but I was worried about ABI compatibility. It's not an issue for me, though, but might be for some users? I do not know, so I decided to err on the side of caution.

@reunanen OpenCV core team discussed your issue and implemented alternative solution. The existing imdecode implementation was modified to not release user-provided buffer, if decoder was not successful. See #24929. See the test in mentioned PR. Closing the PR.

@asmorkalov : thank you, works for me!