bool SkPNGImageDecoder::onDecode(SkStream* sk_stream, SkBitmap* decodedBitmap, Mode mode) { png_structp png_ptr; png_infop info_ptr; if (onDecodeInit(sk_stream, &png_ptr, &info_ptr) == false) { return false; } if (setjmp(png_jmpbuf(png_ptr))) { return false; } PNGAutoClean autoClean(png_ptr, info_ptr); png_uint_32 origWidth, origHeight; int bit_depth, color_type, interlace_type; png_get_IHDR(png_ptr, info_ptr, &origWidth, &origHeight, &bit_depth, &color_type, &interlace_type, int_p_NULL, int_p_NULL); SkBitmap::Config config; bool hasAlpha = false; bool doDither = this->getDitherImage(); SkPMColor theTranspColor = 0; // 0 tells us not to try to match if (getBitmapConfig(png_ptr, info_ptr, &config, &hasAlpha, &doDither, &theTranspColor) == false) { return false; } const int sampleSize = this->getSampleSize(); SkScaledBitmapSampler sampler(origWidth, origHeight, sampleSize); decodedBitmap->setConfig(config, sampler.scaledWidth(), sampler.scaledHeight(), 0); if (SkImageDecoder::kDecodeBounds_Mode == mode) { return true; } // from here down we are concerned with colortables and pixels // we track if we actually see a non-opaque pixels, since sometimes a PNG sets its colortype // to |= PNG_COLOR_MASK_ALPHA, but all of its pixels are in fact opaque. We care, since we // draw lots faster if we can flag the bitmap has being opaque bool reallyHasAlpha = false; SkColorTable* colorTable = NULL; if (color_type == PNG_COLOR_TYPE_PALETTE) { decodePalette(png_ptr, info_ptr, &hasAlpha, &reallyHasAlpha, &colorTable); } SkAutoUnref aur(colorTable); if (!this->allocPixelRef(decodedBitmap, SkBitmap::kIndex8_Config == config ? colorTable : NULL)) { return false; } SkAutoLockPixels alp(*decodedBitmap); /* Add filler (or alpha) byte (before/after each RGB triplet) */ if (color_type == PNG_COLOR_TYPE_RGB || color_type == PNG_COLOR_TYPE_GRAY) { png_set_filler(png_ptr, 0xff, PNG_FILLER_AFTER); } /* Turn on interlace handling. REQUIRED if you are not using * png_read_image(). To see how to handle interlacing passes, * see the png_read_row() method below: */ const int number_passes = interlace_type != PNG_INTERLACE_NONE ? png_set_interlace_handling(png_ptr) : 1; /* Optional call to gamma correct and add the background to the palette * and update info structure. REQUIRED if you are expecting libpng to * update the palette for you (ie you selected such a transform above). */ png_read_update_info(png_ptr, info_ptr); if (SkBitmap::kIndex8_Config == config && 1 == sampleSize) { for (int i = 0; i < number_passes; i++) { for (png_uint_32 y = 0; y < origHeight; y++) { uint8_t* bmRow = decodedBitmap->getAddr8(0, y); png_read_rows(png_ptr, &bmRow, png_bytepp_NULL, 1); } } } else { SkScaledBitmapSampler::SrcConfig sc; int srcBytesPerPixel = 4; if (colorTable != NULL) { sc = SkScaledBitmapSampler::kIndex; srcBytesPerPixel = 1; } else if (hasAlpha) { sc = SkScaledBitmapSampler::kRGBA; } else { sc = SkScaledBitmapSampler::kRGBX; } /* We have to pass the colortable explicitly, since we may have one even if our decodedBitmap doesn't, due to the request that we upscale png's palette to a direct model */ SkAutoLockColors ctLock(colorTable); if (!sampler.begin(decodedBitmap, sc, doDither, ctLock.colors())) { return false; } const int height = decodedBitmap->height(); if (number_passes > 1) { SkAutoMalloc storage(origWidth * origHeight * srcBytesPerPixel); uint8_t* base = (uint8_t*)storage.get(); size_t rb = origWidth * srcBytesPerPixel; for (int i = 0; i < number_passes; i++) { uint8_t* row = base; for (png_uint_32 y = 0; y < origHeight; y++) { uint8_t* bmRow = row; png_read_rows(png_ptr, &bmRow, png_bytepp_NULL, 1); row += rb; } } // now sample it base += sampler.srcY0() * rb; for (int y = 0; y < height; y++) { reallyHasAlpha |= sampler.next(base); base += sampler.srcDY() * rb; } } else { SkAutoMalloc storage(origWidth * srcBytesPerPixel); uint8_t* srcRow = (uint8_t*)storage.get(); skip_src_rows(png_ptr, srcRow, sampler.srcY0()); for (int y = 0; y < height; y++) { uint8_t* tmp = srcRow; png_read_rows(png_ptr, &tmp, png_bytepp_NULL, 1); reallyHasAlpha |= sampler.next(srcRow); if (y < height - 1) { skip_src_rows(png_ptr, srcRow, sampler.srcDY() - 1); } } // skip the rest of the rows (if any) png_uint_32 read = (height - 1) * sampler.srcDY() + sampler.srcY0() + 1; SkASSERT(read <= origHeight); skip_src_rows(png_ptr, srcRow, origHeight - read); } } /* read rest of file, and get additional chunks in info_ptr - REQUIRED */ png_read_end(png_ptr, info_ptr); if (0 != theTranspColor) { reallyHasAlpha |= substituteTranspColor(decodedBitmap, theTranspColor); } decodedBitmap->setIsOpaque(!reallyHasAlpha); return true; }
MetaData::typed_data::typed_data(const typed_data &from) : mType(from.mType), mSize(0) { allocateStorage(from.mSize); memcpy(storage(), from.storage(), mSize); }
void OrthoBuilder::LUsolve( vector<vector<PL_NUM>>& AA, vector<PL_NUM>& ff, vector<PL_NUM>* xx ) { if( AA.size() < 1 ) { cout << "ERROR in LUsolve: AA.size() is less than 1\n"; return; } int AAsize = AA.size(); vector<PL_NUM> storage( AAsize, 0.0 ); PL_NUM tmpNum = 0; int nzRow = 0; if( fabs( AA[0][0] ) < ALMOST_ZERO ) //TODO may be I can join this and the next block. I mean the checks on AA[i][j] != 0 { //make AA[0][0] nonzero by changing the order of rows int nzFound = false; for( nzRow; nzRow < AAsize; ++nzRow ) { if( fabs( AA[nzRow][0] ) > ALMOST_ZERO ) //CHECK, may be it is better to put != 0 here { nzFound = true; break; } } if( nzFound == false ) { cout << "ERROR in LUsolve: no nonzero elements found\n"; return; } for( int col = 0; col < AAsize; ++col ) { storage[col] = AA[nzRow][col]; AA[nzRow][col] = AA[0][col]; AA[0][col] = storage[col]; } tmpNum = ff[nzRow]; ff[nzRow] = ff[0]; ff[0] = tmpNum; } for( int i = 0; i < AAsize; ++i ) { if( fabs( AA[i][i] ) < ALMOST_ZERO ) //TODO may be there should be fabs( ) < DELTA? { for( int row = i + 1; row < AAsize; ++row ) { if( fabs( AA[row][i] ) > ALMOST_ZERO ) //TODO may be there should be fabs( ) > DELTA? { for( int col = 0; col < AAsize; ++col ) { storage[col] = AA[row][col]; //TODO may be we don't need a whole vector here, just single number. (I mean storage) AA[row][col] = AA[i][col]; AA[i][col] = storage[col]; } tmpNum = ff[row]; ff[row] = ff[i]; ff[i] = tmpNum; break; } } } } for( int i = 0; i < AAsize; ++i ) { if( fabs( AA[i][i] ) < ALMOST_ZERO ) { cout << "alert! UFO detected!\n"; } } vector<vector<PL_NUM>> LL( AAsize, vector<PL_NUM>( AAsize, 0.0 ) ); //TODO here we can use less memory, UU and LL are trialgular vector<vector<PL_NUM>> UU( AAsize, vector<PL_NUM>( AAsize, 0.0 ) ); //TODO initialization of arrays is slow //Crout's algorithm, theory is in book: Kincaid, Cheney - Numerical analysis: mathematics of scientific computing for( int k = 0; k < AAsize; ++k ) { UU[k][k] = 1; for( int i = k; i < AAsize; ++i ) { LL[i][k] = AA[i][k]; for( int s = 0; s <= k - 1; ++s ) { LL[i][k] -= LL[i][s] * UU[s][k]; } } for( int j = k + 1; j < AAsize; ++j ) { UU[k][j] = AA[k][j]; for( int s = 0; s <= k - 1; ++s ) { UU[k][j] -= LL[k][s] * UU[s][j]; } UU[k][j] /= LL[k][k]; } } //now we can find xx, by solving LL * zz = ff and then UU * x = zz; for theory look at the same book as for LU decomposition for( int i = 0; i < AAsize; ++i ) { (*xx)[i] = ff[i]; for( int j = 0; j <= i - 1; ++j ) { (*xx)[i] -= LL[i][j] * (*xx)[j]; } (*xx)[i] /= LL[i][i]; } for( int i = AAsize - 1; i >= 0; --i ) { for( int j = i + 1; j < AAsize; ++j ) { (*xx)[i] -= UU[i][j] * (*xx)[j]; } } }
void Font::drawGlyphs(GraphicsContext* gc, const SimpleFontData* font, const GlyphBuffer& glyphBuffer, unsigned from, unsigned numGlyphs, const FloatPoint& point, const FloatRect& textRect) const { SkScalar x = SkFloatToScalar(point.x()); SkScalar y = SkFloatToScalar(point.y()); const OpenTypeVerticalData* verticalData = font->verticalData(); if (font->platformData().orientation() == Vertical && verticalData) { SkAutoSTMalloc<32, SkPoint> storage(numGlyphs); SkPoint* pos = storage.get(); AffineTransform savedMatrix = gc->getCTM(); gc->concatCTM(AffineTransform(0, -1, 1, 0, point.x(), point.y())); gc->concatCTM(AffineTransform(1, 0, 0, 1, -point.x(), -point.y())); const unsigned kMaxBufferLength = 256; Vector<FloatPoint, kMaxBufferLength> translations; const FontMetrics& metrics = font->fontMetrics(); SkScalar verticalOriginX = SkFloatToScalar(point.x() + metrics.floatAscent() - metrics.floatAscent(IdeographicBaseline)); float horizontalOffset = point.x(); unsigned glyphIndex = 0; while (glyphIndex < numGlyphs) { unsigned chunkLength = std::min(kMaxBufferLength, numGlyphs - glyphIndex); const Glyph* glyphs = glyphBuffer.glyphs(from + glyphIndex); translations.resize(chunkLength); verticalData->getVerticalTranslationsForGlyphs(font, &glyphs[0], chunkLength, reinterpret_cast<float*>(&translations[0])); x = verticalOriginX; y = SkFloatToScalar(point.y() + horizontalOffset - point.x()); float currentWidth = 0; for (unsigned i = 0; i < chunkLength; ++i, ++glyphIndex) { pos[i].set( x + SkIntToScalar(lroundf(translations[i].x())), y + -SkIntToScalar(-lroundf(currentWidth - translations[i].y()))); currentWidth += glyphBuffer.advanceAt(from + glyphIndex); } horizontalOffset += currentWidth; paintGlyphs(gc, font, glyphs, chunkLength, pos, textRect); } gc->setCTM(savedMatrix); return; } if (!glyphBuffer.hasOffsets()) { SkAutoSTMalloc<64, SkScalar> storage(numGlyphs); SkScalar* xpos = storage.get(); const float* adv = glyphBuffer.advances(from); for (unsigned i = 0; i < numGlyphs; i++) { xpos[i] = x; x += SkFloatToScalar(adv[i]); } const Glyph* glyphs = glyphBuffer.glyphs(from); paintGlyphsHorizontal(gc, font, glyphs, numGlyphs, xpos, SkFloatToScalar(y), textRect); return; } // FIXME: text rendering speed: // Android has code in their WebCore fork to special case when the // GlyphBuffer has no advances other than the defaults. In that case the // text drawing can proceed faster. However, it's unclear when those // patches may be upstreamed to WebKit so we always use the slower path // here. SkAutoSTMalloc<32, SkPoint> storage(numGlyphs); SkPoint* pos = storage.get(); const FloatSize* offsets = glyphBuffer.offsets(from); const float* advances = glyphBuffer.advances(from); SkScalar advanceSoFar = SkFloatToScalar(0); for (unsigned i = 0; i < numGlyphs; i++) { pos[i].set( x + SkFloatToScalar(offsets[i].width()) + advanceSoFar, y + SkFloatToScalar(offsets[i].height())); advanceSoFar += SkFloatToScalar(advances[i]); } const Glyph* glyphs = glyphBuffer.glyphs(from); paintGlyphs(gc, font, glyphs, numGlyphs, pos, textRect); }
DTC::LiveStreamInfo *Content::AddLiveStream( const QString &sStorageGroup, const QString &sFileName, const QString &sHostName, int nMaxSegments, int nWidth, int nHeight, int nBitrate, int nAudioBitrate, int nSampleRate ) { QString sGroup = sStorageGroup; if (sGroup.isEmpty()) { LOG(VB_UPNP, LOG_WARNING, "AddLiveStream - StorageGroup missing... using 'Default'"); sGroup = "Default"; } if (sFileName.isEmpty()) { QString sMsg ( "AddLiveStream - FileName missing." ); LOG(VB_UPNP, LOG_ERR, sMsg); throw sMsg; } // ------------------------------------------------------------------ // Search for the filename // ------------------------------------------------------------------ QString sFullFileName; if (sHostName.isEmpty() || sHostName == gCoreContext->GetHostName()) { StorageGroup storage( sGroup ); sFullFileName = storage.FindFile( sFileName ); if (sFullFileName.isEmpty()) { LOG(VB_UPNP, LOG_ERR, QString("AddLiveStream - Unable to find %1.").arg(sFileName)); return NULL; } } else { sFullFileName = gCoreContext->GenMythURL(sHostName, 0, sFileName, sStorageGroup); } HTTPLiveStream *hls = new HTTPLiveStream(sFullFileName, nWidth, nHeight, nBitrate, nAudioBitrate, nMaxSegments, 10, 32000, nSampleRate); if (!hls) { LOG(VB_UPNP, LOG_ERR, "AddLiveStream - Unable to create HTTPLiveStream."); return NULL; } DTC::LiveStreamInfo *lsInfo = hls->StartStream(); delete hls; return lsInfo; }
static void draw_nine_clipped(const SkMask& mask, const SkIRect& outerR, const SkIPoint& center, bool fillCenter, const SkIRect& clipR, SkBlitter* blitter) { int cx = center.x(); int cy = center.y(); SkMask m; // top-left m.fBounds = mask.fBounds; m.fBounds.fRight = cx; m.fBounds.fBottom = cy; if (m.fBounds.width() > 0 && m.fBounds.height() > 0) { extractMaskSubset(mask, &m); m.fBounds.offsetTo(outerR.left(), outerR.top()); blitClippedMask(blitter, m, m.fBounds, clipR); } // top-right m.fBounds = mask.fBounds; m.fBounds.fLeft = cx + 1; m.fBounds.fBottom = cy; if (m.fBounds.width() > 0 && m.fBounds.height() > 0) { extractMaskSubset(mask, &m); m.fBounds.offsetTo(outerR.right() - m.fBounds.width(), outerR.top()); blitClippedMask(blitter, m, m.fBounds, clipR); } // bottom-left m.fBounds = mask.fBounds; m.fBounds.fRight = cx; m.fBounds.fTop = cy + 1; if (m.fBounds.width() > 0 && m.fBounds.height() > 0) { extractMaskSubset(mask, &m); m.fBounds.offsetTo(outerR.left(), outerR.bottom() - m.fBounds.height()); blitClippedMask(blitter, m, m.fBounds, clipR); } // bottom-right m.fBounds = mask.fBounds; m.fBounds.fLeft = cx + 1; m.fBounds.fTop = cy + 1; if (m.fBounds.width() > 0 && m.fBounds.height() > 0) { extractMaskSubset(mask, &m); m.fBounds.offsetTo(outerR.right() - m.fBounds.width(), outerR.bottom() - m.fBounds.height()); blitClippedMask(blitter, m, m.fBounds, clipR); } SkIRect innerR; innerR.set(outerR.left() + cx - mask.fBounds.left(), outerR.top() + cy - mask.fBounds.top(), outerR.right() + (cx + 1 - mask.fBounds.right()), outerR.bottom() + (cy + 1 - mask.fBounds.bottom())); if (fillCenter) { blitClippedRect(blitter, innerR, clipR); } const int innerW = innerR.width(); size_t storageSize = (innerW + 1) * (sizeof(int16_t) + sizeof(uint8_t)); SkAutoSMalloc<4*1024> storage(storageSize); int16_t* runs = (int16_t*)storage.get(); uint8_t* alpha = (uint8_t*)(runs + innerW + 1); SkIRect r; // top r.set(innerR.left(), outerR.top(), innerR.right(), innerR.top()); if (r.intersect(clipR)) { int startY = SkMax32(0, r.top() - outerR.top()); int stopY = startY + r.height(); int width = r.width(); for (int y = startY; y < stopY; ++y) { runs[0] = width; runs[width] = 0; alpha[0] = *mask.getAddr8(cx, mask.fBounds.top() + y); blitter->blitAntiH(r.left(), outerR.top() + y, alpha, runs); } } // bottom r.set(innerR.left(), innerR.bottom(), innerR.right(), outerR.bottom()); if (r.intersect(clipR)) { int startY = outerR.bottom() - r.bottom(); int stopY = startY + r.height(); int width = r.width(); for (int y = startY; y < stopY; ++y) { runs[0] = width; runs[width] = 0; alpha[0] = *mask.getAddr8(cx, mask.fBounds.bottom() - y - 1); blitter->blitAntiH(r.left(), outerR.bottom() - y - 1, alpha, runs); } } // left r.set(outerR.left(), innerR.top(), innerR.left(), innerR.bottom()); if (r.intersect(clipR)) { int startX = r.left() - outerR.left(); int stopX = startX + r.width(); int height = r.height(); for (int x = startX; x < stopX; ++x) { blitter->blitV(outerR.left() + x, r.top(), height, *mask.getAddr8(mask.fBounds.left() + x, mask.fBounds.top() + cy)); } } // right r.set(innerR.right(), innerR.top(), outerR.right(), innerR.bottom()); if (r.intersect(clipR)) { int startX = outerR.right() - r.right(); int stopX = startX + r.width(); int height = r.height(); for (int x = startX; x < stopX; ++x) { blitter->blitV(outerR.right() - x - 1, r.top(), height, *mask.getAddr8(mask.fBounds.right() - x - 1, mask.fBounds.top() + cy)); } } }
SkCodec::Result SkScaledCodec::onGetPixels(const SkImageInfo& requestedInfo, void* dst, size_t rowBytes, const Options& options, SkPMColor ctable[], int* ctableCount) { if (options.fSubset) { // Subsets are not supported. return kUnimplemented; } Result result = fScanlineDecoder->start(requestedInfo, &options, ctable, ctableCount); if (kSuccess == result) { // native decode supported return fScanlineDecoder->getScanlines(dst, requestedInfo.height(), rowBytes); } if (kInvalidScale != result) { // no scaling requested return result; } // scaling requested int sampleX; int sampleY; if (!scaling_supported(requestedInfo, fScanlineDecoder->getInfo(), &sampleX, &sampleY)) { return kInvalidScale; } // set first sample pixel in y direction int Y0 = sampleY >> 1; int dstHeight = requestedInfo.height(); int srcHeight = fScanlineDecoder->getInfo().height(); SkImageInfo info = requestedInfo; // use original height as scanlineDecoder does not support y sampling natively info = info.makeWH(requestedInfo.width(), srcHeight); // update scanlineDecoder with new info result = fScanlineDecoder->start(info, &options, ctable, ctableCount); if (kSuccess != result) { return result; } const bool requiresPostYSampling = fScanlineDecoder->requiresPostYSampling(); if (requiresPostYSampling) { SkAutoMalloc storage(srcHeight * rowBytes); uint8_t* storagePtr = static_cast<uint8_t*>(storage.get()); result = fScanlineDecoder->getScanlines(storagePtr, srcHeight, rowBytes); if (kSuccess != result) { return result; } storagePtr += Y0 * rowBytes; for (int y = 0; y < dstHeight; y++) { memcpy(dst, storagePtr, rowBytes); storagePtr += sampleY * rowBytes; dst = SkTAddOffset<void>(dst, rowBytes); } } else { // does not require post y sampling result = fScanlineDecoder->skipScanlines(Y0); if (kSuccess != result) { return result; } for (int y = 0; y < dstHeight; y++) { result = fScanlineDecoder->getScanlines(dst, 1, rowBytes); if (kSuccess != result) { return result; } if (y < dstHeight - 1) { result = fScanlineDecoder->skipScanlines(sampleY - 1); if (kSuccess != result) { return result; } } dst = SkTAddOffset<void>(dst, rowBytes); } } return kSuccess; }
GLuint SkGL::BindNewTexture(const SkBitmap& origBitmap, SkPoint* max) { SkBitmap tmpBitmap; const SkBitmap* bitmap = &origBitmap; if (needToPromoteTo32bit(origBitmap)) { origBitmap.copyTo(&tmpBitmap, SkBitmap::kARGB_8888_Config); // now bitmap points to our temp, which has been promoted to 32bits bitmap = &tmpBitmap; } GLenum format, type; if (!canBeTexture(*bitmap, &format, &type)) { return 0; } SkAutoLockPixels alp(*bitmap); if (!bitmap->readyToDraw()) { return 0; } GLuint textureName; glGenTextures(1, &textureName); glBindTexture(GL_TEXTURE_2D, textureName); // express rowbytes as a number of pixels for ow int ow = bitmap->rowBytesAsPixels(); int oh = bitmap->height(); int nw = SkNextPow2(ow); int nh = SkNextPow2(oh); glPixelStorei(GL_UNPACK_ALIGNMENT, bitmap->bytesPerPixel()); // check if we need to scale to create power-of-2 dimensions #ifdef SK_GL_SUPPORT_COMPRESSEDTEXIMAGE2D if (SkBitmap::kIndex8_Config == bitmap->config()) { size_t imagesize = bitmap->getSize() + SK_GL_SIZE_OF_PALETTE; SkAutoMalloc storage(imagesize); build_compressed_data(storage.get(), *bitmap); // we only support POW2 here (GLES 1.0 restriction) SkASSERT(ow == nw); SkASSERT(oh == nh); glCompressedTexImage2D(GL_TEXTURE_2D, 0, format, ow, oh, 0, imagesize, storage.get()); } else // fall through to non-compressed logic #endif { if (ow != nw || oh != nh) { glTexImage2D(GL_TEXTURE_2D, 0, format, nw, nh, 0, format, type, NULL); glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, ow, oh, format, type, bitmap->getPixels()); } else { // easy case, the bitmap is already pow2 glTexImage2D(GL_TEXTURE_2D, 0, format, ow, oh, 0, format, type, bitmap->getPixels()); } } #ifdef TRACE_TEXTURE_CREATION SkDebugf("--- new texture [%d] size=(%d %d) bpp=%d\n", textureName, ow, oh, bitmap->bytesPerPixel()); #endif if (max) { max->fX = SkFixedToScalar(bitmap->width() << (16 - SkNextLog2(nw))); max->fY = SkFixedToScalar(oh << (16 - SkNextLog2(nh))); } return textureName; }
MainWindow::MainWindow(OCContext* context, QWidget *parent) : QMainWindow(parent), ui(new Ui::MainWindow) { ui->setupUi(this); QStorageInfo storage(qApp->applicationDirPath()); qDebug() << storage.rootPath(); if (storage.isReadOnly()) qDebug() << "isReadOnly:" << storage.isReadOnly(); qDebug() << "name:" << storage.name(); qDebug() << "fileSystemType:" << storage.fileSystemType(); qDebug() << "size:" << storage.bytesTotal()/1000/1000 << "MB"; qDebug() << "availableSize:" << storage.bytesAvailable()/1000/1000 << "MB"; QList<QStorageInfo> drives = QStorageInfo::mountedVolumes(); for(auto& drive : drives) { qDebug() << drive.rootPath(); if (drive.isReadOnly()) qDebug() << "isReadOnly:" << drive.isReadOnly(); qDebug() << "name:" << drive.name(); qDebug() << "fileSystemType:" << drive.fileSystemType(); qDebug() << "size:" << drive.bytesTotal()/1000/1000 << "MB"; qDebug() << "availableSize:" << drive.bytesAvailable()/1000/1000 << "MB"; } _context = context; MediaExplorerPresenter* mediaExplorerPresenter = new MediaExplorerPresenter(_context); PlaybackPresenter* playbackPresenter = new PlaybackPresenter(_context); //Add preview pane //ui->gridLayout_3->addWidget(new PreviewPane(playbackPresenter)); //Set Media Explorer widget //ui->dockWidget_3->setWidget(new MediaExplorerView(mediaExplorerPresenter)); //QGridLayout* layout = new QGridLayout(); //layout->addWidget(new PlaybackSlider(playbackPresenter)), ui->widget->setLayout(layout); stdout = freopen("output_file", "w", stdout); QFile f; f.open(stderr, QIODevice::ReadOnly); QByteArray output = f.readAll(); QString out(output); /*ui->label_2->setText(out); ui->textBrowser->setText(out); ui->textBrowser->append("TEST\n"); ui->textBrowser->append("12345\n"); */ BackupPresenter* backupPresenter = new BackupPresenter(context); ui->stackedWidget->addWidget(new BackupLayout(this, *backupPresenter)); ui->stackedWidget->addWidget(new ClipProcessorLayout()); //ui->buttonGroup->addButton(new QPushButton("Test", this)); connect(ui->buttonGroup, SIGNAL(buttonClicked(int)), SLOT(on_pushButton_7_clicked(int))); /*QMenu* importMenu = new QMenu(); QAction* testAction = new QAction("test menu item", this); connect(testAction,SIGNAL(triggered()), SLOT(SelectImportFolder())); importMenu->addAction(testAction);*/ }
static PyObject * THPStorage_(pynew)(PyTypeObject *type, PyObject *args, PyObject *kwargs) { HANDLE_TH_ERRORS Py_ssize_t num_args = args ? PyTuple_Size(args) : 0; THPStoragePtr self((THPStorage *)type->tp_alloc(type, 0)); THPUtils_assert(self, "failed to allocate a " THPStorageStr " object"); THAllocator* allocator = NULL; // Internally we allow constructing with a keywoard only argument cdata if (kwargs != NULL) { PyObject *allocator_ptr = PyDict_GetItemString(kwargs, "allocator"); if (allocator_ptr) { THPUtils_assert(THPUtils_checkLong(allocator_ptr), "invalid allocator"); allocator = (THAllocator*) PyLong_AsVoidPtr(allocator_ptr); PyDict_DelItemString(kwargs, "allocator"); } Py_ssize_t num_kwargs = PyDict_Size(kwargs); if (num_args == 0) { PyObject *cdata_ptr = PyDict_GetItemString(kwargs, "cdata"); if (num_kwargs == 1 && cdata_ptr && THPUtils_checkLong(cdata_ptr)) { THStorage *ptr = (THStorage*)PyLong_AsVoidPtr(cdata_ptr); self->cdata = ptr; return (PyObject*)self.release(); } } THPUtils_assert(num_kwargs == 0, THPStorageStr "(): invalid keyword arguments"); } // torch.Storage() if (num_args == 0) { if (allocator) { self->cdata = THPStorage_(newWithAllocator)(0, allocator); } else { self->cdata = THStorage_(new)(LIBRARY_STATE_NOARGS); } return (PyObject*)self.release(); } PyObject *first_arg = PyTuple_GET_ITEM(args, 0); // torch.Storage(size) if (num_args == 1 && THPUtils_checkLong(first_arg)) { int64_t size = THPUtils_unpackLong(first_arg); if (allocator) { self->cdata = THPStorage_(newWithAllocator)(size, allocator); } else { self->cdata = THStorage_(newWithSize)(LIBRARY_STATE size); } return (PyObject*)self.release(); } // torch.Storage(view_source, [offset, [size]]) if (num_args < 4 && THPStorage_(Check)(first_arg)) { #ifdef THD_GENERIC_FILE THPUtils_setError("distributed storages don't support storage views"); return NULL; #else THPStorage *storage_arg = (THPStorage *)first_arg; int64_t numel = storage_arg->cdata->size; int64_t offset = 0; if (num_args >= 2) { PyObject *second_arg = PyTuple_GET_ITEM(args, 1); if (!THPUtils_checkLong(second_arg)) goto invalid_arguments; offset = THPUtils_unpackLong(second_arg); } int64_t size = numel - offset; if (num_args >= 3) { PyObject *third_arg = PyTuple_GET_ITEM(args, 2); if (!THPUtils_checkLong(third_arg)) goto invalid_arguments; size = THPUtils_unpackLong(third_arg); } THPUtils_assert(offset >= 0 && offset <= numel, "specified an offset of " "%" PRId64 ", but the viewed storage has only %" PRId64 " element(s)", offset, numel); THPUtils_assert(size >= 1 && size <= numel - offset, "specified a size of " "%" PRId64 ", but the viewed storage has only %" PRId64 " element(s) after offset %" PRId64, size, numel - offset, offset); real *data_ptr = THStorage_(data)(LIBRARY_STATE storage_arg->cdata) + offset; THStoragePtr storage(THStorage_(newWithData)(LIBRARY_STATE data_ptr, size)); storage->flag = TH_STORAGE_REFCOUNTED | TH_STORAGE_VIEW; storage->view = storage_arg->cdata; THStorage_(retain)(LIBRARY_STATE storage_arg->cdata); self->cdata = storage.release(); return (PyObject*)self.release(); #endif } // torch.Storage(sequence) if (num_args == 1 && PySequence_Check(first_arg)) { #ifdef THD_GENERIC_FILE THPUtils_setError("distributed storages don't support construction from a sequence"); #else Py_ssize_t length = PySequence_Length(first_arg); THPUtils_assert(length >= 0, "couldn't obtain the length of %s", THPUtils_typename(first_arg)); self->cdata = THStorage_(newWithSize)(LIBRARY_STATE length); THPObjectPtr item; try { for (Py_ssize_t i = 0; i < length; i++) { item = PySequence_GetItem(first_arg, i); real value = THPUtils_(unpackReal)(item.get()); #if !defined(THC_GENERIC_FILE) self->cdata->unsafe_data<real>()[i] = value; #else // TODO: this might be slow - consider batched updates? THCStorage_(set)(LIBRARY_STATE self->cdata, i, value); #endif } } catch (std::runtime_error &e) { THPUtils_setError("tried to construct a storage from a sequence (%s), " "but one of the items was of type %s instead of %s", THPUtils_typename(first_arg), THPUtils_typename(item.get()), THPUtils_typeTraits<real>::python_type_str); return NULL; } return (PyObject*)self.release(); #endif } #ifndef THD_GENERIC_FILE invalid_arguments: #endif THPUtils_invalidArguments(args, kwargs, THPStorageStr " constructor", 6, "no arguments", "(int size)", "(Sequence data)", "(" THPStorageStr " view_source)", "(" THPStorageStr " view_source, int offset)", "(" THPStorageStr " view_source, int offset, int size)"); return NULL; END_HANDLE_TH_ERRORS }
SkShader* Gradient::platformGradient() { if (m_gradient) return m_gradient; sortStopsIfNecessary(); ASSERT(m_stopsSorted); size_t countUsed = totalStopsNeeded(m_stops.data(), m_stops.size()); ASSERT(countUsed >= 2); ASSERT(countUsed >= m_stops.size()); // FIXME: Why is all this manual pointer math needed?! SkAutoMalloc storage(countUsed * (sizeof(SkColor) + sizeof(SkScalar))); SkColor* colors = (SkColor*)storage.get(); SkScalar* pos = (SkScalar*)(colors + countUsed); fillStops(m_stops.data(), m_stops.size(), pos, colors); SkShader::TileMode tile = SkShader::kClamp_TileMode; switch (m_spreadMethod) { case SpreadMethodReflect: tile = SkShader::kMirror_TileMode; break; case SpreadMethodRepeat: tile = SkShader::kRepeat_TileMode; break; case SpreadMethodPad: tile = SkShader::kClamp_TileMode; break; } if (m_radial) { // Since the two-point radial gradient is slower than the plain radial, // only use it if we have to. if (m_p0 == m_p1 && m_r0 <= 0.0f) { // The radius we give to Skia must be positive (and non-zero). If // we're given a zero radius, just ask for a very small radius so // Skia will still return an object. SkScalar radius = m_r1 > 0 ? WebCoreFloatToSkScalar(m_r1) : WebCoreFloatToSkScalar(FLT_EPSILON); m_gradient = SkGradientShader::CreateRadial(m_p1, radius, colors, pos, static_cast<int>(countUsed), tile); } else { // The radii we give to Skia must be positive. If we're given a // negative radius, ask for zero instead. SkScalar radius0 = m_r0 >= 0.0f ? WebCoreFloatToSkScalar(m_r0) : 0; SkScalar radius1 = m_r1 >= 0.0f ? WebCoreFloatToSkScalar(m_r1) : 0; m_gradient = SkGradientShader::CreateTwoPointRadial(m_p0, radius0, m_p1, radius1, colors, pos, static_cast<int>(countUsed), tile); } if (aspectRatio() != 1) { // CSS3 elliptical gradients: apply the elliptical scaling at the // gradient center point. m_gradientSpaceTransformation.translate(m_p0.x(), m_p0.y()); m_gradientSpaceTransformation.scale(1, 1 / aspectRatio()); m_gradientSpaceTransformation.translate(-m_p0.x(), -m_p0.y()); ASSERT(m_p0 == m_p1); } } else { SkPoint pts[2] = { m_p0, m_p1 }; m_gradient = SkGradientShader::CreateLinear(pts, colors, pos, static_cast<int>(countUsed), tile); } ASSERT(m_gradient); SkMatrix matrix = m_gradientSpaceTransformation; m_gradient->setLocalMatrix(matrix); return m_gradient; }
static void drawBitmapMesh(JNIEnv* env, jobject, SkCanvas* canvas, const SkBitmap* bitmap, int meshWidth, int meshHeight, jfloatArray jverts, int vertIndex, jintArray jcolors, int colorIndex, const SkPaint* paint) { const int ptCount = (meshWidth + 1) * (meshHeight + 1); const int indexCount = meshWidth * meshHeight * 6; AutoJavaFloatArray vertA(env, jverts, vertIndex + (ptCount << 1)); AutoJavaIntArray colorA(env, jcolors, colorIndex + ptCount); /* Our temp storage holds 2 or 3 arrays. texture points [ptCount * sizeof(SkPoint)] optionally vertex points [ptCount * sizeof(SkPoint)] if we need a copy to convert from float to fixed indices [ptCount * sizeof(uint16_t)] */ ssize_t storageSize = ptCount * sizeof(SkPoint); // texs[] #ifdef SK_SCALAR_IS_FIXED storageSize += ptCount * sizeof(SkPoint); // storage for verts #endif storageSize += indexCount * sizeof(uint16_t); // indices[] SkAutoMalloc storage(storageSize); SkPoint* texs = (SkPoint*)storage.get(); SkPoint* verts; uint16_t* indices; #ifdef SK_SCALAR_IS_FLOAT verts = (SkPoint*)(vertA.ptr() + vertIndex); indices = (uint16_t*)(texs + ptCount); #else verts = texs + ptCount; indices = (uint16_t*)(verts + ptCount); // convert floats to fixed { const float* src = vertA.ptr() + vertIndex; for (int i = 0; i < ptCount; i++) { verts[i].set(SkFloatToFixed(src[0]), SkFloatToFixed(src[1])); src += 2; } } #endif // cons up texture coordinates and indices { const SkScalar w = SkIntToScalar(bitmap->width()); const SkScalar h = SkIntToScalar(bitmap->height()); const SkScalar dx = w / meshWidth; const SkScalar dy = h / meshHeight; SkPoint* texsPtr = texs; SkScalar y = 0; for (int i = 0; i <= meshHeight; i++) { if (i == meshHeight) { y = h; // to ensure numerically we hit h exactly } SkScalar x = 0; for (int j = 0; j < meshWidth; j++) { texsPtr->set(x, y); texsPtr += 1; x += dx; } texsPtr->set(w, y); texsPtr += 1; y += dy; } SkASSERT(texsPtr - texs == ptCount); } // cons up indices { uint16_t* indexPtr = indices; int index = 0; for (int i = 0; i < meshHeight; i++) { for (int j = 0; j < meshWidth; j++) { // lower-left triangle *indexPtr++ = index; *indexPtr++ = index + meshWidth + 1; *indexPtr++ = index + meshWidth + 2; // upper-right triangle *indexPtr++ = index; *indexPtr++ = index + meshWidth + 2; *indexPtr++ = index + 1; // bump to the next cell index += 1; } // bump to the next row index += 1; } SkASSERT(indexPtr - indices == indexCount); SkASSERT((char*)indexPtr - (char*)storage.get() == storageSize); } // double-check that we have legal indices #ifdef SK_DEBUG { for (int i = 0; i < indexCount; i++) { SkASSERT((unsigned)indices[i] < (unsigned)ptCount); } } #endif // cons-up a shader for the bitmap SkPaint tmpPaint; if (paint) { tmpPaint = *paint; } SkShader* shader = SkShader::CreateBitmapShader(*bitmap, SkShader::kClamp_TileMode, SkShader::kClamp_TileMode); tmpPaint.setShader(shader)->safeUnref(); canvas->drawVertices(SkCanvas::kTriangles_VertexMode, ptCount, verts, texs, (const SkColor*)colorA.ptr(), NULL, indices, indexCount, tmpPaint); }
static qr_type *qr_create(length_type n, length_type m, storage_type s) { qr_type *qr = vsip_cqrd_create_f(n, m, storage(s)); if (!qr) VSIP_IMPL_THROW(std::bad_alloc()); return qr; }
bool SkFPDFEMBImageDecoder::onDecode(SkStream* stream, SkBitmap* bm, SkBitmap::Config prefConfig, Mode mode) { FPDFEMB_RESULT result; #ifdef USE_FIXED_MEM SkAutoMalloc storage(USE_FIXED_MEM); result = FPDFEMB_InitFixedMemory(storage.get(), USE_FIXED_MEM, pdf_oom_handler); #else FPDFEMB_MEMMGR memmgr; memmgr.Alloc = pdf_alloc; memmgr.AllocNL = pdf_alloc_nl; memmgr.Realloc = pdf_realloc; memmgr.Free = pdf_free; result = FPDFEMB_Init(&memmgr); #endif SkDebugf("----- SkImageDecoder_FPDFEMB_Factory init %d, streamLen = %d\n", result, stream->getLength()); FPDFEMB_FILE_ACCESS file; file.GetSize = file_getsize; file.ReadBlock = file_readblock; file.user = stream; FPDFEMB_DOCUMENT document; result = FPDFEMB_StartLoadDocument(&file, NULL, &document, NULL); SkDebugf("----- SkImageDecoder_FPDFEMB_Factory open %d %p\n", result, document); int pageCount = FPDFEMB_GetPageCount(document); SkDebugf("----- SkImageDecoder_FPDFEMB_Factory pageCount %d\n", pageCount); if (pageCount > 0) { FPDFEMB_PAGE page; result = FPDFEMB_LoadPage(document, 0, &page); SkDebugf("----- SkImageDecoder_FPDFEMB_Factory load page %d\n", result); int width, height; result = FPDFEMB_GetPageSize(page, &width, &height); SkDebugf("----- SkImageDecoder_FPDFEMB_Factory page size %d [%d %d]\n", result, width, height); FPDFEMB_RECT rect; result = FPDFEMB_GetPageBBox(page, &rect); SkDebugf("----- SkImageDecoder_FPDFEMB_Factory page rect %d [%d %d %d %d]\n", result, rect.left, rect.top, rect.right, rect.bottom); SkDebugf("----- SkImageDecoder_FPDFEMB_Factory begin page parse...\n"); result = FPDFEMB_StartParse(page, false, NULL); SkDebugf("----- SkImageDecoder_FPDFEMB_Factory page parse %d\n", result); if (0 == result) { this->render(page, rect, bm, prefConfig, mode); } result = FPDFEMB_ClosePage(page); SkDebugf("----- SkImageDecoder_FPDFEMB_Factory close page %d\n", result); } result = FPDFEMB_CloseDocument(document); SkDebugf("----- SkImageDecoder_FPDFEMB_Factory close %d\n", result); // FPDFEMB_Exit(); return true; }
void testTrainICAAMColor() { std::cout << "trainICTest testTrainICAAMColor" << std::endl; aam::AppearanceDataIC model; aam::TrainModelLoader loader; loader.useGrayImages(false); for (int i = 0; i < TRIANGLES_COUNT; i++) { model.triangles.push_back(cv::Vec3i(trianglesData[i * 3], trianglesData[i * 3 + 1], trianglesData[i * 3 + 2])); } try { std::vector<std::string> fileNames = boost::assign::list_of<std::string> ("107_0764.bmp") /*("107_0766.bmp")*/ ("107_0779.bmp") ("107_0780.bmp") ("107_0781.bmp") ("107_0782.bmp") ("107_0783.bmp") ("107_0784.bmp") ("107_0785.bmp") ("107_0786.bmp") ("107_0787.bmp") ("107_0788.bmp") ("107_0789.bmp") ("107_0790.bmp") ("107_0791.bmp") ("107_0792.bmp") ("107_0793.bmp") ("107_0794.bmp") ("107_0795.bmp") ("107_0798.bmp") ("107_0799.bmp") ("107_0800.bmp") ("108_0801.bmp") ("108_0802.bmp") ("108_0803.bmp") ("108_0804.bmp"); for (int i = 0; i < fileNames.size(); i++) { std::ostringstream stream; stream << "data/cootes/" << fileNames[i] << ".mat.dat"; std::string markupFile = stream.str(); stream.str(std::string()); stream << "data/cootes/" << fileNames[i]; std::string imageFile = stream.str(); loader.load(markupFile, imageFile); } std::vector<aam::TrainModelInfo> trainData = loader.getModels(); aam::AAMFunctions2D::trainModelIC(0.98, trainData, model); cv::FileStorage storage("output/aam_ic_c_test.xml", cv::FileStorage::WRITE); storage << "R" << model.R; storage << "s" << model.s; storage << "s_star" << model.sStar; storage << "s0" << model.s0; storage << "A0" << model.A0; storage << "mask" << model.mask; storage << "triangles" << model.triangles; cv::Mat1i tmp(2, 1); tmp(0, 0) = model.textureSize.width; tmp(1, 0) = model.textureSize.height; storage << "texture_size" << tmp; storage.release(); for (int i = 0; i < model.R.rows; i++) { cv::Mat img; aam::AAMFunctions2D::vector2Appearance(model.R.t().col(i), model.mask, model.textureSize, img); cv::normalize(img, img, 1, 0, cv::NORM_MINMAX); cv::imshow("test", img); cv::waitKey(500); } cv::waitKey(0); } catch (std::exception& e) { std::cout << "%TEST_FAILED% time=0 testname=testTrainICAAMColor (trainICTest) message=Exception occured: " << e.what() << std::endl; } }
void SkGLDevice::drawVertices(const SkDraw& draw, SkCanvas::VertexMode vmode, int vertexCount, const SkPoint vertices[], const SkPoint texs[], const SkColor colors[], SkXfermode* xmode, const uint16_t indices[], int indexCount, const SkPaint& paint) { if (false) { SkRect bounds; SkIRect ibounds; bounds.set(vertices, vertexCount); bounds.round(&ibounds); SkDebugf("---- drawverts: %d pts, texs=%d colors=%d indices=%d bounds [%d %d]\n", vertexCount, texs!=0, colors!=0, indexCount, ibounds.width(), ibounds.height()); } SkGLClipIter* iter = this->updateMatrixClip(); SkGL::SetPaint(paint); const SkGLVertex* glVerts; const SkGLVertex* glTexs = NULL; #if GLSCALAR_IS_SCALAR glVerts = (const SkGLVertex*)vertices; #else SkAutoSTMalloc<32, SkGLVertex> storage(vertexCount); storage.get()->setPoints(vertices, vertexCount); glVerts = storage.get(); #endif uint8_t* colorArray = NULL; if (colors) { colorArray = (uint8_t*)sk_malloc_throw(vertexCount*4); SkGL::SetRGBA(colorArray, colors, vertexCount); } SkAutoFree afca(colorArray); SkGLVertex* texArray = NULL; TexCache* cache = NULL; if (texs && paint.getShader()) { SkShader* shader = paint.getShader(); // if (!shader->setContext(this->accessBitmap(), paint, *draw.fMatrix)) { if (!shader->setContext(*draw.fBitmap, paint, *draw.fMatrix)) { goto DONE; } SkBitmap bitmap; SkMatrix matrix; SkShader::TileMode tileModes[2]; if (shader->asABitmap(&bitmap, &matrix, tileModes)) { SkPoint max; GLuint name; cache = SkGLDevice::LockTexCache(bitmap, &name, &max); if (NULL == cache) { return; } matrix.postScale(max.fX / bitmap.width(), max.fY / bitmap.height()); glMatrixMode(GL_TEXTURE); SkGL::LoadMatrix(matrix); glMatrixMode(GL_MODELVIEW); #if GLSCALAR_IS_SCALAR glTexs = (const SkGLVertex*)texs; #else texArray = (SkGLVertex*)sk_malloc_throw(vertexCount * sizeof(SkGLVertex)); texArray->setPoints(texs, vertexCount); glTexs = texArray; #endif SkGL::SetPaintAlpha(paint); SkGL::SetTexParams(paint.isFilterBitmap(), tileModes[0], tileModes[1]); } } DONE: SkAutoFree aftex(texArray); SkGL::DrawVertices(indices ? indexCount : vertexCount, gVertexModeToGL[vmode], glVerts, glTexs, colorArray, indices, iter); if (cache) { SkGLDevice::UnlockTexCache(cache); } }
void Font::drawGlyphs(GraphicsContext* gc, const SimpleFontData* font, const GlyphBuffer& glyphBuffer, int from, int numGlyphs, const FloatPoint& point) const { // compile-time assert SkASSERT(sizeof(GlyphBufferGlyph) == sizeof(uint16_t)); SkPaint paint; if (!setupForText(&paint, gc, font)) { return; } SkScalar x = SkFloatToScalar(point.x()); SkScalar y = SkFloatToScalar(point.y()); const GlyphBufferGlyph* glyphs = glyphBuffer.glyphs(from); const GlyphBufferAdvance* adv = glyphBuffer.advances(from); SkAutoSTMalloc<32, SkPoint> storage(numGlyphs); SkPoint* pos = storage.get(); SkCanvas* canvas = gc->platformContext()->mCanvas; /* We need an array of [x,y,x,y,x,y,...], but webkit is giving us point.xy + [width, height, width, height, ...], so we have to convert */ if (EmojiFont::IsAvailable()) { // set filtering, to make scaled images look nice(r) paint.setFilterBitmap(true); int localIndex = 0; int localCount = 0; for (int i = 0; i < numGlyphs; i++) { if (EmojiFont::IsEmojiGlyph(glyphs[i])) { if (localCount) canvas->drawPosText(&glyphs[localIndex], localCount * sizeof(uint16_t), &pos[localIndex], paint); EmojiFont::Draw(canvas, glyphs[i], x, y, paint); // reset local index/count track for "real" glyphs localCount = 0; localIndex = i + 1; } else { pos[i].set(x, y); localCount += 1; } x += SkFloatToScalar(adv[i].width()); y += SkFloatToScalar(adv[i].height()); } // draw the last run of glyphs (if any) if (localCount) canvas->drawPosText(&glyphs[localIndex], localCount * sizeof(uint16_t), &pos[localIndex], paint); } else { for (int i = 0; i < numGlyphs; i++) { pos[i].set(x, y); x += SkFloatToScalar(adv[i].width()); y += SkFloatToScalar(adv[i].height()); } canvas->drawPosText(glyphs, numGlyphs * sizeof(uint16_t), pos, paint); } }
// **************************************************************************** // // Function Name: RMergeData::OpenFile( ) // // Description: Make this MergeData takes its values from the given file // if bCompatibleMode == TRUE the file is a PSD4 file // // Returns: Nothing // // Exceptions: None // // **************************************************************************** // BOOLEAN RMergeData::OpenFile( const RMBCString& fileName, BOOL bCompatibleMode ) { uBYTE* pBuffer = ::GetGlobalBuffer( ); BOOLEAN fReturnValue = FALSE; try { RStorage storage( fileName, kRead ); // Quick validate a that we are possible using a text file. YStreamLength current = storage.GetPosition( ); YStreamLength readAmt = ::GetGlobalBufferSize( ); try { storage.Read( readAmt, pBuffer ); } catch( YException exception ) { if ( exception != kEndOfFile ) throw; readAmt = storage.GetPosition( ) - current; } for (YStreamLength iCnt = 0; iCnt < readAmt; ++iCnt ) if ( pBuffer[iCnt] == '\0' ) // If null, this can't be a text file... throw kDataFormatInvalid; // // Reset to beginning of file. storage.SeekAbsolute( current ); // delete the entries, and empty the list ::DeleteAllItems( m_MergeData ); m_MergeData.Empty( ); // Now, merge the new list if there is actually data if ( readAmt > 0 ) { if ( bCompatibleMode == FALSE ) { MergeStorage( storage ); // Remember the new file name m_FileName = fileName; } else MergeCompatibleStorage( storage ); } // We succeeded fReturnValue = TRUE; } catch( YException exception ) { if ( exception == kEndOfFile ) { ::DeleteAllItems( m_MergeData ); m_MergeData.Empty( ); m_FileName = fileName; fReturnValue = TRUE; } else ::ReportException( exception ); } catch( ... ) { ::ReportException( kUnknownError ); } ::ReleaseGlobalBuffer( pBuffer ); return fReturnValue; }
void Font::drawGlyphs(GraphicsContext* gc, const SimpleFontData* font, const GlyphBuffer& glyphBuffer, int from, int numGlyphs, const FloatPoint& point) const { SkASSERT(sizeof(GlyphBufferGlyph) == sizeof(uint16_t)); // compile-time assert const GlyphBufferGlyph* glyphs = glyphBuffer.glyphs(from); SkScalar x = SkFloatToScalar(point.x()); SkScalar y = SkFloatToScalar(point.y()); // FIXME: text rendering speed: // Android has code in their WebCore fork to special case when the // GlyphBuffer has no advances other than the defaults. In that case the // text drawing can proceed faster. However, it's unclear when those // patches may be upstreamed to WebKit so we always use the slower path // here. const GlyphBufferAdvance* adv = glyphBuffer.advances(from); SkAutoSTMalloc<32, SkPoint> storage(numGlyphs), storage2(numGlyphs), storage3(numGlyphs); SkPoint* pos = storage.get(); SkPoint* vPosBegin = storage2.get(); SkPoint* vPosEnd = storage3.get(); bool isVertical = font->platformData().orientation() == Vertical; for (int i = 0; i < numGlyphs; i++) { SkScalar myWidth = SkFloatToScalar(adv[i].width()); pos[i].set(x, y); if (isVertical) { vPosBegin[i].set(x + myWidth, y); vPosEnd[i].set(x + myWidth, y - myWidth); } x += myWidth; y += SkFloatToScalar(adv[i].height()); } gc->platformContext()->prepareForSoftwareDraw(); SkCanvas* canvas = gc->platformContext()->canvas(); TextDrawingModeFlags textMode = gc->platformContext()->getTextDrawingMode(); // We draw text up to two times (once for fill, once for stroke). if (textMode & TextModeFill) { SkPaint paint; gc->platformContext()->setupPaintForFilling(&paint); font->platformData().setupPaint(&paint); adjustTextRenderMode(&paint, gc->platformContext()); paint.setTextEncoding(SkPaint::kGlyphID_TextEncoding); paint.setColor(gc->fillColor().rgb()); if (isVertical) { SkPath path; for (int i = 0; i < numGlyphs; ++i) { path.reset(); path.moveTo(vPosBegin[i]); path.lineTo(vPosEnd[i]); canvas->drawTextOnPath(glyphs + i, 2, path, 0, paint); } } else canvas->drawPosText(glyphs, numGlyphs << 1, pos, paint); } if ((textMode & TextModeStroke) && gc->platformContext()->getStrokeStyle() != NoStroke && gc->platformContext()->getStrokeThickness() > 0) { SkPaint paint; gc->platformContext()->setupPaintForStroking(&paint, 0, 0); font->platformData().setupPaint(&paint); adjustTextRenderMode(&paint, gc->platformContext()); paint.setTextEncoding(SkPaint::kGlyphID_TextEncoding); paint.setColor(gc->strokeColor().rgb()); if (textMode & TextModeFill) { // If we also filled, we don't want to draw shadows twice. // See comment in FontChromiumWin.cpp::paintSkiaText() for more details. SkSafeUnref(paint.setLooper(0)); } if (isVertical) { SkPath path; for (int i = 0; i < numGlyphs; ++i) { path.reset(); path.moveTo(vPosBegin[i]); path.lineTo(vPosEnd[i]); canvas->drawTextOnPath(glyphs + i, 2, path, 0, paint); } } else canvas->drawPosText(glyphs, numGlyphs << 1, pos, paint); } }
QFileInfo Guide::GetChannelIcon( int nChanId, int nWidth /* = 0 */, int nHeight /* = 0 */ ) { // Get Icon file path QString sFileName = ChannelUtil::GetIcon( nChanId ); if (sFileName.isEmpty()) return QFileInfo(); // ------------------------------------------------------------------ // Search for the filename // ------------------------------------------------------------------ StorageGroup storage( "ChannelIcons" ); QString sFullFileName = storage.FindFile( sFileName ); if (sFullFileName.isEmpty()) { LOG(VB_UPNP, LOG_ERR, QString("GetImageFile - Unable to find %1.").arg(sFileName)); return QFileInfo(); } // ---------------------------------------------------------------------- // check to see if the file (still) exists // ---------------------------------------------------------------------- if ((nWidth == 0) && (nHeight == 0)) { if (QFile::exists( sFullFileName )) { return QFileInfo( sFullFileName ); } LOG(VB_UPNP, LOG_ERR, QString("GetImageFile - File Does not exist %1.").arg(sFullFileName)); return QFileInfo(); } // ------------------------------------------------------------------- QString sNewFileName = QString( "%1.%2x%3.png" ) .arg( sFullFileName ) .arg( nWidth ) .arg( nHeight ); // ---------------------------------------------------------------------- // check to see if image is already created. // ---------------------------------------------------------------------- if (QFile::exists( sNewFileName )) return QFileInfo( sNewFileName ); // ---------------------------------------------------------------------- // We need to create it... // ---------------------------------------------------------------------- float fAspect = 0.0; QImage *pImage = new QImage( sFullFileName ); if (!pImage) return QFileInfo(); if (fAspect <= 0) fAspect = (float)(pImage->width()) / pImage->height(); if (fAspect == 0) { delete pImage; return QFileInfo(); } if ( nWidth == 0 ) nWidth = (int)rint(nHeight * fAspect); if ( nHeight == 0 ) nHeight = (int)rint(nWidth / fAspect); QImage img = pImage->scaled( nWidth, nHeight, Qt::IgnoreAspectRatio, Qt::SmoothTransformation); img.save( sNewFileName, "PNG" ); delete pImage; return QFileInfo( sNewFileName ); }
void auth_init() { FILE *fp; static char uname[USERNAME_LEN+1]; static char dir[DIR_LEN+1]; static char per[DIR_LEN+1]; printf("*** AUTH SYSTEM INIT START ***\n"); pthread_mutex_init(&auth_lock,0); fp=fopen(passwd_file,"r"); if (fp==0) printf("passwd NOT EXISTS\n"); else { //printf("USER:\n"); while (!feof(fp)) { MALLOC(struct auth_profile,p); fscanf(fp,"%s",uname); if (feof(fp)) break; fscanf(fp,"%s",p->pass); p->uid=uid_alloc(); map_insert(uname,(int)p); //printf("%s %s\n",uname,p->pass); } printf("passwd READ COMPLETE\n"); fclose(fp); } fp=fopen(permission_file,"r"); if (fp==0) printf("permission NOT EXISTS\n"); else { while (!feof(fp)) { fscanf(fp,"%s",dir); if (feof(fp)) break; fix_dir(dir); while (1) { int uid; fscanf(fp,"%s",uname); if (auth_strcmp(uname,"[end]")) break; fscanf(fp,"%s",per); uid=get_uid_by_name(uname); if (uid>0) { uint_8 mask=give_permission_mask(per); map_insert(storage(dir,uid),mask); //printf("DIR:%s %s %x\n",dir,per,mask); } } } printf("permission READ COMPLETE\n"); fclose(fp); } printf("*** AUTH SYSTEM INIT COMPLETE ***\n\n"); }
// TODO: This needs to be split into helper functions to better scope the // inputs/outputs, and reduce duplicate code. // This issue is tracked in https://bugs.webkit.org/show_bug.cgi?id=62989 void Font::drawGlyphs(GraphicsContext* gc, const SimpleFontData* font, const GlyphBuffer& glyphBuffer, int from, int numGlyphs, const FloatPoint& point) const { COMPILE_ASSERT(sizeof(GlyphBufferGlyph) == sizeof(uint16_t), GlyphBufferGlyphSize_equals_uint16_t); bool shouldSmoothFonts = true; bool shouldAntialias = true; switch (fontDescription().fontSmoothing()) { case Antialiased: shouldSmoothFonts = false; break; case SubpixelAntialiased: break; case NoSmoothing: shouldAntialias = false; shouldSmoothFonts = false; break; case AutoSmoothing: // For the AutoSmooth case, don't do anything! Keep the default settings. break; } if (!shouldUseSmoothing() || PlatformSupport::layoutTestMode()) shouldSmoothFonts = false; const GlyphBufferGlyph* glyphs = glyphBuffer.glyphs(from); SkScalar x = SkFloatToScalar(point.x()); SkScalar y = SkFloatToScalar(point.y()); if (font->platformData().orientation() == Vertical) y += SkFloatToScalar(font->fontMetrics().floatAscent(IdeographicBaseline) - font->fontMetrics().floatAscent()); // FIXME: text rendering speed: // Android has code in their WebCore fork to special case when the // GlyphBuffer has no advances other than the defaults. In that case the // text drawing can proceed faster. However, it's unclear when those // patches may be upstreamed to WebKit so we always use the slower path // here. const GlyphBufferAdvance* adv = glyphBuffer.advances(from); SkAutoSTMalloc<32, SkPoint> storage(numGlyphs); SkPoint* pos = storage.get(); for (int i = 0; i < numGlyphs; i++) { pos[i].set(x, y); x += SkFloatToScalar(adv[i].width); y += SkFloatToScalar(adv[i].height); } SkCanvas* canvas = gc->platformContext()->canvas(); if (font->platformData().orientation() == Vertical) { canvas->save(); canvas->rotate(-90); SkMatrix rotator; rotator.reset(); rotator.setRotate(90); rotator.mapPoints(pos, numGlyphs); } TextDrawingModeFlags textMode = gc->platformContext()->getTextDrawingMode(); // We draw text up to two times (once for fill, once for stroke). if (textMode & TextModeFill) { SkPaint paint; gc->platformContext()->setupPaintForFilling(&paint); setupPaint(&paint, font, this, shouldAntialias, shouldSmoothFonts); gc->platformContext()->adjustTextRenderMode(&paint); paint.setTextEncoding(SkPaint::kGlyphID_TextEncoding); canvas->drawPosText(glyphs, numGlyphs * sizeof(uint16_t), pos, paint); } if ((textMode & TextModeStroke) && gc->platformContext()->getStrokeStyle() != NoStroke && gc->platformContext()->getStrokeThickness() > 0) { SkPaint paint; gc->platformContext()->setupPaintForStroking(&paint, 0, 0); setupPaint(&paint, font, this, shouldAntialias, shouldSmoothFonts); gc->platformContext()->adjustTextRenderMode(&paint); paint.setTextEncoding(SkPaint::kGlyphID_TextEncoding); if (textMode & TextModeFill) { // If we also filled, we don't want to draw shadows twice. // See comment in FontChromiumWin.cpp::paintSkiaText() for more details. paint.setLooper(0); } canvas->drawPosText(glyphs, numGlyphs * sizeof(uint16_t), pos, paint); } if (font->platformData().orientation() == Vertical) canvas->restore(); }
QFileInfo Content::GetImageFile( const QString &sStorageGroup, const QString &sFileName, int nWidth, int nHeight) { QString sGroup = sStorageGroup; if (sGroup.isEmpty()) { LOG(VB_UPNP, LOG_WARNING, "GetFile - StorageGroup missing... using 'Default'"); sGroup = "Default"; } if (sFileName.isEmpty()) { QString sMsg ( "GetFile - FileName missing." ); LOG(VB_UPNP, LOG_ERR, sMsg); throw sMsg; } // ------------------------------------------------------------------ // Search for the filename // ------------------------------------------------------------------ StorageGroup storage( sGroup ); QString sFullFileName = storage.FindFile( sFileName ); if (sFullFileName.isEmpty()) { LOG(VB_UPNP, LOG_ERR, QString("GetImageFile - Unable to find %1.").arg(sFileName)); return QFileInfo(); } // ---------------------------------------------------------------------- // check to see if the file (still) exists // ---------------------------------------------------------------------- if ((nWidth == 0) && (nHeight == 0)) { if (QFile::exists( sFullFileName )) { return QFileInfo( sFullFileName ); } LOG(VB_UPNP, LOG_ERR, QString("GetImageFile - File Does not exist %1.").arg(sFullFileName)); return QFileInfo(); } QString sNewFileName = QString( "%1.%2x%3.jpg" ) .arg( sFullFileName ) .arg( nWidth ) .arg( nHeight ); // ---------------------------------------------------------------------- // check to see if image is already created. // ---------------------------------------------------------------------- if (QFile::exists( sNewFileName )) return QFileInfo( sNewFileName ); // ---------------------------------------------------------------------- // Must generate Generate Image and save. // ---------------------------------------------------------------------- float fAspect = 0.0; QImage *pImage = new QImage( sFullFileName); if (!pImage) return QFileInfo(); if (fAspect <= 0) fAspect = (float)(pImage->width()) / pImage->height(); if ( nWidth == 0 ) nWidth = (int)rint(nHeight * fAspect); if ( nHeight == 0 ) nHeight = (int)rint(nWidth / fAspect); QImage img = pImage->scaled( nWidth, nHeight, Qt::KeepAspectRatio, Qt::SmoothTransformation); QByteArray fname = sNewFileName.toLatin1(); img.save( fname.constData(), "JPG", 60 ); delete pImage; return QFileInfo( sNewFileName ); }
FormMessage::FormMessage (QWidget* parent, bool is_reply, const AMessageInfoGUI& info, int edit_id) : FormMessageUI (parent) { m_text_changed = false; if (edit_id != 0) is_reply = false; m_edit_id = edit_id; connect(m_text_view->View->page(), SIGNAL(linkClicked(const QUrl&)), this, SLOT(link_clicked(const QUrl&))); connect(m_text_view->View->page(), SIGNAL(linkHovered(const QString&, const QString&, const QString&)), this, SLOT(link_hover(const QString&, const QString&, const QString&))); m_forum_tree = NULL; m_main_form = NULL; m_info = info; if (m_edit_id == 0) { m_info.IDParent = m_info.ID; m_info.ID = 0; } // получение информации о форуме сообщения // работает "по тихому", т.к. если возникнет ошибка, то это не сильно принципиально // и можно продолжать нормальную работу, а не пугать пользователя // https://rsdn.ru/forum/janus/3315591.1 std::auto_ptr<IAStorage> storage(AStorageFactory::getStorage()); if (storage.get() != NULL) { AForumInfo forum_info; if (storage->getForumInfo(m_info.IDForum, forum_info) != false) m_forum_info = forum_info; } // формирование текста при ответе if (is_reply == true) { QString subject = m_info.Subject; QString body = m_info.Message; // // корректировка темы // if (subject.length() > 3 && subject.mid(0, 4) == "Re: ") subject.insert(2, "[2]"); else if (subject.length() > 3 && subject.mid(0, 3) == "Re[") { int pos = subject.indexOf("]"); if (pos != -1) { int num = subject.mid(3, pos - 3).toInt(); if (num == 0) subject = "Re: " + subject; else { subject.remove(3, pos - 3); subject.insert(3, QString::number(num + 1)); } } else subject = "Re: " + subject; } else subject = "Re: " + subject; m_info.Subject = subject; // // корректировка тела сообщения // body = AFormatter::normalizeBody(body, info.UserNick).trimmed(); if (body.length() > 0) body += "\r\n\r\n"; if (info.IDUser == 0) body = QString::fromUtf8("Здравствуйте, Аноним, Вы писали:\r\n\r\n") + body; else body = QString::fromUtf8("Здравствуйте, ") + info.UserNick + QString::fromUtf8(", Вы писали:\r\n\r\n") + body; m_info.Message = body; } // if (is_reply == true) else { // замена HTML спец-символов m_info.Message.replace(">", ">"); m_info.Message.replace("<", "<"); m_info.Message.replace("&", "&"); } // удаление таглайнов QRegExp tagline("\\[tagline\\](.+)\\[/tagline\\]"); tagline.setMinimal(true); m_info.Message.replace(tagline, ""); //m_info.Message = m_info.Message.trimmed(); // установка остальных полей m_text_subject->setText(m_info.Subject); m_text_source->setPlainText(m_info.Message); text_subject_text_changed(m_info.Subject); if (is_reply == true) { QIcon icon; icon.addFile(":/icons/reply16.png", QSize(16, 16)); icon.addFile(":/icons/reply22.png", QSize(22, 22)); icon.addFile(":/icons/reply32.png", QSize(32, 32)); icon.addFile(":/icons/reply48.png", QSize(48, 48)); setWindowIcon(icon); m_text_source->setFocus(); m_text_source->moveCursor(QTextCursor::End, QTextCursor::MoveAnchor); } else if (m_edit_id != 0) { QIcon icon; icon.addFile(":/icons/edit16.png", QSize(16, 16)); icon.addFile(":/icons/edit22.png", QSize(22, 22)); icon.addFile(":/icons/edit32.png", QSize(32, 32)); icon.addFile(":/icons/edit48.png", QSize(48, 48)); icon.addFile(":/icons/edit64.png", QSize(64, 64)); setWindowIcon(icon); m_text_source->setFocus(); m_text_source->moveCursor(QTextCursor::End, QTextCursor::MoveAnchor); } else { m_text_subject->setFocus(); m_text_subject->selectAll(); } // установка обработчиков формы connect(m_button_send, SIGNAL(triggered()), this, SLOT(button_send_triggered())); connect(m_button_draft, SIGNAL(triggered()), this, SLOT(button_draft_triggered())); connect(m_text_subject, SIGNAL(textChanged(const QString&)), this, SLOT(text_subject_text_changed(const QString&))); connect(m_tab_message, SIGNAL(currentChanged(int)), this, SLOT(tab_changed(int))); connect(m_text_source, SIGNAL(textChanged()), this, SLOT(text_changed())); }
static Distribution* get_object_p() { return static_cast<Distribution*>(storage()); }
void EventArchiver::archiveIncidences( Calendar* calendar, const QDate& /*limitDate*/, QWidget* widget, const Incidence::List& incidences, bool /*withGUI*/) { FileStorage storage( calendar ); // Save current calendar to disk KTempFile tmpFile; tmpFile.setAutoDelete(true); storage.setFileName( tmpFile.name() ); if ( !storage.save() ) { kdDebug(5850) << "EventArchiver::archiveEvents(): Can't save calendar to temp file" << endl; return; } // Duplicate current calendar by loading in new calendar object CalendarLocal archiveCalendar( KOPrefs::instance()->mTimeZoneId ); FileStorage archiveStore( &archiveCalendar ); archiveStore.setFileName( tmpFile.name() ); if (!archiveStore.load()) { kdDebug(5850) << "EventArchiver::archiveEvents(): Can't load calendar from temp file" << endl; return; } // Strip active events from calendar so that only events to be archived // remain. This is not really efficient, but there is no other easy way. QStringList uids; Incidence::List allIncidences = archiveCalendar.rawIncidences(); Incidence::List::ConstIterator it; for( it = incidences.begin(); it != incidences.end(); ++it ) { uids << (*it)->uid(); } for( it = allIncidences.begin(); it != allIncidences.end(); ++it ) { if ( !uids.contains( (*it)->uid() ) ) { archiveCalendar.deleteIncidence( *it ); } } // Get or create the archive file KURL archiveURL( KOPrefs::instance()->mArchiveFile ); QString archiveFile; if ( KIO::NetAccess::exists( archiveURL, true, widget ) ) { if( !KIO::NetAccess::download( archiveURL, archiveFile, widget ) ) { kdDebug(5850) << "EventArchiver::archiveEvents(): Can't download archive file" << endl; return; } // Merge with events to be archived. archiveStore.setFileName( archiveFile ); if ( !archiveStore.load() ) { kdDebug(5850) << "EventArchiver::archiveEvents(): Can't merge with archive file" << endl; return; } } else { archiveFile = tmpFile.name(); } // Save archive calendar if ( !archiveStore.save() ) { KMessageBox::error(widget,i18n("Cannot write archive file %1.").arg( archiveStore.fileName() )); return; } // Upload if necessary KURL srcUrl; srcUrl.setPath(archiveFile); if (srcUrl != archiveURL) { if ( !KIO::NetAccess::upload( archiveFile, archiveURL, widget ) ) { KMessageBox::error(widget,i18n("Cannot write archive to final destination.")); return; } } KIO::NetAccess::removeTempFile(archiveFile); // Delete archived events from calendar for( it = incidences.begin(); it != incidences.end(); ++it ) { calendar->deleteIncidence( *it ); } emit eventsDeleted(); }
void MetaData::typed_data::getData( uint32_t *type, const void **data, size_t *size) const { *type = mType; *size = mSize; *data = storage(); }
void testTrainICAAMGray() { std::cout << "trainICTest testTrainICAAMGray" << std::endl; aam::AppearanceDataIC model; aam::TrainModelLoader loader; loader.useGrayImages(true); for (int i = 0; i < TRIANGLES_COUNT; i++) { model.triangles.push_back(cv::Vec3i(trianglesData[i * 3], trianglesData[i * 3 + 1], trianglesData[i * 3 + 2])); } try { std::vector<std::string> fileNames = boost::assign::list_of<std::string> ("107_0764.bmp") /*("107_0766.bmp")*/ ("107_0779.bmp") ("107_0780.bmp") ("107_0781.bmp") ("107_0782.bmp") ("107_0783.bmp") ("107_0784.bmp") ("107_0785.bmp") ("107_0786.bmp") ("107_0787.bmp") ("107_0788.bmp") ("107_0789.bmp") ("107_0790.bmp") ("107_0791.bmp") ("107_0792.bmp") ("107_0793.bmp") ("107_0794.bmp") ("107_0795.bmp") ("107_0798.bmp") ("107_0799.bmp") ("107_0800.bmp") ("108_0801.bmp") ("108_0802.bmp") ("108_0803.bmp") ("108_0804.bmp"); for (int i = 0; i < fileNames.size(); i++) { std::ostringstream stream; stream << "data/cootes/" << fileNames[i] << ".mat.dat"; std::string markupFile = stream.str(); stream.str(std::string()); stream << "data/cootes/" << fileNames[i]; std::string imageFile = stream.str(); loader.load(markupFile, imageFile); } std::vector<aam::TrainModelInfo> trainData = loader.getModels(); aam::AAMFunctions2D::trainModelIC(0.95, trainData, model); if (!boost::filesystem::exists("output")) { boost::filesystem::create_directory("output"); } cv::FileStorage storage("output/aam_ic_test.xml", cv::FileStorage::WRITE); storage << "R" << model.R; storage << "s" << model.s; storage << "s_star" << model.sStar; storage << "s0" << model.s0; storage << "A0" << model.A0; storage << "mask" << model.mask; storage << "triangles" << model.triangles; cv::Mat1i tmp(2, 1); tmp(0, 0) = model.textureSize.width; tmp(1, 0) = model.textureSize.height; storage << "texture_size" << tmp; storage.release(); aam::RealMatrix targetR; if (!loadVector("data/aam_r_vectors.raw", model.nPixels, 20, targetR)) { std::cout << "%TEST_FAILED% time=0 testname=testTrainICAAMGray (trainICTest) message=Can't reference R matrix" << std::endl; return; } aam::RealMatrix targetA; if (!loadVector("data/aam_a_vectors.raw", model.nPixels, 22, targetA)) { std::cout << "%TEST_FAILED% time=0 testname=testTrainICAAMGray (trainICTest) message=Can't reference A matrix" << std::endl; return; } cv::Mat m, s; cv::meanStdDev(model.A, m, s); std::cout << m << std::endl; std::cout << s << std::endl; cv::meanStdDev(targetA, m, s); std::cout << m << std::endl; std::cout << s << std::endl; aam::RealMatrix Rsum, Rsum2; cv::reduce(model.R.t(), Rsum, 1, CV_REDUCE_SUM); cv::reduce(targetR, Rsum2, 1, CV_REDUCE_SUM); cv::Mat img, img2; aam::AAMFunctions2D::vector2Appearance(Rsum, model.mask, model.textureSize, img); aam::AAMFunctions2D::vector2Appearance(Rsum2, model.mask, model.textureSize, img2); cv::normalize(img2, img, 1, 0, cv::NORM_MINMAX); cv::imshow("test", img); cv::waitKey(0); } catch (std::exception& e) { std::cout << "%TEST_FAILED% time=0 testname=testTrainICAAMGray (trainICTest) message=Exception occured: " << e.what() << std::endl; } }
SkColorSpaceXform_A2B::SkColorSpaceXform_A2B(SkColorSpace_A2B* srcSpace, SkColorSpace_XYZ* dstSpace) : fLinearDstGamma(kLinear_SkGammaNamed == dstSpace->gammaNamed()) { #if (SkCSXformPrintfDefined) static const char* debugGammaNamed[4] = { "Linear", "SRGB", "2.2", "NonStandard" }; static const char* debugGammas[5] = { "None", "Named", "Value", "Table", "Param" }; #endif int currentChannels; switch (srcSpace->iccType()) { case SkColorSpace_Base::kRGB_ICCTypeFlag: currentChannels = 3; break; case SkColorSpace_Base::kCMYK_ICCTypeFlag: currentChannels = 4; // CMYK images from JPEGs (the only format that supports it) are actually // inverted CMYK, so we need to invert every channel. // TransferFn is y = -x + 1 for x < 1.f, otherwise 0x + 0, ie y = 1 - x for x in [0,1] this->addTransferFns({1.f, 0.f, 0.f, -1.f, 1.f, 0.f, 1.f}, 4); break; default: currentChannels = 0; SkASSERT(false); } // add in all input color space -> PCS xforms for (int i = 0; i < srcSpace->count(); ++i) { const SkColorSpace_A2B::Element& e = srcSpace->element(i); SkASSERT(e.inputChannels() == currentChannels); currentChannels = e.outputChannels(); switch (e.type()) { case SkColorSpace_A2B::Element::Type::kGammaNamed: if (kLinear_SkGammaNamed == e.gammaNamed()) { break; } // take the fast path for 3-channel named gammas if (3 == currentChannels) { if (k2Dot2Curve_SkGammaNamed == e.gammaNamed()) { SkCSXformPrintf("fast path from 2.2\n"); fElementsPipeline.append(SkRasterPipeline::from_2dot2); break; } else if (kSRGB_SkGammaNamed == e.gammaNamed()) { SkCSXformPrintf("fast path from sRGB\n"); // Images should always start the pipeline as unpremul fElementsPipeline.append_from_srgb(kUnpremul_SkAlphaType); break; } } SkCSXformPrintf("Gamma stage added: %s\n", debugGammaNamed[(int)e.gammaNamed()]); SkColorSpaceTransferFn fn; SkAssertResult(named_to_parametric(&fn, e.gammaNamed())); this->addTransferFns(fn, currentChannels); break; case SkColorSpace_A2B::Element::Type::kGammas: { const SkGammas& gammas = e.gammas(); SkCSXformPrintf("Gamma stage added:"); for (int channel = 0; channel < gammas.channels(); ++channel) { SkCSXformPrintf(" %s", debugGammas[(int)gammas.type(channel)]); } SkCSXformPrintf("\n"); bool gammaNeedsRef = false; for (int channel = 0; channel < gammas.channels(); ++channel) { if (SkGammas::Type::kTable_Type == gammas.type(channel)) { SkTableTransferFn table = { gammas.table(channel), gammas.data(channel).fTable.fSize, }; this->addTableFn(table, channel); gammaNeedsRef = true; } else { SkColorSpaceTransferFn fn; SkAssertResult(gamma_to_parametric(&fn, gammas, channel)); this->addTransferFn(fn, channel); } } if (gammaNeedsRef) { fGammaRefs.push_back(sk_ref_sp(&gammas)); } break; } case SkColorSpace_A2B::Element::Type::kCLUT: SkCSXformPrintf("CLUT (%d -> %d) stage added\n", e.colorLUT().inputChannels(), e.colorLUT().outputChannels()); fCLUTs.push_back(sk_ref_sp(&e.colorLUT())); fElementsPipeline.append(SkRasterPipeline::color_lookup_table, fCLUTs.back().get()); break; case SkColorSpace_A2B::Element::Type::kMatrix: if (!e.matrix().isIdentity()) { SkCSXformPrintf("Matrix stage added\n"); addMatrix(e.matrix()); } break; } } // Lab PCS -> XYZ PCS if (SkColorSpace_A2B::PCS::kLAB == srcSpace->pcs()) { SkCSXformPrintf("Lab -> XYZ element added\n"); fElementsPipeline.append(SkRasterPipeline::lab_to_xyz); } // we should now be in XYZ PCS SkASSERT(3 == currentChannels); // and XYZ PCS -> output color space xforms if (!dstSpace->fromXYZD50()->isIdentity()) { addMatrix(*dstSpace->fromXYZD50()); } switch (dstSpace->gammaNamed()) { case kLinear_SkGammaNamed: // do nothing break; case k2Dot2Curve_SkGammaNamed: fElementsPipeline.append(SkRasterPipeline::to_2dot2); break; case kSRGB_SkGammaNamed: fElementsPipeline.append(SkRasterPipeline::to_srgb); break; case kNonStandard_SkGammaNamed: { for (int channel = 0; channel < 3; ++channel) { const SkGammas& gammas = *dstSpace->gammas(); if (SkGammas::Type::kTable_Type == gammas.type(channel)) { static constexpr int kInvTableSize = 256; std::vector<float> storage(kInvTableSize); invert_table_gamma(storage.data(), nullptr, storage.size(), gammas.table(channel), gammas.data(channel).fTable.fSize); SkTableTransferFn table = { storage.data(), (int) storage.size(), }; fTableStorage.push_front(std::move(storage)); this->addTableFn(table, channel); } else { SkColorSpaceTransferFn fn; SkAssertResult(gamma_to_parametric(&fn, gammas, channel)); this->addTransferFn(fn.invert(), channel); } } } break; } }
void GroundProgramBuilder::add() { switch(stack_->type) { case LIT: { stack_->lits.push_back(Lit::create(stack_->type, stack_->vals.size() - stack_->n - 1, stack_->n)); break; } case TERM: { if(stack_->n > 0) { ValVec vals; std::copy(stack_->vals.end() - stack_->n, stack_->vals.end(), std::back_inserter(vals)); stack_->vals.resize(stack_->vals.size() - stack_->n); uint32_t name = stack_->vals.back().index; stack_->vals.back() = Val::func(storage()->index(Func(storage(), name, vals))); } break; } case AGGR_SUM: case AGGR_COUNT: case AGGR_AVG: case AGGR_MIN: case AGGR_MAX: case AGGR_EVEN: case AGGR_EVEN_SET: case AGGR_ODD: case AGGR_ODD_SET: case AGGR_DISJUNCTION: { assert(stack_->type != AGGR_DISJUNCTION || stack_->n > 0); std::copy(stack_->lits.end() - stack_->n, stack_->lits.end(), std::back_inserter(stack_->aggrLits)); stack_->lits.resize(stack_->lits.size() - stack_->n); stack_->lits.push_back(Lit::create(stack_->type, stack_->n ? stack_->aggrLits.size() - stack_->n : stack_->vals.size() - 2, stack_->n)); break; } case STM_RULE: case STM_CONSTRAINT: { Rule::Printer *printer = output_->printer<Rule::Printer>(); printer->begin(); if(stack_->type == STM_RULE) { printLit(printer, stack_->lits.size() - stack_->n - 1, true); } printer->endHead(); for(uint32_t i = stack_->n; i >= 1; i--) { printLit(printer, stack_->lits.size() - i, false); } printer->end(); pop(stack_->n + (stack_->type == STM_RULE)); break; } case STM_SHOW: case STM_HIDE: { Display::Printer *printer = output_->printer<Display::Printer>(); printLit(printer, stack_->lits.size() - 1, stack_->type == STM_SHOW); pop(1); break; } case STM_EXTERNAL: { External::Printer *printer = output_->printer<External::Printer>(); printLit(printer, stack_->lits.size() - 1, true); pop(1); break; } #pragma message "reimplement this" /* case STM_MINIMIZE: case STM_MAXIMIZE: case STM_MINIMIZE_SET: case STM_MAXIMIZE_SET: { Optimize::Printer *printer = output_->printer<Optimize::Printer>(); bool maximize = (stack_->type == STM_MAXIMIZE || stack_->type == STM_MAXIMIZE_SET); bool set = (stack_->type == STM_MINIMIZE_SET || stack_->type == STM_MAXIMIZE_SET); printer->begin(maximize, set); for(uint32_t i = stack_->n; i >= 1; i--) { Lit &a = stack_->lits[stack_->lits.size() - i]; Val prio = stack_->vals[a.offset + a.n + 2]; Val weight = stack_->vals[a.offset + a.n + 1]; printer->print(predLitRep(a), weight.num, prio.num); } printer->end(); pop(stack_->n); break; } */ case STM_COMPUTE: { Compute::Printer *printer = output_->printer<Compute::Printer>(); for(uint32_t i = stack_->n; i >= 1; i--) { Lit &a = stack_->lits[stack_->lits.size() - i]; printer->print(predLitRep(a)); } pop(stack_->n); break; } #pragma message "reimplement me!" //case META_SHOW: //case META_HIDE: // case META_EXTERNAL: // { // Val num = stack_->vals.back(); // stack_->vals.pop_back(); // Val id = stack_->vals.back(); // stack_->vals.pop_back(); // assert(id.type == Val::ID); // assert(num.type == Val::NUM); // storage()->newDomain(id.index, num.num); // if(stack_->type == META_EXTERNAL) { output_->external(id.index, num.num); } // //else { output_->show(id.index, num.num, stack_->type == META_SHOW); } // break; // } #pragma message "reimplement me!" //case META_GLOBALSHOW: case META_GLOBALHIDE: { output_->hideAll(); break; } default: { doAdd(); } } }