22 #include <wels/codec_api.h> 23 #include <wels/codec_ver.h> 36 #if !OPENH264_VER_AT_LEAST(1, 6) 37 #define SM_SIZELIMITED_SLICE SM_DYN_SLICE 40 #define TARGET_BITRATE_DEFAULT 2*1000*1000 51 #if FF_API_OPENH264_CABAC 60 #define OFFSET(x) offsetof(SVCContext, x) 61 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM 62 #define DEPRECATED AV_OPT_FLAG_DEPRECATED 64 #if FF_API_OPENH264_SLICE_MODE 65 #if OPENH264_VER_AT_LEAST(1, 6) 66 {
"slice_mode",
"set slice mode, use slices/max_nal_size",
OFFSET(
slice_mode),
AV_OPT_TYPE_INT, { .i64 = SM_FIXEDSLCNUM_SLICE }, SM_SINGLE_SLICE, SM_RESERVED,
VE|
DEPRECATED,
"slice_mode" },
68 {
"slice_mode",
"set slice mode, use slices/max_nal_size",
OFFSET(
slice_mode),
AV_OPT_TYPE_INT, { .i64 = SM_AUTO_SLICE }, SM_SINGLE_SLICE, SM_RESERVED,
VE|
DEPRECATED,
"slice_mode" },
70 {
"fixed",
"a fixed number of slices", 0,
AV_OPT_TYPE_CONST, { .i64 = SM_FIXEDSLCNUM_SLICE }, 0, 0,
VE,
"slice_mode" },
71 #if OPENH264_VER_AT_LEAST(1, 6) 75 {
"rowmb",
"one slice per row of macroblocks", 0,
AV_OPT_TYPE_CONST, { .i64 = SM_ROWMB_SLICE }, 0, 0,
VE,
"slice_mode" },
76 {
"auto",
"automatic number of slices according to number of threads", 0,
AV_OPT_TYPE_CONST, { .i64 = SM_AUTO_SLICE }, 0, 0,
VE,
"slice_mode" },
77 {
"dyn",
"Dynamic slicing", 0,
AV_OPT_TYPE_CONST, { .i64 = SM_DYN_SLICE }, 0, 0,
VE,
"slice_mode" },
82 #define PROFILE(name, value) name, NULL, 0, AV_OPT_TYPE_CONST, { .i64 = value }, 0, 0, VE, "profile" 89 #if FF_API_OPENH264_CABAC 99 {
"rc_mode",
"Select rate control mode",
OFFSET(
rc_mode),
AV_OPT_TYPE_INT, { .i64 = RC_QUALITY_MODE }, RC_OFF_MODE, RC_TIMESTAMP_MODE,
VE,
"rc_mode" },
100 {
"off",
"bit rate control off", 0,
AV_OPT_TYPE_CONST, { .i64 = RC_OFF_MODE }, 0, 0,
VE,
"rc_mode" },
101 {
"quality",
"quality mode", 0,
AV_OPT_TYPE_CONST, { .i64 = RC_QUALITY_MODE }, 0, 0,
VE,
"rc_mode" },
102 {
"bitrate",
"bitrate mode", 0,
AV_OPT_TYPE_CONST, { .i64 = RC_BITRATE_MODE }, 0, 0,
VE,
"rc_mode" },
103 {
"buffer",
"using buffer status to adjust the video quality (no bitrate control)", 0,
AV_OPT_TYPE_CONST, { .i64 = RC_BUFFERBASED_MODE }, 0, 0,
VE,
"rc_mode" },
104 #if OPENH264_VER_AT_LEAST(1, 4) 105 {
"timestamp",
"bit rate control based on timestamp", 0,
AV_OPT_TYPE_CONST, { .i64 = RC_TIMESTAMP_MODE }, 0, 0,
VE,
"rc_mode" },
123 WelsDestroySVCEncoder(s->
encoder);
132 SEncParamExt param = { 0 };
135 WelsTraceCallback callback_function;
141 if (WelsCreateSVCEncoder(&s->
encoder)) {
147 log_level = WELS_LOG_DETAIL;
148 (*s->
encoder)->SetOption(s->
encoder, ENCODER_OPTION_TRACE_LEVEL, &log_level);
152 (*s->
encoder)->SetOption(s->
encoder, ENCODER_OPTION_TRACE_CALLBACK, &callback_function);
155 (*s->
encoder)->SetOption(s->
encoder, ENCODER_OPTION_TRACE_CALLBACK_CONTEXT, &avctx);
160 param.iPicWidth = avctx->
width;
161 param.iPicHeight = avctx->
height;
165 if (avctx->
qmax >= 0)
166 param.iMaxQp = av_clip(avctx->
qmax, 1, 51);
167 if (avctx->
qmin >= 0)
168 param.iMinQp = av_clip(avctx->
qmin, 1, param.iMaxQp);
169 param.iTemporalLayerNum = 1;
170 param.iSpatialLayerNum = 1;
171 param.bEnableDenoise = 0;
172 param.bEnableBackgroundDetection = 1;
173 param.bEnableAdaptiveQuant = 1;
175 param.bEnableLongTermReference = 0;
176 param.iLtrMarkPeriod = 30;
178 param.uiIntraPeriod = avctx->
gop_size;
179 #if OPENH264_VER_AT_LEAST(1, 4) 180 param.eSpsPpsIdStrategy = CONSTANT_ID;
182 param.bEnableSpsPpsIdAddition = 0;
184 param.bPrefixNalAddingCtrl = 0;
186 param.iEntropyCodingModeFlag = 0;
200 "Unsupported avctx->profile: %d.\n", avctx->
profile);
204 #if FF_API_CODER_TYPE && FF_API_OPENH264_CABAC 216 #if OPENH264_VER_AT_LEAST(1, 8) 223 #if OPENH264_VER_AT_LEAST(1, 8) 225 param.iEntropyCodingModeFlag = 1;
227 "select EProfileIdc PRO_HIGH in libopenh264.\n");
231 param.iEntropyCodingModeFlag = 1;
233 "select EProfileIdc PRO_MAIN in libopenh264.\n");
238 param.iEntropyCodingModeFlag = 0;
240 "select EProfileIdc PRO_BASELINE in libopenh264.\n");
243 param.iEntropyCodingModeFlag = 0;
245 "select EProfileIdc PRO_BASELINE in libopenh264.\n");
249 param.sSpatialLayers[0].iVideoWidth = param.iPicWidth;
250 param.sSpatialLayers[0].iVideoHeight = param.iPicHeight;
251 param.sSpatialLayers[0].fFrameRate = param.fMaxFrameRate;
252 param.sSpatialLayers[0].iSpatialBitrate = param.iTargetBitrate;
253 param.sSpatialLayers[0].iMaxSpatialBitrate = param.iMaxBitrate;
255 #if OPENH264_VER_AT_LEAST(1, 7) 260 { 1, 1 }, { 12, 11 }, { 10, 11 }, { 16, 11 },
261 { 40, 33 }, { 24, 11 }, { 20, 11 }, { 32, 11 },
262 { 80, 33 }, { 18, 11 }, { 15, 11 }, { 64, 33 },
265 static const ESampleAspectRatio asp_idc[] = {
267 ASP_1x1, ASP_12x11, ASP_10x11, ASP_16x11,
268 ASP_40x33, ASP_24x11, ASP_20x11, ASP_32x11,
269 ASP_80x33, ASP_18x11, ASP_15x11, ASP_64x33,
278 if (num == sar_idc[i].num &&
279 den == sar_idc[i].den)
283 param.sSpatialLayers[0].eAspectRatio = ASP_EXT_SAR;
284 param.sSpatialLayers[0].sAspectRatioExtWidth = num;
285 param.sSpatialLayers[0].sAspectRatioExtHeight = den;
287 param.sSpatialLayers[0].eAspectRatio = asp_idc[
i];
289 param.sSpatialLayers[0].bAspectRatioPresent =
true;
291 param.sSpatialLayers[0].bAspectRatioPresent =
false;
297 "Invalid combination -slices %d and -max_nal_size %d.\n",
308 #if OPENH264_VER_AT_LEAST(1, 6) 309 param.sSpatialLayers[0].sSliceArgument.uiSliceMode = s->
slice_mode;
310 param.sSpatialLayers[0].sSliceArgument.uiSliceNum = avctx->
slices;
312 param.sSpatialLayers[0].sSliceCfg.uiSliceMode = s->
slice_mode;
313 param.sSpatialLayers[0].sSliceCfg.sSliceArgument.uiSliceNum = avctx->
slices;
321 #if OPENH264_VER_AT_LEAST(1, 6) 322 param.sSpatialLayers[0].sSliceArgument.uiSliceSizeConstraint = s->
max_nal_size;
324 param.sSpatialLayers[0].sSliceCfg.sSliceArgument.uiSliceSizeConstraint = s->
max_nal_size;
328 "specify a valid max_nal_size to use -slice_mode dyn\n");
333 if ((*s->
encoder)->InitializeExt(s->
encoder, ¶m) != cmResultSuccess) {
339 SFrameBSInfo fbi = { 0 };
342 for (i = 0; i < fbi.sLayerInfo[0].iNalCount; i++)
343 size += fbi.sLayerInfo[0].pNalLengthInByte[i];
348 memcpy(avctx->
extradata, fbi.sLayerInfo[0].pBsBuf, size);
364 SFrameBSInfo fbi = { 0 };
367 SSourcePicture
sp = { 0 };
368 int size = 0, layer, first_layer = 0;
369 int layer_size[MAX_LAYER_NUM_OF_FRAME] = { 0 };
371 sp.iColorFormat = videoFormatI420;
372 for (i = 0; i < 3; i++) {
374 sp.pData[
i] = frame->
data[
i];
376 sp.iPicWidth = avctx->
width;
377 sp.iPicHeight = avctx->
height;
384 if (encoded != cmResultSuccess) {
388 if (fbi.eFrameType == videoFrameTypeSkip) {
399 first_layer = fbi.iLayerNum - 1;
401 for (layer = first_layer; layer < fbi.iLayerNum; layer++) {
402 for (i = 0; i < fbi.sLayerInfo[layer].iNalCount; i++)
403 layer_size[layer] += fbi.sLayerInfo[layer].pNalLengthInByte[i];
404 size += layer_size[layer];
406 av_log(avctx,
AV_LOG_DEBUG,
"%d slices\n", fbi.sLayerInfo[fbi.iLayerNum - 1].iNalCount);
413 for (layer = first_layer; layer < fbi.iLayerNum; layer++) {
414 memcpy(avpkt->
data + size, fbi.sLayerInfo[layer].pBsBuf, layer_size[layer]);
415 size += layer_size[layer];
418 if (fbi.eFrameType == videoFrameTypeIDR)
433 .
name =
"libopenh264",
446 .priv_class = &
class,
447 .wrapper_name =
"libopenh264",
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
#define FF_PROFILE_H264_MAIN
void ff_libopenh264_trace_callback(void *ctx, int level, const char *msg)
This structure describes decoded (raw) audio or video data.
#define AV_LOG_WARNING
Something somehow does not look correct.
int64_t bit_rate
the average bitrate
#define LIBAVUTIL_VERSION_INT
static av_cold int init(AVCodecContext *avctx)
int max_bitrate
Maximum bitrate of the stream, in bits per second.
const char * av_default_item_name(void *ptr)
Return the context name.
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown) That is the width of a pixel divided by the height of the pixel...
#define PROFILE(name, value)
#define AV_CODEC_CAP_AUTO_THREADS
Codec supports avctx->thread_count == 0 (auto).
Macro definitions for various function/variable attributes.
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
int ff_alloc_packet2(AVCodecContext *avctx, AVPacket *avpkt, int64_t size, int64_t min_size)
Check AVPacket size and/or allocate data.
#define FF_CODEC_CAP_INIT_THREADSAFE
The codec does not modify any global variables in the init function, allowing to call the init functi...
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
static double av_q2d(AVRational a)
Convert an AVRational to a double.
#define AV_LOG_VERBOSE
Detailed information.
int av_reduce(int *dst_num, int *dst_den, int64_t num, int64_t den, int64_t max)
Reduce a fraction.
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
#define i(width, name, range_min, range_max)
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
int qmax
maximum quantizer
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
int flags
AV_CODEC_FLAG_*.
#define FF_PROFILE_H264_HIGH
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
const char * name
Name of the codec implementation.
static av_cold int svc_encode_close(AVCodecContext *avctx)
int flags
A combination of AV_PKT_FLAG values.
static av_cold int svc_encode_init(AVCodecContext *avctx)
common internal API header
enum AVPictureType pict_type
Picture type of the frame.
static const AVOption options[]
int width
picture width / height.
#define FF_PROFILE_UNKNOWN
static const AVCodecDefault svc_enc_defaults[]
attribute_deprecated int coder_type
#define FF_ARRAY_ELEMS(a)
int thread_count
thread count is used to decide how many independent tasks should be passed to execute() ...
This structure describes the bitrate properties of an encoded bitstream.
Libavcodec external API header.
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
main external API structure.
int qmin
minimum quantizer
Describe the class of an AVClass context structure.
Rational number (pair of numerator and denominator).
static int svc_encode_frame(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *frame, int *got_packet)
#define SM_SIZELIMITED_SLICE
static enum AVPixelFormat pix_fmts[]
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
#define AV_CODEC_FLAG_GLOBAL_HEADER
Place global headers in extradata instead of every keyframe.
int gop_size
the number of pictures in a group of pictures, or 0 for intra_only
#define TARGET_BITRATE_DEFAULT
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
#define FF_DISABLE_DEPRECATION_WARNINGS
common internal api header.
common internal and external API header
#define AVERROR_UNKNOWN
Unknown error, typically from an external library.
AVCPBProperties * ff_add_cpb_side_data(AVCodecContext *avctx)
Add a CPB properties side data to an encoding context.
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
int slices
Number of slices.
#define FF_ENABLE_DEPRECATION_WARNINGS
int avg_bitrate
Average bitrate of the stream, in bits per second.
int ff_libopenh264_check_version(void *logctx)
AVCodec ff_libopenh264_encoder
#define FF_PROFILE_H264_CONSTRAINED_BASELINE
AVPixelFormat
Pixel format.
This structure stores compressed data.
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
int64_t rc_max_rate
maximum bitrate