decode_ddl.c

解吸SEED格式的源代码

}
 
d_P(prim)
struct prim_struct *prim;
{
	int i,j,num_bytes;
  
	extract_float = mantissa;
	for (i=0; i<prim->data.gain_code.num_codes; i++)
		{
		if (exponent == prim->data.gain_code.code[i])
			{
			if (prim->data.gain_code.mult[i] >= 0)
				extract_float = extract_float*prim->data.gain_code.mult[i];
			else
				extract_float = extract_float/(-prim->data.gain_code.mult[i]);

			break;
			}
		}

/*	discard = FALSE; */
	return;
}

d_E(prim)
struct prim_struct *prim;
{
/* calculate sample from mantissa and exponent */
	extract_exponent = pow ((double) prim->data.exponent.base, (double) ((prim->data.exponent.mult*(exponent+prim->data.exponent.bias))+prim->data.exponent.offset)  );

	extract_float = (double) mantissa * extract_exponent;

/*	discard = FALSE; */
	return;
}

d_Z(prim)
struct prim_struct *prim;
{
	if ((exponent == prim->data.zero_code.exponent) &&
	    (mantissa == prim->data.zero_code.mantissa))
		extract_float = 0.0;

/*	discard = FALSE; */
	return;
}

d_H(prim)
struct prim_struct *prim;
{
	extract_float += (double) hidden_mantissa * extract_exponent;

/*	discard = FALSE; */
	return;
}

void decode_key_int(head)
struct prim_struct *head;
{
	struct prim_struct *prim;
	int i;
 
	extract_accum = 0;
	extract_width = 0;

	prim = head;
	while (prim != NULL)
		{
		switch(prim->type)
			{
			case 'W': cur_data_ptr = d_W(cur_data_ptr, prim); break;
			case 'B': cur_data_ptr = d_B(cur_data_ptr, prim); break;
			case 'D': d_D(prim); break;
			case 'C': d_C(prim); break;
			case 'S': d_S1(prim); break;
			case 'A': d_A(prim); break;
			case 'X': discard = TRUE; break;
			case 'O': d_O(prim); break;
			case 'J': d_J(prim); break;
			case 'M': d_M(prim); break;
			case 'I': d_I(prim); break;
			case 'Y':
				{
				for (i=0; i<prim->data.repeat_fields.count; i++)
					decode_key_int(prim->next);
				return;
				}
			}
		prim = prim->next;
		}
	if (!discard)
		{
		mantissa = extract_accum;		/* make signed */
		*(seismic_data_ptr+demux) = mantissa;
		seismic_data_ptr += 1;
		}
	discard = FALSE;
}

void decode_int(head)
struct prim_struct *head;
{
	struct prim_struct *prim;
	int i;
 
	extract_accum = 0;
	extract_width = 0;

	prim = head;
	while (prim != NULL)
		{
		switch(prim->type)
			{
			case 'W': cur_data_ptr = d_W(cur_data_ptr, prim); break;
			case 'B': cur_data_ptr = d_B(cur_data_ptr, prim); break;
			case 'D': d_D(prim); break;
			case 'C': d_C(prim); break;
			case 'S': d_S1(prim); break;
			case 'A': d_A(prim); break;
			case 'X': discard = TRUE; break;
			case 'O': d_O(prim); break;
			case 'J': d_J(prim); break;
			case 'M': d_M(prim); break;
			case 'I': d_I(prim); break;
			}
		prim = prim->next;
		}
	discard = FALSE;
}

void decode_key_float(head)
struct prim_struct *head;
{
	struct prim_struct *prim;
	int i;
 
	extract_accum = 0;
	extract_width = 0;

	prim = head;
	while (prim != NULL)
		{
		switch(prim->type)
			{
			case 'W': cur_data_ptr = d_W(cur_data_ptr, prim); break;
			case 'B': cur_data_ptr = d_B(cur_data_ptr, prim); break;
			case 'D': d_D(prim); break;
			case 'C': d_C(prim); break;
			case 'S': d_S1(prim); break;
			case 'A': d_A(prim); break;
			case 'X': discard = TRUE; break;
			case 'O': d_O(prim); break;
			case 'J': d_J(prim); break;
			case 'E': d_E(prim); break;
			case 'P': d_P(prim); break;
			case 'Y':
				{
				extract_accum = 0;
				extract_width = 0;

				for (i=0; i<prim->data.repeat_fields.count; i++)
					decode_key_float(prim->next);
				return;
				}
			}
		prim = prim->next;
		}
	if (!discard)
		{
		*(seismic_data_ptr+demux) = (float) extract_float;
		seismic_data_ptr += 1;
		}
	discard = FALSE;
}
  
void decode_key_cmp1(head)
struct prim_struct *head;
{
	struct prim_struct *prim;
	int i;
 
	reverse_flag = FALSE;
	forward_flag = FALSE;
	prim = head;
	while (prim != NULL)
		{
		switch(prim->type)
			{
			case 'W': cur_data_ptr = d_W(cur_data_ptr, prim); break;
			case 'B': cur_data_ptr = d_B(cur_data_ptr, prim); break;
			case 'D': d_D(prim); break;
			case 'C': d_C(prim); break;
			case 'S': d_S1(prim); break;
			case 'A': d_A(prim); break;
			case 'X': discard = TRUE; break;
			case 'O': d_O(prim); break;
			case 'J': d_J(prim); break;
			case 'F': d_F(prim); break;
			case 'R': d_R(prim); break;
			case 'P':
				{
				cur_data_ptr = blk_data_ptr + prim->data.gain_code.code[0];
				break;
				}
			}
		prim = prim->next;
		}
 
	if (reverse_flag)
		{
		reverse_constant = extract_accum;
		reverse_flag = FALSE;
		}
 
	if (forward_flag)
		{
		forward_constant = extract_accum;
		forward_flag = FALSE;
		}
	discard = FALSE;
}
 
void decode_key_cmp2(head)
struct prim_struct *head;
{
	struct prim_struct *prim;
	int i;
 
	prim = head;
	while (prim != NULL)
		{
		switch(prim->type)
			{
			case 'W': cur_data_ptr = d_W(cur_data_ptr, prim); break;
			case 'B': cur_data_ptr = d_B(cur_data_ptr, prim); break;
			case 'X': discard = TRUE; break;
			case 'O': d_O(prim); break;
			case 'J': d_J(prim); break;
			case 'S': d_S2(prim); break;
			case 'N':
				compress_count = prim->data.control_number.number;
				break;
			case 'P':
				{
				if (!P_flag) /* only do this the first time */
					{
					cur_data_ptr = blk_data_ptr + prim->data.gain_code.code[0];
					P_flag = TRUE;
					}
				break;
				}
			}
		prim = prim->next;
		}
	discard = FALSE;
}
 
void decode_key_cmp3(head)
struct prim_struct *head;
{
	struct prim_struct *prim;
	int i;
 
	prim = head;
	while (prim != NULL)
		{
		switch(prim->type)
			{
			case 'W': cur_data_ptr = d_W(cur_data_ptr, prim); break;
			case 'B': cur_data_ptr = d_B(cur_data_ptr, prim); break;
			case 'D': d_D(prim); break;
			case 'C': d_C(prim); break;
			case 'S': d_S1(prim); break;
			case 'A': d_A(prim); break;
			case 'X': discard = TRUE; break;
			case 'O': d_O(prim); break;
			case 'J': d_J(prim); break;
			case 'N':
				if (prim->data.control_number.number != 0)
					{
					i = extract_accum;		/* make signed */
					if (extract_samples == 0) forward_constant = forward_constant - i;
					forward_constant += i;
					*seismic_data_ptr = forward_constant;
					seismic_data_ptr += 1;
					extract_samples++;
					}
				break;
			case 'Y':
				{
				extract_accum = 0;
				extract_width = 0;

				for (i=0; i<prim->data.repeat_fields.count; i++)
					decode_key_cmp3(prim->next);
				return;
				}
			}
		prim = prim->next;
		}
 
	if (!discard)
	{
		i = extract_accum;		/* make signed */
		if (extract_samples == 0) forward_constant = forward_constant - i;
		forward_constant += i;
		*seismic_data_ptr = forward_constant;
		seismic_data_ptr += 1;
		extract_samples++;
	}
	discard = FALSE;
}
 
void decode_key_cmp4(type30, nsamples)
struct type30 *type30;
int nsamples;
{
	struct prim_struct *prim;
	int i,j;
 
	for (i=0; i<compress_count; i++)
		{
		if (extract_samples < nsamples)
			{
			for (j=2; j<type30->number_keys; j++)
				{
				prim = (struct prim_struct *)type30->decoder_key_prim[j];
				if ((prim->type == 'T') && (prim->data.control_key.code==compress_code[i]))
					{
					decode_key_cmp3(prim->next);
					break;
					}
				}
			}
		}
}
 
void decode_ddl (data_ptr, nsamples, index, type30)
char *data_ptr;
int nsamples;
int index;
struct type30 *type30;
{
	int i, j, k;		/* counters */
 
	blk_data_ptr = data_ptr;
	cur_data_ptr = data_ptr;
 
	mult_chan = inter_flag = inter_size = discard = 0;
 
/*                +=======================================+                 */
/*================|   determine family type of decoding   |=================*/
/*                +=======================================+                 */
	switch (type30->family)
		{
		case 0:		/* Integer Family */
			{
			decode_int(type30->decoder_key_prim[0]);

			if (mult_chan > 1) data_hdr->num_mux_chan = mult_chan;
			else data_hdr->num_mux_chan = 1;

			extract_samples = 0;
			while (extract_samples < nsamples)
				{
				for (j = demux = 0;
				     j < data_hdr->num_mux_chan;
				     j++, demux += seis_buffer_length/data_hdr->num_mux_chan)
					{
					decode_key_int(type30->decoder_key_prim[1]);
					seismic_data_ptr -= 1;
					}
				extract_samples++;

				seismic_data_ptr += 1;
				}
			break;
			}
		case 1:		/* Gain Ranged Family */
			{
			decode_int(type30->decoder_key_prim[0]);
 
			if (mult_chan > 1) data_hdr->num_mux_chan = mult_chan;
			else data_hdr->num_mux_chan = 1;

			extract_samples = 0;
			while (extract_samples < nsamples)
				{
				for (j = demux = 0;
				     j < data_hdr->num_mux_chan;
				     j++, demux += seis_buffer_length/data_hdr->num_mux_chan)
					{
					decode_int(type30->decoder_key_prim[1]);
					mantissa = (int) extract_accum;
					decode_int(type30->decoder_key_prim[2]);
					exponent = (int) extract_accum;
					decode_key_float(type30->decoder_key_prim[3]); 
					seismic_data_ptr -= 1;
					}
				extract_samples++;
				seismic_data_ptr += 1;
				}
			break;
			}
		case 50:		/* Compression Family */
			{
			decode_key_cmp1(type30->decoder_key_prim[0]);
 
			P_flag = FALSE;
			extract_samples = 0;
			while (extract_samples < nsamples)
				{
				compress_count = 0;
				decode_key_cmp2(type30->decoder_key_prim[1]);
				decode_key_cmp4(type30, nsamples);
				}
			break;
			}
		default:
			{
			fprintf(stderr,"ERROR - Invalid DDL family code %d, data block ignored\n",
				type30->family);
			}
		}
}