void processVideo(CameraCalibration& calibration, cv::VideoCapture& capture)
{
// Grab first frame to get the frame dimensions
cv::Mat currentFrame, srcFrame;
capture >> srcFrame;
resize(srcFrame, currentFrame, cvSize(653, 368));
// Check the capture succeeded:
if (currentFrame.empty())
{
std::cout << "Cannot open video capture device" << std::endl;
return;
}
cv::Size frameSize(currentFrame.cols, currentFrame.rows);
std::auto_ptr<MarkerDetectionFacade> detector = createMarkerDetection(calibration);
ARDrawingContext drawingCtx("Markerless AR", frameSize, calibration);
bool shouldQuit = false;
do
{
capture >> srcFrame;
if (srcFrame.empty())
{
shouldQuit = true;
continue;
}
resize(srcFrame, currentFrame, cvSize(653,368));
shouldQuit = processFrame(currentFrame, detector, drawingCtx);
} while (!shouldQuit);
}
QDomDocument *XmlWriter::toXml()
{
QDomImplementation implementation;
QDomDocumentType docType = implementation.createDocumentType(
"scribe-document", "scribe", "qt.nokia.com/scribe");
document = new QDomDocument(docType);
// ### This processing instruction is required to ensure that any kind
// of encoding is given when the document is written.
QDomProcessingInstruction process = document->createProcessingInstruction(
"xml", "version=\"1.0\" encoding=\"utf-8\"");
document->appendChild(process);
QDomElement documentElement = document->createElement("document");
document->appendChild(documentElement);
//! [0]
QTextFrame *root = textDocument->rootFrame();
//! [0]
if (root)
processFrame(documentElement, root);
return document;
}
void FrameHandlerMono::addImage(const cv::Mat& img, const double timestamp)
{
if(!startFrameProcessingCommon(timestamp))
return;
// some cleanup from last iteration, can't do before because of visualization
core_kfs_.clear();
overlap_kfs_.clear();
// create new frame
SVO_START_TIMER("pyramid_creation");
new_frame_.reset(new Frame(cam_, img.clone(), timestamp));
SVO_STOP_TIMER("pyramid_creation");
// process frame
UpdateResult res = RESULT_FAILURE;
if(stage_ == STAGE_DEFAULT_FRAME)
res = processFrame();
else if(stage_ == STAGE_SECOND_FRAME)
res = processSecondFrame();
else if(stage_ == STAGE_FIRST_FRAME)
res = processFirstFrame();
else if(stage_ == STAGE_RELOCALIZING)
res = relocalizeFrame(SE3d(Matrix3d::Identity(), Vector3d::Zero()),
map_.getClosestKeyframe(last_frame_));
// set last frame
last_frame_ = new_frame_;
new_frame_.reset();
// finish processing
finishFrameProcessingCommon(last_frame_->id_, res, last_frame_->nObs());
}
/**
* Processes a recorded video or live view from web-camera and allows you to adjust homography refinement and
* reprojection threshold in runtime.
*/
void processVideo(const cv::Mat& patternImage, CameraCalibration& calibration, cv::VideoCapture& capture)
{
// Grab first frame to get the frame dimensions
cv::Mat currentFrame;
capture >> currentFrame;
// Check the capture succeeded:
if (currentFrame.empty())
{
std::cout << "Cannot open video capture device" << std::endl;
return;
}
cv::Size frameSize(currentFrame.cols, currentFrame.rows);
ARPipeline pipeline(patternImage, calibration);
ARDrawingContext drawingCtx("Markerless AR", frameSize, calibration);
bool shouldQuit = false;
do
{
capture >> currentFrame;
if (currentFrame.empty())
{
shouldQuit = true;
continue;
}
shouldQuit = processFrame(currentFrame, pipeline, drawingCtx);
} while (!shouldQuit);
}
FrameHandlerMono::UpdateResult FrameHandlerMono::relocalizeFrame(
const SE3d& T_cur_ref,
FramePtr ref_keyframe)
{
SVO_WARN_STREAM_THROTTLE(1.0, "Relocalizing frame");
if(ref_keyframe == nullptr)
{
SVO_INFO_STREAM("No reference keyframe.");
return RESULT_FAILURE;
}
SparseImgAlign img_align(Config::kltMaxLevel(), Config::kltMinLevel(),
30, SparseImgAlign::GaussNewton, false, false);
size_t img_align_n_tracked = img_align.run(ref_keyframe, new_frame_);
if(img_align_n_tracked > 30)
{
SE3d T_f_w_last = last_frame_->T_f_w_;
last_frame_ = ref_keyframe;
FrameHandlerMono::UpdateResult res = processFrame();
if(res != RESULT_FAILURE)
{
stage_ = STAGE_DEFAULT_FRAME;
SVO_INFO_STREAM("Relocalization successful.");
}
else
new_frame_->T_f_w_ = T_f_w_last; // reset to last well localized pose
return res;
}
return RESULT_FAILURE;
}
void useFrame(cv::Mat& mRgba){
int64 now = cv::getTickCount();
int64 then;
time_queue.push(now);
// Process frame
if(mRgba.cols != 0) {
processFrame(mRgba);
char buffer[256];
sprintf(buffer, "Display performance: %dx%d @ %.3f", mRgba.cols, mRgba.rows, fps);
cv::putText(mRgba, std::string(buffer), cv::Point(8,64),
cv::FONT_HERSHEY_COMPLEX_SMALL, 1, cv::Scalar(0,255,255,255));
}
if (time_queue.size() >= 2)
then = time_queue.front();
else
then = 0;
if (time_queue.size() >= 25)
time_queue.pop();
fps = time_queue.size() * (float)cv::getTickFrequency() / (now-then);
}
int Viewfinder::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QWidget::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
switch (_id) {
case 0: processFrames((*reinterpret_cast< int(*)>(_a[1]))); break;
case 1: processFrame(); break;
case 2: toggleCube(); break;
case 3: toggleGourd(); break;
case 4: paintCube(); break;
case 5: paintGourd(); break;
case 6: changeX(); break;
case 7: changeY(); break;
case 8: changeZ(); break;
case 9: rotateX(); break;
case 10: rotateY(); break;
case 11: rotateZ(); break;
case 12: plus(); break;
case 13: minus(); break;
case 14: openDirectory(); break;
default: ;
}
_id -= 15;
}
return _id;
}
void XmlWriter::processFrame(QDomElement &parent, QTextFrame *frame)
{
QDomElement frameElement = document->createElement("frame");
frameElement.setAttribute("begin", frame->firstPosition());
frameElement.setAttribute("end", frame->lastPosition());
parent.appendChild(frameElement);
//! [0]
QTextFrame::iterator it;
for (it = frame->begin(); !(it.atEnd()); ++it) {
QTextFrame *childFrame = it.currentFrame();
QTextBlock childBlock = it.currentBlock();
if (childFrame) {
QTextTable *childTable = qobject_cast<QTextTable*>(childFrame);
if (childTable)
processTable(frameElement, childTable);
else
processFrame(frameElement, childFrame);
} else if (childBlock.isValid())
//! [0] //! [1]
processBlock(frameElement, childBlock);
}
//! [1]
}
void
liveScanner (dsd_opts * opts, dsd_state * state)
{
if (opts->audio_in_fd == -1)
{
if (pthread_mutex_lock(&state->input_mutex))
{
printf("liveScanner -> Unable to lock mutex\n");
}
}
while (1)
{
noCarrier (opts, state);
state->synctype = getFrameSync (opts, state);
// recalibrate center/umid/lmid
state->center = ((state->max) + (state->min)) / 2;
state->umid = (((state->max) - state->center) * 5 / 8) + state->center;
state->lmid = (((state->min) - state->center) * 5 / 8) + state->center;
while (state->synctype != -1)
{
processFrame (opts, state);
state->synctype = getFrameSync (opts, state);
// recalibrate center/umid/lmid
state->center = ((state->max) + (state->min)) / 2;
state->umid = (((state->max) - state->center) * 5 / 8) + state->center;
state->lmid = (((state->min) - state->center) * 5 / 8) + state->center;
}
}
}
AlgorithmStatus OverlapAdd::process() {
EXEC_DEBUG("process()");
AlgorithmStatus status = acquireData();
EXEC_DEBUG("data acquired");
if (status != OK) {
if (!shouldStop()) return status;
int available = input("frame").available();
if (available == 0) {
return FINISHED;
}
// otherwise, there are still some frames
return CONTINUE;
}
const vector<vector<Real> >& frames = _frames.tokens();
vector<Real>& output = _output.tokens();
assert(frames.size() == 1 && (int) output.size() == _hopSize);
const vector<Real> & windowedFrame = frames[0];
if (windowedFrame.empty()) throw EssentiaException("OverlapAdd: the input frame is empty");
processFrame(_tmpFrame, windowedFrame, output, _frameHistory, _frameSize,
_hopSize, _normalizationGain);
EXEC_DEBUG("releasing");
releaseData();
EXEC_DEBUG("released");
return OK;
}
void pollCallback(polled_camera::GetPolledImage::Request& req,
polled_camera::GetPolledImage::Response& rsp,
sensor_msgs::Image& image, sensor_msgs::CameraInfo& info)
{
if (trigger_mode_ != prosilica::Software) {
rsp.success = false;
rsp.status_message = "Camera is not in software triggered mode";
return;
}
tPvFrame* frame = NULL;
try {
cam_->setBinning(req.binning_x, req.binning_y);
if (req.roi.x_offset || req.roi.y_offset || req.roi.width || req.roi.height) {
// GigE cameras use ROI in binned coordinates, so scale the values down.
// The ROI is expanded if necessary to land on binned coordinates.
unsigned int left_x = req.roi.x_offset / req.binning_x;
unsigned int top_y = req.roi.y_offset / req.binning_y;
unsigned int right_x = (req.roi.x_offset + req.roi.width + req.binning_x - 1) / req.binning_x;
unsigned int bottom_y = (req.roi.y_offset + req.roi.height + req.binning_y - 1) / req.binning_y;
unsigned int width = right_x - left_x;
unsigned int height = bottom_y - top_y;
cam_->setRoi(left_x, top_y, width, height);
} else {
cam_->setRoiToWholeFrame();
}
// Zero duration means "no timeout"
unsigned long timeout = req.timeout.isZero() ? PVINFINITE : req.timeout.toNSec() / 1e6;
frame = cam_->grab(timeout);
}
catch (prosilica::ProsilicaException &e) {
if (e.error_code == ePvErrBadSequence)
throw; // not easily recoverable
rsp.success = false;
rsp.status_message = (boost::format("Prosilica exception: %s") % e.what()).str();
return;
}
if (!frame) {
/// @todo Would be nice if grab() gave more info
rsp.success = false;
rsp.status_message = "Failed to capture frame, may have timed out";
return;
}
info = cam_info_;
image.header.frame_id = img_.header.frame_id;
if (!processFrame(frame, image, info)) {
rsp.success = false;
rsp.status_message = "Captured frame but failed to process it";
return;
}
info.roi.do_rectify = req.roi.do_rectify; // do_rectify should be preserved from request
rsp.success = true;
}
int VBoxNetLwipNAT::processGSO(PCPDMNETWORKGSO pGso, size_t cbFrame)
{
if (!PDMNetGsoIsValid(pGso, cbFrame,
cbFrame - sizeof(PDMNETWORKGSO)))
return VERR_INVALID_PARAMETER;
cbFrame -= sizeof(PDMNETWORKGSO);
uint8_t abHdrScratch[256];
uint32_t const cSegs = PDMNetGsoCalcSegmentCount(pGso,
cbFrame);
for (size_t iSeg = 0; iSeg < cSegs; iSeg++)
{
uint32_t cbSegFrame;
void *pvSegFrame =
PDMNetGsoCarveSegmentQD(pGso,
(uint8_t *)(pGso + 1),
cbFrame,
abHdrScratch,
iSeg,
cSegs,
&cbSegFrame);
int rc = processFrame(pvSegFrame, cbSegFrame);
if (RT_FAILURE(rc))
{
return rc;
}
}
return VINF_SUCCESS;
}
void AudioProcessor::updateCB(const ros::TimerEvent& timer_event)
{
result_ = channel_->getSpectrum(spectrum_, spectrum_size_, 0, fft_method_);
if (result_ == FMOD_OK)
{
now_time_ = ros::Time::now(); // try to grab as close to getting message as possible
freq_status_.tick();
if (received_first_frame_)
{
max_period_between_updates_ = std::max(max_period_between_updates_, (timer_event.current_real - timer_event.last_real).toSec());
last_callback_duration_ = timer_event.profile.last_duration.toSec();
}
received_first_frame_ = true;
consequtively_dropped_frames_ = 0;
processFrame();
}
else
{
ROS_ERROR("Could not get spectrum. (%d) : %s.", result_, FMOD_ErrorString(result_));
consequtively_dropped_frames_++;
if(consequtively_dropped_frames_ > max_dropped_frames_)
{
shutdown();
}
}
frame_count_++;
system_->update();
diagnostic_updater_.update();
}
void LeapMotionPlugin::pluginUpdate(float deltaTime, const controller::InputCalibrationData& inputCalibrationData) {
if (!_enabled) {
return;
}
const auto frame = _controller.frame();
const auto frameID = frame.id();
if (_lastFrameID >= frameID) {
// Leap Motion not connected or duplicate frame.
return;
}
if (!_hasLeapMotionBeenConnected) {
emit deviceConnected(getName());
_hasLeapMotionBeenConnected = true;
}
processFrame(frame); // Updates _joints.
auto joints = _joints;
auto userInputMapper = DependencyManager::get<controller::UserInputMapper>();
userInputMapper->withLock([&, this]() {
_inputDevice->update(deltaTime, inputCalibrationData, joints, _prevJoints);
});
_prevJoints = joints;
_lastFrameID = frameID;
}
QString TextDocumentSerializer::toSimpleHtml(QTextDocument *document)
{
this->document = document;
QTextFrame *root = document->rootFrame();
return processFrame(root);
}
/*
* QoS implementation using 8 queues for each priority and round-robin algorithm.
*/
void Switch::switchFrames()
{
while(1)
{
for (int i = 7; i >= 0; --i)
{
for (int j = 0; j <= i; ++j)
{
r.lock();
if (!queues[i].empty())
{
Frame* frame = queues[i].front();
queues[i].pop();
if(prt==true)
std::cout << frame->toString() << std::endl;
r.unlock();
processFrame(frame, frame->sourcePort);
}
else
{
r.unlock();
break;
}
}
}
}
}
void KeyframeMapper::RGBDCallback(
const ImageMsg::ConstPtr& rgb_msg,
const ImageMsg::ConstPtr& depth_msg,
const CameraInfoMsg::ConstPtr& info_msg)
{
tf::StampedTransform transform;
const ros::Time& time = rgb_msg->header.stamp;
try{
tf_listener_.waitForTransform(
fixed_frame_, rgb_msg->header.frame_id, time, ros::Duration(0.1));
tf_listener_.lookupTransform(
fixed_frame_, rgb_msg->header.frame_id, time, transform);
}
catch(...)
{
return;
}
// create a new frame and increment the counter
rgbdtools::RGBDFrame frame;
createRGBDFrameFromROSMessages(rgb_msg, depth_msg, info_msg, frame);
frame.index = rgbd_frame_index_;
rgbd_frame_index_++;
bool result = processFrame(frame, eigenAffineFromTf(transform));
if (result) publishKeyframeData(keyframes_.size() - 1);
publishPath();
}
void Application::loop()
{
// Check for key input
int key = cv::waitKey(20);
switch (key)
{
case 's':
makeScreenshots();
break;
case 'c':
clearOutputImage();
break;
case 'q':
m_isFinished = true;
}
// Grab new images from the Kinect's cameras
m_depthCamera->frameFromCamera(m_rgbImage, m_depthImage, CV_16UC1);
// Process the current frame
processFrame();
// Display the images
cv::imshow("raw", m_rgbImage);
cv::imshow("depth", m_depthImage);
cv::imshow("output", m_outputImage);
}
void UT612ByteStreamParser::processByte(uint8_t byte)
{
_byteCount++;
bool currentByteIsLinefeed = (byte == 0x0a);
bool frameIsEnding = _lastByteWasCarriageReturn && currentByteIsLinefeed;
_buffer.push_back(byte);
if (frameIsEnding && _buffer.size() >= frame_size)
{
//
// Warn on frame alignment errors
//
int bytesSinceLastFrame = _byteCount - _lastFrameByteCount;
if (bytesSinceLastFrame != frame_size)
{
std::cerr << "\nERROR - FRAME ALIGNMENT ERROR (diff=" << bytesSinceLastFrame << ")" << std::endl;
}
_lastFrameByteCount = _byteCount;
//
// Process the frame
//
std::cout << _frameCount++ << "\t";
if (_doTimestamp)
{
std::cout << getCurrentTime() << "\t";
}
try {
std::string values = processFrame(_buffer, _buffer.size() - frame_size);
std::cout << values;
}
catch (std::runtime_error & e)
{
std::cerr << "Exception: \""<< e.what() << "\"\n";
const uint8_t* d = &_buffer[_buffer.size() - frame_size];
std::cerr << "Offending bytes: " << convert2HexString(d, frame_size) << std::endl;
}
bool showHex = false;
if (showHex)
{
const uint8_t* d = &_buffer[_buffer.size() - frame_size];
std::cout << "\t" << convert2HexString(d, frame_size);
}
std::cout << std::endl;
_buffer.clear();
}
_lastByteWasCarriageReturn = (byte == 0x0d);
}
void publishImage (FlyCapture2::Image * frame)
{
//sensor_msgs::CameraInfoPtr cam_info(new sensor_msgs::CameraInfo(cam_info_->getCameraInfo()));
// or with a member variable:
cam_info_ptr_ = sensor_msgs::CameraInfoPtr(new sensor_msgs::CameraInfo(cam_info_mgr_->getCameraInfo()));
if (processFrame (frame, img_, cam_info_ptr_))
streaming_pub_.publish (img_, *cam_info_ptr_);
}
void BackgroundSuppressionShell::processNextStreamingFrame(Subject &subject, const std::string &signal, const boost::any &data)
{
AnimationFrame *pFrame = boost::any_cast<AnimationFrame*>(data);
if(pFrame != NULL)
{
mCurrentFrame = pFrame->mFrameNumber;
processFrame() && displayResults();
}
}
bool addFrame(NUI_Controller* mNui) //Data Collection for temporal Temporal Optimization
{
if (processedFrameCount>29)
return true;
else if (processedFrameCount==29)
{
for (int i=0;i<29;i++) //last frame data is already in the actual registers
{
for (int j=0;j<16;j++)
sphereRadii[j]+=radiiBuffer[i][j];
estimatedShoulderWidth+=bodySizeBuffer[i][0];
estimatedTorsoHeight+=bodySizeBuffer[i][1];
estimatedBodyHeight+=bodySizeBuffer[i][2];
}
for (int i=0;i<16;i++)
sphereRadii[i]/=30;
for (int i=10;i<12;i++) //Correct Torso, as they are measured by the same bone, and can cause errors.
sphereRadii[i]*=1.4;
for (int i=8;i<10;i++) //Correct Torso, as they are measured by the same bone, and can cause errors.
sphereRadii[i]*=1.2;
for (int i=0;i<4;i++) //Correct Torso, as they are measured by the same bone, and can cause errors.
sphereRadii[i]*=0.75;
estimatedShoulderWidth/=30;
estimatedTorsoHeight/=30;
estimatedBodyHeight/=30;
outputDataToCSV();
for (int i=0;i<29;i++) //free the buffers
{
delete[] radiiBuffer[i];
delete[] bodySizeBuffer[i];
}
//Do not forget to release Images to prevent memory leak
cvReleaseImage(&dImage);
cvReleaseImage(&uImage);
cvReleaseImage(&dImage);
processedFrameCount++;
return true;
}
else
{
if (processFrame(mNui))
{
radiiBuffer[processedFrameCount]=new float[16];
memcpy(radiiBuffer[processedFrameCount],sphereRadii,16*sizeof(float));
bodySizeBuffer[processedFrameCount]=new float[3];
bodySizeBuffer[processedFrameCount][0]=estimatedShoulderWidth;
bodySizeBuffer[processedFrameCount][1]=estimatedTorsoHeight;
bodySizeBuffer[processedFrameCount][2]=estimatedBodyHeight;
processedFrameCount++;
}
return false;
}
}
void ofxGifEncoder::doSave() {
// create a multipage bitmap
FIMULTIBITMAP *multi = FreeImage_OpenMultiBitmap(FIF_GIF, ofToDataPath(fileName).c_str(), TRUE, FALSE);
for(int i = 0; i < frames.size(); i++ ) {
ofxGifFrame * currentFrame = frames[i];
processFrame(currentFrame, multi);
}
FreeImage_CloseMultiBitmap(multi);
}
void VideoExtractor::previous(void)
{
m_mutex.lock();
m_autoPlay = false;
m_videoStream[0]->r_grab();
m_videoStream[1]->r_grab();
processFrame();
m_mutex.unlock();
}
/**
* Processes single image. The processing goes in a loop.
* It allows you to control the detection process by adjusting homography refinement switch and
* reprojection threshold in runtime.
*/
void processSingleImage(const cv::Mat& patternImage, CameraCalibration& calibration, const cv::Mat& image)
{
cv::Size frameSize(image.cols, image.rows);
ARPipeline pipeline(patternImage, calibration);
ARDrawingContext drawingCtx("Markerless AR", frameSize, calibration);
bool shouldQuit = false;
do
{
shouldQuit = processFrame(image, pipeline, drawingCtx);
} while (!shouldQuit);
}
void processSingleImage(CameraCalibration& calibration, const cv::Mat& image)
{
cv::Size frameSize(image.cols, image.rows);
std::auto_ptr<MarkerDetectionFacade> detector = createMarkerDetection(calibration);
ARDrawingContext drawingCtx("Markerless AR", frameSize, calibration);
bool shouldQuit = false;
do
{
shouldQuit = processFrame(image, detector, drawingCtx);
} while (!shouldQuit);
}
void VideoExtractor::slid(int value)
{
m_mutex.lock();
m_autoPlay = false;
m_videoStream[0]->slid(value);
m_videoStream[1]->slid(value);
processFrame();
m_mutex.unlock();
}
VideoFilter::VideoFilter(QObject *parent)
: VideoSource(parent)
, VideoConsumer()
, m_frameDirty(false)
, m_threadFps(30)
, m_fpsLimit(-1)
, m_isThreaded(false)
{
connect(&m_processTimer, SIGNAL(timeout()), this, SLOT(processFrame()));
m_processTimer.setSingleShot(true);
m_processTimer.setInterval(0);
}
bool MainThreadWebSocketChannel::processOneItemFromBuffer()
{
ASSERT(!m_suspended);
ASSERT(m_client);
ASSERT(!m_buffer.isEmpty());
WTF_LOG(Network, "MainThreadWebSocketChannel %p processBuffer() Receive buffer has %lu bytes", this, static_cast<unsigned long>(m_buffer.size()));
if (m_shouldDiscardReceivedData)
return false;
if (m_receivedClosingHandshake) {
skipBuffer(m_buffer.size());
return false;
}
if (m_handshake->mode() == WebSocketHandshake::Incomplete) {
int headerLength = m_handshake->readServerHandshake(m_buffer.data(), m_buffer.size());
if (headerLength <= 0)
return false;
if (m_handshake->mode() == WebSocketHandshake::Connected) {
if (m_identifier) {
TRACE_EVENT_INSTANT1(TRACE_DISABLED_BY_DEFAULT("devtools.timeline"), "WebSocketReceiveHandshakeResponse", "data", InspectorWebSocketEvent::data(m_document, m_identifier));
// FIXME(361045): remove InspectorInstrumentation calls once DevTools Timeline migrates to tracing.
InspectorInstrumentation::didReceiveWebSocketHandshakeResponse(m_document, m_identifier, 0, &m_handshake->serverHandshakeResponse());
}
if (m_deflateFramer.enabled() && m_document) {
const String message = "WebSocket extension \"x-webkit-deflate-frame\" is deprecated";
m_document->addConsoleMessage(ConsoleMessage::create(JSMessageSource, WarningMessageLevel, message, m_sourceURLAtConstruction, m_lineNumberAtConstruction));
}
WTF_LOG(Network, "MainThreadWebSocketChannel %p Connected", this);
skipBuffer(headerLength);
String subprotocol = m_handshake->serverWebSocketProtocol();
String extensions = m_handshake->acceptedExtensions();
m_client->didConnect(subprotocol.isNull() ? "" : subprotocol, extensions.isNull() ? "" : extensions);
WTF_LOG(Network, "MainThreadWebSocketChannel %p %lu bytes remaining in m_buffer", this, static_cast<unsigned long>(m_buffer.size()));
return !m_buffer.isEmpty();
}
ASSERT(m_handshake->mode() == WebSocketHandshake::Failed);
WTF_LOG(Network, "MainThreadWebSocketChannel %p Connection failed", this);
skipBuffer(headerLength);
m_shouldDiscardReceivedData = true;
failAsError(m_handshake->failureReason());
return false;
}
if (m_handshake->mode() != WebSocketHandshake::Connected)
return false;
return processFrame();
}
void VideoFilter::run()
{
while(!m_killed)
{
if(m_frameDirty)
{
m_frameAccessMutex.lock();
processFrame();
m_frameDirty = false;
m_frameAccessMutex.unlock();
}
msleep(1000/m_threadFps);
}
}
