apps/plugins/text_viewer/tv_reader.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2002 Gilles Roux
  11  *               2003 Garrett Derner
  12  *               2010 Yoshihisa Uchida
  13  *
  14  * This program is free software; you can redistribute it and/or
  15  * modify it under the terms of the GNU General Public License
  16  * as published by the Free Software Foundation; either version 2
  17  * of the License, or (at your option) any later version.
  18  *
  19  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  20  * KIND, either express or implied.
  21  *
  22  ****************************************************************************/
  23 #include "plugin.h"
  24 #include "tv_preferences.h"
  25 #include "tv_reader.h"
  26
  27 #if PLUGIN_BUFFER_SIZE < 0x10000
  28 #define TV_MIN_BLOCK_SIZE 0x800
  29 #else
  30 #define TV_MIN_BLOCK_SIZE 0x1000
  31 #endif
  32
  33 /* UTF-8 BOM */
  34 #define BOM "\xef\xbb\xbf"
  35 #define BOM_SIZE 3
  36
  37 static int fd = -1;
  38
  39 static off_t file_pos;
  40 static off_t start_file_pos;
  41
  42 static off_t file_size;
  43
  44 static unsigned char *reader_buffer;
  45 static ssize_t buffer_size;
  46 static ssize_t block_size;
  47
  48 static ssize_t buf_pos;
  49 static ssize_t read_size;
  50
  51 off_t tv_get_file_size(void)
  52 {
  53     return file_size;
  54 }
  55
  56 bool tv_is_eof(void)
  57 {
  58     return (file_pos + buf_pos >= file_size);
  59 }
  60
  61 off_t tv_get_current_file_pos(void)
  62 {
  63     return file_pos + buf_pos;
  64 }
  65
  66 const unsigned char *tv_get_buffer(ssize_t *bufsize)
  67 {
  68     *bufsize = read_size - buf_pos;
  69     return reader_buffer + buf_pos;
  70 }
  71
  72 static ssize_t tv_read(unsigned char *buf, ssize_t reqsize)
  73 {
  74     if (buf - reader_buffer + reqsize > buffer_size)
  75         reqsize = buffer_size - (buf - reader_buffer);
  76
  77     return rb->read(fd, buf, reqsize);
  78 }
  79
  80 void tv_seek(off_t offset, int whence)
  81 {
  82     ssize_t size;
  83
  84     switch (whence)
  85     {
  86         case SEEK_SET:
  87             if (offset >= file_pos && offset < file_pos + read_size)
  88             {
  89                 buf_pos = offset - file_pos;
  90                 return;
  91             }
  92             file_pos = offset;
  93             break;
  94
  95         case SEEK_CUR:
  96             buf_pos += offset;
  97             if (buf_pos >= 0 && buf_pos < read_size)
  98             {
  99                 if (buf_pos > block_size)
 100                 {
 101                     buf_pos  -= block_size;
 102                     file_pos += block_size;
 103                     size = read_size - block_size;
 104                     rb->memcpy(reader_buffer, reader_buffer + block_size, size);
 105                     read_size = tv_read(reader_buffer + block_size, block_size);
 106                     if (read_size < 0)
 107                         read_size = 0;
 108
 109                     read_size += size;
 110                 }
 111                 return;
 112             }
 113             file_pos += buf_pos;
 114             whence = SEEK_SET;
 115             break;
 116
 117         default:
 118             return;
 119             break;
 120     }
 121
 122     if (whence == SEEK_SET)
 123     {
 124         if (file_pos < 0)
 125             file_pos = 0;
 126         else if (file_pos > file_size)
 127             file_pos = file_size;
 128
 129         rb->lseek(fd, file_pos + start_file_pos, SEEK_SET);
 130         buf_pos = 0;
 131         read_size = tv_read(reader_buffer, buffer_size);
 132     }
 133 }
 134
 135 static void tv_change_preferences(const struct tv_preferences *oldp)
 136 {
 137     unsigned char bom[BOM_SIZE];
 138     int cur_start_file_pos = start_file_pos;
 139     off_t cur_file_pos     = file_pos + buf_pos;
 140
 141     file_pos  = 0;
 142     buf_pos   = 0;
 143     read_size = 0;
 144     start_file_pos = 0;
 145
 146     /* open the new file */
 147     if (oldp == NULL || rb->strcmp(oldp->file_name, preferences->file_name))
 148     {
 149         if (fd >= 0)
 150             rb->close(fd);
 151
 152         fd = rb->open(preferences->file_name, O_RDONLY);
 153         if (fd < 0)
 154             return;
 155     }
 156
 157     /*
 158      * When a file is UTF-8 file with BOM, if encoding is UTF-8,
 159      * then file size decreases only BOM_SIZE.
 160      */
 161     if (preferences->encoding == UTF_8)
 162     {
 163         rb->lseek(fd, 0, SEEK_SET);
 164         rb->read(fd, bom, BOM_SIZE);
 165         if (rb->memcmp(bom, BOM, BOM_SIZE) == 0)
 166             start_file_pos = BOM_SIZE;
 167     }
 168
 169     file_size = rb->filesize(fd) - start_file_pos;
 170     tv_seek(cur_file_pos + cur_start_file_pos - start_file_pos, SEEK_SET);
 171 }
 172
 173 bool tv_init_reader(unsigned char **buf, size_t *size)
 174 {
 175     if (*size < 2 * TV_MIN_BLOCK_SIZE)
 176         return false;
 177
 178     block_size    = *size / 2;
 179     buffer_size   = 2 * block_size;
 180     reader_buffer = *buf;
 181
 182     *buf += buffer_size;
 183     *size -= buffer_size;
 184
 185     tv_add_preferences_change_listner(tv_change_preferences);
 186
 187     return true;
 188 }
 189
 190 void tv_finalize_reader(void)
 191 {
 192     if (fd >= 0)
 193         rb->close(fd);
 194 }