vdr  1.7.27
hdffcmd_av.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 HdffCmdAvSetPlayMode(int OsdDevice, uint8_t PlayMode, int Realtime)
00034 {
00035     uint8_t cmdData[8];
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,
00043                        HDFF_MSG_GROUP_AV_DECODER,
00044                        HDFF_MSG_AV_SET_PLAY_MODE);
00045     BitBuffer_SetBits(&cmdBuf, 1, Realtime ? 1 : 0);
00046     BitBuffer_SetBits(&cmdBuf, 7, PlayMode);
00047     osd_cmd.cmd_len = HdffCmdSetLength(&cmdBuf);
00048     return ioctl(OsdDevice, OSD_RAW_CMD, &osd_cmd);
00049 }
00050 
00051 int HdffCmdAvSetVideoPid(int OsdDevice, uint8_t DecoderIndex, uint16_t Pid,
00052                          HdffVideoStreamType_t StreamType)
00053 {
00054     uint8_t cmdData[16];
00055     BitBuffer_t cmdBuf;
00056     osd_raw_cmd_t osd_cmd;
00057 
00058     BitBuffer_Init(&cmdBuf, cmdData, sizeof(cmdData));
00059     memset(&osd_cmd, 0, sizeof(osd_raw_cmd_t));
00060     osd_cmd.cmd_data = cmdData;
00061     HdffCmdBuildHeader(&cmdBuf, HDFF_MSG_TYPE_COMMAND,
00062                        HDFF_MSG_GROUP_AV_DECODER,
00063                        HDFF_MSG_AV_SET_VIDEO_PID);
00064     BitBuffer_SetBits(&cmdBuf, 4, DecoderIndex);
00065     BitBuffer_SetBits(&cmdBuf, 4, StreamType);
00066     BitBuffer_SetBits(&cmdBuf, 3, 0); // reserved
00067     BitBuffer_SetBits(&cmdBuf, 13, Pid);
00068     osd_cmd.cmd_len = HdffCmdSetLength(&cmdBuf);
00069     return ioctl(OsdDevice, OSD_RAW_CMD, &osd_cmd);
00070 }
00071 
00072 int HdffCmdAvSetAudioPid(int OsdDevice, uint8_t DecoderIndex, uint16_t Pid,
00073                          HdffAudioStreamType_t StreamType,
00074                          HdffAvContainerType_t ContainerType)
00075 {
00076     uint8_t cmdData[16];
00077     BitBuffer_t cmdBuf;
00078     osd_raw_cmd_t osd_cmd;
00079 
00080     BitBuffer_Init(&cmdBuf, cmdData, sizeof(cmdData));
00081     memset(&osd_cmd, 0, sizeof(osd_raw_cmd_t));
00082     osd_cmd.cmd_data = cmdData;
00083     HdffCmdBuildHeader(&cmdBuf, HDFF_MSG_TYPE_COMMAND,
00084                        HDFF_MSG_GROUP_AV_DECODER,
00085                        HDFF_MSG_AV_SET_AUDIO_PID);
00086     BitBuffer_SetBits(&cmdBuf, 4, DecoderIndex);
00087     BitBuffer_SetBits(&cmdBuf, 4, StreamType);
00088     BitBuffer_SetBits(&cmdBuf, 2, 0); // reserved
00089     BitBuffer_SetBits(&cmdBuf, 1, ContainerType);
00090     BitBuffer_SetBits(&cmdBuf, 13, Pid);
00091     osd_cmd.cmd_len = HdffCmdSetLength(&cmdBuf);
00092     return ioctl(OsdDevice, OSD_RAW_CMD, &osd_cmd);
00093 }
00094 
00095 int HdffCmdAvSetPcrPid(int OsdDevice, uint8_t DecoderIndex, uint16_t Pid)
00096 {
00097     uint8_t cmdData[16];
00098     BitBuffer_t cmdBuf;
00099     osd_raw_cmd_t osd_cmd;
00100 
00101     BitBuffer_Init(&cmdBuf, cmdData, sizeof(cmdData));
00102     memset(&osd_cmd, 0, sizeof(osd_raw_cmd_t));
00103     osd_cmd.cmd_data = cmdData;
00104     HdffCmdBuildHeader(&cmdBuf, HDFF_MSG_TYPE_COMMAND,
00105                        HDFF_MSG_GROUP_AV_DECODER,
00106                        HDFF_MSG_AV_SET_PCR_PID);
00107     BitBuffer_SetBits(&cmdBuf, 4, DecoderIndex);
00108     BitBuffer_SetBits(&cmdBuf, 4, 0); // reserved
00109     BitBuffer_SetBits(&cmdBuf, 3, 0); // reserved
00110     BitBuffer_SetBits(&cmdBuf, 13, Pid);
00111     osd_cmd.cmd_len = HdffCmdSetLength(&cmdBuf);
00112     return ioctl(OsdDevice, OSD_RAW_CMD, &osd_cmd);
00113 }
00114 
00115 int HdffCmdAvSetTeletextPid(int OsdDevice, uint8_t DecoderIndex, uint16_t Pid)
00116 {
00117     uint8_t cmdData[16];
00118     BitBuffer_t cmdBuf;
00119     osd_raw_cmd_t osd_cmd;
00120 
00121     BitBuffer_Init(&cmdBuf, cmdData, sizeof(cmdData));
00122     memset(&osd_cmd, 0, sizeof(osd_raw_cmd_t));
00123     osd_cmd.cmd_data = cmdData;
00124     HdffCmdBuildHeader(&cmdBuf, HDFF_MSG_TYPE_COMMAND,
00125                        HDFF_MSG_GROUP_AV_DECODER,
00126                        HDFF_MSG_AV_SET_TELETEXT_PID);
00127     BitBuffer_SetBits(&cmdBuf, 4, DecoderIndex);
00128     BitBuffer_SetBits(&cmdBuf, 4, 0); // reserved
00129     BitBuffer_SetBits(&cmdBuf, 3, 0); // reserved
00130     BitBuffer_SetBits(&cmdBuf, 13, Pid);
00131     osd_cmd.cmd_len = HdffCmdSetLength(&cmdBuf);
00132     return ioctl(OsdDevice, OSD_RAW_CMD, &osd_cmd);
00133 }
00134 
00135 int HdffCmdAvSetVideoWindow(int OsdDevice, uint8_t DecoderIndex, int Enable,
00136                             uint16_t X, uint16_t Y, uint16_t Width,
00137                             uint16_t Height)
00138 {
00139     uint8_t cmdData[16];
00140     BitBuffer_t cmdBuf;
00141     osd_raw_cmd_t osd_cmd;
00142 
00143     BitBuffer_Init(&cmdBuf, cmdData, sizeof(cmdData));
00144     memset(&osd_cmd, 0, sizeof(osd_raw_cmd_t));
00145     osd_cmd.cmd_data = cmdData;
00146     HdffCmdBuildHeader(&cmdBuf, HDFF_MSG_TYPE_COMMAND,
00147                        HDFF_MSG_GROUP_AV_DECODER,
00148                        HDFF_MSG_AV_SET_VIDEO_WINDOW);
00149     BitBuffer_SetBits(&cmdBuf, 4, DecoderIndex);
00150     BitBuffer_SetBits(&cmdBuf, 3, 0); // reserved
00151     if (Enable)
00152         BitBuffer_SetBits(&cmdBuf, 1, 1);
00153     else
00154         BitBuffer_SetBits(&cmdBuf, 1, 0);
00155     BitBuffer_SetBits(&cmdBuf, 16, X);
00156     BitBuffer_SetBits(&cmdBuf, 16, Y);
00157     BitBuffer_SetBits(&cmdBuf, 16, Width);
00158     BitBuffer_SetBits(&cmdBuf, 16, Height);
00159     osd_cmd.cmd_len = HdffCmdSetLength(&cmdBuf);
00160     return ioctl(OsdDevice, OSD_RAW_CMD, &osd_cmd);
00161 }
00162 
00163 int HdffCmdAvShowStillImage(int OsdDevice, uint8_t DecoderIndex,
00164                             const uint8_t * StillImage, int Size,
00165                             HdffVideoStreamType_t StreamType)
00166 {
00167     uint8_t cmdData[16];
00168     BitBuffer_t cmdBuf;
00169     osd_raw_cmd_t osd_cmd;
00170     osd_raw_data_t osd_data;
00171     int err;
00172 
00173     memset(&osd_data, 0, sizeof(osd_raw_data_t));
00174     osd_data.data_buffer = StillImage;
00175     osd_data.data_length = Size;
00176     err = ioctl(OsdDevice, OSD_RAW_DATA, &osd_data);
00177     if (err != 0)
00178         return err;
00179 
00180     BitBuffer_Init(&cmdBuf, cmdData, sizeof(cmdData));
00181     memset(&osd_cmd, 0, sizeof(osd_raw_cmd_t));
00182     osd_cmd.cmd_data = cmdData;
00183     HdffCmdBuildHeader(&cmdBuf, HDFF_MSG_TYPE_COMMAND,
00184                        HDFF_MSG_GROUP_AV_DECODER,
00185                        HDFF_MSG_AV_SHOW_STILL_IMAGE);
00186     BitBuffer_SetBits(&cmdBuf, 4, DecoderIndex);
00187     BitBuffer_SetBits(&cmdBuf, 4, StreamType);
00188     BitBuffer_SetBits(&cmdBuf, 16, osd_data.data_handle);
00189     osd_cmd.cmd_len = HdffCmdSetLength(&cmdBuf);
00190     return ioctl(OsdDevice, OSD_RAW_CMD, &osd_cmd);
00191 }
00192 
00193 int HdffCmdAvSetDecoderInput(int OsdDevice, uint8_t DecoderIndex,
00194                              uint8_t DemultiplexerIndex)
00195 {
00196     uint8_t cmdData[16];
00197     BitBuffer_t cmdBuf;
00198     osd_raw_cmd_t osd_cmd;
00199 
00200     BitBuffer_Init(&cmdBuf, cmdData, sizeof(cmdData));
00201     memset(&osd_cmd, 0, sizeof(osd_raw_cmd_t));
00202     osd_cmd.cmd_data = cmdData;
00203     HdffCmdBuildHeader(&cmdBuf, HDFF_MSG_TYPE_COMMAND,
00204                        HDFF_MSG_GROUP_AV_DECODER,
00205                        HDFF_MSG_AV_SET_DECODER_INPUT);
00206     BitBuffer_SetBits(&cmdBuf, 4, DecoderIndex);
00207     BitBuffer_SetBits(&cmdBuf, 4, DemultiplexerIndex);
00208     osd_cmd.cmd_len = HdffCmdSetLength(&cmdBuf);
00209     return ioctl(OsdDevice, OSD_RAW_CMD, &osd_cmd);
00210 }
00211 
00212 int HdffCmdAvSetDemultiplexerInput(int OsdDevice, uint8_t DemultiplexerIndex,
00213                                    uint8_t TsInputIndex)
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,
00223                        HDFF_MSG_GROUP_AV_DECODER,
00224                        HDFF_MSG_AV_SET_DEMULTIPLEXER_INPUT);
00225     BitBuffer_SetBits(&cmdBuf, 4, DemultiplexerIndex);
00226     BitBuffer_SetBits(&cmdBuf, 4, TsInputIndex);
00227     osd_cmd.cmd_len = HdffCmdSetLength(&cmdBuf);
00228     return ioctl(OsdDevice, OSD_RAW_CMD, &osd_cmd);
00229 }
00230 
00231 int HdffCmdAvSetVideoFormat(int OsdDevice, uint8_t DecoderIndex,
00232                             const HdffVideoFormat_t * VideoFormat)
00233 {
00234     uint8_t cmdData[16];
00235     BitBuffer_t cmdBuf;
00236     osd_raw_cmd_t osd_cmd;
00237 
00238     BitBuffer_Init(&cmdBuf, cmdData, sizeof(cmdData));
00239     memset(&osd_cmd, 0, sizeof(osd_raw_cmd_t));
00240     osd_cmd.cmd_data = cmdData;
00241     HdffCmdBuildHeader(&cmdBuf, HDFF_MSG_TYPE_COMMAND,
00242                        HDFF_MSG_GROUP_AV_DECODER,
00243                        HDFF_MSG_AV_SET_VIDEO_FORMAT);
00244     BitBuffer_SetBits(&cmdBuf, 4, DecoderIndex);
00245     BitBuffer_SetBits(&cmdBuf, 1, VideoFormat->AutomaticEnabled ? 1 : 0);
00246     BitBuffer_SetBits(&cmdBuf, 1, VideoFormat->AfdEnabled ? 1 : 0);
00247     BitBuffer_SetBits(&cmdBuf, 2, VideoFormat->TvFormat);
00248     BitBuffer_SetBits(&cmdBuf, 8, VideoFormat->VideoConversion);
00249     osd_cmd.cmd_len = HdffCmdSetLength(&cmdBuf);
00250     return ioctl(OsdDevice, OSD_RAW_CMD, &osd_cmd);
00251 }
00252 
00253 int HdffCmdAvSetVideoOutputMode(int OsdDevice, uint8_t DecoderIndex,
00254                                 HdffVideoOutputMode_t OutputMode)
00255 {
00256     uint8_t cmdData[16];
00257     BitBuffer_t cmdBuf;
00258     osd_raw_cmd_t osd_cmd;
00259 
00260     BitBuffer_Init(&cmdBuf, cmdData, sizeof(cmdData));
00261     memset(&osd_cmd, 0, sizeof(osd_raw_cmd_t));
00262     osd_cmd.cmd_data = cmdData;
00263     HdffCmdBuildHeader(&cmdBuf, HDFF_MSG_TYPE_COMMAND,
00264                        HDFF_MSG_GROUP_AV_DECODER,
00265                        HDFF_MSG_AV_SET_VIDEO_OUTPUT_MODE);
00266     BitBuffer_SetBits(&cmdBuf, 8, OutputMode);
00267     osd_cmd.cmd_len = HdffCmdSetLength(&cmdBuf);
00268     return ioctl(OsdDevice, OSD_RAW_CMD, &osd_cmd);
00269 }
00270 
00271 int HdffCmdAvSetStc(int OsdDevice, uint8_t DecoderIndex, uint64_t Stc)
00272 {
00273     uint8_t cmdData[16];
00274     BitBuffer_t cmdBuf;
00275     osd_raw_cmd_t osd_cmd;
00276 
00277     BitBuffer_Init(&cmdBuf, cmdData, sizeof(cmdData));
00278     memset(&osd_cmd, 0, sizeof(osd_raw_cmd_t));
00279     osd_cmd.cmd_data = cmdData;
00280     HdffCmdBuildHeader(&cmdBuf, HDFF_MSG_TYPE_COMMAND,
00281                        HDFF_MSG_GROUP_AV_DECODER,
00282                        HDFF_MSG_AV_SET_STC);
00283     BitBuffer_SetBits(&cmdBuf, 4, DecoderIndex);
00284     BitBuffer_SetBits(&cmdBuf, 3, 0); // reserved
00285     BitBuffer_SetBits(&cmdBuf, 1, (uint32_t) (Stc >> 32));
00286     BitBuffer_SetBits(&cmdBuf, 32, (uint32_t) Stc);
00287     osd_cmd.cmd_len = HdffCmdSetLength(&cmdBuf);
00288     return ioctl(OsdDevice, OSD_RAW_CMD, &osd_cmd);
00289 }
00290 
00291 int HdffCmdAvFlushBuffer(int OsdDevice, uint8_t DecoderIndex, int FlushAudio,
00292                          int FlushVideo)
00293 {
00294     uint8_t cmdData[16];
00295     BitBuffer_t cmdBuf;
00296     osd_raw_cmd_t osd_cmd;
00297 
00298     BitBuffer_Init(&cmdBuf, cmdData, sizeof(cmdData));
00299     memset(&osd_cmd, 0, sizeof(osd_raw_cmd_t));
00300     osd_cmd.cmd_data = cmdData;
00301     HdffCmdBuildHeader(&cmdBuf, HDFF_MSG_TYPE_COMMAND,
00302                        HDFF_MSG_GROUP_AV_DECODER,
00303                        HDFF_MSG_AV_FLUSH_BUFFER);
00304     BitBuffer_SetBits(&cmdBuf, 4, DecoderIndex);
00305     if (FlushAudio)
00306     {
00307         BitBuffer_SetBits(&cmdBuf, 1, 1);
00308     }
00309     else
00310     {
00311         BitBuffer_SetBits(&cmdBuf, 1, 0);
00312     }
00313     if (FlushVideo)
00314     {
00315         BitBuffer_SetBits(&cmdBuf, 1, 1);
00316     }
00317     else
00318     {
00319         BitBuffer_SetBits(&cmdBuf, 1, 0);
00320     }
00321     osd_cmd.cmd_len = HdffCmdSetLength(&cmdBuf);
00322     return ioctl(OsdDevice, OSD_RAW_CMD, &osd_cmd);
00323 }
00324 
00325 int HdffCmdAvEnableSync(int OsdDevice, uint8_t DecoderIndex, int SyncAudio,
00326                         int SyncVideo)
00327 {
00328     uint8_t cmdData[16];
00329     BitBuffer_t cmdBuf;
00330     osd_raw_cmd_t osd_cmd;
00331 
00332     BitBuffer_Init(&cmdBuf, cmdData, sizeof(cmdData));
00333     memset(&osd_cmd, 0, sizeof(osd_raw_cmd_t));
00334     osd_cmd.cmd_data = cmdData;
00335     HdffCmdBuildHeader(&cmdBuf, HDFF_MSG_TYPE_COMMAND,
00336                        HDFF_MSG_GROUP_AV_DECODER,
00337                        HDFF_MSG_AV_ENABLE_SYNC);
00338     BitBuffer_SetBits(&cmdBuf, 4, DecoderIndex);
00339     BitBuffer_SetBits(&cmdBuf, 1, SyncAudio ? 1 : 0);
00340     BitBuffer_SetBits(&cmdBuf, 1, SyncVideo ? 1 : 0);
00341     osd_cmd.cmd_len = HdffCmdSetLength(&cmdBuf);
00342     return ioctl(OsdDevice, OSD_RAW_CMD, &osd_cmd);
00343 }
00344 
00345 int HdffCmdAvSetVideoSpeed(int OsdDevice, uint8_t DecoderIndex, int32_t Speed)
00346 {
00347     uint8_t cmdData[16];
00348     BitBuffer_t cmdBuf;
00349     osd_raw_cmd_t osd_cmd;
00350 
00351     BitBuffer_Init(&cmdBuf, cmdData, sizeof(cmdData));
00352     memset(&osd_cmd, 0, sizeof(osd_raw_cmd_t));
00353     osd_cmd.cmd_data = cmdData;
00354     HdffCmdBuildHeader(&cmdBuf, HDFF_MSG_TYPE_COMMAND,
00355                        HDFF_MSG_GROUP_AV_DECODER,
00356                        HDFF_MSG_AV_SET_VIDEO_SPEED);
00357     BitBuffer_SetBits(&cmdBuf, 4, DecoderIndex);
00358     BitBuffer_SetBits(&cmdBuf, 4, 0);
00359     BitBuffer_SetBits(&cmdBuf, 32, Speed);
00360     osd_cmd.cmd_len = HdffCmdSetLength(&cmdBuf);
00361     return ioctl(OsdDevice, OSD_RAW_CMD, &osd_cmd);
00362 }
00363 
00364 int HdffCmdAvSetAudioSpeed(int OsdDevice, uint8_t DecoderIndex, int32_t Speed)
00365 {
00366     uint8_t cmdData[16];
00367     BitBuffer_t cmdBuf;
00368     osd_raw_cmd_t osd_cmd;
00369 
00370     BitBuffer_Init(&cmdBuf, cmdData, sizeof(cmdData));
00371     memset(&osd_cmd, 0, sizeof(osd_raw_cmd_t));
00372     osd_cmd.cmd_data = cmdData;
00373     HdffCmdBuildHeader(&cmdBuf, HDFF_MSG_TYPE_COMMAND,
00374                        HDFF_MSG_GROUP_AV_DECODER,
00375                        HDFF_MSG_AV_SET_AUDIO_SPEED);
00376     BitBuffer_SetBits(&cmdBuf, 4, DecoderIndex);
00377     BitBuffer_SetBits(&cmdBuf, 4, 0);
00378     BitBuffer_SetBits(&cmdBuf, 32, Speed);
00379     osd_cmd.cmd_len = HdffCmdSetLength(&cmdBuf);
00380     return ioctl(OsdDevice, OSD_RAW_CMD, &osd_cmd);
00381 }
00382 
00383 int HdffCmdAvEnableVideoAfterStop(int OsdDevice, uint8_t DecoderIndex,
00384                                   int EnableVideoAfterStop)
00385 {
00386     uint8_t cmdData[16];
00387     BitBuffer_t cmdBuf;
00388     osd_raw_cmd_t osd_cmd;
00389 
00390     BitBuffer_Init(&cmdBuf, cmdData, sizeof(cmdData));
00391     memset(&osd_cmd, 0, sizeof(osd_raw_cmd_t));
00392     osd_cmd.cmd_data = cmdData;
00393     HdffCmdBuildHeader(&cmdBuf, HDFF_MSG_TYPE_COMMAND,
00394                        HDFF_MSG_GROUP_AV_DECODER,
00395                        HDFF_MSG_AV_ENABLE_VIDEO_AFTER_STOP);
00396     BitBuffer_SetBits(&cmdBuf, 4, DecoderIndex);
00397     BitBuffer_SetBits(&cmdBuf, 1, EnableVideoAfterStop ? 1 : 0);
00398     osd_cmd.cmd_len = HdffCmdSetLength(&cmdBuf);
00399     return ioctl(OsdDevice, OSD_RAW_CMD, &osd_cmd);
00400 }
00401 
00402 int HdffCmdAvSetAudioDelay(int OsdDevice, int16_t Delay)
00403 {
00404     uint8_t cmdData[16];
00405     BitBuffer_t cmdBuf;
00406     osd_raw_cmd_t osd_cmd;
00407 
00408     BitBuffer_Init(&cmdBuf, cmdData, sizeof(cmdData));
00409     memset(&osd_cmd, 0, sizeof(osd_raw_cmd_t));
00410     osd_cmd.cmd_data = cmdData;
00411     HdffCmdBuildHeader(&cmdBuf, HDFF_MSG_TYPE_COMMAND,
00412                        HDFF_MSG_GROUP_AV_DECODER,
00413                        HDFF_MSG_AV_SET_AUDIO_DELAY);
00414     BitBuffer_SetBits(&cmdBuf, 16, Delay);
00415     osd_cmd.cmd_len = HdffCmdSetLength(&cmdBuf);
00416     return ioctl(OsdDevice, OSD_RAW_CMD, &osd_cmd);
00417 }
00418 
00419 int HdffCmdAvSetAudioDownmix(int OsdDevice, HdffAudioDownmixMode_t DownmixMode)
00420 {
00421     uint8_t cmdData[16];
00422     BitBuffer_t cmdBuf;
00423     osd_raw_cmd_t osd_cmd;
00424 
00425     BitBuffer_Init(&cmdBuf, cmdData, sizeof(cmdData));
00426     memset(&osd_cmd, 0, sizeof(osd_raw_cmd_t));
00427     osd_cmd.cmd_data = cmdData;
00428     HdffCmdBuildHeader(&cmdBuf, HDFF_MSG_TYPE_COMMAND,
00429                        HDFF_MSG_GROUP_AV_DECODER,
00430                        HDFF_MSG_AV_SET_AUDIO_DOWNMIX);
00431     BitBuffer_SetBits(&cmdBuf, 8, DownmixMode);
00432     osd_cmd.cmd_len = HdffCmdSetLength(&cmdBuf);
00433     return ioctl(OsdDevice, OSD_RAW_CMD, &osd_cmd);
00434 }
00435 
00436 int HdffCmdAvSetAudioChannel(int OsdDevice, uint8_t AudioChannel)
00437 {
00438     uint8_t cmdData[16];
00439     BitBuffer_t cmdBuf;
00440     osd_raw_cmd_t osd_cmd;
00441 
00442     BitBuffer_Init(&cmdBuf, cmdData, sizeof(cmdData));
00443     memset(&osd_cmd, 0, sizeof(osd_raw_cmd_t));
00444     osd_cmd.cmd_data = cmdData;
00445     HdffCmdBuildHeader(&cmdBuf, HDFF_MSG_TYPE_COMMAND,
00446                        HDFF_MSG_GROUP_AV_DECODER,
00447                        HDFF_MSG_AV_SET_AUDIO_CHANNEL);
00448     BitBuffer_SetBits(&cmdBuf, 8, AudioChannel);
00449     osd_cmd.cmd_len = HdffCmdSetLength(&cmdBuf);
00450     return ioctl(OsdDevice, OSD_RAW_CMD, &osd_cmd);
00451 }