GLDEF_C void ExternalizeL(const CDbKey& aKey,RWriteStream& aStream)
{
TInt cc=aKey.Count();
aStream.WriteInt32L(cc);
for (TInt ii=0;ii<cc;++ii)
{
const TDbKeyCol& col=aKey[ii];
aStream<<col.iName<<TUint8(col.iOrder)<<TInt32(col.iLength);
}
aStream<<TUint8(aKey.Comparison())<<TUint8(aKey.IsUnique());
}
LOCAL_C TInt WavRecord()
{
// Parse the commandline and get a filename to use
TLex l(CommandLine);
TParse destinationName;
if (destinationName.SetNoWild(l.NextToken(),0,0)!=KErrNone)
{
Test.Printf(_L("No arg, skipping\r\n"));
return(KErrArgument);
}
Test.Next(_L("Record Wav file"));
// Open the file for writing
TInt r;
RFile destination;
r = destination.Replace(Fs,destinationName.FullName(),EFileWrite);
if (r!=KErrNone)
{
Test.Printf(_L("Open file for write failed(%d)\n"), r);
return(r);
}
Test.Printf(_L("File opened for write\r\n"));
Test.Next(_L("Preparing to record"));
// Get the rate
TLex cl(l.NextToken());
TUint32 tmpRate;
TSoundRate rate;
r = cl.Val(tmpRate,EDecimal);
if (r == KErrNone && (r=SamplesPerSecondToRate(tmpRate,rate))==KErrNone)
{
Test.Printf(_L("Parsed rate: %d\r\n"), tmpRate);
RecordFormatBuf().iRate = rate;
}
else
{
Test.Printf(_L("Parse rate failed(%d)\r\n"),r);
RecordFormatBuf().iRate = ESoundRate32000Hz;
}
// Get number of channels
TLex cl_chan(l.NextToken());
TUint32 tmpChannels;
r = cl_chan.Val(tmpChannels,EDecimal);
if (r == KErrNone)
{
Test.Printf(_L("Parsed %d channels\r\n"),tmpChannels);
RecordFormatBuf().iChannels = tmpChannels;
}
else
{
Test.Printf(_L("Parse channels failed(%d)\r\n"), r);
RecordFormatBuf().iChannels = 2;
}
RecordFormatBuf().iEncoding = ESoundEncoding16BitPCM;
// Set the record buffer configuration.
RChunk chunk;
TTestSharedChunkBufConfig bufferConfig;
bufferConfig.iNumBuffers=4;
bufferConfig.iBufferSizeInBytes=RecordBufferSizeInBytes(RecordFormatBuf());
if (RecordCapsBuf().iRequestMinSize)
bufferConfig.iBufferSizeInBytes&=~(RecordCapsBuf().iRequestMinSize-1); // Keep the buffer length valid for the driver.
bufferConfig.iFlags=0;
PrintBufferConf(bufferConfig,Test);
TPckg<TTestSharedChunkBufConfig> bufferConfigBuf(bufferConfig);
r=RxSoundDevice.SetBufferChunkCreate(bufferConfigBuf,chunk);
if (r!=KErrNone)
{
Test.Printf(_L("Buffer configuration not supported(%d)\r\n"),r);
return(r);
}
// Set the audio record configuration.
RxSoundDevice.SetVolume(KSoundMaxVolume);
PrintConfig(RecordFormatBuf(),Test);
r=RxSoundDevice.SetAudioFormat(RecordFormatBuf);
if (r!=KErrNone)
{
Test.Printf(_L("Format not supported\r\n"));
return(r);
}
// Get length in seconds
TLex cl_seconds(l.NextToken());
TUint32 tmpSeconds;
r = cl_seconds.Val(tmpSeconds,EDecimal);
if (r == KErrNone)
{
Test.Printf(_L("Parsed %d seconds\r\n"),tmpSeconds);
}
else
{
Test.Printf(_L("Parse seconds failed(%d)\r\n"),r);
tmpSeconds=10;
}
TInt bytesToRecord = BytesPerSecond(RecordFormatBuf())*tmpSeconds;
Test.Next(_L("Recording..."));
// Lay down a file header
WAVEheader header;
TPtr8 headerDes((TUint8 *)&header, sizeof(struct WAVEheader), sizeof(struct WAVEheader));
// "RIFF"
header.ckID[0] = 'R'; header.ckID[1] = 'I';
header.ckID[2] = 'F'; header.ckID[3] = 'F';
// "WAVE"
header.wave_ckID[0] = 'W'; header.wave_ckID[1] = 'A';
header.wave_ckID[2] = 'V'; header.wave_ckID[3] = 'E';
// "fmt "
header.fmt_ckID[0] = 'f'; header.fmt_ckID[1] = 'm';
header.fmt_ckID[2] = 't'; header.fmt_ckID[3] = ' ';
// "data"
header.data_ckID[0] = 'd'; header.data_ckID[1] = 'a';
header.data_ckID[2] = 't'; header.data_ckID[3] = 'a';
header.nChannels = (TUint16)RecordFormatBuf().iChannels;
header.nSamplesPerSec = RateInSamplesPerSecond(RecordFormatBuf().iRate);
header.nBitsPerSample = 16;
header.nBlockAlign = TUint16((RecordFormatBuf().iChannels == 2) ? 4 : 2);
header.formatTag = 1; // type 1 is PCM
header.fmt_ckSize = 16;
header.nAvgBytesPerSec = BytesPerSecond(RecordFormatBuf());
header.data_ckSize = bytesToRecord;
header.ckSize = bytesToRecord + sizeof(struct WAVEheader) - 8;
Test.Printf(_L("Header rate:%d channels:%d tag:%d bits:%d (%d bytes/s) align %d datalen:%d fmt_ckSize:%d ckSize:%d\r\n"),
header.nSamplesPerSec, header.nChannels, header.formatTag, header.nBitsPerSample,
header.nAvgBytesPerSec, header.nBlockAlign, header.data_ckSize, header.fmt_ckSize, header.ckSize, sizeof(struct WAVEheader));
r = destination.Write(headerDes);
TRequestStatus stat;
TInt length;
TPtrC8 buf;
TTime startTime;
startTime.HomeTime();
// Start off by issuing a record request.
TTime starttime;
starttime.HomeTime();
TInt bytesRecorded = 0;
RxSoundDevice.RecordData(stat,length);
TInt pausesToDo = 10;
pausesToDo = 0;
FOREVER
{
// Wait for the outstanding record request to complete.
User::After(6000);
User::WaitForAnyRequest();
if (stat==KRequestPending)
return(KErrGeneral);
TTime currentTime;
currentTime.HomeTime();
TInt64 elapsedTime = currentTime.Int64()-startTime.Int64(); // us
TTimeIntervalMicroSecondsBuf timeRecordedBuf;
if(RxSoundDevice.TimeRecorded(timeRecordedBuf) == KErrNone)
{
// Compare TimeRecorded with the actual elapsed time. They should be different, but not drift apart too badly...
TInt32 offset = TInt32(elapsedTime - timeRecordedBuf().Int64());
Test.Printf(_L("\telapsedTime - TimeRecorded = %d ms\n"), offset/1000);
}
// Check whether the record request was succesful.
TInt retOffset=stat.Int();
if (retOffset<0)
{
Test.Printf(_L("Record failed(%d)\r\n"),retOffset);
return(retOffset);
}
// Successfully recorded another buffer so write the recorded data to the record file and release the buffer.
buf.Set((const TUint8*)(chunk.Base()+retOffset),length);
r=destination.Write(buf);
if (r!=KErrNone)
{
Test.Printf(_L("File write failed(%d)\r\n"),r);
return(r);
}
r=RxSoundDevice.ReleaseBuffer(retOffset);
if (r!=KErrNone)
{
Test.Printf(_L("Release buffer failed(%d)\r\n"),r);
return(r);
}
Test.Printf(_L("Recorded %d more bytes - %d\r\n"),length,retOffset);
if((pausesToDo > 0) && (bytesRecorded > bytesToRecord/2))
{
--pausesToDo;
Test.Printf(_L("Pause\r\n"));
RxSoundDevice.Pause();
Test.Printf(_L("Paused, sleeping for 0.5 seconds\r\n"));
User::After(500*1000);
Test.Printf(_L("Resume\r\n"));
RxSoundDevice.Resume();
}
// Check whether we have now recorded all the data. If more to record then queue a further request
bytesRecorded+=length;
if (bytesRecorded<bytesToRecord)
{
Test.Printf(_L("RecordData\r\n"));
RxSoundDevice.RecordData(stat,length);
}
else
break;
}
RxSoundDevice.CancelRecordData(); // Stop the driver from recording.
TTime endtime;
endtime.HomeTime();
TInt64 elapsedTime = endtime.Int64()-starttime.Int64(); // us
Test.Printf(_L("Delta time = %d\r\n"),I64LOW(elapsedTime));
Test.Printf(_L("Seconds in buffer: %d (%d)\r\n"), bytesRecorded / header.nAvgBytesPerSec, (bytesRecorded / header.nAvgBytesPerSec)*1000000);
if (I64LOW(elapsedTime) <= (bytesRecorded / header.nAvgBytesPerSec)*1000000)
{
Test.Printf(_L("Time travelling; record took less time than it should have done\r\n"));
return(KErrGeneral);
}
chunk.Close();
destination.Close();
Test.Printf(_L("Record finished\r\n"));
return(KErrNone);
}
LOCAL_C TInt WavPlay()
{
RChunk chunk;
// Parse the commandline and get a filename to use
TLex l(CommandLine);
TFileName thisfile=RProcess().FileName();
TPtrC token=l.NextToken();
if (token.MatchF(thisfile)==0)
token.Set(l.NextToken());
if (token.Length()==0)
{
// No args, skip to end
Test.Printf(_L("Invalid configuration\r\n"));
return(KErrArgument);
}
Test.Next(_L("Play Wav file"));
// Assume that the argument is a WAV filename
TFileName wavFilename=token;
TInt r;
RFile source;
r = source.Open(Fs,wavFilename,EFileRead);
if (r!=KErrNone)
{
Test.Printf(_L("Open failed(%d)\r\n"), r);
return(r);
}
// Read the pcm header
WAVEheader header;
TPtr8 headerDes((TUint8 *)&header,sizeof(struct WAVEheader),sizeof(struct WAVEheader));
r = source.Read(headerDes);
if (r!=KErrNone)
{
source.Close();
return(r);
}
Test.Printf(_L("Header Read %d bytes\r\n"),headerDes.Size());
if (headerDes.Size() != sizeof(struct WAVEheader)) // EOF
{
Test.Printf(_L("Couldn't read a header(%d bytes)\r\n"),headerDes.Size());
source.Close();
return(KErrCorrupt);
}
Test.Printf(_L("Header rate:%d channels:%d tag:%d bits:%d (%d bytes/s) align %d datalen:%d fmt_ckSize:%d ckSize:%d\n"),
header.nSamplesPerSec, header.nChannels, header.formatTag, header.nBitsPerSample,
header.nAvgBytesPerSec, header.nBlockAlign, header.data_ckSize, header.fmt_ckSize, header.ckSize);
if (header.formatTag != 1) // not pcm
{
Test.Printf(_L("Format not PCM(%d)\r\n"),header.formatTag);
source.Close();
return(KErrNotSupported);
}
if (header.nBitsPerSample != 16) // not 16 bit
{
Test.Printf(_L("Format not 16 bit PCM(%d bits)\r\n"),header.nBitsPerSample);
source.Close();
return(KErrNotSupported);
}
TSoundRate rate;
if (SamplesPerSecondToRate(header.nSamplesPerSec,rate)!=KErrNone)
{
Test.Printf(_L("Format specifies a rate not supported(%d)\r\n"),header.nSamplesPerSec);
source.Close();
return(KErrNotSupported);
}
TxSoundDevice.AudioFormat(PlayFormatBuf); // Read back the current setting which must be valid.
PlayFormatBuf().iChannels = header.nChannels;
PlayFormatBuf().iRate = rate;
PlayFormatBuf().iEncoding = ESoundEncoding16BitPCM;
// Set the play buffer configuration.
TInt bufSize=BytesPerSecond(PlayFormatBuf())/8; // Large enough to hold 1/8th second of data.
bufSize&=~(header.nBlockAlign-1); // Keep the buffer length a multiple of the bytes per sample (assumes 16bitPCM, 1 or 2 chans).
if (PlayCapsBuf().iRequestMinSize)
bufSize&=~(PlayCapsBuf().iRequestMinSize-1); // Keep the buffer length valid for the driver.
TTestSharedChunkBufConfig bufferConfig;
bufferConfig.iNumBuffers=3;
bufferConfig.iBufferSizeInBytes=bufSize;
bufferConfig.iFlags=0;
PrintBufferConf(bufferConfig,Test);
TPckg<TTestSharedChunkBufConfig> bufferConfigBuf(bufferConfig);
r=TxSoundDevice.SetBufferChunkCreate(bufferConfigBuf,chunk);
if (r!=KErrNone)
{
Test.Printf(_L("Buffer configuration not supported(%d)\r\n"),r);
source.Close();
return(r);
}
TxSoundDevice.GetBufferConfig(bufferConfigBuf); // Read back the configuration - to get the buffer offsets
CHECK(bufferConfig.iBufferSizeInBytes==bufSize);
// Set the audio play configuration.
TxSoundDevice.SetVolume(KSoundMaxVolume - (KSoundMaxVolume / 4)); // set volume to 75%
PrintConfig(PlayFormatBuf(),Test);
r=TxSoundDevice.SetAudioFormat(PlayFormatBuf);
if (r!=KErrNone)
{
Test.Printf(_L("Format not supported\r\n"));
source.Close();
chunk.Close();
return(r);
}
TxSoundDevice.ResetBytesTransferred();
TInt32 bytesToPlay = header.data_ckSize;
TTime starttime;
starttime.HomeTime();
TRequestStatus stat[3];
TPtr8* tPtr[3];
TInt i;
for (i=0;i<3;i++)
tPtr[i]=new TPtr8(NULL,0);
TTime startTime;
startTime.HomeTime();
// Start off by issuing a play request for each buffer (assuming that the file is long enough). Use the full size
// of each buffer.
TInt stillToRead=bytesToPlay;
TInt stillNotPlayed=bytesToPlay;
TUint flags;
for (i=0 ; i<3 ; i++)
{
// Setup the descriptor for reading in the data from the file.
tPtr[i]->Set(chunk.Base()+bufferConfig.iBufferOffsetList[i],0,bufSize);
// If there is still data to read to play then read this into the descriptor
// and then write it to the driver.
if (stillToRead)
{
r=source.Read(*tPtr[i],Min(stillToRead,bufSize));
if (r!=KErrNone)
{
Test.Printf(_L("Initial file read error(%d)\r\n"),r);
source.Close();
chunk.Close();
return(r);
}
stillToRead-=tPtr[i]->Length();
flags=(stillToRead>0)?0:KSndFlagLastSample;
TxSoundDevice.PlayData(stat[i],bufferConfig.iBufferOffsetList[i],tPtr[i]->Length(),flags);
}
else
stat[i]=KRequestPending;
}
FOREVER
{
// Wait for any one of the outstanding play requests to complete.
User::WaitForAnyRequest();
TTime currentTime;
currentTime.HomeTime();
TInt64 elapsedTime = currentTime.Int64()-startTime.Int64(); // us
TTimeIntervalMicroSecondsBuf timePlayedBuf;
if(TxSoundDevice.TimePlayed(timePlayedBuf) == KErrNone)
{
// Compare TimePlayed with the actual elapsed time. They should be different, but not drift apart too badly...
TInt32 offset = TInt32(elapsedTime - timePlayedBuf().Int64());
Test.Printf(_L("\telapsedTime - TimePlayed = %d ms\n"), offset/1000);
}
// Work out which buffer this applies to
for (i=0 ; i<3 ; i++)
{
if (stat[i]!=KRequestPending)
break;
}
if (i>=3)
{
Test.Printf(_L("I/O error\r\n"));
source.Close();
chunk.Close();
return(KErrGeneral);
}
// Check that the transfer was succesful and whether we have now played all the file.
if (stat[i]!=KErrNone)
{
Test.Printf(_L("Play error(%d)\r\n"),stat[i].Int());
source.Close();
chunk.Close();
return(stat[i].Int());
}
Test.Printf(_L("Played %d bytes(%d) - %d\r\n"),tPtr[i]->Length(),i,stat[i].Int());
stillNotPlayed-=tPtr[i]->Length();
CHECK(stillNotPlayed>=0);
if (!stillNotPlayed)
break;
// Still more to be played so read the next part of the file into the descriptor for this
// buffer and then write it to the driver.
if (stillToRead)
{
TInt len=Min(stillToRead,bufSize);
// If we've got to the end of the file and the driver is particular about the request length then
// zero fill the entire buffer so we can play extra zeros after the last sample from the file.
if (len<bufSize && PlayCapsBuf().iRequestMinSize)
tPtr[i]->FillZ(bufSize);
// Read the next part of the file
r=source.Read(*tPtr[i],len); // This will alter the length of the descriptor
if (r!=KErrNone)
{
Test.Printf(_L("File read error(%d)\r\n"),r);
source.Close();
chunk.Close();
return(r);
}
stillToRead-=tPtr[i]->Length();
// If we've got to the end of the file and the driver is particular about the request length then
// round up the length to the next valid boundary. This is OK since we zero filled.
if (tPtr[i]->Length() < bufSize && PlayCapsBuf().iRequestMinSize)
{
TUint m=PlayCapsBuf().iRequestMinSize-1;
len=(tPtr[i]->Length() + m) & ~m;
}
// Write it to the driver.
flags=(stillToRead>0)?0:KSndFlagLastSample;
TxSoundDevice.PlayData(stat[i],bufferConfig.iBufferOffsetList[i],len,flags);
}
else
stat[i]=KRequestPending;
}
// Delete all the variables again.
for (i=0 ; i<3 ; i++)
delete tPtr[i];
TTime endtime;
endtime.HomeTime();
Test.Printf(_L("Done playing\r\n"));
Test.Printf(_L("Bytes played = %d\r\n"),TxSoundDevice.BytesTransferred());
Test.Printf(_L("Delta time = %d\r\n"),endtime.Int64()-starttime.Int64());
chunk.Close();
source.Close();
return(KErrNone);
}
LOCAL_C TInt testAsyncAccess(TAny* aData)
//
/// Test read file handling.
///
/// @param aData pointer to the thread data area
{
TThreadData& data = *(TThreadData*)aData;
TFileName fileName = data.iFile;
TBool dowrite = (data.iData != NULL);
TBuf8<KBufLen>* buffer = gBufferArr[data.iNum];
TRequestStatus* status = gStatusArr[data.iNum];
RFs myFs;
TInt r = myFs.Connect();
TEST(r==KErrNone);
r = myFs.SetSessionPath(gSessionPath);
if (r != KErrNone)
TTest::Fail(HERE, _L("SetSessionPath returned %d"), r);
TVolumeInfo vol;
TInt drv;
r = myFs.CharToDrive(fileName[0], drv);
if (r != KErrNone)
TTest::Fail(HERE, _L("CharToDrive(%c) returned %d"), fileName[0], r);
r = myFs.Volume(vol, drv);
if (r != KErrNone)
TTest::Fail(HERE, _L("Volume() returned %d"), r);
TInt64 maxwrite = vol.iFree / 2 - KBufLen;
if (maxwrite < KBufLen*2)
TTest::Fail(HERE, _L("Not enough space to do test, only %d KB available"),
TInt(vol.iFree/1024));
RFile f;
RTimer timer;
TRequestStatus tstat;
TTime startTime;
TTime endTime;
TTimeIntervalMicroSeconds timeTaken;
TInt wrnum = 0;
TInt rdnum = 0;
TInt opnum = 0;
TInt opfin = 0;
TInt i;
timer.CreateLocal();
if (dowrite)
{
r = f.Replace(myFs, fileName, EFileStreamText | EFileWrite);
TEST(r==KErrNone);
// wait for both tasks to have a chance to complete opening the files
User::After(1000);
for (i = 0; i < KNumBuf; i++)
buffer[i].Fill('_', KBufLen);
timer.After(tstat, KTimeBM * KSecond);
startTime.HomeTime();
while (tstat == KRequestPending)
{
TInt pos = TInt((wrnum * KBufLen) % maxwrite);
TInt bnum = opnum++ % KNumBuf;
f.Write(pos, buffer[bnum], status[bnum]);
if (opnum - opfin > KMaxLag)
{
while (status[opfin % KNumBuf] == KRequestPending)
User::WaitForRequest(status[opfin % KNumBuf]);
opfin++;
}
++wrnum;
}
while (opfin < opnum)
{
while (status[opfin % KNumBuf] == KRequestPending)
User::WaitForRequest(status[opfin % KNumBuf]);
opfin++;
}
endTime.HomeTime();
TTimeIntervalMicroSeconds timeTaken=endTime.MicroSecondsFrom(startTime);
TInt64 dtime = timeTaken.Int64();
TInt64 dsize = wrnum * KBufLen * TInt64(KSecond);
TInt32 speed = TInt32((dsize + dtime/2) / dtime);
AddStats(gWrStats, dsize, dtime);
TTest::Printf(_L("%8d writes in %6d mS = %8d bytes per second\n"),
wrnum, TInt32(dtime)/1000, speed);
}
else
{
r = f.Open(myFs, fileName, EFileStreamText);
TEST(r==KErrNone);
timer.After(tstat, KTimeBM * KSecond);
startTime.HomeTime();
while (tstat == KRequestPending)
{
TInt pos = TInt((rdnum * KBufLen) % maxwrite);
TInt bnum = opnum++ % KNumBuf;
f.Read(pos, buffer[bnum], status[bnum]);
if (opnum - opfin > KMaxLag)
{
User::WaitForRequest(status[opfin++ % KNumBuf]);
}
++rdnum;
}
while (opfin < opnum)
{
if (status[opfin % KNumBuf] == KRequestPending)
User::WaitForRequest(status[opfin % KNumBuf]);
opfin++;
}
endTime.HomeTime();
timeTaken=endTime.MicroSecondsFrom(startTime);
TInt64 dtime = timeTaken.Int64();
TInt64 dsize = rdnum * KBufLen * TInt64(KSecond);
TInt32 speed = TInt32((dsize + dtime/2) / dtime);
AddStats(gRdStats, dsize, dtime);
// wait to allow the dust to settle
User::After(KSecond);
TTest::Printf(_L("%8d reads in %6d mS = %8d bytes per second\n"),
rdnum, TInt32(dtime)/1000, speed);
myFs.Delete(fileName);
}
timer.Cancel();
timer.Close();
f.Close();
myFs.Close();
return r;
}
GLDEF_C void ExternalizeL(const TDbCol& aCol,RWriteStream& aStream)
{
aStream<<aCol.iName<<TUint8(aCol.iType)<<TInt32(aCol.iMaxLength)<<TUint8(aCol.iAttributes);
}
bool CCpu::SingleStep()
{
ServiceInterruptRequest();
//Save incoming PC to compare with the outgoing one. If they are identical
//this indicates a "halt" instruction.
TUint16 incommingPc = iRegMap.iPC;
//Read the instruction, and decode the op code.
TUint16 inst = iMemMap[iRegMap.iPC++];
TUint op = Decode::BasicOpCode(inst);
//All opcodes need to read and/or write operand A.
TUint16& a = Decode::OperandA(iRegMap, iMemMap, Decode::A(inst));
if(op != Decode::EOpCodeSPECIAL)
{
//All basic instructions need to read A and read and/or write B.
TUint16& b = Decode::OperandB(iRegMap, iMemMap, Decode::B(inst));
switch(op)
{
case Decode::EOpCodeSET:
{
b = a;
AddCycles(1);
break;
}
case Decode::EOpCodeADD:
{
TUint32 u32 = TUint32(b) + TUint32(a);
b = TUint16(u32 & 0xffff);
iRegMap.iEX = TUint16(u32 >> 16);
AddCycles(2);
break;
}
case Decode::EOpCodeSUB:
{
TUint32 u32 = TUint32(b) - TUint32(a);
b = TUint16(u32 & 0xffff);
iRegMap.iEX = TUint16(u32 >> 16);
AddCycles(2);
break;
}
case Decode::EOpCodeMUL:
{
TUint32 u32 = TUint32(b) * TUint32(a);
b = TUint16(u32 & 0xffff);
iRegMap.iEX = TUint16(u32 >> 16);
AddCycles(2);
break;
}
case Decode::EOpCodeMLI:
{
TInt32 i32 = TInt32(b) * TInt32(a);
b = TUint16(i32 & 0x7fff);
iRegMap.iEX = TUint16(i32 >> 16);
AddCycles(2);
break;
}
case Decode::EOpCodeDIV:
{
if(a == 0)
{
b = 0;
iRegMap.iEX = 0;
}
else
{
b /= a;
iRegMap.iEX = TUint16(((TUint32(b) << 16) / TUint32(a)));
}
AddCycles(3);
break;
}
case Decode::EOpCodeDVI:
{
if(a == 0)
{
b = 0;
iRegMap.iEX = 0;
}
else
{
TInt32 sa = TInt32(a);
TInt32 sb = TInt32(b);
b = TUint16(sb / sa);
iRegMap.iEX = TUint16((sb << 16) / sa);
}
AddCycles(3);
break;
}
case Decode::EOpCodeMOD:
{
if(a == 0)
{
b = 0;
}
else
{
b = TUint16(TInt32(b) % TInt32(a));
}
AddCycles(3);
break;
}
case Decode::EOpCodeMDI:
{
if(a == 0)
{
b = 0;
}
else
{
b = TUint16(TInt32(b) % TInt32(a));
}
AddCycles(3);
break;
}
case Decode::EOpCodeAND:
{
b &= a;
AddCycles(1);
break;
}
case Decode::EOpCodeBOR:
{
b |= a;
AddCycles(1);
break;
}
case Decode::EOpCodeXOR:
{
b ^= a;
AddCycles(1);
break;
}
case Decode::EOpCodeSHR:
{
b >>= a;
iRegMap.iEX = TUint16(((TUint32(b) << 16) >> TUint32(a)));
AddCycles(1);
break;
}
case Decode::EOpCodeASR:
{
TInt32 sb = TInt32(b);
b = TUint16(sb >> a);
iRegMap.iEX = TUint16((TInt32(sb) << 16) >> TUint32(a));
AddCycles(1);
break;
}
case Decode::EOpCodeSHL:
{
TUint32 u32 = TUint32(b) << TUint32(a);
b = TUint16(u32 & 0xffff);
iRegMap.iEX = TUint16(u32 >> 16);
AddCycles(1);
break;
}
case Decode::EOpCodeIFB:
{
if((b & a) == 0)
{
SkipInstructions();
}
AddCycles(2);
break;
}
case Decode::EOpCodeIFC:
{
if((b & a) != 0)
{
SkipInstructions();
}
AddCycles(2);
break;
}
case Decode::EOpCodeIFE:
{
if(b != a)
{
SkipInstructions();
}
AddCycles(2);
break;
}
case Decode::EOpCodeIFN:
{
if(b == a)
{
SkipInstructions();
}
AddCycles(2);
break;
}
case Decode::EOpCodeIFG:
{
if(b <= a)
{
SkipInstructions();
}
AddCycles(2);
break;
}
case Decode::EOpCodeIFA:
{
if(TInt32(b) <= TInt32(a))
{
SkipInstructions();
}
AddCycles(2);
break;
}
case Decode::EOpCodeIFL:
{
if(b >= a)
{
SkipInstructions();
}
AddCycles(2);
break;
}
case Decode::EOpCodeIFU:
{
if(TInt32(b) >= TInt32(a))
{
SkipInstructions();
}
AddCycles(2);
break;
}
case Decode::EOpCodeADX:
{
TUint32 u32 = TUint32(b) + TUint32(a) + TUint32(iRegMap.iEX);
b = TUint16(u32 & 0xffff);
iRegMap.iEX = TUint16(u32 >> 16);
AddCycles(3);
break;
}
case Decode::EOpCodeSBX:
{
TUint32 u32 = TUint32(b) - TUint32(a) + TUint32(iRegMap.iEX);
b = TUint16(u32 & 0xffff);
iRegMap.iEX = TUint16(u32 >> 16);
AddCycles(3);
break;
}
case Decode::EOpCodeSTI:
{
b = a;
iRegMap.iI++;
iRegMap.iJ++;
AddCycles(2);
break;
}
case Decode::EOpCodeSTD:
{
b = a;
iRegMap.iI--;
iRegMap.iJ--;
AddCycles(2);
break;
}
default: assert("Unknown basic op code" && false);
}
}
void CCamcTestClient_9::RunLContinuedL()
// This function exist to skip a MS VC6 bug/feature
// Without this, VC6 would complains about stack abuse.
{
if ( iPaused ) //resume
{
switch ( iAction )
{
case K_TC9_NewFileNameWhenPaused :
{
AddDriveLetterToPath(_L("NewFileName.3gp"), iFileName );
iAction=K_Tc9_none;
TMMFFileParams params;
params.iPath = iFileName;
TPckgC<TMMFFileParams> pckg(params);
TUid controllerUid = {0x101F8503}; // controller implementation interface uid
TInt err = iCamc->CustomCommandSync( TMMFMessageDestination( controllerUid, KMMFObjectHandleController ), ECamCControllerCCNewFilename, pckg, KNullDesC8);
if (err)
{
User::Leave(err);
}
break;
}
default:
iPaused = EFalse;
iCamc->Record();
}
}
else //timer
{
switch ( iAction )
{
case K_TC9_NewFileNameWhenRecording :
{
AddDriveLetterToPath(_L("NewFileName.3gp"), iFileName );
TMMFFileParams params;
params.iPath = iFileName;
TPckgC<TMMFFileParams> pckg(params);
TUid controllerUid = {0x101F8503}; // controller implementation interface uid
TInt err = iCamc->CustomCommandSync( TMMFMessageDestination( controllerUid, KMMFObjectHandleController ), ECamCControllerCCNewFilename, pckg, KNullDesC8);
if (err)
{
User::Leave(err);
}
break;
}
case K_TC9_NewFileNameWhenPaused:
{
iCamc->PauseL();
CTimer::After(2 * TInt32 ( 1E6 ) ); // Pause for 2 seconds.
iPaused=ETrue;
break;
}
default:
iCamc->Stop(); // Simulates that iRecording has been completed through the
// MvruoRecordComplete callback
iRecordingReady=ETrue;
CTimer::After( 1000 );
}
}
}
void CCamcTestClient_visualcheck::RunLTrappedL()
{
#ifdef _DEBUG
RDebug::Print(_L("CamCTestClient VisualCheck:RunL"));
#endif
if ( iOpenReady )
{
iOpenReady = EFalse;
switch(iAction)
{
case K_VC_test_case_101:
{
break;
}
case K_VC_test_case_102:
{
iCamc->SetVideoFrameSizeL(TSize(128,96));
iCamc->SetVideoFrameRateL(TReal32(3));
iCamc->SetVideoBitRateL(TInt(28000));
iCamc->SetAudioEnabledL(ETrue);
iCamc->SetAudioBitRateL(12200);
iCamc->SetMaxClipSizeL(95000);
break;
}
case K_VC_test_case_103:
{
iCamc->SetVideoFrameSizeL(TSize(128,96));
iCamc->SetVideoFrameRateL(TReal32(5));
iCamc->SetVideoBitRateL(TInt(28000));
iCamc->SetAudioEnabledL(ETrue);
iCamc->SetAudioBitRateL(6700);
iCamc->SetMaxClipSizeL(95000);
break;
}
case K_VC_test_case_104:
{
iCamc->SetVideoFrameSizeL(TSize(128,96));
iCamc->SetVideoFrameRateL(TReal32(10));
iCamc->SetVideoBitRateL(TInt(28000));
iCamc->SetAudioEnabledL(ETrue);
iCamc->SetAudioBitRateL(5150);
iCamc->SetMaxClipSizeL(250000);
break;
}
case K_VC_test_case_105:
{
iCamc->SetVideoFrameSizeL(TSize(176,144));
iCamc->SetVideoFrameRateL(TReal32(1));
iCamc->SetVideoBitRateL(TInt(42000));
iCamc->SetAudioEnabledL(ETrue);
iCamc->SetAudioBitRateL(7400);
iCamc->SetMaxClipSizeL(95000);
break;
}
case K_VC_test_case_106:
{
iCamc->SetVideoFrameSizeL(TSize(176,144));
iCamc->SetVideoFrameRateL(TReal32(3));
iCamc->SetVideoBitRateL(TInt(42000));
iCamc->SetAudioEnabledL(ETrue);
iCamc->SetAudioBitRateL(4750);
iCamc->SetMaxClipSizeL(95000);
break;
}
case K_VC_test_case_107:
{
iCamc->SetVideoFrameSizeL(TSize(176,144));
iCamc->SetVideoFrameRateL(TReal32(5));
iCamc->SetVideoBitRateL(TInt(42000));
iCamc->SetAudioEnabledL(ETrue);
iCamc->SetAudioBitRateL(12200);
break;
}
case K_VC_test_case_108_a:
{
iCamc->SetVideoFrameSizeL(TSize(176,144));
iCamc->SetVideoFrameRateL(TReal32(8));
iCamc->SetVideoBitRateL(TInt(128000));
iCamc->SetAudioEnabledL(ETrue);
iCamc->SetAudioBitRateL(12200);
iCamc->SetMaxClipSizeL(250000);
break;
}
case K_VC_test_case_108_b:
{
iCamc->SetVideoFrameSizeL(TSize(176,144));
iCamc->SetVideoFrameRateL(TReal32(1));
iCamc->SetVideoBitRateL(TInt(64000));
iCamc->SetAudioEnabledL(ETrue);
iCamc->SetAudioBitRateL(12200);
iCamc->SetMaxClipSizeL(250000);
break;
}
case K_VC_test_case_109:
{
iCamc->SetVideoFrameSizeL(TSize(176,144));
iCamc->SetVideoFrameRateL(TReal32(3));
iCamc->SetVideoBitRateL(TInt(64000));
iCamc->SetAudioEnabledL(ETrue);
iCamc->SetAudioBitRateL(12200);
break;
}
case K_VC_test_case_110:
{
iCamc->SetVideoFrameSizeL(TSize(176,144));
iCamc->SetVideoFrameRateL(TReal32(5));
iCamc->SetVideoBitRateL(TInt(42000));
iCamc->SetAudioEnabledL(EFalse);
iCamc->SetMaxClipSizeL(95000);
break;
}
case K_VC_test_case_111:
{
iCamc->SetVideoFrameSizeL(TSize(176,144));
iCamc->SetVideoFrameRateL(TReal32(5));
iCamc->SetVideoBitRateL(TInt(64000));
iCamc->SetAudioEnabledL(EFalse);
iCamc->SetMaxClipSizeL(500000);
break;
}
case K_VC_test_case_112:
{
iCamc->SetVideoFrameSizeL(TSize(128,96));
iCamc->SetVideoFrameRateL(TReal32(5));
iCamc->SetVideoBitRateL(KMMFVariableVideoBitRate);
iCamc->SetMaxClipSizeL(95000);
break;
}
case K_VC_test_case_113:
{
iCamc->SetMaxClipSizeL(50);
break;
}
case K_VC_test_case_114:
{
break;
}
case K_VC_test_case_115:
{
iCamc->SetVideoFrameSizeL(TSize(176,144));
iCamc->SetVideoFrameRateL(TReal32(5));
iCamc->SetVideoBitRateL(KMMFVariableVideoBitRate);
break;
}
case K_VC_test_case_116:
{
iCamc->SetVideoFrameSizeL(TSize(176,144));
iCamc->SetVideoFrameRateL(TReal32(5));
iCamc->SetVideoBitRateL(TInt(64000));
iCamc->SetAudioEnabledL(ETrue);
iCamc->SetAudioBitRateL(12200);
break;
}
case K_VC_test_case_117:
{
iCamc->SetVideoFrameSizeL(TSize(176,144));
iCamc->SetVideoFrameRateL(TReal32(5));
iCamc->SetVideoBitRateL(TInt(64000));
iCamc->SetMaxClipSizeL(95000);
break;
}
case K_VC_test_case_118:
{
iCamc->SetVideoFrameSizeL(TSize(176,144));
iCamc->SetVideoFrameRateL(TReal32(5));
iCamc->SetVideoBitRateL(TInt(64000));
iCamc->SetAudioEnabledL(ETrue);
iCamc->SetAudioBitRateL(12200);
break;
}
case K_VC_test_case_119:
{
iCamc->SetVideoFrameSizeL(TSize(176,144));
iCamc->SetVideoFrameRateL(TReal32(7));
iCamc->SetVideoBitRateL(TInt(64000));
iCamc->SetMaxClipSizeL(95000);
iCamc->SetAudioEnabledL(ETrue);
iCamc->SetAudioBitRateL(5150);
break;
}
case K_VC_test_case_120:
{
iCamc->SetVideoFrameSizeL(TSize(128,96));
iCamc->SetVideoFrameRateL(TReal32(10));
iCamc->SetVideoBitRateL(TInt(64000));
iCamc->SetMaxClipSizeL(500000);
break;
}
case K_VC_test_case_121:
{
iCamc->SetVideoFrameSizeL(TSize(352,288));
iCamc->SetVideoFrameRateL(TReal32(15));
iCamc->SetVideoBitRateL(TInt(384000));
iCamc->SetAudioEnabledL(ETrue);
break;
}
default:
break;
}
iCamc->Prepare();
}
else if ( iPrepareReady )
{
iPrepareReady = EFalse;
iCamc->Record();
switch(iAction)
{
case K_VC_test_case_101:
{
CTimer::After( 30 * TInt32 ( 1E6 ) ); // Records for 30 sec
break;
}
case K_VC_test_case_102:
case K_VC_test_case_103:
case K_VC_test_case_104:
case K_VC_test_case_105:
case K_VC_test_case_106:
case K_VC_test_case_108_a:
case K_VC_test_case_117:
case K_VC_test_case_119:
case K_VC_test_case_113:
{
// The timeout will be generated by the SetMaxClipSize.
break;
}
case K_VC_test_case_114:
{
CTimer::After( 1 * TInt32 ( 1E6 ) ); // Records for 1 sec
break;
}
case K_VC_test_case_116:
{
CTimer::After( 10 * TInt32 ( 1E6 ) ); // Records for 10 sec
iStartRecording2ndTime = EFalse;
break;
}
default:
{
CTimer::After( 10 * TInt32 ( 1E6 ) );
break;
}
}
}
else if ( iRecordingReady )
{
iRecordingReady = EFalse;
iCamc->Close();
iClosed = ETrue;
CTimer::After(1000);
}
else if (iClosed)
{
CActiveScheduler::Stop();
}
else if ( iPaused ) //resume
{
switch(iAction)
{
case K_VC_test_case_107:
{
iCamc->Record();
CTimer::After( 50 * TInt32 ( 1E6 ) ); // Records for 50 sec.
iPaused = EFalse;
iAction = K_VC_none;
break;
}
case K_VC_test_case_109:
case K_VC_test_case_118:
{
if ( iDoublePause )
{
iCamc->Record();
CTimer::After( 2*60 * TInt32 ( 1E6 ) ); // Record 2 minutes
iPaused = EFalse;
iAction = K_VC_none;
}
else
{
iCamc->Record();
CTimer::After( 2*60 * TInt32 ( 1E6 ) ); // Record 2 minutes
iPaused = EFalse;
iDoublePause = ETrue;
}
break;
}
case K_VC_test_case_112:
{
iCamc->Record();
iPaused = EFalse;
break;
}
case K_VC_test_case_115:
{
if ( iDoublePause )
{
iCamc->Record();
iAction = K_VC_none;
// Record until disk full
}
else
{
iCamc->Record();
CTimer::After( 2*60 * TInt32 ( 1E6 ) ); // Record 2 minutes
iPaused = EFalse;
iDoublePause = ETrue;
}
break;
}
case K_VC_test_case_121:
{
iCamc->Record();
CTimer::After( 50 * TInt32 ( 1E6 ) ); // Records for 50 sec.
iPaused = EFalse;
iAction = K_VC_none;
break;
}
default:
break;
}
}
else //timer
{
switch(iAction)
{
case K_VC_test_case_107:
{
iCamc->PauseL();
iPaused = ETrue;
CTimer::After( 5 * TInt32 ( 1E6 ) ); // Pause 5 sec
break;
}
case K_VC_test_case_108_a:
{
if ( i2ndTime )
{
// Volume down
iCamc->SetGainL( 1 );
iAction = K_VC_none;
}
else
{
// Volume Up
TInt aSetGain;
aSetGain = iCamc->MaxGainL();
iCamc->SetGainL( aSetGain );
CTimer::After( 15 * TInt32 ( 1E6 ) );
i2ndTime = ETrue;
}
break;
}
case K_VC_test_case_108_b:
{
if ( i2ndTime )
{
// Volume down
iCamc->SetGainL( 1 );
iAction = K_VC_none;
}
else
{
// Volume Up
TInt aSetGain;
aSetGain = iCamc->MaxGainL();
iCamc->SetGainL( aSetGain );
CTimer::After( 15 * TInt32 ( 1E6 ) );
i2ndTime = ETrue;
}
break;
}
case K_VC_test_case_109:
case K_VC_test_case_115:
case K_VC_test_case_118:
{
iCamc->PauseL();
iPaused = ETrue;
if ( i2ndTime )
{
CTimer::After( 30 * TInt32 ( 1E6 ) ); // Pauses for 30s
}
else
{
CTimer::After( 10 * TInt32 ( 1E6 ) ); // Pauses for 10s
i2ndTime = ETrue;
}
break;
}
case K_VC_test_case_110:
{
iCamc->SetVideoBitRateL( TCVC_VIDEO_BIT_RATE_10 );
break;
}
case K_VC_test_case_111:
{
iCamc->SetVideoBitRateL( TCVC_VIDEO_BIT_RATE_11 );
iAction = K_VC_none;
break;
}
case K_VC_test_case_112:
{
iCamc->PauseL();
iPaused = ETrue;
CTimer::After( 10 * TInt32 ( 1E6 ) );
break;
}
case K_VC_test_case_116:
{
if(iStartRecording2ndTime)
{
iPrepareReady = ETrue;
CTimer::After( 10 * TInt32 ( 1E6 ) );
iAction = K_VC_none;
}
else
{
iCamc->Stop();
CTimer::After( 3 * TInt32 ( 1E6 ) );
iStartRecording2ndTime = ETrue;
}
break;
}
case K_VC_test_case_120:
{
iCamc->SetVideoBitRateL( TCVC_VIDEO_BIT_RATE_20 );
iAction = K_VC_none;
break;
}
case K_VC_test_case_121:
{
iCamc->PauseL();
iPaused = ETrue;
CTimer::After( 5 * TInt32 ( 1E6 ) ); // Pause 5 sec
break;
}
default:
iCamc->Stop();
// Simulates that iRecording has been completed through the
// MvruoRecordComplete callback
iRecordingReady=ETrue;
CTimer::After( 1 * TInt32 ( 1E6 ) );
}
}
}