以下代码适用于Objective-C：

#import <Foundation/Foundation.h>
#import <VideoToolBox/VideoToolBox.h>

int main(int argc,const char * argv[]) {
    @autoreleasepool {
        VTCompressionSessionRef session;
        VTCompressionSessionCreate(NULL,500,kCMVideoCodecType_H264,NULL,&session);

        NSLog(@"created VTCompressionSession");
    }
    return 0;
}

但无论我尝试过什么,我都找不到将VTCompressionSessionCreate导入swift的方法.

import Foundation
import VideoToolBox

VideoToolBox.VTCompressionSessionCreate()

println("created VTCompressionSession")

例如,此代码中断：模块“VideoToolBox”没有名为“VTCompressionSessionCreate”的成员.
只需调用VTCompressionSessionCreate就会创建错误消息Use of unresolved identifier’VTCompressionSessionCreate’.

看起来它没有暴露在swift中,因为我可以调用像VTCompressionSessionEncodeFrame这样的方法.我错过了一些明显的东西吗

Compression.h

#import <VideoToolBox/VideoToolBox.h>
VTCompressionSessionRef CreateCompressionSession();

Compression.m

#import <Cocoa/Cocoa.h>
#import <Foundation/Foundation.h>
#import <VideoToolBox/VideoToolBox.h>

VTCompressionSessionRef CreateCompressionSession(){
    NSLog(@"CreateCompressionSession");
    VTCompressionSessionRef session;
    VTCompressionSessionCreate(NULL,&session);
    return session;
}

流桥接-Header.h

#import "CompressionSession.h"

现在,您可以在swift中运行以下代码：

import Cocoa
import Foundation
import VideoToolBox

let session = CreateCompressionSession()

public static String getAttributeValue(PsiAnnotation annotation,String attributeName,DefaultPolicy policy) {
  final PsiAnnotationMemberValue value = getAnnotationMemberValue(annotation,attributeName);
  if (value != null) {
    if (value instanceof PsiClassObjectAccessExpression) {
      final PsiType type = ((PsiClassObjectAccessExpression) value).getType();
      if (type == null) {
        return null;
      }
      return type.getCanonicalText();
    }
    else {
      final String text = value.getText();
      return text.substring(1,text.length() - 1);
    }
  }

  if (policy == DefaultPolicy.OWNER_IDENTIFIER_NAME) {
    return PsiUtil.getName(getImmediateOwnerElement(annotation));
  }
  else {
    return null;
  }
}

public static Location getParameterizedLocation(PsiClass psiClass,String paramSetName,String parameterizedClassName)
{
    final PsiAnnotation annotation = AnnotationUtil.findAnnotationInHierarchy(psiClass,Collections.singleton(JUnitUtil.RUN_WITH));
    if(annotation != null)
    {
        final PsiAnnotationMemberValue attributeValue = annotation.findAttributeValue("value");
        if(attributeValue instanceof PsiClassObjectAccessExpression)
        {
            final PsiTypeElement operand = ((PsiClassObjectAccessExpression) attributeValue).getoperand();
            if(InheritanceUtil.isInheritor(operand.getType(),parameterizedClassName))
            {
                return new PsiMemberParameterizedLocation(psiClass.getProject(),psiClass,null,paramSetName);
            }
        }
    }
    return null;
}

@Nullable
@Override
public String getTemplateString(PsiElement psiElement) {
    String clazz;
    if (psiElement instanceof PsiReference) {
        // foo.mock
        PsiReference psiReference = (PsiReference) psiElement;
        PsiLocalVariable psiLocalVariable = (PsiLocalVariable) psiReference.resolve();
        if (psiLocalVariable == null) {
            return psiElement.getText();
        }
        PsiType psiType = psiLocalVariable.getType();
        clazz = psiType.getPresentableText() + ".class";
    } else if (psiElement instanceof PsiClassObjectAccessExpression) {
        // String.class.mock
        PsiClassObjectAccessExpression psiClassObjectAccessExpression = (PsiClassObjectAccessExpression) psiElement;
        String classtext = psiClassObjectAccessExpression.getText();
        if (classtext == null) {
            return psiElement.getText();
        }
        clazz = classtext;
    } else {
        return psiElement.getText();
    }

    return "org.mockito.Mockito.mock(" + clazz + ")$END$";
}

@Override
public void fillActions(LookupElement element,Lookup lookup,Consumer<LookupElementAction> consumer)
{
    Object o = element.getobject();
    if(o instanceof PsiClassObjectAccessExpression)
    {
        o = PsiUtil.resolveClassInType(((PsiClassObjectAccessExpression) o).getoperand().getType());
    }

    if(o instanceof PsiClass)
    {
        PsiClass clazz = (PsiClass) o;
        addExcludes(consumer,clazz,clazz.getQualifiedname());
    }
    else if(o instanceof PsiMethod)
    {
        final PsiMethod method = (PsiMethod) o;
        if(method.hasModifierProperty(PsiModifier.STATIC))
        {
            addExcludes(consumer,method,PsiUtil.getMemberQualifiedname(method));
        }
    }
    else if(o instanceof PsiField)
    {
        final PsiField field = (PsiField) o;
        if(field.hasModifierProperty(PsiModifier.STATIC))
        {
            addExcludes(consumer,field,PsiUtil.getMemberQualifiedname(field));
        }
    }
}

public boolean satisfiedBy(PsiElement element) {
  if (!(element instanceof PsipolyadicExpression)) {
    return false;
  }
  if (element instanceof PsiLiteralExpression || element instanceof PsiClassObjectAccessExpression) {
    return false;
  }
  final PsipolyadicExpression expression = (PsipolyadicExpression)element;
  final PsiType expressionType = expression.getType();
  if (expressionType == null || expressionType.equalsToText("java.lang.String")) {
    // intention disabled for string concatenations because of performance issues on
    // relatively common large string expressions.
    return false;
  }
  final PsiExpression[] operands = expression.getoperands();
  for (PsiExpression operand : operands) {
    if (operand == null) {
      return false;
    }
    final PsiType type = operand.getType();
    if (type == null || type.equalsToText("java.lang.String")) {
      return false;
    }
  }
  if (!PsiUtil.isConstantExpression(expression)) {
    return false;
  }
  try {
    final Object value = ExpressionUtils.computeConstantExpression(expression,true);
    if (value == null) {
      return false;
    }
  }
  catch (ConstantEvaluationOverflowException ignore) {
    return false;
  }
  final PsiElement parent = element.getParent();
  return !(parent instanceof PsiExpression) || !PsiUtil.isConstantExpression((PsiExpression)parent);
}

@Override
public void visitClassObjectAccessExpression(PsiClassObjectAccessExpression expression) {
    mVisitor.report("PsiClassObjectAccessExpression",expression.getText(),expression);
    super.visitExpression(expression);
}

private void encode(ByteBuf compressed) {
    try {
        byte[] out = new byte[(int) Math.ceil(z.next_in.length * 1.001) + 12];
        z.next_out = out;
        z.next_out_index = 0;
        z.avail_out = out.length;

        int resultCode = z.deflate(JZlib.Z_SYNC_FLUSH);
        if (resultCode != JZlib.Z_OK) {
            throw new CompressionException("compression failure: " + resultCode);
        }

        if (z.next_out_index != 0) {
            compressed.writeBytes(out,z.next_out_index);
        }
    } finally {
        // Deference the external references explicitly to tell the VM that
        // the allocated byte arrays are temporary so that the call stack
        // can be utilized.
        // I'm not sure if the modern VMs do this optimization though.
        z.next_in = null;
        z.next_out = null;
    }
}

private void encode(ByteBuf compressed) {
    try {
        byte[] out = new byte[(int) Math.ceil(z.next_in.length * 1.001) + 12];
        z.next_out = out;
        z.next_out_index = 0;
        z.avail_out = out.length;

        int resultCode = z.deflate(JZlib.Z_SYNC_FLUSH);
        if (resultCode != JZlib.Z_OK) {
            throw new CompressionException("compression failure: " + resultCode);
        }

        if (z.next_out_index != 0) {
            compressed.writeBytes(out,z.next_out_index);
        }
    } finally {
        // Deference the external references explicitly to tell the VM that
        // the allocated byte arrays are temporary so that the call stack
        // can be utilized.
        // I'm not sure if the modern VMs do this optimization though.
        z.next_in = null;
        z.next_out = null;
    }
}

SpdyHeaderBlockJZlibEncoder(
        SpdyVersion version,int compressionLevel,int windowBits,int memLevel) {
    super(version);
    if (compressionLevel < 0 || compressionLevel > 9) {
        throw new IllegalArgumentException(
                "compressionLevel: " + compressionLevel + " (expected: 0-9)");
    }
    if (windowBits < 9 || windowBits > 15) {
        throw new IllegalArgumentException(
                "windowBits: " + windowBits + " (expected: 9-15)");
    }
    if (memLevel < 1 || memLevel > 9) {
        throw new IllegalArgumentException(
                "memLevel: " + memLevel + " (expected: 1-9)");
    }

    int resultCode = z.deflateInit(
            compressionLevel,windowBits,memLevel,JZlib.W_ZLIB);
    if (resultCode != JZlib.Z_OK) {
        throw new CompressionException(
                "Failed to initialize an SPDY header block deflater: " + resultCode);
    } else {
        resultCode = z.deflateSetDictionary(SPDY_DICT,SPDY_DICT.length);
        if (resultCode != JZlib.Z_OK) {
            throw new CompressionException(
                    "Failed to set the SPDY dictionary: " + resultCode);
        }
    }
}

public SpdyHeaderBlockJZlibEncoder(
        SpdyVersion version,SPDY_DICT.length);
        if (resultCode != JZlib.Z_OK) {
            throw new CompressionException(
                    "Failed to set the SPDY dictionary: " + resultCode);
        }
    }
}

public SpdyHeaderBlockJZlibEncoder(
        SpdyVersion version,SPDY_DICT.length);
        if (resultCode != JZlib.Z_OK) {
            throw new CompressionException(
                    "Failed to set the SPDY dictionary: " + resultCode);
        }
    }
}

private ByteBuf encode(ByteBufAllocator alloc) {
    boolean release = true;
    ByteBuf out = null;
    try {
        int oldNextinindex = z.next_in_index;
        int oldNextOutIndex = z.next_out_index;

        int maxOutputLength = (int) Math.ceil(z.next_in.length * 1.001) + 12;
        out = alloc.heapBuffer(maxOutputLength);
        z.next_out = out.array();
        z.next_out_index = out.arrayOffset() + out.writerIndex();
        z.avail_out = maxOutputLength;

        int resultCode;
        try {
            resultCode = z.deflate(JZlib.Z_SYNC_FLUSH);
        } finally {
            out.skipBytes(z.next_in_index - oldNextinindex);
        }
        if (resultCode != JZlib.Z_OK) {
            throw new CompressionException("compression failure: " + resultCode);
        }

        int outputLength = z.next_out_index - oldNextOutIndex;
        if (outputLength > 0) {
            out.writerIndex(out.writerIndex() + outputLength);
        }
        release = false;
        return out;
    } finally {
        // Deference the external references explicitly to tell the VM that
        // the allocated byte arrays are temporary so that the call stack
        // can be utilized.
        // I'm not sure if the modern VMs do this optimization though.
        z.next_in = null;
        z.next_out = null;
        if (release && out != null) {
            out.release();
        }
    }
}

var completionHandler: FBSessionStateHandler = {

        session,status,error in

        NSLog("token not cached");

        if error {

            // Login Failed for some reason,so we notify the delegate.
            self.delegate.didFailOpenningSession?(self,withError: ErrorUtility.error(
                code: .FailedOpenningSession,withFacebookError: error
            ));

            // Don't proceed on errors
            return;
        }

        // Session is Now open,we should notify the delegate
        self.delegate.didOpenSession?(self);
    };

    NSLog("here");

    // Open the session,prompting the user if necessary. This might send the application to the background
    if FBSession.openActiveSessionWithReadPermissions(["public_profile"],allowLoginUI: true,completionHandler: completionHandler) {

        NSLog("Token cached");

        // If we end up here,the session token must exist,so we Now have an open session
        self.delegate.didOpenSession?(self);
    }

编辑：我忘了提到NSLog记录“这里”,但不是“令牌缓存”或“令牌没有缓存”

编辑：现在事情有点奇怪了.当我的应用程序启动时,我会显示一个带有Facebook登录按钮的屏幕.当用户按下按钮时,上面的代码被触发.在我授权应用程序之后,应用程序返回到同一个屏幕(它不应该,但是在调用完成处理程序之前我不能以任何其他方式执行).然后我再次尝试按下按钮,现在我确实得到了日志.

这就是我得到的：

here
    token not cached
    here

第一行是从第一次按下按钮,另外两行是在我第二次按下时出现的.现在有什么奇怪的呢？不应该“令牌没有缓存”和“这里”被逆转???它是从最后一次通话中调用competionHandler还是其他什么东西？

没关系,这很多都是固定的.

编辑：另一件事.如果我多次按下按钮,我总是得到“令牌未缓存”.我认为它应该是缓存