978 lines
30 KiB
978 lines
30 KiB
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <fcntl.h>
|
|
#include <unistd.h>
|
|
#include <time.h>
|
|
#include <sys/ioctl.h>
|
|
#include <sys/mman.h>
|
|
#include <linux/videodev2.h>
|
|
#include <linux/v4l2-subdev.h>
|
|
#include <string>
|
|
#include "rk_aiq_types.h"
|
|
#include "rk_aiq_offline_raw.h"
|
|
#include "rk_vi_user_api2_stream_cfg.h"
|
|
#include "uAPI2/rk_aiq_user_api2_sysctl.h"
|
|
#include "rk_aiq_offline_raw.h"
|
|
#include <iostream>
|
|
#include <getopt.h>
|
|
|
|
#define USE_LIBAIQ
|
|
|
|
#define SENSOR_ENTNAME "m00_b_imx415 5-001a"
|
|
|
|
#define VIDEO_DEVNAME "/dev/video8"
|
|
#define VIDEO_WIDTH 3840
|
|
#define VIDEO_HEIGHT 2160
|
|
#define VIDEO_WORKMODE RK_AIQ_WORKING_MODE_NORMAL
|
|
|
|
#define VIDEO_WIDTH_2 3840
|
|
#define VIDEO_HEIGHT_2 2160
|
|
#define VIDEO_WORKMODE_2 RK_AIQ_WORKING_MODE_NORMAL
|
|
|
|
#define RAWCAP_SAVE_NUM 30
|
|
#define STREAM_SAVE_NUM 30
|
|
|
|
struct rk_aiq_vbuf_info {
|
|
uint32_t frame_id;
|
|
uint32_t timestamp;
|
|
float exp_time;
|
|
float exp_gain;
|
|
uint32_t exp_time_reg;
|
|
uint32_t exp_gain_reg;
|
|
uint32_t data_fd;
|
|
uint8_t *data_addr;
|
|
uint32_t data_length;
|
|
bool valid;
|
|
};
|
|
|
|
struct rk_aiq_vbuf {
|
|
void *base_addr;
|
|
uint32_t frame_width;
|
|
uint32_t frame_height;
|
|
struct rk_aiq_vbuf_info buf_info[3];/*index: 0-short,1-medium,2-long*/
|
|
};
|
|
|
|
|
|
static rk_aiq_rawbuf_type_t _rawbuf_type;
|
|
static struct _st_addrinfo _st_addr[3];
|
|
static struct _raw_format _rawfmt;
|
|
static rk_aiq_frame_info_t _finfo;
|
|
|
|
static rkraw_vi_ctx_t *g_vi_ctx;
|
|
|
|
static int g_quit = 0;
|
|
static int g_aiq_quit = 0;
|
|
static int g_aiq_pause = 0;
|
|
static int g_aiq_test_mode = 0;
|
|
|
|
static int saved_num = 0;
|
|
static char g_sns_entity_name[64] = {0};
|
|
static char g_sns_name[64] = {0};
|
|
|
|
static bool use_isp_driver = false;
|
|
static int raw_width = 3840;
|
|
static int raw_height = 2160;
|
|
static int video_width = 640;
|
|
static int video_height = 480;
|
|
static int modul_select = 0;
|
|
static int hdr_mode = 0;
|
|
static const char *isp_vir;
|
|
static const char *real_sns;
|
|
static const char *iq_file_name;
|
|
static const char *video_name;
|
|
static uint32_t pix_fmt = V4L2_PIX_FMT_SBGGR10;
|
|
|
|
static FILE* g_rkraw_fp;
|
|
static uint8_t* g_rkraw_buffer;
|
|
static uint32_t g_rkraw_size;
|
|
static int g_rkraw_index;
|
|
|
|
static struct timeval start_t, cur_t, prev_t;
|
|
|
|
static rk_aiq_sys_ctx_t* g_aiq_ctx;
|
|
|
|
// enum v4l2_memory _tx_memory_type;
|
|
// enum v4l2_memory _rx_memory_type;
|
|
// SmartPtr<V4l2Device> g_vi_ctx->_mRawProcUnit->_mipi_rx_devs[3];
|
|
// SmartPtr<V4l2Device> _mipi_tx_devs[3];
|
|
|
|
void debug_init_time(){
|
|
gettimeofday(&start_t,NULL);
|
|
gettimeofday(&cur_t,NULL);
|
|
gettimeofday(&prev_t,NULL);
|
|
}
|
|
|
|
void debug_update_time(){
|
|
gettimeofday(&prev_t,NULL);
|
|
}
|
|
|
|
void debug_print_time(std::string tag){
|
|
unsigned long tmp;
|
|
double process_ms, total_ms,cur_ms;
|
|
struct timespec kernel_t;
|
|
|
|
gettimeofday(&cur_t,NULL);
|
|
tmp = 1000000 * (cur_t.tv_sec-prev_t.tv_sec)+ cur_t.tv_usec-prev_t.tv_usec;
|
|
prev_t = cur_t;
|
|
process_ms = 1.0*tmp/1000;
|
|
|
|
tmp = 1000000 * (cur_t.tv_sec-start_t.tv_sec)+ cur_t.tv_usec-start_t.tv_usec;
|
|
total_ms = 1.0*tmp/1000;
|
|
|
|
clock_gettime(CLOCK_BOOTTIME , &kernel_t);
|
|
tmp = 1000000000 * kernel_t.tv_sec + kernel_t.tv_nsec;
|
|
cur_ms = 1.0*tmp/1000000000;
|
|
printf("[TIME_DEBUG %.1f] %s process_ms %d, total_ms %d\n", cur_ms, tag.c_str(), (int)process_ms, (int)total_ms);
|
|
}
|
|
|
|
int prepare_rkraw()
|
|
{
|
|
int ret;
|
|
if(g_rkraw_fp){
|
|
fclose(g_rkraw_fp);
|
|
g_rkraw_fp = NULL;
|
|
}
|
|
if(g_rkraw_buffer){
|
|
free(g_rkraw_buffer);
|
|
g_rkraw_buffer = NULL;
|
|
}
|
|
|
|
char filname[32];
|
|
sprintf(filname, "mnt/0.raw");
|
|
g_rkraw_fp = fopen(filname,"rb");
|
|
if(!g_rkraw_fp){
|
|
printf("can't open %s\n", filname);
|
|
return -1;
|
|
}
|
|
|
|
fseek(g_rkraw_fp, 0, SEEK_END);
|
|
g_rkraw_size=ftell(g_rkraw_fp);
|
|
fseek(g_rkraw_fp, 0, SEEK_SET);
|
|
|
|
g_rkraw_buffer = (uint8_t *)malloc(g_rkraw_size);
|
|
if(!g_rkraw_buffer){
|
|
printf("prepare_rkraw malloc failed!\n");
|
|
return -1;
|
|
}
|
|
|
|
ret = fread(g_rkraw_buffer, 1, g_rkraw_size, g_rkraw_fp);
|
|
printf("prepare_rkraw: ret %d, addr 0x%lx\n", ret, (uint64_t)g_rkraw_buffer);
|
|
|
|
if (g_rkraw_index > 20) {
|
|
return -1;
|
|
}
|
|
|
|
g_rkraw_index++;
|
|
return 0;
|
|
}
|
|
|
|
void parse_rk_rawdata(uint8_t *rawdata, uint32_t rkraw_len, struct rk_aiq_vbuf *vbuf)
|
|
{
|
|
unsigned short tag = 0;
|
|
struct _block_header header;
|
|
uint8_t *p = (uint8_t *)rawdata;
|
|
bool bExit = false;
|
|
|
|
struct _st_addrinfo_stream _st_addr[3];
|
|
struct _raw_format _rawfmt;
|
|
|
|
while(!bExit){
|
|
tag = *((unsigned short*)p);
|
|
switch (tag)
|
|
{
|
|
case START_TAG:
|
|
p = p+TAG_BYTE_LEN;
|
|
memset(_st_addr, 0, sizeof(_st_addr));
|
|
memset(&_rawfmt, 0, sizeof(_rawfmt));
|
|
memset(&_finfo, 0, sizeof(_finfo));
|
|
break;
|
|
case NORMAL_RAW_TAG:
|
|
{
|
|
header = *((struct _block_header *)p);
|
|
p = p + sizeof(struct _block_header);
|
|
if (header.block_length == sizeof(struct _st_addrinfo_stream)) {
|
|
_st_addr[0] = *((struct _st_addrinfo_stream*)p);
|
|
}
|
|
p = p + header.block_length;
|
|
|
|
break;
|
|
}
|
|
case HDR_S_RAW_TAG:
|
|
{
|
|
header = *((struct _block_header *)p);
|
|
p = p + sizeof(struct _block_header);
|
|
if (header.block_length == sizeof(struct _st_addrinfo_stream)) {
|
|
_st_addr[0] = *((struct _st_addrinfo_stream*)p);
|
|
}
|
|
p = p + header.block_length;
|
|
break;
|
|
}
|
|
case HDR_M_RAW_TAG:
|
|
{
|
|
header = *((struct _block_header *)p);
|
|
p = p + sizeof(struct _block_header);
|
|
if (header.block_length == sizeof(struct _st_addrinfo_stream)) {
|
|
_st_addr[1] = *((struct _st_addrinfo_stream*)p);
|
|
}
|
|
p = p + header.block_length;
|
|
break;
|
|
}
|
|
case HDR_L_RAW_TAG:
|
|
{
|
|
header = *((struct _block_header *)p);
|
|
p = p + sizeof(struct _block_header);
|
|
if (header.block_length == sizeof(struct _st_addrinfo_stream)) {
|
|
_st_addr[2] = *((struct _st_addrinfo_stream*)p);
|
|
}
|
|
p = p + header.block_length;
|
|
break;
|
|
}
|
|
case FORMAT_TAG:
|
|
{
|
|
_rawfmt = *((struct _raw_format *)p);
|
|
p = p + sizeof(struct _block_header) + _rawfmt.size;
|
|
break;
|
|
}
|
|
case STATS_TAG:
|
|
{
|
|
_finfo = *((rk_aiq_frame_info_t *)p);
|
|
p = p + sizeof(struct _block_header) + _finfo.size;
|
|
break;
|
|
}
|
|
case ISP_REG_FMT_TAG:
|
|
{
|
|
header = *((struct _block_header *)p);
|
|
p += sizeof(struct _block_header);
|
|
p = p + header.block_length;
|
|
break;
|
|
}
|
|
case ISP_REG_TAG:
|
|
{
|
|
header = *((struct _block_header *)p);
|
|
p += sizeof(struct _block_header);
|
|
p = p + header.block_length;
|
|
break;
|
|
}
|
|
case ISPP_REG_FMT_TAG:
|
|
{
|
|
header = *((struct _block_header *)p);
|
|
p += sizeof(struct _block_header);
|
|
p = p + header.block_length;
|
|
break;
|
|
}
|
|
case ISPP_REG_TAG:
|
|
{
|
|
header = *((struct _block_header *)p);
|
|
p += sizeof(struct _block_header);
|
|
p = p + header.block_length;
|
|
break;
|
|
}
|
|
case PLATFORM_TAG:
|
|
{
|
|
header = *((struct _block_header *)p);
|
|
p += sizeof(struct _block_header);
|
|
p = p + header.block_length;
|
|
break;
|
|
}
|
|
case END_TAG:
|
|
{
|
|
//uint32_t _len = p - (uint8_t *)rawdata;
|
|
//printf("_len %d rkraw_len %d\n", _len, rkraw_len);
|
|
bExit = true;
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
printf("Not support TAG(0x%04x)\n", tag);
|
|
bExit = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
printf("frame_id %d, size %d %d %d, format %dx%d\n",
|
|
_rawfmt.frame_id,
|
|
_st_addr[0].size,_st_addr[1].size,_st_addr[2].size,
|
|
_rawfmt.width, _rawfmt.height
|
|
);
|
|
//if(_st_addr[0].fd){
|
|
// printf("get haddr %x\n",_st_addr[0].haddr);
|
|
// printf("get laddr %x\n",_st_addr[0].laddr);
|
|
//}
|
|
|
|
uint64_t uptr;
|
|
uptr = _st_addr[0].haddr;
|
|
uptr = uptr << 32;
|
|
uptr = uptr | _st_addr[0].laddr;
|
|
|
|
vbuf->buf_info[0].data_addr = (uint8_t *)uptr;
|
|
vbuf->buf_info[0].data_length = _st_addr[0].size;
|
|
|
|
if(_st_addr[1].size > 0){
|
|
uptr = _st_addr[1].haddr;
|
|
uptr = uptr << 32;
|
|
uptr = uptr | _st_addr[1].laddr;
|
|
|
|
vbuf->buf_info[1].data_addr = (uint8_t *)uptr;
|
|
vbuf->buf_info[1].data_length = _st_addr[1].size;
|
|
}
|
|
}
|
|
|
|
static int capture_raw(uint8_t *rkraw_data, uint32_t rkraw_len)
|
|
{
|
|
rk_aiq_vbuf buf;
|
|
struct _block_header _header;
|
|
_header.block_id = NORMAL_RAW_TAG;
|
|
uint16_t end_tag = END_TAG;
|
|
//print_v4l2_info(vbuf, vfmt, state);
|
|
|
|
memset(&buf, 0, sizeof(rk_aiq_vbuf));
|
|
|
|
parse_rk_rawdata(rkraw_data, rkraw_len, &buf);
|
|
|
|
char filname[32];
|
|
sprintf(filname, "/tmp/raw%d", saved_num);
|
|
FILE *fp = fopen(filname,"wb");
|
|
if(fp){
|
|
int ret = 0;
|
|
_header.block_length = buf.buf_info[0].data_length;
|
|
|
|
ret += fwrite(rkraw_data, 1, sizeof(struct _raw_format) + 2, fp);
|
|
|
|
if(buf.buf_info[1].data_length > 0)
|
|
_header.block_id = HDR_S_RAW_TAG;
|
|
ret += fwrite(&_header, 1, sizeof(struct _block_header), fp);
|
|
ret += fwrite((void *)buf.buf_info[0].data_addr, 1, buf.buf_info[0].data_length, fp);
|
|
|
|
if(buf.buf_info[1].data_length > 0){
|
|
_header.block_id = HDR_M_RAW_TAG;
|
|
ret += fwrite(&_header, 1, sizeof(struct _block_header), fp);
|
|
ret += fwrite((void *)buf.buf_info[0].data_addr, 1, buf.buf_info[0].data_length, fp);
|
|
}
|
|
ret += fwrite(&end_tag, 1, 2, fp);
|
|
printf("%s:write file ret %d\n", __func__, ret);
|
|
fclose(fp);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
static int on_frame_ready_capture(uint8_t *rkraw_data, uint32_t rkraw_len)
|
|
{
|
|
debug_print_time("on_frame_ready_capture");
|
|
if(g_quit == 0){
|
|
|
|
capture_raw(rkraw_data, rkraw_len);
|
|
saved_num++;
|
|
if(saved_num == RAWCAP_SAVE_NUM)
|
|
g_quit = 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int on_frame_ready_streaming(uint8_t *rkraw_data, uint32_t rkraw_len)
|
|
{
|
|
//capture_raw(rkraw_data, rkraw_len);
|
|
rkrawstream_vicap_buf_take(g_vi_ctx);
|
|
rkrawstream_readback_set_buffer(g_vi_ctx, rkraw_data);
|
|
|
|
saved_num++;
|
|
if(saved_num == STREAM_SAVE_NUM)
|
|
g_quit = 1;
|
|
return 0;
|
|
}
|
|
|
|
static void on_isp_process_done_streaming(int dev_index)
|
|
{
|
|
printf("on_isp_process_done_streaming\n");
|
|
rkrawstream_vicap_buf_return(g_vi_ctx, dev_index);
|
|
}
|
|
|
|
static void on_isp_process_done_offline(int dev_index)
|
|
{
|
|
printf("%s:index %d\n", __func__, dev_index);
|
|
}
|
|
|
|
void print_sensor_info(rk_aiq_static_info_t *s_info)
|
|
{
|
|
int i = 0;
|
|
printf("\n\n****** sensor %s infos: *********\n",s_info->sensor_info.sensor_name);
|
|
for(i=0; i<10; i++){
|
|
if(s_info->sensor_info.support_fmt[i].width >0)
|
|
printf("format%d: %dx%d, format 0x%x, fps %d hdr %d\n",i,
|
|
s_info->sensor_info.support_fmt[i].width,
|
|
s_info->sensor_info.support_fmt[i].height,
|
|
s_info->sensor_info.support_fmt[i].format,
|
|
s_info->sensor_info.support_fmt[i].fps,
|
|
s_info->sensor_info.support_fmt[i].hdr_mode);
|
|
}
|
|
}
|
|
|
|
#include "rkvi_demo_isp.c_part"
|
|
|
|
int rawcap_test(void)
|
|
{
|
|
strcpy(g_sns_entity_name, SENSOR_ENTNAME);
|
|
printf("g_sns_entity_name:%s\n", g_sns_entity_name);
|
|
sscanf(&g_sns_entity_name[6], "%s", g_sns_name);
|
|
printf("sns_name:%s\n", g_sns_name);
|
|
|
|
rkraw_vi_init_params_t init_p;
|
|
rkraw_vi_prepare_params_t prepare_p;
|
|
|
|
/* init rkraw_vi user api */
|
|
g_vi_ctx = rkrawstream_uapi_init();
|
|
init_p.sns_ent_name = g_sns_entity_name;
|
|
init_p.use_offline = false;
|
|
rkrawstream_vicap_init(g_vi_ctx, &init_p);
|
|
|
|
prepare_p.width = VIDEO_WIDTH;
|
|
prepare_p.height = VIDEO_HEIGHT;
|
|
prepare_p.pix_fmt = V4L2_PIX_FMT_SGBRG10;
|
|
prepare_p.hdr_mode = VIDEO_WORKMODE;
|
|
rkrawstream_vicap_prepare(g_vi_ctx, &prepare_p);
|
|
|
|
rkrawstream_vicap_start(g_vi_ctx, on_frame_ready_capture);
|
|
|
|
while(g_quit == 0)
|
|
usleep(10000);
|
|
|
|
g_aiq_quit = 1;
|
|
rkrawstream_vicap_stop(g_vi_ctx);
|
|
/* clean up library. */
|
|
rkrawstream_uapi_deinit(g_vi_ctx);
|
|
return 0;
|
|
}
|
|
|
|
|
|
int stream_test(void)
|
|
{
|
|
pthread_t isp_tid;
|
|
strcpy(g_sns_entity_name, SENSOR_ENTNAME);
|
|
printf("g_sns_entity_name:%s\n", g_sns_entity_name);
|
|
sscanf(&g_sns_entity_name[6], "%s", g_sns_name);
|
|
printf("sns_name:%s\n", g_sns_name);
|
|
|
|
rkraw_vi_init_params_t init_p;
|
|
rkraw_vi_prepare_params_t prepare_p;
|
|
int param[2];
|
|
|
|
g_ispfd = open(VIDEO_DEVNAME, O_RDWR /* required */ /*| O_NONBLOCK*/, 0);
|
|
if (-1 == g_ispfd) {
|
|
printf("Cannot open '%s'\n", VIDEO_DEVNAME);
|
|
return 0;
|
|
}
|
|
|
|
/* init rkraw_vi user api */
|
|
g_vi_ctx = rkrawstream_uapi_init();
|
|
init_p.sns_ent_name = g_sns_entity_name;
|
|
init_p.use_offline = false;
|
|
rkrawstream_vicap_init(g_vi_ctx, &init_p);
|
|
rkrawstream_readback_init(g_vi_ctx, &init_p);
|
|
|
|
prepare_p.width = VIDEO_WIDTH;
|
|
prepare_p.height = VIDEO_HEIGHT;
|
|
prepare_p.pix_fmt = V4L2_PIX_FMT_SGBRG10;
|
|
prepare_p.hdr_mode = VIDEO_WORKMODE;
|
|
rkrawstream_vicap_prepare(g_vi_ctx, &prepare_p);
|
|
rkrawstream_readback_prepare(g_vi_ctx, &prepare_p);
|
|
|
|
g_aiq_ctx = rk_aiq_uapi2_sysctl_init(g_sns_entity_name, "/etc/iqfiles", NULL, NULL);
|
|
rkrawstream_readback_set_aiqctx(g_vi_ctx, g_aiq_ctx);
|
|
|
|
g_aiq_pause = 1;
|
|
g_aiq_quit = 0;
|
|
param[0] = VIDEO_WIDTH;
|
|
param[1] = VIDEO_HEIGHT;
|
|
pthread_create(&isp_tid, NULL, isp_thread, param);
|
|
sleep(1);
|
|
|
|
rk_aiq_uapi2_sysctl_prepare(g_aiq_ctx, VIDEO_WIDTH, VIDEO_HEIGHT, VIDEO_WORKMODE);
|
|
rk_aiq_uapi2_sysctl_start(g_aiq_ctx);
|
|
|
|
printf("rkisp_init_device %d %d\n", param[0], param[1]);
|
|
rkisp_init_device(param[0], param[1]);
|
|
rkisp_start_capturing();
|
|
|
|
rkrawstream_vicap_start(g_vi_ctx, on_frame_ready_streaming);
|
|
rkrawstream_readback_start(g_vi_ctx, on_isp_process_done_streaming);
|
|
g_aiq_pause = 0;
|
|
|
|
while(g_quit == 0)
|
|
usleep(10000);
|
|
|
|
g_aiq_quit = 1;
|
|
rkrawstream_vicap_stop(g_vi_ctx);
|
|
rkrawstream_readback_stop(g_vi_ctx);
|
|
rk_aiq_uapi2_sysctl_stop(g_aiq_ctx, false);
|
|
/* clean up library. */
|
|
rkrawstream_uapi_deinit(g_vi_ctx);
|
|
|
|
pthread_join(isp_tid, NULL);
|
|
|
|
rkisp_stop_capturing();
|
|
rkisp_uninit_device();
|
|
rk_aiq_uapi2_sysctl_deinit(g_aiq_ctx);
|
|
|
|
close(g_ispfd);
|
|
return 0;
|
|
}
|
|
|
|
void release_buffer(void *addr) {
|
|
printf("release buffer called: addr=%p\n", addr);
|
|
}
|
|
|
|
void parse_rk_rawdata_exp(uint8_t *rawdata)
|
|
{
|
|
unsigned short tag = 0;
|
|
struct _block_header header;
|
|
uint8_t *p = (uint8_t *)rawdata;
|
|
bool bExit = false;
|
|
|
|
struct _st_addrinfo_stream _st_addr[3];
|
|
struct _raw_format _rawfmt;
|
|
|
|
while(!bExit){
|
|
tag = *((unsigned short*)p);
|
|
switch (tag)
|
|
{
|
|
case START_TAG:
|
|
p = p+TAG_BYTE_LEN;
|
|
memset(_st_addr, 0, sizeof(_st_addr));
|
|
memset(&_rawfmt, 0, sizeof(_rawfmt));
|
|
memset(&_finfo, 0, sizeof(_finfo));
|
|
break;
|
|
case NORMAL_RAW_TAG:
|
|
{
|
|
header = *((struct _block_header *)p);
|
|
p = p + sizeof(struct _block_header);
|
|
if (header.block_length == sizeof(struct _st_addrinfo_stream)) {
|
|
_st_addr[0] = *((struct _st_addrinfo_stream*)p);
|
|
}
|
|
p = p + header.block_length;
|
|
|
|
break;
|
|
}
|
|
case HDR_S_RAW_TAG:
|
|
{
|
|
header = *((struct _block_header *)p);
|
|
p = p + sizeof(struct _block_header);
|
|
if (header.block_length == sizeof(struct _st_addrinfo_stream)) {
|
|
_st_addr[0] = *((struct _st_addrinfo_stream*)p);
|
|
}
|
|
p = p + header.block_length;
|
|
break;
|
|
}
|
|
case HDR_M_RAW_TAG:
|
|
{
|
|
header = *((struct _block_header *)p);
|
|
p = p + sizeof(struct _block_header);
|
|
if (header.block_length == sizeof(struct _st_addrinfo_stream)) {
|
|
_st_addr[1] = *((struct _st_addrinfo_stream*)p);
|
|
}
|
|
p = p + header.block_length;
|
|
break;
|
|
}
|
|
case HDR_L_RAW_TAG:
|
|
{
|
|
header = *((struct _block_header *)p);
|
|
p = p + sizeof(struct _block_header);
|
|
if (header.block_length == sizeof(struct _st_addrinfo_stream)) {
|
|
_st_addr[2] = *((struct _st_addrinfo_stream*)p);
|
|
}
|
|
p = p + header.block_length;
|
|
break;
|
|
}
|
|
case FORMAT_TAG:
|
|
{
|
|
_rawfmt = *((struct _raw_format *)p);
|
|
p = p + sizeof(struct _block_header) + _rawfmt.size;
|
|
break;
|
|
}
|
|
case STATS_TAG:
|
|
{
|
|
_finfo = *((rk_aiq_frame_info_t *)p);
|
|
p = p + sizeof(struct _block_header) + _finfo.size;
|
|
break;
|
|
}
|
|
case ISP_REG_FMT_TAG:
|
|
{
|
|
header = *((struct _block_header *)p);
|
|
p += sizeof(struct _block_header);
|
|
p = p + header.block_length;
|
|
break;
|
|
}
|
|
case ISP_REG_TAG:
|
|
{
|
|
header = *((struct _block_header *)p);
|
|
p += sizeof(struct _block_header);
|
|
p = p + header.block_length;
|
|
break;
|
|
}
|
|
case ISPP_REG_FMT_TAG:
|
|
{
|
|
header = *((struct _block_header *)p);
|
|
p += sizeof(struct _block_header);
|
|
p = p + header.block_length;
|
|
break;
|
|
}
|
|
case ISPP_REG_TAG:
|
|
{
|
|
header = *((struct _block_header *)p);
|
|
p += sizeof(struct _block_header);
|
|
p = p + header.block_length;
|
|
break;
|
|
}
|
|
case PLATFORM_TAG:
|
|
{
|
|
header = *((struct _block_header *)p);
|
|
p += sizeof(struct _block_header);
|
|
p = p + header.block_length;
|
|
break;
|
|
}
|
|
case END_TAG:
|
|
{
|
|
//uint32_t _len = p - (uint8_t *)rawdata;
|
|
//printf("_len %d rkraw_len %d\n", _len, rkraw_len);
|
|
bExit = true;
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
printf("Not support TAG(0x%04x)\n", tag);
|
|
bExit = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
printf("frame_id %d, size %d %d %d, format %dx%d\n",
|
|
_rawfmt.frame_id,
|
|
_st_addr[0].size,_st_addr[1].size,_st_addr[2].size,
|
|
_rawfmt.width, _rawfmt.height
|
|
);
|
|
}
|
|
|
|
int offline_test(void)
|
|
{
|
|
pthread_t isp_tid;
|
|
|
|
if (use_isp_driver) {
|
|
prepare_rkraw();
|
|
g_rkraw_index = 0;
|
|
parse_rk_rawdata_exp(g_rkraw_buffer);
|
|
rk_aiq_frame_info_t offline_finfo[2];
|
|
offline_finfo[0] = _finfo;
|
|
offline_finfo[1] = _finfo;
|
|
if (!rk_aiq_uapi2_sysctl_rawReproc_preInit(isp_vir, real_sns, offline_finfo)) {
|
|
printf("%s is no exit\n", isp_vir);
|
|
return -1;
|
|
}
|
|
strcpy(g_sns_entity_name, rk_aiq_uapi2_sysctl_getBindedSnsEntNmByVd(video_name));
|
|
}else{
|
|
strcpy(g_sns_entity_name, rk_aiq_uapi2_sysctl_getBindedSnsEntNmByVd(VIDEO_DEVNAME));
|
|
}
|
|
printf("g_sns_entity_name:%s\n", g_sns_entity_name);
|
|
sscanf(&g_sns_entity_name[6], "%s", g_sns_name);
|
|
printf("sns_name:%s\n", g_sns_name);
|
|
|
|
rkraw_vi_init_params_t init_p;
|
|
rkraw_vi_prepare_params_t prepare_p;
|
|
int param[2];
|
|
|
|
if (use_isp_driver) {
|
|
g_ispfd = open(video_name, O_RDWR /* required */ /*| O_NONBLOCK*/, 0);
|
|
if (-1 == g_ispfd) {
|
|
printf("Cannot open '%s'\n", video_name);
|
|
return 0;
|
|
}
|
|
} else {
|
|
g_ispfd = open(VIDEO_DEVNAME, O_RDWR /* required */ /*| O_NONBLOCK*/, 0);
|
|
if (-1 == g_ispfd) {
|
|
printf("Cannot open '%s'\n", VIDEO_DEVNAME);
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
/* init rkraw_vi user api */
|
|
if (use_isp_driver){
|
|
g_vi_ctx = rkrawstream_uapi_init(isp_vir, real_sns);
|
|
} else {
|
|
g_vi_ctx = rkrawstream_uapi_init();
|
|
}
|
|
init_p.sns_ent_name = g_sns_entity_name;
|
|
init_p.use_offline = true;
|
|
rkrawstream_readback_init(g_vi_ctx, &init_p);
|
|
if (use_isp_driver) {
|
|
rk_aiq_uapi2_sysctl_preInit(g_sns_entity_name, RK_AIQ_WORKING_MODE_NORMAL, iq_file_name);
|
|
}
|
|
g_aiq_ctx = rk_aiq_uapi2_sysctl_init(g_sns_entity_name, "/etc/iqfiles", NULL, NULL);
|
|
rkrawstream_readback_set_aiqctx(g_vi_ctx, g_aiq_ctx);
|
|
|
|
rk_aiq_raw_prop_t prop;
|
|
if (pix_fmt == V4L2_PIX_FMT_SBGGR10)
|
|
prop.format = RK_PIX_FMT_SBGGR10;
|
|
else if (pix_fmt == V4L2_PIX_FMT_SGBRG10)
|
|
prop.format = RK_PIX_FMT_SGBRG10;
|
|
else if (pix_fmt == V4L2_PIX_FMT_SRGGB10)
|
|
prop.format = RK_PIX_FMT_SRGGB10;
|
|
else if (pix_fmt == V4L2_PIX_FMT_SGRBG10)
|
|
prop.format = RK_PIX_FMT_SGRBG10;
|
|
else if (pix_fmt == V4L2_PIX_FMT_SBGGR12)
|
|
prop.format = RK_PIX_FMT_SBGGR12;
|
|
else if (pix_fmt == V4L2_PIX_FMT_SGBRG12)
|
|
prop.format = RK_PIX_FMT_SGBRG12;
|
|
else if (pix_fmt == V4L2_PIX_FMT_SRGGB12)
|
|
prop.format = RK_PIX_FMT_SRGGB12;
|
|
else if (pix_fmt == V4L2_PIX_FMT_SGRBG12)
|
|
prop.format = RK_PIX_FMT_SGRBG12;
|
|
else if (pix_fmt == V4L2_PIX_FMT_SBGGR14)
|
|
prop.format = RK_PIX_FMT_SBGGR14;
|
|
else if (pix_fmt == V4L2_PIX_FMT_SGBRG14)
|
|
prop.format = RK_PIX_FMT_SGBRG14;
|
|
else if (pix_fmt == V4L2_PIX_FMT_SRGGB14)
|
|
prop.format = RK_PIX_FMT_SRGGB14;
|
|
else if (pix_fmt == V4L2_PIX_FMT_SGRBG14)
|
|
prop.format = RK_PIX_FMT_SGRBG14;
|
|
else
|
|
prop.format = RK_PIX_FMT_SBGGR10;
|
|
prop.frame_width = raw_width;
|
|
prop.frame_height = raw_height;
|
|
prop.rawbuf_type = RK_AIQ_RAW_FILE;
|
|
rk_aiq_uapi2_sysctl_prepareRkRaw(g_aiq_ctx, prop);
|
|
|
|
|
|
if(use_isp_driver) {
|
|
prepare_p.width = raw_width;
|
|
prepare_p.height = raw_height;
|
|
prepare_p.pix_fmt = pix_fmt;
|
|
prepare_p.hdr_mode = hdr_mode;
|
|
} else {
|
|
prepare_p.width = VIDEO_WIDTH;
|
|
prepare_p.height = VIDEO_HEIGHT;
|
|
prepare_p.pix_fmt = V4L2_PIX_FMT_SGBRG10;
|
|
prepare_p.hdr_mode = VIDEO_WORKMODE;
|
|
}
|
|
rkrawstream_readback_prepare(g_vi_ctx, &prepare_p);
|
|
|
|
g_aiq_pause = 1;
|
|
g_aiq_quit = 0;
|
|
param[0] = video_width;
|
|
param[1] = video_height;
|
|
pthread_create(&isp_tid, NULL, isp_thread, param);
|
|
sleep(2);
|
|
|
|
rk_aiq_uapi2_sysctl_prepare(g_aiq_ctx, video_width, video_height, VIDEO_WORKMODE);
|
|
//rk_aiq_uapi2_sysctl_registRkRawCb(g_aiq_ctx, release_buffer);
|
|
rk_aiq_uapi2_sysctl_start(g_aiq_ctx);
|
|
|
|
printf("rkisp_init_device %d %d\n", param[0], param[1]);
|
|
rkisp_init_device(param[0], param[1]);
|
|
rkisp_start_capturing();
|
|
|
|
rkrawstream_readback_start(g_vi_ctx, on_isp_process_done_offline);
|
|
g_aiq_pause = 0;
|
|
|
|
while(g_quit == 0){
|
|
/* in offline mode, feed frames to isp.*/
|
|
printf("\n");
|
|
if(prepare_rkraw() < 0){
|
|
break;
|
|
}else{
|
|
usleep(30000);
|
|
}
|
|
rkrawstream_readback_set_buffer(g_vi_ctx, g_rkraw_buffer);
|
|
usleep(100000);
|
|
}
|
|
|
|
g_aiq_quit = 1;
|
|
rkrawstream_readback_stop(g_vi_ctx);
|
|
rk_aiq_uapi2_sysctl_stop(g_aiq_ctx, false);
|
|
/* clean up library. */
|
|
rkrawstream_uapi_deinit(g_vi_ctx);
|
|
|
|
pthread_join(isp_tid, NULL);
|
|
|
|
rkisp_stop_capturing();
|
|
rkisp_uninit_device();
|
|
rk_aiq_uapi2_sysctl_deinit(g_aiq_ctx);
|
|
|
|
close(g_ispfd);
|
|
return 0;
|
|
}
|
|
|
|
void print_help()
|
|
{
|
|
printf("\n\n****** librkraw_vi demo by ydb *********\n\n");
|
|
printf("--rawcap capture rkraw file in /tmp.\n");
|
|
printf("--stream live stream to isp.\n");
|
|
printf("--offaiq run aiq and isp offline.\n");
|
|
printf("you must choose one from rawcap, stream and offaiq, and you just can choose one of them\n");
|
|
printf("\nif you choose --offaiq, there are some params you can config\n");
|
|
printf("--width video width, default value 640\n");
|
|
printf("--height video height, default value 480\n");
|
|
printf("--rawfmt raw width and height, config it such as 640x480, use 'x', don't use 'X'\n");
|
|
printf("--iqfile enter iqfile name, iq file can be found at /etc/iqfiles/\n");
|
|
printf("--ispdriver isp driver module name, such as rkisp0-vir0\n");
|
|
printf("--video mainpath video on the isp driver you choosed, such as /dev/video8\n");
|
|
printf("--sensor what sensor name of raw, such as imx415\n");
|
|
printf("--pix raw pix fmt, such as GB10(SGBRG10), default value BG10(SBGGR10)\n");
|
|
printf(" all pix fmt BG10, GB10, BA10, RG10, BG12, GB12, RG12, BA12, BG14, GB14, RG14, BA14\n");
|
|
printf("--har optional, hdr mode, val 2 means hdrx2, 3 means hdrx3, default value 0(normal mode)");
|
|
printf("--help print help info\n");
|
|
}
|
|
|
|
static void parse_args(int argc, char **argv)
|
|
{
|
|
int c;
|
|
int digit_optind = 0;
|
|
optind = 0;
|
|
while (1) {
|
|
int this_option_optind = optind ? optind : 1;
|
|
int option_index = 0;
|
|
static struct option long_options[] = {
|
|
{"width", required_argument, 0, 'w' },
|
|
{"height", required_argument, 0, 'h' },
|
|
{"offaiq", no_argument, 0, 'f' },
|
|
{"video", required_argument, 0, 'v' },
|
|
{"stream", no_argument, 0, 'o' },
|
|
{"rawcap", no_argument, 0, 'r' },
|
|
{"help", no_argument, 0, 'p' },
|
|
{"iqfile", required_argument, 0, 'i' },
|
|
{"sensor", required_argument, 0, 's' },
|
|
{"ispdriver", required_argument, 0, 'd' },
|
|
{"hdr", required_argument, 0, 'a'},
|
|
{"pix", required_argument, 0, 'x'},
|
|
{"rawfmt", required_argument, 0, 't'},
|
|
{0, 0, 0, 0 }
|
|
};
|
|
|
|
//c = getopt_long(argc, argv, "w:h:f:i:d:o:c:ps",
|
|
c = getopt_long(argc, argv, "w:h:v:d:i:s:t:orfp",
|
|
long_options, &option_index);
|
|
if (c == -1)
|
|
break;
|
|
|
|
switch (c)
|
|
{
|
|
case 'w':
|
|
video_width = atoi(optarg);
|
|
break;
|
|
case 'h':
|
|
video_height = atoi(optarg);
|
|
break;
|
|
case 'f':
|
|
{
|
|
use_isp_driver = true;
|
|
modul_select = 1;
|
|
}
|
|
break;
|
|
case 'v':
|
|
video_name = optarg;
|
|
break;
|
|
case 'd':
|
|
isp_vir = optarg;
|
|
break;
|
|
case 'i':
|
|
iq_file_name = optarg;
|
|
break;
|
|
case 's':
|
|
real_sns = optarg;
|
|
break;
|
|
case 'o':
|
|
modul_select = 2;
|
|
break;
|
|
case 'r':
|
|
modul_select = 3;
|
|
break;
|
|
case 'p':
|
|
print_help();
|
|
break;
|
|
case 'a':
|
|
{
|
|
int mode_val = atoi(optarg);
|
|
if (mode_val == 2) {
|
|
hdr_mode = RK_AIQ_WORKING_MODE_ISP_HDR2;
|
|
}else if (mode_val == 3) {
|
|
hdr_mode = RK_AIQ_WORKING_MODE_ISP_HDR3;
|
|
} else {
|
|
hdr_mode = RK_AIQ_WORKING_MODE_NORMAL;
|
|
}
|
|
|
|
}
|
|
break;
|
|
case 'x':
|
|
{
|
|
if (strcmp(optarg, "BG10") == 0)
|
|
pix_fmt = V4L2_PIX_FMT_SBGGR10;
|
|
else if (strcmp(optarg, "GB10") == 0)
|
|
pix_fmt = V4L2_PIX_FMT_SGBRG10;
|
|
else if (strcmp(optarg, "RG10") == 0)
|
|
pix_fmt = V4L2_PIX_FMT_SRGGB10;
|
|
else if (strcmp(optarg, "BA10") == 0)
|
|
pix_fmt = V4L2_PIX_FMT_SGRBG10;
|
|
else if (strcmp(optarg, "BG12") == 0)
|
|
pix_fmt = V4L2_PIX_FMT_SBGGR12;
|
|
else if (strcmp(optarg, "GB12") == 0)
|
|
pix_fmt = V4L2_PIX_FMT_SGBRG12;
|
|
else if (strcmp(optarg, "RG12") == 0)
|
|
pix_fmt = V4L2_PIX_FMT_SRGGB12;
|
|
else if (strcmp(optarg, "BA12") == 0)
|
|
pix_fmt = V4L2_PIX_FMT_SGRBG12;
|
|
else if (strcmp(optarg, "BG14") == 0)
|
|
pix_fmt = V4L2_PIX_FMT_SBGGR14;
|
|
else if (strcmp(optarg, "GB14") == 0)
|
|
pix_fmt = V4L2_PIX_FMT_SGBRG14;
|
|
else if (strcmp(optarg, "RG14") == 0)
|
|
pix_fmt = V4L2_PIX_FMT_SRGGB14;
|
|
else if (strcmp(optarg, "BA14") == 0)
|
|
pix_fmt = V4L2_PIX_FMT_SGRBG14;
|
|
else
|
|
pix_fmt = V4L2_PIX_FMT_SBGGR10;
|
|
}
|
|
break;
|
|
case 't':
|
|
{
|
|
raw_width = atoi(optarg);
|
|
char *raw_fmt = strstr(optarg, "x");
|
|
raw_height = atoi(raw_fmt + 1);
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
int main(int argc, char **argv)
|
|
{
|
|
bool use_aiq = false;
|
|
bool use_rawcap = false;
|
|
bool use_rawstream = false;
|
|
bool test_switch = false;
|
|
bool use_offline = false;
|
|
pthread_t isp_tid;
|
|
g_aiq_test_mode = 0;
|
|
|
|
//rkraw_vi_sensor_info_t m_info = {0};
|
|
rk_aiq_static_info_t s_info;
|
|
|
|
parse_args(argc, argv);
|
|
if (!modul_select)
|
|
return 0;
|
|
switch (modul_select)
|
|
{
|
|
case 1:
|
|
offline_test();
|
|
break;
|
|
case 2:
|
|
stream_test();
|
|
break;
|
|
case 3:
|
|
rawcap_test();
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
return 0;
|
|
}
|
|
|