static void compressor_fixup_params(struct compress_params *params) { compressor(params->type)->fixup_params(params); if (params->level < 0) params->level = compressor(params->type)->default_level; }
int main(void) { signed int fridgeTemp; signed int freezeTemp; signed int defrostTemp; signed int fridgePro; network_control(ENABLE); iomod_backlight(ON); /* Initialize servo and temperature sensor ports */ DDRB = 0x0F; PORTB = 0x00; set_bit(DDRD, 2); clear_bit(PORTD, 2); /* Set up .01 sec timer */ TCCR0A = (2 << WGM00); TCCR0B = (5 << CS00); TIMSK0 = (1 << OCIE0A); OCR0A = 195; sei(); //fridgeTemp = -5; //freezeTemp = -18; while(1) { /* Check tempreture in fridge and freezer */ fridgeTemp = temp_sensor_read(FRIDGE_SENSE, TEMPERATURE); freezeTemp = temp_sensor_read(FREEZE_SENSE, TEMPERATURE); // defrostTemp = temp_sensor_read(DEFROST_SENSE, TEMPERATURE); /* Control freezer */ if (freezeTemp > (freezerSet + FREEZE_RANGE)) compressor(ON); else if (freezeTemp < (freezerSet - FREEZE_RANGE)) compressor(OFF); /* Control refridgerator */ fridgePro = ((fridgeTemp - fridgeSet) * 100) / FRIDGE_RANGE; if (fridgePro > 100) fridgePro = 100; if (fridgePro < -100) fridgePro = -100; damper_control(1200 + (fridgePro * 4)); /* Display information on LCD */ iomod_text(FIRST_LINE, "FD:"); iomod_signed(FIRST_LINE+3, fridgeTemp, 2); iomod_text(SECOND_LINE, "FZ:"); iomod_signed(SECOND_LINE+3, freezeTemp, 2); // iomod_text(SECOND_LINE+6, "FZ:"); // iomod_signed(SECOND_LINE+9, defrostTemp, 2); } }
std::unique_ptr<std::vector<char>> Format::pack( Data::PooledStack dataStack, const ChunkType chunkType) const { std::unique_ptr<std::vector<char>> data; const std::size_t numPoints(dataStack.size()); const std::size_t pointSize(schema().pointSize()); if (m_compress) { Compressor compressor(m_metadata.schema(), dataStack.size()); for (const char* pos : dataStack) compressor.push(pos, pointSize); data = compressor.data(); } else { data = makeUnique<std::vector<char>>(); data->reserve(numPoints * pointSize); for (const char* pos : dataStack) { data->insert(data->end(), pos, pos + pointSize); } } assert(data); dataStack.reset(); Packer packer(m_tailFields, *data, numPoints, chunkType); append(*data, packer.buildTail()); return data; }
static int filter_frame(AVFilterLink *link, AVFrame *frame) { AVFilterContext *ctx = link->dst; SidechainCompressContext *s = ctx->priv; AVFilterLink *outlink = ctx->outputs[0]; const double *scsrc; double *sample; int nb_samples; int ret, i; for (i = 0; i < 2; i++) if (link == ctx->inputs[i]) break; av_assert0(i < 2 && !s->input_frame[i]); s->input_frame[i] = frame; if (!s->input_frame[0] || !s->input_frame[1]) return 0; nb_samples = FFMIN(s->input_frame[0]->nb_samples, s->input_frame[1]->nb_samples); sample = (double *)s->input_frame[0]->data[0]; scsrc = (const double *)s->input_frame[1]->data[0]; compressor(s, sample, sample, scsrc, nb_samples, s->level_in, s->level_sc, ctx->inputs[0], ctx->inputs[1]); ret = ff_filter_frame(outlink, s->input_frame[0]); s->input_frame[0] = NULL; av_frame_free(&s->input_frame[1]); return ret; }
void BpfWriter::writeByteMajor(const PointView* data) { union { float f; uint32_t u32; } uu; // We're going to pretend for now that we only ever have one point buffer. BpfCompressor compressor(m_stream, data->size() * sizeof(float) * m_dims.size()); if (m_header.m_compression) compressor.startBlock(); for (auto & bpfDim : m_dims) { for (size_t b = 0; b < sizeof(float); b++) { for (PointId idx = 0; idx < data->size(); ++idx) { uu.f = (float)getAdjustedValue(data, bpfDim, idx); uint8_t u8 = (uint8_t)(uu.u32 >> (b * CHAR_BIT)); m_stream << u8; } } } if (m_header.m_compression) { compressor.compress(); compressor.finish(); } }
void BpfWriter::writePointMajor(const PointView* data) { // Blocks of 10,000 points will ensure that we're under 16MB, even // for 255 dimensions. size_t blockpoints = std::min<point_count_t>(10000UL, data->size()); // For compression we're going to write to a buffer so that it can be // compressed before it's written to the file stream. BpfCompressor compressor(m_stream, blockpoints * sizeof(float) * m_dims.size()); PointId idx = 0; while (idx < data->size()) { if (m_header.m_compression) compressor.startBlock(); size_t blockId; for (blockId = 0; idx < data->size() && blockId < blockpoints; ++idx, ++blockId) { for (auto & bpfDim : m_dims) { double d = getAdjustedValue(data, bpfDim, idx); m_stream << (float)d; } } if (m_header.m_compression) { compressor.compress(); compressor.finish(); } } }
void bunzip2OstreamTest() { // test std::stringstream bzip2target; { zim::Bzip2Stream compressor(bzip2target); compressor << testtext << std::flush; compressor.end(); } { std::ostringstream msg; msg << "teststring with " << testtext.size() << " bytes compressed into " << bzip2target.str().size() << " bytes"; reportMessage(msg.str()); } std::ostringstream bunzip2target; { zim::Bunzip2Stream bunzip2(bunzip2target); // bunzip2 is a ostream here bunzip2 << bzip2target.str() << std::flush; } { std::ostringstream msg; msg << "teststring uncompressed to " << bunzip2target.str().size() << " bytes"; reportMessage(msg.str()); } CXXTOOLS_UNIT_ASSERT_EQUALS(testtext, bunzip2target.str()); }
static int acompressor_filter_frame(AVFilterLink *inlink, AVFrame *in) { const double *src = (const double *)in->data[0]; AVFilterContext *ctx = inlink->dst; SidechainCompressContext *s = ctx->priv; AVFilterLink *outlink = ctx->outputs[0]; AVFrame *out; double *dst; if (av_frame_is_writable(in)) { out = in; } else { out = ff_get_audio_buffer(inlink, in->nb_samples); if (!out) { av_frame_free(&in); return AVERROR(ENOMEM); } av_frame_copy_props(out, in); } dst = (double *)out->data[0]; compressor(s, src, dst, src, in->nb_samples, s->level_in, s->level_in, inlink, inlink); if (out != in) av_frame_free(&in); return ff_filter_frame(outlink, out); }
// This example demonstrates how to use the Qt Xml classes together with QtIOCompressor to store // compressed xml data in a file. int main() { // Create some xml. QDomDocument doc("MyML"); QDomElement root = doc.createElement("MyML"); doc.appendChild(root); QDomElement tag = doc.createElement("Greeting"); root.appendChild(tag); QDomText t = doc.createTextNode("Hello World"); tag.appendChild(t); // Write it to a compressed file using a QTextStream. QFile file("xmltest"); file.open(QIODevice::ReadWrite); QtIOCompressor compressor(&file); compressor.open(QIODevice::WriteOnly); QTextStream textStream(&compressor); const int indent = 0; doc.save(textStream, indent); // Close the QtIOCompressor and seek to start of file. compressor.close(); file.seek(0); // Read compressed xml from file and print it. compressor.open(QIODevice::ReadOnly); QDomDocument readDoc; readDoc.setContent(&compressor); const QString readXml = readDoc.toString(); qDebug() << readXml; }
// Main do Programa de compressão // @param argc numero de parametros // @param [in] argv array com os parametros // @retval EXIT_FAILURE se falhar na execução // @retval 0 se executar corretamente int main(int argc, char *argv[]) { cout << "TRABALHO PRATICO 1 - INTRODUCAO A COMPUTACAO VISUAL - DCC - UFMG" << endl; cout << "NOME : Guilherme Henrique Rodrigues Nascimento" << endl; cout << "MATRICULA: 2010054460" << endl; cout << "Programa de compressão com LZW" << endl; ifstream arquivo_ent(argv[1], ios_base::binary); if (!arquivo_ent.is_open()) { cout << argv[1] << " não pode ser aberto" << endl; return EXIT_FAILURE; } string nome = argv[1]; int tamanho = (int) nome.size(); //cout << tamanho; string nomesaida = nome.substr(0, tamanho - 4); ofstream arquivo_saida(nomesaida.append(".compactado"), ios_base::binary); if (!arquivo_saida.is_open()) { cout << "arquivo de saida " << argv[2] << " não pode ser criado." << endl; return EXIT_FAILURE; } compressor(arquivo_ent, arquivo_saida); cout << "Aquivo compactado" << endl; return 0; }
int main(int argc, char **argv) { if (!ReadParameter(argc, argv)) { std::cout << "Bad Parameters.\n"; return 1; } SetConfig(); if (compress) { // Compress db_compress::Compressor compressor(outputFileName, schema, config); int iter_cnt = 0; while (1) { std::cout << "Iteration " << ++iter_cnt << " Starts\n"; std::ifstream inFile(inputFileName); std::string str; int tuple_cnt = 0; while (std::getline(inFile,str)) { std::stringstream sstream(str); std::string item; db_compress::Tuple tuple(schema.attr_type.size()); db_compress::IntegerAttrValue attr(++tuple_cnt); tuple.attr[0] = &attr; size_t count = 0; std::vector< std::unique_ptr<ColorAttr> > vec; while (std::getline(sstream, item, ' ')) { if (++ count > 1) AppendAttr(std::stod(item), &tuple, count - 1); } // The first item is tuple id if (count != schema.attr_type.size()) { std::cerr << "File Format Error!\n"; } compressor.ReadTuple(tuple); if (!compressor.RequireFullPass() && tuple_cnt >= NonFullPassStopPoint) { break; } } compressor.EndOfData(); if (!compressor.RequireMoreIterations()) break; } } else { // Decompress db_compress::Decompressor decompressor(inputFileName, schema); std::ofstream outFile(outputFileName); decompressor.Init(); while (decompressor.HasNext()) { db_compress::Tuple tuple(33); decompressor.ReadNextTuple(&tuple); for (size_t i = 0; i < schema.attr_type.size(); ++i) { double attr = ExtractAttr(&tuple, i); outFile << attr << (i == schema.attr_type.size() - 1 ? '\n' : ' '); } } } return 0; }
void write_compressed(std::ostream &out, config const &cfg) { boost::iostreams::filtering_stream<boost::iostreams::output> filter; filter.push(compressor()); filter.push(out); write(filter, cfg); // prevent empty gz files because of https://svn.boost.org/trac/boost/ticket/5237 filter << "\n"; }
int main(int argc, char *argv[]) { int n = 5; uchar row1[] = {0, 0, 0, 0, 0}; uchar row2[] = {0, 1, 0, 0, 0}; uchar row3[] = {1, 1, 0, 2, 2}; DeltaRowCompressor compressor(n, 0); test(&compressor, row1); test(&compressor, row2); test(&compressor, row3); }
bool PodcastService::Podcast::load() { if (fileName.isEmpty()) { return false; } QFile file(fileName); QtIOCompressor compressor(&file); compressor.setStreamFormat(QtIOCompressor::GzipFormat); if (!compressor.open(QIODevice::ReadOnly)) { return false; } QXmlStreamReader reader(&compressor); unplayedCount=0; while (!reader.atEnd()) { reader.readNext(); if (!reader.error() && reader.isStartElement()) { QString element = reader.name().toString(); QXmlStreamAttributes attributes=reader.attributes(); if (constTopTag == element) { imageUrl=attributes.value(constImageAttribute).toString(); url=attributes.value(constRssAttribute).toString(); name=attributes.value(constNameAttribute).toString(); if (url.isEmpty() || name.isEmpty()) { return false; } } else if (constEpisodeTag == element) { QString epName=attributes.value(constNameAttribute).toString(); QString epUrl=attributes.value(constUrlAttribute).toString(); if (!epName.isEmpty() && !epUrl.isEmpty()) { Episode *ep=new Episode(QDateTime::fromString(attributes.value(constDateAttribute).toString(), Qt::ISODate), epName, epUrl, this); QString localFile=attributes.value(constLocalAttribute).toString(); QString time=attributes.value(constTimeAttribute).toString(); ep->duration=time.isEmpty() ? 0 : time.toUInt(); ep->played=constTrue==attributes.value(constPlayedAttribute).toString(); if (QFile::exists(localFile)) { ep->localFile=localFile; } episodes.append(ep); if (!ep->played) { unplayedCount++; } } } } } return true; }
void compress_filter(struct compress_params *params, int fd_in, int fd_out, const char *desc_fmt, ...) { va_list args; struct varbuf desc = VARBUF_INIT; va_start(args, desc_fmt); varbuf_vprintf(&desc, desc_fmt, args); va_end(args); compressor(params->type)->compress(fd_in, fd_out, params, desc.buf); }
void decompress_filter(enum compressor_type type, int fd_in, int fd_out, const char *desc_fmt, ...) { va_list args; struct varbuf desc = VARBUF_INIT; va_start(args, desc_fmt); varbuf_vprintf(&desc, desc_fmt, args); va_end(args); compressor(type)->decompress(fd_in, fd_out, desc.buf); }
TEST(Decompressor, GZip) { StringWriter* writer = new StringWriter; GZipCompressor compressor(writer); EXPECT_LT(0, compressor.WriteString(IPSUM)); EXPECT_LT(writer->GetBuffer().size(), compressor.totalBytesIn()); StringWriter* outputWriter = new StringWriter; GZipDecompressor decompressor(outputWriter); EXPECT_EQ(decompressor.WriteString(writer->GetBuffer()), IPSUM.size()); ASSERT_EQ(compressor.totalBytesIn(), outputWriter->GetBuffer().size()); for (int i = 0; i < outputWriter->GetBuffer().size(); ++i) { EXPECT_EQ(IPSUM.data()[i], outputWriter->GetBuffer()[i]); }; };
static int filter_frame(AVFilterLink *link, AVFrame *frame) { AVFilterContext *ctx = link->dst; SidechainCompressContext *s = ctx->priv; AVFilterLink *outlink = ctx->outputs[0]; AVFrame *out = NULL, *in[2] = { NULL }; double *dst; int nb_samples; int i; for (i = 0; i < 2; i++) if (link == ctx->inputs[i]) break; av_assert0(i < 2); av_audio_fifo_write(s->fifo[i], (void **)frame->extended_data, frame->nb_samples); av_frame_free(&frame); nb_samples = FFMIN(av_audio_fifo_size(s->fifo[0]), av_audio_fifo_size(s->fifo[1])); if (!nb_samples) return 0; out = ff_get_audio_buffer(outlink, nb_samples); if (!out) return AVERROR(ENOMEM); for (i = 0; i < 2; i++) { in[i] = ff_get_audio_buffer(ctx->inputs[i], nb_samples); if (!in[i]) { av_frame_free(&in[0]); av_frame_free(&in[1]); av_frame_free(&out); return AVERROR(ENOMEM); } av_audio_fifo_read(s->fifo[i], (void **)in[i]->data, nb_samples); } dst = (double *)out->data[0]; out->pts = s->pts; s->pts += nb_samples; compressor(s, (double *)in[0]->data[0], dst, (double *)in[1]->data[0], nb_samples, s->level_in, s->level_sc, ctx->inputs[0], ctx->inputs[1]); av_frame_free(&in[0]); av_frame_free(&in[1]); return ff_filter_frame(outlink, out); }
void VlrCompressor::done() { // Close and clear the point encoder. m_encoder->done(); m_encoder.reset(); newChunk(); // Save our current position. Go to the location where we need // to write the chunk table offset at the beginning of the point data. uint64_t chunkTablePos = htole64((uint64_t) m_stream.m_buf.size()); // We need to add the offset given a construction time since // we did not use a stream to write the header and vlrs uint64_t trueChunkTablePos = htole64((uint64_t) m_stream.m_buf.size() + m_offsetToData); // Equivalent of stream.seekp(m_chunkInfoPos); stream << chunkTablePos memcpy(&m_stream.m_buf[m_chunkInfoPos], (char*) &trueChunkTablePos, sizeof(uint64_t)); // Move to the start of the chunk table. // Which in our case is the end of the m_stream vector // Write the chunk table header in two steps // 1. Push bytes into the stream // 2. memcpy the data into the pushed bytes unsigned char skip[2 * sizeof(uint32_t)] = {0}; m_stream.putBytes(skip, sizeof(skip)); uint32_t version = htole32(0); uint32_t chunkTableSize = htole32((uint32_t) m_chunkTable.size()); memcpy(&m_stream.m_buf[chunkTablePos], &version, sizeof(uint32_t)); memcpy(&m_stream.m_buf[chunkTablePos + sizeof(uint32_t)], &chunkTableSize, sizeof(uint32_t)); // Encode and write the chunk table. // OutputStream outputStream(m_stream); TypedLazPerfBuf<uint8_t> outputStream(m_stream); Encoder encoder(outputStream); laszip::compressors::integer compressor(32, 2); compressor.init(); uint32_t predictor = 0; for (uint32_t chunkSize : m_chunkTable) { chunkSize = htole32(chunkSize); compressor.compress(encoder, predictor, chunkSize, 1); predictor = chunkSize; } encoder.done(); }
std::unique_ptr<std::vector<char>> Compression::compress( const char* data, const std::size_t size, const Schema& schema) { CompressionStream compressionStream(size); pdal::LazPerfCompressor<CompressionStream> compressor( compressionStream, schema.pdalLayout().dimTypes()); compressor.compress(data, size); compressor.done(); return compressionStream.data(); }
int alpng_deflate(uint8_t* data, uint32_t data_length, uint8_t** compressed_data, uint32_t* compressed_data_length, char** error_msg) { CryptoPP::ZlibCompressor compressor(0, 9); compressor.Put((byte *)data, data_length); compressor.MessageEnd(); unsigned int dest_length = compressor.MaxRetrievable(); *compressed_data = (uint8_t*) malloc(dest_length); if (!*compressed_data) { *error_msg = "Cannot allocate memory!"; return 0; } compressor.Get((byte *)*compressed_data, dest_length); *compressed_data_length = dest_length; return 1; }
bool CompressedImage::import(const RasterImage& rasterImage, unsigned char rangeRegionSize) { //Retrieve all raster layers std::vector<Pixmap*> layers = rasterImage.getLayers(); PixmapCompressor compressor(rangeRegionSize, rangeRegionSize * 2); //Compress each layer separately for (unsigned int i = 0; i < layers.size(); ++i) { std::cout << "====================\nLayer " << i << "\n====================" << std::endl; m_layers.push_back(compressor.compress(layers[i])); } return true; }
static int parse_line_instruction(t_parser *parser, char **my_tab) { if (is_defined(my_tab[0]) == 1) { if (compressor(&my_tab) == 1) { my_putstr_err("Can’t perform malloc", 2); return (1); } if (is_number_valid(my_tab, my_tab[0]) == 1) parser->current_address += get_incsize(my_tab); else return (syntax_error_and_return(parser->line_nb)); if (valid_args(my_tab) == 0) return (syntax_error_and_return(parser->line_nb)); } else return (syntax_error_and_return(parser->line_nb)); return (0); }
void WikipediaSettings::parseLangs() { NetworkJob *reply = qobject_cast<NetworkJob*>(sender()); if (!reply) { return; } reload->setEnabled(true); reply->deleteLater(); if (reply!=job) { return; } job=0; QByteArray data=reply->readAll(); parseLangs(data); QFile f(localeFile()); QtIOCompressor compressor(&f); compressor.setStreamFormat(QtIOCompressor::GzipFormat); if (compressor.open(QIODevice::WriteOnly)) { compressor.write(data); } }
void KdbxXmlWriter::writeBinaries() { m_xml.writeStartElement("Binaries"); QHash<QByteArray, int>::const_iterator i; for (i = m_idMap.constBegin(); i != m_idMap.constEnd(); ++i) { m_xml.writeStartElement("Binary"); m_xml.writeAttribute("ID", QString::number(i.value())); QByteArray data; if (m_db->compressionAlgorithm() == Database::CompressionGZip) { m_xml.writeAttribute("Compressed", "True"); QBuffer buffer; buffer.open(QIODevice::ReadWrite); QtIOCompressor compressor(&buffer); compressor.setStreamFormat(QtIOCompressor::GzipFormat); compressor.open(QIODevice::WriteOnly); qint64 bytesWritten = compressor.write(i.key()); Q_ASSERT(bytesWritten == i.key().size()); Q_UNUSED(bytesWritten); compressor.close(); buffer.seek(0); data = buffer.readAll(); } else { data = i.key(); } if (!data.isEmpty()) { m_xml.writeCharacters(QString::fromLatin1(data.toBase64())); } m_xml.writeEndElement(); } m_xml.writeEndElement(); }
static int crypt_all(int *pcount, struct db_salt *salt) { const int count = *pcount; int index = 0; #ifdef _OPENMP #pragma omp parallel for for (index = 0; index < count; index++) #endif { // hash is compressor(md5(password)) MD5_CTX ctx; unsigned char *out = (unsigned char*)crypt_out[index]; unsigned char hash[16]; MD5_Init(&ctx); MD5_Update(&ctx, saved_key[index], saved_len[index]); MD5_Final(hash, &ctx); compressor(hash, out); } return count; }
/*static*/ KValueRef Codec::CreateZipAsync(const ValueList& args) { std::string directory = args.GetString(0); std::string zipFile = args.GetString(1); AutoPtr<AsyncJob> job = args.GetObject(2).cast<AsyncJob>(); KMethodRef callback = 0; if (args.size() > 3) { callback = args.GetMethod(3); } Poco::Path path(directory); path.makeDirectory(); std::ofstream stream(UTF8ToSystem(zipFile).c_str(), std::ios::binary | std::ios::trunc); Poco::Zip::Compress compressor(stream, true); try { compressor.addRecursive(path); } catch (std::exception& e) { Logger::Get("Codec")->Error("exception compressing: %s", e.what()); throw ValueException::FromFormat("Exception during zip: %s", e.what()); } compressor.close(); stream.close(); if (!callback.isNull()) { ValueList args; args.push_back(Value::NewString(zipFile)); RunOnMainThread(callback, args, true); } return Value::Undefined; }
void MusicLibraryModel::convertCache(const QString &compressedName) { QString prev=compressedName; prev.replace(constLibraryCompressedExt, constLibraryExt); if (QFile::exists(prev) && !QFile::exists(compressedName)) { QFile old(prev); if (old.open(QIODevice::ReadOnly)) { QByteArray a=old.readAll(); old.close(); QFile newCache(compressedName); QtIOCompressor compressor(&newCache); compressor.setStreamFormat(QtIOCompressor::GzipFormat); if (compressor.open(QIODevice::WriteOnly)) { compressor.write(a); compressor.close(); QFile::remove(prev); } } } }
void BpfWriter::writeDimMajor(const PointView* data) { // We're going to pretend for now that we only even have one point buffer. BpfCompressor compressor(m_stream, data->size() * sizeof(float)); for (auto & bpfDim : m_dims) { if (m_header.m_compression) compressor.startBlock(); for (PointId idx = 0; idx < data->size(); ++idx) { double d = getAdjustedValue(data, bpfDim, idx); m_stream << (float)d; } if (m_header.m_compression) { compressor.compress(); compressor.finish(); } } }
void ImapTransport::test() { #if 0 qMailLog(IMAP) << "Rfc1951Compressor and Rfc1951Decompressor functional testing running..."; // Mainly aiming to test for bounday conditions // So make the compression/decompression buffers about the same size as the input/output QByteArray data("This\n is some test data.\r\n The quick brown fox jumps over the lazy dog. 0123456789.\r\n"); for(int i = 10; i <= 100; ++ i) { for(int j = 10; i <= 100; ++ i) { for (int k = 10; k <= 100; ++k) { Rfc1951Compressor compressor(i); Rfc1951Decompressor decompressor(j); QByteArray input(data.left(k)); input += "\r\n"; QByteArray compressed; { QDataStream stream(&compressed, QIODevice::WriteOnly); compressor.write(&stream, &input); } { QByteArray output; QBuffer buffer(&compressed); buffer.open(QIODevice::ReadOnly); decompressor.consume(&buffer); while (decompressor.canReadLine()) { output += decompressor.readLine(); } if (input != output) { qMailLog(IMAP) << "Test failure: input" << input.toHex() << "output" << output.toHex(); Q_ASSERT(input == output); } } } } } qMailLog(IMAP) << "Rfc1951Compressor and Rfc1951Decompressor functional testing completed OK"; #endif }