LCOV - code coverage report
Current view: top level - src/libvalent/mixer - valent-mixer-stream.c (source / functions) Coverage Total Hit
Test: Code Coverage Lines: 96.6 % 117 113
Test Date: 2024-05-12 19:03:18 Functions: 100.0 % 15 15
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 63.9 % 36 23

             Branch data     Line data    Source code
       1                 :             : // SPDX-License-Identifier: GPL-3.0-or-later
       2                 :             : // SPDX-FileCopyrightText: Andy Holmes <andrew.g.r.holmes@gmail.com>
       3                 :             : 
       4                 :             : #define G_LOG_DOMAIN "valent-mixer-stream"
       5                 :             : 
       6                 :             : #include "config.h"
       7                 :             : 
       8                 :             : #include <libvalent-core.h>
       9                 :             : 
      10                 :             : #include "valent-mixer-enums.h"
      11                 :             : #include "valent-mixer-stream.h"
      12                 :             : 
      13                 :             : 
      14                 :             : /**
      15                 :             :  * ValentMixerStream:
      16                 :             :  *
      17                 :             :  * A base class for mixer streams.
      18                 :             :  *
      19                 :             :  * `ValentMixerStream` is a base class for mixer streams, intended for use by
      20                 :             :  * implementations of [class@Valent.MixerAdapter].
      21                 :             :  *
      22                 :             :  * Since: 1.0
      23                 :             :  */
      24                 :             : 
      25                 :             : typedef struct
      26                 :             : {
      27                 :             :   char                 *name;
      28                 :             :   char                 *description;
      29                 :             :   ValentMixerDirection  direction;
      30                 :             :   unsigned int          level;
      31                 :             :   unsigned int          muted : 1;
      32                 :             : } ValentMixerStreamPrivate;
      33                 :             : 
      34   [ +  +  +  - ]:        1071 : G_DEFINE_TYPE_WITH_PRIVATE (ValentMixerStream, valent_mixer_stream, G_TYPE_OBJECT)
      35                 :             : 
      36                 :             : enum {
      37                 :             :   PROP_0,
      38                 :             :   PROP_DESCRIPTION,
      39                 :             :   PROP_DIRECTION,
      40                 :             :   PROP_LEVEL,
      41                 :             :   PROP_MUTED,
      42                 :             :   PROP_NAME,
      43                 :             :   N_PROPERTIES
      44                 :             : };
      45                 :             : 
      46                 :             : static GParamSpec *properties[N_PROPERTIES] = { NULL, };
      47                 :             : 
      48                 :             : /**
      49                 :             :  * ValentMixerStreamClass:
      50                 :             :  * @get_name: the virtual function pointer for valent_mixer_stream_get_name()
      51                 :             :  * @get_description: the virtual function pointer for valent_mixer_stream_get_description()
      52                 :             :  * @get_level: the virtual function pointer for valent_mixer_stream_get_level()
      53                 :             :  * @set_level: the virtual function pointer for valent_mixer_stream_set_level()
      54                 :             :  * @get_muted: the virtual function pointer for valent_mixer_stream_get_muted()
      55                 :             :  * @set_muted: the virtual function pointer for valent_mixer_stream_set_muted()
      56                 :             :  *
      57                 :             :  * The virtual function table for `ValentMixerStream`.
      58                 :             :  */
      59                 :             : 
      60                 :             : /* LCOV_EXCL_START */
      61                 :             : static const char *
      62                 :             : valent_mixer_stream_real_get_name (ValentMixerStream *stream)
      63                 :             : {
      64                 :             :   ValentMixerStreamPrivate *priv = valent_mixer_stream_get_instance_private (stream);
      65                 :             : 
      66                 :             :   if (priv->name == NULL)
      67                 :             :     priv->name = g_uuid_string_random ();
      68                 :             : 
      69                 :             :   return priv->name;
      70                 :             : }
      71                 :             : 
      72                 :             : static const char *
      73                 :             : valent_mixer_stream_real_get_description (ValentMixerStream *stream)
      74                 :             : {
      75                 :             :   ValentMixerStreamPrivate *priv = valent_mixer_stream_get_instance_private (stream);
      76                 :             : 
      77                 :             :   if (priv->description == NULL)
      78                 :             :     return "Unnamed Stream";
      79                 :             : 
      80                 :             :   return priv->description;
      81                 :             : }
      82                 :             : 
      83                 :             : ValentMixerDirection
      84                 :             : valent_mixer_stream_real_get_direction (ValentMixerStream *stream)
      85                 :             : {
      86                 :             :   ValentMixerStreamPrivate *priv = valent_mixer_stream_get_instance_private (stream);
      87                 :             : 
      88                 :             :   return priv->direction;
      89                 :             : }
      90                 :             : 
      91                 :             : static unsigned int
      92                 :             : valent_mixer_stream_real_get_level (ValentMixerStream *stream)
      93                 :             : {
      94                 :             :   ValentMixerStreamPrivate *priv = valent_mixer_stream_get_instance_private (stream);
      95                 :             : 
      96                 :             :   return priv->level;
      97                 :             : }
      98                 :             : 
      99                 :             : static void
     100                 :             : valent_mixer_stream_real_set_level (ValentMixerStream *stream,
     101                 :             :                                     unsigned int       level)
     102                 :             : {
     103                 :             :   ValentMixerStreamPrivate *priv = valent_mixer_stream_get_instance_private (stream);
     104                 :             : 
     105                 :             :   if (priv->level == level)
     106                 :             :     return;
     107                 :             : 
     108                 :             :   priv->level = level;
     109                 :             :   g_object_notify_by_pspec (G_OBJECT (stream), properties [PROP_LEVEL]);
     110                 :             : }
     111                 :             : 
     112                 :             : static gboolean
     113                 :             : valent_mixer_stream_real_get_muted (ValentMixerStream *stream)
     114                 :             : {
     115                 :             :   ValentMixerStreamPrivate *priv = valent_mixer_stream_get_instance_private (stream);
     116                 :             : 
     117                 :             :   return priv->muted;
     118                 :             : }
     119                 :             : 
     120                 :             : static void
     121                 :             : valent_mixer_stream_real_set_muted (ValentMixerStream *stream,
     122                 :             :                                     gboolean           mute)
     123                 :             : {
     124                 :             :   ValentMixerStreamPrivate *priv = valent_mixer_stream_get_instance_private (stream);
     125                 :             : 
     126                 :             :   if (priv->muted == mute)
     127                 :             :     return;
     128                 :             : 
     129                 :             :   priv->muted = mute;
     130                 :             :   g_object_notify_by_pspec (G_OBJECT (stream), properties [PROP_MUTED]);
     131                 :             : }
     132                 :             : /* LCOV_EXCL_STOP */
     133                 :             : 
     134                 :             : /*
     135                 :             :  * GObject
     136                 :             :  */
     137                 :             : static void
     138                 :          32 : valent_mixer_stream_finalize (GObject *object)
     139                 :             : {
     140                 :          32 :   ValentMixerStream *self = VALENT_MIXER_STREAM (object);
     141                 :          32 :   ValentMixerStreamPrivate *priv = valent_mixer_stream_get_instance_private (self);
     142                 :             : 
     143         [ +  - ]:          32 :   g_clear_pointer (&priv->name, g_free);
     144         [ +  - ]:          32 :   g_clear_pointer (&priv->description, g_free);
     145                 :             : 
     146                 :          32 :   G_OBJECT_CLASS (valent_mixer_stream_parent_class)->finalize (object);
     147                 :          32 : }
     148                 :             : 
     149                 :             : static void
     150                 :           5 : valent_mixer_stream_get_property (GObject    *object,
     151                 :             :                                   guint       prop_id,
     152                 :             :                                   GValue     *value,
     153                 :             :                                   GParamSpec *pspec)
     154                 :             : {
     155                 :           5 :   ValentMixerStream *self = VALENT_MIXER_STREAM (object);
     156                 :             : 
     157   [ +  +  +  +  :           5 :   switch (prop_id)
                   +  - ]
     158                 :             :     {
     159                 :           1 :     case PROP_DESCRIPTION:
     160                 :           1 :       g_value_set_string (value, valent_mixer_stream_get_description (self));
     161                 :           1 :       break;
     162                 :             : 
     163                 :           1 :     case PROP_DIRECTION:
     164                 :           1 :       g_value_set_enum (value, valent_mixer_stream_get_direction (self));
     165                 :           1 :       break;
     166                 :             : 
     167                 :           1 :     case PROP_LEVEL:
     168                 :           1 :       g_value_set_uint (value, valent_mixer_stream_get_level (self));
     169                 :           1 :       break;
     170                 :             : 
     171                 :           1 :     case PROP_MUTED:
     172                 :           1 :       g_value_set_boolean (value, valent_mixer_stream_get_muted (self));
     173                 :           1 :       break;
     174                 :             : 
     175                 :           1 :     case PROP_NAME:
     176                 :           1 :       g_value_set_string (value, valent_mixer_stream_get_name (self));
     177                 :           1 :       break;
     178                 :             : 
     179                 :           0 :     default:
     180                 :           0 :       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
     181                 :             :     }
     182                 :           5 : }
     183                 :             : 
     184                 :             : static void
     185                 :         132 : valent_mixer_stream_set_property (GObject      *object,
     186                 :             :                                   guint         prop_id,
     187                 :             :                                   const GValue *value,
     188                 :             :                                   GParamSpec   *pspec)
     189                 :             : {
     190                 :         132 :   ValentMixerStream *self = VALENT_MIXER_STREAM (object);
     191                 :         132 :   ValentMixerStreamPrivate *priv = valent_mixer_stream_get_instance_private (self);
     192                 :             : 
     193   [ +  +  +  +  :         132 :   switch (prop_id)
                   +  - ]
     194                 :             :     {
     195                 :          32 :     case PROP_DESCRIPTION:
     196                 :          32 :       priv->description = g_value_dup_string (value);
     197                 :          32 :       break;
     198                 :             : 
     199                 :          32 :     case PROP_DIRECTION:
     200                 :          32 :       priv->direction = g_value_get_enum (value);
     201                 :          32 :       break;
     202                 :             : 
     203                 :          27 :     case PROP_LEVEL:
     204                 :          27 :       valent_mixer_stream_set_level (self, g_value_get_uint (value));
     205                 :          27 :       break;
     206                 :             : 
     207                 :           9 :     case PROP_MUTED:
     208                 :           9 :       valent_mixer_stream_set_muted (self, g_value_get_boolean (value));
     209                 :           9 :       break;
     210                 :             : 
     211                 :          32 :     case PROP_NAME:
     212                 :          32 :       priv->name = g_value_dup_string (value);
     213                 :          32 :       break;
     214                 :             : 
     215                 :           0 :     default:
     216                 :           0 :       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
     217                 :             :     }
     218                 :         132 : }
     219                 :             : 
     220                 :             : static void
     221                 :           4 : valent_mixer_stream_class_init (ValentMixerStreamClass *klass)
     222                 :             : {
     223                 :           4 :   GObjectClass *object_class = G_OBJECT_CLASS (klass);
     224                 :           4 :   ValentMixerStreamClass *stream_class = VALENT_MIXER_STREAM_CLASS (klass);
     225                 :             : 
     226                 :           4 :   object_class->finalize = valent_mixer_stream_finalize;
     227                 :           4 :   object_class->get_property = valent_mixer_stream_get_property;
     228                 :           4 :   object_class->set_property = valent_mixer_stream_set_property;
     229                 :             : 
     230                 :           4 :   stream_class->get_name = valent_mixer_stream_real_get_name;
     231                 :           4 :   stream_class->get_description = valent_mixer_stream_real_get_description;
     232                 :           4 :   stream_class->get_direction = valent_mixer_stream_real_get_direction;
     233                 :           4 :   stream_class->get_level = valent_mixer_stream_real_get_level;
     234                 :           4 :   stream_class->set_level = valent_mixer_stream_real_set_level;
     235                 :           4 :   stream_class->get_muted = valent_mixer_stream_real_get_muted;
     236                 :           4 :   stream_class->set_muted = valent_mixer_stream_real_set_muted;
     237                 :             : 
     238                 :             :   /**
     239                 :             :    * ValentMixerStream:description: (getter get_description)
     240                 :             :    *
     241                 :             :    * The human-readable label of the stream.
     242                 :             :    *
     243                 :             :    * Implementation may emit [signal@GObject.Object::notify] for this property
     244                 :             :    * if it changes.
     245                 :             :    *
     246                 :             :    * Since: 1.0
     247                 :             :    */
     248                 :           8 :   properties [PROP_DESCRIPTION] =
     249                 :           4 :     g_param_spec_string ("description", NULL, NULL,
     250                 :             :                          NULL,
     251                 :             :                          (G_PARAM_READWRITE |
     252                 :             :                           G_PARAM_CONSTRUCT_ONLY |
     253                 :             :                           G_PARAM_EXPLICIT_NOTIFY |
     254                 :             :                           G_PARAM_STATIC_STRINGS));
     255                 :             : 
     256                 :             :   /**
     257                 :             :    * ValentMixerStream:direction: (getter get_direction)
     258                 :             :    *
     259                 :             :    * The port direction of the stream.
     260                 :             :    *
     261                 :             :    * Since: 1.0
     262                 :             :    */
     263                 :           8 :   properties [PROP_DIRECTION] =
     264                 :           4 :     g_param_spec_enum ("direction", NULL, NULL,
     265                 :             :                        VALENT_TYPE_MIXER_DIRECTION,
     266                 :             :                        VALENT_MIXER_INPUT,
     267                 :             :                        (G_PARAM_CONSTRUCT_ONLY |
     268                 :             :                         G_PARAM_READWRITE |
     269                 :             :                         G_PARAM_EXPLICIT_NOTIFY |
     270                 :             :                         G_PARAM_STATIC_STRINGS));
     271                 :             : 
     272                 :             :   /**
     273                 :             :    * ValentMixerStream:level: (getter get_level) (setter set_level)
     274                 :             :    *
     275                 :             :    * The input or output level of the stream.
     276                 :             :    *
     277                 :             :    * Since: 1.0
     278                 :             :    */
     279                 :           8 :   properties [PROP_LEVEL] =
     280                 :           4 :     g_param_spec_uint ("level", NULL, NULL,
     281                 :             :                        0, 100,
     282                 :             :                        0,
     283                 :             :                        (G_PARAM_READWRITE |
     284                 :             :                         G_PARAM_EXPLICIT_NOTIFY |
     285                 :             :                         G_PARAM_STATIC_STRINGS));
     286                 :             : 
     287                 :             :   /**
     288                 :             :    * ValentMixerStream:muted: (getter get_muted) (setter set_muted)
     289                 :             :    *
     290                 :             :    * Whether the stream is muted.
     291                 :             :    *
     292                 :             :    * Since: 1.0
     293                 :             :    */
     294                 :           8 :   properties [PROP_MUTED] =
     295                 :           4 :     g_param_spec_boolean ("muted", NULL, NULL,
     296                 :             :                           FALSE,
     297                 :             :                           (G_PARAM_READWRITE |
     298                 :             :                            G_PARAM_EXPLICIT_NOTIFY |
     299                 :             :                            G_PARAM_STATIC_STRINGS));
     300                 :             : 
     301                 :             :   /**
     302                 :             :    * ValentMixerStream:name: (getter get_name)
     303                 :             :    *
     304                 :             :    * The unique name of the stream.
     305                 :             :    *
     306                 :             :    * Since: 1.0
     307                 :             :    */
     308                 :           8 :   properties [PROP_NAME] =
     309                 :           4 :     g_param_spec_string ("name", NULL, NULL,
     310                 :             :                          NULL,
     311                 :             :                          (G_PARAM_READWRITE |
     312                 :             :                           G_PARAM_CONSTRUCT_ONLY |
     313                 :             :                           G_PARAM_EXPLICIT_NOTIFY |
     314                 :             :                           G_PARAM_STATIC_STRINGS));
     315                 :             : 
     316                 :           4 :   g_object_class_install_properties (object_class, N_PROPERTIES, properties);
     317                 :           4 : }
     318                 :             : 
     319                 :             : static void
     320                 :          32 : valent_mixer_stream_init (ValentMixerStream *stream)
     321                 :             : {
     322                 :          32 : }
     323                 :             : 
     324                 :             : /**
     325                 :             :  * valent_mixer_stream_get_name: (get-property name) (virtual get_name)
     326                 :             :  * @stream: a `ValentMixerStream`
     327                 :             :  *
     328                 :             :  * Get the unique name of @stream.
     329                 :             :  *
     330                 :             :  * Returns: (transfer none): a unique name
     331                 :             :  *
     332                 :             :  * Since: 1.0
     333                 :             :  */
     334                 :             : const char *
     335                 :           9 : valent_mixer_stream_get_name (ValentMixerStream *stream)
     336                 :             : {
     337                 :           9 :   const char *ret;
     338                 :             : 
     339                 :           9 :   VALENT_ENTRY;
     340                 :             : 
     341         [ +  - ]:           9 :   g_return_val_if_fail (VALENT_IS_MIXER_STREAM (stream), NULL);
     342                 :             : 
     343                 :           9 :   ret = VALENT_MIXER_STREAM_GET_CLASS (stream)->get_name (stream);
     344                 :             : 
     345                 :           9 :   VALENT_RETURN (ret);
     346                 :             : }
     347                 :             : 
     348                 :             : /**
     349                 :             :  * valent_mixer_stream_get_description: (get-property description) (virtual get_description)
     350                 :             :  * @stream: a `ValentMixerStream`
     351                 :             :  *
     352                 :             :  * Get the human-readable label of @stream.
     353                 :             :  *
     354                 :             :  * Returns: (transfer none): a stream description
     355                 :             :  *
     356                 :             :  * Since: 1.0
     357                 :             :  */
     358                 :             : const char *
     359                 :           9 : valent_mixer_stream_get_description (ValentMixerStream *stream)
     360                 :             : {
     361                 :           9 :   const char *ret;
     362                 :             : 
     363                 :           9 :   VALENT_ENTRY;
     364                 :             : 
     365         [ +  - ]:           9 :   g_return_val_if_fail (VALENT_IS_MIXER_STREAM (stream), NULL);
     366                 :             : 
     367                 :           9 :   ret = VALENT_MIXER_STREAM_GET_CLASS (stream)->get_description (stream);
     368                 :             : 
     369                 :           9 :   VALENT_RETURN (ret);
     370                 :             : }
     371                 :             : 
     372                 :             : /**
     373                 :             :  * valent_mixer_stream_get_direction: (get-property direction) (virtual get_direction)
     374                 :             :  * @stream: a `ValentMixerStream`
     375                 :             :  *
     376                 :             :  * Get the port direction of @stream.
     377                 :             :  *
     378                 :             :  * Returns: the `ValentMixerDirection` of @stream
     379                 :             :  *
     380                 :             :  * Since: 1.0
     381                 :             :  */
     382                 :             : ValentMixerDirection
     383                 :          41 : valent_mixer_stream_get_direction (ValentMixerStream *stream)
     384                 :             : {
     385                 :          41 :   ValentMixerStreamPrivate *priv = valent_mixer_stream_get_instance_private (stream);
     386                 :             : 
     387         [ +  - ]:          41 :   g_return_val_if_fail (VALENT_IS_MIXER_STREAM (stream), VALENT_MIXER_INPUT);
     388                 :             : 
     389                 :          41 :   return priv->direction;
     390                 :             : }
     391                 :             : 
     392                 :             : /**
     393                 :             :  * valent_mixer_stream_get_level: (get-property level) (virtual get_level)
     394                 :             :  * @stream: a `ValentMixerStream`
     395                 :             :  *
     396                 :             :  * Get the level of @stream (eg. speaker volume, microphone sensitivity).
     397                 :             :  *
     398                 :             :  * Implementations that override this method should also override
     399                 :             :  * [vfunc@Valent.MixerStream.set_level].
     400                 :             :  *
     401                 :             :  * Returns: a volume level between `0` and `100`
     402                 :             :  *
     403                 :             :  * Since: 1.0
     404                 :             :  */
     405                 :             : unsigned int
     406                 :          58 : valent_mixer_stream_get_level (ValentMixerStream *stream)
     407                 :             : {
     408                 :          58 :   unsigned int ret;
     409                 :             : 
     410                 :          58 :   VALENT_ENTRY;
     411                 :             : 
     412         [ +  - ]:          58 :   g_return_val_if_fail (VALENT_IS_MIXER_STREAM (stream), 0);
     413                 :             : 
     414                 :          58 :   ret = VALENT_MIXER_STREAM_GET_CLASS (stream)->get_level (stream);
     415                 :             : 
     416                 :          58 :   VALENT_RETURN (ret);
     417                 :             : }
     418                 :             : 
     419                 :             : /**
     420                 :             :  * valent_mixer_stream_set_level: (set-property level) (virtual set_level)
     421                 :             :  * @stream: a `ValentMixerStream`
     422                 :             :  * @level: a volume level between `0` and `100`
     423                 :             :  *
     424                 :             :  * Set the level of @stream (eg. speaker volume, microphone sensitivity).
     425                 :             :  *
     426                 :             :  * Implementations that override this method should also override
     427                 :             :  * [vfunc@Valent.MixerStream.get_level].
     428                 :             :  *
     429                 :             :  * Since: 1.0
     430                 :             :  */
     431                 :             : void
     432                 :          41 : valent_mixer_stream_set_level (ValentMixerStream *stream,
     433                 :             :                                unsigned int       level)
     434                 :             : {
     435                 :          41 :   VALENT_ENTRY;
     436                 :             : 
     437         [ +  - ]:          41 :   g_return_if_fail (VALENT_IS_MIXER_STREAM (stream));
     438         [ -  + ]:          41 :   g_return_if_fail (level <= 100);
     439                 :             : 
     440                 :          41 :   VALENT_MIXER_STREAM_GET_CLASS (stream)->set_level (stream, level);
     441                 :             : 
     442                 :          41 :   VALENT_EXIT;
     443                 :             : }
     444                 :             : 
     445                 :             : /**
     446                 :             :  * valent_mixer_stream_get_muted: (get-property muted) (virtual get_muted)
     447                 :             :  * @stream: a `ValentMixerStream`
     448                 :             :  *
     449                 :             :  * Get the muted state of @stream.
     450                 :             :  *
     451                 :             :  * Implementations that override this method should also override
     452                 :             :  * [vfunc@Valent.MixerStream.set_muted].
     453                 :             :  *
     454                 :             :  * Returns: %TRUE if the stream is muted, or %FALSE if not
     455                 :             :  *
     456                 :             :  * Since: 1.0
     457                 :             :  */
     458                 :             : gboolean
     459                 :          58 : valent_mixer_stream_get_muted (ValentMixerStream *stream)
     460                 :             : {
     461                 :          58 :   gboolean ret;
     462                 :             : 
     463                 :          58 :   VALENT_ENTRY;
     464                 :             : 
     465         [ +  - ]:          58 :   g_return_val_if_fail (VALENT_IS_MIXER_STREAM (stream), FALSE);
     466                 :             : 
     467                 :          58 :   ret = VALENT_MIXER_STREAM_GET_CLASS (stream)->get_muted (stream);
     468                 :             : 
     469                 :          58 :   VALENT_RETURN (ret);
     470                 :             : }
     471                 :             : 
     472                 :             : /**
     473                 :             :  * valent_mixer_stream_set_muted: (set-property muted) (virtual set_muted)
     474                 :             :  * @stream: a `ValentMixerStream`
     475                 :             :  * @state: whether the stream should be muted
     476                 :             :  *
     477                 :             :  * Set the muted state of @stream.
     478                 :             :  *
     479                 :             :  * Implementations that override this method should also override
     480                 :             :  * [vfunc@Valent.MixerStream.get_muted].
     481                 :             :  *
     482                 :             :  * Since: 1.0
     483                 :             :  */
     484                 :             : void
     485                 :          23 : valent_mixer_stream_set_muted (ValentMixerStream *stream,
     486                 :             :                                gboolean           state)
     487                 :             : {
     488                 :          23 :   VALENT_ENTRY;
     489                 :             : 
     490         [ +  - ]:          23 :   g_return_if_fail (VALENT_IS_MIXER_STREAM (stream));
     491                 :             : 
     492                 :          23 :   VALENT_MIXER_STREAM_GET_CLASS (stream)->set_muted (stream, state);
     493                 :             : 
     494                 :          23 :   VALENT_EXIT;
     495                 :             : }
     496                 :             : 
        

Generated by: LCOV version 2.0-1