karthick B
/
GR-PEACH_video
Important changes to repositories hosted on mbed.com
Mbed hosted mercurial repositories are deprecated and are due to be permanently deleted in July 2026.
To keep a copy of this software download the repository Zip archive or clone locally using Mercurial.
It is also possible to export all your personal repositories from the account settings page.
Fork of
GR-PEACH_video
by 
Renesas
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 14:27:41 by
1.7.2