【实例简介】录制的视频保存在 java.io.tmpdir 目录，windows通常为 C:\Users\Administrator\AppData\Local\Temp
【实例截图】
点击播放后，效果如下：
【核心代码】
import java.awt.AWTException;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.GridLayout;
import java.awt.MouseInfo;
import java.awt.Point;
import java.awt.Rectangle;
import java.awt.Robot;
import java.awt.Toolkit;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.awt.image.BufferedImage;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.Closeable;
import java.io.File;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.nio.ByteBuffer;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.channels.FileChannel.MapMode;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
import java.util.zip.ZipEntry;
import java.util.zip.ZipInputStream;
import java.util.zip.ZipOutputStream;
import javax.imageio.ImageIO;
import javax.sound.sampled.AudioFormat;
import javax.sound.sampled.AudioSystem;
import javax.sound.sampled.DataLine;
import javax.sound.sampled.SourceDataLine;
import javax.sound.sampled.TargetDataLine;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;
/**
* java录像小程序: 视频文件保存在系统临时目录, 回车全屏播放, ESC退出全屏播放
* @author dgqjava
*
*/
@SuppressWarnings("serial")
public class MainFrame extends JFrame {
private static final int WIDTH = 200;
private static final int HEIGHT = 70;
private static final Color BUTTON_COLOR = new Color(155, 183, 214);
private static final Color BUTTON_FOCUS_COLOR = new Color(87, 156, 242);
private static final Color BUTTON_DISABLE_COLOR = new Color(180, 207, 229);
private static final Font BUTTON_FONT = new Font("华文行楷", Font.BOLD, 15);
private static final String DEFAULT_FILE_PATH = System.getProperty("java.io.tmpdir");
private static Dimension screenSize;
private final JButton start = new JButton("开始");
private final JButton pause = new JButton("暂停");
private final JButton restart = new JButton("继续");
private final JButton stop = new JButton("完成");
private final JButton play = new JButton("播放");
private final JButton close = new JButton("退出");
private String currentFilePath;
public MainFrame() {
setUndecorated(true);
setSize(WIDTH, HEIGHT);
Toolkit tk = Toolkit.getDefaultToolkit();
screenSize = tk.getScreenSize();
setLocation((int) screenSize.getWidth() - WIDTH, (int) (screenSize.getHeight() - tk.getScreenInsets(getGraphicsConfiguration()).bottom - HEIGHT));
MouseListener buttonMouseListener = new MouseAdapter() {
public void mouseEntered(MouseEvent e) {
JButton btn = (JButton) e.getSource();
if(btn.isEnabled()) {
btn.setBackground(BUTTON_FOCUS_COLOR);
}
}
public void mouseExited(MouseEvent e) {
JButton btn = (JButton) e.getSource();
if(btn.isEnabled()) {
btn.setBackground(BUTTON_COLOR);
}
}
};
start.addMouseListener(buttonMouseListener);
pause.addMouseListener(buttonMouseListener);
restart.addMouseListener(buttonMouseListener);
stop.addMouseListener(buttonMouseListener);
play.addMouseListener(buttonMouseListener);
close.addMouseListener(buttonMouseListener);
ChangeListener changeListener = new ChangeListener() {
public void stateChanged(ChangeEvent e) {
JButton btn = (JButton) e.getSource();
if(btn.isEnabled()) {
btn.setBackground(BUTTON_COLOR);
} else {
btn.setBackground(BUTTON_DISABLE_COLOR);
}
}
};
start.addChangeListener(changeListener);
pause.addChangeListener(changeListener);
restart.addChangeListener(changeListener);
stop.addChangeListener(changeListener);
play.addChangeListener(changeListener);
start.setFont(BUTTON_FONT);
pause.setFont(BUTTON_FONT);
restart.setFont(BUTTON_FONT);
stop.setFont(BUTTON_FONT);
play.setFont(BUTTON_FONT);
close.setFont(BUTTON_FONT);
start.setBackground(BUTTON_COLOR);
pause.setBackground(BUTTON_DISABLE_COLOR);
restart.setBackground(BUTTON_DISABLE_COLOR);
stop.setBackground(BUTTON_DISABLE_COLOR);
play.setBackground(BUTTON_DISABLE_COLOR);
close.setBackground(BUTTON_COLOR);
pause.setEnabled(false);
restart.setEnabled(false);
stop.setEnabled(false);
play.setEnabled(false);
start.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
start.setEnabled(false);
pause.setEnabled(true);
stop.setEnabled(true);
play.setEnabled(false);
currentFilePath = DEFAULT_FILE_PATH System.currentTimeMillis();
RecordHelper.start(currentFilePath);
}
});
pause.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
pause.setEnabled(false);
restart.setEnabled(true);
stop.setEnabled(false);
RecordHelper.pause();
}
});
restart.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
pause.setEnabled(true);
restart.setEnabled(false);
stop.setEnabled(true);
RecordHelper.restart();
}
});
stop.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
start.setEnabled(true);
pause.setEnabled(false);
stop.setEnabled(false);
play.setEnabled(true);
RecordHelper.stop();
}
});
play.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
setVisible(false);
new PlayerFrame();
}
});
close.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
System.exit(0);
}
});
setLayout(new GridLayout(2, 3));
add(start);
add(pause);
add(restart);
add(stop);
add(play);
add(close);
setVisible(true);
}
class PlayerFrame extends JFrame {
private MyVideo mv;
private final ExecutorService player;
private volatile BufferedImage lastImage;
public PlayerFrame() {
player = Executors.newSingleThreadExecutor();
player.execute(new Runnable() {
public void run() {
mv = new MyVideo(new File(currentFilePath), false, (byte) 0);
mv.position(0);
}
});
player.execute(new Runnable() {
public void run() {
for(;;) {
Object[] data = mv.nextFrame();
if(0 == data.length) {
player.shutdown();
AudioHelper.flush();
dispose();
MainFrame.this.setVisible(true);
play.setEnabled(true);
return;
}
lastImage = (BufferedImage) data[0];
repaint();
byte[] audioData = (byte[]) data[1];
AudioHelper.writeData(audioData);
}
}
});
setUndecorated(true);
setBounds((int) (screenSize.getWidth() / 8), (int) (screenSize.getHeight() / 8), (int) (screenSize.getWidth() / 4 * 3), (int) (screenSize.getHeight() / 4 * 3));
final JPanel canvas = new JPanel() {
protected void paintComponent(Graphics g) {
super.paintComponent(g);
if(null != lastImage) {
int w = lastImage.getWidth();
int h = lastImage.getHeight();
if(w * getHeight() > h * getWidth()) {
g.drawImage(lastImage, 0, (int) (getHeight() - getWidth() * 1.0 / w * h) / 2, getWidth(), (int) (getWidth() * 1.0 / w * h), null);
} else {
g.drawImage(lastImage, (int) (getWidth() - getHeight() * 1.0 / h * w) / 2, 0, (int) (getHeight() * 1.0 / h * w), getHeight(), null);
}
}
Point mouseLocation = MouseInfo.getPointerInfo().getLocation();
if(new Rectangle(PlayerFrame.this.getLocation().x, PlayerFrame.this.getLocation().y getHeight() - 70, getWidth(), 50).contains(mouseLocation)) {
Color c = g.getColor();
g.setColor(new Color(0, 0, 100, 60));
g.fill3DRect(0, getHeight() - 70, getWidth(), 50, true);
g.setColor(new Color(97, 211, 225, 120));
g.fill3DRect(mouseLocation.x - PlayerFrame.this.getX() - 1, getHeight() - 70, 3, 50, true);
g.fill3DRect(0, getHeight() - 70, mv.position() * getWidth() / mv.length(), 50, true);
g.setColor(c);
}
}
};
canvas.addMouseMotionListener(new MouseAdapter() {
public void mouseMoved(MouseEvent e) {
repaint();
}
});
canvas.addMouseListener(new MouseAdapter() {
public void mouseClicked(MouseEvent e) {
if(new Rectangle(PlayerFrame.this.getLocation().x, PlayerFrame.this.getLocation().y getHeight() - 70, getWidth(), 50).contains(e.getLocationOnScreen()) && null != mv) {
mv.position((e.getLocationOnScreen().x - PlayerFrame.this.getLocation().x) * mv.length() / getWidth());
}
}
});
canvas.setBackground(Color.BLACK);
add(canvas);
addKeyListener(new KeyAdapter() {
public void keyReleased(KeyEvent e) {
if(e.getKeyCode() == KeyEvent.VK_ENTER) {
PlayerFrame.this.setLocation(0, 0);
PlayerFrame.this.setSize(screenSize);
} else if(e.getKeyCode() == KeyEvent.VK_ESCAPE) {
PlayerFrame.this.setBounds((int) (screenSize.getWidth() / 8), (int) (screenSize.getHeight() / 8), (int) (screenSize.getWidth() / 4 * 3), (int) (screenSize.getHeight() / 4 * 3));
}
}
});
setVisible(true);
}
}
public static void main(String[] args) throws Exception {
new MainFrame();
}
}
/**
* 对应一个视频文件, 视频文件数据格式如下:
* {
* 文件头信息: 30byte "作者:dgqjava qq群:326337220".getBytes("UTF-8")
* 帧列表 : [
* 帧信息 : {
* nbyte 图片数据
* nbyte 音频数据
* }
* ]
* 索引列表 : [
* 索引信息 : {
* 1byte 帧标识: 增量01010101|全量10101010
* 2byte 音频数据压缩大小
* 3byte 图片数据压缩大小
* 4byte 帧位置
* }
* ]
* 索引列表位置 : 4byte
* 每秒帧数 : 1byte
* }
* @author dgqjava
*
*/
class MyVideo implements Closeable {
private static final String HEADER = "作者:dgqjava qq群:326337220";
private final byte[] header = new byte[30];
private final byte rate;
private final List indexList = new ArrayList();
private volatile int frameIndex;
private volatile BufferedImage last;
private volatile int[] oldRgbData;
private long lastFrameTime = -1;
private final boolean isCreate;
private final RandomAccessFile raf;
private final FileChannel fileChannel;
private final MappedByteBuffer mbb;
public MyVideo(File file, boolean isCreate, byte rate) {
try {
this.isCreate = isCreate;
if(isCreate) {
this.rate = rate;
mbb = null;
file.createNewFile();
raf = new RandomAccessFile(file, "rw");
fileChannel = raf.getChannel();
ByteBuffer bb = ByteBuffer.wrap(HEADER.getBytes("UTF-8"));
while(bb.hasRemaining()) {
fileChannel.write(bb);
}
} else {
raf = new RandomAccessFile(file, "r");
fileChannel = raf.getChannel();
mbb = fileChannel.map(MapMode.READ_ONLY, 0, fileChannel.size());
mbb.get(header, 0, header.length);
if(!HEADER.equals(new String(header, "UTF-8"))) {
throw new RuntimeException("文件格式错误");
}
mbb.position(mbb.capacity() - 5);
byte[] bs = new byte[4];
mbb.get(bs);
int indexIndex = ByteBuffer.wrap(bs).getInt();
this.rate = mbb.get();
mbb.position(indexIndex);
byte[] indexByte = new byte[10];
while(mbb.position() < mbb.capacity() - 5) {
mbb.get(indexByte);
indexList.add(FrameIndex.fromByteArray(indexByte));
}
}
} catch (Exception e) {
throw new RuntimeException(e);
}
}
public synchronized void position(int newFrameIndex) {
try {
frameIndex = newFrameIndex;
int lastFullFrameIndex;
for(lastFullFrameIndex = frameIndex; lastFullFrameIndex >= 0; lastFullFrameIndex--) {
if(indexList.get(lastFullFrameIndex).isFull) {
break;
}
}
Frame frame = getFrame(lastFullFrameIndex);
last = ImageIO.read(new ByteArrayInputStream(ZipHelper.unZip(frame.getPicData()).toByteArray()));
oldRgbData = ImageHelper.getRgb(last);
for(int i = lastFullFrameIndex 1; i <= frameIndex; i ) {
frame = getFrame(i);
int[] rgb = ImageHelper.byteArray2RgbArray(ZipHelper.unZip(frame.getPicData()).toByteArray());
ImageHelper.setRgbArrayChange(last, oldRgbData, rgb);
}
} catch (Exception e) {
e.printStackTrace();
}
}
public int position() {
return frameIndex;
}
public int length() {
return indexList.size();
}
public synchronized Object[] nextFrame() {
try {
Frame frame = getFrame( frameIndex);
if(null == frame) {
return new Object[]{};
}
byte[] audioData = ZipHelper.unZip(frame.getAudioData()).toByteArray();
int[] rgb = null;
if(frame.getFlag() == Frame.FULL) {
last = ImageIO.read(new ByteArrayInputStream(ZipHelper.unZip(frame.getPicData()).toByteArray()));
} else {
rgb = ImageHelper.byteArray2RgbArray(ZipHelper.unZip(frame.getPicData()).toByteArray());
}
audioData = ZipHelper.unZip(frame.getAudioData()).toByteArray();
if(-1 != lastFrameTime) {
long period = System.currentTimeMillis() - lastFrameTime;
if(period < 1000 / rate) {
Thread.sleep(1000 / rate - period);
}
}
if(null != rgb) {
ImageHelper.setRgbArrayChange(last, oldRgbData, rgb);
}
lastFrameTime = System.currentTimeMillis();
return new Object[] {last, audioData};
} catch (Exception e) {
throw new RuntimeException(e);
}
}
public void addFrame(Frame frame) {
try {
FrameIndex fi = new FrameIndex(frame.getFlag() == Frame.FULL, frame.getAudioData().length, frame.getPicData().length, (int) fileChannel.position());
indexList.add(fi);
write(frame.getPicData());
write(frame.getAudioData());
} catch (IOException e) {
e.printStackTrace();
}
}
public Frame getFrame(int index) {
if(index == indexList.size()) {
return null;
}
FrameIndex frameIndex = indexList.get(index);
byte[] picData = new byte[frameIndex.picDataSize];
byte[] audioData = new byte[frameIndex.audioDataSize];
mbb.position(frameIndex.index);
mbb.get(picData);
mbb.get(audioData);
return new Frame(frameIndex.isFull ? Frame.FULL : Frame.INCREMENTAL, picData, audioData);
}
public void close() {
try {
if(isCreate) {
int indexListIndex = (int) fileChannel.position();
for(FrameIndex fi : indexList) {
write(fi.toByteArray());
}
write(ByteBuffer.allocate(4).putInt(indexListIndex).array());
write(new byte[] {rate});
}
fileChannel.force(false);
raf.close();
fileChannel.close();
} catch (IOException e) {
e.printStackTrace();
}
}
private void write(byte[] data) throws IOException {
ByteBuffer bb = ByteBuffer.wrap(data);
while(bb.hasRemaining()) {
fileChannel.write(bb);
}
}
static class FrameIndex {
private final boolean isFull;
private final int audioDataSize;
private final int picDataSize;
private final int index;
public FrameIndex(boolean isFull, int audioDataSize, int picDataSize, int index) {
this.isFull = isFull;
this.audioDataSize = audioDataSize;
this.picDataSize = picDataSize;
this.index = index;
}
public boolean isFull() {
return isFull;
}
public int getAudioDataSize() {
return audioDataSize;
}
public int getPicDataSize() {
return picDataSize;
}
public int getIndex() {
return index;
}
public byte[] toByteArray() {
byte[] result = new byte[10];
result[0] = (isFull ? Frame.FULL : Frame.INCREMENTAL);
ByteBuffer.allocate(4).putInt(audioDataSize).array();
System.arraycopy(ByteBuffer.allocate(4).putInt(audioDataSize).array(), 2, result, 1, 2);
System.arraycopy(ByteBuffer.allocate(4).putInt(picDataSize).array(), 1, result, 3, 3);
System.arraycopy(ByteBuffer.allocate(4).putInt(index).array(), 0, result, 6, 4);
return result;
}
public static FrameIndex fromByteArray(byte[] bs) {
boolean isFull = (Frame.FULL == bs[0]);
byte[] temp = new byte[8];
System.arraycopy(bs, 1, temp, 6, 2);
int audioDataSize = (int) ByteBuffer.wrap(temp).getLong();
System.arraycopy(bs, 3, temp, 5, 3);
int picDataSize = (int) ByteBuffer.wrap(temp).getLong();
System.arraycopy(bs, 6, temp, 4, 4);
int index = (int) ByteBuffer.wrap(temp).getLong();
return new FrameIndex(isFull, audioDataSize, picDataSize, index);
}
}
static class Frame {
public static final Frame TERMINATE_FRAME = new Frame((byte) 0, null, null);
public static final byte FULL = 0;
public static final byte INCREMENTAL = 1;
private final byte flag;
private final byte[] picData;
private final byte[] audioData;
public Frame(byte flag, byte[] picData, byte[] audioData) {
this.flag = flag;
this.picData = picData;
this.audioData = audioData;
}
public byte getFlag() {
return flag;
}
public byte[] getPicData() {
return picData;
}
public byte[] getAudioData() {
return audioData;
}
}
}
class RecordHelper {
private static final byte RECORD_RATE = 5;
private static final int DEFAULT_FULL_PIC_RATE = 80;
private static final int FULL_PIC_PERIOD = 60;
private static final Rectangle rectangle = new Rectangle(Toolkit.getDefaultToolkit().getScreenSize());
private static ScheduledExecutorService screenCapture;
private static ScheduledExecutorService audioProcesser;
private static final ExecutorService ioProcesser = Executors.newSingleThreadExecutor();
private static final ExecutorService dataProcesser = Executors.newSingleThreadExecutor();
private static final BlockingQueue screenQueue = new LinkedBlockingQueue();
private static final BlockingQueue audioQueue = new LinkedBlockingQueue();
private static final BlockingQueue frameQueue = new LinkedBlockingQueue();
private static volatile boolean generateFull = false;
public static void start(final String filePath) {
generateFull = true;
restart();
dataProcesser.execute(new Runnable() {
public void run() {
try {
double lastFullPicTime = -1;
int[] latestRgb = null;
for(;;) {
byte[] picData;
byte flag;
Object[] imageData = screenQueue.take();
byte[] audioData = audioQueue.take();
if(generateFull) {
latestRgb = ImageHelper.getRgb((BufferedImage) imageData[1]);
picData = ZipHelper.zip(ImageHelper.image2Stream((BufferedImage) imageData[1]).toByteArray()).toByteArray();
flag = MyVideo.Frame.FULL;
lastFullPicTime = (Long) imageData[0];
frameQueue.put(new MyVideo.Frame(flag, picData, ZipHelper.zip(audioData).toByteArray()));
generateFull = false;
continue;
}
int[] temp = latestRgb.clone();
double rate = DEFAULT_FULL_PIC_RATE - ((((Long) imageData[0]) - lastFullPicTime) * DEFAULT_FULL_PIC_RATE / 1000 / FULL_PIC_PERIOD);
byte[] changeData = ImageHelper.getByteArrayChange(temp, (BufferedImage) imageData[1], rate);
if(null != changeData) {
latestRgb = temp;
picData = ZipHelper.zip(changeData).toByteArray();
flag = MyVideo.Frame.INCREMENTAL;
} else {
latestRgb = ImageHelper.getRgb((BufferedImage) imageData[1]);
picData = ZipHelper.zip(ImageHelper.image2Stream((BufferedImage) imageData[1]).toByteArray()).toByteArray();
flag = MyVideo.Frame.FULL;
lastFullPicTime = (Long) imageData[0];
}
frameQueue.put(new MyVideo.Frame(flag, picData, ZipHelper.zip(audioData).toByteArray()));
}
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
});
ioProcesser.execute(new Runnable() {
public void run() {
MyVideo video = new MyVideo(new File(filePath), true, RECORD_RATE);
try {
for(;;) {
MyVideo.Frame frame = frameQueue.take();
if(frame == MyVideo.Frame.TERMINATE_FRAME) {
return;
}
video.addFrame(frame);
}
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
} finally {
video.close();
}
}
});
}
public static void pause() {
screenCapture.shutdownNow();
audioProcesser.shutdownNow();
}
public static void restart() {
screenCapture = Executors.newSingleThreadScheduledExecutor();
audioProcesser = Executors.newSingleThreadScheduledExecutor();
screenCapture.scheduleAtFixedRate(new Runnable() {
public void run() {
try {
screenQueue.put(new Object[] {System.currentTimeMillis(), ImageHelper.getScreen(rectangle)});
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
}, 0, 1000 / RECORD_RATE, TimeUnit.MILLISECONDS);
final int bufferSize = AudioHelper.getBufferSize();
byte[] data = new byte[bufferSize];
AudioHelper.readData(data);
audioProcesser.scheduleAtFixedRate(new Runnable() {
public void run() {
try {
byte[] data = new byte[bufferSize];
int count = AudioHelper.readData(data);
audioQueue.put(Arrays.copyOf(data, count));
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
}, 0, 1000 / RECORD_RATE, TimeUnit.MILLISECONDS);
}
public static void stop() {
try {
pause();
frameQueue.put(MyVideo.Frame.TERMINATE_FRAME);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
final class ImageHelper {
private static final Robot robot;
private static final int DEFAULT_RGB = (255 << 24) | (0 << 16) | (0 << 8) | (0 << 0);
private static final String DEFAULT_FORMAT_NAME = "BMP";
static {
try {
robot = new Robot();
} catch (AWTException e) {
throw new RuntimeException(e);
}
}
public static BufferedImage getScreen(Rectangle rectangle) {
return robot.createScreenCapture(rectangle);
}
/**
* 获取图片的rgb数组
* @param images
* @return
*/
public static int[] getRgb(BufferedImage images) {
int w = images.getWidth();
int h = images.getHeight();
int[] result = new int[w * h];
for(int i = 0; i < h; i ) {
for(int j = 0; j < w; j ) {
result[i * w j] = images.getRGB(j, i);
}
}
return result;
}
/**
* 获取图片像素对比后差异的rgb数组, 并将新图片的变化部分更新到原图片的rgb数组中
* @param oldRgbData 对比的原图片的rgb数组
* @param currentImage 新图片
* @return
*/
public static int[] getRgbChange(int[] oldRgbData, BufferedImage currentImage) {
int w = currentImage.getWidth();
int h = currentImage.getHeight();
int[] result = new int[w * h];
for(int i = 0; i < h; i ) {
for(int j = 0; j < w; j ) {
int index = i * w j;
int oldRgb = oldRgbData[index];
int newRgb = currentImage.getRGB(j, i);
int rgb;
if(oldRgb != newRgb) {
rgb = (DEFAULT_RGB == newRgb ? oldRgb : newRgb);
result[index] = rgb;
} else {
rgb = DEFAULT_RGB;
result[index] = rgb;
}
oldRgbData[index] = rgb;
}
}
return result;
}
/**
* 获取图片像素对比后差异的rgb数组并压缩生成byte数组, 并将新图片的变化部分更新到原图片的rgb数组中
* @param oldRgbData
* @param currentImage
* @param allowPercent 当像素的变化比例超过这个值时放弃生成byte数组, 返回null
* @return
*/
public static byte[] getByteArrayChange(int[] oldRgbData, BufferedImage currentImage, double allowPercent) {
try {
int h = currentImage.getHeight();
int w = currentImage.getWidth();
int total = w * h;
int changeCount = 0;
ByteBuffer buffer = ByteBuffer.allocate(4);
int samePointCount = 0;
List chunkCountList = new ArrayList();
ByteArrayOutputStream baos = new ByteArrayOutputStream();
for(int i = 0; i < h; i ) {
for(int j = 0; j < w; j ) {
int index = i * w j;
int oldRgb = oldRgbData[index];
int newRgb = currentImage.getRGB(j, i);
int rgb;
if(oldRgb != newRgb) {
if(changeCount * 100D / total >= allowPercent) {
return null;
}
oldRgbData[index] = newRgb;
rgb = (DEFAULT_RGB == newRgb ? oldRgb : newRgb);
} else {
rgb = DEFAULT_RGB;
}
if(DEFAULT_RGB == rgb) {
if(samePointCount >= 0) {
samePointCount ;
} else {
chunkCountList.add(samePointCount);
samePointCount = 1;
}
} else {
if(samePointCount <= 0) {
samePointCount--;
} else {
chunkCountList.add(samePointCount);
samePointCount = -1;
}
buffer.clear();
baos.write(buffer.putInt(rgb).array());
}
}
}
chunkCountList.add(samePointCount);
byte[] rgbData = baos.toByteArray();
byte[] result = new byte[(chunkCountList.size() 1) * 4 rgbData.length];
buffer.clear();
int index = 0;
System.arraycopy(buffer.putInt(chunkCountList.size()).array(), 0, result, index, 4);
for(int chunkSize : chunkCountList) {
buffer.clear();
System.arraycopy(buffer.putInt(chunkSize).array(), 0, result, index = 4, 4);
}
System.arraycopy(rgbData, 0, result, index 4, rgbData.length);
return result;
} catch (IOException e) {
throw new RuntimeException(e);
}
}
/**
* 设置图片像素对比后差异的rgb数组, 并将变化部分更新到原图片的rgb数组中
* @param lastImage
* @param oldRgbData
* @param rgbChangeData
*/
public static void setRgbArrayChange(BufferedImage lastImage, int[] oldRgbData, int[] rgbChangeData) {
int h = lastImage.getHeight();
int w = lastImage.getWidth();
for(int i = 0; i < h; i ) {
for(int j = 0; j < w; j ) {
int index = i * w j;
int newRgb = rgbChangeData[index];
if(DEFAULT_RGB != newRgb) {
int oldRgb = oldRgbData[index];
int rgb;
if(oldRgb != newRgb) {
rgb = newRgb;
lastImage.setRGB(j, i, rgb);
} else {
rgb = DEFAULT_RGB;
lastImage.setRGB(j, i, rgb);
}
oldRgbData[index] = rgb;
}
}
}
}
public static void setRgbArray(BufferedImage image, int[] rgbChangeData) {
int h = image.getHeight();
int w = image.getWidth();
for(int i = 0; i < h; i ) {
for(int j = 0; j < w; j ) {
int newRgb = rgbChangeData[i * w j];
if(DEFAULT_RGB != newRgb) {
image.setRGB(j, i, newRgb);
}
}
}
}
public static ByteArrayOutputStream image2Stream(BufferedImage image) {
try {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
ImageIO.write(image, DEFAULT_FORMAT_NAME, baos);
return baos;
} catch (IOException e) {
throw new RuntimeException(e);
}
}
/**
* 压缩后的byte数组还原为rgb数组
* @param data
* @return
*/
public static int[] byteArray2RgbArray(byte[] data) {
ByteBuffer buffer = ByteBuffer.allocate(4);
buffer.clear();
buffer.put(new byte[] {data[0], data[1], data[2], data[3]});
buffer.flip();
int chunkCount = buffer.getInt();
List chunkCountList = new ArrayList(chunkCount);
int index = 4;
int rgbCount = 0;
for(int i = 0; i < chunkCount; i ) {
buffer.clear();
buffer.put((new byte[] {data[index 0], data[index 1], data[index 2], data[index 3]}));
buffer.flip();
int chunkSize = buffer.getInt();
chunkCountList.add(chunkSize);
rgbCount = Math.abs(chunkSize);
index = 4;
}
int[] rgbData = new int[rgbCount];
int rgbDataIndex = 0;
for(int chunkSize : chunkCountList) {
if(chunkSize > 0) {
for(int j = 0; j < chunkSize; j ) {
rgbData[rgbDataIndex ] = DEFAULT_RGB;
}
} else {
for(int j = 0; j > chunkSize; j--) {
buffer.clear();
buffer.put(new byte[] {data[index 0], data[index 1], data[index 2], data[index 3]});
buffer.flip();
rgbData[rgbDataIndex ] = buffer.getInt();
index = 4;
}
}
}
return rgbData;
}
}
final class AudioHelper {
private static final float RATE = 8000;
private static final int SAMPLE_SIZE_IN_BITS = 8;
private static final int CHANNELS = 1;
private static final AudioFormat DEFAULT_AUDIO_FORMAT = new AudioFormat(AudioFormat.Encoding.PCM_SIGNED, RATE, SAMPLE_SIZE_IN_BITS, CHANNELS, SAMPLE_SIZE_IN_BITS / 8 * CHANNELS, RATE, false);
private static SourceDataLine sourceDataLine;
private static TargetDataLine targetDataLine;
static {
try {
DataLine.Info targetInfo = new DataLine.Info(TargetDataLine.class, DEFAULT_AUDIO_FORMAT);
targetDataLine = (TargetDataLine) AudioSystem.getLine(targetInfo);
targetDataLine.open(DEFAULT_AUDIO_FORMAT);
targetDataLine.start();
DataLine.Info sourceInfo = new DataLine.Info(SourceDataLine.class, DEFAULT_AUDIO_FORMAT);
sourceDataLine = (SourceDataLine) AudioSystem.getLine(sourceInfo);
sourceDataLine.open(DEFAULT_AUDIO_FORMAT);
sourceDataLine.start();
} catch (Exception e) {
throw new RuntimeException(e);
}
}
public static int getBufferSize() {
return targetDataLine.getBufferSize();
}
public static int readData(byte[] bs) {
return targetDataLine.read(bs, 0, targetDataLine.available());
}
public static void writeData(byte[] bs) {
sourceDataLine.write(bs, 0, bs.length);
}
public static void flush() {
sourceDataLine.flush();
}
}
final class ZipHelper {
public static ByteArrayOutputStream zip(byte[] data) {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
try {
ZipOutputStream zip = new ZipOutputStream(baos);
ZipEntry entry = new ZipEntry("zip");
entry.setSize(data.length);
zip.putNextEntry(entry);
zip.write(data);
zip.closeEntry();
zip.close();
} catch (Exception e) {
e.printStackTrace();
}
return baos;
}
public static ByteArrayOutputStream unZip(byte[] data) {
ByteArrayOutputStream baos = null;
try {
ByteArrayInputStream bis = new ByteArrayInputStream(data);
ZipInputStream zip = new ZipInputStream(bis);
if (zip.getNextEntry() != null) {
byte[] buf = new byte[1024];
int num;
baos = new ByteArrayOutputStream();
while ((num = zip.read(buf, 0, buf.length)) != -1) {
baos.write(buf, 0, num);
}
baos.flush();
baos.close();
}
zip.close();
bis.close();
} catch (Exception e) {
e.printStackTrace();
}
return baos;
}
}
