int tdb_rec_write(struct tdb_context *tdb, tdb_off_t offset, struct list_struct *rec)
{
struct list_struct r = *rec;
return tdb->methods->tdb_write(tdb, offset, CONVERT(r), sizeof(r));
}
//---------------------------------------------------------------------------
void __fastcall TQrySaleForm::btnQryYearClick(TObject *Sender)
{
CString szSQL = "";
/////////////////////////////////////////////////////////////////////////////////////////////
//业绩查询
szSQL = "select op_code_sl, isnull(busi_volume_cur,0) gross, \
dbo.gen_should_com(busi_volume_cur, dbo.gen_new_cli_prize_yearmonth(year_month,op_code_sl), busi_volume_base, ratio) should_com, \
cast(100*(1-isnull(busi_volume_cur,0)/isnull(busi_volume_base,100)) as decimal(9,2)) as pect_busi, \
case sign(busi_volume_base-busi_volume_cur) \
when 1 then (busi_volume_base-busi_volume_cur)\
else 0 end as last_busi,\
*\
from commition \
where 1=1 ";
if (g_theOperator.op_class==E_OPERATOR_TYPE_SALER){
szSQL += " and op_code_sl="; szSQL += Str2DBString(g_theOperator.op_code);
}
if (!cbbYear->Text.IsEmpty()){
szSQL += " and year(year_month)="; szSQL += Str2DBString(cbbYear->Text.c_str());
}
if (!cbbMonth->Text.IsEmpty()){
szSQL += " and month(year_month)="; szSQL += Str2DBString(cbbMonth->Text.c_str());
}
szSQL += "order by year_month, op_code_sl";
Edit1->Text = AnsiString(szSQL);
//run
RunSQL(szSQL, true);
if (dm1->Query1->Eof){
ShowMessage("记录不存在");
}
lvTask->Clear();
//show
double sum_should_com = 0;
while(!dm1->Query1->Eof)
{
TListItem *pItem = lvTask->Items->Add();
double should_com = dm1->Query1->FieldByName("should_com")->AsFloat;
sum_should_com += should_com;
pItem->Caption = dm1->Query1->FieldByName("op_code_sl")->AsString;
pItem->SubItems->Add(dm1->Query1->FieldByName("gross")->AsString);
pItem->SubItems->Add(should_com);
pItem->SubItems->Add(0.85*should_com);
pItem->SubItems->Add(0.15*should_com);
pItem->SubItems->Add(dm1->Query1->FieldByName("passed")->AsString);
pItem->SubItems->Add(dm1->Query1->FieldByName("busi_volume_cur")->AsString);
pItem->SubItems->Add(dm1->Query1->FieldByName("last_busi")->AsString);
double last_busi = dm1->Query1->FieldByName("pect_busi")->AsFloat;
last_busi = last_busi<0?0:last_busi;
pItem->SubItems->Add(last_busi);
dm1->Query1->Next();
}
lbTotalPrize->Caption = 0.85*sum_should_com;
/////////////////////////////////////////////////////////////////////////////////////////////
//回扣查询
szSQL = "select *, \
CONVERT(varchar, acceptdate, 111) as date_accept, \
case year(date) when 2099 then '-' else CONVERT(varchar, date, 111) end as date_kb \
from detail_kb, operation \
where dkoid=oid ";
if (g_theOperator.op_class==E_OPERATOR_TYPE_SALER){
szSQL += " and op_code_sl="; szSQL += Str2DBString(g_theOperator.op_code);
}
if (!cbbClShortName->Text.IsEmpty()){
szSQL += " and cl_shortname="; szSQL += Str2DBString(cbbClShortName->Text.c_str());
}
if (!cbbYear->Text.IsEmpty()){
szSQL += " and year(acceptdate)="; szSQL += Str2DBString(cbbYear->Text.c_str());
}
if (!cbbMonth->Text.IsEmpty()){
szSQL += " and month(acceptdate)="; szSQL += Str2DBString(cbbMonth->Text.c_str());
}
RunSQL(szSQL, true);
if (dm1->Query1->Eof){
ShowMessage("回扣记录不存在");
}
lvKB->Clear();
while(!dm1->Query1->Eof)
{
TListItem *pItem = lvKB->Items->Add();
pItem->Caption = dm1->Query1->FieldByName("oid")->AsString;
pItem->SubItems->Add(dm1->Query1->FieldByName("date_accept")->AsString);
pItem->SubItems->Add(dm1->Query1->FieldByName("cl_shortname")->AsString);
pItem->SubItems->Add(dm1->Query1->FieldByName("kb_value")->AsFloat);
pItem->SubItems->Add(dm1->Query1->FieldByName("date_kb")->AsString);
dm1->Query1->Next();
}
}
int tdb_ofs_write(struct tdb_context *tdb, tdb_off_t offset, tdb_off_t *d)
{
tdb_off_t off = *d;
return tdb->methods->tdb_write(tdb, offset, CONVERT(off), sizeof(*d));
}
/* Adjust pointer to point at first requested element, convert to
* floating point, populate VB->AttribPtr[].
*/
static void _tnl_import_array( struct gl_context *ctx,
GLuint attrib,
GLuint count,
const struct gl_client_array *input,
const GLubyte *ptr )
{
TNLcontext *tnl = TNL_CONTEXT(ctx);
struct vertex_buffer *VB = &tnl->vb;
GLuint stride = input->StrideB;
if (input->Type != GL_FLOAT) {
const GLuint sz = input->Size;
GLubyte *buf = get_space(ctx, count * sz * sizeof(GLfloat));
GLfloat *fptr = (GLfloat *)buf;
switch (input->Type) {
case GL_BYTE:
CONVERT(GLbyte, BYTE_TO_FLOAT);
break;
case GL_UNSIGNED_BYTE:
if (input->Format == GL_BGRA) {
/* See GL_EXT_vertex_array_bgra */
convert_bgra_to_float(input, ptr, fptr, count);
}
else {
CONVERT(GLubyte, UBYTE_TO_FLOAT);
}
break;
case GL_SHORT:
CONVERT(GLshort, SHORT_TO_FLOAT);
break;
case GL_UNSIGNED_SHORT:
CONVERT(GLushort, USHORT_TO_FLOAT);
break;
case GL_INT:
CONVERT(GLint, INT_TO_FLOAT);
break;
case GL_UNSIGNED_INT:
CONVERT(GLuint, UINT_TO_FLOAT);
break;
case GL_DOUBLE:
CONVERT(GLdouble, (GLfloat));
break;
case GL_HALF_FLOAT:
convert_half_to_float(input, ptr, fptr, count, sz);
break;
case GL_FIXED:
convert_fixed_to_float(input, ptr, fptr, count);
break;
default:
assert(0);
break;
}
ptr = buf;
stride = sz * sizeof(GLfloat);
}
VB->AttribPtr[attrib] = &tnl->tmp_inputs[attrib];
VB->AttribPtr[attrib]->data = (GLfloat (*)[4])ptr;
VB->AttribPtr[attrib]->start = (GLfloat *)ptr;
VB->AttribPtr[attrib]->count = count;
VB->AttribPtr[attrib]->stride = stride;
VB->AttribPtr[attrib]->size = input->Size;
/* This should die, but so should the whole GLvector4f concept:
*/
VB->AttribPtr[attrib]->flags = (((1<<input->Size)-1) |
VEC_NOT_WRITEABLE |
(stride == 4*sizeof(GLfloat) ? 0 : VEC_BAD_STRIDE));
VB->AttribPtr[attrib]->storage = NULL;
}
Vec3 phyMgr::getGravity() const
{
return CONVERT(_dynamics_world->getGravity());
}
void a52_downmix (sample_t * samples, int acmod, int output, sample_t bias,
level_t clev, level_t slev)
{
/* avoid compiler warning */
(void)clev;
switch (CONVERT (acmod, output & A52_CHANNEL_MASK)) {
case CONVERT (A52_CHANNEL, A52_CHANNEL2):
memcpy (samples, samples + 256, 256 * sizeof (sample_t));
break;
case CONVERT (A52_CHANNEL, A52_MONO):
case CONVERT (A52_STEREO, A52_MONO):
mix_2to1:
mix2to1 (samples, samples + 256, bias);
break;
case CONVERT (A52_2F1R, A52_MONO):
if (slev == 0)
goto mix_2to1;
case CONVERT (A52_3F, A52_MONO):
mix_3to1:
mix3to1 (samples, bias);
break;
case CONVERT (A52_3F1R, A52_MONO):
if (slev == 0)
goto mix_3to1;
case CONVERT (A52_2F2R, A52_MONO):
if (slev == 0)
goto mix_2to1;
mix4to1 (samples, bias);
break;
case CONVERT (A52_3F2R, A52_MONO):
if (slev == 0)
goto mix_3to1;
mix5to1 (samples, bias);
break;
case CONVERT (A52_MONO, A52_DOLBY):
memcpy (samples + 256, samples, 256 * sizeof (sample_t));
break;
case CONVERT (A52_3F, A52_STEREO):
case CONVERT (A52_3F, A52_DOLBY):
mix_3to2:
mix3to2 (samples, bias);
break;
case CONVERT (A52_2F1R, A52_STEREO):
if (slev == 0)
break;
mix21to2 (samples, samples + 256, bias);
break;
case CONVERT (A52_2F1R, A52_DOLBY):
mix21toS (samples, bias);
break;
case CONVERT (A52_3F1R, A52_STEREO):
if (slev == 0)
goto mix_3to2;
mix31to2 (samples, bias);
break;
case CONVERT (A52_3F1R, A52_DOLBY):
mix31toS (samples, bias);
break;
case CONVERT (A52_2F2R, A52_STEREO):
if (slev == 0)
break;
mix2to1 (samples, samples + 512, bias);
mix2to1 (samples + 256, samples + 768, bias);
break;
case CONVERT (A52_2F2R, A52_DOLBY):
mix22toS (samples, bias);
break;
case CONVERT (A52_3F2R, A52_STEREO):
if (slev == 0)
goto mix_3to2;
mix32to2 (samples, bias);
break;
case CONVERT (A52_3F2R, A52_DOLBY):
mix32toS (samples, bias);
break;
case CONVERT (A52_3F1R, A52_3F):
if (slev == 0)
break;
mix21to2 (samples, samples + 512, bias);
break;
case CONVERT (A52_3F2R, A52_3F):
if (slev == 0)
break;
mix2to1 (samples, samples + 768, bias);
mix2to1 (samples + 512, samples + 1024, bias);
break;
case CONVERT (A52_3F1R, A52_2F1R):
mix3to2 (samples, bias);
memcpy (samples + 512, samples + 768, 256 * sizeof (sample_t));
break;
case CONVERT (A52_2F2R, A52_2F1R):
mix2to1 (samples + 512, samples + 768, bias);
break;
case CONVERT (A52_3F2R, A52_2F1R):
mix3to2 (samples, bias);
move2to1 (samples + 768, samples + 512, bias);
break;
case CONVERT (A52_3F2R, A52_3F1R):
mix2to1 (samples + 768, samples + 1024, bias);
break;
case CONVERT (A52_2F1R, A52_2F2R):
memcpy (samples + 768, samples + 512, 256 * sizeof (sample_t));
break;
case CONVERT (A52_3F1R, A52_2F2R):
mix3to2 (samples, bias);
memcpy (samples + 512, samples + 768, 256 * sizeof (sample_t));
break;
case CONVERT (A52_3F2R, A52_2F2R):
mix3to2 (samples, bias);
memcpy (samples + 512, samples + 768, 256 * sizeof (sample_t));
memcpy (samples + 768, samples + 1024, 256 * sizeof (sample_t));
break;
case CONVERT (A52_3F1R, A52_3F2R):
memcpy (samples + 1024, samples + 768, 256 * sizeof (sample_t));
break;
}
}
/**
* Convert attribute data type to float
* If the attribute uses named buffer object replace the bo with newly allocated bo
*/
static void evergreenConvertAttrib(GLcontext *ctx, int count,
const struct gl_client_array *input,
struct StreamDesc *attr)
{
context_t *context = R700_CONTEXT(ctx);
const GLvoid *src_ptr;
GLboolean mapped_named_bo = GL_FALSE;
GLfloat *dst_ptr;
GLuint stride;
stride = (input->StrideB == 0) ? evergreen_getTypeSize(input->Type) * input->Size : input->StrideB;
/* Convert value for first element only */
if (input->StrideB == 0)
{
count = 1;
}
if (input->BufferObj->Name)
{
if (!input->BufferObj->Pointer)
{
ctx->Driver.MapBuffer(ctx, GL_ARRAY_BUFFER, GL_READ_ONLY_ARB, input->BufferObj);
mapped_named_bo = GL_TRUE;
}
src_ptr = ADD_POINTERS(input->BufferObj->Pointer, input->Ptr);
}
else
{
src_ptr = input->Ptr;
}
radeonAllocDmaRegion(&context->radeon, &attr->bo, &attr->bo_offset,
sizeof(GLfloat) * input->Size * count, 32);
radeon_bo_map(attr->bo, 1);
dst_ptr = (GLfloat *)ADD_POINTERS(attr->bo->ptr, attr->bo_offset);
assert(src_ptr != NULL);
switch (input->Type)
{
case GL_DOUBLE:
CONVERT(GLdouble, (GLfloat));
break;
case GL_UNSIGNED_INT:
CONVERT(GLuint, UINT_TO_FLOAT);
break;
case GL_INT:
CONVERT(GLint, INT_TO_FLOAT);
break;
case GL_UNSIGNED_SHORT:
CONVERT(GLushort, USHORT_TO_FLOAT);
break;
case GL_SHORT:
CONVERT(GLshort, SHORT_TO_FLOAT);
break;
case GL_UNSIGNED_BYTE:
assert(input->Format != GL_BGRA);
CONVERT(GLubyte, UBYTE_TO_FLOAT);
break;
case GL_BYTE:
CONVERT(GLbyte, BYTE_TO_FLOAT);
break;
default:
assert(0);
break;
}
radeon_bo_unmap(attr->bo);
if (mapped_named_bo)
{
ctx->Driver.UnmapBuffer(ctx, GL_ARRAY_BUFFER, input->BufferObj);
}
}
nsresult
Convert(uint8_t aIn, BluetoothStatus& aOut)
{
static const BluetoothStatus sStatus[] = {
CONVERT(0x00, STATUS_SUCCESS),
CONVERT(0x01, STATUS_FAIL),
CONVERT(0x02, STATUS_NOT_READY),
CONVERT(0x03, STATUS_NOMEM),
CONVERT(0x04, STATUS_BUSY),
CONVERT(0x05, STATUS_DONE),
CONVERT(0x06, STATUS_UNSUPPORTED),
CONVERT(0x07, STATUS_PARM_INVALID),
CONVERT(0x08, STATUS_UNHANDLED),
CONVERT(0x09, STATUS_AUTH_FAILURE),
CONVERT(0x0a, STATUS_RMT_DEV_DOWN)
};
if (NS_WARN_IF(aIn >= MOZ_ARRAY_LENGTH(sStatus))) {
return NS_ERROR_ILLEGAL_VALUE;
}
aOut = sStatus[aIn];
return NS_OK;
}
nsresult
Convert(BluetoothPropertyType aIn, uint8_t& aOut)
{
static const uint8_t sPropertyType[] = {
CONVERT(PROPERTY_UNKNOWN, 0x00),
CONVERT(PROPERTY_BDNAME, 0x01),
CONVERT(PROPERTY_BDADDR, 0x02),
CONVERT(PROPERTY_UUIDS, 0x03),
CONVERT(PROPERTY_CLASS_OF_DEVICE, 0x04),
CONVERT(PROPERTY_TYPE_OF_DEVICE, 0x05),
CONVERT(PROPERTY_SERVICE_RECORD, 0x06),
CONVERT(PROPERTY_ADAPTER_SCAN_MODE, 0x07),
CONVERT(PROPERTY_ADAPTER_BONDED_DEVICES, 0x08),
CONVERT(PROPERTY_ADAPTER_DISCOVERY_TIMEOUT, 0x09),
CONVERT(PROPERTY_REMOTE_FRIENDLY_NAME, 0x0a),
CONVERT(PROPERTY_REMOTE_RSSI, 0x0b),
CONVERT(PROPERTY_REMOTE_VERSION_INFO, 0x0c),
CONVERT(PROPERTY_REMOTE_DEVICE_TIMESTAMP, 0xff)
};
if (NS_WARN_IF(aIn >= MOZ_ARRAY_LENGTH(sPropertyType))) {
aOut = 0x00; // silences compiler warning
return NS_ERROR_ILLEGAL_VALUE;
}
aOut = sPropertyType[aIn];
return NS_OK;
}
/*
* Create the form hierarchy of widgets.
*/
Widget
Createform(Widget parent)
{
Arg args[256];
Cardinal ac=0;
Boolean argok=False;
Widget form;
Widget tabStack;
Widget scrolledWindow;
Widget text;
Widget form1;
Widget frame;
Widget form2;
Widget radioBox1;
Widget toggleButton4;
Widget toggleButton5;
Widget toggleButton6;
Widget label4;
Widget radioBox;
Widget toggleButton;
Widget toggleButton1;
Widget toggleButton2;
Widget toggleButton3;
Widget label3;
Widget tabStack1;
Widget label;
Widget label1;
Widget label2;
Widget separator;
Widget pushButton;
/*
* Register the converters for the widgets.
*/
RegisterBxConverters(XtWidgetToApplicationContext(parent));
XtInitializeWidgetClass(xmFormWidgetClass);
XtInitializeWidgetClass(xmTabStackWidgetClass);
XtInitializeWidgetClass(xmScrolledWindowWidgetClass);
XtInitializeWidgetClass(xmTextWidgetClass);
XtInitializeWidgetClass(xmFrameWidgetClass);
XtInitializeWidgetClass(xmRowColumnWidgetClass);
XtInitializeWidgetClass(xmToggleButtonWidgetClass);
XtInitializeWidgetClass(xmLabelWidgetClass);
XtInitializeWidgetClass(xmSeparatorWidgetClass);
XtInitializeWidgetClass(xmPushButtonWidgetClass);
ac = 0;
XtSetArg(args[ac], XmNresizePolicy, XmRESIZE_GROW);
ac++;
XtSetArg(args[ac], XmNdialogTitle,
CONVERT(parent, "EnhancementPak TabStack Demo",
XmRXmString, 0, &argok));
if (argok) ac++;
XtSetArg(args[ac], XmNx, 333);
ac++;
XtSetArg(args[ac], XmNy, 277);
ac++;
XtSetArg(args[ac], XmNwidth, 839);
ac++;
XtSetArg(args[ac], XmNheight, 508);
ac++;
XtSetArg(args[ac], XmNbackground,
CONVERT(parent, "#ccc",
XmRPixel, 0, &argok));
if (argok) ac++;
XtSetArg(args[ac], XmNforeground,
CONVERT(parent, "Black",
XmRPixel, 0, &argok));
if (argok) ac++;
form = XmCreateForm(parent,
"form",
args,
ac);
ac = 0;
XtSetArg(args[ac], XmNresizePolicy, XmRESIZE_GROW);
ac++;
XtSetArg(args[ac], XmNx, 10);
ac++;
XtSetArg(args[ac], XmNy, 10);
ac++;
XtSetArg(args[ac], XmNwidth, 818);
ac++;
XtSetArg(args[ac], XmNheight, 436);
ac++;
XtSetArg(args[ac], XmNbackground,
CONVERT(parent, "#ccc",
XmRPixel, 0, &argok));
if (argok) ac++;
XtSetArg(args[ac], XmNfontList,
CONVERT(parent, "-*-helvetica-bold-r-*-*-*-120-*-*-*-*-iso8859-1",
XmRFontList, 0, &argok));
if (argok) ac++;
XtSetArg(args[ac], XmNforeground,
CONVERT(parent, "Black",
XmRPixel, 0, &argok));
if (argok) ac++;
tabStack = XmCreateTabStack(form,
"tabStack",
args,
ac);
XtManageChild(tabStack);
ac = 0;
XtSetArg(args[ac], XmNscrollingPolicy, XmAPPLICATION_DEFINED);
ac++;
XtSetArg(args[ac], XmNx, -794);
ac++;
XtSetArg(args[ac], XmNy, 56);
ac++;
XtSetArg(args[ac], XmNbackground,
CONVERT(parent, "#ccc",
XmRPixel, 0, &argok));
if (argok) ac++;
XtSetArg(args[ac], XmNforeground,
CONVERT(parent, "Black",
XmRPixel, 0, &argok));
if (argok) ac++;
scrolledWindow = XmCreateScrolledWindow(tabStack,
"scrolledWindow",
args,
ac);
XtManageChild(scrolledWindow);
ac = 0;
XtSetArg(args[ac], XmNbackground,
CONVERT(parent, "LightBlue",
XmRPixel, 0, &argok));
if (argok) ac++;
XtSetArg(args[ac], XmNvalue, "The XmTabStack widget manages a group of widgets such that only one widget\n\
in the group is visible at a time. Each child is associated with a \"tab\"\n\
that displays a text label and/or a pixmap. By selecting the \"tab\" the user\n\
interactively determines which child is displayed. This widget exhibits\n\
behavior similar to the Microsoft Windows(TM) Tab Control.\n\
\n\
The tabs can be configured to appear above, below, to the right, and to the\n\
left of a work area with the text oriented in any of the four cardinal\n\
directions.\n\
\n\
The TabStack allows the user to select, either by pointer or keyboard\n\
traversal, tabs. When a tab is selected it changes appearance so that it\n\
appears to be raised above the other tabs. When a tab is selected the\n\
child associated with the tab is made visible. One tab is selected at all\n\
times.");
ac++;
XtSetArg(args[ac], XmNeditMode, XmMULTI_LINE_EDIT);
ac++;
XtSetArg(args[ac], XmNfontList,
CONVERT(parent, "-*-helvetica-bold-r-*-*-*-120-*-*-*-*-iso8859-1",
XmRFontList, 0, &argok));
if (argok) ac++;
XtSetArg(args[ac], XmNforeground,
CONVERT(parent, "Black",
XmRPixel, 0, &argok));
if (argok) ac++;
text = XmCreateText(scrolledWindow,
"text",
args,
ac);
XtManageChild(text);
ac = 0;
XtSetArg(args[ac], XmNresizePolicy, XmRESIZE_GROW);
ac++;
XtSetArg(args[ac], XmNx, 12);
ac++;
XtSetArg(args[ac], XmNy, 56);
ac++;
XtSetArg(args[ac], XmNbackground,
CONVERT(parent, "#ccc",
XmRPixel, 0, &argok));
if (argok) ac++;
XtSetArg(args[ac], XmNforeground,
CONVERT(parent, "Black",
XmRPixel, 0, &argok));
if (argok) ac++;
form1 = XmCreateForm(tabStack,
"form1",
args,
ac);
XtManageChild(form1);
ac = 0;
XtSetArg(args[ac], XmNshadowType, XmSHADOW_IN);
ac++;
XtSetArg(args[ac], XmNx, 484);
ac++;
XtSetArg(args[ac], XmNy, 10);
ac++;
XtSetArg(args[ac], XmNbackground,
CONVERT(parent, "#ccc",
XmRPixel, 0, &argok));
if (argok) ac++;
XtSetArg(args[ac], XmNforeground,
CONVERT(parent, "Black",
XmRPixel, 0, &argok));
if (argok) ac++;
frame = XmCreateFrame(form1,
"frame",
args,
ac);
XtManageChild(frame);
ac = 0;
XtSetArg(args[ac], XmNresizePolicy, XmRESIZE_GROW);
ac++;
XtSetArg(args[ac], XmNx, 2);
ac++;
XtSetArg(args[ac], XmNy, 2);
ac++;
XtSetArg(args[ac], XmNbackground,
CONVERT(parent, "#ccc",
XmRPixel, 0, &argok));
if (argok) ac++;
XtSetArg(args[ac], XmNforeground,
CONVERT(parent, "Black",
XmRPixel, 0, &argok));
if (argok) ac++;
form2 = XmCreateForm(frame,
"form2",
args,
ac);
XtManageChild(form2);
ac = 0;
XtSetArg(args[ac], XmNisHomogeneous, False);
ac++;
XtSetArg(args[ac], XmNnumColumns, 2);
ac++;
XtSetArg(args[ac], XmNx, 89);
ac++;
XtSetArg(args[ac], XmNy, 89);
ac++;
XtSetArg(args[ac], XmNbackground,
CONVERT(parent, "#ccc",
XmRPixel, 0, &argok));
if (argok) ac++;
XtSetArg(args[ac], XmNforeground,
CONVERT(parent, "Black",
XmRPixel, 0, &argok));
if (argok) ac++;
radioBox1 = XmCreateRadioBox(form2,
"radioBox1",
args,
ac);
XtManageChild(radioBox1);
ac = 0;
XtSetArg(args[ac], XmNlabelString,
CONVERT(parent, "Round",
XmRXmString, 0, &argok));
if (argok) ac++;
XtSetArg(args[ac], XmNbackground,
CONVERT(parent, "#ccc",
XmRPixel, 0, &argok));
if (argok) ac++;
XtSetArg(args[ac], XmNfontList,
CONVERT(parent, "-*-helvetica-bold-r-*-*-*-120-*-*-*-*-iso8859-1",
XmRFontList, 0, &argok));
if (argok) ac++;
XtSetArg(args[ac], XmNforeground,
CONVERT(parent, "Black",
XmRPixel, 0, &argok));
if (argok) ac++;
toggleButton4 = XmCreateToggleButton(radioBox1,
"toggleButton4",
args,
ac);
XtManageChild(toggleButton4);
XtAddCallback(toggleButton4, XmNvalueChangedCallback, BxSetValuesCB, (XtPointer)"tabStack1.tabStyle=rounded");
ac = 0;
XtSetArg(args[ac], XmNlabelString,
CONVERT(parent, "Beveled",
XmRXmString, 0, &argok));
if (argok) ac++;
XtSetArg(args[ac], XmNset, True);
ac++;
XtSetArg(args[ac], XmNbackground,
CONVERT(parent, "#ccc",
XmRPixel, 0, &argok));
if (argok) ac++;
XtSetArg(args[ac], XmNfontList,
CONVERT(parent, "-*-helvetica-bold-r-*-*-*-120-*-*-*-*-iso8859-1",
XmRFontList, 0, &argok));
if (argok) ac++;
XtSetArg(args[ac], XmNforeground,
CONVERT(parent, "Black",
XmRPixel, 0, &argok));
if (argok) ac++;
toggleButton5 = XmCreateToggleButton(radioBox1,
"toggleButton5",
args,
ac);
XtManageChild(toggleButton5);
XtAddCallback(toggleButton5, XmNvalueChangedCallback, BxSetValuesCB, (XtPointer)"tabStack1.tabStyle=beveled");
ac = 0;
XtSetArg(args[ac], XmNlabelString,
CONVERT(parent, "Square",
XmRXmString, 0, &argok));
if (argok) ac++;
XtSetArg(args[ac], XmNbackground,
CONVERT(parent, "#ccc",
XmRPixel, 0, &argok));
if (argok) ac++;
XtSetArg(args[ac], XmNfontList,
CONVERT(parent, "-*-helvetica-bold-r-*-*-*-120-*-*-*-*-iso8859-1",
XmRFontList, 0, &argok));
if (argok) ac++;
XtSetArg(args[ac], XmNforeground,
CONVERT(parent, "Black",
XmRPixel, 0, &argok));
if (argok) ac++;
toggleButton6 = XmCreateToggleButton(radioBox1,
"toggleButton6",
args,
ac);
XtManageChild(toggleButton6);
XtAddCallback(toggleButton6, XmNvalueChangedCallback, BxSetValuesCB, (XtPointer)"tabStack1.tabStyle=squared");
ac = 0;
XtSetArg(args[ac], XmNlabelString,
CONVERT(parent, "Corners:",
XmRXmString, 0, &argok));
if (argok) ac++;
XtSetArg(args[ac], XmNx, 10);
ac++;
XtSetArg(args[ac], XmNy, 89);
ac++;
XtSetArg(args[ac], XmNbackground,
CONVERT(parent, "#ccc",
XmRPixel, 0, &argok));
if (argok) ac++;
XtSetArg(args[ac], XmNfontList,
CONVERT(parent, "-*-helvetica-bold-r-*-*-*-120-*-*-*-*-iso8859-1",
XmRFontList, 0, &argok));
if (argok) ac++;
XtSetArg(args[ac], XmNforeground,
CONVERT(parent, "Black",
XmRPixel, 0, &argok));
if (argok) ac++;
label4 = XmCreateLabel(form2,
"label4",
args,
ac);
XtManageChild(label4);
ac = 0;
XtSetArg(args[ac], XmNisHomogeneous, False);
ac++;
XtSetArg(args[ac], XmNnumColumns, 2);
ac++;
XtSetArg(args[ac], XmNx, 92);
ac++;
XtSetArg(args[ac], XmNy, 10);
ac++;
XtSetArg(args[ac], XmNbackground,
CONVERT(parent, "#ccc",
XmRPixel, 0, &argok));
if (argok) ac++;
XtSetArg(args[ac], XmNforeground,
CONVERT(parent, "Black",
XmRPixel, 0, &argok));
if (argok) ac++;
radioBox = XmCreateRadioBox(form2,
"radioBox",
args,
ac);
XtManageChild(radioBox);
ac = 0;
XtSetArg(args[ac], XmNlabelString,
CONVERT(parent, "Top",
XmRXmString, 0, &argok));
if (argok) ac++;
XtSetArg(args[ac], XmNset, True);
ac++;
XtSetArg(args[ac], XmNbackground,
CONVERT(parent, "#ccc",
XmRPixel, 0, &argok));
if (argok) ac++;
XtSetArg(args[ac], XmNfontList,
CONVERT(parent, "-*-helvetica-bold-r-*-*-*-120-*-*-*-*-iso8859-1",
XmRFontList, 0, &argok));
if (argok) ac++;
XtSetArg(args[ac], XmNforeground,
CONVERT(parent, "Black",
XmRPixel, 0, &argok));
if (argok) ac++;
toggleButton = XmCreateToggleButton(radioBox,
"toggleButton",
args,
ac);
XtManageChild(toggleButton);
XtAddCallback(toggleButton, XmNvalueChangedCallback, BxSetValuesCB, (XtPointer)"tabStack1.tabSide=top");
ac = 0;
XtSetArg(args[ac], XmNlabelString,
CONVERT(parent, "Bottom",
XmRXmString, 0, &argok));
if (argok) ac++;
XtSetArg(args[ac], XmNbackground,
CONVERT(parent, "#ccc",
XmRPixel, 0, &argok));
if (argok) ac++;
XtSetArg(args[ac], XmNfontList,
CONVERT(parent, "-*-helvetica-bold-r-*-*-*-120-*-*-*-*-iso8859-1",
XmRFontList, 0, &argok));
if (argok) ac++;
XtSetArg(args[ac], XmNforeground,
CONVERT(parent, "Black",
XmRPixel, 0, &argok));
if (argok) ac++;
toggleButton1 = XmCreateToggleButton(radioBox,
"toggleButton1",
args,
ac);
XtManageChild(toggleButton1);
XtAddCallback(toggleButton1, XmNvalueChangedCallback, BxSetValuesCB, (XtPointer)"tabStack1.tabSide=bottom");
ac = 0;
XtSetArg(args[ac], XmNlabelString,
CONVERT(parent, "Right",
XmRXmString, 0, &argok));
if (argok) ac++;
XtSetArg(args[ac], XmNbackground,
CONVERT(parent, "#ccc",
XmRPixel, 0, &argok));
if (argok) ac++;
XtSetArg(args[ac], XmNfontList,
CONVERT(parent, "-*-helvetica-bold-r-*-*-*-120-*-*-*-*-iso8859-1",
XmRFontList, 0, &argok));
if (argok) ac++;
XtSetArg(args[ac], XmNforeground,
CONVERT(parent, "Black",
XmRPixel, 0, &argok));
if (argok) ac++;
toggleButton2 = XmCreateToggleButton(radioBox,
"toggleButton2",
args,
ac);
XtManageChild(toggleButton2);
XtAddCallback(toggleButton2, XmNvalueChangedCallback, BxSetValuesCB, (XtPointer)"tabStack1.tabSide=right");
ac = 0;
XtSetArg(args[ac], XmNlabelString,
CONVERT(parent, "Left",
XmRXmString, 0, &argok));
if (argok) ac++;
XtSetArg(args[ac], XmNbackground,
CONVERT(parent, "#ccc",
XmRPixel, 0, &argok));
if (argok) ac++;
XtSetArg(args[ac], XmNfontList,
CONVERT(parent, "-*-helvetica-bold-r-*-*-*-120-*-*-*-*-iso8859-1",
XmRFontList, 0, &argok));
if (argok) ac++;
XtSetArg(args[ac], XmNforeground,
CONVERT(parent, "Black",
XmRPixel, 0, &argok));
if (argok) ac++;
toggleButton3 = XmCreateToggleButton(radioBox,
"toggleButton3",
args,
ac);
XtManageChild(toggleButton3);
XtAddCallback(toggleButton3, XmNvalueChangedCallback, BxSetValuesCB, (XtPointer)"tabStack1.tabSide=left");
ac = 0;
XtSetArg(args[ac], XmNlabelString,
CONVERT(parent, "Tabs On:",
XmRXmString, 0, &argok));
if (argok) ac++;
XtSetArg(args[ac], XmNx, 10);
ac++;
XtSetArg(args[ac], XmNy, 10);
ac++;
XtSetArg(args[ac], XmNbackground,
CONVERT(parent, "#ccc",
XmRPixel, 0, &argok));
if (argok) ac++;
XtSetArg(args[ac], XmNfontList,
CONVERT(parent, "-*-helvetica-bold-r-*-*-*-120-*-*-*-*-iso8859-1",
XmRFontList, 0, &argok));
if (argok) ac++;
XtSetArg(args[ac], XmNforeground,
CONVERT(parent, "Black",
XmRPixel, 0, &argok));
if (argok) ac++;
label3 = XmCreateLabel(form2,
"label3",
args,
ac);
XtManageChild(label3);
ac = 0;
XtSetArg(args[ac], XmNresizePolicy, XmRESIZE_GROW);
ac++;
XtSetArg(args[ac], XmNheight, 276);
ac++;
XtSetArg(args[ac], XmNbackground,
CONVERT(parent, "#ccc",
XmRPixel, 0, &argok));
if (argok) ac++;
XtSetArg(args[ac], XmNfontList,
CONVERT(parent, "-*-helvetica-bold-r-*-*-*-120-*-*-*-*-iso8859-1",
XmRFontList, 0, &argok));
if (argok) ac++;
XtSetArg(args[ac], XmNforeground,
CONVERT(parent, "Black",
XmRPixel, 0, &argok));
if (argok) ac++;
tabStack1 = XmCreateTabStack(form1,
"tabStack1",
args,
ac);
XtManageChild(tabStack1);
ac = 0;
XtSetArg(args[ac], XmNlabelString,
CONVERT(parent, ":::t\"Sample TabStack\"\"Label One\"",
XmRXmString, 0, &argok));
if (argok) ac++;
XtSetArg(args[ac], XmNx, 12);
ac++;
XtSetArg(args[ac], XmNy, 50);
ac++;
XtSetArg(args[ac], XmNbackground,
CONVERT(parent, "#ccc",
XmRPixel, 0, &argok));
if (argok) ac++;
XtSetArg(args[ac], XmNfontList,
CONVERT(parent, "-*-helvetica-bold-r-*-*-*-120-*-*-*-*-iso8859-1",
XmRFontList, 0, &argok));
if (argok) ac++;
XtSetArg(args[ac], XmNforeground,
CONVERT(parent, "Black",
XmRPixel, 0, &argok));
if (argok) ac++;
label = XmCreateLabel(tabStack1,
"label",
args,
ac);
XtManageChild(label);
ac = 0;
XtSetArg(args[ac], XmNlabelString,
CONVERT(parent, ":::t\"Sample TabStack\"\"Label Two\"",
XmRXmString, 0, &argok));
if (argok) ac++;
XtSetArg(args[ac], XmNx, -441);
ac++;
XtSetArg(args[ac], XmNy, 50);
ac++;
XtSetArg(args[ac], XmNbackground,
CONVERT(parent, "#ccc",
XmRPixel, 0, &argok));
if (argok) ac++;
XtSetArg(args[ac], XmNfontList,
CONVERT(parent, "-*-helvetica-bold-r-*-*-*-120-*-*-*-*-iso8859-1",
XmRFontList, 0, &argok));
if (argok) ac++;
XtSetArg(args[ac], XmNforeground,
CONVERT(parent, "Black",
XmRPixel, 0, &argok));
if (argok) ac++;
label1 = XmCreateLabel(tabStack1,
"label1",
args,
ac);
XtManageChild(label1);
ac = 0;
XtSetArg(args[ac], XmNlabelString,
CONVERT(parent, ":::t\"Sample TabStack\"\"Label Three\"",
XmRXmString, 0, &argok));
if (argok) ac++;
XtSetArg(args[ac], XmNx, -441);
ac++;
XtSetArg(args[ac], XmNy, 50);
ac++;
XtSetArg(args[ac], XmNbackground,
CONVERT(parent, "#ccc",
XmRPixel, 0, &argok));
if (argok) ac++;
XtSetArg(args[ac], XmNfontList,
CONVERT(parent, "-*-helvetica-bold-r-*-*-*-120-*-*-*-*-iso8859-1",
XmRFontList, 0, &argok));
if (argok) ac++;
XtSetArg(args[ac], XmNforeground,
CONVERT(parent, "Black",
XmRPixel, 0, &argok));
if (argok) ac++;
label2 = XmCreateLabel(tabStack1,
"label2",
args,
ac);
XtManageChild(label2);
ac = 0;
XtSetArg(args[ac], XmNx, 9);
ac++;
XtSetArg(args[ac], XmNy, 456);
ac++;
XtSetArg(args[ac], XmNbackground,
CONVERT(parent, "#ccc",
XmRPixel, 0, &argok));
if (argok) ac++;
XtSetArg(args[ac], XmNforeground,
CONVERT(parent, "Black",
XmRPixel, 0, &argok));
if (argok) ac++;
separator = XmCreateSeparator(form,
"separator",
args,
ac);
XtManageChild(separator);
ac = 0;
XtSetArg(args[ac], XmNlabelString,
CONVERT(parent, "Quit",
XmRXmString, 0, &argok));
if (argok) ac++;
XtSetArg(args[ac], XmNx, 784);
ac++;
XtSetArg(args[ac], XmNy, 468);
ac++;
XtSetArg(args[ac], XmNbackground,
CONVERT(parent, "#ccc",
XmRPixel, 0, &argok));
if (argok) ac++;
XtSetArg(args[ac], XmNfontList,
CONVERT(parent, "-*-helvetica-bold-r-*-*-*-120-*-*-*-*-iso8859-1",
XmRFontList, 0, &argok));
if (argok) ac++;
XtSetArg(args[ac], XmNforeground,
CONVERT(parent, "Black",
XmRPixel, 0, &argok));
if (argok) ac++;
pushButton = XmCreatePushButton(form,
"pushButton",
args,
ac);
XtManageChild(pushButton);
XtAddCallback(pushButton, XmNactivateCallback, BxExitCB, (XtPointer)0);
ac = 0;
XtSetArg(args[ac], XmNtopAttachment, XmATTACH_FORM);
ac++;
XtSetArg(args[ac], XmNbottomAttachment, XmATTACH_WIDGET);
ac++;
XtSetArg(args[ac], XmNleftAttachment, XmATTACH_FORM);
ac++;
XtSetArg(args[ac], XmNrightAttachment, XmATTACH_FORM);
ac++;
XtSetArg(args[ac], XmNbottomWidget, separator);
ac++;
XtSetArg(args[ac], XmNtopOffset, 10);
ac++;
XtSetArg(args[ac], XmNbottomOffset, 10);
ac++;
XtSetArg(args[ac], XmNleftOffset, 10);
ac++;
XtSetArg(args[ac], XmNrightOffset, 11);
ac++;
XtSetValues(tabStack, args, ac);
ac = 0;
XtSetArg(args[ac], XmNtabLabelString,
CONVERT(parent, "Description",
XmRXmString, 0, &argok));
if (argok) ac++;
XtSetValues(scrolledWindow, args, ac);
ac = 0;
XtSetArg(args[ac], XmNtabLabelString,
CONVERT(parent, "Resources",
XmRXmString, 0, &argok));
if (argok) ac++;
XtSetArg(args[ac], XmNtabLabelPixmap, XPM_PIXMAP(parent, allviewpix_icon));
ac++;
XtSetValues(form1, args, ac);
ac = 0;
XtSetArg(args[ac], XmNtopAttachment, XmATTACH_FORM);
ac++;
XtSetArg(args[ac], XmNbottomAttachment, XmATTACH_FORM);
ac++;
XtSetArg(args[ac], XmNleftAttachment, XmATTACH_NONE);
ac++;
XtSetArg(args[ac], XmNrightAttachment, XmATTACH_FORM);
ac++;
XtSetArg(args[ac], XmNtopOffset, 10);
ac++;
XtSetArg(args[ac], XmNbottomOffset, 10);
ac++;
XtSetArg(args[ac], XmNrightOffset, 10);
ac++;
XtSetValues(frame, args, ac);
ac = 0;
XtSetArg(args[ac], XmNtopAttachment, XmATTACH_WIDGET);
ac++;
XtSetArg(args[ac], XmNbottomAttachment, XmATTACH_NONE);
ac++;
XtSetArg(args[ac], XmNleftAttachment, XmATTACH_POSITION);
ac++;
XtSetArg(args[ac], XmNrightAttachment, XmATTACH_FORM);
ac++;
XtSetArg(args[ac], XmNtopWidget, radioBox);
ac++;
XtSetArg(args[ac], XmNleftPosition, 30);
ac++;
XtSetArg(args[ac], XmNtopOffset, 10);
ac++;
XtSetArg(args[ac], XmNbottomOffset, 0);
ac++;
XtSetArg(args[ac], XmNrightOffset, 10);
ac++;
XtSetValues(radioBox1, args, ac);
ac = 0;
XtSetArg(args[ac], XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET);
ac++;
XtSetArg(args[ac], XmNbottomAttachment, XmATTACH_OPPOSITE_WIDGET);
ac++;
XtSetArg(args[ac], XmNleftAttachment, XmATTACH_FORM);
ac++;
XtSetArg(args[ac], XmNtopWidget, radioBox1);
ac++;
XtSetArg(args[ac], XmNbottomWidget, radioBox1);
ac++;
XtSetArg(args[ac], XmNtopOffset, 0);
ac++;
XtSetArg(args[ac], XmNbottomOffset, 0);
ac++;
XtSetArg(args[ac], XmNleftOffset, 10);
ac++;
XtSetValues(label4, args, ac);
ac = 0;
XtSetArg(args[ac], XmNtopAttachment, XmATTACH_FORM);
ac++;
XtSetArg(args[ac], XmNleftAttachment, XmATTACH_POSITION);
ac++;
XtSetArg(args[ac], XmNrightAttachment, XmATTACH_FORM);
ac++;
XtSetArg(args[ac], XmNleftPosition, 31);
ac++;
XtSetArg(args[ac], XmNtopOffset, 10);
ac++;
XtSetArg(args[ac], XmNrightOffset, 10);
ac++;
XtSetValues(radioBox, args, ac);
ac = 0;
XtSetArg(args[ac], XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET);
ac++;
XtSetArg(args[ac], XmNbottomAttachment, XmATTACH_OPPOSITE_WIDGET);
ac++;
XtSetArg(args[ac], XmNleftAttachment, XmATTACH_FORM);
ac++;
XtSetArg(args[ac], XmNtopWidget, radioBox);
ac++;
XtSetArg(args[ac], XmNbottomWidget, radioBox);
ac++;
XtSetArg(args[ac], XmNtopOffset, 0);
ac++;
XtSetArg(args[ac], XmNbottomOffset, 0);
ac++;
XtSetArg(args[ac], XmNleftOffset, 10);
ac++;
XtSetValues(label3, args, ac);
ac = 0;
XtSetArg(args[ac], XmNtopAttachment, XmATTACH_FORM);
ac++;
XtSetArg(args[ac], XmNbottomAttachment, XmATTACH_FORM);
ac++;
XtSetArg(args[ac], XmNleftAttachment, XmATTACH_FORM);
ac++;
XtSetArg(args[ac], XmNrightAttachment, XmATTACH_WIDGET);
ac++;
XtSetArg(args[ac], XmNrightWidget, frame);
ac++;
XtSetArg(args[ac], XmNtopOffset, 10);
ac++;
XtSetArg(args[ac], XmNbottomOffset, 82);
ac++;
XtSetArg(args[ac], XmNleftOffset, 9);
ac++;
XtSetArg(args[ac], XmNrightOffset, 10);
ac++;
XtSetValues(tabStack1, args, ac);
ac = 0;
XtSetArg(args[ac], XmNtabLabelString,
CONVERT(parent, "One",
XmRXmString, 0, &argok));
if (argok) ac++;
XtSetValues(label, args, ac);
ac = 0;
XtSetArg(args[ac], XmNtabLabelString,
CONVERT(parent, "Two",
XmRXmString, 0, &argok));
if (argok) ac++;
XtSetValues(label1, args, ac);
ac = 0;
XtSetArg(args[ac], XmNtabLabelString,
CONVERT(parent, "Three",
XmRXmString, 0, &argok));
if (argok) ac++;
XtSetValues(label2, args, ac);
ac = 0;
XtSetArg(args[ac], XmNtopAttachment, XmATTACH_NONE);
ac++;
XtSetArg(args[ac], XmNbottomAttachment, XmATTACH_WIDGET);
ac++;
XtSetArg(args[ac], XmNleftAttachment, XmATTACH_FORM);
ac++;
XtSetArg(args[ac], XmNrightAttachment, XmATTACH_FORM);
ac++;
XtSetArg(args[ac], XmNbottomWidget, pushButton);
ac++;
XtSetArg(args[ac], XmNbottomOffset, 10);
ac++;
XtSetArg(args[ac], XmNleftOffset, 9);
ac++;
XtSetArg(args[ac], XmNrightOffset, 10);
ac++;
XtSetValues(separator, args, ac);
ac = 0;
XtSetArg(args[ac], XmNtopAttachment, XmATTACH_NONE);
ac++;
XtSetArg(args[ac], XmNbottomAttachment, XmATTACH_FORM);
ac++;
XtSetArg(args[ac], XmNleftAttachment, XmATTACH_NONE);
ac++;
XtSetArg(args[ac], XmNrightAttachment, XmATTACH_FORM);
ac++;
XtSetArg(args[ac], XmNbottomOffset, 10);
ac++;
XtSetArg(args[ac], XmNrightOffset, 10);
ac++;
XtSetValues(pushButton, args, ac);
return( form );
}
nsresult
Convert(uint8_t aIn, BluetoothPropertyType& aOut)
{
static const BluetoothPropertyType sPropertyType[] = {
CONVERT(0x00, static_cast<BluetoothPropertyType>(0)), // invalid, required by gcc
CONVERT(0x01, PROPERTY_BDNAME),
CONVERT(0x02, PROPERTY_BDADDR),
CONVERT(0x03, PROPERTY_UUIDS),
CONVERT(0x04, PROPERTY_CLASS_OF_DEVICE),
CONVERT(0x05, PROPERTY_TYPE_OF_DEVICE),
CONVERT(0x06, PROPERTY_SERVICE_RECORD),
CONVERT(0x07, PROPERTY_ADAPTER_SCAN_MODE),
CONVERT(0x08, PROPERTY_ADAPTER_BONDED_DEVICES),
CONVERT(0x09, PROPERTY_ADAPTER_DISCOVERY_TIMEOUT),
CONVERT(0x0a, PROPERTY_REMOTE_FRIENDLY_NAME),
CONVERT(0x0b, PROPERTY_REMOTE_RSSI),
CONVERT(0x0c, PROPERTY_REMOTE_VERSION_INFO)
};
if (aIn == 0xff) {
/* This case is handled separately to not populate
* |sPropertyType| with empty entries. */
aOut = PROPERTY_REMOTE_DEVICE_TIMESTAMP;
return NS_OK;
}
if (NS_WARN_IF(!aIn) ||
NS_WARN_IF(aIn >= MOZ_ARRAY_LENGTH(sPropertyType))) {
return NS_ERROR_ILLEGAL_VALUE;
}
aOut = sPropertyType[aIn];
return NS_OK;
}
void PRcustompaperinfo(int pwidth, int plength, int xres, int yres)
{
#if 0 /*Disabling custom paper for now */
int i;
Sint32 n;
PAPERINFO * np = (PAPERINFO *) paper_table_variable_resolution;
CONST PAPERINFO * op = (CONST PAPERINFO *) system_paper_table;
Boolean convert8 = ( xres % 300 );
#if defined(SUPPORT_EDGE2EDGE) || defined(RXPS_EDGE_TO_EDGE)
Boolean = OMGetCurrentBool(OMEDGETOEDGE,OMSYSTEM);
#ifdef PCL_CUSTOM_EDGE2EDGE
Boolean enter_lang;
if(customEdge2Edge){
int njobid, ujobid;
enter_lang = OMGetCurrentEnum(OMREQPROCREASON, OMSYSTEM) ==
REQPROCREASON_ENTERLANGUAGE;
PrintSysGetjobid( &njobid, &ujobid);
if(njobid == pre_njobid && ujobid == pre_ujobid)
enter_lang = pre_enter_lang_custom;
else {
pre_njobid = njobid;
pre_ujobid = ujobid;
}
}
#endif /* PCL_CUSTOM_EDGE2EDGE */
#endif /* SUPPORT_EDGE2EDGE || RXPS_EDGE_TO_EDGE */
#if defined(SUPPORT_EDGE2EDGE) || defined(RXPS_EDGE_TO_EDGE)
if (cvtx == xres && cvty == yres && cvtw == pwidth && cvtl == plength && set_edge2edge_custom == edge2edge
#ifdef PCL_CUSTOM_EDGE2EDGE
&& (!customEdge2Edge || enter_lang == pre_enter_lang_custom)
#endif
)
return;
#else
if (cvtx == xres && cvty == yres && cvtw == pwidth && cvtl == plength)
return;
#endif /* SUPPORT_EDGE2EDGE || RXPS_EDGE_TO_EDGE */
for (i = dimof(system_paper_table); i > 0; i--, np++, op++) {
if (op->OMcode == PAPERSIZE_CUSTOM)
break;
}
if (i == 0)
return;
#if defined(SUPPORT_EDGE2EDGE) || defined(RXPS_EDGE_TO_EDGE)
if ( edge2edge ) {
#ifdef PCL_CUSTOM_EDGE2EDGE
if (customEdge2Edge && !enter_lang) {
np->size.x = np->printable.x = np->rotnomsize.x = pwidth;
np->nominal.x = pwidth - CONVERT_XONE(nomoffset);
np->size.y = np->printable.y = np->nominal.y = plength;
np->rotnomsize.y = plength - CONVERT_YONE(rotnomoffset);
np->offset.x = np->offset.y = 0;
CONVERT(nomoffset);
if (pwidth >= plength) {
CONVERT(rotnomoffset);
} else {
np->rotnomoffset.x = np->rotnomoffset.y = 0;
}
/* The next 2 entries are NOT scaled. They get scaled when they used.
*/
np->HPnomoffset.x = np->nomoffset.x;
np->HPnomoffset.y = np->HProtnomoffset.x = 0;
np->HProtnomoffset.y = np->rotnomoffset.y;
} else {
#endif /*PCL_CUSTOM_EDGE2EDGE*/
#ifdef RP_CUSTOMPAPERSIZE
#if (defined(EMPCL5)||defined(EMPCLXL)) && (defined(EMPOSTSCRIPT)||defined(EMPDF))
if ((TRUE == PrintSysIsPS()) || (TRUE == PrintSysIsPDF())){
#endif
if(pwidth > plength){
np->size.x = np->printable.x = np->nominal.x = np->rotnomsize.x = plength;
np->size.y = np->printable.y = np->nominal.y = np->rotnomsize.y = pwidth;
} else {
np->size.x = np->printable.x = np->nominal.x = np->rotnomsize.x = pwidth;
np->size.y = np->printable.y = np->nominal.y = np->rotnomsize.y = plength;
}
#if (defined(EMPCL5)||defined(EMPCLXL)) && (defined(EMPOSTSCRIPT)||defined(EMPDF))
} else {
np->size.x = np->printable.x = np->nominal.x = np->rotnomsize.x = pwidth;
np->size.y = np->printable.y = np->nominal.y = np->rotnomsize.y = plength;
}
#endif
#else /* RP_CUSTOMPAPERSIZE */
np->size.x = np->printable.x = np->nominal.x = np->rotnomsize.x = pwidth;
np->size.y = np->printable.y = np->nominal.y = np->rotnomsize.y = plength;
#endif /* RP_CUSTOMPAPERSIZE */
np->offset.x = np->nomoffset.x = np->rotnomoffset.x = 0;
np->offset.y = np->nomoffset.y = np->rotnomoffset.y = 0;
/* The next 2 entries are NOT scaled. They get scaled when they used.
*/
np->HPnomoffset.x = np->HProtnomoffset.x = 0;
np->HPnomoffset.y = np->HProtnomoffset.y = 0;
#ifdef PCL_CUSTOM_EDGE2EDGE
}
#endif
} else {
#endif
#ifdef RP_CUSTOMPAPERSIZE
#if (defined(EMPCL5)||defined(EMPCLXL)) && (defined(EMPOSTSCRIPT)||defined(EMPDF))
if ((TRUE == PrintSysIsPS()) || (TRUE == PrintSysIsPDF())){
#endif
np->printable.x = pwidth - 2 * CONVERT_XONE(offset);
np->printable.y = plength - 2 * CONVERT_YONE(offset);
if(pwidth > plength){
np->size.x = plength;
np->size.y = pwidth;
np->nominal.x = plength - 2 * CONVERT_XONE(nomoffset);
np->nominal.y = pwidth - 2 * CONVERT_YONE(nomoffset);
np->rotnomsize.x = plength - 2 * CONVERT_XONE(rotnomoffset);
np->rotnomsize.y = pwidth - 2 * CONVERT_YONE(rotnomoffset);
} else {
np->size.x = pwidth;
np->size.y = plength;
np->printable.x = pwidth - 2 * CONVERT_XONE(offset);
np->printable.y = plength - 2 * CONVERT_YONE(offset);
np->nominal.x = pwidth - 2 * CONVERT_XONE(nomoffset);
np->nominal.y = plength - 2 * CONVERT_YONE(nomoffset);
np->rotnomsize.x = pwidth - 2 * CONVERT_XONE(rotnomoffset);
np->rotnomsize.y = plength - 2 * CONVERT_YONE(rotnomoffset);
}
#if (defined(EMPCL5)||defined(EMPCLXL)) && (defined(EMPOSTSCRIPT)||defined(EMPDF))
} else{
np->size.x = pwidth;
np->size.y = plength;
np->printable.x = pwidth - 2 * CONVERT_XONE(offset);
np->printable.y = plength - 2 * CONVERT_YONE(offset);
np->nominal.x = pwidth - 2 * CONVERT_XONE(nomoffset);
np->nominal.y = plength - 2 * CONVERT_YONE(nomoffset);
np->rotnomsize.x = pwidth - 2 * CONVERT_XONE(rotnomoffset);
np->rotnomsize.y = plength - 2 * CONVERT_YONE(rotnomoffset);
}
#endif
#else /* RP_CUSTOMPAPERSIZE */
np->size.x = pwidth;
np->size.y = plength;
np->printable.x = pwidth - 2 * CONVERT_XONE(offset);
np->printable.y = plength - 2 * CONVERT_YONE(offset);
np->nominal.x = pwidth - 2 * CONVERT_XONE(nomoffset);
np->nominal.y = plength - 2 * CONVERT_YONE(nomoffset);
np->rotnomsize.x = pwidth - 2 * CONVERT_XONE(rotnomoffset);
np->rotnomsize.y = plength - 2 * CONVERT_YONE(rotnomoffset);
#endif /* RP_CUSTOMPAPERSIZE */
CONVERT(offset);
CONVERT(nomoffset);
CONVERT(rotnomoffset);
/* The next 2 entries are NOT scaled. They get scaled when they used.
*/
FIELDCOPY(HPnomoffset);
FIELDCOPY(HProtnomoffset);
#if defined(SUPPORT_EDGE2EDGE) || defined(RXPS_EDGE_TO_EDGE)
}
#endif
#ifdef PCL5_CUSTOMSIZE_COMMAND
#if (defined(EMPCL5)||defined(EMPCLXL)) && (defined(EMPOSTSCRIPT)||defined(EMPDF))
if( (TRUE == PrintSysIsPCL()) || (TRUE == PrintSysIsPCLXL())){
#endif
if (np->printable.x <= 0)
np->printable.x = NBITS;
if (np->nominal.x <= 0)
np->nominal.x = NBITS;
if (np->rotnomsize.x <= 0)
np->rotnomsize.x = NBITS;
if (np->printable.y <= 0)
np->printable.y = 1;
if (np->nominal.y <= 0)
np->nominal.y = 1;
if (np->rotnomsize.y <= 0)
np->rotnomsize.y = 1;
#if (defined(EMPCL5)||defined(EMPCLXL)) && (defined(EMPOSTSCRIPT)||defined(EMPDF))
}
#endif
#endif /* PCL5_CUSTOMSIZE_COMMAND */
np->OMcode = op->OMcode;
np->PCLpaperID = op->PCLpaperID;
np->XLpaperID = op->XLpaperID;
np->envelope = op->envelope;
np->noduplex = op->noduplex;
#ifdef EMPOSTSCRIPT /* RP_CUSTOMPAPERSIZE */
#if (defined(EMPCL5)||defined(EMPCLXL)) && (defined(EMPOSTSCRIPT)||defined(EMPDF))
if ((TRUE == PrintSysIsPS()) || (TRUE == PrintSysIsPDF())){
#endif
#ifdef RP_CUSTOMPAPERSIZE
if(pwidth > plength){
np->PS_PageSize.x = (int)(((float)plength/xres)*72); /* dot -> pt */
np->PS_PageSize.y = (int)(((float)pwidth/yres)*72); /* dot -> pt */
}else{
np->PS_PageSize.x = (int)(((float)pwidth/xres)*72); /* dot -> pt */
np->PS_PageSize.y = (int)(((float)plength/yres)*72); /* dot -> pt */
}
#endif /* RP_CUSTOMPAPERSIZE */
#if defined(SUPPORT_EDGE2EDGE) || defined(RXPS_EDGE_TO_EDGE)
if ( edge2edge ) {
np->PS_printable.x = pwidth;
np->PS_printable.y = plength;
np->PS_margins.x = 0;
np->PS_margins.y = 0;
} else {
#endif /* SUPPORT_EDGE2EDGE || RXPS_EDGE_TO_EDGE */
np->PS_printable.x = pwidth - 2 * CONVERT_XONE(PS_margins);
np->PS_printable.y = plength - 2 * CONVERT_YONE(PS_margins);
CONVERT(PS_margins);
#if defined(SUPPORT_EDGE2EDGE) || defined(RXPS_EDGE_TO_EDGE)
}
#endif
#if (defined(EMPCL5)||defined(EMPCLXL)) && (defined(EMPOSTSCRIPT)||defined(EMPDF))
}
#endif
#endif /* EMPOSTSCRIPT (RP_CUSTOMPAPERSIZE) */
np->resolution.x = xres;
np->resolution.y = yres;
#ifdef GPS_REJECTION
np->Direction = op->Direction;
np->Duplex = op->Duplex;
np->Staple = op->Staple;
np->RotateCollate = op->RotateCollate;
np->StandardTray = op->StandardTray;
np->ShiftBin = op->ShiftBin;
np->MailBoxBin = op->MailBoxBin;
#endif /* GPS_REJECTION */
cvtx = xres;
cvty = yres;
cvtw = pwidth;
cvtl = plength;
#if defined(SUPPORT_EDGE2EDGE) || defined(RXPS_EDGE_TO_EDGE)
set_edge2edge_custom = edge2edge;
#ifdef PCL_CUSTOM_EDGE2EDGE
if(customEdge2Edge){
pre_enter_lang_custom = enter_lang;
}
#endif
#endif /* SUPPORT_EDGE2EDGE || RXPS_EDGE_TO_EDGE */
#endif /*Cutompaper disabled for now */
}
static void r300SetupIndexBuffer(GLcontext *ctx, const struct _mesa_index_buffer *mesa_ind_buf)
{
r300ContextPtr r300 = R300_CONTEXT(ctx);
if (!mesa_ind_buf) {
r300->ind_buf.bo = NULL;
return;
}
radeon_print(RADEON_RENDER, RADEON_TRACE, "%s\n", __func__);
#if MESA_BIG_ENDIAN
if (mesa_ind_buf->type == GL_UNSIGNED_INT) {
#else
if (mesa_ind_buf->type != GL_UNSIGNED_BYTE) {
#endif
const GLvoid *src_ptr;
GLvoid *dst_ptr;
GLboolean mapped_named_bo = GL_FALSE;
if (mesa_ind_buf->obj->Name && !mesa_ind_buf->obj->Pointer) {
ctx->Driver.MapBuffer(ctx, GL_ELEMENT_ARRAY_BUFFER, GL_READ_ONLY_ARB, mesa_ind_buf->obj);
assert(mesa_ind_buf->obj->Pointer != NULL);
mapped_named_bo = GL_TRUE;
}
src_ptr = ADD_POINTERS(mesa_ind_buf->obj->Pointer, mesa_ind_buf->ptr);
const GLuint size = mesa_ind_buf->count * getTypeSize(mesa_ind_buf->type);
radeonAllocDmaRegion(&r300->radeon, &r300->ind_buf.bo, &r300->ind_buf.bo_offset, size, 4);
radeon_bo_map(r300->ind_buf.bo, 1);
assert(r300->ind_buf.bo->ptr != NULL);
dst_ptr = ADD_POINTERS(r300->ind_buf.bo->ptr, r300->ind_buf.bo_offset);
memcpy(dst_ptr, src_ptr, size);
radeon_bo_unmap(r300->ind_buf.bo);
r300->ind_buf.is_32bit = (mesa_ind_buf->type == GL_UNSIGNED_INT);
r300->ind_buf.count = mesa_ind_buf->count;
if (mapped_named_bo) {
ctx->Driver.UnmapBuffer(ctx, GL_ELEMENT_ARRAY_BUFFER, mesa_ind_buf->obj);
}
} else {
r300FixupIndexBuffer(ctx, mesa_ind_buf);
}
}
#define CONVERT( TYPE, MACRO ) do { \
GLuint i, j, sz; \
sz = input->Size; \
if (input->Normalized) { \
for (i = 0; i < count; i++) { \
const TYPE *in = (TYPE *)src_ptr; \
for (j = 0; j < sz; j++) { \
*dst_ptr++ = MACRO(*in); \
in++; \
} \
src_ptr += stride; \
} \
} else { \
for (i = 0; i < count; i++) { \
const TYPE *in = (TYPE *)src_ptr; \
for (j = 0; j < sz; j++) { \
*dst_ptr++ = (GLfloat)(*in); \
in++; \
} \
src_ptr += stride; \
} \
} \
} while (0)
/**
* Convert attribute data type to float
* If the attribute uses named buffer object replace the bo with newly allocated bo
*/
static void r300ConvertAttrib(GLcontext *ctx, int count, const struct gl_client_array *input, struct vertex_attribute *attr)
{
r300ContextPtr r300 = R300_CONTEXT(ctx);
const GLvoid *src_ptr;
GLboolean mapped_named_bo = GL_FALSE;
GLfloat *dst_ptr;
GLuint stride;
stride = (input->StrideB == 0) ? getTypeSize(input->Type) * input->Size : input->StrideB;
/* Convert value for first element only */
if (input->StrideB == 0)
count = 1;
if (input->BufferObj->Name) {
if (!input->BufferObj->Pointer) {
ctx->Driver.MapBuffer(ctx, GL_ARRAY_BUFFER, GL_READ_ONLY_ARB, input->BufferObj);
mapped_named_bo = GL_TRUE;
}
src_ptr = ADD_POINTERS(input->BufferObj->Pointer, input->Ptr);
} else {
src_ptr = input->Ptr;
}
radeonAllocDmaRegion(&r300->radeon, &attr->bo, &attr->bo_offset, sizeof(GLfloat) * input->Size * count, 32);
radeon_bo_map(attr->bo, 1);
dst_ptr = (GLfloat *)ADD_POINTERS(attr->bo->ptr, attr->bo_offset);
radeon_print(RADEON_FALLBACKS, RADEON_IMPORTANT,
"%s: Converting vertex attributes, attribute data format %x,"
"stride %d, components %d\n"
, __FUNCTION__, input->Type
, stride, input->Size);
assert(src_ptr != NULL);
switch (input->Type) {
case GL_DOUBLE:
CONVERT(GLdouble, (GLfloat));
break;
case GL_UNSIGNED_INT:
CONVERT(GLuint, UINT_TO_FLOAT);
break;
case GL_INT:
CONVERT(GLint, INT_TO_FLOAT);
break;
case GL_UNSIGNED_SHORT:
CONVERT(GLushort, USHORT_TO_FLOAT);
break;
case GL_SHORT:
CONVERT(GLshort, SHORT_TO_FLOAT);
break;
case GL_UNSIGNED_BYTE:
assert(input->Format != GL_BGRA);
CONVERT(GLubyte, UBYTE_TO_FLOAT);
break;
case GL_BYTE:
CONVERT(GLbyte, BYTE_TO_FLOAT);
break;
default:
assert(0);
break;
}
radeon_bo_unmap(attr->bo);
if (mapped_named_bo) {
ctx->Driver.UnmapBuffer(ctx, GL_ARRAY_BUFFER, input->BufferObj);
}
}
static int
default_char2int(SCR *sp, const char * str, ssize_t len, CONVWIN *cw,
size_t *tolen, const CHAR_T **dst, const char *enc)
{
int j;
size_t i = 0;
CHAR_T **tostr = (CHAR_T **)(void *)&cw->bp1;
size_t *blen = &cw->blen1;
mbstate_t mbs;
size_t n;
ssize_t nlen = len;
const char *src = (const char *)str;
iconv_t id = (iconv_t)-1;
char buffer[CONV_BUFFER_SIZE];
size_t left = len;
int error = 1;
MEMSET(&mbs, 0, 1);
BINC_RETW(NULL, *tostr, *blen, nlen);
#ifdef USE_ICONV
if (strcmp(nl_langinfo(CODESET), enc)) {
id = iconv_open(nl_langinfo(CODESET), enc);
if (id == (iconv_t)-1)
goto err;
CONVERT(str, left, src, len);
}
#endif
for (i = 0, j = 0; j < len; ) {
n = mbrtowc((*tostr)+i, src+j, len-j, &mbs);
/* NULL character converted */
if (n == (size_t)-2) error = -(len-j);
if (n == (size_t)-1 || n == (size_t)-2)
HANDLE_MBR_ERROR(n, mbs, (*tostr)[i], src[j]);
if (n == 0) n = 1;
j += n;
if (++i >= *blen) {
nlen += 256;
BINC_RETW(NULL, *tostr, *blen, nlen);
}
if (id != (iconv_t)-1 && j == len && left) {
CONVERT(str, left, src, len);
j = 0;
}
}
*tolen = i;
if (id != (iconv_t)-1)
iconv_close(id);
*dst = cw->bp1;
return 0;
err:
*tolen = i;
if (id != (iconv_t)-1)
iconv_close(id);
*dst = cw->bp1;
return error;
}
int a52_downmix_coeff (level_t * coeff, int acmod, int output, level_t level,
level_t clev, level_t slev)
{
level_t level_3db;
level_3db = MUL_C (level, LEVEL_3DB);
switch (CONVERT (acmod, output & A52_CHANNEL_MASK)) {
case CONVERT (A52_CHANNEL, A52_CHANNEL):
case CONVERT (A52_MONO, A52_MONO):
case CONVERT (A52_STEREO, A52_STEREO):
case CONVERT (A52_3F, A52_3F):
case CONVERT (A52_2F1R, A52_2F1R):
case CONVERT (A52_3F1R, A52_3F1R):
case CONVERT (A52_2F2R, A52_2F2R):
case CONVERT (A52_3F2R, A52_3F2R):
case CONVERT (A52_STEREO, A52_DOLBY):
coeff[0] = coeff[1] = coeff[2] = coeff[3] = coeff[4] = level;
return 0;
case CONVERT (A52_CHANNEL, A52_MONO):
coeff[0] = coeff[1] = MUL_C (level, LEVEL_6DB);
return 3;
case CONVERT (A52_STEREO, A52_MONO):
coeff[0] = coeff[1] = level_3db;
return 3;
case CONVERT (A52_3F, A52_MONO):
coeff[0] = coeff[2] = level_3db;
coeff[1] = MUL_C (MUL_L (level_3db, clev), LEVEL_PLUS6DB);
return 7;
case CONVERT (A52_2F1R, A52_MONO):
coeff[0] = coeff[1] = level_3db;
coeff[2] = MUL_L (level_3db, slev);
return 7;
case CONVERT (A52_2F2R, A52_MONO):
coeff[0] = coeff[1] = level_3db;
coeff[2] = coeff[3] = MUL_L (level_3db, slev);
return 15;
case CONVERT (A52_3F1R, A52_MONO):
coeff[0] = coeff[2] = level_3db;
coeff[1] = MUL_C (MUL_L (level_3db, clev), LEVEL_PLUS6DB);
coeff[3] = MUL_L (level_3db, slev);
return 15;
case CONVERT (A52_3F2R, A52_MONO):
coeff[0] = coeff[2] = level_3db;
coeff[1] = MUL_C (MUL_L (level_3db, clev), LEVEL_PLUS6DB);
coeff[3] = coeff[4] = MUL_L (level_3db, slev);
return 31;
case CONVERT (A52_MONO, A52_DOLBY):
coeff[0] = level_3db;
return 0;
case CONVERT (A52_3F, A52_DOLBY):
coeff[0] = coeff[2] = coeff[3] = coeff[4] = level;
coeff[1] = level_3db;
return 7;
case CONVERT (A52_3F, A52_STEREO):
case CONVERT (A52_3F1R, A52_2F1R):
case CONVERT (A52_3F2R, A52_2F2R):
coeff[0] = coeff[2] = coeff[3] = coeff[4] = level;
coeff[1] = MUL_L (level, clev);
return 7;
case CONVERT (A52_2F1R, A52_DOLBY):
coeff[0] = coeff[1] = level;
coeff[2] = level_3db;
return 7;
case CONVERT (A52_2F1R, A52_STEREO):
coeff[0] = coeff[1] = level;
coeff[2] = MUL_L (level_3db, slev);
return 7;
case CONVERT (A52_3F1R, A52_DOLBY):
coeff[0] = coeff[2] = level;
coeff[1] = coeff[3] = level_3db;
return 15;
case CONVERT (A52_3F1R, A52_STEREO):
coeff[0] = coeff[2] = level;
coeff[1] = MUL_L (level, clev);
coeff[3] = MUL_L (level_3db, slev);
return 15;
case CONVERT (A52_2F2R, A52_DOLBY):
coeff[0] = coeff[1] = level;
coeff[2] = coeff[3] = level_3db;
return 15;
case CONVERT (A52_2F2R, A52_STEREO):
coeff[0] = coeff[1] = level;
coeff[2] = coeff[3] = MUL_L (level, slev);
return 15;
case CONVERT (A52_3F2R, A52_DOLBY):
coeff[0] = coeff[2] = level;
coeff[1] = coeff[3] = coeff[4] = level_3db;
return 31;
case CONVERT (A52_3F2R, A52_2F1R):
coeff[0] = coeff[2] = level;
coeff[1] = MUL_L (level, clev);
coeff[3] = coeff[4] = level_3db;
return 31;
case CONVERT (A52_3F2R, A52_STEREO):
coeff[0] = coeff[2] = level;
coeff[1] = MUL_L (level, clev);
coeff[3] = coeff[4] = MUL_L (level, slev);
return 31;
case CONVERT (A52_3F1R, A52_3F):
coeff[0] = coeff[1] = coeff[2] = level;
coeff[3] = MUL_L (level_3db, slev);
return 13;
case CONVERT (A52_3F2R, A52_3F):
coeff[0] = coeff[1] = coeff[2] = level;
coeff[3] = coeff[4] = MUL_L (level, slev);
return 29;
case CONVERT (A52_2F2R, A52_2F1R):
coeff[0] = coeff[1] = level;
coeff[2] = coeff[3] = level_3db;
return 12;
case CONVERT (A52_3F2R, A52_3F1R):
coeff[0] = coeff[1] = coeff[2] = level;
coeff[3] = coeff[4] = level_3db;
return 24;
case CONVERT (A52_2F1R, A52_2F2R):
coeff[0] = coeff[1] = level;
coeff[2] = level_3db;
return 0;
case CONVERT (A52_3F1R, A52_2F2R):
coeff[0] = coeff[2] = level;
coeff[1] = MUL_L (level, clev);
coeff[3] = level_3db;
return 7;
case CONVERT (A52_3F1R, A52_3F2R):
coeff[0] = coeff[1] = coeff[2] = level;
coeff[3] = level_3db;
return 0;
case CONVERT (A52_CHANNEL, A52_CHANNEL1):
coeff[0] = level;
coeff[1] = 0;
return 0;
case CONVERT (A52_CHANNEL, A52_CHANNEL2):
coeff[0] = 0;
coeff[1] = level;
return 0;
}
return -1; /* NOTREACHED */
}
int dts_downmix_coeff (level_t * coeff, int acmod, int output, level_t level,
level_t clev, level_t slev)
{
level_t level_3db;
level_3db = (sample_t)(MUL_C (level, LEVEL_3DB));
switch (CONVERT (acmod, output & DTS_CHANNEL_MASK)) {
case CONVERT (DTS_CHANNEL, DTS_CHANNEL):
case CONVERT (DTS_MONO, DTS_MONO):
case CONVERT (DTS_STEREO, DTS_STEREO):
case CONVERT (DTS_3F, DTS_3F):
case CONVERT (DTS_2F1R, DTS_2F1R):
case CONVERT (DTS_3F1R, DTS_3F1R):
case CONVERT (DTS_2F2R, DTS_2F2R):
case CONVERT (DTS_3F2R, DTS_3F2R):
case CONVERT (DTS_STEREO, DTS_DOLBY):
coeff[0] = coeff[1] = coeff[2] = coeff[3] = coeff[4] = level;
return 0;
case CONVERT (DTS_CHANNEL, DTS_MONO):
coeff[0] = coeff[1] = (sample_t)(MUL_C (level, LEVEL_6DB));
return 3;
case CONVERT (DTS_STEREO, DTS_MONO):
coeff[0] = coeff[1] = level_3db;
return 3;
case CONVERT (DTS_3F, DTS_MONO):
coeff[0] = coeff[2] = level_3db;
coeff[1] = (sample_t)(MUL_C (MUL_L (level_3db, clev), LEVEL_PLUS6DB));
return 7;
case CONVERT (DTS_2F1R, DTS_MONO):
coeff[0] = coeff[1] = level_3db;
coeff[2] = MUL_L (level_3db, slev);
return 7;
case CONVERT (DTS_2F2R, DTS_MONO):
coeff[0] = coeff[1] = level_3db;
coeff[2] = coeff[3] = MUL_L (level_3db, slev);
return 15;
case CONVERT (DTS_3F1R, DTS_MONO):
coeff[0] = coeff[2] = level_3db;
coeff[1] = (sample_t)(MUL_C (MUL_L (level_3db, clev), LEVEL_PLUS6DB));
coeff[3] = MUL_L (level_3db, slev);
return 15;
case CONVERT (DTS_3F2R, DTS_MONO):
coeff[0] = coeff[2] = level_3db;
coeff[1] = (sample_t)(MUL_C (MUL_L (level_3db, clev), LEVEL_PLUS6DB));
coeff[3] = coeff[4] = MUL_L (level_3db, slev);
return 31;
case CONVERT (DTS_MONO, DTS_DOLBY):
coeff[0] = level_3db;
return 0;
case CONVERT (DTS_3F, DTS_DOLBY):
coeff[0] = coeff[2] = coeff[3] = coeff[4] = level;
coeff[1] = level_3db;
return 7;
case CONVERT (DTS_3F, DTS_STEREO):
case CONVERT (DTS_3F1R, DTS_2F1R):
case CONVERT (DTS_3F2R, DTS_2F2R):
coeff[0] = coeff[2] = coeff[3] = coeff[4] = level;
coeff[1] = MUL_L (level, clev);
return 7;
case CONVERT (DTS_2F1R, DTS_DOLBY):
coeff[0] = coeff[1] = level;
coeff[2] = level_3db;
return 7;
case CONVERT (DTS_2F1R, DTS_STEREO):
coeff[0] = coeff[1] = level;
coeff[2] = MUL_L (level_3db, slev);
return 7;
case CONVERT (DTS_3F1R, DTS_DOLBY):
coeff[0] = coeff[2] = level;
coeff[1] = coeff[3] = level_3db;
return 15;
case CONVERT (DTS_3F1R, DTS_STEREO):
coeff[0] = coeff[2] = level;
coeff[1] = MUL_L (level, clev);
coeff[3] = MUL_L (level_3db, slev);
return 15;
case CONVERT (DTS_2F2R, DTS_DOLBY):
coeff[0] = coeff[1] = level;
coeff[2] = coeff[3] = level_3db;
return 15;
case CONVERT (DTS_2F2R, DTS_STEREO):
coeff[0] = coeff[1] = level;
coeff[2] = coeff[3] = MUL_L (level, slev);
return 15;
case CONVERT (DTS_3F2R, DTS_DOLBY):
coeff[0] = coeff[2] = level;
coeff[1] = coeff[3] = coeff[4] = level_3db;
return 31;
case CONVERT (DTS_3F2R, DTS_2F1R):
coeff[0] = coeff[2] = level;
coeff[1] = MUL_L (level, clev);
coeff[3] = coeff[4] = level_3db;
return 31;
case CONVERT (DTS_3F2R, DTS_STEREO):
coeff[0] = coeff[2] = level;
coeff[1] = MUL_L (level, clev);
coeff[3] = coeff[4] = MUL_L (level, slev);
return 31;
case CONVERT (DTS_3F1R, DTS_3F):
coeff[0] = coeff[1] = coeff[2] = level;
coeff[3] = MUL_L (level_3db, slev);
return 13;
case CONVERT (DTS_3F2R, DTS_3F):
coeff[0] = coeff[1] = coeff[2] = level;
coeff[3] = coeff[4] = MUL_L (level, slev);
return 29;
case CONVERT (DTS_2F2R, DTS_2F1R):
coeff[0] = coeff[1] = level;
coeff[2] = coeff[3] = level_3db;
return 12;
case CONVERT (DTS_3F2R, DTS_3F1R):
coeff[0] = coeff[1] = coeff[2] = level;
coeff[3] = coeff[4] = level_3db;
return 24;
case CONVERT (DTS_2F1R, DTS_2F2R):
coeff[0] = coeff[1] = level;
coeff[2] = level_3db;
return 0;
case CONVERT (DTS_3F1R, DTS_2F2R):
coeff[0] = coeff[2] = level;
coeff[1] = MUL_L (level, clev);
coeff[3] = level_3db;
return 7;
case CONVERT (DTS_3F1R, DTS_3F2R):
coeff[0] = coeff[1] = coeff[2] = level;
coeff[3] = level_3db;
return 0;
}
return -1; /* NOTREACHED */
}
int a52_downmix_init (int input, int flags, level_t * level,
level_t clev, level_t slev)
{
static uint8_t table[11][8] = {
{A52_CHANNEL, A52_DOLBY, A52_STEREO, A52_STEREO,
A52_STEREO, A52_STEREO, A52_STEREO, A52_STEREO},
{A52_MONO, A52_MONO, A52_MONO, A52_MONO,
A52_MONO, A52_MONO, A52_MONO, A52_MONO},
{A52_CHANNEL, A52_DOLBY, A52_STEREO, A52_STEREO,
A52_STEREO, A52_STEREO, A52_STEREO, A52_STEREO},
{A52_CHANNEL, A52_DOLBY, A52_STEREO, A52_3F,
A52_STEREO, A52_3F, A52_STEREO, A52_3F},
{A52_CHANNEL, A52_DOLBY, A52_STEREO, A52_STEREO,
A52_2F1R, A52_2F1R, A52_2F1R, A52_2F1R},
{A52_CHANNEL, A52_DOLBY, A52_STEREO, A52_STEREO,
A52_2F1R, A52_3F1R, A52_2F1R, A52_3F1R},
{A52_CHANNEL, A52_DOLBY, A52_STEREO, A52_3F,
A52_2F2R, A52_2F2R, A52_2F2R, A52_2F2R},
{A52_CHANNEL, A52_DOLBY, A52_STEREO, A52_3F,
A52_2F2R, A52_3F2R, A52_2F2R, A52_3F2R},
{A52_CHANNEL1, A52_MONO, A52_MONO, A52_MONO,
A52_MONO, A52_MONO, A52_MONO, A52_MONO},
{A52_CHANNEL2, A52_MONO, A52_MONO, A52_MONO,
A52_MONO, A52_MONO, A52_MONO, A52_MONO},
{A52_CHANNEL, A52_DOLBY, A52_STEREO, A52_DOLBY,
A52_DOLBY, A52_DOLBY, A52_DOLBY, A52_DOLBY}
};
int output;
output = flags & A52_CHANNEL_MASK;
if (output > A52_DOLBY)
return -1;
output = table[output][input & 7];
if (output == A52_STEREO &&
(input == A52_DOLBY || (input == A52_3F && clev == LEVEL (LEVEL_3DB))))
output = A52_DOLBY;
if (flags & A52_ADJUST_LEVEL) {
level_t adjust;
switch (CONVERT (input & 7, output)) {
case CONVERT (A52_3F, A52_MONO):
adjust = DIV (LEVEL_3DB, LEVEL (1) + clev);
break;
case CONVERT (A52_STEREO, A52_MONO):
case CONVERT (A52_2F2R, A52_2F1R):
case CONVERT (A52_3F2R, A52_3F1R):
level_3db:
adjust = LEVEL (LEVEL_3DB);
break;
case CONVERT (A52_3F2R, A52_2F1R):
if (clev < LEVEL (LEVEL_PLUS3DB - 1))
goto level_3db;
/* break thru */
case CONVERT (A52_3F, A52_STEREO):
case CONVERT (A52_3F1R, A52_2F1R):
case CONVERT (A52_3F1R, A52_2F2R):
case CONVERT (A52_3F2R, A52_2F2R):
adjust = DIV (1, LEVEL (1) + clev);
break;
case CONVERT (A52_2F1R, A52_MONO):
adjust = DIV (LEVEL_PLUS3DB, LEVEL (2) + slev);
break;
case CONVERT (A52_2F1R, A52_STEREO):
case CONVERT (A52_3F1R, A52_3F):
adjust = DIV (1, LEVEL (1) + MUL_C (slev, LEVEL_3DB));
break;
case CONVERT (A52_3F1R, A52_MONO):
adjust = DIV (LEVEL_3DB, LEVEL (1) + clev + MUL_C (slev, 0.5));
break;
case CONVERT (A52_3F1R, A52_STEREO):
adjust = DIV (1, LEVEL (1) + clev + MUL_C (slev, LEVEL_3DB));
break;
case CONVERT (A52_2F2R, A52_MONO):
adjust = DIV (LEVEL_3DB, LEVEL (1) + slev);
break;
case CONVERT (A52_2F2R, A52_STEREO):
case CONVERT (A52_3F2R, A52_3F):
adjust = DIV (1, LEVEL (1) + slev);
break;
case CONVERT (A52_3F2R, A52_MONO):
adjust = DIV (LEVEL_3DB, LEVEL (1) + clev + slev);
break;
case CONVERT (A52_3F2R, A52_STEREO):
adjust = DIV (1, LEVEL (1) + clev + slev);
break;
case CONVERT (A52_MONO, A52_DOLBY):
adjust = LEVEL (LEVEL_PLUS3DB);
break;
case CONVERT (A52_3F, A52_DOLBY):
case CONVERT (A52_2F1R, A52_DOLBY):
adjust = LEVEL (1 / (1 + LEVEL_3DB));
break;
case CONVERT (A52_3F1R, A52_DOLBY):
case CONVERT (A52_2F2R, A52_DOLBY):
adjust = LEVEL (1 / (1 + 2 * LEVEL_3DB));
break;
case CONVERT (A52_3F2R, A52_DOLBY):
adjust = LEVEL (1 / (1 + 3 * LEVEL_3DB));
break;
default:
return output;
}
*level = MUL_L (*level, adjust);
}
return output;
}
int dts_downmix_init (int input, int flags, level_t * level,
level_t clev, level_t slev)
{
static uint8_t table[11][10] = {
/* DTS_MONO */
{DTS_MONO, DTS_MONO, DTS_MONO, DTS_MONO,
DTS_MONO, DTS_MONO, DTS_MONO, DTS_MONO,
DTS_MONO, DTS_MONO},
/* DTS_CHANNEL */
{DTS_MONO, DTS_CHANNEL, DTS_STEREO, DTS_STEREO,
DTS_STEREO, DTS_STEREO, DTS_STEREO, DTS_STEREO,
DTS_STEREO, DTS_STEREO},
/* DTS_STEREO */
{DTS_MONO, DTS_CHANNEL, DTS_STEREO, DTS_STEREO,
DTS_STEREO, DTS_STEREO, DTS_STEREO, DTS_STEREO,
DTS_STEREO, DTS_STEREO},
/* DTS_STEREO_SUMDIFF */
{DTS_MONO, DTS_CHANNEL, DTS_STEREO, DTS_STEREO,
DTS_STEREO, DTS_STEREO, DTS_STEREO, DTS_STEREO,
DTS_STEREO, DTS_STEREO},
/* DTS_STEREO_TOTAL */
{DTS_MONO, DTS_CHANNEL, DTS_STEREO, DTS_STEREO,
DTS_STEREO, DTS_STEREO, DTS_STEREO, DTS_STEREO,
DTS_STEREO, DTS_STEREO},
/* DTS_3F */
{DTS_MONO, DTS_CHANNEL, DTS_STEREO, DTS_STEREO,
DTS_STEREO, DTS_3F, DTS_3F, DTS_3F,
DTS_3F, DTS_3F},
/* DTS_2F1R */
{DTS_MONO, DTS_CHANNEL, DTS_STEREO, DTS_STEREO,
DTS_STEREO, DTS_2F1R, DTS_2F1R, DTS_2F1R,
DTS_2F1R, DTS_2F1R},
/* DTS_3F1R */
{DTS_MONO, DTS_CHANNEL, DTS_STEREO, DTS_STEREO,
DTS_STEREO, DTS_3F, DTS_3F1R, DTS_3F1R,
DTS_3F1R, DTS_3F1R},
/* DTS_2F2R */
{DTS_MONO, DTS_CHANNEL, DTS_STEREO, DTS_STEREO,
DTS_STEREO, DTS_STEREO, DTS_2F2R, DTS_2F2R,
DTS_2F2R, DTS_2F2R},
/* DTS_3F2R */
{DTS_MONO, DTS_CHANNEL, DTS_STEREO, DTS_STEREO,
DTS_STEREO, DTS_3F, DTS_3F2R, DTS_3F2R,
DTS_3F2R, DTS_3F2R},
/* DTS_4F2R */
{DTS_MONO, DTS_CHANNEL, DTS_STEREO, DTS_STEREO,
DTS_STEREO, DTS_4F2R, DTS_4F2R, DTS_4F2R,
DTS_4F2R, DTS_4F2R},
};
int output;
output = flags & DTS_CHANNEL_MASK;
if (output > DTS_CHANNEL_MAX)
return -1;
output = table[output][input];
if (output == DTS_STEREO &&
(input == DTS_DOLBY || (input == DTS_3F && clev == LEVEL (LEVEL_3DB))))
output = DTS_DOLBY;
if (flags & DTS_ADJUST_LEVEL) {
level_t adjust;
switch (CONVERT (input & 7, output)) {
case CONVERT (DTS_3F, DTS_MONO):
adjust = (sample_t)(DIV (LEVEL_3DB, LEVEL (1) + clev));
break;
case CONVERT (DTS_STEREO, DTS_MONO):
case CONVERT (DTS_2F2R, DTS_2F1R):
case CONVERT (DTS_3F2R, DTS_3F1R):
level_3db:
adjust = (sample_t)(LEVEL (LEVEL_3DB));
break;
case CONVERT (DTS_3F2R, DTS_2F1R):
if (clev < LEVEL (LEVEL_PLUS3DB - 1))
goto level_3db;
/* break thru */
case CONVERT (DTS_3F, DTS_STEREO):
case CONVERT (DTS_3F1R, DTS_2F1R):
case CONVERT (DTS_3F1R, DTS_2F2R):
case CONVERT (DTS_3F2R, DTS_2F2R):
adjust = DIV (1, LEVEL (1) + clev);
break;
case CONVERT (DTS_2F1R, DTS_MONO):
adjust = (sample_t)(DIV (LEVEL_PLUS3DB, LEVEL (2) + slev));
break;
case CONVERT (DTS_2F1R, DTS_STEREO):
case CONVERT (DTS_3F1R, DTS_3F):
adjust = (sample_t)(DIV (1, LEVEL (1) + MUL_C (slev, LEVEL_3DB)));
break;
case CONVERT (DTS_3F1R, DTS_MONO):
adjust = (sample_t)(DIV (LEVEL_3DB, LEVEL (1) + clev + MUL_C (slev, 0.5)));
break;
case CONVERT (DTS_3F1R, DTS_STEREO):
adjust = (sample_t)(DIV (1, LEVEL (1) + clev + MUL_C (slev, LEVEL_3DB)));
break;
case CONVERT (DTS_2F2R, DTS_MONO):
adjust = (sample_t)(DIV (LEVEL_3DB, LEVEL (1) + slev));
break;
case CONVERT (DTS_2F2R, DTS_STEREO):
case CONVERT (DTS_3F2R, DTS_3F):
adjust = DIV (1, LEVEL (1) + slev);
break;
case CONVERT (DTS_3F2R, DTS_MONO):
adjust = (sample_t)(DIV (LEVEL_3DB, LEVEL (1) + clev + slev));
break;
case CONVERT (DTS_3F2R, DTS_STEREO):
adjust = DIV (1, LEVEL (1) + clev + slev);
break;
case CONVERT (DTS_MONO, DTS_DOLBY):
adjust = (sample_t)(LEVEL (LEVEL_PLUS3DB));
break;
case CONVERT (DTS_3F, DTS_DOLBY):
case CONVERT (DTS_2F1R, DTS_DOLBY):
adjust = (sample_t)(LEVEL (1 / (1 + LEVEL_3DB)));
break;
case CONVERT (DTS_3F1R, DTS_DOLBY):
case CONVERT (DTS_2F2R, DTS_DOLBY):
adjust = (sample_t)(LEVEL (1 / (1 + 2 * LEVEL_3DB)));
break;
case CONVERT (DTS_3F2R, DTS_DOLBY):
adjust = (sample_t)(LEVEL (1 / (1 + 3 * LEVEL_3DB)));
break;
default:
return output;
}
*level = MUL_L (*level, adjust);
}
return output;
}
void a52_upmix (sample_t * samples, int acmod, int output)
{
switch (CONVERT (acmod, output & A52_CHANNEL_MASK)) {
case CONVERT (A52_CHANNEL, A52_CHANNEL2):
memcpy (samples + 256, samples, 256 * sizeof (sample_t));
break;
case CONVERT (A52_3F2R, A52_MONO):
zero (samples + 1024);
case CONVERT (A52_3F1R, A52_MONO):
case CONVERT (A52_2F2R, A52_MONO):
zero (samples + 768);
case CONVERT (A52_3F, A52_MONO):
case CONVERT (A52_2F1R, A52_MONO):
zero (samples + 512);
case CONVERT (A52_CHANNEL, A52_MONO):
case CONVERT (A52_STEREO, A52_MONO):
zero (samples + 256);
break;
case CONVERT (A52_3F2R, A52_STEREO):
case CONVERT (A52_3F2R, A52_DOLBY):
zero (samples + 1024);
case CONVERT (A52_3F1R, A52_STEREO):
case CONVERT (A52_3F1R, A52_DOLBY):
zero (samples + 768);
case CONVERT (A52_3F, A52_STEREO):
case CONVERT (A52_3F, A52_DOLBY):
mix_3to2:
memcpy (samples + 512, samples + 256, 256 * sizeof (sample_t));
zero (samples + 256);
break;
case CONVERT (A52_2F2R, A52_STEREO):
case CONVERT (A52_2F2R, A52_DOLBY):
zero (samples + 768);
case CONVERT (A52_2F1R, A52_STEREO):
case CONVERT (A52_2F1R, A52_DOLBY):
zero (samples + 512);
break;
case CONVERT (A52_3F2R, A52_3F):
zero (samples + 1024);
case CONVERT (A52_3F1R, A52_3F):
case CONVERT (A52_2F2R, A52_2F1R):
zero (samples + 768);
break;
case CONVERT (A52_3F2R, A52_3F1R):
zero (samples + 1024);
break;
case CONVERT (A52_3F2R, A52_2F1R):
zero (samples + 1024);
case CONVERT (A52_3F1R, A52_2F1R):
mix_31to21:
memcpy (samples + 768, samples + 512, 256 * sizeof (sample_t));
goto mix_3to2;
case CONVERT (A52_3F2R, A52_2F2R):
memcpy (samples + 1024, samples + 768, 256 * sizeof (sample_t));
goto mix_31to21;
}
}
void dts_downmix (sample_t * samples, int acmod, int output, sample_t bias,
level_t clev, level_t slev)
{
(void)clev;
switch (CONVERT (acmod, output & DTS_CHANNEL_MASK)) {
case CONVERT (DTS_CHANNEL, DTS_MONO):
case CONVERT (DTS_STEREO, DTS_MONO):
mix_2to1:
mix2to1 (samples, samples + 256, bias);
break;
case CONVERT (DTS_2F1R, DTS_MONO):
if (slev == 0)
goto mix_2to1;
case CONVERT (DTS_3F, DTS_MONO):
mix_3to1:
mix3to1 (samples, bias);
break;
case CONVERT (DTS_3F1R, DTS_MONO):
if (slev == 0)
goto mix_3to1;
case CONVERT (DTS_2F2R, DTS_MONO):
if (slev == 0)
goto mix_2to1;
mix4to1 (samples, bias);
break;
case CONVERT (DTS_3F2R, DTS_MONO):
if (slev == 0)
goto mix_3to1;
mix5to1 (samples, bias);
break;
case CONVERT (DTS_MONO, DTS_DOLBY):
memcpy (samples + 256, samples, 256 * sizeof (sample_t));
break;
case CONVERT (DTS_3F, DTS_STEREO):
case CONVERT (DTS_3F, DTS_DOLBY):
mix_3to2:
mix3to2 (samples, bias);
break;
case CONVERT (DTS_2F1R, DTS_STEREO):
if (slev == 0)
break;
mix21to2 (samples, samples + 256, bias);
break;
case CONVERT (DTS_2F1R, DTS_DOLBY):
mix21toS (samples, bias);
break;
case CONVERT (DTS_3F1R, DTS_STEREO):
if (slev == 0)
goto mix_3to2;
mix31to2 (samples, bias);
break;
case CONVERT (DTS_3F1R, DTS_DOLBY):
mix31toS (samples, bias);
break;
case CONVERT (DTS_2F2R, DTS_STEREO):
if (slev == 0)
break;
mix2to1 (samples, samples + 512, bias);
mix2to1 (samples + 256, samples + 768, bias);
break;
case CONVERT (DTS_2F2R, DTS_DOLBY):
mix22toS (samples, bias);
break;
case CONVERT (DTS_3F2R, DTS_STEREO):
if (slev == 0)
goto mix_3to2;
mix32to2 (samples, bias);
break;
case CONVERT (DTS_3F2R, DTS_DOLBY):
mix32toS (samples, bias);
break;
case CONVERT (DTS_3F1R, DTS_3F):
if (slev == 0)
break;
mix21to2 (samples, samples + 512, bias);
break;
case CONVERT (DTS_3F2R, DTS_3F):
if (slev == 0)
break;
mix2to1 (samples, samples + 768, bias);
mix2to1 (samples + 512, samples + 1024, bias);
break;
case CONVERT (DTS_3F1R, DTS_2F1R):
mix3to2 (samples, bias);
memcpy (samples + 512, samples + 768, 256 * sizeof (sample_t));
break;
case CONVERT (DTS_2F2R, DTS_2F1R):
mix2to1 (samples + 512, samples + 768, bias);
break;
case CONVERT (DTS_3F2R, DTS_2F1R):
mix3to2 (samples, bias);
move2to1 (samples + 768, samples + 512, bias);
break;
case CONVERT (DTS_3F2R, DTS_3F1R):
mix2to1 (samples + 768, samples + 1024, bias);
break;
case CONVERT (DTS_2F1R, DTS_2F2R):
memcpy (samples + 768, samples + 512, 256 * sizeof (sample_t));
break;
case CONVERT (DTS_3F1R, DTS_2F2R):
mix3to2 (samples, bias);
memcpy (samples + 512, samples + 768, 256 * sizeof (sample_t));
break;
case CONVERT (DTS_3F2R, DTS_2F2R):
mix3to2 (samples, bias);
memcpy (samples + 512, samples + 768, 256 * sizeof (sample_t));
memcpy (samples + 768, samples + 1024, 256 * sizeof (sample_t));
break;
case CONVERT (DTS_3F1R, DTS_3F2R):
memcpy (samples + 1024, samples + 768, 256 * sizeof (sample_t));
break;
}
}
#define LOOKUP_COEFFS int ruv = CoefsRV[*pv]; \
int guv = CoefsGU[*pu] + CoefsGV[*pv]; \
int buv = CoefsBU[*pu]; \
int r, g, b;
/* yuv420p, yuv422p -> */
#define CONVERT(OUTPUT_FUNC) LOOKUP_COEFFS \
VANILLA_YUV2RGB_PIXEL(py[0], ruv, guv, buv) \
OUTPUT_FUNC(dst, r, g, b) \
VANILLA_YUV2RGB_PIXEL(py[1], ruv, guv, buv) \
OUTPUT_FUNC((dst+4), r, g, b)
#define CLEANUP
YUV_CONVERT(yuv420_to_rgba_vanilla, CONVERT(VANILLA_RGBA_OUT), VANILLA_RGBA_OUT, 2, 8, 2, 1, 2)
YUV_CONVERT(yuv420_to_bgra_vanilla, CONVERT(VANILLA_BGRA_OUT), VANILLA_BGRA_OUT, 2, 8, 2, 1, 2)
YUV_CONVERT(yuv420_to_abgr_vanilla, CONVERT(VANILLA_ABGR_OUT), VANILLA_ABGR_OUT, 2, 8, 2, 1, 2)
YUV_CONVERT(yuv420_to_argb_vanilla, CONVERT(VANILLA_ARGB_OUT), VANILLA_ARGB_OUT, 2, 8, 2, 1, 2)
YUV_CONVERT(yuv422_to_rgba_vanilla, CONVERT(VANILLA_RGBA_OUT), VANILLA_RGBA_OUT, 2, 8, 2, 1, 1)
YUV_CONVERT(yuv422_to_bgra_vanilla, CONVERT(VANILLA_BGRA_OUT), VANILLA_BGRA_OUT, 2, 8, 2, 1, 1)
YUV_CONVERT(yuv422_to_abgr_vanilla, CONVERT(VANILLA_ABGR_OUT), VANILLA_ABGR_OUT, 2, 8, 2, 1, 1)
YUV_CONVERT(yuv422_to_argb_vanilla, CONVERT(VANILLA_ARGB_OUT), VANILLA_ARGB_OUT, 2, 8, 2, 1, 1)
#undef CONVERT
/* yuv444p -> */
#define CONVERT(OUTPUT_FUNC) LOOKUP_COEFFS \
VANILLA_YUV2RGB_PIXEL(py[0], ruv, guv, buv) \
OUTPUT_FUNC(dst, r, g, b)
void
x_drawable_rep::set_color (color c) {
cur_fg= c;
XSetForeground (dpy, gc, CONVERT (blend (cur_fg, cur_bg)));
}
void phyMgr::setGravity(const Vec3& gravity)
{
_dynamics_world->setGravity(CONVERT(gravity));
}
void
x_drawable_rep::set_background (color c) {
cur_bg= c;
XSetBackground (dpy, gc, CONVERT (cur_bg));
}
/*
* Creates the DIEFFECT from a SDL_HapticEffect.
*/
static int
SDL_SYS_ToDIEFFECT(SDL_Haptic * haptic, DIEFFECT * dest,
SDL_HapticEffect * src)
{
int i;
DICONSTANTFORCE *constant;
DIPERIODIC *periodic;
DICONDITION *condition; /* Actually an array of conditions - one per axis. */
DIRAMPFORCE *ramp;
DICUSTOMFORCE *custom;
DIENVELOPE *envelope;
SDL_HapticConstant *hap_constant;
SDL_HapticPeriodic *hap_periodic;
SDL_HapticCondition *hap_condition;
SDL_HapticRamp *hap_ramp;
SDL_HapticCustom *hap_custom;
DWORD *axes;
/* Set global stuff. */
SDL_memset(dest, 0, sizeof(DIEFFECT));
dest->dwSize = sizeof(DIEFFECT); /* Set the structure size. */
dest->dwSamplePeriod = 0; /* Not used by us. */
dest->dwGain = 10000; /* Gain is set globally, not locally. */
dest->dwFlags = DIEFF_OBJECTOFFSETS; /* Seems obligatory. */
/* Envelope. */
envelope = SDL_malloc(sizeof(DIENVELOPE));
if (envelope == NULL) {
return SDL_OutOfMemory();
}
SDL_memset(envelope, 0, sizeof(DIENVELOPE));
dest->lpEnvelope = envelope;
envelope->dwSize = sizeof(DIENVELOPE); /* Always should be this. */
/* Axes. */
dest->cAxes = haptic->naxes;
if (dest->cAxes > 0) {
axes = SDL_malloc(sizeof(DWORD) * dest->cAxes);
if (axes == NULL) {
return SDL_OutOfMemory();
}
axes[0] = haptic->hwdata->axes[0]; /* Always at least one axis. */
if (dest->cAxes > 1) {
axes[1] = haptic->hwdata->axes[1];
}
if (dest->cAxes > 2) {
axes[2] = haptic->hwdata->axes[2];
}
dest->rgdwAxes = axes;
}
/* The big type handling switch, even bigger than Linux's version. */
switch (src->type) {
case SDL_HAPTIC_CONSTANT:
hap_constant = &src->constant;
constant = SDL_malloc(sizeof(DICONSTANTFORCE));
if (constant == NULL) {
return SDL_OutOfMemory();
}
SDL_memset(constant, 0, sizeof(DICONSTANTFORCE));
/* Specifics */
constant->lMagnitude = CONVERT(hap_constant->level);
dest->cbTypeSpecificParams = sizeof(DICONSTANTFORCE);
dest->lpvTypeSpecificParams = constant;
/* Generics */
dest->dwDuration = hap_constant->length * 1000; /* In microseconds. */
dest->dwTriggerButton = DIGetTriggerButton(hap_constant->button);
dest->dwTriggerRepeatInterval = hap_constant->interval;
dest->dwStartDelay = hap_constant->delay * 1000; /* In microseconds. */
/* Direction. */
if (SDL_SYS_SetDirection(dest, &hap_constant->direction, dest->cAxes) < 0) {
return -1;
}
/* Envelope */
if ((hap_constant->attack_length == 0)
&& (hap_constant->fade_length == 0)) {
SDL_free(dest->lpEnvelope);
dest->lpEnvelope = NULL;
} else {
envelope->dwAttackLevel = CCONVERT(hap_constant->attack_level);
envelope->dwAttackTime = hap_constant->attack_length * 1000;
envelope->dwFadeLevel = CCONVERT(hap_constant->fade_level);
envelope->dwFadeTime = hap_constant->fade_length * 1000;
}
break;
case SDL_HAPTIC_SINE:
/* !!! FIXME: put this back when we have more bits in 2.1 */
/* case SDL_HAPTIC_SQUARE: */
case SDL_HAPTIC_TRIANGLE:
case SDL_HAPTIC_SAWTOOTHUP:
case SDL_HAPTIC_SAWTOOTHDOWN:
hap_periodic = &src->periodic;
periodic = SDL_malloc(sizeof(DIPERIODIC));
if (periodic == NULL) {
return SDL_OutOfMemory();
}
SDL_memset(periodic, 0, sizeof(DIPERIODIC));
/* Specifics */
periodic->dwMagnitude = CONVERT(SDL_abs(hap_periodic->magnitude));
periodic->lOffset = CONVERT(hap_periodic->offset);
periodic->dwPhase =
(hap_periodic->phase + (hap_periodic->magnitude < 0 ? 18000 : 0)) % 36000;
periodic->dwPeriod = hap_periodic->period * 1000;
dest->cbTypeSpecificParams = sizeof(DIPERIODIC);
dest->lpvTypeSpecificParams = periodic;
/* Generics */
dest->dwDuration = hap_periodic->length * 1000; /* In microseconds. */
dest->dwTriggerButton = DIGetTriggerButton(hap_periodic->button);
dest->dwTriggerRepeatInterval = hap_periodic->interval;
dest->dwStartDelay = hap_periodic->delay * 1000; /* In microseconds. */
/* Direction. */
if (SDL_SYS_SetDirection(dest, &hap_periodic->direction, dest->cAxes)
< 0) {
return -1;
}
/* Envelope */
if ((hap_periodic->attack_length == 0)
&& (hap_periodic->fade_length == 0)) {
SDL_free(dest->lpEnvelope);
dest->lpEnvelope = NULL;
} else {
envelope->dwAttackLevel = CCONVERT(hap_periodic->attack_level);
envelope->dwAttackTime = hap_periodic->attack_length * 1000;
envelope->dwFadeLevel = CCONVERT(hap_periodic->fade_level);
envelope->dwFadeTime = hap_periodic->fade_length * 1000;
}
break;
case SDL_HAPTIC_SPRING:
case SDL_HAPTIC_DAMPER:
case SDL_HAPTIC_INERTIA:
case SDL_HAPTIC_FRICTION:
hap_condition = &src->condition;
condition = SDL_malloc(sizeof(DICONDITION) * dest->cAxes);
if (condition == NULL) {
return SDL_OutOfMemory();
}
SDL_memset(condition, 0, sizeof(DICONDITION));
/* Specifics */
for (i = 0; i < (int) dest->cAxes; i++) {
condition[i].lOffset = CONVERT(hap_condition->center[i]);
condition[i].lPositiveCoefficient =
CONVERT(hap_condition->right_coeff[i]);
condition[i].lNegativeCoefficient =
CONVERT(hap_condition->left_coeff[i]);
condition[i].dwPositiveSaturation =
CCONVERT(hap_condition->right_sat[i] / 2);
condition[i].dwNegativeSaturation =
CCONVERT(hap_condition->left_sat[i] / 2);
condition[i].lDeadBand = CCONVERT(hap_condition->deadband[i] / 2);
}
dest->cbTypeSpecificParams = sizeof(DICONDITION) * dest->cAxes;
dest->lpvTypeSpecificParams = condition;
/* Generics */
dest->dwDuration = hap_condition->length * 1000; /* In microseconds. */
dest->dwTriggerButton = DIGetTriggerButton(hap_condition->button);
dest->dwTriggerRepeatInterval = hap_condition->interval;
dest->dwStartDelay = hap_condition->delay * 1000; /* In microseconds. */
/* Direction. */
if (SDL_SYS_SetDirection(dest, &hap_condition->direction, dest->cAxes)
< 0) {
return -1;
}
/* Envelope - Not actually supported by most CONDITION implementations. */
SDL_free(dest->lpEnvelope);
dest->lpEnvelope = NULL;
break;
case SDL_HAPTIC_RAMP:
hap_ramp = &src->ramp;
ramp = SDL_malloc(sizeof(DIRAMPFORCE));
if (ramp == NULL) {
return SDL_OutOfMemory();
}
SDL_memset(ramp, 0, sizeof(DIRAMPFORCE));
/* Specifics */
ramp->lStart = CONVERT(hap_ramp->start);
ramp->lEnd = CONVERT(hap_ramp->end);
dest->cbTypeSpecificParams = sizeof(DIRAMPFORCE);
dest->lpvTypeSpecificParams = ramp;
/* Generics */
dest->dwDuration = hap_ramp->length * 1000; /* In microseconds. */
dest->dwTriggerButton = DIGetTriggerButton(hap_ramp->button);
dest->dwTriggerRepeatInterval = hap_ramp->interval;
dest->dwStartDelay = hap_ramp->delay * 1000; /* In microseconds. */
/* Direction. */
if (SDL_SYS_SetDirection(dest, &hap_ramp->direction, dest->cAxes) < 0) {
return -1;
}
/* Envelope */
if ((hap_ramp->attack_length == 0) && (hap_ramp->fade_length == 0)) {
SDL_free(dest->lpEnvelope);
dest->lpEnvelope = NULL;
} else {
envelope->dwAttackLevel = CCONVERT(hap_ramp->attack_level);
envelope->dwAttackTime = hap_ramp->attack_length * 1000;
envelope->dwFadeLevel = CCONVERT(hap_ramp->fade_level);
envelope->dwFadeTime = hap_ramp->fade_length * 1000;
}
break;
case SDL_HAPTIC_CUSTOM:
hap_custom = &src->custom;
custom = SDL_malloc(sizeof(DICUSTOMFORCE));
if (custom == NULL) {
return SDL_OutOfMemory();
}
SDL_memset(custom, 0, sizeof(DICUSTOMFORCE));
/* Specifics */
custom->cChannels = hap_custom->channels;
custom->dwSamplePeriod = hap_custom->period * 1000;
custom->cSamples = hap_custom->samples;
custom->rglForceData =
SDL_malloc(sizeof(LONG) * custom->cSamples * custom->cChannels);
for (i = 0; i < hap_custom->samples * hap_custom->channels; i++) { /* Copy data. */
custom->rglForceData[i] = CCONVERT(hap_custom->data[i]);
}
dest->cbTypeSpecificParams = sizeof(DICUSTOMFORCE);
dest->lpvTypeSpecificParams = custom;
/* Generics */
dest->dwDuration = hap_custom->length * 1000; /* In microseconds. */
dest->dwTriggerButton = DIGetTriggerButton(hap_custom->button);
dest->dwTriggerRepeatInterval = hap_custom->interval;
dest->dwStartDelay = hap_custom->delay * 1000; /* In microseconds. */
/* Direction. */
if (SDL_SYS_SetDirection(dest, &hap_custom->direction, dest->cAxes) < 0) {
return -1;
}
/* Envelope */
if ((hap_custom->attack_length == 0)
&& (hap_custom->fade_length == 0)) {
SDL_free(dest->lpEnvelope);
dest->lpEnvelope = NULL;
} else {
envelope->dwAttackLevel = CCONVERT(hap_custom->attack_level);
envelope->dwAttackTime = hap_custom->attack_length * 1000;
envelope->dwFadeLevel = CCONVERT(hap_custom->fade_level);
envelope->dwFadeTime = hap_custom->fade_length * 1000;
}
break;
default:
return SDL_SetError("Haptic: Unknown effect type.");
}
return 0;
}
static void setEffect(DirectInputEffect *dinputEffect, const DIEFFECT *di_eff)
{
uint32_t i;
switch (dinputEffect->real_type)
{
case SDL_HAPTIC_CONSTANT:
{
DICONSTANTFORCE *di_constant = (DICONSTANTFORCE *)di_eff->typeSpecificParams;
if (dinputEffect->effect.type == SDL_HAPTIC_SINE)
{
SDL_HapticPeriodic *periodic = &dinputEffect->effect.periodic;
if (di_constant)
periodic->magnitude = CONVERT(di_constant->magnitude);
periodic->length = CONVERT_LENGTH(di_eff->duration);
// printf("Constant as Sine: %d, %d\n", periodic->length, periodic->magnitude);
}
else
{
SDL_HapticConstant *constant = &dinputEffect->effect.constant;
if (di_constant)
constant->level = CONVERT(di_constant->magnitude);
constant->length = CONVERT_LENGTH(di_eff->duration);
constant->direction.type = SDL_HAPTIC_POLAR; //di_eff->flags shows that POLAR is used (0x20)
for (i = 0; i < di_eff->cAxes; ++i)
constant->direction.dir[i] = di_eff->rglDirection[i];
// printf("Constant: %d %d %d, %X\n", constant->length, constant->level, di_eff->cAxes, di_eff->flags);
}
} break;
case SDL_HAPTIC_SINE:
{
DIPERIODIC *di_periodic = (DIPERIODIC *)di_eff->typeSpecificParams;
SDL_HapticPeriodic *periodic = &dinputEffect->effect.periodic;
if (di_periodic)
{
periodic->magnitude = CONVERT(di_periodic->magnitude);
periodic->offset = CONVERT(di_periodic->offset);
periodic->period = (uint16_t)CONVERT_LENGTH(di_periodic->period);
periodic->phase = di_periodic->phase;
}
periodic->length = CONVERT_LENGTH(di_eff->duration);
if (di_eff->envelope)
setEnvelope(&periodic->attack_length, &periodic->attack_level, &periodic->fade_length, &periodic->fade_level, di_eff->envelope);
// printf("Square as Sine: %d\n", periodic->magnitude);
} break;
case SDL_HAPTIC_SPRING:
{
/* Deadband always 0, Coeff and Saturation always the same */
if (dinputEffect->effect.type == SDL_HAPTIC_SPRING)
{
/* Is it OK? I can't test it! */
SDL_HapticCondition *condition = &dinputEffect->effect.condition;
for (i = 0; i < di_eff->cAxes; ++i)
{
DICONDITION *di_condition = (DICONDITION *)di_eff->typeSpecificParams + i;
condition->center[i] = CONVERT(di_condition->lOffset);
condition->right_coeff[i] = CONVERT(di_condition->lPositiveCoefficient);
condition->left_coeff[i] = CONVERT(di_condition->lNegativeCoefficient);
condition->right_sat[i] = CONVERT(di_condition->dwPositiveSaturation);
condition->left_sat[i] = CONVERT(di_condition->dwNegativeSaturation);
condition->deadband[i] = CONVERT(di_condition->lDeadBand);
// printf("Spring[%d]: %d %d %d %d %d %d\n", i, condition->center[i], condition->right_coeff[i], condition->left_coeff[i], condition->right_sat[i], condition->left_sat[i], condition->deadband[i]);
}
condition->length = CONVERT_LENGTH(di_eff->duration);
}
else if (dinputEffect->effect.type == SDL_HAPTIC_CONSTANT && di_eff->cAxes)
{
/* Simulate Spring with Constant - this probably works bad :D */
SDL_HapticConstant *constant = &dinputEffect->effect.constant;
DICONDITION *di_condition = (DICONDITION *)di_eff->typeSpecificParams;
int32_t axis = *dinputEffect->xAxis * 20000 / 65535 - 10000;
int32_t force;
if (*dinputEffect->xAxis > 0)
force = di_condition->lPositiveCoefficient * (axis - di_condition->lOffset);
else
force = di_condition->lNegativeCoefficient * (axis - di_condition->lOffset);
constant->direction.type = SDL_HAPTIC_CARTESIAN;
constant->direction.dir[0] = (force == 0) ? 0 : (force < 0 ? -1 : 1);
constant->attack_level = SDL_abs(force / 3052);
constant->attack_length = (uint16_t)CONVERT_LENGTH(di_eff->duration);
// printf("Spring as Constant: coeffP: %d, coeffN: %d, offset: %d, xAxis: %d, force: %d, attack: %d\n", di_condition->lPositiveCoefficient, di_condition->lNegativeCoefficient, di_condition->lOffset, axis, force, force / 3052);
}
} break;
}
}
