void free_export_file(export_file* ef) {
freeConstantPool(ef->constant_pool, ef->constant_pool_count);
free(ef->constant_pool);
freeClasses(ef->classes, ef->export_class_count);
free(ef->classes);
}
JNIEXPORT void JNICALL NAME(nativeRelease)(JNIEnv *env, jobject thiz)
{
vlc_mutex_t *parse_lock = (vlc_mutex_t *) getIntValue(env, thiz, "mNativeMediaParseLock");
vlc_cond_t *parse_cond = (vlc_cond_t *) getIntValue(env, thiz, "mNativeMediaParseCond");
/* wake up threads that waiting on prepare */
vlc_mutex_lock(parse_lock);
setIntValue(env, thiz, "mNativeMediaParsed", 4);
vlc_cond_broadcast(parse_cond);
vlc_mutex_unlock(parse_lock);
jint mLibVlcMediaPlayer = getIntValue(env, thiz, "mLibVlcMediaPlayer");
if (mLibVlcMediaPlayer != 0)
{
libvlc_event_manager_t *em;
libvlc_media_player_t *mp = (libvlc_media_player_t*) mLibVlcMediaPlayer;
libvlc_media_t *md = libvlc_media_player_get_media(mp);
if (md) {
em = libvlc_media_event_manager(md);
for (int i = 0; i < sizeof(md_listening) / sizeof(*md_listening); i++)
{
libvlc_event_detach(em, md_listening[i], vlc_event_callback, thiz);
}
}
em = libvlc_media_player_event_manager(mp);
for (int i = 0; i < sizeof(mp_listening) / sizeof(*mp_listening); i++)
{
libvlc_event_detach(em, mp_listening[i], vlc_event_callback, thiz);
}
libvlc_media_player_stop(mp);
libvlc_media_player_release(mp);
setIntValue(env, thiz, "mLibVlcMediaPlayer", 0);
}
jint mLibVlcInstance = getIntValue(env, thiz, "mLibVlcInstance");
if (mLibVlcInstance != 0)
{
libvlc_instance_t *instance = (libvlc_instance_t*) mLibVlcInstance;
libvlc_release(instance);
setIntValue(env, thiz, "mLibVlcInstance", 0);
}
setIntValue(env, thiz, "mNativeMediaBufferingCount", 0);
vlc_mutex_destroy(parse_lock);
free(parse_lock);
setIntValue(env, thiz, "mNativeMediaParseLock", 0);
vlc_cond_destroy(parse_cond);
free(parse_cond);
setIntValue(env, thiz, "mNativeMediaParseCond", 0);
freeClasses(env, thiz);
}
calorimeterLSF::~calorimeterLSF ()
{
freeClasses ();
return;
}
export_file* read_export_file(const char* filename) {
char* data = NULL;
export_file* ef = NULL;
unsigned int length = 0;
unsigned int position = 0;
u2 indexCP = 0;
u1 indexClass = 0;
printf("Starting to read the export file: %s\n", filename);
data = readFile(filename, &length);
if(data == NULL)
return NULL;
if(length == 0) {
fprintf(stderr, "No data to parse\n");
free(data);
return NULL;
}
ef = (export_file*)malloc(sizeof(export_file));
if(ef == NULL)
return NULL;
if((position + 8) > length) {
fprintf(stderr, "Not enough data to parse - %d\n", __LINE__);
free(ef);
free(data);
return NULL;
}
ef->magic = bigEndianToLittleEndianU32(data);
position += 4;
ef->minor_version = data[position++];
ef->major_version = data[position++];
ef->constant_pool_count = bigEndianToLittleEndianU16(data + position);
position += 2;
if(ef->constant_pool_count < 1) {
fprintf(stderr, "The constant pool is empty. There should be at least one element.\n");
free(ef);
free(data);
return NULL;
}
/*printf("Constant pool count: %u\n", ef->constant_pool_count);*/
ef->constant_pool = (ef_cp_info*)malloc(sizeof(ef_cp_info) * ef->constant_pool_count);
if(ef->constant_pool == NULL) {
perror("parseExportFile");
free(ef);
free(data);
return NULL;
}
for(; indexCP < ef->constant_pool_count; ++indexCP) {
if((position + 1) > length) {
fprintf(stderr, "Not enough data to parse - %d\n", __LINE__);
freeConstantPool(ef->constant_pool, indexCP);
free(ef->constant_pool);
free(ef);
free(data);
return NULL;
}
ef->constant_pool[indexCP].tag = data[position++];
switch(ef->constant_pool[indexCP].tag) {
case EF_CONSTANT_PACKAGE:
if((position + 6) > length) {
fprintf(stderr, "Not enough data to parse - %d\n", __LINE__);
freeConstantPool(ef->constant_pool, indexCP);
free(ef->constant_pool);
free(ef);
free(data);
return NULL;
}
ef->constant_pool[indexCP].CONSTANT_Package.flags = data[position++];
ef->constant_pool[indexCP].CONSTANT_Package.name_index = bigEndianToLittleEndianU16(data + position);
position += 2;
ef->constant_pool[indexCP].CONSTANT_Package.minor_version = data[position++];
ef->constant_pool[indexCP].CONSTANT_Package.major_version = data[position++];
ef->constant_pool[indexCP].CONSTANT_Package.aid_length = data[position++];
if((position + ef->constant_pool[indexCP].CONSTANT_Package.aid_length) > length) {
fprintf(stderr, "Not enough data to parse - %d\n", __LINE__);
freeConstantPool(ef->constant_pool, indexCP);
free(ef->constant_pool);
free(ef);
free(data);
return NULL;
}
ef->constant_pool[indexCP].CONSTANT_Package.aid = (u1*)malloc(sizeof(u1) * ef->constant_pool[indexCP].CONSTANT_Package.aid_length);
if(ef->constant_pool[indexCP].CONSTANT_Package.aid == NULL) {
perror("parseExportFile");
freeConstantPool(ef->constant_pool, indexCP);
free(ef->constant_pool);
free(ef);
free(data);
return NULL;
}
memcpy(ef->constant_pool[indexCP].CONSTANT_Package.aid, data + position, sizeof(u1) * ef->constant_pool[indexCP].CONSTANT_Package.aid_length);
position += ef->constant_pool[indexCP].CONSTANT_Package.aid_length;
break;
case EF_CONSTANT_CLASSREF:
if((position + 2) > length) {
fprintf(stderr, "Not enough data to parse - %d\n", __LINE__);
freeConstantPool(ef->constant_pool, indexCP);
free(ef->constant_pool);
free(ef);
free(data);
return NULL;
}
ef->constant_pool[indexCP].CONSTANT_Classref.name_index = bigEndianToLittleEndianU16(data + position);
position += 2;
break;
case EF_CONSTANT_INTEGER:
if((position + 4) > length) {
fprintf(stderr, "Not enough data to parse - %d\n", __LINE__);
freeConstantPool(ef->constant_pool, indexCP);
free(ef->constant_pool);
free(ef);
free(data);
return NULL;
}
ef->constant_pool[indexCP].CONSTANT_Integer.bytes = bigEndianToLittleEndianU32(data + position);
position += 4;
break;
case EF_CONSTANT_UTF8:
if((position + 2) > length) {
fprintf(stderr, "Not enough data to parse - %d\n", __LINE__);
freeConstantPool(ef->constant_pool, indexCP);
free(ef->constant_pool);
free(ef);
free(data);
return NULL;
}
ef->constant_pool[indexCP].CONSTANT_Utf8.length = bigEndianToLittleEndianU16(data + position);
position += 2;
if((position + ef->constant_pool[indexCP].CONSTANT_Utf8.length) > length) {
fprintf(stderr, "Not enough data to parse - %d\n", __LINE__);
freeConstantPool(ef->constant_pool, indexCP);
free(ef->constant_pool);
free(ef);
free(data);
return NULL;
}
ef->constant_pool[indexCP].CONSTANT_Utf8.bytes = (u1*)malloc(sizeof(u1) * ef->constant_pool[indexCP].CONSTANT_Utf8.length);
if(ef->constant_pool[indexCP].CONSTANT_Utf8.bytes == NULL) {
perror("parseExportFile");
freeConstantPool(ef->constant_pool, indexCP);
free(ef->constant_pool);
free(ef);
free(data);
return NULL;
}
memcpy(ef->constant_pool[indexCP].CONSTANT_Utf8.bytes, data + position, sizeof(u1) * ef->constant_pool[indexCP].CONSTANT_Utf8.length);
position += ef->constant_pool[indexCP].CONSTANT_Utf8.length;
/*printf("\tIndex %u: %.*s\n", indexCP, ef->constant_pool[indexCP].CONSTANT_Utf8.length, ef->constant_pool[indexCP].CONSTANT_Utf8.bytes);*/
break;
default:
fprintf(stderr, "The tag %u is not supported.\n", ef->constant_pool[indexCP].tag);
freeConstantPool(ef->constant_pool, indexCP);
free(ef->constant_pool);
free(ef);
free(data);
return NULL;
}
}
if((position + 3) > length) {
fprintf(stderr, "Not enough data to parse - %d\n", __LINE__);
freeConstantPool(ef->constant_pool, ef->constant_pool_count);
free(ef->constant_pool);
free(ef);
free(data);
return NULL;
}
ef->this_package = bigEndianToLittleEndianU16(data + position);
position += 2;
ef->export_class_count = data[position++];
/*printf("class count: %u\n", ef->export_class_count);*/
if(ef->export_class_count == 0) {
ef->classes = NULL;
return ef;
}
ef->classes = (ef_class_info*)malloc(sizeof(ef_class_info) * ef->export_class_count);
if(ef->classes == NULL) {
perror("parseExportFile");
freeConstantPool(ef->constant_pool, ef->constant_pool_count);
free(ef->constant_pool);
free(ef);
free(data);
return NULL;
}
for(; indexClass < ef->export_class_count; ++indexClass) {
u2 index = 0;
if((position + 7) > length) {
fprintf(stderr, "Not enough data to parse - %d\n", __LINE__);
freeConstantPool(ef->constant_pool, ef->constant_pool_count);
free(ef->constant_pool);
freeClasses(ef->classes, indexClass);
free(ef->classes);
free(ef);
free(data);
return NULL;
}
ef->classes[indexClass].token = data[position++];
ef->classes[indexClass].access_flags = bigEndianToLittleEndianU16(data + position);
position += 2;
ef->classes[indexClass].name_index = bigEndianToLittleEndianU16(data + position);
position += 2;
ef->classes[indexClass].export_supers_count = bigEndianToLittleEndianU16(data + position);
position += 2;
/*printf("Class %u\n\tSupers count:%u\n", indexClass, ef->classes[indexClass].export_supers_count);*/
if(ef->classes[indexClass].export_supers_count > 0) {
if((position + (2 * ef->classes[indexClass].export_supers_count) + 1) > length) {
fprintf(stderr, "Not enough data to parse - %d\n", __LINE__);
freeConstantPool(ef->constant_pool, ef->constant_pool_count);
free(ef->constant_pool);
freeClasses(ef->classes, indexClass);
free(ef->classes);
free(ef);
free(data);
return NULL;
}
ef->classes[indexClass].supers = (u2*)malloc(sizeof(u2) * ef->classes[indexClass].export_supers_count);
if(ef->classes[indexClass].supers == NULL) {
perror("parseExportFile");
freeConstantPool(ef->constant_pool, ef->constant_pool_count);
free(ef->constant_pool);
freeClasses(ef->classes, indexClass);
free(ef->classes);
free(ef);
free(data);
return NULL;
}
for(; index < ef->classes[indexClass].export_supers_count; ++index) {
ef->classes[indexClass].supers[index] = bigEndianToLittleEndianU16(data + position);
position += 2;
}
} else {
if((position + 1) > length) {
fprintf(stderr, "Not enough data to parse - %d\n", __LINE__);
freeConstantPool(ef->constant_pool, ef->constant_pool_count);
free(ef->constant_pool);
freeClasses(ef->classes, indexClass);
free(ef->classes);
free(ef);
free(data);
return NULL;
}
ef->classes[indexClass].supers = NULL;
}
ef->classes[indexClass].export_interfaces_count = data[position++];
/*printf("\tInterfaces count: %u\n", ef->classes[indexClass].export_interfaces_count);*/
if(ef->classes[indexClass].export_interfaces_count > 0) {
if((position + (2 * ef->classes[indexClass].export_interfaces_count) + 2) > length) {
fprintf(stderr, "Not enough data to parse - %d\n", __LINE__);
freeConstantPool(ef->constant_pool, ef->constant_pool_count);
free(ef->constant_pool);
free(ef->classes[indexClass].supers);
freeClasses(ef->classes, indexClass);
free(ef->classes);
free(ef);
free(data);
return NULL;
}
ef->classes[indexClass].interfaces = (u2*)malloc(sizeof(u2) * ef->classes[indexClass].export_interfaces_count);
if(ef->classes[indexClass].interfaces == NULL) {
perror("parseExportFile");
freeConstantPool(ef->constant_pool, ef->constant_pool_count);
free(ef->constant_pool);
free(ef->classes[indexClass].supers);
freeClasses(ef->classes, indexClass);
free(ef->classes);
free(ef);
free(data);
return NULL;
}
for(index = 0; index < ef->classes[indexClass].export_interfaces_count; ++index) {
ef->classes[indexClass].interfaces[index] = bigEndianToLittleEndianU16(data + position);
position += 2;
}
} else {
ef->classes[indexClass].interfaces = NULL;
}
ef->classes[indexClass].export_fields_count = bigEndianToLittleEndianU16(data + position);
position += 2;
/*printf("\tFields count: %u\n", ef->classes[indexClass].export_fields_count);*/
if(ef->classes[indexClass].export_fields_count > 0) {
ef->classes[indexClass].fields = (ef_field_info*)malloc(sizeof(ef_field_info) * ef->classes[indexClass].export_fields_count);
if(ef->classes[indexClass].fields == NULL) {
perror("parseExportFile");
freeConstantPool(ef->constant_pool, ef->constant_pool_count);
free(ef->constant_pool);
free(ef->classes[indexClass].supers);
free(ef->classes[indexClass].interfaces);
freeClasses(ef->classes, indexClass);
free(ef->classes);
free(ef);
free(data);
return NULL;
}
for(index = 0; index < ef->classes[indexClass].export_fields_count; ++index) {
u2 indexAttribute = 0;
if((position + 9) > length) {
fprintf(stderr, "Not enough data to parse - %d\n", __LINE__);
freeConstantPool(ef->constant_pool, ef->constant_pool_count);
free(ef->constant_pool);
free(ef->classes[indexClass].supers);
free(ef->classes[indexClass].interfaces);
freeFields(ef->classes[indexClass].fields, index);
free(ef->classes[indexClass].fields);
freeClasses(ef->classes, indexClass);
free(ef->classes);
free(ef);
free(data);
return NULL;
}
ef->classes[indexClass].fields[index].token = data[position++];
ef->classes[indexClass].fields[index].access_flags = bigEndianToLittleEndianU16(data + position);
position += 2;
ef->classes[indexClass].fields[index].name_index = bigEndianToLittleEndianU16(data + position);
position += 2;
ef->classes[indexClass].fields[index].descriptor_index = bigEndianToLittleEndianU16(data + position);
position += 2;
ef->classes[indexClass].fields[index].attributes_count = bigEndianToLittleEndianU16(data + position);
position += 2;
/*printf("\tField %u\n\t\tAttributes count: %u\n", index, ef->classes[indexClass].fields[index].attributes_count);*/
if(ef->classes[indexClass].fields[index].attributes_count > 0) {
if((position + (8 * ef->classes[indexClass].fields[index].attributes_count) + 2) > length) {
fprintf(stderr, "Not enough data to parse - %d\n", __LINE__);
freeConstantPool(ef->constant_pool, ef->constant_pool_count);
free(ef->constant_pool);
free(ef->classes[indexClass].supers);
free(ef->classes[indexClass].interfaces);
freeFields(ef->classes[indexClass].fields, index);
free(ef->classes[indexClass].fields);
freeClasses(ef->classes, indexClass);
free(ef->classes);
free(ef);
free(data);
return NULL;
}
ef->classes[indexClass].fields[index].attributes = (ef_attribute_info*)malloc(sizeof(ef_attribute_info) * ef->classes[indexClass].fields[index].attributes_count);
if(ef->classes[indexClass].fields[index].attributes == NULL) {
perror("parseExportFile");
freeConstantPool(ef->constant_pool, ef->constant_pool_count);
free(ef->constant_pool);
free(ef->classes[indexClass].supers);
free(ef->classes[indexClass].interfaces);
freeFields(ef->classes[indexClass].fields, index);
free(ef->classes[indexClass].fields);
freeClasses(ef->classes, indexClass);
free(ef->classes);
free(ef);
free(data);
return NULL;
}
for(; indexAttribute < ef->classes[indexClass].fields[index].attributes_count; ++indexAttribute) {
ef->classes[indexClass].fields[index].attributes[indexAttribute].attribute_name_index = bigEndianToLittleEndianU16(data + position);
position += 2;
ef->classes[indexClass].fields[index].attributes[indexAttribute].attribute_length = bigEndianToLittleEndianU32(data + position);
position += 4;
ef->classes[indexClass].fields[index].attributes[indexAttribute].constantvalue_index = bigEndianToLittleEndianU16(data + position);
position += 2;
}
} else {
ef->classes[indexClass].fields[index].attributes = NULL;
}
}
} else {
ef->classes[indexClass].fields = NULL;
}
ef->classes[indexClass].export_methods_count = bigEndianToLittleEndianU16(data + position);
position += 2;
/*printf("\tMethods count: %u\n",ef->classes[indexClass].export_methods_count);*/
if(ef->classes[indexClass].export_methods_count > 0) {
if((position + (7 * ef->classes[indexClass].export_methods_count)) > length) {
fprintf(stderr, "Not enough data to parse - %d\n", __LINE__);
freeConstantPool(ef->constant_pool, ef->constant_pool_count);
free(ef->constant_pool);
free(ef->classes[indexClass].supers);
free(ef->classes[indexClass].interfaces);
freeFields(ef->classes[indexClass].fields, ef->classes[indexClass].export_fields_count);
free(ef->classes[indexClass].fields);
freeClasses(ef->classes, indexClass);
free(ef->classes);
free(ef);
free(data);
return NULL;
}
ef->classes[indexClass].methods = (ef_method_info*)malloc(sizeof(ef_method_info) * ef->classes[indexClass].export_methods_count);
if(ef->classes[indexClass].methods == NULL) {
perror("parseExportFile");
freeConstantPool(ef->constant_pool, ef->constant_pool_count);
free(ef->constant_pool);
free(ef->classes[indexClass].supers);
free(ef->classes[indexClass].interfaces);
freeFields(ef->classes[indexClass].fields, ef->classes[indexClass].export_fields_count);
free(ef->classes[indexClass].fields);
freeClasses(ef->classes, indexClass);
free(ef->classes);
free(ef);
free(data);
return NULL;
}
for(index = 0; index < ef->classes[indexClass].export_methods_count; ++index) {
ef->classes[indexClass].methods[index].token = data[position++];
ef->classes[indexClass].methods[index].access_flags = bigEndianToLittleEndianU16(data + position);
position += 2;
ef->classes[indexClass].methods[index].name_index = bigEndianToLittleEndianU16(data + position);
position += 2;
ef->classes[indexClass].methods[index].descriptor_index = bigEndianToLittleEndianU16(data + position);
position += 2;
}
} else {
ef->classes[indexClass].methods = NULL;
}
}
return ef;
}
