1. What are you doing in the above code? The array name is mute and the name itself points to the first item of the array. So, the code should be:
SPI.transfer(mute, sizeof(mute)); //both bytes of the array will be transmitted one-after-another.
2. The following command does transfer single byte data.
byte x = SPI.transfer(mute[1]); //x holds the data coming from SPDR Register of Slave
3. The avialable data transfer commands of SPi protocol are:
receivedVal = SPI.transfer(val)
receivedVal16 = SPI.transfer16(val16)
SPI.transfer(buffer, size)
4. If you execute this command (for array transmission): SPI.transfer(mute, sizeof(mute)), the original data of the mute[]
array will be replaced by the data coming from Slave as the DPDR Registers of Master and Slave form a circulating buffer sysetm (Fig-1). It is not the data corruption; but, a feature of the SPI Protocol.

Figure-1:
5. You can study the following two sketches and can easily figure out the reason for the source array data to get changed.
Master SPI Sketch:
#include <SPI.h>
byte myData[] = {0x56, 0x89};
void setup ()
{
Serial.begin(115200);
digitalWrite(SS, HIGH); // ensure SS stays high for now
SPI.begin ();
delay(100);
digitalWrite(SS, LOW); // SS is pin 10
SPI.setClockDivider(SPI_CLOCK_DIV16); //1Mbits/sec
Serial.print("Array value before transfer command: ");
Serial.print(myData[0], HEX);
Serial.println(myData[1], HEX);
SPI.transfer(myData, sizeof(myData));
Serial.print("Array value after transfer command: ");
Serial.print(myData[0], HEX);
Serial.println(myData[1], HEX);
}
void loop()
{
}
Slave SPI Sketch:
#include <SPI.h>
volatile byte myData[] = {0x12, 0x34};
volatile int i = 0;
volatile byte x;
void setup ()
{
Serial.begin(115200);
pinMode(SS, INPUT_PULLUP);
pinMode(MISO, OUTPUT);
SPCR |= !(_BV(MSTR));
SPCR |= _BV(SPE);
SPI.attachInterrupt();
SPDR = 0x99;
}
void loop()
{
}
ISR(SPI_STC_vect)
{
SPDR = myData[i];
i++;
if(i == 2)
{
i = 0;
}
}
Master Serial Monitor Output:
Array value before transfer command: 5689
Array value after transfer command: 3456