Sequential logic in VHDL
Write a process, write a case, just latch the information you need in your process:

p_main: process(clk, reset_n)
  type t_nible_state is (firstnible, secondnible);
  variable r_nible_state : t_nible_state;

  variable r_latchednible : std_logic_vector(7 downto 0);
  variable r_latchedparity : std_logic;

  variable nibletosend : std_logic_vector(3 downto 0);
  variable paritytosend : std_logic;
  variable niblevalid : boolean;

begin

  if reset_n = '0' then
    r_nible_state := firstnible;
    r_latchednible := (others =&gt; '0');
    r_latchedparity := '0';

    nibleoutput &lt;= (others =&gt; '0');
    parityoutput &lt;= '0';
    niblevalidoutput &lt;= false;

  elsif rising_edge(clk) then
    nibletosend := (others =&gt; '0');
    paritytosend := '0';
    niblevalid := false;

    case r_nible_state is
      when firstnible =&gt;
        if bytevalide then -- might not be needed if data is valid every two clock cycles
          r_nible_state := secondnible;

          -- just latch all information you need about both nibles dependent on
          -- the input byte, this includes any parity bits for both this step
          -- and the next
          -- if regs are a problem, but gates are not, latch the
          -- inputbyte, determine parity two times using logic
          r_latchednible := inputbyte(7 downto 4);
          r_latchedparity := secondnibleparity(inputbyte);

          nibletosend := inputbyte(3 downto 0);
          paritytosend := firstnibleparity(inputbyte);
          niblevalid := true;
        end if;
      when secondnible =&gt;
        r_nible_state := firstnible;

        nibletosend := r_latchednible;
        paritytosend := r_latchedparity;
        niblevalid := true;
    end case;

    -- you can put the hamming encoder here using nibletosend
    -- or move to the next block
    nibleoutput &lt;= nibletosend;
    parityoutput &lt;= paritytosend;
    niblevalidoutput &lt;= niblevalid;

  end if;

end process;


Code is untested, but the idea should be simple enough.