x86emu_mem_t *emu_mem_clone(x86emu_mem_t *mem)
{
mem2_pdir_t *pdir, *new_pdir;
mem2_ptable_t *ptable, *new_ptable;
mem2_page_t page;
unsigned pdir_idx, u1;
x86emu_mem_t *new_mem = NULL;
if(!mem) return new_mem;
new_mem = mem_dup(mem, sizeof *new_mem);
if((pdir = mem->pdir)) {
new_pdir = new_mem->pdir = mem_dup(mem->pdir, sizeof *mem->pdir);
for(pdir_idx = 0; pdir_idx < (1 << X86EMU_PDIR_BITS); pdir_idx++) {
ptable = (*pdir)[pdir_idx];
if(!ptable) continue;
new_ptable = (*new_pdir)[pdir_idx] = mem_dup(ptable, sizeof *ptable);
for(u1 = 0; u1 < (1 << X86EMU_PTABLE_BITS); u1++) {
page = (*ptable)[u1];
if(page.attr) {
(*new_ptable)[u1].attr = mem_dup(page.attr, 2 * X86EMU_PAGE_SIZE);
if(page.data == page.attr + X86EMU_PAGE_SIZE) {
(*new_ptable)[u1].data = (*new_ptable)[u1].attr + X86EMU_PAGE_SIZE;
}
}
}
}
}
return new_mem;
}
static int fi_get_sockaddr(int sa_family, uint64_t flags,
const char *node, const char *service,
struct sockaddr **addr, size_t *addrlen)
{
struct addrinfo hints, *ai;
int ret;
memset(&hints, 0, sizeof hints);
hints.ai_family = sa_family;
hints.ai_socktype = SOCK_STREAM;
if (flags & FI_SOURCE)
hints.ai_flags = AI_PASSIVE;
ret = getaddrinfo(node, service, &hints, &ai);
if (ret)
return -FI_ENODATA;
*addr = mem_dup(ai->ai_addr, ai->ai_addrlen);
if (!*addr) {
ret = -FI_ENOMEM;
goto out;
}
*addrlen = ai->ai_addrlen;
out:
freeaddrinfo(ai);
return ret;
}
HRESULT
NinePixelShader9_ctor( struct NinePixelShader9 *This,
struct NineUnknownParams *pParams,
const DWORD *pFunction, void *cso )
{
struct NineDevice9 *device;
struct nine_shader_info info;
struct pipe_context *pipe;
HRESULT hr;
DBG("This=%p pParams=%p pFunction=%p cso=%p\n", This, pParams, pFunction, cso);
hr = NineUnknown_ctor(&This->base, pParams);
if (FAILED(hr))
return hr;
if (cso) {
This->ff_cso = cso;
return D3D_OK;
}
device = This->base.device;
info.type = PIPE_SHADER_FRAGMENT;
info.byte_code = pFunction;
info.const_i_base = NINE_CONST_I_BASE(device->max_ps_const_f) / 16;
info.const_b_base = NINE_CONST_B_BASE(device->max_ps_const_f) / 16;
info.sampler_mask_shadow = 0x0;
info.sampler_ps1xtypes = 0x0;
info.fog_enable = 0;
info.projected = 0;
info.process_vertices = false;
pipe = nine_context_get_pipe_acquire(device);
hr = nine_translate_shader(device, &info, pipe);
nine_context_get_pipe_release(device);
if (FAILED(hr))
return hr;
This->byte_code.version = info.version;
This->byte_code.tokens = mem_dup(pFunction, info.byte_size);
if (!This->byte_code.tokens)
return E_OUTOFMEMORY;
This->byte_code.size = info.byte_size;
This->variant.cso = info.cso;
This->last_cso = info.cso;
This->last_key = 0;
This->sampler_mask = info.sampler_mask;
This->rt_mask = info.rt_mask;
This->const_used_size = info.const_used_size;
This->bumpenvmat_needed = info.bumpenvmat_needed;
/* no constant relative addressing for ps */
assert(info.lconstf.data == NULL);
assert(info.lconstf.ranges == NULL);
return D3D_OK;
}
static void *
llvmpipe_create_rasterizer_state(struct pipe_context *pipe,
const struct pipe_rasterizer_state *rast)
{
/* We do nothing special with rasterizer state.
* The CSO handle is just a pointer to a pipe_rasterizer_state object.
*/
return mem_dup(rast, sizeof(*rast));
}
memfile_t *memfile_open_memory(u8 *data,u32 size)
{
memfile_t *ret;
ret = memfile_create();
ret->size = size;
ret->data = (u8*)mem_dup(data,size);
return(ret);
}
static int ofix_dup_addr(struct fi_info *info, struct fi_info *dup)
{
dup->addr_format = info->addr_format;
if (info->src_addr) {
dup->src_addrlen = info->src_addrlen;
dup->src_addr = mem_dup(info->src_addr, info->src_addrlen);
if (dup->src_addr == NULL)
return -FI_ENOMEM;
}
if (info->dest_addr) {
dup->dest_addrlen = info->dest_addrlen;
dup->dest_addr = mem_dup(info->dest_addr, info->dest_addrlen);
if (dup->dest_addr == NULL) {
free(dup->src_addr);
dup->src_addr = NULL;
return -FI_ENOMEM;
}
}
return 0;
}
x86emu_t *x86emu_clone(x86emu_t *emu)
{
x86emu_t *new_emu = NULL;
if(!emu) return new_emu;
new_emu = mem_dup(emu, sizeof *emu);
new_emu->mem = emu_mem_clone(emu->mem);
if(emu->log.buf && emu->log.ptr) {
new_emu->log.buf = malloc(emu->log.size);
// copy only used log space
if(emu->log.ptr <= emu->log.buf + emu->log.size) {
new_emu->log.ptr = new_emu->log.buf + (emu->log.ptr - emu->log.buf);
memcpy(new_emu->log.buf, emu->log.buf, emu->log.ptr - emu->log.buf);
}
}
new_emu->io.map = mem_dup(emu->io.map, X86EMU_IO_PORTS * sizeof *emu->io.map);
new_emu->io.stats_i = mem_dup(emu->io.stats_i, X86EMU_IO_PORTS * sizeof *emu->io.stats_i);
new_emu->io.stats_o = mem_dup(emu->io.stats_o, X86EMU_IO_PORTS * sizeof *emu->io.stats_o);
new_emu->x86.msr = mem_dup(emu->x86.msr, X86EMU_MSRS * sizeof *emu->x86.msr);
new_emu->x86.msr_perm = mem_dup(emu->x86.msr_perm, X86EMU_MSRS * sizeof *emu->x86.msr_perm);
return new_emu;
}
static void udpx_getinfo_ifs(struct fi_info **info)
{
struct ifaddrs *ifaddrs, *ifa;
struct fi_info *head, *tail, *cur;
size_t addrlen;
uint32_t addr_format;
int ret;
ret = getifaddrs(&ifaddrs);
if (ret)
return;
head = tail = NULL;
for (ifa = ifaddrs; ifa != NULL; ifa = ifa->ifa_next) {
if (ifa->ifa_addr == NULL || !(ifa->ifa_flags & IFF_UP))
continue;
switch (ifa->ifa_addr->sa_family) {
case AF_INET:
addrlen = sizeof(struct sockaddr_in);
addr_format = FI_SOCKADDR_IN;
break;
case AF_INET6:
addrlen = sizeof(struct sockaddr_in6);
addr_format = FI_SOCKADDR_IN6;
break;
default:
continue;
}
cur = fi_dupinfo(*info);
if (!cur)
break;
if (!head)
head = cur;
else
tail->next = cur;
tail = cur;
if ((cur->src_addr = mem_dup(ifa->ifa_addr, addrlen))) {
cur->src_addrlen = addrlen;
cur->addr_format = addr_format;
}
}
freeifaddrs(ifaddrs);
if (head) {
fi_freeinfo(*info);
*info = head;
}
}
static int register_fd(void *x, int *fd, const char *path)
{
char full[_MAX_PATH];
if (NULL == _fullpath(full, path, _MAX_PATH)) {
return 0;
} else {
char *copy = mem_dup(full);
*fd = --FD_FROM_P(x);
hashtable_put(HT_FROM_P(x), UINT_TO_POINTER(*fd), copy);
return 1;
}
}
DIR *opendir(void *x, const char *filename)
{
DIR *dp;
char *filespec;
struct _stat buffer;
int index, fd, allocated;
if (-1 == (fd = win32_open_ex(x, filename, _O_RDONLY, &buffer))) {
return NULL;
}
if (!S_ISDIR(buffer.st_mode)) {
errno = ENOTDIR;
return NULL;
}
allocated = strlen(filename) + 2 + 1;
filespec = mem_new_n(*filename, allocated);
if (0 != strcpy_s(filespec, allocated, filename)) {
free(filespec);
return NULL;
}
index = strlen(filespec) - 1;
if (index >= 0 && (filespec[index] == '/' || (filespec[index] == '\\' && (index == 0 || !IsDBCSLeadByte(filespec[index-1]))))) {
filespec[index] = '\0';
}
if (0 != strncat_s(filespec, allocated, "\\*", sizeof("\\*") - 1)) {
free(filespec);
return NULL;
}
dp = mem_new(*dp);
dp->offset = 0;
dp->finished = 0;
if ((dp->handle = FindFirstFileA(filespec, &(dp->fileinfo))) == INVALID_HANDLE_VALUE) {
DWORD err = GetLastError();
if (err == ERROR_NO_MORE_FILES || err == ERROR_FILE_NOT_FOUND) {
dp->finished = 1;
} else {
free(dp);
free(filespec);
win32_close(x, fd);
return NULL;
}
}
dp->fd = fd;
dp->dir = mem_dup(filename);
free(filespec);
return dp;
}
static void check_ep_name_str(struct gnix_ep_name actual, void *expected,
size_t ep_name_len)
{
char *ep_name_str;
struct gnix_ep_name rebuilt;
ep_name_str = (char *) mem_dup(expected, ep_name_len);
fas_to_ep_name(ep_name_str, &rebuilt);
check_ep_name(actual, rebuilt);
free(ep_name_str);
}
static void *
llvmpipe_create_blend_state(struct pipe_context *pipe,
const struct pipe_blend_state *blend)
{
struct pipe_blend_state *state = mem_dup(blend, sizeof *blend);
int i;
if (LP_PERF & PERF_NO_BLEND) {
state->independent_blend_enable = 0;
for (i = 0; i < PIPE_MAX_COLOR_BUFS; i++)
state->rt[i].blend_enable = 0;
}
return state;
}
HRESULT
NinePixelShader9_ctor( struct NinePixelShader9 *This,
struct NineUnknownParams *pParams,
const DWORD *pFunction, void *cso )
{
struct NineDevice9 *device;
struct nine_shader_info info;
HRESULT hr;
hr = NineUnknown_ctor(&This->base, pParams);
if (FAILED(hr))
return hr;
if (cso) {
This->variant.cso = cso;
return D3D_OK;
}
device = This->base.device;
info.type = PIPE_SHADER_FRAGMENT;
info.byte_code = pFunction;
info.const_i_base = NINE_CONST_I_BASE(device->max_ps_const_f) / 16;
info.const_b_base = NINE_CONST_B_BASE(device->max_ps_const_f) / 16;
info.sampler_mask_shadow = 0x0;
info.sampler_ps1xtypes = 0x0;
hr = nine_translate_shader(device, &info);
if (FAILED(hr))
return hr;
This->byte_code.version = info.version;
This->byte_code.tokens = mem_dup(pFunction, info.byte_size);
if (!This->byte_code.tokens)
return E_OUTOFMEMORY;
This->byte_code.size = info.byte_size;
This->variant.cso = info.cso;
This->sampler_mask = info.sampler_mask;
This->rt_mask = info.rt_mask;
This->const_used_size = info.const_used_size;
if (info.const_used_size == ~0)
This->const_used_size = NINE_CONSTBUF_SIZE(device->max_ps_const_f);
This->lconstf = info.lconstf;
return D3D_OK;
}
static void *
llvmpipe_create_sampler_state(struct pipe_context *pipe,
const struct pipe_sampler_state *sampler)
{
struct pipe_sampler_state *state = mem_dup(sampler, sizeof *sampler);
if (LP_PERF & PERF_NO_MIP_LINEAR) {
if (state->min_mip_filter == PIPE_TEX_MIPFILTER_LINEAR)
state->min_mip_filter = PIPE_TEX_MIPFILTER_NEAREST;
}
if (LP_PERF & PERF_NO_MIPMAPS)
state->min_mip_filter = PIPE_TEX_MIPFILTER_NONE;
if (LP_PERF & PERF_NO_LINEAR) {
state->mag_img_filter = PIPE_TEX_FILTER_NEAREST;
state->min_img_filter = PIPE_TEX_FILTER_NEAREST;
}
return state;
}
static void *
llvmpipe_create_depth_stencil_state(struct pipe_context *pipe,
const struct pipe_depth_stencil_alpha_state *depth_stencil)
{
struct pipe_depth_stencil_alpha_state *state;
state = mem_dup(depth_stencil, sizeof *depth_stencil);
if (LP_PERF & PERF_NO_DEPTH) {
state->depth.enabled = 0;
state->depth.writemask = 0;
state->stencil[0].enabled = 0;
state->stencil[1].enabled = 0;
}
if (LP_PERF & PERF_NO_ALPHATEST) {
state->alpha.enabled = 0;
}
return state;
}
/**
* Insert a new key + data pointer into the table.
* Note: we create a copy of the key, but not the data!
* If the key is already present in the table, replace the existing
* entry (calling the delete callback on the previous entry).
* If the maximum capacity of the map is reached an old entry
* will be deleted (the delete callback will be called).
*/
boolean
util_keymap_insert(struct keymap *map, const void *key,
const void *data, void *user)
{
unsigned key_hash;
struct keymap_item *item;
struct cso_hash_iter iter;
assert(map);
if (!map)
return FALSE;
key_hash = hash(key, map->key_size);
item = hash_table_find_item(map, key, key_hash);
if (item) {
/* call delete callback for old entry/item */
map->delete_func(map, item->key, item->value, user);
item->value = (void *) data;
return TRUE;
}
item = MALLOC_STRUCT(keymap_item);
if (!item)
return FALSE;
item->key = mem_dup(key, map->key_size);
item->value = (void *) data;
iter = cso_hash_insert(map->cso, key_hash, item);
if (cso_hash_iter_is_null(iter)) {
FREE(item);
return FALSE;
}
map->num_entries++;
return TRUE;
}
u32t dsk_flushgpt(hdd_info *hi) {
struct Disk_GPT *pt = hi->ghead,
*pt2 = hi->ghead2;
if (!hi || !hi->gpthead || !hi->ptg || !pt) return DPTE_INVARGS;
// update partition data crc32
pt ->GPT_PtCRC = crc32(crc32(0,0,0), (u8t*)hi->ptg, sizeof(struct GPT_Record) *
pt->GPT_PtCout);
// there is no second copy? reconstruct one
if (!pt2) {
// check location
if (!pt->GPT_Hdr2Pos || pt->GPT_Hdr2Pos==FFFF64)
pt->GPT_Hdr2Pos = hi->info.TotalSectors - 1;
if (pt->GPT_Hdr2Pos - hi->gpt_sectors <= pt->GPT_UserLast)
return DPTE_GPTHDR;
// makes a copy
hi->ghead2 = pt2 = (struct Disk_GPT *)mem_dup(hi->ghead);
pt2->GPT_PtInfo = pt->GPT_Hdr2Pos - hi->gpt_sectors;
}
// update crc32 in headers
pt->GPT_HdrCRC = 0;
pt->GPT_HdrCRC = crc32(crc32(0,0,0), (u8t*)pt, sizeof(struct Disk_GPT));
pt2->GPT_HdrCRC = 0;
pt2->GPT_HdrCRC = crc32(crc32(0,0,0), (u8t*)pt2, sizeof(struct Disk_GPT));
// write second copy of partition data
if (hlp_diskwrite(hi->disk, pt2->GPT_PtInfo, hi->gpt_sectors, hi->ptg) !=
hi->gpt_sectors) return DPTE_ERRWRITE;
// write second header
if (!hlp_diskwrite(hi->disk, pt->GPT_Hdr2Pos, 1, pt2)) return DPTE_ERRWRITE;
// write first copy of partition data
if (hlp_diskwrite(hi->disk, pt->GPT_PtInfo, hi->gpt_sectors, hi->ptg) !=
hi->gpt_sectors) return DPTE_ERRWRITE;
// write first header
if (!hlp_diskwrite(hi->disk, pt->GPT_Hdr1Pos, 1, pt)) return DPTE_ERRWRITE;
return 0;
}
void *
llvmpipe_create_rasterizer_state(struct pipe_context *pipe,
const struct pipe_rasterizer_state *rast)
{
return mem_dup(rast, sizeof(*rast));
}
struct fi_info *DEFAULT_SYMVER_PRE(fi_dupinfo)(const struct fi_info *info)
{
struct fi_info *dup;
if (!info)
return ofi_allocinfo_internal();
dup = mem_dup(info, sizeof(*dup));
if (dup == NULL) {
return NULL;
}
dup->src_addr = NULL;
dup->dest_addr = NULL;
dup->tx_attr = NULL;
dup->rx_attr = NULL;
dup->ep_attr = NULL;
dup->domain_attr = NULL;
dup->fabric_attr = NULL;
dup->next = NULL;
if (info->src_addr != NULL) {
dup->src_addr = mem_dup(info->src_addr, info->src_addrlen);
if (dup->src_addr == NULL)
goto fail;
}
if (info->dest_addr != NULL) {
dup->dest_addr = mem_dup(info->dest_addr, info->dest_addrlen);
if (dup->dest_addr == NULL)
goto fail;
}
if (info->tx_attr != NULL) {
dup->tx_attr = mem_dup(info->tx_attr, sizeof(*info->tx_attr));
if (dup->tx_attr == NULL)
goto fail;
}
if (info->rx_attr != NULL) {
dup->rx_attr = mem_dup(info->rx_attr, sizeof(*info->rx_attr));
if (dup->rx_attr == NULL)
goto fail;
}
if (info->ep_attr != NULL) {
dup->ep_attr = mem_dup(info->ep_attr, sizeof(*info->ep_attr));
if (dup->ep_attr == NULL)
goto fail;
}
if (info->domain_attr) {
dup->domain_attr = mem_dup(info->domain_attr,
sizeof(*info->domain_attr));
if (dup->domain_attr == NULL)
goto fail;
if (info->domain_attr->name != NULL) {
dup->domain_attr->name = strdup(info->domain_attr->name);
if (dup->domain_attr->name == NULL)
goto fail;
}
}
if (info->fabric_attr) {
dup->fabric_attr = mem_dup(info->fabric_attr,
sizeof(*info->fabric_attr));
if (dup->fabric_attr == NULL)
goto fail;
dup->fabric_attr->name = NULL;
dup->fabric_attr->prov_name = NULL;
if (info->fabric_attr->name != NULL) {
dup->fabric_attr->name = strdup(info->fabric_attr->name);
if (dup->fabric_attr->name == NULL)
goto fail;
}
if (info->fabric_attr->prov_name != NULL) {
dup->fabric_attr->prov_name = strdup(info->fabric_attr->prov_name);
if (dup->fabric_attr->prov_name == NULL)
goto fail;
}
}
return dup;
fail:
fi_freeinfo(dup);
return NULL;
}
/*
=======================================
FMODEx 文件读取
=======================================
*/
CR_API sFMT_PRT*
load_fmodex (
__CR_IO__ iDATIN* datin,
__CR_IN__ const sLOADER* param
)
{
uint_t size;
void_t* data;
ansi_t* path;
sFMT_PRT* rett;
FMOD_MODE mode;
iXMM_FMOD* port;
FMOD_SOUND* sound;
FMOD_RESULT result;
FMOD_CHANNEL* channel;
FMOD_CREATESOUNDEXINFO ex_info;
/* 必须先初始化 */
if (s_fmodex == NULL)
return (NULL);
mode = FMOD_LOOP_OFF | FMOD_2D | FMOD_HARDWARE | FMOD_ACCURATETIME;
/* 不支持文件区段功能 */
switch (param->type)
{
case CR_LDR_ANSI:
data = NULL;
result = FMOD_System_CreateStream(s_fmodex, param->name.ansi,
mode, NULL, &sound);
break;
case CR_LDR_WIDE:
data = NULL;
path = utf16_to_local(CR_LOCAL, param->name.wide);
if (path == NULL)
return (NULL);
result = FMOD_System_CreateStream(s_fmodex, path, mode,
NULL, &sound);
mem_free(path);
break;
case CR_LDR_BUFF:
if (cut_size(&size, param->buff.size))
return (NULL);
data = mem_dup(param->buff.data, param->buff.size);
if (data == NULL)
return (NULL);
path = (ansi_t*)data;
mode |= FMOD_OPENMEMORY;
mem_zero(&ex_info, sizeof(ex_info));
ex_info.cbsize = sizeof(ex_info);
ex_info.length = size;
result = FMOD_System_CreateStream(s_fmodex, path, mode,
&ex_info, &sound);
break;
default:
return (NULL);
}
/* 无法支持的格式 */
if (result != FMOD_OK)
goto _failure1;
/* 生成播放通道对象 */
result = FMOD_System_PlaySound(s_fmodex, FMOD_CHANNEL_FREE,
sound, TRUE, &channel);
if (result != FMOD_OK)
goto _failure2;
/* 生成媒体播放接口对象 */
port = struct_new(iXMM_FMOD);
if (port == NULL)
goto _failure3;
struct_zero(port, iXMM_FMOD);
port->m_dat = data;
port->m_snd = sound;
port->m_chn = channel;
if (!fmodex_info(port)) {
iXMM_FMOD_release((iXMMEDIA*)port);
return (NULL);
}
port->xmms.__volume__ = 100;
port->xmms.__vptr__ = &s_xmms_vtbl;
/* 返回读取的文件数据 */
rett = struct_new(sFMT_PRT);
if (rett == NULL) {
iXMM_FMOD_release((iXMMEDIA*)port);
return (NULL);
}
CR_NOUSE(datin);
rett->type = CR_FMTZ_PRT;
rett->port = (iPORT*)port;
rett->more = "iXMMEDIA";
rett->infor = port->m_inf;
return (rett);
_failure3:
FMOD_Channel_Stop(channel);
_failure2:
FMOD_Sound_Release(sound);
_failure1:
TRY_FREE(data);
return (NULL);
}
int h264_unpack_nal(h264_unpack_ctx_t *ctx
, node_t *pkt
, node_t *nal
, void *_uargs)
{
int ret = 0;
int skip = 0;
uint8_t fu_nal_hdr = 0;
unpack_ctx_t *_ctx = (unpack_ctx_t*)ctx;
_ctx->cur_pkt_is_begin= 0;
_ctx->cur_pkt_is_comp = 0;
if((skip = get_hdr_size(_ctx, pkt, &fu_nal_hdr)) < 0)
{
/* pkt err */
ret = 1;
goto __error;
}
if((_ctx->cur_pkt_type != HDR_TYPE(pkt))
|| (_ctx->cur_times != pkt->times)
|| (mem_data(&_ctx->nal_mem) == NULL))
{
/* reset && alloc nal */
int hdr_s, data_s;
if(mem_data(&_ctx->nal_mem))
{
printf("%s ===> err: skip next nal, lost cur nal;\n", __FUNCTION__);
_ctx->parm._free(&_ctx->nal_mem);
mem_data(&_ctx->nal_mem) = NULL;
}
_ctx->parm._size(&_ctx->parm, _uargs, &data_s, &hdr_s);
printf("data_s: %d, hdr_s: %d\n", data_s, hdr_s);
_ctx->nal_buf_size = data_s;
_ctx->nal_buf_off = 0;
_ctx->nal_mem = _ctx->parm._alloc(&_ctx->parm, data_s, hdr_s);
}
_ctx->cur_times = pkt->times;
/* memcpy pkt to nal; */
if((mem_data_s(&pkt->mem)-skip) > (_ctx->nal_buf_size - _ctx->nal_buf_off))
{
/* size not enough */
ret = -2;
goto __error;
}
if(fu_nal_hdr)
{
*(mem_data(&_ctx->nal_mem)+_ctx->nal_buf_off++) = fu_nal_hdr;
skip++;
}
memcpy(mem_data(&_ctx->nal_mem)+_ctx->nal_buf_off, mem_data(&pkt->mem)+skip, mem_data_s(&pkt->mem)-skip);
_ctx->nal_buf_off += (mem_data_s(&pkt->mem)-skip);
if(_ctx->cur_pkt_is_comp)
{
nal->times= _ctx->cur_times;
mem_dup(&nal->mem, &_ctx->nal_mem);
mem_data_s(&nal->mem) = _ctx->nal_buf_off;
/* push nal to user */
mem_data(&_ctx->nal_mem) = NULL;
ret = 1;
}
return ret;
__error:
printf("%s ===> err: %d;\n", __FUNCTION__, ret);
if(mem_data(&_ctx->nal_mem))
{
_ctx->parm._free(&_ctx->nal_mem);
mem_data(&_ctx->nal_mem) = NULL;
}
return ret;
}
void *
softpipe_create_blend_state(struct pipe_context *pipe,
const struct pipe_blend_state *blend)
{
return mem_dup(blend, sizeof(*blend));
}
void *
softpipe_create_depth_stencil_state(struct pipe_context *pipe,
const struct pipe_depth_stencil_alpha_state *depth_stencil)
{
return mem_dup(depth_stencil, sizeof(*depth_stencil));
}
static void *
cell_create_depth_stencil_alpha_state(struct pipe_context *pipe,
const struct pipe_depth_stencil_alpha_state *dsa)
{
return mem_dup(dsa, sizeof(*dsa));
}
int util_getinfo(const struct fi_provider *prov, uint32_t version,
const char *node, const char *service, uint64_t flags,
const struct fi_info *prov_info, struct fi_info *hints,
struct fi_info **info)
{
struct util_fabric *fabric;
struct util_domain *domain;
struct dlist_entry *item;
int ret, copy_dest;
FI_DBG(prov, FI_LOG_CORE, "checking info\n");
if ((flags & FI_SOURCE) && !node && !service) {
FI_INFO(prov, FI_LOG_CORE,
"FI_SOURCE set, but no node or service\n");
return -FI_EINVAL;
}
ret = fi_check_info(prov, prov_info, hints, FI_MATCH_EXACT);
if (ret)
return ret;
*info = fi_dupinfo(prov_info);
if (!*info) {
FI_INFO(prov, FI_LOG_CORE, "cannot copy info\n");
return -FI_ENOMEM;
}
ofi_alter_info(*info, hints);
fabric = fi_fabric_find((*info)->fabric_attr->name);
if (fabric) {
FI_DBG(prov, FI_LOG_CORE, "Found opened fabric\n");
(*info)->fabric_attr->fabric = &fabric->fabric_fid;
fastlock_acquire(&fabric->lock);
item = dlist_find_first_match(&fabric->domain_list,
util_find_domain, *info);
if (item) {
FI_DBG(prov, FI_LOG_CORE, "Found open domain\n");
domain = container_of(item, struct util_domain,
list_entry);
(*info)->domain_attr->domain = &domain->domain_fid;
}
fastlock_release(&fabric->lock);
}
if (flags & FI_SOURCE) {
ret = ofi_get_addr((*info)->addr_format, flags,
node, service, &(*info)->src_addr,
&(*info)->src_addrlen);
if (ret) {
FI_INFO(prov, FI_LOG_CORE,
"source address not available\n");
goto err;
}
copy_dest = (hints && hints->dest_addr);
} else {
if (node || service) {
copy_dest = 0;
ret = ofi_get_addr((*info)->addr_format, flags,
node, service, &(*info)->dest_addr,
&(*info)->dest_addrlen);
if (ret) {
FI_INFO(prov, FI_LOG_CORE,
"cannot resolve dest address\n");
goto err;
}
} else {
copy_dest = (hints && hints->dest_addr);
}
if (hints && hints->src_addr) {
(*info)->src_addr = mem_dup(hints->src_addr,
hints->src_addrlen);
if (!(*info)->src_addr) {
ret = -FI_ENOMEM;
goto err;
}
(*info)->src_addrlen = hints->src_addrlen;
}
}
if (copy_dest) {
(*info)->dest_addr = mem_dup(hints->dest_addr,
hints->dest_addrlen);
if (!(*info)->dest_addr) {
ret = -FI_ENOMEM;
goto err;
}
(*info)->dest_addrlen = hints->dest_addrlen;
}
if ((*info)->dest_addr && !(*info)->src_addr) {
ret = ofi_get_src_addr((*info)->addr_format, (*info)->dest_addr,
(*info)->dest_addrlen, &(*info)->src_addr,
&(*info)->src_addrlen);
if (ret) {
FI_INFO(prov, FI_LOG_CORE,
"cannot resolve source address\n");
}
}
return 0;
err:
fi_freeinfo(*info);
return ret;
}
/*
* |<- num(4)+9*[off(4)+size(4)] ->|<--- data --->|
* return: -1: err, >=0: frm num
*/
int h264_unpack_frm(h264_unpack_ctx_t *ctx
, node_t *pkt
, node_t *frm
, void *_uargs)
{
int ret = 0;
int skip = 0;
uint8_t fu_nal_hdr = 0;
unpack_ctx_t *_ctx = (unpack_ctx_t*)ctx;
_ctx->cur_pkt_is_begin= 0;
_ctx->cur_pkt_is_comp = 0;
if((skip = get_hdr_size(_ctx, pkt, &fu_nal_hdr)) < 0)
{
/* pkt err */
ret = -1;
goto __error;
}
if( (_ctx->cur_times != pkt->times)
|| (mem_data(&_ctx->nal_mem) == NULL))
{
int hdr_s, data_s;
if(mem_data(&_ctx->nal_mem))
{
/* warning...... no seq in pkt */
/* dup frm, push to user */
frm->times= _ctx->cur_times;
frm->type = _ctx->cur_frm_type;
mem_dup(&frm->mem, &_ctx->nal_mem);
mem_data_s(&frm->mem) = _ctx->nal_buf_off;
#if 0
printf("%s ===> OK: push frame nal_num:%d, size(%d+%d=%d)\n"
, __FUNCTION__
, *((int*)(mem_data(&_ctx->nal_mem)+NAL_OFF_NUM))
, NAL_INFO_SIZE
, _ctx->nal_buf_off - NAL_INFO_SIZE
, _ctx->nal_buf_off);
#endif
mem_data(&_ctx->nal_mem) = NULL;
ret = 1;
}
/* reset && alloc frm */
_ctx->parm._size(&_ctx->parm, _uargs, &data_s, &hdr_s);
_ctx->nal_buf_size = data_s;
_ctx->nal_buf_off = NAL_INFO_SIZE;
_ctx->nal_mem = _ctx->parm._alloc(&_ctx->parm, data_s, hdr_s);
*((int*)(mem_data(&_ctx->nal_mem)+NAL_OFF_NUM)) = 0;
}
_ctx->cur_times = pkt->times;
int i = *((int*)(mem_data(&_ctx->nal_mem)+NAL_OFF_NUM));
/* memcpy pkt to ctx frm; */
if((mem_data_s(&pkt->mem)-skip + 4) > (_ctx->nal_buf_size - _ctx->nal_buf_off))
{
/* size not enough */
ret = -2;
goto __error;
}
if(_ctx->cur_pkt_is_begin)
{
if(*((int*)(mem_data(&_ctx->nal_mem)+NAL_OFF_NUM)) == 0)
{
if( _ctx->cur_nal_type == 7 /* sps */
|| _ctx->cur_nal_type == 8 /* pps */
|| _ctx->cur_nal_type == 6) /* sei */
_ctx->cur_frm_type = 1; /* FRAME_I */
else
_ctx->cur_frm_type = 2; /* FRAME_P */
}
//printf("%s ===> nal_idx:%d begin:\n", __FUNCTION__, i);
*((int*)(mem_data(&_ctx->nal_mem)+NAL_OFF_I_OFF(i))) = _ctx->nal_buf_off;
*((int*)(mem_data(&_ctx->nal_mem)+NAL_OFF_I_SIZE(i))) = 4;
*(mem_data(&_ctx->nal_mem)+_ctx->nal_buf_off++) = 0x00;
*(mem_data(&_ctx->nal_mem)+_ctx->nal_buf_off++) = 0x00;
*(mem_data(&_ctx->nal_mem)+_ctx->nal_buf_off++) = 0x00;
*(mem_data(&_ctx->nal_mem)+_ctx->nal_buf_off++) = 0x01;
}
(*(int*)(mem_data(&_ctx->nal_mem)+NAL_OFF_I_SIZE(i))) += (mem_data_s(&pkt->mem)-skip);
if(fu_nal_hdr)
{
*(mem_data(&_ctx->nal_mem)+_ctx->nal_buf_off++) = fu_nal_hdr;
skip++;
}
memcpy(mem_data(&_ctx->nal_mem)+_ctx->nal_buf_off, mem_data(&pkt->mem)+skip, mem_data_s(&pkt->mem)-skip);
_ctx->nal_buf_off += (mem_data_s(&pkt->mem)-skip);
if(_ctx->cur_pkt_is_comp)
{
//printf("%s ===> nal_idx:%d end, size:%d\n", __FUNCTION__, i, *((int*)(mem_data(&_ctx->nal_mem)+NAL_OFF_I_SIZE(i))));
(*((int*)(mem_data(&_ctx->nal_mem)+NAL_OFF_NUM)))++;
}
return ret;
__error:
printf("%s ===> err: %d;\n", __FUNCTION__, ret);
if(mem_data(&_ctx->nal_mem))
{
_ctx->parm._free(&_ctx->nal_mem);
mem_data(&_ctx->nal_mem) = NULL;
}
return ret;
}
static void *
cell_create_rasterizer_state(struct pipe_context *pipe,
const struct pipe_rasterizer_state *rasterizer)
{
return mem_dup(rasterizer, sizeof(*rasterizer));
}
struct fi_info_1_0 *fi_dupinfo_1_0(const struct fi_info_1_0 *info)
{
struct fi_info *dup;
if (!info)
return (struct fi_info_1_0 *) ofi_allocinfo_internal();
ofi_dup_attr(dup, info);
if (dup == NULL) {
return NULL;
}
dup->src_addr = NULL;
dup->dest_addr = NULL;
dup->tx_attr = NULL;
dup->rx_attr = NULL;
dup->ep_attr = NULL;
dup->domain_attr = NULL;
dup->fabric_attr = NULL;
dup->next = NULL;
if (info->src_addr != NULL) {
dup->src_addr = mem_dup(info->src_addr, info->src_addrlen);
if (dup->src_addr == NULL)
goto fail;
}
if (info->dest_addr != NULL) {
dup->dest_addr = mem_dup(info->dest_addr, info->dest_addrlen);
if (dup->dest_addr == NULL)
goto fail;
}
if (info->tx_attr != NULL) {
ofi_dup_attr(dup->tx_attr, info->tx_attr);
if (dup->tx_attr == NULL)
goto fail;
}
if (info->rx_attr != NULL) {
ofi_dup_attr(dup->rx_attr, info->rx_attr);
if (dup->rx_attr == NULL)
goto fail;
}
if (info->ep_attr != NULL) {
ofi_dup_attr(dup->ep_attr, info->ep_attr);
if (dup->ep_attr == NULL)
goto fail;
}
if (info->domain_attr) {
ofi_dup_attr(dup->domain_attr, info->domain_attr);
if (dup->domain_attr == NULL)
goto fail;
if (info->domain_attr->name != NULL) {
dup->domain_attr->name = strdup(info->domain_attr->name);
if (dup->domain_attr->name == NULL)
goto fail;
}
}
if (info->fabric_attr) {
ofi_dup_attr(dup->fabric_attr, info->fabric_attr);
if (dup->fabric_attr == NULL)
goto fail;
dup->fabric_attr->name = NULL;
dup->fabric_attr->prov_name = NULL;
if (info->fabric_attr->name != NULL) {
dup->fabric_attr->name = strdup(info->fabric_attr->name);
if (dup->fabric_attr->name == NULL)
goto fail;
}
if (info->fabric_attr->prov_name != NULL) {
dup->fabric_attr->prov_name = strdup(info->fabric_attr->prov_name);
if (dup->fabric_attr->prov_name == NULL)
goto fail;
}
}
return (struct fi_info_1_0 *) dup;
fail:
fi_freeinfo(dup);
return NULL;
}
HRESULT
NineVertexShader9_ctor( struct NineVertexShader9 *This,
struct NineUnknownParams *pParams,
const DWORD *pFunction, void *cso )
{
struct NineDevice9 *device;
struct nine_shader_info info;
HRESULT hr;
unsigned i;
DBG("This=%p pParams=%p pFunction=%p cso=%p\n",
This, pParams, pFunction, cso);
hr = NineUnknown_ctor(&This->base, pParams);
if (FAILED(hr))
return hr;
if (cso) {
This->ff_cso = cso;
return D3D_OK;
}
device = This->base.device;
info.type = PIPE_SHADER_VERTEX;
info.byte_code = pFunction;
info.const_i_base = NINE_CONST_I_BASE(device->max_vs_const_f) / 16;
info.const_b_base = NINE_CONST_B_BASE(device->max_vs_const_f) / 16;
info.sampler_mask_shadow = 0x0;
info.sampler_ps1xtypes = 0x0;
info.fog_enable = 0;
info.point_size_min = 0;
info.point_size_max = 0;
info.swvp_on = !!(device->params.BehaviorFlags & D3DCREATE_SOFTWARE_VERTEXPROCESSING);
info.process_vertices = false;
hr = nine_translate_shader(device, &info);
if (hr == D3DERR_INVALIDCALL &&
(device->params.BehaviorFlags & D3DCREATE_MIXED_VERTEXPROCESSING)) {
/* Retry with a swvp shader. It will require swvp to be on. */
info.swvp_on = true;
hr = nine_translate_shader(device, &info);
}
if (hr == D3DERR_INVALIDCALL)
ERR("Encountered buggy shader\n");
if (FAILED(hr))
return hr;
This->byte_code.version = info.version;
This->swvp_only = info.swvp_on;
This->byte_code.tokens = mem_dup(pFunction, info.byte_size);
if (!This->byte_code.tokens)
return E_OUTOFMEMORY;
This->byte_code.size = info.byte_size;
This->variant.cso = info.cso;
This->last_cso = info.cso;
This->last_key = (uint32_t) (info.swvp_on << 9);
This->const_used_size = info.const_used_size;
This->lconstf = info.lconstf;
This->sampler_mask = info.sampler_mask;
This->position_t = info.position_t;
This->point_size = info.point_size;
for (i = 0; i < info.num_inputs && i < ARRAY_SIZE(This->input_map); ++i)
This->input_map[i].ndecl = info.input_map[i];
This->num_inputs = i;
return D3D_OK;
}
void *
llvmpipe_create_sampler_state(struct pipe_context *pipe,
const struct pipe_sampler_state *sampler)
{
return mem_dup(sampler, sizeof(*sampler));
}
