Move Objective-C video renderers to webrtc/api/objc.

webrtc/api/objc/RTCOpenGLVideoRenderer.mm

 /*
- * libjingle
- * Copyright 2014 Google Inc.
+ *  Copyright 2015 The WebRTC project authors. All Rights Reserved.
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *
- *  1. Redistributions of source code must retain the above copyright notice,
- *     this list of conditions and the following disclaimer.
- *  2. Redistributions in binary form must reproduce the above copyright notice,
- *     this list of conditions and the following disclaimer in the documentation
- *     and/or other materials provided with the distribution.
- *  3. The name of the author may not be used to endorse or promote products
- *     derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
- * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
- * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
- * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
- * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *  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.
  */
 
-#if !defined(__has_feature) || !__has_feature(objc_arc)
-#error "This file requires ARC support."
-#endif
-
 #import "RTCOpenGLVideoRenderer.h"
 
 #include <string.h>
 
 #include "webrtc/base/scoped_ptr.h"
 
 #if TARGET_OS_IPHONE
 #import <OpenGLES/ES3/gl.h>
 #else
 #import <OpenGL/gl3.h>
 #endif
 
-#import "RTCI420Frame.h"
+#import "RTCVideoFrame.h"
 
 // TODO(tkchin): check and log openGL errors. Methods here return BOOLs in
 // anticipation of that happening in the future.
 
 #if TARGET_OS_IPHONE
 #define RTC_PIXEL_FORMAT GL_LUMINANCE
 #define SHADER_VERSION
 #define VERTEX_SHADER_IN "attribute"
 #define VERTEX_SHADER_OUT "varying"
 #define FRAGMENT_SHADER_IN "varying"
@@ skipping 40 matching lines @@
   "    u = u - 0.5;\n"
   "    v = v - 0.5;\n"
   "    r = y + 1.403 * v;\n"
   "    g = y - 0.344 * u - 0.714 * v;\n"
   "    b = y + 1.770 * u;\n"
   "    " FRAGMENT_SHADER_COLOR " = vec4(r, g, b, 1.0);\n"
   "  }\n";
 
 // Compiles a shader of the given |type| with GLSL source |source| and returns
 // the shader handle or 0 on error.
-GLuint CreateShader(GLenum type, const GLchar* source) {
+GLuint CreateShader(GLenum type, const GLchar *source) {
   GLuint shader = glCreateShader(type);
   if (!shader) {
     return 0;
   }
   glShaderSource(shader, 1, &source, NULL);
   glCompileShader(shader);
   GLint compileStatus = GL_FALSE;
   glGetShaderiv(shader, GL_COMPILE_STATUS, &compileStatus);
   if (compileStatus == GL_FALSE) {
     glDeleteShader(shader);
@@ skipping 41 matching lines @@
 
 // |kNumTextures| must not exceed 8, which is the limit in OpenGLES2. Two sets
 // of 3 textures are used here, one for each of the Y, U and V planes. Having
 // two sets alleviates CPU blockage in the event that the GPU is asked to render
 // to a texture that is already in use.
 static const GLsizei kNumTextureSets = 2;
 static const GLsizei kNumTextures = 3 * kNumTextureSets;
 
 @implementation RTCOpenGLVideoRenderer {
 #if TARGET_OS_IPHONE
-  EAGLContext* _context;
+  EAGLContext *_context;
 #else
-  NSOpenGLContext* _context;
+  NSOpenGLContext *_context;
 #endif
   BOOL _isInitialized;
   NSUInteger _currentTextureSet;
   // Handles for OpenGL constructs.
   GLuint _textures[kNumTextures];
   GLuint _program;
 #if !TARGET_OS_IPHONE
   GLuint _vertexArray;
 #endif
   GLuint _vertexBuffer;
   GLint _position;
   GLint _texcoord;
   GLint _ySampler;
   GLint _uSampler;
   GLint _vSampler;
   // Used to create a non-padded plane for GPU upload when we receive padded
   // frames.
   rtc::scoped_ptr<uint8_t[]> _planeBuffer;
 }
 
+@synthesize lastDrawnFrame = _lastDrawnFrame;
+
 + (void)initialize {
   // Disable dithering for performance.
   glDisable(GL_DITHER);
 }
 
 #if TARGET_OS_IPHONE
-- (instancetype)initWithContext:(EAGLContext*)context {
+- (instancetype)initWithContext:(EAGLContext *)context {
 #else
-- (instancetype)initWithContext:(NSOpenGLContext*)context {
+- (instancetype)initWithContext:(NSOpenGLContext *)context {
 #endif
   NSAssert(context != nil, @"context cannot be nil");
   if (self = [super init]) {
     _context = context;
   }
   return self;
 }
 
-- (BOOL)drawFrame:(RTCI420Frame*)frame {
+- (BOOL)drawFrame:(RTCVideoFrame *)frame {
   if (!_isInitialized) {
     return NO;
   }
   if (_lastDrawnFrame == frame) {
     return NO;
   }
   [self ensureGLContext];
   glClear(GL_COLOR_BUFFER_BIT);
   if (frame) {
     if (![self updateTextureSizesForFrame:frame] ||
@@ skipping 100 matching lines @@
     glActiveTexture(GL_TEXTURE0 + i);
     glBindTexture(GL_TEXTURE_2D, _textures[i]);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
   }
   return YES;
 }
 
-- (BOOL)updateTextureSizesForFrame:(RTCI420Frame*)frame {
+- (BOOL)updateTextureSizesForFrame:(RTCVideoFrame *)frame {
   if (frame.height == _lastDrawnFrame.height &&
       frame.width == _lastDrawnFrame.width &&
       frame.chromaWidth == _lastDrawnFrame.chromaWidth &&
       frame.chromaHeight == _lastDrawnFrame.chromaHeight) {
     return YES;
   }
   GLsizei lumaWidth = frame.width;
   GLsizei lumaHeight = frame.height;
   GLsizei chromaWidth = frame.chromaWidth;
   GLsizei chromaHeight = frame.chromaHeight;
@@ skipping 22 matching lines @@
     glTexImage2D(GL_TEXTURE_2D,
                  0,
                  RTC_PIXEL_FORMAT,
                  chromaWidth,
                  chromaHeight,
                  0,
                  RTC_PIXEL_FORMAT,
                  GL_UNSIGNED_BYTE,
                  0);
   }
-  if (frame.yPitch != frame.width || frame.uPitch != frame.chromaWidth ||
-      frame.vPitch != frame.chromaWidth) {
+  if ((NSUInteger)frame.yPitch != frame.width ||
+      (NSUInteger)frame.uPitch != frame.chromaWidth ||
+      (NSUInteger)frame.vPitch != frame.chromaWidth) {
     _planeBuffer.reset(new uint8_t[frame.width * frame.height]);
   } else {
     _planeBuffer.reset();
   }
   return YES;
 }
 
-- (void)uploadPlane:(const uint8_t*)plane
+- (void)uploadPlane:(const uint8_t *)plane
             sampler:(GLint)sampler
              offset:(NSUInteger)offset
-              width:(NSUInteger)width
-             height:(NSUInteger)height
-             stride:(NSInteger)stride {
+              width:(size_t)width
+             height:(size_t)height
+             stride:(int32_t)stride {
   glActiveTexture(GL_TEXTURE0 + offset);
   // When setting texture sampler uniforms, the texture index is used not
   // the texture handle.
   glUniform1i(sampler, offset);
 #if TARGET_OS_IPHONE
   BOOL hasUnpackRowLength = _context.API == kEAGLRenderingAPIOpenGLES3;
 #else
   BOOL hasUnpackRowLength = YES;
 #endif
-  const uint8_t* uploadPlane = plane;
-  if (stride != width) {
+  const uint8_t *uploadPlane = plane;
+  if ((size_t)stride != width) {
    if (hasUnpackRowLength) {
       // GLES3 allows us to specify stride.
       glPixelStorei(GL_UNPACK_ROW_LENGTH, stride);
       glTexImage2D(GL_TEXTURE_2D,
                    0,
                    RTC_PIXEL_FORMAT,
                    width,
                    height,
                    0,
                    RTC_PIXEL_FORMAT,
                    GL_UNSIGNED_BYTE,
                    uploadPlane);
       glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
       return;
     } else {
       // Make an unpadded copy and upload that instead. Quick profiling showed
       // that this is faster than uploading row by row using glTexSubImage2D.
-      uint8_t* unpaddedPlane = _planeBuffer.get();
-      for (NSUInteger y = 0; y < height; ++y) {
+      uint8_t *unpaddedPlane = _planeBuffer.get();
+      for (size_t y = 0; y < height; ++y) {
         memcpy(unpaddedPlane + y * width, plane + y * stride, width);
       }
       uploadPlane = unpaddedPlane;
     }
   }
   glTexImage2D(GL_TEXTURE_2D,
                0,
                RTC_PIXEL_FORMAT,
                width,
                height,
                0,
                RTC_PIXEL_FORMAT,
                GL_UNSIGNED_BYTE,
                uploadPlane);
 }
 
-- (BOOL)updateTextureDataForFrame:(RTCI420Frame*)frame {
+- (BOOL)updateTextureDataForFrame:(RTCVideoFrame *)frame {
   NSUInteger textureOffset = _currentTextureSet * 3;
   NSAssert(textureOffset + 3 <= kNumTextures, @"invalid offset");
 
   [self uploadPlane:frame.yPlane
             sampler:_ySampler
              offset:textureOffset
               width:frame.width
              height:frame.height
              stride:frame.yPitch];
 
@@ skipping 33 matching lines @@
 #endif
     return NO;
   }
   glBindBuffer(GL_ARRAY_BUFFER, _vertexBuffer);
   glBufferData(GL_ARRAY_BUFFER, sizeof(gVertices), gVertices, GL_DYNAMIC_DRAW);
 
   // Read position attribute from |gVertices| with size of 2 and stride of 4
   // beginning at the start of the array. The last argument indicates offset
   // of data within |gVertices| as supplied to the vertex buffer.
   glVertexAttribPointer(
-      _position, 2, GL_FLOAT, GL_FALSE, 4 * sizeof(GLfloat), (void*)0);
+      _position, 2, GL_FLOAT, GL_FALSE, 4 * sizeof(GLfloat), (void *)0);
   glEnableVertexAttribArray(_position);
 
   // Read texcoord attribute from |gVertices| with size of 2 and stride of 4
   // beginning at the first texcoord in the array. The last argument indicates
   // offset of data within |gVertices| as supplied to the vertex buffer.
   glVertexAttribPointer(_texcoord,
                         2,
                         GL_FLOAT,
                         GL_FALSE,
                         4 * sizeof(GLfloat),
-                        (void*)(2 * sizeof(GLfloat)));
+                        (void *)(2 * sizeof(GLfloat)));
   glEnableVertexAttribArray(_texcoord);
 
   return YES;
 }
 
 @end