title: Camera2Video sample application - crash
body: <p>I try to start sample Camera2Video. I create new virtual device and use emulated camera with green or red foursquare. Application show preview wirking, but when i press start button - it`s crash with error:</p>
  
  <blockquote>
    <p>E/BufferQueueProducer: [GraphicBufferSource] queueBuffer: BufferQueue
    has been abandoned
        E/Surface: queueBuffer: error queuing buffer to SurfaceTexture, -19
        E/BufferQueueProducer: [GraphicBufferSource] dequeueBuffer: BufferQueue has been abandoned
        E/EGL_emulation: tid 4026: swapBuffers(322): error 0x3003 (EGL_BAD_ALLOC)
        E/CameraDeviceGLThread-0: Received exception on GL render thread:                                                             java.lang.IllegalStateException: swapBuffers: EGL error: 0x3003<br>
    at
    android.hardware.camera2.legacy.SurfaceTextureRenderer.checkEglError(SurfaceTextureRenderer.java:530)
    at
    android.hardware.camera2.legacy.SurfaceTextureRenderer.swapBuffers(SurfaceTextureRenderer.java:523)
    at
    android.hardware.camera2.legacy.SurfaceTextureRenderer.drawIntoSurfaces(SurfaceTextureRenderer.java:727)
    at
    android.hardware.camera2.legacy.GLThreadManager$1.handleMessage(GLThreadManager.java:105)
        at android.os.Handler.dispatchMessage(Handler.java:98)
        at android.os.Looper.loop(Looper.java:148)
        at android.os.HandlerThread.run(HandlerThread.java:61)
        I/CameraDeviceState: Legacy camera service transitioning to state ERROR
        E/RequestThread-0: Timed out while waiting for request to complete.
        W/CaptureCollector: Preview buffers dropped for request: 0
        E/CameraDeviceState: Cannot receive result while in state: 0
        E/CameraDeviceState: Cannot receive result while in state: 0
        E/CameraDeviceState: Cannot receive result while in state: 0
        E/Surface: getSlotFromBufferLocked: unknown buffer: 0xab751140</p>
  </blockquote>
  
  <p>This is class of sample application:
  CameraActivity:</p>
  
  <pre><code>package com.example.android.camera2video;
  import android.app.Activity;
  import android.os.Bundle;
  public class CameraActivity extends Activity {
      @Override
      protected void onCreate(Bundle savedInstanceState) {
          super.onCreate(savedInstanceState);
          setContentView(R.layout.activity_camera);
          if (null == savedInstanceState) {
              getFragmentManager().beginTransaction()
                      .replace(R.id.container, Camera2VideoFragment.newInstance())
                      .commit();
          }
      }
  }
  </code></pre>
  
  <p>AutoFitTextureView:</p>
  
  <pre><code>package com.example.android.camera2video;
  import android.content.Context;
  import android.util.AttributeSet;
  import android.view.TextureView;
  public class AutoFitTextureView extends TextureView {
      private int mRatioWidth = 0;
      private int mRatioHeight = 0;
  
      public AutoFitTextureView(Context context) {
          this(context, null);
      }
  
      public AutoFitTextureView(Context context, AttributeSet attrs) {
          this(context, attrs, 0);
      }
  
      public AutoFitTextureView(Context context, AttributeSet attrs, int defStyle) {
          super(context, attrs, defStyle);
      }
  
      public void setAspectRatio(int width, int height) {
          if (width &lt; 0 || height &lt; 0) {
              throw new IllegalArgumentException("Size cannot be negative.");
          }
          mRatioWidth = width;
          mRatioHeight = height;
          requestLayout();
      }
  
      @Override
      protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
          super.onMeasure(widthMeasureSpec, heightMeasureSpec);
          int width = MeasureSpec.getSize(widthMeasureSpec);
          int height = MeasureSpec.getSize(heightMeasureSpec);
          if (0 == mRatioWidth || 0 == mRatioHeight) {
              setMeasuredDimension(width, height);
          } else {
              if (width &lt; height * mRatioWidth / mRatioHeight) {
                  setMeasuredDimension(width, width * mRatioHeight / mRatioWidth);
              } else {
                  setMeasuredDimension(height * mRatioWidth / mRatioHeight, height);
              }
          }
      }
  }
  </code></pre>
  
  <p>and Camera2VideoFragment:</p>
  
  <pre><code>package com.example.android.camera2video;
  
  import android.Manifest;
  import android.app.Activity;
  import android.app.AlertDialog;
  import android.app.Dialog;
  import android.app.DialogFragment;
  import android.app.Fragment;
  import android.content.Context;
  import android.content.DialogInterface;
  import android.content.pm.PackageManager;
  import android.content.res.Configuration;
  import android.graphics.Matrix;
  import android.graphics.RectF;
  import android.graphics.SurfaceTexture;
  import android.hardware.camera2.CameraAccessException;
  import android.hardware.camera2.CameraCaptureSession;
  import android.hardware.camera2.CameraCharacteristics;
  import android.hardware.camera2.CameraDevice;
  import android.hardware.camera2.CameraManager;
  import android.hardware.camera2.CameraMetadata;
  import android.hardware.camera2.CaptureRequest;
  import android.hardware.camera2.params.StreamConfigurationMap;
  import android.media.MediaRecorder;
  import android.os.Bundle;
  import android.os.Handler;
  import android.os.HandlerThread;
  import android.support.annotation.NonNull;
  import android.support.v13.app.FragmentCompat;
  import android.support.v4.app.ActivityCompat;
  import android.util.Log;
  import android.util.Size;
  import android.util.SparseIntArray;
  import android.view.LayoutInflater;
  import android.view.Surface;
  import android.view.TextureView;
  import android.view.View;
  import android.view.ViewGroup;
  import android.widget.Button;
  import android.widget.Toast;
  
  import java.io.File;
  import java.io.IOException;
  import java.util.ArrayList;
  import java.util.Collections;
  import java.util.Comparator;
  import java.util.List;
  import java.util.concurrent.Semaphore;
  import java.util.concurrent.TimeUnit;
  
  public class Camera2VideoFragment extends Fragment
          implements View.OnClickListener, FragmentCompat.OnRequestPermissionsResultCallback {
  
      private static final SparseIntArray ORIENTATIONS = new SparseIntArray();
  
      private static final String TAG = "Camera2VideoFragment";
      private static final int REQUEST_VIDEO_PERMISSIONS = 1;
      private static final String FRAGMENT_DIALOG = "dialog";
  
      private static final String[] VIDEO_PERMISSIONS = {
              Manifest.permission.CAMERA,
              Manifest.permission.RECORD_AUDIO,
      };
  
      static {
          ORIENTATIONS.append(Surface.ROTATION_0, 90);
          ORIENTATIONS.append(Surface.ROTATION_90, 0);
          ORIENTATIONS.append(Surface.ROTATION_180, 270);
          ORIENTATIONS.append(Surface.ROTATION_270, 180);
      }
  
      private AutoFitTextureView mTextureView;
  
      private Button mButtonVideo;
  
      private CameraDevice mCameraDevice;
  
      private CameraCaptureSession mPreviewSession;
  
       private TextureView.SurfaceTextureListener mSurfaceTextureListener
              = new TextureView.SurfaceTextureListener() {
  
          @Override
          public void onSurfaceTextureAvailable(SurfaceTexture surfaceTexture,
                                                int width, int height) {
              openCamera(width, height);
          }
  
          @Override
          public void onSurfaceTextureSizeChanged(SurfaceTexture surfaceTexture,
                                                  int width, int height) {
              configureTransform(width, height);
          }
  
          @Override
          public boolean onSurfaceTextureDestroyed(SurfaceTexture surfaceTexture) {
              return true;
          }
  
          @Override
          public void onSurfaceTextureUpdated(SurfaceTexture surfaceTexture) {
          }
  
      };
  
      private Size mPreviewSize;
  
      private Size mVideoSize;
  
      private CaptureRequest.Builder mPreviewBuilder;
  
      private MediaRecorder mMediaRecorder;
  
      private boolean mIsRecordingVideo;
  
      private HandlerThread mBackgroundThread;
  
      private Handler mBackgroundHandler;
  
      private Semaphore mCameraOpenCloseLock = new Semaphore(1);
  
      private CameraDevice.StateCallback mStateCallback = new CameraDevice.StateCallback() {
  
          @Override
          public void onOpened(CameraDevice cameraDevice) {
              mCameraDevice = cameraDevice;
              startPreview();
              mCameraOpenCloseLock.release();
              if (null != mTextureView) {
                  configureTransform(mTextureView.getWidth(), mTextureView.getHeight());
              }
          }
  
          @Override
          public void onDisconnected(CameraDevice cameraDevice) {
              mCameraOpenCloseLock.release();
              cameraDevice.close();
              mCameraDevice = null;
          }
  
          @Override
          public void onError(CameraDevice cameraDevice, int error) {
              mCameraOpenCloseLock.release();
              cameraDevice.close();
              mCameraDevice = null;
              Activity activity = getActivity();
              if (null != activity) {
                  activity.finish();
              }
          }
  
      };
  
      public static Camera2VideoFragment newInstance() {
          return new Camera2VideoFragment();
      }
  
      private static Size chooseVideoSize(Size[] choices) {
          for (Size size : choices) {
              if (size.getWidth() == size.getHeight() * 4 / 3 &amp;&amp; size.getWidth() &lt;= 1080) {
                  return size;
              }
          }
          Log.e(TAG, "Couldn't find any suitable video size");
          return choices[choices.length - 1];
      }
  
  
      private static Size chooseOptimalSize(Size[] choices, int width, int height, Size aspectRatio) {
          // Collect the supported resolutions that are at least as big as the preview Surface
          List&lt;Size&gt; bigEnough = new ArrayList&lt;Size&gt;();
          int w = aspectRatio.getWidth();
          int h = aspectRatio.getHeight();
          for (Size option : choices) {
              if (option.getHeight() == option.getWidth() * h / w &amp;&amp;
                      option.getWidth() &gt;= width &amp;&amp; option.getHeight() &gt;= height) {
                  bigEnough.add(option);
              }
          }
  
          // Pick the smallest of those, assuming we found any
          if (bigEnough.size() &gt; 0) {
              return Collections.min(bigEnough, new CompareSizesByArea());
          } else {
              Log.e(TAG, "Couldn't find any suitable preview size");
              return choices[0];
          }
      }
  
      @Override
      public View onCreateView(LayoutInflater inflater, ViewGroup container,
                               Bundle savedInstanceState) {
          return inflater.inflate(R.layout.fragment_camera2_video, container, false);
      }
  
      @Override
      public void onViewCreated(final View view, Bundle savedInstanceState) {
          mTextureView = (AutoFitTextureView) view.findViewById(R.id.texture);
          mButtonVideo = (Button) view.findViewById(R.id.video);
          mButtonVideo.setOnClickListener(this);
          view.findViewById(R.id.info).setOnClickListener(this);
      }
  
      @Override
      public void onResume() {
          super.onResume();
          startBackgroundThread();
          if (mTextureView.isAvailable()) {
              openCamera(mTextureView.getWidth(), mTextureView.getHeight());
          } else {
              mTextureView.setSurfaceTextureListener(mSurfaceTextureListener);
          }
      }
  
      @Override
      public void onPause() {
          closeCamera();
          stopBackgroundThread();
          super.onPause();
      }
  
      @Override
      public void onClick(View view) {
          switch (view.getId()) {
              case R.id.video: {
                  if (mIsRecordingVideo) {
                      stopRecordingVideo();
                  } else {
                      startRecordingVideo();
                  }
                  break;
              }
              case R.id.info: {
                  Activity activity = getActivity();
                  if (null != activity) {
                      new AlertDialog.Builder(activity)
                              .setMessage(R.string.intro_message)
                              .setPositiveButton(android.R.string.ok, null)
                              .show();
                  }
                  break;
              }
          }
      }
  
      /**
       * Starts a background thread and its {@link Handler}.
       */
      private void startBackgroundThread() {
          mBackgroundThread = new HandlerThread("CameraBackground");
          mBackgroundThread.start();
          mBackgroundHandler = new Handler(mBackgroundThread.getLooper());
      }
  
      /**
       * Stops the background thread and its {@link Handler}.
       */
      private void stopBackgroundThread() {
          mBackgroundThread.quitSafely();
          try {
              mBackgroundThread.join();
              mBackgroundThread = null;
              mBackgroundHandler = null;
          } catch (InterruptedException e) {
              e.printStackTrace();
          }
      }
  
      /**
       * Gets whether you should show UI with rationale for requesting permissions.
       *
       * @param permissions The permissions your app wants to request.
       * @return Whether you can show permission rationale UI.
       */
      private boolean shouldShowRequestPermissionRationale(String[] permissions) {
          for (String permission : permissions) {
              if (FragmentCompat.shouldShowRequestPermissionRationale(this, permission)) {
                  return true;
              }
          }
          return false;
      }
  
      /**
       * Requests permissions needed for recording video.
       */
      private void requestVideoPermissions() {
          if (shouldShowRequestPermissionRationale(VIDEO_PERMISSIONS)) {
              new ConfirmationDialog().show(getChildFragmentManager(), FRAGMENT_DIALOG);
          } else {
              FragmentCompat.requestPermissions(this, VIDEO_PERMISSIONS, REQUEST_VIDEO_PERMISSIONS);
          }
      }
  
      @Override
      public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions,
                                             @NonNull int[] grantResults) {
          Log.d(TAG, "onRequestPermissionsResult");
          if (requestCode == REQUEST_VIDEO_PERMISSIONS) {
              if (grantResults.length == VIDEO_PERMISSIONS.length) {
                  for (int result : grantResults) {
                      if (result != PackageManager.PERMISSION_GRANTED) {
                          ErrorDialog.newInstance(getString(R.string.permission_request))
                                  .show(getChildFragmentManager(), FRAGMENT_DIALOG);
                          break;
                      }
                  }
              } else {
                  ErrorDialog.newInstance(getString(R.string.permission_request))
                          .show(getChildFragmentManager(), FRAGMENT_DIALOG);
              }
          } else {
              super.onRequestPermissionsResult(requestCode, permissions, grantResults);
          }
      }
  
      private boolean hasPermissionsGranted(String[] permissions) {
          for (String permission : permissions) {
              if (ActivityCompat.checkSelfPermission(getActivity(), permission)
                      != PackageManager.PERMISSION_GRANTED) {
                  return false;
              }
          }
          return true;
      }
  
      /**
       * Tries to open a {@link CameraDevice}. The result is listened by `mStateCallback`.
       */
      private void openCamera(int width, int height) {
          if (!hasPermissionsGranted(VIDEO_PERMISSIONS)) {
              requestVideoPermissions();
              return;
          }
          final Activity activity = getActivity();
          if (null == activity || activity.isFinishing()) {
              return;
          }
          CameraManager manager = (CameraManager) activity.getSystemService(Context.CAMERA_SERVICE);
          try {
              Log.d(TAG, "tryAcquire");
              if (!mCameraOpenCloseLock.tryAcquire(2500, TimeUnit.MILLISECONDS)) {
                  throw new RuntimeException("Time out waiting to lock camera opening.");
              }
              String cameraId = manager.getCameraIdList()[0];
  
              // Choose the sizes for camera preview and video recording
              CameraCharacteristics characteristics = manager.getCameraCharacteristics(cameraId);
              StreamConfigurationMap map = characteristics
                      .get(CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP);
              mVideoSize = chooseVideoSize(map.getOutputSizes(MediaRecorder.class));
              mPreviewSize = chooseOptimalSize(map.getOutputSizes(SurfaceTexture.class),
                      width, height, mVideoSize);
  
              int orientation = getResources().getConfiguration().orientation;
              if (orientation == Configuration.ORIENTATION_LANDSCAPE) {
                  mTextureView.setAspectRatio(mPreviewSize.getWidth(), mPreviewSize.getHeight());
              } else {
                  mTextureView.setAspectRatio(mPreviewSize.getHeight(), mPreviewSize.getWidth());
              }
              configureTransform(width, height);
              mMediaRecorder = new MediaRecorder();
              manager.openCamera(cameraId, mStateCallback, null);
          } catch (CameraAccessException e) {
              Toast.makeText(activity, "Cannot access the camera.", Toast.LENGTH_SHORT).show();
              activity.finish();
          } catch (NullPointerException e) {
              // Currently an NPE is thrown when the Camera2API is used but not supported on the
              // device this code runs.
              ErrorDialog.newInstance(getString(R.string.camera_error))
                      .show(getChildFragmentManager(), FRAGMENT_DIALOG);
          } catch (InterruptedException e) {
              throw new RuntimeException("Interrupted while trying to lock camera opening.");
          }
      }
  
      private void closeCamera() {
          try {
              mCameraOpenCloseLock.acquire();
              if (null != mCameraDevice) {
                  mCameraDevice.close();
                  mCameraDevice = null;
              }
              if (null != mMediaRecorder) {
                  mMediaRecorder.release();
                  mMediaRecorder = null;
              }
          } catch (InterruptedException e) {
              throw new RuntimeException("Interrupted while trying to lock camera closing.");
          } finally {
              mCameraOpenCloseLock.release();
          }
      }
  
  
      private void startPreview() {
          if (null == mCameraDevice || !mTextureView.isAvailable() || null == mPreviewSize) {
              return;
          }
          try {
              setUpMediaRecorder();
              SurfaceTexture texture = mTextureView.getSurfaceTexture();
              assert texture != null;
              texture.setDefaultBufferSize(mPreviewSize.getWidth(), mPreviewSize.getHeight());
              mPreviewBuilder = mCameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_RECORD);
              List&lt;Surface&gt; surfaces = new ArrayList&lt;Surface&gt;();
  
              Surface previewSurface = new Surface(texture);
              surfaces.add(previewSurface);
              mPreviewBuilder.addTarget(previewSurface);
  
              Surface recorderSurface = mMediaRecorder.getSurface();
              surfaces.add(recorderSurface);
              mPreviewBuilder.addTarget(recorderSurface);
  
              mCameraDevice.createCaptureSession(surfaces, new CameraCaptureSession.StateCallback() {
  
                  @Override
                  public void onConfigured(CameraCaptureSession cameraCaptureSession) {
                      mPreviewSession = cameraCaptureSession;
                      updatePreview();
                  }
  
                  @Override
                  public void onConfigureFailed(CameraCaptureSession cameraCaptureSession) {
                      Activity activity = getActivity();
                      if (null != activity) {
                          Toast.makeText(activity, "Failed", Toast.LENGTH_SHORT).show();
                      }
                  }
              }, mBackgroundHandler);
          } catch (CameraAccessException e) {
              e.printStackTrace();
          } catch (IOException e) {
              e.printStackTrace();
          }
      }
  
        private void updatePreview() {
          if (null == mCameraDevice) {
              return;
          }
          try {
              setUpCaptureRequestBuilder(mPreviewBuilder);
              HandlerThread thread = new HandlerThread("CameraPreview");
              thread.start();
              mPreviewSession.setRepeatingRequest(mPreviewBuilder.build(), null, mBackgroundHandler);
          } catch (CameraAccessException e) {
              e.printStackTrace();
          }
      }
  
      private void setUpCaptureRequestBuilder(CaptureRequest.Builder builder) {
          builder.set(CaptureRequest.CONTROL_MODE, CameraMetadata.CONTROL_MODE_AUTO);
      }
  
      private void configureTransform(int viewWidth, int viewHeight) {
          Activity activity = getActivity();
          if (null == mTextureView || null == mPreviewSize || null == activity) {
              return;
          }
          int rotation = activity.getWindowManager().getDefaultDisplay().getRotation();
          Matrix matrix = new Matrix();
          RectF viewRect = new RectF(0, 0, viewWidth, viewHeight);
          RectF bufferRect = new RectF(0, 0, mPreviewSize.getHeight(), mPreviewSize.getWidth());
          float centerX = viewRect.centerX();
          float centerY = viewRect.centerY();
          if (Surface.ROTATION_90 == rotation || Surface.ROTATION_270 == rotation) {
              bufferRect.offset(centerX - bufferRect.centerX(), centerY - bufferRect.centerY());
              matrix.setRectToRect(viewRect, bufferRect, Matrix.ScaleToFit.FILL);
              float scale = Math.max(
                      (float) viewHeight / mPreviewSize.getHeight(),
                      (float) viewWidth / mPreviewSize.getWidth());
              matrix.postScale(scale, scale, centerX, centerY);
              matrix.postRotate(90 * (rotation - 2), centerX, centerY);
          }
          mTextureView.setTransform(matrix);
      }
  
      private void setUpMediaRecorder() throws IOException {
          final Activity activity = getActivity();
          if (null == activity) {
              return;
          }
          mMediaRecorder.setAudioSource(MediaRecorder.AudioSource.MIC);
          mMediaRecorder.setVideoSource(MediaRecorder.VideoSource.SURFACE);
          mMediaRecorder.setOutputFormat(MediaRecorder.OutputFormat.MPEG_4);
          mMediaRecorder.setOutputFile(getVideoFile(activity).getAbsolutePath());
          mMediaRecorder.setVideoEncodingBitRate(10000000);
          mMediaRecorder.setVideoFrameRate(30);
          mMediaRecorder.setVideoSize(mVideoSize.getWidth(), mVideoSize.getHeight());
          mMediaRecorder.setVideoEncoder(MediaRecorder.VideoEncoder.H264);
          mMediaRecorder.setAudioEncoder(MediaRecorder.AudioEncoder.AAC);
          int rotation = activity.getWindowManager().getDefaultDisplay().getRotation();
          int orientation = ORIENTATIONS.get(rotation);
          mMediaRecorder.setOrientationHint(orientation);
          mMediaRecorder.prepare();
      }
  
      private File getVideoFile(Context context) {
          return new File(context.getExternalFilesDir(null), "video.mp4");
      }
  
      private void startRecordingVideo() {
          try {
              // UI
              mButtonVideo.setText(R.string.stop);
              mIsRecordingVideo = true;
  
              // Start recording
              mMediaRecorder.start();
          } catch (IllegalStateException e) {
              e.printStackTrace();
          }
      }
  
      private void stopRecordingVideo() {
          // UI
          mIsRecordingVideo = false;
          mButtonVideo.setText(R.string.record);
          // Stop recording
          mMediaRecorder.stop();
          mMediaRecorder.reset();
          Activity activity = getActivity();
          if (null != activity) {
              Toast.makeText(activity, "Video saved: " + getVideoFile(activity),
                      Toast.LENGTH_SHORT).show();
          }
          startPreview();
      }
  
      static class CompareSizesByArea implements Comparator&lt;Size&gt; {
  
          @Override
          public int compare(Size lhs, Size rhs) {
              // We cast here to ensure the multiplications won't overflow
              return Long.signum((long) lhs.getWidth() * lhs.getHeight() -
                      (long) rhs.getWidth() * rhs.getHeight());
          }
  
      }
  
      public static class ErrorDialog extends DialogFragment {
  
          private static final String ARG_MESSAGE = "message";
  
          public static ErrorDialog newInstance(String message) {
              ErrorDialog dialog = new ErrorDialog();
              Bundle args = new Bundle();
              args.putString(ARG_MESSAGE, message);
              dialog.setArguments(args);
              return dialog;
          }
  
          @Override
          public Dialog onCreateDialog(Bundle savedInstanceState) {
              final Activity activity = getActivity();
              return new AlertDialog.Builder(activity)
                      .setMessage(getArguments().getString(ARG_MESSAGE))
                      .setPositiveButton(android.R.string.ok, new DialogInterface.OnClickListener() {
                          @Override
                          public void onClick(DialogInterface dialogInterface, int i) {
                              activity.finish();
                          }
                      })
                      .create();
          }
  
      }
  
      public static class ConfirmationDialog extends DialogFragment {
  
          @Override
          public Dialog onCreateDialog(Bundle savedInstanceState) {
              final Fragment parent = getParentFragment();
              return new AlertDialog.Builder(getActivity())
                      .setMessage(R.string.permission_request)
                      .setPositiveButton(android.R.string.ok, new DialogInterface.OnClickListener() {
                          @Override
                          public void onClick(DialogInterface dialog, int which) {
                              FragmentCompat.requestPermissions(parent, VIDEO_PERMISSIONS,
                                      REQUEST_VIDEO_PERMISSIONS);
                          }
                      })
                      .setNegativeButton(android.R.string.cancel,
                              new DialogInterface.OnClickListener() {
                                  @Override
                                  public void onClick(DialogInterface dialog, int which) {
                                      parent.getActivity().finish();
                                  }
                              })
                      .create();
          }
  
      }
  
  }
  </code></pre>
  
  <p>I`m beginner in android, please help - Why is this error? 
  And how I can fix this error?</p>
  
  <p>Camera2Video sample available on git repository and write - that all works.</p>
  
  <p>Thank you.</p>