Default ANIMATION_DATA_READ_BUFFER is insufficient for maximum capacity

The qsafeconstraints.h file has the following definition:

static const quint32 ANIMATION_DATA_READ_BUFFER=100U*1024U; //100 kilobytes for the animation data.

When testing the capacity test variant B with 128 safe images, and the states and transitions are defined in the root level (not under the safe QML type), the runtime throws outOfCache exception in the qsafestatefilereader.cpp file (row 86)

if (size > Constraints::ANIMATION_DATA_READ_BUFFER) {
        throw OutOfCache;
    }

The QML file has maximum 128 safe images, and there are 8 states in total. Each state contains animation for each QML object.

The loaded transitionReadBuffer has a size of 905379 in this case.

The temporary workaround is obvious to increase the buffer:

static const quint32 ANIMATION_DATA_READ_BUFFER=1000U*1024U; //1000 kilobytes for the animation data.

But then another issue is spotted:

qsafestateloader.cpp throws QSafeAnimations::IndexOutOfBounds exception

See line 253-260

if (Constraints::MAX_NUM_OF_ANIMATIONS_PER_ITEM >= transitionsCount) {
                while (transitionsCount > 0U) {
                    readTransition(buffer, dataIndex, stateContainer.m_transitions);
                    transitionsCount--;
                }
            } else {
                throw QSafeAnimations::IndexOutOfBounds;
            }

transitionsCount has value of 7168.

While the limit is defined in the safeconstraints.h file:

static const quint32 MAX_NUM_OF_ANIMATIONS_PER_ITEM=((MAX_NUM_OF_STATES*MAX_NUM_OF_STATES)-MAX_NUM_OF_STATES)*5U; //Permutations of the MAX_NUM_OF_STATES * amount of properties (x,y,opacity,sprite,color)

This seems to equal ((8*8) - 8) * 5U = (64-8)*5U = 56*5U = 280U

So the default values seem to work for smaller cases than the maximum capacity.

That yields a smaller memory footprint, but the capacity requirements are not met.

Maybe some explanations would be needed in the documentation FAQ part for tuning these settings if the user wants to balance between the capacity and memory footprint.