jpeg_main.c

基于Linux的ffmepg decoder

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include "../../faraday_mpeg4_common/dev_mem.h"

#include "cjpeg.h"
#include "jpeglib.h"
#include "portab.h"
#include "test_mem.h"
#include "vpe_m.h"

#define IMAGE_WIDTH	480	//192
#define IMAGE_HEIGHT 640	//128
#define IMAGE_COMP	3
#define IMAGE_QUALITY	90
#define IMAGE_RST	5
#define IMAGE_BUF_SZ	(IMAGE_WIDTH * IMAGE_HEIGHT * IMAGE_COMP)
#define BS_BUF_SZ	(IMAGE_WIDTH * IMAGE_HEIGHT)
#define SET_COMP(index,hsamp,vsamp)  \
  (h[index] = (hsamp), \
   v[index] = (vsamp))
#define MAX(a,b)	((a) > (b) ? (a) : (b))
#define INPUT_FILE_NAME		"..\\..\\..\\..\\pattern\\c030_input422_480640.yuv"
#define OUTPUT_FILE_NAME		"..\\..\\..\\..\\pattern\\c030_422q90rst5qt1ht1_480640_result.jpg"
static void usage(char *name);
int main(int argc, char **argv)
{
	int i;
	FJPEG_ENC_PARAM tEncParam;
	uint32_t u32BS_len = 0;
	uint8_t * pu8output_buffer_y_virt = NULL;
	uint8_t * pu8output_buffer_u_virt = NULL;
	uint8_t * pu8output_buffer_v_virt = NULL;
	uint8_t * pu8output_buffer_y_phy = NULL;
	uint8_t * pu8output_buffer_u_phy = NULL;
	uint8_t * pu8output_buffer_v_phy = NULL;
	uint8_t * pu8bs_buffer_virt = NULL;
	uint8_t * pu8bs_buffer_phy = NULL;
	unsigned int y_image_size,u_image_size,v_image_size,yuv_size;
	unsigned int max_h_samp,max_v_samp;
	FILE *in_file,*out_file;
	unsigned int * base;
	char in_filename[80];
	char out_filename[80];

#ifndef FPGA
 	__rt_lib_init(BaseOfHeap, TopOfHeap);
#endif

	tEncParam.u32img_width = IMAGE_WIDTH;		// image width
	tEncParam.u32img_height = IMAGE_HEIGHT;		// image height
	tEncParam.u32comp_num = IMAGE_COMP;			// component numbers
	tEncParam.u32img_qual = IMAGE_QUALITY;		//usually set 75 < qual <100, if qual<50 the quality of image is very pool
	tEncParam.u32rst_interval = IMAGE_RST;		//default value is 0
	tEncParam.eYUVsampling = JCS_yuv422;	//JCS_yuv420;

	for (i=1; i< argc; i++) {
		if (strcmp("-i", argv[i]) == 0 && i < argc - 1 ) {
			i ++;
			strcpy (in_filename, argv[i]);
		}
		else if (strcmp("-o", argv[i]) == 0 && i < argc - 1 ) {
			i ++;
			strcpy (out_filename, argv[i]);
		}
		else if (strcmp("-w", argv[i]) == 0 && i < argc - 1 ) {
			i++;
			tEncParam.u32img_width = (uint32_t)atoi(argv[i]);
		}
		else if (strcmp("-h", argv[i]) == 0 && i < argc - 1 ) {
			i++;
			tEncParam.u32img_height = (uint32_t)atoi(argv[i]);
		}
		else if (strcmp("-comp", argv[i]) == 0 && i < argc - 1 ) {
			i++;
			tEncParam.u32comp_num = (uint32_t)atoi(argv[i]);
		}
		else if (strcmp("-qlt", argv[i]) == 0 && i < argc - 1 ) {
			i++;
			tEncParam.u32img_qual = (uint32_t)atoi(argv[i]);
		}
		else if (strcmp("-rst", argv[i]) == 0 && i < argc - 1 ) {
			i++;
			tEncParam.u32rst_interval = (uint32_t)atoi(argv[i]);
		}
		else if (strcmp("-fmt", argv[i]) == 0 && i < argc - 1 ) {
			i ++;
			if (strcmp("yuv420", argv[i]) == 0)
				tEncParam.eYUVsampling = JCS_yuv420;
			else if (strcmp("yuv422", argv[i]) == 0)
				tEncParam.eYUVsampling = JCS_yuv422;
			else if (strcmp("yuv211", argv[i]) == 0)
				tEncParam.eYUVsampling = JCS_yuv211;
			else if (strcmp("yuv333", argv[i]) == 0)
				tEncParam.eYUVsampling = JCS_yuv333;
			else if (strcmp("yuv222", argv[i]) == 0)
				tEncParam.eYUVsampling = JCS_yuv222;
			else if (strcmp("yuv111", argv[i]) == 0)
				tEncParam.eYUVsampling = JCS_yuv111;
			else {
				printf("Unreconigized format '%s', stop\n", argv[i]);
				usage(argv[0]);
				return -1;
			}
		}
		else {
			printf("Unreconigized parameter '%s', stop\n", argv[i]);
			usage(argv[0]);
			return -1;
		}
	}
/*****************************************************************************
 * Values checking
 ****************************************************************************/
	if ((tEncParam.u32img_width > 2048) || (tEncParam.u32img_height > 2048)) {
		usage(argv[0]);
		return -1;
	}
	if (tEncParam.u32comp_num > 3) {
		usage(argv[0]);
		return -1;
	}
	if (tEncParam.u32img_qual > 100) {
		usage(argv[0]);
		return -1;
	}

	// open input YUV file, the YUV data file is arranged in 2D format
	if((in_file=fopen(in_filename,"rb"))==NULL) {
      printf ("Can't open file %s\n", in_filename);
      exit(1);
	}

	// open output bitstream file
	if((out_file=fopen(out_filename,"wb"))==NULL) {
      printf ("Can't open file %s\n", out_filename);
      exit(1);
	}

	pu8bs_buffer_virt = (uint8_t *)TM_DmaMalloc(BS_BUF_SZ, CACHE_LINE, CACHE_LINE, (void **)&pu8bs_buffer_phy);
	if (!pu8bs_buffer_virt)
		goto free_all_memory;

	base = (unsigned char *)ioremap(0x90700000, 0x100000);
	if (base == 0) {			/// maping failure
		printf("mpeg4 maping failure\n");
		return -1;
	}
	printf("jpeg virt addr = 0x%x\n", (int)base);
	tEncParam.pu32BaseAddr = base;
	tEncParam.u32CacheAlign = 16;
	tEncParam.u32BSAddr_phy = (uint32_t)pu8bs_buffer_phy;
	tEncParam.pfnDmaMalloc = TM_DmaMalloc;
	tEncParam.pfnDmaFree = TM_DmaFree;
	{
		int h[3], v[3];
		switch (tEncParam.eYUVsampling) {
			case JCS_yuv420:
			  SET_COMP(0, 2, 1);
			  SET_COMP(1, 1,1);
			  SET_COMP(2, 1,1);
			  break;
			case JCS_yuv422:
			  SET_COMP(0, 4,1);
			  SET_COMP(1, 2,1);
			  SET_COMP(2, 2,1);
			  break;
			case JCS_yuv211:
			  SET_COMP(0, 2,1);
			  SET_COMP(1, 1,1);
			  SET_COMP(2, 1,1);
			  break;
			case JCS_yuv333:
			  SET_COMP(0, 3,1);
			  SET_COMP(1, 3,1);
			  SET_COMP(2, 3,1);
			  break;
			case JCS_yuv222:
			  SET_COMP(0, 2,1);
			  SET_COMP(1, 2,1);
			  SET_COMP(2, 2,1);
			  break;
			case JCS_yuv111:
			  SET_COMP(0, 1,1);
			  SET_COMP(1, 1,1);
			  SET_COMP(2, 1,1);
			  break;
			default:
			  SET_COMP(0, 2,2);
			  SET_COMP(1, 1,1);
			  SET_COMP(2, 1,1);
			  break;
		}
  		// get the maximum horizontal sampling factor
		max_h_samp=MAX(h[0], MAX(h[1], h[2]));
		// get the maximum horizontal sampling factor
		max_v_samp=MAX(v[0], MAX(v[1], v[2]));
		 // calculate each component size according to its maximum sampling factor
		 // and individual sampling factor
		y_image_size=((h[0]*tEncParam.u32img_width)/max_h_samp) *
		                	((v[0]*tEncParam.u32img_height)/max_v_samp);
		u_image_size=((h[1]*tEncParam.u32img_width)/max_h_samp) *
		                	((v[1]*tEncParam.u32img_height)/max_v_samp);
		v_image_size=((h[2]*tEncParam.u32img_width)/max_h_samp) *
		                	((v[2]*tEncParam.u32img_height)/max_v_samp);
		yuv_size = y_image_size+u_image_size+v_image_size;
		// allocate the input Y frame buffer with 8-byte aligned (64-bit alignment)
		pu8output_buffer_y_virt = 
				(unsigned char *)TM_DmaMalloc(y_image_size,8,16,(void **)&pu8output_buffer_y_phy);
		if(pu8output_buffer_y_virt ==NULL)
			goto free_all_memory;
		pu8output_buffer_u_virt = 
				(unsigned char *)TM_DmaMalloc(u_image_size,8,16,(void **)&pu8output_buffer_u_phy);
		if(pu8output_buffer_u_virt ==NULL)
			goto free_all_memory;
		pu8output_buffer_v_virt = 
				(unsigned char *)TM_DmaMalloc(v_image_size,8,16,(void **)&pu8output_buffer_v_phy);
		if(pu8output_buffer_v_virt ==NULL)
			goto free_all_memory;

		tEncParam.u32YAddr_phy = (uint32_t)pu8output_buffer_y_phy;
		tEncParam.u32UAddr_phy = (uint32_t)pu8output_buffer_u_phy;
		tEncParam.u32VAddr_phy = (uint32_t)pu8output_buffer_v_phy;
	}
	// to read the Y component of YUV data from file
	if(fread(pu8output_buffer_y_virt,sizeof(unsigned char),y_image_size,in_file)!=y_image_size)
		exit(1);
	// to read the U component of YUV data from file
	if(fread(pu8output_buffer_u_virt,sizeof(unsigned char),u_image_size,in_file)!=u_image_size)
		exit(1);
	// to read the V component of YUV data from file
	if(fread(pu8output_buffer_v_virt,sizeof(unsigned char),v_image_size,in_file)!=v_image_size)
		exit(1);
	mFa526CleanInvalidateDCacheAll();

#ifdef FPGA
	printf ("Start to encode\n");
#endif
	JpegEnc(&tEncParam, &u32BS_len);
#ifdef FPGA
	printf ("encode finish\n");
#endif

	fwrite(pu8bs_buffer_virt, sizeof(unsigned char), u32BS_len, out_file);
	// close output YUV file
	fclose(out_file);    
	// close input bitstream file
	fclose(in_file);

 free_all_memory:
	if (pu8output_buffer_y_virt) TM_DmaFree(pu8output_buffer_y_virt, pu8output_buffer_y_phy);
	if (pu8output_buffer_u_virt) TM_DmaFree(pu8output_buffer_u_virt, pu8output_buffer_u_phy);
	if (pu8output_buffer_v_virt) TM_DmaFree(pu8output_buffer_v_virt, pu8output_buffer_v_phy);
	if (pu8bs_buffer_virt) TM_DmaFree(pu8bs_buffer_virt, pu8bs_buffer_phy);

	if (u32BS_len == 0) {
		mVpe_FAIL();
	} else { 	// simulation finish in PASS
		mVpe_PASS();
	}
	return 0;
}

static void usage(char *name)
{
	fprintf(stderr, "Usage : %s <-i input_file>  <-o output_file> [OPTIONS]\n", name);
	fprintf(stderr, "-i input_file            : input raw data file name\n");
	fprintf(stderr, "-o output_file         : output jpeg file name\n");
	fprintf(stderr, "Options :\n");
	fprintf(stderr, "-fmt input_format  : input file format, posible: \"yuv420\", \"yuv422\", \"yuv211\", \"yuv333\", \"yuv222\", \"yuv111\"  (default = yuv422)\n");
	fprintf(stderr, " -w integer            : picture width ([1.2048, default = %d])\n", IMAGE_WIDTH);
	fprintf(stderr, " -h integer           : picture height ([1.2048], default = %d)\n", IMAGE_HEIGHT);
	fprintf(stderr, " -qlt integer         : quality ([1.100], default = %d)\n", IMAGE_QUALITY);
	fprintf(stderr, " -rst integer        : restart marker([1. inf], default = %d)\n", IMAGE_RST);
	fprintf(stderr, " -comp integer    : component number in input file ([1. 3], default = %d)\n", IMAGE_COMP);
}