big - Cómo pasar la cámara de un dispositivo con iOS a otro mediante conectividad multi-par

ionic p

Question

¿Cómo podemos transferir eficientemente la alimentación de la cámara de un dispositivo iOS a otro usando bluetooth o wifi en iOS 7? A continuación se muestra el código para obtener el buffer de vapor.

- (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);
}

aquí podemos obtener la imagen que está siendo capturada por la cámara iOS.

¿Podemos enviar información del buffer de muestra directamente a otro dispositivo usando multi pares o existe alguna forma eficiente de transmitir los datos a otros dispositivos iOS?

Gracias.

Answer 1

Tengo la manera de hacerlo. Podemos usar la conectividad multi-par para transmitir imágenes comprimidas para que se vea como la transmisión de la cámara.

Un par que va a enviar la secuencia usará este código. En el método Delegate de captura de salida:

 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];

Y en el lado de recepción:

- (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"];
}

Obtendremos el valor de FPS y, en consecuencia, podemos establecer parámetros para administrar nuestras imágenes de transmisión.

Espero que ayude

Gracias.

Answer 2

Esta es la mejor manera de hacerlo (y explico por qué al final):

En el dispositivo iOS que envía los datos de imagen:

- (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];
}
}

En el dispositivo iOS que recibe los datos de imagen:

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);
});
}
});
});
}

La razón para los semáforos y las colas separadas de GCD es simple: desea que los marcos se muestren a intervalos de tiempo iguales. De lo contrario, el video parecerá disminuir la velocidad al principio a veces, justo antes de acelerar más allá de lo normal para ponerse al día. Mi esquema garantiza que cada cuadro se reproduzca uno tras otro al mismo ritmo, independientemente de los cuellos de botella de ancho de banda de la red.