From cf2a3436fe9120ab05eca520afb3bc0563e5ae88 Mon Sep 17 00:00:00 2001 From: Lukas Herman Date: Sat, 4 Jan 2020 18:49:33 -0800 Subject: [PATCH] Merge github.com/pion/codec --- .clang-format | 106 +++ .gitmodules | 3 + Makefile | 18 + cvendor/include/openh264/codec_api.h | 592 +++++++++++++++++ cvendor/include/openh264/codec_app_def.h | 810 +++++++++++++++++++++++ cvendor/include/openh264/codec_def.h | 215 ++++++ cvendor/include/openh264/codec_ver.h | 15 + cvendor/lib/openh264/libopenh264.a | Bin 0 -> 2164292 bytes cvendor/src/openh264 | 1 + go.mod | 2 +- go.sum | 3 - pkg/codec/codec.go | 13 + pkg/codec/h264/bridge.cpp | 123 ++++ pkg/codec/h264/bridge.hpp | 37 ++ pkg/codec/h264/h264.go | 78 +++ track.go | 4 +- 16 files changed, 2014 insertions(+), 6 deletions(-) create mode 100644 .clang-format create mode 100644 .gitmodules create mode 100644 Makefile create mode 100644 cvendor/include/openh264/codec_api.h create mode 100644 cvendor/include/openh264/codec_app_def.h create mode 100644 cvendor/include/openh264/codec_def.h create mode 100644 cvendor/include/openh264/codec_ver.h create mode 100644 cvendor/lib/openh264/libopenh264.a create mode 160000 cvendor/src/openh264 create mode 100644 pkg/codec/codec.go create mode 100644 pkg/codec/h264/bridge.cpp create mode 100644 pkg/codec/h264/bridge.hpp create mode 100644 pkg/codec/h264/h264.go diff --git a/.clang-format b/.clang-format new file mode 100644 index 0000000..01bb3e2 --- /dev/null +++ b/.clang-format @@ -0,0 +1,106 @@ +--- +Language: Cpp +# BasedOnStyle: LLVM +AccessModifierOffset: -2 +AlignAfterOpenBracket: Align +AlignConsecutiveAssignments: false +AlignConsecutiveDeclarations: false +AlignEscapedNewlines: Right +AlignOperands: true +AlignTrailingComments: true +AllowAllParametersOfDeclarationOnNextLine: true +AllowShortBlocksOnASingleLine: false +AllowShortCaseLabelsOnASingleLine: false +AllowShortFunctionsOnASingleLine: All +AllowShortIfStatementsOnASingleLine: false +AllowShortLoopsOnASingleLine: false +AlwaysBreakAfterDefinitionReturnType: None +AlwaysBreakAfterReturnType: None +AlwaysBreakBeforeMultilineStrings: false +AlwaysBreakTemplateDeclarations: false +BinPackArguments: true +BinPackParameters: true +BraceWrapping: + AfterClass: false + AfterControlStatement: false + AfterEnum: false + AfterFunction: false + AfterNamespace: false + AfterObjCDeclaration: false + AfterStruct: false + AfterUnion: false + BeforeCatch: false + BeforeElse: false + IndentBraces: false + SplitEmptyFunction: true + SplitEmptyRecord: true + SplitEmptyNamespace: true +BreakBeforeBinaryOperators: None +BreakBeforeBraces: Attach +BreakBeforeInheritanceComma: false +BreakBeforeTernaryOperators: true +BreakConstructorInitializersBeforeComma: false +BreakConstructorInitializers: BeforeColon +BreakAfterJavaFieldAnnotations: false +BreakStringLiterals: true +ColumnLimit: 120 +CommentPragmas: '^ IWYU pragma:' +CompactNamespaces: false +ConstructorInitializerAllOnOneLineOrOnePerLine: false +ConstructorInitializerIndentWidth: 4 +ContinuationIndentWidth: 4 +Cpp11BracedListStyle: true +DerivePointerAlignment: false +DisableFormat: false +ExperimentalAutoDetectBinPacking: false +FixNamespaceComments: true +ForEachMacros: + - foreach + - Q_FOREACH + - BOOST_FOREACH +IncludeCategories: + - Regex: '^"(llvm|llvm-c|clang|clang-c)/' + Priority: 2 + - Regex: '^(<|"(gtest|gmock|isl|json)/)' + Priority: 3 + - Regex: '.*' + Priority: 1 +IncludeIsMainRegex: '(Test)?$' +IndentCaseLabels: false +IndentWidth: 2 +IndentWrappedFunctionNames: false +JavaScriptQuotes: Leave +JavaScriptWrapImports: true +KeepEmptyLinesAtTheStartOfBlocks: true +MacroBlockBegin: '' +MacroBlockEnd: '' +MaxEmptyLinesToKeep: 1 +NamespaceIndentation: None +ObjCBlockIndentWidth: 2 +ObjCSpaceAfterProperty: false +ObjCSpaceBeforeProtocolList: true +PenaltyBreakAssignment: 2 +PenaltyBreakBeforeFirstCallParameter: 19 +PenaltyBreakComment: 300 +PenaltyBreakFirstLessLess: 120 +PenaltyBreakString: 1000 +PenaltyExcessCharacter: 1000000 +PenaltyReturnTypeOnItsOwnLine: 60 +PointerAlignment: Right +ReflowComments: true +SortIncludes: true +SortUsingDeclarations: true +SpaceAfterCStyleCast: false +SpaceAfterTemplateKeyword: true +SpaceBeforeAssignmentOperators: true +SpaceBeforeParens: ControlStatements +SpaceInEmptyParentheses: false +SpacesBeforeTrailingComments: 1 +SpacesInAngles: false +SpacesInContainerLiterals: true +SpacesInCStyleCastParentheses: false +SpacesInParentheses: false +SpacesInSquareBrackets: false +Standard: Cpp11 +TabWidth: 8 +UseTab: Never \ No newline at end of file diff --git a/.gitmodules b/.gitmodules new file mode 100644 index 0000000..52c8240 --- /dev/null +++ b/.gitmodules @@ -0,0 +1,3 @@ +[submodule "cvendor/src/openh264"] + path = cvendor/src/openh264 + url = https://github.com/cisco/openh264.git diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..18b8b15 --- /dev/null +++ b/Makefile @@ -0,0 +1,18 @@ +vendor_dir = cvendor +src_dir = $(vendor_dir)/src +lib_dir = $(vendor_dir)/lib +include_dir = $(vendor_dir)/include + +vendor: create_out_dirs openh264 + +openh264: $(src_dir)/openh264 + cd $^ && $(MAKE) + mkdir -p $(lib_dir)/$@ $(include_dir)/$@ + cp $^/libopenh264.a $(lib_dir)/$@ + cp $^/codec/api/svc/*.h $(include_dir)/$@ + +create_out_dirs: + mkdir -p $(lib_dir) $(include_dir) + +dependencies: + apt install -y nasm \ No newline at end of file diff --git a/cvendor/include/openh264/codec_api.h b/cvendor/include/openh264/codec_api.h new file mode 100644 index 0000000..a1326c8 --- /dev/null +++ b/cvendor/include/openh264/codec_api.h @@ -0,0 +1,592 @@ +/*! + *@page License + * + * \copy + * Copyright (c) 2013, Cisco Systems + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN + * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * + */ + +#ifndef WELS_VIDEO_CODEC_SVC_API_H__ +#define WELS_VIDEO_CODEC_SVC_API_H__ + +#ifndef __cplusplus +#if defined(_MSC_VER) && (_MSC_VER < 1800) +typedef unsigned char bool; +#else +#include +#endif +#endif + +#include "codec_app_def.h" +#include "codec_def.h" + +#if defined(_WIN32) || defined(__cdecl) +#define EXTAPI __cdecl +#else +#define EXTAPI +#endif + +/** + * @file codec_api.h +*/ + +/** + * @page Overview + * * This page is for openh264 codec API usage. + * * For how to use the encoder,please refer to page UsageExampleForEncoder + * * For how to use the decoder,please refer to page UsageExampleForDecoder + * * For more detail about ISVEncoder,please refer to page ISVCEncoder + * * For more detail about ISVDecoder,please refer to page ISVCDecoder +*/ + +/** + * @page DecoderUsageExample + * + * @brief + * * An example for using the decoder for Decoding only or Parsing only + * + * Step 1:decoder declaration + * @code + * + * //decoder declaration + * ISVCDecoder *pSvcDecoder; + * //input: encoded bitstream start position; should include start code prefix + * unsigned char *pBuf =...; + * //input: encoded bit stream length; should include the size of start code prefix + * int iSize =...; + * //output: [0~2] for Y,U,V buffer for Decoding only + * unsigned char *pData[3] =...; + * //in-out: for Decoding only: declare and initialize the output buffer info, this should never co-exist with Parsing only + * SBufferInfo sDstBufInfo; + * memset(&sDstBufInfo, 0, sizeof(SBufferInfo)); + * //in-out: for Parsing only: declare and initialize the output bitstream buffer info for parse only, this should never co-exist with Decoding only + * SParserBsInfo sDstParseInfo; + * memset(&sDstParseInfo, 0, sizeof(SParserBsInfo)); + * sDstParseInfo.pDstBuff = new unsigned char[PARSE_SIZE]; //In Parsing only, allocate enough buffer to save transcoded bitstream for a frame + * + * @endcode + * + * Step 2:decoder creation + * @code + * WelsCreateDecoder(&pSvcDecoder); + * @endcode + * + * Step 3:declare required parameter, used to differentiate Decoding only and Parsing only + * @code + * SDecodingParam sDecParam = {0}; + * sDecParam.sVideoProperty.eVideoBsType = VIDEO_BITSTREAM_AVC; + * //for Parsing only, the assignment is mandatory + * sDecParam.bParseOnly = true; + * @endcode + * + * Step 4:initialize the parameter and decoder context, allocate memory + * @code + * pSvcDecoder->Initialize(&sDecParam); + * @endcode + * + * Step 5:do actual decoding process in slice level; + * this can be done in a loop until data ends + * @code + * //for Decoding only + * iRet = pSvcDecoder->DecodeFrameNoDelay(pBuf, iSize, pData, &sDstBufInfo); + * //or + * iRet = pSvcDecoder->DecodeFrame2(pBuf, iSize, pData, &sDstBufInfo); + * //for Parsing only + * iRet = pSvcDecoder->DecodeParser(pBuf, iSize, &sDstParseInfo); + * //decode failed + * If (iRet != 0){ + * //error handling (RequestIDR or something like that) + * } + * //for Decoding only, pData can be used for render. + * if (sDstBufInfo.iBufferStatus==1){ + * //output handling (pData[0], pData[1], pData[2]) + * } + * //for Parsing only, sDstParseInfo can be used for, e.g., HW decoding + * if (sDstBufInfo.iNalNum > 0){ + * //Hardware decoding sDstParseInfo; + * } + * //no-delay decoding can be realized by directly calling DecodeFrameNoDelay(), which is the recommended usage. + * //no-delay decoding can also be realized by directly calling DecodeFrame2() again with NULL input, as in the following. In this case, decoder would immediately reconstruct the input data. This can also be used similarly for Parsing only. Consequent decoding error and output indication should also be considered as above. + * iRet = pSvcDecoder->DecodeFrame2(NULL, 0, pData, &sDstBufInfo); + * //judge iRet, sDstBufInfo.iBufferStatus ... + * @endcode + * + * Step 6:uninitialize the decoder and memory free + * @code + * pSvcDecoder->Uninitialize(); + * @endcode + * + * Step 7:destroy the decoder + * @code + * DestroyDecoder(pSvcDecoder); + * @endcode + * +*/ + +/** + * @page EncoderUsageExample1 + * + * @brief + * * An example for using encoder with basic parameter + * + * Step1:setup encoder + * @code + * ISVCEncoder* encoder_; + * int rv = WelsCreateSVCEncoder (&encoder_); + * assert (rv == 0); + * assert (encoder_ != NULL); + * @endcode + * + * Step2:initilize with basic parameter + * @code + * SEncParamBase param; + * memset (¶m, 0, sizeof (SEncParamBase)); + * param.iUsageType = usageType; //from EUsageType enum + * param.fMaxFrameRate = frameRate; + * param.iPicWidth = width; + * param.iPicHeight = height; + * param.iTargetBitrate = 5000000; + * encoder_->Initialize (¶m); + * @endcode + * + * Step3:set option, set option during encoding process + * @code + * encoder_->SetOption (ENCODER_OPTION_TRACE_LEVEL, &g_LevelSetting); + * int videoFormat = videoFormatI420; + * encoder_->SetOption (ENCODER_OPTION_DATAFORMAT, &videoFormat); + * @endcode + * + * Step4: encode and store ouput bistream + * @code + * int frameSize = width * height * 3 / 2; + * BufferedData buf; + * buf.SetLength (frameSize); + * assert (buf.Length() == (size_t)frameSize); + * SFrameBSInfo info; + * memset (&info, 0, sizeof (SFrameBSInfo)); + * SSourcePicture pic; + * memset (&pic, 0, sizeof (SsourcePicture)); + * pic.iPicWidth = width; + * pic.iPicHeight = height; + * pic.iColorFormat = videoFormatI420; + * pic.iStride[0] = pic.iPicWidth; + * pic.iStride[1] = pic.iStride[2] = pic.iPicWidth >> 1; + * pic.pData[0] = buf.data(); + * pic.pData[1] = pic.pData[0] + width * height; + * pic.pData[2] = pic.pData[1] + (width * height >> 2); + * for(int num = 0;numEncodeFrame (&pic, &info); + * assert (rv == cmResultSuccess); + * if (info.eFrameType != videoFrameTypeSkip) { + * //output bitstream handling + * } + * } + * @endcode + * + * Step5:teardown encoder + * @code + * if (encoder_) { + * encoder_->Uninitialize(); + * WelsDestroySVCEncoder (encoder_); + * } + * @endcode + * + */ + +/** + * @page EncoderUsageExample2 + * + * @brief + * * An example for using the encoder with extension parameter. + * * The same operation on Step 1,3,4,5 with Example-1 + * + * Step 2:initialize with extension parameter + * @code + * SEncParamExt param; + * encoder_->GetDefaultParams (¶m); + * param.iUsageType = usageType; + * param.fMaxFrameRate = frameRate; + * param.iPicWidth = width; + * param.iPicHeight = height; + * param.iTargetBitrate = 5000000; + * param.bEnableDenoise = denoise; + * param.iSpatialLayerNum = layers; + * //SM_DYN_SLICE don't support multi-thread now + * if (sliceMode != SM_SINGLE_SLICE && sliceMode != SM_DYN_SLICE) + * param.iMultipleThreadIdc = 2; + * + * for (int i = 0; i < param.iSpatialLayerNum; i++) { + * param.sSpatialLayers[i].iVideoWidth = width >> (param.iSpatialLayerNum - 1 - i); + * param.sSpatialLayers[i].iVideoHeight = height >> (param.iSpatialLayerNum - 1 - i); + * param.sSpatialLayers[i].fFrameRate = frameRate; + * param.sSpatialLayers[i].iSpatialBitrate = param.iTargetBitrate; + * + * param.sSpatialLayers[i].sSliceCfg.uiSliceMode = sliceMode; + * if (sliceMode == SM_DYN_SLICE) { + * param.sSpatialLayers[i].sSliceCfg.sSliceArgument.uiSliceSizeConstraint = 600; + * param.uiMaxNalSize = 1500; + * } + * } + * param.iTargetBitrate *= param.iSpatialLayerNum; + * encoder_->InitializeExt (¶m); + * int videoFormat = videoFormatI420; + * encoder_->SetOption (ENCODER_OPTION_DATAFORMAT, &videoFormat); + * + * @endcode + */ + + + + +#ifdef __cplusplus +/** +* @brief Endocder definition +*/ +class ISVCEncoder { + public: + /** + * @brief Initialize the encoder + * @param pParam basic encoder parameter + * @return CM_RETURN: 0 - success; otherwise - failed; + */ + virtual int EXTAPI Initialize (const SEncParamBase* pParam) = 0; + + /** + * @brief Initilaize encoder by using extension parameters. + * @param pParam extension parameter for encoder + * @return CM_RETURN: 0 - success; otherwise - failed; + */ + virtual int EXTAPI InitializeExt (const SEncParamExt* pParam) = 0; + + /** + * @brief Get the default extension parameters. + * If you want to change some parameters of encoder, firstly you need to get the default encoding parameters, + * after that you can change part of parameters you want to. + * @param pParam extension parameter for encoder + * @return CM_RETURN: 0 - success; otherwise - failed; + * */ + virtual int EXTAPI GetDefaultParams (SEncParamExt* pParam) = 0; + /// uninitialize the encoder + virtual int EXTAPI Uninitialize() = 0; + + /** + * @brief Encode one frame + * @param kpSrcPic the pointer to the source luminance plane + * chrominance data: + * CbData = kpSrc + m_iMaxPicWidth * m_iMaxPicHeight; + * CrData = CbData + (m_iMaxPicWidth * m_iMaxPicHeight)/4; + * the application calling this interface needs to ensure the data validation between the location + * @param pBsInfo output bit stream + * @return 0 - success; otherwise -failed; + */ + virtual int EXTAPI EncodeFrame (const SSourcePicture* kpSrcPic, SFrameBSInfo* pBsInfo) = 0; + + /** + * @brief Encode the parameters from output bit stream + * @param pBsInfo output bit stream + * @return 0 - success; otherwise - failed; + */ + virtual int EXTAPI EncodeParameterSets (SFrameBSInfo* pBsInfo) = 0; + + /** + * @brief Force encoder to encoder frame as IDR if bIDR set as true + * @param bIDR true: force encoder to encode frame as IDR frame;false, return 1 and nothing to do + * @return 0 - success; otherwise - failed; + */ + virtual int EXTAPI ForceIntraFrame (bool bIDR, int iLayerId = -1) = 0; + + /** + * @brief Set option for encoder, detail option type, please refer to enumurate ENCODER_OPTION. + * @param pOption option for encoder such as InDataFormat, IDRInterval, SVC Encode Param, Frame Rate, Bitrate,... + * @return CM_RETURN: 0 - success; otherwise - failed; + */ + virtual int EXTAPI SetOption (ENCODER_OPTION eOptionId, void* pOption) = 0; + + /** + * @brief Get option for encoder, detail option type, please refer to enumurate ENCODER_OPTION. + * @param pOption option for encoder such as InDataFormat, IDRInterval, SVC Encode Param, Frame Rate, Bitrate,... + * @return CM_RETURN: 0 - success; otherwise - failed; + */ + virtual int EXTAPI GetOption (ENCODER_OPTION eOptionId, void* pOption) = 0; + virtual ~ISVCEncoder() {} +}; + + + +/** +* @brief Decoder definition +*/ +class ISVCDecoder { + public: + + /** + * @brief Initilaize decoder + * @param pParam parameter for decoder + * @return 0 - success; otherwise - failed; + */ + virtual long EXTAPI Initialize (const SDecodingParam* pParam) = 0; + + /// Uninitialize the decoder + virtual long EXTAPI Uninitialize() = 0; + + /** + * @brief Decode one frame + * @param pSrc the h264 stream to be decoded + * @param iSrcLen the length of h264 stream + * @param ppDst buffer pointer of decoded data (YUV) + * @param pStride output stride + * @param iWidth output width + * @param iHeight output height + * @return 0 - success; otherwise -failed; + */ + virtual DECODING_STATE EXTAPI DecodeFrame (const unsigned char* pSrc, + const int iSrcLen, + unsigned char** ppDst, + int* pStride, + int& iWidth, + int& iHeight) = 0; + + /** + * @brief For slice level DecodeFrameNoDelay() (4 parameters input), + * whatever the function return value is, the output data + * of I420 format will only be available when pDstInfo->iBufferStatus == 1,. + * This function will parse and reconstruct the input frame immediately if it is complete + * It is recommended as the main decoding function for H.264/AVC format input + * @param pSrc the h264 stream to be decoded + * @param iSrcLen the length of h264 stream + * @param ppDst buffer pointer of decoded data (YUV) + * @param pDstInfo information provided to API(width, height, etc.) + * @return 0 - success; otherwise -failed; + */ + virtual DECODING_STATE EXTAPI DecodeFrameNoDelay (const unsigned char* pSrc, + const int iSrcLen, + unsigned char** ppDst, + SBufferInfo* pDstInfo) = 0; + + /** + * @brief For slice level DecodeFrame2() (4 parameters input), + * whatever the function return value is, the output data + * of I420 format will only be available when pDstInfo->iBufferStatus == 1,. + * (e.g., in multi-slice cases, only when the whole picture + * is completely reconstructed, this variable would be set equal to 1.) + * @param pSrc the h264 stream to be decoded + * @param iSrcLen the length of h264 stream + * @param ppDst buffer pointer of decoded data (YUV) + * @param pDstInfo information provided to API(width, height, etc.) + * @return 0 - success; otherwise -failed; + */ + virtual DECODING_STATE EXTAPI DecodeFrame2 (const unsigned char* pSrc, + const int iSrcLen, + unsigned char** ppDst, + SBufferInfo* pDstInfo) = 0; + + + /** + * @brief This function gets a decoded ready frame remaining in buffers after the last frame has been decoded. + * Use GetOption with option DECODER_OPTION_NUM_OF_FRAMES_REMAINING_IN_BUFFER to get the number of frames remaining in buffers. + * Note that it is only applicable for profile_idc != 66 + * @param ppDst buffer pointer of decoded data (YUV) + * @param pDstInfo information provided to API(width, height, etc.) + * @return 0 - success; otherwise -failed; + */ + virtual DECODING_STATE EXTAPI FlushFrame (unsigned char** ppDst, + SBufferInfo* pDstInfo) = 0; + + /** + * @brief This function parse input bitstream only, and rewrite possible SVC syntax to AVC syntax + * @param pSrc the h264 stream to be decoded + * @param iSrcLen the length of h264 stream + * @param pDstInfo bit stream info + * @return 0 - success; otherwise -failed; + */ + virtual DECODING_STATE EXTAPI DecodeParser (const unsigned char* pSrc, + const int iSrcLen, + SParserBsInfo* pDstInfo) = 0; + + /** + * @brief This API does not work for now!! This is for future use to support non-I420 color format output. + * @param pSrc the h264 stream to be decoded + * @param iSrcLen the length of h264 stream + * @param pDst buffer pointer of decoded data (YUV) + * @param iDstStride output stride + * @param iDstLen bit stream info + * @param iWidth output width + * @param iHeight output height + * @param iColorFormat output color format + * @return to do ... + */ + virtual DECODING_STATE EXTAPI DecodeFrameEx (const unsigned char* pSrc, + const int iSrcLen, + unsigned char* pDst, + int iDstStride, + int& iDstLen, + int& iWidth, + int& iHeight, + int& iColorFormat) = 0; + + /** + * @brief Set option for decoder, detail option type, please refer to enumurate DECODER_OPTION. + * @param pOption option for decoder such as OutDataFormat, Eos Flag, EC method, ... + * @return CM_RETURN: 0 - success; otherwise - failed; + */ + virtual long EXTAPI SetOption (DECODER_OPTION eOptionId, void* pOption) = 0; + + /** + * @brief Get option for decoder, detail option type, please refer to enumurate DECODER_OPTION. + * @param pOption option for decoder such as OutDataFormat, Eos Flag, EC method, ... + * @return CM_RETURN: 0 - success; otherwise - failed; + */ + virtual long EXTAPI GetOption (DECODER_OPTION eOptionId, void* pOption) = 0; + virtual ~ISVCDecoder() {} +}; + + +extern "C" +{ +#else + +typedef struct ISVCEncoderVtbl ISVCEncoderVtbl; +typedef const ISVCEncoderVtbl* ISVCEncoder; +struct ISVCEncoderVtbl { + +int (*Initialize) (ISVCEncoder*, const SEncParamBase* pParam); +int (*InitializeExt) (ISVCEncoder*, const SEncParamExt* pParam); + +int (*GetDefaultParams) (ISVCEncoder*, SEncParamExt* pParam); + +int (*Uninitialize) (ISVCEncoder*); + +int (*EncodeFrame) (ISVCEncoder*, const SSourcePicture* kpSrcPic, SFrameBSInfo* pBsInfo); +int (*EncodeParameterSets) (ISVCEncoder*, SFrameBSInfo* pBsInfo); + +int (*ForceIntraFrame) (ISVCEncoder*, bool bIDR); + +int (*SetOption) (ISVCEncoder*, ENCODER_OPTION eOptionId, void* pOption); +int (*GetOption) (ISVCEncoder*, ENCODER_OPTION eOptionId, void* pOption); +}; + +typedef struct ISVCDecoderVtbl ISVCDecoderVtbl; +typedef const ISVCDecoderVtbl* ISVCDecoder; +struct ISVCDecoderVtbl { +long (*Initialize) (ISVCDecoder*, const SDecodingParam* pParam); +long (*Uninitialize) (ISVCDecoder*); + +DECODING_STATE (*DecodeFrame) (ISVCDecoder*, const unsigned char* pSrc, + const int iSrcLen, + unsigned char** ppDst, + int* pStride, + int* iWidth, + int* iHeight); + +DECODING_STATE (*DecodeFrameNoDelay) (ISVCDecoder*, const unsigned char* pSrc, + const int iSrcLen, + unsigned char** ppDst, + SBufferInfo* pDstInfo); + +DECODING_STATE (*DecodeFrame2) (ISVCDecoder*, const unsigned char* pSrc, + const int iSrcLen, + unsigned char** ppDst, + SBufferInfo* pDstInfo); + +DECODING_STATE (*FlushFrame) (ISVCDecoder*, unsigned char** ppDst, + SBufferInfo* pDstInfo); + +DECODING_STATE (*DecodeParser) (ISVCDecoder*, const unsigned char* pSrc, + const int iSrcLen, + SParserBsInfo* pDstInfo); + +DECODING_STATE (*DecodeFrameEx) (ISVCDecoder*, const unsigned char* pSrc, + const int iSrcLen, + unsigned char* pDst, + int iDstStride, + int* iDstLen, + int* iWidth, + int* iHeight, + int* iColorFormat); + +long (*SetOption) (ISVCDecoder*, DECODER_OPTION eOptionId, void* pOption); +long (*GetOption) (ISVCDecoder*, DECODER_OPTION eOptionId, void* pOption); +}; +#endif + +typedef void (*WelsTraceCallback) (void* ctx, int level, const char* string); + +/** @brief Create encoder + * @param ppEncoder encoder + * @return 0 - success; otherwise - failed; +*/ +int WelsCreateSVCEncoder (ISVCEncoder** ppEncoder); + + +/** @brief Destroy encoder +* @param pEncoder encoder + * @return void +*/ +void WelsDestroySVCEncoder (ISVCEncoder* pEncoder); + + +/** @brief Get the capability of decoder + * @param pDecCapability decoder capability + * @return 0 - success; otherwise - failed; +*/ +int WelsGetDecoderCapability (SDecoderCapability* pDecCapability); + + +/** @brief Create decoder + * @param ppDecoder decoder + * @return 0 - success; otherwise - failed; +*/ +long WelsCreateDecoder (ISVCDecoder** ppDecoder); + + +/** @brief Destroy decoder + * @param pDecoder decoder + * @return void +*/ +void WelsDestroyDecoder (ISVCDecoder* pDecoder); + +/** @brief Get codec version + * Note, old versions of Mingw (GCC < 4.7) are buggy and use an + * incorrect/different ABI for calling this function, making it + * incompatible with MSVC builds. + * @return The linked codec version +*/ +OpenH264Version WelsGetCodecVersion (void); + +/** @brief Get codec version + * @param pVersion struct to fill in with the version +*/ +void WelsGetCodecVersionEx (OpenH264Version* pVersion); + +#ifdef __cplusplus +} +#endif + +#endif//WELS_VIDEO_CODEC_SVC_API_H__ diff --git a/cvendor/include/openh264/codec_app_def.h b/cvendor/include/openh264/codec_app_def.h new file mode 100644 index 0000000..1e26f9f --- /dev/null +++ b/cvendor/include/openh264/codec_app_def.h @@ -0,0 +1,810 @@ +/*! + * \copy + * Copyright (c) 2013, Cisco Systems + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN + * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * + */ + + + +#ifndef WELS_VIDEO_CODEC_APPLICATION_DEFINITION_H__ +#define WELS_VIDEO_CODEC_APPLICATION_DEFINITION_H__ +/** + * @file codec_app_def.h + * @brief Data and /or structures introduced in Cisco OpenH264 application +*/ + +#include "codec_def.h" +/* Constants */ +#define MAX_TEMPORAL_LAYER_NUM 4 +#define MAX_SPATIAL_LAYER_NUM 4 +#define MAX_QUALITY_LAYER_NUM 4 + +#define MAX_LAYER_NUM_OF_FRAME 128 +#define MAX_NAL_UNITS_IN_LAYER 128 ///< predetermined here, adjust it later if need + +#define MAX_RTP_PAYLOAD_LEN 1000 +#define AVERAGE_RTP_PAYLOAD_LEN 800 + + +#define SAVED_NALUNIT_NUM_TMP ( (MAX_SPATIAL_LAYER_NUM*MAX_QUALITY_LAYER_NUM) + 1 + MAX_SPATIAL_LAYER_NUM ) ///< SPS/PPS + SEI/SSEI + PADDING_NAL +#define MAX_SLICES_NUM_TMP ( ( MAX_NAL_UNITS_IN_LAYER - SAVED_NALUNIT_NUM_TMP ) / 3 ) + + +#define AUTO_REF_PIC_COUNT -1 ///< encoder selects the number of reference frame automatically +#define UNSPECIFIED_BIT_RATE 0 ///< to do: add detail comment + +/** + * @brief Struct of OpenH264 version + */ +/// +/// E.g. SDK version is 1.2.0.0, major version number is 1, minor version number is 2, and revision number is 0. +typedef struct _tagVersion { + unsigned int uMajor; ///< The major version number + unsigned int uMinor; ///< The minor version number + unsigned int uRevision; ///< The revision number + unsigned int uReserved; ///< The reserved number, it should be 0. +} OpenH264Version; + +/** +* @brief Decoding status +*/ +typedef enum { + /** + * Errors derived from bitstream parsing + */ + dsErrorFree = 0x00, ///< bit stream error-free + dsFramePending = 0x01, ///< need more throughput to generate a frame output, + dsRefLost = 0x02, ///< layer lost at reference frame with temporal id 0 + dsBitstreamError = 0x04, ///< error bitstreams(maybe broken internal frame) the decoder cared + dsDepLayerLost = 0x08, ///< dependented layer is ever lost + dsNoParamSets = 0x10, ///< no parameter set NALs involved + dsDataErrorConcealed = 0x20, ///< current data error concealed specified + dsRefListNullPtrs = 0x40, /// do not write any of the following information to the header + unsigned char + uiVideoFormat; // EVideoFormatSPS; 3 bits in header; 0-5 => component, kpal, ntsc, secam, mac, undef + bool bFullRange; // false => analog video data range [16, 235]; true => full data range [0,255] + bool bColorDescriptionPresent; // false => do not write any of the following three items to the header + unsigned char + uiColorPrimaries; // EColorPrimaries; 8 bits in header; 0 - 9 => ???, bt709, undef, ???, bt470m, bt470bg, + // smpte170m, smpte240m, film, bt2020 + unsigned char + uiTransferCharacteristics; // ETransferCharacteristics; 8 bits in header; 0 - 15 => ???, bt709, undef, ???, bt470m, bt470bg, smpte170m, + // smpte240m, linear, log100, log316, iec61966-2-4, bt1361e, iec61966-2-1, bt2020-10, bt2020-12 + unsigned char + uiColorMatrix; // EColorMatrix; 8 bits in header (corresponds to FFmpeg "colorspace"); 0 - 10 => GBR, bt709, + // undef, ???, fcc, bt470bg, smpte170m, smpte240m, YCgCo, bt2020nc, bt2020c + + bool bAspectRatioPresent; ///< aspect ratio present in VUI + ESampleAspectRatio eAspectRatio; ///< aspect ratio idc + unsigned short sAspectRatioExtWidth; ///< use if aspect ratio idc == 255 + unsigned short sAspectRatioExtHeight; ///< use if aspect ratio idc == 255 + +} SSpatialLayerConfig; + +/** +* @brief Encoder usage type +*/ +typedef enum { + CAMERA_VIDEO_REAL_TIME, ///< camera video for real-time communication + SCREEN_CONTENT_REAL_TIME, ///< screen content signal + CAMERA_VIDEO_NON_REAL_TIME, + SCREEN_CONTENT_NON_REAL_TIME, + INPUT_CONTENT_TYPE_ALL, +} EUsageType; + +/** +* @brief Enumulate the complexity mode +*/ +typedef enum { + LOW_COMPLEXITY = 0, ///< the lowest compleixty,the fastest speed, + MEDIUM_COMPLEXITY, ///< medium complexity, medium speed,medium quality + HIGH_COMPLEXITY ///< high complexity, lowest speed, high quality +} ECOMPLEXITY_MODE; + +/** + * @brief Enumulate for the stategy of SPS/PPS strategy + */ +typedef enum { + CONSTANT_ID = 0, ///< constant id in SPS/PPS + INCREASING_ID = 0x01, ///< SPS/PPS id increases at each IDR + SPS_LISTING = 0x02, ///< using SPS in the existing list if possible + SPS_LISTING_AND_PPS_INCREASING = 0x03, + SPS_PPS_LISTING = 0x06, +} EParameterSetStrategy; + +// TODO: Refine the parameters definition. +/** +* @brief SVC Encoding Parameters +*/ +typedef struct TagEncParamBase { + EUsageType + iUsageType; ///< application type; please refer to the definition of EUsageType + + int iPicWidth; ///< width of picture in luminance samples (the maximum of all layers if multiple spatial layers presents) + int iPicHeight; ///< height of picture in luminance samples((the maximum of all layers if multiple spatial layers presents) + int iTargetBitrate; ///< target bitrate desired, in unit of bps + RC_MODES iRCMode; ///< rate control mode + float fMaxFrameRate; ///< maximal input frame rate + +} SEncParamBase, *PEncParamBase; + +/** +* @brief SVC Encoding Parameters extention +*/ +typedef struct TagEncParamExt { + EUsageType + iUsageType; ///< same as in TagEncParamBase + + int iPicWidth; ///< same as in TagEncParamBase + int iPicHeight; ///< same as in TagEncParamBase + int iTargetBitrate; ///< same as in TagEncParamBase + RC_MODES iRCMode; ///< same as in TagEncParamBase + float fMaxFrameRate; ///< same as in TagEncParamBase + + int iTemporalLayerNum; ///< temporal layer number, max temporal layer = 4 + int iSpatialLayerNum; ///< spatial layer number,1<= iSpatialLayerNum <= MAX_SPATIAL_LAYER_NUM, MAX_SPATIAL_LAYER_NUM = 4 + SSpatialLayerConfig sSpatialLayers[MAX_SPATIAL_LAYER_NUM]; + + ECOMPLEXITY_MODE iComplexityMode; + unsigned int uiIntraPeriod; ///< period of Intra frame + int iNumRefFrame; ///< number of reference frame used + EParameterSetStrategy + eSpsPpsIdStrategy; ///< different stategy in adjust ID in SPS/PPS: 0- constant ID, 1-additional ID, 6-mapping and additional + bool bPrefixNalAddingCtrl; ///< false:not use Prefix NAL; true: use Prefix NAL + bool bEnableSSEI; ///< false:not use SSEI; true: use SSEI -- TODO: planning to remove the interface of SSEI + bool bSimulcastAVC; ///< (when encoding more than 1 spatial layer) false: use SVC syntax for higher layers; true: use Simulcast AVC + int iPaddingFlag; ///< 0:disable padding;1:padding + int iEntropyCodingModeFlag; ///< 0:CAVLC 1:CABAC. + + /* rc control */ + bool bEnableFrameSkip; ///< False: don't skip frame even if VBV buffer overflow.True: allow skipping frames to keep the bitrate within limits + int iMaxBitrate; ///< the maximum bitrate, in unit of bps, set it to UNSPECIFIED_BIT_RATE if not needed + int iMaxQp; ///< the maximum QP encoder supports + int iMinQp; ///< the minmum QP encoder supports + unsigned int uiMaxNalSize; ///< the maximum NAL size. This value should be not 0 for dynamic slice mode + + /*LTR settings*/ + bool bEnableLongTermReference; ///< 1: on, 0: off + int iLTRRefNum; ///< the number of LTR(long term reference),TODO: not supported to set it arbitrary yet + unsigned int iLtrMarkPeriod; ///< the LTR marked period that is used in feedback. + /* multi-thread settings*/ + unsigned short + iMultipleThreadIdc; ///< 1 # 0: auto(dynamic imp. internal encoder); 1: multiple threads imp. disabled; lager than 1: count number of threads; + bool bUseLoadBalancing; ///< only used when uiSliceMode=1 or 3, will change slicing of a picture during the run-time of multi-thread encoding, so the result of each run may be different + + /* Deblocking loop filter */ + int iLoopFilterDisableIdc; ///< 0: on, 1: off, 2: on except for slice boundaries + int iLoopFilterAlphaC0Offset; ///< AlphaOffset: valid range [-6, 6], default 0 + int iLoopFilterBetaOffset; ///< BetaOffset: valid range [-6, 6], default 0 + /*pre-processing feature*/ + bool bEnableDenoise; ///< denoise control + bool bEnableBackgroundDetection; ///< background detection control //VAA_BACKGROUND_DETECTION //BGD cmd + bool bEnableAdaptiveQuant; ///< adaptive quantization control + bool bEnableFrameCroppingFlag; ///< enable frame cropping flag: TRUE always in application + bool bEnableSceneChangeDetect; + + bool bIsLosslessLink; ///< LTR advanced setting +} SEncParamExt; + +/** +* @brief Define a new struct to show the property of video bitstream. +*/ +typedef struct { + unsigned int size; ///< size of the struct + VIDEO_BITSTREAM_TYPE eVideoBsType; ///< video stream type (AVC/SVC) +} SVideoProperty; + +/** +* @brief SVC Decoding Parameters, reserved here and potential applicable in the future +*/ +typedef struct TagSVCDecodingParam { + char* pFileNameRestructed; ///< file name of reconstructed frame used for PSNR calculation based debug + + unsigned int uiCpuLoad; ///< CPU load + unsigned char uiTargetDqLayer; ///< setting target dq layer id + + ERROR_CON_IDC eEcActiveIdc; ///< whether active error concealment feature in decoder + bool bParseOnly; ///< decoder for parse only, no reconstruction. When it is true, SPS/PPS size should not exceed SPS_PPS_BS_SIZE (128). Otherwise, it will return error info + + SVideoProperty sVideoProperty; ///< video stream property +} SDecodingParam, *PDecodingParam; + +/** +* @brief Bitstream inforamtion of a layer being encoded +*/ +typedef struct { + unsigned char uiTemporalId; + unsigned char uiSpatialId; + unsigned char uiQualityId; + EVideoFrameType eFrameType; + unsigned char uiLayerType; + + /** + * The sub sequence layers are ordered hierarchically based on their dependency on each other so that any picture in a layer shall not be + * predicted from any picture on any higher layer. + */ + int iSubSeqId; ///< refer to D.2.11 Sub-sequence information SEI message semantics + int iNalCount; ///< count number of NAL coded already + int* pNalLengthInByte; ///< length of NAL size in byte from 0 to iNalCount-1 + unsigned char* pBsBuf; ///< buffer of bitstream contained +} SLayerBSInfo, *PLayerBSInfo; + +/** +* @brief Frame bit stream info +*/ +typedef struct { + int iLayerNum; + SLayerBSInfo sLayerInfo[MAX_LAYER_NUM_OF_FRAME]; + + EVideoFrameType eFrameType; + int iFrameSizeInBytes; + long long uiTimeStamp; +} SFrameBSInfo, *PFrameBSInfo; + +/** +* @brief Structure for source picture +*/ +typedef struct Source_Picture_s { + int iColorFormat; ///< color space type + int iStride[4]; ///< stride for each plane pData + unsigned char* pData[4]; ///< plane pData + int iPicWidth; ///< luma picture width in x coordinate + int iPicHeight; ///< luma picture height in y coordinate + long long uiTimeStamp; ///< timestamp of the source picture, unit: millisecond +} SSourcePicture; +/** +* @brief Structure for bit rate info +*/ +typedef struct TagBitrateInfo { + LAYER_NUM iLayer; + int iBitrate; ///< the maximum bitrate +} SBitrateInfo; + +/** +* @brief Structure for dump layer info +*/ +typedef struct TagDumpLayer { + int iLayer; + char* pFileName; +} SDumpLayer; + +/** +* @brief Structure for profile info in layer +* +*/ +typedef struct TagProfileInfo { + int iLayer; + EProfileIdc uiProfileIdc; ///< the profile info +} SProfileInfo; + +/** +* @brief Structure for level info in layer +* +*/ +typedef struct TagLevelInfo { + int iLayer; + ELevelIdc uiLevelIdc; ///< the level info +} SLevelInfo; +/** +* @brief Structure for dilivery status +* +*/ +typedef struct TagDeliveryStatus { + bool bDeliveryFlag; ///< 0: the previous frame isn't delivered,1: the previous frame is delivered + int iDropFrameType; ///< the frame type that is dropped; reserved + int iDropFrameSize; ///< the frame size that is dropped; reserved +} SDeliveryStatus; + +/** +* @brief The capability of decoder, for SDP negotiation +*/ +typedef struct TagDecoderCapability { + int iProfileIdc; ///< profile_idc + int iProfileIop; ///< profile-iop + int iLevelIdc; ///< level_idc + int iMaxMbps; ///< max-mbps + int iMaxFs; ///< max-fs + int iMaxCpb; ///< max-cpb + int iMaxDpb; ///< max-dpb + int iMaxBr; ///< max-br + bool bRedPicCap; ///< redundant-pic-cap +} SDecoderCapability; + +/** +* @brief Structure for parse only output +*/ +typedef struct TagParserBsInfo { + int iNalNum; ///< total NAL number in current AU + int* pNalLenInByte; ///< each nal length + unsigned char* pDstBuff; ///< outputted dst buffer for parsed bitstream + int iSpsWidthInPixel; ///< required SPS width info + int iSpsHeightInPixel; ///< required SPS height info + unsigned long long uiInBsTimeStamp; ///< input BS timestamp + unsigned long long uiOutBsTimeStamp; ///< output BS timestamp +} SParserBsInfo, *PParserBsInfo; + +/** +* @brief Structure for encoder statistics +*/ +typedef struct TagVideoEncoderStatistics { + unsigned int uiWidth; ///< the width of encoded frame + unsigned int uiHeight; ///< the height of encoded frame + //following standard, will be 16x aligned, if there are multiple spatial, this is of the highest + float fAverageFrameSpeedInMs; ///< average_Encoding_Time + + // rate control related + float fAverageFrameRate; ///< the average frame rate in, calculate since encoding starts, supposed that the input timestamp is in unit of ms + float fLatestFrameRate; ///< the frame rate in, in the last second, supposed that the input timestamp is in unit of ms (? useful for checking BR, but is it easy to calculate? + unsigned int uiBitRate; ///< sendrate in Bits per second, calculated within the set time-window + unsigned int uiAverageFrameQP; ///< the average QP of last encoded frame + + unsigned int uiInputFrameCount; ///< number of frames + unsigned int uiSkippedFrameCount; ///< number of frames + + unsigned int uiResolutionChangeTimes; ///< uiResolutionChangeTimes + unsigned int uiIDRReqNum; ///< number of IDR requests + unsigned int uiIDRSentNum; ///< number of actual IDRs sent + unsigned int uiLTRSentNum; ///< number of LTR sent/marked + + long long iStatisticsTs; ///< Timestamp of updating the statistics + + unsigned long iTotalEncodedBytes; + unsigned long iLastStatisticsBytes; + unsigned long iLastStatisticsFrameCount; +} SEncoderStatistics; + +/** +* @brief Structure for decoder statistics +*/ +typedef struct TagVideoDecoderStatistics { + unsigned int uiWidth; ///< the width of encode/decode frame + unsigned int uiHeight; ///< the height of encode/decode frame + float fAverageFrameSpeedInMs; ///< average_Decoding_Time + float fActualAverageFrameSpeedInMs; ///< actual average_Decoding_Time, including freezing pictures + unsigned int uiDecodedFrameCount; ///< number of frames + unsigned int uiResolutionChangeTimes; ///< uiResolutionChangeTimes + unsigned int uiIDRCorrectNum; ///< number of correct IDR received + //EC on related + unsigned int + uiAvgEcRatio; ///< when EC is on, the average ratio of total EC areas, can be an indicator of reconstruction quality + unsigned int + uiAvgEcPropRatio; ///< when EC is on, the rough average ratio of propogate EC areas, can be an indicator of reconstruction quality + unsigned int uiEcIDRNum; ///< number of actual unintegrity IDR or not received but eced + unsigned int uiEcFrameNum; ///< + unsigned int uiIDRLostNum; ///< number of whole lost IDR + unsigned int + uiFreezingIDRNum; ///< number of freezing IDR with error (partly received), under resolution change + unsigned int uiFreezingNonIDRNum; ///< number of freezing non-IDR with error + int iAvgLumaQp; ///< average luma QP. default: -1, no correct frame outputted + int iSpsReportErrorNum; ///< number of Sps Invalid report + int iSubSpsReportErrorNum; ///< number of SubSps Invalid report + int iPpsReportErrorNum; ///< number of Pps Invalid report + int iSpsNoExistNalNum; ///< number of Sps NoExist Nal + int iSubSpsNoExistNalNum; ///< number of SubSps NoExist Nal + int iPpsNoExistNalNum; ///< number of Pps NoExist Nal + + unsigned int uiProfile; ///< Profile idc in syntax + unsigned int uiLevel; ///< level idc according to Annex A-1 + + int iCurrentActiveSpsId; ///< current active SPS id + int iCurrentActivePpsId; ///< current active PPS id + + unsigned int iStatisticsLogInterval; ///< frame interval of statistics log +} SDecoderStatistics; // in building, coming soon + +/** +* @brief Structure for sample aspect ratio (SAR) info in VUI +*/ +typedef struct TagVuiSarInfo { + unsigned int uiSarWidth; ///< SAR width + unsigned int uiSarHeight; ///< SAR height + bool bOverscanAppropriateFlag; ///< SAR overscan flag +} SVuiSarInfo, *PVuiSarInfo; + +#endif//WELS_VIDEO_CODEC_APPLICATION_DEFINITION_H__ diff --git a/cvendor/include/openh264/codec_def.h b/cvendor/include/openh264/codec_def.h new file mode 100644 index 0000000..4f7eb9d --- /dev/null +++ b/cvendor/include/openh264/codec_def.h @@ -0,0 +1,215 @@ +/*! + * \copy + * Copyright (c) 2013, Cisco Systems + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN + * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * + */ + +#ifndef WELS_VIDEO_CODEC_DEFINITION_H__ +#define WELS_VIDEO_CODEC_DEFINITION_H__ + +/** + * @file codec_def.h +*/ + +/** +* @brief Enumerate the type of video format +*/ +typedef enum { + videoFormatRGB = 1, ///< rgb color formats + videoFormatRGBA = 2, + videoFormatRGB555 = 3, + videoFormatRGB565 = 4, + videoFormatBGR = 5, + videoFormatBGRA = 6, + videoFormatABGR = 7, + videoFormatARGB = 8, + + videoFormatYUY2 = 20, ///< yuv color formats + videoFormatYVYU = 21, + videoFormatUYVY = 22, + videoFormatI420 = 23, ///< the same as IYUV + videoFormatYV12 = 24, + videoFormatInternal = 25, ///< only used in SVC decoder testbed + + videoFormatNV12 = 26, ///< new format for output by DXVA decoding + + videoFormatVFlip = 0x80000000 +} EVideoFormatType; + +/** +* @brief Enumerate video frame type +*/ +typedef enum { + videoFrameTypeInvalid, ///< encoder not ready or parameters are invalidate + videoFrameTypeIDR, ///< IDR frame in H.264 + videoFrameTypeI, ///< I frame type + videoFrameTypeP, ///< P frame type + videoFrameTypeSkip, ///< skip the frame based encoder kernel + videoFrameTypeIPMixed ///< a frame where I and P slices are mixing, not supported yet +} EVideoFrameType; + +/** +* @brief Enumerate return type +*/ +typedef enum { + cmResultSuccess, ///< successful + cmInitParaError, ///< parameters are invalid + cmUnknownReason, + cmMallocMemeError, ///< malloc a memory error + cmInitExpected, ///< initial action is expected + cmUnsupportedData +} CM_RETURN; + +/** +* @brief Enumulate the nal unit type +*/ +enum ENalUnitType { + NAL_UNKNOWN = 0, + NAL_SLICE = 1, + NAL_SLICE_DPA = 2, + NAL_SLICE_DPB = 3, + NAL_SLICE_DPC = 4, + NAL_SLICE_IDR = 5, ///< ref_idc != 0 + NAL_SEI = 6, ///< ref_idc == 0 + NAL_SPS = 7, + NAL_PPS = 8 + ///< ref_idc == 0 for 6,9,10,11,12 +}; + +/** +* @brief NRI: eNalRefIdc +*/ +enum ENalPriority { + NAL_PRIORITY_DISPOSABLE = 0, + NAL_PRIORITY_LOW = 1, + NAL_PRIORITY_HIGH = 2, + NAL_PRIORITY_HIGHEST = 3 +}; + +#define IS_PARAMETER_SET_NAL(eNalRefIdc, eNalType) \ +( (eNalRefIdc == NAL_PRIORITY_HIGHEST) && (eNalType == (NAL_SPS|NAL_PPS) || eNalType == NAL_SPS) ) + +#define IS_IDR_NAL(eNalRefIdc, eNalType) \ +( (eNalRefIdc == NAL_PRIORITY_HIGHEST) && (eNalType == NAL_SLICE_IDR) ) + +#define FRAME_NUM_PARAM_SET (-1) +#define FRAME_NUM_IDR 0 + +/** + * @brief eDeblockingIdc + */ +enum { + DEBLOCKING_IDC_0 = 0, + DEBLOCKING_IDC_1 = 1, + DEBLOCKING_IDC_2 = 2 +}; +#define DEBLOCKING_OFFSET (6) +#define DEBLOCKING_OFFSET_MINUS (-6) + +/* Error Tools definition */ +typedef unsigned short ERR_TOOL; + +/** + @brief to do +*/ +enum { + ET_NONE = 0x00, ///< NONE Error Tools + ET_IP_SCALE = 0x01, ///< IP Scalable + ET_FMO = 0x02, ///< Flexible Macroblock Ordering + ET_IR_R1 = 0x04, ///< Intra Refresh in predifined 2% MB + ET_IR_R2 = 0x08, ///< Intra Refresh in predifined 5% MB + ET_IR_R3 = 0x10, ///< Intra Refresh in predifined 10% MB + ET_FEC_HALF = 0x20, ///< Forward Error Correction in 50% redundency mode + ET_FEC_FULL = 0x40, ///< Forward Error Correction in 100% redundency mode + ET_RFS = 0x80 ///< Reference Frame Selection +}; + +/** +* @brief Information of coded Slice(=NAL)(s) +*/ +typedef struct SliceInformation { + unsigned char* pBufferOfSlices; ///< base buffer of coded slice(s) + int iCodedSliceCount; ///< number of coded slices + unsigned int* pLengthOfSlices; ///< array of slices length accordingly by number of slice + int iFecType; ///< FEC type[0, 50%FEC, 100%FEC] + unsigned char uiSliceIdx; ///< index of slice in frame [FMO: 0,..,uiSliceCount-1; No FMO: 0] + unsigned char uiSliceCount; ///< count number of slice in frame [FMO: 2-8; No FMO: 1] + char iFrameIndex; ///< index of frame[-1, .., idr_interval-1] + unsigned char uiNalRefIdc; ///< NRI, priority level of slice(NAL) + unsigned char uiNalType; ///< NAL type + unsigned char + uiContainingFinalNal; ///< whether final NAL is involved in buffer of coded slices, flag used in Pause feature in T27 +} SliceInfo, *PSliceInfo; + +/** +* @brief thresholds of the initial, maximal and minimal rate +*/ +typedef struct { + int iWidth; ///< frame width + int iHeight; ///< frame height + int iThresholdOfInitRate; ///< threshold of initial rate + int iThresholdOfMaxRate; ///< threshold of maximal rate + int iThresholdOfMinRate; ///< threshold of minimal rate + int iMinThresholdFrameRate; ///< min frame rate min + int iSkipFrameRate; ///< skip to frame rate min + int iSkipFrameStep; ///< how many frames to skip +} SRateThresholds, *PRateThresholds; + +/** +* @brief Structure for decoder memery +*/ +typedef struct TagSysMemBuffer { + int iWidth; ///< width of decoded pic for display + int iHeight; ///< height of decoded pic for display + int iFormat; ///< type is "EVideoFormatType" + int iStride[2]; ///< stride of 2 component +} SSysMEMBuffer; + +/** +* @brief Buffer info +*/ +typedef struct TagBufferInfo { + int iBufferStatus; ///< 0: one frame data is not ready; 1: one frame data is ready + unsigned long long uiInBsTimeStamp; ///< input BS timestamp + unsigned long long uiOutYuvTimeStamp; ///< output YUV timestamp, when bufferstatus is 1 + union { + SSysMEMBuffer sSystemBuffer; ///< memory info for one picture + } UsrData; ///< output buffer info +} SBufferInfo; + + +/** +* @brief In a GOP, multiple of the key frame number, derived from +* the number of layers(index or array below) +*/ +static const char kiKeyNumMultiple[] = { + 1, 1, 2, 4, 8, 16, +}; + +#endif//WELS_VIDEO_CODEC_DEFINITION_H__ diff --git a/cvendor/include/openh264/codec_ver.h b/cvendor/include/openh264/codec_ver.h new file mode 100644 index 0000000..06d5efc --- /dev/null +++ b/cvendor/include/openh264/codec_ver.h @@ -0,0 +1,15 @@ +//The current file is auto-generated by script: generate_codec_ver.sh +#ifndef CODEC_VER_H +#define CODEC_VER_H + +#include "codec_app_def.h" + +static const OpenH264Version g_stCodecVersion = {2, 0, 0, 1905}; +static const char* const g_strCodecVer = "OpenH264 version:2.0.0.1905"; + +#define OPENH264_MAJOR (2) +#define OPENH264_MINOR (0) +#define OPENH264_REVISION (0) +#define OPENH264_RESERVED (1905) + +#endif // CODEC_VER_H diff --git a/cvendor/lib/openh264/libopenh264.a b/cvendor/lib/openh264/libopenh264.a new file mode 100644 index 0000000000000000000000000000000000000000..40bc949f674356192d935cffb2a2d9b46ab29d43 GIT binary patch literal 2164292 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