int form_toa (char *name_data, char *name_predict, int subint, int chn, int nchn, long int imjd, long int smjd, double offs, double phase, double e_phase, long double *t, long double *e_dt, double *freqout)
// chn is the channel to form toa
// nchn is the total number of subchn
{
int h;
h = subint;
long double dt;
double offset; // offset of each subint
long double mjd0; // the mjd of each subint
T2Predictor pred;
int ret;
double period, frequency;
double freq[nchn];
// transform phase shift to TOAs
// get the freq of the subint
read_freq(name_data, h, freq, nchn);
frequency = freq[chn];
(*freqout) = frequency;
printf ("Frequency is %lf\n", frequency);
// get the period
print_t2pred(name_predict); // output t2pred.dat
T2Predictor_Init(&pred); // prepare the predictor
if (ret=T2Predictor_Read(&pred,(char *)"t2pred.dat"))
{
printf("Error: unable to read predictor\n");
exit(1);
}
// get the offset of each subint
offset = read_offs(name_data, h);
// get the period at mjd0
mjd0 = (long double)(imjd) + ((long double)(smjd) + (long double)(offs) + (long double)(offset))/86400.0L;
printf ("imjd is %ld \n", imjd);
printf ("mjd0 is %.15Lf \n", mjd0);
period = 1.0/T2Predictor_GetFrequency(&pred,mjd0,frequency);
printf ("Period is %.15lf\n", period);
// transform phase shift to time shift
//dt = (phase/M_PI)*period/2.0;
//e_dt = (e_phase/M_PI)*period/2.0;
dt = ((long double)(phase)/M_PI)*((long double)(period))/2.0L;
(*e_dt) = ((long double)(e_phase)/M_PI)*((long double)(period))/2.0L;
printf ("dt is %.10Lf +/- %.10Lf\n", dt, e_dt);
// calculate the TOA
(*t) = (long double)(imjd) + ((long double)(smjd) + (long double)(offs) - (long double)(dt) + (long double)(offset))/86400.0L;
//t = imjd;
printf ("offset is %lf\n", offset);
//fprintf (fp, "%s %lf %.15Lf %Lf 7\n", fname, frequency, t, e_dt*1e+6);
return 0;
}
//int main ( int argc, char *argv[] )
int read_prof ( char *name, int subint, double *profile, int nphase, int npol, int nchan)
{
double value[nphase*npol*nchan];
double scl[npol*nchan];
double offs[npol*nchan];
read_value (name, subint, value, nphase, nchan, npol);
read_offs (name, subint, offs, nchan, npol);
read_scl (name, subint, scl, nchan, npol);
int i,j,h;
for (i = 0; i < npol; i++) // print the results
//for (i = 0; i < nchan; i++) // print the results
{
for (h = 0; h < nchan; h++) // print the results
//for (h = 0; h < npol; h++) // print the results
{
for (j = 0; j < nphase; j++) // print the results
{
//profile[i*nchan*nphase+h*nphase+j] = value[i*nchan*nphase+h*nphase+j];
profile[i*nchan*nphase+h*nphase+j] = value[i*nchan*nphase+h*nphase+j]*scl[i*nchan+h] + offs[i*nchan+h];
//profile[i*npol*nphase+h*nphase+j] = value[i*npol*nphase+h*nphase+j]*scl[i*npol+h] + offs[i*npol+h];
//profile[i*nphase+j] = value[i*nphase+j];
//printf("%d %lf \n", i, profile[i]);
}
}
}
return 0;
}
static int mjpegb_decode_frame(AVCodecContext *avctx,
void *data, int *got_frame,
AVPacket *avpkt)
{
const uint8_t *buf = avpkt->data;
int buf_size = avpkt->size;
MJpegDecodeContext *s = avctx->priv_data;
const uint8_t *buf_end, *buf_ptr;
GetBitContext hgb; /* for the header */
uint32_t dqt_offs, dht_offs, sof_offs, sos_offs, second_field_offs;
uint32_t field_size, sod_offs;
int ret;
buf_ptr = buf;
buf_end = buf + buf_size;
s->got_picture = 0;
read_header:
/* reset on every SOI */
s->restart_interval = 0;
s->restart_count = 0;
s->mjpb_skiptosod = 0;
if (buf_end - buf_ptr >= 1 << 28)
return AVERROR_INVALIDDATA;
init_get_bits(&hgb, buf_ptr, /*buf_size*/(buf_end - buf_ptr)*8);
skip_bits(&hgb, 32); /* reserved zeros */
if (get_bits_long(&hgb, 32) != MKBETAG('m','j','p','g')) {
av_log(avctx, AV_LOG_WARNING, "not mjpeg-b (bad fourcc)\n");
return AVERROR_INVALIDDATA;
}
field_size = get_bits_long(&hgb, 32); /* field size */
av_log(avctx, AV_LOG_DEBUG, "field size: 0x%"PRIx32"\n", field_size);
skip_bits(&hgb, 32); /* padded field size */
second_field_offs = read_offs(avctx, &hgb, buf_end - buf_ptr, "second_field_offs is %d and size is %d\n");
av_log(avctx, AV_LOG_DEBUG, "second field offs: 0x%"PRIx32"\n",
second_field_offs);
dqt_offs = read_offs(avctx, &hgb, buf_end - buf_ptr, "dqt is %d and size is %d\n");
av_log(avctx, AV_LOG_DEBUG, "dqt offs: 0x%"PRIx32"\n", dqt_offs);
if (dqt_offs) {
init_get_bits(&s->gb, buf_ptr+dqt_offs, (buf_end - (buf_ptr+dqt_offs))*8);
s->start_code = DQT;
ret = ff_mjpeg_decode_dqt(s);
if (ret < 0 && (avctx->err_recognition & AV_EF_EXPLODE))
return ret;
}
dht_offs = read_offs(avctx, &hgb, buf_end - buf_ptr, "dht is %d and size is %d\n");
av_log(avctx, AV_LOG_DEBUG, "dht offs: 0x%"PRIx32"\n", dht_offs);
if (dht_offs) {
init_get_bits(&s->gb, buf_ptr+dht_offs, (buf_end - (buf_ptr+dht_offs))*8);
s->start_code = DHT;
ff_mjpeg_decode_dht(s);
}
sof_offs = read_offs(avctx, &hgb, buf_end - buf_ptr, "sof is %d and size is %d\n");
av_log(avctx, AV_LOG_DEBUG, "sof offs: 0x%"PRIx32"\n", sof_offs);
if (sof_offs) {
init_get_bits(&s->gb, buf_ptr+sof_offs, (buf_end - (buf_ptr+sof_offs))*8);
s->start_code = SOF0;
if ((ret = ff_mjpeg_decode_sof(s)) < 0)
return ret;
}
sos_offs = read_offs(avctx, &hgb, buf_end - buf_ptr, "sos is %d and size is %d\n");
av_log(avctx, AV_LOG_DEBUG, "sos offs: 0x%"PRIx32"\n", sos_offs);
sod_offs = read_offs(avctx, &hgb, buf_end - buf_ptr, "sof is %d and size is %d\n");
av_log(avctx, AV_LOG_DEBUG, "sod offs: 0x%"PRIx32"\n", sod_offs);
if (sos_offs) {
init_get_bits(&s->gb, buf_ptr + sos_offs,
8 * FFMIN(field_size, buf_end - buf_ptr - sos_offs));
s->mjpb_skiptosod = (sod_offs - sos_offs - show_bits(&s->gb, 16));
s->start_code = SOS;
ret = ff_mjpeg_decode_sos(s, NULL, 0, NULL);
if (ret < 0 && (avctx->err_recognition & AV_EF_EXPLODE))
return ret;
}
if (s->interlaced) {
s->bottom_field ^= 1;
/* if not bottom field, do not output image yet */
if (s->bottom_field != s->interlace_polarity && second_field_offs) {
buf_ptr = buf + second_field_offs;
goto read_header;
}
}
//XXX FIXME factorize, this looks very similar to the EOI code
if(!s->got_picture) {
av_log(avctx, AV_LOG_WARNING, "no picture\n");
return buf_size;
}
if ((ret = av_frame_ref(data, s->picture_ptr)) < 0)
return ret;
*got_frame = 1;
if (!s->lossless && avctx->debug & FF_DEBUG_QP) {
av_log(avctx, AV_LOG_DEBUG, "QP: %d\n",
FFMAX3(s->qscale[0], s->qscale[1], s->qscale[2]));
}
return buf_size;
}
static int mjpegb_decode_frame(AVCodecContext *avctx,
void *data, int *data_size,
AVPacket *avpkt)
{
const uint8_t *buf = avpkt->data;
int buf_size = avpkt->size;
MJpegDecodeContext *s = avctx->priv_data;
const uint8_t *buf_end, *buf_ptr;
AVFrame *picture = data;
GetBitContext hgb; /* for the header */
uint32_t dqt_offs, dht_offs, sof_offs, sos_offs, second_field_offs;
uint32_t field_size, sod_offs;
buf_ptr = buf;
buf_end = buf + buf_size;
read_header:
/* reset on every SOI */
s->restart_interval = 0;
s->restart_count = 0;
s->mjpb_skiptosod = 0;
init_get_bits(&hgb, buf_ptr, /*buf_size*/(buf_end - buf_ptr)*8);
skip_bits(&hgb, 32); /* reserved zeros */
if (get_bits_long(&hgb, 32) != MKBETAG('m','j','p','g'))
{
av_log(avctx, AV_LOG_WARNING, "not mjpeg-b (bad fourcc)\n");
return 0;
}
field_size = get_bits_long(&hgb, 32); /* field size */
av_log(avctx, AV_LOG_DEBUG, "field size: 0x%x\n", field_size);
skip_bits(&hgb, 32); /* padded field size */
second_field_offs = read_offs(avctx, &hgb, buf_end - buf_ptr, "second_field_offs is %d and size is %d\n");
av_log(avctx, AV_LOG_DEBUG, "second field offs: 0x%x\n", second_field_offs);
dqt_offs = read_offs(avctx, &hgb, buf_end - buf_ptr, "dqt is %d and size is %d\n");
av_log(avctx, AV_LOG_DEBUG, "dqt offs: 0x%x\n", dqt_offs);
if (dqt_offs)
{
init_get_bits(&s->gb, buf_ptr+dqt_offs, (buf_end - (buf_ptr+dqt_offs))*8);
s->start_code = DQT;
ff_mjpeg_decode_dqt(s);
}
dht_offs = read_offs(avctx, &hgb, buf_end - buf_ptr, "dht is %d and size is %d\n");
av_log(avctx, AV_LOG_DEBUG, "dht offs: 0x%x\n", dht_offs);
if (dht_offs)
{
init_get_bits(&s->gb, buf_ptr+dht_offs, (buf_end - (buf_ptr+dht_offs))*8);
s->start_code = DHT;
ff_mjpeg_decode_dht(s);
}
sof_offs = read_offs(avctx, &hgb, buf_end - buf_ptr, "sof is %d and size is %d\n");
av_log(avctx, AV_LOG_DEBUG, "sof offs: 0x%x\n", sof_offs);
if (sof_offs)
{
init_get_bits(&s->gb, buf_ptr+sof_offs, (buf_end - (buf_ptr+sof_offs))*8);
s->start_code = SOF0;
if (ff_mjpeg_decode_sof(s) < 0)
return -1;
}
sos_offs = read_offs(avctx, &hgb, buf_end - buf_ptr, "sos is %d and size is %d\n");
av_log(avctx, AV_LOG_DEBUG, "sos offs: 0x%x\n", sos_offs);
sod_offs = read_offs(avctx, &hgb, buf_end - buf_ptr, "sof is %d and size is %d\n");
av_log(avctx, AV_LOG_DEBUG, "sod offs: 0x%x\n", sod_offs);
if (sos_offs)
{
// init_get_bits(&s->gb, buf+sos_offs, (buf_end - (buf+sos_offs))*8);
init_get_bits(&s->gb, buf_ptr+sos_offs, field_size*8);
s->mjpb_skiptosod = (sod_offs - sos_offs - show_bits(&s->gb, 16));
s->start_code = SOS;
ff_mjpeg_decode_sos(s, NULL, NULL);
}
if (s->interlaced) {
s->bottom_field ^= 1;
/* if not bottom field, do not output image yet */
if (s->bottom_field != s->interlace_polarity && second_field_offs)
{
buf_ptr = buf + second_field_offs;
second_field_offs = 0;
goto read_header;
}
}
//XXX FIXME factorize, this looks very similar to the EOI code
*picture= *s->picture_ptr;
*data_size = sizeof(AVFrame);
if(!s->lossless){
picture->quality= FFMAX3(s->qscale[0], s->qscale[1], s->qscale[2]);
picture->qstride= 0;
picture->qscale_table= s->qscale_table;
memset(picture->qscale_table, picture->quality, (s->width+15)/16);
if(avctx->debug & FF_DEBUG_QP)
av_log(avctx, AV_LOG_DEBUG, "QP: %d\n", picture->quality);
picture->quality*= FF_QP2LAMBDA;
}
return buf_ptr - buf;
}
int main (int argc, char *argv[])
{
int h,i,j,k,m,z;
//////////////////////////////////////////////////////
char inName[128]; // name of input data file
char fname[128]; // name of data file
char ext[128]; // extension of new data file
char ext0[]="D"; // default extension of new data file
int nstokes;
int mode = 0; // default: creat new file ".D"
//int pmode = 0; // default: use predictor
char tdisName[128]; // name of tdis file
int tdisMode = 0; // default: no tdis read
int index, n;
int indexTdis;
double DM;
int DMstatus = 0;
for (i=0;i<argc;i++)
{
if (strcmp(argv[i],"-f") == 0)
{
index = i + 1;
n = 0;
while ( (index + n) < argc && strcmp(argv[index+n],"-e") != 0 && strcmp(argv[index+n],"-r") != 0 && strcmp(argv[index+n],"-DM") != 0 && strcmp(argv[index+n],"-tdis") != 0)
{
n++;
}
//strcpy(fname,argv[++i]);
}
else if (strcmp(argv[i],"-e") == 0)
{
strcpy(ext,argv[++i]);
mode = 1; // creat new file with new extension
}
//else if (strcmp(argv[i],"-np") == 0) // not use predictor
//{
// pmode = 1;
//}
else if (strcmp(argv[i],"-r") == 0) // file name of tdis
{
indexTdis = i + 1;
}
else if (strcmp(argv[i],"-tdis") == 0) // use tdis1 and tdis2
{
tdisMode = 1;
}
else if (strcmp(argv[i],"-DM") == 0) // use input DM
{
DMstatus = 1;
DM = atof(argv[++i]);
}
}
T2Predictor pred;
/////////////////////////////////////////////////////////////////////////////////
// start to deal with different data file
for (k = 0; k < n; k++)
{
// get the data file name
strcpy(inName,argv[k+index]);
if (mode == 0)
{
createNewfile(inName, fname, ext0);
printf ("%s\n", fname);
}
else
{
createNewfile(inName, fname, ext);
printf ("%s\n", fname);
}
////////////////////////////////////////////////////
double freqRef; // observing central freq at SSB
double cfreq; // observing central freq, e.g., 1369 MHz
freqRef = read_obsFreqSSB (fname);
cfreq = read_obsFreq (fname);
//freqRef = 1369.0; // MHz
double dm;
if (DMstatus == 1)
{
dm = DM;
}
else
{
dm = readDm(fname);
}
printf ("DM0: %.4lf\n", dm);
T2Predictor_Init(&pred);
int ret;
if (ret=T2Predictor_ReadFits(&pred,fname))
{
printf("Error: unable to read predictor\n");
exit(1);
}
long int imjd, smjd;
double offs, mjd, subint_offs;
imjd = stt_imjd(fname);
smjd = stt_smjd(fname);
offs = stt_offs(fname);
double psrfreq;
double psrfreq0;
psrfreq0 = read_psrfreq (fname);
////////////////////////////////////////////////
int nphase;
int nchn;
int nsub;
int npol;
nchn = get_nchan(fname);
npol = get_npol(fname);
nsub = get_subint(fname);
nphase = get_nphase(fname);
//printf ("%d\n", nchn);
////////////////////////////////////////////////
double tdis1[nchn],tdis2[nchn],freqSSB[nchn];
FILE *fp;
{
strcpy(tdisName,argv[k+indexTdis]);
printf ("%s\n", tdisName);
if ((fp = fopen(tdisName, "r")) == NULL)
{
fprintf (stdout, "Can't open file\n");
exit(1);
}
m = 0;
while (fscanf(fp, "%lf %lf %lf", &tdis1[m],&tdis2[m],&freqSSB[m]) == 3)
{
//printf ("%lf\n", tdis[m]);
m++;
}
if (fclose (fp) != 0)
fprintf (stderr, "Error closing\n");
}
////////////////////////////////////////////////////////////////////////////////
double *p_multi, *p_multi_deDM;
p_multi = (double *)malloc(sizeof(double)*nchn*npol*nphase);
p_multi_deDM = (double *)malloc(sizeof(double)*nchn*npol*nphase);
double *p_temp, *p_temp_deDM;
p_temp = (double *)malloc(sizeof(double)*npol*nphase);
p_temp_deDM = (double *)malloc(sizeof(double)*npol*nphase);
double phaseShift;
double phaseShift0;
double freq[nchn];
double batPsrFreq = 208.0;
// start to derive toa from different subint
for (h = 1; h <= nsub; h++)
{
subint_offs = read_offs(fname, h);
batPsrFreq = read_batFreq(fname, h);
mjd = imjd + (smjd + offs + subint_offs)/86400.0L;
//printf ("mjd: %lf\n", mjd);
psrfreq = T2Predictor_GetFrequency(&pred,mjd,cfreq);
printf ("psr freq %.10lf %.10lf\n", batPsrFreq, psrfreq);
// read profiles from data file
read_prof(fname,h,p_multi,nphase);
read_freq(fname,h,freq,nchn);
//readfile(argv[2],&n,tt,p_multi);
// start to derive toas for different channels
for (i = 0; i < nchn; i++)
{
//psrfreq = T2Predictor_GetFrequency(&pred,mjd,freq[i]);
phaseShift0 = 2.0*M_PI*(T2Predictor_GetPhase(&pred,mjd,freq[i])-floor(T2Predictor_GetPhase(&pred,mjd,freq[i])));
//printf ("Chn%d\n", i);
z = 0;
for (nstokes = 0; nstokes < npol; nstokes++)
{
for (j = 0; j < nphase; j++)
{
p_temp[z] = p_multi[nstokes*nchn*nphase + i*nphase + j];
//printf ("%d %lf\n", n, p_temp[n]);
z++;
}
}
// dedisperse
if (tdisMode == 1)
{
phaseShift = phaseShiftDMtdis (tdis1[i], tdis2[i], psrfreq, freqSSB[i], dm, batPsrFreq);
//phaseShift = phaseShiftDMtdis (tdis1[i], tdis2[i], psrfreq, freqSSB[i], dm, psrfreq0);
}
else
{
//printf ("%lf\n", freq[i]);
phaseShift = phaseShiftDM (dm, freq[i], pred, mjd, freqRef, psrfreq);
}
//printf ("phase shift %.10lf %.10lf\n", phaseShift0, phaseShift);
deDM (nphase, npol, p_temp, phaseShift, p_temp_deDM);
for (nstokes = 0; nstokes < npol; nstokes++)
{
for (j = 0; j < nphase; j++)
{
p_multi_deDM[nstokes*nchn*nphase + i*nphase + j] = p_temp_deDM[j];
//printf ("%d %lf\n", j, p_temp_deDM[j]);
}
}
}
write_prof (fname, h, p_multi_deDM, nphase);
modify_freq (fname, h, freqRef, nchn, freqSSB);
}
free(p_multi);
free(p_multi_deDM);
free(p_temp);
free(p_temp_deDM);
T2Predictor_Destroy(&pred);
}
return 0;
}
