void FFmpegDecoderVideo::decodeLoop()
{
FFmpegPacket packet;
double pts;
while (! m_exit)
{
// Work on the current packet until we have decoded all of it
while (m_bytes_remaining > 0)
{
// Save global PTS to be stored in m_frame via getBuffer()
m_packet_pts = packet.packet.pts;
// Decode video frame
int frame_finished = 0;
// We want to use the entire packet since some codecs will require extra information for decoding
const int bytes_decoded = avcodec_decode_video2(m_context, m_frame.get(), &frame_finished, &(packet.packet));
if (bytes_decoded < 0)
throw std::runtime_error("avcodec_decode_video failed()");
m_bytes_remaining -= bytes_decoded;
m_packet_data += bytes_decoded;
// Publish the frame if we have decoded a complete frame
if (frame_finished)
{
AVRational timebase;
// Find out the frame pts
if (m_frame->pts != int64_t(AV_NOPTS_VALUE))
{
pts = m_frame->pts;
timebase = m_context->time_base;
}
else if (packet.packet.dts == int64_t(AV_NOPTS_VALUE) &&
m_frame->opaque != 0 &&
*reinterpret_cast<const int64_t*>(m_frame->opaque) != int64_t(AV_NOPTS_VALUE))
{
pts = *reinterpret_cast<const int64_t*>(m_frame->opaque);
timebase = m_stream->time_base;
}
else if (packet.packet.dts != int64_t(AV_NOPTS_VALUE))
{
pts = packet.packet.dts;
timebase = m_stream->time_base;
}
else
{
pts = 0;
timebase = m_context->time_base;
}
pts *= av_q2d(timebase);
const double synched_pts = m_clocks.videoSynchClock(m_frame.get(), av_q2d(timebase), pts);
const double frame_delay = m_clocks.videoRefreshSchedule(synched_pts);
publishFrame(frame_delay, m_clocks.audioDisabled());
}
}
while(m_paused && !m_exit)
{
microSleep(10000);
}
// Get the next packet
pts = 0;
if (packet.valid())
packet.clear();
bool is_empty = true;
packet = m_packets.timedPop(is_empty, 10);
if (! is_empty)
{
if (packet.type == FFmpegPacket::PACKET_DATA)
{
m_bytes_remaining = packet.packet.size;
m_packet_data = packet.packet.data;
}
else if (packet.type == FFmpegPacket::PACKET_FLUSH)
{
avcodec_flush_buffers(m_context);
}
}
}
}
static int64_t toFixedPoint(double in) {
return int64_t(0.5 + in * (int64_t(1) << 32));
}
bool ExportFFmpeg::EncodeAudioFrame(int16_t *pFrame, int frameSize)
{
int nBytesToWrite = 0;
uint8_t *pRawSamples = NULL;
int nAudioFrameSizeOut = default_frame_size * mEncAudioCodecCtx->channels * sizeof(int16_t);
int ret;
nBytesToWrite = frameSize;
pRawSamples = (uint8_t*)pFrame;
av_fifo_realloc2(mEncAudioFifo.get(), av_fifo_size(mEncAudioFifo.get()) + frameSize);
// Put the raw audio samples into the FIFO.
ret = av_fifo_generic_write(mEncAudioFifo.get(), pRawSamples, nBytesToWrite,NULL);
wxASSERT(ret == nBytesToWrite);
if (nAudioFrameSizeOut > mEncAudioFifoOutBufSiz) {
wxMessageBox(wxString::Format(_("FFmpeg : ERROR - nAudioFrameSizeOut too large.")),
_("FFmpeg Error"), wxOK|wxCENTER|wxICON_EXCLAMATION);
return false;
}
// Read raw audio samples out of the FIFO in nAudioFrameSizeOut byte-sized groups to encode.
while ((ret = av_fifo_size(mEncAudioFifo.get())) >= nAudioFrameSizeOut)
{
ret = av_fifo_generic_read(mEncAudioFifo.get(), mEncAudioFifoOutBuf.get(), nAudioFrameSizeOut, NULL);
AVPacketEx pkt;
int ret= encode_audio(mEncAudioCodecCtx.get(),
&pkt, // out
mEncAudioFifoOutBuf.get(), // in
default_frame_size);
if (ret < 0)
{
wxMessageBox(wxString::Format(_("FFmpeg : ERROR - Can't encode audio frame.")),
_("FFmpeg Error"), wxOK|wxCENTER|wxICON_EXCLAMATION);
return false;
}
if (ret == 0)
continue;
// Rescale from the codec time_base to the AVStream time_base.
if (pkt.pts != int64_t(AV_NOPTS_VALUE))
pkt.pts = av_rescale_q(pkt.pts, mEncAudioCodecCtx->time_base, mEncAudioStream->time_base);
if (pkt.dts != int64_t(AV_NOPTS_VALUE))
pkt.dts = av_rescale_q(pkt.dts, mEncAudioCodecCtx->time_base, mEncAudioStream->time_base);
//wxLogDebug(wxT("FFmpeg : (%d) Writing audio frame with PTS: %lld."), mEncAudioCodecCtx->frame_number, (long long) pkt.pts);
pkt.stream_index = mEncAudioStream->index;
// Write the encoded audio frame to the output file.
if ((ret = av_interleaved_write_frame(mEncFormatCtx.get(), &pkt)) < 0)
{
wxMessageBox(wxString::Format(_("FFmpeg : ERROR - Failed to write audio frame to file.")),
_("FFmpeg Error"), wxOK|wxCENTER|wxICON_EXCLAMATION);
return false;
}
}
return true;
}
TimeDuration
TimeDuration::Resolution()
{
NS_ABORT_IF_FALSE(gInitialized, "calling TimeDuration too early");
return TimeDuration::FromTicks(int64_t(sResolution));
}
void net_process() {
while (true) {
struct bitcoin_msg_header header;
if (read_all(sock, (char*)&header, sizeof(header)) != sizeof(header))
return disconnect("failed to read message header");
if (header.magic != BITCOIN_MAGIC)
return disconnect("invalid magic bytes");
struct timeval start_read;
gettimeofday(&start_read, NULL);
header.length = le32toh(header.length);
if (header.length > 5000000)
return disconnect("got message too large");
auto msg = std::make_shared<std::vector<unsigned char> > (sizeof(struct bitcoin_msg_header) + uint32_t(header.length));
if (read_all(sock, (char*)&(*msg)[sizeof(struct bitcoin_msg_header)], header.length) != int(header.length))
return disconnect("failed to read message");
unsigned char fullhash[32];
CSHA256 hash;
hash.Write(&(*msg)[sizeof(struct bitcoin_msg_header)], header.length).Finalize(fullhash);
hash.Reset().Write(fullhash, sizeof(fullhash)).Finalize(fullhash);
if (memcmp((char*)fullhash, header.checksum, sizeof(header.checksum)))
return disconnect("got invalid message checksum");
if (!strncmp(header.command, "version", strlen("version"))) {
if (connected != 0)
return disconnect("got invalid version");
connected = 1;
if (header.length < sizeof(struct bitcoin_version_start))
return disconnect("got short version");
struct bitcoin_version_start *their_version = (struct bitcoin_version_start*) &(*msg)[sizeof(struct bitcoin_msg_header)];
printf("%s Protocol version %u\n", host.c_str(), le32toh(their_version->protocol_version));
struct bitcoin_version_with_header version_msg;
version_msg.version.start.timestamp = htole64(time(0));
memcpy(((char*)&version_msg.version.end.user_agent) + 27, location, 7);
static_assert(BITCOIN_UA_LENGTH == 27 + 7 + 2 /* 27 + 7 + '/' + '\0' */, "BITCOIN_UA changed in header but file not updated");
prepare_message("version", (unsigned char*)&version_msg, sizeof(struct bitcoin_version));
if (send_all(sock, (char*)&version_msg, sizeof(struct bitcoin_version_with_header)) != sizeof(struct bitcoin_version_with_header))
return disconnect("failed to send version message");
struct bitcoin_msg_header verack_header;
prepare_message("verack", (unsigned char*)&verack_header, 0);
if (send_all(sock, (char*)&verack_header, sizeof(struct bitcoin_msg_header)) != sizeof(struct bitcoin_msg_header))
return disconnect("failed to send verack");
continue;
} else if (!strncmp(header.command, "verack", strlen("verack"))) {
if (connected != 1)
return disconnect("got invalid verack");
connected = 2;
send_mutex.unlock();
continue;
}
if (connected != 2)
return disconnect("got non-version, non-verack before version+verack");
if (!strncmp(header.command, "ping", strlen("ping"))) {
memcpy(&header.command, "pong", sizeof("pong"));
memcpy(&(*msg)[0], &header, sizeof(struct bitcoin_msg_header));
std::lock_guard<std::mutex> lock(send_mutex);
if (send_all(sock, (char*)&(*msg)[0], sizeof(struct bitcoin_msg_header) + header.length) != int64_t(sizeof(struct bitcoin_msg_header) + header.length))
return disconnect("failed to send pong");
continue;
} else if (!strncmp(header.command, "inv", strlen("inv"))) {
std::lock_guard<std::mutex> lock(send_mutex);
try {
std::set<std::vector<unsigned char> > setRequestBlocks;
std::set<std::vector<unsigned char> > setRequestTxn;
std::vector<unsigned char>::const_iterator it = msg->begin();
it += sizeof(struct bitcoin_msg_header);
uint64_t count = read_varint(it, msg->end());
if (count > 50000)
return disconnect("inv count > MAX_INV_SZ");
uint32_t MSG_TX = htole32(1);
uint32_t MSG_BLOCK = htole32(2);
for (uint64_t i = 0; i < count; i++) {
move_forward(it, 4 + 32, msg->end());
std::vector<unsigned char> hash(it-32, it);
const uint32_t type = (*(it-(1+32)) << 24) | (*(it-(2+32)) << 16) | (*(it-(3+32)) << 8) | *(it-(4+32));
if (type == MSG_TX) {
if (!txnAlreadySeen.insert(hash).second)
continue;
setRequestTxn.insert(hash);
} else if (type == MSG_BLOCK) {
if (!blocksAlreadySeen.insert(hash).second)
continue;
setRequestBlocks.insert(hash);
} else
return disconnect("unknown inv type");
}
if (setRequestBlocks.size()) {
std::vector<unsigned char> getdataMsg;
std::vector<unsigned char> invCount = varint(setRequestBlocks.size());
getdataMsg.reserve(sizeof(struct bitcoin_msg_header) + invCount.size() + setRequestBlocks.size()*36);
getdataMsg.insert(getdataMsg.end(), sizeof(struct bitcoin_msg_header), 0);
getdataMsg.insert(getdataMsg.end(), invCount.begin(), invCount.end());
for (auto& hash : setRequestBlocks) {
getdataMsg.insert(getdataMsg.end(), (unsigned char*)&MSG_BLOCK, ((unsigned char*)&MSG_BLOCK) + 4);
getdataMsg.insert(getdataMsg.end(), hash.begin(), hash.end());
}
prepare_message("getdata", (unsigned char*)&getdataMsg[0], invCount.size() + setRequestBlocks.size()*36);
if (send_all(sock, (char*)&getdataMsg[0], sizeof(struct bitcoin_msg_header) + invCount.size() + setRequestBlocks.size()*36) !=
int(sizeof(struct bitcoin_msg_header) + invCount.size() + setRequestBlocks.size()*36))
return disconnect("error sending getdata");
for (auto& hash : setRequestBlocks) {
struct timeval tv;
gettimeofday(&tv, NULL);
for (unsigned int i = 0; i < hash.size(); i++)
printf("%02x", hash[hash.size() - i - 1]);
printf(" requested from %s at %lu\n", host.c_str(), uint64_t(tv.tv_sec) * 1000 + uint64_t(tv.tv_usec) / 1000);
}
}
if (setRequestTxn.size()) {
std::vector<unsigned char> getdataMsg;
std::vector<unsigned char> invCount = varint(setRequestTxn.size());
getdataMsg.reserve(sizeof(struct bitcoin_msg_header) + invCount.size() + setRequestTxn.size()*36);
getdataMsg.insert(getdataMsg.end(), sizeof(struct bitcoin_msg_header), 0);
getdataMsg.insert(getdataMsg.end(), invCount.begin(), invCount.end());
for (const std::vector<unsigned char>& hash : setRequestTxn) {
getdataMsg.insert(getdataMsg.end(), (unsigned char*)&MSG_TX, ((unsigned char*)&MSG_TX) + 4);
getdataMsg.insert(getdataMsg.end(), hash.begin(), hash.end());
}
prepare_message("getdata", (unsigned char*)&getdataMsg[0], invCount.size() + setRequestTxn.size()*36);
if (send_all(sock, (char*)&getdataMsg[0], sizeof(struct bitcoin_msg_header) + invCount.size() + setRequestTxn.size()*36) !=
int(sizeof(struct bitcoin_msg_header) + invCount.size() + setRequestTxn.size()*36))
return disconnect("error sending getdata");
}
} catch (read_exception) {
return disconnect("failed to process inv");
}
continue;
}
memcpy(&(*msg)[0], &header, sizeof(struct bitcoin_msg_header));
if (!strncmp(header.command, "block", strlen("block"))) {
provide_block(this, msg, start_read);
} else if (!strncmp(header.command, "tx", strlen("tx"))) {
provide_transaction(this, msg);
}
}
}
nsresult
CacheFileMetadata::ReadMetadata(CacheFileMetadataListener *aListener)
{
LOG(("CacheFileMetadata::ReadMetadata() [this=%p, listener=%p]", this, aListener));
MOZ_ASSERT(!mListener);
MOZ_ASSERT(!mHashArray);
MOZ_ASSERT(!mBuf);
MOZ_ASSERT(!mWriteBuf);
nsresult rv;
int64_t size = mHandle->FileSize();
MOZ_ASSERT(size != -1);
if (size == 0) {
// this is a new entry
LOG(("CacheFileMetadata::ReadMetadata() - Filesize == 0, creating empty "
"metadata. [this=%p]", this));
InitEmptyMetadata();
aListener->OnMetadataRead(NS_OK);
return NS_OK;
}
if (size < int64_t(sizeof(CacheFileMetadataHeader) + 2*sizeof(uint32_t))) {
// there must be at least checksum, header and offset
LOG(("CacheFileMetadata::ReadMetadata() - File is corrupted, creating "
"empty metadata. [this=%p, filesize=%lld]", this, size));
InitEmptyMetadata();
aListener->OnMetadataRead(NS_OK);
return NS_OK;
}
// Set offset so that we read at least kMinMetadataRead if the file is big
// enough.
int64_t offset;
if (size < kMinMetadataRead) {
offset = 0;
} else {
offset = size - kMinMetadataRead;
}
// round offset to kAlignSize blocks
offset = (offset / kAlignSize) * kAlignSize;
mBufSize = size - offset;
mBuf = static_cast<char *>(moz_xmalloc(mBufSize));
DoMemoryReport(MemoryUsage());
LOG(("CacheFileMetadata::ReadMetadata() - Reading metadata from disk, trying "
"offset=%lld, filesize=%lld [this=%p]", offset, size, this));
mReadStart = mozilla::TimeStamp::Now();
mListener = aListener;
rv = CacheFileIOManager::Read(mHandle, offset, mBuf, mBufSize, this);
if (NS_FAILED(rv)) {
LOG(("CacheFileMetadata::ReadMetadata() - CacheFileIOManager::Read() failed"
" synchronously, creating empty metadata. [this=%p, rv=0x%08x]",
this, rv));
mListener = nullptr;
InitEmptyMetadata();
aListener->OnMetadataRead(NS_OK);
return NS_OK;
}
return NS_OK;
}
int64_t
PRMJ_Now(void)
{
static int nCalls = 0;
long double lowresTime, highresTimerValue;
FILETIME ft;
LARGE_INTEGER now;
bool calibrated = false;
bool needsCalibration = false;
int64_t returnedTime;
long double cachedOffset = 0.0;
/* For non threadsafe platforms, NowInit is not necessary */
#ifdef JS_THREADSAFE
PR_CallOnce(&calibrationOnce, NowInit);
#endif
do {
if (!calibration.calibrated || needsCalibration) {
MUTEX_LOCK(&calibration.calibration_lock);
MUTEX_LOCK(&calibration.data_lock);
/* Recalibrate only if no one else did before us */
if(calibration.offset == cachedOffset) {
/* Since calibration can take a while, make any other
threads immediately wait */
MUTEX_SETSPINCOUNT(&calibration.data_lock, 0);
NowCalibrate();
calibrated = true;
/* Restore spin count */
MUTEX_SETSPINCOUNT(&calibration.data_lock, DATALOCK_SPINCOUNT);
}
MUTEX_UNLOCK(&calibration.data_lock);
MUTEX_UNLOCK(&calibration.calibration_lock);
}
/* Calculate a low resolution time */
GetSystemTimeAsFileTime(&ft);
lowresTime = 0.1*(long double)(FILETIME2INT64(ft) - win2un);
if (calibration.freq > 0.0) {
long double highresTime, diff;
DWORD timeAdjustment, timeIncrement;
BOOL timeAdjustmentDisabled;
/* Default to 15.625 ms if the syscall fails */
long double skewThreshold = 15625.25;
/* Grab high resolution time */
QueryPerformanceCounter(&now);
highresTimerValue = (long double)now.QuadPart;
MUTEX_LOCK(&calibration.data_lock);
highresTime = calibration.offset + PRMJ_USEC_PER_SEC*
(highresTimerValue-calibration.timer_offset)/calibration.freq;
cachedOffset = calibration.offset;
/* On some dual processor/core systems, we might get an earlier time
so we cache the last time that we returned */
calibration.last = js::Max(calibration.last, int64_t(highresTime));
returnedTime = calibration.last;
MUTEX_UNLOCK(&calibration.data_lock);
/* Rather than assume the NT kernel ticks every 15.6ms, ask it */
if (GetSystemTimeAdjustment(&timeAdjustment,
&timeIncrement,
&timeAdjustmentDisabled)) {
if (timeAdjustmentDisabled) {
/* timeAdjustment is in units of 100ns */
skewThreshold = timeAdjustment/10.0;
} else {
/* timeIncrement is in units of 100ns */
skewThreshold = timeIncrement/10.0;
}
}
/* Check for clock skew */
diff = lowresTime - highresTime;
/* For some reason that I have not determined, the skew can be
up to twice a kernel tick. This does not seem to happen by
itself, but I have only seen it triggered by another program
doing some kind of file I/O. The symptoms are a negative diff
followed by an equally large positive diff. */
if (mozilla::Abs(diff) > 2 * skewThreshold) {
/*fprintf(stderr,"Clock skew detected (diff = %f)!\n", diff);*/
if (calibrated) {
/* If we already calibrated once this instance, and the
clock is still skewed, then either the processor(s) are
wildly changing clockspeed or the system is so busy that
we get switched out for long periods of time. In either
case, it would be infeasible to make use of high
resolution results for anything, so let's resort to old
behavior for this call. It's possible that in the
future, the user will want the high resolution timer, so
we don't disable it entirely. */
returnedTime = int64_t(lowresTime);
needsCalibration = false;
} else {
/* It is possible that when we recalibrate, we will return a
value less than what we have returned before; this is
unavoidable. We cannot tell the different between a
faulty QueryPerformanceCounter implementation and user
changes to the operating system time. Since we must
respect user changes to the operating system time, we
cannot maintain the invariant that Date.now() never
decreases; the old implementation has this behavior as
well. */
needsCalibration = true;
}
} else {
/* No detectable clock skew */
returnedTime = int64_t(highresTime);
needsCalibration = false;
}
} else {
/* No high resolution timer is available, so fall back */
returnedTime = int64_t(lowresTime);
}
} while (needsCalibration);
return returnedTime;
}
int64_t GDAPI godot_variant_as_int(const godot_variant *p_self) {
const Variant *self = (const Variant *)p_self;
return self->operator int64_t();
}
//TODO: seek by byte
void AVDemuxer::seek(qreal q)
{
if ((!a_codec_context && !v_codec_context) || !format_context) {
qWarning("can not seek. context not ready: %p %p %p", a_codec_context, v_codec_context, format_context);
return;
}
if (seek_timer.isValid()) {
//why sometimes seek_timer.elapsed() < 0
if (!seek_timer.hasExpired(kSeekInterval)) {
qDebug("seek too frequent. ignore");
return;
}
seek_timer.restart();
} else {
seek_timer.start();
}
QMutexLocker lock(&mutex);
Q_UNUSED(lock);
q = qMax<qreal>(0.0, q);
if (q >= 1.0) {
qWarning("Invalid seek position %f/1.0", q);
return;
}
#if 0
//t: unit is s
qreal t = q;// * (double)format_context->duration; //
int ret = av_seek_frame(format_context, -1, (int64_t)(t*AV_TIME_BASE), t > pkt->pts ? 0 : AVSEEK_FLAG_BACKWARD);
qDebug("[AVDemuxer] seek to %f %f %lld / %lld", q, pkt->pts, (int64_t)(t*AV_TIME_BASE), duration());
#else
//t: unit is us (10^-6 s, AV_TIME_BASE)
int64_t t = int64_t(q*duration());///AV_TIME_BASE;
//TODO: pkt->pts may be 0, compute manually. Check wether exceed the length
if (t >= duration()) {
qWarning("Invailid seek position: %lld/%lld", t, duration());
return;
}
bool backward = t <= (int64_t)(pkt->pts*AV_TIME_BASE);
qDebug("[AVDemuxer] seek to %f %f %lld / %lld backward=%lld", q, pkt->pts, t, duration(), backward);
//AVSEEK_FLAG_BACKWARD has no effect? because we know the timestamp
int seek_flag = (backward ? 0 : AVSEEK_FLAG_BACKWARD); //AVSEEK_FLAG_ANY
int ret = av_seek_frame(format_context, -1, t, seek_flag);
#endif
if (ret < 0) {
qWarning("[AVDemuxer] seek error: %s", av_err2str(ret));
return;
}
//replay
if (q == 0) {
qDebug("************seek to 0. started = false");
started_ = false;
v_codec_context->frame_number = 0; //TODO: why frame_number not changed after seek?
}
if (master_clock) {
master_clock->updateValue(qreal(t)/qreal(AV_TIME_BASE));
master_clock->updateExternalClock(t/1000LL); //in msec. ignore usec part using t/1000
}
//calc pts
//use AVThread::flush() when reaching end
//if (videoCodecContext())
// avcodec_flush_buffers(videoCodecContext());
//if (audioCodecContext())
// avcodec_flush_buffers(audioCodecContext());
}
void ViewEqualizer::Listener::notifyLoadData(Channel* channel,
const uint32_t frameNumber,
const Statistics& statistics,
const Viewport& /*region*/)
{
Load& load = _getLoad(frameNumber);
if (load == Load::NONE)
return;
LBASSERT(_taskIDs.find(channel) != _taskIDs.end());
const uint32_t taskID = _taskIDs[channel];
// gather relevant load data
int64_t startTime = std::numeric_limits<int64_t>::max();
int64_t endTime = 0;
bool loadSet = false;
int64_t transmitTime = 0;
for (size_t i = 0; i < statistics.size() && !loadSet; ++i)
{
const Statistic& data = statistics[i];
if (data.task != taskID) // data from another compound
continue;
switch (data.type)
{
case Statistic::CHANNEL_CLEAR:
case Statistic::CHANNEL_DRAW:
case Statistic::CHANNEL_READBACK:
startTime = LB_MIN(startTime, data.startTime);
endTime = LB_MAX(endTime, data.endTime);
break;
case Statistic::CHANNEL_ASYNC_READBACK:
case Statistic::CHANNEL_FRAME_TRANSMIT:
transmitTime += data.startTime - data.endTime;
break;
case Statistic::CHANNEL_FRAME_WAIT_SENDTOKEN:
transmitTime -= data.endTime - data.startTime;
break;
// assemble blocks on input frames, stop using subsequent data
case Statistic::CHANNEL_ASSEMBLE:
loadSet = true;
break;
default:
break;
}
}
if (startTime == std::numeric_limits<int64_t>::max())
return;
LBASSERTINFO(load.missing > 0, load << " for " << channel->getName() << " "
<< channel->getSerial());
const int64_t time = LB_MAX(endTime - startTime, transmitTime);
load.time += time;
--load.missing;
if (load.missing == 0)
{
const float rTime = float(load.time) / float(load.nResources);
load.time = int64_t(rTime * sqrtf(float(load.nResources)));
}
LBLOG(LOG_LB1) << "Task " << taskID << ", added time " << time << " to "
<< load << " from " << channel->getName() << " "
<< channel->getSerial() << std::endl;
}
/* Decode data from the current packet. Return -1 on error, 0 if the packet is finished,
* and 1 if we have a frame (we may have more data in the packet). */
int FFMpeg_Helper::DecodePacket()
{
if( eof == 0 && current_packet_offset == -1 )
return 0; /* no packet */
while( eof == 1 || (eof == 0 && current_packet_offset < pkt.size) )
{
if ( GetNextTimestamp )
{
if (pkt.dts != int64_t(AV_NOPTS_VALUE))
pts = (float)pkt.dts / AV_TIME_BASE;
else
pts = -1;
GetNextTimestamp = false;
}
/* If we have no data on the first frame, just return EOF; passing an empty packet
* to avcodec_decode_video in this case is crashing it. However, passing an empty
* packet is normal with B-frames, to flush. This may be unnecessary in newer
* versions of avcodec, but I'm waiting until a new stable release to upgrade. */
if( pkt.size == 0 && FrameNumber == -1 )
return 0; /* eof */
int got_frame;
CHECKPOINT;
/* Hack: we need to send size = 0 to flush frames at the end, but we have
* to give it a buffer to read from since it tries to read anyway. */
static uint8_t dummy[FF_INPUT_BUFFER_PADDING_SIZE] = { 0 };
int len = avcodec::avcodec_decode_video(
&m_stream->codec,
&frame, &got_frame,
pkt.size? pkt.data:dummy, pkt.size );
CHECKPOINT;
if (len < 0)
{
LOG->Warn("avcodec_decode_video: %i", len);
return -1; // XXX
}
current_packet_offset += len;
if (!got_frame)
{
if( eof == 1 )
eof = 2;
continue;
}
GetNextTimestamp = true;
if (pts != -1)
{
CurrentTimestamp = pts;
}
else
{
/* If the timestamp is zero, this frame is to be played at the
* time of the last frame plus the length of the last frame. */
CurrentTimestamp += LastFrameDelay;
}
/* Length of this frame: */
LastFrameDelay = (float)m_stream->codec.frame_rate_base / m_stream->codec.frame_rate;
LastFrameDelay += frame.repeat_pict * (LastFrameDelay * 0.5f);
return 1;
}
return 0; /* packet done */
}
namespace random {
typedef random::subtract_with_carry<int64_t, (int64_t(1)<<48), 10, 24, 0> ranlux64_base;
}
NS_IMETHODIMP
nsCRLManager::ImportCrl (uint8_t *aData, uint32_t aLength, nsIURI * aURI, uint32_t aType, bool doSilentDownload, const PRUnichar* crlKey)
{
if (!NS_IsMainThread()) {
NS_ERROR("nsCRLManager::ImportCrl called off the main thread");
return NS_ERROR_NOT_SAME_THREAD;
}
nsNSSShutDownPreventionLock locker;
nsresult rv;
PLArenaPool *arena = nullptr;
CERTCertificate *caCert;
SECItem derName = { siBuffer, nullptr, 0 };
SECItem derCrl;
CERTSignedData sd;
SECStatus sec_rv;
CERTSignedCrl *crl;
nsAutoCString url;
nsCOMPtr<nsICRLInfo> crlData;
bool importSuccessful;
int32_t errorCode;
nsString errorMessage;
nsCOMPtr<nsINSSComponent> nssComponent(do_GetService(kNSSComponentCID, &rv));
if (NS_FAILED(rv)) return rv;
aURI->GetSpec(url);
arena = PORT_NewArena(DER_DEFAULT_CHUNKSIZE);
if (!arena) {
goto loser;
}
memset(&sd, 0, sizeof(sd));
derCrl.data = (unsigned char*)aData;
derCrl.len = aLength;
sec_rv = CERT_KeyFromDERCrl(arena, &derCrl, &derName);
if (sec_rv != SECSuccess) {
goto loser;
}
caCert = CERT_FindCertByName(CERT_GetDefaultCertDB(), &derName);
if (!caCert) {
if (aType == SEC_KRL_TYPE){
goto loser;
}
} else {
sec_rv = SEC_ASN1DecodeItem(arena,
&sd, SEC_ASN1_GET(CERT_SignedDataTemplate),
&derCrl);
if (sec_rv != SECSuccess) {
goto loser;
}
sec_rv = CERT_VerifySignedData(&sd, caCert, PR_Now(),
nullptr);
if (sec_rv != SECSuccess) {
goto loser;
}
}
crl = SEC_NewCrl(CERT_GetDefaultCertDB(), const_cast<char*>(url.get()), &derCrl,
aType);
if (!crl) {
goto loser;
}
crlData = new nsCRLInfo(crl);
SSL_ClearSessionCache();
SEC_DestroyCrl(crl);
importSuccessful = true;
goto done;
loser:
importSuccessful = false;
errorCode = PR_GetError();
switch (errorCode) {
case SEC_ERROR_CRL_EXPIRED:
nssComponent->GetPIPNSSBundleString("CrlImportFailureExpired", errorMessage);
break;
case SEC_ERROR_CRL_BAD_SIGNATURE:
nssComponent->GetPIPNSSBundleString("CrlImportFailureBadSignature", errorMessage);
break;
case SEC_ERROR_CRL_INVALID:
nssComponent->GetPIPNSSBundleString("CrlImportFailureInvalid", errorMessage);
break;
case SEC_ERROR_OLD_CRL:
nssComponent->GetPIPNSSBundleString("CrlImportFailureOld", errorMessage);
break;
case SEC_ERROR_CRL_NOT_YET_VALID:
nssComponent->GetPIPNSSBundleString("CrlImportFailureNotYetValid", errorMessage);
break;
default:
nssComponent->GetPIPNSSBundleString("CrlImportFailureReasonUnknown", errorMessage);
errorMessage.AppendInt(errorCode,16);
break;
}
done:
if(!doSilentDownload){
if (!importSuccessful){
nsString message;
nsString temp;
nssComponent->GetPIPNSSBundleString("CrlImportFailure1x", message);
message.Append(NS_LITERAL_STRING("\n").get());
message.Append(errorMessage);
nssComponent->GetPIPNSSBundleString("CrlImportFailure2", temp);
message.Append(NS_LITERAL_STRING("\n").get());
message.Append(temp);
nsNSSComponent::ShowAlertWithConstructedString(message);
} else {
nsCOMPtr<nsICertificateDialogs> certDialogs;
// Not being able to display the success dialog should not
// be a fatal error, so don't return a failure code.
{
nsPSMUITracker tracker;
if (tracker.isUIForbidden()) {
rv = NS_ERROR_NOT_AVAILABLE;
}
else {
rv = ::getNSSDialogs(getter_AddRefs(certDialogs),
NS_GET_IID(nsICertificateDialogs), NS_CERTIFICATEDIALOGS_CONTRACTID);
}
}
if (NS_SUCCEEDED(rv)) {
nsCOMPtr<nsIInterfaceRequestor> cxt = new PipUIContext();
certDialogs->CrlImportStatusDialog(cxt, crlData);
}
}
} else {
if (!crlKey) {
return NS_ERROR_FAILURE;
}
nsCOMPtr<nsIPrefService> prefSvc = do_GetService(NS_PREFSERVICE_CONTRACTID,&rv);
nsCOMPtr<nsIPrefBranch> pref = do_GetService(NS_PREFSERVICE_CONTRACTID,&rv);
if (NS_FAILED(rv)){
return rv;
}
nsAutoCString updateErrCntPrefStr(CRL_AUTOUPDATE_ERRCNT_PREF);
LossyAppendUTF16toASCII(crlKey, updateErrCntPrefStr);
if(importSuccessful){
PRUnichar *updateTime;
nsAutoCString updateTimeStr;
nsCString updateURL;
int32_t timingTypePref;
double dayCnt;
char *dayCntStr;
nsAutoCString updateTypePrefStr(CRL_AUTOUPDATE_TIMIINGTYPE_PREF);
nsAutoCString updateTimePrefStr(CRL_AUTOUPDATE_TIME_PREF);
nsAutoCString updateUrlPrefStr(CRL_AUTOUPDATE_URL_PREF);
nsAutoCString updateDayCntPrefStr(CRL_AUTOUPDATE_DAYCNT_PREF);
nsAutoCString updateFreqCntPrefStr(CRL_AUTOUPDATE_FREQCNT_PREF);
LossyAppendUTF16toASCII(crlKey, updateTypePrefStr);
LossyAppendUTF16toASCII(crlKey, updateTimePrefStr);
LossyAppendUTF16toASCII(crlKey, updateUrlPrefStr);
LossyAppendUTF16toASCII(crlKey, updateDayCntPrefStr);
LossyAppendUTF16toASCII(crlKey, updateFreqCntPrefStr);
pref->GetIntPref(updateTypePrefStr.get(),&timingTypePref);
//Compute and update the next download instant
if(timingTypePref == TYPE_AUTOUPDATE_TIME_BASED){
pref->GetCharPref(updateDayCntPrefStr.get(),&dayCntStr);
}else{
pref->GetCharPref(updateFreqCntPrefStr.get(),&dayCntStr);
}
dayCnt = atof(dayCntStr);
nsMemory::Free(dayCntStr);
bool toBeRescheduled = false;
if(NS_SUCCEEDED(ComputeNextAutoUpdateTime(crlData, timingTypePref, dayCnt, &updateTime))){
updateTimeStr.AssignWithConversion(updateTime);
pref->SetCharPref(updateTimePrefStr.get(),updateTimeStr.get());
//Now, check if this update time is already in the past. This would
//imply we have downloaded the same crl, or there is something wrong
//with the next update date. We will not reschedule this crl in this
//session anymore - or else, we land into a loop. It would anyway be
//imported once the browser is restarted.
if(int64_t(updateTime) > int64_t(PR_Now())){
toBeRescheduled = true;
}
nsMemory::Free(updateTime);
}
//Update the url to download from, next time
crlData->GetLastFetchURL(updateURL);
pref->SetCharPref(updateUrlPrefStr.get(),updateURL.get());
pref->SetIntPref(updateErrCntPrefStr.get(),0);
if (toBeRescheduled) {
nsAutoString hashKey(crlKey);
nssComponent->RemoveCrlFromList(hashKey);
nssComponent->DefineNextTimer();
}
} else{
int32_t errCnt;
nsAutoCString errMsg;
nsAutoCString updateErrDetailPrefStr(CRL_AUTOUPDATE_ERRDETAIL_PREF);
LossyAppendUTF16toASCII(crlKey, updateErrDetailPrefStr);
errMsg.AssignWithConversion(errorMessage.get());
rv = pref->GetIntPref(updateErrCntPrefStr.get(),&errCnt);
if(NS_FAILED(rv))
errCnt = 0;
pref->SetIntPref(updateErrCntPrefStr.get(),errCnt+1);
pref->SetCharPref(updateErrDetailPrefStr.get(),errMsg.get());
}
prefSvc->SavePrefFile(nullptr);
}
return rv;
}
NS_IMETHODIMP
nsCRLManager::ComputeNextAutoUpdateTime(nsICRLInfo *info,
uint32_t autoUpdateType, double dayCnt, PRUnichar **nextAutoUpdate)
{
if (!info)
return NS_ERROR_FAILURE;
NS_ENSURE_ARG_POINTER(nextAutoUpdate);
PRTime microsecInDayCnt;
PRTime now = PR_Now();
PRTime tempTime;
int64_t diff = 0;
int64_t secsInDay = 86400UL;
int64_t temp;
int64_t cycleCnt = 0;
double tmpData = double(secsInDay);
tmpData *= dayCnt;
microsecInDayCnt = int64_t(tmpData) * PR_USEC_PER_SEC;
PRTime lastUpdate;
PRTime nextUpdate;
nsresult rv;
rv = info->GetLastUpdate(&lastUpdate);
if (NS_FAILED(rv))
return rv;
rv = info->GetNextUpdate(&nextUpdate);
if (NS_FAILED(rv))
return rv;
switch (autoUpdateType) {
case TYPE_AUTOUPDATE_FREQ_BASED:
diff = now - lastUpdate; //diff is the no of micro sec between now and last update
cycleCnt = diff / microsecInDayCnt; //temp is the number of full cycles from lst update
temp = diff % microsecInDayCnt;
if(temp != 0) {
++cycleCnt; //no of complete cycles till next autoupdate instant
}
temp = cycleCnt * microsecInDayCnt; //micro secs from last update
tempTime = lastUpdate + temp;
break;
case TYPE_AUTOUPDATE_TIME_BASED:
tempTime = nextUpdate - microsecInDayCnt;
break;
default:
return NS_ERROR_NOT_IMPLEMENTED;
}
//Now, a basic constraing is that the next auto update date can never be after
//next update, if one is defined
if(nextUpdate > 0) {
if(tempTime > nextUpdate) {
tempTime = nextUpdate;
}
}
// Return value as string; no pref type for Int64/PRTime
char *tempTimeStr = PR_smprintf("%lli", tempTime);
*nextAutoUpdate = ToNewUnicode(nsDependentCString(tempTimeStr));
PR_smprintf_free(tempTimeStr);
return NS_OK;
}
int64_t MemTrace::TimerGetSystemCounter()
{
struct timeval tv;
gettimeofday(&tv, nullptr);
return int64_t(tv.tv_sec) * 1000000 + tv.tv_usec;
}
config_data &config_data::operator()(const std::string &name, int value)
{
return (*this)(name, variant(int64_t(value)));
}
// Prescaler value relative to the current value.
int64_t GPTimer::valueof(sc_core::sc_time t, int64_t offset, sc_core::sc_time cycletime) const {
return static_cast<int64_t>(lastvalue - int64_t(sc_core::sc_time(t - lasttime - (1 + offset) * cycletime) / cycletime) + 1);
}
void GDMonoField::set_value_from_variant(MonoObject *p_object, const Variant &p_value) {
#define SET_FROM_STRUCT(m_type) \
{ \
GDMonoMarshal::M_##m_type from = MARSHALLED_OUT(m_type, p_value.operator ::m_type()); \
mono_field_set_value(p_object, mono_field, &from); \
}
#define SET_FROM_ARRAY(m_type) \
{ \
MonoArray *managed = GDMonoMarshal::m_type##_to_mono_array(p_value.operator ::m_type()); \
mono_field_set_value(p_object, mono_field, managed); \
}
switch (type.type_encoding) {
case MONO_TYPE_BOOLEAN: {
MonoBoolean val = p_value.operator bool();
mono_field_set_value(p_object, mono_field, &val);
} break;
case MONO_TYPE_CHAR: {
int16_t val = p_value.operator unsigned short();
mono_field_set_value(p_object, mono_field, &val);
} break;
case MONO_TYPE_I1: {
int8_t val = p_value.operator signed char();
mono_field_set_value(p_object, mono_field, &val);
} break;
case MONO_TYPE_I2: {
int16_t val = p_value.operator signed short();
mono_field_set_value(p_object, mono_field, &val);
} break;
case MONO_TYPE_I4: {
int32_t val = p_value.operator signed int();
mono_field_set_value(p_object, mono_field, &val);
} break;
case MONO_TYPE_I8: {
int64_t val = p_value.operator int64_t();
mono_field_set_value(p_object, mono_field, &val);
} break;
case MONO_TYPE_U1: {
uint8_t val = p_value.operator unsigned char();
mono_field_set_value(p_object, mono_field, &val);
} break;
case MONO_TYPE_U2: {
uint16_t val = p_value.operator unsigned short();
mono_field_set_value(p_object, mono_field, &val);
} break;
case MONO_TYPE_U4: {
uint32_t val = p_value.operator unsigned int();
mono_field_set_value(p_object, mono_field, &val);
} break;
case MONO_TYPE_U8: {
uint64_t val = p_value.operator uint64_t();
mono_field_set_value(p_object, mono_field, &val);
} break;
case MONO_TYPE_R4: {
float val = p_value.operator float();
mono_field_set_value(p_object, mono_field, &val);
} break;
case MONO_TYPE_R8: {
double val = p_value.operator double();
mono_field_set_value(p_object, mono_field, &val);
} break;
case MONO_TYPE_STRING: {
MonoString *mono_string = GDMonoMarshal::mono_string_from_godot(p_value);
mono_field_set_value(p_object, mono_field, mono_string);
} break;
case MONO_TYPE_VALUETYPE: {
GDMonoClass *tclass = type.type_class;
if (tclass == CACHED_CLASS(Vector2)) {
SET_FROM_STRUCT(Vector2);
break;
}
if (tclass == CACHED_CLASS(Rect2)) {
SET_FROM_STRUCT(Rect2);
break;
}
if (tclass == CACHED_CLASS(Transform2D)) {
SET_FROM_STRUCT(Transform2D);
break;
}
if (tclass == CACHED_CLASS(Vector3)) {
SET_FROM_STRUCT(Vector3);
break;
}
if (tclass == CACHED_CLASS(Basis)) {
SET_FROM_STRUCT(Basis);
break;
}
if (tclass == CACHED_CLASS(Quat)) {
SET_FROM_STRUCT(Quat);
break;
}
if (tclass == CACHED_CLASS(Transform)) {
SET_FROM_STRUCT(Transform);
break;
}
if (tclass == CACHED_CLASS(AABB)) {
SET_FROM_STRUCT(AABB);
break;
}
if (tclass == CACHED_CLASS(Color)) {
SET_FROM_STRUCT(Color);
break;
}
if (tclass == CACHED_CLASS(Plane)) {
SET_FROM_STRUCT(Plane);
break;
}
if (mono_class_is_enum(tclass->get_mono_ptr())) {
MonoType *enum_basetype = mono_class_enum_basetype(tclass->get_mono_ptr());
switch (mono_type_get_type(enum_basetype)) {
case MONO_TYPE_BOOLEAN: {
MonoBoolean val = p_value.operator bool();
mono_field_set_value(p_object, mono_field, &val);
break;
}
case MONO_TYPE_CHAR: {
uint16_t val = p_value.operator unsigned short();
mono_field_set_value(p_object, mono_field, &val);
break;
}
case MONO_TYPE_I1: {
int8_t val = p_value.operator signed char();
mono_field_set_value(p_object, mono_field, &val);
break;
}
case MONO_TYPE_I2: {
int16_t val = p_value.operator signed short();
mono_field_set_value(p_object, mono_field, &val);
break;
}
case MONO_TYPE_I4: {
int32_t val = p_value.operator signed int();
mono_field_set_value(p_object, mono_field, &val);
break;
}
case MONO_TYPE_I8: {
int64_t val = p_value.operator int64_t();
mono_field_set_value(p_object, mono_field, &val);
break;
}
case MONO_TYPE_U1: {
uint8_t val = p_value.operator unsigned char();
mono_field_set_value(p_object, mono_field, &val);
break;
}
case MONO_TYPE_U2: {
uint16_t val = p_value.operator unsigned short();
mono_field_set_value(p_object, mono_field, &val);
break;
}
case MONO_TYPE_U4: {
uint32_t val = p_value.operator unsigned int();
mono_field_set_value(p_object, mono_field, &val);
break;
}
case MONO_TYPE_U8: {
uint64_t val = p_value.operator uint64_t();
mono_field_set_value(p_object, mono_field, &val);
break;
}
default: {
ERR_EXPLAIN(String() + "Attempted to convert Variant to a managed enum value of unmarshallable base type.");
ERR_FAIL();
}
}
break;
}
ERR_EXPLAIN(String() + "Attempted to set the value of a field of unmarshallable type: " + tclass->get_name());
ERR_FAIL();
} break;
case MONO_TYPE_ARRAY:
case MONO_TYPE_SZARRAY: {
MonoArrayType *array_type = mono_type_get_array_type(type.type_class->get_mono_type());
if (array_type->eklass == CACHED_CLASS_RAW(MonoObject)) {
SET_FROM_ARRAY(Array);
break;
}
if (array_type->eklass == CACHED_CLASS_RAW(uint8_t)) {
SET_FROM_ARRAY(PoolByteArray);
break;
}
if (array_type->eklass == CACHED_CLASS_RAW(int32_t)) {
SET_FROM_ARRAY(PoolIntArray);
break;
}
if (array_type->eklass == REAL_T_MONOCLASS) {
SET_FROM_ARRAY(PoolRealArray);
break;
}
if (array_type->eklass == CACHED_CLASS_RAW(String)) {
SET_FROM_ARRAY(PoolStringArray);
break;
}
if (array_type->eklass == CACHED_CLASS_RAW(Vector2)) {
SET_FROM_ARRAY(PoolVector2Array);
break;
}
if (array_type->eklass == CACHED_CLASS_RAW(Vector3)) {
SET_FROM_ARRAY(PoolVector3Array);
break;
}
if (array_type->eklass == CACHED_CLASS_RAW(Color)) {
SET_FROM_ARRAY(PoolColorArray);
break;
}
ERR_EXPLAIN(String() + "Attempted to convert Variant to a managed array of unmarshallable element type.");
ERR_FAIL();
} break;
case MONO_TYPE_CLASS: {
GDMonoClass *type_class = type.type_class;
// GodotObject
if (CACHED_CLASS(GodotObject)->is_assignable_from(type_class)) {
MonoObject *managed = GDMonoUtils::unmanaged_get_managed(p_value.operator Object *());
mono_field_set_value(p_object, mono_field, managed);
break;
}
if (CACHED_CLASS(NodePath) == type_class) {
MonoObject *managed = GDMonoUtils::create_managed_from(p_value.operator NodePath());
mono_field_set_value(p_object, mono_field, managed);
break;
}
if (CACHED_CLASS(RID) == type_class) {
MonoObject *managed = GDMonoUtils::create_managed_from(p_value.operator RID());
mono_field_set_value(p_object, mono_field, managed);
break;
}
if (CACHED_CLASS(Dictionary) == type_class) {
MonoObject *managed = GDMonoUtils::create_managed_from(p_value.operator Dictionary(), CACHED_CLASS(Dictionary));
mono_field_set_value(p_object, mono_field, managed);
break;
}
if (CACHED_CLASS(Array) == type_class) {
MonoObject *managed = GDMonoUtils::create_managed_from(p_value.operator Array(), CACHED_CLASS(Array));
mono_field_set_value(p_object, mono_field, managed);
break;
}
if (type_class->implements_interface(CACHED_CLASS(System_Collections_IDictionary))) {
MonoObject *managed = GDMonoUtils::create_managed_from(p_value.operator Dictionary(), CACHED_CLASS(Dictionary));
mono_field_set_value(p_object, mono_field, managed);
break;
}
if (type_class->implements_interface(CACHED_CLASS(System_Collections_IEnumerable))) {
MonoObject *managed = GDMonoUtils::create_managed_from(p_value.operator Array(), CACHED_CLASS(Array));
mono_field_set_value(p_object, mono_field, managed);
break;
}
ERR_EXPLAIN(String() + "Attempted to set the value of a field of unmarshallable type: " + type_class->get_name());
ERR_FAIL();
} break;
case MONO_TYPE_OBJECT: {
// Variant
switch (p_value.get_type()) {
case Variant::BOOL: {
MonoBoolean val = p_value.operator bool();
mono_field_set_value(p_object, mono_field, &val);
} break;
case Variant::INT: {
int32_t val = p_value.operator signed int();
mono_field_set_value(p_object, mono_field, &val);
} break;
case Variant::REAL: {
#ifdef REAL_T_IS_DOUBLE
double val = p_value.operator double();
mono_field_set_value(p_object, mono_field, &val);
#else
float val = p_value.operator float();
mono_field_set_value(p_object, mono_field, &val);
#endif
} break;
case Variant::STRING: {
MonoString *mono_string = GDMonoMarshal::mono_string_from_godot(p_value);
mono_field_set_value(p_object, mono_field, mono_string);
} break;
case Variant::VECTOR2: {
SET_FROM_STRUCT(Vector2);
} break;
case Variant::RECT2: {
SET_FROM_STRUCT(Rect2);
} break;
case Variant::VECTOR3: {
SET_FROM_STRUCT(Vector3);
} break;
case Variant::TRANSFORM2D: {
SET_FROM_STRUCT(Transform2D);
} break;
case Variant::PLANE: {
SET_FROM_STRUCT(Plane);
} break;
case Variant::QUAT: {
SET_FROM_STRUCT(Quat);
} break;
case Variant::AABB: {
SET_FROM_STRUCT(AABB);
} break;
case Variant::BASIS: {
SET_FROM_STRUCT(Basis);
} break;
case Variant::TRANSFORM: {
SET_FROM_STRUCT(Transform);
} break;
case Variant::COLOR: {
SET_FROM_STRUCT(Color);
} break;
case Variant::NODE_PATH: {
MonoObject *managed = GDMonoUtils::create_managed_from(p_value.operator NodePath());
mono_field_set_value(p_object, mono_field, managed);
} break;
case Variant::_RID: {
MonoObject *managed = GDMonoUtils::create_managed_from(p_value.operator RID());
mono_field_set_value(p_object, mono_field, managed);
} break;
case Variant::OBJECT: {
MonoObject *managed = GDMonoUtils::unmanaged_get_managed(p_value.operator Object *());
mono_field_set_value(p_object, mono_field, managed);
break;
}
case Variant::DICTIONARY: {
MonoObject *managed = GDMonoUtils::create_managed_from(p_value.operator Dictionary(), CACHED_CLASS(Dictionary));
mono_field_set_value(p_object, mono_field, managed);
} break;
case Variant::ARRAY: {
MonoObject *managed = GDMonoUtils::create_managed_from(p_value.operator Array(), CACHED_CLASS(Array));
mono_field_set_value(p_object, mono_field, managed);
} break;
case Variant::POOL_BYTE_ARRAY: {
SET_FROM_ARRAY(PoolByteArray);
} break;
case Variant::POOL_INT_ARRAY: {
SET_FROM_ARRAY(PoolIntArray);
} break;
case Variant::POOL_REAL_ARRAY: {
SET_FROM_ARRAY(PoolRealArray);
} break;
case Variant::POOL_STRING_ARRAY: {
SET_FROM_ARRAY(PoolStringArray);
} break;
case Variant::POOL_VECTOR2_ARRAY: {
SET_FROM_ARRAY(PoolVector2Array);
} break;
case Variant::POOL_VECTOR3_ARRAY: {
SET_FROM_ARRAY(PoolVector3Array);
} break;
case Variant::POOL_COLOR_ARRAY: {
SET_FROM_ARRAY(PoolColorArray);
} break;
default: break;
}
} break;
case MONO_TYPE_GENERICINST: {
MonoReflectionType *reftype = mono_type_get_object(SCRIPTS_DOMAIN, type.type_class->get_mono_type());
MonoException *exc = NULL;
GDMonoUtils::TypeIsGenericDictionary type_is_dict = CACHED_METHOD_THUNK(MarshalUtils, TypeIsGenericDictionary);
MonoBoolean is_dict = invoke_method_thunk(type_is_dict, reftype, &exc);
UNLIKELY_UNHANDLED_EXCEPTION(exc);
if (is_dict) {
MonoObject *managed = GDMonoUtils::create_managed_from(p_value.operator Dictionary(), type.type_class);
mono_field_set_value(p_object, mono_field, managed);
break;
}
exc = NULL;
GDMonoUtils::TypeIsGenericArray type_is_array = CACHED_METHOD_THUNK(MarshalUtils, TypeIsGenericArray);
MonoBoolean is_array = invoke_method_thunk(type_is_array, reftype, &exc);
UNLIKELY_UNHANDLED_EXCEPTION(exc);
if (is_array) {
MonoObject *managed = GDMonoUtils::create_managed_from(p_value.operator Array(), type.type_class);
mono_field_set_value(p_object, mono_field, managed);
break;
}
if (type.type_class->implements_interface(CACHED_CLASS(System_Collections_IDictionary))) {
MonoObject *managed = GDMonoUtils::create_managed_from(p_value.operator Dictionary(), CACHED_CLASS(Dictionary));
mono_field_set_value(p_object, mono_field, managed);
break;
}
if (type.type_class->implements_interface(CACHED_CLASS(System_Collections_IEnumerable))) {
MonoObject *managed = GDMonoUtils::create_managed_from(p_value.operator Array(), CACHED_CLASS(Array));
mono_field_set_value(p_object, mono_field, managed);
break;
}
} break;
default: {
ERR_PRINTS(String() + "Attempted to set the value of a field of unexpected type encoding: " + itos(type.type_encoding));
} break;
}
#undef SET_FROM_ARRAY_AND_BREAK
#undef SET_FROM_STRUCT_AND_BREAK
}
int64_t SensorBase::getTimestamp() {
struct timespec t;
t.tv_sec = t.tv_nsec = 0;
clock_gettime(CLOCK_MONOTONIC, &t);
return int64_t(t.tv_sec)*1000000000LL + t.tv_nsec;
}
LPRImage* ImageSynthesis::genFocusImage(const LPRImage *pSrcImage, const VSDRect &vsdRect)
{
assert(pSrcImage != NULL);
int depth = pSrcImage->depth;
int nChannels = pSrcImage->nChannels;
// 先创建一个与原图像相同大小的图像
LPRImage *pResultImage = LPRCreateImage(pSrcImage->width, pSrcImage->height, depth, nChannels);
memset(pResultImage->pData, 0, pResultImage->imageSize);
// 创建focus部分的图像
LPRImage *pFocusImage = LPRCreateImage(vsdRect.width, vsdRect.height, depth, nChannels);
RECT focusRect;
focusRect.left = vsdRect.x;
focusRect.top = vsdRect.y;
focusRect.right = vsdRect.x + vsdRect.width;
focusRect.bottom = vsdRect.y + vsdRect.height;
LPRCopyLargeRegionToSub(pSrcImage, pFocusImage, focusRect);
//LPRSaveImage(pFocusImage, "d:\\focus.jpg");
//////////////////////////////////////////////////////////////////////////
// 开始放大focus图像
// 首先计算宽高比 w1/h1 = w2/h2 => w1*h2 = w2*h1；为了避免溢出，用64位整数
int srcFocusDelta = int64_t(pSrcImage->width)*int64_t(pFocusImage->height) - int64_t(pSrcImage->height)*int64_t(pFocusImage->width);
if (srcFocusDelta != 0) // 宽高比不相等时，需要放大，然后复制
{
int startCopyX = 0;
int startCopyY = 0;
int resizedImageWidth = 0;
int resizedImageHeight = 0;
LPRImage *pResizedImage = NULL;
if (srcFocusDelta > 0) // 原图像的宽高比更大，则按照高来放大图像
{
resizedImageWidth = int(pFocusImage->width*(double(pSrcImage->height)/double(pFocusImage->height)));
resizedImageHeight = pSrcImage->height;
startCopyX = (pSrcImage->width - resizedImageWidth)/2;
startCopyY = 0;
pResizedImage = LPRCreateImage(resizedImageWidth, resizedImageHeight, depth, nChannels);
LPRResizeImage(pFocusImage, pResizedImage);
//LPRSaveImage(pResizedImage, "d:\\resized.jpg");
}
else if (srcFocusDelta < 0) // 原图像的宽高比更小，则按照宽来放大图像
{
resizedImageWidth = pSrcImage->width;
resizedImageHeight = int(pFocusImage->height*(double(pSrcImage->width)/double(pFocusImage->width)));
startCopyX = 0;
startCopyY = (pSrcImage->height - resizedImageHeight)/2;
pResizedImage = LPRCreateImage(resizedImageWidth, resizedImageHeight, depth, nChannels);
LPRResizeImage(pFocusImage, pResizedImage);
}
// 开始复制
RECT copyRect;
copyRect.left = startCopyX;
copyRect.top = startCopyY;
copyRect.right = startCopyX + resizedImageWidth;
copyRect.bottom = startCopyY + resizedImageHeight;
LPRCopySubImageToLarge(pResizedImage, pResultImage, copyRect);
LPRReleaseImage(pResizedImage);
}
else // 宽高比相等，则直接往结果图像缩放
{
LPRResizeImage(pFocusImage, pResultImage);
}
//LPRSaveImage(pResultImage, "d:\\res.jpg");
LPRReleaseImage(pFocusImage);
return pResultImage;
}
TimeDuration
TimeDuration::FromMilliseconds(double aMilliseconds)
{
NS_ABORT_IF_FALSE(gInitialized, "calling TimeDuration too early");
return TimeDuration::FromTicks(int64_t((aMilliseconds * kNsPerMsd) / sNsPerTick));
}
int UHD_SAFE_MAIN(int argc, char* argv[])
{
uhd::set_thread_priority_safe();
// variables to be set by po
std::string args, file, format, ant, subdev, ref, wirefmt, streamargs, radio_args,
block_id, block_args;
size_t total_num_samps, spb, radio_id, radio_chan;
double rate, freq, gain, bw, total_time, setup_time;
// setup the program options
po::options_description desc("Allowed options");
// clang-format off
desc.add_options()
("help", "help message")
("file", po::value<std::string>(&file)->default_value("usrp_samples.dat"), "name of the file to write binary samples to")
("format", po::value<std::string>(&format)->default_value("sc16"), "File sample format: sc16, fc32, or fc64")
("duration", po::value<double>(&total_time)->default_value(0), "total number of seconds to receive")
("nsamps", po::value<size_t>(&total_num_samps)->default_value(0), "total number of samples to receive")
("spb", po::value<size_t>(&spb)->default_value(10000), "samples per buffer")
("streamargs", po::value<std::string>(&streamargs)->default_value(""), "stream args")
("progress", "periodically display short-term bandwidth")
("stats", "show average bandwidth on exit")
("sizemap", "track packet size and display breakdown on exit")
("null", "run without writing to file")
("continue", "don't abort on a bad packet")
("args", po::value<std::string>(&args)->default_value(""), "USRP device address args")
("setup", po::value<double>(&setup_time)->default_value(1.0), "seconds of setup time")
("radio-id", po::value<size_t>(&radio_id)->default_value(0), "Radio ID to use (0 or 1).")
("radio-chan", po::value<size_t>(&radio_chan)->default_value(0), "Radio channel")
("radio-args", po::value<std::string>(&radio_args), "Radio channel")
("rate", po::value<double>(&rate)->default_value(1e6), "RX rate of the radio block")
("freq", po::value<double>(&freq)->default_value(0.0), "RF center frequency in Hz")
("gain", po::value<double>(&gain), "gain for the RF chain")
("ant", po::value<std::string>(&ant), "antenna selection")
("bw", po::value<double>(&bw), "analog frontend filter bandwidth in Hz")
("ref", po::value<std::string>(&ref), "reference source (internal, external, mimo)")
("skip-lo", "skip checking LO lock status")
("int-n", "tune USRP with integer-N tuning")
("block-id", po::value<std::string>(&block_id)->default_value(""), "If block ID is specified, this block is inserted between radio and host.")
("block-args", po::value<std::string>(&block_args)->default_value(""), "These args are passed straight to the block.")
;
// clang-format on
po::variables_map vm;
po::store(po::parse_command_line(argc, argv, desc), vm);
po::notify(vm);
// print the help message
if (vm.count("help")) {
std::cout << boost::format("UHD/RFNoC RX samples to file %s") % desc << std::endl;
std::cout << std::endl
<< "This application streams data from a single channel of a USRP "
"device to a file.\n"
<< std::endl;
return ~0;
}
bool bw_summary = vm.count("progress") > 0;
bool stats = vm.count("stats") > 0;
if (vm.count("null") > 0) {
file = "";
}
bool enable_size_map = vm.count("sizemap") > 0;
bool continue_on_bad_packet = vm.count("continue") > 0;
if (enable_size_map) {
std::cout << "Packet size tracking enabled - will only recv one packet at a time!"
<< std::endl;
}
if (format != "sc16" and format != "fc32" and format != "fc64") {
std::cout << "Invalid sample format: " << format << std::endl;
return EXIT_FAILURE;
}
/************************************************************************
* Create device and block controls
***********************************************************************/
std::cout << std::endl;
std::cout << boost::format("Creating the USRP device with: %s...") % args
<< std::endl;
uhd::device3::sptr usrp = uhd::device3::make(args);
// Create handle for radio object
uhd::rfnoc::block_id_t radio_ctrl_id(0, "Radio", radio_id);
// This next line will fail if the radio is not actually available
uhd::rfnoc::radio_ctrl::sptr radio_ctrl =
usrp->get_block_ctrl<uhd::rfnoc::radio_ctrl>(radio_ctrl_id);
std::cout << "Using radio " << radio_id << ", channel " << radio_chan << std::endl;
/************************************************************************
* Set up radio
***********************************************************************/
radio_ctrl->set_args(radio_args);
if (vm.count("ref")) {
std::cout << "TODO -- Need to implement API call to set clock source."
<< std::endl;
// Lock mboard clocks TODO
// usrp->set_clock_source(ref);
}
// set the sample rate
if (rate <= 0.0) {
std::cerr << "Please specify a valid sample rate" << std::endl;
return EXIT_FAILURE;
}
std::cout << boost::format("Setting RX Rate: %f Msps...") % (rate / 1e6) << std::endl;
radio_ctrl->set_rate(rate);
std::cout << boost::format("Actual RX Rate: %f Msps...")
% (radio_ctrl->get_rate() / 1e6)
<< std::endl
<< std::endl;
// set the center frequency
if (vm.count("freq")) {
std::cout << boost::format("Setting RX Freq: %f MHz...") % (freq / 1e6)
<< std::endl;
uhd::tune_request_t tune_request(freq);
if (vm.count("int-n")) {
// tune_request.args = uhd::device_addr_t("mode_n=integer"); TODO
}
radio_ctrl->set_rx_frequency(freq, radio_chan);
std::cout << boost::format("Actual RX Freq: %f MHz...")
% (radio_ctrl->get_rx_frequency(radio_chan) / 1e6)
<< std::endl
<< std::endl;
}
// set the rf gain
if (vm.count("gain")) {
std::cout << boost::format("Setting RX Gain: %f dB...") % gain << std::endl;
radio_ctrl->set_rx_gain(gain, radio_chan);
std::cout << boost::format("Actual RX Gain: %f dB...")
% radio_ctrl->get_rx_gain(radio_chan)
<< std::endl
<< std::endl;
}
// set the IF filter bandwidth
if (vm.count("bw")) {
// std::cout << boost::format("Setting RX Bandwidth: %f MHz...") % (bw/1e6) <<
// std::endl; radio_ctrl->set_rx_bandwidth(bw, radio_chan); // TODO std::cout <<
// boost::format("Actual RX Bandwidth: %f MHz...") %
// (radio_ctrl->get_rx_bandwidth(radio_chan)/1e6) << std::endl << std::endl;
}
// set the antenna
if (vm.count("ant")) {
radio_ctrl->set_rx_antenna(ant, radio_chan);
}
std::this_thread::sleep_for(std::chrono::milliseconds(int64_t(1000 * setup_time)));
// check Ref and LO Lock detect
if (not vm.count("skip-lo")) {
// TODO
// check_locked_sensor(usrp->get_rx_sensor_names(0), "lo_locked",
// boost::bind(&uhd::usrp::multi_usrp::get_rx_sensor, usrp, _1, radio_id),
// setup_time); if (ref == "external")
// check_locked_sensor(usrp->get_mboard_sensor_names(0), "ref_locked",
// boost::bind(&uhd::usrp::multi_usrp::get_mboard_sensor, usrp, _1, radio_id),
// setup_time);
}
size_t spp = radio_ctrl->get_arg<int>("spp");
/************************************************************************
* Set up streaming
***********************************************************************/
uhd::device_addr_t streamer_args(streamargs);
uhd::rfnoc::graph::sptr rx_graph = usrp->create_graph("rfnoc_rx_to_file");
usrp->clear();
// Set the stream args on the radio:
if (block_id.empty()) {
// If no extra block is required, connect to the radio:
streamer_args["block_id"] = radio_ctrl_id.to_string();
streamer_args["block_port"] = str(boost::format("%d") % radio_chan);
} else {
// Otherwise, see if the requested block exists and connect it to the radio:
if (not usrp->has_block(block_id)) {
std::cout << "Block does not exist on current device: " << block_id
<< std::endl;
return EXIT_FAILURE;
}
uhd::rfnoc::source_block_ctrl_base::sptr blk_ctrl =
usrp->get_block_ctrl<uhd::rfnoc::source_block_ctrl_base>(block_id);
if (not block_args.empty()) {
// Set the block args on the other block:
blk_ctrl->set_args(uhd::device_addr_t(block_args));
}
// Connect:
std::cout << "Connecting " << radio_ctrl_id << " ==> " << blk_ctrl->get_block_id()
<< std::endl;
rx_graph->connect(
radio_ctrl_id, radio_chan, blk_ctrl->get_block_id(), uhd::rfnoc::ANY_PORT);
streamer_args["block_id"] = blk_ctrl->get_block_id().to_string();
spp = blk_ctrl->get_args().cast<size_t>("spp", spp);
}
// create a receive streamer
std::cout << "Samples per packet: " << spp << std::endl;
uhd::stream_args_t stream_args(
format, "sc16"); // We should read the wire format from the blocks
stream_args.args = streamer_args;
stream_args.args["spp"] = boost::lexical_cast<std::string>(spp);
std::cout << "Using streamer args: " << stream_args.args.to_string() << std::endl;
uhd::rx_streamer::sptr rx_stream = usrp->get_rx_stream(stream_args);
if (total_num_samps == 0) {
std::signal(SIGINT, &sig_int_handler);
std::cout << "Press Ctrl + C to stop streaming..." << std::endl;
}
#define recv_to_file_args() \
(rx_stream, \
file, \
spb, \
rate, \
total_num_samps, \
total_time, \
bw_summary, \
stats, \
enable_size_map, \
continue_on_bad_packet)
// recv to file
if (format == "fc64")
recv_to_file<std::complex<double>> recv_to_file_args();
else if (format == "fc32")
recv_to_file<std::complex<float>> recv_to_file_args();
else if (format == "sc16")
recv_to_file<std::complex<short>> recv_to_file_args();
else
throw std::runtime_error("Unknown data format: " + format);
// finished
std::cout << std::endl << "Done!" << std::endl << std::endl;
return EXIT_SUCCESS;
}
static bool pre_proc_open(const Array& descriptorspec,
std::vector<DescriptorItem> &items) {
/* walk the descriptor spec and set up files/pipes */
items.resize(descriptorspec.size());
int i = 0;
for (ArrayIter iter(descriptorspec); iter; ++iter, ++i) {
DescriptorItem &item = items[i];
String index = iter.first();
if (!index.isNumeric()) {
raise_warning("descriptor spec must be an integer indexed array");
break;
}
item.index = index.toInt32();
Variant descitem = iter.second();
if (descitem.isResource()) {
auto file = cast<File>(descitem);
if (!item.readFile(file)) break;
} else if (!descitem.isArray()) {
raise_warning("Descriptor must be either an array or a File-Handle");
break;
} else {
Array descarr = descitem.toArray();
if (!descarr.exists(int64_t(0))) {
raise_warning("Missing handle qualifier in array");
break;
}
String ztype = descarr[int64_t(0)].toString();
if (ztype == s_pipe) {
if (!descarr.exists(int64_t(1))) {
raise_warning("Missing mode parameter for 'pipe'");
break;
}
if (!item.readPipe(descarr[int64_t(1)].toString())) break;
} else if (ztype == s_file) {
if (!descarr.exists(int64_t(1))) {
raise_warning("Missing file name parameter for 'file'");
break;
}
if (!descarr.exists(int64_t(2))) {
raise_warning("Missing mode parameter for 'file'");
break;
}
if (!item.openFile(descarr[int64_t(1)].toString(),
descarr[int64_t(2)].toString())) {
break;
}
} else {
raise_warning("%s is not a valid descriptor spec", ztype.data());
break;
}
}
}
if (i >= descriptorspec.size()) return true;
for (int j = 0; j < i; j++) {
items[j].cleanup();
}
return false;
}
void recv_to_file(uhd::rx_streamer::sptr rx_stream,
const std::string& file,
const size_t samps_per_buff,
const double rx_rate,
const unsigned long long num_requested_samples,
double time_requested = 0.0,
bool bw_summary = false,
bool stats = false,
bool enable_size_map = false,
bool continue_on_bad_packet = false)
{
unsigned long long num_total_samps = 0;
uhd::rx_metadata_t md;
std::vector<samp_type> buff(samps_per_buff);
std::ofstream outfile;
if (not file.empty()) {
outfile.open(file.c_str(), std::ofstream::binary);
}
bool overflow_message = true;
// setup streaming
uhd::stream_cmd_t stream_cmd((num_requested_samples == 0)
? uhd::stream_cmd_t::STREAM_MODE_START_CONTINUOUS
: uhd::stream_cmd_t::STREAM_MODE_NUM_SAMPS_AND_DONE);
stream_cmd.num_samps = size_t(num_requested_samples);
stream_cmd.stream_now = true;
stream_cmd.time_spec = uhd::time_spec_t();
std::cout << "Issuing stream cmd" << std::endl;
rx_stream->issue_stream_cmd(stream_cmd);
const auto start_time = std::chrono::steady_clock::now();
const auto stop_time =
start_time + std::chrono::milliseconds(int64_t(1000 * time_requested));
// Track time and samps between updating the BW summary
auto last_update = start_time;
unsigned long long last_update_samps = 0;
typedef std::map<size_t, size_t> SizeMap;
SizeMap mapSizes;
// Run this loop until either time expired (if a duration was given), until
// the requested number of samples were collected (if such a number was
// given), or until Ctrl-C was pressed.
while (not stop_signal_called
and (num_requested_samples != num_total_samps or num_requested_samples == 0)
and (time_requested == 0.0 or std::chrono::steady_clock::now() <= stop_time)) {
const auto now = std::chrono::steady_clock::now();
size_t num_rx_samps =
rx_stream->recv(&buff.front(), buff.size(), md, 3.0, enable_size_map);
if (md.error_code == uhd::rx_metadata_t::ERROR_CODE_TIMEOUT) {
std::cout << boost::format("Timeout while streaming") << std::endl;
break;
}
if (md.error_code == uhd::rx_metadata_t::ERROR_CODE_OVERFLOW) {
if (overflow_message) {
overflow_message = false;
std::cerr
<< boost::format(
"Got an overflow indication. Please consider the following:\n"
" Your write medium must sustain a rate of %fMB/s.\n"
" Dropped samples will not be written to the file.\n"
" Please modify this example for your purposes.\n"
" This message will not appear again.\n")
% (rx_rate * sizeof(samp_type) / 1e6);
}
continue;
}
if (md.error_code != uhd::rx_metadata_t::ERROR_CODE_NONE) {
std::string error = str(boost::format("Receiver error: %s") % md.strerror());
if (continue_on_bad_packet) {
std::cerr << error << std::endl;
continue;
} else
throw std::runtime_error(error);
}
if (enable_size_map) {
SizeMap::iterator it = mapSizes.find(num_rx_samps);
if (it == mapSizes.end())
mapSizes[num_rx_samps] = 0;
mapSizes[num_rx_samps] += 1;
}
num_total_samps += num_rx_samps;
if (outfile.is_open()) {
outfile.write((const char*)&buff.front(), num_rx_samps * sizeof(samp_type));
}
if (bw_summary) {
last_update_samps += num_rx_samps;
const auto time_since_last_update = now - last_update;
if (time_since_last_update > std::chrono::seconds(UPDATE_INTERVAL)) {
const double time_since_last_update_s =
std::chrono::duration<double>(time_since_last_update).count();
const double rate = double(last_update_samps) / time_since_last_update_s;
std::cout << "\t" << (rate / 1e6) << " MSps" << std::endl;
last_update_samps = 0;
last_update = now;
}
}
}
const auto actual_stop_time = std::chrono::steady_clock::now();
stream_cmd.stream_mode = uhd::stream_cmd_t::STREAM_MODE_STOP_CONTINUOUS;
std::cout << "Issuing stop stream cmd" << std::endl;
rx_stream->issue_stream_cmd(stream_cmd);
// Run recv until nothing is left
int num_post_samps = 0;
do {
num_post_samps = rx_stream->recv(&buff.front(), buff.size(), md, 3.0);
} while (num_post_samps and md.error_code == uhd::rx_metadata_t::ERROR_CODE_NONE);
if (outfile.is_open())
outfile.close();
if (stats) {
std::cout << std::endl;
const double actual_duration_seconds =
std::chrono::duration<float>(actual_stop_time - start_time).count();
std::cout << boost::format("Received %d samples in %f seconds") % num_total_samps
% actual_duration_seconds
<< std::endl;
const double rate = (double)num_total_samps / actual_duration_seconds;
std::cout << (rate / 1e6) << " MSps" << std::endl;
if (enable_size_map) {
std::cout << std::endl;
std::cout << "Packet size map (bytes: count)" << std::endl;
for (SizeMap::iterator it = mapSizes.begin(); it != mapSizes.end(); it++)
std::cout << it->first << ":\t" << it->second << std::endl;
}
}
}
static int64_t to_usec(const timeval& tv) {
return (int64_t(tv.tv_sec) * 1000000) + tv.tv_usec;
}
status_t
AVFormatReader::Stream::FindKeyFrame(uint32 flags, int64* frame,
bigtime_t* time) const
{
BAutolock _(&fLock);
if (fContext == NULL || fStream == NULL)
return B_NO_INIT;
TRACE_FIND("AVFormatReader::Stream::FindKeyFrame(%ld,%s%s%s%s, "
"%lld, %lld)\n", VirtualIndex(),
(flags & B_MEDIA_SEEK_TO_FRAME) ? " B_MEDIA_SEEK_TO_FRAME" : "",
(flags & B_MEDIA_SEEK_TO_TIME) ? " B_MEDIA_SEEK_TO_TIME" : "",
(flags & B_MEDIA_SEEK_CLOSEST_BACKWARD)
? " B_MEDIA_SEEK_CLOSEST_BACKWARD" : "",
(flags & B_MEDIA_SEEK_CLOSEST_FORWARD)
? " B_MEDIA_SEEK_CLOSEST_FORWARD" : "",
*frame, *time);
bool inLastRequestedRange = false;
if ((flags & B_MEDIA_SEEK_TO_FRAME) != 0) {
if (fLastReportedKeyframe.reportedFrame
<= fLastReportedKeyframe.requestedFrame) {
inLastRequestedRange
= *frame >= fLastReportedKeyframe.reportedFrame
&& *frame <= fLastReportedKeyframe.requestedFrame;
} else {
inLastRequestedRange
= *frame >= fLastReportedKeyframe.requestedFrame
&& *frame <= fLastReportedKeyframe.reportedFrame;
}
} else if ((flags & B_MEDIA_SEEK_TO_FRAME) == 0) {
if (fLastReportedKeyframe.reportedTime
<= fLastReportedKeyframe.requestedTime) {
inLastRequestedRange
= *time >= fLastReportedKeyframe.reportedTime
&& *time <= fLastReportedKeyframe.requestedTime;
} else {
inLastRequestedRange
= *time >= fLastReportedKeyframe.requestedTime
&& *time <= fLastReportedKeyframe.reportedTime;
}
}
if (inLastRequestedRange) {
*frame = fLastReportedKeyframe.reportedFrame;
*time = fLastReportedKeyframe.reportedTime;
TRACE_FIND(" same as last reported keyframe\n");
return B_OK;
}
double frameRate = FrameRate();
if ((flags & B_MEDIA_SEEK_TO_FRAME) != 0)
*time = (bigtime_t)(*frame * 1000000.0 / frameRate + 0.5);
status_t ret;
if (fGhostStream == NULL) {
BAutolock _(fSourceLock);
fGhostStream = new(std::nothrow) StreamBase(fSource, fSourceLock,
&fLock);
if (fGhostStream == NULL) {
TRACE(" failed to allocate ghost stream\n");
return B_NO_MEMORY;
}
ret = fGhostStream->Open();
if (ret != B_OK) {
TRACE(" ghost stream failed to open: %s\n", strerror(ret));
return B_ERROR;
}
ret = fGhostStream->Init(fVirtualIndex);
if (ret != B_OK) {
TRACE(" ghost stream failed to init: %s\n", strerror(ret));
return B_ERROR;
}
}
fLastReportedKeyframe.requestedFrame = *frame;
fLastReportedKeyframe.requestedTime = *time;
fLastReportedKeyframe.seekFlags = flags;
ret = fGhostStream->Seek(flags, frame, time);
if (ret != B_OK) {
TRACE(" ghost stream failed to seek: %s\n", strerror(ret));
return B_ERROR;
}
fLastReportedKeyframe.reportedFrame = *frame;
fLastReportedKeyframe.reportedTime = *time;
TRACE_FIND(" found time: %.2fs\n", *time / 1000000.0);
if ((flags & B_MEDIA_SEEK_TO_FRAME) != 0) {
*frame = int64_t(*time * FrameRate() / 1000000.0 + 0.5);
TRACE_FIND(" found frame: %lld\n", *frame);
}
return B_OK;
}
ReturnValue Tile::__queryAdd(int32_t index, const Thing* thing, uint32_t count,
uint32_t flags) const
{
const CreatureVector* creatures = getCreatures();
const TileItemVector* items = getItemList();
if(const Creature* creature = thing->getCreature()){
if(hasBitSet(FLAG_NOLIMIT, flags)){
return RET_NOERROR;
}
if(hasBitSet(FLAG_PATHFINDING, flags)){
if(floorChange() || positionChange()){
return RET_NOTPOSSIBLE;
}
}
if(ground == NULL)
return RET_NOTPOSSIBLE;
if(const Monster* monster = creature->getMonster()){
if(hasFlag(TILESTATE_PROTECTIONZONE))
return RET_NOTPOSSIBLE;
if(floorChange() || positionChange()){
return RET_NOTPOSSIBLE;
}
if(monster->canPushCreatures() && !monster->isSummon()){
if(creatures){
Creature* creature;
for(uint32_t i = 0; i < creatures->size(); ++i){
creature = creatures->at(i);
if( !creature->getMonster() ||
!creature->isPushable() ||
(creature->getMonster()->isPlayerSummon()))
{
return RET_NOTPOSSIBLE;
}
}
}
}
else if(creatures && !creatures->empty()){
return RET_NOTENOUGHROOM;
}
if(hasFlag(TILESTATE_IMMOVABLEBLOCKSOLID)){
return RET_NOTPOSSIBLE;
}
if(hasBitSet(FLAG_PATHFINDING, flags) && hasFlag(TILESTATE_IMMOVABLENOFIELDBLOCKPATH)){
return RET_NOTPOSSIBLE;
}
if(hasFlag(TILESTATE_BLOCKSOLID) || (hasBitSet(FLAG_PATHFINDING, flags) && hasFlag(TILESTATE_NOFIELDBLOCKPATH))){
if(!(monster->canPushItems() || hasBitSet(FLAG_IGNOREBLOCKITEM, flags) ) ){
return RET_NOTPOSSIBLE;
}
}
MagicField* field = getFieldItem();
if(field && !field->isBlocking(monster)){
CombatType_t combatType = field->getCombatType();
//There are 3 options for a monster to enter a magic field
//1) Monster is immune
if(!monster->isImmune(combatType)){
//2) Monster is "strong" enough to handle the damage and was attacked
//3) Monster is already afflicated by this type of condition
if(hasBitSet(FLAG_IGNOREFIELDDAMAGE, flags)){
if(!monster->hasCondition(Combat::DamageToConditionType(combatType), false)){
if(!monster->canPushItems() || !monster->hadRecentBattle()){
return RET_NOTPOSSIBLE;
}
}
}
else{
return RET_NOTPOSSIBLE;
}
}
}
}
else if(const Player* player = creature->getPlayer()){
if(creatures && !creatures->empty() && !hasBitSet(FLAG_IGNOREBLOCKCREATURE, flags)){
return RET_NOTENOUGHROOM; //RET_NOTPOSSIBLE
}
if(player->getParent() == NULL && hasFlag(TILESTATE_NOLOGOUT)){
//player is trying to login to a "no logout" tile
return RET_NOTPOSSIBLE;
}
if(player->getTile()){
if(player->isPzLocked() && !player->getTile()->hasFlag(TILESTATE_PVPZONE) && hasFlag(TILESTATE_PVPZONE)){
//player is trying to enter a pvp zone while being pz-locked
return RET_PLAYERISPZLOCKEDENTERPVPZONE;
}
if(player->isPzLocked() && player->getTile()->hasFlag(TILESTATE_PVPZONE) && !hasFlag(TILESTATE_PVPZONE)){
//player is trying to leave a pvp zone while being pz-locked
return RET_PLAYERISPZLOCKEDLEAVEPVPZONE;
}
}
if(hasFlag(TILESTATE_NOPVPZONE) && player->isPzLocked()){
return RET_PLAYERISPZLOCKED;
}
if(hasFlag(TILESTATE_PROTECTIONZONE) && player->isPzLocked()){
return RET_PLAYERISPZLOCKED;
}
}
else{
if(creatures && !creatures->empty() && !hasBitSet(FLAG_IGNOREBLOCKCREATURE, flags)){
return RET_NOTENOUGHROOM;
}
}
if(items){
MagicField* field = getFieldItem();
if(field && field->isBlocking(creature)){
return RET_NOTPOSSIBLE;
}
if(!hasBitSet(FLAG_IGNOREBLOCKITEM, flags)){
//If the FLAG_IGNOREBLOCKITEM bit isn't set we dont have to iterate every single item
if(hasFlag(TILESTATE_BLOCKSOLID)){
return RET_NOTENOUGHROOM;
}
}
else{
//FLAG_IGNOREBLOCKITEM is set
if(ground){
const ItemType& iiType = Item::items[ground->getID()];
if(ground->isBlocking(creature) && (!iiType.moveable || ground->getUniqueId() != 0)){
return RET_NOTPOSSIBLE;
}
}
if(const TileItemVector* items = getItemList()){
Item* iitem;
for(ItemVector::const_iterator it = items->begin(); it != items->end(); ++it){
iitem = (*it);
const ItemType& iiType = Item::items[iitem->getID()];
if(iitem->isBlocking(creature) && (!iiType.moveable || iitem->getUniqueId() != 0)){
return RET_NOTPOSSIBLE;
}
}
}
}
}
}
else if(const Item* item = thing->getItem()){
#ifdef __DEBUG__
if(thing->getParent() == NULL && !hasBitSet(FLAG_NOLIMIT, flags)){
std::cout << "Notice: Tile::__queryAdd() - thing->getParent() == NULL" << std::endl;
}
#endif
if(items){
int64_t c = g_config.getNumber(ConfigManager::MAX_STACK_SIZE);
//acceptable stack sizes should be higher than 100 and <= than 65535
uint16_t max_stack_size = uint16_t(std::max(std::min(c, int64_t(0xFFFF)), int64_t(100)));
if (items->size() >= max_stack_size){
return RET_NOTPOSSIBLE;
}
}
if(hasBitSet(FLAG_NOLIMIT, flags)){
return RET_NOERROR;
}
bool itemIsHangable = item->isHangable();
if(ground == NULL && !itemIsHangable){
return RET_NOTPOSSIBLE;
}
if(creatures && !creatures->empty() && !hasBitSet(FLAG_IGNOREBLOCKCREATURE, flags)){
for(CreatureVector::const_iterator cit = creatures->begin(); cit != creatures->end(); ++cit){
if((!(*cit)->getPlayer() || !(*cit)->getPlayer()->hasSomeInvisibilityFlag()) && item->isBlocking(*cit)){
return RET_NOTENOUGHROOM;
}
}
}
const uint32_t itemLimit = g_config.getNumber(hasFlag(TILESTATE_PROTECTIONZONE) ? ConfigManager::PROTECTION_TILE_LIMIT : ConfigManager::TILE_LIMIT);
if(itemLimit && getThingCount() > itemLimit)
return RET_TILEISFULL;
bool hasHangable = false;
bool supportHangable = false;
if(items){
Thing* iithing = NULL;
for(uint32_t i = 0; i < getThingCount(); ++i){
iithing = __getThing(i);
if(const Item* iitem = iithing->getItem()){
const ItemType& iiType = Item::items[iitem->getID()];
if(iiType.isHangable){
hasHangable = true;
}
if(iiType.isHorizontal || iiType.isVertical){
supportHangable = true;
}
if(itemIsHangable && (iiType.isHorizontal || iiType.isVertical)){
//
}
else if(iiType.blockSolid || iiType.isSolidForItems()){
if(item->isPickupable()){
if(iiType.allowPickupable){
continue;
}
if(!iiType.hasHeight || iiType.pickupable || iiType.isBed()){
return RET_NOTENOUGHROOM;
}
}
else{
return RET_NOTENOUGHROOM;
}
}
}
}
}
if(itemIsHangable && hasHangable && supportHangable){
return RET_NEEDEXCHANGE;
}
}
return RET_NOERROR;
}
status_t
StreamBase::Seek(uint32 flags, int64* frame, bigtime_t* time)
{
BAutolock _(fStreamLock);
if (fContext == NULL || fStream == NULL)
return B_NO_INIT;
TRACE_SEEK("StreamBase::Seek(%ld,%s%s%s%s, %lld, "
"%lld)\n", VirtualIndex(),
(flags & B_MEDIA_SEEK_TO_FRAME) ? " B_MEDIA_SEEK_TO_FRAME" : "",
(flags & B_MEDIA_SEEK_TO_TIME) ? " B_MEDIA_SEEK_TO_TIME" : "",
(flags & B_MEDIA_SEEK_CLOSEST_BACKWARD)
? " B_MEDIA_SEEK_CLOSEST_BACKWARD" : "",
(flags & B_MEDIA_SEEK_CLOSEST_FORWARD)
? " B_MEDIA_SEEK_CLOSEST_FORWARD" : "",
*frame, *time);
double frameRate = FrameRate();
if ((flags & B_MEDIA_SEEK_TO_FRAME) != 0) {
// Seeking is always based on time, initialize it when client seeks
// based on frame.
*time = (bigtime_t)(*frame * 1000000.0 / frameRate + 0.5);
}
int64_t timeStamp = *time;
int searchFlags = AVSEEK_FLAG_BACKWARD;
if ((flags & B_MEDIA_SEEK_CLOSEST_FORWARD) != 0)
searchFlags = 0;
if (fSeekByBytes) {
searchFlags |= AVSEEK_FLAG_BYTE;
BAutolock _(fSourceLock);
int64_t fileSize;
if (fSource->GetSize(&fileSize) != B_OK)
return B_NOT_SUPPORTED;
int64_t duration = Duration();
if (duration == 0)
return B_NOT_SUPPORTED;
timeStamp = int64_t(fileSize * ((double)timeStamp / duration));
if ((flags & B_MEDIA_SEEK_CLOSEST_BACKWARD) != 0) {
timeStamp -= 65536;
if (timeStamp < 0)
timeStamp = 0;
}
bool seekAgain = true;
bool seekForward = true;
bigtime_t lastFoundTime = -1;
int64_t closestTimeStampBackwards = -1;
while (seekAgain) {
if (avformat_seek_file(fContext, -1, INT64_MIN, timeStamp,
INT64_MAX, searchFlags) < 0) {
TRACE(" avformat_seek_file() (by bytes) failed.\n");
return B_ERROR;
}
seekAgain = false;
// Our last packet is toast in any case. Read the next one so we
// know where we really seeked.
fReusePacket = false;
if (_NextPacket(true) == B_OK) {
while (fPacket.pts == kNoPTSValue) {
fReusePacket = false;
if (_NextPacket(true) != B_OK)
return B_ERROR;
}
if (fPacket.pos >= 0)
timeStamp = fPacket.pos;
bigtime_t foundTime
= _ConvertFromStreamTimeBase(fPacket.pts);
if (foundTime != lastFoundTime) {
lastFoundTime = foundTime;
if (foundTime > *time) {
if (closestTimeStampBackwards >= 0) {
timeStamp = closestTimeStampBackwards;
seekAgain = true;
seekForward = false;
continue;
}
int64_t diff = int64_t(fileSize
* ((double)(foundTime - *time) / (2 * duration)));
if (diff < 8192)
break;
timeStamp -= diff;
TRACE_SEEK(" need to seek back (%lld) (time: %.2f "
"-> %.2f)\n", timeStamp, *time / 1000000.0,
foundTime / 1000000.0);
if (timeStamp < 0)
foundTime = 0;
else {
seekAgain = true;
continue;
}
} else if (seekForward && foundTime < *time - 100000) {
closestTimeStampBackwards = timeStamp;
int64_t diff = int64_t(fileSize
* ((double)(*time - foundTime) / (2 * duration)));
if (diff < 8192)
break;
timeStamp += diff;
TRACE_SEEK(" need to seek forward (%lld) (time: "
"%.2f -> %.2f)\n", timeStamp, *time / 1000000.0,
foundTime / 1000000.0);
if (timeStamp > duration)
foundTime = duration;
else {
seekAgain = true;
continue;
}
}
}
TRACE_SEEK(" found time: %lld -> %lld (%.2f)\n", *time,
foundTime, foundTime / 1000000.0);
*time = foundTime;
*frame = (uint64)(*time * frameRate / 1000000LL + 0.5);
TRACE_SEEK(" seeked frame: %lld\n", *frame);
} else {
TRACE_SEEK(" _NextPacket() failed!\n");
return B_ERROR;
}
}
} else {
// We may not get a PTS from the next packet after seeking, so
// we try to get an expected time from the index.
int64_t streamTimeStamp = _ConvertToStreamTimeBase(*time);
int index = av_index_search_timestamp(fStream, streamTimeStamp,
searchFlags);
if (index < 0) {
TRACE(" av_index_search_timestamp() failed\n");
} else {
if (index > 0) {
const AVIndexEntry& entry = fStream->index_entries[index];
streamTimeStamp = entry.timestamp;
} else {
// Some demuxers use the first index entry to store some
// other information, like the total playing time for example.
// Assume the timeStamp of the first entry is alays 0.
// TODO: Handle start-time offset?
streamTimeStamp = 0;
}
bigtime_t foundTime = _ConvertFromStreamTimeBase(streamTimeStamp);
bigtime_t timeDiff = foundTime > *time
? foundTime - *time : *time - foundTime;
if (timeDiff > 1000000
&& (fStreamBuildsIndexWhileReading
|| index == fStream->nb_index_entries - 1)) {
// If the stream is building the index on the fly while parsing
// it, we only have entries in the index for positions already
// decoded, i.e. we cannot seek into the future. In that case,
// just assume that we can seek where we want and leave
// time/frame unmodified. Since successfully seeking one time
// will generate index entries for the seeked to position, we
// need to remember this in fStreamBuildsIndexWhileReading,
// since when seeking back there will be later index entries,
// but we still want to ignore the found entry.
fStreamBuildsIndexWhileReading = true;
TRACE_SEEK(" Not trusting generic index entry. "
"(Current count: %d)\n", fStream->nb_index_entries);
} else {
// If we found a reasonably time, write it into *time.
// After seeking, we will try to read the sought time from
// the next packet. If the packet has no PTS value, we may
// still have a more accurate time from the index lookup.
*time = foundTime;
}
}
if (avformat_seek_file(fContext, -1, INT64_MIN, timeStamp, INT64_MAX,
searchFlags) < 0) {
TRACE(" avformat_seek_file() failed.\n");
// Try to fall back to av_seek_frame()
timeStamp = _ConvertToStreamTimeBase(timeStamp);
if (av_seek_frame(fContext, fStream->index, timeStamp,
searchFlags) < 0) {
TRACE(" avformat_seek_frame() failed as well.\n");
// Fall back to seeking to the beginning by bytes
timeStamp = 0;
if (av_seek_frame(fContext, fStream->index, timeStamp,
AVSEEK_FLAG_BYTE) < 0) {
TRACE(" avformat_seek_frame() by bytes failed as "
"well.\n");
// Do not propagate error in any case. We fail if we can't
// read another packet.
} else
*time = 0;
}
}
// Our last packet is toast in any case. Read the next one so
// we know where we really sought.
bigtime_t foundTime = *time;
fReusePacket = false;
if (_NextPacket(true) == B_OK) {
if (fPacket.pts != kNoPTSValue)
foundTime = _ConvertFromStreamTimeBase(fPacket.pts);
else
TRACE_SEEK(" no PTS in packet after seeking\n");
} else
TRACE_SEEK(" _NextPacket() failed!\n");
*time = foundTime;
TRACE_SEEK(" sought time: %.2fs\n", *time / 1000000.0);
*frame = (uint64)(*time * frameRate / 1000000.0 + 0.5);
TRACE_SEEK(" sought frame: %lld\n", *frame);
}
return B_OK;
}
bool ExportFFmpeg::Finalize()
{
int i, nEncodedBytes;
// Flush the audio FIFO and encoder.
for (;;)
{
AVPacket pkt;
int nFifoBytes = av_fifo_size(mEncAudioFifo); // any bytes left in audio FIFO?
av_init_packet(&pkt);
nEncodedBytes = 0;
int nAudioFrameSizeOut = default_frame_size * mEncAudioCodecCtx->channels * sizeof(int16_t);
if (nAudioFrameSizeOut > mEncAudioFifoOutBufSiz || nFifoBytes > mEncAudioFifoOutBufSiz) {
wxMessageBox(wxString::Format(_("FFmpeg : ERROR - Too much remaining data.")),
_("FFmpeg Error"), wxOK|wxCENTER|wxICON_EXCLAMATION);
return false;
}
// Flush the audio FIFO first if necessary. It won't contain a _full_ audio frame because
// if it did we'd have pulled it from the FIFO during the last encodeAudioFrame() call -
// the encoder must support short/incomplete frames for this to work.
if (nFifoBytes > 0)
{
// Fill audio buffer with zeroes. If codec tries to read the whole buffer,
// it will just read silence. If not - who cares?
memset(mEncAudioFifoOutBuf,0,mEncAudioFifoOutBufSiz);
const AVCodec *codec = mEncAudioCodecCtx->codec;
// We have an incomplete buffer of samples left. Is it OK to encode it?
// If codec supports CODEC_CAP_SMALL_LAST_FRAME, we can feed it with smaller frame
// Or if codec is FLAC, feed it anyway (it doesn't have CODEC_CAP_SMALL_LAST_FRAME, but it works)
// Or if frame_size is 1, then it's some kind of PCM codec, they don't have frames and will be fine with the samples
// Or if user configured the exporter to pad with silence, then we'll send audio + silence as a frame.
if ((codec->capabilities & (CODEC_CAP_SMALL_LAST_FRAME|CODEC_CAP_VARIABLE_FRAME_SIZE))
|| mEncAudioCodecCtx->frame_size <= 1
|| gPrefs->Read(wxT("/FileFormats/OverrideSmallLastFrame"), true)
)
{
int frame_size = default_frame_size;
// The last frame is going to contain a smaller than usual number of samples.
// For codecs without CODEC_CAP_SMALL_LAST_FRAME use normal frame size
if (codec->capabilities & (CODEC_CAP_SMALL_LAST_FRAME|CODEC_CAP_VARIABLE_FRAME_SIZE))
frame_size = nFifoBytes / (mEncAudioCodecCtx->channels * sizeof(int16_t));
wxLogDebug(wxT("FFmpeg : Audio FIFO still contains %d bytes, writing %d sample frame ..."),
nFifoBytes, frame_size);
// Pull the bytes out from the FIFO and feed them to the encoder.
if (av_fifo_generic_read(mEncAudioFifo, mEncAudioFifoOutBuf, nFifoBytes, NULL) == 0)
{
nEncodedBytes = encode_audio(mEncAudioCodecCtx, &pkt, (int16_t*)mEncAudioFifoOutBuf, frame_size);
}
}
}
// Now flush the encoder.
if (nEncodedBytes <= 0)
nEncodedBytes = encode_audio(mEncAudioCodecCtx, &pkt, NULL, 0);
if (nEncodedBytes <= 0)
break;
pkt.stream_index = mEncAudioStream->index;
// Set presentation time of frame (currently in the codec's timebase) in the stream timebase.
if(pkt.pts != int64_t(AV_NOPTS_VALUE))
pkt.pts = av_rescale_q(pkt.pts, mEncAudioCodecCtx->time_base, mEncAudioStream->time_base);
if(pkt.dts != int64_t(AV_NOPTS_VALUE))
pkt.dts = av_rescale_q(pkt.dts, mEncAudioCodecCtx->time_base, mEncAudioStream->time_base);
if (av_interleaved_write_frame(mEncFormatCtx, &pkt) != 0)
{
wxMessageBox(wxString::Format(_("FFmpeg : ERROR - Couldn't write last audio frame to output file.")),
_("FFmpeg Error"), wxOK|wxCENTER|wxICON_EXCLAMATION);
break;
}
av_free_packet(&pkt);
}
// Write any file trailers.
av_write_trailer(mEncFormatCtx);
// Close the codecs.
if (mEncAudioStream != NULL)
avcodec_close(mEncAudioStream->codec);
for (i = 0; i < (int)mEncFormatCtx->nb_streams; i++)
{
av_freep(&mEncFormatCtx->streams[i]->codec);
av_freep(&mEncFormatCtx->streams[i]);
}
// Close the output file if we created it.
if (!(mEncFormatDesc->flags & AVFMT_NOFILE))
ufile_close(mEncFormatCtx->pb);
// Free any buffers or structures we allocated.
av_free(mEncFormatCtx);
av_freep(&mEncAudioFifoOutBuf);
mEncAudioFifoOutBufSiz = 0;
av_fifo_free(mEncAudioFifo);
mEncAudioFifo = NULL;
return true;
}
void
nsSprocketLayout::ComputeChildSizes(nsIFrame* aBox,
nsBoxLayoutState& aState,
nscoord& aGivenSize,
nsBoxSize* aBoxSizes,
nsComputedBoxSize*& aComputedBoxSizes)
{
//nscoord onePixel = aState.PresContext()->IntScaledPixelsToTwips(1);
int32_t sizeRemaining = aGivenSize;
int32_t spacerConstantsRemaining = 0;
// ----- calculate the spacers constants and the size remaining -----
if (!aComputedBoxSizes)
aComputedBoxSizes = new (aState) nsComputedBoxSize();
nsBoxSize* boxSizes = aBoxSizes;
nsComputedBoxSize* computedBoxSizes = aComputedBoxSizes;
int32_t count = 0;
int32_t validCount = 0;
while (boxSizes)
{
NS_ASSERTION((boxSizes->min <= boxSizes->pref && boxSizes->pref <= boxSizes->max),"bad pref, min, max size");
// ignore collapsed children
// if (boxSizes->collapsed)
// {
// computedBoxSizes->valid = true;
// computedBoxSizes->size = boxSizes->pref;
// validCount++;
// boxSizes->flex = 0;
// }// else {
if (computedBoxSizes->valid) {
sizeRemaining -= computedBoxSizes->size;
validCount++;
} else {
if (boxSizes->flex == 0)
{
computedBoxSizes->valid = true;
computedBoxSizes->size = boxSizes->pref;
validCount++;
}
spacerConstantsRemaining += boxSizes->flex;
sizeRemaining -= boxSizes->pref;
}
sizeRemaining -= (boxSizes->left + boxSizes->right);
//}
boxSizes = boxSizes->next;
if (boxSizes && !computedBoxSizes->next)
computedBoxSizes->next = new (aState) nsComputedBoxSize();
computedBoxSizes = computedBoxSizes->next;
count++;
}
// everything accounted for?
if (validCount < count)
{
// ----- Ok we are give a size to fit into so stretch or squeeze to fit
// ----- Make sure we look at our min and max size
bool limit = true;
for (int pass=1; true == limit; pass++)
{
limit = false;
boxSizes = aBoxSizes;
computedBoxSizes = aComputedBoxSizes;
while (boxSizes) {
// ignore collapsed spacers
// if (!boxSizes->collapsed) {
nscoord pref = 0;
nscoord max = NS_INTRINSICSIZE;
nscoord min = 0;
nscoord flex = 0;
pref = boxSizes->pref;
min = boxSizes->min;
max = boxSizes->max;
flex = boxSizes->flex;
// ----- look at our min and max limits make sure we aren't too small or too big -----
if (!computedBoxSizes->valid) {
int32_t newSize = pref + int32_t(int64_t(sizeRemaining) * flex / spacerConstantsRemaining);
if (newSize<=min) {
computedBoxSizes->size = min;
computedBoxSizes->valid = true;
spacerConstantsRemaining -= flex;
sizeRemaining += pref;
sizeRemaining -= min;
limit = true;
} else if (newSize>=max) {
computedBoxSizes->size = max;
computedBoxSizes->valid = true;
spacerConstantsRemaining -= flex;
sizeRemaining += pref;
sizeRemaining -= max;
limit = true;
}
}
// }
boxSizes = boxSizes->next;
computedBoxSizes = computedBoxSizes->next;
}
}
}
// ---- once we have removed and min and max issues just stretch us out in the remaining space
// ---- or shrink us. Depends on the size remaining and the spacer constants
aGivenSize = 0;
boxSizes = aBoxSizes;
computedBoxSizes = aComputedBoxSizes;
while (boxSizes) {
// ignore collapsed spacers
// if (!(boxSizes && boxSizes->collapsed)) {
nscoord pref = 0;
nscoord flex = 0;
pref = boxSizes->pref;
flex = boxSizes->flex;
if (!computedBoxSizes->valid) {
computedBoxSizes->size = pref + int32_t(int64_t(sizeRemaining) * flex / spacerConstantsRemaining);
computedBoxSizes->valid = true;
}
aGivenSize += (boxSizes->left + boxSizes->right);
aGivenSize += computedBoxSizes->size;
// }
boxSizes = boxSizes->next;
computedBoxSizes = computedBoxSizes->next;
}
}
