Off
indfetch(Device* d, Off qpath, Off addr, Off a, int itag, int tag, int uid)
{
Iobuf *bp;
if(!addr)
return 0;
bp = getbuf(d, addr, Brd);
if(!bp || checktag(bp, itag, qpath)) {
if(!bp) {
print("ind fetch bp = 0\n");
return 0;
}
print("ind fetch tag\n");
putbuf(bp);
return 0;
}
addr = ((Off *)bp->iobuf)[a];
if(!addr && tag) {
addr = bufalloc(d, tag, qpath, uid);
if(addr) {
((Off *)bp->iobuf)[a] = addr;
bp->flags |= Bmod;
if(tag == Tdir)
bp->flags |= Bimm;
settag(bp, itag, qpath);
}
}
putbuf(bp);
return addr;
}
void init(LavParam *param, uint8_t *buffer[])
{
param->luma_size = param->output_width * param->output_height;
switch (param->chroma) {
default:
mjpeg_warn("unsupported chroma (%d), assume '420jpeg'", param->chroma);
param->chroma = Y4M_UNKNOWN; /* will update in writeoutYUV4MPEGheader() */
/* and do same as case Y4M_CHROMA_420JPEG... */
case Y4M_UNKNOWN:
case Y4M_CHROMA_420JPEG:
case Y4M_CHROMA_420MPEG2:
case Y4M_CHROMA_420PALDV:
param->chroma_width = param->output_width / 2;
param->chroma_height = param->output_height / 2;
break;
case Y4M_CHROMA_422:
param->chroma_width = param->output_width / 2;
param->chroma_height = param->output_height;
break;
case Y4M_CHROMA_411:
param->chroma_width = param->output_width / 4;
param->chroma_height = param->output_height;
break;
}
param->chroma_size = param->chroma_height * param->chroma_width;
buffer[0] = (uint8_t *)bufalloc(param->luma_size);
buffer[1] = (uint8_t *)bufalloc(param->chroma_size);
buffer[2] = (uint8_t *)bufalloc(param->chroma_size);
#ifdef HAVE_LIBDV
dv_frame[0] = (uint8_t *)bufalloc(3 * param->output_width * param->output_height);
dv_frame[1] = buffer[1];
dv_frame[2] = buffer[2];
#endif
}
Off
rel2abs(Iobuf *p, Dentry *d, Off a, int tag, int putb, int uid)
{
int i;
Off addr, qpath, indaddrs = 1, div;
Device *dev;
if(a < 0) {
print("rel2abs: neg offset\n");
if(putb)
putbuf(p);
return 0;
}
dev = p->dev;
qpath = d->qid.path;
/* is `a' a direct block? */
if(a < NDBLOCK) {
addr = d->dblock[a];
if(!addr && tag) {
addr = bufalloc(dev, tag, qpath, uid);
d->dblock[a] = addr;
p->flags |= Bmod|Bimm;
}
if(putb)
putbuf(p);
return addr;
}
a -= NDBLOCK;
/*
* loop through indirect block depths.
*/
for (i = 0; i < NIBLOCK; i++) {
indaddrs *= INDPERBUF;
/* is a's disk addr in this indir block or one of its kids? */
if (a < indaddrs) {
addr = d->iblocks[i];
if(!addr && tag) {
addr = bufalloc(dev, Tind1+i, qpath, uid);
d->iblocks[i] = addr;
p->flags |= Bmod|Bimm;
}
if(putb)
putbuf(p);
div = indaddrs;
for (; i >= 0; i--) {
div /= INDPERBUF;
if (div <= 0)
panic("rel2abs: non-positive divisor");
addr = indfetch(dev, qpath, addr,
(a/div)%INDPERBUF, Tind1+i,
(i == 0? tag: Tind1+i-1), uid);
}
return addr;
}
a -= indaddrs;
}
if(putb)
putbuf(p);
/* quintuple-indirect blocks not implemented. */
print("rel2abs: no %d-deep indirect\n", NIBLOCK+1);
return 0;
}
/* 计算当前激活的程序的CRC，并且把它和在_viruscrc保存的CRC比较. */
int validatecrc(const char *progname)
{
int retcode; /* 函数返回码 */
if (_viruscrc.x.polynomial != 0)
{
unsigned char *buffer; /* 程序位图的缓存 */
size_t bufsize; /* 缓存的大小. */
/* 如果可能，分配8k的内存；至少保证分配512字节. */
bufsize = 8192;
buffer = bufalloc(&bufsize, 512);
if (buffer)
{
char pn[80]; /* 程序的全名 */
FILE *progfile; /* 文件指针 */
if (_osmajor < 3)
/* 根据在progname指定的路径搜索文件. */
findprog(progname, pn);
else
strcpy(pn, argv0);
if ((progfile = fopen(pn, "rb")) != NULL)
{
crc32_t table[256]; /* CRC表 */
register crc32_t *halfi; /* i/2的CRC指针 */
crc32_t crc; /* 当前的CRC */
register size_t i; /* 字节计数器. */
unsigned char *bufptr; /* 缓存区遍历指针 */
/* 为了快速计算机生成一长CRC查找表 */
for (i = 0, halfi = table, table[0] = 0; i < 256; i += 2, halfi++)
if (hib(hiw(*halfi)) & 0x80)
table[i] = (table[i + 1] = *halfi << 1) ^ _viruscrc.x.polynomial;
else
table[i + 1] = (table[i] = *halfi << 1) ^ _viruscrc.x.polynomial;
crc = 0;
while ((i = fread(buffer, 1, bufsize, progfile)) != 0)
for (bufptr = buffer; i--; bufptr++)
crc = (crc << 8) ^ table[hib(hiw(crc)) ^ *bufptr];
fclose(progfile);
retcode = crc == _viruscrc.x.crc ? CRC_VALID : CRC_INVALID;
}
else
retcode = CRC_FILEERR;
free(buffer);
}
else
retcode = CRC_NOMEM;
}
else
/* CRC多项式必须不为0 */
retcode = CRC_ISZERO;
return (retcode);
}
/*
* Function: get_hostent_from_etc_hosts
*
* Purpose: Read the ETC_HOSTS file and check if it contains the given name.
* Return the result in a hostent structure.
*
* Parameters:
* ctx -- The validation context.
* name -- The domain name or IP address in string form.
* af -- The address family: AF_INET or AF_INET6.
* ret -- Pointer to a hostent structure to return the result.
* This parameter must not be NULL.
* buf -- A buffer to store auxiliary data. This parameter must not be NULL.
* buflen -- Length of the buffer 'buf'.
* offset -- Pointer to an integer variable that contains the offset in the buffer
* 'buf', where data can be written. When this function writes any data
* in the auxiliary data, the offset is incremented accordingly. This
* parameter must not be NULL.
*
* Return value: Returns NULL on failure and 'ret' on success.
*
* See also: get_hostent_from_response()
*/
static struct hostent *
get_hostent_from_etc_hosts(val_context_t * ctx,
const char *name,
int af,
struct hostent *ret,
char *buf, int buflen, int *offset)
{
int orig_offset = 0;
struct hosts *hs = NULL;
struct hosts *h_prev = NULL;
if ((ret == NULL) || (buf == NULL) || (offset == NULL)
|| (*offset < 0)) {
return NULL;
}
/*
* Parse the /etc/hosts file
*/
hs = parse_etc_hosts(name);
orig_offset = *offset;
memset(ret, 0, sizeof(struct hostent));
/*
* XXX: todo -- can hs have more than one element ?
*/
while (hs) {
struct sockaddr_in sa;
#if defined( WIN32 )
size_t addrlen4 = sizeof(struct sockaddr_in);
#endif
#ifdef VAL_IPV6
struct sockaddr_in6 sa6;
#if defined( WIN32 )
size_t addrlen6 = sizeof(struct sockaddr_in6);
#endif
#endif
char addr_buf[INET6_ADDRSTRLEN];
int i, alias_count;
int len = 0;
const char *addr = NULL;
size_t buflen = INET6_ADDRSTRLEN;
if ((af == AF_INET)
&& (INET_PTON(AF_INET, hs->address, ((struct sockaddr *)&sa), &addrlen4) > 0)) {
INET_NTOP(AF_INET, (&sa), sizeof(sa), addr_buf, buflen, addr);
val_log(ctx, LOG_DEBUG, "get_hostent_from_etc_hosts(): type of address is IPv4");
val_log(ctx, LOG_DEBUG, "get_hostent_from_etc_hosts(): Address is: %s",
addr
);
}
#ifdef VAL_IPV6
else if ((af == AF_INET6)
&& (INET_PTON(AF_INET6, hs->address, ((struct sockaddr *)&sa6), &addrlen6) > 0)) {
INET_NTOP(AF_INET6, (&sa6), sizeof(sa6), addr_buf, buflen, addr);
val_log(ctx, LOG_DEBUG, "get_hostent_from_etc_hosts(): type of address is IPv6");
val_log(ctx, LOG_DEBUG, "get_hostent_from_etc_hosts(): Address is: %s",
addr
);
}
#endif
else {
/*
* not a valid address ... skip this line
*/
val_log(ctx, LOG_WARNING,
"get_hostent_from_etc_hosts(): error in address format: %s",
hs->address);
h_prev = hs;
hs = hs->next;
FREE_HOSTS(h_prev);
continue;
}
// Name
len =
(hs->canonical_hostname ==
NULL) ? 0 : strlen(hs->canonical_hostname);
if (hs->canonical_hostname) {
ret->h_name = (char *) bufalloc(buf, buflen, offset, len + 1);
if (ret->h_name == NULL) {
goto err;
}
memcpy(ret->h_name, hs->canonical_hostname, len + 1);
} else {
ret->h_name = NULL;
}
// Aliases
alias_count = 0;
while (hs->aliases[alias_count]) {
alias_count++;
}
alias_count++;
ret->h_aliases =
(char **) bufalloc(buf, buflen, offset,
alias_count * sizeof(char *));
if (ret->h_aliases == NULL) {
goto err;
}
for (i = 0; i < alias_count; i++) {
len = (hs->aliases[i] == NULL) ? 0 : strlen(hs->aliases[i]);
if (hs->aliases[i]) {
ret->h_aliases[i] =
(char *) bufalloc(buf, buflen, offset, len + 1);
if (ret->h_aliases[i] == NULL) {
goto err;
}
memcpy(ret->h_aliases[i], hs->aliases[i], len + 1);
} else {
ret->h_aliases[i] = NULL;
}
}
// Addresses
ret->h_addr_list =
(char **) bufalloc(buf, buflen, offset, 2 * sizeof(char *));
if ((ret->h_addr_list == NULL)
|| ((af != AF_INET) && (af != AF_INET6))) {
goto err;
}
if (af == AF_INET) {
ret->h_addrtype = AF_INET;
ret->h_length = sizeof(struct in_addr);
ret->h_addr_list[0] =
(char *) bufalloc(buf, buflen, offset,
sizeof(struct in_addr));
if (ret->h_addr_list[0] == NULL) {
goto err;
}
memcpy(ret->h_addr_list[0], &sa.sin_addr, sizeof(struct in_addr));
ret->h_addr_list[1] = 0;
}
#ifdef VAL_IPV6
else if (af == AF_INET6) {
ret->h_addrtype = AF_INET6;
ret->h_length = sizeof(struct in6_addr);
ret->h_addr_list[0] =
(char *) bufalloc(buf, buflen, offset,
sizeof(struct in6_addr));
if (ret->h_addr_list[0] == NULL) {
goto err;
}
memcpy(ret->h_addr_list[0], &sa6.sin6_addr,
sizeof(struct in6_addr));
ret->h_addr_list[1] = 0;
}
#endif
/*
* clean up host list
*/
while (hs) {
h_prev = hs;
hs = hs->next;
FREE_HOSTS(h_prev);
}
return ret;
}
return NULL;
err:
/*
* clean up host list
*/
while (hs) {
h_prev = hs;
hs = hs->next;
FREE_HOSTS(h_prev);
}
*offset = orig_offset;
return NULL;
} /* get_hostent_from_etc_hosts() */
/*
* Function: val_gethostbyname2_r
*
* Purpose: A validating DNSSEC-aware version of the reentrant gethostbyname2_r
* function. This function supports both IPv4 and IPv6 addresses.
*
* Parameters:
* ctx -- The validation context. Can be NULL for default value.
* name -- The domain name or IP address in string format.
* af -- Address family AF_INET or AF_INET6
* ret -- Pointer to a hostent variable to store the return value.
* This parameter must not be NULL.
* buf -- Pointer to a buffer to store auxiliary data. This
* parameter must not be NULL.
* buflen -- Length of the buffer 'buf'.
* result -- Pointer to a variable of type (struct hostent *). This
* parameter must not be NULL. *result will contain NULL on
* failure and will point to the 'ret' parameter on success.
* h_errnop -- Pointer to an integer variable to return the h_errno error
* code. This parameter must not be NULL.
* val_status -- A pointer to a val_status_t variable to hold the
* returned validation-status value. This parameter
* must not be NULL.
* If successful, *val_status will contain a success
* code. If there is a failure, *val_status will contain
* the validator error code. To test whether the returned
* error code represents a trustworthy status, the caller
* can use the val_istrusted() function.
*
* Return value: 0 on success, and a non-zero error-code on failure.
*
* See also: val_gethostbyname2(), val_gethostbyname_r(), val_istrusted()
*/
int
val_gethostbyname2_r(val_context_t * context,
const char *name,
int af,
struct hostent *ret,
char *buf,
size_t buflen,
struct hostent **result,
int *h_errnop, val_status_t * val_status)
{
struct sockaddr_in sa;
#if defined( WIN32 )
size_t addrlen4 = sizeof(struct sockaddr_in);
#endif
#ifdef VAL_IPV6
struct sockaddr_in6 sa6;
#if defined( WIN32 )
size_t addrlen6 = sizeof(struct sockaddr_in6);
#endif
#endif
int offset = 0;
val_status_t local_ans_status = VAL_OOB_ANSWER;
int trusted = 0;
int retval;
struct val_result_chain *results = NULL;
u_int16_t type;
val_context_t *ctx = NULL;
*val_status = VAL_DONT_KNOW;
if (!name || !ret || !h_errnop || !val_status || !result || !buf) {
goto err;
}
ctx = val_create_or_refresh_context(context); /* does CTX_LOCK_POL_SH */
if (ctx == NULL)
goto err;
if (VAL_NO_ERROR == val_is_local_trusted(ctx, &trusted)) {
if (trusted) {
local_ans_status = VAL_TRUSTED_ANSWER;
}
}
/*
* Check if the address-family is AF_INET and the address is an IPv4 address
*/
if ((af == AF_INET) && (INET_PTON(AF_INET, name, ((struct sockaddr *)&sa), &addrlen4) > 0)) {
memset(ret, 0, sizeof(struct hostent));
// Name
ret->h_name = bufalloc(buf, buflen, &offset, strlen(name) + 1);
if (ret->h_name == NULL) {
goto err;
}
memcpy(ret->h_name, name, strlen(name) + 1);
// Alias
ret->h_aliases =
(char **) bufalloc(buf, buflen, &offset, sizeof(char *));
if (ret->h_aliases == NULL) {
goto err;
}
ret->h_aliases[0] = 0;
// Address
ret->h_addrtype = AF_INET;
ret->h_length = sizeof(struct in_addr);
ret->h_addr_list =
(char **) bufalloc(buf, buflen, &offset, 2 * sizeof(char *));
if (ret->h_addr_list == NULL) {
goto err;
}
ret->h_addr_list[0] =
(char *) bufalloc(buf, buflen, &offset,
sizeof(struct in_addr));
if (ret->h_addr_list[0] == NULL) {
goto err;
}
memcpy(ret->h_addr_list[0], &sa.sin_addr, sizeof(struct in_addr));
ret->h_addr_list[1] = 0;
*val_status = VAL_TRUSTED_ANSWER;
*h_errnop = NETDB_SUCCESS;
*result = ret;
}
#ifdef VAL_IPV6
/*
* Check if the address-family is AF_INET6 and the address is an IPv6 address
*/
else if ((af == AF_INET6)
&& (INET_PTON(AF_INET6, name, ((struct sockaddr *)&sa6), &addrlen6) > 0)) {
memset(ret, 0, sizeof(struct hostent));
// Name
ret->h_name = bufalloc(buf, buflen, &offset, strlen(name) + 1);
if (ret->h_name == NULL) {
goto err;
}
memcpy(ret->h_name, name, strlen(name) + 1);
// Alias
ret->h_aliases =
(char **) bufalloc(buf, buflen, &offset, sizeof(char *));
if (ret->h_aliases == NULL) {
goto err;
}
ret->h_aliases[0] = 0;
// Address
ret->h_addrtype = AF_INET6;
ret->h_length = sizeof(struct in6_addr);
ret->h_addr_list =
(char **) bufalloc(buf, buflen, &offset, 2 * sizeof(char *));
if (ret->h_addr_list == NULL) {
goto err;
}
ret->h_addr_list[0] =
(char *) bufalloc(buf, buflen, &offset,
sizeof(struct in6_addr));
if (ret->h_addr_list[0] == NULL) {
goto err;
}
memcpy(ret->h_addr_list[0], &sa6.sin6_addr, sizeof(struct in6_addr));
ret->h_addr_list[1] = 0;
*val_status = VAL_TRUSTED_ANSWER;
*h_errnop = NETDB_SUCCESS;
*result = ret;
}
#endif
else if (NULL !=
(*result = get_hostent_from_etc_hosts(ctx, name, af,
ret, buf, buflen, &offset))) {
/*
* First check the ETC_HOSTS file
* XXX: TODO check the order in the ETC_HOST_CONF file
*/
*val_status = local_ans_status;
*h_errnop = NETDB_SUCCESS;
} else {
#ifdef VAL_IPV6
if (af == AF_INET6)
type = ns_t_aaaa;
else
#endif
type = ns_t_a;
/*
* Query the validator
*/
if (VAL_NO_ERROR ==
(retval =
val_resolve_and_check(ctx, name, ns_c_in, type,
0,
&results))) {
/*
* Convert the validator result into hostent
*/
*result =
get_hostent_from_response(ctx, af, ret, results,
h_errnop, buf, buflen, &offset, val_status);
} else {
val_log(ctx, LOG_ERR,
"val_gethostbyname2_r(): val_resolve_and_check failed - %s", p_val_err(retval));
}
if (*result == NULL) {
goto err;
} else {
val_free_result_chain(results);
results = NULL;
*h_errnop = NETDB_SUCCESS;
}
}
val_log(ctx, LOG_DEBUG, "val_gethostbyname2_r returned success, herrno = %d, val_status = %s",
*h_errnop, val_status? p_val_status(*val_status) : NULL);
CTX_UNLOCK_POL(ctx);
return 0;
err:
if (result) {
*result = NULL;
}
if (h_errnop)
*h_errnop = NO_RECOVERY;
if (ctx) {
val_log(ctx, LOG_DEBUG, "val_gethostbyname2_r returned failure, herrno = %d, val_status = %s",
*h_errnop, val_status? p_val_status(*val_status) : NULL);
CTX_UNLOCK_POL(ctx);
}
return (NO_RECOVERY);
}
/*
* Function: get_hostent_from_response
*
* Purpose: Converts the linked list of val_result_chain structures obtained
* as a result from the validator into a hostent structure.
*
* Parameters:
* ctx -- The validation context.
* af -- The address family: AF_INET or AF_INET6.
* ret -- Pointer to a hostent structure to return the result.
* This parameter must not be NULL.
* results -- Pointer to a linked list of val_result_chain structures.
* h_errnop -- Pointer to an integer variable to store the h_errno value.
* buf -- A buffer to store auxiliary data. This parameter must not be NULL.
* buflen -- Length of the buffer 'buf'.
* offset -- Pointer to an integer variable that contains the offset in the buffer
* 'buf', where data can be written. When this function writes any data
* in the auxiliary data, the offset is incremented accordingly. This
* parameter must not be NULL.
*
* Return value: Returns NULL on failure and 'ret' on success.
*
* See also: get_hostent_from_etc_hosts()
*/
static struct hostent *
get_hostent_from_response(val_context_t * ctx, int af, struct hostent *ret,
struct val_result_chain *results, int *h_errnop,
char *buf, int buflen, int *offset,
val_status_t * val_status)
{
int alias_count = 0;
int alias_index = 0;
int addr_count = 0;
int addr_index = 0;
int orig_offset = 0;
struct val_result_chain *res;
int validated = 1;
int trusted = 1;
struct val_rrset_rec *rrset;
char *alias_target = NULL;
/*
* Check parameter sanity
*/
if (!results || !h_errnop || !buf || !offset || !ret || !val_status) {
return NULL;
}
*val_status = VAL_DONT_KNOW;
*h_errnop = 0;
orig_offset = *offset;
memset(ret, 0, sizeof(struct hostent));
/*
* Count the number of aliases and addresses in the result
*/
for (res = results; res != NULL; res = res->val_rc_next) {
rrset = res->val_rc_rrset;
if (res->val_rc_alias && rrset) {
val_log(ctx, LOG_DEBUG,
"get_hostent_from_response(): type of record = CNAME");
alias_count++;
continue;
}
// Get a count of aliases and addresses
if (rrset) {
struct val_rr_rec *rr = rrset->val_rrset_data;
while (rr) {
if ((af == AF_INET)
&& (rrset->val_rrset_type == ns_t_a)) {
val_log(ctx, LOG_DEBUG,
"get_hostent_from_response(): type of record = A");
addr_count++;
} else if ((af == AF_INET6)
&& (rrset->val_rrset_type == ns_t_aaaa)) {
val_log(ctx, LOG_DEBUG,
"get_hostent_from_response(): type of record = AAAA");
addr_count++;
}
rr = rr->rr_next;
}
}
}
ret->h_aliases =
(char **) bufalloc(buf, buflen, offset,
(alias_count + 1) * sizeof(char *));
if (ret->h_aliases == NULL) {
goto err;
}
ret->h_aliases[alias_count] = NULL;
ret->h_addr_list =
(char **) bufalloc(buf, buflen, offset,
(addr_count + 1) * sizeof(char *));
if (ret->h_addr_list == NULL) {
goto err;
}
ret->h_addr_list[addr_count] = NULL;
alias_index = alias_count - 1;
if (results == NULL) {
*val_status = VAL_UNTRUSTED_ANSWER;
*h_errnop = HOST_NOT_FOUND;
goto err;
}
/*
* Process the result
*/
for (res = results; res != NULL; res = res->val_rc_next) {
rrset = res->val_rc_rrset;
if (!(validated && val_isvalidated(res->val_rc_status)))
validated = 0;
if (!(trusted && val_istrusted(res->val_rc_status)))
trusted = 0;
/* save the non-existence state */
if (val_does_not_exist(res->val_rc_status)) {
*val_status = res->val_rc_status;
if (res->val_rc_status == VAL_NONEXISTENT_NAME ||
res->val_rc_status == VAL_NONEXISTENT_NAME_NOCHAIN) {
*h_errnop = HOST_NOT_FOUND;
} else {
*h_errnop = NO_DATA;
}
break;
}
if (res->val_rc_alias && rrset) {
// Handle CNAME RRs
if (alias_index >= 0) {
ret->h_aliases[alias_index] =
(char *) bufalloc(buf, buflen, offset,
(strlen(rrset->val_rrset_name) + 1) * sizeof(char));
if (ret->h_aliases[alias_index] == NULL) {
goto err;
}
memcpy(ret->h_aliases[alias_index], rrset->val_rrset_name,
strlen(rrset->val_rrset_name) + 1);
alias_index--;
}
/* save the alias target for later use */
alias_target = res->val_rc_alias;
} else if (rrset) {
if (((af == AF_INET)
&& (rrset->val_rrset_type == ns_t_a))
|| ((af == AF_INET6)
&& (rrset->val_rrset_type == ns_t_aaaa))) {
struct val_rr_rec *rr = rrset->val_rrset_data;
if (!ret->h_name) {
ret->h_name =
(char *) bufalloc(buf, buflen, offset,
(strlen(rrset->val_rrset_name) +
1) * sizeof(char));
if (ret->h_name == NULL) {
goto err;
}
memcpy(ret->h_name, rrset->val_rrset_name, strlen(rrset->val_rrset_name) + 1);
}
while (rr) {
// Handle A and AAAA RRs
ret->h_length = rr->rr_rdata_length;
ret->h_addrtype = af;
ret->h_addr_list[addr_index] =
(char *) bufalloc(buf, buflen, offset,
rr->rr_rdata_length *
sizeof(char));
if (ret->h_addr_list[addr_index] == NULL) {
goto err;
}
memcpy(ret->h_addr_list[addr_index], rr->rr_rdata,
rr->rr_rdata_length);
addr_index++;
rr = rr->rr_next;
}
}
}
}
/* pick up official name from the alias target */
if (!ret->h_name && alias_target) {
ret->h_name = (char *) bufalloc(buf, buflen, offset,
(strlen(alias_target) + 1) * sizeof(char));
if (ret->h_name == NULL) {
goto err;
}
memcpy(ret->h_name, alias_target, strlen(alias_target) + 1);
}
if (addr_count > 0) {
*h_errnop = NETDB_SUCCESS;
if (validated)
*val_status = VAL_VALIDATED_ANSWER;
else if (trusted)
*val_status = VAL_TRUSTED_ANSWER;
else
*val_status = VAL_UNTRUSTED_ANSWER;
} else if (alias_count == 0) {
goto err;
} else if (*h_errnop == 0) {
/* missing a proof of non-existence for alias */
*val_status = VAL_UNTRUSTED_ANSWER;
*h_errnop = NO_DATA;
}
return ret;
err:
*offset = orig_offset;
return NULL;
} /* get_hostent_from_response() */
static void init()
{
int i, n, size;
static int block_count_tab[3] = {6,8,12};
int lum_buffer_size, chrom_buffer_size;
pthread_mutexattr_t mutex_attr;
pthread_mutexattr_init(&mutex_attr);
pthread_mutex_init(&test_lock, &mutex_attr);
bzero(&cur_picture, sizeof(pict_data_s));
mpeg2_initbits();
init_fdct();
init_idct();
init_motion();
init_predict_hv();
init_quantizer_hv();
init_transform_hv();
/* round picture dimensions to nZearest multiple of 16 or 32 */
mb_width = (horizontal_size+15)/16;
mb_height = prog_seq ?
(vertical_size + 15) / 16 :
2 * ((vertical_size + 31) / 32);
mb_height2 = fieldpic ?
mb_height >> 1 :
mb_height; /* for field pictures */
width = 16 * mb_width;
height = 16 * mb_height;
chrom_width = (chroma_format==CHROMA444) ? width : width>>1;
chrom_height = (chroma_format!=CHROMA420) ? height : height>>1;
height2 = fieldpic ? height>>1 : height;
width2 = fieldpic ? width<<1 : width;
chrom_width2 = fieldpic ? chrom_width<<1 : chrom_width;
block_count = block_count_tab[chroma_format-1];
lum_buffer_size = (width*height) +
sizeof(uint8_t) *(width/2)*(height/2) +
sizeof(uint8_t) *(width/4)*(height/4+1);
chrom_buffer_size = chrom_width*chrom_height;
fsubsample_offset = (width)*(height) * sizeof(uint8_t);
qsubsample_offset = fsubsample_offset + (width/2)*(height/2)*sizeof(uint8_t);
rowsums_offset = 0;
colsums_offset = 0;
mb_per_pict = mb_width*mb_height2;
/* clip table */
if (!(clp = (unsigned char *)malloc(1024)))
error("malloc failed\n");
clp+= 384;
for (i=-384; i<640; i++)
clp[i] = (i<0) ? 0 : ((i>255) ? 255 : i);
/* Allocate the frame buffer */
frame_buffers = (uint8_t ***)
bufalloc(2*READ_LOOK_AHEAD*sizeof(uint8_t**));
for(n=0;n<2*READ_LOOK_AHEAD;n++)
{
frame_buffers[n] = (uint8_t **) bufalloc(3*sizeof(uint8_t*));
for (i=0; i<3; i++)
{
frame_buffers[n][i] =
bufalloc( (i==0) ? lum_buffer_size : chrom_buffer_size );
}
}
/* TODO: The ref and aux frame buffers are no redundant! */
for( i = 0 ; i<3; i++)
{
int size = (i==0) ? lum_buffer_size : chrom_buffer_size;
newrefframe[i] = bufalloc(size);
oldrefframe[i] = bufalloc(size);
auxframe[i] = bufalloc(size);
predframe[i] = bufalloc(size);
}
cur_picture.qblocks =
(int16_t (*)[64])bufalloc(mb_per_pict*block_count*sizeof(int16_t [64]));
/* Initialise current transformed picture data tables
These will soon become a buffer for transformed picture data to allow
look-ahead for bit allocation etc.
*/
cur_picture.mbinfo = (
struct mbinfo *)bufalloc(mb_per_pict*sizeof(struct mbinfo));
cur_picture.blocks =
(int16_t (*)[64])bufalloc(mb_per_pict * block_count * sizeof(int16_t [64]));
/* open statistics output file */
if(statname[0]=='-') statfile = stdout;
else
if(!(statfile = fopen(statname,"w")))
{
sprintf(errortext,"Couldn't create statistics output file %s",statname);
error(errortext);
}
ratectl = malloc(processors * sizeof(ratectl_t*));
for(i = 0; i < processors; i++)
ratectl[i] = calloc(1, sizeof(ratectl_t));
/* Start parallel threads */
//printf("init 1\n");
start_motion_engines();
//printf("init 2\n");
start_transform_engines();
//printf("init 3\n");
start_itransform_engines();
//printf("init 4\n");
start_slice_engines();
//printf("init 5\n");
}