Imdecode source code interpretation

Connected to a imencode Source code interpretation , Simply write a code comment

static bool
imdecode_( const Mat& buf, int flags, Mat& mat )
{
    
    //  Whether the picture is empty 
    CV_Assert(!buf.empty());
    //  Whether the incoming pictures are continuous , Here's a concept , The continuity of the image 
    /* isContinue You can check whether the picture is continuous in memory ,  Such as through rect tailoring , Although the returned image seems to have been cropped in form ,  But like a deep copy , The problem of shallow copy , The clipping in the above way is only a shallow copy , Not continuous in memory  */
    CV_Assert(buf.isContinuous());
    /*  Check this Mat Is it Vector, Used to confirm whether the incoming data format is correct . */
    CV_Assert(buf.checkVector(1, CV_8U) > 0);
    /*  Convert to single line ,reshape  Logically change the number of channels and rows of the matrix ,  But there is actually no data replication , And data increase and decrease  */
    Mat buf_row = buf.reshape(1, 1);  // decoders expects single row, avoid issues with vector columns

    String filename;
    //  It's also a factory model , Find the decoder 
    ImageDecoder decoder = findDecoder(buf_row);
    if( !decoder )
        //  No suitable decoder ,
        return 0;

    //  Check whether the decoder supports in memory decoding 
    //  If not , You need to create a temporary file to store the decoded file 
    if( !decoder->setSource(buf_row) )
    {
    
        //  Decoding in memory is not supported 
        //  Create temporary file 
        filename = tempfile();
        //  Write binary 
        FILE* f = fopen( filename.c_str(), "wb" );
        //  Whether the file was successfully opened 
        if( !f )
            return 0;
        //  Returns the total number of elements of the matrix  *  The data size of each element in the matrix 
        size_t bufSize = buf_row.total()*buf.elemSize();
        //  Write picture cache 
        if (fwrite(buf_row.ptr(), 1, bufSize, f) != bufSize)
        {
    
            //  Write failure , Close file 
            fclose( f );
            CV_Error( Error::StsError, "failed to write image data to temporary file" );
        }
        //  After writing , Close file 
        if( fclose(f) != 0 )
        {
    
            //  Failed to close file 
            CV_Error( Error::StsError, "failed to write image data to temporary file" );
        }
        //  Set decoding source file 
        decoder->setSource(filename);
    }
    //  Whether decoding is successful flag bit 
    bool success = false;
    try
    {
    
        //  Read file header 
        if (decoder->readHeader())
            success = true;
    }
    catch (const cv::Exception& e)
    {
    
        std::cerr << "imdecode_('" << filename << "'): can't read header: " << e.what() << std::endl << std::flush;
    }
    catch (...)
    {
    
        std::cerr << "imdecode_('" << filename << "'): can't read header: unknown exception" << std::endl << std::flush;
    }
    //  Decoding failed ,
    if (!success)
    {
    
        //  Release decoder 
        decoder.release();
        //  Check if the file is empty 
        if (!filename.empty())
        {
    
            //  Delete file 
            if (0 != remove(filename.c_str()))
            {
    
                std::cerr << "unable to remove temporary file:" << filename << std::endl << std::flush;
            }
        }
        return 0;
    }

    // established the required input image size
    //  Check if it is a valid picture size 
    Size size = validateInputImageSize(Size(decoder->width(), decoder->height()));
    
    //  Get picture type 
    int type = decoder->type();
    if( (flags & IMREAD_LOAD_GDAL) != IMREAD_LOAD_GDAL && flags != IMREAD_UNCHANGED )
    {
    
        if( (flags & IMREAD_ANYDEPTH) == 0 )
            type = CV_MAKETYPE(CV_8U, CV_MAT_CN(type));

        if( (flags & IMREAD_COLOR) != 0 ||
           ((flags & IMREAD_ANYCOLOR) != 0 && CV_MAT_CN(type) > 1) )
            type = CV_MAKETYPE(CV_MAT_DEPTH(type), 3);
        else
            type = CV_MAKETYPE(CV_MAT_DEPTH(type), 1);
    }
    //  Create an empty picture 
    mat.create( size.height, size.width, type );
    
    success = false;
    try
    {
    
        //  Write the decoded file into the blank picture 
        if (decoder->readData(mat))
            success = true;
    }
    catch (const cv::Exception& e)
    {
    
        std::cerr << "imdecode_('" << filename << "'): can't read data: " << e.what() << std::endl << std::flush;
    }
    catch (...)
    {
    
        std::cerr << "imdecode_('" << filename << "'): can't read data: unknown exception" << std::endl << std::flush;
    }
    //  Release decoder 
    decoder.release();
    //  Does the file exist 
    if (!filename.empty())
    {
    
        //  Delete file 
        if (0 != remove(filename.c_str()))
        {
    
            std::cerr << "unable to remove temporary file:" << filename << std::endl << std::flush;
        }
    }

    if (!success)
    {
    
        //  Decoding failed , Release picture 
        mat.release();
        return false;
    }

    return true;
}