status_t AudioPolicyManager::startOutput(audio_io_handle_t output, AudioSystem::stream_type stream, int session)
{
LOGV("startOutput() output %d, stream %d", output, stream);
ssize_t index = mOutputs.indexOfKey(output);
if (index < 0) {
LOGW("startOutput() unknow output %d", output);
return BAD_VALUE;
}
AudioOutputDescriptor *outputDesc = mOutputs.valueAt(index);
routing_strategy strategy = getStrategy((AudioSystem::stream_type)stream);
#ifdef WITH_A2DP
if (mA2dpOutput != 0 && !a2dpUsedForSonification() &&
(strategy == STRATEGY_SONIFICATION || strategy == STRATEGY_ENFORCED_AUDIBLE)) {
setStrategyMute(STRATEGY_MEDIA, true, mA2dpOutput);
}
#endif
// incremenent usage count for this stream on the requested output:
// NOTE that the usage count is the same for duplicated output and hardware output which is
// necassary for a correct control of hardware output routing by startOutput() and stopOutput()
outputDesc->changeRefCount(stream, 1);
#ifdef FM_RADIO
#ifdef WITH_QCOM_LPA
if ((stream == AudioSystem::FM && output == mA2dpOutput) || output == mLPADecodeOutput)
setOutputDevice(output, AudioPolicyManagerBase::getNewDevice(output), true);
else
setOutputDevice(output, AudioPolicyManagerBase::getNewDevice(output));
#else
if (stream == AudioSystem::FM && output == mA2dpOutput)
setOutputDevice(output, AudioPolicyManagerBase::getNewDevice(output), true);
else
setOutputDevice(output, AudioPolicyManagerBase::getNewDevice(output));
#endif
#else
#ifdef WITH_QCOM_LPA
if (output == mLPADecodeOutput)
setOutputDevice(output, AudioPolicyManagerBase::getNewDevice(output), true);
else
setOutputDevice(output, AudioPolicyManagerBase::getNewDevice(output));
#else
setOutputDevice(output, AudioPolicyManagerBase::getNewDevice(output));
#endif
#endif
// handle special case for sonification while in call
if (isInCall()) {
AudioPolicyManagerBase::handleIncallSonification(stream, true, false);
}
// apply volume rules for current stream and device if necessary
checkAndSetVolume(stream, mStreams[stream].mIndexCur, output, outputDesc->device());
return NO_ERROR;
}
Sword::Sword(const std::string& n) :
name(n),
strategy(getStrategy(name)),
//swordSurface(IOManager::getInstance().loadAndSet(Gamedata::getInstance().getXmlStr(name+"File"), true)),
swordFrame(FrameFactory::getInstance().getFrames(name)),
frameInterval(Gamedata::getInstance().getXmlInt(name+"SwordInterval")),
timeSinceLastFrame(0),
swordList(),
freeList()
{}
Bullets::Bullets(const std::string& n):
Sprite(n),
name(n),
strategy(getStrategy(name)),
//bulletSurface(IOManager::getInstance().loadAndSet(Gamedata::getInstance().getXmlStr(name+"/File"),true)),
bulletFrame(FrameFactory::getInstance().getFrame(name)),
frameInterval(Gamedata::getInstance().getXmlInt(name+"/Interval")),
timeSinceLastFrame(0),
bulletList(),
freeList()
{}
uint32_t AudioPolicyManagerBase::getDevicesForStream(AudioSystem::stream_type stream) {
uint32_t devices;
// By checking the range of stream before calling getStrategy, we avoid
// getStrategy's behavior for invalid streams. getStrategy would do a LOGE
// and then return STRATEGY_MEDIA, but we want to return the empty set.
if (stream < (AudioSystem::stream_type) 0 || stream >= AudioSystem::NUM_STREAM_TYPES) {
devices = 0;
} else {
AudioPolicyManagerBase::routing_strategy strategy = getStrategy(stream);
devices = getDeviceForStrategy(strategy, true);
}
return devices;
}
/* LGE_CHANGE_E [email protected] 2010.01.27 */ status_t AudioPolicyManagerALSA::stopOutput(audio_io_handle_t output, AudioSystem::stream_type stream) { LOGV("stopOutput() output %d, stream %d", output, stream); ssize_t index = mOutputs.indexOfKey(output); if (index < 0) { LOGW("stopOutput() unknow output %d", output); return BAD_VALUE; } AudioOutputDescriptor *outputDesc = mOutputs.valueAt(index); routing_strategy strategy = getStrategy((AudioSystem::stream_type)stream); // handle special case for sonification while in call if (mPhoneState == AudioSystem::MODE_IN_CALL) { handleIncallSonification(stream, false, false); } if (outputDesc->isUsedByStrategy(strategy)) { // decrement usage count of this stream on the output outputDesc->changeRefCount(stream, -1); if (!outputDesc->isUsedByStrategy(strategy)) { // if the stream is the last of its strategy to use this output, change routing // in the following order or priority: // PHONE > SONIFICATION > MEDIA > DTMF uint32_t newDevice = 0; if (outputDesc->isUsedByStrategy(STRATEGY_PHONE)) { newDevice = getDeviceForStrategy(STRATEGY_PHONE); } else if (outputDesc->isUsedByStrategy(STRATEGY_SONIFICATION)) { newDevice = getDeviceForStrategy(STRATEGY_SONIFICATION); } else if (mPhoneState == AudioSystem::MODE_IN_CALL) { newDevice = getDeviceForStrategy(STRATEGY_PHONE); } else if (outputDesc->isUsedByStrategy(STRATEGY_MEDIA)) { newDevice = getDeviceForStrategy(STRATEGY_MEDIA); } else if (outputDesc->isUsedByStrategy(STRATEGY_DTMF)) { newDevice = getDeviceForStrategy(STRATEGY_DTMF); } // apply routing change if necessary. // insert a delay of 2 times the audio hardware latency to ensure PCM // buffers in audio flinger and audio hardware are emptied before the // routing change is executed. setOutputDevice(mHardwareOutput, newDevice, false, mOutputs.valueFor(mHardwareOutput)->mLatency*2); } // store time at which the last music track was stopped - see computeVolume() if (stream == AudioSystem::MUSIC) { mMusicStopTime = systemTime(); } return NO_ERROR; } else { LOGW("stopOutput() refcount is already 0 for output %d", output); return INVALID_OPERATION; } }
void PackVmlinuzI386::pack(OutputFile *fo)
{
readKernel();
// prepare filter
Filter ft(ph.level);
ft.buf_len = ph.u_len;
ft.addvalue = physical_start; // saves 4 bytes in unfilter code
// compress
upx_compress_config_t cconf; cconf.reset();
// limit stack size needed for runtime decompression
cconf.conf_lzma.max_num_probs = 1846 + (768 << 4); // ushort: ~28 KiB stack
compressWithFilters(&ft, 512, &cconf, getStrategy(ft));
const unsigned lsize = getLoaderSize();
defineDecompressorSymbols();
defineFilterSymbols(&ft);
linker->defineSymbol("src_for_decompressor", zimage_offset + lsize);
linker->defineSymbol("original_entry", physical_start);
linker->defineSymbol("stack_offset", stack_offset_during_uncompression);
relocateLoader();
MemBuffer loader(lsize);
memcpy(loader, getLoader(), lsize);
patchPackHeader(loader, lsize);
boot_sect_t * const bs = (boot_sect_t *) ((unsigned char *) setup_buf);
bs->sys_size = ALIGN_UP(lsize + ph.c_len, 16u) / 16;
bs->payload_length = ph.c_len;
fo->write(setup_buf, setup_buf.getSize());
fo->write(loader, lsize);
fo->write(obuf, ph.c_len);
#if 0
printf("%-13s: setup : %8ld bytes\n", getName(), (long) setup_buf.getSize());
printf("%-13s: loader : %8ld bytes\n", getName(), (long) lsize);
printf("%-13s: compressed : %8ld bytes\n", getName(), (long) ph.c_len);
#endif
// verify
verifyOverlappingDecompression();
// finally check the compression ratio
if (!checkFinalCompressionRatio(fo))
throwNotCompressible();
}
MultiSprite::MultiSprite(const std::string& name,
const Vector2f& pos, const Vector2f& vel,
const std::vector<Frame*>& fms) :
Drawable(name, pos, vel),
frames(fms),
worldWidth(Gamedata::getInstance().getXmlInt("worldWidth")),
worldHeight(Gamedata::getInstance().getXmlInt("worldHeight")),
dt(0),
currentFrame(0),
numberOfFrames( Gamedata::getInstance().getXmlInt(name+"Frames") ),
frameInterval( Gamedata::getInstance().getXmlInt(name+"FrameInterval") ),
timeSinceLastFrame( 0 ),
frameWidth(fms[0]->getWidth()),
frameHeight(fms[0]->getHeight()),
STATUS(0),
strategy(getStrategy(name))
{ }
audio_io_handle_t AudioPolicyManager::getSession(AudioSystem::stream_type stream,
uint32_t format,
AudioSystem::output_flags flags,
int32_t sessionId)
{
audio_io_handle_t output = 0;
uint32_t latency = 0;
routing_strategy strategy = getStrategy((AudioSystem::stream_type)stream);
uint32_t device = getDeviceForStrategy(strategy);
LOGV("getSession() stream %d, format %d, sessionId %x, flags %x device %d", stream, format, sessionId, flags, device);
AudioOutputDescriptor *outputDesc = new AudioOutputDescriptor();
outputDesc->mDevice = device;
outputDesc->mSamplingRate = 0;
outputDesc->mFormat = format;
outputDesc->mChannels = 2;
outputDesc->mLatency = 0;
outputDesc->mFlags = (AudioSystem::output_flags)(flags | AudioSystem::OUTPUT_FLAG_DIRECT);
outputDesc->mRefCount[stream] = 0;
output = mpClientInterface->openSession(&outputDesc->mDevice,
&outputDesc->mFormat,
outputDesc->mFlags,
stream,
sessionId);
// only accept an output with the requeted parameters
if ((format != 0 && format != outputDesc->mFormat) || !output) {
LOGE("openSession() failed opening a session: format %d, sessionId %d output %d",
format, sessionId, output);
if(output) {
mpClientInterface->closeSession(output);
}
delete outputDesc;
return 0;
}
//reset it here, it will get updated in startoutput
outputDesc->mDevice = 0;
mOutputs.add(output, outputDesc);
mLPADecodeOutput = output;
mLPAStreamType = stream;
return output;
}
MultiSprite::MultiSprite( const std::string& name) :
Drawable(name,
Vector2f(Gamedata::getInstance().getXmlInt(name+"X"),
Gamedata::getInstance().getXmlInt(name+"Y")),
Vector2f(Gamedata::getInstance().getXmlInt(name+"SpeedX"),
Gamedata::getInstance().getXmlInt(name+"SpeedY"))
),
frames( FrameFactory::getInstance().getFrames(name) ),
worldWidth(Gamedata::getInstance().getXmlInt("worldWidth")),
worldHeight(Gamedata::getInstance().getXmlInt("worldHeight")),
dt(0),
currentFrame(0),
numberOfFrames( Gamedata::getInstance().getXmlInt(name+"Frames") ),
frameInterval( Gamedata::getInstance().getXmlInt(name+"FrameInterval") ),
timeSinceLastFrame( 0 ),
frameWidth(frames[0]->getWidth()),
frameHeight(frames[0]->getHeight()),
STATUS(0),
strategy(getStrategy(name))
{ }
//单击“添加旅客”按钮，开始运行
void Widget::addTravelerButtonClicked()
{
//添加旅客，初始化旅客信息
qDebug() << "Add new traveler, reset all elements in widget";
std::vector<bool> temp(12, false);
throughcity = temp;
qDebug() << "throughcity creat success.";
travelers.push_back(Traveler(addtravelertimes-1, getStartTime(), getDeadline(),
getStrategy(), getStart(), getDestination(),
ui->ThroughCityCheckBox->isChecked(), throughcity));
qDebug() << "travelers.pushback...";
startclicked.push_back(false);
addtravelertimes += 1;
startclickedtimes = 0;
//将界面右侧各栏初始化显示
ui->TravelerComboBox->addItem(QString::number(addtravelertimes));
ui->TravelerComboBox->setCurrentText(QString::number(addtravelertimes));
ui->StartButton->setText(QString::fromWCharArray(L"开始"));
ui->TravelerComboBox->setEnabled(true);
ui->StartComboBox->setEnabled(true);
ui->StrategyComboBox->setEnabled(true);
ui->DestinationComboBox->setEnabled(true);
ui->StrategyComboBox->setCurrentIndex(0);
ui->StartComboBox->setCurrentIndex(0);
ui->DestinationComboBox->setCurrentIndex(1);
ui->ThroughCityCheckBox->setEnabled(true);
ui->DeadlineDateTimeEdit->setEnabled(false);
ui->StartDateTimeEdit->setEnabled(true);
ui->StartButton->setEnabled(true);
ui->StartDateTimeEdit->setDateTime(QDateTime::currentDateTime());
int deaDay = QDateTime::currentDateTime().date().day();
deaDay += 1;
QDateTime deadlineDateTime;
deadlineDateTime.setDate(QDate(QDateTime::currentDateTime().date().year(), QDateTime::currentDateTime().date().month(), deaDay));
deadlineDateTime.setTime(QTime(QDateTime::currentDateTime().time()));
ui->DeadlineDateTimeEdit->setDateTime(deadlineDateTime);
}
//-----------------------------------------------------------------------
void LodStrategyManager::setDefaultStrategy(const String& name)
{
// Lookup by name and set default strategy
setDefaultStrategy(getStrategy(name));
}
void PackUnix::packExtent(
const Extent &x,
unsigned &total_in,
unsigned &total_out,
Filter *ft,
OutputFile *fo,
unsigned hdr_u_len
)
{
unsigned const init_u_adler = ph.u_adler;
unsigned const init_c_adler = ph.c_adler;
MemBuffer hdr_ibuf;
if (hdr_u_len) {
hdr_ibuf.alloc(hdr_u_len);
fi->seek(0, SEEK_SET);
int l = fi->readx(hdr_ibuf, hdr_u_len);
(void)l;
}
fi->seek(x.offset, SEEK_SET);
for (off_t rest = x.size; 0 != rest; ) {
int const filter_strategy = ft ? getStrategy(*ft) : 0;
int l = fi->readx(ibuf, UPX_MIN(rest, (off_t)blocksize));
if (l == 0) {
break;
}
rest -= l;
// Note: compression for a block can fail if the
// file is e.g. blocksize + 1 bytes long
// compress
ph.c_len = ph.u_len = l;
ph.overlap_overhead = 0;
unsigned end_u_adler = 0;
if (ft) {
// compressWithFilters() updates u_adler _inside_ compress();
// that is, AFTER filtering. We want BEFORE filtering,
// so that decompression checks the end-to-end checksum.
end_u_adler = upx_adler32(ibuf, ph.u_len, ph.u_adler);
ft->buf_len = l;
// compressWithFilters() requirements?
ph.filter = 0;
ph.filter_cto = 0;
ft->id = 0;
ft->cto = 0;
compressWithFilters(ft, OVERHEAD, NULL_cconf, filter_strategy,
0, 0, 0, hdr_ibuf, hdr_u_len);
}
else {
(void) compress(ibuf, ph.u_len, obuf); // ignore return value
}
if (ph.c_len < ph.u_len) {
const upx_bytep tbuf = NULL;
if (ft == NULL || ft->id == 0) tbuf = ibuf;
ph.overlap_overhead = OVERHEAD;
if (!testOverlappingDecompression(obuf, tbuf, ph.overlap_overhead)) {
// not in-place compressible
ph.c_len = ph.u_len;
}
}
if (ph.c_len >= ph.u_len) {
// block is not compressible
ph.c_len = ph.u_len;
memcpy(obuf, ibuf, ph.c_len);
// must update checksum of compressed data
ph.c_adler = upx_adler32(ibuf, ph.u_len, ph.saved_c_adler);
}
// write block sizes
b_info tmp;
if (hdr_u_len) {
unsigned hdr_c_len = 0;
MemBuffer hdr_obuf;
hdr_obuf.allocForCompression(hdr_u_len);
int r = upx_compress(hdr_ibuf, hdr_u_len, hdr_obuf, &hdr_c_len, 0,
ph.method, 10, NULL, NULL);
if (r != UPX_E_OK)
throwInternalError("header compression failed");
if (hdr_c_len >= hdr_u_len)
throwInternalError("header compression size increase");
ph.saved_u_adler = upx_adler32(hdr_ibuf, hdr_u_len, init_u_adler);
ph.saved_c_adler = upx_adler32(hdr_obuf, hdr_c_len, init_c_adler);
ph.u_adler = upx_adler32(ibuf, ph.u_len, ph.saved_u_adler);
ph.c_adler = upx_adler32(obuf, ph.c_len, ph.saved_c_adler);
end_u_adler = ph.u_adler;
memset(&tmp, 0, sizeof(tmp));
set_te32(&tmp.sz_unc, hdr_u_len);
set_te32(&tmp.sz_cpr, hdr_c_len);
tmp.b_method = (unsigned char) ph.method;
fo->write(&tmp, sizeof(tmp));
b_len += sizeof(b_info);
fo->write(hdr_obuf, hdr_c_len);
total_out += hdr_c_len;
total_in += hdr_u_len;
hdr_u_len = 0; // compress hdr one time only
}
memset(&tmp, 0, sizeof(tmp));
set_te32(&tmp.sz_unc, ph.u_len);
set_te32(&tmp.sz_cpr, ph.c_len);
if (ph.c_len < ph.u_len) {
tmp.b_method = (unsigned char) ph.method;
if (ft) {
tmp.b_ftid = (unsigned char) ft->id;
tmp.b_cto8 = ft->cto;
}
}
fo->write(&tmp, sizeof(tmp));
b_len += sizeof(b_info);
if (ft) {
ph.u_adler = end_u_adler;
}
// write compressed data
if (ph.c_len < ph.u_len) {
fo->write(obuf, ph.c_len);
// Checks ph.u_adler after decompression, after unfiltering
verifyOverlappingDecompression(ft);
}
else {
fo->write(ibuf, ph.u_len);
}
total_in += ph.u_len;
total_out += ph.c_len;
}
}
int PackUnix::pack2(OutputFile *fo, Filter &ft)
{
// compress blocks
unsigned total_in = 0;
unsigned total_out = 0;
// FIXME: ui_total_passes is not correct with multiple blocks...
// ui_total_passes = (file_size + blocksize - 1) / blocksize;
// if (ui_total_passes == 1)
// ui_total_passes = 0;
unsigned remaining = file_size;
unsigned n_block = 0;
while (remaining > 0)
{
// FIXME: disable filters if we have more than one block.
// FIXME: There is only 1 un-filter in the stub [as of 2002-11-10].
// So the next block really has no choice!
// This merely prevents an assert() in compressWithFilters(),
// which assumes it has free choice on each call [block].
// And if the choices aren't the same on each block,
// then un-filtering will give incorrect results.
int filter_strategy = getStrategy(ft);
if (file_size > (off_t)blocksize)
filter_strategy = -3; // no filters
int l = fi->readx(ibuf, UPX_MIN(blocksize, remaining));
remaining -= l;
// Note: compression for a block can fail if the
// file is e.g. blocksize + 1 bytes long
// compress
ph.overlap_overhead = 0;
ph.c_len = ph.u_len = l;
ft.buf_len = l;
// compressWithFilters() updates u_adler _inside_ compress();
// that is, AFTER filtering. We want BEFORE filtering,
// so that decompression checks the end-to-end checksum.
unsigned const end_u_adler = upx_adler32(ibuf, ph.u_len, ph.u_adler);
compressWithFilters(&ft, OVERHEAD, NULL_cconf, filter_strategy,
!!n_block++); // check compression ratio only on first block
if (ph.c_len < ph.u_len) {
const upx_bytep tbuf = NULL;
if (ft.id == 0) tbuf = ibuf;
ph.overlap_overhead = OVERHEAD;
if (!testOverlappingDecompression(obuf, tbuf, ph.overlap_overhead)) {
// not in-place compressible
ph.c_len = ph.u_len;
}
}
if (ph.c_len >= ph.u_len) {
// block is not compressible
ph.c_len = ph.u_len;
// must manually update checksum of compressed data
ph.c_adler = upx_adler32(ibuf, ph.u_len, ph.saved_c_adler);
}
// write block header
b_info blk_info;
memset(&blk_info, 0, sizeof(blk_info));
set_te32(&blk_info.sz_unc, ph.u_len);
set_te32(&blk_info.sz_cpr, ph.c_len);
if (ph.c_len < ph.u_len) {
blk_info.b_method = (unsigned char) ph.method;
blk_info.b_ftid = (unsigned char) ph.filter;
blk_info.b_cto8 = (unsigned char) ph.filter_cto;
}
fo->write(&blk_info, sizeof(blk_info));
b_len += sizeof(b_info);
// write compressed data
if (ph.c_len < ph.u_len) {
fo->write(obuf, ph.c_len);
verifyOverlappingDecompression(); // uses ph.u_adler
}
else {
fo->write(ibuf, ph.u_len);
}
ph.u_adler = end_u_adler;
total_in += ph.u_len;
total_out += ph.c_len;
}
// update header with totals
ph.u_len = total_in;
ph.c_len = total_out;
if ((off_t)total_in != file_size) {
throwEOFException();
}
return 1; // default: write end-of-compression bhdr next
}
void PackBvmlinuzI386::pack(OutputFile *fo)
{
readKernel();
// prepare filter
Filter ft(ph.level);
ft.buf_len = (filter_len ? filter_len : (ph.u_len * 3)/5);
// May 2008: 3/5 is heuristic to cover most .text but avoid non-instructions.
// Otherwise "call trick" filter cannot find a free marker byte,
// especially when it searches over tables of data.
ft.addvalue = 0; // The destination buffer might be relocated at runtime.
upx_compress_config_t cconf; cconf.reset();
// LINUZ001 allows most of low memory as stack for Bvmlinuz
cconf.conf_lzma.max_num_probs = (0x90000 - 0x10000)>>1; // ushort: 512 KiB stack
compressWithFilters(&ft, 512, &cconf, getStrategy(ft));
// align everything to dword boundary - it is easier to handle
unsigned c_len = ph.c_len;
memset(obuf + c_len, 0, 4);
c_len = ALIGN_UP(c_len, 4u);
const unsigned lsize = getLoaderSize();
if (M_IS_LZMA(ph.method)) {
const lzma_compress_result_t *res = &ph.compress_result.result_lzma;
upx_uint32_t properties = // lc, lp, pb, dummy
(res->lit_context_bits << 0) |
(res->lit_pos_bits << 8) |
(res->pos_bits << 16);
if (linker->bele->isBE()) // big endian - bswap32
acc_swab32s(&properties);
linker->defineSymbol("lzma_properties", properties);
// -2 for properties
linker->defineSymbol("lzma_c_len", ph.c_len - 2);
linker->defineSymbol("lzma_u_len", ph.u_len);
unsigned const stack = getDecompressorWrkmemSize();
linker->defineSymbol("lzma_stack_adjust", 0u - stack);
}
const int e_len = getLoaderSectionStart("LZCUTPOI");
assert(e_len > 0);
if (0==page_offset) { // not relocatable kernel
const unsigned d_len4 = ALIGN_UP(lsize - e_len, 4u);
const unsigned decompr_pos = ALIGN_UP(ph.u_len + ph.overlap_overhead, 16u);
const unsigned copy_size = c_len + d_len4;
const unsigned edi = decompr_pos + d_len4 - 4; // copy to
const unsigned esi = ALIGN_UP(c_len + lsize, 4u) - 4; // copy from
linker->defineSymbol("decompressor", decompr_pos - bzimage_offset + physical_start);
linker->defineSymbol("src_for_decompressor", physical_start + decompr_pos - c_len);
linker->defineSymbol("words_to_copy", copy_size / 4);
linker->defineSymbol("copy_dest", physical_start + edi);
linker->defineSymbol("copy_source", bzimage_offset + esi);
}
defineFilterSymbols(&ft);
defineDecompressorSymbols();
if (0==page_offset) {
linker->defineSymbol("original_entry", physical_start);
}
linker->defineSymbol("stack_offset", stack_offset_during_uncompression);
relocateLoader();
MemBuffer loader(lsize);
memcpy(loader, getLoader(), lsize);
patchPackHeader(loader, lsize);
boot_sect_t * const bs = (boot_sect_t *) ((unsigned char *) setup_buf);
bs->sys_size = (ALIGN_UP(lsize + c_len, 16u) / 16);
fo->write(setup_buf, setup_buf.getSize());
unsigned const e_pfx = (0==page_offset) ? 0 : getLoaderSectionStart("LINUZ110");
if (0!=page_offset) {
fo->write(loader, e_pfx);
}
else {
fo->write(loader, e_len);
}
fo->write(obuf, c_len);
if (0!=page_offset) {
fo->write(loader + e_pfx, e_len - e_pfx);
}
fo->write(loader + e_len, lsize - e_len);
#if 0
printf("%-13s: setup : %8ld bytes\n", getName(), (long) setup_buf.getSize());
printf("%-13s: entry : %8ld bytes\n", getName(), (long) e_len);
printf("%-13s: compressed : %8ld bytes\n", getName(), (long) c_len);
printf("%-13s: decompressor : %8ld bytes\n", getName(), (long) (lsize - e_len));
#endif
// verify
verifyOverlappingDecompression();
// finally check the compression ratio
if (!checkFinalCompressionRatio(fo))
throwNotCompressible();
}
//单击“开始”按钮，获取用户输入信息
void Widget::startButtonClicked()
{
QDateTime startDateTime;
//对于当前旅客，初次点击开始按钮
if (startclicked[ui->TravelerComboBox->currentIndex()] == false)
{
qDebug() << "StartButton clicked 1st time for CurrentTraveler";
strategy = getStrategy();
start = getStart();
destination = getDestination();
//始发地和目的地相同则弹框报错，不作操作
if (start == destination)
{
qDebug() << "Start and Dedtination is the same one, wait for another command";
QMessageBox::information(this, "Error", QString::fromWCharArray(L"出发地和目的地相同"));
return;
}
//（策略三的情况下）截止时间早于当前时间报错，不作操作
if (!(ui->StartDateTimeEdit->dateTime() < ui->DeadlineDateTimeEdit->dateTime()))
{
qDebug() << "Deadline ahead of StratTime, wait for another command";
QMessageBox::information(this, "Error", QString::fromWCharArray(L"截止时间早于当前时间"));
return;
}
startDateTime = getStartTime();
travelers[ui->TravelerComboBox->currentIndex()] = (Traveler(addtravelertimes-1, startDateTime,
getDeadline(), strategy, start, destination, ui->ThroughCityCheckBox->isChecked(), throughcity));
std::vector<Attribute> path = travelers[ui->TravelerComboBox->currentIndex()].getPlan();
if (path.size() == 0)
{
qDebug() << "No legal path";
QMessageBox::information(this, "Error", QString::fromWCharArray(L"无有效路径"));
startclicked[ui->TravelerComboBox->currentIndex()] = false;
return;
}
startclicked[ui->TravelerComboBox->currentIndex()] = true;
currentTraveler = ui->TravelerComboBox->currentIndex();
displayTotalTime();
displayFare(path);
displayPath(path);
qDebug() << "StartButton rename as ChangePlan for CurrentTraveler";
ui->StartButton->setText(QString::fromWCharArray(L"更改"));
ui->StartComboBox->setEnabled(false);
ui->StartDateTimeEdit->setEnabled(false);
startclickedtimes += 1;
startclicked[ui->TravelerComboBox->currentIndex()] = true;
return;
}
//对于当前旅客，执行更改计划操作
if (startclicked[ui->TravelerComboBox->currentIndex()] == true)
{
qDebug() << "StartButton clicked for CurrentTraveler";
strategy = getStrategy();
destination = getDestination();
if (!(ui->StartDateTimeEdit->dateTime() < ui->DeadlineDateTimeEdit->dateTime()))
{
qDebug() << "Deadline ahead of StartTime, reset the DeadlineDateTimeEdit,wait for another command";
QMessageBox::information(this, "Error", QString::fromWCharArray(L"截止时间早于当前时间"));
int deaDay = ui->StartDateTimeEdit->dateTime().date().day();
deaDay += 1;
QDateTime deadlineDateTime;
deadlineDateTime.setDate(QDate(ui->StartDateTimeEdit->dateTime().date().year(), ui->StartDateTimeEdit->dateTime().date().month(), deaDay));
deadlineDateTime.setTime(QTime(ui->StartDateTimeEdit->dateTime().time()));
ui->DeadlineDateTimeEdit->setDateTime(deadlineDateTime);
return;
}
//获得新计划的始发地，即原计划的当前停留地/运行途中即将到达地
int nextCity2Arrive = ui->LeftWidget->nextCity();
if (nextCity2Arrive != -1)
{
std::vector<Attribute> path = travelers[ui->TravelerComboBox->currentIndex()].changePlan(nextCity2Arrive, strategy, destination, getDeadline(),
ui->ThroughCityCheckBox->isChecked(),throughcity);
if (path.size() == 0)
{
qDebug() << "No legal path";
QMessageBox::information(this, "Error", QString::fromWCharArray(L"无有效路径"));
return;
}
qDebug() << "Change plan success.";
currentTraveler = ui->TravelerComboBox->currentIndex();
displayTotalTime();
displayFare(path);
displayPath(path);
}
}
}
status_t AudioPolicyManagerALSA::setDeviceConnectionState(AudioSystem::audio_devices device,
AudioSystem::device_connection_state state,
const char *device_address)
{
LOGV("setDeviceConnectionState() device: %x, state %d, address %s", device, state, device_address);
// connect/disconnect only 1 device at a time
if (AudioSystem::popCount(device) != 1) return BAD_VALUE;
if (strlen(device_address) >= MAX_DEVICE_ADDRESS_LEN) {
LOGE("setDeviceConnectionState() invalid address: %s", device_address);
return BAD_VALUE;
}
// handle output devices
if (AudioSystem::isOutputDevice(device)) {
#ifndef WITH_A2DP
if (AudioSystem::isA2dpDevice(device)) {
LOGE("setDeviceConnectionState() invalid device: %x", device);
return BAD_VALUE;
}
#endif
switch (state)
{
// handle output device connection
case AudioSystem::DEVICE_STATE_AVAILABLE:
if (mAvailableOutputDevices & device) {
LOGW("setDeviceConnectionState() device already connected: %x", device);
return INVALID_OPERATION;
}
LOGV("setDeviceConnectionState() connecting device %x", device);
// register new device as available
mAvailableOutputDevices |= device;
#ifdef WITH_A2DP
// handle A2DP device connection
if (AudioSystem::isA2dpDevice(device)) {
status_t status = handleA2dpConnection(device, device_address);
if (status != NO_ERROR) {
mAvailableOutputDevices &= ~device;
return status;
}
} else
#endif
{
if (AudioSystem::isBluetoothScoDevice(device)) {
LOGV("setDeviceConnectionState() BT SCO device, address %s", device_address);
// keep track of SCO device address
mScoDeviceAddress = String8(device_address, MAX_DEVICE_ADDRESS_LEN);
#ifdef WITH_A2DP
if (mA2dpOutput != 0 &&
mPhoneState != AudioSystem::MODE_NORMAL) {
mpClientInterface->suspendOutput(mA2dpOutput);
}
#endif
}
}
break;
// handle output device disconnection
case AudioSystem::DEVICE_STATE_UNAVAILABLE: {
if (!(mAvailableOutputDevices & device)) {
LOGW("setDeviceConnectionState() device not connected: %x", device);
return INVALID_OPERATION;
}
LOGV("setDeviceConnectionState() disconnecting device %x", device);
// remove device from available output devices
mAvailableOutputDevices &= ~device;
#ifdef WITH_A2DP
// handle A2DP device disconnection
if (AudioSystem::isA2dpDevice(device)) {
status_t status = handleA2dpDisconnection(device, device_address);
if (status != NO_ERROR) {
mAvailableOutputDevices |= device;
return status;
}
} else
#endif
{
if (AudioSystem::isBluetoothScoDevice(device)) {
mScoDeviceAddress = "";
#ifdef WITH_A2DP
if (mA2dpOutput != 0 &&
mPhoneState != AudioSystem::MODE_NORMAL) {
mpClientInterface->restoreOutput(mA2dpOutput);
}
#endif
}
}
} break;
default:
LOGE("setDeviceConnectionState() invalid state: %x", state);
return BAD_VALUE;
}
// request routing change if necessary
uint32_t newDevice = getNewDevice(mHardwareOutput, false);
// force routing if device disconnection occurs when stream is stopped
if ((newDevice == 0) && (state == AudioSystem::DEVICE_STATE_UNAVAILABLE))
newDevice = getDeviceForStrategy(STRATEGY_MEDIA, false);
#ifdef WITH_A2DP
//+++ KBNAM_PORTING
/* org
checkOutputForAllStrategies(newDevice);
*/
checkOutputForAllStrategies();
//---
// A2DP outputs must be closed after checkOutputForAllStrategies() is executed
if (state == AudioSystem::DEVICE_STATE_UNAVAILABLE && AudioSystem::isA2dpDevice(device)) {
closeA2dpOutputs();
}
#endif
updateDeviceForStrategy();
setOutputDevice(mHardwareOutput, newDevice);
if (device == AudioSystem::DEVICE_OUT_WIRED_HEADSET) {
device = AudioSystem::DEVICE_IN_WIRED_HEADSET;
} else if (device == AudioSystem::DEVICE_OUT_BLUETOOTH_SCO ||
device == AudioSystem::DEVICE_OUT_BLUETOOTH_SCO_HEADSET ||
device == AudioSystem::DEVICE_OUT_BLUETOOTH_SCO_CARKIT) {
device = AudioSystem::DEVICE_IN_BLUETOOTH_SCO_HEADSET;
} else {
return NO_ERROR;
}
}
// handle input devices
if (AudioSystem::isInputDevice(device)) {
switch (state)
{
// handle input device connection
case AudioSystem::DEVICE_STATE_AVAILABLE: {
if (mAvailableInputDevices & device) {
LOGW("setDeviceConnectionState() device already connected: %d", device);
return INVALID_OPERATION;
}
mAvailableInputDevices |= device;
}
break;
// handle input device disconnection
case AudioSystem::DEVICE_STATE_UNAVAILABLE: {
if (!(mAvailableInputDevices & device)) {
LOGW("setDeviceConnectionState() device not connected: %d", device);
return INVALID_OPERATION;
}
mAvailableInputDevices &= ~device;
} break;
default:
LOGE("setDeviceConnectionState() invalid state: %x", state);
return BAD_VALUE;
}
audio_io_handle_t activeInput = getActiveInput();
if (activeInput != 0) {
AudioInputDescriptor *inputDesc = mInputs.valueFor(activeInput);
uint32_t newDevice = getDeviceForInputSource(inputDesc->mInputSource);
if (newDevice != inputDesc->mDevice) {
LOGV("setDeviceConnectionState() changing device from %x to %x for input %d",
inputDesc->mDevice, newDevice, activeInput);
inputDesc->mDevice = newDevice;
AudioParameter param = AudioParameter();
param.addInt(String8(AudioParameter::keyRouting), (int)newDevice);
mpClientInterface->setParameters(activeInput, param.toString());
}
}
else {
/* LGE_CHANGE_S [email protected] 2010.01.27 */
#ifdef SUPPORT_FM_ANALOG
if (device == AudioSystem::DEVICE_IN_FM_ANALOG) {
routing_strategy strategy = getStrategy((AudioSystem::stream_type)3);
uint32_t curOutdevice = getDeviceForStrategy(strategy);
/* If A2DP headset is connected then route FM to Headset */
if (curOutdevice == AudioSystem::DEVICE_OUT_BLUETOOTH_A2DP ||
curOutdevice == AudioSystem::DEVICE_OUT_BLUETOOTH_SCO) {
curOutdevice = AudioSystem::DEVICE_OUT_WIRED_HEADSET;
}
if (state) {
// routing_strategy strategy = getStrategy((AudioSystem::stream_type)3);
// uint32_t curOutdevice = getDeviceForStrategy(strategy);
/* Get the new input descriptor for FM Rx In */
mfmInput = getFMInput(AUDIO_SOURCE_FM_ANALOG,8000,1,
AudioSystem::CHANNEL_IN_MONO,(AudioSystem::audio_in_acoustics)7);
/* Forcely open the current output device again for
* FM Rx playback path to open
*/
LOGV("curOutdevice = %x",curOutdevice);
setOutputDevice(mHardwareOutput, curOutdevice, true);
/* Tell the audio flinger playback thread that
* FM Rx is active
*/
mpClientInterface->setFMRxActive(true);
} else {
int newDevice=0;
AudioParameter param = AudioParameter();
param.addInt(String8(AudioParameter::keyRouting), (int)newDevice);
/* Change the input device from FM to default before releasing Input */
mpClientInterface->setParameters(mfmInput, param.toString());
param.addInt(String8("fm_off"), (int)newDevice);
/* Close the capture handle */
mpClientInterface->setParameters(mfmInput, param.toString());
/* Release the input descriptor for FM Rx In */
releaseInput(mfmInput);
/* Close the playback handle */
mpClientInterface->setParameters(mHardwareOutput, param.toString());
/* Tell the audio flinger playback thread that
* FM Rx is not active now.
*/
mpClientInterface->setFMRxActive(false);
}
}
#endif // SUPPORT_FM_ANALOG
/* LGE_CHANGE_E [email protected] 2010.01.27 */
}
return NO_ERROR;
}
LOGW("setDeviceConnectionState() invalid device: %x", device);
return BAD_VALUE;
}