static void writeexec(struct GlobalVars *gv,FILE *f)
/* creates a TOS executable file (which is relocatable) */
{
struct LinkedSection *sections[3];
int nsyms = tos_initwrite(gv,sections);
int i;
tos_header(f,sections[0] ? sections[0]->size+sections[0]->gapsize : 0,
sections[1] ? sections[1]->size+sections[1]->gapsize : 0,
sections[2] ? sections[2]->size : 0,
(unsigned long)nsyms*sizeof(struct DRIsym),gv->tosflags);
for (i=0; i<3; i++)
calc_relocs(gv,sections[i]);
if (sections[0]) {
fwritex(f,sections[0]->data,sections[0]->filesize);
fwritegap(f,(sections[0]->size-sections[0]->filesize)+sections[0]->gapsize);
}
if (sections[1]) {
fwritex(f,sections[1]->data,sections[1]->filesize);
fwritegap(f,(sections[1]->size-sections[1]->filesize)+sections[1]->gapsize);
}
if (nsyms)
tos_symboltable(gv,f,sections);
tos_writerelocs(gv,f,sections);
}
int main(int argc, char **argv)
{
int m = ORDER, stable, i;
FILE *fp = stdin;
double *k, *a, g = GAMMA;
Boolean flags = STABLE;
if ((cmnd = strrchr(argv[0], '/')) == NULL)
cmnd = argv[0];
else
cmnd++;
while (--argc)
if (**++argv == '-') {
switch (*(*argv + 1)) {
case 'm':
m = atoi(*++argv);
--argc;
break;
case 'g':
g = atof(*++argv);
--argc;
break;
case 'c':
g = atoi(*++argv);
--argc;
if (g < 1)
fprintf(stderr, "%s : value of c must be c>=1!\n", cmnd);
g = -1.0 / g;
break;
case 's':
flags = 1 - flags;
break;
case 'h':
usage(0);
default:
fprintf(stderr, "%s : Invalid option '%c'!\n", cmnd, *(*argv + 1));
usage(1);
}
} else
fp = getfp(*argv, "rb");
a = dgetmem(m + m + 2);
k = a + m + 1;
while (freadf(a, sizeof(*a), m + 1, fp) == m + 1) {
if (g != 1.0)
for (i = 1; i <= m; i++)
a[i] *= g;
stable = lpc2par(a, k, m);
if (flags)
fwritex(&stable, sizeof(stable), 1, stdout);
else
fwritef(k, sizeof(*k), m + 1, stdout);
}
return (0);
}
static void write_dri_sym(FILE *f,const char *name,
uint16_t type,uint32_t value)
{
struct DRIsym stab;
int longname = strlen(name) > DRI_NAMELEN;
strncpy(stab.name,name,DRI_NAMELEN);
write16be(stab.type,longname?(type|STYP_LONGNAME):type);
write32be(stab.value,value);
fwritex(f,&stab,sizeof(struct DRIsym));
if (longname) {
char rest_of_name[sizeof(struct DRIsym)];
memset(rest_of_name,0,sizeof(struct DRIsym));
strncpy(rest_of_name,name+DRI_NAMELEN,sizeof(struct DRIsym));
fwritex(f,rest_of_name,sizeof(struct DRIsym));
}
}
static void tos_header(FILE *f,unsigned long tsize,unsigned long dsize,
unsigned long bsize,unsigned long ssize,
unsigned long flags)
{
PH hdr;
write16be(hdr.ph_branch,0x601a);
write32be(hdr.ph_tlen,tsize);
write32be(hdr.ph_dlen,dsize);
write32be(hdr.ph_blen,bsize);
write32be(hdr.ph_slen,ssize);
write32be(hdr.ph_magic,0);
write32be(hdr.ph_flags,flags);
write16be(hdr.ph_abs,0);
fwritex(f,&hdr,sizeof(PH));
}
void conv(FILE * fp, size_t iosize)
{
long adrs, n;
int i;
char ibuf[BUFSIZE], obuf[BUFSIZE];
int ffseek(FILE * fp, long off);
if (ffseek(fp, adrs = start + iosize * sno))
return;
for (n = sno; (adrs <= _end) && (n <= eno); adrs += iosize, ++n) {
freadx(ibuf, iosize, 1, fp);
if (feof(fp))
break;
for (i = 0; i < (int) iosize; ++i)
obuf[i] = ibuf[iosize - 1 - i];
fwritex(obuf, iosize, 1, stdout);
}
return;
}
Vdec_ReturnType vdec_post_input_buffer(struct VDecoder *dec, video_input_frame_info *frame, void *cookie)
{
QTV_MSG_PRIO3(QTVDIAG_GENERAL,QTVDIAG_PRIO_LOW,"vdec: post_input data=%p len=%d cookie=%p\n", frame->data, frame->len, cookie);
#ifdef LOG_INPUT_BUFFERS
static int take_input = 1;
#endif
int fatal_err = 0;
/*checkBufAvail flag is needed since we do not need to checkout
* YUV/Slice buffer incase the NAL corresponds to same frame.
* This is required for multiple NALs in one input buffer
*/
bool checkBufAvail = true;
VDEC_INPUT_BUFFER input;
VideoDecoder *pDec = (VideoDecoder*)(dec->core);
VDEC_ERROR err = VDEC_ERR_EVERYTHING_FINE;
if (NULL == dec || NULL == frame || NULL == frame->data )
{
QTV_MSG_PRIO3(QTVDIAG_GENERAL,QTVDIAG_PRIO_ERROR,"vdec: error: encountered NULL parameter dec: 0x%x frame: 0x%x data: 0x%x\n",
(unsigned int)dec,
(unsigned int)frame,
(unsigned int)frame->data);
return VDEC_EFAILED;
}
input.buffer[0] = (unsigned char*)frame->data;
input.timestamp[0] = (long long)frame->timestamp;
input.buffer_size[0] = (unsigned long int)frame->len;
input.buffer_pos[0] = 0;
input.layers = 1;
input.eOSIndicator[0]= false;
QTV_MSG_PRIO1(QTVDIAG_GENERAL,QTVDIAG_PRIO_MED,"vdec: received ts: %lld", frame->timestamp);
if (frame->timestamp < timestamp )
{
QTV_MSG_PRIO2(QTVDIAG_GENERAL,QTVDIAG_PRIO_MED,"vdec: error: out of order stamp! %d < %d\n",
(int)(frame->timestamp&0xFFFFFFFF), timestamp);
}
timestamp = (int)frame->timestamp;
QTV_MSG_PRIO2(QTVDIAG_GENERAL,QTVDIAG_PRIO_MED,"vdec: vdec_core_post_input. buffer_size[0]: %ld frame->flags: 0x%x\n",
input.buffer_size[0], frame->flags);
if (input.buffer_size[0] == 0 && frame->flags & FRAME_FLAG_EOS)
{
QTV_MSG_PRIO(QTVDIAG_GENERAL,QTVDIAG_PRIO_LOW,"vdec: Zero-length buffer with EOS bit set\n");
input.eOSIndicator[0] = true;
if(pDec)
err = pDec->EOS( );
else
err = VDEC_ERR_NULL_STREAM_ID;
if(VDEC_ERR_OUT_OF_BUFFERS == err) return VDEC_EOUTOFBUFFERS;
vdec_decoder_info->ctxt->buffer_done(vdec_decoder_info->ctxt, cookie);
if (VDEC_ERR_EVERYTHING_FINE == err) return VDEC_SUCCESS;
return VDEC_EFAILED;
}
QTV_MSG_PRIO(QTVDIAG_GENERAL,QTVDIAG_PRIO_LOW,"vdec: vdec_core_post_input\n");
#ifdef LOG_INPUT_BUFFERS
if (take_input)
{
fwritex((unsigned char*)frame->data, frame->len, pInputFile);
QTV_MSG_PRIO2(QTVDIAG_GENERAL,QTVDIAG_PRIO_HIGH,"vdec: frame %d frame->len %d\n", counter++, frame->len);
}
#endif
do {
QPERF_TIME(arm_decode, err = pDec->Decode( &input, checkBufAvail ));
if (VDEC_ERR_EVERYTHING_FINE != err)
{
QTV_MSG_PRIO1(QTVDIAG_GENERAL,QTVDIAG_PRIO_HIGH,"vdec: vdec_decoder error: %d\n", (int)err);
if(VDEC_ERR_UNSUPPORTED_DIMENSIONS == err) {
fatal_err = 1;
break;
}
}
checkBufAvail = false;
} while( ( VDEC_ERR_EVERYTHING_FINE == err ) && ( 0 != input.buffer_size[0] ) );
#ifdef LOG_INPUT_BUFFERS
take_input = (err==14?0:1);
#endif
if(VDEC_ERR_OUT_OF_BUFFERS == err) return VDEC_EOUTOFBUFFERS;
vdec_input_buffer_release_cb_handler(pDec,&input,cookie);
if(VDEC_ERR_EVERYTHING_FINE == err) return VDEC_SUCCESS;
if(fatal_err) {
static struct vdec_frame frame;
memset(&frame, 0, sizeof(frame));
frame.flags |= FRAME_FLAG_FATAL_ERROR;
QPERF_END(frame_data);
vdec_decoder_info->ctxt->frame_done(vdec_decoder_info->ctxt, &frame);
}
return VDEC_EFAILED;
}
void vdec_frame_cb_handler ( const VDEC_STREAM_ID /*stream*/,
VDEC_CB_STATUS status,
VDEC_FRAME * const pFrame,
unsigned long int /*nBytesConsumed*/,
void * const pCbData )
{
int index;
++nFrameDoneCnt;
QTV_MSG_PRIO1(QTVDIAG_GENERAL,QTVDIAG_PRIO_MED,"vdec: frame done cb cnt: %d", nFrameDoneCnt);
switch(status)
{
case VDEC_STATUS_GOOD_FRAME:
case VDEC_STATUS_FLUSH:
{
if (NULL == pFrame)
{
QTV_MSG_PRIO(QTVDIAG_GENERAL,QTVDIAG_PRIO_HIGH,"vdec: pFrame parameter is NULL, dropping frame\n");
break;
}
//Iterate through the output frame array to locate corresponding index
for (index=0; index<vdec_decoder_info->ctxt->outputBuffer.numBuffers; index++)
{
//if (pFrame->pBuf == (VDEC_BYTE*)vdec_decoder_info->output[index].phys)
if (pFrame->pBuf == (VDEC_BYTE*)vdec_decoder_info->output[index].base)
{
break;
}
}
if (vdec_decoder_info->ctxt->outputBuffer.numBuffers == index)
{
QTV_MSG_PRIO1(QTVDIAG_GENERAL,QTVDIAG_PRIO_HIGH,"vdec: error: unable to map address %p, dropping frame\n", pFrame->pBuf);
}
else
{
if(VDEC_STATUS_FLUSH == status)
{
vdec_decoder_info->output[index].flags |= FRAME_FLAG_FLUSHED;
}
else
{
++nGoodFrameCnt;
#ifdef PROFILE_DECODER
++qperf_total_frame_cnt;
#endif
vdec_decoder_info->output[index].flags = 0;
QTV_MSG_PRIO1(QTVDIAG_GENERAL,QTVDIAG_PRIO_LOW,"vdec: callback status good frame, cnt: %d\n", nGoodFrameCnt);
#ifdef LOG_YUV_FRAMES
if (pYUVFile)
{
int size = vdec_decoder_info->width*vdec_decoder_info->height*1.5;
fwritex(vdec_decoder_info->output[index].base, size, pYUVFile);
}
#endif
}
if(nGoodFrameCnt >1)
{
QPERF_END(frame_data);
}
QPERF_START(frame_data);
vdec_decoder_info->output[index].timestamp = pFrame->timestamp;
if(pFrame->frameType == VDEC_FRAMETYPE_I)
{
vdec_decoder_info->output[index].frameDetails.ePicType[0] = VDEC_PICTURE_TYPE_I;
}
if(pFrame->frameType == VDEC_FRAMETYPE_B)
{
vdec_decoder_info->output[index].frameDetails.ePicType[0] = VDEC_PICTURE_TYPE_B;
}
if(pFrame->frameType == VDEC_FRAMETYPE_P)
{
vdec_decoder_info->output[index].frameDetails.ePicType[0] = VDEC_PICTURE_TYPE_P;
}
vdec_decoder_info->ctxt->frame_done(vdec_decoder_info->ctxt, &vdec_decoder_info->output[index]);
}
break;
}
case VDEC_STATUS_DECODE_ERROR:
{
QTV_MSG_PRIO(QTVDIAG_GENERAL,QTVDIAG_PRIO_ERROR,"vdec: callback status decode error\n");
break;
}
case VDEC_STATUS_FATAL_ERROR:
{
QTV_MSG_PRIO(QTVDIAG_GENERAL,QTVDIAG_PRIO_FATAL,"vdec: callback status error fatal\n");
//Iterate through the output frame array to locate corresponding index
for (index=0; index<vdec_decoder_info->ctxt->outputBuffer.numBuffers; index++)
{
if (pFrame->pBuf == (VDEC_BYTE*)vdec_decoder_info->output[index].base)
{
break;
}
}
if (vdec_decoder_info->ctxt->outputBuffer.numBuffers == index)
{
QTV_MSG_PRIO1(QTVDIAG_GENERAL,QTVDIAG_PRIO_FATAL,
"vdec: error: unable to map address %p for VDEC_STATUS_FATAL_ERROR, dropping frame\n", pFrame->pBuf);
}
else
{
QTV_MSG_PRIO1(QTVDIAG_GENERAL,QTVDIAG_PRIO_FATAL,"vdec: frame done index = %d\n",index);
vdec_decoder_info->output[index].flags = FRAME_FLAG_FATAL_ERROR;
vdec_decoder_info->ctxt->frame_done(vdec_decoder_info->ctxt, &vdec_decoder_info->output[index]);
}
break;
}
case VDEC_STATUS_VOP_NOT_CODED:
{
QTV_MSG_PRIO(QTVDIAG_GENERAL,QTVDIAG_PRIO_HIGH,"vdec: callback status not coded\n");
break;
}
case VDEC_STATUS_SUSPEND_DONE:
{
QTV_MSG_PRIO(QTVDIAG_GENERAL,QTVDIAG_PRIO_MED,"vdec: callback status suspend done\n");
break;
}
case VDEC_STATUS_EOS:
{
static struct vdec_frame frame;
memset(&frame, 0, sizeof(frame));
frame.flags |= FRAME_FLAG_EOS;
QPERF_END(frame_data);
vdec_decoder_info->ctxt->frame_done(vdec_decoder_info->ctxt, &frame);
QTV_MSG_PRIO(QTVDIAG_GENERAL,QTVDIAG_PRIO_LOW,"vdec: callback status EOS\n");
break;
}
default:
QTV_MSG_PRIO(QTVDIAG_GENERAL,QTVDIAG_PRIO_HIGH,"vdec: callback status unknown status\n");
break;
}
return;
}
int main(int argc, char **argv)
{
FILE *fp2 = NULL, *fp1 = stdin;
int start = START, leng1 = LENG1, leng2 = LENG2, i, j, flag = 1;
size_t size = sizeof(float);
Boolean write = WRITE;
char *y, c, *s;
long double x;
if ((cmnd = strrchr(argv[0], '/')) == NULL)
cmnd = argv[0];
else
cmnd++;
while (--argc)
if (*(s = *++argv) == '-') {
c = *++s;
switch (c) {
case 's':
start = atoi(*++argv);
--argc;
break;
case 'l':
leng1 = atoi(*++argv);
--argc;
break;
case 'n':
leng1 = atoi(*++argv) + 1;
--argc;
break;
case 'L':
leng2 = atoi(*++argv);
--argc;
break;
case 'N':
leng2 = atoi(*++argv) + 1;
--argc;
break;
case 'o':
write = 1 - write;
break;
case 'h':
usage(0);
default:
fprintf(stderr, "%s : Invalid option '%c'!\n", cmnd, *(*argv + 1));
usage(1);
}
} else if (*s == '+') {
c = *++s;
switch (c) {
case 'c':
size = sizeof(char);
break;
case 's':
size = sizeof(short);
break;
case 'i':
if (*(s + 1) == '3') {
size = 3;
(*argv)++;
} else {
size = sizeof(int);
}
break;
case 'l':
if (*(s + 1) == 'e') {
size = sizeof(long long);
(*argv)++;
} else {
size = sizeof(long);
}
break;
case 'C':
size = sizeof(unsigned char);
break;
case 'S':
size = sizeof(unsigned short);
break;
case 'I':
if (*(s + 1) == '3') {
size = 3;
(*argv)++;
} else {
size = sizeof(unsigned int);
}
break;
case 'L':
if (*(s + 1) == 'E') {
size = sizeof(unsigned long long);
(*argv)++;
} else {
size = sizeof(unsigned long);
}
break;
case 'f':
size = sizeof(float);
break;
case 'd':
if (*(s + 1) == 'e') {
size = sizeof(long double);
(*argv)++;
} else {
size = sizeof(double);
}
break;
default:
fprintf(stderr, "%s : Invalid option '%c'!\n", cmnd, *(*argv + 1));
usage(1);
}
} else if (fp2 == NULL)
fp2 = getfp(*argv, "rb");
else
fp1 = getfp(*argv, "rb");
if (fp2 == NULL) {
fprintf(stderr, "%s : Inserted data must be specified !\n", cmnd);
usage(1);
}
y = (char *) dgetmem(leng2 * size);
for (;;) {
for (j = start, i = leng1; j-- && i--;) {
if (freadx(&x, size, 1, fp1) != 1)
break;
fwritex(&x, size, 1, stdout);
}
for (j = leng2; j--;)
if (write) {
if (freadx(&x, size, 1, fp1) != 1)
break;
i--;
}
if (freadx(y, size, leng2, fp2) != leng2)
if (!flag)
break;
fwritex(y, size, leng2, stdout);
flag = 0;
for (; i-- > 0;) {
if (freadx(&x, size, 1, fp1) != 1)
break;
fwritex(&x, size, 1, stdout);
}
}
if ((fgetc(fp1) == EOF) && (fgetc(fp2) == EOF)) {
if (feof(fp1) && feof(fp2))
return (0);
}
return (1);
}
int main(int argc, char **argv)
{
int l = LENG, cbsize = CBSIZE, index;
Boolean qflag = QFLAG;
FILE *fp = stdin, *fpcb = NULL;
double *x, *qx, *cb;
if ((cmnd = strrchr(argv[0], '/')) == NULL)
cmnd = argv[0];
else
cmnd++;
while (--argc)
if (**++argv == '-') {
switch (*(*argv + 1)) {
case 'l':
l = atoi(*++argv);
--argc;
break;
case 'n':
l = atoi(*++argv) + 1;
--argc;
break;
case 's':
cbsize = atoi(*++argv);
--argc;
break;
case 'q':
qflag = 1 - qflag;
break;
case 'h':
usage(0);
default:
fprintf(stderr, "%s : Invalid option '%c'!\n", cmnd, *(*argv + 1));
usage(1);
}
} else if (fpcb == NULL)
fpcb = getfp(*argv, "rb");
else
fp = getfp(*argv, "rb");
fseek(fpcb, 0, 2);
#ifdef DOUBLE
cbsize = ftell(fpcb) / sizeof(double) / l;
#else
cbsize = ftell(fpcb) / sizeof(float) / l;
#endif /* DOUBLE */
rewind(fpcb);
x = dgetmem(l + l + cbsize * l);
qx = x + l;
cb = qx + l;
if (freadf(cb, sizeof(*cb), cbsize * l, fpcb) != cbsize * l) {
fprintf(stderr, "%s : Codebook size error!\n", cmnd);
return (1);
}
if (!qflag)
while (freadf(x, sizeof(*x), l, fp) == l) {
index = vq(x, cb, l, cbsize);
fwritex(&index, sizeof(index), 1, stdout);
} else
while (freadf(x, sizeof(*x), l, fp) == l) {
index = vq(x, cb, l, cbsize);
ivq(index, cb, l, qx);
fwritef(qx, sizeof(*qx), l, stdout);
}
return (0);
}
static void rawseg_writeexec(struct GlobalVars *gv,FILE *f)
/* creates a new file for each segment, writes file name, start address */
/* and length into the output file */
{
const char *fn = "rawseg_writeexec(): ";
bool firstsec;
unsigned long addr;
FILE *segf;
struct Phdr *p;
struct LinkedSection *ls,*prevls;
struct SegReloc *srlist;
char buf[256];
for (p=gv->phdrlist; p; p=p->next) {
if (p->type==PT_LOAD && (p->flags&PHDR_USED) &&
p->start!=ADDR_NONE && p->start_vma!=ADDR_NONE) {
firstsec = TRUE;
srlist = NULL;
snprintf(buf,256,"%s.%s",gv->dest_name,p->name);
segf = fopen(buf,"wb");
if (segf == NULL) {
error(29,buf); /* cannot create file */
continue;
}
/* write file name, start address and length of segment to output */
fprintf(f,"\"%s\" 0x%llx 0x%llx\n",buf,p->start,p->mem_end-p->start);
/* write segment's sections */
for (ls=(struct LinkedSection *)gv->lnksec.first;
ls->n.next!=NULL; ls=(struct LinkedSection *)ls->n.next) {
if (ls->copybase>=(unsigned long)p->start &&
(ls->copybase+ls->size)<=(unsigned long)p->mem_end &&
(ls->flags & SF_ALLOC)) {
if (gv->keep_relocs) {
/* remember relocations, adjusted from section to segment base */
struct Reloc *r;
struct RelocInsert *ri;
struct LinkedSection *relsec;
struct Phdr *relph;
for (r=(struct Reloc *)ls->relocs.first;
r->n.next!=NULL; r=(struct Reloc *)r->n.next) {
if (ri = r->insert) {
if (r->rtype!=R_ABS || ri->bpos!=0 || ri->bsiz!=32) {
/* only absolute 32-bit relocs are supported */
error(32,fff_rawseg.tname,reloc_name[r->rtype],
(int)ri->bpos,(int)ri->bsiz,ri->mask,
ls->name,r->offset);
continue;
}
}
else
continue;
if (r->relocsect.lnk == NULL) {
if (r->flags & RELF_DYNLINK)
continue; /* NULL, because it was resolved by a sh.obj. */
else
ierror("%sReloc type %d (%s) at %s+0x%lx "
"(addend 0x%llx) is missing a relocsect.lnk",
fn,(int)r->rtype,reloc_name[r->rtype],ls->name,
r->offset,r->addend);
}
relsec = r->relocsect.lnk;
/* find out to which segment relsec belongs */
for (relph=gv->phdrlist; relph; relph=relph->next) {
if (relph->type==PT_LOAD && (relph->flags&PHDR_USED) &&
relph->start!=ADDR_NONE && relph->start_vma!=ADDR_NONE) {
if (relsec->copybase>=(unsigned long)relph->start &&
(relsec->copybase+relsec->size)<=
(unsigned long)relph->mem_end &&
(relsec->flags & SF_ALLOC))
break;
}
}
/* use segment's base address for relocation instead */
if (relph) {
lword segoffs,a,v;
struct SegReloc *newsr,*srp;
segoffs = (lword)relsec->copybase - relph->start;
v = writesection(gv,ls->data+r->offset,r,r->addend+segoffs);
if (v != 0) {
/* Calculated value doesn't fit into relocation type x ... */
if (ri = r->insert)
error(35,gv->dest_name,ls->name,r->offset,v,
reloc_name[r->rtype],(int)ri->bpos,
(int)ri->bsiz,ri->mask);
else
ierror("%sReloc (%s+%lx), type=%s, without RelocInsert",
fn,ls->name,r->offset,reloc_name[r->rtype]);
}
/* remember relocation offset and segment for later */
newsr = alloc(sizeof(struct SegReloc));
newsr->next = NULL;
newsr->seg = relph;
newsr->offset = (ls->copybase - (unsigned long)p->start) +
r->offset;
if (srp = srlist) {
while (srp->next)
srp = srp->next;
srp->next = newsr;
}
else
srlist = newsr;
}
else
ierror("%sNo segment for reloc offset section '%s'",
fn,relsec->name);
}
}
else
calc_relocs(gv,ls);
if (!firstsec) {
/* write an alignment gap, when needed */
if (ls->copybase > addr)
fwritegap(segf,ls->copybase-addr);
else if (ls->copybase < addr)
error(98,fff[gv->dest_format]->tname,ls->name,prevls->name);
}
else
firstsec = FALSE;
fwritex(segf,ls->data,ls->size);
addr = ls->copybase + ls->size;
prevls = ls;
}
}
fclose(segf);
if (srlist) {
/* write relocation files for this segment */
struct Phdr *relph;
struct SegReloc *sr;
uint32_t rcnt;
FILE *rf;
for (relph=gv->phdrlist; relph; relph=relph->next) {
for (sr=srlist,rf=NULL,rcnt=0; sr; sr=sr->next) {
if (sr->seg == relph) {
if (!rf) {
snprintf(buf,256,"%s.%s.rel%s",
gv->dest_name,p->name,relph->name);
rf = fopen(buf,"wb");
if (rf == NULL) {
error(29,buf); /* cannot create file */
continue;
}
fwritegap(rf,4); /* number of relocs will be stored here */
}
if (gv->endianess == _BIG_ENDIAN_)
fwrite32be(rf,sr->offset);
else
fwrite32le(rf,sr->offset);
rcnt++;
}
}
if (rf) {
/* write number of relocs into the first word */
fseek(rf,0,SEEK_SET);
if (gv->endianess == _BIG_ENDIAN_)
fwrite32be(rf,rcnt);
else
fwrite32le(rf,rcnt);
fclose(rf);
}
}
}
}
}
}
int main(int argc, char **argv)
{
int l = LENG, *cbsize, *index, stage = 0, ss = 0, num, i;
char **cbfile;
FILE *fp = stdin, *fpcb;
double *cb = NULL, *x, *qx, *p;
Boolean qflag = QFLAG;
cbsize = (int *) calloc(argc / 2, sizeof(*cbsize));
index = (int *) calloc(argc / 2, sizeof(*index));
cbfile = (char **) calloc(argc / 2, sizeof(**cbfile));
if ((cmnd = strrchr(argv[0], '/')) == NULL)
cmnd = argv[0];
else
cmnd++;
while (--argc)
if (**++argv == '-') {
switch (*(*argv + 1)) {
case 'l':
l = atoi(*++argv);
--argc;
break;
case 'n':
l = atoi(*++argv) + 1;
--argc;
break;
case 's':
cbsize[stage] = atoi(*++argv);
cbfile[stage++] = *++argv;
argc -= 2;
break;
case 'q':
qflag = 1 - qflag;
break;
case 'h':
usage(0);
default:
fprintf(stderr, "%s : Invalid option '%c'!\n", cmnd, *(*argv + 1));
usage(1);
}
} else
fp = getfp(*argv, "rb");
for (i = 0, num = 0; i < stage; i++)
num += cbsize[i];
cb = dgetmem(num * l);
p = cb;
for (i = 0; i < stage; i++) {
fpcb = getfp(cbfile[i], "rb");
if (freadf(p, sizeof(*p), cbsize[i] * l, fpcb) != cbsize[i] * l) {
fprintf(stderr, "%s : Codebook size error of %d stage!\n", cmnd, ss);
return (1);
}
p += cbsize[i] * l;
}
x = dgetmem(l + l);
qx = x + l;
if (!qflag)
while (freadf(x, sizeof(*x), l, fp) == l) {
msvq(x, cb, l, cbsize, stage, index);
fwritex(index, sizeof(*index), stage, stdout);
} else
while (freadf(x, sizeof(*x), l, fp) == l) {
msvq(x, cb, l, cbsize, stage, index);
imsvq(index, cb, l, cbsize, stage, qx);
fwritef(qx, sizeof(*qx), l, stdout);
}
return (0);
}
void write_file(long fs, char BIT, char *rawfile, char *wavfile)
{
FILE *fpi, *fpo;
char RIFF[] = "RIFF";
char WAVE[] = "WAVE";
char fmt_chunk[] = "fmt ";
char data_chunk[] = "data";
int file_size, rawfile_size;
int chunk_size = 16;
int data_speed;
short formatID = 1;
short channel = 1; /* mono:1¡¤stereo:2 */
short block_size; /* 16bit, mono => 16bit*1=2byte */
short bit;
int c, buf[2] = { 0, 0 };
fpi = getfp(rawfile, "rb");
fpo = getfp(wavfile, "wb");
fseek(fpi, 0, SEEK_END);
rawfile_size = ftell(fpi);
file_size = rawfile_size + 36;
fseek(fpi, 0, SEEK_SET);
/* RIFF header */
fwritex(RIFF, sizeof(char), 4, fpo);
/* file size */
buf[0] = file_size;
fwrite_little_endian(buf, 4, 1, fpo);
/* WAVE header */
fwritex(WAVE, sizeof(char), 4, fpo);
/* fmt chunk */
fwritex(fmt_chunk, sizeof(char), 4, fpo);
/* chunk size */
buf[0] = chunk_size;
fwrite_little_endian(buf, 4, 1, fpo);
/* formatID */
fwritex(&formatID, sizeof(short), 1, fpo);
/* channel (mono:1¡¤stereo:2) */
fwritex(&channel, sizeof(short), 1, fpo);
/* sampling frequency */
buf[0] = fs;
fwrite_little_endian(buf, 4, 1, fpo);
/* data speed */
data_speed = fs * BIT / 8 * formatID;
buf[0] = data_speed;
fwrite_little_endian(buf, 4, 1, fpo);
/* block size */
block_size = BIT / 8 * formatID;
fwritex(&block_size, sizeof(short), 1, fpo);
/* bit number */
bit = BIT;
fwritex(&bit, sizeof(short), 1, fpo);
/* data chunk */
fwritex(data_chunk, sizeof(char), 4, fpo);
/* file size of data */
buf[0] = rawfile_size;
fwrite_little_endian(buf, 4, 1, fpo);
while ((c = fgetc(fpi)) != EOF)
fputc(c, fpo);
fclose(fpi);
fclose(fpo);
}
static void aoutmint_writeexec(struct GlobalVars *gv,FILE *f)
/* creates an a.out-MiNT executable file */
{
const int be = _BIG_ENDIAN_;
uint8_t jmp_entry_code[] = { 0x20,0x3a,0x00,0x1a,0x4e,0xfb,0x08,0xfa };
struct LinkedSection *sections[3];
unsigned long secsizes[2];
struct mint_exec me;
long tparel_offset,tparel_size;
struct nlist32 *stksize;
aout_initwrite(gv,sections);
if (sections[0] == NULL) /* this requires a .text section! */
error(97,fff[gv->dest_format]->tname,TEXTNAME);
memset(&me,0,sizeof(struct mint_exec)); /* init header with zero */
text_data_bss_gaps(sections); /* calculate gap size between sections */
secsizes[0] = sections[0]->size + sections[0]->gapsize;
secsizes[1] = sections[1] ? sections[1]->filesize : 0;
/* init TOS header */
write16be(me.tos.ph_branch,0x601a);
write32be(me.tos.ph_tlen,secsizes[0]+TEXT_OFFSET);
write32be(me.tos.ph_dlen,secsizes[1]);
write32be(me.tos.ph_blen,(sections[2]?sections[2]->size:0) +
(sections[1]?sections[1]->gapsize:0));
write32be(me.tos.ph_magic,0x4d694e54); /* "MiNT" */
write32be(me.tos.ph_flags,gv->tosflags); /* Atari memory flags */
write16be(me.tos.ph_abs,0); /* includes relocations */
aout_addsymlist(gv,sections,BIND_GLOBAL,0,be);
aout_addsymlist(gv,sections,BIND_WEAK,0,be);
aout_addsymlist(gv,sections,BIND_LOCAL,0,be);
aout_debugsyms(gv,be);
calc_relocs(gv,sections[0]);
calc_relocs(gv,sections[1]);
/* The Atari symbol table size is the sum of a.out symbols and strings,
which is now known. */
write32be(me.tos.ph_slen,aoutsymlist.nextindex * sizeof(struct nlist32) +
aoutstrlist.nextoffset);
/* set jmp_entry to move.l a_entry(pc),d0
jmp (-6,pc,d0.l) */
memcpy(me.jmp_entry,jmp_entry_code,sizeof(jmp_entry_code));
/* init a.out NMAGIC header */
SETMIDMAG(&me.aout,NMAGIC,0,0);
write32be(me.aout.a_text,sections[0]->size+sections[0]->gapsize);
write32be(me.aout.a_data,sections[1]?sections[1]->filesize:0);
write32be(me.aout.a_bss,(sections[2]?sections[2]->size:0) +
(sections[1]?sections[1]->gapsize:0));
write32be(me.aout.a_syms,aoutsymlist.nextindex*sizeof(struct nlist32));
write32be(me.aout.a_entry,TEXT_OFFSET);
/* save offset to __stksize when symbol is present */
if (stksize = find_aout_sym("__stksize")) {
write32be(me.stkpos,
read32be(&stksize->n_value)+sizeof(me)-TEXT_OFFSET);
}
/* write a.out-MiNT header (256 bytes) */
fwritex(f,&me,sizeof(me));
/* write sections */
fwritex(f,sections[0]->data,sections[0]->size);
fwritegap(f,sections[0]->gapsize);
if (sections[1])
fwritex(f,sections[1]->data,sections[1]->filesize);
/* write a.out symbols */
aout_writesymbols(f);
aout_writestrings(f,be);
/* write TPA relocs */
tparel_offset = ftell(f);
tos_writerelocs(gv,f,sections);
tparel_size = ftell(f) - tparel_offset;
/* we have to patch tparel_pos and tparel_size in the header, as we
didn't know about the size of the TPA relocs table before */
fseek(f,offsetof(struct mint_exec,tparel_pos),SEEK_SET);
fwrite32be(f,tparel_offset);
fwrite32be(f,tparel_size);
}
/* fwritef : write double type data */
int fwritef(double *ptr, const size_t size, const int nitems, FILE * fp)
{
return (fwritex(ptr, size, nitems, fp));
}
