Skip to content

V
vlc
Commit 32932c15 authored by Filippo Carone's avatar Filippo Carone
Browse files
Options

removing old and unsupported java-gcj bindings

parent 9a8650a1
Show whitespace changes
Inline Side-by-side
Showing with 0 additions and 570 deletions
bindings/java-gcj/AUTHORS deleted 100644 → 0
View file @ 9a8650a1
Filippo Carone <filippo[dontspam]@carone.org>
bindings/java-gcj/JVLC.java deleted 100644 → 0
View file @ 9a8650a1
/*****************************************************************************
* JVLC.java: global class for vlc Java Bindings
*****************************************************************************
* Copyright (C) 1998-2004 the VideoLAN team
*
* Authors: Filippo Carone <filippo@carone.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
*****************************************************************************/
public class JVLC {
private int id;
public JVLC(String[] args) {
String[] properArgs = new String[args.length + 1];
properArgs[0] = "jvlc";
for (int i = 0; i < args.length; i++)
properArgs[i+1] = args[i];
this.id = create();
init(properArgs);
}
private native int create();
private native int init(String[] args);
public native int addInterface(String moduleName, boolean blocking, boolean startPlay);
public int addInterface(boolean blocking, boolean startPlay) {
return addInterface(null, blocking, startPlay);
}
public native String getVersion();
public native String getError(int errorCode);
public native int die();
public native int cleanUp();
public native int setVariable(JVLCVariable jvlcVariable);
public native JVLCVariable getVariable(String varName); // XXX in progress
public native int addTarget(String URI, String[] options, int insertMode, int position);
public native int play();
public native int pause();
public native int stop();
public native boolean isPlaying();
public native float getPosition();
public native float setPosition(float position);
public native int getTime();
public native int setTime(int seconds, boolean relative);
public native int getLength();
public native float speedFaster();
public native float speedSlower();
public native int getPlaylistIndex();
public native int getPlaylistItems();
public native int playlistNext();
public native int playlistPrev();
public native int playlistClear();
public native int getVolume();
public native int setVolume(int volume);
public native int muteVolume();
public native int fullScreen();
}
bindings/java-gcj/JVLCBoolVariable.java deleted 100644 → 0
View file @ 9a8650a1
public class JVLCBoolVariable extends JVLCVariable {
public JVLCBoolVariable(String name, int value) {
super(name);
if (value != 0) this.value = new Integer(1);
else this.value = new Integer(0);
}
public int getBoolValue() {
return ((Integer)value).intValue();
}
}
bindings/java-gcj/JVLCFloatVariable.java deleted 100644 → 0
View file @ 9a8650a1
public class JVLCFloatVariable extends JVLCVariable {
public JVLCFloatVariable(String name, float value) {
super(name);
this.value = new Float(value);
}
public float getFloatValue() {
return ((Float)value).floatValue();
}
}
bindings/java-gcj/JVLCIntVariable.java deleted 100644 → 0
View file @ 9a8650a1
public class JVLCIntVariable extends JVLCVariable {
public JVLCIntVariable(String name, int value) {
super(name);
this.value = new Integer(value);
}
public int getIntValue() {
return ((Integer)value).intValue();
}
}
bindings/java-gcj/JVLCStringVariable.java deleted 100644 → 0
View file @ 9a8650a1
public class JVLCStringVariable extends JVLCVariable {
public JVLCStringVariable(String name, String value) {
super(name);
this.value = value;
}
public String getStringValue() {
return (String)value;
}
}
bindings/java-gcj/JVLCTimeVariable.java deleted 100644 → 0
View file @ 9a8650a1
public class JVLCTimeVariable extends JVLCVariable {
public JVLCTimeVariable(String name, long value) {
super(name);
this.value = new Long(value);
}
public long getTimeValue() {
return ((Long)value).longValue();
}
}
bindings/java-gcj/JVLCVarValue.java deleted 100644 → 0
View file @ 9a8650a1
public class JVLCVarValue {
String name;
int OID;
public JVLCVarValue(String name, int OID) {
this.name = name;
this.OID = OID;
}
public String getName() {
return name;
}
public int getOID() {
return OID;
}
}
bindings/java-gcj/JVLCVarVariable.java deleted 100644 → 0
View file @ 9a8650a1
public class JVLCVarVariable extends JVLCVariable {
public JVLCVarVariable(String name, JVLCVarValue value) {
super(name);
this.value = value;
}
public JVLCVarValue getVarValue() {
return (JVLCVarValue)value;
}
}
bindings/java-gcj/JVLCVariable.java deleted 100644 → 0
View file @ 9a8650a1
public abstract class JVLCVariable {
String name;
Object value;
public JVLCVariable(String name) {
this.name = name;
}
public String getName() {
return name;
}
public Object getValue() {
return value;
}
public void setValue(Object value) {
this.value = value;
}
}
bindings/java-gcj/Makefile deleted 100644 → 0
View file @ 9a8650a1
OBJECTS = VlcClient.o JVLC.o JVLCVariable.o JVLCVarValue.o JVLCVarVariable.o JVLCIntVariable.o JVLCTimeVariable.o JVLCStringVariable.o JVLCFloatVariable.o JVLCBoolVariable.o vlc-glue.o
FLAGS = -I. -I/usr/local/include/vlc -L../../lib -lvlc `top_builddir=../.. ../../vlc-config --libs vlc builtin extern` `top_builddir=../.. ../../vlc-config --cxxflags` --main=VlcClient
JHEADERS = JVLC.h JVLCVariable.h JVLCIntVariable.h JVLCBoolVariable.h JVLCTimeVariable.h JVLCStringVariable.h JVLCFloatVariable.h JVLCVarVariable.h JVLCVarValue.h
JCC=gcj
CXX=g++
JCH=gcjh
DEBUG=-g
VlcClient: $(OBJECTS)
$(JCC) -o jvlc -I. $(OBJECTS) $(DEBUG) $(FLAGS)
VlcClient.class: VlcClient.java
$(JCC) $(DEBUG) -C VlcClient.java
%.o: %.class
$(JCC) $(DEBUG) -c $?
%.class: %.java
$(JCC) $(DEBUG) -C $?
%.h: %.class
$(JCH) $(*F)
vlc-glue.o: $(JHEADERS) vlc-glue.cc
$(CXX) $(DEBUG) -I./ -c vlc-glue.cc
clean:
rm -f jvlc *.o *.class $(JHEADERS) *~
bindings/java-gcj/README deleted 100644 → 0
View file @ 9a8650a1
Implementation Notes
--------------------
The union vlc_value_t has been implemented as a hierarchy of classes
which has JVLCVariable.class as the root. All the children of this
class are named JVLC<type>Variable.class and are mapped 1:1 to the
union members with some exceptions: p_address is not implemented since
there's no notion of address in Java, vlc_object_t is not implemented
since I don't know how to represent it in Java and is not defined in
vlc/vlc.h
\ No newline at end of file
bindings/java-gcj/VlcClient.java deleted 100644 → 0
View file @ 9a8650a1
public class VlcClient {
public static void main(String[] args) {
JVLC vlc = new JVLC(args);
System.out.println(vlc.getVersion());
vlc.addInterface(true, true);
vlc.die();
vlc.cleanUp();
}
}
bindings/java-gcj/vlc-glue.cc deleted 100644 → 0
View file @ 9a8650a1
/* These are a must*/
#include <gcj/cni.h>
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#include <vlc/vlc.h>
#include <stdio.h> // for printf
#include <stdlib.h> // for calloc
/* JVLC internal imports, generated by gcjh */
#include "JVLC.h"
#include "JVLCVariable.h"
#include "JVLCIntVariable.h"
#include "JVLCBoolVariable.h"
#include "JVLCFloatVariable.h"
#include "JVLCStringVariable.h"
#include "JVLCTimeVariable.h"
#include "JVLCVarVariable.h"
#include "JVLCVarValue.h"
/* Java classes used throughout here */
#include <java/lang/String.h>
#include <java/lang/Class.h>
#include <java/lang/System.h>
#include <java/io/PrintStream.h>
void setString(jstring orig, char* dest);
jint JVLC::create () {
return VLC_Create();
}
jint JVLC::init(JArray< ::java::lang::String *> *args) {
int argc = 0;
char* arguments[argc];
if (args != NULL) // It's a very bad day otherwise
{
argc = args->length;
arguments[argc];
/*
* convert the JArray<String*>* in char**
* so in a way suitable for VLC_Init
*/
jstring* argsElements = elements(args);
for (int i = 0; i < argc; i++) {
arguments[i] = (char*) malloc(JvGetStringUTFLength(argsElements[i]) + 1);
setString(argsElements[i], arguments[i]);
}
}
return VLC_Init(this->id, argc, arguments);
}
jint JVLC::addInterface(java::lang::String* moduleName, jboolean blocking, jboolean startPlay) {
char* psz_module = NULL;
if (moduleName != NULL) {
psz_module = (char *) malloc(JvGetStringUTFLength(moduleName));
setString(moduleName, psz_module);
}
int i_blocking = 0;
int i_startPlay = 0;
if (blocking) i_blocking = 1;
if (startPlay) i_startPlay = 1;
int addIntf_res = VLC_AddIntf(this->id, (char* const) psz_module, i_blocking, i_startPlay);
if (psz_module != NULL)
free(psz_module);
return addIntf_res;
}
jstring JVLC::getVersion() {
return JvNewStringUTF(VLC_Version());
}
jstring JVLC::getError(jint errorCode) {
return JvNewStringUTF(VLC_Error(errorCode));
}
jint JVLC::die() {
return VLC_Die(this->id);
}
jint JVLC::cleanUp() {
return VLC_CleanUp(this->id);
}
jint JVLC::setVariable(::JVLCVariable *jvlcVariable) {
/* these are the two parameters given the the
* VLC_VariableSet() function
*/
vlc_value_t value;
char* psz_var = NULL;
if (jvlcVariable != NULL) {
jclass variableClass = jvlcVariable->getClass();
/* We use the class name for kinda of instanceof */
jstring className = variableClass->getName();
/**
* VLC_SetVariable takes a union as its second argument.
* The union members are mapped 1:1 to java types which
* extend JVLCVariable. So here we check the runtime type
* of the actual variable and act consequently. Here is the
* mapping:
*
* typedef union
*{
* int i_int; JVLCIntVariable
* vlc_bool_t b_bool; JVLCBoolVariable
* float f_float; JVLCFloatVariable
* char * psz_string; JVLCStringVariable
* void * p_address; -- NOT IMPLEMENTED --
* vlc_object_t * p_object; -- NOT IMPLEMENTED --
* vlc_list_t * p_list; JVLCListVariable XXX:TODO
* signed long long i_time; JVLCTimeVariable
* struct { char *psz_name; int i_object_id; } var; JVLCVarVariable <- this name sucks
* // Make sure the structure is at least 64bits
* struct { char a, b, c, d, e, f, g, h; } padding; <- Do we really need this?
*
* } vlc_value_t;
*/
/* i_int */
if (className->equals(JvNewStringUTF("VLCIntVariable" ))) {
value.i_int = ((::JVLCIntVariable *)jvlcVariable)->getIntValue();
}
/* b_bool */
else if (className->equals(JvNewStringUTF("VLCBoolVariable"))) {
value.b_bool = ((::JVLCBoolVariable *)jvlcVariable)->getBoolValue();
}
/* f_float */
else if (className->equals(JvNewStringUTF("VLCFloatVariable"))) {
value.f_float = ((::JVLCFloatVariable *)jvlcVariable)->getFloatValue();
}
/* psz_string */
else if (className->equals(JvNewStringUTF("VLCStringVariable"))) {
value.psz_string = (char* const) elements((((::JVLCStringVariable *)jvlcVariable)->getStringValue())->toCharArray());
}
/* i_time */
else if (className->equals(JvNewStringUTF("VLCTimeVariable"))) {
value.i_time = ((::JVLCTimeVariable *)jvlcVariable)->getTimeValue();
}
/* var */
else if (className->equals(JvNewStringUTF("VLCVarVariable"))) {
jstring varValueName = ((::JVLCVarVariable *)jvlcVariable)->getVarValue()->getName();
value.var.psz_name = (char *) malloc(JvGetStringUTFLength(varValueName));
setString(varValueName, value.var.psz_name);
value.var.i_object_id = (((::JVLCVarVariable *)jvlcVariable)->getVarValue())->getOID();
}
psz_var = (char *) malloc(JvGetStringUTFLength(jvlcVariable->getName()));
setString(jvlcVariable->getName(), psz_var);
}
return VLC_VariableSet(this->id, (char* const) psz_var, value);
}
jint JVLC::addTarget(::java::lang::String *URI, JArray< ::java::lang::String *> *options, jint insertMode, jint position) {
char* psz_target = NULL;
char** ppsz_options = NULL;
int options_number = 0;
if (URI != NULL) {
psz_target = (char *) malloc( JvGetStringUTFLength(URI));
setString(URI, psz_target);
}
if (options != NULL) {
options_number = options->length;
ppsz_options[options_number];
jstring* jstr_options = elements(options);
for (jint i = 0; i < options_number; i++) {
ppsz_options[i] = (char *) malloc(JvGetStringUTFLength(jstr_options[i]));
setString(jstr_options[i], ppsz_options[i]);
}
}
return VLC_AddTarget(this->id, (char const *)psz_target, (const char **) ppsz_options, options_number, insertMode, position);
}
jint JVLC::play() {
return VLC_Play(this->id);
}
jint JVLC::pause() {
return VLC_Pause(this->id);
}
jint JVLC::stop() {
return VLC_Stop(this->id);
}
jboolean JVLC::isPlaying() {
return VLC_IsPlaying(this->id);
}
jfloat JVLC::getPosition() {
return VLC_PositionGet(this->id);
}
jfloat JVLC::setPosition(jfloat position) {
return VLC_PositionSet(this->id, position);
}
jint JVLC::getTime() {
return VLC_TimeGet(this->id);
}
jint JVLC::setTime(jint seconds, jboolean relative) {
return VLC_TimeSet(this->id, seconds, relative);
}
jint JVLC::getLength() {
return VLC_LengthGet(this->id);
}
jfloat JVLC::speedFaster() {
return VLC_SpeedFaster(this->id);
}
jfloat JVLC::speedSlower() {
return VLC_SpeedSlower(this->id);
}
jint JVLC::getPlaylistIndex() {
return VLC_PlaylistIndex(this->id);
}
jint JVLC::getPlaylistItems() {
return VLC_PlaylistNumberOfItems(this->id);
}
jint JVLC::playlistNext() {
return VLC_PlaylistNext(this->id);
}
jint JVLC::playlistPrev() {
return VLC_PlaylistPrev(this->id);
}
jint JVLC::playlistClear() {
return VLC_PlaylistClear(this->id);
}
jint JVLC::setVolume(jint volume) {
return VLC_VolumeSet(this->id, volume);
}
jint JVLC::getVolume() {
return VLC_VolumeGet(this->id);
}
jint JVLC::muteVolume() {
return VLC_VolumeMute(this->id);
}
jint JVLC::fullScreen() {
return VLC_FullScreen(this->id);
}
/* XXX: in progress */
::JVLCVariable* JVLC::getVariable(::java::lang::String* varName) {
char* const psz_var = (char* const) elements( varName->toCharArray());
vlc_value_t value;
if (VLC_VariableGet(this->id, psz_var, &value) != VLC_SUCCESS) {
// throw exception
return NULL;
}
return NULL;
}
/*
* This is an helper function to convert jstrings to char*s
* setString _assumes_ the char* dest has been allocated
* XXX: should return >= 0 on success, < 0 on error
*/
void setString(jstring orig, char* dest) {
jsize chars = JvGetStringUTFRegion(orig, 0, orig->length(), dest);
dest[chars] = '\0';
}
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment