void MP4ElstAtom::Generate()
{
SetVersion(0);
AddProperties(GetVersion());
MP4Atom::Generate();
}
void OCLContextProperties::AddOpenGLContextProperties() {
#ifdef __linux__
cl_context_properties props[7] = {
CL_GL_CONTEXT_KHR, (cl_context_properties) glXGetCurrentContext(),
CL_GLX_DISPLAY_KHR, (cl_context_properties) glXGetCurrentDisplay(),
0
};
#elif __APPLE__
CGLContextObj kGLContext = CGLGetCurrentContext();
CGLShareGroupObj kCGLShareGroup = CGLGetShareGroup(kGLContext);
cl_context_properties props[5] = {
CL_CONTEXT_PROPERTY_USE_CGL_SHAREGROUP_APPLE, (cl_context_properties) kCGLShareGroup,
NULL
};
//foundCtx = clCreateContext(
//props, 0, 0, NULL, NULL, clerr);
#elif WIN32
cl_context_properties props[5] = {
CL_GL_CONTEXT_KHR, (cl_context_properties) wglGetCurrentContext(),
CL_WGL_HDC_KHR, (cl_context_properties) wglGetCurrentDC()
};
#else
#error "Platform Not avalible for GL intergration"
#endif
AddProperties(props);
}
LRESULT CPropertyView::OnUpdate(WPARAM /*wParam*/, LPARAM /*lParam*/)
{
SPropertyList FinalProperties;
memset(&FinalProperties, 0, sizeof(SPropertyList));
for(int idx = 0; idx < m_ctrlComboBox.GetCount(); idx++) {
IPropertyEnabled *pProperty = (IPropertyEnabled *)m_ctrlComboBox.GetItemDataPtr(idx);
ASSERT((int)pProperty != -1);
if((int)pProperty == -1) return 0;
if(pProperty->isFlagged()) {
SPropertyList Properties;
memset(&Properties, 0, sizeof(SPropertyList));
pProperty->GetProperties(&Properties);
if(!FinalProperties.Merge(&Properties)) break;
m_ctrlComboBox.SetSel(idx, TRUE);
} else {
m_ctrlComboBox.SetSel(idx, FALSE);
}
}
if(FinalProperties.nProperties == 0) m_ctrlList.ResetContent();
AddProperties(&FinalProperties);
BOOL bDummy;
m_ctrlComboBox.OnSelChange(0,0,0,bDummy);
return 0;
}
void MP4SoundAtom::Read()
{
MP4Atom *parent = GetParentAtom();
if (ATOMID(parent->GetType()) != ATOMID("stsd")) {
// Quicktime has an interesting thing - they'll put an mp4a atom
// which is blank inside a wave atom, which is inside an mp4a atom
// we have a mp4a inside an wave inside an mp4a - delete all properties
m_pProperties.Delete(8);
m_pProperties.Delete(7);
m_pProperties.Delete(6);
m_pProperties.Delete(5);
m_pProperties.Delete(4);
m_pProperties.Delete(3);
m_pProperties.Delete(2);
m_pProperties.Delete(1);
m_pProperties.Delete(0);
if (ATOMID(GetType()) == ATOMID("alac")) {
AddProperty(new MP4BytesProperty("decoderConfig", m_size));
ReadProperties();
}
if (m_pChildAtomInfos.Size() > 0) {
ReadChildAtoms();
}
} else {
ReadProperties(0, 3); // read first 3 properties
AddProperties(((MP4IntegerProperty *)m_pProperties[2])->GetValue());
ReadProperties(3); // continue
if (m_pChildAtomInfos.Size() > 0) {
ReadChildAtoms();
}
}
Skip();
}
wxObject* Create(IObject *obj, wxObject * /*parent*/)
{
wxFlexGridSizer *sizer = new wxFlexGridSizer(
obj->GetPropertyAsInteger(_("rows")),
obj->GetPropertyAsInteger(_("cols")),
obj->GetPropertyAsInteger(_("vgap")),
obj->GetPropertyAsInteger(_("hgap")));
AddProperties( obj, sizer );
return sizer;
}
void MP4MvhdAtom::Generate()
{
u_int8_t version = m_pFile->Use64Bits(GetType()) ? 1 : 0;
SetVersion(version);
AddProperties(version);
MP4Atom::Generate();
// set creation and modification times
MP4Timestamp now = MP4GetAbsTimestamp();
if (version == 1) {
((MP4Integer64Property*)m_pProperties[2])->SetValue(now);
((MP4Integer64Property*)m_pProperties[3])->SetValue(now);
} else {
((MP4Integer32Property*)m_pProperties[2])->SetValue(now);
((MP4Integer32Property*)m_pProperties[3])->SetValue(now);
}
((MP4Integer32Property*)m_pProperties[4])->SetValue(1000);
((MP4Float32Property*)m_pProperties[6])->SetValue(1.0);
((MP4Float32Property*)m_pProperties[7])->SetValue(1.0);
// property reserved has non-zero fixed values
static u_int8_t reserved[70] = {
0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x01, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x01, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x40, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
};
m_pProperties[8]->SetReadOnly(false);
((MP4BytesProperty*)m_pProperties[8])->
SetValue(reserved, sizeof(reserved));
m_pProperties[8]->SetReadOnly(true);
// set next track id
((MP4Integer32Property*)m_pProperties[9])->SetValue(1);
}
void MP4ElstAtom::Read()
{
/* read atom version */
ReadProperties(0, 1);
/* need to create the properties based on the atom version */
AddProperties(GetVersion());
/* now we can read the remaining properties */
ReadProperties(1);
Skip(); // to end of atom
}
void MP4TrunAtom::Read()
{
/* read atom version, flags, and sampleCount */
ReadProperties(0, 3);
/* need to create the properties based on the atom flags */
AddProperties(GetFlags());
/* now we can read the remaining properties */
ReadProperties(3);
Skip(); // to end of atom
}
void MP4TkhdAtom::Generate()
{
uint8_t version = m_File.Use64Bits(GetType()) ? 1 : 0;
SetVersion(version);
AddProperties(version);
MP4Atom::Generate();
MP4Timestamp now = 0;
if(1)
{//»ñµÃʱ¼ä
now = m_File.GetAllCreateTime();
}
else
{
// set creation and modification times
now = MP4GetAbsTimestamp();
}
if (version == 1) {
((MP4Integer64Property*)m_pProperties[2])->SetValue(now);
((MP4Integer64Property*)m_pProperties[3])->SetValue(now);
} else {
((MP4Integer32Property*)m_pProperties[2])->SetValue(now);
((MP4Integer32Property*)m_pProperties[3])->SetValue(now);
}
// property "matrix" has non-zero fixed values
// this default identity matrix indicates no transformation, i.e.
// 1, 0, 0
// 0, 1, 0
// 0, 0, 1
// see http://developer.apple.com/documentation/QuickTime/QTFF/QTFFChap4/chapter_5_section_4.html
static uint8_t matrix[36] = {
0x00, 0x01, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x01, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x40, 0x00, 0x00, 0x00,
};
((MP4BytesProperty*)m_pProperties[12])->
SetValue(matrix, sizeof(matrix));
}
wxObject* Create(IObject *obj, wxObject * /*parent*/)
{
wxGridBagSizer* sizer = new wxGridBagSizer(
obj->GetPropertyAsInteger(_("vgap")),
obj->GetPropertyAsInteger(_("hgap")));
sizer->SetCols(0);
AddProperties( obj, sizer );
if ( !obj->IsNull( _("empty_cell_size") ) )
{
sizer->SetEmptyCellSize( obj->GetPropertyAsSize( _("empty_cell_size") ) );
}
return sizer;
}
void MP4MdhdAtom::Generate()
{
u_int8_t version = m_pFile->Use64Bits(GetType()) ? 1 : 0;
SetVersion(version);
AddProperties(version);
MP4Atom::Generate();
// set creation and modification times
MP4Timestamp now = MP4GetAbsTimestamp();
if (version == 1) {
((MP4Integer64Property*)m_pProperties[2])->SetValue(now);
((MP4Integer64Property*)m_pProperties[3])->SetValue(now);
} else {
((MP4Integer32Property*)m_pProperties[2])->SetValue(now);
((MP4Integer32Property*)m_pProperties[3])->SetValue(now);
}
}
CArcView::CArcView(CShapeView* source, CShapeView* end, std::vector<Point> interPoints, pm::Arc* arcModel)
: CElement(ARC)
, source(source)
, end(end)
, arcModel(arcModel)
, arrowCap(new AdjustableArrowCap(5,5))
, valPosition(40)
, valDistance(-15)
{
AddProperties();
for(auto it=interPoints.begin(); it!=interPoints.end(); ++it)
{
pathPoints.push_back(*it);
}
computeCollisionPoints(TRUE);
cleanDouble();
computeEnclosingRect(TRUE);
}
void
EngineList::SetFromNode(DataNode *parentNode)
{
if(parentNode == 0)
return;
DataNode *searchNode = parentNode->GetNode("EngineList");
if(searchNode == 0)
return;
DataNode *node;
DataNode **children;
if((node = searchNode->GetNode("engineName")) != 0)
SetEngineName(node->AsStringVector());
if((node = searchNode->GetNode("simulationName")) != 0)
SetSimulationName(node->AsStringVector());
// Clear all the EnginePropertiess if we got any.
bool clearedProperties = false;
// Go through all of the children and construct a new
// EngineProperties for each one of them.
children = searchNode->GetChildren();
if(children != 0)
{
for(int i = 0; i < searchNode->GetNumChildren(); ++i)
{
if(children[i]->GetKey() == std::string("EngineProperties"))
{
if (!clearedProperties)
{
ClearProperties();
clearedProperties = true;
}
EngineProperties temp;
temp.SetFromNode(children[i]);
AddProperties(temp);
}
}
}
}
void MP4TkhdAtom::Generate()
{
u_int8_t version = m_pFile->Use64Bits(GetType()) ? 1 : 0;
SetVersion(version);
AddProperties(version);
MP4Atom::Generate();
// set creation and modification times
MP4Timestamp now = MP4GetAbsTimestamp();
if (version == 1) {
((MP4Integer64Property*)m_pProperties[2])->SetValue(now);
((MP4Integer64Property*)m_pProperties[3])->SetValue(now);
} else {
((MP4Integer32Property*)m_pProperties[2])->SetValue(now);
((MP4Integer32Property*)m_pProperties[3])->SetValue(now);
}
// property reserved3 has non-zero fixed values
static u_int8_t reserved3[38] = {
0x00, 0x00,
0x00, 0x01, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x01, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x40, 0x00, 0x00, 0x00,
};
m_pProperties[9]->SetReadOnly(false);
((MP4BytesProperty*)m_pProperties[9])->
SetValue(reserved3, sizeof(reserved3));
m_pProperties[9]->SetReadOnly(true);
}
nsresult
RDFContentSinkImpl::OpenProperty(const PRUnichar* aName, const PRUnichar** aAttributes)
{
nsresult rv;
// an "object" non-terminal is either a "description", a "typed
// node", or a "container", so this change the content sink's
// state appropriately.
nsCOMPtr<nsIAtom> localName;
const nsDependentSubstring& nameSpaceURI =
SplitExpatName(aName, getter_AddRefs(localName));
const char* attrName;
localName->GetUTF8String(&attrName);
NS_ConvertUTF16toUTF8 propertyStr(nameSpaceURI);
propertyStr.Append(attrName);
nsCOMPtr<nsIRDFResource> property;
rv = gRDFService->GetResource(propertyStr, getter_AddRefs(property));
if (NS_FAILED(rv)) return rv;
// See if they've specified a 'resource' attribute, in which case
// they mean *that* to be the object of this property.
nsCOMPtr<nsIRDFResource> target;
GetResourceAttribute(aAttributes, getter_AddRefs(target));
PRBool isAnonymous = PR_FALSE;
if (! target) {
// See if an 'ID' attribute has been specified, in which case
// this corresponds to the fourth form of [6.12].
// XXX strictly speaking, we should reject the RDF/XML as
// invalid if they've specified both an 'ID' and a 'resource'
// attribute. Bah.
// XXX strictly speaking, 'about=' isn't allowed here, but
// what the hell.
GetIdAboutAttribute(aAttributes, getter_AddRefs(target), &isAnonymous);
}
if (target) {
// They specified an inline resource for the value of this
// property. Create an RDF resource for the inline resource
// URI, add the properties to it, and attach the inline
// resource to its parent.
PRInt32 count;
rv = AddProperties(aAttributes, target, &count);
NS_ASSERTION(NS_SUCCEEDED(rv), "problem adding properties");
if (NS_FAILED(rv)) return rv;
if (count || !isAnonymous) {
// If the resource was "anonymous" (i.e., they hadn't
// explicitly set an ID or resource attribute), then we'll
// only assert this property from the context element *if*
// there were properties specified on the anonymous
// resource.
rv = mDataSource->Assert(GetContextElement(0), property, target, PR_TRUE);
if (NS_FAILED(rv)) return rv;
}
// XXX Technically, we should _not_ fall through here and push
// the element onto the stack: this is supposed to be a closed
// node. But right now I'm lazy and the code will just Do The
// Right Thing so long as the RDF is well-formed.
}
// Push the element onto the context stack and change state.
PushContext(property, mState, mParseMode);
mState = eRDFContentSinkState_InPropertyElement;
SetParseMode(aAttributes);
return NS_OK;
}
nsresult
RDFContentSinkImpl::OpenObject(const PRUnichar* aName,
const PRUnichar** aAttributes)
{
// an "object" non-terminal is either a "description", a "typed
// node", or a "container", so this change the content sink's
// state appropriately.
nsCOMPtr<nsIAtom> localName;
const nsDependentSubstring& nameSpaceURI =
SplitExpatName(aName, getter_AddRefs(localName));
// Figure out the URI of this object, and create an RDF node for it.
nsCOMPtr<nsIRDFResource> source;
GetIdAboutAttribute(aAttributes, getter_AddRefs(source));
// If there is no `ID' or `about', then there's not much we can do.
if (! source)
return NS_ERROR_FAILURE;
// Push the element onto the context stack
PushContext(source, mState, mParseMode);
// Now figure out what kind of state transition we need to
// make. We'll either be going into a mode where we parse a
// description or a container.
PRBool isaTypedNode = PR_TRUE;
if (nameSpaceURI.EqualsLiteral(RDF_NAMESPACE_URI)) {
isaTypedNode = PR_FALSE;
if (localName == kDescriptionAtom) {
// it's a description
mState = eRDFContentSinkState_InDescriptionElement;
}
else if (localName == kBagAtom) {
// it's a bag container
InitContainer(kRDF_Bag, source);
mState = eRDFContentSinkState_InContainerElement;
}
else if (localName == kSeqAtom) {
// it's a seq container
InitContainer(kRDF_Seq, source);
mState = eRDFContentSinkState_InContainerElement;
}
else if (localName == kAltAtom) {
// it's an alt container
InitContainer(kRDF_Alt, source);
mState = eRDFContentSinkState_InContainerElement;
}
else {
// heh, that's not *in* the RDF namespace: just treat it
// like a typed node
isaTypedNode = PR_TRUE;
}
}
if (isaTypedNode) {
const char* attrName;
localName->GetUTF8String(&attrName);
NS_ConvertUTF16toUTF8 typeStr(nameSpaceURI);
typeStr.Append(attrName);
nsCOMPtr<nsIRDFResource> type;
nsresult rv = gRDFService->GetResource(typeStr, getter_AddRefs(type));
if (NS_FAILED(rv)) return rv;
rv = mDataSource->Assert(source, kRDF_type, type, PR_TRUE);
if (NS_FAILED(rv)) return rv;
mState = eRDFContentSinkState_InDescriptionElement;
}
AddProperties(aAttributes, source);
return NS_OK;
}
