1751 lines
49 KiB
C
1751 lines
49 KiB
C
#include "system/includes.h"
|
||
#include "server/video_server.h"
|
||
#include "server/video_engine_server.h"
|
||
#include "net_video_rec.h"
|
||
#include "strm_video_rec.h"
|
||
#include "action.h"
|
||
#include "app_config.h"
|
||
#include "asm/debug.h"
|
||
#include "asm/osd.h"
|
||
#include "app_database.h"
|
||
#include "storage_device.h"
|
||
#include "server/ctp_server.h"
|
||
#include "os/os_api.h"
|
||
#include "net_server.h"
|
||
#include "server/net_server.h"
|
||
#include "stream_protocol.h"
|
||
#include "event/device_event.h"
|
||
#include "event/net_event.h"
|
||
#include "event/key_event.h"
|
||
|
||
#include "net/config_network.h"
|
||
|
||
extern int pthread_mutex_unlock(int *mutex);
|
||
/******************************************/
|
||
/*tiny code*/
|
||
extern int db_select(const char *name);
|
||
extern int db_update(const char *name, u32 value);
|
||
/******************************************/
|
||
|
||
void net_video_server_init(void);
|
||
static int net_rt_video1_open(struct intent *it);
|
||
static int net_rt_video0_open(struct intent *it);
|
||
static int net_video_rec_start(u8 mark);
|
||
static int net_video_rec_stop(u8 close);
|
||
static int net_video_rec0_ch2_stop(u8 close);
|
||
static int net_video_rec1_ch2_stop(u8 close);
|
||
static int net_video_rec1_stop(u8 close);
|
||
static int net_video_rec_take_photo(void (*callback)(char *buffer, int len));
|
||
static int net_video_rec_get_abr(u32 width);
|
||
static int net_video_rec_alloc_buf(void);
|
||
static void net_video_rec_free_buf(void);
|
||
|
||
#define AUDIO_VOLUME 100
|
||
#define NET_VIDEO_REC_SERVER_NAME "net_video_server"
|
||
#define TAKE_PHOTO_MEM_LEN 40 * 1024
|
||
|
||
#define NET_VIDEO_ERR(x) {if(x) printf("######## %s %d err !!!! \n\n\n",__func__,__LINE__);}
|
||
|
||
static int net_rt_video0_stop(struct intent *it);
|
||
static int net_rt_video1_stop(struct intent *it);
|
||
static int net_video_rec_control(void *_run_cmd);
|
||
|
||
static const unsigned char net_osd_format_buf[] = "yyyy-nn-dd hh:mm:ss";
|
||
|
||
static int net_vd_msg[2];
|
||
|
||
static const u16 net_rec_pix_w[] = {1280, 640};
|
||
static const u16 net_rec_pix_h[] = {720, 480};
|
||
|
||
static struct net_video_hdl net_rec_handler = {0};
|
||
static struct strm_video_hdl *fv_rec_handler = NULL;
|
||
static struct video_rec_hdl *rec_handler = NULL;
|
||
|
||
#define __this_net (&net_rec_handler)
|
||
#define __this_strm (fv_rec_handler)
|
||
#define __this (rec_handler)
|
||
|
||
static OS_MUTEX net_vdrec_mutex;
|
||
|
||
#ifndef CONFIG_VIDEO0_ENABLE
|
||
#undef NET_VREC0_FBUF_SIZE
|
||
#define NET_VREC0_FBUF_SIZE 0
|
||
#endif
|
||
#ifndef CONFIG_VIDEO1_ENABLE
|
||
#undef NET_VREC1_FBUF_SIZE
|
||
#define NET_VREC1_FBUF_SIZE 0
|
||
#endif
|
||
|
||
#if NET_VREC0_FBUF_SIZE
|
||
#if (defined CONFIG_NET_TCP_ENABLE || defined CONFIG_NET_UDP_ENABLE || defined CONFIG_VIDEO_720P)
|
||
//内部sram只用静态buff
|
||
#define USE_STATIC_BUFF 1// 0 malloc , 1 static
|
||
#else
|
||
#define USE_STATIC_BUFF 0// 0 malloc , 1 static
|
||
#endif
|
||
#endif
|
||
|
||
#if (defined CONFIG_IPERF_ENABLE) && (defined CONFIG_NO_SDRAM_ENABLE) //无sdram开iperf测试内存需要130K，去掉静态留出内存
|
||
#undef USE_STATIC_BUFF
|
||
#define USE_STATIC_BUFF 0
|
||
#endif
|
||
|
||
#ifdef CONFIG_VIDEO_720P
|
||
#define NET_ISC_SBUF_SIZE (CONFIG_VIDEO_IMAGE_W*64*3/2)/*720P内部ISC BUFF采用内部ram*/
|
||
#else
|
||
#define NET_ISC_SBUF_SIZE (CONFIG_VIDEO_IMAGE_W*32*3/2)/*720P内部ISC BUFF采用内部ram*/
|
||
#endif
|
||
|
||
#ifdef CONFIG_VIDEO_720P
|
||
#define CAP_IMG_SIZE (150*1024)
|
||
#else
|
||
#define CAP_IMG_SIZE (40*1024)
|
||
#endif
|
||
|
||
#if USE_STATIC_BUFF
|
||
u8 net_video_buf[NET_VREC0_FBUF_SIZE] ALIGNE(4);
|
||
u8 net_audio_buf[NET_AUDIO_BUF_SIZE] ALIGNE(4);
|
||
u8 net_isc_sbuf[NET_ISC_SBUF_SIZE] SEC(.sram) ALIGNE(32);//必须32对齐
|
||
#endif
|
||
|
||
/*
|
||
*start user net video rec , 必须在app_config.h配置宏CONFIG_NET_USR_ENABLE 和NET_USR_PATH
|
||
*/
|
||
int user_net_video_rec_open(char forward)
|
||
{
|
||
int ret;
|
||
u8 open = 2;//char type : 0 audio , 1 video , 2 audio and video
|
||
struct intent it = {0};
|
||
struct rt_stream_app_info info = {0};
|
||
|
||
info.width = CONFIG_VIDEO_IMAGE_W;
|
||
info.height = CONFIG_VIDEO_IMAGE_H;
|
||
|
||
//帧率 app_config.h : NET_VIDEO_REC_FPS0/NET_VIDEO_REC_FPS1
|
||
|
||
it.data = &open;
|
||
it.exdata = (u32)&info;
|
||
|
||
if (__this_net->is_open) {
|
||
return 0;
|
||
}
|
||
__this_net->is_open = TRUE;
|
||
if (forward) {
|
||
ret = net_rt_video0_open(&it);
|
||
if (ret) {
|
||
__this_net->is_open = FALSE;
|
||
}
|
||
}
|
||
return ret;
|
||
}
|
||
|
||
int user_net_video_rec_close(char forward)
|
||
{
|
||
int ret = 0;
|
||
struct intent it = {0};
|
||
u8 close = 2;//char type : 0 audio , 1 video , 2 audio and video
|
||
|
||
it.data = &close;
|
||
if (!__this_net->is_open) {
|
||
return 0;
|
||
}
|
||
if (forward) {
|
||
ret = net_rt_video0_stop(&it);
|
||
}
|
||
__this_net->is_open = FALSE;
|
||
return ret;
|
||
}
|
||
|
||
void user_net_video_rec_take_photo_cb(char *buf, int len)//必须打开user_net_video_rec_open()
|
||
{
|
||
if (buf && len) {
|
||
printf("take photo success \n");
|
||
put_buf(buf, 32);
|
||
/*
|
||
//目录1写卡例子
|
||
FILE *fd = fopen(CAMERA0_CAP_PATH"IMG_***.jpg","w+");
|
||
if (fd) {
|
||
fwrite(fd,buf,len);
|
||
fclose(fd);
|
||
}
|
||
*/
|
||
}
|
||
}
|
||
//qua : 0 240p, 1 480p, 2 720p
|
||
int user_net_video_rec_take_photo(int qua, void (*callback)(char *buf, int len))//必须打开user_net_video_rec_open()
|
||
{
|
||
db_update("qua", qua);
|
||
net_video_rec_take_photo(callback);
|
||
return 0;
|
||
}
|
||
//example 720P: user_net_video_rec_take_photo(2, user_net_video_rec_take_photo_cb);
|
||
int user_net_video_rec_take_photo_test(void)
|
||
{
|
||
user_net_video_rec_take_photo(2, user_net_video_rec_take_photo_cb);
|
||
return 0;
|
||
}
|
||
/*
|
||
*end of user net video rec
|
||
*/
|
||
|
||
int net_video_rec_get_list_vframe(void)
|
||
{
|
||
return __this_net->fbuf_fcnt;
|
||
}
|
||
void net_video_rec_pkg_get_video_in_frame(char *fbuf, u32 frame_size)
|
||
{
|
||
__this_net->fbuf_fcnt++;
|
||
__this_net->fbuf_ffil += frame_size;
|
||
}
|
||
void net_video_rec_pkg_get_video_out_frame(char *fbuf, u32 frame_size)
|
||
{
|
||
if (__this_net->fbuf_fcnt) {
|
||
__this_net->fbuf_fcnt--;
|
||
}
|
||
if (__this_net->fbuf_ffil) {
|
||
__this_net->fbuf_ffil -= frame_size;
|
||
}
|
||
}
|
||
static void net_video_handler_init(void)
|
||
{
|
||
if (!fv_rec_handler) {
|
||
fv_rec_handler = (struct strm_video_hdl *)get_strm_video_rec_handler();
|
||
}
|
||
if (!rec_handler) {
|
||
rec_handler = (struct video_rec_hdl *)get_video_rec_handler();
|
||
}
|
||
}
|
||
|
||
void *get_net_video_rec_handler(void)
|
||
{
|
||
return (void *)&net_rec_handler;
|
||
}
|
||
|
||
void *get_video_rec0_handler(void)
|
||
{
|
||
if (!__this) {
|
||
return NULL;
|
||
}
|
||
return (void *)__this->video_rec0;
|
||
}
|
||
|
||
void *get_video_rec1_handler(void)
|
||
{
|
||
if (!__this) {
|
||
return NULL;
|
||
}
|
||
#ifdef CONFIG_VIDEO1_ENABLE
|
||
return (void *)__this->video_rec1;
|
||
#endif
|
||
#ifdef CONFIG_VIDEO2_ENABLE
|
||
return (void *)__this->video_rec2;
|
||
#endif
|
||
return NULL;
|
||
}
|
||
|
||
int net_video_rec_state(void)//获取录像状态，返回值大于0（1280/640）成功，失败 0
|
||
{
|
||
int res = db_select("res");
|
||
res = (res > 1 || res < 0) ? 1 : res;
|
||
if (__this && __this->state == VIDREC_STA_START) {
|
||
return net_rec_pix_w[res];
|
||
}
|
||
return 0;
|
||
}
|
||
int net_video_rec_uvc_online(void)
|
||
{
|
||
return dev_online("uvc");
|
||
}
|
||
int net_pkg_get_video_size(int *width, int *height)
|
||
{
|
||
u8 id = __this_net->video_id ? 1 : 0;
|
||
*width = __this_net->net_videoreq[id].rec.width;
|
||
*height = __this_net->net_videoreq[id].rec.height;
|
||
return 0;
|
||
}
|
||
int net_video_buff_set_frame_cnt(void)
|
||
{
|
||
#ifdef NET_VIDEO_BUFF_FRAME_CNT
|
||
return NET_VIDEO_BUFF_FRAME_CNT;
|
||
#else
|
||
return 0;
|
||
#endif
|
||
}
|
||
u8 net_video_rec_get_drop_fp(void)
|
||
{
|
||
#ifdef NET_VIDEO_REC_DROP_REAl_FP
|
||
return NET_VIDEO_REC_DROP_REAl_FP;
|
||
#else
|
||
return 0;
|
||
#endif
|
||
}
|
||
u8 net_video_rec_get_lose_fram(void)
|
||
{
|
||
#ifdef NET_VIDEO_REC_LOSE_FRAME_CNT
|
||
return NET_VIDEO_REC_LOSE_FRAME_CNT;
|
||
#else
|
||
return 0;
|
||
#endif
|
||
}
|
||
u8 net_video_rec_get_send_fram(void)
|
||
{
|
||
#ifdef NET_VIDEO_REC_SEND_FRAME_CNT
|
||
return NET_VIDEO_REC_SEND_FRAME_CNT;
|
||
#else
|
||
return 0;
|
||
#endif
|
||
}
|
||
int net_video_rec_get_fps(void)
|
||
{
|
||
int ret;
|
||
int fp = 15;
|
||
ret = net_video_rec_state();
|
||
if (ret) {
|
||
fp = VIDEO_REC_FPS;
|
||
} else {
|
||
if (!__this_net->video_id) {
|
||
fp = NET_VIDEO_REC_FPS0;
|
||
} else {
|
||
fp = NET_VIDEO_REC_FPS1;
|
||
}
|
||
}
|
||
ret = fp ? fp : 20;
|
||
return ret;
|
||
}
|
||
|
||
void net_video_rec_post_msg(const char *msg, ...)
|
||
{
|
||
#ifdef CONFIG_UI_ENABLE
|
||
/*
|
||
union uireq req;
|
||
va_list argptr;
|
||
|
||
va_start(argptr, msg);
|
||
|
||
if (__this->ui) {
|
||
req.msg.receiver = ID_WINDOW_VIDEO_REC;
|
||
req.msg.msg = msg;
|
||
req.msg.exdata = argptr;
|
||
|
||
server_request(__this->ui, UI_REQ_MSG, &req);
|
||
}
|
||
|
||
va_end(argptr);
|
||
*/
|
||
#endif
|
||
|
||
}
|
||
void net_video_rec_fmt_notify(void)
|
||
{
|
||
char buf[32];
|
||
#if defined CONFIG_ENABLE_VLIST
|
||
extern void FILE_DELETE(char *__fname, u8 create_file);
|
||
FILE_DELETE(NULL, __this_net->is_open);
|
||
sprintf(buf, "frm:1");
|
||
CTP_CMD_COMBINED(NULL, CTP_NO_ERR, "FORMAT", "NOTIFY", buf);
|
||
#endif
|
||
}
|
||
|
||
char *video_rec_finish_get_name(FILE *fd, int index, u8 is_emf) //index ：video0前视0，video1则1，video2则2 , is_emf 紧急文件
|
||
{
|
||
static char path[64] ALIGNE(32) = {0};
|
||
u8 name[64];
|
||
u8 *dir;
|
||
int err;
|
||
|
||
#ifdef CONFIG_ENABLE_VLIST
|
||
memset(path, 0, sizeof(path));
|
||
err = fget_name(fd, name, 64);
|
||
/*printf("finish_get_name: %s \n", name);*/
|
||
if (err <= 0) {
|
||
return NULL;
|
||
}
|
||
if (index < 0) {
|
||
strcpy(path, name);
|
||
return path;
|
||
}
|
||
switch (index) {
|
||
case 0:
|
||
dir = CONFIG_REC_PATH_0;
|
||
break;
|
||
case 1:
|
||
dir = CONFIG_REC_PATH_1;
|
||
break;
|
||
case 2:
|
||
dir = CONFIG_REC_PATH_2;
|
||
break;
|
||
default:
|
||
return NULL;
|
||
}
|
||
#ifdef CONFIG_EMR_DIR_ENABLE
|
||
if (is_emf) {
|
||
sprintf(path, "%s%s%s", dir, CONFIG_EMR_REC_DIR, name);
|
||
} else
|
||
#endif
|
||
{
|
||
sprintf(path, "%s%s", dir, name);
|
||
}
|
||
|
||
return path;
|
||
#else
|
||
return NULL;
|
||
#endif
|
||
}
|
||
|
||
int video_rec_finish_notify(char *path)
|
||
{
|
||
int err = 0;
|
||
|
||
if (__this_net->video_rec_err) {
|
||
__this_net->video_rec_err = FALSE;
|
||
return 0;
|
||
}
|
||
os_mutex_pend(&net_vdrec_mutex, 0);
|
||
#ifdef CONFIG_ENABLE_VLIST
|
||
FILE_LIST_ADD(0, (const char *)path, __this_net->is_open);
|
||
#endif
|
||
os_mutex_post(&net_vdrec_mutex);
|
||
return err;
|
||
}
|
||
int video_rec_delect_notify(FILE *fd, int id)
|
||
{
|
||
int err = 0;
|
||
if (__this_net->video_rec_err) {
|
||
__this_net->video_rec_err = FALSE;
|
||
return 0;
|
||
}
|
||
#ifdef CONFIG_ENABLE_VLIST
|
||
char *delect_path;
|
||
os_mutex_pend(&net_vdrec_mutex, 0);
|
||
char *path = video_rec_finish_get_name(fd, id, 0);
|
||
if (path == NULL) {
|
||
os_mutex_post(&net_vdrec_mutex);
|
||
return -1;
|
||
}
|
||
FILE_DELETE((const char *)path, __this_net->is_open);
|
||
os_mutex_post(&net_vdrec_mutex);
|
||
#endif
|
||
return err;
|
||
}
|
||
|
||
int video_rec_err_notify(const char *method)
|
||
{
|
||
int err = 0;
|
||
char *err_path;
|
||
|
||
os_mutex_pend(&net_vdrec_mutex, 0);
|
||
if (method && !strcmp((const char *)method, "VIDEO_REC_ERR")) {
|
||
__this_net->video_rec_err = TRUE;
|
||
}
|
||
os_mutex_post(&net_vdrec_mutex);
|
||
return err;
|
||
}
|
||
int video_rec_state_notify(void)
|
||
{
|
||
int err = 0;
|
||
net_vd_msg[0] = NET_VIDREC_STATE_NOTIFY;
|
||
err = os_taskq_post_msg(NET_VIDEO_REC_SERVER_NAME, 1, (int)net_vd_msg);
|
||
return err;
|
||
}
|
||
|
||
int video_rec_start_notify(void)
|
||
{
|
||
return net_video_rec_control(0);//启动录像之前需要关闭实时流
|
||
}
|
||
int video_rec_all_stop_notify(void)
|
||
{
|
||
int err = 0;
|
||
net_vd_msg[0] = NET_VIDREC_STA_STOP;
|
||
err = os_taskq_post_msg(NET_VIDEO_REC_SERVER_NAME, 1, (int)net_vd_msg);
|
||
return err;
|
||
}
|
||
void net_video_rec_status_notify(void)
|
||
{
|
||
char buf[128];
|
||
u8 sta = 0;
|
||
if (__this && __this->state == VIDREC_STA_START) {
|
||
sta = 1;
|
||
}
|
||
memset(buf, 0, sizeof(buf));
|
||
sprintf(buf, "status:%d", sta);
|
||
CTP_CMD_COMBINED(NULL, CTP_NO_ERR, "VIDEO_CTRL", "NOTIFY", buf);
|
||
}
|
||
int net_video_rec_event_notify(void)
|
||
{
|
||
char buf[128];
|
||
int res = db_select("res2");
|
||
res = res > 0 ? res : 0;
|
||
#ifdef CONFIG_VIDEO1_ENABLE
|
||
#ifdef CONFIG_SPI_VIDEO_ENABLE
|
||
extern int spi_camera_width_get(void);
|
||
extern int spi_camera_height_get(void);
|
||
sprintf(buf, "status:1,h:%d,w:%d,fps:%d,rate:%d,format:1", spi_camera_height_get(), spi_camera_width_get(), 15, net_video_rec_get_audio_rate());
|
||
CTP_CMD_COMBINED(NULL, CTP_NO_ERR, "PULL_VIDEO_STATUS", "NOTIFY", buf);
|
||
return 0;
|
||
#endif
|
||
if (dev_online("video1"))
|
||
#else
|
||
#ifdef CONFIG_VIDEO2_ENABLE
|
||
if (dev_online("uvc"))
|
||
#else
|
||
if (0)
|
||
#endif
|
||
#endif
|
||
{
|
||
switch (res) {
|
||
case VIDEO_RES_1080P:
|
||
sprintf(buf, "status:1,h:%d,w:%d,fps:%d,rate:%d,format:1", 720, 1280, net_video_rec_get_fps(), net_video_rec_get_audio_rate());
|
||
break;
|
||
case VIDEO_RES_720P:
|
||
sprintf(buf, "status:1,h:%d,w:%d,fps:%d,rate:%d,format:1", 480, 640, net_video_rec_get_fps(), net_video_rec_get_audio_rate());
|
||
break;
|
||
case VIDEO_RES_VGA:
|
||
sprintf(buf, "status:1,h:%d,w:%d,fps:%d,rate:%d,format:1", 480, 640, net_video_rec_get_fps(), net_video_rec_get_audio_rate());
|
||
break;
|
||
default:
|
||
sprintf(buf, "status:1,h:%d,w:%d,fps:%d,rate:%d,format:1", 480, 640, net_video_rec_get_fps(), net_video_rec_get_audio_rate());
|
||
break;
|
||
}
|
||
CTP_CMD_COMBINED(NULL, CTP_NO_ERR, "PULL_VIDEO_STATUS", "NOTIFY", buf);
|
||
} else {
|
||
strcpy(buf, "status:0");
|
||
CTP_CMD_COMBINED(NULL, CTP_NO_ERR, "PULL_VIDEO_STATUS", "NOTIFY", buf);
|
||
}
|
||
return 0;
|
||
}
|
||
int net_video_rec_event_stop(void)
|
||
{
|
||
net_video_rec_stop(1);
|
||
return 0;
|
||
}
|
||
int net_video_rec_event_start(void)
|
||
{
|
||
net_rt_video0_open(NULL);
|
||
return 0;
|
||
}
|
||
int video_rec_sd_event_ctp_notify(char state)
|
||
{
|
||
char buf[128];
|
||
printf("~~~ : %s , %d\n\n", __func__, state);
|
||
|
||
#if defined CONFIG_ENABLE_VLIST
|
||
if (!state) {
|
||
FILE_REMOVE_ALL();
|
||
}
|
||
#endif
|
||
sprintf(buf, "online:%d", state);
|
||
CTP_CMD_COMBINED(NULL, CTP_NO_ERR, "SD_STATUS", "NOTIFY", buf);
|
||
|
||
if (state) {
|
||
u32 space = 0;
|
||
struct vfs_partition *part = NULL;
|
||
if (storage_device_ready() == 0) {
|
||
msleep(200);
|
||
if (storage_device_ready()) {
|
||
goto sd_scan;
|
||
}
|
||
printf("---%s , storage_device_not_ready !!!!\n\n", __func__);
|
||
CTP_CMD_COMBINED(NULL, CTP_SD_OFFLINE, "TF_CAP", "NOTIFY", CTP_SD_OFFLINE_MSG);
|
||
} else {
|
||
sd_scan:
|
||
part = fget_partition(CONFIG_ROOT_PATH);
|
||
fget_free_space(CONFIG_ROOT_PATH, &space);
|
||
sprintf(buf, "left:%d,total:%d", space / 1024, part->total_size / 1024);
|
||
CTP_CMD_COMBINED(NULL, CTP_NO_ERR, "TF_CAP", "NOTIFY", buf);
|
||
}
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
|
||
//NET USE API
|
||
static void video_rec_get_app_status(struct intent *it)
|
||
{
|
||
it->data = (const char *)__this;
|
||
it->exdata = (u32)__this_net;
|
||
}
|
||
static void ctp_cmd_notity(const char *path)
|
||
{
|
||
#if defined CONFIG_ENABLE_VLIST
|
||
FILE_LIST_ADD(0, path, __this_net->is_open);
|
||
#endif
|
||
}
|
||
|
||
int net_video_rec_get_audio_rate()
|
||
{
|
||
return VIDEO_REC_AUDIO_SAMPLE_RATE;
|
||
}
|
||
|
||
int video_rec_cap_photo(char *buf, int len)
|
||
{
|
||
u32 *flen;
|
||
u8 *cap_img;
|
||
if (__this_net->cap_image) {
|
||
cap_img = &__this_net->cap_image;
|
||
} else {
|
||
cap_img = &__this_strm->cap_image;
|
||
}
|
||
if (*cap_img && __this && __this->cap_buf) {
|
||
*cap_img = FALSE;
|
||
flen = __this->cap_buf;
|
||
memcpy(__this->cap_buf + 4, buf, len);
|
||
*flen = len;
|
||
}
|
||
return 0;
|
||
}
|
||
static int net_video_rec_take_photo(void (*callback)(char *buffer, int len))
|
||
{
|
||
struct server *server = NULL;
|
||
union video_req req = {0};
|
||
char *path;
|
||
char buf[48];
|
||
char name_buf[20];
|
||
int err;
|
||
|
||
if (!(__this_net->net_state == VIDREC_STA_START || __this_net->net_state_ch2 == VIDREC_STA_START)) {
|
||
printf("waring :net video not open or video record running \n");
|
||
goto error;
|
||
}
|
||
|
||
server = __this_net->net_video_rec;
|
||
req.icap.quality = VIDEO_MID_Q;
|
||
req.icap.buf_size = CAP_IMG_SIZE;
|
||
req.icap.buf = malloc(CAP_IMG_SIZE);
|
||
if (!req.icap.buf) {
|
||
goto error;
|
||
}
|
||
req.rec.text_osd = NULL;
|
||
req.rec.graph_osd = NULL;
|
||
req.icap.text_label = NULL;
|
||
req.icap.file_name = name_buf;
|
||
req.icap.path = CAMERA0_CAP_PATH"IMG_****.jpg";
|
||
path = CAMERA0_CAP_PATH;
|
||
err = server_request(server, VIDEO_REQ_IMAGE_CAPTURE, &req);
|
||
if (err != 0) {
|
||
puts("\n\n\ntake photo err\n\n\n");
|
||
goto error;
|
||
}
|
||
sprintf(buf, "%s%s", path, req.icap.file_name);
|
||
printf("%s\n\n", buf);
|
||
CTP_CMD_COMBINED(NULL, CTP_REQUEST, "PHOTO_CTRL", "NOTIFY", CTP_REQUEST_MSG);
|
||
if (req.icap.buf) {
|
||
free(req.icap.buf);
|
||
}
|
||
return 0;
|
||
|
||
error:
|
||
if (req.icap.buf) {
|
||
free(req.icap.buf);
|
||
}
|
||
return -EINVAL;
|
||
}
|
||
|
||
|
||
|
||
extern int atoi(const char *);
|
||
static void rt_stream_cmd_analysis(u8 chl, u32 add)
|
||
{
|
||
char *key;
|
||
char *value;
|
||
struct rt_stream_app_info *info = (struct rt_stream_app_info *)add;
|
||
|
||
info->width = CONFIG_VIDEO_IMAGE_W;
|
||
info->height = CONFIG_VIDEO_IMAGE_H;
|
||
|
||
__this_net->net_videoreq[chl].rec.width = info->width;
|
||
__this_net->net_videoreq[chl].rec.height = info->height;
|
||
__this_net->net_videoreq[chl].rec.format = info->type - NET_VIDEO_FMT_AVI;
|
||
__this_net->net_videoreq[chl].rec.format = 0;
|
||
__this_net->net_videoreq[chl].rec.fps = net_video_rec_get_fps();
|
||
__this_net->net_videoreq[chl].rec.real_fps = net_video_rec_get_fps();
|
||
__this_net->priv = info->priv;
|
||
printf(">>>>>>>> ch %d , info->type : %d ,w:%d , h:%d\n\n", chl, info->type, info->width, info->height);
|
||
|
||
}
|
||
|
||
static void net_video_rec_set_bitrate(unsigned int bits_rate)
|
||
{
|
||
union video_req req = {0};
|
||
|
||
req.rec.channel = __this_net->channel;
|
||
|
||
req.rec.state = VIDEO_STATE_RESET_BITS_RATE;
|
||
req.rec.abr_kbps = bits_rate;
|
||
|
||
server_request(__this_net->net_video_rec, VIDEO_REQ_REC, &req);
|
||
}
|
||
|
||
/*
|
||
*双路应用层使用小内存YUV大小:根据传参的width可知是实时流或录像分辨率的宽进行区分
|
||
*返回值:设定双路的YUV大小(默认200K左右，最小为16行对应YUV大小)(0:1帧对应YUV大小)
|
||
*/
|
||
u32 app_jpeg_spec_set_large_image_yuv_size(u16 width)
|
||
{
|
||
#ifdef CONFIG_VIDEO_SPEC_DOUBLE_REC_MODE
|
||
return (__SDRAM_SIZE__ > 2 * 1024 * 1024) ? 0 : 200 * 1024;
|
||
#endif
|
||
return 0;
|
||
}
|
||
/*双路应用层动态码率修改:根据传参的width可知是实时流或录像分辨率的宽进行区分
|
||
返回值:动态码率设置值(0:原始请求设置的码率)
|
||
*/
|
||
u32 app_jpeg_spec_abr_set(u16 width, u32 fps, u32 abr_kbps)
|
||
{
|
||
return 0;
|
||
}
|
||
/*单路应用层动态码率修改:根据传参的width可知是实时流或录像分辨率的宽进行区分
|
||
返回值:动态码率设置值(0:原始请求设置的码率)
|
||
*/
|
||
u32 app_jpeg_abr_set(u16 width, u32 fps, u32 abr_kbps)
|
||
{
|
||
return 0;
|
||
}
|
||
/*码率控制，根据具体分辨率设置*/
|
||
static int net_video_rec_get_abr(u32 width)
|
||
{
|
||
/*视频码率kbps使用说明:
|
||
码率：一帧图片以K字节为单位大小 * 帧率 * 8，比如：一帧图片为30KB，帧率为20帧，则码率为30*20*8=4800
|
||
VGA图片大小说明：低等质量(小于20K)，中等质量(20K-40K)，高质量(大于40K，极限70K)
|
||
720P图片大小说明：低等质量(小于50K)，中等质量(50k-100K)，高质量(大于100K，极限150K)
|
||
*/
|
||
|
||
if (width <= 640) {
|
||
return 3000;
|
||
} else {
|
||
return 4000;
|
||
}
|
||
}
|
||
|
||
static void net_rec_dev_server_event_handler(void *priv, int argc, int *argv)
|
||
{
|
||
int mark = 2;
|
||
struct intent it;
|
||
/*
|
||
*该回调函数会在录像过程中，写卡出错被当前录像APP调用，例如录像过程中突然拔卡
|
||
*/
|
||
switch (argv[0]) {
|
||
case VIDEO_SERVER_UVM_ERR:
|
||
log_e("APP_UVM_DEAL_ERR\n");
|
||
break;
|
||
case VIDEO_SERVER_PKG_ERR:
|
||
log_e("video_server_pkg_err\n");
|
||
break;
|
||
case VIDEO_SERVER_PKG_END:
|
||
if (db_select("cyc") > 0) {
|
||
/*video_rec_savefile((int)priv);*/
|
||
} else {
|
||
net_video_rec_control(0);
|
||
}
|
||
break;
|
||
case VIDEO_SERVER_PKG_NET_ERR:
|
||
|
||
init_intent(&it);
|
||
it.data = &mark;
|
||
if (__this_net->net_video0_vrt_on) {
|
||
net_rt_video0_stop(&it);
|
||
__this_net->is_open = FALSE;
|
||
} else if (__this_net->net_video1_vrt_on) {
|
||
#ifdef CONFIG_SPI_VIDEO_ENABLE
|
||
extern int spi_video_task_kill(void *priv);
|
||
int err = spi_video_task_kill(__this_net->priv);
|
||
if (!err) {
|
||
__this_net->net_video1_vrt_on = 0;
|
||
}
|
||
#endif
|
||
}
|
||
break;
|
||
default :
|
||
break;
|
||
}
|
||
}
|
||
|
||
static int net_video_rec0_start()
|
||
{
|
||
int err;
|
||
union video_req req = {0};
|
||
struct video_text_osd text_osd = {0};
|
||
struct video_graph_osd graph_osd;
|
||
u16 max_one_line_strnum;
|
||
char buf[128];
|
||
|
||
#if NET_VIDEO_SHARE_CHANNEL
|
||
if (__this && __this->state == VIDREC_STA_START) {
|
||
#if (!defined CONFIG_NO_SDRAM_ENABLE)
|
||
net_video_rec_free_buf();//使用sdram共用通道释放内存以节省内存，不带sdram则录像和实时流已共用
|
||
#endif
|
||
union video_req req = {0};
|
||
u8 path[48];
|
||
__this_net->net_video_rec = __this->video_rec0;
|
||
req.rec.packet_cb = stream_packet_cb;
|
||
err = server_request(__this_net->net_video_rec, VIDEO_REQ_SET_PACKET_CALLBACK, &req);
|
||
if (err) {
|
||
return err;
|
||
}
|
||
struct sockaddr_in *addr = ctp_srv_get_cli_addr(__this_net->priv);
|
||
if (!addr) {
|
||
addr = cdp_srv_get_cli_addr(__this_net->priv);
|
||
}
|
||
if (!addr) {
|
||
sprintf(path, "usr://%s", "192.168.1.");
|
||
} else {
|
||
#if (defined CONFIG_NET_UDP_ENABLE)
|
||
sprintf(path, "udp://%s:%d", inet_ntoa(addr->sin_addr.s_addr), _FORWARD_PORT);
|
||
#elif (defined CONFIG_NET_TCP_ENABLE)
|
||
sprintf(path, "tcp://%s:%d", inet_ntoa(addr->sin_addr.s_addr), _FORWARD_PORT);
|
||
#elif (defined CONFIG_USR_VIDEO_ENABLE)
|
||
sprintf(path, "usr://%s", CONFIG_USR_PATH);
|
||
#elif (defined CONFIG_NET_TUTK_ENABLE)
|
||
sprintf(req.rec.net_par.netpath, "tutk://%s", " 192.168.1.1");
|
||
#endif
|
||
}
|
||
err = stream_protocol_task_create(path, NULL);
|
||
if (!err) {
|
||
__this_net->net_state = VIDREC_STA_START;
|
||
} else {
|
||
__this_net->net_state = VIDREC_STA_STOP;
|
||
}
|
||
return err;
|
||
}
|
||
#endif
|
||
|
||
if (!__this_net->net_video_rec) {
|
||
#ifdef CONFIG_UVC_VIDEO2_ENABLE
|
||
__this_net->net_video_rec = server_open("video_server", "video2.1");
|
||
#else
|
||
__this_net->net_video_rec = server_open("video_server", "video0.1");
|
||
#endif
|
||
if (!__this_net->net_video_rec) {
|
||
return VREC_ERR_V0_SERVER_OPEN;
|
||
}
|
||
|
||
server_register_event_handler(__this_net->net_video_rec, (void *)0, net_rec_dev_server_event_handler);
|
||
}
|
||
|
||
__this_net->video_id = 0;
|
||
#ifdef CONFIG_UVC_VIDEO2_ENABLE
|
||
req.rec.uvc_id = __this_net->uvc_id;
|
||
#endif
|
||
#ifdef CONFIG_VIDEO_REC_PPBUF_MODE
|
||
req.rec.bfmode = VIDEO_PPBUF_MODE;
|
||
#endif
|
||
#ifdef CONFIG_VIDEO_SPEC_DOUBLE_REC_MODE
|
||
req.rec.wl80_spec_mode = VIDEO_WL80_SPEC_DOUBLE_REC_MODE;
|
||
#endif
|
||
#ifdef CONFIG_UI_ENABLE
|
||
req.rec.picture_mode = 1;//整帧图片模式
|
||
#endif
|
||
#if USE_STATIC_BUFF
|
||
req.rec.isc_sbuf = net_isc_sbuf;
|
||
req.rec.sbuf_size = NET_ISC_SBUF_SIZE;
|
||
#else
|
||
req.rec.isc_sbuf = NULL;
|
||
req.rec.sbuf_size = 0;
|
||
#endif
|
||
req.rec.block_done_cb = NULL;
|
||
req.rec.camera_type = VIDEO_CAMERA_NORMAL;
|
||
req.rec.channel = __this_net->channel = 1;
|
||
req.rec.width = __this_net->net_videoreq[0].rec.width;
|
||
req.rec.height = __this_net->net_videoreq[0].rec.height;
|
||
printf(">>>>>>width=%d height=%d\n\n\n\n", __this_net->net_videoreq[0].rec.width, __this_net->net_videoreq[0].rec.height);
|
||
req.rec.state = VIDEO_STATE_START;
|
||
req.rec.fpath = CONFIG_REC_PATH_0;
|
||
|
||
if (__this_net->net_videoreq[0].rec.format == 1) {
|
||
puts("in h264\n\n");
|
||
req.rec.format = NET_VIDEO_FMT_MOV;
|
||
} else {
|
||
req.rec.format = NET_VIDEO_FMT_AVI;
|
||
}
|
||
if (__this_net->net_videoreq[0].rec.format == 1) {
|
||
req.rec.fname = "vid_***.mov";
|
||
} else {
|
||
req.rec.fname = "vid_***.avi";
|
||
}
|
||
|
||
req.rec.quality = VIDEO_LOW_Q;
|
||
req.rec.fps = 0;
|
||
req.rec.real_fps = net_video_rec_get_fps();
|
||
req.rec.net_par.net_audrt_onoff = __this_net->net_video0_art_on;
|
||
req.rec.net_par.net_vidrt_onoff = __this_net->net_video0_vrt_on;
|
||
req.rec.audio.sample_rate = VIDEO_REC_AUDIO_SAMPLE_RATE;
|
||
req.rec.audio.channel = 1;
|
||
req.rec.audio.channel_bit_map = 0;
|
||
req.rec.audio.volume = AUDIO_VOLUME;
|
||
req.rec.audio.buf = __this_net->audio_buf;
|
||
req.rec.audio.buf_len = NET_AUDIO_BUF_SIZE;
|
||
req.rec.pkg_mute.aud_mute = !db_select("mic");
|
||
|
||
/*
|
||
*码率，I帧和P帧比例，必须是偶数（当录MOV的时候才有效）,
|
||
*roio_xy :值表示宏块坐标， [6:0]左边x坐标 ，[14:8]右边x坐标，[22:16]上边y坐标，[30:24]下边y坐标,写0表示1个宏块有效
|
||
* roio_ratio : 区域比例系数
|
||
*/
|
||
req.rec.abr_kbps = net_video_rec_get_abr(req.rec.width);
|
||
req.rec.IP_interval = 0;
|
||
/*感兴趣区域为下方 中间 2/6 * 4/6 区域，可以调整
|
||
感兴趣区域qp 为其他区域的 70% ，可以调整
|
||
*/
|
||
req.rec.roi.roio_xy = (req.rec.height * 5 / 6 / 16) << 24 | (req.rec.height * 3 / 6 / 16) << 16 | (req.rec.width * 5 / 6 / 16) << 8 | (req.rec.width) * 1 / 6 / 16;
|
||
req.rec.roi.roi1_xy = (req.rec.height * 11 / 12 / 16) << 24 | (req.rec.height * 4 / 12 / 16) << 16 | (req.rec.width * 11 / 12 / 16) << 8 | (req.rec.width) * 1 / 12 / 16;
|
||
req.rec.roi.roi2_xy = 0;
|
||
req.rec.roi.roi3_xy = (1 << 24) | (0 << 16) | ((req.rec.width / 16) << 8) | 0;
|
||
req.rec.roi.roio_ratio = 256 * 70 / 100 ;
|
||
req.rec.roi.roio_ratio1 = 256 * 90 / 100;
|
||
req.rec.roi.roio_ratio2 = 0;
|
||
req.rec.roi.roio_ratio3 = 256 * 80 / 100;
|
||
|
||
#ifdef CONFIG_OSD_ENABLE
|
||
text_osd.font_w = OSD_DEFAULT_WIDTH;//必须16对齐
|
||
text_osd.font_h = OSD_DEFAULT_HEIGHT;//必须16对齐
|
||
text_osd.text_format = net_osd_format_buf;
|
||
text_osd.x = (req.rec.width - text_osd.font_w * strlen(text_osd.text_format) + 15) / 16 * 16;
|
||
text_osd.y = (req.rec.height - text_osd.font_h + 15) / 16 * 16;
|
||
text_osd.osd_yuv = 0xe20095;
|
||
text_osd.font_matrix_table = NULL;
|
||
text_osd.font_matrix_base = NULL;
|
||
text_osd.font_matrix_len = 0;
|
||
if (db_select("dat") > 0) {
|
||
req.rec.text_osd = &text_osd;
|
||
}
|
||
#endif
|
||
|
||
/*
|
||
*慢动作倍数(与延时摄影互斥,无音频); 延时录像的间隔ms(与慢动作互斥,无音频)
|
||
*/
|
||
req.rec.slow_motion = 0;
|
||
req.rec.tlp_time = 0;//db_select("gap");
|
||
req.rec.buf = __this_net->net_v0_fbuf;
|
||
req.rec.buf_len = NET_VREC0_FBUF_SIZE;
|
||
|
||
struct sockaddr_in *addr = ctp_srv_get_cli_addr(__this_net->priv);
|
||
if (!addr) {
|
||
addr = cdp_srv_get_cli_addr(__this_net->priv);
|
||
}
|
||
#if (defined CONFIG_NET_UDP_ENABLE)
|
||
sprintf(req.rec.net_par.netpath, "udp://%s:%d"
|
||
, inet_ntoa(addr->sin_addr.s_addr)
|
||
, _FORWARD_PORT);
|
||
#elif (defined CONFIG_NET_TCP_ENABLE)
|
||
sprintf(req.rec.net_par.netpath, "tcp://%s:%d"
|
||
, inet_ntoa(addr->sin_addr.s_addr)
|
||
, _FORWARD_PORT);
|
||
#elif (defined CONFIG_UVC_VIDEO2_ENABLE)
|
||
sprintf(req.rec.net_par.netpath, "usr://%s", "192.168.1.1");
|
||
#elif (defined CONFIG_USR_VIDEO_ENABLE)
|
||
sprintf(req.rec.net_par.netpath, "usr://%s", CONFIG_USR_PATH);
|
||
#elif (defined CONFIG_NET_TUTK_ENABLE)
|
||
sprintf(req.rec.net_par.netpath, "tutk://%s", " 192.168.1.1");
|
||
#endif
|
||
|
||
err = server_request(__this_net->net_video_rec, VIDEO_REQ_REC, &req);
|
||
|
||
if (err != 0) {
|
||
puts("\n\n\nstart rec err\n\n\n");
|
||
return VREC_ERR_V0_REQ_START;
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
static int net_video_rec0_stop(u8 close)
|
||
{
|
||
union video_req req = {0};
|
||
int err = 0;
|
||
printf("\nnet video rec0 stop\n");
|
||
__this_net->net_state = VIDREC_STA_STOPING;
|
||
#if NET_VIDEO_SHARE_CHANNEL
|
||
if (__this && __this->state == VIDREC_STA_START) {
|
||
err = stream_protocol_task_kill();
|
||
__this_net->net_video_rec = NULL;
|
||
} else
|
||
#endif
|
||
{
|
||
req.rec.channel = 1;
|
||
req.rec.state = VIDEO_STATE_STOP;
|
||
err = server_request(__this_net->net_video_rec, VIDEO_REQ_REC, &req);
|
||
|
||
if (err != 0) {
|
||
printf("\nstop rec err 0x%x\n", err);
|
||
return VREC_ERR_V0_REQ_STOP;
|
||
}
|
||
|
||
if (close) {
|
||
if (__this_net->net_video_rec) {
|
||
server_close(__this_net->net_video_rec);
|
||
__this_net->net_video_rec = NULL;
|
||
}
|
||
}
|
||
}
|
||
__this_net->net_state = VIDREC_STA_STOP;
|
||
__this_net->video_id = 0;
|
||
return 0;
|
||
}
|
||
|
||
static void net_video_rec_free_buf(void)
|
||
{
|
||
#if (USE_STATIC_BUFF == 0)
|
||
if (__this_net->net_v0_fbuf) {
|
||
free(__this_net->net_v0_fbuf);
|
||
__this_net->net_v0_fbuf = NULL;
|
||
}
|
||
if (__this_net->audio_buf) {
|
||
free(__this_net->audio_buf);
|
||
__this_net->audio_buf = NULL;
|
||
}
|
||
#else
|
||
__this_net->net_v0_fbuf = NULL;
|
||
__this_net->audio_buf = NULL;
|
||
#endif
|
||
}
|
||
static int net_video_rec_alloc_buf(void)
|
||
{
|
||
if (!__this_net->net_v0_fbuf && NET_VREC0_FBUF_SIZE) {
|
||
#if (USE_STATIC_BUFF == 0)
|
||
__this_net->net_v0_fbuf = malloc(NET_VREC0_FBUF_SIZE);
|
||
#else
|
||
__this_net->net_v0_fbuf = net_video_buf;
|
||
#endif
|
||
if (!__this_net->net_v0_fbuf) {
|
||
puts("malloc v0_buf err\n\n");
|
||
return -ENOMEM;
|
||
}
|
||
}
|
||
if (!__this_net->audio_buf && VIDEO_REC_AUDIO_SAMPLE_RATE && NET_AUDIO_BUF_SIZE) {
|
||
#if (USE_STATIC_BUFF == 0)
|
||
__this_net->audio_buf = malloc(NET_AUDIO_BUF_SIZE);
|
||
#else
|
||
__this_net->audio_buf = net_audio_buf;
|
||
#endif
|
||
if (!__this_net->audio_buf) {
|
||
free(__this_net->net_v0_fbuf);
|
||
__this_net->net_v0_fbuf = NULL;
|
||
return -ENOMEM;
|
||
}
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
char *get_net_video_isc_buf(int *buf_size)
|
||
{
|
||
#if (USE_STATIC_BUFF == 0)
|
||
*buf_size = 0;
|
||
return 0;
|
||
#else
|
||
*buf_size = NET_ISC_SBUF_SIZE;
|
||
return net_isc_sbuf;
|
||
#endif
|
||
}
|
||
char *get_net_video_rec0_video_buf(int *buf_size)
|
||
{
|
||
*buf_size = NET_VREC0_FBUF_SIZE;
|
||
#if (USE_STATIC_BUFF == 0)
|
||
return __this_net->net_v0_fbuf;
|
||
#else
|
||
return net_video_buf;
|
||
#endif
|
||
}
|
||
char *get_net_video_rec1_video_buf(int *buf_size)
|
||
{
|
||
*buf_size = 0;
|
||
return NULL;
|
||
}
|
||
char *get_net_video_rec2_video_buf(int *buf_size)
|
||
{
|
||
*buf_size = 0;
|
||
return NULL;
|
||
}
|
||
char *get_net_video_rec_audio_buf(int *buf_size)
|
||
{
|
||
*buf_size = NET_AUDIO_BUF_SIZE;
|
||
#if (USE_STATIC_BUFF == 0)
|
||
return __this_net->audio_buf;
|
||
#else
|
||
return net_audio_buf;
|
||
#endif
|
||
}
|
||
static int net_video0_rec_start(struct intent *it)
|
||
{
|
||
int err = 0;
|
||
#ifdef CONFIG_VIDEO0_ENABLE
|
||
err = net_video_rec_alloc_buf();
|
||
if (err) {
|
||
return err;
|
||
}
|
||
if (__this_net->net_video0_art_on || __this_net->net_video0_vrt_on) {
|
||
__this_net->net_state = VIDREC_STA_STARTING;
|
||
err = net_video_rec0_start();
|
||
|
||
if (err) {
|
||
goto __start_err0;
|
||
}
|
||
__this_net->net_state = VIDREC_STA_START;
|
||
}
|
||
|
||
return 0;
|
||
|
||
__start_err0:
|
||
puts("\nstart0 err\n");
|
||
net_video_rec0_stop(0);
|
||
|
||
if (err) {
|
||
printf("\nstart wrong0 %x\n", err);
|
||
//while(1);
|
||
}
|
||
|
||
#endif
|
||
return err;
|
||
}
|
||
|
||
static int net_video_rec_start(u8 mark)
|
||
{
|
||
int err;
|
||
if (!__this_net->is_open) {
|
||
return 0;
|
||
}
|
||
|
||
puts("start net rec\n");
|
||
err = net_video_rec_alloc_buf();
|
||
if (err) {
|
||
return err;
|
||
}
|
||
|
||
#ifdef CONFIG_VIDEO0_ENABLE
|
||
|
||
printf("\n art %d, vrt %d\n", __this_net->net_video0_art_on, __this_net->net_video0_vrt_on);
|
||
|
||
if ((__this_net->net_video0_art_on || __this_net->net_video0_vrt_on)
|
||
&& (__this_net->net_state != VIDREC_STA_START)) {
|
||
puts("\nnet video rec0 start \n");
|
||
err = net_video_rec0_start();
|
||
if (err) {
|
||
goto __start_err0;
|
||
}
|
||
__this_net->net_state = VIDREC_STA_START;
|
||
}
|
||
|
||
#endif
|
||
|
||
return 0;
|
||
|
||
#ifdef CONFIG_VIDEO0_ENABLE
|
||
__start_err0:
|
||
puts("\nstart0 err\n");
|
||
net_video_rec0_stop(0);
|
||
|
||
if (err) {
|
||
printf("\nstart wrong0 %x\n", err);
|
||
}
|
||
|
||
#endif
|
||
|
||
return -EFAULT;
|
||
}
|
||
|
||
|
||
static int net_video0_rec_stop(u8 close)
|
||
{
|
||
int err;
|
||
#ifdef CONFIG_VIDEO0_ENABLE
|
||
__this_net->net_state = VIDREC_STA_STOPING;
|
||
err = net_video_rec0_stop(close);
|
||
|
||
if (err) {
|
||
puts("\n net stop0 err\n");
|
||
}
|
||
|
||
__this_net->net_state = VIDREC_STA_STOP;
|
||
#endif
|
||
return err;
|
||
}
|
||
|
||
static int net_video_rec_stop(u8 close)
|
||
{
|
||
if (!__this_net->is_open) {
|
||
return 0;
|
||
}
|
||
|
||
int err = 0;
|
||
|
||
#ifdef CONFIG_VIDEO0_ENABLE
|
||
puts("\n net_video_rec_stop. 0.. \n");
|
||
|
||
if (__this_net->net_state == VIDREC_STA_START) {
|
||
__this_net->net_state = VIDREC_STA_STOPING;
|
||
err = net_video_rec0_stop(close);
|
||
|
||
if (err) {
|
||
puts("\n net stop0 err\n");
|
||
}
|
||
__this_net->net_state = VIDREC_STA_STOP;
|
||
printf("-----%s state stop \n", __func__);
|
||
}
|
||
|
||
#endif
|
||
|
||
return err;
|
||
}
|
||
|
||
static int net_rt_video0_open(struct intent *it)
|
||
{
|
||
int ret;
|
||
if (!__this_net->is_open) {
|
||
return 0;
|
||
}
|
||
puts("\nnet rt video0 open \n");
|
||
#ifdef CONFIG_VIDEO0_ENABLE
|
||
if (it) {
|
||
u8 mark = *((u8 *)it->data);
|
||
|
||
if (mark == 0) {
|
||
__this_net->net_video0_art_on = 1;
|
||
__this_net->net_video0_vrt_on = 0 ;
|
||
} else if (mark == 1) {
|
||
__this_net->net_video0_vrt_on = 1;
|
||
__this_net->net_video0_art_on = 0;
|
||
} else {
|
||
__this_net->net_video0_art_on = 1;
|
||
__this_net->net_video0_vrt_on = 1;
|
||
}
|
||
rt_stream_cmd_analysis(0, it->exdata);
|
||
} else {
|
||
if (__this_net->net_video0_art_on == 0 && __this_net->net_video0_vrt_on == 0) {
|
||
puts("\n rt not open\n");
|
||
return 0;
|
||
}
|
||
}
|
||
if (__this_net->net_state == VIDREC_STA_START) {
|
||
puts("\n net rt is on \n");
|
||
return 0;
|
||
}
|
||
ret = net_video0_rec_start(it);
|
||
return ret;
|
||
#else
|
||
return 0;
|
||
#endif
|
||
|
||
}
|
||
|
||
|
||
static int net_rt_video0_stop(struct intent *it)
|
||
{
|
||
int ret = 0;
|
||
puts("\nnet rt video0 stop \n");
|
||
if (!__this_net->is_open) {
|
||
return 0;
|
||
}
|
||
|
||
#ifdef CONFIG_VIDEO0_ENABLE
|
||
u8 mark = 2;
|
||
if (it) {
|
||
mark = *((u8 *)it->data);
|
||
}
|
||
|
||
if (mark == 0) {
|
||
__this_net->net_video0_art_on = 0;
|
||
} else if (mark == 1) {
|
||
__this_net->net_video0_vrt_on = 0;
|
||
} else {
|
||
__this_net->net_video0_art_on = 0;
|
||
__this_net->net_video0_vrt_on = 0;
|
||
}
|
||
|
||
if (__this_net->net_state == VIDREC_STA_START) {
|
||
ret = net_video0_rec_stop(1);
|
||
}
|
||
#endif
|
||
return ret;
|
||
}
|
||
|
||
void net_video_rec0_close()
|
||
{
|
||
if (__this_net->net_video_rec) {
|
||
server_close(__this_net->net_video_rec);
|
||
__this_net->net_video_rec = NULL;
|
||
}
|
||
|
||
}
|
||
|
||
static int net_video_rec_close()
|
||
{
|
||
#ifdef CONFIG_VIDEO0_ENABLE
|
||
net_video_rec0_close();
|
||
#endif
|
||
return 0;
|
||
}
|
||
|
||
/*
|
||
* 录像app的录像控制入口, 根据当前状态调用相应的函数
|
||
*/
|
||
static int net_video_rec_control(void *_run_cmd)
|
||
{
|
||
int err = 0;
|
||
u32 clust;
|
||
int run_cmd = (int)_run_cmd;
|
||
struct vfs_partition *part;
|
||
if (storage_device_ready() == 0) {
|
||
if (!dev_online(SDX_DEV)) {
|
||
net_video_rec_post_msg("noCard");
|
||
} else {
|
||
net_video_rec_post_msg("fsErr");
|
||
}
|
||
CTP_CMD_COMBINED(NULL, CTP_SDCARD, "VIDEO_CTRL", "NOTIFY", CTP_SDCARD_MSG);
|
||
return 0;
|
||
} else {
|
||
net_video_handler_init();
|
||
part = fget_partition(CONFIG_ROOT_PATH);
|
||
if (!part) {
|
||
printf("err in fget_partition");
|
||
return 0;
|
||
}
|
||
if (__this) {
|
||
__this->total_size = part->total_size;
|
||
}
|
||
#ifdef CONFIG_JLFAT_ENABLE
|
||
if (part->clust_size < 32 * 1024 || (part->fs_attr & F_ATTR_RO)) {
|
||
#else
|
||
if (part->clust_size < 32 || (part->fs_attr & F_ATTR_RO)) {
|
||
#endif
|
||
net_video_rec_post_msg("fsErr");
|
||
CTP_CMD_COMBINED(NULL, CTP_SDCARD, "VIDEO_CTRL", "NOTIFY", CTP_SDCARD_MSG);
|
||
return 0;
|
||
}
|
||
}
|
||
if (__this) {
|
||
switch (__this->state) {
|
||
case VIDREC_STA_IDLE:
|
||
case VIDREC_STA_STOP:
|
||
if (run_cmd) {
|
||
break;
|
||
}
|
||
__this_net->video_rec_err = FALSE;//用在录像IMC打不开情况下
|
||
printf("--NET_VIDEO_START\n");
|
||
/*NET_VIDEO_ERR(strm_video_rec_close(1));*/
|
||
NET_VIDEO_ERR(net_video_rec_stop(1));
|
||
__this_net->fbuf_fcnt = 0;
|
||
__this_net->fbuf_ffil = 0;
|
||
err = video_rec_control_start();
|
||
if (err == 0) {
|
||
/* net_video_rec_post_msg("onREC"); */
|
||
if (__this->gsen_lock == 1) {
|
||
net_video_rec_post_msg("lockREC");
|
||
}
|
||
}
|
||
NET_VIDEO_ERR(err);
|
||
|
||
/*NET_VIDEO_ERR(strm_video_rec_open());*/
|
||
NET_VIDEO_ERR(net_rt_video0_open(NULL));
|
||
/*NET_VIDEO_ERR(net_rt_video1_open(NULL));*/
|
||
|
||
net_video_rec_status_notify();
|
||
printf("--NET_VIDEO_OPEN OK\n");
|
||
|
||
break;
|
||
case VIDREC_STA_START:
|
||
if (run_cmd == 0) {
|
||
printf("--NET_VIDEO_STOP\n");
|
||
/*NET_VIDEO_ERR(strm_video_rec_close(1));*/
|
||
NET_VIDEO_ERR(net_video_rec_stop(1));
|
||
__this_net->fbuf_fcnt = 0;
|
||
__this_net->fbuf_ffil = 0;
|
||
|
||
err = video_rec_control_doing();
|
||
NET_VIDEO_ERR(err);
|
||
|
||
/*NET_VIDEO_ERR(strm_video_rec_open());*/
|
||
NET_VIDEO_ERR(net_video_rec_start(1));
|
||
printf("--NET_VIDEO_OPEN OK\n");
|
||
}
|
||
net_video_rec_status_notify();
|
||
break;
|
||
default:
|
||
puts("\nvrec forbid\n");
|
||
err = 1;
|
||
break;
|
||
}
|
||
}
|
||
|
||
return err;
|
||
}
|
||
/*
|
||
*录像的状态机,进入录像app后就是跑这里
|
||
*/
|
||
static int net_video_rec_state_machine(struct application *app, enum app_state state, struct intent *it)
|
||
{
|
||
int err = 0;
|
||
int len;
|
||
char buf[128];
|
||
|
||
switch (state) {
|
||
case APP_STA_START:
|
||
if (!it) {
|
||
break;
|
||
}
|
||
switch (it->action) {
|
||
case ACTION_VIDEO_REC_MAIN:
|
||
net_video_server_init();
|
||
break;
|
||
case ACTION_VIDEO_TAKE_PHOTO:
|
||
/*printf("----ACTION_VIDEO_TAKE_PHOTO----\n\n");*/
|
||
net_video_rec_take_photo(NULL);
|
||
break;
|
||
case ACTION_VIDEO_REC_CONCTRL:
|
||
printf("----ACTION_VIDEO_REC_CONCTRL-----\n\n");
|
||
err = net_video_rec_control(0);
|
||
break;
|
||
|
||
case ACTION_VIDEO_REC_GET_APP_STATUS:
|
||
printf("----ACTION_VIDEO_REC_GET_APP_STATUS-----\n\n");
|
||
video_rec_get_app_status(it);
|
||
break;
|
||
|
||
case ACTION_VIDEO_REC_GET_PATH:
|
||
/*printf("----ACTION_VIDEO_REC_GET_PATHL-----\n\n");*/
|
||
break;
|
||
case ACTION_VIDEO0_OPEN_RT_STREAM:
|
||
printf("----ACTION_VIDEO0_OPEN_RT_STREAM-----\n\n");
|
||
__this_net->is_open = TRUE;
|
||
__this_net->fbuf_fcnt = 0;
|
||
__this_net->fbuf_ffil = 0;
|
||
#ifdef CONFIG_SPI_VIDEO_ENABLE
|
||
extern int spi_video_wait_done(void);
|
||
spi_video_wait_done();
|
||
#endif
|
||
err = net_rt_video0_open(it);
|
||
sprintf(buf, "format:%d,w:%d,h:%d,fps:%d,rate:%d"
|
||
, __this_net->net_videoreq[0].rec.format
|
||
, __this_net->net_videoreq[0].rec.width
|
||
, __this_net->net_videoreq[0].rec.height
|
||
, __this_net->net_videoreq[0].rec.real_fps
|
||
, VIDEO_REC_AUDIO_SAMPLE_RATE);
|
||
printf("<<<<<<< : %s\n\n\n\n\n", buf);
|
||
if (err) {
|
||
printf("ACTION_VIDEO0_OPEN_RT_STREAM err!!!\n\n");
|
||
CTP_CMD_COMBINED(NULL, CTP_RT_OPEN_FAIL, "OPEN_RT_STREAM", "NOTIFY", CTP_RT_OPEN_FAIL_MSG);
|
||
} else {
|
||
if (CTP_CMD_COMBINED(NULL, CTP_NO_ERR, "OPEN_RT_STREAM", "NOTIFY", buf)) {
|
||
CTP_CMD_COMBINED(NULL, CTP_NO_ERR, "OPEN_RT_STREAM", "NOTIFY", buf);
|
||
}
|
||
printf("CTP NOTIFY VIDEO0 OK\n\n");
|
||
}
|
||
break;
|
||
|
||
case ACTION_VIDEO1_OPEN_RT_STREAM:
|
||
printf("----ACTION_VIDEO1_OPEN_RT_STREAM----\n\n");
|
||
__this_net->fbuf_fcnt = 0;
|
||
__this_net->fbuf_ffil = 0;
|
||
|
||
#ifdef CONFIG_SPI_VIDEO_ENABLE
|
||
extern int spi_video_task_create(void *priv);
|
||
extern int spi_camera_width_get(void);
|
||
extern int spi_camera_height_get(void);
|
||
extern int spi_video_wait_done(void);
|
||
spi_video_wait_done();
|
||
if (it) {
|
||
rt_stream_cmd_analysis(1, it->exdata);
|
||
err = spi_video_task_create(__this_net->priv);
|
||
if (!err) {
|
||
__this_net->net_video1_vrt_on = 1;
|
||
__this_net->net_videoreq[1].rec.width = spi_camera_width_get();
|
||
__this_net->net_videoreq[1].rec.height = spi_camera_height_get();
|
||
__this_net->net_videoreq[1].rec.real_fps = 15;
|
||
}
|
||
}
|
||
#endif
|
||
sprintf(buf, "format:%d,w:%d,h:%d,fps:%d,rate:%d"
|
||
, __this_net->net_videoreq[1].rec.format
|
||
, __this_net->net_videoreq[1].rec.width
|
||
, __this_net->net_videoreq[1].rec.height
|
||
, __this_net->net_videoreq[1].rec.real_fps
|
||
, VIDEO_REC_AUDIO_SAMPLE_RATE);
|
||
printf("<<<<<<< : %s\n\n\n\n\n", buf);
|
||
if (err) {
|
||
printf("ACTION_VIDEO1_OPEN_RT_STREAM err!!!\n\n");
|
||
CTP_CMD_COMBINED(NULL, CTP_RT_OPEN_FAIL, "OPEN_PULL_RT_STREAM", "NOTIFY", CTP_RT_OPEN_FAIL_MSG);
|
||
} else {
|
||
CTP_CMD_COMBINED(NULL, CTP_NO_ERR, "OPEN_PULL_RT_STREAM", "NOTIFY", buf);
|
||
printf("CTP NOTIFY VIDEO1 OK\n\n");
|
||
}
|
||
break;
|
||
|
||
case ACTION_VIDEO0_CLOSE_RT_STREAM:
|
||
printf("---ACTION_VIDEO0_CLOSE_RT_STREAM---\n\n");
|
||
#ifdef CONFIG_SPI_VIDEO_ENABLE
|
||
extern int spi_video_wait_done(void);
|
||
spi_video_wait_done();
|
||
#endif
|
||
net_rt_video0_stop(it);
|
||
if (err) {
|
||
printf("ACTION_VIDEO_CLOE_RT_STREAM err!!!\n\n");
|
||
strcpy(buf, "status:0");
|
||
} else {
|
||
strcpy(buf, "status:1");
|
||
}
|
||
CTP_CMD_COMBINED(NULL, CTP_NO_ERR, "CLOSE_RT_STREAM", "NOTIFY", buf);
|
||
printf("CTP NOTIFY VIDEO0 OK\n\n");
|
||
__this_net->is_open = FALSE;
|
||
__this_net->fbuf_fcnt = 0;
|
||
__this_net->fbuf_ffil = 0;
|
||
break;
|
||
|
||
case ACTION_VIDEO1_CLOSE_RT_STREAM:
|
||
printf("---ACTION_VIDEO1_CLOSE_RT_STREAM---\n\n");
|
||
#ifdef CONFIG_SPI_VIDEO_ENABLE
|
||
extern int spi_video_task_kill(void *priv);
|
||
extern int spi_video_wait_done(void);
|
||
spi_video_wait_done();
|
||
err = spi_video_task_kill(__this_net->priv);
|
||
if (!err) {
|
||
__this_net->net_video1_vrt_on = 0;
|
||
}
|
||
#endif
|
||
if (err) {
|
||
printf("ACTION_VIDE1_CLOE_RT_STREAM err!!!\n\n");
|
||
strcpy(buf, "status:0");
|
||
} else {
|
||
strcpy(buf, "status:1");
|
||
}
|
||
|
||
CTP_CMD_COMBINED(NULL, CTP_NO_ERR, "CLOSE_PULL_RT_STREAM", "NOTIFY", buf);
|
||
printf("CTP NOTIFY VIDEO1 OK\n\n");
|
||
__this_net->is_open = FALSE;
|
||
__this_net->fbuf_fcnt = 0;
|
||
__this_net->fbuf_ffil = 0;
|
||
break;
|
||
case ACTION_VIDEO_CYC_SAVEFILE:
|
||
#if 0
|
||
video_cyc_file(0);
|
||
#if defined CONFIG_VIDEO1_ENABLE
|
||
video_cyc_file(1);
|
||
#endif
|
||
#if defined CONFIG_VIDEO2_ENABLE
|
||
video_cyc_file(2);
|
||
#endif
|
||
#endif
|
||
strcpy(buf, "status:1");
|
||
CTP_CMD_COMBINED(NULL, CTP_NO_ERR, "VIDEO_CYC_SAVEFILE", "NOTIFY", buf);
|
||
break;
|
||
}
|
||
break;
|
||
}
|
||
|
||
return err;
|
||
}
|
||
|
||
static void net_video_rec_ioctl(u32 argv)
|
||
{
|
||
char buf[128];
|
||
u32 *pargv = (u32 *)argv;
|
||
u32 type = (u32)pargv[0];
|
||
char *path = (char *)pargv[1];
|
||
|
||
/*printf("%s type : %d , %s \n\n", __func__, type, path);*/
|
||
switch (type) {
|
||
case NET_VIDREC_STA_STOP:
|
||
if (__this_net->net_state == VIDREC_STA_START || __this_net->net_state1 == VIDREC_STA_START \
|
||
|| __this_net->net_state_ch2 == VIDREC_STA_START || __this_net->net_state1_ch2 == VIDREC_STA_START) {
|
||
net_video_rec_stop(1);
|
||
}
|
||
/*if (__this_strm->state == VIDREC_STA_START || __this_strm->state_ch2 == VIDREC_STA_START) {*/
|
||
/*strm_video_rec_close(1);*/
|
||
/*}*/
|
||
__this_net->is_open = FALSE;
|
||
net_video_rec_free_buf();
|
||
break;
|
||
case NET_VIDREC_STATE_NOTIFY:
|
||
sprintf(buf, "status:%d", ((__this->state == VIDREC_STA_START) ? 1 : 0));
|
||
CTP_CMD_COMBINED(__this_net->priv, CTP_NO_ERR, "VIDEO_CTRL", "NOTIFY", buf);
|
||
break;
|
||
default :
|
||
return ;
|
||
}
|
||
}
|
||
|
||
static int net_video_rec_device_event_handler(struct device_event *dev)
|
||
{
|
||
int err;
|
||
struct intent it;
|
||
u8 *tpye;
|
||
|
||
if (!ASCII_StrCmp(dev->arg, "usb_host*", 9)) {
|
||
switch (dev->event) {
|
||
case DEVICE_EVENT_IN:
|
||
tpye = (u8 *)dev->value;
|
||
if (strstr(tpye, "uvc")) {
|
||
__this_net->uvc_id = tpye[3] - '0';
|
||
}
|
||
printf("UVC or msd_storage online %s, id=%d\n", tpye, __this_net->uvc_id);
|
||
break;
|
||
case DEVICE_EVENT_OUT:
|
||
tpye = (u8 *)dev->value;
|
||
if (strstr(tpye, "uvc")) {
|
||
__this_net->uvc_id = tpye[3] - '0';
|
||
}
|
||
printf("UVC or msd_storage offline %s, id=%d\n", tpye, __this_net->uvc_id);
|
||
if (__this && __this->state == VIDREC_STA_START) {
|
||
video_rec_control_doing();
|
||
}
|
||
net_video_rec_event_stop();
|
||
break;
|
||
}
|
||
} else if (!ASCII_StrCmp(dev->arg, "sd*", 4)) {
|
||
switch (dev->event) {
|
||
case DEVICE_EVENT_IN:
|
||
/* video_rec_sd_event_ctp_notify(1); */
|
||
/* extern int video_rec_sd_in(); */
|
||
video_rec_sd_in();
|
||
break;
|
||
case DEVICE_EVENT_OUT:
|
||
/* extern int video_rec_sd_out(); */
|
||
video_rec_sd_out();
|
||
/* video_rec_sd_event_ctp_notify(0); */
|
||
break;
|
||
}
|
||
} else if (!ASCII_StrCmp(dev->arg, "sys_power", 7)) {
|
||
switch (dev->event) {
|
||
case DEVICE_EVENT_POWER_CHARGER_IN:
|
||
puts("---charger in\n\n");
|
||
if ((__this && __this->state == VIDREC_STA_IDLE) ||
|
||
(__this && __this->state == VIDREC_STA_STOP)) {
|
||
video_rec_control_start();
|
||
}
|
||
break;
|
||
case DEVICE_EVENT_POWER_CHARGER_OUT:
|
||
puts("---charger out\n");
|
||
if (__this && __this->state == VIDREC_STA_START) {
|
||
video_rec_control_doing();
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
return 0;
|
||
}
|
||
static int net_video_key_event_handler(struct key_event *key)
|
||
{
|
||
int ret = 0;
|
||
static char state = 1;
|
||
|
||
switch (key->action) {
|
||
case KEY_EVENT_CLICK:
|
||
printf("KEY_EVENT_CLICK \n");
|
||
int cmd_video_rec_ctl(char start);
|
||
cmd_video_rec_ctl(state);
|
||
state = !state;
|
||
ret = true;
|
||
break;
|
||
case KEY_EVENT_LONG:
|
||
printf("KEY_EVENT_LONG \n");
|
||
int cmd_take_photo_ctl(char start);
|
||
cmd_take_photo_ctl(1);
|
||
ret = true;
|
||
break;
|
||
default:
|
||
break;
|
||
}
|
||
return ret;
|
||
}
|
||
int net_video_event_hander(void *e)
|
||
{
|
||
struct net_event *event = (struct net_event *)e;
|
||
struct ctp_arg *event_arg = (struct ctp_arg *)event->arg;
|
||
/* struct net_event *net = &event->u.net; */
|
||
|
||
switch (event->event) {
|
||
case NET_EVENT_CMD:
|
||
/*printf("IN NET_EVENT_CMD\n\n\n\n");*/
|
||
ctp_cmd_analysis(event_arg->topic, event_arg->content, event_arg->cli);
|
||
if (event_arg->content) {
|
||
free(event_arg->content);
|
||
}
|
||
event_arg->content = NULL;
|
||
if (event_arg) {
|
||
free(event_arg);
|
||
}
|
||
event_arg = NULL;
|
||
return true;
|
||
break;
|
||
case NET_EVENT_DATA:
|
||
/* printf("IN NET_EVENT_DATA\n"); */
|
||
break;
|
||
/* case NET_EVENT_SMP_CFG_FINISH: */
|
||
/* printf(">>>>>>>>>>>>>>>>>>NET_EVENT_SMP_CFG_FINISH"); */
|
||
/* config_network_stop(); */
|
||
/* config_network_connect(); */
|
||
/* break; */
|
||
}
|
||
return false;
|
||
}
|
||
static void net_video_server_task(void *p)
|
||
{
|
||
int res;
|
||
int msg[16];
|
||
|
||
if (os_mutex_create(&net_vdrec_mutex) != OS_NO_ERR) {
|
||
printf("net_video_server_task , os_mutex_create err !!!\n\n");
|
||
return;
|
||
}
|
||
net_video_handler_init();
|
||
printf("net_video_server_task running\n\n");
|
||
|
||
while (1) {
|
||
|
||
res = os_task_pend("taskq", msg, ARRAY_SIZE(msg));
|
||
if (os_task_del_req(OS_TASK_SELF) == OS_TASK_DEL_REQ) {
|
||
os_task_del_res(OS_TASK_SELF);
|
||
}
|
||
|
||
switch (res) {
|
||
case OS_TASKQ:
|
||
switch (msg[0]) {
|
||
case Q_EVENT:
|
||
break;
|
||
case Q_MSG:
|
||
net_video_rec_ioctl((u32)msg[1]);
|
||
break;
|
||
default:
|
||
break;
|
||
}
|
||
break;
|
||
case OS_TIMER:
|
||
break;
|
||
case OS_TIMEOUT:
|
||
break;
|
||
}
|
||
}
|
||
os_mutex_del(&net_vdrec_mutex, OS_DEL_ALWAYS);
|
||
}
|
||
|
||
void net_video_server_init(void)
|
||
{
|
||
task_create(net_video_server_task, 0, "net_video_server");
|
||
}
|
||
|
||
|
||
/*录像app的事件总入口*/
|
||
static int net_video_rec_event_handler(struct application *app, struct sys_event *event)
|
||
{
|
||
switch (event->type) {
|
||
case SYS_KEY_EVENT:
|
||
return net_video_key_event_handler((struct key_event *)event->payload);
|
||
case SYS_DEVICE_EVENT:
|
||
return net_video_rec_device_event_handler((struct device_event *)event->payload);
|
||
/*return video_rec_device_event_action((struct device_event *)event->payload);//录卡时:设备事件和 vidoe_rec公用一个handler，*/
|
||
case SYS_NET_EVENT:
|
||
net_video_event_hander((void *)event->payload);
|
||
return false;
|
||
default:
|
||
return false;
|
||
}
|
||
}
|
||
|
||
static const struct application_operation net_video_rec_ops = {
|
||
.state_machine = net_video_rec_state_machine,
|
||
.event_handler = net_video_rec_event_handler,
|
||
};
|
||
|
||
//REGISTER_APPLICATION(app_video_rec) = {
|
||
// .name = "net_video_rec",
|
||
// .ops = &net_video_rec_ops,
|
||
// .state = APP_STA_DESTROY,
|
||
//};
|
||
|
||
|