buffering.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2007 Nicolas Pennequin
  11  *
  12  * All files in this archive are subject to the GNU General Public License.
  13  * See the file COPYING in the source tree root for full license agreement.
  14  *
  15  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  16  * KIND, either express or implied.
  17  *
  18  ****************************************************************************/
  19
  20 #include <stdio.h>
  21 #include <stdlib.h>
  22 #include <stdbool.h>
  23 #include <string.h>
  24 #include <fcntl.h>
  25 #include "buffering.h"
  26 #include "aux.h"
  27
  28 /* Rockbox constants */
  29 #define HZ 1
  30 /* amount of data to read in one read() call */
  31 #define AUDIO_DEFAULT_FILECHUNK      (1024*32)
  32
  33
  34 #define BUFFER_SIZE  (32*1024*1024)
  35 #define GUARD_SIZE   (32*1024)
  36
  37
  38 /* Ring buffer helper macros */
  39 /* Buffer pointer (p) plus value (v), wrapped if necessary */
  40 #define RINGBUF_ADD(p,v) ((p+v)<buffer_len ? p+v : p+v-buffer_len)
  41 /* Buffer pointer (p) minus value (v), wrapped if necessary */
  42 #define RINGBUF_SUB(p,v) ((p>=v) ? p-v : p+buffer_len-v)
  43 /* How far value (v) plus buffer pointer (p1) will cross buffer pointer (p2) */
  44 #define RINGBUF_ADD_CROSS(p1,v,p2) \
  45 ((p1<p2) ? (int)(p1+v)-(int)p2 : (int)(p1+v-p2)-(int)buffer_len)
  46 /* Bytes available in the buffer */
  47 #define BUF_USED RINGBUF_SUB(buf_widx, buf_ridx)
  48
  49 #ifndef MIN
  50 #define MIN(a, b) (((a)<(b))?(a):(b))
  51 #endif
  52
  53
  54 static size_t buffer_len;
  55 static char *buffer;
  56 static char *buffer_end;
  57
  58 static size_t conf_filechunk;
  59
  60 static size_t buf_widx;
  61 static size_t buf_ridx;
  62
  63 /* current memory handle in the linked list. NULL when the list is empty. */
  64 static struct memory_handle *cur_handle;
  65 /* first memory handle in the linked list. NULL when the list is empty. */
  66 static struct memory_handle *first_handle;
  67 static int num_handles;
  68
  69
  70 /* add a new handle to the linked list and return it. It will have become the
  71    new current handle */
  72 static struct memory_handle *add_handle(void)
  73 {
  74     /* this will give each handle a unique id */
  75     static int cur_handle_id = 0;
  76
  77     int data_size = sizeof(struct memory_handle) /*
  78                     + 1024*1024 - sizeof(struct memory_handle) */;
  79
  80     /* check that we actually can add the handle and its data */
  81     if (RINGBUF_ADD_CROSS(buf_widx, data_size, buf_ridx) >= 0) {
  82         return NULL;
  83     }
  84
  85     struct memory_handle *new_handle = (struct memory_handle *)(buffer + buf_widx);
  86     buf_widx = RINGBUF_ADD(buf_widx, data_size);
  87
  88     if (!first_handle) {
  89         /* the new handle is the first one */
  90         first_handle = new_handle;
  91     }
  92
  93     if (cur_handle) {
  94         cur_handle->next = new_handle;
  95     }
  96
  97     cur_handle = new_handle;
  98     cur_handle->id = cur_handle_id++;
  99     num_handles++;
 100     return cur_handle;
 101 }
 102
 103 /* delete a given memory handle from the linked list
 104    and return true for success. Nothing is actually erased from memory. */
 105 static bool rm_handle(struct memory_handle *h)
 106 {
 107     if (h == first_handle) {
 108         first_handle = h->next;
 109     } else {
 110         struct memory_handle *m = first_handle;
 111         while (m && m->next != h) {
 112             m = m->next;
 113         }
 114         if (h && m && m->next == h) {
 115             m->next = h->next;
 116         } else {
 117             return false;
 118         }
 119     }
 120     num_handles--;
 121     return true;
 122 }
 123
 124 /* Return a pointer to the memory handle of given ID.
 125    NULL if the handle wasn't found */
 126 static struct memory_handle *find_handle(int handle_id)
 127 {
 128     static int last_handle_id = -1;
 129     static struct memory_handle *last_m = NULL;
 130     struct memory_handle *m = first_handle;
 131     /* simple cacheing because most of the time the requested handle
 132        will either be the same as the last, or the one after the last */
 133     if (last_m)
 134     {
 135         if (last_handle_id == handle_id)
 136             return last_m;
 137         else if (last_m->next && (last_m->next->id == handle_id))
 138         {
 139             last_m = last_m->next;
 140             last_handle_id = handle_id;
 141             return last_m;
 142         }
 143     }
 144     while (m && m->id != handle_id) {
 145         m = m->next;
 146     }
 147     last_handle_id = handle_id;
 148     last_m = m;
 149     return (m->id == handle_id) ? m : NULL;
 150 }
 151
 152 /* Buffer data for the given handle. Return the amount of data buffered
 153    or -1 if the handle wasn't found */
 154 static int buffer_handle(int handle_id)
 155 {
 156     struct memory_handle *h = find_handle(handle_id);
 157     //printf("find_handle %d:\nid: %d\npath: %s\n\n", handle_id, h->id, h->path);
 158     if (!h)
 159         return -1;
 160
 161     if (h->filerem == 0) {
 162         /* nothing left to buffer */
 163         return 0;
 164     }
 165
 166     if (h->fd < 0)  /* file closed, reopen */
 167     {
 168         if (*h->path)
 169             h->fd = open(h->path, O_RDONLY);
 170         else
 171             return -1;
 172
 173         if (h->fd < 0)
 174             return -1;
 175
 176         if (h->offset)
 177             lseek(h->fd, h->offset, SEEK_SET);
 178     }
 179
 180     int ret = 0;
 181     while (h->filerem > 0)
 182     {
 183         /* max amount to copy */
 184         size_t copy_n = MIN(conf_filechunk, buffer_len - buf_widx);
 185
 186         if (RINGBUF_ADD_CROSS(buf_widx, copy_n, buf_ridx) >= 0)
 187             break;
 188
 189         /* rc is the actual amount read */
 190         int rc = read(h->fd, &buffer[buf_widx], copy_n);
 191
 192         if (rc < 0)
 193         {
 194             printf("File ended %ldB early", h->filerem);
 195             h->filesize -= h->filerem;
 196             h->filerem = 0;
 197             break;
 198         }
 199
 200         /* Advance buffer */
 201         buf_widx = RINGBUF_ADD(buf_widx, rc);
 202         h->available += rc;
 203         ret += rc;
 204         h->filerem -= rc;
 205     }
 206
 207     if (h->filerem == 0) {
 208         /* finished buffering the file */
 209         close(h->fd);
 210     }
 211
 212     printf("buffered %d bytes (%d of %d available, remaining: %d)\n",
 213            ret, h->available, h->filesize, h->filerem);
 214     return ret;
 215 }
 216
 217 /* Request a file be buffered
 218     filename: name of the file t open
 219     offset:   starting offset to buffer from the file
 220     RETURNS:  <0 if the file cannot be opened, or one file already
 221                 queued to be opened, otherwise the handle for the file in the buffer
 222 */
 223 int bufopen(char *file, size_t offset)
 224 {
 225     /* add the file to the buffering queue. */
 226     /* for now, we'll assume the queue is always empty, so the handle
 227        gets added immediately */
 228
 229     printf("bufopen: %s (offset: %d)\n", file, offset);
 230
 231     int fd = open(file, O_RDONLY);
 232     if (fd < 0)
 233         return -1;
 234
 235     if (offset)
 236         lseek(fd, offset, SEEK_SET);
 237
 238     struct memory_handle *h = add_handle();
 239     strncpy(h->path, file, MAX_PATH);
 240     h->fd = fd;
 241     h->filesize = filesize(fd);
 242     h->filerem = h->filesize - offset;
 243     h->offset = offset;
 244     h->buf_idx = buf_widx;
 245     h->data = buf_widx;
 246     h->available = 0;
 247
 248     printf("added handle : %d\n", h->id);
 249     return h->id;
 250 }
 251
 252 /* Close the handle. Return 0 for success and < 0 for failure */
 253 int bufclose(int handle_id)
 254 {
 255     printf("bufclose: %d\n", handle_id);
 256     struct memory_handle *h = find_handle(handle_id);
 257     if (!h)
 258         return -1;
 259
 260     /* when we close the first handle, we can reclaim the space from its buffer */
 261     if (h == first_handle) {
 262         buf_ridx = h->buf_idx + h->available;
 263         /* is this right in all cases ? */
 264     }
 265
 266     return rm_handle(h) ? 0 : -1;
 267 }
 268
 269 /* Seek in a handle. Return 0 for success and < 0 for failure */
 270 int bufseek(int handle_id, size_t offset)
 271 {
 272     struct memory_handle *h = find_handle(handle_id);
 273     if (!h)
 274         return -1;
 275
 276     h->buf_idx = RINGBUF_ADD(h->data, offset);
 277     return 0;
 278 }
 279
 280 static void list_handles(void)
 281 {
 282     struct memory_handle *m = first_handle;
 283     while (m) {
 284         printf("%02d - %d\n", m->id, (void *)m-(void *)buffer);
 285         m = m->next;
 286     }
 287 }
 288
 289 void buffer_init(void)
 290 {
 291     buffer = (char *)malloc(sizeof(char) * (BUFFER_SIZE + GUARD_SIZE));
 292     if (!buffer)
 293     {
 294         printf("couldn't allocate buffer\n");
 295         exit(1);
 296     }
 297     buffer_len = BUFFER_SIZE;
 298     buffer_end = buffer + BUFFER_SIZE;
 299
 300     buf_widx = 0;
 301     buf_ridx = 0;
 302
 303     first_handle = NULL;
 304     first_handle = NULL;
 305     num_handles = 0;
 306
 307     conf_filechunk = AUDIO_DEFAULT_FILECHUNK;
 308 }
 309
 310 int main(int argc, char **argv)
 311 {
 312     buffer_init();
 313
 314     printf("sizeof memory_handle : %d\n", sizeof(struct memory_handle));
 315     printf("\n");
 316
 317     int i, hdl;
 318     for (i = 1; i < argc; i++) {
 319         hdl = bufopen(argv[i], 0);
 320         buffer_handle(hdl);
 321         printf("used: %d, free: %d\n", BUF_USED, BUFFER_SIZE - BUF_USED);
 322         printf("buf_widx: %d\n", buf_widx);
 323         printf("----\n");
 324     }
 325
 326     printf("\n");
 327     bufclose(0);
 328     printf("used: %d, free: %d\n", BUF_USED, BUFFER_SIZE - BUF_USED);
 329     printf("buf_widx: %d\n", buf_widx);
 330     printf("\n");
 331     bufclose(1);
 332     printf("used: %d, free: %d\n", BUF_USED, BUFFER_SIZE - BUF_USED);
 333     printf("buf_widx: %d\n", buf_widx);
 334     printf("\n");
 335
 336     buffer_handle(2);
 337     printf("used: %d, free: %d\n", BUF_USED, BUFFER_SIZE - BUF_USED);
 338     printf("buf_widx: %d\n", buf_widx);
 339
 340     return 0;
 341 }