openh264 背景检测功能源码分析

已于 2024-06-21 22:59:34 修改
阅读量907 收藏 20
点赞数 15
分类专栏： # openh264 文章标签： openh264 h264 背景检测 视频编解码 webrtc 音视频 RTC
于 2024-06-06 16:01:15 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yanceyxin/article/details/139501966
版权

文件位置

  • openh264/codec/processing/src/BackgroundDetection.cpp

代码流程

在这里插入图片描述

  • 核心函数
    • 从代码流程可以看到实现背景检测的核心功能主要是CBackgroundDetection类中ForegroundBackgroundDivision函数和ForegroundDilationAndBackgroundErosion函数。

原理

  • 参数开关控制：(bool)bEnableBackgroundDetection

ForegroundBackgroundDivision 函数

  1. 功能：前景和背景粗略区分
  2. 原理过程：
  • 计算以宏块为单位的图像宽iPicWidthInOU和高iPicHeightInOU；
  • 计算每行的宏块个数iPicWidthInMb；
  • 声明并初始化指向Background OU数组的指针，该数组内部是宏块级OU 的数据信息；
  • 双层for 循环遍历所有宏块级 OU单元；
    • 调用GetOUParameters函数获取 OU 参数，主要是iSD、iSAD、ISD、iMAD、iMinSubMad、iMaxDiffSubSd；
    • 当前 OU背景标志iBackgroundFlag赋值 0；
    • 如果当前OU的平均绝对偏差（Mean Absolute Difference,MAD）大于63，则跳过当前OU；移动到下一个 OU；
    • 如果当前 OU 的iMaxDiffSubSd小于等于iSAD / 8或者iMaxDiffSubSd小于等于16x8，且iSAD小于2x16x16x2；
      • 如果iSAD小于16*8，则当前OU背景标志iBackgroundFlag 赋值 1；
      • 否则，当前OU背景标志iBackgroundFlag 的计算公式如下：
        • 如果当前 OU 的iSAD 小于2x16x16，判断当前 OU 的iSD是否小于iSADx3 / 4，将大小关系结果赋值给iBackgroundFlag；
        • 否则，判断当前 OU 的iSDx2 是否小于当前 OU 的iSAD，将大小关系结果赋值给iBackgroundFlag；
    • 移动到下一个宏块级OU；
  1. 原理图：
    在这里插入图片描述
  2. 相关源码：
  • ForegroundBackgroundDivision函数
void CBackgroundDetection::ForegroundBackgroundDivision (vBGDParam* pBgdParam) {
  int32_t iPicWidthInOU         = pBgdParam->iBgdWidth  >> LOG2_BGD_OU_SIZE;
  int32_t iPicHeightInOU        = pBgdParam->iBgdHeight >> LOG2_BGD_OU_SIZE;
  int32_t iPicWidthInMb         = (15 + pBgdParam->iBgdWidth) >> 4;

  SBackgroundOU* pBackgroundOU = pBgdParam->pOU_array;

  for (int32_t j = 0; j < iPicHeightInOU; j ++) {
    for (int32_t i = 0; i < iPicWidthInOU; i++) {
      GetOUParameters (pBgdParam->pCalcRes, (j * iPicWidthInMb + i) << (LOG2_BGD_OU_SIZE - LOG2_MB_SIZE), iPicWidthInMb,
                       pBackgroundOU);

      pBackgroundOU->iBackgroundFlag = 0;
      if (pBackgroundOU->iMAD > 63) {
        pBackgroundOU++;
        continue;
      }
      if ((pBackgroundOU->iMaxDiffSubSd <= pBackgroundOU->iSAD >> 3
           || pBackgroundOU->iMaxDiffSubSd <= (BGD_OU_SIZE * Q_FACTOR))
          && pBackgroundOU->iSAD < (BGD_THD_SAD << 1)) { //BGD_OU_SIZE*BGD_OU_SIZE>>2
        if (pBackgroundOU->iSAD <= BGD_OU_SIZE * Q_FACTOR) {
          pBackgroundOU->iBackgroundFlag = 1;
        } else {
          pBackgroundOU->iBackgroundFlag = pBackgroundOU->iSAD < BGD_THD_SAD ?
                                           (pBackgroundOU->iSD < (pBackgroundOU->iSAD * 3) >> 2) :
                                           (pBackgroundOU->iSD << 1 < pBackgroundOU->iSAD);
        }
      }
      pBackgroundOU++;
    }
  }
}
  • GetOUParameters函数
void CBackgroundDetection::GetOUParameters (SVAACalcResult* sVaaCalcInfo, int32_t iMbIndex, int32_t iMbWidth,
    SBackgroundOU* pBgdOU) {
  int32_t       iSubSD[4];
  uint8_t       iSubMAD[4];
  int32_t       iSubSAD[4];

  uint8_t (*pMad8x8)[4];
  int32_t (*pSad8x8)[4];
  int32_t (*pSd8x8)[4];

  pSad8x8 = sVaaCalcInfo->pSad8x8;
  pMad8x8 = sVaaCalcInfo->pMad8x8;
  pSd8x8  = sVaaCalcInfo->pSumOfDiff8x8;

  iSubSAD[0] = pSad8x8[iMbIndex][0];
  iSubSAD[1] = pSad8x8[iMbIndex][1];
  iSubSAD[2] = pSad8x8[iMbIndex][2];
  iSubSAD[3] = pSad8x8[iMbIndex][3];

  iSubSD[0] = pSd8x8[iMbIndex][0];
  iSubSD[1] = pSd8x8[iMbIndex][1];
  iSubSD[2] = pSd8x8[iMbIndex][2];
  iSubSD[3] = pSd8x8[iMbIndex][3];

  iSubMAD[0] = pMad8x8[iMbIndex][0];
  iSubMAD[1] = pMad8x8[iMbIndex][1];
  iSubMAD[2] = pMad8x8[iMbIndex][2];
  iSubMAD[3] = pMad8x8[iMbIndex][3];

  pBgdOU->iSD   = iSubSD[0] + iSubSD[1] + iSubSD[2] + iSubSD[3];
  pBgdOU->iSAD  = iSubSAD[0] + iSubSAD[1] + iSubSAD[2] + iSubSAD[3];
  pBgdOU->iSD   = WELS_ABS (pBgdOU->iSD);

  // get the max absolute difference (MAD) of OU and min value of the MAD of sub-blocks of OU
  pBgdOU->iMAD = WELS_MAX (WELS_MAX (iSubMAD[0], iSubMAD[1]), WELS_MAX (iSubMAD[2], iSubMAD[3]));
  pBgdOU->iMinSubMad = WELS_MIN (WELS_MIN (iSubMAD[0], iSubMAD[1]), WELS_MIN (iSubMAD[2], iSubMAD[3]));

  // get difference between the max and min SD of the SDs of sub-blocks of OU
  pBgdOU->iMaxDiffSubSd = WELS_MAX (WELS_MAX (iSubSD[0], iSubSD[1]), WELS_MAX (iSubSD[2], iSubSD[3])) -
                          WELS_MIN (WELS_MIN (iSubSD[0], iSubSD[1]), WELS_MIN (iSubSD[2], iSubSD[3]));
}

ForegroundDilationAndBackgroundErosion 函数

  1. 功能：前景膨胀和背景腐蚀
  2. 函数关系图：
    在这里插入图片描述
  3. 过程：
  • 定义iPicStrideUV变量存储 图像UV 分量步长；
  • 计算宏块级OU 的宽iPicWidthInOU和高iPicHeightInOU；
  • 计算宏块级OU 的 UV 步长iOUStrideUV；
  • 计算每行宏块个数iPicWidthInMb；
  • 定义了一个指向SBackgroundOU结构体的指针pBackgroundOU，用来访问背景检测单元数组；
  • 定义了一个指向int8_t的指针pVaaBackgroundMbFlag，用来访问背景宏块标志数组；
  • 定义了一个长度为4的指针数组pOUNeighbours，用来存储当前OU的四个邻居OU的指针；
  • 将pOUNeighbours[2]（即顶部OU）初始化为pBackgroundOU；
  • 外层 for 循环 遍历每一列宏块级OU；
    • 初始化pRowSkipFlag指针，指向当前行的宏块标志；
    • 初始化 pOUNeighbours[0] （左OU） 为pBackgroundOU；
    • 计算pOUNeighbours[3]（底OU）；
    • 内存 for 循环遍历每一行宏块级OU；
      • 计算pOUNeighbours[1]（即右OU）;
      • 如果当前 OU pBackgroundOU的iBackgroundFlag为真；
        • 调用ForegroundDilation函数进行前景膨胀；
      • 否则；
        • 调用BackgroundErosion函数进行背景腐蚀；
      • 调用UpperOUForegroundCheck函数检测上方 OU是否为前景；
      • 调用SetBackgroundMbFlag函数设置背景宏块标志；
      • 更新pRowSkipFlag，pOUNeighbours、pBackgroundOU为下一个 宏块级OU 做准备；
    • 更新pOUNeighbours[2]和pVaaBackgroundMbFlag指针，为下一行OU的处理做准备。
  1. 原理图：
    在这里插入图片描述
  2. 相关源码：
  • ForegroundDilationAndBackgroundErosion函数
void CBackgroundDetection::ForegroundDilationAndBackgroundErosion (vBGDParam* pBgdParam) {
  int32_t iPicStrideUV          = pBgdParam->iStride[1];
  int32_t iPicWidthInOU         = pBgdParam->iBgdWidth  >> LOG2_BGD_OU_SIZE;
  int32_t iPicHeightInOU        = pBgdParam->iBgdHeight >> LOG2_BGD_OU_SIZE;
  int32_t iOUStrideUV           = iPicStrideUV << (LOG2_BGD_OU_SIZE - 1);
  int32_t iPicWidthInMb         = (15 + pBgdParam->iBgdWidth) >> 4;

  SBackgroundOU* pBackgroundOU = pBgdParam->pOU_array;
  int8_t*        pVaaBackgroundMbFlag = (int8_t*)pBgdParam->pBackgroundMbFlag;
  SBackgroundOU* pOUNeighbours[4];//0: left; 1: right; 2: top; 3: bottom

  pOUNeighbours[2]      = pBackgroundOU;//top OU
  for (int32_t j = 0; j < iPicHeightInOU; j ++) {
    int8_t* pRowSkipFlag = pVaaBackgroundMbFlag;
    pOUNeighbours[0]    = pBackgroundOU;//left OU
    pOUNeighbours[3]    = pBackgroundOU + (iPicWidthInOU & ((j == iPicHeightInOU - 1) - 1)); //bottom OU
    for (int32_t i = 0; i < iPicWidthInOU; i++) {
      pOUNeighbours[1] = pBackgroundOU + (i < iPicWidthInOU - 1); //right OU

      if (pBackgroundOU->iBackgroundFlag)
        ForegroundDilation (pBackgroundOU, pOUNeighbours, pBgdParam, j * iOUStrideUV + (i << LOG2_BGD_OU_SIZE_UV));
      else
        BackgroundErosion (pBackgroundOU, pOUNeighbours);

      // check the up OU
      if (j > 1 && i > 0 && i < iPicWidthInOU - 1 && pOUNeighbours[2]->iBackgroundFlag == 1) {
        UpperOUForegroundCheck (pOUNeighbours[2], pRowSkipFlag - OU_SIZE_IN_MB * iPicWidthInMb, iPicWidthInOU, iPicWidthInMb);
      }

      SetBackgroundMbFlag (pRowSkipFlag, iPicWidthInMb, pBackgroundOU->iBackgroundFlag);

      // preparation for the next OU
      pRowSkipFlag += OU_SIZE_IN_MB;
      pOUNeighbours[0] = pBackgroundOU;
      pOUNeighbours[2]++;
      pOUNeighbours[3]++;
      pBackgroundOU++;
    }
    pOUNeighbours[2]      = pBackgroundOU - iPicWidthInOU;
    pVaaBackgroundMbFlag += OU_SIZE_IN_MB * iPicWidthInMb;
  }
}
  • ForegroundDilation函数
inline void CBackgroundDetection::ForegroundDilation (SBackgroundOU* pBackgroundOU, SBackgroundOU* pOUNeighbours[],
    vBGDParam* pBgdParam, int32_t iChromaSampleStartPos) {
  int32_t iPicStrideUV = pBgdParam->iStride[1];
  int32_t iSumNeighBackgroundFlags = pOUNeighbours[0]->iBackgroundFlag + pOUNeighbours[1]->iBackgroundFlag +
                                      pOUNeighbours[2]->iBackgroundFlag + pOUNeighbours[3]->iBackgroundFlag;

  if (pBackgroundOU->iSAD > BGD_OU_SIZE * Q_FACTOR) {
    switch (iSumNeighBackgroundFlags) {
    case 0:
    case 1:
      pBackgroundOU->iBackgroundFlag = 0;
      break;
    case 2:
    case 3:
      pBackgroundOU->iBackgroundFlag = !ForegroundDilation23Luma (pBackgroundOU, pOUNeighbours);

      // chroma component check
      if (pBackgroundOU->iBackgroundFlag == 1) {
        int8_t iNeighbourForegroundFlags = (!pOUNeighbours[0]->iBackgroundFlag) | ((!pOUNeighbours[1]->iBackgroundFlag) << 1)
                                            | ((!pOUNeighbours[2]->iBackgroundFlag) << 2) | ((!pOUNeighbours[3]->iBackgroundFlag) << 3);
        pBackgroundOU->iBackgroundFlag = !ForegroundDilation23Chroma (iNeighbourForegroundFlags, iChromaSampleStartPos,
                                         iPicStrideUV, pBgdParam);
      }
      break;
    default:
      break;
    }
  }
}
  • BackgroundErosion函数
inline void CBackgroundDetection::BackgroundErosion (SBackgroundOU* pBackgroundOU, SBackgroundOU* pOUNeighbours[]) {
  if (pBackgroundOU->iMaxDiffSubSd <= (BGD_OU_SIZE * Q_FACTOR)) { //BGD_OU_SIZE*BGD_OU_SIZE>>2
    int32_t iSumNeighBackgroundFlags = pOUNeighbours[0]->iBackgroundFlag + pOUNeighbours[1]->iBackgroundFlag +
                                       pOUNeighbours[2]->iBackgroundFlag + pOUNeighbours[3]->iBackgroundFlag;
    int32_t sumNbrBGsad = (pOUNeighbours[0]->iSAD & (-pOUNeighbours[0]->iBackgroundFlag)) + (pOUNeighbours[2]->iSAD &
                          (-pOUNeighbours[2]->iBackgroundFlag))
                          + (pOUNeighbours[1]->iSAD & (-pOUNeighbours[1]->iBackgroundFlag)) + (pOUNeighbours[3]->iSAD &
                              (-pOUNeighbours[3]->iBackgroundFlag));
    if (pBackgroundOU->iSAD * iSumNeighBackgroundFlags <= (3 * sumNbrBGsad) >> 1) {
      if (iSumNeighBackgroundFlags == 4) {
        pBackgroundOU->iBackgroundFlag = 1;
      } else {
        if ((pOUNeighbours[0]->iBackgroundFlag & pOUNeighbours[1]->iBackgroundFlag)
            || (pOUNeighbours[2]->iBackgroundFlag & pOUNeighbours[3]->iBackgroundFlag)) {
          pBackgroundOU->iBackgroundFlag = !ForegroundDilation23Luma (pBackgroundOU, pOUNeighbours);
        }
      }
    }
  }
}
  • UpperOUForegroundCheck函数
inline void CBackgroundDetection::UpperOUForegroundCheck (SBackgroundOU* pCurOU, int8_t* pBackgroundMbFlag,
    int32_t iPicWidthInOU, int32_t iPicWidthInMb) {
  if (pCurOU->iSAD > BGD_OU_SIZE * Q_FACTOR) {
    SBackgroundOU* pOU_L = pCurOU - 1;
    SBackgroundOU* pOU_R = pCurOU + 1;
    SBackgroundOU* pOU_U = pCurOU - iPicWidthInOU;
    SBackgroundOU* pOU_D = pCurOU + iPicWidthInOU;
    if (pOU_L->iBackgroundFlag + pOU_R->iBackgroundFlag + pOU_U->iBackgroundFlag + pOU_D->iBackgroundFlag <= 1) {
      SetBackgroundMbFlag (pBackgroundMbFlag, iPicWidthInMb, 0);
      pCurOU->iBackgroundFlag = 0;
    }
  }
}
  • ForegroundDilation23Luma函数
inline bool CBackgroundDetection::ForegroundDilation23Luma (SBackgroundOU* pBackgroundOU,
    SBackgroundOU* pOUNeighbours[]) {
  SBackgroundOU* pOU_L = pOUNeighbours[0];
  SBackgroundOU* pOU_R = pOUNeighbours[1];
  SBackgroundOU* pOU_U = pOUNeighbours[2];
  SBackgroundOU* pOU_D = pOUNeighbours[3];

  if (pBackgroundOU->iMAD > pBackgroundOU->iMinSubMad << 1) {
    int32_t iMaxNbrForegroundMad;
    int32_t iMaxNbrBackgroundMad;
    int32_t aBackgroundMad[4];
    int32_t aForegroundMad[4];

    aForegroundMad[0] = (pOU_L->iBackgroundFlag - 1) & pOU_L->iMAD;
    aForegroundMad[1] = (pOU_R->iBackgroundFlag - 1) & pOU_R->iMAD;
    aForegroundMad[2] = (pOU_U->iBackgroundFlag - 1) & pOU_U->iMAD;
    aForegroundMad[3] = (pOU_D->iBackgroundFlag - 1) & pOU_D->iMAD;
    iMaxNbrForegroundMad = WELS_MAX (WELS_MAX (aForegroundMad[0], aForegroundMad[1]), WELS_MAX (aForegroundMad[2],
                                     aForegroundMad[3]));

    aBackgroundMad[0] = ((!pOU_L->iBackgroundFlag) - 1) & pOU_L->iMAD;
    aBackgroundMad[1] = ((!pOU_R->iBackgroundFlag) - 1) & pOU_R->iMAD;
    aBackgroundMad[2] = ((!pOU_U->iBackgroundFlag) - 1) & pOU_U->iMAD;
    aBackgroundMad[3] = ((!pOU_D->iBackgroundFlag) - 1) & pOU_D->iMAD;
    iMaxNbrBackgroundMad = WELS_MAX (WELS_MAX (aBackgroundMad[0], aBackgroundMad[1]), WELS_MAX (aBackgroundMad[2],
                                     aBackgroundMad[3]));

    return ((iMaxNbrForegroundMad > pBackgroundOU->iMinSubMad << 2) || (pBackgroundOU->iMAD > iMaxNbrBackgroundMad << 1
            && pBackgroundOU->iMAD <= (iMaxNbrForegroundMad * 3) >> 1));
  }
  return 0;
}
  • ForegroundDilation23Chroma函数
inline bool CBackgroundDetection::ForegroundDilation23Chroma (int8_t iNeighbourForegroundFlags,
    int32_t iStartSamplePos, int32_t iPicStrideUV, vBGDParam* pBgdParam) {
  static const int8_t kaOUPos[4]        = {OU_LEFT, OU_RIGHT, OU_TOP, OU_BOTTOM};
  int32_t       aEdgeOffset[4]          = {0, BGD_OU_SIZE_UV - 1, 0, iPicStrideUV* (BGD_OU_SIZE_UV - 1)};
  int32_t       iStride[4]              = {iPicStrideUV, iPicStrideUV, 1, 1};

  // V component first, high probability because V stands for red color and human skin colors have more weight on this component
  for (int32_t i = 0; i < 4; i++) {
    if (iNeighbourForegroundFlags & kaOUPos[i]) {
      uint8_t* pRefC = pBgdParam->pRef[2] + iStartSamplePos + aEdgeOffset[i];
      uint8_t* pCurC = pBgdParam->pCur[2] + iStartSamplePos + aEdgeOffset[i];
      if (CalculateAsdChromaEdge (pRefC, pCurC, iStride[i]) > BGD_THD_ASD_UV) {
        return 1;
      }
    }
  }
  // U component, which stands for blue color, low probability
  for (int32_t i = 0; i < 4; i++) {
    if (iNeighbourForegroundFlags & kaOUPos[i]) {
      uint8_t* pRefC = pBgdParam->pRef[1] + iStartSamplePos + aEdgeOffset[i];
      uint8_t* pCurC = pBgdParam->pCur[1] + iStartSamplePos + aEdgeOffset[i];
      if (CalculateAsdChromaEdge (pRefC, pCurC, iStride[i]) > BGD_THD_ASD_UV) {
        return 1;
      }
    }
  }

  return 0;
}
  • CalculateAsdChromaEdge函数
inline int32_t CBackgroundDetection::CalculateAsdChromaEdge (uint8_t* pOriRef, uint8_t* pOriCur, int32_t iStride) {
  int32_t ASD = 0;
  int32_t idx;
  for (idx = 0; idx < BGD_OU_SIZE_UV; idx++) {
    ASD += *pOriCur - *pOriRef;
    pOriRef += iStride;
    pOriCur += iStride;
  }
  return WELS_ABS (ASD);
}
码流怪侠
关注
专栏目录
WebRTC学习进阶之路 --- 一、概述、原理、源码目录结构与整体架构介绍
SmallBottle-CGWLMX的博客
11-23 3530
片头语：在学习WebRTC首先最好具备一定的音视频相关基础知识，可以参考https://blog.csdn.net/xiaomucgwlmx/article/details/102838490，里边有很详细的介绍总结以供参考，接下来让我们一起来认识一下WebRTC。 WebRTC学习进阶之路系列总目录：https://blog.csdn.net/xiaomucgwlmx/article/deta...
openh264 编解码器源码分析综述
想都是问题，做才有答案～～
06-21 597
openh264 编解码器源码分析综述
openh264 编码器源码分析：AnalyzePictureComplexity 函数
想都是问题，做才有答案～～
06-12 1174
openh264 编码器源码分析：AnalyzePictureComplexity 函数
openh264 Pskip 模式决策过程源码分析
想都是问题，做才有答案～～
06-18 1344
openh264 Pskip 模式决策过程源码分析
openH264参数总结
老衲不出家
05-30 3837
在基于webrtc项目中用到了openH264编码器，在实际应用中对编码器的关键参数优化给出一些总结和建议：1.iRCMode：码率控制模式：0值对应quality mode（RC_QUALITY_MODE）更侧重保证视频质量，码率稳定性控制稍差；1值对应bitrate mode (RC_BITRATE_MODE)，更侧重保证码率的稳定性。 建议该参数设置为1：iRCMode =1；2.  iTe...
网搜源码
markman101---神即是道 道法自然 如来
07-30 7220
VideoNet.rar - 该程序可以用于两个人在LAN/Intranet(或者Internet)上进行视频会议。现在有许多视频会议程序，每个都有各自的性能提升技术。主要的问题是视频会议视频帧的尺寸对于传输来说太大。因此，性能依赖于对帧的编解码。 , This procedure may use in two people (or Internet) on carries on the video frequency conference in LAN/Intranet. Now has many vid
直播相关知识之二 采集、处理、编码和封装
胡杰的专栏
01-18 9565
直播相关知识之二 采集、处理、编码和封装、推流和传输、现代播放器原理、延迟优化 采集 采集是整个视频推流过程中的第一个环节，它从系统的采集设备中获取原始视频数据，将其输出到下一个环节。视频的采集涉及两方面数据的采集：音频采集和图像采集，它们分别对应两种完全不同的输入源和数据格式。 采集内容 1.音频采集 音频数据既能与图像结合组合成视频数据，也能以纯音频的方式采集播放，后者在很多成熟的应用场景如在
基于深度学习的屠宰厂生猪无序识别计数算法开发与应用
qq_1262330535的博客
10-24 633
随着经济现代化的不断发展，人们的物质需求不断增加，对猪肉的需求一直在增长，以家庭为主的小型生猪屠宰场将逐渐满足不了市场快速增长的需求，在激烈的竞争中逐渐显露出劣势被市场淘汰，而大规模的集约式的生猪屠宰场将成为市场的主流。在传统的小型生猪屠宰场，因为生猪数量少、场地小，这给人工进行计数带来很多便利。在传统的小型生猪屠宰场中的工作人员需要完全依靠自己对猪场进行检查监控，他们需要不间断的进行生猪的计数，消耗工作人员大量的体力，而且工作十分枯燥无趣，可能会导致工作人员因疲劳疏忽工作而造成漏检错检。
直播技术简单介绍（非原创）
Globalizationa的博客
10-02 4421
文章大纲 一、视频直播原理介绍二、视频直播代码演示（Android）三、项目源码下载四、参考文章 一、视频直播原理介绍 1. 视频直播技术流程 视频直播的流程可以分为如下几步：采集 —>处理—>编码和封装—>推流到服务器—>服务器流分发—>播放器流播放 2. 采集 采集是整个视频推流过程中的第一个环节，它从系统的采集设备中获取原始视频数据，将其输出到下一个环节。视频的采集涉及两方面数据的采集：音频采集和图像采集，它们分别对应两种完全...
openh264源码
07-05
《深入解析OpenH264源码：编码与解码技术详解》 OpenH264是一个开源的H.264编解码器库，由思科系统开发并维护，广泛应用于各种视频通信和流媒体应用中。本文将详细探讨OpenH264源码中的关键技术和实现细节，帮助...
openh264(openh264.lib)
09-21
在VS2013环境下编译的OpenH264库，可以方便开发者在Windows平台上集成H.264编码和解码功能。 1. **H.264标准** H.264，也称为AVC（Advanced Video Coding），是国际电信联盟（ITU-T）和国际标准化组织（ISO/IEC）...
09-openh264.zip open264的官方最新源码
03-06
【描述】"open264的官方最新源码"表明，用户可以获取到OpenH264项目的最新开发版本，这意味着它可能包含了最新的功能改进、性能优化以及潜在的bug修复。开发者和研究人员可以深入研究源代码，理解其工作原理，或者...
openh264:开源H.264编解码器-Open source
03-25
OpenH264 OpenH264是一个编解码器库，支持H.264编码和解码。 它适用于WebRTC等实时应用程序。 有关更多详细信息，请参见 。 编码器功能 受限基线配置文件，最高级别为5.2（最大帧大小为36864宏块） 任意分辨率，不...
官方openH264编译时使用的源码
09-22
openH264是由思科系统开源的一个高效、高质量的H.264编解码器库，它为开发者提供了在各种平台上实现H.264编码和解码功能的能力。在web开发中，H.264作为主流的视频编码标准，广泛应用于流媒体服务，如在线视频会议、...
Android视频编解码 简述(1)
起司锅仔的博客
10-20 374
随着现在大屏幕的风潮来袭，出现了许多设备互联的需求，其中最重要的功能之一就是投屏功能，其次现在的app都离不开视频播放，这些功能的背后都少不了音视频编解码，我们这个章节就来了解一下编解码的一些知识。首先我们先来说一下为什么需要编解码，其实主要目的就是为了减少视频的大小，试想如果我们有一个10242048分辨率的视频（手机屏幕的大小差不多这个量级），我们使用RGBA来编码，一个像素4个字节，那么一个图像就是2MB。
FreeSWITCH Record
qq_27890899的博客
08-13 1094
FreeSWITCH学习记录，从部署到配置，从Java后端到H5前端，旨在实现一套企业级融合通信系统。
C++音视频学习记录（1）概念扫盲
qq_53395528的博客
11-09 804
NAL是H.264标准中的一个层次，用于将视频编码层（VCL）的数据封装成适合传输和存储的格式。NAL的主要功能是将编码后的视频数据格式化，并添加必要的头信息，以确保数据可以通过各种网络和存储介质传输。NALU是NAL的基本单元，包含一个NALU头和一个RBSP（原始字节序列载荷）。每个NALU可以包含不同类型的数据，如视频帧、序列参数集（SPS）、图像参数集（PPS）等。SEI：提供辅助信息，帮助解码器更好地处理视频流。SPS：提供全局参数，适用于整个视频序列。PPS。
[大模型]视频生成-Sora简析
就随便写写....
11-05 1152
Sora模型的简述
Pr：视频过渡快速参考（合集 · 2025版）
最新发布
qq_41176800的博客
11-10 448
Adobe Premiere Pro 自带七组约四十多个视频过渡 Video Transitions效果，包含不同风格和用途，可在两个剪辑之间创造平滑、自然的转场，用来丰富时间、地点或情绪的变化。恰当地应用过渡可让观众更好地理解故事或人物。提示：点击下面的效果组名称或截图，即可访问该组里面的效果的详细说明。通用选项：持续时间Duration视频过渡默认的持续时间为 25帧，可在“首选项/时间轴”...
openh264 源码下载
06-07
您可以在以下链接中下载 OpenH264 的源代码： - 官方网站：https://github.com/cisco/openh264/releases - GitHub 仓库：https://github.com/cisco/openh264 请注意，这些源代码受版权保护，您需要遵循相应的许可...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

码流怪侠

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值