WhyCan Forum(哇酷开发者社区)

# export
export EDITOR='/bin/vi'
export HOME='/root'
export LOGNAME='root'
export PATH='/bin:/sbin:/usr/bin:/usr/sbin'
export PS1='# '
export PWD='/root'
export SHELL='/bin/sh'
export SHLVL='1'
export TERM='vt102'
export USER='root'
#

malloc ok, count=146
malloc ok, count=147
malloc ok, count=148
malloc ok, count=149
malloc ok, count=150
malloc ok, count=151
malloc ok, count=152
malloc ok, count=153
[  216.137338] mem_test invoked oom-killer: gfp_mask=0x24200ca(GFP_HIGHUSER_MOVABLE), nodemask=0, order=0, oom_score_adj=0
[  216.150768] CPU: 0 PID: 1703 Comm: mem_test Not tainted 4.9.118 #183
[  216.164815] Hardware name: sun8iw8
[  216.168650] [<c010c7cc>] (unwind_backtrace) from [<c010a6f4>] (show_stack+0x10/0x14)
[  216.179140] [<c010a6f4>] (show_stack) from [<c01da458>] (dump_header.constprop.3+0x64/0x1ac)
[  216.190381] [<c01da458>] (dump_header.constprop.3) from [<c01975a4>] (oom_kill_process+0xec/0x4a8)
[  216.208704] [<c01975a4>] (oom_kill_process) from [<c0197e28>] (out_of_memory+0x348/0x3f0)
[  216.217901] [<c0197e28>] (out_of_memory) from [<c019c0ec>] (__alloc_pages_nodemask+0x950/0xa28)
[  216.234830] [<c019c0ec>] (__alloc_pages_nodemask) from [<c01ba94c>] (handle_mm_fault+0x140/0xb70)
[  216.245960] [<c01ba94c>] (handle_mm_fault) from [<c010ec34>] (do_page_fault+0x210/0x2a8)
[  216.256745] [<c010ec34>] (do_page_fault) from [<c01012d4>] (do_DataAbort+0x38/0xb8)
[  216.271863] [<c01012d4>] (do_DataAbort) from [<c010b39c>] (__dabt_usr+0x3c/0x40)
[  216.281845] Exception stack(0xc2393fb0 to 0xc2393ff8)
[  216.294763] 3fa0:                                     ad371010 00006b7f ad448028 00007fff
[  216.304956] 3fc0: 00000000 00000000 00000000 00000000 00000001 00000000 00000020 beda4e34
[  216.316019] 3fe0: ad37101c beda4df0 00000000 b6f72774 20000010 ffffffff
[  216.330038] [ pid ]   uid  tgid total_vm      rss nr_ptes nr_pmds swapents oom_score_adj name
[  216.341363] [  720]     0   720      330        1       4       0        6             0 syslogd
[  216.359483] [  724]     0   724      329        1       4       0        6             0 klogd
[  216.369134] [  736]     0   736      333        1       5       0       13             0 mdev
[  216.383525] [  780]     0   780     1657       11       7       0      754             0 haveged
[  216.395798] [  786]  1001   786      331        0       4       0       18             0 dbus-daemon
[  216.407732] [  792]     0   792     1110       27       6       0       81             0 ntpd
[  216.424769] [  805]     0   805      223        1       4       0        9             0 dropbear
[  216.435459] [  808]     0   808   168315       19       8       0      211             0 allxbee
[  216.446949] [  812]     0   812   167906       32       7       0      313             0 iotWatchdog
[  216.464755] [  952]     0   952      332        1       4       0       10             0 sh
[  216.474740] [ 1616]     0  1616      329        1       3       0        6             0 udhcpc
[  216.486136] [ 1703]     0  1703    40009     8503      82       0    31313             0 mem_test
[  216.502559] Out of memory: Kill process 1703 (mem_test) score 836 or sacrifice child
[  216.512924] Killed process 1703 (mem_test) total-vm:160036kB, anon-rss:33956kB, file-rss:56kB, shmem-rss:0kB
[  216.602368] oom_reaper: reaped process 1703 (mem_test), now anon-rss:4kB, file-rss:0kB, shmem-rss:0kB
Killed
# bg
-sh: bg: No current job
#
#
# free
              total        used        free      shared  buff/cache   available
Mem:          53960       12648       21936           8       19376       37272
Swap:        131068        5320      125748
#

/dev/by-name/rootfs_data
                          1.4M     24.0K      1.2M   2% /overlay
overlayfs:/overlay        1.4M     24.0K      1.2M   2% /

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <getopt.h>           
#include <fcntl.h>            
#include <unistd.h>
#include <errno.h>
#include <malloc.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/time.h>
#include <sys/mman.h>
#include <sys/ioctl.h>
 
#include <asm/types.h>        
#include <linux/videodev2.h>

#define BUF_NUM                         4
#define FRAMESINBUF                     1

struct CJ_Buffer {
        void *memory;
        int length;
};

struct CJ_Buffer *gpV4l2Buf;
 
int gMemMapLen;

int file_fd;
char *dev_name = "/dev/video0";
int fd;


int getFullSize(int * full_w, int * full_h)
{
    struct v4l2_frmsizeenum size_enum;
    size_enum.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    size_enum.pixel_format = V4L2_PIX_FMT_NV12;
    size_enum.index = 0;
    if (-1 == ioctl(fd, VIDIOC_ENUM_FRAMESIZES, &size_enum))
    {
        perror("VIDIOC_ENUM_FRAMESIZES failed");  
        return 0;   
    }
    
    *full_w = size_enum.discrete.width;
    *full_h = size_enum.discrete.height;

        printf("getFullSize: %dx%d\n", *full_w, *full_h);
    
    return 1;
}

int tryFmtSize(int *width, int *height)
{
    int ret = -1;
    struct v4l2_format fmt;

    printf("%dx%d", *width, *height);

    memset(&fmt, 0, sizeof(fmt));
    fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    fmt.fmt.pix.width  = *width;
    fmt.fmt.pix.height = *height;

    //fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV;
    //fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_MJPEG;
    //fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_H264;
    fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_NV12;

    fmt.fmt.pix.field = V4L2_FIELD_NONE;

    ret = ioctl(fd, VIDIOC_TRY_FMT, &fmt);
    if (ret < 0)
    {
        perror("VIDIOC_TRY_FMT failed");
        return ret;
    }

    // driver surpport this size
    *width = fmt.fmt.pix.width;
    *height = fmt.fmt.pix.height;

    return 0;
}

int setContrastValue(int value)
{
    int ret = -1;
    struct v4l2_control ctrl;

    ctrl.id = V4L2_CID_CONTRAST;
    ctrl.value = value;
    ret = ioctl(fd, VIDIOC_S_CTRL, &ctrl);
    if (ret < 0) {
        perror("VIDIOC_S_CTRL failed");
    } else {
        printf("setContrastValue ok\n");
    }

    return ret;
}
int setBrightnessValue(int value)
{
    struct v4l2_control ctrl;
    int ret = -1;

    ctrl.id = V4L2_CID_BRIGHTNESS;
    ctrl.value = value;
    ret = ioctl(fd, VIDIOC_S_CTRL, &ctrl);
    if (ret < 0) {
        perror("VIDIOC_S_CTRL failed");
    } else {
        printf("setBrightnessValue ok\n");
    }
    return ret;
}

int setSaturationValue(int value)
{
    struct v4l2_control ctrl;
    int ret = -1;

    ctrl.id = V4L2_CID_SATURATION;
    ctrl.value = value;
    ret = ioctl(fd, VIDIOC_S_CTRL, &ctrl);
    if (ret < 0) {
        perror("VIDIOC_S_CTRL failed");
    } else {
        printf("setSaturationValue ok\n");
    }
    return ret;
}

int setSharpnessValue(int value)
{
    struct v4l2_control ctrl;
    int ret = -1;

    ctrl.id = V4L2_CID_SHARPNESS;
    ctrl.value = value;
    ret = ioctl(fd, VIDIOC_S_CTRL, &ctrl);
    if (ret < 0) {
        perror("VIDIOC_S_CTRL failed");
    } else {
        printf("setSharpnessValue ok\n");
    }
    return ret;
}

int setHueValue(int value)
{
    struct v4l2_control ctrl;
    int ret = -1;

    ctrl.id = V4L2_CID_HUE;
    ctrl.value = value;
    ret = ioctl(fd, VIDIOC_S_CTRL, &ctrl);
    if (ret < 0) {
        perror("VIDIOC_S_CTRL failed");
    } else {
        printf("setHueValue ok\n");
    }

    return ret;
}

int setHflip(int value)
{
    struct v4l2_control ctrl;
    int ret = -1;
    
    ctrl.id = V4L2_CID_HFLIP_THUMB;
    ctrl.value = value;
    printf("V4L2CameraDevice::setHflip value=%d\n", value);
    ret = ioctl(fd, VIDIOC_S_CTRL, &ctrl);
    if (ret < 0)
    {
        //setSharpnessValue failed
        perror("setHflip thumb failed\n");
    }
    ctrl.id = V4L2_CID_HFLIP;
    ctrl.value = value;
    printf("V4L2CameraDevice::setHflip value=%d\n", value);
    ret = ioctl(fd, VIDIOC_S_CTRL, &ctrl);
    if (ret < 0)
    {
        //setSharpnessValue failed
        perror("setHflip failed\n");
    }
    return ret;
}

int setVflip(int value)
{
    struct v4l2_control ctrl;
    int ret = -1;
    
    ctrl.id = V4L2_CID_VFLIP_THUMB;
    ctrl.value = value;
    printf("V4L2CameraDevice::setVflip value=%d\n", value);
    ret = ioctl(fd, VIDIOC_S_CTRL, &ctrl);
    if (ret < 0)
    {
        //setSharpnessValue failed
        perror("setVflip thumb failed111\n");
    }
    ctrl.id = V4L2_CID_VFLIP;
    ctrl.value = value;
    printf("V4L2CameraDevice::setVflip value=%d\n", value);
    ret = ioctl(fd, VIDIOC_S_CTRL, &ctrl);
    if (ret < 0)
    {
        //setSharpnessValue failed
        perror("setVflip failed111\n");
    }

    return ret;
}

int v4l2setCaptureParams(int framerate)
{
    printf("framerate=%d", framerate);
    int ret = -1;
    
    struct v4l2_streamparm params;
    params.parm.capture.timeperframe.numerator = 1;
    params.parm.capture.timeperframe.denominator = framerate;
    params.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    params.parm.capture.capturemode = V4L2_MODE_VIDEO;

    printf("VIDIOC_S_PARM mFrameRate: %d, capture mode: %d\n", framerate, params.parm.capture.capturemode);

    ret = ioctl(fd, VIDIOC_S_PARM, &params);
    if (ret < 0) {
        perror("VIDIOC_S_PARM failed");
    } else {
        printf("v4l2setCaptureParams ok\n");
    }

    return ret;
}

void v4l2SetVideoParams(int width, int height, int sub_w, int sub_h, unsigned int pix_fmt)
{
    struct v4l2_format format;

    printf("main:%dx%d, sub:%dx%d, pfmt: 0x%x\n", width, height, sub_w, sub_h, pix_fmt);
    memset(&format, 0, sizeof(format));
    format.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    format.fmt.pix.width  = width;
    format.fmt.pix.height = height;
    //format.fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV;
    //format.fmt.pix.pixelformat = V4L2_PIX_FMT_MJPEG;
    //format.fmt.pix.pixelformat = V4L2_PIX_FMT_H264;
    format.fmt.pix.pixelformat = V4L2_PIX_FMT_NV12;
    format.fmt.pix.field = V4L2_FIELD_NONE;

    if ((sub_w > 0 && sub_w < width) && (sub_h > 0 && sub_h < height)) {
        struct v4l2_pix_format sub_fmt;
        memset(&sub_fmt, 0, sizeof(sub_fmt));
        format.fmt.pix.subchannel = &sub_fmt;
        format.fmt.pix.subchannel->width = sub_w;
        format.fmt.pix.subchannel->height = sub_h;
        format.fmt.pix.subchannel->pixelformat = pix_fmt;
        format.fmt.pix.subchannel->field = V4L2_FIELD_NONE;
        format.fmt.pix.subchannel->rot_angle = 0;
        printf("sub_w=%d, sub_h=%d\n", sub_w, sub_h);
    }

    if (ioctl(fd, VIDIOC_S_FMT, &format) < 0)
    {
        perror("VIDIOC_S_FMT failed");
        return;
    }

    return;
}

void initV4l2Buffer()
{
    gpV4l2Buf = (struct CJ_Buffer *)malloc(sizeof(struct CJ_Buffer) * BUF_NUM);
    if (gpV4l2Buf == NULL) {
        perror("alloc V4l2Buffer_tag error!!");
        return;
    }
    memset(gpV4l2Buf, 0, sizeof(struct CJ_Buffer) * BUF_NUM);
}

void setFramesInV4L2BufNum()
{
        unsigned int nFramesInBuf = FRAMESINBUF;
    printf("mFramesInV4l2buf=%u\n", FRAMESINBUF);
    if (ioctl (fd, VIDIOC_SET_NFRAME_BUF, &nFramesInBuf) < 0) {
        perror("VIDIOC_SET_NFRAME_BUF failed");
    }
}

int v4l2ReqBufs(int * buf_cnt)
{
    int ret = 0;
    struct v4l2_requestbuffers rb;

    printf("TO VIDIOC_REQBUFS count: %d\n", *buf_cnt);

    memset(&rb, 0, sizeof(rb));
    rb.type   = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    rb.memory = V4L2_MEMORY_MMAP;
    rb.count  = *buf_cnt;

    ret = ioctl(fd, VIDIOC_REQBUFS, &rb);
    if (ret < 0)
    {
        perror("VIDIOC_REQBUFS failed");
        return ret;
    }

    *buf_cnt = rb.count;
    printf("VIDIOC_REQBUFS count: %d\n", *buf_cnt);

    return 1;
}

int v4l2QueryBuf()
{
        int i;
    int ret = 0;
    struct v4l2_buffer buf;

    for (i = 0; i < BUF_NUM; i++)
    {
        memset (&buf, 0, sizeof (struct v4l2_buffer));
        buf.type   = V4L2_BUF_TYPE_VIDEO_CAPTURE;
        buf.memory = V4L2_MEMORY_MMAP;
        buf.index  = i;

        ret = ioctl (fd, VIDIOC_QUERYBUF, &buf);
        if (ret < 0)
        {
            perror("VIDIOC_QUERYBUF failed");
            return ret;
        }

        gpV4l2Buf[i].memory = mmap(0, buf.length,
                                PROT_READ | PROT_WRITE, 
                                MAP_SHARED, 
                                fd, 
                                buf.m.offset);

                gMemMapLen = buf.length;
        printf("index: %d, mem: %x, len: %d, offset: %x\n", i, (int)gpV4l2Buf[i].memory, buf.length, buf.m.offset);
 
        if (gpV4l2Buf[i].memory == MAP_FAILED)
        {
            perror("mmap failed");
            return -1;
        }
        }

    for (i = 0; i < BUF_NUM; i++)
    {
        memset (&buf, 0, sizeof (struct v4l2_buffer));
        buf.type   = V4L2_BUF_TYPE_VIDEO_CAPTURE;
        buf.memory = V4L2_MEMORY_MMAP;
        buf.index  = i;
        // start with all buffers in queue
        ret = ioctl(fd, VIDIOC_QBUF, &buf);
        if (ret < 0)
        {
            perror("VIDIOC_QBUF failed");
            return ret;
        }
    }

    return 1;
}

int v4l2StartStreaming()
{
    int ret = 0;
    enum v4l2_buf_type type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

    ret = ioctl (fd, VIDIOC_STREAMON, &type);
    if (ret < 0)
    {
        perror("VIDIOC_STREAMON failed");
        return ret;
    }

    return 1;
}

int v4l2StopStreaming()
{
    int ret = 0;
    enum v4l2_buf_type type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

    ret = ioctl (fd, VIDIOC_STREAMOFF, &type);
    if (ret < 0)
    {
        perror("VIDIOC_STREAMOFF failed");
        return ret;
    }
    printf("V4L2Camera::v4l2StopStreaming ok\n");

    return 1;
}

int v4l2UnmapBuf()
{
        int i;
    int ret = 0;

    for (i = 0; i < BUF_NUM; i++)
    {
        ret = munmap(gpV4l2Buf[i].memory, gMemMapLen);
        if (ret < 0)
        {
            perror("munmap failed");
            return ret;
        }

        gpV4l2Buf[i].memory = NULL;
    }

    return 1;
}

int main (int argc,char ** argv)
{
        struct v4l2_capability cap;
        struct v4l2_format fmt;
        struct v4l2_pix_format sub_fmt;
        struct v4l2_requestbuffers req;
        struct v4l2_buffer buf; 
    struct v4l2_input inp;
        unsigned int i;
        enum v4l2_buf_type type;
        
        int width, height;
     
     
        fd = open(dev_name, O_RDWR | O_NONBLOCK, 0);

        ioctl (fd, VIDIOC_QUERYCAP, &cap);
        printf("Driver Name:%s\n Card Name:%s\n Bus info:%s\n\n", cap.driver, cap.card, cap.bus_info);
        printf("capabilities:%d\n", cap.capabilities);
        
    if ((cap.capabilities & V4L2_CAP_VIDEO_CAPTURE) == 0 &&
                (cap.capabilities & V4L2_CAP_STREAMING) == 0) 
    {
        perror("cap capabilities format fail");  
        return -2 ;   
    }


    inp.index = 0;
    if (-1 == ioctl(fd, VIDIOC_S_INPUT, &inp))
    {
        perror("VIDIOC_S_INPUT error!");  
        return -2 ;   
    }
        
        getFullSize(&width, &height);
        
        width = 640; height = 480;
        /*tryFmtSize(&width, &height);
        setContrastValue(50);
        setBrightnessValue(50);
        setSaturationValue(0);
        setSharpnessValue(10);
        setHueValue(30);
        setHflip(0);
        setVflip(0);*/
        
        v4l2setCaptureParams(30);
        v4l2SetVideoParams(640, 480, 320, 240, V4L2_PIX_FMT_NV12);
        
        initV4l2Buffer();
        setFramesInV4L2BufNum();

    int buf_cnt = BUF_NUM;
    v4l2ReqBufs(&buf_cnt);
        
        v4l2QueryBuf();
        v4l2StartStreaming();
        
        //for (i = 0; i < 10; i++)
        //      sleep(1);

    //struct v4l2_control ctrl;

   // ctrl.id = V4L2_CID_TAKE_PICTURE;
    //if (ioctl(fd, VIDIOC_S_CTRL, &ctrl) < 0) {
  //      perror("VIDIOC_S_CTRL failed");
  //  } else {
  //      perror("setTakePictureCtrl ok\n");
 //   }
        
        
        FILE* fp = fopen("test2.nv12", "w");
        if(fp == NULL)
        {
                printf("open file error.\n");
                goto end;
        }

        for (i = 0; i < 200; i++)
        {
                fd_set fds;

                FD_ZERO(&fds);
                FD_SET(fd, &fds);

                select(fd + 1, &fds, NULL, NULL, NULL);

            memset(&buf, 0, sizeof(struct v4l2_buffer));
                buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
                buf.memory = V4L2_MEMORY_MMAP;
                ioctl(fd, VIDIOC_DQBUF, &buf);

            void *pMem = gpV4l2Buf[buf.index].memory;
                printf("frame addr = %x, length=%d, %d\n", (unsigned int)pMem, gpV4l2Buf[buf.index].length, buf.length);

                fwrite(pMem, 640 * 480 * 3 / 2, 1, fp);
#if 0
                if (i == 199)
                {
                        file_fd = open("test.jpg", O_RDWR | O_CREAT, 0777);
                        write(file_fd, pMem, 640 * 480 * 3 / 2);
                        close (file_fd);
                        printf("frame index = %d, size = %d.\n", buf.index, buf.length);
                }
#endif
                ioctl(fd, VIDIOC_QBUF, &buf);
        }

end:
        fclose(fp);     
        v4l2StopStreaming();
        v4l2UnmapBuf();
        

        close (fd);
        printf("Camera Done.\n");


        return 0;
}

$ find . |grep SerialPort  |grep \\.so
./output/build/qt5serialport-5.12.4/lib/libQt5SerialPort.so.5.12.4
./output/build/qt5serialport-5.12.4/lib/libQt5SerialPort.so.5.12
./output/build/qt5serialport-5.12.4/lib/libQt5SerialPort.so.5
./output/build/qt5serialport-5.12.4/lib/libQt5SerialPort.so
./output/host/arm-buildroot-linux-uclibcgnueabi/sysroot/usr/lib/libQt5SerialPort.so.5.12.4
./output/host/arm-buildroot-linux-uclibcgnueabi/sysroot/usr/lib/libQt5SerialPort.so.5.12
./output/host/arm-buildroot-linux-uclibcgnueabi/sysroot/usr/lib/libQt5SerialPort.so.5
./output/host/arm-buildroot-linux-uclibcgnueabi/sysroot/usr/lib/libQt5SerialPort.so
./output/target/usr/lib/libQt5SerialPort.so.5.12.4
./output/target/usr/lib/libQt5SerialPort.so.5.12
./output/target/usr/lib/libQt5SerialPort.so.5