| 1 | /* |
| 2 | * Copyright (C) 2013 The Android Open Source Project |
| 3 | * Copyright@ Samsung Electronics Co. LTD |
| 4 | * |
| 5 | * Licensed under the Apache License, Version 2.0 (the "License"); |
| 6 | * you may not use this file except in compliance with the License. |
| 7 | * You may obtain a copy of the License at |
| 8 | * |
| 9 | * http://www.apache.org/licenses/LICENSE-2.0 |
| 10 | * |
| 11 | * Unless required by applicable law or agreed to in writing, software |
| 12 | * distributed under the License is distributed on an "AS IS" BASIS, |
| 13 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 14 | * See the License for the specific language governing permissions and |
| 15 | * limitations under the License. |
| 16 | */ |
| 17 | |
| 18 | /*! |
| 19 | * \file libgscaler_obj.cpp |
| 20 | * \brief source file for Gscaler HAL |
| 21 | * \author Sungchun Kang (sungchun.kang@samsung.com) |
| 22 | * \date 2013/06/01 |
| 23 | * |
| 24 | * <b>Revision History: </b> |
| 25 | * - 2013.06.01 : Sungchun Kang (sungchun.kang@samsung.com) \n |
| 26 | * Create |
| 27 | */ |
| 28 | |
| 29 | #include "libgscaler_obj.h" |
| 30 | #include "content_protect.h" |
| 31 | |
| 32 | int CGscaler::m_gsc_output_create(void *handle, int dev_num, int out_mode) |
| 33 | { |
| 34 | Exynos_gsc_In(); |
| 35 | |
| 36 | struct media_device *media0; |
| 37 | struct media_entity *gsc_sd_entity; |
| 38 | struct media_entity *gsc_vd_entity; |
| 39 | struct media_entity *sink_sd_entity; |
| 40 | struct media_link *links; |
| 41 | char node[32]; |
| 42 | char devname[32]; |
| 43 | unsigned int cap; |
| 44 | int i; |
| 45 | int fd = 0; |
| 46 | CGscaler* gsc = GetGscaler(handle); |
| 47 | if (gsc == NULL) { |
| 48 | ALOGE("%s::handle == NULL() fail", __func__); |
| 49 | return -1; |
| 50 | } |
| 51 | |
| 52 | if ((out_mode != GSC_OUT_FIMD) && |
| 53 | (out_mode != GSC_OUT_TV)) |
| 54 | return -1; |
| 55 | |
| 56 | gsc->out_mode = out_mode; |
| 57 | /* GSCX => FIMD_WINX : arbitrary linking is not allowed */ |
| 58 | if ((out_mode == GSC_OUT_FIMD) && |
| 59 | #ifndef USES_ONLY_GSC0_GSC1 |
| 60 | (dev_num > 2)) |
| 61 | #else |
| 62 | (dev_num > 1)) |
| 63 | #endif |
| 64 | return -1; |
| 65 | |
| 66 | /* media0 */ |
| 67 | snprintf(node, sizeof(node), "%s%d", PFX_NODE_MEDIADEV, 0); |
| 68 | media0 = exynos_media_open(node); |
| 69 | if (media0 == NULL) { |
| 70 | ALOGE("%s::exynos_media_open failed (node=%s)", __func__, node); |
| 71 | return false; |
| 72 | } |
| 73 | gsc->mdev.media0 = media0; |
| 74 | |
| 75 | /* Get the sink subdev entity by name and make the node of sink subdev*/ |
| 76 | if (out_mode == GSC_OUT_FIMD) |
| 77 | snprintf(devname, sizeof(devname), PFX_FIMD_ENTITY, dev_num); |
| 78 | else |
| 79 | snprintf(devname, sizeof(devname), PFX_MXR_ENTITY, 0); |
| 80 | |
| 81 | sink_sd_entity = exynos_media_get_entity_by_name(media0, devname, |
| 82 | strlen(devname)); |
| 83 | if (!sink_sd_entity) { |
| 84 | ALOGE("%s:: failed to get the sink sd entity", __func__); |
| 85 | goto gsc_output_err; |
| 86 | } |
| 87 | gsc->mdev.sink_sd_entity = sink_sd_entity; |
| 88 | |
| 89 | sink_sd_entity->fd = exynos_subdev_open_devname(devname, O_RDWR); |
| 90 | if (sink_sd_entity->fd < 0) { |
| 91 | ALOGE("%s:: failed to open sink subdev node", __func__); |
| 92 | goto gsc_output_err; |
| 93 | } |
| 94 | |
| 95 | /* get GSC video dev & sub dev entity by name*/ |
| 96 | #if defined(USES_DT) |
| 97 | switch (dev_num) { |
| 98 | case 0: |
| 99 | snprintf(devname, sizeof(devname), PFX_GSC_VIDEODEV_ENTITY0); |
| 100 | break; |
| 101 | case 1: |
| 102 | snprintf(devname, sizeof(devname), PFX_GSC_VIDEODEV_ENTITY1); |
| 103 | break; |
| 104 | case 2: |
| 105 | snprintf(devname, sizeof(devname), PFX_GSC_VIDEODEV_ENTITY2); |
| 106 | break; |
| 107 | } |
| 108 | #else |
| 109 | snprintf(devname, sizeof(devname), PFX_GSC_VIDEODEV_ENTITY, dev_num); |
| 110 | #endif |
| 111 | gsc_vd_entity = exynos_media_get_entity_by_name(media0, devname, |
| 112 | strlen(devname)); |
| 113 | if (!gsc_vd_entity) { |
| 114 | ALOGE("%s:: failed to get the gsc vd entity", __func__); |
| 115 | goto gsc_output_err; |
| 116 | } |
| 117 | gsc->mdev.gsc_vd_entity = gsc_vd_entity; |
| 118 | |
| 119 | snprintf(devname, sizeof(devname), PFX_GSC_SUBDEV_ENTITY, dev_num); |
| 120 | gsc_sd_entity = exynos_media_get_entity_by_name(media0, devname, |
| 121 | strlen(devname)); |
| 122 | if (!gsc_sd_entity) { |
| 123 | ALOGE("%s:: failed to get the gsc sd entity", __func__); |
| 124 | goto gsc_output_err; |
| 125 | } |
| 126 | gsc->mdev.gsc_sd_entity = gsc_sd_entity; |
| 127 | |
| 128 | /* gsc sub-dev open */ |
| 129 | snprintf(devname, sizeof(devname), PFX_GSC_SUBDEV_ENTITY, dev_num); |
| 130 | gsc_sd_entity->fd = exynos_subdev_open_devname(devname, O_RDWR); |
| 131 | if (gsc_sd_entity->fd < 0) { |
| 132 | ALOGE("%s: gsc sub-dev open fail", __func__); |
| 133 | goto gsc_output_err; |
| 134 | } |
| 135 | |
| 136 | /* setup link : GSC : video device --> sub device */ |
| 137 | for (i = 0; i < (int) gsc_vd_entity->num_links; i++) { |
| 138 | links = &gsc_vd_entity->links[i]; |
| 139 | |
| 140 | if (links == NULL || |
| 141 | links->source->entity != gsc_vd_entity || |
| 142 | links->sink->entity != gsc_sd_entity) { |
| 143 | continue; |
| 144 | } else if (exynos_media_setup_link(media0, links->source, |
| 145 | links->sink, MEDIA_LNK_FL_ENABLED) < 0) { |
| 146 | ALOGE("%s::exynos_media_setup_link \ |
| 147 | [src.entity=%d->sink.entity=%d] failed", |
| 148 | __func__, links->source->entity->info.id, |
| 149 | links->sink->entity->info.id); |
| 150 | return -1; |
| 151 | } |
| 152 | } |
| 153 | |
| 154 | /* setup link : GSC: sub device --> sink device */ |
| 155 | for (i = 0; i < (int) gsc_sd_entity->num_links; i++) { |
| 156 | links = &gsc_sd_entity->links[i]; |
| 157 | |
| 158 | if (links == NULL || links->source->entity != gsc_sd_entity || |
| 159 | links->sink->entity != sink_sd_entity) { |
| 160 | continue; |
| 161 | } else if (exynos_media_setup_link(media0, links->source, |
| 162 | links->sink, MEDIA_LNK_FL_ENABLED) < 0) { |
| 163 | ALOGE("%s::exynos_media_setup_link \ |
| 164 | [src.entity=%d->sink.entity=%d] failed", |
| 165 | __func__, links->source->entity->info.id, |
| 166 | links->sink->entity->info.id); |
| 167 | return -1; |
| 168 | } |
| 169 | } |
| 170 | |
| 171 | /* gsc video-dev open */ |
| 172 | #if defined(USES_DT) |
| 173 | switch (dev_num) { |
| 174 | case 0: |
| 175 | snprintf(devname, sizeof(devname), PFX_GSC_VIDEODEV_ENTITY0); |
| 176 | break; |
| 177 | case 1: |
| 178 | snprintf(devname, sizeof(devname), PFX_GSC_VIDEODEV_ENTITY1); |
| 179 | break; |
| 180 | case 2: |
| 181 | snprintf(devname, sizeof(devname), PFX_GSC_VIDEODEV_ENTITY2); |
| 182 | break; |
| 183 | } |
| 184 | #else |
| 185 | snprintf(devname, sizeof(devname), PFX_GSC_VIDEODEV_ENTITY, dev_num); |
| 186 | #endif |
| 187 | gsc_vd_entity->fd = exynos_v4l2_open_devname(devname, O_RDWR); |
| 188 | if (gsc_vd_entity->fd < 0) { |
| 189 | ALOGE("%s: gsc video-dev open fail", __func__); |
| 190 | goto gsc_output_err; |
| 191 | } |
| 192 | |
| 193 | cap = V4L2_CAP_STREAMING | V4L2_CAP_VIDEO_OUTPUT_MPLANE; |
| 194 | |
| 195 | if (exynos_v4l2_querycap(gsc_vd_entity->fd, cap) == false) { |
| 196 | ALOGE("%s::exynos_v4l2_querycap() fail", __func__); |
| 197 | goto gsc_output_err; |
| 198 | } |
| 199 | |
| 200 | Exynos_gsc_Out(); |
| 201 | |
| 202 | return 0; |
| 203 | |
| 204 | gsc_output_err: |
| 205 | gsc->m_gsc_out_destroy(handle); |
| 206 | |
| 207 | return -1; |
| 208 | } |
| 209 | |
| 210 | int CGscaler::m_gsc_out_stop(void *handle) |
| 211 | { |
| 212 | Exynos_gsc_In(); |
| 213 | |
| 214 | struct v4l2_requestbuffers reqbuf; |
| 215 | CGscaler* gsc = GetGscaler(handle); |
| 216 | if (gsc == NULL) { |
| 217 | ALOGE("%s::handle == NULL() fail", __func__); |
| 218 | return -1; |
| 219 | } |
| 220 | |
| 221 | if (gsc->src_info.stream_on == false) { |
| 222 | /* to handle special scenario.*/ |
| 223 | gsc->src_info.qbuf_cnt = 0; |
| 224 | ALOGD("%s::GSC is already stopped", __func__); |
| 225 | goto SKIP_STREAMOFF; |
| 226 | } |
| 227 | gsc->src_info.qbuf_cnt = 0; |
| 228 | gsc->src_info.stream_on = false; |
| 229 | |
| 230 | if (exynos_v4l2_streamoff(gsc->mdev.gsc_vd_entity->fd, |
| 231 | V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) < 0) { |
| 232 | ALOGE("%s::stream off failed", __func__); |
| 233 | return -1; |
| 234 | } |
| 235 | |
| 236 | SKIP_STREAMOFF: |
| 237 | Exynos_gsc_Out(); |
| 238 | |
| 239 | return 0; |
| 240 | } |
| 241 | |
| 242 | bool CGscaler::m_gsc_out_destroy(void *handle) |
| 243 | { |
| 244 | Exynos_gsc_In(); |
| 245 | |
| 246 | struct media_link * links; |
| 247 | int i; |
| 248 | CGscaler* gsc = GetGscaler(handle); |
| 249 | if (gsc == NULL) { |
| 250 | ALOGE("%s::handle == NULL() fail", __func__); |
| 251 | return false; |
| 252 | } |
| 253 | |
| 254 | if (gsc->src_info.stream_on == true) { |
| 255 | if (gsc->m_gsc_out_stop(gsc) < 0) |
| 256 | ALOGE("%s::m_gsc_out_stop() fail", __func__); |
| 257 | |
| 258 | gsc->src_info.stream_on = false; |
| 259 | } |
| 260 | |
| 261 | if (gsc->mdev.media0 && gsc->mdev.gsc_sd_entity && |
| 262 | gsc->mdev.gsc_vd_entity && gsc->mdev.sink_sd_entity) { |
| 263 | |
| 264 | /* unlink : gscaler-out --> fimd */ |
| 265 | for (i = 0; i < (int) gsc->mdev.gsc_sd_entity->num_links; i++) { |
| 266 | links = &gsc->mdev.gsc_sd_entity->links[i]; |
| 267 | if (links == NULL || |
| 268 | links->source->entity != gsc->mdev.gsc_sd_entity || |
| 269 | links->sink->entity != gsc->mdev.sink_sd_entity) { |
| 270 | continue; |
| 271 | } else if (exynos_media_setup_link(gsc->mdev.media0, |
| 272 | links->source, links->sink, 0) < 0) { |
| 273 | ALOGE("%s::exynos_media_setup_unlink \ |
| 274 | [src.entity=%d->sink.entity=%d] failed", |
| 275 | __func__, links->source->entity->info.id, |
| 276 | links->sink->entity->info.id); |
| 277 | } |
| 278 | } |
| 279 | } |
| 280 | |
| 281 | if (gsc->mdev.gsc_vd_entity && gsc->mdev.gsc_vd_entity->fd > 0) { |
| 282 | close(gsc->mdev.gsc_vd_entity->fd); |
| 283 | gsc->mdev.gsc_vd_entity->fd = -1; |
| 284 | } |
| 285 | |
| 286 | if (gsc->mdev.gsc_sd_entity && gsc->mdev.gsc_sd_entity->fd > 0) { |
| 287 | close(gsc->mdev.gsc_sd_entity->fd); |
| 288 | gsc->mdev.gsc_sd_entity->fd = -1; |
| 289 | } |
| 290 | |
| 291 | if (gsc->mdev.sink_sd_entity && gsc->mdev.sink_sd_entity->fd > 0) { |
| 292 | close(gsc->mdev.sink_sd_entity->fd); |
| 293 | gsc->mdev.sink_sd_entity->fd = -1; |
| 294 | } |
| 295 | |
| 296 | if (gsc->mdev.media0) |
| 297 | exynos_media_close(gsc->mdev.media0); |
| 298 | |
| 299 | gsc->mdev.media0 = NULL; |
| 300 | gsc->mdev.gsc_sd_entity = NULL; |
| 301 | gsc->mdev.gsc_vd_entity = NULL; |
| 302 | gsc->mdev.sink_sd_entity = NULL; |
| 303 | |
| 304 | Exynos_gsc_Out(); |
| 305 | return true; |
| 306 | } |
| 307 | |
| 308 | int CGscaler::m_gsc_m2m_create(int dev) |
| 309 | { |
| 310 | Exynos_gsc_In(); |
| 311 | |
| 312 | int fd = 0; |
| 313 | int video_node_num; |
| 314 | unsigned int cap; |
| 315 | char node[32]; |
| 316 | |
| 317 | switch(dev) { |
| 318 | case 0: |
| 319 | video_node_num = NODE_NUM_GSC_0; |
| 320 | break; |
| 321 | case 1: |
| 322 | video_node_num = NODE_NUM_GSC_1; |
| 323 | break; |
| 324 | #ifndef USES_ONLY_GSC0_GSC1 |
| 325 | case 2: |
| 326 | video_node_num = NODE_NUM_GSC_2; |
| 327 | break; |
| 328 | case 3: |
| 329 | video_node_num = NODE_NUM_GSC_3; |
| 330 | break; |
| 331 | #endif |
| 332 | default: |
| 333 | ALOGE("%s::unexpected dev(%d) fail", __func__, dev); |
| 334 | return -1; |
| 335 | break; |
| 336 | } |
| 337 | |
| 338 | snprintf(node, sizeof(node), "%s%d", PFX_NODE_GSC, video_node_num); |
| 339 | fd = exynos_v4l2_open(node, O_RDWR); |
| 340 | if (fd < 0) { |
| 341 | ALOGE("%s::exynos_v4l2_open(%s) fail", __func__, node); |
| 342 | return -1; |
| 343 | } |
| 344 | |
| 345 | cap = V4L2_CAP_STREAMING | |
| 346 | V4L2_CAP_VIDEO_OUTPUT_MPLANE | |
| 347 | V4L2_CAP_VIDEO_CAPTURE_MPLANE; |
| 348 | |
| 349 | if (exynos_v4l2_querycap(fd, cap) == false) { |
| 350 | ALOGE("%s::exynos_v4l2_querycap() fail", __func__); |
| 351 | close(fd); |
| 352 | fd = 0; |
| 353 | return -1; |
| 354 | } |
| 355 | |
| 356 | Exynos_gsc_Out(); |
| 357 | |
| 358 | return fd; |
| 359 | } |
| 360 | |
| 361 | bool CGscaler::m_gsc_find_and_create(void *handle) |
| 362 | { |
| 363 | Exynos_gsc_In(); |
| 364 | |
| 365 | int i = 0; |
| 366 | bool flag_find_new_gsc = false; |
| 367 | unsigned int total_sleep_time = 0; |
| 368 | CGscaler* gsc = GetGscaler(handle); |
| 369 | if (gsc == NULL) { |
| 370 | ALOGE("%s::handle == NULL() fail", __func__); |
| 371 | return false; |
| 372 | } |
| 373 | |
| 374 | do { |
| 375 | for (i = 0; i < NUM_OF_GSC_HW; i++) { |
| 376 | #ifndef USES_ONLY_GSC0_GSC1 |
| 377 | if (i == 0 || i == 3) |
| 378 | #else |
| 379 | if (i == 0) |
| 380 | #endif |
| 381 | continue; |
| 382 | |
| 383 | gsc->gsc_id = i; |
| 384 | gsc->gsc_fd = gsc->m_gsc_m2m_create(i); |
| 385 | if (gsc->gsc_fd < 0) { |
| 386 | gsc->gsc_fd = 0; |
| 387 | continue; |
| 388 | } |
| 389 | |
| 390 | flag_find_new_gsc = true; |
| 391 | break; |
| 392 | } |
| 393 | |
| 394 | if (flag_find_new_gsc == false) { |
| 395 | usleep(GSC_WAITING_TIME_FOR_TRYLOCK); |
| 396 | total_sleep_time += GSC_WAITING_TIME_FOR_TRYLOCK; |
| 397 | ALOGV("%s::waiting for the gscaler availability", __func__); |
| 398 | } |
| 399 | |
| 400 | } while(flag_find_new_gsc == false |
| 401 | && total_sleep_time < MAX_GSC_WAITING_TIME_FOR_TRYLOCK); |
| 402 | |
| 403 | if (flag_find_new_gsc == false) |
| 404 | ALOGE("%s::we don't have any available gsc.. fail", __func__); |
| 405 | |
| 406 | Exynos_gsc_Out(); |
| 407 | |
| 408 | return flag_find_new_gsc; |
| 409 | } |
| 410 | |
| 411 | bool CGscaler::m_gsc_m2m_destroy(void *handle) |
| 412 | { |
| 413 | Exynos_gsc_In(); |
| 414 | |
| 415 | CGscaler* gsc = GetGscaler(handle); |
| 416 | if (gsc == NULL) { |
| 417 | ALOGE("%s::handle == NULL() fail", __func__); |
| 418 | return false; |
| 419 | } |
| 420 | |
| 421 | /* |
| 422 | * just in case, we call stop here because we cannot afford to leave |
| 423 | * secure side protection on if things failed. |
| 424 | */ |
| 425 | gsc->m_gsc_m2m_stop(handle); |
| 426 | |
| 427 | if (gsc->gsc_id >= HW_SCAL0) { |
| 428 | bool ret = exynos_sc_free_and_close(gsc->scaler); |
| 429 | Exynos_gsc_Out(); |
| 430 | return ret; |
| 431 | } |
| 432 | |
| 433 | if (0 < gsc->gsc_fd) |
| 434 | close(gsc->gsc_fd); |
| 435 | gsc->gsc_fd = 0; |
| 436 | |
| 437 | Exynos_gsc_Out(); |
| 438 | |
| 439 | return true; |
| 440 | } |
| 441 | |
| 442 | int CGscaler::m_gsc_m2m_stop(void *handle) |
| 443 | { |
| 444 | Exynos_gsc_In(); |
| 445 | |
| 446 | struct v4l2_requestbuffers req_buf; |
| 447 | int ret = 0; |
| 448 | CGscaler* gsc = GetGscaler(handle); |
| 449 | if (gsc == NULL) { |
| 450 | ALOGE("%s::handle == NULL() fail", __func__); |
| 451 | return -1; |
| 452 | } |
| 453 | |
| 454 | if (!gsc->src_info.stream_on && !gsc->dst_info.stream_on) { |
| 455 | /* wasn't streaming, return success */ |
| 456 | return 0; |
| 457 | } else if (gsc->src_info.stream_on != gsc->dst_info.stream_on) { |
| 458 | ALOGE("%s: invalid state, queue stream state doesn't match \ |
| 459 | (%d != %d)", __func__, gsc->src_info.stream_on, |
| 460 | gsc->dst_info.stream_on); |
| 461 | ret = -1; |
| 462 | } |
| 463 | |
| 464 | /* |
| 465 | * we need to plow forward on errors below to make sure that if we had |
| 466 | * turned on content protection on secure side, we turn it off. |
| 467 | * |
| 468 | * also, if we only failed to turn on one of the streams, we'll turn |
| 469 | * the other one off correctly. |
| 470 | */ |
| 471 | if (gsc->src_info.stream_on == true) { |
| 472 | if (exynos_v4l2_streamoff(gsc->gsc_fd, |
| 473 | gsc->src_info.buf.buf_type) < 0) { |
| 474 | ALOGE("%s::exynos_v4l2_streamoff(src) fail", __func__); |
| 475 | ret = -1; |
| 476 | } |
| 477 | gsc->src_info.stream_on = false; |
| 478 | } |
| 479 | |
| 480 | if (gsc->dst_info.stream_on == true) { |
| 481 | if (exynos_v4l2_streamoff(gsc->gsc_fd, |
| 482 | gsc->dst_info.buf.buf_type) < 0) { |
| 483 | ALOGE("%s::exynos_v4l2_streamoff(dst) fail", __func__); |
| 484 | ret = -1; |
| 485 | } |
| 486 | gsc->dst_info.stream_on = false; |
| 487 | } |
| 488 | |
| 489 | /* if drm is enabled */ |
| 490 | if (gsc->allow_drm && gsc->protection_enabled) { |
| 491 | unsigned int protect_id = 0; |
| 492 | |
| 493 | if (gsc->gsc_id == 0) |
| 494 | protect_id = CP_PROTECT_GSC0; |
| 495 | else if (gsc->gsc_id == 1) |
| 496 | protect_id = CP_PROTECT_GSC1; |
| 497 | else if (gsc->gsc_id == 2) |
| 498 | protect_id = CP_PROTECT_GSC3; |
| 499 | else if (gsc->gsc_id == 3) |
| 500 | protect_id = CP_PROTECT_GSC3; |
| 501 | |
| 502 | CP_Disable_Path_Protection(protect_id); |
| 503 | gsc->protection_enabled = false; |
| 504 | } |
| 505 | |
| 506 | if (exynos_v4l2_s_ctrl(gsc->gsc_fd, |
| 507 | V4L2_CID_CONTENT_PROTECTION, 0) < 0) { |
| 508 | ALOGE("%s::exynos_v4l2_s_ctrl(V4L2_CID_CONTENT_PROTECTION) fail", |
| 509 | __func__); |
| 510 | ret = -1; |
| 511 | } |
| 512 | |
| 513 | /* src: clear_buf */ |
| 514 | req_buf.count = 0; |
| 515 | req_buf.type = gsc->src_info.buf.buf_type; |
| 516 | req_buf.memory = gsc->src_info.buf.mem_type; |
| 517 | if (exynos_v4l2_reqbufs(gsc->gsc_fd, &req_buf) < 0) { |
| 518 | ALOGE("%s::exynos_v4l2_reqbufs():src: fail", __func__); |
| 519 | ret = -1; |
| 520 | } |
| 521 | |
| 522 | /* dst: clear_buf */ |
| 523 | req_buf.count = 0; |
| 524 | req_buf.type = gsc->dst_info.buf.buf_type; |
| 525 | req_buf.memory = gsc->dst_info.buf.mem_type;; |
| 526 | if (exynos_v4l2_reqbufs(gsc->gsc_fd, &req_buf) < 0) { |
| 527 | ALOGE("%s::exynos_v4l2_reqbufs():dst: fail", __func__); |
| 528 | ret = -1; |
| 529 | } |
| 530 | |
| 531 | Exynos_gsc_Out(); |
| 532 | |
| 533 | return ret; |
| 534 | } |
| 535 | |
| 536 | int CGscaler::m_gsc_m2m_run_core(void *handle) |
| 537 | { |
| 538 | Exynos_gsc_In(); |
| 539 | |
| 540 | unsigned int rotate, hflip, vflip; |
| 541 | bool is_dirty; |
| 542 | bool is_drm; |
| 543 | CGscaler* gsc = GetGscaler(handle); |
| 544 | if (gsc == NULL) { |
| 545 | ALOGE("%s::handle == NULL() fail", __func__); |
| 546 | return -1; |
| 547 | } |
| 548 | |
| 549 | is_dirty = gsc->src_info.dirty || gsc->dst_info.dirty; |
| 550 | is_drm = gsc->src_info.mode_drm; |
| 551 | |
| 552 | if (is_dirty && (gsc->src_info.mode_drm != gsc->dst_info.mode_drm)) { |
| 553 | ALOGE("%s: drm mode mismatch between src and dst, \ |
| 554 | gsc%d (s=%d d=%d)", __func__, gsc->gsc_id, |
| 555 | gsc->src_info.mode_drm, gsc->dst_info.mode_drm); |
| 556 | return -1; |
| 557 | } else if (is_drm && !gsc->allow_drm) { |
| 558 | ALOGE("%s: drm mode is not supported on gsc%d", __func__, |
| 559 | gsc->gsc_id); |
| 560 | return -1; |
| 561 | } |
| 562 | |
| 563 | CGscaler::rotateValueHAL2GSC(gsc->dst_img.rot, &rotate, &hflip, &vflip); |
| 564 | |
| 565 | if (CGscaler::m_gsc_check_src_size(&gsc->src_info.width, |
| 566 | &gsc->src_info.height, &gsc->src_info.crop_left, |
| 567 | &gsc->src_info.crop_top, &gsc->src_info.crop_width, |
| 568 | &gsc->src_info.crop_height, gsc->src_info.v4l2_colorformat, |
| 569 | (rotate == 90 || rotate == 270)) == false) { |
| 570 | ALOGE("%s::m_gsc_check_src_size() fail", __func__); |
| 571 | return -1; |
| 572 | } |
| 573 | |
| 574 | if (CGscaler::m_gsc_check_dst_size(&gsc->dst_info.width, |
| 575 | &gsc->dst_info.height, &gsc->dst_info.crop_left, |
| 576 | &gsc->dst_info.crop_top, &gsc->dst_info.crop_width, |
| 577 | &gsc->dst_info.crop_height, gsc->dst_info.v4l2_colorformat, |
| 578 | gsc->dst_info.rotation) == false) { |
| 579 | ALOGE("%s::m_gsc_check_dst_size() fail", __func__); |
| 580 | return -1; |
| 581 | } |
| 582 | |
| 583 | /* dequeue buffers from previous work if necessary */ |
| 584 | if (gsc->src_info.stream_on == true) { |
| 585 | if (gsc->m_gsc_m2m_wait_frame_done(handle) < 0) { |
| 586 | ALOGE("%s::exynos_gsc_m2m_wait_frame_done fail", __func__); |
| 587 | return -1; |
| 588 | } |
| 589 | } |
| 590 | |
| 591 | /* |
| 592 | * need to set the content protection flag before doing reqbufs |
| 593 | * in set_format |
| 594 | */ |
| 595 | if (is_dirty && gsc->allow_drm && is_drm) { |
| 596 | if (exynos_v4l2_s_ctrl(gsc->gsc_fd, |
| 597 | V4L2_CID_CONTENT_PROTECTION, is_drm) < 0) { |
| 598 | ALOGE("%s::exynos_v4l2_s_ctrl() fail", __func__); |
| 599 | return -1; |
| 600 | } |
| 601 | } |
| 602 | |
| 603 | /* |
| 604 | * from this point on, we have to ensure to call stop to clean up |
| 605 | * whatever state we have set. |
| 606 | */ |
| 607 | |
| 608 | if (gsc->src_info.dirty) { |
| 609 | if (CGscaler::m_gsc_set_format(gsc->gsc_fd, &gsc->src_info) == false) { |
| 610 | ALOGE("%s::m_gsc_set_format(src) fail", __func__); |
| 611 | goto done; |
| 612 | } |
| 613 | gsc->src_info.dirty = false; |
| 614 | } |
| 615 | |
| 616 | if (gsc->dst_info.dirty) { |
| 617 | if (CGscaler::m_gsc_set_format(gsc->gsc_fd, &gsc->dst_info) == false) { |
| 618 | ALOGE("%s::m_gsc_set_format(dst) fail", __func__); |
| 619 | goto done; |
| 620 | } |
| 621 | gsc->dst_info.dirty = false; |
| 622 | } |
| 623 | |
| 624 | /* |
| 625 | * set up csc equation property |
| 626 | */ |
| 627 | if (is_dirty) { |
| 628 | if (exynos_v4l2_s_ctrl(gsc->gsc_fd, |
| 629 | V4L2_CID_CSC_EQ_MODE, gsc->eq_auto) < 0) { |
| 630 | ALOGE("%s::exynos_v4l2_s_ctrl(V4L2_CID_CSC_EQ_MODE) fail", __func__); |
| 631 | return -1; |
| 632 | } |
| 633 | |
| 634 | if (exynos_v4l2_s_ctrl(gsc->gsc_fd, |
| 635 | V4L2_CID_CSC_EQ, gsc->v4l2_colorspace) < 0) { |
| 636 | ALOGE("%s::exynos_v4l2_s_ctrl(V4L2_CID_CSC_EQ) fail", __func__); |
| 637 | return -1; |
| 638 | } |
| 639 | |
| 640 | if (exynos_v4l2_s_ctrl(gsc->gsc_fd, |
| 641 | V4L2_CID_CSC_RANGE, gsc->range_full) < 0) { |
| 642 | ALOGE("%s::exynos_v4l2_s_ctrl(V4L2_CID_CSC_RANGE) fail", __func__); |
| 643 | return -1; |
| 644 | } |
| 645 | } |
| 646 | |
| 647 | /* if we are enabling drm, make sure to enable hw protection. |
| 648 | * Need to do this before queuing buffers so that the mmu is reserved |
| 649 | * and power domain is kept on. |
| 650 | */ |
| 651 | if (is_dirty && gsc->allow_drm && is_drm) { |
| 652 | unsigned int protect_id = 0; |
| 653 | |
| 654 | if (gsc->gsc_id == 0) { |
| 655 | protect_id = CP_PROTECT_GSC0; |
| 656 | } else if (gsc->gsc_id == 1) { |
| 657 | protect_id = CP_PROTECT_GSC1; |
| 658 | } else if (gsc->gsc_id == 2) { |
| 659 | protect_id = CP_PROTECT_GSC2; |
| 660 | } else if (gsc->gsc_id == 3) { |
| 661 | protect_id = CP_PROTECT_GSC3; |
| 662 | } else { |
| 663 | ALOGE("%s::invalid gscaler id %d for content protection", |
| 664 | __func__, gsc->gsc_id); |
| 665 | goto done; |
| 666 | } |
| 667 | |
| 668 | if (CP_Enable_Path_Protection(protect_id) != 0) { |
| 669 | ALOGE("%s::CP_Enable_Path_Protection failed", __func__); |
| 670 | goto done; |
| 671 | } |
| 672 | gsc->protection_enabled = true; |
| 673 | } |
| 674 | |
| 675 | if (gsc->m_gsc_set_addr(gsc->gsc_fd, &gsc->src_info) == false) { |
| 676 | ALOGE("%s::m_gsc_set_addr(src) fail", __func__); |
| 677 | goto done; |
| 678 | } |
| 679 | |
| 680 | if (gsc->m_gsc_set_addr(gsc->gsc_fd, &gsc->dst_info) == false) { |
| 681 | ALOGE("%s::m_gsc_set_addr(dst) fail", __func__); |
| 682 | goto done; |
| 683 | } |
| 684 | |
| 685 | if (gsc->src_info.stream_on == false) { |
| 686 | if (exynos_v4l2_streamon(gsc->gsc_fd, gsc->src_info.buf.buf_type) < 0) { |
| 687 | ALOGE("%s::exynos_v4l2_streamon(src) fail", __func__); |
| 688 | goto done; |
| 689 | } |
| 690 | gsc->src_info.stream_on = true; |
| 691 | } |
| 692 | |
| 693 | if (gsc->dst_info.stream_on == false) { |
| 694 | if (exynos_v4l2_streamon(gsc->gsc_fd, gsc->dst_info.buf.buf_type) < 0) { |
| 695 | ALOGE("%s::exynos_v4l2_streamon(dst) fail", __func__); |
| 696 | goto done; |
| 697 | } |
| 698 | gsc->dst_info.stream_on = true; |
| 699 | } |
| 700 | |
| 701 | Exynos_gsc_Out(); |
| 702 | |
| 703 | return 0; |
| 704 | |
| 705 | done: |
| 706 | gsc->m_gsc_m2m_stop(handle); |
| 707 | return -1; |
| 708 | } |
| 709 | |
| 710 | bool CGscaler::m_gsc_check_src_size( |
| 711 | unsigned int *w, unsigned int *h, |
| 712 | unsigned int *crop_x, unsigned int *crop_y, |
| 713 | unsigned int *crop_w, unsigned int *crop_h, |
| 714 | int v4l2_colorformat, bool rotation) |
| 715 | { |
| 716 | unsigned int minWidth, minHeight, shift = 0; |
| 717 | if (v4l2_colorformat == V4L2_PIX_FMT_RGB32 || v4l2_colorformat == V4L2_PIX_FMT_RGB565) |
| 718 | shift = 1; |
| 719 | if (rotation) { |
| 720 | minWidth = GSC_MIN_SRC_H_SIZE >> shift; |
| 721 | minHeight = GSC_MIN_SRC_W_SIZE >> shift; |
| 722 | } else { |
| 723 | minWidth = GSC_MIN_SRC_W_SIZE >> shift; |
| 724 | minHeight = GSC_MIN_SRC_H_SIZE >> shift; |
| 725 | } |
| 726 | |
| 727 | if (*w < minWidth || *h < minHeight) { |
| 728 | ALOGE("%s::too small size (w : %d < %d) (h : %d < %d)", |
| 729 | __func__, GSC_MIN_SRC_W_SIZE, *w, GSC_MIN_SRC_H_SIZE, *h); |
| 730 | return false; |
| 731 | } |
| 732 | |
| 733 | if (*crop_w < minWidth || *crop_h < minHeight) { |
| 734 | ALOGE("%s::too small size (w : %d < %d) (h : %d < %d)", |
| 735 | __func__, GSC_MIN_SRC_W_SIZE,* crop_w, GSC_MIN_SRC_H_SIZE, *crop_h); |
| 736 | return false; |
| 737 | } |
| 738 | |
| 739 | return true; |
| 740 | } |
| 741 | |
| 742 | bool CGscaler::m_gsc_check_dst_size( |
| 743 | unsigned int *w, unsigned int *h, |
| 744 | unsigned int *crop_x, unsigned int *crop_y, |
| 745 | unsigned int *crop_w, unsigned int *crop_h, |
| 746 | int v4l2_colorformat, |
| 747 | int rotation) |
| 748 | { |
| 749 | if (*w < GSC_MIN_DST_W_SIZE || *h < GSC_MIN_DST_H_SIZE) { |
| 750 | ALOGE("%s::too small size (w : %d < %d) (h : %d < %d)", |
| 751 | __func__, GSC_MIN_DST_W_SIZE, *w, GSC_MIN_DST_H_SIZE, *h); |
| 752 | return false; |
| 753 | } |
| 754 | |
| 755 | if (*crop_w < GSC_MIN_DST_W_SIZE || *crop_h < GSC_MIN_DST_H_SIZE) { |
| 756 | ALOGE("%s::too small size (w : %d < %d) (h : %d < %d)", |
| 757 | __func__, GSC_MIN_DST_W_SIZE,* crop_w, GSC_MIN_DST_H_SIZE, *crop_h); |
| 758 | return false; |
| 759 | } |
| 760 | |
| 761 | return true; |
| 762 | } |
| 763 | |
| 764 | |
| 765 | int CGscaler::m_gsc_multiple_of_n(int number, int N) |
| 766 | { |
| 767 | int result = number; |
| 768 | switch (N) { |
| 769 | case 1: |
| 770 | case 2: |
| 771 | case 4: |
| 772 | case 8: |
| 773 | case 16: |
| 774 | case 32: |
| 775 | case 64: |
| 776 | case 128: |
| 777 | case 256: |
| 778 | result = (number - (number & (N-1))); |
| 779 | break; |
| 780 | default: |
| 781 | result = number - (number % N); |
| 782 | break; |
| 783 | } |
| 784 | return result; |
| 785 | } |
| 786 | |
| 787 | int CGscaler::m_gsc_m2m_wait_frame_done(void *handle) |
| 788 | { |
| 789 | Exynos_gsc_In(); |
| 790 | |
| 791 | CGscaler* gsc = GetGscaler(handle); |
| 792 | if (gsc == NULL) { |
| 793 | ALOGE("%s::handle == NULL() fail", __func__); |
| 794 | return -1; |
| 795 | } |
| 796 | |
| 797 | if ((gsc->src_info.stream_on == false) || |
| 798 | (gsc->dst_info.stream_on == false)) { |
| 799 | ALOGE("%s:: src_strean_on or dst_stream_on are false", __func__); |
| 800 | return -1; |
| 801 | } |
| 802 | |
| 803 | if (gsc->src_info.buf.buffer_queued) { |
| 804 | if (exynos_v4l2_dqbuf(gsc->gsc_fd, &gsc->src_info.buf.buffer) < 0) { |
| 805 | ALOGE("%s::exynos_v4l2_dqbuf(src) fail", __func__); |
| 806 | return -1; |
| 807 | } |
| 808 | gsc->src_info.buf.buffer_queued = false; |
| 809 | } |
| 810 | |
| 811 | if (gsc->dst_info.buf.buffer_queued) { |
| 812 | if (exynos_v4l2_dqbuf(gsc->gsc_fd, &gsc->dst_info.buf.buffer) < 0) { |
| 813 | ALOGE("%s::exynos_v4l2_dqbuf(dst) fail", __func__); |
| 814 | return -1; |
| 815 | } |
| 816 | gsc->dst_info.buf.buffer_queued = false; |
| 817 | } |
| 818 | |
| 819 | Exynos_gsc_Out(); |
| 820 | |
| 821 | return 0; |
| 822 | } |
| 823 | |
| 824 | bool CGscaler::m_gsc_set_format(int fd, GscInfo *info) |
| 825 | { |
| 826 | Exynos_gsc_In(); |
| 827 | |
| 828 | struct v4l2_requestbuffers req_buf; |
| 829 | int plane_count; |
| 830 | |
| 831 | plane_count = m_gsc_get_plane_count(info->v4l2_colorformat); |
| 832 | if (plane_count < 0) { |
| 833 | ALOGE("%s::not supported v4l2_colorformat", __func__); |
| 834 | return false; |
| 835 | } |
| 836 | |
| 837 | if (exynos_v4l2_s_ctrl(fd, V4L2_CID_ROTATE, info->rotation) < 0) { |
| 838 | ALOGE("%s::exynos_v4l2_s_ctrl(V4L2_CID_ROTATE) fail", __func__); |
| 839 | return false; |
| 840 | } |
| 841 | |
| 842 | if (exynos_v4l2_s_ctrl(fd, V4L2_CID_VFLIP, info->flip_horizontal) < 0) { |
| 843 | ALOGE("%s::exynos_v4l2_s_ctrl(V4L2_CID_VFLIP) fail", __func__); |
| 844 | return false; |
| 845 | } |
| 846 | |
| 847 | if (exynos_v4l2_s_ctrl(fd, V4L2_CID_HFLIP, info->flip_vertical) < 0) { |
| 848 | ALOGE("%s::exynos_v4l2_s_ctrl(V4L2_CID_HFLIP) fail", __func__); |
| 849 | return false; |
| 850 | } |
| 851 | |
| 852 | info->format.type = info->buf.buf_type; |
| 853 | info->format.fmt.pix_mp.width = info->width; |
| 854 | info->format.fmt.pix_mp.height = info->height; |
| 855 | info->format.fmt.pix_mp.pixelformat = info->v4l2_colorformat; |
| 856 | info->format.fmt.pix_mp.field = V4L2_FIELD_ANY; |
| 857 | info->format.fmt.pix_mp.num_planes = plane_count; |
| 858 | |
| 859 | if (exynos_v4l2_s_fmt(fd, &info->format) < 0) { |
| 860 | ALOGE("%s::exynos_v4l2_s_fmt() fail", __func__); |
| 861 | return false; |
| 862 | } |
| 863 | |
| 864 | info->crop.type = info->buf.buf_type; |
| 865 | info->crop.c.left = info->crop_left; |
| 866 | info->crop.c.top = info->crop_top; |
| 867 | info->crop.c.width = info->crop_width; |
| 868 | info->crop.c.height = info->crop_height; |
| 869 | |
| 870 | if (exynos_v4l2_s_crop(fd, &info->crop) < 0) { |
| 871 | ALOGE("%s::exynos_v4l2_s_crop() fail", __func__); |
| 872 | return false; |
| 873 | } |
| 874 | |
| 875 | if (exynos_v4l2_s_ctrl(fd, V4L2_CID_CACHEABLE, info->cacheable) < 0) { |
| 876 | ALOGE("%s::exynos_v4l2_s_ctrl() fail", __func__); |
| 877 | return false; |
| 878 | } |
| 879 | |
| 880 | req_buf.count = 1; |
| 881 | req_buf.type = info->buf.buf_type; |
| 882 | req_buf.memory = info->buf.mem_type; |
| 883 | if (exynos_v4l2_reqbufs(fd, &req_buf) < 0) { |
| 884 | ALOGE("%s::exynos_v4l2_reqbufs() fail", __func__); |
| 885 | return false; |
| 886 | } |
| 887 | |
| 888 | Exynos_gsc_Out(); |
| 889 | |
| 890 | return true; |
| 891 | } |
| 892 | |
| 893 | unsigned int CGscaler::m_gsc_get_plane_count(int v4l_pixel_format) |
| 894 | { |
| 895 | int plane_count = 0; |
| 896 | |
| 897 | switch (v4l_pixel_format) { |
| 898 | case V4L2_PIX_FMT_RGB32: |
| 899 | case V4L2_PIX_FMT_BGR32: |
| 900 | case V4L2_PIX_FMT_RGB24: |
| 901 | case V4L2_PIX_FMT_RGB565: |
| 902 | case V4L2_PIX_FMT_RGB555X: |
| 903 | case V4L2_PIX_FMT_RGB444: |
| 904 | case V4L2_PIX_FMT_YUYV: |
| 905 | case V4L2_PIX_FMT_UYVY: |
| 906 | case V4L2_PIX_FMT_NV16: |
| 907 | case V4L2_PIX_FMT_NV61: |
| 908 | case V4L2_PIX_FMT_YVU420: |
| 909 | case V4L2_PIX_FMT_YUV420: |
| 910 | case V4L2_PIX_FMT_NV12: |
| 911 | case V4L2_PIX_FMT_NV21: |
| 912 | case V4L2_PIX_FMT_YUV422P: |
| 913 | plane_count = 1; |
| 914 | break; |
| 915 | case V4L2_PIX_FMT_NV12M: |
| 916 | case V4L2_PIX_FMT_NV12MT_16X16: |
| 917 | case V4L2_PIX_FMT_NV21M: |
| 918 | plane_count = 2; |
| 919 | break; |
| 920 | case V4L2_PIX_FMT_YVU420M: |
| 921 | case V4L2_PIX_FMT_YUV420M: |
| 922 | plane_count = 3; |
| 923 | break; |
| 924 | default: |
| 925 | ALOGE("%s::unmatched v4l_pixel_format color_space(0x%x)\n", |
| 926 | __func__, v4l_pixel_format); |
| 927 | plane_count = -1; |
| 928 | break; |
| 929 | } |
| 930 | |
| 931 | return plane_count; |
| 932 | } |
| 933 | |
| 934 | bool CGscaler::m_gsc_set_addr(int fd, GscInfo *info) |
| 935 | { |
| 936 | unsigned int i; |
| 937 | unsigned int plane_size[NUM_OF_GSC_PLANES]; |
| 938 | |
| 939 | CGscaler::m_gsc_get_plane_size(plane_size, info->width, |
| 940 | info->height, info->v4l2_colorformat); |
| 941 | |
| 942 | info->buf.buffer.index = 0; |
| 943 | info->buf.buffer.flags = V4L2_BUF_FLAG_USE_SYNC; |
| 944 | info->buf.buffer.type = info->buf.buf_type; |
| 945 | info->buf.buffer.memory = info->buf.mem_type; |
| 946 | info->buf.buffer.m.planes = info->buf.planes; |
| 947 | info->buf.buffer.length = info->format.fmt.pix_mp.num_planes; |
| 948 | info->buf.buffer.reserved = info->acquireFenceFd; |
| 949 | |
| 950 | for (i = 0; i < info->format.fmt.pix_mp.num_planes; i++) { |
| 951 | if (info->buf.buffer.memory == V4L2_MEMORY_DMABUF) |
| 952 | info->buf.buffer.m.planes[i].m.fd = (int)info->buf.addr[i]; |
| 953 | else |
| 954 | info->buf.buffer.m.planes[i].m.userptr = |
| 955 | (unsigned long)info->buf.addr[i]; |
| 956 | info->buf.buffer.m.planes[i].length = plane_size[i]; |
| 957 | info->buf.buffer.m.planes[i].bytesused = 0; |
| 958 | } |
| 959 | |
| 960 | if (exynos_v4l2_qbuf(fd, &info->buf.buffer) < 0) { |
| 961 | ALOGE("%s::exynos_v4l2_qbuf() fail", __func__); |
| 962 | return false; |
| 963 | } |
| 964 | info->buf.buffer_queued = true; |
| 965 | |
| 966 | info->releaseFenceFd = info->buf.buffer.reserved; |
| 967 | |
| 968 | return true; |
| 969 | } |
| 970 | |
| 971 | unsigned int CGscaler::m_gsc_get_plane_size( |
| 972 | unsigned int *plane_size, |
| 973 | unsigned int width, |
| 974 | unsigned int height, |
| 975 | int v4l_pixel_format) |
| 976 | { |
| 977 | switch (v4l_pixel_format) { |
| 978 | /* 1 plane */ |
| 979 | case V4L2_PIX_FMT_RGB32: |
| 980 | case V4L2_PIX_FMT_BGR32: |
| 981 | plane_size[0] = width * height * 4; |
| 982 | plane_size[1] = 0; |
| 983 | plane_size[2] = 0; |
| 984 | break; |
| 985 | case V4L2_PIX_FMT_RGB24: |
| 986 | plane_size[0] = width * height * 3; |
| 987 | plane_size[1] = 0; |
| 988 | plane_size[2] = 0; |
| 989 | break; |
| 990 | case V4L2_PIX_FMT_RGB565: |
| 991 | case V4L2_PIX_FMT_RGB555X: |
| 992 | case V4L2_PIX_FMT_RGB444: |
| 993 | case V4L2_PIX_FMT_YUYV: |
| 994 | case V4L2_PIX_FMT_UYVY: |
| 995 | plane_size[0] = width * height * 2; |
| 996 | plane_size[1] = 0; |
| 997 | plane_size[2] = 0; |
| 998 | break; |
| 999 | /* 2 planes */ |
| 1000 | case V4L2_PIX_FMT_NV12M: |
| 1001 | case V4L2_PIX_FMT_NV21M: |
| 1002 | plane_size[0] = width * height; |
| 1003 | plane_size[1] = width * (height / 2); |
| 1004 | plane_size[2] = 0; |
| 1005 | break; |
| 1006 | case V4L2_PIX_FMT_NV12: |
| 1007 | case V4L2_PIX_FMT_NV21: |
| 1008 | plane_size[0] = width * height * 3 / 2; |
| 1009 | plane_size[1] = 0; |
| 1010 | plane_size[2] = 0; |
| 1011 | break; |
| 1012 | case V4L2_PIX_FMT_NV16: |
| 1013 | case V4L2_PIX_FMT_NV61: |
| 1014 | case V4L2_PIX_FMT_YUV422P: |
| 1015 | plane_size[0] = width * height * 2; |
| 1016 | plane_size[1] = 0; |
| 1017 | plane_size[2] = 0; |
| 1018 | break; |
| 1019 | case V4L2_PIX_FMT_NV12MT_16X16: |
| 1020 | plane_size[0] = ALIGN(width, 16) * ALIGN(height, 16); |
| 1021 | plane_size[1] = ALIGN(width, 16) * ALIGN(height / 2, 8); |
| 1022 | plane_size[2] = 0; |
| 1023 | break; |
| 1024 | /* 3 planes */ |
| 1025 | case V4L2_PIX_FMT_YUV420M: |
| 1026 | plane_size[0] = width * height; |
| 1027 | plane_size[1] = (width / 2) * (height / 2); |
| 1028 | plane_size[2] = (width / 2) * (height / 2); |
| 1029 | break; |
| 1030 | case V4L2_PIX_FMT_YVU420: |
| 1031 | plane_size[0] = ALIGN(width, 16) * height + ALIGN(width / 2, 16) * height; |
| 1032 | plane_size[1] = 0; |
| 1033 | plane_size[2] = 0; |
| 1034 | break; |
| 1035 | case V4L2_PIX_FMT_YUV420: |
| 1036 | plane_size[0] = width * height * 3 / 2; |
| 1037 | plane_size[1] = 0; |
| 1038 | plane_size[2] = 0; |
| 1039 | break; |
| 1040 | case V4L2_PIX_FMT_YVU420M: |
| 1041 | plane_size[0] = ALIGN(width, 16) * height; |
| 1042 | plane_size[1] = ALIGN(width / 2, 16) * (height / 2); |
| 1043 | plane_size[2] = plane_size[1]; |
| 1044 | break; |
| 1045 | default: |
| 1046 | ALOGE("%s::unmatched v4l_pixel_format color_space(0x%x)\n", |
| 1047 | __func__, v4l_pixel_format); |
| 1048 | return -1; |
| 1049 | } |
| 1050 | |
| 1051 | return 0; |
| 1052 | } |
| 1053 | |
| 1054 | int CGscaler::m_gsc_m2m_config(void *handle, |
| 1055 | exynos_mpp_img *src_img, exynos_mpp_img *dst_img) |
| 1056 | { |
| 1057 | Exynos_gsc_In(); |
| 1058 | |
| 1059 | int32_t src_color_space; |
| 1060 | int32_t dst_color_space; |
| 1061 | int ret; |
| 1062 | unsigned int rotate; |
| 1063 | unsigned int hflip; |
| 1064 | unsigned int vflip; |
| 1065 | CGscaler* gsc = GetGscaler(handle); |
| 1066 | if (gsc == NULL) { |
| 1067 | ALOGE("%s::handle == NULL() fail", __func__); |
| 1068 | return -1; |
| 1069 | } |
| 1070 | |
| 1071 | if ((src_img->drmMode && !gsc->allow_drm) || |
| 1072 | (src_img->drmMode != dst_img->drmMode)) { |
| 1073 | ALOGE("%s::invalid drm state request for gsc%d (s=%d d=%d)", |
| 1074 | __func__, gsc->gsc_id, src_img->drmMode, dst_img->drmMode); |
| 1075 | return -1; |
| 1076 | } |
| 1077 | |
| 1078 | src_color_space = HAL_PIXEL_FORMAT_2_V4L2_PIX(src_img->format); |
| 1079 | dst_color_space = HAL_PIXEL_FORMAT_2_V4L2_PIX(dst_img->format); |
| 1080 | CGscaler::rotateValueHAL2GSC(dst_img->rot, &rotate, &hflip, &vflip); |
| 1081 | exynos_gsc_set_rotation(gsc, rotate, hflip, vflip); |
| 1082 | |
| 1083 | ret = exynos_gsc_set_src_format(gsc, src_img->fw, src_img->fh, |
| 1084 | src_img->x, src_img->y, src_img->w, src_img->h, |
| 1085 | src_color_space, src_img->cacheable, src_img->drmMode); |
| 1086 | if (ret < 0) { |
| 1087 | ALOGE("%s: fail: exynos_gsc_set_src_format \ |
| 1088 | [fw %d fh %d x %d y %d w %d h %d f %x rot %d]", |
| 1089 | __func__, src_img->fw, src_img->fh, src_img->x, src_img->y, |
| 1090 | src_img->w, src_img->h, src_color_space, src_img->rot); |
| 1091 | return -1; |
| 1092 | } |
| 1093 | |
| 1094 | ret = exynos_gsc_set_dst_format(gsc, dst_img->fw, dst_img->fh, |
| 1095 | dst_img->x, dst_img->y, dst_img->w, dst_img->h, |
| 1096 | dst_color_space, dst_img->cacheable, dst_img->drmMode); |
| 1097 | if (ret < 0) { |
| 1098 | ALOGE("%s: fail: exynos_gsc_set_dst_format \ |
| 1099 | [fw %d fh %d x %d y %d w %d h %d f %x rot %d]", |
| 1100 | __func__, dst_img->fw, dst_img->fh, dst_img->x, dst_img->y, |
| 1101 | dst_img->w, dst_img->h, src_color_space, dst_img->rot); |
| 1102 | return -1; |
| 1103 | } |
| 1104 | |
| 1105 | Exynos_gsc_Out(); |
| 1106 | |
| 1107 | return 0; |
| 1108 | } |
| 1109 | |
| 1110 | int CGscaler::m_gsc_out_config(void *handle, |
| 1111 | exynos_mpp_img *src_img, exynos_mpp_img *dst_img) |
| 1112 | { |
| 1113 | Exynos_gsc_In(); |
| 1114 | |
| 1115 | struct v4l2_format fmt; |
| 1116 | struct v4l2_crop crop; |
| 1117 | struct v4l2_requestbuffers reqbuf; |
| 1118 | struct v4l2_subdev_format sd_fmt; |
| 1119 | struct v4l2_subdev_crop sd_crop; |
| 1120 | int i; |
| 1121 | unsigned int rotate; |
| 1122 | unsigned int hflip; |
| 1123 | unsigned int vflip; |
| 1124 | unsigned int plane_size[NUM_OF_GSC_PLANES]; |
| 1125 | bool rgb; |
| 1126 | |
| 1127 | struct v4l2_rect dst_rect; |
| 1128 | int32_t src_color_space; |
| 1129 | int32_t dst_color_space; |
| 1130 | int32_t src_planes; |
| 1131 | |
| 1132 | CGscaler* gsc = GetGscaler(handle); |
| 1133 | if (gsc == NULL) { |
| 1134 | ALOGE("%s::handle == NULL() fail", __func__); |
| 1135 | return -1; |
| 1136 | } |
| 1137 | |
| 1138 | if (gsc->src_info.stream_on != false) { |
| 1139 | ALOGE("Error: Src is already streamed on !!!!"); |
| 1140 | return -1; |
| 1141 | } |
| 1142 | |
| 1143 | memcpy(&gsc->src_img, src_img, sizeof(exynos_mpp_img)); |
| 1144 | memcpy(&gsc->dst_img, dst_img, sizeof(exynos_mpp_img)); |
| 1145 | src_color_space = HAL_PIXEL_FORMAT_2_V4L2_PIX(src_img->format); |
| 1146 | dst_color_space = HAL_PIXEL_FORMAT_2_V4L2_PIX(dst_img->format); |
| 1147 | src_planes = m_gsc_get_plane_count(src_color_space); |
| 1148 | src_planes = (src_planes == -1) ? 1 : src_planes; |
| 1149 | rgb = get_yuv_planes(dst_color_space) == -1; |
| 1150 | CGscaler::rotateValueHAL2GSC(dst_img->rot, &rotate, &hflip, &vflip); |
| 1151 | |
| 1152 | if (CGscaler::m_gsc_check_src_size(&gsc->src_img.fw, |
| 1153 | &gsc->src_img.fh, &gsc->src_img.x, &gsc->src_img.y, |
| 1154 | &gsc->src_img.w, &gsc->src_img.h, src_color_space, |
| 1155 | (rotate == 90 || rotate == 270)) == false) { |
| 1156 | ALOGE("%s::m_gsc_check_src_size() fail", __func__); |
| 1157 | return -1; |
| 1158 | } |
| 1159 | |
| 1160 | /*set: src v4l2_buffer*/ |
| 1161 | gsc->src_info.buf.src_buf_idx = 0; |
| 1162 | gsc->src_info.qbuf_cnt = 0; |
| 1163 | /* set format: src pad of GSC sub-dev*/ |
| 1164 | sd_fmt.pad = GSCALER_SUBDEV_PAD_SOURCE; |
| 1165 | sd_fmt.which = V4L2_SUBDEV_FORMAT_ACTIVE; |
| 1166 | if (gsc->out_mode == GSC_OUT_FIMD) { |
| 1167 | sd_fmt.format.width = gsc->dst_img.fw; |
| 1168 | sd_fmt.format.height = gsc->dst_img.fh; |
| 1169 | } else { |
| 1170 | sd_fmt.format.width = gsc->dst_img.w; |
| 1171 | sd_fmt.format.height = gsc->dst_img.h; |
| 1172 | } |
| 1173 | sd_fmt.format.code = rgb ? V4L2_MBUS_FMT_XRGB8888_4X8_LE : |
| 1174 | V4L2_MBUS_FMT_YUV8_1X24; |
| 1175 | if (exynos_subdev_s_fmt(gsc->mdev.gsc_sd_entity->fd, &sd_fmt) < 0) { |
| 1176 | ALOGE("%s::GSC subdev set format failed", __func__); |
| 1177 | return -1; |
| 1178 | } |
| 1179 | |
| 1180 | /* set crop: src crop of GSC sub-dev*/ |
| 1181 | sd_crop.pad = GSCALER_SUBDEV_PAD_SOURCE; |
| 1182 | sd_crop.which = V4L2_SUBDEV_FORMAT_ACTIVE; |
| 1183 | if (gsc->out_mode == GSC_OUT_FIMD) { |
| 1184 | sd_crop.rect.left = gsc->dst_img.x; |
| 1185 | sd_crop.rect.top = gsc->dst_img.y; |
| 1186 | sd_crop.rect.width = gsc->dst_img.w; |
| 1187 | sd_crop.rect.height = gsc->dst_img.h; |
| 1188 | } else { |
| 1189 | sd_crop.rect.left = 0; |
| 1190 | sd_crop.rect.top = 0; |
| 1191 | sd_crop.rect.width = gsc->dst_img.w; |
| 1192 | sd_crop.rect.height = gsc->dst_img.h; |
| 1193 | } |
| 1194 | |
| 1195 | /* sink pad is connected to GSC out */ |
| 1196 | /* set format: sink sub-dev */ |
| 1197 | if (gsc->out_mode == GSC_OUT_FIMD) { |
| 1198 | sd_fmt.pad = FIMD_SUBDEV_PAD_SINK; |
| 1199 | sd_fmt.format.width = gsc->dst_img.w; |
| 1200 | sd_fmt.format.height = gsc->dst_img.h; |
| 1201 | } else { |
| 1202 | sd_fmt.pad = MIXER_V_SUBDEV_PAD_SINK; |
| 1203 | sd_fmt.format.width = gsc->dst_img.w + gsc->dst_img.x*2; |
| 1204 | sd_fmt.format.height = gsc->dst_img.h + gsc->dst_img.y*2; |
| 1205 | } |
| 1206 | |
| 1207 | sd_fmt.which = V4L2_SUBDEV_FORMAT_ACTIVE; |
| 1208 | sd_fmt.format.code = rgb ? V4L2_MBUS_FMT_XRGB8888_4X8_LE : |
| 1209 | V4L2_MBUS_FMT_YUV8_1X24; |
| 1210 | if (exynos_subdev_s_fmt(gsc->mdev.sink_sd_entity->fd, &sd_fmt) < 0) { |
| 1211 | ALOGE("%s::sink:set format failed (PAD=%d)", __func__, |
| 1212 | sd_fmt.pad); |
| 1213 | return -1; |
| 1214 | } |
| 1215 | |
| 1216 | /* set crop: sink sub-dev */ |
| 1217 | if (gsc->out_mode == GSC_OUT_FIMD) |
| 1218 | sd_crop.pad = FIMD_SUBDEV_PAD_SINK; |
| 1219 | else |
| 1220 | sd_crop.pad = MIXER_V_SUBDEV_PAD_SINK; |
| 1221 | |
| 1222 | sd_crop.which = V4L2_SUBDEV_FORMAT_ACTIVE; |
| 1223 | if (gsc->out_mode == GSC_OUT_FIMD) { |
| 1224 | sd_crop.rect.left = gsc->dst_img.x; |
| 1225 | sd_crop.rect.top = gsc->dst_img.y; |
| 1226 | sd_crop.rect.width = gsc->dst_img.w; |
| 1227 | sd_crop.rect.height = gsc->dst_img.h; |
| 1228 | } else { |
| 1229 | sd_crop.rect.left = 0; |
| 1230 | sd_crop.rect.top = 0; |
| 1231 | sd_crop.rect.width = gsc->dst_img.w; |
| 1232 | sd_crop.rect.height = gsc->dst_img.h; |
| 1233 | } |
| 1234 | |
| 1235 | if (gsc->out_mode != GSC_OUT_FIMD) { |
| 1236 | sd_fmt.pad = MIXER_V_SUBDEV_PAD_SOURCE; |
| 1237 | sd_fmt.which = V4L2_SUBDEV_FORMAT_ACTIVE; |
| 1238 | sd_fmt.format.width = gsc->dst_img.w + gsc->dst_img.x*2; |
| 1239 | sd_fmt.format.height = gsc->dst_img.h + gsc->dst_img.y*2; |
| 1240 | sd_fmt.format.code = V4L2_MBUS_FMT_XRGB8888_4X8_LE; |
| 1241 | if (exynos_subdev_s_fmt(gsc->mdev.sink_sd_entity->fd, &sd_fmt) < 0) { |
| 1242 | ALOGE("%s::sink:set format failed (PAD=%d)", __func__, |
| 1243 | sd_fmt.pad); |
| 1244 | return -1; |
| 1245 | } |
| 1246 | |
| 1247 | sd_fmt.pad = MIXER_V_SUBDEV_PAD_SOURCE; |
| 1248 | sd_crop.which = V4L2_SUBDEV_FORMAT_ACTIVE; |
| 1249 | sd_crop.rect.left = gsc->dst_img.x; |
| 1250 | sd_crop.rect.top = gsc->dst_img.y; |
| 1251 | sd_crop.rect.width = gsc->dst_img.w; |
| 1252 | sd_crop.rect.height = gsc->dst_img.h; |
| 1253 | if (exynos_subdev_s_crop(gsc->mdev.sink_sd_entity->fd, &sd_crop) < 0) { |
| 1254 | ALOGE("%s::sink: subdev set crop failed(PAD=%d)", __func__, |
| 1255 | sd_crop.pad); |
| 1256 | return -1; |
| 1257 | } |
| 1258 | } |
| 1259 | |
| 1260 | /*set GSC ctrls */ |
| 1261 | if (exynos_v4l2_s_ctrl(gsc->mdev.gsc_vd_entity->fd, V4L2_CID_ROTATE, |
| 1262 | rotate) < 0) { |
| 1263 | ALOGE("%s:: exynos_v4l2_s_ctrl (V4L2_CID_ROTATE: %d) failed", |
| 1264 | __func__, rotate); |
| 1265 | return -1; |
| 1266 | } |
| 1267 | |
| 1268 | if (exynos_v4l2_s_ctrl(gsc->mdev.gsc_vd_entity->fd, V4L2_CID_HFLIP, |
| 1269 | vflip) < 0) { |
| 1270 | ALOGE("%s:: exynos_v4l2_s_ctrl (V4L2_CID_HFLIP: %d) failed", |
| 1271 | __func__, vflip); |
| 1272 | return -1; |
| 1273 | } |
| 1274 | |
| 1275 | if (exynos_v4l2_s_ctrl(gsc->mdev.gsc_vd_entity->fd, V4L2_CID_VFLIP, |
| 1276 | hflip) < 0) { |
| 1277 | ALOGE("%s:: exynos_v4l2_s_ctrl (V4L2_CID_VFLIP: %d) failed", |
| 1278 | __func__, hflip); |
| 1279 | return -1; |
| 1280 | } |
| 1281 | |
| 1282 | if (exynos_v4l2_s_ctrl(gsc->mdev.gsc_vd_entity->fd, |
| 1283 | V4L2_CID_CACHEABLE, 1) < 0) { |
| 1284 | ALOGE("%s:: exynos_v4l2_s_ctrl (V4L2_CID_CACHEABLE: 1) failed", |
| 1285 | __func__); |
| 1286 | return -1; |
| 1287 | } |
| 1288 | |
| 1289 | if (exynos_v4l2_s_ctrl(gsc->mdev.gsc_vd_entity->fd, |
| 1290 | V4L2_CID_CONTENT_PROTECTION, gsc->src_img.drmMode) < 0) { |
| 1291 | ALOGE("%s::exynos_v4l2_s_ctrl(V4L2_CID_CONTENT_PROTECTION) fail", |
| 1292 | __func__); |
| 1293 | return -1; |
| 1294 | } |
| 1295 | |
| 1296 | if (exynos_v4l2_s_ctrl(gsc->mdev.gsc_vd_entity->fd, |
| 1297 | V4L2_CID_CSC_EQ_MODE, gsc->eq_auto) < 0) { |
| 1298 | ALOGE("%s::exynos_v4l2_s_ctrl(V4L2_CID_CSC_EQ_MODE) fail", __func__); |
| 1299 | return -1; |
| 1300 | } |
| 1301 | |
| 1302 | if (exynos_v4l2_s_ctrl(gsc->mdev.gsc_vd_entity->fd, |
| 1303 | V4L2_CID_CSC_EQ, gsc->v4l2_colorspace) < 0) { |
| 1304 | ALOGE("%s::exynos_v4l2_s_ctrl(V4L2_CID_CSC_EQ) fail", __func__); |
| 1305 | return -1; |
| 1306 | } |
| 1307 | |
| 1308 | if (exynos_v4l2_s_ctrl(gsc->mdev.gsc_vd_entity->fd, |
| 1309 | V4L2_CID_CSC_RANGE, gsc->range_full) < 0) { |
| 1310 | ALOGE("%s::exynos_v4l2_s_ctrl(V4L2_CID_CSC_RANGE) fail", __func__); |
| 1311 | return -1; |
| 1312 | } |
| 1313 | |
| 1314 | /* set src format :GSC video dev*/ |
| 1315 | fmt.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE; |
| 1316 | fmt.fmt.pix_mp.width = gsc->src_img.fw; |
| 1317 | fmt.fmt.pix_mp.height = gsc->src_img.fh; |
| 1318 | fmt.fmt.pix_mp.pixelformat = src_color_space; |
| 1319 | fmt.fmt.pix_mp.field = V4L2_FIELD_NONE; |
| 1320 | fmt.fmt.pix_mp.num_planes = src_planes; |
| 1321 | |
| 1322 | if (exynos_v4l2_s_fmt(gsc->mdev.gsc_vd_entity->fd, &fmt) < 0) { |
| 1323 | ALOGE("%s::videodev set format failed", __func__); |
| 1324 | return -1; |
| 1325 | } |
| 1326 | |
| 1327 | /* set src crop info :GSC video dev*/ |
| 1328 | crop.type = fmt.type; |
| 1329 | crop.c.left = gsc->src_img.x; |
| 1330 | crop.c.top = gsc->src_img.y; |
| 1331 | crop.c.width = gsc->src_img.w; |
| 1332 | crop.c.height = gsc->src_img.h; |
| 1333 | |
| 1334 | if (exynos_v4l2_s_crop(gsc->mdev.gsc_vd_entity->fd, &crop) < 0) { |
| 1335 | ALOGE("%s::videodev set crop failed", __func__); |
| 1336 | return -1; |
| 1337 | } |
| 1338 | |
| 1339 | reqbuf.type = fmt.type; |
| 1340 | reqbuf.memory = V4L2_MEMORY_DMABUF; |
| 1341 | reqbuf.count = MAX_BUFFERS_GSCALER_OUT; |
| 1342 | |
| 1343 | if (exynos_v4l2_reqbufs(gsc->mdev.gsc_vd_entity->fd, &reqbuf) < 0) { |
| 1344 | ALOGE("%s::request buffers failed", __func__); |
| 1345 | return -1; |
| 1346 | } |
| 1347 | |
| 1348 | Exynos_gsc_Out(); |
| 1349 | |
| 1350 | return 0; |
| 1351 | } |
| 1352 | |
| 1353 | void CGscaler::rotateValueHAL2GSC(unsigned int transform, |
| 1354 | unsigned int *rotate, unsigned int *hflip, unsigned int *vflip) |
| 1355 | { |
| 1356 | int rotate_flag = transform & 0x7; |
| 1357 | *rotate = 0; |
| 1358 | *hflip = 0; |
| 1359 | *vflip = 0; |
| 1360 | |
| 1361 | switch (rotate_flag) { |
| 1362 | case HAL_TRANSFORM_ROT_90: |
| 1363 | *rotate = 90; |
| 1364 | break; |
| 1365 | case HAL_TRANSFORM_ROT_180: |
| 1366 | *rotate = 180; |
| 1367 | break; |
| 1368 | case HAL_TRANSFORM_ROT_270: |
| 1369 | *rotate = 270; |
| 1370 | break; |
| 1371 | case HAL_TRANSFORM_FLIP_H | HAL_TRANSFORM_ROT_90: |
| 1372 | *rotate = 90; |
| 1373 | *vflip = 1; /* set vflip to compensate the rot & flip order. */ |
| 1374 | break; |
| 1375 | case HAL_TRANSFORM_FLIP_V | HAL_TRANSFORM_ROT_90: |
| 1376 | *rotate = 90; |
| 1377 | *hflip = 1; /* set hflip to compensate the rot & flip order. */ |
| 1378 | break; |
| 1379 | case HAL_TRANSFORM_FLIP_H: |
| 1380 | *hflip = 1; |
| 1381 | break; |
| 1382 | case HAL_TRANSFORM_FLIP_V: |
| 1383 | *vflip = 1; |
| 1384 | break; |
| 1385 | default: |
| 1386 | break; |
| 1387 | } |
| 1388 | } |
| 1389 | |
| 1390 | int CGscaler::m_gsc_m2m_run(void *handle, |
| 1391 | exynos_mpp_img *src_img, exynos_mpp_img *dst_img) |
| 1392 | { |
| 1393 | Exynos_gsc_In(); |
| 1394 | |
| 1395 | CGscaler* gsc = GetGscaler(handle); |
| 1396 | if (gsc == NULL) { |
| 1397 | ALOGE("%s::handle == NULL() fail", __func__); |
| 1398 | return -1; |
| 1399 | } |
| 1400 | void *addr[3] = {NULL, NULL, NULL}; |
| 1401 | int ret = 0; |
| 1402 | |
| 1403 | addr[0] = (void *)src_img->yaddr; |
| 1404 | addr[1] = (void *)src_img->uaddr; |
| 1405 | addr[2] = (void *)src_img->vaddr; |
| 1406 | ret = exynos_gsc_set_src_addr(handle, addr, src_img->mem_type, |
| 1407 | src_img->acquireFenceFd); |
| 1408 | if (ret < 0) { |
| 1409 | ALOGE("%s::fail: exynos_gsc_set_src_addr[%x %x %x]", __func__, |
| 1410 | (unsigned int)addr[0], (unsigned int)addr[1], |
| 1411 | (unsigned int)addr[2]); |
| 1412 | return -1; |
| 1413 | } |
| 1414 | |
| 1415 | addr[0] = (void *)dst_img->yaddr; |
| 1416 | addr[1] = (void *)dst_img->uaddr; |
| 1417 | addr[2] = (void *)dst_img->vaddr; |
| 1418 | ret = exynos_gsc_set_dst_addr(handle, addr, dst_img->mem_type, |
| 1419 | dst_img->acquireFenceFd); |
| 1420 | if (ret < 0) { |
| 1421 | ALOGE("%s::fail: exynos_gsc_set_dst_addr[%x %x %x]", __func__, |
| 1422 | (unsigned int)addr[0], (unsigned int)addr[1], |
| 1423 | (unsigned int)addr[2]); |
| 1424 | return -1; |
| 1425 | } |
| 1426 | |
| 1427 | ret = gsc->m_gsc_m2m_run_core(handle); |
| 1428 | if (ret < 0) { |
| 1429 | ALOGE("%s::fail: m_gsc_m2m_run_core", __func__); |
| 1430 | return -1; |
| 1431 | } |
| 1432 | |
| 1433 | if (src_img->acquireFenceFd >= 0) { |
| 1434 | close(src_img->acquireFenceFd); |
| 1435 | src_img->acquireFenceFd = -1; |
| 1436 | } |
| 1437 | |
| 1438 | if (dst_img->acquireFenceFd >= 0) { |
| 1439 | close(dst_img->acquireFenceFd); |
| 1440 | dst_img->acquireFenceFd = -1; |
| 1441 | } |
| 1442 | |
| 1443 | src_img->releaseFenceFd = gsc->src_info.releaseFenceFd; |
| 1444 | dst_img->releaseFenceFd = gsc->dst_info.releaseFenceFd; |
| 1445 | |
| 1446 | Exynos_gsc_Out(); |
| 1447 | |
| 1448 | return 0; |
| 1449 | } |
| 1450 | |
| 1451 | int CGscaler::m_gsc_out_run(void *handle, exynos_mpp_img *src_img) |
| 1452 | { |
| 1453 | struct v4l2_plane planes[NUM_OF_GSC_PLANES]; |
| 1454 | struct v4l2_buffer buf; |
| 1455 | int32_t src_color_space; |
| 1456 | int32_t src_planes; |
| 1457 | unsigned int i; |
| 1458 | unsigned int plane_size[NUM_OF_GSC_PLANES]; |
| 1459 | CGscaler* gsc = GetGscaler(handle); |
| 1460 | if (gsc == NULL) { |
| 1461 | ALOGE("%s::handle == NULL() fail", __func__); |
| 1462 | return -1; |
| 1463 | } |
| 1464 | |
| 1465 | /* All buffers have been queued, dequeue one */ |
| 1466 | if (gsc->src_info.qbuf_cnt == MAX_BUFFERS_GSCALER_OUT) { |
| 1467 | memset(&buf, 0, sizeof(struct v4l2_buffer)); |
| 1468 | for (i = 0; i < NUM_OF_GSC_PLANES; i++) |
| 1469 | memset(&planes[i], 0, sizeof(struct v4l2_plane)); |
| 1470 | |
| 1471 | buf.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE; |
| 1472 | buf.memory = V4L2_MEMORY_DMABUF; |
| 1473 | buf.m.planes = planes; |
| 1474 | |
| 1475 | src_color_space = HAL_PIXEL_FORMAT_2_V4L2_PIX(gsc->src_img.format); |
| 1476 | src_planes = m_gsc_get_plane_count(src_color_space); |
| 1477 | src_planes = (src_planes == -1) ? 1 : src_planes; |
| 1478 | buf.length = src_planes; |
| 1479 | |
| 1480 | |
| 1481 | if (exynos_v4l2_dqbuf(gsc->mdev.gsc_vd_entity->fd, &buf) < 0) { |
| 1482 | ALOGE("%s::dequeue buffer failed (index=%d)(mSrcBufNum=%d)", |
| 1483 | __func__, gsc->src_info.buf.src_buf_idx, |
| 1484 | MAX_BUFFERS_GSCALER_OUT); |
| 1485 | return -1; |
| 1486 | } |
| 1487 | gsc->src_info.qbuf_cnt--; |
| 1488 | } |
| 1489 | |
| 1490 | memset(&buf, 0, sizeof(struct v4l2_buffer)); |
| 1491 | for (i = 0; i < NUM_OF_GSC_PLANES; i++) |
| 1492 | memset(&planes[i], 0, sizeof(struct v4l2_plane)); |
| 1493 | |
| 1494 | src_color_space = HAL_PIXEL_FORMAT_2_V4L2_PIX(gsc->src_img.format); |
| 1495 | src_planes = m_gsc_get_plane_count(src_color_space); |
| 1496 | src_planes = (src_planes == -1) ? 1 : src_planes; |
| 1497 | |
| 1498 | buf.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE; |
| 1499 | buf.memory = V4L2_MEMORY_DMABUF; |
| 1500 | buf.flags = V4L2_BUF_FLAG_USE_SYNC; |
| 1501 | buf.length = src_planes; |
| 1502 | buf.index = gsc->src_info.buf.src_buf_idx; |
| 1503 | buf.m.planes = planes; |
| 1504 | buf.reserved = src_img->acquireFenceFd; |
| 1505 | |
| 1506 | gsc->src_info.buf.addr[0] = (void*)src_img->yaddr; |
| 1507 | gsc->src_info.buf.addr[1] = (void*)src_img->uaddr; |
| 1508 | gsc->src_info.buf.addr[2] = (void*)src_img->vaddr; |
| 1509 | |
| 1510 | if (CGscaler::tmp_get_plane_size(src_color_space, plane_size, |
| 1511 | gsc->src_img.fw, gsc->src_img.fh, src_planes) != true) { |
| 1512 | ALOGE("%s:get_plane_size:fail", __func__); |
| 1513 | return -1; |
| 1514 | } |
| 1515 | |
| 1516 | for (i = 0; i < buf.length; i++) { |
| 1517 | buf.m.planes[i].m.fd = (int)gsc->src_info.buf.addr[i]; |
| 1518 | buf.m.planes[i].length = plane_size[i]; |
| 1519 | buf.m.planes[i].bytesused = plane_size[i]; |
| 1520 | } |
| 1521 | |
| 1522 | /* Queue the buf */ |
| 1523 | if (exynos_v4l2_qbuf(gsc->mdev.gsc_vd_entity->fd, &buf) < 0) { |
| 1524 | ALOGE("%s::queue buffer failed (index=%d)(mSrcBufNum=%d)", |
| 1525 | __func__, gsc->src_info.buf.src_buf_idx, |
| 1526 | MAX_BUFFERS_GSCALER_OUT); |
| 1527 | return -1; |
| 1528 | } |
| 1529 | gsc->src_info.buf.src_buf_idx++; |
| 1530 | gsc->src_info.buf.src_buf_idx = |
| 1531 | gsc->src_info.buf.src_buf_idx % MAX_BUFFERS_GSCALER_OUT; |
| 1532 | gsc->src_info.qbuf_cnt++; |
| 1533 | |
| 1534 | if (gsc->src_info.stream_on == false) { |
| 1535 | if (exynos_v4l2_streamon(gsc->mdev.gsc_vd_entity->fd, |
| 1536 | (v4l2_buf_type)buf.type) < 0) { |
| 1537 | ALOGE("%s::stream on failed", __func__); |
| 1538 | return -1; |
| 1539 | } |
| 1540 | gsc->src_info.stream_on = true; |
| 1541 | } |
| 1542 | |
| 1543 | src_img->releaseFenceFd = buf.reserved; |
| 1544 | return 0; |
| 1545 | } |
| 1546 | |
| 1547 | bool CGscaler::tmp_get_plane_size(int V4L2_PIX, |
| 1548 | unsigned int * size, unsigned int width, unsigned int height, int src_planes) |
| 1549 | { |
| 1550 | unsigned int frame_ratio = 1; |
| 1551 | int src_bpp = get_yuv_bpp(V4L2_PIX); |
| 1552 | unsigned int frame_size = width * height; |
| 1553 | |
| 1554 | src_planes = (src_planes == -1) ? 1 : src_planes; |
| 1555 | frame_ratio = 8 * (src_planes -1) / (src_bpp - 8); |
| 1556 | |
| 1557 | switch (src_planes) { |
| 1558 | case 1: |
| 1559 | switch (V4L2_PIX) { |
| 1560 | case V4L2_PIX_FMT_BGR32: |
| 1561 | case V4L2_PIX_FMT_RGB32: |
| 1562 | size[0] = frame_size << 2; |
| 1563 | break; |
| 1564 | case V4L2_PIX_FMT_RGB565: |
| 1565 | case V4L2_PIX_FMT_NV16: |
| 1566 | case V4L2_PIX_FMT_NV61: |
| 1567 | case V4L2_PIX_FMT_YUYV: |
| 1568 | case V4L2_PIX_FMT_UYVY: |
| 1569 | case V4L2_PIX_FMT_VYUY: |
| 1570 | case V4L2_PIX_FMT_YVYU: |
| 1571 | size[0] = frame_size << 1; |
| 1572 | break; |
| 1573 | case V4L2_PIX_FMT_YUV420: |
| 1574 | case V4L2_PIX_FMT_NV12: |
| 1575 | case V4L2_PIX_FMT_NV21: |
| 1576 | case V4L2_PIX_FMT_NV21M: |
| 1577 | size[0] = (frame_size * 3) >> 1; |
| 1578 | break; |
| 1579 | case V4L2_PIX_FMT_YVU420: |
| 1580 | size[0] = frame_size + (ALIGN((width >> 1), 16) * ((height >> 1) * 2)); |
| 1581 | break; |
| 1582 | default: |
| 1583 | ALOGE("%s::invalid color type (%x)", __func__, V4L2_PIX); |
| 1584 | return false; |
| 1585 | break; |
| 1586 | } |
| 1587 | size[1] = 0; |
| 1588 | size[2] = 0; |
| 1589 | break; |
| 1590 | case 2: |
| 1591 | size[0] = frame_size; |
| 1592 | size[1] = frame_size / frame_ratio; |
| 1593 | size[2] = 0; |
| 1594 | break; |
| 1595 | case 3: |
| 1596 | size[0] = frame_size; |
| 1597 | size[1] = frame_size / frame_ratio; |
| 1598 | size[2] = frame_size / frame_ratio; |
| 1599 | break; |
| 1600 | default: |
| 1601 | ALOGE("%s::invalid color foarmt", __func__); |
| 1602 | return false; |
| 1603 | break; |
| 1604 | } |
| 1605 | |
| 1606 | return true; |
| 1607 | } |
| 1608 | |
| 1609 | int CGscaler::ConfigMpp(void *handle, exynos_mpp_img *src, |
| 1610 | exynos_mpp_img *dst) |
| 1611 | { |
| 1612 | return exynos_gsc_config_exclusive(handle, src, dst); |
| 1613 | } |
| 1614 | |
| 1615 | int CGscaler::RunMpp(void *handle, exynos_mpp_img *src, |
| 1616 | exynos_mpp_img *dst) |
| 1617 | { |
| 1618 | return exynos_gsc_run_exclusive(handle, src, dst); |
| 1619 | } |
| 1620 | |
| 1621 | int CGscaler::StopMpp(void *handle) |
| 1622 | { |
| 1623 | return exynos_gsc_stop_exclusive(handle); |
| 1624 | } |
| 1625 | |
| 1626 | void CGscaler::DestroyMpp(void *handle) |
| 1627 | { |
| 1628 | return exynos_gsc_destroy(handle); |
| 1629 | } |
| 1630 | |
| 1631 | int CGscaler::SetCSCProperty(void *handle, unsigned int eqAuto, |
| 1632 | unsigned int fullRange, unsigned int colorspace) |
| 1633 | { |
| 1634 | return exynos_gsc_set_csc_property(handle, eqAuto, fullRange, |
| 1635 | colorspace); |
| 1636 | } |
| 1637 | |
| 1638 | int CGscaler::FreeMpp(void *handle) |
| 1639 | { |
| 1640 | return exynos_gsc_free_and_close(handle); |
| 1641 | } |
| 1642 | |
| 1643 | int CGscaler::SetInputCrop(void *handle, |
| 1644 | exynos_mpp_img *src_img, exynos_mpp_img *dst_img) |
| 1645 | { |
| 1646 | struct v4l2_crop crop; |
| 1647 | int ret = 0; |
| 1648 | CGscaler *gsc = GetGscaler(handle); |
| 1649 | if (gsc == NULL) { |
| 1650 | ALOGE("%s::handle == NULL() fail", __func__); |
| 1651 | return -1; |
| 1652 | } |
| 1653 | |
| 1654 | crop.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE; |
| 1655 | crop.c.left = src_img->x; |
| 1656 | crop.c.top = src_img->y; |
| 1657 | crop.c.width = src_img->w; |
| 1658 | crop.c.height = src_img->h; |
| 1659 | |
| 1660 | return exynos_v4l2_s_crop(gsc->mdev.gsc_vd_entity->fd, &crop); |
| 1661 | } |