mirror of
https://gitlab.freedesktop.org/gstreamer/gstreamer.git
synced 2024-11-26 19:51:11 +00:00
292 lines
8.5 KiB
C
292 lines
8.5 KiB
C
/*
|
|
* gstvaapiutils_mpeg2.c - MPEG-2 related utilities
|
|
*
|
|
* Copyright (C) 2011-2014 Intel Corporation
|
|
* Author: Gwenole Beauchesne <gwenole.beauchesne@intel.com>
|
|
*
|
|
* 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 <gst/codecparsers/gstmpegvideoparser.h>
|
|
#include "gstvaapicompat.h"
|
|
#include "gstvaapiutils_mpeg2_priv.h"
|
|
|
|
#define DEBUG 1
|
|
#include "gstvaapidebug.h"
|
|
|
|
struct map
|
|
{
|
|
guint value;
|
|
const gchar *name;
|
|
};
|
|
|
|
/* Profile string map */
|
|
static const struct map gst_vaapi_mpeg2_profile_map[] = {
|
|
/* *INDENT-OFF* */
|
|
{ GST_VAAPI_PROFILE_MPEG2_SIMPLE, "simple" },
|
|
{ GST_VAAPI_PROFILE_MPEG2_MAIN, "main" },
|
|
{ GST_VAAPI_PROFILE_MPEG2_HIGH, "high" },
|
|
{ 0, NULL }
|
|
/* *INDENT-ON* */
|
|
};
|
|
|
|
/* Level string map */
|
|
static const struct map gst_vaapi_mpeg2_level_map[] = {
|
|
/* *INDENT-OFF* */
|
|
{ GST_VAAPI_LEVEL_MPEG2_LOW, "low" },
|
|
{ GST_VAAPI_LEVEL_MPEG2_MAIN, "main" },
|
|
{ GST_VAAPI_LEVEL_MPEG2_HIGH_1440, "high-1440" },
|
|
{ GST_VAAPI_LEVEL_MPEG2_HIGH, "high" },
|
|
{ GST_VAAPI_LEVEL_MPEG2_HIGHP, "highP" },
|
|
{ 0, NULL }
|
|
/* *INDENT-ON* */
|
|
};
|
|
|
|
/* Table 8-10 to 8-13 (up to Main profile only) */
|
|
/* *INDENT-OFF* */
|
|
static const GstVaapiMPEG2LevelLimits gst_vaapi_mpeg2_level_limits[] = {
|
|
/* level h_size v_size fps samples kbps vbv_size */
|
|
{ GST_VAAPI_LEVEL_MPEG2_LOW,
|
|
0x0a, 352, 288, 30, 3041280, 4000, 475136 },
|
|
{ GST_VAAPI_LEVEL_MPEG2_MAIN,
|
|
0x08, 720, 576, 30, 1036800, 15000, 1835008 },
|
|
{ GST_VAAPI_LEVEL_MPEG2_HIGH_1440,
|
|
0x06, 1440, 1152, 60, 47001600, 60000, 7340032 },
|
|
{ GST_VAAPI_LEVEL_MPEG2_HIGH,
|
|
0x04, 1920, 1152, 60, 62668800, 80000, 9781248 },
|
|
/* Amendment 3: New level for 1080@50p/60p */
|
|
{ GST_VAAPI_LEVEL_MPEG2_HIGHP,
|
|
0x02, 1920, 1152, 60, 125337600, 80000, 9781248 },
|
|
{ 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_mpeg2_get_profile_score (GstVaapiProfile profile)
|
|
{
|
|
const struct map *const m =
|
|
map_lookup_value (gst_vaapi_mpeg2_profile_map, profile);
|
|
|
|
return m ? 1 + (m - gst_vaapi_mpeg2_profile_map) : 0;
|
|
}
|
|
|
|
/** Returns GstVaapiProfile from MPEG-2 profile_idc value */
|
|
GstVaapiProfile
|
|
gst_vaapi_utils_mpeg2_get_profile (guint8 profile_idc)
|
|
{
|
|
GstVaapiProfile profile;
|
|
|
|
switch (profile_idc) {
|
|
case GST_MPEG_VIDEO_PROFILE_SIMPLE:
|
|
profile = GST_VAAPI_PROFILE_MPEG2_SIMPLE;
|
|
break;
|
|
case GST_MPEG_VIDEO_PROFILE_MAIN:
|
|
profile = GST_VAAPI_PROFILE_MPEG2_MAIN;
|
|
break;
|
|
case GST_MPEG_VIDEO_PROFILE_HIGH:
|
|
profile = GST_VAAPI_PROFILE_MPEG2_HIGH;
|
|
break;
|
|
default:
|
|
GST_DEBUG ("unsupported profile_idc value");
|
|
profile = GST_VAAPI_PROFILE_UNKNOWN;
|
|
break;
|
|
}
|
|
return profile;
|
|
}
|
|
|
|
/** Returns MPEG-2 profile_idc value from GstVaapiProfile */
|
|
guint8
|
|
gst_vaapi_utils_mpeg2_get_profile_idc (GstVaapiProfile profile)
|
|
{
|
|
guint8 profile_idc;
|
|
|
|
switch (profile) {
|
|
case GST_VAAPI_PROFILE_MPEG2_SIMPLE:
|
|
profile_idc = GST_MPEG_VIDEO_PROFILE_SIMPLE;
|
|
break;
|
|
case GST_VAAPI_PROFILE_MPEG2_MAIN:
|
|
profile_idc = GST_MPEG_VIDEO_PROFILE_MAIN;
|
|
break;
|
|
case GST_VAAPI_PROFILE_MPEG2_HIGH:
|
|
profile_idc = GST_MPEG_VIDEO_PROFILE_HIGH;
|
|
break;
|
|
default:
|
|
GST_DEBUG ("unsupported GstVaapiProfile value");
|
|
profile_idc = 0;
|
|
break;
|
|
}
|
|
return profile_idc;
|
|
}
|
|
|
|
/** Returns GstVaapiProfile from a string representation */
|
|
GstVaapiProfile
|
|
gst_vaapi_utils_mpeg2_get_profile_from_string (const gchar * str)
|
|
{
|
|
const struct map *const m =
|
|
map_lookup_name (gst_vaapi_mpeg2_profile_map, str);
|
|
|
|
return m ? (GstVaapiProfile) m->value : GST_VAAPI_PROFILE_UNKNOWN;
|
|
}
|
|
|
|
/** Returns a string representation for the supplied MPEG-2 profile */
|
|
const gchar *
|
|
gst_vaapi_utils_mpeg2_get_profile_string (GstVaapiProfile profile)
|
|
{
|
|
const struct map *const m =
|
|
map_lookup_value (gst_vaapi_mpeg2_profile_map, profile);
|
|
|
|
return m ? m->name : NULL;
|
|
}
|
|
|
|
/** Returns GstVaapiLevelMPEG2 from MPEG-2 level_idc value */
|
|
GstVaapiLevelMPEG2
|
|
gst_vaapi_utils_mpeg2_get_level (guint8 level_idc)
|
|
{
|
|
const GstVaapiMPEG2LevelLimits *llp;
|
|
|
|
for (llp = gst_vaapi_mpeg2_level_limits; llp->level != 0; llp++) {
|
|
if (llp->level_idc == level_idc)
|
|
return llp->level;
|
|
}
|
|
GST_DEBUG ("unsupported level_idc value");
|
|
return (GstVaapiLevelMPEG2) 0;
|
|
}
|
|
|
|
/** Returns MPEG-2 level_idc value from GstVaapiLevelMPEG2 */
|
|
guint8
|
|
gst_vaapi_utils_mpeg2_get_level_idc (GstVaapiLevelMPEG2 level)
|
|
{
|
|
const GstVaapiMPEG2LevelLimits *const llp =
|
|
gst_vaapi_utils_mpeg2_get_level_limits (level);
|
|
|
|
return llp ? llp->level_idc : 0;
|
|
}
|
|
|
|
/** Returns GstVaapiLevelMPEG2 from a string representation */
|
|
GstVaapiLevelMPEG2
|
|
gst_vaapi_utils_mpeg2_get_level_from_string (const gchar * str)
|
|
{
|
|
const struct map *const m = map_lookup_name (gst_vaapi_mpeg2_level_map, str);
|
|
|
|
return (GstVaapiLevelMPEG2) (m ? m->value : 0);
|
|
}
|
|
|
|
/** Returns a string representation for the supplied MPEG-2 level */
|
|
const gchar *
|
|
gst_vaapi_utils_mpeg2_get_level_string (GstVaapiLevelMPEG2 level)
|
|
{
|
|
if (level < GST_VAAPI_LEVEL_MPEG2_LOW || level > GST_VAAPI_LEVEL_MPEG2_HIGHP)
|
|
return NULL;
|
|
return gst_vaapi_mpeg2_level_map[level - GST_VAAPI_LEVEL_MPEG2_LOW].name;
|
|
}
|
|
|
|
/** Returns level limits as specified in Tables 8-10 to 8-13 of the
|
|
MPEG-2 standard */
|
|
const GstVaapiMPEG2LevelLimits *
|
|
gst_vaapi_utils_mpeg2_get_level_limits (GstVaapiLevelMPEG2 level)
|
|
{
|
|
if (level < GST_VAAPI_LEVEL_MPEG2_LOW || level > GST_VAAPI_LEVEL_MPEG2_HIGHP)
|
|
return NULL;
|
|
return &gst_vaapi_mpeg2_level_limits[level - GST_VAAPI_LEVEL_MPEG2_LOW];
|
|
}
|
|
|
|
/** Returns Tables 8-10 to 8-13 from the specification (up to High profile) */
|
|
const GstVaapiMPEG2LevelLimits *
|
|
gst_vaapi_utils_mpeg2_get_level_limits_table (guint * out_length_ptr)
|
|
{
|
|
if (out_length_ptr)
|
|
*out_length_ptr = G_N_ELEMENTS (gst_vaapi_mpeg2_level_limits) - 1;
|
|
return gst_vaapi_mpeg2_level_limits;
|
|
}
|
|
|
|
/** Returns GstVaapiChromaType from MPEG-2 chroma_format_idc value */
|
|
GstVaapiChromaType
|
|
gst_vaapi_utils_mpeg2_get_chroma_type (guint chroma_format_idc)
|
|
{
|
|
GstVaapiChromaType chroma_type;
|
|
|
|
switch (chroma_format_idc) {
|
|
case GST_MPEG_VIDEO_CHROMA_420:
|
|
chroma_type = GST_VAAPI_CHROMA_TYPE_YUV420;
|
|
break;
|
|
case GST_MPEG_VIDEO_CHROMA_422:
|
|
chroma_type = GST_VAAPI_CHROMA_TYPE_YUV422;
|
|
break;
|
|
case GST_MPEG_VIDEO_CHROMA_444:
|
|
chroma_type = GST_VAAPI_CHROMA_TYPE_YUV444;
|
|
break;
|
|
default:
|
|
GST_DEBUG ("unsupported chroma_format_idc value");
|
|
chroma_type = (GstVaapiChromaType) 0;
|
|
break;
|
|
}
|
|
return chroma_type;
|
|
}
|
|
|
|
/** Returns MPEG-2 chroma_format_idc value from GstVaapiChromaType */
|
|
guint
|
|
gst_vaapi_utils_mpeg2_get_chroma_format_idc (GstVaapiChromaType chroma_type)
|
|
{
|
|
guint chroma_format_idc;
|
|
|
|
switch (chroma_type) {
|
|
case GST_VAAPI_CHROMA_TYPE_YUV420:
|
|
chroma_format_idc = GST_MPEG_VIDEO_CHROMA_420;
|
|
break;
|
|
case GST_VAAPI_CHROMA_TYPE_YUV422:
|
|
chroma_format_idc = GST_MPEG_VIDEO_CHROMA_422;
|
|
break;
|
|
case GST_VAAPI_CHROMA_TYPE_YUV444:
|
|
chroma_format_idc = GST_MPEG_VIDEO_CHROMA_444;
|
|
break;
|
|
default:
|
|
GST_DEBUG ("unsupported GstVaapiChromaType value");
|
|
chroma_format_idc = 1;
|
|
break;
|
|
}
|
|
return chroma_format_idc;
|
|
}
|