void Shell_GetOemInfo()
{
memset(&g_OemInfo, 0, sizeof(OemInfo));
Boot_ReadOemInfo(&g_OemInfo);
PF(DL_MAIN, ("\tTestMode = %s.\n", g_OemInfo.m_isTestMode ? "TURE" : "FALSE"));
PF(DL_MAIN, ("\tisDefaultPrintf = %s.\n", g_OemInfo.m_isDefaultPrintf ? "TURE" : "FALSE"));
}
void Flow::CorrectFlow(FP T, FP p, FP ref_val, FixedValue fv) {
FP res_p = 1.0, res_t = 1.0;
int iter=0;
if(fv == FV_MACH) {
do {
MACH(ref_val);
t0 = T/TAU();
p0 = p/PF();
res_p = fabs((p0-p/PF())/p0);
res_t = fabs((t0-T/TAU())/t0);
Wg(ref_val*Asound());
iter++;
} while ((res_p > 0.0001 || res_t > 0.0001) && iter < 100);
/*
MACH(ref_val);
t0 = T/TAU();
p0 = p/PF();
*/
} else if(fv == FV_VELOCITY) {
do {
MACH(ref_val/Asound());
t0 = T/TAU();
p0 = p/PF();
res_p = fabs((p0-p/PF())/p0);
res_t = fabs((t0-T/TAU())/t0);
Wg(ref_val);
iter++;
} while ((res_p > 0.0001 || res_t > 0.0001) && iter < 100);
}
}
static void
parse_new_syntax(struct tokenlist *tl)
{
vsb_printf(tl->sb, "Please change \"%.*s\" to \"return(%.*s)\".\n",
PF(tl->t), PF(tl->t));
vcc_ErrWhere(tl, tl->t);
}
void
vcc_ParseRoundRobinDirector(struct vcc *tl)
{
struct token *t_field, *t_be;
int nelem;
struct fld_spec *fs;
const char *first;
char *p;
fs = vcc_FldSpec(tl, "!backend", NULL);
Fc(tl, 0, "\nstatic const struct vrt_dir_round_robin_entry "
"vdrre_%.*s[] = {\n", PF(tl->t_dir));
for (nelem = 0; tl->t->tok != '}'; nelem++) { /* List of members */
first = "";
t_be = tl->t;
vcc_ResetFldSpec(fs);
SkipToken(tl, '{');
Fc(tl, 0, "\t{");
while (tl->t->tok != '}') { /* Member fields */
vcc_IsField(tl, &t_field, fs);
ERRCHK(tl);
if (vcc_IdIs(t_field, "backend")) {
vcc_ParseBackendHost(tl, nelem, &p);
ERRCHK(tl);
AN(p);
Fc(tl, 0, "%s .host = VGC_backend_%s",
first, p);
} else {
ErrInternal(tl);
}
first = ", ";
}
vcc_FieldsOk(tl, fs);
if (tl->err) {
VSB_printf(tl->sb,
"\nIn member host specification starting at:\n");
vcc_ErrWhere(tl, t_be);
return;
}
Fc(tl, 0, " },\n");
vcc_NextToken(tl);
}
Fc(tl, 0, "};\n");
Fc(tl, 0,
"\nstatic const struct vrt_dir_round_robin vgc_dir_priv_%.*s = {\n",
PF(tl->t_dir));
Fc(tl, 0, "\t.name = \"%.*s\",\n", PF(tl->t_dir));
Fc(tl, 0, "\t.nmember = %d,\n", nelem);
Fc(tl, 0, "\t.members = vdrre_%.*s,\n", PF(tl->t_dir));
Fc(tl, 0, "};\n");
}
static void
vcc_Function(struct vcc *tl)
{
int m, i;
vcc_NextToken(tl);
ExpectErr(tl, ID);
m = IsMethod(tl->t);
if (m != -1) {
assert(m < VCL_MET_MAX);
tl->fb = tl->fm[m];
if (tl->mprocs[m] == NULL) {
(void)vcc_AddDef(tl, tl->t, SYM_SUB);
vcc_AddRef(tl, tl->t, SYM_SUB);
tl->mprocs[m] = vcc_AddProc(tl, tl->t);
}
tl->curproc = tl->mprocs[m];
Fb(tl, 1, " /* ... from ");
vcc_Coord(tl, tl->fb, NULL);
Fb(tl, 0, " */\n");
} else {
tl->fb = tl->fc;
i = vcc_AddDef(tl, tl->t, SYM_SUB);
if (i > 1) {
VSB_printf(tl->sb,
"Function %.*s redefined\n", PF(tl->t));
vcc_ErrWhere(tl, tl->t);
return;
}
tl->curproc = vcc_AddProc(tl, tl->t);
Fh(tl, 0, "static int VGC_function_%.*s (struct sess *sp);\n",
PF(tl->t));
Fc(tl, 1, "\nstatic int\n");
Fc(tl, 1, "VGC_function_%.*s (struct sess *sp)\n", PF(tl->t));
}
vcc_NextToken(tl);
tl->indent += INDENT;
Fb(tl, 1, "{\n");
L(tl, vcc_Compound(tl));
if (m == -1) {
/*
* non-method subroutines must have an explicit non-action
* return in case they just fall through the bottom.
*/
Fb(tl, 1, " return(0);\n");
}
Fb(tl, 1, "}\n");
tl->indent -= INDENT;
tl->fb = NULL;
tl->curproc = NULL;
}
static void
vxp_expr_regex(struct vxp *vxp, struct vex_rhs **prhs)
{
const char *errptr;
int erroff;
/* XXX: Caseless option */
AN(prhs);
AZ(*prhs);
if (vxp->t->tok != VAL) {
VSB_printf(vxp->sb, "Expected regular expression got '%.*s' ",
PF(vxp->t));
vxp_ErrWhere(vxp, vxp->t, -1);
return;
}
AN(vxp->t->dec);
ALLOC_OBJ(*prhs, VEX_RHS_MAGIC);
AN(*prhs);
(*prhs)->type = VEX_REGEX;
(*prhs)->val_string = strdup(vxp->t->dec);
(*prhs)->val_regex = VRE_compile(vxp->t->dec, vxp->vre_options,
&errptr, &erroff);
if ((*prhs)->val_regex == NULL) {
AN(errptr);
VSB_printf(vxp->sb, "Regular expression error: %s ", errptr);
vxp_ErrWhere(vxp, vxp->t, erroff);
return;
}
vxp_NextToken(vxp);
}
FP Flow::Pg(FP NewPg) {
FP TmpPI;
if(NewPg >= P0()) return Pg();
TmpPI = NewPg/P0();
PF(TmpPI);
return Pg();
}
List* List_AddTail(List* pHead, List* pNode)
{
List* pListNode = pHead;
Assert(pNode);
pNode->m_pNext = Null;
if(pHead == Null)
{
pNode->m_pPre = Null;
pHead = pNode;
goto END;
}
//Get the tail node
while(pListNode->m_pNext)
{
pListNode = pListNode->m_pNext;
Assert(pListNode != pNode);
}
pListNode->m_pNext = pNode;
pNode->m_pPre = pListNode;
END:
PF(DL_LISTEX, ("List_AddTail(), count=%d\n", List_Count(pHead)));
return pHead;
}
PRIVATE
void
ListFree( void * unit )
{
int done = FALSE;
LIST_UNIT * lu;
ALLOC_UNIT * t = NULL;
ALLOC_UNIT * tbl = NULL;
WAIT_FOR_LOCK( LIST_MUTEX );
for( t = GLOBAL_ALLOC_TABLE; t; t = (ALLOC_UNIT *)tbl -> prev )
tbl = t;
if( !tbl )
{
DBG(PF( "Error freeing list structure.\n" ));
RELEASE_LOCK( LIST_MUTEX );
return;
}
lu = (LIST_UNIT *)( (int) unit - sizeof( int ) );
if( lu -> check != ALLOC_USED_FLAG )
{
ERROR( "Free of a corrupt list node from allocation table." );
RELEASE_LOCK( LIST_MUTEX );
return;
}
do
{
if ( (unit >= tbl -> min) && (unit < tbl -> max) )
{
tbl -> avail++;
lu -> check = ALLOC_FREE_FLAG;
lu -> ptr_a = NULL;
lu -> ptr_b = NULL;
lu -> ptr_c = NULL;
done = TRUE;
break;
}
else
{
tbl = (ALLOC_UNIT *)tbl -> next;
}
} while( tbl && !done );
if ( !done )
ERROR( "Couldn't find list in allocation table\n" );
RELEASE_LOCK( LIST_MUTEX );
}
void CCopyBlock::BuildBlockTagsList(char* ModelClass, char* BlockName, BOOL FromDatalib, CSVector& List)
{
int Cnt = 0;
List.SetSize(16);
Strng Section;
Section.Set("%s(%s)", BlockName, ModelClass);
char Buff[16384];
CProfINIFile PF(FromDatalib ? CfgFiles() : PrjFiles(), (char*)CopyBlkFileName);
CheckCopyBlockVer(PF);
DWORD dw = PF.RdSection(Section(), Buff, sizeof(Buff));
ASSERT(dw<sizeof(Buff)-2); //section too large!!!
char* p = Buff;
while (p[0])
{
int len = strlen(p);
char* Nextp = p;
Nextp += (len + 1);
char* pp = strchr(p, '=');
if (pp)
{
if (Cnt>=List.GetSize())
List.SetSize(List.GetSize()+8);
pp[0] = 0;
char* pValue = &pp[1];
char* ppp = strchr(p, '.');
if (ppp)
List[Cnt].Set("x%s (%s)", ppp, pValue);
else
List[Cnt].Set("%s (%s)", p, pValue);
Cnt++;
}
p = Nextp;
}
List.SetSize(Cnt);
}
void Shell_GetTempPwdEmail(uint8_t *seed)
{
uint8 buff[SECTOR_SIZE] = {0};
PwdMgr_GetTempPwdEmail(buff, seed);
PF(DL_MAIN, ("Email = %s; Pwd=%s; isTempPwd=%d.\n", buff, &buff[256], g_pNvd->m_isTempPsw));
}
void
vcc_ParseBackend(struct vcc *tl)
{
struct token *t_first, *t_be;
struct symbol *sym;
char vgcname[MAX_BACKEND_NAME + 20];
t_first = tl->t;
vcc_NextToken(tl); /* ID: backend */
vcc_ExpectCid(tl); /* ID: name */
ERRCHK(tl);
if (tl->t->e - tl->t->b > MAX_BACKEND_NAME) {
VSB_printf(tl->sb,
"Name of %.*s too long (max %d, is %zu):\n",
PF(t_first), MAX_BACKEND_NAME,
(size_t)(tl->t->e - tl->t->b));
vcc_ErrWhere(tl, tl->t);
return;
}
t_be = tl->t;
vcc_NextToken(tl);
sprintf(vgcname, "vgc_backend_%.*s", PF(t_be));
Fh(tl, 0, "\nstatic struct director *%s;\n", vgcname);
sym = VCC_HandleSymbol(tl, t_be, BACKEND, "%s", vgcname);
ERRCHK(tl);
vcc_ParseHostDef(tl, t_be, vgcname);
ERRCHK(tl);
if (tl->err) {
VSB_printf(tl->sb,
"\nIn %.*s specification starting at:\n", PF(t_first));
vcc_ErrWhere(tl, t_first);
return;
}
if (tl->default_director == NULL || vcc_IdIs(t_be, "default")) {
tl->default_director = sym->rname;
tl->t_default_director = t_be;
}
}
void Shell_BleEnable(Bool isEnable)
{
g_pBle->m_isActiveNew = isEnable;
//Nvd_Write(g_pNvd);
PF(DL_MAIN, ("isBleEnable = %d\n", g_pBle->m_isActiveNew));
}
void CFindTagDlg::OnFind()
{
UpdateData(TRUE);
bPrevAutoAccess = m_AutoAccess;
gs_pPrj->m_bGrfPromptForZoom = m_ZoomPrompt;
gs_pPrj->m_bGrfMoveCursor = m_MoveCursor;
gs_pPrj->m_bGrfRegExpOn = m_RegExpOn;
gs_pPrj->bDoGrfAutoAccess = m_AutoAccess;
BOOL bChanged = 0;
CString sCurSel;
int nIndex = m_TagCombo.GetCurSel();
if (nIndex==CB_ERR)
{
m_TagCombo.GetWindowText(sCurSel);
if (sCurSel.GetLength()>0 && m_TagCombo.FindStringExact(-1, (const char*)sCurSel)==CB_ERR)
{
bChanged = 1;
m_TagCombo.InsertString(0, (const char*)sCurSel);
//m_TagCombo.SetCurSel(0);
}
}
else
{
m_TagCombo.GetLBText(nIndex, sCurSel);
if (nIndex>0)
{
bChanged = 1;
m_TagCombo.DeleteString(nIndex);
m_TagCombo.InsertString(0, (const char*)sCurSel);
//m_TagCombo.SetCurSel(0);
}
}
sFindTag = sCurSel;
if (bChanged && sFindTag.GetLength()>0)
{//list changed, save it...
char Buff[8192];
CProfINIFile PF(PrjIniFile());
int Pos = 0;
for (int i=0; i<16 && i<m_TagCombo.GetCount(); i++)
{
CString FindTxt;
m_TagCombo.GetLBText(i, FindTxt);
int Len = FindTxt.GetLength();
if (Len>0)
{
sprintf(&Buff[Pos], "Find_%02d=%s", i, (const char*)FindTxt);
Pos = Pos + 8 + Len;
Buff[Pos++] = 0;
}
}
Buff[Pos++] = 0;
Buff[Pos++] = 0;
PF.WrSection("FindTags", Buff);
}
bTrendFind = 0;
EndDialog(IDOK);
}
void
vcc_ParseDirector(struct vcc *tl)
{
struct token *t_first;
int isfirst;
t_first = tl->t;
vcc_NextToken(tl); /* ID: director | backend */
vcc_ExpectCid(tl); /* ID: name */
ERRCHK(tl);
if (tl->t->e - tl->t->b > 64) {
VSB_printf(tl->sb,
"Name of %.*s too long (max 64, is %zu):\n",
PF(t_first), (size_t)(tl->t->e - tl->t->b));
vcc_ErrWhere(tl, tl->t);
return;
}
tl->t_dir = tl->t;
vcc_NextToken(tl);
isfirst = tl->ndirector;
if (vcc_IdIs(t_first, "backend")) {
vcc_ParseSimpleDirector(tl);
} else {
VSB_printf(tl->sb,
"\ndirectors are now in VMOD.directors\n");
vcc_ErrWhere(tl, t_first);
return;
}
if (tl->err) {
VSB_printf(tl->sb,
"\nIn %.*s specification starting at:\n", PF(t_first));
vcc_ErrWhere(tl, t_first);
return;
}
if (isfirst == 1 || vcc_IdIs(tl->t_dir, "default")) {
tl->defaultdir = tl->ndirector - 1;
tl->t_defaultdir = tl->t_dir;
}
tl->t_dir = NULL;
}
static void
check_writebit(struct tokenlist *tl, const struct var *vp)
{
if (vp->access == V_RW || vp->access == V_WO)
return;
vsb_printf(tl->sb, "Variable %.*s cannot be modified.\n", PF(tl->t));
vcc_ErrWhere(tl, tl->t);
}
int Pixel_to_JPG(const unsigned char *pixelBuff, int pixelSize, int pixelFmt, int pixelWidth, int pixelHeight, unsigned char *jpgBuff, int *jpgSize) {
AVFormatContext *formatContext;
AVOutputFormat *outputFormat;
AVIOContext *ioContext;
AVStream *stream;
AVCodecContext *codecContext;
AVCodec *codec;
AVFrame *frame;
AVPacket packet;
int ioRet;
int codecRet;
int gotPacket;
int pixelSizeMin;
int result = -1;
av_register_all();
formatContext = avformat_alloc_context();
outputFormat = av_guess_format("mjpeg", NULL, NULL);
ioContext = avio_alloc_context(jpgBuff, *jpgSize, 0, NULL, NULL, NULL, NULL);
formatContext->oformat = outputFormat;
formatContext->pb = ioContext;
stream = av_new_stream(formatContext, 0);
codecContext = stream->codec;
codecContext->codec_id = outputFormat->video_codec;
codecContext->codec_type = AVMEDIA_TYPE_VIDEO;
codecContext->pix_fmt = (enum AVPixelFormat)PF(pixelFmt);
codecContext->width = pixelWidth;
codecContext->height = pixelHeight;
codecContext->time_base.num = 1;
codecContext->time_base.den = 25;
codec = avcodec_find_encoder(codecContext->codec_id);
avcodec_open2(codecContext, codec, NULL);
avformat_write_header(formatContext, NULL);
pixelSizeMin = avpicture_get_size(codecContext->pix_fmt, codecContext->width, codecContext->height);
if (pixelSizeMin <= pixelSize) {
av_new_packet(&packet, pixelSizeMin);
frame = avcodec_alloc_frame();
avpicture_fill((AVPicture *)frame, pixelBuff, codecContext->pix_fmt, codecContext->width, codecContext->height);
codecRet = avcodec_encode_video2(codecContext, &packet, frame, &gotPacket);
if (0 <= codecRet && 1 == gotPacket) {
av_write_frame(formatContext, &packet);
if (packet.size <= *jpgSize) {
*jpgSize = packet.size;
result = *jpgSize;
}
}
avcodec_free_frame(&frame);
av_free_packet(&packet);
}
av_write_trailer(formatContext);
av_free(ioContext);
avcodec_close(codecContext);
avformat_free_context(formatContext);
return result;
}
//Desarrollo Funcion mostrarVector
void mostrarVector (int v [], int cont)
{
int i;
for (i=0; i < cont; i++)
{
PF ("\n\n%d", v [i]);
}
}
double Linear_Eeq::DH_Diso(const PlasticFlow& plastic_flow, const stresstensor& Stre,
const straintensor& Stra, const MaterialParameter& material_parameter)
{
double twoOthree = 2.0/3.0;
double L = getLinearFactor(material_parameter);
straintensor PF = plastic_flow.PlasticFlowTensor(Stre, Stra, material_parameter);
tensor dmOdq = plastic_flow.Dm_Diso(Stre, Stra, material_parameter);
double m_eq = sqrt(twoOthree * (PF("mn")*PF("mn")).trace());
double scalar1 = (PF("mn")*dmOdq("mn")).trace();
double scalar2 = scalar1 * twoOthree * L;
if (m_eq != 0.0)
scalar2 *= (1.0/m_eq);
else
scalar2 = 0.0;
return scalar2;
}
static void
vxp_ErrToken(const struct vxp *vxp, const struct token *t)
{
if (t->tok == EOI)
VSB_printf(vxp->sb, "end of input");
else
VSB_printf(vxp->sb, "'%.*s'", PF(t));
}
void
vcc_ParseLeastBusyDirector(struct tokenlist *tl, const struct token *t_policy,
const struct token *t_dir)
{
struct token *t_field, *t_be;
int nbh, nelem;
struct fld_spec *fs;
const char *first;
fs = vcc_FldSpec(tl, "!backend", NULL);
Fc(tl, 0, "\nstatic const struct vrt_dir_least_busy_entry "
"vdrre_%.*s[] = {\n", PF(t_dir));
for (nelem = 0; tl->t->tok != '}'; nelem++) { /* List of members */
first = "";
t_be = tl->t;
vcc_ResetFldSpec(fs);
nbh = -1;
ExpectErr(tl, '{');
vcc_NextToken(tl);
Fc(tl, 0, "\t{");
while (tl->t->tok != '}') { /* Member fields */
vcc_IsField(tl, &t_field, fs);
ERRCHK(tl);
if (vcc_IdIs(t_field, "backend")) {
vcc_ParseBackendHost(tl, &nbh,
t_dir, t_policy, nelem);
Fc(tl, 0, "%s .host = &bh_%d", first, nbh);
ERRCHK(tl);
} else {
ErrInternal(tl);
}
first = ", ";
}
vcc_FieldsOk(tl, fs);
if (tl->err) {
vsb_printf(tl->sb,
"\nIn member host specification starting at:\n");
vcc_ErrWhere(tl, t_be);
return;
}
Fc(tl, 0, " },\n");
vcc_NextToken(tl);
}
Fc(tl, 0, "};\n");
Fc(tl, 0,
"\nstatic const struct vrt_dir_least_busy vdrr_%.*s = {\n",
PF(t_dir));
Fc(tl, 0, "\t.name = \"%.*s\",\n", PF(t_dir));
Fc(tl, 0, "\t.nmember = %d,\n", nelem);
Fc(tl, 0, "\t.members = vdrre_%.*s,\n", PF(t_dir));
Fc(tl, 0, "};\n");
Fi(tl, 0, "\tVRT_init_dir_least_busy("
"cli, &VGC_backend_%.*s , &vdrr_%.*s);\n", PF(t_dir), PF(t_dir));
Ff(tl, 0, "\tVRT_fini_dir(cli, VGC_backend_%.*s);\n", PF(t_dir));
}
void CDDEStatsDlg::OnOK()
{
RECT Rect;
GetWindowRect(&Rect);
CProfINIFile PF(PrjIniFile());
PF.WrInt("General", "DDEXPos", Rect.left);
PF.WrInt("General", "DDEYPos", Rect.top);
CDialog::OnOK();
DestroyWindow();
}
static void
vxp_expr_num(struct vxp *vxp, struct vex_rhs **prhs, int vxid)
{
char *endptr;
AN(prhs);
AZ(*prhs);
if (vxp->t->tok != VAL) {
VSB_printf(vxp->sb, "Expected number got '%.*s' ", PF(vxp->t));
vxp_ErrWhere(vxp, vxp->t, -1);
return;
}
AN(vxp->t->dec);
ALLOC_OBJ(*prhs, VEX_RHS_MAGIC);
AN(*prhs);
if (strchr(vxp->t->dec, '.')) {
(*prhs)->type = VEX_FLOAT;
(*prhs)->val_float = VNUM(vxp->t->dec);
if (isnan((*prhs)->val_float)) {
VSB_printf(vxp->sb, "Floating point parse error ");
vxp_ErrWhere(vxp, vxp->t, -1);
return;
}
} else {
(*prhs)->type = VEX_INT;
(*prhs)->val_int = strtoll(vxp->t->dec, &endptr, 0);
while (isspace(*endptr))
endptr++;
if (*endptr != '\0') {
VSB_printf(vxp->sb, "Integer parse error ");
vxp_ErrWhere(vxp, vxp->t, -1);
return;
}
}
if (vxid && (*prhs)->type != VEX_INT) {
VSB_printf(vxp->sb, "Expected integer got '%.*s' ",
PF(vxp->t));
vxp_ErrWhere(vxp, vxp->t, 0);
return;
}
vxp_NextToken(vxp);
}
static int query_formats(AVFilterContext *ctx)
{
static const enum PixelFormat pix_fmts[] = {
AV_PIX_FMT_GRAY8, AV_PIX_FMT_GRAY16,
#define PF_NOALPHA(suf) AV_PIX_FMT_YUV420##suf, AV_PIX_FMT_YUV422##suf, AV_PIX_FMT_YUV444##suf
#define PF_ALPHA(suf) AV_PIX_FMT_YUVA420##suf, AV_PIX_FMT_YUVA422##suf, AV_PIX_FMT_YUVA444##suf
#define PF(suf) PF_NOALPHA(suf), PF_ALPHA(suf)
PF(P), PF(P9), PF(P10), PF_NOALPHA(P12), PF_NOALPHA(P14), PF(P16),
AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV410P,
AV_PIX_FMT_YUVJ411P, AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVJ422P,
AV_PIX_FMT_YUVJ440P, AV_PIX_FMT_YUVJ444P,
AV_PIX_FMT_GBRP, AV_PIX_FMT_GBRP9, AV_PIX_FMT_GBRP10,
AV_PIX_FMT_GBRP12, AV_PIX_FMT_GBRP14, AV_PIX_FMT_GBRP16,
AV_PIX_FMT_GBRAP, AV_PIX_FMT_GBRAP16,
AV_PIX_FMT_NONE
};
ff_set_common_formats(ctx, ff_make_format_list(pix_fmts));
return 0;
}
static void pi_rcv_check_and_fix_lid(osm_log_t * log, ib_port_info_t * pi,
osm_physp_t * p)
{
if (PF(cl_ntoh16(pi->base_lid) > IB_LID_UCAST_END_HO)) {
OSM_LOG(log, OSM_LOG_ERROR, "ERR 0F04: "
"Got invalid base LID %u from the network. "
"Corrected to %u\n", cl_ntoh16(pi->base_lid),
cl_ntoh16(p->port_info.base_lid));
pi->base_lid = p->port_info.base_lid;
}
}
static int query_formats(AVFilterContext *ctx)
{
static const enum AVPixelFormat pix_fmts[] = {
AV_PIX_FMT_GRAY8, AV_PIX_FMT_GRAY9, AV_PIX_FMT_GRAY10,
AV_PIX_FMT_GRAY12, AV_PIX_FMT_GRAY16,
AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV444P,
AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV410P,
AV_PIX_FMT_YUVJ411P, AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVJ422P,
AV_PIX_FMT_YUVJ440P, AV_PIX_FMT_YUVJ444P,
AV_PIX_FMT_GBRP,
#define PF(suf) AV_PIX_FMT_YUV420##suf, AV_PIX_FMT_YUV422##suf, AV_PIX_FMT_YUV444##suf, AV_PIX_FMT_GBR##suf
PF(P9), PF(P10), PF(P12), PF(P14), PF(P16),
AV_PIX_FMT_NONE
};
AVFilterFormats *fmts_list = ff_make_format_list(pix_fmts);
if (!fmts_list)
return AVERROR(ENOMEM);
return ff_set_common_formats(ctx, fmts_list);
}
const tensor& Linear_Eeq::DH_Ds(const PlasticFlow& plastic_flow, const stresstensor& Stre,
const straintensor& Stra, const MaterialParameter& material_parameter)
{
double twoOthree = 2.0/3.0;
double L = getLinearFactor(material_parameter);
straintensor PF = plastic_flow.PlasticFlowTensor(Stre, Stra, material_parameter);
tensor dmOds = plastic_flow.Dm_Ds(Stre, Stra, material_parameter);
double m_eq = sqrt(twoOthree * (PF("mn")*PF("mn")).trace());
tensor tensor1 = PF("ij") * dmOds("ijmn");
tensor1.null_indices();
tensor tensor2 = tensor1 * (twoOthree * L);
if (m_eq != 0.0)
ScalarEvolution::SE_tensorR2 = tensor2 *(1.0/m_eq);
else
ScalarEvolution::SE_tensorR2 = tensor2 *0.0;
return ScalarEvolution::SE_tensorR2;
}
void
vcc_Eval_Backend(struct vcc *tl, struct expr **e, const struct symbol *sym)
{
assert(sym->kind == SYM_BACKEND);
vcc_ExpectCid(tl);
vcc_AddRef(tl, tl->t, SYM_BACKEND);
*e = vcc_mk_expr(BACKEND, "VGCDIR(_%.*s)", PF(tl->t));
vcc_NextToken(tl);
}
void
vcc_ErrToken(const struct tokenlist *tl, const struct token *t)
{
if (t->tok == EOI)
vsb_printf(tl->sb, "end of input");
else if (t->tok == CSRC)
vsb_printf(tl->sb, "C{ ... }C");
else
vsb_printf(tl->sb, "'%.*s'", PF(t));
}
static void
parse_call(struct vcc *tl)
{
vcc_NextToken(tl);
ExpectErr(tl, ID);
vcc_AddCall(tl, tl->t);
vcc_AddRef(tl, tl->t, SYM_SUB);
Fb(tl, 1, "if (VGC_function_%.*s(ctx))\n", PF(tl->t));
Fb(tl, 1, "\treturn (1);\n");
vcc_NextToken(tl);
}
