git.sesse.net Git - ffmpeg/blob - libavfilter/vf_tonemap_vaapi.c

   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 #include <string.h>
  19
  20 #include "libavutil/avassert.h"
  21 #include "libavutil/mem.h"
  22 #include "libavutil/opt.h"
  23 #include "libavutil/pixdesc.h"
  24 #include "libavutil/mastering_display_metadata.h"
  25
  26 #include "avfilter.h"
  27 #include "formats.h"
  28 #include "internal.h"
  29 #include "vaapi_vpp.h"
  30
  31 typedef struct HDRVAAPIContext {
  32     VAAPIVPPContext vpp_ctx; // must be the first field
  33
  34     char *output_format_string;
  35
  36     char *color_primaries_string;
  37     char *color_transfer_string;
  38     char *color_matrix_string;
  39
  40     enum AVColorPrimaries color_primaries;
  41     enum AVColorTransferCharacteristic color_transfer;
  42     enum AVColorSpace color_matrix;
  43
  44     VAHdrMetaDataHDR10  in_metadata;
  45
  46     AVFrameSideData    *src_display;
  47     AVFrameSideData    *src_light;
  48 } HDRVAAPIContext;
  49
  50 static int tonemap_vaapi_save_metadata(AVFilterContext *avctx, AVFrame *input_frame)
  51 {
  52     HDRVAAPIContext *ctx = avctx->priv;
  53     AVMasteringDisplayMetadata *hdr_meta;
  54     AVContentLightMetadata *light_meta;
  55
  56     if (input_frame->color_trc != AVCOL_TRC_SMPTE2084) {
  57         av_log(avctx, AV_LOG_WARNING, "Only support HDR10 as input for vaapi tone-mapping\n");
  58     }
  59
  60     ctx->src_display = av_frame_get_side_data(input_frame,
  61                                               AV_FRAME_DATA_MASTERING_DISPLAY_METADATA);
  62     if (ctx->src_display) {
  63         hdr_meta = (AVMasteringDisplayMetadata *)ctx->src_display->data;
  64         if (!hdr_meta) {
  65             av_log(avctx, AV_LOG_ERROR, "No mastering display data\n");
  66             return AVERROR(EINVAL);
  67         }
  68
  69         if (hdr_meta->has_luminance) {
  70             const int luma_den = 10000;
  71             ctx->in_metadata.max_display_mastering_luminance =
  72                 lrint(luma_den * av_q2d(hdr_meta->max_luminance));
  73             ctx->in_metadata.min_display_mastering_luminance =
  74                 FFMIN(lrint(luma_den * av_q2d(hdr_meta->min_luminance)),
  75                       ctx->in_metadata.max_display_mastering_luminance);
  76
  77             av_log(avctx, AV_LOG_DEBUG,
  78                    "Mastering Display Metadata(in luminance):\n");
  79             av_log(avctx, AV_LOG_DEBUG,
  80                    "min_luminance=%u, max_luminance=%u\n",
  81                    ctx->in_metadata.min_display_mastering_luminance,
  82                    ctx->in_metadata.max_display_mastering_luminance);
  83         }
  84
  85         if (hdr_meta->has_primaries) {
  86             int i;
  87             const int mapping[3] = {1, 2, 0};  //green, blue, red
  88             const int chroma_den = 50000;
  89
  90             for (i = 0; i < 3; i++) {
  91                 const int j = mapping[i];
  92                 ctx->in_metadata.display_primaries_x[i] =
  93                     FFMIN(lrint(chroma_den *
  94                                 av_q2d(hdr_meta->display_primaries[j][0])),
  95                           chroma_den);
  96                 ctx->in_metadata.display_primaries_y[i] =
  97                     FFMIN(lrint(chroma_den *
  98                                 av_q2d(hdr_meta->display_primaries[j][1])),
  99                           chroma_den);
 100             }
 101
 102             ctx->in_metadata.white_point_x =
 103                 FFMIN(lrint(chroma_den * av_q2d(hdr_meta->white_point[0])),
 104                       chroma_den);
 105             ctx->in_metadata.white_point_y =
 106                 FFMIN(lrint(chroma_den * av_q2d(hdr_meta->white_point[1])),
 107                       chroma_den);
 108
 109             av_log(avctx, AV_LOG_DEBUG,
 110                    "Mastering Display Metadata(in primaries):\n");
 111             av_log(avctx, AV_LOG_DEBUG,
 112                    "G(%u,%u) B(%u,%u) R(%u,%u) WP(%u,%u)\n",
 113                    ctx->in_metadata.display_primaries_x[0],
 114                    ctx->in_metadata.display_primaries_y[0],
 115                    ctx->in_metadata.display_primaries_x[1],
 116                    ctx->in_metadata.display_primaries_y[1],
 117                    ctx->in_metadata.display_primaries_x[2],
 118                    ctx->in_metadata.display_primaries_y[2],
 119                    ctx->in_metadata.white_point_x,
 120                    ctx->in_metadata.white_point_y);
 121         }
 122     } else {
 123         av_log(avctx, AV_LOG_ERROR, "No mastering display data from input\n");
 124         return AVERROR(EINVAL);
 125     }
 126
 127     ctx->src_light = av_frame_get_side_data(input_frame,
 128                                             AV_FRAME_DATA_CONTENT_LIGHT_LEVEL);
 129     if (ctx->src_light) {
 130         light_meta = (AVContentLightMetadata *)ctx->src_light->data;
 131         if (!light_meta) {
 132             av_log(avctx, AV_LOG_ERROR, "No light metadata\n");
 133             return AVERROR(EINVAL);
 134         }
 135
 136         ctx->in_metadata.max_content_light_level = light_meta->MaxCLL;
 137         ctx->in_metadata.max_pic_average_light_level = light_meta->MaxFALL;
 138
 139         av_log(avctx, AV_LOG_DEBUG,
 140                "Mastering Content Light Level (in):\n");
 141         av_log(avctx, AV_LOG_DEBUG,
 142                "MaxCLL(%u) MaxFALL(%u)\n",
 143                ctx->in_metadata.max_content_light_level,
 144                ctx->in_metadata.max_pic_average_light_level);
 145     } else {
 146         av_log(avctx, AV_LOG_DEBUG, "No content light level from input\n");
 147     }
 148     return 0;
 149 }
 150
 151 static int tonemap_vaapi_set_filter_params(AVFilterContext *avctx, AVFrame *input_frame)
 152 {
 153     VAAPIVPPContext *vpp_ctx   = avctx->priv;
 154     HDRVAAPIContext *ctx       = avctx->priv;
 155     VAStatus vas;
 156     VAProcFilterParameterBufferHDRToneMapping *hdrtm_param;
 157
 158     vas = vaMapBuffer(vpp_ctx->hwctx->display, vpp_ctx->filter_buffers[0],
 159                       (void**)&hdrtm_param);
 160     if (vas != VA_STATUS_SUCCESS) {
 161         av_log(avctx, AV_LOG_ERROR, "Failed to map "
 162                "buffer (%d): %d (%s).\n",
 163                vpp_ctx->filter_buffers[0], vas, vaErrorStr(vas));
 164         return AVERROR(EIO);
 165     }
 166
 167     memcpy(hdrtm_param->data.metadata, &ctx->in_metadata, sizeof(VAHdrMetaDataHDR10));
 168
 169     vas = vaUnmapBuffer(vpp_ctx->hwctx->display, vpp_ctx->filter_buffers[0]);
 170     if (vas != VA_STATUS_SUCCESS) {
 171         av_log(avctx, AV_LOG_ERROR, "Failed to unmap output buffers: "
 172                "%d (%s).\n", vas, vaErrorStr(vas));
 173         return AVERROR(EIO);
 174     }
 175
 176     return 0;
 177 }
 178
 179 static int tonemap_vaapi_build_filter_params(AVFilterContext *avctx)
 180 {
 181     VAAPIVPPContext *vpp_ctx   = avctx->priv;
 182     HDRVAAPIContext *ctx       = avctx->priv;
 183     VAStatus vas;
 184     VAProcFilterParameterBufferHDRToneMapping hdrtm_param;
 185     VAProcFilterCapHighDynamicRange hdr_cap[VAProcHighDynamicRangeMetadataTypeCount];
 186     int num_query_caps;
 187     int i;
 188
 189     memset(&hdrtm_param, 0, sizeof(hdrtm_param));
 190     memset(&ctx->in_metadata, 0, sizeof(ctx->in_metadata));
 191
 192     num_query_caps = VAProcHighDynamicRangeMetadataTypeCount;
 193     vas = vaQueryVideoProcFilterCaps(vpp_ctx->hwctx->display,
 194                                      vpp_ctx->va_context,
 195                                      VAProcFilterHighDynamicRangeToneMapping,
 196                                      &hdr_cap, &num_query_caps);
 197     if (vas != VA_STATUS_SUCCESS) {
 198         av_log(avctx, AV_LOG_ERROR, "Failed to query HDR caps "
 199                "context: %d (%s).\n", vas, vaErrorStr(vas));
 200         return AVERROR(EIO);
 201     }
 202
 203     for (i = 0; i < num_query_caps; i++) {
 204         if (hdr_cap[i].metadata_type != VAProcHighDynamicRangeMetadataNone)
 205             break;
 206     }
 207
 208     if (i >= num_query_caps) {
 209         av_log(avctx, AV_LOG_ERROR, "VAAPI driver doesn't support HDR\n");
 210         return AVERROR(EINVAL);
 211     }
 212
 213     for (i = 0; i < num_query_caps; i++) {
 214         if (VA_TONE_MAPPING_HDR_TO_SDR & hdr_cap[i].caps_flag)
 215             break;
 216     }
 217
 218     if (i >= num_query_caps) {
 219         av_log(avctx, AV_LOG_ERROR,
 220                "VAAPI driver doesn't support HDR to SDR\n");
 221         return AVERROR(EINVAL);
 222     }
 223
 224     hdrtm_param.type = VAProcFilterHighDynamicRangeToneMapping;
 225     hdrtm_param.data.metadata_type = VAProcHighDynamicRangeMetadataHDR10;
 226     hdrtm_param.data.metadata      = &ctx->in_metadata;
 227     hdrtm_param.data.metadata_size = sizeof(VAHdrMetaDataHDR10);
 228
 229     return ff_vaapi_vpp_make_param_buffers(avctx,
 230                                            VAProcFilterParameterBufferType,
 231                                            &hdrtm_param, sizeof(hdrtm_param), 1);
 232 }
 233
 234 static int tonemap_vaapi_filter_frame(AVFilterLink *inlink, AVFrame *input_frame)
 235 {
 236     AVFilterContext *avctx     = inlink->dst;
 237     AVFilterLink *outlink      = avctx->outputs[0];
 238     VAAPIVPPContext *vpp_ctx   = avctx->priv;
 239     HDRVAAPIContext *ctx       = avctx->priv;
 240     AVFrame *output_frame      = NULL;
 241     VASurfaceID input_surface, output_surface;
 242
 243     VAProcPipelineParameterBuffer params;
 244     int err;
 245
 246     av_log(avctx, AV_LOG_DEBUG, "Filter input: %s, %ux%u (%"PRId64").\n",
 247            av_get_pix_fmt_name(input_frame->format),
 248            input_frame->width, input_frame->height, input_frame->pts);
 249
 250     if (vpp_ctx->va_context == VA_INVALID_ID){
 251         av_frame_free(&input_frame);
 252         return AVERROR(EINVAL);
 253     }
 254
 255     err = tonemap_vaapi_save_metadata(avctx, input_frame);
 256     if (err < 0)
 257         goto fail;
 258
 259     err = tonemap_vaapi_set_filter_params(avctx, input_frame);
 260     if (err < 0)
 261         goto fail;
 262
 263     input_surface = (VASurfaceID)(uintptr_t)input_frame->data[3];
 264     av_log(avctx, AV_LOG_DEBUG, "Using surface %#x for tonemap vpp input.\n",
 265            input_surface);
 266
 267     output_frame = ff_get_video_buffer(outlink, vpp_ctx->output_width,
 268                                        vpp_ctx->output_height);
 269     if (!output_frame) {
 270         err = AVERROR(ENOMEM);
 271         goto fail;
 272     }
 273
 274     output_surface = (VASurfaceID)(uintptr_t)output_frame->data[3];
 275     av_log(avctx, AV_LOG_DEBUG, "Using surface %#x for tonemap vpp output.\n",
 276            output_surface);
 277     memset(&params, 0, sizeof(params));
 278
 279     err = av_frame_copy_props(output_frame, input_frame);
 280     if (err < 0)
 281         goto fail;
 282
 283     if (ctx->color_primaries != AVCOL_PRI_UNSPECIFIED)
 284         output_frame->color_primaries = ctx->color_primaries;
 285
 286     if (ctx->color_transfer != AVCOL_TRC_UNSPECIFIED)
 287         output_frame->color_trc = ctx->color_transfer;
 288     else
 289         output_frame->color_trc = AVCOL_TRC_BT709;
 290
 291     if (ctx->color_matrix != AVCOL_SPC_UNSPECIFIED)
 292         output_frame->colorspace = ctx->color_matrix;
 293
 294     err = ff_vaapi_vpp_init_params(avctx, &params,
 295                                    input_frame, output_frame);
 296     if (err < 0)
 297         goto fail;
 298
 299     err = ff_vaapi_vpp_render_picture(avctx, &params, output_frame);
 300     if (err < 0)
 301         goto fail;
 302
 303     av_frame_free(&input_frame);
 304
 305     av_log(avctx, AV_LOG_DEBUG, "Filter output: %s, %ux%u (%"PRId64").\n",
 306            av_get_pix_fmt_name(output_frame->format),
 307            output_frame->width, output_frame->height, output_frame->pts);
 308
 309     return ff_filter_frame(outlink, output_frame);
 310
 311 fail:
 312     av_frame_free(&input_frame);
 313     av_frame_free(&output_frame);
 314     return err;
 315 }
 316
 317 static av_cold int tonemap_vaapi_init(AVFilterContext *avctx)
 318 {
 319     VAAPIVPPContext *vpp_ctx = avctx->priv;
 320     HDRVAAPIContext *ctx     = avctx->priv;
 321
 322     ff_vaapi_vpp_ctx_init(avctx);
 323     vpp_ctx->build_filter_params = tonemap_vaapi_build_filter_params;
 324     vpp_ctx->pipeline_uninit = ff_vaapi_vpp_pipeline_uninit;
 325
 326     if (ctx->output_format_string) {
 327         vpp_ctx->output_format = av_get_pix_fmt(ctx->output_format_string);
 328         switch (vpp_ctx->output_format) {
 329         case AV_PIX_FMT_NV12:
 330         case AV_PIX_FMT_P010:
 331             break;
 332         default:
 333             av_log(avctx, AV_LOG_ERROR, "Invalid output format.\n");
 334             return AVERROR(EINVAL);
 335         }
 336     } else {
 337         vpp_ctx->output_format = AV_PIX_FMT_NV12;
 338         av_log(avctx, AV_LOG_WARNING, "Output format not set, use default format NV12\n");
 339     }
 340
 341 #define STRING_OPTION(var_name, func_name, default_value) do { \
 342         if (ctx->var_name ## _string) { \
 343             int var = av_ ## func_name ## _from_name(ctx->var_name ## _string); \
 344             if (var < 0) { \
 345                 av_log(avctx, AV_LOG_ERROR, "Invalid %s.\n", #var_name); \
 346                 return AVERROR(EINVAL); \
 347             } \
 348             ctx->var_name = var; \
 349         } else { \
 350             ctx->var_name = default_value; \
 351         } \
 352     } while (0)
 353
 354     STRING_OPTION(color_primaries, color_primaries, AVCOL_PRI_UNSPECIFIED);
 355     STRING_OPTION(color_transfer,  color_transfer,  AVCOL_TRC_UNSPECIFIED);
 356     STRING_OPTION(color_matrix,    color_space,     AVCOL_SPC_UNSPECIFIED);
 357
 358     return 0;
 359 }
 360
 361 #define OFFSET(x) offsetof(HDRVAAPIContext, x)
 362 #define FLAGS (AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_FILTERING_PARAM)
 363 static const AVOption tonemap_vaapi_options[] = {
 364     { "format", "Output pixel format set", OFFSET(output_format_string), AV_OPT_TYPE_STRING, .flags = FLAGS, "format" },
 365     { "matrix", "Output color matrix coefficient set",
 366       OFFSET(color_matrix_string), AV_OPT_TYPE_STRING,
 367       { .str = NULL }, .flags = FLAGS, "matrix" },
 368     { "m",      "Output color matrix coefficient set",
 369       OFFSET(color_matrix_string), AV_OPT_TYPE_STRING,
 370       { .str = NULL }, .flags = FLAGS, "matrix" },
 371     { "primaries", "Output color primaries set",
 372       OFFSET(color_primaries_string), AV_OPT_TYPE_STRING,
 373       { .str = NULL }, .flags = FLAGS, "primaries" },
 374     { "p",         "Output color primaries set",
 375       OFFSET(color_primaries_string), AV_OPT_TYPE_STRING,
 376       { .str = NULL }, .flags = FLAGS, "primaries" },
 377     { "transfer", "Output color transfer characteristics set",
 378       OFFSET(color_transfer_string),  AV_OPT_TYPE_STRING,
 379       { .str = NULL }, .flags = FLAGS, "transfer" },
 380     { "t",        "Output color transfer characteristics set",
 381       OFFSET(color_transfer_string),  AV_OPT_TYPE_STRING,
 382       { .str = NULL }, .flags = FLAGS, "transfer" },
 383     { NULL }
 384 };
 385
 386
 387 AVFILTER_DEFINE_CLASS(tonemap_vaapi);
 388
 389 static const AVFilterPad tonemap_vaapi_inputs[] = {
 390     {
 391         .name         = "default",
 392         .type         = AVMEDIA_TYPE_VIDEO,
 393         .filter_frame = &tonemap_vaapi_filter_frame,
 394         .config_props = &ff_vaapi_vpp_config_input,
 395     },
 396     { NULL }
 397 };
 398
 399 static const AVFilterPad tonemap_vaapi_outputs[] = {
 400     {
 401         .name = "default",
 402         .type = AVMEDIA_TYPE_VIDEO,
 403         .config_props = &ff_vaapi_vpp_config_output,
 404     },
 405     { NULL }
 406 };
 407
 408 AVFilter ff_vf_tonemap_vaapi = {
 409     .name           = "tonemap_vaapi",
 410     .description    = NULL_IF_CONFIG_SMALL("VAAPI VPP for tone-mapping"),
 411     .priv_size      = sizeof(HDRVAAPIContext),
 412     .init           = &tonemap_vaapi_init,
 413     .uninit         = &ff_vaapi_vpp_ctx_uninit,
 414     .query_formats  = &ff_vaapi_vpp_query_formats,
 415     .inputs         = tonemap_vaapi_inputs,
 416     .outputs        = tonemap_vaapi_outputs,
 417     .priv_class     = &tonemap_vaapi_class,
 418     .flags_internal = FF_FILTER_FLAG_HWFRAME_AWARE,
 419 };