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);
164 "Could not set framerate for libopenh264enc: integer overflow\n");
169 param.iPicWidth = avctx->
width;
170 param.iPicHeight = avctx->
height;
174 if (avctx->
qmax >= 0)
175 param.iMaxQp = av_clip(avctx->
qmax, 1, 51);
176 if (avctx->
qmin >= 0)
177 param.iMinQp = av_clip(avctx->
qmin, 1, param.iMaxQp);
178 param.iTemporalLayerNum = 1;
179 param.iSpatialLayerNum = 1;
180 param.bEnableDenoise = 0;
181 param.bEnableBackgroundDetection = 1;
182 param.bEnableAdaptiveQuant = 1;
184 param.bEnableLongTermReference = 0;
185 param.iLtrMarkPeriod = 30;
187 param.uiIntraPeriod = avctx->
gop_size;
188 #if OPENH264_VER_AT_LEAST(1, 4) 189 param.eSpsPpsIdStrategy = CONSTANT_ID;
191 param.bEnableSpsPpsIdAddition = 0;
193 param.bPrefixNalAddingCtrl = 0;
195 param.iEntropyCodingModeFlag = 0;
209 "Unsupported avctx->profile: %d.\n", avctx->
profile);
213 #if FF_API_CODER_TYPE && FF_API_OPENH264_CABAC 225 #if OPENH264_VER_AT_LEAST(1, 8) 232 #if OPENH264_VER_AT_LEAST(1, 8) 234 param.iEntropyCodingModeFlag = 1;
236 "select EProfileIdc PRO_HIGH in libopenh264.\n");
240 param.iEntropyCodingModeFlag = 1;
242 "select EProfileIdc PRO_MAIN in libopenh264.\n");
247 param.iEntropyCodingModeFlag = 0;
249 "select EProfileIdc PRO_BASELINE in libopenh264.\n");
252 param.iEntropyCodingModeFlag = 0;
254 "select EProfileIdc PRO_BASELINE in libopenh264.\n");
258 param.sSpatialLayers[0].iVideoWidth = param.iPicWidth;
259 param.sSpatialLayers[0].iVideoHeight = param.iPicHeight;
260 param.sSpatialLayers[0].fFrameRate = param.fMaxFrameRate;
261 param.sSpatialLayers[0].iSpatialBitrate = param.iTargetBitrate;
262 param.sSpatialLayers[0].iMaxSpatialBitrate = param.iMaxBitrate;
264 #if OPENH264_VER_AT_LEAST(1, 7) 269 { 1, 1 }, { 12, 11 }, { 10, 11 }, { 16, 11 },
270 { 40, 33 }, { 24, 11 }, { 20, 11 }, { 32, 11 },
271 { 80, 33 }, { 18, 11 }, { 15, 11 }, { 64, 33 },
274 static const ESampleAspectRatio asp_idc[] = {
276 ASP_1x1, ASP_12x11, ASP_10x11, ASP_16x11,
277 ASP_40x33, ASP_24x11, ASP_20x11, ASP_32x11,
278 ASP_80x33, ASP_18x11, ASP_15x11, ASP_64x33,
287 if (num == sar_idc[i].num &&
288 den == sar_idc[i].den)
292 param.sSpatialLayers[0].eAspectRatio = ASP_EXT_SAR;
293 param.sSpatialLayers[0].sAspectRatioExtWidth = num;
294 param.sSpatialLayers[0].sAspectRatioExtHeight = den;
296 param.sSpatialLayers[0].eAspectRatio = asp_idc[
i];
298 param.sSpatialLayers[0].bAspectRatioPresent =
true;
300 param.sSpatialLayers[0].bAspectRatioPresent =
false;
306 "Invalid combination -slices %d and -max_nal_size %d.\n",
317 #if OPENH264_VER_AT_LEAST(1, 6) 318 param.sSpatialLayers[0].sSliceArgument.uiSliceMode = s->
slice_mode;
319 param.sSpatialLayers[0].sSliceArgument.uiSliceNum = avctx->
slices;
321 param.sSpatialLayers[0].sSliceCfg.uiSliceMode = s->
slice_mode;
322 param.sSpatialLayers[0].sSliceCfg.sSliceArgument.uiSliceNum = avctx->
slices;
330 #if OPENH264_VER_AT_LEAST(1, 6) 331 param.sSpatialLayers[0].sSliceArgument.uiSliceSizeConstraint = s->
max_nal_size;
333 param.sSpatialLayers[0].sSliceCfg.sSliceArgument.uiSliceSizeConstraint = s->
max_nal_size;
337 "specify a valid max_nal_size to use -slice_mode dyn\n");
342 if ((*s->
encoder)->InitializeExt(s->
encoder, ¶m) != cmResultSuccess) {
348 SFrameBSInfo fbi = { 0 };
351 for (i = 0; i < fbi.sLayerInfo[0].iNalCount; i++)
352 size += fbi.sLayerInfo[0].pNalLengthInByte[i];
357 memcpy(avctx->
extradata, fbi.sLayerInfo[0].pBsBuf, size);
373 SFrameBSInfo fbi = { 0 };
376 SSourcePicture
sp = { 0 };
377 int size = 0, layer, first_layer = 0;
378 int layer_size[MAX_LAYER_NUM_OF_FRAME] = { 0 };
380 sp.iColorFormat = videoFormatI420;
381 for (i = 0; i < 3; i++) {
383 sp.pData[
i] = frame->
data[
i];
385 sp.iPicWidth = avctx->
width;
386 sp.iPicHeight = avctx->
height;
393 if (encoded != cmResultSuccess) {
397 if (fbi.eFrameType == videoFrameTypeSkip) {
408 first_layer = fbi.iLayerNum - 1;
410 for (layer = first_layer; layer < fbi.iLayerNum; layer++) {
411 for (i = 0; i < fbi.sLayerInfo[layer].iNalCount; i++)
412 layer_size[layer] += fbi.sLayerInfo[layer].pNalLengthInByte[i];
413 size += layer_size[layer];
415 av_log(avctx,
AV_LOG_DEBUG,
"%d slices\n", fbi.sLayerInfo[fbi.iLayerNum - 1].iNalCount);
422 for (layer = first_layer; layer < fbi.iLayerNum; layer++) {
423 memcpy(avpkt->
data + size, fbi.sLayerInfo[layer].pBsBuf, layer_size[layer]);
424 size += layer_size[layer];
427 if (fbi.eFrameType == videoFrameTypeIDR)
442 .
name =
"libopenh264",
455 .priv_class = &
class,
456 .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)
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
#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 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
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
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
int ticks_per_frame
For some codecs, the time base is closer to the field rate than the frame rate.
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
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later.That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another.Frame references ownership and permissions
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