void Transcode(CStdString &file)
{
OrkLogManager::Instance()->Initialize();
ObjectFactory::GetSingleton()->Initialize();
ConfigManager::Instance()->Initialize();
std::list<ACE_DLL> pluginDlls;
LoadPlugins(pluginDlls);
// Register in-built filters
FilterRef filter(new AlawToPcmFilter());
FilterRegistry::instance()->RegisterFilter(filter);
filter.reset(new UlawToPcmFilter());
FilterRegistry::instance()->RegisterFilter(filter);
filter.reset(new GsmToPcmFilter());
FilterRegistry::instance()->RegisterFilter(filter);
filter.reset(new IlbcToPcmFilter());
FilterRegistry::instance()->RegisterFilter(filter);
filter.reset(new AudioGainFilter());
FilterRegistry::instance()->RegisterFilter(filter);
filter.reset(new G722ToPcmFilter());
FilterRegistry::instance()->RegisterFilter(filter);
filter.reset(new SpeexDecoder() );
FilterRegistry::instance()->RegisterFilter(filter);
filter.reset(new G721CodecDecoder());
FilterRegistry::instance()->RegisterFilter(filter);
// Register in-built tape processors and build the processing chain
BatchProcessing::Initialize();
Reporting::Initialize();
TapeFileNaming::Initialize();
if (!ACE_Thread_Manager::instance()->spawn(ACE_THR_FUNC(BatchProcessing::ThreadHandler)))
{
LOG4CXX_INFO(LOG.rootLog, CStdString("Failed to create batch processing thread"));
}
// Transmit the tape to the BatchProcessing
CStdString ProcessorName("BatchProcessing");
TapeProcessorRef bp = TapeProcessorRegistry::instance()->GetNewTapeProcessor(ProcessorName);
CStdString portName("SinglePort");
AudioTapeRef tape(new AudioTape(portName, file));
bp->AddAudioTape(tape);
// Make sure it stops after processing
tape.reset();
bp->AddAudioTape(tape);
// Wait for completion
while(!Daemon::Singleton()->IsStopping())
{
ACE_OS::sleep(1);
}
}
void optimize(
size_t n ,
CppAD::vector<size_t>& dep_taddr ,
player<Base>* play ,
recorder<Base>* rec )
{
// temporary indices
size_t i, j, k;
// temporary variables
OpCode op; // current operator
const size_t *arg; // operator arguments
size_t i_var; // index of first result for current operator
// range and domain dimensions for F
size_t m = dep_taddr.size();
// number of variables in the player
const size_t num_var = play->num_rec_var();
// number of VecAD indices
size_t num_vecad_ind = play->num_rec_vecad_ind();
// number of VecAD vectors
size_t num_vecad_vec = play->num_rec_vecad_vec();
// -------------------------------------------------------------
// data structure that maps variable index in original operation
// sequence to corresponding operator information
CppAD::vector<struct optimize_old_variable> tape(num_var);
// -------------------------------------------------------------
// Determine how each variable is connected to the dependent variables
// initialize all variables has having no connections
for(i = 0; i < num_var; i++)
tape[i].connect = not_connected;
for(j = 0; j < m; j++)
{ // mark dependent variables as having one or more connections
tape[ dep_taddr[j] ].connect = yes_connected;
}
// vecad_connect contains a value for each VecAD object.
// vecad maps a VecAD index (which corresponds to the beginning of the
// VecAD object) to the vecad_connect falg for the VecAD object.
CppAD::vector<optimize_connection> vecad_connect(num_vecad_vec);
CppAD::vector<size_t> vecad(num_vecad_ind);
j = 0;
for(i = 0; i < num_vecad_vec; i++)
{ vecad_connect[i] = not_connected;
// length of this VecAD
size_t length = play->GetVecInd(j);
// set to proper index for this VecAD
vecad[j] = i;
for(k = 1; k <= length; k++)
vecad[j+k] = num_vecad_vec; // invalid index
// start of next VecAD
j += length + 1;
}
CPPAD_ASSERT_UNKNOWN( j == num_vecad_ind );
// Initialize a reverse mode sweep through the operation sequence
size_t i_op;
play->start_reverse(op, arg, i_op, i_var);
CPPAD_ASSERT_UNKNOWN( op == EndOp );
size_t mask;
while(op != BeginOp)
{ // next op
play->next_reverse(op, arg, i_op, i_var);
// This if is not necessary becasue last assignment
// with this value of i_var will have NumRes(op) > 0
if( NumRes(op) > 0 )
{ tape[i_var].op = op;
tape[i_var].arg = arg;
}
# ifndef NDEBUG
if( i_op <= n )
{ CPPAD_ASSERT_UNKNOWN((op == InvOp) | (op == BeginOp));
}
else CPPAD_ASSERT_UNKNOWN((op != InvOp) & (op != BeginOp));
# endif
switch( op )
{
// Unary operator where operand is arg[0]
case AbsOp:
case AcosOp:
case AsinOp:
case AtanOp:
case CosOp:
case CoshOp:
case DisOp:
case DivvpOp:
case ExpOp:
case LogOp:
case PowvpOp:
case SinOp:
case SinhOp:
case SqrtOp:
if( tape[i_var].connect != not_connected )
tape[arg[0]].connect = yes_connected;
break; // --------------------------------------------
// Unary operator where operand is arg[1]
case DivpvOp:
case MulpvOp:
case PowpvOp:
case PrivOp:
if( tape[i_var].connect != not_connected )
tape[arg[1]].connect = yes_connected;
break; // --------------------------------------------
// Special case for SubvpOp
case SubvpOp:
if( tape[i_var].connect != not_connected )
{
if( tape[arg[0]].connect == not_connected )
tape[arg[0]].connect = sum_connected;
else
tape[arg[0]].connect = yes_connected;
if( tape[i_var].connect == sum_connected )
tape[i_var].connect = csum_connected;
}
break; // --------------------------------------------
// Special case for AddpvOp and SubpvOp
case AddpvOp:
case SubpvOp:
if( tape[i_var].connect != not_connected )
{
if( tape[arg[1]].connect == not_connected )
tape[arg[1]].connect = sum_connected;
else
tape[arg[1]].connect = yes_connected;
if( tape[i_var].connect == sum_connected )
tape[i_var].connect = csum_connected;
}
break; // --------------------------------------------
// Special case for AddvvOp and SubvvOp
case AddvvOp:
case SubvvOp:
if( tape[i_var].connect != not_connected )
{
if( tape[arg[0]].connect == not_connected )
tape[arg[0]].connect = sum_connected;
else
tape[arg[0]].connect = yes_connected;
if( tape[arg[1]].connect == not_connected )
tape[arg[1]].connect = sum_connected;
else
tape[arg[1]].connect = yes_connected;
if( tape[i_var].connect == sum_connected )
tape[i_var].connect = csum_connected;
}
break; // --------------------------------------------
// Other binary operators
// where operands are arg[0], arg[1]
case DivvvOp:
case MulvvOp:
case PowvvOp:
if( tape[i_var].connect != not_connected )
{
tape[arg[0]].connect = yes_connected;
tape[arg[1]].connect = yes_connected;
}
break; // --------------------------------------------
// Conditional expression operators
case CExpOp:
CPPAD_ASSERT_UNKNOWN( NumArg(CExpOp) == 6 );
if( tape[i_var].connect != not_connected )
{
mask = 1;
for(i = 2; i < 6; i++)
{ if( arg[1] & mask )
{ CPPAD_ASSERT_UNKNOWN( arg[i] < i_var );
tape[arg[i]].connect = yes_connected;
}
mask = mask << 1;
}
}
break; // --------------------------------------------
// Operations where there is noting to do
case BeginOp:
case ComOp:
case EndOp:
case InvOp:
case ParOp:
case PripOp:
case StppOp:
break; // --------------------------------------------
// Load using a parameter index
case LdpOp:
if( tape[i_var].connect != not_connected )
{
i = vecad[ arg[0] - 1 ];
vecad_connect[i] = yes_connected;
}
break; // --------------------------------------------
// Load using a variable index
case LdvOp:
if( tape[i_var].connect != not_connected )
{
i = vecad[ arg[0] - 1 ];
vecad_connect[i] = yes_connected;
tape[arg[1]].connect = yes_connected;
}
break; // --------------------------------------------
// Store a variable using a parameter index
case StpvOp:
i = vecad[ arg[0] - 1 ];
if( vecad_connect[i] != not_connected )
tape[arg[2]].connect = yes_connected;
break; // --------------------------------------------
// Store a variable using a variable index
case StvvOp:
i = vecad[ arg[0] - 1 ];
if( vecad_connect[i] )
{ tape[arg[1]].connect = yes_connected;
tape[arg[2]].connect = yes_connected;
}
break; // --------------------------------------------
// all cases should be handled above
default:
CPPAD_ASSERT_UNKNOWN(0);
}
}
// values corresponding to BeginOp
CPPAD_ASSERT_UNKNOWN( i_op == 0 && i_var == 0 && op == BeginOp );
tape[i_var].op = op;
// -------------------------------------------------------------
// Erase all information in the recording
rec->Erase();
// Initilaize table mapping hash code to variable index in tape
// as pointing to the BeginOp at the beginning of the tape
CppAD::vector<size_t> hash_table_var(CPPAD_HASH_TABLE_SIZE);
for(i = 0; i < CPPAD_HASH_TABLE_SIZE; i++)
hash_table_var[i] = 0;
CPPAD_ASSERT_UNKNOWN( tape[0].op == BeginOp );
// initialize mapping from old variable index to new variable index
for(i = 0; i < num_var; i++)
tape[i].new_var = num_var; // invalid index
// initialize mapping from old VecAD index to new VecAD index
CppAD::vector<size_t> new_vecad_ind(num_vecad_ind);
for(i = 0; i < num_vecad_ind; i++)
new_vecad_ind[i] = num_vecad_ind; // invalid index
j = 0; // index into the old set of indices
for(i = 0; i < num_vecad_vec; i++)
{ // length of this VecAD
size_t length = play->GetVecInd(j);
if( vecad_connect[i] != not_connected )
{ // Put this VecAD vector in new recording
CPPAD_ASSERT_UNKNOWN(length < num_vecad_ind);
new_vecad_ind[j] = rec->PutVecInd(length);
for(k = 1; k <= length; k++) new_vecad_ind[j+k] =
rec->PutVecInd(
rec->PutPar(
play->GetPar(
play->GetVecInd(j+k)
) ) );
}
// start of next VecAD
j += length + 1;
}
CPPAD_ASSERT_UNKNOWN( j == num_vecad_ind );
// start playing the operations in the forward direction
play->start_forward(op, arg, i_op, i_var);
// playing forward skips BeginOp at the beginning, but not EndOp at
// the end. Put BeginOp at beginning of recording
CPPAD_ASSERT_UNKNOWN( op == BeginOp );
CPPAD_ASSERT_NARG_NRES(BeginOp, 0, 1);
tape[i_var].new_var = rec->PutOp(BeginOp);
// temporary buffer for new argument values
size_t new_arg[6];
// temporary work space used by optimize_record_csum
// (decalared here to avoid realloaction of memory)
optimize_csum_stacks csum_work;
while(op != EndOp)
{ // next op
play->next_forward(op, arg, i_op, i_var);
CPPAD_ASSERT_UNKNOWN( (i_op > n) | (op == InvOp) );
CPPAD_ASSERT_UNKNOWN( (i_op <= n) | (op != InvOp) );
// determine if we should keep this operation in the new
// operation sequence
bool keep;
switch( op )
{ case ComOp:
case PripOp:
case PrivOp:
keep = false;
break;
case InvOp:
case EndOp:
keep = true;
break;
case StppOp:
case StvpOp:
case StpvOp:
case StvvOp:
CPPAD_ASSERT_UNKNOWN( NumRes(op) == 0 );
i = vecad[ arg[0] - 1 ];
keep = vecad_connect[i] != not_connected;
break;
case AddpvOp:
case AddvvOp:
case SubpvOp:
case SubvpOp:
case SubvvOp:
keep = tape[i_var].connect != not_connected;
keep &= tape[i_var].connect != csum_connected;
break;
default:
keep = tape[i_var].connect != not_connected;
break;
}
size_t match_var = 0;
unsigned short code = 0;
bool replace_hash = false;
if( keep ) switch( op )
{
// Unary operator where operand is arg[0]
case AbsOp:
case AcosOp:
case AsinOp:
case AtanOp:
case CosOp:
case CoshOp:
case DisOp:
case ExpOp:
case LogOp:
case SinOp:
case SinhOp:
case SqrtOp:
match_var = optimize_unary_match(
tape , // inputs
i_var ,
play->num_rec_par() ,
play->GetPar() ,
hash_table_var ,
code // outputs
);
if( match_var > 0 )
tape[i_var].new_var = match_var;
else
{
replace_hash = true;
new_arg[0] = tape[ arg[0] ].new_var;
rec->PutArg( new_arg[0] );
i = rec->PutOp(op);
tape[i_var].new_var = i;
CPPAD_ASSERT_UNKNOWN( new_arg[0] < i );
}
break;
// ---------------------------------------------------
// Binary operators where
// left is a variable and right is a parameter
case SubvpOp:
if( tape[arg[0]].connect == csum_connected )
{
// convert to a sequence of summation operators
tape[i_var].new_var = optimize_record_csum(
tape , // inputs
i_var ,
play->num_rec_par() ,
play->GetPar() ,
rec ,
csum_work
);
// abort rest of this case
break;
}
case DivvpOp:
case PowvpOp:
match_var = optimize_binary_match(
tape , // inputs
i_var ,
play->num_rec_par() ,
play->GetPar() ,
hash_table_var ,
code // outputs
);
if( match_var > 0 )
tape[i_var].new_var = match_var;
else
{ tape[i_var].new_var = optimize_record_vp(
tape , // inputs
i_var ,
play->num_rec_par() ,
play->GetPar() ,
rec ,
op ,
arg
);
replace_hash = true;
}
break;
// ---------------------------------------------------
// Binary operators where
// left is a parameter and right is a variable
case SubpvOp:
case AddpvOp:
if( tape[arg[1]].connect == csum_connected )
{
// convert to a sequence of summation operators
tape[i_var].new_var = optimize_record_csum(
tape , // inputs
i_var ,
play->num_rec_par() ,
play->GetPar() ,
rec ,
csum_work
);
// abort rest of this case
break;
}
case DivpvOp:
case MulpvOp:
case PowpvOp:
match_var = optimize_binary_match(
tape , // inputs
i_var ,
play->num_rec_par() ,
play->GetPar() ,
hash_table_var ,
code // outputs
);
if( match_var > 0 )
tape[i_var].new_var = match_var;
else
{ tape[i_var].new_var = optimize_record_pv(
tape , // inputs
i_var ,
play->num_rec_par() ,
play->GetPar() ,
rec ,
op ,
arg
);
replace_hash = true;
}
break;
// ---------------------------------------------------
// Binary operator where
// both operators are variables
case AddvvOp:
case SubvvOp:
if( (tape[arg[0]].connect == csum_connected) |
(tape[arg[1]].connect == csum_connected)
)
{
// convert to a sequence of summation operators
tape[i_var].new_var = optimize_record_csum(
tape , // inputs
i_var ,
play->num_rec_par() ,
play->GetPar() ,
rec ,
csum_work
);
// abort rest of this case
break;
}
case DivvvOp:
case MulvvOp:
case PowvvOp:
match_var = optimize_binary_match(
tape , // inputs
i_var ,
play->num_rec_par() ,
play->GetPar() ,
hash_table_var ,
code // outputs
);
if( match_var > 0 )
tape[i_var].new_var = match_var;
else
{ tape[i_var].new_var = optimize_record_vv(
tape , // inputs
i_var ,
play->num_rec_par() ,
play->GetPar() ,
rec ,
op ,
arg
);
replace_hash = true;
}
break;
// ---------------------------------------------------
// Conditional expression operators
case CExpOp:
CPPAD_ASSERT_NARG_NRES(op, 6, 1);
new_arg[0] = arg[0];
new_arg[1] = arg[1];
mask = 1;
for(i = 2; i < 6; i++)
{ if( arg[1] & mask )
{ new_arg[i] = tape[arg[i]].new_var;
CPPAD_ASSERT_UNKNOWN(
new_arg[i] < num_var
);
}
else new_arg[i] = rec->PutPar(
play->GetPar( arg[i] )
);
mask = mask << 1;
}
rec->PutArg(
new_arg[0] ,
new_arg[1] ,
new_arg[2] ,
new_arg[3] ,
new_arg[4] ,
new_arg[5]
);
tape[i_var].new_var = rec->PutOp(op);
break;
// ---------------------------------------------------
// Operations with no arguments and no results
case EndOp:
CPPAD_ASSERT_NARG_NRES(op, 0, 0);
rec->PutOp(op);
break;
// ---------------------------------------------------
// Operations with no arguments and one result
case InvOp:
CPPAD_ASSERT_NARG_NRES(op, 0, 1);
tape[i_var].new_var = rec->PutOp(op);
break;
// ---------------------------------------------------
// Operations with one argument that is a parameter
case ParOp:
CPPAD_ASSERT_NARG_NRES(op, 1, 1);
new_arg[0] = rec->PutPar( play->GetPar(arg[0] ) );
rec->PutArg( new_arg[0] );
tape[i_var].new_var = rec->PutOp(op);
break;
// ---------------------------------------------------
// Load using a parameter index
case LdpOp:
CPPAD_ASSERT_NARG_NRES(op, 3, 1);
new_arg[0] = new_vecad_ind[ arg[0] ];
new_arg[1] = arg[1];
CPPAD_ASSERT_UNKNOWN( new_arg[0] < num_vecad_ind );
rec->PutArg(
new_arg[0],
new_arg[1],
0
);
tape[i_var].new_var = rec->PutOp(op);
break;
// ---------------------------------------------------
// Load using a variable index
case LdvOp:
CPPAD_ASSERT_NARG_NRES(op, 3, 1);
new_arg[0] = new_vecad_ind[ arg[0] ];
new_arg[1] = tape[arg[1]].new_var;
CPPAD_ASSERT_UNKNOWN( new_arg[0] < num_vecad_ind );
CPPAD_ASSERT_UNKNOWN( new_arg[1] < num_var );
rec->PutArg(
new_arg[0],
new_arg[1],
0
);
tape[i_var].new_var = rec->PutOp(op);
break;
// ---------------------------------------------------
// Store a parameter using a parameter index
case StppOp:
CPPAD_ASSERT_NARG_NRES(op, 3, 0);
new_arg[0] = new_vecad_ind[ arg[0] ];
new_arg[1] = rec->PutPar( play->GetPar(arg[1]) );
new_arg[2] = rec->PutPar( play->GetPar(arg[2]) );
CPPAD_ASSERT_UNKNOWN( new_arg[0] < num_vecad_ind );
rec->PutArg(
new_arg[0],
new_arg[1],
new_arg[2]
);
rec->PutOp(op);
break;
// ---------------------------------------------------
// Store a parameter using a variable index
case StvpOp:
CPPAD_ASSERT_NARG_NRES(op, 3, 0);
new_arg[0] = new_vecad_ind[ arg[0] ];
new_arg[1] = tape[arg[1]].new_var;
new_arg[2] = rec->PutPar( play->GetPar(arg[2]) );
CPPAD_ASSERT_UNKNOWN( new_arg[0] < num_vecad_ind );
CPPAD_ASSERT_UNKNOWN( new_arg[1] < num_var );
rec->PutArg(
new_arg[0],
new_arg[1],
new_arg[2]
);
rec->PutOp(op);
break;
// ---------------------------------------------------
// Store a variable using a parameter index
case StpvOp:
CPPAD_ASSERT_NARG_NRES(op, 3, 0);
new_arg[0] = new_vecad_ind[ arg[0] ];
new_arg[1] = rec->PutPar( play->GetPar(arg[1]) );
new_arg[2] = tape[arg[2]].new_var;
CPPAD_ASSERT_UNKNOWN( new_arg[0] < num_vecad_ind );
CPPAD_ASSERT_UNKNOWN( new_arg[1] < num_var );
CPPAD_ASSERT_UNKNOWN( new_arg[2] < num_var );
rec->PutArg(
new_arg[0],
new_arg[1],
new_arg[2]
);
rec->PutOp(op);
break;
// ---------------------------------------------------
// Store a variable using a variable index
case StvvOp:
CPPAD_ASSERT_NARG_NRES(op, 3, 0);
new_arg[0] = new_vecad_ind[ arg[0] ];
new_arg[1] = tape[arg[1]].new_var;
new_arg[2] = tape[arg[2]].new_var;
CPPAD_ASSERT_UNKNOWN( new_arg[0] < num_vecad_ind );
CPPAD_ASSERT_UNKNOWN( new_arg[1] < num_var );
CPPAD_ASSERT_UNKNOWN( new_arg[2] < num_var );
rec->PutArg(
new_arg[0],
new_arg[1],
new_arg[2]
);
rec->PutOp(op);
break;
// ---------------------------------------------------
// all cases should be handled above
default:
CPPAD_ASSERT_UNKNOWN(false);
}
if( replace_hash )
{ // The old variable index i_var corresponds to the
// new variable index tape[i_var].new_var. In addition
// this is the most recent variable that has this code.
hash_table_var[code] = i_var;
}
}
// modify the dependent variable vector to new indices
for(i = 0; i < dep_taddr.size(); i++ )
{ CPPAD_ASSERT_UNKNOWN( tape[ dep_taddr[i] ].new_var < num_var );
dep_taddr[i] = tape[ dep_taddr[i] ].new_var;
}
}
int main(int argc,char** argv){
const char* fname;
if(argc==2)
fname=argv[1];
else if(argc==1)
fname="/dev/stdout";
else
usage(1);
mwg::bio::ftape tape(fname,"rb");
if(!tape){
std::fprintf(stderr,"failed to open the file %s.\n",fname);
usage(1);
}
mwg::bio::tape_head<mwg::bio::ftape,mwg::bio::little_endian_flag> head(tape);
struct gzip_member_header{
mwg::byte id1;
mwg::byte id2;
mwg::byte cm;
mwg::byte flg;
mwg::u4t mtime;
mwg::byte xfl;
mwg::byte os;
} header={0};
head.read(header.id1 );
head.read(header.id2 );
head.read(header.cm );
head.read(header.flg );
head.read(header.mtime);
head.read(header.xfl );
head.read(header.os );
//mwg_assert(c1==31&&c2==139,"c1=%02x c2=%02x",c1,c2);
if(!(header.id1==31&&header.id2==139)){
std::fprintf(stderr,"gzcut: invalid ID1/ID2 %d/%d\n",header.id1,header.id2);
std::exit(1);
}
if(header.cm!=8){
std::fprintf(stderr,"gzcut: unrecognized compression method %d\n",header.cm);
std::exit(1);
}
if(header.flg&0xE0){
std::fprintf(stderr,"gzcut: unrecognized flag bits 0x%02X\n",header.flg&0xE0);
std::exit(1);
}
if(!(header.xfl==2||header.xfl==4||header.xfl==0)){
std::fprintf(stderr,"gzcut: unrecognized compression flag bits combination: 0x%02X\n",header.xfl);
std::exit(1);
}
enum{
FTEXT =0x01,
FHCRC =0x02,
FEXTRA =0x04,
FNAME =0x08,
FCOMMENT=0x10,
};
if(header.flg&FEXTRA){
mwg::u4t xlen;
head.read(xlen);
head.seek(xlen,SEEK_CUR);
}
if(header.flg&FNAME){
mwg::byte d=0;
std::fprintf(stderr,"gzcut: filename: ");
while(head.read(d)&&d!=0)putc(d,stderr);
putc('\n',stderr);
}
if(header.flg&FCOMMENT){
mwg::byte d=0;
std::fprintf(stderr,"gzcut: comment: ");
while(head.read(d)&&d!=0)putc(d,stderr);
putc('\n',stderr);
}
if(header.flg&FHCRC){
mwg::u2t crc16=0;
head.read(crc16);
std::fprintf(stderr,"gzcut: crc16: 0x%04X\n",crc16);
}
mwg::i8t csize=0;
{
mwg::i8t cur=head.tell();
auto mark=head.mark();
head.seek(-8,SEEK_END);
csize=head.tell()-cur;
mwg::u4t crc32;
mwg::u4t isize;
head.read(crc32);
head.read(isize);
std::fprintf(stderr,"gzcut: crc32: 0x%04X\n",crc32);
std::fprintf(stderr,"gzcut: compressed size: %lld\n",(long long)csize);
std::fprintf(stderr,"gzcut: original size: %lld mod 2^32\n",(long long)isize);
}
{
a85encoder enc(stdout);
mwg::byte b;
for(mwg::i8t i=0;i<csize&&head.read(b);i++)
enc.consume(b);
}
return 0;
}
DWORD WINAPI MdiMachiningBuildThreadProc(LPVOID lpParam)
{
LPCmdThreadParam pData;
LPCmdThreadParam pData_nc;
DWORD dwThreadID;
LPNCDATA pDataNcGraphMem;
FILE *file;
int nItemCount;
int reallength;
TCHAR szBuffer[501];
int decodeNum,compasateNum,tapeNum,ComputeNum;
int all_decode_num,all_creat_num;
nc_data decodeData[2*DECODE_NUM_ONCE];
nc_data compasateData[2*DECODE_NUM_ONCE];
nc_data tapeData[2*DECODE_NUM_ONCE];
nc_data ComputeData[2*DECODE_NUM_ONCE];
M_data MChild[2*DECODE_NUM_ONCE];
int fdEdit; //译码文件句柄定义
int end_decode;
double compasate_Start_point_X,compasate_Start_point_Y;
int compasate_build_c;
nc_data *compasate_cs;
double tape_Start_point_X,tape_Start_point_Y;
double tape_Start_point_B,tape_Start_point_C;
int tape_build_c,first5152flag;
nc_data *tape_cs;
int nc_start_flag;
int i;
int j = 0,k = 0;
char ptext[100];
//以下添加mdi加工程序
//SuspendThread(MdihThread);
compasate_Start_point_X=0.;
compasate_Start_point_Y=0.;
compasate_build_c=0;
tape_Start_point_X=0.;
tape_Start_point_Y=0.;
tape_build_c=0;
memset(decodeData,0,2*DECODE_NUM_ONCE*sizeof(nc_data));
memset(compasateData,0,2*DECODE_NUM_ONCE*sizeof(nc_data));
memset(ComputeData,0,2*DECODE_NUM_ONCE*sizeof(nc_data));
memset(MChild,0,2*DECODE_NUM_ONCE*sizeof(M_data));
compasate_cs = (nc_data *)malloc(sizeof(nc_data));
memset(compasate_cs,0,sizeof(nc_data));
tape_cs = (nc_data *)malloc(sizeof(nc_data));
memset(tape_cs,0,sizeof(nc_data));
pData = (LPCmdThreadParam)lpParam;
end_decode = 0;
all_decode_num =0;
all_creat_num = 0;
nc_start_flag=1;
//将mdi的nc码放到临时文件中
if ((file = fopen("MdiTemp.txt", "w+")) == NULL)
{
MessageBox (pData->hWnd,"can not create MdiTemp file in function MdiMachiningBuildThreadProc",NULL,NULL);
return 1;
}
nItemCount = SendMessage(GetDlgItem(pData->hWnd,IDC_MDILIST),LB_GETCOUNT,0,0);
if(nItemCount==0)
{
MessageBox (pData->hWnd,"there is no NCCODE in function MdiMachiningBuildThreadProc",NULL,NULL);
return 1;
}
for(i=0;i<nItemCount;i++)
{
SendMessage(GetDlgItem(pData->hWnd,IDC_MDILIST),LB_GETTEXT,i,(LPARAM)szBuffer);
reallength = SendMessage(GetDlgItem(pData->hWnd,IDC_MDILIST),LB_GETTEXTLEN,i,0);
if (fwrite(szBuffer, 1, reallength, file) < 0)
{
MessageBox (pData->hWnd,"write file err in function MdiMachiningBuildThreadProc" ,NULL,NULL);
return 1;
}
}
fclose (file);
fdEdit = _open("MdiTemp.txt", O_RDONLY);
do{
do{
reallength = _read(fdEdit, ptext+k, 1 );
if(reallength == 0)
{
return 0;
}
k++;
}while(ptext[k-1] != ';');
ptext[k] = 0;
if(strstr(ptext+j,"X"))
{
data_coorswitch.x=Gcode2d(ptext+j,"X");
}
else
{
data_coorswitch.x = 0;
}
if(strstr(ptext+j,"Y"))
{
data_coorswitch.y=Gcode2d(ptext+j,"Y");
}
else
{
data_coorswitch.y = 0;
}
if(strstr(ptext+j,"Z"))
{
data_coorswitch.z=Gcode2d(ptext+j,"Z");
}
else
{
data_coorswitch.z = 0;
}
if(strstr(ptext,"B"))
{
data_coorswitch.b=Gcode2d(ptext,"B");
}
else
{
data_coorswitch.b = 0;
}
if(strstr(ptext+j,"C"))
{
data_coorswitch.c=Gcode2d(ptext+j,"C");
}
else
{
data_coorswitch.c = 0;
}
if(strstr(ptext+j,"G54:"))
{
G54_coordinate = data_coorswitch;
}
if(strstr(ptext+j,"G55:"))
{
G55_coordinate = data_coorswitch;
}
if(strstr(ptext+j,"G56:"))
{
G56_coordinate = data_coorswitch;
}
if(strstr(ptext+j,"G57:"))
{
G57_coordinate = data_coorswitch;
}
if(strstr(ptext+j,"G58:"))
{
G58_coordinate = data_coorswitch;
}
if(strstr(ptext+j,"G59:"))
{
G59_coordinate = data_coorswitch;
}
if(strstr(ptext+j,"G92:"))
{
data_w = data_coorswitch;
data_r.x = data_m.x - data_w.x;
data_r.y = data_m.y - data_w.y;
data_r.z = data_m.z - data_w.z;
data_r.b = data_m.b - data_w.b;
data_r.c = data_m.c - data_w.c;
}
j = k;
readbuffer_to_fc(pData->hWnd);
fc_upday(hWndCoor);
}while(reallength !=0);
SuspendThread(MdihThread);
//开设译码绘图内存
pDataNcGraphMem = (LPNCDATA)HeapAlloc(GetProcessHeap(),
HEAP_ZERO_MEMORY,
MAX_NC_MEM*sizeof(nc_data)
);
if(pDataNcGraphMem == NULL)
{
MessageBox(pData->hWnd,"can not alloc heapmemory in function MdiMachiningBuildThreadProc",NULL,NULL);
return 1;
}
//开设NC代码内存
lpNcCodeMem = (LPNCCODE)HeapAlloc(GetProcessHeap(),
HEAP_ZERO_MEMORY,
MAX_NC_MEM*sizeof(nc_code)
);
if(pDataNcGraphMem == NULL)
{
MessageBox(pData->hWnd,"can not alloc heapmemory in function AutoMachiningBuildThreadProc",NULL,NULL);
return 1;
}
//为读取文件到内存打开文件
fdEdit = _open(szBuffer, O_RDONLY);
if (fdEdit <= 0)
{
MessageBox (pData->hWnd, "can not open file in AutoMachiningBuildThreadProc","Program", MB_OK | MB_ICONSTOP);
return 1;
}
ReadNcCodeFileToMem(pData->hWnd,fdEdit,lpNcCodeMem,&NcCodeNum);
_close(fdEdit);
//打开译码文件
fdEdit = _open("MdiTemp.txt", O_RDONLY);
if (fdEdit <= 0)
{
MessageBox (pData->hWnd, "can not open file in MdiMachiningBuildThreadProc","Program", MB_OK | MB_ICONSTOP);
return 1;
}
ReadNcCodeFileToMem(pData->hWnd,fdEdit,lpNcCodeMem,&NcCodeNum);
do{
if(decode(pData->hWnd,lpNcCodeMem,decodeData,&decodeNum,&all_decode_num,&end_decode,MChild)==1) return 1; // 分段译码
if(compensate(pData->hWnd,decodeData,decodeNum,compasateData,&compasateNum,&compasate_Start_point_X,&compasate_Start_point_Y, &compasate_build_c,compasate_cs)==1) return 1;//分段刀具补偿
if(tape(pData->hWnd,compasateData,compasateNum,tapeData,&tapeNum,&tape_Start_point_X,&tape_Start_point_Y,&tape_build_c,&first5152flag,tape_cs,&tape_Start_point_B,&tape_Start_point_C)==1,&tape_Start_point_B,&tape_Start_point_C) return 1; //锥面补偿
if(DSP_Compute(pData->hWnd,tapeData,tapeNum,ComputeData,&ComputeNum)==1) return 1;
CopyMemory(pDataNcGraphMem+all_creat_num,ComputeData,(ComputeNum*sizeof(nc_data)));
memset(compasateData,0,2*DECODE_NUM_ONCE*sizeof(nc_data));
memset(tapeData,0,2*DECODE_NUM_ONCE*sizeof(nc_data));
memset(ComputeData,0,2*DECODE_NUM_ONCE*sizeof(nc_data));
all_creat_num=all_creat_num + ComputeNum;
ComputeNum = 0;
compasateNum=0;
tapeNum=0;
//开设向下位机传送数据线程
if(nc_start_flag==1)
{
pData_nc = (LPCmdThreadParam)HeapAlloc(GetProcessHeap(),
HEAP_ZERO_MEMORY,
sizeof(CmdThreadParam)
);
if(pData_nc == NULL)
{
MessageBox(pData->hWnd,"can not alloc heapmemory in function MdiMachiningBuildThreadProc",NULL,NULL);
return 1;
}
pData_nc->hWnd = pData->hWnd;
pData_nc->wndCtrl = pData->wndCtrl;
pData_nc->menuID = pData->menuID;
pData_nc->notifyCode =pData-> notifyCode;
pData_nc->ncMem = pDataNcGraphMem;
NcSendhThread = CreateThread(
NULL,
0,
NcSendThreadProc,
pData_nc,
0,
&dwThreadID
);
if( NcSendhThread==NULL)
{
MessageBox(pData->hWnd,"can not create Thread in function MdiMachiningBuildThreadProc",NULL,NULL);
return 1;
}
SendNCDriverUserDecodeEvent(pData->hWnd,NcSendhThread); //向驱动程序下传传送数据线程的句柄
nc_start_flag = 0;
}
}while(end_decode != 1);
_close(fdEdit);
//find_draw_param(GetDlgItem (pData->hWnd, IDC_AUTOGRAPH),pDataNcGraphMem,&auto_draw_width,&auto_draw_length,&auto_mw, &auto_ml,all_creat_num);//求取画图参数
//draw_all(GetDlgItem (pData->hWnd, IDC_AUTOGRAPH),pDataNcGraphMem,auto_draw_width,auto_draw_length,auto_mw, auto_ml,all_creat_num); //画全部图
free(tape_cs);
free(compasate_cs);
//取消线程、释放内存
CloseHandle(MdihThread);
if(HeapFree(GetProcessHeap(),HEAP_NO_SERIALIZE,pData) == 0){
MessageBox(pData->hWnd,"can not free heapmemory in function MdiMachiningBuildThreadProc",NULL,NULL);
return 1;
}
return 0;
}
