Оптимальная методика анализа данных char * в реальном времени, полученных из буфера, для текстового содержимого в C ++ - PullRequest
Новая
       5

Оптимальная методика анализа данных char * в реальном времени, полученных из буфера, для текстового содержимого в C ++

1 голос
/ 02 сентября 2011

Я создал прямой непрерывный поток mjpeg. Грубая иллюстрация, как это 

....[image (jpeg)]->[text "content-length"]->[image (jpeg)]->[text "content-length"]->....

Как вы можете видеть, я получаю данные из медиа-линии gstreamer, которая содержит изображение и мой собственный текст (Примечание: хотя я использую Gstreamer, мой вопрос касается только принципов C ++.)

Чтобы проанализировать эти данные в реальном времени, я пытаюсь получить их и поместить в очередь. Впоследствии я планирую проанализировать данные по слову «длина содержимого» после того, как очередь содержит определенное количество пакетов.

Мой код выглядит следующим образом: 

void clear( std::queue<char> &q )
{
   std::queue<char> empty;
   std::swap( q, empty );
}


static GstFlowReturn new_buffer (GstAppSink *app_sink, gpointer user_data)
{

  GstBuffer* buffer = gst_app_sink_pull_buffer(app_sink);

  //create queue
  std::queue<char> q;

  g_print("The input buffer contents are\n");

  gint i=0;
  for(i=0; buffer->data[i];i++)
  {  
      //g_print("\n%d",i);
      q.push(buffer->data[i]);
  }
  //g_print("\nsize of inbuf is %d\n",GST_BUFFER_SIZE(buffer)); 
  g_print("\n");  
  gst_buffer_unref(buffer);

  //#####################
  //parsing method here???
  //#####################

  clear(q);
  return GST_FLOW_OK;
}

Я использовал циклические очереди / кольцевой буфер в C / C ++ раньше. Это лучший вариант? Или же очереди C ++ STL были бы более подходящими в этом сценарии, как описано выше?

Ответы [ 2 ]

0 голосов
/ 29 сентября 2011

Я закончил тем, что использовал класс ringbuffer

В заголовочном файле объявляем 

 //queue size
enum { rb_size = 5 };       // ---->element1 -> element2 -> .... -> elementN -> gap ->
                            // ^                                                     |
                            // |                                                     |  
                            // <--------------------<------------------<-------------V
typedef struct 
{
 char * data[rb_size];
 int head, tail;
} ring_buffer_struct; 

namespace myspace{
class ring_buffer{

    private:

    protected:          

    public: 
    //========= constructor ============
    ring_buffer()  
    {
    //If necessary initialization can happen here.

    }
    //========== destructor =============
    virtual ~ring_buffer()
    {

    }
    //===================================
    virtual void rb_start(ring_buffer_struct *b);
    virtual bool rb_empty(ring_buffer_struct const *b);
    virtual char *  rb_front(ring_buffer_struct const *b);
    virtual char *  rb_rear(ring_buffer_struct const *b);
    virtual void rb_pop_front(ring_buffer_struct *b);
    virtual ring_buffer_struct* rb_push_back(ring_buffer_struct *b);

}; //end of class
}

В файле cpp 

//start
void myspace::ring_buffer::rb_start(ring_buffer_struct *b)
{
b->head = 0; b->tail = 0;
}

//clear
bool myspace::ring_buffer::rb_empty(ring_buffer_struct const *b)
{
    return b->head == b->tail;
}

//front element
char *  myspace::ring_buffer::rb_front(ring_buffer_struct const *b)
{
return b->data[b->head]; //data gets popped
}

//rear element
    char *  myspace::ring_buffer::rb_rear(ring_buffer_struct const *b)
{
return b->data[b->tail]; //data gets pushed
}

//pop out front element
void myspace::ring_buffer::rb_pop_front(ring_buffer_struct *b)
{ 

    if(b->head < b->tail)  
{
      ++b->head; 
    }      
    if(b->head > b->tail)
{     
  b->head = 0;        
}

}

//push in rear element
ring_buffer_struct* myspace::ring_buffer::rb_push_back(ring_buffer_struct *b)
{
int new_tail = b->tail;

if (++new_tail >= rb_size)
{   //beginning of the queue
    new_tail = 0;      
}
if (new_tail != b->head)
{             
   //middle of the queue
    b->tail = new_tail;       
}
 if (new_tail <= b->head) 
     {
       b->tail = 0;           
     }

return b;
}

И используем в main () 

  ...

char element1[10] = "abcdefghi";
char element2[10] = "bcdefghij";
char element3[10] = "cdefghijk";

ring_buffer_struct rb;
myspace::ring_buffer q;
q.rb_empty(&rb); //make sure empty
q.rb_start(&rb); //start - initialize

    //initialize
    uint16_t i;
    for(i=0;i<rb_size;i++)
    {
     rb.data[rb.tail] = (char *)"000000000";
     q.rb_push_back(&rb);
    }

    rb.data[rb.tail] = element1;
    q.rb_push_back(&rb);
    q.rb_pop_front(&rb);         //now parse    


    rb.data[rb.tail] = element2;
    q.rb_push_back(&rb);
    q.rb_pop_front(&rb);    //now parse

      ...

Для разбора: я посмотрел этот пост

Простой разбор строк с C ++

0 голосов
/ 03 сентября 2011

Предложение не по теме:

При использовании трюка подкачки для очистки контейнера STL не вызывайте явно std::swap, так как в итоге вы можете не получить более оптимизированную версию.Лучший способ: 

void clear( std::queue<char> &q )
{
   std::queue<char> empty;
   using std::swap;
   swap( q, empty );
}

Это позволяет компилятору выбирать специализированную версию swap, оптимизированную для типа используемого вами контейнера.Вы также можете попробовать q.swap(empty);, но я не уверен, что все реализации STL предлагают это.

...