static Elf_Bhdr *add_boot_note(Elf_Bhdr *bhdr, const char *name,
unsigned type, const char *desc, unsigned descsz)
{
Elf_Nhdr nhdr;
unsigned ent_size, new_size, pad;
char *addr;
if (!bhdr)
return NULL;
nhdr.n_namesz = name? strlen(name)+1 : 0;
nhdr.n_descsz = descsz;
nhdr.n_type = type;
ent_size = sizeof(nhdr) + padded(nhdr.n_namesz) + padded(nhdr.n_descsz);
if (bhdr->b_size + ent_size > 0xffff) {
printf("Boot notes too big\n");
free(bhdr);
return NULL;
}
if (bhdr->b_size + ent_size > bhdr->b_checksum) {
do {
new_size = bhdr->b_checksum * 2;
} while (new_size < bhdr->b_size + ent_size);
if (new_size > 0xffff)
new_size = 0xffff;
debug("expanding boot note size to %u\n", new_size);
#ifdef HAVE_REALLOC
bhdr = realloc(bhdr, new_size);
bhdr->b_checksum = new_size;
#else
printf("Boot notes too big\n");
free(bhdr);
return NULL;
#endif
}
addr = (char *) bhdr;
addr += bhdr->b_size;
memcpy(addr, &nhdr, sizeof(nhdr));
addr += sizeof(nhdr);
if (name && nhdr.n_namesz) {
memcpy(addr, name, nhdr.n_namesz);
addr += nhdr.n_namesz;
pad = padded(nhdr.n_namesz) - nhdr.n_namesz;
memset(addr, 0, pad);
addr += pad;
}
memcpy(addr, desc, nhdr.n_descsz);
addr += nhdr.n_descsz;
pad = padded(nhdr.n_descsz) - nhdr.n_descsz;
memset(addr, 0, pad);
bhdr->b_size += ent_size;
bhdr->b_records++;
return bhdr;
}
size_t process(univector<T, Tag>& output, univector_ref<const T> input)
{
const itype required_input_size = input_size_for_output(output.size());
const itype input_size = input.size();
for (size_t i = 0; i < output.size(); i++)
{
const itype intermediate_index =
output_position_to_intermediate(static_cast<itype>(i) + output_position);
const itype intermediate_start = intermediate_index - taps + 1;
const std::lldiv_t input_pos =
floor_div(intermediate_start + interpolation_factor - 1, interpolation_factor);
const itype input_start = input_pos.quot; // first input sample
const itype tap_start = interpolation_factor - 1 - input_pos.rem;
const univector_ref<T> tap_ptr = filter.slice(static_cast<size_t>(tap_start * depth));
if (input_start >= input_position + input_size)
{
output[i] = T(0);
}
else if (input_start >= input_position)
{
output[i] = dotproduct(input.slice(input_start - input_position, depth), tap_ptr);
}
else
{
const itype prev_count = input_position - input_start;
output[i] = dotproduct(delay.slice(size_t(depth - prev_count)), tap_ptr) +
dotproduct(input.slice(0, size_t(depth - prev_count)),
tap_ptr.slice(size_t(prev_count), size_t(depth - prev_count)));
}
}
if (required_input_size >= depth)
{
delay.slice(0, delay.size()) = padded(input.slice(size_t(required_input_size - depth)));
}
else
{
delay.truncate(size_t(depth - required_input_size)) = delay.slice(size_t(required_input_size));
delay.slice(size_t(depth - required_input_size)) = padded(input);
}
input_position += required_input_size;
output_position += output.size();
return required_input_size;
}
int keystore_rsa_priv_enc(int flen, const unsigned char* from, unsigned char* to, RSA* rsa,
int padding) {
ALOGV("keystore_rsa_sign(%d, %p, %p, %p, %d)", flen, from, to, rsa, padding);
int num = RSA_size(rsa);
UniquePtr<uint8_t> padded(new uint8_t[num]);
if (padded.get() == NULL) {
ALOGE("could not allocate padded signature");
return 0;
}
switch (padding) {
case RSA_PKCS1_PADDING:
if (!RSA_padding_add_PKCS1_type_1(padded.get(), num, from, flen)) {
return 0;
}
break;
case RSA_X931_PADDING:
if (!RSA_padding_add_X931(padded.get(), num, from, flen)) {
return 0;
}
break;
case RSA_NO_PADDING:
if (!RSA_padding_add_none(padded.get(), num, from, flen)) {
return 0;
}
break;
default:
ALOGE("Unknown padding type: %d", padding);
return 0;
}
uint8_t* key_id = reinterpret_cast<uint8_t*>(RSA_get_ex_data(rsa, rsa_key_handle));
if (key_id == NULL) {
ALOGE("key had no key_id!");
return 0;
}
Keystore_Reply reply;
if (keystore_cmd(CommandCodes[SIGN], &reply, 2, strlen(reinterpret_cast<const char*>(key_id)),
key_id, static_cast<size_t>(num), reinterpret_cast<const uint8_t*>(padded.get()))
!= NO_ERROR) {
ALOGE("There was an error during rsa_mod_exp");
return 0;
}
const size_t replyLen = reply.length();
if (replyLen <= 0) {
ALOGW("No valid signature returned");
return 0;
}
memcpy(to, reply.get(), replyLen);
ALOGV("rsa=%p keystore_rsa_sign => returning %p len %llu", rsa, to,
(unsigned long long) replyLen);
return static_cast<int>(replyLen);
}
size_t skip(size_t output_size, univector_ref<const T> input)
{
const itype required_input_size = input_size_for_output(output_size);
if (required_input_size >= depth)
{
delay.slice(0, delay.size()) = padded(input.slice(size_t(required_input_size - depth)));
}
else
{
delay.truncate(size_t(depth - required_input_size)) = delay.slice(size_t(required_input_size));
delay.slice(size_t(depth - required_input_size)) = padded(input);
}
input_position += required_input_size;
output_position += output_size;
return required_input_size;
}
void convolve_filter<T>::set_data(const univector<T>& data)
{
univector<T> input(fft.size);
const T ifftsize = reciprocal(T(fft.size));
for (size_t i = 0; i < ir_segments.size(); i++)
{
segments[i].resize(block_size);
ir_segments[i].resize(block_size, 0);
input = padded(data.slice(i * block_size, block_size));
fft.execute(ir_segments[i], input, temp, dft_pack_format::Perm);
process(ir_segments[i], ir_segments[i] * ifftsize);
}
saved_input.resize(block_size, 0);
scratch.resize(block_size * 2);
premul.resize(block_size, 0);
cscratch.resize(block_size);
overlap.resize(block_size, 0);
}
void convolve_filter<T>::process_buffer(T* output, const T* input, size_t size)
{
size_t processed = 0;
while (processed < size)
{
const size_t processing = std::min(size - processed, block_size - input_position);
internal::builtin_memcpy(saved_input.data() + input_position, input + processed,
processing * sizeof(T));
process(scratch, padded(saved_input));
fft.execute(segments[position], scratch, temp, dft_pack_format::Perm);
if (input_position == 0)
{
process(premul, zeros());
for (size_t i = 1; i < segments.size(); i++)
{
const size_t n = (position + i) % segments.size();
fft_multiply_accumulate(premul, ir_segments[i], segments[n], dft_pack_format::Perm);
}
}
fft_multiply_accumulate(cscratch, premul, ir_segments[0], segments[position], dft_pack_format::Perm);
fft.execute(scratch, cscratch, temp, dft_pack_format::Perm);
process(make_univector(output + processed, processing),
scratch.slice(input_position) + overlap.slice(input_position));
input_position += processing;
if (input_position == block_size)
{
input_position = 0;
process(saved_input, zeros());
internal::builtin_memcpy(overlap.data(), scratch.data() + block_size, block_size * sizeof(T));
position = position > 0 ? position - 1 : segments.size() - 1;
}
processed += processing;
}
}
static int lreplace( gdcm::Tag const &t, const char *value, gdcm::VL const & vl, gdcm::DataSet &ds ) {
if ( t.GetGroup() < 0x0008 ) return 0;
if ( t.IsPrivate() && vl == 0 && ds.FindDataElement( t ) ) {
gdcm::DataElement de ( ds.GetDataElement( t ) );
if ( de.GetVR() != gdcm::VR::INVALID ) {
if ( de.GetVR() == gdcm::VR::SQ && *value == 0 )
{ return emptyData( t, ds ); } // Only allowed operation for a Private Tag
else { return 0; } //Trying to replace value of a Private Tag
}
de.SetByteValue( "", 0 );
ds.Insert( de );
return 1;
} else {
const gdcm::DictEntry &entry = dicts.GetDictEntry( t );
if ( entry.GetVR() == gdcm::VR::INVALID || entry.GetVR() == gdcm::VR::UN )
{ return 0; }
if ( entry.GetVR() == gdcm::VR::SQ && vl == 0 && value && *value == 0 )
{ return emptyData( t, ds ); }
else if ( entry.GetVR() && gdcm::VR::VRBINARY && vl == 0 )
{ return replaceData( t, ds, entry, "", 0 ); }
else { // ASCII
if ( value ) {
std::string padded( value, vl);
if ( vl.IsOdd() && (entry.GetVR() != gdcm::VR::UI) ) { padded += " "; }
return replaceData( t, ds, entry, padded.c_str(), (gdcm::VL::Type)padded.size() );
}
}
}
return 0;
}
/**
* Evaluate the score of the given configurations
*/
vector<double> FAsTMatch::evaluateConfigs( Mat& image, Mat& templ, vector<Mat>& affine_matrices,
Mat& xs, Mat& ys, bool photometric_invariance ) {
int r1x = 0.5 * (templ.cols - 1),
r1y = 0.5 * (templ.rows - 1),
r2x = 0.5 * (image.cols - 1),
r2y = 0.5 * (image.rows - 1);
int no_of_configs = static_cast<int>(affine_matrices.size());
int no_of_points = xs.cols;
/* Use a padded image, to avoid boundary checking */
Mat padded( image.rows * 3, image.cols, image.type(), Scalar(0.0) );
image.copyTo( Mat(padded, Rect(0, image.rows, image.cols, image.rows)) );
/* Create a lookup array for our template values based on the given random x and y points */
int * xs_ptr = xs.ptr<int>(0),
* ys_ptr = ys.ptr<int>(0);
vector<float> vals_i1( no_of_points );
for( int i = 0; i < no_of_points; i++ )
vals_i1[i] = templ.at<float>(ys_ptr[i] - 1, xs_ptr[i] - 1);
/* Recenter our indices */
Mat xs_centered = xs.clone() - (r1x + 1),
ys_centered = ys.clone() - (r1y + 1);
int * xs_ptr_cent = xs_centered.ptr<int>(0),
* ys_ptr_cent = ys_centered.ptr<int>(0);
vector<double> distances(no_of_configs, 0.0 );
/* Calculate the score for each configurations on each of our randomly sampled points */
tbb::parallel_for( 0, no_of_configs, 1, [&](int i) {
float a11 = affine_matrices[i].at<float>(0, 0),
a12 = affine_matrices[i].at<float>(0, 1),
a13 = affine_matrices[i].at<float>(0, 2),
a21 = affine_matrices[i].at<float>(1, 0),
a22 = affine_matrices[i].at<float>(1, 1),
a23 = affine_matrices[i].at<float>(1, 2);
double tmp_1 = (r2x + 1) + a13 + 0.5;
double tmp_2 = (r2y + 1) + a23 + 0.5 + 1 * image.rows;
double score = 0.0;
if(!photometric_invariance) {
for( int j = 0; j < no_of_points; j++ ) {
int target_x = int( a11 * xs_ptr_cent[j] + a12 * ys_ptr_cent[j] + tmp_1 ),
target_y = int( a21 * xs_ptr_cent[j] + a22 * ys_ptr_cent[j] + tmp_2 );
score += abs(vals_i1[j] - padded.at<float>(target_y - 1, target_x - 1) );
}
}
else {
vector<double> xs_target(no_of_points),
ys_target(no_of_points);
double sum_x = 0.0,
sum_y = 0.0,
sum_x_squared = 0.0,
sum_y_squared = 0.0;
for( int j = 0; j < no_of_points; j++ ) {
int target_x = int( a11 * xs_ptr_cent[j] + a12 * ys_ptr_cent[j] + tmp_1 ),
target_y = int( a21 * xs_ptr_cent[j] + a22 * ys_ptr_cent[j] + tmp_2 );
float xi = vals_i1[j],
yi = padded.at<float>(target_y - 1, target_x - 1);
xs_target[j] = xi;
ys_target[j] = yi;
sum_x += xi;
sum_y += yi;
sum_x_squared += (xi * xi);
sum_y_squared += (yi * yi);
}
double epsilon = 1e-7;
double mean_x = sum_x / no_of_points,
mean_y = sum_y / no_of_points,
sigma_x = sqrt((sum_x_squared - ( sum_x * sum_x ) / no_of_points ) / no_of_points) + epsilon,
sigma_y = sqrt((sum_y_squared - ( sum_y * sum_y ) / no_of_points ) / no_of_points) + epsilon;
double sigma_div = sigma_x / sigma_y;
double temp = -mean_x + sigma_div * mean_y;
for( int j = 0; j < no_of_points; j++ )
score += fabs( xs_target[j] - sigma_div * ys_target[j] + temp );
}
distances[i] = score / no_of_points;
});
return distances;
}
//
// Loads the raw reflection data directly from a *.d3dbsp file and stores it in the "dest" buffer
// Returns TRUE if successful
// Will fail if destSize does not match the length of the reflection data in the file
//
BOOL LoadBSPReflectionData(const char* bspPath, BYTE* dest, size_t destSize)
{
FILE* h;
if (fopen_s(&h, bspPath, "rb") != 0)
{
printf("ERROR: Could not open file %s\n", bspPath);
return FALSE;
}
DWORD magic = 0;
fread(&magic, 4, 1, h);
if (magic != 'PSBI')
{
printf("ERROR: File %s appears to be corrupt\n", bspPath);
fclose(h);
return FALSE;
}
DWORD version = 0;
fread(&version, 4, 1, h);
if (version != 45)
{
printf("ERROR: D3DBSP %s is version %d when it should be version %d\n", bspPath, version, 45);
fclose(h);
return FALSE;
}
DWORD lumpCount = 0;
fread(&lumpCount, 4, 1, h);
DWORD* index = new DWORD[lumpCount * 2];
fread(index, 8, lumpCount, h);
DWORD offset = ftell(h);
DWORD size = 0;
for (DWORD i = 0; i < lumpCount*2; i+=2)
{
if (index[i] == 0x29)
{
size = index[i + 1];
break;
}
else
offset += padded(index[i + 1]);
}
//
// If the size of the reflection data in the D3DBSP file does not match the size
// of the reflection data in the fastfile, the user likely added or removed one
// or more reflection probes from the map and then rebuilt the BSP
//
if (padded(size) != padded(destSize))
{
printf("ERROR: Fastfile probe count does not match the BSP probe count - please rebuild fastfile\n");
fclose(h);
return FALSE;
}
fseek(h, offset, SEEK_SET);
fread(dest, 1, size, h);
fclose(h);
return TRUE;
}
