标签: unsafe-pointers

我一直在做一些不安全的位图操作,并发现增加指针的次数可以带来一些重大的性能提升.我不知道为什么会这样,即使你在循环do很多位运算,它仍然是更好地做到上的指针反复次数比较少.

因此,例如,使用UInt64迭代超过32位像素,而不是使用UInt64迭代两个像素,并在一个周期内执行两次操作.

以下是通过读取两个像素并对其进行修改(当然,它会因奇数宽度的图像而失败,但仅用于测试).

    private void removeBlueWithTwoPixelIteration()
    {
        // think of a big image with data
        Bitmap bmp = new Bitmap(15000, 15000, System.Drawing.Imaging.PixelFormat.Format32bppArgb);
        TimeSpan startTime, endTime;

        unsafe {

            UInt64 doublePixel;
            UInt32 pixel1;
            UInt32 pixel2;

            const int readSize = sizeof(UInt64);
            const UInt64 rightHalf = UInt32.MaxValue;

            PerformanceCounter pf = new PerformanceCounter("System", "System Up Time"); pf.NextValue();

            BitmapData bd = bmp.LockBits(new Rectangle(0, 0, bmp.Width, bmp.Height), System.Drawing.Imaging.ImageLockMode.ReadWrite, bmp.PixelFormat);
            byte* image = (byte*)bd.Scan0.ToPointer();

            startTime = TimeSpan.FromSeconds(pf.NextValue());

            for (byte* line = image; line < image + bd.Stride * …

以前曾经问过这个问题,但是有问题的话,Swift的内容一定有所改变.我正在尝试存储CMSampleBuffer从AVCaptureSession以后处理的对象.经过一些实验,我发现AVCaptureSession必须重复使用它的CMSampleBuffer引用.当我试图保持超过15时会话挂起.所以我想我会复制样本缓冲区.但我似乎无法让它发挥作用.这是我写的:

var allocator: Unmanaged<CFAllocator>! = CFAllocatorGetDefault()
var bufferCopy: UnsafeMutablePointer<CMSampleBuffer?>
let err = CMSampleBufferCreateCopy(allocator.takeRetainedValue(), sampleBuffer, bufferCopy)
if err == noErr {
    bufferArray.append(bufferCopy.memory!)
} else {
    NSLog("Failed to copy buffer. Error: \(err)")
}

这不会编译,因为它说Variable 'bufferCopy' used before being initialized.我看了很多例子,他们要么编译也不能工作,否则他们就不会编译.

有谁看到我在这里做错了什么？

我正在为一些 C 库编写包装器。是否可以将 UnsafePointer 转换为不可变结构？对于可变结构这不是问题：

func Foo_get(ptr : UnsafePointer<Foo>) {
    //does not mutate
}

struct Foo {
    //big data

    mutating func get1() { //inconvenient
        Foo_get(&self)
    }

    func get2() { //unnecessary copy
        var copy = self
        Foo_get(&copy)
    }
}

但这两种解决方案都不是理想的。

我正在尝试了解Swift中指针的使用，尤其是：Unsafe[Mutable]Pointer和UnsafeRaw[Mutable]Pointer。关于这个问题，我有几个问题。

1. 是UnsafePointer <T>等于const T * Pointer在？和UnsafeMutablePointer <T>等于T * Pointer在C 2

2. Unsafe[Mutable]Pointer和之间有什么区别UnsafeRaw[Mutable]Pointer？

3. 为什么编译

func receive(pointer: UnsafePointer<Int> ) {
    print("param value is: \(pointer.pointee)")
}

var a: Int = 1
receive(pointer: &a) // prints 1

但这给我一个错误？

var a: Int = 1
var pointer: UnsafePointer<Int> = &a // error : Cannot pass immutable value of type 'Int' as inout argument

我在Swift项目中使用的是C库，其中一个函数需要a UnsafePointer<UnsafePointer<UInt8>?>!作为输入输出参数，我应该在其中传递数据。但是问题是我有此数据UnsafeMutablePointer<UnsafeMutablePointer<UInt8>?>!类型。

我的问题是-什么是转换的最有效和最简单的方法UnsafeMutablePointer，以UnsafePointer在斯威夫特3？这些指针在“书面上”并没有太大的区别，与技术环境也没有太大区别，但是我找不到关于该主题的有价值的信息。

任何帮助，将不胜感激。谢谢

我正在从USB设备收集数据,这些数据必须转到音频输出组件.目前,我没有足够快地提供数据以避免输出信号中的咔嗒声.所以每毫秒都很重要.

目前,我正在收集以65536字节的字节数组传送的数据.前两个字节表示小端格式的16位数据.这两个字节必须放在double数组的第一个元素中.后两个字节必须放在不同双数组的第一个元素中.然后对65536缓冲区中的所有字节重复此操作,以便最终得到2 double[]个大小为16384的数组.

我目前正在使用BitConverter.ToInt16,如代码所示.运行它需要大约0.3ms,但必须完成10次才能将数据包发送到音频输出.所以开销是3ms,这足以使一些数据包最终无法按时交付.

码

byte[] buffer = new byte[65536];
double[] bufferA = new double[16384];
double[] bufferB = new double[16384]

for(int i= 0; i < 65536; i +=4)
{
    bufferA[i/4] = BitConverter.ToInt16(buffer, i);
    bufferB[i/4] = BitConverter.ToInt16(buffer, i+2);
}

我怎样才能改善这个？是否可以使用不安全的代码复制值？我没有这方面的经验.谢谢

在 Swift 中，我想将data类型为 的数据缓冲区（名为 ）传递给采用类型为指针的DataC 函数（名为） 。do_somethingUnsafePointer<UInt8>

下面的代码示例正确吗？如果是这样，在这种情况下可以使用assumingMemoryBound(to:)代替 吗bindMemory(to:capacity:)？

data.withUnsafeBytes { (unsafeBytes) in
  let bytes = unsafeBytes.baseAddress!.assumingMemoryBound(to: UInt8.self)
  do_something(bytes, unsafeBytes.count)
}

Are unsafe.Pointer()s reference counted and thus protected from being garbage collected?

例如，如果我有一个字符串，则它在作用域内时存在，如果我有一个 *string，则当指针在作用域内时该字符串存在，但如果我有一个 unsafe.Pointer(&s) （其中 s 是一个字符串）或者其他什么）只要不安全指针仍然指向它，s就会留在范围内吗？

我发现谷歌说一旦你转换为 uintptr ，它绝对不是，因为 uintptr 只是一个 int ，但我找不到任何关于 unsafe.Pointer() 的明确的方式或另一种方式，可能是因为答案很明显，但我我不太确定，因为我找不到任何可以准确解释的内容。

如果我将 unsafe.Pointer 转换为其他指针类型，我认为这不会改变什么？

我正在尝试使用 Brad Larson 出色的GPUImage框架，并且正在努力处理GPUImageHarrisCornerDetectionFilter.

角作为GLFloatin数组返回UnsafeMutablePointer- 我想将其转换为数组CGPoint

我试过为内存分配空间

var cornerPointer = UnsafeMutablePointer<GLfloat>.alloc(Int(cornersDetected) * 2)

但数据似乎没有任何意义 - 零或 1E-32

我找到了如何在 Swift 中循环遍历 <UnsafeMutablePointer> 数组元素的完美答案并尝试

filter.cornersDetectedBlock = {(cornerArray:UnsafeMutablePointer<GLfloat>, cornersDetected:UInt, frameTime:CMTime) in
        crosshairGenerator.renderCrosshairsFromArray(cornerArray, count:cornersDetected, frameTime:frameTime)

    for floatData in UnsafeBufferPointer(start: cornerArray, count: cornersDetected)
    {
        println("\(floatData)")
    }

但是编译器不喜欢UnsafeBufferPointer- 所以我把它改成了UnsafeMutablePointer，但它不喜欢参数列表。

我确信这很好而且很简单，而且听起来其他人必须这样做 - 那么解决方案是什么？

我需要你的帮助，这段代码在 Swift 3 中不再编译

//: Let's set up the `sockaddr_in` C structure using the initializer.
var sin = sockaddr_in(
    sin_len: UInt8(sizeof(sockaddr_in)),
    sin_family: sa_family_t(AF_INET),
    sin_port: in_port_t(0),
    sin_addr: in_addr(s_addr: inet_addr(routerIP)),
    sin_zero: (0,0,0,0,0,0,0,0)
)

//: Now convert the structure into a `CFData` object.
let data = withUnsafePointer(&sin) { ptr in
    CFDataCreate(kCFAllocatorDefault, UnsafePointer(ptr), sizeof(sockaddr_in))
}

//: Create the `CFHostRef` with the `CFData` object and store the retained value for later use.
host = CFHostCreateWithAddress(kCFAllocatorDefault, data).takeRetainedValue()

我必须修复“withUnsafePointer”这一行，但我不知道如何解决？

我试过这样的事情

    let data = withUnsafePointer(to: &sin) { ptr …