guacamole-spice-protocol/src/guacenc/buffer.c

172 lines
4.8 KiB
C
Raw Normal View History

/*
2016-03-25 19:59:40 +00:00
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
2016-03-25 19:59:40 +00:00
* http://www.apache.org/licenses/LICENSE-2.0
*
2016-03-25 19:59:40 +00:00
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
#include "config.h"
#include "buffer.h"
2016-02-27 18:07:55 +00:00
#include <cairo/cairo.h>
#include <assert.h>
#include <stdlib.h>
guacenc_buffer* guacenc_buffer_alloc() {
return calloc(1, sizeof(guacenc_buffer));
}
2016-02-27 18:07:55 +00:00
/**
* Frees the underlying image data, surface, and graphics context of the given
* buffer, marking each as unallocated.
*
* @param buffer
* The guacenc_buffer whose image data, surface, and graphics context
* should be freed.
*/
static void guacenc_buffer_free_image(guacenc_buffer* buffer) {
/* Free graphics context */
if (buffer->cairo != NULL) {
cairo_destroy(buffer->cairo);
buffer->cairo = NULL;
}
/* Free Cairo surface */
if (buffer->surface != NULL) {
cairo_surface_destroy(buffer->surface);
buffer->surface = NULL;
}
/* Free image data (previously wrapped by Cairo surface */
free(buffer->image);
buffer->image = NULL;
}
void guacenc_buffer_free(guacenc_buffer* buffer) {
/* Ignore NULL buffer */
if (buffer == NULL)
return;
/* Free buffer and underlying image */
2016-02-27 18:07:55 +00:00
guacenc_buffer_free_image(buffer);
free(buffer);
}
int guacenc_buffer_resize(guacenc_buffer* buffer, int width, int height) {
/* Ignore requests which do not change the size */
if (buffer->width == width && buffer->height == height)
return 0;
2016-02-27 18:07:55 +00:00
/* Simply deallocate if new image has absolutely no pixels */
if (width == 0 || height == 0) {
guacenc_buffer_free_image(buffer);
buffer->width = width;
buffer->height = height;
buffer->stride = 0;
return 0;
}
/* Allocate data for new image */
int stride = cairo_format_stride_for_width(CAIRO_FORMAT_ARGB32, width);
unsigned char* image = calloc(1, stride*height);
/* Wrap data in surface */
cairo_surface_t* surface = cairo_image_surface_create_for_data(image,
CAIRO_FORMAT_ARGB32, width, height, stride);
2016-02-27 18:07:55 +00:00
/* Obtain graphics context of new surface */
cairo_t* cairo = cairo_create(surface);
/* Copy old surface, if defined */
if (buffer->surface != NULL) {
cairo_set_operator(cairo, CAIRO_OPERATOR_SOURCE);
2016-02-27 18:07:55 +00:00
cairo_set_source_surface(cairo, buffer->surface, 0, 0);
cairo_set_operator(cairo, CAIRO_OPERATOR_OVER);
2016-02-27 18:07:55 +00:00
cairo_paint(cairo);
}
/* Update properties */
buffer->width = width;
buffer->height = height;
2016-02-27 18:07:55 +00:00
buffer->stride = stride;
/* Replace old image */
guacenc_buffer_free_image(buffer);
buffer->image = image;
buffer->surface = surface;
buffer->cairo = cairo;
return 0;
}
int guacenc_buffer_fit(guacenc_buffer* buffer, int x, int y) {
/* Increase width to fit X (if necessary) */
int new_width = buffer->width;
if (new_width < x+1)
new_width = x+1;
/* Increase height to fit Y (if necessary) */
int new_height = buffer->height;
if (new_height < y+1)
new_height = y+1;
/* Resize buffer if size needs to change to fit X/Y coordinate */
if (new_width != buffer->width || new_height != buffer->height)
return guacenc_buffer_resize(buffer, new_width, new_height);
/* No change necessary */
return 0;
}
int guacenc_buffer_copy(guacenc_buffer* dst, guacenc_buffer* src) {
/* Resize destination to exactly fit source */
if (guacenc_buffer_resize(dst, src->width, src->height))
return 1;
/* Copy surface contents identically */
if (src->surface != NULL) {
/* Destination must be non-NULL as its size is that of the source */
assert(dst->cairo != NULL);
/* Reset state of destination */
cairo_t* cairo = dst->cairo;
cairo_reset_clip(cairo);
/* Overwrite destination with contents of source */
cairo_set_operator(cairo, CAIRO_OPERATOR_SOURCE);
cairo_set_source_surface(cairo, src->surface, 0, 0);
cairo_paint(cairo);
/* Reset operator of destination to default */
cairo_set_operator(cairo, CAIRO_OPERATOR_OVER);
}
return 0;
}