convertpar.cpp

完整的RTP RTSP代码库

			}
		}
	}
	else {
		for (iObj = 0; iObj < nVO; iObj++)
		{
			rgbSadctDisable [BASE_LAYER] [iObj] = 1;
			rgbSadctDisable [ENHN_LAYER] [iObj] = 1;
		}
	}
	
	for (iObj = 0; iObj < nVO; iObj++)
	{
		/*************/
		fprintf(pfOut, "Texture.SADCT.Enable [%d] = %d\n", iObj, !rgbSadctDisable [BASE_LAYER] [iObj]);
		/*************/
		if(bAnyScalability)
			/*************/
			fprintf(pfOut, "Texture.SADCT.Enable [%d] = %d\n", iObj + nVO, !rgbSadctDisable [ENHN_LAYER] [iObj]);
			/*************/
	}

	// end sadct

	// quantizer selection: 0 -- H.263, 1 -- MPEG
	nextValidLine (pfPara, pnLine);
	for (iObj = 0; iObj < nVO; iObj++)	{
		if (fscanf (pfPara, "%d", (int *)&(rgfQuant [BASE_LAYER] [iObj])) != 1)	{
			fprintf(stderr, "wrong parameter file format on line %d\n", *pnLine);
			fatal_error("Conversion aborted");
		}
		my_assert (rgfQuant [BASE_LAYER] [iObj] ==0 || rgfQuant [BASE_LAYER] [iObj] == 1);
		/*************/
		fprintf(pfOut, "Quant.Type [%d] = \"%s\"\n", iObj, rgfQuant [BASE_LAYER] [iObj]==0 ? "H263" : "MPEG");
		/*************/
	}
	if (bAnyScalability)	{
		for (iObj = 0; iObj < nVO; iObj++)	{
			if (fscanf (pfPara, "%d", (int *)&(rgfQuant [ENHN_LAYER] [iObj])) != 1)	{
				fprintf(stderr, "wrong parameter file format on line %d\n", *pnLine);
				fatal_error("Conversion aborted");
			}
			my_assert (rgfQuant [ENHN_LAYER] [iObj] ==0 || rgfQuant [ENHN_LAYER] [iObj] == 1);
			/*************/
			fprintf(pfOut, "Quant.Type [%d] = \"%s\"\n", iObj + nVO, rgfQuant [ENHN_LAYER] [iObj]==0 ? "H263" : "MPEG");
			/*************/
		}
	}

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

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

	// threhold to code Intra-DC as AC
	nextValidLine (pfPara, pnLine);
	for (iObj = 0; iObj < nVO; iObj++)	{
		if (fscanf (pfPara, "%d", &(rgiIntraDCSwitchingThr [BASE_LAYER] [iObj])) != 1)	{
			fprintf(stderr, "wrong parameter file format on line %d\n", *pnLine);
			fatal_error("Conversion aborted");
		}
		my_assert (rgiIntraDCSwitchingThr [BASE_LAYER] [iObj] >= 0 && 
				rgiIntraDCSwitchingThr [BASE_LAYER] [iObj] <= 7);
		/*************/
		fprintf(pfOut, "Texture.IntraDCThreshold [%d] = %d\n", iObj, rgiIntraDCSwitchingThr [BASE_LAYER] [iObj]);
		/*************/
	}
	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");
				/*************/
			}
		}
	}