apps/plugins/sort.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2002 Linus Nielsen Feltzing
  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 #include "plugin.h"
  20
  21 /****************************************************************************
  22  * Buffer handling:
  23  *
  24  * We allocate the MP3 buffer for storing the text to be sorted, and then
  25  * search the buffer for newlines and store an array of character pointers
  26  * to the strings.
  27  *
  28  * The pointer array grows from the top of the buffer and downwards:
  29  *
  30  * |-------------|
  31  * | pointers[2] |--------|
  32  * | pointers[1] |------| |
  33  * | pointers[0] |----| | |
  34  * |-------------|    | | |
  35  * |             |    | | |
  36  * |             |    | | |
  37  * | free space  |    | | |
  38  * |             |    | | |
  39  * |             |    | | |
  40  * |-------------|    | | |
  41  * |             |    | | |
  42  * | line 3\0    |<---| | |
  43  * | line 2\0    |<-----| |
  44  * | line 1\0    |<-------|
  45  * |-------------|
  46  *
  47  * The advantage of this method is that we optimize the buffer usage.
  48  *
  49  * The disadvantage is that the string pointers will be loaded in reverse
  50  * order. We therefore sort the strings in reverse order as well, so we
  51  * don't have to sort an already sorted buffer.
  52  ****************************************************************************/
  53
  54 /***************************************************************************
  55  * TODO: Implement a merge sort for files larger than the buffer
  56  ****************************************************************************/
  57
  58 PLUGIN_HEADER
  59
  60 static struct plugin_api* rb;
  61
  62 ssize_t buf_size;
  63 static char *filename;
  64 static int num_entries;
  65 static char **pointers;
  66 static char *stringbuffer;
  67 static char crlf[2] = "\r\n";
  68
  69 /* Compare function for sorting backwards */
  70 static int compare(const void* p1, const void* p2)
  71 {
  72     char *s1 = *(char **)p1;
  73     char *s2 = *(char **)p2;
  74
  75     return rb->strcasecmp(s2, s1);
  76 }
  77
  78 static void sort_buffer(void)
  79 {
  80     rb->qsort(pointers, num_entries, sizeof(char *), compare);
  81 }
  82
  83 int read_buffer(int offset)
  84 {
  85     int fd;
  86     char *buf_ptr;
  87     char *tmp_ptr;
  88     int readsize;
  89
  90     fd = rb->open(filename, O_RDONLY);
  91     if(fd < 0)
  92         return 10 * fd - 1;
  93
  94     /* Fill the buffer from the file */
  95     rb->lseek(fd, offset, SEEK_SET);
  96     readsize = rb->read(fd, stringbuffer, buf_size);
  97     rb->close(fd);
  98
  99     if(readsize < 0)
 100         return readsize * 10 - 2;
 101
 102     /* Temporary fix until we can do merged sorting */
 103     if(readsize == buf_size)
 104         return buf_size; /* File too big */
 105
 106     buf_ptr = stringbuffer;
 107     num_entries = 0;
 108
 109     do {
 110         tmp_ptr = buf_ptr;
 111         while(*buf_ptr != '\n' && buf_ptr < (char *)pointers) {
 112             /* Terminate the string with CR... */
 113             if(*buf_ptr == '\r')
 114                 *buf_ptr = 0;
 115             buf_ptr++;
 116         }
 117         /* ...and with LF */
 118         if(*buf_ptr == '\n')
 119             *buf_ptr = 0;
 120         else {
 121             return tmp_ptr - stringbuffer; /* Buffer is full, return
 122                                               the point to resume at */
 123         }
 124
 125         pointers--;
 126         *pointers = tmp_ptr;
 127         num_entries++;
 128         buf_ptr++;
 129     } while(buf_ptr < stringbuffer + readsize);
 130
 131     return 0;
 132 }
 133
 134 static int write_file(void)
 135 {
 136     char tmpfilename[MAX_PATH+1];
 137     int fd;
 138     int i;
 139     int rc;
 140
 141     /* Create a temporary file */
 142     rb->snprintf(tmpfilename, MAX_PATH+1, "%s.tmp", filename);
 143     fd = rb->creat(tmpfilename);
 144     if(fd < 0)
 145         return 10 * fd - 1;
 146
 147     /* Write the sorted strings, with appended CR/LF, to the temp file,
 148        in reverse order */
 149     for(i = num_entries-1;i >= 0;i--) {
 150         rc = rb->write(fd, pointers[i], rb->strlen(pointers[i]));
 151         if(rc < 0) {
 152             rb->close(fd);
 153             return 10 * rc - 2;
 154         }
 155
 156         rc = rb->write(fd, crlf, 2);
 157         if(rc < 0) {
 158             rb->close(fd);
 159             return 10 * rc - 3;
 160         }
 161     }
 162
 163     rb->close(fd);
 164
 165     /* Remove the original file */
 166     rc = rb->remove(filename);
 167     if(rc < 0) {
 168         return 10 * rc - 4;
 169     }
 170
 171     /* Replace the old file with the new */
 172     rc = rb->rename(tmpfilename, filename);
 173     if(rc < 0) {
 174         return 10 * rc - 5;
 175     }
 176     return 0;
 177 }
 178
 179 enum plugin_status plugin_start(struct plugin_api* api, void* parameter)
 180 {
 181     char *buf;
 182     int rc;
 183
 184     filename = (char *)parameter;
 185
 186     rb = api;
 187
 188     buf = rb->plugin_get_audio_buffer((size_t *)&buf_size); /* start munching memory */
 189
 190     stringbuffer = buf;
 191     pointers = (char **)(buf + buf_size - sizeof(int));
 192
 193     rb->lcd_clear_display();
 194     rb->splash(0, "Loading...");
 195
 196     rc = read_buffer(0);
 197     if(rc == 0) {
 198         rb->lcd_clear_display();
 199         rb->splash(0, "Sorting...");
 200         sort_buffer();
 201
 202         rb->lcd_clear_display();
 203         rb->splash(0, "Writing...");
 204
 205         rc = write_file();
 206         if(rc < 0) {
 207             rb->lcd_clear_display();
 208             rb->splash(HZ, "Can't write file: %d", rc);
 209         } else {
 210             rb->lcd_clear_display();
 211             rb->splash(HZ, "Done");
 212         }
 213     } else {
 214         if(rc < 0) {
 215             rb->lcd_clear_display();
 216             rb->splash(HZ, "Can't read file: %d", rc);
 217         } else {
 218             rb->lcd_clear_display();
 219             rb->splash(HZ, "The file is too big");
 220         }
 221     }
 222
 223     return PLUGIN_OK;
 224 }