apps/gui/skin_engine/skin_buffer.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2002 by Linus Nielsen Feltzing
  11  * Copyright (C) 2009 Jonathan Gordon
  12  *
  13  * This program is free software; you can redistribute it and/or
  14  * modify it under the terms of the GNU General Public License
  15  * as published by the Free Software Foundation; either version 2
  16  * of the License, or (at your option) any later version.
  17  *
  18  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  19  * KIND, either express or implied.
  20  *
  21  ****************************************************************************/
  22
  23 #include <stdio.h>
  24 #include <string.h>
  25 #include <stdlib.h>
  26 #include "config.h"
  27 #include "buffer.h"
  28 #include "settings.h"
  29 #include "screen_access.h"
  30 #include "skin_engine.h"
  31 #include "wps_internals.h"
  32 #include "skin_tokens.h"
  33 #include "skin_buffer.h"
  34 #include "skin_fonts.h"
  35
  36 /* skin buffer management.
  37  * This module is used to allocate space in a single global skin buffer for
  38  * tokens for both/all screens.
  39  *
  40  * This is mostly just copy/paste from firmware/buffer.c
  41  *
  42  *
  43  * MAIN_ and REMOTE_BUFFER are just for reasonable size calibration,
  44  * both screens can use the whole buffer as they need; it's not split
  45  * between screens
  46  *
  47  * Buffer can be allocated from either "end" of the global buffer.
  48  * items with unknown sizes get allocated from the start (0->)      (data)
  49  * items with known sizes get allocated from the end (<-buf_size)   (tokens)
  50  * After loading 2 skins the buffer will look like this:
  51  *  |tokens skin1|images skin1|tokens s2|images s2|---SPACE---|data skin2|data skin1|
  52  * Make sure to never start allocating from the beginning before letting us know
  53  * how much was used. and RESPECT THE buf_free RETURN VALUES!
  54  *
  55  */
  56
  57
  58 #ifdef HAVE_LCD_BITMAP
  59 #define MAIN_BUFFER ((2*LCD_HEIGHT*LCD_WIDTH*LCD_DEPTH/8) \
  60                     + (SKINNABLE_SCREENS_COUNT * LCD_BACKDROP_BYTES))
  61
  62 #if (NB_SCREENS > 1)
  63 #define REMOTE_BUFFER (2*(LCD_REMOTE_HEIGHT*LCD_REMOTE_WIDTH*LCD_REMOTE_DEPTH/8) \
  64                       + (SKINNABLE_SCREENS_COUNT * REMOTE_LCD_BACKDROP_BYTES))
  65 #else
  66 #define REMOTE_BUFFER 0
  67 #endif
  68
  69
  70 #define SKIN_BUFFER_SIZE (MAIN_BUFFER + REMOTE_BUFFER + SKIN_FONT_SIZE) + \
  71                          (WPS_MAX_TOKENS * sizeof(struct wps_token))
  72 #endif
  73
  74 #ifdef HAVE_LCD_CHARCELLS
  75 #define SKIN_BUFFER_SIZE (LCD_HEIGHT * LCD_WIDTH) * 64 + \
  76                          (WPS_MAX_TOKENS * sizeof(struct wps_token))
  77 #endif
  78
  79 static unsigned char buffer[SKIN_BUFFER_SIZE];
  80 static unsigned char *buffer_front = NULL; /* start of the free space,
  81                                               increases with allocation*/
  82 static unsigned char *buffer_back  = NULL; /* end of the free space
  83                                               decreases with allocation */
  84 static size_t buf_size = SKIN_BUFFER_SIZE;
  85
  86 void skin_buffer_init(void)
  87 {
  88 #if 0 /* this will go in again later probably */
  89     if (buffer == NULL)
  90     {
  91         buf_size = SKIN_BUFFER_SIZE;/* global_settings.skin_buf_size */
  92
  93         buffer = buffer_alloc(buf_size);
  94         buffer_front = buffer;
  95         buffer_back = bufer + buf_size;
  96     }
  97     else
  98 #endif
  99     {
 100         /* reset the buffer.... */
 101         buffer_front = buffer;
 102         buffer_back = buffer + buf_size;
 103     }
 104 }
 105
 106 /* get the number of bytes currently being used */
 107 size_t skin_buffer_usage(void)
 108 {
 109     return buf_size - (buffer_back-buffer_front);
 110 }
 111
 112 size_t skin_buffer_freespace(void)
 113 {
 114     return buffer_back-buffer_front;
 115 }
 116
 117 /* Allocate size bytes from the buffer
 118  * allocates from the back end (data end)
 119  */
 120 void* skin_buffer_alloc(size_t size)
 121 {
 122     if (skin_buffer_freespace() <= size)
 123     {
 124         return NULL;
 125     }
 126     buffer_back -= size;
 127     /* 32-bit aligned */
 128     buffer_back = (void *)(((unsigned long)buffer_back) & ~3);
 129
 130     memset(buffer_back, 0, size);
 131     return buffer_back;
 132 }
 133
 134 /* Get a pointer to the skin buffer and the count of how much is free
 135  * used to do your own buffer management.
 136  * Any memory used will be overwritten next time wps_buffer_alloc()
 137  * is called unless skin_buffer_increment() is called first
 138  *
 139  * This is from the start of the buffer, it is YOUR responsility to make
 140  * sure you dont ever use more then *freespace, and bear in mind this will only
 141  * be valid untill skin_buffer_alloc() is next called...
 142  * so call skin_buffer_increment() and skin_buffer_freespace() regularly
 143  */
 144 void* skin_buffer_grab(size_t *freespace)
 145 {
 146     *freespace = buf_size - skin_buffer_usage();
 147     return buffer_front;
 148 }
 149
 150 /* Use after skin_buffer_grab() to specify how much buffer was used */
 151 void skin_buffer_increment(size_t used, bool align)
 152 {
 153     buffer_front += used;
 154     if (align)
 155     {
 156         /* 32-bit aligned */
 157         buffer_front = (void *)(((unsigned long)buffer_front + 3) & ~3);
 158     }
 159 }
 160
 161 /* free previously skin_buffer_increment()'ed space. This just moves the pointer
 162  * back 'used' bytes so make sure you actually want to do this */
 163 void skin_buffer_free_from_front(size_t used)
 164 {
 165     buffer_front -= used;
 166     /* 32-bit aligned */
 167     buffer_front = (void *)(((unsigned long)buffer_front + 3) & ~3);
 168 }
 169
 170