JavaScript (ES6),  118  113 bytes

(w,h,M,F)=>(g=(c,n)=>'01210'.replace(/./g,i=>c(+i).repeat([F,M,n][i])))(y=>g(x=>'###+X#++'[y+x*5&7]+' ',w)+`
`,h)

Try it online!

Commented

(w, h, M, F) => ( // given the 4 input variables
 g = ( // g = helper function taking:
 c, // c = callback function returning a string to repeat
 n // n = number of times the painting part must be repeated
 ) => //
 '01210' // string describing the picture structure, with:
 .replace( // 0 = frame, 1 = matte, 2 = painting
 /./g, // for each character in the above string:
 i => // i = identifier of the current area
 c(+i) // invoke the callback function
 .repeat // and repeat it ...
 ([F, M, n][i]) // ... either F, M or n times
 ) // end of replace()
)( // outer call to g:
 y => // callback function taking y:
 g( // inner call to g:
 x => // callback function taking x:
 '###+X#++' // figure out which character to use
 [y + x * 5 & 7] // by applying a small hash function to (x, y)
 + ' ', // append a space
 w // repeat the painting part w times
 ) // end of inner call
 + 'n', // append a line feed
 h // repeat the painting part h times
) // end of outer call

Python 2, 98 bytes

w,h,a,b=input()
a*='+'
b*='#'
for c in b+a+h*'X'+a+b:print' '.join(min(c,d)for d in b+a+w*'X'+a+b)

Try it online!

Prints a space-separated grid, strictly following the spec. I'm amused that *= is used to convert a and b from numbers to strings.

Python 3 can save some bytes by avoiding ' '.join, maybe more by using f-strings and assignment expressions.

Python 3, 95 bytes

def f(w,h,a,b):
 a*='+';b*='#'
 for c in b+a+h*'X'+a+b:print(*[min(c,d)for d in b+a+w*'X'+a+b])

Try it online!

Charcoal, 48 47 44 bytes

≔×ＮXθ≔×ＮXηＦＥ+#×Ｎι«≔⁺ι⁺θιθ≔⁺ι⁺ηιη»Ｅη⪫⭆θ⌊⟦ιλ⟧ 

Try it online! Link is to verbose version of code. Note: Trailing space. Edit: Now uses @xnor's algorithm. Explanation:

≔×ＮXθ≔×ＮXη

Input the width and height and convert them into strings of Xs.

ＦＥ+#×Ｎι

Loop over the characters + and #, converting them into strings of length given by the remaining two inputs. Then loop over those two strings.

«≔⁺ι⁺θιθ≔⁺ι⁺ηιη»

Prefix and suffix the painting with the strings for the matting and framing.

Ｅη⪫⭆θ⌊⟦ιλ⟧ 

Loop over the strings, taking the minimum of the horizontal and vertical characters, and then double-spacing the rows, implicitly printing each row on its own line.

Python 3.8 (pre-release), 116 115 bytes

lambda a,b,c,d,e='#',f='+':"n".join((g:=[e*(a+2*c+2*d)]*d+[(h:=e*d)+f*(a+c*2)+h]*c)+[h+f*c+'X'*a+f*c+h]*b+g[::-1])

Try it online!

First attempt at golfing, will be improved soon.
a is width, b is height, c is matte width, and d is frame width.

-1 bytes using the := operator to define h as e * d

EXPLANATION:

lambda a,b,c,d,e='#',f='+': Define a lambda which takes in arguments a, b, c, and d (The width of the painting, the height of the painting, the padding of the matte, and the padding of the frame width, respectively). It also defines variables e and f as '#' and '+', respectively.
 "n".join( Turn the list into a string, where each element is separated by newlines
 (g:= Define g as (while still evaling the lists)...
 [e*(a+2*c+2*d)]*d+ Form the top rows (the ones filled with hashtags)
 [(h:=e*d)+f*(a+c*2)+h]*c Form the middle-top rows (uses := to golf this section)
 )+
 [h+f*c+'X'*a+f*c+h]*b+ Form the middle row
 g[::-1] Uses g to golf the code (forms the entire middle-bottom-to-bottom)
 )

Wolfram Language (Mathematica), 142 bytes

(t=(p=Table)["# ",2(c=#4+#3)+#2,2c+#];p[t[[i,j]]="+ ",j,z=#4+1,c+#3+#,i,z,c+#3+#2];p[t[[i,j]]="X ",j,#3+z,c+#,i,#3+z,c+#2];""<>#&/@t)&

Try it online!

05AB1E (legacy), 32 31 bytes

и'Xׄ+#vyI©×UεX.ø}®FDнgy×.ø]€S»

Takes the input in the order height, width, matte, frame. If the input order specified in the challenge is strict (still waiting on OP for verification), a leading s (swap) can be added for +1 byte.

Uses the legacy version of 05AB1E instead of the new version, because there seems to be a weird bug with the surround in a map and loop..

Try it online.

Explanation:

и # Repeat the second (implicit) input the first (implicit) input amount of
 # times as list
 'X× '# Repeat "X" that many times
„+#v # Loop `y` over the characters ["+","#"]:
 y # Push character `y`
 I # Push the next input (matte in the first iteration; frame in the second)
 © # And store it in the register (without popping)
 × # Repeat character `y` that input amount of times
 U # Pop and store that string in variable `X`
 εX.ø} # Surround each string in the list with string `X`
 ®F # Inner loop the value from the register amount of times:
 Dнg # Get the new width by taking the length of the first string
 y× # Repeat character `y` that many times
 .ø # And surround the list with this leading and trailing string
 ] # Close both the inner and outer loops
 €S # Convert each inner string to a list of characters
 » # Join every list of characters by spaces, and then every string by newlines
 # (and output the result implicitly)

Javascript, 158 bytes

(w,h,m,f)=>(q="repeat",(z=("#"[q](w+2*(m+f)))+`
`)[q](f))+(x=((e="#"[q](f))+(r="+"[q](m))+(t="+"[q](w))+r+e+`
`)[q](m))+(e+r+"X"[q](w)+r+e+`
`)[q](h)+x+z)

Can probably be trimmed down a little bit

f=

(w,h,m,f)=>(q="repeat",(z=("# "[q](w+2*(m+f))+`
`)[q](f))+(x=((e="# "[q](f))+(r="+ "[q](m))+(t="+ "[q](w))+r+e+`
`)[q](m))+(e+r+"X "[q](w)+r+e+`
`)[q](h)+x+z)

console.log(f(3,2,1,2))

Perl 6, 98 bytes

map(&min,[X] map (($_='#'x$^d~'+'x$^c)~'X'x*~.flip).comb,$^a,$^b).rotor($b+2*($c+$d)).join("n")

Try it online!

This is a port of xnor's Python answer.

Perl 6, 115 bytes

->a,b,c,d$_=['#'xx$!*2+a]xx($!=c+d)*2+b;.[d..^*-d;d..^a+$!+c]='+'xx*;.[$!..^*-$!;$!..^a+$!]='X'xx*;.join("
")

Try it online!

Roughly golfed anonymous codeblock utilising Perl 6's multi-dimensional list assignment. For example, @a[1;2] = 'X'; will assign 'X' to the element with index 2 from the list with index 1, and @a[1,2,3;3,4,5]='X'xx 9; will replace all the elements with indexes 3,4,5 of the lists with indexes 1,2,3 with 'X'.

Explanation:

First, we initialise the list as a a+2*(c+d) by b+2*(c+d) rectangle of #s.

$_=['#'xx$!*2+a]xx($!=c+d)*2+a;
State:
# # # # # # # # #
# # # # # # # # #
# # # # # # # # #
# # # # # # # # #
# # # # # # # # #
# # # # # # # # #
# # # # # # # # #
# # # # # # # # #

Then we assign the inner rectangle of +s

.[d..^*-d;d..^a+$!+c]='+'xx*;
State:
# # # # # # # # #
# # # # # # # # #
# # + + + + + # #
# # + + + + + # #
# # + + + + + # #
# # + + + + + # #
# # # # # # # # #
# # # # # # # # #

Finally, the innermost rectangle of Xs.

.[$!..^*-$!;$!..^a+$!]='X'xx*;
# # # # # # # # #
# # # # # # # # #
# # + + + + + # #
# # + X X X + # #
# # + X X X + # #
# # + + + + + # #
# # # # # # # # #
# # # # # # # # #

Jelly, 35 31 bytes

⁽Q=,⁽QƙDị€x@€⁽-FD¤«þƝẎị“#+X”K€Y

Try it online!

Takes the input in the order matte, frame, width, height; comma separated. Outputs the ASCII-art picture with frame and matte. If the input order is strict I’d need to add 4 bytes (as per my original post).