This can be a valid approach. You're observing a very practical issue that arises often when using fixed-point (i.e. integer) arithmetic (although it can happen in floating-point also). When the numeric format that you're using to perform calculations doesn't have enough precision to express the full range of values that can arise from your calculations, some form of rounding is required (e.g. truncation, round-to-nearest, and so on). This is often modeled as an additive quantization error to your signal.
However, for some combinations of algorithm and rounding scheme, when the magnitude of the input signal is very low, it's possible to get what you observed: a large number of zero outputs. Basically, somewhere in the sequence of operations, the intermediate results are becoming small enough to not break the threshold required to quantize to a nonzero level. The value is then rounded to zero, which can often propagate forward to the output. The result is, as you noted, an algorithm that generates a lot of output zeros.
So can you get around this by scaling the data up? Sometimes (there are very few techniques that work all the time!). If your input signal is bounded in magnitude to a value below full-scale of the numeric format (16-bit signed integers run from -32768 to +32767), then you could scale the input signal up to more fully use the range available to it. This can help to mitigate the effects of roundoff error, as the magnitude of any roundoff error becomes smaller in comparison to the signal of interest. So, in the case where all of your outputs are getting rounded to zeros internally to the algorithm, this may help.
When can such a technique hurt you? Depending upon the structure of the algorithm's calculations, scaling the input signal up might expose you to numeric overflows. Also, if the signal contains background noise or interference that is larger in magnitude than the algorithm's roundoff error, then the quality of what you get at the output is going to be typically limited by the environment, not error introduced in the computation.