Sposób parowania kamery z jednego urządzenia z systemem iOS na inny przy użyciu połączenia z wieloma urządzeniami równorzędnymi

Question

w jaki sposób możemy wydajnie przesyłać pliki z kamer z jednego urządzenia z systemem iOS do innego przy użyciu technologii Bluetooth lub Wi-Fi w systemie iOS 7. Poniżej znajduje się kod do uzyskania bufora parowego.

- (void)captureOutput:(AVCaptureOutput *)captureOutput 
     didOutputSampleBuffer:(CMSampleBufferRef)sampleBuffer 
     fromConnection:(AVCaptureConnection *)connection 
{ 
    // Create a UIImage from the sample buffer data 
    UIImage *image = [self imageFromSampleBuffer:sampleBuffer]; 


} 

    // Create a UIImage from sample buffer data 
- (UIImage *) imageFromSampleBuffer:(CMSampleBufferRef) sampleBuffer 
{ 
    // Get a CMSampleBuffer's Core Video image buffer for the media data 
    CVImageBufferRef imageBuffer = CMSampleBufferGetImageBuffer(sampleBuffer); 
    // Lock the base address of the pixel buffer 
    CVPixelBufferLockBaseAddress(imageBuffer, 0); 

    // Get the number of bytes per row for the pixel buffer 
    void *baseAddress = CVPixelBufferGetBaseAddress(imageBuffer); 

    // Get the number of bytes per row for the pixel buffer 
    size_t bytesPerRow = CVPixelBufferGetBytesPerRow(imageBuffer); 
    // Get the pixel buffer width and height 
    size_t width = CVPixelBufferGetWidth(imageBuffer); 
    size_t height = CVPixelBufferGetHeight(imageBuffer); 

    // Create a device-dependent RGB color space 
    CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceRGB(); 

    // Create a bitmap graphics context with the sample buffer data 
    CGContextRef context = CGBitmapContextCreate(baseAddress, width, height, 8, 
     bytesPerRow, colorSpace, kCGBitmapByteOrder32Little | kCGImageAlphaPremultipliedFirst); 
    // Create a Quartz image from the pixel data in the bitmap graphics context 
    CGImageRef quartzImage = CGBitmapContextCreateImage(context); 
    // Unlock the pixel buffer 
    CVPixelBufferUnlockBaseAddress(imageBuffer,0); 

    // Free up the context and color space 
    CGContextRelease(context); 
    CGColorSpaceRelease(colorSpace); 

    // Create an image object from the Quartz image 
    UIImage *image = [UIImage imageWithCGImage:quartzImage]; 

    // Release the Quartz image 
    CGImageRelease(quartzImage); 

    return (image); 
} 

tutaj możemy uzyskać obraz, który jest przechwytywany przez kamerę iOS.

Czy możemy przesłać informacje o buforze próbki bezpośrednio do innego urządzenia za pomocą multi-peera lub czy istnieje skuteczny sposób na parowanie danych na inne urządzenia z systemem iOS?

Dziękuję.

Answer 1

Mam sposób, w jaki to robimy. Możemy używać łączności z wieloma urządzeniami równorzędnymi, aby przesyłać skompresowane obrazy, tak aby wyglądały jak strumieniowanie kamery.

Jeden wzajemnej, który zamierza wysłać strumień użyje tej metody code.In captureOutput Delegat:

 NSData *imageData = UIImageJPEGRepresentation(cgBackedImage, 0.2); 

    // maybe not always the correct input? just using this to send current FPS... 
    AVCaptureInputPort* inputPort = connection.inputPorts[0]; 
    AVCaptureDeviceInput* deviceInput = (AVCaptureDeviceInput*) inputPort.input; 
    CMTime frameDuration = deviceInput.device.activeVideoMaxFrameDuration; 
    NSDictionary* dict = @{ 
          @"image": imageData, 
          @"timestamp" : timestamp, 
          @"framesPerSecond": @(frameDuration.timescale) 
          }; 
    NSData *data = [NSKeyedArchiver archivedDataWithRootObject:dict]; 


    [_session sendData:data toPeers:_session.connectedPeers withMode:MCSessionSendDataReliable error:nil]; 

A na stronie odbiorczej:

- (void)session:(MCSession *)session didReceiveData:(NSData *)data fromPeer:(MCPeerID *)peerID { 

// NSLog(@"(%@) Read %d bytes", peerID.displayName, data.length); 

    NSDictionary* dict = (NSDictionary*) [NSKeyedUnarchiver unarchiveObjectWithData:data]; 
    UIImage* image = [UIImage imageWithData:dict[@"image"] scale:2.0]; 
    NSNumber* framesPerSecond = dict[@"framesPerSecond"]; 


} 

otrzymamy wartość FPS, a zatem możemy ustawić parametry do zarządzania naszymi strumieniowymi obrazami.

Mam nadzieję, że to pomoże.

Dziękuję.

Answer 2

Oto najlepszy sposób to zrobić (i wyjaśnić, dlaczego na końcu):

Na urządzeniu z iOS wysyłającego dane obrazu:

- (void)captureOutput:(AVCaptureOutput *)captureOutput didOutputSampleBuffer:(CMSampleBufferRef)sampleBuffer fromConnection:(AVCaptureConnection *)connection 
{ 
    CVImageBufferRef imageBuffer = CMSampleBufferGetImageBuffer(sampleBuffer); 

    CVPixelBufferLockBaseAddress(imageBuffer,0); 
    uint8_t *baseAddress = (uint8_t *)CVPixelBufferGetBaseAddress(imageBuffer); 
    size_t bytesPerRow = CVPixelBufferGetBytesPerRow(imageBuffer); 
    size_t width = CVPixelBufferGetWidth(imageBuffer); 
    size_t height = CVPixelBufferGetHeight(imageBuffer); 

    CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceRGB(); 
    CGContextRef newContext = CGBitmapContextCreate(baseAddress, width, height, 8, bytesPerRow, colorSpace, kCGBitmapByteOrder32Little | kCGImageAlphaPremultipliedFirst); 
    CGImageRef newImage = CGBitmapContextCreateImage(newContext); 


    UIImage *image = [[UIImage alloc] initWithCGImage:newImage scale:1 orientation:UIImageOrientationUp]; 
    CGImageRelease(newImage); 
    CGContextRelease(newContext); 
    CGColorSpaceRelease(colorSpace); 
    CVPixelBufferUnlockBaseAddress(imageBuffer, 0); 

    if (image) { 
     NSData *data = UIImageJPEGRepresentation(image, 0.7); 
     NSError *err; 
     [((ViewController *)self.parentViewController).session sendData:data toPeers:((ViewController *)self.parentViewController).session.connectedPeers withMode:MCSessionSendDataReliable error:&err]; 
    } 
} 

Na urządzeniu z iOS odbierającego dane obrazu :

typedef struct { 
    size_t length; 
    void *data; 
} ImageCacheDataStruct; 

- (void)session:(nonnull MCSession *)session didReceiveData:(nonnull NSData *)data fromPeer:(nonnull MCPeerID *)peerID 
{ 
    dispatch_async(self.imageCacheDataQueue, ^{ 
     dispatch_semaphore_wait(self.semaphore, DISPATCH_TIME_FOREVER); 
     const void *dataBuffer = [data bytes]; 
     size_t dataLength = [data length]; 
     ImageCacheDataStruct *imageCacheDataStruct = calloc(1, sizeof(imageCacheDataStruct)); 
     imageCacheDataStruct->data = (void*)dataBuffer; 
     imageCacheDataStruct->length = dataLength; 

     __block const void * kMyKey; 
     dispatch_queue_set_specific(self.imageDisplayQueue, &kMyKey, (void *)imageCacheDataStruct, NULL); 

     dispatch_sync(self.imageDisplayQueue, ^{ 
      ImageCacheDataStruct *imageCacheDataStruct = calloc(1, sizeof(imageCacheDataStruct)); 
      imageCacheDataStruct = dispatch_queue_get_specific(self.imageDisplayQueue, &kMyKey); 
      const void *dataBytes = imageCacheDataStruct->data; 
      size_t length = imageCacheDataStruct->length; 
      NSData *imageData = [NSData dataWithBytes:dataBytes length:length]; 
      UIImage *image = [UIImage imageWithData:imageData]; 
      if (image) { 
       dispatch_async(dispatch_get_main_queue(), ^{ 
        [((ViewerViewController *)self.childViewControllers.lastObject).view.layer setContents:(__bridge id)image.CGImage]; 
        dispatch_semaphore_signal(self.semaphore); 
       }); 
      } 
     }); 
    }); 
} 

powodem semafory i odrębnych kolejkach GCD jest prosty: chcesz wyświetlać ramek w równych odstępach czasu. W przeciwnym razie wideo wydaje się zwalniać na początku, tuż przed przekroczeniem normalnej prędkości, aby nadrobić zaległości. Mój schemat zapewnia, że ​​każda klatka gra jedna po drugiej w tym samym tempie, niezależnie od wąskich gardeł przepustowości sieci.