Home | History | Annotate | Download | only in ocl 
      1 /*
      2  * cl_fisheye_handler.h - CL fisheye handler
      3  *
      4  *  Copyright (c) 2016 Intel Corporation
      5  *
      6  * Licensed under the Apache License, Version 2.0 (the "License");
      7  * you may not use this file except in compliance with the License.
      8  * You may obtain a copy of the License at
      9  *
     10  *      http://www.apache.org/licenses/LICENSE-2.0
     11  *
     12  * Unless required by applicable law or agreed to in writing, software
     13  * distributed under the License is distributed on an "AS IS" BASIS,
     14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     15  * See the License for the specific language governing permissions and
     16  * limitations under the License.
     17  *
     18  * Author: Wind Yuan <feng.yuan (at) intel.com>
     19  */
     20 
     21 #ifndef XCAM_CL_FISHEYE_HANDLER_H
     22 #define XCAM_CL_FISHEYE_HANDLER_H
     23 
     24 #include <xcam_std.h>
     25 #include <interface/data_types.h>
     26 #include <ocl/cl_image_handler.h>
     27 #include <ocl/cl_geo_map_handler.h>
     28 #include <surview_fisheye_dewarp.h>
     29 
     30 namespace XCam {
     31 
     32 class CLFisheyeHandler;
     33 class CLFisheye2GPSKernel
     34     : public CLImageKernel
     35 {
     36 public:
     37     explicit CLFisheye2GPSKernel (const SmartPtr<CLContext> &context, SmartPtr<CLFisheyeHandler> &handler);
     38 
     39 protected:
     40     virtual XCamReturn prepare_arguments (CLArgList &args, CLWorkSize &work_size);
     41 
     42 private:
     43     SmartPtr<CLFisheyeHandler>  _handler;
     44 };
     45 
     46 class CLFisheyeHandler
     47     : public CLImageHandler
     48     , public GeoKernelParamCallback
     49 {
     50     friend class CLFisheye2GPSKernel;
     51 public:
     52     explicit CLFisheyeHandler (const SmartPtr<CLContext> &context, SurroundMode surround_mode, bool use_map, bool need_lsc);
     53     virtual ~CLFisheyeHandler();
     54 
     55     void set_output_size (uint32_t width, uint32_t height);
     56     void get_output_size (uint32_t &width, uint32_t &height) const;
     57 
     58     void set_dst_range (float longitude, float latitude);
     59     void get_dst_range (float &longitude, float &latitude) const;
     60     void set_fisheye_info (const FisheyeInfo &info);
     61     const FisheyeInfo &get_fisheye_info () const {
     62         return _fisheye_info;
     63     }
     64 
     65     void set_lsc_table (float *table, uint32_t table_size);
     66     void set_lsc_gray_threshold (float min_threshold, float max_threshold);
     67 
     68     void set_bowl_config(const BowlDataConfig bowl_data_config) {
     69         _bowl_data_config = bowl_data_config;
     70     }
     71     const BowlDataConfig &get_bowl_config() {
     72         return _bowl_data_config;
     73     }
     74 
     75     void set_intrinsic_param(const IntrinsicParameter intrinsic_param) {
     76         _intrinsic_param = intrinsic_param;
     77     }
     78     const IntrinsicParameter &get_intrinsic_param() {
     79         return _intrinsic_param;
     80     }
     81 
     82     void set_extrinsic_param(const ExtrinsicParameter extrinsic_param) {
     83         _extrinsic_param = extrinsic_param;
     84     }
     85     const ExtrinsicParameter &get_extrinsic_param() {
     86         return _extrinsic_param;
     87     }
     88 
     89 
     90 protected:
     91     // derived from CLImageHandler
     92     virtual XCamReturn prepare_buffer_pool_video_info (
     93         const VideoBufferInfo &input, VideoBufferInfo &output);
     94     virtual XCamReturn prepare_parameters (SmartPtr<VideoBuffer> &input, SmartPtr<VideoBuffer> &output);
     95     virtual XCamReturn execute_done (SmartPtr<VideoBuffer> &output);
     96 
     97     // derived from GeoKernelParamCallback
     98     virtual SmartPtr<CLImage> get_geo_input_image (NV12PlaneIdx index);
     99     virtual SmartPtr<CLImage> get_geo_output_image (NV12PlaneIdx index);
    100     virtual SmartPtr<CLImage> get_geo_map_table () {
    101         return _geo_table;
    102     }
    103     virtual void get_geo_equivalent_out_size (float &width, float &height);
    104     virtual void get_geo_pixel_out_size (float &width, float &height);
    105 
    106     virtual SmartPtr<CLImage> get_lsc_table ();
    107     virtual float* get_lsc_gray_threshold ();
    108 
    109 private:
    110     SmartPtr<CLImage> &get_input_image (NV12PlaneIdx index) {
    111         XCAM_ASSERT (index < NV12PlaneMax);
    112         return _input [index];
    113     }
    114     SmartPtr<CLImage> &get_output_image (NV12PlaneIdx index) {
    115         XCAM_ASSERT (index < NV12PlaneMax);
    116         return _output [index];
    117     }
    118 
    119     SmartPtr<CLImage> create_cl_image (
    120         uint32_t width, uint32_t height, cl_channel_order order, cl_channel_type type);
    121     XCamReturn generate_fisheye_table (
    122         uint32_t fisheye_width, uint32_t fisheye_height, const FisheyeInfo &fisheye_info);
    123 
    124     void ensure_lsc_params ();
    125     XCamReturn generate_lsc_table (
    126         uint32_t fisheye_width, uint32_t fisheye_height, FisheyeInfo &fisheye_info);
    127 
    128 
    129     XCAM_DEAD_COPY (CLFisheyeHandler);
    130 
    131 private:
    132     uint32_t                         _output_width;
    133     uint32_t                         _output_height;
    134     float                            _range_longitude;
    135     float                            _range_latitude;
    136     FisheyeInfo                    _fisheye_info;
    137     float                            _map_factor;
    138     bool                             _use_map;
    139     uint32_t                         _need_lsc;
    140     uint32_t                         _lsc_array_size;
    141     float                            _gray_threshold[2];  // [min_gray_threshold, max_gray_threshold]
    142     float                            *_lsc_array;
    143 
    144     BowlDataConfig                   _bowl_data_config;
    145 
    146     IntrinsicParameter               _intrinsic_param;
    147     ExtrinsicParameter               _extrinsic_param;
    148 
    149     SurroundMode                     _surround_mode;
    150 
    151     SmartPtr<CLImage>                _geo_table;
    152     SmartPtr<CLImage>                _lsc_table;
    153     SmartPtr<CLImage>                _input[NV12PlaneMax];
    154     SmartPtr<CLImage>                _output[NV12PlaneMax];
    155 };
    156 
    157 SmartPtr<CLImageHandler>
    158 create_fisheye_handler (const SmartPtr<CLContext> &context, SurroundMode surround_mode = SphereView, bool use_map = false, bool need_lsc = false);
    159 
    160 }
    161 
    162 #endif //XCAM_CL_FISHEYE_HANDLER_H
    163 
    164