Unable to use NvMedia IDP to display images output from NvMedia IPP

Hi,

I’m trying to build a basic capture-display application using NvMedia framework, but I’ve encountered some problems that I couldn’t figure out. I’m using DRIVE Software 10.0 and SF3325 camera.
The goal is very simple: just to achieve something like VideoCapture and imshow() in OpenCV. The work flow is ICP->ISP->Output->NvMediaIPPComponentGetOutput()->NvMediaIDPFlip()
I used ipp_raw sample as the reference for building IPP, and img_play sample as reference for setting up IDP. Since I don’t quite understand how the “releaseList” work in IDP, my implementation is different from img_play sample, and this could be one issue.

Below is my code:

// Nvmedia camera
#include <iostream>
#include <dw/core/Context.h>
#include <dw/core/Logger.h>
#include <dw/core/VersionCurrent.h>
#include <dw/interop/streamer/ImageStreamer.h>
#include <dwvisualization/core/Renderer.h>
#include <framework/DriveWorksSample.hpp>
#include <framework/Log.hpp>
#include <framework/WindowGLFW.hpp>
#include <sys/time.h>
#include <limits.h>
#include <unistd.h>
// NvMedia
#include "nvmedia_ipp.h"
#include "nvmedia_icp.h"
#include "nvmedia_isc.h"
#include "nvmedia_idp.h"
#include "nvmedia_2d.h"
#include "img_dev.h"
#include "nvmedia_acp.h"
using namespace std;

void printOrange(const char *format,...) {
    printf("\e[38;5;208m");
    printf(format);
    printf("\n\e[0m");
}

void printBlue(const char *format,...) {
    printf("\e[38;5;87m");
    printf(format);
    printf("\n\e[0m");
}

class nvmIPP {
    NvMediaDevice *nvmDevice = nullptr;
    NvMediaIDP *idpDevice = nullptr;
    NvMediaIPPManager *ippManager = nullptr;
    NvMediaIPPPipeline *ipp[NVMEDIA_MAX_PIPELINES_PER_MANAGER]; // 16
    NvMediaIPPComponent *ippComponents[NVMEDIA_MAX_PIPELINES_PER_MANAGER][NVMEDIA_MAX_COMPONENTS_PER_PIPELINE]; // 16 32
    NvMediaIPPComponent *ippIspComponents[NVMEDIA_MAX_PIPELINES_PER_MANAGER];
    NvMediaIPPComponent *ippIscComponents[NVMEDIA_MAX_PIPELINES_PER_MANAGER];
    NvMediaIPPComponent *ippCAComponents[NVMEDIA_MAX_PIPELINES_PER_MANAGER];
    NvMediaIPPComponent *outputComponent[NVMEDIA_MAX_PIPELINES_PER_MANAGER];
    NvMediaICPSettings captureSettings = {};
    ExtImgDevice *SF3325Camera = nullptr; // ISC
    
public:
    nvmIPP () {
        nvmDevice = NvMediaDeviceCreate();
        if (!nvmDevice) {cerr << "NvMediaDeviceCreate failed line:" << __LINE__ << "\n"; return;}
        ippInit();
        ippSetCaptureSettings();
        memset(ippComponents, 0, sizeof(ippComponents));
        IPPCreateISC();
        IPPCreateICPEX();
        IPPCreateISP();
        IPPCreateCA();
        IPPCreateOutput();
        IPPAddComponentsToPipeline();
        NvMediaStatus status = NVMEDIA_STATUS_ERROR;
        status = NvMediaIPPPipelineStart(ipp[0]);
        if (status != NVMEDIA_STATUS_OK) {cerr << "NvMediaIPPPipelineStart failed line:" << __LINE__ << "\n"; return;}
        status = ExtImgDevStart(SF3325Camera);
        if (status != NVMEDIA_STATUS_OK) {cerr << "ExtImgDevStart failed line:" << __LINE__ << "\n"; return;}
        IDPInit();
        printBlue("nvmIPP instantialized");
    }
    
    ~nvmIPP () {
        if (idpDevice) NvMediaIDPDestroy(idpDevice);
        NvMediaIPPPipelineStop(ipp[0]);
        if (nvmDevice) NvMediaDeviceDestroy(nvmDevice);
        if (SF3325Camera) ExtImgDevDeinit(SF3325Camera);
        printBlue("nvmIPP: byebye");
    }
    
    bool ippInit () {
        printBlue("ippInit");
        memset(ippComponents, 0, sizeof(ippComponents));
        memset(ippIspComponents, 0, sizeof(ippIspComponents));
        memset(ippIscComponents, 0, sizeof(ippIscComponents));
        ExtImgDevParam extImgDevParam  = {};
        extImgDevParam.desAddr = 0x29;
        extImgDevParam.brdcstSerAddr = 0x40;  // Address of serializer device. 0x40 ddpx-a
        extImgDevParam.brdcstSensorAddr = 0x10; // Address of sensor device. 0x10: AR0231
        extImgDevParam.e2pPhysicalAddr = 0;
        extImgDevParam.sensorAddr[0] = extImgDevParam.brdcstSensorAddr + 1;
        extImgDevParam.sensorIdentifier[0] = (char *)("");
        extImgDevParam.i2cDevice = 0; // 0: NVMEDIA_ISC_I2C_BUS_0
        extImgDevParam.moduleName = (char *)("ref_max96712_96705_ar0231rccbsf3324bae");
        extImgDevParam.board = (char *)("ddpx-a");
        extImgDevParam.resolution = (char *)("1920x1208");
        extImgDevParam.sensorsNum = 1;
        extImgDevParam.inputFormat = (char *)("raw12");
        extImgDevParam.interface = (char *)("csi-a");
        ExtImgDevMapInfo camMap;
        extImgDevParam.camMap = &camMap;
        extImgDevParam.camMap->enable = CAM_ENABLE_DEFAULT;
        extImgDevParam.camMap->mask = CAM_MASK_DEFAULT;
        extImgDevParam.camMap->csiOut = CSI_OUT_DEFAULT;
        extImgDevParam.enableEmbLines = NVMEDIA_TRUE;
        extImgDevParam.initialized = NVMEDIA_FALSE;
        extImgDevParam.enableSimulator = NVMEDIA_FALSE;
        extImgDevParam.enableVirtualChannels = NVMEDIA_FALSE;
        extImgDevParam.slave = NVMEDIA_FALSE;
        SF3325Camera = ExtImgDevInit(&extImgDevParam);
        if (!SF3325Camera) {cerr << "extImgDevice init failed line:" << __LINE__ << "\n"; return false;}
        return true;
    }
    
    bool ippSetCaptureSettings() {
        printBlue("ippSetCaptureSettings");
        ExtImgDevProperty *sf3325property = &SF3325Camera->property;
        captureSettings.interfaceType = sf3325property->interface;
        captureSettings.inputFormat.inputFormatType = sf3325property->inputFormatType;
        captureSettings.inputFormat.bitsPerPixel = sf3325property->bitsPerPixel;
        NVM_SURF_FMT_DEFINE_ATTR(surfFormatAttrs);
        NVM_SURF_FMT_SET_ATTR_RAW(surfFormatAttrs,RGGB,UINT,12,PL)
        surfFormatAttrs[NVM_SURF_ATTR_COMPONENT_ORDER].value += sf3325property->pixelOrder;
        captureSettings.startX = 0;
        captureSettings.startY = 0;
        captureSettings.surfaceType = NvMediaSurfaceFormatGetType(surfFormatAttrs, NVM_SURF_FMT_ATTR_MAX);
        captureSettings.width = sf3325property->width;
        captureSettings.height = sf3325property->height;
        captureSettings.embeddedDataType = sf3325property->embDataType;
        captureSettings.embeddedDataLines = sf3325property->embLinesTop + sf3325property->embLinesBottom;
        captureSettings.interfaceLanes = 2; // CSI interface lanes  1,2,4
        captureSettings.phyMode = sf3325property->phyMode;
        captureSettings.tpgEnable = sf3325property->tpgEnable;
        captureSettings.pixelFrequency = sf3325property->pixelFrequency;
        ippManager = NvMediaIPPManagerCreate(NVMEDIA_IPP_VERSION_INFO, nvmDevice);
        if (!ippManager) {cerr << "NvMediaIPPManagerCreate failed line:" << __LINE__ << "\n"; return false;}
        ipp[0] = NvMediaIPPPipelineCreate(ippManager);
        return true;
    }
    
    NvMediaStatus IPPCreateISC() {
        printBlue("IPPCreateISC");
        NvMediaIPPIscComponentConfig iscComponentConfig = {};
        iscComponentConfig.iscSensorDevice = SF3325Camera->iscSensor[0];
        ippIscComponents[0] = NvMediaIPPComponentCreateNew(ipp[0], NVMEDIA_IPP_COMPONENT_ISC, nullptr, &iscComponentConfig);
        if (!ippIscComponents[0]) {cerr << "NvMediaIPPComponentCreateNew() failed line:" << __LINE__ << "\n"; return NVMEDIA_STATUS_ERROR;}
        return NVMEDIA_STATUS_OK;
    }
    
    NvMediaStatus IPPCreateICPEX() {
        printBlue("IPPCreateICPEX");
        NvMediaICPSettingsEx icpSettingsEx = {};
        NvMediaIPPBufferPoolParamsNew *bufferPools[5], bufferPool={};
        // IPPSetICPBufferPoolConfig
        bufferPool.width = captureSettings.width;
        bufferPool.height = captureSettings.height;
        bufferPool.portType = NVMEDIA_IPP_PORT_IMAGE_1;
        bufferPool.poolBuffersNum = 3;
        NVM_SURF_FMT_DEFINE_ATTR(surfFormatAttrs);
        NVM_SURF_FMT_SET_ATTR_RAW(surfFormatAttrs,RGGB,UINT,12,PL);
        bufferPool.surfaceType = NvMediaSurfaceFormatGetType(surfFormatAttrs, NVM_SURF_FMT_ATTR_MAX);
        bufferPool.imagesCount = 1;
        bufferPool.surfAllocAttrs[0].type = NVM_SURF_ATTR_WIDTH;
        bufferPool.surfAllocAttrs[0].value = bufferPool.width;
        bufferPool.surfAllocAttrs[1].type = NVM_SURF_ATTR_HEIGHT;
        bufferPool.surfAllocAttrs[1].value = bufferPool.height;
        bufferPool.surfAllocAttrs[2].type = NVM_SURF_ATTR_EMB_LINES_TOP;
        bufferPool.surfAllocAttrs[2].value = SF3325Camera->property.embLinesTop;
        bufferPool.surfAllocAttrs[3].type = NVM_SURF_ATTR_EMB_LINES_BOTTOM;
        bufferPool.surfAllocAttrs[3].value = SF3325Camera->property.embLinesBottom;
        bufferPool.surfAllocAttrs[4].type = NVM_SURF_ATTR_CPU_ACCESS;
        bufferPool.surfAllocAttrs[4].value = NVM_SURF_ATTR_CPU_ACCESS_CACHED;
        bufferPool.surfAllocAttrs[5].type = NVM_SURF_ATTR_ALLOC_TYPE;
        bufferPool.surfAllocAttrs[5].value = NVM_SURF_ATTR_ALLOC_ISOCHRONOUS;
        bufferPool.numSurfAllocAttrs = 6;
        // end IPPSetICPBufferPoolConfig
        icpSettingsEx.interfaceType = captureSettings.interfaceType;
        icpSettingsEx.interfaceLanes = captureSettings.interfaceLanes;
        icpSettingsEx.numVirtualGroups = 1;
        icpSettingsEx.phyMode = captureSettings.phyMode;
        icpSettingsEx.virtualGroups[0].numVirtualChannels = 1;
        icpSettingsEx.virtualGroups[0].virtualChannels[0].virtualChannelIndex = SF3325Camera->property.vcId[0];
        icpSettingsEx.virtualGroups[0].virtualChannels[0].icpSettings = captureSettings;
        bufferPools[0] = &bufferPool;
        bufferPools[1] = NULL;
        ippComponents[0][0] = NvMediaIPPComponentCreateNew(ipp[0], NVMEDIA_IPP_COMPONENT_ICP_EX, bufferPools, &icpSettingsEx);
        if (!ippComponents[0][0]) {cerr << "NvMediaIPPComponentCreateNew() failed line:" << __LINE__ << "\n"; return NVMEDIA_STATUS_ERROR;}
        return NVMEDIA_STATUS_OK;
    }
    
    NvMediaStatus IPPCreateISP() {
        printBlue("IPPCreateISP");
        NvMediaIPPIspComponentConfig ispComponentConfig = {};
        NvMediaIPPBufferPoolParamsNew *bufferPools[4], bufferPool, bufferPool2;
        memset(&ispComponentConfig, 0, sizeof(ispComponentConfig));
        ispComponentConfig.ispSelect = NVMEDIA_ISP_SELECT_ISP_A;
        bufferPools[0] = &bufferPool;
        bufferPools[1] = &bufferPool2; // stats pool
        bufferPools[2] = NULL;
        memset(&bufferPool, 0, sizeof(bufferPool));
        bufferPool.portType = NVMEDIA_IPP_PORT_IMAGE_1;
        bufferPool.poolBuffersNum = 3;
        bufferPool.height = captureSettings.height;
        bufferPool.width = captureSettings.width;
        NVM_SURF_FMT_DEFINE_ATTR(surfFormatAttrs);
        NVM_SURF_FMT_SET_ATTR_YUV(surfFormatAttrs,YUV,420,SEMI_PLANAR,UINT,8,BL);
        bufferPool.surfaceType = NvMediaSurfaceFormatGetType(surfFormatAttrs, NVM_SURF_FMT_ATTR_MAX);
        bufferPool.imagesCount = 1;
        bufferPool.surfAllocAttrs[0].type = NVM_SURF_ATTR_WIDTH;
        bufferPool.surfAllocAttrs[0].value = bufferPool.width;
        bufferPool.surfAllocAttrs[1].type = NVM_SURF_ATTR_HEIGHT;
        bufferPool.surfAllocAttrs[1].value = bufferPool.height;
        bufferPool.surfAllocAttrs[2].type = NVM_SURF_ATTR_CPU_ACCESS;
        bufferPool.surfAllocAttrs[2].value = NVM_SURF_ATTR_CPU_ACCESS_CACHED;
        bufferPool.surfAllocAttrs[3].type = NVM_SURF_ATTR_COLOR_STD_TYPE;
        bufferPool.surfAllocAttrs[3].value = NVM_SURF_ATTR_COLOR_STD_REC709_ER;
        bufferPool.numSurfAllocAttrs = 4;
        // stats port
        memset(&bufferPool2, 0, sizeof(bufferPool2));
        bufferPool2.portType = NVMEDIA_IPP_PORT_STATS_1;
        bufferPool2.poolBuffersNum = 3;
        ippIspComponents[0] = NvMediaIPPComponentCreateNew(ipp[0], NVMEDIA_IPP_COMPONENT_ISP, bufferPools, &ispComponentConfig);
        ippComponents[0][1] = ippIspComponents[0];
        if (!ippComponents[0][1]) {cerr << "NvMediaIPPComponentCreateNew() failed line:" << __LINE__ << "\n"; return NVMEDIA_STATUS_ERROR;}
        return NVMEDIA_STATUS_OK;
    }
    
    NvMediaStatus IPPCreateCA() {
        printBlue("IPPCreateCA");
        NvMediaIPPControlAlgorithmComponentConfig caConfig = {};
        memset(&caConfig, 0, sizeof(caConfig));
        NvMediaIPPBufferPoolParamsNew *bufferPools[4], bufferPool;
        NvMediaIPPPluginFuncs nvpluginFuncs = {
            .createFunc = nullptr,
            .destroyFunc = nullptr,
            .processExFunc = nullptr
        };
        caConfig.width = captureSettings.width;
        caConfig.height = captureSettings.height;
        // FIXME: ulgy conversion from uint_32t to NvMediaRawPixelOrder
        //        caConfig.pixelOrder = (NvMediaRawPixelOrder)SF3325Camera->property.pixelOrder;
        caConfig.pixelOrder = NVMEDIA_RAW_PIXEL_ORDER_RCCB;
        caConfig.bitsPerPixel = SF3325Camera->property.bitsPerPixel;
        caConfig.iscSensorDevice = SF3325Camera->iscSensor[0];
        caConfig.pluginFuncs = &nvpluginFuncs;
        bufferPools[0] = &bufferPool;
        bufferPools[1] = nullptr;
        bufferPool.portType = NVMEDIA_IPP_PORT_SENSOR_CONTROL_1;
        bufferPool.poolBuffersNum = 3;
        ippCAComponents[0] = NvMediaIPPComponentCreateNew(ipp[0], NVMEDIA_IPP_COMPONENT_ALG, bufferPools, &caConfig);
        if (!ippCAComponents[0]) {cerr << "NvMediaIPPComponentCreateNew() failed line:" << __LINE__ << "\n"; return NVMEDIA_STATUS_ERROR;}
        return NVMEDIA_STATUS_OK;
    }
    
    NvMediaStatus IPPCreateOutput() {
        printBlue("IPPCreateOutput");
        outputComponent[0] = NvMediaIPPComponentCreateNew(ipp[0], NVMEDIA_IPP_COMPONENT_OUTPUT, NULL, NULL);
        ippComponents[0][2] = outputComponent[0];
        if (!ippComponents[0][2]) {cerr << "NvMediaIPPComponentCreateNew() failed line:" << __LINE__ << "\n"; return NVMEDIA_STATUS_ERROR;}
        return NVMEDIA_STATUS_OK;
    }
    
    NvMediaStatus IPPAddComponentsToPipeline() {
        printBlue("IPPAddComponentsToPipeline");
        NvMediaStatus status = NVMEDIA_STATUS_ERROR;
        status = NvMediaIPPComponentAttach(ipp[0], ippComponents[0][0], ippIspComponents[0], NVMEDIA_IPP_PORT_IMAGE_1);
        status = NvMediaIPPComponentAttach(ipp[0], ippIspComponents[0], outputComponent[0], NVMEDIA_IPP_PORT_IMAGE_1);
        status = NvMediaIPPComponentAttach(ipp[0], ippIspComponents[0], ippCAComponents[0], NVMEDIA_IPP_PORT_STATS_1);
        status = NvMediaIPPComponentAttach(ipp[0], ippCAComponents[0], ippIscComponents[0], NVMEDIA_IPP_PORT_SENSOR_CONTROL_1);
        if (status != NVMEDIA_STATUS_OK) {cerr << "NvMediaIPPComponentAttach() failed line:" << __LINE__ << "\n"; return NVMEDIA_STATUS_ERROR;}
        return NVMEDIA_STATUS_OK;
    }
    
    NvMediaStatus IDPInit () {
        NvMediaIDPDeviceParams queryOutputs[3];
        NvMediaDispAttributes attributes = {};
        int outputDeviceNum = 0;
        if (NvMediaIDPQuery(&outputDeviceNum, queryOutputs) != NVMEDIA_STATUS_OK) {printOrange("NvMediaIDPQuery failed"); return NVMEDIA_STATUS_ERROR;}
        idpDevice = NvMediaIDPCreate(queryOutputs[0].displayId, 1, nullptr, queryOutputs[0].enabled);
        if (!idpDevice) {printOrange("NvMediaIDPCreate failed"); return NVMEDIA_STATUS_ERROR;}
        attributes.depth = 1;
        NvMediaIDPSetAttributes(idpDevice, NVMEDIA_DISP_ATTR_SET_DEPTH, &attributes);
        return NVMEDIA_STATUS_OK;
    }
    
    NvMediaStatus IDPDisplayImage (NvMediaImage *imgToDisplay) {
        NvMediaImage *releaseFrames[9] = {0};
        NvMediaImage **releaseList = &releaseFrames[0];
        NvMediaStatus status = NvMediaIDPFlip(idpDevice, imgToDisplay, NULL, NULL, releaseList, NULL);
        if (status != NVMEDIA_STATUS_OK) {printOrange("NvMediaIDPFlip failed");}
        return NVMEDIA_STATUS_OK;
    }
    
    bool onProcess () {
        NvMediaIPPComponentOutput ippOutput = {};
        NvMediaStatus status = NvMediaIPPComponentGetOutput(outputComponent[0], 100, &ippOutput); // blocking func
        cout << "ippOutput.image " << ippOutput.image << " type " << ippOutput.image->type << " width " << ippOutput.image->width << " height " << ippOutput.image->height << " imageCount " << ippOutput.image->imageCount << " captureTimeStamp.sec " << ippOutput.image->captureTimeStamp.tv_sec << " colorStd " << ippOutput.image->colorStd << endl;
        if (status != NVMEDIA_STATUS_OK) {printOrange("NvMediaIPPComponentGetOutput failed");}
        IDPDisplayImage(ippOutput.image);
        status = NvMediaIPPComponentReturnOutput(outputComponent[0], &ippOutput);
        return true;
    }
};

int main(int argc, const char *argv[]) {
    argc = argc;
    argv = argv;
    nvmIPP app = nvmIPP();
    for (size_t i=0; i<30; i++) {
        app.onProcess();
    }
    return 0;
}

And here’s the output:

ippInit
nvmedia isc: GetCameraPowerControlLevel: 936: Camera power control library: NVCCP
Max96712 Rev 2 detected!
MAX96712: Enable periodic AEQ on Link 0
MAX96705: Pre-emphasis set to 0xaa
Sensor AR0231 RCCB Rev7 detected!
ippSetCaptureSettings
IPPCreateISC
IPPCreateICPEX
IPPCreateISP
IPPCreateCA
No autocontrol plugin, default settings will be used
IPPCreateOutput
IPPAddComponentsToPipeline
nvmIPP instantialized
ippOutput.image 0xe53060 type 35 width 1920 height 1208 imageCount 1 captureTimeStamp.sec 1583197290 colorStd 5
nvmDisplayFlipQueueDisplayYUV: Flip failed
NvMediaIDPFlip failed
ippOutput.image 0xe53850 type 35 width 1920 height 1208 imageCount 1 captureTimeStamp.sec 1583197290 colorStd 5
nvmDisplayFlipQueueDisplayYUV: Flip failed
NvMediaIDPFlip failed
ippOutput.image 0xe54040 type 35 width 1920 height 1208 imageCount 1 captureTimeStamp.sec 1583197290 colorStd 5
nvmDisplayFlipQueueDisplayYUV: Flip failed
NvMediaIDPFlip failed
ippOutput.image 0xe53060 type 35 width 1920 height 1208 imageCount 1 captureTimeStamp.sec 1583197290 colorStd 5
nvmDisplayFlipQueueDisplayYUV: Flip failed
NvMediaIDPFlip failed
ippOutput.image 0xe53850 type 35 width 1920 height 1208 imageCount 1 captureTimeStamp.sec 1583197290 colorStd 5
nvmDisplayFlipQueueDisplayYUV: Flip failed
NvMediaIDPFlip failed
ippOutput.image 0xe54040 type 35 width 1920 height 1208 imageCount 1 captureTimeStamp.sec 1583197290 colorStd 5
nvmDisplayFlipQueueDisplayYUV: Flip failed
NvMediaIDPFlip failed
ippOutput.image 0xe53060 type 35 width 1920 height 1208 imageCount 1 captureTimeStamp.sec 1583197290 colorStd 5
nvmDisplayFlipQueueDisplayYUV: Flip failed
NvMediaIDPFlip failed
ippOutput.image 0xe53850 type 35 width 1920 height 1208 imageCount 1 captureTimeStamp.sec 1583197290 colorStd 5
nvmDisplayFlipQueueDisplayYUV: Flip failed
NvMediaIDPFlip failed
ippOutput.image 0xe54040 type 35 width 1920 height 1208 imageCount 1 captureTimeStamp.sec 1583197290 colorStd 5
nvmDisplayFlipQueueDisplayYUV: Flip failed
NvMediaIDPFlip failed
ippOutput.image 0xe53060 type 35 width 1920 height 1208 imageCount 1 captureTimeStamp.sec 1583197291 colorStd 5
nvmDisplayFlipQueueDisplayYUV: Flip failed
NvMediaIDPFlip failed
ippOutput.image 0xe53850 type 35 width 1920 height 1208 imageCount 1 captureTimeStamp.sec 1583197291 colorStd 5
nvmDisplayFlipQueueDisplayYUV: Flip failed
NvMediaIDPFlip failed
ippOutput.image 0xe54040 type 35 width 1920 height 1208 imageCount 1 captureTimeStamp.sec 1583197291 colorStd 5
nvmDisplayFlipQueueDisplayYUV: Flip failed
NvMediaIDPFlip failed
ippOutput.image 0xe53060 type 35 width 1920 height 1208 imageCount 1 captureTimeStamp.sec 1583197291 colorStd 5
nvmDisplayFlipQueueDisplayYUV: Flip failed
NvMediaIDPFlip failed
ippOutput.image 0xe53850 type 35 width 1920 height 1208 imageCount 1 captureTimeStamp.sec 1583197291 colorStd 5
nvmDisplayFlipQueueDisplayYUV: Flip failed
NvMediaIDPFlip failed
ippOutput.image 0xe54040 type 35 width 1920 height 1208 imageCount 1 captureTimeStamp.sec 1583197291 colorStd 5
nvmDisplayFlipQueueDisplayYUV: Flip failed
NvMediaIDPFlip failed
ippOutput.image 0xe53060 type 35 width 1920 height 1208 imageCount 1 captureTimeStamp.sec 1583197291 colorStd 5
nvmDisplayFlipQueueDisplayYUV: Flip failed
NvMediaIDPFlip failed
ippOutput.image 0xe53850 type 35 width 1920 height 1208 imageCount 1 captureTimeStamp.sec 1583197291 colorStd 5
nvmDisplayFlipQueueDisplayYUV: Flip failed
NvMediaIDPFlip failed
ippOutput.image 0xe54040 type 35 width 1920 height 1208 imageCount 1 captureTimeStamp.sec 1583197291 colorStd 5
nvmDisplayFlipQueueDisplayYUV: Flip failed
NvMediaIDPFlip failed
ippOutput.image 0xe53060 type 35 width 1920 height 1208 imageCount 1 captureTimeStamp.sec 1583197291 colorStd 5
nvmDisplayFlipQueueDisplayYUV: Flip failed
NvMediaIDPFlip failed
ippOutput.image 0xe53850 type 35 width 1920 height 1208 imageCount 1 captureTimeStamp.sec 1583197291 colorStd 5
nvmDisplayFlipQueueDisplayYUV: Flip failed
NvMediaIDPFlip failed
ippOutput.image 0xe54040 type 35 width 1920 height 1208 imageCount 1 captureTimeStamp.sec 1583197291 colorStd 5
nvmDisplayFlipQueueDisplayYUV: Flip failed
NvMediaIDPFlip failed
ippOutput.image 0xe53060 type 35 width 1920 height 1208 imageCount 1 captureTimeStamp.sec 1583197291 colorStd 5
nvmDisplayFlipQueueDisplayYUV: Flip failed
NvMediaIDPFlip failed
ippOutput.image 0xe53850 type 35 width 1920 height 1208 imageCount 1 captureTimeStamp.sec 1583197291 colorStd 5
nvmDisplayFlipQueueDisplayYUV: Flip failed
NvMediaIDPFlip failed
ippOutput.image 0xe54040 type 35 width 1920 height 1208 imageCount 1 captureTimeStamp.sec 1583197291 colorStd 5
nvmDisplayFlipQueueDisplayYUV: Flip failed
NvMediaIDPFlip failed
ippOutput.image 0xe53060 type 35 width 1920 height 1208 imageCount 1 captureTimeStamp.sec 1583197291 colorStd 5
nvmDisplayFlipQueueDisplayYUV: Flip failed
NvMediaIDPFlip failed
ippOutput.image 0xe53850 type 35 width 1920 height 1208 imageCount 1 captureTimeStamp.sec 1583197291 colorStd 5
nvmDisplayFlipQueueDisplayYUV: Flip failed
NvMediaIDPFlip failed
ippOutput.image 0xe54040 type 35 width 1920 height 1208 imageCount 1 captureTimeStamp.sec 1583197291 colorStd 5
nvmDisplayFlipQueueDisplayYUV: Flip failed
NvMediaIDPFlip failed
ippOutput.image 0xe53060 type 35 width 1920 height 1208 imageCount 1 captureTimeStamp.sec 1583197291 colorStd 5
nvmDisplayFlipQueueDisplayYUV: Flip failed
NvMediaIDPFlip failed
ippOutput.image 0xe53850 type 35 width 1920 height 1208 imageCount 1 captureTimeStamp.sec 1583197291 colorStd 5
nvmDisplayFlipQueueDisplayYUV: Flip failed
NvMediaIDPFlip failed
ippOutput.image 0xe54040 type 35 width 1920 height 1208 imageCount 1 captureTimeStamp.sec 1583197291 colorStd 5
nvmDisplayFlipQueueDisplayYUV: Flip failed
NvMediaIDPFlip failed
nvmIPP: byebye

It seems the capturing part is working because NvMediaIPPComponentGetOutput() did not raise any error, and ippOutput.image(NvMediaImage) contains reasonable values. However, I’m not 100% sure the issue is with IDP. I tried to feed the output image into NvMedia IEP to encode it, but got segmentation fault. I also tried to replace the display part of ipp_raw sample (which use egl stream to display) with IDP, and got similar error.

Could you provide any suggestion on how to debug this?
Thank you!

Hi James22,

Did you mean you failed to run nvmimg_enc with your output image?

Hi Vick,
I tried both my output and the output from ipp_raw sample (YUV420), and I also created a new empty YUV420BL NvMediaImage, then feed it into IEP, also got a segmentation fault. I guess there’s something wrong with buffer allocation. Maybe IEP is very picky about what kind of surfaces fed into it, but I haven’t figured out where the problem is.

Not sure if the segmentation fault has the same root cause as the NvMediaIDPFlip error.

But for the NvMediaIDPFlip error, maybe you can refer to nvmimg_play sample and try to pass the same working arguments to the function call in your application.