6410H264编码rtp串流

OK6410下的wiif的视频小车——camer h264 rtp

采用6410+ov9650的组合采集视频，给出的demo中ov9650只能输出15帧每秒，百度收索ov9650相关配置找到能正常输出30帧每秒的配置，ok6410提供的mfc中无论怎么配置api都不能达到30fps的采样速度，只有15fps，百度里有人说用mmap方式代替read进行可以加快图像采集速度可是调用VIDIOC_QUERYBUF根本无延时，无法判断什么时候中断读取相机接口，希望有高手点播一下，最后无奈只能去driver修改，最开始发现相机接口的4个buffer在读取数据时不时按照顺序读取只读取了其中两个buffer，所以考虑是否是交错模式和连续模式配置错误，但是都给设置为连续模式后还是只有15fps只读取两个buffer，后来找到在相机接口对应的irq函数s3c_fimc_frame_handler中产生中断控制了读取buffer，逐修改中断函数如下：

,,,,,,,,,,,,,,,,,,,,,,,,

case S3C_FIMC_FLAG_IRQ_X:
dev_dbg(ctrl->dev, "irq flag is x\n");
s3c_fimc_enable_lastirq(ctrl);
s3c_fimc_disable_lastirq(ctrl);
FSET_HANDLE_IRQ(ctrl);
FSET_IRQ_LAST(ctrl);
+++ ret = S3C_FIMC_FRAME_TAKE;
--- ret = S3C_FIMC_FRAME_SKIP;
break;

,,,,,,,,,,,,,,,,,,,,,,,,

修改后能够正确采集到30fps的图像，后面附有30fps采集压缩程序，修改自自带的Multmedia_DD。在移植后的vlc中找到读取h264文件的入口（file.c)，修改读取文件为读取h264压缩后的数据，由于不懂vlc如何加入c文件编译，所以将所有函数都放在了file.c文件中。这个过程比较多报错所以折腾了很久，h264压缩和采集需要建立新线程处理，为file.c中的fileread函数提供数据，线程之间通信我建立了一个环形buffer进行视频数据的读取。vlc因为默认采用25fps进行解复用，所以修改modules/demux/mpeg/h264.c文件：

,,,,,,,,,,,,,,,,,,,,,,,,

p_demux->pf_control= Control;

p_demux->p_sys     = p_sys = malloc( sizeof( demux_sys_t ) );

p_sys->p_es        = NULL;

p_sys->i_dts       = 0;

p_sys->f_fps       = 29.988;//修改为ov9650输出帧率：29.988

,,,,,,,,,,,,,,,,,,,,,,,,

经过各种折腾终于在电脑端用vlc播放出来了。rtp视频虽然能正常播放了，但还是有几个问题：

1、6410的camera接口输出24Mhz时钟不精准，是不是导致输出30帧率不准确的主要原因？虽然9650里面有微调帧率的寄存器0x92 0x93 0x2a 0x2b。但是我只能调整到29.988。

2、在rtp播放过程中vlc会出现：

main input error: ES_OUT_SET_(GROUP_)PCR  is called too late (pts_delay increased to 1000 ms)

和

main mux warning: late buffer for mux input

两种输出，这是否是因为6410产生h264数据包的时间戳有问题引起的？

总结：

ov9650输出帧率、h264硬件压缩帧率和vlc相关帧率设置都会引起rtp传输时产生问题：a、内存不断增加，并且播放越久延时越大；b、vlc不停的输出PCR  is called too late和late buffer for mux input，导致视频不连续。6410设置帧率应该乘以该帧率的一倍！不然录制的视频播放速度很快！

采集压缩程序：

/* Main Process(Camera previewing) */

int Forlinx_Test_Cam_Encoding(int argc, char **argv, int lcdnum) {
int ret, start, found = 0;
int k_id;
unsigned int addr = 0;
char rgb_for_preview[LCD_WIDTH_MAX * LCD_HEIGHT_MAX * 4]; // MAX

struct v4l2_capability cap;
struct v4l2_input chan;
struct v4l2_framebuffer preview;
struct v4l2_pix_format preview_fmt;
struct v4l2_format codec_fmt;

pp_params pp_param;
int pp_fd;

g_LCD_Width = lcdsize[lcdnum][0];
g_LCD_Height = lcdsize[lcdnum][1];

// source picture width and height must be a multiple of 16 in codecing
codec_Width = g_LCD_Width / 16 * 16;
codec_Height = g_LCD_Height / 16 * 16;

g_YUV_Frame_Buffer_Size = (codec_Width * codec_Height) + (codec_Width
* codec_Height) / 2;

/* Camera codec initialization */
if ((cam_c_fp = cam_c_init()) < 0)
exit_from_app();
signal_ctrl_c();

#if 1
/* Codec set */
/* Get capability */
ret = ioctl(cam_c_fp, VIDIOC_QUERYCAP, &cap);
if (ret < 0) {
printf("V4L2 : ioctl on VIDIOC_QUERYCAP failled\n");
exit(1);
}

/* Check the type - preview(OVERLAY) */
if (!(cap.capabilities & V4L2_CAP_VIDEO_CAPTURE)) {
printf("V4L2 : Can not capture(V4L2_CAP_VIDEO_CAPTURE is false)\n");
exit(1);
}

/* Set format */
codec_fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
codec_fmt.fmt.pix.width = codec_Width;//LCD_WIDTH;
codec_fmt.fmt.pix.height = codec_Height; //LCD_HEIGHT;
codec_fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_YUV420;
codec_fmt.fmt.pix.priv = V4L2_FMT_OUT; // must set

ret = ioctl(cam_c_fp, VIDIOC_S_FMT, &codec_fmt);
if (ret < 0) {
printf("V4L2 : ioctl on VIDIOC_S_FMT failled\n");
exit(1);
}

ret = ioctl(cam_c_fp, VIDIOC_OVERLAY, &codec_start);
if (ret < 0) {
printf("V4L2 : ioctl on VIDIOC_OVERLAY failed\n");
exit(1);
}
codec_reqbuffer.count = 4;
codec_reqbuffer.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
codec_reqbuffer.memory = V4L2_MEMORY_MMAP;
ret = ioctl(cam_c_fp, VIDIOC_REQBUFS, &codec_reqbuffer);
if (ret < 0) {
printf("V4L2 : ioctl on VIDIOC_DQBUF failled\n");
exit(1);
}
printf("codec_reqbuffer.count : %d\n", codec_reqbuffer.count);
VideoBuffer*          buffers = calloc( codec_reqbuffer.count, sizeof(*buffers) );
struct v4l2_buffer    buf;
int numBufs;
for (numBufs = 0; numBufs < codec_reqbuffer.count; numBufs++) {
   memset( &buf, 0, sizeof(buf) );
   buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
   buf.memory = V4L2_MEMORY_MMAP;
   buf.index = numBufs;
   printf("buf.type %d, buf.memory %d, buf.index%d\n", buf.type, buf.memory,buf.index);
   // 读取缓存
   if (ioctl(cam_c_fp, VIDIOC_QUERYBUF, &buf) == -1) {
    printf("VIDIOC_QUERYBUF err\n");
       return -1;
   }
   buffers[numBufs].length = buf.length;
   // 转换成相对地址
   buffers[numBufs].start = mmap(NULL, buf.length,
       PROT_READ | PROT_WRITE,
       MAP_SHARED,
       cam_c_fp, buf.m.offset);
   if (buffers[numBufs].start == MAP_FAILED) {
    printf("MAP_FAILED\n");
       return -1;
   }
   // 放入缓存队列
   if (ioctl(cam_c_fp, VIDIOC_QBUF, &buf) == -1) {
    printf("VIDIOC_QBUF err\n");
       return -1;
   }
}
#endif
printf("\n[8. Camera preview & MFC encoding]\n");
printf("Forlinx Embedded, %s\n", VERSION);
printf("Using IP          : MFC, Post processor, LCD, Camera\n");
printf("Display size      : (%dx%d)\n", g_LCD_Width, g_LCD_Height);

/* Encoding and decoding threads creation */
k_id = pthread_create(&pth, 0, (void *) &encoding_thread, 0);

while (1) {
if (finished)
break;
sleep(1);//liu
}
pthread_join(pth, NULL);
finished = 0;
exit_from_app();
return 0;
}

/***************** Encoding Thread *****************/
void encoding_thread(void) {
char file_name[100];
int yuv_cnt = 0;
int start, ret;
int frame_num = YUV_FRAME_NUM;
int key;
unsigned char g_yuv[YUV_FRAME_BUFFER_SIZE_MAX];
unsigned char *encoded_buf;
long encoded_size;
struct v4l2_buffer buf;
memset(&buf,0,sizeof(buf));
buf.type=V4L2_BUF_TYPE_VIDEO_CAPTURE;
buf.memory=V4L2_MEMORY_MMAP;
buf.index=0;

printf("\ne : Encoding\n");
printf("x : Exit\n");
printf("Select ==> ");
while (1) {
key = getchar();//liu
if (key == 'e')
encoding_flag = TRUE;
else if (key == 'x') {
finished = 1;
pthread_exit(0);
}
if (encoding_flag == TRUE) {
pthread_mutex_lock(&mutex);
handle = mfc_encoder_init(codec_Width, codec_Height, 30, 1000, 30);
sprintf(&file_name[0], "Cam_encoding_%dx%d-%d.264", codec_Width,
codec_Height, ++film_cnt);
printf("Name of encoded file : Cam_encoding_%dx%d-%d.264\n",
codec_Width, codec_Height, film_cnt);
fflush(stdout);

/* file create/open, note to "wb" */
encoded_fp = fopen(&file_name[0], "wb");
if (!encoded_fp) {
perror(&file_name[0]);
}

/* Codec start */
start = 1;
ret = ioctl(cam_c_fp, VIDIOC_STREAMON, &start);
if (ret < 0) {
printf("V4L2 : ioctl on VIDIOC_STREAMON failed\n");
exit(1);
}
struct timeval t_start, t_end;
long cost_time = 0;
for (yuv_cnt = 0; yuv_cnt < frame_num; yuv_cnt++) {
frame_count++;
buf.index=0;
gettimeofday(&t_start, NULL);
#if 1
/* read from camera device */
if (read(cam_c_fp, g_yuv, g_YUV_Frame_Buffer_Size) < 0) {
perror("read()");
}
#endif
#if 1
ret = ioctl(cam_c_fp, VIDIOC_DQBUF, &buf);
if (ret < 0) {
printf("V4L2 : ioctl on VIDIOC_DQBUF failled\n");
exit(1);
}
#endif
#if 1
if(frame_count == 1)
encoded_buf = mfc_encoder_exe(handle, g_yuv, g_YUV_Frame_Buffer_Size, 1, &encoded_size);
else
encoded_buf = mfc_encoder_exe(handle, g_yuv, g_YUV_Frame_Buffer_Size, 0, &encoded_size);
#endif
gettimeofday(&t_end, NULL);
cost_time = t_end.tv_usec - t_start.tv_usec;

printf("Cost a time: %ld us\n", cost_time);
//重新放入缓存队列
if (ioctl(cam_c_fp, VIDIOC_QBUF, &buf) == -1) {
printf("VIDIOC_QBUF err\n");
   return -1;
}
fwrite(encoded_buf, 1, encoded_size, encoded_fp);
}
frame_count = 0;

/* Codec stop */
start = 0;
ret = ioctl(cam_c_fp, VIDIOC_STREAMOFF, &start);
if (ret < 0) {
printf("V4L2 : ioctl on VIDIOC_STREAMOFF failed\n");
exit(1);
}

printf("100 frames were encoded\n");
printf("\nSelect ==> ");

mfc_encoder_free(handle);
fclose(encoded_fp);
encoding_flag = FALSE;
pthread_mutex_unlock(&mutex);
}
}
}

————————ov9650 配置vga 30fps————————

        /* OV9650intialization parameter table for VGA application */
        {0x12, 0x80},       // Camera Soft reset. Self cleared after reset.
        {CHIP_DELAY, 10},
        {0x11,0x80},{0x6a,0x3e},{0x3b,0x09},{0x13,0xe0},{0x01,0x80},{0x02,0x80},{0x00,0x00},{0x10,0x00},
       {0x13,0xe5},{0x39,0x43},{0x38,0x12},{0x37,0x00},{0x35,0x91},{0x0e,0xa0},{0x1e,0x04},{0xA8,0x80},
       {0x12,0x40},{0x04,0x40},{0x0c,0x04},{0x0d,0x80},{0x18,0xc6},{0x17,0x26},{0x32,0xad},{0x03,0x00},
       {0x1a,0x3d},{0x19,0x01},{0x3f,0xa6},{0x14,0x2e},{0x15,0x10},{0x41,0x02},{0x42,0x08},{0x1b,0x00},
       {0x16,0x06},{0x33,0xe2},{0x34,0xbf},{0x96,0x04},{0x3a,0x00},{0x8e,0x00},{0x3c,0x77},{0x8B,0x06},
       {0x94,0x88},{0x95,0x88},{0x40,0xc1},{0x29,0x3f},{0x0f,0x42},{0x3d,0x92},{0x69,0x40},{0x5C,0xb9},
       {0x5D,0x96},{0x5E,0x10},{0x59,0xc0},{0x5A,0xaf},{0x5B,0x55},{0x43,0xf0},{0x44,0x10},{0x45,0x68},
       {0x46,0x96},{0x47,0x60},{0x48,0x80},{0x5F,0xe0},{0x60,0x8c},{0x61,0x20},{0xa5,0xd9},{0xa4,0x74},
       {0x8d,0x02},{0x13,0xe7},{0x4f,0x3a},{0x50,0x3d},{0x51,0x03},{0x52,0x12},{0x53,0x26},{0x54,0x38},
       {0x55,0x40},{0x56,0x40},{0x57,0x40},{0x58,0x0d},{0x8C,0x23},{0x3E,0x02},{0xa9,0xb8},{0xaa,0x92},
       {0xab,0x0a},{0x8f,0xdf},{0x90,0x00},{0x91,0x00},{0x9f,0x00},{0xa0,0x00},{0x3A,0x01},{0x24,0x70},
       {0x25,0x64},{0x26,0xc3},
{0x2a,0x00},{0x2b,0x00},
{0x92,0x04},//liu
{0x93,0x00},//liu
{0x6c,0x40},{0x6d,0x30},{0x6e,0x4b},{0x6f,0x60},
        {0x70,0x70},{0x71,0x70},{0x72,0x70},{0x73,0x70},{0x74,0x60},{0x75,0x60},{0x76,0x50},{0x77,0x48},
       {0x78,0x3a},{0x79,0x2e},{0x7a,0x28},{0x7b,0x22},{0x7c,0x04},{0x7d,0x07},{0x7e,0x10},{0x7f,0x28},
       {0x80,0x36},{0x81,0x44},{0x82,0x52},{0x83,0x60},{0x84,0x6c},{0x85,0x78},{0x86,0x8c},{0x87,0x9e},
       {0x88,0xbb},{0x89,0xd2},{0x8a,0xe6},