jint JNI_OnLoad(JavaVM *vm, void *reserved) {
LOGV(TAG, "Loading library");
jvm = vm;
JNIEnv *env;
if ((*vm)->GetEnv(vm, (void **) &env, JNI_VERSION_1_6)) {
return JNI_ERR; /* JNI version not supported */
}
jFXActivityClass = (*env)->NewGlobalRef(env, (*env)->FindClass(env, "javafxports/android/FXActivity"));
CHECK_EXCEPTION(env);
jFXActivity_notifyGlassStartup = (*env)->GetStaticMethodID(env, jFXActivityClass, "notify_glassHasStarted", "()V");
CHECK_EXCEPTION(env);
jFXActivity_notifyGlassShutdown = (*env)->GetStaticMethodID(env, jFXActivityClass, "notify_glassShutdown", "()V");
CHECK_EXCEPTION(env);
jFXActivity_notifyShowIME = (*env)->GetStaticMethodID(env, jFXActivityClass, "notify_showIME", "()V");
CHECK_EXCEPTION(env);
jFXActivity_notifyHideIME = (*env)->GetStaticMethodID(env, jFXActivityClass, "notify_hideIME", "()V");
CHECK_EXCEPTION(env);
return JNI_VERSION_1_6;
}
void init_ids(JNIEnv *env) {
jNativeWebViewClass = (*env)->NewGlobalRef(env,
(*env)->FindClass(env, "com/sun/webkit/NativeWebView"));
CHECK_EXCEPTION(env);
jNativeWebView_fire_load_event = (*env)->GetStaticMethodID(env, jNativeWebViewClass,
"fire_load_event", "(IIILjava/lang/String;Ljava/lang/String;II)V");
CHECK_EXCEPTION(env);
}
static void read_physical_drive_sector_to_file(uint8_t drive_number, uint64_t sector_number, _In_z_ const wchar_t* output_file_name)
{
std::vector<uint8_t> sector = read_physical_drive_sector(drive_number, sector_number);
std::ofstream output_file(output_file_name, std::ios::binary | std::ios::trunc);
CHECK_EXCEPTION(output_file.good(), u8"Error opening: " + PortableRuntime::utf8_from_utf16(output_file_name));
output_file.write(reinterpret_cast<const char*>(sector.data()), sector.size());
CHECK_EXCEPTION(!output_file.fail(), u8"Error writing output file.");
}
static int parse_arguments_and_execute()
{
enum
{
Argument_logical_sector = 0,
Argument_file_name,
Argument_help,
};
const std::vector<Parsing::Argument_descriptor> argument_map =
{
{ Argument_logical_sector, u8"logical-sector", u8's', true, u8"The logical block address (LBA) of the sector to read." },
{ Argument_file_name, u8"file-name", u8'f', true, u8"The name of the file to hold the output. This file will be overwritten." },
{ Argument_help, u8"help", u8'?', false, nullptr },
};
#ifndef NDEBUG
Parsing::validate_argument_map(argument_map);
#endif
const auto arguments = WindowsCommon::args_from_command_line();
const auto options = Parsing::options_from_allowed_args(arguments, argument_map);
int error_level = 0;
if(options.count(Argument_help) == 0)
{
CHECK_EXCEPTION(options.count(Argument_logical_sector) > 0, u8"Missing a required argument: --" + std::string(argument_map[Argument_logical_sector].long_name));
CHECK_EXCEPTION(options.count(Argument_file_name) > 0, u8"Missing a required argument: --" + std::string(argument_map[Argument_file_name].long_name));
// There is no _atoui64 function (and perhaps a private implementation is a good idea), but
// reading an int64_t into a uint64_t will have no negative (ha!) consequences, as any sector
// number is considered a valid sector to read.
const uint64_t sector_number = _atoi64(options.at(Argument_logical_sector).c_str());
GetSector::read_physical_drive_sector_to_file(0, sector_number, PortableRuntime::utf16_from_utf8(options.at(Argument_file_name)).c_str());
}
else
{
constexpr auto arg_program_name = 0;
// Hold a reference to program_name_long for the duration of the output functions.
const auto program_name_long = PortableRuntime::utf16_from_utf8(arguments[arg_program_name]);
const auto program_name = PathFindFileNameW(program_name_long.c_str());
std::fwprintf(stderr, L"Usage: %s [options]\nOptions:\n", program_name);
std::fwprintf(stderr, PortableRuntime::utf16_from_utf8(Parsing::Options_help_text(argument_map)).c_str());
std::fwprintf(stderr,
L"\nTo read the Master Boot Record:\n %s -%c 1 -%c mbr.bin\n",
program_name,
argument_map[Argument_logical_sector].short_name,
argument_map[Argument_file_name].short_name);
error_level = 1;
}
return error_level;
}
void fire_load_event(int id, int frameID, int state, char *url, char *content_type,
int progress, int error_code) {
JNIEnv *env;
(*jvm)->AttachCurrentThread(jvm, &env, 0);
jstring jurl = (*env)->NewStringUTF(env, url);
jstring jcontentType = (*env)->NewStringUTF(env, content_type);
CHECK_EXCEPTION(env);
(*env)->CallStaticVoidMethod(env, jNativeWebViewClass,
jNativeWebView_fire_load_event,
id, frameID, state, jurl, jcontentType, progress, error_code);
CHECK_EXCEPTION(env);
}
static size_t
AndroidDecrypt(vlc_keystore *p_keystore, void *p_ctx, const uint8_t *p_src,
size_t i_src_len, uint8_t **pp_dst)
{
(void) p_ctx;
JNIEnv *p_env = GET_ENV();
if (p_env == NULL)
return 0;
jobject jivArray = NULL, jiv = NULL, jcipher = NULL;
jcipher = CALL_STATICOBJ(Cipher, Cipher.getInstance, fields.VLC_CIPHER);
if (CHECK_EXCEPTION())
return 0;
/* Get the IV located at the beginning of the secret */
size_t i_dst_len = 0;
uint32_t i_iv_len;
if (i_src_len < sizeof(uint32_t))
goto end;
memcpy(&i_iv_len, p_src, sizeof(uint32_t));
if (i_iv_len == 0 || i_src_len < (sizeof(uint32_t) + i_iv_len))
goto end;
jivArray = (*p_env)->NewByteArray(p_env, i_iv_len);
if (CHECK_EXCEPTION())
goto end;
(*p_env)->SetByteArrayRegion(p_env, jivArray, 0, i_iv_len,
(jbyte *)(p_src + sizeof(uint32_t)) );
jiv = NEW_OBJECT(IvParameterSpec, jivArray);
if (CHECK_EXCEPTION())
goto end;
/* Use the IV to initialize the decrypt Cipher */
CALL_VOID(jcipher, Cipher.init, fields.Cipher.DECRYPT_MODE, s_jkey, jiv);
if (CHECK_EXCEPTION())
goto end;
i_dst_len = Process(p_keystore, p_env, jcipher,
p_src + sizeof(uint32_t) + i_iv_len,
i_src_len - sizeof(uint32_t) - i_iv_len,
NULL, 0, pp_dst);
end:
DEL_LREF(jcipher);
if (jivArray != NULL)
DEL_LREF(jivArray);
if (jiv != NULL)
DEL_LREF(jiv);
return i_dst_len;
}
static int array2_test(IC_Env *env)
{
long dl[2][3] = {{11, 2, 7}, {22, 8 ,13}};
m_dd dlo;
m_dd_slice* dlr;
fprintf(stdout, "\n======== m_i_array2 test ======\n\n");
dlr = m_i_array2_test(NULL, dl, dlo, env);
CHECK_EXCEPTION(env);
RETURN_IF_OK(cmp_dd(dl,dlo) && cmp_dd(dl,dlr));
if (!cmp_dd(dl,dlo)) {
fprintf(stdout, " out parameter error, sent:\n");
print_dd(dl);
fprintf(stdout, " got:\n");
print_dd(dlo);
fprintf(stdout, "\n");
}
if (!cmp_dd(dl,dlr)) {
fprintf(stdout, " result error, sent:\n");
print_dd(dl);
fprintf(stdout, " got:\n");
print_dd(dlr);
fprintf(stdout, "\n");
}
free(*dlr);
return -1;
}
static int string2_test(IC_Env *env)
{
char* sa[3] = {"hello", "foo", "bar"};
m_sseq ssi = {3, 3, sa};
m_sseq *sso, *ssr;
fprintf(stdout, "\n======== m_i_string2 test ======\n\n");
ssr = m_i_string2_test(NULL, &ssi, &sso, env);
CHECK_EXCEPTION(env);
RETURN_IF_OK(cmp_sseq(&ssi, sso) && cmp_sseq(&ssi, sso));
if (!cmp_sseq(&ssi, sso)) {
fprintf(stdout, " out parameter error, sent:\n");
print_sseq(&ssi);
fprintf(stdout, "got:\n");
print_sseq(sso);
}
if (!cmp_sseq(&ssi, ssr)) {
fprintf(stdout, " result error, sent:\n");
print_sseq(&ssi);
fprintf(stdout, "got:\n");
print_sseq(ssr);
}
CORBA_free(sso);
CORBA_free(ssr);
return -1;
}
static int void_test(IC_Env *env)
{
fprintf(stdout, "\n======== m_i_void test ======\n\n");
m_i_void_test(NULL,env);
CHECK_EXCEPTION(env);
RETURN_IF_OK(1);
}
static int term_struct_test(IC_Env *env)
{
m_et eti = { erl_format("[{hej, 1, 23}, \"string\", {1.23, 45}]"),
121212 };
m_et eto, etr;
fprintf(stdout, "\n======== m_i_term_struct test ======\n\n");
etr = m_i_term_struct_test(NULL, &eti, &eto, env);
CHECK_EXCEPTION(env);
RETURN_IF_OK(cmp_et(&eti, &eto) && cmp_et(&eti, &etr));
if (!cmp_et(&eti, &eto)) {
fprintf(stdout, " out parameter error, sent:\n");
print_et(&eti);
fprintf(stdout, "got:\n");
print_et(&eto);
}
if (!cmp_et(&eti, &etr)) {
fprintf(stdout, " result error, sent:\n");
print_et(&eti);
fprintf(stdout, "got:\n");
print_et(&etr);
}
free_et(&eti);
free_et(&eto);
free_et(&etr);
return -1;
}
static int term_sequence_test(IC_Env *env)
{
ETERM* et_array[4] = {
erl_format("[{apa, 1, 23}, \"string\", {1.23, 45}]"),
erl_format("[{banan, 1, 23}, \"string\", {1.23, 45}]"),
erl_format("[{apelsin, 1, 23}, \"string\", {1.23, 45}]"),
erl_format("[{mango, 1, 23}, \"string\", {1.23, 45}]")};
m_etseq etsi = {4, 4, et_array}, *etso, *etsr;
fprintf(stdout, "\n======== m_i_term_sequence test ======\n\n");
etsr = m_i_term_sequence_test(NULL, &etsi, &etso, env);
CHECK_EXCEPTION(env);
RETURN_IF_OK(cmp_etseq(&etsi, etso) && cmp_etseq(&etsi, etsr));
if (!cmp_etseq(&etsi, etso)) {
fprintf(stdout, " out parameter error, sent:\n");
print_etseq(&etsi);
fprintf(stdout, "got:\n");
print_etseq(etso);
}
if (!cmp_etseq(&etsi, etsr)) {
fprintf(stdout, " result error, sent:\n");
print_etseq(&etsi);
fprintf(stdout, "got:\n");
print_etseq(etsr);
}
free_etseq_buf(&etsi);
free_etseq_buf(etso);
free_etseq_buf(etsr);
CORBA_free(etso);
CORBA_free(etsr);
return -1;
}
static int inline_sequence_test(IC_Env *env)
{
int i;
long al[500];
m_s isi = {4711, {500, 10, al}},
*iso, *isr;
for (i = 0; i < 500; i++)
al[i]=i;
fprintf(stdout, "\n======== m_i_inline_sequence test ======\n\n");
isr = m_i_inline_sequence_test(NULL, &isi, &iso, env);
CHECK_EXCEPTION(env);
RETURN_IF_OK(cmp_s(&isi, iso) && cmp_s(&isi, isr));
if (!cmp_s(&isi, iso)) {
fprintf(stdout, " out parameter error, sent:\n");
print_s(&isi);
fprintf(stdout, "got:\n");
print_s(iso);
}
if (!cmp_s(&isi, isr)) {
fprintf(stdout, " result error, sent:\n");
print_s(&isi);
fprintf(stdout, "got:\n");
print_s(isr);
}
CORBA_free(iso);
CORBA_free(isr);
return -1;
}
static int seq5_test(IC_Env *env)
{
m_arr3 arr3a[3] = {
{4711, 18931947, 3},
{4711, 18931947, 3},
{4711, 18931947, 3}};
m_sarr3 arr3sa[3] = {{3, 3, arr3a}, {3, 3, arr3a}, {3, 3, arr3a}};
m_ssarr3 arr3ssi = {3, 3, arr3sa};
m_ssarr3 *arr3sso;
m_ssarr3 *arr3ssr;
fprintf(stdout, "\n======== m_i_seq5 test ======\n\n");
arr3ssr = m_i_seq5_test(NULL, &arr3ssi, &arr3sso, env);
CHECK_EXCEPTION(env);
RETURN_IF_OK(cmp_ssarr3(&arr3ssi, arr3sso) &&
cmp_ssarr3(&arr3ssi, arr3ssr));
if (!cmp_ssarr3(&arr3ssi, arr3sso)) {
fprintf(stdout, " out parameter error, sent:\n");
print_ssarr3(&arr3ssi);
fprintf(stdout, " got:\n");
print_ssarr3(arr3sso);
fprintf(stdout, "\n");
}
if (!cmp_ssarr3(&arr3ssi, arr3ssr)) {
fprintf(stdout, " result error, sent:\n");
print_ssarr3(&arr3ssi);
fprintf(stdout, " got:\n");
print_ssarr3(arr3ssr);
fprintf(stdout, "\n");
}
CORBA_free(arr3sso);
CORBA_free(arr3ssr);
return -1;
}
static int seq3_test(IC_Env *env)
{
m_lseq lsi, *lso, *lsr;
long al[500];
int i=0;
for (i = 0; i < 500; i++)
al[i]=i;
lsi._length = 500;
lsi._buffer = al;
fprintf(stdout, "\n======== m_i_seq3 test ======\n\n");
lsr = m_i_seq3_test(NULL, &lsi, &lso, env);
CHECK_EXCEPTION(env);
RETURN_IF_OK(cmp_lseq(&lsi, lso) && cmp_lseq(&lsi, lsr));
if (!cmp_lseq(&lsi, lso)) {
fprintf(stdout, " out parameter error, sent:\n");
print_lseq(&lsi);
fprintf(stdout, " got:\n");
print_lseq(lso);
fprintf(stdout, "\n");
}
if (!cmp_lseq(&lsi, lsr)) {
fprintf(stdout, " result error, sent:\n");
print_lseq(&lsi);
fprintf(stdout, " got:\n");
print_lseq(lsr);
fprintf(stdout, "\n");
}
CORBA_free(lso);
CORBA_free(lsr);
return -1;
}
static int array1_test(IC_Env *env)
{
int i;
long al[500];
m_arr1 alo;
m_arr1_slice* alr;
for (i = 0; i < 500; i++)
al[i]=i;
fprintf(stdout, "\n======== m_i_array1 test ======\n\n");
alr = m_i_array1_test(NULL, al, alo, env);
CHECK_EXCEPTION(env);
RETURN_IF_OK(cmp_arr1(al, alo) && cmp_arr1(al, alr));
if (!cmp_arr1(al, alo)) {
fprintf(stdout, " out parameter error, sent:\n");
print_arr1(al);
fprintf(stdout, " got:\n");
print_arr1(alo);
fprintf(stdout, "\n");
}
if (!cmp_arr1(al,alr)) {
fprintf(stdout, " result error, sent:\n");
print_arr1(al);
fprintf(stdout, " got:\n");
print_arr1(alr);
fprintf(stdout, "\n");
}
free(alo);
free(alr);
return -1;
}
/**
* Convert an image to a blob and the blob to a String.
*
* No Ruby usage (internal function)
*
* Notes:
* - Returns Qnil if there is no image
*
* @param image the Image to convert
* @return Ruby string representation of image
* @see str_to_image
*/
static VALUE
image_to_str(Image *image)
{
VALUE dimg = Qnil;
unsigned char *blob;
size_t length;
Info *info;
ExceptionInfo *exception;
if (image)
{
info = CloneImageInfo(NULL);
exception = AcquireExceptionInfo();
blob = ImageToBlob(info, image, &length, exception);
DestroyImageInfo(info);
CHECK_EXCEPTION();
DestroyExceptionInfo(exception);
dimg = rb_str_new((char *)blob, (long)length);
magick_free((void*)blob);
}
RB_GC_GUARD(dimg);
return dimg;
}
/*
Method: Info#format=
Purpose: Set the image encoding format
*/
VALUE
Info_format_eq(VALUE self, VALUE magick)
{
Info *info;
const MagickInfo *m;
char *mgk;
ExceptionInfo exception;
Data_Get_Struct(self, Info, info);
GetExceptionInfo(&exception);
mgk = StringValuePtr(magick);
m = GetMagickInfo(mgk, &exception);
CHECK_EXCEPTION()
(void) DestroyExceptionInfo(&exception);
if (!m)
{
rb_raise(rb_eArgError, "unknown format: %s", mgk);
}
strncpy(info->magick, m->name, MaxTextExtent-1);
return self;
}
static int seq1_test(IC_Env *env)
{
m_bseq bs, *bso, *bsr;
m_b ba[3] = {{4711, 'a'}, {4712, 'b'}, {4713, 'c'}};
bs._length = 3;
bs._buffer = ba;
fprintf(stdout, "\n======== m_i_seq1 test ======\n\n");
bsr = m_i_seq1_test(NULL, &bs, &bso, env);
CHECK_EXCEPTION(env);
RETURN_IF_OK(cmp_bseq(&bs, bso) && cmp_bseq(&bs, bsr));
if (!cmp_bseq(&bs, bso)) {
fprintf(stdout, " out parameter error, sent:\n");
print_bseq(&bs);
fprintf(stdout, " got:\n");
print_bseq(bso);
fprintf(stdout, "\n");
}
if (!cmp_bseq(&bs, bsr)) {
fprintf(stdout, " result error, sent:\n");
print_bseq(&bs);
fprintf(stdout, " got:\n");
print_bseq(bsr);
fprintf(stdout, "\n");
}
CORBA_free(bso);
CORBA_free(bsr);
return -1;
}
static int term_test(IC_Env *env)
{
ETERM *ti, *to, *tr;
ti = erl_format("[{hej, 1, 23}, \"string\", {1.23, 45}]");
fprintf(stdout, "\n======== m_i_term test ======\n\n");
tr = m_i_term_test(NULL, ti, &to, env);
CHECK_EXCEPTION(env);
RETURN_IF_OK(erl_match(ti, to) && erl_match(ti, tr));
if (!erl_match(ti, to)) {
fprintf(stdout, " out parameter error, sent:\n");
print_term(ti);
fprintf(stdout, "got:\n");
print_term(to);
}
if (!erl_match(ti, tr)) {
fprintf(stdout, " result error, sent:\n");
print_term(ti);
fprintf(stdout, "got:\n");
print_term(tr);
}
erl_free_term(ti);
erl_free_term(to);
erl_free_term(tr);
return -1;
}
static int seq4_test(IC_Env *env)
{
char *stra0[3] = {"a", "long", "time"};
char *stra1[3] = {"ago", "there", "was"};
char *stra2[3] = {"a", "buggy", "compiler"};
m_sstr3 str3s[3] = {{3, 3, stra0}, {3, 3, stra1}, {3, 3, stra2}};
m_ssstr3 str3ssi = {3, 3, str3s};
m_ssstr3 *str3sso, *str3ssr;
fprintf(stdout, "\n======== m_i_seq4 test ======\n\n");
str3ssr = m_i_seq4_test(NULL, &str3ssi, &str3sso, env);
CHECK_EXCEPTION(env);
RETURN_IF_OK(cmp_ssstr3(&str3ssi, str3sso) &&
cmp_ssstr3(&str3ssi, str3ssr));
if (!cmp_ssstr3(&str3ssi, str3sso)){
fprintf(stdout, " out parameter error, sent:\n");
print_ssstr3(&str3ssi);
fprintf(stdout, " got:\n");
print_ssstr3(str3sso);
fprintf(stdout, "\n");
}
if (!cmp_ssstr3(&str3ssi, str3ssr)) {
fprintf(stdout, " result error, sent:\n");
print_ssstr3(&str3ssi);
fprintf(stdout, " got:\n");
print_ssstr3(str3ssr);
fprintf(stdout, "\n");
}
CORBA_free(str3sso);
CORBA_free(str3ssr);
return -1;
}
static int typedef_test(IC_Env *env)
{
m_banan mbi, mbo; /* erlang_port */
m_apa mai; /* ETERM* */
m_apa mao = NULL;
long tl;
strcpy(mbi.node,"node");
mbi.id = 15;
mbi.creation = 1;
fprintf(stdout, "\n======== m_i_typedef test ======\n\n");
mai = erl_format("[{hej, 1, 23}, \"string\", {1.23, 45}]");
tl = m_i_typedef_test(NULL, mai, &mbi, &mao, &mbo, env);
CHECK_EXCEPTION(env);
RETURN_IF_OK(erl_match(mai, mao) && cmp_port(&mbi, &mbo) && tl == 4711);
if (!erl_match(mai, mao)) {
fprintf(stdout, " out parameter error (term), sent:\n");
print_term(mai);
fprintf(stdout, "got:\n");
print_term(mao);
}
if (!cmp_port(&mbi, &mbo)) {
fprintf(stdout, " out parameter error (port), sent:\n");
print_port(&mbi);
fprintf(stdout, "got:\n");
print_port(&mbo);
}
if (tl != 4711) {
fprintf(stdout, " result error, sent: 4711, got %ld\n", tl);
}
erl_free_term(mai);
erl_free_term(mao);
return -1;
}
static int char_test(IC_Env *env)
{
char c = 'g', co, cr;
/* char test */
fprintf(stdout, "\n======== m_i_char test ======\n\n");
cr = m_i_char_test(NULL, c, &co, env);
CHECK_EXCEPTION(env);
RETURN_IF_OK(c == co && c == cr);
if
static size_t
AndroidEncrypt(vlc_keystore *p_keystore, void *p_ctx, const uint8_t *p_src,
size_t i_src_len, uint8_t **pp_dst)
{
(void) p_ctx;
JNIEnv *p_env = GET_ENV();
if (p_env == NULL)
return 0;
jobject jcipher = NULL;
jcipher = CALL_STATICOBJ(Cipher, Cipher.getInstance, fields.VLC_CIPHER);
if (CHECK_EXCEPTION())
return 0;
size_t i_dst_len = 0;
CALL_VOID(jcipher, Cipher.init, fields.Cipher.ENCRYPT_MODE, s_jkey, NULL);
if (CHECK_EXCEPTION())
goto end;
/* Get the IV (Initialization Vector) initialized by Android that will be
* used to decrypt this secret. This IV will be stored with the encrypted
* secret */
jarray jivArray = (jarray) CALL_OBJ(jcipher, Cipher.getIV);
if (jivArray == NULL)
goto end;
jsize i_iv_len = (*p_env)->GetArrayLength(p_env, jivArray);
if (i_iv_len == 0)
goto end;
jbyte *p_iv_bytes = (*p_env)->GetByteArrayElements(p_env, jivArray, 0);
i_dst_len = Process(p_keystore, p_env, jcipher, p_src, i_src_len,
(const uint8_t *)p_iv_bytes, i_iv_len, pp_dst);
(*p_env)->ReleaseByteArrayElements(p_env, jivArray, p_iv_bytes, 0);
DEL_LREF(jivArray);
end:
DEL_LREF(jcipher);
return i_dst_len;
}
/*
Method: ImageList#to_blob
Purpose: returns the imagelist as a blob (a String)
Notes: runs an info parm block if present - the user can
specify the image format and depth
*/
VALUE
ImageList_to_blob(VALUE self)
{
Image *images;
Info *info;
volatile VALUE info_obj;
volatile VALUE blob_str;
void *blob = NULL;
size_t length = 0;
ExceptionInfo exception;
info_obj = rm_info_new();
Data_Get_Struct(info_obj, Info, info);
// Convert the images array to an images sequence.
images = images_from_imagelist(self);
GetExceptionInfo(&exception);
(void) SetImageInfo(info, MagickTrue, &exception);
rm_check_exception(&exception, images, RetainOnError);
if (*info->magick != '\0')
{
Image *img;
for (img = images; img; img = GetNextImageInList(img))
{
strncpy(img->magick, info->magick, sizeof(info->magick)-1);
}
}
// Unconditionally request multi-images support. The worst that
// can happen is that there's only one image or the format
// doesn't support multi-image files.
info->adjoin = MagickTrue;
blob = ImagesToBlob(info, images, &length, &exception);
if (exception.severity != UndefinedException)
{
magick_free((void*)blob);
}
rm_split(images);
CHECK_EXCEPTION()
(void) DestroyExceptionInfo(&exception);
if (length == 0 || !blob)
{
return Qnil;
}
blob_str = rb_str_new(blob, (long)length);
magick_free((void*)blob);
return blob_str;
}
/*
* Init JNI fields, fetch the key stored by Android or generate a new one
*/
static void
AndroidInit(vlc_keystore *p_keystore)
{
JNIEnv *p_env = GET_ENV();
if (p_env == NULL)
return;
if (InitJni(p_keystore, p_env) != VLC_SUCCESS)
return;
jobject jkeystore = NULL, jentry = NULL, jkey = NULL;
jstring jstringAlias = NULL, jstringProvider = NULL;
jstringAlias = NEW_STR("LibVLCAndroid");
if (CHECK_EXCEPTION())
goto end;
jstringProvider = NEW_STR("AndroidKeyStore");
if (CHECK_EXCEPTION())
goto end;
jkeystore = CALL_STATICOBJ(KeyStore, KeyStore.getInstance, jstringProvider);
if (CHECK_EXCEPTION())
goto end;
CALL_VOID(jkeystore, KeyStore.load, NULL);
if (CHECK_EXCEPTION())
goto end;
jentry = CALL_OBJ(jkeystore, KeyStore.getEntry, jstringAlias, NULL);
if (CHECK_EXCEPTION())
goto end;
if (jentry != NULL)
{
jkey = CALL_OBJ(jentry, KeyStore.SecretKeyEntry.getSecretKey);
if (CHECK_EXCEPTION())
goto end;
}
else
{
jkey = GenerateKey(p_keystore, p_env, jstringAlias, jstringProvider);
if (jkey == NULL)
goto end;
}
s_jkey = NEW_GREF(jkey);
end:
if (jstringAlias != NULL)
DEL_LREF(jstringAlias);
if (jstringProvider != NULL)
DEL_LREF(jstringProvider);
if (jkeystore != NULL)
DEL_LREF(jkeystore);
if (jentry != NULL)
DEL_LREF(jentry);
if (jkey != NULL)
DEL_LREF(jkey);
}
static int double_test(IC_Env *env)
{
double d = 12.1212, db, dr;
fprintf(stdout, "\n======== m_i_double test ======\n\n");
dr = m_i_double_test(NULL, d, &db, env);
CHECK_EXCEPTION(env);
RETURN_IF_OK(d == db && d == dr);
if (d != db)
fprintf(stdout, " out parameter error, sent: %f, got: %f\n", d, db);
if (d != dr)
fprintf(stdout, " result error, sent: %f, got: %f\n", d, dr);
return -1;
}
/*
Extern: rm_pixelpacket_to_color_name
Purpose: Map the color intensity to a named color
Returns: the named color as a String
Notes: See below for the equivalent function that accepts an Info
structure instead of an Image.
*/
VALUE
rm_pixelpacket_to_color_name(Image *image, PixelPacket *color)
{
char name[MaxTextExtent];
ExceptionInfo exception;
GetExceptionInfo(&exception);
(void) QueryColorname(image, color, X11Compliance, name, &exception);
CHECK_EXCEPTION()
(void) DestroyExceptionInfo(&exception);
return rb_str_new2(name);
}
static int enum_test(IC_Env *env)
{
m_fruit ei = m_banana, eo, er;
fprintf(stdout, "\n======== m_i_enum test ======\n\n");
er = m_i_enum_test(NULL, ei, &eo, env);
CHECK_EXCEPTION(env);
RETURN_IF_OK(ei == eo && ei == er);
if (ei != eo)
fprintf(stdout, " out parameter error, sent: %d, got: %d\n", ei, eo);
if (ei != er)
fprintf(stdout, " result error, sent: %d, got: %d\n", ei, er);
return -1;
}
static int octet_test(IC_Env *env)
{
char o ='r', oo, or;
fprintf(stdout, "\n======== m_i_octet test ======\n\n");
or = m_i_octet_test(NULL, o, &oo, env);
CHECK_EXCEPTION(env);
RETURN_IF_OK(o == oo && o == or);
if (o != oo)
fprintf(stdout, " out parameter error, sent: %c, got: %c\n", o, oo);
if (o != or)
fprintf(stdout, " result error, sent: %c, got: %c\n", o, or);
return -1;
}
static int bool_test(IC_Env *env)
{
unsigned char i = 0, io, ir;
fprintf(stdout, "\n======== m_i_bool test ======\n\n");
ir = m_i_bool_test(NULL, i, &io, env);
CHECK_EXCEPTION(env);
RETURN_IF_OK(i == io && i == ir);
if (i != io)
fprintf(stdout, " out parameter error, sent: %d, got: %d\n", i, io);
if (i != ir)
fprintf(stdout, " result error, sent: %d, got: %d\n", i, ir);
return -1;
}
