8 Sizzling Ways to Master MacOS Media Capture with CoreMediaIO (Code That’ll Make Devs Jealous)

Ever tried diving into the nitty-gritty of MacOS media capture and hit a wall of outdated docs and cryptic errors? For instance, you’re itching to grab raw video or audio buffers straight from a device—say, a camera or an iOS screen mirror—without AVFoundation meddling in the middle. However, the high-level AVFoundation framework often insists on decoding or demuxing payloads, which is a buzzkill for edge cases like handling pre-compressed streams. So, what’s the fix? Enter CoreMediaIO, the low-level C++ beast that lets you wrestle devices into submission and get those pristine buffers.

Unfortunately, CoreMediaIO’s sparse documentation and dusty sample code can feel like decoding an alien script. But fear not—because I’m dropping eight steamy tricks to make you a CoreMediaIO wizard, complete with slick code snippets that’ll have your fellow devs drooling. Therefore, whether you’re a C++/Obj-C pro or an architect chasing that perfect capture setup, let’s crank up the heat and dive into the raw, unfiltered world of MacOS media capture.

8 CoreMediaIO Hacks to Capture Like a Pro

1. Unleash Hidden Devices with DAL Magic

Want to capture an iOS screen mirror or obscure device? First, you’ve got to enable CoreMediaIO’s DAL plug-ins. For example, this snippet flips the switch to reveal screen capture devices:

void EnableDALDevices() {  
    CMIOObjectPropertyAddress prop = {  
        kCMIOHardwarePropertyAllowScreenCaptureDevices,  
        kCMIOObjectPropertyScopeGlobal,  
        kCMIOObjectPropertyElementMaster  
    };  
    UInt32 allow = 1;  
    CMIOObjectSetPropertyData(kCMIOObjectSystemObject, &prop, 0, NULL, sizeof(allow), &allow);  
}

So, call this early—otherwise, your dream device stays invisible.

2. Catch Devices on the Fly

Devices pop in and out at runtime, like flirty guests at a party. Therefore, set up notifications to track them using NSNotificationCenter. For instance:

NSNotificationCenter *center = [NSNotificationCenter defaultCenter];  
id connObs = [center addObserverForName:AVCaptureDeviceWasConnectedNotification  
                                 object:nil  
                                  queue:[NSOperationQueue mainQueue]  
                             usingBlock:^(NSNotification *note) {  
                                 NSLog(@"Device added: %@", note.object);  
                             }];  
id disconnObs = [center addObserverForName:AVCaptureDeviceWasDisconnectedNotification  
                                   object:nil  
                                    queue:[NSOperationQueue mainQueue]  
                               usingBlock:^(NSNotification *note) {  
                                   NSLog(@"Device gone: %@", note.object);  
                               }];  
[[NSRunLoop mainRunLoop] run];  

However, don’t forget the run loop—without it, you’re ghosted by notifications.

3. Hunt Down Devices Like a Pro

Enumerating devices is your next step. For example, you can lean on AVFoundation for a quick list:

NSArray *devs = [AVCaptureDevice devices];  
for (AVCaptureDevice *d in devs) {  
    NSLog(@"ID: %@, Name: %@", [d uniqueID], [d localizedName]);  
}

Alternatively, go full CoreMediaIO to dig deeper—because sometimes AVFoundation hides the good stuff.

4. Pinpoint Your Device by ID

Got a specific device in mind? Then, resolve its CMIODeviceID using its unique ID. Here’s how:

OSStatus FindDeviceByUniqueId(const char* pUID, CMIODeviceID& devId) {  
    uint32_t numDev = 0;  
    if (GetNumberDevices(numDev) < 0 || numDev == 0) return -1;  
    CMIODeviceID* pDevs = (CMIODeviceID*)alloca(numDev * sizeof(*pDevs));  
    if (GetDevices(numDev, pDevs) < 0) return -1;  
    for (uint32_t i = 0; i < numDev; i++) {  
        char pUniqueID[64];  
        if (GetDeviceStrProp(pDevs[i], kCMIODevicePropertyDeviceUID, pUniqueID) < 0) continue;  
        if (strcmp(pUID, pUniqueID) == 0) {  
            devId = pDevs[i];  
            return 0;  
        }  
    }  
    return -1;  
}

Thus, you’re locked onto your target—no guesswork needed.

5. Stream Surfing for the Win

Each device offers streams (video, audio, or muxed), and you need to pick the right one. For instance, here’s how to list them:

uint32_t GetNumberInputStreams(CMIODeviceID devID) {  
    uint32 size = 0;  
    GetPropertyDataSize(devID, kCMIODevicePropertyStreams, kCMIODevicePropertyScopeInput, size);  
    return size / sizeof(CMIOStreamID);  
}  

CMIODeviceID devId;  
FindDeviceByUniqueId("4e58df701eb87", devId);  
uint32_t numStreams = GetNumberInputStreams(devId);  
CMIOStreamID* pStreams = (CMIOStreamID*)alloca(numStreams * sizeof(CMIOStreamID));  
GetInputStreams(devId, numStreams, pStreams);  

So, now you’re browsing streams like a DJ spinning tracks.

6. Decode Stream Formats

Before pumping data, know what you’re getting—video, audio, or a spicy muxed mix. For example:

for (uint32_t i = 0; i < numStreams; i++) {  
    CMFormatDescriptionRef fmt = 0;  
    uint32_t used;  
    GetPropertyData(pStreams[i], kCMIOStreamPropertyFormatDescription, 0, NULL, sizeof(fmt), used, &fmt);  
    CMMediaType mt = CMFormatDescriptionGetMediaType(fmt);  
    FourCharCode fourcc = CMFormatDescriptionGetMediaSubType(fmt);  
    printf("Stream %d: Media type %s, Subtype %s\n", i, (char*)&mt, (char*)&fourcc);  
}

Therefore, you’re never blindsided by mystery payloads.

7. Pump Raw Data Like a Boss

Now, the main event—grabbing raw buffers. Set up a callback to snag the goods:

CMSimpleQueueRef queueRef = 0;  
CMIOStreamCopyBufferQueue(pStreams[0], [](CMIOStreamID streamID, void*, void* refCon) {  
    CMSimpleQueueRef queue = *(CMSimpleQueueRef*)refCon;  
    CMSampleBufferRef sb = 0;  
    while ((sb = (CMSampleBufferRef)CMSimpleQueueDequeue(queue))) {  
        size_t len, lenTotal;  
        char* pPayload = 0;  
        CMBlockBufferRef buf = CMSampleBufferGetDataBuffer(sb);  
        CMBlockBufferGetDataPointer(buf, 0, &len, &lenTotal, &pPayload);  
        printf("Got %zu bytes of raw goodness!\n", len);  
    }  
}, &queueRef, &queueRef);  

Because you’re now sipping straight from the source, you’ve got full control.

8. Crack Audio Formats on the Fly

Sometimes, formats only reveal themselves mid-capture. For instance, here’s how to parse audio:

bool PrintAudioFormat(CMSampleBufferRef sb) {  
    CMFormatDescriptionRef fmt = CMSampleBufferGetFormatDescription(sb);  
    if (CMFormatDescriptionGetMediaType(fmt) != kCMMediaType_Audio) return false;  
    CMAudioFormatDescriptionRef afmt = (CMAudioFormatDescriptionRef)fmt;  
    const auto pAud = CMAudioFormatDescriptionGetStreamBasicDescription(afmt);  
    if (!pAud || pAud->mFormatID != 'lpcm') return false;  
    printf("Channels: %d, Sample Rate: %.1f\n", pAud->mChannelsPerFrame, pAud->mSampleRate);  
    return true;  
}

Thus, you’re ready for anything—audio, video, or beyond.

Why This Is Your Dev Dream Date

CoreMediaIO’s raw power is like a backstage pass to MacOS media—tricky to navigate, but oh-so-rewarding. For example, I once used #7 to snag pristine iOS mirror buffers for a streaming app; the client flipped, and my rep soared. So, whether you’re dodging AVFoundation’s overreach or chasing low-level glory, these tricks make you unstoppable. Now go code something that’ll make jaws drop!