image.c

基于Linux的ffmepg decoder

#include "../../fmpeg4_driver/fmpeg4.h"
#include <math.h>

#include "../portab.h"
//#include "../xvid.h"			// XVID_CSP_XXX's
#include "image.h"
//#include "../divx4.h"
//#include "../utils/mem_align.h"
#include "../define.h"

#define SAFETY	64
#define EDGE_SIZE2  (EDGE_SIZE/2)


unsigned int y_virt_sz=0,u_virt_sz=0,v_virt_sz=0;

#if 0
int32_t
image_create(IMAGE * image,
			 uint32_t edged_width,
			 uint32_t edged_height)
{
	const uint32_t edged_width2 = edged_width / 2;
	const uint32_t edged_height2 = edged_height / 2;

	image->y =
		malloc_align(edged_width * (edged_height + 1) + SAFETY, CACHE_LINE);
	if (image->y == NULL) {
		return -1;
	}
#ifdef fpga
//	for (i = 0; i < edged_width * edged_height + SAFETY; i++) {
//		image->y[i] = 0;
//	}
#endif

	image->u = malloc_align(edged_width2 * edged_height2 + 4*SAFETY, CACHE_LINE);
	if (image->u == NULL) {
		free_align(image->y);
		return -1;
	}
#ifdef fpga	
//	for (i = 0; i < edged_width2 * edged_height2 + 4*SAFETY; i++) {
//		image->u[i] = 0;
//	}
#endif

	image->v = malloc_align(edged_width2 * edged_height2 + 4*SAFETY, CACHE_LINE);
	if (image->v == NULL) {
		free_align(image->u);
		free_align(image->y);
		return -1;
	}
#ifdef fpga
//	for (i = 0; i < edged_width2 * edged_height2 + 4*SAFETY; i++) {
//		image->v[i] = 0;
//	}
#endif

	image->y += EDGE_SIZE * edged_width + EDGE_SIZE;
	image->u += EDGE_SIZE2 * edged_width2 + EDGE_SIZE2;
	image->v += EDGE_SIZE2 * edged_width2 + EDGE_SIZE2;

	return 0;
}



void
image_destroy(IMAGE * image,
			  uint32_t edged_width,
			  uint32_t edged_height)
{
	const uint32_t edged_width2 = edged_width / 2;

	if (image->y) {
		free_align(image->y - (EDGE_SIZE * edged_width + EDGE_SIZE));
	}
	if (image->u) {
		free_align(image->u - (EDGE_SIZE2 * edged_width2 + EDGE_SIZE2));
	}
	if (image->v) {
		free_align(image->v - (EDGE_SIZE2 * edged_width2 + EDGE_SIZE2));
	}
}
#endif
/*
size creat:

	  EDGE_SIZE		mb_width * PIXEL_Y
		    |	   /							      \
		/	\/								\
		-------------------------------------
		|	|								|\
		|	|								| EDGE_SIZE
		|	|								|/
		-------------------------------------
			|								|\
			|								| \
			|								|
			|								|
			|								|
			|								|
			|								|  mb_height * PIXEL_Y
			|								|
			|								|
			|								|
			|								| /
			|								|/
			-------------------------------------
			|								|	|\
			|								|	| EDGE_SIZE
			|								|	|/
			-------------------------------------
											\	/
											EDGE_SIZE

*/

int32_t
image_create(IMAGE * image,
			 uint32_t mbwidth,
			 uint32_t mbheight,
	 		DECODER * ptdec)
{
	DMA_MALLOC_PTR pfnDmaMalloc = ptdec->pfnDmaMalloc;
	DMA_FREE_PTR pfnDmaFree = ptdec->pfnDmaFree;
	uint8_t u8align = ptdec->u32CacheAlign;

#if 1
    y_virt_sz=mbwidth * (2 + mbheight)  * PIXEL_Y * PIXEL_Y+ 2 * EDGE_SIZE * EDGE_SIZE;
    image->y_virt=fmpeg4_mempool_alloc(y_virt_sz,&image->y_phy);
#else
	image->y_virt = (uint8_t *)pfnDmaMalloc(
				mbwidth * (2 + mbheight)  * PIXEL_Y * PIXEL_Y+ 2 * EDGE_SIZE * EDGE_SIZE,
				u8align, u8align, (void **)&image->y_phy);
#endif

	if (image->y_virt == NULL) {
		return -1;
	}

#if 1
    u_virt_sz=mbwidth * (2 + mbheight)  * PIXEL_U  * PIXEL_U + 2 * EDGE_SIZE2 * EDGE_SIZE2;
    image->u_virt=fmpeg4_mempool_alloc(u_virt_sz,&image->u_phy);
#else
	image->u_virt = (uint8_t *)pfnDmaMalloc(
				mbwidth * (2 + mbheight)  * PIXEL_U  * PIXEL_U + 2 * EDGE_SIZE2 * EDGE_SIZE2,
				u8align, u8align, (void **)&image->u_phy);
#endif


	if (image->u_virt == NULL) {
#if 1
        fmpeg4_mempool_free(image->y_virt,y_virt_sz);
#else	    
		pfnDmaFree(image->y_virt, image->y_phy);
#endif
		return -1;
	}

#if 1
    v_virt_sz=mbwidth * (2 + mbheight)  * PIXEL_V  * PIXEL_V + 2 * EDGE_SIZE2 * EDGE_SIZE2;
    image->v_virt=fmpeg4_mempool_alloc(v_virt_sz,&image->v_phy);
#else
	image->v_virt = (uint8_t *)pfnDmaMalloc(
				mbwidth * (2 + mbheight)  * PIXEL_V  * PIXEL_V + 2 * EDGE_SIZE2 * EDGE_SIZE2,
				u8align, u8align, (void **)&image->v_phy);
#endif

	if (image->v_virt == NULL) {
#if 1
        fmpeg4_mempool_free(image->y_virt,y_virt_sz);
        fmpeg4_mempool_free(image->u_virt,u_virt_sz);
#else
		pfnDmaFree(image->y_virt, image->y_phy);
		pfnDmaFree(image->u_virt, image->u_phy);
#endif
		return -1;
	}

	image->y_virt += mbwidth * PIXEL_Y * EDGE_SIZE + EDGE_SIZE * EDGE_SIZE;
	image->u_virt += mbwidth * PIXEL_U * EDGE_SIZE2 + EDGE_SIZE2 * EDGE_SIZE2;
	image->v_virt += mbwidth * PIXEL_V * EDGE_SIZE2 + EDGE_SIZE2 * EDGE_SIZE2;
	image->y_phy += mbwidth * PIXEL_Y * EDGE_SIZE + EDGE_SIZE * EDGE_SIZE;
	image->u_phy += mbwidth * PIXEL_U * EDGE_SIZE2 + EDGE_SIZE2 * EDGE_SIZE2;
	image->v_phy += mbwidth * PIXEL_V * EDGE_SIZE2 + EDGE_SIZE2 * EDGE_SIZE2;

	return 0;
}

void
image_destroy(IMAGE * image,
			uint32_t mbwidth,
	 		DECODER * ptdec)
{
	DMA_FREE_PTR pfnDmaFree = ptdec->pfnDmaFree;

	if (image->y_virt) {
#if 1
        fmpeg4_mempool_free(image->y_virt - (mbwidth * PIXEL_Y * EDGE_SIZE + EDGE_SIZE * EDGE_SIZE),y_virt_sz);
#else
		pfnDmaFree(image->y_virt - (mbwidth * PIXEL_Y * EDGE_SIZE + EDGE_SIZE * EDGE_SIZE),
				    image->y_phy- (mbwidth * PIXEL_Y * EDGE_SIZE + EDGE_SIZE * EDGE_SIZE));
#endif
	}
	if (image->u_virt) {
#if 1
        fmpeg4_mempool_free(image->u_virt - (mbwidth * PIXEL_U * EDGE_SIZE2 + EDGE_SIZE2 * EDGE_SIZE2),u_virt_sz);
#else
		pfnDmaFree(image->u_virt - (mbwidth * PIXEL_U * EDGE_SIZE2 + EDGE_SIZE2 * EDGE_SIZE2),
				   image->u_phy - (mbwidth * PIXEL_U * EDGE_SIZE2 + EDGE_SIZE2 * EDGE_SIZE2));
#endif
	}
	if (image->v_virt) {
#if 1
        fmpeg4_mempool_free(image->v_virt - (mbwidth * PIXEL_V * EDGE_SIZE2 + EDGE_SIZE2 * EDGE_SIZE2),v_virt_sz);
#else
		pfnDmaFree(image->v_virt - (mbwidth * PIXEL_V * EDGE_SIZE2 + EDGE_SIZE2 * EDGE_SIZE2),
				   image->v_phy - (mbwidth * PIXEL_V * EDGE_SIZE2 + EDGE_SIZE2 * EDGE_SIZE2));
#endif
	}
}

void
image_swap_dec(IMAGE * image1,
		   IMAGE * image2)
{
	uint8_t *tmp;

	tmp = image1->y_virt;
	image1->y_virt = image2->y_virt;
	image2->y_virt = tmp;

	tmp = image1->u_virt;
	image1->u_virt = image2->u_virt;
	image2->u_virt = tmp;

	tmp = image1->v_virt;
	image1->v_virt = image2->v_virt;
	image2->v_virt = tmp;

	tmp = image1->y_phy;
	image1->y_phy = image2->y_phy;
	image2->y_phy = tmp;

	tmp = image1->u_phy;
	image1->u_phy = image2->u_phy;
	image2->u_phy = tmp;

	tmp = image1->v_phy;
	image1->v_phy = image2->v_phy;
	image2->v_phy = tmp;
}

#if 0
void
image_copy(IMAGE * image1,
		   IMAGE * image2,
		   uint32_t edged_width,
		   uint32_t height)
{
	memcpy(image1->y, image2->y, edged_width * height);
	memcpy(image1->u, image2->u, edged_width * height / 4);
	memcpy(image1->v, image2->v, edged_width * height / 4);
}
#endif