FIMV_MFC_V1.0.rar display_optimization1.c - Read

来源：互联网发布：c 编程思想编辑：程序博客网时间：2024/04/30 05:40

转自：http://read.pudn.com/downloads143/sourcecode/unix_linux/622436/FIMV_MFC_V1.0/mfc_app/API/display_optimization1.c__.htm
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/ioctl.h>
#include <fcntl.h>
#include <ctype.h>
#include <unistd.h>
#include <sys/mman.h>
#include <string.h>
#include <errno.h>
#include <sys/time.h>
#include <signal.h>
#include <linux/vt.h>
#include <linux/fb.h>
#include <pthread.h>
#include <semaphore.h>
#include "SsbSipH264Decode.h"
#include "SsbSipMpeg4Decode.h"
#include "SsbSipVC1Decode.h"
#include "FrameExtractor.h"
#include "MPEG4Frames.h"
#include "H263Frames.h"
#include "H264Frames.h"
#include "SsbSipLogMsg.h"
#include "performance.h"
#include "post.h"
#include "lcd.h"
#include "MfcDriver.h"
#include "FileRead.h"
#include "display_optimization1.h"
static unsigned char delimiter_h264[4] = {0x00, 0x00, 0x00, 0x01};
static int nFrameLeng;
#define INPUT_BUFFER_SIZE (204800)
static void *handle;
static int in_fd;
static int file_size;
static char *in_addr;
static int fb_size;
static int pp_fd, fb_fd;
static char *fb_addr;
static void sig_del_h264(void);
static q_instance queue[10];
static sem_t full;
static sem_t empty;
static int producer_idx, consumer_idx;
static int frame_cnt;
static int frame_need_cnt[2];
static pthread_t th;
static void *rendering(void *arg)
{
pp_params *pp_param = (pp_params *)arg;
while(1) {
sem_wait(&full);
pp_param->SrcFrmSt = queue[consumer_idx].phy_addr;
ioctl(pp_fd, PPROC_SET_PARAMS, pp_param);
ioctl(pp_fd, PPROC_START);
consumer_idx++;
consumer_idx %= frame_need_cnt[0];
if(nFrameLeng < 4)
break;
sem_post(&empty);
}
return NULL;
}
int Test_Display_Optimization1(int argc, char **argv)
{
void *pStrmBuf;
unsigned int pYUVBuf[2];
struct stat s;
FRAMEX_CTX *pFrameExCtx; // frame extractor context
FRAMEX_STRM_PTR file_strm;
SSBSIP_H264_STREAM_INFO stream_info;
pp_params pp_param;
s3c_win_info_t osd_info_to_driver;
int r;
#ifdef FPS
struct timeval start, stop;
unsigned int time = 0;
#endif
if(signal(SIGINT, sig_del_h264) == SIG_ERR) {
printf("Sinal Error\n");
}
if (argc != 2) {
printf("Usage : mfc <H.264 input filename>\n");
return -1;
}
#ifndef RGB24BPP
printf("Display optimization 1 supports 24bpp only.\n");
printf("Because local path is used between post processor and lcd\n");
printf("RGB24BPP macro must be added in Makefile\n");
return -1;
#endif
// in file open
in_fd = open(argv[1], O_RDONLY);
if(in_fd < 0) {
printf("Input file open failed\n");
return -1;
}
// get input file size
fstat(in_fd, &s);
file_size = s.st_size;
// mapping input file to memory
in_addr = (char *)mmap(0, file_size, PROT_READ, MAP_SHARED, in_fd, 0);
if(in_addr == NULL) {
printf("input file memory mapping failed\n");
return -1;
}
// Post processor open
pp_fd = open(PP_DEV_NAME, O_RDWR|O_NDELAY);
if(pp_fd < 0)
{
printf("Post processor open error\n");
return -1;
}
// LCD frame buffer open
fb_fd = open(FB_DEV_NAME, O_RDWR|O_NDELAY);
if(fb_fd < 0)
{
printf("LCD frame buffer open error\n");
return -1;
}
///////////////////////////////////
// FrameExtractor Initialization //
///////////////////////////////////
pFrameExCtx = FrameExtractorInit(FRAMEX_IN_TYPE_MEM, delimiter_h264, sizeof(delimiter_h264), 1);
file_strm.p_start = file_strm.p_cur = (unsigned char *)in_addr;
file_strm.p_end = (unsigned char *)(in_addr + file_size);
FrameExtractorFirst(pFrameExCtx, &file_strm);
//////////////////////////////////////
/// 1. Create new instance ///
/// (SsbSipH264DecodeInit) ///
//////////////////////////////////////
handle = SsbSipH264DecodeInit();
if (handle == NULL) {
printf("H264_Dec_Init Failed.\n");
return -1;
}
/////////////////////////////////////////////
/// 2. Obtaining the Input Buffer ///
/// (SsbSipH264DecodeGetInBuf) ///
/////////////////////////////////////////////
pStrmBuf = SsbSipH264DecodeGetInBuf(handle, nFrameLeng);
if (pStrmBuf == NULL) {
printf("SsbSipH264DecodeGetInBuf Failed.\n");
SsbSipH264DecodeDeInit(handle);
return -1;
}
////////////////////////////////////
// H264 CONFIG stream extraction //
////////////////////////////////////
nFrameLeng = ExtractConfigStreamH264(pFrameExCtx, &file_strm, pStrmBuf, INPUT_BUFFER_SIZE, NULL);
////////////////////////////////////////////////////////////////
/// 3. Configuring the instance with the config stream ///
/// (SsbSipH264DecodeExe) ///
////////////////////////////////////////////////////////////////
if (SsbSipH264DecodeExe(handle, nFrameLeng) != SSBSIP_H264_DEC_RET_OK) {
printf("H.264 Decoder Configuration Failed.\n");
return -1;
}
/////////////////////////////////////
/// 4. Get stream information ///
/////////////////////////////////////
SsbSipH264DecodeGetConfig(handle, H264_DEC_GETCONF_STREAMINFO, &stream_info);
printf("\t<STREAMINFO> width=%d height=%d.\n", stream_info.width, stream_info.height);
// set post processor configuration
pp_param.SrcFullWidth = stream_info.width;
pp_param.SrcFullHeight = stream_info.height;
pp_param.SrcCSpace = YC420;
pp_param.DstFullWidth = 800; // destination width
pp_param.DstFullHeight = 480; // destination height
pp_param.DstCSpace = RGB24;
// Post processor's output directly goes to FIFO in display controller using local path
pp_param.OutPath = POST_FIFO;
pp_param.Mode = ONE_SHOT;
// get LCD frame buffer address
fb_size = pp_param.DstFullWidth * pp_param.DstFullHeight * 4; // RGB888
fb_addr = (char *)mmap(0, fb_size, PROT_READ | PROT_WRITE, MAP_SHARED, fb_fd, 0);
if (fb_addr == NULL) {
printf("LCD frame buffer mmap failed\n");
return -1;
}
osd_info_to_driver.Bpp = 24; // RGB888
osd_info_to_driver.LeftTop_x = 0;
osd_info_to_driver.LeftTop_y = 0;
osd_info_to_driver.Width = 800; // display width
osd_info_to_driver.Height = 480; // display height
// set OSD's information
if(ioctl(fb_fd, SET_OSD_INFO, &osd_info_to_driver)) {
printf("Some problem with the ioctl SET_OSD_INFO\n");
return -1;
}
//Default setting of window0 doesn't use
ioctl(fb_fd, SET_OSD_STOP);
SsbSipH264DecodeGetConfig(handle, H264_DEC_GETCONF_FRAM_NEED_COUNT, frame_need_cnt);
printf("Frame need count is %d\n", frame_need_cnt[0]);
if(pthread_create(&th, NULL, rendering, (void *)&pp_param) < 0) {
printf("Rendering thread creation error\n");
return -1;
}
r = sem_init(&full, 0, 0);
if(r < 0) {
printf("sem_init failed\n");
return -1;
}
r = sem_init(&empty, 0, frame_need_cnt[0]);
if(r < 0) {
printf("sem_init failed\n");
return -1;
}
#ifdef FPS
gettimeofday(&start, NULL);
#endif
while(1)
{
sem_wait(&empty);
//////////////////////////////////
/// 5. DECODE ///
/// (SsbSipH264DecodeExe) ///
//////////////////////////////////
if (SsbSipH264DecodeExe(handle, nFrameLeng) != SSBSIP_H264_DEC_RET_OK) {
printf("frame count : %d\n", frame_cnt);
break;
}
//////////////////////////////////////////////
/// 6. Obtaining the Output Buffer ///
/// (SsbSipH264DecodeGetOutBuf) ///
//////////////////////////////////////////////
SsbSipH264DecodeGetConfig(handle, H264_DEC_GETCONF_PHYADDR_FRAM_BUF, pYUVBuf);
frame_cnt++;
queue[producer_idx].phy_addr = pYUVBuf[0];
queue[producer_idx].frame_number = frame_cnt;
producer_idx++;
producer_idx %= frame_need_cnt[0];
sem_post(&full);
/////////////////////////////
// Next H.264 VIDEO stream //
/////////////////////////////
nFrameLeng = NextFrameH264(pFrameExCtx, &file_strm, pStrmBuf, INPUT_BUFFER_SIZE, NULL);
if (nFrameLeng < 4)
break;
if(frame_cnt == 1)
ioctl(fb_fd, SET_OSD_START);
}
pthread_join(th, NULL);
#ifdef FPS
gettimeofday(&stop, NULL);
time = measureTime(&start, &stop);
printf("Display Time : %u, Frame Count : %d, FPS : %f\n", time, frame_cnt, (float)frame_cnt*1000/time);
#endif
SsbSipH264DecodeDeInit(handle);
munmap(in_addr, file_size);
munmap(fb_addr, fb_size);
close(pp_fd);
close(fb_fd);
close(in_fd);
return 0;
}
static void sig_del_h264(void)
{
printf("signal handling\n");
pthread_exit(0);
pthread_join(th, NULL);
SsbSipH264DecodeDeInit(handle);
munmap(in_addr, file_size);
munmap(fb_addr, fb_size);
close(pp_fd);
close(fb_fd);
close(in_fd);
}