1// SPDX-License-Identifier: GPL-2.0 2/* 3 * Support for Intel Camera Imaging ISP subsystem. 4 * Copyright (c) 2015, Intel Corporation. 5 * 6 * This program is free software; you can redistribute it and/or modify it 7 * under the terms and conditions of the GNU General Public License, 8 * version 2, as published by the Free Software Foundation. 9 * 10 * This program is distributed in the hope it will be useful, but WITHOUT 11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for 13 * more details. 14 */ 15 16#include <linux/kernel.h> 17#include <linux/math.h> 18 19#include "ia_css_pipe_binarydesc.h" 20#include "ia_css_frame_format.h" 21#include "ia_css_pipe.h" 22#include "ia_css_pipe_util.h" 23#include "ia_css_util.h" 24#include "ia_css_debug.h" 25#include "sh_css_params.h" 26#include <assert_support.h> 27/* HRT_GDC_N */ 28#include "gdc_device.h" 29 30/* This module provides a binary descriptions to used to find a binary. Since, 31 * every stage is associated with a binary, it implicity helps stage 32 * description. Apart from providing a binary description, this module also 33 * populates the frame info's when required.*/ 34 35/* Generic descriptor for offline binaries. Internal function. */ 36static void pipe_binarydesc_get_offline( 37 struct ia_css_pipe const *const pipe, 38 const int mode, 39 struct ia_css_binary_descr *descr, 40 struct ia_css_frame_info *in_info, 41 struct ia_css_frame_info *out_info[], 42 struct ia_css_frame_info *vf_info) 43{ 44 unsigned int i; 45 /* in_info, out_info, vf_info can be NULL */ 46 assert(pipe); 47 assert(descr); 48 ia_css_debug_dtrace(IA_CSS_DEBUG_TRACE_PRIVATE, 49 "pipe_binarydesc_get_offline() enter:\n"); 50 51 descr->mode = mode; 52 descr->online = false; 53 descr->continuous = pipe->stream->config.continuous; 54 descr->striped = false; 55 descr->two_ppc = false; 56 descr->enable_yuv_ds = false; 57 descr->enable_high_speed = false; 58 descr->enable_dvs_6axis = false; 59 descr->enable_reduced_pipe = false; 60 descr->enable_dz = true; 61 descr->enable_xnr = false; 62 descr->enable_dpc = false; 63 descr->enable_tnr = false; 64 descr->enable_capture_pp_bli = false; 65 descr->enable_fractional_ds = false; 66 descr->dvs_env.width = 0; 67 descr->dvs_env.height = 0; 68 descr->stream_format = pipe->stream->config.input_config.format; 69 descr->in_info = in_info; 70 descr->bds_out_info = NULL; 71 for (i = 0; i < IA_CSS_BINARY_MAX_OUTPUT_PORTS; i++) 72 descr->out_info[i] = out_info[i]; 73 descr->vf_info = vf_info; 74 descr->isp_pipe_version = pipe->config.isp_pipe_version; 75 descr->required_bds_factor = SH_CSS_BDS_FACTOR_1_00; 76 descr->stream_config_left_padding = -1; 77} 78 79void ia_css_pipe_get_copy_binarydesc( 80 struct ia_css_pipe const *const pipe, 81 struct ia_css_binary_descr *copy_descr, 82 struct ia_css_frame_info *in_info, 83 struct ia_css_frame_info *out_info, 84 struct ia_css_frame_info *vf_info) 85{ 86 struct ia_css_frame_info *out_infos[IA_CSS_BINARY_MAX_OUTPUT_PORTS]; 87 unsigned int i; 88 /* out_info can be NULL */ 89 assert(pipe); 90 assert(in_info); 91 IA_CSS_ENTER_PRIVATE(""); 92 93 *in_info = *out_info; 94 out_infos[0] = out_info; 95 for (i = 1; i < IA_CSS_BINARY_MAX_OUTPUT_PORTS; i++) 96 out_infos[i] = NULL; 97 pipe_binarydesc_get_offline(pipe, IA_CSS_BINARY_MODE_COPY, 98 copy_descr, in_info, out_infos, vf_info); 99 copy_descr->online = true; 100 copy_descr->continuous = false; 101 copy_descr->two_ppc = (pipe->stream->config.pixels_per_clock == 2); 102 copy_descr->enable_dz = false; 103 copy_descr->isp_pipe_version = IA_CSS_PIPE_VERSION_1; 104 IA_CSS_LEAVE_PRIVATE(""); 105} 106 107void ia_css_pipe_get_vfpp_binarydesc( 108 struct ia_css_pipe const *const pipe, 109 struct ia_css_binary_descr *vf_pp_descr, 110 struct ia_css_frame_info *in_info, 111 struct ia_css_frame_info *out_info) 112{ 113 struct ia_css_frame_info *out_infos[IA_CSS_BINARY_MAX_OUTPUT_PORTS]; 114 unsigned int i; 115 /* out_info can be NULL ??? */ 116 assert(pipe); 117 assert(in_info); 118 IA_CSS_ENTER_PRIVATE(""); 119 120 in_info->raw_bit_depth = 0; 121 out_infos[0] = out_info; 122 for (i = 1; i < IA_CSS_BINARY_MAX_OUTPUT_PORTS; i++) 123 out_infos[i] = NULL; 124 125 pipe_binarydesc_get_offline(pipe, IA_CSS_BINARY_MODE_VF_PP, 126 vf_pp_descr, in_info, out_infos, NULL); 127 vf_pp_descr->enable_fractional_ds = true; 128 IA_CSS_LEAVE_PRIVATE(""); 129} 130 131static struct u32_fract bds_factors_list[] = { 132 [SH_CSS_BDS_FACTOR_1_00] = {1, 1}, 133 [SH_CSS_BDS_FACTOR_1_25] = {5, 4}, 134 [SH_CSS_BDS_FACTOR_1_50] = {3, 2}, 135 [SH_CSS_BDS_FACTOR_2_00] = {2, 1}, 136 [SH_CSS_BDS_FACTOR_2_25] = {9, 4}, 137 [SH_CSS_BDS_FACTOR_2_50] = {5, 2}, 138 [SH_CSS_BDS_FACTOR_3_00] = {3, 1}, 139 [SH_CSS_BDS_FACTOR_4_00] = {4, 1}, 140 [SH_CSS_BDS_FACTOR_4_50] = {9, 2}, 141 [SH_CSS_BDS_FACTOR_5_00] = {5, 1}, 142 [SH_CSS_BDS_FACTOR_6_00] = {6, 1}, 143 [SH_CSS_BDS_FACTOR_8_00] = {8, 1}, 144}; 145 146int sh_css_bds_factor_get_fract(unsigned int bds_factor, struct u32_fract *bds) 147{ 148 /* Throw an error since bds_factor cannot be found in bds_factors_list */ 149 if (bds_factor >= ARRAY_SIZE(bds_factors_list)) 150 return -EINVAL; 151 152 *bds = bds_factors_list[bds_factor]; 153 return 0; 154} 155 156int binarydesc_calculate_bds_factor( 157 struct ia_css_resolution input_res, 158 struct ia_css_resolution output_res, 159 unsigned int *bds_factor) 160{ 161 unsigned int i; 162 unsigned int in_w = input_res.width, 163 in_h = input_res.height, 164 out_w = output_res.width, out_h = output_res.height; 165 166 unsigned int max_bds_factor = 8; 167 unsigned int max_rounding_margin = 2; 168 /* delta in pixels to account for rounding margin in the calculation */ 169 unsigned int delta = max_bds_factor * max_rounding_margin; 170 171 /* Assert if the resolutions are not set */ 172 assert(in_w != 0 && in_h != 0); 173 assert(out_w != 0 && out_h != 0); 174 175 /* Loop over all bds factors until a match is found */ 176 for (i = 0; i < ARRAY_SIZE(bds_factors_list); i++) { 177 unsigned int num = bds_factors_list[i].numerator; 178 unsigned int den = bds_factors_list[i].denominator; 179 180 /* See width-wise and height-wise if this bds_factor 181 * satisfies the condition */ 182 bool cond = (out_w * num / den + delta > in_w) && 183 (out_w * num / den <= in_w) && 184 (out_h * num / den + delta > in_h) && 185 (out_h * num / den <= in_h); 186 187 if (cond) { 188 *bds_factor = i; 189 return 0; 190 } 191 } 192 193 /* Throw an error since a suitable bds_factor cannot be found */ 194 return -EINVAL; 195} 196 197int ia_css_pipe_get_preview_binarydesc( 198 struct ia_css_pipe *const pipe, 199 struct ia_css_binary_descr *preview_descr, 200 struct ia_css_frame_info *in_info, 201 struct ia_css_frame_info *bds_out_info, 202 struct ia_css_frame_info *out_info, 203 struct ia_css_frame_info *vf_info) 204{ 205 int err; 206 struct ia_css_frame_info *out_infos[IA_CSS_BINARY_MAX_OUTPUT_PORTS]; 207 int mode = IA_CSS_BINARY_MODE_PREVIEW; 208 unsigned int i; 209 210 assert(pipe); 211 assert(in_info); 212 assert(out_info); 213 assert(vf_info); 214 IA_CSS_ENTER_PRIVATE(""); 215 216 /* 217 * Set up the info of the input frame with 218 * the ISP required resolution 219 */ 220 in_info->res = pipe->config.input_effective_res; 221 in_info->padded_width = in_info->res.width; 222 in_info->raw_bit_depth = ia_css_pipe_util_pipe_input_format_bpp(pipe); 223 224 if (ia_css_util_is_input_format_yuv(pipe->stream->config.input_config.format)) 225 mode = IA_CSS_BINARY_MODE_COPY; 226 else 227 in_info->format = IA_CSS_FRAME_FORMAT_RAW; 228 229 out_infos[0] = out_info; 230 for (i = 1; i < IA_CSS_BINARY_MAX_OUTPUT_PORTS; i++) 231 out_infos[i] = NULL; 232 233 pipe_binarydesc_get_offline(pipe, mode, 234 preview_descr, in_info, out_infos, vf_info); 235 if (pipe->stream->config.online) { 236 preview_descr->online = pipe->stream->config.online; 237 preview_descr->two_ppc = 238 (pipe->stream->config.pixels_per_clock == 2); 239 } 240 preview_descr->stream_format = pipe->stream->config.input_config.format; 241 242 /* TODO: Remove this when bds_out_info is available! */ 243 *bds_out_info = *in_info; 244 245 if (pipe->extra_config.enable_raw_binning) { 246 if (pipe->config.bayer_ds_out_res.width != 0 && 247 pipe->config.bayer_ds_out_res.height != 0) { 248 bds_out_info->res.width = 249 pipe->config.bayer_ds_out_res.width; 250 bds_out_info->res.height = 251 pipe->config.bayer_ds_out_res.height; 252 bds_out_info->padded_width = 253 pipe->config.bayer_ds_out_res.width; 254 err = 255 binarydesc_calculate_bds_factor(in_info->res, 256 bds_out_info->res, 257 &preview_descr->required_bds_factor); 258 if (err) 259 return err; 260 } else { 261 bds_out_info->res.width = in_info->res.width / 2; 262 bds_out_info->res.height = in_info->res.height / 2; 263 bds_out_info->padded_width = in_info->padded_width / 2; 264 preview_descr->required_bds_factor = 265 SH_CSS_BDS_FACTOR_2_00; 266 } 267 } else { 268 /* TODO: Remove this when bds_out_info->is available! */ 269 bds_out_info->res.width = in_info->res.width; 270 bds_out_info->res.height = in_info->res.height; 271 bds_out_info->padded_width = in_info->padded_width; 272 preview_descr->required_bds_factor = SH_CSS_BDS_FACTOR_1_00; 273 } 274 pipe->required_bds_factor = preview_descr->required_bds_factor; 275 276 /* bayer ds and fractional ds cannot be enabled at the same time, 277 so we disable bds_out_info when fractional ds is used */ 278 if (!pipe->extra_config.enable_fractional_ds) 279 preview_descr->bds_out_info = bds_out_info; 280 else 281 preview_descr->bds_out_info = NULL; 282 /* 283 ----Preview binary----- 284 --in-->|--out->|vf_veceven|--|--->vf 285 ----------------------- 286 * Preview binary normally doesn't have a vf_port but 287 * instead it has an output port. However, the output is 288 * generated by vf_veceven module in which we might have 289 * a downscaling (by 1x, 2x, or 4x). Because the resolution 290 * might change, we need two different info, namely out_info 291 * & vf_info. In fill_binary_info we use out&vf info to 292 * calculate vf decimation factor. 293 */ 294 *out_info = *vf_info; 295 296 /* In case of preview_ds binary, we can do any fractional amount 297 * of downscale, so there is no DS needed in vf_veceven. Therefore, 298 * out and vf infos will be the same. Otherwise, we set out resolution 299 * equal to in resolution. */ 300 if (!pipe->extra_config.enable_fractional_ds) { 301 /* TODO: Change this when bds_out_info is available! */ 302 out_info->res.width = bds_out_info->res.width; 303 out_info->res.height = bds_out_info->res.height; 304 out_info->padded_width = bds_out_info->padded_width; 305 } 306 preview_descr->enable_fractional_ds = 307 pipe->extra_config.enable_fractional_ds; 308 309 preview_descr->enable_dpc = pipe->config.enable_dpc; 310 311 preview_descr->isp_pipe_version = pipe->config.isp_pipe_version; 312 IA_CSS_LEAVE_ERR_PRIVATE(0); 313 return 0; 314} 315 316int ia_css_pipe_get_video_binarydesc( 317 struct ia_css_pipe *const pipe, 318 struct ia_css_binary_descr *video_descr, 319 struct ia_css_frame_info *in_info, 320 struct ia_css_frame_info *bds_out_info, 321 struct ia_css_frame_info *out_info, 322 struct ia_css_frame_info *vf_info, 323 int stream_config_left_padding) 324{ 325 int mode = IA_CSS_BINARY_MODE_VIDEO; 326 unsigned int i; 327 struct ia_css_frame_info *out_infos[IA_CSS_BINARY_MAX_OUTPUT_PORTS]; 328 int err = 0; 329 bool stream_dz_config = false; 330 331 /* vf_info can be NULL */ 332 assert(pipe); 333 assert(in_info); 334 /* assert(vf_info != NULL); */ 335 IA_CSS_ENTER_PRIVATE(""); 336 337 /* The solution below is not optimal; we should move to using ia_css_pipe_get_copy_binarydesc() 338 * But for now this fixes things; this code used to be there but was removed 339 * with gerrit 8908 as this was wrong for Skycam; however 240x still needs this 340 */ 341 if (ia_css_util_is_input_format_yuv(pipe->stream->config.input_config.format)) 342 mode = IA_CSS_BINARY_MODE_COPY; 343 344 in_info->res = pipe->config.input_effective_res; 345 in_info->padded_width = in_info->res.width; 346 in_info->format = IA_CSS_FRAME_FORMAT_RAW; 347 in_info->raw_bit_depth = ia_css_pipe_util_pipe_input_format_bpp(pipe); 348 out_infos[0] = out_info; 349 for (i = 1; i < IA_CSS_BINARY_MAX_OUTPUT_PORTS; i++) 350 out_infos[i] = NULL; 351 352 pipe_binarydesc_get_offline(pipe, mode, 353 video_descr, in_info, out_infos, vf_info); 354 355 if (pipe->stream->config.online) { 356 video_descr->online = pipe->stream->config.online; 357 video_descr->two_ppc = 358 (pipe->stream->config.pixels_per_clock == 2); 359 } 360 361 if (mode == IA_CSS_BINARY_MODE_VIDEO) { 362 stream_dz_config = 363 ((pipe->stream->isp_params_configs->dz_config.dx != 364 HRT_GDC_N) 365 || (pipe->stream->isp_params_configs->dz_config.dy != 366 HRT_GDC_N)); 367 368 video_descr->enable_dz = pipe->config.enable_dz 369 || stream_dz_config; 370 video_descr->dvs_env = pipe->config.dvs_envelope; 371 video_descr->enable_yuv_ds = pipe->extra_config.enable_yuv_ds; 372 video_descr->enable_high_speed = 373 pipe->extra_config.enable_high_speed; 374 video_descr->enable_dvs_6axis = 375 pipe->extra_config.enable_dvs_6axis; 376 video_descr->enable_reduced_pipe = 377 pipe->extra_config.enable_reduced_pipe; 378 video_descr->isp_pipe_version = pipe->config.isp_pipe_version; 379 video_descr->enable_fractional_ds = 380 pipe->extra_config.enable_fractional_ds; 381 video_descr->enable_dpc = 382 pipe->config.enable_dpc; 383 video_descr->enable_tnr = 384 pipe->config.enable_tnr; 385 386 if (pipe->extra_config.enable_raw_binning) { 387 if (pipe->config.bayer_ds_out_res.width != 0 && 388 pipe->config.bayer_ds_out_res.height != 0) { 389 bds_out_info->res.width = 390 pipe->config.bayer_ds_out_res.width; 391 bds_out_info->res.height = 392 pipe->config.bayer_ds_out_res.height; 393 bds_out_info->padded_width = 394 pipe->config.bayer_ds_out_res.width; 395 err = 396 binarydesc_calculate_bds_factor( 397 in_info->res, bds_out_info->res, 398 &video_descr->required_bds_factor); 399 if (err) 400 return err; 401 } else { 402 bds_out_info->res.width = 403 in_info->res.width / 2; 404 bds_out_info->res.height = 405 in_info->res.height / 2; 406 bds_out_info->padded_width = 407 in_info->padded_width / 2; 408 video_descr->required_bds_factor = 409 SH_CSS_BDS_FACTOR_2_00; 410 } 411 } else { 412 bds_out_info->res.width = in_info->res.width; 413 bds_out_info->res.height = in_info->res.height; 414 bds_out_info->padded_width = in_info->padded_width; 415 video_descr->required_bds_factor = 416 SH_CSS_BDS_FACTOR_1_00; 417 } 418 419 pipe->required_bds_factor = video_descr->required_bds_factor; 420 421 /* bayer ds and fractional ds cannot be enabled 422 at the same time, so we disable bds_out_info when 423 fractional ds is used */ 424 if (!pipe->extra_config.enable_fractional_ds) 425 video_descr->bds_out_info = bds_out_info; 426 else 427 video_descr->bds_out_info = NULL; 428 429 video_descr->enable_fractional_ds = 430 pipe->extra_config.enable_fractional_ds; 431 video_descr->stream_config_left_padding = stream_config_left_padding; 432 } 433 IA_CSS_LEAVE_ERR_PRIVATE(err); 434 return err; 435} 436 437void ia_css_pipe_get_yuvscaler_binarydesc( 438 struct ia_css_pipe const *const pipe, 439 struct ia_css_binary_descr *yuv_scaler_descr, 440 struct ia_css_frame_info *in_info, 441 struct ia_css_frame_info *out_info, 442 struct ia_css_frame_info *internal_out_info, 443 struct ia_css_frame_info *vf_info) 444{ 445 struct ia_css_frame_info *out_infos[IA_CSS_BINARY_MAX_OUTPUT_PORTS]; 446 struct ia_css_frame_info *this_vf_info = NULL; 447 448 assert(pipe); 449 assert(in_info); 450 /* Note: if the following assert fails, the number of ports has been 451 * changed; in that case an additional initializer must be added 452 * a few lines below after which this assert can be updated. 453 */ 454 assert(IA_CSS_BINARY_MAX_OUTPUT_PORTS == 2); 455 IA_CSS_ENTER_PRIVATE(""); 456 457 in_info->padded_width = in_info->res.width; 458 in_info->raw_bit_depth = 0; 459 ia_css_frame_info_set_width(in_info, in_info->res.width, 0); 460 out_infos[0] = out_info; 461 out_infos[1] = internal_out_info; 462 /* add initializers here if 463 * assert(IA_CSS_BINARY_MAX_OUTPUT_PORTS == ...); 464 * fails 465 */ 466 467 if (vf_info) { 468 this_vf_info = (vf_info->res.width == 0 && 469 vf_info->res.height == 0) ? NULL : vf_info; 470 } 471 472 pipe_binarydesc_get_offline(pipe, 473 IA_CSS_BINARY_MODE_CAPTURE_PP, 474 yuv_scaler_descr, 475 in_info, out_infos, this_vf_info); 476 477 yuv_scaler_descr->enable_fractional_ds = true; 478 IA_CSS_LEAVE_PRIVATE(""); 479} 480 481void ia_css_pipe_get_capturepp_binarydesc( 482 struct ia_css_pipe *const pipe, 483 struct ia_css_binary_descr *capture_pp_descr, 484 struct ia_css_frame_info *in_info, 485 struct ia_css_frame_info *out_info, 486 struct ia_css_frame_info *vf_info) 487{ 488 unsigned int i; 489 struct ia_css_frame_info *out_infos[IA_CSS_BINARY_MAX_OUTPUT_PORTS]; 490 491 assert(pipe); 492 assert(in_info); 493 assert(vf_info); 494 IA_CSS_ENTER_PRIVATE(""); 495 496 /* the in_info is only used for resolution to enable 497 bayer down scaling. */ 498 if (pipe->out_yuv_ds_input_info.res.width) 499 *in_info = pipe->out_yuv_ds_input_info; 500 else 501 *in_info = *out_info; 502 in_info->format = IA_CSS_FRAME_FORMAT_YUV420; 503 in_info->raw_bit_depth = 0; 504 ia_css_frame_info_set_width(in_info, in_info->res.width, 0); 505 506 out_infos[0] = out_info; 507 for (i = 1; i < IA_CSS_BINARY_MAX_OUTPUT_PORTS; i++) 508 out_infos[i] = NULL; 509 510 pipe_binarydesc_get_offline(pipe, 511 IA_CSS_BINARY_MODE_CAPTURE_PP, 512 capture_pp_descr, 513 in_info, out_infos, vf_info); 514 515 capture_pp_descr->enable_capture_pp_bli = 516 pipe->config.default_capture_config.enable_capture_pp_bli; 517 capture_pp_descr->enable_fractional_ds = true; 518 capture_pp_descr->enable_xnr = 519 pipe->config.default_capture_config.enable_xnr != 0; 520 IA_CSS_LEAVE_PRIVATE(""); 521} 522 523/* lookup table for high quality primary binaries */ 524static unsigned int primary_hq_binary_modes[NUM_PRIMARY_HQ_STAGES] = { 525 IA_CSS_BINARY_MODE_PRIMARY_HQ_STAGE0, 526 IA_CSS_BINARY_MODE_PRIMARY_HQ_STAGE1, 527 IA_CSS_BINARY_MODE_PRIMARY_HQ_STAGE2, 528 IA_CSS_BINARY_MODE_PRIMARY_HQ_STAGE3, 529 IA_CSS_BINARY_MODE_PRIMARY_HQ_STAGE4, 530 IA_CSS_BINARY_MODE_PRIMARY_HQ_STAGE5 531}; 532 533void ia_css_pipe_get_primary_binarydesc( 534 struct ia_css_pipe const *const pipe, 535 struct ia_css_binary_descr *prim_descr, 536 struct ia_css_frame_info *in_info, 537 struct ia_css_frame_info *out_info, 538 struct ia_css_frame_info *vf_info, 539 unsigned int stage_idx) 540{ 541 enum ia_css_pipe_version pipe_version = pipe->config.isp_pipe_version; 542 int mode; 543 unsigned int i; 544 struct ia_css_frame_info *out_infos[IA_CSS_BINARY_MAX_OUTPUT_PORTS]; 545 546 assert(pipe); 547 assert(in_info); 548 assert(out_info); 549 assert(stage_idx < NUM_PRIMARY_HQ_STAGES); 550 /* vf_info can be NULL - example video_binarydescr */ 551 /*assert(vf_info != NULL);*/ 552 IA_CSS_ENTER_PRIVATE(""); 553 554 if (pipe_version == IA_CSS_PIPE_VERSION_2_6_1) 555 mode = primary_hq_binary_modes[stage_idx]; 556 else 557 mode = IA_CSS_BINARY_MODE_PRIMARY; 558 559 if (ia_css_util_is_input_format_yuv(pipe->stream->config.input_config.format)) 560 mode = IA_CSS_BINARY_MODE_COPY; 561 562 in_info->res = pipe->config.input_effective_res; 563 in_info->padded_width = in_info->res.width; 564 565 if (pipe->stream->config.pack_raw_pixels) 566 in_info->format = IA_CSS_FRAME_FORMAT_RAW_PACKED; 567 else 568 in_info->format = IA_CSS_FRAME_FORMAT_RAW; 569 570 in_info->raw_bit_depth = ia_css_pipe_util_pipe_input_format_bpp(pipe); 571 out_infos[0] = out_info; 572 for (i = 1; i < IA_CSS_BINARY_MAX_OUTPUT_PORTS; i++) 573 out_infos[i] = NULL; 574 575 pipe_binarydesc_get_offline(pipe, mode, 576 prim_descr, in_info, out_infos, vf_info); 577 578 if (pipe->stream->config.online && 579 pipe->stream->config.mode != IA_CSS_INPUT_MODE_MEMORY) { 580 prim_descr->online = true; 581 prim_descr->two_ppc = 582 (pipe->stream->config.pixels_per_clock == 2); 583 prim_descr->stream_format = pipe->stream->config.input_config.format; 584 } 585 if (mode == IA_CSS_BINARY_MODE_PRIMARY) { 586 prim_descr->isp_pipe_version = pipe->config.isp_pipe_version; 587 prim_descr->enable_fractional_ds = 588 pipe->extra_config.enable_fractional_ds; 589 /* We have both striped and non-striped primary binaries, 590 * if continuous viewfinder is required, then we must select 591 * a striped one. Otherwise we prefer to use a non-striped 592 * since it has better performance. */ 593 if (pipe_version == IA_CSS_PIPE_VERSION_2_6_1) 594 prim_descr->striped = false; 595 else 596 prim_descr->striped = prim_descr->continuous && 597 (!pipe->stream->stop_copy_preview || !pipe->stream->disable_cont_vf); 598 } 599 IA_CSS_LEAVE_PRIVATE(""); 600} 601 602void ia_css_pipe_get_pre_gdc_binarydesc( 603 struct ia_css_pipe const *const pipe, 604 struct ia_css_binary_descr *pre_gdc_descr, 605 struct ia_css_frame_info *in_info, 606 struct ia_css_frame_info *out_info) 607{ 608 unsigned int i; 609 struct ia_css_frame_info *out_infos[IA_CSS_BINARY_MAX_OUTPUT_PORTS]; 610 611 assert(pipe); 612 assert(in_info); 613 assert(out_info); 614 IA_CSS_ENTER_PRIVATE(""); 615 616 *in_info = *out_info; 617 in_info->format = IA_CSS_FRAME_FORMAT_RAW; 618 in_info->raw_bit_depth = ia_css_pipe_util_pipe_input_format_bpp(pipe); 619 out_infos[0] = out_info; 620 for (i = 1; i < IA_CSS_BINARY_MAX_OUTPUT_PORTS; i++) 621 out_infos[i] = NULL; 622 623 pipe_binarydesc_get_offline(pipe, IA_CSS_BINARY_MODE_PRE_ISP, 624 pre_gdc_descr, in_info, out_infos, NULL); 625 pre_gdc_descr->isp_pipe_version = pipe->config.isp_pipe_version; 626 IA_CSS_LEAVE_PRIVATE(""); 627} 628 629void ia_css_pipe_get_gdc_binarydesc( 630 struct ia_css_pipe const *const pipe, 631 struct ia_css_binary_descr *gdc_descr, 632 struct ia_css_frame_info *in_info, 633 struct ia_css_frame_info *out_info) 634{ 635 unsigned int i; 636 struct ia_css_frame_info *out_infos[IA_CSS_BINARY_MAX_OUTPUT_PORTS]; 637 638 assert(pipe); 639 assert(in_info); 640 assert(out_info); 641 IA_CSS_ENTER_PRIVATE(""); 642 643 *in_info = *out_info; 644 in_info->format = IA_CSS_FRAME_FORMAT_QPLANE6; 645 out_infos[0] = out_info; 646 for (i = 1; i < IA_CSS_BINARY_MAX_OUTPUT_PORTS; i++) 647 out_infos[i] = NULL; 648 649 pipe_binarydesc_get_offline(pipe, IA_CSS_BINARY_MODE_GDC, 650 gdc_descr, in_info, out_infos, NULL); 651 IA_CSS_LEAVE_PRIVATE(""); 652} 653 654void ia_css_pipe_get_post_gdc_binarydesc( 655 struct ia_css_pipe const *const pipe, 656 struct ia_css_binary_descr *post_gdc_descr, 657 struct ia_css_frame_info *in_info, 658 struct ia_css_frame_info *out_info, 659 struct ia_css_frame_info *vf_info) 660{ 661 unsigned int i; 662 struct ia_css_frame_info *out_infos[IA_CSS_BINARY_MAX_OUTPUT_PORTS]; 663 664 assert(pipe); 665 assert(in_info); 666 assert(out_info); 667 assert(vf_info); 668 IA_CSS_ENTER_PRIVATE(""); 669 670 *in_info = *out_info; 671 in_info->format = IA_CSS_FRAME_FORMAT_YUV420_16; 672 in_info->raw_bit_depth = 16; 673 out_infos[0] = out_info; 674 for (i = 1; i < IA_CSS_BINARY_MAX_OUTPUT_PORTS; i++) 675 out_infos[i] = NULL; 676 677 pipe_binarydesc_get_offline(pipe, IA_CSS_BINARY_MODE_POST_ISP, 678 post_gdc_descr, in_info, out_infos, vf_info); 679 680 post_gdc_descr->isp_pipe_version = pipe->config.isp_pipe_version; 681 IA_CSS_LEAVE_PRIVATE(""); 682} 683 684void ia_css_pipe_get_pre_de_binarydesc( 685 struct ia_css_pipe const *const pipe, 686 struct ia_css_binary_descr *pre_de_descr, 687 struct ia_css_frame_info *in_info, 688 struct ia_css_frame_info *out_info) 689{ 690 unsigned int i; 691 struct ia_css_frame_info *out_infos[IA_CSS_BINARY_MAX_OUTPUT_PORTS]; 692 693 assert(pipe); 694 assert(in_info); 695 assert(out_info); 696 IA_CSS_ENTER_PRIVATE(""); 697 698 *in_info = *out_info; 699 in_info->format = IA_CSS_FRAME_FORMAT_RAW; 700 in_info->raw_bit_depth = ia_css_pipe_util_pipe_input_format_bpp(pipe); 701 out_infos[0] = out_info; 702 for (i = 1; i < IA_CSS_BINARY_MAX_OUTPUT_PORTS; i++) 703 out_infos[i] = NULL; 704 705 if (pipe->config.isp_pipe_version == IA_CSS_PIPE_VERSION_1) 706 pipe_binarydesc_get_offline(pipe, IA_CSS_BINARY_MODE_PRE_ISP, 707 pre_de_descr, in_info, out_infos, NULL); 708 else if (pipe->config.isp_pipe_version == IA_CSS_PIPE_VERSION_2_2) { 709 pipe_binarydesc_get_offline(pipe, IA_CSS_BINARY_MODE_PRE_DE, 710 pre_de_descr, in_info, out_infos, NULL); 711 } 712 713 if (pipe->stream->config.online) { 714 pre_de_descr->online = true; 715 pre_de_descr->two_ppc = 716 (pipe->stream->config.pixels_per_clock == 2); 717 pre_de_descr->stream_format = pipe->stream->config.input_config.format; 718 } 719 pre_de_descr->isp_pipe_version = pipe->config.isp_pipe_version; 720 IA_CSS_LEAVE_PRIVATE(""); 721} 722 723void ia_css_pipe_get_pre_anr_binarydesc( 724 struct ia_css_pipe const *const pipe, 725 struct ia_css_binary_descr *pre_anr_descr, 726 struct ia_css_frame_info *in_info, 727 struct ia_css_frame_info *out_info) 728{ 729 unsigned int i; 730 struct ia_css_frame_info *out_infos[IA_CSS_BINARY_MAX_OUTPUT_PORTS]; 731 732 assert(pipe); 733 assert(in_info); 734 assert(out_info); 735 IA_CSS_ENTER_PRIVATE(""); 736 737 *in_info = *out_info; 738 in_info->format = IA_CSS_FRAME_FORMAT_RAW; 739 in_info->raw_bit_depth = ia_css_pipe_util_pipe_input_format_bpp(pipe); 740 out_infos[0] = out_info; 741 for (i = 1; i < IA_CSS_BINARY_MAX_OUTPUT_PORTS; i++) 742 out_infos[i] = NULL; 743 744 pipe_binarydesc_get_offline(pipe, IA_CSS_BINARY_MODE_PRE_ISP, 745 pre_anr_descr, in_info, out_infos, NULL); 746 747 if (pipe->stream->config.online) { 748 pre_anr_descr->online = true; 749 pre_anr_descr->two_ppc = 750 (pipe->stream->config.pixels_per_clock == 2); 751 pre_anr_descr->stream_format = pipe->stream->config.input_config.format; 752 } 753 pre_anr_descr->isp_pipe_version = pipe->config.isp_pipe_version; 754 IA_CSS_LEAVE_PRIVATE(""); 755} 756 757void ia_css_pipe_get_anr_binarydesc( 758 struct ia_css_pipe const *const pipe, 759 struct ia_css_binary_descr *anr_descr, 760 struct ia_css_frame_info *in_info, 761 struct ia_css_frame_info *out_info) 762{ 763 unsigned int i; 764 struct ia_css_frame_info *out_infos[IA_CSS_BINARY_MAX_OUTPUT_PORTS]; 765 766 assert(pipe); 767 assert(in_info); 768 assert(out_info); 769 IA_CSS_ENTER_PRIVATE(""); 770 771 *in_info = *out_info; 772 in_info->format = IA_CSS_FRAME_FORMAT_RAW; 773 in_info->raw_bit_depth = ANR_ELEMENT_BITS; 774 out_infos[0] = out_info; 775 for (i = 1; i < IA_CSS_BINARY_MAX_OUTPUT_PORTS; i++) 776 out_infos[i] = NULL; 777 778 pipe_binarydesc_get_offline(pipe, IA_CSS_BINARY_MODE_ANR, 779 anr_descr, in_info, out_infos, NULL); 780 781 anr_descr->isp_pipe_version = pipe->config.isp_pipe_version; 782 IA_CSS_LEAVE_PRIVATE(""); 783} 784 785void ia_css_pipe_get_post_anr_binarydesc( 786 struct ia_css_pipe const *const pipe, 787 struct ia_css_binary_descr *post_anr_descr, 788 struct ia_css_frame_info *in_info, 789 struct ia_css_frame_info *out_info, 790 struct ia_css_frame_info *vf_info) 791{ 792 unsigned int i; 793 struct ia_css_frame_info *out_infos[IA_CSS_BINARY_MAX_OUTPUT_PORTS]; 794 795 assert(pipe); 796 assert(in_info); 797 assert(out_info); 798 assert(vf_info); 799 IA_CSS_ENTER_PRIVATE(""); 800 801 *in_info = *out_info; 802 in_info->format = IA_CSS_FRAME_FORMAT_RAW; 803 in_info->raw_bit_depth = ANR_ELEMENT_BITS; 804 out_infos[0] = out_info; 805 for (i = 1; i < IA_CSS_BINARY_MAX_OUTPUT_PORTS; i++) 806 out_infos[i] = NULL; 807 808 pipe_binarydesc_get_offline(pipe, IA_CSS_BINARY_MODE_POST_ISP, 809 post_anr_descr, in_info, out_infos, vf_info); 810 811 post_anr_descr->isp_pipe_version = pipe->config.isp_pipe_version; 812 IA_CSS_LEAVE_PRIVATE(""); 813} 814 815void ia_css_pipe_get_ldc_binarydesc( 816 struct ia_css_pipe const *const pipe, 817 struct ia_css_binary_descr *ldc_descr, 818 struct ia_css_frame_info *in_info, 819 struct ia_css_frame_info *out_info) 820{ 821 unsigned int i; 822 struct ia_css_frame_info *out_infos[IA_CSS_BINARY_MAX_OUTPUT_PORTS]; 823 824 assert(pipe); 825 assert(in_info); 826 assert(out_info); 827 IA_CSS_ENTER_PRIVATE(""); 828 829 *in_info = *out_info; 830 831 in_info->format = IA_CSS_FRAME_FORMAT_YUV420; 832 in_info->raw_bit_depth = 0; 833 ia_css_frame_info_set_width(in_info, in_info->res.width, 0); 834 835 out_infos[0] = out_info; 836 for (i = 1; i < IA_CSS_BINARY_MAX_OUTPUT_PORTS; i++) 837 out_infos[i] = NULL; 838 839 pipe_binarydesc_get_offline(pipe, IA_CSS_BINARY_MODE_CAPTURE_PP, 840 ldc_descr, in_info, out_infos, NULL); 841 ldc_descr->enable_dvs_6axis = 842 pipe->extra_config.enable_dvs_6axis; 843 IA_CSS_LEAVE_PRIVATE(""); 844} 845