git.sesse.net Git - fjl/blob - bytesource.c

   1 #include <stdbool.h>
   2 #include <string.h>
   3 #include <assert.h>
   4
   5 #include "choice.h"
   6 #include "bytesource.h"
   7
   8 #define MARKER_CHAR 0xff
   9 #define STUFF_MARKER 0x00
  10
  11 void init_byte_source(struct byte_source* source, raw_input_func_t* input_func, void* userdata)
  12 {
  13         // TODO: should this size be a different constant?
  14         memset(source, 0, sizeof(*source));
  15         source->bytes = (uint8_t*)malloc(BYTESOURCE_CHUNK_SIZE);
  16         source->input_func = input_func;
  17         source->userdata = userdata;
  18 }
  19
  20 uint8_t byte_source_read_marker(struct byte_source* src)
  21 {
  22         // Refill until we have at least two bytes or EOF.
  23         while (src->bytes_available < 2) {
  24                 const unsigned bytes_to_read = BYTESOURCE_CHUNK_SIZE - src->bytes_available;
  25                 const ssize_t bytes_read =
  26                         (*src->input_func)(src->userdata,
  27                                            src->bytes + src->bytes_available,
  28                                            bytes_to_read);
  29                 assert(bytes_read >= -1);
  30                 assert(bytes_read <= (ssize_t)bytes_to_read);
  31
  32                 if (bytes_read == -1 || bytes_read == 0) {
  33                         return 0x00;
  34                 }
  35
  36                 src->bytes_available += bytes_read;
  37         }
  38
  39         assert(src->bytes_available >= 2);
  40         if (src->bytes[0] != MARKER_CHAR || src->bytes[1] == STUFF_MARKER) {
  41                 return 0x00;
  42         }
  43
  44         uint8_t ret = src->bytes[1];
  45         memmove(src->bytes, src->bytes + 2, src->bytes_available - 2);
  46         src->bytes_available -= 2;
  47
  48         return ret;
  49 }
  50
  51 ssize_t byte_source_input_func(void* source, uint8_t* buf, size_t len)
  52 {
  53         struct byte_source* src = (struct byte_source*)source;
  54
  55         // If there's no data in the buffer (or only a partial marker), we have
  56         // to read in more from our upstream src.
  57         while (src->bytes_available == 0 ||
  58                (src->bytes_available == 1 && src->bytes[0] == MARKER_CHAR)) {
  59                 const unsigned space_left = BYTESOURCE_CHUNK_SIZE - src->bytes_available;
  60                 const size_t bytes_to_read = (len > space_left ? space_left : len);
  61                 assert(bytes_to_read <= BYTESOURCE_CHUNK_SIZE);
  62                 const ssize_t bytes_read =
  63                         (*src->input_func)(src->userdata,
  64                                               src->bytes + src->bytes_available,
  65                                               bytes_to_read);
  66                 assert(bytes_read >= -1);
  67                 assert(bytes_read <= (ssize_t)bytes_to_read);
  68
  69                 if (bytes_read == -1) {
  70                         return -1;
  71                 } else if (bytes_read == 0) {
  72                         if (src->bytes_available == 1) {
  73                                 // EOF in the middle of a marker => read error
  74                                 return -1;
  75                         } else {
  76                                 assert(src->bytes_available == 0);
  77                                 return 0;
  78                         }
  79                 }
  80
  81                 src->bytes_available += bytes_read;
  82         }
  83
  84         // Now unstuff as much as we can. First of all, if there's a 0xFF at the
  85         // end of the buffer, we don't include it this time; the unstuff function
  86         // will only give us an error since it can't decide if it's a marker or
  87         // a stuffed 0xFF.
  88         unsigned bytes_to_unstuff = src->bytes_available;
  89         bool end_marker = false;
  90         assert(bytes_to_unstuff > 0);
  91         if (src->bytes[bytes_to_unstuff - 1] == 0xff) {
  92                 --bytes_to_unstuff;
  93                 end_marker = true;
  94         }
  95
  96         int unstuffed_bytes = (*unstuff_choice)(buf, src->bytes, bytes_to_unstuff);
  97         assert(unstuffed_bytes != 0);
  98         if (unstuffed_bytes > 0) {
  99                 // Fast path: No markers in the data. We can basically just
 100                 // return it.
 101                 if (end_marker) {
 102                         src->bytes_available = 1;
 103                         src->bytes[0] = 0xff;
 104                 } else {
 105                         src->bytes_available = 0;
 106                         src->bytes[0] = 0;
 107                 }
 108                 return unstuffed_bytes;
 109         }
 110
 111         // Slow path: There was a marker in the data. Unstuff manually until
 112         // we hit the marker, then return that.
 113         assert(unstuffed_bytes == -1);
 114         unsigned bytes_read;
 115         unsigned bytes_written = 0;
 116         for (bytes_read = 0; bytes_read < src->bytes_available; ++bytes_read) {
 117                 buf[bytes_written++] = src->bytes[bytes_read];
 118                 if (src->bytes[bytes_read] != MARKER_CHAR) {
 119                         continue;
 120                 }
 121
 122                 assert(bytes_read < src->bytes_available);
 123                 if (src->bytes[bytes_read + 1] == STUFF_MARKER) {
 124                         // Skip the stuff byte.
 125                         ++bytes_read;
 126                         continue;
 127                 } else {
 128                         // OK, this is our marker.
 129                         break;
 130                 }
 131         }
 132
 133         memmove(src->bytes, src->bytes + bytes_read, src->bytes_available - bytes_read);
 134         src->bytes_available -= bytes_read;
 135         assert(bytes_written >= 1);
 136         return bytes_written - 1;
 137 }