rays 0.1.16 → 0.1.17

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 257d69d9a622000399ced2465f798ffa54db2e1943cc9eeea9c1a0d3f40503c2
-  data.tar.gz: 302a565d951db2bdbb8d7fcf114fc26064ed55e9b1936f7683f24b77975d70d9
+  metadata.gz: 9b9970ac7078fc1ff19c2039b5d9c3714eeaaba98d5825e374639707231fe212
+  data.tar.gz: 12d43f68907b92bc4fcc293273dfaf1353e17006654e245973d3866f31cac2de
 SHA512:
-  metadata.gz: 69618fc55b5fe15c1f13c49f4e52e468f734ceb874a5cffc0186747595ad0df06f096b63a2b6e6e8271327385373e1c9efe6b23954c94064e961d3e547658577
-  data.tar.gz: d0c8e174262e60747382005cefcc0c7ebf7a03d8300ea607976f861dcc0dbec61bff530aad0d890df4cfd05b116cc3b6f5d119a97be6c4e63e061dd89731b0df
+  metadata.gz: 4f732d776a9cf8940d22dde937d72d25a38fda8c8842484d525ae105c0ce591dd20b6e10742418e708c60d22b29e44ab5129649538f7593ad834a38ee9cd54a4
+  data.tar.gz: 42d6400febd65098c2ccc37bafde776ad0b42129996e7edbfc74f9d8862622e3439389fcbbbe3788f5f62c4298dad30d0981df45726874dfb41f47047d9d7117

data/.doc/ext/rays/camera.cpp

@@ -19,11 +19,14 @@ VALUE alloc(VALUE klass)
 }
 
 static
-VALUE initialize(VALUE self)
+VALUE setup(VALUE self, VALUE device_name, VALUE min_width, VALUE min_height, VALUE resize, VALUE crop)
 {
 	RUCY_CHECK_OBJ(Rays::Camera, self);
 
-	*THIS = Rays::Camera();
+	*THIS = Rays::Camera(
+		device_name ? to<const char*>(device_name) : NULL,
+		to<int>(min_width), to<int>(min_height),
+		to<bool>(resize), to<bool>(crop));
 	return self;
 }
 
@@ -48,6 +51,66 @@ VALUE is_active(VALUE self)
 	return value(THIS->is_active());
 }
 
+static
+VALUE set_min_width(VALUE self, VALUE width)
+{
+	CHECK;
+	THIS->set_min_width(to<int>(width));
+	return value(THIS->min_width());
+}
+
+static
+VALUE min_width(VALUE self)
+{
+	CHECK;
+	return value(THIS->min_width());
+}
+
+static
+VALUE set_min_height(VALUE self, VALUE height)
+{
+	CHECK;
+	THIS->set_min_height(to<int>(height));
+	return value(THIS->min_height());
+}
+
+static
+VALUE min_height(VALUE self)
+{
+	CHECK;
+	return value(THIS->min_height());
+}
+
+static
+VALUE set_resize(VALUE self, VALUE resize)
+{
+	CHECK;
+	THIS->set_resize(to<bool>(resize));
+	return value(THIS->is_resize());
+}
+
+static
+VALUE is_resize(VALUE self)
+{
+	CHECK;
+	return value(THIS->is_resize());
+}
+
+static
+VALUE set_crop(VALUE self, VALUE crop)
+{
+	CHECK;
+	THIS->set_crop(to<bool>(crop));
+	return value(THIS->is_crop());
+}
+
+static
+VALUE is_crop(VALUE self)
+{
+	CHECK;
+	return value(THIS->is_crop());
+}
+
 static
 VALUE image(VALUE self)
 {
@@ -56,6 +119,17 @@ VALUE image(VALUE self)
 	return img ? value(*img) : nil();
 }
 
+static
+VALUE device_names(VALUE self)
+{
+	auto names = Rays::get_camera_device_names();
+
+	std::vector<Value> v;
+	for (auto it = names.begin(), end = names.end(); it != end; ++it)
+		v.emplace_back(value(it->c_str()));
+	return value(v.size(), &v[0]);
+}
+
 
 static Class cCamera;
 
@@ -66,11 +140,20 @@ Init_camera ()
 
 	cCamera = rb_define_class_under(mRays, "Camera", rb_cObject);
 	rb_define_alloc_func(cCamera, alloc);
-	rb_define_private_method(cCamera, "initialize", RUBY_METHOD_FUNC(initialize), -1);
+	rb_define_private_method(cCamera, "setup", RUBY_METHOD_FUNC(setup), 5);
 	rb_define_method(cCamera, "start", RUBY_METHOD_FUNC(start), 0);
 	rb_define_method(cCamera, "stop", RUBY_METHOD_FUNC(stop), 0);
 	cCamera.define_method("active?", is_active);
+	rb_define_method(cCamera, "min_width=", RUBY_METHOD_FUNC(set_min_width), 1);
+	rb_define_method(cCamera, "min_width", RUBY_METHOD_FUNC(min_width), 0);
+	rb_define_method(cCamera, "min_height=", RUBY_METHOD_FUNC(set_min_height), 1);
+	rb_define_method(cCamera, "min_height", RUBY_METHOD_FUNC(min_height), 0);
+	rb_define_method(cCamera, "resize=", RUBY_METHOD_FUNC(set_resize), 1);
+	cCamera.define_method("resize?",  is_resize);
+	rb_define_method(cCamera, "crop=", RUBY_METHOD_FUNC(set_crop), 1);
+	cCamera.define_method("crop?",    is_crop);
 	rb_define_method(cCamera, "image", RUBY_METHOD_FUNC(image), 0);
+	rb_define_module_function(cCamera, "device_names", RUBY_METHOD_FUNC(device_names), 0);
 }
 
 

data/VERSION

@@ -1 +1 @@
-0.1.16
+0.1.17

data/ext/rays/bitmap.cpp

@@ -110,7 +110,7 @@ Init_bitmap ()
 	cBitmap.define_alloc_func(alloc);
 	cBitmap.define_private_method("initialize",      initialize);
 	cBitmap.define_private_method("initialize_copy", initialize_copy);
-	cBitmap.define_method("width", width);
+	cBitmap.define_method("width",  width);
 	cBitmap.define_method("height", height);
 	cBitmap.define_method("color_space", color_space);
 	cBitmap.define_method("[]=", set_at);

data/ext/rays/camera.cpp

@@ -20,11 +20,14 @@ RUCY_DEF_ALLOC(alloc, klass)
 RUCY_END
 
 static
-RUCY_DEFN(initialize)
+RUCY_DEF5(setup, device_name, min_width, min_height, resize, crop)
 {
 	RUCY_CHECK_OBJ(Rays::Camera, self);
 
-	*THIS = Rays::Camera();
+	*THIS = Rays::Camera(
+		device_name ? to<const char*>(device_name) : NULL,
+		to<int>(min_width), to<int>(min_height),
+		to<bool>(resize), to<bool>(crop));
 	return self;
 }
 RUCY_END
@@ -53,6 +56,74 @@ RUCY_DEF0(is_active)
 }
 RUCY_END
 
+static
+RUCY_DEF1(set_min_width, width)
+{
+	CHECK;
+	THIS->set_min_width(to<int>(width));
+	return value(THIS->min_width());
+}
+RUCY_END
+
+static
+RUCY_DEF0(min_width)
+{
+	CHECK;
+	return value(THIS->min_width());
+}
+RUCY_END
+
+static
+RUCY_DEF1(set_min_height, height)
+{
+	CHECK;
+	THIS->set_min_height(to<int>(height));
+	return value(THIS->min_height());
+}
+RUCY_END
+
+static
+RUCY_DEF0(min_height)
+{
+	CHECK;
+	return value(THIS->min_height());
+}
+RUCY_END
+
+static
+RUCY_DEF1(set_resize, resize)
+{
+	CHECK;
+	THIS->set_resize(to<bool>(resize));
+	return value(THIS->is_resize());
+}
+RUCY_END
+
+static
+RUCY_DEF0(is_resize)
+{
+	CHECK;
+	return value(THIS->is_resize());
+}
+RUCY_END
+
+static
+RUCY_DEF1(set_crop, crop)
+{
+	CHECK;
+	THIS->set_crop(to<bool>(crop));
+	return value(THIS->is_crop());
+}
+RUCY_END
+
+static
+RUCY_DEF0(is_crop)
+{
+	CHECK;
+	return value(THIS->is_crop());
+}
+RUCY_END
+
 static
 RUCY_DEF0(image)
 {
@@ -62,6 +133,18 @@ RUCY_DEF0(image)
 }
 RUCY_END
 
+static
+RUCY_DEF0(device_names)
+{
+	auto names = Rays::get_camera_device_names();
+
+	std::vector<Value> v;
+	for (auto it = names.begin(), end = names.end(); it != end; ++it)
+		v.emplace_back(value(it->c_str()));
+	return value(v.size(), &v[0]);
+}
+RUCY_END
+
 
 static Class cCamera;
 
@@ -72,11 +155,20 @@ Init_camera ()
 
 	cCamera = mRays.define_class("Camera");
 	cCamera.define_alloc_func(alloc);
-	cCamera.define_private_method("initialize", initialize);
-	cCamera.define_method("start",   start);
-	cCamera.define_method("stop",    stop);
+	cCamera.define_private_method("setup", setup);
+	cCamera.define_method("start", start);
+	cCamera.define_method("stop",  stop);
 	cCamera.define_method("active?", is_active);
-	cCamera.define_method("image",   image);
+	cCamera.define_method("min_width=",  set_min_width);
+	cCamera.define_method("min_width",       min_width);
+	cCamera.define_method("min_height=", set_min_height);
+	cCamera.define_method("min_height",      min_height);
+	cCamera.define_method("resize=", set_resize);
+	cCamera.define_method("resize?",  is_resize);
+	cCamera.define_method("crop=",   set_crop);
+	cCamera.define_method("crop?",    is_crop);
+	cCamera.define_method("image", image);
+	cCamera.define_module_function("device_names", device_names);
 }
 
 

data/include/rays/camera.h

@@ -4,6 +4,7 @@
 #define __RAYS_CAMERA_H__
 
 
+#include <vector>
 #include <xot/pimpl.h>
 #include <rays/defs.h>
 #include <rays/image.h>
@@ -20,7 +21,12 @@ namespace Rays
 
 		public:
 
-			Camera ();
+			Camera (
+				const char* device_name = NULL,
+				int min_width  = -1,
+				int min_height = -1,
+				bool resize    = true,
+				bool crop      = true);
 
 			~Camera ();
 
@@ -30,6 +36,22 @@ namespace Rays
 
 			bool is_active () const;
 
+			void set_min_width (int width);
+
+			int      min_width () const;
+
+			void set_min_height (int height);
+
+			int      min_height () const;
+
+			void set_resize (bool resize = true);
+
+			bool  is_resize () const;
+
+			void set_crop (bool crop = true);
+
+			bool  is_crop () const;
+
 			const Image* image () const;
 
 			operator bool () const;
@@ -43,6 +65,9 @@ namespace Rays
 	};// Camera
 
 
+	std::vector<String> get_camera_device_names ();
+
+
 }// Rays
 
 

data/lib/rays/camera.rb

@@ -10,8 +10,11 @@ module Rays
 
   class Camera
 
-    def initialize (*args, &block)
-      super *args
+    def initialize (
+      min_width = -1, min_height = -1,
+      device_name: nil, resize: true, crop: true, &block)
+
+      setup device_name, min_width, min_height, resize, crop
       Xot::BlockUtil.instance_eval_or_block_call self, &block if block
     end
 

data/rays.gemspec

@@ -28,8 +28,8 @@ Gem::Specification.new do |s|
   s.platform              = Gem::Platform::RUBY
   s.required_ruby_version = '~> 2'
 
-  s.add_runtime_dependency 'xot',  '~> 0.1'
-  s.add_runtime_dependency 'rucy', '~> 0.1'
+  s.add_runtime_dependency 'xot',  '~> 0.1.16'
+  s.add_runtime_dependency 'rucy', '~> 0.1.16'
 
   s.files            = `git ls-files`.split $/
   s.executables      = s.files.grep(%r{^bin/}) {|f| File.basename f}

data/src/ios/bitmap.h

@@ -1,7 +1,7 @@
 // -*- mode: c++ -*-
 #pragma once
-#ifndef __RAYS_SRC_OSX_BITMAP_H__
-#define __RAYS_SRC_OSX_BITMAP_H__
+#ifndef __RAYS_SRC_IOS_BITMAP_H__
+#define __RAYS_SRC_IOS_BITMAP_H__
 
 
 #import <CoreGraphics/CGImage.h>
@@ -12,7 +12,9 @@ namespace Rays
 {
 
 
-	void Bitmap_copy_pixels (Bitmap* bitmap, CGImageRef image);
+	void Bitmap_draw_image (
+		Bitmap* bitmap, CGImageRef image,
+		coord x = 0, coord y = 0, coord width = -1, coord height = -1);
 
 
 }// Rays

data/src/ios/bitmap.mm

@@ -176,8 +176,12 @@ namespace Rays
 	}
 
 	void
-	Bitmap_copy_pixels (Bitmap* bitmap, CGImageRef image)
+	Bitmap_draw_image (
+		Bitmap* bitmap, CGImageRef image,
+		coord x, coord y, coord width, coord height)
 	{
+		if (width == 0 || height == 0) return;
+
 		if (!bitmap || !image)
 			argument_error(__FILE__, __LINE__);
 
@@ -185,9 +189,9 @@ namespace Rays
 		if (!context)
 			rays_error(__FILE__, __LINE__, "getting CGContext failed.");
 
-		size_t width  = CGImageGetWidth(image);
-		size_t height = CGImageGetHeight(image);
-		CGContextDrawImage(context, CGRectMake(0, 0, width, height), image);
+		if (width  < 0) width  = (coord) CGImageGetWidth(image);
+		if (height < 0) height = (coord) CGImageGetHeight(image);
+		CGContextDrawImage(context, CGRectMake(x, y, width, height), image);
 
 		Bitmap_set_modified(bitmap);
 	}
@@ -265,7 +269,7 @@ namespace Rays
 		if (!bmp)
 			rays_error(__FILE__, __LINE__, "invalid bitmap.");
 
-		Bitmap_copy_pixels(&bmp, image);
+		Bitmap_draw_image(&bmp, image);
 		return bmp;
 	}
 

data/src/ios/camera.mm

@@ -3,6 +3,7 @@
 
 
 #import <AVFoundation/AVFoundation.h>
+#include "rays/exception.h"
 #include "bitmap.h"
 
 
@@ -16,9 +17,10 @@ static int video_input_queue_index = 0;
 @implementation VideoInput
 
 	{
-		AVCaptureSession* captureSession;
-		dispatch_queue_t captureQueue;
-		CGImageRef captureImage;
+		AVCaptureSession* session;
+		dispatch_queue_t queue;
+		CGImageRef image;
+		AVCaptureVideoOrientation orientation;
 	}
 
 	- (id) init
@@ -26,9 +28,10 @@ static int video_input_queue_index = 0;
 		self = [super init];
 		if (self)
 		{
-			captureSession = nil;
-			captureQueue   = nil;
-			captureImage   = nil;
+			session     = nil;
+			queue       = nil;
+			image       = nil;
+			orientation = AVCaptureVideoOrientationPortrait;
 		}
 		return self;
 	}
@@ -38,37 +41,38 @@ static int video_input_queue_index = 0;
 		[self stop];
 		[self clearImage];
 
-		if (captureQueue)
+		if (queue)
 		{
-			dispatch_release(captureQueue);
-			captureQueue = nil;
+			dispatch_release(queue);
+			queue = nil;
 		}
 
 		[super dealloc];
 	}
 
-	- (dispatch_queue_t) queue
+	- (dispatch_queue_t) getQueue
 	{
-		if (!captureQueue)
+		if (!queue)
 		{
 			auto name = Xot::stringf(
 				"org.xord.RaysVideoInputQueue_%d",
 				video_input_queue_index++);
-			captureQueue = dispatch_queue_create(name, DISPATCH_QUEUE_SERIAL);
+			queue = dispatch_queue_create(name, DISPATCH_QUEUE_SERIAL);
 		}
-		return captureQueue;
+		return queue;
 	}
 
-	- (BOOL) start
+	- (BOOL) start: (AVCaptureDevice*) device
+		preset: (AVCaptureSessionPreset) preset
 	{
-		[self stop];
+		if (!device) return NO;
 
-		AVCaptureSession* session = [[[AVCaptureSession alloc] init] autorelease];
-		session.sessionPreset = AVCaptureSessionPresetHigh;
+		[self stop];
+		[self updateOrientation];
 
-		AVCaptureDevice* device =
-			[AVCaptureDevice defaultDeviceWithMediaType: AVMediaTypeVideo];
-		if (!device) return NO;
+		AVCaptureSession* sess = [[[AVCaptureSession alloc] init] autorelease];
+		if (preset != nil)
+			sess.sessionPreset = preset;
 
 		//device.activeVideoMinFrameDuration = CMTimeMake(1, 30);
 
@@ -76,7 +80,7 @@ static int video_input_queue_index = 0;
 		AVCaptureDeviceInput* input = [[[AVCaptureDeviceInput alloc]
 			initWithDevice: device error: &error]
 			autorelease];
-		if (!input || error || ![session canAddInput: input])
+		if (!input || error || ![sess canAddInput: input])
 			return NO;
 
 		AVCaptureVideoDataOutput* output =
@@ -85,22 +89,63 @@ static int video_input_queue_index = 0;
 			(NSString*) kCVPixelBufferPixelFormatTypeKey: @(kCVPixelFormatType_32BGRA)
 		};
 		output.alwaysDiscardsLateVideoFrames = YES;
-		[output setSampleBufferDelegate: self queue: self.queue];
-		if (![session canAddOutput: output])
+		[output setSampleBufferDelegate: self queue: [self getQueue]];
+		if (![sess canAddOutput: output])
 			return NO;
 
-		[session addInput: input];
-		[session addOutput: output];
-		[session startRunning];
+		[sess addInput: input];
+		[sess addOutput: output];
+
+		AVCaptureConnection* connection =
+			[output connectionWithMediaType: AVMediaTypeVideo];
+		if (connection)
+		{
+			if (connection.isVideoOrientationSupported)
+				[connection setVideoOrientation: orientation];
 
-		captureSession = [session retain];
+			if (connection.isVideoMirroringSupported)
+			{
+				[connection setVideoMirrored:
+					device.position == AVCaptureDevicePositionFront];
+			}
+		}
+
+		[sess startRunning];
+
+		session = [sess retain];
 		return YES;
 	}
 
+	- (void) updateCaptureOrientation
+	{
+		assert(Thread.isMainThread);
+
+		switch (UIApplication.sharedApplication.statusBarOrientation)
+		{
+			case UIInterfaceOrientationPortraitUpsideDown:
+				orientation = AVCaptureVideoOrientationPortraitUpsideDown;
+				break;
+
+			case UIInterfaceOrientationPortraitLandscapeLeft:
+				orientation = AVCaptureVideoOrientationLandscapeLeft;
+				break;
+
+			case UIInterfaceOrientationPortraitLandscapeRight:
+				orientation = AVCaptureVideoOrientationLandscapeRight;
+				break;
+
+			default:
+				orientation = AVCaptureVideoOrientationPortrait;
+				break;
+		}
+	}
+
 	- (void) captureOutput: (AVCaptureOutput*) output
 		didOutputSampleBuffer: (CMSampleBufferRef) sampleBuffer
 		fromConnection: (AVCaptureConnection*) connection
 	{
+		[connection setVideoOrientation: orientation];
+
 		CVPixelBufferRef pixelBuffer = CMSampleBufferGetImageBuffer(sampleBuffer);
 		if (!pixelBuffer) return;
 
@@ -115,35 +160,37 @@ static int video_input_queue_index = 0;
 
 		dispatch_async(dispatch_get_main_queue(), ^{
 			[self clearImage];
-			captureImage = cgImage;
+			image = cgImage;
+
+			[self updateOrientation];
 		});
 	}
 
 	- (void) stop
 	{
-		if (!captureSession) return;
+		if (!session) return;
 
-		[captureSession stopRunning];
-		[captureSession release];
-		captureSession = nil;
+		[session stopRunning];
+		[session release];
+		session = nil;
 	}
 
 	- (BOOL) isActive
 	{
-		return captureSession != nil;
+		return session != nil;
 	}
 
 	- (void) clearImage
 	{
-		if (!captureImage) return;
+		if (!image) return;
 
-		CGImageRelease(captureImage);
-		captureImage = nil;
+		CGImageRelease(image);
+		image = nil;
 	}
 
 	- (CGImageRef) getImage
 	{
-		return captureImage;
+		return image;
 	}
 
 @end// VideoInput
@@ -156,10 +203,51 @@ namespace Rays
 	struct Camera::Data
 	{
 
+		String device_name;
+
+		int min_width = -1, min_height = -1;
+
+		bool resize = false, crop = false;
+
 		mutable Image image;
 
 		VideoInput* video_input = nil;
 
+		AVCaptureSessionPreset get_preset (AVCaptureDevice* device)
+		{
+			int w = min_width, h = min_height;
+			if (w > 0 && h > 0)
+			{
+				#define SUPPORT(x) \
+					[device supportsAVCaptureSessionPreset: AVCaptureSessionPreset##x]
+
+				//if (w <= 320 && h <= 240 && SUPPORT(320x240))
+				//	return AVCaptureSessionPreset320x240;
+
+				if (w <= 352 && h <= 288 && SUPPORT(352x288))
+					return AVCaptureSessionPreset352x288;
+
+				if (w <= 640 && h <= 480 && SUPPORT(640x480))
+					return AVCaptureSessionPreset640x480;
+
+				//if (w <= 960 && h <= 540 && SUPPORT(960x540))
+				//	return AVCaptureSessionPreset960x540;
+
+				if (w <= 1280 && h <= 720 && SUPPORT(1280x720))
+					return AVCaptureSessionPreset1280x720;
+
+				if (/*w <= 1920 && h <= 1080 &&*/ SUPPORT(1920x1080))
+					return AVCaptureSessionPreset1920x1080;
+
+				//if (SUPPORT(3840x2160))
+				//	return AVCaptureSessionPreset3840x2160;
+
+				#undef SUPPORT
+			}
+
+			return nil;
+		}
+
 		void update_image_from_video_input () const
 		{
 			if (!video_input) return;
@@ -167,24 +255,160 @@ namespace Rays
 			CGImageRef cgImage = [video_input getImage];
 			if (!cgImage) return;
 
-			if (!image)
+			coord draw_x, draw_y, draw_width, draw_height;
+			int bitmap_width, bitmap_height;
+			get_draw_bounds(
+				&draw_x, &draw_y, &draw_width, &draw_height,
+				&bitmap_width, &bitmap_height,
+				cgImage);
+
+			if (
+				!image ||
+				image.bitmap().width()  != bitmap_width ||
+				image.bitmap().height() != bitmap_height)
 			{
-				Bitmap bmp(
-					(int) CGImageGetWidth(cgImage),
-					(int) CGImageGetHeight(cgImage));
-				image = Image(bmp);
+				image = Image(Bitmap(bitmap_width, bitmap_height));
 			}
 
-			Bitmap_copy_pixels(&image.bitmap(), cgImage);
+			Bitmap_draw_image(
+				&image.bitmap(), cgImage,
+				draw_x, draw_y, draw_width, draw_height);
 
 			[video_input clearImage];
 		}
 
+		void get_draw_bounds (
+			coord* draw_x, coord* draw_y, coord* draw_width, coord* draw_height,
+			int* bitmap_width, int* bitmap_height,
+			CGImageRef image) const
+		{
+			int image_width   = (int) CGImageGetWidth(image);
+			int image_height  = (int) CGImageGetHeight(image);
+			float image_ratio = (float) image_width / (float) image_height;
+
+			if (resize && min_width > 0 && min_height > 0)
+			{
+				float min_size_ratio = (float) min_width / (float) min_height;
+				if (image_ratio > min_size_ratio)
+				{
+					*draw_width  = min_height * image_ratio;
+					*draw_height = min_height;
+				}
+				else
+				{
+					*draw_width  = min_width;
+					*draw_height = min_width / image_ratio;
+				}
+			}
+			else if (resize && min_width > 0)
+			{
+				*draw_width  = min_width;
+				*draw_height = min_width / image_ratio;
+			}
+			else if (resize && min_height > 0)
+			{
+				*draw_width  = min_height * image_ratio;
+				*draw_height = min_height;
+			}
+			else
+			{
+				*draw_width  = image_width;
+				*draw_height = image_height;
+			}
+
+			*draw_x        = 0;
+			*draw_y        = 0;
+			*bitmap_width  = *draw_width;
+			*bitmap_height = *draw_height;
+
+			if (crop && min_width > 0)
+			{
+				*draw_x       = min_width / 2 - *draw_width / 2;
+				*bitmap_width = min_width;
+			}
+			else if (crop && min_height > 0)
+			{
+				*draw_y        = min_height / 2 - *draw_height / 2;
+				*bitmap_height = min_height;
+			}
+		}
+
 	};// Camera::Data
 
 
-	Camera::Camera ()
+	static NSArray<AVCaptureDevice*>*
+	get_video_devices ()
 	{
+#if 0
+		AVCaptureDeviceDiscoverySession* discoverySession =
+			[AVCaptureDeviceDiscoverySession
+				discoverySessionWithDeviceTypes: @[
+					AVCaptureDeviceTypeBuiltInWideAngleCamera]
+				mediaType: AVMediaTypeVideo
+				position: AVCaptureDevicePositionUnspecified];
+		NSArray<AVCaptureDevice*>* devices = discoverySession.devices;
+		for (AVCaptureDevice* d in devices)
+		{
+			printf("%s\n", d.localizedName.UTF8String);
+		}
+#endif
+		NSMutableArray<AVCaptureDevice*>* devices = [NSMutableArray array];
+		for (AVCaptureDevice* d in AVCaptureDevice.devices)
+		{
+			if ([d hasMediaType: AVMediaTypeVideo])
+				[devices addObject: d];
+		}
+		return devices;
+	}
+
+	static AVCaptureDevice*
+	get_default_video_device ()
+	{
+		AVCaptureDevice* device =
+			[AVCaptureDevice defaultDeviceWithMediaType: AVMediaTypeVideo];
+		if (!device)
+			rays_error(__FILE__, __LINE__, "Default camera device is not found.");
+
+		return device;
+	}
+
+	static AVCaptureDevice*
+	get_video_device (const char* name)
+	{
+		if (!name || *name == 0)
+			return get_default_video_device();
+
+		for (AVCaptureDevice* d in get_video_devices())
+		{
+			if (strcmp(name, d.localizedName.UTF8String) == 0)
+				return d;
+		}
+
+		rays_error(__FILE__, __LINE__, "Camera device '%s' is not found.", name);
+		return nil;
+	}
+
+	std::vector<String>
+	get_camera_device_names ()
+	{
+		std::vector<String> names;
+		for (AVCaptureDevice* d in get_video_devices())
+			names.emplace_back(d.localizedName.UTF8String);
+		return names;
+	}
+
+
+	Camera::Camera (
+		const char* device_name,
+		int min_width, int min_height, bool resize, bool crop)
+	{
+		if (device_name)
+			self->device_name = device_name;
+
+		self->min_width  = min_width;
+		self->min_height = min_height;
+		self->resize     = resize;
+		self->crop       = crop;
 	}
 
 	Camera::~Camera ()
@@ -197,7 +421,9 @@ namespace Rays
 	Camera::start ()
 	{
 		if (!self->video_input) self->video_input = [[VideoInput alloc] init];
-		return [self->video_input start];
+
+		AVCaptureDevice* device = get_video_device(self->device_name.c_str());
+		return [self->video_input start: device preset: self->get_preset(device)];
 	}
 
 	void
@@ -214,6 +440,54 @@ namespace Rays
 		return self->video_input && [self->video_input isActive];
 	}
 
+	void
+	Camera::set_min_width (int width)
+	{
+		self->min_width = width;
+	}
+
+	int
+	Camera::min_width () const
+	{
+		return self->min_width;
+	}
+
+	void
+	Camera::set_min_height (int height)
+	{
+		self->min_height = height;
+	}
+
+	int
+	Camera::min_height () const
+	{
+		return self->min_height;
+	}
+
+	void
+	Camera::set_resize (bool resize)
+	{
+		self->resize = resize;
+	}
+
+	bool
+	Camera::is_resize () const
+	{
+		return self->resize;
+	}
+
+	void
+	Camera::set_crop (bool crop)
+	{
+		self->crop = crop;
+	}
+
+	bool
+	Camera::is_crop () const
+	{
+		return self->crop;
+	}
+
 	const Image*
 	Camera::image () const
 	{