static GstStructure *gst_avdtp_sink_parse_mpeg_caps(
GstAvdtpSink *self, mpeg_capabilities_t *mpeg)
{
GstStructure *structure;
GValue *value;
GValue *list;
gboolean valid_layer = FALSE;
gboolean mono, stereo;
if (!mpeg)
return NULL;
GST_LOG_OBJECT(self, "parsing mpeg caps");
structure = gst_structure_empty_new("audio/mpeg");
value = g_new0(GValue, 1);
g_value_init(value, G_TYPE_INT);
list = g_value_init(g_new0(GValue, 1), GST_TYPE_LIST);
g_value_set_int(value, 1);
gst_value_list_prepend_value(list, value);
g_value_set_int(value, 2);
gst_value_list_prepend_value(list, value);
gst_structure_set_value(structure, "mpegversion", list);
g_free(list);
/* layer */
GST_LOG_OBJECT(self, "setting mpeg layer");
list = g_value_init(g_new0(GValue, 1), GST_TYPE_LIST);
if (mpeg->layer & BT_MPEG_LAYER_1) {
g_value_set_int(value, 1);
gst_value_list_prepend_value(list, value);
valid_layer = TRUE;
}
if (mpeg->layer & BT_MPEG_LAYER_2) {
g_value_set_int(value, 2);
gst_value_list_prepend_value(list, value);
valid_layer = TRUE;
}
if (mpeg->layer & BT_MPEG_LAYER_3) {
g_value_set_int(value, 3);
gst_value_list_prepend_value(list, value);
valid_layer = TRUE;
}
if (list) {
gst_structure_set_value(structure, "layer", list);
g_free(list);
list = NULL;
}
if (!valid_layer) {
gst_structure_free(structure);
g_free(value);
return NULL;
}
/* rate */
GST_LOG_OBJECT(self, "setting mpeg rate");
list = g_value_init(g_new0(GValue, 1), GST_TYPE_LIST);
if (mpeg->frequency & BT_MPEG_SAMPLING_FREQ_48000) {
g_value_set_int(value, 48000);
gst_value_list_prepend_value(list, value);
}
if (mpeg->frequency & BT_MPEG_SAMPLING_FREQ_44100) {
g_value_set_int(value, 44100);
gst_value_list_prepend_value(list, value);
}
if (mpeg->frequency & BT_MPEG_SAMPLING_FREQ_32000) {
g_value_set_int(value, 32000);
gst_value_list_prepend_value(list, value);
}
if (mpeg->frequency & BT_MPEG_SAMPLING_FREQ_24000) {
g_value_set_int(value, 24000);
gst_value_list_prepend_value(list, value);
}
if (mpeg->frequency & BT_MPEG_SAMPLING_FREQ_22050) {
g_value_set_int(value, 22050);
gst_value_list_prepend_value(list, value);
}
if (mpeg->frequency & BT_MPEG_SAMPLING_FREQ_16000) {
g_value_set_int(value, 16000);
gst_value_list_prepend_value(list, value);
}
g_value_unset(value);
if (list) {
gst_structure_set_value(structure, "rate", list);
g_free(list);
list = NULL;
}
/* channels */
GST_LOG_OBJECT(self, "setting mpeg channels");
mono = FALSE;
stereo = FALSE;
if (mpeg->channel_mode & BT_A2DP_CHANNEL_MODE_MONO)
mono = TRUE;
if ((mpeg->channel_mode & BT_A2DP_CHANNEL_MODE_STEREO) ||
(mpeg->channel_mode &
BT_A2DP_CHANNEL_MODE_DUAL_CHANNEL) ||
(mpeg->channel_mode &
BT_A2DP_CHANNEL_MODE_JOINT_STEREO))
stereo = TRUE;
if (mono && stereo) {
g_value_init(value, GST_TYPE_INT_RANGE);
gst_value_set_int_range(value, 1, 2);
} else {
g_value_init(value, G_TYPE_INT);
if (mono)
g_value_set_int(value, 1);
else if (stereo)
g_value_set_int(value, 2);
else {
GST_ERROR_OBJECT(self,
"Unexpected number of channels");
g_value_set_int(value, 0);
}
}
gst_structure_set_value(structure, "channels", value);
g_free(value);
return structure;
}
static GstCaps *
gst_rtp_h264_pay_getcaps (GstRTPBasePayload * payload, GstPad * pad,
GstCaps * filter)
{
GstCaps *template_caps;
GstCaps *allowed_caps;
GstCaps *caps, *icaps;
gboolean append_unrestricted;
guint i;
allowed_caps =
gst_pad_peer_query_caps (GST_RTP_BASE_PAYLOAD_SRCPAD (payload), NULL);
if (allowed_caps == NULL)
return NULL;
template_caps =
gst_static_pad_template_get_caps (&gst_rtp_h264_pay_sink_template);
if (gst_caps_is_any (allowed_caps)) {
caps = gst_caps_ref (template_caps);
goto done;
}
if (gst_caps_is_empty (allowed_caps)) {
caps = gst_caps_ref (allowed_caps);
goto done;
}
caps = gst_caps_new_empty ();
append_unrestricted = FALSE;
for (i = 0; i < gst_caps_get_size (allowed_caps); i++) {
GstStructure *s = gst_caps_get_structure (allowed_caps, i);
GstStructure *new_s = gst_structure_new_empty ("video/x-h264");
const gchar *profile_level_id;
profile_level_id = gst_structure_get_string (s, "profile-level-id");
if (profile_level_id && strlen (profile_level_id) == 6) {
const gchar *profile;
const gchar *level;
long int spsint;
guint8 sps[3];
spsint = strtol (profile_level_id, NULL, 16);
sps[0] = spsint >> 16;
sps[1] = spsint >> 8;
sps[2] = spsint;
profile = gst_codec_utils_h264_get_profile (sps, 3);
level = gst_codec_utils_h264_get_level (sps, 3);
if (profile && level) {
GST_LOG_OBJECT (payload, "In caps, have profile %s and level %s",
profile, level);
if (!strcmp (profile, "constrained-baseline"))
gst_structure_set (new_s, "profile", G_TYPE_STRING, profile, NULL);
else {
GValue val = { 0, };
GValue profiles = { 0, };
g_value_init (&profiles, GST_TYPE_LIST);
g_value_init (&val, G_TYPE_STRING);
g_value_set_static_string (&val, profile);
gst_value_list_append_value (&profiles, &val);
g_value_set_static_string (&val, "constrained-baseline");
gst_value_list_append_value (&profiles, &val);
gst_structure_take_value (new_s, "profile", &profiles);
}
if (!strcmp (level, "1"))
gst_structure_set (new_s, "level", G_TYPE_STRING, level, NULL);
else {
GValue levels = { 0, };
GValue val = { 0, };
int j;
g_value_init (&levels, GST_TYPE_LIST);
g_value_init (&val, G_TYPE_STRING);
for (j = 0; j < G_N_ELEMENTS (all_levels); j++) {
g_value_set_static_string (&val, all_levels[j]);
gst_value_list_prepend_value (&levels, &val);
if (!strcmp (level, all_levels[j]))
break;
}
gst_structure_take_value (new_s, "level", &levels);
}
} else {
/* Invalid profile-level-id means baseline */
gst_structure_set (new_s,
"profile", G_TYPE_STRING, "constrained-baseline", NULL);
}
} else {
/* No profile-level-id means baseline or unrestricted */
gst_structure_set (new_s,
"profile", G_TYPE_STRING, "constrained-baseline", NULL);
append_unrestricted = TRUE;
}
caps = gst_caps_merge_structure (caps, new_s);
}
static GstStructure *gst_avdtp_sink_parse_sbc_caps(
GstAvdtpSink *self, sbc_capabilities_t *sbc)
{
GstStructure *structure;
GValue *value;
GValue *list;
gboolean mono, stereo;
structure = gst_structure_empty_new("audio/x-sbc");
value = g_value_init(g_new0(GValue, 1), G_TYPE_STRING);
/* mode */
list = g_value_init(g_new0(GValue, 1), GST_TYPE_LIST);
if (sbc->channel_mode & BT_A2DP_CHANNEL_MODE_MONO) {
g_value_set_static_string(value, "mono");
gst_value_list_prepend_value(list, value);
}
if (sbc->channel_mode & BT_A2DP_CHANNEL_MODE_STEREO) {
g_value_set_static_string(value, "stereo");
gst_value_list_prepend_value(list, value);
}
if (sbc->channel_mode & BT_A2DP_CHANNEL_MODE_DUAL_CHANNEL) {
g_value_set_static_string(value, "dual");
gst_value_list_prepend_value(list, value);
}
if (sbc->channel_mode & BT_A2DP_CHANNEL_MODE_JOINT_STEREO) {
g_value_set_static_string(value, "joint");
gst_value_list_prepend_value(list, value);
}
g_value_unset(value);
if (list) {
gst_structure_set_value(structure, "mode", list);
g_free(list);
list = NULL;
}
/* subbands */
list = g_value_init(g_new0(GValue, 1), GST_TYPE_LIST);
value = g_value_init(value, G_TYPE_INT);
if (sbc->subbands & BT_A2DP_SUBBANDS_4) {
g_value_set_int(value, 4);
gst_value_list_prepend_value(list, value);
}
if (sbc->subbands & BT_A2DP_SUBBANDS_8) {
g_value_set_int(value, 8);
gst_value_list_prepend_value(list, value);
}
g_value_unset(value);
if (list) {
gst_structure_set_value(structure, "subbands", list);
g_free(list);
list = NULL;
}
/* blocks */
value = g_value_init(value, G_TYPE_INT);
list = g_value_init(g_new0(GValue, 1), GST_TYPE_LIST);
if (sbc->block_length & BT_A2DP_BLOCK_LENGTH_16) {
g_value_set_int(value, 16);
gst_value_list_prepend_value(list, value);
}
if (sbc->block_length & BT_A2DP_BLOCK_LENGTH_12) {
g_value_set_int(value, 12);
gst_value_list_prepend_value(list, value);
}
if (sbc->block_length & BT_A2DP_BLOCK_LENGTH_8) {
g_value_set_int(value, 8);
gst_value_list_prepend_value(list, value);
}
if (sbc->block_length & BT_A2DP_BLOCK_LENGTH_4) {
g_value_set_int(value, 4);
gst_value_list_prepend_value(list, value);
}
g_value_unset(value);
if (list) {
gst_structure_set_value(structure, "blocks", list);
g_free(list);
list = NULL;
}
/* allocation */
g_value_init(value, G_TYPE_STRING);
list = g_value_init(g_new0(GValue,1), GST_TYPE_LIST);
if (sbc->allocation_method & BT_A2DP_ALLOCATION_LOUDNESS) {
g_value_set_static_string(value, "loudness");
gst_value_list_prepend_value(list, value);
}
if (sbc->allocation_method & BT_A2DP_ALLOCATION_SNR) {
g_value_set_static_string(value, "snr");
gst_value_list_prepend_value(list, value);
}
g_value_unset(value);
if (list) {
gst_structure_set_value(structure, "allocation", list);
g_free(list);
list = NULL;
}
/* rate */
g_value_init(value, G_TYPE_INT);
list = g_value_init(g_new0(GValue, 1), GST_TYPE_LIST);
if (sbc->frequency & BT_SBC_SAMPLING_FREQ_48000) {
g_value_set_int(value, 48000);
gst_value_list_prepend_value(list, value);
}
if (sbc->frequency & BT_SBC_SAMPLING_FREQ_44100) {
g_value_set_int(value, 44100);
gst_value_list_prepend_value(list, value);
}
if (sbc->frequency & BT_SBC_SAMPLING_FREQ_32000) {
g_value_set_int(value, 32000);
gst_value_list_prepend_value(list, value);
}
if (sbc->frequency & BT_SBC_SAMPLING_FREQ_16000) {
g_value_set_int(value, 16000);
gst_value_list_prepend_value(list, value);
}
g_value_unset(value);
if (list) {
gst_structure_set_value(structure, "rate", list);
g_free(list);
list = NULL;
}
/* bitpool */
value = g_value_init(value, GST_TYPE_INT_RANGE);
gst_value_set_int_range(value,
MIN(sbc->min_bitpool, TEMPLATE_MAX_BITPOOL),
MIN(sbc->max_bitpool, TEMPLATE_MAX_BITPOOL));
gst_structure_set_value(structure, "bitpool", value);
g_value_unset(value);
/* channels */
mono = FALSE;
stereo = FALSE;
if (sbc->channel_mode & BT_A2DP_CHANNEL_MODE_MONO)
mono = TRUE;
if ((sbc->channel_mode & BT_A2DP_CHANNEL_MODE_STEREO) ||
(sbc->channel_mode &
BT_A2DP_CHANNEL_MODE_DUAL_CHANNEL) ||
(sbc->channel_mode &
BT_A2DP_CHANNEL_MODE_JOINT_STEREO))
stereo = TRUE;
if (mono && stereo) {
g_value_init(value, GST_TYPE_INT_RANGE);
gst_value_set_int_range(value, 1, 2);
} else {
g_value_init(value, G_TYPE_INT);
if (mono)
g_value_set_int(value, 1);
else if (stereo)
g_value_set_int(value, 2);
else {
GST_ERROR_OBJECT(self,
"Unexpected number of channels");
g_value_set_int(value, 0);
}
}
gst_structure_set_value(structure, "channels", value);
g_free(value);
return structure;
}
static GstCaps *
gst_tinyalsa_sink_getcaps (GstBaseSink * bsink, GstCaps * filter)
{
GstTinyalsaSink *sink = GST_TINYALSA_SINK (bsink);
GstCaps *caps = NULL;
GValue formats = { 0, };
GValue format = { 0, };
struct pcm_params *params = NULL;
struct pcm_mask *mask;
int rate_min, rate_max, channels_min, channels_max;
guint16 m;
GST_DEBUG_OBJECT (sink, "Querying caps");
GST_OBJECT_LOCK (sink);
if (sink->cached_caps) {
GST_DEBUG_OBJECT (sink, "Returning cached caps");
caps = gst_caps_ref (sink->cached_caps);
goto done;
}
if (sink->pcm) {
/* We can't query the device while it's open, so return current caps */
caps = gst_pad_get_current_caps (GST_BASE_SINK_PAD (bsink));
goto done;
}
params = pcm_params_get (sink->card, sink->device, PCM_OUT);
if (!params) {
GST_ERROR_OBJECT (sink, "Could not get PCM params");
goto done;
}
mask = pcm_params_get_mask (params, PCM_PARAM_FORMAT);
m = (mask->bits[1] << 8) | mask->bits[0];
if (!(m & SNDRV_PCM_FORMAT_ANY)) {
GST_ERROR_OBJECT (sink, "Could not find any supported format");
goto done;
}
caps = gst_caps_new_empty_simple ("audio/x-raw");
g_value_init (&formats, GST_TYPE_LIST);
g_value_init (&format, G_TYPE_STRING);
if (m & (1 << SNDRV_PCM_FORMAT_S8)) {
g_value_set_static_string (&format, "S8");
gst_value_list_prepend_value (&formats, &format);
}
if (m & (1 << SNDRV_PCM_FORMAT_S16_LE)) {
g_value_set_static_string (&format, "S16LE");
gst_value_list_prepend_value (&formats, &format);
}
if (m & (1 << SNDRV_PCM_FORMAT_S24_LE)) {
g_value_set_static_string (&format, "S24_32LE");
gst_value_list_prepend_value (&formats, &format);
}
if (m & (1 << SNDRV_PCM_FORMAT_S32_LE)) {
g_value_set_static_string (&format, "S32LE");
gst_value_list_prepend_value (&formats, &format);
}
gst_caps_set_value (caps, "format", &formats);
g_value_unset (&format);
g_value_unset (&formats);
/* This is a bit of a lie, since the device likely only supports some
* standard rates in this range. We should probably filter the range to
* those, standard audio rates but even that isn't guaranteed to be accurate.
*/
rate_min = pcm_params_get_min (params, PCM_PARAM_RATE);
rate_max = pcm_params_get_max (params, PCM_PARAM_RATE);
if (rate_min == rate_max)
gst_caps_set_simple (caps, "rate", G_TYPE_INT, rate_min, NULL);
else
gst_caps_set_simple (caps, "rate", GST_TYPE_INT_RANGE, rate_min, rate_max,
NULL);
channels_min = pcm_params_get_min (params, PCM_PARAM_CHANNELS);
channels_max = pcm_params_get_max (params, PCM_PARAM_CHANNELS);
if (channels_min == channels_max)
gst_caps_set_simple (caps, "channels", G_TYPE_INT, channels_min, NULL);
else
gst_caps_set_simple (caps, "channels", GST_TYPE_INT_RANGE, channels_min,
channels_max, NULL);
gst_caps_replace (&sink->cached_caps, caps);
done:
GST_OBJECT_UNLOCK (sink);
GST_DEBUG_OBJECT (sink, "Got caps %" GST_PTR_FORMAT, caps);
if (caps && filter) {
GstCaps *intersection =
gst_caps_intersect_full (filter, caps, GST_CAPS_INTERSECT_FIRST);
gst_caps_unref (caps);
caps = intersection;
}
if (params)
pcm_params_free (params);
return caps;
}
