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 to newpos.
 219    Return a pointer to the new location of the handle */
 220 static struct memory_handle *move_handle(size_t *delta, struct memory_handle *h)
 221 {
 222     if (*delta < 4) {
 223         /* aligning backwards would yield a negative result,
 224            and moving the handle of such a small amount is a waste
 225            of time anyway. */
 226         return NULL;
 227     }
 228     /* make sure delta is 32-bit aligned so that the handle struct is. */
 229     *delta = (*delta - 3) & ~3;
 230
 231     size_t newpos = RINGBUF_ADD((void *)h - (void *)buffer, *delta);
 232
 233     struct memory_handle *dest = (struct memory_handle *)(&buffer[newpos]);
 234
 235     /* Invalidate the cache to prevent it from keeping the old location of h */
 236     if (h == cached_handle)
 237         cached_handle = NULL;
 238
 239     /* the cur_handle pointer might need updating */
 240     if (h == cur_handle) {
 241         cur_handle = dest;
 242     }
 243
 244     if (h == first_handle) {
 245         first_handle = dest;
 246         buf_ridx = newpos;
 247     } else {
 248         struct memory_handle *m = first_handle;
 249         while (m && m->next != h) {
 250             m = m->next;
 251         }
 252         if (h && m && m->next == h) {
 253             m->next = dest;
 254         } else {
 255             return NULL;
 256         }
 257     }
 258
 259     rb->memmove(dest, h, sizeof(struct memory_handle));
 260
 261     return dest;
 262 }
 263
 264 /* Buffer data for the given handle. Return the amount of data buffered
 265    or -1 if the handle wasn't found */
 266 static ssize_t buffer_handle(int handle_id)
 267 {
 268     DEBUGF("buffer_handle(%d)\n", handle_id);
 269     struct memory_handle *h = find_handle(handle_id);
 270     if (!h)
 271         return -1;
 272
 273     if (h->filerem == 0) {
 274         /* nothing left to buffer */
 275         return 0;
 276     }
 277
 278     if (h->fd < 0)  /* file closed, reopen */
 279     {
 280         if (*h->path)
 281             h->fd = rb->open(h->path, O_RDONLY);
 282         else
 283             return -1;
 284
 285         if (h->fd < 0)
 286             return -1;
 287
 288         if (h->offset)
 289             rb->lseek(h->fd, h->offset, SEEK_SET);
 290     }
 291
 292     ssize_t ret = 0;
 293     while (h->filerem > 0)
 294     {
 295         /* max amount to copy */
 296         size_t copy_n = MIN(conf_filechunk, buffer_len - h->widx);
 297
 298         /* stop copying if it would overwrite the reading position
 299            or the next handle */
 300         if (RINGBUF_ADD_CROSS(h->widx, copy_n, buf_ridx) >= 0 || (h->next &&
 301             RINGBUF_ADD_CROSS(h->widx, copy_n,
 302                               ((void *)h->next - (void *)buffer)) >= 0))
 303             break;
 304
 305         /* rc is the actual amount read */
 306         int rc = rb->read(h->fd, &buffer[h->widx], copy_n);
 307
 308         if (rc < 0)
 309         {
 310             DEBUGF("File ended %ld bytes early\n", (long)h->filerem);
 311             h->filesize -= h->filerem;
 312             h->filerem = 0;
 313             break;
 314         }
 315
 316         /* Advance buffer */
 317         h->widx = RINGBUF_ADD(h->widx, rc);
 318         if (h == cur_handle)
 319             buf_widx = h->widx;
 320         h->available += rc;
 321         ret += rc;
 322         h->filerem -= rc;
 323     }
 324
 325     if (h->filerem == 0) {
 326         /* finished buffering the file */
 327         rb->close(h->fd);
 328     }
 329
 330     DEBUGF("buffered %ld bytes (%ld of %ld available, remaining: %ld)\n",
 331            ret, h->available, h->filesize, h->filerem);
 332
 333     graph_view(100);
 334
 335     return ret;
 336 }
 337
 338 /* Free buffer space by moving the handle struct right before the useful
 339    part of its data buffer */
 340 static void free_buffer(int handle_id)
 341 {
 342     DEBUGF("free_buffer(%d)\n", handle_id);
 343     struct memory_handle *h = find_handle(handle_id);
 344     if (!h)
 345         return;
 346
 347     size_t delta = RINGBUF_SUB(h->ridx, h->data);
 348     h = move_handle(&delta, h);
 349     if (!h) return;
 350     /* The value of delta might change for alignment reasons */
 351     h->data = RINGBUF_ADD(h->data, delta);
 352     h->available -= delta;
 353
 354     graph_view(100);
 355 }
 356
 357 static void fill_buffer(void)
 358 {
 359     DEBUGF("fill buffer()\n");
 360     struct memory_handle *m = first_handle;
 361     while (m) {
 362         if (m->filerem > 0) {
 363             buffer_handle(m->id);
 364             return;
 365         }
 366         m = m->next;
 367     }
 368 }
 369
 370 static size_t data_rem(void)
 371 {
 372     size_t ret = 0;
 373
 374     struct memory_handle *m = first_handle;
 375     while (m) {
 376         ret += m->filerem;
 377         m = m->next;
 378     }
 379
 380     return ret;
 381 }
 382
 383 static size_t wasted_space(void)
 384 {
 385     size_t ret = 0;
 386
 387     struct memory_handle *m = first_handle;
 388     while (m) {
 389         ret += RINGBUF_SUB(m->ridx, m->data);
 390         m = m->next;
 391     }
 392
 393     return ret;
 394 }
 395
 396 /* Request a file be buffered
 397    filename: name of the file to open
 398    offset:starting offset to buffer from the file
 399    return value: <0 if the file cannot be opened, or one file already
 400    queued to be opened, otherwise the handle for the file in the buffer
 401 */
 402 int bufopen(char *file, size_t offset)
 403 {
 404     if (cur_handle && cur_handle->filerem > 0) {
 405         return -1;
 406     }
 407
 408     int fd = rb->open(file, O_RDONLY);
 409     if (fd < 0)
 410         return -1;
 411
 412     size_t size = rb->filesize(fd) - offset;
 413
 414     DEBUGF("bufopen: %s (offset: %ld) (%ld bytes needed)...\n",
 415            file, offset, size);
 416
 417     struct memory_handle *h = add_handle(&size);
 418     if (!h)
 419     {
 420         DEBUGF("failed to add handle\n");
 421         rb->close(fd);
 422         return -1;
 423     }
 424
 425     if (offset) rb->lseek(fd, offset, SEEK_SET);
 426     rb->strncpy(h->path, file, MAX_PATH);
 427     h->fd = fd;
 428     h->filesize = rb->filesize(fd);
 429     h->filerem = h->filesize - offset;
 430     h->offset = offset;
 431     h->ridx = buf_widx;
 432     h->widx = buf_widx;
 433     h->data = buf_widx;
 434     h->available = 0;
 435
 436     DEBUGF("allocated %ld bytes. ID: %d\n", size, h->id);
 437     return h->id;
 438 }
 439
 440 /* Close the handle. Return 0 for success and < 0 for failure */
 441 int bufclose(int handle_id)
 442 {
 443     DEBUGF("bufclose(%d)\n", handle_id);
 444     struct memory_handle *h = find_handle(handle_id);
 445     if (!h)
 446         return -1;
 447
 448     rm_handle(h);
 449     return 0;
 450 }
 451
 452 /* Set reading index in handle (relatively to the start of the handle data).
 453    Return 0 for success and < 0 for failure */
 454 int bufseek(int handle_id, size_t offset)
 455 {
 456     struct memory_handle *h = find_handle(handle_id);
 457     if (!h)
 458         return -1;
 459
 460     if (offset > h->available)
 461         return -2;
 462
 463     h->ridx = RINGBUF_ADD(h->data, offset);
 464     return 0;
 465 }
 466
 467 /* Advance the reading index in a handle (relatively to its current position).
 468    Return 0 for success and < 0 for failure */
 469 int bufadvance(int handle_id, off_t offset)
 470 {
 471     struct memory_handle *h = find_handle(handle_id);
 472     if (!h)
 473         return -1;
 474
 475     if (offset >= 0)
 476     {
 477         /* check for access beyond what's available */
 478         if ((size_t)offset > (h->available - RINGBUF_SUB(h->ridx, h->data)))
 479             return -2;
 480
 481         h->ridx = RINGBUF_ADD(h->ridx, offset);
 482     }
 483     else
 484     {
 485         /* check for access before what's available */
 486         if ((size_t)(-offset) > RINGBUF_SUB(h->ridx, h->data))
 487             return -2;
 488
 489         h->ridx = RINGBUF_SUB(h->ridx, (size_t)(-offset));
 490     }
 491
 492     return 0;
 493 }
 494
 495 /* Copy data from the given handle to the dest buffer.
 496    Return the number of bytes copied or < 0 for failure. */
 497 ssize_t bufread(int handle_id, size_t size, char *dest)
 498 {
 499     struct memory_handle *h = find_handle(handle_id);
 500     size_t buffered_data;
 501     if (!h)
 502         return -1;
 503
 504     if (h->available == 0 && h->filerem > 0)
 505         return -2;
 506
 507     if (h->available == 0 && h->filerem == 0)
 508         return 0;
 509
 510     buffered_data = MIN(size, h->available);
 511
 512     if (h->ridx + buffered_data > buffer_len)
 513     {
 514         size_t read = buffer_len - h->ridx;
 515         rb->memcpy(dest, &buffer[h->ridx], read);
 516         rb->memcpy(dest+read, buffer, buffered_data - read);
 517     }
 518     else rb->memcpy(dest, &buffer[h->ridx], buffered_data);
 519
 520     h->ridx = RINGBUF_ADD(h->ridx, buffered_data);
 521     h->available -= buffered_data;
 522     return buffered_data;
 523 }
 524
 525 /* Update the "data" pointer to make the handle's data available to the caller.
 526    Return the length of the available linear data or < 0 for failure. */
 527 ssize_t bufgetdata(int handle_id, size_t size, unsigned char **data)
 528 {
 529     struct memory_handle *h = find_handle(handle_id);
 530     if (!h)
 531         return -1;
 532
 533     if (h->available == 0 && h->filerem > 0)
 534         return -2;
 535
 536     if (h->available == 0 && h->filerem == 0)
 537         return 0;
 538
 539     ssize_t ret;
 540
 541     if (h->ridx + size > buffer_len &&
 542         h->available - RINGBUF_SUB(h->ridx, h->data) >= size)
 543     {
 544         /* use the guard buffer to provide what was requested. */
 545         size_t copy_n = h->ridx + size - buffer_len;
 546         rb->memcpy(guard_buffer, (unsigned char *)buffer, copy_n);
 547         ret = size;
 548         DEBUGF("used the guard buffer to complete\n");
 549     }
 550     else
 551     {
 552         ret = MIN(h->available - RINGBUF_SUB(h->ridx, h->data),
 553                   buffer_len - h->ridx);
 554     }
 555
 556     *data = (unsigned char *)&buffer[h->ridx];
 557
 558     /* DEBUGF("bufgetdata(%d): h->ridx=%ld, ret=%ld\n", handle_id,
 559            (long)h->ridx, ret); */
 560     return ret;
 561 }
 562
 563 bool test_ll(void)
 564 {
 565     struct memory_handle *m1, *m2, *m3, *m4;
 566
 567     if (cur_handle != NULL || first_handle != NULL)
 568         return false;
 569
 570     m1 = add_handle(NULL);
 571
 572     if (cur_handle != m1 || first_handle != m1 || m1->next != NULL)
 573         return false;
 574
 575     m2 = add_handle(NULL);
 576
 577     if (cur_handle != m2 || first_handle != m1 || m1->next != m2 || m2->next != NULL)
 578         return false;
 579
 580     m3 = add_handle(NULL);
 581
 582     if (cur_handle != m3 || first_handle != m1 || m2->next != m3 || m3->next != NULL)
 583         return false;
 584
 585     rm_handle(m2);
 586
 587     if (cur_handle != m3 || first_handle != m1 || m1->next != m3)
 588         return false;
 589
 590     rm_handle(m3);
 591
 592     if (cur_handle != m1 || first_handle != m1 || m1->next != NULL)
 593         return false;
 594
 595     m4 = add_handle(NULL);
 596
 597     if (cur_handle != m4 || first_handle != m1 || m1->next != m4 || m4->next != NULL)
 598         return false;
 599
 600     rm_handle(m1);
 601
 602     if (cur_handle != m4 || first_handle != m4)
 603         return false;
 604
 605     rm_handle(m4);
 606
 607     if (cur_handle != NULL || first_handle != NULL)
 608         return false;
 609
 610     m1 = add_handle(NULL);
 611     m2 = add_handle(NULL);
 612     m3 = add_handle(NULL);
 613     m4 = add_handle(NULL);
 614
 615     if (cur_handle != m4 || first_handle != m1)
 616         return false;
 617
 618     size_t delta = 1024*100;
 619     m2 = move_handle(&delta, m2);
 620
 621     if (cur_handle != m4 || first_handle != m1 || m1->next != m2 || m2->next != m3)
 622         return false;
 623
 624     delta = 1024*100*3;
 625     m1 = move_handle(&delta, m1);
 626
 627     if (cur_handle != m4 || first_handle != m1 || m1->next != m2)
 628         return false;
 629
 630     rm_handle(m1);
 631     rm_handle(m2);
 632     rm_handle(m3);
 633     rm_handle(m4);
 634
 635     if (cur_handle != NULL || first_handle != NULL)
 636         return false;
 637
 638     return true;
 639 }
 640
 641 /* display a nice graphical view of the ringbuffer. */
 642 static void graph_view(int width)
 643 {
 644 #ifndef ROCKBOX_HAS_LOGF
 645     int i, r_pos, w_pos;
 646     r_pos = buf_ridx * width / buffer_len;
 647     w_pos = buf_widx * width / buffer_len;
 648
 649     DEBUGF("|");
 650     for (i=0; i <= width; i++)
 651     {
 652         if (i != r_pos && i != w_pos)
 653         {
 654             if (buf_ridx <= buf_widx)
 655             {
 656                 if (i > r_pos && i < w_pos) {
 657                     DEBUGF(">");
 658                 } else {
 659                     DEBUGF("-");
 660                 }
 661             }
 662             else
 663             {
 664                 if (i > r_pos || i < w_pos) {
 665                     DEBUGF(">");
 666                 } else {
 667                     DEBUGF("-");
 668                 }
 669             }
 670         }
 671         else
 672         {
 673             if (i == r_pos && i == w_pos)
 674             {
 675                 if (buf_ridx <= buf_widx) {
 676                     DEBUGF("RW");
 677                 } else {
 678                     DEBUGF("WR");
 679                 }
 680             } else if (i == r_pos) {
 681                 DEBUGF("R");
 682             } else if (i == w_pos) {
 683                 DEBUGF("W");
 684             }
 685         }
 686     }
 687     DEBUGF("|");
 688     DEBUGF("\n");
 689 #else
 690     (void)width;
 691 #endif
 692 }
 693
 694 void print_progress(size_t amount, int file, int numfiles)
 695 {
 696     char buf[32];
 697     rb->lcd_clear_display();
 698     rb->snprintf(buf, sizeof(buf), "file %d of %d", file, numfiles);
 699     rb->lcd_puts(0, 0, buf);
 700     rb->snprintf(buf, sizeof(buf), "read: %ld", amount);
 701     rb->lcd_puts(0, 1, buf);
 702     rb->lcd_update();
 703 }
 704
 705 bool buffer_init(void)
 706 {
 707     buffer = rb->plugin_get_audio_buffer(&buffer_len);
 708     if (!buffer)
 709     {
 710         DEBUGF("couldn't allocate buffer\n");
 711         return false;
 712     }
 713     buffer_len -= GUARD_SIZE;
 714     guard_buffer = buffer + buffer_len;
 715
 716     buf_widx = 0;
 717     buf_ridx = 0;
 718
 719     first_handle = NULL;
 720     num_handles = 0;
 721
 722     conf_filechunk = AUDIO_DEFAULT_FILECHUNK;
 723
 724     return true;
 725 }
 726
 727 bool disk_is_spinning(void)
 728 {
 729     return true;
 730 }
 731
 732
 733
 734 static long codec_stack[4*DEFAULT_STACK_SIZE/sizeof(long)];
 735 static struct thread_entry* codecthread_id;
 736
 737 static long bufopen_stack[DEFAULT_STACK_SIZE/sizeof(long)];
 738 static struct thread_entry* bufopenthread_id;
 739
 740 bool done_playing = false;
 741
 742 #define MAX_HANDLES 16
 743
 744 int handles[MAX_HANDLES];
 745
 746 void codec_thread(void)
 747 {
 748     int idx = 0;
 749     int fd = -1; /* used to write the files out as they are read */
 750     unsigned char *data;
 751     char outfile[MAX_PATH];
 752     long read, total = 0;
 753
 754     while (1)
 755     {
 756         if (!done_playing)
 757         {
 758             if (handles[idx] > 0) {
 759
 760                 if (fd < 0) {
 761                     rb->snprintf(outfile, MAX_PATH, "/file%d.mp3", idx);
 762                     fd = rb->open(outfile, O_CREAT|O_TRUNC|O_WRONLY);
 763                     if (fd < 0) {
 764                         DEBUGF("couldn't create file\n");
 765                         rb->splash(HZ, "couldn't create file");
 766                     }
 767                 }
 768
 769                 do {
 770                     read = bufgetdata(handles[idx], GUARD_SIZE, &data);
 771                     if (read >= 0) {
 772                         read = MIN(read, GUARD_SIZE);
 773                         rb->write(fd, data, read);
 774                         total += read;
 775                         bufadvance(handles[idx], read);
 776                         print_progress(total, idx+1, num_files);
 777                     }
 778                     rb->sleep(HZ/20);
 779                 } while (read > 0);
 780
 781                 if (read >= 0 && total >= 0) {
 782                     DEBUGF("read %ld bytes from handle %d\n", total,
 783                            handles[idx]);
 784                 }
 785
 786                 if (read == -2) {
 787                     DEBUGF("data for handle %d isn't ready\n", handles[idx]);
 788                 } else if (read == -1) {
 789                     DEBUGF("couldn't find handle %d\n", handles[idx]);
 790                 } else if (read == 0) {
 791                     DEBUGF("finished reading handle %d\n", handles[idx]);
 792                     bufclose(handles[idx]);
 793                     rb->close(fd);
 794                     fd = -1;
 795                     total = 0;
 796                     idx++;
 797
 798                     if (idx >= num_files) {
 799                         done_playing = true;
 800                         break;
 801                     }
 802                 }
 803             }
 804         }
 805
 806         rb->sleep(HZ/4);
 807     }
 808
 809     DEBUGF("removing the codec thread\n");
 810     rb->remove_thread(NULL);
 811 }
 812
 813 void bufopen_thread(void)
 814 {
 815     int idx = 0, ret;
 816     while (idx < num_files)
 817     {
 818         ret = bufopen(files[idx], 0);
 819         if (ret > 0) {
 820             handles[idx++] = ret;
 821         }
 822         rb->sleep(HZ*8);
 823     }
 824
 825     DEBUGF("bufopen thread finished\n");
 826     rb->remove_thread(NULL);
 827 }
 828
 829
 830 /* this is the plugin entry point */
 831 enum plugin_status plugin_start(struct plugin_api* api, void* parameter)
 832 {
 833     (void)parameter;
 834     rb = api;
 835
 836     buffer_init();
 837
 838     if (!test_ll())
 839     {
 840         DEBUGF("linked list test failed\n");
 841         rb->splash(HZ, "linked list test failed");
 842         return PLUGIN_ERROR;
 843     }
 844
 845     codecthread_id = rb->create_thread(codec_thread,
 846                                        codec_stack,
 847                                        sizeof(codec_stack),
 848                                        "codec"
 849                                        IF_PRIO(,PRIORITY_PLAYBACK)
 850                                        IF_COP(, CPU, false));
 851
 852     bufopenthread_id = rb->create_thread(bufopen_thread,
 853                                          bufopen_stack,
 854                                          sizeof(bufopen_stack),
 855                                          "bufopen"
 856                                          IF_PRIO(,PRIORITY_BACKGROUND)
 857                                          IF_COP(, CPU, false));
 858
 859     if (!codecthread_id)
 860     {
 861         rb->splash(HZ, "failed to create codec thread");
 862         return PLUGIN_ERROR;
 863     }
 864     else if (!bufopenthread_id)
 865     {
 866         rb->splash(HZ, "failed to create bufopen thread");
 867         return PLUGIN_ERROR;
 868     }
 869     else
 870     {
 871
 872         while (!done_playing)
 873         {
 874             if (wasted_space() > buffer_len/4) {
 875                 DEBUGF("there is %ld bytes of wasted space\n", wasted_space());
 876                 struct memory_handle *m = first_handle;
 877                 while (m) {
 878                     free_buffer(m->id);
 879                     m = m->next;
 880                 }
 881             }
 882
 883             if (data_rem() > 0 && BUF_USED < buffer_len/4 &&
 884                 disk_is_spinning())
 885             {
 886                 DEBUGF("%ld bytes left to buffer and the buffer is low\n",
 887                        data_rem());
 888                 fill_buffer();
 889             } else {
 890                 rb->sleep(HZ/2);
 891             }
 892         }
 893         DEBUGF("done playing\n");
 894         rb->yield();
 895     }
 896
 897     rb->backlight_on();
 898     DEBUGF("end of plugin\n");
 899     return PLUGIN_OK;
 900 }