diff options
Diffstat (limited to 'PLUGINS/src/dvbhddevice/libhdffcmd')
19 files changed, 2434 insertions, 0 deletions
diff --git a/PLUGINS/src/dvbhddevice/libhdffcmd/Makefile b/PLUGINS/src/dvbhddevice/libhdffcmd/Makefile new file mode 100644 index 0000000..f9c068a --- /dev/null +++ b/PLUGINS/src/dvbhddevice/libhdffcmd/Makefile @@ -0,0 +1,75 @@ +# +# Makefile for the HDFF firmware command interface library +# + +VERSION = 0.1.0 + +ifndef $(INSTALL_PATH) + INSTALL_PATH=/usr/local +endif + +ifndef $(INSTALL_LIB_PATH) + INSTALL_LIB_PATH=$(INSTALL_PATH)/lib +endif + +ifndef $(INSTALL_INCLUDE_PATH) + INSTALL_INCLUDE_PATH=$(INSTALL_PATH)/include +endif + +LIB_NAME = libhdffcmd + +LIB_OBJS = bitbuffer.o hdffcmd_av.o hdffcmd_base.o hdffcmd_generic.o \ + hdffcmd_hdmi.o hdffcmd_mux.o hdffcmd_osd.o hdffcmd_remote.o + +LIB_HEADERS = hdffcmd.h hdffcmd_av.h hdffcmd_generic.h hdffcmd_hdmi.h \ + hdffcmd_mux.h hdffcmd_osd.h hdffcmd_remote.h + +LIB_STATIC = $(LIB_NAME).a +LIB_SHARED = $(LIB_NAME)-$(VERSION).so + +CC = gcc +CFLAGS = -g -O2 -fPIC -Wall +AR = ar -r + +### Implicit rules: + +%.o: %.c + $(CC) $(CFLAGS) -c $(DEFINES) $(INCLUDES) $< + +# Dependencies: + +MAKEDEP = $(CC) -MM -MG +DEPFILE = .dependencies +$(DEPFILE): Makefile + @$(MAKEDEP) $(DEFINES) $(INCLUDES) $(OBJS:%.o=%.c) > $@ + +-include $(DEPFILE) + +### Targets: + +all: $(LIB_STATIC) $(LIB_SHARED) + +$(LIB_STATIC): $(LIB_OBJS) + $(AR) $(LIB_STATIC) $(LIB_OBJS) + +$(LIB_SHARED): $(LIB_OBJS) + $(CC) -fPIC -shared -o $(LIB_SHARED) $(LIB_OBJS) + ln -sf $(LIB_SHARED) $(LIB_NAME).so + +clean: + rm -f $(LIB_OBJS) $(DEPFILE) $(LIB_STATIC) $(LIB_NAME)*.so + +install: $(LIB_SHARED) + chown root $(LIB_SHARED) + chgrp root $(LIB_SHARED) + chmod 0755 $(LIB_SHARED) + cp -f $(LIB_SHARED) $(INSTALL_LIB_PATH)/ + ln -sf $(LIB_SHARED) $(INSTALL_LIB_PATH)/$(LIB_NAME).so + mkdir -p $(INSTALL_INCLUDE_PATH)/libhdffcmd + list='$(LIB_HEADERS)'; \ + for headerfile in $$list; do \ + cp -f $$headerfile $(INSTALL_INCLUDE_PATH)/libhdffcmd/ ; \ + chown root $(INSTALL_INCLUDE_PATH)/libhdffcmd/$$headerfile ; \ + chgrp root $(INSTALL_INCLUDE_PATH)/libhdffcmd/$$headerfile ; \ + chmod 0644 $(INSTALL_INCLUDE_PATH)/libhdffcmd/$$headerfile ; \ + done diff --git a/PLUGINS/src/dvbhddevice/libhdffcmd/bitbuffer.c b/PLUGINS/src/dvbhddevice/libhdffcmd/bitbuffer.c new file mode 100644 index 0000000..b85990d --- /dev/null +++ b/PLUGINS/src/dvbhddevice/libhdffcmd/bitbuffer.c @@ -0,0 +1,79 @@ +/********************************************************************** + * + * HDFF firmware command interface library + * + * Copyright (C) 2011 Andreas Regel + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the + * Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + *********************************************************************/ + +#include <string.h> + +#include "bitbuffer.h" + +void BitBuffer_Init(BitBuffer_t * BitBuffer, + uint8_t * Data, uint32_t MaxLength) +{ + memset(Data, 0, MaxLength); + BitBuffer->Data = Data; + BitBuffer->MaxLength = MaxLength * 8; + BitBuffer->BitPos = 0; +} + +void BitBuffer_SetBits(BitBuffer_t * BitBuffer, int NumBits, uint32_t Data) +{ + uint32_t nextBitPos; + uint32_t bytePos; + uint32_t bitsInByte; + int shift; + + if (NumBits <= 0 || NumBits > 32) + return; + + nextBitPos = BitBuffer->BitPos + NumBits; + + if (nextBitPos > BitBuffer->MaxLength) + return; + + bytePos = BitBuffer->BitPos / 8; + bitsInByte = BitBuffer->BitPos % 8; + + BitBuffer->Data[bytePos] &= (uint8_t) (0xFF << (8 - bitsInByte)); + shift = NumBits - (8 - bitsInByte); + if (shift > 0) + BitBuffer->Data[bytePos] |= (uint8_t) (Data >> shift); + else + BitBuffer->Data[bytePos] |= (uint8_t) (Data << (-shift)); + NumBits -= 8 - bitsInByte; + bytePos++; + while (NumBits > 0) + { + shift = NumBits - 8; + if (shift > 0) + BitBuffer->Data[bytePos] = (uint8_t) (Data >> shift); + else + BitBuffer->Data[bytePos] = (uint8_t) (Data << (-shift)); + NumBits -= 8; + bytePos++; + } + BitBuffer->BitPos = nextBitPos; +} + +uint32_t BitBuffer_GetByteLength(BitBuffer_t * BitBuffer) +{ + return (BitBuffer->BitPos + 7) / 8; +} diff --git a/PLUGINS/src/dvbhddevice/libhdffcmd/bitbuffer.h b/PLUGINS/src/dvbhddevice/libhdffcmd/bitbuffer.h new file mode 100644 index 0000000..5bdc23b --- /dev/null +++ b/PLUGINS/src/dvbhddevice/libhdffcmd/bitbuffer.h @@ -0,0 +1,43 @@ +/********************************************************************** + * + * HDFF firmware command interface library + * + * Copyright (C) 2011 Andreas Regel + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the + * Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + *********************************************************************/ + +#ifndef BITBUFFER_H +#define BITBUFFER_H + +#include <stdint.h> + +typedef struct BitBuffer_t +{ + uint8_t * Data; + uint32_t MaxLength; + uint32_t BitPos; +} BitBuffer_t; + +void BitBuffer_Init(BitBuffer_t * BitBuffer, + uint8_t * Data, uint32_t MaxLength); + +void BitBuffer_SetBits(BitBuffer_t * BitBuffer, int NumBits, uint32_t Data); + +uint32_t BitBuffer_GetByteLength(BitBuffer_t * BitBuffer); + +#endif /* BITBUFFER_H */ diff --git a/PLUGINS/src/dvbhddevice/libhdffcmd/hdffcmd.h b/PLUGINS/src/dvbhddevice/libhdffcmd/hdffcmd.h new file mode 100644 index 0000000..8d05782 --- /dev/null +++ b/PLUGINS/src/dvbhddevice/libhdffcmd/hdffcmd.h @@ -0,0 +1,42 @@ +/********************************************************************** + * + * HDFF firmware command interface library + * + * Copyright (C) 2011 Andreas Regel + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the + * Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + *********************************************************************/ + +#ifndef HDFFCMD_H +#define HDFFCMD_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "hdffcmd_av.h" +#include "hdffcmd_generic.h" +#include "hdffcmd_hdmi.h" +#include "hdffcmd_mux.h" +#include "hdffcmd_osd.h" +#include "hdffcmd_remote.h" + +#ifdef __cplusplus +} +#endif + +#endif /* HDFFCMD_H */ diff --git a/PLUGINS/src/dvbhddevice/libhdffcmd/hdffcmd_av.c b/PLUGINS/src/dvbhddevice/libhdffcmd/hdffcmd_av.c new file mode 100644 index 0000000..413f3e2 --- /dev/null +++ b/PLUGINS/src/dvbhddevice/libhdffcmd/hdffcmd_av.c @@ -0,0 +1,451 @@ +/********************************************************************** + * + * HDFF firmware command interface library + * + * Copyright (C) 2011 Andreas Regel + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the + * Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + *********************************************************************/ + +#include <stdint.h> +#include <string.h> +#include <sys/ioctl.h> + +#include "hdffcmd.h" +#include "hdffcmd_base.h" +#include "hdffcmd_defs.h" + + +int HdffCmdAvSetPlayMode(int OsdDevice, uint8_t PlayMode, int Realtime) +{ + uint8_t cmdData[8]; + BitBuffer_t cmdBuf; + osd_raw_cmd_t osd_cmd; + + BitBuffer_Init(&cmdBuf, cmdData, sizeof(cmdData)); + memset(&osd_cmd, 0, sizeof(osd_raw_cmd_t)); + osd_cmd.cmd_data = cmdData; + HdffCmdBuildHeader(&cmdBuf, HDFF_MSG_TYPE_COMMAND, + HDFF_MSG_GROUP_AV_DECODER, + HDFF_MSG_AV_SET_PLAY_MODE); + BitBuffer_SetBits(&cmdBuf, 1, Realtime ? 1 : 0); + BitBuffer_SetBits(&cmdBuf, 7, PlayMode); + osd_cmd.cmd_len = HdffCmdSetLength(&cmdBuf); + return ioctl(OsdDevice, OSD_RAW_CMD, &osd_cmd); +} + +int HdffCmdAvSetVideoPid(int OsdDevice, uint8_t DecoderIndex, uint16_t Pid, + HdffVideoStreamType_t StreamType) +{ + uint8_t cmdData[16]; + BitBuffer_t cmdBuf; + osd_raw_cmd_t osd_cmd; + + BitBuffer_Init(&cmdBuf, cmdData, sizeof(cmdData)); + memset(&osd_cmd, 0, sizeof(osd_raw_cmd_t)); + osd_cmd.cmd_data = cmdData; + HdffCmdBuildHeader(&cmdBuf, HDFF_MSG_TYPE_COMMAND, + HDFF_MSG_GROUP_AV_DECODER, + HDFF_MSG_AV_SET_VIDEO_PID); + BitBuffer_SetBits(&cmdBuf, 4, DecoderIndex); + BitBuffer_SetBits(&cmdBuf, 4, StreamType); + BitBuffer_SetBits(&cmdBuf, 3, 0); // reserved + BitBuffer_SetBits(&cmdBuf, 13, Pid); + osd_cmd.cmd_len = HdffCmdSetLength(&cmdBuf); + return ioctl(OsdDevice, OSD_RAW_CMD, &osd_cmd); +} + +int HdffCmdAvSetAudioPid(int OsdDevice, uint8_t DecoderIndex, uint16_t Pid, + HdffAudioStreamType_t StreamType, + HdffAvContainerType_t ContainerType) +{ + uint8_t cmdData[16]; + BitBuffer_t cmdBuf; + osd_raw_cmd_t osd_cmd; + + BitBuffer_Init(&cmdBuf, cmdData, sizeof(cmdData)); + memset(&osd_cmd, 0, sizeof(osd_raw_cmd_t)); + osd_cmd.cmd_data = cmdData; + HdffCmdBuildHeader(&cmdBuf, HDFF_MSG_TYPE_COMMAND, + HDFF_MSG_GROUP_AV_DECODER, + HDFF_MSG_AV_SET_AUDIO_PID); + BitBuffer_SetBits(&cmdBuf, 4, DecoderIndex); + BitBuffer_SetBits(&cmdBuf, 4, StreamType); + BitBuffer_SetBits(&cmdBuf, 2, 0); // reserved + BitBuffer_SetBits(&cmdBuf, 1, ContainerType); + BitBuffer_SetBits(&cmdBuf, 13, Pid); + osd_cmd.cmd_len = HdffCmdSetLength(&cmdBuf); + return ioctl(OsdDevice, OSD_RAW_CMD, &osd_cmd); +} + +int HdffCmdAvSetPcrPid(int OsdDevice, uint8_t DecoderIndex, uint16_t Pid) +{ + uint8_t cmdData[16]; + BitBuffer_t cmdBuf; + osd_raw_cmd_t osd_cmd; + + BitBuffer_Init(&cmdBuf, cmdData, sizeof(cmdData)); + memset(&osd_cmd, 0, sizeof(osd_raw_cmd_t)); + osd_cmd.cmd_data = cmdData; + HdffCmdBuildHeader(&cmdBuf, HDFF_MSG_TYPE_COMMAND, + HDFF_MSG_GROUP_AV_DECODER, + HDFF_MSG_AV_SET_PCR_PID); + BitBuffer_SetBits(&cmdBuf, 4, DecoderIndex); + BitBuffer_SetBits(&cmdBuf, 4, 0); // reserved + BitBuffer_SetBits(&cmdBuf, 3, 0); // reserved + BitBuffer_SetBits(&cmdBuf, 13, Pid); + osd_cmd.cmd_len = HdffCmdSetLength(&cmdBuf); + return ioctl(OsdDevice, OSD_RAW_CMD, &osd_cmd); +} + +int HdffCmdAvSetTeletextPid(int OsdDevice, uint8_t DecoderIndex, uint16_t Pid) +{ + uint8_t cmdData[16]; + BitBuffer_t cmdBuf; + osd_raw_cmd_t osd_cmd; + + BitBuffer_Init(&cmdBuf, cmdData, sizeof(cmdData)); + memset(&osd_cmd, 0, sizeof(osd_raw_cmd_t)); + osd_cmd.cmd_data = cmdData; + HdffCmdBuildHeader(&cmdBuf, HDFF_MSG_TYPE_COMMAND, + HDFF_MSG_GROUP_AV_DECODER, + HDFF_MSG_AV_SET_TELETEXT_PID); + BitBuffer_SetBits(&cmdBuf, 4, DecoderIndex); + BitBuffer_SetBits(&cmdBuf, 4, 0); // reserved + BitBuffer_SetBits(&cmdBuf, 3, 0); // reserved + BitBuffer_SetBits(&cmdBuf, 13, Pid); + osd_cmd.cmd_len = HdffCmdSetLength(&cmdBuf); + return ioctl(OsdDevice, OSD_RAW_CMD, &osd_cmd); +} + +int HdffCmdAvSetVideoWindow(int OsdDevice, uint8_t DecoderIndex, int Enable, + uint16_t X, uint16_t Y, uint16_t Width, + uint16_t Height) +{ + uint8_t cmdData[16]; + BitBuffer_t cmdBuf; + osd_raw_cmd_t osd_cmd; + + BitBuffer_Init(&cmdBuf, cmdData, sizeof(cmdData)); + memset(&osd_cmd, 0, sizeof(osd_raw_cmd_t)); + osd_cmd.cmd_data = cmdData; + HdffCmdBuildHeader(&cmdBuf, HDFF_MSG_TYPE_COMMAND, + HDFF_MSG_GROUP_AV_DECODER, + HDFF_MSG_AV_SET_VIDEO_WINDOW); + BitBuffer_SetBits(&cmdBuf, 4, DecoderIndex); + BitBuffer_SetBits(&cmdBuf, 3, 0); // reserved + if (Enable) + BitBuffer_SetBits(&cmdBuf, 1, 1); + else + BitBuffer_SetBits(&cmdBuf, 1, 0); + BitBuffer_SetBits(&cmdBuf, 16, X); + BitBuffer_SetBits(&cmdBuf, 16, Y); + BitBuffer_SetBits(&cmdBuf, 16, Width); + BitBuffer_SetBits(&cmdBuf, 16, Height); + osd_cmd.cmd_len = HdffCmdSetLength(&cmdBuf); + return ioctl(OsdDevice, OSD_RAW_CMD, &osd_cmd); +} + +int HdffCmdAvShowStillImage(int OsdDevice, uint8_t DecoderIndex, + const uint8_t * StillImage, int Size, + HdffVideoStreamType_t StreamType) +{ + uint8_t cmdData[16]; + BitBuffer_t cmdBuf; + osd_raw_cmd_t osd_cmd; + osd_raw_data_t osd_data; + int err; + + memset(&osd_data, 0, sizeof(osd_raw_data_t)); + osd_data.data_buffer = StillImage; + osd_data.data_length = Size; + err = ioctl(OsdDevice, OSD_RAW_DATA, &osd_data); + if (err != 0) + return err; + + BitBuffer_Init(&cmdBuf, cmdData, sizeof(cmdData)); + memset(&osd_cmd, 0, sizeof(osd_raw_cmd_t)); + osd_cmd.cmd_data = cmdData; + HdffCmdBuildHeader(&cmdBuf, HDFF_MSG_TYPE_COMMAND, + HDFF_MSG_GROUP_AV_DECODER, + HDFF_MSG_AV_SHOW_STILL_IMAGE); + BitBuffer_SetBits(&cmdBuf, 4, DecoderIndex); + BitBuffer_SetBits(&cmdBuf, 4, StreamType); + BitBuffer_SetBits(&cmdBuf, 16, osd_data.data_handle); + osd_cmd.cmd_len = HdffCmdSetLength(&cmdBuf); + return ioctl(OsdDevice, OSD_RAW_CMD, &osd_cmd); +} + +int HdffCmdAvSetDecoderInput(int OsdDevice, uint8_t DecoderIndex, + uint8_t DemultiplexerIndex) +{ + uint8_t cmdData[16]; + BitBuffer_t cmdBuf; + osd_raw_cmd_t osd_cmd; + + BitBuffer_Init(&cmdBuf, cmdData, sizeof(cmdData)); + memset(&osd_cmd, 0, sizeof(osd_raw_cmd_t)); + osd_cmd.cmd_data = cmdData; + HdffCmdBuildHeader(&cmdBuf, HDFF_MSG_TYPE_COMMAND, + HDFF_MSG_GROUP_AV_DECODER, + HDFF_MSG_AV_SET_DECODER_INPUT); + BitBuffer_SetBits(&cmdBuf, 4, DecoderIndex); + BitBuffer_SetBits(&cmdBuf, 4, DemultiplexerIndex); + osd_cmd.cmd_len = HdffCmdSetLength(&cmdBuf); + return ioctl(OsdDevice, OSD_RAW_CMD, &osd_cmd); +} + +int HdffCmdAvSetDemultiplexerInput(int OsdDevice, uint8_t DemultiplexerIndex, + uint8_t TsInputIndex) +{ + uint8_t cmdData[16]; + BitBuffer_t cmdBuf; + osd_raw_cmd_t osd_cmd; + + BitBuffer_Init(&cmdBuf, cmdData, sizeof(cmdData)); + memset(&osd_cmd, 0, sizeof(osd_raw_cmd_t)); + osd_cmd.cmd_data = cmdData; + HdffCmdBuildHeader(&cmdBuf, HDFF_MSG_TYPE_COMMAND, + HDFF_MSG_GROUP_AV_DECODER, + HDFF_MSG_AV_SET_DEMULTIPLEXER_INPUT); + BitBuffer_SetBits(&cmdBuf, 4, DemultiplexerIndex); + BitBuffer_SetBits(&cmdBuf, 4, TsInputIndex); + osd_cmd.cmd_len = HdffCmdSetLength(&cmdBuf); + return ioctl(OsdDevice, OSD_RAW_CMD, &osd_cmd); +} + +int HdffCmdAvSetVideoFormat(int OsdDevice, uint8_t DecoderIndex, + const HdffVideoFormat_t * VideoFormat) +{ + uint8_t cmdData[16]; + BitBuffer_t cmdBuf; + osd_raw_cmd_t osd_cmd; + + BitBuffer_Init(&cmdBuf, cmdData, sizeof(cmdData)); + memset(&osd_cmd, 0, sizeof(osd_raw_cmd_t)); + osd_cmd.cmd_data = cmdData; + HdffCmdBuildHeader(&cmdBuf, HDFF_MSG_TYPE_COMMAND, + HDFF_MSG_GROUP_AV_DECODER, + HDFF_MSG_AV_SET_VIDEO_FORMAT); + BitBuffer_SetBits(&cmdBuf, 4, DecoderIndex); + BitBuffer_SetBits(&cmdBuf, 1, VideoFormat->AutomaticEnabled ? 1 : 0); + BitBuffer_SetBits(&cmdBuf, 1, VideoFormat->AfdEnabled ? 1 : 0); + BitBuffer_SetBits(&cmdBuf, 2, VideoFormat->TvFormat); + BitBuffer_SetBits(&cmdBuf, 8, VideoFormat->VideoConversion); + osd_cmd.cmd_len = HdffCmdSetLength(&cmdBuf); + return ioctl(OsdDevice, OSD_RAW_CMD, &osd_cmd); +} + +int HdffCmdAvSetVideoOutputMode(int OsdDevice, uint8_t DecoderIndex, + HdffVideoOutputMode_t OutputMode) +{ + uint8_t cmdData[16]; + BitBuffer_t cmdBuf; + osd_raw_cmd_t osd_cmd; + + BitBuffer_Init(&cmdBuf, cmdData, sizeof(cmdData)); + memset(&osd_cmd, 0, sizeof(osd_raw_cmd_t)); + osd_cmd.cmd_data = cmdData; + HdffCmdBuildHeader(&cmdBuf, HDFF_MSG_TYPE_COMMAND, + HDFF_MSG_GROUP_AV_DECODER, + HDFF_MSG_AV_SET_VIDEO_OUTPUT_MODE); + BitBuffer_SetBits(&cmdBuf, 8, OutputMode); + osd_cmd.cmd_len = HdffCmdSetLength(&cmdBuf); + return ioctl(OsdDevice, OSD_RAW_CMD, &osd_cmd); +} + +int HdffCmdAvSetStc(int OsdDevice, uint8_t DecoderIndex, uint64_t Stc) +{ + uint8_t cmdData[16]; + BitBuffer_t cmdBuf; + osd_raw_cmd_t osd_cmd; + + BitBuffer_Init(&cmdBuf, cmdData, sizeof(cmdData)); + memset(&osd_cmd, 0, sizeof(osd_raw_cmd_t)); + osd_cmd.cmd_data = cmdData; + HdffCmdBuildHeader(&cmdBuf, HDFF_MSG_TYPE_COMMAND, + HDFF_MSG_GROUP_AV_DECODER, + HDFF_MSG_AV_SET_STC); + BitBuffer_SetBits(&cmdBuf, 4, DecoderIndex); + BitBuffer_SetBits(&cmdBuf, 3, 0); // reserved + BitBuffer_SetBits(&cmdBuf, 1, (uint32_t) (Stc >> 32)); + BitBuffer_SetBits(&cmdBuf, 32, (uint32_t) Stc); + osd_cmd.cmd_len = HdffCmdSetLength(&cmdBuf); + return ioctl(OsdDevice, OSD_RAW_CMD, &osd_cmd); +} + +int HdffCmdAvFlushBuffer(int OsdDevice, uint8_t DecoderIndex, int FlushAudio, + int FlushVideo) +{ + uint8_t cmdData[16]; + BitBuffer_t cmdBuf; + osd_raw_cmd_t osd_cmd; + + BitBuffer_Init(&cmdBuf, cmdData, sizeof(cmdData)); + memset(&osd_cmd, 0, sizeof(osd_raw_cmd_t)); + osd_cmd.cmd_data = cmdData; + HdffCmdBuildHeader(&cmdBuf, HDFF_MSG_TYPE_COMMAND, + HDFF_MSG_GROUP_AV_DECODER, + HDFF_MSG_AV_FLUSH_BUFFER); + BitBuffer_SetBits(&cmdBuf, 4, DecoderIndex); + if (FlushAudio) + { + BitBuffer_SetBits(&cmdBuf, 1, 1); + } + else + { + BitBuffer_SetBits(&cmdBuf, 1, 0); + } + if (FlushVideo) + { + BitBuffer_SetBits(&cmdBuf, 1, 1); + } + else + { + BitBuffer_SetBits(&cmdBuf, 1, 0); + } + osd_cmd.cmd_len = HdffCmdSetLength(&cmdBuf); + return ioctl(OsdDevice, OSD_RAW_CMD, &osd_cmd); +} + +int HdffCmdAvEnableSync(int OsdDevice, uint8_t DecoderIndex, int SyncAudio, + int SyncVideo) +{ + uint8_t cmdData[16]; + BitBuffer_t cmdBuf; + osd_raw_cmd_t osd_cmd; + + BitBuffer_Init(&cmdBuf, cmdData, sizeof(cmdData)); + memset(&osd_cmd, 0, sizeof(osd_raw_cmd_t)); + osd_cmd.cmd_data = cmdData; + HdffCmdBuildHeader(&cmdBuf, HDFF_MSG_TYPE_COMMAND, + HDFF_MSG_GROUP_AV_DECODER, + HDFF_MSG_AV_ENABLE_SYNC); + BitBuffer_SetBits(&cmdBuf, 4, DecoderIndex); + BitBuffer_SetBits(&cmdBuf, 1, SyncAudio ? 1 : 0); + BitBuffer_SetBits(&cmdBuf, 1, SyncVideo ? 1 : 0); + osd_cmd.cmd_len = HdffCmdSetLength(&cmdBuf); + return ioctl(OsdDevice, OSD_RAW_CMD, &osd_cmd); +} + +int HdffCmdAvSetVideoSpeed(int OsdDevice, uint8_t DecoderIndex, int32_t Speed) +{ + uint8_t cmdData[16]; + BitBuffer_t cmdBuf; + osd_raw_cmd_t osd_cmd; + + BitBuffer_Init(&cmdBuf, cmdData, sizeof(cmdData)); + memset(&osd_cmd, 0, sizeof(osd_raw_cmd_t)); + osd_cmd.cmd_data = cmdData; + HdffCmdBuildHeader(&cmdBuf, HDFF_MSG_TYPE_COMMAND, + HDFF_MSG_GROUP_AV_DECODER, + HDFF_MSG_AV_SET_VIDEO_SPEED); + BitBuffer_SetBits(&cmdBuf, 4, DecoderIndex); + BitBuffer_SetBits(&cmdBuf, 4, 0); + BitBuffer_SetBits(&cmdBuf, 32, Speed); + osd_cmd.cmd_len = HdffCmdSetLength(&cmdBuf); + return ioctl(OsdDevice, OSD_RAW_CMD, &osd_cmd); +} + +int HdffCmdAvSetAudioSpeed(int OsdDevice, uint8_t DecoderIndex, int32_t Speed) +{ + uint8_t cmdData[16]; + BitBuffer_t cmdBuf; + osd_raw_cmd_t osd_cmd; + + BitBuffer_Init(&cmdBuf, cmdData, sizeof(cmdData)); + memset(&osd_cmd, 0, sizeof(osd_raw_cmd_t)); + osd_cmd.cmd_data = cmdData; + HdffCmdBuildHeader(&cmdBuf, HDFF_MSG_TYPE_COMMAND, + HDFF_MSG_GROUP_AV_DECODER, + HDFF_MSG_AV_SET_AUDIO_SPEED); + BitBuffer_SetBits(&cmdBuf, 4, DecoderIndex); + BitBuffer_SetBits(&cmdBuf, 4, 0); + BitBuffer_SetBits(&cmdBuf, 32, Speed); + osd_cmd.cmd_len = HdffCmdSetLength(&cmdBuf); + return ioctl(OsdDevice, OSD_RAW_CMD, &osd_cmd); +} + +int HdffCmdAvEnableVideoAfterStop(int OsdDevice, uint8_t DecoderIndex, + int EnableVideoAfterStop) +{ + uint8_t cmdData[16]; + BitBuffer_t cmdBuf; + osd_raw_cmd_t osd_cmd; + + BitBuffer_Init(&cmdBuf, cmdData, sizeof(cmdData)); + memset(&osd_cmd, 0, sizeof(osd_raw_cmd_t)); + osd_cmd.cmd_data = cmdData; + HdffCmdBuildHeader(&cmdBuf, HDFF_MSG_TYPE_COMMAND, + HDFF_MSG_GROUP_AV_DECODER, + HDFF_MSG_AV_ENABLE_VIDEO_AFTER_STOP); + BitBuffer_SetBits(&cmdBuf, 4, DecoderIndex); + BitBuffer_SetBits(&cmdBuf, 1, EnableVideoAfterStop ? 1 : 0); + osd_cmd.cmd_len = HdffCmdSetLength(&cmdBuf); + return ioctl(OsdDevice, OSD_RAW_CMD, &osd_cmd); +} + +int HdffCmdAvSetAudioDelay(int OsdDevice, int16_t Delay) +{ + uint8_t cmdData[16]; + BitBuffer_t cmdBuf; + osd_raw_cmd_t osd_cmd; + + BitBuffer_Init(&cmdBuf, cmdData, sizeof(cmdData)); + memset(&osd_cmd, 0, sizeof(osd_raw_cmd_t)); + osd_cmd.cmd_data = cmdData; + HdffCmdBuildHeader(&cmdBuf, HDFF_MSG_TYPE_COMMAND, + HDFF_MSG_GROUP_AV_DECODER, + HDFF_MSG_AV_SET_AUDIO_DELAY); + BitBuffer_SetBits(&cmdBuf, 16, Delay); + osd_cmd.cmd_len = HdffCmdSetLength(&cmdBuf); + return ioctl(OsdDevice, OSD_RAW_CMD, &osd_cmd); +} + +int HdffCmdAvSetAudioDownmix(int OsdDevice, HdffAudioDownmixMode_t DownmixMode) +{ + uint8_t cmdData[16]; + BitBuffer_t cmdBuf; + osd_raw_cmd_t osd_cmd; + + BitBuffer_Init(&cmdBuf, cmdData, sizeof(cmdData)); + memset(&osd_cmd, 0, sizeof(osd_raw_cmd_t)); + osd_cmd.cmd_data = cmdData; + HdffCmdBuildHeader(&cmdBuf, HDFF_MSG_TYPE_COMMAND, + HDFF_MSG_GROUP_AV_DECODER, + HDFF_MSG_AV_SET_AUDIO_DOWNMIX); + BitBuffer_SetBits(&cmdBuf, 8, DownmixMode); + osd_cmd.cmd_len = HdffCmdSetLength(&cmdBuf); + return ioctl(OsdDevice, OSD_RAW_CMD, &osd_cmd); +} + +int HdffCmdAvSetAudioChannel(int OsdDevice, uint8_t AudioChannel) +{ + uint8_t cmdData[16]; + BitBuffer_t cmdBuf; + osd_raw_cmd_t osd_cmd; + + BitBuffer_Init(&cmdBuf, cmdData, sizeof(cmdData)); + memset(&osd_cmd, 0, sizeof(osd_raw_cmd_t)); + osd_cmd.cmd_data = cmdData; + HdffCmdBuildHeader(&cmdBuf, HDFF_MSG_TYPE_COMMAND, + HDFF_MSG_GROUP_AV_DECODER, + HDFF_MSG_AV_SET_AUDIO_CHANNEL); + BitBuffer_SetBits(&cmdBuf, 8, AudioChannel); + osd_cmd.cmd_len = HdffCmdSetLength(&cmdBuf); + return ioctl(OsdDevice, OSD_RAW_CMD, &osd_cmd); +} diff --git a/PLUGINS/src/dvbhddevice/libhdffcmd/hdffcmd_av.h b/PLUGINS/src/dvbhddevice/libhdffcmd/hdffcmd_av.h new file mode 100644 index 0000000..7c2189b --- /dev/null +++ b/PLUGINS/src/dvbhddevice/libhdffcmd/hdffcmd_av.h @@ -0,0 +1,151 @@ +/********************************************************************** + * + * HDFF firmware command interface library + * + * Copyright (C) 2011 Andreas Regel + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the + * Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + *********************************************************************/ + +#ifndef HDFFCMD_AV_H +#define HDFFCMD_AV_H + +typedef enum HdffAvContainerType_t +{ + HDFF_AV_CONTAINER_PES, + HDFF_AV_CONTAINER_PES_DVD +} HdffAvContainerType_t; + +typedef enum HdffAudioStreamType_t +{ + HDFF_AUDIO_STREAM_INVALID = -1, + HDFF_AUDIO_STREAM_MPEG1 = 0, + HDFF_AUDIO_STREAM_MPEG2, + HDFF_AUDIO_STREAM_AC3, + HDFF_AUDIO_STREAM_AAC, + HDFF_AUDIO_STREAM_HE_AAC, + HDFF_AUDIO_STREAM_PCM, + HDFF_AUDIO_STREAM_EAC3, + HDFF_AUDIO_STREAM_DTS +} HdffAudioStreamType_t; + +typedef enum HdffVideoStreamType_t +{ + HDFF_VIDEO_STREAM_INVALID = -1, + HDFF_VIDEO_STREAM_MPEG1 = 0, + HDFF_VIDEO_STREAM_MPEG2, + HDFF_VIDEO_STREAM_H264, + HDFF_VIDEO_STREAM_MPEG4_ASP, + HDFF_VIDEO_STREAM_VC1 +} HdffVideoStreamType_t; + +typedef enum HdffTvFormat_t +{ + HDFF_TV_FORMAT_4_BY_3, + HDFF_TV_FORMAT_16_BY_9 +} HdffTvFormat_t; + +typedef enum HdffVideoConversion_t +{ + HDFF_VIDEO_CONVERSION_AUTOMATIC, + HDFF_VIDEO_CONVERSION_LETTERBOX_16_BY_9, + HDFF_VIDEO_CONVERSION_LETTERBOX_14_BY_9, + HDFF_VIDEO_CONVERSION_PILLARBOX, + HDFF_VIDEO_CONVERSION_CENTRE_CUT_OUT, + HDFF_VIDEO_CONVERSION_ALWAYS_16_BY_9 +} HdffVideoConversion_t; + +typedef struct HdffVideoFormat_t +{ + int AutomaticEnabled; + int AfdEnabled; + HdffTvFormat_t TvFormat; + HdffVideoConversion_t VideoConversion; +} HdffVideoFormat_t; + +typedef enum HdffVideoOutputMode_t +{ + HDFF_VIDEO_OUTPUT_CLONE, + HDFF_VIDEO_OUTPUT_HD_ONLY +} HdffVideoOutputMode_t; + +typedef enum HdffAudioDownmixMode_t +{ + HDFF_AUDIO_DOWNMIX_OFF, + HDFF_AUDIO_DOWNMIX_ANALOG, + HDFF_AUDIO_DOWNMIX_ALWAYS, + HDFF_AUDIO_DOWNMIX_AUTOMATIC, + HDFF_AUDIO_DOWNMIX_HDMI_ONLY +} HdffAudioDownmixMode_t; + + +int HdffCmdAvSetPlayMode(int OsdDevice, uint8_t PlayMode, int Realtime); + +int HdffCmdAvSetVideoPid(int OsdDevice, uint8_t DecoderIndex, uint16_t Pid, + HdffVideoStreamType_t StreamType); + +int HdffCmdAvSetAudioPid(int OsdDevice, uint8_t DecoderIndex, uint16_t Pid, + HdffAudioStreamType_t StreamType, + HdffAvContainerType_t ContainerType); + +int HdffCmdAvSetPcrPid(int OsdDevice, uint8_t DecoderIndex, uint16_t Pid); + +int HdffCmdAvSetTeletextPid(int OsdDevice, uint8_t DecoderIndex, uint16_t Pid); + +int HdffCmdAvSetVideoWindow(int OsdDevice, uint8_t DecoderIndex, int Enable, + uint16_t X, uint16_t Y, uint16_t Width, + uint16_t Height); + +int HdffCmdAvShowStillImage(int OsdDevice, uint8_t DecoderIndex, + const uint8_t * StillImage, int Size, + HdffVideoStreamType_t StreamType); + +int HdffCmdAvSetDecoderInput(int OsdDevice, uint8_t DecoderIndex, + uint8_t DemultiplexerIndex); + +int HdffCmdAvSetDemultiplexerInput(int OsdDevice, uint8_t DemultiplexerIndex, + uint8_t TsInputIndex); + +int HdffCmdAvSetVideoFormat(int OsdDevice, uint8_t DecoderIndex, + const HdffVideoFormat_t * VideoFormat); + +int HdffCmdAvSetVideoOutputMode(int OsdDevice, uint8_t DecoderIndex, + HdffVideoOutputMode_t OutputMode); + +int HdffCmdAvSetStc(int OsdDevice, uint8_t DecoderIndex, uint64_t Stc); + +int HdffCmdAvFlushBuffer(int OsdDevice, uint8_t DecoderIndex, int FlushAudio, + int FlushVideo); + +int HdffCmdAvEnableSync(int OsdDevice, uint8_t DecoderIndex, int SyncAudio, + int SyncVideo); + +int HdffCmdAvSetVideoSpeed(int OsdDevice, uint8_t DecoderIndex, int32_t Speed); + +int HdffCmdAvSetAudioSpeed(int OsdDevice, uint8_t DecoderIndex, int32_t Speed); + +int HdffCmdAvEnableVideoAfterStop(int OsdDevice, uint8_t DecoderIndex, + int EnableVideoAfterStop); + +int HdffCmdAvSetAudioDelay(int OsdDevice, int16_t Delay); + +int HdffCmdAvSetAudioDownmix(int OsdDevice, + HdffAudioDownmixMode_t DownmixMode); + +int HdffCmdAvSetAudioChannel(int OsdDevice, uint8_t AudioChannel); + +#endif /* HDFFCMD_AV_H */ diff --git a/PLUGINS/src/dvbhddevice/libhdffcmd/hdffcmd_base.c b/PLUGINS/src/dvbhddevice/libhdffcmd/hdffcmd_base.c new file mode 100644 index 0000000..ac1ab7e --- /dev/null +++ b/PLUGINS/src/dvbhddevice/libhdffcmd/hdffcmd_base.c @@ -0,0 +1,45 @@ +/********************************************************************** + * + * HDFF firmware command interface library + * + * Copyright (C) 2011 Andreas Regel + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the + * Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + *********************************************************************/ + +#include "hdffcmd_base.h" + +void HdffCmdBuildHeader(BitBuffer_t * MsgBuf, HdffMessageType_t MsgType, + HdffMessageGroup_t MsgGroup, HdffMessageId_t MsgId) +{ + BitBuffer_SetBits(MsgBuf, 16, 0); // length field will be set later + BitBuffer_SetBits(MsgBuf, 6, 0); // reserved + BitBuffer_SetBits(MsgBuf, 2, MsgType); + BitBuffer_SetBits(MsgBuf, 8, MsgGroup); + BitBuffer_SetBits(MsgBuf, 16, MsgId); +} + +uint32_t HdffCmdSetLength(BitBuffer_t * MsgBuf) +{ + uint32_t length; + + length = BitBuffer_GetByteLength(MsgBuf) - 2; + MsgBuf->Data[0] = (uint8_t) (length >> 8); + MsgBuf->Data[1] = (uint8_t) length; + + return length + 2; +} diff --git a/PLUGINS/src/dvbhddevice/libhdffcmd/hdffcmd_base.h b/PLUGINS/src/dvbhddevice/libhdffcmd/hdffcmd_base.h new file mode 100644 index 0000000..b6856aa --- /dev/null +++ b/PLUGINS/src/dvbhddevice/libhdffcmd/hdffcmd_base.h @@ -0,0 +1,55 @@ +/********************************************************************** + * + * HDFF firmware command interface library + * + * Copyright (C) 2011 Andreas Regel + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the + * Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + *********************************************************************/ + +#ifndef HDFFCMD_BASE_H +#define HDFFCMD_BASE_H + +#include <linux/dvb/osd.h> + +#if !defined OSD_RAW_CMD +typedef struct osd_raw_cmd_s { + const void *cmd_data; + int cmd_len; + void *result_data; + int result_len; +} osd_raw_cmd_t; + +typedef struct osd_raw_data_s { + const void *data_buffer; + int data_length; + int data_handle; +} osd_raw_data_t; + +#define OSD_RAW_CMD _IOWR('o', 162, osd_raw_cmd_t) +#define OSD_RAW_DATA _IOWR('o', 163, osd_raw_data_t) +#endif + +#include "bitbuffer.h" +#include "hdffcmd_defs.h" + +void HdffCmdBuildHeader(BitBuffer_t * MsgBuf, HdffMessageType_t MsgType, + HdffMessageGroup_t MsgGroup, HdffMessageId_t MsgId); + +uint32_t HdffCmdSetLength(BitBuffer_t * MsgBuf); + +#endif /* HDFFCMD_BASE_H */ diff --git a/PLUGINS/src/dvbhddevice/libhdffcmd/hdffcmd_defs.h b/PLUGINS/src/dvbhddevice/libhdffcmd/hdffcmd_defs.h new file mode 100644 index 0000000..8b24d7b --- /dev/null +++ b/PLUGINS/src/dvbhddevice/libhdffcmd/hdffcmd_defs.h @@ -0,0 +1,120 @@ +/********************************************************************** + * + * HDFF firmware command interface library + * + * Copyright (C) 2011 Andreas Regel + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the + * Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + *********************************************************************/ + +#ifndef HDFFCMD_DEFS_H +#define HDFFCMD_DEFS_H + +typedef enum HdffMessageType_t +{ + HDFF_MSG_TYPE_COMMAND, + HDFF_MSG_TYPE_ANSWER, + HDFF_MSG_TYPE_RESULT, + HDFF_MSG_TYPE_EVENT +} HdffMessageType_t; + +typedef enum HdffMessageGroup_t +{ + HDFF_MSG_GROUP_GENERIC, + HDFF_MSG_GROUP_AV_DECODER, + HDFF_MSG_GROUP_AV_MUX, + HDFF_MSG_GROUP_FRONTEND, + HDFF_MSG_GROUP_OSD, + HDFF_MSG_GROUP_HDMI, + HDFF_MSG_GROUP_REMOTE_CONTROL +} HdffMessageGroup_t; + +typedef enum HdffMessageId_t +{ + HDFF_MSG_GEN_GET_FIRMWARE_VERSION = 0, + HDFF_MSG_GEN_GET_INTERFACE_VERSION, + HDFF_MSG_GEN_GET_COPYRIGHTS, + + HDFF_MSG_AV_SET_AUDIO_PID = 0, + HDFF_MSG_AV_SET_VIDEO_PID, + HDFF_MSG_AV_SET_PCR_PID, + HDFF_MSG_AV_SET_TELETEXT_PID, + HDFF_MSG_AV_SHOW_STILL_IMAGE, + HDFF_MSG_AV_SET_VIDEO_WINDOW, + HDFF_MSG_AV_SET_DECODER_INPUT, + HDFF_MSG_AV_SET_DEMULTIPLEXER_INPUT, + HDFF_MSG_AV_SET_VIDEO_FORMAT, + HDFF_MSG_AV_SET_VIDEO_OUTPUT_MODE, + HDFF_MSG_AV_SET_STC, + HDFF_MSG_AV_FLUSH_BUFFER, + HDFF_MSG_AV_ENABLE_SYNC, + HDFF_MSG_AV_SET_VIDEO_SPEED, + HDFF_MSG_AV_SET_AUDIO_SPEED, + HDFF_MSG_AV_ENABLE_VIDEO_AFTER_STOP, + HDFF_MSG_AV_GET_VIDEO_FORMAT_INFO, + HDFF_MSG_AV_SET_AUDIO_DELAY, + HDFF_MSG_AV_SET_AUDIO_DOWNMIX, + HDFF_MSG_AV_SET_AUDIO_CHANNEL, + HDFF_MSG_AV_SET_PLAY_MODE, + + HDFF_MSG_MUX_SET_VIDEO_OUT = 0, + HDFF_MSG_MUX_SET_SLOW_BLANK, + HDFF_MSG_MUX_SET_FAST_BLANK, + HDFF_MSG_MUX_SET_VOLUME, + HDFF_MSG_MUX_SET_AUDIO_MUTE, + + HDFF_MSG_OSD_CONFIGURE = 0, + HDFF_MSG_OSD_RESET, + HDFF_MSG_OSD_CREATE_DISPLAY = 10, + HDFF_MSG_OSD_DELETE_DISPLAY, + HDFF_MSG_OSD_ENABLE_DISPLAY, + HDFF_MSG_OSD_SET_DISPLAY_OUTPUT_RECTANGLE, + HDFF_MSG_OSD_SET_DISPLAY_CLIPPLING_AREA, + HDFF_MSG_OSD_RENDER_DISPLAY, + HDFF_MSG_OSD_SAVE_REGION, + HDFF_MSG_OSD_RESTORE_REGION, + HDFF_MSG_OSD_CREATE_PALETTE = 30, + HDFF_MSG_OSD_DELETE_PALETTE, + HDFF_MSG_OSD_SET_DISPLAY_PALETTE, + HDFF_MSG_OSD_SET_PALETTE_COLORS, + HDFF_MSG_OSD_CREATE_FONT_FACE = 50, + HDFF_MSG_OSD_DELETE_FONT_FACE, + HDFF_MSG_OSD_CREATE_FONT, + HDFF_MSG_OSD_DELETE_FONT, + HDFF_MSG_OSD_DRAW_PIXEL = 70, + HDFF_MSG_OSD_DRAW_RECTANGLE, + HDFF_MSG_OSD_DRAW_CIRCLE, + HDFF_MSG_OSD_DRAW_ELLIPSE, + HDFF_MSG_OSD_DRAW_SLOPE, + HDFF_MSG_OSD_DRAW_TEXT, + HDFF_MSG_OSD_DRAW_WIDE_TEXT, + HDFF_MSG_OSD_DRAW_BITMAP, + + HDFF_MSG_HDMI_ENABLE_OUTPUT = 0, + HDFF_MSG_HDMI_SET_VIDEO_MODE, + HDFF_MSG_HDMI_CONFIGURE, + HDFF_MSG_HDMI_IS_DISPLAY_CONNECTED, + HDFF_MSG_HDMI_GET_DISPLAY_INFO, + HDFF_MSG_HDMI_GET_VIDEO_MODE, + HDFF_MSG_HDMI_SEND_CEC_COMMAND, + + HDFF_MSG_REMOTE_SET_PROTOCOL = 0, + HDFF_MSG_REMOTE_SET_ADDRESS_FILTER, + HDFF_MSG_REMOTE_KEY_EVENT +} HdffMessageId_t; + +#endif /* HDFFCMD_DEFS_H */ diff --git a/PLUGINS/src/dvbhddevice/libhdffcmd/hdffcmd_generic.c b/PLUGINS/src/dvbhddevice/libhdffcmd/hdffcmd_generic.c new file mode 100644 index 0000000..f72a7d3 --- /dev/null +++ b/PLUGINS/src/dvbhddevice/libhdffcmd/hdffcmd_generic.c @@ -0,0 +1,147 @@ +/********************************************************************** + * + * HDFF firmware command interface library + * + * Copyright (C) 2011 Andreas Regel + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the + * Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + *********************************************************************/ + +#include <stdint.h> +#include <string.h> +#include <sys/ioctl.h> + +#include "hdffcmd.h" +#include "hdffcmd_base.h" +#include "hdffcmd_defs.h" + +int HdffCmdGetFirmwareVersion(int OsdDevice, uint32_t * Version, char * String, + uint32_t MaxLength) +{ + uint8_t cmdData[8]; + uint8_t resultData[64]; + BitBuffer_t cmdBuf; + osd_raw_cmd_t osd_cmd; + int err; + + *Version = 0; + String[0] = 0; + + BitBuffer_Init(&cmdBuf, cmdData, sizeof(cmdData)); + memset(&osd_cmd, 0, sizeof(osd_raw_cmd_t)); + osd_cmd.cmd_data = cmdData; + osd_cmd.result_data = resultData; + osd_cmd.result_len = sizeof(resultData); + HdffCmdBuildHeader(&cmdBuf, HDFF_MSG_TYPE_COMMAND, HDFF_MSG_GROUP_GENERIC, + HDFF_MSG_GEN_GET_FIRMWARE_VERSION); + osd_cmd.cmd_len = HdffCmdSetLength(&cmdBuf); + err = ioctl(OsdDevice, OSD_RAW_CMD, &osd_cmd); + if (err == 0) + { + if (osd_cmd.result_len > 0) + { + uint8_t textLength = resultData[9]; + if (textLength >= MaxLength) + textLength = MaxLength - 1; + memcpy(String, &resultData[10], textLength); + String[textLength] = 0; + *Version = (resultData[6] << 16) + | (resultData[7] << 8) + | resultData[8]; + } + } + return err; +} + +int HdffCmdGetInterfaceVersion(int OsdDevice, uint32_t * Version, char * String, + uint32_t MaxLength) +{ + uint8_t cmdData[8]; + uint8_t resultData[64]; + BitBuffer_t cmdBuf; + osd_raw_cmd_t osd_cmd; + int err; + + *Version = 0; + String[0] = 0; + + BitBuffer_Init(&cmdBuf, cmdData, sizeof(cmdData)); + memset(&osd_cmd, 0, sizeof(osd_raw_cmd_t)); + osd_cmd.cmd_data = cmdData; + osd_cmd.result_data = resultData; + osd_cmd.result_len = sizeof(resultData); + HdffCmdBuildHeader(&cmdBuf, HDFF_MSG_TYPE_COMMAND, HDFF_MSG_GROUP_GENERIC, + HDFF_MSG_GEN_GET_INTERFACE_VERSION); + osd_cmd.cmd_len = HdffCmdSetLength(&cmdBuf); + err = ioctl(OsdDevice, OSD_RAW_CMD, &osd_cmd); + if (err == 0) + { + if (osd_cmd.result_len > 0) + { + uint8_t textLength = resultData[9]; + if (textLength >= MaxLength) + textLength = MaxLength - 1; + memcpy(String, &resultData[10], textLength); + String[textLength] = 0; + *Version = (resultData[6] << 16) + | (resultData[7] << 8) + | resultData[8]; + } + } + return err; +} + +int HdffCmdGetCopyrights(int OsdDevice, uint8_t Index, char * String, + uint32_t MaxLength) +{ + uint8_t cmdData[8]; + uint8_t resultData[280]; + BitBuffer_t cmdBuf; + osd_raw_cmd_t osd_cmd; + int err; + + String[0] = 0; + + BitBuffer_Init(&cmdBuf, cmdData, sizeof(cmdData)); + memset(&osd_cmd, 0, sizeof(osd_raw_cmd_t)); + osd_cmd.cmd_data = cmdData; + osd_cmd.result_data = resultData; + osd_cmd.result_len = sizeof(resultData); + HdffCmdBuildHeader(&cmdBuf, HDFF_MSG_TYPE_COMMAND, HDFF_MSG_GROUP_GENERIC, + HDFF_MSG_GEN_GET_COPYRIGHTS); + BitBuffer_SetBits(&cmdBuf, 8, Index); + osd_cmd.cmd_len = HdffCmdSetLength(&cmdBuf); + err = ioctl(OsdDevice, OSD_RAW_CMD, &osd_cmd); + if (err == 0) + { + if (osd_cmd.result_len > 0) + { + uint8_t index = resultData[6]; + uint8_t textLen = resultData[7]; + if (index == Index && textLen > 0) + { + if (textLen >= MaxLength) + { + textLen = MaxLength - 1; + } + memcpy(String, resultData + 8, textLen); + String[textLen] = 0; + } + } + } + return err; +} diff --git a/PLUGINS/src/dvbhddevice/libhdffcmd/hdffcmd_generic.h b/PLUGINS/src/dvbhddevice/libhdffcmd/hdffcmd_generic.h new file mode 100644 index 0000000..c12b296 --- /dev/null +++ b/PLUGINS/src/dvbhddevice/libhdffcmd/hdffcmd_generic.h @@ -0,0 +1,36 @@ +/********************************************************************** + * + * HDFF firmware command interface library + * + * Copyright (C) 2011 Andreas Regel + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the + * Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + *********************************************************************/ + +#ifndef HDFFCMD_GENERIC_H +#define HDFFCMD_GENERIC_H + +int HdffCmdGetFirmwareVersion(int OsdDevice, uint32_t * Version, char * String, + uint32_t MaxLength); + +int HdffCmdGetInterfaceVersion(int OsdDevice, uint32_t * Version, char * String, + uint32_t MaxLength); + +int HdffCmdGetCopyrights(int OsdDevice, uint8_t Index, char * String, + uint32_t MaxLength); + +#endif /* HDFFCMD_GENERIC_H */ diff --git a/PLUGINS/src/dvbhddevice/libhdffcmd/hdffcmd_hdmi.c b/PLUGINS/src/dvbhddevice/libhdffcmd/hdffcmd_hdmi.c new file mode 100644 index 0000000..42b82b5 --- /dev/null +++ b/PLUGINS/src/dvbhddevice/libhdffcmd/hdffcmd_hdmi.c @@ -0,0 +1,82 @@ +/********************************************************************** + * + * HDFF firmware command interface library + * + * Copyright (C) 2011 Andreas Regel + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the + * Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + *********************************************************************/ + +#include <stdint.h> +#include <string.h> +#include <sys/ioctl.h> + +#include "hdffcmd.h" +#include "hdffcmd_base.h" +#include "hdffcmd_defs.h" + + +int HdffCmdHdmiSetVideoMode(int OsdDevice, HdffVideoMode_t VideoMode) +{ + uint8_t cmdData[8]; + BitBuffer_t cmdBuf; + osd_raw_cmd_t osd_cmd; + + BitBuffer_Init(&cmdBuf, cmdData, sizeof(cmdData)); + memset(&osd_cmd, 0, sizeof(osd_raw_cmd_t)); + osd_cmd.cmd_data = cmdData; + HdffCmdBuildHeader(&cmdBuf, HDFF_MSG_TYPE_COMMAND, HDFF_MSG_GROUP_HDMI, + HDFF_MSG_HDMI_SET_VIDEO_MODE); + BitBuffer_SetBits(&cmdBuf, 8, VideoMode); + osd_cmd.cmd_len = HdffCmdSetLength(&cmdBuf); + return ioctl(OsdDevice, OSD_RAW_CMD, &osd_cmd); +} + +int HdffCmdHdmiConfigure(int OsdDevice, const HdffHdmiConfig_t * Config) +{ + uint8_t cmdData[8]; + BitBuffer_t cmdBuf; + osd_raw_cmd_t osd_cmd; + + BitBuffer_Init(&cmdBuf, cmdData, sizeof(cmdData)); + memset(&osd_cmd, 0, sizeof(osd_raw_cmd_t)); + osd_cmd.cmd_data = cmdData; + HdffCmdBuildHeader(&cmdBuf, HDFF_MSG_TYPE_COMMAND, HDFF_MSG_GROUP_HDMI, + HDFF_MSG_HDMI_CONFIGURE); + BitBuffer_SetBits(&cmdBuf, 1, Config->TransmitAudio ? 1 : 0); + BitBuffer_SetBits(&cmdBuf, 1, Config->ForceDviMode ? 1 : 0); + BitBuffer_SetBits(&cmdBuf, 1, Config->CecEnabled ? 1 : 0); + BitBuffer_SetBits(&cmdBuf, 3, Config->VideoModeAdaption); + osd_cmd.cmd_len = HdffCmdSetLength(&cmdBuf); + return ioctl(OsdDevice, OSD_RAW_CMD, &osd_cmd); +} + +int HdffCmdHdmiSendCecCommand(int OsdDevice, HdffCecCommand_t Command) +{ + uint8_t cmdData[8]; + BitBuffer_t cmdBuf; + osd_raw_cmd_t osd_cmd; + + BitBuffer_Init(&cmdBuf, cmdData, sizeof(cmdData)); + memset(&osd_cmd, 0, sizeof(osd_raw_cmd_t)); + osd_cmd.cmd_data = cmdData; + HdffCmdBuildHeader(&cmdBuf, HDFF_MSG_TYPE_COMMAND, HDFF_MSG_GROUP_HDMI, + HDFF_MSG_HDMI_SEND_CEC_COMMAND); + BitBuffer_SetBits(&cmdBuf, 8, Command); + osd_cmd.cmd_len = HdffCmdSetLength(&cmdBuf); + return ioctl(OsdDevice, OSD_RAW_CMD, &osd_cmd); +} diff --git a/PLUGINS/src/dvbhddevice/libhdffcmd/hdffcmd_hdmi.h b/PLUGINS/src/dvbhddevice/libhdffcmd/hdffcmd_hdmi.h new file mode 100644 index 0000000..16e375f --- /dev/null +++ b/PLUGINS/src/dvbhddevice/libhdffcmd/hdffcmd_hdmi.h @@ -0,0 +1,67 @@ +/********************************************************************** + * + * HDFF firmware command interface library + * + * Copyright (C) 2011 Andreas Regel + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the + * Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + *********************************************************************/ + +#ifndef HDFFCMD_HDMI_H +#define HDFFCMD_HDMI_H + + +typedef enum HdffVideoMode_t +{ + HDFF_VIDEO_MODE_576P50 = 18, + HDFF_VIDEO_MODE_720P50 = 19, + HDFF_VIDEO_MODE_1080I50 = 20, + HDFF_VIDEO_MODE_576I50 = 22 +} HdffVideoMode_t; + +typedef enum HdffVideoModeAdaption_t +{ + HDFF_VIDEO_MODE_ADAPT_OFF, + HDFF_VIDEO_MODE_ADAPT_FRAME_RATE, + HDFF_VIDEO_MODE_ADAPT_ONLY_FOR_HD, + HDFF_VIDEO_MODE_ADAPT_ALWAYS +} HdffVideoModeAdaption_t; + +typedef struct HdffHdmiConfig_t +{ + int TransmitAudio; + int ForceDviMode; + int CecEnabled; + HdffVideoModeAdaption_t VideoModeAdaption; +} HdffHdmiConfig_t; + +typedef enum HdffCecCommand_t +{ + HDFF_CEC_COMMAND_TV_ON, + HDFF_CEC_COMMAND_TV_OFF, + HDFF_CEC_COMMAND_TV_ACTIVE_SOURCE, + HDFF_CEC_COMMAND_TV_INACTIVE_SOURCE +} HdffCecCommand_t; + + +int HdffCmdHdmiSetVideoMode(int OsdDevice, HdffVideoMode_t VideoMode); + +int HdffCmdHdmiConfigure(int OsdDevice, const HdffHdmiConfig_t * Config); + +int HdffCmdHdmiSendCecCommand(int OsdDevice, HdffCecCommand_t Command); + +#endif /* HDFFCMD_HDMI_H */ diff --git a/PLUGINS/src/dvbhddevice/libhdffcmd/hdffcmd_mux.c b/PLUGINS/src/dvbhddevice/libhdffcmd/hdffcmd_mux.c new file mode 100644 index 0000000..3698b56 --- /dev/null +++ b/PLUGINS/src/dvbhddevice/libhdffcmd/hdffcmd_mux.c @@ -0,0 +1,81 @@ +/********************************************************************** + * + * HDFF firmware command interface library + * + * Copyright (C) 2011 Andreas Regel + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the + * Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + *********************************************************************/ + +#include <stdint.h> +#include <string.h> +#include <sys/ioctl.h> + +#include "hdffcmd.h" +#include "hdffcmd_base.h" +#include "hdffcmd_defs.h" + + +int HdffCmdMuxSetVideoOut(int OsdDevice, HdffVideoOut_t VideoOut) +{ + uint8_t cmdData[8]; + BitBuffer_t cmdBuf; + osd_raw_cmd_t osd_cmd; + + BitBuffer_Init(&cmdBuf, cmdData, sizeof(cmdData)); + memset(&osd_cmd, 0, sizeof(osd_raw_cmd_t)); + osd_cmd.cmd_data = cmdData; + HdffCmdBuildHeader(&cmdBuf, HDFF_MSG_TYPE_COMMAND, HDFF_MSG_GROUP_AV_MUX, + HDFF_MSG_MUX_SET_VIDEO_OUT); + BitBuffer_SetBits(&cmdBuf, 4, VideoOut); + BitBuffer_SetBits(&cmdBuf, 4, 0); // reserved + osd_cmd.cmd_len = HdffCmdSetLength(&cmdBuf); + return ioctl(OsdDevice, OSD_RAW_CMD, &osd_cmd); +} + +int HdffCmdMuxSetVolume(int OsdDevice, uint8_t Volume) +{ + uint8_t cmdData[8]; + BitBuffer_t cmdBuf; + osd_raw_cmd_t osd_cmd; + + BitBuffer_Init(&cmdBuf, cmdData, sizeof(cmdData)); + memset(&osd_cmd, 0, sizeof(osd_raw_cmd_t)); + osd_cmd.cmd_data = cmdData; + HdffCmdBuildHeader(&cmdBuf, HDFF_MSG_TYPE_COMMAND, HDFF_MSG_GROUP_AV_MUX, + HDFF_MSG_MUX_SET_VOLUME); + BitBuffer_SetBits(&cmdBuf, 8, Volume); + osd_cmd.cmd_len = HdffCmdSetLength(&cmdBuf); + return ioctl(OsdDevice, OSD_RAW_CMD, &osd_cmd); +} + +int HdffCmdMuxMuteAudio(int OsdDevice, int Mute) +{ + uint8_t cmdData[8]; + BitBuffer_t cmdBuf; + osd_raw_cmd_t osd_cmd; + + BitBuffer_Init(&cmdBuf, cmdData, sizeof(cmdData)); + memset(&osd_cmd, 0, sizeof(osd_raw_cmd_t)); + osd_cmd.cmd_data = cmdData; + HdffCmdBuildHeader(&cmdBuf, HDFF_MSG_TYPE_COMMAND, HDFF_MSG_GROUP_AV_MUX, + HDFF_MSG_MUX_SET_AUDIO_MUTE); + BitBuffer_SetBits(&cmdBuf, 1, Mute); + BitBuffer_SetBits(&cmdBuf, 7, 0); // reserved + osd_cmd.cmd_len = HdffCmdSetLength(&cmdBuf); + return ioctl(OsdDevice, OSD_RAW_CMD, &osd_cmd); +} diff --git a/PLUGINS/src/dvbhddevice/libhdffcmd/hdffcmd_mux.h b/PLUGINS/src/dvbhddevice/libhdffcmd/hdffcmd_mux.h new file mode 100644 index 0000000..8821d5f --- /dev/null +++ b/PLUGINS/src/dvbhddevice/libhdffcmd/hdffcmd_mux.h @@ -0,0 +1,56 @@ +/********************************************************************** + * + * HDFF firmware command interface library + * + * Copyright (C) 2011 Andreas Regel + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the + * Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + *********************************************************************/ + +#ifndef HDFFCMD_MUX_H +#define HDFFCMD_MUX_H + + +typedef enum HdffVideoOut_t +{ + HDFF_VIDEO_OUT_DISABLED, + HDFF_VIDEO_OUT_CVBS_RGB, + HDFF_VIDEO_OUT_CVBS_YUV, + HDFF_VIDEO_OUT_YC +} HdffVideoOut_t; + +typedef enum HdffSlowBlank_t +{ + HDFF_SLOW_BLANK_OFF, + HDFF_SLOW_BLANK_16_BY_9, + HDFF_SLOW_BLANK_4_BY_3 +} HdffSlowBlank_t; + +typedef enum HdffFastBlank_t +{ + HDFF_FAST_BLANK_CVBS, + HDFF_FAST_BLANK_RGB +} HdffFastBlank_t; + + +int HdffCmdMuxSetVideoOut(int OsdDevice, HdffVideoOut_t VideoOut); + +int HdffCmdMuxSetVolume(int OsdDevice, uint8_t Volume); + +int HdffCmdMuxMuteAudio(int OsdDevice, int Mute); + +#endif /* HDFFCMD_MUX_H */ diff --git a/PLUGINS/src/dvbhddevice/libhdffcmd/hdffcmd_osd.c b/PLUGINS/src/dvbhddevice/libhdffcmd/hdffcmd_osd.c new file mode 100644 index 0000000..a80051f --- /dev/null +++ b/PLUGINS/src/dvbhddevice/libhdffcmd/hdffcmd_osd.c @@ -0,0 +1,637 @@ +/********************************************************************** + * + * HDFF firmware command interface library + * + * Copyright (C) 2011 Andreas Regel + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the + * Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + *********************************************************************/ + +#include <stdint.h> +#include <string.h> +#include <sys/ioctl.h> + +#include "hdffcmd.h" +#include "hdffcmd_base.h" +#include "hdffcmd_defs.h" + + +int HdffCmdOsdConfigure(int OsdDevice, const HdffOsdConfig_t * Config) +{ + uint8_t cmdData[16]; + BitBuffer_t cmdBuf; + osd_raw_cmd_t osd_cmd; + + BitBuffer_Init(&cmdBuf, cmdData, sizeof(cmdData)); + memset(&osd_cmd, 0, sizeof(osd_raw_cmd_t)); + osd_cmd.cmd_data = cmdData; + HdffCmdBuildHeader(&cmdBuf, HDFF_MSG_TYPE_COMMAND, HDFF_MSG_GROUP_OSD, + HDFF_MSG_OSD_CONFIGURE); + if (Config->FontAntialiasing) + { + BitBuffer_SetBits(&cmdBuf, 1, 1); + } + else + { + BitBuffer_SetBits(&cmdBuf, 1, 0); + } + if (Config->FontKerning) + { + BitBuffer_SetBits(&cmdBuf, 1, 1); + } + else + { + BitBuffer_SetBits(&cmdBuf, 1, 0); + } + osd_cmd.cmd_len = HdffCmdSetLength(&cmdBuf); + return ioctl(OsdDevice, OSD_RAW_CMD, &osd_cmd); +} + +int HdffCmdOsdReset(int OsdDevice) +{ + uint8_t cmdData[8]; + BitBuffer_t cmdBuf; + osd_raw_cmd_t osd_cmd; + + BitBuffer_Init(&cmdBuf, cmdData, sizeof(cmdData)); + memset(&osd_cmd, 0, sizeof(osd_raw_cmd_t)); + osd_cmd.cmd_data = cmdData; + HdffCmdBuildHeader(&cmdBuf, HDFF_MSG_TYPE_COMMAND, HDFF_MSG_GROUP_OSD, + HDFF_MSG_OSD_RESET); + osd_cmd.cmd_len = HdffCmdSetLength(&cmdBuf); + return ioctl(OsdDevice, OSD_RAW_CMD, &osd_cmd); +} + + +int HdffCmdOsdCreateDisplay(int OsdDevice, uint16_t Width, uint16_t Height, + HdffColorType_t ColorType, uint32_t * NewDisplay) +{ + uint8_t cmdData[16]; + uint8_t resultData[16]; + BitBuffer_t cmdBuf; + osd_raw_cmd_t osd_cmd; + int err; + + BitBuffer_Init(&cmdBuf, cmdData, sizeof(cmdData)); + memset(&osd_cmd, 0, sizeof(osd_raw_cmd_t)); + osd_cmd.cmd_data = cmdData; + osd_cmd.result_data = resultData; + osd_cmd.result_len = sizeof(resultData); + HdffCmdBuildHeader(&cmdBuf, HDFF_MSG_TYPE_COMMAND, HDFF_MSG_GROUP_OSD, + HDFF_MSG_OSD_CREATE_DISPLAY); + BitBuffer_SetBits(&cmdBuf, 16, Width); + BitBuffer_SetBits(&cmdBuf, 16, Height); + BitBuffer_SetBits(&cmdBuf, 8, ColorType); + osd_cmd.cmd_len = HdffCmdSetLength(&cmdBuf); + err = ioctl(OsdDevice, OSD_RAW_CMD, &osd_cmd); + *NewDisplay = HDFF_INVALID_HANDLE; + if (err == 0) + { + if (osd_cmd.result_len > 0) + { + *NewDisplay = (resultData[6] << 24) + | (resultData[7] << 16) + | (resultData[8] << 8) + | resultData[9]; + } + } + return err; +} + +int HdffCmdOsdDeleteDisplay(int OsdDevice, uint32_t Display) +{ + uint8_t cmdData[16]; + BitBuffer_t cmdBuf; + osd_raw_cmd_t osd_cmd; + + BitBuffer_Init(&cmdBuf, cmdData, sizeof(cmdData)); + memset(&osd_cmd, 0, sizeof(osd_raw_cmd_t)); + osd_cmd.cmd_data = cmdData; + HdffCmdBuildHeader(&cmdBuf, HDFF_MSG_TYPE_COMMAND, HDFF_MSG_GROUP_OSD, + HDFF_MSG_OSD_DELETE_DISPLAY); + BitBuffer_SetBits(&cmdBuf, 32, Display); + osd_cmd.cmd_len = HdffCmdSetLength(&cmdBuf); + return ioctl(OsdDevice, OSD_RAW_CMD, &osd_cmd); +} + +int HdffCmdOsdEnableDisplay(int OsdDevice, uint32_t Display, int Enable) +{ + uint8_t cmdData[16]; + BitBuffer_t cmdBuf; + osd_raw_cmd_t osd_cmd; + + BitBuffer_Init(&cmdBuf, cmdData, sizeof(cmdData)); + memset(&osd_cmd, 0, sizeof(osd_raw_cmd_t)); + osd_cmd.cmd_data = cmdData; + HdffCmdBuildHeader(&cmdBuf, HDFF_MSG_TYPE_COMMAND, HDFF_MSG_GROUP_OSD, + HDFF_MSG_OSD_ENABLE_DISPLAY); + BitBuffer_SetBits(&cmdBuf, 32, Display); + if (Enable) + { + BitBuffer_SetBits(&cmdBuf, 1, 1); + } + else + { + BitBuffer_SetBits(&cmdBuf, 1, 0); + } + osd_cmd.cmd_len = HdffCmdSetLength(&cmdBuf); + return ioctl(OsdDevice, OSD_RAW_CMD, &osd_cmd); +} + +int HdffCmdOsdSetDisplayOutputRectangle(int OsdDevice, uint32_t Display, + uint16_t X, uint16_t Y, + uint16_t Width, uint16_t Height) +{ + uint8_t cmdData[20]; + BitBuffer_t cmdBuf; + osd_raw_cmd_t osd_cmd; + + BitBuffer_Init(&cmdBuf, cmdData, sizeof(cmdData)); + memset(&osd_cmd, 0, sizeof(osd_raw_cmd_t)); + osd_cmd.cmd_data = cmdData; + HdffCmdBuildHeader(&cmdBuf, HDFF_MSG_TYPE_COMMAND, HDFF_MSG_GROUP_OSD, + HDFF_MSG_OSD_SET_DISPLAY_OUTPUT_RECTANGLE); + BitBuffer_SetBits(&cmdBuf, 32, Display); + BitBuffer_SetBits(&cmdBuf, 16, X); + BitBuffer_SetBits(&cmdBuf, 16, Y); + BitBuffer_SetBits(&cmdBuf, 16, Width); + BitBuffer_SetBits(&cmdBuf, 16, Height); + osd_cmd.cmd_len = HdffCmdSetLength(&cmdBuf); + return ioctl(OsdDevice, OSD_RAW_CMD, &osd_cmd); +} + +int HdffCmdOsdSetDisplayClippingArea(int OsdDevice, uint32_t Display, + int Enable, uint16_t X, uint16_t Y, + uint16_t Width, uint16_t Height) +{ + uint8_t cmdData[20]; + BitBuffer_t cmdBuf; + osd_raw_cmd_t osd_cmd; + + BitBuffer_Init(&cmdBuf, cmdData, sizeof(cmdData)); + memset(&osd_cmd, 0, sizeof(osd_raw_cmd_t)); + osd_cmd.cmd_data = cmdData; + HdffCmdBuildHeader(&cmdBuf, HDFF_MSG_TYPE_COMMAND, HDFF_MSG_GROUP_OSD, + HDFF_MSG_OSD_SET_DISPLAY_CLIPPLING_AREA); + BitBuffer_SetBits(&cmdBuf, 32, Display); + if (Enable) + { + BitBuffer_SetBits(&cmdBuf, 1, 1); + } + else + { + BitBuffer_SetBits(&cmdBuf, 1, 0); + } + BitBuffer_SetBits(&cmdBuf, 7, 0); // reserved + BitBuffer_SetBits(&cmdBuf, 16, X); + BitBuffer_SetBits(&cmdBuf, 16, Y); + BitBuffer_SetBits(&cmdBuf, 16, Width); + BitBuffer_SetBits(&cmdBuf, 16, Height); + osd_cmd.cmd_len = HdffCmdSetLength(&cmdBuf); + return ioctl(OsdDevice, OSD_RAW_CMD, &osd_cmd); +} + +int HdffCmdOsdRenderDisplay(int OsdDevice, uint32_t Display) +{ + uint8_t cmdData[16]; + BitBuffer_t cmdBuf; + osd_raw_cmd_t osd_cmd; + + BitBuffer_Init(&cmdBuf, cmdData, sizeof(cmdData)); + memset(&osd_cmd, 0, sizeof(osd_raw_cmd_t)); + osd_cmd.cmd_data = cmdData; + HdffCmdBuildHeader(&cmdBuf, HDFF_MSG_TYPE_COMMAND, HDFF_MSG_GROUP_OSD, + HDFF_MSG_OSD_RENDER_DISPLAY); + BitBuffer_SetBits(&cmdBuf, 32, Display); + osd_cmd.cmd_len = HdffCmdSetLength(&cmdBuf); + return ioctl(OsdDevice, OSD_RAW_CMD, &osd_cmd); +} + +int HdffCmdOsdSaveRegion(int OsdDevice, uint32_t Display, + uint16_t X, uint16_t Y, + uint16_t Width, uint16_t Height) +{ + uint8_t cmdData[20]; + BitBuffer_t cmdBuf; + osd_raw_cmd_t osd_cmd; + + BitBuffer_Init(&cmdBuf, cmdData, sizeof(cmdData)); + memset(&osd_cmd, 0, sizeof(osd_raw_cmd_t)); + osd_cmd.cmd_data = cmdData; + HdffCmdBuildHeader(&cmdBuf, HDFF_MSG_TYPE_COMMAND, HDFF_MSG_GROUP_OSD, + HDFF_MSG_OSD_SAVE_REGION); + BitBuffer_SetBits(&cmdBuf, 32, Display); + BitBuffer_SetBits(&cmdBuf, 16, X); + BitBuffer_SetBits(&cmdBuf, 16, Y); + BitBuffer_SetBits(&cmdBuf, 16, Width); + BitBuffer_SetBits(&cmdBuf, 16, Height); + osd_cmd.cmd_len = HdffCmdSetLength(&cmdBuf); + return ioctl(OsdDevice, OSD_RAW_CMD, &osd_cmd); +} + +int HdffCmdOsdRestoreRegion(int OsdDevice, uint32_t Display) +{ + uint8_t cmdData[16]; + BitBuffer_t cmdBuf; + osd_raw_cmd_t osd_cmd; + + BitBuffer_Init(&cmdBuf, cmdData, sizeof(cmdData)); + memset(&osd_cmd, 0, sizeof(osd_raw_cmd_t)); + osd_cmd.cmd_data = cmdData; + HdffCmdBuildHeader(&cmdBuf, HDFF_MSG_TYPE_COMMAND, HDFF_MSG_GROUP_OSD, + HDFF_MSG_OSD_RESTORE_REGION); + BitBuffer_SetBits(&cmdBuf, 32, Display); + osd_cmd.cmd_len = HdffCmdSetLength(&cmdBuf); + return ioctl(OsdDevice, OSD_RAW_CMD, &osd_cmd); +} + + +int HdffCmdOsdCreatePalette(int OsdDevice, HdffColorType_t ColorType, + HdffColorFormat_t ColorFormat, + uint32_t NumColors, const uint32_t * Colors, + uint32_t * NewPalette) +{ + uint8_t cmdData[1060]; + uint8_t resultData[16]; + BitBuffer_t cmdBuf; + osd_raw_cmd_t osd_cmd; + int i; + int err; + + BitBuffer_Init(&cmdBuf, cmdData, sizeof(cmdData)); + memset(&osd_cmd, 0, sizeof(osd_raw_cmd_t)); + osd_cmd.cmd_data = cmdData; + osd_cmd.result_data = resultData; + osd_cmd.result_len = sizeof(resultData); + HdffCmdBuildHeader(&cmdBuf, HDFF_MSG_TYPE_COMMAND, HDFF_MSG_GROUP_OSD, + HDFF_MSG_OSD_CREATE_PALETTE); + BitBuffer_SetBits(&cmdBuf, 8, ColorType); + BitBuffer_SetBits(&cmdBuf, 8, ColorFormat); + if (NumColors > 256) + NumColors = 256; + BitBuffer_SetBits(&cmdBuf, 8, NumColors == 256 ? 0 : NumColors); + for (i = 0; i < NumColors; i++) + { + BitBuffer_SetBits(&cmdBuf, 32, Colors[i]); + } + osd_cmd.cmd_len = HdffCmdSetLength(&cmdBuf); + err = ioctl(OsdDevice, OSD_RAW_CMD, &osd_cmd); + *NewPalette = HDFF_INVALID_HANDLE; + if (err == 0) + { + if (osd_cmd.result_len > 0) + { + *NewPalette = (resultData[6] << 24) + | (resultData[7] << 16) + | (resultData[8] << 8) + | resultData[9]; + } + } + return err; +} + +int HdffCmdOsdDeletePalette(int OsdDevice, uint32_t Palette) +{ + uint8_t cmdData[16]; + BitBuffer_t cmdBuf; + osd_raw_cmd_t osd_cmd; + + BitBuffer_Init(&cmdBuf, cmdData, sizeof(cmdData)); + memset(&osd_cmd, 0, sizeof(osd_raw_cmd_t)); + osd_cmd.cmd_data = cmdData; + HdffCmdBuildHeader(&cmdBuf, HDFF_MSG_TYPE_COMMAND, HDFF_MSG_GROUP_OSD, + HDFF_MSG_OSD_DELETE_PALETTE); + BitBuffer_SetBits(&cmdBuf, 32, Palette); + osd_cmd.cmd_len = HdffCmdSetLength(&cmdBuf); + return ioctl(OsdDevice, OSD_RAW_CMD, &osd_cmd); +} + +int HdffCmdOsdSetDisplayPalette(int OsdDevice, uint32_t Display, + uint32_t Palette) +{ + uint8_t cmdData[16]; + BitBuffer_t cmdBuf; + osd_raw_cmd_t osd_cmd; + + BitBuffer_Init(&cmdBuf, cmdData, sizeof(cmdData)); + memset(&osd_cmd, 0, sizeof(osd_raw_cmd_t)); + osd_cmd.cmd_data = cmdData; + HdffCmdBuildHeader(&cmdBuf, HDFF_MSG_TYPE_COMMAND, HDFF_MSG_GROUP_OSD, + HDFF_MSG_OSD_SET_DISPLAY_PALETTE); + BitBuffer_SetBits(&cmdBuf, 32, Display); + BitBuffer_SetBits(&cmdBuf, 32, Palette); + osd_cmd.cmd_len = HdffCmdSetLength(&cmdBuf); + return ioctl(OsdDevice, OSD_RAW_CMD, &osd_cmd); +} + +int HdffCmdOsdSetPaletteColors(int OsdDevice, uint32_t Palette, + HdffColorFormat_t ColorFormat, + uint8_t StartColor, uint32_t NumColors, + const uint32_t * Colors) +{ + uint8_t cmdData[1060]; + BitBuffer_t cmdBuf; + osd_raw_cmd_t osd_cmd; + int i; + + BitBuffer_Init(&cmdBuf, cmdData, sizeof(cmdData)); + memset(&osd_cmd, 0, sizeof(osd_raw_cmd_t)); + osd_cmd.cmd_data = cmdData; + HdffCmdBuildHeader(&cmdBuf, HDFF_MSG_TYPE_COMMAND, HDFF_MSG_GROUP_OSD, + HDFF_MSG_OSD_SET_PALETTE_COLORS); + BitBuffer_SetBits(&cmdBuf, 32, Palette); + BitBuffer_SetBits(&cmdBuf, 8, ColorFormat); + BitBuffer_SetBits(&cmdBuf, 8, StartColor); + if (NumColors > 256) + NumColors = 256; + BitBuffer_SetBits(&cmdBuf, 8, NumColors == 256 ? 0 : NumColors); + for (i = 0; i < NumColors; i++) + { + BitBuffer_SetBits(&cmdBuf, 32, Colors[i]); + } + osd_cmd.cmd_len = HdffCmdSetLength(&cmdBuf); + return ioctl(OsdDevice, OSD_RAW_CMD, &osd_cmd); +} + +int HdffCmdOsdCreateFontFace(int OsdDevice, const uint8_t * FontData, + uint32_t DataSize, uint32_t * NewFontFace) +{ + uint8_t cmdData[16]; + uint8_t resultData[16]; + BitBuffer_t cmdBuf; + osd_raw_cmd_t osd_cmd; + osd_raw_data_t osd_data; + int err; + + *NewFontFace = HDFF_INVALID_HANDLE; + + memset(&osd_data, 0, sizeof(osd_raw_data_t)); + osd_data.data_buffer = FontData; + osd_data.data_length = DataSize; + err = ioctl(OsdDevice, OSD_RAW_DATA, &osd_data); + if (err != 0) + return err; + + BitBuffer_Init(&cmdBuf, cmdData, sizeof(cmdData)); + memset(&osd_cmd, 0, sizeof(osd_raw_cmd_t)); + osd_cmd.cmd_data = cmdData; + osd_cmd.result_data = resultData; + osd_cmd.result_len = sizeof(resultData); + HdffCmdBuildHeader(&cmdBuf, HDFF_MSG_TYPE_COMMAND, HDFF_MSG_GROUP_OSD, + HDFF_MSG_OSD_CREATE_FONT_FACE); + BitBuffer_SetBits(&cmdBuf, 16, osd_data.data_handle); + osd_cmd.cmd_len = HdffCmdSetLength(&cmdBuf); + err = ioctl(OsdDevice, OSD_RAW_CMD, &osd_cmd); + if (err == 0) + { + if (osd_cmd.result_len > 0) + { + *NewFontFace = (resultData[6] << 24) + | (resultData[7] << 16) + | (resultData[8] << 8) + | resultData[9]; + } + } + return err; +} + +int HdffCmdOsdDeleteFontFace(int OsdDevice, uint32_t FontFace) +{ + uint8_t cmdData[16]; + BitBuffer_t cmdBuf; + osd_raw_cmd_t osd_cmd; + + BitBuffer_Init(&cmdBuf, cmdData, sizeof(cmdData)); + memset(&osd_cmd, 0, sizeof(osd_raw_cmd_t)); + osd_cmd.cmd_data = cmdData; + HdffCmdBuildHeader(&cmdBuf, HDFF_MSG_TYPE_COMMAND, HDFF_MSG_GROUP_OSD, + HDFF_MSG_OSD_DELETE_FONT_FACE); + BitBuffer_SetBits(&cmdBuf, 32, FontFace); + osd_cmd.cmd_len = HdffCmdSetLength(&cmdBuf); + return ioctl(OsdDevice, OSD_RAW_CMD, &osd_cmd); +} + +int HdffCmdOsdCreateFont(int OsdDevice, uint32_t FontFace, uint32_t Size, + uint32_t * NewFont) +{ + uint8_t cmdData[16]; + uint8_t resultData[16]; + BitBuffer_t cmdBuf; + osd_raw_cmd_t osd_cmd; + int err; + + *NewFont = HDFF_INVALID_HANDLE; + + BitBuffer_Init(&cmdBuf, cmdData, sizeof(cmdData)); + memset(&osd_cmd, 0, sizeof(osd_raw_cmd_t)); + osd_cmd.cmd_data = cmdData; + osd_cmd.result_data = resultData; + osd_cmd.result_len = sizeof(resultData); + HdffCmdBuildHeader(&cmdBuf, HDFF_MSG_TYPE_COMMAND, HDFF_MSG_GROUP_OSD, + HDFF_MSG_OSD_CREATE_FONT); + BitBuffer_SetBits(&cmdBuf, 32, FontFace); + BitBuffer_SetBits(&cmdBuf, 32, Size); + osd_cmd.cmd_len = HdffCmdSetLength(&cmdBuf); + err = ioctl(OsdDevice, OSD_RAW_CMD, &osd_cmd); + if (err == 0) + { + if (osd_cmd.result_len > 0) + { + *NewFont = (resultData[6] << 24) + | (resultData[7] << 16) + | (resultData[8] << 8) + | resultData[9]; + } + } + return err; +} + +int HdffCmdOsdDeleteFont(int OsdDevice, uint32_t Font) +{ + uint8_t cmdData[16]; + BitBuffer_t cmdBuf; + osd_raw_cmd_t osd_cmd; + + BitBuffer_Init(&cmdBuf, cmdData, sizeof(cmdData)); + memset(&osd_cmd, 0, sizeof(osd_raw_cmd_t)); + osd_cmd.cmd_data = cmdData; + HdffCmdBuildHeader(&cmdBuf, HDFF_MSG_TYPE_COMMAND, HDFF_MSG_GROUP_OSD, + HDFF_MSG_OSD_DELETE_FONT); + BitBuffer_SetBits(&cmdBuf, 32, Font); + osd_cmd.cmd_len = HdffCmdSetLength(&cmdBuf); + return ioctl(OsdDevice, OSD_RAW_CMD, &osd_cmd); +} + + +int HdffCmdOsdDrawRectangle(int OsdDevice, uint32_t Display, uint16_t X, + uint16_t Y, uint16_t Width, uint16_t Height, + uint32_t Color) +{ + uint8_t cmdData[24]; + BitBuffer_t cmdBuf; + osd_raw_cmd_t osd_cmd; + + BitBuffer_Init(&cmdBuf, cmdData, sizeof(cmdData)); + memset(&osd_cmd, 0, sizeof(osd_raw_cmd_t)); + osd_cmd.cmd_data = cmdData; + HdffCmdBuildHeader(&cmdBuf, HDFF_MSG_TYPE_COMMAND, HDFF_MSG_GROUP_OSD, + HDFF_MSG_OSD_DRAW_RECTANGLE); + BitBuffer_SetBits(&cmdBuf, 32, Display); + BitBuffer_SetBits(&cmdBuf, 16, X); + BitBuffer_SetBits(&cmdBuf, 16, Y); + BitBuffer_SetBits(&cmdBuf, 16, Width); + BitBuffer_SetBits(&cmdBuf, 16, Height); + BitBuffer_SetBits(&cmdBuf, 32, Color); + osd_cmd.cmd_len = HdffCmdSetLength(&cmdBuf); + return ioctl(OsdDevice, OSD_RAW_CMD, &osd_cmd); +} + +int HdffCmdOsdDrawEllipse(int OsdDevice, uint32_t Display, uint16_t CX, + uint16_t CY, uint16_t RadiusX, uint16_t RadiusY, + uint32_t Color, uint32_t Flags) +{ + uint8_t cmdData[28]; + BitBuffer_t cmdBuf; + osd_raw_cmd_t osd_cmd; + + BitBuffer_Init(&cmdBuf, cmdData, sizeof(cmdData)); + memset(&osd_cmd, 0, sizeof(osd_raw_cmd_t)); + osd_cmd.cmd_data = cmdData; + HdffCmdBuildHeader(&cmdBuf, HDFF_MSG_TYPE_COMMAND, HDFF_MSG_GROUP_OSD, + HDFF_MSG_OSD_DRAW_ELLIPSE); + BitBuffer_SetBits(&cmdBuf, 32, Display); + BitBuffer_SetBits(&cmdBuf, 16, CX); + BitBuffer_SetBits(&cmdBuf, 16, CY); + BitBuffer_SetBits(&cmdBuf, 16, RadiusX); + BitBuffer_SetBits(&cmdBuf, 16, RadiusY); + BitBuffer_SetBits(&cmdBuf, 32, Color); + BitBuffer_SetBits(&cmdBuf, 32, Flags); + osd_cmd.cmd_len = HdffCmdSetLength(&cmdBuf); + return ioctl(OsdDevice, OSD_RAW_CMD, &osd_cmd); +} + +int HdffCmdOsdDrawText(int OsdDevice, uint32_t Display, uint32_t Font, + uint16_t X, uint16_t Y, const char * Text, + uint32_t Color) +{ + uint8_t cmdData[1060]; + BitBuffer_t cmdBuf; + osd_raw_cmd_t osd_cmd; + int i; + int length; + + length = 0; + while (Text[length]) + { + length++; + } + if (length > 980) + length = 980; + + BitBuffer_Init(&cmdBuf, cmdData, sizeof(cmdData)); + memset(&osd_cmd, 0, sizeof(osd_raw_cmd_t)); + osd_cmd.cmd_data = cmdData; + HdffCmdBuildHeader(&cmdBuf, HDFF_MSG_TYPE_COMMAND, HDFF_MSG_GROUP_OSD, + HDFF_MSG_OSD_DRAW_TEXT); + BitBuffer_SetBits(&cmdBuf, 32, Display); + BitBuffer_SetBits(&cmdBuf, 32, Font); + BitBuffer_SetBits(&cmdBuf, 16, X); + BitBuffer_SetBits(&cmdBuf, 16, Y); + BitBuffer_SetBits(&cmdBuf, 32, Color); + BitBuffer_SetBits(&cmdBuf, 16, length); + for (i = 0; i < length; i++) + { + BitBuffer_SetBits(&cmdBuf, 8, Text[i]); + } + osd_cmd.cmd_len = HdffCmdSetLength(&cmdBuf); + return ioctl(OsdDevice, OSD_RAW_CMD, &osd_cmd); +} + +int HdffCmdOsdDrawWideText(int OsdDevice, uint32_t Display, uint32_t Font, + uint16_t X, uint16_t Y, const uint16_t * Text, + uint32_t Color) +{ + uint8_t cmdData[1060]; + BitBuffer_t cmdBuf; + osd_raw_cmd_t osd_cmd; + int i; + int length; + + length = 0; + while (Text[length]) + { + length++; + } + if (length > 480) + length = 480; + + BitBuffer_Init(&cmdBuf, cmdData, sizeof(cmdData)); + memset(&osd_cmd, 0, sizeof(osd_raw_cmd_t)); + osd_cmd.cmd_data = cmdData; + HdffCmdBuildHeader(&cmdBuf, HDFF_MSG_TYPE_COMMAND, HDFF_MSG_GROUP_OSD, + HDFF_MSG_OSD_DRAW_WIDE_TEXT); + BitBuffer_SetBits(&cmdBuf, 32, Display); + BitBuffer_SetBits(&cmdBuf, 32, Font); + BitBuffer_SetBits(&cmdBuf, 16, X); + BitBuffer_SetBits(&cmdBuf, 16, Y); + BitBuffer_SetBits(&cmdBuf, 32, Color); + BitBuffer_SetBits(&cmdBuf, 16, length); + for (i = 0; i < length; i++) + { + BitBuffer_SetBits(&cmdBuf, 16, Text[i]); + } + osd_cmd.cmd_len = HdffCmdSetLength(&cmdBuf); + return ioctl(OsdDevice, OSD_RAW_CMD, &osd_cmd); +} + +int HdffCmdOsdDrawBitmap(int OsdDevice, uint32_t Display, uint16_t X, + uint16_t Y, const uint8_t * Bitmap, uint16_t BmpWidth, + uint16_t BmpHeight, uint32_t BmpSize, + HdffColorType_t ColorType, uint32_t Palette) +{ + uint8_t cmdData[32]; + BitBuffer_t cmdBuf; + osd_raw_cmd_t osd_cmd; + osd_raw_data_t osd_data; + int err; + + memset(&osd_data, 0, sizeof(osd_raw_data_t)); + osd_data.data_buffer = Bitmap; + osd_data.data_length = BmpSize; + err = ioctl(OsdDevice, OSD_RAW_DATA, &osd_data); + if (err != 0) + return err; + + BitBuffer_Init(&cmdBuf, cmdData, sizeof(cmdData)); + memset(&osd_cmd, 0, sizeof(osd_raw_cmd_t)); + osd_cmd.cmd_data = cmdData; + HdffCmdBuildHeader(&cmdBuf, HDFF_MSG_TYPE_COMMAND, HDFF_MSG_GROUP_OSD, + HDFF_MSG_OSD_DRAW_BITMAP); + BitBuffer_SetBits(&cmdBuf, 32, Display); + BitBuffer_SetBits(&cmdBuf, 16, X); + BitBuffer_SetBits(&cmdBuf, 16, Y); + BitBuffer_SetBits(&cmdBuf, 16, BmpWidth); + BitBuffer_SetBits(&cmdBuf, 16, BmpHeight); + BitBuffer_SetBits(&cmdBuf, 8, ColorType); + BitBuffer_SetBits(&cmdBuf, 6, 0); // reserved + BitBuffer_SetBits(&cmdBuf, 2, 0); // uncompressed + BitBuffer_SetBits(&cmdBuf, 32, Palette); + BitBuffer_SetBits(&cmdBuf, 16, osd_data.data_handle); + BitBuffer_SetBits(&cmdBuf, 32, 0); + osd_cmd.cmd_len = HdffCmdSetLength(&cmdBuf); + return ioctl(OsdDevice, OSD_RAW_CMD, &osd_cmd); +} diff --git a/PLUGINS/src/dvbhddevice/libhdffcmd/hdffcmd_osd.h b/PLUGINS/src/dvbhddevice/libhdffcmd/hdffcmd_osd.h new file mode 100644 index 0000000..5c13559 --- /dev/null +++ b/PLUGINS/src/dvbhddevice/libhdffcmd/hdffcmd_osd.h @@ -0,0 +1,161 @@ +/********************************************************************** + * + * HDFF firmware command interface library + * + * Copyright (C) 2011 Andreas Regel + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the + * Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + *********************************************************************/ + +#ifndef HDFFCMD_OSD_H +#define HDFFCMD_OSD_H + + +#define HDFF_INVALID_HANDLE 0xFFFFFFFF +#define HDFF_SCREEN_DISPLAY_HANDLE 0xFFFFFFFE + +#define HDFF_POSITION_SCREEN_CENTERED 0xFFFF + +#define HDFF_SIZE_FULL_SCREEN 0xFFFF +#define HDFF_SIZE_SAME_AS_SOURCE 0xFFFE + +#define HDFF_FONT_FACE_TIRESIAS 0x00000000 + + +typedef struct HdffOsdConfig_t +{ + int FontAntialiasing; + int FontKerning; +} HdffOsdConfig_t; + +typedef enum HdffColorType_t +{ + HDFF_COLOR_TYPE_CLUT1, + HDFF_COLOR_TYPE_CLUT2, + HDFF_COLOR_TYPE_CLUT4, + HDFF_COLOR_TYPE_CLUT8, + HDFF_COLOR_TYPE_ARGB8888, + HDFF_COLOR_TYPE_ARGB8565, + HDFF_COLOR_TYPE_ARGB4444, + HDFF_COLOR_TYPE_ARGB1555, + HDFF_COLOR_TYPE_RGB888, + HDFF_COLOR_TYPE_RGB565 +} HdffColorType_t; + +typedef enum HdffColorFormat_t +{ + HDFF_COLOR_FORMAT_ARGB, + HDFF_COLOR_FORMAT_ACBYCR +} HdffColorFormat_t; + +typedef enum HdffDrawingFlags_t +{ + HDFF_DRAW_FULL, + HDFF_DRAW_HALF_TOP, + HDFF_DRAW_HALF_LEFT, + HDFF_DRAW_HALF_BOTTOM, + HDFF_DRAW_HALF_RIGHT, + HDFF_DRAW_QUARTER_TOP_LEFT, + HDFF_DRAW_QUARTER_TOP_RIGHT, + HDFF_DRAW_QUARTER_BOTTOM_LEFT, + HDFF_DRAW_QUARTER_BOTTOM_RIGHT, + HDFF_DRAW_QUARTER_TOP_LEFT_INVERTED, + HDFF_DRAW_QUARTER_TOP_RIGHT_INVERTED, + HDFF_DRAW_QUARTER_BOTTOM_LEFT_INVERTED, + HDFF_DRAW_QUARTER_BOTTOM_RIGHT_INVERTED +} HdffDrawingFlags_t; + + +int HdffCmdOsdConfigure(int OsdDevice, const HdffOsdConfig_t * Config); + +int HdffCmdOsdReset(int OsdDevice); + + +int HdffCmdOsdCreateDisplay(int OsdDevice, uint16_t Width, uint16_t Height, + HdffColorType_t ColorType, uint32_t * NewDisplay); + +int HdffCmdOsdDeleteDisplay(int OsdDevice, uint32_t Display); + +int HdffCmdOsdEnableDisplay(int OsdDevice, uint32_t Display, int Enable); + +int HdffCmdOsdSetDisplayOutputRectangle(int OsdDevice, uint32_t Display, + uint16_t X, uint16_t Y, + uint16_t Width, uint16_t Height); + +int HdffCmdOsdSetDisplayClippingArea(int OsdDevice, uint32_t Display, + int Enable, uint16_t X, uint16_t Y, + uint16_t Width, uint16_t Height); + +int HdffCmdOsdRenderDisplay(int OsdDevice, uint32_t Display); + +int HdffCmdOsdSaveRegion(int OsdDevice, uint32_t Display, + uint16_t X, uint16_t Y, + uint16_t Width, uint16_t Height); + +int HdffCmdOsdRestoreRegion(int OsdDevice, uint32_t Display); + + +int HdffCmdOsdCreatePalette(int OsdDevice, HdffColorType_t ColorType, + HdffColorFormat_t ColorFormat, + uint32_t NumColors, const uint32_t * Colors, + uint32_t * NewPalette); + +int HdffCmdOsdDeletePalette(int OsdDevice, uint32_t Palette); + +int HdffCmdOsdSetDisplayPalette(int OsdDevice, uint32_t Display, + uint32_t Palette); + +int HdffCmdOsdSetPaletteColors(int OsdDevice, uint32_t Palette, + HdffColorFormat_t ColorFormat, + uint8_t StartColor, uint32_t NumColors, + const uint32_t * Colors); + + +int HdffCmdOsdCreateFontFace(int OsdDevice, const uint8_t * FontData, + uint32_t DataSize, uint32_t * NewFontFace); + +int HdffCmdOsdDeleteFontFace(int OsdDevice, uint32_t FontFace); + +int HdffCmdOsdCreateFont(int OsdDevice, uint32_t FontFace, uint32_t Size, + uint32_t * NewFont); + +int HdffCmdOsdDeleteFont(int OsdDevice, uint32_t Font); + + +int HdffCmdOsdDrawRectangle(int OsdDevice, uint32_t Display, uint16_t X, + uint16_t Y, uint16_t Width, uint16_t Height, + uint32_t Color); + +int HdffCmdOsdDrawEllipse(int OsdDevice, uint32_t Display, uint16_t CX, + uint16_t CY, uint16_t RadiusX, uint16_t RadiusY, + uint32_t Color, uint32_t Flags); + +int HdffCmdOsdDrawText(int OsdDevice, uint32_t Display, uint32_t Font, + uint16_t X, uint16_t Y, const char * Text, + uint32_t Color); + +int HdffCmdOsdDrawWideText(int OsdDevice, uint32_t Display, uint32_t Font, + uint16_t X, uint16_t Y, const uint16_t * Text, + uint32_t Color); + +int HdffCmdOsdDrawBitmap(int OsdDevice, uint32_t Display, uint16_t X, + uint16_t Y, const uint8_t * Bitmap, uint16_t BmpWidth, + uint16_t BmpHeight, uint32_t BmpSize, + HdffColorType_t ColorType, uint32_t Palette); + + +#endif /* HDFFCMD_OSD_H */ diff --git a/PLUGINS/src/dvbhddevice/libhdffcmd/hdffcmd_remote.c b/PLUGINS/src/dvbhddevice/libhdffcmd/hdffcmd_remote.c new file mode 100644 index 0000000..d9bbe45 --- /dev/null +++ b/PLUGINS/src/dvbhddevice/libhdffcmd/hdffcmd_remote.c @@ -0,0 +1,67 @@ +/********************************************************************** + * + * HDFF firmware command interface library + * + * Copyright (C) 2011 Andreas Regel + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the + * Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + *********************************************************************/ + +#include <stdint.h> +#include <string.h> +#include <sys/ioctl.h> + +#include "hdffcmd.h" +#include "hdffcmd_base.h" +#include "hdffcmd_defs.h" + + +int HdffCmdRemoteSetProtocol(int OsdDevice, HdffRemoteProtocol_t Protocol) +{ + uint8_t cmdData[8]; + BitBuffer_t cmdBuf; + osd_raw_cmd_t osd_cmd; + + BitBuffer_Init(&cmdBuf, cmdData, sizeof(cmdData)); + memset(&osd_cmd, 0, sizeof(osd_raw_cmd_t)); + osd_cmd.cmd_data = cmdData; + HdffCmdBuildHeader(&cmdBuf, HDFF_MSG_TYPE_COMMAND, + HDFF_MSG_GROUP_REMOTE_CONTROL, + HDFF_MSG_REMOTE_SET_PROTOCOL); + BitBuffer_SetBits(&cmdBuf, 8, Protocol); + osd_cmd.cmd_len = HdffCmdSetLength(&cmdBuf); + return ioctl(OsdDevice, OSD_RAW_CMD, &osd_cmd); +} + +int HdffCmdRemoteSetAddressFilter(int OsdDevice, int Enable, uint32_t Address) +{ + uint8_t cmdData[12]; + BitBuffer_t cmdBuf; + osd_raw_cmd_t osd_cmd; + + BitBuffer_Init(&cmdBuf, cmdData, sizeof(cmdData)); + memset(&osd_cmd, 0, sizeof(osd_raw_cmd_t)); + osd_cmd.cmd_data = cmdData; + HdffCmdBuildHeader(&cmdBuf, HDFF_MSG_TYPE_COMMAND, + HDFF_MSG_GROUP_REMOTE_CONTROL, + HDFF_MSG_REMOTE_SET_ADDRESS_FILTER); + BitBuffer_SetBits(&cmdBuf, 1, Enable); + BitBuffer_SetBits(&cmdBuf, 7, 0); // reserved + BitBuffer_SetBits(&cmdBuf, 32, Address); + osd_cmd.cmd_len = HdffCmdSetLength(&cmdBuf); + return ioctl(OsdDevice, OSD_RAW_CMD, &osd_cmd); +} diff --git a/PLUGINS/src/dvbhddevice/libhdffcmd/hdffcmd_remote.h b/PLUGINS/src/dvbhddevice/libhdffcmd/hdffcmd_remote.h new file mode 100644 index 0000000..f2e6b8a --- /dev/null +++ b/PLUGINS/src/dvbhddevice/libhdffcmd/hdffcmd_remote.h @@ -0,0 +1,39 @@ +/********************************************************************** + * + * HDFF firmware command interface library + * + * Copyright (C) 2011 Andreas Regel + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the + * Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + *********************************************************************/ + +#ifndef HDFFCMD_REMOTE_H +#define HDFFCMD_REMOTE_H + +typedef enum HdffRemoteProtocol_t +{ + HDFF_REMOTE_PROTOCOL_NONE, + HDFF_REMOTE_PROTOCOL_RC5, + HDFF_REMOTE_PROTOCOL_RC6 +} HdffRemoteProtocol_t; + + +int HdffCmdRemoteSetProtocol(int OsdDevice, HdffRemoteProtocol_t Protocol); + +int HdffCmdRemoteSetAddressFilter(int OsdDevice, int Enable, uint32_t Address); + +#endif /* HDFFCMD_REMOTE_H */ |