#include <string.h>
#include <tbm_surface.h>
#include <tbm_surface_internal.h>
+#include <tbm_drm_helper.h>
#include <string.h>
#include <time.h>
#include <pixman.h>
+#include <inttypes.h>
#include "tdm.h"
#include "tdm_private.h"
return 0;
}
+static int
+_tdm_helper_check_file_is_valid(const char* path, int del_link)
+{
+ char *real_path;
+
+ if (!path)
+ return 0;
+
+ real_path = realpath(path, NULL);
+ if (real_path && strncmp(path, real_path, strlen(path))) {
+ if (del_link)
+ unlink(path);
+ free(real_path);
+
+ return 0;
+ }
+
+ if (real_path)
+ free(real_path);
+
+ return 1;
+}
+
static void
_tdm_helper_dump_raw(const char *file, void *data1, int size1, void *data2,
int size2, void *data3, int size3)
{
unsigned int *blocks;
- FILE *fp = fopen(file, "w+");
+ FILE *fp;
+
+ if (!_tdm_helper_check_file_is_valid(file, 1))
+ TDM_WRN("'%s' may be symbolic link\n", file);
+
+ fp = fopen(file, "w+");
TDM_RETURN_IF_FAIL(fp != NULL);
blocks = (unsigned int *)data1;
_tdm_helper_dump_png(const char *file, const void *data, int width,
int height)
{
- FILE *fp = fopen(file, "wb");
+ FILE *fp;
+
+ if (!_tdm_helper_check_file_is_valid(file, 1))
+ TDM_WRN("'%s' may be symbolic link\n", file);
+
+ fp = fopen(file, "wb");
TDM_RETURN_IF_FAIL(fp != NULL);
png_structp pPngStruct =
tbm_surface_info_s info;
const char *ext;
char file[TDM_PATH_LEN];
- int ret, bw;
+ int ret, bw, bh;
TDM_RETURN_IF_FAIL(buffer != NULL);
TDM_RETURN_IF_FAIL(dir != NULL);
ret = tbm_surface_get_info(buffer, &info);
TDM_RETURN_IF_FAIL(ret == TBM_SURFACE_ERROR_NONE);
- if (info.format == TBM_FORMAT_ARGB8888 || info.format == TBM_FORMAT_XRGB8888) {
+ if (IS_RGB(info.format))
ext = file_exts[0];
- bw = info.planes[0].stride >> 2;
- } else {
+ else
ext = file_exts[1];
- bw = info.planes[0].stride;
- }
- snprintf(file, TDM_PATH_LEN, "%s/%c%c%c%c_%dx%d_%s.%s",
- dir, FOURCC_STR(info.format), bw, info.height, str, ext);
+ tdm_helper_get_buffer_full_size(buffer, &bw, &bh);
+
+ snprintf(file, TDM_PATH_LEN, "%s/%c%c%c%c_%dx%d_%dx%d_%s.%s",
+ dir, FOURCC_STR(info.format), bw, bh, info.width, info.height, str, ext);
tdm_helper_dump_buffer(buffer, file);
}
tbm_surface_info_s info;
int len, ret;
const char *ext;
+ int bo_cnt;
+ int bw, bh;
TDM_RETURN_IF_FAIL(buffer != NULL);
TDM_RETURN_IF_FAIL(file != NULL);
TDM_RETURN_IF_FAIL(ret == TBM_SURFACE_ERROR_NONE);
len = strnlen(file, 1024);
- if (info.format == TBM_FORMAT_ARGB8888 || info.format == TBM_FORMAT_XRGB8888)
+ if (IS_RGB(info.format))
ext = file_exts[0];
else
ext = file_exts[1];
return;
}
+ tdm_helper_get_buffer_full_size(buffer, &bw, &bh);
+
+ bo_cnt = tbm_surface_internal_get_num_bos(buffer);
+ TDM_DBG("buffer: bo_cnt(%d) %dx%d(%dx%d) %c%c%c%c, plane: (%p+%d, %d,%d) (%p+%d, %d,%d) (%p+%d, %d,%d)",
+ bo_cnt, bw, bh, info.width, info.height, FOURCC_STR(info.format),
+ info.planes[0].ptr, info.planes[0].offset, info.planes[0].stride, info.planes[0].size,
+ info.planes[1].ptr, info.planes[1].offset, info.planes[1].stride, info.planes[1].size,
+ info.planes[2].ptr, info.planes[2].offset, info.planes[2].stride, info.planes[2].size);
+
switch (info.format) {
case TBM_FORMAT_ARGB8888:
case TBM_FORMAT_XRGB8888:
- _tdm_helper_dump_png(file, info.planes[0].ptr,
- info.planes[0].stride >> 2, info.height);
+ _tdm_helper_dump_png(file, info.planes[0].ptr, bw, bh);
break;
case TBM_FORMAT_YVU420:
case TBM_FORMAT_YUV420:
_tdm_helper_dump_raw(file,
info.planes[0].ptr,
- info.planes[0].stride * info.height,
+ info.planes[0].size,
info.planes[1].ptr,
- info.planes[1].stride * (info.height >> 1),
+ info.planes[1].size,
info.planes[2].ptr,
- info.planes[2].stride * (info.height >> 1));
+ info.planes[2].size);
break;
case TBM_FORMAT_NV12:
case TBM_FORMAT_NV21:
_tdm_helper_dump_raw(file,
info.planes[0].ptr,
- info.planes[0].stride * info.height,
+ info.planes[0].size,
info.planes[1].ptr,
- info.planes[1].stride * (info.height >> 1), NULL,
+ info.planes[1].size, NULL,
0);
break;
case TBM_FORMAT_YUYV:
case TBM_FORMAT_UYVY:
_tdm_helper_dump_raw(file,
info.planes[0].ptr,
- info.planes[0].stride * info.height, NULL, 0,
+ info.planes[0].size, NULL, 0,
NULL, 0);
break;
default:
TDM_INFO("dump %s", file);
}
-void
-tdm_helper_clear_buffer_pos(tbm_surface_h buffer, tdm_pos *pos)
+EXTERN void
+tdm_helper_clear_buffer_color(tbm_surface_h buffer, tdm_pos *pos, unsigned int color)
{
tbm_surface_info_s info;
int ret;
for (y = pos->y; y <= (pos->y + pos->h); y++) {
p = info.planes[0].ptr + info.planes[0].stride * y;
for (x = pos->x; x <= (pos->x + pos->w); x++) {
- int *ibuf = (int*)p;
- ibuf[x] = 0x00000000;
+ unsigned int *ibuf = (unsigned int*)p;
+ ibuf[x] = color;
}
}
}
}
EXTERN void
+tdm_helper_clear_buffer_pos(tbm_surface_h buffer, tdm_pos *pos)
+{
+ TDM_RETURN_IF_FAIL(buffer != NULL);
+
+ tdm_helper_clear_buffer_color(buffer, pos, 0);
+}
+
+EXTERN void
tdm_helper_clear_buffer(tbm_surface_h buffer)
{
TDM_RETURN_IF_FAIL(buffer != NULL);
tdm_helper_clear_buffer_pos(buffer, NULL);
}
+EXTERN void
+tdm_helper_get_buffer_full_size(tbm_surface_h buffer, int *buffer_w, int *buffer_h)
+{
+ tbm_surface_info_s info;
+ int ret;
+
+ TDM_RETURN_IF_FAIL(buffer != NULL);
+
+ ret = tbm_surface_get_info(buffer, &info);
+ TDM_RETURN_IF_FAIL(ret == TBM_SURFACE_ERROR_NONE);
+
+ if (buffer_w) {
+ if (IS_RGB(info.format))
+ *buffer_w = info.planes[0].stride >> 2;
+ else
+ *buffer_w = info.planes[0].stride;
+ }
+
+ if (buffer_h)
+ *buffer_h = info.planes[0].size / info.planes[0].stride;
+}
+
static pixman_format_code_t
_tdm_helper_pixman_format_get(tbm_format format)
{
EXTERN int
tdm_helper_get_fd(const char *env)
{
- const char *value;
- int fd, newfd, flags, ret;
-
- value = (const char*)getenv(env);
- if (!value)
- return -1;
-
- ret = sscanf(value, "%d", &fd);
- if (ret < 0) {
- TDM_ERR("sscanf failed: %m");
- return -1;
- }
-
- flags = fcntl(fd, F_GETFD);
- if (flags == -1) {
- TDM_ERR("fcntl failed: %m");
- return -1;
- }
-
- newfd = dup(fd);
- if (newfd < 0) {
- TDM_ERR("dup failed: %m");
- return -1;
- }
-
- TDM_INFO("%s: fd(%d) newfd(%d)", env, fd, newfd);
-
- ret = fcntl(newfd, F_SETFD, flags | FD_CLOEXEC);
- if (ret == -1) {
- TDM_ERR("fcntl failed: %m");
- close(newfd);
+ if (strncmp(env, "TBM_DRM_MASTER_FD", 17) && strncmp(env, "TDM_DRM_MASTER_FD", 17)) {
+ TDM_INFO("DEPRECATED! '%s'", env);
return -1;
}
- return newfd;
+ return tbm_drm_helper_get_master_fd();
}
EXTERN void
tdm_helper_set_fd(const char *env, int fd)
{
- char buf[32];
- int ret;
-
- snprintf(buf, sizeof(buf), "%d", fd);
-
- ret = setenv(env, (const char*)buf, 1);
- if (ret) {
- TDM_ERR("setenv failed: %m");
+ if (strncmp(env, "TBM_DRM_MASTER_FD", 17) && strncmp(env, "TDM_DRM_MASTER_FD", 17)) {
+ TDM_INFO("DEPRECATED! '%s'", env);
return;
}
- if (fd >= 0)
- TDM_INFO("%s: fd(%d)", env, fd);
+ tbm_drm_helper_set_tbm_master_fd(fd);
}
EXTERN void
private_display = dpy;
func_output = &private_display->func_output;
func_layer = &private_display->func_layer;
- _pthread_mutex_lock(&private_display->lock);
/* module information */
module_data = private_display->module_data;
if (private_output->caps.mode_count > 0) {
const tdm_output_mode *current_mode = NULL;
- TDM_DBG_GOTO_IF_FAIL(func_output->output_get_mode, unlock);
+ TDM_DBG_RETURN_IF_FAIL(func_output->output_get_mode);
ret = func_output->output_get_mode(private_output->output_backend, ¤t_mode);
- TDM_DBG_GOTO_IF_FAIL(ret == TDM_ERROR_NONE, unlock);
+ TDM_DBG_RETURN_IF_FAIL(ret == TDM_ERROR_NONE);
TDM_SNPRINTF(reply, len, "\t\t name refresh (Hz) clk hdisp hss hse htot vdisp vss vse vtot vscan\n");
for (i = 0; i < private_output->caps.mode_count; i++) {
TDM_SNPRINTF(reply, len, "\t%d properties:\n", private_output->caps.prop_count);
if (private_output->caps.prop_count > 0) {
- TDM_SNPRINTF(reply, len, "\t\tname\tidx\tvalue\n");
+ TDM_SNPRINTF(reply, len, "\t\tname\ttype\tidx\tvalue\n");
for (i = 0; i < private_output->caps.prop_count; i++) {
tdm_value value;
- TDM_DBG_GOTO_IF_FAIL(func_output->output_get_property, unlock);
+ TDM_DBG_RETURN_IF_FAIL(func_output->output_get_property);
ret = func_output->output_get_property(private_output->output_backend,
private_output->caps.props[i].id,
&value);
- TDM_DBG_GOTO_IF_FAIL(ret == TDM_ERROR_NONE, unlock);
- TDM_SNPRINTF(reply, len, "\t\t%s\t%u\t%u\n",
+ TDM_DBG_RETURN_IF_FAIL(ret == TDM_ERROR_NONE);
+ TDM_SNPRINTF(reply, len, "\t\t%s\t%s\t%u\t",
private_output->caps.props[i].name,
- private_output->caps.props[i].id,
- value.u32);
+ tdm_value_type_str(private_output->caps.props[i].type),
+ private_output->caps.props[i].id);
+ switch (private_output->caps.props[i].type) {
+ case TDM_VALUE_TYPE_PTR:
+ TDM_SNPRINTF(reply, len, "%p\n", value.ptr);
+ break;
+ case TDM_VALUE_TYPE_INT32:
+ TDM_SNPRINTF(reply, len, "%d\n", value.s32);
+ break;
+ case TDM_VALUE_TYPE_INT64:
+ TDM_SNPRINTF(reply, len, "%"PRId64"\n", value.s64);
+ break;
+ case TDM_VALUE_TYPE_UINT64:
+ TDM_SNPRINTF(reply, len, "%"PRIu64"\n", value.u64);
+ break;
+ case TDM_VALUE_TYPE_UINT32:
+ default:
+ TDM_SNPRINTF(reply, len, "%u\n", value.u32);
+ break;
+ }
}
}
}
tdm_size size;
tbm_surface_info_s buf_info;
- TDM_DBG_GOTO_IF_FAIL(func_layer->layer_get_info, unlock);
+ TDM_DBG_RETURN_IF_FAIL(func_layer->layer_get_info);
memset(&info, 0, sizeof info);
ret = func_layer->layer_get_info(private_layer->layer_backend, &info);
- TDM_DBG_GOTO_IF_FAIL(ret == TDM_ERROR_NONE, unlock);
+ TDM_DBG_RETURN_IF_FAIL(ret == TDM_ERROR_NONE);
- format = tbm_surface_get_format(private_layer->showing_buffer);
- tbm_surface_get_info(private_layer->showing_buffer, &buf_info);
+ if (!private_layer->showing_buffer)
+ continue;
+
+ format = tbm_surface_get_format(private_layer->showing_buffer->buffer);
+ tbm_surface_get_info(private_layer->showing_buffer->buffer, &buf_info);
if (IS_RGB(format))
size.h = buf_info.planes[0].stride >> 2;
else
size.h = buf_info.planes[0].stride;
- size.v = tbm_surface_get_height(private_layer->showing_buffer);
+ size.v = tbm_surface_get_height(private_layer->showing_buffer->buffer);
if (info.src_config.format)
format = (info.src_config.format) ? : format;
private_layer->index,
private_output->index,
private_layer->caps.zpos,
- private_layer->showing_buffer, FOURCC_STR(format), size.h, size.v,
+ private_layer->showing_buffer->buffer, FOURCC_STR(format), size.h, size.v,
info.src_config.pos.w, info.src_config.pos.h, info.src_config.pos.x, info.src_config.pos.y,
info.dst_pos.w, info.dst_pos.h, info.dst_pos.x, info.dst_pos.y,
tdm_transform_str(info.transform));
TDM_SNPRINTF(reply, len, "\t%u properties:\n", private_layer->caps.prop_count);
if (private_layer->caps.prop_count > 0) {
- TDM_SNPRINTF(reply, len, "\t\tname\tidx\tvalue\n");
+ TDM_SNPRINTF(reply, len, "\t\tname\ttype\tidx\tvalue\n");
for (i = 0; i < private_layer->caps.prop_count; i++) {
tdm_value value;
- TDM_DBG_GOTO_IF_FAIL(func_layer->layer_get_property, unlock);
+ TDM_DBG_RETURN_IF_FAIL(func_layer->layer_get_property);
ret = func_layer->layer_get_property(private_layer->layer_backend,
private_layer->caps.props[i].id,
&value);
- TDM_DBG_GOTO_IF_FAIL(ret == TDM_ERROR_NONE, unlock);
- TDM_SNPRINTF(reply, len, "\t\t%s\t%u\t%u\n",
+ TDM_DBG_RETURN_IF_FAIL(ret == TDM_ERROR_NONE);
+ TDM_SNPRINTF(reply, len, "\t\t%s\t%s\t%u\t",
private_layer->caps.props[i].name,
- private_layer->caps.props[i].id,
- value.u32);
+ tdm_value_type_str(private_output->caps.props[i].type),
+ private_layer->caps.props[i].id);
+ switch (private_layer->caps.props[i].type) {
+ case TDM_VALUE_TYPE_PTR:
+ TDM_SNPRINTF(reply, len, "%p\n", value.ptr);
+ break;
+ case TDM_VALUE_TYPE_INT32:
+ TDM_SNPRINTF(reply, len, "%d\n", value.s32);
+ break;
+ case TDM_VALUE_TYPE_INT64:
+ TDM_SNPRINTF(reply, len, "%"PRId64"\n", value.s64);
+ break;
+ case TDM_VALUE_TYPE_UINT64:
+ TDM_SNPRINTF(reply, len, "%"PRIu64"\n", value.u64);
+ break;
+ case TDM_VALUE_TYPE_UINT32:
+ default:
+ TDM_SNPRINTF(reply, len, "%u\n", value.u32);
+ break;
+ }
}
}
}
TDM_SNPRINTF(reply, len, "[No Capture capability]\n");
}
TDM_SNPRINTF(reply, len, "\n");
+}
-unlock:
- _pthread_mutex_unlock(&private_display->lock);
+EXTERN int
+tdm_helper_commit_per_vblank_enabled(tdm_display *dpy)
+{
+ TDM_ERR("the deprecated function, use 'tdm_helper_output_commit_per_vblank_enabled' instead.");
+
+ return 0;
}
+
+EXTERN int
+tdm_helper_output_commit_per_vblank_enabled(tdm_output *output)
+{
+ tdm_private_output *private_output = output;
+
+ TDM_RETURN_VAL_IF_FAIL(private_output != NULL, -1);
+
+ return !!private_output->commit_per_vblank;
+}
+