1019 lines
30 KiB
C
1019 lines
30 KiB
C
#include "packet.h"
|
||
#include "app_config.h"
|
||
#include "json_c/json.h"
|
||
#include "json_c/json_tokener.h"
|
||
|
||
#ifdef CONFIG_ENABLE_VLIST
|
||
|
||
int send_date_packet(struct __packet_info *pinfo, u32 msec);
|
||
|
||
int get_video_media_info(struct __packet_info *pinfo)
|
||
{
|
||
char buf[64];
|
||
u32 nlen = 0;
|
||
struct vfs_attr attr;
|
||
fget_attrs(pinfo->fd, &attr);
|
||
|
||
pinfo->time.tm_year = attr.crt_time.year;
|
||
pinfo->time.tm_mon = attr.crt_time.month;
|
||
pinfo->time.tm_mday = attr.crt_time.day;
|
||
pinfo->time.tm_hour = attr.crt_time.hour;
|
||
pinfo->time.tm_min = attr.crt_time.min;
|
||
pinfo->time.tm_sec = attr.crt_time.sec;
|
||
#if 0
|
||
printf("start=%d-%d-%d-%d-%d-%d\n"
|
||
, pinfo->time.tm_year
|
||
, pinfo->time.tm_mon
|
||
, pinfo->time.tm_mday
|
||
, pinfo->time.tm_hour
|
||
, pinfo->time.tm_min
|
||
, pinfo->time.tm_sec);
|
||
#endif
|
||
|
||
/*if (strstr(pinfo->file_name, get_rec_path_1())) {*/
|
||
/*fget_name(pinfo->fd, (u8 *)pinfo->file_name + strlen(get_rec_path_1()), 48);*/
|
||
/*} else if (strstr(pinfo->file_name, get_rec_path_2())) {*/
|
||
/*fget_name(pinfo->fd, (u8 *)pinfo->file_name + strlen(get_rec_path_2()), 48);*/
|
||
/*}*/
|
||
/*printf("pinfo->file_name=%s\n", pinfo->file_name); */
|
||
#ifdef CONFIG_NET_PKG_H264
|
||
read_time_scale_dur(pinfo->fd, &pinfo->info);
|
||
read_height_and_length(pinfo->fd, &pinfo->info);
|
||
read_stts(pinfo->fd, &pinfo->info);
|
||
pinfo->info.sample_rate = get_audio_sample_rate(pinfo->fd);
|
||
if (pinfo->info.sample_rate == -1) {
|
||
return -1;
|
||
}
|
||
if (is_has_audio(pinfo->fd)) {
|
||
u32 count = get_audio_sample_count(pinfo->fd);
|
||
if (count == -1) {
|
||
return -1;
|
||
}
|
||
|
||
pinfo->info.audio_chunk_num = get_audio_chunk_offset_entry(pinfo->fd);
|
||
if (pinfo->info.audio_chunk_num == -1) {
|
||
return -1;
|
||
}
|
||
pinfo->info.audio_block_size = (count * 2) / pinfo->info.audio_chunk_num;
|
||
/* printf("audio block size -> %d\n", pinfo->info.audio_block_size); */
|
||
/* printf("audio size -> %d\n", (count * 2) / pinfo->info.audio_chunk_num); */
|
||
pinfo->info.audio_stco_tab = get_audio_chunk_table(pinfo->fd, &pinfo->info);
|
||
if (pinfo->info.audio_stco_tab == NULL) {
|
||
return -1;
|
||
}
|
||
}
|
||
|
||
/* printf("weight:%d height :%d durition:%d \n", pinfo->info.length >> 16, pinfo->info.height >> 16, pinfo->info.durition / pinfo->info.scale); */
|
||
//get table
|
||
|
||
pinfo->info.stco_tab = get_chunk_index_table(pinfo->fd, &pinfo->info);
|
||
pinfo->info.stsz_tab = get_sample_index_table(pinfo->fd, &pinfo->info);
|
||
if (pinfo->info.stco_tab == NULL && pinfo->info.stsz_tab == NULL) {
|
||
printf(" pinfo->info.stco_tab == NULL\n\n");
|
||
return -1;
|
||
}
|
||
#endif
|
||
|
||
#ifdef CONFIG_NET_PKG_JPEG
|
||
pinfo->info.scale = 1;
|
||
pinfo->info.durition = avi_get_file_time(pinfo->fd, pinfo->state);
|
||
pinfo->info.sample_rate = avi_get_audio_sample_rate(pinfo->fd, pinfo->state);
|
||
pinfo->info.sample_duration = avi_get_fps(pinfo->fd, pinfo->state);
|
||
pinfo->info.video_sample_count = avi_get_video_chunk_num(pinfo->fd, pinfo->state);
|
||
pinfo->info.audio_chunk_num = avi_get_audio_chunk_num(pinfo->fd, pinfo->state);
|
||
avi_get_width_height(pinfo->fd, (void *)&pinfo->info, pinfo->state);
|
||
if (pinfo->info.sample_rate == -1) {
|
||
return -1;
|
||
}
|
||
#endif
|
||
|
||
return 0;
|
||
}
|
||
|
||
static int json_delet_backslash(char *str)
|
||
{
|
||
int len;
|
||
int i;
|
||
char tmp;
|
||
char *buff;
|
||
|
||
if (!str) {
|
||
return 0;
|
||
}
|
||
len = strlen(str);
|
||
if (!len) {
|
||
return 0;
|
||
}
|
||
|
||
buff = malloc(len + 1);
|
||
if (!buff) {
|
||
return 0;
|
||
}
|
||
memcpy(buff, str, len + 1);
|
||
for (i = 0; i < len; i++) {
|
||
tmp = buff[i];
|
||
if (tmp == '\\') {
|
||
memcpy(buff + i, buff + i + 1, len - i);
|
||
}
|
||
}
|
||
memset(str, '\0', len + 1);
|
||
memcpy(str, buff, len);
|
||
free(buff);
|
||
return len;
|
||
}
|
||
|
||
FILE *play_next(struct __packet_info *pinfo)
|
||
{
|
||
char name[64] = {0};
|
||
char tmp_name[64] = {0};
|
||
char *buf = NULL;
|
||
char *pbuf = NULL;
|
||
FILE *tmp_fd = NULL;
|
||
u8 invalid = 0;
|
||
|
||
|
||
json_object *new_obj;
|
||
json_object *list_obj;
|
||
json_object *array_obj;
|
||
json_object *f_obj;
|
||
json_object *t_obj;
|
||
char path[64] = {0};
|
||
char *pname = NULL;
|
||
FILE *fd = NULL;
|
||
int len;
|
||
int i = 0;
|
||
int pst = 0;
|
||
int cnt = 0;
|
||
int array_num = 0;
|
||
long long time;
|
||
long long lastfile_time = 0;
|
||
|
||
/************************************************************************************/
|
||
fget_name(pinfo->fd, (u8 *)name, sizeof(name));
|
||
fclose(pinfo->fd);
|
||
|
||
// FILE_GEN(NULL);
|
||
|
||
if (strstr(pinfo->file_name, get_rec_path_1())) {
|
||
sprintf(path, "%s%s", get_rec_path_1(), "vf_list.txt");
|
||
} else if (strstr(pinfo->file_name, get_rec_path_2())) {
|
||
sprintf(path, "%s%s", get_rec_path_2(), "vf_list.txt");
|
||
}
|
||
fd = fopen(path, "r");
|
||
if (!fd) {
|
||
return NULL;
|
||
}
|
||
len = flen(fd);
|
||
buf = malloc(len);
|
||
if (!buf) {
|
||
printf("no mem in video playback \n");
|
||
fclose(fd);
|
||
return NULL;
|
||
}
|
||
fread(buf, 1, len, fd);
|
||
fclose(fd);
|
||
|
||
new_obj = json_tokener_parse(buf);
|
||
if (!new_obj) {
|
||
free(buf);
|
||
return NULL;
|
||
}
|
||
|
||
list_obj = json_object_object_get(new_obj, "file_list");
|
||
if (!list_obj) {
|
||
json_object_put(new_obj);
|
||
free(buf);
|
||
return NULL;
|
||
}
|
||
array_num = json_object_array_length(list_obj);
|
||
printf("total_file_num : %d \n", array_num);
|
||
|
||
for (cnt = 0; cnt < 3; cnt++) {
|
||
for (i = pst ; i <= array_num; i++) {
|
||
array_obj = json_object_array_get_idx(list_obj, i);
|
||
if (array_obj) {
|
||
f_obj = json_object_object_get(array_obj, "f");
|
||
t_obj = json_object_object_get(array_obj, "t");
|
||
|
||
if (!cnt) {
|
||
if (!strstr(json_object_to_json_string(f_obj), name) || !t_obj) {
|
||
if (i >= array_num) {
|
||
goto exit;
|
||
}
|
||
continue;
|
||
}
|
||
/*printf("0file : %s \n",json_object_to_json_string(f_obj));*/
|
||
pbuf = json_object_to_json_string(t_obj) + 1;
|
||
lastfile_time = strtoll(pbuf, NULL, 10);
|
||
if (lastfile_time <= 0) {
|
||
continue;
|
||
}
|
||
pst = i;
|
||
break;
|
||
} else {
|
||
/*printf("1file : %s \n",json_object_to_json_string(f_obj));*/
|
||
#ifdef CONFIG_NET_PKG_H264
|
||
if ((!strstr(json_object_to_json_string(f_obj), ".MOV") && !strstr(json_object_to_json_string(f_obj), ".mov")) || !t_obj)
|
||
#endif
|
||
#ifdef CONFIG_NET_PKG_JPEG
|
||
if ((!strstr(json_object_to_json_string(f_obj), ".AVI") && !strstr(json_object_to_json_string(f_obj), ".avi")) || !t_obj)
|
||
#endif
|
||
{
|
||
continue;
|
||
}
|
||
|
||
pbuf = json_object_to_json_string(t_obj) + 1;
|
||
time = strtoll(pbuf, NULL, 10);
|
||
if (time > lastfile_time) {
|
||
pbuf = json_object_to_json_string(f_obj);
|
||
len = json_delet_backslash(pbuf);
|
||
if (!len) {
|
||
printf("len err \n");
|
||
goto exit;
|
||
}
|
||
len = strlen(pbuf);
|
||
memcpy(tmp_name, pbuf + 1, len - 2);
|
||
lastfile_time = time;
|
||
pname = tmp_name;
|
||
goto exit;
|
||
}
|
||
if (i >= (array_num - 1)) {
|
||
pst = 0;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
exit:
|
||
json_object_put(new_obj);
|
||
free(buf);
|
||
if (!pname) {
|
||
printf("no file !!\n");
|
||
return NULL;
|
||
}
|
||
tmp_fd = fopen(pname, "r");
|
||
if (!tmp_fd) {
|
||
printf("open file err !!!! %s\n", pname);
|
||
return NULL;
|
||
}
|
||
#ifdef CONFIG_NET_PKG_H264
|
||
if (!is_vaild_mov_file(tmp_fd)) {
|
||
puts("invalid mov file\n");
|
||
fclose(tmp_fd);
|
||
return NULL;
|
||
}
|
||
#endif
|
||
#ifdef CONFIG_NET_JPEG
|
||
avi_net_playback_unpkg_init(tmp_fd, pinfo->state);
|
||
if (!is_vaild_avi_file(tmp_fd, pinfo->state)) {
|
||
puts("invalid video file\n");
|
||
fclose(tmp_fd);
|
||
return NULL;
|
||
}
|
||
#endif
|
||
strcpy(pinfo->file_name, pname);
|
||
printf("play next file : %s\n", pinfo->file_name);
|
||
return tmp_fd;
|
||
|
||
/************************************************************************************/
|
||
#if 0
|
||
fget_name(pinfo->fd, (u8 *)name, sizeof(name));
|
||
#ifdef CONFIG_EMR_REC_DIR
|
||
if (strstr(pinfo->file_name, get_rec_path_1()) && strstr(pinfo->file_name, CONFIG_EMR_REC_DIR)) {
|
||
pinfo->fs = fscan(strcat(get_rec_path_1(), CONFIG_EMR_REC_DIR), "-tMOVAVI -st");
|
||
} else if (strstr(pinfo->file_name, get_rec_path_2()) && strstr(pinfo->file_name, CONFIG_EMR_REC_DIR)) {
|
||
pinfo->fs = fscan(strcat(get_rec_path_2(), CONFIG_EMR_REC_DIR), "-tMOVAVI -st");
|
||
} else
|
||
#endif
|
||
if (strstr(pinfo->file_name, get_rec_path_1())) {
|
||
pinfo->fs = fscan(get_rec_path_1(), "-tMOVAVI -st");
|
||
} else if (strstr(pinfo->file_name, get_rec_path_2())) {
|
||
pinfo->fs = fscan(get_rec_path_2(), "-tMOVAVI -st");
|
||
}
|
||
|
||
#ifdef CONFIG_NET_JPEG
|
||
avi_net_unpkg_exit(pinfo->fd, pinfo->state);
|
||
#endif
|
||
|
||
printf("netx video : name-> %s \n", name);
|
||
fclose(pinfo->fd);
|
||
|
||
while (1) {
|
||
if (tmp_fd == NULL) {
|
||
tmp_fd = fselect(pinfo->fs, FSEL_FIRST_FILE, 0);
|
||
} else {
|
||
tmp_fd = fselect(pinfo->fs, FSEL_NEXT_FILE, 0);
|
||
}
|
||
if (tmp_fd == NULL) {
|
||
break;
|
||
}
|
||
|
||
fget_name(tmp_fd, (u8 *)tmp_name, sizeof(tmp_name));
|
||
/*printf("tmp_name->%s name->%s\n", tmp_name, name);*/
|
||
if (!strcmp(tmp_name, name) && !invalid) {
|
||
if (tmp_fd != NULL) {
|
||
fclose(tmp_fd);
|
||
}
|
||
tmp_fd = fselect(pinfo->fs, FSEL_NEXT_FILE, 0);
|
||
if (tmp_fd == NULL) {
|
||
break;
|
||
}
|
||
#ifdef CONFIG_NET_PKG_H264
|
||
if (!is_vaild_mov_file(tmp_fd)) {
|
||
puts("invalid mov file\n");
|
||
invalid = 1;
|
||
fclose(tmp_fd);
|
||
continue;
|
||
}
|
||
#endif
|
||
#ifdef CONFIG_NET_JPEG
|
||
avi_net_playback_unpkg_init(tmp_fd, pinfo->state);
|
||
if (!is_vaild_avi_file(tmp_fd, pinfo->state)) {
|
||
puts("invalid video file\n");
|
||
invalid = 1;
|
||
fclose(tmp_fd);
|
||
continue;
|
||
}
|
||
#endif
|
||
break;
|
||
}
|
||
if (invalid) {
|
||
tmp_fd = fselect(pinfo->fs, FSEL_NEXT_FILE, 0);
|
||
if (tmp_fd == NULL) {
|
||
break;
|
||
} else {
|
||
fclose(tmp_fd);
|
||
}
|
||
#ifdef CONFIG_NET_PKG_H264
|
||
if (!is_vaild_mov_file(tmp_fd)) {
|
||
puts("invalid mov file\n");
|
||
invalid = 1;
|
||
fclose(tmp_fd);
|
||
continue;
|
||
}
|
||
#endif
|
||
#ifdef CONFIG_NET_JPEG
|
||
avi_net_playback_unpkg_init(tmp_fd, pinfo->state);
|
||
if (!is_vaild_avi_file(tmp_fd, pinfo->state)) {
|
||
puts("invalid video file\n");
|
||
invalid = 1;
|
||
fclose(tmp_fd);
|
||
continue;
|
||
}
|
||
#endif
|
||
break;
|
||
|
||
|
||
}
|
||
|
||
fclose(tmp_fd);
|
||
}
|
||
|
||
fget_name(tmp_fd, (u8 *)tmp_name, sizeof(tmp_name));
|
||
printf("play next file : %s\n", tmp_name);
|
||
fscan_release(pinfo->fs);
|
||
#endif
|
||
|
||
return tmp_fd;
|
||
|
||
}
|
||
FILE *play_prev(struct __packet_info *pinfo)
|
||
{
|
||
//#define CONFIG_REC_PATH_1 CONFIG_STORAGE_PATH"/C/DCIM/1/"
|
||
char name[32];
|
||
char tmp_name[32];
|
||
FILE *tmp_fd = NULL;
|
||
#ifdef CONFIG_NET_PKG_H264
|
||
u32 invalid = 0;
|
||
fget_name(pinfo->fd, (u8 *)name, 32);
|
||
if (strstr(pinfo->file_name, get_rec_path_1())) {
|
||
pinfo->fs = fscan(get_rec_path_1(), "-tMOV -st");
|
||
} else if (strstr(pinfo->file_name, get_rec_path_2())) {
|
||
pinfo->fs = fscan(get_rec_path_2(), "-tMOV -st");
|
||
}
|
||
|
||
fclose(pinfo->fd);
|
||
|
||
while (1) {
|
||
if (tmp_fd == NULL) {
|
||
tmp_fd = fselect(pinfo->fs, FSEL_LAST_FILE, 0);
|
||
} else {
|
||
tmp_fd = fselect(pinfo->fs, FSEL_PREV_FILE, 0);
|
||
}
|
||
|
||
|
||
if (tmp_fd == NULL) {
|
||
break;
|
||
}
|
||
|
||
fget_name(tmp_fd, (u8 *)tmp_name, 32);
|
||
/* printf("tmp_name -> %s \n", tmp_name); */
|
||
if (!strcmp(tmp_name, name) && !invalid) {
|
||
tmp_fd = fselect(pinfo->fs, FSEL_PREV_FILE, 0);
|
||
if (tmp_fd == NULL) {
|
||
break;
|
||
}
|
||
if (!is_vaild_mov_file(tmp_fd)) {
|
||
fclose(tmp_fd);
|
||
continue;
|
||
}
|
||
break;
|
||
}
|
||
|
||
if (invalid) {
|
||
tmp_fd = fselect(pinfo->fs, FSEL_NEXT_FILE, 0);
|
||
if (tmp_fd == NULL) {
|
||
break;
|
||
}
|
||
if (!is_vaild_mov_file(tmp_fd)) {
|
||
puts("invalid mov file\n");
|
||
|
||
invalid = 1;
|
||
continue;
|
||
}
|
||
break;
|
||
|
||
|
||
}
|
||
|
||
fclose(tmp_fd);
|
||
}
|
||
|
||
fscan_release(pinfo->fs);
|
||
#endif
|
||
return tmp_fd;
|
||
|
||
}
|
||
|
||
int send_video_packet(struct __packet_info *pinfo, u32 i)
|
||
{
|
||
int ret;
|
||
u32 tmp ;
|
||
char *buffer = NULL;
|
||
u32 tmp2;
|
||
u32 start_code = 0x01000000;
|
||
u32 send_len = 0;
|
||
int flen;
|
||
|
||
struct frm_head *frame_head = (struct frm_head *)pinfo->data;
|
||
memset(frame_head, 0, sizeof(struct frm_head));
|
||
|
||
#ifdef CONFIG_NET_PKG_H264
|
||
int sample_size = get_sample_size(pinfo->info.stsz_tab, i);
|
||
if (sample_size == -1) {
|
||
return -1;
|
||
}
|
||
int sample_offset = get_chunk_offset(pinfo->info.stco_tab, i);
|
||
if (sample_offset == -1) {
|
||
return -1;
|
||
}
|
||
if (sample_size > pinfo->len) {
|
||
printf("I frame size:0x%x offset:0x%x buffer size:%d\n", sample_size, sample_offset, pinfo->len);
|
||
ASSERT(!(sample_size > pinfo->len), "I frame is too large");
|
||
}
|
||
fseek(pinfo->fd, sample_offset, SEEK_SET);
|
||
|
||
frame_head->type = pinfo->type ;//| pinfo->fast_play_mask;
|
||
// frame_head->type = H264_TYPE_VIDEO;
|
||
frame_head->seq = i;
|
||
|
||
/* printf("video seq=%d\n", frame_head->seq); */
|
||
frame_head->timestamp = 90000 / (pinfo->info.scale / pinfo->info.sample_duration);
|
||
|
||
|
||
ret = fread(pinfo->fd, pinfo->data + sizeof(struct frm_head), sample_size);
|
||
if (ret <= 0) {
|
||
return ret;
|
||
}
|
||
frame_head->frm_sz = ret;
|
||
buffer = (char *)pinfo->data + sizeof(struct frm_head);
|
||
if (*((char *)(buffer + 4)) == 0x67) {
|
||
//处理PPS帧和SPS帧 I帧
|
||
memcpy(&tmp, buffer, 4);
|
||
tmp = htonl(tmp);
|
||
memcpy(buffer, &start_code, 4);
|
||
memcpy(&tmp2, buffer + tmp + 4, 4);
|
||
tmp2 = htonl(tmp2);
|
||
memcpy(buffer + tmp + 4, &start_code, 4);
|
||
memcpy(buffer + tmp + tmp2 + 8, &start_code, 4);
|
||
//printf("tmp %d tmp2 %d\n",tmp,tmp2);
|
||
//printf("&&&&&& video-I seq = %d\n",i);
|
||
} else {
|
||
// 处理P帧
|
||
memcpy(buffer, &start_code, 4);
|
||
}
|
||
ret = sock_send(pinfo->sock, (char *)pinfo->data, ret + sizeof(struct frm_head), 0);
|
||
return ret;
|
||
#endif
|
||
|
||
#ifdef CONFIG_NET_PKG_JPEG
|
||
/*frame_head->type = PREVIEW_TYPE;*/
|
||
frame_head->type = pinfo->type;// | pinfo->fast_play_mask;
|
||
frame_head->seq = i;
|
||
/* printf("video seq=%d\n", frame_head->seq); */
|
||
frame_head->timestamp = 90000 / avi_get_fps(pinfo->fd, pinfo->state);
|
||
|
||
#if 0
|
||
flen = avi_video_set_frame_addr(pinfo->fd, frame_head->seq + 1, pinfo->state);
|
||
if (flen <= 0) {
|
||
return flen;
|
||
}
|
||
frame_head->frm_sz = flen;
|
||
ret = sock_send(pinfo->sock, (char *)pinfo->data, sizeof(struct frm_head), 0);
|
||
if (ret <= 0) {
|
||
return ret;
|
||
}
|
||
|
||
while (flen > 0) {
|
||
ret = fread(pinfo->fd, pinfo->data, MIN(flen, IMAGE_SIZE));
|
||
if (ret <= 0) {
|
||
return ret;
|
||
}
|
||
flen -= ret;
|
||
ret = sock_send(pinfo->sock, (char *)pinfo->data, ret, 0);
|
||
if (ret <= 0) {
|
||
return ret;
|
||
}
|
||
send_len += ret;
|
||
}
|
||
return send_len;
|
||
#else
|
||
/*printf("get video frame...\n");*/
|
||
pinfo->data_len = pinfo->len - sizeof(struct frm_head);
|
||
flen = avi_video_get_frame(pinfo->fd, frame_head->seq + 1, pinfo->data + sizeof(struct frm_head), pinfo->data_len, pinfo->state);
|
||
if (flen <= 0) {
|
||
return flen;
|
||
}
|
||
if (!pinfo->state) {
|
||
printf("get video frame ok...\n");
|
||
}
|
||
frame_head->frm_sz = flen;
|
||
ret = sock_send(pinfo->sock, (char *)pinfo->data, flen + sizeof(struct frm_head), 0);
|
||
return ret;
|
||
#endif
|
||
#endif
|
||
|
||
return ret;
|
||
}
|
||
|
||
int send_audio_packet(struct __packet_info *pinfo, u32 j)
|
||
{
|
||
int ret;
|
||
static u32 tmp = 0;
|
||
static u32 tmp2 = 0;
|
||
struct frm_head *frame_head = (struct frm_head *)pinfo->data;
|
||
|
||
#ifdef CONFIG_NET_PKG_H264
|
||
int audio_offset = get_audio_chunk_offset(pinfo->info.audio_stco_tab, j);
|
||
if (audio_offset == -1) {
|
||
return -1;
|
||
}
|
||
if (false == fseek(pinfo->fd, audio_offset, SEEK_SET)) {
|
||
return -1;
|
||
}
|
||
|
||
tmp = frame_head->seq;
|
||
frame_head->type = PCM_TYPE_AUDIO;
|
||
frame_head->frm_sz = pinfo->info.audio_block_size;
|
||
ret = fread(pinfo->fd, pinfo->data + sizeof(struct frm_head), pinfo->info.audio_block_size);
|
||
if (ret <= 0) {
|
||
return ret;
|
||
}
|
||
ret = sock_send(pinfo->sock, (char *)pinfo->data, ret + sizeof(struct frm_head), 0);
|
||
tmp2++;
|
||
if (tmp2 == pinfo->info.audio_chunk_num) {
|
||
tmp = 0;
|
||
}
|
||
#endif
|
||
|
||
#ifdef CONFIG_NET_JPEG
|
||
pinfo->data_len = pinfo->len - sizeof(struct frm_head);
|
||
ret = avi_audio_get_frame(pinfo->fd, j + 1, pinfo->data + sizeof(struct frm_head), pinfo->data_len, pinfo->state);
|
||
if (ret <= 0) {
|
||
return ret;
|
||
}
|
||
pinfo->info.audio_block_size = ret;
|
||
frame_head->type = PCM_TYPE_AUDIO;
|
||
frame_head->frm_sz = pinfo->info.audio_block_size;
|
||
ret = sock_send(pinfo->sock, (char *)pinfo->data, ret + sizeof(struct frm_head), 0);
|
||
#endif
|
||
return ret;
|
||
}
|
||
|
||
void incr_date_time(struct tm *tm_time, int incr)
|
||
{
|
||
do {
|
||
if (incr >= 60) {
|
||
tm_time->tm_sec += 60;
|
||
incr -= 60;
|
||
} else {
|
||
tm_time->tm_sec += incr;
|
||
incr = 0;
|
||
}
|
||
|
||
if (tm_time->tm_sec > 59) {
|
||
tm_time->tm_sec -= 60;
|
||
tm_time->tm_min += 1;
|
||
|
||
if (tm_time->tm_min > 59) {
|
||
tm_time->tm_min -= 60;
|
||
tm_time->tm_hour += 1;
|
||
|
||
if (tm_time->tm_hour > 23) {
|
||
tm_time->tm_hour -= 24;
|
||
tm_time->tm_mday += 1;
|
||
|
||
if (tm_time->tm_mday > cal_days(tm_time->tm_year, tm_time->tm_mon)) {
|
||
tm_time->tm_mday = 1;
|
||
tm_time->tm_mon += 1;
|
||
|
||
if (tm_time->tm_mon > 12) {
|
||
tm_time->tm_mon = 1;
|
||
++tm_time->tm_year;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
} while (incr);
|
||
}
|
||
u32 conver_date_time(struct tm *tm_time)
|
||
{
|
||
u32 date_time;
|
||
|
||
date_time = tm_time->tm_sec;
|
||
date_time |= tm_time->tm_min << 6;
|
||
date_time |= tm_time->tm_hour << 12;
|
||
date_time |= tm_time->tm_mday << 17;
|
||
date_time |= tm_time->tm_mon << 22;
|
||
date_time |= (tm_time->tm_year - 2015) << 26;
|
||
|
||
return date_time;
|
||
}
|
||
|
||
int send_media_packet(struct __packet_info *pinfo)
|
||
{
|
||
/* puts("send_media_packet\n"); */
|
||
int ret = 0;
|
||
char name[32] = {0};
|
||
|
||
struct frm_head *frame_head = (struct frm_head *)pinfo->data;
|
||
memset(frame_head, 0, sizeof(struct frm_head) + sizeof(struct media_info));
|
||
//send media info packet
|
||
frame_head->type = MEDIA_INFO_TYPE;
|
||
frame_head->seq = 0;
|
||
|
||
|
||
struct media_info *media = (struct media_info *)(pinfo->data + sizeof(struct frm_head));
|
||
#ifdef CONFIG_NET_PKG_H264
|
||
media->length = pinfo->info.length >> 16;
|
||
media->height = pinfo->info.height >> 16;
|
||
media->fps = pinfo->info.scale / pinfo->info.sample_duration;
|
||
#endif
|
||
#ifdef CONFIG_NET_PKG_JPEG
|
||
media->length = pinfo->info.length;
|
||
media->height = pinfo->info.height;
|
||
media->fps = pinfo->info.sample_duration;
|
||
#endif
|
||
media->audio_rate = pinfo->info.sample_rate;
|
||
|
||
media->dur_time = pinfo->info.durition / pinfo->info.scale;
|
||
|
||
|
||
/* printf("fps = %d\n",media->fps); */
|
||
|
||
/*printf("=====media->dur_time=%d\n", media->dur_time);*/
|
||
strcpy(media->filename, pinfo->file_name);
|
||
/* strcpy(pinfo->data + sizeof(struct frm_head) + sizeof(struct media_info),pinfo->file_name); */
|
||
size_t len = sizeof(struct frm_head) + sizeof(struct media_info) + strlen(pinfo->file_name);
|
||
frame_head->frm_sz = len - sizeof(struct frm_head);
|
||
|
||
ret = sock_send(pinfo->sock, (char *)pinfo->data, len, 0);
|
||
if (ret <= 0) {
|
||
return ret;
|
||
}
|
||
ret = send_date_packet(pinfo, 0);//发送起始时间包
|
||
return ret;
|
||
}
|
||
int send_date_packet(struct __packet_info *pinfo, u32 msec)
|
||
{
|
||
int ret = 0;
|
||
u32 date = 0;
|
||
struct tm tm_time;
|
||
#if (defined CONFIG_NET_PKG_H264 || defined CONFIG_NET_PKG_JPEG)
|
||
struct frm_head *frame_head = (struct frm_head *)pinfo->data;
|
||
frame_head->type = DATE_TIME_TYPE;
|
||
frame_head->frm_sz = 4;
|
||
incr_date_time(&pinfo->time, msec);
|
||
date = conver_date_time(&pinfo->time);
|
||
|
||
if (!msec) {
|
||
printf("file start timer : %d-%d-%d-%d-%d-%d\n"
|
||
, pinfo->time.tm_year
|
||
, pinfo->time.tm_mon
|
||
, pinfo->time.tm_mday
|
||
, pinfo->time.tm_hour
|
||
, pinfo->time.tm_min
|
||
, pinfo->time.tm_sec);
|
||
} else {
|
||
#if 1
|
||
printf("xdt=%d-%d-%d-%d-%d-%d\n"
|
||
, pinfo->time.tm_year
|
||
, pinfo->time.tm_mon
|
||
, pinfo->time.tm_mday
|
||
, pinfo->time.tm_hour
|
||
, pinfo->time.tm_min
|
||
, pinfo->time.tm_sec);
|
||
#endif
|
||
}
|
||
|
||
memcpy(pinfo->data + sizeof(struct frm_head), &date, frame_head->frm_sz);
|
||
|
||
ret = sock_send(pinfo->sock, (char *)pinfo->data, sizeof(struct frm_head) + 4, 0);
|
||
#endif
|
||
return ret;
|
||
}
|
||
int send_end_packet(struct __packet_info *pinfo)
|
||
{
|
||
puts("send_end_packet\n");
|
||
int ret = 0;
|
||
struct frm_head *frame_head = (struct frm_head *)pinfo->data;
|
||
memset(frame_head, 0, sizeof(struct frm_head));
|
||
#if (defined CONFIG_NET_PKG_H264 || defined CONFIG_NET_PKG_JPEG)
|
||
|
||
if (pinfo->fd == NULL) {
|
||
puts("PLAY_OVER_TYPE | LAST_FREG_MAKER\n");
|
||
frame_head->type = (PLAY_OVER_TYPE | LAST_FREG_MAKER);
|
||
} else {
|
||
|
||
puts("PLAY_OVER_TYPE\n");
|
||
frame_head->type = PLAY_OVER_TYPE;
|
||
}
|
||
|
||
ret = sock_send(pinfo->sock, (char *)pinfo->data, sizeof(struct frm_head), 0);
|
||
#endif
|
||
return ret;
|
||
|
||
}
|
||
int update_data(struct __packet_info *pinfo)
|
||
{
|
||
|
||
if (pinfo->info.stco_tab != NULL) {
|
||
free(pinfo->info.stco_tab);
|
||
pinfo->info.stco_tab = NULL;
|
||
}
|
||
|
||
if (pinfo->info.stsz_tab != NULL) {
|
||
free(pinfo->info.stsz_tab);
|
||
pinfo->info.stsz_tab = NULL;
|
||
}
|
||
|
||
if (pinfo->info.audio_stco_tab != NULL) {
|
||
free(pinfo->info.audio_stco_tab);
|
||
pinfo->info.audio_stco_tab = NULL;
|
||
}
|
||
#if 0
|
||
if (pinfo->fd != NULL) {
|
||
fclose(pinfo->fd);
|
||
pinfo->fd = NULL;
|
||
|
||
}
|
||
#endif
|
||
|
||
return get_video_media_info(pinfo);
|
||
}
|
||
|
||
|
||
|
||
#if 0
|
||
/*********************************GPS*************************************/
|
||
#define MOV_GPS_BUF_LEN 60*10*512
|
||
#define MOV_FILE_GPS_HEAD_ADDR 0X70
|
||
static int gps_data_addr = 0;//GPS文件地址
|
||
static int gps_data_len = 0;//GPS数据长度
|
||
static short gps_packet_seq = 0;//GPS数据包SEQ
|
||
static u8 *gps_data_buf = NULL;//RAM GPS数据地址
|
||
static int last_sec = 0; //用在快进
|
||
#define GPS_ERROR() {printf("\nerror : func : %s line %d \n\n",__func__,__LINE__);return -1;}
|
||
|
||
static int gps_get_data(char *src, int src_len, char *buf, int buf_len)
|
||
{
|
||
static int addr = 0;
|
||
int len = 0;
|
||
char *pstart, *pend, *pbuf;
|
||
addr = gps_data_addr;
|
||
if (addr >= src_len) {
|
||
addr = 0;
|
||
return -1;
|
||
}
|
||
pend = src + addr;
|
||
pstart = strstr(pend, "$GPRMC");
|
||
if (pstart) {
|
||
pend = strstr(pstart, "\r\n");
|
||
if (pend) {
|
||
pbuf = strstr(pend, "$GPGGA");
|
||
if (pbuf) {
|
||
pbuf = strstr(pbuf + strlen("\r\n"), "\r\n");
|
||
}
|
||
if (pbuf) {
|
||
pend = pbuf;
|
||
}
|
||
len = pend - pstart + strlen("\r\n");
|
||
|
||
pbuf = strstr(pend, "$GPGSA");
|
||
if (pbuf) {
|
||
pbuf = strstr(pbuf + strlen("\r\n"), "\r\n");
|
||
}
|
||
if (pbuf) {
|
||
pend = pbuf;
|
||
}
|
||
len = pend - pstart + strlen("\r\n");
|
||
if (buf_len < len) {
|
||
len = 0;
|
||
goto exit;
|
||
}
|
||
memcpy(buf, pstart, len);
|
||
}
|
||
}
|
||
exit:
|
||
return len;
|
||
}
|
||
|
||
static int send_no_gps_media(struct __packet_info *pinfo)
|
||
{
|
||
int ret = 0;
|
||
int len = 0;
|
||
char buf[32] = "NO GPS DATA\r\n";
|
||
struct frm_head *frame_head = (struct frm_head *)pinfo->data;
|
||
|
||
len = strlen(buf);
|
||
frame_head->type = NO_GPS_DATA_TYPE;
|
||
frame_head->frm_sz = len;
|
||
frame_head->seq = 0;
|
||
memcpy(pinfo->data + sizeof(struct frm_head), buf, len);
|
||
printf("%s\n", buf);
|
||
|
||
ret = sock_send(pinfo->sock, pinfo->data, sizeof(struct frm_head) + len, 0);
|
||
if (ret != sizeof(struct frm_head) + len) {
|
||
printf("gps media send err!!!\n\n");
|
||
return ret;
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
//data_len:<0无数据，>0有数据
|
||
static int send_gps_media(struct __packet_info *pinfo, int data_len)
|
||
{
|
||
int ret = 0;
|
||
int len = 0;
|
||
char buf[32] = "GPS DATA\r\n";
|
||
struct frm_head *frame_head = (struct frm_head *)pinfo->data;
|
||
|
||
if (data_len > 0) {
|
||
len = strlen(buf);
|
||
frame_head->type = GPS_INFO_TYPE;
|
||
frame_head->frm_sz = len;
|
||
frame_head->seq = 0;
|
||
memcpy(pinfo->data + sizeof(struct frm_head), buf, len);
|
||
ret = sock_send(pinfo->sock, pinfo->data, sizeof(struct frm_head) + len, 0);
|
||
if (ret != sizeof(struct frm_head) + len) {
|
||
printf("gps media send err!!!\n\n");
|
||
return ret;
|
||
}
|
||
} else {
|
||
frame_head->type = GPS_INFO_TYPE;
|
||
frame_head->frm_sz = 0;
|
||
frame_head->seq = 0;
|
||
ret = sock_send(pinfo->sock, pinfo->data, sizeof(struct frm_head), 0);
|
||
if (ret != sizeof(struct frm_head)) {
|
||
printf("gps media send err!!!\n\n");
|
||
return ret;
|
||
}
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
int find_gps_data(struct __packet_info *pinfo)
|
||
{
|
||
int current_addr;
|
||
int err;
|
||
last_sec = 0;
|
||
if (pinfo->fd == NULL) {
|
||
GPS_ERROR();
|
||
}
|
||
if (fseek(pinfo->fd, MOV_FILE_GPS_HEAD_ADDR, SEEK_SET) == FALSE) {
|
||
GPS_ERROR();
|
||
}
|
||
if (fread(pinfo->fd, &gps_data_addr, sizeof(gps_data_addr)) != sizeof(gps_data_addr)) {
|
||
GPS_ERROR();
|
||
}
|
||
gps_data_addr = ntohl(gps_data_addr);
|
||
if (gps_data_addr == 0) {
|
||
fseek(pinfo->fd, 0, SEEK_SET);
|
||
send_no_gps_media(pinfo);
|
||
return -1;
|
||
}
|
||
if (fseek(pinfo->fd, gps_data_addr, SEEK_SET) == FALSE) {
|
||
GPS_ERROR();
|
||
}
|
||
if (fread(pinfo->fd, &gps_data_len, sizeof(gps_data_len)) != sizeof(gps_data_len)) {
|
||
GPS_ERROR();
|
||
}
|
||
gps_data_len = ntohl(gps_data_len);
|
||
if (gps_data_len == 0) {
|
||
fseek(pinfo->fd, 0, SEEK_SET);
|
||
send_no_gps_media(pinfo);
|
||
return -1;
|
||
}
|
||
if (gps_data_buf == NULL) {
|
||
gps_data_buf = malloc(MOV_GPS_BUF_LEN);
|
||
if (!gps_data_buf) {
|
||
fseek(pinfo->fd, 0, SEEK_SET);
|
||
GPS_ERROR();
|
||
}
|
||
memset(gps_data_buf, 0, MOV_GPS_BUF_LEN);
|
||
} else {
|
||
memset(gps_data_buf, 0, MOV_GPS_BUF_LEN);
|
||
}
|
||
err = fread(pinfo->fd, gps_data_buf, gps_data_len);
|
||
if (err != gps_data_len) {
|
||
fseek(pinfo->fd, 0, SEEK_SET);
|
||
GPS_ERROR();
|
||
}
|
||
gps_data_addr = 0;
|
||
gps_packet_seq = 0;
|
||
if (fseek(pinfo->fd, 0, SEEK_SET) == FALSE) {
|
||
GPS_ERROR();
|
||
}
|
||
printf("MOV GPS data find succes\n\n");
|
||
return 0;
|
||
}
|
||
|
||
|
||
int send_gps_data_packet(struct __packet_info *pinfo)
|
||
{
|
||
int ret;
|
||
int i;
|
||
int len;
|
||
int current_addr;
|
||
int timer;
|
||
char fast_mode;
|
||
char send_buf[512] = {0};
|
||
struct frm_head *frame_head = (struct frm_head *)pinfo->data;
|
||
|
||
if (frame_head == NULL || gps_data_len == 0) {
|
||
/*printf("gps head or data len 0 !!!\n\n");*/
|
||
return -1;
|
||
}
|
||
timer = pinfo->time.tm_hour * 3600 + pinfo->time.tm_min * 60 + pinfo->time.tm_sec;
|
||
if (!last_sec) {
|
||
fast_mode = 1;
|
||
last_sec = timer;
|
||
} else {
|
||
fast_mode = timer - last_sec;
|
||
last_sec = timer;
|
||
}
|
||
for (; fast_mode >= 1; fast_mode--) {
|
||
len = gps_get_data(gps_data_buf, gps_data_len, send_buf, sizeof(send_buf));
|
||
if (len <= 0) {
|
||
if (len < 0) {
|
||
printf("GPS data read end \n");
|
||
} else {
|
||
printf("GPS data read err \n");
|
||
}
|
||
return -1;
|
||
}
|
||
gps_data_addr += len;
|
||
gps_packet_seq++;
|
||
frame_head->type = GPS_INFO_TYPE;
|
||
frame_head->frm_sz = len;
|
||
frame_head->seq = gps_packet_seq;
|
||
|
||
memcpy(pinfo->data + sizeof(struct frm_head), send_buf, len);
|
||
ret = sock_send(pinfo->sock, pinfo->data, sizeof(struct frm_head) + len, 0);
|
||
if (ret != (sizeof(struct frm_head) + len)) {
|
||
printf("gps data send err !!!\n\n");
|
||
return ret;
|
||
}
|
||
}
|
||
printf("MOV GPS data send succes , len : %d \n\n", len);
|
||
return ret;
|
||
}
|
||
|
||
int unfind_gps_data(void)
|
||
{
|
||
if (gps_data_buf != NULL) {
|
||
free(gps_data_buf);
|
||
}
|
||
gps_data_buf = NULL;
|
||
gps_data_len = 0;
|
||
gps_data_addr = 0;
|
||
gps_packet_seq = 0;
|
||
return 0;
|
||
}
|
||
/******************************************************************/
|
||
#endif
|
||
|
||
#endif
|
||
|