From d87bfaf4800b3ed169831ba3ccdd4c52772cafe4 Mon Sep 17 00:00:00 2001 From: Matthew Newberg Date: Sat, 31 Aug 2019 22:07:09 -0400 Subject: Add random dithering to ColorConverter --- shared-module/displayio/ColorConverter.c | 79 ++++++++++++++++++++++++++------ shared-module/displayio/ColorConverter.h | 6 ++- shared-module/displayio/Display.c | 8 ++++ shared-module/displayio/Palette.h | 15 ++++++ shared-module/displayio/TileGrid.c | 52 +++++++++++---------- shared-module/displayio/display_core.c | 9 ++++ shared-module/displayio/display_core.h | 3 ++ 7 files changed, 133 insertions(+), 39 deletions(-) (limited to 'shared-module') diff --git a/shared-module/displayio/ColorConverter.c b/shared-module/displayio/ColorConverter.c index 940aaa1c6..cf93e71b7 100644 --- a/shared-module/displayio/ColorConverter.c +++ b/shared-module/displayio/ColorConverter.c @@ -28,6 +28,17 @@ #include "py/misc.h" +uint32_t displayio_colorconverter_dither_noise_1 (uint32_t n) +{ + n = (n >> 13) ^ n; + int nn = (n * (n * n * 60493 + 19990303) + 1376312589) & 0x7fffffff; + return (uint32_t) (((float)nn / (1073741824.0f*2)) * 255); +} + +uint32_t displayio_colorconverter_dither_noise_2(uint32_t x, uint32_t y) { + return displayio_colorconverter_dither_noise_1(x + y * 0xFFFF); +} + void common_hal_displayio_colorconverter_construct(displayio_colorconverter_t* self) { } @@ -96,34 +107,72 @@ void displayio_colorconverter_compute_tricolor(const _displayio_colorspace_t* co } } -bool displayio_colorconverter_convert(displayio_colorconverter_t *self, const _displayio_colorspace_t* colorspace, uint32_t input_color, uint32_t* output_color) { +void common_hal_displayio_colorconverter_convert(displayio_colorconverter_t *self, const _displayio_colorspace_t* colorspace, uint32_t input_color, uint32_t* output_color) { + displayio_input_pixel_t input_pixel; + input_pixel.pixel = input_color; + input_pixel.x = input_pixel.y = input_pixel.tile = input_pixel.tile_x = input_pixel.tile_y = 0; + + displayio_output_pixel_t output_pixel; + output_pixel.pixel = 0; + output_pixel.opaque = false; + + displayio_colorconverter_convert(self, colorspace, &input_pixel, &output_pixel); + + (*output_color) = output_pixel.pixel; +} + +bool displayio_colorconverter_convert(displayio_colorconverter_t *self, const _displayio_colorspace_t* colorspace, const displayio_input_pixel_t *input_pixel, displayio_output_pixel_t *output_color) { + uint32_t pixel = input_pixel->pixel; + + if (colorspace->dither){ + uint8_t randr = (displayio_colorconverter_dither_noise_2(input_pixel->tile_x,input_pixel->tile_y)); + uint8_t randg = (displayio_colorconverter_dither_noise_2(input_pixel->tile_x+33,input_pixel->tile_y)); + uint8_t randb = (displayio_colorconverter_dither_noise_2(input_pixel->tile_x,input_pixel->tile_y+33)); + + uint32_t r8 = (pixel >> 16); + uint32_t g8 = (pixel >> 8) & 0xff; + uint32_t b8 = pixel & 0xff; + + if (colorspace->depth == 16) { + b8 = MIN(255,b8 + (randb&0x07)); + r8 = MIN(255,r8 + (randr&0x07)); + g8 = MIN(255,g8 + (randg&0x03)); + } else { + int bitmask = 0xFF >> colorspace->depth; + b8 = MIN(255,b8 + (randb&bitmask)); + r8 = MIN(255,r8 + (randr&bitmask)); + g8 = MIN(255,g8 + (randg&bitmask)); + } + pixel = r8 << 16 | g8 << 8 | b8; + } + if (colorspace->depth == 16) { - *output_color = displayio_colorconverter_compute_rgb565(input_color); + output_color->pixel = displayio_colorconverter_compute_rgb565(pixel); + output_color->opaque = true; return true; } else if (colorspace->tricolor) { - uint8_t luma = displayio_colorconverter_compute_luma(input_color); - *output_color = luma >> (8 - colorspace->depth); - if (displayio_colorconverter_compute_chroma(input_color) <= 16) { + uint8_t luma = displayio_colorconverter_compute_luma(pixel); + output_color->pixel = luma >> (8 - colorspace->depth); + if (displayio_colorconverter_compute_chroma(pixel) <= 16) { if (!colorspace->grayscale) { - *output_color = 0; + output_color->pixel = 0; } + output_color->opaque = true; return true; } - uint8_t pixel_hue = displayio_colorconverter_compute_hue(input_color); - displayio_colorconverter_compute_tricolor(colorspace, pixel_hue, luma, output_color); + uint8_t pixel_hue = displayio_colorconverter_compute_hue(pixel); + displayio_colorconverter_compute_tricolor(colorspace, pixel_hue, luma, &output_color->pixel); return true; - } else if (colorspace->grayscale && colorspace->depth <= 8) { - uint8_t luma = displayio_colorconverter_compute_luma(input_color); - *output_color = luma >> (8 - colorspace->depth); + } else if (colorspace->grayscale && colorspace->depth <= 8) { + uint8_t luma = displayio_colorconverter_compute_luma(pixel); + output_color->pixel = luma >> (8 - colorspace->depth); + output_color->opaque = true; return true; } + output_color->opaque = false; return false; } -void common_hal_displayio_colorconverter_convert(displayio_colorconverter_t *self, const _displayio_colorspace_t* colorspace, uint32_t input_color, uint32_t* output_color) { - displayio_colorconverter_convert(self, colorspace, input_color, output_color); -} - // Currently no refresh logic is needed for a ColorConverter. bool displayio_colorconverter_needs_refresh(displayio_colorconverter_t *self) { return false; diff --git a/shared-module/displayio/ColorConverter.h b/shared-module/displayio/ColorConverter.h index c79e6a2f7..6bb52d720 100644 --- a/shared-module/displayio/ColorConverter.h +++ b/shared-module/displayio/ColorConverter.h @@ -39,7 +39,11 @@ typedef struct { bool displayio_colorconverter_needs_refresh(displayio_colorconverter_t *self); void displayio_colorconverter_finish_refresh(displayio_colorconverter_t *self); -bool displayio_colorconverter_convert(displayio_colorconverter_t *self, const _displayio_colorspace_t* colorspace, uint32_t input_color, uint32_t* output_color); +bool displayio_colorconverter_convert(displayio_colorconverter_t *self, const _displayio_colorspace_t* colorspace, const displayio_input_pixel_t *input_pixel, displayio_output_pixel_t *output_color); + +uint32_t displayio_colorconverter_dither_noise_1 (uint32_t n); +uint32_t displayio_colorconverter_dither_noise_2(uint32_t x, uint32_t y); + uint16_t displayio_colorconverter_compute_rgb565(uint32_t color_rgb888); uint8_t displayio_colorconverter_compute_luma(uint32_t color_rgb888); uint8_t displayio_colorconverter_compute_chroma(uint32_t color_rgb888); diff --git a/shared-module/displayio/Display.c b/shared-module/displayio/Display.c index f210a80c3..03185dffc 100644 --- a/shared-module/displayio/Display.c +++ b/shared-module/displayio/Display.c @@ -150,6 +150,14 @@ void common_hal_displayio_display_set_auto_brightness(displayio_display_obj_t* s self->auto_brightness = auto_brightness; } +void common_hal_displayio_display_set_dither(displayio_display_obj_t* self, bool dither) { + displayio_display_core_set_dither(&self->core, dither); +} + +bool common_hal_displayio_display_get_dither(displayio_display_obj_t* self) { + return displayio_display_core_get_dither(&self->core); +} + mp_float_t common_hal_displayio_display_get_brightness(displayio_display_obj_t* self) { return self->current_brightness; } diff --git a/shared-module/displayio/Palette.h b/shared-module/displayio/Palette.h index 1cfdd199a..758fd43fc 100644 --- a/shared-module/displayio/Palette.h +++ b/shared-module/displayio/Palette.h @@ -41,6 +41,7 @@ typedef struct { bool tricolor; bool pixels_in_byte_share_row; bool reverse_pixels_in_byte; + bool dither; } _displayio_colorspace_t; typedef struct { @@ -52,6 +53,20 @@ typedef struct { bool transparent; // This may have additional bits added later for blending. } _displayio_color_t; +typedef struct { + uint32_t pixel; + uint16_t x; + uint16_t y; + uint8_t tile; + uint16_t tile_x; + uint16_t tile_y; +} displayio_input_pixel_t; + +typedef struct { + uint32_t pixel; + bool opaque; +} displayio_output_pixel_t; + typedef struct { mp_obj_base_t base; _displayio_color_t* colors; diff --git a/shared-module/displayio/TileGrid.c b/shared-module/displayio/TileGrid.c index f34d2fc52..81d142bbe 100644 --- a/shared-module/displayio/TileGrid.c +++ b/shared-module/displayio/TileGrid.c @@ -377,12 +377,16 @@ bool displayio_tilegrid_fill_area(displayio_tilegrid_t *self, const _displayio_c } uint8_t pixels_per_byte = 8 / colorspace->depth; - for (int16_t y = start_y; y < end_y; y++) { - int16_t row_start = start + (y - start_y + y_shift) * y_stride; // in pixels - int16_t local_y = y / self->absolute_transform->scale; - for (int16_t x = start_x; x < end_x; x++) { + + displayio_input_pixel_t input_pixel; + displayio_output_pixel_t output_pixel; + + for (input_pixel.y = start_y; input_pixel.y < end_y; ++input_pixel.y) { + int16_t row_start = start + (input_pixel.y - start_y + y_shift) * y_stride; // in pixels + int16_t local_y = input_pixel.y / self->absolute_transform->scale; + for (input_pixel.x = start_x; input_pixel.x < end_x; ++input_pixel.x) { // Compute the destination pixel in the buffer and mask based on the transformations. - int16_t offset = row_start + (x - start_x + x_shift) * x_stride; // in pixels + int16_t offset = row_start + (input_pixel.x - start_x + x_shift) * x_stride; // in pixels // This is super useful for debugging out of range accesses. Uncomment to use. // if (offset < 0 || offset >= (int32_t) displayio_area_size(area)) { @@ -393,41 +397,43 @@ bool displayio_tilegrid_fill_area(displayio_tilegrid_t *self, const _displayio_c if ((mask[offset / 32] & (1 << (offset % 32))) != 0) { continue; } - int16_t local_x = x / self->absolute_transform->scale; + int16_t local_x = input_pixel.x / self->absolute_transform->scale; uint16_t tile_location = ((local_y / self->tile_height + self->top_left_y) % self->height_in_tiles) * self->width_in_tiles + (local_x / self->tile_width + self->top_left_x) % self->width_in_tiles; - uint8_t tile = tiles[tile_location]; - uint16_t tile_x = (tile % self->bitmap_width_in_tiles) * self->tile_width + local_x % self->tile_width; - uint16_t tile_y = (tile / self->bitmap_width_in_tiles) * self->tile_height + local_y % self->tile_height; + input_pixel.tile = tiles[tile_location]; + input_pixel.tile_x = (input_pixel.tile % self->bitmap_width_in_tiles) * self->tile_width + local_x % self->tile_width; + input_pixel.tile_y = (input_pixel.tile / self->bitmap_width_in_tiles) * self->tile_height + local_y % self->tile_height; + + //uint32_t value = 0; + output_pixel.pixel = 0; + input_pixel.pixel = 0; - uint32_t value = 0; // We always want to read bitmap pixels by row first and then transpose into the destination // buffer because most bitmaps are row associated. if (MP_OBJ_IS_TYPE(self->bitmap, &displayio_bitmap_type)) { - value = common_hal_displayio_bitmap_get_pixel(self->bitmap, tile_x, tile_y); + input_pixel.pixel = common_hal_displayio_bitmap_get_pixel(self->bitmap, input_pixel.tile_x, input_pixel.tile_y); } else if (MP_OBJ_IS_TYPE(self->bitmap, &displayio_shape_type)) { - value = common_hal_displayio_shape_get_pixel(self->bitmap, tile_x, tile_y); + input_pixel.pixel = common_hal_displayio_shape_get_pixel(self->bitmap, input_pixel.tile_x, input_pixel.tile_y); } else if (MP_OBJ_IS_TYPE(self->bitmap, &displayio_ondiskbitmap_type)) { - value = common_hal_displayio_ondiskbitmap_get_pixel(self->bitmap, tile_x, tile_y); + input_pixel.pixel = common_hal_displayio_ondiskbitmap_get_pixel(self->bitmap, input_pixel.tile_x, input_pixel.tile_y); } - - uint32_t pixel; - bool opaque = true; + + output_pixel.opaque = true; if (self->pixel_shader == mp_const_none) { - pixel = value; + output_pixel.pixel = input_pixel.pixel; } else if (MP_OBJ_IS_TYPE(self->pixel_shader, &displayio_palette_type)) { - opaque = displayio_palette_get_color(self->pixel_shader, colorspace, value, &pixel); + output_pixel.opaque = displayio_palette_get_color(self->pixel_shader, colorspace, input_pixel.pixel, &output_pixel.pixel); } else if (MP_OBJ_IS_TYPE(self->pixel_shader, &displayio_colorconverter_type)) { - opaque = displayio_colorconverter_convert(self->pixel_shader, colorspace, value, &pixel); + displayio_colorconverter_convert(self->pixel_shader, colorspace, &input_pixel, &output_pixel); } - if (!opaque) { + if (!output_pixel.opaque) { // A pixel is transparent so we haven't fully covered the area ourselves. full_coverage = false; } else { mask[offset / 32] |= 1 << (offset % 32); if (colorspace->depth == 16) { - *(((uint16_t*) buffer) + offset) = pixel; + *(((uint16_t*) buffer) + offset) = output_pixel.pixel; } else if (colorspace->depth == 8) { - *(((uint8_t*) buffer) + offset) = pixel; + *(((uint8_t*) buffer) + offset) = output_pixel.pixel; } else if (colorspace->depth < 8) { // Reorder the offsets to pack multiple rows into a byte (meaning they share a column). if (!colorspace->pixels_in_byte_share_row) { @@ -446,7 +452,7 @@ bool displayio_tilegrid_fill_area(displayio_tilegrid_t *self, const _displayio_c // Reverse the shift by subtracting it from the leftmost shift. shift = (pixels_per_byte - 1) * colorspace->depth - shift; } - ((uint8_t*)buffer)[offset / pixels_per_byte] |= pixel << shift; + ((uint8_t*)buffer)[offset / pixels_per_byte] |= output_pixel.pixel << shift; } } } diff --git a/shared-module/displayio/display_core.c b/shared-module/displayio/display_core.c index 0f449ea34..83df67c63 100644 --- a/shared-module/displayio/display_core.c +++ b/shared-module/displayio/display_core.c @@ -49,6 +49,7 @@ void displayio_display_core_construct(displayio_display_core_t* self, self->colorspace.pixels_in_byte_share_row = pixels_in_byte_share_row; self->colorspace.bytes_per_cell = bytes_per_cell; self->colorspace.reverse_pixels_in_byte = reverse_pixels_in_byte; + self->colorspace.dither = false; self->current_group = NULL; self->colstart = colstart; self->rowstart = rowstart; @@ -171,6 +172,14 @@ uint16_t displayio_display_core_get_height(displayio_display_core_t* self){ return self->height; } +void displayio_display_core_set_dither(displayio_display_core_t* self, bool dither){ + self->colorspace.dither = dither; +} + +bool displayio_display_core_get_dither(displayio_display_core_t* self){ + return self->colorspace.dither; +} + bool displayio_display_core_bus_free(displayio_display_core_t *self) { return self->bus_free(self->bus); } diff --git a/shared-module/displayio/display_core.h b/shared-module/displayio/display_core.h index e92fdbc9f..3a69cd40a 100644 --- a/shared-module/displayio/display_core.h +++ b/shared-module/displayio/display_core.h @@ -65,6 +65,9 @@ bool displayio_display_core_show(displayio_display_core_t* self, displayio_group uint16_t displayio_display_core_get_width(displayio_display_core_t* self); uint16_t displayio_display_core_get_height(displayio_display_core_t* self); +void displayio_display_core_set_dither(displayio_display_core_t* self, bool dither); +bool displayio_display_core_get_dither(displayio_display_core_t* self); + bool displayio_display_core_bus_free(displayio_display_core_t *self); bool displayio_display_core_begin_transaction(displayio_display_core_t* self); void displayio_display_core_end_transaction(displayio_display_core_t* self); -- cgit v1.2.3 From 3ab6a2343426e1b42141916a74c0c422dbd34828 Mon Sep 17 00:00:00 2001 From: Matthew Newberg Date: Wed, 4 Sep 2019 20:42:24 -0400 Subject: Removed unused return value in displayio_colorconverter_convert --- shared-module/displayio/ColorConverter.c | 11 +++++------ shared-module/displayio/ColorConverter.h | 2 +- 2 files changed, 6 insertions(+), 7 deletions(-) (limited to 'shared-module') diff --git a/shared-module/displayio/ColorConverter.c b/shared-module/displayio/ColorConverter.c index cf93e71b7..304d13a01 100644 --- a/shared-module/displayio/ColorConverter.c +++ b/shared-module/displayio/ColorConverter.c @@ -121,7 +121,7 @@ void common_hal_displayio_colorconverter_convert(displayio_colorconverter_t *sel (*output_color) = output_pixel.pixel; } -bool displayio_colorconverter_convert(displayio_colorconverter_t *self, const _displayio_colorspace_t* colorspace, const displayio_input_pixel_t *input_pixel, displayio_output_pixel_t *output_color) { +void displayio_colorconverter_convert(displayio_colorconverter_t *self, const _displayio_colorspace_t* colorspace, const displayio_input_pixel_t *input_pixel, displayio_output_pixel_t *output_color) { uint32_t pixel = input_pixel->pixel; if (colorspace->dither){ @@ -149,7 +149,7 @@ bool displayio_colorconverter_convert(displayio_colorconverter_t *self, const _d if (colorspace->depth == 16) { output_color->pixel = displayio_colorconverter_compute_rgb565(pixel); output_color->opaque = true; - return true; + return; } else if (colorspace->tricolor) { uint8_t luma = displayio_colorconverter_compute_luma(pixel); output_color->pixel = luma >> (8 - colorspace->depth); @@ -158,19 +158,18 @@ bool displayio_colorconverter_convert(displayio_colorconverter_t *self, const _d output_color->pixel = 0; } output_color->opaque = true; - return true; + return; } uint8_t pixel_hue = displayio_colorconverter_compute_hue(pixel); displayio_colorconverter_compute_tricolor(colorspace, pixel_hue, luma, &output_color->pixel); - return true; + return; } else if (colorspace->grayscale && colorspace->depth <= 8) { uint8_t luma = displayio_colorconverter_compute_luma(pixel); output_color->pixel = luma >> (8 - colorspace->depth); output_color->opaque = true; - return true; + return; } output_color->opaque = false; - return false; } // Currently no refresh logic is needed for a ColorConverter. diff --git a/shared-module/displayio/ColorConverter.h b/shared-module/displayio/ColorConverter.h index 6bb52d720..3657df168 100644 --- a/shared-module/displayio/ColorConverter.h +++ b/shared-module/displayio/ColorConverter.h @@ -39,7 +39,7 @@ typedef struct { bool displayio_colorconverter_needs_refresh(displayio_colorconverter_t *self); void displayio_colorconverter_finish_refresh(displayio_colorconverter_t *self); -bool displayio_colorconverter_convert(displayio_colorconverter_t *self, const _displayio_colorspace_t* colorspace, const displayio_input_pixel_t *input_pixel, displayio_output_pixel_t *output_color); +void displayio_colorconverter_convert(displayio_colorconverter_t *self, const _displayio_colorspace_t* colorspace, const displayio_input_pixel_t *input_pixel, displayio_output_pixel_t *output_color); uint32_t displayio_colorconverter_dither_noise_1 (uint32_t n); uint32_t displayio_colorconverter_dither_noise_2(uint32_t x, uint32_t y); -- cgit v1.2.3 From 4604a69498d5f7ffadb4ebf46a064ea5e18164b6 Mon Sep 17 00:00:00 2001 From: Matthew Newberg Date: Thu, 5 Sep 2019 21:55:45 -0400 Subject: Move dither parameter to ColorConverter constructor and parameter --- shared-bindings/displayio/ColorConverter.c | 39 ++++++++++++++++++++++++++++-- shared-bindings/displayio/ColorConverter.h | 5 +++- shared-bindings/displayio/Display.c | 25 ------------------- shared-module/displayio/ColorConverter.c | 16 ++++++++++-- shared-module/displayio/ColorConverter.h | 1 + shared-module/displayio/Display.c | 8 ------ 6 files changed, 56 insertions(+), 38 deletions(-) (limited to 'shared-module') diff --git a/shared-bindings/displayio/ColorConverter.c b/shared-bindings/displayio/ColorConverter.c index d9524870d..8c48a670a 100644 --- a/shared-bindings/displayio/ColorConverter.c +++ b/shared-bindings/displayio/ColorConverter.c @@ -51,11 +51,18 @@ // TODO(tannewt): Add support for other color formats. //| STATIC mp_obj_t displayio_colorconverter_make_new(const mp_obj_type_t *type, size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) { - mp_arg_check_num(n_args, kw_args, 0, 0, false); + mp_arg_check_num(n_args, kw_args, 0, 1, false); displayio_colorconverter_t *self = m_new_obj(displayio_colorconverter_t); self->base.type = &displayio_colorconverter_type; - common_hal_displayio_colorconverter_construct(self); + + bool dither = false; + + if (n_args > 0) { + dither = mp_obj_is_true(pos_args[0]); + } + + common_hal_displayio_colorconverter_construct(self, dither); return MP_OBJ_FROM_PTR(self); } @@ -79,8 +86,35 @@ STATIC mp_obj_t displayio_colorconverter_obj_convert(mp_obj_t self_in, mp_obj_t } MP_DEFINE_CONST_FUN_OBJ_2(displayio_colorconverter_convert_obj, displayio_colorconverter_obj_convert); +//| .. attribute:: dither +//| +//| True when the display is dithered +//| +STATIC mp_obj_t displayio_colorconverter_obj_get_dither(mp_obj_t self_in) { + displayio_colorconverter_t *self = MP_OBJ_TO_PTR(self_in); + return mp_obj_new_bool(common_hal_displayio_colorconverter_get_dither(self)); +} +MP_DEFINE_CONST_FUN_OBJ_1(displayio_colorconverter_get_dither_obj, displayio_colorconverter_obj_get_dither); + +STATIC mp_obj_t displayio_colorconverter_obj_set_dither(mp_obj_t self_in, mp_obj_t dither) { + displayio_colorconverter_t *self = MP_OBJ_TO_PTR(self_in); + + common_hal_displayio_colorconverter_set_dither(self, mp_obj_is_true(dither)); + + return mp_const_none; +} +MP_DEFINE_CONST_FUN_OBJ_2(displayio_colorconverter_set_dither_obj, displayio_colorconverter_obj_set_dither); + +const mp_obj_property_t displayio_colorconverter_dither_obj = { + .base.type = &mp_type_property, + .proxy = {(mp_obj_t)&displayio_colorconverter_get_dither_obj, + (mp_obj_t)&displayio_colorconverter_set_dither_obj, + (mp_obj_t)&mp_const_none_obj}, +}; + STATIC const mp_rom_map_elem_t displayio_colorconverter_locals_dict_table[] = { { MP_ROM_QSTR(MP_QSTR_convert), MP_ROM_PTR(&displayio_colorconverter_convert_obj) }, + { MP_ROM_QSTR(MP_QSTR_dither), MP_ROM_PTR(&displayio_colorconverter_dither_obj) }, }; STATIC MP_DEFINE_CONST_DICT(displayio_colorconverter_locals_dict, displayio_colorconverter_locals_dict_table); @@ -90,3 +124,4 @@ const mp_obj_type_t displayio_colorconverter_type = { .make_new = displayio_colorconverter_make_new, .locals_dict = (mp_obj_dict_t*)&displayio_colorconverter_locals_dict, }; + diff --git a/shared-bindings/displayio/ColorConverter.h b/shared-bindings/displayio/ColorConverter.h index 24895500e..d550d81be 100644 --- a/shared-bindings/displayio/ColorConverter.h +++ b/shared-bindings/displayio/ColorConverter.h @@ -33,7 +33,10 @@ extern const mp_obj_type_t displayio_colorconverter_type; -void common_hal_displayio_colorconverter_construct(displayio_colorconverter_t* self); +void common_hal_displayio_colorconverter_construct(displayio_colorconverter_t* self, bool dither); void common_hal_displayio_colorconverter_convert(displayio_colorconverter_t *colorconverter, const _displayio_colorspace_t* colorspace, uint32_t input_color, uint32_t* output_color); +void common_hal_displayio_colorconverter_set_dither(displayio_colorconverter_t* self, bool dither); +bool common_hal_displayio_colorconverter_get_dither(displayio_colorconverter_t* self); + #endif // MICROPY_INCLUDED_SHARED_BINDINGS_DISPLAYIO_COLORCONVERTER_H diff --git a/shared-bindings/displayio/Display.c b/shared-bindings/displayio/Display.c index 58d5e5123..5ce7b3581 100644 --- a/shared-bindings/displayio/Display.c +++ b/shared-bindings/displayio/Display.c @@ -346,31 +346,7 @@ const mp_obj_property_t displayio_display_auto_brightness_obj = { (mp_obj_t)&mp_const_none_obj}, }; -//| .. attribute:: dither -//| -//| True when the display is dithered -//| -STATIC mp_obj_t displayio_display_obj_get_dither(mp_obj_t self_in) { - displayio_display_obj_t *self = native_display(self_in); - return mp_obj_new_bool(common_hal_displayio_display_get_dither(self)); -} -MP_DEFINE_CONST_FUN_OBJ_1(displayio_display_get_dither_obj, displayio_display_obj_get_dither); - -STATIC mp_obj_t displayio_display_obj_set_dither(mp_obj_t self_in, mp_obj_t dither) { - displayio_display_obj_t *self = native_display(self_in); - - common_hal_displayio_display_set_dither(self, mp_obj_is_true(dither)); - return mp_const_none; -} -MP_DEFINE_CONST_FUN_OBJ_2(displayio_display_set_dither_obj, displayio_display_obj_set_dither); - -const mp_obj_property_t displayio_display_dither_obj = { - .base.type = &mp_type_property, - .proxy = {(mp_obj_t)&displayio_display_get_dither_obj, - (mp_obj_t)&displayio_display_set_dither_obj, - (mp_obj_t)&mp_const_none_obj}, -}; //| .. attribute:: width @@ -514,7 +490,6 @@ STATIC const mp_rom_map_elem_t displayio_display_locals_dict_table[] = { { MP_ROM_QSTR(MP_QSTR_brightness), MP_ROM_PTR(&displayio_display_brightness_obj) }, { MP_ROM_QSTR(MP_QSTR_auto_brightness), MP_ROM_PTR(&displayio_display_auto_brightness_obj) }, - { MP_ROM_QSTR(MP_QSTR_dither), MP_ROM_PTR(&displayio_display_dither_obj) }, { MP_ROM_QSTR(MP_QSTR_width), MP_ROM_PTR(&displayio_display_width_obj) }, { MP_ROM_QSTR(MP_QSTR_height), MP_ROM_PTR(&displayio_display_height_obj) }, diff --git a/shared-module/displayio/ColorConverter.c b/shared-module/displayio/ColorConverter.c index 304d13a01..a5d7f0b05 100644 --- a/shared-module/displayio/ColorConverter.c +++ b/shared-module/displayio/ColorConverter.c @@ -39,7 +39,8 @@ uint32_t displayio_colorconverter_dither_noise_2(uint32_t x, uint32_t y) { return displayio_colorconverter_dither_noise_1(x + y * 0xFFFF); } -void common_hal_displayio_colorconverter_construct(displayio_colorconverter_t* self) { +void common_hal_displayio_colorconverter_construct(displayio_colorconverter_t* self, bool dither) { + self->dither = dither; } uint16_t displayio_colorconverter_compute_rgb565(uint32_t color_rgb888) { @@ -121,10 +122,18 @@ void common_hal_displayio_colorconverter_convert(displayio_colorconverter_t *sel (*output_color) = output_pixel.pixel; } +void common_hal_displayio_colorconverter_set_dither(displayio_colorconverter_t* self, bool dither) { + self->dither = dither; +} + +bool common_hal_displayio_colorconverter_get_dither(displayio_colorconverter_t* self) { + return self->dither; +} + void displayio_colorconverter_convert(displayio_colorconverter_t *self, const _displayio_colorspace_t* colorspace, const displayio_input_pixel_t *input_pixel, displayio_output_pixel_t *output_color) { uint32_t pixel = input_pixel->pixel; - if (colorspace->dither){ + if (self->dither){ uint8_t randr = (displayio_colorconverter_dither_noise_2(input_pixel->tile_x,input_pixel->tile_y)); uint8_t randg = (displayio_colorconverter_dither_noise_2(input_pixel->tile_x+33,input_pixel->tile_y)); uint8_t randb = (displayio_colorconverter_dither_noise_2(input_pixel->tile_x,input_pixel->tile_y+33)); @@ -172,6 +181,8 @@ void displayio_colorconverter_convert(displayio_colorconverter_t *self, const _d output_color->opaque = false; } + + // Currently no refresh logic is needed for a ColorConverter. bool displayio_colorconverter_needs_refresh(displayio_colorconverter_t *self) { return false; @@ -179,3 +190,4 @@ bool displayio_colorconverter_needs_refresh(displayio_colorconverter_t *self) { void displayio_colorconverter_finish_refresh(displayio_colorconverter_t *self) { } + diff --git a/shared-module/displayio/ColorConverter.h b/shared-module/displayio/ColorConverter.h index 3657df168..10b1604a4 100644 --- a/shared-module/displayio/ColorConverter.h +++ b/shared-module/displayio/ColorConverter.h @@ -35,6 +35,7 @@ typedef struct { mp_obj_base_t base; + bool dither; } displayio_colorconverter_t; bool displayio_colorconverter_needs_refresh(displayio_colorconverter_t *self); diff --git a/shared-module/displayio/Display.c b/shared-module/displayio/Display.c index 03185dffc..f210a80c3 100644 --- a/shared-module/displayio/Display.c +++ b/shared-module/displayio/Display.c @@ -150,14 +150,6 @@ void common_hal_displayio_display_set_auto_brightness(displayio_display_obj_t* s self->auto_brightness = auto_brightness; } -void common_hal_displayio_display_set_dither(displayio_display_obj_t* self, bool dither) { - displayio_display_core_set_dither(&self->core, dither); -} - -bool common_hal_displayio_display_get_dither(displayio_display_obj_t* self) { - return displayio_display_core_get_dither(&self->core); -} - mp_float_t common_hal_displayio_display_get_brightness(displayio_display_obj_t* self) { return self->current_brightness; } -- cgit v1.2.3 From 8768896d6b0ddb35568ad996781a33fd3a0df94f Mon Sep 17 00:00:00 2001 From: jepler Date: Sun, 8 Sep 2019 21:17:36 -0500 Subject: audiomixer: Supply constants in a way "-Og" optimization expects These arguments are constrained to be compile-time constants, a fact that gcc complains about under "-Og" optimization, but not in normal builds. Declare them as enumerated types --- shared-module/audiomixer/Mixer.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'shared-module') diff --git a/shared-module/audiomixer/Mixer.c b/shared-module/audiomixer/Mixer.c index e0fb4fab8..a52489f85 100644 --- a/shared-module/audiomixer/Mixer.c +++ b/shared-module/audiomixer/Mixer.c @@ -262,8 +262,8 @@ static inline uint32_t mult16signed(uint32_t val, int32_t mul) { } #if (defined (__ARM_ARCH_7EM__) && (__ARM_ARCH_7EM__ == 1)) //Cortex-M4 w/FPU int32_t hi, lo; - int32_t bits = 16; // saturate to 16 bits - int32_t shift = 0; // shift is done automatically + enum { bits = 16 }; // saturate to 16 bits + enum { shift = 0 }; // shift is done automatically asm volatile("smulwb %0, %1, %2" : "=r" (lo) : "r" (mul), "r" (val)); asm volatile("smulwt %0, %1, %2" : "=r" (hi) : "r" (mul), "r" (val)); asm volatile("ssat %0, %1, %2, asr %3" : "=r" (lo) : "I" (bits), "r" (lo), "I" (shift)); -- cgit v1.2.3 From 82427612d15ac85d0a34132ace7f8369dacd66ef Mon Sep 17 00:00:00 2001 From: jepler Date: Sun, 8 Sep 2019 21:58:36 -0500 Subject: WaveFile: Return GET_BUFFER_ERROR if wrong amount read Closes: #2128 --- shared-module/audiocore/WaveFile.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'shared-module') diff --git a/shared-module/audiocore/WaveFile.c b/shared-module/audiocore/WaveFile.c index df5d4b61d..0248d42e2 100644 --- a/shared-module/audiocore/WaveFile.c +++ b/shared-module/audiocore/WaveFile.c @@ -216,7 +216,7 @@ audioio_get_buffer_result_t audioio_wavefile_get_buffer(audioio_wavefile_obj_t* } else { *buffer = self->buffer; } - if (f_read(&self->file->fp, *buffer, num_bytes_to_load, &length_read) != FR_OK) { + if (f_read(&self->file->fp, *buffer, num_bytes_to_load, &length_read) != FR_OK || length_read != num_bytes_to_load) { return GET_BUFFER_ERROR; } self->bytes_remaining -= length_read; -- cgit v1.2.3