由网友(你的爱、能见度为零)分享简介：我要拍摄使用JavaCV LIB在Android中的视频。我需要在640×360录制视频。我已经安装了一切，在README.txt文件中所述，我跟着如下面的例子：的https：//$c$c.google.com /p/javacv/source/browse/samples/RecordActivity.java...
我要拍摄使用JavaCV LIB在Android中的视频。 我需要在640×360录制视频。
我已经安装了一切，在README.txt文件中所述，我跟着如下面的例子： 的https：//$c$c.google.com /p/javacv/source/browse/samples/RecordActivity.java 在这个例子中，视频大小是这样的： 私人诠释ImageWidth等= 320; 私人诠释imageHeight = 240;
在我的情况，我需要在640×360的H.264录像。
（更新）我已经恢复我的code，并保持完全一样的例子，只是改变ImageWidth等，并imageHeight为640×360。 现在，我越来越喜欢这一形象的视频： http://bergmann.net.br/img/screenshot_video_error.png
下面是我的code：
进口静态com.google code.javacv.cpp.opencv_core.IPL_DEPTH_8U;
进口java.io.IOException异常;
进口java.nio.ShortBuffer中;
进口android.app.Activity;
进口android.content.Context;
进口android.content.pm.ActivityInfo;
进口android.hardware.Camera;
进口android.hardware.Camera previewCallback。
进口android.media.AudioFormat;
进口android.media.AudioRecord;
进口android.media.MediaRecorder;
进口android.os.Bundle;
进口android.os.PowerManager;
进口android.util.Log;
进口android.view.Display;
进口android.view.KeyEvent;
进口android.view.LayoutInflater;
进口android.view.SurfaceHolder;
进口android.view.SurfaceView;
进口android.view.View;
进口android.view.View.OnClickListener;
进口android.view.WindowManager;
进口android.widget.Button;
进口android.widget.LinearLayout;
进口android.widget.RelativeLayout;
进口com.autosonvideo.helpers.Helpers;
进口com.autosonvideo.logic.CameraHelpers;
进口com.google code.javacv.FFmpegFrameRecorder;
进口com.google code.javacv.cpp.opencv_core.IplImage;
公共类FFmpegRecordActivity扩展活动实现OnClickListener {
私人最终静态字符串CLASS_LABEL =RecordActivity;
私人最终静态字符串LOG_TAG = CLASS_LABEL;
私人PowerManager.WakeLock mWakeLock;
私人字符串ffmpeg_link;
长的startTime = 0;
布尔记录= FALSE;
私人挥发性FFmpegFrameRecorder记录;
私人布尔是previewOn = FALSE;
私人诠释sampleAudioRateInHz = 44100;
私人诠释ImageWidth等= 640;
私人诠释imageHeight = 480;
私人诠释finalImageWidth = 640;
私人诠释finalImageHeight = 360;
私人诠释帧率= 30;
/ *音频数据获取线程* /
私人AudioRecord audioRecord;
私人AudioRecordRunnable audioRecordRunnable;
私人螺纹audioThread;
挥发性布尔runAudioThread = TRUE;
/ *视频数据获取线程* /
私人相机cameraDevice;
私人CameraView cameraView;
私人IplImage的yuvIplimage = NULL;
/ *布局设置* /
私人最终诠释bg_screen_bx = 232;
私人最终诠释bg_screen_by = 128;
私人最终诠释bg_screen_width = 700;
私人最终诠释bg_screen_height = 500;
私人最终诠释bg_width = 1123;
私人最终诠释bg_height = 715;
私人最终诠释live_width = 1280;
私人最终诠释live_height = 960;
私人诠释屏幕宽度，screenHeight;
私人按钮btnRecorderControl;
@覆盖
公共无效的onCreate（包savedInstanceState）{
super.onCreate（savedInstanceState）;
setRequestedOrientation（ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE）;
的setContentView（R.layout.main）;
电源管理器PM =（电源管理器）getSystemService（Context.POWER_SERVICE）;
mWakeLock = pm.newWakeLock（PowerManager.SCREEN_BRIGHT_WAKE_LOCK，
CLASS_LABEL）;
mWakeLock.acquire（）;
InitLayout在（）;
initRecorder（）;
}
@覆盖
保护无效onResume（）{
super.onResume（）;
如果（mWakeLock == NULL）{
电源管理器PM =（电源管理器）getSystemService（Context.POWER_SERVICE）;
mWakeLock = pm.newWakeLock（PowerManager.SCREEN_BRIGHT_WAKE_LOCK，
CLASS_LABEL）;
mWakeLock.acquire（）;
}
}
@覆盖
保护无效的onPause（）{
super.onPause（）;
如果（mWakeLock！= NULL）{
mWakeLock.release（）;
mWakeLock = NULL;
}
}
@覆盖
保护无效的onDestroy（）{
super.onDestroy（）;
记录= FALSE;
如果（cameraView！= NULL）{
cameraView.stop preVIEW（）;
cameraDevice.release（）;
cameraDevice = NULL;
}
如果（mWakeLock！= NULL）{
mWakeLock.release（）;
mWakeLock = NULL;
}
}
私人无效InitLayout在（）{
/ *获取屏幕*大小/
显示显示=（（窗口管理器）getSystemService（Context.WINDOW_SERVICE））
.getDefaultDisplay（）;
屏幕宽度= display.getWidth（）;
screenHeight = display.getHeight（）;
RelativeLayout.LayoutParams layoutParam = NULL;
LayoutInflater myInflate = NULL;
myInflate =（LayoutInflater）getSystemService（Context.LAYOUT_INFLATER_SERVICE）;
RelativeLayout的topLayout =新RelativeLayout的（这一点）;
的setContentView（topLayout）;
的LinearLayout preViewLayout =（的LinearLayout）myInflate.inflate（
R.layout.main，NULL）;
layoutParam =新RelativeLayout.LayoutParams（屏幕宽度，screenHeight）;
topLayout.addView（preViewLayout，layoutParam）;
/ *增加控制按钮：启动和停止* /
btnRecorderControl =（按钮）findViewById（R.id.recorder_control）;
btnRecorderControl.setText（开始）;
btnRecorderControl.setOnClickListener（本）;
/ *添加摄像机视图* /
INT display_width_d =（INT）（1.0 * bg_screen_width *屏幕宽度/ bg_width）;
INT display_height_d =（INT）（1.0 * bg_screen_height * screenHeight / bg_height）;
INT prev_rw，prev_rh;
如果（1.0 * display_width_d / display_height_d＆GT; 1.0 * live_width
/ live_height）{
prev_rh = display_height_d;
prev_rw =（INT）（1.0 * display_height_d * live_width / live_height）;
} 其他 {
prev_rw = display_width_d;
prev_rh =（INT）（1.0 * display_width_d * live_height / live_width）;
}
layoutParam =新RelativeLayout.LayoutParams（prev_rw，prev_rh）;
layoutParam.topMargin =（int）的（1.0 * bg_screen_by * screenHeight / bg_height）;
layoutParam.leftMargin =（INT）（1.0 * bg_screen_bx *屏幕宽度/ bg_width）;
cameraDevice = Camera.open（）;
Log.i（LOG_TAG，cameara开）;
cameraView =新CameraView（这一点，cameraDevice）;
topLayout.addView（cameraView，layoutParam）;
Log.i（LOG_TAG，cameara preVIEW启动：OK）;
}
// ---------------------------------------
//初始化ffmpeg_recorder
// ---------------------------------------
私人无效initRecorder（）{
Log.w（LOG_TAG，初始化记录器）;
如果（yuvIplimage == NULL）{
yuvIplimage = IplImage.create（finalImageWidth，finalImageHeight，
IPL_DEPTH_8U，2）;
Log.i（LOG_TAG，创造yuvIplimage）;
}
ffmpeg_link = CameraHelpers.getOutputMediaFile（
CameraHelpers.MEDIA_TYPE_VIDEO）的ToString（）;
Log.i（LOG_TAGffmpeg_url：+ ffmpeg_link）;
记录=新FFmpegFrameRecorder（ffmpeg_link，finalImageWidth，
finalImageHeight，1）;
recorder.setFormat（MP4）;
recorder.setSampleRate（sampleAudioRateInHz）;
//设置在表面变化的方法
recorder.setFrameRate（帧率）;
Log.i（LOG_TAG，录音机初始化成功）;
audioRecordRunnable =新AudioRecordRunnable（）;
audioThread =新主题（audioRecordRunnable）;
}
公共无效的startRecording（）{
尝试 {
recorder.start（）;
的startTime = System.currentTimeMillis的（）;
记录= TRUE;
audioThread.start（）;
}赶上（FFmpegFrameRecorder.Exception E）{
e.printStackTrace（）;
}
}
公共无效STO precording（）{
runAudioThread = FALSE;
如果（录像机= NULL和放大器;！＆功放;录音）{
记录= FALSE;
Log.v（LOG_TAG，
完成录音，呼吁停止并释放记录）;
尝试 {
recorder.stop（）;
recorder.release（）;
}赶上（FFmpegFrameRecorder.Exception E）{
e.printStackTrace（）;
}
记录= NULL;
}
}
@覆盖
公共布尔的onkeydown（INT键code，KeyEvent的事件）{
如果（键code == KeyEvent.KEY code_BACK）{
如果（录音）{
STO precording（）;
}
完（）;
返回true;
}
返回super.onKeyDown（键code，事件）;
}
// ---------------------------------------------
//音频线，获得和连接codeS音频数据
// ---------------------------------------------
类AudioRecordRunnable实现Runnable {
@覆盖
公共无效的run（）{
android.os.Process
.setThreadPriority（android.os.Process.THREAD_PRIORITY_URGENT_AUDIO）;
//音频
INT缓冲区大小;
短[] audioData;
INT bufferReadResult;
BUFFERSIZE = AudioRecord
.getMinBufferSize（sampleAudioRateInHz，
AudioFormat.CHANNEL_IN_MONO，
AudioFormat.ENCODING_PCM_16BIT）;
audioRecord =新AudioRecord（MediaRecorder.AudioSource.MIC，
sampleAudioRateInHz，AudioFormat.CHANNEL_IN_MONO，
AudioFormat.ENCODING_PCM_16BIT，缓冲区大小）;
audioData =新的短[BUFFERSIZE]
Log.d（LOG_TAG，audioRecord.startRecording（））;
audioRecord.startRecording（）;
/ * ffmpeg_audio编码循环* /
而（runAudioThread）{
// Log.v（LOG_TAG，录音？+录音）;
bufferReadResult = audioRecord.read（audioData，0，
audioData.length）;
如果（bufferReadResult大于0）{
Log.v（LOG_TAGbufferReadResult：+ bufferReadResult）;
//如果记录是不正确的，当启动这个线程，它
!!! //永远不会按照这个if语句的设置...
// 为什么？好问题...
如果（录音）{
尝试 {
recorder.record（ShortBuffer.wrap（audioData，0，
bufferReadResult））;
// Log.v（LOG_TAG，记录+ 1024 * 1 +至+
// 1024 * I + 1024）;
}赶上（FFmpegFrameRecorder.Exception E）{
Log.v（LOG_TAG，e.getMessage（））;
e.printStackTrace（）;
}
}
}
}
Log.v（LOG_TAG，AudioThread结束后，松开audioRecord）;
/ *编码完成，发行记录* /
如果（audioRecord！= NULL）{
audioRecord.stop（）;
audioRecord.release（）;
audioRecord = NULL;
Log.v（LOG_TAG，audioRecord发布了）;
}
}
}
// ---------------------------------------------
//摄像头线，获得和连接codeS视频数据
// ---------------------------------------------
类CameraView扩展了SurfaceView实现SurfaceHolder.Callback，
previewCallback {
私人SurfaceHolder mHolder;
私人相机mCamera;
公共CameraView（上下文的背景下，相机摄像头）{
超（上下文）;
Log.w（照相机，摄像机视图）;
mCamera =摄像头;
mHolder = getHolder（）;
mHolder.addCallback（CameraView.this）;
mHolder.setType（SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS）;
mCamera.set previewCallback（CameraView.this）;
}
@覆盖
公共无效surfaceCreated（SurfaceHolder持有者）{
尝试 {
停止preVIEW（）;
mCamera.set previewDisplay（保持器）;
}赶上（IOException异常除外）{
mCamera.release（）;
mCamera = NULL;
}
}
公共无效surfaceChanged（SurfaceHolder持有人，INT格式，诠释的宽度，
INT高度）{
Log.v（LOG_TAG，设置ImageWidth等：+ ImageWidth等
+imageHeight：+ imageHeight +帧率：
+帧率）;
Camera.Parameters camParams = mCamera.getParameters（）;
camParams.set previewSize（ImageWidth等，imageHeight）;
Log.v（LOG_TAG，
preVIEW帧率：+ camParams.get previewFrameRate（））;
camParams.set previewFrameRate（帧率）;
mCamera.setParameters（camParams）;
启动preVIEW（）;
}
@覆盖
公共无效surfaceDestroyed（SurfaceHolder持有者）{
尝试 {
mHolder.addCallback（空）;
mCamera.set previewCallback（空）;
}赶上（RuntimeException的E）{
//该相机可能刚刚发布，不容忽视。
}
}
公共无效开始preVIEW（）{
如果（！是previewOn和放大器;＆安培;！mCamera = NULL）{
为previewOn = TRUE;
mCamera.start preVIEW（）;
}
}
公共无效停止preVIEW（）{
如果（是previewOn和放大器;＆安培;！mCamera = NULL）{
为previewOn = FALSE;
mCamera.stop preVIEW（）;
}
}
@覆盖
在previewFrame（byte []的数据，摄像头摄像头）{公共无效
/ *获取视频数据* /
如果（yuvIplimage = NULL和放大器;！＆功放;录音）{
// yuvIplimage.getByteBuffer（）把（数据）;
最终诠释startY = 640 *（480 - 360）/ 2;
最终诠释LENY = 640 * 360;
。yuvIplimage.getByteBuffer（）把（数据，startY，LENY）;
最终诠释startVU = 640 * 480 + 320 * 2 *（240 - 180）/ 2;
最终诠释lenVU = 320 * 180 * 2;
。yuvIplimage.getByteBuffer（）把（数据，startVU，lenVU）;
Log.v（LOG_TAG编写框架）;
尝试 {
长T = 1000 *（System.currentTimeMillis的（） - startTime时）;
如果（T＆GT; recorder.getTimestamp（））{
recorder.setTimestamp（T）;
}
recorder.record（yuvIplimage）;
}赶上（FFmpegFrameRecorder.Exception E）{
Log.v（LOG_TAG，e.getMessage（））;
e.printStackTrace（）;
}
}
}
}
@覆盖
公共无效的onClick（视图v）{
如果（！录音）{
的StartRecording（）;
Log.w（LOG_TAG，启动按钮按下）;
btnRecorderControl.setText（停止）;
} 其他 {
//这将触发录音循环停止，然后设置
// isRecorderStart = FALSE;
STO precording（）;
Log.w（LOG_TAG，停止按钮按下）;
btnRecorderControl.setText（开始）;
}
}
}
解决方案
您的相机，最有可能的，能提供640×480 preVIEW帧。该解决将是剪辑这个框架在记录前，像这样的：
@覆盖
在previewFrame（byte []的数据，摄像头摄像头）{公共无效
/ *获取视频数据* /
如果（yuvIplimage = NULL和放大器;！＆功放;录音）{
ByteBuffer的BB = yuvIplimage.getByteBuffer（）; //重置缓冲区
最终诠释startY = ImageWidth等*（imageHeight-finalImageHeight）/ 2;
最终诠释LENY = ImageWidth等* finalImageHeight;
bb.put（数据，startY，LENY）;
最终诠释startVU = ImageWidth等* imageHeight + ImageWidth等*（imageHeight-finalImageHeight）/ 4;
最终诠释lenVU = ImageWidth等* finalImageHeight / 2;
bb.put（数据，startVU，lenVU）;
// Log.v（LOG_TAG，写作框架）;
尝试 {
长T = 1000 *（System.currentTimeMillis的（） - startTime时）;
如果（T＆GT; recorder.getTimestamp（））{
recorder.setTimestamp（T）;
}
recorder.record（yuvIplimage）;
}赶上（FFmpegFrameRecorder.Exception E）{
Log.e（LOG_TAG，问题记录（），E）;
}
}
}
的preVIEW帧具有半平面YVU格式：640×480亮度（Y）字节，其后为320×240对色度的（V和U）字节。我们复制到 yuvIpImage 首相关的Y和后 - 相关VU对。需要注意的是方便，快捷，因为你想要的宽度是一样的原始宽度。
您的相机和摄像机视图应为640×480初始化，并记录 - 以640×360。请注意，高效种植，则只有当 ImageWidth等== finalImageWidth
FIX 它发生这样的 IplImage.getByteBuffer（）重置缓冲区，因此，解决方法是使用一个临时的 BB 的对象。
请注意，你可能会想覆盖了preVIEW一个框架，将隐藏你裁剪这种方式的利润：我们的操作只更改录制的框架，而不是 CameraView 。
I'm trying to record a video in Android using the JavaCV lib. I need to record the video in 640x360.
I have installed everything as described in README.txt file and I followed the example as below: https://code.google.com/p/javacv/source/browse/samples/RecordActivity.java In this example, the video size is this: private int imageWidth = 320; private int imageHeight = 240;
In my case, I need to record a video in 640x360 H.264.
(UPDATE) I have reverted my code and kept exactly like in the example, just changing imageWidth and imageHeight to 640x360. Now I'm getting the video like this image: http://bergmann.net.br/img/screenshot_video_error.png
Here is my code:
import static com.googlecode.javacv.cpp.opencv_core.IPL_DEPTH_8U;
import java.io.IOException;
import java.nio.ShortBuffer;
import android.app.Activity;
import android.content.Context;
import android.content.pm.ActivityInfo;
import android.hardware.Camera;
import android.hardware.Camera.PreviewCallback;
import android.media.AudioFormat;
import android.media.AudioRecord;
import android.media.MediaRecorder;
import android.os.Bundle;
import android.os.PowerManager;
import android.util.Log;
import android.view.Display;
import android.view.KeyEvent;
import android.view.LayoutInflater;
import android.view.SurfaceHolder;
import android.view.SurfaceView;
import android.view.View;
import android.view.View.OnClickListener;
import android.view.WindowManager;
import android.widget.Button;
import android.widget.LinearLayout;
import android.widget.RelativeLayout;
import com.autosonvideo.helpers.Helpers;
import com.autosonvideo.logic.CameraHelpers;
import com.googlecode.javacv.FFmpegFrameRecorder;
import com.googlecode.javacv.cpp.opencv_core.IplImage;
public class FFmpegRecordActivity extends Activity implements OnClickListener {
private final static String CLASS_LABEL = "RecordActivity";
private final static String LOG_TAG = CLASS_LABEL;
private PowerManager.WakeLock mWakeLock;
private String ffmpeg_link;
long startTime = 0;
boolean recording = false;
private volatile FFmpegFrameRecorder recorder;
private boolean isPreviewOn = false;
private int sampleAudioRateInHz = 44100;
private int imageWidth = 640;
private int imageHeight = 480;
private int finalImageWidth = 640;
private int finalImageHeight = 360;
private int frameRate = 30;
/* audio data getting thread */
private AudioRecord audioRecord;
private AudioRecordRunnable audioRecordRunnable;
private Thread audioThread;
volatile boolean runAudioThread = true;
/* video data getting thread */
private Camera cameraDevice;
private CameraView cameraView;
private IplImage yuvIplimage = null;
/* layout setting */
private final int bg_screen_bx = 232;
private final int bg_screen_by = 128;
private final int bg_screen_width = 700;
private final int bg_screen_height = 500;
private final int bg_width = 1123;
private final int bg_height = 715;
private final int live_width = 1280;
private final int live_height = 960;
private int screenWidth, screenHeight;
private Button btnRecorderControl;
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);
setContentView(R.layout.main);
PowerManager pm = (PowerManager) getSystemService(Context.POWER_SERVICE);
mWakeLock = pm.newWakeLock(PowerManager.SCREEN_BRIGHT_WAKE_LOCK,
CLASS_LABEL);
mWakeLock.acquire();
initLayout();
initRecorder();
}
@Override
protected void onResume() {
super.onResume();
if (mWakeLock == null) {
PowerManager pm = (PowerManager) getSystemService(Context.POWER_SERVICE);
mWakeLock = pm.newWakeLock(PowerManager.SCREEN_BRIGHT_WAKE_LOCK,
CLASS_LABEL);
mWakeLock.acquire();
}
}
@Override
protected void onPause() {
super.onPause();
if (mWakeLock != null) {
mWakeLock.release();
mWakeLock = null;
}
}
@Override
protected void onDestroy() {
super.onDestroy();
recording = false;
if (cameraView != null) {
cameraView.stopPreview();
cameraDevice.release();
cameraDevice = null;
}
if (mWakeLock != null) {
mWakeLock.release();
mWakeLock = null;
}
}
private void initLayout() {
/* get size of screen */
Display display = ((WindowManager) getSystemService(Context.WINDOW_SERVICE))
.getDefaultDisplay();
screenWidth = display.getWidth();
screenHeight = display.getHeight();
RelativeLayout.LayoutParams layoutParam = null;
LayoutInflater myInflate = null;
myInflate = (LayoutInflater) getSystemService(Context.LAYOUT_INFLATER_SERVICE);
RelativeLayout topLayout = new RelativeLayout(this);
setContentView(topLayout);
LinearLayout preViewLayout = (LinearLayout) myInflate.inflate(
R.layout.main, null);
layoutParam = new RelativeLayout.LayoutParams(screenWidth, screenHeight);
topLayout.addView(preViewLayout, layoutParam);
/* add control button: start and stop */
btnRecorderControl = (Button) findViewById(R.id.recorder_control);
btnRecorderControl.setText("Start");
btnRecorderControl.setOnClickListener(this);
/* add camera view */
int display_width_d = (int) (1.0 * bg_screen_width * screenWidth / bg_width);
int display_height_d = (int) (1.0 * bg_screen_height * screenHeight / bg_height);
int prev_rw, prev_rh;
if (1.0 * display_width_d / display_height_d > 1.0 * live_width
/ live_height) {
prev_rh = display_height_d;
prev_rw = (int) (1.0 * display_height_d * live_width / live_height);
} else {
prev_rw = display_width_d;
prev_rh = (int) (1.0 * display_width_d * live_height / live_width);
}
layoutParam = new RelativeLayout.LayoutParams(prev_rw, prev_rh);
layoutParam.topMargin = (int) (1.0 * bg_screen_by * screenHeight / bg_height);
layoutParam.leftMargin = (int) (1.0 * bg_screen_bx * screenWidth / bg_width);
cameraDevice = Camera.open();
Log.i(LOG_TAG, "cameara open");
cameraView = new CameraView(this, cameraDevice);
topLayout.addView(cameraView, layoutParam);
Log.i(LOG_TAG, "cameara preview start: OK");
}
// ---------------------------------------
// initialize ffmpeg_recorder
// ---------------------------------------
private void initRecorder() {
Log.w(LOG_TAG, "init recorder");
if (yuvIplimage == null) {
yuvIplimage = IplImage.create(finalImageWidth, finalImageHeight,
IPL_DEPTH_8U, 2);
Log.i(LOG_TAG, "create yuvIplimage");
}
ffmpeg_link = CameraHelpers.getOutputMediaFile(
CameraHelpers.MEDIA_TYPE_VIDEO).toString();
Log.i(LOG_TAG, "ffmpeg_url: " + ffmpeg_link);
recorder = new FFmpegFrameRecorder(ffmpeg_link, finalImageWidth,
finalImageHeight, 1);
recorder.setFormat("mp4");
recorder.setSampleRate(sampleAudioRateInHz);
// Set in the surface changed method
recorder.setFrameRate(frameRate);
Log.i(LOG_TAG, "recorder initialize success");
audioRecordRunnable = new AudioRecordRunnable();
audioThread = new Thread(audioRecordRunnable);
}
public void startRecording() {
try {
recorder.start();
startTime = System.currentTimeMillis();
recording = true;
audioThread.start();
} catch (FFmpegFrameRecorder.Exception e) {
e.printStackTrace();
}
}
public void stopRecording() {
runAudioThread = false;
if (recorder != null && recording) {
recording = false;
Log.v(LOG_TAG,
"Finishing recording, calling stop and release on recorder");
try {
recorder.stop();
recorder.release();
} catch (FFmpegFrameRecorder.Exception e) {
e.printStackTrace();
}
recorder = null;
}
}
@Override
public boolean onKeyDown(int keyCode, KeyEvent event) {
if (keyCode == KeyEvent.KEYCODE_BACK) {
if (recording) {
stopRecording();
}
finish();
return true;
}
return super.onKeyDown(keyCode, event);
}
// ---------------------------------------------
// audio thread, gets and encodes audio data
// ---------------------------------------------
class AudioRecordRunnable implements Runnable {
@Override
public void run() {
android.os.Process
.setThreadPriority(android.os.Process.THREAD_PRIORITY_URGENT_AUDIO);
// Audio
int bufferSize;
short[] audioData;
int bufferReadResult;
bufferSize = AudioRecord
.getMinBufferSize(sampleAudioRateInHz,
AudioFormat.CHANNEL_IN_MONO,
AudioFormat.ENCODING_PCM_16BIT);
audioRecord = new AudioRecord(MediaRecorder.AudioSource.MIC,
sampleAudioRateInHz, AudioFormat.CHANNEL_IN_MONO,
AudioFormat.ENCODING_PCM_16BIT, bufferSize);
audioData = new short[bufferSize];
Log.d(LOG_TAG, "audioRecord.startRecording()");
audioRecord.startRecording();
/* ffmpeg_audio encoding loop */
while (runAudioThread) {
// Log.v(LOG_TAG,"recording? " + recording);
bufferReadResult = audioRecord.read(audioData, 0,
audioData.length);
if (bufferReadResult > 0) {
Log.v(LOG_TAG, "bufferReadResult: " + bufferReadResult);
// If "recording" isn't true when start this thread, it
// never get's set according to this if statement...!!!
// Why? Good question...
if (recording) {
try {
recorder.record(ShortBuffer.wrap(audioData, 0,
bufferReadResult));
// Log.v(LOG_TAG,"recording " + 1024*i + " to " +
// 1024*i+1024);
} catch (FFmpegFrameRecorder.Exception e) {
Log.v(LOG_TAG, e.getMessage());
e.printStackTrace();
}
}
}
}
Log.v(LOG_TAG, "AudioThread Finished, release audioRecord");
/* encoding finish, release recorder */
if (audioRecord != null) {
audioRecord.stop();
audioRecord.release();
audioRecord = null;
Log.v(LOG_TAG, "audioRecord released");
}
}
}
// ---------------------------------------------
// camera thread, gets and encodes video data
// ---------------------------------------------
class CameraView extends SurfaceView implements SurfaceHolder.Callback,
PreviewCallback {
private SurfaceHolder mHolder;
private Camera mCamera;
public CameraView(Context context, Camera camera) {
super(context);
Log.w("camera", "camera view");
mCamera = camera;
mHolder = getHolder();
mHolder.addCallback(CameraView.this);
mHolder.setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS);
mCamera.setPreviewCallback(CameraView.this);
}
@Override
public void surfaceCreated(SurfaceHolder holder) {
try {
stopPreview();
mCamera.setPreviewDisplay(holder);
} catch (IOException exception) {
mCamera.release();
mCamera = null;
}
}
public void surfaceChanged(SurfaceHolder holder, int format, int width,
int height) {
Log.v(LOG_TAG, "Setting imageWidth: " + imageWidth
+ " imageHeight: " + imageHeight + " frameRate: "
+ frameRate);
Camera.Parameters camParams = mCamera.getParameters();
camParams.setPreviewSize(imageWidth, imageHeight);
Log.v(LOG_TAG,
"Preview Framerate: " + camParams.getPreviewFrameRate());
camParams.setPreviewFrameRate(frameRate);
mCamera.setParameters(camParams);
startPreview();
}
@Override
public void surfaceDestroyed(SurfaceHolder holder) {
try {
mHolder.addCallback(null);
mCamera.setPreviewCallback(null);
} catch (RuntimeException e) {
// The camera has probably just been released, ignore.
}
}
public void startPreview() {
if (!isPreviewOn && mCamera != null) {
isPreviewOn = true;
mCamera.startPreview();
}
}
public void stopPreview() {
if (isPreviewOn && mCamera != null) {
isPreviewOn = false;
mCamera.stopPreview();
}
}
@Override
public void onPreviewFrame(byte[] data, Camera camera) {
/* get video data */
if (yuvIplimage != null && recording) {
// yuvIplimage.getByteBuffer().put(data);
final int startY = 640 * (480 - 360) / 2;
final int lenY = 640 * 360;
yuvIplimage.getByteBuffer().put(data, startY, lenY);
final int startVU = 640 * 480 + 320 * 2 * (240 - 180) / 2;
final int lenVU = 320 * 180 * 2;
yuvIplimage.getByteBuffer().put(data, startVU, lenVU);
Log.v(LOG_TAG, "Writing Frame");
try {
long t = 1000 * (System.currentTimeMillis() - startTime);
if (t > recorder.getTimestamp()) {
recorder.setTimestamp(t);
}
recorder.record(yuvIplimage);
} catch (FFmpegFrameRecorder.Exception e) {
Log.v(LOG_TAG, e.getMessage());
e.printStackTrace();
}
}
}
}
@Override
public void onClick(View v) {
if (!recording) {
startRecording();
Log.w(LOG_TAG, "Start Button Pushed");
btnRecorderControl.setText("Stop");
} else {
// This will trigger the audio recording loop to stop and then set
// isRecorderStart = false;
stopRecording();
Log.w(LOG_TAG, "Stop Button Pushed");
btnRecorderControl.setText("Start");
}
}
}
解决方案
Your camera, most likely, can provide 640x480 preview frames. The fix would be to clip this frame before it is recorded, like this:
@Override
public void onPreviewFrame(byte[] data, Camera camera) {
/* get video data */
if (yuvIplimage != null && recording) {
ByteBuffer bb = yuvIplimage.getByteBuffer(); // resets the buffer
final int startY = imageWidth*(imageHeight-finalImageHeight)/2;
final int lenY = imageWidth*finalImageHeight;
bb.put(data, startY, lenY);
final int startVU = imageWidth*imageHeight + imageWidth*(imageHeight-finalImageHeight)/4;
final int lenVU = imageWidth* finalImageHeight/2;
bb.put(data, startVU, lenVU);
// Log.v(LOG_TAG, "Writing Frame");
try {
long t = 1000 * (System.currentTimeMillis() - startTime);
if (t > recorder.getTimestamp()) {
recorder.setTimestamp(t);
}
recorder.record(yuvIplimage);
} catch (FFmpegFrameRecorder.Exception e) {
Log.e(LOG_TAG, "problem with recorder():", e);
}
}
}
The preview frame has semi-planar YVU format: 640x480 luminance (Y) bytes, followed by 320x240 pairs of chroma (V and U) bytes. We copy to yuvIpImage first the relevant Y, and after that - relevant VU pairs. Note that it is easy and fast because the width you want is same as the native width.
Your camera and camera view should be initialized for 640x480, and recorder - to 640x360. Note that the efficient cropping is only possible when imageWidth==finalImageWidth.
FIX it happens so that IplImage.getByteBuffer() resets the buffer, therefore the fix is to use a temporary bb object.
Note that you will probably want to overlay the preview with a frame that will "hide" margins that you crop this way: our manipulations only change the recorded frames, not the CameraView.
相关推荐
最新文章