Recherche avancée

Sur d’autres sites (7003)

• Recording openCV processed frames on Android using CameraBridgeViewBase

  16 août 2018, par Razvan Ilin

  I basically want to do the same thing as here : Recording Live OpenCV Processing on Android

  I am able to preview the camera using openCV’s JavaCameraView, process the frames (finding color blobs) and then I got stuck when I had to record the video as well.

  I tried to implement the highest voted answer on the above question, but due to my limited knowledge with these technologies, I couldn’t understand exactly how to do it. Then I tried to use ffmpeg and used this as an example : https://github.com/bytedeco/javacv/blob/master/samples/RecordActivity.java

  The point where I got stuck here, was how to pass my CameraBridgeViewBase to the CameraView that is used to record the frames. I’m pretty sure I need to somehow modify my onCreate() method somehow, but I need some pointers on how to approach it.

  I’ll paste my code below :

  OpenCVActivity.java :

  package ch.hepia.iti.opencvnativeandroidstudio;
  
  
  
  import android.Manifest;
  
  import android.content.Context;
  
  import android.content.pm.PackageManager;
  
  import android.hardware.Camera;
  
  import android.media.AudioFormat;
  
  import android.media.AudioRecord;
  
  import android.media.CamcorderProfile;
  
  import android.media.MediaRecorder;
  
  import android.media.MediaScannerConnection;
  
  import android.os.Bundle;
  
  import android.os.Environment;
  
  import android.support.v4.app.ActivityCompat;
  
  import android.support.v7.app.AppCompatActivity;
  
  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.WindowManager;
  
  import android.widget.Button;
  
  import android.widget.LinearLayout;
  
  import android.widget.RelativeLayout;
  
  import android.widget.Toast;
  
  
  
  import org.bytedeco.javacpp.avutil;
  
  import org.bytedeco.javacpp.opencv_core;
  
  import org.bytedeco.javacv.FFmpegFrameFilter;
  
  import org.bytedeco.javacv.FFmpegFrameRecorder;
  
  import org.bytedeco.javacv.Frame;
  
  import org.bytedeco.javacv.FrameFilter;
  
  import org.bytedeco.javacv.OpenCVFrameConverter;
  
  import org.opencv.android.BaseLoaderCallback;
  
  import org.opencv.android.CameraBridgeViewBase;
  
  import org.opencv.android.LoaderCallbackInterface;
  
  import org.opencv.android.OpenCVLoader;
  
  import org.opencv.core.Mat;
  
  import org.opencv.core.Scalar;
  
  
  
  import java.io.File;
  
  import java.io.IOException;
  
  import java.nio.ByteBuffer;
  
  import java.nio.ShortBuffer;
  
  import java.util.Collections;
  
  import java.util.Comparator;
  
  import java.util.List;
  
  
  
  public class OpenCVActivity extends AppCompatActivity implements CameraBridgeViewBase.CvCameraViewListener2, View.OnClickListener {
  
  
  
      private String ffmpeg_link = Environment.getExternalStorageDirectory().getAbsolutePath() + "/test2Video.mp4";
  
      private String LOG_TAG = "VideoTest";
  
  
  
      private static final String TAG = "OCVSample::Activity";
  
      private CameraBridgeViewBase _cameraBridgeViewBase;
  
      private Button recordButton;
  
  
  
      long startTime = 0;
  
      boolean recording = false;
  
  
  
      private FFmpegFrameRecorder recorder;
  
  
  
      private boolean isPreviewOn = false;
  
  
  
      /*Filter information, change boolean to true if adding a fitler*/
  
      private boolean addFilter = true;
  
      private String filterString = "";
  
      FFmpegFrameFilter filter;
  
  
  
      private int sampleAudioRateInHz = 44100;
  
      private int imageWidth = 320;
  
      private int imageHeight = 240;
  
      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 Frame yuvImage = 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 = 640;
  
      private final int live_height = 480;
  
      private int screenWidth, screenHeight;
  
      private Button btnRecorderControl;
  
  
  
      /* The number of seconds in the continuous record loop (or 0 to disable loop). */
  
      final int RECORD_LENGTH = 0;
  
      Frame[] images;
  
      long[] timestamps;
  
      ShortBuffer[] samples;
  
      int imagesIndex, samplesIndex;
  
  
  
      private BaseLoaderCallback _baseLoaderCallback = new BaseLoaderCallback(this) {
  
          @Override
  
          public void onManagerConnected(int status) {
  
              switch (status) {
  
                  case LoaderCallbackInterface.SUCCESS: {
  
                      Log.i(TAG, "OpenCV loaded successfully");
  
                      // Load ndk built module, as specified in moduleName in build.gradle
  
                      // after opencv initialization
  
                      System.loadLibrary("native-lib");
  
                      _cameraBridgeViewBase.enableView();
  
                  }
  
                  break;
  
                  default: {
  
                      super.onManagerConnected(status);
  
                  }
  
              }
  
          }
  
      };
  
  
  
      @Override
  
      public void onCreate(Bundle savedInstanceState) {
  
          super.onCreate(savedInstanceState);
  
  
  
          Display display = ((WindowManager) getSystemService(Context.WINDOW_SERVICE)).getDefaultDisplay();
  
          screenWidth = display.getWidth();
  
          screenHeight = display.getHeight();
  
  
  
          getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
  
          setContentView(R.layout.activity_main);
  
  
  
          // Permissions for Android 6+
  
          ActivityCompat.requestPermissions(OpenCVActivity.this,
  
                  new String[]{Manifest.permission.CAMERA},
  
                  1);
  
  
  
          _cameraBridgeViewBase = (CameraBridgeViewBase) findViewById(R.id.main_surface);
  
          _cameraBridgeViewBase.setVisibility(SurfaceView.VISIBLE);
  
          _cameraBridgeViewBase.setCvCameraViewListener(this);
  
  
  
          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.activity_main, null);
  
          layoutParam = new RelativeLayout.LayoutParams(screenWidth, screenHeight);
  
          topLayout.addView(_cameraBridgeViewBase, layoutParam);
  
  
  
          recordButton = (Button) findViewById(R.id.recorder_control);
  
          recordButton.setText("Start");
  
          recordButton.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();
  
          cameraView = new CameraView(this, cameraDevice);
  
          topLayout.addView(cameraView, layoutParam);
  
      }
  
  
  
      //---------------------------------------
  
      // initialize ffmpeg_recorder
  
      //---------------------------------------
  
      private void initRecorder() {
  
  
  
          Log.w(LOG_TAG,"init recorder");
  
  
  
          if (RECORD_LENGTH > 0) {
  
              imagesIndex = 0;
  
              images = new Frame[RECORD_LENGTH * frameRate];
  
              timestamps = new long[images.length];
  
              for (int i = 0; i < images.length; i++) {
  
                  images[i] = new Frame(imageWidth, imageHeight, Frame.DEPTH_UBYTE, 2);
  
                  timestamps[i] = -1;
  
              }
  
          } else if (yuvImage == null) {
  
              yuvImage = new Frame(imageWidth, imageHeight, Frame.DEPTH_UBYTE, 2);
  
              Log.i(LOG_TAG, "create yuvImage");
  
          }
  
  
  
          Log.i(LOG_TAG, "ffmpeg_url: " + ffmpeg_link);
  
          recorder = new FFmpegFrameRecorder(ffmpeg_link, imageWidth, imageHeight, 1);
  
          recorder.setFormat("mp4");
  
          recorder.setSampleRate(sampleAudioRateInHz);
  
          // Set in the surface changed method
  
          recorder.setFrameRate(frameRate);
  
  
  
          // The filterString  is any ffmpeg filter.
  
          // Here is the link for a list: https://ffmpeg.org/ffmpeg-filters.html
  
          filterString = "transpose=0";
  
          filter = new FFmpegFrameFilter(filterString, imageWidth, imageHeight);
  
  
  
          //default format on android
  
          filter.setPixelFormat(avutil.AV_PIX_FMT_NV21);
  
  
  
          Log.i(LOG_TAG, "recorder initialize success");
  
  
  
          audioRecordRunnable = new AudioRecordRunnable();
  
          audioThread = new Thread(audioRecordRunnable);
  
          runAudioThread = true;
  
      }
  
  
  
      public void startRecording() {
  
  
  
          initRecorder();
  
  
  
          try {
  
              recorder.start();
  
              startTime = System.currentTimeMillis();
  
              recording = true;
  
              audioThread.start();
  
  
  
              if(addFilter) {
  
                  filter.start();
  
              }
  
  
  
          } catch (FFmpegFrameRecorder.Exception | FrameFilter.Exception e) {
  
              e.printStackTrace();
  
          }
  
      }
  
  
  
      public void stopRecording() {
  
  
  
          runAudioThread = false;
  
          try {
  
              audioThread.join();
  
          } catch (InterruptedException e) {
  
              // reset interrupt to be nice
  
              Thread.currentThread().interrupt();
  
              return;
  
          }
  
          audioRecordRunnable = null;
  
          audioThread = null;
  
  
  
          if (recorder != null && recording) {
  
              if (RECORD_LENGTH > 0) {
  
                  Log.v(LOG_TAG,"Writing frames");
  
                  try {
  
                      int firstIndex = imagesIndex % samples.length;
  
                      int lastIndex = (imagesIndex - 1) % images.length;
  
                      if (imagesIndex <= images.length) {
  
                          firstIndex = 0;
  
                          lastIndex = imagesIndex - 1;
  
                      }
  
                      if ((startTime = timestamps[lastIndex] - RECORD_LENGTH * 1000000L) < 0) {
  
                          startTime = 0;
  
                      }
  
                      if (lastIndex < firstIndex) {
  
                          lastIndex += images.length;
  
                      }
  
                      for (int i = firstIndex; i <= lastIndex; i++) {
  
                          long t = timestamps[i % timestamps.length] - startTime;
  
                          if (t >= 0) {
  
                              if (t > recorder.getTimestamp()) {
  
                                  recorder.setTimestamp(t);
  
                              }
  
                              recorder.record(images[i % images.length]);
  
                          }
  
                      }
  
  
  
                      firstIndex = samplesIndex % samples.length;
  
                      lastIndex = (samplesIndex - 1) % samples.length;
  
                      if (samplesIndex <= samples.length) {
  
                          firstIndex = 0;
  
                          lastIndex = samplesIndex - 1;
  
                      }
  
                      if (lastIndex < firstIndex) {
  
                          lastIndex += samples.length;
  
                      }
  
                      for (int i = firstIndex; i <= lastIndex; i++) {
  
                          recorder.recordSamples(samples[i % samples.length]);
  
                      }
  
                  } catch (FFmpegFrameRecorder.Exception e) {
  
                      Log.v(LOG_TAG,e.getMessage());
  
                      e.printStackTrace();
  
                  }
  
              }
  
  
  
              recording = false;
  
              Log.v(LOG_TAG,"Finishing recording, calling stop and release on recorder");
  
              try {
  
                  recorder.stop();
  
                  recorder.release();
  
                  filter.stop();
  
                  filter.release();
  
              } catch (FFmpegFrameRecorder.Exception | FrameFilter.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;
  
              ShortBuffer 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);
  
  
  
              if (RECORD_LENGTH > 0) {
  
                  samplesIndex = 0;
  
                  samples = new ShortBuffer[RECORD_LENGTH * sampleAudioRateInHz * 2 / bufferSize + 1];
  
                  for (int i = 0; i < samples.length; i++) {
  
                      samples[i] = ShortBuffer.allocate(bufferSize);
  
                  }
  
              } else {
  
                  audioData = ShortBuffer.allocate(bufferSize);
  
              }
  
  
  
              Log.d(LOG_TAG, "audioRecord.startRecording()");
  
              audioRecord.startRecording();
  
  
  
              /* ffmpeg_audio encoding loop */
  
              while (runAudioThread) {
  
                  if (RECORD_LENGTH > 0) {
  
                      audioData = samples[samplesIndex++ % samples.length];
  
                      audioData.position(0).limit(0);
  
                  }
  
                  //Log.v(LOG_TAG,"recording? " + recording);
  
                  bufferReadResult = audioRecord.read(audioData.array(), 0, audioData.capacity());
  
                  audioData.limit(bufferReadResult);
  
                  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) {
  
                          if (RECORD_LENGTH <= 0) try {
  
                              recorder.recordSamples(audioData);
  
                              //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, Camera.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) {
  
              stopPreview();
  
  
  
              Camera.Parameters camParams = mCamera.getParameters();
  
              List sizes = camParams.getSupportedPreviewSizes();
  
              // Sort the list in ascending order
  
              Collections.sort(sizes, new Comparator() {
  
  
  
                  public int compare(final Camera.Size a, final Camera.Size b) {
  
                      return a.width * a.height - b.width * b.height;
  
                  }
  
              });
  
  
  
              // Pick the first preview size that is equal or bigger, or pick the last (biggest) option if we cannot
  
              // reach the initial settings of imageWidth/imageHeight.
  
              for (int i = 0; i < sizes.size(); i++) {
  
                  if ((sizes.get(i).width >= imageWidth && sizes.get(i).height >= imageHeight) || i == sizes.size() - 1) {
  
                      imageWidth = sizes.get(i).width;
  
                      imageHeight = sizes.get(i).height;
  
                      Log.v(LOG_TAG, "Changed to supported resolution: " + imageWidth + "x" + imageHeight);
  
                      break;
  
                  }
  
              }
  
              camParams.setPreviewSize(imageWidth, imageHeight);
  
  
  
              Log.v(LOG_TAG,"Setting imageWidth: " + imageWidth + " imageHeight: " + imageHeight + " frameRate: " + frameRate);
  
  
  
              camParams.setPreviewFrameRate(frameRate);
  
              Log.v(LOG_TAG,"Preview Framerate: " + camParams.getPreviewFrameRate());
  
  
  
              mCamera.setParameters(camParams);
  
  
  
              // Set the holder (which might have changed) again
  
              try {
  
                  mCamera.setPreviewDisplay(holder);
  
                  mCamera.setPreviewCallback(CameraView.this);
  
                  startPreview();
  
              } catch (Exception e) {
  
                  Log.e(LOG_TAG, "Could not set preview display in surfaceChanged");
  
              }
  
          }
  
  
  
          @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) {
  
              if (audioRecord == null || audioRecord.getRecordingState() != AudioRecord.RECORDSTATE_RECORDING) {
  
                  startTime = System.currentTimeMillis();
  
                  return;
  
              }
  
              if (RECORD_LENGTH > 0) {
  
                  int i = imagesIndex++ % images.length;
  
                  yuvImage = images[i];
  
                  timestamps[i] = 1000 * (System.currentTimeMillis() - startTime);
  
              }
  
  
  
  
  
              /* get video data */
  
              if (yuvImage != null && recording) {
  
                  ((ByteBuffer)yuvImage.image[0].position(0)).put(data);
  
  
  
                  if (RECORD_LENGTH <= 0) try {
  
                      Log.v(LOG_TAG,"Writing Frame");
  
                      long t = 1000 * (System.currentTimeMillis() - startTime);
  
                      if (t > recorder.getTimestamp()) {
  
                          recorder.setTimestamp(t);
  
                      }
  
  
  
                      if(addFilter) {
  
                          filter.push(yuvImage);
  
                          Frame frame2;
  
                          while ((frame2 = filter.pull()) != null) {
  
                              recorder.record(frame2, filter.getPixelFormat());
  
                          }
  
                      } else {
  
                          recorder.record(yuvImage);
  
                      }
  
                  } catch (FFmpegFrameRecorder.Exception | FrameFilter.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");
  
              recordButton.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");
  
              recordButton.setText("Start");
  
          }
  
      }
  
  
  
      @Override
  
      public void onPause() {
  
          super.onPause();
  
          disableCamera();
  
      }
  
  
  
      @Override
  
      public void onResume() {
  
          super.onResume();
  
          if (!OpenCVLoader.initDebug()) {
  
              Log.d(TAG, "Internal OpenCV library not found. Using OpenCV Manager for initialization");
  
              OpenCVLoader.initAsync(OpenCVLoader.OPENCV_VERSION_3_0_0, this, _baseLoaderCallback);
  
          } else {
  
              Log.d(TAG, "OpenCV library found inside package. Using it!");
  
              _baseLoaderCallback.onManagerConnected(LoaderCallbackInterface.SUCCESS);
  
          }
  
      }
  
  
  
      @Override
  
      public void onRequestPermissionsResult(int requestCode, String permissions[], int[] grantResults) {
  
          switch (requestCode) {
  
              case 1: {
  
                  // If request is cancelled, the result arrays are empty.
  
                  if (grantResults.length > 0
  
                          && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
  
                      // permission was granted, yay! Do the
  
                      // contacts-related task you need to do.
  
                  } else {
  
                      // permission denied, boo! Disable the
  
                      // functionality that depends on this permission.
  
                      Toast.makeText(OpenCVActivity.this, "Permission denied to read your External storage", Toast.LENGTH_SHORT).show();
  
                  }
  
                  return;
  
              }
  
              // other 'case' lines to check for other
  
              // permissions this app might request
  
          }
  
      }
  
  
  
      public void onDestroy() {
  
          super.onDestroy();
  
          disableCamera();
  
      }
  
  
  
      public void disableCamera() {
  
          if (_cameraBridgeViewBase != null)
  
              _cameraBridgeViewBase.disableView();
  
      }
  
  
  
      public void onCameraViewStarted(int width, int height) {
  
          setup();
  
      }
  
  
  
      public void onCameraViewStopped() {
  
      }
  
  
  
      public Mat onCameraFrame(CameraBridgeViewBase.CvCameraViewFrame inputFrame) {
  
          Mat rgba = inputFrame.rgba();
  
          salt(rgba.getNativeObjAddr());
  
  
  
          return rgba;
  
      }
  
  
  
  
  
      public native void salt(long matAddrGray);
  
      public native void setup();
  
  }

  activity_main.xml :

  <?xml version="1.0" encoding="utf-8"?>
  
  <linearlayout>
  
  
  
      
  
  
  
      <button></button>
  
  
  
  </linearlayout>

  Could really use some help with this. Has anyone done this before ?

• VP8 for Real-time Video Applications

  15 février 2011, par noreply@blogger.com (John Luther)

  With the growing interest in videoconferencing on the web platform, it’s a good time to explore the features of VP8 that make it an exceptionally good codec for real-time applications like videoconferencing.

  VP8 Design History & Features

  Real-time applications were a primary use case when VP8 was designed. The VP8 encoder has features specifically engineered to overcome the challenges inherent in compressing and transmitting real-time video data.
  

  • Processor-adaptive encoding. 16 encoder complexity levels automatically (or manually) adjust encoder features such as motion search strategy, quantizer optimizations, and loop filtering strength.
  • Encoder can be configured to use a target percentage of the host CPU.
    Ability to measure the time taken to encode each frame and adjust encoder complexity dynamically to keep the encoding time per frame constant
  • Robust error recovery (packet retransmission, forward error correction, recovery frame/new keyframe requests)
  • Temporal scalability (i.e., a single video bitstream that can degrade as needed depending on a participant’s available bandwidth)
  • Highly efficient decoding performance on low-power devices. Conventional video technology has grown to a state of complexity where dedicated hardware chips are needed to make it work well. With VP8, software-based solutions have proven to meet customer needs without requiring specialized hardware.

  For a more information about real-time video features in VP8, see the slide presentation by WebM Project engineer Paul Wilkins (PDF file).

  Commercially Available Products

  Millions of people around the world have been using VP7/8 for video chat for years. VP8 is deployed in some of today’s most popular consumer videoconferencing applications, including Skype (group video calling), Sightspeed, ooVoo and Logitech Vid. All of these vendors are active WebM project supporters. VP8’s predecessor, VP7, has been used in Skype video calling since 2005 and is supported in the new Skype app for iPhone. Other real-time VP8 implementations are coming soon, including ooVoo, and VP8 will play a leading role in Google’s plans for real-time applications on the web platform.

  Real-time applications will be extremely important as the web platform matures. The WebM community has made significant improvements in VP8 for real-time use cases since our launch and will continue to do so in the future.

  John Luther is Product Manager of the WebM Project.

  

• Availability of WebM (VP8) Video Hardware IP Designs

  10 janvier 2011, par noreply@blogger.com (John Luther)

  Hello from the frigid city of Oulu, in the far north of Finland. Our WebM hardware development team, formerly part of On2 Technologies, is now up-to-speed and working hard on a number of video efforts for WebM.
  

  • VP8 (the video codec used in WebM) hardware decoder IP is available from Google for semiconductor companies who want to support high-quality WebM playback in their chipsets.
  • The Oulu team will release the first VP8 video hardware encoder IP in the first quarter of 2011. We have the IP running in an FPGA environment, and rigorous testing is underway. Once all features have been tested and implemented, the encoder will be launched as well.

  WebM video hardware IPs are implemented and delivered as RTL (VHDL/Verilog) source code, which is a register-level hardware description language for creating digital circuit designs. The code is based on the Hantro brand video IP from On2, which has been successfully deployed by numerous chipset companies around the world. Our designs support VP8 up to 1080p resolution and can run 30 or 60fps, depending on the foundry process and hardware clock frequency.

  The WebM/VP8 hardware decoder implementation has already been licensed to over twenty partners and is proven in silicon. We expect the first commercial chips to integrate our VP8 decoder IP to be available in the first quarter of 2011. For example, Chinese semiconductor maker Rockchip last week demonstrated full WebM hardware playback on their new RK29xx series processor at CES in Las Vegas (video below).
  

  
  Note : To view the video in WebM format, ensure that you’ve enrolled in the YouTube HTML5 trial and are using a WebM-compatible browser. You can also view the video on YouTube.

  Hardware implementations of the VP8 encoder also bring exciting possibilities for WebM in portable devices. Not only can hardware-accelerated devices play high-quality WebM content, but hardware encoding also enables high-resolution, real-time video communications apps on the same devices. For example, when VP8 video encoding is fully off-loaded to a hardware accelerator, you can run 720p or even 1080p video conferencing at full framerate on a portable device with minimal battery use.

  The WebM hardware video IP team will be focusing on further developing the VP8 hardware designs while also helping our semiconductor partners to implement WebM video compression in their chipsets. If you have any questions, please visit our Hardware page.

  Happy New Year to the WebM community !

  Jani Huoponen, Product Manager
  Aki Kuusela, Engineering Manager