objective-c ios8 h.264 video-toolbox

objective c - Cómo usar VideoToolbox para descomprimir la transmisión de video H.264



objective-c ios8 (5)

Tuve muchos problemas para descubrir cómo usar el marco de video acelerado por hardware de Apple para descomprimir una transmisión de video H.264. Después de algunas semanas lo descubrí y quería compartir un extenso ejemplo ya que no pude encontrar uno.

Mi objetivo es dar un ejemplo completo e instructivo de Video Toolbox presentado en la sesión 513 de WWDC ''14 . Mi código no se compilará ni se ejecutará, ya que debe integrarse con una transmisión H.264 elemental (como un video leído desde un archivo o transmitido en línea, etc.) y debe ajustarse según el caso específico.

Debo mencionar que tengo muy poca experiencia con la decodificación / decodificación de video, excepto lo que aprendí mientras busqué en Google el tema. No conozco todos los detalles sobre formatos de video, estructura de parámetros, etc., así que solo he incluido lo que creo que necesitas saber.

Estoy usando XCode 6.2 y me he implementado en dispositivos iOS que ejecutan iOS 8.1 y 8.2.

Conceptos:

NALU: las NALU son simplemente una porción de datos de longitud variable que tiene un encabezado de código de inicio NALU 0x00 00 00 01 YY donde los primeros 5 bits de YY le 0x00 00 00 01 YY qué tipo de NALU es y, por lo tanto, qué tipo de datos sigue al encabezado. (Como solo necesita los primeros 5 bits, utilizo YY & 0x1F para obtener los bits relevantes). YY & 0x1F cuáles son todos estos tipos en el método NSString * const naluTypesStrings[] , pero no necesita saber cuáles son todos son.

Parámetros: su decodificador necesita parámetros para saber cómo se almacenan los datos de video H.264. Los 2 que necesita establecer son Conjunto de parámetros de secuencia (SPS) y Conjunto de parámetros de imagen (PPS) y cada uno tiene su propio número de tipo NALU. No necesita saber qué significan los parámetros, el decodificador sabe qué hacer con ellos.

Formato de transmisión H.264 : en la mayoría de las transmisiones H.264, recibirá un conjunto inicial de parámetros PPS y SPS seguidos de una trama i (también conocida como trama IDR o trama enrasada) NALU. Luego recibirá varias NALU de trama P (quizás unas pocas docenas más o menos), luego otro conjunto de parámetros (que pueden ser los mismos que los parámetros iniciales) y una trama i, más tramas P, etc. Las tramas i son mucho más grandes que P marcos. Conceptualmente, puede pensar en el cuadro i como una imagen completa del video, y los cuadros P son solo los cambios que se han realizado en ese cuadro i, hasta que reciba el siguiente cuadro i.

Procedimiento:

  1. Genere NALU individuales a partir de su transmisión H.264. No puedo mostrar el código para este paso, ya que depende mucho de la fuente de video que esté utilizando. Hice este gráfico para mostrar con qué estaba trabajando ("datos" en el gráfico es "marco" en mi siguiente código), pero su caso puede y probablemente diferirá. Mi método uint8_t *frame receivedRawVideoFrame: se llama cada vez que recibo un marco ( uint8_t *frame ) que era uno de los 2 tipos. En el diagrama, esos 2 tipos de cuadros son los 2 grandes cuadros morados.

  2. Cree un CMVideoFormatDescriptionRef a partir de sus NALU SPS y PPS con CMVideoFormatDescriptionCreateFromH264ParameterSets () . No puede mostrar ningún marco sin hacer esto primero. El SPS y el PPS pueden parecer una mezcla de números, pero VTD sabe qué hacer con ellos. Todo lo que necesita saber es que CMVideoFormatDescriptionRef es una descripción de los datos de video., Como ancho / alto, tipo de formato ( kCMPixelFormat_32BGRA , kCMVideoCodecType_H264 etc.), relación de aspecto, espacio de color, etc. Su decodificador mantendrá los parámetros hasta que llegue un nuevo conjunto. (a veces los parámetros se reenvían regularmente incluso cuando no han cambiado).

  3. Vuelva a empaquetar sus NALU de trama IDR y no IDR de acuerdo con el formato "AVCC". Esto significa eliminar los códigos de inicio de NALU y reemplazarlos con un encabezado de 4 bytes que indique la longitud de la NALU. No necesita hacer esto para las NALU de SPS y PPS. (Tenga en cuenta que el encabezado de longitud NALU de 4 bytes está en big-endian, por lo que si tiene un valor UInt32 , debe CMBlockBuffer bytes antes de copiarlo en CMBlockBuffer usando CFSwapInt32 . Hago esto en mi código con la htonl función htonl ).

  4. Empaquete las tramas IDR y NALU no IDR en CMBlockBuffer. No haga esto con las NALU de parámetros SPS PPS. Todo lo que necesita saber sobre CMBlockBuffers es que son un método para envolver bloques arbitrarios de datos en los medios principales. (Cualquier dato de video comprimido en una tubería de video está envuelto en esto).

  5. Empaquete el CMBlockBuffer en CMSampleBuffer. Todo lo que necesita saber sobre CMSampleBuffers es que envuelven nuestros CMBlockBuffers con otra información (aquí sería CMVideoFormatDescription y CMTime , si se usa CMTime ).

  6. Cree un VTDecompressionSessionRef y alimente los búferes de muestra en VTDecompressionSessionDecodeFrame (). Alternativamente, puede usar AVSampleBufferDisplayLayer y su método enqueueSampleBuffer: y no necesitará usar VTDecompSession. Es más sencillo de configurar, pero no arrojará errores si algo sale mal como lo hará VTD.

  7. En la devolución de llamada VTDecompSession, use el CVImageBufferRef resultante para mostrar el cuadro de video. Si necesita convertir su CVImageBuffer en un UIImage , vea mi respuesta de here .

Otras notas:

  • Las transmisiones H.264 pueden variar mucho. De lo que aprendí, los encabezados de código de inicio de NALU son a veces 3 bytes ( 0x00 00 01 ) y a veces 4 ( 0x00 00 00 01 ). Mi código funciona para 4 bytes; necesitará cambiar algunas cosas si está trabajando con 3.

  • Si desea saber más sobre las NALU , esta respuesta me pareció muy útil. En mi caso, descubrí que no necesitaba ignorar los bytes de "prevención de emulación" como se describe, así que personalmente omití ese paso, pero es posible que necesite saber sobre eso.

  • Si su VTDecompressionSession genera un número de error (como -12909), busque el código de error en su proyecto XCode. Busque el marco de VideoToolbox en su navegador de proyectos, ábralo y busque el encabezado VTErrors.h. Si no puede encontrarlo, también he incluido todos los códigos de error a continuación en otra respuesta.

Ejemplo de código:

Entonces, comencemos declarando algunas variables globales e incluyendo el marco VT (VT = Video Toolbox).

#import <VideoToolbox/VideoToolbox.h> @property (nonatomic, assign) CMVideoFormatDescriptionRef formatDesc; @property (nonatomic, assign) VTDecompressionSessionRef decompressionSession; @property (nonatomic, retain) AVSampleBufferDisplayLayer *videoLayer; @property (nonatomic, assign) int spsSize; @property (nonatomic, assign) int ppsSize;

La siguiente matriz solo se usa para que pueda imprimir qué tipo de trama NALU está recibiendo. Si sabe lo que significan todos estos tipos, bien por usted, sabe más sobre H.264 que yo :) Mi código solo maneja los tipos 1, 5, 7 y 8.

NSString * const naluTypesStrings[] = { @"0: Unspecified (non-VCL)", @"1: Coded slice of a non-IDR picture (VCL)", // P frame @"2: Coded slice data partition A (VCL)", @"3: Coded slice data partition B (VCL)", @"4: Coded slice data partition C (VCL)", @"5: Coded slice of an IDR picture (VCL)", // I frame @"6: Supplemental enhancement information (SEI) (non-VCL)", @"7: Sequence parameter set (non-VCL)", // SPS parameter @"8: Picture parameter set (non-VCL)", // PPS parameter @"9: Access unit delimiter (non-VCL)", @"10: End of sequence (non-VCL)", @"11: End of stream (non-VCL)", @"12: Filler data (non-VCL)", @"13: Sequence parameter set extension (non-VCL)", @"14: Prefix NAL unit (non-VCL)", @"15: Subset sequence parameter set (non-VCL)", @"16: Reserved (non-VCL)", @"17: Reserved (non-VCL)", @"18: Reserved (non-VCL)", @"19: Coded slice of an auxiliary coded picture without partitioning (non-VCL)", @"20: Coded slice extension (non-VCL)", @"21: Coded slice extension for depth view components (non-VCL)", @"22: Reserved (non-VCL)", @"23: Reserved (non-VCL)", @"24: STAP-A Single-time aggregation packet (non-VCL)", @"25: STAP-B Single-time aggregation packet (non-VCL)", @"26: MTAP16 Multi-time aggregation packet (non-VCL)", @"27: MTAP24 Multi-time aggregation packet (non-VCL)", @"28: FU-A Fragmentation unit (non-VCL)", @"29: FU-B Fragmentation unit (non-VCL)", @"30: Unspecified (non-VCL)", @"31: Unspecified (non-VCL)", };

Ahora aquí es donde sucede toda la magia.

-(void) receivedRawVideoFrame:(uint8_t *)frame withSize:(uint32_t)frameSize isIFrame:(int)isIFrame { OSStatus status; uint8_t *data = NULL; uint8_t *pps = NULL; uint8_t *sps = NULL; // I know what my H.264 data source''s NALUs look like so I know start code index is always 0. // if you don''t know where it starts, you can use a for loop similar to how i find the 2nd and 3rd start codes int startCodeIndex = 0; int secondStartCodeIndex = 0; int thirdStartCodeIndex = 0; long blockLength = 0; CMSampleBufferRef sampleBuffer = NULL; CMBlockBufferRef blockBuffer = NULL; int nalu_type = (frame[startCodeIndex + 4] & 0x1F); NSLog(@"~~~~~~~ Received NALU Type /"%@/" ~~~~~~~~", naluTypesStrings[nalu_type]); // if we havent already set up our format description with our SPS PPS parameters, we // can''t process any frames except type 7 that has our parameters if (nalu_type != 7 && _formatDesc == NULL) { NSLog(@"Video error: Frame is not an I Frame and format description is null"); return; } // NALU type 7 is the SPS parameter NALU if (nalu_type == 7) { // find where the second PPS start code begins, (the 0x00 00 00 01 code) // from which we also get the length of the first SPS code for (int i = startCodeIndex + 4; i < startCodeIndex + 40; i++) { if (frame[i] == 0x00 && frame[i+1] == 0x00 && frame[i+2] == 0x00 && frame[i+3] == 0x01) { secondStartCodeIndex = i; _spsSize = secondStartCodeIndex; // includes the header in the size break; } } // find what the second NALU type is nalu_type = (frame[secondStartCodeIndex + 4] & 0x1F); NSLog(@"~~~~~~~ Received NALU Type /"%@/" ~~~~~~~~", naluTypesStrings[nalu_type]); } // type 8 is the PPS parameter NALU if(nalu_type == 8) { // find where the NALU after this one starts so we know how long the PPS parameter is for (int i = _spsSize + 4; i < _spsSize + 30; i++) { if (frame[i] == 0x00 && frame[i+1] == 0x00 && frame[i+2] == 0x00 && frame[i+3] == 0x01) { thirdStartCodeIndex = i; _ppsSize = thirdStartCodeIndex - _spsSize; break; } } // allocate enough data to fit the SPS and PPS parameters into our data objects. // VTD doesn''t want you to include the start code header (4 bytes long) so we add the - 4 here sps = malloc(_spsSize - 4); pps = malloc(_ppsSize - 4); // copy in the actual sps and pps values, again ignoring the 4 byte header memcpy (sps, &frame[4], _spsSize-4); memcpy (pps, &frame[_spsSize+4], _ppsSize-4); // now we set our H264 parameters uint8_t* parameterSetPointers[2] = {sps, pps}; size_t parameterSetSizes[2] = {_spsSize-4, _ppsSize-4}; // suggestion from @Kris Dude''s answer below if (_formatDesc) { CFRelease(_formatDesc); _formatDesc = NULL; } status = CMVideoFormatDescriptionCreateFromH264ParameterSets(kCFAllocatorDefault, 2, (const uint8_t *const*)parameterSetPointers, parameterSetSizes, 4, &_formatDesc); NSLog(@"/t/t Creation of CMVideoFormatDescription: %@", (status == noErr) ? @"successful!" : @"failed..."); if(status != noErr) NSLog(@"/t/t Format Description ERROR type: %d", (int)status); // See if decomp session can convert from previous format description // to the new one, if not we need to remake the decomp session. // This snippet was not necessary for my applications but it could be for yours /*BOOL needNewDecompSession = (VTDecompressionSessionCanAcceptFormatDescription(_decompressionSession, _formatDesc) == NO); if(needNewDecompSession) { [self createDecompSession]; }*/ // now lets handle the IDR frame that (should) come after the parameter sets // I say "should" because that''s how I expect my H264 stream to work, YMMV nalu_type = (frame[thirdStartCodeIndex + 4] & 0x1F); NSLog(@"~~~~~~~ Received NALU Type /"%@/" ~~~~~~~~", naluTypesStrings[nalu_type]); } // create our VTDecompressionSession. This isnt neccessary if you choose to use AVSampleBufferDisplayLayer if((status == noErr) && (_decompressionSession == NULL)) { [self createDecompSession]; } // type 5 is an IDR frame NALU. The SPS and PPS NALUs should always be followed by an IDR (or IFrame) NALU, as far as I know if(nalu_type == 5) { // find the offset, or where the SPS and PPS NALUs end and the IDR frame NALU begins int offset = _spsSize + _ppsSize; blockLength = frameSize - offset; data = malloc(blockLength); data = memcpy(data, &frame[offset], blockLength); // replace the start code header on this NALU with its size. // AVCC format requires that you do this. // htonl converts the unsigned int from host to network byte order uint32_t dataLength32 = htonl (blockLength - 4); memcpy (data, &dataLength32, sizeof (uint32_t)); // create a block buffer from the IDR NALU status = CMBlockBufferCreateWithMemoryBlock(NULL, data, // memoryBlock to hold buffered data blockLength, // block length of the mem block in bytes. kCFAllocatorNull, NULL, 0, // offsetToData blockLength, // dataLength of relevant bytes, starting at offsetToData 0, &blockBuffer); NSLog(@"/t/t BlockBufferCreation: /t %@", (status == kCMBlockBufferNoErr) ? @"successful!" : @"failed..."); } // NALU type 1 is non-IDR (or PFrame) picture if (nalu_type == 1) { // non-IDR frames do not have an offset due to SPS and PSS, so the approach // is similar to the IDR frames just without the offset blockLength = frameSize; data = malloc(blockLength); data = memcpy(data, &frame[0], blockLength); // again, replace the start header with the size of the NALU uint32_t dataLength32 = htonl (blockLength - 4); memcpy (data, &dataLength32, sizeof (uint32_t)); status = CMBlockBufferCreateWithMemoryBlock(NULL, data, // memoryBlock to hold data. If NULL, block will be alloc when needed blockLength, // overall length of the mem block in bytes kCFAllocatorNull, NULL, 0, // offsetToData blockLength, // dataLength of relevant data bytes, starting at offsetToData 0, &blockBuffer); NSLog(@"/t/t BlockBufferCreation: /t %@", (status == kCMBlockBufferNoErr) ? @"successful!" : @"failed..."); } // now create our sample buffer from the block buffer, if(status == noErr) { // here I''m not bothering with any timing specifics since in my case we displayed all frames immediately const size_t sampleSize = blockLength; status = CMSampleBufferCreate(kCFAllocatorDefault, blockBuffer, true, NULL, NULL, _formatDesc, 1, 0, NULL, 1, &sampleSize, &sampleBuffer); NSLog(@"/t/t SampleBufferCreate: /t %@", (status == noErr) ? @"successful!" : @"failed..."); } if(status == noErr) { // set some values of the sample buffer''s attachments CFArrayRef attachments = CMSampleBufferGetSampleAttachmentsArray(sampleBuffer, YES); CFMutableDictionaryRef dict = (CFMutableDictionaryRef)CFArrayGetValueAtIndex(attachments, 0); CFDictionarySetValue(dict, kCMSampleAttachmentKey_DisplayImmediately, kCFBooleanTrue); // either send the samplebuffer to a VTDecompressionSession or to an AVSampleBufferDisplayLayer [self render:sampleBuffer]; } // free memory to avoid a memory leak, do the same for sps, pps and blockbuffer if (NULL != data) { free (data); data = NULL; } }

El siguiente método crea su sesión VTD. Recreala cada vez que recibas nuevos parámetros. (No tiene que volver a crearlo cada vez que recibe parámetros, está bastante seguro).

Si desea establecer atributos para el CVPixelBuffer destino, lea los valores de CoreVideo PixelBufferAttributes y colóquelos en NSDictionary *destinationImageBufferAttributes .

-(void) createDecompSession { // make sure to destroy the old VTD session _decompressionSession = NULL; VTDecompressionOutputCallbackRecord callBackRecord; callBackRecord.decompressionOutputCallback = decompressionSessionDecodeFrameCallback; // this is necessary if you need to make calls to Objective C "self" from within in the callback method. callBackRecord.decompressionOutputRefCon = (__bridge void *)self; // you can set some desired attributes for the destination pixel buffer. I didn''t use this but you may // if you need to set some attributes, be sure to uncomment the dictionary in VTDecompressionSessionCreate NSDictionary *destinationImageBufferAttributes = [NSDictionary dictionaryWithObjectsAndKeys: [NSNumber numberWithBool:YES], (id)kCVPixelBufferOpenGLESCompatibilityKey, nil]; OSStatus status = VTDecompressionSessionCreate(NULL, _formatDesc, NULL, NULL, // (__bridge CFDictionaryRef)(destinationImageBufferAttributes) &callBackRecord, &_decompressionSession); NSLog(@"Video Decompression Session Create: /t %@", (status == noErr) ? @"successful!" : @"failed..."); if(status != noErr) NSLog(@"/t/t VTD ERROR type: %d", (int)status); }

Ahora se llama a este método cada vez que VTD termina de descomprimir cualquier fotograma que le haya enviado. Este método se llama incluso si hay un error o si se cae el marco.

void decompressionSessionDecodeFrameCallback(void *decompressionOutputRefCon, void *sourceFrameRefCon, OSStatus status, VTDecodeInfoFlags infoFlags, CVImageBufferRef imageBuffer, CMTime presentationTimeStamp, CMTime presentationDuration) { THISCLASSNAME *streamManager = (__bridge THISCLASSNAME *)decompressionOutputRefCon; if (status != noErr) { NSError *error = [NSError errorWithDomain:NSOSStatusErrorDomain code:status userInfo:nil]; NSLog(@"Decompressed error: %@", error); } else { NSLog(@"Decompressed sucessfully"); // do something with your resulting CVImageBufferRef that is your decompressed frame [streamManager displayDecodedFrame:imageBuffer]; } }

Aquí es donde realmente enviamos el sampleBuffer al VTD para su decodificación.

- (void) render:(CMSampleBufferRef)sampleBuffer { VTDecodeFrameFlags flags = kVTDecodeFrame_EnableAsynchronousDecompression; VTDecodeInfoFlags flagOut; NSDate* currentTime = [NSDate date]; VTDecompressionSessionDecodeFrame(_decompressionSession, sampleBuffer, flags, (void*)CFBridgingRetain(currentTime), &flagOut); CFRelease(sampleBuffer); // if you''re using AVSampleBufferDisplayLayer, you only need to use this line of code // [videoLayer enqueueSampleBuffer:sampleBuffer]; }

Si está utilizando AVSampleBufferDisplayLayer , asegúrese de iniciar la capa de esta manera, en viewDidLoad o dentro de algún otro método de inicio.

-(void) viewDidLoad { // create our AVSampleBufferDisplayLayer and add it to the view videoLayer = [[AVSampleBufferDisplayLayer alloc] init]; videoLayer.frame = self.view.frame; videoLayer.bounds = self.view.bounds; videoLayer.videoGravity = AVLayerVideoGravityResizeAspect; // set Timebase, you may need this if you need to display frames at specific times // I didn''t need it so I haven''t verified that the timebase is working CMTimebaseRef controlTimebase; CMTimebaseCreateWithMasterClock(CFAllocatorGetDefault(), CMClockGetHostTimeClock(), &controlTimebase); //videoLayer.controlTimebase = controlTimebase; CMTimebaseSetTime(self.videoLayer.controlTimebase, kCMTimeZero); CMTimebaseSetRate(self.videoLayer.controlTimebase, 1.0); [[self.view layer] addSublayer:videoLayer]; }

@Livy para eliminar pérdidas de memoria antes de CMVideoFormatDescriptionCreateFromH264ParameterSets , debe agregar lo siguiente:

if (_formatDesc) { CFRelease(_formatDesc); _formatDesc = NULL; }

Además de los VTErrors anteriores, pensé que valía la pena agregar los errores CMFormatDescription, CMBlockBuffer, CMSampleBuffer que puede encontrar al probar el ejemplo de Livy.

kCMFormatDescriptionError_InvalidParameter = -12710, kCMFormatDescriptionError_AllocationFailed = -12711, kCMFormatDescriptionError_ValueNotAvailable = -12718, kCMBlockBufferNoErr = 0, kCMBlockBufferStructureAllocationFailedErr = -12700, kCMBlockBufferBlockAllocationFailedErr = -12701, kCMBlockBufferBadCustomBlockSourceErr = -12702, kCMBlockBufferBadOffsetParameterErr = -12703, kCMBlockBufferBadLengthParameterErr = -12704, kCMBlockBufferBadPointerParameterErr = -12705, kCMBlockBufferEmptyBBufErr = -12706, kCMBlockBufferUnallocatedBlockErr = -12707, kCMBlockBufferInsufficientSpaceErr = -12708, kCMSampleBufferError_AllocationFailed = -12730, kCMSampleBufferError_RequiredParameterMissing = -12731, kCMSampleBufferError_AlreadyHasDataBuffer = -12732, kCMSampleBufferError_BufferNotReady = -12733, kCMSampleBufferError_SampleIndexOutOfRange = -12734, kCMSampleBufferError_BufferHasNoSampleSizes = -12735, kCMSampleBufferError_BufferHasNoSampleTimingInfo = -12736, kCMSampleBufferError_ArrayTooSmall = -12737, kCMSampleBufferError_InvalidEntryCount = -12738, kCMSampleBufferError_CannotSubdivide = -12739, kCMSampleBufferError_SampleTimingInfoInvalid = -12740, kCMSampleBufferError_InvalidMediaTypeForOperation = -12741, kCMSampleBufferError_InvalidSampleData = -12742, kCMSampleBufferError_InvalidMediaFormat = -12743, kCMSampleBufferError_Invalidated = -12744, kCMSampleBufferError_DataFailed = -16750, kCMSampleBufferError_DataCanceled = -16751,

Si no puede encontrar los códigos de error VTD en el marco, decidí incluirlos aquí. (Nuevamente, todos estos errores y más se pueden encontrar dentro de VideoToolbox.framework en el navegador del proyecto, en el archivo VTErrors.h .)

Obtendrá uno de estos códigos de error en la devolución de llamada del marco de decodificación VTD o cuando cree su sesión VTD si hizo algo incorrectamente.

kVTPropertyNotSupportedErr = -12900, kVTPropertyReadOnlyErr = -12901, kVTParameterErr = -12902, kVTInvalidSessionErr = -12903, kVTAllocationFailedErr = -12904, kVTPixelTransferNotSupportedErr = -12905, // c.f. -8961 kVTCouldNotFindVideoDecoderErr = -12906, kVTCouldNotCreateInstanceErr = -12907, kVTCouldNotFindVideoEncoderErr = -12908, kVTVideoDecoderBadDataErr = -12909, // c.f. -8969 kVTVideoDecoderUnsupportedDataFormatErr = -12910, // c.f. -8970 kVTVideoDecoderMalfunctionErr = -12911, // c.f. -8960 kVTVideoEncoderMalfunctionErr = -12912, kVTVideoDecoderNotAvailableNowErr = -12913, kVTImageRotationNotSupportedErr = -12914, kVTVideoEncoderNotAvailableNowErr = -12915, kVTFormatDescriptionChangeNotSupportedErr = -12916, kVTInsufficientSourceColorDataErr = -12917, kVTCouldNotCreateColorCorrectionDataErr = -12918, kVTColorSyncTransformConvertFailedErr = -12919, kVTVideoDecoderAuthorizationErr = -12210, kVTVideoEncoderAuthorizationErr = -12211, kVTColorCorrectionPixelTransferFailedErr = -12212, kVTMultiPassStorageIdentifierMismatchErr = -12213, kVTMultiPassStorageInvalidErr = -12214, kVTFrameSiloInvalidTimeStampErr = -12215, kVTFrameSiloInvalidTimeRangeErr = -12216, kVTCouldNotFindTemporalFilterErr = -12217, kVTPixelTransferNotPermittedErr = -12218,

Un buen ejemplo de Swift de gran parte de esto se puede encontrar en la biblioteca Avios de Josh Baker: https://github.com/tidwall/Avios

Tenga en cuenta que Avios actualmente espera que el usuario maneje los datos fragmentados en los códigos de inicio NAL, pero maneja la decodificación de los datos desde ese punto en adelante.

También vale la pena echar un vistazo a la biblioteca RTMP basada en Swift HaishinKit (anteriormente "LF"), que tiene su propia implementación de decodificación, que incluye un análisis NALU más robusto: https://github.com/shogo4405/lf.swift