FFmpeg: libavcodec/amfenc.c Source File

FFmpeg

[フレーム]

libavcodec

amfenc.c

Go to the documentation of this file.

1 /*

2 * This file is part of FFmpeg.

3 *

4 * FFmpeg is free software; you can redistribute it and/or

5 * modify it under the terms of the GNU Lesser General Public

6 * License as published by the Free Software Foundation; either

7 * version 2.1 of the License, or (at your option) any later version.

8 *

9 * FFmpeg is distributed in the hope that it will be useful,

10 * but WITHOUT ANY WARRANTY; without even the implied warranty of

11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

12 * Lesser General Public License for more details.

13 *

14 * You should have received a copy of the GNU Lesser General Public

15 * License along with FFmpeg; if not, write to the Free Software

16 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

17 */

19 #include "config.h"

20 #include "config_components.h"

22 #include "libavutil/avassert.h"

23 #include "libavutil/imgutils.h"

24 #include "libavutil/hwcontext.h"

25 #include "libavutil/hwcontext_amf.h"

26 #include "libavutil/hwcontext_amf_internal.h"

27 #if CONFIG_D3D11VA

28 #include "libavutil/hwcontext_d3d11va.h"

29 #endif

30 #if CONFIG_DXVA2

31 #define COBJMACROS

32 #include "libavutil/hwcontext_dxva2.h"

33 #endif

34 #include "libavutil/mem.h"

35 #include "libavutil/pixdesc.h"

36 #include "libavutil/time.h"

38 #include "amfenc.h"

39 #include "encode.h"

40 #include "internal.h"

41 #include "libavutil/mastering_display_metadata.h"

43 #define AMF_AV_FRAME_REF L"av_frame_ref"

44 #define PTS_PROP L"PtsProp"

46 static int amf_save_hdr_metadata(AVCodecContext *avctx, const AVFrame *frame, AMFHDRMetadata *hdrmeta)

47 {

48 AVFrameSideData *sd_display;

49 AVFrameSideData *sd_light;

50 AVMasteringDisplayMetadata *display_meta;

51 AVContentLightMetadata *light_meta;

53 sd_display = av_frame_get_side_data(frame, AV_FRAME_DATA_MASTERING_DISPLAY_METADATA);

54 if (sd_display) {

55 display_meta = (AVMasteringDisplayMetadata *)sd_display->data;

56 if (display_meta->has_luminance) {

57 const unsigned int luma_den = 10000;

58 hdrmeta->maxMasteringLuminance =

59 (amf_uint32)(luma_den * av_q2d(display_meta->max_luminance));

60 hdrmeta->minMasteringLuminance =

61 FFMIN((amf_uint32)(luma_den * av_q2d(display_meta->min_luminance)), hdrmeta->maxMasteringLuminance);

62 }

63 if (display_meta->has_primaries) {

64 const unsigned int chroma_den = 50000;

65 hdrmeta->redPrimary[0] =

66 FFMIN((amf_uint16)(chroma_den * av_q2d(display_meta->display_primaries[0][0])), chroma_den);

67 hdrmeta->redPrimary[1] =

68 FFMIN((amf_uint16)(chroma_den * av_q2d(display_meta->display_primaries[0][1])), chroma_den);

69 hdrmeta->greenPrimary[0] =

70 FFMIN((amf_uint16)(chroma_den * av_q2d(display_meta->display_primaries[1][0])), chroma_den);

71 hdrmeta->greenPrimary[1] =

72 FFMIN((amf_uint16)(chroma_den * av_q2d(display_meta->display_primaries[1][1])), chroma_den);

73 hdrmeta->bluePrimary[0] =

74 FFMIN((amf_uint16)(chroma_den * av_q2d(display_meta->display_primaries[2][0])), chroma_den);

75 hdrmeta->bluePrimary[1] =

76 FFMIN((amf_uint16)(chroma_den * av_q2d(display_meta->display_primaries[2][1])), chroma_den);

77 hdrmeta->whitePoint[0] =

78 FFMIN((amf_uint16)(chroma_den * av_q2d(display_meta->white_point[0])), chroma_den);

79 hdrmeta->whitePoint[1] =

80 FFMIN((amf_uint16)(chroma_den * av_q2d(display_meta->white_point[1])), chroma_den);

81 }

83 sd_light = av_frame_get_side_data(frame, AV_FRAME_DATA_CONTENT_LIGHT_LEVEL);

84 if (sd_light) {

85 light_meta = (AVContentLightMetadata *)sd_light->data;

86 if (light_meta) {

87 hdrmeta->maxContentLightLevel = (amf_uint16)light_meta->MaxCLL;

88 hdrmeta->maxFrameAverageLightLevel = (amf_uint16)light_meta->MaxFALL;

89 }

90 }

91 return 0;

92 }

93 return 1;

94 }

96 #if CONFIG_D3D11VA

97 #include <d3d11.h>

98 #endif

100 #ifdef _WIN32

101 #include "compat/w32dlfcn.h"

102 #else

103 #include <dlfcn.h>

104 #endif

105

106 #define FFMPEG_AMF_WRITER_ID L"ffmpeg_amf"

107

108

109 const enum AVPixelFormat ff_amf_pix_fmts[] = {

110 AV_PIX_FMT_NV12,

111 AV_PIX_FMT_YUV420P,

112 #if CONFIG_D3D11VA

113 AV_PIX_FMT_D3D11,

114 #endif

115 #if CONFIG_DXVA2

116 AV_PIX_FMT_DXVA2_VLD,

117 #endif

118 AV_PIX_FMT_P010,

119 AV_PIX_FMT_AMF_SURFACE,

120 AV_PIX_FMT_BGR0,

121 AV_PIX_FMT_RGB0,

122 AV_PIX_FMT_BGRA,

123 AV_PIX_FMT_ARGB,

124 AV_PIX_FMT_RGBA,

125 AV_PIX_FMT_X2BGR10,

126 AV_PIX_FMT_RGBAF16,

127 AV_PIX_FMT_NONE

128 };

129

130 static int64_t next_encoder_index = 0;

131

132 static int amf_init_encoder(AVCodecContext *avctx)

133 {

134 AMFEncoderContext *ctx = avctx->priv_data;

135 const wchar_t *codec_id = NULL;

136 AMF_RESULT res;

137 enum AVPixelFormat pix_fmt;

138 AVHWDeviceContext *hw_device_ctx = (AVHWDeviceContext*)ctx->device_ctx_ref->data;

139 AVAMFDeviceContext *amf_device_ctx = (AVAMFDeviceContext *)hw_device_ctx->hwctx;

140 int alloc_size;

141 wchar_t name[512];

142

143

144 alloc_size = swprintf(name, amf_countof(name), L "%s%lld",PTS_PROP, next_encoder_index) + 1;

145 ctx->pts_property_name = av_memdup(name, alloc_size * sizeof(wchar_t));

146 if(!ctx->pts_property_name)

147 return AVERROR(ENOMEM);

148

149 alloc_size = swprintf(name, amf_countof(name), L "%s%lld",AMF_AV_FRAME_REF, next_encoder_index) + 1;

150 ctx->av_frame_property_name = av_memdup(name, alloc_size * sizeof(wchar_t));

151 if(!ctx->av_frame_property_name)

152 return AVERROR(ENOMEM);

153

154 next_encoder_index++;

155

156 switch (avctx->codec->id) {

157 case AV_CODEC_ID_H264:

158 codec_id = AMFVideoEncoderVCE_AVC;

159 break;

160 case AV_CODEC_ID_HEVC:

161 codec_id = AMFVideoEncoder_HEVC;

162 break;

163 case AV_CODEC_ID_AV1 :

164 codec_id = AMFVideoEncoder_AV1;

165 break;

166 default:

167 break;

168 }

169 AMF_RETURN_IF_FALSE(ctx, codec_id != NULL, AVERROR(EINVAL), "Codec %d is not supported\n", avctx->codec->id);

170

171 if (avctx->hw_frames_ctx)

172 pix_fmt = ((AVHWFramesContext*)avctx->hw_frames_ctx->data)->sw_format;

173 else

174 pix_fmt = avctx->pix_fmt;

175

176 if (pix_fmt == AV_PIX_FMT_P010) {

177 AMF_RETURN_IF_FALSE(ctx, amf_device_ctx->version >= AMF_MAKE_FULL_VERSION(1, 4, 32, 0), AVERROR_UNKNOWN, "10-bit encoder is not supported by AMD GPU drivers versions lower than 23.30.\n");

178 }

179

180 ctx->format = av_av_to_amf_format(pix_fmt);

181 AMF_RETURN_IF_FALSE(ctx, ctx->format != AMF_SURFACE_UNKNOWN, AVERROR(EINVAL),

182 "Format %s is not supported\n", av_get_pix_fmt_name(pix_fmt));

183

184 res = amf_device_ctx->factory->pVtbl->CreateComponent(amf_device_ctx->factory, amf_device_ctx->context, codec_id, &ctx->encoder);

185 AMF_RETURN_IF_FALSE(ctx, res == AMF_OK, AVERROR_ENCODER_NOT_FOUND, "CreateComponent(%ls) failed with error %d\n", codec_id, res);

186

187 ctx->submitted_frame = 0;

188 ctx->encoded_frame = 0;

189 ctx->eof = 0;

190

191 return 0;

192 }

193

194 int av_cold ff_amf_encode_close(AVCodecContext *avctx)

195 {

196 AMFEncoderContext *ctx = avctx->priv_data;

197

198 if (ctx->encoder) {

199 ctx->encoder->pVtbl->Terminate(ctx->encoder);

200 ctx->encoder->pVtbl->Release(ctx->encoder);

201 ctx->encoder = NULL;

202 }

203

204 av_buffer_unref(&ctx->device_ctx_ref);

205 av_fifo_freep2(&ctx->timestamp_list);

206

207 if (ctx->output_list) {

208 // release remaining AMF output buffers

209 while(av_fifo_can_read(ctx->output_list)) {

210 AMFBuffer* buffer = NULL;

211 av_fifo_read(ctx->output_list, &buffer, 1);

212 if(buffer != NULL)

213 buffer->pVtbl->Release(buffer);

214 }

215 av_fifo_freep2(&ctx->output_list);

216 }

217 av_freep(&ctx->pts_property_name);

218 av_freep(&ctx->av_frame_property_name);

219

220 return 0;

221 }

222

223 static int amf_copy_surface(AVCodecContext *avctx, const AVFrame *frame,

224 AMFSurface* surface)

225 {

226 AMFPlane *plane;

227 uint8_t *dst_data[4] = {0};

228 int dst_linesize[4] = {0};

229 int planes;

230 int i;

231

232 planes = (int)surface->pVtbl->GetPlanesCount(surface);

233 av_assert0(planes < FF_ARRAY_ELEMS(dst_data));

234

235 for (i = 0; i < planes; i++) {

236 plane = surface->pVtbl->GetPlaneAt(surface, i);

237 dst_data[i] = plane->pVtbl->GetNative(plane);

238 dst_linesize[i] = plane->pVtbl->GetHPitch(plane);

239 }

240 av_image_copy2(dst_data, dst_linesize,

241 frame->data, frame->linesize, frame->format,

242 avctx->width, avctx->height);

243

244 return 0;

245 }

246

247 static int amf_copy_buffer(AVCodecContext *avctx, AVPacket *pkt, AMFBuffer *buffer)

248 {

249 AMFEncoderContext *ctx = avctx->priv_data;

250 int ret;

251 AMFVariantStruct var = {0};

252 int64_t timestamp = AV_NOPTS_VALUE;

253 int64_t size = buffer->pVtbl->GetSize(buffer);

254

255 if ((ret = ff_get_encode_buffer(avctx, pkt, size, 0)) < 0) {

256 return ret;

257 }

258 memcpy(pkt->data, buffer->pVtbl->GetNative(buffer), size);

259

260 switch (avctx->codec->id) {

261 case AV_CODEC_ID_H264:

262 buffer->pVtbl->GetProperty(buffer, AMF_VIDEO_ENCODER_OUTPUT_DATA_TYPE, &var);

263 if(var.int64Value == AMF_VIDEO_ENCODER_OUTPUT_DATA_TYPE_IDR) {

264 pkt->flags = AV_PKT_FLAG_KEY;

265 }

266 break;

267 case AV_CODEC_ID_HEVC:

268 buffer->pVtbl->GetProperty(buffer, AMF_VIDEO_ENCODER_HEVC_OUTPUT_DATA_TYPE, &var);

269 if (var.int64Value == AMF_VIDEO_ENCODER_HEVC_OUTPUT_DATA_TYPE_IDR) {

270 pkt->flags = AV_PKT_FLAG_KEY;

271 }

272 break;

273 case AV_CODEC_ID_AV1:

274 buffer->pVtbl->GetProperty(buffer, AMF_VIDEO_ENCODER_AV1_OUTPUT_FRAME_TYPE, &var);

275 if (var.int64Value == AMF_VIDEO_ENCODER_AV1_OUTPUT_FRAME_TYPE_KEY) {

276 pkt->flags = AV_PKT_FLAG_KEY;

277 }

278 default:

279 break;

280 }

281

282 buffer->pVtbl->GetProperty(buffer, ctx->pts_property_name, &var);

283

284 pkt->pts = var.int64Value; // original pts

285

286 AMF_RETURN_IF_FALSE(ctx, av_fifo_read(ctx->timestamp_list, &timestamp, 1) >= 0,

287 AVERROR_UNKNOWN, "timestamp_list is empty\n");

288

289 // calc dts shift if max_b_frames > 0

290 if ((ctx->max_b_frames > 0 || ((ctx->pa_adaptive_mini_gop == 1) ? true : false)) && ctx->dts_delay == 0) {

291 int64_t timestamp_last = AV_NOPTS_VALUE;

292 size_t can_read = av_fifo_can_read(ctx->timestamp_list);

293

294 AMF_RETURN_IF_FALSE(ctx, can_read > 0, AVERROR_UNKNOWN,

295 "timestamp_list is empty while max_b_frames = %d\n", avctx->max_b_frames);

296 av_fifo_peek(ctx->timestamp_list, &timestamp_last, 1, can_read - 1);

297 if (timestamp < 0 || timestamp_last < AV_NOPTS_VALUE) {

298 return AVERROR(ERANGE);

299 }

300 ctx->dts_delay = timestamp_last - timestamp;

301 }

302 pkt->dts = timestamp - ctx->dts_delay;

303 return 0;

304 }

305

306 // amfenc API implementation

307 int ff_amf_encode_init(AVCodecContext *avctx)

308 {

309 int ret;

310 AMFEncoderContext *ctx = avctx->priv_data;

311 AVHWDeviceContext *hwdev_ctx = NULL;

312

313 // hardcoded to current HW queue size - will auto-realloc if too small

314 ctx->timestamp_list = av_fifo_alloc2(avctx->max_b_frames + 16, sizeof(int64_t),

315 AV_FIFO_FLAG_AUTO_GROW);

316 if (!ctx->timestamp_list) {

317 return AVERROR(ENOMEM);

318 }

319 ctx->output_list = av_fifo_alloc2(2, sizeof(AMFBuffer*), AV_FIFO_FLAG_AUTO_GROW);

320 if (!ctx->output_list)

321 return AVERROR(ENOMEM);

322

323 ctx->dts_delay = 0;

324

325 ctx->hwsurfaces_in_queue = 0;

326

327 if (avctx->hw_device_ctx) {

328 hwdev_ctx = (AVHWDeviceContext*)avctx->hw_device_ctx->data;

329 if (hwdev_ctx->type == AV_HWDEVICE_TYPE_AMF)

330 {

331 ctx->device_ctx_ref = av_buffer_ref(avctx->hw_device_ctx);

332 }

333 else {

334 ret = av_hwdevice_ctx_create_derived(&ctx->device_ctx_ref, AV_HWDEVICE_TYPE_AMF, avctx->hw_device_ctx, 0);

335 AMF_RETURN_IF_FALSE(ctx, ret == 0, ret, "Failed to create derived AMF device context: %s\n", av_err2str(ret));

336 }

337 } else if (avctx->hw_frames_ctx) {

338 AVHWFramesContext *frames_ctx = (AVHWFramesContext*)avctx->hw_frames_ctx->data;

339 if (frames_ctx->device_ref ) {

340 if (frames_ctx->format == AV_PIX_FMT_AMF_SURFACE) {

341 ctx->device_ctx_ref = av_buffer_ref(frames_ctx->device_ref);

342 }

343 else {

344 ret = av_hwdevice_ctx_create_derived(&ctx->device_ctx_ref, AV_HWDEVICE_TYPE_AMF, frames_ctx->device_ref, 0);

345 AMF_RETURN_IF_FALSE(ctx, ret == 0, ret, "Failed to create derived AMF device context: %s\n", av_err2str(ret));

346 }

347 }

348 }

349 else {

350 ret = av_hwdevice_ctx_create(&ctx->device_ctx_ref, AV_HWDEVICE_TYPE_AMF, NULL, NULL, 0);

351 AMF_RETURN_IF_FALSE(ctx, ret == 0, ret, "Failed to create hardware device context (AMF) : %s\n", av_err2str(ret));

352 }

353

354 if ((ret = amf_init_encoder(avctx)) == 0) {

355 return 0;

356 }

357

358 ff_amf_encode_close(avctx);

359 return ret;

360 }

361

362 static AMF_RESULT amf_set_property_buffer(AMFSurface *object, const wchar_t *name, AMFBuffer *val)

363 {

364 AMF_RESULT res;

365 AMFVariantStruct var;

366 res = AMFVariantInit(&var);

367 if (res == AMF_OK) {

368 AMFGuid guid_AMFInterface = IID_AMFInterface();

369 AMFInterface *amf_interface;

370 res = val->pVtbl->QueryInterface(val, &guid_AMFInterface, (void**)&amf_interface);

371

372 if (res == AMF_OK) {

373 res = AMFVariantAssignInterface(&var, amf_interface);

374 amf_interface->pVtbl->Release(amf_interface);

375 }

376 if (res == AMF_OK) {

377 res = object->pVtbl->SetProperty(object, name, var);

378 }

379 AMFVariantClear(&var);

380 }

381 return res;

382 }

383

384 static AMF_RESULT amf_lock_context(AVCodecContext *avctx)

385 {

386 AMFEncoderContext *ctx = avctx->priv_data;

387 AVHWDeviceContext *hw_device_ctx = (AVHWDeviceContext*)ctx->device_ctx_ref->data;

388 AVAMFDeviceContext *amf_device_ctx = (AVAMFDeviceContext *)hw_device_ctx->hwctx;

389 AMF_RESULT res;

390

391 switch(amf_device_ctx->memory_type) {

392 case AMF_MEMORY_DX11:

393 res = amf_device_ctx->context->pVtbl->LockDX11(amf_device_ctx->context);

394 AMF_RETURN_IF_FALSE(ctx, res == AMF_OK, AVERROR(ENOMEM), "LockDX11() failed with error %d\n", res);

395 break;

396 case AMF_MEMORY_DX12:

397 {

398 AMFContext2 *context2 = NULL;

399 AMFGuid guid = IID_AMFContext2();

400 res = amf_device_ctx->context->pVtbl->QueryInterface(amf_device_ctx->context, &guid, (void**)&context2);

401 AMF_RETURN_IF_FALSE(ctx, res == AMF_OK, AVERROR_UNKNOWN, "QueryInterface for AMFContext2 failed with error %d\n", res);

402 res = context2->pVtbl->LockDX12(context2);

403 AMF_RETURN_IF_FALSE(ctx, res == AMF_OK, AVERROR(ENOMEM), "LockDX12() failed with error %d\n", res);

404 context2->pVtbl->Release(context2);

405 }

406 break;

407 case AMF_MEMORY_DX9:

408 res = amf_device_ctx->context->pVtbl->LockDX9(amf_device_ctx->context);

409 AMF_RETURN_IF_FALSE(ctx, res == AMF_OK, AVERROR(ENOMEM), "LockDX9() failed with error %d\n", res);

410

411 case AMF_MEMORY_VULKAN:

412 {

413 AMFContext2 *context2 = NULL;

414 AMFGuid guid = IID_AMFContext2();

415 res = amf_device_ctx->context->pVtbl->QueryInterface(amf_device_ctx->context, &guid, (void**)&context2);

416 AMF_RETURN_IF_FALSE(ctx, res == AMF_OK, AVERROR_UNKNOWN, "QueryInterface for AMFContext2 failed with error %d\n", res);

417 res = context2->pVtbl->LockVulkan(context2);

418 AMF_RETURN_IF_FALSE(ctx, res == AMF_OK, AVERROR(ENOMEM), "LockVulkan() failed with error %d\n", res);

419 context2->pVtbl->Release(context2);

420 }

421 break;

422 }

423 return AMF_OK;

424 }

425 static AMF_RESULT amf_unlock_context(AVCodecContext *avctx)

426 {

427 AMFEncoderContext *ctx = avctx->priv_data;

428 AVHWDeviceContext *hw_device_ctx = (AVHWDeviceContext*)ctx->device_ctx_ref->data;

429 AVAMFDeviceContext *amf_device_ctx = (AVAMFDeviceContext *)hw_device_ctx->hwctx;

430 AMF_RESULT res;

431

432 switch(amf_device_ctx->memory_type) {

433 case AMF_MEMORY_DX11:

434 res = amf_device_ctx->context->pVtbl->UnlockDX11(amf_device_ctx->context);

435 AMF_RETURN_IF_FALSE(ctx, res == AMF_OK, AVERROR(ENOMEM), "LockDX11() failed with error %d\n", res);

436 break;

437 case AMF_MEMORY_DX12:

438 {

439 AMFContext2 *context2 = NULL;

440 AMFGuid guid = IID_AMFContext2();

441 res = amf_device_ctx->context->pVtbl->QueryInterface(amf_device_ctx->context, &guid, (void**)&context2);

442 AMF_RETURN_IF_FALSE(ctx, res == AMF_OK, AVERROR_UNKNOWN, "QueryInterface for AMFContext2 failed with error %d\n", res);

443 res = context2->pVtbl->UnlockDX12(context2);

444 AMF_RETURN_IF_FALSE(ctx, res == AMF_OK, AVERROR(ENOMEM), "LockDX12() failed with error %d\n", res);

445 context2->pVtbl->Release(context2);

446 }

447 break;

448 case AMF_MEMORY_DX9:

449 res = amf_device_ctx->context->pVtbl->UnlockDX9(amf_device_ctx->context);

450 AMF_RETURN_IF_FALSE(ctx, res == AMF_OK, AVERROR(ENOMEM), "LockDX9() failed with error %d\n", res);

451

452 case AMF_MEMORY_VULKAN:

453 {

454 AMFContext2 *context2 = NULL;

455 AMFGuid guid = IID_AMFContext2();

456 res = amf_device_ctx->context->pVtbl->QueryInterface(amf_device_ctx->context, &guid, (void**)&context2);

457 AMF_RETURN_IF_FALSE(ctx, res == AMF_OK, AVERROR_UNKNOWN, "QueryInterface for AMFContext2 failed with error %d\n", res);

458 res = context2->pVtbl->UnlockVulkan(context2);

459 AMF_RETURN_IF_FALSE(ctx, res == AMF_OK, AVERROR(ENOMEM), "LockVulkan() failed with error %d\n", res);

460 context2->pVtbl->Release(context2);

461 }

462 break;

463 }

464 return AMF_OK;

465 }

466

467 static AMF_RESULT amf_store_attached_frame_ref(AMFEncoderContext *ctx, const AVFrame *frame, AMFSurface *surface)

468 {

469 AMF_RESULT res = AMF_FAIL;

470 int64_t data;

471 AVFrame *frame_ref = av_frame_clone(frame);

472 if (frame_ref) {

473 memcpy(&data, &frame_ref, sizeof(frame_ref)); // store pointer in 8 bytes

474 AMF_ASSIGN_PROPERTY_INT64(res, surface, ctx->av_frame_property_name, data);

475 }

476 return res;

477 }

478

479 static AMF_RESULT amf_release_attached_frame_ref(AMFEncoderContext *ctx, AMFBuffer *buffer)

480 {

481 AMFVariantStruct var = {0};

482 AMF_RESULT res = buffer->pVtbl->GetProperty(buffer, ctx->av_frame_property_name, &var);

483 if(res == AMF_OK && var.int64Value){

484 AVFrame *frame_ref;

485 memcpy(&frame_ref, &var.int64Value, sizeof(frame_ref));

486 av_frame_free(&frame_ref);

487 }

488 return res;

489 }

490

491 static int amf_submit_frame(AVCodecContext *avctx, AVFrame *frame, AMFSurface **surface_resubmit)

492 {

493 AMFEncoderContext *ctx = avctx->priv_data;

494 AVHWDeviceContext *hw_device_ctx = (AVHWDeviceContext*)ctx->device_ctx_ref->data;

495 AVAMFDeviceContext *amf_device_ctx = (AVAMFDeviceContext *)hw_device_ctx->hwctx;

496 AMFSurface *surface;

497 AMF_RESULT res;

498 int ret;

499 int hw_surface = 0;

500 int output_delay = FFMAX(ctx->max_b_frames, 0) + ((avctx->flags & AV_CODEC_FLAG_LOW_DELAY) ? 0 : 1);

501

502 // prepare surface from frame

503 switch (frame->format) {

504 #if CONFIG_D3D11VA

505 case AV_PIX_FMT_D3D11:

506 {

507 static const GUID AMFTextureArrayIndexGUID = { 0x28115527, 0xe7c3, 0x4b66, { 0x99, 0xd3, 0x4f, 0x2a, 0xe6, 0xb4, 0x7f, 0xaf } };

508 ID3D11Texture2D *texture = (ID3D11Texture2D*)frame->data[0]; // actual texture

509 int index = (intptr_t)frame->data[1]; // index is a slice in texture array is - set to tell AMF which slice to use

510 av_assert0(frame->hw_frames_ctx && avctx->hw_frames_ctx &&

511 frame->hw_frames_ctx->data == avctx->hw_frames_ctx->data);

512 texture->lpVtbl->SetPrivateData(texture, &AMFTextureArrayIndexGUID, sizeof(index), &index);

513 res = amf_device_ctx->context->pVtbl->CreateSurfaceFromDX11Native(amf_device_ctx->context, texture, &surface, NULL); // wrap to AMF surface

514 AMF_RETURN_IF_FALSE(ctx, res == AMF_OK, AVERROR(ENOMEM), "CreateSurfaceFromDX11Native() failed with error %d\n", res);

515 hw_surface = 1;

516 }

517 break;

518 #endif

519 #if CONFIG_DXVA2

520 case AV_PIX_FMT_DXVA2_VLD:

521 {

522 IDirect3DSurface9 *texture = (IDirect3DSurface9 *)frame->data[3]; // actual texture

523 res = amf_device_ctx->context->pVtbl->CreateSurfaceFromDX9Native(amf_device_ctx->context, texture, &surface, NULL); // wrap to AMF surface

524 AMF_RETURN_IF_FALSE(ctx, res == AMF_OK, AVERROR(ENOMEM), "CreateSurfaceFromDX9Native() failed with error %d\n", res);

525 hw_surface = 1;

526 }

527 break;

528 #endif

529 case AV_PIX_FMT_AMF_SURFACE:

530 {

531 surface = (AMFSurface*)frame->data[0];

532 surface->pVtbl->Acquire(surface);

533 hw_surface = 1;

534 }

535 break;

536 default:

537 {

538 res = amf_device_ctx->context->pVtbl->AllocSurface(amf_device_ctx->context, AMF_MEMORY_HOST, ctx->format, avctx->width, avctx->height, &surface);

539 AMF_RETURN_IF_FALSE(ctx, res == AMF_OK, AVERROR(ENOMEM), "AllocSurface() failed with error %d\n", res);

540 amf_copy_surface(avctx, frame, surface);

541 }

542 break;

543 }

544 if (hw_surface) {

545 amf_store_attached_frame_ref(ctx, frame, surface);

546 ctx->hwsurfaces_in_queue++;

547 // input HW surfaces can be vertically aligned by 16; tell AMF the real size

548 surface->pVtbl->SetCrop(surface, 0, 0, frame->width, frame->height);

549 }

550 // HDR10 metadata

551 if (frame->color_trc == AVCOL_TRC_SMPTE2084) {

552 AMFBuffer * hdrmeta_buffer = NULL;

553 res = amf_device_ctx->context->pVtbl->AllocBuffer(amf_device_ctx->context, AMF_MEMORY_HOST, sizeof(AMFHDRMetadata), &hdrmeta_buffer);

554 if (res == AMF_OK) {

555 AMFHDRMetadata * hdrmeta = (AMFHDRMetadata*)hdrmeta_buffer->pVtbl->GetNative(hdrmeta_buffer);

556 if (amf_save_hdr_metadata(avctx, frame, hdrmeta) == 0) {

557 switch (avctx->codec->id) {

558 case AV_CODEC_ID_H264:

559 AMF_ASSIGN_PROPERTY_INTERFACE(res, ctx->encoder, AMF_VIDEO_ENCODER_INPUT_HDR_METADATA, hdrmeta_buffer); break;

560 case AV_CODEC_ID_HEVC:

561 AMF_ASSIGN_PROPERTY_INTERFACE(res, ctx->encoder, AMF_VIDEO_ENCODER_HEVC_INPUT_HDR_METADATA, hdrmeta_buffer); break;

562 case AV_CODEC_ID_AV1:

563 AMF_ASSIGN_PROPERTY_INTERFACE(res, ctx->encoder, AMF_VIDEO_ENCODER_AV1_INPUT_HDR_METADATA, hdrmeta_buffer); break;

564 }

565 res = amf_set_property_buffer(surface, L "av_frame_hdrmeta", hdrmeta_buffer);

566 AMF_RETURN_IF_FALSE(ctx, res == AMF_OK, AVERROR_UNKNOWN, "SetProperty failed for \"av_frame_hdrmeta\" with error %d\n", res);

567 }

568 hdrmeta_buffer->pVtbl->Release(hdrmeta_buffer);

569 }

570 }

571 surface->pVtbl->SetPts(surface, frame->pts);

572

573 AMF_ASSIGN_PROPERTY_INT64(res, surface, ctx->pts_property_name, frame->pts);

574

575 switch (avctx->codec->id) {

576 case AV_CODEC_ID_H264:

577 AMF_ASSIGN_PROPERTY_INT64(res, surface, AMF_VIDEO_ENCODER_INSERT_AUD, !!ctx->aud);

578 switch (frame->pict_type) {

579 case AV_PICTURE_TYPE_I:

580 if (ctx->forced_idr) {

581 AMF_ASSIGN_PROPERTY_INT64(res, surface, AMF_VIDEO_ENCODER_INSERT_SPS, 1);

582 AMF_ASSIGN_PROPERTY_INT64(res, surface, AMF_VIDEO_ENCODER_INSERT_PPS, 1);

583 AMF_ASSIGN_PROPERTY_INT64(res, surface, AMF_VIDEO_ENCODER_FORCE_PICTURE_TYPE, AMF_VIDEO_ENCODER_PICTURE_TYPE_IDR);

584 } else {

585 AMF_ASSIGN_PROPERTY_INT64(res, surface, AMF_VIDEO_ENCODER_FORCE_PICTURE_TYPE, AMF_VIDEO_ENCODER_PICTURE_TYPE_I);

586 }

587 break;

588 case AV_PICTURE_TYPE_P:

589 AMF_ASSIGN_PROPERTY_INT64(res, surface, AMF_VIDEO_ENCODER_FORCE_PICTURE_TYPE, AMF_VIDEO_ENCODER_PICTURE_TYPE_P);

590 break;

591 case AV_PICTURE_TYPE_B:

592 AMF_ASSIGN_PROPERTY_INT64(res, surface, AMF_VIDEO_ENCODER_FORCE_PICTURE_TYPE, AMF_VIDEO_ENCODER_PICTURE_TYPE_B);

593 break;

594 }

595 break;

596 case AV_CODEC_ID_HEVC:

597 AMF_ASSIGN_PROPERTY_INT64(res, surface, AMF_VIDEO_ENCODER_HEVC_INSERT_AUD, !!ctx->aud);

598 switch (frame->pict_type) {

599 case AV_PICTURE_TYPE_I:

600 if (ctx->forced_idr) {

601 AMF_ASSIGN_PROPERTY_INT64(res, surface, AMF_VIDEO_ENCODER_HEVC_INSERT_HEADER, 1);

602 AMF_ASSIGN_PROPERTY_INT64(res, surface, AMF_VIDEO_ENCODER_HEVC_FORCE_PICTURE_TYPE, AMF_VIDEO_ENCODER_HEVC_PICTURE_TYPE_IDR);

603 } else {

604 AMF_ASSIGN_PROPERTY_INT64(res, surface, AMF_VIDEO_ENCODER_HEVC_FORCE_PICTURE_TYPE, AMF_VIDEO_ENCODER_HEVC_PICTURE_TYPE_I);

605 }

606 break;

607 case AV_PICTURE_TYPE_P:

608 AMF_ASSIGN_PROPERTY_INT64(res, surface, AMF_VIDEO_ENCODER_HEVC_FORCE_PICTURE_TYPE, AMF_VIDEO_ENCODER_HEVC_PICTURE_TYPE_P);

609 break;

610 }

611 break;

612 case AV_CODEC_ID_AV1:

613 if (frame->pict_type == AV_PICTURE_TYPE_I) {

614 if (ctx->forced_idr) {

615 AMF_ASSIGN_PROPERTY_INT64(res, surface, AMF_VIDEO_ENCODER_AV1_FORCE_INSERT_SEQUENCE_HEADER, 1);

616 AMF_ASSIGN_PROPERTY_INT64(res, surface, AMF_VIDEO_ENCODER_AV1_FORCE_FRAME_TYPE, AMF_VIDEO_ENCODER_AV1_FORCE_FRAME_TYPE_KEY);

617 } else {

618 AMF_ASSIGN_PROPERTY_INT64(res, surface, AMF_VIDEO_ENCODER_AV1_FORCE_FRAME_TYPE, AMF_VIDEO_ENCODER_AV1_FORCE_FRAME_TYPE_INTRA_ONLY);

619 }

620 }

621 break;

622 default:

623 break;

624 }

625 // submit surface

626 res = ctx->encoder->pVtbl->SubmitInput(ctx->encoder, (AMFData*)surface);

627 if (res == AMF_INPUT_FULL) { // handle full queue

628 //store surface for later submission

629 *surface_resubmit = surface;

630 } else {

631 surface->pVtbl->Release(surface);

632 AMF_RETURN_IF_FALSE(ctx, res == AMF_OK, AVERROR_UNKNOWN, "SubmitInput() failed with error %d\n", res);

633 ctx->submitted_frame++;

634 ret = av_fifo_write(ctx->timestamp_list, &frame->pts, 1);

635 if (ret < 0)

636 return ret;

637 if(ctx->submitted_frame <= ctx->encoded_frame + output_delay)

638 return AVERROR(EAGAIN); // too soon to poll or wait

639 }

640 return 0;

641 }

642

643 static int amf_submit_frame_locked(AVCodecContext *avctx, AVFrame *frame, AMFSurface **surface_resubmit)

644 {

645 int ret;

646 int locked = amf_lock_context(avctx);

647 if(locked != AMF_OK)

648 av_log(avctx, AV_LOG_WARNING, "amf_lock_context() failed with %d - should not happen\n", locked);

649

650 ret = amf_submit_frame(avctx, frame, surface_resubmit);

651

652 if(locked == AMF_OK)

653 amf_unlock_context(avctx);

654 return ret;

655 }

656 static AMF_RESULT amf_query_output(AVCodecContext *avctx, AMFBuffer **buffer)

657 {

658 AMFEncoderContext *ctx = avctx->priv_data;

659 AMFData *data = NULL;

660 AMF_RESULT ret = ctx->encoder->pVtbl->QueryOutput(ctx->encoder, &data);

661 *buffer = NULL;

662 if (data) {

663 AMFGuid guid = IID_AMFBuffer();

664 data->pVtbl->QueryInterface(data, &guid, (void**)buffer); // query for buffer interface

665 data->pVtbl->Release(data);

666 if (amf_release_attached_frame_ref(ctx, *buffer) == AMF_OK)

667 ctx->hwsurfaces_in_queue--;

668 ctx->encoded_frame++;

669 }

670 return ret;

671 }

672

673 int ff_amf_receive_packet(AVCodecContext *avctx, AVPacket *avpkt)

674 {

675 AMFEncoderContext *ctx = avctx->priv_data;

676 AMFSurface *surface = NULL;

677 AMF_RESULT res;

678 int ret;

679 AMF_RESULT res_query;

680 AMFBuffer* buffer = NULL;

681 AVFrame *frame = av_frame_alloc();

682 int block_and_wait;

683 int64_t pts = 0;

684 int output_delay = FFMAX(ctx->max_b_frames, 0) + ((avctx->flags & AV_CODEC_FLAG_LOW_DELAY) ? 0 : 1);

685

686 if (!ctx->encoder){

687 av_frame_free(&frame);

688 return AVERROR(EINVAL);

689 }

690 // check if some outputs are available

691 av_fifo_read(ctx->output_list, &buffer, 1);

692 if (buffer != NULL) { // return already retrieved output

693 ret = amf_copy_buffer(avctx, avpkt, buffer);

694 buffer->pVtbl->Release(buffer);

695 return ret;

696 }

697

698 ret = ff_encode_get_frame(avctx, frame);

699 if(ret < 0){

700 if(ret != AVERROR_EOF){

701 av_frame_free(&frame);

702 if(ret == AVERROR(EAGAIN)){

703 if(ctx->submitted_frame <= ctx->encoded_frame + output_delay) // too soon to poll

704 return ret;

705 }

706 }

707 }

708 if(ret != AVERROR(EAGAIN)){

709 if (!frame->buf[0]) { // submit drain

710 if (!ctx->eof) { // submit drain one time only

711 if(!ctx->delayed_drain) {

712 res = ctx->encoder->pVtbl->Drain(ctx->encoder);

713 if (res == AMF_INPUT_FULL) {

714 ctx->delayed_drain = 1; // input queue is full: resubmit Drain() in receive loop

715 } else {

716 if (res == AMF_OK) {

717 ctx->eof = 1; // drain started

718 }

719 AMF_RETURN_IF_FALSE(ctx, res == AMF_OK, AVERROR_UNKNOWN, "Drain() failed with error %d\n", res);

720 }

721 }

722 }

723 } else { // submit frame

724 ret = amf_submit_frame_locked(avctx, frame, &surface);

725 if(ret < 0){

726 av_frame_free(&frame);

727 return ret;

728 }

729 pts = frame->pts;

730 }

731 }

732 av_frame_free(&frame);

733

734 do {

735 block_and_wait = 0;

736 // poll data

737 res_query = amf_query_output(avctx, &buffer);

738 if (buffer) {

739 ret = amf_copy_buffer(avctx, avpkt, buffer);

740 buffer->pVtbl->Release(buffer);

741

742 AMF_RETURN_IF_FALSE(ctx, ret >= 0, ret, "amf_copy_buffer() failed with error %d\n", ret);

743

744 if (ctx->delayed_drain) { // try to resubmit drain

745 res = ctx->encoder->pVtbl->Drain(ctx->encoder);

746 if (res != AMF_INPUT_FULL) {

747 ctx->delayed_drain = 0;

748 ctx->eof = 1; // drain started

749 AMF_RETURN_IF_FALSE(ctx, res == AMF_OK, AVERROR_UNKNOWN, "Repeated Drain() failed with error %d\n", res);

750 } else {

751 av_log(avctx, AV_LOG_WARNING, "Data acquired but delayed drain submission got AMF_INPUT_FULL- should not happen\n");

752 }

753 }

754 } else if (ctx->delayed_drain || (ctx->eof && res_query != AMF_EOF) || (ctx->hwsurfaces_in_queue >= ctx->hwsurfaces_in_queue_max) || surface) {

755 block_and_wait = 1;

756 // Only sleep if the driver doesn't support waiting in QueryOutput()

757 // or if we already have output data so we will skip calling it.

758 if (!ctx->query_timeout_supported || avpkt->data || avpkt->buf) {

759 av_usleep(1000);

760 }

761 }

762 } while (block_and_wait);

763

764 if (res_query == AMF_EOF) {

765 ret = AVERROR_EOF;

766 } else if (buffer == NULL) {

767 ret = AVERROR(EAGAIN);

768 } else {

769 if(surface) {

770 // resubmit surface

771 do {

772 res = ctx->encoder->pVtbl->SubmitInput(ctx->encoder, (AMFData*)surface);

773 if (res != AMF_INPUT_FULL)

774 break;

775

776 if (!ctx->query_timeout_supported)

777 av_usleep(1000);

778

779 // Need to free up space in the encoder queue.

780 // The number of retrieved outputs is limited currently to 21

781 amf_query_output(avctx, &buffer);

782 if (buffer != NULL) {

783 ret = av_fifo_write(ctx->output_list, &buffer, 1);

784 if (ret < 0)

785 return ret;

786 }

787 } while(res == AMF_INPUT_FULL);

788

789 surface->pVtbl->Release(surface);

790 if (res == AMF_INPUT_FULL) {

791 av_log(avctx, AV_LOG_WARNING, "Data acquired but delayed SubmitInput returned AMF_INPUT_FULL- should not happen\n");

792 } else {

793 AMF_RETURN_IF_FALSE(ctx, res == AMF_OK, AVERROR_UNKNOWN, "SubmitInput() failed with error %d\n", res);

794

795 ret = av_fifo_write(ctx->timestamp_list, &pts, 1);

796

797 ctx->submitted_frame++;

798

799 if (ret < 0)

800 return ret;

801 }

802 }

803 ret = 0;

804 }

805 return ret;

806 }

807

808 int ff_amf_get_color_profile(AVCodecContext *avctx)

809 {

810 amf_int64 color_profile = AMF_VIDEO_CONVERTER_COLOR_PROFILE_UNKNOWN;

811 if (avctx->color_range == AVCOL_RANGE_JPEG) {

812 /// Color Space for Full (JPEG) Range

813 switch (avctx->colorspace) {

814 case AVCOL_SPC_SMPTE170M:

815 color_profile = AMF_VIDEO_CONVERTER_COLOR_PROFILE_FULL_601;

816 break;

817 case AVCOL_SPC_BT709:

818 color_profile = AMF_VIDEO_CONVERTER_COLOR_PROFILE_FULL_709;

819 break;

820 case AVCOL_SPC_BT2020_NCL:

821 case AVCOL_SPC_BT2020_CL:

822 color_profile = AMF_VIDEO_CONVERTER_COLOR_PROFILE_FULL_2020;

823 break;

824 }

825 } else {

826 /// Color Space for Limited (MPEG) range

827 switch (avctx->colorspace) {

828 case AVCOL_SPC_SMPTE170M:

829 color_profile = AMF_VIDEO_CONVERTER_COLOR_PROFILE_601;

830 break;

831 case AVCOL_SPC_BT709:

832 color_profile = AMF_VIDEO_CONVERTER_COLOR_PROFILE_709;

833 break;

834 case AVCOL_SPC_BT2020_NCL:

835 case AVCOL_SPC_BT2020_CL:

836 color_profile = AMF_VIDEO_CONVERTER_COLOR_PROFILE_2020;

837 break;

838 }

839 }

840 return color_profile;

841 }

842

843 const AVCodecHWConfigInternal *const ff_amfenc_hw_configs[] = {

844 #if CONFIG_D3D11VA

845 HW_CONFIG_ENCODER_FRAMES(D3D11, D3D11VA),

846 HW_CONFIG_ENCODER_DEVICE(NONE, D3D11VA),

847 #endif

848 #if CONFIG_DXVA2

849 HW_CONFIG_ENCODER_FRAMES(DXVA2_VLD, DXVA2),

850 HW_CONFIG_ENCODER_DEVICE(NONE, DXVA2),

851 #endif

852 HW_CONFIG_ENCODER_FRAMES(AMF_SURFACE, AMF),

853 HW_CONFIG_ENCODER_DEVICE(NONE, AMF),

854 NULL,

855 };

AVMasteringDisplayMetadata::has_primaries

int has_primaries

Flag indicating whether the display primaries (and white point) are set.

Definition: mastering_display_metadata.h:62

amf_release_attached_frame_ref

static AMF_RESULT amf_release_attached_frame_ref(AMFEncoderContext *ctx, AMFBuffer *buffer)

Definition: amfenc.c:479

AV_LOG_WARNING

#define AV_LOG_WARNING

Something somehow does not look correct.

Definition: log.h:216

AVMasteringDisplayMetadata::max_luminance

AVRational max_luminance

Max luminance of mastering display (cd/m^2).

Definition: mastering_display_metadata.h:57

AVPixelFormat

Pixel format.

Definition: pixfmt.h:71

name

it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default minimum maximum flags name is the option name

Definition: writing_filters.txt:88

AVERROR

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

AVCodecContext::colorspace

enum AVColorSpace colorspace

YUV colorspace type.

Definition: avcodec.h:659

av_frame_get_side_data

AVFrameSideData * av_frame_get_side_data(const AVFrame *frame, enum AVFrameSideDataType type)

Definition: frame.c:659

NONE

@ NONE

Definition: af_afade.c:62

AVERROR_EOF

#define AVERROR_EOF

End of file.

Definition: error.h:57

AVBufferRef::data

uint8_t * data

The data buffer.

Definition: buffer.h:90

AVMasteringDisplayMetadata::display_primaries

AVRational display_primaries[3][2]

CIE 1931 xy chromaticity coords of color primaries (r, g, b order).

Definition: mastering_display_metadata.h:42

AVHWFramesContext::format

enum AVPixelFormat format

The pixel format identifying the underlying HW surface type.

Definition: hwcontext.h:200

AVMasteringDisplayMetadata::has_luminance

int has_luminance

Flag indicating whether the luminance (min_ and max_) have been set.

Definition: mastering_display_metadata.h:67

int64_t

long long int64_t

Definition: coverity.c:34

av_frame_free

void av_frame_free(AVFrame **frame)

Free the frame and any dynamically allocated objects in it, e.g.

Definition: frame.c:64

AVContentLightMetadata::MaxCLL

unsigned MaxCLL

Max content light level (cd/m^2).

Definition: mastering_display_metadata.h:111

av_fifo_peek

int av_fifo_peek(const AVFifo *f, void *buf, size_t nb_elems, size_t offset)

Read data from a FIFO without modifying FIFO state.

Definition: fifo.c:255

planes

static const struct @532 planes[]

AVFrame

This structure describes decoded (raw) audio or video data.

Definition: frame.h:427

pixdesc.h

AVCOL_RANGE_JPEG

@ AVCOL_RANGE_JPEG

Full range content.

Definition: pixfmt.h:767

internal.h

AVPacket::data

uint8_t * data

Definition: packet.h:558

encode.h

data

const char data[16]

Definition: mxf.c:149

amf_set_property_buffer

static AMF_RESULT amf_set_property_buffer(AMFSurface *object, const wchar_t *name, AMFBuffer *val)

Definition: amfenc.c:362

AV_PIX_FMT_BGRA

@ AV_PIX_FMT_BGRA

packed BGRA 8:8:8:8, 32bpp, BGRABGRA...

Definition: pixfmt.h:102

FFMAX

#define FFMAX(a, b)

Definition: macros.h:47

av_buffer_ref

AVBufferRef * av_buffer_ref(const AVBufferRef *buf)

Create a new reference to an AVBuffer.

Definition: buffer.c:103

AMF_RETURN_IF_FALSE

#define AMF_RETURN_IF_FALSE(avctx, exp, ret_value,...)

Error handling helper.

Definition: amfenc.h:169

amf_copy_surface

static int amf_copy_surface(AVCodecContext *avctx, const AVFrame *frame, AMFSurface *surface)

Definition: amfenc.c:223

AVERROR_UNKNOWN

#define AVERROR_UNKNOWN

Unknown error, typically from an external library.

Definition: error.h:73

AVCOL_SPC_BT2020_CL

@ AVCOL_SPC_BT2020_CL

ITU-R BT2020 constant luminance system.

Definition: pixfmt.h:702

AV_PKT_FLAG_KEY

#define AV_PKT_FLAG_KEY

The packet contains a keyframe.

Definition: packet.h:613

AV_PIX_FMT_AMF_SURFACE

@ AV_PIX_FMT_AMF_SURFACE

HW acceleration through AMF.

Definition: pixfmt.h:477

av_memdup

void * av_memdup(const void *p, size_t size)

Duplicate a buffer with av_malloc().

Definition: mem.c:304

AVContentLightMetadata

Content light level needed by to transmit HDR over HDMI (CTA-861.3).

Definition: mastering_display_metadata.h:107

AMF_AV_FRAME_REF

#define AMF_AV_FRAME_REF

Definition: amfenc.c:43

AVCodecContext::codec

const struct AVCodec * codec

Definition: avcodec.h:440

av_fifo_write

int av_fifo_write(AVFifo *f, const void *buf, size_t nb_elems)

Write data into a FIFO.

Definition: fifo.c:188

ff_amf_encode_close

int av_cold ff_amf_encode_close(AVCodecContext *avctx)

Common encoder termination function.

Definition: amfenc.c:194

ff_amf_encode_init

int ff_amf_encode_init(AVCodecContext *avctx)

Common encoder initization function.

Definition: amfenc.c:307

AVCodecContext::flags

int flags

AV_CODEC_FLAG_*.

Definition: avcodec.h:488

locked

FFmpeg hosted at Telepoint in bulgaria ns2 avcodec org Replica Name hosted at Prometeus Cdlan in italy instead several VMs run on it Main server peering exchange and hosting They have multiple DC buildings in Sofia and FFmpeg is hosted in XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX The building is locked down and accessible only with personal key cards that are registered People who are granted access to a rack have to go through the access center with their ID to get logged and receive a one time access card that can open the service elevator and only the hall where the destination rack is All racks are locked

Definition: infra.txt:35

val

static double val(void *priv, double ch)

Definition: aeval.c:77

AV_CODEC_FLAG_LOW_DELAY

#define AV_CODEC_FLAG_LOW_DELAY

Force low delay.

Definition: avcodec.h:314

pts

static int64_t pts

Definition: transcode_aac.c:644

av_av_to_amf_format

enum AMF_SURFACE_FORMAT av_av_to_amf_format(enum AVPixelFormat fmt)

Definition: hwcontext_amf.c:121

AVHWDeviceContext

This struct aggregates all the (hardware/vendor-specific) "high-level" state, i.e.

Definition: hwcontext.h:63

av_frame_alloc

AVFrame * av_frame_alloc(void)

Allocate an AVFrame and set its fields to default values.

Definition: frame.c:52

avassert.h

pkt

AVPacket * pkt

Definition: movenc.c:60

FF_ARRAY_ELEMS

#define FF_ARRAY_ELEMS(a)

Definition: sinewin_tablegen.c:29

av_cold

#define av_cold

Definition: attributes.h:106

av_fifo_read

int av_fifo_read(AVFifo *f, void *buf, size_t nb_elems)

Read data from a FIFO.

Definition: fifo.c:240

AVMasteringDisplayMetadata::white_point

AVRational white_point[2]

CIE 1931 xy chromaticity coords of white point.

Definition: mastering_display_metadata.h:47

AV_PIX_FMT_DXVA2_VLD

@ AV_PIX_FMT_DXVA2_VLD

HW decoding through DXVA2, Picture.data[3] contains a LPDIRECT3DSURFACE9 pointer.

Definition: pixfmt.h:134

AMFEncoderContext

AMF encoder context.

Definition: amfenc.h:40

AVCOL_SPC_SMPTE170M

@ AVCOL_SPC_SMPTE170M

also ITU-R BT601-6 525 / ITU-R BT1358 525 / ITU-R BT1700 NTSC / functionally identical to above

Definition: pixfmt.h:697

pix_fmt

static enum AVPixelFormat pix_fmt

Definition: demux_decode.c:41

amf_submit_frame

static int amf_submit_frame(AVCodecContext *avctx, AVFrame *frame, AMFSurface **surface_resubmit)

Definition: amfenc.c:491

av_q2d

static double av_q2d(AVRational a)

Convert an AVRational to a double.

Definition: rational.h:104

av_assert0

#define av_assert0(cond)

assert() equivalent, that is always enabled.

Definition: avassert.h:41

AV_HWDEVICE_TYPE_AMF

@ AV_HWDEVICE_TYPE_AMF

Definition: hwcontext.h:41

amf_init_encoder

static int amf_init_encoder(AVCodecContext *avctx)

Definition: amfenc.c:132

ctx

AVFormatContext * ctx

Definition: movenc.c:49

amf_query_output

static AMF_RESULT amf_query_output(AVCodecContext *avctx, AMFBuffer **buffer)

Definition: amfenc.c:656

av_frame_clone

AVFrame * av_frame_clone(const AVFrame *src)

Create a new frame that references the same data as src.

Definition: frame.c:483

hwcontext_amf.h

codec_id

enum AVCodecID codec_id

Definition: vaapi_decode.c:410

AV_PIX_FMT_YUV420P

@ AV_PIX_FMT_YUV420P

planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)

Definition: pixfmt.h:73

av_usleep

int av_usleep(unsigned usec)

Sleep for a period of time.

Definition: time.c:84

AV_CODEC_ID_H264

@ AV_CODEC_ID_H264

Definition: codec_id.h:79

AV_PIX_FMT_RGBA

@ AV_PIX_FMT_RGBA

packed RGBA 8:8:8:8, 32bpp, RGBARGBA...

Definition: pixfmt.h:100

if(ret)

Definition: filter_design.txt:179

AVPacket::buf

AVBufferRef * buf

A reference to the reference-counted buffer where the packet data is stored.

Definition: packet.h:541

NULL

#define NULL

Definition: coverity.c:32

AVCodecContext::color_range

enum AVColorRange color_range

MPEG vs JPEG YUV range.

Definition: avcodec.h:669

av_buffer_unref

void av_buffer_unref(AVBufferRef **buf)

Free a given reference and automatically free the buffer if there are no more references to it.

Definition: buffer.c:139

AV_CODEC_ID_AV1

@ AV_CODEC_ID_AV1

Definition: codec_id.h:284

AVHWFramesContext::device_ref

AVBufferRef * device_ref

A reference to the parent AVHWDeviceContext.

Definition: hwcontext.h:129

ff_amf_receive_packet

int ff_amf_receive_packet(AVCodecContext *avctx, AVPacket *avpkt)

Ecoding one frame - common function for all AMF encoders.

Definition: amfenc.c:673

AV_PICTURE_TYPE_I

@ AV_PICTURE_TYPE_I

Intra.

Definition: avutil.h:278

av_fifo_can_read

size_t av_fifo_can_read(const AVFifo *f)

Definition: fifo.c:87

amf_copy_buffer

static int amf_copy_buffer(AVCodecContext *avctx, AVPacket *pkt, AMFBuffer *buffer)

Definition: amfenc.c:247

AV_FRAME_DATA_MASTERING_DISPLAY_METADATA

@ AV_FRAME_DATA_MASTERING_DISPLAY_METADATA

Mastering display metadata associated with a video frame.

Definition: frame.h:120

AV_PIX_FMT_BGR0

@ AV_PIX_FMT_BGR0

packed BGR 8:8:8, 32bpp, BGRXBGRX... X=unused/undefined

Definition: pixfmt.h:265

time.h

PTS_PROP

#define PTS_PROP

Definition: amfenc.c:44

amf_submit_frame_locked

static int amf_submit_frame_locked(AVCodecContext *avctx, AVFrame *frame, AMFSurface **surface_resubmit)

Definition: amfenc.c:643

index

int index

Definition: gxfenc.c:90

AVCOL_TRC_SMPTE2084

@ AVCOL_TRC_SMPTE2084

SMPTE ST 2084 for 10-, 12-, 14- and 16-bit systems.

Definition: pixfmt.h:678

AV_PIX_FMT_X2BGR10

#define AV_PIX_FMT_X2BGR10

Definition: pixfmt.h:614

hwcontext_dxva2.h

HW_CONFIG_ENCODER_DEVICE

#define HW_CONFIG_ENCODER_DEVICE(format, device_type_)

Definition: hwconfig.h:95

amf_lock_context

static AMF_RESULT amf_lock_context(AVCodecContext *avctx)

Definition: amfenc.c:384

av_err2str

#define av_err2str(errnum)

Convenience macro, the return value should be used only directly in function arguments but never stan...

Definition: error.h:122

ff_amf_pix_fmts

enum AVPixelFormat ff_amf_pix_fmts[]

Supported formats.

Definition: amfenc.c:109

size

int size

Definition: twinvq_data.h:10344

AVAMFDeviceContext

This struct is allocated as AVHWDeviceContext.hwctx.

Definition: hwcontext_amf.h:33

AV_NOPTS_VALUE

#define AV_NOPTS_VALUE

Undefined timestamp value.

Definition: avutil.h:247

AVFrameSideData::data

uint8_t * data

Definition: frame.h:284

AVCodecHWConfigInternal

Definition: hwconfig.h:25

AVPacket::dts

int64_t dts

Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.

Definition: packet.h:557

AVPacket::flags

int flags

A combination of AV_PKT_FLAG values.

Definition: packet.h:564

AV_PIX_FMT_RGB0

@ AV_PIX_FMT_RGB0

packed RGB 8:8:8, 32bpp, RGBXRGBX... X=unused/undefined

Definition: pixfmt.h:263

AV_PIX_FMT_D3D11

@ AV_PIX_FMT_D3D11

Hardware surfaces for Direct3D11.

Definition: pixfmt.h:336

AVCodec::id

enum AVCodecID id

Definition: codec.h:186

AV_PIX_FMT_ARGB

@ AV_PIX_FMT_ARGB

packed ARGB 8:8:8:8, 32bpp, ARGBARGB...

Definition: pixfmt.h:99

HW_CONFIG_ENCODER_FRAMES

#define HW_CONFIG_ENCODER_FRAMES(format, device_type_)

Definition: hwconfig.h:98

amf_unlock_context

static AMF_RESULT amf_unlock_context(AVCodecContext *avctx)

Definition: amfenc.c:425

AV_FRAME_DATA_CONTENT_LIGHT_LEVEL

@ AV_FRAME_DATA_CONTENT_LIGHT_LEVEL

Content light level (based on CTA-861.3).

Definition: frame.h:137

av_hwdevice_ctx_create_derived

int av_hwdevice_ctx_create_derived(AVBufferRef **dst_ref_ptr, enum AVHWDeviceType type, AVBufferRef *src_ref, int flags)

Create a new device of the specified type from an existing device.

Definition: hwcontext.c:718

#define i(width, name, range_min, range_max)

Definition: cbs_h2645.c:256

AVPacket::pts

int64_t pts

Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...

Definition: packet.h:551

AVCOL_SPC_BT2020_NCL

@ AVCOL_SPC_BT2020_NCL

ITU-R BT2020 non-constant luminance system.

Definition: pixfmt.h:701

amf_save_hdr_metadata

static int amf_save_hdr_metadata(AVCodecContext *avctx, const AVFrame *frame, AMFHDRMetadata *hdrmeta)

Definition: amfenc.c:46

hw_device_ctx

static AVBufferRef * hw_device_ctx

Definition: hw_decode.c:45

ff_amfenc_hw_configs

const AVCodecHWConfigInternal *const ff_amfenc_hw_configs[]

Definition: amfenc.c:843

amf_store_attached_frame_ref

static AMF_RESULT amf_store_attached_frame_ref(AMFEncoderContext *ctx, const AVFrame *frame, AMFSurface *surface)

Definition: amfenc.c:467

AV_CODEC_ID_HEVC

@ AV_CODEC_ID_HEVC

Definition: codec_id.h:228

FFMIN

#define FFMIN(a, b)

Definition: macros.h:49

AVCodecContext::hw_device_ctx

AVBufferRef * hw_device_ctx

A reference to the AVHWDeviceContext describing the device which will be used by a hardware encoder/d...

Definition: avcodec.h:1475

AVMasteringDisplayMetadata

Mastering display metadata capable of representing the color volume of the display used to master the...

Definition: mastering_display_metadata.h:38

AVCodecContext::height

int height

Definition: avcodec.h:592

AVCodecContext::pix_fmt

enum AVPixelFormat pix_fmt

Pixel format, see AV_PIX_FMT_xxx.

Definition: avcodec.h:631

AVCodecContext::hw_frames_ctx

AVBufferRef * hw_frames_ctx

A reference to the AVHWFramesContext describing the input (for encoding) or output (decoding) frames.

Definition: avcodec.h:1453

AVHWFramesContext

This struct describes a set or pool of "hardware" frames (i.e.

Definition: hwcontext.h:118

frame_ref

static int frame_ref(AVFrame *dst, const AVFrame *src)

Definition: swscale.c:1339

ret

Definition: filter_design.txt:187

AVHWDeviceContext::type

enum AVHWDeviceType type

This field identifies the underlying API used for hardware access.

Definition: hwcontext.h:75

AV_PIX_FMT_NV12

@ AV_PIX_FMT_NV12

planar YUV 4:2:0, 12bpp, 1 plane for Y and 1 plane for the UV components, which are interleaved (firs...

Definition: pixfmt.h:96

frame

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

Definition: filter_design.txt:265

av_hwdevice_ctx_create

int av_hwdevice_ctx_create(AVBufferRef **pdevice_ref, enum AVHWDeviceType type, const char *device, AVDictionary *opts, int flags)

Open a device of the specified type and create an AVHWDeviceContext for it.

Definition: hwcontext.c:615

av_fifo_alloc2

AVFifo * av_fifo_alloc2(size_t nb_elems, size_t elem_size, unsigned int flags)

Allocate and initialize an AVFifo with a given element size.

Definition: fifo.c:47

AVCodecContext

main external API structure.

Definition: avcodec.h:431

hwcontext_amf_internal.h

AV_PICTURE_TYPE_B

@ AV_PICTURE_TYPE_B

Bi-dir predicted.

Definition: avutil.h:280

buffer

the frame and frame reference mechanism is intended to as much as expensive copies of that data while still allowing the filters to produce correct results The data is stored in buffers represented by AVFrame structures Several references can point to the same frame buffer

Definition: filter_design.txt:49

ff_get_encode_buffer

int ff_get_encode_buffer(AVCodecContext *avctx, AVPacket *avpkt, int64_t size, int flags)

Get a buffer for a packet.

Definition: encode.c:104

av_image_copy2

static void av_image_copy2(uint8_t *const dst_data[4], const int dst_linesizes[4], uint8_t *const src_data[4], const int src_linesizes[4], enum AVPixelFormat pix_fmt, int width, int height)

Wrapper around av_image_copy() to workaround the limitation that the conversion from uint8_t * const ...

Definition: imgutils.h:184

AV_PIX_FMT_NONE

@ AV_PIX_FMT_NONE

Definition: pixfmt.h:72

#define L(x)

Definition: vpx_arith.h:36

amfenc.h

AVMasteringDisplayMetadata::min_luminance

AVRational min_luminance

Min luminance of mastering display (cd/m^2).

Definition: mastering_display_metadata.h:52