void
eos_shard_writer_v1_write_to_fd (EosShardWriterV1 *self, int fd)
{
GVariant *variant;
/* Sort our records to allow for binary searches on retrieval. */
g_array_sort (self->entries, &compare_records);
variant = header_entry_variant (self->entries);
uint64_t header_size = g_variant_get_size (variant);
header_size = GUINT64_TO_LE (header_size);
g_variant_unref (variant);
lseek (fd, ALIGN (sizeof (header_size) + header_size), SEEK_SET);
int i;
for (i = 0; i < self->entries->len; i++) {
struct eos_shard_writer_v1_record_entry *e = &g_array_index (self->entries, struct eos_shard_writer_v1_record_entry, i);
write_blob (fd, &e->metadata);
write_blob (fd, &e->data);
}
lseek (fd, 0, SEEK_SET);
g_assert (write (fd, &header_size, sizeof (header_size)) >= 0);
variant = header_entry_variant (self->entries);
write_variant (fd, variant);
g_variant_unref (variant);
}
/* This function gets the entry ID corresponding to the message having the
* specified hash and KSN. If the message is not found, 0 is assigned.
* This function sets the KMO error string. It returns -1 on failure.
*/
static int get_entry_id_from_hash(sqlite3 *db, kstr *hash, kstr *ksn, int64_t *entry_id) {
int error = 0;
sqlite3_stmt *stmt = NULL;
assert(hash->slen == 0 || hash->slen == 20); //FIXME: SHA1 is obsolete, use SHA256.
assert(ksn->slen == 0 || ksn->slen == 24);
assert(hash->slen || ksn->slen);
if (sqlite3_prepare(db, "SELECT entry_id FROM mail_eval_res3 WHERE hash = ? AND ksn = ?;", -1, &stmt, NULL))
goto ERR;
if (write_blob(stmt, 1, hash)) goto ERR;
if (write_blob(stmt, 2, ksn)) goto ERR;
error = sqlite3_step(stmt);
/* No such entry. */
if (error == SQLITE_DONE) {
finalize_stmt(db, &stmt);
*entry_id = 0;
return 0;
}
if (error != SQLITE_ROW) goto ERR;
*entry_id = sqlite3_column_int64(stmt, 0);
assert(*entry_id != 0);
if (sqlite3_step(stmt) != SQLITE_DONE) goto ERR;
finalize_stmt(db, &stmt);
return 0;
ERR:
kmo_seterror(sqlite3_errmsg(db));
finalize_stmt(db, &stmt);
return -1;
}
int main(void)
{
int err;
struct isci_orom *isci_orom;
isci_orom = malloc(sizeof(struct isci_orom));
memset(isci_orom, 0, sizeof(struct isci_orom));
set_binary_values(isci_orom);
err = write_blob(isci_orom);
if (err < 0) {
free(isci_orom);
return err;
}
free(isci_orom);
return 0;
}
static void
write_core(pic_state *pic, pic_value obj, pic_value port, struct writer_control *p)
{
pic_value labels = p->labels;
int i;
/* shared objects */
if (is_shared_object(pic, obj, p)) {
if (pic_weak_has(pic, labels, obj)) {
pic_fprintf(pic, port, "#%d#", pic_int(pic, pic_weak_ref(pic, labels, obj)));
return;
}
i = p->cnt++;
pic_fprintf(pic, port, "#%d=", i);
pic_weak_set(pic, labels, obj, pic_int_value(pic, i));
}
switch (pic_type(pic, obj)) {
case PIC_TYPE_UNDEF:
pic_fprintf(pic, port, "#undefined");
break;
case PIC_TYPE_NIL:
pic_fprintf(pic, port, "()");
break;
case PIC_TYPE_TRUE:
pic_fprintf(pic, port, "#t");
break;
case PIC_TYPE_FALSE:
pic_fprintf(pic, port, "#f");
break;
case PIC_TYPE_ID:
pic_fprintf(pic, port, "#<identifier %s>", pic_str(pic, pic_id_name(pic, obj)));
break;
case PIC_TYPE_EOF:
pic_fprintf(pic, port, "#.(eof-object)");
break;
case PIC_TYPE_INT:
pic_fprintf(pic, port, "%d", pic_int(pic, obj));
break;
case PIC_TYPE_SYMBOL:
pic_fprintf(pic, port, "%s", pic_sym(pic, obj));
break;
case PIC_TYPE_FLOAT:
write_float(pic, obj, port);
break;
case PIC_TYPE_BLOB:
write_blob(pic, obj, port);
break;
case PIC_TYPE_CHAR:
write_char(pic, obj, port, p);
break;
case PIC_TYPE_STRING:
write_str(pic, obj, port, p);
break;
case PIC_TYPE_PAIR:
write_pair(pic, obj, port, p);
break;
case PIC_TYPE_VECTOR:
write_vec(pic, obj, port, p);
break;
case PIC_TYPE_DICT:
write_dict(pic, obj, port, p);
break;
default:
pic_fprintf(pic, port, "#<%s %p>", pic_typename(pic, pic_type(pic, obj)), pic_obj_ptr(obj));
break;
}
if (p->op == OP_WRITE) {
if (is_shared_object(pic, obj, p)) {
pic_weak_del(pic, labels, obj);
}
}
}
int main(void)
{
char const *verbose_var = getenv("D3D4LINUX_VERBOSE");
if (!verbose_var || *verbose_var != '1')
dup2(open("/dev/null", O_WRONLY), STDERR_FILENO);
HMODULE lib = LoadLibrary("d3dcompiler_43.dll");
/* Ensure stdout is in binary mode */
setmode(fileno(stdout), O_BINARY);
setmode(fileno(stdin), O_BINARY);
int syscall = read_integer();
int marker = 0;
if (syscall == D3D4LINUX_COMPILE)
{
HRESULT (*compile)(void const *pSrcData, size_t SrcDataSize,
char const *pFileName,
D3D_SHADER_MACRO const *pDefines,
ID3DInclude *pInclude,
char const *pEntrypoint, char const *pTarget,
uint32_t Flags1, uint32_t Flags2,
ID3DBlob **ppCode, ID3DBlob **ppErrorMsgs);
compile = (decltype(compile))GetProcAddress(lib, "D3DCompile");
/* This is a D3DCompile() call */
std::string shader_source = read_string();
int has_filename = (int)read_integer();
std::string shader_file;
if (has_filename)
shader_file = read_string();
std::string shader_main = read_string();
std::string shader_type = read_string();
uint32_t flags1 = (uint32_t)read_integer();
uint32_t flags2 = (uint32_t)read_integer();
marker = (int)read_integer();
if (marker != D3D4LINUX_FINISHED)
goto error;
ID3DBlob *shader_blob = nullptr, *error_blob = nullptr;
HRESULT ret = compile(shader_source.c_str(), shader_source.size(),
shader_file.c_str(),
nullptr, /* unimplemented */
nullptr, /* unimplemented */
shader_main.c_str(),
shader_type.c_str(),
flags1, flags2, &shader_blob, &error_blob);
fprintf(stderr, "[D3D4LINUX] D3DCompile([%d bytes], \"%s\", ?, ?, \"%s\", \"%s\", %04x, %04x ) = 0x%08x\n",
(int)shader_source.size(), has_filename ? shader_file.c_str() : "(nullptr)", shader_main.c_str(), shader_type.c_str(),
flags1, flags2, (int)ret);
write_integer(ret);
write_blob(shader_blob);
write_blob(error_blob);
write_integer(D3D4LINUX_FINISHED);
if (shader_blob)
shader_blob->Release();
if (error_blob)
error_blob->Release();
}
else if (syscall == D3D4LINUX_REFLECT)
{
HRESULT (*reflect)(void const *pSrcData,
size_t SrcDataSize,
REFIID pInterface,
void **ppReflector);
reflect = (decltype(reflect))GetProcAddress(lib, "D3DReflect");
std::vector<uint8_t> *data = read_data();
int iid_code = read_integer();
marker = (int)read_integer();
if (marker != D3D4LINUX_FINISHED)
goto error;
char const *iid_name = "";
IID iid;
switch (iid_code)
{
case D3D4LINUX_IID_SHADER_REFLECTION:
iid = IID_ID3D11ShaderReflection;
iid_name = "IID_ID3D11ShaderReflection";
break;
default:
goto error;
}
void *object;
HRESULT ret = reflect(data ? data->data() : nullptr,
data ? data->size() : 0,
iid, &object);
fprintf(stderr, "[D3D4LINUX] D3DReflect([%d bytes], %s) = 0x%08x\n",
data ? (int)data->size() : 0, iid_name, (int)ret);
write_integer(ret);
if (iid_code == D3D4LINUX_IID_SHADER_REFLECTION)
{
D3D11_SIGNATURE_PARAMETER_DESC param_desc;
D3D11_SHADER_INPUT_BIND_DESC bind_desc;
D3D11_SHADER_VARIABLE_DESC variable_desc;
D3D11_SHADER_BUFFER_DESC buffer_desc;
D3D11_SHADER_DESC shader_desc;
ID3D11ShaderReflection *reflector = (ID3D11ShaderReflection *)object;
/* Serialise D3D11_SHADER_DESC */
reflector->GetDesc(&shader_desc);
write_raw(&shader_desc, sizeof(shader_desc));
write_string(shader_desc.Creator);
/* Serialize all InputParameterDesc */
for (uint32_t i = 0; i < shader_desc.InputParameters; ++i)
{
reflector->GetInputParameterDesc(i, ¶m_desc);
write_raw(¶m_desc, sizeof(param_desc));
write_string(param_desc.SemanticName);
}
/* Serialize all OutParameterDesc */
for (uint32_t i = 0; i < shader_desc.OutputParameters; ++i)
{
reflector->GetOutputParameterDesc(i, ¶m_desc);
write_raw(¶m_desc, sizeof(param_desc));
write_string(param_desc.SemanticName);
}
/* Serialize all ResourceBindingDesc */
for (uint32_t i = 0; i < shader_desc.BoundResources; ++i)
{
reflector->GetResourceBindingDesc(i, &bind_desc);
write_raw(&bind_desc, sizeof(bind_desc));
write_string(bind_desc.Name);
}
/* Serialize all ConstantBuffer */
for (uint32_t i = 0; i < shader_desc.ConstantBuffers; ++i)
{
ID3D11ShaderReflectionConstantBuffer *cbuffer
= reflector->GetConstantBufferByIndex(i);
/* Serialize D3D11_SHADER_BUFFER_DESC */
cbuffer->GetDesc(&buffer_desc);
write_raw(&buffer_desc, sizeof(buffer_desc));
write_string(buffer_desc.Name);
/* Serialize all Variable */
for (uint32_t j = 0; j < buffer_desc.Variables; ++j)
{
ID3D11ShaderReflectionVariable *var
= cbuffer->GetVariableByIndex(j);
/* Serialize D3D11_SHADER_VARIABLE_DESC */
var->GetDesc(&variable_desc);
write_raw(&variable_desc, sizeof(variable_desc));
write_string(variable_desc.Name);
write_integer(variable_desc.DefaultValue ? 1 : 0);
if (variable_desc.DefaultValue)
write_raw(variable_desc.DefaultValue, variable_desc.Size);
}
}
}
write_integer(D3D4LINUX_FINISHED);
delete data;
}
else if (syscall == D3D4LINUX_STRIP)
{
HRESULT (*strip)(void const *pShaderBytecode,
size_t BytecodeLength,
uint32_t uStripFlags,
ID3DBlob **ppStrippedBlob);
strip = (decltype(strip))GetProcAddress(lib, "D3DStripShader");
std::vector<uint8_t> *data = read_data();
uint32_t flags = (uint32_t)read_integer();
marker = (int)read_integer();
if (marker != D3D4LINUX_FINISHED)
goto error;
ID3DBlob *strip_blob = nullptr;
HRESULT ret = strip(data ? data->data() : nullptr,
data ? data->size() : 0,
flags, &strip_blob);
fprintf(stderr, "[D3D4LINUX] D3DStripShader([%d bytes], %04x) = 0x%08x\n",
data ? (int)data->size() : 0, flags, (int)ret);
write_integer(ret);
write_blob(strip_blob);
write_integer(D3D4LINUX_FINISHED);
if (strip_blob)
strip_blob->Release();
}
else if (syscall == D3D4LINUX_DISASSEMBLE)
{
HRESULT (*disas)(void const *pSrcData,
size_t SrcDataSize,
uint32_t Flags,
char const *szComments,
ID3DBlob **ppDisassembly);
disas = (decltype(disas))GetProcAddress(lib, "D3DDisassemble");
std::vector<uint8_t> *data = read_data();
uint32_t flags = (uint32_t)read_integer();
int has_comments = (int)read_integer();
std::string comments;
if (has_comments)
comments = read_string();
marker = (int)read_integer();
if (marker != D3D4LINUX_FINISHED)
goto error;
ID3DBlob *disas_blob = nullptr;
HRESULT ret = disas(data ? data->data() : nullptr,
data ? data->size() : 0,
flags,
has_comments ? comments.c_str() : nullptr,
&disas_blob);
fprintf(stderr, "[D3D4LINUX] D3DDisassemble([%d bytes], %04x, %s) = 0x%08x\n",
data ? (int)data->size() : 0, flags, has_comments ? "[comments]" : "(nullptr)", (int)ret);
write_integer(ret);
write_blob(disas_blob);
write_integer(D3D4LINUX_FINISHED);
if (disas_blob)
disas_blob->Release();
}
return EXIT_SUCCESS;
error:
fprintf(stderr, "[D3D4LINUX] Bad message received: %08x %08x\n", syscall, marker);
}
/* This function converts the database format from version 3 to version 4.
* This function sets the KMO error string. It returns -1 on failure.
*/
static int maildb_convert_to_version_4(sqlite3 *db) {
sqlite3_stmt *stmt1 = NULL;
sqlite3_stmt *stmt2 = NULL;
kstr kstr_array[10];
int k;
for (k = 0; k < 10; k++) kstr_init(kstr_array + k);
begin_transaction(db);
/* Create the new table and update the maildb version. */
if (sqlite3_exec(db, "CREATE TABLE 'mail_eval_res3' "
"("
" 'entry_id' INTEGER PRIMARY KEY,"
" 'hash' BLOB (20),"
" 'ksn' BLOB (24),"
" 'status' INTEGER,"
" 'display_pref' TINYINT(1),"
" 'sig_msg' VARCHAR,"
" 'mid' INTEGER(20),"
" 'original_packaging' TINYINT(1),"
" 'mua' SMALLINT(3),"
" 'field_status' INTEGER(2),"
" 'att_plugin_nbr' TINYINT(1),"
" 'attachment_nbr' TINYINT(1),"
" 'attachment_status' BLOB,"
" 'sym_key' BLOB,"
" 'encryption_status' TINYINT(1),"
" 'decryption_error_msg' VARCHAR,"
" 'pod_status' TINYINT(1),"
" 'pod_msg' VARCHAR,"
" 'otut_status' TINYINT(1),"
" 'otut_string' BLOB,"
" 'otut_msg' VARCHAR,"
" 'kpg_addr' VARCHAR,"
" 'kpg_port' INTEGER(5)"
");"
"UPDATE maildb_version SET version = 4;", NULL, NULL, NULL)) goto ERR;
/* Transfer the data from mail_eval_res to mail_eval_res2. */
if (sqlite3_prepare(db, "SELECT entry_id, hash, ksn, status, display_pref, "
"sig_msg, mid, original_packaging, mua, field_status, "
"att_plugin_nbr, attachment_nbr, attachment_status, sym_key, encryption_status, "
"decryption_error_msg, pod_status, pod_msg, otut_status, otut_string, "
"otut_msg FROM mail_eval_res2;", -1, &stmt1, NULL)) goto ERR;
while (1) {
int i = 0;
int j = 1;
k = 0;
int res = sqlite3_step(stmt1);
if (res == SQLITE_DONE) break;
if (res != SQLITE_ROW) goto ERR;
if (sqlite3_prepare(db, "INSERT INTO mail_eval_res3 ("
"entry_id, hash, ksn, status, display_pref, sig_msg, mid, original_packaging, mua, "
"field_status, att_plugin_nbr, attachment_nbr, attachment_status, sym_key, "
"encryption_status, decryption_error_msg, pod_status, pod_msg, otut_status, "
"otut_string, otut_msg, kpg_addr, kpg_port) "
"VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?);",
-1, &stmt2, NULL)) goto ERR;
if (sqlite3_bind_int64(stmt2, j++, sqlite3_column_int64(stmt1, i++))) goto ERR;
read_blob(stmt1, &kstr_array[k], i++); if (write_blob(stmt2, j++, &kstr_array[k])) goto ERR; k++;
read_blob(stmt1, &kstr_array[k], i++); if (write_blob(stmt2, j++, &kstr_array[k])) goto ERR; k++;
if (sqlite3_bind_int(stmt2, j++, sqlite3_column_int(stmt1, i++))) goto ERR;
if (sqlite3_bind_int(stmt2, j++, sqlite3_column_int(stmt1, i++))) goto ERR;
read_string(stmt1, &kstr_array[k], i++); if (write_string(stmt2, j++, &kstr_array[k])) goto ERR; k++;
if (sqlite3_bind_int64(stmt2, j++, sqlite3_column_int64(stmt1, i++))) goto ERR;
if (sqlite3_bind_int(stmt2, j++, sqlite3_column_int(stmt1, i++))) goto ERR;
if (sqlite3_bind_int(stmt2, j++, sqlite3_column_int(stmt1, i++))) goto ERR;
if (sqlite3_bind_int64(stmt2, j++, sqlite3_column_int64(stmt1, i++))) goto ERR;
if (sqlite3_bind_int64(stmt2, j++, sqlite3_column_int64(stmt1, i++))) goto ERR;
if (sqlite3_bind_int64(stmt2, j++, sqlite3_column_int64(stmt1, i++))) goto ERR;
read_blob(stmt1, &kstr_array[k], i++); if (write_blob(stmt2, j++, &kstr_array[k])) goto ERR; k++;
read_blob(stmt1, &kstr_array[k], i++); if (write_blob(stmt2, j++, &kstr_array[k])) goto ERR; k++;
if (sqlite3_bind_int(stmt2, j++, sqlite3_column_int(stmt1, i++))) goto ERR;
read_string(stmt1, &kstr_array[k], i++); if (write_string(stmt2, j++, &kstr_array[k])) goto ERR; k++;
if (sqlite3_bind_int(stmt2, j++, sqlite3_column_int(stmt1, i++))) goto ERR;
read_string(stmt1, &kstr_array[k], i++); if (write_string(stmt2, j++, &kstr_array[k])) goto ERR; k++;
if (sqlite3_bind_int(stmt2, j++, sqlite3_column_int(stmt1, i++))) goto ERR;
read_blob(stmt1, &kstr_array[k], i++); if (write_blob(stmt2, j++, &kstr_array[k])) goto ERR; k++;
read_string(stmt1, &kstr_array[k], i++); if (write_string(stmt2, j++, &kstr_array[k])) goto ERR; k++;
/* Add KPG address and port. */
kstr_assign_cstr(&kstr_array[k], ""); if (write_string(stmt2, j++, &kstr_array[k])) goto ERR; k++;
if (sqlite3_bind_int(stmt2, j++, 0)) goto ERR;
if (sqlite3_step(stmt2) != SQLITE_DONE) goto ERR;
finalize_stmt(db, &stmt2);
}
finalize_stmt(db, &stmt1);
/* Delete the mail_eval_res table and commit. */
if (sqlite3_exec(db, "DROP TABLE mail_eval_res2; COMMIT;", NULL, NULL, NULL)) goto ERR;
/* Success. */
for (k = 0; k < 10; k++) kstr_free(kstr_array + k);
finalize_stmt(db, &stmt1);
finalize_stmt(db, &stmt2);
return 0;
ERR:
kmo_seterror(sqlite3_errmsg(db));
for (k = 0; k < 10; k++) kstr_free(kstr_array + k);
finalize_stmt(db, &stmt1);
finalize_stmt(db, &stmt2);
rollback_transaction(db);
return -1;
}
/* This function creates a mail_eval_res entry.
* This function sets the KMO error string. It returns -1 on failure.
*/
static int create_mail_eval_res(sqlite3 *db, maildb_mail_info *mail_info, int64_t *entry_id) {
sqlite3_stmt *stmt = NULL;
kstr insert_str;
int i;
assert(*entry_id >= 0);
/* Create the mail_eval_res entry. */
kstr_init_cstr(&insert_str, "INSERT INTO mail_eval_res3 (");
/* If entry_id is not 0, then we must specify the entry_id in the INSERT. */
if (*entry_id != 0) {
kstr_append_cstr(&insert_str, "entry_id, ");
}
kstr_append_cstr(&insert_str,
"hash, ksn, status, display_pref, sig_msg, mid, original_packaging, mua, field_status, "
"att_plugin_nbr, attachment_nbr, attachment_status, sym_key, encryption_status, "
"decryption_error_msg, pod_status, pod_msg, otut_status, otut_string, "
"otut_msg, kpg_addr, kpg_port) "
"VALUES (");
if (*entry_id != 0) {
kstr_append_cstr(&insert_str, "?, ");
}
kstr_append_cstr(&insert_str, "?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?);");
if (sqlite3_prepare(db, insert_str.data, -1, &stmt, NULL)) goto ERR;
i = 1;
if (*entry_id != 0) {
if (sqlite3_bind_int64(stmt, i++, *entry_id)) goto ERR;
}
if (write_blob(stmt, i++, &mail_info->hash)) goto ERR;
if (write_blob(stmt, i++, &mail_info->ksn)) goto ERR;
if (sqlite3_bind_int(stmt, i++, mail_info->status)) goto ERR;
if (sqlite3_bind_int(stmt, i++, mail_info->display_pref)) goto ERR;
if (write_string(stmt, i++, &mail_info->sig_msg)) goto ERR;
if (sqlite3_bind_int64(stmt, i++, mail_info->mid)) goto ERR;
if (sqlite3_bind_int(stmt, i++, mail_info->original_packaging)) goto ERR;
if (sqlite3_bind_int(stmt, i++, mail_info->mua)) goto ERR;
if (sqlite3_bind_int(stmt, i++, mail_info->field_status)) goto ERR;
if (sqlite3_bind_int(stmt, i++, mail_info->att_plugin_nbr)) goto ERR;
if (sqlite3_bind_int(stmt, i++, mail_info->attachment_nbr)) goto ERR;
if (write_blob(stmt, i++, &mail_info->attachment_status)) goto ERR;
if (write_blob(stmt, i++, &mail_info->sym_key)) goto ERR;
if (sqlite3_bind_int(stmt, i++, mail_info->encryption_status)) goto ERR;
if (write_string(stmt, i++, &mail_info->decryption_error_msg)) goto ERR;
if (sqlite3_bind_int(stmt, i++, mail_info->pod_status)) goto ERR;
if (write_string(stmt, i++, &mail_info->pod_msg)) goto ERR;
if (sqlite3_bind_int(stmt, i++, mail_info->otut_status)) goto ERR;
if (write_blob(stmt, i++, &mail_info->otut_string)) goto ERR;
if (write_string(stmt, i++, &mail_info->otut_msg)) goto ERR;
if (write_string(stmt, i++, &mail_info->kpg_addr)) goto ERR;
if (sqlite3_bind_int(stmt, i++, mail_info->kpg_port)) goto ERR;
if (sqlite3_step(stmt) != SQLITE_DONE) goto ERR;
finalize_stmt(db, &stmt);
/* Obtain/validate the entry ID. */
if (*entry_id == 0) {
*entry_id = sqlite3_last_insert_rowid(db);
}
else {
assert(*entry_id == sqlite3_last_insert_rowid(db));
}
kstr_free(&insert_str);
return 0;
ERR:
kmo_seterror(sqlite3_errmsg(db));
finalize_stmt(db, &stmt);
kstr_free(&insert_str);
return -1;
}
void transform(int deviceNumber, int levels, unsigned w, unsigned h, unsigned bits)
{
uint64_t cbinput=uint64_t(w)*bits/8;
std::vector<uint64_t> input(2*(cbinput/8));
std::vector<uint64_t> output(2*(cbinput/8));
std::vector<uint32_t> unpackedInput(2*(cbinput/4));
std::vector<uint32_t> unpackedOutput(2*(cbinput/4));
uint64_t* inputWriteptr = &input[0];
uint64_t* inputReadptr = &input[cbinput/8];
uint32_t* unpackedInputReadptr = &unpackedInput[cbinput/4];
uint32_t* unpackedInputWriteptr = &unpackedInput[0];
uint32_t* unpackedOutputReadptr = &unpackedOutput[cbinput/4];
uint32_t* unpackedOutputWriteptr = &unpackedOutput[0];
uint64_t* outputWriteptr = &output[0];
uint64_t* outputReadptr = &output[cbinput/8];
std::vector<uint32_t> gpuReadOffsets(2*levels+1,0);
std::vector<uint32_t> gpuWriteOffsets(2*levels+1,0);
std::vector<uint32_t> aboveOverrides(2*levels,0);
std::vector<uint32_t> belowOverrides(2*levels,0);
int j=0;
for (int i=0; i<2*levels+1; i++)
{
gpuWriteOffsets[i] = j;
j+= 2;
j = j - (4 & -(j >= 4));
j = j + (4 & -(j < 0));
gpuReadOffsets[i] = j;
}
auto cl_instance = init_cl(levels,w,h,bits,"pipeline_kernels.cl",deviceNumber);
tbb::task_group group;
bool finished = false;
int fullness = 0;
bool full = false;
int tailEnd = 4*levels+5;
int image_line = 0;
while(1){
for (int i=0; i<levels; i++) {
if (image_line == 4 + 2*i) aboveOverrides[i] = 0x0 ^ -(levels < 0);
else aboveOverrides[i] = 0xFFFFFFFF ^ -(levels < 0);
if (image_line == 3 + 2*i) belowOverrides[i] = 0x0 ^ -(levels < 0);
else belowOverrides[i] = 0xFFFFFFFF ^ -(levels < 0);
}
for (int i=levels; i<2*levels; i++) {
if (image_line == 4 + 2*i) aboveOverrides[i] = 0xFFFFFFFF ^ -(levels < 0);
else aboveOverrides[i] = 0x0 ^ -(levels < 0);
if (image_line == 3 + 2*i) belowOverrides[i] = 0xFFFFFFFF ^ -(levels < 0);
else belowOverrides[i] = 0x0 ^ -(levels < 0);
}
group.run([&](){
if(!finished && !read_blob(STDIN_FILENO, cbinput, inputWriteptr)) finished = true;
unpack_blob_32(cbinput, inputReadptr, unpackedInputWriteptr);
pack_blob_32(cbinput, unpackedOutputReadptr, outputWriteptr);
if (fullness >= 4*levels+6 || full)
{
full = true;
write_blob(STDOUT_FILENO, cbinput, outputReadptr);
}
else
{
fullness++;
}
});
group.run([&](){
process_opencl_packed_line(levels, w, bits, gpuReadOffsets, gpuWriteOffsets, unpackedInputReadptr, unpackedOutputWriteptr, aboveOverrides, belowOverrides, cl_instance);
for (int i=0; i<2*levels+1; i++)
{
int j = gpuWriteOffsets[i];
j++;
j = j - (4 & -(j >= 4));
gpuWriteOffsets[i] = j;
j = gpuReadOffsets[i];
j++;
j = j - (4 & -(j >= 4));
gpuReadOffsets[i] = j;
}
});
group.wait();
if (tailEnd == 0) {
break;
}
if (finished) tailEnd--;
std::swap(inputReadptr, inputWriteptr);
std::swap(unpackedInputReadptr, unpackedInputWriteptr);
std::swap(unpackedOutputReadptr, unpackedOutputWriteptr);
std::swap(outputReadptr, outputWriteptr);
image_line++;
if (image_line == h) image_line = 0;
}
}
static int
write_exif( Write *write )
{
#ifdef HAVE_EXIF
unsigned char *data;
size_t data_length;
unsigned int idl;
ExifData *ed;
/* Either parse from the embedded EXIF, or if there's none, make
* some fresh EXIF we can write the resolution to.
*/
if( vips_image_get_typeof( write->in, VIPS_META_EXIF_NAME ) ) {
if( vips_image_get_blob( write->in, VIPS_META_EXIF_NAME,
(void *) &data, &data_length ) )
return( -1 );
if( !(ed = exif_data_new_from_data( data, data_length )) )
return( -1 );
}
else {
ed = exif_data_new();
exif_data_set_option( ed,
EXIF_DATA_OPTION_FOLLOW_SPECIFICATION );
exif_data_set_data_type( ed, EXIF_DATA_TYPE_COMPRESSED );
exif_data_set_byte_order( ed, EXIF_BYTE_ORDER_INTEL );
/* Create the mandatory EXIF fields with default data.
*/
exif_data_fix( ed );
}
/* Update EXIF tags from the image metadata.
*/
vips_exif_update( ed, write->in );
/* Update EXIF resolution from the vips image header.
*/
if( vips__set_exif_resolution( ed, write->in ) ) {
exif_data_free( ed );
return( -1 );
}
/* Update EXIF image dimensions from the vips image header.
*/
if( set_exif_dimensions( ed, write->in ) ) {
exif_data_free( ed );
return( -1 );
}
/* Update EXIF orientation from the vips image header.
*/
if( set_exif_orientation( ed, write->in ) ) {
exif_data_free( ed );
return( -1 );
}
/* Reserialise and write. exif_data_save_data() returns an int for some
* reason.
*/
exif_data_save_data( ed, &data, &idl );
if( !idl ) {
vips_error( "VipsJpeg", "%s", _( "error saving EXIF" ) );
exif_data_free( ed );
return( -1 );
}
data_length = idl;
#ifdef DEBUG
printf( "write_exif: attaching %zd bytes of EXIF\n", data_length );
#endif /*DEBUG*/
exif_data_free( ed );
jpeg_write_marker( &write->cinfo, JPEG_APP0 + 1, data, data_length );
free( data );
#else /*!HAVE_EXIF*/
/* No libexif ... just copy the embedded EXIF over.
*/
if( write_blob( write, VIPS_META_EXIF_NAME, JPEG_APP0 + 1 ) )
return( -1 );
#endif /*!HAVE_EXIF*/
return( 0 );
}
/* Write a VIPS image to a JPEG compress struct.
*/
static int
write_vips( Write *write, int qfac, const char *profile,
gboolean optimize_coding, gboolean progressive, gboolean strip,
gboolean no_subsample, gboolean trellis_quant,
gboolean overshoot_deringing, gboolean optimize_scans, int quant_table )
{
VipsImage *in;
J_COLOR_SPACE space;
/* The image we'll be writing ... can change, see CMYK.
*/
in = write->in;
/* Should have been converted for save.
*/
g_assert( in->BandFmt == VIPS_FORMAT_UCHAR );
g_assert( in->Coding == VIPS_CODING_NONE );
g_assert( in->Bands == 1 ||
in->Bands == 3 ||
in->Bands == 4 );
/* Check input image.
*/
if( vips_image_pio_input( in ) )
return( -1 );
/* Set compression parameters.
*/
write->cinfo.image_width = in->Xsize;
write->cinfo.image_height = in->Ysize;
write->cinfo.input_components = in->Bands;
if( in->Bands == 4 &&
in->Type == VIPS_INTERPRETATION_CMYK ) {
space = JCS_CMYK;
/* IJG always sets an Adobe marker, so we should invert CMYK.
*/
if( vips_invert( in, &write->inverted, NULL ) )
return( -1 );
in = write->inverted;
}
else if( in->Bands == 3 )
space = JCS_RGB;
else if( in->Bands == 1 )
space = JCS_GRAYSCALE;
else
/* Use luminance compression for all channels.
*/
space = JCS_UNKNOWN;
write->cinfo.in_color_space = space;
/* Build VIPS output stuff now we know the image we'll be writing.
*/
if( !(write->row_pointer = VIPS_ARRAY( NULL, in->Ysize, JSAMPROW )) )
return( -1 );
#ifdef HAVE_JPEG_EXT_PARAMS
/* Reset compression profile to libjpeg defaults
*/
if( jpeg_c_int_param_supported( &write->cinfo, JINT_COMPRESS_PROFILE ) )
jpeg_c_set_int_param( &write->cinfo,
JINT_COMPRESS_PROFILE, JCP_FASTEST );
#endif
/* Reset to default.
*/
jpeg_set_defaults( &write->cinfo );
/* Compute optimal Huffman coding tables.
*/
write->cinfo.optimize_coding = optimize_coding;
#ifdef HAVE_JPEG_EXT_PARAMS
/* Apply trellis quantisation to each 8x8 block. Implies
* "optimize_coding".
*/
if( trellis_quant ) {
if( jpeg_c_bool_param_supported( &write->cinfo,
JBOOLEAN_TRELLIS_QUANT ) ) {
jpeg_c_set_bool_param( &write->cinfo,
JBOOLEAN_TRELLIS_QUANT, TRUE );
write->cinfo.optimize_coding = TRUE;
}
else
vips_warn( "vips2jpeg",
"%s", _( "trellis_quant unsupported" ) );
}
/* Apply overshooting to samples with extreme values e.g. 0 & 255
* for 8-bit.
*/
if( overshoot_deringing ) {
if( jpeg_c_bool_param_supported( &write->cinfo,
JBOOLEAN_OVERSHOOT_DERINGING ) )
jpeg_c_set_bool_param( &write->cinfo,
JBOOLEAN_OVERSHOOT_DERINGING, TRUE );
else
vips_warn( "vips2jpeg",
"%s", _( "overshoot_deringing unsupported" ) );
}
/* Split the spectrum of DCT coefficients into separate scans.
* Requires progressive output. Must be set before
* jpeg_simple_progression.
*/
if( optimize_scans ) {
if( progressive ) {
if( jpeg_c_bool_param_supported( &write->cinfo,
JBOOLEAN_OPTIMIZE_SCANS ) )
jpeg_c_set_bool_param( &write->cinfo,
JBOOLEAN_OPTIMIZE_SCANS, TRUE );
else
vips_warn( "vips2jpeg",
"%s", _( "Ignoring optimize_scans" ) );
}
else
vips_warn( "vips2jpeg", "%s",
_( "Ignoring optimize_scans for baseline" ) );
}
/* Use predefined quantization table.
*/
if( quant_table > 0 ) {
if( jpeg_c_int_param_supported( &write->cinfo,
JINT_BASE_QUANT_TBL_IDX ) )
jpeg_c_set_int_param( &write->cinfo,
JINT_BASE_QUANT_TBL_IDX, quant_table );
else
vips_warn( "vips2jpeg",
"%s", _( "Setting quant_table unsupported" ) );
}
#else
/* Using jpeglib.h without extension parameters, warn of ignored
* options.
*/
if( trellis_quant )
vips_warn( "vips2jpeg", "%s", _( "Ignoring trellis_quant" ) );
if( overshoot_deringing )
vips_warn( "vips2jpeg",
"%s", _( "Ignoring overshoot_deringing" ) );
if( optimize_scans )
vips_warn( "vips2jpeg", "%s", _( "Ignoring optimize_scans" ) );
if( quant_table > 0 )
vips_warn( "vips2jpeg", "%s", _( "Ignoring quant_table" ) );
#endif
/* Set compression quality. Must be called after setting params above.
*/
jpeg_set_quality( &write->cinfo, qfac, TRUE );
/* Enable progressive write.
*/
if( progressive )
jpeg_simple_progression( &write->cinfo );
/* Turn off chroma subsampling. Follow IM and do it automatically for
* high Q.
*/
if( no_subsample ||
qfac > 90 ) {
int i;
for( i = 0; i < in->Bands; i++ ) {
write->cinfo.comp_info[i].h_samp_factor = 1;
write->cinfo.comp_info[i].v_samp_factor = 1;
}
}
/* Don't write the APP0 JFIF headers if we are stripping.
*/
if( strip )
write->cinfo.write_JFIF_header = FALSE;
/* Build compress tables.
*/
jpeg_start_compress( &write->cinfo, TRUE );
/* Write any APP markers we need.
*/
if( !strip ) {
if( write_exif( write ) ||
write_blob( write,
VIPS_META_XMP_NAME, JPEG_APP0 + 1 ) ||
write_blob( write,
VIPS_META_IPCT_NAME, JPEG_APP0 + 13 ) )
return( -1 );
/* A profile supplied as an argument overrides an embedded
* profile. "none" means don't attach a profile.
*/
if( profile &&
strcmp( profile, "none" ) != 0 &&
write_profile_file( write, profile ) )
return( -1 );
if( !profile &&
vips_image_get_typeof( in, VIPS_META_ICC_NAME ) &&
write_profile_meta( write ) )
return( -1 );
}
/* Write data. Note that the write function grabs the longjmp()!
*/
if( vips_sink_disc( in, write_jpeg_block, write ) )
return( -1 );
/* We have to reinstate the setjmp() before we jpeg_finish_compress().
*/
if( setjmp( write->eman.jmp ) )
return( -1 );
jpeg_finish_compress( &write->cinfo );
return( 0 );
}
