FFmpeg
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  */
18 
19 #include "config.h"
20 #include "config_components.h"
21 
22 #include "libavutil/avassert.h"
23 #include "libavutil/imgutils.h"
24 #include "libavutil/hwcontext.h"
27 #if CONFIG_D3D11VA
29 #endif
30 #if CONFIG_DXVA2
31 #define COBJMACROS
33 #endif
34 #include "libavutil/mem.h"
35 #include "libavutil/pixdesc.h"
36 #include "libavutil/time.h"
37 
38 #include "amfenc.h"
39 #include "encode.h"
40 #include "internal.h"
42 
43 #define AMF_AV_FRAME_REF L"av_frame_ref"
44 #define PTS_PROP L"PtsProp"
45 
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;
52 
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  }
82 
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 }
95 
96 #if CONFIG_D3D11VA
97 #include <d3d11.h>
98 #endif
99 
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 
112 #if CONFIG_D3D11VA
114 #endif
115 #if CONFIG_DXVA2
117 #endif
128 };
129 
131 
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 
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 
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) {
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) {
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) {
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
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),
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 {
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;
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 
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){
485  memcpy(&frame_ref, &var.int64Value, sizeof(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 max_b_frames = ctx->max_b_frames < 0 ? 0 : ctx->max_b_frames;
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
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
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) {
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 + max_b_frames + 1)
638  return AVERROR(EAGAIN); // if frame just submiited - don't 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 
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;
682  int block_and_wait;
683  int64_t pts = 0;
684  int max_b_frames = ctx->max_b_frames < 0 ? 0 : ctx->max_b_frames;
685 
686  if (!ctx->encoder){
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){
702  if(ret == AVERROR(EAGAIN)){
703  if(ctx->submitted_frame <= ctx->encoded_frame + max_b_frames + 1) // 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){
727  return ret;
728  }
729  pts = frame->pts;
730  }
731  }
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 
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;
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;
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 
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),
851 #endif
852  HW_CONFIG_ENCODER_FRAMES(AMF_SURFACE, 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
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:657
NONE
@ NONE
Definition: af_afade.c:60
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:63
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
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:421
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:552
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
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:607
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
val
static double val(void *priv, double ch)
Definition: aeval.c:77
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:51
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:90
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:481
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
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:535
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:278
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:551
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:558
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
i
#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:545
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
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
planes
static const struct @512 planes[]
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:106
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
L
#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
AV_PIX_FMT_P010
#define AV_PIX_FMT_P010
Definition: pixfmt.h:602
AV_PICTURE_TYPE_P
@ AV_PICTURE_TYPE_P
Predicted.
Definition: avutil.h:279
AVERROR_ENCODER_NOT_FOUND
#define AVERROR_ENCODER_NOT_FOUND
Encoder not found.
Definition: error.h:56
mem.h
AVCodecContext::max_b_frames
int max_b_frames
maximum number of B-frames between non-B-frames Note: The output will be delayed by max_b_frames+1 re...
Definition: avcodec.h:769
ff_encode_get_frame
int ff_encode_get_frame(AVCodecContext *avctx, AVFrame *frame)
Called by encoders to get the next frame for encoding.
Definition: encode.c:205
mastering_display_metadata.h
AVFrameSideData
Structure to hold side data for an AVFrame.
Definition: frame.h:276
ff_amf_get_color_profile
int ff_amf_get_color_profile(AVCodecContext *avctx)
Definition: amfenc.c:808
AVPacket
This structure stores compressed data.
Definition: packet.h:529
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:458
next_encoder_index
static int64_t next_encoder_index
Definition: amfenc.c:130
AVContentLightMetadata::MaxFALL
unsigned MaxFALL
Max average light level per frame (cd/m^2).
Definition: mastering_display_metadata.h:116
AV_PIX_FMT_RGBAF16
#define AV_PIX_FMT_RGBAF16
Definition: pixfmt.h:624
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:592
imgutils.h
hwcontext.h
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
av_fifo_freep2
void av_fifo_freep2(AVFifo **f)
Free an AVFifo and reset pointer to NULL.
Definition: fifo.c:286
AVCOL_SPC_BT709
@ AVCOL_SPC_BT709
also ITU-R BT1361 / IEC 61966-2-4 xvYCC709 / derived in SMPTE RP 177 Annex B
Definition: pixfmt.h:692
hwcontext_d3d11va.h
AV_FIFO_FLAG_AUTO_GROW
#define AV_FIFO_FLAG_AUTO_GROW
Automatically resize the FIFO on writes, so that the data fits.
Definition: fifo.h:63
w32dlfcn.h
av_get_pix_fmt_name
const char * av_get_pix_fmt_name(enum AVPixelFormat pix_fmt)
Return the short name for a pixel format, NULL in case pix_fmt is unknown.
Definition: pixdesc.c:3361