• Skip to content
  • Skip to link menu
KDE API Reference
  • KDE API Reference
  • graphics API Reference
  • KDE Home
  • Contact Us
 

digikam

  • extragear
  • graphics
  • digikam
  • core
  • dplugins
  • generic
  • tools
  • mediaserver
  • upnpsdk
  • Platinum
  • Source
  • Devices
  • MediaRenderer
PltMediaController.cpp
Go to the documentation of this file.
1 /*****************************************************************
2 |
3 | Platinum - AV Media Controller (Media Renderer Control Point)
4 |
5 | Copyright (c) 2004-2010, Plutinosoft, LLC.
6 | All rights reserved.
7 | http://www.plutinosoft.com
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 | OEMs, ISVs, VARs and other distributors that combine and
15 | distribute commercially licensed software with Platinum software
16 | and do not wish to distribute the source code for the commercially
17 | licensed software under version 2, or (at your option) any later
18 | version, of the GNU General Public License (the "GPL") must enter
19 | into a commercial license agreement with Plutinosoft, LLC.
20 | [email protected]
21 |
22 | This program is distributed in the hope that it will be useful,
23 | but WITHOUT ANY WARRANTY; without even the implied warranty of
24 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
25 | GNU General Public License for more details.
26 |
27 | You should have received a copy of the GNU General Public License
28 | along with this program; see the file LICENSE.txt. If not, write to
29 | the Free Software Foundation, Inc.,
30 | 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
31 | http://www.gnu.org/licenses/gpl-2.0.html
32 |
33 ****************************************************************/
34 
35 /*----------------------------------------------------------------------
36 | includes
37 +---------------------------------------------------------------------*/
38 #include "Neptune.h"
39 #include "PltMediaController.h"
40 #include "PltDidl.h"
41 #include "PltDeviceData.h"
42 #include "PltUtilities.h"
43 
44 NPT_SET_LOCAL_LOGGER("platinum.media.renderer.controller")
45 
46 /*----------------------------------------------------------------------
47 | PLT_MediaController::PLT_MediaController
48 +---------------------------------------------------------------------*/
49 PLT_MediaController::PLT_MediaController(PLT_CtrlPointReference& ctrl_point,
50  PLT_MediaControllerDelegate* delegate /* = NULL */) :
51  m_CtrlPoint(ctrl_point),
52  m_Delegate(delegate)
53 {
54  m_CtrlPoint->AddListener(this);
55 }
56 
57 /*----------------------------------------------------------------------
58 | PLT_MediaController::~PLT_MediaController
59 +---------------------------------------------------------------------*/
60 PLT_MediaController::~PLT_MediaController()
61 {
62  m_CtrlPoint->RemoveListener(this);
63 }
64 
65 /*----------------------------------------------------------------------
66 | PLT_MediaController::OnDeviceAdded
67 +---------------------------------------------------------------------*/
68 NPT_Result
69 PLT_MediaController::OnDeviceAdded(PLT_DeviceDataReference& device)
70 {
71  // verify the device implements the function we need
72  PLT_Service* serviceAVT = NULL;
73  PLT_Service* serviceCMR;
74  PLT_Service* serviceRC;
75  NPT_String type;
76 
77  if (!device->GetType().StartsWith("urn:schemas-upnp-org:device:MediaRenderer"))
78  return NPT_FAILURE;
79 
80  // optional service
81  type = "urn:schemas-upnp-org:service:AVTransport:*";
82  if (NPT_SUCCEEDED(device->FindServiceByType(type, serviceAVT))) {
83  // in case it's a newer upnp implementation, force to 1
84  NPT_LOG_FINE_1("Service %s found", (const char*)type);
85  serviceAVT->ForceVersion(1);
86  }
87 
88  // required services
89  type = "urn:schemas-upnp-org:service:ConnectionManager:*";
90  if (NPT_FAILED(device->FindServiceByType(type, serviceCMR))) {
91  NPT_LOG_FINE_1("Service %s not found", (const char*)type);
92  return NPT_FAILURE;
93  } else {
94  // in case it's a newer upnp implementation, force to 1
95  serviceCMR->ForceVersion(1);
96  }
97 
98  type = "urn:schemas-upnp-org:service:RenderingControl:*";
99  if (NPT_FAILED(device->FindServiceByType(type, serviceRC))) {
100  NPT_LOG_FINE_1("Service %s not found", (const char*)type);
101  return NPT_FAILURE;
102  } else {
103  // in case it's a newer upnp implementation, force to 1
104  serviceRC->ForceVersion(1);
105  }
106 
107  {
108  NPT_AutoLock lock(m_MediaRenderers);
109 
110  PLT_DeviceDataReference data;
111  NPT_String uuid = device->GetUUID();
112 
113  // is it a new device?
114  if (NPT_SUCCEEDED(NPT_ContainerFind(m_MediaRenderers,
115  PLT_DeviceDataFinder(uuid), data))) {
116  NPT_LOG_WARNING_1("Device (%s) is already in our list!", (const char*)uuid);
117  return NPT_FAILURE;
118  }
119 
120  NPT_LOG_FINE_1("Device Found: %s", (const char*)*device);
121 
122  m_MediaRenderers.Add(device);
123  }
124 
125  if (m_Delegate && m_Delegate->OnMRAdded(device)) {
126  // subscribe to services eventing only if delegate wants it
127  if (serviceAVT) m_CtrlPoint->Subscribe(serviceAVT);
128 
129  // subscribe to required services
130  m_CtrlPoint->Subscribe(serviceCMR);
131  m_CtrlPoint->Subscribe(serviceRC);
132  }
133 
134  return NPT_SUCCESS;
135 }
136 
137 /*----------------------------------------------------------------------
138 | PLT_MediaController::OnDeviceRemoved
139 +---------------------------------------------------------------------*/
140 NPT_Result
141 PLT_MediaController::OnDeviceRemoved(PLT_DeviceDataReference& device)
142 {
143  if (!device->GetType().StartsWith("urn:schemas-upnp-org:device:MediaRenderer"))
144  return NPT_FAILURE;
145 
146  {
147  NPT_AutoLock lock(m_MediaRenderers);
148 
149  // only release if we have kept it around
150  PLT_DeviceDataReference data;
151  NPT_String uuid = device->GetUUID();
152 
153  // Have we seen that device?
154  if (NPT_FAILED(NPT_ContainerFind(m_MediaRenderers, PLT_DeviceDataFinder(uuid), data))) {
155  NPT_LOG_WARNING_1("Device (%s) not found in our list!", (const char*)uuid);
156  return NPT_FAILURE;
157  }
158 
159  NPT_LOG_FINE_1("Device Removed: %s", (const char*)*device);
160 
161  m_MediaRenderers.Remove(device);
162  }
163 
164  if (m_Delegate) {
165  m_Delegate->OnMRRemoved(device);
166  }
167 
168  return NPT_SUCCESS;
169 }
170 
171 /*----------------------------------------------------------------------
172 | PLT_MediaController::FindRenderer
173 +---------------------------------------------------------------------*/
174 NPT_Result
175 PLT_MediaController::FindRenderer(const char* uuid, PLT_DeviceDataReference& device)
176 {
177  NPT_AutoLock lock(m_MediaRenderers);
178 
179  if (NPT_FAILED(NPT_ContainerFind(m_MediaRenderers, PLT_DeviceDataFinder(uuid), device))) {
180  NPT_LOG_FINE_1("Device (%s) not found in our list of renderers", (const char*)uuid);
181  return NPT_FAILURE;
182  }
183 
184  return NPT_SUCCESS;
185 }
186 
187 /*----------------------------------------------------------------------
188 | PLT_MediaController::GetProtocolInfoSink
189 +---------------------------------------------------------------------*/
190 NPT_Result
191 PLT_MediaController::GetProtocolInfoSink(const NPT_String& device_uuid,
192  NPT_List<NPT_String>& sinks)
193 {
194  PLT_DeviceDataReference renderer;
195  NPT_CHECK_WARNING(FindRenderer(device_uuid, renderer));
196 
197  // look for ConnectionManager service
198  PLT_Service* serviceCMR;
199  NPT_CHECK_SEVERE(renderer->FindServiceByType("urn:schemas-upnp-org:service:ConnectionManager:*",
200  serviceCMR));
201 
202  NPT_String value;
203  NPT_CHECK_SEVERE(serviceCMR->GetStateVariableValue("SinkProtocolInfo",
204  value));
205 
206  sinks = value.Split(",");
207  return NPT_SUCCESS;
208 }
209 
210 /*----------------------------------------------------------------------
211 | PLT_MediaController::GetTransportState
212 +---------------------------------------------------------------------*/
213 NPT_Result
214 PLT_MediaController::GetTransportState(const NPT_String& device_uuid,
215  NPT_String& state)
216 {
217  PLT_DeviceDataReference renderer;
218  NPT_CHECK_WARNING(FindRenderer(device_uuid, renderer));
219 
220  // look for AVTransport service
221  PLT_Service* serviceAVT;
222  NPT_CHECK_SEVERE(renderer->FindServiceByType("urn:schemas-upnp-org:service:AVTransport:*",
223  serviceAVT));
224 
225  NPT_CHECK_SEVERE(serviceAVT->GetStateVariableValue("TransportState",
226  state));
227 
228  return NPT_SUCCESS;
229 }
230 
231 /*----------------------------------------------------------------------
232 | PLT_MediaController::GetVolumeState
233 +---------------------------------------------------------------------*/
234 NPT_Result
235 PLT_MediaController::GetVolumeState(const NPT_String& device_uuid,
236  NPT_UInt32& volume)
237 {
238  PLT_DeviceDataReference renderer;
239  NPT_CHECK_WARNING(FindRenderer(device_uuid, renderer));
240 
241  // look for RenderingControl service
242  PLT_Service* serviceRC;
243  NPT_CHECK_SEVERE(renderer->FindServiceByType("urn:schemas-upnp-org:service:RenderingControl:*",
244  serviceRC));
245 
246  NPT_String value;
247  NPT_CHECK_SEVERE(serviceRC->GetStateVariableValue("Volume",
248  value));
249 
250  return value.ToInteger32(volume);
251 }
252 
253 /*----------------------------------------------------------------------
254 | PLT_MediaController::FindMatchingProtocolInfo
255 +---------------------------------------------------------------------*/
256 NPT_Result
257 PLT_MediaController::FindMatchingProtocolInfo(NPT_List<NPT_String>& sinks,
258  const char* protocol_info)
259 {
260  PLT_ProtocolInfo protocol(protocol_info);
261  for (NPT_List<NPT_String>::Iterator iter = sinks.GetFirstItem();
262  iter;
263  iter++) {
264  PLT_ProtocolInfo sink(*iter);
265  if (sink.Match(protocol)) {
266  return NPT_SUCCESS;
267  }
268  }
269 
270  return NPT_ERROR_NO_SUCH_ITEM;
271 }
272 
273 /*----------------------------------------------------------------------
274 | PLT_MediaController::FindBestResource
275 +---------------------------------------------------------------------*/
276 NPT_Result
277 PLT_MediaController::FindBestResource(PLT_DeviceDataReference& device,
278  PLT_MediaObject& item,
279  NPT_Cardinal& resource_index)
280 {
281  if (item.m_Resources.GetItemCount() <= 0) return NPT_ERROR_INVALID_PARAMETERS;
282 
283  NPT_List<NPT_String> sinks;
284  NPT_CHECK_SEVERE(GetProtocolInfoSink(device->GetUUID(), sinks));
285 
286  // look for best resource
287  for (NPT_Cardinal i=0; i< item.m_Resources.GetItemCount(); i++) {
288  if (NPT_SUCCEEDED(FindMatchingProtocolInfo(
289  sinks,
290  item.m_Resources[i].m_ProtocolInfo.ToString()))) {
291  resource_index = i;
292  return NPT_SUCCESS;
293  }
294  }
295 
296  return NPT_ERROR_NO_SUCH_ITEM;
297 }
298 
299 /*----------------------------------------------------------------------
300 | PLT_MediaController::InvokeActionWithInstance
301 +---------------------------------------------------------------------*/
302 NPT_Result
303 PLT_MediaController::InvokeActionWithInstance(PLT_ActionReference& action,
304  NPT_UInt32 instance_id,
305  void* userdata)
306 {
307  // Set the object id
308  NPT_CHECK_SEVERE(action->SetArgumentValue(
309  "InstanceID",
310  NPT_String::FromInteger(instance_id)));
311 
312  // set the arguments on the action, this will check the argument values
313  return m_CtrlPoint->InvokeAction(action, userdata);
314 }
315 
316 /*----------------------------------------------------------------------
317 | PLT_MediaController::GetCurrentTransportActions
318 +---------------------------------------------------------------------*/
319 NPT_Result
320 PLT_MediaController::GetCurrentTransportActions(PLT_DeviceDataReference& device,
321  NPT_UInt32 instance_id,
322  void* userdata)
323 {
324  PLT_ActionReference action;
325  NPT_CHECK_SEVERE(m_CtrlPoint->CreateAction(
326  device,
327  "urn:schemas-upnp-org:service:AVTransport:1",
328  "GetCurrentTransportActions",
329  action));
330  return InvokeActionWithInstance(action, instance_id, userdata);
331 }
332 
333 /*----------------------------------------------------------------------
334 | PLT_MediaController::GetDeviceCapabilities
335 +---------------------------------------------------------------------*/
336 NPT_Result
337 PLT_MediaController::GetDeviceCapabilities(PLT_DeviceDataReference& device,
338  NPT_UInt32 instance_id,
339  void* userdata)
340 {
341  PLT_ActionReference action;
342  NPT_CHECK_SEVERE(m_CtrlPoint->CreateAction(
343  device,
344  "urn:schemas-upnp-org:service:AVTransport:1",
345  "GetDeviceCapabilities",
346  action));
347  return InvokeActionWithInstance(action, instance_id, userdata);
348 }
349 
350 /*----------------------------------------------------------------------
351 | PLT_MediaController::GetMediaInfo
352 +---------------------------------------------------------------------*/
353 NPT_Result
354 PLT_MediaController::GetMediaInfo(PLT_DeviceDataReference& device,
355  NPT_UInt32 instance_id,
356  void* userdata)
357 {
358  PLT_ActionReference action;
359  NPT_CHECK_SEVERE(m_CtrlPoint->CreateAction(
360  device,
361  "urn:schemas-upnp-org:service:AVTransport:1",
362  "GetMediaInfo",
363  action));
364  return InvokeActionWithInstance(action, instance_id, userdata);
365 }
366 
367 /*----------------------------------------------------------------------
368 | PLT_MediaController::GetPositionInfo
369 +---------------------------------------------------------------------*/
370 NPT_Result
371 PLT_MediaController::GetPositionInfo(PLT_DeviceDataReference& device,
372  NPT_UInt32 instance_id,
373  void* userdata)
374 {
375  PLT_ActionReference action;
376  NPT_CHECK_SEVERE(m_CtrlPoint->CreateAction(
377  device,
378  "urn:schemas-upnp-org:service:AVTransport:1",
379  "GetPositionInfo",
380  action));
381  return InvokeActionWithInstance(action, instance_id, userdata);
382 }
383 
384 /*----------------------------------------------------------------------
385 | PLT_MediaController::GetTransportInfo
386 +---------------------------------------------------------------------*/
387 NPT_Result
388 PLT_MediaController::GetTransportInfo(PLT_DeviceDataReference& device,
389  NPT_UInt32 instance_id,
390  void* userdata)
391 {
392  PLT_ActionReference action;
393  NPT_CHECK_SEVERE(m_CtrlPoint->CreateAction(
394  device,
395  "urn:schemas-upnp-org:service:AVTransport:1",
396  "GetTransportInfo",
397  action));
398  return InvokeActionWithInstance(action, instance_id, userdata);
399 }
400 
401 /*----------------------------------------------------------------------
402 | PLT_MediaController::GetTransportSettings
403 +---------------------------------------------------------------------*/
404 NPT_Result
405 PLT_MediaController::GetTransportSettings(PLT_DeviceDataReference& device,
406  NPT_UInt32 instance_id,
407  void* userdata)
408 {
409  PLT_ActionReference action;
410  NPT_CHECK_SEVERE(m_CtrlPoint->CreateAction(
411  device,
412  "urn:schemas-upnp-org:service:AVTransport:1",
413  "GetTransportSettings",
414  action));
415  return InvokeActionWithInstance(action, instance_id, userdata);
416 }
417 
418 /*----------------------------------------------------------------------
419 | PLT_MediaController::Next
420 +---------------------------------------------------------------------*/
421 NPT_Result
422 PLT_MediaController::Next(PLT_DeviceDataReference& device,
423  NPT_UInt32 instance_id,
424  void* userdata)
425 {
426  PLT_ActionReference action;
427  NPT_CHECK_SEVERE(m_CtrlPoint->CreateAction(
428  device,
429  "urn:schemas-upnp-org:service:AVTransport:1",
430  "Next",
431  action));
432  return InvokeActionWithInstance(action, instance_id, userdata);
433 }
434 
435 /*----------------------------------------------------------------------
436 | PLT_MediaController::Pause
437 +---------------------------------------------------------------------*/
438 NPT_Result
439 PLT_MediaController::Pause(PLT_DeviceDataReference& device,
440  NPT_UInt32 instance_id,
441  void* userdata)
442 {
443  PLT_ActionReference action;
444  NPT_CHECK_SEVERE(m_CtrlPoint->CreateAction(
445  device,
446  "urn:schemas-upnp-org:service:AVTransport:1",
447  "Pause",
448  action));
449  return InvokeActionWithInstance(action, instance_id, userdata);
450 }
451 
452 /*----------------------------------------------------------------------
453 | PLT_MediaController::Play
454 +---------------------------------------------------------------------*/
455 NPT_Result
456 PLT_MediaController::Play(PLT_DeviceDataReference& device,
457  NPT_UInt32 instance_id,
458  NPT_String speed,
459  void* userdata)
460 {
461  PLT_ActionReference action;
462  NPT_CHECK_SEVERE(m_CtrlPoint->CreateAction(
463  device,
464  "urn:schemas-upnp-org:service:AVTransport:1",
465  "Play",
466  action));
467 
468  // Set the speed
469  if (NPT_FAILED(action->SetArgumentValue("Speed", speed))) {
470  return NPT_ERROR_INVALID_PARAMETERS;
471  }
472 
473  return InvokeActionWithInstance(action, instance_id, userdata);
474 }
475 
476 /*----------------------------------------------------------------------
477 | PLT_MediaController::Previous
478 +---------------------------------------------------------------------*/
479 NPT_Result
480 PLT_MediaController::Previous(PLT_DeviceDataReference& device,
481  NPT_UInt32 instance_id,
482  void* userdata)
483 {
484  PLT_ActionReference action;
485  NPT_CHECK_SEVERE(m_CtrlPoint->CreateAction(
486  device,
487  "urn:schemas-upnp-org:service:AVTransport:1",
488  "Previous",
489  action));
490  return InvokeActionWithInstance(action, instance_id, userdata);
491 }
492 
493 /*----------------------------------------------------------------------
494 | PLT_MediaController::Seek
495 +---------------------------------------------------------------------*/
496 NPT_Result
497 PLT_MediaController::Seek(PLT_DeviceDataReference& device,
498  NPT_UInt32 instance_id,
499  NPT_String unit,
500  NPT_String target,
501  void* userdata)
502 {
503  PLT_ActionReference action;
504  NPT_CHECK_SEVERE(m_CtrlPoint->CreateAction(
505  device,
506  "urn:schemas-upnp-org:service:AVTransport:1",
507  "Seek",
508  action));
509 
510  // Set the unit
511  if (NPT_FAILED(action->SetArgumentValue("Unit", unit))) {
512  return NPT_ERROR_INVALID_PARAMETERS;
513  }
514 
515  // Set the target
516  if (NPT_FAILED(action->SetArgumentValue("Target", target))) {
517  return NPT_ERROR_INVALID_PARAMETERS;
518  }
519 
520  return InvokeActionWithInstance(action, instance_id, userdata);
521 }
522 
523 /*----------------------------------------------------------------------
524 | PLT_MediaController::CanSetNextAVTransportURI
525 +---------------------------------------------------------------------*/
526 bool
527 PLT_MediaController::CanSetNextAVTransportURI(PLT_DeviceDataReference &device)
528 {
529  if (device.IsNull()) return false;
530 
531  PLT_ActionDesc* action_desc;
532  NPT_Result result = m_CtrlPoint->FindActionDesc(device,
533  "urn:schemas-upnp-org:service:AVTransport:1",
534  "SetNextAVTransportURI",
535  action_desc);
536  return (result == NPT_SUCCESS);
537 }
538 
539 /*----------------------------------------------------------------------
540 | PLT_MediaController::SetAVTransportURI
541 +---------------------------------------------------------------------*/
542 NPT_Result
543 PLT_MediaController::SetAVTransportURI(PLT_DeviceDataReference& device,
544  NPT_UInt32 instance_id,
545  const char* uri,
546  const char* metadata,
547  void* userdata)
548 {
549  PLT_ActionReference action;
550  NPT_CHECK_SEVERE(m_CtrlPoint->CreateAction(
551  device,
552  "urn:schemas-upnp-org:service:AVTransport:1",
553  "SetAVTransportURI",
554  action));
555 
556  // set the uri
557  if (NPT_FAILED(action->SetArgumentValue("CurrentURI", uri))) {
558  return NPT_ERROR_INVALID_PARAMETERS;
559  }
560 
561  // set the uri metadata
562  if (NPT_FAILED(action->SetArgumentValue("CurrentURIMetaData", metadata))) {
563  return NPT_ERROR_INVALID_PARAMETERS;
564  }
565 
566  return InvokeActionWithInstance(action, instance_id, userdata);
567 }
568 
569 /*----------------------------------------------------------------------
570 | PLT_MediaController::SetNextAVTransportURI
571 +---------------------------------------------------------------------*/
572 NPT_Result
573 PLT_MediaController::SetNextAVTransportURI(PLT_DeviceDataReference& device,
574  NPT_UInt32 instance_id,
575  const char* next_uri,
576  const char* next_metadata,
577  void* userdata)
578 {
579  PLT_ActionReference action;
580  NPT_CHECK_SEVERE(m_CtrlPoint->CreateAction(device,
581  "urn:schemas-upnp-org:service:AVTransport:1",
582  "SetNextAVTransportURI",
583  action));
584 
585  // set the uri
586  if (NPT_FAILED(action->SetArgumentValue("NextURI", next_uri))) {
587  return NPT_ERROR_INVALID_PARAMETERS;
588  }
589 
590  // set the uri metadata
591  if (NPT_FAILED(action->SetArgumentValue("NextURIMetaData", next_metadata))) {
592  return NPT_ERROR_INVALID_PARAMETERS;
593  }
594 
595  return InvokeActionWithInstance(action, instance_id, userdata);
596 }
597 
598 /*----------------------------------------------------------------------
599 | PLT_MediaController::SetPlayMode
600 +---------------------------------------------------------------------*/
601 NPT_Result
602 PLT_MediaController::SetPlayMode(PLT_DeviceDataReference& device,
603  NPT_UInt32 instance_id,
604  NPT_String new_play_mode,
605  void* userdata)
606 {
607  PLT_ActionReference action;
608  NPT_CHECK_SEVERE(m_CtrlPoint->CreateAction(
609  device,
610  "urn:schemas-upnp-org:service:AVTransport:1",
611  "SetPlayMode",
612  action));
613 
614  // set the New PlayMode
615  if (NPT_FAILED(action->SetArgumentValue("NewPlayMode", new_play_mode))) {
616  return NPT_ERROR_INVALID_PARAMETERS;
617  }
618 
619  return InvokeActionWithInstance(action, instance_id, userdata);
620 }
621 
622 /*----------------------------------------------------------------------
623 | PLT_MediaController::Stop
624 +---------------------------------------------------------------------*/
625 NPT_Result
626 PLT_MediaController::Stop(PLT_DeviceDataReference& device,
627  NPT_UInt32 instance_id,
628  void* userdata)
629 {
630  PLT_ActionReference action;
631  NPT_CHECK_SEVERE(m_CtrlPoint->CreateAction(
632  device,
633  "urn:schemas-upnp-org:service:AVTransport:1",
634  "Stop",
635  action));
636  return InvokeActionWithInstance(action, instance_id, userdata);
637 }
638 
639 /*----------------------------------------------------------------------
640 | PLT_MediaController::GetCurrentConnectionIDs
641 +---------------------------------------------------------------------*/
642 NPT_Result
643 PLT_MediaController::GetCurrentConnectionIDs(PLT_DeviceDataReference& device,
644  void* userdata)
645 {
646  PLT_ActionReference action;
647  NPT_CHECK_SEVERE(m_CtrlPoint->CreateAction(
648  device,
649  "urn:schemas-upnp-org:service:ConnectionManager:1",
650  "GetCurrentConnectionIDs",
651  action));
652 
653  // set the arguments on the action, this will check the argument values
654  if (NPT_FAILED(m_CtrlPoint->InvokeAction(action, userdata))) {
655  return NPT_ERROR_INVALID_PARAMETERS;
656  }
657 
658  return NPT_SUCCESS;
659 }
660 
661 /*----------------------------------------------------------------------
662 | PLT_MediaController::GetCurrentConnectionInfo
663 +---------------------------------------------------------------------*/
664 NPT_Result
665 PLT_MediaController::GetCurrentConnectionInfo(PLT_DeviceDataReference& device,
666  NPT_UInt32 connection_id,
667  void* userdata)
668 {
669  PLT_ActionReference action;
670  NPT_CHECK_SEVERE(m_CtrlPoint->CreateAction(
671  device,
672  "urn:schemas-upnp-org:service:ConnectionManager:1",
673  "GetCurrentConnectionInfo",
674  action));
675 
676  // set the New PlayMode
677  if (NPT_FAILED(action->SetArgumentValue("ConnectionID",
678  NPT_String::FromInteger(connection_id)))) {
679  return NPT_ERROR_INVALID_PARAMETERS;
680  }
681 
682  // set the arguments on the action, this will check the argument values
683  if (NPT_FAILED(m_CtrlPoint->InvokeAction(action, userdata))) {
684  return NPT_ERROR_INVALID_PARAMETERS;
685  }
686 
687  return NPT_SUCCESS;
688 }
689 
690 /*----------------------------------------------------------------------
691 | PLT_MediaController::GetProtocolInfo
692 +---------------------------------------------------------------------*/
693 NPT_Result
694 PLT_MediaController::GetProtocolInfo(PLT_DeviceDataReference& device,
695  void* userdata)
696 {
697  PLT_ActionReference action;
698  NPT_CHECK_SEVERE(m_CtrlPoint->CreateAction(
699  device,
700  "urn:schemas-upnp-org:service:ConnectionManager:1",
701  "GetProtocolInfo",
702  action));
703 
704  // set the arguments on the action, this will check the argument values
705  if (NPT_FAILED(m_CtrlPoint->InvokeAction(action, userdata))) {
706  return NPT_ERROR_INVALID_PARAMETERS;
707  }
708 
709  return NPT_SUCCESS;
710 }
711 
712 /*----------------------------------------------------------------------
713 | PLT_MediaController::SetMute
714 +---------------------------------------------------------------------*/
715 NPT_Result
716 PLT_MediaController::SetMute(PLT_DeviceDataReference& device,
717  NPT_UInt32 instance_id,
718  const char* channel,
719  bool mute,
720  void* userdata)
721 {
722  PLT_ActionReference action;
723  NPT_CHECK_SEVERE(m_CtrlPoint->CreateAction(
724  device,
725  "urn:schemas-upnp-org:service:RenderingControl:1",
726  "SetMute",
727  action));
728 
729  // set the channel
730  if (NPT_FAILED(action->SetArgumentValue("Channel", channel))) {
731  return NPT_ERROR_INVALID_PARAMETERS;
732  }
733 
734  // set the channel
735  if (NPT_FAILED(action->SetArgumentValue("DesiredMute",
736  mute?"1":"0"))) {
737  return NPT_ERROR_INVALID_PARAMETERS;
738  }
739 
740  return InvokeActionWithInstance(action, instance_id, userdata);
741 }
742 
743 /*----------------------------------------------------------------------
744 | PLT_MediaController::SetVolume
745 +---------------------------------------------------------------------*/
746 NPT_Result PLT_MediaController::SetVolume(PLT_DeviceDataReference& device,
747  NPT_UInt32 instance_id,
748  const char* channel,
749  int volume,
750  void* userdata)
751 {
752 
753  PLT_ActionReference action;
754  NPT_CHECK_SEVERE(m_CtrlPoint->CreateAction(
755  device,
756  "urn:schemas-upnp-org:service:RenderingControl:1",
757  "SetVolume",
758  action));
759 
760  // set the channel
761  if (NPT_FAILED(action->SetArgumentValue("Channel", channel))) {
762  return NPT_ERROR_INVALID_PARAMETERS;
763  }
764 
765  if (NPT_FAILED(action->SetArgumentValue("DesiredVolume",
766  NPT_String::FromInteger(volume)))) {
767  return NPT_ERROR_INVALID_PARAMETERS;
768  }
769 
770  return InvokeActionWithInstance(action, instance_id, userdata);
771 }
772 
773 /*----------------------------------------------------------------------
774 | PLT_MediaController::GetMute
775 +---------------------------------------------------------------------*/
776 NPT_Result
777 PLT_MediaController::GetMute(PLT_DeviceDataReference& device,
778  NPT_UInt32 instance_id,
779  const char* channel,
780  void* userdata)
781 {
782  PLT_ActionReference action;
783  NPT_CHECK_SEVERE(m_CtrlPoint->CreateAction(
784  device,
785  "urn:schemas-upnp-org:service:RenderingControl:1",
786  "GetMute",
787  action));
788 
789  // set the channel
790  if (NPT_FAILED(action->SetArgumentValue("Channel", channel))) {
791  return NPT_ERROR_INVALID_PARAMETERS;
792  }
793 
794  return InvokeActionWithInstance(action, instance_id, userdata);
795 }
796 
797 /*----------------------------------------------------------------------
798 | PLT_MediaController::GetVolume
799 +---------------------------------------------------------------------*/
800 NPT_Result PLT_MediaController::GetVolume(PLT_DeviceDataReference& device,
801  NPT_UInt32 instance_id,
802  const char* channel,
803  void* userdata)
804 {
805  PLT_ActionReference action;
806  NPT_CHECK_SEVERE(m_CtrlPoint->CreateAction(
807  device,
808  "urn:schemas-upnp-org:service:RenderingControl:1",
809  "GetVolume",
810  action));
811 
812  // set the channel
813  if (NPT_FAILED(action->SetArgumentValue("Channel", channel))) {
814  return NPT_ERROR_INVALID_PARAMETERS;
815  }
816 
817  return InvokeActionWithInstance(action, instance_id, userdata);
818 }
819 
820 /*----------------------------------------------------------------------
821 | PLT_MediaController::OnActionResponse
822 +---------------------------------------------------------------------*/
823 NPT_Result
824 PLT_MediaController::OnActionResponse(NPT_Result res,
825  PLT_ActionReference& action,
826  void* userdata)
827 {
828  if (m_Delegate == NULL) return NPT_SUCCESS;
829 
830  PLT_DeviceDataReference device;
831  NPT_String uuid = action->GetActionDesc().GetService()->GetDevice()->GetUUID();
832 
833  /* extract action name */
834  NPT_String actionName = action->GetActionDesc().GetName();
835 
836  /* AVTransport response ? */
837  if (actionName.Compare("GetCurrentTransportActions", true) == 0) {
838  if (NPT_FAILED(FindRenderer(uuid, device))) res = NPT_FAILURE;
839  return OnGetCurrentTransportActionsResponse(res, device, action, userdata);
840  }
841  else if (actionName.Compare("GetDeviceCapabilities", true) == 0) {
842  if (NPT_FAILED(FindRenderer(uuid, device))) res = NPT_FAILURE;
843  return OnGetDeviceCapabilitiesResponse(res, device, action, userdata);
844  }
845  else if (actionName.Compare("GetMediaInfo", true) == 0) {
846  if (NPT_FAILED(FindRenderer(uuid, device))) res = NPT_FAILURE;
847  return OnGetMediaInfoResponse(res, device, action, userdata);
848  }
849  else if (actionName.Compare("GetPositionInfo", true) == 0) {
850  if (NPT_FAILED(FindRenderer(uuid, device))) res = NPT_FAILURE;
851  return OnGetPositionInfoResponse(res, device, action, userdata);
852  }
853  else if (actionName.Compare("GetTransportInfo", true) == 0) {
854  if (NPT_FAILED(FindRenderer(uuid, device))) res = NPT_FAILURE;
855  return OnGetTransportInfoResponse(res, device, action, userdata);
856  }
857  else if (actionName.Compare("GetTransportSettings", true) == 0) {
858  if (NPT_FAILED(FindRenderer(uuid, device))) res = NPT_FAILURE;
859  return OnGetTransportSettingsResponse(res, device, action, userdata);
860  }
861  else if (actionName.Compare("Next", true) == 0) {
862  if (NPT_FAILED(FindRenderer(uuid, device))) res = NPT_FAILURE;
863  m_Delegate->OnNextResult(res, device, userdata);
864  }
865  else if (actionName.Compare("Pause", true) == 0) {
866  if (NPT_FAILED(FindRenderer(uuid, device))) res = NPT_FAILURE;
867  m_Delegate->OnPauseResult(res, device, userdata);
868  }
869  else if (actionName.Compare("Play", true) == 0) {
870  if (NPT_FAILED(FindRenderer(uuid, device))) res = NPT_FAILURE;
871  m_Delegate->OnPlayResult(res, device, userdata);
872  }
873  else if (actionName.Compare("Previous", true) == 0) {
874  if (NPT_FAILED(FindRenderer(uuid, device))) res = NPT_FAILURE;
875  m_Delegate->OnPreviousResult(res, device, userdata);
876  }
877  else if (actionName.Compare("Seek", true) == 0) {
878  if (NPT_FAILED(FindRenderer(uuid, device))) res = NPT_FAILURE;
879  m_Delegate->OnSeekResult(res, device, userdata);
880  }
881  else if (actionName.Compare("SetAVTransportURI", true) == 0) {
882  if (NPT_FAILED(FindRenderer(uuid, device))) res = NPT_FAILURE;
883  m_Delegate->OnSetAVTransportURIResult(res, device, userdata);
884  }
885  else if (actionName.Compare("SetNextAVTransportURI", true) == 0) {
886  if (NPT_FAILED(FindRenderer(uuid, device))) res = NPT_FAILURE;
887  m_Delegate->OnSetNextAVTransportURIResult(res, device, userdata);
888  }
889  else if (actionName.Compare("SetPlayMode", true) == 0) {
890  if (NPT_FAILED(FindRenderer(uuid, device))) res = NPT_FAILURE;
891  m_Delegate->OnSetPlayModeResult(res, device, userdata);
892  }
893  else if (actionName.Compare("Stop", true) == 0) {
894  if (NPT_FAILED(FindRenderer(uuid, device))) res = NPT_FAILURE;
895  m_Delegate->OnStopResult(res, device, userdata);
896  }
897  else if (actionName.Compare("GetCurrentConnectionIDs", true) == 0) {
898  if (NPT_FAILED(FindRenderer(uuid, device))) res = NPT_FAILURE;
899  return OnGetCurrentConnectionIDsResponse(res, device, action, userdata);
900  }
901  else if (actionName.Compare("GetCurrentConnectionInfo", true) == 0) {
902  if (NPT_FAILED(FindRenderer(uuid, device))) res = NPT_FAILURE;
903  return OnGetCurrentConnectionInfoResponse(res, device, action, userdata);
904  }
905  else if (actionName.Compare("GetProtocolInfo", true) == 0) {
906  if (NPT_FAILED(FindRenderer(uuid, device))) res = NPT_FAILURE;
907  return OnGetProtocolInfoResponse(res, device, action, userdata);
908  }
909  else if (actionName.Compare("SetMute", true) == 0) {
910  if (NPT_FAILED(FindRenderer(uuid, device))) res = NPT_FAILURE;
911  m_Delegate->OnSetMuteResult(res, device, userdata);
912  }
913  else if (actionName.Compare("GetMute", true) == 0) {
914  if (NPT_FAILED(FindRenderer(uuid, device))) res = NPT_FAILURE;
915  return OnGetMuteResponse(res, device, action, userdata);
916  }
917  else if (actionName.Compare("SetVolume", true) == 0) {
918  if (NPT_FAILED(FindRenderer(uuid, device))) res = NPT_FAILURE;
919  m_Delegate->OnSetVolumeResult(res, device, userdata);
920  }
921  else if (actionName.Compare("GetVolume", true) == 0) {
922  if (NPT_FAILED(FindRenderer(uuid, device))) res = NPT_FAILURE;
923  return OnGetVolumeResponse(res, device, action, userdata);
924  }
925 
926  return NPT_SUCCESS;
927 }
928 
929 /*----------------------------------------------------------------------
930 | PLT_MediaController::OnGetCurrentTransportActionsResponse
931 +---------------------------------------------------------------------*/
932 NPT_Result
933 PLT_MediaController::OnGetCurrentTransportActionsResponse(NPT_Result res,
934  PLT_DeviceDataReference& device,
935  PLT_ActionReference& action,
936  void* userdata)
937 {
938  NPT_String actions;
939  PLT_StringList values;
940 
941  if (NPT_FAILED(res) || action->GetErrorCode() != 0) {
942  goto bad_action;
943  }
944 
945  if (NPT_FAILED(action->GetArgumentValue("Actions", actions))) {
946  goto bad_action;
947  }
948 
949  // parse the list of actions and return a list to listener
950  ParseCSV(actions, values);
951 
952  m_Delegate->OnGetCurrentTransportActionsResult(NPT_SUCCESS, device, &values, userdata);
953  return NPT_SUCCESS;
954 
955 bad_action:
956  m_Delegate->OnGetCurrentTransportActionsResult(NPT_FAILURE, device, NULL, userdata);
957  return NPT_FAILURE;
958 }
959 
960 /*----------------------------------------------------------------------
961 | PLT_MediaController::OnGetDeviceCapabilitiesResponse
962 +---------------------------------------------------------------------*/
963 NPT_Result
964 PLT_MediaController::OnGetDeviceCapabilitiesResponse(NPT_Result res,
965  PLT_DeviceDataReference& device,
966  PLT_ActionReference& action,
967  void* userdata)
968 {
969  NPT_String value;
970  PLT_DeviceCapabilities capabilities;
971 
972  if (NPT_FAILED(res) || action->GetErrorCode() != 0) {
973  goto bad_action;
974  }
975 
976  if (NPT_FAILED(action->GetArgumentValue("PlayMedia", value))) {
977  goto bad_action;
978  }
979  // parse the list of medias and return a list to listener
980  ParseCSV(value, capabilities.play_media);
981 
982  if (NPT_FAILED(action->GetArgumentValue("RecMedia", value))) {
983  goto bad_action;
984  }
985  // parse the list of rec and return a list to listener
986  ParseCSV(value, capabilities.rec_media);
987 
988  if (NPT_FAILED(action->GetArgumentValue("RecQualityModes", value))) {
989  goto bad_action;
990  }
991  // parse the list of modes and return a list to listener
992  ParseCSV(value, capabilities.rec_quality_modes);
993 
994  m_Delegate->OnGetDeviceCapabilitiesResult(NPT_SUCCESS, device, &capabilities, userdata);
995  return NPT_SUCCESS;
996 
997 bad_action:
998  m_Delegate->OnGetDeviceCapabilitiesResult(NPT_FAILURE, device, NULL, userdata);
999  return NPT_FAILURE;
1000 }
1001 
1002 /*----------------------------------------------------------------------
1003 | PLT_MediaController::OnGetMediaInfoResponse
1004 +---------------------------------------------------------------------*/
1005 NPT_Result
1006 PLT_MediaController::OnGetMediaInfoResponse(NPT_Result res,
1007  PLT_DeviceDataReference& device,
1008  PLT_ActionReference& action,
1009  void* userdata)
1010 {
1011  NPT_String value;
1012  PLT_MediaInfo info;
1013 
1014  if (NPT_FAILED(res) || action->GetErrorCode() != 0) {
1015  goto bad_action;
1016  }
1017 
1018  if (NPT_FAILED(action->GetArgumentValue("NrTracks", info.num_tracks))) {
1019  goto bad_action;
1020  }
1021  if (NPT_FAILED(action->GetArgumentValue("MediaDuration", value))) {
1022  goto bad_action;
1023  }
1024  if (NPT_FAILED(PLT_Didl::ParseTimeStamp(value, info.media_duration))) {
1025  goto bad_action;
1026  }
1027 
1028  if (NPT_FAILED(action->GetArgumentValue("CurrentURI", info.cur_uri))) {
1029  goto bad_action;
1030  }
1031  if (NPT_FAILED(action->GetArgumentValue("CurrentURIMetaData", info.cur_metadata))) {
1032  goto bad_action;
1033  }
1034  if (NPT_FAILED(action->GetArgumentValue("NextURI", info.next_uri))) {
1035  goto bad_action;
1036  }
1037  if (NPT_FAILED(action->GetArgumentValue("NextURIMetaData", info.next_metadata))) {
1038  goto bad_action;
1039  }
1040  if (NPT_FAILED(action->GetArgumentValue("PlayMedium", info.play_medium))) {
1041  goto bad_action;
1042  }
1043  if (NPT_FAILED(action->GetArgumentValue("RecordMedium", info.rec_medium))) {
1044  goto bad_action;
1045  }
1046  if (NPT_FAILED(action->GetArgumentValue("WriteStatus", info.write_status))) {
1047  goto bad_action;
1048  }
1049 
1050  m_Delegate->OnGetMediaInfoResult(NPT_SUCCESS, device, &info, userdata);
1051  return NPT_SUCCESS;
1052 
1053 bad_action:
1054  m_Delegate->OnGetMediaInfoResult(NPT_FAILURE, device, NULL, userdata);
1055  return NPT_FAILURE;
1056 }
1057 
1058 /*----------------------------------------------------------------------
1059 | PLT_MediaController::OnGetPositionInfoResponse
1060 +---------------------------------------------------------------------*/
1061 NPT_Result
1062 PLT_MediaController::OnGetPositionInfoResponse(NPT_Result res,
1063  PLT_DeviceDataReference& device,
1064  PLT_ActionReference& action,
1065  void* userdata)
1066 {
1067  NPT_String value;
1068  PLT_PositionInfo info;
1069 
1070  if (NPT_FAILED(res) || action->GetErrorCode() != 0) {
1071  goto bad_action;
1072  }
1073 
1074  if (NPT_FAILED(action->GetArgumentValue("Track", info.track))) {
1075  goto bad_action;
1076  }
1077 
1078  if (NPT_FAILED(action->GetArgumentValue("TrackDuration", value))) {
1079  goto bad_action;
1080  }
1081  if (NPT_FAILED(PLT_Didl::ParseTimeStamp(value, info.track_duration))) {
1082  // some renderers return garbage sometimes
1083  info.track_duration = NPT_TimeStamp(0.);
1084  }
1085 
1086  if (NPT_FAILED(action->GetArgumentValue("TrackMetaData", info.track_metadata))) {
1087  goto bad_action;
1088  }
1089 
1090  if (NPT_FAILED(action->GetArgumentValue("TrackURI", info.track_uri))) {
1091  goto bad_action;
1092  }
1093 
1094  if (NPT_FAILED(action->GetArgumentValue("RelTime", value))) {
1095  goto bad_action;
1096  }
1097 
1098  // NOT_IMPLEMENTED is a valid value according to spec
1099  if (value != "NOT_IMPLEMENTED" && NPT_FAILED(PLT_Didl::ParseTimeStamp(value, info.rel_time))) {
1100  // some dogy renderers return garbage sometimes
1101  info.rel_time = NPT_TimeStamp(-1.0f);
1102  }
1103 
1104  if (NPT_FAILED(action->GetArgumentValue("AbsTime", value))) {
1105  goto bad_action;
1106  }
1107 
1108  // NOT_IMPLEMENTED is a valid value according to spec
1109  if (value != "NOT_IMPLEMENTED" && NPT_FAILED(PLT_Didl::ParseTimeStamp(value, info.abs_time))) {
1110  // some dogy renderers return garbage sometimes
1111  info.abs_time = NPT_TimeStamp(-1.0f);
1112  }
1113 
1114  if (NPT_FAILED(action->GetArgumentValue("RelCount", info.rel_count))) {
1115  goto bad_action;
1116  }
1117  if (NPT_FAILED(action->GetArgumentValue("AbsCount", info.abs_count))) {
1118  goto bad_action;
1119  }
1120 
1121  m_Delegate->OnGetPositionInfoResult(NPT_SUCCESS, device, &info, userdata);
1122  return NPT_SUCCESS;
1123 
1124 bad_action:
1125  m_Delegate->OnGetPositionInfoResult(NPT_FAILURE, device, NULL, userdata);
1126  return NPT_FAILURE;
1127 }
1128 
1129 /*----------------------------------------------------------------------
1130 | PLT_MediaController::OnGetTransportInfoResponse
1131 +---------------------------------------------------------------------*/
1132 NPT_Result
1133 PLT_MediaController::OnGetTransportInfoResponse(NPT_Result res,
1134  PLT_DeviceDataReference& device,
1135  PLT_ActionReference& action,
1136  void* userdata)
1137 {
1138  PLT_TransportInfo info;
1139 
1140  if (NPT_FAILED(res) || action->GetErrorCode() != 0) {
1141  goto bad_action;
1142  }
1143 
1144  if (NPT_FAILED(action->GetArgumentValue("CurrentTransportState", info.cur_transport_state))) {
1145  goto bad_action;
1146  }
1147  if (NPT_FAILED(action->GetArgumentValue("CurrentTransportStatus", info.cur_transport_status))) {
1148  goto bad_action;
1149  }
1150  if (NPT_FAILED(action->GetArgumentValue("CurrentSpeed", info.cur_speed))) {
1151  goto bad_action;
1152  }
1153 
1154  m_Delegate->OnGetTransportInfoResult(NPT_SUCCESS, device, &info, userdata);
1155  return NPT_SUCCESS;
1156 
1157 bad_action:
1158  m_Delegate->OnGetTransportInfoResult(NPT_FAILURE, device, NULL, userdata);
1159  return NPT_FAILURE;
1160 }
1161 
1162 /*----------------------------------------------------------------------
1163 | PLT_MediaController::OnGetTransportSettingsResponse
1164 +---------------------------------------------------------------------*/
1165 NPT_Result
1166 PLT_MediaController::OnGetTransportSettingsResponse(NPT_Result res,
1167  PLT_DeviceDataReference& device,
1168  PLT_ActionReference& action,
1169  void* userdata)
1170 {
1171  PLT_TransportSettings settings;
1172 
1173  if (NPT_FAILED(res) || action->GetErrorCode() != 0) {
1174  goto bad_action;
1175  }
1176 
1177  if (NPT_FAILED(action->GetArgumentValue("PlayMode", settings.play_mode))) {
1178  goto bad_action;
1179  }
1180  if (NPT_FAILED(action->GetArgumentValue("RecQualityMode", settings.rec_quality_mode))) {
1181  goto bad_action;
1182  }
1183 
1184  m_Delegate->OnGetTransportSettingsResult(NPT_SUCCESS, device, &settings, userdata);
1185  return NPT_SUCCESS;
1186 
1187 bad_action:
1188  m_Delegate->OnGetTransportSettingsResult(NPT_FAILURE, device, NULL, userdata);
1189  return NPT_FAILURE;
1190 }
1191 
1192 /*----------------------------------------------------------------------
1193 | PLT_MediaController::OnGetCurrentConnectionIDsResponse
1194 +---------------------------------------------------------------------*/
1195 NPT_Result
1196 PLT_MediaController::OnGetCurrentConnectionIDsResponse(NPT_Result res,
1197  PLT_DeviceDataReference& device,
1198  PLT_ActionReference& action,
1199  void* userdata)
1200 {
1201  NPT_String value;
1202  PLT_StringList IDs;
1203 
1204  if (NPT_FAILED(res) || action->GetErrorCode() != 0) {
1205  goto bad_action;
1206  }
1207 
1208  if (NPT_FAILED(action->GetArgumentValue("ConnectionIDs", value))) {
1209  goto bad_action;
1210  }
1211  // parse the list of medias and return a list to listener
1212  ParseCSV(value, IDs);
1213 
1214  m_Delegate->OnGetCurrentConnectionIDsResult(NPT_SUCCESS, device, &IDs, userdata);
1215  return NPT_SUCCESS;
1216 
1217 bad_action:
1218  m_Delegate->OnGetCurrentConnectionIDsResult(NPT_FAILURE, device, NULL, userdata);
1219  return NPT_FAILURE;
1220 }
1221 
1222 /*----------------------------------------------------------------------
1223 | PLT_MediaController::OnGetCurrentConnectionInfoResponse
1224 +---------------------------------------------------------------------*/
1225 NPT_Result
1226 PLT_MediaController::OnGetCurrentConnectionInfoResponse(NPT_Result res,
1227  PLT_DeviceDataReference& device,
1228  PLT_ActionReference& action,
1229  void* userdata)
1230 {
1231  NPT_String value;
1232  PLT_ConnectionInfo info;
1233 
1234  if (NPT_FAILED(res) || action->GetErrorCode() != 0) {
1235  goto bad_action;
1236  }
1237 
1238  if (NPT_FAILED(action->GetArgumentValue("RcsID", info.rcs_id))) {
1239  goto bad_action;
1240  }
1241  if (NPT_FAILED(action->GetArgumentValue("AVTransportID", info.avtransport_id))) {
1242  goto bad_action;
1243  }
1244  if (NPT_FAILED(action->GetArgumentValue("ProtocolInfo", info.protocol_info))) {
1245  goto bad_action;
1246  }
1247  if (NPT_FAILED(action->GetArgumentValue("PeerConnectionManager", info.peer_connection_mgr))) {
1248  goto bad_action;
1249  }
1250  if (NPT_FAILED(action->GetArgumentValue("PeerConnectionID", info.peer_connection_id))) {
1251  goto bad_action;
1252  }
1253  if (NPT_FAILED(action->GetArgumentValue("Direction", info.direction))) {
1254  goto bad_action;
1255  }
1256  if (NPT_FAILED(action->GetArgumentValue("Status", info.status))) {
1257  goto bad_action;
1258  }
1259  m_Delegate->OnGetCurrentConnectionInfoResult(NPT_SUCCESS, device, &info, userdata);
1260  return NPT_SUCCESS;
1261 
1262 bad_action:
1263  m_Delegate->OnGetCurrentConnectionInfoResult(NPT_FAILURE, device, NULL, userdata);
1264  return NPT_FAILURE;
1265 }
1266 
1267 /*----------------------------------------------------------------------
1268 | PLT_MediaController::OnGetProtocolInfoResponse
1269 +---------------------------------------------------------------------*/
1270 NPT_Result
1271 PLT_MediaController::OnGetProtocolInfoResponse(NPT_Result res,
1272  PLT_DeviceDataReference& device,
1273  PLT_ActionReference& action,
1274  void* userdata)
1275 {
1276  NPT_String source_info, sink_info;
1277  PLT_StringList sources, sinks;
1278 
1279  if (NPT_FAILED(res) || action->GetErrorCode() != 0) {
1280  goto bad_action;
1281  }
1282 
1283  if (NPT_FAILED(action->GetArgumentValue("Source", source_info))) {
1284  goto bad_action;
1285  }
1286  ParseCSV(source_info, sources);
1287 
1288  if (NPT_FAILED(action->GetArgumentValue("Sink", sink_info))) {
1289  goto bad_action;
1290  }
1291  ParseCSV(sink_info, sinks);
1292 
1293  m_Delegate->OnGetProtocolInfoResult(NPT_SUCCESS, device, &sources, &sinks, userdata);
1294  return NPT_SUCCESS;
1295 
1296 bad_action:
1297  m_Delegate->OnGetProtocolInfoResult(NPT_FAILURE, device, NULL, NULL, userdata);
1298  return NPT_FAILURE;
1299 }
1300 
1301 /*----------------------------------------------------------------------
1302 | PLT_MediaController::OnGetMuteResponse
1303 +---------------------------------------------------------------------*/
1304 NPT_Result
1305 PLT_MediaController::OnGetMuteResponse(NPT_Result res,
1306  PLT_DeviceDataReference& device,
1307  PLT_ActionReference& action,
1308  void* userdata)
1309 {
1310  NPT_String channel, mute;
1311 
1312  if (NPT_FAILED(res) || action->GetErrorCode() != 0) {
1313  goto bad_action;
1314  }
1315 
1316  if (NPT_FAILED(action->GetArgumentValue("Channel", channel))) {
1317  goto bad_action;
1318  }
1319 
1320  if (NPT_FAILED(action->GetArgumentValue("CurrentMute", mute))) {
1321  goto bad_action;
1322  }
1323 
1324  m_Delegate->OnGetMuteResult(
1325  NPT_SUCCESS,
1326  device,
1327  channel,
1328  PLT_Service::IsTrue(mute)?true:false,
1329  userdata);
1330  return NPT_SUCCESS;
1331 
1332 bad_action:
1333  m_Delegate->OnGetMuteResult(NPT_FAILURE, device, "", false, userdata);
1334  return NPT_FAILURE;
1335 }
1336 
1337 /*----------------------------------------------------------------------
1338 | PLT_MediaController::OnGetVolumeResponse
1339 +---------------------------------------------------------------------*/
1340 NPT_Result
1341 PLT_MediaController::OnGetVolumeResponse(NPT_Result res,
1342  PLT_DeviceDataReference& device,
1343  PLT_ActionReference& action,
1344  void* userdata)
1345 {
1346  NPT_String channel;
1347  NPT_String current_volume;
1348  NPT_UInt32 volume;
1349 
1350  if (NPT_FAILED(res) || action->GetErrorCode() != 0) {
1351  goto bad_action;
1352  }
1353 
1354  if (NPT_FAILED(action->GetArgumentValue("Channel", channel))) {
1355  goto bad_action;
1356  }
1357 
1358  if (NPT_FAILED(action->GetArgumentValue("CurrentVolume", current_volume))) {
1359  goto bad_action;
1360  }
1361 
1362  if (NPT_FAILED(current_volume.ToInteger(volume))) {
1363  goto bad_action;
1364  }
1365 
1366  m_Delegate->OnGetVolumeResult(NPT_SUCCESS, device, channel, volume, userdata);
1367  return NPT_SUCCESS;
1368 
1369 bad_action:
1370  m_Delegate->OnGetVolumeResult(NPT_FAILURE, device, "", 0, userdata);
1371  return NPT_FAILURE;
1372 }
1373 
1374 /*----------------------------------------------------------------------
1375 | PLT_MediaController::OnEventNotify
1376 +---------------------------------------------------------------------*/
1377 NPT_Result
1378 PLT_MediaController::OnEventNotify(PLT_Service* service,
1379  NPT_List<PLT_StateVariable*>* vars)
1380 {
1381  if (!service->GetDevice()->GetType().StartsWith("urn:schemas-upnp-org:device:MediaRenderer"))
1382  return NPT_FAILURE;
1383 
1384  if (!m_Delegate) return NPT_SUCCESS;
1385 
1386  /* make sure device associated to service is still around */
1387  PLT_DeviceDataReference data;
1388  NPT_CHECK_WARNING(FindRenderer(service->GetDevice()->GetUUID(), data));
1389 
1390  m_Delegate->OnMRStateVariablesChanged(service, vars);
1391  return NPT_SUCCESS;
1392 }
PLT_MediaController::SetAVTransportURI
NPT_Result SetAVTransportURI(PLT_DeviceDataReference &device, NPT_UInt32 instance_id, const char *uri, const char *metadata, void *userdata)
Definition: PltMediaController.cpp:543
PLT_MediaControllerDelegate::OnGetCurrentConnectionInfoResult
virtual void OnGetCurrentConnectionInfoResult(NPT_Result, PLT_DeviceDataReference &, PLT_ConnectionInfo *, void *)
Definition: PltMediaController.h:201
PLT_MediaInfo::cur_metadata
NPT_String cur_metadata
Definition: PltMediaController.h:59
PLT_MediaControllerDelegate::OnMRAdded
virtual bool OnMRAdded(PLT_DeviceDataReference &)
Definition: PltMediaController.h:107
PLT_MediaController::GetProtocolInfoSink
virtual NPT_Result GetProtocolInfoSink(const NPT_String &device_uuid, NPT_List< NPT_String > &sinks)
Definition: PltMediaController.cpp:191
NPT_SUCCESS
#define NPT_SUCCESS
Result indicating that the operation or call succeeded.
Definition: NptResults.h:104
PLT_MediaController::GetMute
NPT_Result GetMute(PLT_DeviceDataReference &device, NPT_UInt32 instance_id, const char *channel, void *userdata)
Definition: PltMediaController.cpp:777
PltDidl.h
UPnP AV Didl.
PltMediaController.h
PLT_PositionInfo::track_duration
NPT_TimeStamp track_duration
Definition: PltMediaController.h:69
PLT_ConnectionInfo::peer_connection_id
NPT_UInt32 peer_connection_id
Definition: PltMediaController.h:94
PLT_MediaControllerDelegate::OnSetMuteResult
virtual void OnSetMuteResult(NPT_Result, PLT_DeviceDataReference &, void *)
Definition: PltMediaController.h:215
PLT_MediaInfo::write_status
NPT_String write_status
Definition: PltMediaController.h:64
PLT_DeviceDataFinder
The PLT_DeviceDataFinder class returns a PLT_DeviceData instance given a device UUID.
Definition: PltDeviceData.h:221
PLT_MediaController::GetCurrentTransportActions
NPT_Result GetCurrentTransportActions(PLT_DeviceDataReference &device, NPT_UInt32 instance_id, void *userdata)
Definition: PltMediaController.cpp:320
PLT_MediaControllerDelegate::OnPreviousResult
virtual void OnPreviousResult(NPT_Result, PLT_DeviceDataReference &, void *)
Definition: PltMediaController.h:164
PLT_MediaController::GetDeviceCapabilities
NPT_Result GetDeviceCapabilities(PLT_DeviceDataReference &device, NPT_UInt32 instance_id, void *userdata)
Definition: PltMediaController.cpp:337
NPT_SET_LOCAL_LOGGER
#define NPT_SET_LOCAL_LOGGER(_name)
Definition: NptLogging.h:283
PLT_MediaController::Next
NPT_Result Next(PLT_DeviceDataReference &device, NPT_UInt32 instance_id, void *userdata)
Definition: PltMediaController.cpp:422
PLT_CtrlPoint::Subscribe
virtual NPT_Result Subscribe(PLT_Service *service, bool cancel=false, void *userdata=NULL)
Definition: PltCtrlPoint.cpp:1503
PLT_MediaController::GetCurrentConnectionIDs
NPT_Result GetCurrentConnectionIDs(PLT_DeviceDataReference &device, void *userdata)
Definition: PltMediaController.cpp:643
NPT_String::FromInteger
static NPT_String FromInteger(NPT_Int64 value)
Definition: NptStrings.cpp:71
PLT_ProtocolInfo
The PLT_ProtocolInfo class holds information about the protocol info of a given UPnP Media Item resou...
Definition: PltProtocolInfo.h:68
PLT_MediaControllerDelegate::OnPlayResult
virtual void OnPlayResult(NPT_Result, PLT_DeviceDataReference &, void *)
Definition: PltMediaController.h:159
PLT_Action::GetActionDesc
PLT_ActionDesc & GetActionDesc()
Return the action description.
Definition: PltAction.h:148
PLT_MediaController::SetPlayMode
NPT_Result SetPlayMode(PLT_DeviceDataReference &device, NPT_UInt32 instance_id, NPT_String new_play_mode, void *userdata)
Definition: PltMediaController.cpp:602
PLT_MediaController::GetProtocolInfo
NPT_Result GetProtocolInfo(PLT_DeviceDataReference &device, void *userdata)
Definition: PltMediaController.cpp:694
PLT_TransportSettings::rec_quality_mode
NPT_String rec_quality_mode
Definition: PltMediaController.h:86
NPT_LOG_FINE_1
#define NPT_LOG_FINE_1(_msg, _arg1)
Definition: NptLogging.h:401
PLT_MediaControllerDelegate::OnGetTransportSettingsResult
virtual void OnGetTransportSettingsResult(NPT_Result, PLT_DeviceDataReference &, PLT_TransportSettings *, void *)
Definition: PltMediaController.h:143
PLT_Didl::ParseTimeStamp
static NPT_Result ParseTimeStamp(const NPT_String &timestamp, NPT_UInt32 &seconds)
Definition: PltDidl.cpp:291
NPT_Array::GetItemCount
NPT_Cardinal GetItemCount() const
Definition: NptArray.h:71
NPT_FAILURE
#define NPT_FAILURE
Result indicating an unspecified failure condition.
Definition: NptResults.h:107
PLT_DeviceData::GetUUID
const NPT_String & GetUUID() const
Definition: PltDeviceData.h:113
PLT_MediaController::GetVolume
NPT_Result GetVolume(PLT_DeviceDataReference &device, NPT_UInt32 instance_id, const char *channel, void *userdata)
Definition: PltMediaController.cpp:800
PLT_ConnectionInfo::avtransport_id
NPT_UInt32 avtransport_id
Definition: PltMediaController.h:91
PLT_MediaControllerDelegate::OnGetMuteResult
virtual void OnGetMuteResult(NPT_Result, PLT_DeviceDataReference &, const char *, bool, void *)
Definition: PltMediaController.h:220
PLT_MediaControllerDelegate::OnGetCurrentConnectionIDsResult
virtual void OnGetCurrentConnectionIDsResult(NPT_Result, PLT_DeviceDataReference &, PLT_StringList *, void *)
Definition: PltMediaController.h:195
NPT_UInt32
unsigned int NPT_UInt32
Definition: NptTypes.h:45
PLT_MediaController::Pause
NPT_Result Pause(PLT_DeviceDataReference &device, NPT_UInt32 instance_id, void *userdata)
Definition: PltMediaController.cpp:439
PLT_MediaInfo::num_tracks
NPT_UInt32 num_tracks
Definition: PltMediaController.h:56
PLT_ActionDesc
The PLT_ActionDesc class provides information about a UPnP Service given action.
Definition: PltAction.h:61
PLT_MediaController::GetMediaInfo
NPT_Result GetMediaInfo(PLT_DeviceDataReference &device, NPT_UInt32 instance_id, void *userdata)
Definition: PltMediaController.cpp:354
PLT_MediaController
Definition: PltMediaController.h:243
PLT_ActionDesc::GetService
PLT_Service * GetService()
Return the service the action is associated with.
Definition: PltAction.cpp:88
PltUtilities.h
Neptune.h
PLT_MediaController::FindRenderer
virtual NPT_Result FindRenderer(const char *uuid, PLT_DeviceDataReference &device)
Definition: PltMediaController.cpp:175
PLT_Service::ForceVersion
NPT_Result ForceVersion(NPT_Cardinal version)
When a control point discover a new service with a higher version number than it can work with...
Definition: PltService.cpp:401
PLT_MediaInfo::play_medium
NPT_String play_medium
Definition: PltMediaController.h:62
PLT_MediaController::~PLT_MediaController
~PLT_MediaController() override
Definition: PltMediaController.cpp:60
PLT_TransportSettings
Definition: PltMediaController.h:84
PLT_DeviceCapabilities::rec_quality_modes
PLT_StringList rec_quality_modes
Definition: PltMediaController.h:52
PLT_MediaControllerDelegate::OnStopResult
virtual void OnStopResult(NPT_Result, PLT_DeviceDataReference &, void *)
Definition: PltMediaController.h:189
PLT_MediaController::Seek
NPT_Result Seek(PLT_DeviceDataReference &device, NPT_UInt32 instance_id, NPT_String unit, NPT_String target, void *userdata)
Definition: PltMediaController.cpp:497
PLT_MediaController::CanSetNextAVTransportURI
bool CanSetNextAVTransportURI(PLT_DeviceDataReference &device)
Definition: PltMediaController.cpp:527
PLT_Service
UPnP Service.
Definition: PltService.h:67
PLT_MediaController::SetMute
NPT_Result SetMute(PLT_DeviceDataReference &device, NPT_UInt32 instance_id, const char *channel, bool mute, void *userdata)
Definition: PltMediaController.cpp:716
value
qulonglong value
Definition: itemviewutilities.cpp:530
PLT_MediaController::Stop
NPT_Result Stop(PLT_DeviceDataReference &device, NPT_UInt32 instance_id, void *userdata)
Definition: PltMediaController.cpp:626
PLT_Service::GetStateVariableValue
NPT_Result GetStateVariableValue(const char *name, NPT_String &value)
Return the state variable value given a state variable name.
Definition: PltService.cpp:436
NPT_String::StartsWith
bool StartsWith(const char *s, bool ignore_case=false) const
Definition: NptStrings.cpp:579
PLT_Service::GetDevice
PLT_DeviceData * GetDevice()
Return the PLT_DeviceData* the service is associated with.
Definition: PltService.h:183
NPT_TimeStamp
Definition: NptTime.h:50
PLT_MediaController::OnActionResponse
NPT_Result OnActionResponse(NPT_Result res, PLT_ActionReference &action, void *userdata) override
Definition: PltMediaController.cpp:824
PLT_PositionInfo::rel_count
NPT_Int32 rel_count
Definition: PltMediaController.h:74
PLT_ConnectionInfo
Definition: PltMediaController.h:89
PLT_Action::GetErrorCode
unsigned int GetErrorCode()
Return the error code for the failed action.
Definition: PltAction.cpp:359
NPT_FAILED
#define NPT_FAILED(result)
Definition: NptResults.h:97
PLT_TransportInfo
Definition: PltMediaController.h:78
PLT_MediaControllerDelegate::OnSetAVTransportURIResult
virtual void OnSetAVTransportURIResult(NPT_Result, PLT_DeviceDataReference &, void *)
Definition: PltMediaController.h:174
PLT_MediaControllerDelegate::OnGetVolumeResult
virtual void OnGetVolumeResult(NPT_Result, PLT_DeviceDataReference &, const char *, NPT_UInt32, void *)
Definition: PltMediaController.h:232
PLT_MediaController::OnDeviceAdded
NPT_Result OnDeviceAdded(PLT_DeviceDataReference &device) override
Definition: PltMediaController.cpp:69
NPT_ERROR_INVALID_PARAMETERS
#define NPT_ERROR_INVALID_PARAMETERS
Definition: NptResults.h:128
PLT_MediaControllerDelegate::OnSetVolumeResult
virtual void OnSetVolumeResult(NPT_Result, PLT_DeviceDataReference &, void *)
Definition: PltMediaController.h:227
NPT_AutoLock
Definition: NptThreads.h:93
PLT_TransportSettings::play_mode
NPT_String play_mode
Definition: PltMediaController.h:85
PLT_CtrlPoint::CreateAction
virtual NPT_Result CreateAction(PLT_DeviceDataReference &device, const char *service_type, const char *action_name, PLT_ActionReference &action)
Definition: PltCtrlPoint.cpp:636
PLT_PositionInfo::abs_time
NPT_TimeStamp abs_time
Definition: PltMediaController.h:73
PLT_MediaControllerDelegate::OnGetTransportInfoResult
virtual void OnGetTransportInfoResult(NPT_Result, PLT_DeviceDataReference &, PLT_TransportInfo *, void *)
Definition: PltMediaController.h:137
PLT_MediaControllerDelegate::OnMRStateVariablesChanged
virtual void OnMRStateVariablesChanged(PLT_Service *, NPT_List< PLT_StateVariable * > *)
Definition: PltMediaController.h:109
PLT_Service::IsTrue
static bool IsTrue(const NPT_String &value)
Definition: PltService.h:108
PLT_MediaController::GetVolumeState
virtual NPT_Result GetVolumeState(const NPT_String &device_uuid, NPT_UInt32 &volume)
Definition: PltMediaController.cpp:235
NPT_ERROR_NO_SUCH_ITEM
#define NPT_ERROR_NO_SUCH_ITEM
Definition: NptResults.h:133
PLT_MediaController::Previous
NPT_Result Previous(PLT_DeviceDataReference &device, NPT_UInt32 instance_id, void *userdata)
Definition: PltMediaController.cpp:480
PLT_MediaControllerDelegate::OnGetMediaInfoResult
virtual void OnGetMediaInfoResult(NPT_Result, PLT_DeviceDataReference &, PLT_MediaInfo *, void *)
Definition: PltMediaController.h:125
NPT_CHECK_SEVERE
#define NPT_CHECK_SEVERE(_result)
Definition: NptLogging.h:462
PLT_DeviceData::GetType
const NPT_String & GetType() const
Definition: PltDeviceData.h:115
NPT_CHECK_WARNING
#define NPT_CHECK_WARNING(_result)
Definition: NptLogging.h:464
PLT_MediaControllerDelegate::OnMRRemoved
virtual void OnMRRemoved(PLT_DeviceDataReference &)
Definition: PltMediaController.h:108
PLT_MediaController::GetTransportState
virtual NPT_Result GetTransportState(const NPT_String &device_uuid, NPT_String &state)
Definition: PltMediaController.cpp:214
PLT_DeviceCapabilities::rec_media
PLT_StringList rec_media
Definition: PltMediaController.h:51
PLT_PositionInfo
Definition: PltMediaController.h:67
PLT_ConnectionInfo::protocol_info
NPT_String protocol_info
Definition: PltMediaController.h:92
PLT_MediaController::GetCurrentConnectionInfo
NPT_Result GetCurrentConnectionInfo(PLT_DeviceDataReference &device, NPT_UInt32 connection_id, void *userdata)
Definition: PltMediaController.cpp:665
PLT_Action::GetArgumentValue
NPT_Result GetArgumentValue(const char *name, NPT_String &value)
Retrieve the string value of an argument given an argument name.
Definition: PltAction.cpp:136
PLT_PositionInfo::track_uri
NPT_String track_uri
Definition: PltMediaController.h:71
PLT_MediaInfo::next_uri
NPT_String next_uri
Definition: PltMediaController.h:60
PLT_MediaController::FindBestResource
virtual NPT_Result FindBestResource(PLT_DeviceDataReference &device, PLT_MediaObject &item, NPT_Cardinal &resource_index)
Definition: PltMediaController.cpp:277
PLT_MediaController::FindMatchingProtocolInfo
virtual NPT_Result FindMatchingProtocolInfo(NPT_List< NPT_String > &sinks, const char *protocol_info)
Definition: PltMediaController.cpp:257
PLT_CtrlPoint::RemoveListener
virtual NPT_Result RemoveListener(PLT_CtrlPointListener *listener)
Definition: PltCtrlPoint.cpp:353
PLT_MediaControllerDelegate::OnSetNextAVTransportURIResult
virtual void OnSetNextAVTransportURIResult(NPT_Result, PLT_DeviceDataReference &, void *)
Definition: PltMediaController.h:179
PLT_MediaInfo::media_duration
NPT_TimeStamp media_duration
Definition: PltMediaController.h:57
PLT_MediaControllerDelegate::OnNextResult
virtual void OnNextResult(NPT_Result, PLT_DeviceDataReference &, void *)
Definition: PltMediaController.h:149
PLT_CtrlPoint::FindActionDesc
virtual NPT_Result FindActionDesc(PLT_DeviceDataReference &device, const char *service_type, const char *action_name, PLT_ActionDesc *&action_desc)
Definition: PltCtrlPoint.cpp:609
PLT_TransportInfo::cur_transport_status
NPT_String cur_transport_status
Definition: PltMediaController.h:80
PLT_PositionInfo::track
NPT_UInt32 track
Definition: PltMediaController.h:68
PLT_MediaController::OnEventNotify
NPT_Result OnEventNotify(PLT_Service *service, NPT_List< PLT_StateVariable * > *vars) override
Definition: PltMediaController.cpp:1378
PLT_MediaControllerDelegate
Definition: PltMediaController.h:102
PLT_MediaController::GetTransportSettings
NPT_Result GetTransportSettings(PLT_DeviceDataReference &device, NPT_UInt32 instance_id, void *userdata)
Definition: PltMediaController.cpp:405
NPT_Reference::IsNull
bool IsNull() const
Returns whether this references a NULL object.
Definition: NptReferences.h:130
NPT_String::ToInteger
NPT_Result ToInteger(int &value, bool relaxed=true) const
Definition: NptStrings.cpp:937
PLT_MediaControllerDelegate::OnSetPlayModeResult
virtual void OnSetPlayModeResult(NPT_Result, PLT_DeviceDataReference &, void *)
Definition: PltMediaController.h:184
PLT_MediaController::Play
NPT_Result Play(PLT_DeviceDataReference &device, NPT_UInt32 instance_id, NPT_String speed, void *userdata)
Definition: PltMediaController.cpp:456
NPT_ContainerFind
NPT_Result NPT_ContainerFind(T &container, const P &predicate, typename T::Element &item, NPT_Ordinal n=0)
Definition: NptCommon.h:70
PLT_MediaInfo
Definition: PltMediaController.h:55
PLT_MediaInfo::cur_uri
NPT_String cur_uri
Definition: PltMediaController.h:58
PLT_MediaObject::m_Resources
NPT_Array< PLT_MediaItemResource > m_Resources
Definition: PltMediaItem.h:263
PLT_MediaController::SetNextAVTransportURI
NPT_Result SetNextAVTransportURI(PLT_DeviceDataReference &device, NPT_UInt32 instance_id, const char *next_uri, const char *next_metadata, void *userdata)
Definition: PltMediaController.cpp:573
PLT_MediaControllerDelegate::OnPauseResult
virtual void OnPauseResult(NPT_Result, PLT_DeviceDataReference &, void *)
Definition: PltMediaController.h:154
PLT_PositionInfo::track_metadata
NPT_String track_metadata
Definition: PltMediaController.h:70
PLT_MediaController::GetTransportInfo
NPT_Result GetTransportInfo(PLT_DeviceDataReference &device, NPT_UInt32 instance_id, void *userdata)
Definition: PltMediaController.cpp:388
PLT_MediaController::ParseCSV
static void ParseCSV(const char *csv, PLT_StringList &values)
Definition: PltMediaController.h:318
PLT_ProtocolInfo::Match
bool Match(const PLT_ProtocolInfo &other) const
Definition: PltProtocolInfo.cpp:457
PLT_MediaControllerDelegate::OnSeekResult
virtual void OnSeekResult(NPT_Result, PLT_DeviceDataReference &, void *)
Definition: PltMediaController.h:169
PLT_ConnectionInfo::peer_connection_mgr
NPT_String peer_connection_mgr
Definition: PltMediaController.h:93
PLT_MediaControllerDelegate::OnGetProtocolInfoResult
virtual void OnGetProtocolInfoResult(NPT_Result, PLT_DeviceDataReference &, PLT_StringList *, PLT_StringList *, void *)
Definition: PltMediaController.h:207
PLT_ConnectionInfo::rcs_id
NPT_UInt32 rcs_id
Definition: PltMediaController.h:90
PLT_MediaController::GetPositionInfo
NPT_Result GetPositionInfo(PLT_DeviceDataReference &device, NPT_UInt32 instance_id, void *userdata)
Definition: PltMediaController.cpp:371
PLT_MediaInfo::rec_medium
NPT_String rec_medium
Definition: PltMediaController.h:63
PLT_MediaObject
The PLT_MediaObject class is any data entity that can be returned by a ContentDirectory Service from ...
Definition: PltMediaItem.h:217
NPT_List::GetFirstItem
Iterator GetFirstItem() const
Definition: NptList.h:125
PLT_CtrlPoint::InvokeAction
virtual NPT_Result InvokeAction(PLT_ActionReference &action, void *userdata=NULL)
Definition: PltCtrlPoint.cpp:1686
PLT_TransportInfo::cur_transport_state
NPT_String cur_transport_state
Definition: PltMediaController.h:79
NPT_SUCCEEDED
#define NPT_SUCCEEDED(result)
Definition: NptResults.h:98
PLT_DeviceData::FindServiceByType
NPT_Result FindServiceByType(const char *type, PLT_Service *&service)
Definition: PltDeviceData.cpp:732
PLT_MediaControllerDelegate::OnGetPositionInfoResult
virtual void OnGetPositionInfoResult(NPT_Result, PLT_DeviceDataReference &, PLT_PositionInfo *, void *)
Definition: PltMediaController.h:131
PltDeviceData.h
UPnP Device information.
PLT_TransportInfo::cur_speed
NPT_String cur_speed
Definition: PltMediaController.h:81
Digikam::cimg_library::cimg::info
void info()
Print information about CImg environment variables.
Definition: CImg.h:5763
PLT_Action::SetArgumentValue
NPT_Result SetArgumentValue(const char *name, const char *value)
Set an argument value.
Definition: PltAction.cpp:205
PLT_MediaController::SetVolume
NPT_Result SetVolume(PLT_DeviceDataReference &device, NPT_UInt32 instance_id, const char *channel, int volume, void *userdata)
Definition: PltMediaController.cpp:746
NPT_Reference< PLT_CtrlPoint >
PLT_ActionDesc::GetName
const NPT_String & GetName() const
Return the action name.
Definition: PltAction.h:84
PLT_ConnectionInfo::status
NPT_String status
Definition: PltMediaController.h:96
PLT_MediaInfo::next_metadata
NPT_String next_metadata
Definition: PltMediaController.h:61
PLT_PositionInfo::rel_time
NPT_TimeStamp rel_time
Definition: PltMediaController.h:72
NPT_String
Definition: NptStrings.h:57
PLT_PositionInfo::abs_count
NPT_Int32 abs_count
Definition: PltMediaController.h:75
PLT_MediaControllerDelegate::OnGetDeviceCapabilitiesResult
virtual void OnGetDeviceCapabilitiesResult(NPT_Result, PLT_DeviceDataReference &, PLT_DeviceCapabilities *, void *)
Definition: PltMediaController.h:119
PLT_DeviceCapabilities::play_media
PLT_StringList play_media
Definition: PltMediaController.h:50
PLT_DeviceCapabilities
Definition: PltMediaController.h:49
PLT_ConnectionInfo::direction
NPT_String direction
Definition: PltMediaController.h:95
NPT_Result
int NPT_Result
Definition: NptTypes.h:56
NPT_List< NPT_String >
NULL
#define NULL
Definition: NptConstants.h:39
NPT_String::Compare
int Compare(const char *s, bool ignore_case=false) const
Definition: NptStrings.cpp:395
PLT_MediaController::OnDeviceRemoved
NPT_Result OnDeviceRemoved(PLT_DeviceDataReference &device) override
Definition: PltMediaController.cpp:141
NPT_LOG_WARNING_1
#define NPT_LOG_WARNING_1(_msg, _arg1)
Definition: NptLogging.h:361
PLT_MediaControllerDelegate::OnGetCurrentTransportActionsResult
virtual void OnGetCurrentTransportActionsResult(NPT_Result, PLT_DeviceDataReference &, PLT_StringList *, void *)
Definition: PltMediaController.h:113
NPT_Cardinal
unsigned int NPT_Cardinal
Definition: NptTypes.h:57
This file is part of the KDE documentation.
Documentation copyright © 1996-2019 The KDE developers.
Generated on Tue Dec 10 2019 04:05:43 by doxygen 1.8.7 written by Dimitri van Heesch, © 1997-2006

KDE's Doxygen guidelines are available online.

digikam

Skip menu "digikam"
  • Main Page
  • Namespace List
  • Namespace Members
  • Alphabetical List
  • Class List
  • Class Hierarchy
  • Class Members
  • File List
  • File Members
  • Modules
  • Related Pages
-->

graphics API Reference

Skip menu "graphics API Reference"
  • digikam
  • KDiagram
  •     KChart
  •     KGantt
  • KPhotoAlbum
  •   AndroidRemoteControl
  • Krita
  •   libs
  •     KritaBasicFlakes
  •     brush
  •     KritaUndo2
  •     KritaFlake
  •     image
  •     KritaPlugin
  •     Krita
  •     KritaOdf
  •     KritaPigment
  •     KritaStore
  •     ui
  •     KritaWidgets
  •     KritaWidgetUtils
  •   plugins
  •     Assitants
  •     Extensions
  •     Filters
  •         KritaText
  •         KritaTextLayout
  •     Generators
  •     Formats
  •             src
  •     PaintOps
  •       libpaintop
Report problems with this website to our bug tracking system.
Contact the specific authors with questions and comments about the page contents.

KDE® and the K Desktop Environment® logo are registered trademarks of KDE e.V. | Legal