MythTV  master
firewiredevice.cpp
Go to the documentation of this file.
1 
7 // C++ headers
8 #include <algorithm>
9 #include <chrono> // for milliseconds
10 #include <thread> // for sleep_for
11 
12 // Qt headers
13 #include <QMap>
14 
15 // MythTV headers
16 #include "linuxfirewiredevice.h"
17 #if USING_OSX_FIREWIRE
18 #include "darwinfirewiredevice.h"
19 #endif
20 #include "mythlogging.h"
21 #include "mpegtables.h"
22 
23 #define LOC QString("FireDev(%1): ").arg(guid_to_string(m_guid))
24 
25 static void fw_init(QMap<uint64_t,QString> &id_to_model);
26 
27 QMap<uint64_t,QString> FirewireDevice::s_idToModel;
29 
30 FirewireDevice::FirewireDevice(uint64_t guid, uint subunitid, uint speed) :
31  m_guid(guid), m_subunitid(subunitid),
32  m_speed(speed)
33 {
34 }
35 
37 {
38  if (listener)
39  {
40  auto it = find(m_listeners.begin(), m_listeners.end(), listener);
41  if (it == m_listeners.end())
42  m_listeners.push_back(listener);
43  }
44 
45  LOG(VB_RECORD, LOG_INFO, LOC +
46  QString("AddListener() %1").arg(m_listeners.size()));
47 }
48 
50 {
51  auto it = m_listeners.end();
52 
53  do
54  {
55  it = find(m_listeners.begin(), m_listeners.end(), listener);
56  if (it != m_listeners.end())
57  it = m_listeners.erase(it);
58  }
59  while (it != m_listeners.end());
60 
61  LOG(VB_RECORD, LOG_INFO, LOC +
62  QString("RemoveListener() %1").arg(m_listeners.size()));
63 }
64 
66 {
67  QMutexLocker locker(&m_lock);
68 
69  std::vector<uint8_t> cmd;
70  std::vector<uint8_t> ret;
71 
72  cmd.push_back(kAVCControlCommand);
74  cmd.push_back(kAVCUnitPowerOpcode);
75  cmd.push_back((on) ? kAVCPowerStateOn : kAVCPowerStateOff);
76 
77  QString cmdStr = (on) ? "on" : "off";
78  LOG(VB_RECORD, LOG_INFO, LOC + QString("Powering %1").arg(cmdStr));
79 
80  if (!SendAVCCommand(cmd, ret, -1))
81  {
82  LOG(VB_GENERAL, LOG_ERR, LOC + "Power on cmd failed (no response)");
83  return false;
84  }
85 
86  if (kAVCAcceptedStatus != ret[0])
87  {
88  LOG(VB_GENERAL, LOG_ERR, LOC + QString("Power %1 failed").arg(cmdStr));
89 
90  return false;
91  }
92 
93  LOG(VB_RECORD, LOG_INFO, LOC +
94  QString("Power %1 cmd sent successfully").arg(cmdStr));
95 
96  return true;
97 }
98 
100 {
101  QMutexLocker locker(&m_lock);
102 
103  std::vector<uint8_t> cmd;
104  std::vector<uint8_t> ret;
105 
106  cmd.push_back(kAVCStatusInquiryCommand);
107  cmd.push_back(kAVCSubunitTypeUnit | kAVCSubunitIdIgnore);
108  cmd.push_back(kAVCUnitPowerOpcode);
109  cmd.push_back(kAVCPowerStateQuery);
110 
111  LOG(VB_CHANNEL, LOG_INFO, LOC + "Requesting STB Power State");
112 
113  if (!SendAVCCommand(cmd, ret, -1))
114  {
115  LOG(VB_GENERAL, LOG_ERR, LOC + "Power cmd failed (no response)");
116  return kAVCPowerQueryFailed;
117  }
118 
119  QString loc = LOC + "STB Power State: ";
120 
121  if (ret[0] != kAVCResponseImplemented)
122  {
123  LOG(VB_CHANNEL, LOG_INFO, loc + "Query not implemented");
124  return kAVCPowerUnknown;
125  }
126 
127  // check 1st operand..
128  if (ret[3] == kAVCPowerStateOn)
129  {
130  LOG(VB_CHANNEL, LOG_INFO, loc + "On");
131  return kAVCPowerOn;
132  }
133 
134  if (ret[3] == kAVCPowerStateOff)
135  {
136  LOG(VB_CHANNEL, LOG_INFO, loc + "Off");
137  return kAVCPowerOff;
138  }
139 
140  LOG(VB_GENERAL, LOG_ERR, LOC + "STB Power State: Unknown Response");
141 
142  return kAVCPowerUnknown;
143 }
144 
145 bool FirewireDevice::SetChannel(const QString &panel_model,
146  uint alt_method, uint channel)
147 {
148  LOG(VB_CHANNEL, LOG_INFO, QString("SetChannel(model %1, alt %2, chan %3)")
149  .arg(panel_model).arg(alt_method).arg(channel));
150 
151  QMutexLocker locker(&m_lock);
152  LOG(VB_CHANNEL, LOG_INFO, "SetChannel() -- locked");
153 
154  if (!IsSTBSupported(panel_model))
155  {
156  LOG(VB_GENERAL, LOG_ERR, LOC +
157  QString("Model: '%1' ").arg(panel_model) +
158  "is not supported by internal channel changer.");
159  return false;
160  }
161 
162  std::array<uint,3> digit {
163  (channel % 1000) / 100,
164  (channel % 100) / 10,
165  (channel % 10)
166  };
167 
169  {
170  LOG(VB_GENERAL, LOG_ERR, LOC +
171  "SetChannel: Extended subunits are not supported.");
172 
173  return false;
174  }
175 
176  std::vector<uint8_t> cmd;
177  std::vector<uint8_t> ret;
178 
179  if ((panel_model.toUpper() == "SA GENERIC") ||
180  (panel_model.toUpper() == "SA4200HD") ||
181  (panel_model.toUpper() == "SA4250HDC"))
182  {
183  if (panel_model.toUpper() == "SA4250HDC")
184  {
185  LOG(VB_GENERAL, LOG_ERR, LOC +
186  "The Scientific Atlanta 4250 HDC is not supported "
187  "\n\t\t\tby any MythTV Firewire channel changer."
188  "At the moment you must use an IR blaster.");
189  }
190 
191  cmd.push_back(kAVCControlCommand);
192  cmd.push_back(kAVCSubunitTypePanel | m_subunitid);
193  cmd.push_back(kAVCPanelPassThrough);
195 
196  cmd.push_back(4); // operand length
197  cmd.push_back((channel>>8) & 0x0f);
198  cmd.push_back(channel & 0xff);
199  cmd.push_back(0x00);
200  cmd.push_back(0x00);
201 
202  if (!SendAVCCommand(cmd, ret, -1))
203  return false;
204 
205  bool press_ok = (kAVCAcceptedStatus == ret[0]);
206 
208  if (!SendAVCCommand(cmd, ret, -1))
209  return false;
210 
211  bool release_ok = (kAVCAcceptedStatus == ret[0]);
212 
213  if (!press_ok && !release_ok)
214  {
215  LOG(VB_GENERAL, LOG_ERR, LOC + "Tuning failed");
216  return false;
217  }
218 
219  SetLastChannel(channel);
220  return true;
221  }
222 
223  // the PACE is obviously not a Motorola channel changer, but the
224  // same commands work for it as the Motorola.
225  bool is_mot = ((panel_model.startsWith("DCT-", Qt::CaseInsensitive)) ||
226  (panel_model.startsWith("DCH-", Qt::CaseInsensitive)) ||
227  (panel_model.startsWith("DCX-", Qt::CaseInsensitive)) ||
228  (panel_model.startsWith("QIP-", Qt::CaseInsensitive)) ||
229  (panel_model.startsWith("MOTO", Qt::CaseInsensitive)) ||
230  (panel_model.startsWith("PACE-", Qt::CaseInsensitive)));
231 
232  if (is_mot && !alt_method)
233  {
234  for (uint d : digit)
235  {
236  cmd.clear();
237  cmd.push_back(kAVCControlCommand);
238  cmd.push_back(kAVCSubunitTypePanel | m_subunitid);
239  cmd.push_back(kAVCPanelPassThrough);
240  cmd.push_back((kAVCPanelKey0 + d) | kAVCPanelKeyPress);
241  cmd.push_back(0x00);
242  cmd.push_back(0x00);
243  cmd.push_back(0x00);
244  cmd.push_back(0x00);
245 
246  if (!SendAVCCommand(cmd, ret, -1))
247  return false;
248 
249  std::this_thread::sleep_for(500ms);
250  }
251 
252  SetLastChannel(channel);
253  return true;
254  }
255 
256  if (is_mot && alt_method)
257  {
258  cmd.push_back(kAVCControlCommand);
259  cmd.push_back(kAVCSubunitTypePanel | m_subunitid);
260  cmd.push_back(kAVCPanelPassThrough);
262 
263  cmd.push_back(4); // operand length
264  cmd.push_back((channel>>8) & 0x0f);
265  cmd.push_back(channel & 0xff);
266  cmd.push_back(0x00);
267  cmd.push_back(0xff);
268 
269  if (!SendAVCCommand(cmd, ret, -1))
270  return false;
271 
272  SetLastChannel(channel);
273  return true;
274  }
275 
276  if (panel_model.toUpper() == "SA3250HD")
277  {
278  cmd.push_back(kAVCControlCommand);
279  cmd.push_back(kAVCSubunitTypePanel | m_subunitid);
280  cmd.push_back(kAVCPanelPassThrough);
282 
283  cmd.push_back(4); // operand length
284  cmd.push_back(0x30 | digit[2]);
285  cmd.push_back(0x30 | digit[1]);
286  cmd.push_back(0x30 | digit[0]);
287  cmd.push_back(0xff);
288 
289  if (!SendAVCCommand(cmd, ret, -1))
290  return false;
291 
292  cmd[5] = 0x30 | digit[0];
293  cmd[6] = 0x30 | digit[1];
294  cmd[7] = 0x30 | digit[2];
295 
296  if (!SendAVCCommand(cmd, ret, -1))
297  return false;
298 
299  SetLastChannel(channel);
300  return true;
301  }
302 
303  return false;
304 }
305 
307  const unsigned char *data, uint dataSize)
308 {
309  if ((dataSize >= TSPacket::kSize) && (data[0] == SYNC_BYTE) &&
310  ((data[1] & 0x1f) == 0) && (data[2] == 0))
311  {
312  ProcessPATPacket(*(reinterpret_cast<const TSPacket*>(data)));
313  }
314 
315  for (auto & listener : m_listeners)
316  listener->AddData(data, dataSize);
317 }
318 
320 {
321  m_bufferCleared = (channel == m_lastChannel);
322  m_lastChannel = channel;
323 
324  LOG(VB_GENERAL, LOG_INFO, QString("SetLastChannel(%1): cleared: %2")
325  .arg(channel).arg(m_bufferCleared ? "yes" : "no"));
326 }
327 
329 {
330  if (!tspacket.TransportError() && !tspacket.Scrambled() &&
331  tspacket.HasPayload() && tspacket.PayloadStart() && (tspacket.PID() == 0))
332  {
333  PSIPTable pes(tspacket);
334  uint crc = pes.CalcCRC();
335  m_bufferCleared |= (crc != m_lastCrc);
336  m_lastCrc = crc;
337 #if 0
338  LOG(VB_RECORD, LOG_DEBUG, LOC +
339  QString("ProcessPATPacket: CRC 0x%1 cleared: %2")
340  .arg(crc,0,16).arg(m_bufferCleared ? "yes" : "no"));
341 #endif
342  }
343  else
344  {
345  LOG(VB_GENERAL, LOG_ERR, LOC + "Can't handle large PAT's");
346  }
347 }
348 
349 QString FirewireDevice::GetModelName(uint vendor_id, uint model_id)
350 {
351  QMutexLocker locker(&s_staticLock);
352  if (s_idToModel.empty())
354 
355  QString ret = s_idToModel[(((uint64_t) vendor_id) << 32) | model_id];
356 
357  if (ret.isEmpty())
358  return "MOTO GENERIC";
359  return ret;
360 }
361 
362 std::vector<AVCInfo> FirewireDevice::GetSTBList(void)
363 {
364  std::vector<AVCInfo> list;
365 
366 #ifdef USING_LINUX_FIREWIRE
368 #elif USING_OSX_FIREWIRE
370 #endif
371 
372 //#define DEBUG_AVC_INFO
373 #ifdef DEBUG_AVC_INFO
374  AVCInfo info;
375  info.guid = 0x0016928a7b600001ULL;
376  info.specid = 0x0;
377  info.vendorid = 0x000014f8;
378  info.modelid = 0x00001072;
379  info.firmware_revision = 0x0;
380  info.product_name = "Explorer 4200 HD";
381  list.push_back(info);
382 
383  info.guid = 0xff2145a850e39810ULL;
384  info.specid = 0x0;
385  info.vendorid = 0x000014f8;
386  info.modelid = 0x00000be0;
387  info.firmware_revision = 0x0;
388  info.product_name = "Explorer 3250 HD";
389  list.push_back(info);
390 #endif // DEBUG_AVC_INFO
391 
392  return list;
393 }
394 
395 static void fw_init(QMap<uint64_t,QString> &id_to_model)
396 {
397  const std::array<const uint64_t,16> sa_vendor_ids
398  {
399  0x0a73, 0x0f21, 0x11e6, 0x14f8, 0x1692, 0x1868,
400  0x1947, 0x1ac3, 0x1bd7, 0x1cea, 0x1e6b, 0x21be,
401  0x223a, 0x22ce, 0x23be, 0x252e,
402  };
403 
404  for (uint64_t vendor_id : sa_vendor_ids)
405  {
406  id_to_model[vendor_id << 32 | 0x0be0] = "SA3250HD";
407  id_to_model[vendor_id << 32 | 0x1072] = "SA4200HD";
408  id_to_model[vendor_id << 32 | 0x10cc] = "SA4250HDC";
409  id_to_model[vendor_id << 32 | 0x22ce] = "SA8300HD";
410  }
411 
412  const std::array<uint64_t,59> motorola_vendor_ids
413  {
414  /* DCH-3200, DCX-3200 */
415  0x1c11, 0x1cfb, 0x1fc4, 0x23a3, 0x23ee, 0x25f1,
416  0xfa01, 0x25f1, 0x25f2, 0xcc7d37, 0x946269, 0x6455b1,
417  /* DCX-3432 */
418  0x24a0,
419  /* DCH-3416 */
420  0x1e46,
421  /* DCT-3416 */
422  0x1bdd,
423  /* DCT-3412 */
424  0x159a,
425  /* DCT-6200, DCT-3416 */
426  0x0ce5, 0x0e5c, 0x1225, 0x0f9f, 0x1180,
427  0x12c9, 0x11ae, 0x152f, 0x14e8, 0x16b5, 0x1371,
428  0x19a6, 0x1aad, 0x0b06, 0x195e, 0x10dc,
429  /* DCT-6212 */
430  0x0f9f, 0x152f,
431  /* DCT-6216, 2224 */
432  0x17ee, 0x1a66,
433  /* QIP 6200 */
434  0x211e,
435  /* QIP 7100 */
436  0x2374,
437  /* unknown, see http://standards.ieee.org/regauth/oui/oui.txt */
438  0x04db, 0x0406, 0x0ce5, 0x111a, 0x1225, 0x1404,
439  0x1626, 0x18c0, 0x1ade, 0x1cfb, 0x2040, 0x2180,
440  0x2210, 0x230b, 0x2375, 0x2395, 0x23a2, 0x23ed,
441  0x23ee, 0x23a0, 0x23a1,
442  };
443 
444  for (uint64_t vendor_id : motorola_vendor_ids)
445  {
446  id_to_model[vendor_id << 32 | 0xf740] = "DCX-3200";
447  id_to_model[vendor_id << 32 | 0xf804] = "DCX-3200";
448  id_to_model[vendor_id << 32 | 0xfa03] = "DCX-3200";
449  id_to_model[vendor_id << 32 | 0xfa05] = "DCX-3200";
450  id_to_model[vendor_id << 32 | 0xfa07] = "DCX-3200";
451  id_to_model[vendor_id << 32 | 0x24a1] = "DCX-3200";
452  id_to_model[vendor_id << 32 | 0x2322] = "DCX-3200";
453  id_to_model[vendor_id << 32 | 0xea05] = "DCX-3432";
454  id_to_model[vendor_id << 32 | 0xd330] = "DCH-3200";
455  id_to_model[vendor_id << 32 | 0xb630] = "DCH-3416";
456  id_to_model[vendor_id << 32 | 0x34cb] = "DCT-3412";
457  id_to_model[vendor_id << 32 | 0x346b] = "DCT-3416";
458  id_to_model[vendor_id << 32 | 0xb630] = "DCT-3416";
459  id_to_model[vendor_id << 32 | 0x6200] = "DCT-6200";
460  id_to_model[vendor_id << 32 | 0x620a] = "DCT-6200";
461  id_to_model[vendor_id << 32 | 0x64ca] = "DCT-6212";
462  id_to_model[vendor_id << 32 | 0x64cb] = "DCT-6212";
463  id_to_model[vendor_id << 32 | 0x646b] = "DCT-6216";
464  id_to_model[vendor_id << 32 | 0x8100] = "QIP-7100";
465  id_to_model[vendor_id << 32 | 0x7100] = "QIP-6200";
466  id_to_model[vendor_id << 32 | 0x0001] = "QIP-7100";
467  }
468 
469  const std::array<const uint64_t,2> pace_vendor_ids
470  {
471  /* PACE 550-HD & 779 */
472  0x1cc3, 0x5094,
473  };
474 
475  for (uint64_t vendor_id : pace_vendor_ids)
476  {
477  id_to_model[vendor_id << 32 | 0x10551] = "PACE-550";
478  id_to_model[vendor_id << 32 | 0x10755] = "PACE-779";
479  }
480 }
481 
482 bool FirewireDevice::IsSTBSupported(const QString &panel_model)
483 {
484  QString model = panel_model.toUpper();
485  return ((model == "DCH-3200") ||
486  (model == "DCH-3416") ||
487  (model == "DCT-3412") ||
488  (model == "DCT-3416") ||
489  (model == "DCT-6200") ||
490  (model == "DCT-6212") ||
491  (model == "DCT-6216") ||
492  (model == "DCX-3200") ||
493  (model == "SA3250HD") ||
494  (model == "SA4200HD") ||
495  (model == "SA4250HDC") ||
496  (model == "SA8300HD") ||
497  (model == "PACE-550") ||
498  (model == "PACE-779") ||
499  (model == "QIP-6200") ||
500  (model == "QIP-7100") ||
501  (model == "SA GENERIC") ||
502  (model == "MOTO GENERIC"));
503 }
linuxfirewiredevice.h
TSHeader::PayloadStart
bool PayloadStart(void) const
Definition: tspacket.h:70
FirewireDevice::kAVCPowerStateOff
@ kAVCPowerStateOff
Definition: firewiredevice.h:123
FirewireDevice::kAVCPanelKeyTuneFunction
@ kAVCPanelKeyTuneFunction
Definition: firewiredevice.h:185
FirewireDevice::RemoveListener
virtual void RemoveListener(TSDataListener *listener)
Definition: firewiredevice.cpp:49
FirewireDevice::m_lastCrc
uint m_lastCrc
Definition: firewiredevice.h:234
FirewireDevice::m_bufferCleared
bool m_bufferCleared
Definition: firewiredevice.h:235
FirewireDevice::kAVCPowerOn
@ kAVCPowerOn
Definition: firewiredevice.h:30
FirewireDevice::kAVCPowerStateOn
@ kAVCPowerStateOn
Definition: firewiredevice.h:122
FirewireDevice::FirewireDevice
FirewireDevice(uint64_t guid, uint subunitid, uint speed)
Definition: firewiredevice.cpp:30
FirewireDevice::GetModelName
static QString GetModelName(uint vendor_id, uint model_id)
Definition: firewiredevice.cpp:349
darwinfirewiredevice.h
LinuxFirewireDevice::GetSTBList
static std::vector< AVCInfo > GetSTBList(void)
Definition: linuxfirewiredevice.cpp:799
TSHeader::PID
unsigned int PID(void) const
Definition: tspacket.h:74
FirewireDevice::kAVCAcceptedStatus
@ kAVCAcceptedStatus
Definition: firewiredevice.h:46
FirewireDevice::AddListener
virtual void AddListener(TSDataListener *listener)
Definition: firewiredevice.cpp:36
PESPacket::CalcCRC
uint CalcCRC(void) const
Definition: pespacket.cpp:162
FirewireDevice::kAVCPanelKey0
@ kAVCPanelKey0
Definition: firewiredevice.h:144
LOG
#define LOG(_MASK_, _LEVEL_, _QSTRING_)
Definition: mythlogging.h:23
FirewireDevice::ProcessPATPacket
void ProcessPATPacket(const TSPacket &tspacket)
Definition: firewiredevice.cpp:328
TSHeader::Scrambled
bool Scrambled(void) const
Definition: tspacket.h:93
TSDataListener
Definition: streamlisteners.h:52
FirewireDevice::SendAVCCommand
virtual bool SendAVCCommand(const std::vector< uint8_t > &cmd, std::vector< uint8_t > &result, int retry_cnt)=0
FirewireDevice::kAVCSubunitIdIgnore
@ kAVCSubunitIdIgnore
Definition: firewiredevice.h:65
FirewireDevice::GetSTBList
static std::vector< AVCInfo > GetSTBList(void)
Definition: firewiredevice.cpp:362
AVCInfo
Definition: avcinfo.h:22
SYNC_BYTE
#define SYNC_BYTE
Definition: tspacket.h:16
FirewireDevice::PowerState
PowerState
Definition: firewiredevice.h:28
FirewireDevice::kAVCControlCommand
@ kAVCControlCommand
Definition: firewiredevice.h:39
FirewireDevice::kAVCPanelPassThrough
@ kAVCPanelPassThrough
Definition: firewiredevice.h:116
PSIPTable
A PSIP table is a variant of a PES packet containing an MPEG, ATSC or DVB table.
Definition: mpegtables.h:409
DarwinFirewireDevice::GetSTBList
static std::vector< AVCInfo > GetSTBList(void)
Definition: darwinfirewiredevice.cpp:608
mythlogging.h
TSPacket
Used to access the data of a Transport Stream packet.
Definition: tspacket.h:169
FirewireDevice::kAVCPanelKeyRelease
@ kAVCPanelKeyRelease
Definition: firewiredevice.h:188
FirewireDevice::kAVCPanelKeyPress
@ kAVCPanelKeyPress
Definition: firewiredevice.h:187
mpegtables.h
fw_init
static void fw_init(QMap< uint64_t, QString > &id_to_model)
Definition: firewiredevice.cpp:395
FirewireDevice::kAVCResponseImplemented
@ kAVCResponseImplemented
Definition: firewiredevice.h:53
uint
unsigned int uint
Definition: compat.h:140
FirewireDevice::IsSTBSupported
static bool IsSTBSupported(const QString &model)
Definition: firewiredevice.cpp:482
FirewireDevice::BroadcastToListeners
virtual void BroadcastToListeners(const unsigned char *data, uint dataSize)
Definition: firewiredevice.cpp:306
FirewireDevice::s_idToModel
static QMap< uint64_t, QString > s_idToModel
Vendor ID + Model ID to FirewireDevice STB model string.
Definition: firewiredevice.h:242
FirewireDevice::kAVCPowerUnknown
@ kAVCPowerUnknown
Definition: firewiredevice.h:32
FirewireDevice::kAVCStatusInquiryCommand
@ kAVCStatusInquiryCommand
Definition: firewiredevice.h:40
FirewireDevice::m_subunitid
uint m_subunitid
Definition: firewiredevice.h:231
FirewireDevice::SetLastChannel
void SetLastChannel(uint channel)
Definition: firewiredevice.cpp:319
FirewireDevice::m_lastChannel
uint m_lastChannel
Definition: firewiredevice.h:233
FirewireDevice::kAVCPowerQueryFailed
@ kAVCPowerQueryFailed
Definition: firewiredevice.h:33
FirewireDevice::s_staticLock
static QMutex s_staticLock
Definition: firewiredevice.h:243
FirewireDevice::kAVCSubunitIdExtended
@ kAVCSubunitIdExtended
Definition: firewiredevice.h:64
FirewireDevice::m_listeners
std::vector< TSDataListener * > m_listeners
Definition: firewiredevice.h:238
TSHeader::HasPayload
bool HasPayload(void) const
Definition: tspacket.h:97
FirewireDevice::kAVCSubunitTypePanel
@ kAVCSubunitTypePanel
Definition: firewiredevice.h:75
FirewireDevice::kAVCPowerStateQuery
@ kAVCPowerStateQuery
Definition: firewiredevice.h:124
FirewireDevice::kAVCUnitPowerOpcode
@ kAVCUnitPowerOpcode
Definition: firewiredevice.h:102
FirewireDevice::GetPowerState
virtual PowerState GetPowerState(void)
Definition: firewiredevice.cpp:99
d
static const iso6937table * d
Definition: iso6937tables.cpp:1025
FirewireDevice::SetChannel
virtual bool SetChannel(const QString &panel_model, uint alt_method, uint channel)
Definition: firewiredevice.cpp:145
FirewireDevice::kAVCPowerOff
@ kAVCPowerOff
Definition: firewiredevice.h:31
FirewireDevice::SetPowerState
virtual bool SetPowerState(bool on)
Definition: firewiredevice.cpp:65
FirewireDevice::m_lock
QMutex m_lock
Definition: firewiredevice.h:239
FirewireDevice::kAVCSubunitTypeUnit
@ kAVCSubunitTypeUnit
Definition: firewiredevice.h:81
find
static pid_list_t::iterator find(const PIDInfoMap &map, pid_list_t &list, pid_list_t::iterator begin, pid_list_t::iterator end, bool find_open)
Definition: dvbstreamhandler.cpp:356
TSHeader::TransportError
bool TransportError(void) const
Definition: tspacket.h:67
TSPacket::kSize
static constexpr unsigned int kSize
Definition: tspacket.h:223
LOC
#define LOC
FirewireDevice Copyright (c) 2005 by Jim Westfall Distributed as part of MythTV under GPL v2 and late...
Definition: firewiredevice.cpp:23