diff --git a/docs/libs/gst-plugins-base-libs-sections.txt b/docs/libs/gst-plugins-base-libs-sections.txt index 82040a44f0..0e96aaf395 100644 --- a/docs/libs/gst-plugins-base-libs-sections.txt +++ b/docs/libs/gst-plugins-base-libs-sections.txt @@ -3047,6 +3047,23 @@ GST_TYPE_VIDEO_MATRIX_MODE GST_TYPE_VIDEO_PRIMARIES_MODE GST_TYPE_VIDEO_DITHER_METHOD +#video-hdr.h + +GstVideoMasteringDisplayInfo +GstVideoContentLightLevel +gst_video_mastering_display_info_add_to_caps +gst_video_mastering_display_info_from_caps +gst_video_mastering_display_info_from_string +gst_video_mastering_display_info_init +gst_video_mastering_display_info_is_equal +gst_video_mastering_display_info_is_valid +gst_video_mastering_display_info_to_string +gst_video_content_light_level_add_to_caps +gst_video_content_light_level_from_caps +gst_video_content_light_level_from_string +gst_video_content_light_level_init +gst_video_content_light_level_to_string + #video-multiview.h GstVideoMultiviewMode diff --git a/gst-libs/gst/video/Makefile.am b/gst-libs/gst/video/Makefile.am index b101f00006..16487e4080 100644 --- a/gst-libs/gst/video/Makefile.am +++ b/gst-libs/gst/video/Makefile.am @@ -5,7 +5,7 @@ include $(top_srcdir)/common/orc.mak glib_enum_headers = video.h video-format.h video-color.h video-info.h video-dither.h \ colorbalance.h navigation.h video-chroma.h video-tile.h video-converter.h \ video-resampler.h video-frame.h video-scaler.h video-anc.h \ - video-overlay-composition.h + video-overlay-composition.h video-hdr.h glib_enum_define = GST_VIDEO glib_gen_prefix = gst_video glib_gen_basename = video @@ -32,6 +32,7 @@ libgstvideo_@GST_API_VERSION@_la_SOURCES = \ video-color.c \ video-converter.c \ video-dither.c \ + video-hdr.c \ video-info.c \ video-frame.c \ video-scaler.c \ @@ -72,6 +73,7 @@ libgstvideo_@GST_API_VERSION@include_HEADERS = \ video-color.h \ video-converter.h \ video-dither.h \ + video-hdr.h \ video-info.h \ video-frame.h \ video-scaler.h \ diff --git a/gst-libs/gst/video/meson.build b/gst-libs/gst/video/meson.build index b4dfcdf65b..397f103497 100644 --- a/gst-libs/gst/video/meson.build +++ b/gst-libs/gst/video/meson.build @@ -24,6 +24,7 @@ video_sources = [ 'video-event.c', 'video-format.c', 'video-frame.c', + 'video-hdr.c', 'video-info.c', 'video-multiview.c', 'video-resampler.c', @@ -57,6 +58,7 @@ video_headers = [ 'video-color.h', 'video-converter.h', 'video-dither.h', + 'video-hdr.h', 'video-info.h', 'video-frame.h', 'video-prelude.h', diff --git a/gst-libs/gst/video/video-hdr.c b/gst-libs/gst/video/video-hdr.c new file mode 100644 index 0000000000..46d449dbf6 --- /dev/null +++ b/gst-libs/gst/video/video-hdr.c @@ -0,0 +1,455 @@ +/* GStreamer + * Copyright (C) <2018-2019> Seungha Yang + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the + * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, + * Boston, MA 02110-1301, USA. + */ + +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif + +#include +#include + +#include "video-hdr.h" + +#define N_ELEMENT_MASTERING_DISPLAY_INFO 20 +#define MASTERING_FORMAT \ + "%d:%d:" \ + "%d:%d:" \ + "%d:%d:" \ + "%d:%d:" \ + "%d:%d:" \ + "%d:%d:" \ + "%d:%d:" \ + "%d:%d:" \ + "%d:%d:" \ + "%d:%d" + +#define MASTERING_SCANF_ARGS(m) \ + &(m)->Rx_n, &(m)->Rx_d, &(m)->Ry_n, &(m)->Ry_d, \ + &(m)->Gx_n, &(m)->Gx_d, &(m)->Gy_n, &(m)->Gy_d, \ + &(m)->Bx_n, &(m)->Bx_d, &(m)->By_n, &(m)->By_d, \ + &(m)->Wx_n, &(m)->Wx_d, &(m)->Wy_n, &(m)->Wy_d, \ + &(m)->max_luma_n, &(m)->max_luma_d, \ + &(m)->min_luma_n, &(m)->min_luma_d + +#define RX_ARGS(m) (m)->Rx_n, (m)->Rx_d +#define RY_ARGS(m) (m)->Ry_n, (m)->Ry_d +#define GX_ARGS(m) (m)->Gx_n, (m)->Gx_d +#define GY_ARGS(m) (m)->Gy_n, (m)->Gy_d +#define BX_ARGS(m) (m)->Bx_n, (m)->Bx_d +#define BY_ARGS(m) (m)->By_n, (m)->By_d +#define WX_ARGS(m) (m)->Wx_n, (m)->Wx_d +#define WY_ARGS(m) (m)->Wy_n, (m)->Wy_d +#define MAX_LUMA_ARGS(m) (m)->max_luma_n, (m)->max_luma_d +#define MIN_LUMA_ARGS(m) (m)->min_luma_n, (m)->min_luma_d + +#define MASTERING_PRINTF_ARGS(m) \ + RX_ARGS(m), RY_ARGS(m), \ + GX_ARGS(m), GY_ARGS(m), \ + BX_ARGS(m), BY_ARGS(m), \ + WX_ARGS(m), WY_ARGS(m), \ + MAX_LUMA_ARGS(m), MIN_LUMA_ARGS(m) + +/** + * gst_video_mastering_display_info_init: + * @minfo: a #GstVideoMasteringDisplayInfo + * + * Initialize @minfo + * + * Since: 1.18 + */ +void +gst_video_mastering_display_info_init (GstVideoMasteringDisplayInfo * minfo) +{ + g_return_if_fail (minfo != NULL); + + memset (minfo, 0, sizeof (GstVideoMasteringDisplayInfo)); +} + +#define DIVIDE_ARGS(val,gcd) \ +{ \ + minfo->G_PASTE(val,_n) /= gcd; \ + minfo->G_PASTE(val,_d) /= gcd; \ +} + +static void +gst_video_mastering_display_info_normalize (GstVideoMasteringDisplayInfo * + minfo) +{ + guint gcd; + + gcd = gst_util_greatest_common_divisor (RX_ARGS (minfo)); + DIVIDE_ARGS (Rx, gcd); + + gcd = gst_util_greatest_common_divisor (RY_ARGS (minfo)); + DIVIDE_ARGS (Ry, gcd); + + gcd = gst_util_greatest_common_divisor (GX_ARGS (minfo)); + DIVIDE_ARGS (Gx, gcd); + + gcd = gst_util_greatest_common_divisor (GY_ARGS (minfo)); + DIVIDE_ARGS (Gy, gcd); + + gcd = gst_util_greatest_common_divisor (BX_ARGS (minfo)); + DIVIDE_ARGS (Bx, gcd); + + gcd = gst_util_greatest_common_divisor (BY_ARGS (minfo)); + DIVIDE_ARGS (By, gcd); + + gcd = gst_util_greatest_common_divisor (WX_ARGS (minfo)); + DIVIDE_ARGS (Wx, gcd); + + gcd = gst_util_greatest_common_divisor (WY_ARGS (minfo)); + DIVIDE_ARGS (Wy, gcd); + + gcd = gst_util_greatest_common_divisor (MAX_LUMA_ARGS (minfo)); + DIVIDE_ARGS (max_luma, gcd); + + gcd = gst_util_greatest_common_divisor (MIN_LUMA_ARGS (minfo)); + DIVIDE_ARGS (min_luma, gcd); +} + +/** + * gst_video_mastering_display_info_from_string: + * @minfo: (out): a #GstVideoMasteringDisplayInfo + * @mastering: a #GstStructure representing #GstVideoMasteringDisplayInfo + * + * Extract #GstVideoMasteringDisplayInfo from @mastering + * + * Returns: %TRUE if @minfo was filled with @mastering + * + * Since: 1.18 + */ +gboolean + gst_video_mastering_display_info_from_string + (GstVideoMasteringDisplayInfo * minfo, const gchar * mastering) +{ + GstVideoMasteringDisplayInfo tmp; + + g_return_val_if_fail (minfo != NULL, FALSE); + g_return_val_if_fail (mastering != NULL, FALSE); + + if (sscanf (mastering, MASTERING_FORMAT, + MASTERING_SCANF_ARGS (&tmp)) == N_ELEMENT_MASTERING_DISPLAY_INFO && + gst_video_mastering_display_info_is_valid (&tmp)) { + gst_video_mastering_display_info_normalize (&tmp); + *minfo = tmp; + return TRUE; + } + + return FALSE; +} + +/** + * gst_video_mastering_display_info_to_string: + * @minfo: a #GstVideoMasteringDisplayInfo + * + * Convert @minfo to its string representation + * + * Returns: (transfer full) (nullable): a string representation of @minfo + * or %NULL if @minfo has invalid chromaticity and/or luminance values + * + * Since: 1.18 + */ +gchar * +gst_video_mastering_display_info_to_string (const + GstVideoMasteringDisplayInfo * minfo) +{ + GstVideoMasteringDisplayInfo copy; + + g_return_val_if_fail (minfo != NULL, NULL); + + if (!gst_video_mastering_display_info_is_valid (minfo)) + return NULL; + + copy = *minfo; + gst_video_mastering_display_info_normalize (©); + + return g_strdup_printf (MASTERING_FORMAT, MASTERING_PRINTF_ARGS (©)); +} + +/** + * gst_video_mastering_display_info_is_equal: + * @minfo: a #GstVideoMasteringDisplayInfo + * @other: a #GstVideoMasteringDisplayInfo + * + * Checks equality between @minfo and @other. + * + * Returns: %TRUE if @minfo and @other are equal. + * + * Since: 1.18 + */ +gboolean +gst_video_mastering_display_info_is_equal (const + GstVideoMasteringDisplayInfo * minfo, + const GstVideoMasteringDisplayInfo * other) +{ + if (gst_util_fraction_compare (RX_ARGS (minfo), RX_ARGS (other)) || + gst_util_fraction_compare (RY_ARGS (minfo), RY_ARGS (other)) || + gst_util_fraction_compare (GX_ARGS (minfo), GX_ARGS (other)) || + gst_util_fraction_compare (GY_ARGS (minfo), GY_ARGS (other)) || + gst_util_fraction_compare (BX_ARGS (minfo), BX_ARGS (other)) || + gst_util_fraction_compare (BY_ARGS (minfo), BY_ARGS (other)) || + gst_util_fraction_compare (WX_ARGS (minfo), WX_ARGS (other)) || + gst_util_fraction_compare (WY_ARGS (minfo), WY_ARGS (other)) || + gst_util_fraction_compare (MAX_LUMA_ARGS (minfo), MAX_LUMA_ARGS (other)) + || gst_util_fraction_compare (MIN_LUMA_ARGS (minfo), + MIN_LUMA_ARGS (other))) + return FALSE; + + return TRUE; +} + +/** + * gst_video_mastering_display_info_is_valid: + * @minfo: a #GstVideoMasteringDisplayInfo + * + * Checks the minumum validity of @mininfo (not theoretical validation). + * + * Each x and y chromaticity coordinate should be in the range of [0, 1] + * min_luma should be less than max_luma. + * + * Returns: %TRUE if @minfo satisfies the condition. + * + * Since: 1.18 + */ +gboolean +gst_video_mastering_display_info_is_valid (const GstVideoMasteringDisplayInfo * + minfo) +{ + GstVideoMasteringDisplayInfo other; + + gst_video_mastering_display_info_init (&other); + + if (!memcmp (minfo, &other, sizeof (GstVideoMasteringDisplayInfo))) + return FALSE; + + /* should be valid fraction */ + if (!minfo->Rx_d || !minfo->Ry_d || !minfo->Gx_d || !minfo->Gy_d || + !minfo->Bx_d || !minfo->By_d || !minfo->Wx_d || !minfo->Wy_d || + !minfo->max_luma_d || !minfo->min_luma_d) + return FALSE; + + /* should be less than one */ + if (gst_util_fraction_compare (RX_ARGS (minfo), 1, 1) > 0 || + gst_util_fraction_compare (RY_ARGS (minfo), 1, 1) > 0 || + gst_util_fraction_compare (GX_ARGS (minfo), 1, 1) > 0 || + gst_util_fraction_compare (GY_ARGS (minfo), 1, 1) > 0 || + gst_util_fraction_compare (BX_ARGS (minfo), 1, 1) > 0 || + gst_util_fraction_compare (BY_ARGS (minfo), 1, 1) > 0 || + gst_util_fraction_compare (WX_ARGS (minfo), 1, 1) > 0 || + gst_util_fraction_compare (WY_ARGS (minfo), 1, 1) > 0) + return FALSE; + + if (gst_util_fraction_compare (MAX_LUMA_ARGS (minfo), + MIN_LUMA_ARGS (minfo)) <= 0) + return FALSE; + + return TRUE; +} + +/** + * gst_video_mastering_display_info_from_caps: + * @minfo: a #GstVideoMasteringDisplayInfo + * @caps: a #GstCaps + * + * Parse @caps and update @minfo + * + * Returns: %TRUE if @caps has #GstVideoMasteringDisplayInfo and could be parsed + * + * Since: 1.18 + */ +gboolean +gst_video_mastering_display_info_from_caps (GstVideoMasteringDisplayInfo * + minfo, const GstCaps * caps) +{ + GstStructure *structure; + const gchar *s; + + g_return_val_if_fail (minfo != NULL, FALSE); + g_return_val_if_fail (GST_IS_CAPS (caps), FALSE); + + structure = gst_caps_get_structure (caps, 0); + + if ((s = gst_structure_get_string (structure, + "mastering-display-info")) == NULL) + return FALSE; + + return gst_video_mastering_display_info_from_string (minfo, s); +} + +/** + * gst_video_mastering_display_info_add_to_caps: + * @minfo: a #GstVideoMasteringDisplayInfo + * @caps: a #GstCaps + * + * Set string representation of @minfo to @caps + * + * Returns: %TRUE if @minfo was successfully set to @caps + * + * Since: 1.18 + */ +gboolean +gst_video_mastering_display_info_add_to_caps (const GstVideoMasteringDisplayInfo + * minfo, GstCaps * caps) +{ + gchar *s; + + g_return_val_if_fail (minfo != NULL, FALSE); + g_return_val_if_fail (GST_IS_CAPS (caps), FALSE); + g_return_val_if_fail (gst_caps_is_writable (caps), FALSE); + + s = gst_video_mastering_display_info_to_string (minfo); + if (!s) + return FALSE; + + gst_caps_set_simple (caps, "mastering-display-info", G_TYPE_STRING, s, NULL); + g_free (s); + + return TRUE; +} + +/** + * gst_video_content_light_level_init: + * @linfo: a #GstVideoContentLightLevel + * + * Initialize @linfo + * + * Since: 1.18 + */ +void +gst_video_content_light_level_init (GstVideoContentLightLevel * linfo) +{ + g_return_if_fail (linfo != NULL); + + memset (linfo, 0, sizeof (GstVideoContentLightLevel)); +} + +/** + * gst_video_content_light_level_from_string: + * @linfo: a #GstVideoContentLightLevel + * @level: a content-light-level string from caps + * + * Parse the value of content-light-level caps field and update @minfo + * with the parsed values. + * + * Returns: %TRUE if @linfo points to valid #GstVideoContentLightLevel. + * + * Since: 1.18 + */ +gboolean +gst_video_content_light_level_from_string (GstVideoContentLightLevel * + linfo, const gchar * level) +{ + guint maxCLL_n, maxCLL_d; + guint maxFALL_n, maxFALL_d; + + g_return_val_if_fail (linfo != NULL, FALSE); + g_return_val_if_fail (level != NULL, FALSE); + + if (sscanf (level, "%u:%u:%u:%u", &maxCLL_n, &maxCLL_d, &maxFALL_n, + &maxFALL_d) == 4 && maxCLL_d != 0 && maxFALL_d != 0) { + linfo->maxCLL_n = maxCLL_n; + linfo->maxCLL_d = maxCLL_d; + linfo->maxFALL_n = maxFALL_n; + linfo->maxFALL_d = maxFALL_d; + return TRUE; + } + + return FALSE; +} + +/** + * gst_video_content_light_level_to_string: + * @linfo: a #GstVideoContentLightLevel + * Convert @linfo to its string representation. + * + * Returns: (transfer full): a string representation of @linfo. + * + * Since: 1.18 + */ +gchar * +gst_video_content_light_level_to_string (const GstVideoContentLightLevel * + linfo) +{ + g_return_val_if_fail (linfo != NULL, NULL); + + /* When maxCLL and/or maxFALL is zero, it means no upper bound is indicated. + * But at least it should be valid fraction value */ + g_return_val_if_fail (linfo->maxCLL_d != 0 && linfo->maxFALL_d != 0, NULL); + + return g_strdup_printf ("%u:%u:%u:%u", + linfo->maxCLL_n, linfo->maxCLL_d, linfo->maxFALL_n, linfo->maxFALL_d); +} + +/** + * gst_video_content_light_level_from_caps: + * @linfo: a #GstVideoContentLightLevel + * @caps: a #GstCaps + * + * Parse @caps and update @linfo + * + * Returns: if @caps has #GstVideoContentLightLevel and could be parsed + * + * Since: 1.18 + */ +gboolean +gst_video_content_light_level_from_caps (GstVideoContentLightLevel * linfo, + const GstCaps * caps) +{ + GstStructure *structure; + const gchar *s; + + g_return_val_if_fail (linfo != NULL, FALSE); + g_return_val_if_fail (GST_IS_CAPS (caps), FALSE); + + structure = gst_caps_get_structure (caps, 0); + + if ((s = gst_structure_get_string (structure, "content-light-level")) == NULL) + return FALSE; + + return gst_video_content_light_level_from_string (linfo, s); +} + +/** + * gst_video_content_light_level_add_to_caps: + * @linfo: a #GstVideoContentLightLevel + * @caps: a #GstCaps + * + * Parse @caps and update @linfo + * + * Returns: %TRUE if @linfo was successfully set to @caps + * + * Since: 1.18 + */ +gboolean +gst_video_content_light_level_add_to_caps (const GstVideoContentLightLevel * + linfo, GstCaps * caps) +{ + gchar *s; + + g_return_val_if_fail (linfo != NULL, FALSE); + g_return_val_if_fail (GST_IS_CAPS (caps), FALSE); + g_return_val_if_fail (gst_caps_is_writable (caps), FALSE); + + s = gst_video_content_light_level_to_string (linfo); + gst_caps_set_simple (caps, "content-light-level", G_TYPE_STRING, s, NULL); + g_free (s); + + return TRUE; +} diff --git a/gst-libs/gst/video/video-hdr.h b/gst-libs/gst/video/video-hdr.h new file mode 100644 index 0000000000..a4d32af9f7 --- /dev/null +++ b/gst-libs/gst/video/video-hdr.h @@ -0,0 +1,143 @@ +/* GStreamer + * Copyright (C) <2018-2019> Seungha Yang + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the + * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, + * Boston, MA 02110-1301, USA. + */ + +#ifndef __GST_VIDEO_HDR_H__ +#define __GST_VIDEO_HDR_H__ + +#include +#include + +G_BEGIN_DECLS + +typedef struct _GstVideoMasteringDisplayInfo GstVideoMasteringDisplayInfo; +typedef struct _GstVideoContentLightLevel GstVideoContentLightLevel; + +/** + * GstVideoMasteringDisplayInfo: + * @Rx_n: the numerator of nunormalized red x coordinate as defined CIE 1931 + * @Rx_d: the denominator of normalized red x coordinate as defined CIE 1931 + * @Ry_n: the numerator of normalized red y coordinate as defined CIE 1931 + * @Ry_d: the denominator of normalized red y coordinate as defined CIE 1931 + * @Gx_n: the numerator of normalized green x coordinate as defined CIE 1931 + * @Gx_d: the denominator of normalized green x coordinate as defined CIE 1931 + * @Gy_n: the numerator of normalized green y coordinate as defined CIE 1931 + * @Gy_d: the denominator of normalized green y coordinate as defined CIE 1931 + * @Bx_n: the numerator of normalized blue x coordinate as defined CIE 1931 + * @Bx_d: the denominator of normalized blue x coordinate as defined CIE 1931 + * @By_n: the numerator of normalized blue y coordinate as defined CIE 1931 + * @By_d: the denominator of normalized blue y coordinate as defined CIE 1931 + * @Wx_n: the numerator of normalized white x coordinate as defined CIE 1931 + * @Wx_d: the denominator of normalized white x coordinate as defined CIE 1931 + * @Wy_n: the numerator of normalized white y coordinate as defined CIE 1931 + * @Wy_d: the denominator of normalized white y coordinate as defined CIE 1931 + * @max_luma_n: the numerator of maximum display luminance in candelas per square meter (cd/m^2 and nit) + * @max_luma_d: the denominator of maximum display luminance in candelas per square meter (cd/m^2 and nit) + * @min_luma_n: the numerator of minimum display luminance in candelas per square meter (cd/m^2 and nit) + * @min_luma_d: the denominator of minimum display luminance in candelas per square meter (cd/m^2 and nit) + * + * Mastering display color volume information defined by SMPTE ST 2086 + * (a.k.a static HDR metadata). + * Each array represent fraction value of red, green, blue, white + * and min/max luma (the first element of an array is numerator). + * + * The decimal representation of each red, green, blue and white value should + * be in the range of [0, 1]. + * + * Since: 1.18 + */ +struct _GstVideoMasteringDisplayInfo +{ + guint Rx_n, Rx_d, Ry_n, Ry_d; + guint Gx_n, Gx_d, Gy_n, Gy_d; + guint Bx_n, Bx_d, By_n, By_d; + guint Wx_n, Wx_d, Wy_n, Wy_d; + guint max_luma_n, max_luma_d; + guint min_luma_n, min_luma_d; + + /*< private >*/ + guint _gst_reserved[GST_PADDING]; +}; + +GST_VIDEO_API +void gst_video_mastering_display_info_init (GstVideoMasteringDisplayInfo * minfo); + +GST_VIDEO_API +gboolean gst_video_mastering_display_info_from_string (GstVideoMasteringDisplayInfo * minfo, + const gchar * mastering); + +GST_VIDEO_API +gchar * gst_video_mastering_display_info_to_string (const GstVideoMasteringDisplayInfo * minfo); + +GST_VIDEO_API +gboolean gst_video_mastering_display_info_is_equal (const GstVideoMasteringDisplayInfo * minfo, + const GstVideoMasteringDisplayInfo * other); + +GST_VIDEO_API +gboolean gst_video_mastering_display_info_is_valid (const GstVideoMasteringDisplayInfo * minfo); + +GST_VIDEO_API +gboolean gst_video_mastering_display_info_from_caps (GstVideoMasteringDisplayInfo * minfo, + const GstCaps * caps); + +GST_VIDEO_API +gboolean gst_video_mastering_display_info_add_to_caps (const GstVideoMasteringDisplayInfo * minfo, + GstCaps * caps); + +/** + * GstVideoContentLightMeta: + * @maxCLL_n: the numerator of Maximum Content Light Level (cd/m^2 and nit) + * @maxCLL_d: the denominator of Maximum Content Light Level (cd/m^2 and nit) + * @maxFALL_n: the numerator Maximum Frame-Average Light Level (cd/m^2 and nit) + * @maxFALL_d: the denominator Maximum Frame-Average Light Level (cd/m^2 and nit) + * + * Content light level information specified in CEA-861.3, Appendix A. + * + * Since: 1.18 + */ +struct _GstVideoContentLightLevel +{ + guint maxCLL_n, maxCLL_d; + guint maxFALL_n, maxFALL_d; + + /*< private >*/ + guint _gst_reserved[GST_PADDING]; +}; + +GST_VIDEO_API +void gst_video_content_light_level_init (GstVideoContentLightLevel * linfo); + +GST_VIDEO_API +gboolean gst_video_content_light_level_from_string (GstVideoContentLightLevel * linfo, + const gchar * level); + +GST_VIDEO_API +gchar * gst_video_content_light_level_to_string (const GstVideoContentLightLevel * linfo); + +GST_VIDEO_API +gboolean gst_video_content_light_level_from_caps (GstVideoContentLightLevel * linfo, + const GstCaps * caps); + +GST_VIDEO_API +gboolean gst_video_content_light_level_add_to_caps (const GstVideoContentLightLevel * linfo, + GstCaps * caps); + + +G_END_DECLS + +#endif /* __GST_VIDEO_HDR_H__ */ diff --git a/gst-libs/gst/video/video.h b/gst-libs/gst/video/video.h index c26df59016..c6ca091e93 100644 --- a/gst-libs/gst/video/video.h +++ b/gst-libs/gst/video/video.h @@ -183,5 +183,6 @@ G_END_DECLS #include #include #include +#include #endif /* __GST_VIDEO_H__ */