stbhwav.h

Go to the documentation of this file.

/*******************************************************************************
 * Copyright © 2014 The DTVKit Open Software Foundation Ltd (www.dtvkit.org)
 * Copyright © 2004 Ocean Blue Software Ltd
 *
 * This file is part of a DTVKit Software Component
 * You are permitted to copy, modify or distribute this file subject to the terms
 * of the DTVKit 1.0 Licence which can be found in licence.txt or at www.dtvkit.org
 *
 * THIS CODE AND INFORMATION ARE PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND,
 * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE.
 *
 * If you or your organisation is not a member of DTVKit then you have access
 * to this source code outside of the terms of the licence agreement
 * and you are expected to delete this and any associated files immediately.
 * Further information on DTVKit, membership and terms can be found at www.dtvkit.org
 *******************************************************************************/
// pre-processor mechanism so multiple inclusions don't cause compilation error

#ifndef _STBHWAV_H
#define _STBHWAV_H

#include "techtype.h"
#include "stbhwc.h"
#include "osdtype.h"

//---Constant and macro definitions for public use-----------------------------

//---Enumerations for public use-----------------------------------------------

typedef enum e_stb_av_audio_mode
{
   AV_AUDIO_STEREO = 0,
   AV_AUDIO_LEFT = 1,
   AV_AUDIO_RIGHT = 2,
   AV_AUDIO_MONO = 3,
   AV_AUDIO_MULTICHANNEL = 4
} E_STB_AV_AUDIO_MODE;

typedef enum e_stb_av_decode_source
{
   AV_DEMUX = 0,
   AV_MEMORY = 1
} E_STB_AV_DECODE_SOURCE;

typedef enum e_stb_av_video_codec
{
   AV_VIDEO_CODEC_AUTO = 0,
   AV_VIDEO_CODEC_MPEG1 = 1,
   AV_VIDEO_CODEC_MPEG2 = 2,
   AV_VIDEO_CODEC_H264 = 3,
   AV_VIDEO_CODEC_H265 = 4,
   AV_VIDEO_CODEC_AVS = 5,
} E_STB_AV_VIDEO_CODEC;

typedef enum e_stb_av_audio_codec
{
   AV_AUDIO_CODEC_AUTO = 0,
   AV_AUDIO_CODEC_MP2 = 1,
   AV_AUDIO_CODEC_MP3 = 2,
   AV_AUDIO_CODEC_AC3 = 3,
   AV_AUDIO_CODEC_EAC3 = 4,
   AV_AUDIO_CODEC_AAC = 5,
   AV_AUDIO_CODEC_HEAAC = 6,
   AV_AUDIO_CODEC_AAC_ADTS = 7
} E_STB_AV_AUDIO_CODEC;

typedef E_ASPECT_RATIO E_STB_AV_ASPECT_RATIO;

typedef enum e_stb_av_video_format
{
   VIDEO_FORMAT_UNDEFINED = 255,
   VIDEO_FORMAT_AUTO = 0,
   VIDEO_FORMAT_ORIGINAL,
   VIDEO_FORMAT_PALBGH,
   VIDEO_FORMAT_PALDKL,
   VIDEO_FORMAT_PALI,
   VIDEO_FORMAT_PALM,
   VIDEO_FORMAT_PALN,
   VIDEO_FORMAT_NTSC,
   VIDEO_FORMAT_SECAMBGH,
   VIDEO_FORMAT_SECAMDKL,
   VIDEO_FORMAT_576IHD,
   VIDEO_FORMAT_576PHD,
   VIDEO_FORMAT_720HD,     /* HD Format, 1280x720  progressive, 50 fps */
   VIDEO_FORMAT_720P50HD = VIDEO_FORMAT_720HD,
   VIDEO_FORMAT_720P60HD,
   VIDEO_FORMAT_1080IHD,   /* HD Format, 1920x1080 interlaced, 25 fps */
   VIDEO_FORMAT_1080P25HD, /* HD Format, 1920x1080 progressive, 25 fps */
   VIDEO_FORMAT_1080P30HD, /* HD Format, 1920x1080 progressive, 30 fps */
   VIDEO_FORMAT_1080I50HD, /* HD Format, 1920x1080 interlaced,  50 fps */
   VIDEO_FORMAT_1080P50HD, /* HD Format, 1920x1080 progressive, 50 fps */
   VIDEO_FORMAT_1080P60HD, /* HD Format, 1920x1080 progressive, 60 fps */
   VIDEO_FORMAT_2160P24UHD,
   VIDEO_FORMAT_2160P25UHD,
   VIDEO_FORMAT_2160P30UHD,
   VIDEO_FORMAT_2160P50UHD,
   VIDEO_FORMAT_2160P60UHD,
} E_STB_AV_VIDEO_FORMAT;

typedef enum e_stb_av_outputs
{
   AV_OUTPUT_TV_SCART = 0,
   AV_OUTPUT_VCR_SCART = 1,
   AV_OUTPUT_AUX_SCART = 2,
   AV_OUTPUT_HDMI = 3
} E_STB_AV_OUTPUTS;

typedef enum e_stb_av_sources
{
   AV_SOURCE_ENCODER_SVIDEO = 0,
   AV_SOURCE_ENCODER_RGB = 1,
   AV_SOURCE_ENCODER_COMPOSITE = 2,
   AV_SOURCE_VCR_SVIDEO = 3,
   AV_SOURCE_VCR_RGB = 4,
   AV_SOURCE_VCR_COMPOSITE = 5,
   AV_SOURCE_AUX_SVIDEO = 6,
   AV_SOURCE_AUX_RGB = 7,
   AV_SOURCE_AUX_COMPOSITE = 8,
   AV_SOURCE_DVD_SVIDEO = 9,
   AV_SOURCE_DVD_RGB = 10,
   AV_SOURCE_DVD_COMPOSITE = 11,
   AV_SOURCE_ANALOG_TUNER = 12,
   AV_SOURCE_ANALOG_TUNER_WITH_OSD = 13,
   AV_SOURCE_HDMI = 14,
   AV_SOURCE_CVBS = 15,
   AV_SOURCE_TUNER = 16,
   AV_SOURCE_NONE = 255
} E_STB_AV_SOURCES;

typedef enum e_stb_av_srm_reply
{
   SRM_OK = 0,
   SRM_BUSY = 1,
   SRM_NOT_REQUIRED = 2
} E_STB_AV_SRM_REPLY;

typedef enum
{
   VIDEO_INFO_VIDEO_RESOLUTION = 0x01,
   VIDEO_INFO_SCREEN_RESOLUTION = 0x02,
   VIDEO_INFO_VIDEO_ASPECT_RATIO = 0x04,
   VIDEO_INFO_DISPLAY_ASPECT_RATIO = 0x08,
   VIDEO_INFO_ASPECT_MODE = 0x10,
   VIDEO_INFO_AFD = 0x20,
   VIDEO_INFO_DECODER_STATUS = 0x40
} E_STB_AV_VIDEO_INFO_TYPE;

typedef enum
{
   DECODER_STATUS_NONE,
   DECODER_STATUS_VIDEO,
   DECODER_STATUS_IFRAME
} E_STB_AV_DECODER_STATUS;

typedef enum
{
   DIGITAL_AUDIO_PCM,
   DIGITAL_AUDIO_COMPRESSED,
   DIGITAL_AUDIO_AUTO
} E_STB_DIGITAL_AUDIO_TYPE;

typedef enum e_stb_av_audio_route
{
   SPEAKER_TV_N_AD_HEADPHONE_TV_N_AD,
   SPEAKER_TV_ONLY_HEADPHONE_AD_ONLY,
   SPEAKER_TV_N_AD_HEADPHONE_AD_ONLY,
   SPEAKER_TV_ONLY_HEADPHONE_TV_N_AD,
   AUTO_ROUTE_UNKNOWN,
} E_STB_AV_AUDIO_ROUTE;


//---Global type defs for public use-------------------------------------------

typedef struct
{
   BOOLEAN macrovision_set;
   U8BIT macrovision;

   BOOLEAN aps_set;
   U8BIT aps;

   BOOLEAN cgms_a_set;
   U8BIT cgms_a;

   BOOLEAN ict_set;
   U8BIT ict;

   BOOLEAN hdcp_set;
   BOOLEAN hdcp;

   BOOLEAN scms_set;
   U8BIT scms;

   BOOLEAN dot_set;
   U8BIT dot;
} S_STB_AV_COPY_PROTECTION;

typedef struct
{
   E_STB_AV_VIDEO_INFO_TYPE flags;
   U16BIT video_width;
   U16BIT video_height;
   U16BIT screen_width;
   U16BIT screen_height;
   E_STB_AV_ASPECT_RATIO video_aspect_ratio;
   E_STB_AV_ASPECT_RATIO display_aspect_ratio;
   U8BIT afd;
   E_STB_AV_DECODER_STATUS status;
} S_STB_AV_VIDEO_INFO;

typedef void (*CC_DATA_CALLBACK)(U8BIT path, void* context, U8BIT* data, U16BIT data_len);


//---Global Function prototypes for public use---------------------------------

void STB_AVInitialise(U8BIT audio_paths, U8BIT video_paths);

void STB_AVBlankVideo(U8BIT path, BOOLEAN blank);

void STB_AVSetVideoSource(U8BIT path, E_STB_AV_DECODE_SOURCE source, U32BIT param);

BOOLEAN STB_AVSetVideoCodec(U8BIT path, E_STB_AV_VIDEO_CODEC codec);

E_STB_AV_VIDEO_CODEC STB_AVGetVideoCodec(U8BIT path);

void STB_AVStartVideoDecoding(U8BIT path);

void STB_AVPauseVideoDecoding(U8BIT path);

void STB_AVResumeVideoDecoding(U8BIT path);

void STB_AVStopVideoDecoding(U8BIT decoder);

void STB_AVSetAudioSource(U8BIT path, E_STB_AV_DECODE_SOURCE source, U32BIT param);

BOOLEAN STB_AVSetAudioCodec(U8BIT path, E_STB_AV_AUDIO_CODEC codec);

E_STB_AV_AUDIO_CODEC STB_AVGetAudioCodec(U8BIT path);

void STB_AVChangeAudioMode(U8BIT path, E_STB_AV_AUDIO_MODE mode);

void STB_AVStartAudioDecoding(U8BIT decoder);

void STB_AVStopAudioDecoding(U8BIT decoder);

void STB_AVSetAudioVolume(U8BIT path, U8BIT vol);

U8BIT STB_AVGetAudioVolume(U8BIT path);

void STB_AVSetAudioMute(U8BIT path, BOOLEAN mute);

BOOLEAN STB_AVGetAudioMute(U8BIT path);

void STB_AVSetADSource(U8BIT path, E_STB_AV_DECODE_SOURCE source, U32BIT param);

BOOLEAN STB_AVSetADCodec(U8BIT path, E_STB_AV_AUDIO_CODEC codec);

E_STB_AV_AUDIO_CODEC STB_AVGetADCodec(U8BIT path);

void STB_AVChangeADMode(U8BIT path, E_STB_AV_AUDIO_MODE mode);

void STB_AVStartADDecoding(U8BIT decoder);

void STB_AVStopADDecoding(U8BIT decoder);

void STB_AVSetADVolume(U8BIT path, U8BIT vol);

U8BIT STB_AVGetADVolume(U8BIT path);

void STB_AVGetSTC(U8BIT path, U8BIT stc[5]);

void STB_AVSetTVType(U8BIT path, E_STB_AV_ASPECT_RATIO ratio, E_STB_AV_VIDEO_FORMAT format);

void STB_AVGetScreenSize(U8BIT path, U16BIT *width, U16BIT *height);

void STB_AVSetAVOutputSource(E_STB_AV_OUTPUTS output, E_STB_AV_SOURCES source, U32BIT param);

void STB_AVSetAVOutput(BOOLEAN av_on);

void STB_AVSetHDMIStandby(BOOLEAN standby);

U8BIT STB_AVGetHDMISupportedModes(E_STB_AV_VIDEO_FORMAT **modes);

void STB_AVGetHDMINativeResolution(U16BIT *width, U16BIT *height);

void STB_AVEnableHDMIDecoding(void);

void STB_AVDisableHDMIDecoding(void);

BOOLEAN STB_AVIsHDCPAuthenticated(void);

BOOLEAN STB_AVSetIFrameCodec(U8BIT path, E_STB_AV_VIDEO_CODEC codec);

void STB_AVLoadIFrame(U8BIT path, U8BIT *data, U32BIT size);

void STB_AVShowIFrame(U8BIT path);

void STB_AVHideIFrame(U8BIT path);

E_HW_STATUS STB_AVPlayAudioSample(U8BIT path, U32BIT loop_count);

E_HW_STATUS STB_AVLoadAudioSample(U8BIT path, U8BIT *data, U32BIT size);

E_HW_STATUS STB_AVPauseAudioSample(U8BIT path);

E_HW_STATUS STB_AVResumeAudioSample(U8BIT path);

void STB_AVStopAudioSample(U8BIT path);

void STB_AVSetSpdifMode(U8BIT path, E_STB_DIGITAL_AUDIO_TYPE audio_type);

void STB_AVSetHDMIAudioMode(U8BIT path, E_STB_DIGITAL_AUDIO_TYPE audio_type);

void STB_AVSetAudioDelay(U8BIT path, U16BIT millisecond);

void STB_AVSetVideoCallback(U8BIT path, void (*callback)(S_STB_AV_VIDEO_INFO *, void *), void *user_data);

void STB_AVApplyVideoTransformation(U8BIT path, S_RECTANGLE *input, S_RECTANGLE *output);

S16BIT STB_AVGetMinPlaySpeed(U8BIT video_decoder);

S16BIT STB_AVGetMaxPlaySpeed(U8BIT video_decoder);

S16BIT STB_AVGetNextPlaySpeed(U8BIT video_decoder, S16BIT speed, S16BIT inc,
   BOOLEAN include_slow_speeds);

void STB_AVSetCopyProtection(S_STB_AV_COPY_PROTECTION *copy_protection);

void STB_AVSetUhfModulatorChannel(U8BIT chan);

U8BIT STB_AVGetUhfModulatorChannel(void);

U8BIT STB_AVGetVideoFrameRate(U8BIT path);

E_STB_AV_SRM_REPLY STB_AVApplySRM(U8BIT path, U8BIT *data, U32BIT len);

void STB_AVCECOneTouchPlay(void);
E_STB_AV_VIDEO_FORMAT STB_AVGetHDMINativeFormat(void);
void STB_AVPlayMp3(U8BIT path, U8BIT *buffer, U32BIT buffer_size);
void STB_AVStopMp3(U8BIT path);

void STB_AVRegisterCcCallback(U8BIT path, void* context, CC_DATA_CALLBACK callback);

#endif //  _STBHWAV_H