static void
copy_to_hw_buffer(struct weston_output *output, pixman_region32_t *region)
{
struct pixman_output_state *po = get_output_state(output);
pixman_region32_t output_region;
pixman_region32_init(&output_region);
pixman_region32_copy(&output_region, region);
region_global_to_output(output, &output_region);
pixman_image_set_clip_region32 (po->hw_buffer, &output_region);
pixman_image_composite32(PIXMAN_OP_SRC,
po->shadow_image, /* src */
NULL /* mask */,
po->hw_buffer, /* dest */
0, 0, /* src_x, src_y */
0, 0, /* mask_x, mask_y */
0, 0, /* dest_x, dest_y */
pixman_image_get_width (po->hw_buffer), /* width */
pixman_image_get_height (po->hw_buffer) /* height */);
pixman_image_set_clip_region32 (po->hw_buffer, NULL);
}
WL_EXPORT void
pixman_renderer_output_set_buffer(struct weston_output *output, pixman_image_t *buffer)
{
struct pixman_output_state *po = get_output_state(output);
if (po->hw_buffer)
pixman_image_unref(po->hw_buffer);
po->hw_buffer = buffer;
if (po->hw_buffer) {
output->compositor->read_format = pixman_image_get_format(po->hw_buffer);
pixman_image_ref(po->hw_buffer);
}
}
WL_EXPORT void
pixman_renderer_output_destroy(struct weston_output *output)
{
struct pixman_output_state *po = get_output_state(output);
pixman_image_unref(po->shadow_image);
if (po->hw_buffer)
pixman_image_unref(po->hw_buffer);
po->shadow_image = NULL;
po->hw_buffer = NULL;
free(po);
}
static void
pixman_renderer_repaint_output(struct weston_output *output,
pixman_region32_t *output_damage)
{
struct pixman_output_state *po = get_output_state(output);
if (!po->hw_buffer)
return;
repaint_surfaces(output, output_damage);
copy_to_hw_buffer(output, output_damage);
pixman_region32_copy(&output->previous_damage, output_damage);
wl_signal_emit(&output->frame_signal, output);
/* Actual flip should be done by caller */
}
static int
pixman_renderer_read_pixels(struct weston_output *output,
pixman_format_code_t format, void *pixels,
uint32_t x, uint32_t y,
uint32_t width, uint32_t height)
{
struct pixman_output_state *po = get_output_state(output);
pixman_transform_t transform;
pixman_image_t *out_buf;
if (!po->hw_buffer) {
errno = ENODEV;
return -1;
}
out_buf = pixman_image_create_bits(format,
width,
height,
pixels,
(PIXMAN_FORMAT_BPP(format) / 8) * width);
/* Caller expects vflipped source image */
pixman_transform_init_translate(&transform,
pixman_int_to_fixed (x),
pixman_int_to_fixed (y - pixman_image_get_height (po->hw_buffer)));
pixman_transform_scale(&transform, NULL,
pixman_fixed_1,
pixman_fixed_minus_1);
pixman_image_set_transform(po->hw_buffer, &transform);
pixman_image_composite32(PIXMAN_OP_SRC,
po->hw_buffer, /* src */
NULL /* mask */,
out_buf, /* dest */
0, 0, /* src_x, src_y */
0, 0, /* mask_x, mask_y */
0, 0, /* dest_x, dest_y */
pixman_image_get_width (po->hw_buffer), /* width */
pixman_image_get_height (po->hw_buffer) /* height */);
pixman_image_set_transform(po->hw_buffer, NULL);
pixman_image_unref(out_buf);
return 0;
}
static void
repaint_region(struct weston_view *ev, struct weston_output *output,
pixman_region32_t *region, pixman_region32_t *surf_region,
pixman_op_t pixman_op)
{
struct pixman_renderer *pr =
(struct pixman_renderer *) output->compositor->renderer;
struct pixman_surface_state *ps = get_surface_state(ev->surface);
struct pixman_output_state *po = get_output_state(output);
pixman_region32_t final_region;
float view_x, view_y;
pixman_transform_t transform;
pixman_fixed_t fw, fh;
/* The final region to be painted is the intersection of
* 'region' and 'surf_region'. However, 'region' is in the global
* coordinates, and 'surf_region' is in the surface-local
* coordinates
*/
pixman_region32_init(&final_region);
if (surf_region) {
pixman_region32_copy(&final_region, surf_region);
/* Convert from surface to global coordinates */
if (!ev->transform.enabled) {
pixman_region32_translate(&final_region, ev->geometry.x, ev->geometry.y);
} else {
weston_view_to_global_float(ev, 0, 0, &view_x, &view_y);
pixman_region32_translate(&final_region, (int)view_x, (int)view_y);
}
/* We need to paint the intersection */
pixman_region32_intersect(&final_region, &final_region, region);
} else {
/* If there is no surface region, just use the global region */
pixman_region32_copy(&final_region, region);
}
/* Convert from global to output coord */
region_global_to_output(output, &final_region);
/* And clip to it */
pixman_image_set_clip_region32 (po->shadow_image, &final_region);
/* Set up the source transformation based on the surface
position, the output position/transform/scale and the client
specified buffer transform/scale */
pixman_transform_init_identity(&transform);
pixman_transform_scale(&transform, NULL,
pixman_double_to_fixed ((double)1.0/output->current_scale),
pixman_double_to_fixed ((double)1.0/output->current_scale));
fw = pixman_int_to_fixed(output->width);
fh = pixman_int_to_fixed(output->height);
switch (output->transform) {
default:
case WL_OUTPUT_TRANSFORM_NORMAL:
case WL_OUTPUT_TRANSFORM_FLIPPED:
break;
case WL_OUTPUT_TRANSFORM_90:
case WL_OUTPUT_TRANSFORM_FLIPPED_90:
pixman_transform_rotate(&transform, NULL, 0, -pixman_fixed_1);
pixman_transform_translate(&transform, NULL, 0, fh);
break;
case WL_OUTPUT_TRANSFORM_180:
case WL_OUTPUT_TRANSFORM_FLIPPED_180:
pixman_transform_rotate(&transform, NULL, -pixman_fixed_1, 0);
pixman_transform_translate(&transform, NULL, fw, fh);
break;
case WL_OUTPUT_TRANSFORM_270:
case WL_OUTPUT_TRANSFORM_FLIPPED_270:
pixman_transform_rotate(&transform, NULL, 0, pixman_fixed_1);
pixman_transform_translate(&transform, NULL, fw, 0);
break;
}
switch (output->transform) {
case WL_OUTPUT_TRANSFORM_FLIPPED:
case WL_OUTPUT_TRANSFORM_FLIPPED_90:
case WL_OUTPUT_TRANSFORM_FLIPPED_180:
case WL_OUTPUT_TRANSFORM_FLIPPED_270:
pixman_transform_scale(&transform, NULL,
pixman_int_to_fixed (-1),
pixman_int_to_fixed (1));
pixman_transform_translate(&transform, NULL, fw, 0);
break;
}
pixman_transform_translate(&transform, NULL,
pixman_double_to_fixed (output->x),
pixman_double_to_fixed (output->y));
if (ev->transform.enabled) {
/* Pixman supports only 2D transform matrix, but Weston uses 3D,
* so we're omitting Z coordinate here
*/
pixman_transform_t surface_transform = {{
{ D2F(ev->transform.matrix.d[0]),
D2F(ev->transform.matrix.d[4]),
D2F(ev->transform.matrix.d[12]),
},
{ D2F(ev->transform.matrix.d[1]),
D2F(ev->transform.matrix.d[5]),
D2F(ev->transform.matrix.d[13]),
},
{ D2F(ev->transform.matrix.d[3]),
D2F(ev->transform.matrix.d[7]),
D2F(ev->transform.matrix.d[15]),
}
}};
pixman_transform_invert(&surface_transform, &surface_transform);
pixman_transform_multiply (&transform, &surface_transform, &transform);
} else {
pixman_transform_translate(&transform, NULL,
pixman_double_to_fixed ((double)-ev->geometry.x),
pixman_double_to_fixed ((double)-ev->geometry.y));
}
if (ev->surface->buffer_viewport.scaler_set) {
double scaler_x, scaler_y, scaler_width, scaler_height;
double ratio_x, ratio_y;
scaler_x = wl_fixed_to_double(ev->surface->buffer_viewport.src_x);
scaler_y = wl_fixed_to_double(ev->surface->buffer_viewport.src_y);
scaler_width = wl_fixed_to_double(ev->surface->buffer_viewport.src_width);
scaler_height = wl_fixed_to_double(ev->surface->buffer_viewport.src_height);
ratio_x = scaler_width / ev->surface->buffer_viewport.dst_width;
ratio_y = scaler_height / ev->surface->buffer_viewport.dst_height;
pixman_transform_scale(&transform, NULL,
pixman_double_to_fixed(ratio_x),
pixman_double_to_fixed(ratio_y));
pixman_transform_translate(&transform, NULL, pixman_double_to_fixed(scaler_x),
pixman_double_to_fixed(scaler_y));
}
pixman_transform_scale(&transform, NULL,
pixman_double_to_fixed(ev->surface->buffer_viewport.scale),
pixman_double_to_fixed(ev->surface->buffer_viewport.scale));
fw = pixman_int_to_fixed(pixman_image_get_width(ps->image));
fh = pixman_int_to_fixed(pixman_image_get_height(ps->image));
switch (ev->surface->buffer_viewport.transform) {
case WL_OUTPUT_TRANSFORM_FLIPPED:
case WL_OUTPUT_TRANSFORM_FLIPPED_90:
case WL_OUTPUT_TRANSFORM_FLIPPED_180:
case WL_OUTPUT_TRANSFORM_FLIPPED_270:
pixman_transform_scale(&transform, NULL,
pixman_int_to_fixed (-1),
pixman_int_to_fixed (1));
pixman_transform_translate(&transform, NULL, fw, 0);
break;
}
switch (ev->surface->buffer_viewport.transform) {
default:
case WL_OUTPUT_TRANSFORM_NORMAL:
case WL_OUTPUT_TRANSFORM_FLIPPED:
break;
case WL_OUTPUT_TRANSFORM_90:
case WL_OUTPUT_TRANSFORM_FLIPPED_90:
pixman_transform_rotate(&transform, NULL, 0, pixman_fixed_1);
pixman_transform_translate(&transform, NULL, fh, 0);
break;
case WL_OUTPUT_TRANSFORM_180:
case WL_OUTPUT_TRANSFORM_FLIPPED_180:
pixman_transform_rotate(&transform, NULL, -pixman_fixed_1, 0);
pixman_transform_translate(&transform, NULL, fw, fh);
break;
case WL_OUTPUT_TRANSFORM_270:
case WL_OUTPUT_TRANSFORM_FLIPPED_270:
pixman_transform_rotate(&transform, NULL, 0, -pixman_fixed_1);
pixman_transform_translate(&transform, NULL, 0, fw);
break;
}
pixman_image_set_transform(ps->image, &transform);
if (ev->transform.enabled || output->current_scale != ev->surface->buffer_viewport.scale)
pixman_image_set_filter(ps->image, PIXMAN_FILTER_BILINEAR, NULL, 0);
else
pixman_image_set_filter(ps->image, PIXMAN_FILTER_NEAREST, NULL, 0);
if (ps->buffer_ref.buffer)
wl_shm_buffer_begin_access(ps->buffer_ref.buffer->shm_buffer);
pixman_image_composite32(pixman_op,
ps->image, /* src */
NULL /* mask */,
po->shadow_image, /* dest */
0, 0, /* src_x, src_y */
0, 0, /* mask_x, mask_y */
0, 0, /* dest_x, dest_y */
pixman_image_get_width (po->shadow_image), /* width */
pixman_image_get_height (po->shadow_image) /* height */);
if (ps->buffer_ref.buffer)
wl_shm_buffer_end_access(ps->buffer_ref.buffer->shm_buffer);
if (pr->repaint_debug)
pixman_image_composite32(PIXMAN_OP_OVER,
pr->debug_color, /* src */
NULL /* mask */,
po->shadow_image, /* dest */
0, 0, /* src_x, src_y */
0, 0, /* mask_x, mask_y */
0, 0, /* dest_x, dest_y */
pixman_image_get_width (po->shadow_image), /* width */
pixman_image_get_height (po->shadow_image) /* height */);
pixman_image_set_clip_region32 (po->shadow_image, NULL);
pixman_region32_fini(&final_region);
}
/** Paint an intersected region
*
* \param ev The view to be painted.
* \param output The output being painted.
* \param repaint_output The region to be painted in output coordinates.
* \param source_clip The region of the source image to use, in source image
* coordinates. If NULL, use the whole source image.
* \param pixman_op Compositing operator, either SRC or OVER.
*/
static void
repaint_region(struct weston_view *ev, struct weston_output *output,
pixman_region32_t *repaint_output,
pixman_region32_t *source_clip,
pixman_op_t pixman_op)
{
struct pixman_renderer *pr =
(struct pixman_renderer *) output->compositor->renderer;
struct pixman_surface_state *ps = get_surface_state(ev->surface);
struct pixman_output_state *po = get_output_state(output);
struct weston_buffer_viewport *vp = &ev->surface->buffer_viewport;
pixman_transform_t transform;
pixman_filter_t filter;
pixman_image_t *mask_image;
pixman_color_t mask = { 0, };
/* Clip rendering to the damaged output region */
pixman_image_set_clip_region32(po->shadow_image, repaint_output);
pixman_renderer_compute_transform(&transform, ev, output);
if (ev->transform.enabled || output->current_scale != vp->buffer.scale)
filter = PIXMAN_FILTER_BILINEAR;
else
filter = PIXMAN_FILTER_NEAREST;
if (ps->buffer_ref.buffer)
wl_shm_buffer_begin_access(ps->buffer_ref.buffer->shm_buffer);
if (ev->alpha < 1.0) {
mask.alpha = 0xffff * ev->alpha;
mask_image = pixman_image_create_solid_fill(&mask);
} else {
mask_image = NULL;
}
if (source_clip)
composite_clipped(ps->image, mask_image, po->shadow_image,
&transform, filter, source_clip);
else
composite_whole(pixman_op, ps->image, mask_image,
po->shadow_image, &transform, filter);
if (mask_image)
pixman_image_unref(mask_image);
if (ps->buffer_ref.buffer)
wl_shm_buffer_end_access(ps->buffer_ref.buffer->shm_buffer);
if (pr->repaint_debug)
pixman_image_composite32(PIXMAN_OP_OVER,
pr->debug_color, /* src */
NULL /* mask */,
po->shadow_image, /* dest */
0, 0, /* src_x, src_y */
0, 0, /* mask_x, mask_y */
0, 0, /* dest_x, dest_y */
pixman_image_get_width (po->shadow_image), /* width */
pixman_image_get_height (po->shadow_image) /* height */);
pixman_image_set_clip_region32 (po->shadow_image, NULL);
}
uint8_t execute_pdu(pdu_type *pdu) {
switch (pdu->opcode) {
case OPCODE_GET_TYPE: {
pdu->number_of_arguments = 1;
pdu->arguments[0] = MODULE_TYPE;
break;
}
case OPCODE_GET_ID: {
pdu->number_of_arguments = 1;
pdu->arguments[0] = get_module_id();
break;
}
case OPCODE_GET_FW_VERSION: {
pdu->number_of_arguments = 3;
pdu->arguments[0] = FIRMWARE_MAJOR;
pdu->arguments[1] = FIRMWARE_MINOR;
pdu->arguments[2] = FIRMWARE_PATCHLEVEL;
break;
}
case OPCODE_GET_NR_CHANNELS: {
pdu->number_of_arguments = 1;
pdu->arguments[0] = NUM_CHANNELS;
break;
}
case OPCODE_GET_FEATURES: {
pdu->number_of_arguments = 1;
pdu->arguments[0] = 0;
break;
}
case OPCODE_GET_SW_THRESHOLD: {
pdu->number_of_arguments = 1;
pdu->arguments[0] = get_switch_threshold();
break;
}
case OPCODE_GET_DIMMER_THRESHOLD: {
pdu->number_of_arguments = 1;
pdu->arguments[0] = get_long_press_threshold();
break;
}
case OPCODE_GET_DIMMER_DELAY: {
pdu->number_of_arguments = 1;
pdu->arguments[0] = get_dimmer_delay();
break;
}
case OPCODE_GET_SW_TIMER: {
if (pdu->number_of_arguments == 1) {
uint8_t channel_number = pdu->arguments[0];
if (is_valid_channel(channel_number)) {
uint16_t channel_timer = get_switch_timer(channel_number);
pdu->number_of_arguments = 1;
pdu->arguments[0] = channel_timer;
} else {
return ERROR_INVALID_CHANNEL_NUMBER;
}
} else {
return ERROR_WRONG_NUMBER_OF_ARGUMENTS;
}
break;
}
case OPCODE_GET_CHANNEL_MAPPING: {
if (pdu->number_of_arguments == 1) {
uint8_t channel_number = pdu->arguments[0];
if (is_valid_channel(channel_number)) {
uint8_t channel_mapping = get_switch_mapping(channel_number);
pdu->number_of_arguments = 1;
pdu->arguments[0] = channel_mapping;
} else {
return ERROR_INVALID_CHANNEL_NUMBER;
}
} else {
return ERROR_WRONG_NUMBER_OF_ARGUMENTS;
}
break;
}
case OPCODE_GET_DEFAULT_STATE: {
if (pdu->number_of_arguments == 1) {
uint8_t channel_number = pdu->arguments[0];
if (is_valid_channel(channel_number)) {
uint8_t channel_state = get_default_channel_state(channel_number);
pdu->number_of_arguments = 1;
pdu->arguments[0] = channel_state;
} else {
return ERROR_INVALID_CHANNEL_NUMBER;
}
} else {
return ERROR_WRONG_NUMBER_OF_ARGUMENTS;
}
break;
}
case OPCODE_GET_DEFAULT_PERCENTAGE: {
if (pdu->number_of_arguments == 1) {
uint8_t channel_number = pdu->arguments[0];
if (is_valid_channel(channel_number)) {
uint8_t percentage = get_default_dimmer_percentage(channel_number);
pdu->number_of_arguments = 1;
pdu->arguments[0] = percentage;
} else {
return ERROR_INVALID_CHANNEL_NUMBER;
}
} else {
return ERROR_WRONG_NUMBER_OF_ARGUMENTS;
}
break;
}
case OPCODE_GET_DEFAULT_DIMMER_DIRECTION: {
if (pdu->number_of_arguments == 1) {
uint8_t channel_number = pdu->arguments[0];
if (is_valid_channel(channel_number)) {
uint8_t direction = get_default_dimmer_direction(channel_number);
pdu->number_of_arguments = 1;
pdu->arguments[0] = direction;
} else {
return ERROR_INVALID_CHANNEL_NUMBER;
}
} else {
return ERROR_WRONG_NUMBER_OF_ARGUMENTS;
}
break;
}
case OPCODE_SET_SW_THRESHOLD: {
if (pdu->number_of_arguments == 1) {
uint16_t threshold = pdu->arguments[0];
set_switch_threshold(threshold);
pdu->number_of_arguments = 0;
} else {
return ERROR_WRONG_NUMBER_OF_ARGUMENTS;
}
break;
}
case OPCODE_SET_DIMMER_DELAY: {
if (pdu->number_of_arguments == 1) {
uint8_t delay = pdu->arguments[0];
set_dimmer_delay(delay);
pdu->number_of_arguments = 0;
} else {
return ERROR_WRONG_NUMBER_OF_ARGUMENTS;
}
break;
}
case OPCODE_SET_DIMMER_THRESHOLD: {
if (pdu->number_of_arguments == 1) {
uint16_t threshold = pdu->arguments[0];
set_long_press_threshold(threshold);
pdu->number_of_arguments = 0;
} else {
return ERROR_WRONG_NUMBER_OF_ARGUMENTS;
}
break;
}
case OPCODE_SET_SW_TIMER: {
if (pdu->number_of_arguments == 2) {
uint8_t channel_number = pdu->arguments[0];
uint16_t timer = pdu->arguments[1];
if (is_valid_channel(channel_number)) {
set_switch_timer(channel_number, timer);
pdu->number_of_arguments = 0;
} else {
return ERROR_WRONG_NUMBER_OF_ARGUMENTS;
}
} else {
return ERROR_WRONG_NUMBER_OF_ARGUMENTS;
}
break;
}
case OPCODE_SET_CHANNEL_MAPPING: {
if (pdu->number_of_arguments == 2) {
uint8_t channel_number = pdu->arguments[0];
uint8_t mapping = pdu->arguments[1];
if (is_valid_channel(channel_number) && is_valid_channel(mapping)) {
set_switch_mapping(channel_number, mapping);
pdu->number_of_arguments = 0;
} else {
return ERROR_WRONG_NUMBER_OF_ARGUMENTS;
}
} else {
return ERROR_WRONG_NUMBER_OF_ARGUMENTS;
}
break;
}
case OPCODE_SET_DEFAULT_STATE: {
if (pdu->number_of_arguments == 2) {
uint8_t channel_number = pdu->arguments[0];
uint8_t default_state = pdu->arguments[1];
if (is_valid_channel(channel_number)) {
if (default_state == 0 || default_state == 1) {
set_default_channel_state(channel_number, default_state);
pdu->number_of_arguments = 0;
} else {
return ERROR_INVALID_STATE;
}
} else {
return ERROR_WRONG_NUMBER_OF_ARGUMENTS;
}
} else {
return ERROR_WRONG_NUMBER_OF_ARGUMENTS;
}
break;
}
case OPCODE_SET_DEFAULT_PERCENTAGE: {
if (pdu->number_of_arguments == 2) {
uint8_t channel_number = pdu->arguments[0];
uint8_t default_percentage = pdu->arguments[1];
if (is_valid_channel(channel_number)) {
if (default_percentage >= 0 || default_percentage <= 100) {
set_default_dimmer_percentage(channel_number, default_percentage);
pdu->number_of_arguments = 0;
} else {
return ERROR_INVALID_PERCENTAGE;
}
} else {
return ERROR_WRONG_NUMBER_OF_ARGUMENTS;
}
} else {
return ERROR_WRONG_NUMBER_OF_ARGUMENTS;
}
break;
}
case OPCODE_SET_DEFAULT_DIMMER_DIRECTION: {
if (pdu->number_of_arguments == 2) {
uint8_t channel_number = pdu->arguments[0];
uint8_t default_direction = pdu->arguments[1];
if (is_valid_channel(channel_number)) {
if (default_direction == 0 || default_direction == 1) {
set_default_dimmer_direction(channel_number, default_direction);
pdu->number_of_arguments = 0;
} else {
return ERROR_INVALID_STATE;
}
} else {
return ERROR_WRONG_NUMBER_OF_ARGUMENTS;
}
} else {
return ERROR_WRONG_NUMBER_OF_ARGUMENTS;
}
break;
}
case OPCODE_RELOAD_CONFIGURATION: {
configuration_load();
pdu->number_of_arguments = 0;
break;
}
case OPCODE_SAVE_CONFIGURATION: {
configuration_save();
pdu->number_of_arguments = 0;
break;
}
case OPCODE_GET_OUTPUT_STATE: {
if (pdu->number_of_arguments == 1) {
uint8_t channel_number = pdu->arguments[0];
if (is_valid_channel(channel_number)) {
uint8_t output_state = get_output_state(channel_number);
pdu->number_of_arguments = 2;
pdu->arguments[0] = output_state;
pdu->arguments[1] = get_percentage(channel_number);
} else {
return ERROR_INVALID_CHANNEL_NUMBER;
}
} else {
return ERROR_WRONG_NUMBER_OF_ARGUMENTS;
}
break;
}
case OPCODE_GET_INPUT_STATE: {
if (pdu->number_of_arguments == 1) {
uint8_t channel_number = pdu->arguments[0];
if (is_valid_channel(channel_number)) {
uint8_t switch_state = get_switch_state(channel_number);
pdu->number_of_arguments = 1;
pdu->arguments[0] = switch_state;
} else {
return ERROR_INVALID_CHANNEL_NUMBER;
}
} else {
return ERROR_WRONG_NUMBER_OF_ARGUMENTS;
}
break;
}
case OPCODE_SWITCH_OUTPUT: {
if (pdu->number_of_arguments == 2) {
uint8_t channel_number = pdu->arguments[0];
if (is_valid_channel(channel_number)) {
uint8_t new_state = pdu->arguments[1];
if (new_state == STATE_OFF || new_state == STATE_ON) {
switch_output(channel_number, new_state);
pdu->number_of_arguments = 0;
} else {
return ERROR_INVALID_STATE;
}
} else {
return ERROR_INVALID_CHANNEL_NUMBER;
}
} else {
return ERROR_WRONG_NUMBER_OF_ARGUMENTS;
}
break;
}
case OPCODE_DIM: {
if (pdu->number_of_arguments == 2) {
uint8_t channel_number = pdu->arguments[0];
if (is_valid_channel(channel_number)) {
uint8_t percentage = pdu->arguments[1];
if (percentage >= 0 || percentage <= 100) {
dim(channel_number, percentage);
pdu->number_of_arguments = 0;
} else {
return ERROR_INVALID_PERCENTAGE;
}
} else {
return ERROR_INVALID_CHANNEL_NUMBER;
}
} else {
return ERROR_WRONG_NUMBER_OF_ARGUMENTS;
}
break;
}
default: {
return ERROR_INVALID_OPCODE;
}
}
return 0;
}
