convertpar.cpp

网络MPEG4IP流媒体开发源代码

		/*************/
	}
	if (bAnyScalability)	{
		for (iObj = 0; iObj < nVO; iObj++)	{
			if (fscanf (pfPara, "%d", &(rgiIntraDCSwitchingThr [ENHN_LAYER] [iObj])) != 1)	{
				fprintf(stderr, "wrong parameter file format on line %d\n", *pnLine);
				fatal_error("Conversion aborted");
			}
			my_assert (rgiIntraDCSwitchingThr [ENHN_LAYER] [iObj] >= 0 && 
					rgiIntraDCSwitchingThr [ENHN_LAYER] [iObj] <= 7);
			/*************/
			fprintf(pfOut, "Texture.IntraDCThreshold [%d] = %d\n", iObj + nVO, rgiIntraDCSwitchingThr [ENHN_LAYER] [iObj]);
			/*************/
		}
	}

	// I-VO quantization stepsize
	nextValidLine (pfPara, pnLine);
	for (iObj = 0; iObj < nVO; iObj++)	{
		if (fscanf (pfPara, "%d", &(rgiIStep [BASE_LAYER] [iObj])) != 1)	{
			fprintf(stderr, "wrong parameter file format on line %d\n", *pnLine);
			fatal_error("Conversion aborted");
		}
		my_assert (rgiIStep [BASE_LAYER] [iObj] > 0 && rgiIStep [BASE_LAYER] [iObj] < (1<<uiQuantPrecision));
		/*************/
		fprintf(pfOut, "Texture.QuantStep.IVOP [%d] = %d\n", iObj, rgiIStep [BASE_LAYER] [iObj]);
		/*************/
	}
	if (bAnyScalability)	{
		for (iObj = 0; iObj < nVO; iObj++)	{
			if (fscanf (pfPara, "%d", &(rgiIStep [ENHN_LAYER] [iObj])) != 1)	{
				fprintf(stderr, "wrong parameter file format on line %d\n", *pnLine);
				fatal_error("Conversion aborted");
			}
			my_assert (rgiIStep [ENHN_LAYER] [iObj] > 0 && rgiIStep [ENHN_LAYER] [iObj] < (1<<uiQuantPrecision));
			/*************/
			fprintf(pfOut, "Texture.QuantStep.IVOP [%d] = %d\n", iObj + nVO, rgiIStep [ENHN_LAYER] [iObj]);
			/*************/
		}
	}

	// P-VO quantization stepsize
	nextValidLine (pfPara, pnLine);
	for (iObj = 0; iObj < nVO; iObj++)	{
		if (fscanf (pfPara, "%d", &(rgiPStep [BASE_LAYER] [iObj])) != 1)	{
			fprintf(stderr, "wrong parameter file format on line %d\n", *pnLine);
			fatal_error("Conversion aborted");
		}
		my_assert (rgiPStep [BASE_LAYER] [iObj] > 0 && rgiPStep [BASE_LAYER] [iObj] < (1<<uiQuantPrecision));
		/*************/
		fprintf(pfOut, "Texture.QuantStep.PVOP [%d] = %d\n", iObj, rgiPStep [BASE_LAYER] [iObj]);
		/*************/
	}
	if (bAnyScalability)	{
		for (iObj = 0; iObj < nVO; iObj++)	{
			if (fscanf (pfPara, "%d", &(rgiPStep [ENHN_LAYER] [iObj])) != 1)	{
				fprintf(stderr, "wrong parameter file format on line %d\n", *pnLine);
				fatal_error("Conversion aborted");
			}
			my_assert (rgiPStep [ENHN_LAYER] [iObj] > 0 && rgiPStep [ENHN_LAYER] [iObj] < (1<<uiQuantPrecision));
			/*************/
			fprintf(pfOut, "Texture.QuantStep.PVOP [%d] = %d\n", iObj + nVO, rgiPStep [ENHN_LAYER] [iObj]);
			/*************/
		}
	}

	// quantization stepsize for B-VOP
	nextValidLine (pfPara, pnLine);
	for (iObj = 0; iObj < nVO; iObj++)	{
		if (fscanf (pfPara, "%d", &(rgiStepBCode [BASE_LAYER] [iObj])) != 1)	{
			fprintf(stderr, "wrong parameter file format on line %d\n", *pnLine);
			fatal_error("Conversion aborted");
		}
		my_assert (rgiStepBCode [BASE_LAYER] [iObj] > 0 && rgiStepBCode [BASE_LAYER] [iObj] < (1<<uiQuantPrecision));
		/*************/
		fprintf(pfOut, "Texture.QuantStep.BVOP [%d] = %d\n", iObj, rgiStepBCode [BASE_LAYER] [iObj]);
		/*************/
	}
	if (bAnyScalability)	{
		for (iObj = 0; iObj < nVO; iObj++)	{
			if (fscanf (pfPara, "%d", &(rgiStepBCode [ENHN_LAYER] [iObj])) != 1)	{
				fprintf(stderr, "wrong parameter file format on line %d\n", *pnLine);
				fatal_error("Conversion aborted");
			}
			my_assert (rgiStepBCode [ENHN_LAYER] [iObj] > 0 && rgiStepBCode [ENHN_LAYER] [iObj] < (1<<uiQuantPrecision));
			/*************/
			fprintf(pfOut, "Texture.QuantStep.BVOP [%d] = %d\n", iObj + nVO, rgiStepBCode [ENHN_LAYER] [iObj]);
			/*************/
		}
	}

	// load non-default gray alpha intra Q-Matrix, 0 -- FALSE, 1 -- TRUE
	nextValidLine (pfPara, pnLine);
	for (iObj = 0; iObj < nVO; iObj++)	{
		if (fscanf (pfPara, "%d", &rgbLoadIntraMatrixAlpha [BASE_LAYER] [iObj]) != 1)	{
			fprintf(stderr, "wrong parameter file format on line %d\n", *pnLine);
			fatal_error("Conversion aborted");
		}
		my_assert (rgbLoadIntraMatrixAlpha [BASE_LAYER] [iObj] ==0 || 
				rgbLoadIntraMatrixAlpha [BASE_LAYER] [iObj] == 1);
		/*************/
		fprintf(pfOut, "Alpha.QuantMatrix.Intra.Enable [%d] = %d\n", iObj, rgbLoadIntraMatrixAlpha [BASE_LAYER] [iObj]);
		/*************/
		if (rgbLoadIntraMatrixAlpha [BASE_LAYER] [iObj]) {
			/*************/
			fprintf(pfOut, "Alpha.QuantMatrix.Intra [%d] = {", iObj);
			/*************/
			for (UInt i = 0; i < BLOCK_SQUARE_SIZE; i++) {
				if(i>0)
					/*************/
					fprintf(pfOut, ", ");
					/*************/
				if (fscanf (pfPara, "%d", &rgppiIntraQuantizerMatrixAlpha [BASE_LAYER] [iObj] [i]) != 1)	{
					fprintf(stderr, "wrong parameter file format on line %d\n", *pnLine);
					fatal_error("Conversion aborted");
				}
				/*************/
				fprintf(pfOut, "%d", rgppiIntraQuantizerMatrixAlpha [BASE_LAYER] [iObj] [i]);
				/*************/
			}
			/*************/
			fprintf(pfOut, "}\n");
			/*************/
		}
	}
	if (bAnyScalability)	{
		for (iObj = 0; iObj < nVO; iObj++)	{
			if (fscanf (pfPara, "%d", &rgbLoadIntraMatrixAlpha [ENHN_LAYER] [iObj]) != 1)	{
				fprintf(stderr, "wrong parameter file format on line %d\n", *pnLine);
				fatal_error("Conversion aborted");
			}
			my_assert (rgbLoadIntraMatrixAlpha [ENHN_LAYER] [iObj] ==0 || 
					rgbLoadIntraMatrixAlpha [ENHN_LAYER] [iObj] == 1);
			/*************/
			fprintf(pfOut, "Alpha.QuantMatrix.Intra.Enable [%d] = %d\n", iObj + nVO, rgbLoadIntraMatrixAlpha [ENHN_LAYER] [iObj]);
			/*************/
			if (rgbLoadIntraMatrixAlpha [ENHN_LAYER] [iObj]) {
				/*************/
				fprintf(pfOut, "Alpha.QuantMatrix.Intra [%d] = {", iObj + nVO);
				/*************/
				for (UInt i = 0; i < BLOCK_SQUARE_SIZE; i++) {
					if(i>0)
						/*************/
						fprintf(pfOut, ", ");
						/*************/
					if (fscanf (pfPara, "%d", &rgppiIntraQuantizerMatrixAlpha [ENHN_LAYER] [iObj] [i]) != 1)	{
						fprintf(stderr, "wrong parameter file format on line %d\n", *pnLine);
						fatal_error("Conversion aborted");
					}
					/*************/
					fprintf(pfOut, "%d", rgppiIntraQuantizerMatrixAlpha [ENHN_LAYER] [iObj] [i]);
					/*************/
				}
				/*************/
				fprintf(pfOut, "}\n");
				/*************/
			}
		}
	}

	// load non-default  gray alpha inter Q-Matrix, 0 -- FALSE, 1 -- TRUE
	nextValidLine (pfPara, pnLine);
	for (iObj = 0; iObj < nVO; iObj++)	{
		if (fscanf (pfPara, "%d", &rgbLoadInterMatrixAlpha [BASE_LAYER] [iObj]) != 1)	{
			fprintf(stderr, "wrong parameter file format on line %d\n", *pnLine);
			fatal_error("Conversion aborted");
		}
		my_assert (rgbLoadInterMatrixAlpha [BASE_LAYER] [iObj] ==0 || 
				rgbLoadInterMatrixAlpha [BASE_LAYER] [iObj] == 1);
		/*************/
		fprintf(pfOut, "Alpha.QuantMatrix.Inter.Enable [%d] = %d\n", iObj, rgbLoadInterMatrixAlpha [BASE_LAYER] [iObj]);
		/*************/
		if (rgbLoadInterMatrixAlpha [BASE_LAYER] [iObj]) {
			/*************/
			fprintf(pfOut, "Alpha.QuantMatrix.Inter [%d] = {", iObj);
			/*************/
			for (UInt i = 0; i < BLOCK_SQUARE_SIZE; i++) {
				if(i>0)
					/*************/
					fprintf(pfOut, ", ");
					/*************/
				if (fscanf (pfPara, "%d", &rgppiInterQuantizerMatrixAlpha [BASE_LAYER] [iObj] [i]) != 1)	{
					fprintf(stderr, "wrong parameter file format on line %d\n", *pnLine);
					fatal_error("Conversion aborted");
				}
				/*************/
				fprintf(pfOut, "%d", rgppiInterQuantizerMatrixAlpha [BASE_LAYER] [iObj] [i]);
				/*************/
			}
			/*************/
			fprintf(pfOut, "}\n");
			/*************/
		}
	}
	if (bAnyScalability)	{
		for (iObj = 0; iObj < nVO; iObj++)	{
			if (fscanf (pfPara, "%d", &rgbLoadInterMatrixAlpha [ENHN_LAYER] [iObj]) != 1)	{
				fprintf(stderr, "wrong parameter file format on line %d\n", *pnLine);
				fatal_error("Conversion aborted");
			}
			my_assert (rgbLoadInterMatrixAlpha [ENHN_LAYER] [iObj] ==0 || 
					rgbLoadInterMatrixAlpha [ENHN_LAYER] [iObj] == 1);
			/*************/
			fprintf(pfOut, "Alpha.QuantMatrix.Inter.Enable [%d] = %d\n", iObj + nVO, rgbLoadInterMatrixAlpha [ENHN_LAYER] [iObj]);
			/*************/
			if (rgbLoadInterMatrixAlpha [ENHN_LAYER] [iObj]) {
				/*************/
				fprintf(pfOut, "Alpha.QuantMatrix.Inter [%d] = {", iObj + nVO);
				/*************/
				for (UInt i = 0; i < BLOCK_SQUARE_SIZE; i++) {
					if(i>0)
						/*************/
						fprintf(pfOut, ", ");
						/*************/
					if (fscanf (pfPara, "%d", &rgppiInterQuantizerMatrixAlpha [ENHN_LAYER] [iObj] [i]) != 1)	{
						fprintf(stderr, "wrong parameter file format on line %d\n", *pnLine);
						fatal_error("Conversion aborted");
					}
					/*************/
					fprintf(pfOut, "%d", rgppiInterQuantizerMatrixAlpha [ENHN_LAYER] [iObj] [i]);
					/*************/
				}
				/*************/
				fprintf(pfOut, "}\n");
				/*************/
			}
		}
	}

	// I-VO quantization stepsize for Alpha
	nextValidLine (pfPara, pnLine);
	for (iObj = 0; iObj < nVO; iObj++)	{
		if (fscanf (pfPara, "%d", &(rgiIStepAlpha [BASE_LAYER] [iObj])) != 1)	{
			fprintf(stderr, "wrong parameter file format on line %d\n", *pnLine);
			fatal_error("Conversion aborted");
		}
		my_assert (rgiIStepAlpha [BASE_LAYER] [iObj] > 0 && rgiIStepAlpha [BASE_LAYER] [iObj] < 32);
		/*************/
		fprintf(pfOut, "Alpha.QuantStep.IVOP [%d] = %d\n", iObj, rgiIStepAlpha [BASE_LAYER] [iObj]);
		/*************/
	}
	if (bAnyScalability)	{
		for (iObj = 0; iObj < nVO; iObj++)	{
			if (fscanf (pfPara, "%d", &(rgiIStepAlpha [ENHN_LAYER] [iObj])) != 1)	{
				fprintf(stderr, "wrong parameter file format on line %d\n", *pnLine);
				fatal_error("Conversion aborted");
			}
			my_assert (rgiIStepAlpha [ENHN_LAYER] [iObj] > 0 && rgiIStepAlpha [ENHN_LAYER] [iObj] < 32);
			/*************/
			fprintf(pfOut, "Alpha.QuantStep.IVOP [%d] = %d\n", iObj + nVO, rgiIStepAlpha [ENHN_LAYER] [iObj]);
			/*************/
		}
	}

	// P-VO quantization stepsize for Alpha
	nextValidLine (pfPara, pnLine);
	for (iObj = 0; iObj < nVO; iObj++)	{
		if (fscanf (pfPara, "%d", &(rgiPStepAlpha [BASE_LAYER] [iObj])) != 1)	{
			fprintf(stderr, "wrong parameter file format on line %d\n", *pnLine);
			fatal_error("Conversion aborted");
		}
		my_assert (rgiPStepAlpha [BASE_LAYER] [iObj] > 0 && rgiPStepAlpha [BASE_LAYER] [iObj] < 64);
		/*************/
		fprintf(pfOut, "Alpha.QuantStep.PVOP [%d] = %d\n", iObj, rgiPStepAlpha [BASE_LAYER] [iObj]);
		/*************/
	}
	if (bAnyScalability)	{
		for (iObj = 0; iObj < nVO; iObj++)	{
			if (fscanf (pfPara, "%d", &(rgiPStepAlpha [ENHN_LAYER] [iObj])) != 1)	{
				fprintf(stderr, "wrong parameter file format on line %d\n", *pnLine);
				fatal_error("Conversion aborted");
			}
			my_assert (rgiPStepAlpha [ENHN_LAYER] [iObj] > 0 && rgiPStepAlpha [ENHN_LAYER] [iObj] < 64);
			/*************/
			fprintf(pfOut, "Alpha.QuantStep.PVOP [%d] = %d\n", iObj + nVO, rgiPStepAlpha [ENHN_LAYER] [iObj]);
			/*************/
		}
	}

	// B-VO quantization stepsize for Alpha
	nextValidLine (pfPara, pnLine);
	for (iObj = 0; iObj < nVO; iObj++)	{
		if (fscanf (pfPara, "%d", &(rgiBStepAlpha [BASE_LAYER] [iObj])) != 1)	{
			fprintf(stderr, "wrong parameter file format on line %d\n", *pnLine);
			fatal_error("Conversion aborted");
		}
		my_assert (rgiBStepAlpha [BASE_LAYER] [iObj] > 0 && rgiBStepAlpha [BASE_LAYER] [iObj] < 64);
		/*************/
		fprintf(pfOut, "Alpha.QuantStep.BVOP [%d] = %d\n", iObj, rgiBStepAlpha [BASE_LAYER] [iObj]);
		/*************/
	}
	if (bAnyScalability)	{
		for (iObj = 0; iObj < nVO; iObj++)	{
			if (fscanf (pfPara, "%d", &(rgiBStepAlpha [ENHN_LAYER] [iObj])) != 1)	{
				fprintf(stderr, "wrong parameter file format on line %d\n", *pnLine);
				fatal_error("Conversion aborted");
			}
			my_assert (rgiBStepAlpha [ENHN_LAYER] [iObj] > 0 && rgiBStepAlpha [ENHN_LAYER] [iObj] < 64);
			/*************/
			fprintf(pfOut, "Alpha.QuantStep.BVOP [%d] = %d\n", iObj + nVO, rgiBStepAlpha [ENHN_LAYER] [iObj]);
			/*************/
		}
	}

	// disable_gray_quant_update
	nextValidLine (pfPara, pnLine);
	for (iObj = 0; iObj < nVO; iObj++)	{
		if (fscanf (pfPara, "%d", &(rgbNoGrayQuantUpdate [BASE_LAYER] [iObj])) != 1)	{
			fprintf(stderr, "wrong parameter file format on line %d\n", *pnLine);
			fatal_error("Conversion aborted");
		}
		/*************/
		fprintf(pfOut, "Alpha.QuantDecouple.Enable [%d] = %d\n", iObj, rgbNoGrayQuantUpdate [BASE_LAYER] [iObj]);
		/*************/
	}
	if (bAnyScalability)	{
		for (iObj = 0; iObj < nVO; iObj++)	{
			if (fscanf (pfPara, "%d", &(rgbNoGrayQuantUpdate [ENHN_LAYER] [iObj])) != 1)	{
				fprintf(stderr, "wrong parameter file format on line %d\n", *pnLine);
				fatal_error("Conversion aborted");
			}
			/*************/
			fprintf(pfOut, "Alpha.QuantDecouple.Enable [%d] = %d\n", iObj + nVO, rgbNoGrayQuantUpdate [ENHN_LAYER] [iObj]);
			/*************/
		}
	}

	// number of P-VOP's between 2 I-VOP's; if there are B-VOPs, the no. of encode frames will multiply
	nextValidLine (pfPara, pnLine);
	for (iObj = 0; iObj < nVO; iObj++)	{
		if (fscanf (pfPara, "%d", &rgiNumPbetweenIVOP [iObj]) != 1)	{
			fprintf(stderr, "wrong parameter file format on line %d\n", *pnLine);
			fatal_error("Conversion aborted");