vdr  1.7.27
hdffcmd_osd.c
Go to the documentation of this file.
00001 /**********************************************************************
00002  *
00003  * HDFF firmware command interface library
00004  *
00005  * Copyright (C) 2011  Andreas Regel
00006  *
00007  * This program is free software; you can redistribute it and/or
00008  * modify it under the terms of the GNU General Public License
00009  * as published by the Free Software Foundation; either version 2
00010  * of the License, or (at your option) any later version.
00011 
00012  * This program is distributed in the hope that it will be useful,
00013  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00014  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00015  * GNU General Public License for more details.
00016 
00017  * You should have received a copy of the GNU General Public License
00018  * along with this program; if not, write to the
00019  * Free Software Foundation, Inc.,
00020  * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
00021  *
00022  *********************************************************************/
00023 
00024 #include <stdint.h>
00025 #include <string.h>
00026 #include <sys/ioctl.h>
00027 
00028 #include "hdffcmd.h"
00029 #include "hdffcmd_base.h"
00030 #include "hdffcmd_defs.h"
00031 
00032 
00033 int HdffCmdOsdConfigure(int OsdDevice, const HdffOsdConfig_t * Config)
00034 {
00035     uint8_t cmdData[16];
00036     BitBuffer_t cmdBuf;
00037     osd_raw_cmd_t osd_cmd;
00038 
00039     BitBuffer_Init(&cmdBuf, cmdData, sizeof(cmdData));
00040     memset(&osd_cmd, 0, sizeof(osd_raw_cmd_t));
00041     osd_cmd.cmd_data = cmdData;
00042     HdffCmdBuildHeader(&cmdBuf, HDFF_MSG_TYPE_COMMAND, HDFF_MSG_GROUP_OSD,
00043                        HDFF_MSG_OSD_CONFIGURE);
00044     if (Config->FontAntialiasing)
00045     {
00046         BitBuffer_SetBits(&cmdBuf, 1, 1);
00047     }
00048     else
00049     {
00050         BitBuffer_SetBits(&cmdBuf, 1, 0);
00051     }
00052     if (Config->FontKerning)
00053     {
00054         BitBuffer_SetBits(&cmdBuf, 1, 1);
00055     }
00056     else
00057     {
00058         BitBuffer_SetBits(&cmdBuf, 1, 0);
00059     }
00060     osd_cmd.cmd_len = HdffCmdSetLength(&cmdBuf);
00061     return ioctl(OsdDevice, OSD_RAW_CMD, &osd_cmd);
00062 }
00063 
00064 int HdffCmdOsdReset(int OsdDevice)
00065 {
00066     uint8_t cmdData[8];
00067     BitBuffer_t cmdBuf;
00068     osd_raw_cmd_t osd_cmd;
00069 
00070     BitBuffer_Init(&cmdBuf, cmdData, sizeof(cmdData));
00071     memset(&osd_cmd, 0, sizeof(osd_raw_cmd_t));
00072     osd_cmd.cmd_data = cmdData;
00073     HdffCmdBuildHeader(&cmdBuf, HDFF_MSG_TYPE_COMMAND, HDFF_MSG_GROUP_OSD,
00074                        HDFF_MSG_OSD_RESET);
00075     osd_cmd.cmd_len = HdffCmdSetLength(&cmdBuf);
00076     return ioctl(OsdDevice, OSD_RAW_CMD, &osd_cmd);
00077 }
00078 
00079 
00080 int HdffCmdOsdCreateDisplay(int OsdDevice, uint16_t Width, uint16_t Height,
00081                             HdffColorType_t ColorType, uint32_t * NewDisplay)
00082 {
00083     uint8_t cmdData[16];
00084     uint8_t resultData[16];
00085     BitBuffer_t cmdBuf;
00086     osd_raw_cmd_t osd_cmd;
00087     int err;
00088 
00089     BitBuffer_Init(&cmdBuf, cmdData, sizeof(cmdData));
00090     memset(&osd_cmd, 0, sizeof(osd_raw_cmd_t));
00091     osd_cmd.cmd_data = cmdData;
00092     osd_cmd.result_data = resultData;
00093     osd_cmd.result_len = sizeof(resultData);
00094     HdffCmdBuildHeader(&cmdBuf, HDFF_MSG_TYPE_COMMAND, HDFF_MSG_GROUP_OSD,
00095                        HDFF_MSG_OSD_CREATE_DISPLAY);
00096     BitBuffer_SetBits(&cmdBuf, 16, Width);
00097     BitBuffer_SetBits(&cmdBuf, 16, Height);
00098     BitBuffer_SetBits(&cmdBuf, 8, ColorType);
00099     osd_cmd.cmd_len = HdffCmdSetLength(&cmdBuf);
00100     err = ioctl(OsdDevice, OSD_RAW_CMD, &osd_cmd);
00101     *NewDisplay = HDFF_INVALID_HANDLE;
00102     if (err == 0)
00103     {
00104         if (osd_cmd.result_len > 0)
00105         {
00106             if (resultData[2] == HDFF_MSG_TYPE_ANSWER)
00107             {
00108                 *NewDisplay = (resultData[6] << 24)
00109                             | (resultData[7] << 16)
00110                             | (resultData[8] << 8)
00111                             | resultData[9];
00112             }
00113             else
00114                 err = -1;
00115         }
00116     }
00117     return err;
00118 }
00119 
00120 int HdffCmdOsdDeleteDisplay(int OsdDevice, uint32_t Display)
00121 {
00122     uint8_t cmdData[16];
00123     BitBuffer_t cmdBuf;
00124     osd_raw_cmd_t osd_cmd;
00125 
00126     BitBuffer_Init(&cmdBuf, cmdData, sizeof(cmdData));
00127     memset(&osd_cmd, 0, sizeof(osd_raw_cmd_t));
00128     osd_cmd.cmd_data = cmdData;
00129     HdffCmdBuildHeader(&cmdBuf, HDFF_MSG_TYPE_COMMAND, HDFF_MSG_GROUP_OSD,
00130                        HDFF_MSG_OSD_DELETE_DISPLAY);
00131     BitBuffer_SetBits(&cmdBuf, 32, Display);
00132     osd_cmd.cmd_len = HdffCmdSetLength(&cmdBuf);
00133     return ioctl(OsdDevice, OSD_RAW_CMD, &osd_cmd);
00134 }
00135 
00136 int HdffCmdOsdEnableDisplay(int OsdDevice, uint32_t Display, int Enable)
00137 {
00138     uint8_t cmdData[16];
00139     BitBuffer_t cmdBuf;
00140     osd_raw_cmd_t osd_cmd;
00141 
00142     BitBuffer_Init(&cmdBuf, cmdData, sizeof(cmdData));
00143     memset(&osd_cmd, 0, sizeof(osd_raw_cmd_t));
00144     osd_cmd.cmd_data = cmdData;
00145     HdffCmdBuildHeader(&cmdBuf, HDFF_MSG_TYPE_COMMAND, HDFF_MSG_GROUP_OSD,
00146                        HDFF_MSG_OSD_ENABLE_DISPLAY);
00147     BitBuffer_SetBits(&cmdBuf, 32, Display);
00148     if (Enable)
00149     {
00150         BitBuffer_SetBits(&cmdBuf, 1, 1);
00151     }
00152     else
00153     {
00154         BitBuffer_SetBits(&cmdBuf, 1, 0);
00155     }
00156     osd_cmd.cmd_len = HdffCmdSetLength(&cmdBuf);
00157     return ioctl(OsdDevice, OSD_RAW_CMD, &osd_cmd);
00158 }
00159 
00160 int HdffCmdOsdSetDisplayOutputRectangle(int OsdDevice, uint32_t Display,
00161                                         uint16_t X, uint16_t Y,
00162                                         uint16_t Width, uint16_t Height)
00163 {
00164     uint8_t cmdData[20];
00165     BitBuffer_t cmdBuf;
00166     osd_raw_cmd_t osd_cmd;
00167 
00168     BitBuffer_Init(&cmdBuf, cmdData, sizeof(cmdData));
00169     memset(&osd_cmd, 0, sizeof(osd_raw_cmd_t));
00170     osd_cmd.cmd_data = cmdData;
00171     HdffCmdBuildHeader(&cmdBuf, HDFF_MSG_TYPE_COMMAND, HDFF_MSG_GROUP_OSD,
00172                        HDFF_MSG_OSD_SET_DISPLAY_OUTPUT_RECTANGLE);
00173     BitBuffer_SetBits(&cmdBuf, 32, Display);
00174     BitBuffer_SetBits(&cmdBuf, 16, X);
00175     BitBuffer_SetBits(&cmdBuf, 16, Y);
00176     BitBuffer_SetBits(&cmdBuf, 16, Width);
00177     BitBuffer_SetBits(&cmdBuf, 16, Height);
00178     osd_cmd.cmd_len = HdffCmdSetLength(&cmdBuf);
00179     return ioctl(OsdDevice, OSD_RAW_CMD, &osd_cmd);
00180 }
00181 
00182 int HdffCmdOsdSetDisplayClippingArea(int OsdDevice, uint32_t Display,
00183                                      int Enable, uint16_t X, uint16_t Y,
00184                                      uint16_t Width, uint16_t Height)
00185 {
00186     uint8_t cmdData[20];
00187     BitBuffer_t cmdBuf;
00188     osd_raw_cmd_t osd_cmd;
00189 
00190     BitBuffer_Init(&cmdBuf, cmdData, sizeof(cmdData));
00191     memset(&osd_cmd, 0, sizeof(osd_raw_cmd_t));
00192     osd_cmd.cmd_data = cmdData;
00193     HdffCmdBuildHeader(&cmdBuf, HDFF_MSG_TYPE_COMMAND, HDFF_MSG_GROUP_OSD,
00194                        HDFF_MSG_OSD_SET_DISPLAY_CLIPPLING_AREA);
00195     BitBuffer_SetBits(&cmdBuf, 32, Display);
00196     if (Enable)
00197     {
00198         BitBuffer_SetBits(&cmdBuf, 1, 1);
00199     }
00200     else
00201     {
00202         BitBuffer_SetBits(&cmdBuf, 1, 0);
00203     }
00204     BitBuffer_SetBits(&cmdBuf, 7, 0); // reserved
00205     BitBuffer_SetBits(&cmdBuf, 16, X);
00206     BitBuffer_SetBits(&cmdBuf, 16, Y);
00207     BitBuffer_SetBits(&cmdBuf, 16, Width);
00208     BitBuffer_SetBits(&cmdBuf, 16, Height);
00209     osd_cmd.cmd_len = HdffCmdSetLength(&cmdBuf);
00210     return ioctl(OsdDevice, OSD_RAW_CMD, &osd_cmd);
00211 }
00212 
00213 int HdffCmdOsdRenderDisplay(int OsdDevice, uint32_t Display)
00214 {
00215     uint8_t cmdData[16];
00216     BitBuffer_t cmdBuf;
00217     osd_raw_cmd_t osd_cmd;
00218 
00219     BitBuffer_Init(&cmdBuf, cmdData, sizeof(cmdData));
00220     memset(&osd_cmd, 0, sizeof(osd_raw_cmd_t));
00221     osd_cmd.cmd_data = cmdData;
00222     HdffCmdBuildHeader(&cmdBuf, HDFF_MSG_TYPE_COMMAND, HDFF_MSG_GROUP_OSD,
00223                        HDFF_MSG_OSD_RENDER_DISPLAY);
00224     BitBuffer_SetBits(&cmdBuf, 32, Display);
00225     osd_cmd.cmd_len = HdffCmdSetLength(&cmdBuf);
00226     return ioctl(OsdDevice, OSD_RAW_CMD, &osd_cmd);
00227 }
00228 
00229 int HdffCmdOsdSaveRegion(int OsdDevice, uint32_t Display,
00230                          uint16_t X, uint16_t Y,
00231                          uint16_t Width, uint16_t Height)
00232 {
00233     uint8_t cmdData[20];
00234     BitBuffer_t cmdBuf;
00235     osd_raw_cmd_t osd_cmd;
00236 
00237     BitBuffer_Init(&cmdBuf, cmdData, sizeof(cmdData));
00238     memset(&osd_cmd, 0, sizeof(osd_raw_cmd_t));
00239     osd_cmd.cmd_data = cmdData;
00240     HdffCmdBuildHeader(&cmdBuf, HDFF_MSG_TYPE_COMMAND, HDFF_MSG_GROUP_OSD,
00241                        HDFF_MSG_OSD_SAVE_REGION);
00242     BitBuffer_SetBits(&cmdBuf, 32, Display);
00243     BitBuffer_SetBits(&cmdBuf, 16, X);
00244     BitBuffer_SetBits(&cmdBuf, 16, Y);
00245     BitBuffer_SetBits(&cmdBuf, 16, Width);
00246     BitBuffer_SetBits(&cmdBuf, 16, Height);
00247     osd_cmd.cmd_len = HdffCmdSetLength(&cmdBuf);
00248     return ioctl(OsdDevice, OSD_RAW_CMD, &osd_cmd);
00249 }
00250 
00251 int HdffCmdOsdRestoreRegion(int OsdDevice, uint32_t Display)
00252 {
00253     uint8_t cmdData[16];
00254     BitBuffer_t cmdBuf;
00255     osd_raw_cmd_t osd_cmd;
00256 
00257     BitBuffer_Init(&cmdBuf, cmdData, sizeof(cmdData));
00258     memset(&osd_cmd, 0, sizeof(osd_raw_cmd_t));
00259     osd_cmd.cmd_data = cmdData;
00260     HdffCmdBuildHeader(&cmdBuf, HDFF_MSG_TYPE_COMMAND, HDFF_MSG_GROUP_OSD,
00261                        HDFF_MSG_OSD_RESTORE_REGION);
00262     BitBuffer_SetBits(&cmdBuf, 32, Display);
00263     osd_cmd.cmd_len = HdffCmdSetLength(&cmdBuf);
00264     return ioctl(OsdDevice, OSD_RAW_CMD, &osd_cmd);
00265 }
00266 
00267 
00268 int HdffCmdOsdCreatePalette(int OsdDevice, HdffColorType_t ColorType,
00269                             HdffColorFormat_t ColorFormat,
00270                             uint32_t NumColors, const uint32_t * Colors,
00271                             uint32_t * NewPalette)
00272 {
00273     uint8_t cmdData[1060];
00274     uint8_t resultData[16];
00275     BitBuffer_t cmdBuf;
00276     osd_raw_cmd_t osd_cmd;
00277     int i;
00278     int err;
00279 
00280     BitBuffer_Init(&cmdBuf, cmdData, sizeof(cmdData));
00281     memset(&osd_cmd, 0, sizeof(osd_raw_cmd_t));
00282     osd_cmd.cmd_data = cmdData;
00283     osd_cmd.result_data = resultData;
00284     osd_cmd.result_len = sizeof(resultData);
00285     HdffCmdBuildHeader(&cmdBuf, HDFF_MSG_TYPE_COMMAND, HDFF_MSG_GROUP_OSD,
00286                        HDFF_MSG_OSD_CREATE_PALETTE);
00287     BitBuffer_SetBits(&cmdBuf, 8, ColorType);
00288     BitBuffer_SetBits(&cmdBuf, 8, ColorFormat);
00289     if (NumColors > 256)
00290         NumColors = 256;
00291     BitBuffer_SetBits(&cmdBuf, 8, NumColors == 256 ? 0 : NumColors);
00292     for (i = 0; i < NumColors; i++)
00293     {
00294         BitBuffer_SetBits(&cmdBuf, 32, Colors[i]);
00295     }
00296     osd_cmd.cmd_len = HdffCmdSetLength(&cmdBuf);
00297     err = ioctl(OsdDevice, OSD_RAW_CMD, &osd_cmd);
00298     *NewPalette = HDFF_INVALID_HANDLE;
00299     if (err == 0)
00300     {
00301         if (osd_cmd.result_len > 0)
00302         {
00303             if (resultData[2] == HDFF_MSG_TYPE_ANSWER)
00304             {
00305                 *NewPalette = (resultData[6] << 24)
00306                             | (resultData[7] << 16)
00307                             | (resultData[8] << 8)
00308                             | resultData[9];
00309             }
00310             else
00311                 err = -1;
00312         }
00313     }
00314     return err;
00315 }
00316 
00317 int HdffCmdOsdDeletePalette(int OsdDevice, uint32_t Palette)
00318 {
00319     uint8_t cmdData[16];
00320     BitBuffer_t cmdBuf;
00321     osd_raw_cmd_t osd_cmd;
00322 
00323     BitBuffer_Init(&cmdBuf, cmdData, sizeof(cmdData));
00324     memset(&osd_cmd, 0, sizeof(osd_raw_cmd_t));
00325     osd_cmd.cmd_data = cmdData;
00326     HdffCmdBuildHeader(&cmdBuf, HDFF_MSG_TYPE_COMMAND, HDFF_MSG_GROUP_OSD,
00327                        HDFF_MSG_OSD_DELETE_PALETTE);
00328     BitBuffer_SetBits(&cmdBuf, 32, Palette);
00329     osd_cmd.cmd_len = HdffCmdSetLength(&cmdBuf);
00330     return ioctl(OsdDevice, OSD_RAW_CMD, &osd_cmd);
00331 }
00332 
00333 int HdffCmdOsdSetDisplayPalette(int OsdDevice, uint32_t Display,
00334                                 uint32_t Palette)
00335 {
00336     uint8_t cmdData[16];
00337     BitBuffer_t cmdBuf;
00338     osd_raw_cmd_t osd_cmd;
00339 
00340     BitBuffer_Init(&cmdBuf, cmdData, sizeof(cmdData));
00341     memset(&osd_cmd, 0, sizeof(osd_raw_cmd_t));
00342     osd_cmd.cmd_data = cmdData;
00343     HdffCmdBuildHeader(&cmdBuf, HDFF_MSG_TYPE_COMMAND, HDFF_MSG_GROUP_OSD,
00344                        HDFF_MSG_OSD_SET_DISPLAY_PALETTE);
00345     BitBuffer_SetBits(&cmdBuf, 32, Display);
00346     BitBuffer_SetBits(&cmdBuf, 32, Palette);
00347     osd_cmd.cmd_len = HdffCmdSetLength(&cmdBuf);
00348     return ioctl(OsdDevice, OSD_RAW_CMD, &osd_cmd);
00349 }
00350 
00351 int HdffCmdOsdSetPaletteColors(int OsdDevice, uint32_t Palette,
00352                                HdffColorFormat_t ColorFormat,
00353                                uint8_t StartColor, uint32_t NumColors,
00354                                const uint32_t * Colors)
00355 {
00356     uint8_t cmdData[1060];
00357     BitBuffer_t cmdBuf;
00358     osd_raw_cmd_t osd_cmd;
00359     int i;
00360 
00361     BitBuffer_Init(&cmdBuf, cmdData, sizeof(cmdData));
00362     memset(&osd_cmd, 0, sizeof(osd_raw_cmd_t));
00363     osd_cmd.cmd_data = cmdData;
00364     HdffCmdBuildHeader(&cmdBuf, HDFF_MSG_TYPE_COMMAND, HDFF_MSG_GROUP_OSD,
00365                        HDFF_MSG_OSD_SET_PALETTE_COLORS);
00366     BitBuffer_SetBits(&cmdBuf, 32, Palette);
00367     BitBuffer_SetBits(&cmdBuf, 8, ColorFormat);
00368     BitBuffer_SetBits(&cmdBuf, 8, StartColor);
00369     if (NumColors > 256)
00370         NumColors = 256;
00371     BitBuffer_SetBits(&cmdBuf, 8, NumColors == 256 ? 0 : NumColors);
00372     for (i = 0; i < NumColors; i++)
00373     {
00374         BitBuffer_SetBits(&cmdBuf, 32, Colors[i]);
00375     }
00376     osd_cmd.cmd_len = HdffCmdSetLength(&cmdBuf);
00377     return ioctl(OsdDevice, OSD_RAW_CMD, &osd_cmd);
00378 }
00379 
00380 int HdffCmdOsdCreateFontFace(int OsdDevice, const uint8_t * FontData,
00381                              uint32_t DataSize, uint32_t * NewFontFace)
00382 {
00383     uint8_t cmdData[16];
00384     uint8_t resultData[16];
00385     BitBuffer_t cmdBuf;
00386     osd_raw_cmd_t osd_cmd;
00387     osd_raw_data_t osd_data;
00388     int err;
00389 
00390     *NewFontFace = HDFF_INVALID_HANDLE;
00391 
00392     memset(&osd_data, 0, sizeof(osd_raw_data_t));
00393     osd_data.data_buffer = FontData;
00394     osd_data.data_length = DataSize;
00395     err = ioctl(OsdDevice, OSD_RAW_DATA, &osd_data);
00396     if (err != 0)
00397         return err;
00398 
00399     BitBuffer_Init(&cmdBuf, cmdData, sizeof(cmdData));
00400     memset(&osd_cmd, 0, sizeof(osd_raw_cmd_t));
00401     osd_cmd.cmd_data = cmdData;
00402     osd_cmd.result_data = resultData;
00403     osd_cmd.result_len = sizeof(resultData);
00404     HdffCmdBuildHeader(&cmdBuf, HDFF_MSG_TYPE_COMMAND, HDFF_MSG_GROUP_OSD,
00405                        HDFF_MSG_OSD_CREATE_FONT_FACE);
00406     BitBuffer_SetBits(&cmdBuf, 16, osd_data.data_handle);
00407     osd_cmd.cmd_len = HdffCmdSetLength(&cmdBuf);
00408     err = ioctl(OsdDevice, OSD_RAW_CMD, &osd_cmd);
00409     if (err == 0)
00410     {
00411         if (osd_cmd.result_len > 0)
00412         {
00413             if (resultData[2] == HDFF_MSG_TYPE_ANSWER)
00414             {
00415                 *NewFontFace = (resultData[6] << 24)
00416                              | (resultData[7] << 16)
00417                              | (resultData[8] << 8)
00418                              | resultData[9];
00419             }
00420             else
00421                 err = -1;
00422         }
00423     }
00424     return err;
00425 }
00426 
00427 int HdffCmdOsdDeleteFontFace(int OsdDevice, uint32_t FontFace)
00428 {
00429     uint8_t cmdData[16];
00430     BitBuffer_t cmdBuf;
00431     osd_raw_cmd_t osd_cmd;
00432 
00433     BitBuffer_Init(&cmdBuf, cmdData, sizeof(cmdData));
00434     memset(&osd_cmd, 0, sizeof(osd_raw_cmd_t));
00435     osd_cmd.cmd_data = cmdData;
00436     HdffCmdBuildHeader(&cmdBuf, HDFF_MSG_TYPE_COMMAND, HDFF_MSG_GROUP_OSD,
00437                        HDFF_MSG_OSD_DELETE_FONT_FACE);
00438     BitBuffer_SetBits(&cmdBuf, 32, FontFace);
00439     osd_cmd.cmd_len = HdffCmdSetLength(&cmdBuf);
00440     return ioctl(OsdDevice, OSD_RAW_CMD, &osd_cmd);
00441 }
00442 
00443 int HdffCmdOsdCreateFont(int OsdDevice, uint32_t FontFace, uint32_t Size,
00444                          uint32_t * NewFont)
00445 {
00446     uint8_t cmdData[16];
00447     uint8_t resultData[16];
00448     BitBuffer_t cmdBuf;
00449     osd_raw_cmd_t osd_cmd;
00450     int err;
00451 
00452     *NewFont = HDFF_INVALID_HANDLE;
00453 
00454     BitBuffer_Init(&cmdBuf, cmdData, sizeof(cmdData));
00455     memset(&osd_cmd, 0, sizeof(osd_raw_cmd_t));
00456     osd_cmd.cmd_data = cmdData;
00457     osd_cmd.result_data = resultData;
00458     osd_cmd.result_len = sizeof(resultData);
00459     HdffCmdBuildHeader(&cmdBuf, HDFF_MSG_TYPE_COMMAND, HDFF_MSG_GROUP_OSD,
00460                        HDFF_MSG_OSD_CREATE_FONT);
00461     BitBuffer_SetBits(&cmdBuf, 32, FontFace);
00462     BitBuffer_SetBits(&cmdBuf, 32, Size);
00463     osd_cmd.cmd_len = HdffCmdSetLength(&cmdBuf);
00464     err = ioctl(OsdDevice, OSD_RAW_CMD, &osd_cmd);
00465     if (err == 0)
00466     {
00467         if (osd_cmd.result_len > 0)
00468         {
00469             if (resultData[2] == HDFF_MSG_TYPE_ANSWER)
00470             {
00471                 *NewFont = (resultData[6] << 24)
00472                          | (resultData[7] << 16)
00473                          | (resultData[8] << 8)
00474                          | resultData[9];
00475             }
00476             else
00477                 err = -1;
00478         }
00479     }
00480     return err;
00481 }
00482 
00483 int HdffCmdOsdDeleteFont(int OsdDevice, uint32_t Font)
00484 {
00485     uint8_t cmdData[16];
00486     BitBuffer_t cmdBuf;
00487     osd_raw_cmd_t osd_cmd;
00488 
00489     BitBuffer_Init(&cmdBuf, cmdData, sizeof(cmdData));
00490     memset(&osd_cmd, 0, sizeof(osd_raw_cmd_t));
00491     osd_cmd.cmd_data = cmdData;
00492     HdffCmdBuildHeader(&cmdBuf, HDFF_MSG_TYPE_COMMAND, HDFF_MSG_GROUP_OSD,
00493                        HDFF_MSG_OSD_DELETE_FONT);
00494     BitBuffer_SetBits(&cmdBuf, 32, Font);
00495     osd_cmd.cmd_len = HdffCmdSetLength(&cmdBuf);
00496     return ioctl(OsdDevice, OSD_RAW_CMD, &osd_cmd);
00497 }
00498 
00499 
00500 int HdffCmdOsdDrawRectangle(int OsdDevice, uint32_t Display, uint16_t X,
00501                             uint16_t Y, uint16_t Width, uint16_t Height,
00502                             uint32_t Color)
00503 {
00504     uint8_t cmdData[24];
00505     BitBuffer_t cmdBuf;
00506     osd_raw_cmd_t osd_cmd;
00507 
00508     BitBuffer_Init(&cmdBuf, cmdData, sizeof(cmdData));
00509     memset(&osd_cmd, 0, sizeof(osd_raw_cmd_t));
00510     osd_cmd.cmd_data = cmdData;
00511     HdffCmdBuildHeader(&cmdBuf, HDFF_MSG_TYPE_COMMAND, HDFF_MSG_GROUP_OSD,
00512                        HDFF_MSG_OSD_DRAW_RECTANGLE);
00513     BitBuffer_SetBits(&cmdBuf, 32, Display);
00514     BitBuffer_SetBits(&cmdBuf, 16, X);
00515     BitBuffer_SetBits(&cmdBuf, 16, Y);
00516     BitBuffer_SetBits(&cmdBuf, 16, Width);
00517     BitBuffer_SetBits(&cmdBuf, 16, Height);
00518     BitBuffer_SetBits(&cmdBuf, 32, Color);
00519     osd_cmd.cmd_len = HdffCmdSetLength(&cmdBuf);
00520     return ioctl(OsdDevice, OSD_RAW_CMD, &osd_cmd);
00521 }
00522 
00523 int HdffCmdOsdDrawEllipse(int OsdDevice, uint32_t Display, uint16_t CX,
00524                           uint16_t CY, uint16_t RadiusX, uint16_t RadiusY,
00525                           uint32_t Color, uint32_t Flags)
00526 {
00527     uint8_t cmdData[28];
00528     BitBuffer_t cmdBuf;
00529     osd_raw_cmd_t osd_cmd;
00530 
00531     BitBuffer_Init(&cmdBuf, cmdData, sizeof(cmdData));
00532     memset(&osd_cmd, 0, sizeof(osd_raw_cmd_t));
00533     osd_cmd.cmd_data = cmdData;
00534     HdffCmdBuildHeader(&cmdBuf, HDFF_MSG_TYPE_COMMAND, HDFF_MSG_GROUP_OSD,
00535                        HDFF_MSG_OSD_DRAW_ELLIPSE);
00536     BitBuffer_SetBits(&cmdBuf, 32, Display);
00537     BitBuffer_SetBits(&cmdBuf, 16, CX);
00538     BitBuffer_SetBits(&cmdBuf, 16, CY);
00539     BitBuffer_SetBits(&cmdBuf, 16, RadiusX);
00540     BitBuffer_SetBits(&cmdBuf, 16, RadiusY);
00541     BitBuffer_SetBits(&cmdBuf, 32, Color);
00542     BitBuffer_SetBits(&cmdBuf, 32, Flags);
00543     osd_cmd.cmd_len = HdffCmdSetLength(&cmdBuf);
00544     return ioctl(OsdDevice, OSD_RAW_CMD, &osd_cmd);
00545 }
00546 
00547 int HdffCmdOsdDrawText(int OsdDevice, uint32_t Display, uint32_t Font,
00548                        uint16_t X, uint16_t Y, const char * Text,
00549                        uint32_t Color)
00550 {
00551     uint8_t cmdData[1060];
00552     BitBuffer_t cmdBuf;
00553     osd_raw_cmd_t osd_cmd;
00554     int i;
00555     int length;
00556 
00557     length = 0;
00558     while (Text[length])
00559     {
00560         length++;
00561     }
00562     if (length > 980)
00563         length = 980;
00564 
00565     BitBuffer_Init(&cmdBuf, cmdData, sizeof(cmdData));
00566     memset(&osd_cmd, 0, sizeof(osd_raw_cmd_t));
00567     osd_cmd.cmd_data = cmdData;
00568     HdffCmdBuildHeader(&cmdBuf, HDFF_MSG_TYPE_COMMAND, HDFF_MSG_GROUP_OSD,
00569                        HDFF_MSG_OSD_DRAW_TEXT);
00570     BitBuffer_SetBits(&cmdBuf, 32, Display);
00571     BitBuffer_SetBits(&cmdBuf, 32, Font);
00572     BitBuffer_SetBits(&cmdBuf, 16, X);
00573     BitBuffer_SetBits(&cmdBuf, 16, Y);
00574     BitBuffer_SetBits(&cmdBuf, 32, Color);
00575     BitBuffer_SetBits(&cmdBuf, 16, length);
00576     for (i = 0; i < length; i++)
00577     {
00578         BitBuffer_SetBits(&cmdBuf, 8, Text[i]);
00579     }
00580     osd_cmd.cmd_len = HdffCmdSetLength(&cmdBuf);
00581     return ioctl(OsdDevice, OSD_RAW_CMD, &osd_cmd);
00582 }
00583 
00584 int HdffCmdOsdDrawWideText(int OsdDevice, uint32_t Display, uint32_t Font,
00585                            uint16_t X, uint16_t Y, const uint16_t * Text,
00586                            uint32_t Color)
00587 {
00588     uint8_t cmdData[1060];
00589     BitBuffer_t cmdBuf;
00590     osd_raw_cmd_t osd_cmd;
00591     int i;
00592     int length;
00593 
00594     length = 0;
00595     while (Text[length])
00596     {
00597         length++;
00598     }
00599     if (length > 480)
00600         length = 480;
00601 
00602     BitBuffer_Init(&cmdBuf, cmdData, sizeof(cmdData));
00603     memset(&osd_cmd, 0, sizeof(osd_raw_cmd_t));
00604     osd_cmd.cmd_data = cmdData;
00605     HdffCmdBuildHeader(&cmdBuf, HDFF_MSG_TYPE_COMMAND, HDFF_MSG_GROUP_OSD,
00606                        HDFF_MSG_OSD_DRAW_WIDE_TEXT);
00607     BitBuffer_SetBits(&cmdBuf, 32, Display);
00608     BitBuffer_SetBits(&cmdBuf, 32, Font);
00609     BitBuffer_SetBits(&cmdBuf, 16, X);
00610     BitBuffer_SetBits(&cmdBuf, 16, Y);
00611     BitBuffer_SetBits(&cmdBuf, 32, Color);
00612     BitBuffer_SetBits(&cmdBuf, 16, length);
00613     for (i = 0; i < length; i++)
00614     {
00615         BitBuffer_SetBits(&cmdBuf, 16, Text[i]);
00616     }
00617     osd_cmd.cmd_len = HdffCmdSetLength(&cmdBuf);
00618     return ioctl(OsdDevice, OSD_RAW_CMD, &osd_cmd);
00619 }
00620 
00621 int HdffCmdOsdDrawBitmap(int OsdDevice, uint32_t Display, uint16_t X,
00622                          uint16_t Y, const uint8_t * Bitmap, uint16_t BmpWidth,
00623                          uint16_t BmpHeight, uint32_t BmpSize,
00624                          HdffColorType_t ColorType, uint32_t Palette)
00625 {
00626     uint8_t cmdData[32];
00627     BitBuffer_t cmdBuf;
00628     osd_raw_cmd_t osd_cmd;
00629     osd_raw_data_t osd_data;
00630     int err;
00631 
00632     memset(&osd_data, 0, sizeof(osd_raw_data_t));
00633     osd_data.data_buffer = Bitmap;
00634     osd_data.data_length = BmpSize;
00635     err = ioctl(OsdDevice, OSD_RAW_DATA, &osd_data);
00636     if (err != 0)
00637         return err;
00638 
00639     BitBuffer_Init(&cmdBuf, cmdData, sizeof(cmdData));
00640     memset(&osd_cmd, 0, sizeof(osd_raw_cmd_t));
00641     osd_cmd.cmd_data = cmdData;
00642     HdffCmdBuildHeader(&cmdBuf, HDFF_MSG_TYPE_COMMAND, HDFF_MSG_GROUP_OSD,
00643                        HDFF_MSG_OSD_DRAW_BITMAP);
00644     BitBuffer_SetBits(&cmdBuf, 32, Display);
00645     BitBuffer_SetBits(&cmdBuf, 16, X);
00646     BitBuffer_SetBits(&cmdBuf, 16, Y);
00647     BitBuffer_SetBits(&cmdBuf, 16, BmpWidth);
00648     BitBuffer_SetBits(&cmdBuf, 16, BmpHeight);
00649     BitBuffer_SetBits(&cmdBuf, 8, ColorType);
00650     BitBuffer_SetBits(&cmdBuf, 6, 0); // reserved
00651     BitBuffer_SetBits(&cmdBuf, 2, 0); // uncompressed
00652     BitBuffer_SetBits(&cmdBuf, 32, Palette);
00653     BitBuffer_SetBits(&cmdBuf, 16, osd_data.data_handle);
00654     BitBuffer_SetBits(&cmdBuf, 32, 0);
00655     osd_cmd.cmd_len = HdffCmdSetLength(&cmdBuf);
00656     return ioctl(OsdDevice, OSD_RAW_CMD, &osd_cmd);
00657 }