diff --git a/imagebuffer.cpp b/imagebuffer.cpp
index 7469125..4f7cc1d 100644
--- a/imagebuffer.cpp
+++ b/imagebuffer.cpp
@@ -5,11 +5,11 @@ using namespace std::chrono;
 
 ImageBuffer::ImageBuffer(size_t buffer_size, QObject *parent) : QObject(parent), buffer_size(buffer_size) {
   buffer.resize(buffer_size, nullptr);
-  std::cerr << "imagebuffer constructor!" << std::endl;
+  qDebug() << "Imagebuffer constructor!";
 }
 
 void ImageBuffer::clear() {
-  // std::cerr << "Clear Image buffer!" << std::endl;
+  qDebug() << "Clear Image buffer!";
 
   for (auto & img: buffer) {
     if (img != nullptr)
@@ -25,16 +25,21 @@ size_t ImageBuffer::capacity() {
 
 double ImageBuffer::bufferPressure() {
   double pressure;
+  size_t l = bufferLoad();
   mutex.lock();
-  pressure = static_cast<double>(load)/static_cast<double>(buffer.capacity());
+  pressure = l / buffer_size * 100;
   mutex.unlock();
-  return pressure * 100;
+  return pressure;
 }
 
 size_t ImageBuffer::bufferLoad() {
   size_t l;
   mutex.lock();
-  l = load;
+  if (read_idx > head_idx){
+    l = buffer_size - read_idx - head_idx;
+  } else {
+    l = head_idx - read_idx;
+  }
   mutex.unlock();
   return l;
 }
@@ -42,35 +47,31 @@ size_t ImageBuffer::bufferLoad() {
 void ImageBuffer::resize(size_t new_size) {
   qDebug() << "Buffer Resize";
   mutex.lock();
-  
   buffer_size = new_size;
   buffer.clear();
-  buffer.resize(new_size, nullptr);
-  current_read_index = 0;
-  current_write_index = 0;
+  buffer.resize(buffer_size, nullptr);
+  framecounts.clear();
+  framecounts.resize(buffer_size, 0);
+  read_idx = 0;
+  head_idx = 0;
   load = 0;
+  framecount = 0;
   mutex.unlock();
 }
 
 void ImageBuffer::push(MyImage *img) {
   mutex.lock();
-  if (buffer[current_write_index] != nullptr) {
-    qWarning() << "possible frame drop detected!!";
-    qWarning() << "buffer.push write: " << current_write_index << " read: " << current_read_index << " load: " << load;
-    delete(buffer[current_write_index]);
+  head_idx += 1;
+  framecount +=1;
+  if (head_idx >= buffer_size) {
+    head_idx = 0;
   }
-  buffer[current_write_index] = img;
-  current_write_index += 1;
-  load += 1;
-  if (current_write_index >= buffer_size){
-    current_write_index = 0;
-  } 
-  if (load >= buffer_size){
-    load = buffer_size;
-    if (current_read_index == current_write_index)
-      current_read_index = current_write_index < buffer_size - 1 ? current_write_index + 1 : 0;
+  if (buffer[head_idx] != nullptr) {
+    delete(buffer[head_idx]);
   }
-  // std::cout << "Buffer.afterpush: load = " << load << " write index =" << current_write_index << " read index = " << current_read_index << std::endl;
+  buffer[head_idx] = img;
+  framecounts[head_idx] = framecount;
+  load = load < buffer_size ? load +=1 : buffer_size;
 
   mutex.unlock();
 }
@@ -83,35 +84,28 @@ bool ImageBuffer::bufferNotEmpty() {
   return res;
 }
 
-MyImage* ImageBuffer::pop() {
-  bool ret = false;
-  MyImage * img;
+MyImage* ImageBuffer::read(size_t &framecount){
+  MyImage *img = nullptr;
   mutex.lock();
-  if (load > 0) {
-    img = buffer[current_read_index];
-    current_read_index < (buffer_size - 1) ? current_read_index += 1 : current_read_index = 0;
-    load -= 1;
+  if (read_idx < head_idx) {
+    read_idx += 1;
+  } else if (read_idx > head_idx) {
+    read_idx < buffer_size ? read_idx += 1 : read_idx = 0;
+  } else {
+    framecount = 0;
+    return img;
   }
+  img = buffer[read_idx];
+  framecount = framecounts[read_idx];
   mutex.unlock();
-  std::cerr << "buffer.pop write: " << current_write_index << " read: " << current_read_index << " load: " << load << std::endl;
-
   return img;
 }
 
-MyImage* ImageBuffer::readLast() {
-  MyImage *img;
-  img = nullptr;
+MyImage* ImageBuffer::readLast(size_t &framecount) {
+  MyImage *img = nullptr;
   mutex.lock();
-  if (load > 0) {
-    size_t idx = current_write_index - 1;
-
-    if (idx < 0) {
-      std::cerr << "Bank" << std::endl;
-      idx = buffer_size - 1;
-    }
-    std::cerr << "read form index " << idx << std::endl;
-    img = buffer[idx];
-  }
+  img = buffer[head_idx];
+  framecount = framecounts[head_idx];
   mutex.unlock();
   return img;
 }
diff --git a/imagebuffer.h b/imagebuffer.h
index b4deb58..6f7ee85 100644
--- a/imagebuffer.h
+++ b/imagebuffer.h
@@ -17,8 +17,8 @@ public:
   void clear();
   void resize(size_t new_size);
   void push(MyImage *img);
-  MyImage* pop();
-  MyImage* readLast();
+  MyImage* read(size_t &framecount);
+  MyImage* readLast(size_t &framecount);
   size_t capacity();
   double bufferPressure();
   size_t bufferLoad();
@@ -29,10 +29,12 @@ private:
   int numUsedBytes = 0;
 
   std::vector<MyImage*> buffer;
-  size_t current_write_index = 0;
-  size_t current_read_index = 0;
+  std::vector<size_t> framecounts;
+  size_t head_idx = 0;
+  size_t read_idx = 0;
   size_t load = 0;
   size_t buffer_size;
+  size_t framecount = 0;
 
 signals: