VDEC

//1. Initialize AscendCL.

// 2. Allocate runtime resources.

// 3. 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);
                // The 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, which indicates the description data of the decoded output image.
        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, which indicates the description data of the decoded input stream.
        aclError ret = acldvppDestroyStreamDesc(input);
    }

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

//4. Create the description of the video stream processing channel, and set the attributes of the video processing channel description. The thread (threadId indicates the thread ID) and callback function need to be created in advance.
// vdecChannelDescis 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));

// 5. Create a channel for processing the video stream.
ret = aclvdecCreateChannel(vdecChannelDesc);


// 6. Call aclrtGetRunMode to obtain the run mode of the software stack. If ACL_DEVICE is returned, allocate and use the device buffer. If ACL_HOST is returned, transfer the input image data to the device by using the aclrtMemcpy call. After the data transfer is complete, the buffer needs to be freed in a timely manner.
aclrtRunMode runMode;
ret = aclrtGetRunMode(&runMode);

// 7. Send the stream in frame mode and decode the stream.
count = 0;
while (count < 10) { // Assume that there are 10 frames in the stream, so perform the send action 10 times.
// 7.1 Allocate input buffer (run mode specific) 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);
    }

    // 7.2 Create the description of the input video stream and set the stream attributes.
    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);

    // 7.3 Allocate device buffer picOutBufferDev for storing the VDEC-decoded output data. size is the size of the decoded image. Calculate the size based on the image format and the width and height of the aligned image, and then assign it to size.
    ret = acldvppMalloc(&picOutBufferDev, size);

    // 7.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));

    // 7.5 Decode the video stream. The callback function is called after each decoded frame to write data to the file, and destroy allocations 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.
}

// 8. Destroy the image processing channel and image description information.
ret = aclvdecDestroyChannel(vdecChannelDesc);
aclvdecDestroyChannelDesc(vdecChannelDesc);

// 9. Deallocate runtime resources.

// 10. Deinitialize AscendCL.

// ......