← Back to branch summary

~ubuntu-branches/ubuntu/trusty/digikam/trusty

« back to all changes in this revision

Viewing changes to extra/kipi-plugins/dlnaexport/extra/hupnp_av/src/mediarenderer/hrendererconnection_info.cpp

  • Committer: Package Import Robot
  • Author(s): Rohan Garg
  • Date: 2012-11-26 18:24:20 UTC
  • mfrom: (1.9.1) (3.1.23 experimental)
  • Revision ID: package-import@ubuntu.com-20121126182420-qoy6z0nx4ai0wzcl
Tags: 4:3.0.0~beta3-0ubuntu1
https://launchpad.net/bugs/890059
https://launchpad.net/bugs/1011211
https://launchpad.net/bugs/658047
* New upstream release
  - Add build-deps :  libhupnp-dev, libqtgstreamer-dev, libmagickcore-dev
* Merge from debian, remaining changes:
  - Make sure libqt4-opengl-dev, libgl1-mesa-dev and libglu1-mesa-dev only
    install on i386,amd64 and powerpc
  - Depend on libtiff-dev instead of libtiff4-dev
  - Drop digikam breaks/replaces kipi-plugins-common since we're past the
    LTS release now
  - digikam to recommend mplayerthumbs | ffmpegthumbs. We currently only
    have latter in the archives, even though former is also supposed to
    be part of kdemultimedia. (LP: #890059)
  - kipi-plugins to recommend www-browser rather than konqueror directly
    since 2.8 no direct usage of konqueror is present in the flickr
    plugin anymore (LP: #1011211)
  - Keep kubuntu_mysqld_executable_name.diff
  - Don't install libkipi translations
  - Keep deps on libcv-dev, libcvaux-dev
  - Keep split packaging of libraries
  - Replace icons from KDE 3 time in debian/xpm.d/*.xpm with the new
    versions (LP: #658047)
* Update debian/not-installed

Show diffs side-by-side

added added

removed removed

Lines of Context:
extra/kipi-plugins/dlnaexport/extra/hupnp_av/src/mediarenderer/hrendererconnection_info.cpp
 
1
/*
 
2
 *  Copyright (C) 2011 Tuomo Penttinen, all rights reserved.
 
3
 *
 
4
 *  Author: Tuomo Penttinen <tp@herqq.org>
 
5
 *
 
6
 *  This file is part of Herqq UPnP Av (HUPnPAv) library.
 
7
 *
 
8
 *  Herqq UPnP Av is free software: you can redistribute it and/or modify
 
9
 *  it under the terms of the GNU General Public License as published by
 
10
 *  the Free Software Foundation, either version 3 of the License, or
 
11
 *  (at your option) any later version.
 
12
 *
 
13
 *  Herqq UPnP Av is distributed in the hope that it will be useful,
 
14
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 
15
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 
16
 *  GNU General Public License for more details.
 
17
 *
 
18
 *  You should have received a copy of the GNU General Public License
 
19
 *  along with Herqq UPnP Av. If not, see <http://www.gnu.org/licenses/>.
 
20
 */
 
21
 
 
22
#include "hrendererconnection_info.h"
 
23
#include "hrendererconnection_info_p.h"
 
24
 
 
25
#include "../hav_global_p.h"
 
26
 
 
27
#include "../transport/hrecordqualitymode.h"
 
28
#include "../renderingcontrol/hvolumedbrange_result.h"
 
29
 
 
30
#include <HUpnpCore/private/hmisc_utils_p.h>
 
31
 
 
32
#include <QtCore/QUrl>
 
33
#include <QtCore/QStringList>
 
34
 
 
35
namespace Herqq
 
36
{
 
37
 
 
38
namespace Upnp
 
39
{
 
40
 
 
41
namespace Av
 
42
{
 
43
 
 
44
/*******************************************************************************
 
45
 * HChannelInformation
 
46
 ******************************************************************************/
 
47
HChannelInformation::HChannelInformation(const HChannel& ch) :
 
48
    m_channel(ch), volume(0), volumeDb(0), minVolumeDb(0), maxVolumeDb(0),
 
49
    muted(false), loudness(false)
 
50
{
 
51
}
 
52
 
 
53
/*******************************************************************************
 
54
 * HRendererConnectionEventInfoPrivate
 
55
 ******************************************************************************/
 
56
class HRendererConnectionEventInfoPrivate :
 
57
    public QSharedData
 
58
{
 
59
H_DISABLE_ASSIGN(HRendererConnectionEventInfoPrivate)
 
60
 
 
61
public:
 
62
 
 
63
    QString m_variableName;
 
64
    QString m_oldValue;
 
65
    QString m_newValue;
 
66
    HChannel m_channel;
 
67
};
 
68
 
 
69
/*******************************************************************************
 
70
 * HRendererConnectionEventInfo
 
71
 ******************************************************************************/
 
72
HRendererConnectionEventInfo::HRendererConnectionEventInfo() :
 
73
    h_ptr(new HRendererConnectionEventInfoPrivate())
 
74
{
 
75
}
 
76
 
 
77
HRendererConnectionEventInfo::HRendererConnectionEventInfo(
 
78
    const QString& propName,
 
79
    const QString& newValue) :
 
80
        h_ptr(new HRendererConnectionEventInfoPrivate())
 
81
{
 
82
    h_ptr->m_variableName = propName.trimmed();
 
83
    h_ptr->m_newValue = newValue;
 
84
}
 
85
 
 
86
HRendererConnectionEventInfo::HRendererConnectionEventInfo(
 
87
    const HRendererConnectionEventInfo& other) :
 
88
        h_ptr(other.h_ptr)
 
89
{
 
90
    Q_ASSERT(&other != this);
 
91
}
 
92
 
 
93
HRendererConnectionEventInfo& HRendererConnectionEventInfo::operator=(
 
94
    const HRendererConnectionEventInfo& other)
 
95
{
 
96
    Q_ASSERT(&other != this);
 
97
    h_ptr = other.h_ptr;
 
98
    return *this;
 
99
}
 
100
 
 
101
HRendererConnectionEventInfo::~HRendererConnectionEventInfo()
 
102
{
 
103
}
 
104
 
 
105
bool HRendererConnectionEventInfo::isValid() const
 
106
{
 
107
    return !h_ptr->m_variableName.isEmpty() &&
 
108
            h_ptr->m_oldValue != h_ptr->m_newValue;
 
109
}
 
110
 
 
111
QString HRendererConnectionEventInfo::propertyName() const
 
112
{
 
113
    return h_ptr->m_variableName;
 
114
}
 
115
 
 
116
QString HRendererConnectionEventInfo::oldValue() const
 
117
{
 
118
    return h_ptr->m_oldValue;
 
119
}
 
120
 
 
121
QString HRendererConnectionEventInfo::newValue() const
 
122
{
 
123
    return h_ptr->m_newValue;
 
124
}
 
125
 
 
126
HChannel HRendererConnectionEventInfo::channel() const
 
127
{
 
128
    return h_ptr->m_channel;
 
129
}
 
130
 
 
131
void HRendererConnectionEventInfo::setPropertyName(const QString& arg)
 
132
{
 
133
    h_ptr->m_variableName = arg.trimmed();
 
134
}
 
135
 
 
136
void HRendererConnectionEventInfo::setOldValue(const QString& arg)
 
137
{
 
138
    h_ptr->m_oldValue = arg;
 
139
}
 
140
 
 
141
void HRendererConnectionEventInfo::setNewValue(const QString& arg)
 
142
{
 
143
    h_ptr->m_newValue = arg;
 
144
}
 
145
 
 
146
void HRendererConnectionEventInfo::setChannel(const HChannel& arg)
 
147
{
 
148
    h_ptr->m_channel = arg;
 
149
}
 
150
 
 
151
bool operator==(const HRendererConnectionEventInfo& obj1, const HRendererConnectionEventInfo& obj2)
 
152
{
 
153
    return obj1.propertyName() == obj2.propertyName() &&
 
154
           obj1.newValue() == obj2.newValue() &&
 
155
           obj1.oldValue() == obj2.oldValue() &&
 
156
           obj1.channel() == obj2.channel();
 
157
}
 
158
 
 
159
/*******************************************************************************
 
160
 * HRendererConnectionInfoPrivate
 
161
 ******************************************************************************/
 
162
HRendererConnectionInfoPrivate::HRendererConnectionInfoPrivate() :
 
163
    q_ptr(0),
 
164
    m_parent(0),
 
165
    m_valueSetters(),
 
166
    m_valueGetters(),
 
167
    m_transportActions(),
 
168
    m_drmState(HAvTransportInfo::DrmState_Unknown),
 
169
    m_deviceCapabilities(),
 
170
    m_mediaInfo(),
 
171
    m_positionInfo(),
 
172
    m_transportInfo(),
 
173
    m_transportSettings(),
 
174
    m_presets(),
 
175
    m_rcsAttributes(),
 
176
    m_horizontalKeystone(0),
 
177
    m_verticalKeystone(0),
 
178
    m_channelInfo()
 
179
{
 
180
    m_valueSetters.insert("TransportState", ValueSetter(this, &HRendererConnectionInfoPrivate::setTransportState));
 
181
    m_valueSetters.insert("TransportStatus", ValueSetter(this, &HRendererConnectionInfoPrivate::setTransportStatus));
 
182
    m_valueSetters.insert("CurrentMediaCategory", ValueSetter(this, &HRendererConnectionInfoPrivate::setCurrentMediaCategory));
 
183
    m_valueSetters.insert("PlaybackStorageMedium", ValueSetter(this, &HRendererConnectionInfoPrivate::setPlaybackStorageMedium));
 
184
    m_valueSetters.insert("RecordStorageMedium", ValueSetter(this, &HRendererConnectionInfoPrivate::setRecordStorageMedium));
 
185
    m_valueSetters.insert("PossiblePlaybackStorageMedia", ValueSetter(this, &HRendererConnectionInfoPrivate::setPossiblePlaybackStorageMedia));
 
186
    m_valueSetters.insert("PossibleRecordStorageMedia", ValueSetter(this, &HRendererConnectionInfoPrivate::setPossibleRecordStorageMedia));
 
187
    m_valueSetters.insert("CurrentPlayMode", ValueSetter(this, &HRendererConnectionInfoPrivate::setCurrentPlayMode));
 
188
    m_valueSetters.insert("TransportPlaySpeed", ValueSetter(this, &HRendererConnectionInfoPrivate::setTransportPlaySpeed));
 
189
    m_valueSetters.insert("RecordMediumWriteStatus", ValueSetter(this, &HRendererConnectionInfoPrivate::setRecordMediumWriteStatus));
 
190
    m_valueSetters.insert("CurrentRecordQualityMode", ValueSetter(this, &HRendererConnectionInfoPrivate::setCurrentRecordQualityMode));
 
191
    m_valueSetters.insert("PossibleRecordQualityModes", ValueSetter(this, &HRendererConnectionInfoPrivate::setPossibleRecordQualityModes));
 
192
    m_valueSetters.insert("NumberOfTracks", ValueSetter(this, &HRendererConnectionInfoPrivate::setNumberOfTracks));
 
193
    m_valueSetters.insert("CurrentTrack", ValueSetter(this, &HRendererConnectionInfoPrivate::setCurrentTrack));
 
194
    m_valueSetters.insert("CurrentTrackDuration", ValueSetter(this, &HRendererConnectionInfoPrivate::setCurrentTrackDuration));
 
195
    m_valueSetters.insert("CurrentMediaDuration", ValueSetter(this, &HRendererConnectionInfoPrivate::setCurrentMediaDuration));
 
196
    m_valueSetters.insert("CurrentTrackMetaData", ValueSetter(this, &HRendererConnectionInfoPrivate::setCurrentTrackMetaData));
 
197
    m_valueSetters.insert("CurrentTrackURI", ValueSetter(this, &HRendererConnectionInfoPrivate::setCurrentTrackURI));
 
198
    m_valueSetters.insert("AVTransportURI", ValueSetter(this, &HRendererConnectionInfoPrivate::setAVTransportURI));
 
199
    m_valueSetters.insert("AVTransportURIMetaData", ValueSetter(this, &HRendererConnectionInfoPrivate::setAVTransportURIMetaData));
 
200
    m_valueSetters.insert("NextAVTransportURI", ValueSetter(this, &HRendererConnectionInfoPrivate::setNextAVTransportURI));
 
201
    m_valueSetters.insert("NextAVTransportURIMetaData", ValueSetter(this, &HRendererConnectionInfoPrivate::setNextAVTransportURIMetaData));
 
202
    m_valueSetters.insert("RelativeTimePosition", ValueSetter(this, &HRendererConnectionInfoPrivate::setRelativeTimePosition));
 
203
    m_valueSetters.insert("AbsoluteTimePosition", ValueSetter(this, &HRendererConnectionInfoPrivate::setAbsoluteTimePosition));
 
204
    m_valueSetters.insert("RelativeCounterPosition", ValueSetter(this, &HRendererConnectionInfoPrivate::setRelativeCounterPosition));
 
205
    m_valueSetters.insert("AbsoluteCounterPosition", ValueSetter(this, &HRendererConnectionInfoPrivate::setAbsoluteCounterPosition));
 
206
    m_valueSetters.insert("CurrentTransportActions", ValueSetter(this, &HRendererConnectionInfoPrivate::setCurrentTransportActions));
 
207
    m_valueSetters.insert("DRMState", ValueSetter(this, &HRendererConnectionInfoPrivate::setDrmState));
 
208
 
 
209
    m_valueSetters.insert("Brightness", ValueSetter(this, &HRendererConnectionInfoPrivate::setBrightness));
 
210
    m_valueSetters.insert("Contrast", ValueSetter(this, &HRendererConnectionInfoPrivate::setContrast));
 
211
    m_valueSetters.insert("Sharpness", ValueSetter(this, &HRendererConnectionInfoPrivate::setSharpness));
 
212
    m_valueSetters.insert("RedVideoGain", ValueSetter(this, &HRendererConnectionInfoPrivate::setRedVideoGain));
 
213
    m_valueSetters.insert("GreenVideoGain", ValueSetter(this, &HRendererConnectionInfoPrivate::setGreenVideoGain));
 
214
    m_valueSetters.insert("BlueVideoGain", ValueSetter(this, &HRendererConnectionInfoPrivate::setBlueVideoGain));
 
215
    m_valueSetters.insert("RedVideoBlackLevel", ValueSetter(this, &HRendererConnectionInfoPrivate::setRedVideoBlackLevel));
 
216
    m_valueSetters.insert("GreenVideoBlackLevel", ValueSetter(this, &HRendererConnectionInfoPrivate::setGreenVideoBlackLevel));
 
217
    m_valueSetters.insert("BlueVideoBlackLevel", ValueSetter(this, &HRendererConnectionInfoPrivate::setBlueVideoBlackLevel));
 
218
    m_valueSetters.insert("ColorTemperature", ValueSetter(this, &HRendererConnectionInfoPrivate::setColorTemperature));
 
219
    m_valueSetters.insert("HorizontalKeystone", ValueSetter(this, &HRendererConnectionInfoPrivate::setHorizontalKeystone));
 
220
    m_valueSetters.insert("VerticalKeystone", ValueSetter(this, &HRendererConnectionInfoPrivate::setVerticalKeystone));
 
221
    m_valueSetters.insert("Mute", ValueSetter(this, &HRendererConnectionInfoPrivate::setMute));
 
222
    m_valueSetters.insert("Volume", ValueSetter(this, &HRendererConnectionInfoPrivate::setVolume));
 
223
    m_valueSetters.insert("VolumeDB", ValueSetter(this, &HRendererConnectionInfoPrivate::setVolumeDB));
 
224
    m_valueSetters.insert("Loudness", ValueSetter(this, &HRendererConnectionInfoPrivate::setLoudness));
 
225
 
 
226
    m_valueGetters.insert("TransportState", ValueGetter(this, &HRendererConnectionInfoPrivate::getTransportState));
 
227
    m_valueGetters.insert("TransportStatus", ValueGetter(this, &HRendererConnectionInfoPrivate::getTransportStatus));
 
228
    m_valueGetters.insert("CurrentMediaCategory", ValueGetter(this, &HRendererConnectionInfoPrivate::getCurrentMediaCategory));
 
229
    m_valueGetters.insert("PlaybackStorageMedium", ValueGetter(this, &HRendererConnectionInfoPrivate::getPlaybackStorageMedium));
 
230
    m_valueGetters.insert("RecordStorageMedium", ValueGetter(this, &HRendererConnectionInfoPrivate::getRecordStorageMedium));
 
231
    m_valueGetters.insert("PossiblePlaybackStorageMedia", ValueGetter(this, &HRendererConnectionInfoPrivate::getPossiblePlaybackStorageMedia));
 
232
    m_valueGetters.insert("PossibleRecordStorageMedia", ValueGetter(this, &HRendererConnectionInfoPrivate::getPossibleRecordStorageMedia));
 
233
    m_valueGetters.insert("CurrentPlayMode", ValueGetter(this, &HRendererConnectionInfoPrivate::getCurrentPlayMode));
 
234
    m_valueGetters.insert("TransportPlaySpeed", ValueGetter(this, &HRendererConnectionInfoPrivate::getTransportPlaySpeed));
 
235
    m_valueGetters.insert("RecordMediumWriteStatus", ValueGetter(this, &HRendererConnectionInfoPrivate::getRecordMediumWriteStatus));
 
236
    m_valueGetters.insert("CurrentRecordQualityMode", ValueGetter(this, &HRendererConnectionInfoPrivate::getCurrentRecordQualityMode));
 
237
    m_valueGetters.insert("PossibleRecordQualityModes", ValueGetter(this, &HRendererConnectionInfoPrivate::getPossibleRecordQualityModes));
 
238
    m_valueGetters.insert("NumberOfTracks", ValueGetter(this, &HRendererConnectionInfoPrivate::getNumberOfTracks));
 
239
    m_valueGetters.insert("CurrentTrack", ValueGetter(this, &HRendererConnectionInfoPrivate::getCurrentTrack));
 
240
    m_valueGetters.insert("CurrentTrackDuration", ValueGetter(this, &HRendererConnectionInfoPrivate::getCurrentTrackDuration));
 
241
    m_valueGetters.insert("CurrentMediaDuration", ValueGetter(this, &HRendererConnectionInfoPrivate::getCurrentMediaDuration));
 
242
    m_valueGetters.insert("CurrentTrackMetaData", ValueGetter(this, &HRendererConnectionInfoPrivate::getCurrentTrackMetaData));
 
243
    m_valueGetters.insert("CurrentTrackURI", ValueGetter(this, &HRendererConnectionInfoPrivate::getCurrentTrackURI));
 
244
    m_valueGetters.insert("AVTransportURI", ValueGetter(this, &HRendererConnectionInfoPrivate::getAVTransportURI));
 
245
    m_valueGetters.insert("AVTransportURIMetaData", ValueGetter(this, &HRendererConnectionInfoPrivate::getAVTransportURIMetaData));
 
246
    m_valueGetters.insert("NextAVTransportURI", ValueGetter(this, &HRendererConnectionInfoPrivate::getNextAVTransportURI));
 
247
    m_valueGetters.insert("NextAVTransportURIMetaData", ValueGetter(this, &HRendererConnectionInfoPrivate::getNextAVTransportURIMetaData));
 
248
    m_valueGetters.insert("RelativeTimePosition", ValueGetter(this, &HRendererConnectionInfoPrivate::getRelativeTimePosition));
 
249
    m_valueGetters.insert("AbsoluteTimePosition", ValueGetter(this, &HRendererConnectionInfoPrivate::getAbsoluteTimePosition));
 
250
    m_valueGetters.insert("RelativeCounterPosition", ValueGetter(this, &HRendererConnectionInfoPrivate::getRelativeCounterPosition));
 
251
    m_valueGetters.insert("AbsoluteCounterPosition", ValueGetter(this, &HRendererConnectionInfoPrivate::getAbsoluteCounterPosition));
 
252
    m_valueGetters.insert("CurrentTransportActions", ValueGetter(this, &HRendererConnectionInfoPrivate::getCurrentTransportActions));
 
253
    m_valueGetters.insert("DRMState", ValueGetter(this, &HRendererConnectionInfoPrivate::getDrmState));
 
254
 
 
255
    m_valueGetters.insert("Brightness", ValueGetter(this, &HRendererConnectionInfoPrivate::getBrightness));
 
256
    m_valueGetters.insert("Contrast", ValueGetter(this, &HRendererConnectionInfoPrivate::getContrast));
 
257
    m_valueGetters.insert("Sharpness", ValueGetter(this, &HRendererConnectionInfoPrivate::getSharpness));
 
258
    m_valueGetters.insert("RedVideoGain", ValueGetter(this, &HRendererConnectionInfoPrivate::getRedVideoGain));
 
259
    m_valueGetters.insert("GreenVideoGain", ValueGetter(this, &HRendererConnectionInfoPrivate::getGreenVideoGain));
 
260
    m_valueGetters.insert("BlueVideoGain", ValueGetter(this, &HRendererConnectionInfoPrivate::getBlueVideoGain));
 
261
    m_valueGetters.insert("RedVideoBlackLevel", ValueGetter(this, &HRendererConnectionInfoPrivate::getRedVideoBlackLevel));
 
262
    m_valueGetters.insert("GreenVideoBlackLevel", ValueGetter(this, &HRendererConnectionInfoPrivate::getGreenVideoBlackLevel));
 
263
    m_valueGetters.insert("BlueVideoBlackLevel", ValueGetter(this, &HRendererConnectionInfoPrivate::getBlueVideoBlackLevel));
 
264
    m_valueGetters.insert("ColorTemperature", ValueGetter(this, &HRendererConnectionInfoPrivate::getColorTemperature));
 
265
    m_valueGetters.insert("HorizontalKeystone", ValueGetter(this, &HRendererConnectionInfoPrivate::getHorizontalKeystone));
 
266
    m_valueGetters.insert("VerticalKeystone", ValueGetter(this, &HRendererConnectionInfoPrivate::getVerticalKeystone));
 
267
    m_valueGetters.insert("Mute", ValueGetter(this, &HRendererConnectionInfoPrivate::getMute));
 
268
    m_valueGetters.insert("Volume", ValueGetter(this, &HRendererConnectionInfoPrivate::getVolume));
 
269
    m_valueGetters.insert("VolumeDB", ValueGetter(this, &HRendererConnectionInfoPrivate::getVolumeDB));
 
270
    m_valueGetters.insert("Loudness", ValueGetter(this, &HRendererConnectionInfoPrivate::getLoudness));
 
271
}
 
272
 
 
273
HRendererConnectionInfoPrivate::~HRendererConnectionInfoPrivate()
 
274
{
 
275
    qDeleteAll(m_channelInfo);
 
276
}
 
277
 
 
278
HChannelInformation* HRendererConnectionInfoPrivate::checkAndAddChannel(const HChannel& channel)
 
279
{
 
280
    if (!channel.isValid())
 
281
    {
 
282
        return 0;
 
283
    }
 
284
 
 
285
    HChannelInformation* info = getChannel(channel);
 
286
    if (!info)
 
287
    {
 
288
        info = new HChannelInformation(channel);
 
289
        m_channelInfo.append(info);
 
290
    }
 
291
 
 
292
    return info;
 
293
}
 
294
 
 
295
HChannelInformation* HRendererConnectionInfoPrivate::getChannel(const HChannel& channel) const
 
296
{
 
297
    foreach(HChannelInformation* ch, m_channelInfo)
 
298
    {
 
299
        if (channel == ch->channel())
 
300
        {
 
301
            return ch;
 
302
        }
 
303
    }
 
304
    return 0;
 
305
}
 
306
 
 
307
void HRendererConnectionInfoPrivate::setCurrentTransportActions(const QString& value, const HChannel&)
 
308
{
 
309
    QSet<HTransportAction> actions;
 
310
    foreach(const QString& arg, value.split(','))
 
311
    {
 
312
        HTransportAction action = arg;
 
313
        if (action.isValid())
 
314
        {
 
315
            actions.insert(action);
 
316
        }
 
317
    }
 
318
    q_ptr->setCurrentTransportActions(actions);
 
319
}
 
320
 
 
321
void HRendererConnectionInfoPrivate::setCurrentMediaCategory(const QString& value, const HChannel&)
 
322
{
 
323
    q_ptr->setCurrentMediaCategory(HMediaInfo::mediaCategoryFromString(value));
 
324
}
 
325
 
 
326
void HRendererConnectionInfoPrivate::setDrmState(const QString& value, const HChannel&)
 
327
{
 
328
    q_ptr->setDrmState(HAvTransportInfo::drmStateFromString(value));
 
329
}
 
330
 
 
331
void HRendererConnectionInfoPrivate::setPossiblePlaybackStorageMedia(const QString& value, const HChannel&)
 
332
{
 
333
    QSet<HStorageMedium> mediums;
 
334
    foreach(const QString& arg, value.split(','))
 
335
    {
 
336
        HStorageMedium medium = arg;
 
337
        if (medium.isValid())
 
338
        {
 
339
            mediums.insert(medium);
 
340
        }
 
341
    }
 
342
    q_ptr->setPossiblePlaybackStorageMedia(mediums);
 
343
}
 
344
 
 
345
void HRendererConnectionInfoPrivate::setPossibleRecordStorageMedia(const QString& value, const HChannel&)
 
346
{
 
347
    QSet<HStorageMedium> mediums;
 
348
    foreach(const QString& arg, value.split(','))
 
349
    {
 
350
        HStorageMedium medium = arg;
 
351
        if (medium.isValid())
 
352
        {
 
353
            mediums.insert(medium);
 
354
        }
 
355
    }
 
356
    q_ptr->setPossibleRecordStorageMedia(mediums);
 
357
}
 
358
 
 
359
void HRendererConnectionInfoPrivate::setPossibleRecordQualityModes(const QString& value, const HChannel&)
 
360
{
 
361
    QSet<HRecordQualityMode> modes;
 
362
    foreach(const QString& arg, value.split(','))
 
363
    {
 
364
        HRecordQualityMode mode = arg;
 
365
        if (mode.isValid())
 
366
        {
 
367
            modes.insert(mode);
 
368
        }
 
369
    }
 
370
    q_ptr->setPossibleRecordQualityModes(modes);
 
371
}
 
372
 
 
373
void HRendererConnectionInfoPrivate::setNumberOfTracks(const QString& value, const HChannel&)
 
374
{
 
375
    q_ptr->setNumberOfTracks(value.toUInt());
 
376
}
 
377
 
 
378
void HRendererConnectionInfoPrivate::setCurrentMediaDuration(const QString& value, const HChannel&)
 
379
{
 
380
    q_ptr->setCurrentMediaDuration(value);
 
381
}
 
382
 
 
383
void HRendererConnectionInfoPrivate::setAVTransportURI(const QString& value, const HChannel&)
 
384
{
 
385
    q_ptr->setCurrentResourceUri(value);
 
386
}
 
387
 
 
388
void HRendererConnectionInfoPrivate::setAVTransportURIMetaData(const QString& value, const HChannel&)
 
389
{
 
390
    q_ptr->setCurrentResourceMetadata(value);
 
391
}
 
392
 
 
393
void HRendererConnectionInfoPrivate::setNextAVTransportURI(const QString& value, const HChannel&)
 
394
{
 
395
    q_ptr->setNextResourceUri(value);
 
396
}
 
397
 
 
398
void HRendererConnectionInfoPrivate::setNextAVTransportURIMetaData(const QString& value, const HChannel&)
 
399
{
 
400
    q_ptr->setNextResourceMetadata(value);
 
401
}
 
402
 
 
403
void HRendererConnectionInfoPrivate::setPlaybackStorageMedium(const QString& value, const HChannel&)
 
404
{
 
405
    q_ptr->setPlaybackStorageMedium(value);
 
406
}
 
407
 
 
408
void HRendererConnectionInfoPrivate::setRecordStorageMedium(const QString& value, const HChannel&)
 
409
{
 
410
    q_ptr->setRecordStorageMedium(value);
 
411
}
 
412
 
 
413
void HRendererConnectionInfoPrivate::setRecordMediumWriteStatus(const QString& value, const HChannel&)
 
414
{
 
415
    q_ptr->setRecordMediumWriteStatus(value);
 
416
}
 
417
 
 
418
void HRendererConnectionInfoPrivate::setCurrentTrack(const QString& value, const HChannel&)
 
419
{
 
420
    q_ptr->setCurrentTrack(value.toUInt());
 
421
}
 
422
 
 
423
void HRendererConnectionInfoPrivate::setCurrentTrackDuration(const QString& value, const HChannel&)
 
424
{
 
425
    q_ptr->setCurrentTrackDuration(value);
 
426
}
 
427
 
 
428
void HRendererConnectionInfoPrivate::setCurrentTrackMetaData(const QString& value, const HChannel&)
 
429
{
 
430
    q_ptr->setCurrentTrackMetadata(value);
 
431
}
 
432
 
 
433
void HRendererConnectionInfoPrivate::setCurrentTrackURI(const QString& value, const HChannel&)
 
434
{
 
435
    q_ptr->setCurrentTrackUri(value);
 
436
}
 
437
 
 
438
void HRendererConnectionInfoPrivate::setRelativeTimePosition(const QString& value, const HChannel&)
 
439
{
 
440
    q_ptr->setRelativeTimePosition(value);
 
441
}
 
442
 
 
443
void HRendererConnectionInfoPrivate::setAbsoluteTimePosition(const QString& value, const HChannel&)
 
444
{
 
445
    q_ptr->setAbsoluteTimePosition(value);
 
446
}
 
447
 
 
448
void HRendererConnectionInfoPrivate::setRelativeCounterPosition(const QString& value, const HChannel&)
 
449
{
 
450
    q_ptr->setRelativeCounterPosition(value.toUInt());
 
451
}
 
452
 
 
453
void HRendererConnectionInfoPrivate::setAbsoluteCounterPosition(const QString& value, const HChannel&)
 
454
{
 
455
    q_ptr->setAbsoluteCounterPosition(value.toUInt());
 
456
}
 
457
 
 
458
void HRendererConnectionInfoPrivate::setTransportState(const QString& value, const HChannel&)
 
459
{
 
460
    q_ptr->setTransportState(value);
 
461
}
 
462
 
 
463
void HRendererConnectionInfoPrivate::setTransportStatus(const QString& value, const HChannel&)
 
464
{
 
465
    q_ptr->setTransportStatus(value);
 
466
}
 
467
 
 
468
void HRendererConnectionInfoPrivate::setTransportPlaySpeed(const QString& value, const HChannel&)
 
469
{
 
470
    q_ptr->setTransportPlaySpeed(value);
 
471
}
 
472
 
 
473
void HRendererConnectionInfoPrivate::setCurrentPlayMode(const QString& value, const HChannel&)
 
474
{
 
475
    q_ptr->setCurrentPlayMode(value);
 
476
}
 
477
 
 
478
void HRendererConnectionInfoPrivate::setCurrentRecordQualityMode(const QString& value, const HChannel&)
 
479
{
 
480
    q_ptr->setCurrentRecordQualityMode(value);
 
481
}
 
482
 
 
483
void HRendererConnectionInfoPrivate::setBrightness(const QString& value, const HChannel&)
 
484
{
 
485
    q_ptr->setRcsValue(HRendererConnectionInfo::Brightness, value.toUShort());
 
486
}
 
487
 
 
488
void HRendererConnectionInfoPrivate::setContrast(const QString& value, const HChannel&)
 
489
{
 
490
    q_ptr->setRcsValue(HRendererConnectionInfo::Contrast, value.toUShort());
 
491
}
 
492
 
 
493
void HRendererConnectionInfoPrivate::setSharpness(const QString& value, const HChannel&)
 
494
{
 
495
    q_ptr->setRcsValue(HRendererConnectionInfo::Sharpness, value.toUShort());
 
496
}
 
497
 
 
498
void HRendererConnectionInfoPrivate::setRedVideoGain(const QString& value, const HChannel&)
 
499
{
 
500
    q_ptr->setRcsValue(HRendererConnectionInfo::RedVideoGain, value.toUShort());
 
501
}
 
502
 
 
503
void HRendererConnectionInfoPrivate::setGreenVideoGain(const QString& value, const HChannel&)
 
504
{
 
505
    q_ptr->setRcsValue(HRendererConnectionInfo::GreenVideoGain, value.toUShort());
 
506
}
 
507
 
 
508
void HRendererConnectionInfoPrivate::setBlueVideoGain(const QString& value, const HChannel&)
 
509
{
 
510
    q_ptr->setRcsValue(HRendererConnectionInfo::BlueVideoGain, value.toUShort());
 
511
}
 
512
 
 
513
void HRendererConnectionInfoPrivate::setRedVideoBlackLevel(const QString& value, const HChannel&)
 
514
{
 
515
    q_ptr->setRcsValue(HRendererConnectionInfo::RedVideoBlackLevel, value.toUShort());
 
516
}
 
517
 
 
518
void HRendererConnectionInfoPrivate::setGreenVideoBlackLevel(const QString& value, const HChannel&)
 
519
{
 
520
    q_ptr->setRcsValue(HRendererConnectionInfo::GreenVideoBlackLevel, value.toUShort());
 
521
}
 
522
 
 
523
void HRendererConnectionInfoPrivate::setBlueVideoBlackLevel(const QString& value, const HChannel&)
 
524
{
 
525
    q_ptr->setRcsValue(HRendererConnectionInfo::BlueVideoBlackLevel, value.toUShort());
 
526
}
 
527
 
 
528
void HRendererConnectionInfoPrivate::setColorTemperature(const QString& value, const HChannel&)
 
529
{
 
530
    q_ptr->setRcsValue(HRendererConnectionInfo::ColorTemperature, value.toUShort());
 
531
}
 
532
 
 
533
void HRendererConnectionInfoPrivate::setHorizontalKeystone(const QString& value, const HChannel&)
 
534
{
 
535
    q_ptr->setHorizontalKeystone(value.toShort());
 
536
}
 
537
 
 
538
void HRendererConnectionInfoPrivate::setVerticalKeystone(const QString& value, const HChannel&)
 
539
{
 
540
    q_ptr->setVerticalKeystone(value.toShort());
 
541
}
 
542
 
 
543
void HRendererConnectionInfoPrivate::setMute(const QString& value, const HChannel& ch)
 
544
{
 
545
    bool ok = false;
 
546
    q_ptr->setMute(ch, toBool(value, &ok));
 
547
    Q_UNUSED(ok)
 
548
}
 
549
 
 
550
void HRendererConnectionInfoPrivate::setVolume(const QString& value, const HChannel& ch)
 
551
{
 
552
    q_ptr->setVolume(ch, value.toUShort());
 
553
}
 
554
 
 
555
void HRendererConnectionInfoPrivate::setVolumeDB(const QString& value, const HChannel& ch)
 
556
{
 
557
    q_ptr->setVolumeDb(ch, value.toShort());
 
558
}
 
559
 
 
560
void HRendererConnectionInfoPrivate::setLoudness(const QString& value, const HChannel& ch)
 
561
{
 
562
    bool ok = false;
 
563
    q_ptr->setLoudness(ch, toBool(value, &ok));
 
564
    Q_UNUSED(ok)
 
565
}
 
566
 
 
567
QString HRendererConnectionInfoPrivate::getCurrentMediaCategory(const HChannel&) const
 
568
{
 
569
    return HMediaInfo::toString(m_mediaInfo.mediaCategory());
 
570
}
 
571
 
 
572
QString HRendererConnectionInfoPrivate::getCurrentTransportActions(const HChannel&) const
 
573
{
 
574
    return strToCsvString(m_transportActions);
 
575
}
 
576
 
 
577
QString HRendererConnectionInfoPrivate::getDrmState(const HChannel&) const
 
578
{
 
579
    return HAvTransportInfo::drmStateToString(m_drmState);
 
580
}
 
581
 
 
582
QString HRendererConnectionInfoPrivate::getPossiblePlaybackStorageMedia(const HChannel&) const
 
583
{
 
584
    return strToCsvString(m_deviceCapabilities.playMedia());
 
585
}
 
586
 
 
587
QString HRendererConnectionInfoPrivate::getPossibleRecordStorageMedia(const HChannel&) const
 
588
{
 
589
    return strToCsvString(m_deviceCapabilities.recordMedia());
 
590
}
 
591
 
 
592
QString HRendererConnectionInfoPrivate::getPossibleRecordQualityModes(const HChannel&) const
 
593
{
 
594
    return strToCsvString(m_deviceCapabilities.recordQualityModes());
 
595
}
 
596
 
 
597
QString HRendererConnectionInfoPrivate::getNumberOfTracks(const HChannel&) const
 
598
{
 
599
    return QString::number(m_mediaInfo.numberOfTracks());
 
600
}
 
601
 
 
602
QString HRendererConnectionInfoPrivate::getCurrentMediaDuration(const HChannel&) const
 
603
{
 
604
    return m_mediaInfo.mediaDuration().toString();
 
605
}
 
606
 
 
607
QString HRendererConnectionInfoPrivate::getAVTransportURI(const HChannel&) const
 
608
{
 
609
    return m_mediaInfo.currentUri().toString();
 
610
}
 
611
 
 
612
QString HRendererConnectionInfoPrivate::getAVTransportURIMetaData(const HChannel&) const
 
613
{
 
614
    return m_mediaInfo.currentUriMetadata();
 
615
}
 
616
 
 
617
QString HRendererConnectionInfoPrivate::getNextAVTransportURI(const HChannel&) const
 
618
{
 
619
    return m_mediaInfo.nextUri().toString();
 
620
}
 
621
 
 
622
QString HRendererConnectionInfoPrivate::getNextAVTransportURIMetaData(const HChannel&) const
 
623
{
 
624
    return m_mediaInfo.nextUriMetadata();
 
625
}
 
626
 
 
627
QString HRendererConnectionInfoPrivate::getPlaybackStorageMedium(const HChannel&) const
 
628
{
 
629
    return m_mediaInfo.playMedium().toString();
 
630
}
 
631
 
 
632
QString HRendererConnectionInfoPrivate::getRecordStorageMedium(const HChannel&) const
 
633
{
 
634
    return m_mediaInfo.recordMedium().toString();
 
635
}
 
636
 
 
637
QString HRendererConnectionInfoPrivate::getRecordMediumWriteStatus(const HChannel&) const
 
638
{
 
639
    return m_mediaInfo.writeStatus().toString();
 
640
}
 
641
 
 
642
QString HRendererConnectionInfoPrivate::getCurrentTrack(const HChannel&) const
 
643
{
 
644
    return QString::number(m_positionInfo.track());
 
645
}
 
646
 
 
647
QString HRendererConnectionInfoPrivate::getCurrentTrackDuration(const HChannel&) const
 
648
{
 
649
    return m_positionInfo.trackDuration().toString();
 
650
}
 
651
 
 
652
QString HRendererConnectionInfoPrivate::getCurrentTrackMetaData(const HChannel&) const
 
653
{
 
654
    return m_positionInfo.trackMetadata();
 
655
}
 
656
 
 
657
QString HRendererConnectionInfoPrivate::getCurrentTrackURI(const HChannel&) const
 
658
{
 
659
    return m_positionInfo.trackUri().toString();
 
660
}
 
661
 
 
662
QString HRendererConnectionInfoPrivate::getRelativeTimePosition(const HChannel&) const
 
663
{
 
664
    return m_positionInfo.relativeTimePosition().toString();
 
665
}
 
666
 
 
667
QString HRendererConnectionInfoPrivate::getAbsoluteTimePosition(const HChannel&) const
 
668
{
 
669
    return m_positionInfo.absoluteTimePosition().toString();
 
670
}
 
671
 
 
672
QString HRendererConnectionInfoPrivate::getRelativeCounterPosition(const HChannel&) const
 
673
{
 
674
    return QString::number(m_positionInfo.relativeCounterPosition());
 
675
}
 
676
 
 
677
QString HRendererConnectionInfoPrivate::getAbsoluteCounterPosition(const HChannel&) const
 
678
{
 
679
    return QString::number(m_positionInfo.absoluteCounterPosition());
 
680
}
 
681
 
 
682
QString HRendererConnectionInfoPrivate::getTransportState(const HChannel&) const
 
683
{
 
684
    return m_transportInfo.state().toString();
 
685
}
 
686
 
 
687
QString HRendererConnectionInfoPrivate::getTransportStatus(const HChannel&) const
 
688
{
 
689
    return m_transportInfo.status().toString();
 
690
}
 
691
 
 
692
QString HRendererConnectionInfoPrivate::getTransportPlaySpeed(const HChannel&) const
 
693
{
 
694
    return m_transportInfo.speed();
 
695
}
 
696
 
 
697
QString HRendererConnectionInfoPrivate::getCurrentPlayMode(const HChannel&) const
 
698
{
 
699
    return m_transportSettings.playMode().toString();
 
700
}
 
701
 
 
702
QString HRendererConnectionInfoPrivate::getCurrentRecordQualityMode(const HChannel&) const
 
703
{
 
704
    return m_transportSettings.recordQualityMode().toString();
 
705
}
 
706
 
 
707
QString HRendererConnectionInfoPrivate::getBrightness(const HChannel&) const
 
708
{
 
709
    return QString::number(m_rcsAttributes.value(HRendererConnectionInfo::Brightness));
 
710
}
 
711
 
 
712
QString HRendererConnectionInfoPrivate::getContrast(const HChannel&) const
 
713
{
 
714
    return QString::number(m_rcsAttributes.value(HRendererConnectionInfo::Contrast));
 
715
}
 
716
 
 
717
QString HRendererConnectionInfoPrivate::getSharpness(const HChannel&) const
 
718
{
 
719
    return QString::number(m_rcsAttributes.value(HRendererConnectionInfo::Sharpness));
 
720
}
 
721
 
 
722
QString HRendererConnectionInfoPrivate::getRedVideoGain(const HChannel&) const
 
723
{
 
724
    return QString::number(m_rcsAttributes.value(HRendererConnectionInfo::RedVideoGain));
 
725
}
 
726
 
 
727
QString HRendererConnectionInfoPrivate::getGreenVideoGain(const HChannel&) const
 
728
{
 
729
    return QString::number(m_rcsAttributes.value(HRendererConnectionInfo::GreenVideoGain));
 
730
}
 
731
 
 
732
QString HRendererConnectionInfoPrivate::getBlueVideoGain(const HChannel&) const
 
733
{
 
734
    return QString::number(m_rcsAttributes.value(HRendererConnectionInfo::BlueVideoGain));
 
735
}
 
736
 
 
737
QString HRendererConnectionInfoPrivate::getRedVideoBlackLevel(const HChannel&) const
 
738
{
 
739
    return QString::number(m_rcsAttributes.value(HRendererConnectionInfo::RedVideoBlackLevel));
 
740
}
 
741
 
 
742
QString HRendererConnectionInfoPrivate::getGreenVideoBlackLevel(const HChannel&) const
 
743
{
 
744
    return QString::number(m_rcsAttributes.value(HRendererConnectionInfo::GreenVideoBlackLevel));
 
745
}
 
746
 
 
747
QString HRendererConnectionInfoPrivate::getBlueVideoBlackLevel(const HChannel&) const
 
748
{
 
749
    return QString::number(m_rcsAttributes.value(HRendererConnectionInfo::BlueVideoBlackLevel));
 
750
}
 
751
 
 
752
QString HRendererConnectionInfoPrivate::getColorTemperature(const HChannel&) const
 
753
{
 
754
    return QString::number(m_rcsAttributes.value(HRendererConnectionInfo::ColorTemperature));
 
755
}
 
756
 
 
757
QString HRendererConnectionInfoPrivate::getHorizontalKeystone(const HChannel&) const
 
758
{
 
759
    return QString::number(m_horizontalKeystone);
 
760
}
 
761
 
 
762
QString HRendererConnectionInfoPrivate::getVerticalKeystone(const HChannel&) const
 
763
{
 
764
    return QString::number(m_verticalKeystone);
 
765
}
 
766
 
 
767
QString HRendererConnectionInfoPrivate::getMute(const HChannel& ch) const
 
768
{
 
769
    HChannelInformation* chInfo = getChannel(ch);
 
770
    return chInfo ? (chInfo->muted ? "1" : "0") : QString();
 
771
}
 
772
 
 
773
QString HRendererConnectionInfoPrivate::getVolume(const HChannel& ch) const
 
774
{
 
775
    HChannelInformation* chInfo = getChannel(ch);
 
776
    return chInfo ? QString::number(chInfo->volume) : QString();
 
777
}
 
778
 
 
779
QString HRendererConnectionInfoPrivate::getVolumeDB(const HChannel& ch) const
 
780
{
 
781
    HChannelInformation* chInfo = getChannel(ch);
 
782
    return chInfo ? QString::number(chInfo->volumeDb) : QString();
 
783
}
 
784
 
 
785
QString HRendererConnectionInfoPrivate::getLoudness(const HChannel& ch) const
 
786
{
 
787
    HChannelInformation* chInfo = getChannel(ch);
 
788
    return chInfo ? (chInfo->loudness ? "1" : "0") : QString();
 
789
}
 
790
 
 
791
/*******************************************************************************
 
792
 * HRendererConnectionInfo
 
793
 ******************************************************************************/
 
794
HRendererConnectionInfo::HRendererConnectionInfo(
 
795
    HRendererConnection* owner) :
 
796
        QObject(reinterpret_cast<QObject*>(owner)),
 
797
            h_ptr(new HRendererConnectionInfoPrivate())
 
798
{
 
799
    h_ptr->q_ptr = this;
 
800
    h_ptr->m_parent = owner;
 
801
}
 
802
 
 
803
HRendererConnectionInfo::~HRendererConnectionInfo()
 
804
{
 
805
    delete h_ptr;
 
806
}
 
807
 
 
808
HRendererConnection* HRendererConnectionInfo::connection() const
 
809
{
 
810
    return h_ptr->m_parent;
 
811
}
 
812
 
 
813
HTransportState HRendererConnectionInfo::transportState() const
 
814
{
 
815
    return h_ptr->m_transportInfo.state();
 
816
}
 
817
 
 
818
HTransportStatus HRendererConnectionInfo::transportStatus() const
 
819
{
 
820
    return h_ptr->m_transportInfo.status();
 
821
}
 
822
 
 
823
HMediaInfo::MediaCategory HRendererConnectionInfo::currentMediaCategory() const
 
824
{
 
825
    return h_ptr->m_mediaInfo.mediaCategory();
 
826
}
 
827
 
 
828
HStorageMedium HRendererConnectionInfo::playbackStorageMedium() const
 
829
{
 
830
    return h_ptr->m_mediaInfo.playMedium();
 
831
}
 
832
 
 
833
HStorageMedium HRendererConnectionInfo::recordStorageMedium() const
 
834
{
 
835
    return h_ptr->m_mediaInfo.recordMedium();
 
836
}
 
837
 
 
838
QSet<HStorageMedium> HRendererConnectionInfo::possiblePlaybackStorageMedia() const
 
839
{
 
840
    return h_ptr->m_deviceCapabilities.playMedia();
 
841
}
 
842
 
 
843
QSet<HStorageMedium> HRendererConnectionInfo::possibleRecordStorageMedia() const
 
844
{
 
845
    return h_ptr->m_deviceCapabilities.recordMedia();
 
846
}
 
847
 
 
848
HPlayMode HRendererConnectionInfo::currentPlayMode() const
 
849
{
 
850
    return h_ptr->m_transportSettings.playMode();
 
851
}
 
852
 
 
853
QString HRendererConnectionInfo::transportPlaySpeed() const
 
854
{
 
855
    return h_ptr->m_transportInfo.speed();
 
856
}
 
857
 
 
858
HRecordMediumWriteStatus HRendererConnectionInfo::recordMediumWriteStatus() const
 
859
{
 
860
    return h_ptr->m_mediaInfo.writeStatus();
 
861
}
 
862
 
 
863
HRecordQualityMode HRendererConnectionInfo::currentRecordQualityMode() const
 
864
{
 
865
    return h_ptr->m_transportSettings.recordQualityMode();
 
866
}
 
867
 
 
868
QSet<HRecordQualityMode> HRendererConnectionInfo::possibleRecordQualityModes() const
 
869
{
 
870
    return h_ptr->m_deviceCapabilities.recordQualityModes();
 
871
}
 
872
 
 
873
quint32 HRendererConnectionInfo::numberOfTracks() const
 
874
{
 
875
    return h_ptr->m_mediaInfo.numberOfTracks();
 
876
}
 
877
 
 
878
quint32 HRendererConnectionInfo::currentTrack() const
 
879
{
 
880
    return h_ptr->m_positionInfo.track();
 
881
}
 
882
 
 
883
HDuration HRendererConnectionInfo::currentTrackDuration() const
 
884
{
 
885
    return h_ptr->m_positionInfo.trackDuration();
 
886
}
 
887
 
 
888
HDuration HRendererConnectionInfo::currentMediaDuration() const
 
889
{
 
890
    return h_ptr->m_mediaInfo.mediaDuration();
 
891
}
 
892
 
 
893
QString HRendererConnectionInfo::currentTrackMetadata() const
 
894
{
 
895
    return h_ptr->m_positionInfo.trackMetadata();
 
896
}
 
897
 
 
898
QUrl HRendererConnectionInfo::currentTrackUri() const
 
899
{
 
900
    return h_ptr->m_positionInfo.trackUri();
 
901
}
 
902
 
 
903
QUrl HRendererConnectionInfo::currentResourceUri() const
 
904
{
 
905
    return h_ptr->m_mediaInfo.currentUri();
 
906
}
 
907
 
 
908
QString HRendererConnectionInfo::currentResourceMetadata() const
 
909
{
 
910
    return h_ptr->m_mediaInfo.currentUriMetadata();
 
911
}
 
912
 
 
913
QUrl HRendererConnectionInfo::nextResourceUri() const
 
914
{
 
915
    return h_ptr->m_mediaInfo.nextUri();
 
916
}
 
917
 
 
918
QString HRendererConnectionInfo::nextResourceMetadata() const
 
919
{
 
920
    return h_ptr->m_mediaInfo.nextUriMetadata();
 
921
}
 
922
 
 
923
HDuration HRendererConnectionInfo::relativeTimePosition() const
 
924
{
 
925
    return h_ptr->m_positionInfo.relativeTimePosition();
 
926
}
 
927
 
 
928
HDuration HRendererConnectionInfo::absoluteTimePosition() const
 
929
{
 
930
    return h_ptr->m_positionInfo.absoluteTimePosition();
 
931
}
 
932
 
 
933
qint32 HRendererConnectionInfo::relativeCounterPosition() const
 
934
{
 
935
    return h_ptr->m_positionInfo.relativeCounterPosition();
 
936
}
 
937
 
 
938
qint32 HRendererConnectionInfo::absoluteCounterPosition() const
 
939
{
 
940
    return h_ptr->m_positionInfo.absoluteCounterPosition();
 
941
}
 
942
 
 
943
QSet<HTransportAction> HRendererConnectionInfo::currentTransportActions() const
 
944
{
 
945
    return h_ptr->m_transportActions;
 
946
}
 
947
 
 
948
HAvTransportInfo::DrmState HRendererConnectionInfo::drmState() const
 
949
{
 
950
    return h_ptr->m_drmState;
 
951
}
 
952
 
 
953
HDeviceCapabilities HRendererConnectionInfo::deviceCapabilities() const
 
954
{
 
955
    return h_ptr->m_deviceCapabilities;
 
956
}
 
957
 
 
958
HMediaInfo HRendererConnectionInfo::mediaInfo() const
 
959
{
 
960
    return h_ptr->m_mediaInfo;
 
961
}
 
962
 
 
963
HPositionInfo HRendererConnectionInfo::positionInfo() const
 
964
{
 
965
    return h_ptr->m_positionInfo;
 
966
}
 
967
 
 
968
HTransportInfo HRendererConnectionInfo::transportInfo() const
 
969
{
 
970
    return h_ptr->m_transportInfo;
 
971
}
 
972
 
 
973
HTransportSettings HRendererConnectionInfo::transportSettings() const
 
974
{
 
975
    return h_ptr->m_transportSettings;
 
976
}
 
977
 
 
978
QSet<QString> HRendererConnectionInfo::presets() const
 
979
{
 
980
    return h_ptr->m_presets;
 
981
}
 
982
 
 
983
QString HRendererConnectionInfo::rcsAttributeToString(RcsAttribute arg)
 
984
{
 
985
    QString retVal = "";
 
986
    switch(arg)
 
987
    {
 
988
    case Brightness:
 
989
        retVal = "Brightness";
 
990
        break;
 
991
    case Contrast:
 
992
        retVal = "Contrast";
 
993
        break;
 
994
    case Sharpness:
 
995
        retVal = "Sharpness";
 
996
        break;
 
997
    case RedVideoGain:
 
998
        retVal = "RedVideoGain";
 
999
        break;
 
1000
    case GreenVideoGain:
 
1001
        retVal = "GreenVideoGain";
 
1002
        break;
 
1003
    case BlueVideoGain:
 
1004
        retVal = "BlueVideoGain";
 
1005
        break;
 
1006
    case RedVideoBlackLevel:
 
1007
        retVal = "RedVideoBlackLevel";
 
1008
        break;
 
1009
    case GreenVideoBlackLevel:
 
1010
        retVal = "GreenVideoBlackLevel";
 
1011
        break;
 
1012
    case BlueVideoBlackLevel:
 
1013
        retVal = "BlueVideoBlackLevel";
 
1014
        break;
 
1015
    case ColorTemperature:
 
1016
        retVal = "ColorTemperature";
 
1017
        break;
 
1018
    default:
 
1019
        Q_ASSERT(false);
 
1020
        break;
 
1021
    }
 
1022
    return retVal;
 
1023
}
 
1024
 
 
1025
quint16 HRendererConnectionInfo::rcsValue(RcsAttribute attr) const
 
1026
{
 
1027
    return h_ptr->m_rcsAttributes.value(attr);
 
1028
}
 
1029
 
 
1030
qint16 HRendererConnectionInfo::horizontalKeystone() const
 
1031
{
 
1032
    return h_ptr->m_horizontalKeystone;
 
1033
}
 
1034
 
 
1035
qint16 HRendererConnectionInfo::verticalKeystone() const
 
1036
{
 
1037
    return h_ptr->m_verticalKeystone;
 
1038
}
 
1039
 
 
1040
bool HRendererConnectionInfo::muted(const HChannel& channel, bool* ok) const
 
1041
{
 
1042
    HChannelInformation* info = h_ptr->getChannel(channel);
 
1043
    if (!info)
 
1044
    {
 
1045
        if (ok) { *ok = false; }
 
1046
        return false;
 
1047
    }
 
1048
    if (ok) { *ok = true; }
 
1049
    return info->muted;
 
1050
}
 
1051
 
 
1052
quint16 HRendererConnectionInfo::volume(const HChannel& channel, bool* ok) const
 
1053
{
 
1054
    HChannelInformation* info = h_ptr->getChannel(channel);
 
1055
    if (!info)
 
1056
    {
 
1057
        if (ok) { *ok = false; }
 
1058
        return false;
 
1059
    }
 
1060
    if (ok) { *ok = true; }
 
1061
    return info->volume;
 
1062
}
 
1063
 
 
1064
qint16 HRendererConnectionInfo::volumeDb(const HChannel& channel, bool* ok) const
 
1065
{
 
1066
    HChannelInformation* info = h_ptr->getChannel(channel);
 
1067
    if (!info)
 
1068
    {
 
1069
        if (ok) { *ok = false; }
 
1070
        return false;
 
1071
    }
 
1072
    if (ok) { *ok = true; }
 
1073
    return info->volumeDb;
 
1074
}
 
1075
 
 
1076
HVolumeDbRangeResult HRendererConnectionInfo::volumeDbRange(
 
1077
    const HChannel& channel, bool* ok) const
 
1078
{
 
1079
    HVolumeDbRangeResult retVal;
 
1080
    HChannelInformation* info = h_ptr->getChannel(channel);
 
1081
    if (ok)
 
1082
    {
 
1083
        *ok = info;
 
1084
    }
 
1085
    if (info)
 
1086
    {
 
1087
        retVal = HVolumeDbRangeResult(info->minVolumeDb, info->maxVolumeDb);
 
1088
    }
 
1089
    return retVal;
 
1090
}
 
1091
 
 
1092
bool HRendererConnectionInfo::loudnessEnabled(const HChannel& channel, bool* ok) const
 
1093
{
 
1094
    HChannelInformation* info = h_ptr->getChannel(channel);
 
1095
    if (!info)
 
1096
    {
 
1097
        if (ok) { *ok = false; }
 
1098
        return false;
 
1099
    }
 
1100
    if (ok) { *ok = true; }
 
1101
    return info->loudness;
 
1102
}
 
1103
 
 
1104
void HRendererConnectionInfo::setTransportState(const HTransportState& arg)
 
1105
{
 
1106
    if (arg != transportState())
 
1107
    {
 
1108
        h_ptr->m_transportInfo.setState(arg);
 
1109
        emit propertyChanged(this, HRendererConnectionEventInfo(
 
1110
            "TransportState", h_ptr->getTransportState()));
 
1111
    }
 
1112
}
 
1113
 
 
1114
void HRendererConnectionInfo::setTransportStatus(const HTransportStatus& arg)
 
1115
{
 
1116
    if (arg != transportStatus())
 
1117
    {
 
1118
        h_ptr->m_transportInfo.setStatus(arg);
 
1119
        emit propertyChanged(this, HRendererConnectionEventInfo(
 
1120
            "TransportStatus", h_ptr->getTransportStatus()));
 
1121
    }
 
1122
}
 
1123
 
 
1124
void HRendererConnectionInfo::setCurrentMediaCategory(HMediaInfo::MediaCategory arg)
 
1125
{
 
1126
    if (arg != currentMediaCategory())
 
1127
    {
 
1128
        h_ptr->m_mediaInfo.setMediaCategory(arg);
 
1129
        emit propertyChanged(this, HRendererConnectionEventInfo(
 
1130
            "CurrentMediaCategory", h_ptr->getCurrentMediaCategory()));
 
1131
    }
 
1132
}
 
1133
 
 
1134
void HRendererConnectionInfo::setPlaybackStorageMedium(const HStorageMedium& arg)
 
1135
{
 
1136
    if (arg != playbackStorageMedium())
 
1137
    {
 
1138
        h_ptr->m_mediaInfo.setPlayMedium(arg);
 
1139
        emit propertyChanged(this, HRendererConnectionEventInfo(
 
1140
            "PlaybackStorageMedium", h_ptr->getPlaybackStorageMedium()));
 
1141
    }
 
1142
}
 
1143
 
 
1144
void HRendererConnectionInfo::setRecordStorageMedium(const HStorageMedium& arg)
 
1145
{
 
1146
    if (arg != recordStorageMedium())
 
1147
    {
 
1148
        h_ptr->m_mediaInfo.setRecordMedium(arg);
 
1149
        emit propertyChanged(this, HRendererConnectionEventInfo(
 
1150
            "RecordStorageMedium", h_ptr->getRecordStorageMedium()));
 
1151
    }
 
1152
}
 
1153
 
 
1154
void HRendererConnectionInfo::setPossiblePlaybackStorageMedia(
 
1155
    const QSet<HStorageMedium>& arg)
 
1156
{
 
1157
    if (arg != possiblePlaybackStorageMedia())
 
1158
    {
 
1159
        h_ptr->m_deviceCapabilities.setPlayMedia(arg);
 
1160
        emit propertyChanged(this, HRendererConnectionEventInfo(
 
1161
            "PossiblePlaybackStorageMedia", h_ptr->getPossiblePlaybackStorageMedia()));
 
1162
    }
 
1163
}
 
1164
 
 
1165
void HRendererConnectionInfo::setPossibleRecordStorageMedia(
 
1166
    const QSet<HStorageMedium>& arg)
 
1167
{
 
1168
    if (arg != possibleRecordStorageMedia())
 
1169
    {
 
1170
        h_ptr->m_deviceCapabilities.setRecordMedia(arg);
 
1171
        emit propertyChanged(this, HRendererConnectionEventInfo(
 
1172
            "PossibleRecordStorageMedia", h_ptr->getPossibleRecordStorageMedia()));
 
1173
    }
 
1174
}
 
1175
 
 
1176
void HRendererConnectionInfo::setCurrentPlayMode(const HPlayMode& arg)
 
1177
{
 
1178
    if (arg != currentPlayMode())
 
1179
    {
 
1180
        h_ptr->m_transportSettings.setPlayMode(arg);
 
1181
        emit propertyChanged(this, HRendererConnectionEventInfo(
 
1182
            "CurrentPlayMode", h_ptr->getCurrentPlayMode()));
 
1183
    }
 
1184
}
 
1185
 
 
1186
void HRendererConnectionInfo::setTransportPlaySpeed(const QString& arg)
 
1187
{
 
1188
    if (arg != transportPlaySpeed())
 
1189
    {
 
1190
        h_ptr->m_transportInfo.setSpeed(arg);
 
1191
        emit propertyChanged(this, HRendererConnectionEventInfo(
 
1192
            "TransportPlaySpeed", h_ptr->getTransportPlaySpeed()));
 
1193
    }
 
1194
}
 
1195
 
 
1196
void HRendererConnectionInfo::setRecordMediumWriteStatus(
 
1197
    const HRecordMediumWriteStatus& arg)
 
1198
{
 
1199
    if (arg != recordMediumWriteStatus())
 
1200
    {
 
1201
        h_ptr->m_mediaInfo.setWriteStatus(arg);
 
1202
        emit propertyChanged(this, HRendererConnectionEventInfo(
 
1203
            "RecordMediumWriteStatus", h_ptr->getRecordMediumWriteStatus()));
 
1204
    }
 
1205
}
 
1206
 
 
1207
void HRendererConnectionInfo::setCurrentRecordQualityMode(
 
1208
    const HRecordQualityMode& arg)
 
1209
{
 
1210
    if (arg != currentRecordQualityMode())
 
1211
    {
 
1212
        h_ptr->m_transportSettings.setRecordQualityMode(arg);
 
1213
        emit propertyChanged(this, HRendererConnectionEventInfo(
 
1214
            "CurrentRecordQualityMode", h_ptr->getCurrentRecordQualityMode()));
 
1215
    }
 
1216
}
 
1217
 
 
1218
void HRendererConnectionInfo::setPossibleRecordQualityModes(
 
1219
    const QSet<HRecordQualityMode>& arg)
 
1220
{
 
1221
    if (arg != possibleRecordQualityModes())
 
1222
    {
 
1223
        h_ptr->m_deviceCapabilities.setRecordQualityModes(arg);
 
1224
        emit propertyChanged(this, HRendererConnectionEventInfo(
 
1225
            "PossibleRecordQualityModes", h_ptr->getPossibleRecordQualityModes()));
 
1226
    }
 
1227
}
 
1228
 
 
1229
void HRendererConnectionInfo::setNumberOfTracks(quint32 arg)
 
1230
{
 
1231
    if (arg != numberOfTracks())
 
1232
    {
 
1233
        h_ptr->m_mediaInfo.setNumberOfTracks(arg);
 
1234
        emit propertyChanged(this, HRendererConnectionEventInfo(
 
1235
            "NumberOfTracks", h_ptr->getNumberOfTracks()));
 
1236
    }
 
1237
}
 
1238
 
 
1239
void HRendererConnectionInfo::setCurrentTrack(quint32 arg)
 
1240
{
 
1241
    if (arg != currentTrack())
 
1242
    {
 
1243
        h_ptr->m_positionInfo.setTrack(arg);
 
1244
        emit propertyChanged(this, HRendererConnectionEventInfo(
 
1245
            "CurrentTrack", h_ptr->getCurrentTrack()));
 
1246
    }
 
1247
}
 
1248
 
 
1249
void HRendererConnectionInfo::setCurrentTrackDuration(const HDuration& arg)
 
1250
{
 
1251
    if (arg != currentTrackDuration())
 
1252
    {
 
1253
        h_ptr->m_positionInfo.setTrackDuration(arg);
 
1254
        emit propertyChanged(this, HRendererConnectionEventInfo(
 
1255
            "CurrentTrackDuration", h_ptr->getCurrentTrackDuration()));
 
1256
    }
 
1257
}
 
1258
 
 
1259
void HRendererConnectionInfo::setCurrentMediaDuration(const HDuration& arg)
 
1260
{
 
1261
    if (arg != currentMediaDuration())
 
1262
    {
 
1263
        h_ptr->m_mediaInfo.setMediaDuration(arg);
 
1264
        emit propertyChanged(this, HRendererConnectionEventInfo(
 
1265
            "CurrentMediaDuration", h_ptr->getCurrentMediaDuration()));
 
1266
    }
 
1267
}
 
1268
 
 
1269
void HRendererConnectionInfo::setCurrentTrackMetadata(const QString& arg)
 
1270
{
 
1271
    if (arg != currentTrackMetadata())
 
1272
    {
 
1273
        h_ptr->m_positionInfo.setTrackMetadata(arg);
 
1274
        emit propertyChanged(this, HRendererConnectionEventInfo(
 
1275
            "CurrentTrackMetaData", h_ptr->getCurrentTrackMetaData()));
 
1276
    }
 
1277
}
 
1278
 
 
1279
void HRendererConnectionInfo::setCurrentTrackUri(const QUrl& arg)
 
1280
{
 
1281
    if (arg != currentTrackUri())
 
1282
    {
 
1283
        h_ptr->m_positionInfo.setTrackUri(arg);
 
1284
        emit propertyChanged(this, HRendererConnectionEventInfo(
 
1285
            "CurrentTrackURI", h_ptr->getCurrentTrackURI()));
 
1286
    }
 
1287
}
 
1288
 
 
1289
void HRendererConnectionInfo::setCurrentResourceUri(const QUrl& arg)
 
1290
{
 
1291
    if (arg != currentResourceUri())
 
1292
    {
 
1293
        h_ptr->m_mediaInfo.setCurrentUri(arg);
 
1294
        emit propertyChanged(this, HRendererConnectionEventInfo(
 
1295
            "AVTransportURI", h_ptr->getAVTransportURI()));
 
1296
    }
 
1297
}
 
1298
 
 
1299
void HRendererConnectionInfo::setCurrentResourceMetadata(const QString& arg)
 
1300
{
 
1301
    if (arg != currentResourceMetadata())
 
1302
    {
 
1303
        h_ptr->m_mediaInfo.setCurrentUriMetadata(arg);
 
1304
        emit propertyChanged(this, HRendererConnectionEventInfo(
 
1305
            "AVTransportURIMetaData", h_ptr->getAVTransportURIMetaData()));
 
1306
    }
 
1307
}
 
1308
 
 
1309
void HRendererConnectionInfo::setNextResourceUri(const QUrl& arg)
 
1310
{
 
1311
    if (arg != nextResourceUri())
 
1312
    {
 
1313
        h_ptr->m_mediaInfo.setNextUri(arg);
 
1314
        emit propertyChanged(this, HRendererConnectionEventInfo(
 
1315
            "NextAVTransportURI", h_ptr->getNextAVTransportURI()));
 
1316
    }
 
1317
}
 
1318
 
 
1319
void HRendererConnectionInfo::setNextResourceMetadata(const QString& arg)
 
1320
{
 
1321
    if (arg != nextResourceMetadata())
 
1322
    {
 
1323
        h_ptr->m_mediaInfo.setNextUriMetadata(arg);
 
1324
        emit propertyChanged(this, HRendererConnectionEventInfo(
 
1325
            "NextAVTransportURIMetaData", h_ptr->getNextAVTransportURIMetaData()));
 
1326
    }
 
1327
}
 
1328
 
 
1329
void HRendererConnectionInfo::setRelativeTimePosition(const HDuration& arg)
 
1330
{
 
1331
    if (arg != relativeTimePosition())
 
1332
    {
 
1333
        h_ptr->m_positionInfo.setRelativeTimePosition(arg);
 
1334
        emit propertyChanged(this, HRendererConnectionEventInfo(
 
1335
            "RelativeTimePosition", h_ptr->getRelativeTimePosition()));
 
1336
    }
 
1337
}
 
1338
 
 
1339
void HRendererConnectionInfo::setAbsoluteTimePosition(const HDuration& arg)
 
1340
{
 
1341
    if (arg != absoluteTimePosition())
 
1342
    {
 
1343
        h_ptr->m_positionInfo.setAbsoluteTimePosition(arg);
 
1344
        emit propertyChanged(this, HRendererConnectionEventInfo(
 
1345
            "AbsoluteTimePosition", h_ptr->getAbsoluteTimePosition()));
 
1346
    }
 
1347
}
 
1348
 
 
1349
void HRendererConnectionInfo::setRelativeCounterPosition(qint32 arg)
 
1350
{
 
1351
    if (arg != relativeCounterPosition())
 
1352
    {
 
1353
        h_ptr->m_positionInfo.setRelativeCounterPosition(arg);
 
1354
        emit propertyChanged(this, HRendererConnectionEventInfo(
 
1355
            "RelativeCounterPosition", h_ptr->getRelativeCounterPosition()));
 
1356
    }
 
1357
}
 
1358
 
 
1359
void HRendererConnectionInfo::setAbsoluteCounterPosition(qint32 arg)
 
1360
{
 
1361
    if (arg != absoluteCounterPosition())
 
1362
    {
 
1363
        h_ptr->m_positionInfo.setAbsoluteCounterPosition(arg);
 
1364
        emit propertyChanged(this, HRendererConnectionEventInfo(
 
1365
            "AbsoluteCounterPosition", h_ptr->getAbsoluteCounterPosition()));
 
1366
    }
 
1367
}
 
1368
 
 
1369
void HRendererConnectionInfo::setCurrentTransportActions(
 
1370
    const QSet<HTransportAction>& arg)
 
1371
{
 
1372
    if (arg != currentTransportActions())
 
1373
    {
 
1374
        h_ptr->m_transportActions = arg;
 
1375
        emit propertyChanged(this, HRendererConnectionEventInfo(
 
1376
            "CurrentTransportActions", h_ptr->getCurrentTransportActions()));
 
1377
    }
 
1378
}
 
1379
 
 
1380
void HRendererConnectionInfo::setDrmState(HAvTransportInfo::DrmState arg)
 
1381
{
 
1382
    if (arg != drmState())
 
1383
    {
 
1384
        h_ptr->m_drmState = arg;
 
1385
        emit propertyChanged(this, HRendererConnectionEventInfo(
 
1386
            "DRMState", h_ptr->getDrmState()));
 
1387
    }
 
1388
}
 
1389
 
 
1390
void HRendererConnectionInfo::setDeviceCapabilities(
 
1391
    const HDeviceCapabilities& arg)
 
1392
{
 
1393
    setPossiblePlaybackStorageMedia(arg.playMedia());
 
1394
    setPossibleRecordQualityModes(arg.recordQualityModes());
 
1395
    setPossibleRecordStorageMedia(arg.recordMedia());
 
1396
}
 
1397
 
 
1398
void HRendererConnectionInfo::setMediaInfo(const HMediaInfo& arg)
 
1399
{
 
1400
    setCurrentResourceUri(arg.currentUri());
 
1401
    setCurrentResourceMetadata(arg.currentUriMetadata());
 
1402
    setCurrentMediaCategory(arg.mediaCategory());
 
1403
    setCurrentMediaDuration(arg.mediaDuration());
 
1404
    setNextResourceUri(arg.nextUri());
 
1405
    setNextResourceMetadata(arg.nextUriMetadata());
 
1406
    setNumberOfTracks(arg.numberOfTracks());
 
1407
    setPlaybackStorageMedium(arg.playMedium());
 
1408
    setRecordStorageMedium(arg.recordMedium());
 
1409
    setRecordMediumWriteStatus(arg.writeStatus());
 
1410
}
 
1411
 
 
1412
void HRendererConnectionInfo::setPositionInfo(const HPositionInfo& arg)
 
1413
{
 
1414
    setAbsoluteCounterPosition(arg.absoluteCounterPosition());
 
1415
    setAbsoluteTimePosition(arg.absoluteTimePosition());
 
1416
    setRelativeCounterPosition(arg.relativeCounterPosition());
 
1417
    setRelativeTimePosition(arg.relativeTimePosition());
 
1418
    setCurrentTrack(arg.track());
 
1419
    setCurrentTrackDuration(arg.trackDuration());
 
1420
    setCurrentTrackMetadata(arg.trackMetadata());
 
1421
    setCurrentTrackUri(arg.trackUri());
 
1422
}
 
1423
 
 
1424
void HRendererConnectionInfo::setTransportInfo(const HTransportInfo& arg)
 
1425
{
 
1426
    setTransportPlaySpeed(arg.speed());
 
1427
    setTransportState(arg.state());
 
1428
    setTransportStatus(arg.status());
 
1429
}
 
1430
 
 
1431
void HRendererConnectionInfo::setTransportSettings(const HTransportSettings& arg)
 
1432
{
 
1433
    setCurrentPlayMode(arg.playMode());
 
1434
    setCurrentRecordQualityMode(arg.recordQualityMode());
 
1435
}
 
1436
 
 
1437
void HRendererConnectionInfo::setPresets(const QSet<QString>& presets)
 
1438
{
 
1439
    h_ptr->m_presets = presets;
 
1440
}
 
1441
 
 
1442
void HRendererConnectionInfo::setRcsValue(RcsAttribute attr, quint16 value)
 
1443
{
 
1444
    if (h_ptr->m_rcsAttributes.value(attr) != value)
 
1445
    {
 
1446
        h_ptr->m_rcsAttributes.insert(attr, value);
 
1447
        emit propertyChanged(this, HRendererConnectionEventInfo(
 
1448
            rcsAttributeToString(attr), QString::number(value)));
 
1449
    }
 
1450
}
 
1451
 
 
1452
void HRendererConnectionInfo::setHorizontalKeystone(qint16 value)
 
1453
{
 
1454
    if (horizontalKeystone() != value)
 
1455
    {
 
1456
        h_ptr->m_horizontalKeystone = value;
 
1457
        emit propertyChanged(this, HRendererConnectionEventInfo(
 
1458
            "HorizontalKeystone", QString::number(value)));
 
1459
    }
 
1460
}
 
1461
 
 
1462
void HRendererConnectionInfo::setVerticalKeystone(qint16 value)
 
1463
{
 
1464
    if (verticalKeystone() != value)
 
1465
    {
 
1466
        h_ptr->m_verticalKeystone = value;
 
1467
        emit propertyChanged(this, HRendererConnectionEventInfo(
 
1468
            "VerticalKeystone", QString::number(value)));
 
1469
    }
 
1470
}
 
1471
 
 
1472
bool HRendererConnectionInfo::setMute(const HChannel& channel, bool enabled)
 
1473
{
 
1474
    HChannelInformation* info = 0;
 
1475
    if ((info = h_ptr->checkAndAddChannel(channel)))
 
1476
    {
 
1477
        if (info->muted != enabled)
 
1478
        {
 
1479
            info->muted = enabled;
 
1480
            emit propertyChanged(this, HRendererConnectionEventInfo(
 
1481
                "Mute", enabled ? "1" : "0"));
 
1482
        }
 
1483
    }
 
1484
    return info;
 
1485
}
 
1486
 
 
1487
bool HRendererConnectionInfo::setVolume(const HChannel& channel, quint16 value)
 
1488
{
 
1489
    HChannelInformation* info = 0;
 
1490
    if ((info = h_ptr->checkAndAddChannel(channel)))
 
1491
    {
 
1492
        if (info->volume != value)
 
1493
        {
 
1494
            info->volume = value;
 
1495
            emit propertyChanged(this, HRendererConnectionEventInfo(
 
1496
                "Volume", QString::number(value)));
 
1497
        }
 
1498
    }
 
1499
    return info;
 
1500
}
 
1501
 
 
1502
bool HRendererConnectionInfo::setVolumeDb(const HChannel& channel, qint16 value)
 
1503
{
 
1504
    HChannelInformation* info = 0;
 
1505
    if ((info = h_ptr->checkAndAddChannel(channel)))
 
1506
    {
 
1507
        if (info->volumeDb != value)
 
1508
        {
 
1509
            info->volumeDb = value;
 
1510
            emit propertyChanged(this, HRendererConnectionEventInfo(
 
1511
                "VolumeDB", QString::number(value)));
 
1512
        }
 
1513
    }
 
1514
    return info;
 
1515
}
 
1516
 
 
1517
bool HRendererConnectionInfo::setLoudness(const HChannel& channel, bool enabled)
 
1518
{
 
1519
    HChannelInformation* info = 0;
 
1520
    if ((info = h_ptr->checkAndAddChannel(channel)))
 
1521
    {
 
1522
        if (info->loudness != enabled)
 
1523
        {
 
1524
            info->loudness = enabled;
 
1525
            emit propertyChanged(this, HRendererConnectionEventInfo(
 
1526
                "Loudness", enabled ? "1" : "0"));
 
1527
        }
 
1528
    }
 
1529
    return info;
 
1530
}
 
1531
 
 
1532
QString HRendererConnectionInfo::value(const QString& svName, bool* ok) const
 
1533
{
 
1534
    return value(svName, HChannel(), ok);
 
1535
}
 
1536
 
 
1537
QString HRendererConnectionInfo::value(
 
1538
    const QString& svName, const HChannel& channel, bool* ok) const
 
1539
{
 
1540
    if (h_ptr->m_valueGetters.contains(svName))
 
1541
    {
 
1542
        if (ok) { *ok = true; }
 
1543
        ValueGetter getter = h_ptr->m_valueGetters.value(svName);
 
1544
        return getter(channel);
 
1545
    }
 
1546
 
 
1547
    if (ok) { *ok = false; }
 
1548
    return QString();
 
1549
}
 
1550
 
 
1551
bool HRendererConnectionInfo::setValue(const QString& svName, const QString& value)
 
1552
{
 
1553
    return setValue(svName, HChannel(), value);
 
1554
}
 
1555
 
 
1556
bool HRendererConnectionInfo::setValue(
 
1557
    const QString& svName, const HChannel& channel, const QString& value)
 
1558
{
 
1559
    if (h_ptr->m_valueSetters.contains(svName))
 
1560
    {
 
1561
        ValueSetter setter = h_ptr->m_valueSetters.value(svName);
 
1562
        setter(value, channel);
 
1563
        return true;
 
1564
    }
 
1565
    return false;
 
1566
}
 
1567
 
 
1568
bool HRendererConnectionInfo::hasChannelAssociated(const QString& svName)
 
1569
{
 
1570
    bool retVal = false;
 
1571
    QString trimmed = svName.trimmed();
 
1572
    if (trimmed.compare("Mute", Qt::CaseInsensitive) == 0)
 
1573
    {
 
1574
        retVal = true;
 
1575
    }
 
1576
    else if (trimmed.compare("Volume", Qt::CaseInsensitive) == 0)
 
1577
    {
 
1578
        retVal = true;
 
1579
    }
 
1580
    else if (trimmed.compare("VolumeDB", Qt::CaseInsensitive) == 0)
 
1581
    {
 
1582
        retVal = true;
 
1583
    }
 
1584
    else if (trimmed.compare("Loudness", Qt::CaseInsensitive) == 0)
 
1585
    {
 
1586
        retVal = true;
 
1587
    }
 
1588
    return retVal;
 
1589
}
 
1590
 
 
1591
}
 
1592
}
 
1593
}