source/src/fifo.cpp

   1 /*
   2         Skelton for retropc emulator
   3
   4         Author : Takeda.Toshiya
   5         Date   : 2014.12.19-
   6
   7         [ fifo buffer ]
   8 */
   9
  10 #include <stdlib.h>
  11 #include <malloc.h>
  12 #include "fifo.h"
  13 #include "fileio.h"
  14
  15 FIFO::FIFO(int s, int empty_warn, int fill_warn)
  16 {
  17         size = s;
  18         //buf = (int*)malloc(size * sizeof(int));
  19         buf = new int[size];
  20
  21         cnt = rpt = wpt = 0;
  22         empty_warn_val = empty_warn;
  23         if(fill_warn <= 0) {
  24                 fill_warn_val = INT_MAX;
  25         } else {
  26                 fill_warn_val = fill_warn;
  27         }
  28 }
  29
  30 void FIFO::release()
  31 {
  32         //free(buf);
  33         delete[] buf;
  34 }
  35
  36 void FIFO::clear()
  37 {
  38         cnt = rpt = wpt = 0;
  39         fill_warn_flag = false;
  40         if(empty_warn_val > 0) empty_warn_flag = false;
  41 }
  42
  43 void FIFO::write(int val, bool *p_fill_warn)
  44 {
  45         __LIKELY_IF(cnt < size) {
  46                 buf[wpt++] = val;
  47                 __UNLIKELY_IF(wpt >= size) {
  48                         wpt = 0;
  49                 }
  50                 cnt++;
  51                 __UNLIKELY_IF(fill_warn_val < cnt) {
  52                         fill_warn_flag = true;
  53                 } else {
  54                         fill_warn_flag = false;
  55                 }
  56         }
  57         __UNLIKELY_IF(p_fill_warn != nullptr) {
  58                 *p_fill_warn = fill_warn_flag;
  59         }
  60 }
  61
  62 int FIFO::read(bool *p_empty_warn)
  63 {
  64         int val = 0;
  65         __LIKELY_IF(cnt > 0) {
  66                 val = buf[rpt++];
  67                 __UNLIKELY_IF(rpt >= size) {
  68                         rpt = 0;
  69                 }
  70                 cnt--;
  71                 __UNLIKELY_IF(cnt <= 0) {
  72                         cnt = 0;
  73                         rpt = 0;
  74                         wpt = 0;
  75                 }
  76                 __UNLIKELY_IF(empty_warn_val > cnt) {
  77                         empty_warn_flag = true;
  78                 } else {
  79                         empty_warn_flag = false;
  80                 }
  81         }
  82         __UNLIKELY_IF(p_empty_warn != nullptr) {
  83                 *p_empty_warn = empty_warn_flag;
  84         }
  85         return val;
  86 }
  87
  88 int FIFO::read_not_remove(int pt, bool *p_empty_warn)
  89 {
  90         __UNLIKELY_IF(p_empty_warn != nullptr) {
  91                 *p_empty_warn = empty_warn_flag;
  92         }
  93         __LIKELY_IF(pt >= 0 && pt < cnt) {
  94                 pt += rpt;
  95                 if(pt >= size) {
  96                         pt -= size;
  97                 }
  98                 return buf[pt];
  99         }
 100         return 0;
 101 }
 102
 103 void FIFO::write_not_push(int pt, int d, bool *p_fill_warn)
 104 {
 105         __UNLIKELY_IF(p_fill_warn != nullptr) {
 106                 *p_fill_warn = fill_warn_flag;
 107         }
 108         __LIKELY_IF(pt >= 0 && pt < cnt) {
 109                 pt += wpt;
 110                 if(pt >= size) {
 111                         pt -= size;
 112                 }
 113                 buf[pt] = d;
 114                 return;
 115         }
 116 }
 117
 118 int FIFO::count()
 119 {
 120         return cnt;
 121 }
 122
 123 int FIFO::fifo_size()
 124 {
 125         return size;
 126 }
 127
 128 bool FIFO::full()
 129 {
 130         return (cnt == size);
 131 }
 132
 133 int FIFO::left()
 134 {
 135         int val = size - cnt;
 136         __UNLIKELY_IF(val < 0) val = 0;
 137         __UNLIKELY_IF(val > size) val = size;
 138         return val;
 139 }
 140
 141 bool FIFO::empty()
 142 {
 143         return (cnt <= 0);
 144 }
 145
 146 #define STATE_VERSION   1
 147
 148 bool FIFO::process_state(void *f, bool loading)
 149 {
 150         FILEIO *state_fio = (FILEIO *)f;
 151
 152         if(!state_fio->StateCheckUint32(STATE_VERSION)) {
 153                 return false;
 154         }
 155         state_fio->StateValue(size);
 156         state_fio->StateArray(buf, size * sizeof(int), 1);
 157         state_fio->StateValue(cnt);
 158         state_fio->StateValue(rpt);
 159         state_fio->StateValue(wpt);
 160         return true;
 161 }