private_output = private_layer->private_output; \
private_display = private_output->private_display
+#define OUTPUT_HWC_CAP_CHECK() \
+ if (private_output->caps.capabilities & TDM_OUTPUT_CAPABILITY_HWC) { \
+ TDM_ERR("output(%p) support HWC. Use HWC functions", private_output); \
+ _pthread_mutex_unlock(&private_display->lock); \
+ return TDM_ERROR_OPERATION_FAILED; \
+ }
+
+#define OUTPUT_HWC_CAP_CHECK_ERROR() \
+ if (private_output->caps.capabilities & TDM_OUTPUT_CAPABILITY_HWC) { \
+ TDM_ERR("output(%p) support HWC. Use HWC functions", private_output); \
+ if (error) *error = TDM_ERROR_OPERATION_FAILED; \
+ _pthread_mutex_unlock(&private_display->lock); \
+ return NULL; \
+ }
+
+#define OUTPUT_HWC_CAP_CHECK_VOID_RETURN() \
+ if (private_output->caps.capabilities & TDM_OUTPUT_CAPABILITY_HWC) { \
+ TDM_ERR("output(%p) support HWC. Use HWC functions", private_output); \
+ _pthread_mutex_unlock(&private_display->lock); \
+ return; \
+ }
+
+/* LCOV_EXCL_START */
static void _tdm_layer_cb_wait_vblank(tdm_vblank *vblank, tdm_error error, unsigned int sequence,
unsigned int tv_sec, unsigned int tv_usec, void *user_data);
static void _tbm_layer_queue_acquirable_cb(tbm_surface_queue_h surface_queue, void *data);
_pthread_mutex_lock(&private_display->lock);
+ OUTPUT_HWC_CAP_CHECK_ERROR();
+
if (error)
*error = TDM_ERROR_NONE;
_pthread_mutex_lock(&private_display->lock);
+ OUTPUT_HWC_CAP_CHECK();
+
*index = private_layer->index;
_pthread_mutex_unlock(&private_display->lock);
_pthread_mutex_lock(&private_display->lock);
+ OUTPUT_HWC_CAP_CHECK();
+
*capabilities = private_layer->caps.capabilities;
_pthread_mutex_unlock(&private_display->lock);
_pthread_mutex_lock(&private_display->lock);
+ OUTPUT_HWC_CAP_CHECK();
+
*formats = (const tbm_format *)private_layer->caps.formats;
*count = private_layer->caps.format_count;
_pthread_mutex_lock(&private_display->lock);
+ OUTPUT_HWC_CAP_CHECK();
+
*props = (const tdm_prop *)private_layer->caps.props;
*count = private_layer->caps.prop_count;
_pthread_mutex_lock(&private_display->lock);
+ OUTPUT_HWC_CAP_CHECK();
+
*zpos = private_layer->caps.zpos;
_pthread_mutex_unlock(&private_display->lock);
_pthread_mutex_lock(&private_display->lock);
+ OUTPUT_HWC_CAP_CHECK();
+
private_module = private_layer->private_module;
func_layer = &private_module->func_layer;
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);
_pthread_mutex_lock(&private_display->lock);
+ OUTPUT_HWC_CAP_CHECK();
+
private_module = private_layer->private_module;
func_layer = &private_module->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 */
TDM_ERR("not implemented!!");
return TDM_ERROR_NOT_IMPLEMENTED;
- /* LCOV_EXCL_STOP */
}
if (info->src_config.format)
_pthread_mutex_lock(&private_display->lock);
+ OUTPUT_HWC_CAP_CHECK();
+
ret = tdm_layer_set_info_internal(private_layer, info);
_pthread_mutex_unlock(&private_display->lock);
_pthread_mutex_lock(&private_display->lock);
+ OUTPUT_HWC_CAP_CHECK();
+
private_module = private_layer->private_module;
func_layer = &private_module->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 *l = NULL;
char *p = bufs;
int *remain = &len;
+ int n;
pipe = private_output->pipe;
zpos = private_layer->caps.zpos;
TDM_SNPRINTF(p, remain, "_%p", l->showing_buffer->buffer);
}
- snprintf(fname, sizeof(fname), "tdm_%d_lyr_%d%s", pipe, zpos, bufs);
+ n = snprintf(fname, sizeof(fname), "tdm_%d_lyr_%d%s", pipe, zpos, bufs);
+ if ((size_t)n >= sizeof(fname)) {
+ fname[sizeof(fname) - 1] = '\0';
+ }
tbm_surface_internal_dump_buffer(buffer, fname);
TDM_DBG("%s dump excute", fname);
return;
}
-/* LCOV_EXCL_STOP */
void
tdm_layer_free_buffer(tdm_private_layer *private_layer, tdm_private_layer_buffer *layer_buffer)
tdm_private_output *private_output = private_layer->private_output;
tdm_func_layer *func_layer;
- /* LCOV_EXCL_START */
/* dump buffer */
if (tdm_dump_enable && !(private_layer->caps.capabilities & TDM_LAYER_CAPABILITY_VIDEO))
_tdm_layer_dump_buffer(private_layer, buffer);
private_output->index, private_layer->index, i++);
tdm_helper_dump_buffer_str(buffer, tdm_debug_dump_dir, str);
}
- /* LCOV_EXCL_STOP */
private_module = private_layer->private_module;
func_layer = &private_module->func_layer;
private_layer->usable = 0;
if (!func_layer->layer_set_buffer) {
- /* LCOV_EXCL_START */
TDM_ERR("not implemented!!");
return TDM_ERROR_NOT_IMPLEMENTED;
- /* LCOV_EXCL_START */
}
private_layer->pending_buffer_changed = 1;
_pthread_mutex_lock(&private_display->lock);
+ OUTPUT_HWC_CAP_CHECK();
+
ret = tdm_layer_set_buffer_internal(private_layer, buffer);
_pthread_mutex_unlock(&private_display->lock);
TDM_INFO("layer(%p,%d) now usable", private_layer, private_layer->index);
if (!func_layer->layer_unset_buffer) {
- /* LCOV_EXCL_START */
TDM_ERR("not implemented!!");
return TDM_ERROR_NOT_IMPLEMENTED;
- /* LCOV_EXCL_START */
}
ret = func_layer->layer_unset_buffer(private_layer->layer_backend);
_pthread_mutex_lock(&private_display->lock);
+ OUTPUT_HWC_CAP_CHECK();
+
ret = tdm_layer_unset_buffer_internal(private_layer);
TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
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) {
if (tdm_ttrace_module & TDM_TTRACE_LAYER) {
}
static unsigned int
-_tdm_lauer_get_output_used_layer_count(tdm_private_output *private_output)
+_tdm_layer_get_output_used_layer_count(tdm_private_output *private_output)
{
tdm_private_layer *private_layer = NULL;
unsigned int count = 0;
return 0;
}
- if (private_output->commit_per_vblank == 1 && _tdm_lauer_get_output_used_layer_count(private_output) > 1) {
+ if (private_output->commit_per_vblank == 1 && _tdm_layer_get_output_used_layer_count(private_output) > 1) {
if (tdm_debug_module & TDM_DEBUG_COMMIT)
TDM_INFO("layer(%p,%d) commit: not possible(more than 2 layers)",
private_layer, private_layer->index);
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)
layer_commit_handler->committed_buffer = private_layer->waiting_buffer;
private_layer->waiting_buffer = NULL;
+ if (!private_layer->committing && layer_commit_handler->committed_buffer)
+ private_layer->commiting_buffer = layer_commit_handler->committed_buffer->buffer;
+
if (private_layer->committing)
TDM_WRN("layer(%p,%d) too many commit", private_layer, private_layer->index);
else
_pthread_mutex_unlock(&private_display->lock);
ret = tdm_vblank_wait(private_output->vblank, 0, 0, 1, _tdm_layer_cb_wait_vblank, private_output);
_pthread_mutex_lock(&private_display->lock);
- TDM_GOTO_IF_FAIL(ret == TDM_ERROR_NONE, commit_failed);
+ if (ret != TDM_ERROR_NONE) {
+ if (TDM_OUTPUT_DPMS_VSYNC_IS_OFF(private_output->current_dpms_value)) {
+ /* dpms off : the allocated memory was free in tdm_output_commit_internal */
+ return ret;
+ }
+ goto commit_failed;
+
+ }
private_output->layer_waiting_vblank = 1;
if (tdm_debug_module & TDM_DEBUG_COMMIT)
_pthread_mutex_lock(&private_display->lock);
+ OUTPUT_HWC_CAP_CHECK();
+
ret = tdm_layer_commit_internal(private_layer, func, user_data);
_pthread_mutex_unlock(&private_display->lock);
_pthread_mutex_lock(&private_display->lock);
+ OUTPUT_HWC_CAP_CHECK();
+
*committing = private_layer->committing;
_pthread_mutex_unlock(&private_display->lock);
_pthread_mutex_lock(&private_display->lock);
+ OUTPUT_HWC_CAP_CHECK();
+
tdm_layer_remove_commit_handler_internal(layer, func, user_data);
_pthread_mutex_unlock(&private_display->lock);
_pthread_mutex_lock(&private_display->lock);
+ OUTPUT_HWC_CAP_CHECK_ERROR();
+
if (error)
*error = TDM_ERROR_NONE;
func_layer = &private_module->func_layer;
if (!func_layer->layer_set_buffer) {
- /* LCOV_EXCL_START */
_pthread_mutex_unlock(&private_display->lock);
return;
- /* LCOV_EXCL_STOP */
}
if (TBM_SURFACE_QUEUE_ERROR_NONE != tbm_surface_queue_acquire(private_layer->buffer_queue, &buffer) ||
buffer == NULL) {
- /* LCOV_EXCL_START */
TDM_ERR("layer(%p,%d) tbm_surface_queue_acquire() failed surface:%p",
private_layer, private_layer->index, buffer);
_pthread_mutex_unlock(&private_display->lock);
return;
- /* LCOV_EXCL_STOP */
}
ret = tdm_layer_set_buffer_internal(private_layer, buffer);
_pthread_mutex_lock(&private_display->lock);
+ OUTPUT_HWC_CAP_CHECK();
+
private_module = private_layer->private_module;
func_layer = &private_module->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_STOP */
}
if (buffer_queue == private_layer->buffer_queue) {
_pthread_mutex_lock(&private_display->lock);
+ OUTPUT_HWC_CAP_CHECK();
+
*usable = private_layer->usable;
_pthread_mutex_unlock(&private_display->lock);
_pthread_mutex_lock(&private_display->lock);
+ OUTPUT_HWC_CAP_CHECK();
+
private_module = private_layer->private_module;
func_layer = &private_module->func_layer;
}
if (!func_layer->layer_set_video_pos) {
- /* LCOV_EXCL_START */
_pthread_mutex_unlock(&private_display->lock);
TDM_ERR("layer(%p,%d) not implemented!!", private_layer, private_layer->index);
return TDM_ERROR_NOT_IMPLEMENTED;
- /* LCOV_EXCL_STOP */
}
ret = func_layer->layer_set_video_pos(private_layer->layer_backend, zpos);
_pthread_mutex_lock(&private_display->lock);
+ OUTPUT_HWC_CAP_CHECK_ERROR();
+
capture = (tdm_capture *)tdm_capture_create_layer_internal(private_layer, error);
_pthread_mutex_unlock(&private_display->lock);
_pthread_mutex_lock(&private_display->lock);
+ OUTPUT_HWC_CAP_CHECK();
+
private_module = private_layer->private_module;
func_layer = &private_module->func_layer;
if (!func_layer->layer_get_buffer_flags) {
- /* LCOV_EXCL_START */
*flags = 0;
_pthread_mutex_unlock(&private_display->lock);
TDM_INFO("not implemented!!");
return TDM_ERROR_NONE;
- /* LCOV_EXCL_STOP */
}
ret = func_layer->layer_get_buffer_flags(private_layer->layer_backend, flags);
return ret;
}
+/* LCOV_EXCL_STOP */