Beispiel #1
0
int main(int argc, char **argv) {
  int infile, outfile, bufsize;
  size_t readbytes, thisread, nread, nwrote;
  off_t offsetbytes;
  off_t sook;
  double offset, length, framens;
  char msg[512], *buf, *bptr, *outname, *inname, *dotptr;
  struct mark5_stream *ms;

  outname = NULL;

  // m5slice test.m5b Mark5B-512-8-2 <offset> <length>

  if(argc !=5 )	{
    usage(argv[0]);
    return EXIT_FAILURE;
  }

  inname = argv[1];

  offset = atof(argv[3]); // Seconds
  length = atof(argv[4]); // Seconds

  ms = new_mark5_stream_absorb(new_mark5_stream_file(inname, 0),
			       new_mark5_format_generic_from_string(argv[2]));
		
  if(!ms) {
    fprintf(stderr, "Error: problem opening or decoding %s\n", inname);
    return EXIT_FAILURE;
  }

  framens = ms->framens;

  offsetbytes = (off_t)(ms->frameoffset + offset/framens*1e9*ms->framebytes);

  readbytes = length/framens*1e9*ms->framebytes;

  delete_mark5_stream(ms);

  infile = open(inname, OPENOPTIONS);
  if (infile==-1) {
    sprintf(msg, "Failed to open input file (%s) [%d]", 
	    inname, errno);
    perror(msg);
    return EXIT_FAILURE;
  }

  if (offsetbytes>0) {
    sook = lseek(infile, offsetbytes, SEEK_SET);
    if (sook==-1 || sook!=offsetbytes) {
      if (sook==-1)
	perror("Skiping to offset\n");
      else
	fprintf(stderr, "Could not offset to right place in file\n");
      close(infile);
      free(outname);
      return EXIT_FAILURE;
    }
  }
  
  // Create output file name if not set
  if (outname==NULL) {

    // File name contained in buffer
    dotptr = strrchr(inname, '.');

    outname = malloc(strlen(inname)+strlen("-slice")+1);
    if (outname==NULL) {
      close(infile);
      free(outname);
      return EXIT_FAILURE;
    }

    if (dotptr==NULL) {
      sprintf(outname, "%s-slice", inname);
    } else {
      *dotptr = 0;
      ++dotptr;
      sprintf(outname, "%s-slice.%s", inname, dotptr);
    }
  }

  outfile = creat(outname, S_IRUSR|S_IWUSR|S_IRGRP);
  if (outfile == -1) {
    fprintf(stderr, "Error creating output file \"%s\"\n", outname);
    perror(NULL);
    close(infile);
    return(0);
  }

  bufsize = BUFSIZE*1024;
  buf = malloc(bufsize);
  
  while (readbytes>0) {
    if (readbytes>bufsize) 
      thisread = bufsize;
    else
      thisread = readbytes;

    nread = read(infile, buf, thisread);

    if (nread==0) {
      printf("EOF detected before full slice read\n");
      close(infile);
      close(outfile);
      free(buf);
      free(outname);
      return EXIT_SUCCESS;

    } else if (nread==-1) {
      perror("Error reading file");
      close(outfile);
      close(infile);
      free(outname);
      free(buf);
      return EXIT_FAILURE;
    }
    readbytes -= nread;

    bptr = buf;
    while (nread>0) {
      nwrote = write(outfile, bptr, nread);
      if (nwrote==-1 || nwrote==0) {
	if (nwrote==-1)
	  perror("Error writing outfile");
	else 
	  fprintf(stderr, "Error writing outfile");
	close(outfile);
	close(infile);
	free(buf);
	free(outname);
	return EXIT_FAILURE;
      }
      nread -= nwrote;
    }
  }

  close(infile);
  close(outfile);
  free(outname);

  return EXIT_SUCCESS;
}
Beispiel #2
0
static int timeaverage(const char *filename, const char *formatname, double tint, double time,
		       const char *outfile, long long offset) {
  struct mark5_stream *ms;
  double **data=0, *avif;
  double complex **cdata=0;
  int i, status=0, nused;
  int nif;
  uint64_t totalsamples, nint, samplesDone, navg;
  FILE *out;
  int docomplex = 0;

  //total = unpacked = 0;

  ms = new_mark5_stream(new_mark5_stream_file(filename, offset),
			new_mark5_format_generic_from_string(formatname));

  if(!ms) {
    printf("Error: problem opening %s\n", filename);
    return EXIT_FAILURE;
  }

  mark5_stream_print(ms);

  if (ms->complex_decode != 0)  {
    printf("Complex decode\n");
    docomplex = 1;
  }

  out = fopen(outfile, "w");
  if(!out) {
    fprintf(stderr, "Error: cannot open %s for write\n", outfile);
    delete_mark5_stream(ms);
    return EXIT_FAILURE;
  }

  //R = nbin*freq/ms->samprate;

  nif = ms->nchan;
  totalsamples = (ms->samprate * time);  // Total number of samples to process
  nint  = (ms->samprate * tint/1000.0);  // Samples per itergration

  printf("DEBUG: %Ld samples per integration\n", (long long)nint);
  printf("DEBUG: %Ld total number of samples\n", (long long)totalsamples);

  if (docomplex)  {
    cdata = (complex double **)malloc(nif*sizeof(double complex*));
    for(i = 0; i < nif; i++) {
      cdata[i] = (complex double *)malloc(ChunkSize*sizeof(complex double));
    }
  } else {
    data = (double**)malloc(nif*sizeof(double*));
    for(i = 0; i < nif; i++) {
      data[i] = (double *)malloc(ChunkSize*sizeof(double));
    }
  } 
  avif = (double*)calloc(nif,sizeof(double));
	    
  if (ms->ns < 0 || ms->ns > 1000000000) {
    fflush(stdout);
    fprintf(stderr, "\n***Warning*** The nano-seconds portion of the timestamp is nonsensable: %d; continuing anyway, but don't expect the time alignment to be meaningful.\n\n", ms->ns);
  }
	    
  int iInt = 0;
  samplesDone = 0;
  navg = 0;
  nused = -1;
  while (samplesDone<totalsamples) {
    if(die) break;

    if (docomplex) {
      status = average_complex(ms, &nused, nint, &navg, avif, cdata);
    } else {
      status = average_real(ms, &nused, nint, &navg, avif, data);
    }
    if (status<0) {
      break;
    }

    if (navg>=nint) {
      fprintf(out, "%4d %10.6f", iInt, iInt*nint/(double)ms->samprate);
      iInt++;
      int i;
      for(i=0; i<nif; i++) {
	avif[i] /= navg;
	fprintf(out, " %1f", avif[i]);
	avif[i] = 0;
      }
      fprintf(out, "\n");
      samplesDone += navg;
      navg = 0;
    }
  }
  fclose(out);

  for(i = 0; i < nif; i++) {
    if (docomplex)
      free(cdata[i]);
    else
      free(data[i]);
  }
  if (docomplex)
    free(cdata);
  else
    free(data);
  free(avif);
  delete_mark5_stream(ms);

  if(status >= 0)
    status = EXIT_SUCCESS;
  return status;
}
Beispiel #3
0
DataStream *newDataStream(FILE *in)
{
	const int NItem = 7;
	DataStream *ds;
	char buffer[NItem][MaxLineLen+1];
	int i;
	char *v;

	ds = (DataStream *)calloc(1, sizeof(DataStream));

	for(i = 0; i < NItem; i++)
	{
		v = fgets(buffer[i], MaxLineLen, in);
		if(!v)
		{
			deleteDataStream(ds);
			
			return 0;
		}
		stripEOL(buffer[i]);
	}

	ds->inputFile = strdup(buffer[0]);
	ds->dataFormat = strdup(buffer[1]);
	ds->subBand = atoi(buffer[2]);
	ds->offset = atoll(buffer[3]);
	ds->fftSize = atoi(buffer[4]);
	ds->startChan = atoi(buffer[5]);
	ds->nChan = atoi(buffer[6]);
	if(ds->startChan < 0 || ds->startChan > ds->fftSize/2 ||
	   (ds->nChan > 0 && (ds->startChan + ds->nChan) > ds->fftSize/2) ||
	   (ds->nChan < 0 && (ds->startChan + ds->nChan) < -1))
	{
		printf("The start channel must be in 0 .. %d, inclusive, and\n"
		       "the number of channels to keep must be as well:\n"
		       "For file %s\n"
		       "you have %d < 0 or %d > %d with %d channels to keep\n",
			ds->fftSize/2, ds->inputFile, ds->startChan,
			ds->startChan, ds->fftSize/2, ds->nChan);

		deleteDataStream(ds);
		ds = 0;

		return 0;
	}

	ds->ms = new_mark5_stream_absorb(
		new_mark5_stream_file(ds->inputFile, ds->offset),
		new_mark5_format_generic_from_string(ds->dataFormat) );

	if(!ds->ms)
	{
		printf("problem opening %s\n", ds->inputFile);

		deleteDataStream(ds);
		ds = 0;
		
		return 0;
	}

	mark5_stream_print(ds->ms);

	ds->data = (double **)calloc(ds->ms->nchan, sizeof(double *));
	for(i = 0; i < ds->ms->nchan; i++)
	{
		ds->data[i] = (double *)calloc(ds->fftSize+2, sizeof(double));
	}
	ds->zdata = (fftw_complex *)calloc(ds->fftSize/2+2, sizeof(fftw_complex));
	ds->spec = (fftw_complex *)calloc(abs(ds->nChan), sizeof(fftw_complex));
	ds->plan = fftw_plan_dft_r2c_1d(ds->fftSize, ds->data[ds->subBand], ds->zdata, FFTW_ESTIMATE);

	ds->deltaF = (double)(ds->ms->samprate)/(double)(ds->fftSize);

	return ds;
}
Beispiel #4
0
static int fold(const char *filename, const char *formatname, int nbin, int nint,
	double freq, const char *outfile, long long offset)
{
	struct mark5_stream *ms;
	double **data=0, **bins=0;
	double complex **cdata=0;
	int **weight;
	int c, i, j, k, status;
	int nif, bin;
	long long total, unpacked;
	FILE *out;
	double R;
	long long sampnum;
	int docorrection = 1;
	int docomplex = 0;

	if(nbin < 0)
	{
		nbin = -nbin;
		docorrection = 0;
	}

	total = unpacked = 0;

	ms = new_mark5_stream(
		new_mark5_stream_file(filename, offset),
		new_mark5_format_generic_from_string(formatname) );

	if(!ms)
	{
		printf("Error: problem opening %s\n", filename);

		return EXIT_FAILURE;
	}

	if(ms->nbit < 2)
	{
		fprintf(stderr, "Warning: 1-bit data supplied.  Results will be\n");
		fprintf(stderr, "useless.  Proceeding anyway!\n\n");
	}

	if(ms->nbit > 2)
	{
		fprintf(stderr, "More than 2 bits: power not being corrected!\n");
		docorrection = 0;
	}

	mark5_stream_print(ms);

	if (ms->complex_decode != 0) 
	  {
	    printf("Complex decode\n");
	    docomplex = 1;
	  }

	sampnum = (long long)((double)ms->ns*(double)ms->samprate*1.0e-9 + 0.5);

	out = fopen(outfile, "w");
	if(!out)
	{
		fprintf(stderr, "Error: cannot open %s for write\n", outfile);
		delete_mark5_stream(ms);

		return EXIT_FAILURE;
	}

	R = nbin*freq/ms->samprate;

	nif = ms->nchan;

	if (!docomplex) 
	  {
	    data = (double **)malloc(nif*sizeof(double *));
	    bins = (double **)malloc(nif*sizeof(double *));
	    weight = (int **)malloc(nif*sizeof(int *));
	    for(i = 0; i < nif; i++)
	      {
		data[i] = (double *)malloc(ChunkSize*sizeof(double));
		bins[i] = (double *)calloc(nbin, sizeof(double));
		weight[i] = (int *)calloc(nbin, sizeof(int));
	      }
	    
	    if(ms->ns < 0 || ms->ns > 1000000000)
	      {
		fflush(stdout);
		fprintf(stderr, "\n***Warning*** The nano-seconds portion of the timestamp is nonsensable: %d; continuing anyway, but don't expect the time alignment to be meaningful.\n\n", ms->ns);
		
		sampnum = 0;
	      }
	    
	    for(j = 0; j < nint; j++)
	      {
		if(die)
		  {
		    break;
		  }
		
		status = mark5_stream_decode_double(ms, ChunkSize, data);
		
		if(status < 0)
		  {
		    break;
		  }
		else
		  {
		    total += ChunkSize;
		    unpacked += status;
		  }
		
		if(ms->consecutivefails > 5)
		  {
		    printf("Too many failures.  consecutive, total fails = %d %d\n", ms->consecutivefails, ms->nvalidatefail);
			
		    break;
		  }

		for(k = 0; k < ChunkSize; k++)
		  {
		    if(data[0][k] != 0.0)
		      {
			bin = ((long long)(sampnum*R)) % nbin;
			for(i = 0; i < nif; i++)
			  {
			    bins[i][bin] += data[i][k]*data[i][k];
			    weight[i][bin]++;
			  }
		      }
		    sampnum++;
		  }
	      }
	  } 
	else 
	  {
	    cdata = (complex double **)malloc(nif*sizeof(double complex*));
	    bins = (double **)malloc(nif*sizeof(double *));
	    weight = (int **)malloc(nif*sizeof(double *));
	    for(i = 0; i < nif; i++)
	      {
		cdata[i] = (complex double *)malloc(ChunkSize*sizeof(complex double));
		bins[i] = (double *)calloc(nbin, sizeof(double));
		weight[i] = (int *)calloc(nbin, sizeof(int));
	      }
	    
	    if(ms->ns < 0 || ms->ns > 1000000000)
	      {
		fflush(stdout);
		fprintf(stderr, "\n***Warning*** The nano-seconds portion of the timestamp is nonsensable: %d; continuing anyway, but don't expect the time alignment to be meaningful.\n\n", ms->ns);
		
		sampnum = 0;
	      }
	    
	    for(j = 0; j < nint; j++)
	      {
		if(die)
		  {
		    break;
		  }
		
		status = mark5_stream_decode_double_complex(ms, ChunkSize, cdata);
		
		if(status < 0)
		  {
		    break;
		  }
		else
		  {
		    total += ChunkSize;
		    unpacked += status;
		  }
		
		if(ms->consecutivefails > 5)
		  {
		    printf("Too many failures.  consecutive, total fails = %d %d\n", ms->consecutivefails, ms->nvalidatefail);
			
		    break;
		  }

		for(k = 0; k < ChunkSize; k++)
		  {
		    if(cdata[0][k] != 0.0)
		      {
			bin = ((long long)(sampnum*R)) % nbin;
			for(i = 0; i < nif; i++)
			  {
			    bins[i][bin] += creal(cdata[i][k])*creal(cdata[i][k]) +
			                   cimag(cdata[i][k])*cimag(cdata[i][k]);
			    weight[i][bin]++;
			  }
		      }
		    sampnum++;
		  }
	      }
	  }

	fprintf(stderr, "%lld / %lld samples unpacked\n", unpacked, total);

	/* normalize */
	for(k = 0; k < nbin; k++)
	{
		for(i = 0; i < nif; i++)
		{
			if(weight[i][k]) 
			{
				bins[i][k] /= weight[i][k];

			}
		}
	}

	/* convert the mean quantized voltage squared to nominal power */
	if(docorrection)
	{
		for(k = 0; k < nbin; k++)
		{
			for(i = 0; i < nif; i++)
			{
				bins[i][k] = correct_2bit_power(bins[i][k]);
			}
		}
	}

	for(c = 0; c < nbin; c++)
	{
		fprintf(out, "%11.9f ", c/(freq*nbin));
		for(i = 0; i < nif; i++)
		{
			fprintf(out, " %f", bins[i][c]);
		}
		fprintf(out, "\n");
	}

	fclose(out);

	for(i = 0; i < nif; i++)
	{
	  if (docomplex)
		free(cdata[i]);
	  else
		free(data[i]);
	  free(bins[i]);
	  free(weight[i]);
	}
	if (docomplex)
	  free(cdata);
	else
	  free(data);
	free(bins);
	free(weight);

	delete_mark5_stream(ms);

	return EXIT_SUCCESS;
}