微波EDA网，见证研发工程师的成长！
首页 > 研发问答 > 嵌入式设计讨论 > 嵌入式系统设计讨论 > 4.MTX20开发板添加USB Camera支持和应用程序验证。

4.MTX20开发板添加USB Camera支持和应用程序验证。

时间：10-02 整理：3721RD 点击：
因为工作的需要，自己对Camera HAL做过很多研究，本以为在MediaTek X20开发板上移植USB Camera会是很easy的事情，可还是遇到一些问题。
一）添加驱动支持
kernel-3.18对UVC的框架已经支持的很好，只需要打开编译开关即可，下面的开关是否全部有用处自己没有验证。

  1. select MEDIA_SUPPORT
  2.         select MEDIA_USB_SUPPORT
  3.         select MEDIA_CAMERA_SUPPORT
  4.         select MEDIA_CONTROLLER
  5.         select VIDEO_DEV
  6.         select VIDEO_V4L2_SUBDEV_API
  7.         select VIDEO_V4L2
  8.         select VIDEOBUF_GEN
  9.         select VIDEOBUF2_DMA_SG
  10.         select V4L2_MEM2MEM_DEV
  11.         select VIDEOBUF2_CORE
  12.         select VIDEOBUF2_MEMOPS
  13.         select VIDEOBUF2_DMA_CONTIG
  14.         select VIDEOBUF2_VMALLOC
  15.         select VIDEO_V4L2_INT_DEVICE
  16.         select V4L_PLATFORM_DRIVERS
  17.         select V4L_TEST_DRIVERS
  18.         select USB_VIDEO_CLASS
  19.         select USB_VIDEO_CLASS_INPUT_EVDEV
  20.         select USB_GSPCA

复制代码

编译，更新系统后开发板，开发板设置USB为HOST模式，插入USB Camera，应该就可以找到
类似/dev/video0设备节点，插入多个Camera设备时要分清楚自己要测试哪个。
如果没有/dev/video*设备节点，则说明系统不对，需要进一步调查。反正我前几天一直没有出现这个设备节点，后面又莫名其妙的出现了。
二）应用程序支持
我这里支持添加C代码，编译成一个可执行程序测试，后面在使用JNI和APK程序方式测试。

  1. #include "ImageProc.h"
  2. //01-24 07:43:06.439: E/TEST(3756): VIDIOC_DQBUF error 22, Invalid argument
  3. #define FOURCC_FORMAT                "%c%c%c%c"
  4. #define FOURCC_ARGS(c)                (c) & 0xFF, ((c) >> 8) & 0xFF, ((c) >> 16) & 0xFF, ((c) >> 24) & 0xFF

  6. int errnoexit(const char *s)
  7. {
  8.         LOGE("%s error %d, %s", s, errno, strerror (errno));
  9.         return ERROR_LOCAL;
  10. }

  12. int xioctl(int fd, int request, void *arg)
  13. {
  14.         int r;

  16.         do r = ioctl (fd, request, arg);
  17.         while (-1 == r && EINTR == errno);

  19.         return r;
  20. }

  22. //检查video设备名称
  23. int checkCamerabase(void){
  24.         struct stat st;
  25.         int i;
  26.         int start_from_4 = 1;
  27.        
  28.         /* if /dev/video[0-3] exist, camerabase=4, otherwise, camrerabase = 0 */
  29.         for(i=0 ; i<4 ; i++){
  30.                 sprintf(dev_name,"/dev/video%d",i);
  31.                 if (-1 == stat (dev_name, &st)) {
  32.                         start_from_4 &= 0;
  33.                 }else{
  34.                         start_from_4 &= 1;
  35.                 }
  36.         }

  38.         if(start_from_4){
  39.                 return 4;
  40.         }else{
  41.                 return 0;
  42.         }
  43. }
  44. //打开video设备
  45. int opendevice(int i)
  46. {
  47.         struct stat st;

  49.         sprintf(dev_name,"/dev/video%d",i);
  50.         //stat() 获得文件属性，并判断是否为字符设备文件
  51.         if (-1 == stat (dev_name, &st)) {
  52.                 LOGE("Cannot identify '%s': %d, %s", dev_name, errno, strerror (errno));
  53.                 return ERROR_LOCAL;
  54.         }

  56.         if (！S_ISCHR (st.st_mode)) {
  57.                 LOGE("%s is no device", dev_name);
  58.                 return ERROR_LOCAL;
  59.         }

  61.         fd = open (dev_name, O_RDWR);

  63.         if (-1 == fd) {
  64.                 LOGE("Cannot open '%s': %d, %s", dev_name, errno, strerror (errno));
  65.                 return ERROR_LOCAL;
  66.         }
  67.         return SUCCESS_LOCAL;
  68. }
  69. //初始化设备
  70. int initdevice(void)
  71. {
  72.         struct v4l2_capability cap;
  73.         struct v4l2_cropcap cropcap;
  74.         struct v4l2_crop crop;
  75.         struct v4l2_format fmt;
  76.         unsigned int min;
  77.         //VIDIOC_QUERYCAP 命令 来获得当前设备的各个属性
  78.         if (-1 == xioctl (fd, VIDIOC_QUERYCAP, &cap)) {
  79.                 if (EINVAL == errno) {
  80.                         LOGE("%s is no V4L2 device", dev_name);
  81.                         return ERROR_LOCAL;
  82.                 } else {
  83.                         return errnoexit ("VIDIOC_QUERYCAP");
  84.                 }
  85.         }
  86.         //V4L2_CAP_VIDEO_CAPTURE 0x00000001
  87.         // 这个设备支持 video capture 的接口，即这个设备具备 video capture 的功能
  88.         if (！(cap.capabilities & V4L2_CAP_VIDEO_CAPTURE)) {
  89.                 LOGE("%s is no video capture device", dev_name);
  90.                 return ERROR_LOCAL;
  91.         }
  92.         //V4L2_CAP_STREAMING 0x04000000
  93.         // 这个设备是否支持 streaming I/O 操作函数
  94.         if (！(cap.capabilities & V4L2_CAP_STREAMING)) {
  95.                 LOGE("%s does not support streaming i/o", dev_name);
  96.                 return ERROR_LOCAL;
  97.         }
  98.         //获得设备对 Image Cropping 和 Scaling 的支持
  99. #if 0
  100.         CLEAR (cropcap);

  102.         cropcap.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  103.         if (0 == xioctl (fd, VIDIOC_CROPCAP, &cropcap)) {
  104.                 crop.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  105.                 crop.c = cropcap.defrect;

  107.                 if (-1 == xioctl (fd, VIDIOC_S_CROP, &crop)) {
  108.                         switch (errno) {
  109.                                 case EINVAL:
  110.                                         break;
  111.                                 default:
  112.                                         break;
  113.                         }
  114.                 }
  115.         } else {
  116.         }
  117. #endif
  118.         //设置图形格式
  119.         CLEAR (fmt);

  121.         fmt.type                = V4L2_BUF_TYPE_VIDEO_CAPTURE;

  123.         fmt.fmt.pix.width       = IMG_WIDTH;
  124.         fmt.fmt.pix.height      = IMG_HEIGHT;

  126.         fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV;//V4L2_PIX_FMT_YUYV;//V4L2_PIX_FMT_MJPEG;//V4L2_PIX_FMT_YUYV;
  127.         fmt.fmt.pix.field       = V4L2_FIELD_ANY;
  128.         //检查流权限
  129.         if (-1 == xioctl (fd, VIDIOC_S_FMT, &fmt))
  130.                 return errnoexit ("VIDIOC_S_FMT");
  131.                 LOGE("=0 IMG_WIDTH=0x%x, IMG_HEIGHT=0x%x, V4L2_PIX_FMT_YUYV=0x%x", IMG_WIDTH, IMG_HEIGHT, V4L2_PIX_FMT_YUYV);

  133.         min = fmt.fmt.pix.width * 2;
  134.         //每行像素所占的 byte 数
  135.         if (fmt.fmt.pix.bytesperline < min)
  136.                 fmt.fmt.pix.bytesperline = min;
  137.         min = fmt.fmt.pix.bytesperline * fmt.fmt.pix.height;
  138.         if (fmt.fmt.pix.sizeimage < min)
  139.                 fmt.fmt.pix.sizeimage = min;

  141.         return initmmap ();

  143. }
  144. //I/O模式选择
  145. int initmmap(void)
  146. {
  147.         struct v4l2_requestbuffers req;

  149.         CLEAR (req);

  151.         req.count               = 4;
  152.         req.type                = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  153.         req.memory              = V4L2_MEMORY_MMAP;

  155.         if (-1 == xioctl (fd, VIDIOC_REQBUFS, &req)) {
  156.                 if (EINVAL == errno) {
  157.                         LOGE("%s does not support memory mapping", dev_name);
  158.                         return ERROR_LOCAL;
  159.                 } else {
  160.                         return errnoexit ("VIDIOC_REQBUFS");
  161.                 }
  162.         }

  164.         if (req.count < 2) {
  165.                 LOGE("Insufficient buffer memory on %s", dev_name);
  166.                 return ERROR_LOCAL;
  167.         }

  169.         buffers = calloc (req.count, sizeof (*buffers));

  171.         if (！buffers) {
  172.                 LOGE("Out of memory");
  173.                 return ERROR_LOCAL;
  174.         }

  176.         for (n_buffers = 0; n_buffers < req.count; ++n_buffers) {
  177.                 struct v4l2_buffer buf;

  179.                  CLEAR (buf);

  181.                 buf.type        = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  182.                 buf.memory      = V4L2_MEMORY_MMAP;
  183.                 buf.index       = n_buffers;

  185.                 if (-1 == xioctl (fd, VIDIOC_QUERYBUF, &buf))
  186.                         return errnoexit ("VIDIOC_QUERYBUF");

  188.                 buffers[n_buffers].length = buf.length;
  189.                 buffers[n_buffers].start =
  190.                 mmap (NULL ,
  191.                         buf.length,
  192.                         PROT_READ | PROT_WRITE,
  193.                         MAP_SHARED,
  194.                         fd, buf.m.offset);

  196.                 if (MAP_FAILED == buffers[n_buffers].start)
  197.                         return errnoexit ("mmap");
  198.         }

  200.         return SUCCESS_LOCAL;
  201. }

  203. int startcapturing(void)
  204. {
  205.         unsigned int i;
  206.         enum v4l2_buf_type type;

  208.         for (i = 0; i < n_buffers; ++i) {
  209.                 struct v4l2_buffer buf;

  211.                 CLEAR (buf);

  213.                 buf.type        = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  214.                 buf.memory      = V4L2_MEMORY_MMAP;
  215.                 buf.index       = i;

  217.                 if (-1 == xioctl (fd, VIDIOC_QBUF, &buf))
  218.                         return errnoexit ("VIDIOC_QBUF");
  219.         }

  221.         type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

  223.         if (-1 == xioctl (fd, VIDIOC_STREAMON, &type))
  224.                 return errnoexit ("VIDIOC_STREAMON");

  226.         return SUCCESS_LOCAL;
  227. }

  229. int readframeonce(void)
  230. {
  231.         int i = 1;
  232.         for (;;) {
  233.                 fd_set fds;
  234.                 struct timeval tv;
  235.                 int r;

  237.                 FD_ZERO (&fds);
  238.                 FD_SET (fd, &fds);

  240.                 tv.tv_sec = 2;
  241.                 tv.tv_usec = 0;

  243.                 r = select (fd + 1, &fds, NULL, NULL, &tv);

  245.                 if (-1 == r) {
  246.                         if (EINTR == errno)
  247.                                 continue;

  249.                         return errnoexit ("select");
  250.                 }

  252.                 if (0 == r) {
  253.                         LOGE("select timeout");
  254.                         return ERROR_LOCAL;

  256.                 }

  258.                 if (readframe (i)==1)
  259.                         break;

  261.         }

  263.         return SUCCESS_LOCAL;

  265. }


  268. void processimage (const void *p){
  269.                 yuyv422toABGRY((unsigned char *)p);
  270. }

  272. int readframe(int num){

  274.         struct v4l2_buffer buf;
  275.         unsigned int i;
  276.         int fd_save = 0;
  277.         //timeval cur_time;
  278.         time_t timep;
  279.         char str[32] = {0};
  280.         int nRet = 0;
  281.         CLEAR (buf);

  283.         buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  284.         buf.memory = V4L2_MEMORY_MMAP;
  285.         //buf.memory = V4L2_MEMORY_USERPTR;
  286.         //LOGE("fd=%d,request=%d,buf=%d",fd,VIDIOC_DQBUF,&buf);
  287.         if (-1 == xioctl (fd, VIDIOC_DQBUF, &buf)) {
  288.                 switch (errno) {
  289.                         case EAGAIN:
  290.                                 return 0;
  291.                         case EIO:
  292.                         default:
  293.                                 return errnoexit ("VIDIOC_DQBUF");
  294.                 }
  295.         }

  297.         assert (buf.index < n_buffers);
  298. #if 0
  299.         processimage (buffers[buf.index].start);
  300.         //    gettimeofday(&cur_time, NULL);
  301.         struct tm *p;
  302.     time(&timep);
  303.     p = localtime(&timep); //取得当地时间
  304.         sprintf(str, "%d_%d.bmp", 123, num);
  305. #else
  306.         sprintf(str, "%d_%d.yuv", 123, num);
  307. #endif
  308.                 fd_save = open (str, O_RDWR | O_APPEND);
  309.                 LOGE("=0009=save open %s", str);

  311.         if (-1 == fd_save) {
  312.                 LOGE("=0010=Cannot open '%s': %d, %s", str, errno, strerror (errno));
  313.                 //return ERROR_LOCAL;
  314.         }
  315.         else
  316.                 {
  317.         nRet = write(fd_save, buffers[buf.index].start, buffers[buf.index].length);
  318.         if (-1 == nRet) {
  319.                 LOGE("=0011=Cannot open '%s': %d, %s", str, errno, strerror (errno));
  320.                 return ERROR_LOCAL;
  321.         }
  322.         else
  323.         {
  324.                 nRet = 10;
  325.         }
  326.                 }
  327.         close(fd_save);
  328.         if (-1 == xioctl (fd, VIDIOC_QBUF, &buf))
  329.                 return errnoexit ("VIDIOC_QBUF");
  330.         if(nRet == 10)
  331.                 {
  332.                
  333.                 }
  334.         return 1;
  335. }

  337. int stopcapturing(void)
  338. {
  339.         enum v4l2_buf_type type;

  341.         type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

  343.         if (-1 == xioctl (fd, VIDIOC_STREAMOFF, &type))
  344.                 return errnoexit ("VIDIOC_STREAMOFF");

  346.         return SUCCESS_LOCAL;

  348. }

  350. int uninitdevice(void)
  351. {
  352.         unsigned int i;

  354.         for (i = 0; i < n_buffers; ++i)
  355.                 if (-1 == munmap (buffers[i].start, buffers[i].length))
  356.                         return errnoexit ("munmap");

  358.         free (buffers);

  360.         return SUCCESS_LOCAL;
  361. }
  362. //关闭设备
  363. int closedevice(void)
  364. {
  365.         if (-1 == close (fd)){
  366.                 fd = -1;
  367.                 return errnoexit ("close");
  368.         }

  370.         fd = -1;
  371.         return SUCCESS_LOCAL;
  372. }

  374. void yuyv422toABGRY(unsigned char *src)
  375. {

  377.         int width=0;
  378.         int height=0;

  380.         width = IMG_WIDTH;
  381.         height = IMG_HEIGHT;

  383.         int frameSize =width*height*2;

  385.         int i;

  387.         if((！rgb || ！ybuf)){
  388.                 return;
  389.         }
  390.         int *lrgb = NULL;
  391.         int *lybuf = NULL;
  392.                
  393.         lrgb = &rgb[0];
  394.         lybuf = &ybuf[0];

  396.         if(yuv_tbl_ready==0){
  397.                 for(i=0 ; i<256 ; i++){
  398.                         y1192_tbl[i] = 1192*(i-16);
  399.                         if(y1192_tbl[i]<0){
  400.                                 y1192_tbl[i]=0;
  401.                         }

  403.                         v1634_tbl[i] = 1634*(i-128);
  404.                         v833_tbl[i] = 833*(i-128);
  405.                         u400_tbl[i] = 400*(i-128);
  406.                         u2066_tbl[i] = 2066*(i-128);
  407.                 }
  408.                 yuv_tbl_ready=1;
  409.         }

  411.         for(i=0 ; i<frameSize ; i+=4){
  412.                 unsigned char y1, y2, u, v;
  413.                 y1 = src[i];
  414.                 u = src[i+1];
  415.                 y2 = src[i+2];
  416.                 v = src[i+3];

  418.                 int y1192_1=y1192_tbl[y1];
  419.                 int r1 = (y1192_1 + v1634_tbl[v])>>10;
  420.                 int g1 = (y1192_1 - v833_tbl[v] - u400_tbl[u])>>10;
  421.                 int b1 = (y1192_1 + u2066_tbl[u])>>10;

  423.                 int y1192_2=y1192_tbl[y2];
  424.                 int r2 = (y1192_2 + v1634_tbl[v])>>10;
  425.                 int g2 = (y1192_2 - v833_tbl[v] - u400_tbl[u])>>10;
  426.                 int b2 = (y1192_2 + u2066_tbl[u])>>10;

  428.                 r1 = r1>255 ? 255 : r1<0 ? 0 : r1;
  429.                 g1 = g1>255 ? 255 : g1<0 ? 0 : g1;
  430.                 b1 = b1>255 ? 255 : b1<0 ? 0 : b1;
  431.                 r2 = r2>255 ? 255 : r2<0 ? 0 : r2;
  432.                 g2 = g2>255 ? 255 : g2<0 ? 0 : g2;
  433.                 b2 = b2>255 ? 255 : b2<0 ? 0 : b2;

  435.                 *lrgb++ = 0xff000000 | b1<<16 | g1<<8 | r1;
  436.                 *lrgb++ = 0xff000000 | b2<<16 | g2<<8 | r2;

  438.                 if(lybuf！=NULL){
  439.                         *lybuf++ = y1;
  440.                         *lybuf++ = y2;
  441.                 }
  442.         }

  444. }

  446. #if 1
  447. int main()
  448. {
  449.         int ret;
  450.         int num = 0;;
  451.     struct v4l2_format v4l2_fmt;
  452.     memset(&v4l2_fmt, 0, sizeof(v4l2_fmt));
  453.         LOGE("=0=usb camera imageproc\n");

  455.         if(camerabase<0){
  456.                 //camerabase = checkCamerabase();
  457.         }
  458.         ret = opendevice(0);
  459.         LOGE("=1=usb camera imageproc\n");

  461.         if(ret ！= ERROR_LOCAL){
  462.                 ret = initdevice();
  463.         }
  464.         v4l2_fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

  466.   ret = ioctl(fd, VIDIOC_G_FMT, &v4l2_fmt);
  467.   if ( ret < 0) {
  468.       LOGE("ERR(%s):VIDIOC_G_FMT failed. %s(%d)\n", __func__, strerror(errno), errno);
  469.      // return -1;
  470.   }

  472.         LOGE("=2=usb v4l2_fmt.fmt.pix.width=%d, v4l2_fmt.fmt.pix.height=%d, v4l2_fmt.fmt.pix.pixelformat=0x%x\n",
  473.         v4l2_fmt.fmt.pix.width, v4l2_fmt.fmt.pix.height, v4l2_fmt.fmt.pix.pixelformat);
  474.                         LOGE("  Frame format: "FOURCC_FORMAT"\n", FOURCC_ARGS(v4l2_fmt.fmt.pix.pixelformat));

  476.         if(ret ！= ERROR_LOCAL){
  477.                 ret = startcapturing();
  478.         LOGE("=1=usb camera imageproc\n");

  480.                 if(ret ！= SUCCESS_LOCAL){
  481.                         stopcapturing();
  482.                         uninitdevice ();
  483.                         closedevice ();
  484.                         LOGE("device resetted");       
  485.                 }

  487.         }
  488.         LOGE("=3=usb camera imageproc\n");

  490.         if(ret ！= ERROR_LOCAL){
  491.                 rgb = (int *)malloc(sizeof(int) * (IMG_WIDTH*IMG_HEIGHT));
  492.                 ybuf = (int *)malloc(sizeof(int) * (IMG_WIDTH*IMG_HEIGHT));
  493.         }
  494.         LOGE("=4=usb camera imageproc\n");
  495.                 //*************************************************
  496.                 while(num < 20)
  497.                 {
  498.                                 readframeonce();
  499.                                 num++;
  500.                         }
  501.         //*************************************************
  502.         LOGE("=5=usb camera imageproc\n");
  503.         stopcapturing ();
  504.         LOGE("=6=usb camera imageproc\n");

  506.         uninitdevice ();
  507.         LOGE("=7=usb camera imageproc\n");

  509.         closedevice ();

  511.         if(rgb) free(rgb);
  512.         if(ybuf) free(ybuf);
  513.         
  514.         fd = -1;
  515.        
  516.         return ret;

  518. }
  519. #else
  520. void
  521. Java_com_camera_simplewebcam_CameraPreview_pixeltobmp( JNIEnv* env,jobject thiz,jobject bitmap){

  523.         jboolean bo;


  526.         AndroidBitmapInfo  info;
  527.         void*              pixels;
  528.         int                ret;
  529.         int i;
  530.         int *colors;

  532.         int width=0;
  533.         int height=0;

  535.         if ((ret = AndroidBitmap_getInfo(env, bitmap, &info)) < 0) {
  536.                 LOGE("AndroidBitmap_getInfo() failed ！ error=%d", ret);
  537.                 return;
  538.         }
  539.    
  540.         width = info.width;
  541.         height = info.height;

  543.         if(！rgb || ！ybuf) return;

  545.         if (info.format ！= ANDROID_BITMAP_FORMAT_RGBA_8888) {
  546.                 LOGE("Bitmap format is not RGBA_8888 ！");
  547.                 return;
  548.         }

  550.         if ((ret = AndroidBitmap_lockPixels(env, bitmap, &pixels)) < 0) {
  551.                 LOGE("AndroidBitmap_lockPixels() failed ！ error=%d", ret);
  552.         }

  554.         colors = (int*)pixels;
  555.         int *lrgb =NULL;
  556.         lrgb = &rgb[0];

  558.         for(i=0 ; i<width*height ; i++){
  559.                 *colors++ = *lrgb++;
  560.         }

  562.         AndroidBitmap_unlockPixels(env, bitmap);

  564. }

  566. jint
  567. Java_com_camera_simplewebcam_CameraPreview_prepareCamera( JNIEnv* env,jobject thiz, jint videoid){

  569.         int ret;

  571.         if(camerabase<0){
  572.                 camerabase = checkCamerabase();
  573.         }

  575.         ret = opendevice(camerabase + videoid);

  577.         if(ret ！= ERROR_LOCAL){
  578.                 ret = initdevice();
  579.         }
  580.         if(ret ！= ERROR_LOCAL){
  581.                 ret = startcapturing();

  583.                 if(ret ！= SUCCESS_LOCAL){
  584.                         stopcapturing();
  585.                         uninitdevice ();
  586.                         closedevice ();
  587.                         LOGE("device resetted");       
  588.                 }

  590.         }

  592.         if(ret ！= ERROR_LOCAL){
  593.                 rgb = (int *)malloc(sizeof(int) * (IMG_WIDTH*IMG_HEIGHT));
  594.                 ybuf = (int *)malloc(sizeof(int) * (IMG_WIDTH*IMG_HEIGHT));
  595.         }

  597.         return ret;
  598. }       



  602. jint
  603. Java_com_camera_simplewebcam_CameraPreview_prepareCameraWithBase( JNIEnv* env,jobject thiz, jint videoid, jint videobase){
  604.        
  605.                 int ret;

  607.                 camerabase = videobase;
  608.        
  609.                 return Java_com_camera_simplewebcam_CameraPreview_prepareCamera(env,thiz,videoid);
  610.        
  611. }

  613. void
  614. Java_com_camera_simplewebcam_CameraPreview_processCamera( JNIEnv* env,
  615.                                                                                 jobject thiz){

  617.         readframeonce();
  618. }

  620. void
  621. Java_com_camera_simplewebcam_CameraPreview_stopCamera(JNIEnv* env,jobject thiz){

  623.         stopcapturing ();

  625.         uninitdevice ();

  627.         closedevice ();

  629.         if(rgb) free(rgb);
  630.         if(ybuf) free(ybuf);
  631.         
  632.         fd = -1;

  634. }

  636. #endif

复制代码

上面是.c文件，下面是编译文件Android.mk，从代码就可以看出来，我的代码是从SimpleWebCam开源代码摘取的，特此感谢。

  1. LOCAL_PATH:= $(call my-dir)


  4. #########################################################
  5. include $(CLEAR_VARS)

  7. LOCAL_SRC_FILES:= ImageProc.c

  9. LOCAL_C_INCLUDES += external/jpeg \
  10.         external/skia/include/core/ \
  11.         frameworks/base/core/jni/android/graphics \
  12.         system/core/include/

  14. LOCAL_SHARED_LIBRARIES := libandroid_runtime


  17. LOCAL_CFLAGS := -Wall -fpic -pipe -O0

  19. LOCAL_MODULE    := ImageProc
  20. LOCAL_LDLIBS    := -llog

  22. include $(BUILD_EXECUTABLE)

复制代码

编译完成push到系统中，执行这个应用程序，pull出123_1.yuv文件。
直接使用vlc程序得到下面的结果：


使用另外一款YUV显示软件结果正常：


可以这么认为其实保存好的YUV数据文件的数据是对的，只是保存文件的头信息不对，导致两个软件显示结果不对，要深入理解这个问题就必须对YUV格式做进一步解析，这里只得出一个成功的结论。
三）总结：
1.对v4l2与Camera驱动的关系有了更进一步的认识；
2.对Camera模组支持模式：YUV和MJPG格式有了清晰认识；
3.对YUV格式数据文件读写加深了理解。
上一篇：天嵌Cortex-A8学习视频教程，免费奉送
下一篇：学习嵌入式
栏目分类
热门文章

Copyright © 2017-2020 微波EDA网 版权所有

网站地图

Top