George Hotz
6 years ago
parent
ef93a715e1
commit
84560ccd55
31 changed files with 9193 additions and 0 deletions
@ -0,0 +1,19 @@ |
||||
Import('env', 'arch', 'messaging', 'common', 'gpucommon', 'visionipc', 'cereal') |
||||
|
||||
libs = ['m', 'pthread', common, 'jpeg', 'json', cereal, 'OpenCL', messaging, 'czmq', 'zmq', 'capnp', 'kj', 'capnp_c', visionipc, gpucommon] |
||||
|
||||
if arch == "aarch64": |
||||
libs += ['gsl', 'CB', 'adreno_utils', 'EGL', 'GLESv3', 'cutils', 'ui'] |
||||
cameras = ['cameras/camera_qcom.c'] |
||||
else: |
||||
libs += [] |
||||
cameras = ['cameras/camera_frame_stream.cc'] |
||||
|
||||
env.SharedLibrary('snapshot/visionipc', |
||||
["#selfdrive/common/visionipc.c", "#selfdrive/common/ipc.c"]) |
||||
|
||||
env.Program('camerad', [ |
||||
'main.cc', |
||||
'transforms/rgb_to_yuv.c', |
||||
cameras, |
||||
], LIBS=libs) |
||||
@ -0,0 +1,8 @@ |
||||
#ifndef _SELFDRIVE_VISIOND_VISIOND_H_ |
||||
#define _SELFDRIVE_VISIOND_VISIOND_H_ |
||||
|
||||
#include <inttypes.h> |
||||
|
||||
typedef struct { uint8_t *y, *u, *v; } YUVBuf; |
||||
|
||||
#endif // _SELFDRIVE_VISIOND_VISIOND_H_
|
||||
@ -0,0 +1,47 @@ |
||||
#ifndef CAMERA_COMMON_H |
||||
#define CAMERA_COMMON_H |
||||
|
||||
#include <stdint.h> |
||||
#include <stdbool.h> |
||||
|
||||
#define CAMERA_ID_IMX298 0 |
||||
#define CAMERA_ID_IMX179 1 |
||||
#define CAMERA_ID_S5K3P8SP 2 |
||||
#define CAMERA_ID_OV8865 3 |
||||
#define CAMERA_ID_IMX298_FLIPPED 4 |
||||
#define CAMERA_ID_OV10640 5 |
||||
#define CAMERA_ID_MAX 6 |
||||
|
||||
#ifdef __cplusplus |
||||
extern "C" { |
||||
#endif |
||||
|
||||
typedef struct CameraInfo { |
||||
const char* name; |
||||
int frame_width, frame_height; |
||||
int frame_stride; |
||||
bool bayer; |
||||
int bayer_flip; |
||||
bool hdr; |
||||
} CameraInfo; |
||||
|
||||
typedef struct FrameMetadata { |
||||
uint32_t frame_id; |
||||
uint64_t timestamp_eof; |
||||
unsigned int frame_length; |
||||
unsigned int integ_lines; |
||||
unsigned int global_gain; |
||||
unsigned int lens_pos; |
||||
float lens_sag; |
||||
float lens_err; |
||||
float lens_true_pos; |
||||
float gain_frac; |
||||
} FrameMetadata; |
||||
|
||||
extern CameraInfo cameras_supported[CAMERA_ID_MAX]; |
||||
|
||||
#ifdef __cplusplus |
||||
} |
||||
#endif |
||||
|
||||
#endif |
||||
@ -0,0 +1,166 @@ |
||||
#include "camera_frame_stream.h" |
||||
|
||||
#include <string> |
||||
#include <unistd.h> |
||||
#include <vector> |
||||
#include <cassert> |
||||
#include <string.h> |
||||
#include <signal.h> |
||||
|
||||
#include <libyuv.h> |
||||
#include <capnp/serialize.h> |
||||
#include "cereal/gen/cpp/log.capnp.h" |
||||
#include "messaging.hpp" |
||||
|
||||
#include "common/util.h" |
||||
#include "common/timing.h" |
||||
#include "common/swaglog.h" |
||||
#include "buffering.h" |
||||
|
||||
extern "C" { |
||||
#include <libavcodec/avcodec.h> |
||||
} |
||||
|
||||
extern volatile sig_atomic_t do_exit; |
||||
|
||||
#define FRAME_WIDTH 1164 |
||||
#define FRAME_HEIGHT 874 |
||||
|
||||
namespace { |
||||
void camera_open(CameraState *s, VisionBuf *camera_bufs, bool rear) { |
||||
assert(camera_bufs); |
||||
s->camera_bufs = camera_bufs; |
||||
} |
||||
|
||||
void camera_close(CameraState *s) { |
||||
tbuffer_stop(&s->camera_tb); |
||||
} |
||||
|
||||
void camera_release_buffer(void *cookie, int buf_idx) { |
||||
CameraState *s = static_cast<CameraState *>(cookie); |
||||
} |
||||
|
||||
void camera_init(CameraState *s, int camera_id, unsigned int fps) { |
||||
assert(camera_id < ARRAYSIZE(cameras_supported)); |
||||
s->ci = cameras_supported[camera_id]; |
||||
assert(s->ci.frame_width != 0); |
||||
|
||||
s->frame_size = s->ci.frame_height * s->ci.frame_stride; |
||||
s->fps = fps; |
||||
|
||||
tbuffer_init2(&s->camera_tb, FRAME_BUF_COUNT, "frame", camera_release_buffer, s); |
||||
} |
||||
|
||||
void run_frame_stream(DualCameraState *s) { |
||||
int err; |
||||
Context * context = Context::create(); |
||||
SubSocket * recorder_sock = SubSocket::create(context, "frame"); |
||||
assert(recorder_sock != NULL); |
||||
|
||||
CameraState *const rear_camera = &s->rear; |
||||
auto *tb = &rear_camera->camera_tb; |
||||
|
||||
while (!do_exit) { |
||||
Message * msg = recorder_sock->receive(); |
||||
|
||||
auto amsg = kj::heapArray<capnp::word>((msg->getSize() / sizeof(capnp::word)) + 1); |
||||
memcpy(amsg.begin(), msg->getData(), msg->getSize()); |
||||
|
||||
capnp::FlatArrayMessageReader cmsg(amsg); |
||||
cereal::Event::Reader event = cmsg.getRoot<cereal::Event>(); |
||||
auto frame = event.getFrame(); |
||||
|
||||
const int buf_idx = tbuffer_select(tb); |
||||
rear_camera->camera_bufs_metadata[buf_idx] = { |
||||
.frame_id = frame.getFrameId(), |
||||
.timestamp_eof = frame.getTimestampEof(), |
||||
.frame_length = static_cast<unsigned>(frame.getFrameLength()), |
||||
.integ_lines = static_cast<unsigned>(frame.getIntegLines()), |
||||
.global_gain = static_cast<unsigned>(frame.getGlobalGain()), |
||||
}; |
||||
|
||||
cl_command_queue q = rear_camera->camera_bufs[buf_idx].copy_q; |
||||
cl_mem yuv_cl = rear_camera->camera_bufs[buf_idx].buf_cl; |
||||
cl_event map_event; |
||||
void *yuv_buf = (void *)clEnqueueMapBuffer(q, yuv_cl, CL_TRUE, |
||||
CL_MAP_WRITE, 0, frame.getImage().size(), |
||||
0, NULL, &map_event, &err); |
||||
assert(err == 0); |
||||
clWaitForEvents(1, &map_event); |
||||
clReleaseEvent(map_event); |
||||
memcpy(yuv_buf, frame.getImage().begin(), frame.getImage().size()); |
||||
|
||||
clEnqueueUnmapMemObject(q, yuv_cl, yuv_buf, 0, NULL, &map_event); |
||||
clWaitForEvents(1, &map_event); |
||||
clReleaseEvent(map_event); |
||||
tbuffer_dispatch(tb, buf_idx); |
||||
delete msg; |
||||
|
||||
} |
||||
delete recorder_sock; |
||||
delete context; |
||||
} |
||||
|
||||
} // namespace
|
||||
|
||||
CameraInfo cameras_supported[CAMERA_ID_MAX] = { |
||||
[CAMERA_ID_IMX298] = { |
||||
.frame_width = FRAME_WIDTH, |
||||
.frame_height = FRAME_HEIGHT, |
||||
.frame_stride = FRAME_WIDTH*3, |
||||
.bayer = false, |
||||
.bayer_flip = false, |
||||
}, |
||||
[CAMERA_ID_OV8865] = { |
||||
.frame_width = 1632, |
||||
.frame_height = 1224, |
||||
.frame_stride = 2040, // seems right
|
||||
.bayer = false, |
||||
.bayer_flip = 3, |
||||
.hdr = false |
||||
}, |
||||
}; |
||||
|
||||
void cameras_init(DualCameraState *s) { |
||||
memset(s, 0, sizeof(*s)); |
||||
|
||||
camera_init(&s->rear, CAMERA_ID_IMX298, 20); |
||||
s->rear.transform = (mat3){{ |
||||
1.0, 0.0, 0.0, |
||||
0.0, 1.0, 0.0, |
||||
0.0, 0.0, 1.0, |
||||
}}; |
||||
|
||||
camera_init(&s->front, CAMERA_ID_OV8865, 10); |
||||
s->front.transform = (mat3){{ |
||||
1.0, 0.0, 0.0, |
||||
0.0, 1.0, 0.0, |
||||
0.0, 0.0, 1.0, |
||||
}}; |
||||
} |
||||
|
||||
void camera_autoexposure(CameraState *s, float grey_frac) {} |
||||
|
||||
void cameras_open(DualCameraState *s, VisionBuf *camera_bufs_rear, |
||||
VisionBuf *camera_bufs_focus, VisionBuf *camera_bufs_stats, |
||||
VisionBuf *camera_bufs_front) { |
||||
assert(camera_bufs_rear); |
||||
assert(camera_bufs_front); |
||||
int err; |
||||
|
||||
// LOG("*** open front ***");
|
||||
camera_open(&s->front, camera_bufs_front, false); |
||||
|
||||
// LOG("*** open rear ***");
|
||||
camera_open(&s->rear, camera_bufs_rear, true); |
||||
} |
||||
|
||||
void cameras_close(DualCameraState *s) { |
||||
camera_close(&s->rear); |
||||
} |
||||
|
||||
void cameras_run(DualCameraState *s) { |
||||
set_thread_name("frame_streaming"); |
||||
run_frame_stream(s); |
||||
cameras_close(s); |
||||
} |
||||
@ -0,0 +1,58 @@ |
||||
#ifndef CAMERA_FRAME_STREAM_H |
||||
#define CAMERA_FRAME_STREAM_H |
||||
|
||||
#include <stdbool.h> |
||||
|
||||
#ifdef __APPLE__ |
||||
#include <OpenCL/cl.h> |
||||
#else |
||||
#include <CL/cl.h> |
||||
#endif |
||||
|
||||
#include "common/mat.h" |
||||
|
||||
#include "buffering.h" |
||||
#include "common/visionbuf.h" |
||||
#include "camera_common.h" |
||||
|
||||
#define FRAME_BUF_COUNT 16 |
||||
|
||||
#ifdef __cplusplus |
||||
extern "C" { |
||||
#endif |
||||
|
||||
typedef struct CameraState { |
||||
int camera_id; |
||||
CameraInfo ci; |
||||
int frame_size; |
||||
|
||||
VisionBuf *camera_bufs; |
||||
FrameMetadata camera_bufs_metadata[FRAME_BUF_COUNT]; |
||||
TBuffer camera_tb; |
||||
|
||||
int fps; |
||||
float digital_gain; |
||||
|
||||
float cur_gain_frac; |
||||
|
||||
mat3 transform; |
||||
} CameraState; |
||||
|
||||
|
||||
typedef struct DualCameraState { |
||||
int ispif_fd; |
||||
|
||||
CameraState rear; |
||||
CameraState front; |
||||
} DualCameraState; |
||||
|
||||
void cameras_init(DualCameraState *s); |
||||
void cameras_open(DualCameraState *s, VisionBuf *camera_bufs_rear, VisionBuf *camera_bufs_focus, VisionBuf *camera_bufs_stats, VisionBuf *camera_bufs_front); |
||||
void cameras_run(DualCameraState *s); |
||||
void cameras_close(DualCameraState *s); |
||||
void camera_autoexposure(CameraState *s, float grey_frac); |
||||
#ifdef __cplusplus |
||||
} // extern "C"
|
||||
#endif |
||||
|
||||
#endif |
||||
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,131 @@ |
||||
#ifndef CAMERA_H |
||||
#define CAMERA_H |
||||
|
||||
#include <stdint.h> |
||||
#include <stdbool.h> |
||||
#include <pthread.h> |
||||
|
||||
#include "msmb_isp.h" |
||||
#include "msmb_ispif.h" |
||||
#include "msmb_camera.h" |
||||
#include "msm_cam_sensor.h" |
||||
|
||||
#include "common/mat.h" |
||||
#include "common/visionbuf.h" |
||||
#include "common/buffering.h" |
||||
|
||||
#include "camera_common.h" |
||||
|
||||
#define FRAME_BUF_COUNT 4 |
||||
#define METADATA_BUF_COUNT 4 |
||||
|
||||
#define DEVICE_OP3 0 |
||||
#define DEVICE_OP3T 1 |
||||
#define DEVICE_LP3 2 |
||||
|
||||
#define NUM_FOCUS 8 |
||||
|
||||
#ifdef __cplusplus |
||||
extern "C" { |
||||
#endif |
||||
|
||||
typedef struct CameraState CameraState; |
||||
|
||||
typedef int (*camera_apply_exposure_func)(CameraState *s, int gain, int integ_lines, int frame_length); |
||||
|
||||
typedef struct StreamState { |
||||
struct msm_isp_buf_request buf_request; |
||||
struct msm_vfe_axi_stream_request_cmd stream_req; |
||||
struct msm_isp_qbuf_info qbuf_info[FRAME_BUF_COUNT]; |
||||
VisionBuf *bufs; |
||||
} StreamState; |
||||
|
||||
typedef struct CameraState { |
||||
int camera_num; |
||||
int camera_id; |
||||
CameraInfo ci; |
||||
int frame_size; |
||||
|
||||
int device; |
||||
|
||||
void* ops_sock; |
||||
|
||||
uint32_t pixel_clock; |
||||
uint32_t line_length_pclk; |
||||
unsigned int max_gain; |
||||
|
||||
int csid_fd; |
||||
int csiphy_fd; |
||||
int sensor_fd; |
||||
int isp_fd; |
||||
int eeprom_fd; |
||||
// rear only
|
||||
int ois_fd, actuator_fd; |
||||
uint16_t infinity_dac; |
||||
|
||||
struct msm_vfe_axi_stream_cfg_cmd stream_cfg; |
||||
|
||||
size_t eeprom_size; |
||||
uint8_t *eeprom; |
||||
|
||||
// uint32_t camera_bufs_ids[FRAME_BUF_COUNT];
|
||||
FrameMetadata camera_bufs_metadata[FRAME_BUF_COUNT]; |
||||
TBuffer camera_tb; |
||||
|
||||
pthread_mutex_t frame_info_lock; |
||||
FrameMetadata frame_metadata[METADATA_BUF_COUNT]; |
||||
int frame_metadata_idx; |
||||
float cur_exposure_frac; |
||||
float cur_gain_frac; |
||||
int cur_gain; |
||||
int cur_frame_length; |
||||
int cur_integ_lines; |
||||
|
||||
float digital_gain; |
||||
|
||||
StreamState ss[3]; |
||||
|
||||
uint64_t last_t; |
||||
|
||||
camera_apply_exposure_func apply_exposure; |
||||
|
||||
int16_t focus[NUM_FOCUS]; |
||||
uint8_t confidence[NUM_FOCUS]; |
||||
|
||||
float focus_err; |
||||
|
||||
uint16_t cur_step_pos; |
||||
uint16_t cur_lens_pos; |
||||
uint64_t last_sag_ts; |
||||
float last_sag_acc_z; |
||||
float lens_true_pos; |
||||
|
||||
int fps; |
||||
|
||||
mat3 transform; |
||||
} CameraState; |
||||
|
||||
|
||||
typedef struct DualCameraState { |
||||
int device; |
||||
|
||||
int ispif_fd; |
||||
|
||||
CameraState rear; |
||||
CameraState front; |
||||
} DualCameraState; |
||||
|
||||
void cameras_init(DualCameraState *s); |
||||
void cameras_open(DualCameraState *s, VisionBuf *camera_bufs_rear, VisionBuf *camera_bufs_focus, VisionBuf *camera_bufs_stats, VisionBuf *camera_bufs_front); |
||||
void cameras_run(DualCameraState *s); |
||||
void cameras_close(DualCameraState *s); |
||||
|
||||
void camera_autoexposure(CameraState *s, float grey_frac); |
||||
void actuator_move(CameraState *s, uint16_t target); |
||||
int sensor_write_regs(CameraState *s, struct msm_camera_i2c_reg_array* arr, size_t size, int data_type); |
||||
|
||||
#ifdef __cplusplus |
||||
} // extern "C"
|
||||
#endif |
||||
|
||||
#endif |
||||
@ -0,0 +1,130 @@ |
||||
const __constant float3 color_correction[3] = { |
||||
// Matrix from WBraw -> sRGBD65 (normalized) |
||||
(float3)( 1.62393627, -0.2092988, 0.00119886), |
||||
(float3)(-0.45734315, 1.5534676, -0.59296798), |
||||
(float3)(-0.16659312, -0.3441688, 1.59176912), |
||||
}; |
||||
|
||||
float3 color_correct(float3 x) { |
||||
float3 ret = (0,0,0); |
||||
|
||||
// white balance of daylight |
||||
x /= (float3)(0.4609375, 1.0, 0.546875); |
||||
x = max(0.0, min(1.0, x)); |
||||
|
||||
// fix up the colors |
||||
ret += x.x * color_correction[0]; |
||||
ret += x.y * color_correction[1]; |
||||
ret += x.z * color_correction[2]; |
||||
return ret; |
||||
} |
||||
|
||||
float3 srgb_gamma(float3 p) { |
||||
// go all out and add an sRGB gamma curve |
||||
const float3 ph = (1.0f + 0.055f)*pow(p, 1/2.4f) - 0.055f; |
||||
const float3 pl = p*12.92f; |
||||
return select(ph, pl, islessequal(p, 0.0031308f)); |
||||
} |
||||
|
||||
__constant int dpcm_lookup[512] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 0, -1, -2, -3, -4, -5, -6, -7, -8, -9, -10, -11, -12, -13, -14, -15, -16, -17, -18, -19, -20, -21, -22, -23, -24, -25, -26, -27, -28, -29, -30, -31, 935, 951, 967, 983, 999, 1015, 1031, 1047, 1063, 1079, 1095, 1111, 1127, 1143, 1159, 1175, 1191, 1207, 1223, 1239, 1255, 1271, 1287, 1303, 1319, 1335, 1351, 1367, 1383, 1399, 1415, 1431, -935, -951, -967, -983, -999, -1015, -1031, -1047, -1063, -1079, -1095, -1111, -1127, -1143, -1159, -1175, -1191, -1207, -1223, -1239, -1255, -1271, -1287, -1303, -1319, -1335, -1351, -1367, -1383, -1399, -1415, -1431, 419, 427, 435, 443, 451, 459, 467, 475, 483, 491, 499, 507, 515, 523, 531, 539, 547, 555, 563, 571, 579, 587, 595, 603, 611, 619, 627, 635, 643, 651, 659, 667, 675, 683, 691, 699, 707, 715, 723, 731, 739, 747, 755, 763, 771, 779, 787, 795, 803, 811, 819, 827, 835, 843, 851, 859, 867, 875, 883, 891, 899, 907, 915, 923, -419, -427, -435, -443, -451, -459, -467, -475, -483, -491, -499, -507, -515, -523, -531, -539, -547, -555, -563, -571, -579, -587, -595, -603, -611, -619, -627, -635, -643, -651, -659, -667, -675, -683, -691, -699, -707, -715, -723, -731, -739, -747, -755, -763, -771, -779, -787, -795, -803, -811, -819, -827, -835, -843, -851, -859, -867, -875, -883, -891, -899, -907, -915, -923, 161, 165, 169, 173, 177, 181, 185, 189, 193, 197, 201, 205, 209, 213, 217, 221, 225, 229, 233, 237, 241, 245, 249, 253, 257, 261, 265, 269, 273, 277, 281, 285, 289, 293, 297, 301, 305, 309, 313, 317, 321, 325, 329, 333, 337, 341, 345, 349, 353, 357, 361, 365, 369, 373, 377, 381, 385, 389, 393, 397, 401, 405, 409, 413, -161, -165, -169, -173, -177, -181, -185, -189, -193, -197, -201, -205, -209, -213, -217, -221, -225, -229, -233, -237, -241, -245, -249, -253, -257, -261, -265, -269, -273, -277, -281, -285, -289, -293, -297, -301, -305, -309, -313, -317, -321, -325, -329, -333, -337, -341, -345, -349, -353, -357, -361, -365, -369, -373, -377, -381, -385, -389, -393, -397, -401, -405, -409, -413, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 64, 66, 68, 70, 72, 74, 76, 78, 80, 82, 84, 86, 88, 90, 92, 94, 96, 98, 100, 102, 104, 106, 108, 110, 112, 114, 116, 118, 120, 122, 124, 126, 128, 130, 132, 134, 136, 138, 140, 142, 144, 146, 148, 150, 152, 154, 156, 158, -32, -34, -36, -38, -40, -42, -44, -46, -48, -50, -52, -54, -56, -58, -60, -62, -64, -66, -68, -70, -72, -74, -76, -78, -80, -82, -84, -86, -88, -90, -92, -94, -96, -98, -100, -102, -104, -106, -108, -110, -112, -114, -116, -118, -120, -122, -124, -126, -128, -130, -132, -134, -136, -138, -140, -142, -144, -146, -148, -150, -152, -154, -156, -158}; |
||||
|
||||
inline uint4 decompress(uint4 p, uint4 pl) { |
||||
uint4 r1 = (pl + (uint4)(dpcm_lookup[p.s0], dpcm_lookup[p.s1], dpcm_lookup[p.s2], dpcm_lookup[p.s3])); |
||||
uint4 r2 = ((p-0x200)<<5) | 0xF; |
||||
r2 += select((uint4)(0,0,0,0), (uint4)(1,1,1,1), r2 <= pl); |
||||
return select(r2, r1, p < 0x200); |
||||
} |
||||
|
||||
__kernel void debayer10(__global uchar const * const in, |
||||
__global uchar * out, float digital_gain) |
||||
{ |
||||
const int oy = get_global_id(0); |
||||
if (oy >= RGB_HEIGHT) return; |
||||
const int iy = oy * 2; |
||||
|
||||
uint4 pint_last; |
||||
for (int ox = 0; ox < RGB_WIDTH; ox += 2) { |
||||
const int ix = (ox/2) * 5; |
||||
|
||||
// TODO: why doesn't this work for the frontview |
||||
/*const uchar8 v1 = vload8(0, &in[iy * FRAME_STRIDE + ix]); |
||||
const uchar ex1 = v1.s4; |
||||
const uchar8 v2 = vload8(0, &in[(iy+1) * FRAME_STRIDE + ix]); |
||||
const uchar ex2 = v2.s4;*/ |
||||
|
||||
const uchar4 v1 = vload4(0, &in[iy * FRAME_STRIDE + ix]); |
||||
const uchar ex1 = in[iy * FRAME_STRIDE + ix + 4]; |
||||
const uchar4 v2 = vload4(0, &in[(iy+1) * FRAME_STRIDE + ix]); |
||||
const uchar ex2 = in[(iy+1) * FRAME_STRIDE + ix + 4]; |
||||
|
||||
uint4 pinta[2]; |
||||
pinta[0] = (uint4)( |
||||
(((uint)v1.s0 << 2) + ( (ex1 >> 0) & 3)), |
||||
(((uint)v1.s1 << 2) + ( (ex1 >> 2) & 3)), |
||||
(((uint)v2.s0 << 2) + ( (ex2 >> 0) & 3)), |
||||
(((uint)v2.s1 << 2) + ( (ex2 >> 2) & 3))); |
||||
pinta[1] = (uint4)( |
||||
(((uint)v1.s2 << 2) + ( (ex1 >> 4) & 3)), |
||||
(((uint)v1.s3 << 2) + ( (ex1 >> 6) & 3)), |
||||
(((uint)v2.s2 << 2) + ( (ex2 >> 4) & 3)), |
||||
(((uint)v2.s3 << 2) + ( (ex2 >> 6) & 3))); |
||||
|
||||
#pragma unroll |
||||
for (uint px = 0; px < 2; px++) { |
||||
uint4 pint = pinta[px]; |
||||
|
||||
#if HDR |
||||
// decompress HDR |
||||
pint = (ox == 0 && px == 0) ? ((pint<<4) | 8) : decompress(pint, pint_last); |
||||
pint_last = pint; |
||||
#endif |
||||
|
||||
float4 p = convert_float4(pint); |
||||
|
||||
// 64 is the black level of the sensor, remove |
||||
// (changed to 56 for HDR) |
||||
const float black_level = 56.0f; |
||||
p = (p - black_level); |
||||
|
||||
// correct vignetting (no pow function?) |
||||
// see https://www.eecis.udel.edu/~jye/lab_research/09/JiUp.pdf the A (4th order) |
||||
const float r = ((oy - RGB_HEIGHT/2)*(oy - RGB_HEIGHT/2) + (ox - RGB_WIDTH/2)*(ox - RGB_WIDTH/2)); |
||||
const float fake_f = 700.0f; // should be 910, but this fits... |
||||
const float lil_a = (1.0f + r/(fake_f*fake_f)); |
||||
p = p * lil_a * lil_a; |
||||
|
||||
// rescale to 1.0 |
||||
#if HDR |
||||
p /= (16384.0f-black_level); |
||||
#else |
||||
p /= (1024.0f-black_level); |
||||
#endif |
||||
|
||||
// digital gain |
||||
p *= digital_gain; |
||||
|
||||
// use both green channels |
||||
#if BAYER_FLIP == 3 |
||||
float3 c1 = (float3)(p.s3, (p.s1+p.s2)/2.0f, p.s0); |
||||
#elif BAYER_FLIP == 2 |
||||
float3 c1 = (float3)(p.s2, (p.s0+p.s3)/2.0f, p.s1); |
||||
#elif BAYER_FLIP == 1 |
||||
float3 c1 = (float3)(p.s1, (p.s0+p.s3)/2.0f, p.s2); |
||||
#elif BAYER_FLIP == 0 |
||||
float3 c1 = (float3)(p.s0, (p.s1+p.s2)/2.0f, p.s3); |
||||
#endif |
||||
|
||||
// color correction |
||||
c1 = color_correct(c1); |
||||
|
||||
#if HDR |
||||
// srgb gamma isn't right for YUV, so it's disabled for now |
||||
c1 = srgb_gamma(c1); |
||||
#endif |
||||
|
||||
// output BGR |
||||
const int ooff = oy * RGB_STRIDE/3 + ox; |
||||
vstore3(convert_uchar3_sat(c1.zyx * 255.0f), ooff+px, out); |
||||
} |
||||
} |
||||
} |
||||
File diff suppressed because one or more lines are too long
@ -0,0 +1,829 @@ |
||||
#ifndef __LINUX_MSM_CAM_SENSOR_H |
||||
#define __LINUX_MSM_CAM_SENSOR_H |
||||
|
||||
#ifdef MSM_CAMERA_BIONIC |
||||
#include <sys/types.h> |
||||
#endif |
||||
|
||||
//#include <linux/v4l2-mediabus.h>
|
||||
#include "msm_camsensor_sdk.h" |
||||
|
||||
#include <linux/types.h> |
||||
#include <linux/i2c.h> |
||||
#ifdef CONFIG_COMPAT |
||||
#include <linux/compat.h> |
||||
#endif |
||||
|
||||
#define I2C_SEQ_REG_SETTING_MAX 5 |
||||
|
||||
#define MSM_SENSOR_MCLK_8HZ 8000000 |
||||
#define MSM_SENSOR_MCLK_16HZ 16000000 |
||||
#define MSM_SENSOR_MCLK_24HZ 24000000 |
||||
|
||||
#define MAX_SENSOR_NAME 32 |
||||
#define MAX_ACTUATOR_AF_TOTAL_STEPS 1024 |
||||
|
||||
#define MAX_OIS_MOD_NAME_SIZE 32 |
||||
#define MAX_OIS_NAME_SIZE 32 |
||||
#define MAX_OIS_REG_SETTINGS 800 |
||||
|
||||
#define MOVE_NEAR 0 |
||||
#define MOVE_FAR 1 |
||||
|
||||
#define MSM_ACTUATOR_MOVE_SIGNED_FAR -1 |
||||
#define MSM_ACTUATOR_MOVE_SIGNED_NEAR 1 |
||||
|
||||
#define MAX_ACTUATOR_REGION 5 |
||||
|
||||
#define MAX_EEPROM_NAME 32 |
||||
|
||||
#define MAX_AF_ITERATIONS 3 |
||||
#define MAX_NUMBER_OF_STEPS 47 |
||||
#define MAX_REGULATOR 5 |
||||
|
||||
#define MSM_V4L2_PIX_FMT_META v4l2_fourcc('M', 'E', 'T', 'A') /* META */ |
||||
#define MSM_V4L2_PIX_FMT_SBGGR14 v4l2_fourcc('B', 'G', '1', '4') |
||||
/* 14 BGBG.. GRGR.. */ |
||||
#define MSM_V4L2_PIX_FMT_SGBRG14 v4l2_fourcc('G', 'B', '1', '4') |
||||
/* 14 GBGB.. RGRG.. */ |
||||
#define MSM_V4L2_PIX_FMT_SGRBG14 v4l2_fourcc('B', 'A', '1', '4') |
||||
/* 14 GRGR.. BGBG.. */ |
||||
#define MSM_V4L2_PIX_FMT_SRGGB14 v4l2_fourcc('R', 'G', '1', '4') |
||||
/* 14 RGRG.. GBGB.. */ |
||||
|
||||
enum flash_type { |
||||
LED_FLASH = 1, |
||||
STROBE_FLASH, |
||||
GPIO_FLASH |
||||
}; |
||||
|
||||
enum msm_sensor_resolution_t { |
||||
MSM_SENSOR_RES_FULL, |
||||
MSM_SENSOR_RES_QTR, |
||||
MSM_SENSOR_RES_2, |
||||
MSM_SENSOR_RES_3, |
||||
MSM_SENSOR_RES_4, |
||||
MSM_SENSOR_RES_5, |
||||
MSM_SENSOR_RES_6, |
||||
MSM_SENSOR_RES_7, |
||||
MSM_SENSOR_INVALID_RES, |
||||
}; |
||||
|
||||
enum msm_camera_stream_type_t { |
||||
MSM_CAMERA_STREAM_PREVIEW, |
||||
MSM_CAMERA_STREAM_SNAPSHOT, |
||||
MSM_CAMERA_STREAM_VIDEO, |
||||
MSM_CAMERA_STREAM_INVALID, |
||||
}; |
||||
|
||||
enum sensor_sub_module_t { |
||||
SUB_MODULE_SENSOR, |
||||
SUB_MODULE_CHROMATIX, |
||||
SUB_MODULE_ACTUATOR, |
||||
SUB_MODULE_EEPROM, |
||||
SUB_MODULE_LED_FLASH, |
||||
SUB_MODULE_STROBE_FLASH, |
||||
SUB_MODULE_CSID, |
||||
SUB_MODULE_CSID_3D, |
||||
SUB_MODULE_CSIPHY, |
||||
SUB_MODULE_CSIPHY_3D, |
||||
SUB_MODULE_OIS, |
||||
SUB_MODULE_EXT, |
||||
SUB_MODULE_MAX, |
||||
}; |
||||
|
||||
enum { |
||||
MSM_CAMERA_EFFECT_MODE_OFF, |
||||
MSM_CAMERA_EFFECT_MODE_MONO, |
||||
MSM_CAMERA_EFFECT_MODE_NEGATIVE, |
||||
MSM_CAMERA_EFFECT_MODE_SOLARIZE, |
||||
MSM_CAMERA_EFFECT_MODE_SEPIA, |
||||
MSM_CAMERA_EFFECT_MODE_POSTERIZE, |
||||
MSM_CAMERA_EFFECT_MODE_WHITEBOARD, |
||||
MSM_CAMERA_EFFECT_MODE_BLACKBOARD, |
||||
MSM_CAMERA_EFFECT_MODE_AQUA, |
||||
MSM_CAMERA_EFFECT_MODE_EMBOSS, |
||||
MSM_CAMERA_EFFECT_MODE_SKETCH, |
||||
MSM_CAMERA_EFFECT_MODE_NEON, |
||||
MSM_CAMERA_EFFECT_MODE_MAX |
||||
}; |
||||
|
||||
enum { |
||||
MSM_CAMERA_WB_MODE_AUTO, |
||||
MSM_CAMERA_WB_MODE_CUSTOM, |
||||
MSM_CAMERA_WB_MODE_INCANDESCENT, |
||||
MSM_CAMERA_WB_MODE_FLUORESCENT, |
||||
MSM_CAMERA_WB_MODE_WARM_FLUORESCENT, |
||||
MSM_CAMERA_WB_MODE_DAYLIGHT, |
||||
MSM_CAMERA_WB_MODE_CLOUDY_DAYLIGHT, |
||||
MSM_CAMERA_WB_MODE_TWILIGHT, |
||||
MSM_CAMERA_WB_MODE_SHADE, |
||||
MSM_CAMERA_WB_MODE_OFF, |
||||
MSM_CAMERA_WB_MODE_MAX |
||||
}; |
||||
|
||||
enum { |
||||
MSM_CAMERA_SCENE_MODE_OFF, |
||||
MSM_CAMERA_SCENE_MODE_AUTO, |
||||
MSM_CAMERA_SCENE_MODE_LANDSCAPE, |
||||
MSM_CAMERA_SCENE_MODE_SNOW, |
||||
MSM_CAMERA_SCENE_MODE_BEACH, |
||||
MSM_CAMERA_SCENE_MODE_SUNSET, |
||||
MSM_CAMERA_SCENE_MODE_NIGHT, |
||||
MSM_CAMERA_SCENE_MODE_PORTRAIT, |
||||
MSM_CAMERA_SCENE_MODE_BACKLIGHT, |
||||
MSM_CAMERA_SCENE_MODE_SPORTS, |
||||
MSM_CAMERA_SCENE_MODE_ANTISHAKE, |
||||
MSM_CAMERA_SCENE_MODE_FLOWERS, |
||||
MSM_CAMERA_SCENE_MODE_CANDLELIGHT, |
||||
MSM_CAMERA_SCENE_MODE_FIREWORKS, |
||||
MSM_CAMERA_SCENE_MODE_PARTY, |
||||
MSM_CAMERA_SCENE_MODE_NIGHT_PORTRAIT, |
||||
MSM_CAMERA_SCENE_MODE_THEATRE, |
||||
MSM_CAMERA_SCENE_MODE_ACTION, |
||||
MSM_CAMERA_SCENE_MODE_AR, |
||||
MSM_CAMERA_SCENE_MODE_FACE_PRIORITY, |
||||
MSM_CAMERA_SCENE_MODE_BARCODE, |
||||
MSM_CAMERA_SCENE_MODE_HDR, |
||||
MSM_CAMERA_SCENE_MODE_MAX |
||||
}; |
||||
|
||||
enum csid_cfg_type_t { |
||||
CSID_INIT, |
||||
CSID_CFG, |
||||
CSID_TESTMODE_CFG, |
||||
CSID_RELEASE, |
||||
}; |
||||
|
||||
enum csiphy_cfg_type_t { |
||||
CSIPHY_INIT, |
||||
CSIPHY_CFG, |
||||
CSIPHY_RELEASE, |
||||
}; |
||||
|
||||
enum camera_vreg_type { |
||||
VREG_TYPE_DEFAULT, |
||||
VREG_TYPE_CUSTOM, |
||||
}; |
||||
|
||||
enum sensor_af_t { |
||||
SENSOR_AF_FOCUSSED, |
||||
SENSOR_AF_NOT_FOCUSSED, |
||||
}; |
||||
|
||||
enum cci_i2c_master_t { |
||||
MASTER_0, |
||||
MASTER_1, |
||||
MASTER_MAX, |
||||
}; |
||||
|
||||
struct msm_camera_i2c_array_write_config { |
||||
struct msm_camera_i2c_reg_setting conf_array; |
||||
uint16_t slave_addr; |
||||
}; |
||||
|
||||
struct msm_camera_i2c_read_config { |
||||
uint16_t slave_addr; |
||||
uint16_t reg_addr; |
||||
enum msm_camera_i2c_reg_addr_type addr_type; |
||||
enum msm_camera_i2c_data_type data_type; |
||||
uint16_t data; |
||||
}; |
||||
|
||||
struct msm_camera_csi2_params { |
||||
struct msm_camera_csid_params csid_params; |
||||
struct msm_camera_csiphy_params csiphy_params; |
||||
uint8_t csi_clk_scale_enable; |
||||
}; |
||||
|
||||
struct msm_camera_csi_lane_params { |
||||
uint16_t csi_lane_assign; |
||||
uint16_t csi_lane_mask; |
||||
}; |
||||
|
||||
struct csi_lane_params_t { |
||||
uint16_t csi_lane_assign; |
||||
uint8_t csi_lane_mask; |
||||
uint8_t csi_if; |
||||
int8_t csid_core[2]; |
||||
uint8_t csi_phy_sel; |
||||
}; |
||||
|
||||
struct msm_sensor_info_t { |
||||
char sensor_name[MAX_SENSOR_NAME]; |
||||
uint32_t session_id; |
||||
int32_t subdev_id[SUB_MODULE_MAX]; |
||||
int32_t subdev_intf[SUB_MODULE_MAX]; |
||||
uint8_t is_mount_angle_valid; |
||||
uint32_t sensor_mount_angle; |
||||
int modes_supported; |
||||
enum camb_position_t position; |
||||
}; |
||||
|
||||
struct camera_vreg_t { |
||||
const char *reg_name; |
||||
int min_voltage; |
||||
int max_voltage; |
||||
int op_mode; |
||||
uint32_t delay; |
||||
const char *custom_vreg_name; |
||||
enum camera_vreg_type type; |
||||
}; |
||||
|
||||
struct sensorb_cfg_data { |
||||
int cfgtype; |
||||
union { |
||||
struct msm_sensor_info_t sensor_info; |
||||
struct msm_sensor_init_params sensor_init_params; |
||||
void *setting; |
||||
struct msm_sensor_i2c_sync_params sensor_i2c_sync_params; |
||||
} cfg; |
||||
}; |
||||
|
||||
struct csid_cfg_data { |
||||
enum csid_cfg_type_t cfgtype; |
||||
union { |
||||
uint32_t csid_version; |
||||
struct msm_camera_csid_params *csid_params; |
||||
struct msm_camera_csid_testmode_parms *csid_testmode_params; |
||||
} cfg; |
||||
}; |
||||
|
||||
struct csiphy_cfg_data { |
||||
enum csiphy_cfg_type_t cfgtype; |
||||
union { |
||||
struct msm_camera_csiphy_params *csiphy_params; |
||||
struct msm_camera_csi_lane_params *csi_lane_params; |
||||
} cfg; |
||||
}; |
||||
|
||||
enum eeprom_cfg_type_t { |
||||
CFG_EEPROM_GET_INFO, |
||||
CFG_EEPROM_GET_CAL_DATA, |
||||
CFG_EEPROM_READ_CAL_DATA, |
||||
CFG_EEPROM_WRITE_DATA, |
||||
CFG_EEPROM_GET_MM_INFO, |
||||
CFG_EEPROM_INIT, |
||||
}; |
||||
|
||||
struct eeprom_get_t { |
||||
uint32_t num_bytes; |
||||
}; |
||||
|
||||
struct eeprom_read_t { |
||||
uint8_t *dbuffer; |
||||
uint32_t num_bytes; |
||||
}; |
||||
|
||||
struct eeprom_write_t { |
||||
uint8_t *dbuffer; |
||||
uint32_t num_bytes; |
||||
}; |
||||
|
||||
struct eeprom_get_cmm_t { |
||||
uint32_t cmm_support; |
||||
uint32_t cmm_compression; |
||||
uint32_t cmm_size; |
||||
}; |
||||
|
||||
struct msm_eeprom_info_t { |
||||
struct msm_sensor_power_setting_array *power_setting_array; |
||||
enum i2c_freq_mode_t i2c_freq_mode; |
||||
struct msm_eeprom_memory_map_array *mem_map_array; |
||||
}; |
||||
|
||||
struct msm_eeprom_cfg_data { |
||||
enum eeprom_cfg_type_t cfgtype; |
||||
uint8_t is_supported; |
||||
union { |
||||
char eeprom_name[MAX_SENSOR_NAME]; |
||||
struct eeprom_get_t get_data; |
||||
struct eeprom_read_t read_data; |
||||
struct eeprom_write_t write_data; |
||||
struct eeprom_get_cmm_t get_cmm_data; |
||||
struct msm_eeprom_info_t eeprom_info; |
||||
} cfg; |
||||
}; |
||||
|
||||
#ifdef CONFIG_COMPAT |
||||
struct msm_sensor_power_setting32 { |
||||
enum msm_sensor_power_seq_type_t seq_type; |
||||
uint16_t seq_val; |
||||
compat_uint_t config_val; |
||||
uint16_t delay; |
||||
compat_uptr_t data[10]; |
||||
}; |
||||
|
||||
struct msm_sensor_power_setting_array32 { |
||||
struct msm_sensor_power_setting32 power_setting_a[MAX_POWER_CONFIG]; |
||||
compat_uptr_t power_setting; |
||||
uint16_t size; |
||||
struct msm_sensor_power_setting32 |
||||
power_down_setting_a[MAX_POWER_CONFIG]; |
||||
compat_uptr_t power_down_setting; |
||||
uint16_t size_down; |
||||
}; |
||||
|
||||
struct msm_camera_sensor_slave_info32 { |
||||
char sensor_name[32]; |
||||
char eeprom_name[32]; |
||||
char actuator_name[32]; |
||||
char ois_name[32]; |
||||
char flash_name[32]; |
||||
enum msm_sensor_camera_id_t camera_id; |
||||
uint16_t slave_addr; |
||||
enum i2c_freq_mode_t i2c_freq_mode; |
||||
enum msm_camera_i2c_reg_addr_type addr_type; |
||||
struct msm_sensor_id_info_t sensor_id_info; |
||||
struct msm_sensor_power_setting_array32 power_setting_array; |
||||
uint8_t is_init_params_valid; |
||||
struct msm_sensor_init_params sensor_init_params; |
||||
enum msm_sensor_output_format_t output_format; |
||||
}; |
||||
|
||||
struct msm_camera_csid_lut_params32 { |
||||
uint8_t num_cid; |
||||
struct msm_camera_csid_vc_cfg vc_cfg_a[MAX_CID]; |
||||
compat_uptr_t vc_cfg[MAX_CID]; |
||||
}; |
||||
|
||||
struct msm_camera_csid_params32 { |
||||
uint8_t lane_cnt; |
||||
uint16_t lane_assign; |
||||
uint8_t phy_sel; |
||||
uint32_t csi_clk; |
||||
struct msm_camera_csid_lut_params32 lut_params; |
||||
uint8_t csi_3p_sel; |
||||
}; |
||||
|
||||
struct msm_camera_csi2_params32 { |
||||
struct msm_camera_csid_params32 csid_params; |
||||
struct msm_camera_csiphy_params csiphy_params; |
||||
uint8_t csi_clk_scale_enable; |
||||
}; |
||||
|
||||
struct csid_cfg_data32 { |
||||
enum csid_cfg_type_t cfgtype; |
||||
union { |
||||
uint32_t csid_version; |
||||
compat_uptr_t csid_params; |
||||
compat_uptr_t csid_testmode_params; |
||||
} cfg; |
||||
}; |
||||
|
||||
struct eeprom_read_t32 { |
||||
compat_uptr_t dbuffer; |
||||
uint32_t num_bytes; |
||||
}; |
||||
|
||||
struct eeprom_write_t32 { |
||||
compat_uptr_t dbuffer; |
||||
uint32_t num_bytes; |
||||
}; |
||||
|
||||
struct msm_eeprom_info_t32 { |
||||
compat_uptr_t power_setting_array; |
||||
enum i2c_freq_mode_t i2c_freq_mode; |
||||
compat_uptr_t mem_map_array; |
||||
}; |
||||
|
||||
struct msm_eeprom_cfg_data32 { |
||||
enum eeprom_cfg_type_t cfgtype; |
||||
uint8_t is_supported; |
||||
union { |
||||
char eeprom_name[MAX_SENSOR_NAME]; |
||||
struct eeprom_get_t get_data; |
||||
struct eeprom_read_t32 read_data; |
||||
struct eeprom_write_t32 write_data; |
||||
struct msm_eeprom_info_t32 eeprom_info; |
||||
} cfg; |
||||
}; |
||||
|
||||
struct msm_camera_i2c_seq_reg_setting32 { |
||||
compat_uptr_t reg_setting; |
||||
uint16_t size; |
||||
enum msm_camera_i2c_reg_addr_type addr_type; |
||||
uint16_t delay; |
||||
}; |
||||
#endif |
||||
|
||||
enum msm_sensor_cfg_type_t { |
||||
CFG_SET_SLAVE_INFO, |
||||
CFG_SLAVE_READ_I2C, |
||||
CFG_WRITE_I2C_ARRAY, |
||||
CFG_SLAVE_WRITE_I2C_ARRAY, |
||||
CFG_WRITE_I2C_SEQ_ARRAY, |
||||
CFG_POWER_UP, |
||||
CFG_POWER_DOWN, |
||||
CFG_SET_STOP_STREAM_SETTING, |
||||
CFG_GET_SENSOR_INFO, |
||||
CFG_GET_SENSOR_INIT_PARAMS, |
||||
CFG_SET_INIT_SETTING, |
||||
CFG_SET_RESOLUTION, |
||||
CFG_SET_STOP_STREAM, |
||||
CFG_SET_START_STREAM, |
||||
CFG_SET_SATURATION, |
||||
CFG_SET_CONTRAST, |
||||
CFG_SET_SHARPNESS, |
||||
CFG_SET_ISO, |
||||
CFG_SET_EXPOSURE_COMPENSATION, |
||||
CFG_SET_ANTIBANDING, |
||||
CFG_SET_BESTSHOT_MODE, |
||||
CFG_SET_EFFECT, |
||||
CFG_SET_WHITE_BALANCE, |
||||
CFG_SET_AUTOFOCUS, |
||||
CFG_CANCEL_AUTOFOCUS, |
||||
CFG_SET_STREAM_TYPE, |
||||
CFG_SET_I2C_SYNC_PARAM, |
||||
CFG_WRITE_I2C_ARRAY_ASYNC, |
||||
CFG_WRITE_I2C_ARRAY_SYNC, |
||||
CFG_WRITE_I2C_ARRAY_SYNC_BLOCK, |
||||
}; |
||||
|
||||
enum msm_actuator_cfg_type_t { |
||||
CFG_GET_ACTUATOR_INFO, |
||||
CFG_SET_ACTUATOR_INFO, |
||||
CFG_SET_DEFAULT_FOCUS, |
||||
CFG_MOVE_FOCUS, |
||||
CFG_SET_POSITION, |
||||
CFG_ACTUATOR_POWERDOWN, |
||||
CFG_ACTUATOR_POWERUP, |
||||
CFG_ACTUATOR_INIT, |
||||
}; |
||||
|
||||
enum msm_ois_cfg_type_t { |
||||
CFG_OIS_INIT, |
||||
CFG_OIS_POWERDOWN, |
||||
CFG_OIS_POWERUP, |
||||
CFG_OIS_CONTROL, |
||||
CFG_OIS_I2C_WRITE_SEQ_TABLE, |
||||
}; |
||||
|
||||
enum msm_ois_i2c_operation { |
||||
MSM_OIS_WRITE = 0, |
||||
MSM_OIS_POLL, |
||||
}; |
||||
|
||||
struct reg_settings_ois_t { |
||||
uint16_t reg_addr; |
||||
enum msm_camera_i2c_reg_addr_type addr_type; |
||||
uint32_t reg_data; |
||||
enum msm_camera_i2c_data_type data_type; |
||||
enum msm_ois_i2c_operation i2c_operation; |
||||
uint32_t delay; |
||||
#define OIS_REG_DATA_SEQ_MAX 128 |
||||
unsigned char reg_data_seq[OIS_REG_DATA_SEQ_MAX]; |
||||
uint32_t reg_data_seq_size; |
||||
}; |
||||
|
||||
struct msm_ois_params_t { |
||||
uint16_t data_size; |
||||
uint16_t setting_size; |
||||
uint32_t i2c_addr; |
||||
enum i2c_freq_mode_t i2c_freq_mode; |
||||
enum msm_camera_i2c_reg_addr_type i2c_addr_type; |
||||
enum msm_camera_i2c_data_type i2c_data_type; |
||||
struct reg_settings_ois_t *settings; |
||||
}; |
||||
|
||||
struct msm_ois_set_info_t { |
||||
struct msm_ois_params_t ois_params; |
||||
}; |
||||
|
||||
struct msm_actuator_move_params_t { |
||||
int8_t dir; |
||||
int8_t sign_dir; |
||||
int16_t dest_step_pos; |
||||
int32_t num_steps; |
||||
uint16_t curr_lens_pos; |
||||
struct damping_params_t *ringing_params; |
||||
}; |
||||
|
||||
struct msm_actuator_tuning_params_t { |
||||
int16_t initial_code; |
||||
uint16_t pwd_step; |
||||
uint16_t region_size; |
||||
uint32_t total_steps; |
||||
struct region_params_t *region_params; |
||||
}; |
||||
|
||||
struct park_lens_data_t { |
||||
uint32_t damping_step; |
||||
uint32_t damping_delay; |
||||
uint32_t hw_params; |
||||
uint32_t max_step; |
||||
}; |
||||
|
||||
struct msm_actuator_params_t { |
||||
enum actuator_type act_type; |
||||
uint8_t reg_tbl_size; |
||||
uint16_t data_size; |
||||
uint16_t init_setting_size; |
||||
uint32_t i2c_addr; |
||||
enum i2c_freq_mode_t i2c_freq_mode; |
||||
enum msm_actuator_addr_type i2c_addr_type; |
||||
enum msm_actuator_data_type i2c_data_type; |
||||
struct msm_actuator_reg_params_t *reg_tbl_params; |
||||
struct reg_settings_t *init_settings; |
||||
struct park_lens_data_t park_lens; |
||||
}; |
||||
|
||||
struct msm_actuator_set_info_t { |
||||
struct msm_actuator_params_t actuator_params; |
||||
struct msm_actuator_tuning_params_t af_tuning_params; |
||||
}; |
||||
|
||||
struct msm_actuator_get_info_t { |
||||
uint32_t focal_length_num; |
||||
uint32_t focal_length_den; |
||||
uint32_t f_number_num; |
||||
uint32_t f_number_den; |
||||
uint32_t f_pix_num; |
||||
uint32_t f_pix_den; |
||||
uint32_t total_f_dist_num; |
||||
uint32_t total_f_dist_den; |
||||
uint32_t hor_view_angle_num; |
||||
uint32_t hor_view_angle_den; |
||||
uint32_t ver_view_angle_num; |
||||
uint32_t ver_view_angle_den; |
||||
}; |
||||
|
||||
enum af_camera_name { |
||||
ACTUATOR_MAIN_CAM_0, |
||||
ACTUATOR_MAIN_CAM_1, |
||||
ACTUATOR_MAIN_CAM_2, |
||||
ACTUATOR_MAIN_CAM_3, |
||||
ACTUATOR_MAIN_CAM_4, |
||||
ACTUATOR_MAIN_CAM_5, |
||||
ACTUATOR_WEB_CAM_0, |
||||
ACTUATOR_WEB_CAM_1, |
||||
ACTUATOR_WEB_CAM_2, |
||||
}; |
||||
|
||||
struct msm_ois_cfg_data { |
||||
int cfgtype; |
||||
union { |
||||
struct msm_ois_set_info_t set_info; |
||||
struct msm_camera_i2c_seq_reg_setting *settings; |
||||
} cfg; |
||||
}; |
||||
|
||||
struct msm_actuator_set_position_t { |
||||
uint16_t number_of_steps; |
||||
uint32_t hw_params; |
||||
uint16_t pos[MAX_NUMBER_OF_STEPS]; |
||||
uint16_t delay[MAX_NUMBER_OF_STEPS]; |
||||
}; |
||||
|
||||
struct msm_actuator_cfg_data { |
||||
int cfgtype; |
||||
uint8_t is_af_supported; |
||||
union { |
||||
struct msm_actuator_move_params_t move; |
||||
struct msm_actuator_set_info_t set_info; |
||||
struct msm_actuator_get_info_t get_info; |
||||
struct msm_actuator_set_position_t setpos; |
||||
enum af_camera_name cam_name; |
||||
} cfg; |
||||
}; |
||||
|
||||
enum msm_camera_led_config_t { |
||||
MSM_CAMERA_LED_OFF, |
||||
MSM_CAMERA_LED_LOW, |
||||
MSM_CAMERA_LED_HIGH, |
||||
MSM_CAMERA_LED_INIT, |
||||
MSM_CAMERA_LED_RELEASE, |
||||
}; |
||||
|
||||
struct msm_camera_led_cfg_t { |
||||
enum msm_camera_led_config_t cfgtype; |
||||
int32_t torch_current[MAX_LED_TRIGGERS]; |
||||
int32_t flash_current[MAX_LED_TRIGGERS]; |
||||
int32_t flash_duration[MAX_LED_TRIGGERS]; |
||||
}; |
||||
|
||||
struct msm_flash_init_info_t { |
||||
enum msm_flash_driver_type flash_driver_type; |
||||
uint32_t slave_addr; |
||||
enum i2c_freq_mode_t i2c_freq_mode; |
||||
struct msm_sensor_power_setting_array *power_setting_array; |
||||
struct msm_camera_i2c_reg_setting_array *settings; |
||||
}; |
||||
|
||||
struct msm_flash_cfg_data_t { |
||||
enum msm_flash_cfg_type_t cfg_type; |
||||
int32_t flash_current[MAX_LED_TRIGGERS]; |
||||
int32_t flash_duration[MAX_LED_TRIGGERS]; |
||||
union { |
||||
struct msm_flash_init_info_t *flash_init_info; |
||||
struct msm_camera_i2c_reg_setting_array *settings; |
||||
} cfg; |
||||
}; |
||||
|
||||
/* sensor init structures and enums */ |
||||
enum msm_sensor_init_cfg_type_t { |
||||
CFG_SINIT_PROBE, |
||||
CFG_SINIT_PROBE_DONE, |
||||
CFG_SINIT_PROBE_WAIT_DONE, |
||||
}; |
||||
|
||||
struct sensor_init_cfg_data { |
||||
enum msm_sensor_init_cfg_type_t cfgtype; |
||||
struct msm_sensor_info_t probed_info; |
||||
char entity_name[MAX_SENSOR_NAME]; |
||||
union { |
||||
void *setting; |
||||
} cfg; |
||||
}; |
||||
|
||||
#define VIDIOC_MSM_SENSOR_CFG \ |
||||
_IOWR('V', BASE_VIDIOC_PRIVATE + 1, struct sensorb_cfg_data) |
||||
|
||||
#define VIDIOC_MSM_SENSOR_RELEASE \ |
||||
_IO('V', BASE_VIDIOC_PRIVATE + 2) |
||||
|
||||
#define VIDIOC_MSM_SENSOR_GET_SUBDEV_ID \ |
||||
_IOWR('V', BASE_VIDIOC_PRIVATE + 3, uint32_t) |
||||
|
||||
#define VIDIOC_MSM_CSIPHY_IO_CFG \ |
||||
_IOWR('V', BASE_VIDIOC_PRIVATE + 4, struct csiphy_cfg_data) |
||||
|
||||
#define VIDIOC_MSM_CSID_IO_CFG \ |
||||
_IOWR('V', BASE_VIDIOC_PRIVATE + 5, struct csid_cfg_data) |
||||
|
||||
#define VIDIOC_MSM_ACTUATOR_CFG \ |
||||
_IOWR('V', BASE_VIDIOC_PRIVATE + 6, struct msm_actuator_cfg_data) |
||||
|
||||
#define VIDIOC_MSM_FLASH_LED_DATA_CFG \ |
||||
_IOWR('V', BASE_VIDIOC_PRIVATE + 7, struct msm_camera_led_cfg_t) |
||||
|
||||
#define VIDIOC_MSM_EEPROM_CFG \ |
||||
_IOWR('V', BASE_VIDIOC_PRIVATE + 8, struct msm_eeprom_cfg_data) |
||||
|
||||
#define VIDIOC_MSM_SENSOR_GET_AF_STATUS \ |
||||
_IOWR('V', BASE_VIDIOC_PRIVATE + 9, uint32_t) |
||||
|
||||
#define VIDIOC_MSM_SENSOR_INIT_CFG \ |
||||
_IOWR('V', BASE_VIDIOC_PRIVATE + 10, struct sensor_init_cfg_data) |
||||
|
||||
#define VIDIOC_MSM_OIS_CFG \ |
||||
_IOWR('V', BASE_VIDIOC_PRIVATE + 11, struct msm_ois_cfg_data) |
||||
|
||||
#define VIDIOC_MSM_FLASH_CFG \ |
||||
_IOWR('V', BASE_VIDIOC_PRIVATE + 13, struct msm_flash_cfg_data_t) |
||||
|
||||
#ifdef CONFIG_COMPAT |
||||
struct msm_camera_i2c_reg_setting32 { |
||||
compat_uptr_t reg_setting; |
||||
uint16_t size; |
||||
enum msm_camera_i2c_reg_addr_type addr_type; |
||||
enum msm_camera_i2c_data_type data_type; |
||||
uint16_t delay; |
||||
}; |
||||
|
||||
struct msm_camera_i2c_array_write_config32 { |
||||
struct msm_camera_i2c_reg_setting32 conf_array; |
||||
uint16_t slave_addr; |
||||
}; |
||||
|
||||
struct msm_actuator_tuning_params_t32 { |
||||
int16_t initial_code; |
||||
uint16_t pwd_step; |
||||
uint16_t region_size; |
||||
uint32_t total_steps; |
||||
compat_uptr_t region_params; |
||||
}; |
||||
|
||||
struct msm_actuator_params_t32 { |
||||
enum actuator_type act_type; |
||||
uint8_t reg_tbl_size; |
||||
uint16_t data_size; |
||||
uint16_t init_setting_size; |
||||
uint32_t i2c_addr; |
||||
enum i2c_freq_mode_t i2c_freq_mode; |
||||
enum msm_actuator_addr_type i2c_addr_type; |
||||
enum msm_actuator_data_type i2c_data_type; |
||||
compat_uptr_t reg_tbl_params; |
||||
compat_uptr_t init_settings; |
||||
struct park_lens_data_t park_lens; |
||||
}; |
||||
|
||||
struct msm_actuator_set_info_t32 { |
||||
struct msm_actuator_params_t32 actuator_params; |
||||
struct msm_actuator_tuning_params_t32 af_tuning_params; |
||||
}; |
||||
|
||||
struct sensor_init_cfg_data32 { |
||||
enum msm_sensor_init_cfg_type_t cfgtype; |
||||
struct msm_sensor_info_t probed_info; |
||||
char entity_name[MAX_SENSOR_NAME]; |
||||
union { |
||||
compat_uptr_t setting; |
||||
} cfg; |
||||
}; |
||||
|
||||
struct msm_actuator_move_params_t32 { |
||||
int8_t dir; |
||||
int8_t sign_dir; |
||||
int16_t dest_step_pos; |
||||
int32_t num_steps; |
||||
uint16_t curr_lens_pos; |
||||
compat_uptr_t ringing_params; |
||||
}; |
||||
|
||||
struct msm_actuator_cfg_data32 { |
||||
int cfgtype; |
||||
uint8_t is_af_supported; |
||||
union { |
||||
struct msm_actuator_move_params_t32 move; |
||||
struct msm_actuator_set_info_t32 set_info; |
||||
struct msm_actuator_get_info_t get_info; |
||||
struct msm_actuator_set_position_t setpos; |
||||
enum af_camera_name cam_name; |
||||
} cfg; |
||||
}; |
||||
|
||||
struct csiphy_cfg_data32 { |
||||
enum csiphy_cfg_type_t cfgtype; |
||||
union { |
||||
compat_uptr_t csiphy_params; |
||||
compat_uptr_t csi_lane_params; |
||||
} cfg; |
||||
}; |
||||
|
||||
struct sensorb_cfg_data32 { |
||||
int cfgtype; |
||||
union { |
||||
struct msm_sensor_info_t sensor_info; |
||||
struct msm_sensor_init_params sensor_init_params; |
||||
compat_uptr_t setting; |
||||
struct msm_sensor_i2c_sync_params sensor_i2c_sync_params; |
||||
} cfg; |
||||
}; |
||||
|
||||
struct msm_ois_params_t32 { |
||||
uint16_t data_size; |
||||
uint16_t setting_size; |
||||
uint32_t i2c_addr; |
||||
enum i2c_freq_mode_t i2c_freq_mode; |
||||
enum msm_camera_i2c_reg_addr_type i2c_addr_type; |
||||
enum msm_camera_i2c_data_type i2c_data_type; |
||||
compat_uptr_t settings; |
||||
}; |
||||
|
||||
struct msm_ois_set_info_t32 { |
||||
struct msm_ois_params_t32 ois_params; |
||||
}; |
||||
|
||||
struct msm_ois_cfg_data32 { |
||||
int cfgtype; |
||||
union { |
||||
struct msm_ois_set_info_t32 set_info; |
||||
compat_uptr_t settings; |
||||
} cfg; |
||||
}; |
||||
|
||||
struct msm_flash_init_info_t32 { |
||||
enum msm_flash_driver_type flash_driver_type; |
||||
uint32_t slave_addr; |
||||
enum i2c_freq_mode_t i2c_freq_mode; |
||||
compat_uptr_t power_setting_array; |
||||
compat_uptr_t settings; |
||||
}; |
||||
|
||||
struct msm_flash_cfg_data_t32 { |
||||
enum msm_flash_cfg_type_t cfg_type; |
||||
int32_t flash_current[MAX_LED_TRIGGERS]; |
||||
int32_t flash_duration[MAX_LED_TRIGGERS]; |
||||
union { |
||||
compat_uptr_t flash_init_info; |
||||
compat_uptr_t settings; |
||||
} cfg; |
||||
}; |
||||
|
||||
#define VIDIOC_MSM_ACTUATOR_CFG32 \ |
||||
_IOWR('V', BASE_VIDIOC_PRIVATE + 6, struct msm_actuator_cfg_data32) |
||||
|
||||
#define VIDIOC_MSM_SENSOR_INIT_CFG32 \ |
||||
_IOWR('V', BASE_VIDIOC_PRIVATE + 10, struct sensor_init_cfg_data32) |
||||
|
||||
#define VIDIOC_MSM_CSIPHY_IO_CFG32 \ |
||||
_IOWR('V', BASE_VIDIOC_PRIVATE + 4, struct csiphy_cfg_data32) |
||||
|
||||
#define VIDIOC_MSM_SENSOR_CFG32 \ |
||||
_IOWR('V', BASE_VIDIOC_PRIVATE + 1, struct sensorb_cfg_data32) |
||||
|
||||
#define VIDIOC_MSM_EEPROM_CFG32 \ |
||||
_IOWR('V', BASE_VIDIOC_PRIVATE + 8, struct msm_eeprom_cfg_data32) |
||||
|
||||
#define VIDIOC_MSM_OIS_CFG32 \ |
||||
_IOWR('V', BASE_VIDIOC_PRIVATE + 11, struct msm_ois_cfg_data32) |
||||
|
||||
#define VIDIOC_MSM_CSID_IO_CFG32 \ |
||||
_IOWR('V', BASE_VIDIOC_PRIVATE + 5, struct csid_cfg_data32) |
||||
|
||||
#define VIDIOC_MSM_FLASH_CFG32 \ |
||||
_IOWR('V', BASE_VIDIOC_PRIVATE + 13, struct msm_flash_cfg_data_t32) |
||||
#endif |
||||
|
||||
#endif /* __LINUX_MSM_CAM_SENSOR_H */ |
||||
@ -0,0 +1,386 @@ |
||||
#ifndef __LINUX_MSM_CAMSENSOR_SDK_H |
||||
#define __LINUX_MSM_CAMSENSOR_SDK_H |
||||
|
||||
#define KVERSION 0x1 |
||||
|
||||
#define MAX_POWER_CONFIG 12 |
||||
#define GPIO_OUT_LOW (0 << 1) |
||||
#define GPIO_OUT_HIGH (1 << 1) |
||||
#define CSI_EMBED_DATA 0x12 |
||||
#define CSI_RESERVED_DATA_0 0x13 |
||||
#define CSI_YUV422_8 0x1E |
||||
#define CSI_RAW8 0x2A |
||||
#define CSI_RAW10 0x2B |
||||
#define CSI_RAW12 0x2C |
||||
#define CSI_DECODE_6BIT 0 |
||||
#define CSI_DECODE_8BIT 1 |
||||
#define CSI_DECODE_10BIT 2 |
||||
#define CSI_DECODE_12BIT 3 |
||||
#define CSI_DECODE_DPCM_10_8_10 5 |
||||
#define MAX_CID 16 |
||||
#define I2C_SEQ_REG_DATA_MAX 1024 |
||||
#define I2C_REG_DATA_MAX (8*1024) |
||||
|
||||
#define MSM_V4L2_PIX_FMT_META v4l2_fourcc('M', 'E', 'T', 'A') /* META */ |
||||
#define MSM_V4L2_PIX_FMT_SBGGR14 v4l2_fourcc('B', 'G', '1', '4') |
||||
/* 14 BGBG.. GRGR.. */ |
||||
#define MSM_V4L2_PIX_FMT_SGBRG14 v4l2_fourcc('G', 'B', '1', '4') |
||||
/* 14 GBGB.. RGRG.. */ |
||||
#define MSM_V4L2_PIX_FMT_SGRBG14 v4l2_fourcc('B', 'A', '1', '4') |
||||
/* 14 GRGR.. BGBG.. */ |
||||
#define MSM_V4L2_PIX_FMT_SRGGB14 v4l2_fourcc('R', 'G', '1', '4') |
||||
/* 14 RGRG.. GBGB.. */ |
||||
|
||||
#define MAX_ACTUATOR_REG_TBL_SIZE 8 |
||||
#define MAX_ACTUATOR_REGION 5 |
||||
#define NUM_ACTUATOR_DIR 2 |
||||
#define MAX_ACTUATOR_SCENARIO 8 |
||||
#define MAX_ACT_MOD_NAME_SIZE 32 |
||||
#define MAX_ACT_NAME_SIZE 32 |
||||
#define MAX_ACTUATOR_INIT_SET 120 |
||||
#define MAX_I2C_REG_SET 12 |
||||
|
||||
#define MAX_LED_TRIGGERS 3 |
||||
|
||||
#define MSM_EEPROM_MEMORY_MAP_MAX_SIZE 80 |
||||
#define MSM_EEPROM_MAX_MEM_MAP_CNT 8 |
||||
|
||||
enum msm_sensor_camera_id_t { |
||||
CAMERA_0, |
||||
CAMERA_1, |
||||
CAMERA_2, |
||||
CAMERA_3, |
||||
MAX_CAMERAS, |
||||
}; |
||||
|
||||
enum i2c_freq_mode_t { |
||||
I2C_STANDARD_MODE, |
||||
I2C_FAST_MODE, |
||||
I2C_CUSTOM_MODE, |
||||
I2C_FAST_PLUS_MODE, |
||||
I2C_MAX_MODES, |
||||
}; |
||||
|
||||
enum camb_position_t { |
||||
BACK_CAMERA_B, |
||||
FRONT_CAMERA_B, |
||||
AUX_CAMERA_B = 0x100, |
||||
INVALID_CAMERA_B, |
||||
}; |
||||
|
||||
enum msm_sensor_power_seq_type_t { |
||||
SENSOR_CLK, |
||||
SENSOR_GPIO, |
||||
SENSOR_VREG, |
||||
SENSOR_I2C_MUX, |
||||
SENSOR_I2C, |
||||
}; |
||||
|
||||
enum msm_camera_i2c_reg_addr_type { |
||||
MSM_CAMERA_I2C_BYTE_ADDR = 1, |
||||
MSM_CAMERA_I2C_WORD_ADDR, |
||||
MSM_CAMERA_I2C_3B_ADDR, |
||||
MSM_CAMERA_I2C_ADDR_TYPE_MAX, |
||||
}; |
||||
|
||||
enum msm_camera_i2c_data_type { |
||||
MSM_CAMERA_I2C_BYTE_DATA = 1, |
||||
MSM_CAMERA_I2C_WORD_DATA, |
||||
MSM_CAMERA_I2C_DWORD_DATA, |
||||
MSM_CAMERA_I2C_SET_BYTE_MASK, |
||||
MSM_CAMERA_I2C_UNSET_BYTE_MASK, |
||||
MSM_CAMERA_I2C_SET_WORD_MASK, |
||||
MSM_CAMERA_I2C_UNSET_WORD_MASK, |
||||
MSM_CAMERA_I2C_SET_BYTE_WRITE_MASK_DATA, |
||||
MSM_CAMERA_I2C_SEQ_DATA, |
||||
MSM_CAMERA_I2C_DATA_TYPE_MAX, |
||||
}; |
||||
|
||||
enum msm_sensor_power_seq_gpio_t { |
||||
SENSOR_GPIO_RESET, |
||||
SENSOR_GPIO_STANDBY, |
||||
SENSOR_GPIO_AF_PWDM, |
||||
SENSOR_GPIO_VIO, |
||||
SENSOR_GPIO_VANA, |
||||
SENSOR_GPIO_VDIG, |
||||
SENSOR_GPIO_VAF, |
||||
SENSOR_GPIO_FL_EN, |
||||
SENSOR_GPIO_FL_NOW, |
||||
SENSOR_GPIO_FL_RESET, |
||||
SENSOR_GPIO_CUSTOM1, |
||||
SENSOR_GPIO_CUSTOM2, |
||||
SENSOR_GPIO_MAX, |
||||
}; |
||||
|
||||
enum msm_camera_vreg_name_t { |
||||
CAM_VDIG, |
||||
CAM_VIO, |
||||
CAM_VANA, |
||||
CAM_VAF, |
||||
CAM_V_CUSTOM1, |
||||
CAM_V_CUSTOM2, |
||||
CAM_VREG_MAX, |
||||
}; |
||||
|
||||
enum msm_sensor_clk_type_t { |
||||
SENSOR_CAM_MCLK, |
||||
SENSOR_CAM_CLK, |
||||
SENSOR_CAM_CLK_MAX, |
||||
}; |
||||
|
||||
enum camerab_mode_t { |
||||
CAMERA_MODE_2D_B = (1<<0), |
||||
CAMERA_MODE_3D_B = (1<<1), |
||||
CAMERA_MODE_INVALID = (1<<2), |
||||
}; |
||||
|
||||
enum msm_actuator_data_type { |
||||
MSM_ACTUATOR_BYTE_DATA = 1, |
||||
MSM_ACTUATOR_WORD_DATA, |
||||
}; |
||||
|
||||
enum msm_actuator_addr_type { |
||||
MSM_ACTUATOR_BYTE_ADDR = 1, |
||||
MSM_ACTUATOR_WORD_ADDR, |
||||
}; |
||||
|
||||
enum msm_actuator_write_type { |
||||
MSM_ACTUATOR_WRITE_HW_DAMP, |
||||
MSM_ACTUATOR_WRITE_DAC, |
||||
MSM_ACTUATOR_WRITE, |
||||
MSM_ACTUATOR_WRITE_DIR_REG, |
||||
MSM_ACTUATOR_POLL, |
||||
MSM_ACTUATOR_READ_WRITE, |
||||
}; |
||||
|
||||
enum msm_actuator_i2c_operation { |
||||
MSM_ACT_WRITE = 0, |
||||
MSM_ACT_POLL, |
||||
}; |
||||
|
||||
enum actuator_type { |
||||
ACTUATOR_VCM, |
||||
ACTUATOR_PIEZO, |
||||
ACTUATOR_HVCM, |
||||
ACTUATOR_BIVCM, |
||||
}; |
||||
|
||||
enum msm_flash_driver_type { |
||||
FLASH_DRIVER_PMIC, |
||||
FLASH_DRIVER_I2C, |
||||
FLASH_DRIVER_GPIO, |
||||
FLASH_DRIVER_DEFAULT |
||||
}; |
||||
|
||||
enum msm_flash_cfg_type_t { |
||||
CFG_FLASH_INIT, |
||||
CFG_FLASH_RELEASE, |
||||
CFG_FLASH_OFF, |
||||
CFG_FLASH_LOW, |
||||
CFG_FLASH_HIGH, |
||||
}; |
||||
|
||||
enum msm_sensor_output_format_t { |
||||
MSM_SENSOR_BAYER, |
||||
MSM_SENSOR_YCBCR, |
||||
MSM_SENSOR_META, |
||||
}; |
||||
|
||||
struct msm_sensor_power_setting { |
||||
enum msm_sensor_power_seq_type_t seq_type; |
||||
unsigned short seq_val; |
||||
long config_val; |
||||
unsigned short delay; |
||||
void *data[10]; |
||||
}; |
||||
|
||||
struct msm_sensor_power_setting_array { |
||||
struct msm_sensor_power_setting power_setting_a[MAX_POWER_CONFIG]; |
||||
struct msm_sensor_power_setting *power_setting; |
||||
unsigned short size; |
||||
struct msm_sensor_power_setting power_down_setting_a[MAX_POWER_CONFIG]; |
||||
struct msm_sensor_power_setting *power_down_setting; |
||||
unsigned short size_down; |
||||
}; |
||||
|
||||
enum msm_camera_i2c_operation { |
||||
MSM_CAM_WRITE = 0, |
||||
MSM_CAM_POLL, |
||||
MSM_CAM_READ, |
||||
}; |
||||
|
||||
struct msm_sensor_i2c_sync_params { |
||||
unsigned int cid; |
||||
int csid; |
||||
unsigned short line; |
||||
unsigned short delay; |
||||
}; |
||||
|
||||
struct msm_camera_reg_settings_t { |
||||
uint16_t reg_addr; |
||||
enum msm_camera_i2c_reg_addr_type addr_type; |
||||
uint16_t reg_data; |
||||
enum msm_camera_i2c_data_type data_type; |
||||
enum msm_camera_i2c_operation i2c_operation; |
||||
uint16_t delay; |
||||
}; |
||||
|
||||
struct msm_eeprom_mem_map_t { |
||||
int slave_addr; |
||||
struct msm_camera_reg_settings_t |
||||
mem_settings[MSM_EEPROM_MEMORY_MAP_MAX_SIZE]; |
||||
int memory_map_size; |
||||
}; |
||||
|
||||
struct msm_eeprom_memory_map_array { |
||||
struct msm_eeprom_mem_map_t memory_map[MSM_EEPROM_MAX_MEM_MAP_CNT]; |
||||
uint32_t msm_size_of_max_mappings; |
||||
}; |
||||
|
||||
struct msm_sensor_init_params { |
||||
/* mask of modes supported: 2D, 3D */ |
||||
int modes_supported; |
||||
/* sensor position: front, back */ |
||||
enum camb_position_t position; |
||||
/* sensor mount angle */ |
||||
unsigned int sensor_mount_angle; |
||||
}; |
||||
|
||||
struct msm_sensor_id_info_t { |
||||
unsigned short sensor_id_reg_addr; |
||||
unsigned short sensor_id; |
||||
unsigned short sensor_id_mask; |
||||
// added in LeEco
|
||||
unsigned char module_id; |
||||
unsigned char vcm_id; |
||||
}; |
||||
|
||||
struct msm_camera_sensor_slave_info { |
||||
char sensor_name[32]; |
||||
char eeprom_name[32]; |
||||
char actuator_name[32]; |
||||
char ois_name[32]; |
||||
char flash_name[32]; |
||||
enum msm_sensor_camera_id_t camera_id; |
||||
unsigned short slave_addr; |
||||
enum i2c_freq_mode_t i2c_freq_mode; |
||||
enum msm_camera_i2c_reg_addr_type addr_type; |
||||
struct msm_sensor_id_info_t sensor_id_info; |
||||
struct msm_sensor_power_setting_array power_setting_array; |
||||
unsigned char is_init_params_valid; |
||||
struct msm_sensor_init_params sensor_init_params; |
||||
enum msm_sensor_output_format_t output_format; |
||||
}; |
||||
|
||||
struct msm_camera_i2c_reg_array { |
||||
unsigned short reg_addr; |
||||
unsigned short reg_data; |
||||
unsigned int delay; |
||||
}; |
||||
|
||||
struct msm_camera_i2c_reg_setting { |
||||
struct msm_camera_i2c_reg_array *reg_setting; |
||||
unsigned short size; |
||||
enum msm_camera_i2c_reg_addr_type addr_type; |
||||
enum msm_camera_i2c_data_type data_type; |
||||
unsigned short delay; |
||||
}; |
||||
|
||||
struct msm_camera_csid_vc_cfg { |
||||
unsigned char cid; |
||||
unsigned char dt; |
||||
unsigned char decode_format; |
||||
}; |
||||
|
||||
struct msm_camera_csid_lut_params { |
||||
unsigned char num_cid; |
||||
struct msm_camera_csid_vc_cfg vc_cfg_a[MAX_CID]; |
||||
struct msm_camera_csid_vc_cfg *vc_cfg[MAX_CID]; |
||||
}; |
||||
|
||||
struct msm_camera_csid_params { |
||||
unsigned char lane_cnt; |
||||
unsigned short lane_assign; |
||||
unsigned char phy_sel; |
||||
unsigned int csi_clk; |
||||
struct msm_camera_csid_lut_params lut_params; |
||||
unsigned char csi_3p_sel; |
||||
}; |
||||
|
||||
struct msm_camera_csid_testmode_parms { |
||||
unsigned int num_bytes_per_line; |
||||
unsigned int num_lines; |
||||
unsigned int h_blanking_count; |
||||
unsigned int v_blanking_count; |
||||
unsigned int payload_mode; |
||||
}; |
||||
|
||||
struct msm_camera_csiphy_params { |
||||
unsigned char lane_cnt; |
||||
unsigned char settle_cnt; |
||||
unsigned short lane_mask; |
||||
unsigned char combo_mode; |
||||
unsigned char csid_core; |
||||
unsigned int csiphy_clk; |
||||
unsigned char csi_3phase; |
||||
}; |
||||
|
||||
struct msm_camera_i2c_seq_reg_array { |
||||
unsigned short reg_addr; |
||||
unsigned char reg_data[I2C_SEQ_REG_DATA_MAX]; |
||||
unsigned short reg_data_size; |
||||
}; |
||||
|
||||
struct msm_camera_i2c_seq_reg_setting { |
||||
struct msm_camera_i2c_seq_reg_array *reg_setting; |
||||
unsigned short size; |
||||
enum msm_camera_i2c_reg_addr_type addr_type; |
||||
unsigned short delay; |
||||
}; |
||||
|
||||
struct msm_actuator_reg_params_t { |
||||
enum msm_actuator_write_type reg_write_type; |
||||
unsigned int hw_mask; |
||||
unsigned short reg_addr; |
||||
unsigned short hw_shift; |
||||
unsigned short data_shift; |
||||
unsigned short data_type; |
||||
unsigned short addr_type; |
||||
unsigned short reg_data; |
||||
unsigned short delay; |
||||
}; |
||||
|
||||
|
||||
struct damping_params_t { |
||||
unsigned int damping_step; |
||||
unsigned int damping_delay; |
||||
unsigned int hw_params; |
||||
}; |
||||
|
||||
struct region_params_t { |
||||
/* [0] = ForwardDirection Macro boundary
|
||||
[1] = ReverseDirection Inf boundary |
||||
*/ |
||||
unsigned short step_bound[2]; |
||||
unsigned short code_per_step; |
||||
/* qvalue for converting float type numbers to integer format */ |
||||
unsigned int qvalue; |
||||
}; |
||||
|
||||
struct reg_settings_t { |
||||
unsigned short reg_addr; |
||||
enum msm_actuator_addr_type addr_type; |
||||
unsigned short reg_data; |
||||
enum msm_actuator_data_type data_type; |
||||
enum msm_actuator_i2c_operation i2c_operation; |
||||
unsigned int delay; |
||||
}; |
||||
|
||||
struct msm_camera_i2c_reg_setting_array { |
||||
struct msm_camera_i2c_reg_array reg_setting_a[MAX_I2C_REG_SET]; |
||||
unsigned short size; |
||||
enum msm_camera_i2c_reg_addr_type addr_type; |
||||
enum msm_camera_i2c_data_type data_type; |
||||
unsigned short delay; |
||||
}; |
||||
#endif /* __LINUX_MSM_CAM_SENSOR_H */ |
||||
@ -0,0 +1,220 @@ |
||||
#ifndef __LINUX_MSMB_CAMERA_H |
||||
#define __LINUX_MSMB_CAMERA_H |
||||
|
||||
#include <linux/videodev2.h> |
||||
#include <linux/types.h> |
||||
#include <linux/ioctl.h> |
||||
|
||||
#define MSM_CAM_LOGSYNC_FILE_NAME "logsync" |
||||
#define MSM_CAM_LOGSYNC_FILE_BASEDIR "camera" |
||||
|
||||
#define MSM_CAM_V4L2_IOCTL_NOTIFY \ |
||||
_IOW('V', BASE_VIDIOC_PRIVATE + 30, struct msm_v4l2_event_data) |
||||
|
||||
#define MSM_CAM_V4L2_IOCTL_NOTIFY_META \ |
||||
_IOW('V', BASE_VIDIOC_PRIVATE + 31, struct msm_v4l2_event_data) |
||||
|
||||
#define MSM_CAM_V4L2_IOCTL_CMD_ACK \ |
||||
_IOW('V', BASE_VIDIOC_PRIVATE + 32, struct msm_v4l2_event_data) |
||||
|
||||
#define MSM_CAM_V4L2_IOCTL_NOTIFY_ERROR \ |
||||
_IOW('V', BASE_VIDIOC_PRIVATE + 33, struct msm_v4l2_event_data) |
||||
|
||||
#define MSM_CAM_V4L2_IOCTL_NOTIFY_DEBUG \ |
||||
_IOW('V', BASE_VIDIOC_PRIVATE + 34, struct msm_v4l2_event_data) |
||||
|
||||
#ifdef CONFIG_COMPAT |
||||
#define MSM_CAM_V4L2_IOCTL_NOTIFY32 \ |
||||
_IOW('V', BASE_VIDIOC_PRIVATE + 30, struct v4l2_event32) |
||||
|
||||
#define MSM_CAM_V4L2_IOCTL_NOTIFY_META32 \ |
||||
_IOW('V', BASE_VIDIOC_PRIVATE + 31, struct v4l2_event32) |
||||
|
||||
#define MSM_CAM_V4L2_IOCTL_CMD_ACK32 \ |
||||
_IOW('V', BASE_VIDIOC_PRIVATE + 32, struct v4l2_event32) |
||||
|
||||
#define MSM_CAM_V4L2_IOCTL_NOTIFY_ERROR32 \ |
||||
_IOW('V', BASE_VIDIOC_PRIVATE + 33, struct v4l2_event32) |
||||
|
||||
#define MSM_CAM_V4L2_IOCTL_NOTIFY_DEBUG32 \ |
||||
_IOW('V', BASE_VIDIOC_PRIVATE + 34, struct v4l2_event32) |
||||
|
||||
#endif |
||||
|
||||
#define QCAMERA_DEVICE_GROUP_ID 1 |
||||
#define QCAMERA_VNODE_GROUP_ID 2 |
||||
#define MSM_CAMERA_NAME "msm_camera" |
||||
#define MSM_CONFIGURATION_NAME "msm_config" |
||||
|
||||
#define MSM_CAMERA_SUBDEV_CSIPHY 0 |
||||
#define MSM_CAMERA_SUBDEV_CSID 1 |
||||
#define MSM_CAMERA_SUBDEV_ISPIF 2 |
||||
#define MSM_CAMERA_SUBDEV_VFE 3 |
||||
#define MSM_CAMERA_SUBDEV_AXI 4 |
||||
#define MSM_CAMERA_SUBDEV_VPE 5 |
||||
#define MSM_CAMERA_SUBDEV_SENSOR 6 |
||||
#define MSM_CAMERA_SUBDEV_ACTUATOR 7 |
||||
#define MSM_CAMERA_SUBDEV_EEPROM 8 |
||||
#define MSM_CAMERA_SUBDEV_CPP 9 |
||||
#define MSM_CAMERA_SUBDEV_CCI 10 |
||||
#define MSM_CAMERA_SUBDEV_LED_FLASH 11 |
||||
#define MSM_CAMERA_SUBDEV_STROBE_FLASH 12 |
||||
#define MSM_CAMERA_SUBDEV_BUF_MNGR 13 |
||||
#define MSM_CAMERA_SUBDEV_SENSOR_INIT 14 |
||||
#define MSM_CAMERA_SUBDEV_OIS 15 |
||||
#define MSM_CAMERA_SUBDEV_FLASH 16 |
||||
#define MSM_CAMERA_SUBDEV_EXT 17 |
||||
|
||||
#define MSM_MAX_CAMERA_SENSORS 5 |
||||
|
||||
/* The below macro is defined to put an upper limit on maximum
|
||||
* number of buffer requested per stream. In case of extremely |
||||
* large value for number of buffer due to data structure corruption |
||||
* we return error to avoid integer overflow. Group processing |
||||
* can have max of 9 groups of 8 bufs each. This value may be |
||||
* configured in future*/ |
||||
#define MSM_CAMERA_MAX_STREAM_BUF 72 |
||||
|
||||
/* Max batch size of processing */ |
||||
#define MSM_CAMERA_MAX_USER_BUFF_CNT 16 |
||||
|
||||
/* featur base */ |
||||
#define MSM_CAMERA_FEATURE_BASE 0x00010000 |
||||
#define MSM_CAMERA_FEATURE_SHUTDOWN (MSM_CAMERA_FEATURE_BASE + 1) |
||||
|
||||
#define MSM_CAMERA_STATUS_BASE 0x00020000 |
||||
#define MSM_CAMERA_STATUS_FAIL (MSM_CAMERA_STATUS_BASE + 1) |
||||
#define MSM_CAMERA_STATUS_SUCCESS (MSM_CAMERA_STATUS_BASE + 2) |
||||
|
||||
/* event type */ |
||||
#define MSM_CAMERA_V4L2_EVENT_TYPE (V4L2_EVENT_PRIVATE_START + 0x00002000) |
||||
|
||||
/* event id */ |
||||
#define MSM_CAMERA_EVENT_MIN 0 |
||||
#define MSM_CAMERA_NEW_SESSION (MSM_CAMERA_EVENT_MIN + 1) |
||||
#define MSM_CAMERA_DEL_SESSION (MSM_CAMERA_EVENT_MIN + 2) |
||||
#define MSM_CAMERA_SET_PARM (MSM_CAMERA_EVENT_MIN + 3) |
||||
#define MSM_CAMERA_GET_PARM (MSM_CAMERA_EVENT_MIN + 4) |
||||
#define MSM_CAMERA_MAPPING_CFG (MSM_CAMERA_EVENT_MIN + 5) |
||||
#define MSM_CAMERA_MAPPING_SES (MSM_CAMERA_EVENT_MIN + 6) |
||||
#define MSM_CAMERA_MSM_NOTIFY (MSM_CAMERA_EVENT_MIN + 7) |
||||
#define MSM_CAMERA_EVENT_MAX (MSM_CAMERA_EVENT_MIN + 8) |
||||
|
||||
/* data.command */ |
||||
#define MSM_CAMERA_PRIV_S_CROP (V4L2_CID_PRIVATE_BASE + 1) |
||||
#define MSM_CAMERA_PRIV_G_CROP (V4L2_CID_PRIVATE_BASE + 2) |
||||
#define MSM_CAMERA_PRIV_G_FMT (V4L2_CID_PRIVATE_BASE + 3) |
||||
#define MSM_CAMERA_PRIV_S_FMT (V4L2_CID_PRIVATE_BASE + 4) |
||||
#define MSM_CAMERA_PRIV_TRY_FMT (V4L2_CID_PRIVATE_BASE + 5) |
||||
#define MSM_CAMERA_PRIV_METADATA (V4L2_CID_PRIVATE_BASE + 6) |
||||
#define MSM_CAMERA_PRIV_QUERY_CAP (V4L2_CID_PRIVATE_BASE + 7) |
||||
#define MSM_CAMERA_PRIV_STREAM_ON (V4L2_CID_PRIVATE_BASE + 8) |
||||
#define MSM_CAMERA_PRIV_STREAM_OFF (V4L2_CID_PRIVATE_BASE + 9) |
||||
#define MSM_CAMERA_PRIV_NEW_STREAM (V4L2_CID_PRIVATE_BASE + 10) |
||||
#define MSM_CAMERA_PRIV_DEL_STREAM (V4L2_CID_PRIVATE_BASE + 11) |
||||
#define MSM_CAMERA_PRIV_SHUTDOWN (V4L2_CID_PRIVATE_BASE + 12) |
||||
#define MSM_CAMERA_PRIV_STREAM_INFO_SYNC \ |
||||
(V4L2_CID_PRIVATE_BASE + 13) |
||||
#define MSM_CAMERA_PRIV_G_SESSION_ID (V4L2_CID_PRIVATE_BASE + 14) |
||||
#define MSM_CAMERA_PRIV_CMD_MAX 20 |
||||
|
||||
/* data.status - success */ |
||||
#define MSM_CAMERA_CMD_SUCESS 0x00000001 |
||||
#define MSM_CAMERA_BUF_MAP_SUCESS 0x00000002 |
||||
|
||||
/* data.status - error */ |
||||
#define MSM_CAMERA_ERR_EVT_BASE 0x00010000 |
||||
#define MSM_CAMERA_ERR_CMD_FAIL (MSM_CAMERA_ERR_EVT_BASE + 1) |
||||
#define MSM_CAMERA_ERR_MAPPING (MSM_CAMERA_ERR_EVT_BASE + 2) |
||||
#define MSM_CAMERA_ERR_DEVICE_BUSY (MSM_CAMERA_ERR_EVT_BASE + 3) |
||||
|
||||
/* The msm_v4l2_event_data structure should match the
|
||||
* v4l2_event.u.data field. |
||||
* should not exceed 16 elements */ |
||||
struct msm_v4l2_event_data { |
||||
/*word 0*/ |
||||
unsigned int command; |
||||
/*word 1*/ |
||||
unsigned int status; |
||||
/*word 2*/ |
||||
unsigned int session_id; |
||||
/*word 3*/ |
||||
unsigned int stream_id; |
||||
/*word 4*/ |
||||
unsigned int map_op; |
||||
/*word 5*/ |
||||
unsigned int map_buf_idx; |
||||
/*word 6*/ |
||||
unsigned int notify; |
||||
/*word 7*/ |
||||
unsigned int arg_value; |
||||
/*word 8*/ |
||||
unsigned int ret_value; |
||||
/*word 9*/ |
||||
unsigned int v4l2_event_type; |
||||
/*word 10*/ |
||||
unsigned int v4l2_event_id; |
||||
/*word 11*/ |
||||
unsigned int handle; |
||||
/*word 12*/ |
||||
unsigned int nop6; |
||||
/*word 13*/ |
||||
unsigned int nop7; |
||||
/*word 14*/ |
||||
unsigned int nop8; |
||||
/*word 15*/ |
||||
unsigned int nop9; |
||||
}; |
||||
|
||||
/* map to v4l2_format.fmt.raw_data */ |
||||
struct msm_v4l2_format_data { |
||||
enum v4l2_buf_type type; |
||||
unsigned int width; |
||||
unsigned int height; |
||||
unsigned int pixelformat; /* FOURCC */ |
||||
unsigned char num_planes; |
||||
unsigned int plane_sizes[VIDEO_MAX_PLANES]; |
||||
}; |
||||
|
||||
/* MSM Four-character-code (FOURCC) */ |
||||
#define msm_v4l2_fourcc(a, b, c, d)\ |
||||
((__u32)(a) | ((__u32)(b) << 8) | ((__u32)(c) << 16) |\
|
||||
((__u32)(d) << 24)) |
||||
|
||||
/* Composite stats */ |
||||
#define MSM_V4L2_PIX_FMT_STATS_COMB v4l2_fourcc('S', 'T', 'C', 'M') |
||||
/* AEC stats */ |
||||
#define MSM_V4L2_PIX_FMT_STATS_AE v4l2_fourcc('S', 'T', 'A', 'E') |
||||
/* AF stats */ |
||||
#define MSM_V4L2_PIX_FMT_STATS_AF v4l2_fourcc('S', 'T', 'A', 'F') |
||||
/* AWB stats */ |
||||
#define MSM_V4L2_PIX_FMT_STATS_AWB v4l2_fourcc('S', 'T', 'W', 'B') |
||||
/* IHIST stats */ |
||||
#define MSM_V4L2_PIX_FMT_STATS_IHST v4l2_fourcc('I', 'H', 'S', 'T') |
||||
/* Column count stats */ |
||||
#define MSM_V4L2_PIX_FMT_STATS_CS v4l2_fourcc('S', 'T', 'C', 'S') |
||||
/* Row count stats */ |
||||
#define MSM_V4L2_PIX_FMT_STATS_RS v4l2_fourcc('S', 'T', 'R', 'S') |
||||
/* Bayer Grid stats */ |
||||
#define MSM_V4L2_PIX_FMT_STATS_BG v4l2_fourcc('S', 'T', 'B', 'G') |
||||
/* Bayer focus stats */ |
||||
#define MSM_V4L2_PIX_FMT_STATS_BF v4l2_fourcc('S', 'T', 'B', 'F') |
||||
/* Bayer hist stats */ |
||||
#define MSM_V4L2_PIX_FMT_STATS_BHST v4l2_fourcc('B', 'H', 'S', 'T') |
||||
|
||||
enum smmu_attach_mode { |
||||
NON_SECURE_MODE = 0x01, |
||||
SECURE_MODE = 0x02, |
||||
MAX_PROTECTION_MODE = 0x03, |
||||
}; |
||||
|
||||
struct msm_camera_smmu_attach_type { |
||||
enum smmu_attach_mode attach; |
||||
}; |
||||
|
||||
struct msm_camera_user_buf_cont_t { |
||||
unsigned int buf_cnt; |
||||
unsigned int buf_idx[MSM_CAMERA_MAX_USER_BUFF_CNT]; |
||||
}; |
||||
|
||||
#endif /* __LINUX_MSMB_CAMERA_H */ |
||||
@ -0,0 +1,880 @@ |
||||
#ifndef __MSMB_ISP__ |
||||
#define __MSMB_ISP__ |
||||
|
||||
#include <linux/videodev2.h> |
||||
|
||||
#define MAX_PLANES_PER_STREAM 3 |
||||
#define MAX_NUM_STREAM 7 |
||||
|
||||
#define ISP_VERSION_47 47 |
||||
#define ISP_VERSION_46 46 |
||||
#define ISP_VERSION_44 44 |
||||
#define ISP_VERSION_40 40 |
||||
#define ISP_VERSION_32 32 |
||||
#define ISP_NATIVE_BUF_BIT (0x10000 << 0) |
||||
#define ISP0_BIT (0x10000 << 1) |
||||
#define ISP1_BIT (0x10000 << 2) |
||||
#define ISP_META_CHANNEL_BIT (0x10000 << 3) |
||||
#define ISP_SCRATCH_BUF_BIT (0x10000 << 4) |
||||
#define ISP_OFFLINE_STATS_BIT (0x10000 << 5) |
||||
#define ISP_STATS_STREAM_BIT 0x80000000 |
||||
|
||||
struct msm_vfe_cfg_cmd_list; |
||||
|
||||
enum ISP_START_PIXEL_PATTERN { |
||||
ISP_BAYER_RGRGRG, |
||||
ISP_BAYER_GRGRGR, |
||||
ISP_BAYER_BGBGBG, |
||||
ISP_BAYER_GBGBGB, |
||||
ISP_YUV_YCbYCr, |
||||
ISP_YUV_YCrYCb, |
||||
ISP_YUV_CbYCrY, |
||||
ISP_YUV_CrYCbY, |
||||
ISP_PIX_PATTERN_MAX |
||||
}; |
||||
|
||||
enum msm_vfe_plane_fmt { |
||||
Y_PLANE, |
||||
CB_PLANE, |
||||
CR_PLANE, |
||||
CRCB_PLANE, |
||||
CBCR_PLANE, |
||||
VFE_PLANE_FMT_MAX |
||||
}; |
||||
|
||||
enum msm_vfe_input_src { |
||||
VFE_PIX_0, |
||||
VFE_RAW_0, |
||||
VFE_RAW_1, |
||||
VFE_RAW_2, |
||||
VFE_SRC_MAX, |
||||
}; |
||||
|
||||
enum msm_vfe_axi_stream_src { |
||||
PIX_ENCODER, |
||||
PIX_VIEWFINDER, |
||||
PIX_VIDEO, |
||||
CAMIF_RAW, |
||||
IDEAL_RAW, |
||||
RDI_INTF_0, |
||||
RDI_INTF_1, |
||||
RDI_INTF_2, |
||||
VFE_AXI_SRC_MAX |
||||
}; |
||||
|
||||
enum msm_vfe_frame_skip_pattern { |
||||
NO_SKIP, |
||||
EVERY_2FRAME, |
||||
EVERY_3FRAME, |
||||
EVERY_4FRAME, |
||||
EVERY_5FRAME, |
||||
EVERY_6FRAME, |
||||
EVERY_7FRAME, |
||||
EVERY_8FRAME, |
||||
EVERY_16FRAME, |
||||
EVERY_32FRAME, |
||||
SKIP_ALL, |
||||
SKIP_RANGE, |
||||
MAX_SKIP, |
||||
}; |
||||
|
||||
/*
|
||||
* Define an unused period. When this period is set it means that the stream is |
||||
* stopped(i.e the pattern is 0). We don't track the current pattern, just the |
||||
* period defines what the pattern is, if period is this then pattern is 0 else |
||||
* pattern is 1 |
||||
*/ |
||||
#define MSM_VFE_STREAM_STOP_PERIOD 15 |
||||
|
||||
enum msm_isp_stats_type { |
||||
MSM_ISP_STATS_AEC, /* legacy based AEC */ |
||||
MSM_ISP_STATS_AF, /* legacy based AF */ |
||||
MSM_ISP_STATS_AWB, /* legacy based AWB */ |
||||
MSM_ISP_STATS_RS, /* legacy based RS */ |
||||
MSM_ISP_STATS_CS, /* legacy based CS */ |
||||
MSM_ISP_STATS_IHIST, /* legacy based HIST */ |
||||
MSM_ISP_STATS_SKIN, /* legacy based SKIN */ |
||||
MSM_ISP_STATS_BG, /* Bayer Grids */ |
||||
MSM_ISP_STATS_BF, /* Bayer Focus */ |
||||
MSM_ISP_STATS_BE, /* Bayer Exposure*/ |
||||
MSM_ISP_STATS_BHIST, /* Bayer Hist */ |
||||
MSM_ISP_STATS_BF_SCALE, /* Bayer Focus scale */ |
||||
MSM_ISP_STATS_HDR_BE, /* HDR Bayer Exposure */ |
||||
MSM_ISP_STATS_HDR_BHIST, /* HDR Bayer Hist */ |
||||
MSM_ISP_STATS_AEC_BG, /* AEC BG */ |
||||
MSM_ISP_STATS_MAX /* MAX */ |
||||
}; |
||||
|
||||
/*
|
||||
* @stats_type_mask: Stats type mask (enum msm_isp_stats_type). |
||||
* @stream_src_mask: Stream src mask (enum msm_vfe_axi_stream_src) |
||||
* @skip_mode: skip pattern, if skip mode is range only then min/max is used |
||||
* @min_frame_id: minimum frame id (valid only if skip_mode = RANGE) |
||||
* @max_frame_id: maximum frame id (valid only if skip_mode = RANGE) |
||||
*/ |
||||
struct msm_isp_sw_framskip { |
||||
uint32_t stats_type_mask; |
||||
uint32_t stream_src_mask; |
||||
enum msm_vfe_frame_skip_pattern skip_mode; |
||||
uint32_t min_frame_id; |
||||
uint32_t max_frame_id; |
||||
}; |
||||
|
||||
enum msm_vfe_testgen_color_pattern { |
||||
COLOR_BAR_8_COLOR, |
||||
UNICOLOR_WHITE, |
||||
UNICOLOR_YELLOW, |
||||
UNICOLOR_CYAN, |
||||
UNICOLOR_GREEN, |
||||
UNICOLOR_MAGENTA, |
||||
UNICOLOR_RED, |
||||
UNICOLOR_BLUE, |
||||
UNICOLOR_BLACK, |
||||
MAX_COLOR, |
||||
}; |
||||
|
||||
enum msm_vfe_camif_input { |
||||
CAMIF_DISABLED, |
||||
CAMIF_PAD_REG_INPUT, |
||||
CAMIF_MIDDI_INPUT, |
||||
CAMIF_MIPI_INPUT, |
||||
}; |
||||
|
||||
struct msm_vfe_fetch_engine_cfg { |
||||
uint32_t input_format; |
||||
uint32_t buf_width; |
||||
uint32_t buf_height; |
||||
uint32_t fetch_width; |
||||
uint32_t fetch_height; |
||||
uint32_t x_offset; |
||||
uint32_t y_offset; |
||||
uint32_t buf_stride; |
||||
}; |
||||
|
||||
enum msm_vfe_camif_output_format { |
||||
CAMIF_QCOM_RAW, |
||||
CAMIF_MIPI_RAW, |
||||
CAMIF_PLAIN_8, |
||||
CAMIF_PLAIN_16, |
||||
CAMIF_MAX_FORMAT, |
||||
}; |
||||
|
||||
/*
|
||||
* Camif output general configuration |
||||
*/ |
||||
struct msm_vfe_camif_subsample_cfg { |
||||
uint32_t irq_subsample_period; |
||||
uint32_t irq_subsample_pattern; |
||||
uint32_t sof_counter_step; |
||||
uint32_t pixel_skip; |
||||
uint32_t line_skip; |
||||
uint32_t first_line; |
||||
uint32_t last_line; |
||||
uint32_t first_pixel; |
||||
uint32_t last_pixel; |
||||
enum msm_vfe_camif_output_format output_format; |
||||
}; |
||||
|
||||
/*
|
||||
* Camif frame and window configuration |
||||
*/ |
||||
struct msm_vfe_camif_cfg { |
||||
uint32_t lines_per_frame; |
||||
uint32_t pixels_per_line; |
||||
uint32_t first_pixel; |
||||
uint32_t last_pixel; |
||||
uint32_t first_line; |
||||
uint32_t last_line; |
||||
uint32_t epoch_line0; |
||||
uint32_t epoch_line1; |
||||
uint32_t is_split; |
||||
enum msm_vfe_camif_input camif_input; |
||||
struct msm_vfe_camif_subsample_cfg subsample_cfg; |
||||
}; |
||||
|
||||
struct msm_vfe_testgen_cfg { |
||||
uint32_t lines_per_frame; |
||||
uint32_t pixels_per_line; |
||||
uint32_t v_blank; |
||||
uint32_t h_blank; |
||||
enum ISP_START_PIXEL_PATTERN pixel_bayer_pattern; |
||||
uint32_t rotate_period; |
||||
enum msm_vfe_testgen_color_pattern color_bar_pattern; |
||||
uint32_t burst_num_frame; |
||||
}; |
||||
|
||||
enum msm_vfe_inputmux { |
||||
CAMIF, |
||||
TESTGEN, |
||||
EXTERNAL_READ, |
||||
}; |
||||
|
||||
enum msm_vfe_stats_composite_group { |
||||
STATS_COMPOSITE_GRP_NONE, |
||||
STATS_COMPOSITE_GRP_1, |
||||
STATS_COMPOSITE_GRP_2, |
||||
STATS_COMPOSITE_GRP_MAX, |
||||
}; |
||||
|
||||
enum msm_vfe_hvx_streaming_cmd { |
||||
HVX_DISABLE, |
||||
HVX_ONE_WAY, |
||||
HVX_ROUND_TRIP |
||||
}; |
||||
|
||||
struct msm_vfe_pix_cfg { |
||||
struct msm_vfe_camif_cfg camif_cfg; |
||||
struct msm_vfe_testgen_cfg testgen_cfg; |
||||
struct msm_vfe_fetch_engine_cfg fetch_engine_cfg; |
||||
enum msm_vfe_inputmux input_mux; |
||||
enum ISP_START_PIXEL_PATTERN pixel_pattern; |
||||
uint32_t input_format; |
||||
enum msm_vfe_hvx_streaming_cmd hvx_cmd; |
||||
uint32_t is_split; |
||||
}; |
||||
|
||||
struct msm_vfe_rdi_cfg { |
||||
uint8_t cid; |
||||
uint8_t frame_based; |
||||
}; |
||||
|
||||
struct msm_vfe_input_cfg { |
||||
union { |
||||
struct msm_vfe_pix_cfg pix_cfg; |
||||
struct msm_vfe_rdi_cfg rdi_cfg; |
||||
} d; |
||||
enum msm_vfe_input_src input_src; |
||||
uint32_t input_pix_clk; |
||||
}; |
||||
|
||||
struct msm_vfe_fetch_eng_start { |
||||
uint32_t session_id; |
||||
uint32_t stream_id; |
||||
uint32_t buf_idx; |
||||
uint8_t offline_mode; |
||||
uint32_t fd; |
||||
uint32_t buf_addr; |
||||
uint32_t frame_id; |
||||
}; |
||||
|
||||
struct msm_vfe_axi_plane_cfg { |
||||
uint32_t output_width; /*Include padding*/ |
||||
uint32_t output_height; |
||||
uint32_t output_stride; |
||||
uint32_t output_scan_lines; |
||||
uint32_t output_plane_format; /*Y/Cb/Cr/CbCr*/ |
||||
uint32_t plane_addr_offset; |
||||
uint8_t csid_src; /*RDI 0-2*/ |
||||
uint8_t rdi_cid;/*CID 1-16*/ |
||||
}; |
||||
|
||||
enum msm_stream_memory_input_t { |
||||
MEMORY_INPUT_DISABLED, |
||||
MEMORY_INPUT_ENABLED |
||||
}; |
||||
|
||||
struct msm_vfe_axi_stream_request_cmd { |
||||
uint32_t session_id; |
||||
uint32_t stream_id; |
||||
uint32_t vt_enable; |
||||
uint32_t output_format;/*Planar/RAW/Misc*/ |
||||
enum msm_vfe_axi_stream_src stream_src; /*CAMIF/IDEAL/RDIs*/ |
||||
struct msm_vfe_axi_plane_cfg plane_cfg[MAX_PLANES_PER_STREAM]; |
||||
|
||||
uint32_t burst_count; |
||||
uint32_t hfr_mode; |
||||
uint8_t frame_base; |
||||
|
||||
uint32_t init_frame_drop; /*MAX 31 Frames*/ |
||||
enum msm_vfe_frame_skip_pattern frame_skip_pattern; |
||||
uint8_t buf_divert; /* if TRUE no vb2 buf done. */ |
||||
/*Return values*/ |
||||
uint32_t axi_stream_handle; |
||||
uint32_t controllable_output; |
||||
uint32_t burst_len; |
||||
/* Flag indicating memory input stream */ |
||||
enum msm_stream_memory_input_t memory_input; |
||||
}; |
||||
|
||||
struct msm_vfe_axi_stream_release_cmd { |
||||
uint32_t stream_handle; |
||||
}; |
||||
|
||||
enum msm_vfe_axi_stream_cmd { |
||||
STOP_STREAM, |
||||
START_STREAM, |
||||
STOP_IMMEDIATELY, |
||||
}; |
||||
|
||||
struct msm_vfe_axi_stream_cfg_cmd { |
||||
uint8_t num_streams; |
||||
uint32_t stream_handle[VFE_AXI_SRC_MAX]; |
||||
enum msm_vfe_axi_stream_cmd cmd; |
||||
uint8_t sync_frame_id_src; |
||||
}; |
||||
|
||||
enum msm_vfe_axi_stream_update_type { |
||||
ENABLE_STREAM_BUF_DIVERT, |
||||
DISABLE_STREAM_BUF_DIVERT, |
||||
UPDATE_STREAM_FRAMEDROP_PATTERN, |
||||
UPDATE_STREAM_STATS_FRAMEDROP_PATTERN, |
||||
UPDATE_STREAM_AXI_CONFIG, |
||||
UPDATE_STREAM_REQUEST_FRAMES, |
||||
UPDATE_STREAM_ADD_BUFQ, |
||||
UPDATE_STREAM_REMOVE_BUFQ, |
||||
UPDATE_STREAM_SW_FRAME_DROP, |
||||
}; |
||||
|
||||
enum msm_vfe_iommu_type { |
||||
IOMMU_ATTACH, |
||||
IOMMU_DETACH, |
||||
}; |
||||
|
||||
enum msm_vfe_buff_queue_id { |
||||
VFE_BUF_QUEUE_DEFAULT, |
||||
VFE_BUF_QUEUE_SHARED, |
||||
VFE_BUF_QUEUE_MAX, |
||||
}; |
||||
|
||||
struct msm_vfe_axi_stream_cfg_update_info { |
||||
uint32_t stream_handle; |
||||
uint32_t output_format; |
||||
uint32_t user_stream_id; |
||||
uint32_t frame_id; |
||||
enum msm_vfe_frame_skip_pattern skip_pattern; |
||||
struct msm_vfe_axi_plane_cfg plane_cfg[MAX_PLANES_PER_STREAM]; |
||||
struct msm_isp_sw_framskip sw_skip_info; |
||||
}; |
||||
|
||||
struct msm_vfe_axi_halt_cmd { |
||||
uint32_t stop_camif; |
||||
uint32_t overflow_detected; |
||||
uint32_t blocking_halt; |
||||
}; |
||||
|
||||
struct msm_vfe_axi_reset_cmd { |
||||
uint32_t blocking; |
||||
uint32_t frame_id; |
||||
}; |
||||
|
||||
struct msm_vfe_axi_restart_cmd { |
||||
uint32_t enable_camif; |
||||
}; |
||||
|
||||
struct msm_vfe_axi_stream_update_cmd { |
||||
uint32_t num_streams; |
||||
enum msm_vfe_axi_stream_update_type update_type; |
||||
struct msm_vfe_axi_stream_cfg_update_info |
||||
update_info[MSM_ISP_STATS_MAX]; |
||||
}; |
||||
|
||||
struct msm_vfe_smmu_attach_cmd { |
||||
uint32_t security_mode; |
||||
uint32_t iommu_attach_mode; |
||||
}; |
||||
|
||||
struct msm_vfe_stats_stream_request_cmd { |
||||
uint32_t session_id; |
||||
uint32_t stream_id; |
||||
enum msm_isp_stats_type stats_type; |
||||
uint32_t composite_flag; |
||||
uint32_t framedrop_pattern; |
||||
uint32_t init_frame_drop; /*MAX 31 Frames*/ |
||||
uint32_t irq_subsample_pattern; |
||||
uint32_t buffer_offset; |
||||
uint32_t stream_handle; |
||||
}; |
||||
|
||||
struct msm_vfe_stats_stream_release_cmd { |
||||
uint32_t stream_handle; |
||||
}; |
||||
struct msm_vfe_stats_stream_cfg_cmd { |
||||
uint8_t num_streams; |
||||
uint32_t stream_handle[MSM_ISP_STATS_MAX]; |
||||
uint8_t enable; |
||||
uint32_t stats_burst_len; |
||||
}; |
||||
|
||||
enum msm_vfe_reg_cfg_type { |
||||
VFE_WRITE, |
||||
VFE_WRITE_MB, |
||||
VFE_READ, |
||||
VFE_CFG_MASK, |
||||
VFE_WRITE_DMI_16BIT, |
||||
VFE_WRITE_DMI_32BIT, |
||||
VFE_WRITE_DMI_64BIT, |
||||
VFE_READ_DMI_16BIT, |
||||
VFE_READ_DMI_32BIT, |
||||
VFE_READ_DMI_64BIT, |
||||
GET_MAX_CLK_RATE, |
||||
GET_CLK_RATES, |
||||
GET_ISP_ID, |
||||
VFE_HW_UPDATE_LOCK, |
||||
VFE_HW_UPDATE_UNLOCK, |
||||
SET_WM_UB_SIZE, |
||||
SET_UB_POLICY, |
||||
}; |
||||
|
||||
struct msm_vfe_cfg_cmd2 { |
||||
uint16_t num_cfg; |
||||
uint16_t cmd_len; |
||||
void __user *cfg_data; |
||||
void __user *cfg_cmd; |
||||
}; |
||||
|
||||
struct msm_vfe_cfg_cmd_list { |
||||
struct msm_vfe_cfg_cmd2 cfg_cmd; |
||||
struct msm_vfe_cfg_cmd_list *next; |
||||
uint32_t next_size; |
||||
}; |
||||
|
||||
struct msm_vfe_reg_rw_info { |
||||
uint32_t reg_offset; |
||||
uint32_t cmd_data_offset; |
||||
uint32_t len; |
||||
}; |
||||
|
||||
struct msm_vfe_reg_mask_info { |
||||
uint32_t reg_offset; |
||||
uint32_t mask; |
||||
uint32_t val; |
||||
}; |
||||
|
||||
struct msm_vfe_reg_dmi_info { |
||||
uint32_t hi_tbl_offset; /*Optional*/ |
||||
uint32_t lo_tbl_offset; /*Required*/ |
||||
uint32_t len; |
||||
}; |
||||
|
||||
struct msm_vfe_reg_cfg_cmd { |
||||
union { |
||||
struct msm_vfe_reg_rw_info rw_info; |
||||
struct msm_vfe_reg_mask_info mask_info; |
||||
struct msm_vfe_reg_dmi_info dmi_info; |
||||
} u; |
||||
|
||||
enum msm_vfe_reg_cfg_type cmd_type; |
||||
}; |
||||
|
||||
enum vfe_sd_type { |
||||
VFE_SD_0 = 0, |
||||
VFE_SD_1, |
||||
VFE_SD_COMMON, |
||||
VFE_SD_MAX, |
||||
}; |
||||
|
||||
/* When you change the value below, check for the sof event_data size.
|
||||
* V4l2 limits payload to 64 bytes */ |
||||
#define MS_NUM_SLAVE_MAX 1 |
||||
|
||||
/* Usecases when 2 HW need to be related or synced */ |
||||
enum msm_vfe_dual_hw_type { |
||||
DUAL_NONE = 0, |
||||
DUAL_HW_VFE_SPLIT = 1, |
||||
DUAL_HW_MASTER_SLAVE = 2, |
||||
}; |
||||
|
||||
/* Type for 2 INTF when used in Master-Slave mode */ |
||||
enum msm_vfe_dual_hw_ms_type { |
||||
MS_TYPE_NONE, |
||||
MS_TYPE_MASTER, |
||||
MS_TYPE_SLAVE, |
||||
}; |
||||
|
||||
struct msm_isp_set_dual_hw_ms_cmd { |
||||
uint8_t num_src; |
||||
/* Each session can be only one type but multiple intf if YUV cam */ |
||||
enum msm_vfe_dual_hw_ms_type dual_hw_ms_type; |
||||
/* Primary intf is mostly associated with preview.
|
||||
* This primary intf SOF frame_id and timestamp is tracked |
||||
* and used to calculate delta */ |
||||
enum msm_vfe_input_src primary_intf; |
||||
/* input_src array indicates other input INTF that may be Master/Slave.
|
||||
* For these additional intf, frame_id and timestamp are not saved. |
||||
* However, if these are slaves then they will still get their |
||||
* frame_id from Master */ |
||||
enum msm_vfe_input_src input_src[VFE_SRC_MAX]; |
||||
uint32_t sof_delta_threshold; /* In milliseconds. Sent for Master */ |
||||
}; |
||||
|
||||
enum msm_isp_buf_type { |
||||
ISP_PRIVATE_BUF, |
||||
ISP_SHARE_BUF, |
||||
MAX_ISP_BUF_TYPE, |
||||
}; |
||||
|
||||
struct msm_isp_unmap_buf_req { |
||||
uint32_t fd; |
||||
}; |
||||
|
||||
struct msm_isp_buf_request { |
||||
uint32_t session_id; |
||||
uint32_t stream_id; |
||||
uint8_t num_buf; |
||||
uint32_t handle; |
||||
enum msm_isp_buf_type buf_type; |
||||
}; |
||||
|
||||
struct msm_isp_qbuf_plane { |
||||
uint32_t addr; |
||||
uint32_t offset; |
||||
uint32_t length; |
||||
}; |
||||
|
||||
struct msm_isp_qbuf_buffer { |
||||
struct msm_isp_qbuf_plane planes[MAX_PLANES_PER_STREAM]; |
||||
uint32_t num_planes; |
||||
}; |
||||
|
||||
struct msm_isp_qbuf_info { |
||||
uint32_t handle; |
||||
int32_t buf_idx; |
||||
/*Only used for prepare buffer*/ |
||||
struct msm_isp_qbuf_buffer buffer; |
||||
/*Only used for diverted buffer*/ |
||||
uint32_t dirty_buf; |
||||
}; |
||||
|
||||
struct msm_isp_clk_rates { |
||||
uint32_t svs_rate; |
||||
uint32_t nominal_rate; |
||||
uint32_t high_rate; |
||||
}; |
||||
|
||||
struct msm_vfe_axi_src_state { |
||||
enum msm_vfe_input_src input_src; |
||||
uint32_t src_active; |
||||
uint32_t src_frame_id; |
||||
}; |
||||
|
||||
enum msm_isp_event_mask_index { |
||||
ISP_EVENT_MASK_INDEX_STATS_NOTIFY = 0, |
||||
ISP_EVENT_MASK_INDEX_ERROR = 1, |
||||
ISP_EVENT_MASK_INDEX_IOMMU_P_FAULT = 2, |
||||
ISP_EVENT_MASK_INDEX_STREAM_UPDATE_DONE = 3, |
||||
ISP_EVENT_MASK_INDEX_REG_UPDATE = 4, |
||||
ISP_EVENT_MASK_INDEX_SOF = 5, |
||||
ISP_EVENT_MASK_INDEX_BUF_DIVERT = 6, |
||||
ISP_EVENT_MASK_INDEX_COMP_STATS_NOTIFY = 7, |
||||
ISP_EVENT_MASK_INDEX_MASK_FE_READ_DONE = 8, |
||||
ISP_EVENT_MASK_INDEX_BUF_DONE = 9, |
||||
ISP_EVENT_MASK_INDEX_REG_UPDATE_MISSING = 10, |
||||
ISP_EVENT_MASK_INDEX_PING_PONG_MISMATCH = 11, |
||||
ISP_EVENT_MASK_INDEX_BUF_FATAL_ERROR = 12, |
||||
}; |
||||
|
||||
|
||||
#define ISP_EVENT_SUBS_MASK_NONE 0 |
||||
|
||||
#define ISP_EVENT_SUBS_MASK_STATS_NOTIFY \ |
||||
(1 << ISP_EVENT_MASK_INDEX_STATS_NOTIFY) |
||||
|
||||
#define ISP_EVENT_SUBS_MASK_ERROR \ |
||||
(1 << ISP_EVENT_MASK_INDEX_ERROR) |
||||
|
||||
#define ISP_EVENT_SUBS_MASK_IOMMU_P_FAULT \ |
||||
(1 << ISP_EVENT_MASK_INDEX_IOMMU_P_FAULT) |
||||
|
||||
#define ISP_EVENT_SUBS_MASK_STREAM_UPDATE_DONE \ |
||||
(1 << ISP_EVENT_MASK_INDEX_STREAM_UPDATE_DONE) |
||||
|
||||
#define ISP_EVENT_SUBS_MASK_REG_UPDATE \ |
||||
(1 << ISP_EVENT_MASK_INDEX_REG_UPDATE) |
||||
|
||||
#define ISP_EVENT_SUBS_MASK_SOF \ |
||||
(1 << ISP_EVENT_MASK_INDEX_SOF) |
||||
|
||||
#define ISP_EVENT_SUBS_MASK_BUF_DIVERT \ |
||||
(1 << ISP_EVENT_MASK_INDEX_BUF_DIVERT) |
||||
|
||||
#define ISP_EVENT_SUBS_MASK_COMP_STATS_NOTIFY \ |
||||
(1 << ISP_EVENT_MASK_INDEX_COMP_STATS_NOTIFY) |
||||
|
||||
#define ISP_EVENT_SUBS_MASK_FE_READ_DONE \ |
||||
(1 << ISP_EVENT_MASK_INDEX_MASK_FE_READ_DONE) |
||||
|
||||
#define ISP_EVENT_SUBS_MASK_BUF_DONE \ |
||||
(1 << ISP_EVENT_MASK_INDEX_BUF_DONE) |
||||
|
||||
#define ISP_EVENT_SUBS_MASK_REG_UPDATE_MISSING \ |
||||
(1 << ISP_EVENT_MASK_INDEX_REG_UPDATE_MISSING) |
||||
|
||||
#define ISP_EVENT_SUBS_MASK_PING_PONG_MISMATCH \ |
||||
(1 << ISP_EVENT_MASK_INDEX_PING_PONG_MISMATCH) |
||||
|
||||
#define ISP_EVENT_SUBS_MASK_BUF_FATAL_ERROR \ |
||||
(1 << ISP_EVENT_MASK_INDEX_BUF_FATAL_ERROR) |
||||
|
||||
enum msm_isp_event_idx { |
||||
ISP_REG_UPDATE = 0, |
||||
ISP_EPOCH_0 = 1, |
||||
ISP_EPOCH_1 = 2, |
||||
ISP_START_ACK = 3, |
||||
ISP_STOP_ACK = 4, |
||||
ISP_IRQ_VIOLATION = 5, |
||||
ISP_STATS_OVERFLOW = 6, |
||||
ISP_BUF_DONE = 7, |
||||
ISP_FE_RD_DONE = 8, |
||||
ISP_IOMMU_P_FAULT = 9, |
||||
ISP_ERROR = 10, |
||||
ISP_HW_FATAL_ERROR = 11, |
||||
ISP_PING_PONG_MISMATCH = 12, |
||||
ISP_REG_UPDATE_MISSING = 13, |
||||
ISP_BUF_FATAL_ERROR = 14, |
||||
ISP_EVENT_MAX = 15 |
||||
}; |
||||
|
||||
#define ISP_EVENT_OFFSET 8 |
||||
#define ISP_EVENT_BASE (V4L2_EVENT_PRIVATE_START) |
||||
#define ISP_BUF_EVENT_BASE (ISP_EVENT_BASE + (1 << ISP_EVENT_OFFSET)) |
||||
#define ISP_STATS_EVENT_BASE (ISP_EVENT_BASE + (2 << ISP_EVENT_OFFSET)) |
||||
#define ISP_CAMIF_EVENT_BASE (ISP_EVENT_BASE + (3 << ISP_EVENT_OFFSET)) |
||||
#define ISP_STREAM_EVENT_BASE (ISP_EVENT_BASE + (4 << ISP_EVENT_OFFSET)) |
||||
#define ISP_EVENT_REG_UPDATE (ISP_EVENT_BASE + ISP_REG_UPDATE) |
||||
#define ISP_EVENT_EPOCH_0 (ISP_EVENT_BASE + ISP_EPOCH_0) |
||||
#define ISP_EVENT_EPOCH_1 (ISP_EVENT_BASE + ISP_EPOCH_1) |
||||
#define ISP_EVENT_START_ACK (ISP_EVENT_BASE + ISP_START_ACK) |
||||
#define ISP_EVENT_STOP_ACK (ISP_EVENT_BASE + ISP_STOP_ACK) |
||||
#define ISP_EVENT_IRQ_VIOLATION (ISP_EVENT_BASE + ISP_IRQ_VIOLATION) |
||||
#define ISP_EVENT_STATS_OVERFLOW (ISP_EVENT_BASE + ISP_STATS_OVERFLOW) |
||||
#define ISP_EVENT_ERROR (ISP_EVENT_BASE + ISP_ERROR) |
||||
#define ISP_EVENT_SOF (ISP_CAMIF_EVENT_BASE) |
||||
#define ISP_EVENT_EOF (ISP_CAMIF_EVENT_BASE + 1) |
||||
#define ISP_EVENT_BUF_DONE (ISP_EVENT_BASE + ISP_BUF_DONE) |
||||
#define ISP_EVENT_BUF_DIVERT (ISP_BUF_EVENT_BASE) |
||||
#define ISP_EVENT_STATS_NOTIFY (ISP_STATS_EVENT_BASE) |
||||
#define ISP_EVENT_COMP_STATS_NOTIFY (ISP_EVENT_STATS_NOTIFY + MSM_ISP_STATS_MAX) |
||||
#define ISP_EVENT_FE_READ_DONE (ISP_EVENT_BASE + ISP_FE_RD_DONE) |
||||
#define ISP_EVENT_IOMMU_P_FAULT (ISP_EVENT_BASE + ISP_IOMMU_P_FAULT) |
||||
#define ISP_EVENT_HW_FATAL_ERROR (ISP_EVENT_BASE + ISP_HW_FATAL_ERROR) |
||||
#define ISP_EVENT_PING_PONG_MISMATCH (ISP_EVENT_BASE + ISP_PING_PONG_MISMATCH) |
||||
#define ISP_EVENT_REG_UPDATE_MISSING (ISP_EVENT_BASE + ISP_REG_UPDATE_MISSING) |
||||
#define ISP_EVENT_BUF_FATAL_ERROR (ISP_EVENT_BASE + ISP_BUF_FATAL_ERROR) |
||||
#define ISP_EVENT_STREAM_UPDATE_DONE (ISP_STREAM_EVENT_BASE) |
||||
|
||||
/* The msm_v4l2_event_data structure should match the
|
||||
* v4l2_event.u.data field. |
||||
* should not exceed 64 bytes */ |
||||
|
||||
struct msm_isp_buf_event { |
||||
uint32_t session_id; |
||||
uint32_t stream_id; |
||||
uint32_t handle; |
||||
uint32_t output_format; |
||||
int8_t buf_idx; |
||||
}; |
||||
struct msm_isp_fetch_eng_event { |
||||
uint32_t session_id; |
||||
uint32_t stream_id; |
||||
uint32_t handle; |
||||
uint32_t fd; |
||||
int8_t buf_idx; |
||||
int8_t offline_mode; |
||||
}; |
||||
struct msm_isp_stats_event { |
||||
uint32_t stats_mask; /* 4 bytes */ |
||||
uint8_t stats_buf_idxs[MSM_ISP_STATS_MAX]; /* 11 bytes */ |
||||
}; |
||||
|
||||
struct msm_isp_stream_ack { |
||||
uint32_t session_id; |
||||
uint32_t stream_id; |
||||
uint32_t handle; |
||||
}; |
||||
|
||||
enum msm_vfe_error_type { |
||||
ISP_ERROR_NONE, |
||||
ISP_ERROR_CAMIF, |
||||
ISP_ERROR_BUS_OVERFLOW, |
||||
ISP_ERROR_RETURN_EMPTY_BUFFER, |
||||
ISP_ERROR_FRAME_ID_MISMATCH, |
||||
ISP_ERROR_MAX, |
||||
}; |
||||
|
||||
struct msm_isp_error_info { |
||||
enum msm_vfe_error_type err_type; |
||||
uint32_t session_id; |
||||
uint32_t stream_id; |
||||
uint32_t stream_id_mask; |
||||
}; |
||||
|
||||
/* This structure reports delta between master and slave */ |
||||
struct msm_isp_ms_delta_info { |
||||
uint8_t num_delta_info; |
||||
uint32_t delta[MS_NUM_SLAVE_MAX]; |
||||
}; |
||||
|
||||
/* This is sent in EPOCH irq */ |
||||
struct msm_isp_output_info { |
||||
uint8_t regs_not_updated; |
||||
/* mask with bufq_handle for regs not updated or return empty */ |
||||
uint16_t output_err_mask; |
||||
/* mask with stream_idx for get_buf failed */ |
||||
uint8_t stream_framedrop_mask; |
||||
/* mask with stats stream_idx for get_buf failed */ |
||||
uint16_t stats_framedrop_mask; |
||||
/* delta between master and slave */ |
||||
}; |
||||
|
||||
/* This structure is piggybacked with SOF event */ |
||||
struct msm_isp_sof_info { |
||||
uint8_t regs_not_updated; |
||||
/* mask with AXI_SRC for regs not updated */ |
||||
uint16_t reg_update_fail_mask; |
||||
/* mask with bufq_handle for get_buf failed */ |
||||
uint32_t stream_get_buf_fail_mask; |
||||
/* mask with stats stream_idx for get_buf failed */ |
||||
uint16_t stats_get_buf_fail_mask; |
||||
/* delta between master and slave */ |
||||
struct msm_isp_ms_delta_info ms_delta_info; |
||||
}; |
||||
|
||||
struct msm_isp_event_data { |
||||
/*Wall clock except for buffer divert events
|
||||
*which use monotonic clock |
||||
*/ |
||||
struct timeval timestamp; |
||||
/* Monotonic timestamp since bootup */ |
||||
struct timeval mono_timestamp; |
||||
uint32_t frame_id; |
||||
union { |
||||
/* Sent for Stats_Done event */ |
||||
struct msm_isp_stats_event stats; |
||||
/* Sent for Buf_Divert event */ |
||||
struct msm_isp_buf_event buf_done; |
||||
/* Sent for offline fetch done event */ |
||||
struct msm_isp_fetch_eng_event fetch_done; |
||||
/* Sent for Error_Event */ |
||||
struct msm_isp_error_info error_info; |
||||
/*
|
||||
* This struct needs to be removed once |
||||
* userspace switches to sof_info |
||||
*/ |
||||
struct msm_isp_output_info output_info; |
||||
/* Sent for SOF event */ |
||||
struct msm_isp_sof_info sof_info; |
||||
} u; /* union can have max 52 bytes */ |
||||
}; |
||||
|
||||
#ifdef CONFIG_COMPAT |
||||
struct msm_isp_event_data32 { |
||||
struct compat_timeval timestamp; |
||||
struct compat_timeval mono_timestamp; |
||||
uint32_t frame_id; |
||||
union { |
||||
struct msm_isp_stats_event stats; |
||||
struct msm_isp_buf_event buf_done; |
||||
struct msm_isp_fetch_eng_event fetch_done; |
||||
struct msm_isp_error_info error_info; |
||||
struct msm_isp_output_info output_info; |
||||
struct msm_isp_sof_info sof_info; |
||||
} u; |
||||
}; |
||||
#endif |
||||
|
||||
#define V4L2_PIX_FMT_QBGGR8 v4l2_fourcc('Q', 'B', 'G', '8') |
||||
#define V4L2_PIX_FMT_QGBRG8 v4l2_fourcc('Q', 'G', 'B', '8') |
||||
#define V4L2_PIX_FMT_QGRBG8 v4l2_fourcc('Q', 'G', 'R', '8') |
||||
#define V4L2_PIX_FMT_QRGGB8 v4l2_fourcc('Q', 'R', 'G', '8') |
||||
#define V4L2_PIX_FMT_QBGGR10 v4l2_fourcc('Q', 'B', 'G', '0') |
||||
#define V4L2_PIX_FMT_QGBRG10 v4l2_fourcc('Q', 'G', 'B', '0') |
||||
#define V4L2_PIX_FMT_QGRBG10 v4l2_fourcc('Q', 'G', 'R', '0') |
||||
#define V4L2_PIX_FMT_QRGGB10 v4l2_fourcc('Q', 'R', 'G', '0') |
||||
#define V4L2_PIX_FMT_QBGGR12 v4l2_fourcc('Q', 'B', 'G', '2') |
||||
#define V4L2_PIX_FMT_QGBRG12 v4l2_fourcc('Q', 'G', 'B', '2') |
||||
#define V4L2_PIX_FMT_QGRBG12 v4l2_fourcc('Q', 'G', 'R', '2') |
||||
#define V4L2_PIX_FMT_QRGGB12 v4l2_fourcc('Q', 'R', 'G', '2') |
||||
#define V4L2_PIX_FMT_QBGGR14 v4l2_fourcc('Q', 'B', 'G', '4') |
||||
#define V4L2_PIX_FMT_QGBRG14 v4l2_fourcc('Q', 'G', 'B', '4') |
||||
#define V4L2_PIX_FMT_QGRBG14 v4l2_fourcc('Q', 'G', 'R', '4') |
||||
#define V4L2_PIX_FMT_QRGGB14 v4l2_fourcc('Q', 'R', 'G', '4') |
||||
#define V4L2_PIX_FMT_P16BGGR10 v4l2_fourcc('P', 'B', 'G', '0') |
||||
#define V4L2_PIX_FMT_P16GBRG10 v4l2_fourcc('P', 'G', 'B', '0') |
||||
#define V4L2_PIX_FMT_P16GRBG10 v4l2_fourcc('P', 'G', 'R', '0') |
||||
#define V4L2_PIX_FMT_P16RGGB10 v4l2_fourcc('P', 'R', 'G', '0') |
||||
#define V4L2_PIX_FMT_NV14 v4l2_fourcc('N', 'V', '1', '4') |
||||
#define V4L2_PIX_FMT_NV41 v4l2_fourcc('N', 'V', '4', '1') |
||||
#define V4L2_PIX_FMT_META v4l2_fourcc('Q', 'M', 'E', 'T') |
||||
#define V4L2_PIX_FMT_SBGGR14 v4l2_fourcc('B', 'G', '1', '4') /* 14 BGBG.GRGR.*/ |
||||
#define V4L2_PIX_FMT_SGBRG14 v4l2_fourcc('G', 'B', '1', '4') /* 14 GBGB.RGRG.*/ |
||||
#define V4L2_PIX_FMT_SGRBG14 v4l2_fourcc('B', 'A', '1', '4') /* 14 GRGR.BGBG.*/ |
||||
#define V4L2_PIX_FMT_SRGGB14 v4l2_fourcc('R', 'G', '1', '4') /* 14 RGRG.GBGB.*/ |
||||
|
||||
#define VIDIOC_MSM_VFE_REG_CFG \ |
||||
_IOWR('V', BASE_VIDIOC_PRIVATE, struct msm_vfe_cfg_cmd2) |
||||
|
||||
#define VIDIOC_MSM_ISP_REQUEST_BUF \ |
||||
_IOWR('V', BASE_VIDIOC_PRIVATE+1, struct msm_isp_buf_request) |
||||
|
||||
#define VIDIOC_MSM_ISP_ENQUEUE_BUF \ |
||||
_IOWR('V', BASE_VIDIOC_PRIVATE+2, struct msm_isp_qbuf_info) |
||||
|
||||
#define VIDIOC_MSM_ISP_RELEASE_BUF \ |
||||
_IOWR('V', BASE_VIDIOC_PRIVATE+3, struct msm_isp_buf_request) |
||||
|
||||
#define VIDIOC_MSM_ISP_REQUEST_STREAM \ |
||||
_IOWR('V', BASE_VIDIOC_PRIVATE+4, struct msm_vfe_axi_stream_request_cmd) |
||||
|
||||
#define VIDIOC_MSM_ISP_CFG_STREAM \ |
||||
_IOWR('V', BASE_VIDIOC_PRIVATE+5, struct msm_vfe_axi_stream_cfg_cmd) |
||||
|
||||
#define VIDIOC_MSM_ISP_RELEASE_STREAM \ |
||||
_IOWR('V', BASE_VIDIOC_PRIVATE+6, struct msm_vfe_axi_stream_release_cmd) |
||||
|
||||
#define VIDIOC_MSM_ISP_INPUT_CFG \ |
||||
_IOWR('V', BASE_VIDIOC_PRIVATE+7, struct msm_vfe_input_cfg) |
||||
|
||||
#define VIDIOC_MSM_ISP_SET_SRC_STATE \ |
||||
_IOWR('V', BASE_VIDIOC_PRIVATE+8, struct msm_vfe_axi_src_state) |
||||
|
||||
#define VIDIOC_MSM_ISP_REQUEST_STATS_STREAM \ |
||||
_IOWR('V', BASE_VIDIOC_PRIVATE+9, \
|
||||
struct msm_vfe_stats_stream_request_cmd) |
||||
|
||||
#define VIDIOC_MSM_ISP_CFG_STATS_STREAM \ |
||||
_IOWR('V', BASE_VIDIOC_PRIVATE+10, struct msm_vfe_stats_stream_cfg_cmd) |
||||
|
||||
#define VIDIOC_MSM_ISP_RELEASE_STATS_STREAM \ |
||||
_IOWR('V', BASE_VIDIOC_PRIVATE+11, \
|
||||
struct msm_vfe_stats_stream_release_cmd) |
||||
|
||||
#define VIDIOC_MSM_ISP_REG_UPDATE_CMD \ |
||||
_IOWR('V', BASE_VIDIOC_PRIVATE+12, enum msm_vfe_input_src) |
||||
|
||||
#define VIDIOC_MSM_ISP_UPDATE_STREAM \ |
||||
_IOWR('V', BASE_VIDIOC_PRIVATE+13, struct msm_vfe_axi_stream_update_cmd) |
||||
|
||||
#define VIDIOC_MSM_VFE_REG_LIST_CFG \ |
||||
_IOWR('V', BASE_VIDIOC_PRIVATE+14, struct msm_vfe_cfg_cmd_list) |
||||
|
||||
#define VIDIOC_MSM_ISP_SMMU_ATTACH \ |
||||
_IOWR('V', BASE_VIDIOC_PRIVATE+15, struct msm_vfe_smmu_attach_cmd) |
||||
|
||||
#define VIDIOC_MSM_ISP_UPDATE_STATS_STREAM \ |
||||
_IOWR('V', BASE_VIDIOC_PRIVATE+16, struct msm_vfe_axi_stream_update_cmd) |
||||
|
||||
#define VIDIOC_MSM_ISP_AXI_HALT \ |
||||
_IOWR('V', BASE_VIDIOC_PRIVATE+17, struct msm_vfe_axi_halt_cmd) |
||||
|
||||
#define VIDIOC_MSM_ISP_AXI_RESET \ |
||||
_IOWR('V', BASE_VIDIOC_PRIVATE+18, struct msm_vfe_axi_reset_cmd) |
||||
|
||||
#define VIDIOC_MSM_ISP_AXI_RESTART \ |
||||
_IOWR('V', BASE_VIDIOC_PRIVATE+19, struct msm_vfe_axi_restart_cmd) |
||||
|
||||
#define VIDIOC_MSM_ISP_FETCH_ENG_START \ |
||||
_IOWR('V', BASE_VIDIOC_PRIVATE+20, struct msm_vfe_fetch_eng_start) |
||||
|
||||
#define VIDIOC_MSM_ISP_DEQUEUE_BUF \ |
||||
_IOWR('V', BASE_VIDIOC_PRIVATE+21, struct msm_isp_qbuf_info) |
||||
|
||||
#define VIDIOC_MSM_ISP_SET_DUAL_HW_MASTER_SLAVE \ |
||||
_IOWR('V', BASE_VIDIOC_PRIVATE+22, struct msm_isp_set_dual_hw_ms_cmd) |
||||
|
||||
#define VIDIOC_MSM_ISP_MAP_BUF_START_FE \ |
||||
_IOWR('V', BASE_VIDIOC_PRIVATE+23, struct msm_vfe_fetch_eng_start) |
||||
|
||||
#define VIDIOC_MSM_ISP_UNMAP_BUF \ |
||||
_IOWR('V', BASE_VIDIOC_PRIVATE+24, struct msm_isp_unmap_buf_req) |
||||
|
||||
#endif /* __MSMB_ISP__ */ |
||||
@ -0,0 +1,125 @@ |
||||
#ifndef MSM_CAM_ISPIF_H |
||||
#define MSM_CAM_ISPIF_H |
||||
|
||||
#define CSID_VERSION_V20 0x02000011 |
||||
#define CSID_VERSION_V22 0x02001000 |
||||
#define CSID_VERSION_V30 0x30000000 |
||||
#define CSID_VERSION_V3 0x30000000 |
||||
|
||||
enum msm_ispif_vfe_intf { |
||||
VFE0, |
||||
VFE1, |
||||
VFE_MAX |
||||
}; |
||||
#define VFE0_MASK (1 << VFE0) |
||||
#define VFE1_MASK (1 << VFE1) |
||||
|
||||
enum msm_ispif_intftype { |
||||
PIX0, |
||||
RDI0, |
||||
PIX1, |
||||
RDI1, |
||||
RDI2, |
||||
INTF_MAX |
||||
}; |
||||
#define MAX_PARAM_ENTRIES (INTF_MAX * 2) |
||||
#define MAX_CID_CH 8 |
||||
|
||||
#define PIX0_MASK (1 << PIX0) |
||||
#define PIX1_MASK (1 << PIX1) |
||||
#define RDI0_MASK (1 << RDI0) |
||||
#define RDI1_MASK (1 << RDI1) |
||||
#define RDI2_MASK (1 << RDI2) |
||||
|
||||
|
||||
enum msm_ispif_vc { |
||||
VC0, |
||||
VC1, |
||||
VC2, |
||||
VC3, |
||||
VC_MAX |
||||
}; |
||||
|
||||
enum msm_ispif_cid { |
||||
CID0, |
||||
CID1, |
||||
CID2, |
||||
CID3, |
||||
CID4, |
||||
CID5, |
||||
CID6, |
||||
CID7, |
||||
CID8, |
||||
CID9, |
||||
CID10, |
||||
CID11, |
||||
CID12, |
||||
CID13, |
||||
CID14, |
||||
CID15, |
||||
CID_MAX |
||||
}; |
||||
|
||||
enum msm_ispif_csid { |
||||
CSID0, |
||||
CSID1, |
||||
CSID2, |
||||
CSID3, |
||||
CSID_MAX |
||||
}; |
||||
|
||||
struct msm_ispif_params_entry { |
||||
enum msm_ispif_vfe_intf vfe_intf; |
||||
enum msm_ispif_intftype intftype; |
||||
int num_cids; |
||||
enum msm_ispif_cid cids[3]; |
||||
enum msm_ispif_csid csid; |
||||
int crop_enable; |
||||
uint16_t crop_start_pixel; |
||||
uint16_t crop_end_pixel; |
||||
}; |
||||
|
||||
struct msm_ispif_param_data { |
||||
uint32_t num; |
||||
struct msm_ispif_params_entry entries[MAX_PARAM_ENTRIES]; |
||||
}; |
||||
|
||||
struct msm_isp_info { |
||||
uint32_t max_resolution; |
||||
uint32_t id; |
||||
uint32_t ver; |
||||
}; |
||||
|
||||
struct msm_ispif_vfe_info { |
||||
int num_vfe; |
||||
struct msm_isp_info info[VFE_MAX]; |
||||
}; |
||||
|
||||
enum ispif_cfg_type_t { |
||||
ISPIF_CLK_ENABLE, |
||||
ISPIF_CLK_DISABLE, |
||||
ISPIF_INIT, |
||||
ISPIF_CFG, |
||||
ISPIF_START_FRAME_BOUNDARY, |
||||
ISPIF_RESTART_FRAME_BOUNDARY, |
||||
ISPIF_STOP_FRAME_BOUNDARY, |
||||
ISPIF_STOP_IMMEDIATELY, |
||||
ISPIF_RELEASE, |
||||
ISPIF_ENABLE_REG_DUMP, |
||||
ISPIF_SET_VFE_INFO, |
||||
}; |
||||
|
||||
struct ispif_cfg_data { |
||||
enum ispif_cfg_type_t cfg_type; |
||||
union { |
||||
int reg_dump; /* ISPIF_ENABLE_REG_DUMP */ |
||||
uint32_t csid_version; /* ISPIF_INIT */ |
||||
struct msm_ispif_vfe_info vfe_info; /* ISPIF_SET_VFE_INFO */ |
||||
struct msm_ispif_param_data params; /* CFG, START, STOP */ |
||||
}; |
||||
}; |
||||
|
||||
#define VIDIOC_MSM_ISPIF_CFG \ |
||||
_IOWR('V', BASE_VIDIOC_PRIVATE, struct ispif_cfg_data) |
||||
|
||||
#endif /* MSM_CAM_ISPIF_H */ |
||||
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,72 @@ |
||||
#!/usr/bin/env python3 |
||||
import os |
||||
import json |
||||
import signal |
||||
import subprocess |
||||
import time |
||||
from PIL import Image |
||||
from common.basedir import BASEDIR |
||||
from common.params import Params |
||||
from selfdrive.camerad.snapshot.visionipc import VisionIPC |
||||
|
||||
with open(BASEDIR + "/selfdrive/controls/lib/alerts_offroad.json") as json_file: |
||||
OFFROAD_ALERTS = json.load(json_file) |
||||
|
||||
|
||||
def jpeg_write(fn, dat): |
||||
img = Image.fromarray(dat) |
||||
img.save(fn, "JPEG") |
||||
|
||||
|
||||
def snapshot(): |
||||
params = Params() |
||||
front_camera_allowed = int(params.get("RecordFront")) |
||||
|
||||
params.put("IsTakingSnapshot", "1") |
||||
params.put("Offroad_IsTakingSnapshot", json.dumps(OFFROAD_ALERTS["Offroad_IsTakingSnapshot"])) |
||||
time.sleep(2.0) # Give thermald time to read the param, or if just started give camerad time to start |
||||
|
||||
# Check if camerad is already started |
||||
ps = subprocess.Popen("ps | grep camerad", shell=True, stdout=subprocess.PIPE) |
||||
ret = list(filter(lambda x: 'grep ' not in x, ps.communicate()[0].decode('utf-8').strip().split("\n"))) |
||||
if len(ret) > 0: |
||||
params.put("IsTakingSnapshot", "0") |
||||
params.delete("Offroad_IsTakingSnapshot") |
||||
return None |
||||
|
||||
proc = subprocess.Popen(os.path.join(BASEDIR, "selfdrive/camerad/camerad"), cwd=os.path.join(BASEDIR, "selfdrive/camerad")) |
||||
time.sleep(3.0) |
||||
|
||||
ret = None |
||||
start_time = time.time() |
||||
while time.time() - start_time < 5.0: |
||||
try: |
||||
ipc = VisionIPC() |
||||
pic = ipc.get() |
||||
del ipc |
||||
|
||||
if front_camera_allowed: |
||||
ipc_front = VisionIPC(front=True) |
||||
fpic = ipc_front.get() |
||||
del ipc_front |
||||
else: |
||||
fpic = None |
||||
|
||||
ret = pic, fpic |
||||
break |
||||
except Exception: |
||||
time.sleep(1) |
||||
|
||||
proc.send_signal(signal.SIGINT) |
||||
proc.communicate() |
||||
|
||||
params.put("IsTakingSnapshot", "0") |
||||
params.delete("Offroad_IsTakingSnapshot") |
||||
return ret |
||||
|
||||
|
||||
if __name__ == "__main__": |
||||
pic, fpic = snapshot() |
||||
print(pic.shape) |
||||
jpeg_write("/tmp/back.jpg", pic) |
||||
jpeg_write("/tmp/front.jpg", fpic) |
||||
@ -0,0 +1,93 @@ |
||||
#!/usr/bin/env python3 |
||||
import os |
||||
from cffi import FFI |
||||
|
||||
import numpy as np |
||||
|
||||
gf_dir = os.path.dirname(os.path.abspath(__file__)) |
||||
|
||||
ffi = FFI() |
||||
ffi.cdef(""" |
||||
|
||||
typedef enum VisionStreamType { |
||||
VISION_STREAM_RGB_BACK, |
||||
VISION_STREAM_RGB_FRONT, |
||||
VISION_STREAM_YUV, |
||||
VISION_STREAM_YUV_FRONT, |
||||
VISION_STREAM_MAX, |
||||
} VisionStreamType; |
||||
|
||||
typedef struct VisionUIInfo { |
||||
int big_box_x, big_box_y; |
||||
int big_box_width, big_box_height; |
||||
int transformed_width, transformed_height; |
||||
|
||||
int front_box_x, front_box_y; |
||||
int front_box_width, front_box_height; |
||||
} VisionUIInfo; |
||||
|
||||
typedef struct VisionStreamBufs { |
||||
VisionStreamType type; |
||||
|
||||
int width, height, stride; |
||||
size_t buf_len; |
||||
|
||||
union { |
||||
VisionUIInfo ui_info; |
||||
} buf_info; |
||||
} VisionStreamBufs; |
||||
|
||||
typedef struct VIPCBuf { |
||||
int fd; |
||||
size_t len; |
||||
void* addr; |
||||
} VIPCBuf; |
||||
|
||||
typedef struct VIPCBufExtra { |
||||
// only for yuv |
||||
uint32_t frame_id; |
||||
uint64_t timestamp_eof; |
||||
} VIPCBufExtra; |
||||
|
||||
typedef struct VisionStream { |
||||
int ipc_fd; |
||||
int last_idx; |
||||
int last_type; |
||||
int num_bufs; |
||||
VisionStreamBufs bufs_info; |
||||
VIPCBuf *bufs; |
||||
} VisionStream; |
||||
|
||||
int visionstream_init(VisionStream *s, VisionStreamType type, bool tbuffer, VisionStreamBufs *out_bufs_info); |
||||
VIPCBuf* visionstream_get(VisionStream *s, VIPCBufExtra *out_extra); |
||||
void visionstream_destroy(VisionStream *s); |
||||
|
||||
""" |
||||
) |
||||
|
||||
|
||||
class VisionIPCError(Exception): |
||||
pass |
||||
|
||||
|
||||
class VisionIPC(): |
||||
def __init__(self, front=False): |
||||
self.clib = ffi.dlopen(os.path.join(gf_dir, "libvisionipc.so")) |
||||
|
||||
self.s = ffi.new("VisionStream*") |
||||
self.buf_info = ffi.new("VisionStreamBufs*") |
||||
|
||||
err = self.clib.visionstream_init(self.s, self.clib.VISION_STREAM_RGB_FRONT if front else self.clib.VISION_STREAM_RGB_BACK, True, self.buf_info) |
||||
|
||||
if err != 0: |
||||
self.clib.visionstream_destroy(self.s) |
||||
raise VisionIPCError |
||||
|
||||
def __del__(self): |
||||
self.clib.visionstream_destroy(self.s) |
||||
|
||||
def get(self): |
||||
buf = self.clib.visionstream_get(self.s, ffi.NULL) |
||||
pbuf = ffi.buffer(buf.addr, buf.len) |
||||
ret = np.frombuffer(pbuf, dtype=np.uint8).reshape((-1, self.buf_info.stride//3, 3)) |
||||
return ret[:self.buf_info.height, :self.buf_info.width, [2,1,0]] |
||||
@ -0,0 +1,48 @@ |
||||
#include <stdio.h> |
||||
#include <stdarg.h> |
||||
#include <stdbool.h> |
||||
|
||||
#include "camera_qcom.h" |
||||
|
||||
bool do_exit = false; |
||||
|
||||
void cloudlog_e(int levelnum, const char* filename, int lineno, const char* func, |
||||
const char* fmt, ...) { |
||||
va_list args; |
||||
va_start(args, fmt); |
||||
vprintf(fmt, args); |
||||
printf("\n"); |
||||
} |
||||
|
||||
void set_thread_name(const char* name) { |
||||
} |
||||
|
||||
// tbuffers
|
||||
|
||||
void tbuffer_init2(TBuffer *tb, int num_bufs, const char* name, |
||||
void (*release_cb)(void* c, int idx), |
||||
void* cb_cookie) { |
||||
printf("tbuffer_init2\n"); |
||||
} |
||||
|
||||
void tbuffer_dispatch(TBuffer *tb, int idx) { |
||||
printf("tbuffer_dispatch\n"); |
||||
} |
||||
|
||||
void tbuffer_stop(TBuffer *tb) { |
||||
printf("tbuffer_stop\n"); |
||||
} |
||||
|
||||
int main() { |
||||
DualCameraState s; |
||||
cameras_init(&s); |
||||
VisionBuf camera_bufs_rear[0x10] = {0}; |
||||
VisionBuf camera_bufs_focus[0x10] = {0}; |
||||
VisionBuf camera_bufs_stats[0x10] = {0}; |
||||
VisionBuf camera_bufs_front[0x10] = {0}; |
||||
cameras_open(&s, |
||||
camera_bufs_rear, camera_bufs_focus, |
||||
camera_bufs_stats, camera_bufs_front); |
||||
cameras_close(&s); |
||||
} |
||||
|
||||
@ -0,0 +1,10 @@ |
||||
#!/bin/sh |
||||
|
||||
gcc -DQCOM -I ~/one -I ~/one/selfdrive -I ../../include \ |
||||
-I ~/one/phonelibs/android_system_core/include -I ~/one/phonelibs/opencl/include \ |
||||
-I ~/one/selfdrive/visiond/cameras \ |
||||
test.c ../../cameras/camera_qcom.c \ |
||||
-l:libczmq.a -l:libzmq.a -lgnustl_shared -lm -llog -lcutils \ |
||||
-l:libcapn.a -l:libcapnp.a -l:libkj.a \ |
||||
~/one/cereal/gen/c/log.capnp.o |
||||
|
||||
@ -0,0 +1,40 @@ |
||||
#!/usr/bin/env python3 |
||||
import time |
||||
import numpy as np |
||||
import cereal.messaging as messaging |
||||
from PIL import ImageFont, ImageDraw, Image |
||||
|
||||
font = ImageFont.truetype("arial", size=72) |
||||
def get_frame(idx): |
||||
img = np.zeros((874, 1164, 3), np.uint8) |
||||
img[100:400, 100:100+(idx%10)*100] = 255 |
||||
|
||||
# big number |
||||
im2 = Image.new("RGB", (200,200)) |
||||
draw = ImageDraw.Draw(im2) |
||||
draw.text((10, 100), "%02d" % idx, font=font) |
||||
img[400:600, 400:600] = np.array(im2.getdata()).reshape((200,200,3)) |
||||
return img.tostring() |
||||
|
||||
if __name__ == "__main__": |
||||
from common.realtime import Ratekeeper |
||||
rk = Ratekeeper(20) |
||||
|
||||
pm = messaging.PubMaster(['frame']) |
||||
frm = [get_frame(x) for x in range(30)] |
||||
idx = 0 |
||||
while 1: |
||||
print("send %d" % idx) |
||||
dat = messaging.new_message() |
||||
dat.init('frame') |
||||
dat.valid = True |
||||
dat.frame = { |
||||
"frameId": idx, |
||||
"image": frm[idx%len(frm)], |
||||
} |
||||
pm.send('frame', dat) |
||||
|
||||
idx += 1 |
||||
rk.keep_time() |
||||
#time.sleep(1.0) |
||||
|
||||
@ -0,0 +1,9 @@ |
||||
#!/bin/sh |
||||
cd .. |
||||
while :; do |
||||
./camerad & |
||||
pid="$!" |
||||
sleep 2 |
||||
kill -2 $pid |
||||
wait $pid |
||||
done |
||||
@ -0,0 +1,57 @@ |
||||
CC = clang
|
||||
CXX = clang++
|
||||
|
||||
PHONELIBS = ../../../../phonelibs
|
||||
|
||||
WARN_FLAGS = -Werror=implicit-function-declaration \
|
||||
-Werror=incompatible-pointer-types \
|
||||
-Werror=int-conversion \
|
||||
-Werror=return-type \
|
||||
-Werror=format-extra-args \
|
||||
-Wno-deprecated-declarations
|
||||
|
||||
CFLAGS = -std=gnu11 -fPIC -O2 $(WARN_FLAGS)
|
||||
|
||||
UNAME_M := $(shell uname -m)
|
||||
ifeq ($(UNAME_M),x86_64) |
||||
OPENCL_LIBS = -framework OpenCL
|
||||
else |
||||
OPENCL_FLAGS = -I$(PHONELIBS)/opencl/include
|
||||
OPENCL_LIBS = -L/system/vendor/lib64 -lgsl -lCB -lOpenCL
|
||||
endif |
||||
|
||||
OBJS += yuv_bench.o \
|
||||
../../../common/util.o \
|
||||
../../clutil.o
|
||||
|
||||
OUTPUT = yuv
|
||||
|
||||
.PHONY: all |
||||
all: $(OUTPUT) |
||||
|
||||
$(OUTPUT): $(OBJS) |
||||
@echo "[ LINK ] $@"
|
||||
$(CXX) -fPIC -o '$@' $^ \
|
||||
-L/usr/lib \
|
||||
$(OPENCL_LIBS)
|
||||
|
||||
|
||||
%.o: %.cc |
||||
@echo "[ CXX ] $@"
|
||||
$(CXX) $(CXXFLAGS) -MMD \
|
||||
-I../.. -I../../.. -I ../../../.. \
|
||||
$(OPENCL_FLAGS) \
|
||||
-c -o '$@' '$<'
|
||||
|
||||
|
||||
%.o: %.c |
||||
@echo "[ CC ] $@"
|
||||
$(CC) $(CFLAGS) -MMD \
|
||||
-I../.. -I../../.. -I ../../../.. \
|
||||
$(OPENCL_FLAGS) \
|
||||
-c -o '$@' '$<'
|
||||
|
||||
.PHONY: clean |
||||
clean: |
||||
rm -f $(OUTPUT) $(OBJS) $(DEPS)
|
||||
|
||||
@ -0,0 +1,19 @@ |
||||
import numpy as np |
||||
import cv2 |
||||
|
||||
# img_bgr = np.zeros((874, 1164, 3), dtype=np.uint8) |
||||
# for y in range(874): |
||||
# for k in range(1164*3): |
||||
# img_bgr[y, k//3, k%3] = k ^ y |
||||
|
||||
# cv2.imwrite("img_rgb.png", img_bgr) |
||||
|
||||
|
||||
cl = np.fromstring(open("out_cl.bin", "rb").read(), dtype=np.uint8) |
||||
|
||||
cl_r = cl.reshape(874 * 3 // 2, -1) |
||||
|
||||
cv2.imwrite("out_y.png", cl_r[:874]) |
||||
|
||||
cl_bgr = cv2.cvtColor(cl_r, cv2.COLOR_YUV2BGR_I420) |
||||
cv2.imwrite("out_cl.png", cl_bgr) |
||||
@ -0,0 +1,116 @@ |
||||
|
||||
#define PIX_PER_WI_X 1 |
||||
#define PIX_PER_WI_Y 1 |
||||
|
||||
#define scn 3 |
||||
#define bidx 2 |
||||
#define uidx 0 |
||||
|
||||
#define R_COMP x |
||||
#define G_COMP y |
||||
#define B_COMP z |
||||
|
||||
__constant float c_RGB2YUVCoeffs_420[8] = { 0.256999969f, 0.50399971f, 0.09799957f, -0.1479988098f, -0.2909994125f, |
||||
0.438999176f, -0.3679990768f, -0.0709991455f }; |
||||
|
||||
__kernel void RGB2YUV_YV12_IYUV(__global const uchar* srcptr, int src_step, int src_offset, |
||||
__global uchar* dstptr, int dst_step, int dst_offset, |
||||
int rows, int cols) |
||||
{ |
||||
int x = get_global_id(0) * PIX_PER_WI_X; |
||||
int y = get_global_id(1) * PIX_PER_WI_Y; |
||||
|
||||
if (x < cols/2) |
||||
{ |
||||
int src_index = mad24(y << 1, src_step, mad24(x << 1, scn, src_offset)); |
||||
int ydst_index = mad24(y << 1, dst_step, (x << 1) + dst_offset); |
||||
int y_rows = rows / 3 * 2; |
||||
int vsteps[2] = { cols >> 1, dst_step - (cols >> 1)}; |
||||
__constant float* coeffs = c_RGB2YUVCoeffs_420; |
||||
|
||||
#pragma unroll |
||||
for (int cy = 0; cy < PIX_PER_WI_Y; ++cy) |
||||
{ |
||||
if (y < rows / 3) |
||||
{ |
||||
__global const uchar* src1 = srcptr + src_index; |
||||
__global const uchar* src2 = src1 + src_step; |
||||
__global uchar* ydst1 = dstptr + ydst_index; |
||||
__global uchar* ydst2 = ydst1 + dst_step; |
||||
|
||||
__global uchar* udst = dstptr + mad24(y_rows + (y>>1), dst_step, dst_offset + (y%2)*(cols >> 1) + x); |
||||
__global uchar* vdst = udst + mad24(y_rows >> 2, dst_step, y_rows % 4 ? vsteps[y%2] : 0); |
||||
|
||||
#if PIX_PER_WI_X == 2 |
||||
int s11 = *((__global const int*) src1); |
||||
int s12 = *((__global const int*) src1 + 1); |
||||
int s13 = *((__global const int*) src1 + 2); |
||||
#if scn == 4 |
||||
int s14 = *((__global const int*) src1 + 3); |
||||
#endif |
||||
int s21 = *((__global const int*) src2); |
||||
int s22 = *((__global const int*) src2 + 1); |
||||
int s23 = *((__global const int*) src2 + 2); |
||||
#if scn == 4 |
||||
int s24 = *((__global const int*) src2 + 3); |
||||
#endif |
||||
float src_pix1[scn * 4], src_pix2[scn * 4]; |
||||
|
||||
*((float4*) src_pix1) = convert_float4(as_uchar4(s11)); |
||||
*((float4*) src_pix1 + 1) = convert_float4(as_uchar4(s12)); |
||||
*((float4*) src_pix1 + 2) = convert_float4(as_uchar4(s13)); |
||||
#if scn == 4 |
||||
*((float4*) src_pix1 + 3) = convert_float4(as_uchar4(s14)); |
||||
#endif |
||||
*((float4*) src_pix2) = convert_float4(as_uchar4(s21)); |
||||
*((float4*) src_pix2 + 1) = convert_float4(as_uchar4(s22)); |
||||
*((float4*) src_pix2 + 2) = convert_float4(as_uchar4(s23)); |
||||
#if scn == 4 |
||||
*((float4*) src_pix2 + 3) = convert_float4(as_uchar4(s24)); |
||||
#endif |
||||
uchar4 y1, y2; |
||||
y1.x = convert_uchar_sat(fma(coeffs[0], src_pix1[ 2-bidx], fma(coeffs[1], src_pix1[ 1], fma(coeffs[2], src_pix1[ bidx], 16.5f)))); |
||||
y1.y = convert_uchar_sat(fma(coeffs[0], src_pix1[ scn+2-bidx], fma(coeffs[1], src_pix1[ scn+1], fma(coeffs[2], src_pix1[ scn+bidx], 16.5f)))); |
||||
y1.z = convert_uchar_sat(fma(coeffs[0], src_pix1[2*scn+2-bidx], fma(coeffs[1], src_pix1[2*scn+1], fma(coeffs[2], src_pix1[2*scn+bidx], 16.5f)))); |
||||
y1.w = convert_uchar_sat(fma(coeffs[0], src_pix1[3*scn+2-bidx], fma(coeffs[1], src_pix1[3*scn+1], fma(coeffs[2], src_pix1[3*scn+bidx], 16.5f)))); |
||||
y2.x = convert_uchar_sat(fma(coeffs[0], src_pix2[ 2-bidx], fma(coeffs[1], src_pix2[ 1], fma(coeffs[2], src_pix2[ bidx], 16.5f)))); |
||||
y2.y = convert_uchar_sat(fma(coeffs[0], src_pix2[ scn+2-bidx], fma(coeffs[1], src_pix2[ scn+1], fma(coeffs[2], src_pix2[ scn+bidx], 16.5f)))); |
||||
y2.z = convert_uchar_sat(fma(coeffs[0], src_pix2[2*scn+2-bidx], fma(coeffs[1], src_pix2[2*scn+1], fma(coeffs[2], src_pix2[2*scn+bidx], 16.5f)))); |
||||
y2.w = convert_uchar_sat(fma(coeffs[0], src_pix2[3*scn+2-bidx], fma(coeffs[1], src_pix2[3*scn+1], fma(coeffs[2], src_pix2[3*scn+bidx], 16.5f)))); |
||||
|
||||
*((__global int*) ydst1) = as_int(y1); |
||||
*((__global int*) ydst2) = as_int(y2); |
||||
|
||||
float uv[4] = { fma(coeffs[3], src_pix1[ 2-bidx], fma(coeffs[4], src_pix1[ 1], fma(coeffs[5], src_pix1[ bidx], 128.5f))), |
||||
fma(coeffs[5], src_pix1[ 2-bidx], fma(coeffs[6], src_pix1[ 1], fma(coeffs[7], src_pix1[ bidx], 128.5f))), |
||||
fma(coeffs[3], src_pix1[2*scn+2-bidx], fma(coeffs[4], src_pix1[2*scn+1], fma(coeffs[5], src_pix1[2*scn+bidx], 128.5f))), |
||||
fma(coeffs[5], src_pix1[2*scn+2-bidx], fma(coeffs[6], src_pix1[2*scn+1], fma(coeffs[7], src_pix1[2*scn+bidx], 128.5f))) }; |
||||
|
||||
udst[0] = convert_uchar_sat(uv[uidx] ); |
||||
vdst[0] = convert_uchar_sat(uv[1 - uidx]); |
||||
udst[1] = convert_uchar_sat(uv[2 + uidx]); |
||||
vdst[1] = convert_uchar_sat(uv[3 - uidx]); |
||||
#else |
||||
float4 src_pix1 = convert_float4(vload4(0, src1)); |
||||
float4 src_pix2 = convert_float4(vload4(0, src1+scn)); |
||||
float4 src_pix3 = convert_float4(vload4(0, src2)); |
||||
float4 src_pix4 = convert_float4(vload4(0, src2+scn)); |
||||
|
||||
ydst1[0] = convert_uchar_sat(fma(coeffs[0], src_pix1.R_COMP, fma(coeffs[1], src_pix1.G_COMP, fma(coeffs[2], src_pix1.B_COMP, 16.5f)))); |
||||
ydst1[1] = convert_uchar_sat(fma(coeffs[0], src_pix2.R_COMP, fma(coeffs[1], src_pix2.G_COMP, fma(coeffs[2], src_pix2.B_COMP, 16.5f)))); |
||||
ydst2[0] = convert_uchar_sat(fma(coeffs[0], src_pix3.R_COMP, fma(coeffs[1], src_pix3.G_COMP, fma(coeffs[2], src_pix3.B_COMP, 16.5f)))); |
||||
ydst2[1] = convert_uchar_sat(fma(coeffs[0], src_pix4.R_COMP, fma(coeffs[1], src_pix4.G_COMP, fma(coeffs[2], src_pix4.B_COMP, 16.5f)))); |
||||
|
||||
float uv[2] = { fma(coeffs[3], src_pix1.R_COMP, fma(coeffs[4], src_pix1.G_COMP, fma(coeffs[5], src_pix1.B_COMP, 128.5f))), |
||||
fma(coeffs[5], src_pix1.R_COMP, fma(coeffs[6], src_pix1.G_COMP, fma(coeffs[7], src_pix1.B_COMP, 128.5f))) }; |
||||
|
||||
udst[0] = convert_uchar_sat(uv[uidx] ); |
||||
vdst[0] = convert_uchar_sat(uv[1-uidx]); |
||||
#endif |
||||
++y; |
||||
src_index += 2*src_step; |
||||
ydst_index += 2*dst_step; |
||||
} |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,145 @@ |
||||
#include <cstdlib> |
||||
#include <cstdio> |
||||
#include <cassert> |
||||
|
||||
#include <cstring> |
||||
#include <unistd.h> |
||||
|
||||
// #include <opencv2/opencv.hpp>
|
||||
|
||||
#ifdef __APPLE__ |
||||
#include <OpenCL/cl.h> |
||||
#else |
||||
#include <CL/cl.h> |
||||
#endif |
||||
|
||||
#include "common/util.h" |
||||
#include "common/timing.h" |
||||
#include "common/mat.h" |
||||
#include "clutil.h" |
||||
|
||||
int main() { |
||||
|
||||
int rgb_width = 1164; |
||||
int rgb_height = 874; |
||||
|
||||
int rgb_stride = rgb_width*3; |
||||
|
||||
size_t out_size = rgb_width*rgb_height*3/2; |
||||
|
||||
uint8_t* rgb_buf = (uint8_t*)calloc(1, rgb_width*rgb_height*3); |
||||
uint8_t* out = (uint8_t*)calloc(1, out_size); |
||||
|
||||
for (int y=0; y<rgb_height; y++) { |
||||
for (int k=0; k<rgb_stride; k++) { |
||||
rgb_buf[y*rgb_stride + k] = k ^ y; |
||||
} |
||||
} |
||||
|
||||
|
||||
// init cl
|
||||
/* Get Platform and Device Info */ |
||||
cl_platform_id platform_id = NULL; |
||||
cl_uint num_platforms_unused; |
||||
int err = clGetPlatformIDs(1, &platform_id, &num_platforms_unused); |
||||
if (err != 0) { |
||||
fprintf(stderr, "cl error: %d\n", err); |
||||
} |
||||
assert(err == 0); |
||||
|
||||
cl_device_id device_id = NULL; |
||||
cl_uint num_devices_unused; |
||||
err = clGetDeviceIDs(platform_id, CL_DEVICE_TYPE_DEFAULT, 1, &device_id, |
||||
&num_devices_unused); |
||||
if (err != 0) { |
||||
fprintf(stderr, "cl error: %d\n", err); |
||||
} |
||||
assert(err == 0); |
||||
|
||||
cl_print_info(platform_id, device_id); |
||||
printf("\n"); |
||||
|
||||
cl_context context = clCreateContext(NULL, 1, &device_id, NULL, NULL, &err); |
||||
assert(err == 0); |
||||
|
||||
cl_program prg = cl_create_program_from_file(context, "yuv.cl"); |
||||
|
||||
err = clBuildProgram(prg, 1, &device_id, "", NULL, NULL); |
||||
if (err != 0) { |
||||
cl_print_build_errors(prg, device_id); |
||||
} |
||||
cl_check_error(err); |
||||
|
||||
|
||||
cl_kernel krnl = clCreateKernel(prg, "RGB2YUV_YV12_IYUV", &err); |
||||
assert(err == 0); |
||||
|
||||
|
||||
cl_mem inbuf_cl = clCreateBuffer(context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR, |
||||
rgb_width*rgb_height*3, (void*)rgb_buf, &err); |
||||
cl_check_error(err); |
||||
cl_mem out_cl = clCreateBuffer(context, CL_MEM_READ_WRITE, out_size, NULL, &err); |
||||
cl_check_error(err); |
||||
|
||||
|
||||
// load into net
|
||||
err = clSetKernelArg(krnl, 0, sizeof(cl_mem), &inbuf_cl); //srcptr
|
||||
assert(err == 0); |
||||
|
||||
int zero = 0; |
||||
err = clSetKernelArg(krnl, 1, sizeof(cl_int), &rgb_stride); //src_step
|
||||
assert(err == 0); |
||||
err = clSetKernelArg(krnl, 2, sizeof(cl_int), &zero); //src_offset
|
||||
assert(err == 0); |
||||
|
||||
err = clSetKernelArg(krnl, 3, sizeof(cl_mem), &out_cl); //dstptr
|
||||
assert(err == 0); |
||||
err = clSetKernelArg(krnl, 4, sizeof(cl_int), &rgb_width); //dst_step
|
||||
assert(err == 0); |
||||
err = clSetKernelArg(krnl, 5, sizeof(cl_int), &zero); //dst_offset
|
||||
assert(err == 0); |
||||
|
||||
const int rows = rgb_height * 3 / 2; |
||||
err = clSetKernelArg(krnl, 6, sizeof(cl_int), &rows); //rows
|
||||
assert(err == 0); |
||||
err = clSetKernelArg(krnl, 7, sizeof(cl_int), &rgb_width); //cols
|
||||
assert(err == 0); |
||||
|
||||
cl_command_queue q = clCreateCommandQueue(context, device_id, 0, &err); |
||||
assert(err == 0); |
||||
const size_t work_size[2] = {rgb_width/2, rows/3}; |
||||
|
||||
err = clEnqueueNDRangeKernel(q, krnl, 2, NULL, |
||||
(const size_t*)&work_size, NULL, 0, 0, NULL); |
||||
cl_check_error(err); |
||||
clFinish(q); |
||||
|
||||
|
||||
|
||||
double t1 = millis_since_boot(); |
||||
for (int k=0; k<32; k++) { |
||||
err = clEnqueueNDRangeKernel(q, krnl, 2, NULL, |
||||
(const size_t*)&work_size, NULL, 0, 0, NULL); |
||||
cl_check_error(err); |
||||
} |
||||
clFinish(q); |
||||
double t2 = millis_since_boot(); |
||||
printf("t: %.2f\n", (t2-t1)/32.); |
||||
|
||||
uint8_t* out_ptr = (uint8_t*)clEnqueueMapBuffer(q, out_cl, CL_FALSE, |
||||
CL_MAP_READ, 0, out_size, |
||||
0, NULL, NULL, &err); |
||||
assert(err == 0); |
||||
clFinish(q); |
||||
|
||||
|
||||
FILE* of = fopen("out_cl.bin", "wb"); |
||||
fwrite(out_ptr, out_size, 1, of); |
||||
fclose(of); |
||||
|
||||
|
||||
// #endif
|
||||
|
||||
|
||||
return 0; |
||||
} |
||||
@ -0,0 +1,53 @@ |
||||
#include <string.h> |
||||
#include <assert.h> |
||||
|
||||
#include "clutil.h" |
||||
|
||||
#include "rgb_to_yuv.h" |
||||
|
||||
void rgb_to_yuv_init(RGBToYUVState* s, cl_context ctx, cl_device_id device_id, int width, int height, int rgb_stride) { |
||||
int err = 0; |
||||
memset(s, 0, sizeof(*s)); |
||||
assert(width % 2 == 0); |
||||
assert(height % 2 == 0); |
||||
s->width = width; |
||||
s->height = height; |
||||
char args[1024]; |
||||
snprintf(args, sizeof(args), |
||||
"-cl-fast-relaxed-math -cl-denorms-are-zero " |
||||
#ifdef CL_DEBUG |
||||
"-DCL_DEBUG " |
||||
#endif |
||||
"-DWIDTH=%d -DHEIGHT=%d -DUV_WIDTH=%d -DUV_HEIGHT=%d -DRGB_STRIDE=%d -DRGB_SIZE=%d", |
||||
width, height, width/ 2, height / 2, rgb_stride, width * height); |
||||
cl_program prg = CLU_LOAD_FROM_FILE(ctx, device_id, "transforms/rgb_to_yuv.cl", args); |
||||
|
||||
s->rgb_to_yuv_krnl = clCreateKernel(prg, "rgb_to_yuv", &err); |
||||
assert(err == 0); |
||||
// done with this
|
||||
err = clReleaseProgram(prg); |
||||
assert(err == 0); |
||||
} |
||||
|
||||
void rgb_to_yuv_destroy(RGBToYUVState* s) { |
||||
int err = 0; |
||||
err = clReleaseKernel(s->rgb_to_yuv_krnl); |
||||
assert(err == 0); |
||||
} |
||||
|
||||
void rgb_to_yuv_queue(RGBToYUVState* s, cl_command_queue q, cl_mem rgb_cl, cl_mem yuv_cl) { |
||||
int err = 0; |
||||
err = clSetKernelArg(s->rgb_to_yuv_krnl, 0, sizeof(cl_mem), &rgb_cl); |
||||
assert(err == 0); |
||||
err = clSetKernelArg(s->rgb_to_yuv_krnl, 1, sizeof(cl_mem), &yuv_cl); |
||||
assert(err == 0); |
||||
const size_t work_size[2] = { |
||||
(size_t)(s->width + (s->width % 4 == 0 ? 0 : (4 - s->width % 4))) / 4,
|
||||
(size_t)(s->height + (s->height % 4 == 0 ? 0 : (4 - s->height % 4))) / 4 |
||||
}; |
||||
cl_event event; |
||||
err = clEnqueueNDRangeKernel(q, s->rgb_to_yuv_krnl, 2, NULL, &work_size[0], NULL, 0, 0, &event); |
||||
assert(err == 0); |
||||
clWaitForEvents(1, &event); |
||||
clReleaseEvent(event); |
||||
} |
||||
@ -0,0 +1,127 @@ |
||||
#define RGB_TO_Y(r, g, b) ((((mul24(b, 13) + mul24(g, 65) + mul24(r, 33)) + 64) >> 7) + 16) |
||||
#define RGB_TO_U(r, g, b) ((mul24(b, 56) - mul24(g, 37) - mul24(r, 19) + 0x8080) >> 8) |
||||
#define RGB_TO_V(r, g, b) ((mul24(r, 56) - mul24(g, 47) - mul24(b, 9) + 0x8080) >> 8) |
||||
#define AVERAGE(x, y, z, w) ((convert_ushort(x) + convert_ushort(y) + convert_ushort(z) + convert_ushort(w) + 1) >> 1) |
||||
|
||||
inline void convert_2_ys(__global uchar * out_yuv, int yi, const uchar8 rgbs1) { |
||||
uchar2 yy = (uchar2)( |
||||
RGB_TO_Y(rgbs1.s2, rgbs1.s1, rgbs1.s0), |
||||
RGB_TO_Y(rgbs1.s5, rgbs1.s4, rgbs1.s3) |
||||
); |
||||
#ifdef CL_DEBUG |
||||
if(yi >= RGB_SIZE) |
||||
printf("Y vector2 overflow, %d > %d\n", yi, RGB_SIZE); |
||||
#endif |
||||
vstore2(yy, 0, out_yuv + yi); |
||||
} |
||||
|
||||
inline void convert_4_ys(__global uchar * out_yuv, int yi, const uchar8 rgbs1, const uchar8 rgbs3) { |
||||
const uchar4 yy = (uchar4)( |
||||
RGB_TO_Y(rgbs1.s2, rgbs1.s1, rgbs1.s0), |
||||
RGB_TO_Y(rgbs1.s5, rgbs1.s4, rgbs1.s3), |
||||
RGB_TO_Y(rgbs3.s0, rgbs1.s7, rgbs1.s6), |
||||
RGB_TO_Y(rgbs3.s3, rgbs3.s2, rgbs3.s1) |
||||
); |
||||
#ifdef CL_DEBUG |
||||
if(yi > RGB_SIZE - 4) |
||||
printf("Y vector4 overflow, %d > %d\n", yi, RGB_SIZE - 4); |
||||
#endif |
||||
vstore4(yy, 0, out_yuv + yi); |
||||
} |
||||
|
||||
inline void convert_uv(__global uchar * out_yuv, int ui, int vi, |
||||
const uchar8 rgbs1, const uchar8 rgbs2) { |
||||
// U & V: average of 2x2 pixels square |
||||
const short ab = AVERAGE(rgbs1.s0, rgbs1.s3, rgbs2.s0, rgbs2.s3); |
||||
const short ag = AVERAGE(rgbs1.s1, rgbs1.s4, rgbs2.s1, rgbs2.s4); |
||||
const short ar = AVERAGE(rgbs1.s2, rgbs1.s5, rgbs2.s2, rgbs2.s5); |
||||
#ifdef CL_DEBUG |
||||
if(ui >= RGB_SIZE + RGB_SIZE / 4) |
||||
printf("U overflow, %d >= %d\n", ui, RGB_SIZE + RGB_SIZE / 4); |
||||
if(vi >= RGB_SIZE + RGB_SIZE / 2) |
||||
printf("V overflow, %d >= %d\n", vi, RGB_SIZE + RGB_SIZE / 2); |
||||
#endif |
||||
out_yuv[ui] = RGB_TO_U(ar, ag, ab); |
||||
out_yuv[vi] = RGB_TO_V(ar, ag, ab); |
||||
} |
||||
|
||||
inline void convert_2_uvs(__global uchar * out_yuv, int ui, int vi, |
||||
const uchar8 rgbs1, const uchar8 rgbs2, const uchar8 rgbs3, const uchar8 rgbs4) { |
||||
// U & V: average of 2x2 pixels square |
||||
const short ab1 = AVERAGE(rgbs1.s0, rgbs1.s3, rgbs2.s0, rgbs2.s3); |
||||
const short ag1 = AVERAGE(rgbs1.s1, rgbs1.s4, rgbs2.s1, rgbs2.s4); |
||||
const short ar1 = AVERAGE(rgbs1.s2, rgbs1.s5, rgbs2.s2, rgbs2.s5); |
||||
const short ab2 = AVERAGE(rgbs1.s6, rgbs3.s1, rgbs2.s6, rgbs4.s1); |
||||
const short ag2 = AVERAGE(rgbs1.s7, rgbs3.s2, rgbs2.s7, rgbs4.s2); |
||||
const short ar2 = AVERAGE(rgbs3.s0, rgbs3.s3, rgbs4.s0, rgbs4.s3); |
||||
uchar2 u2 = (uchar2)( |
||||
RGB_TO_U(ar1, ag1, ab1), |
||||
RGB_TO_U(ar2, ag2, ab2) |
||||
); |
||||
uchar2 v2 = (uchar2)( |
||||
RGB_TO_V(ar1, ag1, ab1), |
||||
RGB_TO_V(ar2, ag2, ab2) |
||||
); |
||||
#ifdef CL_DEBUG1 |
||||
if(ui > RGB_SIZE + RGB_SIZE / 4 - 2) |
||||
printf("U 2 overflow, %d >= %d\n", ui, RGB_SIZE + RGB_SIZE / 4 - 2); |
||||
if(vi > RGB_SIZE + RGB_SIZE / 2 - 2) |
||||
printf("V 2 overflow, %d >= %d\n", vi, RGB_SIZE + RGB_SIZE / 2 - 2); |
||||
#endif |
||||
vstore2(u2, 0, out_yuv + ui); |
||||
vstore2(v2, 0, out_yuv + vi); |
||||
} |
||||
|
||||
__kernel void rgb_to_yuv(__global uchar const * const rgb, |
||||
__global uchar * out_yuv) |
||||
{ |
||||
const int dx = get_global_id(0); |
||||
const int dy = get_global_id(1); |
||||
const int col = mul24(dx, 4); // Current column in rgb image |
||||
const int row = mul24(dy, 4); // Current row in rgb image |
||||
const int bgri_start = mad24(row, RGB_STRIDE, mul24(col, 3)); // Start offset of rgb data being converted |
||||
const int yi_start = mad24(row, WIDTH, col); // Start offset in the target yuv buffer |
||||
int ui = mad24(row / 2, UV_WIDTH, RGB_SIZE + col / 2); |
||||
int vi = mad24(row / 2 , UV_WIDTH, RGB_SIZE + UV_WIDTH * UV_HEIGHT + col / 2); |
||||
int num_col = min(WIDTH - col, 4); |
||||
int num_row = min(HEIGHT - row, 4); |
||||
if(num_row == 4) { |
||||
const uchar8 rgbs0_0 = vload8(0, rgb + bgri_start); |
||||
const uchar8 rgbs0_1 = vload8(0, rgb + bgri_start + 8); |
||||
const uchar8 rgbs1_0 = vload8(0, rgb + bgri_start + RGB_STRIDE); |
||||
const uchar8 rgbs1_1 = vload8(0, rgb + bgri_start + RGB_STRIDE + 8); |
||||
const uchar8 rgbs2_0 = vload8(0, rgb + bgri_start + RGB_STRIDE * 2); |
||||
const uchar8 rgbs2_1 = vload8(0, rgb + bgri_start + RGB_STRIDE * 2 + 8); |
||||
const uchar8 rgbs3_0 = vload8(0, rgb + bgri_start + RGB_STRIDE * 3); |
||||
const uchar8 rgbs3_1 = vload8(0, rgb + bgri_start + RGB_STRIDE * 3 + 8); |
||||
if(num_col == 4) { |
||||
convert_4_ys(out_yuv, yi_start, rgbs0_0, rgbs0_1); |
||||
convert_4_ys(out_yuv, yi_start + WIDTH, rgbs1_0, rgbs1_1); |
||||
convert_4_ys(out_yuv, yi_start + WIDTH * 2, rgbs2_0, rgbs2_1); |
||||
convert_4_ys(out_yuv, yi_start + WIDTH * 3, rgbs3_0, rgbs3_1); |
||||
convert_2_uvs(out_yuv, ui, vi, rgbs0_0, rgbs1_0, rgbs0_1, rgbs1_1); |
||||
convert_2_uvs(out_yuv, ui + UV_WIDTH, vi + UV_WIDTH, rgbs2_0, rgbs3_0, rgbs2_1, rgbs3_1); |
||||
} else if(num_col == 2) { |
||||
convert_2_ys(out_yuv, yi_start, rgbs0_0); |
||||
convert_2_ys(out_yuv, yi_start + WIDTH, rgbs1_0); |
||||
convert_2_ys(out_yuv, yi_start + WIDTH * 2, rgbs2_0); |
||||
convert_2_ys(out_yuv, yi_start + WIDTH * 3, rgbs3_0); |
||||
convert_uv(out_yuv, ui, vi, rgbs0_0, rgbs1_0); |
||||
convert_uv(out_yuv, ui + UV_WIDTH, vi + UV_WIDTH, rgbs2_0, rgbs3_0); |
||||
} |
||||
} else { |
||||
const uchar8 rgbs0_0 = vload8(0, rgb + bgri_start); |
||||
const uchar8 rgbs0_1 = vload8(0, rgb + bgri_start + 8); |
||||
const uchar8 rgbs1_0 = vload8(0, rgb + bgri_start + RGB_STRIDE); |
||||
const uchar8 rgbs1_1 = vload8(0, rgb + bgri_start + RGB_STRIDE + 8); |
||||
if(num_col == 4) { |
||||
convert_4_ys(out_yuv, yi_start, rgbs0_0, rgbs0_1); |
||||
convert_4_ys(out_yuv, yi_start + WIDTH, rgbs1_0, rgbs1_1); |
||||
convert_2_uvs(out_yuv, ui, vi, rgbs0_0, rgbs1_0, rgbs0_1, rgbs1_1); |
||||
} else if(num_col == 2) { |
||||
convert_2_ys(out_yuv, yi_start, rgbs0_0); |
||||
convert_2_ys(out_yuv, yi_start + WIDTH, rgbs1_0); |
||||
convert_uv(out_yuv, ui, vi, rgbs0_0, rgbs1_0); |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,32 @@ |
||||
#ifndef RGB_TO_YUV_H |
||||
#define RGB_TO_YUV_H |
||||
|
||||
#include <inttypes.h> |
||||
#include <stdbool.h> |
||||
|
||||
#ifdef __APPLE__ |
||||
#include <OpenCL/cl.h> |
||||
#else |
||||
#include <CL/cl.h> |
||||
#endif |
||||
|
||||
#ifdef __cplusplus |
||||
extern "C" { |
||||
#endif |
||||
|
||||
typedef struct { |
||||
int width, height; |
||||
cl_kernel rgb_to_yuv_krnl; |
||||
} RGBToYUVState; |
||||
|
||||
void rgb_to_yuv_init(RGBToYUVState* s, cl_context ctx, cl_device_id device_id, int width, int height, int rgb_stride); |
||||
|
||||
void rgb_to_yuv_destroy(RGBToYUVState* s); |
||||
|
||||
void rgb_to_yuv_queue(RGBToYUVState* s, cl_command_queue q, cl_mem rgb_cl, cl_mem yuv_cl); |
||||
|
||||
#ifdef __cplusplus |
||||
} |
||||
#endif |
||||
|
||||
#endif // RGB_TO_YUV_H
|
||||
@ -0,0 +1,201 @@ |
||||
#include <memory.h> |
||||
#include <iostream> |
||||
#include <getopt.h> |
||||
#include <math.h> |
||||
#include <fstream> |
||||
#include <cstdlib> |
||||
#include <vector> |
||||
#include <string> |
||||
#include <iomanip> |
||||
#include <thread> |
||||
#include <fcntl.h> |
||||
#include <signal.h> |
||||
#include <unistd.h> |
||||
#include <cassert> |
||||
#include <cstdint> |
||||
|
||||
#ifdef ANDROID |
||||
|
||||
#define MAXE 0 |
||||
#include <unistd.h> |
||||
|
||||
#else |
||||
// The libyuv implementation on ARM is slightly different than on x86
|
||||
// Our implementation matches the ARM version, so accept errors of 1
|
||||
#define MAXE 1 |
||||
|
||||
#endif |
||||
|
||||
#include <libyuv.h> |
||||
|
||||
#include <CL/cl.h> |
||||
|
||||
#include "clutil.h" |
||||
#include "rgb_to_yuv.h" |
||||
|
||||
|
||||
static inline double millis_since_boot() { |
||||
struct timespec t; |
||||
clock_gettime(CLOCK_BOOTTIME, &t); |
||||
return t.tv_sec * 1000.0 + t.tv_nsec * 1e-6; |
||||
} |
||||
|
||||
void cl_init(cl_device_id &device_id, cl_context &context) { |
||||
int err; |
||||
cl_platform_id platform_id = NULL; |
||||
cl_uint num_devices; |
||||
cl_uint num_platforms; |
||||
|
||||
err = clGetPlatformIDs(1, &platform_id, &num_platforms); |
||||
err = clGetDeviceIDs(platform_id, CL_DEVICE_TYPE_DEFAULT, 1, |
||||
&device_id, &num_devices); |
||||
cl_print_info(platform_id, device_id); |
||||
context = clCreateContext(NULL, 1, &device_id, NULL, NULL, &err); |
||||
} |
||||
|
||||
|
||||
bool compare_results(uint8_t *a, uint8_t *b, int len, int stride, int width, int height, uint8_t *rgb) { |
||||
int min_diff = 0., max_diff = 0., max_e = 0.; |
||||
int e1 = 0, e0 = 0; |
||||
int e0y = 0, e0u = 0, e0v = 0, e1y = 0, e1u = 0, e1v = 0; |
||||
int max_e_i = 0; |
||||
for (int i = 0;i < len;i++) { |
||||
int e = ((int)a[i]) - ((int)b[i]); |
||||
if(e < min_diff) { |
||||
min_diff = e; |
||||
} |
||||
if(e > max_diff) { |
||||
max_diff = e; |
||||
} |
||||
int e_abs = std::abs(e); |
||||
if(e_abs > max_e) { |
||||
max_e = e_abs; |
||||
max_e_i = i; |
||||
} |
||||
if(e_abs < 1) { |
||||
e0++; |
||||
if(i < stride * height) |
||||
e0y++; |
||||
else if(i < stride * height + stride * height / 4) |
||||
e0u++; |
||||
else |
||||
e0v++; |
||||
} else { |
||||
e1++; |
||||
if(i < stride * height) |
||||
e1y++; |
||||
else if(i < stride * height + stride * height / 4) |
||||
e1u++; |
||||
else |
||||
e1v++; |
||||
} |
||||
} |
||||
//printf("max diff : %d, min diff : %d, e < 1: %d, e >= 1: %d\n", max_diff, min_diff, e0, e1);
|
||||
//printf("Y: e < 1: %d, e >= 1: %d, U: e < 1: %d, e >= 1: %d, V: e < 1: %d, e >= 1: %d\n", e0y, e1y, e0u, e1u, e0v, e1v);
|
||||
if(max_e <= MAXE) { |
||||
return true; |
||||
} |
||||
int row = max_e_i / stride; |
||||
if(row < height) { |
||||
printf("max error is Y: %d = (libyuv: %u - cl: %u), row: %d, col: %d\n", max_e, a[max_e_i], b[max_e_i], row, max_e_i % stride); |
||||
} else if(row >= height && row < (height + height / 4)) { |
||||
printf("max error is U: %d = %u - %u, row: %d, col: %d\n", max_e, a[max_e_i], b[max_e_i], (row - height) / 2, max_e_i % stride / 2); |
||||
} else { |
||||
printf("max error is V: %d = %u - %u, row: %d, col: %d\n", max_e, a[max_e_i], b[max_e_i], (row - height - height / 4) / 2, max_e_i % stride / 2); |
||||
} |
||||
return false; |
||||
} |
||||
|
||||
int main(int argc, char** argv) { |
||||
srand(1337); |
||||
|
||||
clu_init(); |
||||
cl_device_id device_id; |
||||
cl_context context; |
||||
cl_init(device_id, context) ; |
||||
|
||||
int err; |
||||
const cl_queue_properties props[] = {0}; //CL_QUEUE_PRIORITY_KHR, CL_QUEUE_PRIORITY_HIGH_KHR, 0};
|
||||
cl_command_queue q = clCreateCommandQueueWithProperties(context, device_id, props, &err); |
||||
if(err != 0) { |
||||
std::cout << "clCreateCommandQueueWithProperties error: " << err << std::endl; |
||||
} |
||||
|
||||
int width = 1164; |
||||
int height = 874; |
||||
|
||||
int opt = 0; |
||||
while ((opt = getopt(argc, argv, "f")) != -1) |
||||
{ |
||||
switch (opt) |
||||
{ |
||||
case 'f': |
||||
std::cout << "Using front camera dimensions" << std::endl; |
||||
int width = 1152; |
||||
int height = 846; |
||||
} |
||||
} |
||||
|
||||
std::cout << "Width: " << width << " Height: " << height << std::endl; |
||||
uint8_t *rgb_frame = new uint8_t[width * height * 3]; |
||||
|
||||
|
||||
RGBToYUVState rgb_to_yuv_state; |
||||
rgb_to_yuv_init(&rgb_to_yuv_state, context, device_id, width, height, width * 3); |
||||
|
||||
int frame_yuv_buf_size = width * height * 3 / 2; |
||||
cl_mem yuv_cl = clCreateBuffer(context, CL_MEM_READ_WRITE, frame_yuv_buf_size, (void*)NULL, &err); |
||||
uint8_t *frame_yuv_buf = new uint8_t[frame_yuv_buf_size]; |
||||
uint8_t *frame_yuv_ptr_y = frame_yuv_buf; |
||||
uint8_t *frame_yuv_ptr_u = frame_yuv_buf + (width * height); |
||||
uint8_t *frame_yuv_ptr_v = frame_yuv_ptr_u + ((width/2) * (height/2)); |
||||
|
||||
cl_mem rgb_cl = clCreateBuffer(context, CL_MEM_READ_WRITE, width * height * 3, (void*)NULL, &err); |
||||
int mismatched = 0; |
||||
int counter = 0; |
||||
srand (time(NULL)); |
||||
|
||||
for (int i = 0; i < 100; i++){ |
||||
for (int i = 0; i < width * height * 3; i++){ |
||||
rgb_frame[i] = (uint8_t)rand(); |
||||
} |
||||
|
||||
double t1 = millis_since_boot(); |
||||
libyuv::RGB24ToI420((uint8_t*)rgb_frame, width * 3, |
||||
frame_yuv_ptr_y, width, |
||||
frame_yuv_ptr_u, width/2, |
||||
frame_yuv_ptr_v, width/2, |
||||
width, height); |
||||
double t2 = millis_since_boot(); |
||||
//printf("Libyuv: rgb to yuv: %.2fms\n", t2-t1);
|
||||
|
||||
clEnqueueWriteBuffer(q, rgb_cl, CL_TRUE, 0, width * height * 3, (void *)rgb_frame, 0, NULL, NULL); |
||||
t1 = millis_since_boot(); |
||||
rgb_to_yuv_queue(&rgb_to_yuv_state, q, rgb_cl, yuv_cl); |
||||
t2 = millis_since_boot(); |
||||
|
||||
//printf("OpenCL: rgb to yuv: %.2fms\n", t2-t1);
|
||||
uint8_t *yyy = (uint8_t *)clEnqueueMapBuffer(q, yuv_cl, CL_TRUE, |
||||
CL_MAP_READ, 0, frame_yuv_buf_size, |
||||
0, NULL, NULL, &err); |
||||
if(!compare_results(frame_yuv_ptr_y, yyy, frame_yuv_buf_size, width, width, height, (uint8_t*)rgb_frame)) |
||||
mismatched++; |
||||
clEnqueueUnmapMemObject(q, yuv_cl, yyy, 0, NULL, NULL); |
||||
|
||||
// std::this_thread::sleep_for(std::chrono::milliseconds(20));
|
||||
if(counter++ % 100 == 0) |
||||
printf("Matched: %d, Mismatched: %d\n", counter - mismatched, mismatched); |
||||
|
||||
} |
||||
printf("Matched: %d, Mismatched: %d\n", counter - mismatched, mismatched); |
||||
|
||||
delete[] frame_yuv_buf; |
||||
rgb_to_yuv_destroy(&rgb_to_yuv_state); |
||||
clReleaseContext(context); |
||||
delete[] rgb_frame; |
||||
|
||||
if (mismatched == 0) |
||||
return 0; |
||||
else |
||||
return -1; |
||||
} |
||||
Loading…
Reference in new issue