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