int V4L2JpegEncoder::run(void)
{
int ret;
sp<Buffer> thumbData;
sp<Buffer> exifData;
TRACE();
ret = openDevice();
if (ret < 0) {
ERR("Failed to open JPEG encoder device");
return -1;
}
if (thumbnail.allocation != 0) {
ret = encodeImage(&thumbnail);
if (ret >= 0) {
V4L2Buffer *buf =
output.allocation->getBuffer(0);
thumbData = new Buffer(buf->getUsed(),
buf->getAddress());
}
}
ret = encodeImage(&input);
if (ret < 0) {
ERR("Failed to encode JPEG image");
closeDevice();
return -1;
}
closeDevice();
uint32_t exifSize = EXIF_SIZE;
if (thumbData != 0)
exifSize += thumbData->getSize();
exifData = new Buffer(exifSize);
if (exifData == 0 || !exifData->initCheck()) {
ERR("Failed to allocate exif buffer");
return -1;
}
exifData->zero();
exifSize = buildExif(exifData, thumbData);
V4L2Buffer *buf = output.allocation->getBuffer(0);
char *addr = (char *)buf->getAddress();
memmove(addr + exifSize, addr, buf->getUsed());
memcpy(addr, addr + exifSize, 2);
memcpy(addr + 2, exifData->getData(), exifSize);
return buf->getUsed() + exifSize;
}
virtual void encode()
{
mImgs = boost::shared_ptr<boost::circular_buffer<CameraImage> >(new boost::circular_buffer<CameraImage>(60));
while(1)
{
if(mImgs->size() == 0)
{
usleep(3000);
continue;
}
printf("encoding!\n");
CameraImage i = mImgs->back();
mImgs->pop_back();
encodeImage(i);
msgpack_sbuffer buffer;
msgpack_packer pk;
msgpack_sbuffer_init(&buffer);
msgpack_packer_init(&pk, &buffer, msgpack_sbuffer_write);
msgpack_pack_array(&pk, 4);
msgpack_pack_int(&pk, 1);
msgpack_pack_int(&pk, i.camera_timestamp);
msgpack_pack_raw(&pk, i.encoded.size);
msgpack_pack_raw_body(&pk, (void*)i.encoded.buffer.get(), i.encoded.size);
write(mFile, buffer.data, buffer.size);
msgpack_sbuffer_destroy(&buffer);
}
}
static void encodeDataObject(ArgumentEncoder* encoder, const DataObjectGtk* dataObject)
{
bool hasText = dataObject->hasText();
encoder->encode(hasText);
if (hasText)
encoder->encode(dataObject->text());
bool hasMarkup = dataObject->hasMarkup();
encoder->encode(hasMarkup);
if (hasMarkup)
encoder->encode(dataObject->markup());
bool hasURL = dataObject->hasURL();
encoder->encode(hasURL);
if (hasURL)
encoder->encode(dataObject->url().string());
bool hasURIList = dataObject->hasURIList();
encoder->encode(hasURIList);
if (hasURIList)
encoder->encode(dataObject->uriList());
bool hasImage = dataObject->hasImage();
encoder->encode(hasImage);
if (hasImage)
encodeImage(encoder, dataObject->image());
}
static void encodeDataObject(ArgumentEncoder& encoder, const DataObjectGtk* dataObject)
{
bool hasText = dataObject->hasText();
encoder << hasText;
if (hasText)
encoder << dataObject->text();
bool hasMarkup = dataObject->hasMarkup();
encoder << hasMarkup;
if (hasMarkup)
encoder << dataObject->markup();
bool hasURL = dataObject->hasURL();
encoder << hasURL;
if (hasURL)
encoder << dataObject->url().string();
bool hasURIList = dataObject->hasURIList();
encoder << hasURIList;
if (hasURIList)
encoder << dataObject->uriList();
bool hasImage = dataObject->hasImage();
encoder << hasImage;
if (hasImage)
encodeImage(encoder, dataObject->image());
bool hasUnknownTypeData = dataObject->hasUnknownTypeData();
encoder << hasUnknownTypeData;
if (hasUnknownTypeData)
encoder << dataObject->unknownTypes();
}
void ArgumentCoder<PasteboardImage>::encode(ArgumentEncoder& encoder, const WebCore::PasteboardImage& pasteboardImage)
{
encodeImage(encoder, pasteboardImage.image.get());
encoder << pasteboardImage.url.url;
encoder << pasteboardImage.url.title;
encoder << pasteboardImage.resourceMIMEType;
if (pasteboardImage.resourceData)
encodeSharedBuffer(encoder, pasteboardImage.resourceData.get());
}
String ImageDataBuffer::toDataURL(const String& mimeType, const double& quality) const
{
ASSERT(MIMETypeRegistry::isSupportedImageMIMETypeForEncoding(mimeType));
Vector<unsigned char> result;
if (!encodeImage(mimeType, quality, &result))
return "data:,";
return "data:" + mimeType + ";base64," + base64Encode(result);
}
String ImageDataBuffer::toDataURL(const String& mimeType, const double* quality) const
{
ASSERT(MIMETypeRegistry::isSupportedImageMIMETypeForEncoding(mimeType));
Vector<char> encodedImage;
if (!encodeImage(*this, mimeType, quality, &encodedImage))
return "data:,";
return "data:" + mimeType + ";base64," + base64Encode(encodedImage);
}
String ImageBuffer::toDataURL(const String& mimeType, const double* quality) const
{
ASSERT(MIMETypeRegistry::isSupportedImageMIMETypeForEncoding(mimeType));
Vector<char> encodedImage;
if (!isSurfaceValid() || !encodeImage(m_surface->bitmap(), mimeType, quality, &encodedImage))
return "data:,";
return "data:" + mimeType + ";base64," + base64Encode(encodedImage);
}
String ImageDataToDataURL(const ImageData& imageData, const String& mimeType, const double* quality)
{
ASSERT(MIMETypeRegistry::isSupportedImageMIMETypeForEncoding(mimeType));
Vector<char> encodedImage, base64Data;
if (!encodeImage(imageData, mimeType, quality, &encodedImage))
return "data:,";
base64Encode(encodedImage, base64Data);
return "data:" + mimeType + ";base64," + base64Data;
}
String ImageBuffer::toDataURL(const String& mimeType, const double* quality) const
{
ASSERT(MIMETypeRegistry::isSupportedImageMIMETypeForEncoding(mimeType));
Vector<char> encodedImage, base64Data;
SkDevice* device = context()->platformContext()->canvas()->getDevice();
if (!encodeImage(device->accessBitmap(false), mimeType, quality, &encodedImage))
return "data:,";
base64Encode(encodedImage, base64Data);
return "data:" + mimeType + ";base64," + base64Data;
}
String ImageBuffer::toDataURL(const String& mimeType, const double* quality, CoordinateSystem) const
{
ASSERT(MIMETypeRegistry::isSupportedImageMIMETypeForEncoding(mimeType));
Vector<char> encodedImage;
if (!encodeImage(*context()->platformContext()->bitmap(), mimeType, quality, &encodedImage))
return "data:,";
Vector<char> base64Data;
base64Encode(encodedImage, base64Data);
return "data:" + mimeType + ";base64," + base64Data;
}
String ImageBuffer::toDataURL(const String& mimeType, std::optional<double> quality, CoordinateSystem) const
{
ASSERT(MIMETypeRegistry::isSupportedImageMIMETypeForEncoding(mimeType));
GUniqueOutPtr<gchar> buffer;
gsize bufferSize;
if (!encodeImage(m_data.m_surface.get(), mimeType, quality, buffer, bufferSize))
return "data:,";
Vector<char> base64Data;
base64Encode(buffer.get(), bufferSize, base64Data);
return "data:" + mimeType + ";base64," + base64Data;
}
String ImageBuffer::toDataURL(const String& mimeType, const double* quality, CoordinateSystem) const
{
ASSERT(MIMETypeRegistry::isSupportedImageMIMETypeForEncoding(mimeType));
// QImageWriter does not support mimetypes. It does support Qt image formats (png,
// gif, jpeg..., xpm) so skip the image/ to get the Qt image format used to encode
// the m_pixmap image.
QByteArray data;
if (!encodeImage(m_data.m_pixmap, mimeType.substring(sizeof "image"), quality, data))
return "data:,";
return "data:" + mimeType + ";base64," + data.toBase64().data();
}
String ImageBuffer::toDataURL(const String& mimeType, const double*, CoordinateSystem) const
{
ASSERT(MIMETypeRegistry::isSupportedImageMIMETypeForEncoding(mimeType));
cairo_surface_t* image = cairo_get_target(context()->platformContext()->cr());
Vector<char> encodedImage;
if (!image || !encodeImage(image, mimeType, &encodedImage))
return "data:,";
Vector<char> base64Data;
base64Encode(encodedImage, base64Data);
return "data:" + mimeType + ";base64," + base64Data;
}
void ArgumentCoder<Cursor>::encode(ArgumentEncoder& encoder, const Cursor& cursor)
{
encoder.encodeEnum(cursor.type());
if (cursor.type() != Cursor::Custom)
return;
if (cursor.image()->isNull()) {
encoder << false; // There is no valid image being encoded.
return;
}
encoder << true;
encodeImage(encoder, cursor.image());
encoder << cursor.hotSpot();
}
virtual unsigned int encodeImage(cv::Mat inputImage,
unsigned char *outputBuffer,
unsigned int maxOutputLength) {
return encodeImage(inputImage, outputBuffer, maxOutputLength, DEFAULT_JPEG_QUALITY);
}
void PackWcle::pack(OutputFile *fo)
{
handleStub(fo);
if (ih.byte_order || ih.word_order
|| ih.exe_format_level
|| ih.cpu_type < 2 || ih.cpu_type > 5
|| ih.target_os != 1
|| ih.module_type != 0x200
|| ih.object_iterate_data_map_offset
|| ih.resource_entries
|| ih.module_directives_entries
|| ih.imported_modules_count
|| ih.object_table_entries > 255)
throwCantPack("watcom/le: unexpected value in header");
readObjectTable();
readPageMap();
readResidentNames();
readEntryTable();
readFixupPageTable();
readFixups();
readImage();
readNonResidentNames();
// if (find_le32(iimage,20,get_le32("UPX ")) >= 0)
if (find_le32(iimage,UPX_MIN(soimage,256u),UPX_MAGIC_LE32) >= 0)
throwAlreadyPacked();
if (ih.init_ss_object != objects)
throwCantPack("the stack is not in the last object");
preprocessFixups();
const unsigned text_size = IOT(ih.init_cs_object-1,npages) * mps;
const unsigned text_vaddr = IOT(ih.init_cs_object-1,my_base_address);
// attach some useful data at the end of preprocessed fixups
ifixups[sofixups++] = (unsigned char) (ih.automatic_data_object & 0xff);
unsigned ic = objects*sizeof(*iobject_table);
memcpy(ifixups+sofixups,iobject_desc,ic);
iobject_desc.dealloc();
sofixups += ic;
set_le32(ifixups+sofixups,ih.init_esp_offset+IOT(ih.init_ss_object-1,my_base_address)); // old stack pointer
set_le32(ifixups+sofixups+4,ih.init_eip_offset+text_vaddr); // real entry point
set_le32(ifixups+sofixups+8,mps*pages); // virtual address of unpacked relocations
ifixups[sofixups+12] = (unsigned char) (unsigned) objects;
sofixups += 13;
// prepare filter
Filter ft(ph.level);
ft.buf_len = text_size;
ft.addvalue = text_vaddr;
// compress
encodeImage(&ft);
const unsigned lsize = getLoaderSize();
neweip = getLoaderSection("WCLEMAIN");
int e_len = getLoaderSectionStart("WCLECUTP");
const unsigned d_len = lsize - e_len;
assert(e_len > 0 && e_len < RESERVED);
memmove(oimage+e_len,oimage+RESERVED,soimage);
soimage += lsize;
opages = (soimage+mps-1)/mps;
oh.bytes_on_last_page = soimage%mps;
encodeObjectTable();
encodeFixups();
encodeFixupPageTable();
encodePageMap();
encodeEntryTable();
encodeResidentNames();
encodeNonResidentNames();
// patch loader
ic = (OOT(0,virtual_size) - d_len) &~ 15;
assert(ic > ((ph.u_len + ph.overlap_overhead + 31) &~ 15));
linker->defineSymbol("WCLECUTP", ic);
linker->defineSymbol("original_entry", ih.init_eip_offset + text_vaddr);
linker->defineSymbol("original_stack", ih.init_esp_offset +
IOT(ih.init_ss_object - 1, my_base_address));
linker->defineSymbol("start_of_relocs", mps*pages);
defineDecompressorSymbols();
defineFilterSymbols(&ft);
linker->defineSymbol("filter_buffer_start", text_vaddr);
unsigned jpos = (((ph.c_len + 3) &~ 3) + d_len + 3) / 4;
linker->defineSymbol("words_to_copy", jpos);
linker->defineSymbol("copy_dest", ((ic + d_len + 3) &~ 3) - 4);
linker->defineSymbol("copy_source", e_len + jpos * 4 - 4);
relocateLoader();
MemBuffer loader(lsize);
memcpy(loader, getLoader(), lsize);
patchPackHeader(loader, lsize);
memcpy(oimage, loader, e_len);
memcpy(oimage + soimage - d_len, loader + e_len, d_len);
writeFile(fo, opt->watcom_le.le);
// verify
verifyOverlappingDecompression(oimage + e_len, oimage.getSize() - e_len);
// copy the overlay
const unsigned overlaystart = ih.data_pages_offset + exe_offset
+ getImageSize();
const unsigned overlay = file_size - overlaystart - ih.non_resident_name_table_length;
checkOverlay(overlay);
copyOverlay(fo, overlay, &oimage);
// finally check the compression ratio
if (!checkFinalCompressionRatio(fo))
throwNotCompressible();
}
