//axis aligned circle for setting up brushes for thick lines
void rs_gdImageCircleForBrush(gdImagePtr im, int x, int y, int rad, RS_Color& color)
{
int gdc = ConvertColor(im, color);
float rad2 = (float)rad*rad;
for (int j = -rad, k = y+j; j <= rad; j++, k++)
{
float j_offset = j + 0.5f;
float hlen = sqrt(rad2 - j_offset*j_offset);
int solidwid = (int)hlen;
if (solidwid)
gdImageLine(im, x-solidwid, k, x+solidwid-1, k, gdc);
float aalpha = hlen - solidwid;
RS_Color ac = color;
ac.alpha() = (int)(ac.alpha() * aalpha);
int gdc2 = ConvertColor(im, ac);
gdImageSetPixel(im, x-solidwid-1, k, gdc2);
gdImageSetPixel(im, x+solidwid, k, gdc2);
}
}
int JRenderServer::AddDirLight( const Vec3& dir, DWORD diffuse, DWORD specular, bool bPerPixel )
{
D3DLIGHT8 light;
light.Type = D3DLIGHT_DIRECTIONAL ;
light.Diffuse = ConvertColor( diffuse );
light.Specular = ConvertColor( specular );
light.Ambient = ConvertColor( 0xFF000000 );
Vec3 ldir( dir.x, dir.y, dir.z );
ldir.normalize();
light.Direction.x = ldir.x;
light.Direction.y = ldir.y;
light.Direction.z = ldir.z;
light.Range = 100.0f;
light.Position.x = 0.0f;
light.Position.y = 0.0f;
light.Position.z = 0.0f;
light.Attenuation0 = 0.0f;
light.Attenuation1 = 0.0f;
light.Attenuation2 = 0.0f;
light.Falloff = 0.0f;
light.Theta = c_PI;
light.Phi = c_PI;
IDirect3DDevice8* pDevice = GetDirect3DDevice8();
pDevice->LightEnable( 0, TRUE );
pDevice->SetLight ( 0, &light );
return 0;
} // JRenderServer::AddDirLight
void ConvertStyle(ShieldRuleProto const * pSrc, double scale, dp::FontDecl & dest)
{
// fonts smaller than 8px look "jumpy" on LDPI devices
uint8_t const h = max(8, static_cast<int>(pSrc->height() * scale));
dest = dp::FontDecl(ConvertColor(pSrc->color()), h);
if (pSrc->has_stroke_color())
dest.m_outlineColor = ConvertColor(pSrc->stroke_color());
}
void Render(SDL_Window* window, SDL_GLContext context) {
SDL_GL_MakeCurrent(window, context);
glClearColor(ConvertColor(69), ConvertColor(177), ConvertColor(237), 1);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glMatrixMode(GL_PROJECTION);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
environment.Draw();
player.Draw();
environment.DrawForeground();
SDL_GL_SwapWindow(window);
}
static void WINAPI addcolor(intptr_t lno,intptr_t start,intptr_t len,const struct ABColor* color,enum ColorizePriority priority)
{
if((color->ForegroundDefault)&&(color->BackgroundDefault)) return;
if(len==0) return;
WaitForSingleObject(Mutex,INFINITE);
EditorColor ec;
ec.StructSize=sizeof(ec);
ec.StringNumber=lno;
ec.StartPos=start;
ec.EndPos=start+len-1;
ConvertColor(*color,ec.Color);
ec.Owner=MainGuid;
switch(priority)
{
case EPriorityNormal:
ec.Priority=0;
break;
case EPriorityBrackets:
ec.Priority=100;
break;
}
ec.Flags=ECF_AUTODELETE;
Info.EditorControl(-1,ECTL_ADDCOLOR,0,&ec);
ReleaseMutex(Mutex);
}
void ConvertStyle(CaptionDefProto const * pSrc, double scale, dp::FontDecl & dest, m2::PointD & offset)
{
// fonts smaller than 8px look "jumpy" on LDPI devices
uint8_t const h = max(8, static_cast<int>(pSrc->height() * scale));
offset = m2::PointD(0, 0);
if (pSrc->has_offset_x())
offset.x = scale * pSrc->offset_x();
if (pSrc->has_offset_y())
offset.y = scale * pSrc->offset_y();
dest = dp::FontDecl(ConvertColor(pSrc->color()), h);
if (pSrc->has_stroke_color())
dest.m_outlineColor = ConvertColor(pSrc->stroke_color());
}
Vector4 ChatWindow::GetColor(char c){
switch(c){
case MsgColorTeam1:
if(client->GetWorld())
return ConvertColor(client->GetWorld()->GetTeam(0).color);
case MsgColorTeam2:
if(client->GetWorld())
return ConvertColor(client->GetWorld()->GetTeam(1).color);
case MsgColorTeam3:
if(client->GetWorld())
return ConvertColor(client->GetWorld()->GetTeam(2).color);
case MsgColorRed:
return MakeVector4(1,0,0,1);
case MsgColorSysInfo:
return MakeVector4(0,1,0,1);
default:
return MakeVector4(1,1,1,1);
}
}
// push Renderable nodes
//virtual
bool ControlPointGob::GetRenderables(RenderableNodeCollector* collector, RenderContext* context)
{
Mesh* mesh = ShapeLibGetMesh(RenderShape::QuadLineStrip);
m_localBounds = mesh->bounds;
const float pointSize = 8; // control point size in pixels
float upp = context->Cam().ComputeUnitPerPixel(float3(&m_world.M41),
context->ViewPort().y);
float scale = pointSize * upp;
Matrix scaleM = Matrix::CreateScale(scale);
float3 objectPos = float3(m_world.M41,m_world.M42,m_world.M43);
Matrix b = Matrix::CreateBillboard(objectPos,context->Cam().CamPos(),context->Cam().CamUp(),context->Cam().CamLook());
Matrix billboard = scaleM * b;
// calculate bounds for screen facing quad
float3 transformed, min, max;
transformed = mesh->pos[0];
transformed.Transform(billboard);
min = max = transformed;
for (auto it = mesh->pos.begin(); it != mesh->pos.end(); ++it)
{
transformed = (*it);
transformed.Transform(billboard);
min = minimize(min, transformed);
max = maximize(max, transformed);
}
m_bounds = AABB(min,max);
// give it same color as curve
int color = 0xFFFF0000;
CurveGob* curve = (CurveGob*)m_parent;
if(curve != NULL)
{
color = curve->GetColor();
}
// set renderable
RenderableNode r;
r.mesh = mesh;
ConvertColor(color, &r.diffuse);
r.objectId = GetInstanceId();
r.bounds = m_bounds;
r.WorldXform = billboard;
r.SetFlag(RenderableNode::kTestAgainstBBoxOnly, true);
r.SetFlag(RenderableNode::kShadowCaster, false);
r.SetFlag(RenderableNode::kShadowReceiver, false);
collector->Add(r, RenderFlags::None, Shaders::BasicShader);
return true;
}
void ConvertStyle(CircleRuleProto const * pSrc, double scale, CircleInfo & dest)
{
dest = CircleInfo(pSrc->radius() * scale, ConvertColor(pSrc->color()));
if (pSrc->has_border())
{
PenInfo pen;
ConvertStyle(&(pSrc->border()), scale, pen);
dest.m_isOutlined = true;
dest.m_outlineColor = pen.m_color;
dest.m_outlineWidth = pen.m_w;
}
}
/**
* Function description
*
* @return 0 on success, otherwise a Win32 error code
*/
static UINT gdi_SolidFill(RdpgfxClientContext* context,
const RDPGFX_SOLID_FILL_PDU* solidFill)
{
UINT status = CHANNEL_RC_OK;
UINT16 index;
UINT32 color;
BYTE a, r, g, b;
UINT32 nWidth, nHeight;
RECTANGLE_16* rect;
gdiGfxSurface* surface;
RECTANGLE_16 invalidRect;
rdpGdi* gdi = (rdpGdi*) context->custom;
surface = (gdiGfxSurface*) context->GetSurfaceData(context,
solidFill->surfaceId);
if (!surface)
return ERROR_INTERNAL_ERROR;
b = solidFill->fillPixel.B;
g = solidFill->fillPixel.G;
r = solidFill->fillPixel.R;
a = solidFill->fillPixel.XA;
color = GetColor(PIXEL_FORMAT_ARGB32, r, g, b, a);
color = ConvertColor(color, PIXEL_FORMAT_ARGB32, surface->format,
&gdi->palette);
for (index = 0; index < solidFill->fillRectCount; index++)
{
rect = &(solidFill->fillRects[index]);
nWidth = rect->right - rect->left;
nHeight = rect->bottom - rect->top;
invalidRect.left = rect->left;
invalidRect.top = rect->top;
invalidRect.right = rect->right;
invalidRect.bottom = rect->bottom;
freerdp_image_fill(surface->data, surface->format, surface->scanline,
rect->left, rect->top, nWidth, nHeight, color);
region16_union_rect(&(surface->invalidRegion), &(surface->invalidRegion),
&invalidRect);
}
if (!gdi->inGfxFrame)
{
status = CHANNEL_RC_NOT_INITIALIZED;
IFCALLRET(context->UpdateSurfaces, status, context);
}
return status;
}
static BOOL wf_decode_color(wfContext* wfc, const UINT32 srcColor,
COLORREF* color, UINT32* format)
{
rdpGdi* gdi;
rdpSettings* settings;
UINT32 SrcFormat, DstFormat;
if (!wfc)
return FALSE;
gdi = wfc->context.gdi;
settings = wfc->context.settings;
if (!gdi || !settings)
return FALSE;
SrcFormat = gdi_get_pixel_format(gdi->context->settings->ColorDepth,
FALSE);
if (format)
*format = SrcFormat;
switch (GetBitsPerPixel(gdi->dstFormat))
{
case 32:
DstFormat = PIXEL_FORMAT_ABGR32;
break;
case 24:
DstFormat = PIXEL_FORMAT_BGR24;
break;
case 16:
DstFormat = PIXEL_FORMAT_RGB16;
break;
default:
return FALSE;
}
*color = ConvertColor(srcColor, SrcFormat,
DstFormat, &gdi->palette);
return TRUE;
}
// ------------------------------------------------------------------------------------------------
void ConvertColor(aiColor4D& out, const IfcColourOrFactor& in,ConversionData& conv,const aiColor4D* base)
{
if (const EXPRESS::REAL* const r = in.ToPtr<EXPRESS::REAL>()) {
out.r = out.g = out.b = static_cast<float>(*r);
if(base) {
out.r *= static_cast<float>( base->r );
out.g *= static_cast<float>( base->g );
out.b *= static_cast<float>( base->b );
out.a = static_cast<float>( base->a );
}
else out.a = 1.0;
}
else if (const IfcColourRgb* const rgb = in.ResolveSelectPtr<IfcColourRgb>(conv.db)) {
ConvertColor(out,*rgb);
}
else {
IFCImporter::LogWarn("skipping unknown IfcColourOrFactor entity");
}
}
BOOL xf_decode_color(rdpGdi* gdi, const UINT32 srcColor,
UINT32* color, UINT32* format)
{
xfContext* xfc;
UINT32 DstFormat;
UINT32 SrcFormat;
if (!gdi || !gdi->context || !gdi->context->settings)
return FALSE;
xfc = (xfContext*)gdi->context;
SrcFormat = gdi_get_pixel_format(gdi->context->settings->ColorDepth);
if (format)
*format = SrcFormat;
DstFormat = xf_get_local_color_format(xfc, FALSE);
*color = ConvertColor(srcColor, SrcFormat,
DstFormat, &gdi->palette);
return TRUE;
}
INLINE BOOL gdi_decode_color(rdpGdi* gdi, const UINT32 srcColor,
UINT32* color, UINT32* format)
{
UINT32 SrcFormat;
UINT32 ColorDepth;
if (!gdi || !color || !gdi->context || !gdi->context->settings)
return FALSE;
ColorDepth = gdi->context->settings->ColorDepth;
switch (ColorDepth)
{
case 32:
case 24:
SrcFormat = PIXEL_FORMAT_BGR24;
break;
case 16:
SrcFormat = PIXEL_FORMAT_RGB16;
break;
case 15:
SrcFormat = PIXEL_FORMAT_RGB15;
break;
case 8:
SrcFormat = PIXEL_FORMAT_RGB8;
break;
default:
return FALSE;
}
if (format)
*format = gdi->dstFormat;
*color = ConvertColor(srcColor, SrcFormat, gdi->dstFormat, &gdi->palette);
return TRUE;
}
//-----------------------------------------------------------------------------------------------------------------------------------
// push Renderable nodes
//virtual
void CurveGob::GetRenderables(RenderableNodeCollector* collector, RenderContext* context)
{
if (!IsVisible(context->Cam().GetFrustum()) || m_points.size() < 2)
return;
super::GetRenderables(collector, context);
RenderableNode r;
r.mesh = &m_mesh;
ConvertColor(m_color, &r.diffuse);
r.objectId = GetInstanceId();
r.SetFlag( RenderableNode::kShadowCaster, false );
r.SetFlag( RenderableNode::kShadowReceiver, false );
r.bounds = m_bounds;
r.WorldXform = m_world;
collector->Add( r, RenderFlags::None, Shaders::BasicShader );
// draw control points.
for( auto it = m_points.begin(); it != m_points.end(); ++it)
{
(*it)->GetRenderables(collector,context);
}
}
BOOL gdi_FillRect(HGDI_DC hdc, const HGDI_RECT rect, HGDI_BRUSH hbr)
{
UINT32 x, y;
UINT32 color, dstColor;
BOOL monochrome = FALSE;
UINT32 nXDest, nYDest;
UINT32 nWidth, nHeight;
const BYTE* srcp;
DWORD formatSize;
gdi_RectToCRgn(rect, &nXDest, &nYDest, &nWidth, &nHeight);
if (!hdc || !hbr)
return FALSE;
if (!gdi_ClipCoords(hdc, &nXDest, &nYDest, &nWidth, &nHeight, NULL, NULL))
return TRUE;
switch (hbr->style)
{
case GDI_BS_SOLID:
color = hbr->color;
for (x = 0; x < nWidth; x++)
{
BYTE* dstp = gdi_get_bitmap_pointer(hdc, nXDest + x,
nYDest);
if (dstp)
WriteColor(dstp, hdc->format, color);
}
srcp = gdi_get_bitmap_pointer(hdc, nXDest, nYDest);
formatSize = GetBytesPerPixel(hdc->format);
for (y = 1; y < nHeight; y++)
{
BYTE* dstp = gdi_get_bitmap_pointer(hdc, nXDest, nYDest + y);
memcpy(dstp, srcp, nWidth * formatSize);
}
break;
case GDI_BS_HATCHED:
case GDI_BS_PATTERN:
monochrome = (hbr->pattern->format == PIXEL_FORMAT_MONO);
formatSize = GetBytesPerPixel(hbr->pattern->format);
for (y = 0; y < nHeight; y++)
{
for (x = 0; x < nWidth; x++)
{
const UINT32 yOffset = ((nYDest + y) * hbr->pattern->width %
hbr->pattern->height) * formatSize;
const UINT32 xOffset = ((nXDest + x) % hbr->pattern->width) * formatSize;
const BYTE* patp = &hbr->pattern->data[yOffset + xOffset];
BYTE* dstp = gdi_get_bitmap_pointer(hdc, nXDest + x,
nYDest + y);
if (!patp)
return FALSE;
if (monochrome)
{
if (*patp == 0)
dstColor = hdc->bkColor;
else
dstColor = hdc->textColor;
}
else
{
dstColor = ReadColor(patp, hbr->pattern->format);
dstColor = ConvertColor(dstColor, hbr->pattern->format, hdc->format, NULL);
}
if (dstp)
WriteColor(dstp, hdc->format, dstColor);
}
}
break;
default:
break;
}
if (!gdi_InvalidateRegion(hdc, nXDest, nYDest, nWidth, nHeight))
return FALSE;
return TRUE;
}
Ptr<text::DocumentModel> BuildDocumentModel(const WString& fileName, List<Ptr<GifRun>>& animations)
{
HDC dc=CreateCompatibleDC(NULL);
int dpi=GetDeviceCaps(dc, LOGPIXELSY);
DeleteDC(dc);
Ptr<text::DocumentModel> document=new text::DocumentModel;
WString rawDocument;
{
FileStream fileStream(fileName, FileStream::ReadOnly);
BomDecoder decoder;
DecoderStream decoderStream(fileStream, decoder);
StreamReader reader(decoderStream);
rawDocument=reader.ReadToEnd();
}
WString regexTag_s=L"<(<tag>s)>(<font>[^:]+):(<bold>[^:]+):(<color>[^:]+):(<size>[^:]+):(<text>/.*?)<//s>";
WString regexTag_i=L"<(<tag>i)>(<cx>[^:]+),(<cy>[^:]+):(<b>[^:]+):(<file>/.*?)<//i>";
WString regexTag_p=L"<(<tag>p)//>";
Regex regexTag(regexTag_s+L"|"+regexTag_i+L"|"+regexTag_p);
Regex regexLine(L"\r\n");
RegexMatch::List matches;
regexTag.Search(rawDocument, matches);
Ptr<text::DocumentParagraph> paragraph=0;
Ptr<text::DocumentLine> line=0;
for(int i=0;i<matches.Count();i++)
{
Ptr<RegexMatch> match=matches[i];
if(match->Groups()[L"tag"].Get(0).Value()==L"p")
{
paragraph=0;
line=0;
}
else if(match->Groups()[L"tag"].Get(0).Value()==L"i")
{
int cx=wtoi(match->Groups()[L"cx"].Get(0).Value());
int cy=wtoi(match->Groups()[L"cy"].Get(0).Value());
int b=wtoi(match->Groups()[L"b"].Get(0).Value());
WString file=match->Groups()[L"file"].Get(0).Value();
if(!paragraph)
{
paragraph=new text::DocumentParagraph;
document->paragraphs.Add(paragraph);
line=0;
}
if(!line)
{
line=new text::DocumentLine;
paragraph->lines.Add(line);
}
Ptr<text::DocumentImageRun> run=new text::DocumentImageRun;
run->size=Size(cx, cy);
run->baseline=b;
run->image=GetCurrentController()->ImageService()->CreateImageFromFile(L"..\\Resources\\"+file);
run->frameIndex=0;
line->runs.Add(run);
if(run->image->GetFrameCount()>1)
{
Ptr<GifRun> gifRun=new GifRun;
gifRun->imageRun=run;
gifRun->paragraphIndex=document->paragraphs.Count()-1;
animations.Add(gifRun);
}
}
else if(match->Groups()[L"tag"].Get(0).Value()==L"s")
{
FontProperties fontStyle;
Color fontColor;
RegexMatch::List lines;
{
WString font=match->Groups()[L"font"].Get(0).Value();
WString bold=match->Groups()[L"bold"].Get(0).Value();
WString color=match->Groups()[L"color"].Get(0).Value();
WString size=match->Groups()[L"size"].Get(0).Value();
WString text=match->Groups()[L"text"].Get(0).Value();
fontStyle.fontFamily=font;
fontStyle.bold=bold==L"true";
fontStyle.size=(int)(wtof(size)*dpi/72);
fontColor=ConvertColor(color);
regexLine.Split(text, true, lines);
}
for(int j=0;j<lines.Count();j++)
{
WString lineText=lines[j]->Result().Value();
if(!paragraph)
{
paragraph=new text::DocumentParagraph;
document->paragraphs.Add(paragraph);
line=0;
}
if(!line || j>0)
{
line=new text::DocumentLine;
paragraph->lines.Add(line);
}
Ptr<text::DocumentTextRun> run=new text::DocumentTextRun;
run->style=fontStyle;
run->color=fontColor;
run->text=lineText;
line->runs.Add(run);
}
}
}
return document;
}
void BoxLightGob::SetAmbient(int color)
{
ConvertColor(color, &m_light->ambient);
}
uint32_t GtkToolkitUiSettings::GetSystemColor(SystemColor color)
{
switch (color)
{
case COLOR_BUTTON:
case COLOR_SCROLLBAR_BACKGROUND:
return ConvertColor(m_style->bg[GTK_STATE_NORMAL]);
case COLOR_BUTTON_LIGHT:
return ConvertColor(m_style->light[GTK_STATE_NORMAL]);
case COLOR_BUTTON_DARK:
return ConvertColor(m_style->dark[GTK_STATE_NORMAL]);
case COLOR_BUTTON_VERYDARK:
return ConvertColor(m_style->black);
case COLOR_UI_BACKGROUND:
return ConvertColor(m_style->bg[GTK_STATE_NORMAL]);
case COLOR_BACKGROUND:
case COLOR_SKIN:
return ConvertColor(m_style->base[GTK_STATE_NORMAL]);
case COLOR_BACKGROUND_SELECTED:
case COLOR_BACKGROUND_SELECTED_NOFOCUS:
return ConvertColor(m_style->base[GTK_STATE_SELECTED]);
case COLOR_BACKGROUND_HIGHLIGHTED:
return MakeColor(35, 220, 35); //Green
case COLOR_BACKGROUND_HIGHLIGHTED_NOFOCUS:
return MakeColor(255, 225, 35); //Yellow
case COLOR_BACKGROUND_DISABLED:
return ConvertColor(m_style->base[GTK_STATE_INSENSITIVE]);
case COLOR_BUTTON_TEXT:
return ConvertColor(m_style->fg[GTK_STATE_NORMAL]);
case COLOR_TEXT:
return ConvertColor(m_style->text[GTK_STATE_NORMAL]);
case COLOR_UI_FONT:
return ConvertColor(m_style->fg[GTK_STATE_NORMAL]);
case COLOR_TEXT_SELECTED:
case COLOR_TEXT_SELECTED_NOFOCUS:
case COLOR_TEXT_HIGHLIGHTED:
case COLOR_TEXT_HIGHLIGHTED_NOFOCUS:
return ConvertColor(m_style->fg[GTK_STATE_SELECTED]);
case COLOR_TEXT_DISABLED:
case COLOR_UI_DISABLED_FONT:
return ConvertColor(m_style->fg[GTK_STATE_INSENSITIVE]);
case COLOR_UI_BUTTON_HOVER:
return ConvertColor(m_style->bg[GTK_STATE_PRELIGHT]);
case COLOR_LINK:
return MakeColor(0, 0, 204);
case COLOR_VISITED_LINK:
return MakeColor(128, 0, 128);
case COLOR_TOOLTIP_BACKGROUND:
return MakeColor(0xFF, 0xFF, 0xE1);
case COLOR_TOOLTIP_TEXT:
return MakeColor(0, 0, 0);
case COLOR_UI_MENU:
{
GtkStyle* style = gtk_style_attach(
gtk_widget_get_style(m_menu_item),
gtk_widget_get_parent_window(m_menu_item));
uint32_t color = ConvertColor(style->fg[GTK_STATE_NORMAL]);
gtk_style_detach(style);
return color;
}
case COLOR_WORKSPACE:
return MakeColor(0x80, 0x80, 0x80);
default:
#ifdef DEBUG
printf("GtkToolkitUiSettings::GetSystemColor: Unknown color code %d. Using red.\n", color);
return MakeColor(0xff, 0, 0);
#else
return MakeColor(0xff, 0xff, 0xff);
#endif
}
}
void BoxLightGob::SetDiffuse(int color)
{
ConvertColor(color, &m_light->diffuse);
}
//-------------------------------------------------------------------------------------------------
void ConvertColor( int color , float3* out)
{
float4 lcolor;
ConvertColor(color, &lcolor);
*out = float3(lcolor.x, lcolor.y, lcolor.z);
}
/*
======================================================================
mexFunction
This is the Matlab interface function for the MPEG to Matlab decoder.
This routine initializes variables, creates the output matrices and
calls the MPEG encoder functions to decode the MPEG file.
======================================================================
*/
void
mexFunction(int nlhs,
mxArray *plhs[],
int nrhs,
const mxArray *prhs[])
{
char filename[256]; /* input MPEG file name */
char err_text[80]; /* string to hold error message */
static VidStream *theStream; /* pointer to Video Stream struct. */
int h,i,j,k; /* loop counters */
double *cm; /* pointer to colormap matrix values */
double *movie; /* pointer to movie matrix values */
double *red; /* pointer to R,G,B matrix values */
double *green;
double *blue;
int movie_rows; /* number of rows in movie matrix */
int num_pix_doubles; /* number of doubles used by each frame */
int n_colors; /* number of colors in colormap */
unsigned char r,g,b; /* hold RGB values converted from YUV */
unsigned char *m_ptr; /* pointer to bytes in movie matrix */
double *r_ptr; /* pointers to doubles in R,G,B matrices */
double *g_ptr;
double *b_ptr;
unsigned int lum, crom; /* indices into luminance and crominance */
int vid_status; /* holds return from main decoder call */
int last_frame; /* holds last frame requested by user */
int n_req_frames; /* number of requested frames */
double *req_frames; /* points to array of frame numbers */
int frames_stored; /* counts # of frames stored in matrix */
int no_colormap; /* whether or not to return colormap */
int rgb_format; /* RGB if true, otherwise colormapped */
int NewOutput = 0; /* 0: Pre-5.3 movie format, 1: 5.3+ movie format */
int NewTrueColorOutput = 0; /* 0: Indexed movie, 1: TrueColor movie */
unsigned int temp_int; /* used as temp storage for flipping bytes*/
mxArray *fid[2], *filestr[2]; /* matrices used in searching Matlab path */
/* check arguments */
no_colormap = 1;
rgb_format = 0;
if (nlhs == 2)
no_colormap = 0;
else if (nlhs == 3)
rgb_format = 1;
else if (nlhs > 3)
mexErrMsgTxt("Too many output arguments.");
else if (nlhs < 1)
mexErrMsgTxt("Too few output arguments.");
if (nrhs < 1)
mexErrMsgTxt("Too few input arguments.");
if (nrhs > 3)
mexErrMsgTxt("Too many input arguments.");
if (!mxIsChar(prhs[0]))
mexErrMsgTxt("First argument (file name) must be a string.");
mxGetString(prhs[0], filename, 256);
/* get list of frame numbers if passed*/
if ((nrhs >= 2) && (!mxIsEmpty(prhs[1])))
{
if (mxGetN(prhs[1]) > 1)
{
n_req_frames = mxGetN(prhs[1]);
if (mxGetM(prhs[1]) > 1)
mexErrMsgTxt("Second argument must be a vector");
}
else
{
n_req_frames = mxGetM(prhs[1]);
}
req_frames = mxGetPr(prhs[1]);
/* find the highest number frame requested */
last_frame = 1;
for (j = 0; j < n_req_frames; j++)
{
if ((int)req_frames[j] > last_frame)
last_frame = (int)req_frames[j];
}
}
else
{
last_frame = 0;
n_req_frames = 0;
}
if (nrhs == 3) {
char str[100];
mxGetString(prhs[2], str, 100);
if (strcmp(str, "truecolor") == 0) {
NewTrueColorOutput = 1;
}
NewOutput = 1;
}
/* open the MPEG file */
/* call Matlab to search the Matlab path */
filestr[0] = mxCreateString(filename);
mexCallMATLAB(1,fid,1,filestr,"fopen");
if (*(mxGetPr(fid[0])) == -1)
{
if (strchr(filename, '.') == NULL)
{
strcat(filename, ".mpg");
mxDestroyArray(filestr[0]);
mxDestroyArray(fid[0]);
filestr[0] = mxCreateString(filename);
mexCallMATLAB(1,fid,1,filestr,"fopen");
if (*mxGetPr(fid[0]) == -1)
mexErrMsgTxt("Could not open file.");
}
else
mexErrMsgTxt("Could not open file.");
}
mxDestroyArray(filestr[0]);
mexCallMATLAB(1,filestr,1,fid,"fopen");
mxGetString(filestr[0], filename, 255);
mxDestroyArray(filestr[0]);
mexCallMATLAB(1,filestr,1,fid,"fclose");
mxDestroyArray(fid[0]);
mxDestroyArray(filestr[0]);
#ifdef WIN32
input = fopen(filename, "rb");
#else
input = fopen(filename, "r");
#endif
if (input == NULL) {
mexErrMsgTxt("Could not open file.");
}
/* initialization */
ditherType = ORDERED2_DITHER;
LUM_RANGE = 8;
CR_RANGE = CB_RANGE = 4;
noDisplayFlag = 0;
#ifdef SH_MEM
shmemFlag = 1;
#endif
init_tables();
InitColor();
InitOrdered2Dither();
EOF_flag = 0;
curBits = 0;
bitOffset = 0;
bufLength = 0;
bitBuffer = NULL;
totNumFrames = 0;
start_decode = 1;
curVidStream = NULL;
theStream = NewVidStream(BUF_LENGTH);
if (theStream == NULL)
mexErrMsgTxt("Out of memory.");
/* parse the MPEG header */
mpegVidRsrc(0, theStream);
/* create the movie and colormap Matrices */
n_colors = LUM_RANGE*CB_RANGE*CR_RANGE;
/*realTimeStart = ReadSysClock();*/
if (n_req_frames == 0)
{
/* if user did not specify frames to get, one pass is needed to determine
* the number of frames before actually putting them into the matrix */
vid_status = 0;
while (vid_status != 1)
{
vid_status = mpegVidRsrc(0, theStream);
}
n_req_frames = last_frame = totNumFrames;
req_frames = (double *)mxCalloc(n_req_frames, sizeof(double));
for (i = 0; i < n_req_frames; i++)
req_frames[i] = i+1;
DestroyVidStream(theStream);
rewind(input);
EOF_flag = 0;
curBits = 0;
bitOffset = 0;
bufLength = 0;
bitBuffer = NULL;
totNumFrames = 0;
theStream = NewVidStream(BUF_LENGTH);
mpegVidRsrc(0, theStream);
}
/* create the output matrices */
if (NewOutput)
{
char *fieldnames[] = {"cdata", "colormap"};
plhs[0] = mxCreateStructMatrix(1, n_req_frames, 2, (const char **)fieldnames);
if (NewTrueColorOutput)
{
int i;
int dims[3];
dims[0] = theStream->v_size; dims[1] = theStream->h_size; dims[2] = 3;
for (i = 0; i < n_req_frames; i++)
{
mxArray *cdata = mxCreateNumericArray(3, dims, mxUINT8_CLASS, mxREAL);
mxSetField(plhs[0], i, "cdata", cdata);
}
}
else
{
int i;
int dims[2];
dims[0] = theStream->v_size; dims[1] = theStream->h_size;
for (i = 0; i < n_req_frames; i++)
{
mxArray *cdata = mxCreateNumericArray(2, dims, mxUINT8_CLASS, mxREAL);
mxArray *colormap = mxCreateDoubleMatrix(n_colors, 3, mxREAL);
mxSetField(plhs[0], i, "cdata", cdata);
mxSetField(plhs[0], i, "colormap", colormap);
{
/* Fill in the colormap */
double *cm = mxGetPr(colormap);
int j;
for (j = 0; j < n_colors; j++)
{
/* fprintf(stderr, "Color: %d\n", j); */
ConvertColor(lum_values[(j/(CR_RANGE*CB_RANGE))%LUM_RANGE],
cr_values[(j/CB_RANGE)%CR_RANGE],
cb_values[j%CB_RANGE],
&r, &g, &b);
cm[j] = (double)r/255;
cm[n_colors + j] = (double)g/255;
cm[n_colors * 2 + j] = (double)b/255;
}
}
}
}
}
else
{
if (rgb_format)
{
plhs[0] = mxCreateDoubleMatrix(theStream->v_size, theStream->h_size*n_req_frames,
mxREAL);
if (plhs[0] == NULL)
mexErrMsgTxt("Out of memory.");
plhs[1] = mxCreateDoubleMatrix(theStream->v_size, theStream->h_size*n_req_frames,
mxREAL);
if (plhs[1] == NULL)
mexErrMsgTxt("Out of memory.");
plhs[2] = mxCreateDoubleMatrix(theStream->v_size, theStream->h_size*n_req_frames,
mxREAL);
if (plhs[2] == NULL)
mexErrMsgTxt("Out of memory.");
red = mxGetPr(plhs[0]);
green = mxGetPr(plhs[1]);
blue = mxGetPr(plhs[2]);
movie_rows = mxGetM(plhs[0]);
}
else
{
num_pix_doubles = (int)((theStream->h_size*theStream->v_size + 7)/8);
if (n_req_frames > 0)
plhs[0] = mxCreateDoubleMatrix(388 + num_pix_doubles, n_req_frames, mxREAL);
if (plhs[0] == NULL)
mexErrMsgTxt("Out of memory.");
movie = mxGetPr(plhs[0]);
movie_rows = mxGetM(plhs[0]);
}
if (!no_colormap)
{
plhs[1] = mxCreateDoubleMatrix(n_colors, 3, mxREAL);
if (plhs[1] == NULL)
mexErrMsgTxt("Out of memory.");
cm = mxGetPr(plhs[1]);
/* create a Matlab colormap */
/* fprintf(stderr, "About to create colormap\n");*/
for (j = 0; j < n_colors; j++)
{
/* fprintf(stderr, "Color: %d\n", j); */
ConvertColor(lum_values[(j/(CR_RANGE*CB_RANGE))%LUM_RANGE],
cr_values[(j/CB_RANGE)%CR_RANGE],
cb_values[j%CB_RANGE],
&r, &g, &b);
cm[j] = (double)r/255;
cm[n_colors + j] = (double)g/255;
cm[n_colors * 2 + j] = (double)b/255;
}
}
}
/*fprintf(stderr, "movie rows: %d\n", movie_rows);*/
/* get requested frames and store them in output martrix (matrices).*/
frames_stored = 0;
for (j = 1; j <= last_frame; j++)
{
/*fprintf(stderr, "Generating frame #%d\n", j);*/
while (totNumFrames < j)
{
vid_status = mpegVidRsrc(0, theStream);
if (vid_status == 1)
{
sprintf(err_text, "Frame(s) requested beyond last frame (%d).",
totNumFrames);
mexErrMsgTxt(err_text);
}
}
/* store this frame wherever it has been requested */
for (i = 0; i < n_req_frames; i++)
{
if ((int)req_frames[i] == j)
{
frames_stored++;
if (NewOutput)
{
mxArray *cdata = mxGetField(plhs[0], i, "cdata");
unsigned char *pr = (unsigned char *)mxGetPr(cdata);
if (NewTrueColorOutput)
{
unsigned char *pg = pr + theStream->v_size * theStream->h_size;
unsigned char *pb = pg + theStream->v_size * theStream->h_size;
lum = 0;
crom = 0;
for (h = 0; h < theStream->h_size; h++)
{
lum = h;
crom = h/2;
for (k = 0; k < theStream->v_size; k++)
{
ConvertColor(*(curVidStream->current->luminance + lum),
*(curVidStream->current->Cr + crom),
*(curVidStream->current->Cb + crom),
&r, &g, &b);
*pr = (unsigned char)r;
*pg = (unsigned char)g;
*pb = (unsigned char)b;
pr++; pg++; pb++;
lum += theStream->h_size;
if ((k % 2) == 1)
{
crom += theStream->h_size / 2;
}
}
}
}
else
{
int index = 0;
for (h = 0; h < theStream->h_size; h++)
{
for (k = 0; k < theStream->v_size; k++)
{
index = k * theStream->h_size + h;
*pr = *(curVidStream->current->display + index);
pr++;
}
}
}
}
else
{
if (rgb_format)
{
lum = 0;
crom = 0;
for (h = 0; h < theStream->v_size; h++)
{
r_ptr = red + theStream->v_size*theStream->h_size * i + h;
g_ptr = green + theStream->v_size*theStream->h_size * i + h;
b_ptr = blue + theStream->v_size*theStream->h_size * i + h;
for (k = 0; k < theStream->h_size; k++)
{
ConvertColor(*(curVidStream->current->luminance + lum),
*(curVidStream->current->Cr + crom),
*(curVidStream->current->Cb + crom),
&r, &g, &b);
*r_ptr = (double)r/255;
*g_ptr = (double)g/255;
*b_ptr = (double)b/255;
r_ptr += theStream->v_size;
g_ptr += theStream->v_size;
b_ptr += theStream->v_size;
lum++;
if (k%2 == 0)
crom++;
}
if (h%2 == 0)
crom -= theStream->h_size / 2;
}
}
else
{
/* create Matlab movie frame header */
m_ptr = (unsigned char *)(movie + (movie_rows * i));
*((double *)m_ptr) = curVidStream->h_size;
m_ptr += sizeof(double);
*((double *)m_ptr) = curVidStream->v_size;
m_ptr += sizeof(double);
*((double *)m_ptr) = 0;
m_ptr += sizeof(double);
if (MOVIE_GetClientByteOrder() == ELITTLE_ENDIAN)
{
*((int *)m_ptr) = 0;
m_ptr += sizeof(int);
*((int *)m_ptr) = LUM_RANGE*CB_RANGE*CR_RANGE;
m_ptr += sizeof(int);
}
else
{
*((int *)m_ptr) = LUM_RANGE*CB_RANGE*CR_RANGE;
m_ptr += sizeof(int);
*((int *)m_ptr) = 0;
m_ptr += sizeof(int);
}
m_ptr += 256*3*sizeof(float);
/* copy frame data into movie matrix */
memcpy(m_ptr, curVidStream->current->display,
(theStream->h_size*theStream->v_size));
if (MOVIE_GetClientByteOrder() == ELITTLE_ENDIAN)
{
for (k = 0; k < (movie_rows - 388); k++)
{
temp_int = FLIPBYTES(*((unsigned int *)m_ptr));
*((unsigned int *)m_ptr) =
FLIPBYTES(*((unsigned int *)m_ptr + 1));
*((unsigned int *)m_ptr + 1) = temp_int;
m_ptr += sizeof(double);
}
}
}
}
}
}
}
/* destroy the video stream */
DestroyVidStream(theStream);
fclose(input);
}
void BoxLightGob::SetSpecular(int color)
{
ConvertColor(color, &m_light->specular);
}
