/* * Generic thunking code to convert data between host and target CPU * * Copyright (c) 2003 Fabrice Bellard * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #include #include #include #include "qemu.h" #include "thunk.h" //#define DEBUG #define MAX_STRUCTS 128 /* XXX: make it dynamic */ StructEntry struct_entries[MAX_STRUCTS]; static inline const argtype *thunk_type_next(const argtype *type_ptr) { int type; type = *type_ptr++; switch(type) { case TYPE_CHAR: case TYPE_SHORT: case TYPE_INT: case TYPE_LONGLONG: case TYPE_ULONGLONG: case TYPE_LONG: case TYPE_ULONG: case TYPE_PTRVOID: return type_ptr; case TYPE_PTR: return thunk_type_next(type_ptr); case TYPE_ARRAY: return thunk_type_next(type_ptr + 1); case TYPE_STRUCT: return type_ptr + 1; default: return NULL; } } void thunk_register_struct(int id, const char *name, const argtype *types) { const argtype *type_ptr; StructEntry *se; int nb_fields, offset, max_align, align, size, i, j; se = struct_entries + id; /* first we count the number of fields */ type_ptr = types; nb_fields = 0; while (*type_ptr != TYPE_NULL) { type_ptr = thunk_type_next(type_ptr); nb_fields++; } se->field_types = types; se->nb_fields = nb_fields; se->name = name; #ifdef DEBUG printf("struct %s: id=%d nb_fields=%d\n", se->name, id, se->nb_fields); #endif /* now we can alloc the data */ for(i = 0;i < 2; i++) { offset = 0; max_align = 1; se->field_offsets[i] = malloc(nb_fields * sizeof(int)); type_ptr = se->field_types; for(j = 0;j < nb_fields; j++) { size = thunk_type_size(type_ptr, i); align = thunk_type_align(type_ptr, i); offset = (offset + align - 1) & ~(align - 1); se->field_offsets[i][j] = offset; offset += size; if (align > max_align) max_align = align; type_ptr = thunk_type_next(type_ptr); } offset = (offset + max_align - 1) & ~(max_align - 1); se->size[i] = offset; se->align[i] = max_align; #ifdef DEBUG printf("%s: size=%d align=%d\n", i == THUNK_HOST ? "host" : "target", offset, max_align); #endif } } void thunk_register_struct_direct(int id, const char *name, StructEntry *se1) { StructEntry *se; se = struct_entries + id; *se = *se1; se->name = name; } /* now we can define the main conversion functions */ const argtype *thunk_convert(void *dst, const void *src, const argtype *type_ptr, int to_host) { int type; type = *type_ptr++; switch(type) { case TYPE_CHAR: *(uint8_t *)dst = *(uint8_t *)src; break; case TYPE_SHORT: *(uint16_t *)dst = tswap16(*(uint16_t *)src); break; case TYPE_INT: *(uint32_t *)dst = tswap32(*(uint32_t *)src); break; case TYPE_LONGLONG: case TYPE_ULONGLONG: *(uint64_t *)dst = tswap64(*(uint64_t *)src); break; #if HOST_LONG_BITS == 32 && TARGET_LONG_BITS == 32 case TYPE_LONG: case TYPE_ULONG: case TYPE_PTRVOID: *(uint32_t *)dst = tswap32(*(uint32_t *)src); break; #elif HOST_LONG_BITS == 64 && TARGET_LONG_BITS == 32 case TYPE_LONG: case TYPE_ULONG: case TYPE_PTRVOID: if (to_host) { *(uint64_t *)dst = tswap32(*(uint32_t *)src); } else { *(uint32_t *)dst = tswap32(*(uint64_t *)src & 0xffffffff); } break; #else #warning unsupported conversion #endif case TYPE_ARRAY: { int array_length, i, dst_size, src_size; const uint8_t *s; uint8_t *d; array_length = *type_ptr++; dst_size = thunk_type_size(type_ptr, to_host); src_size = thunk_type_size(type_ptr, 1 - to_host); d = dst; s = src; for(i = 0;i < array_length; i++) { thunk_convert(d, s, type_ptr, to_host); d += dst_size; s += src_size; } type_ptr = thunk_type_next(type_ptr); } break; case TYPE_STRUCT: { int i; const StructEntry *se; const uint8_t *s; uint8_t *d; const argtype *field_types; const int *dst_offsets, *src_offsets; se = struct_entries + *type_ptr++; if (se->convert[0] != NULL) { /* specific conversion is needed */ (*se->convert[to_host])(dst, src); } else { /* standard struct conversion */ field_types = se->field_types; dst_offset
/* Copyright 2017 Fred Sundvik
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#include "lcd_backlight_keyframes.h"

bool lcd_backlight_keyframe_animate_color(keyframe_animation_t* animation, visualizer_state_t* state) {
    int     frame_length = animation->frame_lengths[animation->current_frame];
    int     current_pos  = frame_length - animation->time_left_in_frame;
    uint8_t t_h          = LCD_HUE(state->target_lcd_color);
    uint8_t t_s          = LCD_SAT(state->target_lcd_color);
    uint8_t t_i          = LCD_INT(state->target_lcd_color);
    uint8_t p_h          = LCD_HUE(state->prev_lcd_color);
    uint8_t p_s          = LCD_SAT(state->prev_lcd_color);
    uint8_t p_i          = LCD_INT(state->prev_lcd_color);

    uint8_t d_h1 = t_h - p_h;  // Modulo arithmetic since we want to wrap around
    int     d_h2 = t_h - p_h;
    // Chose the shortest way around
    int d_h = abs(d_h2) < d_h1 ? d_h2 : d_h1;
    int d_s = t_s - p_s;
    int d_i = t_i - p_i;

    int hue       = (d_h * current_pos) / frame_length;
    int sat       = (d_s * current_pos) / frame_length;
    int intensity = (d_i * current_pos) / frame_length;
    // dprintf("%X -> %X = %X\n", p_h, t_h, hue);
    hue += p_h;
    sat += p_s;
    intensity += p_i;
    state->current_lcd_color = LCD_COLOR(hue, sat, intensity);
    lcd_backlight_color(LCD_HUE(state->current_lcd_color), LCD_SAT(state->current_lcd_color), LCD_INT(state->current_lcd_color));

    return true;
}

bool lcd_backlight_keyframe_set_color(keyframe_animation_t* animation, visualizer_state_t* state) {
    (void)animation;
    state->prev_lcd_color    = state->target_lcd_color;
    state->current_lcd_color = state->target_lcd_color;
    lcd_backlight_color(LCD_HUE(state->current_lcd_color), LCD_SAT(state->current_lcd_color), LCD_INT(state->current_lcd_color));
    return false;
}

bool lcd_backlight_keyframe_disable(keyframe_animation_t* animation, visualizer_state_t* state) {
    (void)animation;
    (void)state;
    lcd_backlight_hal_color(0, 0, 0);
    return false;
}

bool lcd_backlight_keyframe_enable(keyframe_animation_t* animation, visualizer_state_t* state) {
    (void)animation;
    (void)state;
    lcd_backlight_color(LCD_HUE(state->current_lcd_color), LCD_SAT(state->current_lcd_color), LCD_INT(state->current_lcd_color));
    return false;
}
generated by cgit v1.2.3 (git 2.25.1) at 2025-12-23 07:15:23 +0000