← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/oss4/oneiric-proposed

« back to all changes in this revision

Viewing changes to lib/libossmix/libossmix_cache.c

  • Committer: Bazaar Package Importer
  • Author(s): Stefano Rivera
  • Date: 2011-06-16 20:37:48 UTC
  • mfrom: (5.1.3 sid)
  • Revision ID: james.westby@ubuntu.com-20110616203748-jbrxik6ql33z54co
Tags: 4.2-build2004-1ubuntu1
https://launchpad.net/bugs/746048
https://launchpad.net/bugs/770972
* Merge from Debian unstable.
  - Supports our current kernel (LP: #746048)
  Remaining changes:
  - debian/oss4-dkms.dkms.in: s/source/build/ in Kernel headers paths.
* ld-as-needed.patch: Re-order CC arguments to enable building with ld
  --as-needed (LP: #770972)

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/libossmix/libossmix_cache.c
 
1
/*
 
2
 *
 
3
 * This file is part of Open Sound System.
 
4
 *
 
5
 * Copyright (C) 4Front Technologies 1996-2008.
 
6
 *
 
7
 * This this source file is released under GPL v2 license (no other versions).
 
8
 * See the COPYING file included in the main directory of this source
 
9
 * distribution for the license terms and conditions.
 
10
 *
 
11
 */
 
12
/*
 
13
 * Settings cache for libossmix
 
14
 */
 
15
#include <stdio.h>
 
16
#include <stdlib.h>
 
17
#include <unistd.h>
 
18
#include <soundcard.h>
 
19
#include <fcntl.h>
 
20
#include <string.h>
 
21
#include <sys/types.h>
 
22
#include <sys/socket.h>
 
23
#include <netinet/in.h>
 
24
#include <fcntl.h>
 
25
#include <errno.h>
 
26
#include <netdb.h>
 
27
 
 
28
#define OSSMIX_REMOTE
 
29
 
 
30
#include "libossmix.h"
 
31
#include "libossmix_impl.h"
 
32
 
 
33
static local_mixer_t *mixers[MAX_TMP_MIXER] = { NULL };
 
34
 
 
35
void
 
36
mixc_add_node (int mixernum, int node, oss_mixext * ext)
 
37
{
 
38
  local_mixer_t *lmixer;
 
39
  oss_mixext *lnode;
 
40
 
 
41
  if (mixers[mixernum] == NULL)
 
42
    {
 
43
      int i;
 
44
 
 
45
      mixers[mixernum] = lmixer = malloc (sizeof (*lmixer));
 
46
      if (lmixer == NULL)
 
47
        {
 
48
          fprintf (stderr, "mixc_add_node: Out of memory\n");
 
49
          exit (EXIT_FAILURE);
 
50
        }
 
51
 
 
52
      memset (lmixer, 0, sizeof (*lmixer));
 
53
      for (i = 0; i < MAX_TMP_NODES; i++)
 
54
        lmixer->values[i] = -1; // Invalid
 
55
    }
 
56
  else
 
57
    lmixer = mixers[mixernum];
 
58
 
 
59
  if (ext->ctrl >= lmixer->nrext)
 
60
    lmixer->nrext = ext->ctrl + 1;
 
61
 
 
62
  if (node >= MAX_TMP_NODES)
 
63
    {
 
64
      fprintf (stderr, "mixc_add_node: Node number too large %d\n", node);
 
65
      exit (EXIT_FAILURE);
 
66
    }
 
67
 
 
68
  lnode = lmixer->nodes[node];
 
69
 
 
70
  if (lnode == NULL)
 
71
    {
 
72
      lmixer->nodes[node] = lnode = malloc (sizeof (*lnode));
 
73
 
 
74
      if (lnode == NULL)
 
75
        {
 
76
          fprintf (stderr, "mixc_get_node: Out of memory\n");
 
77
          exit (EXIT_FAILURE);
 
78
        }
 
79
    }
 
80
 
 
81
  memcpy (lnode, ext, sizeof (*ext));
 
82
 
 
83
}
 
84
 
 
85
oss_mixext *
 
86
mixc_get_node (int mixernum, int node)
 
87
{
 
88
  local_mixer_t *lmixer;
 
89
  oss_mixext *lnode;
 
90
 
 
91
  if (mixers[mixernum] == NULL)
 
92
    {
 
93
      return NULL;
 
94
    }
 
95
  lmixer = mixers[mixernum];
 
96
 
 
97
  if (node >= MAX_TMP_NODES)
 
98
    {
 
99
      fprintf (stderr, "mixc_get_node: Node number too large %d\n", node);
 
100
      exit (EXIT_FAILURE);
 
101
    }
 
102
 
 
103
  lnode = lmixer->nodes[node];
 
104
 
 
105
  return lnode;
 
106
}
 
107
 
 
108
void
 
109
mixc_clear_changeflags(int mixernum)
 
110
{
 
111
  local_mixer_t *lmixer;
 
112
 
 
113
  if (mixers[mixernum] == NULL)
 
114
    {
 
115
      return;
 
116
    }
 
117
  lmixer = mixers[mixernum];
 
118
 
 
119
  memset(lmixer->changemask, 0, sizeof(lmixer->changemask));
 
120
}
 
121
 
 
122
void
 
123
mixc_set_value (int mixernum, int node, int value)
 
124
{
 
125
  local_mixer_t *lmixer;
 
126
 
 
127
  if (mixers[mixernum] == NULL)
 
128
    {
 
129
      return;
 
130
    }
 
131
  lmixer = mixers[mixernum];
 
132
 
 
133
  if (node >= MAX_TMP_NODES)
 
134
    {
 
135
      fprintf (stderr, "mixc_set_value: Node number too large %d\n", node);
 
136
      exit (EXIT_FAILURE);
 
137
    }
 
138
 
 
139
  if (lmixer->values[node] != value)
 
140
     lmixer->changemask[node / 8] |= (1 << (node % 8));
 
141
 
 
142
  lmixer->values[node] = value;
 
143
}
 
144
 
 
145
int
 
146
mixc_get_value (int mixernum, int node)
 
147
{
 
148
  local_mixer_t *lmixer;
 
149
 
 
150
  if (mixers[mixernum] == NULL)
 
151
    {
 
152
      return -1;
 
153
    }
 
154
  lmixer = mixers[mixernum];
 
155
 
 
156
  if (node >= MAX_TMP_NODES)
 
157
    {
 
158
      fprintf (stderr, "mixc_get_value: Node number too large %d\n", node);
 
159
      exit (EXIT_FAILURE);
 
160
    }
 
161
  lmixer->changemask[node / 8] &= ~(1 << (node % 8));
 
162
 
 
163
  return lmixer->values[node];
 
164
}
 
165
 
 
166
int
 
167
mixc_get_all_values (int mixernum, value_packet_t value_packet, int changecheck)
 
168
{
 
169
  int i, n = 0;
 
170
  oss_mixext *lnode;
 
171
  local_mixer_t *lmixer;
 
172
 
 
173
  if (mixers[mixernum] == NULL)
 
174
    {
 
175
      fprintf (stderr, "mixc_get_all_values: Mixer %d doesn't exist\n",
 
176
               mixernum);
 
177
      return 0;
 
178
    }
 
179
  lmixer = mixers[mixernum];
 
180
 
 
181
  for (i = 0; i < lmixer->nrext; i++)
 
182
    {
 
183
      lnode = lmixer->nodes[i];
 
184
 
 
185
      if (lnode == NULL)
 
186
        {
 
187
          fprintf (stderr, "mixc_get_all_values: Mixer %d, node %d == NULL\n",
 
188
                   mixernum, i);
 
189
          continue;
 
190
        }
 
191
 
 
192
      if (changecheck) // Not changed since the last time
 
193
      if (!(lmixer->changemask[i / 8] & (1 << (i % 8)) ))
 
194
         continue;
 
195
 
 
196
      if (lnode->type != MIXT_DEVROOT && lnode->type != MIXT_GROUP
 
197
          && lnode->type != MIXT_MARKER)
 
198
        {
 
199
          value_packet[n].node = i;
 
200
          value_packet[n].value = lmixer->values[i];
 
201
 
 
202
          lmixer->changemask[i / 8] &= ~(1 << (i % 8));
 
203
 
 
204
//printf("Send %d = %08x\n", i, lmixer->values[i]);
 
205
          n++;
 
206
        }
 
207
    }
 
208
 
 
209
  return n;
 
210
}