NVIDIA Jetson TX1 系列开发教程之十：V4L2+OpenCV2.4.13实现预览、拍照功能

迷南。 2022-06-10 10:12 286阅读 0赞

**NVIDIA Jetson TX1 系列开发教程之十：V4L2+OpenCV2.4.13实现预览、拍照功能**

--------------------

*  **转载请注明作者和出处：[http://blog.csdn.net/u011475210][http_blog.csdn.net_u011475210]**
 *  **嵌入式平台：NVIDIA Jetson TX1**
 *  **嵌入式系统：Ubuntu16.04**
 *  **虚拟机系统：Ubuntu14.04**
 *  **编者: WordZzzz**

--------------------

**写在前面：**  
本篇博文主要用来讲解上篇博文中关于V4L2框架的程序部分，并在其基础上实现预览和拍照功能的实现.其中，预览分辨率640\*480，用键盘检测来改变标志位，当标志位改变时进行拍照，拍照分辨率1920\*1080，随后自动切换回预览模式，肉眼基本看不出切换卡顿。

**一、V4L2框架：**  
V4L2程序是基于标准的V4L2框架来写的，大部分程序注释都已给出，如果还有什么不清楚的地方，可以评论、私信或自行查阅V4L2开发手册。

下图是标准V4L2程序流程图。

![这里写图片描述][SouthEast]

博客中的程序，在标准V4L2程序的基础上进一步进行了封装，主要是为了实现拍照与预览模式的切换。

/*
     * v4l2cap.h
     *
     *  Created on: Jul 26, 2017
     *      Author: wordzzzz
     */
    
    #ifndef V4L2CAP_H_
    #define V4L2CAP_H_
    
    #include "include.h"
    
    #define CLEAR(x) memset(&(x), 0, sizeof(x))
    
    #define TRUE 1
    #define FALSE 0
    
    class V4L2Capture {
        
    public:
        V4L2Capture(char *devName, int width, int height, int width_cap, int height_cap);
        virtual ~V4L2Capture();
    
        int openDevice();
        int closeDevice();
        int initDevice();
        int initDeviceCap();
        int startCapture();
        int stopCapture();
        int freeBuffers();
        int getFrame(void **,size_t *);
        int backFrame();
        int pre2cap();
        int cap2pre();
        int preBegin();
        int preEnd();
    
        int initBuffers();
    
        struct cam_buffer
        {
            void* start;
            unsigned int length;
        };
        char *devName;
        int widthCap;
        int heightCap;
        int width;
        int height;
        int fd_cam;
        cam_buffer *buffers;
        unsigned int n_buffers;
        int frameIndex;
    };
    
    #endif /* V4L2CAP_H_ */

/*
     * v4l2cap.cpp
     *
     *  Created on: Jul 26, 2017
     *      Author: wordzzzz
     */
    
    #include "v4l2cap.h"
    
    V4L2Capture::V4L2Capture(char *devName, int width, int height, int width_cap, int height_cap) {
        // TODO Auto-generated constructor stub
        this->devName = devName;
        this->fd_cam = -1;
        this->buffers = NULL;
        this->n_buffers = 0;
        this->frameIndex = -1;
        this->width=width;
        this->height=height;
        this->widthCap=width_cap;
        this->heightCap=height_cap;
    }
    
    V4L2Capture::~V4L2Capture() {
        // TODO Auto-generated destructor stub
    }
    
    /**********打开设备**********/
    int V4L2Capture::openDevice() {
        /*设备的打开*/
        printf("video dev : %s\n", devName);
        fd_cam = open(devName, O_RDWR);
        if (fd_cam < 0) {
            perror("Can't open video device");
        }
        return TRUE;
    }
    
    /**********关闭设备**********/
    int V4L2Capture::closeDevice() {
        if (fd_cam > 0) {
            int ret = 0;
            if ((ret = close(fd_cam)) < 0) {
                perror("Can't close video device");
            }
            return TRUE;
        } else {
            return FALSE;
        }
    }
    
    /**********初始化设备（预览模式）**********/
    int V4L2Capture::initDevice() {
        int ret;
        struct v4l2_capability cam_cap;     //显示设备信息
        struct v4l2_cropcap cam_cropcap;    //设置摄像头的捕捉能力
        struct v4l2_fmtdesc cam_fmtdesc;    //查询所有支持的格式：VIDIOC_ENUM_FMT
        struct v4l2_crop cam_crop;          //图像的缩放
        struct v4l2_format cam_format;      //设置摄像头的视频制式、帧格式等
    
        /* 使用IOCTL命令VIDIOC_QUERYCAP，获取摄像头的基本信息*/
        ret = ioctl(fd_cam, VIDIOC_QUERYCAP, &cam_cap);
        if (ret < 0) {
            perror("Can't get device information: VIDIOCGCAP");
        }
        printf(
                "Driver Name:%s\nCard Name:%s\nBus info:%s\nDriver Version:%u.%u.%u\n",
                cam_cap.driver, cam_cap.card, cam_cap.bus_info,
                (cam_cap.version >> 16) & 0XFF, (cam_cap.version >> 8) & 0XFF,
                cam_cap.version & 0XFF);
    
        /* 使用IOCTL命令VIDIOC_ENUM_FMT，获取摄像头所有支持的格式*/
        cam_fmtdesc.index = 0;
        cam_fmtdesc.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
        printf("Support format:\n");
        while (ioctl(fd_cam, VIDIOC_ENUM_FMT, &cam_fmtdesc) != -1) {
            printf("\t%d.%s\n", cam_fmtdesc.index + 1, cam_fmtdesc.description);
            cam_fmtdesc.index++;
        }
    
        /* 使用IOCTL命令VIDIOC_CROPCAP，获取摄像头的捕捉能力*/
        cam_cropcap.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
        if (0 == ioctl(fd_cam, VIDIOC_CROPCAP, &cam_cropcap)) {
            printf("Default rec:\n\tleft:%d\n\ttop:%d\n\twidth:%d\n\theight:%d\n",
                    cam_cropcap.defrect.left, cam_cropcap.defrect.top,
                    cam_cropcap.defrect.width, cam_cropcap.defrect.height);
            /* 使用IOCTL命令VIDIOC_S_CROP，获取摄像头的窗口取景参数*/
            cam_crop.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
            cam_crop.c = cam_cropcap.defrect;       //默认取景窗口大小
            if (-1 == ioctl(fd_cam, VIDIOC_S_CROP, &cam_crop)) {
                //printf("Can't set crop para\n");
            }
        } else {
            printf("Can't set cropcap para\n");
        }
    
        /* 使用IOCTL命令VIDIOC_S_FMT，设置摄像头帧信息*/
        cam_format.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
        cam_format.fmt.pix.width = width;
        cam_format.fmt.pix.height = height;
        cam_format.fmt.pix.pixelformat = V4L2_PIX_FMT_MJPEG;        //要和摄像头支持的类型对应
        cam_format.fmt.pix.field = V4L2_FIELD_INTERLACED;
        ret = ioctl(fd_cam, VIDIOC_S_FMT, &cam_format);
        if (ret < 0) {
            perror("Can't set frame information");
        }
        /* 使用IOCTL命令VIDIOC_G_FMT，获取摄像头帧信息*/
        cam_format.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
        ret = ioctl(fd_cam, VIDIOC_G_FMT, &cam_format);
        if (ret < 0) {
            perror("Can't get frame information");
        }
        printf("Current data format information:\n\twidth:%d\n\theight:%d\n",
                cam_format.fmt.pix.width, cam_format.fmt.pix.height);
        return TRUE;
    }
    
    /**********初始化设备（拍照模式）**********/
    int V4L2Capture::initDeviceCap() {
        int ret;
        struct v4l2_format cam_format;      //设置摄像头的视频制式、帧格式等
    
        /* 使用IOCTL命令VIDIOC_S_FMT，设置摄像头帧信息*/
        cam_format.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
        cam_format.fmt.pix.width = widthCap;
        cam_format.fmt.pix.height = heightCap;
        cam_format.fmt.pix.pixelformat = V4L2_PIX_FMT_MJPEG;        //要和摄像头支持的类型对应
        cam_format.fmt.pix.field = V4L2_FIELD_INTERLACED;
        ret = ioctl(fd_cam, VIDIOC_S_FMT, &cam_format);
        if (ret < 0) {
            perror("Can't set frame information");
        }
        /* 使用IOCTL命令VIDIOC_G_FMT，获取摄像头帧信息*/
        cam_format.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
        ret = ioctl(fd_cam, VIDIOC_G_FMT, &cam_format);
        if (ret < 0) {
            perror("Can't get frame information");
        }
        printf("Current data format information:\n\twidth:%d\n\theight:%d\n",
                cam_format.fmt.pix.width, cam_format.fmt.pix.height);
        return TRUE;
    }
    
    /**********申请缓存**********/
    int V4L2Capture::initBuffers() {
        int ret;
        /* 使用IOCTL命令VIDIOC_REQBUFS，申请帧缓冲*/
        struct v4l2_requestbuffers req;
        CLEAR(req);
        req.count = 4;
        req.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
        req.memory = V4L2_MEMORY_MMAP;
        ret = ioctl(fd_cam, VIDIOC_REQBUFS, &req);
        if (ret < 0) {
            perror("Request frame buffers failed");
        }
        if (req.count < 2) {
            perror("Request frame buffers while insufficient buffer memory");
        }
        buffers = (struct cam_buffer*) calloc(req.count, sizeof(*buffers));
        if (!buffers) {
            perror("Out of memory");
        }
        for (n_buffers = 0; n_buffers < req.count; n_buffers++) {
            struct v4l2_buffer buf;
            CLEAR(buf);
            // 查询序号为n_buffers 的缓冲区，得到其起始物理地址和大小
            buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
            buf.memory = V4L2_MEMORY_MMAP;
            buf.index = n_buffers;
            ret = ioctl(fd_cam, VIDIOC_QUERYBUF, &buf);
            if (ret < 0) {
                printf("VIDIOC_QUERYBUF %d failed\n", n_buffers);
                return FALSE;
            }
            buffers[n_buffers].length = buf.length;
            //printf("buf.length= %d\n",buf.length);
            // 映射内存
            buffers[n_buffers].start = mmap(
                    NULL, // start anywhere
                    buf.length, PROT_READ | PROT_WRITE, MAP_SHARED, fd_cam,
                    buf.m.offset);
            if (MAP_FAILED == buffers[n_buffers].start) {
                printf("mmap buffer%d failed\n", n_buffers);
                return FALSE;
            }
        }
        return TRUE;
    }
    
    /**********释放缓存**********/
    int V4L2Capture::freeBuffers() {
        unsigned int i;
        for (i = 0; i < n_buffers; ++i) {
            if (-1 == munmap(buffers[i].start, buffers[i].length)) {
                printf("munmap buffer%d failed\n", i);
                return FALSE;
            }
        }
        free(buffers);
        return TRUE;
    }
    
    /**********开始采集**********/
    int V4L2Capture::startCapture() {
        unsigned int i;
        for (i = 0; i < n_buffers; i++) {
            struct v4l2_buffer buf;
            CLEAR(buf);
            buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
            buf.memory = V4L2_MEMORY_MMAP;
            buf.index = i;
            if (-1 == ioctl(fd_cam, VIDIOC_QBUF, &buf)) {
                printf("VIDIOC_QBUF buffer%d failed\n", i);
                return FALSE;
            }
        }
        enum v4l2_buf_type type;
        type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
        if (-1 == ioctl(fd_cam, VIDIOC_STREAMON, &type)) {
            printf("VIDIOC_STREAMON error");
            return FALSE;
        }
        return TRUE;
    }
    
    
    /**********停止采集**********/
    int V4L2Capture::stopCapture() {
        enum v4l2_buf_type type;
        type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
        if (-1 == ioctl(fd_cam, VIDIOC_STREAMOFF, &type)) {
            printf("VIDIOC_STREAMOFF error\n");
            return FALSE;
        }
        return TRUE;
    }
    
    /**********获取图像**********/
    int V4L2Capture::getFrame(void **frame_buf, size_t* len) {
        struct v4l2_buffer queue_buf;
        CLEAR(queue_buf);
        queue_buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
        queue_buf.memory = V4L2_MEMORY_MMAP;
        if (-1 == ioctl(fd_cam, VIDIOC_DQBUF, &queue_buf)) {
            printf("VIDIOC_DQBUF error\n");
            return FALSE;
        }
        //printf("queue_buf.index=%d\n",queue_buf.index);
        //pthread_rwlock_wrlock(&rwlock);
        *frame_buf = buffers[queue_buf.index].start;
        *len = buffers[queue_buf.index].length;
        frameIndex = queue_buf.index;
        //pthread_rwlock_unlock(&rwlock);
        return TRUE;
    }
    
    /**********返回队列**********/
    int V4L2Capture::backFrame() {
        if (frameIndex != -1) {
            struct v4l2_buffer queue_buf;
            CLEAR(queue_buf);
            queue_buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
            queue_buf.memory = V4L2_MEMORY_MMAP;
            queue_buf.index = frameIndex;
            if (-1 == ioctl(fd_cam, VIDIOC_QBUF, &queue_buf)) {
                printf("VIDIOC_QBUF error\n");
                return FALSE;
            }
            return TRUE;
        }
        return FALSE;
    }
    
    /**********预览切换至拍照**********/
    int V4L2Capture::pre2cap() {
        if(V4L2Capture::stopCapture() == FALSE){
            printf("StopCapture fail~~\n");
            exit(2);
        }
        if(V4L2Capture::freeBuffers() == FALSE){
            printf("FreeBuffers fail~~\n");
            exit(2);
        }
        if(V4L2Capture::closeDevice() == FALSE){
            printf("CloseDevice fail~~\n");
            exit(1);
        }
        if(V4L2Capture::openDevice() == FALSE){
            printf("OpenDevice fail~~\n");
            exit(1);
        }
        if(V4L2Capture::initDeviceCap() == FALSE){
            printf("InitDeviceCap fail~~\n");
            exit(1);
        }
        if(V4L2Capture::initBuffers() == FALSE){
            printf("InitBuffers fail~~\n");
            exit(2);
        }
        if(V4L2Capture::startCapture() == FALSE){
            printf("StartCapture fail~~\n");
            exit(2);
        }
        return TRUE;
    }
    
    /**********拍照切换至预览**********/
    int V4L2Capture::cap2pre() {
        if(V4L2Capture::stopCapture() == FALSE){
            printf("StopCapture fail~~\n");
            exit(2);
        }
        if(V4L2Capture::freeBuffers() == FALSE){
            printf("FreeBuffers fail~~\n");
            exit(2);
        }
        if(V4L2Capture::closeDevice() == FALSE){
            printf("CloseDevice fail~~\n");
            exit(1);
        }
        if(V4L2Capture::openDevice() == FALSE){
            printf("OpenDevice fail~~\n");
            exit(1);
        }
        if(V4L2Capture::initDevice() == FALSE){
            printf("InitDevice fail~~\n");
            exit(1);
        }
        if(V4L2Capture::initBuffers() == FALSE){
            printf("InitBuffers fail~~\n");
            exit(2);
        }
        if(V4L2Capture::startCapture() == FALSE){
            printf("StartCapture fail~~\n");
            exit(2);
        }
        return TRUE;
    }
    
    /**********预览开启**********/
    int V4L2Capture::preBegin() {
        if(V4L2Capture::openDevice() == FALSE){
            printf("OpenDevice fail~~\n");
            exit(1);
        }
        printf("first~~\n");
        if(V4L2Capture::initDevice() == FALSE){
            printf("InitDevice fail~~\n");
            exit(1);
        }
        printf("second~~\n");
        if(V4L2Capture::initBuffers() == FALSE){
            printf("InitBuffers fail~~\n");
            exit(2);
        }
        printf("third~~\n");
        if(V4L2Capture::startCapture() == FALSE){
            printf("StartCapture fail~~\n");
            exit(2);
        }
        printf("fourth~~\n");
        return TRUE;
    }
    
    /**********预览结束**********/
    int V4L2Capture::preEnd() {
        if(V4L2Capture::stopCapture() == FALSE){
            printf("StopCapture fail~~\n");
            exit(2);
        }
        if(V4L2Capture::freeBuffers() == FALSE){
            printf("FreeBuffers fail~~\n");
            exit(2);
        }
        if(V4L2Capture::closeDevice() == FALSE){
            printf("CloseDevice fail~~\n");
            exit(1);
        }
        return TRUE;
    }

**二、键盘检测：**  
主要实现的功能是通过模拟kbhit功能，实现在线程中完成对键盘的检测功能（检测到‘c’时标志位置1）。

/*
     * pthread.h
     *
     *  Created on: Jul 27, 2017
     *      Author: wordzzzz
     */
    
    #ifndef PTHREAD_H_
    #define PTHREAD_H_
    
    #include "include.h"
    
    static __inline
    int tty_reset(void);
    
    static __inline
    int tty_set(void);
    
    static __inline
    int kbhit(void);
    
    void *thread(void *arg);
    
    static struct termios ori_attr, cur_attr;
    
    extern uchar flag;
    
    #endif /* PTHREAD_H_ */

/*
     * pthread.cpp
     *
     *  Created on: Jul 27, 2017
     *      Author: wordzzzz
     */
    
    #include "thread.h"
    
    static __inline
    int tty_reset(void)
    {
            if (tcsetattr(STDIN_FILENO, TCSANOW, &ori_attr) != 0)
                    return -1;
    
            return 0;
    }
    
    static __inline
    int tty_set(void)
    {
    
            if ( tcgetattr(STDIN_FILENO, &ori_attr) )
                    return -1;
    
            memcpy(&cur_attr, &ori_attr, sizeof(cur_attr) );
            cur_attr.c_lflag &= ~ICANON;
    //        cur_attr.c_lflag |= ECHO;
            cur_attr.c_lflag &= ~ECHO;
            cur_attr.c_cc[VMIN] = 1;
            cur_attr.c_cc[VTIME] = 0;
    
            if (tcsetattr(STDIN_FILENO, TCSANOW, &cur_attr) != 0)
                    return -1;
    
            return 0;
    }
    
    static __inline
    int kbhit(void)
    {
    
            fd_set rfds;
            struct timeval tv;
            int retval;
    
            /* Watch stdin (fd 0) to see when it has input. */
            FD_ZERO(&rfds);
            FD_SET(0, &rfds);
            /* Wait up to five seconds. */
            tv.tv_sec  = 0;
            tv.tv_usec = 0;
    
            retval = select(1, &rfds, NULL, NULL, &tv);
            /* Don't rely on the value of tv now! */
    
            if (retval == -1) {
                    perror("select()");
                    return 0;
            } else if (retval)
                    return 1;
            /* FD_ISSET(0, &rfds) will be true. */
            else
                    return 0;
            return 0;
    }
    
    void *thread(void *arg)
    {
        int tty_set_flag;
        tty_set_flag = tty_set();
        while(1) {
    
            if( kbhit() ) {
                const int key = getchar();
                printf("%c pressed\n", key);
                //检测到'c'则标志位置1
                if(key == 'c')
                    flag=1;
                //检测到'q'则退出程序
                if(key == 'q')
                    exit(0);
                    break;
            } else {
    //              fprintf(stderr, "<no key detected>\n");
            }
        }
    
        if(tty_set_flag == 0)
                tty_reset();
        return 0;
    }

**三、主函数：**  
include.h里面包含我们所有用到的头文件。

/*
     * include.h
     *
     *  Created on: Jul 26, 2017
     *      Author: wordzzzz
     */
    
    #ifndef INCLUDE_H_
    #define INCLUDE_H_
    
    extern "C" {
    #include <unistd.h>
    #include <error.h>
    #include <fcntl.h>
    #include <pthread.h>
    #include <termios.h>
    #include <linux/videodev2.h>
    #include <sys/mman.h>
    #include <sys/time.h>
    #include <sys/ioctl.h>
    #include <sys/types.h>
    
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    }
    
    #include <iostream>
    #include <iomanip>
    #include <string>
    
    #include <opencv2/core/core.hpp>
    #include <opencv2/highgui/highgui.hpp>
    
    using namespace std;
    
    #endif /* INCLUDE_H_ */

主函数主要实现预览模式的开启、键盘检测线程开启，预览和拍照模式的切换等功能，总体程序比较简单。

/*
     * main.cpp
     *
     *  Created on: Jul 26, 2017
     *      Author: wordzzzz
     */
    
    #include "include.h"
    #include "v4l2cap.h"
    #include "thread.h"
    
    #define IMAGEWIDTH_CAP 1920 //拍照分辨率
    #define IMAGEHEIGHT_CAP 1080//拍照分辨率
    
    #define IMAGEWIDTH 640      //预览分辨率
    #define IMAGEHEIGHT 480     //预览分辨率
    
    #define TRUE 1
    #define FALSE 0
    
    uchar flag;
    
    int main()
    {
        IplImage* img,* img_cap;
        CvMat cvmat,cvmat_cap;
        double t;
        flag=0;
        unsigned char *frame = NULL;
        unsigned long frameSize = 0;
        string videoDev="/dev/video1";//制定设备号
    
        V4L2Capture *vcap = new V4L2Capture(const_cast<char*>(videoDev.c_str()),
                IMAGEWIDTH, IMAGEHEIGHT, IMAGEWIDTH_CAP, IMAGEHEIGHT_CAP);
        vcap->preBegin();//预览模式开启
    
        cvNamedWindow("one",CV_WINDOW_AUTOSIZE);//创建显示窗口
    
        pthread_t id;
        printf("Main thread id is %d \n",pthread_self());
        if(!pthread_create(&id,NULL,thread,NULL))
        {
        printf("succeed!\n");
        }
        else
        {
       printf("Fail to Create Thread");
        return -1;
        }
    
        while(1){
            //如果flag为1，则抓取一张照片
            if(flag == 1){
                vcap->pre2cap();                      //预览模式切换至拍照模式
                //这里多获取几次图像队列，以便得到更高的图像质量（刚打开设备时图像模糊）
                vcap->getFrame((void **) &frame, &frameSize);vcap->backFrame();
                vcap->getFrame((void **) &frame, &frameSize);vcap->backFrame();
                vcap->getFrame((void **) &frame, &frameSize);
                cvmat_cap = cvMat(IMAGEHEIGHT_CAP,IMAGEWIDTH_CAP,CV_8UC3,frame);//CV_8UC3
                img_cap = cvDecodeImage(&cvmat_cap,1);//OpenCV图像解码
    
                if(!img_cap)    printf("No img_cap\n");
                cvSaveImage("cap.jpg",img_cap);       //保存图片
                cvReleaseImage(&img_cap);             //释放img_cap
                vcap->backFrame();                    //返回队列
    
                vcap->cap2pre();                      //拍照模式切换至预览模式
    
                flag = 0;
            }
            t = (double)cvGetTickCount();
            vcap->getFrame((void **) &frame, &frameSize);
            cvmat = cvMat(IMAGEHEIGHT,IMAGEWIDTH,CV_8UC3,frame);//CV_8UC3
            img = cvDecodeImage(&cvmat,1);           //OpenCV图像解码
            if(!img)    printf("No img\n");
            cvShowImage("one",img);                  //显示图片
            cvReleaseImage(&img);                    //释放img
            vcap->backFrame();                       //返回队列
            cvWaitKey(1);                            //没有这句话图像无法显示
            t=(double)cvGetTickCount()-t;
            printf("used time is %gms\n",(t/(cvGetTickFrequency()*1000)));
        }
    
        pthread_exit(0);                            //退出键盘检测线程
    
        vcap->preEnd();                             //预览模式结束
    
        return 0;
    }

**系列教程持续发布中，欢迎订阅、关注、收藏、评论、点赞哦～～(￣▽￣～)～**

**完的汪(∪｡∪)｡｡｡zzz**

[http_blog.csdn.net_u011475210]: http://blog.csdn.net/u011475210
[SouthEast]: /images/20220610/cda2b5b7c6534e65bd156d576c16adb9.png