Renesas
Video library for GR-PEACH
Dependents: Trace_Program2 GR-PEACH_Camera_in_barcode GR-PEACH_LCD_sample GR-PEACH_LCD_4_3inch_sample ... more
Embed:
(wiki syntax)
Show/hide line numbers
r_vdc5.c
Go to the documentation of this file.
00001 /******************************************************************************* 00002 * DISCLAIMER 00003 * This software is supplied by Renesas Electronics Corporation and is only 00004 * intended for use with Renesas products. No other uses are authorized. This 00005 * software is owned by Renesas Electronics Corporation and is protected under 00006 * all applicable laws, including copyright laws. 00007 * THIS SOFTWARE IS PROVIDED "AS IS" AND RENESAS MAKES NO WARRANTIES REGARDING 00008 * THIS SOFTWARE, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING BUT NOT 00009 * LIMITED TO WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE 00010 * AND NON-INFRINGEMENT. ALL SUCH WARRANTIES ARE EXPRESSLY DISCLAIMED. 00011 * TO THE MAXIMUM EXTENT PERMITTED NOT PROHIBITED BY LAW, NEITHER RENESAS 00012 * ELECTRONICS CORPORATION NOR ANY OF ITS AFFILIATED COMPANIES SHALL BE LIABLE 00013 * FOR ANY DIRECT, INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES FOR 00014 * ANY REASON RELATED TO THIS SOFTWARE, EVEN IF RENESAS OR ITS AFFILIATES HAVE 00015 * BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. 00016 * Renesas reserves the right, without notice, to make changes to this software 00017 * and to discontinue the availability of this software. By using this software, 00018 * you agree to the additional terms and conditions found by accessing the 00019 * following link: 00020 * http://www.renesas.com/disclaimer 00021 * Copyright (C) 2012 - 2015 Renesas Electronics Corporation. All rights reserved. 00022 *******************************************************************************/ 00023 /**************************************************************************//** 00024 * @file r_vdc5.c 00025 * @version 1.00 00026 * $Rev: 199 $ 00027 * $Date:: 2014-05-23 16:33:52 +0900#$ 00028 * @brief VDC5 driver API function 00029 ******************************************************************************/ 00030 00031 /****************************************************************************** 00032 Includes <System Includes> , "Project Includes" 00033 ******************************************************************************/ 00034 #include "r_vdc5.h" 00035 #include "r_vdc5_user.h" 00036 #include "r_vdc5_register.h" 00037 #include "r_vdc5_shared_param.h" 00038 #include "r_vdc5_check_parameter.h" 00039 00040 00041 /****************************************************************************** 00042 Macro definitions 00043 ******************************************************************************/ 00044 00045 /****************************************************************************** 00046 Typedef definitions 00047 ******************************************************************************/ 00048 00049 /****************************************************************************** 00050 Private global variables and functions 00051 ******************************************************************************/ 00052 static vdc5_scaling_type_t ConvertRwProcId2SclId(const vdc5_layer_id_t layer_id); 00053 static vdc5_graphics_type_t ConvertRwProcId2GrId(const vdc5_layer_id_t layer_id); 00054 00055 00056 /**************************************************************************//** 00057 * @brief VDC5 driver initialization 00058 * 00059 * Description:<br> 00060 * This function performs the following processing: 00061 * - Initializes the VDC5 driver's internal variables. 00062 * - Calls the user-defined function specified in init_func. 00063 * - Sets up and enables the VDC5's panel clock. 00064 * - Sets up and enables the LVDS only if LVDS is used. 00065 * - Disables all the VDC5 interrupts. 00066 * @param[in] ch : Channel 00067 * @param[in] param : Initialization parameter 00068 * @param[in] init_func : Pointer to a user-defined function 00069 * @param[in] user_num : User defined number 00070 * @retval Error code 00071 *****************************************************************************/ 00072 vdc5_error_t R_VDC5_Initialize ( 00073 const vdc5_channel_t ch, 00074 const vdc5_init_t * const param, 00075 void (* const init_func)(uint32_t), 00076 const uint32_t user_num) 00077 { 00078 vdc5_error_t ret; 00079 vdc5_resource_state_t rsrc_state; 00080 00081 ret = VDC5_OK ; 00082 #ifdef R_VDC5_CHECK_PARAMETERS 00083 ret = VDC5_InitializeCheckPrm(ch, param); 00084 #endif /* R_VDC5_CHECK_PARAMETERS */ 00085 if (ret == VDC5_OK ) { 00086 VDC5_ShrdPrmInit(ch); 00087 /* Resource checks */ 00088 rsrc_state = VDC5_ShrdPrmGetResource(ch, VDC5_RESOURCE_LVDS_CLK ); 00089 if (rsrc_state != VDC5_RESOURCE_ST_INVALID ) { 00090 /* The LVDS PLL clock has been already set. */ 00091 if (param->lvds != NULL) { 00092 ret = VDC5_ERR_RESOURCE_LVDS_CLK ; 00093 } 00094 } 00095 } 00096 if (ret == VDC5_OK ) { 00097 VDC5_ShrdPrmSetInitParam(ch, param); 00098 00099 /* Callback function */ 00100 if (init_func != 0) { 00101 init_func(user_num); 00102 } 00103 00104 VDC5_Initialize(ch, param); 00105 00106 /* Disable all VDC5 interrupts */ 00107 VDC5_Int_Disable(ch); 00108 00109 VDC5_ShrdPrmSetResource(ch, VDC5_RESOURCE_PANEL_CLK , VDC5_RESOURCE_ST_VALID ); 00110 if (param->lvds != NULL) { 00111 VDC5_ShrdPrmSetResource(ch, VDC5_RESOURCE_LVDS_CLK , VDC5_RESOURCE_ST_VALID ); 00112 } 00113 } 00114 return ret; 00115 } /* End of function R_VDC5_Initialize() */ 00116 00117 /**************************************************************************//** 00118 * @brief VDC5 driver termination 00119 * 00120 * Description:<br> 00121 * This function performs the following processing: 00122 * - Disables all the VDC5 interrupts. 00123 * - Disables the VDC5 panel clock. 00124 * - Disables the LVDS if one is used and becomes unnecessary as the result of calling this function. 00125 * - Calls the user-defined function specified in quit_func. 00126 * @param[in] ch : Channel 00127 * @param[in] quit_func : Pointer to a user-defined function 00128 * @param[in] user_num : User defined number 00129 * @retval Error code 00130 *****************************************************************************/ 00131 vdc5_error_t R_VDC5_Terminate (const vdc5_channel_t ch, void (* const quit_func)(uint32_t), const uint32_t user_num) 00132 { 00133 vdc5_error_t ret; 00134 vdc5_onoff_t lvds_ref; 00135 00136 ret = VDC5_OK ; 00137 #ifdef R_VDC5_CHECK_PARAMETERS 00138 ret = VDC5_TerminateCheckPrm(ch); 00139 #endif /* R_VDC5_CHECK_PARAMETERS */ 00140 if (ret == VDC5_OK ) { 00141 VDC5_ShrdPrmSetTerminate(ch); 00142 00143 /* Disable all VDC5 interrupts */ 00144 VDC5_Int_Disable(ch); 00145 00146 VDC5_Terminate(ch); 00147 00148 VDC5_ShrdPrmSetResource(ch, VDC5_RESOURCE_PANEL_CLK , VDC5_RESOURCE_ST_INVALID ); 00149 00150 lvds_ref = VDC5_ShrdPrmGetLvdsClkRef(); 00151 if (lvds_ref == VDC5_OFF ) { /* LVDS PLL clock is not referred. */ 00152 VDC5_ShrdPrmSetResource(ch, VDC5_RESOURCE_LVDS_CLK , VDC5_RESOURCE_ST_INVALID ); 00153 } 00154 00155 /* Callback function */ 00156 if (quit_func != 0) { 00157 quit_func(user_num); 00158 } 00159 } 00160 return ret; 00161 } /* End of function R_VDC5_Terminate() */ 00162 00163 /**************************************************************************//** 00164 * @brief Video input setup 00165 * 00166 * Description:<br> 00167 * This function performs the following processing: 00168 * - Selects the video input. 00169 * - Sets up the phase timing of the input signals. 00170 * - Performs delay control on the sync signal for the video inputs. 00171 * - Sets up the parameters for the external input video signals only when they are used. 00172 * @param[in] ch : Channel 00173 * @param[in] param : Video input setup parameter 00174 * @retval Error code 00175 *****************************************************************************/ 00176 vdc5_error_t R_VDC5_VideoInput (const vdc5_channel_t ch, const vdc5_input_t * const param) 00177 { 00178 vdc5_error_t ret; 00179 00180 ret = VDC5_OK ; 00181 #ifdef R_VDC5_CHECK_PARAMETERS 00182 ret = VDC5_VideoInputCheckPrm(ch, param); 00183 #endif /* R_VDC5_CHECK_PARAMETERS */ 00184 if (ret == VDC5_OK ) { 00185 VDC5_ShrdPrmSetInputParam(ch, param); 00186 00187 /* Setting VDC5 registers */ 00188 VDC5_VideoInput(ch, param); 00189 00190 VDC5_ShrdPrmSetResource(ch, VDC5_RESOURCE_VIDEO_IN , VDC5_RESOURCE_ST_VALID ); 00191 } 00192 return ret; 00193 } /* End of function R_VDC5_VideoInput() */ 00194 00195 /**************************************************************************//** 00196 * @brief Sync control setup 00197 * 00198 * Description:<br> 00199 * This function performs the following processing: 00200 * - Selects the vertical sync signal. 00201 * - Sets up the period of the sync signal. 00202 * - Sets up the delay of the vertical sync signal. 00203 * - Sets up the full-screen enable signal. 00204 * - Sets up the compensation for the vertical sync signal. 00205 * @param[in] ch : Channel 00206 * @param[in] param : Sync control parameter 00207 * @retval Error code 00208 *****************************************************************************/ 00209 vdc5_error_t R_VDC5_SyncControl (const vdc5_channel_t ch, const vdc5_sync_ctrl_t * const param) 00210 { 00211 vdc5_error_t ret; 00212 vdc5_resource_state_t rsrc_state; 00213 00214 ret = VDC5_OK ; 00215 #ifdef R_VDC5_CHECK_PARAMETERS 00216 ret = VDC5_SyncControlCheckPrm(ch, param); 00217 #endif /* R_VDC5_CHECK_PARAMETERS */ 00218 if (ret == VDC5_OK ) { 00219 /* Resource checks */ 00220 rsrc_state = VDC5_ShrdPrmGetResource(ch, VDC5_RESOURCE_PANEL_CLK ); 00221 if (rsrc_state != VDC5_RESOURCE_ST_VALID ) { 00222 ret = VDC5_ERR_RESOURCE_CLK ; 00223 } 00224 } 00225 if (ret == VDC5_OK ) { 00226 if (param->res_vs_sel == VDC5_OFF ) { 00227 /* External input Vsync signal is selected. */ 00228 if (param->res_vs_in_sel == VDC5_RES_VS_IN_SEL_SC0 ) { 00229 /* Scaler 0 */ 00230 rsrc_state = VDC5_ShrdPrmGetResource(ch, VDC5_RESOURCE_VIDEO_IN ); 00231 } else { 00232 /* Scaler 1 */ 00233 rsrc_state = VDC5_ShrdPrmGetResource( 00234 ((ch == VDC5_CHANNEL_0 ) ? VDC5_CHANNEL_1 : VDC5_CHANNEL_0 ), 00235 VDC5_RESOURCE_VIDEO_IN ); 00236 } 00237 if (rsrc_state != VDC5_RESOURCE_ST_VALID ) { 00238 ret = VDC5_ERR_RESOURCE_INPUT ; 00239 } 00240 } 00241 } 00242 if (ret == VDC5_OK ) { 00243 VDC5_ShrdPrmSetSyncParam(ch, param); 00244 00245 /* Setting VDC5 registers */ 00246 VDC5_SyncControl(ch, param); 00247 00248 VDC5_ShrdPrmSetResource(ch, VDC5_RESOURCE_VSYNC , VDC5_RESOURCE_ST_VALID ); 00249 } 00250 return ret; 00251 } /* End of function R_VDC5_SyncControl() */ 00252 00253 /**************************************************************************//** 00254 * @brief Display output setup 00255 * 00256 * Description:<br> 00257 * This function performs the following processing: 00258 * - Sets up the timing signals for driving the LCD panel. 00259 * - Sets up the phase, data sequence, and format of the LCD panel output data. 00260 * - Sets up the background color. 00261 * @param[in] ch : Channel 00262 * @param[in] param : Display output configuration parameter 00263 * @retval Error code 00264 *****************************************************************************/ 00265 vdc5_error_t R_VDC5_DisplayOutput (const vdc5_channel_t ch, const vdc5_output_t * const param) 00266 { 00267 vdc5_error_t ret; 00268 vdc5_resource_state_t rsrc_state; 00269 00270 ret = VDC5_OK ; 00271 #ifdef R_VDC5_CHECK_PARAMETERS 00272 ret = VDC5_DisplayOutputCheckPrm(ch, param); 00273 #endif /* R_VDC5_CHECK_PARAMETERS */ 00274 if (ret == VDC5_OK ) { 00275 /* Resource checks */ 00276 rsrc_state = VDC5_ShrdPrmGetResource(ch, VDC5_RESOURCE_PANEL_CLK ); 00277 if (rsrc_state != VDC5_RESOURCE_ST_VALID ) { 00278 ret = VDC5_ERR_RESOURCE_CLK ; 00279 } else { 00280 rsrc_state = VDC5_ShrdPrmGetResource(ch, VDC5_RESOURCE_VSYNC ); 00281 if (rsrc_state != VDC5_RESOURCE_ST_VALID ) { 00282 ret = VDC5_ERR_RESOURCE_VSYNC ; 00283 } 00284 } 00285 } 00286 if (ret == VDC5_OK ) { 00287 VDC5_ShrdPrmSetOutputParam(ch, param); 00288 00289 /* Setting VDC5 registers */ 00290 VDC5_DisplayOutput(ch, param); 00291 00292 VDC5_ShrdPrmSetResource(ch, VDC5_RESOURCE_LCD_PANEL , VDC5_RESOURCE_ST_VALID ); 00293 } 00294 return ret; 00295 } /* End of function R_VDC5_DisplayOutput() */ 00296 00297 /**************************************************************************//** 00298 * @brief Interrupt callback setup 00299 * 00300 * Description:<br> 00301 * This function performs the following processing: 00302 * - Enables the interrupt when the pointer to the corresponding interrupt callback function is specified. 00303 * - Registers the specified interrupt callback function. 00304 * - Disables the interrupt when the pointer to the corresponding interrupt callback function is not 00305 * specified. 00306 * @param[in] ch : Channel 00307 * @param[in] param : Interrupt callback setup parameter 00308 * @retval Error code 00309 *****************************************************************************/ 00310 vdc5_error_t R_VDC5_CallbackISR (const vdc5_channel_t ch, const vdc5_int_t * const param) 00311 { 00312 vdc5_error_t ret; 00313 vdc5_resource_state_t rsrc_state; 00314 00315 ret = VDC5_OK ; 00316 #ifdef R_VDC5_CHECK_PARAMETERS 00317 ret = VDC5_CallbackISRCheckPrm(ch, param); 00318 #endif /* R_VDC5_CHECK_PARAMETERS */ 00319 if (ret == VDC5_OK ) { 00320 /* Resource checks */ 00321 rsrc_state = VDC5_ShrdPrmGetResource(ch, VDC5_RESOURCE_PANEL_CLK ); 00322 if (rsrc_state != VDC5_RESOURCE_ST_VALID ) { 00323 ret = VDC5_ERR_RESOURCE_CLK ; 00324 } else { 00325 rsrc_state = VDC5_ShrdPrmGetResource(ch, VDC5_RESOURCE_VSYNC ); 00326 if (rsrc_state != VDC5_RESOURCE_ST_VALID ) { 00327 ret = VDC5_ERR_RESOURCE_VSYNC ; 00328 } 00329 } 00330 } 00331 if (ret == VDC5_OK ) { 00332 /* Setting VDC5 registers */ 00333 VDC5_Int_SetInterrupt(ch, param); 00334 } 00335 return ret; 00336 } /* End of function R_VDC5_CallbackISR() */ 00337 00338 /**************************************************************************//** 00339 * @brief Data write control processing 00340 * 00341 * Description:<br> 00342 * This function performs the following processing: 00343 * - Sets up the input image area to be captured. 00344 * - Makes input image scale-down/rotation control settings (layers 0 and 1 only). 00345 * - Makes frame buffer write control settings. 00346 * @param[in] ch : Channel 00347 * @param[in] layer_id : Layer ID 00348 * - VDC5_LAYER_ID_0_WR 00349 * - VDC5_LAYER_ID_1_WR 00350 * - VDC5_LAYER_ID_OIR_WR 00351 * @param[in] param : Data write control parameter 00352 * @retval Error code 00353 *****************************************************************************/ 00354 vdc5_error_t R_VDC5_WriteDataControl ( 00355 const vdc5_channel_t ch, 00356 const vdc5_layer_id_t layer_id, 00357 const vdc5_write_t * const param) 00358 { 00359 vdc5_error_t ret; 00360 vdc5_scaling_type_t scaling_id; 00361 vdc5_resource_state_t rsrc_state; 00362 00363 scaling_id = ConvertRwProcId2SclId(layer_id); 00364 00365 ret = VDC5_OK ; 00366 #ifdef R_VDC5_CHECK_PARAMETERS 00367 ret = VDC5_WriteDataControlCheckPrm(ch, layer_id, param); 00368 #endif /* R_VDC5_CHECK_PARAMETERS */ 00369 if (ret == VDC5_OK ) { 00370 /* Resource checks */ 00371 rsrc_state = VDC5_ShrdPrmGetLayerResource(ch, layer_id); 00372 if (rsrc_state != VDC5_RESOURCE_ST_INVALID ) { 00373 /* The specified layer is already used. */ 00374 ret = VDC5_ERR_RESOURCE_LAYER ; 00375 } else { 00376 if (layer_id == VDC5_LAYER_ID_0_WR ) { 00377 /* Layer 0 */ 00378 rsrc_state = VDC5_ShrdPrmGetResource(ch, VDC5_RESOURCE_VIDEO_IN ); 00379 } else if (layer_id == VDC5_LAYER_ID_1_WR ) { 00380 /* Layer 1 */ 00381 rsrc_state = VDC5_ShrdPrmGetResource( 00382 ((ch == VDC5_CHANNEL_0 ) ? VDC5_CHANNEL_1 : VDC5_CHANNEL_0 ), 00383 VDC5_RESOURCE_VIDEO_IN ); 00384 } else { 00385 /* Layer OIR */ 00386 rsrc_state = VDC5_RESOURCE_ST_VALID ; 00387 } 00388 if (rsrc_state != VDC5_RESOURCE_ST_VALID ) { 00389 ret = VDC5_ERR_RESOURCE_INPUT ; 00390 } 00391 } 00392 } 00393 if (ret == VDC5_OK ) { 00394 VDC5_ShrdPrmSetWriteParam(ch, scaling_id, param); 00395 00396 /* Setting VDC5 registers */ 00397 VDC5_WriteDataControl(ch, scaling_id, param); 00398 00399 VDC5_ShrdPrmSetLayerResource(ch, layer_id, VDC5_RESOURCE_ST_VALID ); 00400 } 00401 return ret; 00402 } /* End of function R_VDC5_WriteDataControl() */ 00403 00404 /**************************************************************************//** 00405 * @brief Data write change processing 00406 * 00407 * Description:<br> 00408 * This function performs the following processing: 00409 * - Changes the input image area to be captured. 00410 * - Makes changes with respect to scaling-down/rotation control of the input image (layers 0 and 1 only). 00411 * @param[in] ch : Channel 00412 * @param[in] layer_id : Layer ID 00413 * - VDC5_LAYER_ID_0_WR 00414 * - VDC5_LAYER_ID_1_WR 00415 * - VDC5_LAYER_ID_OIR_WR 00416 * @param[in] param : Data write change parameter 00417 * @retval Error code 00418 *****************************************************************************/ 00419 vdc5_error_t R_VDC5_ChangeWriteProcess ( 00420 const vdc5_channel_t ch, 00421 const vdc5_layer_id_t layer_id, 00422 const vdc5_write_chg_t * const param) 00423 { 00424 vdc5_error_t ret; 00425 vdc5_scaling_type_t scaling_id; 00426 vdc5_resource_state_t rsrc_state; 00427 00428 scaling_id = ConvertRwProcId2SclId(layer_id); 00429 00430 ret = VDC5_OK ; 00431 #ifdef R_VDC5_CHECK_PARAMETERS 00432 ret = VDC5_ChangeWriteProcessCheckPrm(ch, layer_id, param); 00433 #endif /* R_VDC5_CHECK_PARAMETERS */ 00434 if (ret == VDC5_OK ) { 00435 /* Resource checks */ 00436 rsrc_state = VDC5_ShrdPrmGetRwProcEnabled(ch, layer_id); 00437 if (rsrc_state == VDC5_RESOURCE_ST_INVALID ) { 00438 /* The specified layer is invalid. */ 00439 ret = VDC5_ERR_RESOURCE_LAYER ; 00440 } 00441 } 00442 if (ret == VDC5_OK ) { 00443 VDC5_ShrdPrmSetChgWriteParam(ch, scaling_id, param); 00444 00445 /* Setting VDC5 registers */ 00446 VDC5_ChangeWriteProcess(ch, scaling_id, param); 00447 } 00448 return ret; 00449 } /* End of function R_VDC5_ChangeWriteProcess() */ 00450 00451 /**************************************************************************//** 00452 * @brief Data read control processing 00453 * 00454 * Description:<br> 00455 * This function performs the following processing: 00456 * - Sets up the display area for graphics images. 00457 * - Makes image scale-up control settings (layers 0 and 1 only). 00458 * - Makes frame buffer read control settings. 00459 * @param[in] ch : Channel 00460 * @param[in] layer_id : Layer ID 00461 * - VDC5_LAYER_ID_0_RD 00462 * - VDC5_LAYER_ID_1_RD 00463 * - VDC5_LAYER_ID_2_RD 00464 * - VDC5_LAYER_ID_3_RD 00465 * - VDC5_LAYER_ID_OIR_RD 00466 * @param[in] param : Data read control parameter 00467 * @retval Error code 00468 *****************************************************************************/ 00469 vdc5_error_t R_VDC5_ReadDataControl ( 00470 const vdc5_channel_t ch, 00471 const vdc5_layer_id_t layer_id, 00472 const vdc5_read_t * const param) 00473 { 00474 vdc5_error_t ret; 00475 vdc5_graphics_type_t graphics_id; 00476 vdc5_resource_state_t rsrc_state; 00477 00478 graphics_id = ConvertRwProcId2GrId(layer_id); 00479 00480 ret = VDC5_OK ; 00481 #ifdef R_VDC5_CHECK_PARAMETERS 00482 ret = VDC5_ReadDataControlCheckPrm(ch, layer_id, graphics_id, param); 00483 #endif /* R_VDC5_CHECK_PARAMETERS */ 00484 if (ret == VDC5_OK ) { 00485 /* Resource checks */ 00486 rsrc_state = VDC5_ShrdPrmGetLayerResource(ch, layer_id); 00487 if (rsrc_state != VDC5_RESOURCE_ST_INVALID ) { 00488 /* The specified layer is already used. */ 00489 ret = VDC5_ERR_RESOURCE_LAYER ; 00490 } 00491 } 00492 if (ret == VDC5_OK ) { 00493 VDC5_ShrdPrmSetReadParam(ch, graphics_id, param); 00494 00495 /* Setting VDC5 registers */ 00496 VDC5_ReadDataControl(ch, graphics_id, param); 00497 00498 VDC5_ShrdPrmSetLayerResource(ch, layer_id, VDC5_RESOURCE_ST_VALID ); 00499 } 00500 return ret; 00501 } /* End of function R_VDC5_ReadDataControl() */ 00502 00503 /**************************************************************************//** 00504 * @brief Data read change processing 00505 * 00506 * Description:<br> 00507 * This function performs the following processing: 00508 * - Changes the frame buffer base address. 00509 * - Changes the frame buffer read size (image scale-up control) (layers 0 and 1 only). 00510 * - Changes the display area for graphics images. 00511 * - Changes the graphics display mode. 00512 * @param[in] ch : Channel 00513 * @param[in] layer_id : Layer ID 00514 * - VDC5_LAYER_ID_0_RD 00515 * - VDC5_LAYER_ID_1_RD 00516 * - VDC5_LAYER_ID_2_RD 00517 * - VDC5_LAYER_ID_3_RD 00518 * - VDC5_LAYER_ID_OIR_RD 00519 * @param[in] param : Data read change parameter 00520 * @retval Error code 00521 *****************************************************************************/ 00522 vdc5_error_t R_VDC5_ChangeReadProcess ( 00523 const vdc5_channel_t ch, 00524 const vdc5_layer_id_t layer_id, 00525 const vdc5_read_chg_t * const param) 00526 { 00527 vdc5_error_t ret; 00528 vdc5_graphics_type_t graphics_id; 00529 vdc5_resource_state_t rsrc_state; 00530 00531 graphics_id = ConvertRwProcId2GrId(layer_id); 00532 00533 ret = VDC5_OK ; 00534 #ifdef R_VDC5_CHECK_PARAMETERS 00535 ret = VDC5_ChangeReadProcessCheckPrm(ch, layer_id, param); 00536 #endif /* R_VDC5_CHECK_PARAMETERS */ 00537 if (ret == VDC5_OK ) { 00538 /* Resource checks */ 00539 rsrc_state = VDC5_ShrdPrmGetRwProcEnabled(ch, layer_id); 00540 if (rsrc_state == VDC5_RESOURCE_ST_INVALID ) { 00541 /* The specified layer is invalid. */ 00542 ret = VDC5_ERR_RESOURCE_LAYER ; 00543 } 00544 } 00545 if (ret == VDC5_OK ) { 00546 VDC5_ShrdPrmSetChgReadParam(ch, graphics_id, param); 00547 00548 /* Setting VDC5 registers */ 00549 VDC5_ChangeReadProcess(ch, graphics_id, param); 00550 } 00551 return ret; 00552 } /* End of function R_VDC5_ChangeReadProcess() */ 00553 00554 /**************************************************************************//** 00555 * @brief Data write/read start processing 00556 * 00557 * Description:<br> 00558 * This function performs layer start processing. If the layer ID specified in layer_id 00559 * is VDC5_LAYER_ID_ALL, the function starts all the layers that are in the stopped state 00560 * and also enabled. If the layer ID is not VDC5_LAYER_ID_ALL, the function starts only 00561 * the specified layer.<br> 00562 * When performing start processing for write, the function starts a write to the frame buffer. 00563 * When performing start processing for read, the function starts a read from the frame buffer 00564 * and sets the graphics display mode to the specified values for each layer. 00565 * @param[in] ch : Channel 00566 * @param[in] layer_id : Layer ID 00567 * @param[in] param : Data write/read start parameter 00568 * @retval Error code 00569 *****************************************************************************/ 00570 vdc5_error_t R_VDC5_StartProcess ( 00571 const vdc5_channel_t ch, 00572 const vdc5_layer_id_t layer_id, 00573 const vdc5_start_t * const param) 00574 { 00575 vdc5_error_t ret; 00576 vdc5_resource_state_t rsrc_state; 00577 00578 ret = VDC5_OK ; 00579 #ifdef R_VDC5_CHECK_PARAMETERS 00580 ret = VDC5_StartProcessCheckPrm(ch, layer_id, param); 00581 #endif /* R_VDC5_CHECK_PARAMETERS */ 00582 if (ret == VDC5_OK ) { 00583 /* Resource checks */ 00584 if (layer_id != VDC5_LAYER_ID_ALL ) { 00585 rsrc_state = VDC5_ShrdPrmGetRwProcReady(ch, layer_id); 00586 if (rsrc_state == VDC5_RESOURCE_ST_INVALID ) { 00587 /* The specified layer is invalid. */ 00588 ret = VDC5_ERR_RESOURCE_LAYER ; 00589 } 00590 } 00591 } 00592 if (ret == VDC5_OK ) { 00593 /* Setting VDC5 registers */ 00594 VDC5_StartProcess(ch, layer_id, param); 00595 } 00596 return ret; 00597 } /* End of function R_VDC5_StartProcess() */ 00598 00599 /**************************************************************************//** 00600 * @brief Data write/read stop processing 00601 * 00602 * Description:<br> 00603 * This function performs layer stop processing. If the layer ID specified in layer_id is 00604 * VDC5_LAYER_ID_ALL, the function stops all the layers that are enabled and running. 00605 * If the layer ID is not VDC5_LAYER_ID_ALL, the function stops only the specified layer.<br> 00606 * When performing stop processing for write, the function stops the write to the frame buffer. 00607 * When performing stop processing for read, the function stops the read from the frame buffer 00608 * and resets the graphics display mode to the initial values for each of the layers. 00609 * @param[in] ch : Channel 00610 * @param[in] layer_id : Layer ID 00611 * @retval Error code 00612 *****************************************************************************/ 00613 vdc5_error_t R_VDC5_StopProcess (const vdc5_channel_t ch, const vdc5_layer_id_t layer_id) 00614 { 00615 vdc5_error_t ret; 00616 vdc5_resource_state_t rsrc_state; 00617 00618 ret = VDC5_OK ; 00619 #ifdef R_VDC5_CHECK_PARAMETERS 00620 ret = VDC5_StopProcessCheckPrm(ch, layer_id); 00621 #endif /* R_VDC5_CHECK_PARAMETERS */ 00622 if (ret == VDC5_OK ) { 00623 /* Resource checks */ 00624 if (layer_id != VDC5_LAYER_ID_ALL ) { 00625 rsrc_state = VDC5_ShrdPrmGetRwProcEnabled(ch, layer_id); 00626 if (rsrc_state == VDC5_RESOURCE_ST_INVALID ) { 00627 /* The specified layer is invalid. */ 00628 ret = VDC5_ERR_RESOURCE_LAYER ; 00629 } 00630 } 00631 } 00632 if (ret == VDC5_OK ) { 00633 /* Setting VDC5 registers */ 00634 VDC5_StopProcess(ch, layer_id); 00635 } 00636 return ret; 00637 } /* End of function R_VDC5_StopSurface() */ 00638 00639 /**************************************************************************//** 00640 * @brief Data write/read control release processing 00641 * 00642 * Description:<br> 00643 * This function performs the following processing: 00644 * - Disables the specified layer. 00645 * - Initializes the cascaded connection settings (layer 1 read processing only). 00646 * - Initializes the VIN synthesizer settings (layer 0 and 1 read processing only). 00647 * @param[in] ch : Channel 00648 * @param[in] layer_id : Layer ID 00649 * @retval Error code 00650 *****************************************************************************/ 00651 vdc5_error_t R_VDC5_ReleaseDataControl (const vdc5_channel_t ch, const vdc5_layer_id_t layer_id) 00652 { 00653 vdc5_error_t ret; 00654 vdc5_resource_state_t rsrc_state; 00655 00656 ret = VDC5_OK ; 00657 #ifdef R_VDC5_CHECK_PARAMETERS 00658 ret = VDC5_ReleaseDataControlCheckPrm(ch, layer_id); 00659 #endif /* R_VDC5_CHECK_PARAMETERS */ 00660 if (ret == VDC5_OK ) { 00661 /* Resource checks */ 00662 if (layer_id != VDC5_LAYER_ID_ALL ) { 00663 rsrc_state = VDC5_ShrdPrmGetRwProcReady(ch, layer_id); 00664 if (rsrc_state == VDC5_RESOURCE_ST_INVALID ) { 00665 /* The specified layer is invalid. */ 00666 ret = VDC5_ERR_RESOURCE_LAYER ; 00667 } 00668 } 00669 } 00670 if (ret == VDC5_OK ) { 00671 /* Setting VDC5 registers */ 00672 VDC5_ReleaseDataControl(ch, layer_id); 00673 00674 VDC5_ShrdPrmSetLayerResource(ch, layer_id, VDC5_RESOURCE_ST_INVALID ); 00675 } 00676 return ret; 00677 } /* End of function R_VDC5_ReleaseDataControl() */ 00678 00679 /**************************************************************************//** 00680 * @brief Noise reduction setup 00681 * 00682 * Description:<br> 00683 * This function performs the following processing: 00684 * - Turns on and off noise reduction processing. 00685 * - Sets up the noise reduction parameters for the Y/G, Cb/B, and Cr/R signals. 00686 * @param[in] ch : Channel 00687 * @param[in] nr1d_on : Noise reduction ON/OFF setting 00688 * @param[in] param : Noise reduction setup parameter 00689 * @retval Error code 00690 *****************************************************************************/ 00691 vdc5_error_t R_VDC5_VideoNoiseReduction ( 00692 const vdc5_channel_t ch, 00693 const vdc5_onoff_t nr1d_on, 00694 const vdc5_noise_reduction_t * const param) 00695 { 00696 vdc5_error_t ret; 00697 vdc5_resource_state_t rsrc_state; 00698 00699 ret = VDC5_OK ; 00700 #ifdef R_VDC5_CHECK_PARAMETERS 00701 ret = VDC5_VideoNoiseReductCheckPrm(ch, param); 00702 #endif /* R_VDC5_CHECK_PARAMETERS */ 00703 if (ret == VDC5_OK ) { 00704 /* Resource checks */ 00705 rsrc_state = VDC5_ShrdPrmGetResource(ch, VDC5_RESOURCE_VIDEO_IN ); 00706 if (rsrc_state != VDC5_RESOURCE_ST_VALID ) { 00707 ret = VDC5_ERR_RESOURCE_INPUT ; 00708 } 00709 } 00710 if (ret == VDC5_OK ) { 00711 /* Setting VDC5 registers */ 00712 VDC5_VideoNoiseReduction(ch, nr1d_on, param); 00713 } 00714 return ret; 00715 } /* End of function R_VDC5_VideoNoiseReduction() */ 00716 00717 /**************************************************************************//** 00718 * @brief Color matrix setup 00719 * 00720 * Description:<br> 00721 * This function sets up the specified color matrix. 00722 * @param[in] ch : Channel 00723 * @param[in] param : Color matrix setup parameter 00724 * @retval Error code 00725 *****************************************************************************/ 00726 vdc5_error_t R_VDC5_ImageColorMatrix (const vdc5_channel_t ch, const vdc5_color_matrix_t * const param) 00727 { 00728 vdc5_error_t ret; 00729 vdc5_resource_state_t rsrc_state; 00730 00731 ret = VDC5_OK ; 00732 #ifdef R_VDC5_CHECK_PARAMETERS 00733 ret = VDC5_ImageColorMatrixCheckPrm(ch, param); 00734 #endif /* R_VDC5_CHECK_PARAMETERS */ 00735 if (ret == VDC5_OK ) { 00736 /* Resource checks */ 00737 if (param->module == VDC5_COLORMTX_IMGCNT ) { 00738 rsrc_state = VDC5_ShrdPrmGetLayerResource(ch, VDC5_LAYER_ID_0_WR ); 00739 if (rsrc_state == VDC5_RESOURCE_ST_INVALID ) { 00740 rsrc_state = VDC5_ShrdPrmGetLayerResource( 00741 ((ch == VDC5_CHANNEL_0 ) ? VDC5_CHANNEL_1 : VDC5_CHANNEL_0 ), 00742 VDC5_LAYER_ID_1_WR ); 00743 } 00744 } else if (param->module == VDC5_COLORMTX_ADJ_0 ) { 00745 rsrc_state = VDC5_ShrdPrmGetLayerResource(ch, VDC5_LAYER_ID_0_RD ); 00746 } else { 00747 rsrc_state = VDC5_ShrdPrmGetLayerResource(ch, VDC5_LAYER_ID_1_RD ); 00748 } 00749 00750 if (rsrc_state == VDC5_RESOURCE_ST_INVALID ) { 00751 ret = VDC5_ERR_RESOURCE_LAYER ; 00752 } 00753 } 00754 if (ret == VDC5_OK ) { 00755 /* Setting VDC5 registers */ 00756 VDC5_ImageColorMatrix(ch, param); 00757 } 00758 return ret; 00759 } /* End of function R_VDC5_ImageColorMatrix() */ 00760 00761 /**************************************************************************//** 00762 * @brief Image enhancement processing 00763 * 00764 * Description:<br> 00765 * This function performs the following processing: 00766 * - Turns on and off sharpness processing. 00767 * - Sets up the sharpness parameter. 00768 * - Turns on and off LTI processing. 00769 * - Sets up the LTI parameter. 00770 * - Sets up the enhancer-enabled area to be subjected to sharpness and LTI processing. 00771 * @param[in] ch : Channel 00772 * @param[in] imgimprv_id : Image quality improver ID 00773 * @param[in] shp_h_on : Sharpness ON/OFF setting 00774 * @param[in] sharp_param : Sharpness setup parameter 00775 * @param[in] lti_h_on : LTI ON/OFF setting 00776 * @param[in] lti_param : LTI setup parameter 00777 * @param[in] enh_area : Enhancer-enabled area setup parameter 00778 * @retval Error code 00779 *****************************************************************************/ 00780 vdc5_error_t R_VDC5_ImageEnhancement ( 00781 const vdc5_channel_t ch, 00782 const vdc5_imgimprv_id_t imgimprv_id, 00783 const vdc5_onoff_t shp_h_on, 00784 const vdc5_enhance_sharp_t * const sharp_param, 00785 const vdc5_onoff_t lti_h_on, 00786 const vdc5_enhance_lti_t * const lti_param, 00787 const vdc5_period_rect_t * const enh_area) 00788 { 00789 vdc5_error_t ret; 00790 vdc5_resource_state_t rsrc_state; 00791 vdc5_color_space_t color_space; 00792 00793 ret = VDC5_OK ; 00794 #ifdef R_VDC5_CHECK_PARAMETERS 00795 ret = VDC5_ImageEnhancementCheckPrm(ch, imgimprv_id, sharp_param, enh_area); 00796 #endif /* R_VDC5_CHECK_PARAMETERS */ 00797 if (ret == VDC5_OK ) { 00798 /* Resource checks */ 00799 rsrc_state = VDC5_ShrdPrmGetLayerResource( 00800 ch, 00801 ((imgimprv_id == VDC5_IMG_IMPRV_0 ) ? VDC5_LAYER_ID_0_RD : VDC5_LAYER_ID_1_RD )); 00802 if (rsrc_state == VDC5_RESOURCE_ST_INVALID ) { 00803 /* The layer is invalid. */ 00804 ret = VDC5_ERR_RESOURCE_LAYER ; 00805 } else { 00806 /* Condition checks */ 00807 color_space = VDC5_ShrdPrmGetColorSpaceFbRd( 00808 ch, 00809 ((imgimprv_id == VDC5_IMG_IMPRV_0 ) ? VDC5_GR_TYPE_GR0 : VDC5_GR_TYPE_GR1 )); 00810 if (color_space == VDC5_COLOR_SPACE_GBR ) { 00811 /* The image quality improver does not act on RGB signals. */ 00812 ret = VDC5_ERR_IF_CONDITION ; 00813 } 00814 } 00815 } 00816 if (ret == VDC5_OK ) { 00817 /* Setting VDC5 registers */ 00818 VDC5_ImageEnhancement(ch, imgimprv_id, shp_h_on, sharp_param, lti_h_on, lti_param, enh_area); 00819 } 00820 return ret; 00821 } /* End of function R_VDC5_ImageEnhancement() */ 00822 00823 /**************************************************************************//** 00824 * @brief Black stretch setup 00825 * 00826 * Description:<br> 00827 * This function performs the following processing: 00828 * - Turns on and off black stretch processing. 00829 * - Sets up the black stretch parameters. 00830 * @param[in] ch : Channel 00831 * @param[in] imgimprv_id : Image quality improver ID 00832 * @param[in] bkstr_on : Black stretch ON/OFF setting 00833 * @param[in] param : Black stretch setup parameter 00834 * @retval Error code 00835 *****************************************************************************/ 00836 vdc5_error_t R_VDC5_ImageBlackStretch ( 00837 const vdc5_channel_t ch, 00838 const vdc5_imgimprv_id_t imgimprv_id, 00839 const vdc5_onoff_t bkstr_on, 00840 const vdc5_black_t * const param) 00841 { 00842 vdc5_error_t ret; 00843 vdc5_resource_state_t rsrc_state; 00844 vdc5_color_space_t color_space; 00845 00846 ret = VDC5_OK ; 00847 #ifdef R_VDC5_CHECK_PARAMETERS 00848 ret = VDC5_ImageBlackStretchCheckPrm(ch, imgimprv_id, param); 00849 #endif /* R_VDC5_CHECK_PARAMETERS */ 00850 if (ret == VDC5_OK ) { 00851 /* Resource checks */ 00852 rsrc_state = VDC5_ShrdPrmGetLayerResource( 00853 ch, 00854 ((imgimprv_id == VDC5_IMG_IMPRV_0 ) ? VDC5_LAYER_ID_0_RD : VDC5_LAYER_ID_1_RD )); 00855 if (rsrc_state == VDC5_RESOURCE_ST_INVALID ) { 00856 /* The layer is invalid. */ 00857 ret = VDC5_ERR_RESOURCE_LAYER ; 00858 } else { 00859 /* Condition checks */ 00860 color_space = VDC5_ShrdPrmGetColorSpaceFbRd( 00861 ch, 00862 ((imgimprv_id == VDC5_IMG_IMPRV_0 ) ? VDC5_GR_TYPE_GR0 : VDC5_GR_TYPE_GR1 )); 00863 if (color_space == VDC5_COLOR_SPACE_GBR ) { 00864 /* The image quality improver does not act on RGB signals. */ 00865 ret = VDC5_ERR_IF_CONDITION ; 00866 } 00867 } 00868 } 00869 if (ret == VDC5_OK ) { 00870 /* Setting VDC5 registers */ 00871 VDC5_ImageBlackStretch(ch, imgimprv_id, bkstr_on, param); 00872 } 00873 return ret; 00874 } /* End of function R_VDC5_ImageBlackStretch() */ 00875 00876 /**************************************************************************//** 00877 * @brief Alpha blending setup 00878 * 00879 * Description:<br> 00880 * This function performs the following processing: 00881 * - Sets up the alpha value of the ARGB1555/RGBA5551 formats. 00882 * - Make settings for premultiplication processing at alpha blending in one-pixel. 00883 * @param[in] ch : Channel 00884 * @param[in] layer_id : Layer ID 00885 * - VDC5_LAYER_ID_1_RD 00886 * - VDC5_LAYER_ID_2_RD 00887 * - VDC5_LAYER_ID_3_RD 00888 * @param[in] param : Alpha blending setup parameter 00889 * @retval Error code 00890 *****************************************************************************/ 00891 vdc5_error_t R_VDC5_AlphaBlending ( 00892 const vdc5_channel_t ch, 00893 const vdc5_layer_id_t layer_id, 00894 const vdc5_alpha_blending_t * const param) 00895 { 00896 vdc5_error_t ret; 00897 vdc5_graphics_type_t graphics_id; 00898 vdc5_resource_state_t rsrc_state; 00899 00900 graphics_id = ConvertRwProcId2GrId(layer_id); 00901 00902 ret = VDC5_OK ; 00903 #ifdef R_VDC5_CHECK_PARAMETERS 00904 ret = VDC5_AlphaBlendingCheckPrm(ch, layer_id, param); 00905 #endif /* R_VDC5_CHECK_PARAMETERS */ 00906 if (ret == VDC5_OK ) { 00907 /* Resource checks */ 00908 rsrc_state = VDC5_ShrdPrmGetLayerResource(ch, layer_id); 00909 if (rsrc_state == VDC5_RESOURCE_ST_INVALID ) { 00910 /* The specified layer is invalid. */ 00911 ret = VDC5_ERR_RESOURCE_LAYER ; 00912 } 00913 } 00914 if (ret == VDC5_OK ) { 00915 /* Setting VDC5 registers */ 00916 VDC5_AlphaBlending(ch, graphics_id, param); 00917 } 00918 return ret; 00919 } /* End of function R_VDC5_AlphaBlending() */ 00920 00921 /**************************************************************************//** 00922 * @brief Rectangle alpha blending setup 00923 * 00924 * Description:<br> 00925 * This function performs the following processing: 00926 * - Turns on and off alpha blending in a rectangular area. 00927 * - Sets up the rectangular area subjected to alpha blending. 00928 * - Sets up the alpha value for alpha blending in a rectangular area. 00929 * - Makes fade-in/-out settings to be applied to rectangle alpha blending. 00930 * - Allocates graphics 0 and 1 to the lower-layer/current graphics in the VIN synthesizer. 00931 * @param[in] ch : Channel 00932 * @param[in] layer_id : Layer ID 00933 * - VDC5_LAYER_ID_1_RD 00934 * - VDC5_LAYER_ID_2_RD 00935 * - VDC5_LAYER_ID_3_RD 00936 * - VDC5_LAYER_ID_VIN_RD 00937 * @param[in] gr_arc_on : ON/OFF setting for alpha blending in a rectangular area 00938 * @param[in] param : Setup parameter for alpha blending in a rectangular area 00939 * @retval Error code 00940 *****************************************************************************/ 00941 vdc5_error_t R_VDC5_AlphaBlendingRect ( 00942 const vdc5_channel_t ch, 00943 const vdc5_layer_id_t layer_id, 00944 const vdc5_onoff_t gr_arc_on, 00945 const vdc5_alpha_blending_rect_t * const param) 00946 { 00947 vdc5_error_t ret; 00948 vdc5_graphics_type_t graphics_id; 00949 vdc5_color_space_t color_space; 00950 vdc5_resource_state_t rsrc_state; 00951 00952 graphics_id = ConvertRwProcId2GrId(layer_id); 00953 00954 ret = VDC5_OK ; 00955 #ifdef R_VDC5_CHECK_PARAMETERS 00956 ret = VDC5_AlphaBlendingRectCheckPrm(ch, layer_id, param); 00957 #endif /* R_VDC5_CHECK_PARAMETERS */ 00958 if (ret == VDC5_OK ) { 00959 if (layer_id != VDC5_LAYER_ID_VIN_RD ) { 00960 /* Resource checks */ 00961 rsrc_state = VDC5_ShrdPrmGetLayerResource(ch, layer_id); 00962 if (rsrc_state == VDC5_RESOURCE_ST_INVALID ) { 00963 /* The specified layer is invalid. */ 00964 ret = VDC5_ERR_RESOURCE_LAYER ; 00965 } else { 00966 /* Condition checks */ 00967 color_space = VDC5_ShrdPrmGetColorSpaceFbRd(ch, graphics_id); 00968 if (color_space == VDC5_COLOR_SPACE_YCBCR ) { 00969 /* Alpha blending cannot be used 00970 when the format of the signal read from the frame buffer is YCbCr422 or YCbCr444. */ 00971 ret = VDC5_ERR_IF_CONDITION ; 00972 } 00973 } 00974 } 00975 } 00976 if (ret == VDC5_OK ) { 00977 /* Setting VDC5 registers */ 00978 VDC5_AlphaBlendingRect(ch, graphics_id, gr_arc_on, param); 00979 } 00980 return ret; 00981 } /* End of function R_VDC5_AlphaBlendingRect() */ 00982 00983 /**************************************************************************//** 00984 * @brief Chroma-key setup 00985 * 00986 * Description:<br> 00987 * This function performs the following processing: 00988 * - Turns on and off the chroma-key processing. 00989 * - Sets up the color signals to be subject to chroma-key processing and 00990 * the color signals after replacement. 00991 * @param[in] ch : Channel 00992 * @param[in] layer_id : Layer ID 00993 * - VDC5_LAYER_ID_0_RD 00994 * - VDC5_LAYER_ID_1_RD 00995 * - VDC5_LAYER_ID_2_RD 00996 * - VDC5_LAYER_ID_3_RD 00997 * - VDC5_LAYER_ID_OIR_RD 00998 * @param[in] gr_ck_on : Chroma-key ON/OFF setting 00999 * @param[in] param : Chroma-key setup parameter 01000 * @retval Error code 01001 *****************************************************************************/ 01002 vdc5_error_t R_VDC5_Chromakey ( 01003 const vdc5_channel_t ch, 01004 const vdc5_layer_id_t layer_id, 01005 const vdc5_onoff_t gr_ck_on, 01006 const vdc5_chromakey_t * const param) 01007 { 01008 vdc5_error_t ret; 01009 vdc5_graphics_type_t graphics_id; 01010 vdc5_color_space_t color_space; 01011 vdc5_resource_state_t rsrc_state; 01012 01013 graphics_id = ConvertRwProcId2GrId(layer_id); 01014 01015 ret = VDC5_OK ; 01016 #ifdef R_VDC5_CHECK_PARAMETERS 01017 ret = VDC5_ChromakeyCheckPrm(ch, layer_id, graphics_id, param); 01018 #endif /* R_VDC5_CHECK_PARAMETERS */ 01019 if (ret == VDC5_OK ) { 01020 /* Resource checks */ 01021 rsrc_state = VDC5_ShrdPrmGetLayerResource(ch, layer_id); 01022 if (rsrc_state == VDC5_RESOURCE_ST_INVALID ) { 01023 /* The specified layer is invalid. */ 01024 ret = VDC5_ERR_RESOURCE_LAYER ; 01025 } else { 01026 /* Condition checks */ 01027 color_space = VDC5_ShrdPrmGetColorSpaceFbRd(ch, graphics_id); 01028 if (color_space == VDC5_COLOR_SPACE_YCBCR ) { 01029 /* Chroma-key processing cannot be used 01030 when the format of the signal read from the frame buffer is YCbCr422 or YCbCr444. */ 01031 ret = VDC5_ERR_IF_CONDITION ; 01032 } 01033 } 01034 } 01035 if (ret == VDC5_OK ) { 01036 /* Setting VDC5 registers */ 01037 VDC5_Chromakey(ch, graphics_id, gr_ck_on, param); 01038 } 01039 return ret; 01040 } /* End of function R_VDC5_Chromakey() */ 01041 01042 /**************************************************************************//** 01043 * @brief CLUT setup 01044 * 01045 * Description:<br> 01046 * This function sets up CLUT for the specified layer. 01047 * @param[in] ch : Channel 01048 * @param[in] layer_id : Layer ID 01049 * - VDC5_LAYER_ID_0_RD 01050 * - VDC5_LAYER_ID_1_RD 01051 * - VDC5_LAYER_ID_2_RD 01052 * - VDC5_LAYER_ID_3_RD 01053 * - VDC5_LAYER_ID_OIR_RD 01054 * @param[in] param : CLUT setup parameter 01055 * @retval Error code 01056 *****************************************************************************/ 01057 vdc5_error_t R_VDC5_CLUT (const vdc5_channel_t ch, const vdc5_layer_id_t layer_id, const vdc5_clut_t * const param) 01058 { 01059 vdc5_error_t ret; 01060 vdc5_graphics_type_t graphics_id; 01061 vdc5_resource_state_t rsrc_state; 01062 01063 graphics_id = ConvertRwProcId2GrId(layer_id); 01064 01065 ret = VDC5_OK ; 01066 #ifdef R_VDC5_CHECK_PARAMETERS 01067 ret = VDC5_CLUTCheckPrm(ch, layer_id, graphics_id, param); 01068 #endif /* R_VDC5_CHECK_PARAMETERS */ 01069 if (ret == VDC5_OK ) { 01070 /* Resource checks */ 01071 rsrc_state = VDC5_ShrdPrmGetLayerResource(ch, layer_id); 01072 if (rsrc_state == VDC5_RESOURCE_ST_INVALID ) { 01073 /* The specified layer is invalid. */ 01074 ret = VDC5_ERR_RESOURCE_LAYER ; 01075 } 01076 } 01077 if (ret == VDC5_OK ) { 01078 /* Setting VDC5 registers */ 01079 VDC5_CLUT(ch, graphics_id, param); 01080 } 01081 return ret; 01082 } /* End of function R_VDC5_SetCLUT() */ 01083 01084 /**************************************************************************//** 01085 * @brief Display calibration processing 01086 * 01087 * Description:<br> 01088 * This function performs the following processing: 01089 * - Sets up panel brightness adjustment. 01090 * - Sets up contrast adjustment. 01091 * - Sets up panel dithering. 01092 * - Makes control settings for the correction circuit sequence. 01093 * @param[in] ch : Channel 01094 * @param[in] param : Display calibration parameter 01095 * @retval Error code 01096 *****************************************************************************/ 01097 vdc5_error_t R_VDC5_DisplayCalibration (const vdc5_channel_t ch, const vdc5_disp_calibration_t * const param) 01098 { 01099 vdc5_error_t ret; 01100 vdc5_resource_state_t rsrc_state; 01101 01102 ret = VDC5_OK ; 01103 #ifdef R_VDC5_CHECK_PARAMETERS 01104 ret = VDC5_DisplayCalibrationCheckPrm(ch, param); 01105 #endif /* R_VDC5_CHECK_PARAMETERS */ 01106 if (ret == VDC5_OK ) { 01107 /* Resource checks */ 01108 rsrc_state = VDC5_ShrdPrmGetResource(ch, VDC5_RESOURCE_LCD_PANEL ); 01109 if (rsrc_state != VDC5_RESOURCE_ST_VALID ) { 01110 ret = VDC5_ERR_RESOURCE_OUTPUT ; 01111 } 01112 } 01113 if (ret == VDC5_OK ) { 01114 /* Setting VDC5 registers */ 01115 VDC5_DisplayCalibration(ch, param); 01116 } 01117 return ret; 01118 } /* End of function R_VDC5_DisplayCalibration() */ 01119 01120 /**************************************************************************//** 01121 * @brief Gamma correction setup 01122 * 01123 * Description:<br> 01124 * This function performs the following processing: 01125 * - Turns on and off gamma correction processing. 01126 * - Sets up the gamma correction gain adjustment values for the G/B/R signals. 01127 * - Sets up the gamma correction start threshold values for the G/B/R signals. 01128 * @param[in] ch : Channel 01129 * @param[in] gam_on : Gamma correction ON/OFF setting 01130 * @param[in] param : Gamma correction setup parameter 01131 * @retval Error code 01132 *****************************************************************************/ 01133 vdc5_error_t R_VDC5_GammaCorrection ( 01134 const vdc5_channel_t ch, 01135 const vdc5_onoff_t gam_on, 01136 const vdc5_gamma_correction_t * const param) 01137 { 01138 vdc5_error_t ret; 01139 vdc5_resource_state_t rsrc_state; 01140 01141 ret = VDC5_OK ; 01142 #ifdef R_VDC5_CHECK_PARAMETERS 01143 ret = VDC5_GammaCorrectionCheckPrm(ch, param); 01144 #endif /* R_VDC5_CHECK_PARAMETERS */ 01145 if (ret == VDC5_OK ) { 01146 /* Resource checks */ 01147 rsrc_state = VDC5_ShrdPrmGetResource(ch, VDC5_RESOURCE_LCD_PANEL ); 01148 if (rsrc_state != VDC5_RESOURCE_ST_VALID ) { 01149 ret = VDC5_ERR_RESOURCE_OUTPUT ; 01150 } 01151 } 01152 if (ret == VDC5_OK ) { 01153 /* Setting VDC5 registers */ 01154 VDC5_GammaCorrection(ch, gam_on, param); 01155 } 01156 return ret; 01157 } /* End of function R_VDC5_GammaCorrection() */ 01158 01159 /****************************************************************************** 01160 Local Functions 01161 ******************************************************************************/ 01162 /**************************************************************************//** 01163 * @brief Convert read/write process ID into scaling type ID 01164 * 01165 * @param[in] layer_id : Layer ID 01166 * @retval Scaling type ID 01167 *****************************************************************************/ 01168 static vdc5_scaling_type_t ConvertRwProcId2SclId (const vdc5_layer_id_t layer_id) 01169 { 01170 vdc5_scaling_type_t scaling_id; 01171 01172 switch (layer_id) { 01173 case VDC5_LAYER_ID_0_WR : /* Layer 0, write process */ 01174 scaling_id = VDC5_SC_TYPE_SC0 ; /* Scaler 0 */ 01175 break; 01176 case VDC5_LAYER_ID_1_WR : /* Layer 1, write process */ 01177 scaling_id = VDC5_SC_TYPE_SC1 ; /* Scaler 1 */ 01178 break; 01179 case VDC5_LAYER_ID_OIR_WR : /* Layer OIR, write process */ 01180 scaling_id = VDC5_SC_TYPE_OIR ; /* OIR */ 01181 break; 01182 default: /* Error */ 01183 scaling_id = VDC5_SC_TYPE_NUM ; 01184 break; 01185 } 01186 return scaling_id; 01187 } /* End of function ConvertRwProcId2SclId() */ 01188 01189 /**************************************************************************//** 01190 * @brief Convert read/write process ID into graphics type ID 01191 * 01192 * @param[in] layer_id : Layer ID 01193 * @retval Graphics type ID 01194 *****************************************************************************/ 01195 static vdc5_graphics_type_t ConvertRwProcId2GrId (const vdc5_layer_id_t layer_id) 01196 { 01197 vdc5_graphics_type_t graphics_id; 01198 01199 switch (layer_id) { 01200 case VDC5_LAYER_ID_0_RD : /* Layer 0, read process */ 01201 graphics_id = VDC5_GR_TYPE_GR0 ; /* Graphics 0 */ 01202 break; 01203 case VDC5_LAYER_ID_1_RD : /* Layer 1, read process */ 01204 graphics_id = VDC5_GR_TYPE_GR1 ; /* Graphics 1 */ 01205 break; 01206 case VDC5_LAYER_ID_2_RD : /* Layer 2, read process */ 01207 graphics_id = VDC5_GR_TYPE_GR2 ; /* Graphics 2 */ 01208 break; 01209 case VDC5_LAYER_ID_3_RD : /* Layer 3, read process */ 01210 graphics_id = VDC5_GR_TYPE_GR3 ; /* Graphics 3 */ 01211 break; 01212 case VDC5_LAYER_ID_VIN_RD : /* Layer VIN, read process */ 01213 graphics_id = VDC5_GR_TYPE_VIN ; /* VIN */ 01214 break; 01215 case VDC5_LAYER_ID_OIR_RD : /* Layer OIR, read process */ 01216 graphics_id = VDC5_GR_TYPE_OIR ; /* OIR */ 01217 break; 01218 default: /* Error */ 01219 graphics_id = VDC5_GR_TYPE_NUM ; 01220 break; 01221 } 01222 return graphics_id; 01223 } /* End of function ConvertRwProcId2GrId() */ 01224
Generated on Tue Jul 12 2022 15:08:46 by
1.7.2