Inequality outside of process (in when statement?) (VHDL)
Your approach is perfectly legal. The commas are not, however. Getting rid of them should solve your problem, unless there are other issues that are not clear from the code you posted.
Note that there are side-effects to moving your code out of a clocked process, though - the value of blank will change 1 clock earlier, and your timing performance will be worse. Make sure your design can sustain these changes.
Be aware also that the logic for h_sync is not equivalent (though this may actually be an improvement) - in the clocked process, h_sync is not assigned a value in every branch of the if-block, and it appears that it could get stuck at '0' for certain values of HFP, etc. In the concurrent assignment, its value is always explicitly assigned.
brief tutorial on sequential signal assignment
Refer to How does signal assignment work in a process?
The canonical way of thinking about VHDL processes is that signals are not updated until the process suspends (which, for a clocked process, is at the end of the process). It may be helpful to realize that clocked processes are meant to represent physical registers and actual signal propagation. Either way, if you are assigning multiple interdependent signals in clocked processes, the value can only &quot;advance&quot; one signal at a time on each clock edge.
So consider the following code:
(A)
process (clk)
  if rising_edge(clk) then
    foo &lt;= foo + 1; -- if value is becoming N this clock cycle...
    if foo = N then -- value is still N-1 here - signal has not updated yet
      bar &lt;= '1';
    else
      bar &lt;= '0';
    end if;
  end if;
end process;

(B)
process (clk)
  if rising_edge(clk) then
    foo &lt;= foo + 1; -- if value is becoming N this clock cycle...
  end if;
end process;
    
bar &lt;= '1' when foo = N else '0'; -- assigned concurrently, so value is already N here

In (A), foo is not updated until the end of the process. On the clock cycle when foo becomes N, it hasn't been updated when the &quot;if&quot; check is done, so the value of bar will not change. bar will change 1 clock later, since on that iteration of the process, foo will have been updated to equal N.
In (B), bar is not assigned in a clocked process, and therefore will be updated as soon as foo changes (after some logic delays in the real world, of course).
Does that help?