| @@ -0,0 +1,228 @@ |
| | 1 | /* |
| | 2 | * OpenH264 video encoder |
| | 3 | * Copyright (C) 2014 Martin Storsjo |
| | 4 | * |
| | 5 | * This file is part of Libav. |
| | 6 | * |
| | 7 | * Libav is free software; you can redistribute it and/or |
| | 8 | * modify it under the terms of the GNU Lesser General Public |
| | 9 | * License as published by the Free Software Foundation; either |
| | 10 | * version 2.1 of the License, or (at your option) any later version. |
| | 11 | * |
| | 12 | * Libav is distributed in the hope that it will be useful, |
| | 13 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| | 14 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| | 15 | * Lesser General Public License for more details. |
| | 16 | * |
| | 17 | * You should have received a copy of the GNU Lesser General Public |
| | 18 | * License along with Libav; if not, write to the Free Software |
| | 19 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
| | 20 | */ |
| | 21 | |
| | 22 | #include <wels/codec_api.h> |
| | 23 | #include <wels/codec_ver.h> |
| | 24 | |
| | 25 | #include "libavutil/attributes.h" |
| | 26 | #include "libavutil/common.h" |
| | 27 | #include "libavutil/opt.h" |
| | 28 | #include "libavutil/intreadwrite.h" |
| | 29 | #include "libavutil/mathematics.h" |
| | 30 | |
| | 31 | #include "avcodec.h" |
| | 32 | #include "internal.h" |
| | 33 | |
| | 34 | typedef struct SVCContext { |
| | 35 | const AVClass *av_class; |
| | 36 | ISVCEncoder *encoder; |
| | 37 | int slice_mode; |
| | 38 | int loopfilter; |
| | 39 | char *profile; |
| | 40 | } SVCContext; |
| | 41 | |
| | 42 | #define OFFSET(x) offsetof(SVCContext, x) |
| | 43 | #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM |
| | 44 | static const AVOption options[] = { |
| | 45 | { "slice_mode", "Slice mode", OFFSET(slice_mode), AV_OPT_TYPE_INT, { .i64 = SM_AUTO_SLICE }, SM_SINGLE_SLICE, SM_RESERVED, VE, "slice_mode" }, |
| | 46 | { "fixed", "A fixed number of slices", 0, AV_OPT_TYPE_CONST, { .i64 = SM_FIXEDSLCNUM_SLICE }, 0, 0, VE, "slice_mode" }, |
| | 47 | { "rowmb", "One slice per row of macroblocks", 0, AV_OPT_TYPE_CONST, { .i64 = SM_ROWMB_SLICE }, 0, 0, VE, "slice_mode" }, |
| | 48 | { "auto", "Automatic number of slices according to number of threads", 0, AV_OPT_TYPE_CONST, { .i64 = SM_AUTO_SLICE }, 0, 0, VE, "slice_mode" }, |
| | 49 | { "loopfilter", "Enable loop filter", OFFSET(loopfilter), AV_OPT_TYPE_INT, { .i64 = 1 }, 0, 1, VE }, |
| | 50 | { "profile", "Set profile restrictions", OFFSET(profile), AV_OPT_TYPE_STRING, { 0 }, 0, 0, VE }, |
| | 51 | { NULL } |
| | 52 | }; |
| | 53 | |
| | 54 | static const AVClass class = { |
| | 55 | "libopenh264enc", av_default_item_name, options, LIBAVUTIL_VERSION_INT |
| | 56 | }; |
| | 57 | |
| | 58 | static av_cold int svc_encode_close(AVCodecContext *avctx) |
| | 59 | { |
| | 60 | SVCContext *s = avctx->priv_data; |
| | 61 | |
| | 62 | if (s->encoder) |
| | 63 | WelsDestroySVCEncoder(s->encoder); |
| | 64 | return 0; |
| | 65 | } |
| | 66 | |
| | 67 | static av_cold int svc_encode_init(AVCodecContext *avctx) |
| | 68 | { |
| | 69 | SVCContext *s = avctx->priv_data; |
| | 70 | SEncParamExt param = { 0 }; |
| | 71 | int err = AVERROR_UNKNOWN; |
| | 72 | av_unused OpenH264Version libver; |
| | 73 | (void)g_strCodecVer; // Avoid warnings due to unused static members from codec_ver.h |
| | 74 | |
| | 75 | // Mingw GCC < 4.7 on x86_32 uses an incorrect/buggy ABI for the WelsGetCodecVersion |
| | 76 | // function (for functions returning larger structs), thus skip the check in those |
| | 77 | // configurations. |
| | 78 | #if !defined(_WIN32) || !defined(__GNUC__) || !ARCH_X86_32 || AV_GCC_VERSION_AT_LEAST(4, 7) |
| | 79 | libver = WelsGetCodecVersion(); |
| | 80 | if (memcmp(&libver, &g_stCodecVersion, sizeof(libver))) { |
| | 81 | av_log(avctx, AV_LOG_ERROR, "Incorrect library version loaded\n"); |
| | 82 | return AVERROR(EINVAL); |
| | 83 | } |
| | 84 | #endif |
| | 85 | |
| | 86 | if (WelsCreateSVCEncoder(&s->encoder)) { |
| | 87 | av_log(avctx, AV_LOG_ERROR, "Unable to create encoder\n"); |
| | 88 | return AVERROR_UNKNOWN; |
| | 89 | } |
| | 90 | |
| | 91 | (*s->encoder)->GetDefaultParams(s->encoder, ¶m); |
| | 92 | |
| | 93 | param.fMaxFrameRate = avctx->time_base.den / avctx->time_base.num; |
| | 94 | param.iPicWidth = avctx->width; |
| | 95 | param.iPicHeight = avctx->height; |
| | 96 | param.iTargetBitrate = avctx->bit_rate; |
| | 97 | param.iMaxBitrate = FFMAX(avctx->rc_max_rate, avctx->bit_rate); |
| | 98 | param.iRCMode = RC_QUALITY_MODE; |
| | 99 | param.iTemporalLayerNum = 1; |
| | 100 | param.iSpatialLayerNum = 1; |
| | 101 | param.bEnableDenoise = 0; |
| | 102 | param.bEnableBackgroundDetection = 1; |
| | 103 | param.bEnableAdaptiveQuant = 1; |
| | 104 | param.bEnableFrameSkip = 0; |
| | 105 | param.bEnableLongTermReference = 0; |
| | 106 | param.iLtrMarkPeriod = 30; |
| | 107 | param.uiIntraPeriod = avctx->gop_size; |
| | 108 | param.bEnableSpsPpsIdAddition = 0; |
| | 109 | param.bPrefixNalAddingCtrl = 0; |
| | 110 | param.iLoopFilterDisableIdc = !s->loopfilter; |
| | 111 | param.iEntropyCodingModeFlag = 0; |
| | 112 | param.iMultipleThreadIdc = avctx->thread_count; |
| | 113 | if (s->profile && !strcmp(s->profile, "main")) |
| | 114 | param.iEntropyCodingModeFlag = 1; |
| | 115 | else if (!s->profile && avctx->coder_type == FF_CODER_TYPE_AC) |
| | 116 | param.iEntropyCodingModeFlag = 1; |
| | 117 | |
| | 118 | param.sSpatialLayers[0].iVideoWidth = param.iPicWidth; |
| | 119 | param.sSpatialLayers[0].iVideoHeight = param.iPicHeight; |
| | 120 | param.sSpatialLayers[0].fFrameRate = param.fMaxFrameRate; |
| | 121 | param.sSpatialLayers[0].iSpatialBitrate = param.iTargetBitrate; |
| | 122 | param.sSpatialLayers[0].iMaxSpatialBitrate = param.iMaxBitrate; |
| | 123 | |
| | 124 | if (avctx->slices > 1) |
| | 125 | s->slice_mode = SM_FIXEDSLCNUM_SLICE; |
| | 126 | param.sSpatialLayers[0].sSliceCfg.uiSliceMode = s->slice_mode; |
| | 127 | param.sSpatialLayers[0].sSliceCfg.sSliceArgument.uiSliceNum = avctx->slices; |
| | 128 | |
| | 129 | if ((*s->encoder)->InitializeExt(s->encoder, ¶m) != cmResultSuccess) { |
| | 130 | av_log(avctx, AV_LOG_ERROR, "Initialize failed\n"); |
| | 131 | goto fail; |
| | 132 | } |
| | 133 | |
| | 134 | if (avctx->flags & CODEC_FLAG_GLOBAL_HEADER) { |
| | 135 | SFrameBSInfo fbi = { 0 }; |
| | 136 | int i, size = 0; |
| | 137 | (*s->encoder)->EncodeParameterSets(s->encoder, &fbi); |
| | 138 | for (i = 0; i < fbi.sLayerInfo[0].iNalCount; i++) |
| | 139 | size += fbi.sLayerInfo[0].pNalLengthInByte[i]; |
| | 140 | avctx->extradata = av_mallocz(size + FF_INPUT_BUFFER_PADDING_SIZE); |
| | 141 | if (!avctx->extradata) { |
| | 142 | err = AVERROR(ENOMEM); |
| | 143 | goto fail; |
| | 144 | } |
| | 145 | avctx->extradata_size = size; |
| | 146 | memcpy(avctx->extradata, fbi.sLayerInfo[0].pBsBuf, size); |
| | 147 | } |
| | 148 | |
| | 149 | return 0; |
| | 150 | |
| | 151 | fail: |
| | 152 | svc_encode_close(avctx); |
| | 153 | return err; |
| | 154 | } |
| | 155 | |
| | 156 | static int svc_encode_frame(AVCodecContext *avctx, AVPacket *avpkt, |
| | 157 | const AVFrame *frame, int *got_packet) |
| | 158 | { |
| | 159 | SVCContext *s = avctx->priv_data; |
| | 160 | SFrameBSInfo fbi = { 0 }; |
| | 161 | int i, ret; |
| | 162 | int encoded; |
| | 163 | SSourcePicture sp = { 0 }; |
| | 164 | int size = 0, layer, first_layer = 0; |
| | 165 | int layer_size[MAX_LAYER_NUM_OF_FRAME] = { 0 }; |
| | 166 | |
| | 167 | sp.iColorFormat = videoFormatI420; |
| | 168 | for (i = 0; i < 3; i++) { |
| | 169 | sp.iStride[i] = frame->linesize[i]; |
| | 170 | sp.pData[i] = frame->data[i]; |
| | 171 | } |
| | 172 | sp.iPicWidth = avctx->width; |
| | 173 | sp.iPicHeight = avctx->height; |
| | 174 | |
| | 175 | encoded = (*s->encoder)->EncodeFrame(s->encoder, &sp, &fbi); |
| | 176 | if (encoded != cmResultSuccess) { |
| | 177 | av_log(avctx, AV_LOG_ERROR, "EncodeFrame failed\n"); |
| | 178 | return AVERROR_UNKNOWN; |
| | 179 | } |
| | 180 | if (fbi.eFrameType == videoFrameTypeSkip) { |
| | 181 | av_log(avctx, AV_LOG_DEBUG, "frame skipped\n"); |
| | 182 | return 0; |
| | 183 | } |
| | 184 | first_layer = 0; |
| | 185 | // Normal frames are returned with one single layers, while IDR |
| | 186 | // frames have two layers, where the first layer contains the SPS/PPS. |
| | 187 | // If using global headers, don't include the SPS/PPS in the returned |
| | 188 | // packet - thus, only return one layer. |
| | 189 | if (avctx->flags & CODEC_FLAG_GLOBAL_HEADER) |
| | 190 | first_layer = fbi.iLayerNum - 1; |
| | 191 | |
| | 192 | for (layer = first_layer; layer < fbi.iLayerNum; layer++) { |
| | 193 | for (i = 0; i < fbi.sLayerInfo[layer].iNalCount; i++) |
| | 194 | layer_size[layer] += fbi.sLayerInfo[layer].pNalLengthInByte[i]; |
| | 195 | size += layer_size[layer]; |
| | 196 | } |
| | 197 | av_log(NULL, AV_LOG_DEBUG, "%d slices\n", fbi.sLayerInfo[fbi.iLayerNum - 1].iNalCount); |
| | 198 | |
| | 199 | if ((ret = ff_alloc_packet(avpkt, size))) { |
| | 200 | av_log(avctx, AV_LOG_ERROR, "Error getting output packet\n"); |
| | 201 | return ret; |
| | 202 | } |
| | 203 | size = 0; |
| | 204 | for (layer = first_layer; layer < fbi.iLayerNum; layer++) { |
| | 205 | memcpy(avpkt->data + size, fbi.sLayerInfo[layer].pBsBuf, layer_size[layer]); |
| | 206 | size += layer_size[layer]; |
| | 207 | } |
| | 208 | avpkt->pts = frame->pts; |
| | 209 | if (fbi.eFrameType == videoFrameTypeIDR) |
| | 210 | avpkt->flags |= AV_PKT_FLAG_KEY; |
| | 211 | *got_packet = 1; |
| | 212 | return 0; |
| | 213 | } |
| | 214 | |
| | 215 | AVCodec ff_libopenh264_encoder = { |
| | 216 | .name = "libopenh264", |
| | 217 | .type = AVMEDIA_TYPE_VIDEO, |
| | 218 | .id = AV_CODEC_ID_H264, |
| | 219 | .priv_data_size = sizeof(SVCContext), |
| | 220 | .init = svc_encode_init, |
| | 221 | .encode2 = svc_encode_frame, |
| | 222 | .close = svc_encode_close, |
| | 223 | .capabilities = CODEC_CAP_AUTO_THREADS, |
| | 224 | .pix_fmts = (const enum PixelFormat[]){ AV_PIX_FMT_YUV420P, |
| | 225 | AV_PIX_FMT_NONE }, |
| | 226 | .long_name = NULL_IF_CONFIG_SMALL("OpenH264"), |
| | 227 | .priv_class = &class, |
| | 228 | }; |