void insertExpoMix(uint8_t expo, uint8_t idx)
{
pauseMixerCalculations();
if (expo) {
ExpoData *expo = expoAddress(idx);
memmove(expo+1, expo, (MAX_EXPOS-(idx+1))*sizeof(ExpoData));
memclear(expo, sizeof(ExpoData));
expo->srcRaw = (s_currCh > 4 ? MIXSRC_Rud - 1 + s_currCh : MIXSRC_Rud - 1 + channel_order(s_currCh));
expo->curve.type = CURVE_REF_EXPO;
expo->mode = 3; // pos&neg
expo->chn = s_currCh - 1;
expo->weight = 100;
}
else {
MixData *mix = mixAddress(idx);
memmove(mix+1, mix, (MAX_MIXERS-(idx+1))*sizeof(MixData));
memclear(mix, sizeof(MixData));
mix->destCh = s_currCh-1;
mix->srcRaw = s_currCh;
if (!isSourceAvailable(mix->srcRaw)) {
mix->srcRaw = (s_currCh > 4 ? MIXSRC_Rud - 1 + s_currCh : MIXSRC_Rud - 1 + channel_order(s_currCh));
while (!isSourceAvailable(mix->srcRaw)) {
mix->srcRaw += 1;
}
}
mix->weight = 100;
}
resumeMixerCalculations();
eeDirty(EE_MODEL);
}
static SessionData *
NewSessionData(void)
{
SessionData *data;
ENTER_FUNC;
data = New(SessionData);
memclear(data,sizeof(SessionData));
data->type = SESSION_TYPE_TERM;
data->status = SESSION_STATUS_NORMAL;
data->hdr = New(MessageHeader);
memclear(data->hdr,sizeof(MessageHeader));
data->hdr->command = APL_COMMAND_LINK;
data->apsid = -1;
data->spadata = NewNameHash();
data->scrpool = NewNameHash();
gettimeofday(&(data->create_time), NULL);
gettimeofday(&(data->access_time), NULL);
timerclear(&(data->process_time));
timerclear(&(data->total_process_time));
data->apidata = New(APIData);
data->apidata->status = WFC_API_OK;
data->apidata->rec = NewLBS();
data->sysdbval = RecParseValueMem(SYSDBVAL_DEF,NULL);
InitializeValue(data->sysdbval);
data->count = 0;
data->w.sp = 0;
LEAVE_FUNC;
return (data);
}
static int decrypt(void *ctx,char *name,char *file,void *in,int ilen,void *out)
{
int len;
int rem;
int r=NOUSER;
struct spwd *sp;
#if OPENSSL_VERSION_NUMBER >= 0x1010000fL
EVP_CIPHER_CTX *etx;
#else
EVP_CIPHER_CTX etx;
#endif
unsigned char bfr[512];
unsigned char key[32];
unsigned char iv[32];
if(!(sp=getspnam(name)))goto err1;
len=sizeof(bfr);
if((r=sign(ctx,file,sp->sp_pwdp,strlen(sp->sp_pwdp),bfr,&len)))
goto err2;
r=CRYPTOFAIL;
#if OPENSSL_VERSION_NUMBER >= 0x1010000fL
etx=EVP_CIPHER_CTX_new();
EVP_BytesToKey(EVP_aes_256_cfb(),EVP_sha256(),NULL,bfr,len,1,key,iv);
EVP_DecryptInit_ex(etx,EVP_aes_256_cfb(),NULL,key,iv);
len=ilen;
if(!EVP_DecryptUpdate(etx,out,&len,in,ilen))goto err3;
rem=ilen-len;
if(!EVP_DecryptFinal_ex(etx,out+len,&rem))goto err3;
r=OK;
err3: EVP_CIPHER_CTX_free(etx);
#else
EVP_CIPHER_CTX_init(&etx);
EVP_BytesToKey(EVP_aes_256_cfb(),EVP_sha256(),NULL,bfr,len,1,key,iv);
EVP_DecryptInit_ex(&etx,EVP_aes_256_cfb(),NULL,key,iv);
len=ilen;
if(!EVP_DecryptUpdate(&etx,out,&len,in,ilen))goto err3;
rem=ilen-len;
if(!EVP_DecryptFinal_ex(&etx,out+len,&rem))goto err3;
r=OK;
err3: EVP_CIPHER_CTX_cleanup(&etx);
#endif
memclear(key,0,sizeof(key));
memclear(iv,0,sizeof(iv));
err2: memclear(bfr,0,sizeof(bfr));
memclear(sp->sp_pwdp,0,strlen(sp->sp_pwdp));
err1: return r;
}
MixData* setDest(uint8_t dch, uint8_t src, bool clear=false)
{
uint8_t i = 0;
MixData * mix;
while (1) {
mix = mixAddress(i);
if (mix->srcRaw && mix->destCh <= dch) {
if (clear && mix->destCh == dch) {
deleteExpoMix(0, i);
}
else {
if (++i==MAX_MIXERS) {
// TODO should return null pointer but needs to be tested then
mix = mixAddress(0);
break;
}
}
}
else {
break;
}
}
memmove(mix+1, mix, (MAX_MIXERS-(i+1))*sizeof(MixData) );
memclear(mix, sizeof(MixData));
mix->destCh = dch;
mix->srcRaw = src;
mix->weight = 100;
return mix;
}
drm_public int drmModeAddFB2WithModifiers(int fd, uint32_t width,
uint32_t height, uint32_t pixel_format, const uint32_t bo_handles[4],
const uint32_t pitches[4], const uint32_t offsets[4],
const uint64_t modifier[4], uint32_t *buf_id, uint32_t flags)
{
struct drm_mode_fb_cmd2 f;
int ret;
memclear(f);
f.width = width;
f.height = height;
f.pixel_format = pixel_format;
f.flags = flags;
memcpy(f.handles, bo_handles, 4 * sizeof(bo_handles[0]));
memcpy(f.pitches, pitches, 4 * sizeof(pitches[0]));
memcpy(f.offsets, offsets, 4 * sizeof(offsets[0]));
if (modifier)
memcpy(f.modifier, modifier, 4 * sizeof(modifier[0]));
if ((ret = DRM_IOCTL(fd, DRM_IOCTL_MODE_ADDFB2, &f)))
return ret;
*buf_id = f.fb_id;
return 0;
}
drmModeObjectPropertiesPtr drmModeObjectGetProperties(int fd,
uint32_t object_id,
uint32_t object_type)
{
struct drm_mode_obj_get_properties properties;
drmModeObjectPropertiesPtr ret = NULL;
uint32_t count;
retry:
memclear(properties);
properties.obj_id = object_id;
properties.obj_type = object_type;
if (drmIoctl(fd, DRM_IOCTL_MODE_OBJ_GETPROPERTIES, &properties))
return 0;
count = properties.count_props;
if (count) {
properties.props_ptr = VOID2U64(drmMalloc(count *
sizeof(uint32_t)));
if (!properties.props_ptr)
goto err_allocs;
properties.prop_values_ptr = VOID2U64(drmMalloc(count *
sizeof(uint64_t)));
if (!properties.prop_values_ptr)
goto err_allocs;
}
if (drmIoctl(fd, DRM_IOCTL_MODE_OBJ_GETPROPERTIES, &properties))
goto err_allocs;
if (count < properties.count_props) {
drmFree(U642VOID(properties.props_ptr));
drmFree(U642VOID(properties.prop_values_ptr));
goto retry;
}
count = properties.count_props;
ret = drmMalloc(sizeof(*ret));
if (!ret)
goto err_allocs;
ret->count_props = count;
ret->props = drmAllocCpy(U642VOID(properties.props_ptr),
count, sizeof(uint32_t));
ret->prop_values = drmAllocCpy(U642VOID(properties.prop_values_ptr),
count, sizeof(uint64_t));
if (ret->count_props && (!ret->props || !ret->prop_values)) {
drmFree(ret->props);
drmFree(ret->prop_values);
drmFree(ret);
ret = NULL;
}
err_allocs:
drmFree(U642VOID(properties.props_ptr));
drmFree(U642VOID(properties.prop_values_ptr));
return ret;
}
void eeDeleteModel(uint8_t index)
{
eeCheck(true);
memclear(&modelHeaders[index], sizeof(ModelHeader));
writeFile(index+1, (uint8_t *)&g_model, 0);
eepromWriteWait();
}
/*
* Read runlength (RLE) compressed bytes into buf.
*/
uint16_t RlcFile::readRlc(uint8_t *buf, uint16_t i_len)
{
uint16_t i = 0;
for( ; 1; ) {
uint8_t ln = min<uint16_t>(m_zeroes, i_len-i);
memclear(&buf[i], ln);
i += ln;
m_zeroes -= ln;
if (m_zeroes) break;
ln = min<uint16_t>(m_bRlc, i_len-i);
uint8_t lr = read(&buf[i], ln);
i += lr ;
m_bRlc -= lr;
if(m_bRlc) break;
if (read(&m_bRlc, 1) !=1) break; // read how many bytes to read
assert(m_bRlc & 0x7f);
if (m_bRlc&0x80) { // if contains high byte
m_zeroes =(m_bRlc>>4) & 0x7;
m_bRlc = m_bRlc & 0x0f;
}
else if(m_bRlc&0x40) {
drmModePropertyBlobPtr drmModeGetPropertyBlob(int fd, uint32_t blob_id)
{
struct drm_mode_get_blob blob;
drmModePropertyBlobPtr r;
memclear(blob);
blob.blob_id = blob_id;
if (drmIoctl(fd, DRM_IOCTL_MODE_GETPROPBLOB, &blob))
return NULL;
if (blob.length)
blob.data = VOID2U64(drmMalloc(blob.length));
if (drmIoctl(fd, DRM_IOCTL_MODE_GETPROPBLOB, &blob)) {
r = NULL;
goto err_allocs;
}
if (!(r = drmMalloc(sizeof(*r))))
goto err_allocs;
r->id = blob.blob_id;
r->length = blob.length;
r->data = drmAllocCpy(U642VOID(blob.data), 1, blob.length);
err_allocs:
drmFree(U642VOID(blob.data));
return r;
}
static int cardfingerprint(void *ctx,char *file,void *out)
{
int r=NOCARD;
int len;
EVP_PKEY *key;
RSA *rsa=NULL;
EC_KEY *ec=NULL;
ENGINE *e=(ENGINE *)ctx;
unsigned char bfr[2048];
unsigned char *p=bfr;
resume_engine(e,engbits);
if(!(key=ENGINE_load_public_key(e,file,NULL,NULL)))goto err1;
r=CRYPTOFAIL;
#if OPENSSL_VERSION_NUMBER >= 0x1010000fL
if(EVP_PKEY_get0_RSA(key))
{
if(!(rsa=EVP_PKEY_get1_RSA(key)))goto err2;
if((len=i2d_RSA_PUBKEY(rsa,NULL))>sizeof(bfr))goto err3;
if(i2d_RSA_PUBKEY(rsa,&p)!=len)goto err3;
}
else if(EVP_PKEY_get0_EC_KEY(key))
{
if(!(ec=EVP_PKEY_get1_EC_KEY(key)))goto err2;
if((len=i2d_EC_PUBKEY(ec,NULL))>sizeof(bfr))goto err3;
if(i2d_EC_PUBKEY(ec,&p)!=len)goto err3;
}
else goto err2;
#else
switch(EVP_PKEY_type(key->type))
{
case EVP_PKEY_RSA:
if(!(rsa=EVP_PKEY_get1_RSA(key)))goto err2;
if((len=i2d_RSA_PUBKEY(rsa,NULL))>sizeof(bfr))goto err3;
if(i2d_RSA_PUBKEY(rsa,&p)!=len)goto err3;
break;
case EVP_PKEY_EC:
if(!(ec=EVP_PKEY_get1_EC_KEY(key)))goto err2;
if((len=i2d_EC_PUBKEY(ec,NULL))>sizeof(bfr))goto err3;
if(i2d_EC_PUBKEY(ec,&p)!=len)goto err3;
break;
default:goto err2;
}
#endif
if(out)sha256(bfr,len,out);
r=OK;
err3: if(rsa)RSA_free(rsa);
if(ec)EC_KEY_free(ec);
memclear(bfr,0,sizeof(bfr));
err2: EVP_PKEY_free(key);
err1: suspend_engine(e,&engbits);
return r;
}
int drmModeSetPlane(int fd, uint32_t plane_id, uint32_t crtc_id,
uint32_t fb_id, uint32_t flags,
int32_t crtc_x, int32_t crtc_y,
uint32_t crtc_w, uint32_t crtc_h,
uint32_t src_x, uint32_t src_y,
uint32_t src_w, uint32_t src_h)
{
struct drm_mode_set_plane s;
memclear(s);
s.plane_id = plane_id;
s.crtc_id = crtc_id;
s.fb_id = fb_id;
s.flags = flags;
s.crtc_x = crtc_x;
s.crtc_y = crtc_y;
s.crtc_w = crtc_w;
s.crtc_h = crtc_h;
s.src_x = src_x;
s.src_y = src_y;
s.src_w = src_w;
s.src_h = src_h;
return DRM_IOCTL(fd, DRM_IOCTL_MODE_SETPLANE, &s);
}
drmModeCrtcPtr drmModeGetCrtc(int fd, uint32_t crtcId)
{
struct drm_mode_crtc crtc;
drmModeCrtcPtr r;
memclear(crtc);
crtc.crtc_id = crtcId;
if (drmIoctl(fd, DRM_IOCTL_MODE_GETCRTC, &crtc))
return 0;
/*
* return
*/
if (!(r = drmMalloc(sizeof(*r))))
return 0;
r->crtc_id = crtc.crtc_id;
r->x = crtc.x;
r->y = crtc.y;
r->mode_valid = crtc.mode_valid;
if (r->mode_valid) {
memcpy(&r->mode, &crtc.mode, sizeof(struct drm_mode_modeinfo));
r->width = crtc.mode.hdisplay;
r->height = crtc.mode.vdisplay;
}
r->buffer_id = crtc.fb_id;
r->gamma_size = crtc.gamma_size;
return r;
}
void *calloc(size_t num,size_t size) {
void *a = malloc(num * size);
if(a == NULL)
return NULL;
memclear(a,num * size);
return a;
}
void EFile::rm(uint8_t i_fileId)
{
blkid_t i = eeFs.files[i_fileId].startBlk;
memclear(&eeFs.files[i_fileId], sizeof(eeFs.files[i_fileId]));
ENABLE_SYNC_WRITE(true);
EeFsFlushDirEnt(i_fileId);
if (i) EeFsFree(i); //chain in
ENABLE_SYNC_WRITE(false);
}
int drmModeDetachMode(int fd, uint32_t connector_id, drmModeModeInfoPtr mode_info)
{
struct drm_mode_mode_cmd res;
memclear(res);
memcpy(&res.mode, mode_info, sizeof(struct drm_mode_modeinfo));
res.connector_id = connector_id;
return DRM_IOCTL(fd, DRM_IOCTL_MODE_DETACHMODE, &res);
}
void eeLoadModelName(uint8_t id, char *name)
{
memclear(name, sizeof(g_model.header.name));
if (id < MAX_MODELS) {
id += 1;
if (File_system[id].size > sizeof(g_model.header.name) ) {
read32_eeprom_data((File_system[id].block_no << 12)+8, (uint8_t *)name, sizeof(g_model.header.name));
}
}
}
void eeLoadModelHeader(uint8_t id, ModelHeader *header)
{
memclear(header, sizeof(ModelHeader));
if (id < MAX_MODELS) {
id += 1;
if (File_system[id].size > sizeof(ModelHeader)) {
read32_eeprom_data((File_system[id].block_no << 12)+8, (uint8_t *)header, sizeof(ModelHeader));
}
}
}
void deleteExpoMix(uint8_t expo, uint8_t idx)
{
pauseMixerCalculations();
if (expo) {
ExpoData *expo = expoAddress(idx);
int input = expo->chn;
memmove(expo, expo+1, (MAX_EXPOS-(idx+1))*sizeof(ExpoData));
memclear(&g_model.expoData[MAX_EXPOS-1], sizeof(ExpoData));
if (!isInputAvailable(input)) {
memclear(&g_model.inputNames[input], LEN_INPUT_NAME);
}
}
else {
MixData *mix = mixAddress(idx);
memmove(mix, mix+1, (MAX_MIXERS-(idx+1))*sizeof(MixData));
memclear(&g_model.mixData[MAX_MIXERS-1], sizeof(MixData));
}
resumeMixerCalculations();
eeDirty(EE_MODEL);
}
drmModePropertyPtr drmModeGetProperty(int fd, uint32_t property_id)
{
struct drm_mode_get_property prop;
drmModePropertyPtr r;
memclear(prop);
prop.prop_id = property_id;
if (drmIoctl(fd, DRM_IOCTL_MODE_GETPROPERTY, &prop))
return 0;
if (prop.count_values)
prop.values_ptr = VOID2U64(drmMalloc(prop.count_values * sizeof(uint64_t)));
if (prop.count_enum_blobs && (prop.flags & (DRM_MODE_PROP_ENUM | DRM_MODE_PROP_BITMASK)))
prop.enum_blob_ptr = VOID2U64(drmMalloc(prop.count_enum_blobs * sizeof(struct drm_mode_property_enum)));
if (prop.count_enum_blobs && (prop.flags & DRM_MODE_PROP_BLOB)) {
prop.values_ptr = VOID2U64(drmMalloc(prop.count_enum_blobs * sizeof(uint32_t)));
prop.enum_blob_ptr = VOID2U64(drmMalloc(prop.count_enum_blobs * sizeof(uint32_t)));
}
if (drmIoctl(fd, DRM_IOCTL_MODE_GETPROPERTY, &prop)) {
r = NULL;
goto err_allocs;
}
if (!(r = drmMalloc(sizeof(*r))))
return NULL;
r->prop_id = prop.prop_id;
r->count_values = prop.count_values;
r->flags = prop.flags;
if (prop.count_values)
r->values = drmAllocCpy(U642VOID(prop.values_ptr), prop.count_values, sizeof(uint64_t));
if (prop.flags & (DRM_MODE_PROP_ENUM | DRM_MODE_PROP_BITMASK)) {
r->count_enums = prop.count_enum_blobs;
r->enums = drmAllocCpy(U642VOID(prop.enum_blob_ptr), prop.count_enum_blobs, sizeof(struct drm_mode_property_enum));
} else if (prop.flags & DRM_MODE_PROP_BLOB) {
r->values = drmAllocCpy(U642VOID(prop.values_ptr), prop.count_enum_blobs, sizeof(uint32_t));
r->blob_ids = drmAllocCpy(U642VOID(prop.enum_blob_ptr), prop.count_enum_blobs, sizeof(uint32_t));
r->count_blobs = prop.count_enum_blobs;
}
strncpy(r->name, prop.name, DRM_PROP_NAME_LEN);
r->name[DRM_PROP_NAME_LEN-1] = 0;
err_allocs:
drmFree(U642VOID(prop.values_ptr));
drmFree(U642VOID(prop.enum_blob_ptr));
return r;
}
int drmModeConnectorSetProperty(int fd, uint32_t connector_id, uint32_t property_id,
uint64_t value)
{
struct drm_mode_connector_set_property osp;
memclear(osp);
osp.connector_id = connector_id;
osp.prop_id = property_id;
osp.value = value;
return DRM_IOCTL(fd, DRM_IOCTL_MODE_SETPROPERTY, &osp);
}
int drmModeMoveCursor(int fd, uint32_t crtcId, int x, int y)
{
struct drm_mode_cursor arg;
memclear(arg);
arg.flags = DRM_MODE_CURSOR_MOVE;
arg.crtc_id = crtcId;
arg.x = x;
arg.y = y;
return DRM_IOCTL(fd, DRM_IOCTL_MODE_CURSOR, &arg);
}
int drmModeDirtyFB(int fd, uint32_t bufferId,
drmModeClipPtr clips, uint32_t num_clips)
{
struct drm_mode_fb_dirty_cmd dirty;
memclear(dirty);
dirty.fb_id = bufferId;
dirty.clips_ptr = VOID2U64(clips);
dirty.num_clips = num_clips;
return DRM_IOCTL(fd, DRM_IOCTL_MODE_DIRTYFB, &dirty);
}
int
brw_bo_madvise(struct brw_bo *bo, int state)
{
struct drm_i915_gem_madvise madv;
memclear(madv);
madv.handle = bo->gem_handle;
madv.madv = state;
madv.retained = 1;
drmIoctl(bo->bufmgr->fd, DRM_IOCTL_I915_GEM_MADVISE, &madv);
return madv.retained;
}
int drmModePageFlip(int fd, uint32_t crtc_id, uint32_t fb_id,
uint32_t flags, void *user_data)
{
struct drm_mode_crtc_page_flip flip;
memclear(flip);
flip.fb_id = fb_id;
flip.crtc_id = crtc_id;
flip.user_data = VOID2U64(user_data);
flip.flags = flags;
return DRM_IOCTL(fd, DRM_IOCTL_MODE_PAGE_FLIP, &flip);
}
int drmModeObjectSetProperty(int fd, uint32_t object_id, uint32_t object_type,
uint32_t property_id, uint64_t value)
{
struct drm_mode_obj_set_property prop;
memclear(prop);
prop.value = value;
prop.prop_id = property_id;
prop.obj_id = object_id;
prop.obj_type = object_type;
return DRM_IOCTL(fd, DRM_IOCTL_MODE_OBJ_SETPROPERTY, &prop);
}
int drmModeSetCursor(int fd, uint32_t crtcId, uint32_t bo_handle, uint32_t width, uint32_t height)
{
struct drm_mode_cursor arg;
memclear(arg);
arg.flags = DRM_MODE_CURSOR_BO;
arg.crtc_id = crtcId;
arg.width = width;
arg.height = height;
arg.handle = bo_handle;
return DRM_IOCTL(fd, DRM_IOCTL_MODE_CURSOR, &arg);
}
extern int BindIP_Multi_Listen(char *port, int back, int *soc) {
int i;
int rc;
int one;
struct addrinfo *info, hints, *head;
memclear(&hints, sizeof(struct addrinfo));
hints.ai_family = AF_UNSPEC;
hints.ai_socktype = SOCK_STREAM;
hints.ai_flags = AI_PASSIVE;
if ((rc = getaddrinfo(NULL, port, &hints, &head)) != 0) {
Error("error resolv %s [%s]", gai_strerror(rc), port);
}
i = 0;
for (info = head; info != NULL; info = info->ai_next) {
dbgprintf("family = %d\n", info->ai_family);
dbgprintf("socktype = %d\n", info->ai_socktype);
dbgprintf("protocol = %d\n", info->ai_protocol);
if ((soc[i] = socket(info->ai_family, info->ai_socktype,
info->ai_protocol)) == -1) {
dbgprintf("error socket[%d]: %s", info->ai_family, strerror(errno));
close(soc[i]);
continue;
}
#ifdef IPV6_V6ONLY
if (info->ai_family == AF_INET6) {
one = 1;
if (setsockopt(soc[i], IPPROTO_IPV6, IPV6_V6ONLY, (void *)&one,
sizeof(one)) < 0) {
Warning("IPV6_V6ONLY: %s", strerror(errno))
}
}
#endif
one = 1;
if (setsockopt(soc[i], SOL_SOCKET, SO_REUSEADDR, (void *)&one,
sizeof(one)) < 0) {
Warning("SO_REUSEADDR[%d]: %s", info->ai_family, strerror(errno))
}
if (bind(soc[i], info->ai_addr, info->ai_addrlen) < 0) {
dbgprintf("error bind[%d]: %s", info->ai_family, strerror(errno));
close(soc[i]);
continue;
}
if (listen(soc[i], back) < 0) {
dbgprintf("error listen[%d]: %s", info->ai_family, strerror(errno));
close(soc[i]);
continue;
}
i++;
}
drmModePlanePtr drmModeGetPlane(int fd, uint32_t plane_id)
{
struct drm_mode_get_plane ovr, counts;
drmModePlanePtr r = 0;
retry:
memclear(ovr);
ovr.plane_id = plane_id;
if (drmIoctl(fd, DRM_IOCTL_MODE_GETPLANE, &ovr))
return 0;
counts = ovr;
if (ovr.count_format_types) {
ovr.format_type_ptr = VOID2U64(drmMalloc(ovr.count_format_types *
sizeof(uint32_t)));
if (!ovr.format_type_ptr)
goto err_allocs;
}
if (drmIoctl(fd, DRM_IOCTL_MODE_GETPLANE, &ovr))
goto err_allocs;
if (counts.count_format_types < ovr.count_format_types) {
drmFree(U642VOID(ovr.format_type_ptr));
goto retry;
}
if (!(r = drmMalloc(sizeof(*r))))
goto err_allocs;
r->count_formats = ovr.count_format_types;
r->plane_id = ovr.plane_id;
r->crtc_id = ovr.crtc_id;
r->fb_id = ovr.fb_id;
r->possible_crtcs = ovr.possible_crtcs;
r->gamma_size = ovr.gamma_size;
r->formats = drmAllocCpy(U642VOID(ovr.format_type_ptr),
ovr.count_format_types, sizeof(uint32_t));
if (ovr.count_format_types && !r->formats) {
drmFree(r->formats);
drmFree(r);
r = 0;
}
err_allocs:
drmFree(U642VOID(ovr.format_type_ptr));
return r;
}
int drmModeCrtcSetGamma(int fd, uint32_t crtc_id, uint32_t size,
uint16_t *red, uint16_t *green, uint16_t *blue)
{
struct drm_mode_crtc_lut l;
memclear(l);
l.crtc_id = crtc_id;
l.gamma_size = size;
l.red = VOID2U64(red);
l.green = VOID2U64(green);
l.blue = VOID2U64(blue);
return DRM_IOCTL(fd, DRM_IOCTL_MODE_SETGAMMA, &l);
}
extern struct tm
ValueToDate(
ValueStruct *val)
{
struct tm ret;
Fixed *xval;
char *str;
memclear(&ret,sizeof(struct tm));
if ( val == NULL ) {
} else
switch (ValueType(val)) {
case GL_TYPE_CHAR:
case GL_TYPE_VARCHAR:
case GL_TYPE_TEXT:
case GL_TYPE_SYMBOL:
str = ValueString(val);
ret.tm_year = StrToInt(str,4); str += 4;
ret.tm_mon = StrToInt(str,2) - 1; str += 2;
ret.tm_mday = StrToInt(str,2); str += 2;
ret.tm_hour = 0;
ret.tm_min = 0;
ret.tm_sec = 0;
mktime(&ret);
break;
case GL_TYPE_NUMBER:
xval = &ValueFixed(val);
str = xval->sval;
ret.tm_year = StrToInt(str,4); str += 4;
ret.tm_mon = StrToInt(str,2) - 1; str += 2;
ret.tm_mday = StrToInt(str,2); str += 2;
ret.tm_hour = 0;
ret.tm_min = 0;
ret.tm_sec = 0;
mktime(&ret);
break;
case GL_TYPE_TIMESTAMP:
case GL_TYPE_DATE:
memcpy(&ret,&ValueDateTime(val),sizeof(struct tm));
ret.tm_hour = 0;
ret.tm_min = 0;
ret.tm_sec = 0;
mktime(&ret);
break;
default:
break;
}
return (ret);
}
