convertpar.cpp

网络MPEG4IP流媒体开发源代码

			fatal_error("Conversion aborted");
		}
		my_assert (rgbNoCrChange [iObj] == TRUE || rgbNoCrChange [iObj] == FALSE); //boolean value
		if (rgiBinaryAlphaTH [iObj] == 0)
			my_assert (rgbNoCrChange [iObj] == TRUE); //MB-level size conversion of shape is off in lossless mode\n");
		/*************/
		fprintf(pfOut, "Alpha.Binary.SizeConversion.Enable [%d] = %d\n", iObj, !rgbNoCrChange [iObj]);
		/*************/
	}

	//	Added for error resilient mode by Toshiba(1997-11-14)
	nextValidLine (pfPara, pnLine);
	for (iObj = 0; iObj < nVO; iObj++)	{
		if (fscanf (pfPara, "%d", &rgiBinaryAlphaRR [iObj]) != 1)	{
			fprintf	(stderr, "wrong parameter file format on line %d\n", *pnLine);
			fatal_error("Conversion aborted");
		}
		my_assert (rgiBinaryAlphaRR [iObj] >= 0);
		/*************/
		fprintf(pfOut, "ErrorResil.AlphaRefreshRate [%d] = %d\n", iObj, rgiBinaryAlphaRR [iObj]);
		/*************/
	}
	// End Toshiba(1997-11-14)

	// rounding control disable
	if(iVersion > 812)
		nextValidLine (pfPara, pnLine);
	for (iObj = 0; iObj < nVO; iObj++)	{
		if(iVersion > 812)
		{
			if (fscanf (pfPara, "%d", &rgbRoundingControlDisable [iObj]) != 1)	{
				fprintf(stderr, "wrong parameter file format on line %d\n", *pnLine);
				fatal_error("Conversion aborted");
			}
		}
		else
			rgbRoundingControlDisable [iObj] = 0;
		my_assert (rgbRoundingControlDisable [iObj]  == 0 || rgbRoundingControlDisable [iObj] == 1);
		/*************/
		fprintf(pfOut, "Motion.RoundingControl.Enable [%d] = %d\n", iObj, !rgbRoundingControlDisable [iObj]);
		/*************/
	}
	if(iVersion > 812)
		nextValidLine (pfPara, pnLine);
	for (iObj = 0; iObj < nVO; iObj++)	{
		if(iVersion > 812)
		{
			if (fscanf (pfPara, "%d", &rgiInitialRoundingType [iObj]) != 1)	{
				fprintf	(stderr, "wrong parameter file format on line %d\n", *pnLine);
				fatal_error("Conversion aborted");
			}
		}
		else
			rgiInitialRoundingType [iObj] = 0;
		my_assert (rgiInitialRoundingType [iObj] == 0 || rgiInitialRoundingType [iObj] == 1);
		/*************/
		fprintf(pfOut, "Motion.RoundingControl.StartValue [%d] = %d\n", iObj, rgiInitialRoundingType [iObj]);
		/*************/
	}

	// error resilient coding disable
	nextValidLine (pfPara, pnLine);
	Int iErrorResilientFlags;
	for (iObj = 0; iObj < nVO; iObj++)	{
		if (fscanf (pfPara, "%d", &iErrorResilientFlags) != 1)	{
			fprintf(stderr, "wrong parameter file format on line %d\n", *pnLine);
			fatal_error("Conversion aborted");
		}
		rgbErrorResilientDisable [BASE_LAYER] [iObj] = iErrorResilientFlags & 0x1;
//	Modified for error resilient mode by Toshiba(1998-1-16)
		rgbDataPartitioning [BASE_LAYER] [iObj]		 = (iErrorResilientFlags & 0x2) ? TRUE : FALSE;
		rgbReversibleVlc [BASE_LAYER] [iObj]		 = (iErrorResilientFlags & 0x4) ? TRUE : FALSE;
//	End Toshiba(1998-1-16)
		if( rgbErrorResilientDisable [BASE_LAYER] [iObj])
			rgiBinaryAlphaRR [iObj] = -1;

		/*************/
		fprintf(pfOut, "ErrorResil.RVLC.Enable [%d] = %d\n", iObj, rgbReversibleVlc [BASE_LAYER] [iObj]);
		fprintf(pfOut, "ErrorResil.DataPartition.Enable [%d] = %d\n", iObj, rgbDataPartitioning [BASE_LAYER] [iObj]);
		fprintf(pfOut, "ErrorResil.VideoPacket.Enable [%d] = %d\n", iObj, !rgbErrorResilientDisable [BASE_LAYER] [iObj]);
		/*************/
	}
	if (bAnyScalability)	{
		for (iObj = 0; iObj < nVO; iObj++)	{
			if (fscanf (pfPara, "%d", &rgbErrorResilientDisable [ENHN_LAYER] [iObj]) != 1)	{
				fprintf(stderr, "wrong parameter file format on line %d\n", *pnLine);
				fatal_error("Conversion aborted");
			}
			my_assert (rgbErrorResilientDisable [ENHN_LAYER] [iObj] == TRUE); //error resilient coding not supported as for now
			rgbErrorResilientDisable [ENHN_LAYER] [iObj] = TRUE;
			rgbDataPartitioning [ENHN_LAYER] [iObj] = FALSE;
			rgbReversibleVlc [ENHN_LAYER] [iObj] = FALSE;
			/*************/
			fprintf(pfOut, "ErrorResil.RVLC.Enable [%d] = %d\n", iObj + nVO, rgbReversibleVlc [ENHN_LAYER] [iObj]);
			fprintf(pfOut, "ErrorResil.DataPartition.Enable [%d] = %d\n", iObj + nVO, rgbDataPartitioning [ENHN_LAYER] [iObj]);
			fprintf(pfOut, "ErrorResil.VideoPacket.Enable [%d] = %d\n", iObj + nVO, !rgbErrorResilientDisable [ENHN_LAYER] [iObj]);
			/*************/
		}
	}

	// Bit threshold for video packet spacing control
	nextValidLine (pfPara, pnLine);
	for (iObj = 0; iObj < nVO; iObj++)	{
		if (fscanf (pfPara, "%d", &rgiVPBitTh [BASE_LAYER] [iObj]) != 1)	{
			fprintf(stderr, "wrong parameter file format on line %d\n", *pnLine);
			fatal_error("Conversion aborted");
		}
		if (rgbErrorResilientDisable [BASE_LAYER] [iObj])
			rgiVPBitTh [BASE_LAYER] [iObj] = -1;	// set VPBitTh to negative value
		/*************/
		fprintf(pfOut, "ErrorResil.VideoPacket.Length [%d] = %d\n", iObj, rgiVPBitTh [BASE_LAYER] [iObj]);
		/*************/
	}
	if (bAnyScalability)	{
		for (iObj = 0; iObj < nVO; iObj++)	{
			if (fscanf (pfPara, "%d", &rgiVPBitTh [ENHN_LAYER] [iObj]) != 1)	{
				fprintf(stderr, "wrong parameter file format on line %d\n", *pnLine);
				fatal_error("Conversion aborted");
			}
			rgiVPBitTh [ENHN_LAYER] [iObj] = -1;
			/*************/
			fprintf(pfOut, "ErrorResil.VideoPacket.Length [%d] = %d\n", iObj + nVO, rgiVPBitTh [ENHN_LAYER] [iObj]);
			/*************/
		}
	}

	// Interlaced coding
	nextValidLine (pfPara, pnLine);
	for (iObj = 0; iObj < nVO; iObj++)	{
		if (fscanf (pfPara, "%d", &rgbInterlacedCoding [BASE_LAYER] [iObj]) != 1)	{
			fprintf(stderr, "wrong parameter file format on line %d\n", *pnLine);
			fatal_error("Conversion aborted");
		}
		my_assert (rgbInterlacedCoding [BASE_LAYER] [iObj] == 0 || rgbInterlacedCoding [BASE_LAYER] [iObj] == 1);
		/*************/
		fprintf(pfOut, "Motion.Interlaced.Enable [%d] = %d\n", iObj, rgbInterlacedCoding [BASE_LAYER] [iObj]);
		/*************/
	}
	if (bAnyScalability)	{
		for (iObj = 0; iObj < nVO; iObj++)	{
			if (fscanf (pfPara, "%d", &rgbInterlacedCoding [ENHN_LAYER] [iObj]) != 1)	{
				fprintf(stderr, "wrong parameter file format on line %d\n", *pnLine);
				fatal_error("Conversion aborted");
			}
			my_assert (rgbInterlacedCoding [ENHN_LAYER] [iObj] == 0 || rgbInterlacedCoding [ENHN_LAYER] [iObj] == 1);
			/*************/
			fprintf(pfOut, "Motion.Interlaced.Enable [%d] = %d\n", iObj + nVO, rgbInterlacedCoding [ENHN_LAYER] [iObj]);
			/*************/
		}
	}
	
	// quantizer selection: 0 -- H.263, 1 -- MPEG
	nextValidLine (pfPara, pnLine);
	for (iObj = 0; iObj < nVO; iObj++)	{
	  int read;
		if (fscanf (pfPara, "%d", &read) != 1) {
			fprintf(stderr, "wrong parameter file format on line %d\n", *pnLine);
			fatal_error("Conversion aborted");
		}
		rgfQuant [BASE_LAYER] [iObj] = (Quantizer)read;
		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++)	{
		  int read;
			if (fscanf (pfPara, "%d", &read) != 1) {
				fprintf(stderr, "wrong parameter file format on line %d\n", *pnLine);
				fatal_error("Conversion aborted");
			}
			rgfQuant [ENHN_LAYER] [iObj] = (Quantizer)read;
			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]);