Mercurial > mplayer.hg

comparison stream/dvb_tune.c @ 19271:64d82a45a05d

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
introduce new 'stream' directory for all stream layer related components and split them from libmpdemux
author ben
date Mon, 31 Jul 2006 17:39:17 +0000
parents libmpdemux/dvb_tune.c@0783dd397f74
children 3af036ae3c75
comparison
equal deleted inserted replaced
19270:7d39b911f0bd 19271:64d82a45a05d
1 /* dvbtune - tune.c
2
3 Copyright (C) Dave Chapman 2001,2002
4
5 Modified for use with MPlayer, for details see the changelog at
6 http://svn.mplayerhq.hu/mplayer/trunk/
7 $Id$
8
9 This program is free software; you can redistribute it and/or
10 modify it under the terms of the GNU General Public License
11 as published by the Free Software Foundation; either version 2
12 of the License, or (at your option) any later version.
13
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
22 Or, point your browser to http://www.gnu.org/copyleft/gpl.html
23
24 */
25
26 #include <stdio.h>
27 #include <stdlib.h>
28 #include <ctype.h>
29 #include <sys/ioctl.h>
30 #include <sys/poll.h>
31 #include <unistd.h>
32 #include <fcntl.h>
33 #include <error.h>
34 #include <time.h>
35 #include <errno.h>
36 #include "config.h"
37
38 #ifdef HAVE_DVB_HEAD
39 #include <linux/dvb/dmx.h>
40 #include <linux/dvb/frontend.h>
41 char* dvb_frontenddev[4]={"/dev/dvb/adapter0/frontend0","/dev/dvb/adapter1/frontend0","/dev/dvb/adapter2/frontend0","/dev/dvb/adapter3/frontend0"};
42 char* dvb_dvrdev[4]={"/dev/dvb/adapter0/dvr0","/dev/dvb/adapter1/dvr0","/dev/dvb/adapter2/dvr0","/dev/dvb/adapter3/dvr0"};
43 char* dvb_demuxdev[4]={"/dev/dvb/adapter0/demux0","/dev/dvb/adapter1/demux0","/dev/dvb/adapter2/demux0","/dev/dvb/adapter3/demux0"};
44 static char* dvb_secdev[4]={"","","",""}; //UNUSED, ONLY FOR UNIFORMITY
45 #else
46 #include <ost/dmx.h>
47 #include <ost/sec.h>
48 #include <ost/frontend.h>
49 char* dvb_frontenddev[4]={"/dev/ost/frontend0","/dev/ost/frontend1","/dev/ost/frontend2","/dev/ost/frontend3"};
50 char* dvb_dvrdev[4]={"/dev/ost/dvr0","/dev/ost/dvr1","/dev/ost/dvr2","/dev/ost/dvr3"};
51 static char* dvb_secdev[4]={"/dev/ost/sec0","/dev/ost/sec1","/dev/ost/sec2","/dev/ost/sec3"};
52 char* dvb_demuxdev[4]={"/dev/ost/demux0","/dev/ost/demux1","/dev/ost/demux2","/dev/ost/demux3"};
53 #endif
54
55 #include "dvbin.h"
56 #include "mp_msg.h"
57
58
59
60 int dvb_get_tuner_type(int fe_fd)
61 {
62 #ifdef HAVE_DVB_HEAD
63 struct dvb_frontend_info fe_info;
64 #else
65 FrontendInfo fe_info;
66 #endif
67
68 int res;
69
70 res = ioctl(fe_fd, FE_GET_INFO, &fe_info);
71 if(res < 0)
72 {
73 mp_msg(MSGT_DEMUX, MSGL_ERR, "FE_GET_INFO error: %d, FD: %d\n\n", errno, fe_fd);
74 return 0;
75 }
76
77 switch(fe_info.type)
78 {
79 case FE_OFDM:
80 mp_msg(MSGT_DEMUX, MSGL_V, "TUNER TYPE SEEMS TO BE DVB-T\n");
81 return TUNER_TER;
82
83 case FE_QPSK:
84 mp_msg(MSGT_DEMUX, MSGL_V, "TUNER TYPE SEEMS TO BE DVB-S\n");
85 return TUNER_SAT;
86
87 case FE_QAM:
88 mp_msg(MSGT_DEMUX, MSGL_V, "TUNER TYPE SEEMS TO BE DVB-C\n");
89 return TUNER_CBL;
90
91 #ifdef DVB_ATSC
92 case FE_ATSC:
93 mp_msg(MSGT_DEMUX, MSGL_V, "TUNER TYPE SEEMS TO BE DVB-ATSC\n");
94 return TUNER_ATSC;
95 #endif
96 default:
97 mp_msg(MSGT_DEMUX, MSGL_ERR, "UNKNOWN TUNER TYPE\n");
98 return 0;
99 }
100
101 }
102
103 int dvb_set_ts_filt(int fd, uint16_t pid, dmx_pes_type_t pestype);
104
105 int dvb_open_devices(dvb_priv_t *priv, int n, int demux_cnt, int *pids)
106 {
107 int i;
108
109 priv->fe_fd = open(dvb_frontenddev[n], O_RDWR | O_NONBLOCK);
110 if(priv->fe_fd < 0)
111 {
112 mp_msg(MSGT_DEMUX, MSGL_ERR, "ERROR OPENING FRONTEND DEVICE %s: ERRNO %d\n", dvb_frontenddev[n], errno);
113 return 0;
114 }
115 #ifdef HAVE_DVB_HEAD
116 priv->sec_fd=0;
117 #else
118 priv->sec_fd = open(dvb_secdev[n], O_RDWR);
119 if(priv->sec_fd < 0)
120 {
121 mp_msg(MSGT_DEMUX, MSGL_ERR, "ERROR OPENING SEC DEVICE %s: ERRNO %d\n", dvb_secdev[n], errno);
122 close(priv->fe_fd);
123 return 0;
124 }
125 #endif
126 priv->demux_fds_cnt = 0;
127 mp_msg(MSGT_DEMUX, MSGL_V, "DVB_OPEN_DEVICES(%d)\n", demux_cnt);
128 for(i = 0; i < demux_cnt; i++)
129 {
130 priv->demux_fds[i] = open(dvb_demuxdev[n], O_RDWR | O_NONBLOCK);
131 if(priv->demux_fds[i] < 0)
132 {
133 mp_msg(MSGT_DEMUX, MSGL_ERR, "ERROR OPENING DEMUX 0: %d\n", errno);
134 return 0;
135 }
136 else
137 {
138 mp_msg(MSGT_DEMUX, MSGL_V, "OPEN(%d), file %s: FD=%d, CNT=%d\n", i, dvb_demuxdev[n], priv->demux_fds[i], priv->demux_fds_cnt);
139 priv->demux_fds_cnt++;
140 }
141 }
142
143
144 priv->dvr_fd = open(dvb_dvrdev[n], O_RDONLY| O_NONBLOCK);
145 if(priv->dvr_fd < 0)
146 {
147 mp_msg(MSGT_DEMUX, MSGL_ERR, "ERROR OPENING DVR DEVICE %s: %d\n", dvb_dvrdev[n], errno);
148 return 0;
149 }
150
151 return 1;
152 }
153
154
155 int dvb_fix_demuxes(dvb_priv_t *priv, int cnt, int *pids)
156 {
157 int i;
158
159 mp_msg(MSGT_DEMUX, MSGL_V, "FIX %d -> %d\n", priv->demux_fds_cnt, cnt);
160 if(priv->demux_fds_cnt >= cnt)
161 {
162 for(i = priv->demux_fds_cnt-1; i >= cnt; i--)
163 {
164 mp_msg(MSGT_DEMUX, MSGL_V, "FIX, CLOSE fd(%d): %d\n", i, priv->demux_fds[i]);
165 close(priv->demux_fds[i]);
166 }
167 priv->demux_fds_cnt = cnt;
168 }
169 else if(priv->demux_fds_cnt < cnt)
170 {
171 for(i = priv->demux_fds_cnt; i < cnt; i++)
172 {
173 priv->demux_fds[i] = open(dvb_demuxdev[priv->card], O_RDWR | O_NONBLOCK);
174 mp_msg(MSGT_DEMUX, MSGL_V, "FIX, OPEN fd(%d): %d\n", i, priv->demux_fds[i]);
175 if(priv->demux_fds[i] < 0)
176 {
177 mp_msg(MSGT_DEMUX, MSGL_ERR, "ERROR OPENING DEMUX 0: %d\n", errno);
178 return 0;
179 }
180 else
181 priv->demux_fds_cnt++;
182 }
183 }
184
185 return 1;
186 }
187
188 int dvb_set_ts_filt(int fd, uint16_t pid, dmx_pes_type_t pestype)
189 {
190 int i;
191 struct dmx_pes_filter_params pesFilterParams;
192
193 pesFilterParams.pid = pid;
194 pesFilterParams.input = DMX_IN_FRONTEND;
195 pesFilterParams.output = DMX_OUT_TS_TAP;
196 #ifdef HAVE_DVB_HEAD
197 pesFilterParams.pes_type = pestype;
198 #else
199 pesFilterParams.pesType = pestype;
200 #endif
201
202 pesFilterParams.flags = DMX_IMMEDIATE_START;
203
204 errno = 0;
205 if ((i = ioctl(fd, DMX_SET_PES_FILTER, &pesFilterParams)) < 0)
206 {
207 mp_msg(MSGT_DEMUX, MSGL_ERR, "ERROR IN SETTING DMX_FILTER %i for fd %d: ERRNO: %d", pid, fd, errno);
208 return 0;
209 }
210
211 mp_msg(MSGT_DEMUX, MSGL_V, "SET PES FILTER ON PID %d to fd %d, RESULT: %d, ERRNO: %d\n", pid, fd, i, errno);
212 return 1;
213 }
214
215
216 int dvb_demux_stop(int fd)
217 {
218 int i;
219 i = ioctl(fd, DMX_STOP);
220
221 mp_msg(MSGT_DEMUX, MSGL_DBG2, "STOPPING FD: %d, RESULT: %d\n", fd, i);
222
223 return (i==0);
224 }
225
226
227 int dvb_demux_start(int fd)
228 {
229 int i;
230 i = ioctl(fd, DMX_START);
231
232 mp_msg(MSGT_DEMUX, MSGL_DBG2, "STARTING FD: %d, RESULT: %d\n", fd, i);
233
234 return (i==0);
235 }
236
237
238 static int tune_it(int fd_frontend, int fd_sec, unsigned int freq, unsigned int srate, char pol, int tone,
239 fe_spectral_inversion_t specInv, unsigned int diseqc, fe_modulation_t modulation, fe_code_rate_t HP_CodeRate,
240 fe_transmit_mode_t TransmissionMode, fe_guard_interval_t guardInterval, fe_bandwidth_t bandwidth,
241 fe_code_rate_t LP_CodeRate, fe_hierarchy_t hier, int tmout);
242
243
244 int dvb_tune(dvb_priv_t *priv, int freq, char pol, int srate, int diseqc, int tone,
245 fe_spectral_inversion_t specInv, fe_modulation_t modulation, fe_guard_interval_t guardInterval,
246 fe_transmit_mode_t TransmissionMode, fe_bandwidth_t bandWidth, fe_code_rate_t HP_CodeRate,
247 fe_code_rate_t LP_CodeRate, fe_hierarchy_t hier, int timeout)
248 {
249 int ris;
250
251 mp_msg(MSGT_DEMUX, MSGL_INFO, "dvb_tune Freq: %lu\n", (long unsigned int) freq);
252
253 ris = tune_it(priv->fe_fd, priv->sec_fd, freq, srate, pol, tone, specInv, diseqc, modulation, HP_CodeRate, TransmissionMode, guardInterval, bandWidth, LP_CodeRate, hier, timeout);
254
255 if(ris != 0)
256 mp_msg(MSGT_DEMUX, MSGL_INFO, "dvb_tune, TUNING FAILED\n");
257
258 return (ris == 0);
259 }
260
261
262 #ifndef HAVE_DVB_HEAD
263 static int SecGetStatus (int fd, struct secStatus *state)
264 {
265 if(ioctl(fd, SEC_GET_STATUS, state) < 0)
266 {
267 mp_msg(MSGT_DEMUX, MSGL_ERR, ("SEC GET STATUS: "));
268 return -1;
269 }
270
271 switch (state->busMode)
272 {
273 case SEC_BUS_IDLE:
274 mp_msg(MSGT_DEMUX, MSGL_V, "SEC BUS MODE: IDLE (%d)\n",state->busMode);
275 break;
276 case SEC_BUS_BUSY:
277 mp_msg(MSGT_DEMUX, MSGL_V, "SEC BUS MODE: BUSY (%d)\n",state->busMode);
278 break;
279 case SEC_BUS_OFF:
280 mp_msg(MSGT_DEMUX, MSGL_V, "SEC BUS MODE: OFF (%d)\n",state->busMode);
281 break;
282 case SEC_BUS_OVERLOAD:
283 mp_msg(MSGT_DEMUX, MSGL_V, "SEC BUS MODE: OVERLOAD (%d)\n",state->busMode);
284 break;
285 default:
286 mp_msg(MSGT_DEMUX, MSGL_V, "SEC BUS MODE: unknown (%d)\n",state->busMode);
287 break;
288 }
289
290 switch (state->selVolt)
291 {
292 case SEC_VOLTAGE_OFF:
293 mp_msg(MSGT_DEMUX, MSGL_V, "SEC VOLTAGE: OFF (%d)\n",state->selVolt);
294 break;
295 case SEC_VOLTAGE_LT:
296 mp_msg(MSGT_DEMUX, MSGL_V, "SEC VOLTAGE: LT (%d)\n",state->selVolt);
297 break;
298 case SEC_VOLTAGE_13:
299 mp_msg(MSGT_DEMUX, MSGL_V, "SEC VOLTAGE: 13 (%d)\n",state->selVolt);
300 break;
301 case SEC_VOLTAGE_13_5:
302 mp_msg(MSGT_DEMUX, MSGL_V, "SEC VOLTAGE: 13.5 (%d)\n",state->selVolt);
303 break;
304 case SEC_VOLTAGE_18:
305 mp_msg(MSGT_DEMUX, MSGL_V, "SEC VOLTAGE: 18 (%d)\n",state->selVolt);
306 break;
307 case SEC_VOLTAGE_18_5:
308 mp_msg(MSGT_DEMUX, MSGL_V, "SEC VOLTAGE: 18.5 (%d)\n",state->selVolt);
309 break;
310 default:
311 mp_msg(MSGT_DEMUX, MSGL_V, "SEC VOLTAGE: unknown (%d)\n",state->selVolt);
312 break;
313 }
314
315 mp_msg(MSGT_DEMUX, MSGL_V, "SEC CONT TONE: %s\n", (state->contTone == SEC_TONE_ON ? "ON" : "OFF"));
316 return 0;
317 }
318
319 #endif
320
321 static void print_status(fe_status_t festatus)
322 {
323 mp_msg(MSGT_DEMUX, MSGL_V, "FE_STATUS:");
324 if (festatus & FE_HAS_SIGNAL) mp_msg(MSGT_DEMUX, MSGL_V," FE_HAS_SIGNAL");
325 #ifdef HAVE_DVB_HEAD
326 if (festatus & FE_TIMEDOUT) mp_msg(MSGT_DEMUX, MSGL_V, " FE_TIMEDOUT");
327 #else
328 if (festatus & FE_HAS_POWER) mp_msg(MSGT_DEMUX, MSGL_V, " FE_HAS_POWER");
329 if (festatus & FE_SPECTRUM_INV) mp_msg(MSGT_DEMUX, MSGL_V, " FE_SPECTRUM_INV");
330 if (festatus & FE_TUNER_HAS_LOCK) mp_msg(MSGT_DEMUX, MSGL_V, " FE_TUNER_HAS_LOCK");
331 #endif
332 if (festatus & FE_HAS_LOCK) mp_msg(MSGT_DEMUX, MSGL_V, " FE_HAS_LOCK");
333 if (festatus & FE_HAS_CARRIER) mp_msg(MSGT_DEMUX, MSGL_V, " FE_HAS_CARRIER");
334 if (festatus & FE_HAS_VITERBI) mp_msg(MSGT_DEMUX, MSGL_V, " FE_HAS_VITERBI");
335 if (festatus & FE_HAS_SYNC) mp_msg(MSGT_DEMUX, MSGL_V, " FE_HAS_SYNC");
336 mp_msg(MSGT_DEMUX, MSGL_V, "\n");
337 }
338
339
340 #ifdef HAVE_DVB_HEAD
341 static int check_status(int fd_frontend,struct dvb_frontend_parameters* feparams, int tuner_type, uint32_t base, int tmout)
342 {
343 int32_t strength;
344 fe_status_t festatus;
345 struct pollfd pfd[1];
346 int ok=0, locks=0;
347 time_t tm1, tm2;
348
349 if (ioctl(fd_frontend,FE_SET_FRONTEND,feparams) < 0)
350 {
351 mp_msg(MSGT_DEMUX, MSGL_ERR, "ERROR tuning channel\n");
352 return -1;
353 }
354
355 pfd[0].fd = fd_frontend;
356 pfd[0].events = POLLPRI;
357
358 mp_msg(MSGT_DEMUX, MSGL_V, "Getting frontend status\n");
359 tm1 = tm2 = time((time_t*) NULL);
360 while(!ok)
361 {
362 festatus = 0;
363 if(poll(pfd,1,tmout*1000) > 0)
364 {
365 if (pfd[0].revents & POLLPRI)
366 {
367 if(ioctl(fd_frontend, FE_READ_STATUS, &festatus) >= 0)
368 if(festatus & FE_HAS_LOCK)
369 locks++;
370 }
371 }
372 usleep(10000);
373 tm2 = time((time_t*) NULL);
374 if((festatus & FE_TIMEDOUT) || (locks >= 2) || (tm2 - tm1 >= tmout))
375 ok = 1;
376 }
377
378 if(festatus & FE_HAS_LOCK)
379 {
380 if(ioctl(fd_frontend,FE_GET_FRONTEND,feparams) >= 0)
381 {
382 switch(tuner_type)
383 {
384 case FE_OFDM:
385 mp_msg(MSGT_DEMUX, MSGL_V, "Event: Frequency: %d\n",feparams->frequency);
386 break;
387 case FE_QPSK:
388 mp_msg(MSGT_DEMUX, MSGL_V, "Event: Frequency: %d\n",(unsigned int)((feparams->frequency)+base));
389 mp_msg(MSGT_DEMUX, MSGL_V, " SymbolRate: %d\n",feparams->u.qpsk.symbol_rate);
390 mp_msg(MSGT_DEMUX, MSGL_V, " FEC_inner: %d\n",feparams->u.qpsk.fec_inner);
391 mp_msg(MSGT_DEMUX, MSGL_V, "\n");
392 break;
393 case FE_QAM:
394 mp_msg(MSGT_DEMUX, MSGL_V, "Event: Frequency: %d\n",feparams->frequency);
395 mp_msg(MSGT_DEMUX, MSGL_V, " SymbolRate: %d\n",feparams->u.qpsk.symbol_rate);
396 mp_msg(MSGT_DEMUX, MSGL_V, " FEC_inner: %d\n",feparams->u.qpsk.fec_inner);
397 break;
398 #ifdef DVB_ATSC
399 case FE_ATSC:
400 mp_msg(MSGT_DEMUX, MSGL_V, "Event: Frequency: %d\n",feparams->frequency);
401 mp_msg(MSGT_DEMUX, MSGL_V, " Modulation: %d\n",feparams->u.vsb.modulation);
402 break;
403 #endif
404 default:
405 break;
406 }
407 }
408
409 strength=0;
410 if(ioctl(fd_frontend,FE_READ_BER,&strength) >= 0)
411 mp_msg(MSGT_DEMUX, MSGL_V, "Bit error rate: %d\n",strength);
412
413 strength=0;
414 if(ioctl(fd_frontend,FE_READ_SIGNAL_STRENGTH,&strength) >= 0)
415 mp_msg(MSGT_DEMUX, MSGL_V, "Signal strength: %d\n",strength);
416
417 strength=0;
418 if(ioctl(fd_frontend,FE_READ_SNR,&strength) >= 0)
419 mp_msg(MSGT_DEMUX, MSGL_V, "SNR: %d\n",strength);
420
421 strength=0;
422 if(ioctl(fd_frontend,FE_READ_UNCORRECTED_BLOCKS,&strength) >= 0)
423 mp_msg(MSGT_DEMUX, MSGL_V, "UNC: %d\n",strength);
424
425 print_status(festatus);
426 }
427 else
428 {
429 mp_msg(MSGT_DEMUX, MSGL_ERR, "Not able to lock to the signal on the given frequency, timeout: %d\n", tmout);
430 return -1;
431 }
432 return 0;
433 }
434
435 #else
436
437 static int check_status(int fd_frontend,FrontendParameters* feparams,int tuner_type,uint32_t base, int tmout)
438 {
439 int i,res;
440 int32_t strength;
441 fe_status_t festatus;
442 FrontendEvent event;
443
444 struct pollfd pfd[1];
445
446 while(1)
447 {
448 if(ioctl(fd_frontend, FE_GET_EVENT, &event) == -1)
449 break;
450 }
451
452 i = 0; res = -1;
453 while ((i < 3) && (res < 0))
454 {
455 if (ioctl(fd_frontend,FE_SET_FRONTEND,feparams) < 0)
456 {
457 mp_msg(MSGT_DEMUX, MSGL_ERR, "ERROR tuning channel\n");
458 return -1;
459 }
460
461 pfd[0].fd = fd_frontend;
462 pfd[0].events = POLLIN | POLLPRI;
463
464 if(poll(pfd,1,tmout*1000) > 0)
465 {
466 if (pfd[0].revents & POLLPRI)
467 {
468 mp_msg(MSGT_DEMUX, MSGL_V, "Getting frontend event\n");
469 if ( ioctl(fd_frontend, FE_GET_EVENT, &event) < 0)
470 {
471 mp_msg(MSGT_DEMUX, MSGL_ERR, "FE_GET_EVENT");
472 return -1;
473 }
474 mp_msg(MSGT_DEMUX, MSGL_V, "Received ");
475 switch(event.type)
476 {
477 case FE_UNEXPECTED_EV:
478 mp_msg(MSGT_DEMUX, MSGL_V, "unexpected event\n");
479 res = -1;
480 break;
481
482 case FE_FAILURE_EV:
483 mp_msg(MSGT_DEMUX, MSGL_V, "failure event\n");
484 res = -1;
485 break;
486
487 case FE_COMPLETION_EV:
488 mp_msg(MSGT_DEMUX, MSGL_V, "completion event\n");
489 res = 0;
490 break;
491 }
492 }
493 i++;
494 }
495 }
496
497 if (res > 0)
498 switch (event.type)
499 {
500 case FE_UNEXPECTED_EV: mp_msg(MSGT_DEMUX, MSGL_V, "FE_UNEXPECTED_EV\n");
501 break;
502 case FE_COMPLETION_EV: mp_msg(MSGT_DEMUX, MSGL_V, "FE_COMPLETION_EV\n");
503 break;
504 case FE_FAILURE_EV: mp_msg(MSGT_DEMUX, MSGL_V, "FE_FAILURE_EV\n");
505 break;
506 }
507
508 if (event.type == FE_COMPLETION_EV)
509 {
510 switch(tuner_type)
511 {
512 case FE_OFDM:
513 mp_msg(MSGT_DEMUX, MSGL_V, "Event: Frequency: %d\n",event.u.completionEvent.Frequency);
514 break;
515
516 case FE_QPSK:
517 mp_msg(MSGT_DEMUX, MSGL_V, "Event: Frequency: %d\n",(unsigned int)((event.u.completionEvent.Frequency)+base));
518 mp_msg(MSGT_DEMUX, MSGL_V, " SymbolRate: %d\n",event.u.completionEvent.u.qpsk.SymbolRate);
519 mp_msg(MSGT_DEMUX, MSGL_V, " FEC_inner: %d\n",event.u.completionEvent.u.qpsk.FEC_inner);
520 mp_msg(MSGT_DEMUX, MSGL_V, "\n");
521 break;
522
523 case FE_QAM:
524 mp_msg(MSGT_DEMUX, MSGL_V, "Event: Frequency: %d\n",event.u.completionEvent.Frequency);
525 mp_msg(MSGT_DEMUX, MSGL_V, " SymbolRate: %d\n",event.u.completionEvent.u.qpsk.SymbolRate);
526 mp_msg(MSGT_DEMUX, MSGL_V, " FEC_inner: %d\n",event.u.completionEvent.u.qpsk.FEC_inner);
527 break;
528
529 default:
530 break;
531 }
532
533 strength=0;
534 if(ioctl(fd_frontend,FE_READ_BER,&strength) >= 0)
535 mp_msg(MSGT_DEMUX, MSGL_V, "Bit error rate: %d\n",strength);
536
537 strength=0;
538 if(ioctl(fd_frontend,FE_READ_SIGNAL_STRENGTH,&strength) >= 0)
539 mp_msg(MSGT_DEMUX, MSGL_V, "Signal strength: %d\n",strength);
540
541 strength=0;
542 if(ioctl(fd_frontend,FE_READ_SNR,&strength) >= 0)
543 mp_msg(MSGT_DEMUX, MSGL_V, "SNR: %d\n",strength);
544
545 festatus=0;
546 mp_msg(MSGT_DEMUX, MSGL_V, "FE_STATUS:");
547
548 if(ioctl(fd_frontend,FE_READ_STATUS,&festatus) >= 0)
549 print_status(festatus);
550 else
551 mp_msg(MSGT_DEMUX, MSGL_ERR, " ERROR, UNABLE TO READ_STATUS");
552
553 mp_msg(MSGT_DEMUX, MSGL_V, "\n");
554 }
555 else
556 {
557 mp_msg(MSGT_DEMUX, MSGL_V, "Not able to lock to the signal on the given frequency\n");
558 return -1;
559 }
560 return 0;
561 }
562 #endif
563
564 #ifdef HAVE_DVB_HEAD
565
566 static struct diseqc_cmd {
567 struct dvb_diseqc_master_cmd cmd;
568 uint32_t wait;
569 };
570
571 static int diseqc_send_msg(int fd, fe_sec_voltage_t v, struct diseqc_cmd *cmd,
572 fe_sec_tone_mode_t t, fe_sec_mini_cmd_t b)
573 {
574 if(ioctl(fd, FE_SET_TONE, SEC_TONE_OFF) == -1)
575 return -1;
576 if(ioctl(fd, FE_SET_VOLTAGE, v) == -1)
577 return -1;
578 usleep(15 * 1000);
579 if(ioctl(fd, FE_DISEQC_SEND_MASTER_CMD, &cmd->cmd) == -1)
580 return -1;
581 usleep(cmd->wait * 1000);
582 usleep(15 * 1000);
583 if(ioctl(fd, FE_DISEQC_SEND_BURST, b) == -1)
584 return -1;
585 usleep(15 * 1000);
586 if(ioctl(fd, FE_SET_TONE, t) == -1)
587 return -1;
588
589 return 0;
590 }
591
592 /* digital satellite equipment control,
593 * specification is available from http://www.eutelsat.com/
594 */
595 static int do_diseqc(int secfd, int sat_no, int polv, int hi_lo)
596 {
597 struct diseqc_cmd cmd = { {{0xe0, 0x10, 0x38, 0xf0, 0x00, 0x00}, 4}, 0 };
598
599 /* param: high nibble: reset bits, low nibble set bits,
600 * bits are: option, position, polarizaion, band
601 */
602 cmd.cmd.msg[3] =
603 0xf0 | (((sat_no * 4) & 0x0f) | (hi_lo ? 1 : 0) | (polv ? 0 : 2));
604
605 return diseqc_send_msg(secfd, polv ? SEC_VOLTAGE_13 : SEC_VOLTAGE_18,
606 &cmd, hi_lo ? SEC_TONE_ON : SEC_TONE_OFF,
607 (sat_no / 4) % 2 ? SEC_MINI_B : SEC_MINI_A);
608 }
609
610 #else
611
612 static int do_diseqc(int secfd, int sat_no, int polv, int hi_lo)
613 {
614 struct secCommand scmd;
615 struct secCmdSequence scmds;
616
617 scmds.continuousTone = (hi_lo ? SEC_TONE_ON : SEC_TONE_OFF);
618 scmds.voltage = (polv ? SEC_VOLTAGE_13 : SEC_VOLTAGE_18);
619 scmds.miniCommand = SEC_MINI_NONE;
620
621 scmd.type = SEC_CMDTYPE_DISEQC;
622 scmds.numCommands = 1;
623 scmds.commands = &scmd;
624
625 scmd.u.diseqc.addr = 0x10;
626 scmd.u.diseqc.cmd = 0x38;
627 scmd.u.diseqc.numParams = 1;
628 scmd.u.diseqc.params[0] = 0xf0 |
629 (((sat_no) << 2) & 0x0F) |
630 (hi_lo ? 1 : 0) |
631 (polv ? 0 : 2);
632
633 if (ioctl(secfd,SEC_SEND_SEQUENCE,&scmds) < 0)
634 {
635 mp_msg(MSGT_DEMUX, MSGL_ERR, "Error sending DisEqC");
636 return -1;
637 }
638
639 return 0;
640 }
641 #endif
642
643 static int tune_it(int fd_frontend, int fd_sec, unsigned int freq, unsigned int srate, char pol, int tone,
644 fe_spectral_inversion_t specInv, unsigned int diseqc, fe_modulation_t modulation, fe_code_rate_t HP_CodeRate,
645 fe_transmit_mode_t TransmissionMode, fe_guard_interval_t guardInterval, fe_bandwidth_t bandwidth,
646 fe_code_rate_t LP_CodeRate, fe_hierarchy_t hier, int timeout)
647 {
648 int res, hi_lo, dfd;
649 #ifdef HAVE_DVB_HEAD
650 struct dvb_frontend_parameters feparams;
651 struct dvb_frontend_info fe_info;
652 #else
653 FrontendParameters feparams;
654 FrontendInfo fe_info;
655 struct secStatus sec_state;
656 #endif
657
658
659 mp_msg(MSGT_DEMUX, MSGL_V, "TUNE_IT, fd_frontend %d, fd_sec %d\nfreq %lu, srate %lu, pol %c, tone %i, specInv, diseqc %u, fe_modulation_t modulation,fe_code_rate_t HP_CodeRate, fe_transmit_mode_t TransmissionMode,fe_guard_interval_t guardInterval, fe_bandwidth_t bandwidth\n",
660 fd_frontend, fd_sec, (long unsigned int)freq, (long unsigned int)srate, pol, tone, diseqc);
661
662
663 if ( (res = ioctl(fd_frontend,FE_GET_INFO, &fe_info) < 0))
664 {
665 mp_msg(MSGT_DEMUX, MSGL_FATAL, "FE_GET_INFO FAILED\n");
666 return -1;
667 }
668
669
670 #ifdef HAVE_DVB_HEAD
671 mp_msg(MSGT_DEMUX, MSGL_V, "Using DVB card \"%s\"\n", fe_info.name);
672 #endif
673
674 switch(fe_info.type)
675 {
676 case FE_OFDM:
677 #ifdef HAVE_DVB_HEAD
678 if (freq < 1000000) freq*=1000UL;
679 feparams.frequency=freq;
680 feparams.inversion=specInv;
681 feparams.u.ofdm.bandwidth=bandwidth;
682 feparams.u.ofdm.code_rate_HP=HP_CodeRate;
683 feparams.u.ofdm.code_rate_LP=LP_CodeRate;
684 feparams.u.ofdm.constellation=modulation;
685 feparams.u.ofdm.transmission_mode=TransmissionMode;
686 feparams.u.ofdm.guard_interval=guardInterval;
687 feparams.u.ofdm.hierarchy_information=hier;
688 #else
689 if (freq < 1000000) freq*=1000UL;
690 feparams.Frequency=freq;
691 feparams.Inversion=specInv;
692 feparams.u.ofdm.bandWidth=bandwidth;
693 feparams.u.ofdm.HP_CodeRate=HP_CodeRate;
694 feparams.u.ofdm.LP_CodeRate=LP_CodeRate;
695 feparams.u.ofdm.Constellation=modulation;
696 feparams.u.ofdm.TransmissionMode=TransmissionMode;
697 feparams.u.ofdm.guardInterval=guardInterval;
698 feparams.u.ofdm.HierarchyInformation=hier;
699 #endif
700 mp_msg(MSGT_DEMUX, MSGL_V, "tuning DVB-T to %d Hz, bandwidth: %d\n",freq, bandwidth);
701 break;
702 case FE_QPSK:
703 if (freq > 2200000)
704 {
705 // this must be an absolute frequency
706 if (freq < SLOF)
707 {
708 #ifdef HAVE_DVB_HEAD
709 freq = feparams.frequency=(freq-LOF1);
710 #else
711 freq = feparams.Frequency=(freq-LOF1);
712 #endif
713 hi_lo = 0;
714 }
715 else
716 {
717 #ifdef HAVE_DVB_HEAD
718 freq = feparams.frequency=(freq-LOF2);
719 #else
720 freq = feparams.Frequency=(freq-LOF2);
721 #endif
722 hi_lo = 1;
723 }
724 }
725 else
726 {
727 // this is an L-Band frequency
728 #ifdef HAVE_DVB_HEAD
729 feparams.frequency=freq;
730 #else
731 feparams.Frequency=freq;
732 #endif
733 }
734
735 #ifdef HAVE_DVB_HEAD
736 feparams.inversion=specInv;
737 feparams.u.qpsk.symbol_rate=srate;
738 feparams.u.qpsk.fec_inner=HP_CodeRate;
739 dfd = fd_frontend;
740 #else
741 feparams.Inversion=specInv;
742 feparams.u.qpsk.SymbolRate=srate;
743 feparams.u.qpsk.FEC_inner=HP_CodeRate;
744 dfd = fd_sec;
745 #endif
746
747 mp_msg(MSGT_DEMUX, MSGL_V, "tuning DVB-S to Freq: %u, Pol: %c Srate: %d, 22kHz: %s, LNB: %d\n",freq,pol,srate,hi_lo ? "on" : "off", diseqc);
748
749 if(do_diseqc(dfd, diseqc, (pol == 'V' ? 1 : 0), hi_lo) == 0)
750 mp_msg(MSGT_DEMUX, MSGL_V, "DISEQC SETTING SUCCEDED\n");
751 else
752 {
753 mp_msg(MSGT_DEMUX, MSGL_ERR, "DISEQC SETTING FAILED\n");
754 return -1;
755 }
756 break;
757 case FE_QAM:
758 mp_msg(MSGT_DEMUX, MSGL_V, "tuning DVB-C to %d, srate=%d\n",freq,srate);
759 #ifdef HAVE_DVB_HEAD
760 feparams.frequency=freq;
761 feparams.inversion=specInv;
762 feparams.u.qam.symbol_rate = srate;
763 feparams.u.qam.fec_inner = HP_CodeRate;
764 feparams.u.qam.modulation = modulation;
765 #else
766 feparams.Frequency=freq;
767 feparams.Inversion=specInv;
768 feparams.u.qam.SymbolRate = srate;
769 feparams.u.qam.FEC_inner = HP_CodeRate;
770 feparams.u.qam.QAM = modulation;
771 #endif
772 break;
773 #ifdef DVB_ATSC
774 case FE_ATSC:
775 mp_msg(MSGT_DEMUX, MSGL_V, "tuning ATSC to %d, modulation=%d\n",freq,modulation);
776 feparams.frequency=freq;
777 feparams.u.vsb.modulation = modulation;
778 break;
779 #endif
780 default:
781 mp_msg(MSGT_DEMUX, MSGL_V, "Unknown FE type. Aborting\n");
782 return 0;
783 }
784 usleep(100000);
785
786 #ifndef HAVE_DVB_HEAD
787 if (fd_sec) SecGetStatus(fd_sec, &sec_state);
788 #endif
789
790 return(check_status(fd_frontend,&feparams,fe_info.type, (hi_lo ? LOF2 : LOF1), timeout));
791 }