VDEC

// 1. Create a callback function.
void callback(acldvppStreamDesc *input, acldvppPicDesc *output, void *userdata)
{
    static int count = 1;
    if (output != nullptr) {
        //Obtain the VDEC output buffer, call the user-defined function WriteToFile to write output buffer data to a file, and then call acldvppFree to free the output buffer.
        void *vdecOutBufferDev = acldvppGetPicDescData(output);
        if (vdecOutBufferDev != nullptr) {
            // 0: vdec success; others, vdec failed
            // If retCode is 0, the decoding is successful. If retCode is 1, the decoding fails.
            int retCode = acldvppGetPicDescRetCode(output);
            if (retCode == 0) {
                // process task: write file
                uint32_t size = acldvppGetPicDescSize(output);
                std::string fileNameSave = "outdir/image" + std::to_string(count);
                // VDEC output result is stored on the device. Perform the following operations in the WriteToFile method:
                if (!Utils::WriteToFile(fileNameSave.c_str(), vdecOutBufferDev, size)) {
                    ERROR_LOG("write file failed.");
                }
            } else {
                ERROR_LOG("vdec decode frame failed.");
            }

            // free output vdecOutBufferDev
            aclError ret = acldvppFree(vdecOutBufferDev);
        }
        //Destroy data of type acldvppPicDesc, that is, the output image description.
        aclError ret = acldvppDestroyPicDesc(output);
    }

    // free input vdecInBufferDev and destroy stream desc
    if (input != nullptr) {
        void *vdecInBufferDev = acldvppGetStreamDescData(input);
        if (vdecInBufferDev != nullptr) {
            aclError ret = acldvppFree(vdecInBufferDev);
        }
        //Destroy data of type acldvppStreamDesc,  that is, the input stream description.
        aclError ret = acldvppDestroyStreamDesc(input);
    }

    INFO_LOG("success to callback %d.", count);
    count++;
}

// 2. Set the attributes of the video stream processing channel description. The thread (threadId indicates the thread ID) and callback function need to be created in advance.
// vdecChannelDesc is of type aclvdecChannelDesc.
vdecChannelDesc = aclvdecCreateChannelDesc();
aclError ret = aclvdecSetChannelDescChannelId(vdecChannelDesc, 10);
ret = aclvdecSetChannelDescThreadId(vdecChannelDesc, threadId);
ret = aclvdecSetChannelDescCallback(vdecChannelDesc, callback);
// In the sample, the H265_MAIN_LEVEL video coding protocol is used.
ret = aclvdecSetChannelDescEnType(vdecChannelDesc, static_cast<acldvppStreamFormat>(H265_MAIN_LEVEL));
// In the sample, PIXEL_FORMAT_YVU_SEMIPLANAR_420 is used.
ret = aclvdecSetChannelDescOutPicFormat(vdecChannelDesc, static_cast<acldvppPixelFormat>(PIXEL_FORMAT_YUV_SEMIPLANAR_420));

// 3. Create a channel for processing video streams.
ret = aclvdecCreateChannel(vdecChannelDesc);


// 4. Call aclrtGetRunMode to obtain the run mode of the software stack. If the run mode obtained by calling aclrtGetRunMode is ACL_HOST, call aclrtMemcpy to transfer the input image data to the device. After the data transfer is complete, free the memory in a timely manner. Otherwise, the memory of the device is directly allocated and used.
aclrtRunMode runMode;
ret = aclrtGetRunMode(&runMode);

// 5. Send the stream by frame and decode it.
count = 0;
while (count < 10) { // Assume that there are 10 frames in the stream, so perform the send action 10 times.
// 5.1 Apply for the input stream memory (differentiated by the running status) and read a frame of stream data. inBufferSize is the size of a frame to be read. You need to assign a value based on the actual stream size of each frame.
    if (runMode == ACL_HOST){ 
        // Allocate the host buffer inputHostBuff.
        void* inputHostBuff= nullptr;
        // inBufferSize is the size of the input stream.
        inputHostBuff= malloc(inBufferSize);
        // Load a frame of the input stream into the buffer. The ReadStreamFile function is defined by the user.
        ReadStreamFile(picName, inputHostBuff, inBufferSize);
        // Allocate the device buffer inBufferDev.
        ret = acldvppMalloc(&inBufferDev, inBufferSize);
    // Transfer the input image data to the device by using the aclrtMemcpy call.
        ret = aclrtMemcpy(inBufferDev, inBufferSize, inputHostBuff, inBufferSize, ACL_MEMCPY_HOST_TO_DEVICE);
        // Free the host buffer in a timely manner after data transfer is complete.
        free(inputHostBuff);
    } else {
        // Allocate device input buffer dataDev. inBufferSize is the size of each frame of the input stream.
        ret = acldvppMalloc(&inBufferDev, inBufferSize);
        // Load a frame of the input stream into the buffer. The ReadStreamFile function is defined by the user.
        ReadStreamFile(picName, inBufferDev, inBufferSize);
    }

// 5.2 Create the description of the input video stream and set the attributes of the stream information.
    streamInputDesc = acldvppCreateStreamDesc(); 
    // inBufferDev indicates the buffer for storing the input video data on the device, and inBufferSize indicates the buffer size.
    ret = acldvppSetStreamDescData(streamInputDesc, inBufferDev);
    ret = acldvppSetStreamDescSize(streamInputDesc, inBufferSize);

// 5.3 Allocate the device buffer picOutBufferDev for storing the output data after VDEC decoding. The size is the size of the decoded image. You need to calculate the size based on the image format and the width and height of the aligned image, and then assign a value to the size.
    ret = acldvppMalloc(&picOutBufferDev, size);

// 5.4 Create the description of the output image and set the attributes of the image description.
    // picOutputDesc is of type acldvppPicDesc
    picOutputDesc = acldvppCreatePicDesc();
    ret = acldvppSetPicDescData(picOutputDesc, picOutBufferDev);
    ret = acldvppSetPicDescSize(picOutputDesc, size);
    ret = acldvppSetPicDescFormat(picOutputDesc, static_cast<acldvppPixelFormat>(PIXEL_FORMAT_YUV_SEMIPLANAR_420));

// 5.5 Decode video streams. After each frame of data is decoded, the system automatically calls the callback function to write the decoded data to a file, and then releases related resources in a timely manner.
    ret = aclvdecSendFrame(vdecChannelDesc, streamInputDesc, picOutputDesc, nullptr, nullptr);
    // ......
    count++;
    // Note that aclvdecSendFrame is an asynchronous API. The input buffer (inBufferDev), output buffer (picOutBufferDev), input descriptor (streamInputDesc), and output descriptor (picOutputDesc) cannot be freed in advance and need to be freed in the callback function.
}

// 6. Release the image processing channel and image description.
ret = aclvdecDestroyChannel(vdecChannelDesc);
aclvdecDestroyChannelDesc(vdecChannelDesc);

......