18#include <winpr/sysinfo.h>
20#include <freerdp/codec/av2.h>
21#include <freerdp/primitives.h>
22#include <freerdp/log.h>
23#include <freerdp/codec/region.h>
27#define TAG FREERDP_TAG("codec.av2")
29#if defined(WITH_LIBAVM)
32#include <avm/avm_decoder.h>
33#include <avm/avm_image.h>
39#if defined(WITH_LIBAVM) && defined(WITH_LIBAVM_ENCODER)
40#define AV2_ENCODER_LIBAVM
41#include <avm/avm_encoder.h>
47#if defined(WITH_DAV2D) && !defined(WITH_LIBAVM)
48#define AV2_DECODER_DAV2D
49#include <dav2d/dav2d.h>
52#if defined(WITH_LIBAVM) || defined(WITH_DAV2D)
54#if defined(WITH_LIBYUV)
59#define AV2_PROFILE_MAIN_420_10_IP0 0
60#define AV2_PROFILE_MAIN_444_10_IP1 4
63#if defined(WITH_LIBAVM) && !defined(AVM_USAGE_REALTIME)
64#define AVM_USAGE_REALTIME AVM_USAGE_GOOD_QUALITY
79struct S_FREERDP_AV2_CONTEXT
84#if defined(WITH_LIBAVM)
86#if defined(AV2_ENCODER_LIBAVM)
87 avm_codec_enc_cfg_t ecfg;
88 avm_codec_pts_t framecount;
89 avm_enc_frame_flags_t eflags;
95 avm_codec_flags_t flags;
96 avm_codec_iface_t* iface;
99#if defined(WITH_LIBAVM)
100 avm_codec_dec_cfg_t dcfg;
102#if defined(AV2_DECODER_DAV2D)
111#if defined(WITH_LIBAVM)
112static void av2_avm_destroy(FREERDP_AV2_CONTEXT* av2)
114 const avm_codec_err_t rc = avm_codec_destroy(&av2->ctx);
115 if (rc != AVM_CODEC_OK)
116 WLog_Print(av2->log, WLOG_WARN,
"avm_codec_destroy: %s", avm_codec_err_to_string(rc));
120#if defined(AV2_ENCODER_LIBAVM)
123static BOOL av2_avm_control(FREERDP_AV2_CONTEXT* av2,
int id,
const char* name,
int value)
125 const avm_codec_err_t rc = avm_codec_control(&av2->ctx,
id, value);
126 if (rc != AVM_CODEC_OK)
128 WLog_Print(av2->log, WLOG_WARN,
"avm_codec_control(%s, %d): %s", name, value,
129 avm_codec_err_to_string(rc));
136BOOL freerdp_av2_context_set_option(FREERDP_AV2_CONTEXT* av2, FREERDP_AV2_CONTEXT_OPTION option,
139#if defined(AV2_ENCODER_LIBAVM)
142 case FREERDP_AV2_CONTEXT_OPTION_PROFILE:
147 WLog_Print(av2->log, WLOG_WARN,
148 "Unknown FREERDP_AV2_CONTEXT_OPTION_PROFILE value %" PRIu32, value);
152 av2->profile = value;
153 av2->ecfg.g_profile =
154 (value == 1) ? AV2_PROFILE_MAIN_444_10_IP1 : AV2_PROFILE_MAIN_420_10_IP0;
157 case FREERDP_AV2_CONTEXT_OPTION_RATECONTROL:
162 case FREERDP_AV2_VBR:
163 av2->ecfg.rc_end_usage = AVM_VBR;
165 case FREERDP_AV2_CBR:
166 av2->ecfg.rc_end_usage = AVM_CBR;
169 av2->ecfg.rc_end_usage = AVM_CQ;
172 av2->ecfg.rc_end_usage = AVM_Q;
175 WLog_Print(av2->log, WLOG_WARN,
176 "Unknown FREERDP_AV2_CONTEXT_OPTION_RATECONTROL value [0x%08" PRIx32
182 case FREERDP_AV2_CONTEXT_OPTION_BITRATE:
185 av2->ecfg.rc_target_bitrate = value;
187 case FREERDP_AV2_CONTEXT_OPTION_USAGETYPE:
190 av2->ecfg.g_usage = value;
192 case FREERDP_AV2_CONTEXT_OPTION_QP:
193 if (!av2->encoder || (value > 255))
197 case FREERDP_AV2_CONTEXT_OPTION_THREADS:
198 if (!av2->encoder || (value > 64))
200 av2->ecfg.g_threads = (value > 0) ? value : 1;
202 case FREERDP_AV2_CONTEXT_OPTION_SPEED:
203 if (!av2->encoder || ((value > 10) && (value != UINT32_MAX)))
207 case FREERDP_AV2_CONTEXT_OPTION_TILE_COLUMNS:
208 if (!av2->encoder || (value > 6))
210 av2->tileColumns = value;
212 case FREERDP_AV2_CONTEXT_OPTION_DPB_SIZE:
213 if (!av2->encoder || (value > 16))
215 av2->dpbSize = value;
218 WLog_Print(av2->log, WLOG_ERROR,
"Unknown FREERDP_AV2_CONTEXT_OPTION[0x%08" PRIx32
"]",
223 if (!av2->initialized)
225 return freerdp_av2_context_reset(av2, av2->ecfg.g_w, av2->ecfg.g_h);
227 WLog_Print(av2->log, WLOG_WARN,
228 "AV2 encoder requires libavm with its encoder, recompile with '-DWITH_AVM=ON'");
229 WINPR_UNUSED(option);
235UINT32 freerdp_av2_context_get_option(FREERDP_AV2_CONTEXT* av2, FREERDP_AV2_CONTEXT_OPTION option)
237#if defined(AV2_ENCODER_LIBAVM)
240 case FREERDP_AV2_CONTEXT_OPTION_PROFILE:
244 case FREERDP_AV2_CONTEXT_OPTION_RATECONTROL:
247 switch (av2->ecfg.rc_end_usage)
250 return FREERDP_AV2_VBR;
252 return FREERDP_AV2_CBR;
254 return FREERDP_AV2_CQ;
257 return FREERDP_AV2_Q;
259 case FREERDP_AV2_CONTEXT_OPTION_BITRATE:
262 return av2->ecfg.rc_target_bitrate;
263 case FREERDP_AV2_CONTEXT_OPTION_USAGETYPE:
266 return av2->ecfg.g_usage;
267 case FREERDP_AV2_CONTEXT_OPTION_QP:
271 case FREERDP_AV2_CONTEXT_OPTION_THREADS:
274 return av2->ecfg.g_threads;
275 case FREERDP_AV2_CONTEXT_OPTION_SPEED:
279 case FREERDP_AV2_CONTEXT_OPTION_TILE_COLUMNS:
282 return av2->tileColumns;
283 case FREERDP_AV2_CONTEXT_OPTION_DPB_SIZE:
288 WLog_Print(av2->log, WLOG_ERROR,
"Unknown FREERDP_AV2_CONTEXT_OPTION[0x%08" PRIx32
"]",
294 WINPR_UNUSED(option);
299INT32 freerdp_av2_compress(FREERDP_AV2_CONTEXT* av2,
const BYTE* pSrcData, DWORD SrcFormat,
300 UINT32 nSrcStep, UINT32 nSrcWidth, UINT32 nSrcHeight,
301 const RECTANGLE_16* regionRect, BYTE** ppDstData, UINT32* pDstSize,
304 *ppDstData =
nullptr;
309 WLog_Print(av2->log, WLOG_ERROR,
"av2->encoder: %d", av2->encoder);
313#if defined(AV2_ENCODER_LIBAVM)
317 WLog_Print(av2->log, WLOG_ERROR,
"primitives_get(): nullptr");
321 if (av2->yuvWidth != nSrcWidth)
323 WLog_Print(av2->log, WLOG_ERROR,
"av2->yuvWidth[%" PRIu32
"] != nSrcWidth[%" PRIu32
"]",
324 av2->yuvWidth, nSrcWidth);
328 if (av2->yuvHeight != nSrcHeight)
330 WLog_Print(av2->log, WLOG_ERROR,
"av2->yuvHeight[%" PRIu32
"] != nSrcHeight[%" PRIu32
"]",
331 av2->yuvHeight, nSrcHeight);
335 const prim_size_t roi = { .width = nSrcWidth, .height = nSrcHeight };
337 avm_image_t buffer = WINPR_C_ARRAY_INIT;
339 avm_image_t* img = &buffer;
341#if defined(WITH_LIBYUV)
345 if ((SrcFormat == PIXEL_FORMAT_BGRA32) || (SrcFormat == PIXEL_FORMAT_BGRX32))
347 switch (av2->profile)
350 img->fmt = AVM_IMG_FMT_I420;
351 img->x_chroma_shift = 1;
352 img->y_chroma_shift = 1;
353 rec = ARGBToI420(pSrcData, nSrcStep, av2->yuvdata[0], av2->yuvStride[0],
354 av2->yuvdata[1], av2->yuvStride[1], av2->yuvdata[2],
355 WINPR_ASSERTING_INT_CAST(
int, av2->yuvStride[2]),
356 WINPR_ASSERTING_INT_CAST(
int, roi.width),
357 WINPR_ASSERTING_INT_CAST(
int, roi.height));
360 img->fmt = AVM_IMG_FMT_I444;
361 rec = ARGBToI444(pSrcData, nSrcStep, av2->yuvdata[0], av2->yuvStride[0],
362 av2->yuvdata[1], av2->yuvStride[1], av2->yuvdata[2],
363 WINPR_ASSERTING_INT_CAST(
int, av2->yuvStride[2]),
364 WINPR_ASSERTING_INT_CAST(
int, roi.width),
365 WINPR_ASSERTING_INT_CAST(
int, roi.height));
368 WLog_Print(av2->log, WLOG_ERROR,
"Unsupported AV2 profile %" PRIu32, av2->profile);
375 switch (av2->profile)
378 img->fmt = AVM_IMG_FMT_I420;
379 img->x_chroma_shift = 1;
380 img->y_chroma_shift = 1;
381 rec = primitives->RGBToYUV420_8u_P3AC4R(pSrcData, SrcFormat, nSrcStep, av2->yuvdata,
382 av2->yuvStride, &roi);
385 img->fmt = AVM_IMG_FMT_I444;
386 rec = primitives->
RGBToI444_8u(pSrcData, SrcFormat, nSrcStep, av2->yuvdata,
387 av2->yuvStride, &roi);
390 WLog_Print(av2->log, WLOG_ERROR,
"Unsupported AV2 profile %" PRIu32, av2->profile);
396 WLog_Print(av2->log, WLOG_ERROR,
"RGB to YUV conversion failed: %d", rec);
400 img->d_w = img->r_w = img->w = roi.width;
401 img->d_h = img->r_h = img->h = roi.height;
402 img->stride[0] = WINPR_ASSERTING_INT_CAST(
int, av2->yuvStride[0]);
403 img->stride[1] = WINPR_ASSERTING_INT_CAST(
int, av2->yuvStride[1]);
404 img->stride[2] = WINPR_ASSERTING_INT_CAST(
int, av2->yuvStride[2]);
405 img->planes[0] = av2->yuvdata[0];
406 img->planes[1] = av2->yuvdata[1];
407 img->planes[2] = av2->yuvdata[2];
409 const avm_codec_err_t rc = avm_codec_encode(&av2->ctx, img, ++av2->framecount, 1, av2->eflags);
412 if (rc != AVM_CODEC_OK)
414 WLog_Print(av2->log, WLOG_WARN,
"avm_codec_encode: %s", avm_codec_err_to_string(rc));
418 avm_codec_iter_t iter =
nullptr;
419 const avm_codec_cx_pkt_t* pkt =
nullptr;
420 while ((pkt = avm_codec_get_cx_data(&av2->ctx, &iter)) !=
nullptr)
422 if (pkt->kind != AVM_CODEC_CX_FRAME_PKT)
425 *ppDstData = pkt->data.frame.buf;
426 *pDstSize = WINPR_ASSERTING_INT_CAST(UINT32, pkt->data.frame.sz);
434 rect->right = WINPR_ASSERTING_INT_CAST(UINT16, nSrcWidth);
435 rect->bottom = WINPR_ASSERTING_INT_CAST(UINT16, nSrcHeight);
437 return allocate_h264_metablock(10, rect, meta, 1);
439 WLog_Print(av2->log, WLOG_ERROR,
440 "AV2 encoder requires libavm with its encoder, recompile with '-DWITH_AVM=ON'");
441 WINPR_UNUSED(pSrcData);
442 WINPR_UNUSED(SrcFormat);
443 WINPR_UNUSED(nSrcStep);
444 WINPR_UNUSED(nSrcWidth);
445 WINPR_UNUSED(nSrcHeight);
446 WINPR_UNUSED(regionRect);
452static BOOL isRectValid(UINT32 width, UINT32 height,
const RECTANGLE_16* rect)
455 if (rect->left > width)
457 if (rect->right > width)
459 if (rect->left >= rect->right)
461 if (rect->top > height)
463 if (rect->bottom > height)
465 if (rect->top >= rect->bottom)
470static BOOL areRectsValid(wLog* log, UINT32 width, UINT32 height,
const RECTANGLE_16* rects,
473 WINPR_ASSERT(rects || (count == 0));
474 for (
size_t x = 0; x < count; x++)
477 if (!isRectValid(width, height, rect))
479 char buffer[64] = WINPR_C_ARRAY_INIT;
480 WLog_Print(log, WLOG_WARN,
481 "Rectangle %" PRIuz
" %s outside of bounding frame %" PRIu32
"x%" PRIu32, x,
482 rectangle_to_string(rect, buffer,
sizeof(buffer)), width, height);
493static BOOL av2_planes_to_8bit(FREERDP_AV2_CONTEXT* av2, av2_planes* planes)
496 WINPR_ASSERT(planes);
499 return (planes->bpc == 8);
500 if ((planes->bpc < 8) || (planes->bpc > 16))
502 WLog_Print(av2->log, WLOG_ERROR,
"AV2 picture bpc %" PRIu32
" not supported", planes->bpc);
506 if ((planes->width > av2->yuvWidth) || (planes->height > av2->yuvHeight))
508 WLog_Print(av2->log, WLOG_ERROR,
509 "AV2 picture %" PRIu32
"x%" PRIu32
" larger than the surface %" PRIu32
511 planes->width, planes->height, av2->yuvWidth, av2->yuvHeight);
515 const UINT32 shift = planes->bpc - 8;
516 for (
size_t p = 0; p < 3; p++)
518 const UINT32 w = ((p == 0) || planes->i444) ? planes->width : (planes->width + 1) / 2;
519 const UINT32 h = ((p == 0) || planes->i444) ? planes->height : (planes->height + 1) / 2;
520 for (UINT32 y = 0; y < h; y++)
522 const UINT16* src = WINPR_PACKED_ALIGN_CAST(
523 const UINT16*, &planes->data[p][1ull * y * planes->stride[p]]);
524 BYTE* dst = &av2->yuvdata[p][1ull * y * av2->yuvStride[p]];
525 for (UINT32 x = 0; x < w; x++)
527 const UINT32 v = src[x] >> shift;
528 dst[x] = (BYTE)MIN(v, UINT8_MAX);
531 planes->data[p] = av2->yuvdata[p];
532 planes->stride[p] = av2->yuvStride[p];
535 planes->highbd = FALSE;
540static INT32 av2_convert(FREERDP_AV2_CONTEXT* av2, av2_planes* planes, BYTE* pDstData,
541 DWORD DstFormat, UINT32 nDstStep, UINT32 nDstWidth, UINT32 nDstHeight,
544 if (!av2_planes_to_8bit(av2, planes))
546 WLog_Print(av2->log, WLOG_ERROR,
"AV2 picture with %" PRIu32
" bit samples not supported",
554 const UINT32 nWidth = (planes->width < nDstWidth) ? planes->width : nDstWidth;
555 const UINT32 nHeight = (planes->height < nDstHeight) ? planes->height : nDstHeight;
556 const prim_size_t roi = { .width = nWidth, .height = nHeight };
558 if (!areRectsValid(av2->log, roi.width, roi.height, regionRects, numRegionRect))
562#if defined(WITH_LIBYUV)
566 if ((DstFormat == PIXEL_FORMAT_BGRA32) || (DstFormat == PIXEL_FORMAT_BGRX32))
568 const int stride0 = WINPR_ASSERTING_INT_CAST(
int, planes->stride[0]);
569 const int stride1 = WINPR_ASSERTING_INT_CAST(
int, planes->stride[1]);
570 const int stride2 = WINPR_ASSERTING_INT_CAST(
int, planes->stride[2]);
571 const int iWidth = WINPR_ASSERTING_INT_CAST(
int, nWidth);
572 const int iHeight = WINPR_ASSERTING_INT_CAST(
int, nHeight);
573 const int iDstStep = WINPR_ASSERTING_INT_CAST(
int, nDstStep);
576 rec = J444ToARGB(planes->data[0], stride0, planes->data[1], stride1, planes->data[2],
577 stride2, pDstData, iDstStep, iWidth, iHeight);
579 rec = J420ToARGB(planes->data[0], stride0, planes->data[1], stride1, planes->data[2],
580 stride2, pDstData, iDstStep, iWidth, iHeight);
588 WLog_Print(av2->log, WLOG_ERROR,
"primitives_get(): nullptr");
593 rec = primitives->
I444ToRGB_8u(planes->data, planes->stride, pDstData, nDstStep,
596 rec = primitives->YUV420ToRGB_8u_P3AC4R(planes->data, planes->stride, pDstData,
597 nDstStep, DstFormat, &roi);
601 WLog_Print(av2->log, WLOG_ERROR,
"YUV to RGB conversion failed: %d", rec);
607#if defined(AV2_DECODER_DAV2D)
608static void av2_dav2d_data_free(WINPR_ATTR_UNUSED
const uint8_t* buf,
609 WINPR_ATTR_UNUSED
void* cookie)
615static INT32 av2_dav2d_drain_one(FREERDP_AV2_CONTEXT* av2, BYTE* pDstData, DWORD DstFormat,
616 UINT32 nDstStep, UINT32 nDstWidth, UINT32 nDstHeight,
619 Dav2dPicture pic = WINPR_C_ARRAY_INIT;
620 const int prc = dav2d_get_picture(av2->dav2d, &pic);
621 if (prc == DAV2D_ERR(EAGAIN))
625 WLog_Print(av2->log, WLOG_WARN,
"dav2d_get_picture: %d", prc);
630 switch (pic.p.layout)
632 case DAV2D_PIXEL_LAYOUT_I420:
633 case DAV2D_PIXEL_LAYOUT_I444:
635 av2_planes planes = { .data = { pic.data[0], pic.data[1], pic.data[2] },
636 .stride = { (UINT32)pic.stride[0], (UINT32)pic.stride[1],
637 (UINT32)pic.stride[1] },
638 .width = (UINT32)pic.p.w,
639 .height = (UINT32)pic.p.h,
640 .bpc = (UINT32)pic.p.bpc,
641 .highbd = (pic.p.bpc > 8),
642 .i444 = (pic.p.layout == DAV2D_PIXEL_LAYOUT_I444) };
643 rc = av2_convert(av2, &planes, pDstData, DstFormat, nDstStep, nDstWidth, nDstHeight,
644 regionRects, numRegionRect);
648 WLog_Print(av2->log, WLOG_ERROR,
"dav2d picture layout %u not supported", pic.p.layout);
651 dav2d_picture_unref(&pic);
652 return (rc == TRUE) ? TRUE : rc;
656INT32 freerdp_av2_decompress(FREERDP_AV2_CONTEXT* av2,
const BYTE* pSrcData, UINT32 SrcSize,
657 BYTE* pDstData, DWORD DstFormat, UINT32 nDstStep, UINT32 nDstWidth,
659 UINT32 numRegionRect)
664 WLog_Print(av2->log, WLOG_ERROR,
"av2->encoder: %d", av2->encoder);
668 if (!areRectsValid(av2->log, nDstWidth, nDstHeight, regionRects, numRegionRect))
671#if defined(AV2_DECODER_DAV2D)
672 Dav2dData data = WINPR_C_ARRAY_INIT;
673 const int wrc = dav2d_data_wrap(&data, pSrcData, SrcSize, av2_dav2d_data_free,
nullptr);
676 WLog_Print(av2->log, WLOG_WARN,
"dav2d_data_wrap: %d", wrc);
682 const int src = dav2d_send_data(av2->dav2d, &data);
683 if ((src < 0) && (src != DAV2D_ERR(EAGAIN)))
685 WLog_Print(av2->log, WLOG_WARN,
"dav2d_send_data: %d", src);
686 dav2d_data_unref(&data);
690 const INT32 rc = av2_dav2d_drain_one(av2, pDstData, DstFormat, nDstStep, nDstWidth,
691 nDstHeight, regionRects, numRegionRect);
692 if ((rc != TRUE) && (rc != FALSE))
694 dav2d_data_unref(&data);
702 const INT32 rc = av2_dav2d_drain_one(av2, pDstData, DstFormat, nDstStep, nDstWidth,
703 nDstHeight, regionRects, numRegionRect);
711#elif defined(WITH_LIBAVM)
712 const avm_codec_err_t rc = avm_codec_decode(&av2->ctx, pSrcData, SrcSize,
nullptr);
713 if (rc != AVM_CODEC_OK)
715 WLog_Print(av2->log, WLOG_WARN,
"avm_codec_decode: %s", avm_codec_err_to_string(rc));
719 avm_image_t* img =
nullptr;
720 avm_codec_iter_t iter =
nullptr;
721 while ((img = avm_codec_get_frame(&av2->ctx, &iter)) !=
nullptr)
723 const avm_img_fmt_t fmt = img->fmt & ~AVM_IMG_FMT_HIGHBITDEPTH;
724 if ((fmt != AVM_IMG_FMT_I420) && (fmt != AVM_IMG_FMT_I444))
726 WLog_Print(av2->log, WLOG_ERROR,
"img->fmt %d not supported", img->fmt);
731 av2_planes planes = { .data = { img->planes[0], img->planes[1], img->planes[2] },
732 .stride = { (UINT32)img->stride[0], (UINT32)img->stride[1],
733 (UINT32)img->stride[2] },
736 .bpc = img->bit_depth,
737 .highbd = (img->fmt & AVM_IMG_FMT_HIGHBITDEPTH) != 0,
738 .i444 = (fmt == AVM_IMG_FMT_I444) };
740 const INT32 crc = av2_convert(av2, &planes, pDstData, DstFormat, nDstStep, nDstWidth,
741 nDstHeight, regionRects, numRegionRect);
750#if defined(WITH_LIBAVM)
753#define AV2_AVM_DECODER_MAX_THREADS 4
755static unsigned int av2_avm_decoder_threads(
void)
757#if defined(__EMSCRIPTEN__)
763 GetNativeSystemInfo(&sysInfo);
764 if (sysInfo.dwNumberOfProcessors < 1)
766 if (sysInfo.dwNumberOfProcessors > AV2_AVM_DECODER_MAX_THREADS)
767 return AV2_AVM_DECODER_MAX_THREADS;
768 return sysInfo.dwNumberOfProcessors;
773BOOL freerdp_av2_context_reset(FREERDP_AV2_CONTEXT* av2, UINT32 width, UINT32 height)
777#if defined(AV2_ENCODER_LIBAVM)
778 av2->ecfg.g_w = width;
779 av2->ecfg.g_h = height;
781 if (av2->initialized)
783 const avm_codec_err_t rc = avm_codec_destroy(&av2->ctx);
784 av2->initialized =
false;
785 if (rc != AVM_CODEC_OK)
787 WLog_Print(av2->log, WLOG_WARN,
"avm_codec_destroy: %s",
788 avm_codec_err_to_string(rc));
793 const avm_codec_err_t rc =
794 avm_codec_enc_init(&av2->ctx, av2->iface, &av2->ecfg, av2->flags);
795 if (rc != AVM_CODEC_OK)
797 WLog_Print(av2->log, WLOG_WARN,
"avm_codec_enc_init: %s", avm_codec_err_to_string(rc));
800 av2->initialized =
true;
803 int cpuUsed = (av2->ecfg.g_usage == AVM_USAGE_REALTIME) ? 9 : 6;
804 if (av2->speed != UINT32_MAX)
805 cpuUsed = (int)av2->speed;
806 if ((avm_codec_control(&av2->ctx, AVME_SET_CPUUSED, cpuUsed) != AVM_CODEC_OK) &&
810 WLog_Print(av2->log, WLOG_WARN,
"AVME_SET_CPUUSED %d refused: 9 instead", cpuUsed);
812 if (!av2_avm_control(av2, AVME_SET_CPUUSED,
"AVME_SET_CPUUSED", cpuUsed))
815 if (!av2_avm_control(av2, AV2E_SET_TUNE_CONTENT,
"AV2E_SET_TUNE_CONTENT",
816 AVM_CONTENT_SCREEN) ||
817 !av2_avm_control(av2, AV2E_SET_ROW_MT,
"AV2E_SET_ROW_MT", 1) ||
818 !av2_avm_control(av2, AV2E_SET_TILE_COLUMNS,
"AV2E_SET_TILE_COLUMNS",
819 (
int)av2->tileColumns))
822 if (((av2->ecfg.rc_end_usage == AVM_Q) || (av2->ecfg.rc_end_usage == AVM_CQ)) &&
823 (av2->qp > 0) && !av2_avm_control(av2, AVME_SET_QP,
"AVME_SET_QP", (
int)av2->qp))
829 if (avm_codec_set_option(&av2->ctx,
"reduced-ref-frame-mvs-mode",
"1") != AVM_CODEC_OK)
830 WLog_Print(av2->log, WLOG_WARN,
"reduced-ref-frame-mvs-mode refused: %s",
831 avm_codec_error(&av2->ctx));
835 if (av2->dpbSize > 0)
837 char dpb[8] = WINPR_C_ARRAY_INIT;
838 (void)_snprintf(dpb,
sizeof(dpb),
"%" PRIu32, av2->dpbSize);
839 if (avm_codec_set_option(&av2->ctx,
"dpb-size", dpb) != AVM_CODEC_OK)
840 WLog_Print(av2->log, WLOG_WARN,
"dpb-size %s refused: %s", dpb,
841 avm_codec_error(&av2->ctx));
845 av2->eflags = AVM_EFLAG_FORCE_KF;
847 WLog_Print(av2->log, WLOG_ERROR,
848 "AV2 encoder requires libavm with its encoder, recompile with '-DWITH_AVM=ON'");
854#if defined(AV2_DECODER_DAV2D)
855 if (av2->initialized)
857 dav2d_close(&av2->dav2d);
858 av2->initialized =
false;
861 Dav2dSettings settings = WINPR_C_ARRAY_INIT;
862 dav2d_default_settings(&settings);
865 settings.n_threads = 1;
866 settings.max_frame_delay = 1;
868 const int rc = dav2d_open(&av2->dav2d, &settings);
871 WLog_Print(av2->log, WLOG_WARN,
"dav2d_open: %d", rc);
874 av2->initialized =
true;
875#elif defined(WITH_LIBAVM)
876 if (av2->initialized)
878 av2_avm_destroy(av2);
879 av2->initialized =
false;
883 av2->dcfg.h = height;
884 av2->dcfg.threads = av2_avm_decoder_threads();
885 const avm_codec_err_t rc =
886 avm_codec_dec_init(&av2->ctx, av2->iface, &av2->dcfg, av2->flags);
887 if (rc != AVM_CODEC_OK)
889 WLog_Print(av2->log, WLOG_WARN,
"avm_codec_dec_init: %s", avm_codec_err_to_string(rc));
892 av2->initialized =
true;
895 if ((av2->dcfg.threads > 1) &&
896 (avm_codec_control(&av2->ctx, AV2D_SET_ROW_MT, 1) != AVM_CODEC_OK))
897 WLog_Print(av2->log, WLOG_WARN,
"AV2D_SET_ROW_MT refused: %s",
898 avm_codec_error(&av2->ctx));
900 WLog_Print(av2->log, WLOG_WARN,
901 "This build does not support AV2 decoding. Recompile with '-DWITH_DAV2D=ON' "
902 "or '-DWITH_AVM=ON'");
907 av2->yuvWidth = width;
908 av2->yuvStride[0] = width;
910 const size_t pad = av2->yuvStride[0] % 16;
912 av2->yuvStride[0] += 16 - pad;
913 av2->yuvStride[1] = av2->yuvStride[0];
914 av2->yuvStride[2] = av2->yuvStride[0];
916 av2->yuvHeight = height;
917 winpr_aligned_free(av2->yuvdata[0]);
918 winpr_aligned_free(av2->yuvdata[1]);
919 winpr_aligned_free(av2->yuvdata[2]);
920 av2->yuvdata[0] = winpr_aligned_malloc(1ull * av2->yuvStride[0] * av2->yuvHeight, 64);
921 av2->yuvdata[1] = winpr_aligned_malloc(1ull * av2->yuvStride[1] * av2->yuvHeight, 64);
922 av2->yuvdata[2] = winpr_aligned_malloc(1ull * av2->yuvStride[2] * av2->yuvHeight, 64);
923 return (av2->yuvdata[0] !=
nullptr) && (av2->yuvdata[1] !=
nullptr) &&
924 (av2->yuvdata[2] !=
nullptr);
927void freerdp_av2_context_free(FREERDP_AV2_CONTEXT* av2)
932 if (av2->initialized)
936#if defined(WITH_LIBAVM)
937 av2_avm_destroy(av2);
942#if defined(AV2_DECODER_DAV2D)
943 dav2d_close(&av2->dav2d);
944#elif defined(WITH_LIBAVM)
945 av2_avm_destroy(av2);
949 winpr_aligned_free(av2->yuvdata[0]);
950 winpr_aligned_free(av2->yuvdata[1]);
951 winpr_aligned_free(av2->yuvdata[2]);
955FREERDP_AV2_CONTEXT* freerdp_av2_context_new(BOOL Compressor)
957 FREERDP_AV2_CONTEXT* ctx = calloc(1,
sizeof(FREERDP_AV2_CONTEXT));
960 ctx->encoder = Compressor;
961 ctx->log = WLog_Get(TAG);
967#if defined(AV2_ENCODER_LIBAVM)
968 ctx->iface = avm_codec_av2_cx();
971 WLog_Print(ctx->log, WLOG_ERROR,
"avm_codec_av2_cx() nullptr");
975 const avm_codec_err_t rc =
976 avm_codec_enc_config_default(ctx->iface, &ctx->ecfg, AVM_USAGE_REALTIME);
977 if (rc != AVM_CODEC_OK)
979 WLog_Print(ctx->log, WLOG_ERROR,
"avm_codec_enc_config_default() %s",
980 avm_codec_err_to_string(rc));
984 ctx->ecfg.g_lag_in_frames = 0;
985 ctx->ecfg.kf_mode = AVM_KF_DISABLED;
986 ctx->ecfg.g_profile = AV2_PROFILE_MAIN_420_10_IP0;
987 ctx->ecfg.g_bit_depth = AVM_BITS_8;
988 ctx->ecfg.g_input_bit_depth = 8;
989 ctx->speed = UINT32_MAX;
991 WLog_Print(ctx->log, WLOG_ERROR,
992 "AV2 encoder requires libavm with its encoder, recompile with '-DWITH_AVM=ON'");
996#if defined(WITH_LIBAVM)
999 ctx->iface = avm_codec_av2_dx();
1002 WLog_Print(ctx->log, WLOG_ERROR,
"avm_codec_av2_dx() nullptr");
1011 freerdp_av2_context_free(ctx);
1016struct S_FREERDP_AV2_CONTEXT
1022BOOL freerdp_av2_context_set_option(WINPR_ATTR_UNUSED FREERDP_AV2_CONTEXT* av2,
1023 WINPR_ATTR_UNUSED FREERDP_AV2_CONTEXT_OPTION option,
1024 WINPR_ATTR_UNUSED UINT32 value)
1029UINT32 freerdp_av2_context_get_option(WINPR_ATTR_UNUSED FREERDP_AV2_CONTEXT* av2,
1030 WINPR_ATTR_UNUSED FREERDP_AV2_CONTEXT_OPTION option)
1035INT32 freerdp_av2_compress(WINPR_ATTR_UNUSED FREERDP_AV2_CONTEXT* av2,
1036 WINPR_ATTR_UNUSED
const BYTE* pSrcData,
1037 WINPR_ATTR_UNUSED DWORD SrcFormat, WINPR_ATTR_UNUSED UINT32 nSrcStep,
1038 WINPR_ATTR_UNUSED UINT32 nSrcWidth, WINPR_ATTR_UNUSED UINT32 nSrcHeight,
1040 WINPR_ATTR_UNUSED BYTE** ppDstData, WINPR_ATTR_UNUSED UINT32* pDstSize,
1044 WLog_Print(av2->log, WLOG_ERROR,
1045 "This build does not support AV2 codec. Recompile with '-DWITH_AVM=ON' or "
1046 "'-DWITH_DAV2D=ON'");
1050INT32 freerdp_av2_decompress(WINPR_ATTR_UNUSED FREERDP_AV2_CONTEXT* av2,
1051 WINPR_ATTR_UNUSED
const BYTE* pSrcData,
1052 WINPR_ATTR_UNUSED UINT32 SrcSize, WINPR_ATTR_UNUSED BYTE* pDstData,
1053 WINPR_ATTR_UNUSED DWORD DstFormat, WINPR_ATTR_UNUSED UINT32 nDstStep,
1054 WINPR_ATTR_UNUSED UINT32 nDstWidth,
1055 WINPR_ATTR_UNUSED UINT32 nDstHeight,
1057 WINPR_ATTR_UNUSED UINT32 numRegionRect)
1060 WLog_Print(av2->log, WLOG_ERROR,
1061 "This build does not support AV2 codec. Recompile with '-DWITH_AVM=ON' or "
1062 "'-DWITH_DAV2D=ON'");
1066BOOL freerdp_av2_context_reset(WINPR_ATTR_UNUSED FREERDP_AV2_CONTEXT* av2,
1067 WINPR_ATTR_UNUSED UINT32 width, WINPR_ATTR_UNUSED UINT32 height)
1070 WLog_Print(av2->log, WLOG_WARN,
1071 "This build does not support AV2 codec. Recompile with '-DWITH_AVM=ON' or "
1072 "'-DWITH_DAV2D=ON'");
1076void freerdp_av2_context_free(WINPR_ATTR_UNUSED FREERDP_AV2_CONTEXT* av2)
1081FREERDP_AV2_CONTEXT* freerdp_av2_context_new(BOOL Compressor)
1083 FREERDP_AV2_CONTEXT* ctx = calloc(1,
sizeof(FREERDP_AV2_CONTEXT));
1086 ctx->Compressor = Compressor;
1087 ctx->log = WLog_Get(TAG);
WINPR_ATTR_NODISCARD fn_RGBToYUV444_8u_P3AC4R_t RGBToI444_8u
WINPR_ATTR_NODISCARD fn_YUV444ToRGB_8u_P3AC4R_t I444ToRGB_8u
Convert a plain YUV444 picture (e.g. decoded AV1) to RGB. Unlike YUV444ToRGB_8u_P3AC4R this does not ...