ManagedShader(ResourceManager& rm, std::string vert="", std::string frag="")
: ShaderProgram(),
rm(rm),
relink(0)
{
vertex(vert);
fragment(frag);
}
void scgi_server::decode(const std::string& payload) {
// headers length
const char* p = payload.data();
char* e = nullptr;
size_t hl = std::strtoul(p, &e, 10);
if (*e != ':') {
throw scgi_payload_error{"Delimiter ':' is expected."};
}
const char* end = ++e + hl;
// headers
for (p = e; p < end; ++p) {
std::string k = fragment(p);
(*this)[k] = fragment(++p);
}
if (p != end or *p != ',') {
throw scgi_payload_error{"Broken SCGI payload."};
}
this->content = ++p;
// SCGI
auto scgi = this->find("SCGI");
if (scgi == this->end()) {
throw scgi_payload_error{"Invalid SCGI payload."};
}
else if (scgi->second != "1") {
throw scgi_payload_error{
"Unsupported protocol version: " + scgi->second
};
}
this->erase(scgi);
// CONTENT_LENGTH
auto cl = this->find("CONTENT_LENGTH");
if (cl == this->end()) {
throw scgi_payload_error{
"The \"CONTENT_LENGTH\" header must always be present,"
" even if its value is \"0\"."
};
}
this->content_length = std::strtoul(cl->second.data(), &e, 10);
if (*e != 0) {
throw scgi_payload_error{"Invalid content length."};
}
this->erase(cl);
}
ShaderManager::ShaderManager()
{
ShaderStage staticMeshVsh(GL_VERTEX_SHADER, "shaders/static_mesh.vsh");
ShaderStage staticMeshFsh(GL_FRAGMENT_SHADER, "shaders/static_mesh.fsh");
//Color mult prog
m_staticMeshShader = new UnlitTintedShaderDescription(staticMeshVsh, staticMeshFsh);
//Room prog
ShaderStage roomFragmentShader(GL_FRAGMENT_SHADER, "shaders/room.fsh");
for (int isWater = 0; isWater < 2; isWater++)
{
for (int isFlicker = 0; isFlicker < 2; isFlicker++)
{
std::ostringstream stream;
stream << "#define IS_WATER " << isWater << std::endl;
stream << "#define IS_FLICKER " << isFlicker << std::endl;
ShaderStage roomVsh(GL_VERTEX_SHADER, "shaders/room.vsh", stream.str().c_str());
m_roomShaders[isWater][isFlicker] = new UnlitTintedShaderDescription(roomVsh, roomFragmentShader);
}
}
// Entity prog
ShaderStage entityVertexShader(GL_VERTEX_SHADER, "shaders/entity.vsh");
ShaderStage entitySkinVertexShader(GL_VERTEX_SHADER, "shaders/entity_skin.vsh");
for (int i = 0; i <= MAX_NUM_LIGHTS; i++) {
std::ostringstream stream;
stream << "#define NUMBER_OF_LIGHTS " << i << std::endl;
ShaderStage fragment(GL_FRAGMENT_SHADER, "shaders/entity.fsh", stream.str().c_str());
m_entityShader[i][0] = new LitShaderDescription(entityVertexShader, fragment);
m_entityShader[i][1] = new LitShaderDescription(entitySkinVertexShader, fragment);
}
// GUI prog
ShaderStage guiVertexShader(GL_VERTEX_SHADER, "shaders/gui.vsh");
ShaderStage guiFsh(GL_FRAGMENT_SHADER, "shaders/gui.fsh");
m_gui = new GuiShaderDescription(guiVertexShader, guiFsh);
ShaderStage guiTexFsh(GL_FRAGMENT_SHADER, "shaders/gui_tex.fsh");
m_guiTextured = new GuiShaderDescription(guiVertexShader, guiTexFsh);
ShaderStage textVsh(GL_VERTEX_SHADER, "shaders/text.vsh");
ShaderStage textFsh(GL_FRAGMENT_SHADER, "shaders/text.fsh");
m_text = new TextShaderDescription(textVsh, textFsh);
ShaderStage spriteVsh(GL_VERTEX_SHADER, "shaders/sprite.vsh");
ShaderStage spriteFsh(GL_FRAGMENT_SHADER, "shaders/sprite.fsh");
m_sprites = new SpriteShaderDescription(spriteVsh, spriteFsh);
ShaderStage stencilVsh(GL_VERTEX_SHADER, "shaders/stencil.vsh");
ShaderStage stencilFsh(GL_FRAGMENT_SHADER, "shaders/stencil.fsh");
m_stencil = new UnlitShaderDescription(stencilVsh, stencilFsh);
ShaderStage debugVsh(GL_VERTEX_SHADER, "shaders/debuglines.vsh");
ShaderStage debugFsh(GL_FRAGMENT_SHADER, "shaders/debuglines.fsh");
m_debugline = new UnlitShaderDescription(debugVsh, debugFsh);
}
// Read a rule table from 'in' and filter it according to the test sentences.
//
// This involves testing TSG fragments for matches against at potential match
// sites in the set of test parse trees / forests. There are a few
// optimizations that make this reasonably fast in practice:
//
// Optimization 1
// If a rule has the same TSG fragment as the previous rule then re-use the
// result of the previous filtering decision.
//
// Optimization 2
// Test if the TSG fragment contains any symbols that don't occur in the
// symbol vocabulary of the test set. If it does then the rule can be
// discarded.
//
// Optimization 3
// Prior to filtering, a map is constructed from each distinct test set tree /
// forest vertex symbol to the set of vertices having that symbol. During
// filtering, for each rule's TSG fragment the leaf with the smallest number of
// corresponding test nodes nodes is determined. Matching is only attempted
// at those sites (this is done in MatchFragment, which has tree- and
// forest-specific implementations).
//
// Some statistics from real data (WMT14, English-German, tree-version):
//
// 4.4M Parallel sentences (source-side parsed with Berkeley parser)
// 2.7K Test sentences (newstest2014)
//
// 73.4M Original rule table size (number of distinct, composed GHKM rules)
// 22.9M Number of rules with same source-side as previous rule
// 50.5M Number of rules requiring vocabulary matching test
// 24.1M Number of rules requiring full tree matching test
// 6.7M Number of rules retained after filtering
//
void TsgFilter::Filter(std::istream &in, std::ostream &out)
{
const util::MultiCharacter delimiter("|||");
std::string line;
std::string prevLine;
StringPiece source;
bool keep = true;
int lineNum = 0;
std::vector<TreeFragmentToken> tokens;
std::vector<IdTree *> leaves;
while (std::getline(in, line)) {
++lineNum;
// Read the source-side of the rule.
util::TokenIter<util::MultiCharacter> it(line, delimiter);
// Check if this rule has the same source-side as the previous rule. If
// it does then we already know whether or not to keep the rule. This
// optimisation is based on the assumption that the rule table is sorted
// (which is the case in the standard Moses training pipeline).
if (*it == source) {
if (keep) {
out << line << std::endl;
}
continue;
}
// The source-side is different from the previous rule's.
source = *it;
// Tokenize the source-side tree fragment.
tokens.clear();
for (TreeFragmentTokenizer p(source); p != TreeFragmentTokenizer(); ++p) {
tokens.push_back(*p);
}
// Construct an IdTree representing the source-side tree fragment. This
// will fail if the fragment contains any symbols that don't occur in
// m_testVocab and in that case the rule can be discarded. In practice,
// this catches a lot of discardable rules (see comment at the top of this
// function). If the fragment is successfully created then we attempt to
// match the tree fragment against the test trees. This test is exact, but
// slow.
int i = 0;
leaves.clear();
boost::scoped_ptr<IdTree> fragment(BuildTree(tokens, i, leaves));
keep = fragment.get() && MatchFragment(*fragment, leaves);
if (keep) {
out << line << std::endl;
}
// Retain line for the next iteration (in order that the source StringPiece
// remains valid).
prevLine.swap(line);
}
}
static inline void
drawtri_horse(Image *img, Rect *r, short *a, short *b, short *c, uchar *color)
{
v4int abp_y, bcp_y, cap_y, abp, bcp, cap;
v4int abp_dx, bcp_dx, cap_dx;
v4int abp_dy, bcp_dy, cap_dy;
v4int mask;
short u0, v0;
enum { ustep = 2, vstep = 2 };
abp_dx = vec4ir(ori2i_dx(a, b));
bcp_dx = vec4ir(ori2i_dx(b, c));
cap_dx = vec4ir(ori2i_dx(c, a));
abp_dy = vec4ir(ori2i_dy(a, b));
bcp_dy = vec4ir(ori2i_dy(b, c));
cap_dy = vec4ir(ori2i_dy(c, a));
short p[2] = { r->u0, r->v0 };
abp_y = vec4ir(ori2i(a, b, p)) + vec4i(0, abp_dx[0], abp_dy[0], abp_dx[0]+abp_dy[0]);
bcp_y = vec4ir(ori2i(b, c, p)) + vec4i(0, bcp_dx[0], bcp_dy[0], bcp_dx[0]+bcp_dy[0]);
cap_y = vec4ir(ori2i(c, a, p)) + vec4i(0, cap_dx[0], cap_dy[0], cap_dx[0]+cap_dy[0]);
abp_y += topleft(a, b);
bcp_y += topleft(b, c);
cap_y += topleft(c, a);
abp_dx = abp_dx * ustep;
bcp_dx = bcp_dx * ustep;
cap_dx = cap_dx * ustep;
abp_dy = abp_dy * vstep;
bcp_dy = bcp_dy * vstep;
cap_dy = cap_dy * vstep;
for(v0 = r->v0; v0 < r->vend; v0 += vstep){
abp = abp_y;
bcp = bcp_y;
cap = cap_y;
for(u0 = r->u0; u0 < r->uend; u0 += ustep){
mask = (abp | bcp | cap) >> 31;
if((mask[0]&mask[1]&mask[2]&mask[3]) == 0){
mask |= vec4i(0, -(u0 == r->uend-1), 0, -(u0 == r->uend-1));
mask |= vec4i(0, 0, -(v0 == r->vend-1), -(v0 == r->vend-1));
fragment(img, u0, v0, *(u32int*)color, mask);
}
abp += abp_dx;
bcp += bcp_dx;
cap += cap_dx;
}
abp_y += abp_dy;
bcp_y += bcp_dy;
cap_y += cap_dy;
}
}
void FlatTextarea::processDocumentContentsChange(int position, int charsAdded) {
int32 emojiPosition = 0, emojiLen = 0;
const EmojiData *emoji = 0;
QTextDocument *doc(document());
while (true) {
int32 start = position, end = position + charsAdded;
QTextBlock from = doc->findBlock(start), till = doc->findBlock(end);
if (till.isValid()) till = till.next();
for (QTextBlock b = from; b != till; b = b.next()) {
for (QTextBlock::Iterator iter = b.begin(); !iter.atEnd(); ++iter) {
QTextFragment fragment(iter.fragment());
if (!fragment.isValid()) continue;
int32 fp = fragment.position(), fe = fp + fragment.length();
if (fp >= end || fe <= start) {
continue;
}
QString t(fragment.text());
const QChar *ch = t.constData(), *e = ch + t.size();
for (; ch != e; ++ch) {
emoji = emojiFromText(ch, e, emojiLen);
if (emoji) {
emojiPosition = fp + (ch - t.constData());
break;
}
if (ch + 1 < e && ch->isHighSurrogate() && (ch + 1)->isLowSurrogate()) ++ch;
}
if (emoji) break;
}
if (emoji) break;
}
if (emoji) {
if (!document()->pageSize().isNull()) {
document()->setPageSize(QSizeF(0, 0));
}
QTextCursor c(doc->docHandle(), emojiPosition);
c.setPosition(emojiPosition + emojiLen, QTextCursor::KeepAnchor);
int32 removedUpto = c.position();
insertEmoji(emoji, c);
charsAdded -= removedUpto - position;
position = emojiPosition + 1;
emoji = 0;
emojiPosition = 0;
} else {
break;
}
}
}
Node* Node::insertBefore(Node *newChild, Node* refChild)
{
ASSERT(0);
return nullptr;
#if 0
if (newChild == NULL) return E_INVALIDARG;
ILDOMNode *refChild;
if (V_VT(&vrefChild) == VT_NULL || V_VT(&vrefChild) == VT_EMPTY)
{
refChild = NULL;
}
else if (V_VT(&vrefChild) == VT_UNKNOWN || V_VT(&vrefChild) == VT_DISPATCH)
{
if (V_UNKNOWN(&vrefChild))
{
refChild = CComQIPtr<ILDOMNode, &IID_ILDOMNode>(V_UNKNOWN(&vrefChild));
if (refChild == NULL) return E_INVALIDARG;
}
else
refChild = NULL;
}
else
return E_INVALIDARG;
CComQIPtr<ILDOMDocumentFragment, &IID_ILDOMDocumentFragment> fragment((IUnknown*)newChild);
if (fragment)
{
CComPtr<ILDOMNode> child;
fragment->get_firstChild(&child);
while (child)
{
CComPtr<ILDOMNode> nextSibling;
child->get_nextSibling(&nextSibling);
insertNode(thisNode, child, refChild, NULL);
child = nextSibling;
}
if (pVal)
{
*pVal = NULL; // ??
}
return S_OK;
}
else
{
return insertNode(thisNode, newChild, refChild, pVal);
}
#endif
}
const PacketBuilder::FragmentPtr OutboundMessageState::getNextFragment()
{
if(!m_fragments.size())
fragment();
for(const auto& fs : m_fragments) {
if(!fs.second.sent)
return fs.first;
}
return PacketBuilder::FragmentPtr();
}
static Uri make_base(const Uri& document)
{
auto tmp = document;
if (tmp.relative())
tmp = "http://" + tmp.string();
tmp.fragment(std::string());
tmp.query(std::string());
tmp.path(filesystem::path{ tmp.path() }.remove_filename().string());
tmp.ensure_query();
return tmp;
}
bool FlatTextarea::hasText() const {
QTextDocument *doc(document());
QTextBlock from = doc->begin(), till = doc->end();
if (from == till) return false;
for (QTextBlock::Iterator iter = from.begin(); !iter.atEnd(); ++iter) {
QTextFragment fragment(iter.fragment());
if (!fragment.isValid()) continue;
if (!fragment.text().isEmpty()) return true;
}
return (from.next() != till);
}
Shader::Shader(const char* name_, const char* vertexSource, const char* fragmentSource, gl::ObjectStore& store, Defines defines)
: name(name_)
, program(store.createProgram())
, vertexShader(store.createShader(GL_VERTEX_SHADER))
, fragmentShader(store.createShader(GL_FRAGMENT_SHADER))
{
util::stopwatch stopwatch("shader compilation", Event::Shader);
if (!compileShader(vertexShader, vertexSource)) {
Log::Error(Event::Shader, "Vertex shader %s failed to compile: %s", name, vertexSource);
throw util::ShaderException(std::string { "Vertex shader " } + name + " failed to compile");
}
std::string fragment(fragmentSource);
if (defines & Defines::Overdraw) {
assert(fragment.find("#ifdef OVERDRAW_INSPECTOR") != std::string::npos);
fragment.replace(fragment.find_first_of('\n'), 1, "\n#define OVERDRAW_INSPECTOR\n");
}
if (!compileShader(fragmentShader, fragment.c_str())) {
Log::Error(Event::Shader, "Fragment shader %s failed to compile: %s", name, fragmentSource);
throw util::ShaderException(std::string { "Fragment shader " } + name + " failed to compile");
}
// Attach shaders
MBGL_CHECK_ERROR(glAttachShader(program.get(), vertexShader.get()));
MBGL_CHECK_ERROR(glAttachShader(program.get(), fragmentShader.get()));
// Bind attribute variables
MBGL_CHECK_ERROR(glBindAttribLocation(program.get(), a_pos, "a_pos"));
MBGL_CHECK_ERROR(glBindAttribLocation(program.get(), a_extrude, "a_extrude"));
MBGL_CHECK_ERROR(glBindAttribLocation(program.get(), a_offset, "a_offset"));
MBGL_CHECK_ERROR(glBindAttribLocation(program.get(), a_data, "a_data"));
MBGL_CHECK_ERROR(glBindAttribLocation(program.get(), a_texture_pos, "a_texture_pos"));
// Link program
GLint status;
MBGL_CHECK_ERROR(glLinkProgram(program.get()));
MBGL_CHECK_ERROR(glGetProgramiv(program.get(), GL_LINK_STATUS, &status));
if (status == 0) {
GLint logLength;
MBGL_CHECK_ERROR(glGetProgramiv(program.get(), GL_INFO_LOG_LENGTH, &logLength));
const auto log = std::make_unique<GLchar[]>(logLength);
if (logLength > 0) {
MBGL_CHECK_ERROR(glGetProgramInfoLog(program.get(), logLength, &logLength, log.get()));
Log::Error(Event::Shader, "Program failed to link: %s", log.get());
}
throw util::ShaderException(std::string { "Program " } + name + " failed to link: " + log.get());
}
}
bool shader_t::compile()
{
m_program_handle = 0;
GLuint vertex( compile_shader( GL_VERTEX_SHADER, m_vertex_shader_src ) );
if( vertex == 0 )
{
return false;
}
GLuint fragment( compile_shader( GL_FRAGMENT_SHADER, m_fragment_shader_src ) );
if( fragment == 0 )
{
glDeleteShader( vertex );
return false;
}
GLuint program( glCreateProgram() );
if( program == 0 )
{
glDeleteShader( vertex );
glDeleteShader( fragment );
return false;
}
glBindAttribLocation( program, Common::POSITION, "VertexPosition" );
glBindAttribLocation( program, Common::COLOR, "VertexColor" );
glAttachShader( program, vertex );
glAttachShader( program, fragment );
glLinkProgram( program );
glDeleteShader( vertex );
glDeleteShader( fragment );
GLint result;
glGetShaderiv( program, GL_LINK_STATUS, &result );
if( GL_FALSE == result )
{
log_opengl_error( program );
return false;
}
m_program_handle = program;
return true;
}
std::string URL::pathEtc() const
{
std::string res;
res.append(path());
if (hasQuery()) {
res.append("?");
res.append(query());
}
if (hasFragment()) {
res.append("#");
res.append(fragment());
}
return res;
}
void CMaterialSet::dumpSources(const CUniqueID& id)
{
atUint32 i = 0;
for (atUint32 matId : m_materials)
{
std::ofstream fragment(Athena::utility::sprintf("fs_%s_%i.txt", id.toString().c_str(), i));
CMaterial& mat = CMaterialCache::instance()->material(matId);
fragment << mat.fragmentSource().toStdString();
fragment.flush();
std::ofstream vertex(Athena::utility::sprintf("vs_%s_%i.txt", id.toString().c_str(), i));
vertex << mat.vertexSource().toStdString();
vertex.flush();
i++;
}
}
static Uri canonical(const Uri& uri, const Uri& base)
{
if (uri.absolute())
return uri;
auto temp = base;
temp.fragment(uri.fragment());
temp.query(uri.query());
auto path = filesystem::canonical(uri.path(), base.path());
if (path.has_root_name())
path = path.string().substr(path.root_name().string().length());
temp.path(path.string());
return temp;
}
/**
* Allocate a new area for the fragment from the parent sublist.
*
* @return 0 on success, non-zero on failure
*/
uintptr_t
allocateMemoryForSublistFragment(void *vmThreadRawPtr, J9VMGC_SublistFragment *fragmentPrimitive)
{
OMR_VMThread *omrVMThread = (OMR_VMThread*) vmThreadRawPtr;
MM_SublistFragment fragment(fragmentPrimitive);
MM_SublistFragment::flush(fragmentPrimitive);
MM_EnvironmentBase *env = MM_EnvironmentBase::getEnvironment(omrVMThread);
bool result = ((MM_SublistPool *)fragmentPrimitive->parentList)->allocate(env, &fragment);
if (result) {
return 0;
} else {
#if defined(OMR_GC_MODRON_SCAVENGER)
env->getExtensions()->setRememberedSetOverflowState();
#endif /* OMR_GC_MODRON_SCAVENGER */
return 1;
}
}
std::unique_ptr<unsigned> CircleValueRecognitionEngine::recognize(const IBitmapRawData & data, ImageRect const * rect)
{
if (!rect) throw invalid_argument("rect");
BitmapRawData fragment(data);
ImageRect cropRect = *rect;
++cropRect.width;
++cropRect.height;
fragment.crop(cropRect);
#ifdef _DEBUG
Debug::WriteBmp("fragment.bmp", fragment.getWidth(), fragment.getHeight(), [&](size_t x, size_t y) { return fragment.getPixel(x, y); });
#endif
std::set<unsigned> digitNumbers({ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 });
const auto num = tesseract_->recognize(fragment, digitNumbers);
if (num)
return std::make_unique<unsigned>(num->first);
return nullptr;
}
//Produção Statement
StatementNode* statement(){
printf("Statement\n");
if (lookahead == ID){
int lexema = retornaIndiceLexemaAtual();
REGISTRO *regi = retornaRegistroAtual();
IdNode* idStm = new IdNode(lexema, regi);
match(ID, followStatement, &lexema);
return statementDuasLinhas(idStm);
}else if (lookahead == IF){
match(IF,followStatement, NULL);
ExpressionNode* exp = expression();
StatementNode* stmt = statement();
StatementNode* stmtLinha = statementLinha();
return new IfNode(exp, stmt, stmtLinha);
}else if (lookahead == WHILE){
match(WHILE,followStatement, NULL);
ExpressionNode* exp = expression();
StatementNode* stmt = statement();
return new WhileNode(exp, stmt);
}else if (lookahead == WRITE){
match(WRITE,followStatement, NULL);
match(OPENPAR,followStatement, NULL);
ExpressionListNode* expList = expressionList();
match(CLOSEPAR,followStatement, NULL);
return new WriteNode(expList);
}else if (lookahead == READ){
match(READ,followStatement, NULL);
match(OPENPAR,followStatement, NULL);
ExpressionListNode* expList = expressionList();
match(CLOSEPAR,followStatement, NULL);
return new ReadNode(expList);
}else if (lookaheadPertenceFirst(NameDecl) == 1){
return namedecl();
}else if (lookaheadPertenceFirst(Fragment) == 1){
return fragment();
}else {
emiteErroSintatico(ERRO_TOKEN_INVALIDO,lookahead,retornaLinha()); return NULL;}
}
void ShaderLibrary::loadAllShaders()
{
s_shaders.insert(NoShader, 0);
QVariantMap defaultParameters;
defaultParameters.insert("Shininess", QVariant(0.5));
defaultParameters.insert("Highlights", QVariant(0.5));
setUniformVariables(NoShader, defaultParameters);
QDir dir(Preferences::ShaderDirectory());
if (!dir.exists() || !dir.isReadable()) {
QLOG_WARN() << "Could not access shader directory: " + dir.path();
return;
}
QDir::Filters filters(QDir::Files | QDir::Readable);
QStringList contents(dir.entryList(filters));
unsigned program;
QStringList::iterator iter;
for (iter = contents.begin(); iter != contents.end(); ++iter) {
QFileInfo vertex(dir, *iter);
if (vertex.suffix().contains("vert", Qt::CaseInsensitive)) {
QFileInfo fragment(dir, vertex.completeBaseName() + ".frag");
if (fragment.exists()) {
QString name(fragment.completeBaseName());
name = name.replace("_", " ");
program = createProgram(vertex.filePath(), fragment.filePath());
if (program > 0) {
QLOG_DEBUG() << "Shader compilation successful:" << name;
s_shaders.insert(name, program);
QVariantMap uniforms(parseUniformVariables(vertex.filePath()));
uniforms.unite(parseUniformVariables(fragment.filePath()));
setUniformVariables(name, uniforms);
}
}
}
}
}
/** * URI = scheme ":" hier-part [ "?" query ] [ "#" fragment ] * * foo://[email protected]:8042/over/there?name=ferret#nose * \_/ \_______________________/\_________/ \_________/ \__/ * | | | | | * scheme authority path query fragment */ inline std::tstring_t Uri::uri() const { std::tstring_t sRv; std::tstring_t temp; temp = scheme(); if (!temp.empty()) { sRv += xT(""); sRv += temp; } temp = authority(); if (!temp.empty()) { sRv += xT(":"); sRv += temp; } temp = path(); if (!temp.empty()) { sRv += xT(""); sRv += temp; } temp = query(); if (!temp.empty()) { sRv += xT("?"); sRv += temp; } temp = fragment(); if (!temp.empty()) { sRv += xT("#"); sRv += temp; } return sRv; }
void url::
user_info(const stream9::opt<boost::string_ref> &user_info)
{
rebuild(scheme(), host(), port(), path(), query(),
fragment(), user_info);
}
void RTMFPWriter::raiseMessage() {
bool header = true;
bool stop = true;
bool sent = false;
UInt64 stage = _stageAck+1;
for(RTMFPMessage* pMessage : _messagesSent) {
RTMFPMessage& message(*pMessage);
if(message.fragments.empty())
break;
// not repeat unbuffered messages
if(!message.repeatable) {
stage += message.fragments.size();
header = true;
continue;
}
/// HERE -> message repeatable AND already flushed one time!
if(stop) {
_band.flush(); // To repeat message, before we must send precedent waiting mesages
stop = false;
}
map<UInt32,UInt64>::const_iterator itFrag=message.fragments.begin();
UInt32 available = message.size()-itFrag->first;
while(itFrag!=message.fragments.end()) {
UInt32 contentSize = available;
UInt32 fragment(itFrag->first);
++itFrag;
// Compute flags
UInt8 flags = 0;
if(fragment>0)
flags |= MESSAGE_WITH_BEFOREPART; // fragmented
if(itFrag!=message.fragments.end()) {
flags |= MESSAGE_WITH_AFTERPART;
contentSize = itFrag->first - fragment;
}
UInt32 size = contentSize+4;
if(header)
size+=headerSize(stage);
// Actual sending packet is enough large? Here we send just one packet!
if(size>_band.availableToWrite()) {
if(!sent)
ERROR("Raise messages on writer ",id," without sending!");
DEBUG("Raise message on writer ",id," finishs on stage ",stage);
return;
}
sent=true;
// Write packet
size-=3; // type + timestamp removed, before the "writeMessage"
flush(_band.writeMessage(header ? 0x10 : 0x11,(UInt16)size)
,stage++,flags,header,message,fragment,contentSize);
available -= contentSize;
header=false;
}
}
if(stop)
_trigger.stop();
}
// -----------------------------------------------------------------------------
// CBrCtlSampleAppLinkResolver::GetFileNameL
// Translate the file name from a URL to a valid file name in the system.
// -----------------------------------------------------------------------------
//
TBool
CBrCtlSampleAppLinkResolver::GetFileNameL(const TDesC& aFileName)
{
// This function accepts URLs in the following format:
// file://filename.xxx
// file:///filename.xxx
// file://c:/filename.xxx
// file:///c:/filename.xxx
//
_LIT(KFileScheme, "file://");
_LIT(KDefaultDrivePath, "C:\\");
_LIT(KPathChar, "\\");
TInt count;
TInt index = 0;
TBool drvLetter = EFalse;
TUint16 c;
// Verify the file scheme
TPtrC urlPtr(aFileName);
if (urlPtr.FindF(KFileScheme) != 0)
{
return EFalse;
}
urlPtr.Set(urlPtr.Mid(KFileScheme().Length()));
// make sure there are enough characters in the filename before
// trying to check them
count = urlPtr.Length();
if(count == 0)
{
return EFalse; // no filename, so can't look at urlPtr[0]
}
// Skip the first '/' if there is one
if (urlPtr[0] == '/')
{
urlPtr.Set(urlPtr.Mid(1));
}
count = urlPtr.Length();
// Is there a drive letter?
if(count > 1)
{
// can check for drive letter
if (urlPtr[1 + index] == ':')
{
drvLetter = ETrue;
}
}
if(drvLetter == EFalse)
{
// 3 additional characters for the string "c:\"
count = urlPtr.Length() + 3;
}
iFileName = HBufC::NewL(count);
if (!drvLetter)
{
iFileName->Des().Append(KDefaultDrivePath);
}
TBool fragment(EFalse);
// Convert relative path containing /./ and /../ to absolute path
for (; index < urlPtr.Length() && !fragment; index ++)
{
switch(urlPtr[index])
{
case '#': //Check if there is a fragment '#'
{
fragment = ETrue;
continue; // Just stop there
}
case '/':
{
iFileName->Des().Append(KPathChar);
break;
}
case '.':
{
if (index > 1 && urlPtr[index - 1] == '/')
{
if (index < count - 1 && urlPtr[index + 1] == '/')
{
index ++; // skip ./
break;
}
if (index > 2 && index < count - 3 &&
urlPtr[index + 1] == '.' && urlPtr[index + 2] == '/')
{
TInt i = index - 2;
for (; i > 0 && urlPtr[i] != '/'; i--) {} // skip /../
iFileName->Des().SetLength(iFileName->Des().Length() - (index - i));
index += 2;
break;
}
}
}
// no break
//lint -fallthrough
default:
{
c = urlPtr[index];
iFileName->Des().Append(&c, 1);
break;
}
} // end of switch
}
return ETrue;
}
void GGLAssembler::build_blending(
component_t& temp, // incomming fragment / output
const pixel_t& pixel, // framebuffer
int component,
Scratch& regs)
{
if (!mInfo[component].blend)
return;
int fs = component==GGLFormat::ALPHA ? mBlendSrcA : mBlendSrc;
int fd = component==GGLFormat::ALPHA ? mBlendDstA : mBlendDst;
if (fs==GGL_SRC_ALPHA_SATURATE && component==GGLFormat::ALPHA)
fs = GGL_ONE;
const int blending = blending_codes(fs, fd);
if (!temp.size()) {
// here, blending will produce something which doesn't depend on
// that component (eg: GL_ZERO:GL_*), so the register has not been
// allocated yet. Will never be used as a source.
temp = component_t(regs.obtain(), CORRUPTIBLE);
}
// we are doing real blending...
// fb: extracted dst
// fragment: extracted src
// temp: component_t(fragment) and result
// scoped register allocator
Scratch scratches(registerFile());
comment("blending");
// we can optimize these cases a bit...
// (1) saturation is not needed
// (2) we can use only one multiply instead of 2
// (3) we can reduce the register pressure
// R = S*f + D*(1-f) = (S-D)*f + D
// R = S*(1-f) + D*f = (D-S)*f + S
const bool same_factor_opt1 =
(fs==GGL_DST_COLOR && fd==GGL_ONE_MINUS_DST_COLOR) ||
(fs==GGL_SRC_COLOR && fd==GGL_ONE_MINUS_SRC_COLOR) ||
(fs==GGL_DST_ALPHA && fd==GGL_ONE_MINUS_DST_ALPHA) ||
(fs==GGL_SRC_ALPHA && fd==GGL_ONE_MINUS_SRC_ALPHA);
const bool same_factor_opt2 =
(fs==GGL_ONE_MINUS_DST_COLOR && fd==GGL_DST_COLOR) ||
(fs==GGL_ONE_MINUS_SRC_COLOR && fd==GGL_SRC_COLOR) ||
(fs==GGL_ONE_MINUS_DST_ALPHA && fd==GGL_DST_ALPHA) ||
(fs==GGL_ONE_MINUS_SRC_ALPHA && fd==GGL_SRC_ALPHA);
// XXX: we could also optimize these cases:
// R = S*f + D*f = (S+D)*f
// R = S*(1-f) + D*(1-f) = (S+D)*(1-f)
// R = S*D + D*S = 2*S*D
// see if we need to extract 'component' from the destination (fb)
integer_t fb;
if (blending & (BLEND_DST|FACTOR_DST)) {
fb.setTo(scratches.obtain(), 32);
extract(fb, pixel, component);
if (mDithering) {
// XXX: maybe what we should do instead, is simply
// expand fb -or- fragment to the larger of the two
if (fb.size() < temp.size()) {
// for now we expand 'fb' to min(fragment, 8)
int new_size = temp.size() < 8 ? temp.size() : 8;
expand(fb, fb, new_size);
}
}
}
// convert input fragment to integer_t
if (temp.l && (temp.flags & CORRUPTIBLE)) {
MOV(AL, 0, temp.reg, reg_imm(temp.reg, LSR, temp.l));
temp.h -= temp.l;
temp.l = 0;
}
integer_t fragment(temp.reg, temp.size(), temp.flags);
// if not done yet, convert input fragment to integer_t
if (temp.l) {
// here we know temp is not CORRUPTIBLE
fragment.reg = scratches.obtain();
MOV(AL, 0, fragment.reg, reg_imm(temp.reg, LSR, temp.l));
fragment.flags |= CORRUPTIBLE;
}
if (!(temp.flags & CORRUPTIBLE)) {
// temp is not corruptible, but since it's the destination it
// will be modified, so we need to allocate a new register.
temp.reg = regs.obtain();
temp.flags &= ~CORRUPTIBLE;
fragment.flags &= ~CORRUPTIBLE;
}
if ((blending & BLEND_SRC) && !same_factor_opt1) {
// source (fragment) is needed for the blending stage
// so it's not CORRUPTIBLE (unless we're doing same_factor_opt1)
fragment.flags &= ~CORRUPTIBLE;
}
if (same_factor_opt1) {
// R = S*f + D*(1-f) = (S-D)*f + D
integer_t factor;
build_blend_factor(factor, fs,
component, pixel, fragment, fb, scratches);
// fb is always corruptible from this point
fb.flags |= CORRUPTIBLE;
build_blendFOneMinusF(temp, factor, fragment, fb);
} else if (same_factor_opt2) {
// R = S*(1-f) + D*f = (D-S)*f + S
integer_t factor;
// fb is always corrruptible here
fb.flags |= CORRUPTIBLE;
build_blend_factor(factor, fd,
component, pixel, fragment, fb, scratches);
build_blendOneMinusFF(temp, factor, fragment, fb);
} else {
integer_t src_factor;
integer_t dst_factor;
// if destination (fb) is not needed for the blending stage,
// then it can be marked as CORRUPTIBLE
if (!(blending & BLEND_DST)) {
fb.flags |= CORRUPTIBLE;
}
// XXX: try to mark some registers as CORRUPTIBLE
// in most case we could make those corruptible
// when we're processing the last component
// but not always, for instance
// when fragment is constant and not reloaded
// when fb is needed for logic-ops or masking
// when a register is aliased (for instance with mAlphaSource)
// blend away...
if (fs==GGL_ZERO) {
if (fd==GGL_ZERO) { // R = 0
// already taken care of
} else if (fd==GGL_ONE) { // R = D
// already taken care of
} else { // R = D*fd
// compute fd
build_blend_factor(dst_factor, fd,
component, pixel, fragment, fb, scratches);
mul_factor(temp, fb, dst_factor);
}
} else if (fs==GGL_ONE) {
if (fd==GGL_ZERO) { // R = S
// NOP, taken care of
} else if (fd==GGL_ONE) { // R = S + D
component_add(temp, fb, fragment); // args order matters
component_sat(temp);
} else { // R = S + D*fd
// compute fd
build_blend_factor(dst_factor, fd,
component, pixel, fragment, fb, scratches);
mul_factor_add(temp, fb, dst_factor, component_t(fragment));
component_sat(temp);
}
} else {
// compute fs
build_blend_factor(src_factor, fs,
component, pixel, fragment, fb, scratches);
if (fd==GGL_ZERO) { // R = S*fs
mul_factor(temp, fragment, src_factor);
} else if (fd==GGL_ONE) { // R = S*fs + D
mul_factor_add(temp, fragment, src_factor, component_t(fb));
component_sat(temp);
} else { // R = S*fs + D*fd
mul_factor(temp, fragment, src_factor);
if (scratches.isUsed(src_factor.reg))
scratches.recycle(src_factor.reg);
// compute fd
build_blend_factor(dst_factor, fd,
component, pixel, fragment, fb, scratches);
mul_factor_add(temp, fb, dst_factor, temp);
if (!same_factor_opt1 && !same_factor_opt2) {
component_sat(temp);
}
}
}
}
// now we can be corrupted (it's the dest)
temp.flags |= CORRUPTIBLE;
}
void FlowWriter::raiseMessage() {
list<Message*>::const_iterator it;
bool header = true;
bool stop = true;
bool sent = false;
UInt64 stage = _stageAck+1;
for(it=_messagesSent.begin();it!=_messagesSent.end();++it) {
Message& message(**it);
if(message.fragments.empty())
break;
// not repeat unbuffered messages
if(!message.repeatable) {
stage += message.fragments.size();
header = true;
continue;
}
/// HERE -> message repeatable AND already flushed one time!
if(stop) {
_band.flush(false); // To repeat message, before we must send precedent waiting mesages
stop = false;
}
std::map<UInt32,UInt64>::const_iterator
itFrag=message.fragments.begin();
UInt32 available;
BinaryReader& content = message.reader(available);
while(itFrag!=message.fragments.end()) {
UInt32 contentSize = available;
UInt32 fragment(itFrag->first);
++itFrag;
// Compute flags
UInt8 flags = 0;
if(fragment>0)
flags |= MESSAGE_WITH_BEFOREPART; // fragmented
if(itFrag!=message.fragments.end()) {
flags |= MESSAGE_WITH_AFTERPART;
contentSize = itFrag->first - fragment;
}
UInt32 size = contentSize+4;
if(header)
size+=headerSize(stage);
// Actual sending packet is enough large? Here we send just one packet!
if(size>_band.writer().available()) {
if(!sent)
ERROR("Raise messages on flowWriter %s without sending!",NumberFormatter::format(id).c_str());
DEBUG("Raise message on flowWriter %s finishs on stage %s",NumberFormatter::format(id).c_str(),NumberFormatter::format(stage).c_str());
return;
}
sent=true;
// Write packet
size-=3; // type + timestamp removed, before the "writeMessage"
flush(_band.writeMessage(header ? 0x10 : 0x11,(UInt16)size)
,stage++,flags,header,content,contentSize);
available -= contentSize;
header=false;
}
}
if(stop)
_trigger.stop();
}
void url::
scheme(const boost::string_ref &scheme)
{
rebuild(scheme, host(), port(), path(), query(), fragment(), user_info());
}
void url::
port(const stream9::opt<uint16_t> port)
{
rebuild(scheme(), host(), port,
path(), query(), fragment(), user_info());
}
QString FlatTextarea::getText(int32 start, int32 end) const {
if (end >= 0 && end <= start) return QString();
if (start < 0) start = 0;
bool full = (start == 0) && (end < 0);
QTextDocument *doc(document());
QTextBlock from = full ? doc->begin() : doc->findBlock(start), till = (end < 0) ? doc->end() : doc->findBlock(end);
if (till.isValid()) till = till.next();
int32 possibleLen = 0;
for (QTextBlock b = from; b != till; b = b.next()) {
possibleLen += b.length();
}
QString result;
result.reserve(possibleLen + 1);
if (!full && end < 0) {
end = possibleLen;
}
for (QTextBlock b = from; b != till; b = b.next()) {
for (QTextBlock::Iterator iter = b.begin(); !iter.atEnd(); ++iter) {
QTextFragment fragment(iter.fragment());
if (!fragment.isValid()) continue;
int32 p = full ? 0 : fragment.position(), e = full ? 0 : (p + fragment.length());
if (!full) {
if (p >= end || e <= start) {
continue;
}
}
QTextCharFormat f = fragment.charFormat();
QString emojiText;
QString t(fragment.text());
if (!full) {
if (p < start) {
t = t.mid(start - p, end - start);
} else if (e > end) {
t = t.mid(0, end - p);
}
}
QChar *ub = t.data(), *uc = ub, *ue = uc + t.size();
for (; uc != ue; ++uc) {
switch (uc->unicode()) {
case 0xfdd0: // QTextBeginningOfFrame
case 0xfdd1: // QTextEndOfFrame
case QChar::ParagraphSeparator:
case QChar::LineSeparator:
*uc = QLatin1Char('\n');
break;
case QChar::Nbsp:
*uc = QLatin1Char(' ');
break;
case QChar::ObjectReplacementCharacter:
if (emojiText.isEmpty() && f.isImageFormat()) {
QString imageName = static_cast<QTextImageFormat*>(&f)->name();
if (imageName.startsWith(QLatin1String("emoji://e."))) {
if (EmojiPtr emoji = emojiFromUrl(imageName)) {
emojiText = textEmojiString(emoji);
}
}
}
if (uc > ub) result.append(ub, uc - ub);
if (!emojiText.isEmpty()) result.append(emojiText);
ub = uc + 1;
break;
}
}
if (uc > ub) result.append(ub, uc - ub);
}
result.append('\n');
}
result.chop(1);
return result;
}
void RTMFPWriter::acknowledgment(PacketReader& packet) {
UInt64 bufferSize = packet.read7BitLongValue(); // TODO use this value in reliability mechanism?
if(bufferSize==0) {
// In fact here, we should send a 0x18 message (with id flow),
// but it can create a loop... We prefer the following behavior
fail("Negative acknowledgment");
return;
}
UInt64 stageAckPrec = _stageAck;
UInt64 stageReaden = packet.read7BitLongValue();
UInt64 stage = _stageAck+1;
if(stageReaden>_stage) {
ERROR("Acknowledgment received ",stageReaden," superior than the current sending stage ",_stage," on writer ",id);
_stageAck = _stage;
} else if(stageReaden<=_stageAck) {
// already acked
if(packet.available()==0)
DEBUG("Acknowledgment ",stageReaden," obsolete on writer ",id);
} else
_stageAck = stageReaden;
UInt64 maxStageRecv = stageReaden;
UInt32 pos=packet.position();
while(packet.available()>0)
maxStageRecv += packet.read7BitLongValue()+packet.read7BitLongValue()+2;
if(pos != packet.position()) {
// TRACE(stageReaden,"..x"Util::FormatHex(reader.current(),reader.available()));
packet.reset(pos);
}
UInt64 lostCount = 0;
UInt64 lostStage = 0;
bool repeated = false;
bool header = true;
bool stop=false;
auto it=_messagesSent.begin();
while(!stop && it!=_messagesSent.end()) {
RTMFPMessage& message(**it);
if(message.fragments.empty()) {
CRITIC("RTMFPMessage ",(stage+1)," is bad formatted on fowWriter ",id);
++it;
continue;
}
map<UInt32,UInt64>::iterator itFrag=message.fragments.begin();
while(message.fragments.end()!=itFrag) {
// ACK
if(_stageAck>=stage) {
message.fragments.erase(message.fragments.begin());
itFrag=message.fragments.begin();
++_ackCount;
++stage;
continue;
}
// Read lost informations
while(!stop) {
if(lostCount==0) {
if(packet.available()>0) {
lostCount = packet.read7BitLongValue()+1;
lostStage = stageReaden+1;
stageReaden = lostStage+lostCount+packet.read7BitLongValue();
} else {
stop=true;
break;
}
}
// check the range
if(lostStage>_stage) {
// Not yet sent
ERROR("Lost information received ",lostStage," have not been yet sent on writer ",id);
stop=true;
} else if(lostStage<=_stageAck) {
// already acked
--lostCount;
++lostStage;
continue;
}
break;
}
if(stop)
break;
// lostStage > 0 and lostCount > 0
if(lostStage!=stage) {
if(repeated) {
++stage;
++itFrag;
header=true;
} else // No repeated, it means that past lost packet was not repeatable, we can ack this intermediate received sequence
_stageAck = stage;
continue;
}
/// Repeat message asked!
if(!message.repeatable) {
if(repeated) {
++itFrag;
++stage;
header=true;
} else {
INFO("RTMFPWriter ",id," : message ",stage," lost");
--_ackCount;
++_lostCount;
_stageAck = stage;
}
--lostCount;
++lostStage;
continue;
}
repeated = true;
// Don't repeate before that the receiver receives the itFrag->second sending stage
if(itFrag->second >= maxStageRecv) {
++stage;
header=true;
--lostCount;
++lostStage;
++itFrag;
continue;
}
// Repeat message
DEBUG("RTMFPWriter ",id," : stage ",stage," repeated");
UInt32 fragment(itFrag->first);
itFrag->second = _stage; // Save actual stage sending to wait that the receiver gets it before to retry
UInt32 contentSize = message.size() - fragment; // available
++itFrag;
// Compute flags
UInt8 flags = 0;
if(fragment>0)
flags |= MESSAGE_WITH_BEFOREPART; // fragmented
if(itFrag!=message.fragments.end()) {
flags |= MESSAGE_WITH_AFTERPART;
contentSize = itFrag->first - fragment;
}
UInt32 size = contentSize+4;
UInt32 availableToWrite(_band.availableToWrite());
if(!header && size>availableToWrite) {
_band.flush();
header=true;
}
if(header)
size+=headerSize(stage);
if(size>availableToWrite)
_band.flush();
// Write packet
size-=3; // type + timestamp removed, before the "writeMessage"
flush(_band.writeMessage(header ? 0x10 : 0x11,(UInt16)size)
,stage,flags,header,message,fragment,contentSize);
header=false;
--lostCount;
++lostStage;
++stage;
}
if(message.fragments.empty()) {
if(message.repeatable)
--_repeatable;
if(_ackCount || _lostCount) {
_qos.add(_lostCount / (_lostCount + _ackCount));
_ackCount=_lostCount=0;
}
delete *it;
it=_messagesSent.erase(it);
} else
++it;
}
if(lostCount>0 && packet.available()>0)
ERROR("Some lost information received have not been yet sent on writer ",id);
// rest messages repeatable?
if(_repeatable==0)
_trigger.stop();
else if(_stageAck>stageAckPrec || repeated)
_trigger.reset();
}
// -----------------------------------------------------------------------------
// CWidgetUiObserver::TranslateURLToFilenameL
// Translate the file name from a URL to a valid file name in the system.
// -----------------------------------------------------------------------------
//
TBool CWidgetUiObserver::TranslateURLToFilenameL( const TDesC& aFileName, const TDesC& aLanguageDir )
{
// This function accepts URLs in the following format:
// file://filename.xxx
// file:///filename.xxx
// file://c:/filename.xxx
// file:///c:/filename.xxx
// c:/dir/file.txt (the browser engine can send these too!)
TInt count( 0 );
TInt index( 0 );
TBool drvLetter = EFalse;
TUint16 c;
HBufC* decodedUrl = EscapeUtils::EscapeDecodeL(aFileName);
CleanupStack::PushL( decodedUrl );
// Throw away the intial file:// part, if present
TPtrC urlPtr( aFileName );
if (urlPtr.FindF( KFileScheme) == 0 )
{
urlPtr.Set( decodedUrl->Mid( KFileScheme().Length() ) );
}
// Make sure there are enough characters in the filename before
// trying to check them
count = urlPtr.Length() + aLanguageDir.Length() + KLprojExt().Length() + KPathChar().Length();
if ( urlPtr.Length() > 0 ) //do nothing for trivial input
{
// Skip the first '/' if there is one
if ( urlPtr[0] == '/' )
{
urlPtr.Set( urlPtr.Mid( 1 ) );
}
// Is there a drive letter?
if ( urlPtr.Length() > 1 )
{
// Can check for drive letter
if ( urlPtr[1 + index] == ':' )
{
drvLetter = ETrue;
}
}
if ( drvLetter == EFalse )
{
// Plan for a c:\ type drive prefix to what we already tallied above
count += KDefaultDrivePath().Length();
}
delete iFileName;
iFileName = NULL;
iFileName = HBufC::NewL( count );
if ( !drvLetter )
{
iFileName->Des().Append( KDefaultDrivePath );
}
TBool fragment( EFalse );
// Convert relative path containing /./ and /../ to absolute path
for ( ; index < urlPtr.Length() && !fragment; index ++ )
{
switch ( urlPtr[index] )
{
case '#': // Check if there is a fragment '#'
{
fragment = ETrue;
continue; // Just stop there
}
case '/':
{
iFileName->Des().Append( KPathChar );
break;
}
case '.':
{
if ( index > 1 && urlPtr[index - 1] == '/' )
{
if ( index < count - 1 && urlPtr[ index + 1 ] == '/' )
{
index ++; // Skip ./
break;
}
if ( index > 2 && index < count - 3 &&
urlPtr[ index + 1 ] == '.' && urlPtr[ index + 2 ] == '/' )
{
TInt i = index - 2;
for ( ; i > 0 && urlPtr[i] != '/'; i-- ) {} // Skip /../
iFileName->Des().SetLength( iFileName->Des().Length() - (index - i) );
index += 2;
break;
}
}
}
// No break
//lint -fallthrough
default:
{
c = urlPtr[ index ];
iFileName->Des().Append( &c, 1 );
break;
}
} // end of switch
}
if ( aLanguageDir.Length() )
{
TChar backSlash = '\\';
TInt pos = iFileName->Des().LocateReverse( backSlash );
if ( pos != KErrNotFound )
{
TPtr p = iFileName->Des();
p.Insert(pos, KLprojExt );
p.Insert(pos, aLanguageDir );
p.Insert(pos, KPathChar );
}
}
} //Do nothing for any trivial input
CleanupStack::PopAndDestroy(1, decodedUrl); // decodedUrl
return ETrue;
}
