}
}
+EINTERN const char*
+e_hwc_window_transition_string_get(E_Hwc_Window_Transition transition)
+{
+ switch (transition)
+ {
+ case E_HWC_WINDOW_TRANSITION_NONE_TO_NONE:
+ return "NOtoNO";
+ case E_HWC_WINDOW_TRANSITION_NONE_TO_CLIENT:
+ return "NOtoCL";
+ case E_HWC_WINDOW_TRANSITION_NONE_TO_DEVICE:
+ return "NOtoDV";
+ case E_HWC_WINDOW_TRANSITION_NONE_TO_CURSOR:
+ return "NOtoCS";
+ case E_HWC_WINDOW_TRANSITION_CLIENT_TO_NONE:
+ return "CLtoNO";
+ case E_HWC_WINDOW_TRANSITION_CLIENT_TO_CLIENT:
+ return "CLtoCL";
+ case E_HWC_WINDOW_TRANSITION_CLIENT_TO_DEVICE:
+ return "CLtoDV";
+ case E_HWC_WINDOW_TRANSITION_CLIENT_TO_CURSOR:
+ return "CLtoCS";
+ case E_HWC_WINDOW_TRANSITION_DEVICE_TO_NONE:
+ return "DVtoNO";
+ case E_HWC_WINDOW_TRANSITION_DEVICE_TO_CLIENT:
+ return "DVtoCL";
+ case E_HWC_WINDOW_TRANSITION_DEVICE_TO_DEVICE:
+ return "DVtoDV";
+ case E_HWC_WINDOW_TRANSITION_CURSOR_TO_NONE:
+ return "CStoNO";
+ case E_HWC_WINDOW_TRANSITION_CURSOR_TO_CLIENT:
+ return "CStoCL";
+ case E_HWC_WINDOW_TRANSITION_CURSOR_TO_CURSOR:
+ return "CStoCS";
+ default:
+ return "UNKNOWN";
+ }
+}
+
EINTERN const char*
e_hwc_window_name_get(E_Hwc_Window *hwc_window)
{
EINTERN Eina_Bool e_hwc_window_device_state_available_check(E_Hwc_Window *hwc_window);
EINTERN Eina_Bool e_hwc_window_transition_set(E_Hwc_Window *hwc_window, E_Hwc_Window_Transition transition);
EINTERN E_Hwc_Window_Transition e_hwc_window_transition_get(E_Hwc_Window *hwc_window);
+EINTERN const char* e_hwc_window_transition_string_get(E_Hwc_Window_Transition transition);
EINTERN Eina_Bool e_hwc_window_constraints_update(E_Hwc_Window *hwc_window);
EINTERN Eina_Bool e_hwc_window_rendered_window_update(E_Hwc_Window *hwc_window);
ehwq_trace = onoff;
INF("EHWQ: hwc trace_debug is %s", onoff?"ON":"OFF");
}
+
+static const char*
+_e_hwc_window_queue_state_string_get(E_Hwc_Window_Queue_State state)
+{
+ switch (state)
+ {
+ case E_HWC_WINDOW_QUEUE_STATE_UNSET:
+ return "UNSET"; // None
+ case E_HWC_WINDOW_QUEUE_STATE_UNSET_WAITING:
+ return "UNSET_WAITING"; // Client
+ case E_HWC_WINDOW_QUEUE_STATE_SET:
+ return "SET"; // Device
+ case E_HWC_WINDOW_QUEUE_STATE_SET_WAITING:
+ return "SET_WAITING"; // Video
+ case E_HWC_WINDOW_QUEUE_STATE_SET_PENDING:
+ return "SET_PENDING"; // Cursor
+ default:
+ return "UNKNOWN";
+ }
+}
+
+EINTERN void
+e_hwc_window_queue_debug_info_get(Eldbus_Message_Iter *iter)
+{
+ Eldbus_Message_Iter *line_array;
+ Eina_Iterator *hash_iter;
+ E_Hwc_Window *hwc_window = NULL;
+ E_Hwc_Window_Queue *queue = NULL;
+ E_Hwc_Window_Queue_Buffer *queue_buffer = NULL;
+ Eina_List *l;
+ int idx = 0;
+ int buf_idx = 0;
+ int pending_set_idx = 0;
+ char info_str[1024];
+
+ eldbus_message_iter_arguments_append(iter, "as", &line_array);
+ if (!_hwc_winq_mgr)
+ {
+ eldbus_message_iter_basic_append(line_array,
+ 's',
+ "E_Hwc_Window_Queue not initialized..");
+ eldbus_message_iter_container_close(iter, line_array);
+ return;
+ }
+
+ /* PROVIDER */
+ hash_iter = eina_hash_iterator_data_new(_hwc_winq_mgr->hwc_winq_hash);
+ EINA_ITERATOR_FOREACH(hash_iter, queue)
+ {
+ if (!queue) continue;
+
+ snprintf(info_str, sizeof(info_str),
+ "[%2d] Queue(%8p) tqueue(%8p) target(%d) state(%s) user(%8p):win(0x%08zx)"
+ " unset_waiting_user(%8p):win(0x%08zx)",
+ ++idx, queue, queue->tqueue, queue->is_target,
+ _e_hwc_window_queue_state_string_get(queue->state),
+ queue->user,
+ queue->user ? e_client_util_win_get(queue->user->ec) : 0,
+ queue->user_waiting_unset,
+ queue->user_waiting_unset ? e_client_util_win_get(queue->user_waiting_unset->ec) : 0);
+ eldbus_message_iter_basic_append(line_array, 's', info_str);
+
+ pending_set_idx = 0;
+ EINA_LIST_FOREACH(queue->user_pending_set, l, hwc_window)
+ {
+ snprintf(info_str, sizeof(info_str),
+ " └─ [%2d] pending_set user(%8p):win(0x%08zx)",
+ ++pending_set_idx, hwc_window, e_client_util_win_get(hwc_window->ec));
+ eldbus_message_iter_basic_append(line_array, 's', info_str);
+ }
+
+ buf_idx = 0;
+ EINA_LIST_FOREACH(queue->buffers, l, queue_buffer)
+ {
+ snprintf(info_str, sizeof(info_str),
+ " └─ [%2d] Queue_Buffer(%8p) tsurface(%8p) exported_wl_buffer(%u)"
+ " exported(%d) usable(%d) released(%d) acquired(%d) dequeued(%d)",
+ ++buf_idx, queue_buffer, queue_buffer->tsurface,
+ queue_buffer->exported_wl_buffer ? wl_resource_get_id(queue_buffer->exported_wl_buffer) : 0,
+ queue_buffer->exported, queue_buffer->usable, queue_buffer->released,
+ queue_buffer->acquired, queue_buffer->dequeued);
+ eldbus_message_iter_basic_append(line_array, 's', info_str);
+ }
+ eldbus_message_iter_basic_append(line_array, 's', "");
+ }
+ eina_iterator_free(hash_iter);
+
+ eldbus_message_iter_container_close(iter, line_array);
+}
EINTERN Eina_List * e_hwc_window_queue_acquirable_buffers_get(E_Hwc_Window_Queue *queue);
EINTERN void e_hwc_window_queue_trace_debug(Eina_Bool onoff);
+EINTERN void e_hwc_window_queue_debug_info_get(Eldbus_Message_Iter *iter);
#endif // E_HWC_WINDOW_QUEUE_H
#endif
ehws_dump_enable = EINA_FALSE;
}
+
+static void
+_e_hwc_windows_window_debug_info_get(Eldbus_Message_Iter *iter, E_Hwc_Wins_Debug_Cmd cmd)
+{
+ Eldbus_Message_Iter *line_array;
+ E_Hwc_Window *hwc_window = NULL;
+ E_Comp_Screen *e_comp_screen = NULL;
+ E_Output *output = NULL;
+ E_Hwc *hwc = NULL;
+ Eina_List *l, *l2;
+ int idx = 0;
+ char info_str[1024];
+ char fmt_str[5];
+ char flip = ' ';
+
+ e_comp_screen = e_comp->e_comp_screen;
+
+ eldbus_message_iter_arguments_append(iter, "as", &line_array);
+ if (!e_comp_screen)
+ {
+ eldbus_message_iter_basic_append(line_array,
+ 's',
+ "e_comp_screen not initialized..");
+ eldbus_message_iter_container_close(iter, line_array);
+ return;
+ }
+
+ eldbus_message_iter_basic_append(line_array, 's',
+ "==========================================================================================="
+ "=============================================================");
+ eldbus_message_iter_basic_append(line_array, 's',
+ " No Win_ID Hwc_win zpos ST AC_ST ACTI TRANSI tsurface src_size src_pos"
+ " FMT dst_pos TRANSF DP_tsurface Queue");
+ eldbus_message_iter_basic_append(line_array, 's',
+ "==========================================================================================="
+ "=============================================================");
+
+ EINA_LIST_FOREACH(e_comp_screen->outputs, l, output)
+ {
+ if (!output) continue;
+ if (!output->config.enabled) continue;
+ if (!output->tdm_hwc) continue;
+
+ hwc = output->hwc;
+ if (!output->hwc) continue;
+
+ EINA_LIST_FOREACH(hwc->hwc_windows, l2, hwc_window)
+ {
+ if (!hwc_window) continue;
+
+ if ((cmd == E_HWC_WINS_DEBUG_CMD_VIS) && (hwc_window->accepted_state == E_HWC_WINDOW_STATE_NONE))
+ continue;
+ else if ((cmd == E_HWC_WINS_DEBUG_CMD_DV) && (hwc_window->accepted_state != E_HWC_WINDOW_STATE_DEVICE))
+ continue;
+ else if ((cmd == E_HWC_WINS_DEBUG_CMD_CL) && (hwc_window->accepted_state != E_HWC_WINDOW_STATE_CLIENT))
+ continue;
+ else if ((cmd == E_HWC_WINS_DEBUG_CMD_CS) && (hwc_window->accepted_state != E_HWC_WINDOW_STATE_CURSOR))
+ continue;
+ else if ((cmd == E_HWC_WINS_DEBUG_CMD_VD) && (hwc_window->accepted_state != E_HWC_WINDOW_STATE_VIDEO))
+ continue;
+ else if ((cmd == E_HWC_WINS_DEBUG_CMD_NO) && (hwc_window->accepted_state != E_HWC_WINDOW_STATE_NONE))
+ continue;
+
+ if (hwc_window->info.src_config.format)
+ snprintf(fmt_str, sizeof(fmt_str), "%c%c%c%c", FOURCC_STR(hwc_window->info.src_config.format));
+ else
+ snprintf(fmt_str, sizeof(fmt_str), " ");
+
+ if (hwc_window->info.transform > TDM_TRANSFORM_270)
+ flip = 'F';
+
+ snprintf(info_str, sizeof(info_str),
+ "%3d 0x%08zx 0x%08zx %4d %s %s %s %s 0x%08zx %04dx%04d %04dx%04d+%04d+%04d"
+ " %4s %04dx%04d+%04d+%04d %c%3d 0x%08zx 0x%08zx",
+ ++idx,
+ e_client_util_win_get(hwc_window->ec),
+ (uintptr_t)hwc_window,
+ hwc_window->zpos,
+ e_hwc_window_state_string_get(hwc_window->state),
+ e_hwc_window_state_string_get(hwc_window->accepted_state),
+ hwc_window->accepted_state ? "A" : "D",
+ e_hwc_window_transition_string_get(hwc_window->transition),
+ (uintptr_t)hwc_window->buffer.tsurface,
+ hwc_window->info.src_config.size.h,
+ hwc_window->info.src_config.size.v,
+ hwc_window->info.src_config.pos.w,
+ hwc_window->info.src_config.pos.h,
+ hwc_window->info.src_config.pos.x,
+ hwc_window->info.src_config.pos.y,
+ fmt_str,
+ hwc_window->info.dst_pos.w,
+ hwc_window->info.dst_pos.h,
+ hwc_window->info.dst_pos.x,
+ hwc_window->info.dst_pos.y,
+ flip,
+ (hwc_window->info.transform < 4) ? hwc_window->info.transform * 90 : (hwc_window->info.transform - 4) * 90,
+ (uintptr_t)hwc_window->display.buffer.tsurface,
+ (uintptr_t)hwc_window->queue);
+ eldbus_message_iter_basic_append(line_array, 's', info_str);
+ }
+ }
+
+ eldbus_message_iter_basic_append(line_array, 's',
+ "==========================================================================================="
+ "=============================================================");
+
+ eldbus_message_iter_container_close(iter, line_array);
+}
+
+EINTERN void
+e_hwc_windows_debug_info_get(Eldbus_Message_Iter *iter, E_Hwc_Wins_Debug_Cmd cmd)
+{
+ if (cmd == E_HWC_WINS_DEBUG_CMD_QUEUE)
+ e_hwc_window_queue_debug_info_get(iter);
+ else if (cmd >= E_HWC_WINS_DEBUG_CMD_VIS && cmd <= E_HWC_WINS_DEBUG_CMD_NO)
+ _e_hwc_windows_window_debug_info_get(iter, cmd);
+}
#ifndef E_HWC_WINDOWS_H
#define E_HWC_WINDOWS_H
+typedef enum
+{
+ E_HWC_WINS_DEBUG_CMD_NONE,
+ E_HWC_WINS_DEBUG_CMD_VIS,
+ E_HWC_WINS_DEBUG_CMD_ALL,
+ E_HWC_WINS_DEBUG_CMD_CL,
+ E_HWC_WINS_DEBUG_CMD_DV,
+ E_HWC_WINS_DEBUG_CMD_CS,
+ E_HWC_WINS_DEBUG_CMD_VD,
+ E_HWC_WINS_DEBUG_CMD_NO,
+ E_HWC_WINS_DEBUG_CMD_QUEUE,
+} E_Hwc_Wins_Debug_Cmd;
+
EINTERN Eina_Bool e_hwc_windows_init(E_Hwc *hwc);
EINTERN void e_hwc_windows_deinit(E_Hwc *hwc);
EINTERN Eina_Bool e_hwc_windows_render(E_Hwc *hwc);
EINTERN void e_hwc_windows_trace_debug(Eina_Bool onoff);
EINTERN void e_hwc_windows_dump_start(void);
EINTERN void e_hwc_windows_dump_stop(void);
+EINTERN void e_hwc_windows_debug_info_get(Eldbus_Message_Iter *iter, E_Hwc_Wins_Debug_Cmd cmd);
#endif
#endif
return;
}
+static void
+_cb_hwc_wins_info_get(const Eldbus_Message *msg)
+{
+ const char *name = NULL, *text = NULL;
+ Eina_Bool res;
+ Eldbus_Message_Iter *lines;
+ char *result = NULL;
+
+ res = eldbus_message_error_get(msg, &name, &text);
+ if (res) goto finish;
+
+ res = eldbus_message_arguments_get(msg, "as", &lines);
+ if (!res) goto finish;
+
+ while (eldbus_message_iter_get_and_next(lines, 's', &result))
+ printf("%s\n", result);
+
+ return;
+
+finish:
+ if ((name) || (text))
+ {
+ printf("errname:%s errmsg:%s\n", name, text);
+ }
+}
+
+static void
+_e_info_client_proc_hwc_wins(int argc, char **argv)
+{
+ Eina_Bool res;
+ E_Hwc_Wins_Debug_Cmd cmd;
+
+ if (argc < 2)
+ cmd = E_HWC_WINS_DEBUG_CMD_VIS;
+ else
+ {
+ if (!argv[2])
+ cmd = E_HWC_WINS_DEBUG_CMD_VIS;
+ else if (eina_streq(argv[2], "all"))
+ cmd = E_HWC_WINS_DEBUG_CMD_ALL;
+ else if (eina_streq(argv[2], "dv"))
+ cmd = E_HWC_WINS_DEBUG_CMD_DV;
+ else if (eina_streq(argv[2], "cl"))
+ cmd = E_HWC_WINS_DEBUG_CMD_CL;
+ else if (eina_streq(argv[2], "cs"))
+ cmd = E_HWC_WINS_DEBUG_CMD_CS;
+ else if (eina_streq(argv[2], "vd"))
+ cmd = E_HWC_WINS_DEBUG_CMD_VD;
+ else if (eina_streq(argv[2], "none"))
+ cmd = E_HWC_WINS_DEBUG_CMD_NO;
+ else if (eina_streq(argv[2], "queue"))
+ cmd = E_HWC_WINS_DEBUG_CMD_QUEUE;
+ else if (eina_streq(argv[2], "help") || eina_streq(argv[2], "usage"))
+ goto usage;
+ else
+ goto usage;
+ }
+
+ res = _e_info_client_eldbus_message_with_args("hwc_wins", _cb_hwc_wins_info_get, "i", cmd);
+
+ EINA_SAFETY_ON_FALSE_RETURN(res);
+
+ return;
+
+usage:
+ printf("Usage: wininfo_info %s", USAGE_HWC_WINS);
+
+ return;
+}
+
typedef struct _ProcInfo
{
const char *option;
"Print input regions",
_e_info_client_proc_input_region
},
+ {
+ "hwc_wins",
+ NULL,
+ "Print hwc windows information",
+ _e_info_client_proc_hwc_wins
+ },
};
static ProcInfo procs_to_execute[] =
return reply;
}
+static Eldbus_Message *
+_e_info_server_cb_hwc_wins_info_get(const Eldbus_Service_Interface *iface EINA_UNUSED, const Eldbus_Message *msg)
+{
+ Eldbus_Message *reply = eldbus_message_method_return_new(msg);
+ E_Hwc_Wins_Debug_Cmd cmd;
+
+ if (!eldbus_message_arguments_get(msg, "i", &cmd))
+ {
+ return eldbus_message_error_new(msg, GET_CALL_MSG_ARG_ERR,
+ "hwc_wins: an attempt to get arguments from method call message failed");
+ }
+
+ e_hwc_windows_debug_info_get(eldbus_message_iter_get(reply), cmd);
+
+ return reply;
+}
+
//{ "method_name", arguments_from_client, return_values_to_client, _method_cb, ELDBUS_METHOD_FLAG },
static const Eldbus_Method methods[] = {
{ "get_window_info", NULL, ELDBUS_ARGS({"iiiiisa("VALUE_TYPE_FOR_TOPVWINS")", "array of ec"}), _e_info_server_cb_window_info_get, 0 },
{ "key_repeat", ELDBUS_ARGS({"sii", "option"}), NULL, _e_info_server_cb_key_repeat, 0},
{ "dump_memchecker", NULL, NULL, _e_info_server_cb_memchecker, 0},
{ "input_region", ELDBUS_ARGS({"siiii", "options"}), ELDBUS_ARGS({"a(iiii)", "path"}), _e_info_server_cb_input_region, 0},
+ { "hwc_wins", ELDBUS_ARGS({"i", "option"}), ELDBUS_ARGS({"as", "hwc wins info"}), _e_info_server_cb_hwc_wins_info_get, 0 },
{ NULL, NULL, NULL, NULL, 0 }
};
"\tenlightenment_info -trace serial 1\n" \
"\tenlightenment_info -trace serial 0\n"
+/* -------------------------------------------------------------------------- */
+/* HWC WINS */
+/* -------------------------------------------------------------------------- */
+#define USAGE_HWC_WINS \
+ "-hwc_wins (no option | all | cl | dv | cs | dv | no)\n" \
+ "Commands:\n" \
+ "\tno option : print visible hwc window info\n" \
+ "\tall : print all hwc window info\n" \
+ "\tcl : print CLIENT accepted state hwc window info\n" \
+ "\tdv : print DEVICE accepted state hwc window info\n" \
+ "\tcs : print CURSOR accepted state hwc window info\n" \
+ "\tvd : print VIDEO accepted state hwc window info\n" \
+ "\tno : print NONE accepted state hwc window info\n" \
+ "\tqueue : print hwc window queue info\n" \
+ "Example:\n" \
+ "\twinfo -hwc_wins\n" \
+ "\twinfo -hwc_wins all\n" \
+ "\twinfo -hwc_wins cl\n" \
+ "\twinfo -hwc_wins dv\n" \
+ "\twinfo -hwc_wins cs\n" \
+ "\twinfo -hwc_wins vd\n" \
+ "\twinfo -hwc_wins no\n " \
+ "\twinfo -hwc_wins queue\n "
+
#endif /* end of _E_INFO_SHARED_TYPES_ */
projects / platform / upstream / enlightenment.git / commitdiff