bitmaps.c

Sample code for use on smp 863x processor.

	png_read_image(png_info->png_ptr, row_pointers);
	png_read_end(png_info->png_ptr, png_info->info_ptr);

	return RM_OK;
	
}

static  RMstatus png_get_palette(RMuint32 *palette, struct RMpngInfo *png_info)
{
	/* FIXME */
	png_colorp pal;
	int palette_size;
	RMuint32 row;
	palette_size = 256;
	if(png_info->gray_levels == 0){
		if(png_get_PLTE(png_info->png_ptr, png_info->info_ptr, &pal, &palette_size)){
			for(row = 0; row < (png_uint_32)palette_size; row++){
				palette[row] = (png_info->alpha<<24) | (pal[row].red<<16) | (pal[row].green<<8) | pal[row].blue;
			}
		}
		else
			return RM_ERROR;
	}
	else{
		RMuint32 level = 0, step = 0xff/(png_info->gray_levels-1);
		for(row = 0; row < png_info->gray_levels; row++){
			palette[row] = (png_info->alpha<<24) | (level<<16) | (level<<8) | level;
			level += step;
		}
	}
	return RM_OK;

}


static void png_cleanup(struct RMpngInfo *png_info)
{
	png_destroy_read_struct(&(png_info->png_ptr), &(png_info->info_ptr), (png_infopp)NULL);

}



static RMstatus jpeg_flip_rotate(RMfile in_fp, RMfile out_fp, JXFORM_CODE transform)
{
	struct jpeg_decompress_struct srcinfo;
	struct jpeg_compress_struct dstinfo;
	struct jpeg_error_mgr jsrcerr, jdsterr;
	jvirt_barray_ptr * src_coef_arrays;

	jvirt_barray_ptr * dst_coef_arrays;
	jpeg_transform_info transformoption; /* image transformation options */

	transformoption.transform = transform;
	transformoption.trim = FALSE;
	transformoption.force_grayscale = FALSE;
	transformoption.crop = FALSE;
	srcinfo.err = jpeg_std_error(&jsrcerr);
	jpeg_create_decompress(&srcinfo);
	dstinfo.err = jpeg_std_error(&jdsterr);
	jpeg_create_compress(&dstinfo);
	jsrcerr.trace_level = jdsterr.trace_level;
	srcinfo.mem->max_memory_to_use = dstinfo.mem->max_memory_to_use;
	jpeg_stdio_src_rm_file(&srcinfo, in_fp);
/* 	jcopy_markers_setup(&srcinfo, JCOPYOPT_DEFAULT); */

	(void) jpeg_read_header(&srcinfo, TRUE);
	jtransform_request_workspace(&srcinfo, &transformoption);
	src_coef_arrays = jpeg_read_coefficients(&srcinfo);
	jpeg_copy_critical_parameters(&srcinfo, &dstinfo);
	dst_coef_arrays = jtransform_adjust_parameters(&srcinfo, &dstinfo,
						       src_coef_arrays,
						       &transformoption);

	jpeg_stdio_dest_rm_file(&dstinfo, out_fp);
	jpeg_write_coefficients(&dstinfo, dst_coef_arrays);
/* 	jcopy_markers_execute(&srcinfo, &dstinfo, JCOPYOPT_DEFAULT); */
	jtransform_execute_transformation(&srcinfo, &dstinfo,
					  src_coef_arrays,
					  &transformoption);
	jpeg_finish_compress(&dstinfo);
	jpeg_destroy_compress(&dstinfo);
	(void) jpeg_finish_decompress(&srcinfo);
	jpeg_destroy_decompress(&srcinfo);
	return RM_OK;
}

static void my_jpeg_error_exit(j_common_ptr cinfo)
{
	jmp_buf env;
	RMbool do_longjmp = FALSE;

	if (cinfo->client_data != NULL) {
		RMMemcpy(&env, cinfo->client_data, sizeof(jmp_buf));
		do_longjmp = TRUE;
	}
	
	RMDBGLOG((ENABLE, "JPEG error: \n  "));
	(*cinfo->err->output_message)(cinfo);
	jpeg_destroy(cinfo);
	
	if (do_longjmp)
		longjmp(env, 1);
}

static RMstatus open_jpg_file(struct RMjpgInfo *jpg_info , struct DCCOSDProfile  *profile)
{

 	struct jpeg_decompress_struct *pCinfo = &(jpg_info->cinfo);
	jmp_buf long_jump_context;
	RMstatus err;
	
	if (setjmp(long_jump_context) != 0) {
		// we only get here due to a longjmp, so my_jpeg_error_exit was called, exit with error then
		pCinfo->client_data = NULL;
		return RM_ERROR;
	}
	// else, setjmp succeded and long_jump_context was saved


	pCinfo->err = jpeg_std_error(&(jpg_info->jerr));

	// setup our own exit handler
	pCinfo->err->error_exit = my_jpeg_error_exit;

	// setup our context
	pCinfo->client_data = (void *)&long_jump_context;

	jpeg_create_decompress(pCinfo);
#if ((EM86XX_CHIP==EM86XX_CHIPID_TANGO15)&&(EM86XX_MODE==EM86XX_MODEID_STANDALONE))
	jpeg_enable_special_large_memory_manager( (j_common_ptr)pCinfo, rua_malloc_large, rua_free_large );
#endif 

	jpeg_stdio_src_rm_file(pCinfo, jpg_info->fp);
	jpeg_read_header(pCinfo, TRUE);
	jpeg_calc_output_dimensions(pCinfo);

	jpg_info->force_420 = TRUE;

	if ((pCinfo->image_width <= 0) || (pCinfo->image_height <= 0)) {
		fprintf(stderr, "illegal image size: %d x %d pixel\n", pCinfo->image_width, pCinfo->image_height);
		err = RM_ERROR;
		goto exit_open_jpg;
	}
	

	if (!(jpg_info->force_rgb)){
		RMuint32 min_chunk, buf_width, buf_height;
		if (pCinfo->progressive_mode) {
			RMDBGLOG((ENABLE, "jpeg file must not be in progressive mode\n"));
			err = RM_ERROR;
			goto exit_open_jpg;
		}
		if (pCinfo->jpeg_color_space != JCS_YCbCr) {
			RMDBGLOG((ENABLE, "jpeg file needs to be in YUV color space\n"));
			err = RM_ERROR;
			goto exit_open_jpg;
		}

		if((pCinfo->comp_info[1].h_samp_factor != pCinfo->comp_info[2].h_samp_factor) ||
		   (pCinfo->comp_info[1].v_samp_factor != pCinfo->comp_info[2].v_samp_factor)){
			RMDBGLOG((ENABLE, "Unsupported jpeg type, different Cb and Cr sampling factors!\n"));
			err = RM_ERROR;
			goto exit_open_jpg;
		}
		if((pCinfo->comp_info[0].h_samp_factor == 2) && (pCinfo->comp_info[0].v_samp_factor == 2) &&
		   (pCinfo->comp_info[1].h_samp_factor == 1) && (pCinfo->comp_info[1].v_samp_factor == 1)){
			/*could change to support a more generic y:(2n,2n) u,v:(n,n) */
			jpg_info->sampling_mode = EMhwlibSamplingMode_420;
		}
		else if((pCinfo->comp_info[0].h_samp_factor == 2) && (pCinfo->comp_info[0].v_samp_factor == 1) &&
			(pCinfo->comp_info[1].h_samp_factor == 1) && (pCinfo->comp_info[1].v_samp_factor == 1)){
			/*could change to support a more generic y:(2n,n) u,v:(n,n) */
			jpg_info->sampling_mode = EMhwlibSamplingMode_422;
		}
		else if((pCinfo->comp_info[0].h_samp_factor == 1) && (pCinfo->comp_info[0].v_samp_factor == 1) &&
			(pCinfo->comp_info[1].h_samp_factor == 1) && (pCinfo->comp_info[1].v_samp_factor == 1)){
			/*could change to support a more generic y:(n,n) u,v:(n,n) */
			jpg_info->sampling_mode = EMhwlibSamplingMode_444;
			/* todo support 444->422 */
			jpg_info->force_420 = TRUE;
		}
		else{
			RMDBGLOG((ENABLE, 
				  "Unsupported jpeg type (luma(%d:%d), chroma(%d:%d))\n",
				  pCinfo->comp_info[0].v_samp_factor,
				  pCinfo->comp_info[0].h_samp_factor,
				  pCinfo->comp_info[1].v_samp_factor,
				  pCinfo->comp_info[1].h_samp_factor));
			err = RM_ERROR;
			goto exit_open_jpg;
		}


		if(pCinfo->max_v_samp_factor * pCinfo->min_DCT_scaled_size > JPEG_MAX_LINES_PER_IMCU){		
			RMDBGLOG((ENABLE, "Unsupported jpeg type (try setting a higher JPEG_MAX_LINES_PER_IMCU)\n"));
			err = RM_ERROR;
			goto exit_open_jpg;
		}

		pCinfo->raw_data_out = TRUE;
		pCinfo->out_color_space = JCS_YCbCr;
		profile->ColorSpace = EMhwlibColorSpace_YUV_601_0_255;
		profile->ColorMode = EMhwlibColorMode_VideoNonInterleaved;
		if(jpg_info->force_420)
			profile->SamplingMode = EMhwlibSamplingMode_420;
		else
			profile->SamplingMode = jpg_info->sampling_mode;

		profile->ColorFormat = EMhwlibColorFormat_32BPP;
		profile->PixelAspectRatio.X = 1;
		profile->PixelAspectRatio.Y = 1;

		buf_width = pCinfo->comp_info[0].width_in_blocks * pCinfo->min_DCT_scaled_size;
		min_chunk = pCinfo->comp_info[0].h_samp_factor * pCinfo->min_DCT_scaled_size;
		buf_width = (buf_width + min_chunk - 1) & ~(min_chunk -1);

		buf_height = pCinfo->comp_info[0].height_in_blocks * pCinfo->min_DCT_scaled_size;
		min_chunk = pCinfo->comp_info[0].v_samp_factor * pCinfo->min_DCT_scaled_size;
		buf_height = (buf_height + min_chunk - 1) & ~(min_chunk -1);

		profile->Width =  buf_width;
		profile->Height = buf_height;

	}
	else{
		profile->ColorSpace = EMhwlibColorSpace_RGB_0_255;
		profile->SamplingMode = EMhwlibSamplingMode_444;
		profile->ColorMode = EMhwlibColorMode_TrueColor;
		profile->ColorFormat = EMhwlibColorFormat_32BPP;
		profile->PixelAspectRatio.X = 1;
		profile->PixelAspectRatio.Y = 1;
		profile->Width = pCinfo->output_width;
		profile->Height = pCinfo->output_height;
		pCinfo->out_color_space = JCS_RGB;
	}


	pCinfo->dct_method = JDCT_ISLOW;
	pCinfo->scale_num = 1;
	pCinfo->scale_denom = 1;
	pCinfo->quantize_colors = FALSE;
	jpeg_start_decompress(pCinfo);
	jpg_info->width = pCinfo->output_width;
	jpg_info->height = pCinfo->output_height;
	err = RM_OK;
	
 exit_open_jpg:
	// remove our context. This context is invalid after the function returns
	pCinfo->client_data = (void *) NULL;
	if (RMFAILED(err)) {
		jpeg_destroy_decompress(pCinfo);
	}
	return err;
}	
	

static RMstatus jpg_to_raw(RMuint8 *luma, RMuint8 *chroma, struct RMjpgInfo *jpg_info)
{
 	struct jpeg_decompress_struct *pCinfo = &(jpg_info->cinfo);

	if(jpg_info->force_rgb){
		JSAMPARRAY 	buffer;			
		RMuint32	row_stride;		
		RMuint32	row;
		RMuint32	databyte, bufbyte;
		RMuint8		temp;
		row_stride = pCinfo->output_width * pCinfo->output_components;
		buffer = (*pCinfo->mem->alloc_sarray) ((j_common_ptr) pCinfo, JPOOL_IMAGE, row_stride, 1);

		for (row = 0; row < pCinfo->output_height; row++){
			jpeg_read_scanlines(pCinfo, buffer, 1);
			/* reverse row (gbr -> rgb) */
			/* todo: this can be done by the jpeglib -- see jmorecfg.h*/
			for(bufbyte = 0; bufbyte < row_stride; ){
				temp = (*buffer)[bufbyte];
				(*buffer)[bufbyte] = (*buffer)[bufbyte + 2];
				(*buffer)[bufbyte + 2] = temp;
				bufbyte += 3;
			}

			temp = 0;
 			for(databyte = 0, bufbyte = 0; databyte < 4 * pCinfo->output_width; databyte++){
				if((databyte + 1) % 4 != 0)
					luma[databyte + row * 4 * pCinfo->output_width]  = (*buffer)[bufbyte++];
				else
					luma[databyte + row * 4 * pCinfo->output_width]  = jpg_info->alpha;
			}
		}
	}
	else{
		JSAMPROW CB[JPEG_MAX_LINES_PER_IMCU], CR[JPEG_MAX_LINES_PER_IMCU], Y[JPEG_MAX_LINES_PER_IMCU];
		JSAMPARRAY jcomponents[3] = {Y, CB, CR};
		RMuint32 i, j, k, readlines = 0, lines_per_imcu, buffer_size = 0, chroma_offs, buf_offs, h_skip = 1, v_skip = 1, min_chunk; 
		RMuint32 luma_width, chroma_width, chroma_height, luma_height;
		RMuint8 *cr_buffer, *cb_buffer;
		if(jpg_info->force_420){
			switch(jpg_info->sampling_mode){
			case EMhwlibSamplingMode_422:
				v_skip = 2;
				h_skip = 1;
				break;
			case EMhwlibSamplingMode_444:
				v_skip = h_skip = 2;
				break;
			default:
				v_skip = h_skip = 1;
				break;
			}
		}
		
		lines_per_imcu = pCinfo->max_v_samp_factor * pCinfo->min_DCT_scaled_size;
		/*luma lines per imcu */	
		luma_height   = pCinfo->comp_info[0].v_samp_factor*pCinfo->min_DCT_scaled_size;
		/*chroma lines per imcu */	
		chroma_height = pCinfo->comp_info[1].v_samp_factor*pCinfo->min_DCT_scaled_size;
	       
		luma_width = pCinfo->comp_info[0].width_in_blocks * pCinfo->min_DCT_scaled_size;
		min_chunk = pCinfo->comp_info[0].h_samp_factor * pCinfo->min_DCT_scaled_size;
		luma_width = (luma_width + min_chunk - 1) & ~(min_chunk -1);
	
		chroma_width = pCinfo->comp_info[1].width_in_blocks * pCinfo->min_DCT_scaled_size;
		min_chunk = pCinfo->comp_info[1].h_samp_factor * pCinfo->min_DCT_scaled_size;
		chroma_width = (chroma_width + min_chunk - 1) & ~(min_chunk -1);

		if(pCinfo->comp_info[1].h_samp_factor != 1){
			RMuint32 min_chunk = pCinfo->comp_info[1].h_samp_factor * pCinfo->min_DCT_scaled_size;
			if((chroma_width % min_chunk) != 0)
				chroma_width += min_chunk -(chroma_width % min_chunk);
		}

		buffer_size = chroma_height * chroma_width;
		
		cr_buffer = RMMalloc(buffer_size);
		cb_buffer = RMMalloc(buffer_size);

		for(k = 0; k < chroma_height; k++){
			CB[k] = cb_buffer + k * chroma_width;
			CR[k] = cr_buffer + k * chroma_width;
		}
		chroma_offs = 0;
		for (i = 0; i < pCinfo->output_height; i += readlines){
			for(k = 0; k < luma_height; k++){
				Y[k] = luma + (i+k)*luma_width;
			}
			readlines = jpeg_read_raw_data (pCinfo, jcomponents, lines_per_imcu);
			/* interleave cb and cr */
			buf_offs = 0;
			for(j = 0; j < chroma_height; j += v_skip){
				for(k = 0; k < chroma_width; k += h_skip){
					chroma[chroma_offs++]  = cb_buffer[buf_offs];
					chroma[chroma_offs++]  = cr_buffer[buf_offs];
					buf_offs += h_skip;
				}
				buf_offs += (v_skip-1) * chroma_width;
			}
		}
		RMFree(cr_buffer);
		RMFree(cb_buffer);
	}
	
	return RM_OK;
}




static void jpg_cleanup(struct RMjpgInfo *jpg_info)
{
	jpeg_finish_decompress(&(jpg_info->cinfo));
#if ((EM86XX_CHIP==EM86XX_CHIPID_TANGO15)&&(EM86XX_MODE==EM86XX_MODEID_STANDALONE))
	jpeg_disable_special_large_memory_manager( (j_common_ptr)&(jpg_info->cinfo) );
#endif 
	jpeg_destroy_decompress(&(jpg_info->cinfo));
}



static RMstatus open_yuv_file(struct RMyuvInfo *yuv_info,  struct DCCOSDProfile *profile)
{
	RMuint32 read_size, marker, width, height, offs;
	RMstatus err;
	RMuint8 header_buf[128];
	// read whole file into a buffer
	err = RMReadFile(yuv_info->fp, header_buf, 128, &read_size); /*read the header */
	if(RMFAILED(err)){
		RMDBGLOG((ENABLE, "Failed to read the bmp header\n"));
		return RM_ERROR;
	}


	/* check header and get colorspace */
	offs = 0;
	while (offs < 128) {
		if (header_buf[offs] == ' ')
			break;
		offs ++;
	}
	header_buf[offs] = '\0';
	if (! (RMMemcmp( header_buf, "YUV601", 6))) {
		profile->ColorSpace = EMhwlibColorSpace_YUV_601_0_255;
	}
	else if (! (RMMemcmp( header_buf, "YUV709", 6))) {
		profile->ColorSpace = EMhwlibColorSpace_YUV_709_0_255;
	}
	else {
		fprintf(stderr, "Cannot find YUV header");
		return RM_ERROR;
	}
		
	/* get width */
	marker = offs + 1;
	while (offs < 128) {
		if (header_buf[offs] == ' ')
			break;
		offs ++;
	}
	header_buf[offs] = '\0';
	width = strtol((RMascii *)header_buf + marker, 0, 0);
	
	/* get height */
	marker = offs + 1;
	while (offs < 128) {
		if (header_buf[offs] == '\n')
			break;
		offs ++;
	}
	header_buf[offs] = '\0';
	height = strtol((RMascii *)header_buf + marker, 0, 0);
	offs += 2;
	
	yuv_info->offset = offs;

	profile->SamplingMode = EMhwlibSamplingMode_422;
	profile->ColorMode = EMhwlibColorMode_VideoInterleaved;
	profile->ColorFormat = EMhwlibColorFormat_32BPP; /* unused */
	profile->PixelAspectRatio.X = 1;
	profile->PixelAspectRatio.Y = 1;
	profile->Width = yuv_info->width = width;
	profile->Height = yuv_info->height = height;
	return RM_OK;
}


static RMstatus yuv_to_raw(RMuint8 *luma, struct RMyuvInfo *yuv_info)
{
	RMuint64 size;
	RMuint32 read_size;
	RMstatus err;
	err = RMSeekFile(yuv_info->fp, yuv_info->offset, RM_FILE_SEEK_START);
	if(RMFAILED(err)){
		RMDBGLOG((ENABLE, "RMSeekFile failed\n"));
		return RM_ERROR;
	}

	size = yuv_info->width * yuv_info->height * 2;
	err = RMReadFile(yuv_info->fp, luma, size - yuv_info->offset, &read_size);
	if(RMFAILED(err)){
		RMDBGLOG((ENABLE, "RMReadFile failed\n"));
		return RM_ERROR;
	}

	return RM_OK;
}

static RMstatus open_gif_file(struct RMgifInfo *gif_info,  struct DCCOSDProfile *profile)
{
/* 	RMstatus err; */
/* 	RMuint16 row, column, i, j; */

	gif_info->gif_hdr = DGifOpen((void*)gif_info->fp, gif_read_data_rm_file);
	if(gif_info->gif_hdr == NULL)
		return RM_ERROR;

	profile->ColorSpace = EMhwlibColorSpace_RGB_0_255;
	profile->SamplingMode = EMhwlibSamplingMode_444;
	profile->ColorMode = EMhwlibColorMode_LUT_8BPP;
	profile->ColorFormat = EMhwlibColorFormat_32BPP;
	profile->PixelAspectRatio.X = 1;