scp-decode.cpp

BIOSIG is an open source software library for biomedical signal processing. Library works well with

void section_1_255()
// section 1 tag 255
{
	U_int_M dim;

	ReadByte(dim);
}//end section_1_255

//______________________________________________________________________________
//                              section 2
//______________________________________________________________________________

void section_2(pointer_section info_sections,DATA_DECODE &data)
//build Huffman tables if included in the file; if none then use del default one
//cannot read the dummy Huffman table
{
	U_int_M nt, i, j, ns=0, pos, dim;
	fpos_t filepos;
	int_S version;

	_COUNT_BYTE=info_sections.index;
	fseek(in,info_sections.index-1,0);
	ID_section(info_sections.index, version);
	dim=info_sections.length-16;

	ReadByte(nt);
	if(nt!=19999U)
	{
		if((data.flag_Huffman=(U_int_M*)mymalloc(sizeof(U_int_M)*(nt+1)))==NULL)
		{
			fprintf(stderr,"Not enough memory");  // no, exit //
			exit(2);
		}
		data.flag_Huffman[0]=nt;
		fgetpos(in,&filepos);
		for(i=1;i<=data.flag_Huffman[0];i++)
		{
			ReadByte(data.flag_Huffman[i]);
			ns+=data.flag_Huffman[i];
			Skip(9*data.flag_Huffman[i]);
		}
		fseek(in,filepos COMPAT,0);
		if((ns*9)>dim || !ns)
		{
			fprintf(stderr,"Cannot read data!!!");
			exit(2);
		}
		if(ns!=0 && (data.t_Huffman=(table_H*)mymalloc(sizeof(table_H)*ns))==NULL)         //array of 5 columns and ns rows
		{
			fprintf(stderr,"Not enough memory");  // no, exit //
			exit(2);
		}
		pos=0;
		for(j=0;j<data.flag_Huffman[0];j++)
		{
			Skip(2);
			for(i=0;i<data.flag_Huffman[j+1];i++)
			{
				ReadByte(data.t_Huffman[pos+i].bit_prefix);
				ReadByte(data.t_Huffman[pos+i].bit_code);
				ReadByte(data.t_Huffman[pos+i].TMS);
				ReadByte(data.t_Huffman[pos+i].base_value);
				ReadByte(data.t_Huffman[pos+i].base_code);
			}
			pos+=data.flag_Huffman[j+1]*9;         // by E.C. may 2004
		}
	}
	else
	{
		if((data.flag_Huffman=(U_int_M*)mymalloc(sizeof(U_int_M)*2))==NULL)
		{
			fprintf(stderr,"Not enough memory");  // no, exit //
			exit(2);
		}
		data.flag_Huffman[0]=1;
		data.flag_Huffman[1]=19;      //number of rows of the default Huffman table
		if((data.t_Huffman=(table_H*)mymalloc(sizeof(table_H)*data.flag_Huffman[1]))==NULL)
		{
			fprintf(stderr,"Not enough memory");  // no, exit //
			exit(2);
		}
		InitHuffman(data.t_Huffman);
	}
}//end section_2

//______________________________________________________________________________
//                              section 3
//______________________________________________________________________________

void section_3(pointer_section info_sections,DATA_DECODE &data, int_S version)
{
	U_int_S val, mask=0x1, i;
	int_S version_loc;

	_COUNT_BYTE=info_sections.index;
	fseek(in,info_sections.index-1,0);
	ID_section(info_sections.index, version_loc);

	ReadByte(data.flag_lead.number);
	ReadByte(val);
	if(val&mask)
		data.flag_lead.subtraction=1;
	else
		data.flag_lead.subtraction=0;
	mask<<=2;
	if(val&mask)
		data.flag_lead.all_simultaneously=1;
	else
		data.flag_lead.all_simultaneously=0;
	data.flag_lead.number_simultaneously=(val&0xF8)>>3;

	if (version==11)                        // by E.C. may 2004 ESAOTE
		data.flag_lead.number_simultaneously=8;

	if(data.flag_lead.number!=0 && (data.data_lead=(lead*)mymalloc(sizeof(lead)*data.flag_lead.number))==NULL)
	{
		fprintf(stderr,"Not enough memory");  // no, exit //
		exit(2);
	}
	for(i=0;i<data.flag_lead.number;i++)
	{
		ReadByte(data.data_lead[i].start);
		ReadByte(data.data_lead[i].end);
		ReadByte(data.data_lead[i].ID);
		if(data.data_lead[i].ID>85)
			data.data_lead[i].ID=0;
	}
}//end section_3

//______________________________________________________________________________
//                              section 4
//______________________________________________________________________________

void section_4(pointer_section info_sections,DATA_DECODE &data,int_S version)
{
	U_int_M i;
	int_S version_loc;

	_COUNT_BYTE=info_sections.index;
	fseek(in,info_sections.index-1,0);
	ID_section(info_sections.index, version_loc);

	ReadByte(data.flag_BdR0.length);
	ReadByte(data.flag_BdR0.fcM);
	ReadByte(data.flag_Res.number);
	if(data.flag_Res.bimodal || data.flag_lead.subtraction)     // by E.C. may 2004
	{
		if(data.flag_Res.number!=0 && (data.data_subtraction=(Subtraction_Zone*)mymalloc(sizeof(Subtraction_Zone)*data.flag_Res.number))==NULL)
		{
			fprintf(stderr,"Not enough memory");  // no, exit //
			exit(2);
		}
		for(i=0;i<data.flag_Res.number;i++)
		{
			ReadByte(data.data_subtraction[i].beat_type);
			ReadByte(data.data_subtraction[i].SB);
			ReadByte(data.data_subtraction[i].fc);
			ReadByte(data.data_subtraction[i].SE);
		}//end for
	}//end if
	if(data.flag_Res.bimodal || data.flag_lead.subtraction)     // by E.C. may 2004
	{
		if(data.flag_Res.number!=0 && (data.data_protected=(Protected_Area*)mymalloc(sizeof(Protected_Area)*data.flag_Res.number))==NULL)
		{
			fprintf(stderr,"Not enough memory");  // no, exit //
			exit(2);
		}
		for(i=0;i<data.flag_Res.number;i++)
			if ((version==10) || (version==11)) {               // by E.C. may 2004 SCP 1.0 no data 
				data.data_protected[i].QB=data.data_subtraction[i].SB;
				data.data_protected[i].QE=data.data_subtraction[i].SE;
			} else {
				ReadByte(data.data_protected[i].QB);
				ReadByte(data.data_protected[i].QE);
			}//end if/for
	}//end if
}//end section_4

//______________________________________________________________________________
//                              section 5
//______________________________________________________________________________

void section_5(pointer_section info_sections,DATA_DECODE &data, bool sez2)
{
	U_int_M i;
	U_int_L t, dim;
	U_int_M value;
	int_S version;

	_COUNT_BYTE=info_sections.index;
	fseek(in,info_sections.index-1,0);
	ID_section(info_sections.index, version);

	ReadByte(data.flag_BdR0.AVM);
	ReadByte(data.flag_BdR0.STM);
	ReadByte(data.flag_BdR0.encoding);
	if(data.flag_BdR0.encoding>2)
		data.flag_BdR0.encoding=0;
	Skip(1);
	if(data.flag_lead.number!=0 && (data.length_BdR0=(U_int_M*)mymalloc(sizeof(U_int_M)*data.flag_lead.number))==NULL)
	{
		fprintf(stderr,"Not enough memory");  // no, exit //
		exit(2);
	}
	dim=0;
	for(i=0;i<data.flag_lead.number;i++)
	{
		ReadByte(data.length_BdR0[i]);     //number of samples (2 bytes each) for each lead
		dim+=data.length_BdR0[i];
	}
	if(sez2)
	{
		data.flag_BdR0.number_samples=(U_int_L)data.flag_BdR0.length*1000L/(U_int_L)data.flag_BdR0.STM;           //number di campioni per elettrodo
		dim*=sizeof(U_int_S);
		if(dim!=0 && (data.samples_BdR0=(U_int_S*)mymalloc(dim))==NULL)
		{
			fprintf(stderr,"Not enough memory");  // no, exit //
			exit(2);
		}
		fread(data.samples_BdR0,sizeof(U_int_S),dim,in);
	}
	else
	{
		data.flag_BdR0.number_samples=dim/(sizeof(int_M)*data.flag_lead.number);       //number of samples per lead
		dim>>=1;
		dim*=sizeof(int_L);
		if(dim!=0 && (data.Median=(int_L*)mymalloc(dim))==NULL)
		{
			fprintf(stderr,"Not enough memory");  // no, exit //
			exit(2);
		}
		dim/=sizeof(int_L);
		for(t=0;t<dim;t++)
		{
			ReadByte(value);
			data.Median[t]=value;
			if(value>0x7FFF)
				data.Median[t]|=0xFFFF0000;
		}
	}
}//end section_5

//______________________________________________________________________________
//                              section 6
//______________________________________________________________________________

void section_6(pointer_section info_sections,DATA_DECODE &data, bool sez2)
{
	U_int_M i;
	U_int_L t, dim;
	U_int_M value;
	int_S version;

	_COUNT_BYTE=info_sections.index;
	fseek(in,info_sections.index-1,0);
	ID_section(info_sections.index, version);

	ReadByte(data.flag_Res.AVM);
	ReadByte(data.flag_Res.STM);
	ReadByte(data.flag_Res.encoding);
	if(data.flag_Res.encoding>2)
		data.flag_Res.encoding=0;
	Skip(1);
	if(data.flag_lead.number!=0 && (data.length_Res=(U_int_M*)mymalloc(sizeof(U_int_M)*data.flag_lead.number))==NULL)
	{
		fprintf(stderr,"Not enough memory");  // no, exit //
		exit(2);
	}
	dim=0;
	for(i=0;i<data.flag_lead.number;i++)
	{
		ReadByte(data.length_Res[i]);     //number of bytes for each lead
		dim+=data.length_Res[i];
	}
	if(sez2)
	{
		data.flag_Res.number_samples=data.data_lead[1].end-data.data_lead[1].start+1; //number of samples after interpolation
		dim*=sizeof(U_int_S);
		if(dim!=0 && (data.samples_Res=(U_int_S*)mymalloc(dim))==NULL)
		{
			fprintf(stderr,"Not enough memory");  // no, exit //
			exit(2);
		}
		fread(data.samples_Res,sizeof(U_int_S),dim,in);
	}
	else
	{
		data.flag_Res.number_samples=dim/(sizeof(int_M)*data.flag_lead.number);       //number of samples per lead
		dim>>=1;
		dim*=sizeof(int_L);
		if(dim!=0 && (data.Residual=(int_L*)mymalloc(dim))==NULL)
		{
			fprintf(stderr,"Not enough memory");  // no, exit //
			exit(2);
		}
		dim/=sizeof(int_L);
		for(t=0;t<dim;t++)
		{
			ReadByte(value);
			data.Residual[t]=value;
			if(value>0x7FFF)
				data.Residual[t]|=0xFFFF0000;
		}
	}
}//end section_6

//______________________________________________________________________________
//                              section 7
//______________________________________________________________________________

void section_7(pointer_section info_sections ,DATA_RECORD &data, int_S version)
{
	U_int_M i, j, dim;
	U_int_S lung;
	fpos_t filepos;
	int_S version_loc;
	int_L length_eval;

	_COUNT_BYTE=info_sections.index;
	fseek(in,info_sections.index-1,0);
	ID_section(info_sections.index, version_loc);

	ReadByte(data.data_global.number);
	//each value should be checked in _special!
	ReadByte(data.data_global.number_spike);
	if (version==11) ReadByte(data.data_global.number_spike);       // by E.C. may 2004 x ESAOTE!! This is an implementation error, for sure!
	ReadByte(data.data_global.average_RR);
	ReadByte(data.data_global.average_PP);
	if(Look(_special,0,3,data.data_global.number)<0)
	{
		if(data.data_global.number!=0 && (data.data_BdR=(BdR_measurement*)mymalloc(sizeof(BdR_measurement)*data.data_global.number))==NULL)
		{
			fprintf(stderr,"Not enough memory");  // no, exit //
			exit(2);
		}
		for(i=0;i<data.data_global.number;i++)
		{
			ReadByte(data.data_BdR[i].P_onset);
			ReadByte(data.data_BdR[i].P_offset);
			ReadByte(data.data_BdR[i].QRS_onset);
			ReadByte(data.data_BdR[i].QRS_offset);
			ReadByte(data.data_BdR[i].T_offset);
			ReadByte(data.data_BdR[i].P_axis);
			ReadByte(data.data_BdR[i].QRS_axis);
			ReadByte(data.data_BdR[i].T_axis);
		}//end for
	}
	if(Look(_special,0,3,data.data_global.number_spike)<0)
	{
		if(data.data_global.number_spike!=0 && (data.data_spike=(spike*)mymalloc(sizeof(spike)*data.data_global.number_spike))==NULL)
		{
			fprintf(stderr,"Not enough memory");  // no, exit //
			exit(2);
		}
		//spike time is in ms from the start of recording
		//amplitude is in signed uV
		for(i=0;i<data.data_global.number_spike;i++)
		{
			ReadByte(data.data_spike[i].time);
			ReadByte(data.data_spike[i].amplitude);
		}//end for
		for(i=0;i<data.data_global.number_spike;i++)
		{
			ReadByte(data.data_spike[i].type);
			if(data.data_spike[i].type>3)
				data.data_spike[i].type=0;
			ReadByte(data.data_spike[i].source);
			if(data.data_spike[i].source>2)
				data.data_spike[i].source=0;
			ReadByte(data.data_spike[i].index);
			ReadByte(data.data_spike[i].pulse_width);
		}//end for
	}//end if
	if (version<13) {          // by E.C. may 2004    CARDIOLINE & ESAOTE missing!!
		if ((data.data_global.average_RR>0) &&
			(data.data_global.average_RR<10000))
			data.data_global.ventricular_rate=60000.0/data.data_global.average_RR+0.5;
		return;
	}
// Insert by F.C.
	if (version>=13) {
		length_eval = 16 + 6 + data.data_global.number * 16 + data.data_global.number_spike * 4 + data.data_global.number_spike * 6;
		if (length_eval >= info_sections.length)
			return;
	}
// End of F.C. insertion
	ReadByte(data.data_global.number_QRS);
	if(Look(_special,0,3,data.data_global.number_QRS)<0)
	{
		fgetpos(in,&filepos);                         //necessary for ESAOTE and CARDIOLINE test files
		dim=info_sections.index+info_sections.length-filepos COMPAT+1;
		if(data.data_global.number_QRS>dim)
		{
			fprintf(stderr,"Error: Cannot extract these data!!!");
			exit(2);                                      //necessary for ESAOTE and CARDIOLINE test files
		} 
		if(data.data_global.number_QRS!=0 && (data.type_BdR=(U_int_S*)mymalloc(sizeof(U_int_S)*data.data_global.number_QRS))==NULL)
		{
			fprintf(stderr,"Not enough memory");  // no, exit //
			exit(2);
		}
		for(i=0;i<data.data_global.number_QRS;i++)
			ReadByte(data.type_BdR[i]);
	}
// Insert by F.C.
	if (version>=13) {
		length_eval += (2 + data.data_global.number_QRS);
		if (length_eval >= info_sections.length)
			return;
	}
// End of F.C. insertion
	ReadByte(data.data_global.ventricular_rate);
	ReadByte(data.data_global.atrial_rate);
	ReadByte(data.data_global.QT_corrected);
	ReadByte(data.data_global.formula_type);
	if(data.data_global.formula_type>2)
		data.data_global.formula_type=0;
	ReadByte(data.data_global.number_tag);
	if(data.data_global.number_tag)
	{
		data.data_global.number_tag-=2;
		data.data_global.number_tag/=7; // tag number 
		//warnig: this calculation is relative to the struc