The branch, master has been updated
via 61b034a47ca2490239b08158a43989627c3c3874 (commit)
via d8e095b56d6b79092a62e870cfb3883b49168970 (commit)
from 7d0483e6a7a72f2b3a86873e6e580c90ca661fce (commit)
- Log -----------------------------------------------------------------
commit 61b034a47ca2490239b08158a43989627c3c3874
Author: Zhao Zhili <[email protected]>
AuthorDate: Tue Oct 7 22:15:50 2025 +0800
Commit: Zhao Zhili <[email protected]>
CommitDate: Thu Nov 27 15:54:49 2025 +0800
avcodec/rkmppenc: add h264/hevc rkmpp encoder
Bump rockchip_mpp to 1.3.8.
Signed-off-by: Zhao Zhili <[email protected]>
diff --git a/Changelog b/Changelog
index e4f7e123d4..cda59ebc90 100644
--- a/Changelog
+++ b/Changelog
@@ -13,6 +13,7 @@ version <next>:
- D3D12 AV1 encoder
- ProRes Vulkan hwaccel
- DPX Vulkan hwaccel
+- Rockchip H.264/HEVC hardware encoder
version 8.0:
diff --git a/configure b/configure
index 7dc99d53ea..7202cbc57a 100755
--- a/configure
+++ b/configure
@@ -3484,6 +3484,7 @@ h264_qsv_decoder_select="h264_mp4toannexb_bsf qsvdec"
h264_qsv_encoder_select="atsc_a53 qsvenc"
h264_rkmpp_decoder_deps="rkmpp"
h264_rkmpp_decoder_select="h264_mp4toannexb_bsf"
+h264_rkmpp_encoder_deps="rkmpp"
h264_vaapi_encoder_select="atsc_a53 cbs_h264 vaapi_encode"
h264_vulkan_encoder_select="atsc_a53 cbs_h264 vulkan_encode"
h264_v4l2m2m_decoder_deps="v4l2_m2m h264_v4l2_m2m"
@@ -3508,6 +3509,7 @@ hevc_qsv_decoder_select="hevc_mp4toannexb_bsf qsvdec"
hevc_qsv_encoder_select="hevcparse qsvenc"
hevc_rkmpp_decoder_deps="rkmpp"
hevc_rkmpp_decoder_select="hevc_mp4toannexb_bsf"
+hevc_rkmpp_encoder_deps="rkmpp"
hevc_vaapi_encoder_deps="VAEncPictureParameterBufferHEVC"
hevc_vaapi_encoder_select="atsc_a53 cbs_h265 vaapi_encode"
hevc_vulkan_encoder_select="atsc_a53 cbs_h265 vulkan_encode"
@@ -7366,7 +7368,7 @@ enabled openssl && { { check_pkg_config openssl
"openssl >= 3.0.0" ope
check_lib openssl openssl/ssl.h
DTLS_get_data_mtu -lssl -lcrypto -lws2_32 -lgdi32 ||
die "ERROR: openssl (>= 1.1.1) not found"; }
enabled pocketsphinx && require_pkg_config pocketsphinx pocketsphinx
pocketsphinx/pocketsphinx.h ps_init
-enabled rkmpp && { require_pkg_config rkmpp "rockchip_mpp >=
1.3.7" rockchip/rk_mpi.h mpp_create &&
+enabled rkmpp && { require_pkg_config rkmpp "rockchip_mpp >=
1.3.8" "rockchip/rk_mpi.h rockchip/mpp_buffer.h" "mpp_create
mpp_buffer_sync_begin_f" &&
{ enabled libdrm ||
die "ERROR: rkmpp requires --enable-libdrm"; }
}
diff --git a/libavcodec/Makefile b/libavcodec/Makefile
index 45c8237181..49d696017d 100644
--- a/libavcodec/Makefile
+++ b/libavcodec/Makefile
@@ -446,6 +446,7 @@ OBJS-$(CONFIG_H264_OMX_ENCODER) += omx.o
OBJS-$(CONFIG_H264_QSV_DECODER) += qsvdec.o
OBJS-$(CONFIG_H264_QSV_ENCODER) += qsvenc_h264.o
OBJS-$(CONFIG_H264_RKMPP_DECODER) += rkmppdec.o
+OBJS-$(CONFIG_H264_RKMPP_ENCODER) += rkmppenc.o
OBJS-$(CONFIG_H264_VAAPI_ENCODER) += vaapi_encode_h264.o h264_levels.o \
h2645data.o hw_base_encode_h264.o
OBJS-$(CONFIG_H264_VULKAN_ENCODER) += vulkan_encode.o vulkan_encode_h264.o
\
@@ -475,6 +476,7 @@ OBJS-$(CONFIG_HEVC_OH_ENCODER) += ohcodec.o ohenc.o
OBJS-$(CONFIG_HEVC_QSV_DECODER) += qsvdec.o
OBJS-$(CONFIG_HEVC_QSV_ENCODER) += qsvenc_hevc.o hevc/ps_enc.o
OBJS-$(CONFIG_HEVC_RKMPP_DECODER) += rkmppdec.o
+OBJS-$(CONFIG_HEVC_RKMPP_ENCODER) += rkmppenc.o
OBJS-$(CONFIG_HEVC_VAAPI_ENCODER) += vaapi_encode_h265.o
h265_profile_level.o \
h2645data.o hw_base_encode_h265.o
OBJS-$(CONFIG_HEVC_VULKAN_ENCODER) += vulkan_encode.o vulkan_encode_h265.o
\
diff --git a/libavcodec/allcodecs.c b/libavcodec/allcodecs.c
index cce23d1541..a335e2bb82 100644
--- a/libavcodec/allcodecs.c
+++ b/libavcodec/allcodecs.c
@@ -156,11 +156,13 @@ extern const FFCodec ff_h264_mediacodec_encoder;
extern const FFCodec ff_h264_mmal_decoder;
extern const FFCodec ff_h264_qsv_decoder;
extern const FFCodec ff_h264_rkmpp_decoder;
+extern const FFCodec ff_h264_rkmpp_encoder;
extern const FFCodec ff_hap_encoder;
extern const FFCodec ff_hap_decoder;
extern const FFCodec ff_hevc_decoder;
extern const FFCodec ff_hevc_qsv_decoder;
extern const FFCodec ff_hevc_rkmpp_decoder;
+extern const FFCodec ff_hevc_rkmpp_encoder;
extern const FFCodec ff_hevc_v4l2m2m_decoder;
extern const FFCodec ff_hnm4_video_decoder;
extern const FFCodec ff_hq_hqa_decoder;
diff --git a/libavcodec/rkmppenc.c b/libavcodec/rkmppenc.c
new file mode 100644
index 0000000000..09501f0bca
--- /dev/null
+++ b/libavcodec/rkmppenc.c
@@ -0,0 +1,584 @@
+/*
+ * RockChip MPP Video Encoder
+ *
+ * This file is part of FFmpeg.
+ *
+ * Copyright (c) 2025 Zhao Zhili <[email protected]>
+ *
+ * FFmpeg is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * FFmpeg is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include "config_components.h"
+
+#include <assert.h>
+#include <stdbool.h>
+
+#include <rockchip/mpp_frame.h>
+#include <rockchip/mpp_packet.h>
+#include <rockchip/rk_mpi.h>
+
+#include "libavutil/avassert.h"
+#include "libavutil/hwcontext.h"
+#include "libavutil/hwcontext_drm.h"
+#include "libavutil/imgutils.h"
+#include "libavutil/log.h"
+#include "libavutil/mem.h"
+#include "libavutil/opt.h"
+
+#include "avcodec.h"
+#include "codec_internal.h"
+#include "encode.h"
+#include "hwconfig.h"
+
+#define RKMPP_TIME_BASE AV_TIME_BASE_Q
+#define RKMPP_ALIGN_SIZE 16
+
+typedef struct RKMPPEncoderContext {
+ const AVClass *av_class;
+
+ MppCtx enc;
+ MppApi *mpi;
+ MppEncCfg cfg;
+ AVFrame *frame;
+
+ MppFrameFormat pix_fmt;
+ int mpp_stride;
+ int mpp_height;
+ // When pix_fmt isn't hardware pixel format
+ MppBufferGroup buf_group;
+ MppBuffer frame_buf;
+
+ MppEncRcMode rc_mode;
+ bool eof_sent;
+} RKMPPEncoderContext;
+
+static const enum AVPixelFormat rkmpp_pix_fmts[] = {
+ AV_PIX_FMT_DRM_PRIME,
+ AV_PIX_FMT_NV12,
+ AV_PIX_FMT_YUV420P,
+ AV_PIX_FMT_NONE
+};
+
+static av_cold int rkmpp_close_encoder(AVCodecContext *avctx)
+{
+ RKMPPEncoderContext *ctx = avctx->priv_data;
+
+ if (ctx->enc) {
+ ctx->mpi->reset(ctx->enc);
+ mpp_destroy(ctx->enc);
+ ctx->enc = NULL;
+ }
+
+ if (ctx->cfg) {
+ mpp_enc_cfg_deinit(ctx->cfg);
+ ctx->cfg = NULL;
+ }
+
+ if (ctx->frame_buf) {
+ mpp_buffer_put(ctx->frame_buf);
+ ctx->frame_buf = NULL;
+ }
+
+ if (ctx->buf_group) {
+ mpp_buffer_group_put(ctx->buf_group);
+ ctx->buf_group = NULL;
+ }
+
+ av_frame_free(&ctx->frame);
+
+ return 0;
+}
+
+static int rkmpp_create_frame_buf(AVCodecContext *avctx)
+{
+ RKMPPEncoderContext *ctx = avctx->priv_data;
+
+ ctx->frame = av_frame_alloc();
+ if (!ctx->frame)
+ return AVERROR(ENOMEM);
+
+ if (avctx->pix_fmt == AV_PIX_FMT_DRM_PRIME)
+ return 0;
+
+ int ret = mpp_buffer_group_get_internal(&ctx->buf_group,
+ MPP_BUFFER_TYPE_DRM | MPP_BUFFER_FLAGS_CACHABLE);
+ if (ret != MPP_OK) {
+ av_log(avctx, AV_LOG_ERROR, "Failed to create buffer group, %d\n",
+ ret);
+ return AVERROR_EXTERNAL;
+ }
+
+ int n = av_image_get_buffer_size(avctx->pix_fmt, ctx->mpp_stride,
+ ctx->mpp_height, 1);
+ if (n < 0)
+ return ret;
+ ret = mpp_buffer_get(ctx->buf_group, &ctx->frame_buf, n);
+ if (ret != MPP_OK) {
+ av_log(avctx, AV_LOG_ERROR, "Failed to get frame buffer, %d\n",
+ ret);
+ return AVERROR_EXTERNAL;
+ }
+
+ return 0;
+}
+
+static int rkmpp_export_extradata(AVCodecContext *avctx)
+{
+ RKMPPEncoderContext *ctx = avctx->priv_data;
+ MppEncHeaderMode mode = (avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER) ?
+ MPP_ENC_HEADER_MODE_DEFAULT : MPP_ENC_HEADER_MODE_EACH_IDR;
+
+ int ret = ctx->mpi->control(ctx->enc, MPP_ENC_SET_HEADER_MODE, &mode);
+ if (ret != MPP_OK) {
+ av_log(avctx, AV_LOG_ERROR, "Failed to set header mode: %d\n", ret);
+ return AVERROR_EXTERNAL;
+ }
+
+ if (!(avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER))
+ return 0;
+
+ size_t size = 4096;
+ avctx->extradata = av_mallocz(size + AV_INPUT_BUFFER_PADDING_SIZE);
+ if (!avctx->extradata)
+ return AVERROR(ENOMEM);
+
+ MppPacket packet = NULL;
+ mpp_packet_init(&packet, avctx->extradata, size);
+ mpp_packet_set_length(packet, 0);
+ ret = ctx->mpi->control(ctx->enc, MPP_ENC_GET_HDR_SYNC, packet);
+ if (ret != MPP_OK) {
+ av_log(avctx, AV_LOG_ERROR, "Failed to get header: %d\n", ret);
+ ret = AVERROR_EXTERNAL;
+ goto out;
+ }
+
+ avctx->extradata_size = mpp_packet_get_length(packet);
+ if (avctx->extradata_size == 0 || avctx->extradata_size > size) {
+ av_log(avctx, AV_LOG_ERROR, "Invalid extradata size %d\n",
+ avctx->extradata_size);
+ ret = AVERROR_EXTERNAL;
+ goto out;
+ }
+
+ ret = 0;
+out:
+ mpp_packet_deinit(&packet);
+
+ return ret;
+}
+
+static av_cold int rkmpp_init_encoder(AVCodecContext *avctx)
+{
+ RKMPPEncoderContext *ctx = avctx->priv_data;
+ int ret;
+
+ MppCodingType codectype;
+ switch (avctx->codec_id) {
+ case AV_CODEC_ID_H264:
+ codectype = MPP_VIDEO_CodingAVC;
+ break;
+ case AV_CODEC_ID_HEVC:
+ codectype = MPP_VIDEO_CodingHEVC;
+ break;
+ default:
+ av_unreachable("Invalid codec_id");
+ }
+
+ ret = mpp_check_support_format(MPP_CTX_ENC, codectype);
+ if (ret != MPP_OK) {
+ av_log(avctx, AV_LOG_ERROR, "The device doesn't support %s\n",
+ avcodec_get_name(avctx->codec_id));
+ return AVERROR_EXTERNAL;
+ }
+
+ ret = mpp_create(&ctx->enc, &ctx->mpi);
+ if (ret != MPP_OK) {
+ av_log(avctx, AV_LOG_ERROR, "Failed to create MPP context (%d).\n",
ret);
+ return AVERROR_EXTERNAL;
+ }
+
+ ret = mpp_init(ctx->enc, MPP_CTX_ENC, codectype);
+ if (ret != MPP_OK) {
+ av_log(avctx, AV_LOG_ERROR, "Failed to initialize MPP context
(%d).\n", ret);
+ return AVERROR_EXTERNAL;
+ }
+
+ ret = mpp_enc_cfg_init(&ctx->cfg);
+ if (ret != MPP_OK) {
+ av_log(avctx, AV_LOG_ERROR, "Failed to initialize config (%d).\n",
ret);
+ return AVERROR_EXTERNAL;
+ }
+
+ MppEncCfg cfg = ctx->cfg;
+ ret = ctx->mpi->control(ctx->enc, MPP_ENC_GET_CFG, cfg);
+ if (ret != MPP_OK) {
+ av_log(avctx, AV_LOG_ERROR, "Failed to get encoder config: %d\n", ret);
+ return AVERROR_EXTERNAL;
+ }
+
+ mpp_enc_cfg_set_s32(cfg, "prep:width", avctx->width);
+ mpp_enc_cfg_set_s32(cfg, "prep:height", avctx->height);
+ ctx->mpp_stride = FFALIGN(avctx->width, RKMPP_ALIGN_SIZE);
+ ctx->mpp_height = FFALIGN(avctx->height, RKMPP_ALIGN_SIZE);
+ mpp_enc_cfg_set_s32(cfg, "prep:hor_stride", ctx->mpp_stride);
+ mpp_enc_cfg_set_s32(cfg, "prep:ver_stride", ctx->mpp_height);
+
+ if (avctx->pix_fmt == AV_PIX_FMT_DRM_PRIME || avctx->pix_fmt ==
AV_PIX_FMT_NV12)
+ ctx->pix_fmt = MPP_FMT_YUV420SP;
+ else if (avctx->pix_fmt == AV_PIX_FMT_YUV420P)
+ ctx->pix_fmt = MPP_FMT_YUV420P;
+ else // Can only happen during development
+ return AVERROR_BUG;
+ mpp_enc_cfg_set_s32(cfg, "prep:format", ctx->pix_fmt);
+
+ if (avctx->colorspace != AVCOL_SPC_UNSPECIFIED)
+ mpp_enc_cfg_set_s32(cfg, "prep:colorspace", avctx->colorspace);
+ if (avctx->color_primaries != AVCOL_PRI_UNSPECIFIED)
+ mpp_enc_cfg_set_s32(cfg, "prep:colorprim", avctx->color_primaries);
+ if (avctx->color_trc != AVCOL_TRC_UNSPECIFIED)
+ mpp_enc_cfg_set_s32(cfg, "prep:colortrc", avctx->color_trc);
+ static_assert((int)AVCOL_RANGE_MPEG == (int)MPP_FRAME_RANGE_MPEG &&
+ (int)AVCOL_RANGE_JPEG == (int)MPP_FRAME_RANGE_JPEG &&
+ (int)AVCOL_RANGE_UNSPECIFIED == (int) MPP_FRAME_RANGE_UNSPECIFIED,
+ "MppFrameColorRange not equal to AVColorRange");
+ mpp_enc_cfg_set_s32(cfg, "prep:colorrange", avctx->color_range);
+
+ /* These two options sound like variable frame rate from the doc, but they
+ * are not. When they are false, bitrate control is based on frame numbers
+ * and framerate. But when they are true, bitrate control is based on wall
+ * clock time, not based on frame timestamps, which makes these options
+ * almost useless, except in certain rare realtime case.
+ */
+ mpp_enc_cfg_set_s32(cfg, "rc:fps_in_flex", 0);
+ mpp_enc_cfg_set_s32(cfg, "rc:fps_out_flex", 0);
+ if (avctx->framerate.den > 0 && avctx->framerate.num > 0) {
+ mpp_enc_cfg_set_s32(cfg, "rc:fps_in_num", avctx->framerate.num);
+ mpp_enc_cfg_set_s32(cfg, "rc:fps_in_denom", avctx->framerate.den);
+ mpp_enc_cfg_set_s32(cfg, "rc:fps_out_num", avctx->framerate.num);
+ mpp_enc_cfg_set_s32(cfg, "rc:fps_out_denom", avctx->framerate.den);
+ }
+
+ if (avctx->gop_size >= 0)
+ mpp_enc_cfg_set_s32(cfg, "rc:gop", avctx->gop_size);
+
+ mpp_enc_cfg_set_u32(cfg, "rc:mode", ctx->rc_mode);
+ if (avctx->bit_rate > 0) {
+ mpp_enc_cfg_set_s32(cfg, "rc:bps_target", avctx->bit_rate);
+ if (avctx->rc_buffer_size >= avctx->bit_rate) {
+ int seconds = round((double)avctx->rc_buffer_size /
avctx->bit_rate);
+ // 60 is the upper bound from the doc
+ seconds = FFMIN(seconds, 60);
+ mpp_enc_cfg_set_s32(cfg, "rc:stats_time", seconds);
+ }
+ }
+ if (avctx->rc_max_rate > 0)
+ mpp_enc_cfg_set_s32(cfg, "rc:bps_max", avctx->rc_max_rate);
+ if (avctx->rc_min_rate > 0)
+ mpp_enc_cfg_set_s32(cfg, "rc:bps_min", avctx->rc_min_rate);
+
+ mpp_enc_cfg_set_u32(cfg, "rc:drop_mode", MPP_ENC_RC_DROP_FRM_DISABLED);
+
+ ret = ctx->mpi->control(ctx->enc, MPP_ENC_SET_CFG, cfg);
+ if (ret != MPP_OK) {
+ av_log(avctx, AV_LOG_ERROR, "Failed to set config: %d\n", ret);
+ return AVERROR_EXTERNAL;
+ }
+
+ ret = rkmpp_create_frame_buf(avctx);
+ if (ret < 0)
+ return ret;
+
+ ret = rkmpp_export_extradata(avctx);
+ if (ret < 0)
+ return ret;
+
+ return 0;
+}
+
+static int rkmpp_output_pkt(AVCodecContext *avctx, AVPacket *pkt, MppPacket
packet)
+{
+ if (mpp_packet_get_eos(packet)) {
+ av_log(avctx, AV_LOG_INFO, "Receive eos packet\n");
+ return AVERROR_EOF;
+ }
+
+ size_t size = mpp_packet_get_length(packet);
+ void *data = mpp_packet_get_pos(packet);
+
+ if (!size || !data) {
+ av_log(avctx, AV_LOG_ERROR, "Encoder return empty packet\n");
+ return AVERROR_EXTERNAL;
+ }
+
+ int ret = ff_get_encode_buffer(avctx, pkt, size, 0);
+ if (ret < 0)
+ return ret;
+ memcpy(pkt->data, data, size);
+
+ int64_t pts = mpp_packet_get_pts(packet);
+ int64_t dts = mpp_packet_get_dts(packet);
+
+ pkt->pts = av_rescale_q(pts, RKMPP_TIME_BASE, avctx->time_base);
+ /* dts is always zero currently, since rkmpp copy dts from MppFrame to
+ * MppPacket, and we don't set dts for MppFrame (it make no sense for
+ * encoder). rkmpp encoder doesn't support reordering, so we can just
+ * set dts as pts.
+ *
+ * TODO: remove this workaround once rkmpp fixed the issue.
+ */
+ if (dts)
+ pkt->dts = av_rescale_q(dts, RKMPP_TIME_BASE, avctx->time_base);
+ else
+ pkt->dts = pkt->pts;
+
+ MppMeta meta = mpp_packet_get_meta(packet);
+ if (!meta) {
+ av_log(avctx, AV_LOG_ERROR, "Failed to get meta from mpp packet\n");
+ return AVERROR_EXTERNAL;
+ }
+
+ int key_frame = 0;
+ ret = mpp_meta_get_s32(meta, KEY_OUTPUT_INTRA, &key_frame);
+ if (ret != MPP_OK) {
+ av_log(avctx, AV_LOG_ERROR, "Failed to get key frame info\n");
+ return AVERROR_EXTERNAL;
+ }
+
+ if (key_frame)
+ pkt->flags |= AV_PKT_FLAG_KEY;
+
+ return 0;
+}
+
+static int rkmpp_set_hw_frame(AVCodecContext *avctx, MppFrame frame)
+{
+ RKMPPEncoderContext *ctx = avctx->priv_data;
+ AVBufferRef *hw_ref = ctx->frame->hw_frames_ctx;
+ int ret;
+
+ if (!hw_ref)
+ return AVERROR(EINVAL);
+
+ AVHWFramesContext *hwframes = (AVHWFramesContext *)hw_ref->data;
+ if (hwframes->sw_format != AV_PIX_FMT_NV12)
+ return AVERROR(EINVAL);
+
+
+ const AVDRMFrameDescriptor *desc = (AVDRMFrameDescriptor
*)ctx->frame->data[0];
+ const AVDRMLayerDescriptor *layer = &desc->layers[0];
+
+ int stride = layer->planes[0].pitch;
+ int vertical = layer->planes[1].offset / stride;
+ if (stride != ctx->mpp_stride || vertical != ctx->mpp_height) {
+ // Update stride info
+ ctx->mpp_stride = stride;
+ ctx->mpp_height = vertical;
+ mpp_enc_cfg_set_s32(ctx->cfg, "prep:hor_stride", ctx->mpp_stride);
+ mpp_enc_cfg_set_s32(ctx->cfg, "prep:ver_stride", ctx->mpp_height);
+ ret = ctx->mpi->control(ctx->enc, MPP_ENC_SET_CFG, ctx->cfg);
+ if (ret != MPP_OK) {
+ av_log(avctx, AV_LOG_ERROR, "Failed to set config: %d\n", ret);
+ return AVERROR_EXTERNAL;
+ }
+ }
+ mpp_frame_set_hor_stride(frame, stride);
+ mpp_frame_set_ver_stride(frame, vertical);
+
+ MppBuffer buffer = {0};
+ MppBufferInfo info = {
+ .type = MPP_BUFFER_TYPE_DRM,
+ .size = desc->objects[0].size,
+ .fd = desc->objects[0].fd,
+ };
+ ret = mpp_buffer_import(&buffer, &info);
+ if (ret != MPP_OK)
+ return AVERROR_EXTERNAL;
+
+ mpp_frame_set_buffer(frame, buffer);
+ mpp_buffer_put(buffer);
+
+ return 0;
+}
+
+static int rkmpp_set_sw_frame(AVCodecContext *avctx, MppFrame frame)
+{
+ RKMPPEncoderContext *ctx = avctx->priv_data;
+ AVFrame *f = ctx->frame;
+
+ mpp_buffer_sync_begin(ctx->frame_buf);
+ void *buf = mpp_buffer_get_ptr(ctx->frame_buf);
+
+ uint8_t *dst[4] = {NULL};
+ int dst_linesizes[4] = {0};
+ int ret = av_image_fill_linesizes(dst_linesizes, f->format,
ctx->mpp_stride);
+ if (ret < 0)
+ goto out;
+ ret = av_image_fill_pointers(dst, f->format, ctx->mpp_height, buf,
+ dst_linesizes);
+ if (ret < 0)
+ goto out;
+
+ av_image_copy2(dst, dst_linesizes, f->data, f->linesize,
+ f->format, f->width, f->height);
+ mpp_frame_set_hor_stride(frame, ctx->mpp_stride);
+ mpp_frame_set_ver_stride(frame, ctx->mpp_height);
+
+ ret = 0;
+
+out:
+ mpp_buffer_sync_end(ctx->frame_buf);
+ if (!ret)
+ mpp_frame_set_buffer(frame, ctx->frame_buf);
+
+ return ret;
+}
+
+static int rkmpp_send_frame(AVCodecContext *avctx)
+{
+ RKMPPEncoderContext *ctx = avctx->priv_data;
+ MppFrame frame = NULL;
+ int ret = 0;
+
+ ret = mpp_frame_init(&frame);
+ if (ret != MPP_OK) {
+ ret = AVERROR_EXTERNAL;
+ goto out;
+ }
+
+ if (ctx->frame->buf[0]) {
+ if (ctx->frame->format == AV_PIX_FMT_DRM_PRIME)
+ ret = rkmpp_set_hw_frame(avctx, frame);
+ else
+ ret = rkmpp_set_sw_frame(avctx, frame);
+
+ if (ret < 0)
+ goto out;
+
+ mpp_frame_set_fmt(frame, ctx->pix_fmt);
+ mpp_frame_set_width(frame, ctx->frame->width);
+ mpp_frame_set_height(frame, ctx->frame->height);
+ mpp_frame_set_pts(frame, av_rescale_q(ctx->frame->pts,
+ avctx->time_base, RKMPP_TIME_BASE));
+ } else {
+ mpp_frame_set_buffer(frame, NULL);
+ mpp_frame_set_eos(frame, 1);
+ }
+
+ ret = ctx->mpi->encode_put_frame(ctx->enc, frame);
+ if (ret != MPP_OK)
+ ret = AVERROR_EXTERNAL;
+
+out:
+ if (frame)
+ mpp_frame_deinit(&frame);
+
+ return ret;
+}
+
+static int rkmpp_receive(AVCodecContext *avctx, AVPacket *pkt)
+{
+ RKMPPEncoderContext *ctx = avctx->priv_data;
+
+ while (true) {
+ MppPacket packet = NULL;
+ int ret = ctx->mpi->encode_get_packet(ctx->enc, &packet);
+
+ if (ret == MPP_OK && packet) {
+ ret = rkmpp_output_pkt(avctx, pkt, packet);
+ mpp_packet_deinit(&packet);
+ return ret;
+ }
+
+ if (ctx->eof_sent)
+ continue;
+
+ if (!ctx->frame->buf[0]) {
+ ret = ff_encode_get_frame(avctx, ctx->frame);
+ if (ret < 0 && ret != AVERROR_EOF)
+ return ret;
+ }
+
+ ret = rkmpp_send_frame(avctx);
+ if (ret < 0)
+ return ret;
+
+ if (!ctx->frame->buf[0])
+ ctx->eof_sent = true;
+ else
+ av_frame_unref(ctx->frame);
+ }
+}
+
+static av_cold void rkmpp_flush(AVCodecContext *avctx)
+{
+ RKMPPEncoderContext *ctx = avctx->priv_data;
+ ctx->mpi->reset(ctx->enc);
+ ctx->eof_sent = true;
+}
+
+static const AVCodecHWConfigInternal *const rkmpp_hw_configs[] = {
+ HW_CONFIG_ENCODER_FRAMES(DRM_PRIME, DRM),
+ NULL
+};
+
+#define OFFSET(x) offsetof(RKMPPEncoderContext, x)
+#define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
+static const AVOption rkmpp_options[] = {
+ {"rc", "rate-control mode",
+ OFFSET(rc_mode), AV_OPT_TYPE_INT, { .i64 = MPP_ENC_RC_MODE_VBR },
MPP_ENC_RC_MODE_VBR, INT_MAX, VE, .unit = "rc"},
+ {"vbr", "Variable bitrate mode",
+ 0, AV_OPT_TYPE_CONST, {.i64 = MPP_ENC_RC_MODE_VBR}, 0, 0, VE,
.unit = "rc"},
+ {"cbr", "Constant bitrate mode",
+ 0, AV_OPT_TYPE_CONST, {.i64 = MPP_ENC_RC_MODE_CBR}, 0, 0, VE,
.unit = "rc"},
+ {"avbr", "Adaptive bit rate mode",
+ 0, AV_OPT_TYPE_CONST, {.i64 = MPP_ENC_RC_MODE_AVBR}, 0, 0, VE,
.unit = "rc"},
+ {NULL},
+};
+
+static const AVClass rkmpp_enc_class = {
+ .class_name = "rkmpp_enc",
+ .item_name = av_default_item_name,
+ .version = LIBAVUTIL_VERSION_INT,
+ .option = rkmpp_options,
+};
+
+#define RKMPP_ENC(NAME, ID) \
+ const FFCodec ff_##NAME##_rkmpp_encoder = { \
+ .p.name = #NAME "_rkmpp", \
+ CODEC_LONG_NAME(#NAME " (rkmpp)"), \
+ .p.type = AVMEDIA_TYPE_VIDEO, \
+ .p.id = ID, \
+ .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY | \
+ AV_CODEC_CAP_HARDWARE | AV_CODEC_CAP_ENCODER_FLUSH, \
+ .priv_data_size = sizeof(RKMPPEncoderContext), \
+ CODEC_PIXFMTS_ARRAY(rkmpp_pix_fmts), \
+ .color_ranges = AVCOL_RANGE_MPEG | AVCOL_RANGE_JPEG, \
+ .init = rkmpp_init_encoder, \
+ FF_CODEC_RECEIVE_PACKET_CB(rkmpp_receive), \
+ .close = rkmpp_close_encoder, \
+ .flush = rkmpp_flush, \
+ .p.priv_class = &rkmpp_enc_class, \
+ .caps_internal = FF_CODEC_CAP_INIT_CLEANUP, \
+ .p.wrapper_name = "rkmpp", \
+ .hw_configs = rkmpp_hw_configs, \
+ };
+
+#if CONFIG_H264_RKMPP_ENCODER
+RKMPP_ENC(h264, AV_CODEC_ID_H264)
+#endif
+
+#if CONFIG_HEVC_RKMPP_ENCODER
+RKMPP_ENC(hevc, AV_CODEC_ID_HEVC)
+#endif
diff --git a/libavcodec/version.h b/libavcodec/version.h
index d0980e28de..da6f3a84ac 100644
--- a/libavcodec/version.h
+++ b/libavcodec/version.h
@@ -29,7 +29,7 @@
#include "version_major.h"
-#define LIBAVCODEC_VERSION_MINOR 20
+#define LIBAVCODEC_VERSION_MINOR 21
#define LIBAVCODEC_VERSION_MICRO 100
#define LIBAVCODEC_VERSION_INT AV_VERSION_INT(LIBAVCODEC_VERSION_MAJOR, \
commit d8e095b56d6b79092a62e870cfb3883b49168970
Author: Zhao Zhili <[email protected]>
AuthorDate: Wed Nov 5 11:30:37 2025 +0800
Commit: Zhao Zhili <[email protected]>
CommitDate: Thu Nov 27 15:54:42 2025 +0800
configure: cleanup rkmpp check
Signed-off-by: Zhao Zhili <[email protected]>
diff --git a/configure b/configure
index fd6f602e1d..7dc99d53ea 100755
--- a/configure
+++ b/configure
@@ -7366,8 +7366,7 @@ enabled openssl && { { check_pkg_config openssl
"openssl >= 3.0.0" ope
check_lib openssl openssl/ssl.h
DTLS_get_data_mtu -lssl -lcrypto -lws2_32 -lgdi32 ||
die "ERROR: openssl (>= 1.1.1) not found"; }
enabled pocketsphinx && require_pkg_config pocketsphinx pocketsphinx
pocketsphinx/pocketsphinx.h ps_init
-enabled rkmpp && { require_pkg_config rkmpp rockchip_mpp
rockchip/rk_mpi.h mpp_create &&
- require_pkg_config rockchip_mpp "rockchip_mpp
>= 1.3.7" rockchip/rk_mpi.h mpp_create &&
+enabled rkmpp && { require_pkg_config rkmpp "rockchip_mpp >=
1.3.7" rockchip/rk_mpi.h mpp_create &&
{ enabled libdrm ||
die "ERROR: rkmpp requires --enable-libdrm"; }
}
-----------------------------------------------------------------------
Summary of changes:
Changelog | 1 +
configure | 5 +-
libavcodec/Makefile | 2 +
libavcodec/allcodecs.c | 2 +
libavcodec/rkmppenc.c | 584 +++++++++++++++++++++++++++++++++++++++++++++++++
libavcodec/version.h | 2 +-
6 files changed, 593 insertions(+), 3 deletions(-)
create mode 100644 libavcodec/rkmppenc.c
hooks/post-receive
--
_______________________________________________
ffmpeg-cvslog mailing list -- [email protected]
To unsubscribe send an email to [email protected]
