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
  35 /* skin buffer management.
  36  * This module is used to allocate space in a single global skin buffer for
  37  * tokens for both/all screens.
  38  *
  39  * This is mostly just copy/paste from firmware/buffer.c
  40  *
  41  *
  42  * MAIN_ and REMOTE_BUFFER are just for reasonable size calibration,
  43  * both screens can use the whole buffer as they need; it's not split
  44  * between screens
  45  *
  46  * Buffer can be allocated from either "end" of the global buffer.
  47  * items with unknown sizes get allocated from the start (0->)      (data)
  48  * items with known sizes get allocated from the end (<-buf_size)   (tokens)
  49  * After loading 2 skins the buffer will look like this:
  50  *  |tokens skin1|images skin1|tokens s2|images s2|---SPACE---|data skin2|data skin1|
  51  * Make sure to never start allocating from the beginning before letting us know
  52  * how much was used. and RESPECT THE buf_free RETURN VALUES!
  53  *
  54  */
  55
  56
  57 #ifdef HAVE_LCD_BITMAP
  58 #define MAIN_BUFFER ((2*LCD_HEIGHT*LCD_WIDTH*LCD_DEPTH/8) \
  59                     + (SKINNABLE_SCREENS_COUNT * LCD_BACKDROP_BYTES))
  60
  61 #if (NB_SCREENS > 1)
  62 #define REMOTE_BUFFER (2*(LCD_REMOTE_HEIGHT*LCD_REMOTE_WIDTH*LCD_REMOTE_DEPTH/8) \
  63                       + (SKINNABLE_SCREENS_COUNT * REMOTE_LCD_BACKDROP_BYTES))
  64 #else
  65 #define REMOTE_BUFFER 0
  66 #endif
  67
  68
  69 #define SKIN_BUFFER_SIZE (MAIN_BUFFER + REMOTE_BUFFER) + \
  70                          (WPS_MAX_TOKENS * sizeof(struct wps_token))
  71 #endif
  72
  73 #ifdef HAVE_LCD_CHARCELLS
  74 #define SKIN_BUFFER_SIZE (LCD_HEIGHT * LCD_WIDTH) * 64 + \
  75                          (WPS_MAX_TOKENS * sizeof(struct wps_token))
  76 #endif
  77
  78 static unsigned char buffer[SKIN_BUFFER_SIZE];
  79 static unsigned char *buffer_front = NULL; /* start of the free space,
  80                                               increases with allocation*/
  81 static unsigned char *buffer_back  = NULL; /* end of the free space
  82                                               decreases with allocation */
  83 static size_t buf_size = SKIN_BUFFER_SIZE;
  84
  85 void skin_buffer_init(void)
  86 {
  87 #if 0 /* this will go in again later probably */
  88     if (buffer == NULL)
  89     {
  90         buf_size = SKIN_BUFFER_SIZE;/* global_settings.skin_buf_size */
  91
  92         buffer = buffer_alloc(buf_size);
  93         buffer_front = buffer;
  94         buffer_back = bufer + buf_size;
  95     }
  96     else
  97 #endif
  98     {
  99         /* reset the buffer.... */
 100         buffer_front = buffer;
 101         buffer_back = buffer + buf_size;
 102     }
 103 }
 104
 105 /* get the number of bytes currently being used */
 106 size_t skin_buffer_usage(void)
 107 {
 108     return buf_size - (buffer_back-buffer_front);
 109 }
 110
 111 size_t skin_buffer_freespace(void)
 112 {
 113     return buffer_back-buffer_front;
 114 }
 115
 116 /* Allocate size bytes from the buffer
 117  * allocates from the back end (data end)
 118  */
 119 void* skin_buffer_alloc(size_t size)
 120 {
 121     if (skin_buffer_freespace() <= size)
 122     {
 123         return NULL;
 124     }
 125     buffer_back -= size;
 126     /* 32-bit aligned */
 127     buffer_back = (void *)(((unsigned long)buffer_back) & ~3);
 128
 129     memset(buffer_back, 0, size);
 130     return buffer_back;
 131 }
 132
 133 /* Get a pointer to the skin buffer and the count of how much is free
 134  * used to do your own buffer management.
 135  * Any memory used will be overwritten next time wps_buffer_alloc()
 136  * is called unless skin_buffer_increment() is called first
 137  *
 138  * This is from the start of the buffer, it is YOUR responsility to make
 139  * sure you dont ever use more then *freespace, and bear in mind this will only
 140  * be valid untill skin_buffer_alloc() is next called...
 141  * so call skin_buffer_increment() and skin_buffer_freespace() regularly
 142  */
 143 void* skin_buffer_grab(size_t *freespace)
 144 {
 145     *freespace = buf_size - skin_buffer_usage();
 146     return buffer_front;
 147 }
 148
 149 /* Use after skin_buffer_grab() to specify how much buffer was used */
 150 void skin_buffer_increment(size_t used, bool align)
 151 {
 152     buffer_front += used;
 153     if (align)
 154     {
 155         /* 32-bit aligned */
 156         buffer_front = (void *)(((unsigned long)buffer_front + 3) & ~3);
 157     }
 158 }
 159
 160 /* free previously skin_buffer_increment()'ed space. This just moves the pointer
 161  * back 'used' bytes so make sure you actually want to do this */
 162 void skin_buffer_free_from_front(size_t used)
 163 {
 164     buffer_front -= used;
 165     /* 32-bit aligned */
 166     buffer_front = (void *)(((unsigned long)buffer_front + 3) & ~3);
 167 }
 168
 169