Index: pjproject/trunk/pjmedia/src/pjmedia-videodev/darwin_dev.m
===================================================================
--- pjproject/trunk/pjmedia/src/pjmedia-videodev/ios_dev.m	(revision 5166)
+++ pjproject/trunk/pjmedia/src/pjmedia-videodev/darwin_dev.m	(revision 5347)
@@ -24,17 +24,25 @@
 
 #if defined(PJMEDIA_HAS_VIDEO) && PJMEDIA_HAS_VIDEO != 0 && \
-    defined(PJMEDIA_VIDEO_DEV_HAS_IOS) && PJMEDIA_VIDEO_DEV_HAS_IOS != 0
-
-#include "Availability.h"
-#ifdef __IPHONE_4_0
-
-#import <UIKit/UIKit.h>
+    defined(PJMEDIA_VIDEO_DEV_HAS_DARWIN) && PJMEDIA_VIDEO_DEV_HAS_DARWIN != 0
+
+#include "TargetConditionals.h"
+
+#if TARGET_OS_IPHONE
+    /* On iOS, we supports rendering using UIView */
+    #import <UIKit/UIKit.h>
+#endif
+
 #import <AVFoundation/AVFoundation.h>
 #import <QuartzCore/QuartzCore.h>
 
-#define THIS_FILE		"ios_dev.c"
+#define THIS_FILE		"darwin_dev.c"
 #define DEFAULT_CLOCK_RATE	90000
-#define DEFAULT_WIDTH		352
-#define DEFAULT_HEIGHT		288
+#if TARGET_OS_IPHONE
+    #define DEFAULT_WIDTH	352
+    #define DEFAULT_HEIGHT	288
+#else
+    #define DEFAULT_WIDTH	1280
+    #define DEFAULT_HEIGHT	720
+#endif
 #define DEFAULT_FPS		15
 
@@ -44,34 +52,42 @@
 #define MAINTAIN_ASPECT_RATIO 	PJ_TRUE
 
-typedef struct ios_fmt_info
+typedef struct darwin_fmt_info
 {
     pjmedia_format_id   pjmedia_format;
-    UInt32		ios_format;
-} ios_fmt_info;
-
-static ios_fmt_info ios_fmts[] =
-{
+    UInt32		darwin_format;
+} darwin_fmt_info;
+
+static darwin_fmt_info darwin_fmts[] =
+{
+#if !TARGET_OS_IPHONE
+    { PJMEDIA_FORMAT_YUY2, kCVPixelFormatType_422YpCbCr8_yuvs },
+    { PJMEDIA_FORMAT_UYVY, kCVPixelFormatType_422YpCbCr8 },
+#endif
     { PJMEDIA_FORMAT_BGRA, kCVPixelFormatType_32BGRA },
     { PJMEDIA_FORMAT_I420, kCVPixelFormatType_420YpCbCr8BiPlanarVideoRange }
 };
 
-typedef struct ios_supported_size
+typedef struct darwin_supported_size
 {
     pj_size_t supported_size_w;
     pj_size_t supported_size_h;
     NSString *preset_str;
-} ios_supported_size;
+} darwin_supported_size;
 
 /* Set the preset_str on set_preset_str method. */
-static ios_supported_size ios_sizes[] =
-{
+static darwin_supported_size darwin_sizes[] =
+{
+#if TARGET_OS_IPHONE
     { 352, 288, NULL },
     { 640, 480, NULL },
     { 1280, 720, NULL },
     { 1920, 1080, NULL }
+#else
+    { 1280, 720, NULL }
+#endif
 };
 
-/* ios device info */
-struct ios_dev_info
+/* darwin device info */
+struct darwin_dev_info
 {
     pjmedia_vid_dev_info	 info;
@@ -79,6 +95,6 @@
 };
 
-/* ios factory */
-struct ios_factory
+/* darwin factory */
+struct darwin_factory
 {
     pjmedia_vid_dev_factory	 base;
@@ -87,5 +103,5 @@
 
     unsigned			 dev_count;
-    struct ios_dev_info		*dev_info;
+    struct darwin_dev_info	*dev_info;
 };
 
@@ -94,15 +110,15 @@
 {
 @public
-    struct ios_stream *stream;
+    struct darwin_stream *stream;
 }
 @end
 
 /* Video stream. */
-struct ios_stream
+struct darwin_stream
 {
     pjmedia_vid_dev_stream  base;		/**< Base stream       */
     pjmedia_vid_dev_param   param;		/**< Settings	       */
     pj_pool_t		   *pool;		/**< Memory pool       */
-    struct ios_factory     *factory;            /**< Factory           */
+    struct darwin_factory  *factory;            /**< Factory           */
 
     pjmedia_vid_dev_cb	    vid_cb;		/**< Stream callback   */
@@ -127,9 +143,11 @@
     AVCaptureVideoPreviewLayer  *prev_layer;
     
+#if TARGET_OS_IPHONE
     void		*render_buf;
     pj_size_t		 render_buf_size;
     CGDataProviderRef    render_data_provider;
     UIView              *render_view;
-    
+#endif
+
     pj_timestamp	 frame_ts;
     unsigned		 ts_inc;
@@ -138,16 +156,16 @@
 
 /* Prototypes */
-static pj_status_t ios_factory_init(pjmedia_vid_dev_factory *f);
-static pj_status_t ios_factory_destroy(pjmedia_vid_dev_factory *f);
-static pj_status_t ios_factory_refresh(pjmedia_vid_dev_factory *f);
-static unsigned    ios_factory_get_dev_count(pjmedia_vid_dev_factory *f);
-static pj_status_t ios_factory_get_dev_info(pjmedia_vid_dev_factory *f,
-					    unsigned index,
-					    pjmedia_vid_dev_info *info);
-static pj_status_t ios_factory_default_param(pj_pool_t *pool,
-					     pjmedia_vid_dev_factory *f,
-					     unsigned index,
-					     pjmedia_vid_dev_param *param);
-static pj_status_t ios_factory_create_stream(
+static pj_status_t darwin_factory_init(pjmedia_vid_dev_factory *f);
+static pj_status_t darwin_factory_destroy(pjmedia_vid_dev_factory *f);
+static pj_status_t darwin_factory_refresh(pjmedia_vid_dev_factory *f);
+static unsigned    darwin_factory_get_dev_count(pjmedia_vid_dev_factory *f);
+static pj_status_t darwin_factory_get_dev_info(pjmedia_vid_dev_factory *f,
+					       unsigned index,
+					       pjmedia_vid_dev_info *info);
+static pj_status_t darwin_factory_default_param(pj_pool_t *pool,
+						pjmedia_vid_dev_factory *f,
+					     	unsigned index,
+					     	pjmedia_vid_dev_param *param);
+static pj_status_t darwin_factory_create_stream(
 					pjmedia_vid_dev_factory *f,
 					pjmedia_vid_dev_param *param,
@@ -156,50 +174,54 @@
 					pjmedia_vid_dev_stream **p_vid_strm);
 
-static pj_status_t ios_stream_get_param(pjmedia_vid_dev_stream *strm,
-				        pjmedia_vid_dev_param *param);
-static pj_status_t ios_stream_get_cap(pjmedia_vid_dev_stream *strm,
-				      pjmedia_vid_dev_cap cap,
-				      void *value);
-static pj_status_t ios_stream_set_cap(pjmedia_vid_dev_stream *strm,
-				      pjmedia_vid_dev_cap cap,
-				      const void *value);
-static pj_status_t ios_stream_start(pjmedia_vid_dev_stream *strm);
-static pj_status_t ios_stream_get_frame(pjmedia_vid_dev_stream *strm,
-                                        pjmedia_frame *frame);
-static pj_status_t ios_stream_put_frame(pjmedia_vid_dev_stream *strm,
-					const pjmedia_frame *frame);
-static pj_status_t ios_stream_stop(pjmedia_vid_dev_stream *strm);
-static pj_status_t ios_stream_destroy(pjmedia_vid_dev_stream *strm);
+static pj_status_t darwin_stream_get_param(pjmedia_vid_dev_stream *strm,
+				           pjmedia_vid_dev_param *param);
+static pj_status_t darwin_stream_get_cap(pjmedia_vid_dev_stream *strm,
+				         pjmedia_vid_dev_cap cap,
+				         void *value);
+static pj_status_t darwin_stream_set_cap(pjmedia_vid_dev_stream *strm,
+				         pjmedia_vid_dev_cap cap,
+				         const void *value);
+static pj_status_t darwin_stream_start(pjmedia_vid_dev_stream *strm);
+static pj_status_t darwin_stream_get_frame(pjmedia_vid_dev_stream *strm,
+                                           pjmedia_frame *frame);
+static pj_status_t darwin_stream_put_frame(pjmedia_vid_dev_stream *strm,
+					   const pjmedia_frame *frame);
+static pj_status_t darwin_stream_stop(pjmedia_vid_dev_stream *strm);
+static pj_status_t darwin_stream_destroy(pjmedia_vid_dev_stream *strm);
 
 /* Operations */
 static pjmedia_vid_dev_factory_op factory_op =
 {
-    &ios_factory_init,
-    &ios_factory_destroy,
-    &ios_factory_get_dev_count,
-    &ios_factory_get_dev_info,
-    &ios_factory_default_param,
-    &ios_factory_create_stream,
-    &ios_factory_refresh
+    &darwin_factory_init,
+    &darwin_factory_destroy,
+    &darwin_factory_get_dev_count,
+    &darwin_factory_get_dev_info,
+    &darwin_factory_default_param,
+    &darwin_factory_create_stream,
+    &darwin_factory_refresh
 };
 
 static pjmedia_vid_dev_stream_op stream_op =
 {
-    &ios_stream_get_param,
-    &ios_stream_get_cap,
-    &ios_stream_set_cap,
-    &ios_stream_start,
-    &ios_stream_get_frame,
-    &ios_stream_put_frame,
-    &ios_stream_stop,
-    &ios_stream_destroy
+    &darwin_stream_get_param,
+    &darwin_stream_get_cap,
+    &darwin_stream_set_cap,
+    &darwin_stream_start,
+    &darwin_stream_get_frame,
+    &darwin_stream_put_frame,
+    &darwin_stream_stop,
+    &darwin_stream_destroy
 };
 
 static void set_preset_str()
 {
-    ios_sizes[0].preset_str = AVCaptureSessionPreset352x288;
-    ios_sizes[1].preset_str = AVCaptureSessionPreset640x480;
-    ios_sizes[2].preset_str = AVCaptureSessionPreset1280x720;
-    ios_sizes[3].preset_str = AVCaptureSessionPreset1920x1080;
+#if TARGET_OS_IPHONE
+    darwin_sizes[0].preset_str = AVCaptureSessionPreset352x288;
+    darwin_sizes[1].preset_str = AVCaptureSessionPreset640x480;
+    darwin_sizes[2].preset_str = AVCaptureSessionPreset1280x720;
+    darwin_sizes[3].preset_str = AVCaptureSessionPreset1920x1080;
+#else
+    darwin_sizes[0].preset_str = AVCaptureSessionPreset1280x720;
+#endif
 }
 
@@ -208,13 +230,13 @@
  */
 /*
- * Init ios_ video driver.
+ * Init darwin_ video driver.
  */
-pjmedia_vid_dev_factory* pjmedia_ios_factory(pj_pool_factory *pf)
-{
-    struct ios_factory *f;
+pjmedia_vid_dev_factory* pjmedia_darwin_factory(pj_pool_factory *pf)
+{
+    struct darwin_factory *f;
     pj_pool_t *pool;
 
-    pool = pj_pool_create(pf, "ios video", 512, 512, NULL);
-    f = PJ_POOL_ZALLOC_T(pool, struct ios_factory);
+    pool = pj_pool_create(pf, "darwin video", 512, 512, NULL);
+    f = PJ_POOL_ZALLOC_T(pool, struct darwin_factory);
     f->pf = pf;
     f->pool = pool;
@@ -226,8 +248,8 @@
 
 /* API: init factory */
-static pj_status_t ios_factory_init(pjmedia_vid_dev_factory *f)
-{
-    struct ios_factory *qf = (struct ios_factory*)f;
-    struct ios_dev_info *qdi;
+static pj_status_t darwin_factory_init(pjmedia_vid_dev_factory *f)
+{
+    struct darwin_factory *qf = (struct darwin_factory*)f;
+    struct darwin_dev_info *qdi;
     unsigned i, l, first_idx, front_idx = -1;
     enum { MAX_DEV_COUNT = 8 };
@@ -236,9 +258,10 @@
     
     /* Initialize input and output devices here */
-    qf->dev_info = (struct ios_dev_info*)
+    qf->dev_info = (struct darwin_dev_info*)
 		   pj_pool_calloc(qf->pool, MAX_DEV_COUNT,
-				  sizeof(struct ios_dev_info));
+				  sizeof(struct darwin_dev_info));
     qf->dev_count = 0;
     
+#if TARGET_OS_IPHONE
     /* Init output device */
     qdi = &qf->dev_info[qf->dev_count++];
@@ -248,4 +271,5 @@
     qdi->info.dir = PJMEDIA_DIR_RENDER;
     qdi->info.has_callback = PJ_FALSE;
+#endif
     
     /* Init input device */
@@ -269,9 +293,11 @@
             pj_ansi_strncpy(qdi->info.name, [device.localizedName UTF8String],
                             sizeof(qdi->info.name));
-            pj_ansi_strncpy(qdi->info.driver, "iOS", sizeof(qdi->info.driver));
+            pj_ansi_strncpy(qdi->info.driver, "AVF", sizeof(qdi->info.driver));
             qdi->info.dir = PJMEDIA_DIR_CAPTURE;
             qdi->info.has_callback = PJ_FALSE;
+#if TARGET_OS_IPHONE
             qdi->info.caps = PJMEDIA_VID_DEV_CAP_INPUT_PREVIEW |
 		    	     PJMEDIA_VID_DEV_CAP_SWITCH;
+#endif
             qdi->dev = device;
         }
@@ -280,5 +306,5 @@
     /* Set front camera to be the first input device (as default dev) */
     if (front_idx != -1 && front_idx != first_idx) {
-        struct ios_dev_info tmp_dev_info = qf->dev_info[first_idx];
+        struct darwin_dev_info tmp_dev_info = qf->dev_info[first_idx];
         qf->dev_info[first_idx] = qf->dev_info[front_idx];
         qf->dev_info[front_idx] = tmp_dev_info;
@@ -295,10 +321,10 @@
                           PJMEDIA_VID_DEV_CAP_ORIENTATION;
 	
-	for (l = 0; l < PJ_ARRAY_SIZE(ios_fmts); l++) {
+	for (l = 0; l < PJ_ARRAY_SIZE(darwin_fmts); l++) {
             pjmedia_format *fmt;
             
             /* Simple renderer UIView only supports BGRA */
             if (qdi->info.dir == PJMEDIA_DIR_RENDER &&
-                ios_fmts[l].pjmedia_format != PJMEDIA_FORMAT_BGRA)
+                darwin_fmts[l].pjmedia_format != PJMEDIA_FORMAT_BGRA)
             {
                 continue;
@@ -308,5 +334,5 @@
                 fmt = &qdi->info.fmt[qdi->info.fmt_cnt++];
                 pjmedia_format_init_video(fmt,
-                                          ios_fmts[l].pjmedia_format,
+                                          darwin_fmts[l].pjmedia_format,
                                           DEFAULT_WIDTH,
                                           DEFAULT_HEIGHT,
@@ -317,25 +343,26 @@
                 
                 /* Set supported size for capture device */
-                for(m = 0; m < PJ_ARRAY_SIZE(ios_sizes) &&
-                           qdi->info.fmt_cnt<PJMEDIA_VID_DEV_INFO_FMT_CNT;
+                for(m = 0;
+                    m < PJ_ARRAY_SIZE(darwin_sizes) &&
+                    qdi->info.fmt_cnt<PJMEDIA_VID_DEV_INFO_FMT_CNT;
                     m++)
                 {
                     if ([dev supportsAVCaptureSessionPreset:
-                                                       ios_sizes[m].preset_str])
+                             darwin_sizes[m].preset_str])
                     {
                         /* Landscape video */
                         fmt = &qdi->info.fmt[qdi->info.fmt_cnt++];
                         pjmedia_format_init_video(fmt,
-                                                  ios_fmts[l].pjmedia_format,
-                                                  ios_sizes[m].supported_size_w,
-                                                  ios_sizes[m].supported_size_h,
-                                                  DEFAULT_FPS, 1);
+                		darwin_fmts[l].pjmedia_format,
+                                darwin_sizes[m].supported_size_w,
+                                darwin_sizes[m].supported_size_h,
+                                DEFAULT_FPS, 1);
                         /* Portrait video */
                         fmt = &qdi->info.fmt[qdi->info.fmt_cnt++];
                         pjmedia_format_init_video(fmt,
-                                                  ios_fmts[l].pjmedia_format,
-                                                  ios_sizes[m].supported_size_h,
-                                                  ios_sizes[m].supported_size_w,
-                                                  DEFAULT_FPS, 1);
+                        	darwin_fmts[l].pjmedia_format,
+                          	darwin_sizes[m].supported_size_h,
+                          	darwin_sizes[m].supported_size_w,
+                                DEFAULT_FPS, 1);
                     }
                 }                
@@ -344,5 +371,5 @@
     }
     
-    PJ_LOG(4, (THIS_FILE, "iOS video initialized with %d devices:",
+    PJ_LOG(4, (THIS_FILE, "Darwin video initialized with %d devices:",
 	       qf->dev_count));
     for (i = 0; i < qf->dev_count; i++) {
@@ -357,7 +384,7 @@
 
 /* API: destroy factory */
-static pj_status_t ios_factory_destroy(pjmedia_vid_dev_factory *f)
-{
-    struct ios_factory *qf = (struct ios_factory*)f;
+static pj_status_t darwin_factory_destroy(pjmedia_vid_dev_factory *f)
+{
+    struct darwin_factory *qf = (struct darwin_factory*)f;
     pj_pool_t *pool = qf->pool;
 
@@ -369,5 +396,5 @@
 
 /* API: refresh the list of devices */
-static pj_status_t ios_factory_refresh(pjmedia_vid_dev_factory *f)
+static pj_status_t darwin_factory_refresh(pjmedia_vid_dev_factory *f)
 {
     PJ_UNUSED_ARG(f);
@@ -376,16 +403,16 @@
 
 /* API: get number of devices */
-static unsigned ios_factory_get_dev_count(pjmedia_vid_dev_factory *f)
-{
-    struct ios_factory *qf = (struct ios_factory*)f;
+static unsigned darwin_factory_get_dev_count(pjmedia_vid_dev_factory *f)
+{
+    struct darwin_factory *qf = (struct darwin_factory*)f;
     return qf->dev_count;
 }
 
 /* API: get device info */
-static pj_status_t ios_factory_get_dev_info(pjmedia_vid_dev_factory *f,
-					    unsigned index,
-					    pjmedia_vid_dev_info *info)
-{
-    struct ios_factory *qf = (struct ios_factory*)f;
+static pj_status_t darwin_factory_get_dev_info(pjmedia_vid_dev_factory *f,
+					       unsigned index,
+					       pjmedia_vid_dev_info *info)
+{
+    struct darwin_factory *qf = (struct darwin_factory*)f;
 
     PJ_ASSERT_RETURN(index < qf->dev_count, PJMEDIA_EVID_INVDEV);
@@ -397,11 +424,11 @@
 
 /* API: create default device parameter */
-static pj_status_t ios_factory_default_param(pj_pool_t *pool,
-					     pjmedia_vid_dev_factory *f,
-					     unsigned index,
-					     pjmedia_vid_dev_param *param)
-{
-    struct ios_factory *qf = (struct ios_factory*)f;
-    struct ios_dev_info *di;
+static pj_status_t darwin_factory_default_param(pj_pool_t *pool,
+					        pjmedia_vid_dev_factory *f,
+					        unsigned index,
+					        pjmedia_vid_dev_param *param)
+{
+    struct darwin_factory *qf = (struct darwin_factory*)f;
+    struct darwin_dev_info *di;
 
     PJ_ASSERT_RETURN(index < qf->dev_count, PJMEDIA_EVID_INVDEV);
@@ -431,4 +458,5 @@
 
 @implementation VOutDelegate
+#if TARGET_OS_IPHONE
 - (void)update_image
 {    
@@ -447,5 +475,6 @@
 
     [pool release];
-}    
+}
+#endif
 
 - (void)captureOutput:(AVCaptureOutput *)captureOutput 
@@ -474,4 +503,9 @@
 
     [stream->frame_lock lock];
+    
+    // TODO: on Mac, nearly all frames, regardless of video format,
+    // have extra padding. So we may need to create a util function to
+    // remove the stride.
+    
     if (stream->is_planar && stream->capture_buf) {
         if (stream->param.fmt.id == PJMEDIA_FORMAT_I420) {
@@ -552,8 +586,8 @@
 @end
 
-static pj_status_t ios_stream_get_frame(pjmedia_vid_dev_stream *strm,
+static pj_status_t darwin_stream_get_frame(pjmedia_vid_dev_stream *strm,
                                         pjmedia_frame *frame)
 {
-    struct ios_stream *stream = (struct ios_stream *)strm;
+    struct darwin_stream *stream = (struct darwin_stream *)strm;
 
     frame->type = PJMEDIA_FRAME_TYPE_VIDEO;
@@ -571,11 +605,11 @@
 
 
-static ios_fmt_info* get_ios_format_info(pjmedia_format_id id)
+static darwin_fmt_info* get_darwin_format_info(pjmedia_format_id id)
 {
     unsigned i;
     
-    for (i = 0; i < PJ_ARRAY_SIZE(ios_fmts); i++) {
-        if (ios_fmts[i].pjmedia_format == id)
-            return &ios_fmts[i];
+    for (i = 0; i < PJ_ARRAY_SIZE(darwin_fmts); i++) {
+        if (darwin_fmts[i].pjmedia_format == id)
+            return &darwin_fmts[i];
     }
     
@@ -584,5 +618,6 @@
 
 
-static pj_status_t ios_init_view(struct ios_stream *strm)
+#if TARGET_OS_IPHONE
+static pj_status_t darwin_init_view(struct darwin_stream *strm)
 {
     pjmedia_vid_dev_param *param = &strm->param;
@@ -602,16 +637,16 @@
     strm->render_view = [[UIView alloc] initWithFrame:view_rect];
     strm->param.window.info.ios.window = strm->render_view;
-    
+
     if (param->flags & PJMEDIA_VID_DEV_CAP_OUTPUT_WINDOW) {
         PJ_ASSERT_RETURN(param->window.info.ios.window, PJ_EINVAL);
-        ios_stream_set_cap(&strm->base, PJMEDIA_VID_DEV_CAP_OUTPUT_WINDOW,
+        darwin_stream_set_cap(&strm->base, PJMEDIA_VID_DEV_CAP_OUTPUT_WINDOW,
                            param->window.info.ios.window);
     }
     if (param->flags & PJMEDIA_VID_DEV_CAP_OUTPUT_HIDE) {
-        ios_stream_set_cap(&strm->base, PJMEDIA_VID_DEV_CAP_OUTPUT_HIDE,
+        darwin_stream_set_cap(&strm->base, PJMEDIA_VID_DEV_CAP_OUTPUT_HIDE,
                            &param->window_hide);
     }
     if (param->flags & PJMEDIA_VID_DEV_CAP_ORIENTATION) {
-        ios_stream_set_cap(&strm->base, PJMEDIA_VID_DEV_CAP_ORIENTATION,
+        darwin_stream_set_cap(&strm->base, PJMEDIA_VID_DEV_CAP_ORIENTATION,
                            &param->orient);
     }
@@ -619,8 +654,9 @@
     return PJ_SUCCESS;
 }
+#endif /* TARGET_OS_IPHONE */
 
 
 /* API: create stream */
-static pj_status_t ios_factory_create_stream(
+static pj_status_t darwin_factory_create_stream(
 					pjmedia_vid_dev_factory *f,
 					pjmedia_vid_dev_param *param,
@@ -629,11 +665,11 @@
 					pjmedia_vid_dev_stream **p_vid_strm)
 {
-    struct ios_factory *qf = (struct ios_factory*)f;
+    struct darwin_factory *qf = (struct darwin_factory*)f;
     pj_pool_t *pool;
-    struct ios_stream *strm;
+    struct darwin_stream *strm;
     pjmedia_video_format_detail *vfd;
     const pjmedia_video_format_info *vfi;
     pj_status_t status = PJ_SUCCESS;
-    ios_fmt_info *ifi = get_ios_format_info(param->fmt.id);
+    darwin_fmt_info *ifi = get_darwin_format_info(param->fmt.id);
 
     PJ_ASSERT_RETURN(f && param && p_vid_strm, PJ_EINVAL);
@@ -644,5 +680,5 @@
 		     PJ_EINVAL);
 
-    if (!(ifi = get_ios_format_info(param->fmt.id)))
+    if (!(ifi = get_darwin_format_info(param->fmt.id)))
         return PJMEDIA_EVID_BADFORMAT;
     
@@ -652,8 +688,8 @@
 
     /* Create and Initialize stream descriptor */
-    pool = pj_pool_create(qf->pf, "ios-dev", 4000, 4000, NULL);
+    pool = pj_pool_create(qf->pf, "darwin-dev", 4000, 4000, NULL);
     PJ_ASSERT_RETURN(pool != NULL, PJ_ENOMEM);
 
-    strm = PJ_POOL_ZALLOC_T(pool, struct ios_stream);
+    strm = PJ_POOL_ZALLOC_T(pool, struct darwin_stream);
     pj_memcpy(&strm->param, param, sizeof(*param));
     strm->pool = pool;
@@ -681,9 +717,9 @@
         AVCaptureDevice *dev = qf->dev_info[param->cap_id].dev;
  
-        for (i = PJ_ARRAY_SIZE(ios_sizes)-1; i > 0; --i) {
-            if (((vfd->size.w == ios_sizes[i].supported_size_w) &&
-                 (vfd->size.h == ios_sizes[i].supported_size_h)) ||
-                ((vfd->size.w == ios_sizes[i].supported_size_h) &&
-                 (vfd->size.h == ios_sizes[i].supported_size_w)))
+        for (i = PJ_ARRAY_SIZE(darwin_sizes)-1; i > 0; --i) {
+            if (((vfd->size.w == darwin_sizes[i].supported_size_w) &&
+                 (vfd->size.h == darwin_sizes[i].supported_size_h)) ||
+                ((vfd->size.w == darwin_sizes[i].supported_size_h) &&
+                 (vfd->size.h == darwin_sizes[i].supported_size_w)))
             {
                 break;
@@ -691,5 +727,5 @@
         }
         
-        strm->cap_session.sessionPreset = ios_sizes[i].preset_str;
+        strm->cap_session.sessionPreset = darwin_sizes[i].preset_str;
         
         /* If the requested size is portrait (or landscape), we make
@@ -697,9 +733,9 @@
          */
         if (vfd->size.w > vfd->size.h) {
-            vfd->size.w = ios_sizes[i].supported_size_w;
-            vfd->size.h = ios_sizes[i].supported_size_h;
+            vfd->size.w = darwin_sizes[i].supported_size_w;
+            vfd->size.h = darwin_sizes[i].supported_size_h;
         } else {
-            vfd->size.h = ios_sizes[i].supported_size_w;
-            vfd->size.w = ios_sizes[i].supported_size_h;
+            vfd->size.h = darwin_sizes[i].supported_size_w;
+            vfd->size.w = darwin_sizes[i].supported_size_h;
         }
         strm->size = vfd->size;
@@ -711,14 +747,21 @@
         param->fmt = strm->param.fmt;
 
-        /* Set frame rate, this may only work on iOS 7 or later */
+#if TARGET_OS_IPHONE
+        /* Set frame rate, this may only work on iOS 7 or later.
+         * On Mac, this may raise an exception if we set it to a value
+         * unsupported by the device. We need to query
+         * activeFormat.videoSupportedFrameRateRanges to get the valid
+         * range.
+         */
         if ([dev respondsToSelector:@selector(activeVideoMinFrameDuration)] &&
             [dev lockForConfiguration:NULL])
         {
             dev.activeVideoMinFrameDuration = CMTimeMake(vfd->fps.denum,
-                                                            vfd->fps.num);
+                                                         vfd->fps.num);
             dev.activeVideoMaxFrameDuration = CMTimeMake(vfd->fps.denum,
-                                                            vfd->fps.num);
+                                                         vfd->fps.num);
             [dev unlockForConfiguration];
         }
+#endif
         
 	/* Add the video device to the session as a device input */
@@ -752,5 +795,5 @@
 	strm->video_output.videoSettings =
 	    [NSDictionary dictionaryWithObjectsAndKeys:
-			  [NSNumber numberWithInt:ifi->ios_format],
+			  [NSNumber numberWithInt:ifi->darwin_format],
 			  kCVPixelBufferPixelFormatTypeKey, nil];
 
@@ -776,5 +819,5 @@
         /* Native preview */
         if (param->flags & PJMEDIA_VID_DEV_CAP_INPUT_PREVIEW) {
-            ios_stream_set_cap(&strm->base, PJMEDIA_VID_DEV_CAP_INPUT_PREVIEW,
+            darwin_stream_set_cap(&strm->base, PJMEDIA_VID_DEV_CAP_INPUT_PREVIEW,
                                &param->native_preview);
         }
@@ -789,13 +832,13 @@
             if (param->orient == PJMEDIA_ORIENT_UNKNOWN)
                 param->orient = PJMEDIA_ORIENT_NATURAL;
-            ios_stream_set_cap(&strm->base, PJMEDIA_VID_DEV_CAP_ORIENTATION,
+            darwin_stream_set_cap(&strm->base, PJMEDIA_VID_DEV_CAP_ORIENTATION,
                                &param->orient);
         }
         
     } else if (param->dir & PJMEDIA_DIR_RENDER) {
-
+#if TARGET_OS_IPHONE
         /* Create renderer stream here */
         
-        status = ios_init_view(strm);
+        status = darwin_init_view(strm);
         if (status != PJ_SUCCESS)
             goto on_error;
@@ -811,4 +854,5 @@
                                             strm->render_buf, strm->frame_size,
                                             NULL);
+#endif
     }
     
@@ -820,5 +864,5 @@
     
 on_error:
-    ios_stream_destroy((pjmedia_vid_dev_stream *)strm);
+    darwin_stream_destroy((pjmedia_vid_dev_stream *)strm);
     
     return status;
@@ -826,8 +870,8 @@
 
 /* API: Get stream info. */
-static pj_status_t ios_stream_get_param(pjmedia_vid_dev_stream *s,
-				        pjmedia_vid_dev_param *pi)
-{
-    struct ios_stream *strm = (struct ios_stream*)s;
+static pj_status_t darwin_stream_get_param(pjmedia_vid_dev_stream *s,
+				           pjmedia_vid_dev_param *pi)
+{
+    struct darwin_stream *strm = (struct darwin_stream*)s;
 
     PJ_ASSERT_RETURN(strm && pi, PJ_EINVAL);
@@ -839,13 +883,15 @@
 
 /* API: get capability */
-static pj_status_t ios_stream_get_cap(pjmedia_vid_dev_stream *s,
-				      pjmedia_vid_dev_cap cap,
-				      void *pval)
-{
-    struct ios_stream *strm = (struct ios_stream*)s;
+static pj_status_t darwin_stream_get_cap(pjmedia_vid_dev_stream *s,
+				         pjmedia_vid_dev_cap cap,
+				         void *pval)
+{
+    struct darwin_stream *strm = (struct darwin_stream*)s;
     
     PJ_ASSERT_RETURN(s && pval, PJ_EINVAL);
+    PJ_UNUSED_ARG(strm);
 
     switch (cap) {
+#if TARGET_OS_IPHONE
         case PJMEDIA_VID_DEV_CAP_OUTPUT_WINDOW:
         {
@@ -855,5 +901,5 @@
             return PJ_SUCCESS;
         }
-            
+#endif /* TARGET_OS_IPHONE */
         default:
             break;
@@ -864,9 +910,9 @@
 
 /* API: set capability */
-static pj_status_t ios_stream_set_cap(pjmedia_vid_dev_stream *s,
-				      pjmedia_vid_dev_cap cap,
-				      const void *pval)
-{
-    struct ios_stream *strm = (struct ios_stream*)s;
+static pj_status_t darwin_stream_set_cap(pjmedia_vid_dev_stream *s,
+				         pjmedia_vid_dev_cap cap,
+				         const void *pval)
+{
+    struct darwin_stream *strm = (struct darwin_stream*)s;
 
     PJ_ASSERT_RETURN(s && pval, PJ_EINVAL);
@@ -902,7 +948,8 @@
 		return PJ_EINVALIDOP;
             
+#if TARGET_OS_IPHONE
             /* Create view, if none */
 	    if (!strm->render_view)
-	        ios_init_view(strm);
+	        darwin_init_view(strm);
             
             /* Preview layer instantiation should be in main thread! */
@@ -920,4 +967,5 @@
             });
             PJ_LOG(4, (THIS_FILE, "Native preview initialized"));
+#endif
             
             return PJ_SUCCESS;
@@ -930,5 +978,5 @@
             
             NSError *error;
-            struct ios_dev_info* di = strm->factory->dev_info;
+            struct darwin_dev_info* di = strm->factory->dev_info;
             pjmedia_vid_dev_switch_param *p =
                                     (pjmedia_vid_dev_switch_param*)pval;
@@ -964,5 +1012,5 @@
             
             /* Set the orientation as well */
-            ios_stream_set_cap(s, PJMEDIA_VID_DEV_CAP_ORIENTATION,
+            darwin_stream_set_cap(s, PJMEDIA_VID_DEV_CAP_ORIENTATION,
             		       &strm->param.orient);
             
@@ -970,4 +1018,5 @@
         }
         
+#if TARGET_OS_IPHONE
         case PJMEDIA_VID_DEV_CAP_FORMAT:
 	{
@@ -975,7 +1024,7 @@
             pjmedia_video_format_detail *vfd;
             pjmedia_format *fmt = (pjmedia_format *)pval;
-            ios_fmt_info *ifi;
-        
-            if (!(ifi = get_ios_format_info(fmt->id)))
+            darwin_fmt_info *ifi;
+        
+            if (!(ifi = get_darwin_format_info(fmt->id)))
                 return PJMEDIA_EVID_BADFORMAT;
         
@@ -1052,5 +1101,6 @@
             return PJ_SUCCESS;
         }
-            
+#endif /* TARGET_OS_IPHONE */
+        
         case PJMEDIA_VID_DEV_CAP_ORIENTATION:
         {
@@ -1067,4 +1117,5 @@
         
             if (strm->param.dir == PJMEDIA_DIR_RENDER) {
+#if TARGET_OS_IPHONE
             	dispatch_async(dispatch_get_main_queue(), ^{
                     strm->render_view.transform =
@@ -1072,4 +1123,5 @@
                             ((int)strm->param.orient-1) * -M_PI_2);
                 });
+#endif
 
 		return PJ_SUCCESS;
@@ -1142,11 +1194,11 @@
 
 /* API: Start stream. */
-static pj_status_t ios_stream_start(pjmedia_vid_dev_stream *strm)
-{
-    struct ios_stream *stream = (struct ios_stream*)strm;
+static pj_status_t darwin_stream_start(pjmedia_vid_dev_stream *strm)
+{
+    struct darwin_stream *stream = (struct darwin_stream*)strm;
 
     PJ_UNUSED_ARG(stream);
 
-    PJ_LOG(4, (THIS_FILE, "Starting iOS video stream"));
+    PJ_LOG(4, (THIS_FILE, "Starting Darwin video stream"));
 
     if (stream->cap_session) {
@@ -1160,5 +1212,6 @@
     
 	if (![stream->cap_session isRunning]) {
-	    PJ_LOG(3, (THIS_FILE, "Unable to start iOS capture session"));
+	    PJ_LOG(3, (THIS_FILE, "Unable to start AVFoundation capture "
+				  "session"));
 	    return PJ_EUNKNOWN;
 	}
@@ -1170,8 +1223,9 @@
 
 /* API: Put frame from stream */
-static pj_status_t ios_stream_put_frame(pjmedia_vid_dev_stream *strm,
-					const pjmedia_frame *frame)
-{
-    struct ios_stream *stream = (struct ios_stream*)strm;
+static pj_status_t darwin_stream_put_frame(pjmedia_vid_dev_stream *strm,
+					   const pjmedia_frame *frame)
+{
+#if TARGET_OS_IPHONE
+    struct darwin_stream *stream = (struct darwin_stream*)strm;
 
     if (stream->frame_size >= frame->size)
@@ -1184,17 +1238,18 @@
         [stream->vout_delegate update_image];
     });
-    
+#endif
+
     return PJ_SUCCESS;
 }
 
 /* API: Stop stream. */
-static pj_status_t ios_stream_stop(pjmedia_vid_dev_stream *strm)
-{
-    struct ios_stream *stream = (struct ios_stream*)strm;
+static pj_status_t darwin_stream_stop(pjmedia_vid_dev_stream *strm)
+{
+    struct darwin_stream *stream = (struct darwin_stream*)strm;
 
     if (!stream->cap_session || ![stream->cap_session isRunning])
         return PJ_SUCCESS;
     
-    PJ_LOG(4, (THIS_FILE, "Stopping iOS video stream"));
+    PJ_LOG(4, (THIS_FILE, "Stopping Darwin video stream"));
 
     if ([NSThread isMainThread]) {
@@ -1211,11 +1266,11 @@
 
 /* API: Destroy stream. */
-static pj_status_t ios_stream_destroy(pjmedia_vid_dev_stream *strm)
-{
-    struct ios_stream *stream = (struct ios_stream*)strm;
+static pj_status_t darwin_stream_destroy(pjmedia_vid_dev_stream *strm)
+{
+    struct darwin_stream *stream = (struct darwin_stream*)strm;
 
     PJ_ASSERT_RETURN(stream != NULL, PJ_EINVAL);
 
-    ios_stream_stop(strm);
+    darwin_stream_stop(strm);
     
     if (stream->cap_session) {
@@ -1239,4 +1294,5 @@
     }
 
+#if TARGET_OS_IPHONE
     if (stream->prev_layer) {
         CALayer *prev_layer = stream->prev_layer;
@@ -1261,4 +1317,5 @@
         stream->render_data_provider = nil;
     }
+#endif /* TARGET_OS_IPHONE */
 
     if (stream->queue) {
@@ -1279,4 +1336,3 @@
 }
 
-#endif  /* __IPHONE_4_0 */
-#endif	/* PJMEDIA_VIDEO_DEV_HAS_IOS */
+#endif	/* PJMEDIA_VIDEO_DEV_HAS_DARWIN */
