Здравствуйте, есть приложение, использующее udp сокеты. В приложении bind с адресом AnyIPv4.
Также есть функция, посылающая в LocalHost данные в размере 72 байт в виде счётчика (по 64 байта).
Посылаемые данные представляют собой изображение, разбитое на блоки размером по 64 байта.
Изображение имеет размеры в 320х256 пикселов ( =81920 пикселов). Посылается 1280 блоков по 72 байта,
из которых данными являются 1280 блоков по 64 байта.
При посылке 1280 блоков по 72 байта принимается только 58304 байта (три четверти от посылаемых данных).
Вопрос: как добиться приема всей последовательности данных?

Фрагменты программного кода:

class Controller;
class Controller2;
class Window : public QWidget
{
    Q_OBJECT

public:
    Window();
    void appendtoLogListBox(const QString & );
    void /*HellowUDP*/writeToUdp(const QByteArray& qBinArray);
    void writeData(const QByteArray& qba);
    void gui_prepare_generate_data();
    QByteArray another_qba;
public slots:
    void displayImage(const QImage& );
    void launch();
    void processUdpData();
    void readPendingDatagrams();
    void setUdpData(const QByteArray& );
signals:
    void writeUdpData(const QByteArray & );
private:
    Helper helper;
    QImage img1;
    Controller *cntrl;
    Controller2 *cntrl_2;
    QUdpSocket *socket;
    QListWidget *listWidget;
    int i_counter;

};

QByteArray another_qba;

Window::Window()
{
    i_counter=0;
    int data_quant=81920;
    another_qba.resize(data_quant);

    connect(button_3,SIGNAL(clicked()),this,SLOT(processUdpData()));
    socket=new QUdpSocket(this);
    bool result;

    result=socket->bind(/*QHostAddress(QString("192.168.10.3" "127.0.0.1"))*/QHostAddress::AnyIPv4/*LocalHost*/,50011/*2*/);
    QString algostr;
    algostr=QString(tr("bind returned %1")).arg(result);
    qDebug() << algostr;
    qDebug() << result;
    if(result)
    {
        qDebug() << "PASS";
    }
    else
    {
        qDebug() << "FAIL";
        qDebug() << "error" << socket->error();
        qDebug() << socket->errorString().toLocal8Bit();
    }
   // do_send_result(algostr);
    connect(socket, &QUdpSocket::readyRead,this,&/*UDPresource*/Window::readPendingDatagrams);
    connect(this,&Window::writeUdpData,this,&Window::setUdpData);
}

void Window::displayImage(const QImage& img)
{
    img1=img;
    helper.img2=img1;
   // update();
   // qDebug() << "--- displayImage func";
    return;
}

void Window::readPendingDatagrams()
{
    int size_of_data=0;
    qint64 ret_value=0;
    QByteArray buffer;
    QString str;
    while(socket->hasPendingDatagrams())
    {
        size_of_data=socket->pendingDatagramSize();
        if(-1==size_of_data) continue;
        buffer.resize(socket->pendingDatagramSize());
        QHostAddress sender;
        quint16 senderPort;
        ret_value=socket->readDatagram(buffer.data(),buffer.size(),&sender,&senderPort);
        if(-1==ret_value)
        {
            str=QString(tr("readDatagram failed"));
            qDebug() << str;
           // do_send_result(str);
            appendtoLogListBox(str);
            continue;
        }
//        qDebug() << "Message from: " << sender;
//        qDebug() << "Message port: " << senderPort;
        quint32 value; bool ok;
        value=sender.toIPv4Address(&ok);
        if(true==ok)
        {
            str=QString(tr("address is %1 port %2")).arg(value,0,16).arg(senderPort);
            //qDebug() << str;
        }
        emit writeUdpData(buffer);
        //qDebug() << "emit writeUdpData(buffer)";
    }
}

void Window::processUdpData()
{
    QByteArray qba1;
    QByteArray Data;
    Data.resize(72);

        Data[0]=0xFF;
        Data[1]=0x00;
        Data[2]=0x00;
        Data[3]=0x00;
        Data[4]=0x00;
        Data[5]=0x00;
        Data[6]=0x00;
        Data[7]=0x00;
        for(int i=0;i<64;i++)
            Data[i+8]=(u_char)i;
        for(int i=0;i<1280;i++)//81920 bytes 
        writeToUdp(Data);
    return;
}

void Window::writeToUdp(const QByteArray& qBinArray)
{
    QByteArray Data;
    QHostAddress address;
   // quint16 port;
    quint16 port_large;
    qint64 retData=0;
    QString str;

    port_large=50011/*50012*/;
    retData=socket->writeDatagram(qBinArray/*Data*/,/*address*/QHostAddress::LocalHost, port_large);
    if(-1==retData)
    {
        qWarning() << "Unable to write data to " << address.toString() << ":" << /*port*/port_large << endl;
        str=QString(tr("*** writeDatagram returned %1")).arg(retData);
        qDebug() << str;
        appendtoLogListBox(str);
    }
}

void Window::setUdpData(const QByteArray& qba)
{
    QString result;
    //result=QString(tr("--- Window _ setUdpData slot"));
    int data_quant=81920;
    //qDebug() << "receiveUdpData slot";
    for(int i=0;i<64;i++)
    {
        another_qba[i_counter]=qba[i+8];
        i_counter++;
    }
    if(i_counter==data_quant)
    {
        gui_prepare_generate_data();
        i_counter=0;
    }
        qDebug() << "i_counter" << i_counter;
    return;
}

void Window::gui_prepare_generate_data()
{
    QString str;
    QString filePath;
    QFile file;
    QDataStream dstrm;
    int n=0;
    int data_quant=0;
    std::vector<unsigned short> buffer_vect;
    QSize rct_size(320,256);

   // QPixmap myPixmap;

    QImage loc_img(rct_size,QImage::Format_RGB32 /*QImage::Format_RGBX8888*/);

    QRgb *line;

   // pixmap_vect.clear();

   // QBuffer hr;

    unsigned long/* long */ start_time=GetTickCount();

        for(int y=0;y<loc_img.height();y++)
        {
           // QRgb *line=reinterpret_cast<QRgb*>(loc_img.scanLine(y));
            line=static_cast<QRgb *>(static_cast<void *>(loc_img.scanLine(y)));
            for(int x=0;x<loc_img.width();x++)
            {
                line[x]=qRgb(another_qba[n],another_qba[n],another_qba[n]);
                n++;
            }
        }

        //img1=loc_img;
        displayImage(loc_img);

    unsigned long/* long */ end_time=GetTickCount();
    unsigned long/* long */ loc_delta=end_time-start_time;
   // loc_list.clear();
    return;
}