Qt通过UDP传图片，实现自定义分包和组包

最新推荐文章于 2023-09-02 14:02:47 发布
最新推荐文章于 2023-09-02 14:02:47 发布
阅读量1.2k 收藏 5
点赞数
分类专栏： QT


转载 http://blog.csdn.net/caoshangpa/article/details/52681572

一.包头结构体

[cpp] view plain copy
print ?
  1. //包头  
  2. struct PackageHeader  
  3. {  
  4.     //包头大小(sizeof(PackageHeader))  
  5.     unsigned int uTransPackageHdrSize;  
  6.     //当前包头的大小(sizeof(PackageHeader)+当前数据包长度)  
  7.     unsigned int uTransPackageSize;  
  8.     //数据的总大小  
  9.     unsigned int uDataSize;  
  10.     //数据被分成包的个数  
  11.     unsigned int uDataPackageNum;  
  12.     //数据包当前的帧号  
  13.     unsigned int uDataPackageCurrIndex;  
  14.     //数据包在整个数据中的偏移  
  15.     unsigned int uDataPackageOffset;  
  16. };  
//包头
struct PackageHeader
{
    //包头大小(sizeof(PackageHeader))
    unsigned int uTransPackageHdrSize;
    //当前包头的大小(sizeof(PackageHeader)+当前数据包长度)
    unsigned int uTransPackageSize;
    //数据的总大小
    unsigned int uDataSize;
    //数据被分成包的个数
    unsigned int uDataPackageNum;
    //数据包当前的帧号
    unsigned int uDataPackageCurrIndex;
    //数据包在整个数据中的偏移
    unsigned int uDataPackageOffset;
};
每包数据由包头和包体组成，包头用于标记每包数据的特征，包体是图片根据指定大小分出的每段数据，这里指定大小为const int UDP_MAX_SIZE=1200。

为何要分包可参考：TCP、UDP数据包大小的限制

二.分包与组包

1.分包

[cpp] view plain copy
print ?
  1. int dataLength=buffer.data().size();  
  2.   
  3. unsigned char *dataBuffer=(unsigned char *)buffer.data().data();  
  4.   
  5. int packetNum = 0;  
  6. int lastPaketSize = 0;  
  7. packetNum = dataLength / UDP_MAX_SIZE;  
  8. lastPaketSize = dataLength % UDP_MAX_SIZE;  
  9. int currentPacketIndex = 0;  
  10. if (lastPaketSize != 0)  
  11. {  
  12.     packetNum = packetNum + 1;  
  13. }  
  14.   
  15. PackageHeader packageHead;  
  16.   
  17. packageHead.uTransPackageHdrSize=sizeof(packageHead);  
  18. packageHead.uDataSize = dataLength;  
  19. packageHead.uDataPackageNum = packetNum;  
  20.   
  21. unsigned char frameBuffer[1024*1000];  
  22. memset(frameBuffer,0,1024*1000);  
  23. while (currentPacketIndex < packetNum)  
  24. {  
  25.     if (currentPacketIndex < (packetNum-1))  
  26.     {  
  27.         packageHead.uTransPackageSize = sizeof(PackageHeader)+UDP_MAX_SIZE;  
  28.         packageHead.uDataPackageCurrIndex = currentPacketIndex+1;  
  29.         packageHead.uDataPackageOffset = currentPacketIndex*UDP_MAX_SIZE;  
  30.         memcpy(frameBuffer, &packageHead, sizeof(PackageHeader));  
  31.         memcpy(frameBuffer+sizeof(PackageHeader), dataBuffer+packageHead.uDataPackageOffset, UDP_MAX_SIZE);  
  32.   
  33.         int length=udpsocketSend->writeDatagram(  
  34.                     (const char*)frameBuffer, packageHead.uTransPackageSize,  
  35.                     QHostAddress(ui->lineEditIP->text()), ui->lineEditPort->text().toInt());  
  36.   
  37.         if(length!=packageHead.uTransPackageSize)  
  38.         {  
  39.           qDebug()<<"Failed to send image";  
  40.         }  
  41.   
  42.         currentPacketIndex++;  
  43.     }  
  44.     else  
  45.     {  
  46.         packageHead.uTransPackageSize = sizeof(PackageHeader)+(dataLength-currentPacketIndex*UDP_MAX_SIZE);  
  47.         packageHead.uDataPackageCurrIndex = currentPacketIndex+1;  
  48.         packageHead.uDataPackageOffset = currentPacketIndex*UDP_MAX_SIZE;  
  49.         memcpy(frameBuffer, &packageHead, sizeof(PackageHeader));  
  50.         memcpy(frameBuffer+sizeof(PackageHeader), dataBuffer+packageHead.uDataPackageOffset, dataLength-currentPacketIndex*UDP_MAX_SIZE);  
  51.         int length=udpsocketSend->writeDatagram(  
  52.                     (const char*)frameBuffer, packageHead.uTransPackageSize,  
  53.                     QHostAddress(ui->lineEditIP->text()), ui->lineEditPort->text().toInt());  
  54.   
  55.         if(length!=packageHead.uTransPackageSize)  
  56.         {  
  57.           qDebug()<<"Failed to send image";  
  58.         }  
  59.   
  60.         currentPacketIndex++;  
  61.     }  
  62. }  
    int dataLength=buffer.data().size();

    unsigned char *dataBuffer=(unsigned char *)buffer.data().data();

    int packetNum = 0;
    int lastPaketSize = 0;
    packetNum = dataLength / UDP_MAX_SIZE;
    lastPaketSize = dataLength % UDP_MAX_SIZE;
    int currentPacketIndex = 0;
    if (lastPaketSize != 0)
    {
        packetNum = packetNum + 1;
    }

    PackageHeader packageHead;

    packageHead.uTransPackageHdrSize=sizeof(packageHead);
    packageHead.uDataSize = dataLength;
    packageHead.uDataPackageNum = packetNum;

    unsigned char frameBuffer[1024*1000];
    memset(frameBuffer,0,1024*1000);
    while (currentPacketIndex < packetNum)
    {
        if (currentPacketIndex < (packetNum-1))
        {
            packageHead.uTransPackageSize = sizeof(PackageHeader)+UDP_MAX_SIZE;
            packageHead.uDataPackageCurrIndex = currentPacketIndex+1;
            packageHead.uDataPackageOffset = currentPacketIndex*UDP_MAX_SIZE;
            memcpy(frameBuffer, &packageHead, sizeof(PackageHeader));
            memcpy(frameBuffer+sizeof(PackageHeader), dataBuffer+packageHead.uDataPackageOffset, UDP_MAX_SIZE);

            int length=udpsocketSend->writeDatagram(
                        (const char*)frameBuffer, packageHead.uTransPackageSize,
                        QHostAddress(ui->lineEditIP->text()), ui->lineEditPort->text().toInt());

            if(length!=packageHead.uTransPackageSize)
            {
              qDebug()<<"Failed to send image";
            }

            currentPacketIndex++;
        }
        else
        {
            packageHead.uTransPackageSize = sizeof(PackageHeader)+(dataLength-currentPacketIndex*UDP_MAX_SIZE);
            packageHead.uDataPackageCurrIndex = currentPacketIndex+1;
            packageHead.uDataPackageOffset = currentPacketIndex*UDP_MAX_SIZE;
            memcpy(frameBuffer, &packageHead, sizeof(PackageHeader));
            memcpy(frameBuffer+sizeof(PackageHeader), dataBuffer+packageHead.uDataPackageOffset, dataLength-currentPacketIndex*UDP_MAX_SIZE);
            int length=udpsocketSend->writeDatagram(
                        (const char*)frameBuffer, packageHead.uTransPackageSize,
                        QHostAddress(ui->lineEditIP->text()), ui->lineEditPort->text().toInt());

            if(length!=packageHead.uTransPackageSize)
            {
              qDebug()<<"Failed to send image";
            }

            currentPacketIndex++;
        }
    }
先将图片转换为QBuffer，这样就可以获取图片的数据和长度，然后根据指定大小UDP_MAX_SIZE分包。在包头中设置每包数据的特征，然后将包体加到包头后面发送出去。

2.组包

[cpp] view plain copy
print ?
  1. static int num = 1;  
  2. static uint size = 0;  
  3.   
  4. PackageHeader *packageHead = (PackageHeader *)datagram.data();  
  5. if (packageHead->uDataPackageCurrIndex == num)  
  6. {  
  7.     num++;  
  8.     size += packageHead->uTransPackageSize-packageHead->uTransPackageHdrSize;  
  9.     if (size > 1024*1000)  
  10.     {  
  11.         qDebug()<<"image too big";  
  12.         num = 1;  
  13.         size = 0;  
  14.         return;  
  15.     }  
  16.     if (packageHead->uDataPackageOffset > 1024*1000)  
  17.     {  
  18.         qDebug()<<"image too big";  
  19.         packageHead->uDataPackageOffset = 0;  
  20.         num = 1;  
  21.         size = 0;  
  22.         return;  
  23.     }  
  24.   
  25.     memcpy(imageData.data+packageHead->uDataPackageOffset, datagram.data()+packageHead->uTransPackageHdrSize,  
  26.            packageHead->uTransPackageSize-packageHead->uTransPackageHdrSize);  
  27.     if ((packageHead->uDataPackageNum == packageHead->uDataPackageCurrIndex)  
  28.             && (size == packageHead->uDataSize))  
  29.     {  
  30.         imageData.length = packageHead->uDataSize;  
  31.   
  32.         QImage image;  
  33.         image.loadFromData((uchar *)imageData.data,imageData.length,"JPG");  
  34.         QPixmap pixmap=QPixmap::fromImage(image);  
  35.         ui->labelImage_2->setPixmap(pixmap);  
  36.         recvImageNum++;  
  37.         ui->lineEditRevFrame->setText(QString::number(recvImageNum));  
  38.         ui->lineEditRevSize->setText(QString::number(imageData.length));  
  39.         memset(&imageData,0,sizeof(UdpUnpackData));  
  40.         num = 1;  
  41.         size = 0;  
  42.     }  
  43. }  
  44. else  
  45. {  
  46.     num = 1;  
  47.     size = 0;  
  48.     memset(&imageData,0,sizeof(UdpUnpackData));  
  49. }  
           static int num = 1;
           static uint size = 0;

           PackageHeader *packageHead = (PackageHeader *)datagram.data();
           if (packageHead->uDataPackageCurrIndex == num)
           {
               num++;
               size += packageHead->uTransPackageSize-packageHead->uTransPackageHdrSize;
               if (size > 1024*1000)
               {
                   qDebug()<<"image too big";
                   num = 1;
                   size = 0;
                   return;
               }
               if (packageHead->uDataPackageOffset > 1024*1000)
               {
                   qDebug()<<"image too big";
                   packageHead->uDataPackageOffset = 0;
                   num = 1;
                   size = 0;
                   return;
               }

               memcpy(imageData.data+packageHead->uDataPackageOffset, datagram.data()+packageHead->uTransPackageHdrSize,
                      packageHead->uTransPackageSize-packageHead->uTransPackageHdrSize);
               if ((packageHead->uDataPackageNum == packageHead->uDataPackageCurrIndex)
                       && (size == packageHead->uDataSize))
               {
                   imageData.length = packageHead->uDataSize;

                   QImage image;
                   image.loadFromData((uchar *)imageData.data,imageData.length,"JPG");
                   QPixmap pixmap=QPixmap::fromImage(image);
                   ui->labelImage_2->setPixmap(pixmap);
                   recvImageNum++;
                   ui->lineEditRevFrame->setText(QString::number(recvImageNum));
                   ui->lineEditRevSize->setText(QString::number(imageData.length));
                   memset(&imageData,0,sizeof(UdpUnpackData));
                   num = 1;
                   size = 0;
               }
           }
           else
           {
               num = 1;
               size = 0;
               memset(&imageData,0,sizeof(UdpUnpackData));
           }
组包是分包的逆过程，根据包头中“数据的总大小”和“数据被分成包的个数”两个字段可以判断组包是否完整，如果完整就在接收端显示出来。
三.示例


界面包括发送端和接收端，接收端的IP地址是自动获取的本机IP地址，上图将发送端的IP地址设置为与接收端IP地址相同，可实现自发自收。

每秒帧数可实时设置每秒发送图片的张数，发送帧数表示一共发送了多少张，接收帧数表示一共接收了多少张，图片大小表示每张图片多少Byte。

可将示例运行于两台计算机，实现双向收发。

源码链接：见http://blog.csdn.net/caoshangpa/article/details/52681572的评论


顶
4
踩
0
 
 
  相关文章推荐
ASKLW
关注
专栏目录
Qt通过UDP传图片 实现自定义分包和组包
09-27
Qt通过UDP传图片 实现自定义分包和组包 详见博客：http://blog.csdn.net/caoshangpa/article/details/52681572
Qt基础 | UDP通信 | UDP单播、广播、组播的介绍与实现
zwcslj的博客
07-30 1471
UDP(用户数据报协议)是轻量的、不可靠的、面向数据报、无连接的协议，它可以用于对可靠性要求不高的场合。与 TCP 通信不同，两个程序之间进行 UDP 通信无需预先建立持久的 socket 连接，UDP 每次发送数据报都需要指定目标地址和端口。QUdpSocket 类用于实现 UDP 通信，它从 QAbstractSocket 类继承，因而与 QTcpScoket 共享大部分的接口函数。主要区别是 QUdpSocket 以数据报传输数据，而不是以连续的数据流。
QT通过UDP分包传输大图像（测试可传6M）
ljjjjjjjjjjj的博客
07-28 3679
UDP传数据每帧数据最大传64k，而图片文件一般远大于64K，此时就需要将图像数据分包传输，接收端也分包接收，直到整个图片数据都收到，再进行其他处理。
c#Udp分包组包方法
weixin_34345560的博客
12-07 484
udp通信协议，相信大家都知道这个。由于是无连接的协议，所有udp的传输效率比tcp高。但是udp协议传输较大的数据文件得分包 最近写了个分包组包的方法，拿来和大家分享，如果有什么不妥的地方，欢迎点评 　　 分包的方法 1 //每个包中二进制数组的长度 2 public static int Count = 60000; 3 4 ...
QT通过UDP分包传输大图像（测试可传6M图片）
07-28
QT框架提供了一种方便的方式来处理UDP通信，本篇文章将深入探讨如何使用QT通过UDP分包传输大图像。 首先，我们要理解UDP的特点。UDP是一种无连接的协议，每个数据包都独立发送，没有握手过程，也没有错误检测和重传...
qt udp多线程收发过程_使用 Qt 获取 UDP 数据并显示成图片
weixin_39891262的博客
12-29 2683
一个项目，要接收 UDP 数据包，解析并获取其中的数据，主要根据解析出来的行号和序号将数据拼接起来，然后将拼接起来的数据(最重要的数据是 R、G、B 三个通道的像素值)显示在窗口中。考虑到每秒钟要接收的数据包的数量较大，Python 的处理速度可能没有那么快，而且之前对 Qt 也比较熟悉了，所以用Qt 作为客户端接收处理数据包，用近期学习的 Python 模拟发送数据包。数据格式在 TCP/IP ...
QT socket网络通信 tcp/udp功能开发，带报告 [源码 成品]基tcp/udp开发，实现文字、图片、文件、语音传输
最新发布
08-07
[源码 成品]基tcp/udp开发，实现文字、图片、文件、语音传输和语音播放、语音对讲（对讲机）；自定义协议，可解决tcp粘包等问题；图片、文件、语音传输做了客户端和服务端的交互（类似握手）；语音对讲采用多线程。 ...
Qt学习之路_4(Qt UDP的初步使用)
weixin_33770878的博客
06-28 287
　　为了使用Qt自带的Socket进行网络编程，先必须熟悉Socket编程的原理，另外还需对Qt一些基本类的操作比较熟悉。由于刚接触不久，所以还是以看人家的代码来学习。这次主要是学Qt下UDP的编程，且熟悉一些Qt下代码的编写流程，所以本文参照的是《Qt及Qt Quick开发实战精解》一书中的第5个例子：局域网聊天工具中的UDP聊天部分。      另外http://www.yafeilinux...
Qt中实现UDP的分包和组包——参考“草上爬”的博客
qq_42615475的博客
06-04 5133
一、为啥我们要分包组包？直接发不行吗？ 最初你可能会存在这样的疑惑？所以我们需要了解下TCP和UDP在Qt中的区别。这里参考了阿拉丁的博客 顺便引用他的图；至于TCP和UDP相应的C/S架构图也可以通过这个兄弟的博客了解，当然还有TCP和UDP在Qt中如何实现。 ①UDP和TCP表格对比 ②在Qt中使用UDP和TCP的一些函数 ③阅读关于Qt中UDP的writeDatagram 通过阅读下图的文档便可以知道：UDP一次性发送的数据量是有限的，所以我们必须要分包！！！ 至于为啥UDP需要分包，TCP不需
UDP分包与组包
董哥的黑板报
07-09 1万+
一、UDP概述 UDP协议就不过多的介绍了，可以参阅：https://blog.csdn.net/qq_41453285/article/details/103984794，或者其他关于UDP的文章 下面有一个网站可以来查看当前各国的流量速率比，进入之后找到中国，点击查看：https://www.speedtest.net/global-index 二、UDP的特性与应用场景 采用UDP有3个关键点： 网络带宽需求较小，而实时性要求高 大部分应用无需维持连接 需要低功耗 应用场景
qt udp
weixin_30322405的博客
04-28 87
#ifndef MUDP_H #define MUDP_H #include <QObject> #include <QUdpSocket> class mudp : public QObject { Q_OBJECT public: explicit mudp(QObject *parent = 0); QUdpS...
QT UDP
u012830675的博客
12-26 670
1、UDP 对于UDP通信，我分为发送端可接收端。向指定ip的端口发送信息。 注意：在.pro文件中要添加QT += network，否则无法使用Qt的网络功能。 发送端： #include QUdpSocket *sender; sender = new QUdpSocket(this); QByteArray datagram = "hello C++"; //UDP广播 w
UDP分包组包的类
yiyefangzhou24的专栏
03-19 4837
分享一个自己写的udp分包组包的例子，一个包以32768为单位分包，每个包有序号，如果乱序或者是缺少，直接舍弃。（有点浪费资源）如果是要实现一个资源发送过程中乱序的重组，请自己修改吧，什么冒泡排序之类的。我就懒得写了。 声明： typedef struct UDPData { unsigned int index; //包序号 unsigned int part; //块总数 unsig
QT UDP通信
QtCompany的博客
09-02 600
链接：https://pan.baidu.com/s/1i2vM3Uf3GAVmdCqf_FuETA。
QT软件网络库使用UDP组播（基于C++语言)
MelyLenient的博客
03-28 2234
使用QT发送UDP包方法 最近对QT感兴趣，虽然日常用C语言比较多，但是由于C与C++的相似性，使用QT并不复杂 QT如何引入网络？ 学习QT自然要学习QT提供的强大库函数。在QT中对于网络应用的使用已经为我们封装成可直接调用的类 接下来进入主题： 如何调用QT的网络库？ 首先在我们新建完工程后，在工程中我们可以看到一个.pro文件！ 这个文件是用来告诉qmake创建makefile文件所需要的细节。打开.pro文件后，在文件中添加QT += network。这样我们的QT工程就可以使用QT提供的强大网络
Qt-udp（组播）
hw5230的博客
01-13 2278
【代码】Qt-udp（组播）
QT UDP通信（单播、广播、组播）
热门推荐
希望能帮助大家，希望大家多多支持，你们的支持是我前进的动力。
03-24 1万+
1.QUdpSocket UDP是轻量的、不可靠的、面向数据报、无连接的协议，它可以用于对可靠性要求不高的场合，与TCP通信不同，无需建立持久的socket连接。 QUdpSocket用于实现UDP通信，与QTcpSocket主要区别是，QUdpSocket以数据报传输数据，而不是以连续的数据流。发送数据使用writeDatagram()，数据报的长度一般少于512字节，每个数据报包含发送者和接收者的IP地址和端口等信息。 要进行UDP通信，首先需要bind函数绑定一个端口，用于接收传入的手机不能。当
qt udp分包组包
12-20
QT是一种跨平台的C++应用程序开发框架，它包含了丰富的网络通信模块。UDP是一种无连接的网络通信协议，它可以实现高效的数据传输。在QT中，我们可以利用UDP协议进行数据的分包和组包。 首先，对于UDP数据的分包，我们可以通过指定数据包的大小来实现。在QT中，可以使用QUdpSocket类来创建UDP客户端或服务器，然后可以使用writeDatagram方法将需要发送的数据分成指定大小的数据包，并进行发送。当接收端收到这些分包后，可以根据自己的需求进行数据的重组。 其次，对于UDP数据的组包，我们需要在接收端进行数据的重新组合。接收端可以使用QUdpSocket类来创建UDP客户端或服务器，然后通过readyRead信号来监听是否有数据包到达。当数据包到达时，接收端可以使用readDatagram方法来读取数据包，然后进行组合操作，最终得到完整的数据内容。 总的来说，QT提供了丰富的网络通信模块和接口，可以方便地实现UDP数据的分包和组包操作。开发者可以根据自己的实际需求，灵活运用QT的网络通信功能，来完成对UDP数据的分包组包操作。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值