← Back to branch summary

~ubuntu-branches/ubuntu/natty/vlc/natty

« back to all changes in this revision

Viewing changes to modules/video_filter/atmo/AtmoMultiConnection.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Benjamin Drung
  • Date: 2010-06-25 01:09:16 UTC
  • mfrom: (1.1.30 upstream)
  • Revision ID: james.westby@ubuntu.com-20100625010916-asxhep2mutg6g6pd
Tags: 1.1.0-1ubuntu1
* Merge from Debian unstable, remaining changes:
  - build and install the libx264 plugin
  - add Xb-Npp header to vlc package
  - Add apport hook to include more vlc dependencies in bug reports
* Drop xulrunner patches.
* Drop 502_xulrunner_191.diff.

Show diffs side-by-side

added added

removed removed

Lines of Context:
modules/video_filter/atmo/AtmoMultiConnection.cpp
 
1
/*
 
2
 * AtmoMultiConnection.cpp: Class for communication with up to 4 - 4 channel classic atmolight controllers
 
3
 * so you can built a cheap solution for having up to 16 channels
 
4
 *
 
5
 * See the README.txt file for copyright information and how to reach the author(s).
 
6
 *
 
7
 * $Id: 71f70f9f40f742412101e2f706f9a3cea4b01bf8 $
 
8
 */
 
9
 
 
10
#include "AtmoDefs.h"
 
11
#include "AtmoMultiConnection.h"
 
12
 
 
13
#if !defined(_ATMO_VLC_PLUGIN_)
 
14
#include "AtmoMultiConfigDialog.h"
 
15
#endif
 
16
 
 
17
#include <stdio.h>
 
18
#include <fcntl.h>
 
19
 
 
20
#if !defined(WIN32)
 
21
#include <termios.h>
 
22
#include <unistd.h>
 
23
#endif
 
24
 
 
25
 
 
26
 
 
27
CAtmoMultiConnection::CAtmoMultiConnection(CAtmoConfig *cfg) : CAtmoConnection(cfg)
 
28
{
 
29
   m_hComports[0] = INVALID_HANDLE_VALUE;
 
30
   m_hComports[1] = INVALID_HANDLE_VALUE;
 
31
   m_hComports[2] = INVALID_HANDLE_VALUE;
 
32
   m_hComports[3] = INVALID_HANDLE_VALUE;
 
33
   memset(&m_output, 0, sizeof(m_output));
 
34
}
 
35
 
 
36
CAtmoMultiConnection::~CAtmoMultiConnection(void)
 
37
{
 
38
}
 
39
 
 
40
HANDLE CAtmoMultiConnection::OpenDevice(char *devName)
 
41
{
 
42
     HANDLE hComport;
 
43
 
 
44
#if !defined(_ATMO_VLC_PLUGIN_)
 
45
     m_dwLastWin32Error = 0;
 
46
#endif
 
47
 
 
48
#if defined(WIN32)
 
49
     hComport = CreateFile(devName, GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL);
 
50
     if(hComport == INVALID_HANDLE_VALUE) {
 
51
#if !defined(_ATMO_VLC_PLUGIN_)
 
52
            m_dwLastWin32Error = GetLastError();
 
53
#endif
 
54
            return INVALID_HANDLE_VALUE;
 
55
     }
 
56
     /* change serial settings (Speed, stopbits etc.) */
 
57
     DCB dcb; // f�r comport-parameter
 
58
     dcb.DCBlength = sizeof(DCB);
 
59
     GetCommState (hComport, &dcb); // ger current serialport settings
 
60
     dcb.BaudRate  = 38400;        // set speed
 
61
     dcb.ByteSize  = 8;            // set databits
 
62
     dcb.Parity    = NOPARITY;     // set parity
 
63
     dcb.StopBits  = ONESTOPBIT;   // set one stop bit
 
64
     SetCommState (hComport, &dcb);    // apply settings
 
65
 
 
66
#else
 
67
 
 
68
     int bconst = B38400;
 
69
     hComport = open(devName,O_RDWR |O_NOCTTY);
 
70
     if(hComport < 0) {
 
71
            return INVALID_HANDLE_VALUE;;
 
72
     }
 
73
     struct termios tio;
 
74
     memset(&tio,0,sizeof(tio));
 
75
     tio.c_cflag = (CS8 | CREAD | HUPCL | CLOCAL);
 
76
     tio.c_iflag = (INPCK | BRKINT);
 
77
     cfsetispeed(&tio, bconst);
 
78
     cfsetospeed(&tio, bconst);
 
79
     if(!tcsetattr(hComport, TCSANOW, &tio)) {
 
80
         tcflush(hComport, TCIOFLUSH);
 
81
     } else {
 
82
         // can't change parms
 
83
        close(hComport);
 
84
        return INVALID_HANDLE_VALUE;
 
85
     }
 
86
#endif
 
87
 
 
88
     return hComport;
 
89
}
 
90
 
 
91
ATMO_BOOL CAtmoMultiConnection::OpenConnection()
 
92
{
 
93
    int z = 0;
 
94
#if defined(_ATMO_VLC_PLUGIN_)
 
95
 
 
96
    for(int c = 0; c < 4; c++ ) {
 
97
        char *devName = m_pAtmoConfig->getSerialDevice( c );
 
98
        if( devName && strlen(devName) > 0 )
 
99
        {
 
100
            m_hComports[z] = OpenDevice( devName );
 
101
            if(m_hComports[z] == INVALID_HANDLE_VALUE) {
 
102
                while(z) {
 
103
                      z--;
 
104
#if defined(WIN32)
 
105
                      CloseHandle( m_hComports[z] );
 
106
#else
 
107
                      close( m_hComports[z] );
 
108
#endif
 
109
                      m_hComports[z] = INVALID_HANDLE_VALUE;
 
110
                }
 
111
                return ATMO_FALSE;
 
112
            }
 
113
            z++;
 
114
        }
 
115
    }
 
116
 
 
117
 
 
118
#else
 
119
 
 
120
    char devName[16];
 
121
 
 
122
    for(int c = 0; c < 4; c++ ) {
 
123
        int comportnr = m_pAtmoConfig->getComport(c);
 
124
        if(comportnr > 0)
 
125
        {
 
126
            sprintf(devName,"com%d",comportnr);
 
127
            m_hComports[z] = OpenDevice(devName);
 
128
            if(m_hComports[z] == INVALID_HANDLE_VALUE) {
 
129
                while(z) {
 
130
                      z--;
 
131
                      CloseHandle( m_hComports[z] );
 
132
                      m_hComports[z] = INVALID_HANDLE_VALUE;
 
133
                }
 
134
                return ATMO_FALSE;
 
135
            }
 
136
            z++;
 
137
        }
 
138
    }
 
139
#endif
 
140
    return ATMO_TRUE;
 
141
}
 
142
 
 
143
void CAtmoMultiConnection::CloseConnection() {
 
144
    for(int i = 0; i < 4; i++ ) {
 
145
        if(m_hComports[i] != INVALID_HANDLE_VALUE) {
 
146
#if defined(WIN32)
 
147
           CloseHandle( m_hComports[i] );
 
148
#else
 
149
           close( m_hComports[i] );
 
150
#endif
 
151
               m_hComports[i] = INVALID_HANDLE_VALUE;
 
152
        }
 
153
    }
 
154
}
 
155
 
 
156
ATMO_BOOL CAtmoMultiConnection::isOpen(void) {
 
157
     int z = 0;
 
158
     for(int i = 0; i < 4; i++ )
 
159
         if(m_hComports[i] != INVALID_HANDLE_VALUE) z++;
 
160
 
 
161
         return (z > 0);
 
162
}
 
163
 
 
164
int CAtmoMultiConnection::getNumChannels()
 
165
{
 
166
    int z = 0;
 
167
#if defined(_ATMO_VLC_PLUGIN_)
 
168
    char *psz_dev;
 
169
    for(int i=0;i<4;i++) {
 
170
        psz_dev = m_pAtmoConfig->getSerialDevice( i );
 
171
        if( psz_dev && strlen( psz_dev ) > 0 )
 
172
            z+=4;
 
173
    }
 
174
#else
 
175
    for(int i=0;i<4;i++)
 
176
        if(m_pAtmoConfig->getComport(i)>0)
 
177
           z+=4;
 
178
#endif
 
179
    return z;
 
180
}
 
181
 
 
182
ATMO_BOOL CAtmoMultiConnection::CreateDefaultMapping(CAtmoChannelAssignment *ca)
 
183
{
 
184
  if(!ca) return ATMO_FALSE;
 
185
  int z = getNumChannels();
 
186
  ca->setSize( z );
 
187
  // 1 : 1 mapping vorschlagen...
 
188
  for(int i = 0; i < z ; i++ ) {
 
189
      ca->setZoneIndex( i, i );
 
190
  }
 
191
  return ATMO_TRUE;
 
192
}
 
193
 
 
194
 
 
195
ATMO_BOOL CAtmoMultiConnection::internal_HardwareWhiteAdjust(HANDLE hComport,
 
196
                                                     int global_gamma,
 
197
                                                     int global_contrast,
 
198
                                                     int contrast_red,
 
199
                                                     int contrast_green,
 
200
                                                     int contrast_blue,
 
201
                                                     int gamma_red,
 
202
                                                     int gamma_green,
 
203
                                                     int gamma_blue,
 
204
                                                     ATMO_BOOL storeToEeprom) {
 
205
  if(hComport == INVALID_HANDLE_VALUE)
 
206
     return ATMO_FALSE;
 
207
 
 
208
     DWORD iBytesWritten;
 
209
/*
 
210
[0] = 255
 
211
[1] = 00
 
212
[2] = 00
 
213
[3] = 101
 
214
 
 
215
[4]  brightness  0..255 ?
 
216
 
 
217
[5]  Contrast Red     11 .. 100
 
218
[6]  Contrast  Green  11 .. 100
 
219
[7]  Contrast  Blue   11 .. 100
 
220
 
 
221
[8]   Gamma Red    11 .. 35
 
222
[9]   Gamma Red    11 .. 35
 
223
[10]  Gamma Red    11 .. 35
 
224
 
 
225
[11]  Globale Contrast  11 .. 100
 
226
 
 
227
[12]  Store Data: 199 (else 0)
 
228
 
 
229
*/
 
230
     unsigned char sendBuffer[16];
 
231
     sendBuffer[0] = 0xFF;
 
232
     sendBuffer[1] = 0x00;
 
233
     sendBuffer[2] = 0x00;
 
234
     sendBuffer[3] = 101;
 
235
 
 
236
     sendBuffer[4] = (global_gamma & 255);
 
237
 
 
238
     sendBuffer[5] = (contrast_red & 255);
 
239
     sendBuffer[6] = (contrast_green & 255);
 
240
     sendBuffer[7] = (contrast_blue & 255);
 
241
 
 
242
     sendBuffer[8]  = (gamma_red & 255);
 
243
     sendBuffer[9]  = (gamma_green & 255);
 
244
     sendBuffer[10] = (gamma_blue & 255);
 
245
 
 
246
     sendBuffer[11] = (global_contrast & 255);
 
247
 
 
248
     if(storeToEeprom == ATMO_TRUE)
 
249
        sendBuffer[12] = 199; // store to eeprom!
 
250
     else
 
251
        sendBuffer[12] = 0;
 
252
 
 
253
#if defined(WIN32)
 
254
     WriteFile(hComport, sendBuffer, 13, &iBytesWritten, NULL); // send to COM-Port
 
255
#else
 
256
     iBytesWritten = write(hComport, sendBuffer, 13);
 
257
     tcdrain(hComport);
 
258
#endif
 
259
 
 
260
     return (iBytesWritten == 13) ? ATMO_TRUE : ATMO_FALSE;
 
261
}
 
262
 
 
263
 
 
264
ATMO_BOOL CAtmoMultiConnection::HardwareWhiteAdjust( int global_gamma,
 
265
                                                     int global_contrast,
 
266
                                                     int contrast_red,
 
267
                                                     int contrast_green,
 
268
                                                     int contrast_blue,
 
269
                                                     int gamma_red,
 
270
                                                     int gamma_green,
 
271
                                                     int gamma_blue,
 
272
                                                     ATMO_BOOL storeToEeprom)
 
273
{
 
274
    for(int z = 0 ; z < 4; z++ ) {
 
275
        if(m_hComports[z]!= INVALID_HANDLE_VALUE)
 
276
           if(internal_HardwareWhiteAdjust(m_hComports[z], global_gamma, global_contrast,
 
277
                                           contrast_red, contrast_green, contrast_blue,
 
278
                                           gamma_red, gamma_green, gamma_blue,
 
279
                                           storeToEeprom) == ATMO_FALSE)
 
280
                                                return ATMO_FALSE;
 
281
    }
 
282
    return ATMO_TRUE;
 
283
}
 
284
 
 
285
ATMO_BOOL CAtmoMultiConnection::internal_SendData(HANDLE hComport, unsigned char *colorData)
 
286
{
 
287
 if(m_hComports[0] == INVALID_HANDLE_VALUE)
 
288
    return ATMO_FALSE;
 
289
 
 
290
  unsigned char buffer[19];
 
291
  DWORD iBytesWritten;
 
292
 
 
293
  buffer[0] = 0xFF;  // Start Byte
 
294
  buffer[1] = 0x00;  // Start channel 0
 
295
  buffer[2] = 0x00;  // Start channel 0
 
296
  buffer[3] = 15; //
 
297
  buffer[4] = 0; // Summe Red
 
298
  buffer[5] = 0; // Summe Green
 
299
  buffer[6] = 0; // Summe Blue
 
300
  memcpy(&buffer[7], colorData, 4 * 3);
 
301
 
 
302
#if defined(WIN32)
 
303
   WriteFile(hComport, buffer, 19, &iBytesWritten, NULL); // send to COM-Port
 
304
#else
 
305
   iBytesWritten = write(hComport, buffer, 19);
 
306
   tcdrain(hComport);
 
307
#endif
 
308
 
 
309
 return (iBytesWritten == 19) ? ATMO_TRUE : ATMO_FALSE;
 
310
}
 
311
 
 
312
ATMO_BOOL CAtmoMultiConnection::SendData(pColorPacket data)
 
313
{
 
314
   if(m_hComports[0] == INVALID_HANDLE_VALUE)
 
315
          return ATMO_FALSE;
 
316
 
 
317
   int numChannels = this->getNumChannels();
 
318
 
 
319
   int idx;
 
320
   int iBuffer = 0;
 
321
   ATMO_BOOL result = ATMO_TRUE;
 
322
 
 
323
   Lock();
 
324
 
 
325
   for(int i = 0; i < numChannels ; i++) {
 
326
       if(m_ChannelAssignment && (i < m_NumAssignedChannels))
 
327
          idx = m_ChannelAssignment[i];
 
328
       else
 
329
          idx = -1;
 
330
       if((idx>=0) && (idx<data->numColors)) {
 
331
          m_output[iBuffer] = data->zone[idx].r;
 
332
          m_output[iBuffer+1] = data->zone[idx].g;
 
333
          m_output[iBuffer+2] = data->zone[idx].b;
 
334
       }
 
335
       iBuffer+=3;
 
336
   }
 
337
   for(int i = 0;i < 4; i++)
 
338
       if(m_hComports[i] != INVALID_HANDLE_VALUE)
 
339
          result = result & internal_SendData(m_hComports[i], &m_output[i*4*3]);
 
340
 
 
341
   Unlock();
 
342
 
 
343
   return result;
 
344
}
 
345
 
 
346
ATMO_BOOL CAtmoMultiConnection::setChannelColor(int channel, tRGBColor color)
 
347
{
 
348
   if(m_hComports[0] == INVALID_HANDLE_VALUE)
 
349
          return ATMO_FALSE;
 
350
   if((channel < 0) || (channel >= getNumChannels()))
 
351
      return ATMO_FALSE;
 
352
 
 
353
   ATMO_BOOL result = ATMO_TRUE;
 
354
 
 
355
   Lock();
 
356
   channel*=3;
 
357
   m_output[channel++] = color.r;
 
358
   m_output[channel++] = color.g;
 
359
   m_output[channel]   = color.b;
 
360
   for(int i = 0; i < 4; i++)
 
361
       if(m_hComports[i] != INVALID_HANDLE_VALUE)
 
362
          result = result & internal_SendData(m_hComports[i], &m_output[i*4*3]);
 
363
   Unlock();
 
364
 
 
365
   return result;
 
366
}
 
367
 
 
368
ATMO_BOOL CAtmoMultiConnection::setChannelValues(int numValues,unsigned char *channel_values)
 
369
{
 
370
  if(m_hComports[0] == INVALID_HANDLE_VALUE)
 
371
     return ATMO_FALSE;
 
372
 
 
373
  if((numValues & 1) || !channel_values)
 
374
     return ATMO_FALSE; // numValues must be even!
 
375
 
 
376
  ATMO_BOOL result = ATMO_TRUE;
 
377
 
 
378
 
 
379
  Lock();
 
380
  int Index = 0;
 
381
  for (int i = 0; i < numValues; i+=2) {
 
382
       Index = (int)channel_values[i];
 
383
       if(Index < sizeof(m_output))
 
384
          m_output[Index] = channel_values[i + 1];
 
385
  }
 
386
  for(int i = 0; i < 4; i++)
 
387
      if(m_hComports[i] != INVALID_HANDLE_VALUE)
 
388
         result = result & internal_SendData(m_hComports[i], &m_output[i*4*3]);
 
389
 
 
390
  Unlock();
 
391
  return result;
 
392
}
 
393
 
 
394
#if !defined(_ATMO_VLC_PLUGIN_)
 
395
 
 
396
char *CAtmoMultiConnection::getChannelName(int ch)
 
397
{
 
398
  int devnum = ch / 4;
 
399
  int kanal  = ch % 4;
 
400
  char buf[60];
 
401
  switch(kanal) {
 
402
         case 0: {
 
403
                   sprintf(buf,"Atmo[%d.%d] Links (%d)", devnum, kanal, ch);
 
404
                   break;
 
405
                 }
 
406
         case 1: {
 
407
                   sprintf(buf,"Atmo[%d.%d] Rechts (%d)", devnum, kanal, ch);
 
408
                   break;
 
409
                 }
 
410
         case 2: {
 
411
                   sprintf(buf,"Atmo[%d.%d] Oben (%d)", devnum, kanal, ch);
 
412
                   break;
 
413
                 }
 
414
         case 3: {
 
415
                   sprintf(buf,"Atmo[%d.%d] Unten (%d)", devnum, kanal, ch);
 
416
                   break;
 
417
                 }
 
418
  }
 
419
  return strdup(buf);
 
420
}
 
421
 
 
422
ATMO_BOOL CAtmoMultiConnection::ShowConfigDialog(HINSTANCE hInst, HWND parent, CAtmoConfig *cfg)
 
423
{
 
424
    CAtmoMultiConfigDialog *dlg = new CAtmoMultiConfigDialog(hInst, parent, cfg);
 
425
 
 
426
    INT_PTR result = dlg->ShowModal();
 
427
 
 
428
    delete dlg;
 
429
 
 
430
    if(result == IDOK)
 
431
      return ATMO_TRUE;
 
432
    else
 
433
      return ATMO_FALSE;
 
434
}
 
435
 
 
436
#endif
 
437