Receive data with UDP protocol

swansorter · 8 Sept 2020, 10:26

hello,
i want all received data to be stored in bytearray but in bytearray only last bunch of data are stored,is ther any way to store all the data in a array
This is my UDP receive progrm:-
connect(mSocket,&QUdpSocket::readyRead,&{
if(mSocket->hasPendingDatagrams())
{
QByteArray data1 ;
datagram1.resize(mSocket->pendingDatagramSize());
QDataStream str(&datagram1, QIODevice::ReadOnly);
mSocket->readDatagram(datagram1.data(),datagram1.size() );
ui->textEdit->append(QString(datagram1.toHex()));

}
});

JonB · 9 Aug 2020, 10:28

@swansorter
This appends whatever it receives as hex to the text edit. How many times is it called? Why are you using UDP? If you use UDP, there is no guarantee all data will arrive, that's the point of UDP.

QDataStream str(&datagram1, QIODevice::ReadOnly);

This line does not seem to do anything, so maybe remove it.

Your lambda only does one datagram read per each readyRead(); but at least in principle you could receive a stream of datagrams for one readyRead(), and it won't activate readRead() again if you fail to read all of them.. I think you should change your if to a while?

swansorter · 8 Sept 2020, 10:48

@JonB I am using udp to read image sensor values
i want receive 2014080bytes

JonB · 8 Sept 2020, 10:51

@swansorter
Your comment does not address what I have said. And the fact remains that you may miss some UDP datagrams. Did you try the code change I mentioned?

swansorter · 8 Sept 2020, 10:53

@JonB sir i changed the if to while and i am able to recieve all the data

JonB · 8 Sept 2020, 10:59

@swansorter
:)

swansorter · 8 Sept 2020, 11:02

@JonB how to store incommming data

JonB · 9 Aug 2020, 11:02

@swansorter
Which direction "incoming"? Assuming you mean as per the code you already have, you need to stop using a local variable QByteArray data1 and instead use, say, a class variable one, so that you can append all the data arriving to it, like you do with your text edit.

KroMignon · 10 Sept 2020, 04:56

@swansorter said in Receive data with UDP protocol:

This is my UDP receive progrm:-
connect(mSocket,&QUdpSocket::readyRead,&{
if(mSocket->hasPendingDatagrams())
{
QByteArray data1 ;
datagram1.resize(mSocket->pendingDatagramSize());
QDataStream str(&datagram1, QIODevice::ReadOnly);
mSocket->readDatagram(datagram1.data(),datagram1.size() );
ui->textEdit->append(QString(datagram1.toHex()));
}
});

This can not work!
a. you have to change the if statement into while, to ensure you will handle all received datagram
b. you copy the data bunch into a local variable, which will be lost after if statement, you have to define a class member to store the different payloads

For example like this:

connect(mSocket,&QUdpSocket::readyRead, [this]() {
    while(mSocket->hasPendingDatagrams())
    {
        QByteArray datagram(mSocket->pendingDatagramSize(), 0);
        mSocket->readDatagram(datagram.data(), datagram.size() );
        ui->textEdit->append(QString(datagram.toHex()));

        // I suppose the class contains a member mPayload which is a QByteArray
        mPayload.append(datagram);
     }
});

Now you have to know when data is completely received ;)

swansorter · 10 Sept 2020, 05:36

modules:composer.user_said_in, @KroMignon, Receive data with UDP protocol

mPayload

mPayload will give segmentation fault if i use out side

KroMignon · 10 Sept 2020, 05:42

@swansorter said in Receive data with UDP protocol:

mPayload will give segmentation fault if i use out side

Can you give more details about what you are doing and the debugger backtrace?

swansorter · 10 Sept 2020, 05:50

@KroMignon
1.i want to receive 2014080 bytes
2.Receiving it bunch by bunch
3.problem is each time i receive data the datagram1(bytearry )updated with new bunch of data and qstring also,so at last i only get last bunch of data.
4. i tried using global variable qstring it receives all the data but giving (SEGMENTATION FAULT).
is there any other way to do it .

this is my udp receive program
void MainWindow::readPendingDatagrams()
{
while(mSocket->hasPendingDatagrams())
{
QString received_data_x;
QByteArray datagram1;
datagram1.resize(mSocket->pendingDatagramSize());
mSocket->readDatagram(datagram1.data(),datagram1.size() );
received_data_x.append(datagram1.toHex());

}

swansorter · wrote on 10 Sept 2020, 05:50

@swansorter if i use class member global variable it gives me a segmentation fault

void MainWindow::on_pushButton_2_pressed()
{
//if iuse class member or global variable;
QString test= received_data//class member;
int width = 2098, height = 240;
int bufpo0 = 0, bufpo1 = 1, bufpo2 = 2, bufpo3 = 3;
QImage img(width, height, QImage::Format_RGB888);
QByteArray cmd= QByteArray::fromHex(test.replace("\r\n","").toLatin1());

   for (int packet = 0; packet < cmd.length(); packet++)
   {

//in this loop am getting segmentation fault*///
Auto_image_RGBdata[packet] = static_cast<quint8>(cmd.data()[bufpo0]) | static_cast<quint8>(cmd.data()[bufpo1]) << 8 | static_cast<quint8>(cmd.data()[bufpo2]) << 16 | static_cast<quint8>(cmd.data()[bufpo3])<< 24;

       bufpo0 = bufpo0 + 4;
       bufpo1 = bufpo1 + 4;
       bufpo2 = bufpo2 + 4;
       bufpo3 = bufpo3 + 4;
   }



   for (int y = 0; y < height; y++)
   {
       for (int x = 0; x < width; x++)
       {
            QRgb value = qRgb((Auto_image_RGBdata[x] >> 22 & 0x000000ff),   Auto_image_RGBdata[x] >> 12 & 0x000000ff), (Auto_image_RGBdata[x]>>2  & 0x000003ff));
           img.setPixel(x,y,value);
       }
   }
   ui->port->setPixmap(QPixmap::fromImage(img.scaled(541,301,Qt::KeepAspectRatio)));

ui->port->setScaledContents(true); QPixmap::fromImage(img.scaled(width/4,height*2,Qt::KeepAspectRatio)).save("image2.jpg","JPG");

}

KroMignon · 10 Sept 2020, 05:59

@swansorter said in Receive data with UDP protocol:

this is my udp receive program
void MainWindow::readPendingDatagrams()
{
while(mSocket->hasPendingDatagrams())
{
QString received_data_x;
QByteArray datagram1;
datagram1.resize(mSocket->pendingDatagramSize());
mSocket->readDatagram(datagram1.data(),datagram1.size() );
received_data_x.append(datagram1.toHex());
}
}

once again received_data_x is a local variable not a class member!

swansorter · 10 Sept 2020, 06:19

@KroMignon if i use received_data_x as class member i am getting segmentation fault

swansorter · wrote on 10 Sept 2020, 06:07

@KroMignon
55 push %rbp
48 89 e5 mov %rsp,%rbp
53 push %rbx
48 81 ec d8 00 00 00 sub $0xd8,%rsp
48 89 bd 28 ff ff ff mov %rdi,-0xd8(%rbp)
64 48 8b 04 25 28 00 00 00 mov %fs:0x28,%rax
48 89 45 e8 mov %rax,-0x18(%rbp)
31 c0 xor %eax,%eax
test= x_member;
48 8b 85 28 ff ff ff mov -0xd8(%rbp),%rax
48 8d 90 88 02 00 00 lea 0x288(%rax),%rdx
48 8d 85 68 ff ff ff lea -0x98(%rbp),%rax
48 89 d6 mov %rdx,%rsi
48 89 c7 mov %rax,%rdi
e8 26 52 00 00 callq 0x555555632a94 <QString::QString(QString const&)>
= 2098, height = 240;
c7 85 5c ff ff ff 32 08 00 00 movl $0x832,-0xa4(%rbp)
c7 85 60 ff ff ff f0 00 00 00 movl $0xf0,-0xa0(%rbp)
= 0, bufpo1 = 1, bufpo2 = 2, bufpo3 = 3;
c7 85 40 ff ff ff 00 00 00 00 movl $0x0,-0xc0(%rbp)
c7 85 44 ff ff ff 01 00 00 00 movl $0x1,-0xbc(%rbp)
c7 85 48 ff ff ff 02 00 00 00 movl $0x2,-0xb8(%rbp)
c7 85 4c ff ff ff 03 00 00 00 movl $0x3,-0xb4(%rbp)
height, QImage::Format_RGB888);
8b 95 60 ff ff ff mov -0xa0(%rbp),%edx
8b b5 5c ff ff ff mov -0xa4(%rbp),%esi
48 8d 45 80 lea -0x80(%rbp),%rax
b9 0d 00 00 00 mov $0xd,%ecx
48 89 c7 mov %rax,%rdi
e8 19 f4 f2 ff callq 0x55555555cce0 _ZN6QImageC1EiiNS_6FormatE@plt
cmd= QByteArray::fromHex(test.replace("\r\n","").toLatin1());
48 8d 45 a0 lea -0x60(%rbp),%rax
48 8d 35 06 05 0d 00 lea 0xd0506(%rip),%rsi # 0x5555556fddd8
48 89 c7 mov %rax,%rdi
e8 be 4e 00 00 callq 0x555555632798 <QString::QString(char const*)>
48 8d 85 78 ff ff ff lea -0x88(%rbp),%rax
48 8d 35 c8 7e 0d 00 lea 0xd7ec8(%rip),%rsi # 0x5555557057b0
48 89 c7 mov %rax,%rdi
e8 a8 4e 00 00 callq 0x555555632798 <QString::QString(char const*)>
48 8d 55 a0 lea -0x60(%rbp),%rdx
48 8d b5 78 ff ff ff lea -0x88(%rbp),%rsi
48 8d 85 68 ff ff ff lea -0x98(%rbp),%rax
b9 01 00 00 00 mov $0x1,%ecx
48 89 c7 mov %rax,%rdi
e8 b1 fc f2 ff callq 0x55555555d5c0 _ZN7QString7replaceERKS_S1_N2Qt15CaseSensitivityE@plt
48 89 c2 mov %rax,%rdx
48 8d 45 c0 lea -0x40(%rbp),%rax
48 89 d6 mov %rdx,%rsi
48 89 c7 mov %rax,%rdi
e8 83 4c 00 00 callq 0x5555556325a4 <QString::toLatin1() const &>
48 8d 85 70 ff ff ff lea -0x90(%rbp),%rax
48 8d 55 c0 lea -0x40(%rbp),%rdx
48 89 d6 mov %rdx,%rsi
48 89 c7 mov %rax,%rdi
e8 39 f4 f2 ff callq 0x55555555cd70 _ZN10QByteArray7fromHexERKS_@plt
48 8d 45 c0 lea -0x40(%rbp),%rax
48 89 c7 mov %rax,%rdi
e8 11 00 f3 ff callq 0x55555555d954 QByteArray::~QByteArray()
48 8d 85 78 ff ff ff lea -0x88(%rbp),%rax
48 89 c7 mov %rax,%rdi
e8 b8 51 00 00 callq 0x555555632b0a QString::~QString()
48 8d 45 a0 lea -0x60(%rbp),%rax
48 89 c7 mov %rax,%rdi
e8 ac 51 00 00 callq 0x555555632b0a QString::~QString()
packet = 0; packet < cmd.length(); packet++)//2098100(lines)=540000packets
c7 85 50 ff ff ff 00 00 00 00 movl $0x0,-0xb0(%rbp)
48 8d 85 70 ff ff ff lea -0x90(%rbp),%rax
48 89 c7 mov %rax,%rdi
e8 71 49 00 00 callq 0x5555556322e8 <QByteArray::length() const>
39 85 50 ff ff ff cmp %eax,-0xb0(%rbp)
0f 9c c0 setl %al
84 c0 test %al,%al
0f 84 d8 00 00 00 je 0x55555562da60 MainWindow::on_pushButton_2_pressed()+564
Auto_image_RGBdata[packet] = static_cast<quint8>(cmd.data()[bufpo0]) | static_cast<quint8>(cmd.data()[bufpo1]) << 8 | static_cast<quint8>(cmd.data()[bufpo2]) << 16 | static_cast<quint8>(cmd.data()[bufpo3])<< 24;
48 8d 85 70 ff ff ff lea -0x90(%rbp),%rax
48 89 c7 mov %rax,%rdi
e8 97 49 00 00 callq 0x55555563232e QByteArray::data()
48 89 c2 mov %rax,%rdx
8b 85 40 ff ff ff mov -0xc0(%rbp),%eax
48 98 cltq
48 01 d0 add %rdx,%rax
0f b6 00 movzbl (%rax),%eax
0f b6 d8 movzbl %al,%ebx
48 8d 85 70 ff ff ff lea -0x90(%rbp),%rax
48 89 c7 mov %rax,%rdi
e8 74 49 00 00 callq 0x55555563232e QByteArray::data()
48 89 c2 mov %rax,%rdx
8b 85 44 ff ff ff mov -0xbc(%rbp),%eax
48 98 cltq
48 01 d0 add %rdx,%rax
0f b6 00 movzbl (%rax),%eax
0f b6 c0 movzbl %al,%eax
c1 e0 08 shl $0x8,%eax
09 c3 or %eax,%ebx
48 8d 85 70 ff ff ff lea -0x90(%rbp),%rax
48 89 c7 mov %rax,%rdi
e8 4c 49 00 00 callq 0x55555563232e QByteArray::data()
48 89 c2 mov %rax,%rdx
8b 85 48 ff ff ff mov -0xb8(%rbp),%eax
48 98 cltq
48 01 d0 add %rdx,%rax
0f b6 00 movzbl (%rax),%eax
0f b6 c0 movzbl %al,%eax
c1 e0 10 shl $0x10,%eax
09 c3 or %eax,%ebx
48 8d 85 70 ff ff ff lea -0x90(%rbp),%rax
48 89 c7 mov %rax,%rdi
e8 24 49 00 00 callq 0x55555563232e QByteArray::data()
48 89 c2 mov %rax,%rdx
8b 85 4c ff ff ff mov -0xb4(%rbp),%eax
48 98 cltq
48 01 d0 add %rdx,%rax
0f b6 00 movzbl (%rax),%eax
0f b6 c0 movzbl %al,%eax
c1 e0 18 shl $0x18,%eax
89 d9 mov %ebx,%ecx
09 c1 or %eax,%ecx
48 8d 05 74 a5 3a 00 lea 0x3aa574(%rip),%rax # 0x5555559d7fa0 <Auto_image_RGBdata>
8b 95 50 ff ff ff mov -0xb0(%rbp),%edx
48 63 d2 movslq %edx,%rdx
89 0c 90 mov %ecx,(%rax,%rdx,4)
= bufpo0 + 4;
83 85 40 ff ff ff 04 addl $0x4,-0xc0(%rbp)
= bufpo1 + 4;
83 85 44 ff ff ff 04 addl $0x4,-0xbc(%rbp)
= bufpo2 + 4;
83 85 48 ff ff ff 04 addl $0x4,-0xb8(%rbp)
= bufpo3 + 4;
83 85 4c ff ff ff 04 addl $0x4,-0xb4(%rbp)
packet = 0; packet < cmd.length(); packet++)//2098100(lines)=540000packets
83 85 50 ff ff ff 01 addl $0x1,-0xb0(%rbp)
e9 08 ff ff ff jmpq 0x55555562d968 MainWindow::on_pushButton_2_pressed()+316
y = 0; y < height; y++)
c7 85 54 ff ff ff 00 00 00 00 movl $0x0,-0xac(%rbp)
8b 85 54 ff ff ff mov -0xac(%rbp),%eax
3b 85 60 ff ff ff cmp -0xa0(%rbp),%eax
0f 8d b2 00 00 00 jge 0x55555562db2e MainWindow::on_pushButton_2_pressed()+770
(int x = 0; x < width; x++)
c7 85 58 ff ff ff 00 00 00 00 movl $0x0,-0xa8(%rbp)
8b 85 58 ff ff ff mov -0xa8(%rbp),%eax
3b 85 5c ff ff ff cmp -0xa4(%rbp),%eax
0f 8d 8a 00 00 00 jge 0x55555562db22 MainWindow::on_pushButton_2_pressed()+758

>> 22 & 0x000000ff),(Auto_image_RGBdata[x] >> 12 & 0x000000ff), (Auto_image_RGBdata[x]>>2 & 0x000003ff));

0x55555562da98 <+0x026c> 48 8d 05 01 a5 3a 00 lea 0x3aa501(%rip),%rax # 0x5555559d7fa0 <Auto_image_RGBdata>
0x55555562da9f <+0x0273> 8b 95 58 ff ff ff mov -0xa8(%rbp),%edx
0x55555562daa5 <+0x0279> 48 63 d2 movslq %edx,%rdx
0x55555562daa8 <+0x027c> 8b 04 90 mov (%rax,%rdx,4),%eax
0x55555562daab <+0x027f> c1 f8 02 sar $0x2,%eax
0x55555562daae <+0x0282> 25 ff 03 00 00 and $0x3ff,%eax
0x55555562dab3 <+0x0287> 89 c6 mov %eax,%esi
0x55555562dab5 <+0x0289> 48 8d 05 e4 a4 3a 00 lea 0x3aa4e4(%rip),%rax # 0x5555559d7fa0 <Auto_image_RGBdata>
0x55555562dabc <+0x0290> 8b 95 58 ff ff ff mov -0xa8(%rbp),%edx
0x55555562dac2 <+0x0296> 48 63 d2 movslq %edx,%rdx
0x55555562dac5 <+0x0299> 8b 04 90 mov (%rax,%rdx,4),%eax
0x55555562dac8 <+0x029c> c1 f8 0c sar $0xc,%eax
0x55555562dacb <+0x029f> 0f b6 c8 movzbl %al,%ecx
0x55555562dace <+0x02a2> 48 8d 05 cb a4 3a 00 lea 0x3aa4cb(%rip),%rax # 0x5555559d7fa0 <Auto_image_RGBdata>
0x55555562dad5 <+0x02a9> 8b 95 58 ff ff ff mov -0xa8(%rbp),%edx
0x55555562dadb <+0x02af> 48 63 d2 movslq %edx,%rdx
0x55555562dade <+0x02b2> 8b 04 90 mov (%rax,%rdx,4),%eax
0x55555562dae1 <+0x02b5> c1 f8 16 sar $0x16,%eax
0x55555562dae4 <+0x02b8> 0f b6 c0 movzbl %al,%eax
0x55555562dae7 <+0x02bb> 89 f2 mov %esi,%edx
0x55555562dae9 <+0x02bd> 89 ce mov %ecx,%esi
0x55555562daeb <+0x02bf> 89 c7 mov %eax,%edi
0x55555562daed <+0x02c1> e8 ff 56 00 00 callq 0x5555556331f1 <qRgb(int, int, int)>
0x55555562daf2 <+0x02c6> 89 85 64 ff ff ff mov %eax,-0x9c(%rbp)
28672 [1] img.setPixel(x,y,value);
0x55555562daf8 <+0x02cc> 8b 8d 64 ff ff ff mov -0x9c(%rbp),%ecx
0x55555562dafe <+0x02d2> 8b 95 54 ff ff ff mov -0xac(%rbp),%edx
0x55555562db04 <+0x02d8> 8b b5 58 ff ff ff mov -0xa8(%rbp),%esi
0x55555562db0a <+0x02de> 48 8d 45 80 lea -0x80(%rbp),%rax
0x55555562db0e <+0x02e2> 48 89 c7 mov %rax,%rdi
0x55555562db11 <+0x02e5> e8 aa f0 f2 ff callq 0x55555555cbc0 _ZN6QImage8setPixelEiij@plt
28669 [2] for (int x = 0; x < width; x++)
0x55555562db16 <+0x02ea> 83 85 58 ff ff ff 01 addl $0x1,-0xa8(%rbp)
0x55555562db1d <+0x02f1> e9 64 ff ff ff jmpq 0x55555562da86 MainWindow::on_pushButton_2_pressed()+602
28666 [2] for (int y = 0; y < height; y++)
0x55555562db22 <+0x02f6> 83 85 54 ff ff ff 01 addl $0x1,-0xac(%rbp)
0x55555562db29 <+0x02fd> e9 3c ff ff ff jmpq 0x55555562da6a MainWindow::on_pushButton_2_pressed()+574
28676 [1] ui->port->setPixmap(QPixmap::fromImage(img.scaled(541,301,Qt::KeepAspectRatio)));
0x55555562db2e <+0x0302> 48 8b 85 28 ff ff ff mov -0xd8(%rbp),%rax
0x55555562db35 <+0x0309> 48 8b 80 20 02 00 00 mov 0x220(%rax),%rax
0x55555562db3c <+0x0310> 48 8b 98 90 00 00 00 mov 0x90(%rax),%rbx
0x55555562db43 <+0x0317> 48 8d 85 78 ff ff ff lea -0x88(%rbp),%rax
0x55555562db4a <+0x031e> be 00 00 00 00 mov $0x0,%esi
0x55555562db4f <+0x0323> 48 89 c7 mov %rax,%rdi
0x55555562db52 <+0x0326> e8 8d 44 00 00 callq 0x555555631fe4 <QFlagsQt::ImageConversionFlag::QFlags(Qt::ImageConversionFlag)>
0x55555562db57 <+0x032b> 48 8d 45 a0 lea -0x60(%rbp),%rax
0x55555562db5b <+0x032f> 48 8d 75 80 lea -0x80(%rbp),%rsi
0x55555562db5f <+0x0333> 41 b9 00 00 00 00 mov $0x0,%r9d
0x55555562db65 <+0x0339> 41 b8 01 00 00 00 mov $0x1,%r8d
0x55555562db6b <+0x033f> b9 2d 01 00 00 mov $0x12d,%ecx
0x55555562db70 <+0x0344> ba 1d 02 00 00 mov $0x21d,%edx
0x55555562db75 <+0x0349> 48 89 c7 mov %rax,%rdi
0x55555562db78 <+0x034c> e8 9d 57 00 00 callq 0x55555563331a <QImage::scaled(int, int, Qt::AspectRatioMode, Qt::TransformationMode) const>
0x55555562db7d <+0x0351> 48 8d 45 c0 lea -0x40(%rbp),%rax
0x55555562db81 <+0x0355> 8b 95 78 ff ff ff mov -0x88(%rbp),%edx
0x55555562db87 <+0x035b> 48 8d 4d a0 lea -0x60(%rbp),%rcx
0x55555562db8b <+0x035f> 48 89 ce mov %rcx,%rsi
0x55555562db8e <+0x0362> 48 89 c7 mov %rax,%rdi
0x55555562db91 <+0x0365> e8 fc 57 00 00 callq 0x555555633392 <QPixmap::fromImage(QImage&&, QFlagsQt::ImageConversionFlag)>
0x55555562db96 <+0x036a> 48 8d 45 c0 lea -0x40(%rbp),%rax
0x55555562db9a <+0x036e> 48 89 c6 mov %rax,%rsi
0x55555562db9d <+0x0371> 48 89 df mov %rbx,%rdi
0x55555562dba0 <+0x0374> e8 6b f3 f2 ff callq 0x55555555cf10 _ZN6QLabel9setPixmapERK7QPixmap@plt
0x55555562dba5 <+0x0379> 48 8d 45 c0 lea -0x40(%rbp),%rax
0x55555562dba9 <+0x037d> 48 89 c7 mov %rax,%rdi
0x55555562dbac <+0x0380> e8 3f ec f2 ff callq 0x55555555c7f0 _ZN7QPixmapD1Ev@plt
0x55555562dbb1 <+0x0385> 48 8d 45 a0 lea -0x60(%rbp),%rax
0x55555562dbb5 <+0x0389> 48 89 c7 mov %rax,%rdi
0x55555562dbb8 <+0x038c> e8 33 f1 f2 ff callq 0x55555555ccf0 _ZN6QImageD1Ev@plt
28677 [1] ui->port->setScaledContents(true);
0x55555562dbbd <+0x0391> 48 8b 85 28 ff ff ff mov -0xd8(%rbp),%rax
0x55555562dbc4 <+0x0398> 48 8b 80 20 02 00 00 mov 0x220(%rax),%rax
0x55555562dbcb <+0x039f> 48 8b 80 90 00 00 00 mov 0x90(%rax),%rax
0x55555562dbd2 <+0x03a6> be 01 00 00 00 mov $0x1,%esi
0x55555562dbd7 <+0x03ab> 48 89 c7 mov %rax,%rdi
0x55555562dbda <+0x03ae> e8 41 f1 f2 ff callq 0x55555555cd20 _ZN6QLabel17setScaledContentsEb@plt
28679 [1] QPixmap::fromImage(img.scaled(width/4,height2,Qt::KeepAspectRatio)).save("image2.jpg","JPG");
0x55555562dbdf <+0x03b3> 48 8d 85 3c ff ff ff lea -0xc4(%rbp),%rax
0x55555562dbe6 <+0x03ba> be 00 00 00 00 mov $0x0,%esi
0x55555562dbeb <+0x03bf> 48 89 c7 mov %rax,%rdi
0x55555562dbee <+0x03c2> e8 f1 43 00 00 callq 0x555555631fe4 <QFlagsQt::ImageConversionFlag::QFlags(Qt::ImageConversionFlag)>
0x55555562dbf3 <+0x03c7> 8b 85 60 ff ff ff mov -0xa0(%rbp),%eax
0x55555562dbf9 <+0x03cd> 8d 14 00 lea (%rax,%rax,1),%edx
0x55555562dbfc <+0x03d0> 8b 85 5c ff ff ff mov -0xa4(%rbp),%eax
0x55555562dc02 <+0x03d6> 8d 48 03 lea 0x3(%rax),%ecx
0x55555562dc05 <+0x03d9> 85 c0 test %eax,%eax
0x55555562dc07 <+0x03db> 0f 48 c1 cmovs %ecx,%eax
0x55555562dc0a <+0x03de> c1 f8 02 sar $0x2,%eax
0x55555562dc0d <+0x03e1> 89 c7 mov %eax,%edi
0x55555562dc0f <+0x03e3> 48 8d 45 a0 lea -0x60(%rbp),%rax
0x55555562dc13 <+0x03e7> 48 8d 75 80 lea -0x80(%rbp),%rsi
0x55555562dc17 <+0x03eb> 41 b9 00 00 00 00 mov $0x0,%r9d
0x55555562dc1d <+0x03f1> 41 b8 01 00 00 00 mov $0x1,%r8d
0x55555562dc23 <+0x03f7> 89 d1 mov %edx,%ecx
0x55555562dc25 <+0x03f9> 89 fa mov %edi,%edx
0x55555562dc27 <+0x03fb> 48 89 c7 mov %rax,%rdi
0x55555562dc2a <+0x03fe> e8 eb 56 00 00 callq 0x55555563331a <QImage::scaled(int, int, Qt::AspectRatioMode, Qt::TransformationMode) const>
0x55555562dc2f <+0x0403> 48 8d 45 c0 lea -0x40(%rbp),%rax
0x55555562dc33 <+0x0407> 8b 95 3c ff ff ff mov -0xc4(%rbp),%edx
0x55555562dc39 <+0x040d> 48 8d 4d a0 lea -0x60(%rbp),%rcx
0x55555562dc3d <+0x0411> 48 89 ce mov %rcx,%rsi
0x55555562dc40 <+0x0414> 48 89 c7 mov %rax,%rdi
0x55555562dc43 <+0x0417> e8 4a 57 00 00 callq 0x555555633392 <QPixmap::fromImage(QImage&&, QFlagsQt::ImageConversionFlag)>
0x55555562dc48 <+0x041c> 48 8d 85 78 ff ff ff lea -0x88(%rbp),%rax
0x55555562dc4f <+0x0423> 48 8d 35 5d 7b 0d 00 lea 0xd7b5d(%rip),%rsi # 0x5555557057b3
0x55555562dc56 <+0x042a> 48 89 c7 mov %rax,%rdi
0x55555562dc59 <+0x042d> e8 3a 4b 00 00 callq 0x555555632798 <QString::QString(char const)>
0x55555562dc5e <+0x0432> 48 8d b5 78 ff ff ff lea -0x88(%rbp),%rsi
0x55555562dc65 <+0x0439> 48 8d 45 c0 lea -0x40(%rbp),%rax
0x55555562dc69 <+0x043d> b9 ff ff ff ff mov $0xffffffff,%ecx
0x55555562dc6e <+0x0442> 48 8d 15 49 7b 0d 00 lea 0xd7b49(%rip),%rdx # 0x5555557057be
0x55555562dc75 <+0x0449> 48 89 c7 mov %rax,%rdi
0x55555562dc78 <+0x044c> e8 43 f6 f2 ff callq 0x55555555d2c0 _ZNK7QPixmap4saveERK7QStringPKci@plt
0x55555562dc7d <+0x0451> 48 8d 85 78 ff ff ff lea -0x88(%rbp),%rax
0x55555562dc84 <+0x0458> 48 89 c7 mov %rax,%rdi
0x55555562dc87 <+0x045b> e8 7e 4e 00 00 callq 0x555555632b0a QString::~QString()
0x55555562dc8c <+0x0460> 48 8d 45 c0 lea -0x40(%rbp),%rax
0x55555562dc90 <+0x0464> 48 89 c7 mov %rax,%rdi
0x55555562dc93 <+0x0467> e8 58 eb f2 ff callq 0x55555555c7f0 _ZN7QPixmapD1Ev@plt
0x55555562dc98 <+0x046c> 48 8d 45 a0 lea -0x60(%rbp),%rax
0x55555562dc9c <+0x0470> 48 89 c7 mov %rax,%rdi
0x55555562dc9f <+0x0473> e8 4c f0 f2 ff callq 0x55555555ccf0 _ZN6QImageD1Ev@plt
28639 [2] QByteArray cmd= QByteArray::fromHex(test.replace("\r\n","").toLatin1());
0x55555562dca4 <+0x0478> 48 8d 85 70 ff ff ff lea -0x90(%rbp),%rax
0x55555562dcab <+0x047f> 48 89 c7 mov %rax,%rdi
0x55555562dcae <+0x0482> e8 a1 fc f2 ff callq 0x55555555d954 QByteArray::~QByteArray()
28638 [2] QImage img(width, height, QImage::Format_RGB888);
0x55555562dcb3 <+0x0487> 48 8d 45 80 lea -0x80(%rbp),%rax
0x55555562dcb7 <+0x048b> 48 89 c7 mov %rax,%rdi
0x55555562dcba <+0x048e> e8 31 f0 f2 ff callq 0x55555555ccf0 _ZN6QImageD1Ev@plt
28635 [2] QString test= x_member;
0x55555562dcbf <+0x0493> 48 8d 85 68 ff ff ff lea -0x98(%rbp),%rax
0x55555562dcc6 <+0x049a> 48 89 c7 mov %rax,%rdi
0x55555562dcc9 <+0x049d> e8 3c 4e 00 00 callq 0x555555632b0a QString::~QString()
28683 [1] }
0x55555562dcce <+0x04a2> 90 nop
0x55555562dccf <+0x04a3> 48 8b 45 e8 mov -0x18(%rbp),%rax
0x55555562dcd3 <+0x04a7> 64 48 33 04 25 28 00 00 00 xor %fs:0x28,%rax
0x55555562dcdc <+0x04b0> 0f 84 da 00 00 00 je 0x55555562ddbc MainWindow::on_pushButton_2_pressed()+1424
0x55555562dce2 <+0x04b6> e9 d0 00 00 00 jmpq 0x55555562ddb7 MainWindow::on_pushButton_2_pressed()+1419
0x55555562dce7 <+0x04bb> 48 89 c3 mov %rax,%rbx
0x55555562dcea <+0x04be> 48 8d 45 c0 lea -0x40(%rbp),%rax
0x55555562dcee <+0x04c2> 48 89 c7 mov %rax,%rdi
0x55555562dcf1 <+0x04c5> e8 5e fc f2 ff callq 0x55555555d954 QByteArray::~QByteArray()
0x55555562dcf6 <+0x04ca> eb 03 jmp 0x55555562dcfb MainWindow::on_pushButton_2_pressed()+1231
0x55555562dcf8 <+0x04cc> 48 89 c3 mov %rax,%rbx
0x55555562dcfb <+0x04cf> 48 8d 85 78 ff ff ff lea -0x88(%rbp),%rax
0x55555562dd02 <+0x04d6> 48 89 c7 mov %rax,%rdi
0x55555562dd05 <+0x04d9> e8 00 4e 00 00 callq 0x555555632b0a QString::~QString()
0x55555562dd0a <+0x04de> eb 03 jmp 0x55555562dd0f MainWindow::on_pushButton_2_pressed()+1251
0x55555562dd0c <+0x04e0> 48 89 c3 mov %rax,%rbx
0x55555562dd0f <+0x04e3> 48 8d 45 a0 lea -0x60(%rbp),%rax
0x55555562dd13 <+0x04e7> 48 89 c7 mov %rax,%rdi
0x55555562dd16 <+0x04ea> e8 ef 4d 00 00 callq 0x555555632b0a QString::~QString()
0x55555562dd1b <+0x04ef> eb 6f jmp 0x55555562dd8c MainWindow::on_pushButton_2_pressed()+1376
0x55555562dd1d <+0x04f1> 48 89 c3 mov %rax,%rbx
28676 [2] ui->port->setPixmap(QPixmap::fromImage(img.scaled(541,301,Qt::KeepAspectRatio)));
0x55555562dd20 <+0x04f4> 48 8d 45 c0 lea -0x40(%rbp),%rax
0x55555562dd24 <+0x04f8> 48 89 c7 mov %rax,%rdi
0x55555562dd27 <+0x04fb> e8 c4 ea f2 ff callq 0x55555555c7f0 _ZN7QPixmapD1Ev@plt
0x55555562dd2c <+0x0500> eb 03 jmp 0x55555562dd31 MainWindow::on_pushButton_2_pressed()+1285
0x55555562dd2e <+0x0502> 48 89 c3 mov %rax,%rbx
0x55555562dd31 <+0x0505> 48 8d 45 a0 lea -0x60(%rbp),%rax
0x55555562dd35 <+0x0509> 48 89 c7 mov %rax,%rdi
0x55555562dd38 <+0x050c> e8 b3 ef f2 ff callq 0x55555555ccf0 _ZN6QImageD1Ev@plt
0x55555562dd3d <+0x0511> eb 39 jmp 0x55555562dd78 MainWindow::on_pushButton_2_pressed()+1356
0x55555562dd3f <+0x0513> 48 89 c3 mov %rax,%rbx
28679 [2] QPixmap::fromImage(img.scaled(width/4,height*2,Qt::KeepAspectRatio)).save("image2.jpg","JPG");
0x55555562dd42 <+0x0516> 48 8d 85 78 ff ff ff lea -0x88(%rbp),%rax
0x55555562dd49 <+0x051d> 48 89 c7 mov %rax,%rdi
0x55555562dd4c <+0x0520> e8 b9 4d 00 00 callq 0x555555632b0a QString::~QString()
0x55555562dd51 <+0x0525> eb 03 jmp 0x55555562dd56 MainWindow::on_pushButton_2_pressed()+1322
0x55555562dd53 <+0x0527> 48 89 c3 mov %rax,%rbx
0x55555562dd56 <+0x052a> 48 8d 45 c0 lea -0x40(%rbp),%rax
0x55555562dd5a <+0x052e> 48 89 c7 mov %rax,%rdi
0x55555562dd5d <+0x0531> e8 8e ea f2 ff callq 0x55555555c7f0 _ZN7QPixmapD1Ev@plt
0x55555562dd62 <+0x0536> eb 03 jmp 0x55555562dd67 MainWindow::on_pushButton_2_pressed()+1339
0x55555562dd64 <+0x0538> 48 89 c3 mov %rax,%rbx
0x55555562dd67 <+0x053b> 48 8d 45 a0 lea -0x60(%rbp),%rax
0x55555562dd6b <+0x053f> 48 89 c7 mov %rax,%rdi
0x55555562dd6e <+0x0542> e8 7d ef f2 ff callq 0x55555555ccf0 _ZN6QImageD1Ev@plt
0x55555562dd73 <+0x0547> eb 03 jmp 0x55555562dd78 MainWindow::on_pushButton_2_pressed()+1356
0x55555562dd75 <+0x0549> 48 89 c3 mov %rax,%rbx
28639 [3] QByteArray cmd= QByteArray::fromHex(test.replace("\r\n","").toLatin1());
0x55555562dd78 <+0x054c> 48 8d 85 70 ff ff ff lea -0x90(%rbp),%rax
0x55555562dd7f <+0x0553> 48 89 c7 mov %rax,%rdi
0x55555562dd82 <+0x0556> e8 cd fb f2 ff callq 0x55555555d954 QByteArray::~QByteArray()
0x55555562dd87 <+0x055b> eb 03 jmp 0x55555562dd8c MainWindow::on_pushButton_2_pressed()+1376
0x55555562dd89 <+0x055d> 48 89 c3 mov %rax,%rbx
28638 [3] QImage img(width, height, QImage::Format_RGB888);
0x55555562dd8c <+0x0560> 48 8d 45 80 lea -0x80(%rbp),%rax
0x55555562dd90 <+0x0564> 48 89 c7 mov %rax,%rdi
0x55555562dd93 <+0x0567> e8 58 ef f2 ff callq 0x55555555ccf0 _ZN6QImageD1Ev@plt
0x55555562dd98 <+0x056c> eb 03 jmp 0x55555562dd9d MainWindow::on_pushButton_2_pressed()+1393
0x55555562dd9a <+0x056e> 48 89 c3 mov %rax,%rbx
28635 [3] QString test= x_member;
0x55555562dd9d <+0x0571> 48 8d 85 68 ff ff ff lea -0x98(%rbp),%rax
0x55555562dda4 <+0x0578> 48 89 c7 mov %rax,%rdi
0x55555562dda7 <+0x057b> e8 5e 4d 00 00 callq 0x555555632b0a QString::~QString()
0x55555562ddac <+0x0580> 48 89 d8 mov %rbx,%rax
0x55555562ddaf <+0x0583> 48 89 c7 mov %rax,%rdi
0x55555562ddb2 <+0x0586> e8 39 ee f2 ff callq 0x55555555cbf0 _Unwind_Resume@plt
28683 [2] }
0x55555562ddb7 <+0x058b> e8 14 ec f2 ff callq 0x55555555c9d0 __stack_chk_fail@plt
0x55555562ddbc <+0x0590> 48 81 c4 d8 00 00 00 add $0xd8,%rsp
0x55555562ddc3 <+0x0597> 5b pop %rbx
0x55555562ddc4 <+0x0598> 5d pop %rbp
0x55555562ddc5 <+0x0599> c3 retq

KroMignon · 9 Oct 2020, 06:57

@swansorter said in Receive data with UDP protocol:

if i use received_data_x as class member i am getting segmentation fault

I don't understand this, I do this in many application running on Windows, Linux and Android and I never got a segmentation fault!

class MainWindow : public QMainWindow
{
    Q_OBJECT

...
   QUdpSoccket *mSocket;
   QByteArray mPayload;
...

private slots:
    void readPendingDatagrams();
}

and then

void MainWindow::readPendingDatagrams()
{
    while(mSocket->hasPendingDatagrams())
    {
        QByteArray datagram1;
        datagram1.resize(mSocket->pendingDatagramSize());
        mSocket->readDatagram(datagram1.data(),datagram1.size() );
        mPayload.append(datagram1.toHex());
    }
}

And this works fine.

swansorter · 10 Sept 2020, 06:30

@KroMignon
void MainWindow::on_pushButton_2_pressed()
{
//if iuse class member or global variable;
QString test= mPayLoad//class member;
int bufpo0 = 0, bufpo1 = 1, bufpo2 = 2, bufpo3 = 3;
QByteArray cmd= QByteArray::fromHex(test.replace("\r\n","").toLatin1());

for (int packet = 0; packet < cmd.length(); packet++)
{
//in this loop am getting segmentation fault*///
Auto_image_RGBdata[packet] = static_cast<quint8>(cmd.data()[bufpo0]) | static_cast<quint8>(cmd.data()[bufpo1]) << 8 | static_cast<quint8>(cmd.data()[bufpo2]) << 16 | static_cast<quint8>(cmd.data()[bufpo3])<< 24;

   bufpo0 = bufpo0 + 4;
   bufpo1 = bufpo1 + 4;
   bufpo2 = bufpo2 + 4;
   bufpo3 = bufpo3 + 4;

}

swansorter · 10 Sept 2020, 06:56

@swansorter in the above code i am getting segmentation fault

KroMignon · 10 Sept 2020, 07:06

@swansorter said in Receive data with UDP protocol:

in the above code i am getting segmentation fault

First, if you are expecting QByteArray, then store it as QByteArray in the readPendingDatagrams() slot, so don't have to convert from QByteArray to hexstring and back:

void MainWindow::readPendingDatagrams()
{
    while(mSocket->hasPendingDatagrams())
    {
        QByteArray datagram1;
        datagram1.resize(mSocket->pendingDatagramSize());
        mSocket->readDatagram(datagram1.data(),datagram1.size() );
        mPayload.append(datagram1);
    }
}

Then how did you declare Auto_image_RGBdata?