mae_pass_thru.c

au1200 linux2.6.11 硬件解码mae驱动和maiplayer播放器源码

			if (pCheckMB->nWidthLuma)
				pCrOut = pCrOut + pCheckMB->nWidthChroma;
			else
				pCrOut = pCrOut + 8;
		}
	}


    FileCacheDone(pFile);
	//fclose (pFile);
}




// ***************************************************************************
//
//  Function:       InterChecksForRefBlkAndMV
//
//
//  Parameters:     pREF_BLK_MV_CHECKERS pChkBlk -- 
//					pointer to REF_BLK_MV_CHECKERS struct
//					char *xFileName -- file name to write data into
//					unsigned char nSource -- From MAE or MPEG-4 Reference code		
//
//  Return Value:   VOID
//
//  Notes:			The intent is to dump all reference block & motion vector
//					related info
//
// ***************************************************************************
void InterChecksForRefBlkAndMV(pREF_BLK_MV_CHECKERS pChkBlk, char *xFileName,
										  unsigned char nSource)
{	
  CachedFILE pFile;
  int outer;
  int iWidth=0;
  unsigned char *pRefBlock;
  char szMBType[10] = {0}, szMBMode[15] = {0}, szRefType[20] = {0};


  if(nFileUpdates & NO_DUMP_ALL)
	return;

  //read, write & append
  pFile = FileCacheGet(xFileName);
  //pFile = fopen (xFileName, "a+");

  if (!pFile)
	return;

	// Write the MB number only for the first block
	if (pChkBlk->nBlockNum == 1)
	{
		if(pChkBlk->bSkip == MACROBLOCK_SKIPPED)
			fprintf(pFile, "$MacroBlock #%d: SKIPPED: ", pChkBlk->nMBNum);
		else
			fprintf(pFile, "$MacroBlock #%d: ", pChkBlk->nMBNum);

		// Write the MBType
		if (pChkBlk->nMBType == MBT_16x16)
			strcpy(szMBType, "MBT_16x16");
		else if (pChkBlk->nMBType == MBT_16x8)
			strcpy(szMBType, "MBT_16x8");
		else if (pChkBlk->nMBType == MBT_8x8)
			strcpy(szMBType, "MBT_8x8");

		fprintf(pFile, "MBType=%s: ", szMBType);

		// Write the MBMode
		if (pChkBlk->nMBMode == MBM_FORWARD)
			strcpy(szMBMode, "Forward Only");
		else if (pChkBlk->nMBMode == MBM_BACKWARD)
			strcpy(szMBMode, "Backward Only");
		else if (pChkBlk->nMBMode == MBM_BIDIRECTIONAL)
			strcpy(szMBMode, "Bi-Directional");

		fprintf(pFile, "MBMode=%s: \n", szMBMode);
	}

	if (pChkBlk->nMBType == MBT_16x16)
	{
		int i;
		unsigned char *pRefPtr = (unsigned char *)pChkBlk->refblk;

		if (pChkBlk->nBlockNum == Y1_LUMA_BLOCK)
		{
			if (nSource == FROM_MAE_CMODEL)
			{
				fprintf(pFile, "$Y MVs (Quarter Pel), X=%d Y=%d: \n", pChkBlk->nActMVX, pChkBlk->nActMVY);
			}
			else if (nSource == FROM_MPEG2_REF)
			{
				fprintf(pFile, "$Y MVs (Half Pel), X=%d Y=%d: \n", pChkBlk->nActMVX, pChkBlk->nActMVY);
			}

			if (pChkBlk->nMBMode == MBM_BIDIRECTIONAL)
			{
				if (pChkBlk->nRefType == FORWARD_REFERENCES)
					fprintf(pFile, "$Y0 Block (FORWARD_REFERENCES):\n");
				else if (pChkBlk->nRefType == BACKWARD_REFERENCES)
					fprintf(pFile, "$Y0 Block (BACKWARD_REFERENCES):\n");
			}
			else
				fprintf(pFile, "$Y0 Block:\n");

			iWidth = pChkBlk->nWidthY;

			for (i = 0; i < 4;)
			{
				// Process the reference block now
				for (outer=0; outer<BLOCK_SIZE; outer++)
				{
					fprintf(pFile, "%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x:\n", *(pRefPtr),
																				 *(pRefPtr + 1),
																				 *(pRefPtr + 2),
																				 *(pRefPtr + 3),
																				 *(pRefPtr + 4),
																				 *(pRefPtr + 5),
																				 *(pRefPtr + 6),
																				 *(pRefPtr + 7) );
					pRefPtr += 8;
					pRefPtr += (iWidth - BLOCK_SIZE);
				}

				i++;

				switch(i+1)
				{
					case Y2_LUMA_BLOCK:
						fprintf(pFile, "$Y1 Block:\n");
						pRefPtr = (unsigned char *)pChkBlk->refblk + 8;
						break;

					case Y3_LUMA_BLOCK:
						fprintf(pFile, "$Y2 Block:\n");
						pRefPtr = (unsigned char *)pChkBlk->refblk + 8 * iWidth;
						break;

					case Y4_LUMA_BLOCK:
						fprintf(pFile, "$Y3 Block:\n");
						pRefPtr = (unsigned char *)pChkBlk->refblk + 8 * iWidth + 8;
						break;
				};

			}
		
			FileCacheDone(pFile);
			//fclose (pFile);
			return;
		
		}	
	}
	else
	{
		if (pChkBlk->nMBType == MBT_16x8)
		{
			int i;
			unsigned char *pRefPtr = (unsigned char *)pChkBlk->refblk;

			if (pChkBlk->nBlockNum == Y1_LUMA_BLOCK)
			{
				iWidth = pChkBlk->nWidthY;

				if (nSource == FROM_MAE_CMODEL)
				{
					fprintf(pFile, "$Y MVs upper 16x8 (Quarter Pel), X=%d Y=%d: \n", pChkBlk->nActMVX, pChkBlk->nActMVY);
				}
				else if (nSource == FROM_MPEG2_REF)
				{
					fprintf(pFile, "$Y MVs upper 16x8 (Half Pel), X=%d Y=%d: \n", pChkBlk->nActMVX, pChkBlk->nActMVY);
				}

				for (i = 0; i < 2;)
				{
					switch (i+1)
					{
						case Y1_LUMA_BLOCK:
							{
								if (pChkBlk->nMBMode == MBM_BIDIRECTIONAL)
								{
									if (pChkBlk->nRefType == FORWARD_TOP || pChkBlk->nRefType == FORWARD_BOTTOM)
										fprintf(pFile, "$Y0 Block (FORWARD_REFERENCES):%s\n",(pChkBlk->nRefType == FORWARD_TOP ? "FORWARD_TOP" : "FORWARD_BOTTOM"));
									else if (pChkBlk->nRefType == BACKWARD_TOP || pChkBlk->nRefType == BACKWARD_BOTTOM)
										fprintf(pFile, "$Y0 Block (BACKWARD_REFERENCES):%s\n",(pChkBlk->nRefType == FORWARD_TOP ? "BACKWARD_TOP" : "BACKWARD_BOTTOM"));
								}
								else
									fprintf(pFile, "$Y0 Block:\n");
							}
							break;

						case Y2_LUMA_BLOCK:
							fprintf(pFile, "$Y1 Block:\n");
							break;
					};

					// Process the reference block now
					for (outer=0; outer<BLOCK_SIZE; outer++)
					{
						fprintf(pFile, "%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x:\n", *(pRefPtr),
																					 *(pRefPtr + 1),
																					 *(pRefPtr + 2),
																					 *(pRefPtr + 3),
																					 *(pRefPtr + 4),
																					 *(pRefPtr + 5),
																					 *(pRefPtr + 6),
																					 *(pRefPtr + 7) );
						pRefPtr += 8;
						pRefPtr += (iWidth - BLOCK_SIZE);
					}

					i++;
					pRefPtr = (unsigned char *)pChkBlk->refblk + 8;
				}

				FileCacheDone(pFile);
				//fclose (pFile);
				return;		

			}	
			else if (pChkBlk->nBlockNum == Y3_LUMA_BLOCK)
			{
				iWidth = pChkBlk->nWidthY;

				pRefPtr = (unsigned char *)pChkBlk->refblk;

				if (nSource == FROM_MAE_CMODEL)
				{
					fprintf(pFile, "$Y MVs lower 16x8 (Quarter Pel), X=%d Y=%d: \n", pChkBlk->nActMVX, pChkBlk->nActMVY);
				}
				else if (nSource == FROM_MPEG2_REF)
				{
					fprintf(pFile, "$Y MVs lower 16x8 (Half Pel), X=%d Y=%d: \n", pChkBlk->nActMVX, pChkBlk->nActMVY);
				}

				for (i = 2; i < 4;)
				{
					if (pChkBlk->nMBMode == MBM_BIDIRECTIONAL && i==2)
					{
						if (pChkBlk->nRefType == FORWARD_TOP || pChkBlk->nRefType == FORWARD_BOTTOM)
							fprintf(pFile, "$Y3 Block (FORWARD_REFERENCES):%s\n",(pChkBlk->nRefType == FORWARD_TOP ? "FORWARD_TOP" : "FORWARD_BOTTOM"));
						else if (pChkBlk->nRefType == BACKWARD_TOP || pChkBlk->nRefType == BACKWARD_BOTTOM)
							fprintf(pFile, "$Y3 Block (BACKWARD_REFERENCES):%s\n",(pChkBlk->nRefType == FORWARD_TOP ? "BACKWARD_TOP" : "BACKWARD_BOTTOM"));
					}
					else
						fprintf(pFile, "$Y%d Block:\n", i);
					
					
					// Process the reference block now
					for (outer=0; outer<BLOCK_SIZE; outer++)
					{
						fprintf(pFile, "%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x:\n", *(pRefPtr),
																					 *(pRefPtr + 1),
																					 *(pRefPtr + 2),
																					 *(pRefPtr + 3),
																					 *(pRefPtr + 4),
																					 *(pRefPtr + 5),
																					 *(pRefPtr + 6),
																					 *(pRefPtr + 7) );
						pRefPtr += 8;
						pRefPtr += (iWidth - BLOCK_SIZE);
					}

					pRefPtr = (unsigned char *)pChkBlk->refblk + 8;

					i++;
				}

				FileCacheDone(pFile);
				//fclose (pFile);
				return;		
			}
		}
	}

	// U & V blocks need to get printed as is
	if (pChkBlk->nBlockNum == U_CHROMA_BLOCK)
		fprintf(pFile, "$U Block:\n");
	else if (pChkBlk->nBlockNum == V_CHROMA_BLOCK)
		fprintf(pFile, "$V Block:\n");

	if (pChkBlk->nBlockNum == U2_CHROMA_BLOCK)
		fprintf(pFile, "$U2 Block:\n");
	else if (pChkBlk->nBlockNum == V2_CHROMA_BLOCK)
		fprintf(pFile, "$V2 Block:\n");

	// Write the Motion Vectors
	switch(pChkBlk->nBlockNum)
	{
		case Y1_LUMA_BLOCK:
		case Y2_LUMA_BLOCK:
		case Y3_LUMA_BLOCK:
		case Y4_LUMA_BLOCK:
		default:
			if (nSource == FROM_MAE_CMODEL)
			{
				fprintf(pFile, "$Y MVs, X=%d Y=%d: \n", pChkBlk->nActMVX, pChkBlk->nActMVY);
			}
			else if (nSource == FROM_MPEG2_REF)
			{
				fprintf(pFile, "$Y MVs, X=%d Y=%d: \n", pChkBlk->nActMVX, pChkBlk->nActMVY);
			}
			iWidth = pChkBlk->nWidthY;
		break;

		case U_CHROMA_BLOCK:
		case U2_CHROMA_BLOCK:
			if (nSource == FROM_MAE_CMODEL)
			{
				fprintf(pFile, "$UV MVs, X=%d Y=%d:\n", pChkBlk->nActMVX, pChkBlk->nActMVY);
			}
			else if (nSource == FROM_MPEG2_REF)
			{
				fprintf(pFile, "$UV MVs, X=%d Y=%d:\n", pChkBlk->nActMVX, pChkBlk->nActMVY);
			}

			iWidth = pChkBlk->nWidthUV;
			break;

		case V_CHROMA_BLOCK:
		case V2_CHROMA_BLOCK:
			if (nSource == FROM_MAE_CMODEL)
			{
				fprintf(pFile, "$UV MVs, X=%d Y=%d:\n", pChkBlk->nActMVX, pChkBlk->nActMVY);
			}
			else if (nSource == FROM_MPEG2_REF)
			{
				fprintf(pFile, "$UV MVs, X=%d Y=%d:\n", pChkBlk->nActMVX, pChkBlk->nActMVY);
			}

			iWidth = pChkBlk->nWidthUV;
		break;
	}


	pRefBlock = (unsigned char *)pChkBlk->refblk;

	// Process the reference block now
	for (outer=0; outer<BLOCK_SIZE; outer++)
	{
		fprintf(pFile, "%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x:\n", *(pRefBlock),
																	 *(pRefBlock + 1),
																	 *(pRefBlock + 2),
																	 *(pRefBlock + 3),
																	 *(pRefBlock + 4),
																	 *(pRefBlock + 5),
																	 *(pRefBlock + 6),
																	 *(pRefBlock + 7) );
		pRefBlock += 8;
		pRefBlock += (iWidth - BLOCK_SIZE);
	}


    FileCacheDone(pFile);
	//fclose (pFile);
}




// ***************************************************************************
//
//  Function:       MAEFree
//
//
//  Parameters:     void *ptr -- input pointer to free
//
//  Return Value:   VOID
//
//  Notes:			A function just to avoid too many lines of code.
//
// ***************************************************************************
void* MAEFree(void *ptr)
{
	if (ptr)
	{
		free(ptr);
	}
	return NULL;
}

void Set_Print_Flag (int iFlag)
{
	nFileUpdates = iFlag;
}


void Call_cmodel_init_global(void)
{
	cmodel_init_global();
}

#if defined(OS_Linux)
char *
itoa(int num, char *out, int radix) {
  return _itoa(num, out, radix);
}

char *
_itoa(int num, char *out, int radix) {
	switch (radix) {
	case 10: sprintf(out, "%d", num); break;
	case 16: sprintf(out, "%x", num); break;
	default:
		fprintf(stderr, "Pathetic itoa function can't handle radix of %d\n", radix);
		exit(1);
	}

	return out;
}
#endif