TagLib::ByteVector TagLib::EncodeBase64(const TagLib::ByteVector& input)
{
SFB::CFError error;
SFB::SecTransform encoder(SecEncodeTransformCreate(kSecBase64Encoding, &error));
if(!encoder) {
LOGGER_WARNING("org.sbooth.AudioEngine", "SecEncodeTransformCreate failed: " << error);
return {};
}
SFB::CFData sourceData(CFDataCreateWithBytesNoCopy(kCFAllocatorDefault, (const UInt8 *)input.data(), (CFIndex)input.size(), kCFAllocatorNull));
if(!sourceData)
return {};
if(!SecTransformSetAttribute(encoder, kSecTransformInputAttributeName, sourceData, &error)) {
LOGGER_WARNING("org.sbooth.AudioEngine", "SecTransformSetAttribute failed: " << error);
return {};
}
SFB::CFData encodedData((CFDataRef)SecTransformExecute(encoder, &error));
if(!encodedData) {
LOGGER_WARNING("org.sbooth.AudioEngine", "SecTransformExecute failed: " << error);
return {};
}
return {(const char *)CFDataGetBytePtr((CFDataRef)encodedData), (size_t)CFDataGetLength((CFDataRef)encodedData)};
}
void CGroupListView::dropEvent(QDropEvent *event)
{
emit info(QString());
drawHighlighter(QModelIndex());
if(event->mimeData()->hasFormat(KFI_FONT_DRAG_MIME))
{
event->acceptProposedAction();
QSet<QString> families;
QByteArray encodedData(event->mimeData()->data(KFI_FONT_DRAG_MIME));
QDataStream ds(&encodedData, QIODevice::ReadOnly);
QModelIndex from(selectedIndexes().last()),
to(indexAt(event->pos()));
ds >> families;
// Are we mvoeing/copying, removing a font from the current group?
if(to.isValid() && from.isValid())
{
if( ((static_cast<CGroupListItem *>(from.internalPointer()))->isSystem() &&
(static_cast<CGroupListItem *>(to.internalPointer()))->isPersonal()) ||
((static_cast<CGroupListItem *>(from.internalPointer()))->isPersonal() &&
(static_cast<CGroupListItem *>(to.internalPointer()))->isSystem()))
QTimer::singleShot(0, this, SLOT(emitMoveFonts()));
else if((static_cast<CGroupListItem *>(from.internalPointer()))->isCustom() &&
!(static_cast<CGroupListItem *>(to.internalPointer()))->isCustom())
emit removeFamilies(from, families);
else
emit addFamilies(to, families);
}
if(isUnclassified())
emit unclassifiedChanged();
}
void Page::userStyleSheetLocationChanged()
{
// FIXME: Eventually we will move to a model of just being handed the sheet
// text instead of loading the URL ourselves.
KURL url = m_settings->userStyleSheetLocation();
if (url.isLocalFile())
m_userStyleSheetPath = url.fileSystemPath();
else
m_userStyleSheetPath = String();
m_didLoadUserStyleSheet = false;
m_userStyleSheet = String();
m_userStyleSheetModificationTime = 0;
// Data URLs with base64-encoded UTF-8 style sheets are common. We can process them
// synchronously and avoid using a loader.
if (url.protocolIs("data") && url.string().startsWith("data:text/css;charset=utf-8;base64,")) {
m_didLoadUserStyleSheet = true;
const unsigned prefixLength = 35;
Vector<char> encodedData(url.string().length() - prefixLength);
for (unsigned i = prefixLength; i < url.string().length(); ++i)
encodedData[i - prefixLength] = static_cast<char>(url.string()[i]);
Vector<char> styleSheetAsUTF8;
if (base64Decode(encodedData, styleSheetAsUTF8))
m_userStyleSheet = String::fromUTF8(styleSheetAsUTF8.data(), styleSheetAsUTF8.size());
}
for (Frame* frame = mainFrame(); frame; frame = frame->tree()->traverseNext()) {
if (frame->document())
frame->document()->clearPageUserSheet();
}
}
/**
* First, make sure that writing an 8-bit RGBA KTX file and then
* reading it produces the same bitmap.
*/
DEF_TEST(KtxReadWrite, reporter) {
// Random number generator with explicit seed for reproducibility
SkRandom rand(0x1005cbad);
SkBitmap bm8888;
bool pixelsAllocated = bm8888.allocN32Pixels(128, 128);
REPORTER_ASSERT(reporter, pixelsAllocated);
uint8_t *pixels = reinterpret_cast<uint8_t*>(bm8888.getPixels());
REPORTER_ASSERT(reporter, NULL != pixels);
if (NULL == pixels) {
return;
}
uint8_t *row = pixels;
for (int y = 0; y < bm8888.height(); ++y) {
for (int x = 0; x < bm8888.width(); ++x) {
uint8_t a = rand.nextRangeU(0, 255);
uint8_t r = rand.nextRangeU(0, 255);
uint8_t g = rand.nextRangeU(0, 255);
uint8_t b = rand.nextRangeU(0, 255);
SkPMColor &pixel = *(reinterpret_cast<SkPMColor*>(row + x*sizeof(SkPMColor)));
pixel = SkPreMultiplyARGB(a, r, g, b);
}
row += bm8888.rowBytes();
}
REPORTER_ASSERT(reporter, !(bm8888.empty()));
SkAutoDataUnref encodedData(SkImageEncoder::EncodeData(bm8888, SkImageEncoder::kKTX_Type, 0));
REPORTER_ASSERT(reporter, NULL != encodedData);
SkAutoTUnref<SkMemoryStream> stream(SkNEW_ARGS(SkMemoryStream, (encodedData)));
REPORTER_ASSERT(reporter, NULL != stream);
SkBitmap decodedBitmap;
bool imageDecodeSuccess = SkImageDecoder::DecodeStream(stream, &decodedBitmap);
REPORTER_ASSERT(reporter, imageDecodeSuccess);
REPORTER_ASSERT(reporter, decodedBitmap.colorType() == bm8888.colorType());
REPORTER_ASSERT(reporter, decodedBitmap.alphaType() == bm8888.alphaType());
REPORTER_ASSERT(reporter, decodedBitmap.width() == bm8888.width());
REPORTER_ASSERT(reporter, decodedBitmap.height() == bm8888.height());
REPORTER_ASSERT(reporter, !(decodedBitmap.empty()));
uint8_t *decodedPixels = reinterpret_cast<uint8_t*>(decodedBitmap.getPixels());
REPORTER_ASSERT(reporter, NULL != decodedPixels);
REPORTER_ASSERT(reporter, decodedBitmap.getSize() == bm8888.getSize());
if (NULL == decodedPixels) {
return;
}
REPORTER_ASSERT(reporter, memcmp(decodedPixels, pixels, decodedBitmap.getSize()) == 0);
}
string HttpRequest::buildRequest()
{
// location is anything that comes after the first '/'
TNL::U32 index = mUrl.find('/');
string location = mUrl.substr(index, mUrl.length() - index);
// request line
mRequest = mMethod + " " + location + " HTTP/1.0";
// content type and data encoding for POST requests
if(mMethod == PostMethod)
{
stringstream encodedData("");
for(map<string, string>::iterator it = mData.begin(); it != mData.end(); it++)
{
encodedData << "--" + HttpRequestBoundary + "\r\n";
encodedData << "Content-Disposition: form-data; name=\"" + (*it).first + "\"\r\n\r\n";
encodedData << (*it).second + "\r\n";
}
for(list<HttpRequestFileInfo>::iterator it = mFiles.begin(); it != mFiles.end(); it++)
{
stringstream fileData;
fileData.write((const char*) (*it).data, (*it).length);
encodedData << "--" + HttpRequestBoundary + "\r\n";
encodedData << "Content-Disposition: form-data; name=\"" + (*it).fieldName + "\"; filename=\"" + (*it).fileName + "\"\r\n";
encodedData << "Content-Type: image/png\r\n";
encodedData << "Content-Transfer-Encoding: binary\r\n\r\n";
encodedData << fileData.str();
encodedData << "\r\n";
}
encodedData << "--" + HttpRequestBoundary + "\r\n";
char contentLengthHeaderBuffer[1024] = { 0 };
dSprintf(contentLengthHeaderBuffer, 1024, "\r\nContent-Length: %d", (U32) encodedData.tellp());
mRequest += contentLengthHeaderBuffer;
mRequest += "\r\nUser-Agent: Bitfighter";
mRequest += "\r\nContent-Type: multipart/form-data, boundary=" + HttpRequestBoundary;
mRequest += "\r\n\r\n";
mRequest += encodedData.str();
}
else
{
mRequest += "\r\n\r\n";
}
return mRequest;
}
void HuffmanCompressor::compress(int size, const INT16 *data, Bitset &transmitData)
{
// Find frequency of each value
for (UINT i = 0; i < size; ++i)
++dataFrequency[data[i]];
dataFrequency[INT16_MAX] = 1; // use max value as the pseudo EOF
// Store each frequency as a (leaf) node in minimum heap
for (auto it = dataFrequency.begin(); it != dataFrequency.end(); ++it) {
Node *node = new Node(it->first, it->second);
minHeap.push(node);
}
// Generate Huffman tree
while (minHeap.size() != 1) {
Node *right = minHeap.top();
minHeap.pop();
Node *left = minHeap.top();
minHeap.pop();
minHeap.push(new Node(left->frequency + right->frequency, left, right)); // Create internal node
}
Node *huffmanTree = minHeap.top();
// Get Huffman codes for each value and generate encoded Huffman tree
std::string code("");
std::string encodedHuffmanTree("");
getHuffmanCode(huffmanTree, code, encodedHuffmanTree);
std::reverse(encodedHuffmanTree.begin(), encodedHuffmanTree.end()); // TODO: try encodedHuffmanTree = bit + encodedHuffmanTree to see if performance is better
// Encode data values
std::string encodedData("");
for (UINT i = 0; i < size; ++i) {
encodedData += huffmanCodes[data[i]];
}
encodedData += huffmanCodes[INT16_MAX]; // add pseudo EOF
std::reverse(encodedData.begin(), encodedData.end());
// Convert data to bit array
transmitData = Bitset(encodedData + encodedHuffmanTree);
// Deallocate memory
deallocateTree(huffmanTree);
minHeap.pop();
dataFrequency.clear();
huffmanCodes.clear();
}
/**
* SkDecodingImageGenerator has an Options struct which lets the
* client of the generator set sample size, dithering, and bitmap
* config. This test loops through many possible options and tries
* them on a set of 5 small encoded images (each in a different
* format). We test both SkData and SkStreamRewindable decoding.
*/
DEF_TEST(ImageDecoderOptions, reporter) {
const char* files[] = {
"randPixels.bmp",
"randPixels.jpg",
"randPixels.png",
"randPixels.webp",
#if !defined(SK_BUILD_FOR_WIN)
// TODO(halcanary): Find out why this fails sometimes.
"randPixels.gif",
#endif
};
SkString resourceDir = GetResourcePath();
if (!sk_exists(resourceDir.c_str())) {
return;
}
int scaleList[] = {1, 2, 3, 4};
bool ditherList[] = {true, false};
SkColorType colorList[] = {
kAlpha_8_SkColorType,
kRGB_565_SkColorType,
kARGB_4444_SkColorType, // Most decoders will fail on 4444.
kN32_SkColorType
// Note that indexed color is left out of the list. Lazy
// decoding doesn't do indexed color.
};
const bool useDataList[] = {true, false};
for (size_t fidx = 0; fidx < SK_ARRAY_COUNT(files); ++fidx) {
SkString path = SkOSPath::SkPathJoin(resourceDir.c_str(), files[fidx]);
if (!sk_exists(path.c_str())) {
continue;
}
SkAutoDataUnref encodedData(SkData::NewFromFileName(path.c_str()));
REPORTER_ASSERT(reporter, encodedData.get() != NULL);
SkAutoTUnref<SkStreamRewindable> encodedStream(
SkStream::NewFromFile(path.c_str()));
REPORTER_ASSERT(reporter, encodedStream.get() != NULL);
for (size_t i = 0; i < SK_ARRAY_COUNT(scaleList); ++i) {
for (size_t j = 0; j < SK_ARRAY_COUNT(ditherList); ++j) {
for (size_t m = 0; m < SK_ARRAY_COUNT(useDataList); ++m) {
for (size_t k = 0; k < SK_ARRAY_COUNT(colorList); ++k) {
SkDecodingImageGenerator::Options opts(scaleList[i],
ditherList[j],
colorList[k]);
test_options(reporter, opts, encodedStream, encodedData,
useDataList[m], path);
}
SkDecodingImageGenerator::Options options(scaleList[i],
ditherList[j]);
test_options(reporter, options, encodedStream, encodedData,
useDataList[m], path);
}
}
}
}
}
