From: Sreerenj Balachandran Date: Mon, 13 Apr 2015 11:53:46 +0000 (+0300) Subject: HEVC: Add codec utility methods to core libgstvaapi X-Git-Tag: 1.19.3~503^2~1830 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=8c5f1b1c4b8bb89db207b2a57cebea45bf43d599;p=platform%2Fupstream%2Fgstreamer.git HEVC: Add codec utility methods to core libgstvaapi Signed-off-by: Sreerenj Balachandran --- diff --git a/gst-libs/gst/vaapi/Makefile.am b/gst-libs/gst/vaapi/Makefile.am index d457b3cc75..782f1ccb3b 100644 --- a/gst-libs/gst/vaapi/Makefile.am +++ b/gst-libs/gst/vaapi/Makefile.am @@ -80,6 +80,7 @@ libgstvaapi_source_c = \ gstvaapiutils_core.c \ gstvaapiutils_h264.c \ gstvaapiutils_mpeg2.c \ + gstvaapiutils_h265.c \ gstvaapivalue.c \ gstvaapivideopool.c \ gstvaapiwindow.c \ @@ -109,6 +110,7 @@ libgstvaapi_source_h = \ gstvaapitypes.h \ gstvaapiutils_h264.h \ gstvaapiutils_mpeg2.h \ + gstvaapiutils_h265.h \ gstvaapivalue.h \ gstvaapivideopool.h \ gstvaapiwindow.h \ @@ -142,6 +144,7 @@ libgstvaapi_source_priv_h = \ gstvaapiutils_core.h \ gstvaapiutils_h264_priv.h \ gstvaapiutils_mpeg2_priv.h \ + gstvaapiutils_h265_priv.h \ gstvaapiversion.h \ gstvaapivideopool_priv.h \ gstvaapiwindow_priv.h \ diff --git a/gst-libs/gst/vaapi/gstvaapiutils_h265.c b/gst-libs/gst/vaapi/gstvaapiutils_h265.c new file mode 100644 index 0000000000..279400e0ca --- /dev/null +++ b/gst-libs/gst/vaapi/gstvaapiutils_h265.c @@ -0,0 +1,325 @@ +/* + * gstvaapiutils_h265.c - H.265 related utilities + * + * Copyright (C) 2015 Intel Corporation + * Author: Sreerenj Balachandran + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public License + * as published by the Free Software Foundation; either version 2.1 + * 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free + * Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + * Boston, MA 02110-1301 USA + */ + +#include "sysdeps.h" +#include +#include "gstvaapiutils_h265_priv.h" + +struct map +{ + guint value; + const gchar *name; +}; + +/* Profile string map */ +static const struct map gst_vaapi_h265_profile_map[] = { +/* *INDENT-OFF* */ + { GST_VAAPI_PROFILE_H265_MAIN, "main" }, + { GST_VAAPI_PROFILE_H265_MAIN10, "main-10" }, + { GST_VAAPI_PROFILE_H265_MAIN_STILL_PICTURE, "main-still-picture" }, + { 0, NULL } +/* *INDENT-ON* */ +}; + +/* Level string map */ +static const struct map gst_vaapi_h265_level_map[] = { +/* *INDENT-OFF* */ + { GST_VAAPI_LEVEL_H265_L1, "1" }, + { GST_VAAPI_LEVEL_H265_L2, "2" }, + { GST_VAAPI_LEVEL_H265_L2_1, "2.1" }, + { GST_VAAPI_LEVEL_H265_L3, "3" }, + { GST_VAAPI_LEVEL_H265_L3_1, "3.1" }, + { GST_VAAPI_LEVEL_H265_L4, "4" }, + { GST_VAAPI_LEVEL_H265_L4_1, "4.1" }, + { GST_VAAPI_LEVEL_H265_L5, "5" }, + { GST_VAAPI_LEVEL_H265_L5_1, "5.1" }, + { GST_VAAPI_LEVEL_H265_L5_2, "5.2" }, + { GST_VAAPI_LEVEL_H265_L6, "6" }, + { GST_VAAPI_LEVEL_H265_L6_1, "6.1" }, + { GST_VAAPI_LEVEL_H265_L6_2, "6.2" }, + { 0, NULL } +/* *INDENT-ON* */ +}; + +/* Table A-1 - Level limits */ +/* *INDENT-OFF* */ +static const GstVaapiH265LevelLimits gst_vaapi_h265_level_limits[] = { + /* level idc MaxLumaPs MCPBMt MCPBHt MSlSeg MTR MTC MaxLumaSr MBRMt MBRHt MinCr*/ + { GST_VAAPI_LEVEL_H265_L1, 30, 36864, 350, 0, 16, 1, 1, 552960, 128, 0, 2}, + { GST_VAAPI_LEVEL_H265_L2, 60, 122880, 1500, 0, 16, 1, 1, 3686400, 1500, 0, 2}, + { GST_VAAPI_LEVEL_H265_L2_1, 63, 245760, 3000, 0, 20, 1, 1, 7372800, 3000, 0, 2}, + { GST_VAAPI_LEVEL_H265_L3, 90, 552960, 6000, 0, 30, 2, 2, 16588800, 6000, 0, 2}, + { GST_VAAPI_LEVEL_H265_L3_1, 93, 983040, 10000, 0, 40, 3, 3, 33177600, 10000, 0, 2}, + { GST_VAAPI_LEVEL_H265_L4, 120, 2228224, 12000, 30000, 75, 5, 5, 66846720, 12000, 30000, 4}, + { GST_VAAPI_LEVEL_H265_L4_1, 123, 2228224, 20000, 50000, 75, 5, 5, 133693440, 20000, 50000, 4}, + { GST_VAAPI_LEVEL_H265_L5, 150, 8912896, 25000, 100000, 200, 11, 10, 267386880, 25000, 100000, 6}, + { GST_VAAPI_LEVEL_H265_L5_1, 153, 8912896, 40000, 160000, 200, 11, 10, 534773760, 40000, 160000, 8}, + { GST_VAAPI_LEVEL_H265_L5_2, 156, 8912896, 60000, 240000, 200, 11, 10, 1069547520, 60000, 240000, 8}, + { GST_VAAPI_LEVEL_H265_L6, 180, 35651584, 60000, 240000, 600, 22, 20, 1069547520, 60000, 240000, 8}, + { GST_VAAPI_LEVEL_H265_L6_1, 183, 35651584, 120000, 480000, 600, 22, 20, 2139095040, 120000, 480000, 8}, + { GST_VAAPI_LEVEL_H265_L6_2, 186, 35651584, 240000, 800000, 600, 22, 20, 4278190080, 240000, 800000, 6}, + { 0, } +}; +/* *INDENT-ON* */ + +/* Lookup value in map */ +static const struct map * +map_lookup_value (const struct map *m, guint value) +{ + g_return_val_if_fail (m != NULL, NULL); + + for (; m->name != NULL; m++) { + if (m->value == value) + return m; + } + return NULL; +} + +/* Lookup name in map */ +static const struct map * +map_lookup_name (const struct map *m, const gchar * name) +{ + g_return_val_if_fail (m != NULL, NULL); + + if (!name) + return NULL; + + for (; m->name != NULL; m++) { + if (strcmp (m->name, name) == 0) + return m; + } + return NULL; +} + +/** Returns a relative score for the supplied GstVaapiProfile */ +guint +gst_vaapi_utils_h265_get_profile_score (GstVaapiProfile profile) +{ + const struct map *const m = + map_lookup_value (gst_vaapi_h265_profile_map, profile); + + return m ? 1 + (m - gst_vaapi_h265_profile_map) : 0; +} + +/** Returns GstVaapiProfile from H.265 profile_idc value */ +GstVaapiProfile +gst_vaapi_utils_h265_get_profile (guint8 profile_idc) +{ + GstVaapiProfile profile; + + switch (profile_idc) { + case GST_H265_PROFILE_MAIN: + profile = GST_VAAPI_PROFILE_H265_MAIN; + break; + case GST_H265_PROFILE_MAIN_10: + profile = GST_VAAPI_PROFILE_H265_MAIN10; + break; + case GST_H265_PROFILE_MAIN_STILL_PICTURE: + profile = GST_VAAPI_PROFILE_H265_MAIN_STILL_PICTURE; + break; + default: + g_debug ("unsupported profile_idc value"); + profile = GST_VAAPI_PROFILE_UNKNOWN; + break; + } + return profile; +} + +/** Returns H.265 profile_idc value from GstVaapiProfile */ +guint8 +gst_vaapi_utils_h265_get_profile_idc (GstVaapiProfile profile) +{ + guint8 profile_idc; + + switch (profile) { + case GST_VAAPI_PROFILE_H265_MAIN: + profile_idc = GST_H265_PROFILE_MAIN; + break; + case GST_VAAPI_PROFILE_H265_MAIN10: + profile_idc = GST_H265_PROFILE_MAIN_10; + break; + case GST_VAAPI_PROFILE_H265_MAIN_STILL_PICTURE: + profile_idc = GST_H265_PROFILE_MAIN_STILL_PICTURE; + break; + default: + g_debug ("unsupported GstVaapiProfile value"); + profile_idc = 0; + break; + } + return profile_idc; +} + +/** Returns GstVaapiProfile from a string representation */ +GstVaapiProfile +gst_vaapi_utils_h265_get_profile_from_string (const gchar * str) +{ + const struct map *const m = map_lookup_name (gst_vaapi_h265_profile_map, str); + + return m ? (GstVaapiProfile) m->value : GST_VAAPI_PROFILE_UNKNOWN; +} + +/** Returns a string representation for the supplied H.265 profile */ +const gchar * +gst_vaapi_utils_h265_get_profile_string (GstVaapiProfile profile) +{ + const struct map *const m = + map_lookup_value (gst_vaapi_h265_profile_map, profile); + + return m ? m->name : NULL; +} + +/** Returns GstVaapiLevelH265 from H.265 level_idc value */ +GstVaapiLevelH265 +gst_vaapi_utils_h265_get_level (guint8 level_idc) +{ + const GstVaapiH265LevelLimits *llp; + + for (llp = gst_vaapi_h265_level_limits; llp->level != 0; llp++) { + if (llp->level_idc == level_idc) + return llp->level; + } + g_debug ("unsupported level_idc value"); + return (GstVaapiLevelH265) 0; +} + +/** Returns H.265 level_idc value from GstVaapiLevelH265 */ +guint8 +gst_vaapi_utils_h265_get_level_idc (GstVaapiLevelH265 level) +{ + const GstVaapiH265LevelLimits *const llp = + gst_vaapi_utils_h265_get_level_limits (level); + + return llp ? llp->level_idc : 0; +} + +/** Returns GstVaapiLevelH265 from a string representation */ +GstVaapiLevelH265 +gst_vaapi_utils_h265_get_level_from_string (const gchar * str) +{ + gint v, level_idc = 0; + + if (!str || !str[0]) + goto not_found; + + v = g_ascii_digit_value (str[0]); + if (v < 0) + goto not_found; + level_idc = v * 30; + + switch (str[1]) { + case '\0': + break; + case '.': + v = g_ascii_digit_value (str[2]); + if (v < 0 || str[3] != '\0') + goto not_found; + level_idc += v; + break; + default: + goto not_found; + } + return gst_vaapi_utils_h265_get_level (level_idc); + +not_found: + return (GstVaapiLevelH265) 0; +} + +/** Returns a string representation for the supplied H.265 level */ +const gchar * +gst_vaapi_utils_h265_get_level_string (GstVaapiLevelH265 level) +{ + if (level < GST_VAAPI_LEVEL_H265_L1 || level > GST_VAAPI_LEVEL_H265_L6_2) + return NULL; + return gst_vaapi_h265_level_map[level - GST_VAAPI_LEVEL_H265_L1].name; +} + +/** Returns level limits as specified in Table A-1 of the H.265 standard */ +const GstVaapiH265LevelLimits * +gst_vaapi_utils_h265_get_level_limits (GstVaapiLevelH265 level) +{ + if (level < GST_VAAPI_LEVEL_H265_L1 || level > GST_VAAPI_LEVEL_H265_L6_2) + return NULL; + return &gst_vaapi_h265_level_limits[level - GST_VAAPI_LEVEL_H265_L1]; +} + +/** Returns the Table A-1 & A-2 specification */ +const GstVaapiH265LevelLimits * +gst_vaapi_utils_h265_get_level_limits_table (guint * out_length_ptr) +{ + if (out_length_ptr) + *out_length_ptr = G_N_ELEMENTS (gst_vaapi_h265_level_limits) - 1; + return gst_vaapi_h265_level_limits; +} + +/** Returns GstVaapiChromaType from H.265 chroma_format_idc value */ +GstVaapiChromaType +gst_vaapi_utils_h265_get_chroma_type (guint chroma_format_idc) +{ + GstVaapiChromaType chroma_type; + + switch (chroma_format_idc) { + case 0: + chroma_type = GST_VAAPI_CHROMA_TYPE_YUV400; + break; + case 1: + chroma_type = GST_VAAPI_CHROMA_TYPE_YUV420; + break; + case 2: + chroma_type = GST_VAAPI_CHROMA_TYPE_YUV422; + break; + case 3: + chroma_type = GST_VAAPI_CHROMA_TYPE_YUV444; + break; + default: + g_debug ("unsupported chroma_format_idc value"); + chroma_type = (GstVaapiChromaType) 0; + break; + } + return chroma_type; +} + +/** Returns H.265 chroma_format_idc value from GstVaapiChromaType */ +guint +gst_vaapi_utils_h265_get_chroma_format_idc (GstVaapiChromaType chroma_type) +{ + guint chroma_format_idc; + + switch (chroma_type) { + case GST_VAAPI_CHROMA_TYPE_YUV400: + chroma_format_idc = 0; + break; + case GST_VAAPI_CHROMA_TYPE_YUV420: + chroma_format_idc = 1; + break; + case GST_VAAPI_CHROMA_TYPE_YUV422: + chroma_format_idc = 2; + break; + case GST_VAAPI_CHROMA_TYPE_YUV444: + chroma_format_idc = 3; + break; + default: + g_debug ("unsupported GstVaapiChromaType value"); + chroma_format_idc = 1; + break; + } + return chroma_format_idc; +} diff --git a/gst-libs/gst/vaapi/gstvaapiutils_h265.h b/gst-libs/gst/vaapi/gstvaapiutils_h265.h new file mode 100644 index 0000000000..fff6e6416b --- /dev/null +++ b/gst-libs/gst/vaapi/gstvaapiutils_h265.h @@ -0,0 +1,88 @@ +/* + * gstvaapiutils_h265.h - H.265 related utilities + * + * Copyright (C) 2015 Intel Corporation + * Author: Sreerenj Balachandran + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public License + * as published by the Free Software Foundation; either version 2.1 + * 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free + * Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + * Boston, MA 02110-1301 USA + */ + +#ifndef GST_VAAPI_UTILS_H265_H +#define GST_VAAPI_UTILS_H265_H + +#include +#include +#include + +G_BEGIN_DECLS + +/** + * GstVaapiLevelH265: + * @GST_VAAPI_LEVEL_H265_L1: H.265 level 1. + * @GST_VAAPI_LEVEL_H265_L2: H.265 level 2. + * @GST_VAAPI_LEVEL_H265_L2_1: H.265 level 2.1. + * @GST_VAAPI_LEVEL_H265_L3: H.265 level 3. + * @GST_VAAPI_LEVEL_H265_L3_1: H.265 level 3.1. + * @GST_VAAPI_LEVEL_H265_L4: H.265 level 4. + * @GST_VAAPI_LEVEL_H265_L4_1: H.265 level 4.1. + * @GST_VAAPI_LEVEL_H265_L5: H.265 level 5. + * @GST_VAAPI_LEVEL_H265_L5_1: H.265 level 5.1. + * @GST_VAAPI_LEVEL_H265_L5_2: H.265 level 5.2. + * @GST_VAAPI_LEVEL_H265_L6: H.265 level 6. + * @GST_VAAPI_LEVEL_H265_L6_1: H.265 level 6.1. + * @GST_VAAPI_LEVEL_H265_L6_2: H.265 level 6.2. + * + * The set of all levels for #GstVaapiLevelH265. + */ +typedef enum { + GST_VAAPI_LEVEL_H265_L1 = 1, + GST_VAAPI_LEVEL_H265_L2, + GST_VAAPI_LEVEL_H265_L2_1, + GST_VAAPI_LEVEL_H265_L3, + GST_VAAPI_LEVEL_H265_L3_1, + GST_VAAPI_LEVEL_H265_L4, + GST_VAAPI_LEVEL_H265_L4_1, + GST_VAAPI_LEVEL_H265_L5, + GST_VAAPI_LEVEL_H265_L5_1, + GST_VAAPI_LEVEL_H265_L5_2, + GST_VAAPI_LEVEL_H265_L6, + GST_VAAPI_LEVEL_H265_L6_1, + GST_VAAPI_LEVEL_H265_L6_2, +} GstVaapiLevelH265; + +/* Returns a relative score for the supplied GstVaapiProfile */ +guint +gst_vaapi_utils_h265_get_profile_score (GstVaapiProfile profile); + +/* Returns GstVaapiProfile from a string representation */ +GstVaapiProfile +gst_vaapi_utils_h265_get_profile_from_string (const gchar * str); + +/* Returns a string representation for the supplied H.265 profile */ +const gchar * +gst_vaapi_utils_h265_get_profile_string (GstVaapiProfile profile); + +/* Returns GstVaapiLevelH265 from a string representation */ +GstVaapiLevelH265 +gst_vaapi_utils_h265_get_level_from_string (const gchar * str); + +/* Returns a string representation for the supplied H.265 level */ +const gchar * +gst_vaapi_utils_h265_get_level_string (GstVaapiLevelH265 level); + +G_END_DECLS + +#endif /* GST_VAAPI_UTILS_H265_H */ diff --git a/gst-libs/gst/vaapi/gstvaapiutils_h265_priv.h b/gst-libs/gst/vaapi/gstvaapiutils_h265_priv.h new file mode 100644 index 0000000000..3991ee96a4 --- /dev/null +++ b/gst-libs/gst/vaapi/gstvaapiutils_h265_priv.h @@ -0,0 +1,105 @@ +/* + * gstvaapiutils_h265_priv.h - H.265 related utilities + * + * Copyright (C) 2015 Intel Corporation + * Author: Sreerenj Balachandran + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public License + * as published by the Free Software Foundation; either version 2.1 + * 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free + * Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + * Boston, MA 02110-1301 USA + */ + +#ifndef GST_VAAPI_UTILS_H265_PRIV_H +#define GST_VAAPI_UTILS_H265_PRIV_H + +#include "gstvaapiutils_h265.h" +#include "libgstvaapi_priv_check.h" + +G_BEGIN_DECLS + +/** + * GstVaapiH265LevelLimits: + * @level: the #GstVaapiLevelH265 + * @level_idc: the H.265 level_idc value + * @MaxLumaPs: the maximum luma picture size + * @MaxCPBTierMain: the maximum CPB size for Main tier(kbits) + * @MaxCPBTierHigh: the maximum CPB size for High tier(kbits) + * @MaxSliceSegPic: the maximum slice segments per picture + * @MaxTileRows: the maximum number of Tile Rows + * @MaxTileColumns: the maximum number of Tile Columns + * @MaxLumaSr: the maximum luma sample rate (samples/sec) + * @MaxBRTierMain: the maximum video bit rate for Main Tier(kbps) + * @MaxBRTierHigh: the maximum video bit rate for High Tier(kbps) + * @MinCr: the mimimum compression ratio + * + * The data structure that describes the limits of an H.265 level. + */ +typedef struct { + GstVaapiLevelH265 level; + guint8 level_idc; + guint32 MaxLumaPs; + guint32 MaxCPBTierMain; + guint32 MaxCPBTierHigh; + guint32 MaxSliceSegPic; + guint32 MaxTileRows; + guint32 MaxTileColumns; + guint32 MaxLumaSr; + guint32 MaxBRTierMain; + guint32 MaxBRTierHigh; + guint32 MinCr; +} GstVaapiH265LevelLimits; + +/* Returns GstVaapiProfile from H.265 profile_idc value */ +G_GNUC_INTERNAL +GstVaapiProfile +gst_vaapi_utils_h265_get_profile (guint8 profile_idc); + +/* Returns H.265 profile_idc value from GstVaapiProfile */ +G_GNUC_INTERNAL +guint8 +gst_vaapi_utils_h265_get_profile_idc (GstVaapiProfile profile); + +/* Returns GstVaapiLevelH265 from H.265 level_idc value */ +G_GNUC_INTERNAL +GstVaapiLevelH265 +gst_vaapi_utils_h265_get_level (guint8 level_idc); + +/* Returns H.265 level_idc value from GstVaapiLevelH265 */ +G_GNUC_INTERNAL +guint8 +gst_vaapi_utils_h265_get_level_idc (GstVaapiLevelH265 level); + +/* Returns level limits as specified in Table A-1 of the H.265 standard */ +G_GNUC_INTERNAL +const GstVaapiH265LevelLimits * +gst_vaapi_utils_h265_get_level_limits (GstVaapiLevelH265 level); + +/* Returns the Table A-1 specification */ +G_GNUC_INTERNAL +const GstVaapiH265LevelLimits * +gst_vaapi_utils_h265_get_level_limits_table (guint * out_length_ptr); + +/* Returns GstVaapiChromaType from H.265 chroma_format_idc value */ +G_GNUC_INTERNAL +GstVaapiChromaType +gst_vaapi_utils_h265_get_chroma_type (guint chroma_format_idc); + +/* Returns H.265 chroma_format_idc value from GstVaapiChromaType */ +G_GNUC_INTERNAL +guint +gst_vaapi_utils_h265_get_chroma_format_idc (GstVaapiChromaType chroma_type); + +G_END_DECLS + +#endif /* GST_VAAPI_UTILS_H265_PRIV_H */