testplugin.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
  21 #include "plugin.h"
  22
  23 PLUGIN_HEADER
  24
  25 struct plugin_api* rb;
  26
  27 #define GUARD_SIZE   (32*1024)
  28
  29 /* amount of data to read in one read() call */
  30 #define AUDIO_DEFAULT_FILECHUNK      (1024*32)
  31
  32 /* Ring buffer helper macros */
  33 /* Buffer pointer (p) plus value (v), wrapped if necessary */
  34 #define RINGBUF_ADD(p,v) ((p+v)<buffer_len ? p+v : p+v-buffer_len)
  35 /* Buffer pointer (p) minus value (v), wrapped if necessary */
  36 #define RINGBUF_SUB(p,v) ((p>=v) ? p-v : p+buffer_len-v)
  37 /* How far value (v) plus buffer pointer (p1) will cross buffer pointer (p2) */
  38 #define RINGBUF_ADD_CROSS(p1,v,p2) \
  39 ((p1<p2) ? (int)(p1+v)-(int)p2 : (int)(p1+v-p2)-(int)buffer_len)
  40 /* Bytes available in the buffer */
  41 #define BUF_USED RINGBUF_SUB(buf_widx, buf_ridx)
  42
  43 #ifdef ROCKBOX_HAS_LOGF
  44 #define DEBUGF rb->logf
  45 #endif
  46
  47 int num_files = 5;
  48 char *files[] = {
  49         "/a.mp3",
  50         "/b.mp3",
  51         "/c.mp3",
  52         "/d.mp3",
  53         "/e.mp3" };
  54
  55 enum data_type {
  56     TYPE_CODEC,
  57     TYPE_AUDIO,
  58     TYPE_ID3,
  59     TYPE_CUESHEET,
  60     TYPE_IMAGE,
  61     TYPE_BUFFER,
  62     TYPE_UNKNOWN,
  63 };
  64
  65 struct memory_handle {
  66     int id;              /* A unique ID for the handle */
  67     enum data_type type;
  68     char path[MAX_PATH];
  69     int fd;
  70     size_t data;         /* Start index of the handle's data buffer */
  71     size_t ridx;         /* Current read pointer, relative to the main buffer */
  72     size_t widx;         /* Current write pointer */
  73     size_t filesize;     /* File total length */
  74     size_t filerem;      /* Remaining bytes of file NOT in buffer */
  75     size_t available;    /* Available bytes to read from buffer */
  76     size_t offset;       /* Offset at which we started reading the file */
  77     struct memory_handle *next;
  78 };
  79
  80
  81 static char *buffer;
  82 static char *guard_buffer;
  83
  84 static size_t buffer_len;
  85 static size_t buf_widx;
  86 static size_t buf_ridx;
  87
  88 static size_t conf_filechunk;
  89
  90 /* current memory handle in the linked list. NULL when the list is empty. */
  91 static struct memory_handle *cur_handle;
  92 /* first memory handle in the linked list. NULL when the list is empty. */
  93 static struct memory_handle *first_handle;
  94 static int num_handles;
  95
  96 static void graph_view(int width);
  97
  98
  99 /* add a new handle to the linked list and return it. It will have become the
 100    new current handle. The handle will reserve "data_size" bytes or if that's
 101    not possible, decrease "data_size" to allow adding the handle. */
 102 static struct memory_handle *add_handle(size_t *data_size)
 103 {
 104     /* this will give each handle a unique id */
 105     static int cur_handle_id = 1;
 106
 107     /* make sure buf_widx is 32-bit aligned so that the handle struct is,
 108        but before that we check we can actually align. */
 109     if (RINGBUF_ADD_CROSS(buf_widx, 3, buf_ridx) >= 0) {
 110         return NULL;
 111     }
 112     buf_widx = (RINGBUF_ADD(buf_widx, 3)) & ~3;
 113
 114     size_t len = (data_size ? *data_size : 0)
 115         + sizeof(struct memory_handle);
 116
 117     /* check that we actually can add the handle and its data */
 118     int overlap = RINGBUF_ADD_CROSS(buf_widx, len, buf_ridx);
 119     if (overlap >= 0) {
 120         *data_size -= overlap;
 121         len -= overlap;
 122     }
 123     if (len < sizeof(struct memory_handle)) {
 124         return NULL;
 125     }
 126
 127     struct memory_handle *new_handle =
 128         (struct memory_handle *)(&buffer[buf_widx]);
 129
 130     /* only advance the buffer write index of the size of the struct */
 131     buf_widx = RINGBUF_ADD(buf_widx, sizeof(struct memory_handle));
 132
 133     if (!first_handle) {
 134         /* the new handle is the first one */
 135         first_handle = new_handle;
 136     }
 137
 138     if (cur_handle) {
 139         cur_handle->next = new_handle;
 140     }
 141
 142     cur_handle = new_handle;
 143     cur_handle->id = cur_handle_id++;
 144     cur_handle->next = NULL;
 145     num_handles++;
 146     return cur_handle;
 147 }
 148
 149 /* delete a given memory handle from the linked list
 150    and return true for success. Nothing is actually erased from memory. */
 151 static bool rm_handle(struct memory_handle *h)
 152 {
 153     if (h == first_handle) {
 154         first_handle = h->next;
 155         if (h == cur_handle) {
 156             DEBUGF("removing the first and last handle\n");
 157             /* h was the first and last handle */
 158             cur_handle = NULL;
 159             buf_ridx = buf_widx;
 160         } else {
 161             buf_ridx = (void *)first_handle - (void *)buffer;
 162         }
 163     } else {
 164         struct memory_handle *m = first_handle;
 165         while (m && m->next != h) {
 166             m = m->next;
 167         }
 168         if (h && m && m->next == h) {
 169             m->next = h->next;
 170             if (h == cur_handle) {
 171                 cur_handle = m;
 172             }
 173         } else {
 174             return false;
 175         }
 176     }
 177
 178     num_handles--;
 179     return true;
 180 }
 181
 182 /* these are unfortunalty needed to be global
 183     so move_handle can invalidate them */
 184 static int cached_handle_id = -1;
 185 static struct memory_handle *cached_handle = NULL;
 186
 187 /* Return a pointer to the memory handle of given ID.
 188    NULL if the handle wasn't found */
 189 static struct memory_handle *find_handle(int handle_id)
 190 {
 191     /* simple caching because most of the time the requested handle
 192     will either be the same as the last, or the one after the last */
 193     if (cached_handle)
 194     {
 195         if (cached_handle_id == handle_id &&
 196             cached_handle_id == cached_handle->id)
 197             return cached_handle;
 198         else if (cached_handle->next && (cached_handle->next->id == handle_id))
 199         {
 200             /* JD's quick testing showd this block was only entered
 201                2/1971 calls to find_handle.
 202                8/1971 calls to find_handle resulted in a cache miss */
 203             cached_handle = cached_handle->next;
 204             cached_handle_id = handle_id;
 205             return cached_handle;
 206         }
 207     }
 208
 209     struct memory_handle *m = first_handle;
 210     while (m && m->id != handle_id) {
 211         m = m->next;
 212     }
 213     cached_handle_id = handle_id;
 214     cached_handle = m;
 215     return (m && m->id == handle_id) ? m : NULL;
 216 }
 217
 218 /* Move a memory handle and data_size of its data of delta.
 219    Return a pointer to the new location of the handle.
 220    delta is the value of which to move the struct data.
 221    data_size is the amount of data to move along with the struct. */
 222 static struct memory_handle *move_handle(struct memory_handle *h,
 223                                          size_t *delta, size_t data_size)
 224 {
 225     if (*delta < 4) {
 226         /* aligning backwards would yield a negative result,
 227            and moving the handle of such a small amount is a waste
 228            of time anyway. */
 229         return NULL;
 230     }
 231     /* make sure delta is 32-bit aligned so that the handle struct is. */
 232     *delta = (*delta - 3) & ~3;
 233
 234     size_t newpos = RINGBUF_ADD((void *)h - (void *)buffer, *delta);
 235
 236     struct memory_handle *dest = (struct memory_handle *)(&buffer[newpos]);
 237
 238     /* Invalidate the cache to prevent it from keeping the old location of h */
 239     if (h == cached_handle)
 240         cached_handle = NULL;
 241
 242     /* the cur_handle pointer might need updating */
 243     if (h == cur_handle) {
 244         cur_handle = dest;
 245     }
 246
 247     if (h == first_handle) {
 248         first_handle = dest;
 249         buf_ridx = newpos;
 250     } else {
 251         struct memory_handle *m = first_handle;
 252         while (m && m->next != h) {
 253             m = m->next;
 254         }
 255         if (h && m && m->next == h) {
 256             m->next = dest;
 257         } else {
 258             return NULL;
 259         }
 260     }
 261
 262     rb->memmove(dest, h, sizeof(struct memory_handle) + data_size);
 263
 264     return dest;
 265 }
 266
 267 /* Buffer data for the given handle. Return the amount of data buffered
 268    or -1 if the handle wasn't found */
 269 static ssize_t buffer_handle(int handle_id)
 270 {
 271     DEBUGF("buffer_handle(%d)\n", handle_id);
 272     struct memory_handle *h = find_handle(handle_id);
 273     if (!h)
 274         return -1;
 275
 276     if (h->filerem == 0) {
 277         /* nothing left to buffer */
 278         return 0;
 279     }
 280
 281     if (h->fd < 0)  /* file closed, reopen */
 282     {
 283         if (*h->path)
 284             h->fd = rb->open(h->path, O_RDONLY);
 285         else
 286             return -1;
 287
 288         if (h->fd < 0)
 289             return -1;
 290
 291         if (h->offset)
 292             rb->lseek(h->fd, h->offset, SEEK_SET);
 293     }
 294
 295     ssize_t ret = 0;
 296     while (h->filerem > 0)
 297     {
 298         /* max amount to copy */
 299         size_t copy_n = MIN( MIN(h->filerem, conf_filechunk),
 300                              buffer_len - h->widx);
 301
 302         /* stop copying if it would overwrite the reading position
 303            or the next handle */
 304         if (RINGBUF_ADD_CROSS(h->widx, copy_n, buf_ridx) >= 0 || (h->next &&
 305             RINGBUF_ADD_CROSS(h->widx, copy_n, (unsigned)
 306                               ((void *)h->next - (void *)buffer)) > 0))
 307             break;
 308
 309         /* rc is the actual amount read */
 310         int rc = rb->read(h->fd, &buffer[h->widx], copy_n);
 311
 312         if (rc < 0)
 313         {
 314             DEBUGF("File ended %ld bytes early\n", (long)h->filerem);
 315             h->filesize -= h->filerem;
 316             h->filerem = 0;
 317             break;
 318         }
 319
 320         /* Advance buffer */
 321         h->widx = RINGBUF_ADD(h->widx, rc);
 322         if (h == cur_handle)
 323             buf_widx = h->widx;
 324         h->available += rc;
 325         ret += rc;
 326         h->filerem -= rc;
 327     }
 328
 329     if (h->filerem == 0) {
 330         /* finished buffering the file */
 331         rb->close(h->fd);
 332     }
 333
 334     DEBUGF("buffered %ld bytes (%ld of %ld available, remaining: %ld)\n",
 335            ret, h->available, h->filesize, h->filerem);
 336
 337     graph_view(100);
 338
 339     return ret;
 340 }
 341
 342 /* Free buffer space by moving the handle struct right before the useful
 343    part of its data buffer */
 344 static void free_buffer(int handle_id)
 345 {
 346     struct memory_handle *h = find_handle(handle_id);
 347     if (!h)
 348         return;
 349
 350     size_t delta;
 351     /* The value of delta might change for alignment reasons */
 352
 353     if (h->next && (h->type == TYPE_ID3 || h->type == TYPE_CUESHEET ||
 354                     h->type == TYPE_IMAGE) && h->filerem == 0 )
 355     {
 356         /* metadata handle: we can move all of it */
 357         delta = RINGBUF_SUB( (unsigned)((void *)h->next - (void *)buffer),
 358                              h->data) - h->available;
 359         h = move_handle(h, &delta, h->available);
 360         if (!h) return;
 361         h->data = RINGBUF_ADD(h->data, delta);
 362         h->ridx = RINGBUF_ADD(h->ridx, delta);
 363         DEBUGF("free_buffer(%d): metadata, moved by %ld bytes\n",
 364                handle_id, delta);
 365     }
 366     else
 367     {
 368         /* only move the handle struct */
 369         delta = RINGBUF_SUB(h->ridx, h->data);
 370         h = move_handle(h, &delta, 0);
 371         if (!h) return;
 372         h->data = RINGBUF_ADD(h->data, delta);
 373         h->available -= delta;
 374         DEBUGF("free_buffer(%d): audio, %ld bytes freed\n", handle_id, delta);
 375     }
 376 }
 377
 378 static void fill_buffer(void)
 379 {
 380     DEBUGF("fill buffer()\n");
 381     struct memory_handle *m = first_handle;
 382     while (m) {
 383         if (m->filerem > 0) {
 384             buffer_handle(m->id);
 385             return;
 386         }
 387         m = m->next;
 388     }
 389 }
 390
 391 static size_t data_rem(void)
 392 {
 393     size_t ret = 0;
 394
 395     struct memory_handle *m = first_handle;
 396     while (m) {
 397         ret += m->filerem;
 398         m = m->next;
 399     }
 400
 401     return ret;
 402 }
 403
 404 static size_t wasted_space(void)
 405 {
 406     size_t ret = 0;
 407
 408     struct memory_handle *m = first_handle;
 409     while (m) {
 410         ret += RINGBUF_SUB(m->ridx, m->data);
 411         m = m->next;
 412     }
 413
 414     return ret;
 415 }
 416
 417 /* Request a file be buffered
 418    filename: name of the file to open
 419    offset:starting offset to buffer from the file
 420    return value: <0 if the file cannot be opened, or one file already
 421    queued to be opened, otherwise the handle for the file in the buffer
 422 */
 423 int bufopen(char *file, size_t offset, enum data_type type)
 424 {
 425     if (cur_handle && cur_handle->filerem > 0) {
 426         /* the current handle hasn't finished buffering. We can only add
 427            a new one if there is already enough free space to finish
 428            the buffering. */
 429         if (cur_handle->filerem < (buffer_len - BUF_USED)) {
 430             /* Before adding the new handle we reserve some space for the
 431                current one to finish buffering its data. */
 432             buf_widx = RINGBUF_ADD(buf_widx, cur_handle->filerem);
 433         } else {
 434             return -1;
 435         }
 436     }
 437
 438     int fd = rb->open(file, O_RDONLY);
 439     if (fd < 0)
 440         return -1;
 441
 442     size_t size = rb->filesize(fd) - offset;
 443
 444     DEBUGF("bufopen: %s (offset: %ld) (%ld bytes needed)...\n",
 445            file, offset, size);
 446
 447     struct memory_handle *h = add_handle(&size);
 448     if (!h)
 449     {
 450         DEBUGF("failed to add handle\n");
 451         rb->close(fd);
 452         return -1;
 453     }
 454
 455     if (offset) rb->lseek(fd, offset, SEEK_SET);
 456     rb->strncpy(h->path, file, MAX_PATH);
 457     h->fd = fd;
 458     h->filesize = rb->filesize(fd);
 459     h->filerem = h->filesize - offset;
 460     h->offset = offset;
 461     h->ridx = buf_widx;
 462     h->widx = buf_widx;
 463     h->data = buf_widx;
 464     h->available = 0;
 465     h->type = type;
 466
 467     DEBUGF("allocated %ld bytes. ID: %d\n", size, h->id);
 468     return h->id;
 469 }
 470
 471 /* Close the handle. Return 0 for success and < 0 for failure */
 472 int bufclose(int handle_id)
 473 {
 474     DEBUGF("bufclose(%d)\n", handle_id);
 475     struct memory_handle *h = find_handle(handle_id);
 476     if (!h)
 477         return -1;
 478
 479     rm_handle(h);
 480     return 0;
 481 }
 482
 483 /* Set reading index in handle (relatively to the start of the handle data).
 484    Return 0 for success and < 0 for failure */
 485 int bufseek(int handle_id, size_t offset)
 486 {
 487     struct memory_handle *h = find_handle(handle_id);
 488     if (!h)
 489         return -1;
 490
 491     if (offset > h->available)
 492         return -2;
 493
 494     h->ridx = RINGBUF_ADD(h->data, offset);
 495     return 0;
 496 }
 497
 498 /* Advance the reading index in a handle (relatively to its current position).
 499    Return 0 for success and < 0 for failure */
 500 int bufadvance(int handle_id, off_t offset)
 501 {
 502     struct memory_handle *h = find_handle(handle_id);
 503     if (!h)
 504         return -1;
 505
 506     if (offset >= 0)
 507     {
 508         /* check for access beyond what's available */
 509         if ((size_t)offset > (h->available - RINGBUF_SUB(h->ridx, h->data)))
 510             return -2;
 511
 512         h->ridx = RINGBUF_ADD(h->ridx, offset);
 513     }
 514     else
 515     {
 516         /* check for access before what's available */
 517         if ((size_t)(-offset) > RINGBUF_SUB(h->ridx, h->data))
 518             return -2;
 519
 520         h->ridx = RINGBUF_SUB(h->ridx, (size_t)(-offset));
 521     }
 522
 523     return 0;
 524 }
 525
 526 /* Copy data from the given handle to the dest buffer.
 527    Return the number of bytes copied or < 0 for failure. */
 528 ssize_t bufread(int handle_id, size_t size, char *dest)
 529 {
 530     struct memory_handle *h = find_handle(handle_id);
 531     size_t buffered_data;
 532     if (!h)
 533         return -1;
 534
 535     if (h->available == 0 && h->filerem > 0)
 536         return -2;
 537
 538     if (h->available == 0 && h->filerem == 0)
 539         return 0;
 540
 541     buffered_data = MIN(size, h->available);
 542
 543     if (h->ridx + buffered_data > buffer_len)
 544     {
 545         size_t read = buffer_len - h->ridx;
 546         rb->memcpy(dest, &buffer[h->ridx], read);
 547         rb->memcpy(dest+read, buffer, buffered_data - read);
 548     }
 549     else rb->memcpy(dest, &buffer[h->ridx], buffered_data);
 550
 551     h->ridx = RINGBUF_ADD(h->ridx, buffered_data);
 552     h->available -= buffered_data;
 553     return buffered_data;
 554 }
 555
 556 /* Update the "data" pointer to make the handle's data available to the caller.
 557    Return the length of the available linear data or < 0 for failure. */
 558 ssize_t bufgetdata(int handle_id, size_t size, unsigned char **data)
 559 {
 560     struct memory_handle *h = find_handle(handle_id);
 561     if (!h)
 562         return -1;
 563
 564     if (h->available == 0 && h->filerem > 0)
 565         return -2;
 566
 567     if (h->available == 0 && h->filerem == 0)
 568         return 0;
 569
 570     ssize_t ret;
 571
 572     if (h->ridx + size > buffer_len &&
 573         h->available - RINGBUF_SUB(h->ridx, h->data) >= size)
 574     {
 575         /* use the guard buffer to provide what was requested. */
 576         size_t copy_n = h->ridx + size - buffer_len;
 577         rb->memcpy(guard_buffer, (unsigned char *)buffer, copy_n);
 578         ret = size;
 579         DEBUGF("used the guard buffer to complete\n");
 580     }
 581     else
 582     {
 583         ret = MIN(h->available - RINGBUF_SUB(h->ridx, h->data),
 584                   buffer_len - h->ridx);
 585     }
 586
 587     *data = (unsigned char *)&buffer[h->ridx];
 588
 589     /* DEBUGF("bufgetdata(%d): h->ridx=%ld, ret=%ld\n", handle_id,
 590            (long)h->ridx, ret); */
 591     return ret;
 592 }
 593
 594 bool test_ll(void)
 595 {
 596     struct memory_handle *m1, *m2, *m3, *m4;
 597
 598     if (cur_handle != NULL || first_handle != NULL)
 599         return false;
 600
 601     m1 = add_handle(NULL);
 602
 603     if (cur_handle != m1 || first_handle != m1 || m1->next != NULL)
 604         return false;
 605
 606     m2 = add_handle(NULL);
 607
 608     if (cur_handle != m2 || first_handle != m1 || m1->next != m2 || m2->next != NULL)
 609         return false;
 610
 611     m3 = add_handle(NULL);
 612
 613     if (cur_handle != m3 || first_handle != m1 || m2->next != m3 || m3->next != NULL)
 614         return false;
 615
 616     rm_handle(m2);
 617
 618     if (cur_handle != m3 || first_handle != m1 || m1->next != m3)
 619         return false;
 620
 621     rm_handle(m3);
 622
 623     if (cur_handle != m1 || first_handle != m1 || m1->next != NULL)
 624         return false;
 625
 626     m4 = add_handle(NULL);
 627
 628     if (cur_handle != m4 || first_handle != m1 || m1->next != m4 || m4->next != NULL)
 629         return false;
 630
 631     rm_handle(m1);
 632
 633     if (cur_handle != m4 || first_handle != m4)
 634         return false;
 635
 636     rm_handle(m4);
 637
 638     if (cur_handle != NULL || first_handle != NULL)
 639         return false;
 640
 641     m1 = add_handle(NULL);
 642     m2 = add_handle(NULL);
 643     m3 = add_handle(NULL);
 644     m4 = add_handle(NULL);
 645
 646     if (cur_handle != m4 || first_handle != m1)
 647         return false;
 648
 649     size_t delta = 1024*100;
 650     m2 = move_handle(m2, &delta, 0);
 651
 652     if (cur_handle != m4 || first_handle != m1 || m1->next != m2 || m2->next != m3)
 653         return false;
 654
 655     delta = 1024*100*3;
 656     m1 = move_handle(m1, &delta, 0);
 657
 658     if (cur_handle != m4 || first_handle != m1 || m1->next != m2)
 659         return false;
 660
 661     rm_handle(m1);
 662     rm_handle(m2);
 663     rm_handle(m3);
 664     rm_handle(m4);
 665
 666     if (cur_handle != NULL || first_handle != NULL)
 667         return false;
 668
 669     return true;
 670 }
 671
 672 /* display a nice graphical view of the ringbuffer. */
 673 static void graph_view(int width)
 674 {
 675 #ifndef ROCKBOX_HAS_LOGF
 676     int i, r_pos, w_pos;
 677     r_pos = buf_ridx * width / buffer_len;
 678     w_pos = buf_widx * width / buffer_len;
 679
 680     DEBUGF("|");
 681     for (i=0; i <= width; i++)
 682     {
 683         if (i != r_pos && i != w_pos)
 684         {
 685             if (buf_ridx <= buf_widx)
 686             {
 687                 if (i > r_pos && i < w_pos) {
 688                     DEBUGF(">");
 689                 } else {
 690                     DEBUGF("-");
 691                 }
 692             }
 693             else
 694             {
 695                 if (i > r_pos || i < w_pos) {
 696                     DEBUGF(">");
 697                 } else {
 698                     DEBUGF("-");
 699                 }
 700             }
 701         }
 702         else
 703         {
 704             if (i == r_pos && i == w_pos)
 705             {
 706                 if (buf_ridx <= buf_widx) {
 707                     DEBUGF("RW");
 708                 } else {
 709                     DEBUGF("WR");
 710                 }
 711             } else if (i == r_pos) {
 712                 DEBUGF("R");
 713             } else if (i == w_pos) {
 714                 DEBUGF("W");
 715             }
 716         }
 717     }
 718     DEBUGF("|");
 719     DEBUGF("\n");
 720 #else
 721     (void)width;
 722 #endif
 723 }
 724
 725 void print_progress(size_t amount, int file, int numfiles)
 726 {
 727     char buf[32];
 728     rb->snprintf(buf, sizeof(buf), "file %d of %d", file, numfiles);
 729     rb->lcd_puts(0, 0, buf);
 730     rb->snprintf(buf, sizeof(buf), "read: %ld", amount);
 731     rb->lcd_puts(0, 1, buf);
 732 }
 733
 734 void print_metadata(int handle_id)
 735 {
 736     ssize_t ret;
 737     char *artist, *title, *newline;
 738     char art[50], ttl[50];
 739     int artist_len, title_len;
 740     unsigned char *buf;
 741
 742     ret = bufgetdata(handle_id, 0, &buf);
 743
 744     artist = buf;
 745     newline = rb->strchr(artist, '\n');
 746     artist_len = newline - artist;
 747     rb->strncpy(art, artist, artist_len);
 748     art[artist_len] = 0;
 749
 750     title = newline + 1;
 751     newline = rb->strchr(title, '\n');
 752     title_len = newline - title;
 753     rb->strncpy(ttl, title, title_len);
 754     ttl[title_len] = 0;
 755
 756     rb->lcd_puts(0, 3, art);
 757     rb->lcd_puts(0, 4, ttl);
 758 }
 759
 760 bool buffer_init(void)
 761 {
 762     buffer = rb->plugin_get_audio_buffer(&buffer_len);
 763     if (!buffer)
 764     {
 765         DEBUGF("couldn't allocate buffer\n");
 766         return false;
 767     }
 768     buffer_len -= GUARD_SIZE;
 769     guard_buffer = buffer + buffer_len;
 770
 771     buf_widx = 0;
 772     buf_ridx = 0;
 773
 774     first_handle = NULL;
 775     num_handles = 0;
 776
 777     conf_filechunk = AUDIO_DEFAULT_FILECHUNK;
 778
 779     return true;
 780 }
 781
 782 bool disk_is_spinning(void)
 783 {
 784     return true;
 785 }
 786
 787
 788
 789 static long codec_stack[4*DEFAULT_STACK_SIZE/sizeof(long)];
 790 static struct thread_entry* codecthread_id;
 791
 792 static long bufopen_stack[DEFAULT_STACK_SIZE/sizeof(long)];
 793 static struct thread_entry* bufopenthread_id;
 794
 795 bool done_playing = false;
 796
 797 #define MAX_HANDLES 16
 798
 799 int handles[MAX_HANDLES];
 800 int meta_handles[MAX_HANDLES];
 801
 802 void codec_thread(void)
 803 {
 804     int idx = 0;
 805     int fd = -1; /* used to write the files out as they are read */
 806     unsigned char *data;
 807     char outfile[MAX_PATH];
 808     long read, total = 0;
 809
 810     while (1)
 811     {
 812         if (!done_playing)
 813         {
 814             if (handles[idx] > 0) {
 815
 816                 if (fd < 0) {
 817                     rb->snprintf(outfile, MAX_PATH, "/file%d.mp3", idx);
 818                     fd = rb->open(outfile, O_CREAT|O_TRUNC|O_WRONLY);
 819                     if (fd < 0) {
 820                         DEBUGF("couldn't create file\n");
 821                         rb->splash(HZ, "couldn't create file");
 822                     }
 823                 }
 824
 825                 do {
 826                     read = bufgetdata(handles[idx], GUARD_SIZE, &data);
 827                     if (read >= 0) {
 828                         read = MIN(read, GUARD_SIZE);
 829                         rb->write(fd, data, read);
 830                         total += read;
 831                         bufadvance(handles[idx], read);
 832                         rb->lcd_clear_display();
 833                         print_progress(total, idx+1, num_files);
 834                         print_metadata(meta_handles[idx]);
 835                         rb->lcd_update();
 836                     }
 837                     rb->sleep(HZ/100);
 838                 } while (read > 0);
 839
 840                 if (read >= 0 && total >= 0) {
 841                     DEBUGF("read %ld bytes from handle %d\n", total,
 842                            handles[idx]);
 843                 }
 844
 845                 if (read == -2) {
 846                     DEBUGF("data for handle %d isn't ready\n", handles[idx]);
 847                 } else if (read == -1) {
 848                     DEBUGF("couldn't find handle %d\n", handles[idx]);
 849                 } else if (read == 0) {
 850                     DEBUGF("finished reading handle %d\n", handles[idx]);
 851                     bufclose(handles[idx]);
 852                     bufclose(meta_handles[idx]);
 853                     rb->close(fd);
 854                     fd = -1;
 855                     total = 0;
 856                     idx++;
 857
 858                     if (idx >= num_files) {
 859                         done_playing = true;
 860                         break;
 861                     }
 862                 }
 863             }
 864         }
 865
 866         rb->sleep(HZ/10);
 867     }
 868
 869     DEBUGF("removing the codec thread\n");
 870     rb->remove_thread(NULL);
 871 }
 872
 873 void bufopen_thread(void)
 874 {
 875     int idx = 0, ret;
 876     char buf[MAX_PATH];
 877     while (idx < num_files)
 878     {
 879         snprintf(buf, MAX_PATH, "/meta%s.txt", files[idx]);
 880         meta_handles[idx] = bufopen(buf, 0, TYPE_ID3);
 881         if (meta_handles[idx] > 0)
 882         {
 883             ret = bufopen(files[idx], 0, TYPE_AUDIO);
 884             if (ret > 0) {
 885                 handles[idx++] = ret;
 886             } else {
 887                 bufclose(meta_handles[idx]);
 888             }
 889         }
 890         rb->sleep(HZ*2);
 891     }
 892
 893     DEBUGF("bufopen thread finished\n");
 894     rb->remove_thread(NULL);
 895 }
 896
 897
 898 /* this is the plugin entry point */
 899 enum plugin_status plugin_start(struct plugin_api* api, void* parameter)
 900 {
 901     (void)parameter;
 902     rb = api;
 903
 904     buffer_init();
 905
 906     if (!test_ll())
 907     {
 908         DEBUGF("linked list test failed\n");
 909         rb->splash(HZ, "linked list test failed");
 910         return PLUGIN_ERROR;
 911     }
 912
 913     codecthread_id = rb->create_thread(codec_thread,
 914                                        codec_stack,
 915                                        sizeof(codec_stack),
 916                                        "codec"
 917                                        IF_PRIO(,PRIORITY_PLAYBACK)
 918                                        IF_COP(, CPU, false));
 919
 920     bufopenthread_id = rb->create_thread(bufopen_thread,
 921                                          bufopen_stack,
 922                                          sizeof(bufopen_stack),
 923                                          "bufopen"
 924                                          IF_PRIO(,PRIORITY_BACKGROUND)
 925                                          IF_COP(, CPU, false));
 926
 927     if (!codecthread_id)
 928     {
 929         rb->splash(HZ, "failed to create codec thread");
 930         return PLUGIN_ERROR;
 931     }
 932     else if (!bufopenthread_id)
 933     {
 934         rb->splash(HZ, "failed to create bufopen thread");
 935         return PLUGIN_ERROR;
 936     }
 937     else
 938     {
 939
 940         while (!done_playing)
 941         {
 942             if (data_rem() > 0 && wasted_space() > buffer_len/5) {
 943                 DEBUGF("there is %ld bytes of wasted space\n", wasted_space());
 944                 struct memory_handle *m = first_handle;
 945                 while (m) {
 946                     if (m->type == TYPE_AUDIO)
 947                         free_buffer(m->id);
 948                     m = m->next;
 949                 }
 950                 m = first_handle;
 951                 while (m) {
 952                     if (m->type != TYPE_AUDIO)
 953                         free_buffer(m->id);
 954                     m = m->next;
 955                 }
 956                 graph_view(100);
 957             }
 958
 959             if (data_rem() > 0 && BUF_USED < 3*buffer_len/4 &&
 960                 disk_is_spinning())
 961             {
 962                 DEBUGF("%ld bytes left to buffer and the buffer is low\n",
 963                        data_rem());
 964                 fill_buffer();
 965             } else {
 966                 rb->sleep(HZ/2);
 967             }
 968         }
 969         DEBUGF("done playing\n");
 970         rb->yield();
 971     }
 972
 973     rb->backlight_on();
 974     DEBUGF("end of plugin\n");
 975     return PLUGIN_OK;
 976 }