Rotating a 2D Matrix Let's say I have the following (2D) matrix:

[[1,  2,  3,  4 ],
 [5,  6,  7,  8 ],
 [9,  10, 11, 12],
 [13, 14, 15, 16]]


Rotate the matrix counterclockwise R times (not in 90 degree increments, just by 1 number each time),

1  2  3  4             2 3   4  8         3   4   8  12
5  6  7  8    --&gt;      1 7  11 12   --&gt;   2  11  10  16 
9  10 11 12            5 6  10 16         1   7   6  15 
13 14 15 16            9 13 14 15         5   9  13  14


Completed example:

Input:

2
[[1,  2,  3,  4 ],
 [5,  6,  7,  8 ],
 [9,  10, 11, 12],
 [13, 14, 15, 16]]


Output:

[[3,  4,  8, 12],
 [2, 11, 10, 16],
 [1,  7,  6, 15],
 [5,  9, 13, 14]]


(weird spaces are to align the numbers in nice columns)

The outer "ring" of the matrix rotates 2 counterclockwise, and the inner right rotates 2 also.  In this matrix, there are only two rings.

An example with 1 "ring":

2
[[1, 2],
 [3, 4],
 [5, 6]]


Should output:

[[4, 6],
 [2, 5],
 [1, 3]]


Your challenge is to take in a matrix and an integer R, and output the translated version after R rotations.

Rotation of a 4x5 matrix is represented by the following figure:


Constraints: 


2 ≤ M, N ≤ 100, where M and N are the dimensions of the matrix. It is guaranteed that the minimum of M and N will be even. 
1 ≤ R ≤ 80, where r is number of rotations.
The matrix will only ever contain positive integers.
Values are not always distinct.
The input should always be as a 2D array (if you can't take runtime input as a 2D array, then you just have to find another way to get input).


Another test case, with non-distinct values:

1
[[1, 1],
 [2, 2],
 [3, 3]]


Outputs:

[[1, 2],
 [1, 3],
 [2, 3]]


This is code-golf, so the shortest answer wins!
Octave, 210 bytes

function M=F(M,R);f=@(z)[-z/2:-1 !eye(!!mod(z,2)) 1:z/2];t=angle(f([x y]=size(M))'+f(y)*i);B=!!M;B(2:x-1,2:y-1)=0;d=bwdist(B,'ch');[~,I]=sortrows([d(:) t(:)]);for k=0:max(d(:));M(h)=shift(M(h=I(d(I)==k)),R);end

Try it on Octave Online!
Ungolfed version:
function M=F(M,R)
    [x y]=size(M);
    f=@(z)[-z/2:-1 !eye(!!mod(z,2)) 1:z/2];
    t=angle(f(x)'+f(y)*i);
    B=!!M;
    B(2:x-1,2:y-1)=0;
    d=bwdist(B,'chessboard');
    [~,I]=sortrows([d(:) t(:)]);
    for k=0:max(d(:))
        M(h)=shift(M(h=I(d(I)==k)),R);
    end
end
R=2;
M=randi(10,4,7)
F(M,R)

Explanation:
f=@(z)[-z/2:-1 !eye(!!mod(z,2)) 1:z/2]; 

A function that gets a number and generates a range that is ordered and centered
for input 4 (even) generates  -2  -1   1   2
for input 5(odd) generates -2.5 -1.5 0  1  2 
only it should be ordered and centered
f(x)'+f(y)*i    

a complex matrix generated from ranges
(-2,-2.5) (-2,-1.5) (-2,0) (-2,1) (-2,2)
(-1,-2.5) (-1,-1.5) (-1,0) (-1,1) (-1,2)
(1,-2.5)  (1,-1.5)  (1,0)  (1,1)  (1,2)
(2,-2.5)  (2,-1.5)  (2,0)  (2,1)  (2,2)

t=angle(f(x)'+f(y)*i);                    

Convert rectangular to polar coordinates and return angles so for each ring angles are sorted counteclockwise
-2.25  -2.50  3.14  2.68  2.36
-1.95  -2.16  3.14  2.36  2.03
-1.19  -0.98  0.00  0.79  1.11
-0.90  -0.64  0.00  0.46  0.79


B=!!M;
B(2:x-1,2:y-1)=0;

The following matrix generated
1   1   1   1   1
1   0   0   0   1
1   0   0   0   1
1   1   1   1   1

d=bwdist(B,'chessboard');

Computes the distance transform of B using chessboard distance to generate ring indices
0   0   0   0   0
0   1   1   1   0
0   1   1   1   0
0   0   0   0   0               

for a 6 * 7 matrix we will have the following matrix
0   0   0   0   0   0   0
0   1   1   1   1   1   0
0   1   2   2   2   1   0
0   1   2   2   2   1   0
0   1   1   1   1   1   0
0   0   0   0   0   0   0   

[~,I]=sortrows([d(:) t(:)]);

lexicographic sort first based on ring index and then by order of angle(indices of sorted elements returned)
    for k=0:max(d(:))
        M(h)=shift(M(h=I(d(I)==k)),R);
    end

and finally circular shift each ring.