IOS 硬解码，一个可以解各种粘包，起始码不同的解码器文件

最新推荐文章于 2023-03-17 15:35:25 发布
最新推荐文章于 2023-03-17 15:35:25 发布
阅读量1.1k 收藏
点赞数
分类专栏： iOS硬解码 NALU粘包
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/FF_lz/article/details/104529920
版权

接触iOS硬解码是从2017上半年开始的，在接触硬解码之前都是集成各种接收数据到渲染的框架，各种坑填都填不完，就直接改用硬解码了，tcp网络码流获取方面使用的是CocoaAsyncSocket网络框架，rtsp摄像头码流获取是通过FFmpeg获取的，这里就不将代码贴出来了，需要的话评论区留言，接下来直接上摄像头h264码流图

上图:这是一段摄像头的sps ，pps，I帧粘包都一块的数据图

 

  1. //  H264Decoder.m
  2.  
  3. #import "H264Decoder.h"
  4. const uint8_t KStartCode[4] = {0, 0, 0, 1};
  5.  
  6. @implementation H264Decoder
  7.  
  8. - (instancetype)init
  9. {
  10.     if (self = [super init]) {
  11.         
  12.         sps = malloc(64);
  13.         pps = malloc(64);
  14.         first = true;
  15.         _decompressionSession = NULL;
  16.         _recordNum = 1;
  17.         
  18.     }
  19.     return self;
  20.  
  21. }
  22. - (NSLock *)theLock
  23. {
  24.     if (!_theLock) {
  25.         _theLock = [[NSLock alloc] init];
  26.     }
  27.     return _theLock;
  28. }
  29.  
  30.  
  31. -(void)decodeFrame:(uint8_t *)frame withSize:(uint32_t)frameSize
  32. {
  33.     //NSData *datas = [NSData dataWithBytes:frame length:frameSize];
  34.     
  35.     if(frameSize <= 0){
  36.         return;
  37.     }
  38.  
  39. //    FILE* fp = fopen("/Users/ff/Desktop/h264.h264","ab+");
  40. //    if(fp != NULL)
  41. //    {
  42. //        NSLog(@"写数据");
  43. //        fwrite(frame, 1, frameSize, fp);
  44. //        fclose(fp);
  45. //    }
  46.     
  47.     int readCount = 0;
  48.     int count=0,len=0;
  49.     char oldValue=0x00;
  50.     
  51. //    _cellTag = tag;
  52.     OSStatus status = 0;
  53.     
  54.     uint8_t *data = NULL;
  55.     
  56.     int startCodeIndex = 0;
  57.     long blockLength = 0;
  58.     
  59.     int IDRStastus = 0;
  60.     //解码前
  61.     CMSampleBufferRef sampleBuffer = NULL;
  62.     //解码后
  63.     CMBlockBufferRef blockBuffer = NULL;
  64.     
  65.     //
  66.  
  67.     int nalu_types = (frame[startCodeIndex + 4] & 0x1F);
  68.     
  69.     if(nalu_types != 1){
  70.         do{//处理粘包数据
  71.             char value=frame[readCount];
  72.             //NSLog(@"value %02u",value);
  73.             readCount++;
  74.             //printf("read data buf value %u \n",value);
  75.             if(value==0x00 || value==0x01||readCount==frameSize){
  76.                 if(readCount==frameSize){
  77.                     sendBuf[len++]=value;
  78.                 }
  79.                 
  80.                 if((count==3&&value==0x01)||readCount==frameSize){
  81.                     if(len>4||readCount==frameSize){
  82.                         {
  83.                             nalu_types = (sendBuf[4]&0x1F);
  84.                             int length=len-3;
  85.                             
  86.                             if(readCount==frameSize){
  87.                                 length=len;
  88.                             }
  89.                             
  90.                             //NSLog(@"当前下标---%ld-----数据类型%d",tag,nalu_types);
  91.                             if(nalu_types==7){
  92.                                 if(_recordNum == 1 && sps != NULL){
  93.                                     _spsSize =  length-4;
  94.                                     memcpy(sps, &sendBuf[4], _spsSize);
  95.                                 }
  96.                             }else if(nalu_types==8){
  97.                                 
  98.                                 if(_recordNum == 1 && pps != NULL){
  99.                                     _ppsSize =  length-4;
  100.                                     memcpy(pps, &sendBuf[4], _ppsSize);
  101.                                     //first &&
  102.                                     if( _spsSize > 0 && _ppsSize > 0)
  103.                                     {
  104.                                         uint8_t*  parameterSetPointers[2] = {sps, pps};
  105.                                         size_t parameterSetSizes[2] = {_spsSize, _ppsSize};
  106.                                         status = CMVideoFormatDescriptionCreateFromH264ParameterSets(kCFAllocatorDefault, 2,
  107.                                                                                                      (const uint8_t *const*)
  108.                                                                                                      parameterSetPointers,
  109.                                                                                                      parameterSetSizes, 4,
  110.                                                                                                      &_formatDesc);
  111.                                         
  112.                                         
  113.                                         if((status == noErr) && (_decompressionSession == NULL))
  114.                                         {
  115.                                             [self createDecompSession];
  116.                                         }
  117.                                         first = false;
  118.                                         
  119.                                     }
  120.                                     _recordNum = 2;
  121.                                 }
  122.                             }else if(nalu_types==6){
  123.                                 
  124.                             }else if(nalu_types==5){
  125.                                 IDRStastus = 1;
  126.                                 blockLength = length;
  127.                                 data = malloc(blockLength);
  128.                                 data = memcpy(data, &sendBuf[0], blockLength);
  129.                                 
  130.                                 uint32_t dataLength32 = htonl (blockLength-4);
  131.                                 memcpy (data, &dataLength32, sizeof (uint32_t));
  132.                                 
  133. //                                NSData *datas = [NSData dataWithBytes:data length:blockLength];
  134. //                                NSLog(@"1----%@",datas);
  135.                                 //2020-02-26 10:29:45.017755+0800 FFMediaDemo[2132:1825923] {length = 1251, bytes = 0x000004df 25b82002 bff62e31 21ce2800 ... 891ecdad 935bbe9f }----
  136.                                 status = CMBlockBufferCreateWithMemoryBlock(NULL, data,
  137.                                                                             blockLength,
  138.                                                                             kCFAllocatorNull, NULL,
  139.                                                                             0,
  140.                                                                             blockLength,
  141.                                                                             0, &blockBuffer);
  142.                                 
  143.                                 
  144.                                 if(status != kCMBlockBufferNoErr){
  145.                                     NSLog(@"\t\t BlockBufferCreation: \t %@", (status == kCMBlockBufferNoErr) ? @"successful!" : @"failed...");
  146.                                     return;
  147.                                 }
  148.                                 
  149.                             }else if(nalu_types==1){
  150.                                 blockLength = length;
  151.                                 data = malloc(blockLength);
  152.                                 data = memcpy(data, &sendBuf[0], blockLength);
  153.                                 
  154.                                 uint32_t dataLength32 = htonl (blockLength-4);
  155.                                 memcpy (data, &dataLength32, sizeof (uint32_t));
  156.                                 
  157.                                 status = CMBlockBufferCreateWithMemoryBlock(NULL, data,
  158.                                                                             blockLength,
  159.                                                                             kCFAllocatorNull, NULL,
  160.                                                                             0,
  161.                                                                             blockLength,
  162.                                                                             0, &blockBuffer);
  163.                                 
  164.                             }else if(nalu_types==9){
  165.                                 
  166.                             }
  167.                             if(readCount!=frameSize){
  168.                                 int nextNalu_types = (frame[readCount]&0x1F);
  169.                                 if(nextNalu_types == 5){
  170.                                     nalu_types = nextNalu_types;
  171.                                     break;
  172.                                 }
  173.                                 if(nextNalu_types == 1){
  174.                                     nalu_types = nextNalu_types;
  175.                                     break;
  176.                                 }
  177.                                 
  178.                             }
  179.                         }
  180.                         len=3;
  181.                         sendBuf[0]=0x00;
  182.                         sendBuf[1]=0x00;
  183.                         sendBuf[2]=0x00;
  184.                     }
  185.                     count=0;
  186.                 }else{
  187.                     if(value==0x00 && oldValue==0x00){
  188.                         count++;
  189.                         if(count>3){
  190.                             count-=1;
  191.                         }
  192.                     }else{
  193.                         if(value==0x00){
  194.                             count=1;
  195.                         }else{
  196.                             count=0;
  197.                         }
  198.                     }
  199.                 }
  200.             }
  201.             sendBuf[len]=value;
  202.             oldValue=value;
  203.             len++;
  204.         }while(readCount<frameSize);
  205.     }
  206.     
  207.  
  208.     if(nalu_types == 5 && IDRStastus != 1){
  209.  
  210.         //NSLog(@"当前帧类型：%d-----下一帧类型",nalu_types);
  211.         blockLength = frameSize-(readCount-4);
  212.         data = malloc(blockLength);
  213.         memcpy(data, &frame[readCount-4], blockLength);
  214.  
  215.         uint32_t dataLength32 = htonl (blockLength-4);
  216.         memcpy (data, &dataLength32, sizeof (uint32_t));
  217.  
  218. //        NSData *datas = [NSData dataWithBytes:data length:blockLength];
  219. //        NSLog(@"2----%@",datas);
  220.  
  221.         status = CMBlockBufferCreateWithMemoryBlock(NULL, data,
  222.                                                     blockLength,
  223.                                                     kCFAllocatorNull, NULL,
  224.                                                     0,
  225.                                                     blockLength,
  226.                                                     0, &blockBuffer);
  227.  
  228.     }
  229.     if(nalu_types == 1){
  230.         blockLength = frameSize-(readCount-4);
  231.         data = malloc(blockLength);
  232.         if(data == NULL)return;
  233.         int newRC = readCount-4;
  234.         if(newRC <= 0){
  235.             newRC = 0;
  236.         }
  237.         memcpy(data, &frame[newRC], blockLength);
  238.         
  239.         uint32_t dataLength32 = htonl (blockLength-4);
  240.         memcpy (data, &dataLength32, sizeof (uint32_t));
  241.         
  242.         status = CMBlockBufferCreateWithMemoryBlock(NULL, data,
  243.                                                     blockLength,
  244.                                                     kCFAllocatorNull, NULL,
  245.                                                     0,
  246.                                                     blockLength,
  247.                                                     0, &blockBuffer);
  248.         
  249.         
  250.     }
  251.  
  252.     if(status == kCMBlockBufferNoErr)
  253.     {
  254.  
  255.         status = CMSampleBufferCreate(NULL,
  256.                                       blockBuffer,
  257.                                       TRUE, 0, 0,
  258.                                       _formatDesc,
  259.                                       1, 0, NULL, 0,
  260.                                       NULL, &sampleBuffer);
  261.         
  262.     }
  263.     if(status == kCMBlockBufferNoErr)
  264.     {
  265.         [self.theLock lock];
  266.         [self render:sampleBuffer];
  267.         [self.theLock unlock];
  268.     }
  269.     
  270.     if (NULL != blockBuffer) {
  271.         CFRelease(blockBuffer);
  272.         blockBuffer = NULL;
  273.     }
  274.  
  275.     if (NULL != sampleBuffer) {
  276.         CFRelease(sampleBuffer);
  277.         sampleBuffer = NULL;
  278.     }
  279.  
  280.     [self relaseData:data];
  281.  
  282. }
  283.  
  284. -(void)relaseData:(uint8_t*) tmpData{
  285.     
  286.     if (NULL != tmpData)
  287.     {
  288.         free (tmpData);
  289.         tmpData = NULL;
  290.     }
  291. }
  292.  
  293. -(void) createDecompSession
  294. {
  295.  
  296.     if(_decompressionSession) {
  297.         VTDecompressionSessionWaitForAsynchronousFrames(_decompressionSession);
  298.         VTDecompressionSessionInvalidate(_decompressionSession);
  299.         CFRelease(_decompressionSession);
  300.         _decompressionSession = NULL;
  301.     }
  302.  
  303.     VTDecompressionOutputCallbackRecord callBackRecord;
  304.     callBackRecord.decompressionOutputCallback = decompressionSessionDecodeFrameCallback;
  305.     
  306.     callBackRecord.decompressionOutputRefCon = (__bridge void *)self;
  307.     
  308.     CMVideoDimensions dimensions = CMVideoFormatDescriptionGetDimensions(_formatDesc);
  309.     uint32_t width = dimensions.width;
  310.     uint32_t height = dimensions.height;
  311.     
  312.     NSDictionary* destinationPixelBufferAttributes = @{
  313.                                                        (id)kCVPixelBufferPixelFormatTypeKey : [NSNumber numberWithInt:kCVPixelFormatType_420YpCbCr8BiPlanarFullRange],
  314.                                                        //硬解必须是 kCVPixelFormatType_420YpCbCr8BiPlanarVideoRange
  315.                                                        //或者是kCVPixelFormatType_420YpCbCr8Planar
  316.                                                        //因为iOS是  nv12  其他是nv21
  317.                                                        (id)kCVPixelBufferWidthKey : [NSNumber numberWithInt:width],
  318.                                                        (id)kCVPixelBufferHeightKey : [NSNumber numberWithInt:height],
  319.                                                        //这里宽高和编码反的
  320.                                                        (id)kCVPixelBufferOpenGLCompatibilityKey : [NSNumber numberWithBool:YES]
  321.                                                        , (id)kCVPixelBufferOpenGLESCompatibilityKey : [NSNumber numberWithBool:YES]
  322.                                                        };
  323.     
  324.  
  325.     OSStatus status = VTDecompressionSessionCreate(kCFAllocatorDefault,
  326.                                  _formatDesc,
  327.                                  NULL,
  328.                                  (__bridge CFDictionaryRef _Nullable)(destinationPixelBufferAttributes),
  329.                                  &callBackRecord,
  330.                                  &_decompressionSession);
  331.     
  332. //    NSLog(@"SessionStatus---%d-----%ld",status,_cellTag);
  333.     VTSessionSetProperty(_decompressionSession, kVTDecompressionPropertyKey_ThreadCount, (__bridge CFTypeRef)[NSNumber numberWithInt:1]);
  334.     VTSessionSetProperty(_decompressionSession, kVTDecompressionPropertyKey_RealTime, kCFBooleanTrue);
  335. }
  336.  
  337. void decompressionSessionDecodeFrameCallback(void *decompressionOutputRefCon,
  338.                                              void *sourceFrameRefCon,
  339.                                              OSStatus status,
  340.                                              VTDecodeInfoFlags infoFlags,
  341.                                              CVPixelBufferRef pixelBufferRef,
  342.                                              CMTime presentationTimeStamp,
  343.                                              CMTime presentationDuration)
  344. {
  345.     
  346. //    NSLog(@"当前下标---%ld",weakSelf.cellTag);
  347.     if (status != noErr || !pixelBufferRef) {
  348.         NSLog(@"Error decompresssing frame at time: %.3f error: %d infoFlags: %u", (float)presentationTimeStamp.value/presentationTimeStamp.timescale, (int)status, (unsigned int)infoFlags);
  349.         return;
  350.     }
  351.     __weak H264Decoder *weakSelf = (__bridge H264Decoder *)decompressionOutputRefCon;
  352.     if(weakSelf.delegate && [weakSelf.delegate respondsToSelector:@selector(displayDecodedFrame:cellTag:)]){
  353.         [weakSelf.delegate displayDecodedFrame:pixelBufferRef];
  354.     }
  355.     
  356. //    [weakSelf pixelBufferRefTransformationSampleBufferRef:pixelBufferRef weakSelf:weakSelf cellTag:weakSelf.cellTag];
  357. //    [weakSelf.delegate getDecodeImageData:pixelBufferRef cellTag:weakSelf.cellTag];
  358. //    if (NULL != pixelBufferRef) {
  359. //        CVPixelBufferRelease(pixelBufferRef);
  360. //        pixelBufferRef = NULL;
  361. //    }
  362.     
  363. }
  364.  
  365. - (void)pixelBufferRefTransformationSampleBufferRef:(CVPixelBufferRef)pixelBufferRef weakSelf:(H264Decoder *)weakSelf cellTag:(NSInteger)tag
  366. {
  367.     //不设置具体时间信息
  368.     CMSampleTimingInfo timing = {kCMTimeInvalid, kCMTimeInvalid, kCMTimeInvalid};
  369.     //获取视频信息
  370.     CMVideoFormatDescriptionRef videoInfo = NULL;
  371.     CMVideoFormatDescriptionCreateForImageBuffer(NULL, pixelBufferRef, &videoInfo);
  372.     NSParameterAssert(videoInfo != NULL);
  373.     CMSampleBufferRef sampleBuffer = NULL;
  374.     CMSampleBufferCreateForImageBuffer(kCFAllocatorDefault,pixelBufferRef, true, NULL, NULL, videoInfo, &timing, &sampleBuffer);
  375.     NSParameterAssert(sampleBuffer != NULL);
  376.     CFRelease(videoInfo);
  377.     CFArrayRef attachments = CMSampleBufferGetSampleAttachmentsArray(sampleBuffer, YES);
  378.     CFMutableDictionaryRef dict = (CFMutableDictionaryRef)CFArrayGetValueAtIndex(attachments, 0);
  379.     CFDictionarySetValue(dict, kCMSampleAttachmentKey_DisplayImmediately, kCFBooleanTrue);
  380.     if(weakSelf.delegate && [weakSelf.delegate respondsToSelector:@selector(getDecodeImageData:cellTag:)]){
  381.       [weakSelf.delegate getDecodeImageData:sampleBuffer];
  382.     }
  383.     if (NULL != sampleBuffer) {
  384.         CFRelease(sampleBuffer);
  385.         sampleBuffer = NULL;
  386.     }
  387. }
  388.  
  389.  
  390.  
  391. - (void) render:(CMSampleBufferRef)sampleBuffer
  392. {
  393.     if(_decompressionSession){
  394.         VTDecodeFrameFlags flags = kVTDecodeFrame_EnableAsynchronousDecompression;
  395.         VTDecodeInfoFlags flagOut;
  396.         OSStatus decodeStatus;
  397.         {
  398.              decodeStatus = VTDecompressionSessionDecodeFrame(_decompressionSession, sampleBuffer, flags,
  399.                                                                       &sampleBuffer, &flagOut);
  400.         }
  401.         
  402.         if(decodeStatus == noErr){
  403.         }else if(decodeStatus == kVTInvalidSessionErr) {
  404.             //        NSLog(@"IOS8VT: Invalid session, reset decoder session");
  405.             [self resetH264Decoder];
  406.         } else if(decodeStatus == kVTParameterErr) {
  407.             //[self resetH264Decoder];
  408.             //        NSLog(@"IOS8VT: decode failed status=%d(Bad data)", decodeStatus);
  409.         } else if(decodeStatus == kVTVideoDecoderBadDataErr) {
  410.             //        NSLog(@"IOS8VT: decode failed status=%d(Bad data)", decodeStatus);
  411.         } else if(decodeStatus != noErr) {
  412.             //        NSLog(@"IOS8VT: decode failed status=%d", decodeStatus);
  413.         } else if (decodeStatus == kVTVideoDecoderMalfunctionErr){
  414.         }
  415.     }
  416. }
  417.  
  418. - (void)resetH264Decoder
  419. {
  420.     if(_decompressionSession) {
  421. //        if(_decompressionSession != nil){
  422. //            VTDecompressionSessionWaitForAsynchronousFrames(_decompressionSession);
  423. //            VTDecompressionSessionInvalidate(_decompressionSession);
  424. //            CFRelease(_decompressionSession);
  425. //        }
  426.         _decompressionSession = NULL;
  427.     }
  428.     NSDictionary* destinationPixelBufferAttributes = @{
  429.                                                        (id)kCVPixelBufferPixelFormatTypeKey : [NSNumber numberWithInt:kCVPixelFormatType_420YpCbCr8BiPlanarFullRange],
  430.                                                        //硬解必须是 kCVPixelFormatType_420YpCbCr8BiPlanarVideoRange
  431.                                                        //                                                           或者是kCVPixelFormatType_420YpCbCr8Planar
  432.                                                        //因为iOS是  nv12  其他是nv21
  433.                                                        (id)kCVPixelBufferWidthKey : [NSNumber numberWithInt:h264outputWidth],
  434.                                                        (id)kCVPixelBufferHeightKey : [NSNumber numberWithInt:h264outputHeight],
  435.                                                        //这里款高和编码反的
  436.                                                        (id)kCVPixelBufferOpenGLCompatibilityKey : [NSNumber numberWithBool:YES]
  437.                                                        };
  438.     
  439.     VTDecompressionOutputCallbackRecord callBackRecord;
  440.     callBackRecord.decompressionOutputCallback = decompressionSessionDecodeFrameCallback;
  441.     callBackRecord.decompressionOutputRefCon =(__bridge void *)self;;
  442.     
  443.     VTDecompressionSessionCreate(kCFAllocatorSystemDefault,
  444.                                                    _formatDesc,
  445.                                                    NULL, (__bridge CFDictionaryRef _Nullable)(destinationPixelBufferAttributes),
  446.                                                    &callBackRecord,
  447.                                                    &_decompressionSession);
  448. }
  449.  
  450. - (void)clearH264Deocder:(dispatch_queue_t)queue{
  451.     [self.theLock lock];
  452.     dispatch_time_t delayTime = dispatch_time(DISPATCH_TIME_NOW, (int64_t)(0.5/*延迟执行时间*/ * NSEC_PER_SEC));
  453.     dispatch_after(delayTime, queue, ^{
  454.         
  455.         if(_decompressionSession){
  456.             VTDecompressionSessionInvalidate(_decompressionSession);
  457.             CFRelease(_decompressionSession);
  458.             _decompressionSession = NULL;
  459.         }
  460.  
  461.         if (_formatDesc) {
  462.             CFRelease(_formatDesc);
  463.             _formatDesc = NULL;
  464.         }
  465.         if (sps != NULL) {
  466.             free(sps);
  467.             sps = NULL;
  468.             _spsSize = 0;
  469.         }
  470.  
  471.         if (pps != NULL) {
  472.             free(pps);
  473.             pps = NULL;
  474.             _ppsSize = 0;
  475.         }
  476.         
  477.     });
  478.     [self.theLock unlock];
  479.  
  480. }
  481.  
  482.  
  483. NSString * const naluTypesStrings[] =
  484. {
  485.     @"0: Unspecified (non-VCL)",
  486.     @"1: Coded slice of a non-IDR picture (VCL)",    // P frame
  487.     @"2: Coded slice data partition A (VCL)",
  488.     @"3: Coded slice data partition B (VCL)",
  489.     @"4: Coded slice data partition C (VCL)",
  490.     @"5: Coded slice of an IDR picture (VCL)",      // I frame
  491.     @"6: Supplemental enhancement information (SEI) (non-VCL)",
  492.     @"7: Sequence parameter set (non-VCL)",         // SPS parameter
  493.     @"8: Picture parameter set (non-VCL)",          // PPS parameter
  494.     @"9: Access unit delimiter (non-VCL)",
  495.     @"10: End of sequence (non-VCL)",
  496.     @"11: End of stream (non-VCL)",
  497.     @"12: Filler data (non-VCL)",
  498.     @"13: Sequence parameter set extension (non-VCL)",
  499.     @"14: Prefix NAL unit (non-VCL)",
  500.     @"15: Subset sequence parameter set (non-VCL)",
  501.     @"16: Reserved (non-VCL)",
  502.     @"17: Reserved (non-VCL)",
  503.     @"18: Reserved (non-VCL)",
  504.     @"19: Coded slice of an auxiliary coded picture without partitioning (non-VCL)",
  505.     @"20: Coded slice extension (non-VCL)",
  506.     @"21: Coded slice extension for depth view components (non-VCL)",
  507.     @"22: Reserved (non-VCL)",
  508.     @"23: Reserved (non-VCL)",
  509.     @"24: STAP-A Single-time aggregation packet (non-VCL)",
  510.     @"25: STAP-B Single-time aggregation packet (non-VCL)",
  511.     @"26: MTAP16 Multi-time aggregation packet (non-VCL)",
  512.     @"27: MTAP24 Multi-time aggregation packet (non-VCL)",
  513.     @"28: FU-A Fragmentation unit (non-VCL)",
  514.     @"29: FU-B Fragmentation unit (non-VCL)",
  515.     @"30: Unspecified (non-VCL)",
  516.     @"31: Unspecified (non-VCL)",
  517. };
  518. @end

从传入数据到分包在到初始化解码，配置解码参数，解码完成回调都在上述代码中，

F小志
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
H264学习
weixin_30475039的博客
10-16 191
最近在给MP4文件做CENC加密时需要解析H264的slice头部，才发现对于H264的一些基本概念没有搞清楚。小小的记录一下： 1. 如何判断一个H264的帧类型。帧类型包括IDR/I/P/B. 看一下标准的描述： nal_unit( NumBytesInNALunit ){ 　　forbidden_zero_bit All 　　　　　　　　　　　　　　　　　　　　　...
h.264语法结构分析
weixin_34191845的博客
02-24 241
NAL Unit Stream Network Abstraction Layer，简称NAL。 h.264把原始的yuv文件编码成码流文件，生成的码流文件就是NAL单元流（NAL unit Stream）。而NAL单元流，就是NAL单元组成的。 标准的Annex B规定了NAL单元组成NAL单元流的方式，下面描述了如何将一个NAL单元打包起来，而多个NAL单元进行组合则形成了NAL单元流。...
H.264流媒体协议格式中的Annex B格式和AVCC格式深度解析
热门推荐
Romantic_Energy的专栏
01-13 2万+
本文需要读者对H.264流有一定的了解才可以理解2种格式差异。          首先要理解的是没有标准的H.264基本流格式。文档中的确包含了一个Annex，特别是描述了一种可能的格式Annex B格式，但是这个并不是一个必须要求的格式。标准文档中指定了视频怎样编码成独立的包，但是这些包是怎样存储和传输的却是开放的。 一. Annex B A.Network Abstractio
iOS8系统H264视频硬件编解码说明
lolo0737的博客
03-11 755
转载出处:http://www.tallmantech.com/archives/206#more-206 公司项目原因，接触了一下视频流H264的编解码知识，之前项目使用的是FFMpeg多媒体库，利用CPU做视频的编码和解码，俗称为软编软解。该方法比较通用，但是占用CPU资源，编解码效率不高。一般系统都会提供GPU或者专用处理器来对视频流进行编解码，也就是硬件编码和解码，简称为硬编解码
SpringCloud（31）—— EnableAsync使用技巧
weixin_30951389的博客
09-09 376
SpringBoot项目中，有时候我们发现使用EnableAsync进行异步调用没有作用。 分析原因： 1. 异步方法使用@Async，没有确定：返回值为Void或Future 2. 异步方法和调用方法写在了同一类中，如果写在同一类中是没有效果的。 实现EnableAsync进行异步调用两种方式： 1.SpringBootApplication 启动类上，增加Enab...
netty消息拆包粘包编解码(java代码)
最新发布
10-22
Netty 是一个高性能、异步事件驱动的网络...在实际应用中，还可以结合其他编码解码器，如`DelimiterBasedFrameDecoder`（基于分隔符的解码器）或`LineBasedFrameDecoder`（基于换行符的解码器），以满足不同的需求。
netty编码器，解码器实例
12-07
同时，我们可以创建一个继承自 ByteToMessageDecoder 的解码器，从接收的字节缓冲区中读取数据并构造出消息对象。 以下是一个简单的编码器和解码器实例： ```java // 自定义消息类 public class CustomMessage { ...
IOS 详解socket编程[oc]粘包、半包处理
08-31
粘包是指多个数据包在接收时被合并成一个大的数据包，而半包则是指数据包没有完全接收，导致部分数据丢失。理解并解决这两个问题对于正确解析网络传输的数据至关重要。 首先，我们要了解TCP协议的特点。TCP是一种...
socket tcp如何防止多次send的包被合成一个包(粘包)发送.zip
01-18
在TCP/IP通信中，"粘包"问题是一个常见的现象，特别是在使用socket编程时。当多个小数据包在传输过程中被合并成一个大包发送，我们就说发生了“粘包”。这通常发生在TCP协议中，因为TCP为了提高网络效率，采用了...
iOS自定义相机/参数调节/视频速率调节/视频合并
weixin_34210740的博客
10-10 932
2019独角兽企业重金招聘Python工程师标准>>> ...
iOS系统中H264硬解及显示详解
WificamSDK7的专栏
05-05 9887
iOS系统中H264硬解及显示说明iOS系统中H264硬解及显示说明苹果在iOS 8.0系统之前，没有开放系统的硬件编码解码功能，不过Mac OS系统一直有，被称为Video ToolBox的框架来处理硬件的编码和解码，终于在iOS 8.0后，苹果将该框架引入iOS系统。 一、VideoToolbox基本数据结构：1、CVPixelBuffer：编码前和解码后的图像数据结构；2、CMTime、CMC
H264 demux后AVPacket送去decode时出错
jzlhll123的专栏
01-12 3020
文章目录背景心路历程第一步 复现第二步 深入代码逻辑第三步 上网第四步 尝试结论附录 H264 小白基础知识简述NALU格式两种封装格式1. annex-B格式2. avcC格式主要关注的二进制 本人刚刚接触多媒体开发。最近遇到一个棘手的问题，某些MP4文件无法在我们的系统（类linux）上播放。 今天写下解决心路历程。代码上以伪代码为主，毕竟公司代码不好直接复制。 等不及看结论的朋友。请直接到文...
iOS音视频开发，VideoToolBox H264视频硬解码
m0_60259116的博客
05-27 2423
VideoToolBox 2014年的WWDC大会,苹果发布iOS 8.0,开放了硬编解码的API，也就是VideoToolBox VideoToolbox 一个底层视频硬编解码框架，纯C语言API，可直接访问硬件的编解码器。提供性能极高的硬编硬解，同时也提供存储在 CoreVideo 像素缓冲区的图像进行格式的转换。 这篇文章记录基于VideoToolBox封装一个H264硬解码视频的工具 硬解码优点 速度快，降低解码时间 功耗大幅降低，降低使用App时的电量消耗 Vid
iOS AVDemo（7）：视频采集
irainsa的博客
03-17 475
iOS/Android 客户端开发同学如果想要开始学习音视频开发，最丝滑的方式是对有一定了解后，再借助 iOS/Android 平台的音视频能力上手去实践音视频的过程，并借助来分析和理解对应的音视频数据。在这个栏目，我们将通过拆解流程并实现 Demo 来向大家介绍如何在 iOS/Android 平台上手音视频开发。。这个 Demo 里包含以下内容：1）实现一个视频采集模块；2）实现视频采集逻辑并将采集的视频图像渲染进行预览，同时支持将数据转换为图片存储到相册；
iOS硬解码H264，创建VTDecompressionSessionRef时，返回 -12913
sure453361860的专栏
11-30 1762
status = VTDecompressionSessionCreate(kCFAllocatorDefault,                                               _decoderFormatDescription,                                               NULL, attrs,
如何在iOS平台上实现视频硬解码？
魔都凯凯的专栏
11-05 7839
在iOS平台上做视频的解码，一般有三种方案： 1、软解码方案：ffmpeg 缺点：消耗CPU太大，一般720P 20帧以上就解不动了 2、硬解码方案：采用私有接口VideoToolBox 优点：CPU消耗极低，解码效率极高 缺点：使用私有接口VideoToolBox，iOS设备必须越狱 3、硬解码方案：采用AVPlayer＋httpserver＋HttpLiveStream的组合方案
iOS（swift）：CVPixelBuffer图像格式转换成CMSampleBuffer
qq26983255的博客
04-23 6838
手机上可以通过imageView作为图像的载体对一副图像进行显示。另一方面，在iOS端图像处理中，可以通过GPU对图像进行处理和渲染，并且通过metal框架，可以将处理后的图像直接显示在MTKView上。但是如果不做复杂的处理或者更加有利于将处理后的图像与MTKView更好的解耦，如何将图像进行显示了呢？一方面我们可以将CVpixelbuffer的图像数据个是转换成UIImage，另一...
音视频学习之 - H264解码
weixin_30832983的博客
08-07 297
解码流程 解析数据 （SPS PPS NALU Unit） 初始化解码器 将解析后的H264 NALU Unit输入到解码器 解码完成后回调，输出解码数据 解码数据显示（OpenGL ES） 解析数据 直接在上一篇音视频学习之 - H264编码代码基础上微调进行解码，即在生成sps/pps和视频流二进制的地方不去存储而是直接进行解码,修改上一篇源码中 函数didCompressH264 的代...
iOS音视频开发七：视频采集
m0_60259116的博客
05-16 917
将通过拆解采集 → 编码 → 封装 → 解封装 → 解码 → 渲染流程并实现 Demo 来向大家介绍如何在 iOS/Android 平台上手音视频开发。 这里是第七篇：iOS 视频采集 Demo。这个 Demo 里包含以下内容： 1）实现一个视频采集模块； 2）实现视频采集逻辑并将采集的视频图像渲染进行预览，同时支持将数据转换为图片存储到相册； 3）详尽的代码注释，帮你理解代码逻辑和原理。 前六篇： iOS要开发，采集音频并存储为 PCM 文件 ​​​​​​iOS音视频开
c#tcplistener 写一个可以处理粘包的服务器
05-30
当客户端发送的数据包长度大于 TcpListener 接收缓冲区的大小时，就会发生粘包问题，这时需要服务器端进行处理。下面是一个可以处理粘包的 C# TcpListener 服务器示例代码： ```csharp using System; using System.Net; using System.Net.Sockets; using System.Text; class TcpServer { static void Main(string[] args) { try { // 创建一个 TcpListener 对象 TcpListener listener = new TcpListener(IPAddress.Any, 8080); // 开始监听 listener.Start(); Console.WriteLine("Waiting for connection..."); while (true) { // 接受客户端连接 TcpClient client = listener.AcceptTcpClient(); Console.WriteLine("Client connected!"); // 获取客户端的网络流 NetworkStream stream = client.GetStream(); // 接收客户端发送的数据 byte[] buffer = new byte[1024]; int totalLength = 0; int bytesRead = 0; while (true) { // 读取数据 bytesRead = stream.Read(buffer, totalLength, buffer.Length - totalLength); totalLength += bytesRead; // 判断数据是否接收完毕 if (bytesRead == 0) { break; } else if (stream.DataAvailable) { continue; } else if (totalLength >= 4) { int dataLength = BitConverter.ToInt32(buffer, 0); if (totalLength - 4 == dataLength) { // 接收到一个完整的数据包 string data = Encoding.ASCII.GetString(buffer, 4, dataLength); Console.WriteLine("Received: {0}", data); // 发送响应数据给客户端 byte[] response = Encoding.ASCII.GetBytes("Hello from server!"); stream.Write(response, 0, response.Length); break; } else if (totalLength - 4 > dataLength) { // 接收到多个数据包 int offset = 4; while (totalLength - offset >= 4) { dataLength = BitConverter.ToInt32(buffer, offset); if (totalLength - offset - 4 >= dataLength) { // 接收到一个完整的数据包 string data = Encoding.ASCII.GetString(buffer, offset + 4, dataLength); Console.WriteLine("Received: {0}", data); // 发送响应数据给客户端 byte[] response = Encoding.ASCII.GetBytes("Hello from server!"); stream.Write(response, 0, response.Length); offset += dataLength + 4; } else { // 数据包不完整，继续接收 break; } } // 移动数据到缓冲区的开头 totalLength -= offset; if (totalLength > 0) { Array.Copy(buffer, offset, buffer, 0, totalLength); } } } } // 关闭连接 client.Close(); Console.WriteLine("Client disconnected."); } } catch (Exception ex) { Console.WriteLine(ex.Message); } } } ``` 该服务器使用一个循环来接收客户端发送的数据，它会不断读取数据，直到接收到一个完整的数据包。如果接收到的数据包长度大于 TcpListener 接收缓冲区的大小，它会将多个数据包拼接成一个完整的数据包。接收到完整的数据包后，它会发送响应数据给客户端，并关闭连接。
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值