关于IMX6Dl 芯片使用硬编解码的问题记录

NXP出了IMX6系列芯片（现在应该是9系列最新了），性能相当于我们嵌入式行业，已经非常优秀（可以做很多事情）

同时，IMX6DL IMX6Q 自带vpu硬编解码，用来处理下视频也是非常不错的，对于我们来说的确非常合适

 

众所周知，mxc_vpu_test.out 是官方提供的测试程序，用于测试各种功能，源码也提供，

但是系统里面源码是跟其他测试程序整合在一起的，往往我们想要在此基础上改改弄弄，然后重新编译是件困难的事情（大神除外）

当然，也可以从网上下载 mxc_vpu_test.out 的源码，貌似也有（csdn就有），但可能跟你板子的库文件版本不一致，会导致各种问题

总之这是一个绕不过去的坑（编译过不算，正常运行编解码才算）

 

以上问题，困扰很久，后来版本搞对了，才算顺利过去。 ---- 记一下，如果用测试程序 编译没有问题，但测试解码时候，出现段错误，往往是你所用h文件跟板子so库用的h文件版本不一样，也就是某些结构体size不一样。

 

另外一个问题：

假设在同一块板子上，先采集USB摄像头的数据，然后vpu编码产生h264流，然后通过“管道”发送给解码线程，解码线程收到h264流，然后调用vpu的解码，然后再显示。当然这个步骤是异步的，两个线程（进程），中间涉及到数据交互的。

源代码是参考 mxc_vpu_test.out 的源码

ps: 说到这里，可能有些人会说，既然是一块板子，那么直接显示USB摄像头上的数据，不是更好的？嗯，我举的例子，的确这样做更好，但不要忘记现实的项目可能是这样的需求：在本终端上显示的画面是其他终端传过来的h264数据，而本终端需要将自己的视频流传输给对方（就好比视频对讲），这样就需要一台板子上同时编解码（当然此时用的通道肯定是两个）

 

 

 

 

貌似应该没有问题，也说得通，只要编解码本身没有问题，那么问题就没有。但现实往往是骨感的，的确是碰到问题

一开始怀疑管道写错了，但管道的确没有问题

 

通过步骤printf 的方式，发现卡在：

 

 

 

也就是说 开始编码的时候，就不再返回。

分析了dec.c 的源码：

dec这边最后一步是出现这里：

 

dec_fill_bsbuffer 实际上是去读取管道数据（由于是阻塞式管道，不阻塞不行，不阻塞的话，这里返回是0，那么dec这边会认为“没有数据” 自然退出）。此时卡住了。

原因：

解码这边，在读取管道数据之前，先调用 vpu_DecStartOneFrame ，这个函数会占据vpu资源，

导致解码那边调用 vpu_EncStartOneFrame 函数卡死（因为获取不到vpu资源，从而也没有往下走）

这样就形成了“死锁”，编码这边等待vpu资源释放（才能有数据往管道里放），解码这边等待管道里有数据（才能完成解码，从而才能释放vpu资源）

 

也许，把 vpu_DecStartOneFrame 放在 dec_fill_bsbuffer 之后，是否可行？也不行，只是概率问题。

 

从现象来看，我们也知道同一块板子如果同时 vpu_DecStartOneFrame vpu_EncStartOneFrame是不行的

 

当然唯一的办法就是错时。

我的办法也很简单，利用一个缓冲，错时，如果缓冲里没有数据，解码这边就不调用 vpu_DecStartOneFrame，线程等待就好了。

当然这个缓冲也有点小复杂，不是简简单单加个锁就行了，还是要考虑到各种情况的。

 

下面亮出我的代码：

static char *m_pPipeBuf = NULL;
static int m_nNowPos = 0;
static int m_nGetPos = 0;
static pthread_mutex_t m_lock;

//建立缓存区
void Safe_InitBuff()
{
    if(m_pPipeBuf != NULL)
        Safe_UnInitBuff();

    pthread_mutex_init(&m_lock,NULL);
    m_pPipeBuf = (char*)malloc(PIPE_LENTH + 1024);
    m_nNowPos = 0;
    m_nGetPos = 0;
}

void Safe_UnInitBuff()
{
    if(m_pPipeBuf != NULL)
    {
        free(m_pPipeBuf);
        m_pPipeBuf = NULL;

        pthread_mutex_destroy(&m_lock);
        m_nNowPos = 0;
        m_nGetPos = 0;
    }
}

//剩余可以存放 多少空间
static int GetLastTemp()
{
    int nLast = 0;

    if(m_nNowPos >= m_nGetPos)
    {
        nLast = PIPE_LENTH - (m_nNowPos - m_nGetPos);
    }
    else
    {

    }
    return nLast;
}

static int AddToPipeBuf(void *pBuf,int nLen)
{
    int nRes = -1;
    if(m_pPipeBuf != NULL)
    {
        int nPos = m_nNowPos % PIPE_LENTH;
        if ((nPos + nLen) > PIPE_LENTH)
        {
            int nCpLen = (PIPE_LENTH - nPos);
            memcpy(&m_pPipeBuf[nPos],pBuf,nCpLen);

            nPos = 0;
            memcpy(&m_pPipeBuf[0],&pBuf[nCpLen],nLen - nCpLen);
        }
        else
        {
            memcpy(&m_pPipeBuf[nPos],pBuf,nLen);
        }

        m_nNowPos = m_nNowPos + nLen;
        nRes = nLen;
    }

    return nRes;
}

static int GetSavedLen()
{
    int nLen = 0;
    if (m_nNowPos == m_nGetPos)
    {
        nLen = 0;
    }
    else if(m_nNowPos > m_nGetPos)
    {
        nLen = m_nNowPos - m_nGetPos;
    }
    else
    {
        //异常，不存在
    }

    return nLen;
}

static int GetFromPipeBuf(void *pBuf,int nLen)
{
    int nPos = (m_nGetPos % PIPE_LENTH);
    int nRes = -1;

    if (nLen > 0)
    {
        if ((nPos + nLen) > PIPE_LENTH)
        {
            int nCpLen = PIPE_LENTH - nPos;
            //先拷贝末尾
            memcpy(pBuf,&m_pPipeBuf[nPos],nCpLen);
            nPos = 0;
            memcpy(&pBuf[nCpLen], &m_pPipeBuf[0], nLen - nCpLen);
        }
        else
        {
            memcpy(pBuf,&m_pPipeBuf[nPos],nLen);
        }

        nRes = nLen;
        m_nGetPos = m_nGetPos + nLen;
    }

    return nRes;
}

//添加数据（如果数据已满，等待）
int Safe_AddBuf(char *pBuf,int nLen)
{
    int nRes = -1;
    if(((nLen + 4) > PIPE_LENTH) || (m_pPipeBuf == NULL))
    {
        return nRes;
    }

    int bIsSaved = 0;
    while (bIsSaved == 0)
    {
        pthread_mutex_lock(&m_lock);
        int nLast = GetLastTemp();

        if(nLast >= (nLen + 4))
        {
            char strNUM[5];
            memcpy(strNUM, &nLen, 4);
            AddToPipeBuf(strNUM, 4);

            nRes = AddToPipeBuf(pBuf, nLen);
            bIsSaved = 1;
        }

        pthread_mutex_unlock(&m_lock);

        if(bIsSaved == 0)
        {
            //< delay 10ms .continue waited
            printf("Safe_SaveBuf: delay 10ms .continue waited\n");
            usleep(10000);
        }
    }

    return nRes;
}

//提取数据（如果没有数据，等待）
int Safe_GetBuf(char *pBuf,int nLen)
{
    static int lastReadAll = 1;     ///< 取完
    static int nLastRead = 0;           ///< 还有多少个没读完

    int nRes = -1;
    if((nLen <= 0) || (m_pPipeBuf == NULL))
    {
        return 0;
    }

    int bIsGet = 0;
    while (bIsGet == 0)
    {
        pthread_mutex_lock(&m_lock);
        int nSaved = GetSavedLen();
        int nframe_length = 0;

        if(nSaved > 0)
        {
            if(lastReadAll == 1)
            {
                if(nSaved > 4)
                {
                    GetFromPipeBuf(&nframe_length,4);

                    if(nframe_length > nLen)
                    {
                        lastReadAll = 0;

                        nLastRead = nframe_length - nLen;
                        nframe_length = nLen;
                        //外部存储 不够（先不管，除非长度写错了）
                    }
                    else
                    {
                        //取走这帧
                        lastReadAll = 1;
                        nLastRead = 0;
                    }
                }
                else
                {
                    //错误---
                }
            }
            else
            {
                //继续-
                if(nLen >= nLastRead)
                {
                    //这次空间够了
                    if(nSaved >= nLastRead)
                    {
                        //把上次未取走的 全部取走
                        nframe_length = nLastRead;
                        nLastRead = 0;
                        lastReadAll = 1;
                    }
                    else
                    {
                        nframe_length = nSaved;
                        nLastRead = nLastRead - nSaved;
                        lastReadAll = 0;
                    }
                }
                else
                {
                    //空间不够 nLastRead
                    if(nSaved >= nLen)
                    {
                        nframe_length = nLen;
                        nLastRead = nLastRead - nLen;
                        lastReadAll = 0;
                    }
                    else
                    {
                        nframe_length = nSaved;
                        nLastRead = nLastRead - nSaved;
                        lastReadAll = 0;
                    }
                }
            }

            if(nframe_length > 0)
            {
                nRes = GetFromPipeBuf(pBuf, nframe_length);
                bIsGet = 1;
            }
        }

        pthread_mutex_unlock(&m_lock);

        if(bIsGet == 0)
        {
            //< delay 100ms .continue waited
            printf("Safe_GetBuf: delay 10ms .continue waited\n");
            usleep(10000);
        }
    }
    return nRes;
}

int Safe_IsHaveData()
{
    int nSaved = 0;
    pthread_mutex_lock(&m_lock);
    nSaved = GetSavedLen();
    pthread_mutex_unlock(&m_lock);
    return nSaved;
}

 

题外话，问题也解决了，效率非常高，cpu仅占3%~5%左右，性能上也很强劲，这款cpu不错

很流畅，延时很少（100ms~200ms左右，感觉！）