尝试了解 CMTime 和 CMTimeMake

Question

1)

CMTimeMake(1,10)

表示持续时间为 1 秒，时间尺度为 10，即每秒 10 帧。这意味着 10 帧的视频时长为 1 秒？

2）

CMTime lastTime=CMTimeMake(1,10);
CMTime frameTime=CMTimeMake(1, 10);
CMTime currentTime=CMTimeAdd(lastTime, frameTime)

= (2, 10) ?

当前时间每秒 10 帧的 2 秒视频？

Answer 1

1)

CMTimeMake(1,10)

实际上表示值 1 和时间刻度 10。它们是分子和分母，所以它是 1/10 秒，而不是 1 秒。

2) 结果将类似于

CMTimeMake(2, 10)

，即 2/10 秒。

Answer 2

彼得是对的。 下面的代码让这个概念更加清晰：

1)

Float64 seconds = 5; 
int32_t preferredTimeScale = 600;
CMTime inTime = CMTimeMakeWithSeconds(seconds, preferredTimeScale);
CMTimeShow(inTime);

上面的代码给出： {3000/600 = 5.000}

这意味着总持续时间为 5 秒，包含 3000 帧，时间尺度为每秒 600 帧。

2)

int64_t value = 10000;
int32_t preferredTimeScale = 600;
CMTime inTime = CMTimeMake(value, preferredTimeScale);
CMTimeShow(inTime);

这个给出了 {10000/600 = 16.667}

这意味着总持续时间为 16.667 秒，包含 10000 帧，时间尺度为每秒 600 帧。

注意 CMTimeMake(int64_t value, int32_t timescale) 之间的区别 和 CMTimeMakeWithSeconds(Float64 秒，int32_t PreferredTimeScale)

希望这个解释有帮助。如需进一步说明，请随时在本文中提出更多问题。

Answer 3

使用

CMTimeMake(A, B)

，您可以存储一个有理数，一个精确的分数

A / B

秒

• CMTimeMake(1, 4)

  -> 时间间隔0.25秒

使用

CMTimeMakeWithSeconds(A, B)

，您可以将

A

秒 存储为

B

步

的分辨率

• CMTimeMakeWithSeconds(0.25, ...)

  -> 时间间隔0.25秒

您经常看到

CMTimeMakeWithSeconds(time, NSEC_PER_SEC)

。

NSEC_PER_SEC

实际上意味着“最大分辨率”。

Answer 4

间隔1秒

如果您只想知道如何间隔1秒（像我一样），这就是您的答案：

int seconds = 1;

CMTime interval = CMTimeMakeWithSeconds(seconds, NSEC_PER_SEC);

Answer 5

一个 CMTime 结构体代表一个

length of time that is stored as rational number.

CMTime 有一个值和一个时间刻度字段，并表示时间值/时间刻度秒。

看到看到这个SO答案很清楚

Answer 6

斯威夫特CMTime

按时间操作时，保持准确性很重要。

CMTime

建议您使用两个整数（值和时间刻度）来表示浮点数。附加函数简化了 CMTime 数学计算

重要的

CMTime

属性是：

• 价值
• 时间刻度 - 一秒
的相等部分的数量
• 秒

公式为

Int64 value(numerator) / Int32 timescale(denominator) = Float64 seconds

//for example
//value 1 / timescale 10 = 1/10(0.1) seconds

下一个示例显示下一个项目：

• 您可以使用构造函数(init())或CMTimeMake函数创建CMTime
• time.seconds 与 CMTimeGetSeconds(time) 相同
• 数学与 CMTime - CMTimeCompare、CMTimeAdd...

import CoreMedia

func testTime() {
   let value: Int64 = 1
   let timescale: Int32 = 10
   let secondsResult: Double = 0.1 // 1/10 sec
   
   let time1: CMTime = CMTime(value: value, timescale: timescale)
   let time2: CMTime = CMTime(seconds: secondsResult, preferredTimescale: timescale)
   
   let time3: CMTime = CMTimeMake(value: value, timescale: timescale)
   let time4: CMTime = CMTimeMakeWithSeconds(secondsResult, preferredTimescale: timescale)
   
   let seconds1: Double = time1.seconds
   let seconds2: Float64 = CMTimeGetSeconds(time1)
   assert(seconds1 == seconds2)
   assert(seconds1 == secondsResult)
   
   assert(time1 == time2)
   assert(time1 == time3)
   assert(time1 == time4)
        
   assert(CMTimeCompare(time1, time2) == 0)
}

使用秒创建 CMTime

您可以使用

值

和时间刻度创建CMTime，其中将计算秒（值/时间刻度）。这种方法很清晰，但您也可以使用

seconds

和 preferredTimescale 创建 CMTime。在这种情况下，您的值和秒可以不同，并重新计算以满足公式（值必须是Int64），这就是为什么它可以四舍五入，因此秒也被重新计算

//preset - seconds: 0.1, preferredTimescale: 10, expect value == 1
//result - seconds: 0.1, value: 1
let time5: CMTime = CMTime(seconds: 0.1, preferredTimescale: 10)
assert(time5.value == 1)
assert(time5.seconds == 0.1)

//preset - seconds: 0.1, preferredTimescale: 1, expect value == 0.1
//result - seconds: 0, value: 0
let time6: CMTime = CMTime(seconds: 0.1, preferredTimescale: 1)
assert(time6.value == 0)
assert(time6.seconds == 0)

//preset - seconds: 1.31, preferredTimescale: 10, expect value == 13.1
//result - seconds: 1.3, value: 13
let time7: CMTime = CMTime(seconds: 1.31, preferredTimescale: 10)
assert(time7.value == 13)
assert(time7.seconds == 1.3)