vdr
2.0.2
Main Page
Namespaces
Classes
Files
File List
File Members
PLUGINS
src
dvbhddevice
libhdffcmd
hdffcmd_av.c
Go to the documentation of this file.
1
/**********************************************************************
2
*
3
* HDFF firmware command interface library
4
*
5
* Copyright (C) 2011 Andreas Regel
6
*
7
* This program is free software; you can redistribute it and/or
8
* modify it under the terms of the GNU General Public License
9
* as published by the Free Software Foundation; either version 2
10
* of the License, or (at your option) any later version.
11
12
* This program is distributed in the hope that it will be useful,
13
* but WITHOUT ANY WARRANTY; without even the implied warranty of
14
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15
* GNU General Public License for more details.
16
17
* You should have received a copy of the GNU General Public License
18
* along with this program; if not, write to the
19
* Free Software Foundation, Inc.,
20
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
21
*
22
*********************************************************************/
23
24
#include <stdint.h>
25
#include <string.h>
26
#include <sys/ioctl.h>
27
28
#include "
hdffcmd.h
"
29
#include "
hdffcmd_base.h
"
30
#include "
hdffcmd_defs.h
"
31
32
33
int
HdffCmdAvSetPlayMode
(
int
OsdDevice, uint8_t PlayMode,
int
Realtime)
34
{
35
uint8_t cmdData[8];
36
BitBuffer_t
cmdBuf;
37
osd_raw_cmd_t
osd_cmd;
38
39
BitBuffer_Init
(&cmdBuf, cmdData,
sizeof
(cmdData));
40
memset(&osd_cmd, 0,
sizeof
(
osd_raw_cmd_t
));
41
osd_cmd.
cmd_data
= cmdData;
42
HdffCmdBuildHeader
(&cmdBuf,
HDFF_MSG_TYPE_COMMAND
,
43
HDFF_MSG_GROUP_AV_DECODER
,
44
HDFF_MSG_AV_SET_PLAY_MODE
);
45
BitBuffer_SetBits
(&cmdBuf, 1, Realtime ? 1 : 0);
46
BitBuffer_SetBits
(&cmdBuf, 7, PlayMode);
47
osd_cmd.
cmd_len
=
HdffCmdSetLength
(&cmdBuf);
48
return
ioctl(OsdDevice,
OSD_RAW_CMD
, &osd_cmd);
49
}
50
51
int
HdffCmdAvSetVideoPid
(
int
OsdDevice, uint8_t DecoderIndex, uint16_t Pid,
52
HdffVideoStreamType_t
StreamType)
53
{
54
uint8_t cmdData[16];
55
BitBuffer_t
cmdBuf;
56
osd_raw_cmd_t
osd_cmd;
57
58
BitBuffer_Init
(&cmdBuf, cmdData,
sizeof
(cmdData));
59
memset(&osd_cmd, 0,
sizeof
(
osd_raw_cmd_t
));
60
osd_cmd.
cmd_data
= cmdData;
61
HdffCmdBuildHeader
(&cmdBuf,
HDFF_MSG_TYPE_COMMAND
,
62
HDFF_MSG_GROUP_AV_DECODER
,
63
HDFF_MSG_AV_SET_VIDEO_PID
);
64
BitBuffer_SetBits
(&cmdBuf, 4, DecoderIndex);
65
BitBuffer_SetBits
(&cmdBuf, 4, StreamType);
66
BitBuffer_SetBits
(&cmdBuf, 3, 0);
// reserved
67
BitBuffer_SetBits
(&cmdBuf, 13, Pid);
68
osd_cmd.
cmd_len
=
HdffCmdSetLength
(&cmdBuf);
69
return
ioctl(OsdDevice,
OSD_RAW_CMD
, &osd_cmd);
70
}
71
72
int
HdffCmdAvSetAudioPid
(
int
OsdDevice, uint8_t DecoderIndex, uint16_t Pid,
73
HdffAudioStreamType_t
StreamType,
74
HdffAvContainerType_t
ContainerType)
75
{
76
uint8_t cmdData[16];
77
BitBuffer_t
cmdBuf;
78
osd_raw_cmd_t
osd_cmd;
79
80
BitBuffer_Init
(&cmdBuf, cmdData,
sizeof
(cmdData));
81
memset(&osd_cmd, 0,
sizeof
(
osd_raw_cmd_t
));
82
osd_cmd.
cmd_data
= cmdData;
83
HdffCmdBuildHeader
(&cmdBuf,
HDFF_MSG_TYPE_COMMAND
,
84
HDFF_MSG_GROUP_AV_DECODER
,
85
HDFF_MSG_AV_SET_AUDIO_PID
);
86
BitBuffer_SetBits
(&cmdBuf, 4, DecoderIndex);
87
BitBuffer_SetBits
(&cmdBuf, 4, StreamType);
88
BitBuffer_SetBits
(&cmdBuf, 2, 0);
// reserved
89
BitBuffer_SetBits
(&cmdBuf, 1, ContainerType);
90
BitBuffer_SetBits
(&cmdBuf, 13, Pid);
91
osd_cmd.
cmd_len
=
HdffCmdSetLength
(&cmdBuf);
92
return
ioctl(OsdDevice,
OSD_RAW_CMD
, &osd_cmd);
93
}
94
95
int
HdffCmdAvSetPcrPid
(
int
OsdDevice, uint8_t DecoderIndex, uint16_t Pid)
96
{
97
uint8_t cmdData[16];
98
BitBuffer_t
cmdBuf;
99
osd_raw_cmd_t
osd_cmd;
100
101
BitBuffer_Init
(&cmdBuf, cmdData,
sizeof
(cmdData));
102
memset(&osd_cmd, 0,
sizeof
(
osd_raw_cmd_t
));
103
osd_cmd.
cmd_data
= cmdData;
104
HdffCmdBuildHeader
(&cmdBuf,
HDFF_MSG_TYPE_COMMAND
,
105
HDFF_MSG_GROUP_AV_DECODER
,
106
HDFF_MSG_AV_SET_PCR_PID
);
107
BitBuffer_SetBits
(&cmdBuf, 4, DecoderIndex);
108
BitBuffer_SetBits
(&cmdBuf, 4, 0);
// reserved
109
BitBuffer_SetBits
(&cmdBuf, 3, 0);
// reserved
110
BitBuffer_SetBits
(&cmdBuf, 13, Pid);
111
osd_cmd.
cmd_len
=
HdffCmdSetLength
(&cmdBuf);
112
return
ioctl(OsdDevice,
OSD_RAW_CMD
, &osd_cmd);
113
}
114
115
int
HdffCmdAvSetTeletextPid
(
int
OsdDevice, uint8_t DecoderIndex, uint16_t Pid)
116
{
117
uint8_t cmdData[16];
118
BitBuffer_t
cmdBuf;
119
osd_raw_cmd_t
osd_cmd;
120
121
BitBuffer_Init
(&cmdBuf, cmdData,
sizeof
(cmdData));
122
memset(&osd_cmd, 0,
sizeof
(
osd_raw_cmd_t
));
123
osd_cmd.
cmd_data
= cmdData;
124
HdffCmdBuildHeader
(&cmdBuf,
HDFF_MSG_TYPE_COMMAND
,
125
HDFF_MSG_GROUP_AV_DECODER
,
126
HDFF_MSG_AV_SET_TELETEXT_PID
);
127
BitBuffer_SetBits
(&cmdBuf, 4, DecoderIndex);
128
BitBuffer_SetBits
(&cmdBuf, 4, 0);
// reserved
129
BitBuffer_SetBits
(&cmdBuf, 3, 0);
// reserved
130
BitBuffer_SetBits
(&cmdBuf, 13, Pid);
131
osd_cmd.
cmd_len
=
HdffCmdSetLength
(&cmdBuf);
132
return
ioctl(OsdDevice,
OSD_RAW_CMD
, &osd_cmd);
133
}
134
135
int
HdffCmdAvSetVideoWindow
(
int
OsdDevice, uint8_t DecoderIndex,
int
Enable,
136
uint16_t X, uint16_t Y, uint16_t Width,
137
uint16_t Height)
138
{
139
uint8_t cmdData[16];
140
BitBuffer_t
cmdBuf;
141
osd_raw_cmd_t
osd_cmd;
142
143
BitBuffer_Init
(&cmdBuf, cmdData,
sizeof
(cmdData));
144
memset(&osd_cmd, 0,
sizeof
(
osd_raw_cmd_t
));
145
osd_cmd.
cmd_data
= cmdData;
146
HdffCmdBuildHeader
(&cmdBuf,
HDFF_MSG_TYPE_COMMAND
,
147
HDFF_MSG_GROUP_AV_DECODER
,
148
HDFF_MSG_AV_SET_VIDEO_WINDOW
);
149
BitBuffer_SetBits
(&cmdBuf, 4, DecoderIndex);
150
BitBuffer_SetBits
(&cmdBuf, 3, 0);
// reserved
151
if
(Enable)
152
BitBuffer_SetBits
(&cmdBuf, 1, 1);
153
else
154
BitBuffer_SetBits
(&cmdBuf, 1, 0);
155
BitBuffer_SetBits
(&cmdBuf, 16, X);
156
BitBuffer_SetBits
(&cmdBuf, 16, Y);
157
BitBuffer_SetBits
(&cmdBuf, 16, Width);
158
BitBuffer_SetBits
(&cmdBuf, 16, Height);
159
osd_cmd.
cmd_len
=
HdffCmdSetLength
(&cmdBuf);
160
return
ioctl(OsdDevice,
OSD_RAW_CMD
, &osd_cmd);
161
}
162
163
int
HdffCmdAvShowStillImage
(
int
OsdDevice, uint8_t DecoderIndex,
164
const
uint8_t * StillImage,
int
Size,
165
HdffVideoStreamType_t
StreamType)
166
{
167
uint8_t cmdData[16];
168
BitBuffer_t
cmdBuf;
169
osd_raw_cmd_t
osd_cmd;
170
osd_raw_data_t
osd_data;
171
int
err;
172
173
memset(&osd_data, 0,
sizeof
(
osd_raw_data_t
));
174
osd_data.
data_buffer
= StillImage;
175
osd_data.
data_length
= Size;
176
err = ioctl(OsdDevice,
OSD_RAW_DATA
, &osd_data);
177
if
(err != 0)
178
return
err;
179
180
BitBuffer_Init
(&cmdBuf, cmdData,
sizeof
(cmdData));
181
memset(&osd_cmd, 0,
sizeof
(
osd_raw_cmd_t
));
182
osd_cmd.
cmd_data
= cmdData;
183
HdffCmdBuildHeader
(&cmdBuf,
HDFF_MSG_TYPE_COMMAND
,
184
HDFF_MSG_GROUP_AV_DECODER
,
185
HDFF_MSG_AV_SHOW_STILL_IMAGE
);
186
BitBuffer_SetBits
(&cmdBuf, 4, DecoderIndex);
187
BitBuffer_SetBits
(&cmdBuf, 4, StreamType);
188
BitBuffer_SetBits
(&cmdBuf, 16, osd_data.
data_handle
);
189
osd_cmd.
cmd_len
=
HdffCmdSetLength
(&cmdBuf);
190
return
ioctl(OsdDevice,
OSD_RAW_CMD
, &osd_cmd);
191
}
192
193
int
HdffCmdAvSetDecoderInput
(
int
OsdDevice, uint8_t DecoderIndex,
194
uint8_t DemultiplexerIndex)
195
{
196
uint8_t cmdData[16];
197
BitBuffer_t
cmdBuf;
198
osd_raw_cmd_t
osd_cmd;
199
200
BitBuffer_Init
(&cmdBuf, cmdData,
sizeof
(cmdData));
201
memset(&osd_cmd, 0,
sizeof
(
osd_raw_cmd_t
));
202
osd_cmd.
cmd_data
= cmdData;
203
HdffCmdBuildHeader
(&cmdBuf,
HDFF_MSG_TYPE_COMMAND
,
204
HDFF_MSG_GROUP_AV_DECODER
,
205
HDFF_MSG_AV_SET_DECODER_INPUT
);
206
BitBuffer_SetBits
(&cmdBuf, 4, DecoderIndex);
207
BitBuffer_SetBits
(&cmdBuf, 4, DemultiplexerIndex);
208
osd_cmd.
cmd_len
=
HdffCmdSetLength
(&cmdBuf);
209
return
ioctl(OsdDevice,
OSD_RAW_CMD
, &osd_cmd);
210
}
211
212
int
HdffCmdAvSetDemultiplexerInput
(
int
OsdDevice, uint8_t DemultiplexerIndex,
213
uint8_t TsInputIndex)
214
{
215
uint8_t cmdData[16];
216
BitBuffer_t
cmdBuf;
217
osd_raw_cmd_t
osd_cmd;
218
219
BitBuffer_Init
(&cmdBuf, cmdData,
sizeof
(cmdData));
220
memset(&osd_cmd, 0,
sizeof
(
osd_raw_cmd_t
));
221
osd_cmd.
cmd_data
= cmdData;
222
HdffCmdBuildHeader
(&cmdBuf,
HDFF_MSG_TYPE_COMMAND
,
223
HDFF_MSG_GROUP_AV_DECODER
,
224
HDFF_MSG_AV_SET_DEMULTIPLEXER_INPUT
);
225
BitBuffer_SetBits
(&cmdBuf, 4, DemultiplexerIndex);
226
BitBuffer_SetBits
(&cmdBuf, 4, TsInputIndex);
227
osd_cmd.
cmd_len
=
HdffCmdSetLength
(&cmdBuf);
228
return
ioctl(OsdDevice,
OSD_RAW_CMD
, &osd_cmd);
229
}
230
231
int
HdffCmdAvSetVideoFormat
(
int
OsdDevice, uint8_t DecoderIndex,
232
const
HdffVideoFormat_t
* VideoFormat)
233
{
234
uint8_t cmdData[16];
235
BitBuffer_t
cmdBuf;
236
osd_raw_cmd_t
osd_cmd;
237
238
BitBuffer_Init
(&cmdBuf, cmdData,
sizeof
(cmdData));
239
memset(&osd_cmd, 0,
sizeof
(
osd_raw_cmd_t
));
240
osd_cmd.
cmd_data
= cmdData;
241
HdffCmdBuildHeader
(&cmdBuf,
HDFF_MSG_TYPE_COMMAND
,
242
HDFF_MSG_GROUP_AV_DECODER
,
243
HDFF_MSG_AV_SET_VIDEO_FORMAT
);
244
BitBuffer_SetBits
(&cmdBuf, 4, DecoderIndex);
245
BitBuffer_SetBits
(&cmdBuf, 1, VideoFormat->
AutomaticEnabled
? 1 : 0);
246
BitBuffer_SetBits
(&cmdBuf, 1, VideoFormat->
AfdEnabled
? 1 : 0);
247
BitBuffer_SetBits
(&cmdBuf, 2, VideoFormat->
TvFormat
);
248
BitBuffer_SetBits
(&cmdBuf, 8, VideoFormat->
VideoConversion
);
249
osd_cmd.
cmd_len
=
HdffCmdSetLength
(&cmdBuf);
250
return
ioctl(OsdDevice,
OSD_RAW_CMD
, &osd_cmd);
251
}
252
253
int
HdffCmdAvSetVideoOutputMode
(
int
OsdDevice, uint8_t DecoderIndex,
254
HdffVideoOutputMode_t
OutputMode)
255
{
256
uint8_t cmdData[16];
257
BitBuffer_t
cmdBuf;
258
osd_raw_cmd_t
osd_cmd;
259
260
BitBuffer_Init
(&cmdBuf, cmdData,
sizeof
(cmdData));
261
memset(&osd_cmd, 0,
sizeof
(
osd_raw_cmd_t
));
262
osd_cmd.
cmd_data
= cmdData;
263
HdffCmdBuildHeader
(&cmdBuf,
HDFF_MSG_TYPE_COMMAND
,
264
HDFF_MSG_GROUP_AV_DECODER
,
265
HDFF_MSG_AV_SET_VIDEO_OUTPUT_MODE
);
266
BitBuffer_SetBits
(&cmdBuf, 8, OutputMode);
267
osd_cmd.
cmd_len
=
HdffCmdSetLength
(&cmdBuf);
268
return
ioctl(OsdDevice,
OSD_RAW_CMD
, &osd_cmd);
269
}
270
271
int
HdffCmdAvSetStc
(
int
OsdDevice, uint8_t DecoderIndex, uint64_t Stc)
272
{
273
uint8_t cmdData[16];
274
BitBuffer_t
cmdBuf;
275
osd_raw_cmd_t
osd_cmd;
276
277
BitBuffer_Init
(&cmdBuf, cmdData,
sizeof
(cmdData));
278
memset(&osd_cmd, 0,
sizeof
(
osd_raw_cmd_t
));
279
osd_cmd.
cmd_data
= cmdData;
280
HdffCmdBuildHeader
(&cmdBuf,
HDFF_MSG_TYPE_COMMAND
,
281
HDFF_MSG_GROUP_AV_DECODER
,
282
HDFF_MSG_AV_SET_STC
);
283
BitBuffer_SetBits
(&cmdBuf, 4, DecoderIndex);
284
BitBuffer_SetBits
(&cmdBuf, 3, 0);
// reserved
285
BitBuffer_SetBits
(&cmdBuf, 1, (uint32_t) (Stc >> 32));
286
BitBuffer_SetBits
(&cmdBuf, 32, (uint32_t) Stc);
287
osd_cmd.
cmd_len
=
HdffCmdSetLength
(&cmdBuf);
288
return
ioctl(OsdDevice,
OSD_RAW_CMD
, &osd_cmd);
289
}
290
291
int
HdffCmdAvFlushBuffer
(
int
OsdDevice, uint8_t DecoderIndex,
int
FlushAudio,
292
int
FlushVideo)
293
{
294
uint8_t cmdData[16];
295
BitBuffer_t
cmdBuf;
296
osd_raw_cmd_t
osd_cmd;
297
298
BitBuffer_Init
(&cmdBuf, cmdData,
sizeof
(cmdData));
299
memset(&osd_cmd, 0,
sizeof
(
osd_raw_cmd_t
));
300
osd_cmd.
cmd_data
= cmdData;
301
HdffCmdBuildHeader
(&cmdBuf,
HDFF_MSG_TYPE_COMMAND
,
302
HDFF_MSG_GROUP_AV_DECODER
,
303
HDFF_MSG_AV_FLUSH_BUFFER
);
304
BitBuffer_SetBits
(&cmdBuf, 4, DecoderIndex);
305
if
(FlushAudio)
306
{
307
BitBuffer_SetBits
(&cmdBuf, 1, 1);
308
}
309
else
310
{
311
BitBuffer_SetBits
(&cmdBuf, 1, 0);
312
}
313
if
(FlushVideo)
314
{
315
BitBuffer_SetBits
(&cmdBuf, 1, 1);
316
}
317
else
318
{
319
BitBuffer_SetBits
(&cmdBuf, 1, 0);
320
}
321
osd_cmd.
cmd_len
=
HdffCmdSetLength
(&cmdBuf);
322
return
ioctl(OsdDevice,
OSD_RAW_CMD
, &osd_cmd);
323
}
324
325
int
HdffCmdAvEnableSync
(
int
OsdDevice, uint8_t DecoderIndex,
int
SyncAudio,
326
int
SyncVideo)
327
{
328
uint8_t cmdData[16];
329
BitBuffer_t
cmdBuf;
330
osd_raw_cmd_t
osd_cmd;
331
332
BitBuffer_Init
(&cmdBuf, cmdData,
sizeof
(cmdData));
333
memset(&osd_cmd, 0,
sizeof
(
osd_raw_cmd_t
));
334
osd_cmd.
cmd_data
= cmdData;
335
HdffCmdBuildHeader
(&cmdBuf,
HDFF_MSG_TYPE_COMMAND
,
336
HDFF_MSG_GROUP_AV_DECODER
,
337
HDFF_MSG_AV_ENABLE_SYNC
);
338
BitBuffer_SetBits
(&cmdBuf, 4, DecoderIndex);
339
BitBuffer_SetBits
(&cmdBuf, 1, SyncAudio ? 1 : 0);
340
BitBuffer_SetBits
(&cmdBuf, 1, SyncVideo ? 1 : 0);
341
osd_cmd.
cmd_len
=
HdffCmdSetLength
(&cmdBuf);
342
return
ioctl(OsdDevice,
OSD_RAW_CMD
, &osd_cmd);
343
}
344
345
int
HdffCmdAvSetVideoSpeed
(
int
OsdDevice, uint8_t DecoderIndex, int32_t Speed)
346
{
347
uint8_t cmdData[16];
348
BitBuffer_t
cmdBuf;
349
osd_raw_cmd_t
osd_cmd;
350
351
BitBuffer_Init
(&cmdBuf, cmdData,
sizeof
(cmdData));
352
memset(&osd_cmd, 0,
sizeof
(
osd_raw_cmd_t
));
353
osd_cmd.
cmd_data
= cmdData;
354
HdffCmdBuildHeader
(&cmdBuf,
HDFF_MSG_TYPE_COMMAND
,
355
HDFF_MSG_GROUP_AV_DECODER
,
356
HDFF_MSG_AV_SET_VIDEO_SPEED
);
357
BitBuffer_SetBits
(&cmdBuf, 4, DecoderIndex);
358
BitBuffer_SetBits
(&cmdBuf, 4, 0);
359
BitBuffer_SetBits
(&cmdBuf, 32, Speed);
360
osd_cmd.
cmd_len
=
HdffCmdSetLength
(&cmdBuf);
361
return
ioctl(OsdDevice,
OSD_RAW_CMD
, &osd_cmd);
362
}
363
364
int
HdffCmdAvSetAudioSpeed
(
int
OsdDevice, uint8_t DecoderIndex, int32_t Speed)
365
{
366
uint8_t cmdData[16];
367
BitBuffer_t
cmdBuf;
368
osd_raw_cmd_t
osd_cmd;
369
370
BitBuffer_Init
(&cmdBuf, cmdData,
sizeof
(cmdData));
371
memset(&osd_cmd, 0,
sizeof
(
osd_raw_cmd_t
));
372
osd_cmd.
cmd_data
= cmdData;
373
HdffCmdBuildHeader
(&cmdBuf,
HDFF_MSG_TYPE_COMMAND
,
374
HDFF_MSG_GROUP_AV_DECODER
,
375
HDFF_MSG_AV_SET_AUDIO_SPEED
);
376
BitBuffer_SetBits
(&cmdBuf, 4, DecoderIndex);
377
BitBuffer_SetBits
(&cmdBuf, 4, 0);
378
BitBuffer_SetBits
(&cmdBuf, 32, Speed);
379
osd_cmd.
cmd_len
=
HdffCmdSetLength
(&cmdBuf);
380
return
ioctl(OsdDevice,
OSD_RAW_CMD
, &osd_cmd);
381
}
382
383
int
HdffCmdAvEnableVideoAfterStop
(
int
OsdDevice, uint8_t DecoderIndex,
384
int
EnableVideoAfterStop)
385
{
386
uint8_t cmdData[16];
387
BitBuffer_t
cmdBuf;
388
osd_raw_cmd_t
osd_cmd;
389
390
BitBuffer_Init
(&cmdBuf, cmdData,
sizeof
(cmdData));
391
memset(&osd_cmd, 0,
sizeof
(
osd_raw_cmd_t
));
392
osd_cmd.
cmd_data
= cmdData;
393
HdffCmdBuildHeader
(&cmdBuf,
HDFF_MSG_TYPE_COMMAND
,
394
HDFF_MSG_GROUP_AV_DECODER
,
395
HDFF_MSG_AV_ENABLE_VIDEO_AFTER_STOP
);
396
BitBuffer_SetBits
(&cmdBuf, 4, DecoderIndex);
397
BitBuffer_SetBits
(&cmdBuf, 1, EnableVideoAfterStop ? 1 : 0);
398
osd_cmd.
cmd_len
=
HdffCmdSetLength
(&cmdBuf);
399
return
ioctl(OsdDevice,
OSD_RAW_CMD
, &osd_cmd);
400
}
401
402
int
HdffCmdAvSetAudioDelay
(
int
OsdDevice, int16_t Delay)
403
{
404
uint8_t cmdData[16];
405
BitBuffer_t
cmdBuf;
406
osd_raw_cmd_t
osd_cmd;
407
408
BitBuffer_Init
(&cmdBuf, cmdData,
sizeof
(cmdData));
409
memset(&osd_cmd, 0,
sizeof
(
osd_raw_cmd_t
));
410
osd_cmd.
cmd_data
= cmdData;
411
HdffCmdBuildHeader
(&cmdBuf,
HDFF_MSG_TYPE_COMMAND
,
412
HDFF_MSG_GROUP_AV_DECODER
,
413
HDFF_MSG_AV_SET_AUDIO_DELAY
);
414
BitBuffer_SetBits
(&cmdBuf, 16, Delay);
415
osd_cmd.
cmd_len
=
HdffCmdSetLength
(&cmdBuf);
416
return
ioctl(OsdDevice,
OSD_RAW_CMD
, &osd_cmd);
417
}
418
419
int
HdffCmdAvSetAudioDownmix
(
int
OsdDevice,
HdffAudioDownmixMode_t
DownmixMode)
420
{
421
uint8_t cmdData[16];
422
BitBuffer_t
cmdBuf;
423
osd_raw_cmd_t
osd_cmd;
424
425
BitBuffer_Init
(&cmdBuf, cmdData,
sizeof
(cmdData));
426
memset(&osd_cmd, 0,
sizeof
(
osd_raw_cmd_t
));
427
osd_cmd.
cmd_data
= cmdData;
428
HdffCmdBuildHeader
(&cmdBuf,
HDFF_MSG_TYPE_COMMAND
,
429
HDFF_MSG_GROUP_AV_DECODER
,
430
HDFF_MSG_AV_SET_AUDIO_DOWNMIX
);
431
BitBuffer_SetBits
(&cmdBuf, 8, DownmixMode);
432
osd_cmd.
cmd_len
=
HdffCmdSetLength
(&cmdBuf);
433
return
ioctl(OsdDevice,
OSD_RAW_CMD
, &osd_cmd);
434
}
435
436
int
HdffCmdAvSetAudioChannel
(
int
OsdDevice, uint8_t AudioChannel)
437
{
438
uint8_t cmdData[16];
439
BitBuffer_t
cmdBuf;
440
osd_raw_cmd_t
osd_cmd;
441
442
BitBuffer_Init
(&cmdBuf, cmdData,
sizeof
(cmdData));
443
memset(&osd_cmd, 0,
sizeof
(
osd_raw_cmd_t
));
444
osd_cmd.
cmd_data
= cmdData;
445
HdffCmdBuildHeader
(&cmdBuf,
HDFF_MSG_TYPE_COMMAND
,
446
HDFF_MSG_GROUP_AV_DECODER
,
447
HDFF_MSG_AV_SET_AUDIO_CHANNEL
);
448
BitBuffer_SetBits
(&cmdBuf, 8, AudioChannel);
449
osd_cmd.
cmd_len
=
HdffCmdSetLength
(&cmdBuf);
450
return
ioctl(OsdDevice,
OSD_RAW_CMD
, &osd_cmd);
451
}
452
453
int
HdffCmdAvSetSyncShift
(
int
OsdDevice, int16_t SyncShift)
454
{
455
uint8_t cmdData[16];
456
BitBuffer_t
cmdBuf;
457
osd_raw_cmd_t
osd_cmd;
458
459
BitBuffer_Init
(&cmdBuf, cmdData,
sizeof
(cmdData));
460
memset(&osd_cmd, 0,
sizeof
(
osd_raw_cmd_t
));
461
osd_cmd.
cmd_data
= cmdData;
462
HdffCmdBuildHeader
(&cmdBuf,
HDFF_MSG_TYPE_COMMAND
,
463
HDFF_MSG_GROUP_AV_DECODER
,
464
HDFF_MSG_AV_SET_OPTIONS
);
465
BitBuffer_SetBits
(&cmdBuf, 1, 1);
466
BitBuffer_SetBits
(&cmdBuf, 31, 0);
// reserved
467
BitBuffer_SetBits
(&cmdBuf, 16, SyncShift);
468
osd_cmd.
cmd_len
=
HdffCmdSetLength
(&cmdBuf);
469
return
ioctl(OsdDevice,
OSD_RAW_CMD
, &osd_cmd);
470
}
471
472
int
HdffCmdAvMuteAudio
(
int
OsdDevice, uint8_t DecoderIndex,
int
Mute)
473
{
474
uint8_t cmdData[16];
475
BitBuffer_t
cmdBuf;
476
osd_raw_cmd_t
osd_cmd;
477
478
BitBuffer_Init
(&cmdBuf, cmdData,
sizeof
(cmdData));
479
memset(&osd_cmd, 0,
sizeof
(
osd_raw_cmd_t
));
480
osd_cmd.
cmd_data
= cmdData;
481
HdffCmdBuildHeader
(&cmdBuf,
HDFF_MSG_TYPE_COMMAND
,
482
HDFF_MSG_GROUP_AV_DECODER
,
483
HDFF_MSG_AV_MUTE_AUDIO
);
484
BitBuffer_SetBits
(&cmdBuf, 4, DecoderIndex);
485
BitBuffer_SetBits
(&cmdBuf, 1, Mute ? 1 : 0);
486
osd_cmd.
cmd_len
=
HdffCmdSetLength
(&cmdBuf);
487
return
ioctl(OsdDevice,
OSD_RAW_CMD
, &osd_cmd);
488
}
489
490
int
HdffCmdAvMuteVideo
(
int
OsdDevice, uint8_t DecoderIndex,
int
Mute)
491
{
492
uint8_t cmdData[16];
493
BitBuffer_t
cmdBuf;
494
osd_raw_cmd_t
osd_cmd;
495
496
BitBuffer_Init
(&cmdBuf, cmdData,
sizeof
(cmdData));
497
memset(&osd_cmd, 0,
sizeof
(
osd_raw_cmd_t
));
498
osd_cmd.
cmd_data
= cmdData;
499
HdffCmdBuildHeader
(&cmdBuf,
HDFF_MSG_TYPE_COMMAND
,
500
HDFF_MSG_GROUP_AV_DECODER
,
501
HDFF_MSG_AV_MUTE_VIDEO
);
502
BitBuffer_SetBits
(&cmdBuf, 4, DecoderIndex);
503
BitBuffer_SetBits
(&cmdBuf, 1, Mute ? 1 : 0);
504
osd_cmd.
cmd_len
=
HdffCmdSetLength
(&cmdBuf);
505
return
ioctl(OsdDevice,
OSD_RAW_CMD
, &osd_cmd);
506
}
507
Generated by
1.8.3.1