static void _tbm_layer_queue_destroy_cb(tbm_surface_queue_h surface_queue, void *data);
static void _tdm_layer_cb_output_commit(tdm_output *output, unsigned int sequence,
unsigned int tv_sec, unsigned int tv_usec, void *user_data);
+static void _tdm_layer_reset_pending_data(tdm_private_layer *private_layer);
EXTERN tdm_error
tdm_layer_get_capabilities(tdm_layer *layer, tdm_layer_capability *capabilities)
private_layer->usable = 0;
if (!func_layer->layer_set_property) {
+ /* LCOV_EXCL_START */
_pthread_mutex_unlock(&private_display->lock);
TDM_ERR("not implemented!!");
return TDM_ERROR_NOT_IMPLEMENTED;
+ /* LCOV_EXCL_STOP */
}
ret = func_layer->layer_set_property(private_layer->layer_backend, id, value);
func_layer = &private_display->func_layer;
if (!func_layer->layer_get_property) {
+ /* LCOV_EXCL_START */
_pthread_mutex_unlock(&private_display->lock);
TDM_ERR("not implemented!!");
return TDM_ERROR_NOT_IMPLEMENTED;
+ /* LCOV_EXCL_SOP */
}
ret = func_layer->layer_get_property(private_layer->layer_backend, id, value);
private_layer->usable = 0;
if (!func_layer->layer_set_info) {
+ /* LCOV_EXCL_START */
_pthread_mutex_unlock(&private_display->lock);
TDM_ERR("not implemented!!");
return TDM_ERROR_NOT_IMPLEMENTED;
+ /* LCOV_EXCL_STOP */
}
if (info->src_config.format)
info->dst_pos.w, info->dst_pos.h,
info->transform);
- ret = func_layer->layer_set_info(private_layer->layer_backend, info);
- TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
+ private_layer->pending_info_changed = 1;
+ private_layer->pending_info = *info;
_pthread_mutex_unlock(&private_display->lock);
func_layer = &private_display->func_layer;
if (!func_layer->layer_get_info) {
+ /* LCOV_EXCL_START */
_pthread_mutex_unlock(&private_display->lock);
TDM_ERR("not implemented!!");
return TDM_ERROR_NOT_IMPLEMENTED;
+ /* LCOV_EXCL_STOP */
}
ret = func_layer->layer_get_info(private_layer->layer_backend, info);
return ret;
}
+/* LCOV_EXCL_START */
static void
_tdm_layer_dump_buffer(tdm_layer *layer, tbm_surface_h buffer)
{
tdm_private_layer *private_layer = (tdm_private_layer*)layer;
tdm_private_output *private_output = private_layer->private_output;
unsigned int pipe;
- int zpos;
- char fname[PATH_MAX];
+ char fname[PATH_MAX], bufs[PATH_MAX];
+ int zpos, len = PATH_MAX;
+ tdm_private_layer *l = NULL;
+ char *p = bufs;
+ int *remain = &len;
pipe = private_output->pipe;
zpos = private_layer->caps.zpos;
- snprintf(fname, sizeof(fname), "tdm_%d_lyr_%d", pipe, zpos);
+ bufs[0] = '\0';
+ LIST_FOR_EACH_ENTRY(l, &private_output->layer_list, link) {
+ if (!l->showing_buffer)
+ continue;
+ TDM_SNPRINTF(p, remain, "_%p", l->showing_buffer->buffer);
+ }
+
+ snprintf(fname, sizeof(fname), "tdm_%d_lyr_%d%s", pipe, zpos, bufs);
tbm_surface_internal_dump_buffer(buffer, fname);
TDM_DBG("%s dump excute", fname);
return;
}
+/* LCOV_EXCL_STOP */
static void
_tdm_layer_free_buffer(tdm_private_layer *private_layer, tdm_private_layer_buffer *layer_buffer)
LIST_INITHEAD(&clone_list);
+ _tdm_layer_reset_pending_data(private_layer);
+
if (private_layer->waiting_buffer) {
_tdm_layer_free_buffer(private_layer, private_layer->waiting_buffer);
private_layer->waiting_buffer = NULL;
tdm_layer_set_buffer(tdm_layer *layer, tbm_surface_h buffer)
{
tdm_func_layer *func_layer;
- tdm_private_layer_buffer *layer_buffer;
LAYER_FUNC_ENTRY();
_pthread_mutex_lock(&private_display->lock);
+ /* LCOV_EXCL_START */
+ /* dump buffer */
+ if (tdm_dump_enable && !(private_layer->caps.capabilities & TDM_LAYER_CAPABILITY_VIDEO))
+ _tdm_layer_dump_buffer(private_layer, buffer);
+
if (tdm_debug_dump & TDM_DUMP_FLAG_LAYER &&
!(private_layer->caps.capabilities & TDM_LAYER_CAPABILITY_VIDEO)) {
char str[TDM_PATH_LEN];
private_output->index, private_layer->index, i++);
tdm_helper_dump_buffer_str(buffer, tdm_debug_dump_dir, str);
}
+ /* LCOV_EXCL_STOP */
func_layer = &private_display->func_layer;
private_layer->usable = 0;
if (!func_layer->layer_set_buffer) {
+ /* LCOV_EXCL_START */
_pthread_mutex_unlock(&private_display->lock);
TDM_ERR("not implemented!!");
return TDM_ERROR_NOT_IMPLEMENTED;
+ /* LCOV_EXCL_START */
}
- layer_buffer = calloc(1, sizeof(tdm_private_layer_buffer));
- if (!layer_buffer) {
- _pthread_mutex_unlock(&private_display->lock);
- TDM_ERR("alloc failed");
- return TDM_ERROR_OUT_OF_MEMORY;
- }
- LIST_INITHEAD(&layer_buffer->link);
+ private_layer->pending_buffer_changed = 1;
- ret = func_layer->layer_set_buffer(private_layer->layer_backend, buffer);
- TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
+ if (private_layer->pending_buffer) {
+ tbm_surface_internal_unref(private_layer->pending_buffer);
- /* dump buffer */
- if (tdm_dump_enable && !(private_layer->caps.capabilities & TDM_LAYER_CAPABILITY_VIDEO))
- _tdm_layer_dump_buffer(layer, buffer);
+ if (tdm_debug_module & TDM_DEBUG_BUFFER)
+ TDM_INFO("layer(%p) pending_buffer(%p) skipped",
+ private_layer, private_layer->pending_buffer);
+ }
- if (ret == TDM_ERROR_NONE) {
- if (private_layer->waiting_buffer)
- _tdm_layer_free_buffer(private_layer, private_layer->waiting_buffer);
+ tbm_surface_internal_ref(buffer);
+ private_layer->pending_buffer = buffer;
- private_layer->waiting_buffer = layer_buffer;
- private_layer->waiting_buffer->buffer = tdm_buffer_ref_backend(buffer);
- if (tdm_debug_module & TDM_DEBUG_BUFFER)
- TDM_INFO("layer(%p) waiting_buffer(%p)",
- private_layer, private_layer->waiting_buffer->buffer);
- } else
- _tdm_layer_free_buffer(private_layer, layer_buffer);
+ if (tdm_debug_module & TDM_DEBUG_BUFFER)
+ TDM_INFO("layer(%p) pending_buffer(%p)",
+ private_layer, private_layer->pending_buffer);
_pthread_mutex_unlock(&private_display->lock);
TDM_INFO("layer(%p) now usable", private_layer);
if (!func_layer->layer_unset_buffer) {
+ /* LCOV_EXCL_START */
_pthread_mutex_unlock(&private_display->lock);
TDM_ERR("not implemented!!");
return TDM_ERROR_NOT_IMPLEMENTED;
+ /* LCOV_EXCL_START */
}
ret = func_layer->layer_unset_buffer(private_layer->layer_backend);
tdm_private_output *private_output = private_layer->private_output;
tdm_private_display *private_display = private_output->private_display;
+ /* LCOV_EXCL_START */
if (private_display->print_fps) {
double curr = tdm_helper_get_time();
if (private_layer->fps_stamp == 0) {
private_layer->fps_stamp = 0;
private_layer->fps_count = 0;
}
+ /* LCOV_EXCL_STOP */
if (private_layer->showing_buffer)
_tdm_layer_free_buffer(private_layer, private_layer->showing_buffer);
if (!found)
return;
+ LIST_DEL(&layer_commit_handler->link);
+
private_layer = layer_commit_handler->private_layer;
if (tdm_debug_module & TDM_DEBUG_COMMIT)
_pthread_mutex_lock(&private_display->lock);
}
- LIST_DEL(&layer_commit_handler->link);
free(layer_commit_handler);
_pthread_mutex_unlock(&private_display->lock);
_tdm_layer_commit_possible(tdm_private_layer *private_layer)
{
tdm_private_output *private_output = private_layer->private_output;
- tdm_private_display *private_display = private_output->private_display;
- TDM_RETURN_VAL_IF_FAIL(private_display->commit_per_vblank > 0, 1);
+ TDM_RETURN_VAL_IF_FAIL(private_output->commit_per_vblank > 0, 1);
/* There is a previous commit request which is not done and displayed on screen yet.
* We can't commit at this time.
return 0;
}
- if (private_display->commit_per_vblank == 1 && _tdm_lauer_get_output_used_layer_count(private_output) > 1) {
+ if (private_output->commit_per_vblank == 1 && _tdm_lauer_get_output_used_layer_count(private_output) > 1) {
if (tdm_debug_module & TDM_DEBUG_COMMIT)
TDM_INFO("layer(%p) commit: not possible(more than 2 layers)", private_layer);
return 0;
return 1;
}
+static void
+_tdm_layer_reset_pending_data(tdm_private_layer *private_layer)
+{
+ private_layer->pending_info_changed = 0;
+ memset(&private_layer->pending_info, 0, sizeof private_layer->pending_info);
+
+ private_layer->pending_buffer_changed = 0;
+ if (private_layer->pending_buffer) {
+ tbm_surface_internal_unref(private_layer->pending_buffer);
+ private_layer->pending_buffer = NULL;
+ }
+}
+
+INTERN tdm_error
+tdm_layer_commit_pending_data(tdm_private_layer *private_layer)
+{
+ tdm_private_output *private_output = private_layer->private_output;
+ tdm_private_display *private_display = private_output->private_display;
+ tdm_func_layer *func_layer;
+ tdm_error ret = TDM_ERROR_NONE;
+
+ func_layer = &private_display->func_layer;
+
+ if (private_layer->pending_info_changed) {
+ ret = func_layer->layer_set_info(private_layer->layer_backend, &private_layer->pending_info);
+ TDM_GOTO_IF_FAIL(ret == TDM_ERROR_NONE, done);
+ }
+
+ if (private_layer->pending_buffer_changed) {
+ tdm_private_layer_buffer *layer_buffer;
+
+ layer_buffer = calloc(1, sizeof(tdm_private_layer_buffer));
+ TDM_GOTO_IF_FAIL(layer_buffer != NULL, done);
+
+ LIST_INITHEAD(&layer_buffer->link);
+
+ ret = func_layer->layer_set_buffer(private_layer->layer_backend, private_layer->pending_buffer);
+ TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
+
+ if (tdm_debug_module & TDM_DEBUG_BUFFER)
+ TDM_INFO("layer(%p) pending_buffer(%p) committed",
+ private_layer, private_layer->pending_buffer);
+
+ if (ret == TDM_ERROR_NONE) {
+ if (private_layer->waiting_buffer)
+ _tdm_layer_free_buffer(private_layer, private_layer->waiting_buffer);
+
+ private_layer->waiting_buffer = layer_buffer;
+ private_layer->waiting_buffer->buffer = tdm_buffer_ref_backend(private_layer->pending_buffer);
+ if (tdm_debug_module & TDM_DEBUG_BUFFER)
+ TDM_INFO("layer(%p) waiting_buffer(%p)",
+ private_layer, private_layer->waiting_buffer->buffer);
+ } else
+ _tdm_layer_free_buffer(private_layer, layer_buffer);
+ }
+
+done:
+ _tdm_layer_reset_pending_data(private_layer);
+
+ return ret;
+}
+
/* CAUTION: Once _tdm_layer_commit returns success, the layer commit handler MUST be called always.
* That is, even if we get error in _tdm_layer_got_output_vblank() function for some reasons,
* the layer commit handler MUST be called.
layer_commit_handler = calloc(1, sizeof(tdm_private_layer_commit_handler));
if (!layer_commit_handler) {
+ /* LCOV_EXCL_START */
TDM_ERR("failed: alloc memory");
return TDM_ERROR_OUT_OF_MEMORY;
+ /* LCOV_EXCL_STOP */
}
if (tdm_debug_module & TDM_DEBUG_COMMIT)
private_layer, private_layer->waiting_buffer,
(layer_commit_handler->committed_buffer) ? layer_commit_handler->committed_buffer->buffer : NULL);
- if (!private_display->commit_per_vblank) {
- TDM_GOTO_IF_FAIL(private_display->commit_type == TDM_COMMIT_TYPE_OUTPUT, commit_failed);
+ if (!private_output->commit_per_vblank) {
+ TDM_GOTO_IF_FAIL(private_output->commit_type == TDM_COMMIT_TYPE_OUTPUT, commit_failed);
LIST_ADDTAIL(&layer_commit_handler->link, &private_output->layer_commit_handler_list);
ret = tdm_output_commit_internal(private_layer->private_output, 0, _tdm_layer_cb_output_commit, layer_commit_handler);
if (tdm_debug_module & TDM_DEBUG_COMMIT)
TDM_INFO("layer(%p) commit: no commit-per-vblank", private_layer);
} else {
- TDM_GOTO_IF_FAIL(private_display->commit_type == TDM_COMMIT_TYPE_LAYER, commit_failed);
+ TDM_GOTO_IF_FAIL(private_output->commit_type == TDM_COMMIT_TYPE_LAYER, commit_failed);
if (private_layer->committing)
TDM_WRN("layer(%d) too many commit", private_layer->index);
_pthread_mutex_lock(&private_display->lock);
- if (private_display->commit_type == TDM_COMMIT_TYPE_NONE) {
- if (!private_display->commit_per_vblank)
- private_display->commit_type = TDM_COMMIT_TYPE_OUTPUT;
+ if (private_output->commit_type == TDM_COMMIT_TYPE_NONE) {
+ if (!private_output->commit_per_vblank)
+ private_output->commit_type = TDM_COMMIT_TYPE_OUTPUT;
else
- private_display->commit_type = TDM_COMMIT_TYPE_LAYER;
+ private_output->commit_type = TDM_COMMIT_TYPE_LAYER;
}
if (private_output->current_dpms_value > TDM_OUTPUT_DPMS_ON) {
return TDM_ERROR_DPMS_OFF;
}
+ /* don't call this inside of _tdm_layer_commit */
+ ret = tdm_layer_commit_pending_data(private_layer);
+ if (ret != TDM_ERROR_NONE) {
+ TDM_ERR("layer(%p) committing pending data failed", layer);
+ _pthread_mutex_unlock(&private_display->lock);
+ return ret;
+ }
+
ret = _tdm_layer_commit(private_layer, func, user_data);
_pthread_mutex_unlock(&private_display->lock);
func_layer = &private_display->func_layer;
if (!func_layer->layer_set_buffer) {
+ /* LCOV_EXCL_START */
_pthread_mutex_unlock(&private_display->lock);
return;
+ /* LCOV_EXCL_STOP */
}
layer_buffer = calloc(1, sizeof(tdm_private_layer_buffer));
if (!layer_buffer) {
+ /* LCOV_EXCL_START */
_pthread_mutex_unlock(&private_display->lock);
TDM_ERR("alloc failed");
return;
+ /* LCOV_EXCL_STOP */
}
LIST_INITHEAD(&layer_buffer->link);
if (TBM_SURFACE_QUEUE_ERROR_NONE != tbm_surface_queue_acquire(private_layer->buffer_queue, &surface) ||
surface == NULL) {
+ /* LCOV_EXCL_START */
TDM_ERR("layer(%p) tbm_surface_queue_acquire() failed surface:%p",
private_layer, surface);
_pthread_mutex_unlock(&private_display->lock);
free(layer_buffer);
return;
+ /* LCOV_EXCL_STOP */
}
+ /* we don't need to handle pending data here because the changes in this function
+ * should be applied immediately. we can't expect calling tdm_layer_commit.
+ */
ret = func_layer->layer_set_buffer(private_layer->layer_backend, surface);
TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
TDM_INFO("layer(%p) waiting_buffer(%p)",
private_layer, private_layer->waiting_buffer->buffer);
- if (private_display->commit_type == TDM_COMMIT_TYPE_OUTPUT) {
+ if (private_output->commit_type == TDM_COMMIT_TYPE_OUTPUT) {
ret = tdm_output_commit_internal(private_layer->private_output, 0, NULL, NULL);
if (ret != TDM_ERROR_NONE)
TDM_ERR("tdm_output_commit_internal() is fail");
- } else if (private_display->commit_type == TDM_COMMIT_TYPE_LAYER) {
+ } else if (private_output->commit_type == TDM_COMMIT_TYPE_LAYER) {
ret = _tdm_layer_commit(private_layer, NULL, NULL);
if (ret != TDM_ERROR_NONE)
TDM_ERR("layer(%p) _tdm_layer_commit() is fail", private_layer);
private_layer->usable = 0;
if (!func_layer->layer_set_buffer) {
+ /* LCOV_EXCL_START */
_pthread_mutex_unlock(&private_display->lock);
TDM_ERR("not implemented!!");
return TDM_ERROR_NOT_IMPLEMENTED;
+ /* LCOV_EXCL_STOP */
}
if (buffer_queue == private_layer->buffer_queue) {
}
if (!func_layer->layer_set_video_pos) {
+ /* LCOV_EXCL_START */
_pthread_mutex_unlock(&private_display->lock);
TDM_ERR("not implemented!!");
return TDM_ERROR_NOT_IMPLEMENTED;
+ /* LCOV_EXCL_STOP */
}
ret = func_layer->layer_set_video_pos(private_layer->layer_backend, zpos);
func_layer = &private_display->func_layer;
if (!func_layer->layer_get_buffer_flags) {
+ /* LCOV_EXCL_START */
_pthread_mutex_unlock(&private_display->lock);
TDM_ERR("not implemented!!");
return TDM_ERROR_NOT_IMPLEMENTED;
+ /* LCOV_EXCL_STOP */
}
ret = func_layer->layer_get_buffer_flags(private_layer->layer_backend, flags);
projects / platform / core / uifw / libtdm.git / blobdiff