LoweBowe/MuseScore
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

[gp] replaced QByteArray to ByteArray

Browse source
This commit is contained in:
Igor Korsukov 2022-07-14 15:50:48 +02:00
parent eae6e644f9
commit 95327fe65c
6 changed files with 57 additions and 42 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
src/framework/global/serialization/xmldom.h
View file

@ -24,8 +24,7 @@
#include <memory>
#include <QByteArray>
#include "types/bytearray.h"
#include "types/string.h"
namespace mu {

18
src/framework/global/types/bytearray.cpp
View file

@ -133,6 +133,17 @@ bool ByteArray::empty() const
return size() == 0;
}
void ByteArray::reserve(size_t nsize)
{
if (nsize <= size()) {
return;
}
detach();
m_data->reserve(nsize + 1);
m_data->operator [](nsize) = 0;
}
void ByteArray::resize(size_t nsize)
{
if (nsize == size()) {
@ -191,7 +202,7 @@ void ByteArray::push_back(const ByteArray& ba)
push_back(ba.constData(), ba.size());
}
uint8_t ByteArray::operator[](size_t pos) const
uint8_t ByteArray::at(size_t pos) const
{
assert(pos < size());
if (pos < size()) {
@ -200,6 +211,11 @@ uint8_t ByteArray::operator[](size_t pos) const
return 0;
}
uint8_t ByteArray::operator[](size_t pos) const
{
return at(pos);
}
uint8_t& ByteArray::operator[](size_t pos)
{
detach();

3
src/framework/global/types/bytearray.h
View file

@ -58,9 +58,12 @@ public:
void push_back(uint8_t b);
void push_back(const uint8_t* b, size_t len);
void push_back(const ByteArray& ba);
uint8_t at(size_t pos) const;
uint8_t operator[](size_t pos) const;
uint8_t& operator[](size_t pos);
void reserve(size_t nsize);
void resize(size_t nsize);
void truncate(size_t pos);
void clear();

51
src/importexport/guitarpro/internal/importgtp-gp6.cpp
View file

@ -245,7 +245,7 @@ std::unique_ptr<IGPDomBuilder> GuitarPro6::createGPDomBuilder() const
// readBit
//---------------------------------------------------------
int GuitarPro6::readBit(QByteArray* buffer)
int GuitarPro6::readBit(ByteArray* buffer)
{
// calculate the byte index by dividing the position in bits by the bits per byte
int byteIndex = position / BITS_IN_BYTE;
@ -266,7 +266,7 @@ int GuitarPro6::readBit(QByteArray* buffer)
// readBits
//---------------------------------------------------------
int GuitarPro6::readBits(QByteArray* buffer, int bitsToRead)
int GuitarPro6::readBits(ByteArray* buffer, int bitsToRead)
{
int bits = 0;
for (int i = (bitsToRead - 1); i >= 0; i--) {
@ -279,7 +279,7 @@ int GuitarPro6::readBits(QByteArray* buffer, int bitsToRead)
// readBitsReversed
//---------------------------------------------------------
int GuitarPro6::readBitsReversed(QByteArray* buffer, int bitsToRead)
int GuitarPro6::readBitsReversed(ByteArray* buffer, int bitsToRead)
{
int bits = 0;
for (int i = 0; i < bitsToRead; i++) {
@ -292,12 +292,12 @@ int GuitarPro6::readBitsReversed(QByteArray* buffer, int bitsToRead)
// getBytes
//---------------------------------------------------------
QByteArray GuitarPro6::getBytes(QByteArray* buffer, int offset, int length)
ByteArray GuitarPro6::getBytes(ByteArray* buffer, int offset, int length)
{
QByteArray newBytes;
ByteArray newBytes;
// compute new bytes from our buffer and return byte array
for (int i = 0; i < length; i++) {
if (buffer->length() > offset + i) {
if (buffer->size() > offset + i) {
newBytes.insert(i, ((*buffer)[offset + i]));
}
}
@ -308,7 +308,7 @@ QByteArray GuitarPro6::getBytes(QByteArray* buffer, int offset, int length)
// readInteger
//---------------------------------------------------------
int GuitarPro6::readInteger(QByteArray* buffer, int offset)
int GuitarPro6::readInteger(ByteArray* buffer, int offset)
{
// assign four bytes and take them from the buffer
char bytes[4];
@ -326,9 +326,9 @@ int GuitarPro6::readInteger(QByteArray* buffer, int offset)
// readString
//---------------------------------------------------------
QByteArray GuitarPro6::readString(QByteArray* buffer, int offset, int length)
ByteArray GuitarPro6::readString(ByteArray* buffer, int offset, int length)
{
QByteArray filename;
ByteArray filename;
// compute the string by iterating through the buffer
for (int i = 0; i < length; i++) {
int charValue = (((*buffer)[offset + i]) & 0xff);
@ -399,7 +399,7 @@ void GuitarPro6::parseFile(const char* filename, ByteArray* data)
// readGPX
//---------------------------------------------------------
void GuitarPro6::readGPX(QByteArray* buffer)
void GuitarPro6::readGPX(ByteArray* buffer)
{
// start by reading the file header. It will tell us if the byte array is compressed.
int fileHeader = readInteger(buffer, 0);
@ -407,7 +407,7 @@ void GuitarPro6::readGPX(QByteArray* buffer)
if (fileHeader == GPX_HEADER_COMPRESSED) {
// this is a compressed file.
int length = readInteger(buffer, position / BITS_IN_BYTE);
QByteArray bcfsBuffer;
ByteArray bcfsBuffer;
bcfsBuffer.reserve(length);
int positionCounter = 0;
while ((position / BITS_IN_BYTE) < length) {
@ -419,7 +419,7 @@ void GuitarPro6::readGPX(QByteArray* buffer)
int offs = readBitsReversed(buffer, bits);
int size = readBitsReversed(buffer, bits);
int pos = (bcfsBuffer.length() - offs);
int pos = (bcfsBuffer.size() - offs);
for (int i = 0; i < (size > offs ? offs : size); i++) {
bcfsBuffer.insert(positionCounter, bcfsBuffer[pos + i]);
positionCounter++;
@ -436,10 +436,10 @@ void GuitarPro6::readGPX(QByteArray* buffer)
readGPX(&bcfsBuffer);
} else if (fileHeader == GPX_HEADER_UNCOMPRESSED) {
// this is an uncompressed file - strip the header off
*buffer = buffer->right(buffer->length() - sizeof(int));
int sectorSize = 0x1000;
int offset = 0;
while ((offset = (offset + sectorSize)) + 3 < buffer->length()) {
*buffer = buffer->right(buffer->size() - sizeof(int));
size_t sectorSize = 0x1000;
size_t offset = 0;
while ((offset = (offset + sectorSize)) + 3 < buffer->size()) {
int newInt = readInteger(buffer, offset);
if (newInt == 2) {
int indexFileName = (offset + 4);
@ -449,18 +449,17 @@ void GuitarPro6::readGPX(QByteArray* buffer)
// create a byte array and put information about files found in it
int block = 0;
int blockCount = 0;
QByteArray* fileBytes = new QByteArray();
ByteArray* fileBytes = new ByteArray();
while ((block = (readInteger(buffer, (indexOfBlock + (4 * (blockCount++)))))) != 0) {
fileBytes->push_back(getBytes(buffer, (offset = (block * sectorSize)), sectorSize));
}
// get file information and read the file
int fileSize = readInteger(buffer, indexFileSize);
if (fileBytes->length() >= fileSize) {
QByteArray filenameBytes = readString(buffer, indexFileName, 127);
char* filename = filenameBytes.data();
QByteArray data = getBytes(fileBytes, 0, fileSize);
ByteArray d = ByteArray::fromQByteArrayNoCopy(data);
parseFile(filename, &d);
size_t fileSize = readInteger(buffer, indexFileSize);
if (fileBytes->size() >= fileSize) {
ByteArray filenameBytes = readString(buffer, indexFileName, 127);
const char* filename = filenameBytes.constChar();
ByteArray data = getBytes(fileBytes, 0, fileSize);
parseFile(filename, &data);
}
delete fileBytes;
}
@ -476,10 +475,8 @@ bool GuitarPro6::read(IODevice* io)
{
f = io;
previousTempo = -1;
ByteArray buffer = io->readAll();
// decompress and read files contained within GPX file
QByteArray ba = buffer.toQByteArrayNoCopy();
ByteArray ba = io->readAll();
readGPX(&ba);

7
src/importexport/guitarpro/internal/importgtp-gp7.cpp
View file

@ -46,13 +46,12 @@ bool GuitarPro7::read(IODevice* io)
f = io;
previousTempo = -1;
mu::ZipReader zip(io);
ZipReader zip(io);
ByteArray fileData = zip.fileData("Content/score.gpif");
ByteArray partsData = zip.fileData("Content/PartConfiguration");
zip.close();
QByteArray partsArray = partsData.toQByteArrayNoCopy();
m_properties = readProperties(&partsArray);
m_properties = readProperties(&partsData);
readGpif(&fileData);
return true;
@ -62,7 +61,7 @@ bool GuitarPro7::read(IODevice* io)
// readProperties
//---------------------------------------------------------
GuitarPro::GPProperties GuitarPro7::readProperties(QByteArray* data)
GuitarPro::GPProperties GuitarPro7::readProperties(ByteArray* data)
{
GPProperties properties;
size_t partsInfoSize = data->size();

17
src/importexport/guitarpro/internal/importgtp.h
View file

@ -413,13 +413,14 @@ class GuitarPro6 : public GuitarPro
};
void parseFile(const char* filename, ByteArray* data);
int readBit(QByteArray* buffer);
QByteArray getBytes(QByteArray* buffer, int offset, int length);
void readGPX(QByteArray* buffer);
int readInteger(QByteArray* buffer, int offset);
QByteArray readString(QByteArray* buffer, int offset, int length);
int readBits(QByteArray* buffer, int bitsToRead);
int readBitsReversed(QByteArray* buffer, int bitsToRead);
int readBit(ByteArray* buffer);
ByteArray getBytes(ByteArray* buffer, int offset, int length);
void readGPX(ByteArray* buffer);
int readInteger(ByteArray* buffer, int offset);
ByteArray readString(ByteArray* buffer, int offset, int length);
int readBits(ByteArray* buffer, int bitsToRead);
int readBitsReversed(ByteArray* buffer, int bitsToRead);
int findNumMeasures(GPPartInfo* partInfo);
void readMasterTracks(XmlDomNode* masterTrack);
void readDrumNote(Note* note, int element, int variation);
@ -452,7 +453,7 @@ public:
GuitarPro7(MasterScore* s)
: GuitarPro6(s, 7) {}
bool read(mu::io::IODevice*) override;
GPProperties readProperties(QByteArray* data);
GPProperties readProperties(ByteArray* data);
};
} // namespace Ms
#endif