Our main class JVidCap is a frame class. You will see recording options when you run the application. You can choose video format, audio options, etc

Let me start telling you about the code. The startMonitoring() function will give you monitoring stream. It first closes the previous processor (if there is one). Processor is the object that records the video. And the function will initialize the class objects according to your choices. We get our processor object from Manager class. We will use the static method createRealizedProcessor of the class Manager. Afterwards we can add the monitor component, and we will see our face on the window.

The next function I will tell you is startCapture. We first get our datasource from processor object. The object that you should know here is the datasink object. It is the one that writes your data to your hard disc. After you have it, you will also say processor.start(); and it is now on.. I don’t want to tell the rest, it is a little bit long.

Please feel free to ask if you have any problems. See ya…

Another object we will use is MediaLocator. It is used to locate media and will be needed to create a player object which will provide us a visual component that can be displayed in a Frame.

CaptureDeviceInfo di = CaptureDeviceManager.getDevice(deviceString); //Get the device info
MediaLocator ml = new MediaLocator(deviceString); //Get the media locator
Player player = Manager.createRealizedPlayer(ml);

Right now, if we are successful to create the player object without any exception raised, then I can proudly say we are so close to see ourselves on the camera. We will just start the player then get the visual component from it. Here you are:

player.start();
Component comp = player.getVisualComponent();

And now, we will just add the comp to the frame and our face is now on the frame. But our goal is to take a picture from camera and save it as an image so let’s take care of that.

FrameGrabbingControl fgc = (FrameGrabbingControl) player.getControl("javax.media.control.FrameGrabbingControl");

In the code above, we used the FrameGrabbingControl of the player. That gives us the ability to create a buffer which can be converted to image.

Buffer = fgc.grabFrame();

We now have the buffer. We will use BufferToImage object to get the image. The code below does that:

BufferToImage btoi= new BufferToImage((VideoFormat)buf.getFormat());
Image imaj = btoi.createImage(buf);

Now at last, we do have the image object that can be saved as a file. You can download the full code by clicking here. Please provide me feedback.

So let’s get started with it by installing to our pc. Here are the steps:

1.       Download the software here: http://www.oracle.com/technetwork/java/javase/download-142937.html

2.       After your installation, you can see the devices JMF has recognized by using JMFRegistry. There, you can also edit the video, audio codecs and create jar libraries based on your needs.

In the next articles, I will show you how to capture images, videos using jmf.

The application will consist of two classes. Our first class will extend JFrame and the second one will be a JPanel class to be added to the first class. All the painting staff will be handled in our JPanel class.

We will create paintings by drawing lines between the points that mouse is clicked on. Here are the classes:

Main.java:

package paint;

import javax.swing.JFrame;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
public class Main extends JFrame {
public Main(){
super("Painting Application");
setSize(400, 500);
setVisible(true);
addWindowListener(new WindowAdapter() {
@Override
public void windowClosing(WindowEvent e){
System.exit(0);
}
});
add(new MyPanel());
}
public static void main(String[] args) {
new Main();
}
}

MyPanel.java:

package paint;
import java.awt.Graphics;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.awt.event.MouseMotionListener;
import javax.swing.JPanel;

public class MyPanel extends JPanel{
MouseMotionListener theListener;
Graphics g;
MouseListener theListening;
int x,y,x1,y1;
boolean inside;
public MyPanel(){
x=0; y=0; x1=-99; y1=-99;
inside=false;
theListener=new MouseMotionListener() {
public void mouseDragged(MouseEvent arg0) {
if(inside){
repaint();
}
}
public void mouseMoved(MouseEvent arg0) {
}
};
theListening=new MouseListener() {

public void mouseClicked(MouseEvent arg0) {
//Nothing to be done…
}

public void mousePressed(MouseEvent arg0) {
//Nothing to be done…
}

public void mouseReleased(MouseEvent arg0) {
x1=-99;y1=-99;//Mouse released. We need to make sure no last point for future use.
}

public void mouseEntered(MouseEvent arg0) {
inside=true; //Mouse has just entered
x1=-99;y1=-99; //No last point because the mouse was outside.
}

public void mouseExited(MouseEvent arg0) {
inside=false; //Mouse is now outside
x1=-99; y1=-99; //No last point, mouse is outside
}
};
this.setSize(400,500);
this.setVisible(true);
this.addMouseMotionListener(theListener);
this.addMouseListener(theListening);
}
@Override
public void paint(Graphics g){

try{
if(x1==-99){ // if x equals to -99 then y also equals to -99. A point of (-99,-99) is not possible so nothing will be drawn.

x=getMousePosition().x; x1=x; //Getting the point so that we will be able to use it as the first point
y=getMousePosition().y; y1=y;  //of the line when another point is clicked.
}
else//Event just occurred at (x1,y1). Between (x,y) and (x1,y1) a line will be drawn
{
x=getMousePosition().x;
y=getMousePosition().y;
g.drawLine(x, y, x1, y1);
x1=x; y1=y;
}
}
catch(Exception ex){
}
}
}

If you have any problem running or understanding the code please give me feedback.

Main.java:

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.ProtocolException;
import java.net.URL;
import java.util.logging.Level;
import java.util.logging.Logger;

public class Main {

private BufferedReader reader;

private HttpURLConnection huc;

private URL url;

public Main(){
try {

url=new URL("http://www.google.com");

}

catch (MalformedURLException ex) {
Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex);
}

try {
huc = (HttpURLConnection) url.openConnection();
} catch (IOException ex) {
Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex);
}
try {
huc.setRequestMethod("GET");
} catch (ProtocolException ex) {
Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex);
}
huc.setRequestProperty("User-Agent", "Mozilla/4.0 (compatible; JVM)");
huc.setRequestProperty("Pragma", "no-cache");
try {
huc.connect();
} catch (IOException ex) {
Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex);
}
try {
reader = new BufferedReader(new InputStreamReader(huc.getInputStream()));
} catch (IOException ex) {
Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex);
}
String line = "", fullPage = "";
try {
while ((line = reader.readLine()) != null) {
fullPage += line;
}
} catch (IOException ex) {
Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex);
}

System.out.println(fullPage);

}

public static void main(String[] args) {
new Main();
}

}

So this code will let you see the html content of any website just like you are connecting via web browser.

Java Access Modifiers

Public: A public member can be accessed by any other java classes.

Private: A private member can only be accessed from the class in which it is defined.

Protected: A protected variable cannot be assigned from another package. It is accessible outside the package only through inheritance. I should give an example. The code below is in a package2 class:

Package1.Class1 class1 = new Package1.Class1();
class1.theProtectedNumber = 5; // This is not ok.

If Package2.Class1 extends package1.Class1 then it can access the protected members by using super methods.

Default:  It also means package-level access. So a default member can be accessed only inside the same package in which it is declared.

Other notions

Static: A static member can be used without creating an instance of a class in which it is declared.

Getter: If a private class member is needed to provide its value to the other classes, then getter methods are used. They are usually declared as “public Member getMember()” and returns the value of the member.

Setter: Just like getters, setters are used to set values. They are usually declared as “public void setMember(MemberClass member)” and changes the member value of the instance.

Interface: Using interface will provide different implementations of an interface. So, classes which implement the same interface will be able to be used as one class. Any class which implements an interface will have to implement all of the interface methods.

Abstract class: An abstract class is used as a super class. Its abstract methods have to be implemented by the subclasses. Any other members of an abstract class can be used by its subclasses without overriding.

Final: Value of a final member cannot be changed.

I know there are so many things to tell, but I am a little bit lazy here, so if you want me to tell more notions, you can just make a comment, and I will reply as fast as I can.