pthread_mutex_lock(&private_client->lock);
- if (private_output->available_modes.count - 1 < index)
+ if (private_output->available_modes.count - 1 < index) {
+ pthread_mutex_unlock(&private_client->lock);
return TDM_ERROR_INVALID_PARAMETER;
+ }
if ((private_output->connection == TDM_OUTPUT_CONN_STATUS_DISCONNECTED) ||
- (private_output->available_modes.count == 0))
+ (private_output->available_modes.count == 0)) {
+ pthread_mutex_unlock(&private_client->lock);
return TDM_ERROR_BAD_REQUEST;
+ }
+
+ TDM_DBG("mode_set request : %d", index);
wl_tdm_output_set_mode(private_output->output, index);
if (h->func)
h->func(private_voutput, buffer, h->user_data);
}
- pthread_mutex_lock(&private_client->lock);
/* if no added commit_handler call commit done immediately */
if (LIST_IS_EMPTY(&private_voutput->commit_handler_list))
tdm_client_voutput_commit_done(private_voutput);
+
+ pthread_mutex_lock(&private_client->lock);
}
void
tdm_client_voutput_destroy(tdm_client_voutput *voutput)
{
tdm_private_client_voutput *private_voutput = (tdm_private_client_voutput *)voutput;
+ tdm_private_client *private_client;
tdm_client_voutput_commit_handler_info *h = NULL, *hh = NULL;
if (!private_voutput)
return;
+ private_client = private_voutput->private_client;
+
+ pthread_mutex_lock(&private_client->lock);
if (!(LIST_IS_EMPTY(&private_voutput->buffer_list))) {
tdm_private_client_buffer *cb = NULL, *cbb = NULL;
LIST_DEL(&private_voutput->link);
free(private_voutput);
+
+ pthread_mutex_unlock(&private_client->lock);
}
tdm_error
tdm_client_voutput_set_available_modes(tdm_client_voutput *voutput, const tdm_client_output_mode *modes, int count)
{
tdm_private_client_voutput *private_voutput;
+ tdm_private_client *private_client;
+ tdm_error ret = TDM_ERROR_NONE;
TDM_RETURN_VAL_IF_FAIL(voutput != NULL, TDM_ERROR_INVALID_PARAMETER);
return TDM_ERROR_INVALID_PARAMETER;
private_voutput = (tdm_private_client_voutput *)voutput;
+ private_client = private_voutput->private_client;
+
+ if (!private_voutput->private_output) {
+ private_voutput->private_output = tdm_client_voutput_get_client_output(private_voutput, &ret);
+ TDM_RETURN_VAL_IF_FAIL(ret == TDM_ERROR_NONE, TDM_ERROR_OPERATION_FAILED);
+ }
- if (private_voutput->private_output->connection == TDM_OUTPUT_CONN_STATUS_CONNECTED)
+ pthread_mutex_lock(&private_client->lock);
+
+ if (private_voutput->private_output->connection != TDM_OUTPUT_CONN_STATUS_DISCONNECTED) {
+ pthread_mutex_unlock(&private_client->lock);
return TDM_ERROR_BAD_REQUEST;
+ }
if (private_voutput->available_modes.modes)
free(private_voutput->available_modes.modes);
memcpy(private_voutput->available_modes.modes, modes, sizeof(tdm_client_output_mode) * count);
}
+ pthread_mutex_unlock(&private_client->lock);
+
return TDM_ERROR_NONE;
}
tdm_client_voutput_set_physical_size(tdm_client_voutput *voutput, unsigned int mmWidth, unsigned int mmHeight)
{
tdm_private_client_voutput *private_voutput;
+ tdm_private_client *private_client;
+ tdm_error ret = TDM_ERROR_NONE;
TDM_RETURN_VAL_IF_FAIL(voutput != NULL, TDM_ERROR_INVALID_PARAMETER);
TDM_RETURN_VAL_IF_FAIL(mmWidth != 0, TDM_ERROR_INVALID_PARAMETER);
TDM_RETURN_VAL_IF_FAIL(mmHeight != 0, TDM_ERROR_INVALID_PARAMETER);
private_voutput = (tdm_private_client_voutput *)voutput;
+ private_client = private_voutput->private_client;
- if (private_voutput->private_output->connection == TDM_OUTPUT_CONN_STATUS_CONNECTED)
+ if (!private_voutput->private_output) {
+ private_voutput->private_output = tdm_client_voutput_get_client_output(private_voutput, &ret);
+ TDM_RETURN_VAL_IF_FAIL(ret == TDM_ERROR_NONE, TDM_ERROR_OPERATION_FAILED);
+ }
+
+ pthread_mutex_lock(&private_client->lock);
+
+ if (private_voutput->private_output->connection != TDM_OUTPUT_CONN_STATUS_DISCONNECTED) {
+ pthread_mutex_unlock(&private_client->lock);
return TDM_ERROR_BAD_REQUEST;
+ }
private_voutput->mmwidth = mmWidth;
private_voutput->mmheight = mmHeight;
+ pthread_mutex_unlock(&private_client->lock);
+
return TDM_ERROR_NONE;
}
tdm_client_voutput_commit_done(tdm_client_voutput *voutput)
{
tdm_private_client_voutput *private_voutput;
+ tdm_private_client *private_client;
tbm_surface_h buffer = NULL;
TDM_RETURN_VAL_IF_FAIL(voutput != NULL, TDM_ERROR_INVALID_PARAMETER);
private_voutput = (tdm_private_client_voutput *)voutput;
+ TDM_RETURN_VAL_IF_FAIL(private_voutput->attach_buffer != NULL, TDM_ERROR_NONE);
+
+ private_client = private_voutput->private_client;
+
+ pthread_mutex_lock(&private_client->lock);
+
buffer = (tbm_surface_h)wl_buffer_get_user_data(private_voutput->attach_buffer->wl_buffer);
tbm_surface_internal_unref(buffer);
private_voutput->attach_buffer = NULL;
wl_tdm_voutput_commit_done(private_voutput->wl_voutput);
+ pthread_mutex_unlock(&private_client->lock);
+
return TDM_ERROR_NONE;
}
{
tdm_private_client_voutput *private_voutput;
tdm_private_client_output *private_output = NULL;
+ tdm_private_client *private_client;
tdm_error ret = TDM_ERROR_NONE;
if (error)
}
private_voutput = (tdm_private_client_voutput *)voutput;
+ private_client = private_voutput->private_client;
- if (private_voutput->get_output)
+ pthread_mutex_lock(&private_client->lock);
+
+ if (private_voutput->get_output) {
+ pthread_mutex_unlock(&private_client->lock);
return private_voutput->private_output;
+ }
+ pthread_mutex_unlock(&private_client->lock);
private_output = (tdm_private_client_output *)tdm_client_get_output(private_voutput->private_client, private_voutput->name, &ret);
if (!private_output) {
TDM_ERR("tdm_client_voutput_get_client_output get private_output fail");
*error = ret;
return NULL;
}
+ pthread_mutex_lock(&private_client->lock);
private_output->voutput = private_voutput;
private_voutput->private_output = private_output;
private_voutput->get_output = 1;
+ pthread_mutex_unlock(&private_client->lock);
+
return private_output;
}
{
tdm_private_client_output *private_output;
tdm_private_client_voutput *private_voutput = NULL;
+ tdm_private_client *private_client;
TDM_RETURN_VAL_IF_FAIL(output != NULL, TDM_ERROR_INVALID_PARAMETER);
private_output = (tdm_private_client_output *)output;
if (!private_output->voutput) return TDM_ERROR_INVALID_PARAMETER;
private_voutput = private_output->voutput;
+ private_client = private_voutput->private_client;
- TDM_RETURN_VAL_IF_FAIL(private_output->connection != TDM_OUTPUT_CONN_STATUS_CONNECTED,
- TDM_ERROR_BAD_REQUEST);
+ pthread_mutex_lock(&private_client->lock);
+
+ if (private_output->connection != TDM_OUTPUT_CONN_STATUS_DISCONNECTED) {
+ pthread_mutex_unlock(&private_client->lock);
+ return TDM_ERROR_NONE;
+ }
if (!private_output->watch_output_changes)
private_output->connection = TDM_OUTPUT_CONN_STATUS_CONNECTED;
/* To Do : change voutput to output */
wl_tdm_voutput_connect(private_voutput->wl_voutput);
+ pthread_mutex_unlock(&private_client->lock);
+
return TDM_ERROR_NONE;
}
{
tdm_private_client_output *private_output;
tdm_private_client_voutput *private_voutput = NULL;
+ tdm_private_client *private_client;
TDM_RETURN_VAL_IF_FAIL(output != NULL, TDM_ERROR_INVALID_PARAMETER);
private_output = (tdm_private_client_output *)output;
if (!private_output->voutput) return TDM_ERROR_INVALID_PARAMETER;
private_voutput = private_output->voutput;
+ private_client = private_voutput->private_client;
- TDM_RETURN_VAL_IF_FAIL(private_output->connection != TDM_OUTPUT_CONN_STATUS_DISCONNECTED,
- TDM_ERROR_BAD_REQUEST);
+ pthread_mutex_lock(&private_client->lock);
+
+ if (private_output->connection == TDM_OUTPUT_CONN_STATUS_DISCONNECTED) {
+ pthread_mutex_unlock(&private_client->lock);
+ return TDM_ERROR_NONE;
+ }
if (!private_output->watch_output_changes)
private_output->connection = TDM_OUTPUT_CONN_STATUS_DISCONNECTED;
/* To Do : change voutput to output */
wl_tdm_voutput_disconnect(private_voutput->wl_voutput);
+ pthread_mutex_unlock(&private_client->lock);
+
return TDM_ERROR_NONE;
}
ASSERT_EQ(PrepareOutput(), true);
ASSERT_EQ(tdm_client_output_get_available_modes(output, &modes, &count), TDM_ERROR_NONE);
+ ASSERT_GT(count, -1);
printf("count:%d\n", count);
tdm_private_output_mode_change_handler *mode_change_handler = NULL;
TDM_RETURN_IF_FAIL(private_output != NULL);
- TDM_RETURN_IF_FAIL(TDM_MUTEX_IS_LOCKED());
if (LIST_IS_EMPTY(&private_output->mode_change_request_handler_list))
return;
ret = tdm_output_get_available_modes(output_info->output, &modes, &count);
TDM_RETURN_IF_FAIL(index < count);
- tdm_output_call_mode_set_request(output_info->output, index);
+ TDM_DBG("mode set request to index:%d", index);
- return;
+ tdm_output_call_mode_set_request(output_info->output, index);
}
static const struct wl_tdm_output_interface tdm_output_implementation = {
TDM_EXIT_IF_FAIL(data != NULL);
TDM_EXIT_IF_FAIL(buffer != NULL);
- if (count < 10)
+ if ((count < 10) || (count >=51 && count < 60))
_dump_buffer(buffer, count);
count++;
- if (count == 70) {
+ if (count == 50) {
+ tdm_client_output_mode *modes;
+ int count = 0;
+
+ printf("client: %d commited(%p), mode change request to index 1\n", count, buffer);
+ tdm_client_output_get_available_modes(data->output, &modes, &count);
+ tdm_client_output_set_mode(data->output, count - 1);
+ } else if (count == 70) {
printf("client: %d commited(%p), disconnect\n", count, buffer);
tdm_client_output_disconnect(data->output);
} else {
_voutput_make_available_mode(tdm_client_output_mode *modes, int count)
{
int i;
- for (i = 0; i < count; i++) {
+ for (i = 0 ; i < count; i++) {
modes[i].clock = 25200;
- modes[i].hdisplay = 640;
+ modes[i].hdisplay = 640 * (count - i);
modes[i].hsync_start = 656;
modes[i].hsync_end = 752;
modes[i].htotal = 800;
modes[i].hskew = 0;
- modes[i].vdisplay = 480;
+ modes[i].vdisplay = 480 * (count - i);
modes[i].vsync_start = 490;
modes[i].vsync_end = 492;
modes[i].vtotal = 525;
tdm_layer *layer;
tbm_surface_h bufs[3];
int buf_idx;
+ int need_mode_change;
+ int index;
};
struct _tdm_test_server {
static void layer_show_buffer(tdm_test_server_layer *l, tbm_surface_h b);
static void capture_attach(tdm_test_server_capture *c, tbm_surface_h b);
static void _vlayer_show_buffer(tdm_test_server_voutput *voutput);
+static void _voutput_layer_init(tdm_test_server_voutput *voutput);
static char*
parse_size(tdm_size *size, char *arg)
}
static void
+_voutput_buff_deinit(tdm_test_server_voutput *voutput)
+{
+ int i;
+
+ for (i = 0; i < 3; i++) {
+ if (!voutput->bufs[i]) continue;
+
+ tbm_surface_destroy(voutput->bufs[i]);
+ voutput->bufs[i] = NULL;
+ }
+}
+
+static void
+_voutput_buff_init(tdm_test_server_voutput *voutput)
+{
+ tdm_output *output = voutput->output;
+ const tdm_output_mode *mode;
+ tdm_error ret = TDM_ERROR_NONE;
+ int i;
+
+ ret = tdm_output_get_mode(output, &mode);
+ TDM_EXIT_IF_FAIL(ret == TDM_ERROR_NONE);
+
+ for (i = 0; i < 3; i++) {
+ tbm_surface_h b = tbm_surface_internal_create_with_flags(mode->hdisplay, mode->vdisplay, DEFAULT_FORMAT, 0);
+ TDM_EXIT_IF_FAIL(b != NULL);
+ tdm_test_buffer_fill(b, i);
+ voutput->bufs[i] = b;
+ }
+}
+static void
_vlayer_cb_commit(tdm_layer *layer, unsigned int sequence,
unsigned int tv_sec, unsigned int tv_usec, void *user_data)
{
tdm_output_conn_status status;
tdm_error ret;
- printf("voutput cb commit:\t %d: l(%p) b(%p)\n", voutput->buf_idx, voutput->layer, voutput->bufs[voutput->buf_idx]);
+ printf("voutput cb:\t %d: l(%p) b(%p)\n", voutput->buf_idx, voutput->layer, voutput->bufs[voutput->buf_idx]);
ret = tdm_output_get_conn_status(voutput->output, &status);
TDM_EXIT_IF_FAIL(ret == TDM_ERROR_NONE);
if (status == TDM_OUTPUT_CONN_STATUS_DISCONNECTED) return;
+ if (voutput->need_mode_change) {
+ const tdm_output_mode *modes;
+ int count = 0;
+
+ tdm_output_get_available_modes(voutput->output, &modes, &count);
+ if (count > voutput->index) {
+ const tdm_output_mode *mode, *current;
+
+ ret = tdm_output_get_mode(voutput->output, ¤t);
+ TDM_EXIT_IF_FAIL(ret == TDM_ERROR_NONE);
+
+ mode = &modes[voutput->index];
+
+ if (mode != current) {
+ printf("mode change to %d (%dx%d, %d)\n",
+ voutput->index, mode->hdisplay, mode->vdisplay, mode->vrefresh);
+ _voutput_buff_deinit(voutput);
+ _voutput_buff_init(voutput);
+
+ ret = tdm_output_set_mode(voutput->output, mode);
+ TDM_EXIT_IF_FAIL(ret == TDM_ERROR_NONE);
+
+ _voutput_layer_init(voutput);
+ voutput->buf_idx = 2;
+ }
+ }
+ voutput->need_mode_change = 0;
+ }
+
voutput->buf_idx++;
_vlayer_show_buffer(voutput);
}
}
static void
-_voutput_buff_init(tdm_test_server_voutput *voutput)
-{
- tdm_output *output = voutput->output;
- const tdm_output_mode *mode;
- tdm_error ret = TDM_ERROR_NONE;
- int i;
-
- ret = tdm_output_get_mode(output, &mode);
- TDM_EXIT_IF_FAIL(ret == TDM_ERROR_NONE);
-
- for (i = 0; i < 3; i++) {
- tbm_surface_h b = tbm_surface_internal_create_with_flags(mode->hdisplay, mode->vdisplay, DEFAULT_FORMAT, 0);
- TDM_EXIT_IF_FAIL(b != NULL);
- tdm_test_buffer_fill(b, i);
- voutput->bufs[i] = b;
- }
-}
-
-static void
_voutput_layer_init(tdm_test_server_voutput *voutput)
{
tdm_output *output = voutput->output;
}
static void
+_tdm_test_server_cb_output_mode_change(tdm_output *output, unsigned int index, void *user_data)
+{
+ tdm_test_server_voutput *voutput = NULL;
+ const tdm_output_mode *modes;
+ int count = 0;
+ tdm_error ret;
+
+ voutput = (tdm_test_server_voutput *)user_data;
+ TDM_EXIT_IF_FAIL(voutput != NULL);
+
+ ret = tdm_output_get_available_modes(output, &modes, &count);
+ TDM_RETURN_IF_FAIL(ret == TDM_ERROR_NONE);
+ TDM_RETURN_IF_FAIL(index < count);
+
+ voutput->need_mode_change = 1;
+ voutput->index = index;
+
+ printf("mode change request. index:%d\n", index);
+}
+
+static void
_tdm_output_cb_destroy_handler(tdm_output *output, void *user_data)
{
tdm_test_server_voutput *voutput = NULL;
- int i;
voutput = (tdm_test_server_voutput *)user_data;
TDM_EXIT_IF_FAIL(voutput != NULL);
+ tdm_output_remove_mode_change_request_handler(output, _tdm_test_server_cb_output_mode_change, voutput);
tdm_output_remove_change_handler(output, _tdm_test_server_cb_output_change, voutput);
tdm_output_remove_destroy_handler(output, _tdm_output_cb_destroy_handler, voutput);
LIST_DEL(&voutput->link);
- for (i = 0; i < 3; i++) {
- tbm_surface_destroy(voutput->bufs[i]);
- }
+ _voutput_buff_deinit(voutput);
printf("voutput: %p destroy\n", voutput);
ret = tdm_output_add_change_handler(output, _tdm_test_server_cb_output_change, voutput);
TDM_EXIT_IF_FAIL(ret == TDM_ERROR_NONE);
+ ret = tdm_output_add_mode_change_request_handler(output, _tdm_test_server_cb_output_mode_change, voutput);
+ TDM_EXIT_IF_FAIL(ret == TDM_ERROR_NONE);
+
ret = tdm_output_add_destroy_handler(output, _tdm_output_cb_destroy_handler, voutput);
TDM_EXIT_IF_FAIL(ret == TDM_ERROR_NONE);
}
LIST_FOR_EACH_ENTRY_SAFE(v, vv, &data->voutput_list, link) {
- for (int i = 0; i < 3; i++) {
- tbm_surface_destroy(v->bufs[i]);
- }
+ _voutput_buff_deinit(v);
LIST_DEL(&v->link);
free(v);
}