iOS: Add interface for injecting custom shaders

webrtc/sdk/objc/Framework/Classes/UI/RTCEAGLVideoView.m

 /*
  *  Copyright 2015 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 #import "WebRTC/RTCEAGLVideoView.h"
 
 #import <GLKit/GLKit.h>
 
-#import "RTCShader+Private.h"
+#import "RTCDefaultShader.h"
+#import "RTCI420TextureCache.h"
+#import "RTCNV12TextureCache.h"
 #import "WebRTC/RTCLogging.h"
 #import "WebRTC/RTCVideoFrame.h"
 
 // RTCDisplayLinkTimer wraps a CADisplayLink and is set to fire every two screen
 // refreshes, which should be 30fps. We wrap the display link in order to avoid
 // a retain cycle since CADisplayLink takes a strong reference onto its target.
 // The timer is paused by default.
 @interface RTCDisplayLinkTimer : NSObject
 
 @property(nonatomic) BOOL isPaused;
@@ skipping 64 matching lines @@
 @property(atomic, strong) RTCVideoFrame *videoFrame;
 @property(nonatomic, readonly) GLKView *glkView;
 @end
 
 @implementation RTCEAGLVideoView {
   RTCDisplayLinkTimer *_timer;
   EAGLContext *_glContext;
   // This flag should only be set and read on the main thread (e.g. by
   // setNeedsDisplay)
   BOOL _isDirty;
-  id<RTCShader> _i420Shader;
-  id<RTCShader> _nv12Shader;
+  id<RTCVideoViewShading> _shader;
+  RTCNV12TextureCache *_nv12TextureCache;
+  RTCI420TextureCache *_i420TextureCache;
   RTCVideoFrame *_lastDrawnFrame;
 }
 
 @synthesize delegate = _delegate;
 @synthesize videoFrame = _videoFrame;
 @synthesize glkView = _glkView;
 
 - (instancetype)initWithFrame:(CGRect)frame {
+  return [self initWithFrame:frame shader:[[RTCDefaultShader alloc] init]];
+}
+
+- (instancetype)initWithCoder:(NSCoder *)aDecoder {
+  return [self initWithCoder:aDecoder shader:[[RTCDefaultShader alloc] init]];
+}
+
+- (instancetype)initWithFrame:(CGRect)frame shader:(id<RTCVideoViewShading>)shader {
   if (self = [super initWithFrame:frame]) {
+    _shader = shader;
     [self configure];
   }
   return self;
 }
 
-- (instancetype)initWithCoder:(NSCoder *)aDecoder {
+- (instancetype)initWithCoder:(NSCoder *)aDecoder shader:(id<RTCVideoViewShading>)shader {
   if (self = [super initWithCoder:aDecoder]) {
+    _shader = shader;
     [self configure];
   }
   return self;
 }
 
 - (void)configure {
   EAGLContext *glContext =
     [[EAGLContext alloc] initWithAPI:kEAGLRenderingAPIOpenGLES3];
   if (!glContext) {
     glContext = [[EAGLContext alloc] initWithAPI:kEAGLRenderingAPIOpenGLES2];
@@ skipping 72 matching lines @@
 // redrawn. This occurs on main thread.
 - (void)glkView:(GLKView *)view drawInRect:(CGRect)rect {
   // The renderer will draw the frame to the framebuffer corresponding to the
   // one used by |view|.
   RTCVideoFrame *frame = self.videoFrame;
   if (!frame || frame == _lastDrawnFrame) {
     return;
   }
   [self ensureGLContext];
   glClear(GL_COLOR_BUFFER_BIT);
-  id<RTCShader> shader = nil;
   if (frame.nativeHandle) {
-    if (!_nv12Shader) {
-      _nv12Shader = [[RTCNativeNV12Shader alloc] initWithContext:_glContext];
+    if (!_nv12TextureCache) {
+      _nv12TextureCache = [[RTCNV12TextureCache alloc] initWithContext:_glContext];
     }
-    shader = _nv12Shader;
+    if (_nv12TextureCache) {
+      [_nv12TextureCache uploadFrameToTextures:frame];
+      [_shader applyShadingForFrameWithRotation:frame.rotation
+                                         yPlane:_nv12TextureCache.yTexture
+                                        uvPlane:_nv12TextureCache.uvTexture];
+      [_nv12TextureCache releaseTextures];
+    }
   } else {
-    if (!_i420Shader) {
-      _i420Shader = [[RTCI420Shader alloc] initWithContext:_glContext];
+    if (!_i420TextureCache) {
+      _i420TextureCache = [[RTCI420TextureCache alloc] initWithContext:_glContext];
     }
-    shader = _i420Shader;
-  }
-  if (shader && [shader drawFrame:frame]) {
-    _lastDrawnFrame = frame;
-  } else {
-    RTCLog(@"Failed to draw frame.");
+    [_i420TextureCache uploadFrameToTextures:frame];
+    [_shader applyShadingForFrameWithRotation:frame.rotation
+                                       yPlane:_i420TextureCache.yTexture
+                                       uPlane:_i420TextureCache.uTexture
+                                       vPlane:_i420TextureCache.vTexture];
   }
 }
 
 #pragma mark - RTCVideoRenderer
 
 // These methods may be called on non-main thread.
 - (void)setSize:(CGSize)size {
   __weak RTCEAGLVideoView *weakSelf = self;
   dispatch_async(dispatch_get_main_queue(), ^{
     RTCEAGLVideoView *strongSelf = weakSelf;
@@ skipping 32 matching lines @@
   [self ensureGLContext];
   glDisable(GL_DITHER);
   _timer.isPaused = NO;
 }
 
 - (void)teardownGL {
   self.videoFrame = nil;
   _timer.isPaused = YES;
   [_glkView deleteDrawable];
   [self ensureGLContext];
-  _i420Shader = nil;
-  _nv12Shader = nil;
+  _nv12TextureCache = nil;
+  _i420TextureCache = nil;
 }
 
 - (void)didBecomeActive {
   [self setupGL];
 }
 
 - (void)willResignActive {
   [self teardownGL];
 }
 
 - (void)ensureGLContext {
   NSAssert(_glContext, @"context shouldn't be nil");
   if ([EAGLContext currentContext] != _glContext) {
     [EAGLContext setCurrentContext:_glContext];
   }
 }
 
 @end