🚀 go-pugleaf

How to use...(actual code is below)...

#include "CircBuff.h"
TCircBuff *Buff1 = new TCircBuff; // Declaration....

//---------------------------------------------------------------------------
// In Server Code - UDP Reader
//---------------------------------------------------------------------------

void __fastcall TDataModule1::UDPServer1UDPRead(TObject *Sender,
       TStream *AData, TIdSocketHandle *ABinding)
{
   if (Buff1) // does our object exists?
   {
     Buff1->tmpl = AData->Size;
     AData->ReadBuffer(Buff1->tmps, Buff1->tmpl);
     Buff1->AddTmp();
   }
}

//---------------------------------------------------------------------------
// In Consumer Code, e.g. A Form with a Timer and a Memo
//---------------------------------------------------------------------------

void __fastcall TForm1::Timer1Timer(TObject *Sender)
{
   unsigned char s[4096]; // you may want to declare this in a heap...
   int len;
   Timer1->Enabled = false;
   if (Buff1->Count>0)
   {
      Memo1->Lines->Add("----------------------");
      Buff1->GetElement(s, len);
      AnsiString B = s;
      Memo1->Lines->Add(B); // place in a memo or something...
   }
   Timer1->Enabled = true;
}



==================================CIRCBUFF.H================================
//--------------------------------------------------------------------------

#ifndef CircBuffH
#define CircBuffH

// You may need to change these accordingly

#define TOTALPACKETS 512
#define PACKETSIZE   4096
struct packetstruct
{
    unsigned char *s;
    int l;

};


class TCircBuff
{

private:
    volatile int front, rear, count;
    packetstruct * buffer;

    CRITICAL_SECTION GlobalCriticalSection;
    void memcpy2(unsigned char *d, unsigned char *s, int l);

public:
   __fastcall TCircBuff();
   __fastcall ~TCircBuff();

   char *tmps;
   int  tmpl;

   void GetElement(unsigned char *ss, int & ll);
   void SetElement(unsigned char *ss, int ll);
   int  FGetCount(void) { return count; };
   void AddTmp();

   __property int Count = { read=FGetCount  };

};

//---------------------------------------------------------------------------
//---------------------------------------------------------------------------

#endif

=============================end-of-CIRCBUFF.H===============================



================================CIRCBUFF.CPP=================================

//---------------------------------------------------------------------------

#include <vcl.h>
#pragma hdrstop

#include "CircBuff.h"

//---------------------------------------------------------------------------
#pragma package(smart_init)
//---------------------------------------------------------------------------

__fastcall TCircBuff::TCircBuff()
{
    buffer = new packetstruct [TOTALPACKETS];
    tmps = new unsigned char [PACKETSIZE];
    for (int i=0; i<TOTALPACKETS; i++)
    {
       buffer[i].s = new unsigned char [PACKETSIZE];
       buffer[i].l = 0;
    }
    front=0;
    rear=0;
    count=0;
    InitializeCriticalSection(&GlobalCriticalSection);
}

//---------------------------------------------------------------------------

__fastcall TCircBuff::~TCircBuff()
{
    for (int i=0; i<TOTALPACKETS; i++)
    {
       delete []buffer[i].s;
    }
   delete []buffer;
   delete []tmps;
   DeleteCriticalSection(&GlobalCriticalSection);
}

//---------------------------------------------------------------------------

void TCircBuff::GetElement(unsigned char *ss, int & ll)
{
   EnterCriticalSection(&GlobalCriticalSection);
   if (count>0)
   {
     memcpy2(tmps, buffer[front].s, PACKETSIZE);
     tmpl = buffer[front].l;
     count--;
     front++;
     if (front == TOTALPACKETS) front=0;
   }
   else
   {
     ZeroMemory(tmps, PACKETSIZE);
     tmpl=0;
   }
   memcpy2(ss, tmps, PACKETSIZE);
   ll = tmpl;
   LeaveCriticalSection(&GlobalCriticalSection);
}

//---------------------------------------------------------------------------

void TCircBuff::SetElement(unsigned char *ss, int ll)
{
   EnterCriticalSection(&GlobalCriticalSection);
   memcpy2(buffer[rear].s, ss,PACKETSIZE);
   buffer[rear].l = ll;
   if (count < TOTALPACKETS)
   {
     count++;
     rear++;
     if (rear == TOTALPACKETS)
     {
       rear = 0;
     }
   }
   LeaveCriticalSection(&GlobalCriticalSection);
}

//---------------------------------------------------------------------------

void TCircBuff::AddTmp()
{
   SetElement(tmps, tmpl);
}

//---------------------------------------------------------------------------

void TCircBuff::memcpy2(unsigned char *d, unsigned char *s, int l)
{
    if (!d) return;
    if (!s) return;
    while (l--) *d++ = *s++;
}

//---------------------------------------------------------------------------

==============================end-of-CIRCBUFF.CPP============================







Dave K. wrote:
> Colin, thanks for the suggestion. If you could post your code I would 
> greatly appreciate it.
> 
> Thanks
> Dave
> 
> 
> Colin B Maharaj wrote:
>> Dave, what I do is to create a circular buffer
>> then take the entire UDP packet and place it in this
>> circular buffer.
>> Will post code on demand....
>>
>>
>>
>> Dave K. wrote:
>>> Hello,
>>> I am using the Indy UDP server component in an application, and am 
>>> experiencing quite a few missed packets 
>>> Dave