Capture. Implemented rotation support

Change-Id: Ieffa647577d1438418e8548034dbdb5b2b798c56
Signed-off-by: Andrii Sokolenko <a.sokolenko@samsung.com>

diff --git a/src/tdm_sprd_capture.c b/src/tdm_sprd_capture.c
index 8ce3dfb..69f811b 100644 (file)
--- a/src/tdm_sprd_capture.c
+++ b/src/tdm_sprd_capture.c
@@ -168,10 +168,13 @@ _tdm_sprd_capture_composite_sw(tdm_sprd_capture_data *capture_data,
        }
        for (i = 0; i < LAYER_COUNT_PER_OUTPUT; i++){
                if (composite_data->temp_layer_buffer[i]) {
+                       tdm_pos src_pos = {.x = 0,
+                                                          .y = 0,
+                                                          .w = tbm_surface_get_width(composite_data->temp_layer_buffer[i]),
+                                                          .h = tbm_surface_get_height(composite_data->temp_layer_buffer[i])};
                        tdm_err = tdm_helper_convert_buffer(composite_data->temp_layer_buffer[i],
-                                                                                                 composite_buf,
-                                                                                                 &composite_data->dst_pos[i],
-                                                                                                 &composite_data->dst_pos[i], 0 , 1);
+                                                                                               composite_buf, &src_pos,
+                                                                                               &composite_data->dst_pos[i], 0, 1);
                        if (tdm_err != TDM_ERROR_NONE) {
                                TDM_WRN("Capture %p error %d Can't composite buffers src %p dst %p. Skip",
                                                capture_data,  tdm_err, composite_data->temp_layer_buffer[i], composite_buf);
@@ -256,6 +259,7 @@ static tdm_error
 _tdm_sprd_capture_make_converter(tdm_sprd_capture_data *capture_data,
                                                                 tbm_surface_h src, tbm_surface_h dst,
                                                                 tdm_pos *src_pos, tdm_pos *dst_pos,
+                                                                tdm_transform transform,
                                                                 tdm_sprd_capture_pp_data ** pp_task_p)
 {
        tdm_error tdm_err = TDM_ERROR_NONE;
@@ -338,7 +342,7 @@ _tdm_sprd_capture_make_converter(tdm_sprd_capture_data *capture_data,
        info_pp.dst_config.pos.h = (dst_pos) ? dst_pos->h : tbm_surface_get_height(dst);
        info_pp.dst_config.size.h = dst_stride;
        info_pp.dst_config.size.v = tbm_surface_get_height(dst);
-
+       info_pp.transform = transform;
        if((tdm_err = sprd_pp_set_info(new_pp_task->pp_link, &info_pp)) != TDM_ERROR_NONE) {
                TDM_WRN("can't set pp info");
                tdm_err = TDM_ERROR_OPERATION_FAILED;
@@ -423,6 +427,7 @@ _tdm_sprd_capture_oneshot_composite_layers_sw(tdm_sprd_capture_data *capture_dat
                }
                if (layer_info.src_config.pos.h == 0 || layer_info.src_config.pos.w == 0) {
                        TDM_INFO("layer %p info is NULL. Skip", tdm_layer_array[i]);
+                       continue;
                }
                if (sprd_layer_get_buffer(tdm_layer_array[i], &surface) != TDM_ERROR_NONE) {
                        TDM_WRN("can't get layer %p surface. Skip", tdm_layer_array[i]);
@@ -435,29 +440,75 @@ _tdm_sprd_capture_oneshot_composite_layers_sw(tdm_sprd_capture_data *capture_dat
                tdm_buffer_ref_backend(surface);
                TDM_DBG("Get layer %p surface %p", tdm_layer_array[i], surface);
                if (1) {
-                       tbm_surface_h temp_buffer = tbm_surface_create(tbm_surface_get_width(buffer),
-                                                                                                                  tbm_surface_get_height(buffer),
+
+                       int output_width = current_mode->hdisplay;
+                       int width = layer_info.src_config.pos.w;
+                       int pos_x = layer_info.dst_pos.x;
+                       tdm_pos scale_pos = {.x = pos_x, .y = layer_info.dst_pos.y,
+                                          .w = ((width + pos_x) <= output_width ? width : output_width - pos_x),
+                                          .h = layer_info.src_config.pos.h};
+                       tdm_pos dst_pos = capture_data->info.dst_config.pos;
+                       TDM_DBG("src_pos (x)(y)+(w)+(h) (%d)(%d)+(%d)+(%d)", scale_pos.x, scale_pos.y,
+                                       scale_pos.w, scale_pos.h);
+                       TDM_DBG("dst_pos (x)(y)+(w)+(h) (%d)(%d)+(%d)+(%d)", dst_pos.x, dst_pos.y,
+                                       dst_pos.w, dst_pos.h);
+                       if (dst_pos.w == 0 || dst_pos.h == 0) {
+                               dst_pos.x = 0;
+                               dst_pos.y = 0;
+                               dst_pos.h = tbm_surface_get_height(buffer);
+                               dst_pos.w = tbm_surface_get_width(buffer);
+                               _tdm_sprd_capture_oneshot_rect_scale(current_mode->hdisplay,
+                                                                                                        current_mode->vdisplay,
+                                                                                                        tbm_surface_get_width(buffer),
+                                                                                                        tbm_surface_get_height(buffer),
+                                                                                                        &dst_pos);
+                               TDM_DBG("--> new_dst_pos (x)(y)+(w)+(h) (%d)(%d)+(%d)+(%d)", dst_pos.x, dst_pos.y,
+                                               dst_pos.w, dst_pos.h);
+                       }
+                       if (capture_data->info.transform & 1) {
+                               int temp = 0;
+                               temp = scale_pos.x;
+                               scale_pos.x = scale_pos.y;
+                               scale_pos.y = temp;
+                               temp = scale_pos.w;
+                               scale_pos.w = scale_pos.h;
+                               scale_pos.h = temp;
+                               _tdm_sprd_capture_oneshot_rect_scale(current_mode->vdisplay,
+                                                                                                        current_mode->hdisplay,
+                                                                                                        dst_pos.w, dst_pos.h, &scale_pos);
+                       } else {
+                               _tdm_sprd_capture_oneshot_rect_scale(current_mode->hdisplay,
+                                                                                                        current_mode->vdisplay,
+                                                                                                        dst_pos.w, dst_pos.h, &scale_pos);
+                       }
+
+                       TDM_DBG("scale_pos (x)(y)+(w)+(h) (%d)(%d)+(%d)+(%d)", scale_pos.x, scale_pos.y,
+                                       scale_pos.w, scale_pos.h);
+/*
+                       if (capture_data->info.transform & 1) {
+
+                       }
+*/
+                       tbm_surface_h temp_buffer = tbm_surface_create(dst_pos.w,
+                                                                                                                  dst_pos.h,
                                                                                                                   TBM_FORMAT_ARGB8888);
                        if (temp_buffer == NULL) {
                                TDM_WRN("Out of memory");
                                tdm_buffer_unref_backend(surface);
                                continue;
                        }
-                       tdm_pos src_pos = {.x = 0, .y = 0,
-                                                          .w = tbm_surface_get_width(surface),
-                                                          .h = tbm_surface_get_height(surface)};
-                       int output_width = current_mode->hdisplay;
-                       int width = layer_info.src_config.pos.w;
-                       int pos_x = layer_info.dst_pos.x;
-                       tdm_pos dst_pos = {.x = pos_x, .y = layer_info.dst_pos.y,
-                                                          .w = ((width + pos_x) <= output_width ? width : output_width - pos_x),
-                                                          .h = layer_info.src_config.pos.h };
-                       _tdm_sprd_capture_oneshot_rect_scale(current_mode->hdisplay, current_mode->vdisplay,
-                                                                                                tbm_surface_get_width(buffer),
-                                                                                                tbm_surface_get_height(buffer),
-                                                                                                &dst_pos);
+
+                       dst_pos.x+= scale_pos.x;
+                       dst_pos.y+= scale_pos.y;
+                       dst_pos.h = scale_pos.h;
+                       dst_pos.w = scale_pos.w;
+
+                       TDM_DBG("adapted dst_pos (x)(y)+(w)+(h) (%d)(%d)+(%d)+(%d)", dst_pos.x, dst_pos.y,
+                                       dst_pos.w, dst_pos.h);
+
                        tdm_err = _tdm_sprd_capture_make_converter(capture_data, surface, temp_buffer,
-                                                                                                          &src_pos, &dst_pos, &pp_tasks[i]);
+                                                                                                          NULL, NULL, capture_data->info.transform,
+                                                                                                          &pp_tasks[i]);
                        if (tdm_err != TDM_ERROR_NONE) {
                                TDM_WRN("can't create converter");
                                tdm_buffer_unref_backend(surface);
@@ -499,7 +550,7 @@ _tdm_sprd_capture_oneshot_composite_layers_sw(tdm_sprd_capture_data *capture_dat
                }
                tdm_err = _tdm_sprd_capture_make_converter(capture_data, composite_data->temp_composite_buffer,
                                                                                                   composite_data->client_buffer,
-                                                                                                  NULL, NULL, &pp_task);
+                                                                                                  NULL, NULL, 0, &pp_task);
                if (tdm_err != TDM_ERROR_NONE) {
                        TDM_WRN("can't create converter");
                        goto fail;