do not hurt my eyes (Lindent)

3 files changed, 334 insertions, 275 deletions

diff --git a/src/vpu_io.c b/src/vpu_io.c
index 133a1b1..f3e5c7a 100644
--- a/src/vpu_io.c
+++ b/src/vpu_io.c
@@ -47,37 +47,44 @@ static unsigned long vpu_reg_base;
 
 static int vpu_platform;
 
-int platform_is_mx27to1()
+int
+platform_is_mx27to1()
 {
 	return (vpu_platform == MX27TO1_VPU);
 }
 
-int platform_is_mx27to2()
+int
+platform_is_mx27to2()
 {
 	return (vpu_platform == MX27TO2_VPU);
 }
 
-int platform_is_mx27()
+int
+platform_is_mx27()
 {
 	return (vpu_platform == MX27TO1_VPU || (vpu_platform == MX27TO2_VPU));
 }
 
-int platform_is_mx32()
+int
+platform_is_mx32()
 {
 	return (vpu_platform == MX32_VPU);
 }
 
-int platform_is_mxc30031()
+int
+platform_is_mxc30031()
 {
 	return (vpu_platform == MXC30031_VPU);
 }
 
-int isVpuInitialized(void)
+int
+isVpuInitialized(void)
 {
 	return VpuReadReg(BIT_CUR_PC) != 0;
 }
 
-static int get_platform_name()
+static int
+get_platform_name()
 {
 	FILE *fp;
 	char buf[1024];
@@ -91,9 +98,9 @@ static int get_platform_name()
 		return platform;
 	}
 
-	nread = fread(buf, 1, sizeof(buf), fp);
+	nread = fread(buf, 1, sizeof (buf), fp);
 	fclose(fp);
-	if ((nread == 0) || (nread == sizeof(buf))) {
+	if ((nread == 0) || (nread == sizeof (buf))) {
 		fclose(fp);
 		return platform;
 	}
@@ -132,9 +139,10 @@ static int get_platform_name()
 }
 
 /* make consideration for both register and physical mem access */
-inline unsigned long *reg_map(unsigned long offset)
+inline unsigned long *
+reg_map(unsigned long offset)
 {
-	return (unsigned long *)(offset + (unsigned long)vpu_reg_base);
+	return (unsigned long *) (offset + (unsigned long) vpu_reg_base);
 }
 
 /*!
@@ -151,7 +159,8 @@ inline unsigned long *reg_map(unsigned long offset)
  * @li  0	          System initialization success.
  * @li -1		System initialization failure.
  */
-int IOSystemInit(void *callback)
+int
+IOSystemInit(void *callback)
 {
 	vpu_platform = get_platform_name();
 	if (vpu_platform == -1) {
@@ -169,11 +178,11 @@ int IOSystemInit(void *callback)
 		return -1;
 	}
 
-	vpu_reg_base = (unsigned long)mmap(NULL, BIT_REG_MARGIN,
-					   PROT_READ | PROT_WRITE,
-					   MAP_SHARED, vpu_fd, 0);
+	vpu_reg_base = (unsigned long) mmap(NULL, BIT_REG_MARGIN,
+					    PROT_READ | PROT_WRITE,
+					    MAP_SHARED, vpu_fd, 0);
 
-	if ((void *)vpu_reg_base == MAP_FAILED) {
+	if ((void *) vpu_reg_base == MAP_FAILED) {
 		printf("Can't map register\n");
 		close(vpu_fd);
 		vpu_fd = -1;
@@ -181,7 +190,7 @@ int IOSystemInit(void *callback)
 	}
 
 	bit_work_addr.size = WORK_BUF_SIZE + PARA_BUF_SIZE +
-	    					CODE_BUF_SIZE + PARA_BUF2_SIZE;
+	    CODE_BUF_SIZE + PARA_BUF2_SIZE;
 
 	if (IOGetPhyMem(&bit_work_addr) != 0)
 		goto err;
@@ -213,7 +222,8 @@ int IOSystemInit(void *callback)
  * @li   0	System shutting down success.
  * @li   -1		System shutting down failure.
  */
-int IOSystemShutdown(void)
+int
+IOSystemShutdown(void)
 {
 	IOFreeVirtMem(&bit_work_addr);
 	IOFreePhyMem(&bit_work_addr);
@@ -222,7 +232,7 @@ int IOSystemShutdown(void)
 
 	VpuWriteReg(BIT_INT_ENABLE, 0);	/* PIC_RUN irq disable */
 
-	if (munmap((void *)vpu_reg_base, BIT_REG_MARGIN) != 0)
+	if (munmap((void *) vpu_reg_base, BIT_REG_MARGIN) != 0)
 		printf("munmap failed\n");
 
 	if (vpu_fd >= 0) {
@@ -233,18 +243,20 @@ int IOSystemShutdown(void)
 	return 0;
 }
 
-unsigned long VpuWriteReg(unsigned long addr, unsigned int data)
+unsigned long
+VpuWriteReg(unsigned long addr, unsigned int data)
 {
 	unsigned long *reg_addr = reg_map(addr);
-	*(volatile unsigned long *)reg_addr = data;
+	*(volatile unsigned long *) reg_addr = data;
 
 	return 0;
 }
 
-unsigned long VpuReadReg(unsigned long addr)
+unsigned long
+VpuReadReg(unsigned long addr)
 {
 	unsigned long *reg_addr = reg_map(addr);
-	return *(volatile unsigned long *)reg_addr;
+	return *(volatile unsigned long *) reg_addr;
 }
 
 /*!
@@ -265,21 +277,21 @@ unsigned long VpuReadReg(unsigned long addr)
  * @li -1		Allocation memory failure.
  */
 
-
-int IOGetPhyMem(vpu_mem_desc * buff)
+int
+IOGetPhyMem(vpu_mem_desc * buff)
 {
-	
+
 	if (ioctl(vpu_fd, VPU_IOC_PHYMEM_ALLOC, buff) < 0) {
-		
+
 		//printf("mem allocation failed!\n");
 		buff->phy_addr = 0;
 		buff->cpu_addr = 0;
 		//buff->phy_addr = 0xa0600000;
-		//buff->cpu_addr = 0xff64d000;		
+		//buff->cpu_addr = 0xff64d000;          
 		//return -1;
-		printf("\033[0;32m%s, %d  get phy memory failed! \n\33[0m", __FUNCTION__, __LINE__);
+		printf("\033[0;32m%s, %d  get phy memory failed! \n\33[0m",
+		       __FUNCTION__, __LINE__);
 	}
-
 	//printf("Get mem size=0x%16x phy_addr=0x%x,cpu_addr=0x%x\n", buff->size,buff->phy_addr,buff->cpu_addr);
 	//printf("\033[0;32m%s, %d  phy addr = 0x%08x \n\33[0m", __FUNCTION__, __LINE__,buff->phy_addr);
 	return 0;
@@ -297,7 +309,8 @@ int IOGetPhyMem(vpu_mem_desc * buff)
  * @li 0            Freeing memory success.
  * @li -1		Freeing memory failure.
  */
-int IOFreePhyMem(vpu_mem_desc * buff)
+int
+IOFreePhyMem(vpu_mem_desc * buff)
 {
 
 	//printf("\033[0;34m%s, %d  phy addr = 0x%08x \n\33[0m", __FUNCTION__, __LINE__,buff->phy_addr);
@@ -318,13 +331,14 @@ int IOFreePhyMem(vpu_mem_desc * buff)
  *
  * @return	user space address.
  */
-int IOGetVirtMem(vpu_mem_desc * buff)
+int
+IOGetVirtMem(vpu_mem_desc * buff)
 {
 	unsigned long va_addr;
 
-	va_addr = (unsigned long)mmap(NULL, buff->size, PROT_READ | PROT_WRITE,
-				      MAP_SHARED, vpu_fd, buff->phy_addr);
-	if ((void *)va_addr == MAP_FAILED) {
+	va_addr = (unsigned long) mmap(NULL, buff->size, PROT_READ | PROT_WRITE,
+				       MAP_SHARED, vpu_fd, buff->phy_addr);
+	if ((void *) va_addr == MAP_FAILED) {
 		buff->virt_uaddr = 0;
 		return -1;
 	}
@@ -342,10 +356,11 @@ int IOGetVirtMem(vpu_mem_desc * buff)
  * @li 0        Success
  * @li Others 	Failure
  */
-int IOFreeVirtMem(vpu_mem_desc * buff)
+int
+IOFreeVirtMem(vpu_mem_desc * buff)
 {
 	if (buff->virt_uaddr != 0) {
-		if (munmap((void *)buff->virt_uaddr, buff->size) != 0)
+		if (munmap((void *) buff->virt_uaddr, buff->size) != 0)
 			printf("munmap failed\n");
 	}
 
@@ -353,7 +368,8 @@ int IOFreeVirtMem(vpu_mem_desc * buff)
 	return 0;
 }
 
-int IOWaitForInt(int timeout_in_ms)
+int
+IOWaitForInt(int timeout_in_ms)
 {
 	int ret = 0;
 	if (timeout_in_ms < 0) {
@@ -365,7 +381,8 @@ int IOWaitForInt(int timeout_in_ms)
 	return ret;
 }
 
-void vl2cc_flush()
+void
+vl2cc_flush()
 {
 	ioctl(vpu_fd, VPU_IOC_VL2CC_FLUSH, NULL);
 }
@@ -374,13 +391,13 @@ void vl2cc_flush()
  * @brief
  * When the system starts up, resetting is needed in advance.
  */
-void ResetVpu(void)
+void
+ResetVpu(void)
 {
 	unsigned long *reg_addr = reg_map(BIT_CODE_RESET);
-	(*(volatile unsigned long *)reg_addr) |= 0x1;
+	(*(volatile unsigned long *) reg_addr) |= 0x1;
 	usleep(10);
-	(*(volatile unsigned long *)reg_addr) &= ~0x1;
+	(*(volatile unsigned long *) reg_addr) &= ~0x1;
 
 	return;
 }
-
diff --git a/src/vpu_lib.c b/src/vpu_lib.c
index 434eb4f..3407917 100644
--- a/src/vpu_lib.c
+++ b/src/vpu_lib.c
@@ -78,12 +78,14 @@ extern vpu_mem_desc bit_work_addr;
  * @li 0: VPU hardware is idle.
  * @li Non-zero value: VPU hardware is busy processing a frame.
  */
-int vpu_IsBusy()
+int
+vpu_IsBusy()
 {
 	return VpuReadReg(BIT_BUSY_FLAG) != 0;
 }
 
-int vpu_WaitForInt(int timeout_in_ms)
+int
+vpu_WaitForInt(int timeout_in_ms)
 {
 	return IOWaitForInt(timeout_in_ms);
 }
@@ -99,7 +101,8 @@ int vpu_WaitForInt(int timeout_in_ms)
  *
  * @return  This function always returns RETCODE_SUCCESS.
  */
-RetCode vpu_Init(PhysicalAddress workBuf)
+RetCode
+vpu_Init(PhysicalAddress workBuf)
 {
 	unsigned int i;
 	volatile Uint32 data;
@@ -111,25 +114,25 @@ RetCode vpu_Init(PhysicalAddress workBuf)
 	paraBuffer = workBuffer + WORK_BUF_SIZE + PARA_BUF2_SIZE;
 
 	virt_codeBuf = (Uint32) (bit_work_addr.virt_uaddr);
-	virt_paraBuf = (unsigned long *)(virt_codeBuf + CODE_BUF_SIZE +
-					 WORK_BUF_SIZE + PARA_BUF2_SIZE);
-	virt_paraBuf2 = (unsigned long *)(virt_codeBuf + CODE_BUF_SIZE +
-					  WORK_BUF_SIZE);
-	
+	virt_paraBuf = (unsigned long *) (virt_codeBuf + CODE_BUF_SIZE +
+					  WORK_BUF_SIZE + PARA_BUF2_SIZE);
+	virt_paraBuf2 = (unsigned long *) (virt_codeBuf + CODE_BUF_SIZE +
+					   WORK_BUF_SIZE);
+
 	/* Copy full Microcode to Code Buffer allocated on SDRAM */
 	if (platform_is_mx27to2()) {
-		for (i = 0; i < sizeof(bit_code2) / sizeof(bit_code2[0]); 
-								i += 2) {
-			data = (unsigned int)((bit_code2[i] << 16) | 
-							bit_code2[i + 1]);
-			((unsigned int *)virt_codeBuf)[i / 2] = data;
+		for (i = 0; i < sizeof (bit_code2) / sizeof (bit_code2[0]);
+		     i += 2) {
+			data = (unsigned int) ((bit_code2[i] << 16) |
+					       bit_code2[i + 1]);
+			((unsigned int *) virt_codeBuf)[i / 2] = data;
 		}
 	} else {
-		for (i = 0; i < sizeof(bit_code) / sizeof(bit_code[0]); 
-								i += 2) {
-			data = (unsigned int)((bit_code[i] << 16) | 
-							bit_code[i + 1]);
-			((unsigned int *)virt_codeBuf)[i / 2] = data;
+		for (i = 0; i < sizeof (bit_code) / sizeof (bit_code[0]);
+		     i += 2) {
+			data = (unsigned int) ((bit_code[i] << 16) |
+					       bit_code[i + 1]);
+			((unsigned int *) virt_codeBuf)[i / 2] = data;
 		}
 	}
 
@@ -144,7 +147,7 @@ RetCode vpu_Init(PhysicalAddress workBuf)
 			return RETCODE_SUCCESS;
 		}
 	}
-	
+
 	VpuWriteReg(BIT_CODE_RUN, 0);
 
 	/* Download BIT Microcode to Program Memory */
@@ -168,7 +171,7 @@ RetCode vpu_Init(PhysicalAddress workBuf)
 	VpuWriteReg(BIT_INT_ENABLE, 8);	/* PIC_RUN irq enable */
 
 	if (platform_is_mxc30031()) {
-		VpuWriteReg(BIT_VPU_PIC_COUNT, 0); /* Init VPU PIC COUNT */
+		VpuWriteReg(BIT_VPU_PIC_COUNT, 0);	/* Init VPU PIC COUNT */
 	}
 
 	if (platform_is_mx27()) {
@@ -176,7 +179,7 @@ RetCode vpu_Init(PhysicalAddress workBuf)
 	}
 
 	VpuWriteReg(BIT_CODE_RUN, 1);
-	
+
 	pCodecInst = &codecInstPool[0];
 	for (i = 0; i < MAX_NUM_INSTANCE; ++i, ++pCodecInst) {
 		pCodecInst->instIndex = i;
@@ -189,7 +192,8 @@ RetCode vpu_Init(PhysicalAddress workBuf)
 /*!
  * @brief Get VPU Firmware Version.
  */
-RetCode vpu_GetVersionInfo(vpu_versioninfo * verinfo)
+RetCode
+vpu_GetVersionInfo(vpu_versioninfo * verinfo)
 {
 	Uint32 ver;
 	Uint16 pn, version;
@@ -271,7 +275,8 @@ RetCode vpu_GetVersionInfo(vpu_versioninfo * verinfo)
  * passed does not satisfy conditions described in the paragraph for 
  * EncOpenParam type.
  */
-RetCode vpu_EncOpen(EncHandle * pHandle, EncOpenParam * pop)
+RetCode
+vpu_EncOpen(EncHandle * pHandle, EncOpenParam * pop)
 {
 	CodecInst *pCodecInst;
 	EncInfo *pEncInfo;
@@ -302,7 +307,7 @@ RetCode vpu_EncOpen(EncHandle * pHandle, EncOpenParam * pop)
 
 	pCodecInst->codecMode =
 	    pop->bitstreamFormat == STD_AVC ? AVC_ENC : MP4_ENC;
-	
+
 	pEncInfo->streamRdPtr = pop->bitstreamBuffer;
 	pEncInfo->streamRdPtrRegAddr = rdPtrRegAddr[instIdx];
 	pEncInfo->streamWrPtrRegAddr = wrPtrRegAddr[instIdx];
@@ -320,7 +325,7 @@ RetCode vpu_EncOpen(EncHandle * pHandle, EncOpenParam * pop)
 	pEncInfo->initialInfoObtained = 0;
 	pEncInfo->dynamicAllocEnable = pop->dynamicAllocEnable;
 	pEncInfo->ringBufferEnable = pop->ringBufferEnable;
-	
+
 	VpuWriteReg(pEncInfo->streamRdPtrRegAddr, pEncInfo->streamRdPtr);
 	VpuWriteReg(pEncInfo->streamWrPtrRegAddr, pEncInfo->streamBufStartAddr);
 
@@ -346,7 +351,8 @@ RetCode vpu_EncOpen(EncHandle * pHandle, EncOpenParam * pop)
  * @li RETCODE_INVALID_HANDLE encHandle is invalid. 
  * @li RETCODE_FRAME_NOT_COMPLETE A frame has not been finished.
  */
-RetCode vpu_EncClose(EncHandle handle)
+RetCode
+vpu_EncClose(EncHandle handle)
 {
 	CodecInst *pCodecInst;
 	EncInfo *pEncInfo;
@@ -388,7 +394,8 @@ RetCode vpu_EncClose(EncHandle handle)
  * @li RETCODE_FRAME_NOT_COMPLETE A frame has not been finished 
  * @li RETCODE_INVALID_PARAM initialInfo is a null pointer.
  */
-RetCode vpu_EncGetInitialInfo(EncHandle handle, EncInitialInfo * info)
+RetCode
+vpu_EncGetInitialInfo(EncHandle handle, EncInitialInfo * info)
 {
 	CodecInst *pCodecInst;
 	EncInfo *pEncInfo;
@@ -430,10 +437,10 @@ RetCode vpu_EncGetInitialInfo(EncHandle handle, EncInitialInfo * info)
 		data = encOP.EncStdParam.mp4Param.mp4_intraDcVlcThr << 2 |
 		    encOP.EncStdParam.mp4Param.mp4_reversibleVlcEnable << 1 |
 		    encOP.EncStdParam.mp4Param.mp4_dataPartitionEnable;
-		data |= ((encOP.EncStdParam.mp4Param.mp4_hecEnable > 0) 
-				? 1 : 0) << 5;
-		data |= ((encOP.EncStdParam.mp4Param.mp4_verid == 2) 
-				? 0 : 1) << 6;
+		data |= ((encOP.EncStdParam.mp4Param.mp4_hecEnable > 0)
+			 ? 1 : 0) << 5;
+		data |= ((encOP.EncStdParam.mp4Param.mp4_verid == 2)
+			 ? 0 : 1) << 6;
 		VpuWriteReg(CMD_ENC_SEQ_MP4_PARA, data);
 	} else if (encOP.bitstreamFormat == STD_H263) {
 		VpuWriteReg(CMD_ENC_SEQ_COD_STD, 1);
@@ -454,8 +461,8 @@ RetCode vpu_EncGetInitialInfo(EncHandle handle, EncInitialInfo * info)
 	}
 
 	data = encOP.slicemode.sliceSize << 2 |
-		encOP.slicemode.sliceSizeMode << 1 | encOP.slicemode.sliceMode;
-	
+	    encOP.slicemode.sliceSizeMode << 1 | encOP.slicemode.sliceMode;
+
 	VpuWriteReg(CMD_ENC_SEQ_SLICE_MODE, data);
 	VpuWriteReg(CMD_ENC_SEQ_GOP_NUM, encOP.gopSize);
 
@@ -475,12 +482,12 @@ RetCode vpu_EncGetInitialInfo(EncHandle handle, EncInitialInfo * info)
 
 	data = (encOP.sliceReport << 1) | encOP.mbReport;
 	data |= (encOP.mbQpReport << 3);
-	
+
 	if (encOP.rcIntraQp >= 0)
 		data |= (1 << 5);
-	
+
 	VpuWriteReg(CMD_ENC_SEQ_INTRA_QP, encOP.rcIntraQp);
-	
+
 	if (pCodecInst->codecMode == AVC_ENC) {
 		data |= (encOP.EncStdParam.avcParam.avc_audEnable << 2);
 		data |= (encOP.EncStdParam.avcParam.avc_fmoEnable << 4);
@@ -492,10 +499,10 @@ RetCode vpu_EncGetInitialInfo(EncHandle handle, EncInitialInfo * info)
 		data = (encOP.EncStdParam.avcParam.avc_fmoType << 4) |
 		    (encOP.EncStdParam.avcParam.avc_fmoSliceNum & 0x0f);
 		data |= (FMO_SLICE_SAVE_BUF_SIZE << 7);
-		
+
 	}
-		
-	VpuWriteReg(CMD_ENC_SEQ_FMO, data); /* FIXME */
+
+	VpuWriteReg(CMD_ENC_SEQ_FMO, data);	/* FIXME */
 
 	if (platform_is_mxc30031()) {
 		VpuWriteReg(BIT_FRAME_MEM_CTRL,
@@ -536,8 +543,9 @@ RetCode vpu_EncGetInitialInfo(EncHandle handle, EncInitialInfo * info)
  * @li RETCODE_INSUFFICIENT_FRAME_BUFFERS num is smaller than requested.
  * @li RETCODE_INVALID_STRIDE stride is smaller than the picture width.
  */
-RetCode vpu_EncRegisterFrameBuffer(EncHandle handle,
-				   FrameBuffer * bufArray, int num, int stride)
+RetCode
+vpu_EncRegisterFrameBuffer(EncHandle handle,
+			   FrameBuffer * bufArray, int num, int stride)
 {
 	CodecInst *pCodecInst;
 	EncInfo *pEncInfo;
@@ -598,9 +606,10 @@ RetCode vpu_EncRegisterFrameBuffer(EncHandle handle,
 	return RETCODE_SUCCESS;
 }
 
-RetCode vpu_EncGetBitstreamBuffer(EncHandle handle,
-				  PhysicalAddress * prdPrt,
-				  PhysicalAddress * pwrPtr, Uint32 * size)
+RetCode
+vpu_EncGetBitstreamBuffer(EncHandle handle,
+			  PhysicalAddress * prdPrt,
+			  PhysicalAddress * pwrPtr, Uint32 * size)
 {
 	CodecInst *pCodecInst;
 	EncInfo *pEncInfo;
@@ -643,7 +652,8 @@ RetCode vpu_EncGetBitstreamBuffer(EncHandle handle,
 	return RETCODE_SUCCESS;
 }
 
-RetCode vpu_EncUpdateBitstreamBuffer(EncHandle handle, Uint32 size)
+RetCode
+vpu_EncUpdateBitstreamBuffer(EncHandle handle, Uint32 size)
 {
 	CodecInst *pCodecInst;
 	EncInfo *pEncInfo;
@@ -679,7 +689,7 @@ RetCode vpu_EncUpdateBitstreamBuffer(EncHandle handle, Uint32 size)
 	} else {
 		rdPtr = pEncInfo->streamBufStartAddr;
 	}
-	
+
 	pEncInfo->streamRdPtr = rdPtr;
 
 	VpuWriteReg(pEncInfo->streamRdPtrRegAddr, rdPtr);
@@ -701,7 +711,8 @@ RetCode vpu_EncUpdateBitstreamBuffer(EncHandle handle, Uint32 size)
  * @li RETCODE_INVALID_FRAME_BUFFER skipPicture in EncParam is 0 
  * and sourceFrame in EncParam is a null pointer.
  */
-RetCode vpu_EncStartOneFrame(EncHandle handle, EncParam * param)
+RetCode
+vpu_EncStartOneFrame(EncHandle handle, EncParam * param)
 {
 	CodecInst *pCodecInst;
 	EncInfo *pEncInfo;
@@ -814,11 +825,11 @@ RetCode vpu_EncStartOneFrame(EncHandle handle, EncParam * param)
 			VpuWriteReg(BIT_VPU_PIC_COUNT, VPU_PIC_COUNT_DISABLE);
 		}
 	}
-	
+
 	if (pEncInfo->dynamicAllocEnable == 1) {
 		VpuWriteReg(CMD_ENC_PIC_BB_START, param->picStreamBufferAddr);
-		VpuWriteReg(CMD_ENC_PIC_BB_SIZE, 
-				param->picStreamBufferSize / 1024);
+		VpuWriteReg(CMD_ENC_PIC_BB_SIZE,
+			    param->picStreamBufferSize / 1024);
 	}
 
 	VpuWriteReg(BIT_BUSY_FLAG, 0x1);
@@ -841,7 +852,8 @@ RetCode vpu_EncStartOneFrame(EncHandle handle, EncParam * param)
  * @li RETCODE_WRONG_CALL_SEQUENCE Wrong calling sequence.
  * @li RETCODE_INVALID_PARAM info is a null pointer.
  */
-RetCode vpu_EncGetOutputInfo(EncHandle handle, EncOutputInfo * info)
+RetCode
+vpu_EncGetOutputInfo(EncHandle handle, EncOutputInfo * info)
 {
 	CodecInst *pCodecInst;
 	EncInfo *pEncInfo;
@@ -888,7 +900,7 @@ RetCode vpu_EncGetOutputInfo(EncHandle handle, EncOutputInfo * info)
 	info->bitstreamWrapAround = VpuReadReg(RET_ENC_PIC_FLAG);
 
 	if (pCodecInst->codecMode == MP4_ENC &&
-		    pEncInfo->openParam.mbQpReport == 1) {
+	    pEncInfo->openParam.mbQpReport == 1) {
 		int widthInMB;
 		int heightInMB;
 		PhysicalAddress readPnt;
@@ -942,7 +954,8 @@ RetCode vpu_EncGetOutputInfo(EncHandle handle, EncOutputInfo * info)
  * @li RETCODE_INVALID_HANDLE encHandle is invalid. 
  * @li RETCODE_FRAME_NOT_COMPLETE A frame has not been finished
  */
-RetCode vpu_EncGiveCommand(EncHandle handle, CodecCommand cmd, void *param)
+RetCode
+vpu_EncGiveCommand(EncHandle handle, CodecCommand cmd, void *param)
 {
 	CodecInst *pCodecInst;
 	EncInfo *pEncInfo;
@@ -1019,7 +1032,7 @@ RetCode vpu_EncGiveCommand(EncHandle handle, CodecCommand cmd, void *param)
 				return RETCODE_INVALID_PARAM;
 			}
 
-			angle = *(int *)param;
+			angle = *(int *) param;
 			if (angle != 0 && angle != 90 &&
 			    angle != 180 && angle != 270) {
 				return RETCODE_INVALID_PARAM;
@@ -1121,7 +1134,7 @@ RetCode vpu_EncGiveCommand(EncHandle handle, CodecCommand cmd, void *param)
 
 			if (platform_is_mxc30031()) {
 				if (scRamParam->SearchRamSize !=
-				    ((((EncPicX + 15) & ~15 ) * 36) + 2048)) {
+				    ((((EncPicX + 15) & ~15) * 36) + 2048)) {
 					return RETCODE_INVALID_PARAM;
 				}
 
@@ -1172,93 +1185,93 @@ RetCode vpu_EncGiveCommand(EncHandle handle, CodecCommand cmd, void *param)
 
 	case ENC_SET_GOP_NUMBER:
 		{
-			int *pGopNumber =(int *)param;
-			if (pCodecInst->codecMode != MP4_ENC && 
-				pCodecInst->codecMode != AVC_ENC ) {
+			int *pGopNumber = (int *) param;
+			if (pCodecInst->codecMode != MP4_ENC &&
+			    pCodecInst->codecMode != AVC_ENC) {
 				return RETCODE_INVALID_COMMAND;
 			}
 
-			if (*pGopNumber < 0 ||  *pGopNumber > 60) {
+			if (*pGopNumber < 0 || *pGopNumber > 60) {
 				return RETCODE_INVALID_PARAM;
 			}
-			
-			SetGopNumber(handle, (Uint32 *)pGopNumber); 
+
+			SetGopNumber(handle, (Uint32 *) pGopNumber);
 			break;
 		}
-		
+
 	case ENC_SET_INTRA_QP:
 		{
-			int *pIntraQp =(int *)param;
+			int *pIntraQp = (int *) param;
 			if (pCodecInst->codecMode != MP4_ENC &&
-					pCodecInst->codecMode != AVC_ENC ) {
+			    pCodecInst->codecMode != AVC_ENC) {
 				return RETCODE_INVALID_COMMAND;
 			}
 
 			if (pCodecInst->codecMode == MP4_ENC) {
-				if(*pIntraQp < 1 || *pIntraQp > 31)
+				if (*pIntraQp < 1 || *pIntraQp > 31)
 					return RETCODE_INVALID_PARAM;
 			}
 
 			if (pCodecInst->codecMode == AVC_ENC) {
-				if(*pIntraQp < 0 || *pIntraQp > 51)
+				if (*pIntraQp < 0 || *pIntraQp > 51)
 					return RETCODE_INVALID_PARAM;
 			}
-			SetIntraQp(handle, (Uint32 *)pIntraQp);
+			SetIntraQp(handle, (Uint32 *) pIntraQp);
 			break;
 		}
 
 	case ENC_SET_BITRATE:
 		{
-			int *pBitrate = (int *)param;
-			if (pCodecInst->codecMode != MP4_ENC && 
-					pCodecInst->codecMode != AVC_ENC ) {
+			int *pBitrate = (int *) param;
+			if (pCodecInst->codecMode != MP4_ENC &&
+			    pCodecInst->codecMode != AVC_ENC) {
 				return RETCODE_INVALID_COMMAND;
 			}
-			
-			if (*pBitrate < 0 || *pBitrate> 32767) {
+
+			if (*pBitrate < 0 || *pBitrate > 32767) {
 				return RETCODE_INVALID_PARAM;
 			}
-			
-			SetBitrate(handle, (Uint32 *)pBitrate);
+
+			SetBitrate(handle, (Uint32 *) pBitrate);
 			break;
 		}
 
 	case ENC_SET_FRAME_RATE:
 		{
-			int *pFramerate = (int *)param;
-			if (pCodecInst->codecMode != MP4_ENC && 
-					pCodecInst->codecMode != AVC_ENC ) {
+			int *pFramerate = (int *) param;
+			if (pCodecInst->codecMode != MP4_ENC &&
+			    pCodecInst->codecMode != AVC_ENC) {
 				return RETCODE_INVALID_COMMAND;
 			}
 
 			if (*pFramerate <= 0) {
 				return RETCODE_INVALID_PARAM;
 			}
-			SetFramerate(handle, (Uint32 *)pFramerate);
+			SetFramerate(handle, (Uint32 *) pFramerate);
 			break;
 		}
 
 	case ENC_SET_INTRA_MB_REFRESH_NUMBER:
 		{
-			int *pIntraRefreshNum =(int *)param;
-			SetIntraRefreshNum(handle, (Uint32 *)pIntraRefreshNum);
+			int *pIntraRefreshNum = (int *) param;
+			SetIntraRefreshNum(handle, (Uint32 *) pIntraRefreshNum);
 			break;
 		}
 
 	case ENC_SET_SLICE_INFO:
 		{
-			EncSliceMode *pSliceMode = (EncSliceMode *)param;
-			if (pSliceMode->sliceMode < 0 || 
-					pSliceMode->sliceMode > 1) {
+			EncSliceMode *pSliceMode = (EncSliceMode *) param;
+			if (pSliceMode->sliceMode < 0 ||
+			    pSliceMode->sliceMode > 1) {
 				return RETCODE_INVALID_PARAM;
 			}
 
-			if (pSliceMode->sliceSizeMode < 0 
-					|| pSliceMode->sliceSizeMode > 1) {
+			if (pSliceMode->sliceSizeMode < 0
+			    || pSliceMode->sliceSizeMode > 1) {
 				return RETCODE_INVALID_PARAM;
 			}
 
-			SetSliceMode(handle, (EncSliceMode *)pSliceMode);
+			SetSliceMode(handle, (EncSliceMode *) pSliceMode);
 			break;
 		}
 
@@ -1271,13 +1284,13 @@ RetCode vpu_EncGiveCommand(EncHandle handle, CodecCommand cmd, void *param)
 			SetHecMode(handle, 1);
 			break;
 		}
-		
+
 	case ENC_DISABLE_HEC:
 		{
 			if (pCodecInst->codecMode != MP4_ENC) {
 				return RETCODE_INVALID_COMMAND;
 			}
-			
+
 			SetHecMode(handle, 0);
 			break;
 		}
@@ -1301,7 +1314,8 @@ RetCode vpu_EncGiveCommand(EncHandle handle, CodecCommand cmd, void *param)
  * @li RETCODE_FAILURE Failed in acquisition of a decoder instance. 
  * @li RETCODE_INVALID_PARAM pop is a null pointer or invalid.
  */
-RetCode vpu_DecOpen(DecHandle * pHandle, DecOpenParam * pop)
+RetCode
+vpu_DecOpen(DecHandle * pHandle, DecOpenParam * pop)
 {
 	CodecInst *pCodecInst;
 	DecInfo *pDecInfo;
@@ -1383,7 +1397,8 @@ RetCode vpu_DecOpen(DecHandle * pHandle, DecOpenParam * pop)
  * @li RETCODE_INVALID_HANDLE decHandle is invalid. 
  * @li RETCODE_FRAME_NOT_COMPLETE A frame has not been finished.
  */
-RetCode vpu_DecClose(DecHandle handle)
+RetCode
+vpu_DecClose(DecHandle handle)
 {
 	CodecInst *pCodecInst;
 	DecInfo *pDecInfo;
@@ -1410,7 +1425,8 @@ RetCode vpu_DecClose(DecHandle handle)
 	return RETCODE_SUCCESS;
 }
 
-RetCode vpu_DecSetEscSeqInit(DecHandle handle, int escape)
+RetCode
+vpu_DecSetEscSeqInit(DecHandle handle, int escape)
 {
 	CodecInst *pCodecInst;
 	DecInfo *pDecInfo;
@@ -1442,7 +1458,8 @@ RetCode vpu_DecSetEscSeqInit(DecHandle handle, int escape)
  * @li RETCODE_FRAME_NOT_COMPLETE A frame has not been finished.
  * @li RETCODE_WRONG_CALL_SEQUENCE Wrong calling sequence.
  */
-RetCode vpu_DecGetInitialInfo(DecHandle handle, DecInitialInfo * info)
+RetCode
+vpu_DecGetInitialInfo(DecHandle handle, DecInitialInfo * info)
 {
 	CodecInst *pCodecInst;
 	DecInfo *pDecInfo;
@@ -1477,14 +1494,14 @@ RetCode vpu_DecGetInitialInfo(DecHandle handle, DecInitialInfo * info)
 	VpuWriteReg(CMD_DEC_SEQ_BB_SIZE, pDecInfo->streamBufSize / 1024);
 
 	if (pDecInfo->filePlayEnable == 1) {
-		VpuWriteReg(CMD_DEC_SEQ_START_BYTE, 
-				pDecInfo->openParam.streamStartByteOffset);
+		VpuWriteReg(CMD_DEC_SEQ_START_BYTE,
+			    pDecInfo->openParam.streamStartByteOffset);
 	}
 
-	val = ((pDecInfo->dynamicAllocEnable << 3) & 0x8) | 
-		((pDecInfo->filePlayEnable << 2) & 0x4) | 
-		((pDecInfo->openParam.reorderEnable << 1) & 0x2);
-	
+	val = ((pDecInfo->dynamicAllocEnable << 3) & 0x8) |
+	    ((pDecInfo->filePlayEnable << 2) & 0x4) |
+	    ((pDecInfo->openParam.reorderEnable << 1) & 0x2);
+
 	if (platform_is_mx27()) {
 		val |= (pDecInfo->openParam.qpReport & 0x1);
 	} else {
@@ -1499,11 +1516,12 @@ RetCode vpu_DecGetInitialInfo(DecHandle handle, DecInitialInfo * info)
 			     IMAGE_ENDIAN));
 	} else {
 		if (pCodecInst->codecMode == AVC_DEC) {
-			VpuWriteReg(CMD_DEC_SEQ_PS_BB_START, 
-					pDecInfo->openParam.psSaveBuffer);
+			VpuWriteReg(CMD_DEC_SEQ_PS_BB_START,
+				    pDecInfo->openParam.psSaveBuffer);
 			VpuWriteReg(CMD_DEC_SEQ_PS_BB_SIZE,
-				(pDecInfo->openParam.psSaveBufferSize / 1024));
-		}			
+				    (pDecInfo->openParam.psSaveBufferSize /
+				     1024));
+		}
 	}
 
 	VpuWriteReg(CMD_DEC_SEQ_SRC_SIZE, pDecInfo->picSrcSize);
@@ -1519,7 +1537,7 @@ RetCode vpu_DecGetInitialInfo(DecHandle handle, DecInitialInfo * info)
 	val = VpuReadReg(RET_DEC_SEQ_SRC_SIZE);
 	info->picWidth = ((val >> 10) & 0x3ff);
 	info->picHeight = (val & 0x3ff);
-	
+
 	val = VpuReadReg(RET_DEC_SEQ_SRC_F_RATE);
 	info->frameRateInfo = val;
 
@@ -1537,12 +1555,12 @@ RetCode vpu_DecGetInitialInfo(DecHandle handle, DecInitialInfo * info)
 
 	/* Not for mxc30031.. */
 	if (!platform_is_mxc30031()) {
-		info->nextDecodedIdxNum = 
-			VpuReadReg(RET_DEC_SEQ_NEXT_FRAME_NUM);
+		info->nextDecodedIdxNum =
+		    VpuReadReg(RET_DEC_SEQ_NEXT_FRAME_NUM);
 	}
 
 	if (pCodecInst->codecMode == AVC_DEC) {
-		val = VpuReadReg(RET_DEC_SEQ_CROP_LEFT_RIGHT);	
+		val = VpuReadReg(RET_DEC_SEQ_CROP_LEFT_RIGHT);
 		val2 = VpuReadReg(RET_DEC_SEQ_CROP_TOP_BOTTOM);
 		if (val == 0 && val2 == 0) {
 			info->picCropRect.left = 0;
@@ -1550,14 +1568,12 @@ RetCode vpu_DecGetInitialInfo(DecHandle handle, DecInitialInfo * info)
 			info->picCropRect.top = 0;
 			info->picCropRect.bottom = 0;
 		} else {
-			info->picCropRect.left = 
-				((val >> 10) & 0x3FF) * 2;
-			info->picCropRect.right = 
-				info->picWidth - ((val & 0x3FF ) * 2);
-			info->picCropRect.top = 
-				((val2>>10) & 0x3FF )*2;
-			info->picCropRect.bottom = 
-				info->picHeight - ((val2 & 0x3FF ) *2);
+			info->picCropRect.left = ((val >> 10) & 0x3FF) * 2;
+			info->picCropRect.right =
+			    info->picWidth - ((val & 0x3FF) * 2);
+			info->picCropRect.top = ((val2 >> 10) & 0x3FF) * 2;
+			info->picCropRect.bottom =
+			    info->picHeight - ((val2 & 0x3FF) * 2);
 		}
 
 		val = (info->picWidth * info->picHeight * 3 / 2) / 1024;
@@ -1589,9 +1605,10 @@ RetCode vpu_DecGetInitialInfo(DecHandle handle, DecInitialInfo * info)
  * the value requested by vpu_DecGetInitialInfo().
  * @li RETCODE_INVALID_STRIDE stride is less than the picture width.
  */
-RetCode vpu_DecRegisterFrameBuffer(DecHandle handle,
-				   FrameBuffer * bufArray, int num, int stride,
-				   DecBufInfo *pBufInfo)
+RetCode
+vpu_DecRegisterFrameBuffer(DecHandle handle,
+			   FrameBuffer * bufArray, int num, int stride,
+			   DecBufInfo * pBufInfo)
 {
 	CodecInst *pCodecInst;
 	DecInfo *pDecInfo;
@@ -1639,16 +1656,17 @@ RetCode vpu_DecRegisterFrameBuffer(DecHandle handle,
 		virt_paraBuf[i * 3 + 1] = bufArray[i].bufCb;
 		virt_paraBuf[i * 3 + 2] = bufArray[i].bufCr;
 	}
-	
+
 	/* Tell the decoder how much frame buffers were allocated. */
 	VpuWriteReg(CMD_SET_FRAME_BUF_NUM, num);
 	VpuWriteReg(CMD_SET_FRAME_BUF_STRIDE, stride);
 
 	if ((!platform_is_mxc30031()) && (pCodecInst->codecMode == AVC_DEC)) {
-		VpuWriteReg(CMD_SET_FRAME_SLICE_BB_START, 
-				pBufInfo->avcSliceBufInfo.sliceSaveBuffer);
-		VpuWriteReg(CMD_SET_FRAME_SLICE_BB_SIZE, 
-			(pBufInfo->avcSliceBufInfo.sliceSaveBufferSize / 1024));
+		VpuWriteReg(CMD_SET_FRAME_SLICE_BB_START,
+			    pBufInfo->avcSliceBufInfo.sliceSaveBuffer);
+		VpuWriteReg(CMD_SET_FRAME_SLICE_BB_SIZE,
+			    (pBufInfo->avcSliceBufInfo.sliceSaveBufferSize /
+			     1024));
 	}
 
 	VpuWriteReg(BIT_BUSY_FLAG, 0x1);
@@ -1672,9 +1690,10 @@ RetCode vpu_DecRegisterFrameBuffer(DecHandle handle,
  * @li RETCODE_INVALID_HANDLE decHandle is invalid. 
  * @li RETCODE_INVALID_PARAM buf or size is invalid.
  */
-RetCode vpu_DecGetBitstreamBuffer(DecHandle handle,
-				  PhysicalAddress * paRdPtr,
-				  PhysicalAddress * paWrPtr, Uint32 * size)
+RetCode
+vpu_DecGetBitstreamBuffer(DecHandle handle,
+			  PhysicalAddress * paRdPtr,
+			  PhysicalAddress * paWrPtr, Uint32 * size)
 {
 	CodecInst *pCodecInst;
 	DecInfo *pDecInfo;
@@ -1693,7 +1712,7 @@ RetCode vpu_DecGetBitstreamBuffer(DecHandle handle,
 
 	pCodecInst = handle;
 	pDecInfo = &pCodecInst->CodecInfo.decInfo;
-	
+
 	rdPtr = VpuReadReg(pDecInfo->streamRdPtrRegAddr);
 	wrPtr = pDecInfo->streamWrPtr;
 
@@ -1722,7 +1741,8 @@ RetCode vpu_DecGetBitstreamBuffer(DecHandle handle,
  * @li RETCODE_INVALID_HANDLE decHandle is invalid.
  * @li RETCODE_INVALID_PARAM Invalid input parameters.
  */
-RetCode vpu_DecUpdateBitstreamBuffer(DecHandle handle, Uint32 size)
+RetCode
+vpu_DecUpdateBitstreamBuffer(DecHandle handle, Uint32 size)
 {
 	CodecInst *pCodecInst;
 	DecInfo *pDecInfo;
@@ -1783,7 +1803,8 @@ RetCode vpu_DecUpdateBitstreamBuffer(DecHandle handle, Uint32 size)
  * @li RETCODE_FRAME_NOT_COMPLETE A frame has not been finished.
  * @li RETCODE_WRONG_CALL_SEQUENCE Wrong calling sequence.
  */
-RetCode vpu_DecStartOneFrame(DecHandle handle, DecParam * param)
+RetCode
+vpu_DecStartOneFrame(DecHandle handle, DecParam * param)
 {
 	CodecInst *pCodecInst;
 	DecInfo *pDecInfo;
@@ -1871,14 +1892,14 @@ RetCode vpu_DecStartOneFrame(DecHandle handle, DecParam * param)
 		    pDecInfo->openParam.mp4DeblkEnable == 1) {
 			if (pDecInfo->deBlockingFilterOutputValid) {
 				VpuWriteReg(CMD_DEC_PIC_DBK_ADDR_Y,
-					    pDecInfo->deBlockingFilterOutput.
-					    bufY);
+					    pDecInfo->
+					    deBlockingFilterOutput.bufY);
 				VpuWriteReg(CMD_DEC_PIC_DBK_ADDR_CB,
-					    pDecInfo->deBlockingFilterOutput.
-					    bufCb);
+					    pDecInfo->
+					    deBlockingFilterOutput.bufCb);
 				VpuWriteReg(CMD_DEC_PIC_DBK_ADDR_CR,
-					    pDecInfo->deBlockingFilterOutput.
-					    bufCr);
+					    pDecInfo->
+					    deBlockingFilterOutput.bufCr);
 			} else
 				return RETCODE_DEBLOCKING_OUTPUT_NOT_SET;
 		}
@@ -1908,16 +1929,16 @@ RetCode vpu_DecStartOneFrame(DecHandle handle, DecParam * param)
 	if (pCodecInst->codecMode == AVC_DEC) {
 		if (pDecInfo->openParam.reorderEnable == 1) {
 			VpuWriteReg(CMD_DEC_DISPLAY_REORDER,
-					param->dispReorderBuf << 1 |
-					VpuReadReg(CMD_DEC_DISPLAY_REORDER));
+				    param->dispReorderBuf << 1 |
+				    VpuReadReg(CMD_DEC_DISPLAY_REORDER));
 		}
 	}
 
 	if (!platform_is_mx27() && (pCodecInst->codecMode == VC1_DEC)) {
 		if (pDecInfo->filePlayEnable == 1) {
-				VpuWriteReg(CMD_DEC_DISPLAY_REORDER,
-					param->dispReorderBuf << 1 |
-					VpuReadReg(CMD_DEC_DISPLAY_REORDER));
+			VpuWriteReg(CMD_DEC_DISPLAY_REORDER,
+				    param->dispReorderBuf << 1 |
+				    VpuReadReg(CMD_DEC_DISPLAY_REORDER));
 		}
 	}
 
@@ -1950,7 +1971,8 @@ RetCode vpu_DecStartOneFrame(DecHandle handle, DecParam * param)
  * @li RETCODE_WRONG_CALL_SEQUENCE Wrong calling sequence.
  * @li RETCODE_INVALID_PARAM Info is an invalid pointer.
  */
-RetCode vpu_DecGetOutputInfo(DecHandle handle, DecOutputInfo * info)
+RetCode
+vpu_DecGetOutputInfo(DecHandle handle, DecOutputInfo * info)
 {
 	CodecInst *pCodecInst;
 	DecInfo *pDecInfo;
@@ -1979,14 +2001,14 @@ RetCode vpu_DecGetOutputInfo(DecHandle handle, DecOutputInfo * info)
 	if (platform_is_mx32()) {
 		vl2cc_flush();
 	}
-	
+
 	if (!platform_is_mxc30031()) {
-		info->notSufficientPsBuffer = 
-			(VpuReadReg(RET_DEC_PIC_SUCCESS) >> 3) & 0x1;
-		info->notSufficientSliceBuffer = 
-			(VpuReadReg(RET_DEC_PIC_SUCCESS) >> 2) & 0x1;
+		info->notSufficientPsBuffer =
+		    (VpuReadReg(RET_DEC_PIC_SUCCESS) >> 3) & 0x1;
+		info->notSufficientSliceBuffer =
+		    (VpuReadReg(RET_DEC_PIC_SUCCESS) >> 2) & 0x1;
 	}
-		
+
 	if ((VpuReadReg(RET_DEC_PIC_SUCCESS) & 0x01) == 0) {
 		pendingInst = 0;
 		return RETCODE_FAILURE;
@@ -2001,13 +2023,13 @@ RetCode vpu_DecGetOutputInfo(DecHandle handle, DecOutputInfo * info)
 	if (!platform_is_mxc30031()) {
 		int i;
 		val = VpuReadReg(RET_DEC_PIC_NEXT_IDX);
-		
-		for (i = 0 ; i < 3 ; i++) {
+
+		for (i = 0; i < 3; i++) {
 			if (i < pDecInfo->initialInfo.nextDecodedIdxNum) {
-					info->indexFrameNextDecoded[i] = 
-						((val >> (i * 5)) & 0x1f);
-				} else {
-					info->indexFrameNextDecoded[i] = -1;
+				info->indexFrameNextDecoded[i] =
+				    ((val >> (i * 5)) & 0x1f);
+			} else {
+				info->indexFrameNextDecoded[i] = -1;
 			}
 		}
 	}
@@ -2021,7 +2043,7 @@ RetCode vpu_DecGetOutputInfo(DecHandle handle, DecOutputInfo * info)
 			}
 		}
 	}
-	
+
 	if (platform_is_mx27()) {
 		if (pCodecInst->codecMode == MP4_DEC &&
 		    pDecInfo->openParam.qpReport == 1) {
@@ -2064,7 +2086,7 @@ RetCode vpu_DecGetOutputInfo(DecHandle handle, DecOutputInfo * info)
 
 		if (pDecInfo->vpuCountEnable == 1) {
 			info->DecVpuCount = (VpuReadReg(BIT_VPU_PIC_COUNT)) &
-								    0x7FFFFFFF;
+			    0x7FFFFFFF;
 		}
 	}
 
@@ -2072,7 +2094,8 @@ RetCode vpu_DecGetOutputInfo(DecHandle handle, DecOutputInfo * info)
 	return RETCODE_SUCCESS;
 }
 
-RetCode vpu_DecBitBufferFlush(DecHandle handle)
+RetCode
+vpu_DecBitBufferFlush(DecHandle handle)
 {
 	CodecInst *pCodecInst;
 	DecInfo *pDecInfo;
@@ -2118,7 +2141,8 @@ RetCode vpu_DecBitBufferFlush(DecHandle handle)
  * @li RETCODE_INVALID_HANDLE decHandle is invalid. 
  * @li RETCODE_FRAME_NOT_COMPLETE A frame has not been finished.
  */
-RetCode vpu_DecGiveCommand(DecHandle handle, CodecCommand cmd, void *param)
+RetCode
+vpu_DecGiveCommand(DecHandle handle, CodecCommand cmd, void *param)
 {
 	CodecInst *pCodecInst;
 	DecInfo *pDecInfo;
@@ -2149,7 +2173,7 @@ RetCode vpu_DecGiveCommand(DecHandle handle, CodecCommand cmd, void *param)
 
 	pCodecInst = handle;
 	pDecInfo = &pCodecInst->CodecInfo.decInfo;
-	
+
 	switch (cmd) {
 	case ENABLE_ROTATION:
 		{
@@ -2210,7 +2234,7 @@ RetCode vpu_DecGiveCommand(DecHandle handle, CodecCommand cmd, void *param)
 			if (param == 0) {
 				return RETCODE_INVALID_PARAM;
 			}
-			angle = *(int *)param;
+			angle = *(int *) param;
 			if (angle != 0 && angle != 90 &&
 			    angle != 180 && angle != 270) {
 				return RETCODE_INVALID_PARAM;
@@ -2254,7 +2278,7 @@ RetCode vpu_DecGiveCommand(DecHandle handle, CodecCommand cmd, void *param)
 			if (param == 0) {
 				return RETCODE_INVALID_PARAM;
 			}
-			stride = *(int *)param;
+			stride = *(int *) param;
 			if (stride % 8 != 0 || stride == 0) {
 				return RETCODE_INVALID_STRIDE;
 			}
@@ -2316,7 +2340,8 @@ RetCode vpu_DecGiveCommand(DecHandle handle, CodecCommand cmd, void *param)
 	return RETCODE_SUCCESS;
 }
 
-void SaveGetEncodeHeader(EncHandle handle, int encHeaderType, char *filename)
+void
+SaveGetEncodeHeader(EncHandle handle, int encHeaderType, char *filename)
 {
 	FILE *fp = NULL;
 	Uint8 *pHeader = NULL;
@@ -2331,7 +2356,7 @@ void SaveGetEncodeHeader(EncHandle handle, int encHeaderType, char *filename)
 
 	vpu_EncGiveCommand(handle, encHeaderType, &encHeaderParam);
 	byteSize = ((encHeaderParam.size + 3) & ~3);
-	pHeader = (Uint8 *) malloc(sizeof(Uint8) * byteSize);
+	pHeader = (Uint8 *) malloc(sizeof (Uint8) * byteSize);
 	if (pHeader) {
 		memcpy(pHeader, encHeaderParam.paraSet, byteSize);
 
@@ -2349,7 +2374,7 @@ void SaveGetEncodeHeader(EncHandle handle, int encHeaderType, char *filename)
 		if (encHeaderParam.size > 0) {
 			fp = fopen(filename, "wb");
 			if (fp) {
-				fwrite(pHeader, sizeof(Uint8),
+				fwrite(pHeader, sizeof (Uint8),
 				       encHeaderParam.size, fp);
 				fclose(fp);
 			}
@@ -2359,8 +2384,9 @@ void SaveGetEncodeHeader(EncHandle handle, int encHeaderType, char *filename)
 	}
 }
 
-void SaveQpReport(PhysicalAddress qpReportAddr, int picWidth, int picHeight,
-		  int frameIdx, char *fileName)
+void
+SaveQpReport(PhysicalAddress qpReportAddr, int picWidth, int picHeight,
+	     int frameIdx, char *fileName)
 {
 	FILE *fp;
 	int i, j;
@@ -2412,4 +2438,3 @@ void SaveQpReport(PhysicalAddress qpReportAddr, int picWidth, int picHeight,
 
 	fclose(fp);
 }
-
diff --git a/src/vpu_util.c b/src/vpu_util.c
index c57a27d..479418d 100644
--- a/src/vpu_util.c
+++ b/src/vpu_util.c
@@ -35,7 +35,8 @@ extern unsigned long *virt_paraBuf2;
  * and returns RETCODE_SUCCESS on success.
  * Failure results in 0(null pointer) in *ppInst and RETCODE_FAILURE.
  */
-RetCode GetCodecInstance(CodecInst ** ppInst)
+RetCode
+GetCodecInstance(CodecInst ** ppInst)
 {
 	int i;
 	CodecInst *pCodecInst;
@@ -52,14 +53,15 @@ RetCode GetCodecInstance(CodecInst ** ppInst)
 	}
 
 	i = pCodecInst->instIndex;
-	memset(pCodecInst, 0, sizeof(CodecInst));
+	memset(pCodecInst, 0, sizeof (CodecInst));
 	pCodecInst->instIndex = i;
 	pCodecInst->inUse = 1;
 	*ppInst = pCodecInst;
 	return RETCODE_SUCCESS;
 }
 
-RetCode CheckInstanceValidity(CodecInst * pci)
+RetCode
+CheckInstanceValidity(CodecInst * pci)
 {
 	CodecInst *pCodecInst;
 	int i;
@@ -72,7 +74,8 @@ RetCode CheckInstanceValidity(CodecInst * pci)
 	return RETCODE_INVALID_HANDLE;
 }
 
-RetCode CheckEncInstanceValidity(EncHandle handle)
+RetCode
+CheckEncInstanceValidity(EncHandle handle)
 {
 	CodecInst *pCodecInst;
 	RetCode ret;
@@ -96,7 +99,8 @@ RetCode CheckEncInstanceValidity(EncHandle handle)
 	return RETCODE_SUCCESS;
 }
 
-RetCode CheckDecInstanceValidity(DecHandle handle)
+RetCode
+CheckDecInstanceValidity(DecHandle handle)
 {
 	CodecInst *pCodecInst;
 	RetCode ret;
@@ -117,19 +121,22 @@ RetCode CheckDecInstanceValidity(DecHandle handle)
 	return RETCODE_SUCCESS;
 }
 
-void FreeCodecInstance(CodecInst * pCodecInst)
+void
+FreeCodecInstance(CodecInst * pCodecInst)
 {
 	pCodecInst->inUse = 0;
 }
 
-void BitIssueCommand(int instIdx, int cdcMode, int cmd)
+void
+BitIssueCommand(int instIdx, int cdcMode, int cmd)
 {
 	VpuWriteReg(BIT_RUN_INDEX, instIdx);
 	VpuWriteReg(BIT_RUN_COD_STD, cdcMode);
 	VpuWriteReg(BIT_RUN_COMMAND, cmd);
 }
 
-RetCode CheckEncOpenParam(EncOpenParam * pop)
+RetCode
+CheckEncOpenParam(EncOpenParam * pop)
 {
 	int picWidth;
 	int picHeight;
@@ -176,8 +183,8 @@ RetCode CheckEncOpenParam(EncOpenParam * pop)
 		return RETCODE_INVALID_PARAM;
 	}
 	if (pop->slicemode.sliceMode == 1) {
-		if (pop->slicemode.sliceSizeMode != 0 && 
-				pop->slicemode.sliceSizeMode != 1) {
+		if (pop->slicemode.sliceSizeMode != 0 &&
+		    pop->slicemode.sliceSizeMode != 1) {
 			return RETCODE_INVALID_PARAM;
 		}
 		if (pop->slicemode.sliceSize == 0) {
@@ -266,8 +273,7 @@ RetCode CheckEncOpenParam(EncOpenParam * pop)
 			return RETCODE_INVALID_PARAM;
 		}
 		if (param->avc_fmoEnable == 1) {
-			if (param->avc_fmoType != 0 && 
-					param->avc_fmoType != 1) {
+			if (param->avc_fmoType != 0 && param->avc_fmoType != 1) {
 				return RETCODE_INVALID_PARAM;
 			}
 			if (param->avc_fmoSliceNum < 2 ||
@@ -287,7 +293,8 @@ RetCode CheckEncOpenParam(EncOpenParam * pop)
 	return RETCODE_SUCCESS;
 }
 
-RetCode CheckEncParam(CodecInst * pCodecInst, EncParam * param)
+RetCode
+CheckEncParam(CodecInst * pCodecInst, EncParam * param)
 {
 	if (param == 0) {
 		return RETCODE_INVALID_PARAM;
@@ -319,7 +326,8 @@ RetCode CheckEncParam(CodecInst * pCodecInst, EncParam * param)
 	return RETCODE_SUCCESS;
 }
 
-void EncodeHeader(EncHandle handle, EncHeaderParam * encHeaderParam)
+void
+EncodeHeader(EncHandle handle, EncHeaderParam * encHeaderParam)
 {
 	CodecInst *pCodecInst;
 	EncInfo *pEncInfo;
@@ -333,18 +341,17 @@ void EncodeHeader(EncHandle handle, EncHeaderParam * encHeaderParam)
 		VpuWriteReg(CMD_ENC_HEADER_BB_START, encHeaderParam->buf);
 		VpuWriteReg(CMD_ENC_HEADER_BB_SIZE, encHeaderParam->size);
 	}
-
 	// 0: SPS, 1: PPS
 	VpuWriteReg(CMD_ENC_HEADER_CODE, encHeaderParam->headerType);
 	BitIssueCommand(pCodecInst->instIndex, pCodecInst->codecMode,
 			ENCODE_HEADER);
 
-	while (VpuReadReg(BIT_BUSY_FLAG));
-	
+	while (VpuReadReg(BIT_BUSY_FLAG)) ;
+
 	if (pEncInfo->dynamicAllocEnable == 1) {
 		rdPtr = VpuReadReg(CMD_ENC_HEADER_BB_START);
 		wrPtr = VpuReadReg(pEncInfo->streamWrPtrRegAddr);
-	} else {	
+	} else {
 		rdPtr = VpuReadReg(pEncInfo->streamRdPtrRegAddr);
 		wrPtr = VpuReadReg(pEncInfo->streamWrPtrRegAddr);
 	}
@@ -353,7 +360,8 @@ void EncodeHeader(EncHandle handle, EncHeaderParam * encHeaderParam)
 	encHeaderParam->size = wrPtr - rdPtr;
 }
 
-RetCode CheckDecOpenParam(DecOpenParam * pop)
+RetCode
+CheckDecOpenParam(DecOpenParam * pop)
 {
 	if (pop == 0) {
 		return RETCODE_INVALID_PARAM;
@@ -390,13 +398,15 @@ RetCode CheckDecOpenParam(DecOpenParam * pop)
 	return RETCODE_SUCCESS;
 }
 
-int DecBitstreamBufEmpty(DecInfo * pDecInfo)
+int
+DecBitstreamBufEmpty(DecInfo * pDecInfo)
 {
 	return VpuReadReg(pDecInfo->streamRdPtrRegAddr) ==
 	    VpuReadReg(pDecInfo->streamWrPtrRegAddr);
 }
 
-void GetParaSet(EncHandle handle, int paraSetType, EncParamSet * para)
+void
+GetParaSet(EncHandle handle, int paraSetType, EncParamSet * para)
 {
 	CodecInst *pCodecInst;
 	EncInfo *pEncInfo;
@@ -414,36 +424,38 @@ void GetParaSet(EncHandle handle, int paraSetType, EncParamSet * para)
 	para->size = VpuReadReg(RET_ENC_PARA_SET_SIZE);
 }
 
-void SetParaSet(DecHandle handle, int paraSetType, DecParamSet * para)
+void
+SetParaSet(DecHandle handle, int paraSetType, DecParamSet * para)
 {
 	CodecInst *pCodecInst;
 	DecInfo *pDecInfo;
 	int i;
 	Uint32 *src;
 	int byteSize;
-	
+
 	pCodecInst = handle;
 	pDecInfo = &pCodecInst->CodecInfo.decInfo;
 
 	src = para->paraSet;
 	byteSize = para->size / 4;
-	
+
 	for (i = 0; i < byteSize; i += 1) {
 		virt_paraBuf[i] = *src++;
 	}
-	
+
 	VpuWriteReg(CMD_DEC_PARA_SET_TYPE, paraSetType);
 	VpuWriteReg(CMD_DEC_PARA_SET_SIZE, para->size);
 	BitIssueCommand(pCodecInst->instIndex, pCodecInst->codecMode,
 			DEC_PARA_SET);
-	
+
 	while (VpuReadReg(BIT_BUSY_FLAG)) ;
 }
 
 // Following are not for MX32 and MX27 TO1
-RetCode SetGopNumber(EncHandle handle, Uint32 *pGopNumber)
+RetCode
+SetGopNumber(EncHandle handle, Uint32 * pGopNumber)
 {
-	CodecInst * pCodecInst;
+	CodecInst *pCodecInst;
 	int data = 0;
 	Uint32 gopNumber = *pGopNumber;
 
@@ -451,17 +463,18 @@ RetCode SetGopNumber(EncHandle handle, Uint32 *pGopNumber)
 	data = 1;
 	VpuWriteReg(CMD_ENC_SEQ_PARA_CHANGE_ENABLE, data);
 	VpuWriteReg(CMD_ENC_SEQ_PARA_RC_GOP, gopNumber);
-	BitIssueCommand(pCodecInst->instIndex, pCodecInst->codecMode, 
+	BitIssueCommand(pCodecInst->instIndex, pCodecInst->codecMode,
 			RC_CHANGE_PARAMETER);
-	
-	while (VpuReadReg(BIT_BUSY_FLAG));
-	
+
+	while (VpuReadReg(BIT_BUSY_FLAG)) ;
+
 	return RETCODE_SUCCESS;
 }
 
-RetCode SetIntraQp(EncHandle handle, Uint32 *pIntraQp)
+RetCode
+SetIntraQp(EncHandle handle, Uint32 * pIntraQp)
 {
-	CodecInst * pCodecInst;
+	CodecInst *pCodecInst;
 	int data = 0;
 	Uint32 intraQp = *pIntraQp;
 
@@ -469,16 +482,17 @@ RetCode SetIntraQp(EncHandle handle, Uint32 *pIntraQp)
 	data = 1 << 1;
 	VpuWriteReg(CMD_ENC_SEQ_PARA_CHANGE_ENABLE, data);
 	VpuWriteReg(CMD_ENC_SEQ_PARA_RC_INTRA_QP, intraQp);
-	BitIssueCommand(pCodecInst->instIndex, pCodecInst->codecMode, 
+	BitIssueCommand(pCodecInst->instIndex, pCodecInst->codecMode,
 			RC_CHANGE_PARAMETER);
-	
-	while (VpuReadReg(BIT_BUSY_FLAG));
+
+	while (VpuReadReg(BIT_BUSY_FLAG)) ;
 	return RETCODE_SUCCESS;
 }
 
-RetCode SetBitrate(EncHandle handle, Uint32 *pBitrate)
+RetCode
+SetBitrate(EncHandle handle, Uint32 * pBitrate)
 {
-	CodecInst * pCodecInst;
+	CodecInst *pCodecInst;
 	int data = 0;
 	Uint32 bitrate = *pBitrate;
 
@@ -486,16 +500,17 @@ RetCode SetBitrate(EncHandle handle, Uint32 *pBitrate)
 	data = 1 << 2;
 	VpuWriteReg(CMD_ENC_SEQ_PARA_CHANGE_ENABLE, data);
 	VpuWriteReg(CMD_ENC_SEQ_PARA_RC_BITRATE, bitrate);
-	BitIssueCommand(pCodecInst->instIndex, pCodecInst->codecMode, 
+	BitIssueCommand(pCodecInst->instIndex, pCodecInst->codecMode,
 			RC_CHANGE_PARAMETER);
-	
-	while (VpuReadReg(BIT_BUSY_FLAG));
+
+	while (VpuReadReg(BIT_BUSY_FLAG)) ;
 	return RETCODE_SUCCESS;
 }
 
-RetCode SetFramerate(EncHandle handle, Uint32 *pFramerate)
+RetCode
+SetFramerate(EncHandle handle, Uint32 * pFramerate)
 {
-	CodecInst * pCodecInst;
+	CodecInst *pCodecInst;
 	int data = 0;
 	Uint32 framerate = *pFramerate;
 
@@ -503,67 +518,69 @@ RetCode SetFramerate(EncHandle handle, Uint32 *pFramerate)
 	data = 1 << 3;
 	VpuWriteReg(CMD_ENC_SEQ_PARA_CHANGE_ENABLE, data);
 	VpuWriteReg(CMD_ENC_SEQ_PARA_RC_FRAME_RATE, framerate);
-	BitIssueCommand(pCodecInst->instIndex, pCodecInst->codecMode, 
+	BitIssueCommand(pCodecInst->instIndex, pCodecInst->codecMode,
 			RC_CHANGE_PARAMETER);
-	
-	while (VpuReadReg(BIT_BUSY_FLAG));
+
+	while (VpuReadReg(BIT_BUSY_FLAG)) ;
 
 	return RETCODE_SUCCESS;
 }
 
-RetCode SetIntraRefreshNum(EncHandle handle, Uint32 *pIntraRefreshNum)
+RetCode
+SetIntraRefreshNum(EncHandle handle, Uint32 * pIntraRefreshNum)
 {
-	CodecInst * pCodecInst;
+	CodecInst *pCodecInst;
 	Uint32 intraRefreshNum = *pIntraRefreshNum;
 	int data = 0;
 	pCodecInst = handle;
 	data = 1 << 4;
 	VpuWriteReg(CMD_ENC_SEQ_PARA_CHANGE_ENABLE, data);
 	VpuWriteReg(CMD_ENC_SEQ_PARA_INTRA_MB_NUM, intraRefreshNum);
-	BitIssueCommand(pCodecInst->instIndex, pCodecInst->codecMode, 
+	BitIssueCommand(pCodecInst->instIndex, pCodecInst->codecMode,
 			RC_CHANGE_PARAMETER);
-	
-	while (VpuReadReg(BIT_BUSY_FLAG));
+
+	while (VpuReadReg(BIT_BUSY_FLAG)) ;
 
 	return RETCODE_SUCCESS;
 }
 
-RetCode SetSliceMode(EncHandle handle, EncSliceMode *pSliceMode)
+RetCode
+SetSliceMode(EncHandle handle, EncSliceMode * pSliceMode)
 {
-	CodecInst * pCodecInst;
+	CodecInst *pCodecInst;
 	Uint32 data = 0;
 	int data2 = 0;
-	
-	data = pSliceMode->sliceSize<<2 | pSliceMode->sliceSizeMode<<1 | 
-		pSliceMode->sliceMode;
+
+	data = pSliceMode->sliceSize << 2 | pSliceMode->sliceSizeMode << 1 |
+	    pSliceMode->sliceMode;
 	pCodecInst = handle;
 
 	data2 = 1 << 5;
 	VpuWriteReg(CMD_ENC_SEQ_PARA_CHANGE_ENABLE, data2);
 	VpuWriteReg(CMD_ENC_SEQ_PARA_SLICE_MODE, data);
-	BitIssueCommand(pCodecInst->instIndex, pCodecInst->codecMode, 
+	BitIssueCommand(pCodecInst->instIndex, pCodecInst->codecMode,
 			RC_CHANGE_PARAMETER);
-	
-	while (VpuReadReg(BIT_BUSY_FLAG));
+
+	while (VpuReadReg(BIT_BUSY_FLAG)) ;
 
 	return RETCODE_SUCCESS;
 }
 
-RetCode SetHecMode(EncHandle handle, int mode)
+RetCode
+SetHecMode(EncHandle handle, int mode)
 {
-	CodecInst * pCodecInst;
+	CodecInst *pCodecInst;
 	Uint32 HecMode = mode;
 	int data = 0;
 	pCodecInst = handle;
-	
+
 	data = 1 << 6;
 	VpuWriteReg(CMD_ENC_SEQ_PARA_CHANGE_ENABLE, data);
 	VpuWriteReg(CMD_ENC_SEQ_PARA_HEC_MODE, HecMode);
-	BitIssueCommand(pCodecInst->instIndex, pCodecInst->codecMode, 
+	BitIssueCommand(pCodecInst->instIndex, pCodecInst->codecMode,
 			RC_CHANGE_PARAMETER);
-	
-	while (VpuReadReg(BIT_BUSY_FLAG));
+
+	while (VpuReadReg(BIT_BUSY_FLAG)) ;
 
 	return RETCODE_SUCCESS;
 }
-