zouhaitao/TAIXIN
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
e76462eeb7733d4fca46c92e4b9c1b5d99fc049a
TAIXIN/sdk/app/video_app/video_app_h264_msi.c

1429 lines
44 KiB
C
Raw Normal View History

Initial commit: TXW82x FPV v2.7.0.7-42229 SDK + project sources
2026-07-06 11:30:13 +08:00
#include "basic_include.h"
#include "lib/multimedia/msi.h"
#include "stream_define.h"
#include "lib/video/h264/h264_drv.h"
#include "osal/work.h"
#include "lib/video/dvp/jpeg/jpg.h"
#include "hal/h264.h"
#include "lib/heap/av_heap.h"
#include "lib/heap/av_psram_heap.h"
#include "lib/heap/av_heap.h"
#include "lib/heap/av_psram_heap.h"
#include "gen420_hardware_msi.h"
#include "user_work/user_work.h"
#include "hal/scale.h"
extern uint32 get_h264_srcID(void *d);
extern uint8_t get_vpp_w_h(uint16_t *w, uint16_t *h);
extern uint8_t get_vpp1_w_h(uint16_t *w, uint16_t *h);
extern uint32 get_h264_w_h(void *d, uint16_t *w, uint16_t *h);
extern uint8_t get_vpp_scale_w_h(uint16_t *w, uint16_t *h);
extern void set_vpp_scale_w_h(uint8_t en, uint16_t w, uint16_t h);
#ifndef SAVE_COUNT
#define SAVE_COUNT 4
#endif
#define USE_WORK 1
#define MAX_BYTES 0
#if VIDEO_YUV_RANGE_TYPE
#undef MAX_BYTES
#define MAX_BITS 160
#define MAX_BYTES (MAX_BITS / 8)
// 位缓冲区结构体
typedef struct
{
uint8_t data[MAX_BYTES]; // 存储数据的字节数组
int current_bit_pos; // 当前位位置（0-127）
} BitBuffer;
// 初始化位缓冲区
void bit_buffer_init(BitBuffer *buffer)
{
// memset(buffer->data, 0, sizeof(buffer->data));
buffer->current_bit_pos = 0;
}
// 设置位缓冲区
void bit_buffer_set(BitBuffer *buffer, uint8_t data)
{
buffer->data[buffer->current_bit_pos / 8] = data;
buffer->current_bit_pos += 8;
}
// 二进制bit左移拼接函数
// 输入：buffer - 位缓冲区指针
// bits - 要添加的二进制数据（最多16位）
// bit_count - 二进制位数（1-16）
// padding - 是否补零到8的倍数（1:是，0:否）
// 返回值：成功添加的位数
int bit_buffer_append(BitBuffer *buffer, uint16_t bits, int bit_count, int padding)
{
if (bit_count < 1 || bit_count > 16)
{
os_printf(KERN_ERR "err:bit_count must 1-16\n");
return 0;
}
if (buffer->current_bit_pos + bit_count > MAX_BITS)
{
printf(KERN_ERR "warning:buff full\n");
bit_count = MAX_BITS - buffer->current_bit_pos;
if (bit_count <= 0)
{
return 0;
}
}
// 确保只取bit_count位
bits &= (1 << bit_count) - 1;
// 逐个bit添加
for (int i = bit_count - 1; i >= 0; i--)
{
int current_byte = buffer->current_bit_pos / 8;
int current_bit_in_byte = 7 - (buffer->current_bit_pos % 8); // 从高位到低位
// 获取当前bit的值
uint8_t bit_value = (bits >> i) & 1;
// 设置对应的bit位
if (bit_value)
{
buffer->data[current_byte] |= (1 << current_bit_in_byte);
}
else
{
buffer->data[current_byte] &= ~(1 << current_bit_in_byte);
}
buffer->current_bit_pos++;
}
// 如果需要补零到8的倍数
if (padding)
{
int remainder = buffer->current_bit_pos % 8;
if (remainder != 0)
{
int bits_to_pad = 8 - remainder;
if (buffer->current_bit_pos + bits_to_pad > MAX_BITS)
{
// printf("warning:buff full when fill zero\n");
bits_to_pad = MAX_BITS - buffer->current_bit_pos;
}
for (int i = 0; i < bits_to_pad; i++)
{
int current_byte = buffer->current_bit_pos / 8;
int current_bit_in_byte = 7 - (buffer->current_bit_pos % 8);
// 补零
buffer->data[current_byte] &= ~(1 << current_bit_in_byte);
buffer->current_bit_pos++;
}
// printf("fill zero %d bit,make byte align\n", bits_to_pad);
}
}
return bit_count;
}
// 打印缓冲区内容（十六进制格式）
void bit_buffer_print_hex(const BitBuffer *buffer)
{
int bytes_used = (buffer->current_bit_pos + 7) / 8;
for (int i = 0; i < bytes_used; i++)
{
os_printf("buff[%02d]:%02x\n", i, buffer->data[i]);
}
}
// 获取当前已使用的字节数
int bit_buffer_get_used_bytes(const BitBuffer *buffer)
{
return (buffer->current_bit_pos + 7) / 8;
}
// 指数哥伦布编码
uint8_t len_exp = 0;
uint8_t len_pre = 0;
uint8_t len_suf = 0;
uint16 exp_out = 0;
void ue_se_enc(uint16 in_data)
{
len_exp = 0;
len_pre = 0;
len_suf = 0;
exp_out = 0;
if ((in_data & 0x1e0) != 0)
{
if ((in_data & 0x100) != 0)
{
len_exp = 14;
len_pre = 7;
len_suf = 8;
}
else if ((in_data & 0x080) != 0)
{
len_exp = 14;
len_pre = 6;
len_suf = 7;
}
else if ((in_data & 0x040) != 0)
{
len_exp = 12;
len_pre = 5;
len_suf = 6;
}
else
{
len_exp = 10;
len_pre = 4;
len_suf = 5;
}
}
else
{
if ((in_data & 0x010) != 0)
{
len_exp = 8;
len_pre = 3;
len_suf = 4;
}
else if ((in_data & 0x008) != 0)
{
len_exp = 6;
len_pre = 2;
len_suf = 3;
}
else if ((in_data & 0x004) != 0)
{
len_exp = 4;
len_pre = 1;
len_suf = 2;
}
else if ((in_data & 0x002) != 0)
{
len_exp = 2;
len_pre = 0;
len_suf = 1;
}
else
{
len_exp = 0;
len_pre = 0;
len_suf = 1;
}
}
len_exp += 1;
len_pre += 1;
len_suf += 1;
exp_out = (in_data & 0x1ff);
}
// main 1920 1080
void h264_sps_gen_test(BitBuffer *buffer, uint16_t wrap_w, uint16_t wrap_h, uint8_t fr)
{
uint8_t level_idc = 52; // h264 0x50
uint16 img_x = wrap_w / 16;
uint16 img_y = (wrap_h + 0xf) / 16;
uint8_t crop_en = 0;
uint8_t crop_y = (img_y * 16 - wrap_h) / 2;
uint8_t full_range = fr;
if (crop_y)
{
crop_en = 1;
}
bit_buffer_init(buffer);
// fixed
bit_buffer_set(buffer, 0x00);
bit_buffer_set(buffer, 0x00);
bit_buffer_set(buffer, 0x00);
bit_buffer_set(buffer, 0x01);
bit_buffer_set(buffer, 0x67);
bit_buffer_set(buffer, 0x4d);
bit_buffer_set(buffer, 0x00);
bit_buffer_set(buffer, level_idc);
bit_buffer_set(buffer, 0x96);
bit_buffer_set(buffer, 0x54);
// img width
ue_se_enc(img_x);
bit_buffer_append(buffer, 0x0000, len_pre, 0);
bit_buffer_append(buffer, exp_out, len_suf, 0);
// img height
ue_se_enc(img_y);
bit_buffer_append(buffer, 0x0000, len_pre, 0);
bit_buffer_append(buffer, exp_out, len_suf, 0);
// other
bit_buffer_append(buffer, 0x0003, 2, 0);
// img crop
if (crop_en)
{
bit_buffer_append(buffer, 0x000f, 4, 0);
ue_se_enc((crop_y + 1));
bit_buffer_append(buffer, exp_out, len_exp, 0);
}
else
{
bit_buffer_append(buffer, 0x0000, 1, 0);
}
// full range
if (full_range)
{
bit_buffer_append(buffer, 0x4880, 15, 0);
}
else
{
bit_buffer_append(buffer, 0x0000, 1, 0);
}
// byte align
bit_buffer_append(buffer, 0x0001, 1, 1);
// bit_buffer_print_hex(buffer);
}
#endif
enum video_app_h264_enum
{
VIDEO_APP_H264_EXIT = BIT(0),
VIDEO_APP_H264_STOP = BIT(1),
};
// data申请空间函数
#define STREAM_MALLOC av_psram_malloc
#define STREAM_FREE av_psram_free
#define STREAM_ZALLOC av_psram_zalloc
// 结构体申请空间函数
#ifdef MORE_SRAM
#define STREAM_LIBC_MALLOC av_psram_malloc
#define STREAM_LIBC_FREE av_psram_free
#define STREAM_LIBC_ZALLOC av_psram_zalloc
#else
#define STREAM_LIBC_MALLOC av_malloc
#define STREAM_LIBC_FREE av_free
#define STREAM_LIBC_ZALLOC av_zalloc
#endif
#define MAX_VIDEO_APP_264 64
// 获取nal的size,从0开始搜索,返回的是的nal头的size,offset相对于头的偏移(通过多次调用,可以用于计算nal_size)
// 返回0代表搜索不到nal的头
static uint8_t get_nal_size(uint8_t *buf, uint32_t size, uint32_t *offset)
{
uint32_t pos = 0;
while ((size - pos) > 3)
{
if (buf[pos] == 0 && buf[pos + 1] == 0 && buf[pos + 2] == 1)
{
*offset = pos;
return 3;
}
if (buf[pos] == 0 && buf[pos + 1] == 0 && buf[pos + 2] == 0 && buf[pos + 3] == 1)
{
*offset = pos;
return 4;
}
pos++;
}
return 0;
}
// 只是获取pps和sps的nalsize
static uint8_t *get_sps_pps_nal_size(uint8_t *buf, uint32_t size, uint32_t *nal_size, uint8_t *head_size)
{
uint32_t offset;
uint8_t nal_head_size = get_nal_size(buf, size, &offset);
uint8_t nal_type;
uint8_t *ret_buf = NULL;
// 找到头部,检查类型
if (nal_head_size && offset + nal_head_size < size)
{
nal_type = buf[nal_head_size + offset] & 0x1f;
// 找到sps和pps就返回长度和偏移(相对buf的偏移)
if (nal_type == 7 || nal_type == 8)
{
// 查找下一个nal
nal_head_size = get_nal_size(buf + offset + nal_head_size, size - (offset + nal_head_size), nal_size);
// os_printf("nal_head_size:%d\tnal_size:%d\n",nal_head_size,*nal_size);
if (nal_head_size)
{
// 偏移到nal的头部
ret_buf = buf + offset;
// 返回nal的头size
*head_size = nal_head_size;
}
}
}
return ret_buf;
}
uint8_t *skip_sps(uint8_t *next_nal_buf, uint32_t size, uint32_t *skip_size)
{
uint8_t sps_times = 0;
uint8_t nal_head_size;
uint32_t nal_size;
uint8_t pps_sps_size = 0;
uint8_t *sps_pps_buf = NULL;
while (sps_times < 1)
{
sps_pps_buf = get_sps_pps_nal_size(next_nal_buf, 64, &nal_size, &nal_head_size);
if (sps_pps_buf && (sps_pps_buf[nal_head_size] & 0x1f) == 7)
{
pps_sps_size += (nal_size + nal_head_size);
next_nal_buf = sps_pps_buf + nal_size + nal_head_size;
}
// 不匹配,就不再去获取pps或者sps了
else
{
break;
}
// os_printf("sps_pps_buf[nal_head_size]& 0x1f):%d\n",sps_pps_buf[nal_head_size]& 0x1f);
sps_times++;
}
if (skip_size)
{
*skip_size = pps_sps_size;
}
return next_nal_buf;
}
#if USE_WORK == 0
struct video_h264_msi_s
{
// struct os_work work;
struct os_task task;
struct os_event evt;
struct msi *msi;
struct h264_device *h264_dev;
uint16_t filter_type;
uint16_t sub_stream_en;
struct fbpool tx_pool;
};
/********************************************************************************************
* I帧和P帧对应的位置图,主要通过寻找nal,定位pps和sps的起始位置并且记录
* 实际内容也会记录,到终端可以采取是否直接读取结构体的pps和sps(尽量从结构体读取)
*
*
* 00 00 00 01 67 xx xx xx 00 00 00 01 68 xx xx xx 00 00 00 01 65 xx xx xx I帧
* sps_buf pps_buf start_len
*
*
*
*
*
* 00 00 00 01 61 xx xx xx P帧
* start_len
*******************************************************************************************/
static int8_t h264_output_msi(struct list_head *get_f, struct video_h264_msi_s *video_h264)
{
int ret = RET_ERR;
uint32_t node_len;
uint32_t h264_len;
uint32_t h264_len_tmp;
uint32_t cp_len;
uint32_t cp_offset;
uint8_t *tmp_buf;
uint32_t timestamp;
uint8_t which;
uint8_t srcID;
uint8_t h264_type_frame;
node_len = get_h264_node_len_new((void *) get_f);
h264_len = get_h264_len(get_f);
timestamp = get_h264_timestamp(get_f);
h264_type_frame = get_h264_type(get_f); // 获取是否为I帧还是P帧
which = get_h264_which(get_f);
srcID = get_h264_srcID(get_f);
uint8_t count = get_h264_loop_num(get_f);
struct framebuff *fb = NULL;
if (!h264_len)
{
goto h264_output_msi_end;
}
fb = fbpool_get(&video_h264->tx_pool, 0, video_h264->msi);
if (fb)
{
// 先去msi寻找是否有空闲节点,如果有,才需要拷贝,否则就丢弃
uint8_t *h264_buf = (uint8_t *) STREAM_MALLOC(h264_len + SAVE_COUNT);
if (!h264_buf)
{
msi_delete_fb(NULL, fb);
goto h264_output_msi_end;
}
// 拷贝264的数据
h264_len_tmp = h264_len;
cp_offset = 0;
while (h264_buf)
{
// 图片节点提取
if (list_empty(get_f) || h264_len_tmp == 0)
{
break;
}
if (h264_len_tmp > node_len)
{
cp_len = node_len;
}
else
{
cp_len = h264_len_tmp;
}
h264_len_tmp -= cp_len;
tmp_buf = get_h264_first_buf(get_f);
hw_memcpy0(h264_buf + cp_offset, get_h264_first_buf(get_f), cp_len);
del_h264_first_node(get_f);
cp_offset += cp_len;
}
// 264末尾加一个序号
if (SAVE_COUNT > 0)
{
os_sprintf(h264_buf + h264_len, "%03d", count & 0xff);
h264_buf[h264_len + 3] = '#';
}
sys_dcache_clean_range((uint32_t *) h264_buf, h264_len + SAVE_COUNT);
fb->data = (uint8_t *) h264_buf;
fb->len = h264_len + SAVE_COUNT;
fb->mtype = F_H264;
fb->stype = which + FSTYPE_H264_VPP_DATA0; // 基于stype某个值
fb->time = timestamp;
fb->srcID = srcID;
// I帧
if (h264_type_frame == 1)
{
// 先去读取sps和pps的长度
uint8_t nal_head_size;
uint32_t nal_size;
uint8_t *sps_pps_buf = fb->data;
uint8_t *pps_buf = NULL;
uint8_t *sps_buf = NULL;
uint8_t pps_len = 0, sps_len = 0;
uint8_t pps_sps_times = 0;
uint8_t *next_nal_buf = fb->data;
// 读取sps和pps,仅仅读取两次,没有就退出
while (sps_pps_buf && pps_sps_times < 2)
{
sps_pps_buf = get_sps_pps_nal_size(next_nal_buf, 64, &nal_size, &nal_head_size);
if (sps_pps_buf && (sps_pps_buf[nal_head_size] & 0x1f) == 7)
{
sps_buf = sps_pps_buf + nal_head_size;
sps_len = nal_size;
next_nal_buf = sps_pps_buf + nal_size + nal_head_size;
}
else if (sps_pps_buf && (sps_pps_buf[nal_head_size] & 0x1f) == 8)
{
pps_buf = sps_pps_buf + nal_head_size;
pps_len = nal_size;
next_nal_buf = sps_pps_buf + nal_size + nal_head_size;
}
// 不匹配,就不再去获取pps或者sps了
else
{
break;
}
// os_printf("sps_pps_buf[nal_head_size]& 0x1f):%d\n",sps_pps_buf[nal_head_size]& 0x1f);
pps_sps_times++;
}
struct fb_h264_s *priv = (struct fb_h264_s *) STREAM_LIBC_ZALLOC(sizeof(struct fb_h264_s));
// 寻找一下nal头有多少字节
uint32_t pos;
uint8_t h264_nal_size = get_nal_size(next_nal_buf, 16, &pos);
priv->pps = pps_buf;
priv->pps_len = pps_len;
priv->sps = sps_buf;
priv->sps_len = sps_len;
fb->priv = (void *) priv;
priv->type = 1;
priv->count = count;
priv->start_len = next_nal_buf - fb->data + pos + h264_nal_size;
// os_printf("priv->start_len:%d\ttype:%d\n",priv->start_len,fb->data[priv->start_len]&0x1f);
// os_printf("pps:%d\tsps:%d\n",pps_buf[0]&0x1f,sps_buf[0]&0x1f);
}
else
{
struct fb_h264_s *priv = (struct fb_h264_s *) STREAM_LIBC_ZALLOC(sizeof(struct fb_h264_s));
uint32_t pos;
uint8_t h264_nal_size = get_nal_size(fb->data, 16, &pos);
priv->type = 2;
fb->priv = (void *) priv;
priv->count = count;
priv->start_len = pos + h264_nal_size;
}
//_os_printf("H%d", h264_type_frame);
// 在msi_output_fb后,不要继续调用其他和msi有关的东西,因为有可能在这个之后,会释放对应的内存
msi_output_fb(video_h264->msi, fb);
ret = RET_OK;
}
h264_output_msi_end:
return ret;
}
static int32 h264_msi_thread(void *d)
{
struct video_h264_msi_s *video_h264 = (struct video_h264_msi_s *) d;
uint32_t flags;
// uint8_t which;
uint32_t stop_flag = 0;
msi_get(video_h264->msi);
while (1)
{
// 如果需要退出,则直接退出线程
os_event_wait(&video_h264->evt, VIDEO_APP_H264_STOP, &stop_flag, OS_EVENT_WMODE_OR, 0);
if (stop_flag & VIDEO_APP_H264_STOP)
{
break;
}
flags = disable_irq();
struct list_head *get_f = (void *) get_h264_frame();
enable_irq(flags);
if (get_f)
{
h264_output_msi(get_f, video_h264);
del_h264_frame(get_f);
}
else
{
os_sleep_ms(1);
}
}
// 设置退出标志
os_event_set(&video_h264->evt, VIDEO_APP_H264_EXIT, NULL);
// 释放对应的msi(不是open的),实际是这个时候才会真正释放
msi_put(video_h264->msi);
return 0;
}
static int32_t h264_msi_action(struct msi *msi, uint32_t cmd_id, uint32_t param1, uint32_t param2)
{
int32_t ret = RET_OK;
struct video_h264_msi_s *video_h264 = (struct video_h264_msi_s *) msi->priv;
switch (cmd_id)
{
case MSI_CMD_POST_DESTROY:
{
h264_mem_init(0, 0, 0, 0, 0);
fbpool_destroy(&video_h264->tx_pool);
// 等待线程退出
os_event_wait(&video_h264->evt, VIDEO_APP_H264_EXIT, NULL, OS_EVENT_WMODE_CLEAR, -1);
os_event_del(&video_h264->evt);
STREAM_LIBC_FREE(video_h264);
}
break;
case MSI_CMD_PRE_DESTROY:
{
// os_work_cancle2(&video_h264->work, 1);
os_event_set(&video_h264->evt, VIDEO_APP_H264_STOP, NULL);
h264_close(video_h264->h264_dev);
if (video_h264->sub_stream_en)
{
unregister_gen420_queue(GEN420_QUEUE_H264);
}
}
break;
case MSI_CMD_FREE_FB:
{
struct framebuff *fb = (struct framebuff *) param1;
if (fb->data)
{
STREAM_FREE(fb->data);
fb->data = NULL;
}
if (fb->priv)
{
STREAM_LIBC_FREE(fb->priv);
fb->priv = NULL;
}
fbpool_put(&video_h264->tx_pool, fb);
// 不需要内核去释放fb
ret = RET_OK + 1;
}
break;
default:
break;
}
return ret;
}
struct msi *h264_msi_init_with_mode(uint32_t drv1_from, uint32_t drv1_w, uint32_t drv1_h, uint32_t drv2_from, uint32_t drv2_w, uint32_t drv2_h)
{
int ret = 0;
struct msi *msi = msi_new(S_H264, 0, NULL);
struct video_h264_msi_s *video_h264 = (struct video_h264_msi_s *) msi->priv;
if (!video_h264)
{
video_h264 = (struct video_h264_msi_s *) STREAM_LIBC_ZALLOC(sizeof(struct video_h264_msi_s));
msi->priv = (void *) video_h264;
msi->enable = 1;
msi->action = h264_msi_action;
video_h264->msi = msi;
fbpool_init(&video_h264->tx_pool, MAX_VIDEO_APP_264);
os_event_init(&video_h264->evt);
video_h264->h264_dev = (struct h264_device *) dev_get(HG_H264_DEVID);
if (video_h264->h264_dev)
{
if (drv1_from == GEN420_DATA || drv2_from == GEN420_DATA)
{
extern int32_t h264_gen420_kick();
uint32_t gen_w = drv1_from == GEN420_DATA ? drv1_w : drv2_w;
uint32_t gen_h = drv1_from == GEN420_DATA ? drv1_h : drv2_h;
ret = register_gen420_queue(GEN420_QUEUE_H264, gen_w, gen_h, h264_gen420_kick, NULL, (uint32) NULL);
if (!ret)
{
video_h264->sub_stream_en = 1;
}
else
{
video_h264->sub_stream_en = 0;
if (drv1_from == GEN420_DATA)
{
drv1_from = 0;
drv1_w = 0;
drv1_h = 0;
}
if (drv2_from == GEN420_DATA)
{
drv2_from = 0;
drv2_w = 0;
drv2_h = 0;
}
}
}
// 自己适应w和h
if (drv1_from == VPP_DATA0)
{
get_vpp_w_h(&drv1_w, &drv1_h);
}
else if (drv1_from == VPP_DATA1)
{
get_vpp1_w_h(&drv1_w, &drv1_h);
}
if (drv2_from == VPP_DATA0)
{
get_vpp_w_h(&drv2_w, &drv2_h);
}
else if (drv2_from == VPP_DATA1)
{
get_vpp1_w_h(&drv2_w, &drv2_h);
}
h264_set_oe_select(video_h264->h264_dev, 0, 0);
h264_enc(drv1_from, drv1_w, drv1_h, drv2_from, drv2_w, drv2_h);
h264_open(video_h264->h264_dev);
h264_set_sw_ready(video_h264->h264_dev);
}
// 启动workqueue
// 创建一个任务去做h264的工作
OS_TASK_INIT("video_h264", &video_h264->task, h264_msi_thread, (void *) video_h264, OS_TASK_PRIORITY_ABOVE_NORMAL, NULL, 1024);
// OS_WORK_INIT(&video_h264->work, h264_msi_work, 0);
// os_run_work_delay(&video_h264->work, 1);
}
return msi;
}
struct msi *h264_msi_init_with_mode_for_264wq(uint32_t drv1_from, uint32_t drv1_w, uint32_t drv1_h)
{
int ret = 0;
struct msi *msi = msi_new(S_H264, 0, NULL);
struct video_h264_msi_s *video_h264 = (struct video_h264_msi_s *) msi->priv;
if (!video_h264)
{
video_h264 = (struct video_h264_msi_s *) STREAM_LIBC_ZALLOC(sizeof(struct video_h264_msi_s));
msi->priv = (void *) video_h264;
msi->enable = 1;
msi->action = h264_msi_action;
video_h264->msi = msi;
fbpool_init(&video_h264->tx_pool, MAX_VIDEO_APP_264);
os_event_init(&video_h264->evt);
video_h264->h264_dev = (struct h264_device *) dev_get(HG_H264_DEVID);
if (video_h264->h264_dev)
{
if (drv1_from == GEN420_DATA)
{
extern int32_t h264_gen420_kick();
uint32_t gen_w = drv1_w;
uint32_t gen_h = drv1_h;
ret = register_gen420_queue(GEN420_QUEUE_H264, gen_w, gen_h, h264_gen420_kick, NULL, (uint32) NULL);
if (!ret)
{
video_h264->sub_stream_en = 1;
}
else
{
video_h264->sub_stream_en = 0;
if (drv1_from == GEN420_DATA)
{
drv1_from = 0;
drv1_w = 0;
drv1_h = 0;
}
}
}
// 自己适应w和h
if (drv1_from == VPP_DATA0)
{
get_vpp_w_h(&drv1_w, &drv1_h);
}
else if (drv1_from == VPP_DATA1)
{
get_vpp1_w_h(&drv1_w, &drv1_h);
}
h264_set_oe_select(video_h264->h264_dev, 0, 0);
h264_enc(drv1_from, drv1_w, drv1_h, -1, 0, 0);
// h264_open(video_h264->h264_dev);
}
// 启动workqueue
// 创建一个任务去做h264的工作
OS_TASK_INIT("video_h264", &video_h264->task, h264_msi_thread, (void *) video_h264, OS_TASK_PRIORITY_ABOVE_NORMAL, NULL, 1024);
// OS_WORK_INIT(&video_h264->work, h264_msi_work, 0);
// os_run_work_delay(&video_h264->work, 1);
}
return msi;
}
#else
struct video_h264_msi_s
{
struct os_work work;
struct os_event evt;
struct msi *msi;
struct h264_device *h264_dev;
uint16_t filter_type;
uint16_t sub_stream_en;
uint8_t drv1_from;
uint8_t drv2_from;
struct fbpool tx_pool;
};
#if VIDEO_YUV_RANGE_TYPE
uint8_t h264_dec_sps_src_param(uint32 w, uint32 h, uint8_t *buf)
{
BitBuffer buffer;
// uint32 itk;
buffer.current_bit_pos = 0;
h264_sps_gen_test(&buffer, w, h, 0);
memcpy(buf, buffer.data, buffer.current_bit_pos / 8);
return buffer.current_bit_pos / 8;
}
#endif
/********************************************************************************************
* I帧和P帧对应的位置图,主要通过寻找nal,定位pps和sps的起始位置并且记录
* 实际内容也会记录,到终端可以采取是否直接读取结构体的pps和sps(尽量从结构体读取)
*
*
* 00 00 00 01 67 xx xx xx 00 00 00 01 68 xx xx xx 00 00 00 01 65 xx xx xx I帧
* sps_buf pps_buf start_len
*
*
*
*
*
* 00 00 00 01 61 xx xx xx P帧
* start_len
*******************************************************************************************/
static int8_t h264_output_msi(struct list_head *get_f, struct video_h264_msi_s *video_h264)
{
int ret = RET_ERR;
uint32_t node_len;
uint32_t h264_len;
uint32_t h264_len_tmp;
uint32_t cp_len;
uint32_t cp_offset;
uint8_t *tmp_buf;
uint32_t timestamp;
uint8_t which;
uint8_t srcID;
uint16_t w, h;
uint8_t h264_type_frame;
node_len = get_h264_node_len_new((void *) get_f);
h264_len = get_h264_len(get_f);
timestamp = get_h264_timestamp(get_f);
h264_type_frame = get_h264_type(get_f); // 获取是否为I帧还是P帧
which = get_h264_which(get_f);
srcID = get_h264_srcID(get_f);
uint8_t count = get_h264_loop_num(get_f);
struct framebuff *fb = NULL;
get_h264_w_h((void *) get_f, &w, &h);
// 新的sps和pps的buf
if (!h264_len)
{
goto h264_output_msi_end;
}
#if VIDEO_YUV_RANGE_TYPE == 1
BitBuffer buffer;
// os_printf("h264_type_frame:%d\n", h264_type_frame);
// 如果是I帧,就重新生成一下对应的sps和pps
if (h264_type_frame == 1)
{
buffer.current_bit_pos = 0;
h264_sps_gen_test(&buffer, w, h, 1);
}
#endif
fb = fbpool_get(&video_h264->tx_pool, 0, video_h264->msi);
if (fb)
{
// 先去msi寻找是否有空闲节点,如果有,才需要拷贝,否则就丢弃
// MAX_BYTES是重新生成的sps和pps的最大空间
uint8_t *h264_buf = (uint8_t *) STREAM_MALLOC(h264_len + SAVE_COUNT + MAX_BYTES);
if (!h264_buf)
{
msi_delete_fb(NULL, fb);
goto h264_output_msi_end;
}
uint32_t reserve_len = 0;
#if VIDEO_YUV_RANGE_TYPE == 1
uint32_t skip_size;
if (h264_type_frame == 1)
{
uint8_t *new_sps_pps_buf = get_h264_first_buf(get_f);
skip_sps(new_sps_pps_buf, 128, &skip_size);
if (skip_size)
{
reserve_len = bit_buffer_get_used_bytes(&buffer) - skip_size;
}
}
#endif
// 拷贝264的数据
h264_len_tmp = h264_len;
// 设置预留的长度
cp_offset = reserve_len;
while (h264_buf)
{
// 图片节点提取
if (list_empty(get_f) || h264_len_tmp == 0)
{
break;
}
if (h264_len_tmp > node_len)
{
cp_len = node_len;
}
else
{
cp_len = h264_len_tmp;
}
h264_len_tmp -= cp_len;
tmp_buf = get_h264_first_buf(get_f);
hw_memcpy0(h264_buf + cp_offset, get_h264_first_buf(get_f), cp_len);
del_h264_first_node(get_f);
cp_offset += cp_len;
}
#if VIDEO_YUV_RANGE_TYPE == 1
// skip_size代表找到sps,替换新的sps
if (h264_type_frame == 1 && skip_size)
{
os_memcpy(h264_buf, buffer.data, bit_buffer_get_used_bytes(&buffer));
}
#endif
// 264末尾加一个序号
if (SAVE_COUNT > 0)
{
os_sprintf((char *) h264_buf + h264_len + reserve_len, "%03d", count & 0xff);
h264_buf[h264_len + reserve_len + 3] = '#';
}
sys_dcache_clean_range((uint32_t *) h264_buf, h264_len + SAVE_COUNT + reserve_len);
fb->data = (uint8_t *) h264_buf;
fb->len = h264_len + SAVE_COUNT + reserve_len;
fb->mtype = F_H264;
fb->stype = which + FSTYPE_H264_VPP_DATA0; // 基于stype某个值
fb->time = timestamp;
fb->srcID = srcID;
// I帧
if (h264_type_frame == 1)
{
// 先去读取sps和pps的长度
uint8_t nal_head_size;
uint32_t nal_size;
uint8_t *sps_pps_buf = fb->data;
uint8_t *pps_buf = NULL;
uint8_t *sps_buf = NULL;
uint8_t pps_len = 0, sps_len = 0;
uint8_t pps_sps_times = 0;
uint8_t *next_nal_buf = fb->data;
// 读取sps和pps,仅仅读取两次,没有就退出
while (sps_pps_buf && pps_sps_times < 2)
{
sps_pps_buf = get_sps_pps_nal_size(next_nal_buf, 64, &nal_size, &nal_head_size);
if (sps_pps_buf && (sps_pps_buf[nal_head_size] & 0x1f) == 7)
{
sps_buf = sps_pps_buf + nal_head_size;
sps_len = nal_size;
next_nal_buf = sps_pps_buf + nal_size + nal_head_size;
}
else if (sps_pps_buf && (sps_pps_buf[nal_head_size] & 0x1f) == 8)
{
pps_buf = sps_pps_buf + nal_head_size;
pps_len = nal_size;
next_nal_buf = sps_pps_buf + nal_size + nal_head_size;
}
// 不匹配,就不再去获取pps或者sps了
else
{
break;
}
// os_printf("sps_pps_buf[nal_head_size]& 0x1f):%d\n",sps_pps_buf[nal_head_size]& 0x1f);
pps_sps_times++;
}
struct fb_h264_s *priv = (struct fb_h264_s *) STREAM_LIBC_ZALLOC(sizeof(struct fb_h264_s));
// 寻找一下nal头有多少字节
uint32_t pos;
uint8_t h264_nal_size = get_nal_size(next_nal_buf, 16, &pos);
priv->pps = pps_buf;
priv->pps_len = pps_len;
priv->sps = sps_buf;
priv->sps_len = sps_len;
fb->priv = (void *) priv;
priv->type = 1;
priv->count = count;
priv->start_len = next_nal_buf - fb->data + pos + h264_nal_size;
priv->w = w;
priv->h = h;
// os_printf("priv->start_len:%d\ttype:%d\n",priv->start_len,fb->data[priv->start_len]&0x1f);
// os_printf("pps:%d\tsps:%d\n",pps_buf[0]&0x1f,sps_buf[0]&0x1f);
}
else
{
struct fb_h264_s *priv = (struct fb_h264_s *) STREAM_LIBC_ZALLOC(sizeof(struct fb_h264_s));
uint32_t pos;
uint8_t h264_nal_size = get_nal_size(fb->data, 16, &pos);
priv->type = 2;
fb->priv = (void *) priv;
priv->count = count;
priv->start_len = pos + h264_nal_size;
priv->w = w;
priv->h = h;
}
//_os_printf("H%d", h264_type_frame);
// 在msi_output_fb后,不要继续调用其他和msi有关的东西,因为有可能在这个之后,会释放对应的内存
msi_output_fb(video_h264->msi, fb);
ret = RET_OK;
}
h264_output_msi_end:
return ret;
}
static int32 h264_msi_work(struct os_work *work)
{
struct video_h264_msi_s *video_h264 = (struct video_h264_msi_s *) work;
uint32_t flags;
h264_msi_work_again:
flags = disable_irq();
struct list_head *get_f = (void *) get_h264_frame();
enable_irq(flags);
if (get_f)
{
h264_output_msi(get_f, video_h264);
del_h264_frame(get_f);
goto h264_msi_work_again;
}
os_run_work_delay(work, 1);
// os_event_set(&video_h264->evt, VIDEO_APP_H264_EXIT, NULL);
return 0;
}
static int32_t h264_msi_action(struct msi *msi, uint32_t cmd_id, uint32_t param1, uint32_t param2)
{
int32_t ret = RET_OK;
struct video_h264_msi_s *video_h264 = (struct video_h264_msi_s *) msi->priv;
switch (cmd_id)
{
case MSI_CMD_POST_DESTROY:
{
h264_mem_init(0, 0, 0, 0, 0);
fbpool_destroy(&video_h264->tx_pool);
// 等待线程退出
// os_event_wait(&video_h264->evt, VIDEO_APP_H264_EXIT, NULL, OS_EVENT_WMODE_CLEAR, -1);
os_event_del(&video_h264->evt);
STREAM_LIBC_FREE(video_h264);
}
break;
case MSI_CMD_PRE_DESTROY:
{
os_work_cancle2(&video_h264->work, 1);
h264_close(video_h264->h264_dev);
if (video_h264->sub_stream_en)
{
unregister_gen420_queue(GEN420_QUEUE_H264);
}
uint8_t scale1 = 0;
// 把检查数据源是否为scale1,如果是scale1,同时把scale1一起关闭了
if (video_h264->drv1_from == SCALER_DATA)
{
scale1 = 1;
}
if (video_h264->drv2_from == SCALER_DATA)
{
scale1 = 1;
}
if (scale1)
{
struct scale_device *scale_dev = (struct scale_device *) dev_get(HG_SCALE1_DEVID);
// 关闭scale1
scale_close(scale_dev);
}
}
break;
case MSI_CMD_FREE_FB:
{
struct framebuff *fb = (struct framebuff *) param1;
if (fb->data)
{
STREAM_FREE(fb->data);
fb->data = NULL;
}
if (fb->priv)
{
STREAM_LIBC_FREE(fb->priv);
fb->priv = NULL;
}
fbpool_put(&video_h264->tx_pool, fb);
// 不需要内核去释放fb
ret = RET_OK + 1;
}
break;
default:
break;
}
return ret;
}
struct msi *h264_msi_init_with_mode(uint32_t drv1_from, uint16_t drv1_w, uint16_t drv1_h, uint16_t drv2_from, uint16_t drv2_w, uint16_t drv2_h)
{
int ret = 0;
uint8_t isnew;
struct msi *msi = msi_new(S_H264, 0, &isnew);
struct video_h264_msi_s *video_h264;
if (msi && isnew)
{
video_h264 = (struct video_h264_msi_s *) STREAM_LIBC_ZALLOC(sizeof(struct video_h264_msi_s));
ASSERT(video_h264);
msi->priv = (void *) video_h264;
msi->enable = 1;
video_h264->h264_dev = (struct h264_device *) dev_get(HG_H264_DEVID);
if (video_h264->h264_dev)
{
if (drv1_from == GEN420_DATA || drv2_from == GEN420_DATA)
{
extern int32_t h264_gen420_kick();
uint32_t gen_w = drv1_from == GEN420_DATA ? drv1_w : drv2_w;
uint32_t gen_h = drv1_from == GEN420_DATA ? drv1_h : drv2_h;
ret = register_gen420_queue(GEN420_QUEUE_H264, gen_w, gen_h, h264_gen420_kick, NULL, (uint32) NULL);
if (!ret)
{
video_h264->sub_stream_en = 1;
}
else
{
video_h264->sub_stream_en = 0;
if (drv1_from == GEN420_DATA)
{
drv1_from = 0;
drv1_w = 0;
drv1_h = 0;
}
if (drv2_from == GEN420_DATA)
{
drv2_from = 0;
drv2_w = 0;
drv2_h = 0;
}
}
}
// 自己适应w和h
if (drv1_from == VPP_DATA0)
{
get_vpp_w_h(&drv1_w, &drv1_h);
}
else if (drv1_from == VPP_DATA1)
{
get_vpp1_w_h(&drv1_w, &drv1_h);
}
else if (drv1_from == SCALER_DATA)
{
ret = get_vpp_scale_w_h(&drv1_w, &drv1_h);
if (!ret)
{
set_vpp_scale_w_h(1, drv1_w, drv1_h);
}
else
{
drv1_from = ~0;
}
}
if (drv2_from == VPP_DATA0)
{
get_vpp_w_h(&drv2_w, &drv2_h);
}
else if (drv2_from == VPP_DATA1)
{
get_vpp1_w_h(&drv2_w, &drv2_h);
}
else if (drv2_from == SCALER_DATA)
{
ret = get_vpp_scale_w_h(&drv2_w, &drv2_h);
if (!ret)
{
set_vpp_scale_w_h(1, drv2_w, drv2_h);
}
else
{
drv2_from = ~0;
}
}
video_h264->drv1_from = drv1_from;
video_h264->drv2_from = drv2_from;
h264_set_oe_select(video_h264->h264_dev, 0, 0);
ret = h264_enc(drv1_from, drv1_w, drv1_h, drv2_from, drv2_w, drv2_h);
if (ret)
{
if (video_h264)
{
STREAM_LIBC_FREE(video_h264);
}
msi_destroy(msi);
msi = NULL;
goto h264_msi_init_with_mode_end;
}
else
{
h264_open(video_h264->h264_dev);
h264_set_sw_ready(video_h264->h264_dev);
msi->action = h264_msi_action;
video_h264->msi = msi;
fbpool_init(&video_h264->tx_pool, MAX_VIDEO_APP_264);
os_event_init(&video_h264->evt);
}
}
// 启动workqueue
// 创建一个任务去做h264的工作
// OS_TASK_INIT("video_h264", &video_h264->task, h264_msi_thread, (void*)video_h264, OS_TASK_PRIORITY_ABOVE_NORMAL, NULL, 1024);
OS_WORK_INIT(&video_h264->work, h264_msi_work, 0);
os_run_work_delay(&video_h264->work, 1);
}
h264_msi_init_with_mode_end:
return msi;
}
struct msi *h264_msi_init_with_timeLapse(uint32_t drv1_from, uint16_t drv1_w, uint16_t drv1_h, uint32_t timer)
{
int ret = 0;
uint8_t isnew = 0;
struct msi *msi = msi_new(S_H264, 0, &isnew);
struct video_h264_msi_s *video_h264;
if (msi && isnew)
{
video_h264 = (struct video_h264_msi_s *) STREAM_LIBC_ZALLOC(sizeof(struct video_h264_msi_s));
ASSERT(video_h264);
msi->priv = (void *) video_h264;
msi->enable = 1;
video_h264->h264_dev = (struct h264_device *) dev_get(HG_H264_DEVID);
if (video_h264->h264_dev)
{
// 自己适应w和h
if (drv1_from == VPP_DATA0)
{
get_vpp_w_h(&drv1_w, &drv1_h);
}
else if (drv1_from == VPP_DATA1)
{
get_vpp1_w_h(&drv1_w, &drv1_h);
}
else if (drv1_from == SCALER_DATA)
{
ret = get_vpp_scale_w_h(&drv1_w, &drv1_h);
if (!ret)
{
set_vpp_scale_w_h(1, drv1_w, drv1_h);
}
else
{
drv1_from = ~0;
}
}
video_h264->drv1_from = drv1_from;
video_h264->drv2_from = ~0;
h264_set_oe_select(video_h264->h264_dev, 0, 0);
ret = h264_enc_with_timeLapse(drv1_from, drv1_w, drv1_h, timer);
if (ret)
{
if (video_h264)
{
STREAM_LIBC_FREE(video_h264);
}
msi_destroy(msi);
msi = NULL;
goto h264_msi_init_with_mode_end;
}
else
{
h264_open(video_h264->h264_dev);
h264_set_sw_ready(video_h264->h264_dev);
msi->action = h264_msi_action;
video_h264->msi = msi;
fbpool_init(&video_h264->tx_pool, MAX_VIDEO_APP_264);
os_event_init(&video_h264->evt);
}
}
// 启动workqueue
// 创建一个任务去做h264的工作
// OS_TASK_INIT("video_h264", &video_h264->task, h264_msi_thread, (void*)video_h264, OS_TASK_PRIORITY_ABOVE_NORMAL, NULL, 1024);
OS_WORK_INIT(&video_h264->work, h264_msi_work, 0);
os_run_work_delay(&video_h264->work, 1);
}
h264_msi_init_with_mode_end:
return msi;
}
struct msi *h264_msi_init_with_mode_for_264wq(uint32_t drv1_from, uint16_t drv1_w, uint16_t drv1_h)
{
int ret = 0;
uint8_t isnew;
struct msi *msi = msi_new(S_H264, 0, &isnew);
struct video_h264_msi_s *video_h264;
if (msi && isnew)
{
video_h264 = (struct video_h264_msi_s *) STREAM_LIBC_ZALLOC(sizeof(struct video_h264_msi_s));
ASSERT(video_h264);
msi->priv = (void *) video_h264;
msi->enable = 1;
video_h264->h264_dev = (struct h264_device *) dev_get(HG_H264_DEVID);
if (video_h264->h264_dev)
{
if (drv1_from == GEN420_DATA)
{
extern int32_t h264_gen420_kick();
uint32_t gen_w = drv1_w;
uint32_t gen_h = drv1_h;
ret = register_gen420_queue(GEN420_QUEUE_H264, gen_w, gen_h, h264_gen420_kick, NULL, (uint32) NULL);
if (!ret)
{
video_h264->sub_stream_en = 1;
}
else
{
video_h264->sub_stream_en = 0;
if (drv1_from == GEN420_DATA)
{
drv1_from = 0;
drv1_w = 0;
drv1_h = 0;
}
}
}
// 自己适应w和h
if (drv1_from == VPP_DATA0)
{
get_vpp_w_h(&drv1_w, &drv1_h);
}
else if (drv1_from == VPP_DATA1)
{
get_vpp1_w_h(&drv1_w, &drv1_h);
}
h264_set_oe_select(video_h264->h264_dev, 0, 0);
ret = h264_enc(drv1_from, drv1_w, drv1_h, -1, 0, 0);
if (ret)
{
if (video_h264)
{
STREAM_LIBC_FREE(video_h264);
}
msi_destroy(msi);
msi = NULL;
goto h264_msi_init_with_mode_end;
}
else
{
h264_open(video_h264->h264_dev);
msi->action = h264_msi_action;
video_h264->msi = msi;
fbpool_init(&video_h264->tx_pool, MAX_VIDEO_APP_264);
os_event_init(&video_h264->evt);
}
}
// 启动workqueue
// 创建一个任务去做h264的工作
// OS_TASK_INIT("video_h264", &video_h264->task, h264_msi_thread, (void*)video_h264, OS_TASK_PRIORITY_ABOVE_NORMAL, NULL, 1024);
OS_WORK_INIT(&video_h264->work, h264_msi_work, 0);
os_run_work_delay(&video_h264->work, 1);
}
h264_msi_init_with_mode_end:
return msi;
}
#endif
Reference in New Issue Copy Permalink