Ubuntu上Qt+Tcp网络编程+V4L2之视频监控

#ifndef SERVER_H
#define SERVER_H

#include <QWidget>
#include "mycamera.h"

class QTcpServer;
class QTcpSocket; //类前置声明

namespace Ui {
class Server;
}

class Server : public QWidget
{
    Q_OBJECT

public:
    explicit Server(QWidget *parent = 0);
    ~Server();

private:
    Ui::Server *ui;

    QTcpServer *tcpServer;   //监听套接字对象指针
    QTcpSocket *tcpConnection;   //连接套接字指针
    Mycamera *camera;    //Mycameta类指针
    unsigned char * pointer_yuv_buffer;   //yuv格式的帧数据缓冲区指针
    unsigned int len;   //帧数据长度
    unsigned char rgb_buffer[IMG_HEIGTH*IMG_WIDTH*3];   //rgb格式的帧数据缓冲区指针
    bool state;    //帧数据获取状态指示标记
    int convert_yuv_to_rgb_buffer();    //将帧数据转换为rgb格式并保存至缓存区

private slots:
    void sendImage();   //私有槽，从摄像头获取帧数据进行格式转换后发送
};

#endif // SERVER_H

#include "server.h"
#include "ui_server.h"
#include <QtNetwork>


Server::Server(QWidget *parent) :
    QWidget(parent),
    ui(new Ui::Server)
{
    ui->setupUi(this);
    //启动摄像头设备
    camera = new Mycamera(tr("/dev/video0"));

    //启动监听套接字
    tcpServer = new QTcpServer(this);

    //设置可以监听的IP范围和端口地址，将端口设置为8888
    if(!tcpServer->listen(QHostAddress::Any,8888))
    {
        qDebug() << tcpServer->errorString();
        close();
    }

    //将sendImage槽与newConnection()信号关联
    connect(tcpServer,SIGNAL(newConnection()),this,SLOT(sendImage()));
}

Server::~Server()
{
    delete camera;
    camera = NULL;
    delete tcpServer;
    tcpServer = NULL;
    delete ui;
}

void Server::sendImage()
{
    //从摄像头获取数据
    this->len = 0;
    this->pointer_yuv_buffer = NULL;
    state = camera->get_frame(&this->pointer_yuv_buffer,&this->len);
    if(state)
    {
        convert_yuv_to_rgb_buffer();    //转化格式并保存数据

        QByteArray block;      //用于暂存要发送的数据
        QDataStream out(&block,QIODevice::WriteOnly);   //数据流

        //设置数据流的版本，与客户端和服务器端所使用的版本相同
        out.setVersion(QDataStream::Qt_4_8);

        int bytesWritten = out.writeRawData((const char *)rgb_buffer,IMG_WIDTH*IMG_HEIGTH*3);

        if(!(bytesWritten == IMG_HEIGTH*IMG_WIDTH*3))
        {
            qDebug() << "error:writing data to socket !\n";
        }

        //获取已经建立连接的套接字
        QTcpSocket *clientConnection = tcpServer->nextPendingConnection();
        connect(clientConnection,SIGNAL(disconnected()),clientConnection,SLOT(deleteLater()));
        clientConnection->write(block);
        clientConnection->disconnectFromHost();

        //发送成功后，释放一帧数据
        camera->unget_frame();
    }
    else
    {
        qDebug() << "error:cannot get frame from cameta!\n";
    }
}

int Server::convert_yuv_to_rgb_buffer()
{
    unsigned char * pointer;
    int i,j;
    unsigned char y1,y2,u,v;
    int r1,g1,b1,r2,g2,b2;

    pointer = pointer_yuv_buffer;

    for(i=0;i<IMG_HEIGTH;i++)
    {
        for(j=0;j<(IMG_WIDTH/2);j++)
        {
            y1 = *(pointer + (i*(IMG_WIDTH/2) + j) *4);
            u  = *(pointer + (i*(IMG_WIDTH/2) + j) *4 + 1);
            y2 = *(pointer + (i*(IMG_WIDTH/2) + j) *4 + 2);
            v  = *(pointer + (i*(IMG_WIDTH/2) + j) *4 + 3);

            r1 = y1 + 1.042 * (v - 128);
            g1 = y1 - 0.34414 * (u - 128) - 0.71414 * (v - 128);
            b1 = y1 + 1.772 * (u - 128);

            r2 = y2 + 1.042 * (v - 128);
            g2 = y2 - 0.34414 * (u - 128) - 0.71414 * (v - 128);
            b2 = y2 + 1.772 * (u - 128);

            if(r1 > 255)
                r1 = 255;
            else if(r1 < 0)
                r1 = 0;

            if(b1 > 255)
                b1 = 255;
            else if(b1 < 0)
                b1 = 0;

            if(g1 > 255)
                g1 = 255;
            else if(g1 < 0)
                g1 = 0;

            if(r2 > 255)
                r2 = 255;
            else if(r2 < 0)
                r2 = 0;

            if(b2 > 255)
                b2 = 255;
            else if(b2 < 0)
                b2 = 0;

            if(g2 > 255)
                g2 = 255;
            else if(g2 < 0)
                g2 = 0;

            *(rgb_buffer +(i * (IMG_WIDTH/2) + j) * 6) = (unsigned char) r1;
            *(rgb_buffer +(i * (IMG_WIDTH/2) + j) * 6 + 1) = (unsigned char) g1;
            *(rgb_buffer +(i * (IMG_WIDTH/2) + j) * 6 + 2) = (unsigned char) b1;
            *(rgb_buffer +(i * (IMG_WIDTH/2) + j) * 6 + 3) = (unsigned char) r2;
            *(rgb_buffer +(i * (IMG_WIDTH/2) + j) * 6 + 4) = (unsigned char) g2;
            *(rgb_buffer +(i * (IMG_WIDTH/2) + j) * 6 + 5) = (unsigned char) b2;
        }
    }
    return 0;
}

#ifndef MYCAMERA_H
#define MYCAMERA_H

#include <QObject>   //QObject类是所有Qt类的基类，也是Qt对象模型的核心
#include <stdio.h>
//#include <stddef.h>      //包含了size_t 的定义  size_t实际就是unsigned int，会根据系统位数不同而不同
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>   //包含open
#include <unistd.h>  //包含close
#include <sys/ioctl.h>
#include <sys/stat.h>
#include <sys/mman.h>   //mmap和munmap
#include <linux/videodev2.h>    //v4l2必包含
#include <linux/types.h>
#include <asm/types.h>

#define FILE_VIDEO "/dev/video0"
#define IMG_WIDTH 640
#define IMG_HEIGTH 480

class Mycamera:public QObject
{
public:
    Mycamera(QString camera_name);  //构造函数
    ~Mycamera();               //析构函数
    int get_frame(unsigned char * * pointer_yuv_buffer,unsigned int * len);    //获取帧数据
    int unget_frame();    //释放帧数据
private:
    struct buffer
    {
        void * start;
        size_t length;
    };  //帧数据缓冲区 数据结构

    QString camera_name;   //摄像头头名 （一般为/dev/video0）
    int fd;  //摄像头设备文件ID
    buffer * buffers;   //缓冲区指针
    unsigned int n_buffers;   //缓存个数
    int index;    //缓存索引

    int open_camera();   //开启摄像头
    int init_camera();   //初始化摄像头
    int start_capture();   //启动摄像头
    int init_mmap();    //申请视频缓冲区，并mmap到用户空间
    int stop_capture();    //停止视频采集
    int uninit_camera();    //释放申请的帧缓冲区
    int close_camera();    //关闭摄像头设备文件
};

#endif // MYCAMERA_H

#include "mycamera.h"

Mycamera::Mycamera(QString camera_name)
{
    this->camera_name = camera_name;
    this->fd = -1;
    this->buffers = NULL;
    this->n_buffers = 0;
    this->index = -1;
    if(open_camera() == false)
    {
        close_camera();// 定义在头文件<unistd.h>中
    }
    if(init_camera() == false)
    {
        close_camera();
    }
    if(start_capture() == false)
    {
        stop_capture();
        close_camera();
    }
}

Mycamera::~Mycamera()
{
    stop_capture();
    uninit_camera();
    close_camera();
}

int Mycamera::open_camera()   //打开摄像头设备文件
{
    fd = open(FILE_VIDEO,O_RDWR);
    if(fd == -1)
    {
        printf("Error opening V4L2 interface\n");
        return false;
    }
    return true;
}

int Mycamera::init_camera()   //初始化摄像头
{
    v4l2_capability cap;
    v4l2_fmtdesc fmtdesc;
    v4l2_format fmt;
    v4l2_streamparm setfps;
    //查询设备属性
    if(ioctl(fd,VIDIOC_QUERYCAP,&cap) == -1)
    {
        printf("Error opening device %s: unable to query device.\n",FILE_VIDEO);
        return false;
    }
    else
    {
        printf("driver:\t\t%s\n",cap.driver);
        printf("card:\t\t%s\n",cap.card);
        printf("bus_info:\t\t%s\n",cap.bus_info);
        printf("version:\t\t%d\n",cap.version);
        printf("capabilities:\t\t%x\n",cap.capabilities);

        if((cap.capabilities & V4L2_CAP_VIDEO_CAPTURE) == V4L2_CAP_VIDEO_CAPTURE)
        {
            printf("Device %s:supports capture.\n",FILE_VIDEO);
        }

        if((cap.capabilities & V4L2_CAP_STREAMING) == V4L2_CAP_STREAMING)
        {
            printf("Device %s:supports streaming\n",FILE_VIDEO);
        }
    }

    //列举摄像头所支持的像素格式
    fmtdesc.index = 0;
    fmtdesc.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    printf("Support format:\n");
    while(ioctl(fd,VIDIOC_ENUM_FMT,&fmtdesc) != -1)
    {
        printf("\t%d.%s\n",fmtdesc.index+1,fmtdesc.description);
        fmtdesc.index++;
    }

    //设置像素格式
    fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV;
    fmt.fmt.pix.height = IMG_HEIGTH;
    fmt.fmt.pix.width = IMG_WIDTH;
    fmt.fmt.pix.field = V4L2_FIELD_INTERLACED;

    if(ioctl(fd,VIDIOC_S_FMT,&fmt) == -1)
    {
        return false;
    }
    //为了确保设置的格式作用到摄像头上，再通过命令VIDIOC_G_FMT将摄像头设置读取回来
    if(ioctl(fd,VIDIOC_G_FMT,&fmt) == -1)
    {
        printf("fmt.type：\t\t%d\n",fmt.type);
        printf("pix.pixelformat:\t\t%c%c%c%c\n",fmt.fmt.pix.pixelformat & 0xFF,(fmt.fmt.pix.pixelformat >> 8) & 0xFF,(fmt.fmt.pix.pixelformat >> 16) & 0xFF,(fmt.fmt.pix.pixelformat >> 24) & 0xFF);
        printf("pix.height:\t\t%d\n",fmt.fmt.pix.height);
        printf("pix.width:\t\t%d\n",fmt.fmt.pix.width);
        printf("pix.field:\t\t%d\n",fmt.fmt.pix.field);
    }

    //设置帧率
    setfps.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

    setfps.parm.capture.timeperframe.numerator = 1;
    setfps.parm.capture.timeperframe.denominator = 10;

    if(ioctl(fd,VIDIOC_S_PARM,&setfps) == -1)
    {
        return false;
    }
    else
    {
        printf("init %s \t[OK]\n",FILE_VIDEO);
    }

    //调用init_mmap()函数来申请缓冲区，并mmap到用户空间
    if(init_mmap() == false)
    {
        return false;
    }

    return true;
}

int Mycamera::init_mmap()   //申请缓冲区，并mmap到用户空间
{
    //申请视频缓冲区
    v4l2_requestbuffers req;

    req.count = 2;
    req.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    req.memory = V4L2_MEMORY_MMAP;

    if(ioctl(fd,VIDIOC_REQBUFS,&req) == -1)
    {
        printf("request for buffers error\n");
        return false;
    }
    if(req.count < 2)
    {
        return false;
    }

    //分配缓存区内存
    buffers = (buffer *)calloc(req.count,sizeof(*buffers));

    if(!buffers)
    {
        printf("Out of memory\n");
        return false;
    }

    //mmap到用户空间
    for(n_buffers = 0;n_buffers < req.count;++n_buffers)
    {
        v4l2_buffer buf;

        buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
        buf.memory = V4L2_MEMORY_MMAP;
        buf.index = n_buffers;

        if(ioctl(fd,VIDIOC_QUERYBUF,&buf) == -1)
        {
            printf("Query buffer error\n");
            return false;
        }

        buffers[n_buffers].length = buf.length;
        buffers[n_buffers].start  = mmap(NULL,buf.length,PROT_READ | PROT_WRITE,MAP_SHARED,fd,buf.m.offset);

        if(buffers[n_buffers].start == MAP_FAILED)
        {
            printf("buffer map error\n");
            return false;
        }
    }

    return true;
}

int Mycamera::stop_capture()    //停止视频采集
{
    v4l2_buf_type type;
    type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

    if(ioctl(fd,VIDIOC_STREAMOFF,&type) == -1)
    {
        printf("streaming off error\n");
        return false;
    }

    return true;
}

int Mycamera::start_capture()   //开始视频采集
{
    unsigned int i;

    for(i = 0; i < n_buffers; ++i)
    {
        v4l2_buffer buf;

        buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
        buf.memory = V4L2_MEMORY_MMAP;
        buf.index = i;

        if(ioctl(fd,VIDIOC_QBUF,&buf) == -1)
        {
            return false;
        }
    }

    v4l2_buf_type type;

    type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

    if(ioctl(fd,VIDIOC_STREAMON,&type) == -1)
    {
        printf("streaming on error\n");
        return false;
    }

    return true;
}

int Mycamera::get_frame(unsigned char * *pointer_yuv_buffer, unsigned int *len)  //获取视频帧
{
    v4l2_buffer queue_buf;

    queue_buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    queue_buf.memory = V4L2_MEMORY_MMAP;

    if(ioctl(fd,VIDIOC_DQBUF,&queue_buf) == -1)
    {
        return false;
    }

    *pointer_yuv_buffer = (unsigned char *)buffers[queue_buf.index].start;
    *len = buffers[queue_buf.index].length;
    index = queue_buf.index;

    return true;
}

int Mycamera::unget_frame()   //释放视频帧，让出缓存空间，准备新的视频帧数据
{
    if(index != -1)
    {
        v4l2_buffer queue_buf;

        queue_buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
        queue_buf.memory = V4L2_MEMORY_MMAP;
        queue_buf.index = index;

        if(ioctl(fd,VIDIOC_QBUF,&queue_buf) == -1)
        {
            return false;
        }
        return true;
    }

    return false;
}

int Mycamera::uninit_camera()   //释放申请的帧缓冲区
{
    unsigned int i;

    for(i = 0; i < n_buffers; ++i)
    {
        if(munmap(buffers[i].start,buffers[i].length) == -1)
        {
            return false;
        }
    }

    delete buffers;
    return true;
}

int Mycamera::close_camera()  //关闭摄像头设备文件
{
    int flag;

    flag = close(fd);

    if(flag == -1)
    {
        return false;
    }

    return true;
}

#ifndef CLIENT_H
#define CLIENT_H

#include <QDialog>
#include <QAbstractSocket>

#define IMG_WIDTH 640
#define IMG_HEIGTH 480

class QTcpSocket;

namespace Ui {
class Client;
}

class Client : public QDialog
{
    Q_OBJECT

public:
    explicit Client(QWidget *parent = 0);
    ~Client();

private:
    Ui::Client *ui;
    QTcpSocket *tcpSocket;
    unsigned char rgb_buffer[IMG_HEIGTH*IMG_WIDTH*3];

    //帧数据缓存区
    QImage *frame;   //图像类变量
    int id;    //计时器ID

private slots:
    void newConnection();    //建立新的连接
    void readMessage();     //读取数据
    void displayError(QAbstractSocket::SocketError);     //显示错误信息

    void on_pushButton_link_clicked();      //连接按钮
    void on_pushButton_unlink_clicked();    //断开按钮
protected:
    void timerEvent(QTimerEvent *);
};

#endif // CLIENT_H

#include "client.h"
#include "ui_client.h"
#include "QtNetwork"

Client::Client(QWidget *parent) :
    QDialog(parent),
    ui(new Ui::Client)
{
    ui->setupUi(this);
    tcpSocket = new QTcpSocket(this);
    connect(tcpSocket,SIGNAL(readyRead()),this,SLOT(readMessage()));
            connect(tcpSocket,SIGNAL(error(QAbstractSocket::SocketError)),this,SLOT(displayError(QAbstractSocket::SocketError)));
    ui->pushButton_unlink->setEnabled(false);

}

Client::~Client()
{
    delete tcpSocket;
    tcpSocket = NULL;
    delete ui;
}

void Client::newConnection()
{
    //取消已有连接
    tcpSocket->abort();
    //用输入的主机名和端口号连接服务器
    tcpSocket->connectToHost(ui->LineEdit_host->text(),ui->LineEdit_port->text().toInt());

}


void Client::readMessage()
{
    QDataStream in(tcpSocket);
    //设置数据流版本，这里要和服务器端的版本相同
    in.setVersion(QDataStream::Qt_4_8);

    //如果没有得到全部的数据，则返回，继续接收收据
    if(tcpSocket->bytesAvailable() < IMG_HEIGTH * IMG_WIDTH * 3)
        return;

    //将接收到的数据存放到变量中
    in.readRawData((char *)rgb_buffer,IMG_WIDTH * IMG_HEIGTH *3);

    //显示接收到的数据
    frame = new QImage(rgb_buffer,IMG_WIDTH,IMG_HEIGTH,QImage::Format_RGB888);
    ui->label_video->setPixmap(QPixmap::fromImage(* frame,Qt::AutoColor));
}


void Client::displayError(QAbstractSocket::SocketError)
{
    qDebug() << tcpSocket->errorString();
}


void Client::timerEvent(QTimerEvent *)
{
    newConnection();   //计数器溢出时调用newconnect函数
}


void Client::on_pushButton_link_clicked()
{
    id = startTimer(150);
    ui->pushButton_link->setEnabled(false);
    ui->pushButton_unlink->setEnabled(true);
}

void Client::on_pushButton_unlink_clicked()
{
    killTimer(id);
    ui->pushButton_link->setEnabled(true);
}