modulescoreincludeopencv2coretypes_c.h

前面的是一些宏定义，是为了兼容C，C++。对于一些函数的调用方式，建议补充一点补充知识：http://blog.csdn.net/yongdun_007/archive/2010/12/21/6090281.aspx，这个头文件是很重要的一个文件，建议大家都看看，这里定义了opencv用到的所有的数据类型和结构。详细如下：

types_c.h包括：常用的宏指令和内联函数，随机数的生成，图像数据类型，矩阵数据类型，多维稠密矩阵，多维稀疏矩阵，稀疏矩阵迭代，直方图，其他数据类型定义（包括矩形，终止准则，点和变量，size变量和Box变量，片和部分，尺度或者角度），动态数据结构（包括内存存储，序列，节点或者集，图结构，链和轮廓），序列类型，序列的读/写操作，对序列的操作（包括图的微操作），保持数据结构的稳定性，系统数据类型。

常用的宏指令和内联函数：

#define CV_PI  3.1415926535897932384626433832795//定义PI大小

#define CV_LOG20.69314718055994530941723212145818//定义log2

#define CV_SWAP(a,b,t) ((t) = (a), (a) = (b), (b) =(t))//交换a,b

#ifndef MIN

#define MIN(a,b)  ((a) >(b) ? (b) : (a))//求a,b最小值

#endif

#ifndef MAX

#define MAX(a,b)  ((a) <(b) ? (b) : (a))//求a,b最大值

#endif

#define  CV_IMIN(a,b)  ((a) ^ (((a)^(b)) &(((a) < (b)) - 1)))//

#define  CV_IMAX(a,b)  ((a) ^ (((a)^(b)) &(((a) > (b)) - 1)))//

#ifndef __cplusplus

#define CV_IABS(a)    (((a)^ ((a) < 0 ? -1 : 0)) - ((a) < 0 ? -1: 0))

#else

#define CV_IABS(a)    abs(a)

#endif

#define CV_CMP(a,b)   (((a) > (b)) - ((a) < (b)))

#define CV_SIGN(a)    CV_CMP((a),0)

// 返回和参数最接近的整数值

CV_INLINE  int cvRound( double value )

//返回不大于参数的最大整数值

CV_INLINE  int cvFloor( double value )

//返回不小于参数的最小整数值

CV_INLINE  int cvCeil( double value )

//对参数开平方并进行求倒

#define cvInvSqrt(value) ((float)(1./sqrt(value)))

//对参数开平方

#define cvSqrt(value) ((float)sqrt(value))

//判定是否为合法数

CV_INLINE int cvIsNaN( double value )

//判定是否为无穷

CV_INLINE int cvIsInf( double value )

随机数的生成

typedef uint64 CvRNG;

//初始化随机数生成器状态

CV_INLINE CvRNG cvRNG( int64 seed CV_DEFAULT(-1))

//返回32位无符号整型并更新RNG

CV_INLINE unsigned cvRandInt( CvRNG* rng )

//返回浮点型随机数并更新RNG

CV_INLINE double cvRandReal( CvRNG* rng )

图像数据类型

#ifndef HAVE_IPL

//定义深度位数

#define IPL_DEPTH_SIGN 0x80000000

#defineIPL_DEPTH_1U    1

#defineIPL_DEPTH_8U    8

#defineIPL_DEPTH_16U  16

#defineIPL_DEPTH_32F  32

//定义有符号深度位数

#define IPL_DEPTH_8S  (IPL_DEPTH_SIGN|8)

#define IPL_DEPTH_16S (IPL_DEPTH_SIGN|16)

#define IPL_DEPTH_32S (IPL_DEPTH_SIGN|32)

//定义数据顺序

#define IPL_DATA_ORDER_PIXEL  0

#define IPL_DATA_ORDER_PLANE  1

//定义图像原点位置

#define IPL_ORIGIN_TL 0 //左上

#define IPL_ORIGIN_BL 1 //左下

//定义扫描线位数

#define IPL_ALIGN_4BYTES  4

#defineIPL_ALIGN_8BYTES  8

#define IPL_ALIGN_16BYTES 16

#define IPL_ALIGN_32BYTES 32

//定义扫描线对齐

#defineIPL_ALIGN_DWORD  IPL_ALIGN_4BYTES

#defineIPL_ALIGN_QWORD  IPL_ALIGN_8BYTES

//定义扫描线宽度状态

#defineIPL_BORDER_CONSTANT  0 //扫描线连续

#define IPL_BORDER_REPLICATE  1//双扫描线

#defineIPL_BORDER_REFLECT   2 //带阴影扫描线

#defineIPL_BORDER_WRAP      3 //波浪扫描线

//定义图像结构体

typedef struct _IplImage

{

int nSize;

int ID;

int nChannels;

int alphaChannel;

int depth;

charcolorModel[4];

charchannelSeq[4];

int dataOrder;

int origin;

int align;

int width;

int height;

struct _IplROI*roi;

struct _IplImage*maskROI;

void *imageId;

struct _IplTileInfo *tileInfo;

int imageSize;

char*imageData;

int widthStep;

int BorderMode[4];

int BorderConst[4];

char *imageDataOrigin;

}

IplImage;

//定义图像分块信息结构体

typedef struct _IplTileInfo IplTileInfo;

//定义图像感兴趣区域

typedef struct _IplROI

{

int  coi; //感兴趣通道

int  xOffset; //X坐标值

int  yOffset; //y坐标值

int width;  //感兴趣区域宽度

int  height; //感兴趣区域高度

}

IplROI;

//定义卷积核结构体

typedef struct _IplConvKernel

{

int  nCols;

int  nRows;

int  anchorX;

int  anchorY;

int *values;

int  nShiftR;

}

IplConvKernel;

//定义快速卷积核结构体

typedef struct _IplConvKernelFP

{

int  nCols;

int  nRows;

int  anchorX;

int  anchorY;

float *values;

}

IplConvKernelFP;

#define IPL_IMAGE_HEADER 1

#defineIPL_IMAGE_DATA  2

#defineIPL_IMAGE_ROI   4

#endif

//定义边界模式

#defineIPL_BORDER_REFLECT_101   4 //带有阴影

#defineIPL_BORDER_TRANSPARENT   5 //透明

#define IPL_IMAGE_MAGIC_VAL ((int)sizeof(IplImage))

#define CV_TYPE_NAME_IMAGE "opencv-image"

#define CV_IS_IMAGE_HDR(img)

((img) != NULL && ((constIplImage*)(img))->nSize == sizeof(IplImage))

#define CV_IS_IMAGE(img)

(CV_IS_IMAGE_HDR(img) &&((IplImage*)img)->imageData != NULL)

//定义存储在图像的双精度数据

#define IPL_DEPTH_64F  64

//定义从给定图像，给定数据类型，给定坐标(col,row)获取图像像素值

#define CV_IMAGE_ELEM( image, elemtype, row, col)

(((elemtype*)((image)->imageData +(image)->widthStep*(row)))[(col)])

矩阵数据类型

//

#defineCV_CN_MAX    512  //定义矩阵数据最大值

#defineCV_CN_SHIFT  3    //

#define CV_DEPTH_MAX  (1<< CV_CN_SHIFT) //

//定义矩阵数据类型

#define CV_8U  0

#define CV_8S  1

#define CV_16U  2

#define CV_16S  3

#define CV_32S  4

#define CV_32F  5

#define CV_64F  6

#define CV_USRTYPE1 7

//

#defineCV_MAT_DEPTH_MASK      (CV_DEPTH_MAX - 1)

#defineCV_MAT_DEPTH(flags)    ((flags) & CV_MAT_DEPTH_MASK)

//

#define CV_MAKETYPE(depth,cn) (CV_MAT_DEPTH(depth) + (((cn)-1)<< CV_CN_SHIFT))

#define CV_MAKE_TYPE CV_MAKETYPE

//

#define CV_8UC1 CV_MAKETYPE(CV_8U,1)

#define CV_8UC2 CV_MAKETYPE(CV_8U,2)

#define CV_8UC3 CV_MAKETYPE(CV_8U,3)

#define CV_8UC4 CV_MAKETYPE(CV_8U,4)

#define CV_8UC(n) CV_MAKETYPE(CV_8U,(n))

//

#define CV_8SC1 CV_MAKETYPE(CV_8S,1)

#define CV_8SC2 CV_MAKETYPE(CV_8S,2)

#define CV_8SC3 CV_MAKETYPE(CV_8S,3)

#define CV_8SC4 CV_MAKETYPE(CV_8S,4)

#define CV_8SC(n) CV_MAKETYPE(CV_8S,(n))

//

#define CV_16UC1 CV_MAKETYPE(CV_16U,1)

#define CV_16UC2 CV_MAKETYPE(CV_16U,2)

#define CV_16UC3 CV_MAKETYPE(CV_16U,3)

#define CV_16UC4 CV_MAKETYPE(CV_16U,4)

#define CV_16UC(n) CV_MAKETYPE(CV_16U,(n))

//

#define CV_16SC1 CV_MAKETYPE(CV_16S,1)

#define CV_16SC2 CV_MAKETYPE(CV_16S,2)

#define CV_16SC3 CV_MAKETYPE(CV_16S,3)

#define CV_16SC4 CV_MAKETYPE(CV_16S,4)

#define CV_16SC(n) CV_MAKETYPE(CV_16S,(n))

//

#define CV_32SC1 CV_MAKETYPE(CV_32S,1)

#define CV_32SC2 CV_MAKETYPE(CV_32S,2)

#define CV_32SC3 CV_MAKETYPE(CV_32S,3)

#define CV_32SC4 CV_MAKETYPE(CV_32S,4)

#define CV_32SC(n) CV_MAKETYPE(CV_32S,(n))

//

#define CV_32FC1 CV_MAKETYPE(CV_32F,1)

#define CV_32FC2 CV_MAKETYPE(CV_32F,2)

#define CV_32FC3 CV_MAKETYPE(CV_32F,3)

#define CV_32FC4 CV_MAKETYPE(CV_32F,4)

#define CV_32FC(n) CV_MAKETYPE(CV_32F,(n))

//

#define CV_64FC1 CV_MAKETYPE(CV_64F,1)

#define CV_64FC2 CV_MAKETYPE(CV_64F,2)

#define CV_64FC3 CV_MAKETYPE(CV_64F,3)

#define CV_64FC4 CV_MAKETYPE(CV_64F,4)

#define CV_64FC(n) CV_MAKETYPE(CV_64F,(n))

//

#define CV_AUTO_STEP  0x7fffffff

#define CV_WHOLE_ARR  cvSlice( 0,0x3fffffff )

//

#defineCV_MAT_CN_MASK         ((CV_CN_MAX - 1) << CV_CN_SHIFT)

#defineCV_MAT_CN(flags)       ((((flags) & CV_MAT_CN_MASK)>> CV_CN_SHIFT) + 1)

#defineCV_MAT_TYPE_MASK       (CV_DEPTH_MAX*CV_CN_MAX - 1)

#defineCV_MAT_TYPE(flags)     ((flags) & CV_MAT_TYPE_MASK)

#define CV_MAT_CONT_FLAG_SHIFT  14

#defineCV_MAT_CONT_FLAG       (1 << CV_MAT_CONT_FLAG_SHIFT)

#defineCV_IS_MAT_CONT(flags)  ((flags) & CV_MAT_CONT_FLAG)

#defineCV_IS_CONT_MAT         CV_IS_MAT_CONT

#defineCV_SUBMAT_FLAG_SHIFT   15

#defineCV_SUBMAT_FLAG         (1 << CV_SUBMAT_FLAG_SHIFT)

#defineCV_IS_SUBMAT(flags)    ((flags) & CV_MAT_SUBMAT_FLAG)

//

#defineCV_MAGIC_MASK      0xFFFF0000

#defineCV_MAT_MAGIC_VAL   0x42420000

#defineCV_TYPE_NAME_MAT   "opencv-matrix"

//定义矩阵结构体

typedef struct CvMat

{

int type;

int step;

int* refcount;

int hdr_refcount;

union

{

uchar* ptr;

short* s;

int* i;

float* fl;

double* db;

} data;

#ifdef __cplusplus

union

{

int rows;

int height;

};

union

{

int cols;

int width;

};

#else

int rows;

int cols;

#endif

}

CvMat;

//判断矩阵头指针

#define CV_IS_MAT_HDR(mat)

((mat) != NULL &&

(((const CvMat*)(mat))->type &CV_MAGIC_MASK) == CV_MAT_MAGIC_VAL&&

((const CvMat*)(mat))->cols > 0&& ((constCvMat*)(mat))->rows > 0)

//

#define CV_IS_MAT_HDR_Z(mat)

((mat) != NULL &&

(((const CvMat*)(mat))->type &CV_MAGIC_MASK) == CV_MAT_MAGIC_VAL&&

((const CvMat*)(mat))->cols >= 0&& ((constCvMat*)(mat))->rows >= 0)

//

#define CV_IS_MAT(mat)

(CV_IS_MAT_HDR(mat) && ((constCvMat*)(mat))->data.ptr != NULL)

//

#define CV_IS_MASK_ARR(mat)

(((mat)->type & (CV_MAT_TYPE_MASK& ~CV_8SC1)) == 0)

#define CV_ARE_TYPES_EQ(mat1, mat2)

((((mat1)->type ^ (mat2)->type)& CV_MAT_TYPE_MASK) == 0)

//

#define CV_ARE_CNS_EQ(mat1, mat2)

((((mat1)->type ^ (mat2)->type)& CV_MAT_CN_MASK) == 0)

//

#define CV_ARE_DEPTHS_EQ(mat1, mat2)

((((mat1)->type ^ (mat2)->type)& CV_MAT_DEPTH_MASK) == 0)

//

#define CV_ARE_SIZES_EQ(mat1, mat2)

((mat1)->rows == (mat2)->rows&& (mat1)->cols ==(mat2)->cols)

#define CV_IS_MAT_CONST(mat)

(((mat)->rows|(mat)->cols) == 1)

//

#define CV_ELEM_SIZE1(type)

((((sizeof(size_t)<<28)|0x8442211)>> CV_MAT_DEPTH(type)*4)& 15)

//

#define CV_ELEM_SIZE(type)

(CV_MAT_CN(type) <<((((sizeof(size_t)/4+1)*16384|0x3a50)>> CV_MAT_DEPTH(type)*2)& 3))

//

#define IPL2CV_DEPTH(depth)

((((CV_8U)+(CV_16U<<4)+(CV_32F<<8)+(CV_64F<<16)+(CV_8S<<20)+

(CV_16S<<24)+(CV_32S<<28))>> ((((depth) & 0xF0)>> 2) +

(((depth) & IPL_DEPTH_SIGN) ? 20 : 0)))& 15)

//初始化矩阵

CV_INLINE CvMat cvMat( int rows, int cols, int type, void* dataCV_DEFAULT(NULL))

//快速将数据添加到矩阵

#define CV_MAT_ELEM_PTR_FAST( mat, row, col, pix_size)

(assert( (unsigned)(row) < (unsigned)(mat).rows&&

(unsigned)(col) < (unsigned)(mat).cols),

(mat).data.ptr + (size_t)(mat).step*(row) + (pix_size)*(col))

//快速将数据添加到矩阵（1）

#define CV_MAT_ELEM_PTR( mat, row, col)

CV_MAT_ELEM_PTR_FAST( mat, row, col, CV_ELEM_SIZE((mat).type) )

//快速将数据添加到矩阵（2）

#define CV_MAT_ELEM( mat, elemtype, row, col)

(*(elemtype*)CV_MAT_ELEM_PTR_FAST( mat, row, col,sizeof(elemtype)))

//从矩阵中获取数据

CV_INLINE double  cvmGet( const CvMat* mat, int row,int col )

//将数据添加到矩阵

CV_INLINE  void cvmSet( CvMat* mat, int row, int col, double value )

//设置矩阵数据类型

CV_INLINE int cvIplDepth( int type )

多维稠密矩阵

//

#defineCV_MATND_MAGIC_VAL   0x42430000

#defineCV_TYPE_NAME_MATND   "opencv-nd-matrix"

//

#defineCV_MAX_DIM           32

#defineCV_MAX_DIM_HEAP      (1 << 16)

//定义稠密矩阵结构体

typedef struct CvMatND

{

int type;

int dims;

int* refcount;

int hdr_refcount;

union

{

uchar* ptr;

float* fl;

double* db;

int* i;

short* s;

} data;

struct

{

int size;

int step;

}

dim[CV_MAX_DIM];

}

CvMatND;

//

#define CV_IS_MATND_HDR(mat)

((mat) != NULL && (((constCvMatND*)(mat))->type &CV_MAGIC_MASK) == CV_MATND_MAGIC_VAL)

//

#define CV_IS_MATND(mat)

(CV_IS_MATND_HDR(mat) && ((constCvMatND*)(mat))->data.ptr != NULL)

多维稀疏矩阵

//

#defineCV_SPARSE_MAT_MAGIC_VAL   0x42440000

#defineCV_TYPE_NAME_SPARSE_MAT   "opencv-sparse-matrix"

//

struct CvSet;

//定义稀疏矩阵结构体

typedef struct CvSparseMat

{

int type;

int dims;

int* refcount;

int hdr_refcount;

struct CvSet* heap;

void** hashtable;

int hashsize;

int valoffset;

int idxoffset;

int size[CV_MAX_DIM];

}

CvSparseMat;

//

#define CV_IS_SPARSE_MAT_HDR(mat)

((mat) != NULL &&

(((const CvSparseMat*)(mat))->type &CV_MAGIC_MASK) == CV_SPARSE_MAT_MAGIC_VAL)

//

#define CV_IS_SPARSE_MAT(mat)

CV_IS_SPARSE_MAT_HDR(mat)

稀疏矩阵迭代

//定义稀疏矩阵迭代体结构体

typedef struct CvSparseNode

{

unsigned hashval;

struct CvSparseNode* next;

}

CvSparseNode;

//定义稀疏矩阵迭代器

typedef struct CvSparseMatIterator

{

CvSparseMat* mat;

CvSparseNode* node;

int curidx;

}

CvSparseMatIterator;

#defineCV_NODE_VAL(mat,node)  ((void*)((uchar*)(node) + (mat)->valoffset))

#defineCV_NODE_IDX(mat,node)  ((int*)((uchar*)(node) + (mat)->idxoffset))

直方图

typedef int CvHistType;

//

#defineCV_HIST_MAGIC_VAL    0x42450000

#define CV_HIST_UNIFORM_FLAG  (1<< 10)

//维区域是否设置的标签

#defineCV_HIST_RANGES_FLAG  (1 << 11)

//定义矩阵状态

#defineCV_HIST_ARRAY        0 //数组直方图

#defineCV_HIST_SPARSE       1 //稀疏直方图

#defineCV_HIST_TREE         CV_HIST_SPARSE //树形直方图

#defineCV_HIST_UNIFORM      1

//定义直方图结构体

typedef struct CvHistogram

{

int    type;

CvArr*  bins;

float  thresh[CV_MAX_DIM][2];

float**thresh2;

CvMatNDmat;

}

CvHistogram;

//

#define CV_IS_HIST( hist )

((hist) != NULL &&

(((CvHistogram*)(hist))->type &CV_MAGIC_MASK) == CV_HIST_MAGIC_VAL&&

(hist)->bins != NULL)

//

#define CV_IS_UNIFORM_HIST( hist )

(((hist)->type &CV_HIST_UNIFORM_FLAG) != 0)

//

#define CV_IS_SPARSE_HIST( hist )

CV_IS_SPARSE_MAT((hist)->bins)

//

#define CV_HIST_HAS_RANGES( hist )

(((hist)->type &CV_HIST_RANGES_FLAG) != 0)

//

其他数据类型应用定义------矩形

//定义矩形结构体

typedef struct CvRect

{

int x;

int y;

int width;

int height;

}

CvRect;

//矩形初始化

CV_INLINE CvRect  cvRect( int x, int y, int width,int height )

{

CvRect r;

r.x = x;

r.y = y;

r.width = width;

r.height = height;

return r;

}

//在感兴趣通道上设置图的感兴趣区域

CV_INLINE IplROI  cvRectToROI( CvRect rect, int coi)

//获取感兴趣区域的矩形大小

CV_INLINE CvRect  cvROIToRect( IplROI roi )

其他数据类型应用定义------终止准则

//

#defineCV_TERMCRIT_ITER   1

#define CV_TERMCRIT_NUMBER CV_TERMCRIT_ITER

#defineCV_TERMCRIT_EPS    2

//定义迭代算法的终止准则结构体

typedef struct CvTermCriteria

{

int   type;

int   max_iter;

double epsilon;

}

CvTermCriteria;

//初始化终止准则

CV_INLINE CvTermCriteria  cvTermCriteria( int type,int max_iter, double epsilon )

其他数据类型应用定义------点和变量

//定义整型二维点

typedef struct CvPoint

{

int x;

int y;

}

CvPoint;

//初始化二维点

CV_INLINE CvPoint  cvPoint( int x, int y )

{

CvPoint p;

p.x = x;

p.y = y;

return p;

}

//定义浮点型二维点

typedef struct CvPoint2D32f

{

float x;

float y;

}

CvPoint2D32f;

//初始化浮点型二维点

CV_INLINE CvPoint2D32f  cvPoint2D32f( double x,double y )

{

CvPoint2D32f p;

p.x = (float)x;

p.y = (float)y;

return p;

}

//

CV_INLINE CvPoint2D32f  cvPointTo32f( CvPoint point)

{

return cvPoint2D32f( (float)point.x, (float)point.y );

}

CV_INLINE CvPoint  cvPointFrom32f( CvPoint2D32f point)

{

CvPoint ipt;

ipt.x = cvRound(point.x);

ipt.y = cvRound(point.y);

return ipt;

}

//定义浮点型三维点

typedef struct CvPoint3D32f

{

float x;

float y;

float z;

}

CvPoint3D32f;

//初始化浮点型三维点

CV_INLINE CvPoint3D32f  cvPoint3D32f( double x,double y, double z )

{

CvPoint3D32f p;

p.x = (float)x;

p.y = (float)y;

p.z = (float)z;

return p;

}

//定义双精度型二维点

typedef struct CvPoint2D64f

{

double x;

double y;

}

CvPoint2D64f;

//初始化双精度型二维点

CV_INLINE CvPoint2D64f  cvPoint2D64f( double x,double y )

{

CvPoint2D64f p;

p.x = x;

p.y = y;

return p;

}

//定义双精度型三维点

typedef struct CvPoint3D64f

{

double x;

double y;

double z;

}

CvPoint3D64f;

//初始化双精度型三维点

CV_INLINE CvPoint3D64f  cvPoint3D64f( double x,double y, double z )

{

CvPoint3D64f p;

p.x = x;

p.y = y;

p.z = z;

return p;

}

其他数据类型应用定义------size变量和Box箱变量

//定义size

typedef struct

{

int width;

int height;

}

CvSize;

//初始化size

CV_INLINE CvSize  cvSize( int width, int height )

{

CvSize s;

s.width = width;

s.height = height;

return s;

}

//定义二维浮点型size

typedef struct CvSize2D32f

{

float width;

float height;

}

CvSize2D32f;

//初始化二维浮点型size

CV_INLINE CvSize2D32f  cvSize2D32f( double width,double height )

{

CvSize2D32f s;

s.width = (float)width;

s.height = (float)height;

return s;

}

//定义二维箱

typedef struct CvBox2D

{

CvPoint2D32f center;

CvSize2D32f size;

floatangle;

}

CvBox2D;

//定义线性迭代状态

typedef struct CvLineIterator

{

uchar* ptr;

int  err;

int  plus_delta;

int  minus_delta;

int  plus_step;

int  minus_step;

}

CvLineIterator;

其他数据类型应用定义------片，部分

//定义片

typedef struct CvSlice

{

int  start_index, end_index;

}

CvSlice;

//初始化片

CV_INLINE CvSlice  cvSlice( int start, int end )

{

CvSlice slice;

slice.start_index = start;

slice.end_index = end;

return slice;

}

#define CV_WHOLE_SEQ_END_INDEX 0x3fffffff

#define CV_WHOLE_SEQ  cvSlice(0,CV_WHOLE_SEQ_END_INDEX)

其他数据类型应用定义------尺度，角度

//定义角度结构体

typedef struct CvScalar

{

double val[4];

}

CvScalar;

//初始化角度

CV_INLINE CvScalar  cvScalar( double val0, doubleval1 CV_DEFAULT(0),

double val2 CV_DEFAULT(0), double val3 CV_DEFAULT(0))

{

CvScalar scalar;

scalar.val[0] = val0; scalar.val[1] = val1;

scalar.val[2] = val2; scalar.val[3] = val3;

return scalar;

}

CV_INLINE CvScalar  cvRealScalar( double val0 )

{

CvScalar scalar;

scalar.val[0] = val0;

scalar.val[1] = scalar.val[2] = scalar.val[3] = 0;

return scalar;

}

CV_INLINE CvScalar  cvScalarAll( double val0123 )

{

CvScalar scalar;

scalar.val[0] = val0123;

scalar.val[1] = val0123;

scalar.val[2] = val0123;

scalar.val[3] = val0123;

return scalar;

}

动态数据结构-内存存储

//定义内存块结构

typedef struct CvMemBlock

{

struct CvMemBlock*  prev;

struct CvMemBlock*  next;

}

CvMemBlock;

#defineCV_STORAGE_MAGIC_VAL   0x42890000

typedef struct CvMemStorage

{

int signature;

CvMemBlock*bottom;

CvMemBlock*top;

struct  CvMemStorage* parent;

intblock_size;

intfree_space;

}

CvMemStorage;

#define CV_IS_STORAGE(storage)

((storage) != NULL&&

(((CvMemStorage*)(storage))->signature& CV_MAGIC_MASK) == CV_STORAGE_MAGIC_VAL)

typedef struct CvMemStoragePos

{

CvMemBlock* top;

int free_space;

}

CvMemStoragePos;

动态数据结构-序列（线性）

//定义序列块结构体

typedef struct CvSeqBlock

{

struct CvSeqBlock*  prev;

struct CvSeqBlock*  next;

int   start_index;

int   count;

schar*data;

}

CvSeqBlock;

//定义序列节点

#defineCV_TREE_NODE_FIELDS(node_type)

int      flags;

int      header_size;

struct   node_type* h_prev;

struct   node_type* h_next;

struct   node_type* v_prev;

struct   node_type* v_next

//读和写序列（动态的添加和删除元素）                            #defineCV_SEQUENCE_FIELDS()

CV_TREE_NODE_FIELDS(CvSeq);

int      total;

int      elem_size;

schar*   block_max;

schar*   ptr;

int      delta_elems;

CvMemStorage*storage;

CvSeqBlock* free_blocks;

CvSeqBlock*first;

//定义序列结构体

typedef struct CvSeq

{

CV_SEQUENCE_FIELDS()

}

CvSeq;

#defineCV_TYPE_NAME_SEQ            "opencv-sequence"

#defineCV_TYPE_NAME_SEQ_TREE       "opencv-sequence-tree"

动态数据结构-节点（集）

（节点顺序是不被保护的，他们可看成介于元素间的空隙，但被插入后就保留在该地方，判断有元素，看MSB‘mose-significantor sign bit’的标志位）

//定义序列节点属性

#defineCV_SET_ELEM_FIELDS(elem_type)

int flags;

struct elem_type* next_free;

//设置序列元素

typedef struct CvSetElem

{

CV_SET_ELEM_FIELDS(CvSetElem)

}

CvSetElem;

//

#defineCV_SET_FIELDS()

CV_SEQUENCE_FIELDS()

CvSetElem*free_elems;

int active_count;

//

typedef struct CvSet

{

CV_SET_FIELDS()

}

CvSet;

#define CV_SET_ELEM_IDX_MASK  ((1 << 26) -1)

#define CV_SET_ELEM_FREE_FLAG  (1<< (sizeof(int)*8-1))

//定义元素指针被设置与否

#define CV_IS_SET_ELEM( ptr ) (((CvSetElem*)(ptr))->flags >= 0)

动态数据结构-图结构

//定义图边属性

#defineCV_GRAPH_EDGE_FIELDS()

intflags;

floatweight;

struct CvGraphEdge*next[2];

struct CvGraphVtx* vtx[2];

//定义图节点属性

#defineCV_GRAPH_VERTEX_FIELDS()

intflags;

struct CvGraphEdge* first;

//定义图边结构体

typedef struct CvGraphEdge

{

CV_GRAPH_EDGE_FIELDS()

}

CvGraphEdge;

//定义图节点结构体

typedef struct CvGraphVtx

{

CV_GRAPH_VERTEX_FIELDS()

}

CvGraphVtx;

//定义二维图

typedef struct CvGraphVtx2D

{

CV_GRAPH_VERTEX_FIELDS()

CvPoint2D32f* ptr;

}

CvGraphVtx2D;

//定义图属性

#define CV_GRAPH_FIELDS()

CV_SET_FIELDS()

CvSet* edges;

//定义图结构

typedef struct CvGraph

{

CV_GRAPH_FIELDS()

}

CvGraph;

#define CV_TYPE_NAME_GRAPH "opencv-graph"

动态数据结构-链和轮廓

//定义链结构

typedef struct CvChain

{

CV_SEQUENCE_FIELDS()

CvPoint  origin;

}

CvChain;

//定义轮廓属性

#define CV_CONTOUR_FIELDS()

CV_SEQUENCE_FIELDS()

CvRectrect;

intcolor;

int reserved[3];

//定义轮廓结构体

typedef struct CvContour

{

CV_CONTOUR_FIELDS()

}

CvContour;

typedef CvContour CvPoint2DSeq;

序列类型

//表示稠密序列

#defineCV_SEQ_MAGIC_VAL            0x42990000

#define CV_IS_SEQ(seq)

((seq) != NULL &&(((CvSeq*)(seq))->flags &CV_MAGIC_MASK) == CV_SEQ_MAGIC_VAL)

//表示稀疏序列

#defineCV_SET_MAGIC_VAL            0x42980000

#define CV_IS_SET(set)

((set) != NULL &&(((CvSeq*)(set))->flags &CV_MAGIC_MASK) == CV_SET_MAGIC_VAL)

//表示稠密序列元素位数

#defineCV_SEQ_ELTYPE_BITS          12

#defineCV_SEQ_ELTYPE_MASK          ((1 << CV_SEQ_ELTYPE_BITS) - 1)

//

#defineCV_SEQ_ELTYPE_POINT         CV_32SC2

#defineCV_SEQ_ELTYPE_CODE          CV_8UC1

//

#defineCV_SEQ_ELTYPE_GENERIC       0

#defineCV_SEQ_ELTYPE_PTR           CV_USRTYPE1

#defineCV_SEQ_ELTYPE_PPOINT        CV_SEQ_ELTYPE_PTR

#defineCV_SEQ_ELTYPE_INDEX         CV_32SC1

#defineCV_SEQ_ELTYPE_GRAPH_EDGE    0

#defineCV_SEQ_ELTYPE_GRAPH_VERTEX  0

#defineCV_SEQ_ELTYPE_TRIAN_ATR     0

#define CV_SEQ_ELTYPE_CONNECTED_COMP0

#defineCV_SEQ_ELTYPE_POINT3D       CV_32FC3

//表示稠密序列类型位数

#defineCV_SEQ_KIND_BITS       2

#defineCV_SEQ_KIND_MASK       (((1 << CV_SEQ_KIND_BITS) -1)<<CV_SEQ_ELTYPE_BITS)

//稠密序列的三种类型

#defineCV_SEQ_KIND_GENERIC    (0 << CV_SEQ_ELTYPE_BITS)

#defineCV_SEQ_KIND_CURVE      (1 << CV_SEQ_ELTYPE_BITS)

#defineCV_SEQ_KIND_BIN_TREE   (2 << CV_SEQ_ELTYPE_BITS)

//稀疏序列的三种类型

#defineCV_SEQ_KIND_GRAPH      (1 << CV_SEQ_ELTYPE_BITS)

#defineCV_SEQ_KIND_SUBDIV2D   (2 << CV_SEQ_ELTYPE_BITS)

#defineCV_SEQ_FLAG_SHIFT      (CV_SEQ_KIND_BITS + CV_SEQ_ELTYPE_BITS)

//曲线序列的类型标志

#defineCV_SEQ_FLAG_CLOSED    (1 << CV_SEQ_FLAG_SHIFT)

#defineCV_SEQ_FLAG_SIMPLE    (0 << CV_SEQ_FLAG_SHIFT)

#defineCV_SEQ_FLAG_CONVEX    (0 << CV_SEQ_FLAG_SHIFT)

#defineCV_SEQ_FLAG_HOLE      (2 << CV_SEQ_FLAG_SHIFT)

//图序列的类型标志

#define CV_GRAPH_FLAG_ORIENTED (1<< CV_SEQ_FLAG_SHIFT)

#defineCV_GRAPH              CV_SEQ_KIND_GRAPH

#defineCV_ORIENTED_GRAPH     (CV_SEQ_KIND_GRAPH|CV_GRAPH_FLAG_ORIENTED)

//定义点集

#defineCV_SEQ_POINT_SET      (CV_SEQ_KIND_GENERIC| CV_SEQ_ELTYPE_POINT)

#defineCV_SEQ_POINT3D_SET    (CV_SEQ_KIND_GENERIC| CV_SEQ_ELTYPE_POINT3D)

#defineCV_SEQ_POLYLINE       (CV_SEQ_KIND_CURVE  |CV_SEQ_ELTYPE_POINT)

#defineCV_SEQ_POLYGON        (CV_SEQ_FLAG_CLOSED | CV_SEQ_POLYLINE )

#defineCV_SEQ_CONTOUR        CV_SEQ_POLYGON

#define CV_SEQ_SIMPLE_POLYGON (CV_SEQ_FLAG_SIMPLE | CV_SEQ_POLYGON  )

//定义曲线链表

#defineCV_SEQ_CHAIN          (CV_SEQ_KIND_CURVE  |CV_SEQ_ELTYPE_CODE)

#defineCV_SEQ_CHAIN_CONTOUR  (CV_SEQ_FLAG_CLOSED | CV_SEQ_CHAIN)

//用二叉树表示轮廓集

#defineCV_SEQ_POLYGON_TREE   (CV_SEQ_KIND_BIN_TREE  |CV_SEQ_ELTYPE_TRIAN_ATR)

//连接部分的序列表示

#define CV_SEQ_CONNECTED_COMP (CV_SEQ_KIND_GENERIC  |CV_SEQ_ELTYPE_CONNECTED_COMP)

//整数表示的序列

#defineCV_SEQ_INDEX          (CV_SEQ_KIND_GENERIC | CV_SEQ_ELTYPE_INDEX)

#define CV_SEQ_ELTYPE( seq)  ((seq)->flags &CV_SEQ_ELTYPE_MASK)

#define CV_SEQ_KIND( seq)    ((seq)->flags & CV_SEQ_KIND_MASK)

//标记检测

#define CV_IS_SEQ_INDEX( seq)     ((CV_SEQ_ELTYPE(seq) == CV_SEQ_ELTYPE_INDEX)&&

(CV_SEQ_KIND(seq) == CV_SEQ_KIND_GENERIC))

#define CV_IS_SEQ_CURVE( seq)     (CV_SEQ_KIND(seq) == CV_SEQ_KIND_CURVE)

#define CV_IS_SEQ_CLOSED( seq)    (((seq)->flags & CV_SEQ_FLAG_CLOSED)!= 0)

#define CV_IS_SEQ_CONVEX( seq)    0

#define CV_IS_SEQ_HOLE( seq)      (((seq)->flags & CV_SEQ_FLAG_HOLE)!= 0)

#define CV_IS_SEQ_SIMPLE( seq)    1

//类型检测

#define CV_IS_SEQ_POINT_SET( seq )

((CV_SEQ_ELTYPE(seq) == CV_32SC2 || CV_SEQ_ELTYPE(seq) ==CV_32FC2))

#define CV_IS_SEQ_POINT_SUBSET( seq )

(CV_IS_SEQ_INDEX( seq ) || CV_SEQ_ELTYPE(seq) ==CV_SEQ_ELTYPE_PPOINT)

#define CV_IS_SEQ_POLYLINE( seq)

(CV_SEQ_KIND(seq) == CV_SEQ_KIND_CURVE&& CV_IS_SEQ_POINT_SET(seq))

#define CV_IS_SEQ_POLYGON( seq)

(CV_IS_SEQ_POLYLINE(seq) &&CV_IS_SEQ_CLOSED(seq))

#define CV_IS_SEQ_CHAIN( seq)

(CV_SEQ_KIND(seq) == CV_SEQ_KIND_CURVE&& (seq)->elem_size== 1)

#define CV_IS_SEQ_CONTOUR( seq )

(CV_IS_SEQ_CLOSED(seq) &&(CV_IS_SEQ_POLYLINE(seq) || CV_IS_SEQ_CHAIN(seq)))

#define CV_IS_SEQ_CHAIN_CONTOUR( seq )

(CV_IS_SEQ_CHAIN( seq ) &&CV_IS_SEQ_CLOSED( seq ))

#define CV_IS_SEQ_POLYGON_TREE( seq )

(CV_SEQ_ELTYPE (seq) == CV_SEQ_ELTYPE_TRIAN_ATR&&

CV_SEQ_KIND( seq ) ==  CV_SEQ_KIND_BIN_TREE)

#define CV_IS_GRAPH( seq)

(CV_IS_SET(seq) &&CV_SEQ_KIND((CvSet*)(seq)) == CV_SEQ_KIND_GRAPH)

#define CV_IS_GRAPH_ORIENTED( seq)

(((seq)->flags &CV_GRAPH_FLAG_ORIENTED) != 0)

#define CV_IS_SUBDIV2D( seq )

(CV_IS_SET(seq) &&CV_SEQ_KIND((CvSet*)(seq)) == CV_SEQ_KIND_SUBDIV2D)

序列的读/写操作

//定义序列写的属性

#defineCV_SEQ_WRITER_FIELDS()

int         header_size;

CvSeq*      seq;

CvSeqBlock* block;

schar*      ptr;

schar*      block_min;

schar*      block_max;

//定义序列写结构体

typedef struct CvSeqWriter

{

CV_SEQ_WRITER_FIELDS()

}

CvSeqWriter;

//定义序列读的属性

#defineCV_SEQ_READER_FIELDS()

int         header_size;

CvSeq*      seq;

CvSeqBlock* block;

schar*      ptr;

schar*      block_min;

schar*      block_max;

int         delta_index;

schar*      prev_elem;

//定义序列读的结构体

typedef struct CvSeqReader

{

CV_SEQ_READER_FIELDS()

}

CvSeqReader;

对序列的操作

#define  CV_SEQ_ELEM( seq, elem_type,index)

(  assert(sizeof((seq)->first[0]) == sizeof(CvSeqBlock)&&

(seq)->elem_size ==sizeof(elem_type)),

(elem_type*)((seq)->first&& (unsigned)index<

(unsigned)((seq)->first->count)?

(seq)->first->data + (index) *sizeof(elem_type):

cvGetSeqElem( (CvSeq*)(seq), (index) )))

#define CV_GET_SEQ_ELEM( elem_type, seq, index ) CV_SEQ_ELEM((seq), elem_type, (index) )

//在序列中增加元素

#define CV_WRITE_SEQ_ELEM_VAR( elem_ptr, writer)

{

if( (writer).ptr >= (writer).block_max)

{

cvCreateSeqBlock(&writer);

}

memcpy((writer).ptr, elem_ptr,(writer).seq->elem_size);

(writer).ptr +=(writer).seq->elem_size;

}

#define CV_WRITE_SEQ_ELEM( elem, writer)

{

assert( (writer).seq->elem_size == sizeof(elem));

if( (writer).ptr >= (writer).block_max)

{

cvCreateSeqBlock(&writer);

}

assert( (writer).ptr <= (writer).block_max -sizeof(elem));

memcpy((writer).ptr, &(elem),sizeof(elem));

(writer).ptr +=sizeof(elem);

}

//向前移动读序列位置

#define CV_NEXT_SEQ_ELEM( elem_size, reader)

{

if( ((reader).ptr += (elem_size)) >=(reader).block_max )

{

cvChangeSeqBlock( &(reader), 1);

}

}

//向前移动读序列位置

#define CV_PREV_SEQ_ELEM( elem_size, reader)

{

if( ((reader).ptr -= (elem_size)) <(reader).block_min )

{

cvChangeSeqBlock( &(reader), -1);

}

}

//读序列中元素并向前移动读位置

#define CV_READ_SEQ_ELEM( elem, reader)

{

assert( (reader).seq->elem_size ==sizeof(elem));

memcpy( &(elem), (reader).ptr,sizeof((elem)));

CV_NEXT_SEQ_ELEM( sizeof(elem), reader)

}

//读序列中元素并向前移动读位置

#define CV_REV_READ_SEQ_ELEM( elem, reader)

{

assert( (reader).seq->elem_size ==sizeof(elem));

memcpy(&(elem), (reader).ptr,sizeof((elem)));

CV_PREV_SEQ_ELEM( sizeof(elem), reader)

}

#define CV_READ_CHAIN_POINT( _pt, reader)

{

(_pt) =(reader).pt;

if( (reader).ptr)

{

CV_READ_SEQ_ELEM( (reader).code,(reader));

assert( ((reader).code & ~7) == 0);

(reader).pt.x +=(reader).deltas[(int)(reader).code][0];

(reader).pt.y +=(reader).deltas[(int)(reader).code][1];

}

}

#define CV_CURRENT_POINT( reader ) (*((CvPoint*)((reader).ptr)))

#define CV_PREV_POINT( reader)    (*((CvPoint*)((reader).prev_elem)))

//读边序列

#define CV_READ_EDGE( pt1, pt2, reader)

{

assert( sizeof(pt1) == sizeof(CvPoint)&&

sizeof(pt2) == sizeof(CvPoint)&&

reader.seq->elem_size == sizeof(CvPoint));

(pt1) = CV_PREV_POINT( reader);

(pt2) = CV_CURRENT_POINT( reader);

(reader).prev_elem =(reader).ptr;

CV_NEXT_SEQ_ELEM( sizeof(CvPoint),(reader));

}

对序列的操作-图的微操作

//返回给定顶点的图边缘

#define  CV_NEXT_GRAPH_EDGE( edge,vertex )

(assert((edge)->vtx[0] == (vertex) ||(edge)->vtx[1] ==(vertex)),

(edge)->next[(edge)->vtx[1] ==(vertex)])

保持数据结构的连续性的说明

//文件存储的“黑箱”定义

typedef struct CvFileStorage CvFileStorage;

//存储标记

#defineCV_STORAGE_READ         0

#defineCV_STORAGE_WRITE        1

#defineCV_STORAGE_WRITE_TEXT   CV_STORAGE_WRITE

#define CV_STORAGE_WRITE_BINARY CV_STORAGE_WRITE

#defineCV_STORAGE_APPEND       2

//属性列表

typedef struct CvAttrList

{

const char**attr;

struct CvAttrList*next;

}

CvAttrList;

CV_INLINE CvAttrList cvAttrList( const char** attrCV_DEFAULT(NULL),

CvAttrList* next CV_DEFAULT(NULL) )

{

CvAttrList l;

l.attr = attr;

l.next = next;

return l;

}

struct CvTypeInfo;

#defineCV_NODE_NONE       0

#defineCV_NODE_INT        1

#defineCV_NODE_INTEGER    CV_NODE_INT

#defineCV_NODE_REAL       2

#defineCV_NODE_FLOAT      CV_NODE_REAL

#defineCV_NODE_STR        3

#defineCV_NODE_STRING     CV_NODE_STR

#defineCV_NODE_REF        4

#defineCV_NODE_SEQ        5

#defineCV_NODE_MAP        6

#defineCV_NODE_TYPE_MASK  7

#define CV_NODE_TYPE(flags)  ((flags)& CV_NODE_TYPE_MASK)

#defineCV_NODE_FLOW       8

#defineCV_NODE_USER       16

#defineCV_NODE_EMPTY      32

#defineCV_NODE_NAMED      64

#defineCV_NODE_IS_INT(flags)       (CV_NODE_TYPE(flags) == CV_NODE_INT)

#defineCV_NODE_IS_REAL(flags)      (CV_NODE_TYPE(flags) == CV_NODE_REAL)

#defineCV_NODE_IS_STRING(flags)    (CV_NODE_TYPE(flags) == CV_NODE_STRING)

#defineCV_NODE_IS_SEQ(flags)       (CV_NODE_TYPE(flags) == CV_NODE_SEQ)

#defineCV_NODE_IS_MAP(flags)       (CV_NODE_TYPE(flags) == CV_NODE_MAP)

#define CV_NODE_IS_COLLECTION(flags) (CV_NODE_TYPE(flags)>= CV_NODE_SEQ)

#defineCV_NODE_IS_FLOW(flags)      (((flags) & CV_NODE_FLOW) != 0)

#defineCV_NODE_IS_EMPTY(flags)     (((flags) & CV_NODE_EMPTY) != 0)

#defineCV_NODE_IS_USER(flags)      (((flags) & CV_NODE_USER) != 0)

#defineCV_NODE_HAS_NAME(flags)     (((flags) & CV_NODE_NAMED) != 0)

#define CV_NODE_SEQ_SIMPLE 256

#define CV_NODE_SEQ_IS_SIMPLE(seq) (((seq)->flags& CV_NODE_SEQ_SIMPLE) != 0)

typedef struct CvString

{

int len;

char* ptr;

}

CvString;

//所有的元素名字以哈希表中，增加搜索速度

typedef struct CvStringHashNode{

unsigned hashval;

CvString str;

struct CvStringHashNode* next;

}

CvStringHashNode;

typedef struct CvGenericHash CvFileNodeHash;

typedef struct CvFileNode

{

int tag;

struct CvTypeInfo* info;

union

{

double f;

inti;

CvString str;

CvSeq* seq;

CvFileNodeHash* map;

} data;

}

CvFileNode;

#ifdef __cplusplus

extern "C" {

#endif

typedef int (CV_CDECL *CvIsInstanceFunc)( const void* struct_ptr);

typedef void (CV_CDECL *CvReleaseFunc)( void** struct_dblptr);

typedef void* (CV_CDECL *CvReadFunc)( CvFileStorage* storage,CvFileNode* node );

typedef void (CV_CDECL *CvWriteFunc)( CvFileStorage* storage,const char* name,

const void* struct_ptr, CvAttrList attributes );

typedef void* (CV_CDECL *CvCloneFunc)( const void* struct_ptr);

#ifdef __cplusplus

}

#endif

typedef struct CvTypeInfo

{

int flags;

int header_size;

struct CvTypeInfo* prev;

struct CvTypeInfo* next;

const char* type_name;

CvIsInstanceFunc is_instance;

CvReleaseFunc release;

CvReadFunc read;

CvWriteFunc write;

CvCloneFunc clone;

}

CvTypeInfo;

系统数据类型

typedef struct CvPluginFuncInfo

{

void** func_addr;

void* default_func_addr;

const char* func_names;

int search_modules;

int loaded_from;

}

CvPluginFuncInfo;

typedef struct CvModuleInfo

{

struct CvModuleInfo* next;

const char* name;

const char* version;

CvPluginFuncInfo* func_tab;

}

CvModuleInfo;

opencv2.2.0源代码（include文件）分析相关推荐

1. vue 1.0源代码重点难点分析

   本文分析vue1.0源代码从入口开始到编译输出到网页显示生效的整个过程,并重点分析一些vue源代码设计原理. vue初始化根组件的入口代码: 对于没有路由的单页应用来说,入口就是new Vue(opt ...

2. Fabric 1.0源代码分析(22)Ledger #blkstorage（block文件存储）

   # Fabric 1.0源代码笔记 之 Ledger #blkstorage(block文件存储) ## blkstorage概述 blkstorage,默认目录/var/hyperledger/pr ...

3. Fabric 1.0源代码分析(2) blockfile（区块文件存储）

   # Fabric 1.0源代码笔记 之 blockfile(区块文件存储) ## 1.blockfile概述 blockfile,即Fabric区块链区块文件存储,默认目录/var/hyperledg ...

4. 熊海CMS_V1.0代码审计与漏洞分析及采坑日记（一）--文件包含漏洞

   前言 最近几天在给协会的学弟讲代码审计入门相关内容,便找了这个熊海CMS_V1.0来教学,结果在这个过程中遇到蛮多问题的,于是这篇文章详细记录了对熊海CMS_V1.0从搭建到审计与漏洞分析的过程,其中 ...

5. PE文件和COFF文件格式分析--MS-DOS 2.0兼容Exe文件段

   MS 2.0节是PE文件格式中第一个"节".其大致结构如下:(转载请指明来源于breaksoftware的csdn博客) 在VC\PlatformSDK\Include\WinNT ...

6. 区块链教程Fabric1.0源代码分析Peer peer channel命令及子命令实现

   区块链教程Fabric1.0源代码分析Peer peer channel命令及子命令实现,2018年下半年,区块链行业正逐渐褪去发展之初的浮躁.回归理性,表面上看相关人才需求与身价似乎正在回落.但事实 ...

7. SRS4.0源代码分析之RTMP拉流处理

   目标: 上一节分析了SRS针对推流客户端的处理逻辑,这里接下来分析针对拉流客户端的处理逻辑. SRS拉流端处理逻辑简单说就是SrsRtmpConn::do_playing()协程从SrsLiveCon ...

8. 5、SRS4.0源代码分析之RTMP拉流处理

   目标: 上一节分析了SRS针对推流客户端的处理逻辑,这里接下来分析针对拉流客户端的处理逻辑. SRS拉流端处理逻辑简单说就是SrsRtmpConn::do_playing()协程从SrsLiveCon ...

9. 4、SRS4.0源代码分析之RTMP推流处理

   目标:     本章我们将分析SRS4.0 RTMP服务模块与推流相关的代码处理逻辑. 内容:     根据上节内容可知,SRS4.0针对RTMP推流客户端的处理逻辑,主要在协程SrsRtmpConn ...

最新文章

1. 从网页的控制台登录云服务器ECS中的Ubuntu系统
2. vs c# release调试
3. logstic 回归文章链接
4. Provisioning profile XXXX can't be found
5. EfficientNet 解析：卷积神经网络模型尺度变换的反思
6. 基于 Linux 的文件操作 网络编程的最后一环
7. 三个关于“契约精神”的故事（转）
8. Flume之介绍 核心组件 可靠性 恢复性
9. 【三维路径规划】基于matlab麻雀算法求解无人机三维航迹优化问题【含Matlab源码 301期】
10. 爱加密加固病毒分析-脱壳篇
11. 百度面试题：求绝对值最小的数
12. 【计算机英语】期末复习笔记
13. 短视频APP开发功能介绍
14. html布局直接填充,css实现自动填充布局
15. Greenplum -- 最全分区表操作
16. 前端Vue页面加水印方法(带源码)
17. Hello, World! 发明者布莱恩·W.克尼汉的传奇人生
18. CSU2104: Extra Judicial Operation-Tarjan边双联通分量缩点两种方法-难受的bug
19. JavaScript伪数组和数组
20. 内蒙古职称计算机考试文件,2017年内蒙古职称计算机考试复习：word2003（三）

热门文章

1. Angularjs controller之间的通信
2. update语句中使用子查询
3. 揭秘继承技术之虚函数
4. weblogic数据源配置的问题,weblogic密码破解
5. STL vector容器
6. [摘记]数值方法04——函数求值
7. 小程序中textarea点击按钮事件
8. 错误: 找不到或无法加载主类 com.leyou.LeyouItemApplication Process finished with exit code 1...
9. 递归函数实现二分查找法
10. IIS中“使用 XSL 样式表无法查看 XML 输入”问题的解决