ios 硬解码h264视频的坑

最新推荐文章于 2024-08-04 22:20:34 发布
最新推荐文章于 2024-08-04 22:20:34 发布
阅读量5.8k 收藏 3
点赞数
分类专栏： iOS直播技术 iOS视频 文章标签： h264 视频 ios

最近这两天在写一个ios demo，用 VideoToolBox 硬解码从网络上实时接收过来的原始h264 nalu 数据（裸数据）。

网络裸数据如下：



后面的原始数据帧类似以上。。。

（1）开始用了一个正常思路的方式：
循环获取原始数据 -----> 分割大包中的nalu并单个送入硬解码 (nalu的前四个字节需要做调整：
由00 00 00 01 变为大端的 nalu 的长度(不包括头四个字节))

发现一个奇异现象：在模拟器中基本可以正常显示，偶尔有点水波现象，但是基本是正常的，不影响观看，然后部署到真机（iphone6－ios 9.3）中，出现绿屏或者出现一半正常显示一半出现绿屏。

大致代码如下：

/** Find the beginning and end of a NAL (Network Abstraction Layer) unit in 
a byte buffer containing H264 bitstream data. 
@param[in]   buf        the buffer 
@param[in]   size       the size of the buffer 
@param[out]  nal_start  the beginning offset of the nal 
@param[out]  nal_end    the end offset of the nal 
@return                 the length of the nal, or 0 if did not find start of nal, or -1 if did not find end of nal */
static int findNalUnit(uint8_t* buf, int size, int* nal_start, int* nal_end)
{
    int i;
    // find start
    *nal_start = 0;
    *nal_end = 0;
    i = 0;
    while (   //( next_bits( 24 ) != 0x000001 && next_bits( 32 ) != 0x00000001 ) 
          (buf[i] != 0 || buf[i+1] != 0 || buf[i+2] != 0x01) &&
          (buf[i] != 0 || buf[i+1] != 0 || buf[i+2] != 0 || buf[i+3] != 0x01)
           )
    { 
        i++; // skip leading zero
        if (i+4 >= size)
        {
            return 0;
        } // did not find nal start
    }
    if  (buf[i] != 0 || buf[i+1] != 0 || buf[i+2] != 0x01) // ( next_bits( 24 ) != 0x000001 )
    {
        i++;
    }
    if  (buf[i] != 0 || buf[i+1] != 0 || buf[i+2] != 0x01)
    {
        /* error, should never happen */
        return 0;
    }
    i+= 3;
    *nal_start = i;
    while (   //( next_bits( 24 ) != 0x000000 && next_bits( 24 ) != 0x000001 )
           (buf[i] != 0 || buf[i+1] != 0 || buf[i+2] != 0) &&
           (buf[i] != 0 || buf[i+1] != 0 || buf[i+2] != 0x01)
           )
    {
        i++;
        // FIXME the next line fails when reading a nal that ends exactly at the end of the data
        if (i+3 >= size) 
        {
            *nal_end = size;
            return (*nal_end - *nal_start);//return -1;
        } // did not find nal end, stream ended first
    }
    *nal_end = i;
    return (*nal_end - *nal_start);
}

- (BOOL)decodeNalu:(uint32_t)frame withSize(uint32_t)frameSize {
    // LOGD(@">>>>>>>>>>开始解码");

    if (frame == NULL || frameSize == 0)
        return NO;

    uint8_t* p = frame, *pf;
    size_t sz = frameSize;
    int nal_start, nal_end;

    while (![[NSThread currentThread] isCancelled] && findNalUnit(p, sz, &nal_start, &nal_end) > 0) {
        CVPixelBufferRef pixelBuffer = NULL;
        int nalu_type = p[nal_start] & 0x1f;
        int nal_len = nal_end - nal_start;
        uint8_t *pnal_size = (uint8_t*)(&nal_len);
        //{(uint8_t)(nal_len >> 24), (uint8_t)(nal_len >> 16), (uint8_t)(nal_len >> 8), (uint8_t)nal_len};
        if (nal_start == 3) { //big-endian
            p[-1] = *(pnal_size + 3);
            p[0]  = *(pnal_size + 2);
            p[1]  = *(pnal_size + 1);
            p[2]  = *(pnal_size);
            pf = p - 1;
        }
        else if (nal_start == 4) {
            p[0] = *(pnal_size + 3);
            p[1] = *(pnal_size + 2);
            p[2] = *(pnal_size + 1);
            p[3] = *(pnal_size);
            pf = p;
        }
        switch (nalu_type)
        {
            case 0x05:
                LOGD(@"nalu_type:%d Nal type is IDR frame", nalu_type);
                if ([self initH264Decoder]) {
                    pixelBuffer = [self decode:pf withSize:(nal_len + 4)];
                }
                break;
            case 0x07:
                LOGD(@"nalu_type:%d Nal type is SPS", nalu_type);
                if (_sps == NULL) {
                    _spsSize = nal_len;
                    _sps = (uint8_t*)malloc(_spsSize);
                    memcpy(_sps, &pf[4], _spsSize);
                }
                break;
            case 0x08:
                LOGD(@"nalu_type:%d Nal type is PPS", nalu_type);
                if (_pps == NULL) {
                    _ppsSize = nal_len;
                    _pps = (uint8_t*)malloc(_ppsSize);
                    memcpy(_pps, &pf[4], _ppsSize);
                }
                break;
            default:
                LOGD(@"nalu_type:%d Nal type is B/P frame", nalu_type);
                if ([self initH264Decoder]) {
                    pixelBuffer = [self decode:pf withSize:(nal_len + 4)];
                }
                break;
       }
        p += nal_start;
        p += nal_len;
        sz -= nal_end;
    }
（2）另外一种方式：
循环获取原始数据 -----> 重新打包大包中的nalu (每个nalu的头部改为当前nalu的长度)

使用这种方式在模拟器和真机上都是正常显示的，没有花屏和绿屏现象。所以，对于获取到的一帧数据可能被分成了多个nalu，解码的时候不需要再拆分成单个nalu单独去解码，这样硬解码器内部认为此单nalu不是一个完整的帧，导致花屏。

大致代码如下：

//
//  WBH264Play.m
//  wenba_rtc
//
//  Created by zhouweiwei on 16/11/20.
//  Copyright © 2016年 zhouweiwei. All rights reserved.
//

#import <Foundation/Foundation.h>
#import "WBH264Play.h"

#define kH264outputWidth  160
#define kH264outputHeight 120

static const uint8_t *avc_find_startcode_internal(const uint8_t *p, const uint8_t *end)
{
    const uint8_t *a = p + 4 - ((intptr_t)p & 3);

    for (end -= 3; p < a && p < end; p++) {
        if (p[0] == 0 && p[1] == 0 && p[2] == 1)
            return p;
    }

    for (end -= 3; p < end; p += 4) {
        uint32_t x = *(const uint32_t*)p;
        //      if ((x - 0x01000100) & (~x) & 0x80008000) // little endian
        //      if ((x - 0x00010001) & (~x) & 0x00800080) // big endian
        if ((x - 0x01010101) & (~x) & 0x80808080) { // generic
            if (p[1] == 0) {
                if (p[0] == 0 && p[2] == 1)
                    return p;
                if (p[2] == 0 && p[3] == 1)
                    return p+1;
            }
            if (p[3] == 0) {
                if (p[2] == 0 && p[4] == 1)
                    return p+2;
                if (p[4] == 0 && p[5] == 1)
                    return p+3;
            }
        }
    }

    for (end += 3; p < end; p++) {
        if (p[0] == 0 && p[1] == 0 && p[2] == 1)
            return p;
    }

    return end + 3;
}

const uint8_t *avc_find_startcode(const uint8_t *p, const uint8_t *end)
{
    const uint8_t *out= avc_find_startcode_internal(p, end);
    if(p<out && out<end && !out[-1]) out--;
    return out;
}

@interface H264HwDecoder()
{
    NSThread *thread;
    uint8_t* _vdata;
    size_t _vsize;

    uint8_t *_buf_out; // 原始接收的重组数据包

    uint8_t *_sps;
    size_t _spsSize;
    uint8_t *_pps;
    size_t _ppsSize;
    VTDecompressionSessionRef _deocderSession;
    CMVideoFormatDescriptionRef _decoderFormatDescription;
}
@end

@implementation H264HwDecoder

//解码回调函数
static void didDecompress(void *decompressionOutputRefCon, void *sourceFrameRefCon, OSStatus status, VTDecodeInfoFlags infoFlags, CVImageBufferRef imageBuffer, CMTime presentationTimeStamp, CMTime presentationDuration ) {

    if (status != noErr || imageBuffer == nil) {
        LOGE(@"Error decompresssing frame at time: %.3f error: %d infoFlags: %u",
             presentationTimeStamp.value/presentationTimeStamp.timescale, status, infoFlags);
        return;
    }

    if (kVTDecodeInfo_FrameDropped & infoFlags) {
        LOGW(@"video frame droped");
        return;
    }

//    int i,j;
//    if (CVPixelBufferIsPlanar(imageBuffer)) {
//        i  = (int)CVPixelBufferGetWidthOfPlane(imageBuffer, 0);
//        j = (int)CVPixelBufferGetHeightOfPlane(imageBuffer, 0);
//    } else {
//        i  = (int)CVPixelBufferGetWidth(imageBuffer);
//        j = (int)CVPixelBufferGetHeight(imageBuffer);
//    }

    __weak H264HwDecoder *decoder = (__bridge H264HwDecoder *)decompressionOutputRefCon;
    if (decoder.delegate != nil) {
        CVPixelBufferRef *outputPixelBuffer = (CVPixelBufferRef *)sourceFrameRefCon;
        *outputPixelBuffer = CVPixelBufferRetain(imageBuffer);
        [decoder.delegate displayDecodedFrame:decoder.uid imageBuffer:imageBuffer];
    }
}

- (BOOL)open:width:(uint16_t)width height:(uint16_t)height (NSObject<IWBH264HwDecoderDelegate>*)displayDelegate {

    [self close];

    if (width == 0 || height == 0) {
        _out_width = kH264outputWidth;
        _out_height = kH264outputHeight;
    }
    else {
        _out_width = width;
        _out_height = height;
    }
    _vsize = _out_width * _out_height * 3;
    _vdata = (uint8_t*)malloc(_vsize * sizeof(uint8_t));

    _buf_out = (uint8_t*)malloc(_out_width * _out_height * sizeof(uint8_t));

    self.delegate = displayDelegate;

    thread = [[NSThread alloc] initWithTarget:self selector:@selector(run) object:nil];
    //thread.name = @"Thread";
    [thread start];

    return YES;
}

- (void)setH264DecoderInterface:(NSObject<IWBH264HwDecoderDelegate>*)displayDelegate {
    self.delegate = displayDelegate;
}

- (void)run {
    size_t out_size = 0;

    while (![[NSThread currentThread] isCancelled]) {
        /*这里从网路端循环获取视频数据*/
        if (api_video_get(_uid, _vdata, &out_size) == 0 && out_size > 0) {
            if ([self decodeNalu:_vdata withSize:out_size]) {
            }
        }

        [NSThread sleepForTimeInterval:0.005];
    }
}

- (void)stop {
    LOGD(@"uid:%u decoder stop", _uid);

    if (_thread != nil) {
        if (!_thread.isCancelled) {
            [_thread cancel];
            LOGD(@"uid:%u thread cancel", _uid);
        }
    }

    LOGD(@"uid:%u decoder stoped", _uid);

    if (_decoderFormatDesc != nil) {
        CFRelease(_decoderFormatDesc);
        _decoderFormatDesc = nil;
    }

    if (_deocderSession != nil) {
        VTDecompressionSessionWaitForAsynchronousFrames(_deocderSession);
        VTDecompressionSessionInvalidate(_deocderSession);
        CFRelease(_deocderSession);
        _deocderSession = nil;
    }

    _uid = 0;

    _out_width = kH264outputWidth;
    _out_height = kH264outputHeight;

    if (_vdata != NULL) {
        free(_vdata);
        _vdata = NULL;
        _vsize = 0;
    }

    if (_sps != NULL) {
        free(_sps);
        _sps = NULL;
        _spsSize = 0;
    }

    if (_pps != NULL) {
        free(_pps);
        _pps = NULL;
        _ppsSize = 0;
    }

    if (_buf_out != NULL) {
        free(_buf_out);
        _buf_out = NULL;
    }

    self.delegate = nil;
}

- (void)close {
    [self stop];
    _thread = nil;

    LOGD(@"uid:%u decoder close", _uid);
}

-(BOOL)initH264Decoder {
    if (_deocderSession) {
        return YES;
    }

    if (!_sps || !_pps || _spsSize == 0 || _ppsSize == 0) {
        return NO;
    }

    const uint8_t* const parameterSetPointers[2] = { _sps, _pps };
    const size_t parameterSetSizes[2] = { _spsSize, _ppsSize };
    OSStatus status = CMVideoFormatDescriptionCreateFromH264ParameterSets(kCFAllocatorDefault,
                                                                          2, //param count
                                                                          parameterSetPointers,
                                                                          parameterSetSizes,
                                                                          4, //nal start code size
                                                                          &_decoderFormatDescription);
    if (status == noErr) {
        NSDictionary* destinationPixelBufferAttributes = @{
                                                           (id)kCVPixelBufferPixelFormatTypeKey : [NSNumber numberWithInt:kCVPixelFormatType_420YpCbCr8BiPlanarVideoRange]
                                                           //硬解必须是 kCVPixelFormatType_420YpCbCr8BiPlanarVideoRange 或者是kCVPixelFormatType_420YpCbCr8Planar
                                                           //因为iOS是nv12  其他是nv21
                                                           , (id)kCVPixelBufferWidthKey  : [NSNumber numberWithInt:kH264outputWidth]
                                                           , (id)kCVPixelBufferHeightKey : [NSNumber numberWithInt:kH264outputHeight]
                                                           //, (id)kCVPixelBufferBytesPerRowAlignmentKey : [NSNumber numberWithInt:kH264outputWidth*2]
                                                           , (id)kCVPixelBufferOpenGLCompatibilityKey : [NSNumber numberWithBool:NO]
                                                           , (id)kCVPixelBufferOpenGLESCompatibilityKey : [NSNumber numberWithBool:YES]
                                                           };

        VTDecompressionOutputCallbackRecord callBackRecord;
        callBackRecord.decompressionOutputCallback = didDecompress;
        callBackRecord.decompressionOutputRefCon = (__bridge void *)self;

        status = VTDecompressionSessionCreate(kCFAllocatorDefault,
                                              _decoderFormatDescription,
                                              NULL,
                                              (__bridge CFDictionaryRef)destinationPixelBufferAttributes,
                                              &callBackRecord,
                                              &_deocderSession);
        VTSessionSetProperty(_deocderSession, kVTDecompressionPropertyKey_ThreadCount, (__bridge CFTypeRef)[NSNumber numberWithInt:1]);
        VTSessionSetProperty(_deocderSession, kVTDecompressionPropertyKey_RealTime, kCFBooleanTrue);
    } else {
        LOGE(@"reset decoder session failed status=%d", status);
        return NO;
    }

    return YES;
}

- (BOOL)resetH264Decoder {
    if(_deocderSession) {
        VTDecompressionSessionWaitForAsynchronousFrames(_deocderSession);
        VTDecompressionSessionInvalidate(_deocderSession);
        CFRelease(_deocderSession);
        _deocderSession = NULL;
    }
    return [self initH264Decoder];
}

- (CVPixelBufferRef)decode:(uint8_t *)frame withSize:(uint32_t)frameSize {
    if (frame == NULL || _deocderSession == nil)
        return NULL;

    CVPixelBufferRef outputPixelBuffer = NULL;
    CMBlockBufferRef blockBuffer = NULL;

    OSStatus status  = CMBlockBufferCreateWithMemoryBlock(NULL,
                                                          (void *)frame,
                                                          frameSize,
                                                          kCFAllocatorNull,
                                                          NULL,
                                                          0,
                                                          frameSize,
                                                          FALSE,
                                                          &blockBuffer);
    if(status == kCMBlockBufferNoErr) {
        CMSampleBufferRef sampleBuffer = NULL;
        const size_t sampleSizeArray[] = {frameSize};
//        status = CMSampleBufferCreateReady(kCFAllocatorDefault,
//                                           blockBuffer,
//                                           _decoderFormatDescription ,
//                                           1, 0, NULL, 1, sampleSizeArray,
//                                           &sampleBuffer);
        status = CMSampleBufferCreate(NULL, blockBuffer, TRUE, 0, 0, _decoderFormatDescription, 1, 0, NULL, 0, NULL, &sampleBuffer);

        if (status == kCMBlockBufferNoErr && sampleBuffer) {
            VTDecodeFrameFlags flags = 0;
            VTDecodeInfoFlags flagOut = 0;
            status = VTDecompressionSessionDecodeFrame(_deocderSession,
                                                       sampleBuffer,
                                                       flags,
                                                       &outputPixelBuffer,
                                                       &flagOut);

            if (status == kVTInvalidSessionErr) {
                LOGE(@"Invalid session, reset decoder session");
                [self resetH264Decoder];
            } else if(status == kVTVideoDecoderBadDataErr) {
                LOGE(@"decode failed status=%d(Bad data)", status);
            } else if(status != noErr) {
                LOGE(@"decode failed status=%d", status);
            }
        }

        if (sampleBuffer != NULL)
            CFRelease(sampleBuffer);
    }
    if (blockBuffer != NULL)
        CFRelease(blockBuffer);

    return outputPixelBuffer;
}

- (BOOL)decodeNalu:(uint8_t *)frame withSize:(uint32_t)frameSize {
    // LOGD(@">>>>>>>>>>开始解码");

    if (frame == NULL || frameSize == 0)
        return NO;

    int size = frameSize;
    const uint8_t *p = frame;
    const uint8_t *end = p + size;
    const uint8_t *nal_start, *nal_end;
    int nal_len, nalu_type;

    size = 0;
    nal_start = avc_find_startcode(p, end);
    while (![[NSThread currentThread] isCancelled]) {
        while (![[NSThread currentThread] isCancelled] && nal_start < end && !*(nal_start++));
        if (nal_start == end)
            break;

        nal_end = avc_find_startcode(nal_start, end);
        nal_len = nal_end - nal_start;

        nalu_type = nal_start[0] & 0x1f;
        if (nalu_type == 0x07) {
            if (_sps == NULL) {
                _spsSize = nal_len;
                _sps = (uint8_t*)malloc(_spsSize);
                memcpy(_sps, nal_start, _spsSize);
            }
        }
        else if (nalu_type == 0x08) {
            if (_pps == NULL) {
                _ppsSize = nal_len;
                _pps = (uint8_t*)malloc(_ppsSize);
                memcpy(_pps, nal_start, _ppsSize);
            }
        }
        else {
            _buf_out[size + 0] = (uint8_t)(nal_len >> 24);
            _buf_out[size + 1] = (uint8_t)(nal_len >> 16);
            _buf_out[size + 2] = (uint8_t)(nal_len >> 8 );
            _buf_out[size + 3] = (uint8_t)(nal_len);

            memcpy(_buf_out + 4 + size, nal_start, nal_len);
            size += 4 + nal_len;
        }

        nal_start = nal_end;
    }

    if ([self initH264Decoder]) {
        CVPixelBufferRef pixelBuffer = NULL;
        pixelBuffer = [self decode:_buf_out withSize:size];
    }

    return size > 0 ? YES : NO;
}

@end


作者：南冠彤
链接：http://www.jianshu.com/p/58920f8b8879
來源：简书
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
humiaor
关注
专栏目录
iOS H264硬解码文档
12-06
iOS H264硬解码文档详细介绍了在苹果公司的iOS平台上实现视频流使用H264编码格式的硬件解码过程，这一过程能够提高设备性能、提升效率，并延长电池寿命。文档中提到的几个关键知识点是： 1. 硬件编解码如何提升用户...
ios视频实现H264硬编码和软编码编译ffmpeg库及环境搭建(附完整demo)
weixin_34004750的博客
06-03 1288
概述 上篇文章我们学习了视频的相关概念及h264编解码的流程，这篇文章我们主要是做代码实现，其内容概要如下： 利用VideoToolBox对实时视频做h264硬编码 ffmpeg 在mac平台安装ffmpeg 简单常用的ffmpeg命令 如何在mac平台编译出ios开发所用的ffmpeg库以及环境搭建 简单介绍ffmpeg库 利用ffmpeg对实时视频做h264软编码 示例代码： h2...
uint8_t报错问题笔记
吸喵高手的小窝
10-24 5377
uint8_t和uint32_报错问题笔记 问题代码如下： #define __u32 uint32_t #define __u8 uint8_t uint8_t *annexBHeader; size_t annexBHeaderLen; size_t nalSize; Linux下编译： 加了#include 还是会报错，于是我注掉了__u32和__u8， 加
系统化学习 H264视频编码（05）码流数据及相关概念解读
最新发布
wangdsh的博客
08-04 908
针对本文，我们主要研究 H.264码流数据结构及相关概念。包括VCL层(Video Coding Layer,视频数据编码层)及其相关概念宏块、片等，NAL层(Network Abstraction Layer,视频数据网络抽象层)及其相关概念SODB、RBSP、EBSP和NALU等；NALU详细信息解读以及Annex格式和RTP格式解读。
IJKPlayer播放视频在iOS部分机型黑屏原因分析
weixin_40290106的博客
04-24 2424
一.背景 1.问题视频在iphone7p等机型上：视频无法正常播放（黑屏）,音频正常播放。 2.问题视频在iphone XR机型上：音视频均能正常播放。 二.断点分析 1.问题视频在iphone7p上创建VideoToolBox解码器成功，解码失败（解码中失败IJKPlayer不能自动切换FFmpeg软解码），视频画面无法正常播放。 解码失败错误码：kVTVideoDecoderBadDataE...
1小时学会：最简单的iOS直播推流（七）h264/aac 硬编码
irainsa的博客
03-21 482
前面已经介绍了如何从硬件设备获取到音视频数据（pcm，NV12）。但是我们需要的视频格式是 aac和 h264。现在就介绍一下如何将pcm编码aac，将NV12数据编码为h264。编码分为软编码和硬编码。硬编码是系统提供的，由系统专门嵌入的硬件设备处理音视频编码，主要计算操作在对应的硬件中。硬编码的特点是，速度快，cpu占用少，但是不够灵活，只能使用一些特定的功能。软编码是指，通过代码计算进行数据编码，主要计算操作在cpu中。软编码的特点是，灵活，多样，功能丰富可扩展，但是cpu占用较多。
iOS H264,H265视频编码（Video encode)
irainsa的博客
03-18 1188
这里我们简单介绍一下H264,H265码流信息H264流数据是由一系列NAL单元(NAL Unit)组成的。一个NALU可能包含：视频帧，视频帧也就是视频片段，具体有I,P,B帧H264的码流H.264属性合集-FormatDesc(包含 SPS和PPS)属性集合注意在H265流数据中新增vps在最前。
iOS 视频h264 和 h265 硬编码-代码
irainsa的博客
03-23 550
这里我们简单介绍一下H264,H265码流信息H264流数据是由一系列NAL单元(NAL Unit)组成的。一个NALU可能包含：视频帧，视频帧也就是视频片段，具体有I,P,B帧H264的码流H.264属性合集-FormatDesc(包含 SPS和PPS)属性集合注意在H265流数据中新增vps在最前。
h264解码库 iOS的 音视频多用
05-24
在iOS平台上进行音视频处理时，H264解码库是不可或缺的工具，它能够帮助开发者实现高效、流畅的音视频播放与编辑功能。H264是一种高效的视频编码标准，广泛应用于高清视频流媒体、网络视频通话、以及各种多媒体应用...
iOS版h264解码demo
12-21
本示例“iOS版h264解码demo”提供了一个实用的参考，帮助开发者了解并实现H264视频流在iOS设备上的解码过程。以下是关于H264解码和在iOS上实现这一过程的关键知识点： 1. H264编码标准：H264，全称Advanced Video ...
ios h264视频硬编码
08-14
在iOS开发中，H264视频硬编码是一项重要的技术，尤其在实时视频传输和流媒体应用中。这里我们关注的是在iOS 8及以上版本中使用VideoToolbox框架进行H264编码的方法。VideoToolbox是苹果提供的一套低级别多媒体处理库...
ios-H264实时硬件编解码demo.zip
07-11
H264实时硬件编解码demo
H264解码 ios oc
07-14
在iOS平台上进行H264视频解码是一个关键的技术任务，尤其对于开发视频播放应用或者进行实时通信的应用来说。H264是一种高效且广泛使用的视频编码标准，它通过先进的压缩算法大大减少了视频数据的存储和传输需求。...
iOS H264编码及解码
ForeverMyheart的博客
08-11 1427
工作之余写了一个类似拉钩首页demo，主要代码如下： class LagouHomeController: UIViewController { var topView = BannerView() var toolView = ToolView() var bgView = UIView() var datas = [ApplyListModel]() var tableView = UITableView() overri...
iOS视频开发（二）：视频H264硬编码
irainsa的博客
03-13 756
前面我们已经介绍了在iOS开发中如果调用摄像头进行视频数据的采集和编解码。但折腾了这么多，对于YUV这玩意儿还是不是特别理解。其实在我的个人实践过程中我也一直搞不懂这个YUV，一顿恶补之后，我们来通俗一点地讲YUV这个数据格式。1、YUV & RGB概述 2、YUV的采样方式 3、YUV的储存方式及常见格式 4、YUV数据量计算 5、YUV裁剪RGB色彩模式是工业界的一种颜色标准，我们知道三原色（RGB）通过互相叠加可以得到各式各样的颜色，是目前运用最广的颜色系统之一。
VTDecompressionSessionInvalidate线程卡死挂起导致的解码问题
CaicaiNo.1
07-10 3281
VideoToolBox解码时，VTDecompressionSessionDecodeFrame返回错误12902，kVTParameterErr = -12902 即参数错误，然后在VTDecompressionSessionInvalidate的时候，就发现线程卡死挂起了 同样操作VTDecompressionSessionWaitForAsynchronousFrames也是一样的，VTDecompressionSessionInvalidate里面也操作了VTDecompressionSessio
IOS 硬解码，一个可以解各种粘包，起始码不同的解码器文件
FF_lz的博客
02-29 1193
接触iOS硬解码是从2017上半年开始的，在接触硬解码之前都是集成各种接收数据到渲染的框架，各种坑填都填不完，就直接改用硬解码了，tcp网络码流获取方面使用的是CocoaAsyncSocket网络框架，rtsp摄像头码流获取是通过FFmpeg获取的，这里就不将代码贴出来了，需要的话评论区留言，接下来直接上摄像头h264码流图 上图:这是一段摄像头的sps ，pps，I帧粘包都一块的数据图 ...
ios系统下h264编码的mp4文件无法播放的问题
HYEHYEHYE的博客
03-22 4547
H.264中有profile（画质级别）和level（用来约束分辨率、帧率和码率）的概念，profile有四种，分别是Baseline Profile（基本画质）、Extended profile（进阶画质）、Main profile（主流画质）和High profile（高级画质），level一般用数字表示，Level越高，视频的码率、分辨率、fps越高。我们可以通过potplayer等播放软件，查看对应的mp4文件的压缩级别，如果压缩级别高于苹果能支持的压缩级别，则会出现ios下无法播放的问题。
iOS 音视频专栏（一）视频流H264分析以及坑
两米阳光的博客
08-01 2255
引言前段时间进新公司，做视频会议，会诊方向的。不采用任何第三方框架，包括推流，拉流，编解码等视频处理，都是自己来编写，除了音频部分要用到webrtc来处理声音降噪，增益等。过程很艰辛，也是踩了无数的坑，总算项目算是整完了。在此，记录一下音视频这块所需要掌握的一些知识点，很多网上能找到的，在这里我就尽量不会太费笔墨。写的不好，轻拍，大家一起进步。 1.视频流 H264 分析网上有很多的对裸流H264
flutter 解码h264二进制流
03-03
FFmpeg是一个开源的音视频处理库，支持多种音视频编解码格式，包括H264。 使用flutter_ffmpeg插件，你可以将H264二进制流传递给FFmpeg进行解码。以下是一个简单的示例代码： 1. 首先，在pubspec.yaml文件中添加...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值