sysmocom
/
pjproject
11
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
pjproject/pjmedia/src/pjmedia-videodev/metal_dev.m

956 lines
31 KiB
Objective-C
Raw Blame History

/*
* Copyright (C) 2024 Teluu Inc. (http://www.teluu.com)
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#include "util.h"
#include <pjmedia-videodev/videodev_imp.h>
#include <pj/assert.h>
#include <pj/log.h>
#include <pj/os.h>
#if defined(PJMEDIA_HAS_VIDEO) && PJMEDIA_HAS_VIDEO != 0 && \
defined(PJMEDIA_VIDEO_DEV_HAS_METAL) && PJMEDIA_VIDEO_DEV_HAS_METAL != 0
#import "MetalKit/MetalKit.h"
#include "TargetConditionals.h"
#define THIS_FILE "metal_dev.m"
#define DEFAULT_CLOCK_RATE 90000
#define DEFAULT_WIDTH 640
#define DEFAULT_HEIGHT 480
#define DEFAULT_FPS 15
#if TARGET_OS_IPHONE
# define NSView UIView
# define NSWindow UIWindow
#endif
typedef struct metal_fmt_info
{
pjmedia_format_id pjmedia_format;
MTLPixelFormat metal_format;
} metal_fmt_info;
static metal_fmt_info metal_fmts[] =
{
{ PJMEDIA_FORMAT_BGRA, MTLPixelFormatBGRA8Unorm },
{ PJMEDIA_FORMAT_RGBA, MTLPixelFormatRGBA8Unorm },
};
struct metal_dev_info
{
pjmedia_vid_dev_info info;
};
/* metal factory */
struct metal_factory
{
pjmedia_vid_dev_factory base;
pj_pool_t *pool;
pj_pool_factory *pf;
unsigned dev_count;
struct metal_dev_info dev_info[1];
};
@interface MetalRenderer : NSObject<MTKViewDelegate>
@end
/* Video stream. */
struct metal_stream
{
pjmedia_vid_dev_stream base; /**< Base stream */
pjmedia_vid_dev_param param; /**< Settings */
pj_pool_t *pool; /**< Memory pool */
struct metal_factory *factory; /**< Factory */
pjmedia_vid_dev_cb vid_cb; /**< Stream callback */
void *user_data; /**< Application data */
pjmedia_rect_size size;
unsigned bytes_per_row;
unsigned frame_size; /**< Frame size (bytes)*/
pj_bool_t is_planar;
pjmedia_vid_dev_conv conv;
pjmedia_rect_size vid_size;
MetalRenderer *renderer;
MTKView *view;
MTLPixelFormat format;
NSWindow *window;
pj_bool_t is_running;
pj_bool_t is_rendering;
void *render_buf;
pj_size_t render_buf_size;
pj_timestamp frame_ts;
unsigned ts_inc;
};
/* Prototypes */
static pj_status_t metal_factory_init(pjmedia_vid_dev_factory *f);
static pj_status_t metal_factory_destroy(pjmedia_vid_dev_factory *f);
static pj_status_t metal_factory_refresh(pjmedia_vid_dev_factory *f);
static unsigned metal_factory_get_dev_count(pjmedia_vid_dev_factory *f);
static pj_status_t metal_factory_get_dev_info(pjmedia_vid_dev_factory *f,
unsigned index,
pjmedia_vid_dev_info *info);
static pj_status_t metal_factory_default_param(pj_pool_t *pool,
pjmedia_vid_dev_factory *f,
unsigned index,
pjmedia_vid_dev_param *param);
static pj_status_t metal_factory_create_stream(
pjmedia_vid_dev_factory *f,
pjmedia_vid_dev_param *param,
const pjmedia_vid_dev_cb *cb,
void *user_data,
pjmedia_vid_dev_stream **p_vid_strm);
static pj_status_t metal_stream_get_param(pjmedia_vid_dev_stream *strm,
pjmedia_vid_dev_param *param);
static pj_status_t metal_stream_get_cap(pjmedia_vid_dev_stream *strm,
pjmedia_vid_dev_cap cap,
void *value);
static pj_status_t metal_stream_set_cap(pjmedia_vid_dev_stream *strm,
pjmedia_vid_dev_cap cap,
const void *value);
static pj_status_t metal_stream_start(pjmedia_vid_dev_stream *strm);
static pj_status_t metal_stream_put_frame(pjmedia_vid_dev_stream *strm,
const pjmedia_frame *frame);
static pj_status_t metal_stream_stop(pjmedia_vid_dev_stream *strm);
static pj_status_t metal_stream_destroy(pjmedia_vid_dev_stream *strm);
/* Operations */
static pjmedia_vid_dev_factory_op factory_op =
{
&metal_factory_init,
&metal_factory_destroy,
&metal_factory_get_dev_count,
&metal_factory_get_dev_info,
&metal_factory_default_param,
&metal_factory_create_stream,
&metal_factory_refresh
};
static pjmedia_vid_dev_stream_op stream_op =
{
&metal_stream_get_param,
&metal_stream_get_cap,
&metal_stream_set_cap,
&metal_stream_start,
NULL,
&metal_stream_put_frame,
&metal_stream_stop,
&metal_stream_destroy
};
static void dispatch_sync_on_main_queue(void (^block)(void))
{
if ([NSThread isMainThread]) {
block();
} else {
dispatch_sync(dispatch_get_main_queue(), block);
}
}
/****************************************************************************
* Factory operations
*/
/*
* Init metal_ video driver.
*/
pjmedia_vid_dev_factory* pjmedia_metal_factory(pj_pool_factory *pf)
{
struct metal_factory *f;
pj_pool_t *pool;
pool = pj_pool_create(pf, "metal video", 8000, 4000, NULL);
f = PJ_POOL_ZALLOC_T(pool, struct metal_factory);
f->pf = pf;
f->pool = pool;
f->base.op = &factory_op;
return &f->base;
}
/* API: init factory */
static pj_status_t metal_factory_init(pjmedia_vid_dev_factory *f)
{
return metal_factory_refresh(f);
}
/* API: destroy factory */
static pj_status_t metal_factory_destroy(pjmedia_vid_dev_factory *f)
{
struct metal_factory *qf = (struct metal_factory*)f;
pj_pool_t *pool = qf->pool;
qf->pool = NULL;
pj_pool_release(pool);
return PJ_SUCCESS;
}
/* API: refresh the list of devices */
static pj_status_t metal_factory_refresh(pjmedia_vid_dev_factory *f)
{
struct metal_factory *qf = (struct metal_factory*)f;
if (@available(macOS 10.14, iOS 12.0, *)) {
struct metal_dev_info *qdi;
unsigned l;
/* Init output device */
qdi = &qf->dev_info[qf->dev_count++];
pj_bzero(qdi, sizeof(*qdi));
pj_ansi_strxcpy(qdi->info.name, "Metal", sizeof(qdi->info.name));
pj_ansi_strxcpy(qdi->info.driver, "Apple", sizeof(qdi->info.driver));
qdi->info.dir = PJMEDIA_DIR_RENDER;
qdi->info.has_callback = PJ_FALSE;
/* Set supported formats */
qdi->info.caps |= PJMEDIA_VID_DEV_CAP_FORMAT |
PJMEDIA_VID_DEV_CAP_OUTPUT_WINDOW |
PJMEDIA_VID_DEV_CAP_OUTPUT_RESIZE |
PJMEDIA_VID_DEV_CAP_OUTPUT_POSITION |
PJMEDIA_VID_DEV_CAP_OUTPUT_HIDE |
PJMEDIA_VID_DEV_CAP_ORIENTATION;
for (l = 0; l < PJ_ARRAY_SIZE(metal_fmts); l++) {
pjmedia_format *fmt = &qdi->info.fmt[qdi->info.fmt_cnt++];
pjmedia_format_init_video(fmt, metal_fmts[l].pjmedia_format,
DEFAULT_WIDTH, DEFAULT_HEIGHT,
DEFAULT_FPS, 1);
}
}
PJ_LOG(4, (THIS_FILE, "Metal video initialized with %d devices",
qf->dev_count));
return PJ_SUCCESS;
}
/* API: get number of devices */
static unsigned metal_factory_get_dev_count(pjmedia_vid_dev_factory *f)
{
struct metal_factory *qf = (struct metal_factory*)f;
return qf->dev_count;
}
/* API: get device info */
static pj_status_t metal_factory_get_dev_info(pjmedia_vid_dev_factory *f,
unsigned index,
pjmedia_vid_dev_info *info)
{
struct metal_factory *qf = (struct metal_factory*)f;
PJ_ASSERT_RETURN(index < qf->dev_count, PJMEDIA_EVID_INVDEV);
pj_memcpy(info, &qf->dev_info[index].info, sizeof(*info));
return PJ_SUCCESS;
}
/* API: create default device parameter */
static pj_status_t metal_factory_default_param(pj_pool_t *pool,
pjmedia_vid_dev_factory *f,
unsigned index,
pjmedia_vid_dev_param *param)
{
struct metal_factory *qf = (struct metal_factory*)f;
struct metal_dev_info *di;
PJ_ASSERT_RETURN(index < qf->dev_count, PJMEDIA_EVID_INVDEV);
PJ_UNUSED_ARG(pool);
di = &qf->dev_info[index];
pj_bzero(param, sizeof(*param));
if (di->info.dir & PJMEDIA_DIR_RENDER) {
param->dir = PJMEDIA_DIR_RENDER;
param->rend_id = index;
param->cap_id = PJMEDIA_VID_INVALID_DEV;
} else {
return PJMEDIA_EVID_INVDEV;
}
param->flags = PJMEDIA_VID_DEV_CAP_FORMAT;
param->clock_rate = DEFAULT_CLOCK_RATE;
pj_memcpy(&param->fmt, &di->info.fmt[0], sizeof(param->fmt));
return PJ_SUCCESS;
}
@implementation MetalRenderer
{
MTKView *_view;
id<MTLDevice> device;
id<MTLCommandQueue> commandQueue;
id<MTLRenderPipelineState> pipelineState;
id<MTLBuffer> vertexBuffer;
id<MTLBuffer> textureCoordBuffer;
@public
struct metal_stream *stream;
}
#define _STRINGIFY( _x ) # _x
- (nonnull instancetype)initWithMetalKitView:(nonnull MTKView *)mtkView
{
self = [super init];
if (self) {
NSString *code;
NSError *error = nil;
id<MTLLibrary> shaderLibrary;
id <MTLFunction> fragmentProgram;
id <MTLFunction> vertexProgram;
MTLRenderPipelineDescriptor *pQuadPipelineStateDescriptor;
/* Create a buffer for a full-screen quad */
static const float vertexData[] = {
-1.0, -1.0, 0.0, 1.0,
1.0, -1.0, 0.0, 1.0,
-1.0, 1.0, 0.0, 1.0,
1.0, 1.0, 0.0, 1.0,
};
/* Create texture coordinates for a full-screen quad */
static const float textureCoordinates[] = {
0.0, 1.0,
1.0, 1.0,
0.0, 0.0,
1.0, 0.0,
};
_view = mtkView;
device = mtkView.device;
/* Create the command queue */
commandQueue = [device newCommandQueue];
/* Metal shader code */
code = [NSString stringWithFormat:@"#include <metal_stdlib>\n%s",
_STRINGIFY(
using namespace metal;
struct VertexInOut
{
float4 m_Position [[position]];
float2 m_TexCoord [[user(texturecoord)]];
};
vertex VertexInOut
texturedVertex(constant float4 *pPosition [[ buffer(0) ]],
constant packed_float2 *pTexCoords [[ buffer(1) ]],
constant float4x4 *pMVP [[ buffer(2) ]],
uint vid [[ vertex_id ]])
{
VertexInOut outVertices;
outVertices.m_Position = pPosition[vid];
outVertices.m_TexCoord = pTexCoords[vid];
return outVertices;
}
fragment half4
texturedFrag(VertexInOut inFrag [[ stage_in ]],
texture2d<half> tex2D [[ texture(0) ]])
{
constexpr sampler quad_sampler;
half4 color = tex2D.sample(quad_sampler, inFrag.m_TexCoord);
return color;
}
)];
/* Create a Metal library instance by compiling the code */
shaderLibrary = [device newLibraryWithSource:code options:nil
error:&error];
if (error) {
NSLog(@"Unable to create Metal library err: %@", error);
return self;
}
fragmentProgram = [shaderLibrary newFunctionWithName:@"texturedFrag"];
vertexProgram = [shaderLibrary newFunctionWithName:@"texturedVertex"];
if (!fragmentProgram || !vertexProgram) {
NSLog(@"Unable to load Metal functions");
return self;
}
/* Create a pipeline state */
pQuadPipelineStateDescriptor = [MTLRenderPipelineDescriptor new];
pQuadPipelineStateDescriptor.colorAttachments[0].pixelFormat =
stream->format;
pQuadPipelineStateDescriptor.vertexFunction = vertexProgram;
pQuadPipelineStateDescriptor.fragmentFunction = fragmentProgram;
pipelineState = [device
newRenderPipelineStateWithDescriptor:pQuadPipelineStateDescriptor
error:&error];
if (error) {
NSLog(@"newRenderPipelineStateWithDescriptor err: %@", error);
return self;
}
vertexBuffer = [device newBufferWithBytes:vertexData
length:sizeof(vertexData)
options:MTLResourceStorageModeShared];
textureCoordBuffer = [device newBufferWithBytes:textureCoordinates
length:sizeof(textureCoordinates)
options:MTLResourceStorageModeShared];
}
return self;
}
- (void)dealloc {
if (vertexBuffer) {
[vertexBuffer release];
vertexBuffer = nil;
}
if (textureCoordBuffer) {
[textureCoordBuffer release];
textureCoordBuffer = nil;
}
if (device) {
[device release];
device = nil;
}
if (commandQueue) {
[commandQueue release];
commandQueue = nil;
}
if (pipelineState) {
[pipelineState release];
pipelineState = nil;
}
[super dealloc];
}
- (void)update_image
{
MTLRenderPassDescriptor *renderPassDescriptor;
id<MTLCommandBuffer> commandBuffer;
id<MTLRenderCommandEncoder> renderEncoder;
id<MTLDrawable> drawable;
id<MTLTexture> texture;
MTLTextureDescriptor *textureDescriptor;
MTLRegion region;
unsigned width = stream->size.w, height = stream->size.h;
/* Place the buffer into a texture */
textureDescriptor = [MTLTextureDescriptor
texture2DDescriptorWithPixelFormat:stream->format
width:width height:height mipmapped:NO];
texture = [device newTextureWithDescriptor:textureDescriptor];
region = MTLRegionMake2D(0, 0, width, height);
[texture replaceRegion:region mipmapLevel:0 withBytes:stream->render_buf
bytesPerRow:stream->bytes_per_row];
/* The render pass descriptor references the texture into which Metal
* should draw.
*/
renderPassDescriptor = _view.currentRenderPassDescriptor;
if (renderPassDescriptor == nil)
return;
commandBuffer = [commandQueue commandBuffer];
renderEncoder = [commandBuffer renderCommandEncoderWithDescriptor:
renderPassDescriptor];
[renderEncoder setRenderPipelineState:pipelineState];
[renderEncoder setVertexBuffer:vertexBuffer offset:0 atIndex:0];
[renderEncoder setVertexBuffer:textureCoordBuffer offset:0 atIndex:1];
[renderEncoder setFragmentTexture:texture atIndex:0];
[renderEncoder drawPrimitives:MTLPrimitiveTypeTriangleStrip vertexStart:0
vertexCount:4];
[renderEncoder endEncoding];
/* Get the drawable that will be presented at the end of the frame */
drawable = _view.currentDrawable;
/* Request that the drawable texture be presented by the windowing system
* once drawing is done.
*/
[commandBuffer presentDrawable:drawable];
[commandBuffer commit];
stream->is_rendering = PJ_FALSE;
}
/* Called whenever the view needs to render a frame. */
- (void)drawInMTKView:(nonnull MTKView *)view
{
}
/* Called whenever view changes orientation or is resized */
- (void)mtkView:(nonnull MTKView *)view drawableSizeWillChange:(CGSize)size
{
}
@end
static pj_status_t metal_init_view(struct metal_stream *strm)
{
pjmedia_vid_dev_param *param = &strm->param;
CGRect view_rect = CGRectMake(0, 0, param->fmt.det.vid.size.w,
param->fmt.det.vid.size.h);
if (param->flags & PJMEDIA_VID_DEV_CAP_OUTPUT_RESIZE) {
view_rect.size.width = param->disp_size.w;
view_rect.size.height = param->disp_size.h;
}
if (param->flags & PJMEDIA_VID_DEV_CAP_OUTPUT_POSITION) {
view_rect.origin.x = param->window_pos.x;
view_rect.origin.y = param->window_pos.y;
}
strm->view = [[MTKView alloc] initWithFrame:view_rect];
if (!strm->view)
return PJMEDIA_EVID_SYSERR;
strm->view.enableSetNeedsDisplay = NO;
strm->view.paused = NO;
strm->view.device = MTLCreateSystemDefaultDevice();
strm->view.clearColor = MTLClearColorMake(0.0, 0.0, 0.0, 1.0);
strm->param.window.info.window = strm->view;
strm->renderer = [MetalRenderer alloc];
if (!strm->renderer)
return PJ_ENOMEM;
strm->renderer->stream = strm;
strm->view.delegate = strm->renderer;
[strm->renderer initWithMetalKitView:strm->view];
if (param->flags & PJMEDIA_VID_DEV_CAP_OUTPUT_WINDOW) {
PJ_ASSERT_RETURN(param->window.info.ios.window, PJ_EINVAL);
metal_stream_set_cap(&strm->base, PJMEDIA_VID_DEV_CAP_OUTPUT_WINDOW,
param->window.info.ios.window);
} else {
#if !TARGET_OS_IPHONE
/* Create the main window */
strm->window = [[NSWindow alloc] initWithContentRect:view_rect
styleMask:(NSWindowStyleMaskTitled |
NSWindowStyleMaskClosable |
NSWindowStyleMaskResizable)
backing:NSBackingStoreBuffered
defer:NO];
if (!strm->window)
return PJMEDIA_EVID_SYSERR;
/* Make the window visible */
[strm->window.contentView addSubview:strm->view];
[strm->window makeKeyAndOrderFront:strm->window];
strm->param.window.info.window = strm->window;
#endif
}
if (param->flags & PJMEDIA_VID_DEV_CAP_OUTPUT_HIDE) {
metal_stream_set_cap(&strm->base, PJMEDIA_VID_DEV_CAP_OUTPUT_HIDE,
&param->window_hide);
}
if (param->flags & PJMEDIA_VID_DEV_CAP_ORIENTATION) {
metal_stream_set_cap(&strm->base, PJMEDIA_VID_DEV_CAP_ORIENTATION,
&param->orient);
}
return PJ_SUCCESS;
}
static metal_fmt_info* get_metal_format_info(pjmedia_format_id id)
{
unsigned i;
for (i = 0; i < PJ_ARRAY_SIZE(metal_fmts); i++) {
if (metal_fmts[i].pjmedia_format == id)
return &metal_fmts[i];
}
return NULL;
}
/* API: create stream */
static pj_status_t metal_factory_create_stream(
pjmedia_vid_dev_factory *f,
pjmedia_vid_dev_param *param,
const pjmedia_vid_dev_cb *cb,
void *user_data,
pjmedia_vid_dev_stream **p_vid_strm)
{
struct metal_factory *qf = (struct metal_factory*)f;
pj_pool_t *pool;
struct metal_stream *strm;
pjmedia_video_format_detail *vfd;
const pjmedia_video_format_info *vfi;
metal_fmt_info *mfi;
pj_status_t status = PJ_SUCCESS;
PJ_ASSERT_RETURN(f && param && p_vid_strm, PJ_EINVAL);
PJ_ASSERT_RETURN(param->fmt.type == PJMEDIA_TYPE_VIDEO &&
param->fmt.detail_type == PJMEDIA_FORMAT_DETAIL_VIDEO &&
param->dir == PJMEDIA_DIR_RENDER,
PJ_EINVAL);
if (!(mfi = get_metal_format_info(param->fmt.id)))
return PJMEDIA_EVID_BADFORMAT;
vfi = pjmedia_get_video_format_info(NULL, param->fmt.id);
if (!vfi)
return PJMEDIA_EVID_BADFORMAT;
/* Create and Initialize stream descriptor */
pool = pj_pool_create(qf->pf, "metal-dev", 4000, 4000, NULL);
PJ_ASSERT_RETURN(pool != NULL, PJ_ENOMEM);
strm = PJ_POOL_ZALLOC_T(pool, struct metal_stream);
pj_memcpy(&strm->param, param, sizeof(*param));
strm->pool = pool;
pj_memcpy(&strm->vid_cb, cb, sizeof(*cb));
strm->user_data = user_data;
strm->factory = qf;
vfd = pjmedia_format_get_video_format_detail(&strm->param.fmt, PJ_TRUE);
pj_memcpy(&strm->size, &vfd->size, sizeof(vfd->size));
strm->bytes_per_row = strm->size.w * vfi->bpp / 8;
strm->frame_size = strm->bytes_per_row * strm->size.h;
strm->ts_inc = PJMEDIA_SPF2(param->clock_rate, &vfd->fps, 1);
strm->is_planar = vfi->plane_cnt > 1;
strm->format = mfi->metal_format;
if (param->dir & PJMEDIA_DIR_RENDER) {
/* Create renderer stream here */
dispatch_sync_on_main_queue(^{
metal_init_view(strm);
});
strm->render_buf = pj_pool_alloc(pool, strm->frame_size);
strm->render_buf_size = strm->frame_size;
PJ_LOG(4, (THIS_FILE, "Metal renderer initialized"));
}
/* Done */
strm->base.op = &stream_op;
*p_vid_strm = &strm->base;
return PJ_SUCCESS;
on_error:
metal_stream_destroy((pjmedia_vid_dev_stream *)strm);
return status;
}
/* API: Get stream info. */
static pj_status_t metal_stream_get_param(pjmedia_vid_dev_stream *s,
pjmedia_vid_dev_param *pi)
{
struct metal_stream *strm = (struct metal_stream*)s;
PJ_ASSERT_RETURN(strm && pi, PJ_EINVAL);
pj_memcpy(pi, &strm->param, sizeof(*pi));
return PJ_SUCCESS;
}
/* API: get capability */
static pj_status_t metal_stream_get_cap(pjmedia_vid_dev_stream *s,
pjmedia_vid_dev_cap cap,
void *pval)
{
struct metal_stream *strm = (struct metal_stream*)s;
PJ_ASSERT_RETURN(s && pval, PJ_EINVAL);
PJ_UNUSED_ARG(strm);
switch (cap) {
case PJMEDIA_VID_DEV_CAP_OUTPUT_WINDOW:
{
pjmedia_vid_dev_hwnd *hwnd = (pjmedia_vid_dev_hwnd *) pval;
hwnd->type = TARGET_OS_IPHONE? PJMEDIA_VID_DEV_HWND_TYPE_IOS:
PJMEDIA_VID_DEV_HWND_TYPE_COCOA;
hwnd->info.window = (void *)strm->view;
return PJ_SUCCESS;
}
default:
break;
}
return PJMEDIA_EVID_INVCAP;
}
/* API: set capability */
static pj_status_t metal_stream_set_cap(pjmedia_vid_dev_stream *s,
pjmedia_vid_dev_cap cap,
const void *pval)
{
struct metal_stream *strm = (struct metal_stream*)s;
PJ_ASSERT_RETURN(s && pval, PJ_EINVAL);
switch (cap) {
case PJMEDIA_VID_DEV_CAP_FORMAT:
{
const pjmedia_video_format_info *vfi;
pjmedia_video_format_detail *vfd;
pjmedia_format *fmt = (pjmedia_format *)pval;
metal_fmt_info *ifi;
if (!(ifi = get_metal_format_info(fmt->id)))
return PJMEDIA_EVID_BADFORMAT;
vfi = pjmedia_get_video_format_info(
pjmedia_video_format_mgr_instance(),
fmt->id);
if (!vfi)
return PJMEDIA_EVID_BADFORMAT;
pjmedia_format_copy(&strm->param.fmt, fmt);
vfd = pjmedia_format_get_video_format_detail(fmt, PJ_TRUE);
pj_memcpy(&strm->size, &vfd->size, sizeof(vfd->size));
strm->bytes_per_row = strm->size.w * vfi->bpp / 8;
strm->frame_size = strm->bytes_per_row * strm->size.h;
if (strm->render_buf_size < strm->frame_size) {
/* Realloc only when needed */
strm->render_buf = pj_pool_alloc(strm->pool, strm->frame_size);
strm->render_buf_size = strm->frame_size;
}
return PJ_SUCCESS;
}
case PJMEDIA_VID_DEV_CAP_OUTPUT_WINDOW:
{
strm->param.window.info.window = (void *)pval;
dispatch_sync_on_main_queue(^{
[(NSView *)pval addSubview:strm->view];
});
return PJ_SUCCESS;
}
case PJMEDIA_VID_DEV_CAP_OUTPUT_RESIZE:
{
pj_memcpy(&strm->param.disp_size, pval,
sizeof(strm->param.disp_size));
dispatch_sync_on_main_queue(^{
CGRect r = (strm->window)? strm->window.frame:
strm->view.bounds;
r.size = CGSizeMake(strm->param.disp_size.w,
strm->param.disp_size.h);
if (!strm->window)
strm->view.bounds = r;
#if !TARGET_OS_IPHONE
else
[strm->window setFrame:r display:YES];
#endif
});
return PJ_SUCCESS;
}
case PJMEDIA_VID_DEV_CAP_OUTPUT_POSITION:
{
pj_memcpy(&strm->param.window_pos, pval,
sizeof(strm->param.window_pos));
dispatch_sync_on_main_queue(^{
#if TARGET_OS_IPHONE
strm->view.center =
CGPointMake(strm->param.window_pos.x +
strm->param.disp_size.w/2.0,
strm->param.window_pos.y +
strm->param.disp_size.h/2.0);
#else
if (strm->window) {
[strm->window setFrameOrigin:
NSMakePoint(strm->param.window_pos.x,
strm->param.window_pos.y)];
} else {
[strm->view setFrameOrigin:
NSMakePoint(strm->param.window_pos.x,
strm->param.window_pos.y)];
}
#endif
});
return PJ_SUCCESS;
}
case PJMEDIA_VID_DEV_CAP_OUTPUT_HIDE:
{
dispatch_sync_on_main_queue(^{
pj_bool_t hide = *((pj_bool_t *)pval);
if (strm->window) {
#if !TARGET_OS_IPHONE
if (hide)
[strm->window orderOut: nil];
else
[strm->window orderFront: nil];
#endif
} else {
strm->view.hidden = (BOOL)hide;
}
});
return PJ_SUCCESS;
}
case PJMEDIA_VID_DEV_CAP_ORIENTATION:
{
pjmedia_orient orient = *(pjmedia_orient *)pval;
pj_assert(orient >= PJMEDIA_ORIENT_UNKNOWN &&
orient <= PJMEDIA_ORIENT_ROTATE_270DEG);
if (orient == PJMEDIA_ORIENT_UNKNOWN)
return PJ_EINVAL;
pj_memcpy(&strm->param.orient, pval,
sizeof(strm->param.orient));
dispatch_sync_on_main_queue(^{
CGFloat angle = -M_PI_2 * ((int)strm->param.orient-1);
#if TARGET_OS_IPHONE
strm->view.transform =
CGAffineTransformMakeRotation(angle);
#else
strm->view.layer.affineTransform =
CGAffineTransformMakeRotation(angle);
#endif
});
return PJ_SUCCESS;
}
default:
break;
}
return PJMEDIA_EVID_INVCAP;
}
/* API: Start stream. */
static pj_status_t metal_stream_start(pjmedia_vid_dev_stream *strm)
{
struct metal_stream *stream = (struct metal_stream*)strm;
PJ_LOG(4, (THIS_FILE, "Starting Metal video stream"));
stream->is_running = PJ_TRUE;
return PJ_SUCCESS;
}
/* API: Put frame from stream */
static pj_status_t metal_stream_put_frame(pjmedia_vid_dev_stream *strm,
const pjmedia_frame *frame)
{
struct metal_stream *stream = (struct metal_stream*)strm;
/* Video conference just trying to send heart beat for updating timestamp
* or keep-alive, this port doesn't need any, just ignore.
*/
if (frame->size==0 || frame->buf==NULL)
return PJ_SUCCESS;
if (!stream->is_running)
return PJ_EINVALIDOP;
/* Prevent more than one async rendering task. */
if (stream->is_rendering)
return PJ_EIGNORED;
if (stream->frame_size >= frame->size)
pj_memcpy(stream->render_buf, frame->buf, frame->size);
else
pj_memcpy(stream->render_buf, frame->buf, stream->frame_size);
/* Perform video display in the main thread */
stream->is_rendering = PJ_TRUE;
[stream->renderer performSelectorOnMainThread:@selector(update_image)
withObject:nil waitUntilDone:NO];
return PJ_SUCCESS;
}
/* API: Stop stream. */
static pj_status_t metal_stream_stop(pjmedia_vid_dev_stream *strm)
{
struct metal_stream *stream = (struct metal_stream*)strm;
unsigned i;
PJ_LOG(4, (THIS_FILE, "Stopping Metal video stream"));
stream->is_running = PJ_FALSE;
/* Wait until the rendering finishes */
for (i = 0; i < 15; i++) pj_thread_sleep(10);
while (stream->is_rendering);
return PJ_SUCCESS;
}
/* API: Destroy stream. */
static pj_status_t metal_stream_destroy(pjmedia_vid_dev_stream *strm)
{
struct metal_stream *stream = (struct metal_stream*)strm;
PJ_ASSERT_RETURN(stream != NULL, PJ_EINVAL);
metal_stream_stop(strm);
if (stream->renderer) {
[stream->renderer release];
stream->renderer = nil;
}
if (stream->view) {
[stream->view
performSelectorOnMainThread:@selector(removeFromSuperview)
withObject:nil waitUntilDone:YES];
[stream->view release];
stream->view = nil;
}
if (stream->window) {
[stream->window performSelectorOnMainThread:@selector(close)
withObject:nil waitUntilDone:YES];
stream->window = nil;
}
pjmedia_vid_dev_conv_destroy_converter(&stream->conv);
pj_pool_release(stream->pool);
return PJ_SUCCESS;
}
#endif /* PJMEDIA_VIDEO_DEV_HAS_METAL */
Reference in New Issue View Git Blame Copy Permalink