TagLib::ByteVector TagLib::EncodeBase64(const TagLib::ByteVector& input)
{
SFB::CFError error;
SFB::SecTransform encoder(SecEncodeTransformCreate(kSecBase64Encoding, &error));
if(!encoder) {
LOGGER_WARNING("org.sbooth.AudioEngine", "SecEncodeTransformCreate failed: " << error);
return {};
}
SFB::CFData sourceData(CFDataCreateWithBytesNoCopy(kCFAllocatorDefault, (const UInt8 *)input.data(), (CFIndex)input.size(), kCFAllocatorNull));
if(!sourceData)
return {};
if(!SecTransformSetAttribute(encoder, kSecTransformInputAttributeName, sourceData, &error)) {
LOGGER_WARNING("org.sbooth.AudioEngine", "SecTransformSetAttribute failed: " << error);
return {};
}
SFB::CFData encodedData((CFDataRef)SecTransformExecute(encoder, &error));
if(!encodedData) {
LOGGER_WARNING("org.sbooth.AudioEngine", "SecTransformExecute failed: " << error);
return {};
}
return {(const char *)CFDataGetBytePtr((CFDataRef)encodedData), (size_t)CFDataGetLength((CFDataRef)encodedData)};
}
void vesKiwiDataConversionTools::GenericConvertTriangles(vtkPolyData* input,
vesSharedPtr<vesGeometryData> output)
{
vesSourceDataP3N3f::Ptr sourceData (new vesSourceDataP3N3f());
double inPoint[3];
for (int i = 0; i < input->GetNumberOfPoints(); ++i){
input->GetPoint(i, inPoint);
vesVertexDataP3N3f vertexData;
vertexData.m_position = vesVector3f(inPoint[0], inPoint[1], inPoint[2]);
sourceData->pushBack(vertexData);
}
// copy triangles in place to ves structure
vtkCellArray* polys = input->GetPolys();
vtkIdType num;
vtkIdType* vertices;
vesSharedPtr< vesIndices<T> > indicesObj =
std::tr1::static_pointer_cast< vesIndices<T> >
(output->triangles()->getVesIndices());
typename vesIndices<T>::Indices* triangleIndices
= indicesObj->indices();
triangleIndices->clear();
triangleIndices->resize(polys->GetNumberOfCells());
T* outIndex = &triangleIndices->front();
for (int i = 0; i < polys->GetNumberOfCells(); ++i)
{
// there are 4 elements for each triangle cell in the array (count, i1, i2, i3)
polys->GetCell(4*i, num, vertices);
*outIndex++ = vertices[0];
*outIndex++ = vertices[1];
*outIndex++ = vertices[2];
}
if (input->GetPointData()->GetNormals())
{
vtkDataArray* normals = input->GetPointData()->GetNormals();
for (int i = 0; i < input->GetNumberOfPoints(); ++i)
{
sourceData->arrayReference()[i].m_normal[0] = normals->GetTuple(i)[0];
sourceData->arrayReference()[i].m_normal[1] = normals->GetTuple(i)[1];
sourceData->arrayReference()[i].m_normal[2] = normals->GetTuple(i)[2];
}
}
else
{
output->computeNormals<T>();
}
output->computeBounds();
output->addSource(sourceData);
}
tristate KexiReportView::afterSwitchFrom(Kexi::ViewMode mode)
{
Q_UNUSED(mode);
qDebug();
if (tempData()->reportSchemaChangedInPreviousView) {
qDebug() << "Schema changed";
delete m_preRenderer;
qDebug() << tempData()->reportDefinition.tagName();
m_preRenderer = new KoReportPreRenderer(tempData()->reportDefinition);
if (m_preRenderer->isValid()) {
KoReportData *reportData = 0;
if (!tempData()->connectionDefinition.isNull()) {
reportData = sourceData(tempData()->connectionDefinition);
}
m_preRenderer->setSourceData(reportData);
m_preRenderer->setName(window()->partItem()->name());
//Add a kexi object to provide kexidb and extra functionality
//! @todo KEXI3 if we want this if(!m_kexi) {
// m_kexi = new KexiScriptAdaptor();
// }
// m_preRenderer->registerScriptObject(m_kexi, "Kexi");
//If using a kexidb source, add a functions scripting object
if (tempData()->connectionDefinition.attribute("type") == "internal") {
m_functions = new KRScriptFunctions(reportData, KexiMainWindowIface::global()->project()->dbConnection());
m_preRenderer->registerScriptObject(m_functions, "field");
connect(m_preRenderer, SIGNAL(groupChanged(QMap<QString, QVariant>)),
m_functions, SLOT(setGroupData(QMap<QString, QVariant>)));
}
if (m_reportDocument) {
qDebug() << "=======================================Deleting old document";
delete m_reportDocument;
}
m_reportDocument = m_preRenderer->generate();
if (m_reportDocument) {
m_reportView->setDocument(m_reportDocument);
#ifndef KEXI_MOBILE
m_pageSelector->setRecordCount(m_reportView->pageCount());
m_pageSelector->setCurrentRecordNumber(1);
#endif
}
} else {
KMessageBox::error(this, xi18n("Report schema appears to be invalid or corrupt"), xi18n("Opening failed"));
}
tempData()->reportSchemaChangedInPreviousView = false;
}
return true;
}
void KexiSourceSelector::setConnectionData(QDomElement c)
{
if (c.attribute("type") == "internal") {
d->sourceType->setCurrentIndex(d->sourceType->findData("internal"));
d->internalSource->setCurrentIndex(d->internalSource->findText(c.attribute("source")));
}
if (c.attribute("type") == "external") {
d->sourceType->setCurrentIndex(d->sourceType->findText("external"));
d->externalSource->setText(c.attribute("source"));
}
emit(setData(sourceData()));
}
//-----------------------------------------------------------------------------
vesSharedPtr<vesGeometryData> vesKiwiDataConversionTools::ConvertPoints(vtkPolyData* input)
{
vesSharedPtr<vesGeometryData> output(new vesGeometryData());
vesSourceDataP3f::Ptr sourceData(new vesSourceDataP3f());
vesVertexDataP3f vertexData;
for (int i = 0; i < input->GetNumberOfPoints(); ++i){
vertexData.m_position[0] = input->GetPoint(i)[0];
vertexData.m_position[1] = input->GetPoint(i)[1];
vertexData.m_position[2] = input->GetPoint(i)[2];
sourceData->pushBack(vertexData);
}
output->addSource(sourceData);
output->setName("PolyData");
// Add point primitive
vesPrimitive::Ptr pointPrimitive (new vesPrimitive());
pointPrimitive->setPrimitiveType(vesPrimitiveRenderType::Points);
pointPrimitive->setIndexCount(1);
output->addPrimitive(pointPrimitive);
return output;
}
tristate KexiReportView::afterSwitchFrom(Kexi::ViewMode mode)
{
Q_UNUSED(mode);
kDebug();
if (tempData()->reportSchemaChangedInPreviousView) {
kDebug() << "Schema changed";
delete m_preRenderer;
kDebug() << tempData()->reportDefinition.tagName();
m_preRenderer = new KoReportPreRenderer(tempData()->reportDefinition);
if (m_preRenderer->isValid()) {
KoReportData *reportData = 0;
if (!tempData()->connectionDefinition.isNull()) {
reportData = sourceData(tempData()->connectionDefinition);
}
if (!reportData) {
reportData = new KexiDBReportData(QString(), KexiMainWindowIface::global()->project()->dbConnection());
}
m_preRenderer->setSourceData(reportData);
m_preRenderer->setName(tempData()->name);
m_currentPage = 1;
//Add a kexi object to provide kexidb and extra functionality
if(!m_kexi) {
m_kexi = new KexiScriptAdaptor();
}
m_preRenderer->registerScriptObject(m_kexi, "Kexi");
//If using a kexidb source, add a functions scripting object
if (tempData()->connectionDefinition.attribute("type") == "internal") {
if (!m_functions) {
m_functions = new KRScriptFunctions(reportData, KexiMainWindowIface::global()->project()->dbConnection());
}
m_preRenderer->registerScriptObject(m_functions, "field");
}
if (m_reportDocument)
delete m_reportDocument;
m_reportDocument = m_preRenderer->generate();
if (m_reportDocument) {
m_pageCount = m_reportDocument->pages();
#ifndef KEXI_MOBILE
m_pageSelector->setRecordCount(m_pageCount);
#endif
}
m_reportWidget = new KoReportPage(this, m_reportDocument);
m_reportWidget->setObjectName("KexiReportPage");
m_scrollArea->setWidget(m_reportWidget);
} else {
KMessageBox::error(this, i18n("Report schema appears to be invalid or corrupt"), i18n("Opening failed"));
}
tempData()->reportSchemaChangedInPreviousView = false;
}
return true;
}
void KexiSourceSelector::setDataClicked()
{
emit(setData(sourceData()));
}
/**
* Decodes the given byte array into the <tt>ImageData</tt>.
* <p>
* Java declaration:
* <pre>
* loadNative(Ljavax/microedition/lcdui/ImageDataFactory;[BII)Z
* </pre>
*
* @param imageData the ImageData to load to
* @param imageBytes A byte array containing the encoded PNG image data
* @param offset The start of the image data within the byte array
* @param length The length of the image data in the byte array
*
* @return true if able to decode
*/
KNIEXPORT KNI_RETURNTYPE_BOOLEAN
KNIDECL(javax_microedition_lcdui_ImageDataFactory_loadNative) {
int length = KNI_GetParameterAsInt(4);
int offset = KNI_GetParameterAsInt(3);
int status = KNI_TRUE;
unsigned char* srcBuffer = NULL;
PIXEL* imgPixelData = NULL;
ALPHA* imgAlphaData = NULL;
java_imagedata* midpImageData = NULL;
TBool generateMask = EFalse;
KNI_StartHandles(4);
KNI_DeclareHandle(pixelData);
KNI_DeclareHandle(alphaData);
KNI_DeclareHandle(inData);
KNI_DeclareHandle(imageData);
KNI_GetParameterAsObject(2, inData);
KNI_GetParameterAsObject(1, imageData);
midpImageData = IMGAPI_GET_IMAGEDATA_PTR(imageData);
srcBuffer = (unsigned char *)JavaByteArray(inData);
int byteArrayLength = KNI_GetArrayLength(inData);
if (offset >= 0 && length >= 0 && offset + length <= byteArrayLength)
{
TPtrC8 sourceData(srcBuffer + offset, length);
TInt width;
TInt height;
if (static_cast<MApplication*>(Dll::Tls())->InitializeDecoder(sourceData, width, height, generateMask) == KErrNone)
{
midpImageData->width = width;
midpImageData->height = height;
SNI_NewArray(SNI_BYTE_ARRAY, midpImageData->width * midpImageData->height * 2, pixelData);
if (generateMask)
{
SNI_NewArray(SNI_BYTE_ARRAY, midpImageData->width * midpImageData->height, alphaData);
}
if (!KNI_IsNullHandle(pixelData) && (!KNI_IsNullHandle(alphaData) || !generateMask))
{
if (generateMask)
{
imgAlphaData = (ALPHA*)JavaByteArray(alphaData);
}
midp_set_jobject_field(KNIPASSARGS imageData, "pixelData", "[B", pixelData);
imgPixelData = (PIXEL*)JavaByteArray(pixelData);
if (static_cast<MApplication*>(Dll::Tls())->DecodeImage((char*)imgPixelData, (char*)imgAlphaData) != KErrNone)
{
status = KNI_FALSE;
}
if (imgAlphaData)
{
midp_set_jobject_field(KNIPASSARGS imageData, "alphaData", "[B", alphaData);
}
}
else
{
status = KNI_FALSE;
}
}
}
KNI_EndHandles();
KNI_ReturnBoolean(status);
}
//-----------------------------------------------------------------------------
vesSharedPtr<vesGeometryData> vesKiwiDataConversionTools::ConvertPVWebData(vesSharedPtr<vesPVWebDataSet> dataset)
{
vesSharedPtr<vesGeometryData> geometryData = vesSharedPtr<vesGeometryData>(new vesGeometryData);
geometryData->setName("PolyData");
const int numberOfVerts = dataset->m_numberOfVerts;
// Todo- handle point primitives
//vesPrimitive::Ptr pointPrimitive(new vesPrimitive());
//pointPrimitive->setPrimitiveType(vesPrimitiveRenderType::Points);
//pointPrimitive->setIndexCount(1);
//geometryData->addPrimitive(pointPrimitive);
if (dataset->m_datasetType == 'M') {
// verts and normals
vesSourceDataP3N3f::Ptr sourceData(new vesSourceDataP3N3f());
vesVertexDataP3N3f vertexData;
for (int i = 0; i < numberOfVerts; ++i) {
float* vertex = dataset->vertices() + i*3;
float* normal = dataset->normals() + i*3;
vertexData.m_position[0] = vertex[0];
vertexData.m_position[1] = vertex[1];
vertexData.m_position[2] = vertex[2];
vertexData.m_normal[0] = normal[0];
vertexData.m_normal[1] = normal[1];
vertexData.m_normal[2] = normal[2];
sourceData->pushBack(vertexData);
}
geometryData->addSource(sourceData);
// triangles
vesSharedPtr<vesIndices<unsigned short> > triangleIndices =
vesSharedPtr<vesIndices<unsigned short> >(new vesIndices<unsigned short>());
vesPrimitive::Ptr trianglesPrimitive = vesPrimitive::Ptr(new vesPrimitive());
trianglesPrimitive->setIndexCount(3);
trianglesPrimitive->setIndicesValueType(vesPrimitiveIndicesValueType::UnsignedShort);
trianglesPrimitive->setPrimitiveType(vesPrimitiveRenderType::Triangles);
trianglesPrimitive->setVesIndices(triangleIndices);
geometryData->addPrimitive(trianglesPrimitive);
for (int i = 0; i < dataset->m_numberOfIndices/3; ++i) {
short* indices = dataset->indices() + i*3;
triangleIndices->pushBackIndices(indices[0], indices[1], indices[2]);
}
}
else if (dataset->m_datasetType == 'L') {
// verts
vesSourceDataP3f::Ptr vertexSourceData(new vesSourceDataP3f());
vesVertexDataP3f vertexData;
for (int i = 0; i < numberOfVerts; ++i) {
float* vertex = dataset->vertices() + i*3;
vertexData.m_position[0] = vertex[0];
vertexData.m_position[1] = vertex[1];
vertexData.m_position[2] = vertex[2];
vertexSourceData->pushBack(vertexData);
}
geometryData->addSource(vertexSourceData);
// lines
vesSharedPtr<vesIndices<unsigned short> > lineIndices =
vesSharedPtr<vesIndices<unsigned short> >(new vesIndices<unsigned short>());
vesPrimitive::Ptr linesPrimitive = vesPrimitive::Ptr(new vesPrimitive());
linesPrimitive->setIndexCount(2);
linesPrimitive->setIndicesValueType(vesPrimitiveIndicesValueType::UnsignedShort);
linesPrimitive->setPrimitiveType(vesPrimitiveRenderType::Lines);
linesPrimitive->setVesIndices(lineIndices);
geometryData->addPrimitive(linesPrimitive);
for (int i = 0; i < dataset->m_numberOfIndices/2; ++i) {
short* indices = dataset->indices() + i*2;
lineIndices->pushBackIndices(indices[0], indices[1]);
}
}
// colors
float opacity = 1.0;
if (dataset->m_transparency) {
opacity = 0.4;
}
vesSourceDataC4f::Ptr colorSourceData(new vesSourceDataC4f());
vesVertexDataC4f vertColor;
for (size_t i = 0; i < numberOfVerts; ++i)
{
unsigned char* color = dataset->colors() + i*4;
vertColor.m_color = vesVector4f(color[0]/255.0, color[1]/255.0, color[2]/255.0, opacity);
colorSourceData->pushBack(vertColor);
}
geometryData->addSource(colorSourceData);
return geometryData;
}
vesSharedPtr<vesGeometryData> vesKiwiDataConversionTools::GenericConvert(
vtkPolyData* input)
{
unsigned int indicesValuesType;
if(typeid(T) == typeid(unsigned int)) {
indicesValuesType = vesPrimitiveIndicesValueType::UnsignedInt;
}
// Default
else {
indicesValuesType = vesPrimitiveIndicesValueType::UnsignedShort;
}
vesPrimitive::Ptr trianglesPrimitive;
vesSharedPtr< vesIndices<T> > triangleIndices;
vesPrimitive::Ptr triangleStripsPrimitive;
vesSharedPtr< vesIndices<T> > triangleStripsIndices;
vesPrimitive::Ptr linesPrimitive;
vesSharedPtr< vesIndices<T> > linesIndices;
vesPrimitive::Ptr verticesPrimitive;
vesSharedPtr< vesIndices<T> > verticesIndices;
vesSharedPtr<vesGeometryData> output =
vesSharedPtr<vesGeometryData>(new vesGeometryData());
vesSourceDataP3N3f::Ptr sourceData (new vesSourceDataP3N3f());
vesVertexDataP3N3f vertexData;
for (int i = 0; i < input->GetNumberOfPoints(); ++i){
vertexData.m_position[0] = input->GetPoint(i)[0];
vertexData.m_position[1] = input->GetPoint(i)[1];
vertexData.m_position[2] = input->GetPoint(i)[2];
vertexData.m_normal[0] = 1.0f;
vertexData.m_normal[1] = 0.0f;
vertexData.m_normal[2] = 0.0f;
sourceData->pushBack(vertexData);
}
output->addSource(sourceData);
output->setName("PolyData");
vtkIdType num;
vtkIdType* vertices;
// Add triangles
vtkCellArray* polys = input->GetPolys();
polys->InitTraversal();
if (polys->GetNumberOfCells() > 0) {
triangleIndices = vesSharedPtr< vesIndices<T> >(new vesIndices<T>());
trianglesPrimitive = vesPrimitive::Ptr(new vesPrimitive());
trianglesPrimitive->setIndexCount(3);
trianglesPrimitive->setIndicesValueType(indicesValuesType);
trianglesPrimitive->setPrimitiveType(vesPrimitiveRenderType::Triangles);
trianglesPrimitive->setVesIndices(triangleIndices);
output->addPrimitive(trianglesPrimitive);
for (int i = 0; i < polys->GetNumberOfCells(); ++i) {
polys->GetNextCell(num, vertices);
if (num == 3) {
triangleIndices->pushBackIndices(vertices[0], vertices[1], vertices[2]);
}
else if (num == 4) {
triangleIndices->pushBackIndices(vertices[0], vertices[1], vertices[2]);
triangleIndices->pushBackIndices(vertices[3], vertices[0], vertices[2]);
}
}
}
// Add triangle strips
vtkCellArray* strips = input->GetStrips();
strips->InitTraversal();
if (strips->GetNumberOfCells() > 0) {
triangleStripsIndices
= vesSharedPtr< vesIndices<T> >( new vesIndices<T>() );
triangleStripsPrimitive = vesPrimitive::Ptr(new vesPrimitive());
triangleStripsPrimitive->setIndexCount(1);
triangleStripsPrimitive->setIndicesValueType(indicesValuesType);
triangleStripsPrimitive->setPrimitiveType(vesPrimitiveRenderType::TriangleStrip);
triangleStripsPrimitive->setVesIndices(triangleIndices);
output->addPrimitive(triangleStripsPrimitive);
for (int i = 0; i < strips->GetNumberOfCells(); ++i) {
strips->GetNextCell(num, vertices);
for (int i = 2; i < num; ++i)
{
if (i & 1)
{
triangleStripsIndices->pushBackIndices(vertices[i-1], vertices[i-2], vertices[i]);
}
else
{
triangleStripsIndices->pushBackIndices(vertices[i-2], vertices[i-1], vertices[i]);
}
}
}
}
// Add lines
vtkCellArray* lines = input->GetLines();
lines->InitTraversal();
if (lines->GetNumberOfCells() > 0) {
linesIndices = vesSharedPtr< vesIndices<T> >(new vesIndices<T>());
linesPrimitive = vesPrimitive::Ptr(new vesPrimitive());
linesPrimitive->setIndexCount(2);
linesPrimitive->setIndicesValueType(indicesValuesType);
linesPrimitive->setPrimitiveType(vesPrimitiveRenderType::Lines);
linesPrimitive->setVesIndices(linesIndices);
output->addPrimitive(linesPrimitive);
for (int i = 0; i < lines->GetNumberOfCells(); ++i) {
lines->GetNextCell(num, vertices);
for (int i = 1; i < num; ++i)
{
linesIndices->pushBackIndices(vertices[i-1], vertices[i]);
}
}
}
// Add verts
vtkCellArray* verts = input->GetVerts();
verts->InitTraversal();
if (verts->GetNumberOfCells() > 0) {
verticesIndices = vesSharedPtr< vesIndices<T> >(new vesIndices<T>());
verticesPrimitive = vesPrimitive::Ptr(new vesPrimitive());
verticesPrimitive->setIndexCount(1);
verticesPrimitive->setIndicesValueType(indicesValuesType);
verticesPrimitive->setPrimitiveType(vesPrimitiveRenderType::Points);
verticesPrimitive->setVesIndices(verticesIndices);
output->addPrimitive(verticesPrimitive);
for (int i = 0; i < verts->GetNumberOfCells() && i < 65000; ++i) {
verts->GetNextCell(num, vertices);
verticesIndices->pushBackIndices(vertices[0]);
}
}
if (input->GetPointData()->GetNormals()) {
vtkDataArray* normals = input->GetPointData()->GetNormals();
for (int i = 0; i < input->GetNumberOfPoints(); ++i) {
sourceData->arrayReference()[i].m_normal[0] = normals->GetTuple(i)[0];
sourceData->arrayReference()[i].m_normal[1] = normals->GetTuple(i)[1];
sourceData->arrayReference()[i].m_normal[2] = normals->GetTuple(i)[2];
}
}
else
{
output->computeNormals<T>();
}
#if 0
// Note- the PDB reader assigns a 3 component 'rgb_colors' array as point scalars,
// so make sure we check the number of components
vtkDataArray* scalars = input->GetPointData()->GetScalars();
if (scalars && scalars->GetNumberOfComponents() == 1)
{
for (int i = 0; i < input->GetNumberOfPoints(); ++i)
{
output->GetPointScalars().push_back(static_cast<float>(scalars->GetTuple1(i)));
}
}
#endif
return output;
}
