将代码中的输入改为通过socket接收（参考代码中的receive_data_via_socket()函数），输出改为通过socket发送（参考代码中的send_data_via_socket（）函数）。将只执行一次的逻辑（
proc_oneshot）改成持续执行接收来自socket的数据：/**
@brief Source file of vendor ai net sample code.
@file ai_net_with_mblob.c
@
ingroup ai_net_sample
@note Noth
ing.
Copyright Novatek Microelectronics Corp. 2021. All rights reserved.
*/
/*-----------------------------------------------------------------------------*/
/*
Includ
ing Files */
/*-----------------------------------------------------------------------------*/
#
include <stdio.h>
#
include <unistd.h>
#
include <stdlib.h>
#
include <str
ing.h>
#
include "hdal.h"
#
include "hd_debug.h"
#
include "vendor_ai.h"
#
include "vendor_ai_cpu/vendor_ai_cpu.h"
#
include <sys/time.h>
#if def
ined(_NVT_NVR_SDK_)
#
include <comm/nvtmem_if.h>
#
include <sys/ioctl.h>
#endif
#if def
ined(_BSP_NA51068_) || def
ined(_BSP_NA51090_)
#
include "vendor_common.h"
#endif
// plat
form dependent
#if def
ined(__
LINUX)
#
include <signal.h>
#
include <p
thread.h> //
for p
thread API
#def
ine MA
IN(argc, argv)
int ma
in(
int argc, char** argv)
#def
ine GETCHAR() getchar()
#else
#
include <FreeRTOS_POSIX.h>
#
include <FreeRTOS_POSIX/signal.h>
#
include <FreeRTOS_POSIX/p
thread.h> //
for p
thread API
#
include <kwrap/util.h> //
for sleep API
#
include <sys/socket.h>
#
include <arpa/
inet.h>
#
include <net
inet/
in.h>
#def
ine sleep(x) vos_util_delay_ms(1000*(x))
#def
ine msleep(x) vos_util_delay_ms(x)
#def
ine usleep(x) vos_util_delay_us(x)
#
include <kwrap/examsys.h> //
for MA
IN(), GETCHAR() API
#def
ine MA
IN(argc, argv) EXAMFUNC_ENTRY(ai3_net_with_mblob, argc, argv)
#def
ine GETCHAR() NVT_EXAMSYS_GETCHAR()
#endif
#def
ine DEBUG_MENU 1
#def
ine DUMP_POST
PROC_
INFO 1
#def
ine DBG_OUT_DUMP 0 // debug mode, dump output iobuf
#def
ine FLOAT_
IN 0
#def
ine FLOAT_OUT 0
///////////////////////////////////////////////////////////////////////////////
#def
ine NET_PATH_ID U
INT32
#def
ine VENDOR_AI_CFG 0x000f0000 //vendor ai config
#def
ine AI_RGB_BUFSIZE(w, h) (ALIGN_CEIL_4((w) * HD_VIDEO_PXLFMT_BPP(HD_VIDEO_PXLFMT_RGB888_PLANAR) / 8) * (h))
#def
ine MULTI_BATCH_
IN 0
#def
ine CONFIG_
INTERNAL_BUFFER 0
#def
ine OUTPUT 1 // 是否输出，debug用
#def
ine BATCH_SIZE 64
U
INT32 g_
proc_num=10;
U
INT32 dump_time_ut=0;
U
INT32 dump_time_
proc=0;
U
INT32 dump_output=0;
static U
INT M
PROCESS_
FOR_AIISP =0;
CHAR dump_path[256];
///////////////////////////////////////////////////////////////////////////////
/*-----------------------------------------------------------------------------*/
/* Type Def
initions */
/*-----------------------------------------------------------------------------*/
typedef struct _MEM_PARM {
U
INTPTR pa;
U
INTPTR va;
U
INT32 size;
U
INTPTR blk;
} MEM_PARM;
/*-----------------------------------------------------------------------------*/
/* Global Functions */
/*-----------------------------------------------------------------------------*/
static HD_RESULT receive_data_via_socket(NET_
PROC *p_net,
int sockfd, U
INT32
input_cnt) {
HD_RESULT ret = HD_OK;
U
INT32 i;
for (i = 0; i < p_net->net_
info.
in_buf_cnt; i++) {
// 接收输入数据长度
U
INT32 data_size = p_net ->
in_buf[i].size; // 预期输入数据大小
size_t total_recevied = 0;
size_t rema
ining = data_size; // 剩余需要接收的
//char *data_buffer = (char *)p_net->
in_buf[i].va;
u
intptr_t data_buffer = p_net ->
in_buf[i].va;
// MEM_PARM mem_parm;
// mem_parm.va = p_net->
in_buf[i].va;
// 超时退出设置
struct timeval tv;
tv.tv_sec = 5;
tv.tv_usec = 0;
setsockopt(sockfd, SOL_SOCKET, SO_RCVTIMEO, (const char*)&tv, sizeof(tv));
while (rema
ining > 0)
{
ssize_t bytes_received = recv(sockfd, (void *)(data_buffer + total_recevied), rema
ining, 0);
if (bytes_received <= 0){
if (bytes_received == 0) {
pr
intf("Client closed connection dur
ing data transfer\n");
return HD_ERR_USER;
}
else if (errno == EAGA
IN || errno == EWOULDBLOCK)
{
pr
intf("Socket receive timeout\n");
return HD_ERR_TIMEDOUT;
}
else {
perror("recv error dur
ing data transfer \n");
return HD_ERR_USER;
}
}
total_recevied += bytes_received;
rema
ining -= bytes_received;
}
if (
input_cnt == 0) // 只在第一次打印此信息
{
pr
intf("\n Received
input %d data via socket, size: %u bytes\n", i, data_size);
}
}
return ret;
}
#if OUTPUT==1
/**
* @brief 通过Socket发送输出结果
* @param p_net 网络处理结构体指针
* @param sockfd Socket文件描述符
* @return HD_RESULT 操作结果
*/
static HD_RESULT send_data_via_socket(NET_
PROC *p_net,
int sockfd, U
INT32
input_cnt, char* out_pr
int) {
HD_RESULT ret = HD_OK;
U
INT32 outlay_num = p_net->net_
info.out_buf_cnt;
LONG total_size = 0;
VENDOR_AI3_BUF ai_buf = {0};
if (out_pr
int == NULL)
{
pr
intf("out_pr
int malloc size fail \n");
return HD_ERR_FAIL;
}
// total_size += spr
intf(out_pr
int + total_size, "
input
index %u\n",
input_cnt);
/* 格式化输出结果 */
for (U
INT32 i=0; i < outlay_num; i++)
{
ret = vendor_ai3_net_get(p_net->
proc_id, p_net->net_
info.out_path_list[i], &ai_buf);
U
INT32 out_length = ai_buf.time * ai_buf.batch_num * ai_buf.channel * ai_buf.height * ai_buf.width; // 输出数据量
// /* 新增文件写入部分 */
FILE *fp = fopen("output.b
in", "wb+"); // 以二进制写入模式打开文件
if (fp == NULL) {
perror("Error open
ing file"); // 输出错误信息
return HD_ERR_FAIL; // 返回错误码
}
size_t written = fwrite((void *)p_net->out_mem_float[i].va, sizeof(FLOAT), out_length, fp); // 写入文件
pr
intf("output ai buf size:%d, out length:%d \n", ai_buf.size, out_length);
if (written != out_length) {
perror("Error writ
ing to file"); // 输出写入错误
fclose(fp);
return HD_ERR_FAIL;
}
fclose(fp); // 关闭文件
if (HD_OK != ret) {
pr
intf("net_path(%u),
proc_id(%u) get out buf fail, i(%d), out_path(0x%x)\n", p_net->net_id, p_net->
proc_id, i, p_net->net_
info.out_path_list[i]);
return ret;
}
if (
input_cnt == 1 && i % dump_mean_time_freq == 0)
{
pr
intf("#######output_size:%u\n", out_length);
}
FLOAT *curr_layer_float_ptr =(FLOAT *)p_net->out_mem_float[i].va;
for (U
INT32 k = 0; k < out_length-1; k++)
{
// 2025.10.21新增：多batch时需要每行只输出一个样本的结果
if ((k+1) % (ai_buf.time * ai_buf.channel * ai_buf.height * ai_buf.width) == 0 && ai_buf.batch_num != 1)
{
total_size += spr
intf(out_pr
int + total_size, "%f\n", *(curr_layer_float_ptr+k));
}
else
{
total_size += spr
intf(out_pr
int + total_size, "%f ", *(curr_layer_float_ptr+k));
}
//total_size += spr
intf(out_pr
int + total_size, "%f ", *(curr_layer_float_ptr+k));
}
total_size += spr
intf(out_pr
int + total_size, "%f\n", *(curr_layer_float_ptr+(out_length-1)));
}
write(sockfd, out_pr
int, total_size);
// 释放内存
//
for (U
INT32 i = 0; i < outlay_num; i++)
// {
// free(outlayer_float[i]);
// outlayer_float[i] = NULL;
// }
// free(outlayer_float);
// outlayer_float = NULL;
return ret;
}
#endif
/**
* @brief 设置Socket服务器
* @return
int 监听Socket的文件描述符
*/
static
int setup_socket_server(void) {
int server_fd;
struct sockaddr_
in address;
int opt = 1;
// 创建Socket文件描述符
if ((server_fd = socket(AF_
INET, SOCK_STREAM, 0)) == 0) {
perror("socket failed");
exit(EXIT_FAILURE);
}
// 设置Socket选项
if (setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt, sizeof(opt))) {
perror("setsockopt failed");
close(server_fd);
exit(EXIT_FAILURE);
}
// 绑定地址和端口
address.s
in_family = AF_
INET;
address.s
in_addr.s_addr =
INADDR_ANY;
address.s
in_port = htons(SOCKET_PORT);
if (b
ind(server_fd, (struct sockaddr *)&address, sizeof(address)) < 0) {
perror("b
ind failed");
close(server_fd);
exit(EXIT_FAILURE);
}
// 开始监听
if (listen(server_fd, MAX_CLIENTS) < 0) {
perror("listen failed");
close(server_fd);
exit(EXIT_FAILURE);
}
pr
intf("Socket server listen
ing on port %d\n", SOCKET_PORT);
return server_fd;
}
static HD_RESULT mem_alloc(MEM_PARM *mem_parm, CHAR* name, U
INT32 size)
{
HD_RESULT ret = HD_OK;
U
INTPTR pa = 0;
void *va = NULL;
//alloc private pool
ret = hd_common_mem_alloc(name, &pa, (void**)&va, size, DDR_ID0);
if (ret!= HD_OK) {
return ret;
}
mem_parm->pa = pa;
mem_parm->va = (U
INTPTR)va;
mem_parm->size = size;
mem_parm->blk = (U
INTPTR)-1;
return HD_OK;
}
static HD_RESULT mem_free(MEM_PARM *mem_parm)
{
HD_RESULT ret = HD_OK;
//free private pool
ret = hd_common_mem_free(mem_parm->pa, (void *)mem_parm->va);
if (ret!= HD_OK) {
return ret;
}
mem_parm->pa = 0;
mem_parm->va = 0;
mem_parm->size = 0;
mem_parm->blk = (U
INT32)-1;
return HD_OK;
}
static
INT32 mem_load(MEM_PARM *mem_parm, const CHAR *filename)
{
FILE *fd;
INT32 size = 0;
fd = fopen(filename, "rb");
if (!fd) {
pr
intf("cannot read %s\r\n", filename);
size = -1;
goto exit;
}
fseek(fd, 0, SEEK_END);
size = ftell(fd);
fseek(fd, 0, SEEK_SET);
// check "ai_
in_buf" enough or not
if (mem_parm->size < (U
INT32)size) {
pr
intf("ERROR: ai_
in_buf(%u) is not enough,
input file(%u)\r\n", mem_parm->size, (U
INT32)size);
size = -1;
goto exit;
}
if (size < 0) {
pr
intf("
getting %s size failed\r\n", filename);
goto exit;
} else if ((
INT32)fread((VOID *)mem_parm->va, 1, size, fd) != size) {
pr
intf("read size < %d\r\n", size);
size = -1;
goto exit;
}
mem_parm->size = size;
// we use cpu to read memory, which needs to deal cache flush.
if(hd_common_mem_flush_cache((VOID *)mem_parm->va, mem_parm->size) != HD_OK) {
pr
intf("flush cache failed.\r\n");
}
exit:
if (fd) {
fclose(fd);
}
return size;
}
/*-----------------------------------------------------------------------------*/
/*
Input Functions */
/*-----------------------------------------------------------------------------*/
///////////////////////////////////////////////////////////////////////////////
typedef struct _NET_
IN_CONFIG {
CHAR
input_filename[256];
U
INT32 w;
U
INT32 h;
U
INT32 c;
U
INT32 b;
U
INT32 bitdepth;
U
INT32 loff;
U
INT32 fmt;
U
INT32 is_comb_img; // 1: image image (or feature-
in) is a comb
ination image (or feature-
in).
} NET_
IN_CONFIG;
typedef struct _NET_
IN {
NET_
IN_CONFIG
in_cfg;
MEM_PARM
input_mem;
U
INT32
in_id;
VENDOR_AI3_BUF src_img;
} NET_
IN;
static NET_
IN *g_
in = NULL;
static U
INT32 _calc_ai_buf_size(U
INT32 loff, U
INT32 h, U
INT32 c, U
INT32 b, U
INT32 bitdepth, U
INT32 fmt)
{
U
INT size = 0;
switch (fmt) {
case HD_VIDEO_PXLFMT_YUV420:
{
size = loff * h * 3 / 2;
}
break;
case HD_VIDEO_PXLFMT_RGB888_PLANAR:
{
size = AI_RGB_BUFSIZE(loff, h);
}
break;
case HD_VIDEO_PXLFMT_BGR888_PLANAR:
{
size = AI_RGB_BUFSIZE(loff, h);
}
break;
default: // feature-
in
{
size = loff * h * c * bitdepth/8;
}
break;
}
if (!size) {
pr
intf("ERROR!! ai_buf size = 0\n");
}
return size;
}
static HD_RESULT _load_buf(MEM_PARM *mem_parm, CHAR *filename, VENDOR_AI3_BUF *p_buf, U
INT32 w, U
INT32 h, U
INT32 c, U
INT32 b, U
INT32 bitdepth, U
INT32 loff, U
INT32 fmt)
{
INT32 file_len;
file_len = mem_load(mem_parm, filename);
if (file_len < 0) {
pr
intf("load buf(%s) fail\r\n", filename);
return HD_ERR_NG;
}
pr
intf("load buf(%s) ok\r\n", filename);
p_buf->width = w;
p_buf->height = h;
p_buf->channel = c;
p_buf->batch_num = b;
p_buf->l
ine_ofs = loff;
p_buf->fmt = fmt;
p_buf->pa = mem_parm->pa;
p_buf->va = mem_parm->va;
p_buf->sign = MAKEFOURCC('A','B','U','F');
p_buf->size = _calc_ai_buf_size(loff, h, c, b, bitdepth, fmt);
if (p_buf->size == 0) {
pr
intf("load buf(%s) fail, p_buf->size = 0\r\n", filename);
return HD_ERR_NG;
}
return HD_OK;
}
static HD_RESULT
input_
init(void)
{
HD_RESULT ret = HD_OK;
int i;
for (i = 0; i < 16; i++) {
NET_
IN* p_net = g_
in + i;
p_net->
in_id = i;
}
return ret;
}
static HD_RESULT
input_un
init(void)
{
HD_RESULT ret = HD_OK;
return ret;
}
static HD_RESULT
input_set_config(NET_PATH_ID
in_path, NET_
IN_CONFIG* p_
in_cfg)
{
HD_RESULT ret = HD_OK;
NET_
IN* p_net = g_
in +
in_path;
U
INT32
in_id = p_net->
in_id;
memcpy((void*)&p_net->
in_cfg, (void*)p_
in_cfg, sizeof(NET_
IN_CONFIG));
pr
intf("
in_path(%u)
in_id(%u) set
in_cfg: file(%s), buf=(%u,%u,%u,%u,%u,%u,%08x)\r\n",
in_path,
in_id,
p_net->
in_cfg.
input_filename,
p_net->
in_cfg.w,
p_net->
in_cfg.h,
p_net->
in_cfg.c,
p_net->
in_cfg.b,
p_net->
in_cfg.bitdepth,
p_net->
in_cfg.loff,
p_net->
in_cfg.fmt);
return ret;
}
static HD_RESULT
input_open(NET_PATH_ID
in_path)
{
HD_RESULT ret = HD_OK;
NET_
IN* p_net = g_
in +
in_path;
U
INT32
in_id = p_net->
in_id;
U
INT32 buf_size = 0;
CHAR mem_name[23] ;
snpr
intf(mem_name, 23, "ai_
in_buf %u",
in_id);
// calculate
in buf size
buf_size = _calc_ai_buf_size(p_net->
in_cfg.loff, p_net->
in_cfg.h, p_net->
in_cfg.c, p_net->
in_cfg.b, p_net->
in_cfg.bitdepth, p_net->
in_cfg.fmt);
if (buf_size == 0) {
pr
intf("
in_path(%u)
in_id(%u) size == 0 \r\n",
in_path,
in_id);
return HD_ERR_FAIL;
}
// allocate
in buf
ret = mem_alloc(&p_net->
input_mem, mem_name, buf_size * p_net->
in_cfg.b);
if (ret != HD_OK) {
pr
intf("
in_path(%u)
in_id(%u) alloc ai_
in_buf fail\r\n",
in_path,
in_id);
return HD_ERR_FAIL;
}
pr
intf("alloc_
in_buf: pa = 0x%lx, va = 0x%lx, size = %u\n", p_net->
input_mem.pa, p_net->
input_mem.va, p_net->
input_mem.size);
// load
in buf
ret = _load_buf(&p_net->
input_mem,
p_net->
in_cfg.
input_filename,
&p_net->src_img,
p_net->
in_cfg.w,
p_net->
in_cfg.h,
p_net->
in_cfg.c,
p_net->
in_cfg.b,
p_net->
in_cfg.bitdepth,
p_net->
in_cfg.loff,
p_net->
in_cfg.fmt);
if (ret != HD_OK) {
pr
intf("
in_path(%u)
in_id(%u)
input_open fail=%d\n",
in_path,
in_id, ret);
}
return ret;
}
static HD_RESULT
input_close(NET_PATH_ID
in_path)
{
HD_RESULT ret = HD_OK;
NET_
IN* p_net = g_
in +
in_path;
mem_free(&p_net->
input_mem);
return ret;
}
static HD_RESULT
input_start(NET_PATH_ID
in_path)
{
HD_RESULT ret = HD_OK;
return ret;
}
static HD_RESULT
input_stop(NET_PATH_ID
in_path)
{
HD_RESULT ret = HD_OK;
return ret;
}
static HD_RESULT
input_pull_buf(NET_PATH_ID
in_path, VENDOR_AI3_BUF *p_
in,
INT32 wait_ms)
{
HD_RESULT ret = HD_OK;
NET_
IN* p_net = g_
in +
in_path;
memcpy((void*)p_
in, (void*)&(p_net->src_img), sizeof(VENDOR_AI3_BUF));
return ret;
}
///////////////////////////////////////////////////////////////////////////////
/*-----------------------------------------------------------------------------*/
/* Network Functions */
/*-----------------------------------------------------------------------------*/
typedef struct _NET_
PROC_CONFIG {
CHAR model_filename[256];
INT32 b
insize;
void *p_share_model;
CHAR label_filename[256];
} NET_
PROC_CONFIG;
typedef struct _NET_
PROC {
NET_
PROC_CONFIG net_cfg;
MEM_PARM
proc_mem;
U
INT32
proc_id;
//CHAR out_class_labels[MAX_CLASS_NUM * VENDOR_AIS_LBL_LEN];
MEM_PARM rslt_mem;
MEM_PARM io_mem;
MEM_PARM
intl_mem;
MEM_PARM *out_mem;
VENDOR_AI3_NET_
INFO net_
info;
} NET_
PROC;
static NET_
PROC *g_net = NULL;
static
INT32 _getsize_model(char* filename)
{
FILE *b
in_fd;
U
INT32 b
in_size = 0;
b
in_fd = fopen(filename, "rb");
if (!b
in_fd) {
pr
intf("get b
in(%s) size fail\n", filename);
return (-1);
}
fseek(b
in_fd, 0, SEEK_END);
b
in_size = ftell(b
in_fd);
fseek(b
in_fd, 0, SEEK_SET);
fclose(b
in_fd);
return b
in_size;
}
static U
INT32 _load_model(CHAR *filename, U
INTPTR va)
{
FILE *fd;
U
INT32 file_size = 0, read_size = 0;
const U
INTPTR model_addr = va;
//DBG_DUMP("model addr = %#lx\r\n", model_addr);
fd = fopen(filename, "rb");
if (!fd) {
pr
intf("load model(%s) fail\r\n", filename);
return 0;
}
fseek ( fd, 0, SEEK_END );
file_size = ALIGN_CEIL_4( ftell(fd) );
fseek ( fd, 0, SEEK_SET );
read_size = fread ((void *)model_addr, 1, file_size, fd);
if (read_size != file_size) {
pr
intf("size mismatch, real = %d, idea = %d\r\n", (
int)read_size, (
int)file_size);
}
fclose(fd);
pr
intf("load model(%s) ok\r\n", filename);
return read_size;
}
/*
static HD_RESULT _load_label(U
INTPTR addr, U
INT32 l
ine_len, const CHAR *filename)
{
FILE *fd;
CHAR *p_l
ine = (CHAR *)addr;
fd = fopen(filename, "r");
if (!fd) {
pr
intf("load label(%s) fail\r\n", filename);
return HD_ERR_NG;
}
while (fgets(p_l
ine, l
ine_len, fd) != NULL) {
p_l
ine[strlen(p_l
ine) - 1] = '\0'; // remove newl
ine character
p_l
ine += l
ine_len;
}
if (fd) {
fclose(fd);
}
pr
intf("load label(%s) ok\r\n", filename);
return HD_OK;
}
*/
static HD_RESULT network_
init(void)
{
HD_RESULT ret = HD_OK;
{
VENDOR_AI3_DEV_CFG dev_cfg = {0};
ret = vendor_ai3_dev_
init(&dev_cfg);
if (ret != HD_OK) {
pr
intf("vendor_ai3_dev_
init fail=%d\n", ret);
return ret;
}
}
// dump AI3 version
{
VENDOR_AI3_VER ai3_ver = {0};
ret = vendor_ai3_dev_get(VENDOR_AI3_CFG_VER, &ai3_ver);
if (ret != HD_OK) {
pr
intf("vendor_ai3_dev_get(CFG_VER) fail=%d\n", ret);
return ret;
}
pr
intf("vendor_ai version = %s\r\n", ai3_ver.vendor_ai_impl_version);
pr
intf("kflow_ai version = %s\r\n", ai3_ver.kflow_ai_impl_version);
pr
intf("kdrv_ai version = %s\r\n", ai3_ver.kdrv_ai_impl_version);
}
return ret;
}
static HD_RESULT network_un
init(void)
{
HD_RESULT ret = HD_OK;
ret = vendor_ai3_dev_un
init();
if (ret != HD_OK) {
pr
intf("vendor_ai3_dev_un
init fail=%d\n", ret);
}
return ret;
}
static
INT32 network_mem_config(NET_PATH_ID net_path, HD_COMMON_MEM_
INIT_CONFIG* p_mem_cfg, void* p_cfg)
{
NET_
PROC* p_net = g_net + net_path;
NET_
PROC_CONFIG* p_
proc_cfg = (NET_
PROC_CONFIG*)p_cfg;
#if def
ined(_NVT_NVR_SDK_)
int sys_fd;
struct nvtmem_hdal_base sys_hdal;
u
intptr_t hdal_start_addr0, hdal_start_addr1;
sys_fd = open("/dev/nvtmem0", O_RDWR);
if (sys_fd < 0) {
pr
intf("Error: cannot open /dev/nvtmem0 device.\n");
exit(0);
}
if (ioctl(sys_fd, NVTMEM_GET_DTS_HDAL_BASE, &sys_hdal) < 0) {
pr
intf("PCIE_SYS_IOC_HDALBASE! \n");
close(sys_fd);
exit(0);
}
close(sys_fd);
/*
init ddr0 user_blk */
hdal_start_addr0 = sys_hdal.base[0];
p_mem_cfg->pool_
info[0].start_addr = hdal_start_addr0;
p_mem_cfg->pool_
info[0].blk_cnt = 1;
p_mem_cfg->pool_
info[0].blk_size = 200 * 1024 * 1024;
p_mem_cfg->pool_
info[0].type = HD_COMMON_MEM_USER_BLK;
p_mem_cfg->pool_
info[0].ddr_id = sys_hdal.ddr_id[0];
pr
intf("create ddr%d: hdal_memory(%#lx, %ldKB), usr_blk(%#lx, %dKB)\n", p_mem_cfg->pool_
info[0].ddr_id,
hdal_start_addr0, sys_hdal.size[0] / 1024, p_mem_cfg->pool_
info[0].start_addr,
p_mem_cfg->pool_
info[0].blk_size * p_mem_cfg->pool_
info[0].blk_cnt / 1024);
/*
init ddr1 user_blk, if ddr1 is exist */
if (sys_hdal.size[1] != 0) {
hdal_start_addr1 = sys_hdal.base[1];
p_mem_cfg->pool_
info[1].start_addr = hdal_start_addr1;
p_mem_cfg->pool_
info[1].blk_cnt = 1;
p_mem_cfg->pool_
info[1].blk_size = 200 * 1024 * 1024;
p_mem_cfg->pool_
info[1].type = HD_COMMON_MEM_USER_BLK;
p_mem_cfg->pool_
info[1].ddr_id = sys_hdal.ddr_id[1];
pr
intf("create ddr%d: hdal_memory(%#lx, %ldKB) usr_blk(%#lx, %dKB)\n", p_mem_cfg->pool_
info[1].ddr_id,
hdal_start_addr1, sys_hdal.size[1] / 1024, p_mem_cfg->pool_
info[1].start_addr,
p_mem_cfg->pool_
info[1].blk_size * p_mem_cfg->pool_
info[1].blk_cnt / 1024);
} else {
pr
intf("create ddr1: hdal_memory(%#lx, %ldKB) is not exist\n", sys_hdal.base[1], sys_hdal.size[1] / 1024);
}
usleep(30000); // wait
for pr
intf completely
#endif
memcpy((void*)&p_net->net_cfg, (void*)p_
proc_cfg, sizeof(NET_
PROC_CONFIG));
if (strlen(p_net->net_cfg.model_filename) == 0) {
pr
intf("net_path(%u)
input model is null\r\n", net_path);
return HD_ERR_NG;
}
p_net->net_cfg.b
insize = _getsize_model(p_net->net_cfg.model_filename);
if (p_net->net_cfg.b
insize <= 0) {
pr
intf("net_path(%u)
input model is not exist?\r\n", net_path);
return HD_ERR_NG;
}
pr
intf("net_path(%u) set net_mem_cfg: model-file(%s), b
insize=%d\r\n",
net_path,
p_net->net_cfg.model_filename,
p_net->net_cfg.b
insize);
pr
intf("net_path(%u) set net_mem_cfg: label-file(%s)\r\n",
net_path,
p_net->net_cfg.label_filename);
return HD_OK;
}
static HD_RESULT network_alloc_io_buf(NET_PATH_ID net_path, U
INT32 req_size)
{
HD_RESULT ret = HD_OK;
NET_
PROC* p_net = g_net + net_path;
CHAR mem_name[23] ;
snpr
intf(mem_name, 23, "ai_io_buf %u", net_path);
ret = mem_alloc(&p_net->io_mem, mem_name, req_size);
if (ret != HD_OK) {
pr
intf("net_path(%u) alloc ai_io_buf fail\r\n", net_path);
return HD_ERR_FAIL;
}
pr
intf("alloc_io_buf: work buf, pa = %#lx, va = %#lx, size = %u\r\n", p_net->io_mem.pa, p_net->io_mem.va, p_net->io_mem.size);
return ret;
}
static HD_RESULT network_free_io_buf(NET_PATH_ID net_path)
{
HD_RESULT ret = HD_OK;
NET_
PROC* p_net = g_net + net_path;
if (p_net->io_mem.pa && p_net->io_mem.va) {
mem_free(&p_net->io_mem);
}
return ret;
}
static HD_RESULT network_alloc_
intl_buf(NET_PATH_ID net_path, U
INT32 req_size)
{
HD_RESULT ret = HD_OK;
NET_
PROC* p_net = g_net + net_path;
CHAR mem_name[23] ;
snpr
intf(mem_name, 23, "ai_ronly_buf %u", net_path);
ret = mem_alloc(&p_net->
intl_mem, mem_name, req_size);
if (ret != HD_OK) {
pr
intf("net_path(%u) alloc ai_ronly_buf fail\r\n", net_path);
return HD_ERR_FAIL;
}
pr
intf("alloc_
intl_buf:
internal buf, pa = %#lx, va = %#lx, size = %u\r\n", p_net->
intl_mem.pa, p_net->
intl_mem.va, p_net->
intl_mem.size);
return ret;
}
static HD_RESULT network_free_
intl_buf(NET_PATH_ID net_path)
{
HD_RESULT ret = HD_OK;
NET_
PROC* p_net = g_net + net_path;
if (p_net->
intl_mem.pa && p_net->
intl_mem.va) {
mem_free(&p_net->
intl_mem);
}
return ret;
}
static HD_RESULT network_open(NET_PATH_ID net_path)
{
HD_RESULT ret = HD_OK;
NET_
PROC* p_net = g_net + net_path;
U
INT32 loadsize = 0;
CHAR mem_name[23] ;
snpr
intf(mem_name, 23, "model.b
in %u", net_path);
if (strlen(p_net->net_cfg.model_filename) == 0) {
pr
intf("net_path(%u)
input model is null\r\n", net_path);
return 0;
}
ret = mem_alloc(&p_net->
proc_mem, mem_name, p_net->net_cfg.b
insize);
if (ret != HD_OK) {
pr
intf("net_path(%u) mem_alloc model.b
in fail=%d\n", net_path, ret);
return HD_ERR_FAIL;
}
//load file
loadsize = _load_model(p_net->net_cfg.model_filename, p_net->
proc_mem.va);
if (loadsize <= 0) {
pr
intf("net_path(%u)
input model load fail: %s\r\n", net_path, p_net->net_cfg.model_filename);
return 0;
}
/*
// load label
ret = _load_label((U
INTPTR)p_net->out_class_labels, VENDOR_AIS_LBL_LEN, p_net->net_cfg.label_filename);
if (ret != HD_OK) {
pr
intf("
proc_id(%u) load_label fail=%d\n",
proc_id, ret);
return HD_ERR_FAIL;
}
*/
{
VENDOR_AI3_MODEL_
INFO model_
info = {0};
model_
info.model_buf.pa = p_net->
proc_mem.pa;
model_
info.model_buf.va = p_net->
proc_mem.va;
model_
info.model_buf.size = p_net->
proc_mem.size;
#if DBG_OUT_DUMP
model_
info.ctrl = CTRL_BUF_DEBUG | CTRL_JOB_DEBUG | CTRL_JOB_DUMPOUT;
#endif
#if FLOAT_
IN
model_
info.ctrl = model_
info.ctrl | CTRL_BUF_FLOAT
IN ;
#endif
#if FLOAT_OUT
model_
info.ctrl = model_
info.ctrl | CTRL_BUF_FLOATOUT ;
#endif
pr
intf("net_path(%u) vendor_ai3_dev_get(MODEL_
INFO) \n", net_path);
ret = vendor_ai3_dev_get(VENDOR_AI3_CFG_MODEL_
INFO, &model_
info);
if (ret != HD_OK) {
pr
intf("net_path(%u) vendor_ai3_dev_get(MODEL_
INFO) fail=%d\n", net_path, ret);
return HD_ERR_FAIL;
}
pr
intf("model_
info get => workbuf size = %d, ronlybuf size = %d\r\n", model_
info.
proc_mem.buf[AI3_
PROC_BUF_WORKBUF].size, model_
info.
proc_mem.buf[AI3_
PROC_BUF_RONLYBUF].size);
// alloc WORKBUF/RONLYBUF
ret = network_alloc_
intl_buf(net_path, model_
info.
proc_mem.buf[AI3_
PROC_BUF_RONLYBUF].size);
if (ret != HD_OK) {
pr
intf("net_path(%u) alloc ronlybuf fail=%d\n", net_path, ret);
return HD_ERR_FAIL;
}
ret = network_alloc_io_buf(net_path, model_
info.
proc_mem.buf[AI3_
PROC_BUF_WORKBUF].size);
if (ret != HD_OK) {
pr
intf("net_path(%u) alloc workbuf fail=%d\n", net_path, ret);
return HD_ERR_FAIL;
}
}
// call open()
{
VENDOR_AI3_
PROC_CFG
proc_cfg = {0};
proc_cfg.model_buf.pa = p_net->
proc_mem.pa;
proc_cfg.model_buf.va = p_net->
proc_mem.va;
proc_cfg.model_buf.size = p_net->
proc_mem.size;
proc_cfg.
proc_mem.buf[AI3_
PROC_BUF_RONLYBUF].pa = p_net->
intl_mem.pa;
proc_cfg.
proc_mem.buf[AI3_
PROC_BUF_RONLYBUF].va = p_net->
intl_mem.va;
proc_cfg.
proc_mem.buf[AI3_
PROC_BUF_RONLYBUF].size = p_net->
intl_mem.size;
proc_cfg.
proc_mem.buf[AI3_
PROC_BUF_WORKBUF].pa = p_net->io_mem.pa;
proc_cfg.
proc_mem.buf[AI3_
PROC_BUF_WORKBUF].va = p_net->io_mem.va;
proc_cfg.
proc_mem.buf[AI3_
PROC_BUF_WORKBUF].size = p_net->io_mem.size;
proc_cfg.plug
in[AI3_PLUG
IN_CPU] = vendor_ai_cpu1_get_eng
ine();
#if DBG_OUT_DUMP
proc_cfg.ctrl = CTRL_BUF_DEBUG | CTRL_JOB_DEBUG | CTRL_JOB_DUMPOUT;
#endif
#if FLOAT_
IN
proc_cfg.ctrl =
proc_cfg.ctrl | CTRL_BUF_FLOAT
IN ;
#endif
#if FLOAT_OUT
proc_cfg.ctrl =
proc_cfg.ctrl | CTRL_BUF_FLOATOUT ;
#endif
ret = vendor_ai3_net_open(&p_net->
proc_id, &
proc_cfg, &p_net->net_
info);
if (ret != HD_OK) {
pr
intf("net_path(%u) vendor_ai3_net_open() fail=%d\n", net_path, ret);
return HD_ERR_FAIL;
} else {
pr
intf("net_path(%u) open success => get
proc_id(%u)\r\n", net_path, p_net->
proc_id);
}
}
return ret;
}
static HD_RESULT network_close(NET_PATH_ID net_path)
{
HD_RESULT ret = HD_OK;
NET_
PROC* p_net = g_net + net_path;
U
INT32
proc_id = p_net->
proc_id;
U
INT32 i ;
// close
ret = vendor_ai3_net_close(
proc_id);
if (ret != HD_OK) {
pr
intf("net_path(%u),
proc_id(%u) vendor_ai3_net_close fail=%d\n", net_path,
proc_id, ret);
return HD_ERR_FAIL;
}
if ((ret = network_free_
intl_buf(net_path)) != HD_OK)
return ret;
if ((ret = network_free_io_buf(net_path)) != HD_OK)
return ret;
mem_free(&p_net->
proc_mem);
for (i = 0 ; i < p_net->net_
info.out_buf_cnt; i++){
if(p_net->out_mem && p_net->out_mem[i].va)
mem_free(&p_net->out_mem[i]);
}
if(p_net->out_mem)
free(p_net->out_mem) ;
return ret;
}
#if DUMP_POST
PROC_
INFO
static HD_RESULT network_dump_ai_buf(VENDOR_AI3_BUF *p_outbuf)
{
HD_RESULT ret = HD_OK;
pr
intf(" sign(0x%x) pa(0x%lx) va(0x%lx) sz(%u) w(%u) h(%u) ch(%u) batch_num(%u)\n",
p_outbuf->sign, p_outbuf->pa, p_outbuf->va, p_outbuf->size, p_outbuf->width,
p_outbuf->height, p_outbuf->channel, p_outbuf->batch_num);
pr
intf(" l_ofs(%llu) c_ofs(%llu) b_ofs(%llu) t_ofs(%llu) layout(%s) name(%s) scale_ratio(%.6f)\n",
p_outbuf->l
ine_ofs, p_outbuf->channel_ofs, p_outbuf->batch_ofs, p_outbuf->time_ofs, p_outbuf->layout,
p_outbuf->name, p_outbuf->scale_ratio);
// pars
ing pixel
format
switch (AI_PXLFMT_TYPE(p_outbuf->fmt)) {
case HD_VIDEO_PXLFMT_AI_U
INT8:
case HD_VIDEO_PXLFMT_AI_S
INT8:
case HD_VIDEO_PXLFMT_AI_U
INT16:
case HD_VIDEO_PXLFMT_AI_S
INT16:
case HD_VIDEO_PXLFMT_AI_U
INT32:
case HD_VIDEO_PXLFMT_AI_S
INT32:
case HD_VIDEO_PXLFMT_AI_FLOAT32:
{
INT8 bitdepth = HD_VIDEO_PXLFMT_BITS(p_outbuf->fmt);
INT8
int_bits = HD_VIDEO_PXLFMT_
INT(p_outbuf->fmt);
INT8 frac_bits = HD_VIDEO_PXLFMT_FRAC(p_outbuf->fmt);
pr
intf(" fmt(0x%x) bits(%u)
int(%u) frac(%u)\n", p_outbuf->fmt, bitdepth,
int_bits, frac_bits);
}
break;
default:
switch ((U
INT32)p_outbuf->fmt) {
case HD_VIDEO_PXLFMT_BGR888_PLANAR:
{
pr
intf(" fmt(0x%x), BGR888_PLANAR\n", p_outbuf->fmt);
}
break;
case HD_VIDEO_PXLFMT_YUV420:
{
pr
intf(" fmt(0x%x), YUV420\n", p_outbuf->fmt);
}
break;
case HD_VIDEO_PXLFMT_Y8:
{
pr
intf(" fmt(0x%x), Y8 only\n", p_outbuf->fmt);
}
break;
case HD_VIDEO_PXLFMT_UV:
{
pr
intf(" fmt(0x%x), UV only\n", p_outbuf->fmt);
}
break;
case 0:
{
pr
intf(" fmt(0x%x), AI BUF\n", p_outbuf->fmt);
}
break;
default:
pr
intf("unknown pxlfmt(0x%x)\n", p_outbuf->fmt);
break;
}
}
pr
intf("\n");
return ret;
}
/*
static
INT32 mem_save(MEM_PARM *mem_parm, const CHAR *filename)
{
FILE *fd;
U
INT32 size = 0;
fd = fopen(filename, "wb");
if (!fd) {
pr
intf("ERR: cannot open %s
for write!\r\n", filename);
return -1;
}
size = (
INT32)fwrite((VOID *)mem_parm->va, 1, mem_parm->size, fd);
if (size != mem_parm->size) {
pr
intf("ERR: write %s with size %ld < wanted %ld?\r\n", filename, size, mem_parm->size);
} else {
pr
intf("write %s with %ld bytes.\r\n", filename, mem_parm->size);
}
if (fd) {
fclose(fd);
}
return size;
}
*/
#endif
///////////////////////////////////////////////////////////////////////////////
typedef struct _VIDEO_LIVEVIEW {
// (1)
input
NET_
IN_CONFIG net_
in_cfg;
NET_PATH_ID
in_path;
// (2) network
NET_
PROC_CONFIG net_
proc_cfg;
NET_PATH_ID net_path;
p
thread_t
proc_
thread_id;
U
INT32
proc_start;
U
INT32
proc_exit;
U
INT32
proc_oneshot;
U
INT32
input_blob_num;
} VIDEO_LIVEVIEW;
static HD_RESULT
init_module(void)
{
HD_RESULT ret;
if ((ret =
input_
init()) != HD_OK)
return ret;
if ((ret = network_
init()) != HD_OK)
return ret;
return HD_OK;
}
static HD_RESULT open_module(VIDEO_LIVEVIEW *p_stream)
{
HD_RESULT ret;
//if ((ret =
input_open(p_stream->
in_path)) != HD_OK)
// return ret;
if ((ret = network_open(p_stream->net_path)) != HD_OK)
return ret;
return HD_OK;
}
static HD_RESULT close_module(VIDEO_LIVEVIEW *p_stream)
{
HD_RESULT ret;
//if ((ret =
input_close(p_stream->
in_path)) != HD_OK)
// return ret;
if ((ret = network_close(p_stream->net_path)) != HD_OK)
return ret;
return HD_OK;
}
static HD_RESULT exit_module(void)
{
HD_RESULT ret;
if ((ret =
input_un
init()) != HD_OK)
return ret;
if ((ret = network_un
init()) != HD_OK)
return ret;
return HD_OK;
}
static HD_RESULT perf_beg
in(void)
{
vendor_ai3_dev_perf_beg
in(VENDOR_AI3_PERF_ID_TIME_UT);
return HD_OK;
}
static HD_RESULT perf_end(void)
{
U
INT32 i;
VENDOR_AI3_PERF_TIME_UT perf_time_ut = {0};
vendor_ai3_dev_perf_end(VENDOR_AI3_PERF_ID_TIME_UT, &perf_time_ut);
pr
intf("\r\n ************* util-per-
proc() *************\r\n");
for (i=0; i<perf_time_ut.core_
count; i++) {
pr
intf("%8s: time(us) = %6d, util(%%) = %6.2f\r\n",
perf_time_ut.core[i].name, perf_time_ut.core[i].time, ((float)perf_time_ut.core[i].util)/100);
}
return HD_OK;
}
///////////////////////////////////////////////////////////////////////////////
static VOID *network_user_
thread(VOID *arg);
static HD_RESULT set_buf_by_
in_path_list(VIDEO_LIVEVIEW *p_stream)
{
HD_RESULT ret = HD_OK;
NET_PATH_ID net_path = p_stream->net_path;
NET_
PROC* p_net = g_net + net_path;
VENDOR_AI3_NET_
INFO net_
info = p_net->net_
info;
VENDOR_AI3_BUF
in_buf = {0};
VENDOR_AI3_BUF tmp_buf = {0};
U
INT32
proc_id = p_net->
proc_id;
U
INT32 i = 0, idx = 0, k = 0;
U
INT32
in_buf_cnt = 0;
U
INT32 *
in_path_list = NULL;
/* get
in path list */
in_path_list = p_net->net_
info.
in_path_list;
in_buf_cnt = net_
info.
in_buf_cnt;
for (i = 0; i <
in_buf_cnt; i++) {
/* get
in buf (by
in path list) */
ret = vendor_ai3_net_get(
proc_id,
in_path_list[i], &tmp_buf);
if (HD_OK != ret) {
pr
intf("net_path(%u),
proc_id(%u) get
in buf fail, i(%d),
in_path(0x%x)\n",net_path,
proc_id, i,
in_path_list[i]);
goto exit;
}
if (dump_output)
{
// dump
in buf
pr
intf("dump_
in_buf: path_id: 0x%x\n",
in_path_list[i]);
ret = network_dump_ai_buf(&tmp_buf);
if (HD_OK != ret) {
pr
intf("net_path(%u),
proc_id(%u) dump
in buf fail !!\n", net_path,
proc_id);
goto exit;
}}
}
for (i = 0; i < p_stream->
input_blob_num; i++) {
NET_
IN* p_
in = g_
in + i;
/* load
input b
in */
ret =
input_pull_buf((p_stream->
in_path + i), &
in_buf, 0);
if (HD_OK != ret) {
pr
intf("
in_path(%u) pull
input fail !!\n", (p_stream->
in_path + i));
goto exit;
}
if (p_
in->
in_cfg.is_comb_img == 0) {
for(k =1 ; k <
in_buf.batch_num; k++) {
U
INTPTR dst_va =
in_buf.va + (k *
in_buf.size);
memcpy((VOID*)dst_va , (VOID*)
in_buf.va,
in_buf.size);
hd_common_mem_flush_cache((VOID *)dst_va,
in_buf.size);
}
}
//pr
intf(" path_%d(0x%x) pa(0x%lx) va(0x%lx) size(%u)\n", idx,
in_path_list[idx],
in_buf.pa,
in_buf.va,
in_buf.size);
ret = vendor_ai3_net_set(
proc_id,
in_path_list[idx], &
in_buf);
if (HD_OK != ret) {
pr
intf("
proc_id(%u)push
input fail !! i(%u)\n",
proc_id, i);
goto exit;
}
idx++;
}
exit:
return ret;
}
static HD_RESULT set_buf_by_out_path_list(NET_PATH_ID net_path)
{
HD_RESULT ret = HD_OK;
NET_
PROC* p_net = g_net + net_path;
U
INT32
proc_id = p_net->
proc_id;
U
INT32 i;
VENDOR_AI3_BUF ai_buf = {0};
/* get out buf */
for (i = 0; i < p_net->net_
info.out_buf_cnt; i++) {
// get out buf (by out path list)
ret = vendor_ai3_net_get(
proc_id, p_net->net_
info.out_path_list[i], &ai_buf);
if (HD_OK != ret) {
pr
intf("
proc_id(%u) get out buf fail, i(%d), out_path(0x%x)\n",
proc_id, i, p_net->net_
info.out_path_list[i]);
goto exit;
}
if (ai_buf.size > p_net->out_mem[i].size){
pr
intf("output size %u < ai_buf.size %u\r\n", p_net->out_mem[i].size, ai_buf.size);
goto exit;
}
ai_buf.va = p_net->out_mem[i].va ;
ai_buf.pa = p_net->out_mem[i].pa ;
ai_buf.size = p_net->out_mem[i].size ;
#if FLOAT_OUT
ai_buf.fmt = HD_VIDEO_PXLFMT_AI_FLOAT32;
#endif
ret = vendor_ai3_net_set(
proc_id, p_net->net_
info.out_path_list[i], &ai_buf);
if (HD_OK != ret) {
pr
intf("
proc_id(%u)set output buf fail !! (%u)\n",
proc_id, i);
goto exit;
}
}
exit:
return ret;
}
#if (1)
static u
intptr_t get_post_buf(u
int32_t size)
{
u
intptr_t buf = (u
intptr_t)malloc(size);
return buf;
}
static VOID release_post_buf(VOID *ptr)
{
if (ptr) {
free(ptr);
}
return;
}
#endif
#if(1)
static HD_RESULT network_dump_out_buf(NET_PATH_ID net_path, VENDOR_AI3_BUF *p_outbuf, U
INT32 id)
{
HD_RESULT ret = HD_OK;
//NET_
PROC *p_net = g_net + net_path;
//
INT32 i;
//AI_NET_ACCURACY_PARM parm = {0};
//AI_NET_SHAPE shape = {p_outbuf->batch_num, p_outbuf->channel, 1, 1, 1};
//
INT32 size = shape.num * shape.channels * shape.height * shape.width;
U
INT32 length = p_outbuf->batch_num * p_outbuf->channel * p_outbuf->height * p_outbuf->width;
FLOAT *p_outbuf_float = (FLOAT *)get_post_buf(length * sizeof(FLOAT));
ret = vendor_ai_cpu_util_fixed2float((VOID *)p_outbuf->va, p_outbuf->fmt, p_outbuf_float, p_outbuf->scale_ratio, length, p_outbuf->zero_po
int);
pr
intf("id:%d size:%d name:%s\n", id, length, p_outbuf->name);
#if (1)
// save output float b
in
CHAR out_float_path[256] = {0};
spr
intf(out_float_path, "%s/float_%s.b
in", dump_path, p_outbuf->name);
pr
intf("out_float_path: %s\n", out_float_path);
FILE* fp_out = NULL;
if ((fp_out = fopen(out_float_path, "wb+")) == NULL) {
pr
intf("fopen fail\n");
} else {
fwrite((VOID *)p_outbuf_float, sizeof(FLOAT), length, fp_out);
//fwrite((VOID *)layer_buffer[i].va, sizeof(
INT16), length, fp_out);
}
if(fp_out){
fclose(fp_out);
}
// save output fixed b
in
CHAR out_fixed_path[256] = {0};
spr
intf(out_fixed_path, "%s/fixed_%s.b
in", dump_path, p_outbuf->name);
pr
intf("out_fixed_path: %s\n", out_fixed_path);
FILE* fp_out1 = NULL;
if ((fp_out1 = fopen(out_fixed_path, "wb+")) == NULL) {
pr
intf("fopen fail\n");
} else {
//fwrite((VOID *)p_outbuf_float, sizeof(FLOAT), length, fp_out1);
fwrite((VOID *)p_outbuf->va, sizeof(
INT16), length, fp_out1);
}
if(fp_out1){
fclose(fp_out1);
}
#endif
/*
INT32 *p_idx = (
INT32 *)get_post_buf(p_outbuf->channel * sizeof(
INT32));
AI_NET_OUTPUT_CLASSS *p_classes = (AI_NET_OUTPUT_CLASSS *)get_post_buf(p_outbuf->batch_num * TOP_N * sizeof(AI_NET_OUTPUT_CLASSS));
parm.
in_addr = (u
intptr_t)p_outbuf_float;
parm.classes = p_classes;
parm.shape = shape;
parm.top_n = TOP_N;
parm.class_idx = p_idx;
ret = ai_net_accuracy_
process(&parm);
pr
intf("Classification Results:\r\n");
for (i = 0; i < parm.top_n; i++) {
pr
intf("%d. no=%d, label=%s, score=%f\r\n", i + 1, parm.classes[i].no,
&p_net->out_class_labels[parm.classes[i].no * LABEL_LEN], parm.classes[i].score);
}
*/
release_post_buf(p_outbuf_float);
//release_post_buf(p_idx);
//release_post_buf(p_classes);
return ret;
}
#endif
static HD_RESULT get_buf_by_out_path_list(NET_PATH_ID net_path)
{
HD_RESULT ret = HD_OK;
NET_
PROC* p_net = g_net + net_path;
U
INT32
proc_id = p_net->
proc_id;
U
INT32 i;
VENDOR_AI3_BUF ai_buf = {0};
pr
intf("########### p_net->net_
info.out_buf_cnt %d \r\n",p_net->net_
info.out_buf_cnt);
/* get out buf */
for (i = 0; i < p_net->net_
info.out_buf_cnt; i++) {
// get out buf (by out path list)
ret = vendor_ai3_net_get(
proc_id, p_net->net_
info.out_path_list[i], &ai_buf);
if (HD_OK != ret) {
pr
intf("net_path(%u),
proc_id(%u) get out buf fail, i(%d), out_path(0x%x)\n", net_path,
proc_id, i, p_net->net_
info.out_path_list[i]);
goto exit;
}
#if DUMP_POST
PROC_
INFO
{
//CHAR dump_path[23];
// dump out buf
if (hd_common_mem_flush_cache((VOID *)ai_buf.va, ai_buf.size) != HD_OK) {
pr
intf("flush cache failed.\r\n");
}
pr
intf("dump_out_buf: path_id: 0x%x\n", p_net->net_
info.out_path_list[i]);
ret = network_dump_ai_buf(&ai_buf);
if (HD_OK != ret) {
pr
intf("net_path(%u) dump out buf fail !!\n", net_path);
goto exit;
}
//snpr
intf(dump_path, 23, "%s.b
in", ai_buf.name);
//pr
intf(" DUMP out_buf (%u): %s va = %lx\n", i, dump_path,(ULONG)p_net->out_mem[i].va);
//mem_save(&p_net->out_mem[i], dump_path);
ret = network_dump_out_buf(net_path, &ai_buf, i);
}
#endif
}
exit:
return ret;
}
static HD_RESULT allocate_buf_by_out_path_list(NET_PATH_ID net_path)
{
HD_RESULT ret = HD_OK;
NET_
PROC* p_net = g_net + net_path;
U
INT32
proc_id = p_net->
proc_id;
U
INT32 i;
VENDOR_AI3_BUF ai_buf = {0};
CHAR mem_name[23] ;
/* get out path list */
p_net->out_mem = (MEM_PARM *)malloc(sizeof(MEM_PARM) * p_net->net_
info.out_buf_cnt);
memset(p_net->out_mem, 0, sizeof(MEM_PARM) * p_net->net_
info.out_buf_cnt);
/* get out buf */
for (i = 0; i < p_net->net_
info.out_buf_cnt; i++) {
// get out buf (by out path list)
ret = vendor_ai3_net_get(
proc_id, p_net->net_
info.out_path_list[i], &ai_buf);
if (HD_OK != ret) {
pr
intf("
proc_id(%u) get out buf fail, i(%d), out_path(0x%x)\n",
proc_id, i, p_net->net_
info.out_path_list[i]);
goto exit;
}
// // allocate
in buf
#if FLOAT_OUT
ai_buf.size = ai_buf.width * ai_buf.height * ai_buf.channel * ai_buf.batch_num *sizeof(float) ;
#endif
snpr
intf(mem_name, 23, "output_buf %u", i);
ret = mem_alloc(&p_net->out_mem[i], mem_name, ai_buf.size);
if (ret != HD_OK) {
pr
intf("
proc_id(%u) alloc ai_
in_buf fail\r\n",
proc_id);
goto exit;
}
pr
intf("alloc_outbuf: pa = 0x%lx, va = 0x%lx, size = %u\n", p_net->out_mem[i].pa, p_net->out_mem[i].va, p_net->out_mem[i].size);
}
return ret;
exit:
for (i = 0 ; i < p_net->net_
info.out_buf_cnt; i++){
if(p_net->out_mem && p_net->out_mem[i].va)
mem_free(&p_net->out_mem[i]);
}
if(p_net->out_mem)
free(p_net->out_mem) ;
return ret;
}
static HD_RESULT network_user_start(VIDEO_LIVEVIEW *p_stream)
{
HD_RESULT ret = HD_OK;
NET_
PROC* p_net = g_net + p_stream->net_path;
U
INT32
proc_id = p_net->
proc_id;
p_stream->
proc_start = 0;
p_stream->
proc_exit = 0;
p_stream->
proc_oneshot = 0;
ret = vendor_ai3_net_start(
proc_id);
if (HD_OK != ret) {
pr
intf("net_path(%u),
proc_id(%u) vendor_ai3_net_start fail !!\n", p_stream->net_path,
proc_id);
}
ret = p
thread_create(&p_stream->
proc_
thread_id, NULL, network_user_
thread, (VOID*)(p_stream));
if (ret < 0) {
return HD_ERR_FAIL;
}
p_stream->
proc_start = 1;
p_stream->
proc_exit = 0;
p_stream->
proc_oneshot = 0;
return ret;
}
static HD_RESULT network_user_oneshot(VIDEO_LIVEVIEW *p_stream)
{
HD_RESULT ret = HD_OK;
p_stream->
proc_oneshot = 1;
return ret;
}
static HD_RESULT network_user_stop(VIDEO_LIVEVIEW *p_stream)
{
HD_RESULT ret = HD_OK;
NET_
PROC* p_net = g_net + p_stream->net_path;
U
INT32
proc_id = p_net->
proc_id;
p_stream->
proc_exit = 1;
if (p_stream->
proc_
thread_id) {
p
thread_jo
in(p_stream->
proc_
thread_id, NULL);
}
//stop: should be call after last time
proc
ret = vendor_ai3_net_stop(
proc_id);
if (HD_OK != ret) {
pr
intf("net_path(%u),
proc_id(%u) vendor_ai3_net_stop fail !!\n", p_stream->net_path,
proc_id);
}
return ret;
}
static VOID *network_user_
thread(VOID *arg)
{
HD_RESULT ret = HD_OK;
VIDEO_LIVEVIEW *p_stream = (VIDEO_LIVEVIEW*)arg;
NET_
PROC* p_net = g_net + p_stream->net_path;
U
INT32
proc_id = p_net->
proc_id;
static struct timeval tstart, tend;
static U
INT64 cur_time = 0;
static U
INT64 all_time = 0;
static float mean_time = 0;
U
INT32
count=0;
pr
intf("\r\n");
while (p_stream->
proc_start == 0) sleep(1);
pr
intf("\r\n");
while (p_stream->
proc_exit == 0) {
if (p_stream->
proc_oneshot) {
p_stream->
proc_oneshot = 0;
for (
count=0;
count<g_
proc_num;
count++) {
// set buf by
in_path_list
ret = set_buf_by_
in_path_list(p_stream);
if (HD_OK != ret) {
pr
intf("net_path(%u),
proc_id(%u) set
in_buf fail(%d) !!\n", p_stream->net_path,
proc_id, ret);
goto skip;
}
ret = set_buf_by_out_path_list(p_stream->net_path);
if (HD_OK != ret) {
pr
intf("net_path(%u),
proc_id(%u) set
in_buf fail(%d) !!\n", p_stream->net_path,
proc_id, ret);
goto skip;
}
// do net
proc
gettimeofday(&tstart, NULL);
if(dump_time_ut){
perf_beg
in();
}
ret = vendor_ai3_net_
proc(
proc_id);
if(dump_time_ut){
perf_end();
}
gettimeofday(&tend, NULL);
if (HD_OK != ret) {
pr
intf("net_path(%u),
proc_id(%u)
proc fail !!\n", p_stream->net_path,
proc_id);
goto skip;
}
//
count++;
cur_time = (U
INT64)(tend.tv_sec - tstart.tv_sec) * 1000000 + (tend.tv_usec - tstart.tv_usec);
if(
count>0){
all_time+=cur_time;
mean_time=all_time/(float)(
count);
if (dump_time_
proc){
pr
intf("
count %d cur time(us): %lld all time(us): %lld mean time(us): %f \r\n",
count,cur_time,all_time,mean_time);
}
}
// pr
intf("net_path(%u),
proc_id(%u) oneshot done!\n", p_stream->net_path,
proc_id);
// get buf by out_path_list
if (dump_output)
{
/* code */
ret = get_buf_by_out_path_list(p_stream->net_path);
if (HD_OK != ret) {
pr
intf("net_path(%u),
proc_id(%u) get out_buf fail(%d) !!\n", p_stream->net_path,
proc_id, ret);
goto skip;
}
}
}
pr
intf("
count %d cur time(us): %lld all time(us): %lld mean time(us): %f \r\n",
count,cur_time,all_time,mean_time);
}
usleep(100);
}
skip:
return 0;
}
/*-----------------------------------------------------------------------------*/
/*
Interface Functions */
/*-----------------------------------------------------------------------------*/
MA
IN(argc, argv)
{
VIDEO_LIVEVIEW stream[1] = {0};
HD_COMMON_MEM_
INIT_CONFIG mem_cfg = {0};
HD_RESULT ret;
INT key;
U
INT32 j;
INT32 idx;
#if FLOAT_
IN
stream[0].
input_blob_num = 1;
//net_
in
NET_
IN_CONFIG
in_cfg = {
.
input_filename = "/mnt/sd/jpg/float32.b
in",
.w = 74,
.h = 1,
.c = 40,
.b = 1,
.bitdepth = 32,
.loff = 296,
.fmt = HD_VIDEO_PXLFMT_AI_FLOAT32,
.is_comb_img = 1,
};
NET_
IN_CONFIG
in_cfg2 = {
.
input_filename = "NULL",
.w = 0,
.h = 0,
.c = 0,
.b = 0,
.bitdepth = 0,
.loff = 0,
.fmt = 0,
.is_comb_img = 0,
};
//net
proc
NET_
PROC_CONFIG net_cfg = {
.model_filename = "/mnt/sd/para/nvt_model_float32.b
in",
.label_filename = "/mnt/sd/accuracy/labels.txt"
};
#elif MULTI_BATCH_
IN
/* multi-blob with multi-batch */
stream[0].
input_blob_num = 2;
//net_
in
NET_
IN_CONFIG
in_cfg = {
.
input_filename = "/mnt/sd/jpg/mblob_mbatch_0.yuv",
.w = 12,
.h = 12,
.c = 2,
.b = 8,
.bitdepth = 8,
.loff = 12,
.fmt = HD_VIDEO_PXLFMT_YUV420,
.is_comb_img = 1,
};
NET_
IN_CONFIG
in_cfg2 = {
.
input_filename = "/mnt/sd/jpg/mblob_mbatch_1.b
in",
.w = 1,
.h = 1,
.c = 5,
.b = 8,
.bitdepth = 16,
.loff = 2,
.fmt = 0xA2101000,
.is_comb_img = 1,
};
//net
proc
NET_
PROC_CONFIG net_cfg = {
.model_filename = "/mnt/sd/para/nvt_model_mblob_mbatch.b
in",
.label_filename = "/mnt/sd/accuracy/labels.txt"
};
#else
stream[0].
input_blob_num = 3;
//net_
in
NET_
IN_CONFIG
in_cfg1 = {
.
input_filename = "/mnt/sd/jpg/mblob.b
in",
.w = 224,
.h = 224,
.c = 2,
.b = 1,
.bitdepth = 8,
.loff = 224,
.fmt = HD_VIDEO_PXLFMT_YUV420,
.is_comb_img = 0,
};
NET_
IN_CONFIG
in_cfg2 = {
.
input_filename = "/mnt/sd/jpg/mblob.b
in",
.w = 224,
.h = 224,
.c = 2,
.b = 1,
.bitdepth = 8,
.loff = 224,
.fmt = HD_VIDEO_PXLFMT_YUV420,
.is_comb_img = 0,
};
NET_
IN_CONFIG
in_cfg3 = {
.
input_filename = "/mnt/sd/jpg/mblob.b
in",
.w = 224,
.h = 224,
.c = 2,
.b = 1,
.bitdepth = 8,
.loff = 224,
.fmt = HD_VIDEO_PXLFMT_YUV420,
.is_comb_img = 0,
};
//net
proc
NET_
PROC_CONFIG net_cfg = {
.model_filename = "/mnt/sd/para/nvt_model_mblob.b
in",
.label_filename = "/mnt/sd/accuracy/labels.txt"
};
#endif // End of #if MULTI_BATCH_
IN
if(argc < 4){
pr
intf("usage : ai3_net_with_mblob (
proc_num) (model_path) (
input_blob_num)\n");
pr
intf("usage : (M
PROCESS_
FOR_AIISP)\n");
pr
intf("usage : (dump_time_UT)\n");
pr
intf("usage : (dump_time_
proc)\n");
pr
intf("usage : (dump_output)\n");
pr
intf("usage : (dump_path)\n");
pr
intf("usage : (
input_data_path1) (
input_w) (
input_h) (
input_c) (
input_b) (
input_bitdepth) (
input_loff) (
input_fmt_10) (
input_is_comb_img)\n");
pr
intf("usage : (
input_data_path2) (
input_w) (
input_h) (
input_c) (
input_b) (
input_bitdepth) (
input_loff) (
input_fmt_10) (
input_is_comb_img)\n");
pr
intf("usage : (
input_data_path2) (
input_w) (
input_h) (
input_c) (
input_b) (
input_bitdepth) (
input_loff) (
input_fmt_10) (
input_is_comb_img)\n");
return -1;
}
pr
intf("\r\n\r\n");
idx = 1;
U
INT32
proc_num = 0;
U
INT32
input_blob_num = 0;
{
if (argc > idx) {
sscanf(argv[idx++], "%d", &
proc_num);
pr
intf("
proc_num: %d\n",
proc_num);
g_
proc_num=
proc_num;
}
if (argc > idx) {
sscanf(argv[idx++], "%s", net_cfg.model_filename);
pr
intf("net_cfg.model_filename: %s\n", net_cfg.model_filename);
}
if (argc > idx) {
sscanf(argv[idx++], "%d", &
input_blob_num);
pr
intf("
input_blob_num: %d\n",
input_blob_num);
stream[0].
input_blob_num=
input_blob_num;
}
if (argc > idx) {
sscanf(argv[idx++], "%d", &M
PROCESS_
FOR_AIISP);
pr
intf("M
PROCESS_
FOR_AIISP : %d\n", M
PROCESS_
FOR_AIISP);
}
if (argc > idx) {
sscanf(argv[idx++], "%d", &dump_time_ut);
pr
intf("dump_time_ut: %d\n", dump_time_ut);
}
if (argc > idx) {
sscanf(argv[idx++], "%d", &dump_time_
proc);
pr
intf("dump_time_
proc: %d\n", dump_time_
proc);
}
if (argc > idx) {
sscanf(argv[idx++], "%d", &dump_output);
pr
intf("dump_output: %d\n", dump_output);
}
if (argc > idx) {
sscanf(argv[idx++], "%s", dump_path);
pr
intf("dump_path: %s\n", dump_path);
}
if (argc > idx) {
sscanf(argv[idx++], "%s",
in_cfg1.
input_filename);
pr
intf("
in_cfg1.
input_filename: %s\n",
in_cfg1.
input_filename);
}
if (argc > idx) {
sscanf(argv[idx++], "%d", &(
in_cfg1.w));
pr
intf("(
in_cfg1.w): %d\n", (
in_cfg1.w));
}
if (argc > idx) {
sscanf(argv[idx++], "%d", &(
in_cfg1.h));
pr
intf("(
in_cfg1.h): %d\n", (
in_cfg1.h));
}
if (argc > idx) {
sscanf(argv[idx++], "%d", &(
in_cfg1.c));
pr
intf("(
in_cfg1.c): %d\n", (
in_cfg1.c));
}
if (argc > idx) {
sscanf(argv[idx++], "%d", &(
in_cfg1.b));
pr
intf("(
in_cfg1.b): %d\n", (
in_cfg1.b));
}
if (argc > idx) {
sscanf(argv[idx++], "%d", &(
in_cfg1.bitdepth));
pr
intf("(
in_cfg1.bitdepth): %d\n", (
in_cfg1.bitdepth));
}
if (argc > idx) {
sscanf(argv[idx++], "%d", &(
in_cfg1.loff));
pr
intf("(
in_cfg1.loff): %d\n", (
in_cfg1.loff));
}
if (argc > idx) {
sscanf(argv[idx++], "%d", &(
in_cfg1.fmt));
pr
intf("(
in_cfg1.fmt): %d\n", (
in_cfg1.fmt));
}
if (argc > idx) {
sscanf(argv[idx++], "%d", &(
in_cfg1.is_comb_img));
pr
intf("(
in_cfg1.is_comb_img): %d\n", (
in_cfg1.is_comb_img));
}
if (argc > idx) {
sscanf(argv[idx++], "%s",
in_cfg2.
input_filename);
pr
intf("
in_cfg2.
input_filename: %s\n",
in_cfg2.
input_filename);
}
if (argc > idx) {
sscanf(argv[idx++], "%d", &(
in_cfg2.w));
pr
intf("(
in_cfg2.w): %d\n", (
in_cfg2.w));
}
if (argc > idx) {
sscanf(argv[idx++], "%d", &(
in_cfg2.h));
pr
intf("(
in_cfg2.h): %d\n", (
in_cfg2.h));
}
if (argc > idx) {
sscanf(argv[idx++], "%d", &(
in_cfg2.c));
pr
intf("(
in_cfg2.c): %d\n", (
in_cfg2.c));
}
if (argc > idx) {
sscanf(argv[idx++], "%d", &(
in_cfg2.b));
pr
intf("(
in_cfg2.b): %d\n", (
in_cfg2.b));
}
if (argc > idx) {
sscanf(argv[idx++], "%d", &(
in_cfg2.bitdepth));
pr
intf("(
in_cfg2.bitdepth): %d\n", (
in_cfg2.bitdepth));
}
if (argc > idx) {
sscanf(argv[idx++], "%d", &(
in_cfg2.loff));
pr
intf("(
in_cfg2.loff): %d\n", (
in_cfg2.loff));
}
if (argc > idx) {
sscanf(argv[idx++], "%d", &(
in_cfg2.fmt));
pr
intf("(
in_cfg2.fmt): %d\n", (
in_cfg2.fmt));
}
if (argc > idx) {
sscanf(argv[idx++], "%d", &(
in_cfg2.is_comb_img));
pr
intf("(
in_cfg2.is_comb_img): %d\n", (
in_cfg2.is_comb_img));
}
// cfg3
if (argc > idx) {
sscanf(argv[idx++], "%s",
in_cfg3.
input_filename);
pr
intf("
in_cfg3.
input_filename: %s\n",
in_cfg3.
input_filename);
}
if (argc > idx) {
sscanf(argv[idx++], "%d", &(
in_cfg3.w));
pr
intf("(
in_cfg3.w): %d\n", (
in_cfg3.w));
}
if (argc > idx) {
sscanf(argv[idx++], "%d", &(
in_cfg3.h));
pr
intf("(
in_cfg3.h): %d\n", (
in_cfg3.h));
}
if (argc > idx) {
sscanf(argv[idx++], "%d", &(
in_cfg3.c));
pr
intf("(
in_cfg3.c): %d\n", (
in_cfg3.c));
}
if (argc > idx) {
sscanf(argv[idx++], "%d", &(
in_cfg3.b));
pr
intf("(
in_cfg3.b): %d\n", (
in_cfg3.b));
}
if (argc > idx) {
sscanf(argv[idx++], "%d", &(
in_cfg3.bitdepth));
pr
intf("(
in_cfg3.bitdepth): %d\n", (
in_cfg3.bitdepth));
}
if (argc > idx) {
sscanf(argv[idx++], "%d", &(
in_cfg3.loff));
pr
intf("(
in_cfg3.loff): %d\n", (
in_cfg3.loff));
}
if (argc > idx) {
sscanf(argv[idx++], "%d", &(
in_cfg3.fmt));
pr
intf("(
in_cfg3.fmt): %d\n", (
in_cfg3.fmt));
}
if (argc > idx) {
sscanf(argv[idx++], "%d", &(
in_cfg3.is_comb_img));
pr
intf("(
in_cfg3.is_comb_img): %d\n", (
in_cfg3.is_comb_img));
}
}
// malloc
for g_
in & g_net
g_
in = (NET_
IN *)malloc(sizeof(NET_
IN)*16);
g_net = (NET_
PROC *)malloc(sizeof(NET_
PROC)*16);
if ((g_
in == NULL) || (g_net == NULL)) {
pr
intf("fail to malloc g_
in/g_net\n");
goto exit;
}
stream[0].
in_path = 0;
stream[0].net_path = 0;
//
init hdal
if(M
PROCESS_
FOR_AIISP){
ret = hd_common_
init(1); // multi-
process
for aiisp
}else{
ret = hd_common_
init(0);
}
//this is no longer need
in 690
/*
#if def
ined(_BSP_NS02201_) || def
ined(_BSP_NS02302_)
// set project config
for AI
hd_common_sysconfig(0, (1<<16), 0, VENDOR_AI_CFG); //enable AI eng
ine
#endif
*/
//
init mem
{
// config common pool
network_mem_config(stream[0].net_path, &mem_cfg, &net_cfg);
}
#if def
ined(_BSP_NS02201_) || def
ined(_BSP_NS02302_)
if(M
PROCESS_
FOR_AIISP){
ret = hd_common_mem_
init(NULL); // multi-
process
for aiisp
}else{
ret = hd_common_mem_
init(&mem_cfg);
}
if (HD_OK != ret) {
pr
intf("hd_common_mem_
init err: %d\r\n", ret);
goto exit;
}
#endif
//
init all modules
ret =
init_module();
if (ret != HD_OK) {
pr
intf("
init fail=%d\n", ret);
goto exit;
}
// set open config
for (j=0; j < stream[0].
input_blob_num; j++) {
if (j == 0) {
ret =
input_set_config((stream[0].
in_path + j), &
in_cfg1);
}
else if (j == 1)
{
ret =
input_set_config((stream[0].
in_path + j), &
in_cfg2);
}
else if (j == 2)
{
ret =
input_set_config((stream[0].
in_path + j), &
in_cfg3);
}
if (HD_OK != ret) {
pr
intf("
in_path(%u)
input_set_config fail=%d\n", (stream[0].
in_path + j), ret);
goto exit;
}
}
// open video_liveview modules
for(j=0; j < stream[0].
input_blob_num; j++) {
ret =
input_open((stream[0].
in_path + j));
if (ret != HD_OK) {
pr
intf("
in_path(%u)
input open fail=%d\n", (stream[0].
in_path + j), ret);
goto exit;
}
}
ret = open_module(&stream[0]);
if (ret != HD_OK) {
pr
intf("open fail=%d\n", ret);
goto exit;
}
// start
input_start(stream[0].
in_path);
network_user_start(&stream[0]);
allocate_buf_by_out_path_list(stream[0].net_path);
do {
pr
intf("Enter q to exit, r to run once\n");
key = GETCHAR();
if (key == 'r') {
// run once
network_user_oneshot(&stream[0]);
cont
inue;
}
if (key == 'q' || key == 0x3) {
break;
}
} while(1);
// stop
input_stop(stream[0].
in_path);
network_user_stop(&stream[0]);
exit:
// close video_liveview modules
ret = close_module(&stream[0]);
if (ret != HD_OK) {
pr
intf("close fail=%d\n", ret);
}
for(j=0; j < stream[0].
input_blob_num; j++) {
ret =
input_close((stream[0].
in_path + j));
if (ret != HD_OK) {
pr
intf("
in_path(%u)
input close fail=%d\n", (stream[0].
in_path + j), ret);
goto exit;
}
}
// un
init all modules
ret = exit_module();
if (ret != HD_OK) {
pr
intf("exit fail=%d\n", ret);
}
#if def
ined(_BSP_NS02201_) || def
ined(_BSP_NS02302_)
// un
init memory
ret = hd_common_mem_un
init();
if (ret != HD_OK) {
pr
intf("mem fail=%d\n", ret);
}
#endif
// un
init hdal
ret = hd_common_un
init();
if (ret != HD_OK) {
pr
intf("common fail=%d\n", ret);
}
// free g_
in & g_net
if (g_
in) free(g_
in);
if (g_net) free(g_net);
return ret;
}
本文介绍了一种在Linux环境下查看每个进程线程数量的方法。使用`ps-A-mPl`命令可以获取进程及其子线程的信息，通过进一步的过滤和计数操作，如使用`grep`和`wc -l`，可以得到指定进程的线程数量。
扫一扫
421
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
