月別アーカイブ: 2008年6月

Core Audio Clock その４ スレーブ時の再生スピード調整

コメントを残す

Core Audio ClockをMTCのスレーブにした時、あるいはインターナルのソースをHostTimeにした時、Core Audio Clockの時間を基準にしてオーディオを再生しようとすると、オーディオデバイスとスピードのずれが出てきますので、調整しなければいけません。

まず、オーディオの再生をしているときのIOProc内で、再生する頭のタイミングのHostTime（以下スタートホストタイム）と、HostTimeとオーディオデバイスのスピードの比率である「RateScalar」が取得できます。それと、MTCのスレーブにしているときはCoreAudioClockの「PlayRate」が、MTCとHostTimeのスピードの比率になっていますので、基本的にこれらを使って調整してみます。

１回のIOProcごとのオーディオデータを用意するスタート時間としてスタートホストタイムを設定し、オーディオデータに( RateScalar × PlayRate )で求めたレートでVariSpeed等をかけてやれば良いはずなのですが、実際はスタートホストタイムがアバウトで微妙にデバイスとずれていたりして音を鳴らすとプチプチとノイズが入ってしまったりします。

なので、スタートホストタイムは直接使わずに、( RateScalar × PlayRate )で調整したバッファフレームサイズ分の時間を毎度足していった値をスタート時間にして、スタートホストタイムとの差を少しずつ調整していくという感じでやってみました。

ということで、インスタンス変数には以下のようなものがあるとしておいて、

CAClockRef clockRef; //Core Audio Clock
Float64 deviceSampleRate; //オーディオデバイスのサンプリング周波数
UInt32 bufferFrames; //オーディオデバイスのバッファフレーム数
double preSeconds; //スタート時間の差を求めるための時間

IOProc内で以下のようなメソッドを呼ぶという感じで試してみました。ここでは、オーディオデータのスタート時間と１フレーム分の時間を求めています。

- (void)ioProc:(AudioBufferList *)outOutputData 
    outputTime:(const AudioTimeStamp *)inOutputTime
{
    OSStatus err;
    
    //アウトプットデバイスのRateScalarを取得する
    double rateScalar = inOutputTime->mRateScalar;
    //スピード調整のためのレート
    double ajustRate;
    //今回のスタート時間
    double startSeconds;
    
    //CAClockのプレイレートを取得する
    double playRate;
    err = CAClockGetPlayRate(clockRef, &playRate);
    if (err != noErr) NSLog(@"get PlayRate Err");
    
    //アウトプットデバイスのスタート時間をホストタイムから変換して取得する
    CAClockTime inHostTime;
    inHostTime.format = kCAClockTimeFormat_HostTime;
    inHostTime.time.hostTime = inOutputTime->mHostTime;
    
    CAClockTime outSecondsTime;
    outSecondsTime.format = kCAClockTimeFormat_Seconds;
    
    err = CAClockTranslateTime(clockRef, &inHostTime, 
        kCAClockTimeFormat_Seconds, &outSecondsTime);
    if (err != noErr) NSLog(@"translatetime Err");
    
    //前回コールバック時に求めたスタート時間との差
    double gap = outSecondsTime.time.seconds - preSeconds;
    
    //今回のスタート時間を設定する。前回との差が大きければリセット
    if (fabs(gap) > 0.1) {
        startSeconds = outSecondsTime.time.seconds;
        gap = 0.0;
    } else {
        startSeconds = preSeconds;
    }
    
    //差がきわめて小さければ調整はしない。
    //調整するなら差の大きさによって調整するレートを求める
    if (fabs(gap) > 0.0001) {
        ajustRate = pow(10, gap);
    } else {
        ajustRate = 1.0;
    }
    
    //１サンプル分の時間
    double secondsPerFrame = 
        playRate * rateScalar / deviceSampleRate * ajustRate;
    //次のコールバック時のスタート時間を算出する
    preSeconds = startSeconds + secondsPerFrame * bufferFrames;


    //
    // ここで、startSecondsとsecondsPerFrameを元に
    // オーディオデータを書き込む
    //
}

テンポラリファイル名を取得する

コメントを残す

テンポラリのディレクトリの中のテンポラリのファイル名を取得するサンプル。

NSTemporaryDirectory()でテンポラリフォルダを取得。mkstempsでテンポラリファイル名が取得できるが、一旦書き込み可能な文字列の配列にコピーしないといけない。NSStringのlengthでは日本語とか含まれている場合、取得した長さが配列の長さと違うので、strlenで配列の長さを取得してコピーする。

#import <Foundation/Foundation.h>

int main (int argc, const char * argv[]) {
    NSAutoreleasePool * pool = 
        [[NSAutoreleasePool alloc] init];

    NSString *tempDir = NSTemporaryDirectory();
    NSString *filePath = 
        [tempDir stringByAppendingPathComponent:
            @"prefixXXXXXXsuffix"];
    
    size_t bufferSize = 
        strlen([filePath fileSystemRepresentation]) + 1;
    char buffer[bufferSize];
    if ([filePath getFileSystemRepresentation:buffer 
            maxLength:bufferSize]) {
        if (mkstemps(buffer, 6) != -1) {
            NSLog(@"TemporaryFile = '%s'", buffer);
        }
    }
    
    [pool drain];
    return 0;
}

Core Audio Clock その３ MTCスレーブ改

コメントを残す

前回のCore Audio Clock その２で、MTCを受信してCore Audio Clockをスレーブで動かすというのをやりましたが、シンクソースにMTCを設定するだけではクォーターフレームメッセージしか受信してくれないので、フルタイムコードメッセージも受け取って再生時以外のタイムコードにも対応できるようにしてみたいと思います。

あれこれ試してみたところ、フルタイムコードをCore Audio Clockが勝手に解析してくれるような機能はないようなので、一旦フルタイムコードメッセージからタイムコードを抜き出してCore Audio ClockのCAClockSetCurrentTimeで設定します。

ただ、CAClockSetCurrentTimeは停止中でないと受け付けてくれないので、MTCを送信してきているシーケンサーが停止時にフルタイムコードを送ってきても、Core Audio ClockはMTCFreewheelTimeで設定されている時間の後に停止するので、そのタイミングでセットしないと受け付けてくれません。

そんな感じで作り直してみたのが以下のコードです。前回プラスCoreMIDI.Frameworkになります。

//
//  CAClockMTCSlaveTest.h
//

#import <Cocoa/Cocoa.h>
#import <CoreMIDI/CoreMIDI.h>
#import <AudioToolbox/AudioToolbox.h>

@interface CAClockMTCSlaveTest : NSObject {
    
    CAClockRef clockRef;
    MIDIEndpointRef srcPointRef;
    BOOL isStart;
    NSTimer *timer;
    IBOutlet NSTextField *textField;
    
    MIDIClientRef clientRef;
    MIDIPortRef inputPortRef;
    CAClockSeconds keepSeconds;
}

- (void)clockListener:(CAClockMessage)message
    parameter:(const void *)param;
- (void)checkTime:(NSTimer *)timr;
- (void)setCurrentTime:(NSNumber *)secondsNumber;
- (void)setFullTimecode:(MIDIPacket *)packet;

@end


//
//  CAClockMTCSlaveTest.m
//

#import "CAClockMTCSlaveTest.h"

@implementation CAClockMTCSlaveTest

#pragma mark -
#pragma mark -- コールバック --

static void 
ClockListener(void *userData, 
    CAClockMessage message, const void *param)
{
    [(id)userData clockListener:message parameter:param];
}

- (void)clockListener:(CAClockMessage)message 
    parameter:(const void *)param
{
    NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
    
    switch (message) {
        case kCAClockMessage_Started:
            isStart = YES;
            NSLog(@"started");
            break;
        case kCAClockMessage_Stopped:
            isStart = NO;
            [self setCurrentTime:
                [NSNumber numberWithDouble:keepSeconds]];
            NSLog(@"stoped");
            break;
        case kCAClockMessage_Armed:
            NSLog(@"armed");
            break;
        case kCAClockMessage_Disarmed:
            NSLog(@"disarmed");
            break;
        case kCAClockMessage_WrongSMPTEFormat:
            NSLog(@"wrongSMPTEFormat");
            break;
        default:
            break;
    }
    
    [pool drain];
}

static void 
MIDIInputProc(const MIDIPacketList *pktlist, 
    void *readProcRefCon, void *srcConnRefCon)
{
    NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
    
    //MIDIパケットリストの先頭のMIDIPacketのポインタを取得
    MIDIPacket *packet = (MIDIPacket *)&(pktlist->packet[0]);
    //パケットリストからパケットの数を取得
    UInt32 packetCount = pktlist->numPackets;
    
    for (NSInteger i = 0; i < packetCount; i++) {
        
        //フルタイムコードであれば処理をする
        if ((packet->data[0] == 0xF0) &&
            (packet->data[1] == 0x7F) && 
            (packet->data[2] == 0x7F) && 
            (packet->data[3] == 0x01) && 
            (packet->data[4] == 0x01)) {
            
            [(id)readProcRefCon setFullTimecode:packet];
        }
        
        //次のパケットへ進む
        packet = MIDIPacketNext(packet);
    }
    
    [pool drain];
}

- (void)setFullTimecode:(MIDIPacket *)packet
{
    OSStatus err;
    
    SMPTETime smpteTime;
    smpteTime.mType = kSMPTETimeType30;
    smpteTime.mHours = packet->data[5] & 0x0F;
    smpteTime.mMinutes = packet->data[6];
    smpteTime.mSeconds = packet->data[7];
    smpteTime.mFrames = packet->data[8];
    smpteTime.mSubframeDivisor = 80;
    smpteTime.mSubframes = 0;
    
    CAClockSeconds seconds;
    err = CAClockSMPTETimeToSeconds(
        clockRef, &smpteTime, &seconds);
    if (err != noErr) {
        NSLog(@"SMPTETimeToSecond err = %d", err);
        return;
    }
    
    NSNumber *secondsNumber = [NSNumber numberWithDouble:seconds];
    [self performSelectorOnMainThread:@selector(setCurrentTime:) 
        withObject:secondsNumber 
        waitUntilDone:NO];
}


#pragma mark -
#pragma mark -- タイムコードをセット --

- (void)setCurrentTime:(NSNumber *)secondsNumber
{
    CAClockSeconds seconds = [secondsNumber doubleValue];
    
    if (!isStart) {
        
        CAClockTime time;
        time.format = kCAClockTimeFormat_Seconds;
        time.time.seconds = seconds;
        
        OSStatus err = CAClockSetCurrentTime(clockRef, &time);
        if (err != noErr) {
            NSLog(@"set setCurrentTime err");
        }
        
    } else {
        
        keepSeconds = seconds;
    }
}

#pragma mark -
#pragma mark -- 初期化など --

- (void)awakeFromNib
{
    OSStatus err = noErr;
    UInt32 size;
    
    //MIDIエンドポイントを取得する
    srcPointRef = MIDIGetSource(0);
    
    //MIDIエンドポイントから名前を取得して表示
    CFStringRef strSrcRef;
    err = MIDIObjectGetStringProperty(
        srcPointRef, kMIDIPropertyDisplayName, &strSrcRef);
    if (err != noErr) {
        NSLog(@"MIDI Get sourceName err = %d", err);
        goto end;
    }
    NSLog(@"connect = %@", strSrcRef);
    CFRelease(strSrcRef);
    
    
    //CAClockを作成する
    err = CAClockNew(0, &clockRef);
    if (err != noErr) {
        NSLog(@"CAClockNew err = %d", err);
        goto end;
    }
    <
br />    //シンクモードをMTCにする
    UInt32 tSyncMode = kCAClockSyncMode_MTCTransport;
    size = sizeof(tSyncMode);
    err = CAClockSetProperty(
        clockRef, kCAClockProperty_SyncMode, size, &tSyncMode);
    if (err != noErr) {
        NSLog(@"set syncmode Err = %d", err);
        goto end;
    }
    
    //CAClockの同期元にMIDIエンドポイントを設定する
    size = sizeof(srcPointRef);
    err = CAClockSetProperty(
        clockRef, kCAClockProperty_SyncSource, size, &srcPointRef);
    if (err != noErr) {
        NSLog(@"caclock setSyncSourct err = %d", err);
        goto end;
    }
    
    //SMPTEを30fpsに設定する
    UInt32 tSMPTEType = kSMPTETimeType30;
    size = sizeof(tSMPTEType);
    err = CAClockSetProperty(
        clockRef, kCAClockProperty_SMPTEFormat, size, &tSMPTEType);
    if (err != noErr) {
        NSLog(@"set smptetype Err = %d", err);
        goto end;
    }
    
    //MTCが停止しても動き続ける時間を設定する
    CAClockSeconds freeWheelTime = 0.2;
    size = sizeof(freeWheelTime);
    err = CAClockSetProperty(
        clockRef, kCAClockProperty_MTCFreewheelTime, 
        size, &freeWheelTime);
    if (err != noErr) {
        NSLog(@"set MTCFreewheelTime Err = %d", err);
        goto end;
    }
    
    //CAClockからの通知を受け取る関数を設定する
    err = CAClockAddListener(clockRef, ClockListener, self);
    if (err != noErr) {
        NSLog(@"caclock addListener err = %d", err);
        goto end;
    }
    
    //シンクソースとの同期を開始する
    err = CAClockArm(clockRef);
    if (err != noErr) {
        NSLog(@"CAClock arm err = %d", err);
        goto end;
    }
    
    
    //
    // フルタイムコードを受信するための設定
    //
    
    //MIDIクライアントを作成する
    NSString *clientName = @"inputClient";
    err = MIDIClientCreate(
        (CFStringRef)clientName, NULL, NULL, &clientRef);
    if (err != noErr) {
        NSLog(@"MIDIClientCreate err = %d", err);
        goto end;
    }
    
    //MIDIポートを作成する
    NSString *inputPortName = @"inputPort";
    err = MIDIInputPortCreate(
        clientRef, (CFStringRef)inputPortName, 
        MIDIInputProc, self, &inputPortRef);
    if (err != noErr) {
        NSLog(@"MIDIInputPortCreate err = %d", err);
        goto end;
    }
    
    //MIDIエンドポイントをポートに接続する
    err = MIDIPortConnectSource(inputPortRef, srcPointRef, NULL);
    if (err != noErr) {
        NSLog(@"MIDIPortConnectSource err = %d", err);
        goto end;
    }
    
    
    //タイマーを開始する
    timer = [NSTimer scheduledTimerWithTimeInterval:0.01 
        target:self selector:@selector(checkTime:) 
        userInfo:nil repeats:YES];
    [[NSRunLoop currentRunLoop] 
        addTimer:timer forMode:NSEventTrackingRunLoopMode];
    
	return;
    
end:
    
	[NSApp terminate:self];
    return;
}

- (void) dealloc
{
    [timer invalidate];
    
    OSStatus err;
    
    err = MIDIPortDisconnectSource(inputPortRef, srcPointRef);
    if (err != noErr) NSLog(@"MIDIPortDisconnectSource Err"); 
    err = MIDIPortDispose(inputPortRef);
    if (err != noErr) NSLog(@"MIDIPortDispose Err");
    err = MIDIClientDispose(clientRef);
    if (err != noErr) NSLog(@"MIDIClientDispose Err");
    
    err = CAClockDisarm(clockRef);
    if (err != noErr) NSLog(@"clock disarm Err");
    err = CAClockDispose(clockRef);
    if (err != noErr) NSLog(@"CAClockDispose err");
    
    [super dealloc];
}

#pragma mark -
#pragma mark -- タイムの表示 --

//現在のタイムを表示する
- (void)checkTime:(NSTimer *)timr
{
    OSStatus err;
    CAClockTime secondTime;
    
    //再生中か停止中かで取得するタイムを変える
    if (isStart) {
        //カレントタイムを取得する
        err = CAClockGetCurrentTime(
            clockRef, kCAClockTimeFormat_Seconds, &secondTime);
        if (err != noErr) {
            NSLog(@"CAClock GetCurrenttime err = %d", err);
            return;
        }
    } else {
        //スタートタイムを取得する
        err = CAClockGetStartTime(
            clockRef, kCAClockTimeFormat_Seconds, &secondTime);
        if (err != noErr) {
            NSLog(@"CAClock GetCurrenttime err = %d", err);
            return;
        }
    }
    
    CAClockSeconds seconds = secondTime.time.seconds;
    
    //秒数からタイムコードに変換する
    SMPTETime tSMPTETime;
    err = CAClockSecondsToSMPTETime(clockRef, seconds, 80, &tSMPTETime);
    if (err != noErr) {
        NSLog(@"secondsToSMPTE err = %d", err);
        return;
    }
    
    SInt16 tHours = tSMPTETime.mHours;
    SInt16 tMinutes = tSMPTETime.mMinutes;
    SInt16 tSeconds = tSMPTETime.mSeconds;
    SInt16 tFrames = tSMPTETime.mFrames;
    
    Float64 tPlayRate;
    err = CAClockGetPlayRate(clockRef, &tPlayRate);
    if (err != noErr) {
        NSLog(@"getPlayRate err = %d", err);
        return;
    }
    
    //タイムを表示する
    NSString *tSMPTEString = 
    [NSString stringWithFormat:
      @"seconds = %f / SMPTE = %2.2hi.%2.2hi.%2.2hi.%2.2hi / PlayRate = %f", 
      seconds, tHours, tMinutes, tSecond
s, tFrames, tPlayRate];
    
    [textField setStringValue:tSMPTEString];
}

@end

Core MIDI その３ MIDIPacketListの送信

コメントを残す

MIDIデータを送信する方法です。まず、MIDIPacketListの作り方を見てみます。

ひとつの普通のメッセージのMIDIPacketを含んだMIDIPacketListを作るだけであればMIDIPacketList構造体を作ってしまえばいいだけですが、複数のMIDIPacketを含んだMIDIPacketListを作りこんでいくには以下の関数を使います。

extern MIDIPacket *
MIDIPacketListInit(MIDIPacketList *pktlist)

extern MIDIPacket *
MIDIPacketListAdd(MIDIPacketList *  pktlist,
                  ByteCount         listSize,
                  MIDIPacket *      curPacket,
                  MIDITimeStamp     time,
                  ByteCount         nData,
                  const Byte *      data)

作り方の順番としては、

・MIDIPacketListとして作成するのに十分なメモリ領域を確保する
・MIDIPacketListInitでMIDIPacketListを初期化し、１つめのMIDIPacketのポインタを取得する
・MIDIPacketListAddでMIDIPacketを書き込む（必要な分だけMIDIPacketListAddを繰り返す）

という感じになります。この方法でMIDIPacketListを作るコードはこんな感じです。とりあえずMIDIPacketは１つだけですけど。

ByteCount bufferSize = 1024;
Byte packetListBuffer[bufferSize];
MIDIPacketList *packetListPtr = (MIDIPacketList *)packetListBuffer;
    
MIDITimeStamp time = AudioGetCurrentHostTime();
    
ByteCount dataSize = 3;
Byte data[dataSize];
data[0] = 0x90;
data[1] = 0x60;
data[2] = 0x10;
    
MIDIPacket *packet = MIDIPacketListInit(packetListPtr);
    
if (packet != NULL) {
    packet = MIDIPacketListAdd(
        packetListPtr, bufferSize, packet, time, dataSize, data);
}

実際に複数のMIDIPacketを追加する場合、MIDIPacketListAddでMIDIPacketの書き込みが成功すれば、次の書き込み位置となるMIDIPacketのポインタが返ってきますので、それをまたMIDIPacketListAddに渡してという風に繰り返してMIDIPacketを追加して行きます。ただ、いろいろ試した感じでは、MIDITimeStampを同じ時間に指定したMIDIPacketを追加しようとしても追加されないようです。他のソフトからは、同じ時間のMIDIPacketがいくつも入ったMIDIPacketListが来たりするんですが…。

MIDIPacketListが作成できたら、MIDISend関数で送信します。

extern OSStatus
MIDISend(MIDIPortRef            port, 
         MIDIEndpointRef        dest, 
         const MIDIPacketList *	pktlist )

ちなみに、MIDIReceivedという関数もあって、最初見たときに、受信なのにメッセージを送るとは何ぞや？と思ったのですが、これはソースとなっているMIDIエンドポイントにMIDIPacketListを送信して、アプリケーション内部で受信するためにというもののようです。

extern OSStatus 
MIDIReceived(MIDIEndpointRef        src, 
             const MIDIPacketList * pktlist )

これを使うと、受信したMIDIPacketListの中に先の時間のMIDIPacketがあったら、その時間に再び受信されるように再送信させられたり、あるいはアプリケーション内の音源をならすような場合、一度にたくさんのMIDIデータを時間を指定して送信しておけばあとは勝手にシーケンスしてくれる、という感じでしょうか。

Core MIDIを調べてると良く出てくるバーチャルソースってのが、そんなとき役立つのではないかと思います。アプリケーション内部にMIDIEndpointをバーチャルソースとして作るのがMIDISourceCreate関数です。

extern OSStatus
MIDISourceCreate(MIDIClientRef      client, 
                 CFStringRef        name, 
                 MIDIEndpointRef *  outSrc )

これでMIDIEndpointを作成してMIDIPortConnectSourceでMIDIPortとつなげたら、外部のソースと同じく受信する事が出来ます。

といったところで実際の送信の方法ですが、アプリケーション外部にMIDIデータを送信する順番としては、

・MIDIClientを作成する
・MIDIOutputPortCreateでMIDIPortを作成する
・出力するMIDIEndpointを取得する
・MIDIPacketListを作成する
・MIDISendで送信する

と、なります。

以下がMIDIデータ送信のサンプルになります。DestinationのMIDIEndpointを１つだけ取得して送信していますので、そこから何かソフトなりシンセなりで受けるようにすれば音が鳴ると思います。ちなみに今回のサンプルくらい各MIDIPacketの間隔が開いていれば、MIDIPacketListのデータが勝手にバラされてMIDIEndpointに送信されるようです。間隔が短かったり、MIDIReceivedの場合は、そのまんまMIDIPacketListに複数のMIDIPacketが入った状態で送信されます。

#import <Cocoa/Cocoa.h>
#import <CoreMIDI/CoreMIDI.h>
#import <CoreAudio/CoreAudio.h>

@interface MIDIOutTest : NSObject {
    
    MIDIClientRef clientRef;
    MIDIPortRef outPortRef;
    MIDIEndpointRef destPointRef;
}

- (void)setup;
- (void)sendNoteOn;

@end

@implementation MIDIOutTest

- (void)awakeFromNib
{
    [self setup];
    [self sendNoteOn];
}

- (void)setup
{
    OSStatus err;
    
    //MIDIクライアントを作成する
    NSString *clientName = @"inputClient";
    err = MIDIClientCreate((CFStringRef)clientName, NULL, NULL, &clientRef);
    if (err != noErr) {
        NSLog(@"MIDIClientCreate err = %d", err);
        return;
    }
    
    //MIDIアウトプットポートを作成する
    NSString *outputPortName = @"outputPort";
    err = MIDIOutputPortCreate(
        clientRef, (CFStringRef)outputPortName, &outPortRef);
    if (err != noErr) {
        NSLog(@"MIDIOutputPortCreate err = %d", err);
        return;
    }
    
    //送信先のMIDIエンドポイントを取得する
    destPointRef = MIDIGetDestination(0);
    
    //送信先のMIDIエンドポイントの名前を取得してログに表示
    CFStringRef strRef;
    err = MIDIObjectGetStringProperty(
        destPointRef, kMIDIPropertyDisplayName, &strRef);
    if (err != noErr) {
        NSLog(@"MIDIObjectGetStringProperty err = %d", err);
        return;
    }
    NSLog(@"connect = %@", strRef);
    CFRelease(strRef);
}

- (void)sendNoteOn
{
    OSStatus err;
    
    //MIDIPacketListを作成する
    ByteCount bufferSize = 1024;
    Byte packetListBuffer[bufferSize];
    MIDIPacketList *packetListPtr = (MIDIPacketList *)packetListBuffer;
    
    //現在のHostTimeを取得する
    MIDITimeStamp time = AudioGetCurrentHostTime();
    
    //ノートオンのMIDIデータを作成する
    Byte noteOnData[3];
    noteOnData[0] = 0x90;
    noteOnData[1] = 0x3C;
    noteOnData[2] = 100;
    
    //ノートオフのMIDIデータを作成する
    Byte noteOffData[3];
    noteOffData[0] = 0x80;
    noteOffData[1] = 0x3C;
    noteOffData[2] = 0x00;
    
    //MIDIPacketListの初期化をする
    MIDIPacket *packet = MIDIPacketListInit(packetListPtr);
    
    for (NSInteger i = 0; i < 12; i++) {
        
        //MIDIPacketListにノートオンのMIDIPacketを追加する
        if (packet != NULL) {
            packet = MIDIPacketListAdd(
                packetListPtr, bufferSize, packet, time, 3, noteOnData);
        } else {
            break;
        }
        
        time = AudioConvertHostTimeToNanos(time) + kSecondScale * 0.25;
        time = AudioConvertNanosToHostTime(time);
        
        //MIDIPacketListにノートオフのMIDIPacketを追加する
        if (packet != NULL) {
            packet = MIDIPacketListAdd(
                packetListPtr, bufferSize, packet, time, 3, noteOffData);
        } else {
            break;
        }
        
        time = AudioConvertHostTimeToNanos(time) + kSecondScale * 0.75;
        time = AudioConvertNanosToHostTime(time);
        
        noteOnData[1] += 1;
        noteOffData[1] += 1;
    }
    
    err = MIDISend(outPortRef, destPointRef, packetListPtr);
    if (err != noErr) {
        NSLog(@"MIDISend err = %d", err);
    }
}

/*
 - (void)dispose
 {
     OSStatus err;
 
     err = MIDIPortDispose(outPortRef);
     if (err != noErr) NSLog(@"MIDIPortDispose err = %d", err);
 
     err = MIDIClientDispose(clientRef);
     if (err != noErr) NSLog(@"MIDIClientDispose err = %d", err);
 }
 */

@end

NSInvocationの作成

1件のフィードバック

NSInvocationOperationとか使っていて、NSInvocationの作り方が良くわからなかったので、自分で作る方法を調べてみました。以下のコードがNSInvocationを使ってtest:というメソッドを呼び出してみたものです。

#import <Cocoa/Cocoa.h>

@interface InvocationTest : NSObject {
    
}

@end

@implementation InvocationTest

- (void)awakeFromNib
{
    SEL selector;
    NSMethodSignature *signature;
    NSInvocation *invocation;
    
    selector = @selector(test:);
    signature = [[self class] 
        instanceMethodSignatureForSelector:selector];
    
    if (signature) {
        invocation = [NSInvocation invocationWithMethodSignature:signature];
        [invocation setSelector:selector];
        [invocation setTarget:self];
        
        NSString *sendString = @"send";
        [invocation setArgument:&sendString atIndex:2];
        
        [invocation invoke];

        id returnValue;
        [invocation getReturnValue:&returnValue];
        
        NSLog(@"%@", returnValue);
    }
    
    [NSApp terminate:self];
}

- (id)test:(id)object
{
    NSLog(@"call test with %@", object);
    return @"return";
}

@end

まず、NSMethodSignatureというのがないとNSInvocationがインスタンス化できないので、instanceMethodSignatureForSelector:で作成します。これはNSObjectのクラスオブジェクトですが、呼び出すクラスにお目当てのメソッドが無いとNSMethodSignatureの作成に成功しません。

NSMethodSignatureのインスタンスが作成できたら、NSInvocationのクラスメソッドであるinvocationWithMethodSignature:でNSInvocationのインスタンスを作成します。

ターゲットとなるオブジェクトと、ここでもセレクタを設定します。さらに引数も渡せますが、setArgument:index:メソッドのインデックスに渡す数字は２からになります。リファレンスには０はselfで、1は_cmdがすでに使われているというような事が書いてあります。

invokeで登録したメソッドが呼び出されます。返り値がある場合はNSInvocationのインスタンスに保持されていますのでgetReturnValueで受け取ります。

Core MIDI その２ MIDIPacketの受信

コメントを残す

Core MIDIではMIDIPacketというものがひとつのMIDIデータになります。そのMIDIPacketをMIDIPacketListに複数（あるいはひとつ）まとめて、MIDIエンドポイントを通してMIDIデータのやり取りをします。

MIDIPacketは構造体になっていて、以下のような感じで宣言されています。

struct MIDIPacket
{
    MIDITimeStamp   timeStamp;
    UInt16          length;
    Byte            data[256];
};
typedef struct MIDIPacket MIDIPacket;

timeStampは、0であれば受け取ったらすぐに処理をしろという事で、値が入ってれば処理すべきHosttimeという事のようです。lengthはdataのサイズです。dataはMIDIデータそのもので、すでに256バイトの配列が確保されているように見えますが、実際にいろいろ試してみた感じではlength分しかデータ領域が無いと思っていた方が良さそうです。

MIDIPacketListは以下のように宣言されています。

struct MIDIPacketList
{
    UInt32      numPackets;	
    MIDIPacket  packet[1];
};

packetは一つ分だけ確保されているように見えますが、MIDIPacketListには複数のMIDIPacketが含まれている事があり、その場合はnumPacketsにその数が入っていて、packetはその分の領域が確保されている状態になるようです。

そんな感じで、宣言されているのをそのまま当てにするとちょっと違っていたりするので、MIDIPacketListからのMIDIPacketの読み込みや、MIDPacketListの作成は、直接行うのではなく専用の関数が用意されています。

extern MIDIPacket *
MIDIPacketNext(MIDIPacket *pkt);

extern MIDIPacket *
MIDIPacketListInit(MIDIPacketList *pktlist)

extern MIDIPacket *
MIDIPacketListAdd(MIDIPacketList *  pktlist,
                  ByteCount         listSize,
                  MIDIPacket *      curPacket,
                  MIDITimeStamp     time,
                  ByteCount         nData,
                  const Byte *      data)

MIDIPacketListからの読み込みですが、ヘッダを見ると以下のような感じにするよう書いてあります。このようにMIDIPacketNextを使えばMIDIPacketのサイズに応じてパケットの位置を進めてくるようです。

MIDIPacket *packet = &packetList->packet[0];
  for (int i = 0; i < packetList->numPackets; ++i) {
    //...
    packet = MIDIPacketNext(packet);
  }

MIDIPacketListを作成するときにはMIDIPacketInitとMIDIPacketListAddを使ってMIDIPacketを追加して行くという事になりますがそれは次回やります。

MIDIPacketListを受信するには、MIDIClientCreate関数でMIDIClientを作成し、そのMIDIClientにMIDIInputPortCreate関数で入力用のMIDIPortを作成してMIDIデータを受信するコールバック関数を登録し、MIDIPortConnectSource関数でMIDIPortをMIDIEndpointと接続します。それぞれの関数は以下のように宣言されています。

extern OSStatus
MIDIClientCreate(CFStringRef     name, 
                 MIDINotifyProc	 notifyProc, 
                 void *          notifyRefCon, 
                 MIDIClientRef * outClient )

extern OSStatus 
MIDIInputPortCreate(MIDIClientRef client, 
                    CFStringRef   portName, 
                    MIDIReadProc  readProc, 
                    void *        refCon, 
                    MIDIPortRef * outPort )

extern OSStatus
MIDIPortConnectSource(MIDIPortRef     port, 
                      MIDIEndpointRef source, 
                      void *          connRefCon )

コールバック関数の引数の構成は決まっていて以下のような感じで宣言されています。

typedef void
(*MIDIReadProc)(const MIDIPacketList *pktlist, 
    void *readProcRefCon, void *srcConnRefCon);

readProcRefConにはMIDIPortを作成したときに登録したrefCon、srcConnRefConにはMIDIPortにソースを接続したときに登録したconnRefConがそれぞれ渡ってきます。これらを使ってMIDIPacketListがやってくるポート等を識別したりして処理する事ができると思います。呼ばれるのはメインスレッドではないようです。

それと、MIDIClientやMIDIPortが必要なくなったらMIDIClientDispose関数やMIDIPortDisposeで解放します。

以下が、アプリケーションの外部からMIDIデータを受信するサンプルです。ちょっと今回は気分を変えて、Cocoaアプリケーションのmain.mを以下のような感じで書き換えてみます。CoreMIDI.Frameworkも追加しておいてください。

//
//  main.m
//

#import <Cocoa/Cocoa.h>
#import <CoreMIDI/CoreMIDI.h>

static void 
MIDIInputProc(const MIDIPacketList *pktlist, 
    void *readProcRefCon, void *srcConnRefCon)
{
    //MIDIパケットリストの先頭のMIDIPacketのポインタを取得
    MIDIPacket *packet = (MIDIPacket *)&(pktlist->packet[0]);
    //パケットリストからパケットの数を取得
    UInt32 packetCount = pktlist->numPackets;
    
    for (NSInteger i = 0; i < packetCount; i++) {
        
        //data[0]からメッセージの種類とチャンネルを分けて取得する
        Byte mes = packet->data[0] & 0xF0;
        Byte ch = packet->data[0] & 0x0F;
        
        //メッセージの種類に応じてログに表示
        if ((mes == 0x90) && (packet->data[2] != 0)) {
            NSLog(@"note on number = %2.2x / velocity = %2.2x / channel = %2.2x",
                  packet->data[1], packet->data[2], ch);
        } else if (mes == 0x80 || mes == 0x90) {
            NSLog(@"note off number = %2.2x / velocity = %2.2x / channel = %2.2x", 
                  packet->data[1], packet->data[2], ch);
        } else if (mes == 0xB0) {
            NSLog(@"cc number = %2.2x / data = %2.2x / channel = %2.2x", 
                  packet->data[1], packet->data[2], ch);
        } else {
            NSLog(@"etc");
        }
        
        //次のパケットへ進む
        packet = MIDIPacketNext(packet);
    }
}

int main(int argc, char *argv[])
{
    OSStatus err;
    MIDIClientRef clientRef;
    MIDIPortRef inputPortRef;
    
    //MIDIクライアントを作成する
    NSString *clientName = @"inputClient";
    err = MIDIClientCreate((CFStringRef)clientName, NULL, NULL, &clientRef);
    if (err != noErr) {
        NSLog(@"MIDIClientCreate err = %d", err);
        return 1;
    }
    
    //MIDIポートを作成する
    NSString *inputPortName = @"inputPort";
    err = MIDIInputPortCreate(
        clientRef, (CFStringRef)inputPortName, 
        MIDIInputProc, NULL, &inputPortRef);
    if (err != noErr) {
        NSLog(@"MIDIInputPortCreate err = %d", err);
        return 1;
    }
    
    //MIDIエンドポイントを取得し、MIDIポートに接続する
    ItemCount sourceCount = MIDIGetNumberOfSources();
    for (ItemCount i = 0; i < sourceCount; i++) {
        MIDIEndpointRef sourcePointRef = MIDIGetSource(i);
        err = MIDIPortConnectSource(inputPortRef, sourcePointRef, NULL);
        if (err != noErr) {
            NSLog(@"MIDIPortConnectSource err = %d", err);
            return 1;
        }
    }
    
    return NSApplicationMain(argc,  (const char **) argv);
}

実行すると、オンラインになっているMIDIインプット全てから受信してログに表示します。MIDIPortとかの解放は全然やってませんし、実際にはMIDITimeStampの時間にもちゃんと対応して処理する事も必要になると思います。

Core MIDI その１ MIDIObject

1件のフィードバック

Core MIDIに関してリアルタイムで調査中ですが、ちょこちょこと分かった事を書いて行こうと思います。ここのページにもいろいろと書いてありますので参考に。

まず用語解説的なところから始めまして、Core MIDIを使うときに必要なMIDIオブジェクトというものを見て行きます。MIDIオブジェクトは、

・MIDIDevice
・MIDIEntity
・MIDIEndpoint

・MIDIClient
・MIDIPort

という５つがあるのですが、上の３つは基本的にアプリケーション外部からCoreMIDI経由で取得するもの（MIDIEndpointは例外あり）で、下の２つのMIDIClientとMIDIPortはアプリケーション側に作るものです。

まず、上の方から見て行きます。MIDIDeviceというのは名前の通りMIDIのデバイスの事ですが、Core MIDIではMIDIインターフェース以外にも、アプリケーション同士を直接つなげるIACドライバとか、ネットワーク経由での接続とかもありまして、それらも全て同じMIDIDeviceとして取得できます。

まあ、実際見た方が分かりやすいと思いますので、Audio MIDI 設定を開いてみますと…

AudioMIDISetup.jpg

このように表示されているとしたら、この表示されている４つがMIDIDeviceになります。右から２つ目の「Onyx Firewire(0134)」ように実際つながっていなくてもAudio MIDI 設定で登録されていれば、MIDIDeviceとして取得できます。

MIDIDeviceはMIDIEntityというのを持っていまして、たとえば今回見ているAudio MIDI 設定のUA-25でいえば…

UA25.jpg

左下の「ポート」の中に表示されている「EDIROL UA-25」というのがエンティティになります。これはデバイスによって複数持つ場合もあり、「IACドライバ」なんかでは自由に増やせますから、

IAC.jpg

こんな風に２つ作っておくと、「IACドライバ」というMIDIDeviceの中から「バス１」と「バス２」という２つのMIDIEntityが取得できます。

MIDIEndpointというのは、MIDIEntityの中にあるMIDI入力や出力の事（Audio MIDI 設定ではポートの右にあるコネクタのところのMIDI入力と出力）になります。MIDIインターフェースに装備されているMIDI INやMIDI OUTのコネクタそのものだと考えてよいと思います。Core MIDIではアプリケーション側から見て入力はSource、出力はDestinationと表現されます。

アプリケーション内部の方に移りまして、MIDIClientというのはアプリケーション内部に作るMIDIデバイスのようなものです。MIDIClientを作成するときにMacのMIDIシステムの変更を受け取るコールバック関数を登録する事もできます。

アプリケーション外部とMIDIデータをやり取りするにはMIDIClientにMIDIPortというものを作成します。入力に関しては、MIDIEndpointをMIDIPortに登録すると同時にコールバックを設定して、リアルタイムでMIDIデータを受け取れます。

ちなみにMusicPlayerの再生とかCore Audio Clockのように、MIDIClientとかMIDIPortとかを作らずにMIDIEndpointを直接渡すだけで良い場合もあります。MIDIClientやMIDIPortは自分でMIDIの生のデータを処理したいときに使うという感じでしょうか。

といったところでサンプルです、。MIDIデバイスからMIDIエンティティを取得してさらに入力側のMIDIエンドポイントを取得します。FoundationToolで新規作成して、CoreMIDI.Frameworkを追加し実行すると、使用可能なデバイスの、エンドポイントの名前とオフラインかどうかを表示します。

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

int main (int argc, const char * argv[]) {
    NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
    
    OSStatus err;
    CFStringRef strDeviceRef = NULL;
    CFStringRef strEndPointRef = NULL;
    
    //MIDIデバイスの数を取得する
    ItemCount count = MIDIGetNumberOfDevices();
    
    for (ItemCount i = 0; i < count; i++) {
        
        //MIDIデバイスを取得する
        MIDIDeviceRef devRef = MIDIGetDevice(i);
        
        //MIDIデバイスの名前を取得する
        err = MIDIObjectGetStringProperty(
            devRef, kMIDIPropertyName, &strDeviceRef);
        if (err != noErr) {
            NSLog(@"err = %d", err);
        }
        
        //MIDIエンティティの数を取得する
        ItemCount numEntities = MIDIDeviceGetNumberOfEntities(devRef);
        
        for (NSInteger j = 0; j < numEntities; j++) {
            
            //MIDIエンティティを取得する
            MIDIEntityRef entityRef = MIDIDeviceGetEntity(devRef, j);
            
            //MIDIエンティティからMIDIエンドポイントのソースの数を取得する
            ItemCount sourceCount = MIDIEntityGetNumberOfSources(entityRef);
            
            for (NSInteger k = 0; k < sourceCount; k++) {
                
                //MIDIエンドポイントを取得する
                MIDIEndpointRef endPointRef = 
                    MIDIEntityGetSource(entityRef, k);
                
                //MIDIエンドポイントの名前を取得する
                err = MIDIObjectGetStringProperty(
                    endPointRef, kMIDIPropertyName, &strEndPointRef);
                if (err != noErr) {
                    NSLog(@"err = %d", err);
                }
                
                SInt32 isOffline;
                err = MIDIObjectGetIntegerProperty(
                    endPointRef, kMIDIPropertyOffline, &isOffline);
                if (err != noErr) {
                    NSLog(@"err = %d", err);
                }
                
                //ログに表示
                NSLog(@"Device = %@ / EndPoint = %@ / Offline = %d", 
                    strDeviceRef, strEndPointRef, isOffline);
                
                if (strEndPointRef) {
                    CFRelease(strEndPointRef);
                    strEndPointRef = NULL;
                }
            }
        }
        
        if (strDeviceRef) {
            CFRelease(strDeviceRef);
            strDeviceRef = NULL;
        }
    }
    
    [pool drain];
    return 0;
}

この方法で使用可能なMIDIエンドポイントを取得するときは、オフラインになっていない事もチェックしないといけなかったりしていろいろ面倒ですが、以下のようにMIDIGetNumberOfSourcesとMIDIGetSourceで、いきなりオンラインになっているMIDIエンドポイントを取得できます。

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

int main (int argc, const char * argv[]) {
    NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];

    OSStatus err;
    CFStringRef strEndPointRef = NULL;
    
    ItemCount sourceCount = MIDIGetNumberOfSources();
    
    for (NSInteger i = 0; i < sourceCount; i++) {
        
        //MIDIエンドポイントを取得する
        MIDIEndpointRef endPointRef = MIDIGetSource(i);
        
        //MIDIエンドポイントの名前を取得する
        err = MIDIObjectGetStringProperty(
            endPointRef, kMIDIPropertyName, &strEndPointRef);
        
        if (err == noErr) {
            
            //ログに表示
            NSLog(@"EndPoint = %@", strEndPointRef);
            
            if (strEndPointRef) {
                CFRelease(strEndPointRef);
                strEndPointRef = NULL;
            }
            
        } else {
            
            NSLog(@"err = %d", err);
        }
    }
    
    [pool drain];
    return 0;
}

Core Audio Clock その２ MTCスレーブ

コメントを残す

Core Audio ClockをMTCのスレーブにするサンプルです。

あれこれMIDIの設定とかしなくちゃいけないのかと思っていたら、意外と簡単でした。MIDIClientとかPortとかつくらずに、MIDIEndPointを直接渡してしまえばいいだけみたいです。

設定の順番としては、

・CAClockを作成する
・SyncModeをMTCTransportにする
・SyncSourceにMTCが送られてくるMIDIEndPointを設定する
・タイムコードのフォーマットを送信側と合わせておく
・CAClockArmでMTCを受信できる状態にする
・同期する必要がなくなったらCAClockDisarmで解除する

といった感じです。

Cocoaアプリケーションを作成して、AudioToolboxとCoreMIDIのフレームワークをインポートし、以下のクラスを作成し、タイムコード表示用のテキストフィールドをアウトレットに設定します。MIDIのインプットは一つしか無い事を想定していますので、Audio MIDI 設定でうまいこと設定してください。同じMac上のMIDIシーケンサから受け取る場合は、IACドライバの「装置はオンライン」にチェックして、シーケンサのMTCのアウトをIACのバスを通して送られてくるように設定します。

//
//  CAClockMTCSlaveTest.h
//

#import <Cocoa/Cocoa.h>
#import <CoreMIDI/CoreMIDI.h>
#import <AudioToolbox/CoreAudioClock.h>

@interface CAClockMTCSlaveTest : NSObject {
    
    CAClockRef clockRef;
    MIDIEndpointRef srcPointRef;
    BOOL isStart;
    NSTimer *timer;
    IBOutlet NSTextField *textField;
}

- (void)clockListener:(CAClockMessage)message parameter:(const void *)param;
- (void)checkTime:(NSTimer *)timr;

@end


//
//  CAClockMTCSlaveTest.m
//

#import "CAClockMTCSlaveTest.h"


@implementation CAClockMTCSlaveTest

#pragma mark -
#pragma mark -- コールバック --

static void 
ClockListener(void *userData, CAClockMessage message, const void *param)
{
    [(id)userData clockListener:message parameter:param];
}

- (void)clockListener:(CAClockMessage)message parameter:(const void *)param
{
    switch (message) {
        case kCAClockMessage_Started:
            isStart = YES;
            NSLog(@"started");
            break;
        case kCAClockMessage_Stopped:
            isStart = NO;
            NSLog(@"stoped");
            break;
        case kCAClockMessage_Armed:
            NSLog(@"armed");
            break;
        case kCAClockMessage_Disarmed:
            NSLog(@"disarmed");
            break;
        case kCAClockMessage_WrongSMPTEFormat:
            NSLog(@"wrongSMPTEFormat");
            break;
        default:
            break;
    }
}

#pragma mark -
#pragma mark -- 初期化など --

- (void)awakeFromNib
{
    OSStatus err = noErr;
    UInt32 size;
    
    //MIDIエンドポイントを取得する
    srcPointRef = MIDIGetSource(0);
    
    //MIDIエンドポイントから名前を取得して表示
    CFStringRef strSrcRef;
    err = MIDIObjectGetStringProperty(
        srcPointRef, kMIDIPropertyDisplayName, &strSrcRef);
    if (err != noErr) {
        NSLog(@"MIDI Get sourceName err = %d", err);
        goto end;
    }
    NSLog(@"connect = %@", strSrcRef);
    CFRelease(strSrcRef);
    
    
    //CAClockを作成する
    err = CAClockNew(0, &clockRef);
    if (err != noErr) {
        NSLog(@"CAClockNew err = %d", err);
        goto end;
    }
    
    //シンクモードをMTCにする
    UInt32 tSyncMode = kCAClockSyncMode_MTCTransport;
    size = sizeof(tSyncMode);
    err = CAClockSetProperty(
        clockRef, kCAClockProperty_SyncMode, size, &tSyncMode);
    if (err != noErr) {
        NSLog(@"set syncmode Err = %d", err);
        goto end;
    }
    
    //CAClockの同期元にMIDIエンドポイントを設定する
    size = sizeof(srcPointRef);
    err = CAClockSetProperty(
        clockRef, kCAClockProperty_SyncSource, size, &srcPointRef);
    if (err != noErr) {
        NSLog(@"caclock setSyncSourct err = %d", err);
        goto end;
    }
    
    //SMPTEを30fpsに設定する
    UInt32 tSMPTEType = kSMPTETimeType30;
    size = sizeof(tSMPTEType);
    err = CAClockSetProperty(
        clockRef, kCAClockProperty_SMPTEFormat, size, &tSMPTEType);
    if (err != noErr) {
        NSLog(@"set smptetype Err = %d", err);
        goto end;
    }
    
    //CAClockからの通知を受け取る関数を設定する
    err = CAClockAddListener(clockRef, ClockListener, self);
    if (err != noErr) {
        NSLog(@"caclock addListener err = %d", err);
        goto end;
    }
    
    err = CAClockArm(clockRef);
    if (err != noErr) {
        NSLog(@"CAClock arm err = %d", err);
        goto end;
    }
    
    //タイマーを開始する
    timer = [NSTimer scheduledTimerWithTimeInterval:0.01 
        target:self selector:@selector(checkTime:) 
        userInfo:nil repeats:YES];
    [[NSRunLoop currentRunLoop] 
        addTimer:timer forMode:NSEventTrackingRunLoopMode];
    
    return;
    
end:
    
    [NSApp terminate:self];
    return;
}

- (void) dealloc
{
    [timer invalidate];

    OSStatus err;
    
    err = CAClockDisarm(clockRef);
    if (err != noErr) NSLog(@"clock disarm Err");
    
    err = CAClockDispose(clockRef);
    if (err != noErr) NSLog(@"CAClockDispose err");
    
    [super dealloc];
}

#pragma mark -
#pragma mark -- タイムの表示 --

//現在のタイムを表示する
- (void)checkTime:(NSTimer *)timr
{
    OSStatus err;
    CAClockTime secondTime;
    
    //再生中か停止中かで取得するタイムを変える
    if (isStart) {
        //カレントタイムを取得する
        err = CAClockGetCurrentTime(
            clockRef, kCAClockTimeFormat_Seconds, &secondTime);
        if (err != noErr) {
            NSLog(@"CAClock GetCurrenttime err = %d", err);
            return;
        }
    } else {
        //スタートタイムを取得する
        err = CAClockGetStartTime(
            clockRef, kCAClockTimeFormat_Seconds, &secondTime);
        if (err != noErr) {
            NSLog(@"CAClock GetCurrenttime err = %d", err);
            return;
        }
    }
    
    CAClockSeconds seconds = secondTime.time.seconds
;
    
    //秒数からタイムコードに変換する
    SMPTETime tSMPTETime;
    err = CAClockSecondsToSMPTETime(clockRef, seconds, 80, &tSMPTETime);
    if (err != noErr) {
        NSLog(@"secondsToSMPTE err = %d", err);
        return;
    }
    
    SInt16 tHours = tSMPTETime.mHours;
    SInt16 tMinutes = tSMPTETime.mMinutes;
    SInt16 tSeconds = tSMPTETime.mSeconds;
    SInt16 tFrames = tSMPTETime.mFrames;
    
    Float64 tPlayRate;
    err = CAClockGetPlayRate(clockRef, &tPlayRate);
    if (err != noErr) {
        NSLog(@"getPlayRate err = %d", err);
        return;
    }
    
    //タイムを表示する
    NSString *tSMPTEString = 
    [NSString stringWithFormat:
        @"seconds = %f / SMPTE = %2.2hi.%2.2hi.%2.2hi.%2.2hi / PlayRate = %f"
        , seconds, tHours, tMinutes, tSeconds, tFrames, tPlayRate];
    
    [textField setStringValue:tSMPTEString];
}

@end

実行して、シーケンサ等からMTCを送り込まれると、受信してタイムを表示するはずです。ただ、SMPTETimeTypeに29.97を設定しても受信出来ませんでした。29.97を受信する時は30にSMPTETimeTypeを設定しておいて、同期するとPlayRateが0.999付近になります。

動き続けるCALayer

コメントを残す

CoreAnimationでCALayerを動かし続けたい時の方法です。プロパティ変更での暗黙的なアニメーションだといろいろと不都合なので、CABasicAnimationを使ってやってみました。

以下がそのサンプルです。カスタムビューにアウトレットをつなげて実行してください。

//
//  EndlessCoreAnimationTest.h
//

#import <Cocoa/Cocoa.h>
#import <QuartzCore/QuartzCore.h>

@interface EndlessCoreAnimationTest : NSObject {

    IBOutlet NSView *view;
    CALayer *moveLayer;
    NSTimer *timer;
    NSDate *startDate;
}

- (void)changeAnimation;

@end


//
//  EndlessCoreAnimationTest.m
//

#import "EndlessCoreAnimationTest.h"


@implementation EndlessCoreAnimationTest

- (void)awakeFromNib
{
    NSRect viewRect = [view bounds];
    CGFloat viewWidth = viewRect.size.width;
    CGFloat viewHeight = viewRect.size.height;
    CGFloat minSize = (viewWidth > viewHeight) ? viewHeight : viewWidth;
    
    CALayer *baseLayer = [CALayer layer];
    CGColorRef baseColor = CGColorCreateGenericRGB(0.0, 0.0, 0.0, 1.0);
    baseLayer.backgroundColor = baseColor;
    CGColorRelease(baseColor);
    
    moveLayer = [CALayer layer];
    moveLayer.anchorPoint = CGPointMake(0.5, - 9.0);
    moveLayer.bounds = CGRectMake(0, 0, minSize * 0.05, minSize * 0.05);
    moveLayer.position = CGPointMake(viewWidth * 0.5, viewHeight * 0.5);
    CGColorRef moveColor = CGColorCreateGenericRGB(1.0, 0.0, 0.0, 1.0);
    moveLayer.backgroundColor = moveColor;
    CGColorRelease(moveColor);
    
    [view setLayer:baseLayer];
    [view setWantsLayer:YES];
    [baseLayer addSublayer:moveLayer];
    
    [self performSelector:@selector(startTimer) 
        withObject:nil afterDelay:1.0];
}

- (void)startTimer
{
    startDate = [[NSDate date] retain];
    [self changeAnimation];
    timer = [NSTimer scheduledTimerWithTimeInterval:1.0 
        target:self selector:@selector(changeAnimation) 
        userInfo:nil repeats:YES];
}

- (void)changeAnimation
{
    CGFloat currentTime = [startDate timeIntervalSinceNow];
    CGFloat duration = 2.0;
    
    CABasicAnimation *anim = 
        [CABasicAnimation animationWithKeyPath:@"transform"];
    CATransform3D fromTrans = 
        CATransform3DMakeRotation(currentTime * M_PI / 4.0, 0.0, 0.0, 1.0);
    CATransform3D toTrans = 
        CATransform3DMakeRotation((currentTime - duration) * M_PI / 4.0, 
        0.0, 0.0, 1.0);
	
    anim.fromValue = [NSValue valueWithCATransform3D:fromTrans];
    anim.toValue = [NSValue valueWithCATransform3D:toTrans];
    anim.duration = duration;
    
    [moveLayer addAnimation:anim forKey:@"transformAnimation"];
}


- (void) dealloc
{
    [timer invalidate];
    [startDate release];
    
    [super dealloc];
}

@end

durationを２秒にしてtoValueを２秒後の値にしたCABasicAnimationを、NSTimerで１秒ごとに途切れる事無く追加しています。追加する時に動いているアニメーションの位置が新たなアニメーションのfromValueと一致するようになっていればスムーズにつながります。