0

Subsequent to my question posted here, further investigation into LAME with gdb revealed that at any given time, only 576 samples are read from the input pcm file. However, these samples are used to populate a 2304 1D or 2*1152 2D array. It is this conversion that I am not able to understand. I am posting the relevant code here and request an explanation. I have explained parts of the code and inserted questions into the code as ???. 

  samples_read = read_samples_pcm(global.musicin, insamp, num_channels * samples_to_read);
  /* global.musicin = FILE pointer to input pcm file.
   * insamp is a 1D int array of [2*1152] size.
   * num_channels = 1. samples_to_read = 576. */
    if (samples_read < 0) {
        return samples_read;
    }
    p = insamp + samples_read;
    samples_read /= num_channels;  /*samples_read = 576 after this step. prior to this it is optimized out.*/
    if (buffer != NULL) { /* output to int buffer */
        if (num_channels == 2) {
            for (i = samples_read; --i >= 0;) {
                buffer[1][i] = *--p;
                buffer[0][i] = *--p;
            }
        }
        else if (num_channels == 1) {
            memset(buffer[1], 0, samples_read * sizeof(int));
            for (i = samples_read; --i >= 0;) {
                buffer[0][i] = *--p;
                /*??? Is this line a fancy way of copying first 576 samples of insamp into buffer[0]?*/
            }
        }
        else
            assert(0);
    }

The function read_samples_pcm is defined so: 

static int
read_samples_pcm(FILE * const musicin, int sample_buffer[2304], int samples_to_read)
{
    int     samples_read;

    samples_read = sf_read_int((SNDFILE *) musicin, sample_buffer, samples_to_read);

#if 0
    switch (global.pcmbitwidth) {
    case 8:
        for (i = 0; i < samples_read; i++)
            sample_buffer[i] <<= (8 * sizeof(int) - 8);
        break;
    case 16:  /*input pcm is 16 bit say.*/
        for (i = 0; i < samples_read; i++)
            sample_buffer[i] <<= (8 * sizeof(int) - 16); /*??? what is going on? */
        break;
    case 24:
        for (i = 0; i < samples_read; i++)
            sample_buffer[i] <<= (8 * sizeof(int) - 24);
        break;
    case 32:
        break;
    default:
        if (silent < 10) {
            error_printf("Only 8, 16, 24 and 32 bit input files supported \n");
        }
        exit(1);
    }
#endif

    return samples_read;
}
Community
  • 1
  • 1
Sriram
  • 10,298
  • 21
  • 83
  • 136

1 Answers1

1

/??? Is this line a fancy way of copying first 576 samples of insamp into buffer[0]?/

Basically, yes. It's just copying the data end->start rather than the usual start->end order. I'm not sure but I think some people prefer this for memory cache performance reasons.

/*??? what is going on? */

It's scaling the 16-bit input to a 32-bit number. Let's walk through it:

sample_buffer[i] <<= (8 * sizeof(int) - 16);

If sizeof(int) is 4 bytes, 8 * 4 - 16 = 16. Thus, shift the 16-bit number left by 16 in order to scale it to a 32-bit number. If sizeof(int) is 8 bytes, 8 * 8 - 16 = 48. If ints are 64-bit, a left shift by 48 bits is necessary.

I'm not sure if I've answered all your questions here. Feel free to follow up.

Multimedia Mike
  • 12,660
  • 5
  • 46
  • 62
  • @Mike: Thanks for the reply. The bit-shift makes sense. However, in the copying part, don't you think that the copy operation is start->end as well? `p = insamp + samples_read` which means `p` points to `insamp[576]`. now in the copy operation, for the first `i`, `buffer[0][575] = insamp[575]`. am i correct? – Sriram Jan 31 '13 at 04:29
  • The copy operation appears to be end->start. Perhaps it was misleading when I wrote "the usual start->end order". I didn't mean that this code was doing the copy start->end. Rather, I meant that (I believe) start->end is how most people intuitively implement and visualize a memcpy operation (though, fun fact: memcpy is not guaranteed to copy in any particular order). – Multimedia Mike Jan 31 '13 at 04:35