Discrete Wavelet Transform on images and watermark embedding in LL band coefficients, data is lost when IDWT-DWT is performed again?

Question

I'm writing an image watermarking system to hide a watermark in an image's low frequency band by transforming the image's luminance channel with a Discrete Wavelet Transform, then modifying coefficients in the LL band of the DWT output. I then do an Inverse DWT and rebuild my image.

The problem I'm having is when I modify coefficients in the DWT output, then inverse-DWT, and then DWT again, the modified coefficients are radically different.

For example, one of the output coefficients in the LL band of the 2-scale DWT was -0.10704, I modified this coefficient to be 16.89, then performed the IDWT on my data. I then took the output of the IDWT and performed a DWT on it again, and my coefficient which was modified to be 16.89 became 0.022.

I'm fairly certain that the DWT and IDWT code is correct because I've tested it against other libraries and the output from each transform matches when the filter coefficients and other parameters are the same. (Within what can be expected due to rounding error)

The main problem I have is that I perhaps don't understand the DWT all that well, I thought DWT and IDWT were supposed to be reasonably lossless (Aside from rounding error and such), yet this doesn't seem to be the case here.

I'm hoping someone more familiar with the transform can point me at a possible issue, is it possible that because the coefficients in my other subbands (LH, HL, HH) for that position are insignificant I'm losing data? If so, how can I determine which coefficients this may happen to?

My embedding function is below, coefficients are chosen in the LL band, "strong" is determined to be true if the absolute value of the LH, HH, or HL band for the selected location is larger than the mean value of the corresponding subband.

//If this evaluates to true, then the texture is considered strong.
if ((Math.Abs(LH[i][w]) >= LHmean) || (Math.Abs(HL[i][w]) >= HLmean) || (Math.Abs(HH[i][w]) >= HHmean)) 



    static double MarkCoeff(int index, double coeff,bool strong)
    {
        int q1 = 16;
        int q2 = 8;
        int quantizestep = 0;
        byte watermarkbit = binaryWM[index];


        if(strong)
            quantizestep  = q1;
        else
            quantizestep = q2;

        coeff /= (double)quantizestep;
        double coeffdiff = 0;
        if(coeff > 0.0)
            coeffdiff = coeff - (int)coeff;
        else
            coeffdiff = coeff + (int)coeff;

        if (1 == ((int)coeff % 2))
        {
            //odd
            if (watermarkbit == 0)
            {
                if (Math.Abs(coeffdiff) > 0.5)
                    coeff += 1.0;
                else
                    coeff -= 1.0;
            }
        }
        else
        {
            //even
            if (watermarkbit == 1)
            {
                if (Math.Abs(coeffdiff) > 0.5)
                    coeff += 1.0;
                else
                    coeff -= 1.0;
            }
        }

        coeff *= (double)quantizestep;

        return coeff;
    }