static int quicktime_decode_rawaudio(quicktime_t *file,
int16_t *output_i, float *output_f, long samples,
int track, int channel)
{
int i, result;
int little_endian = is_little_endian();
quicktime_audio_map_t *track_map = &(file->atracks[track]);
quicktime_rawaudio_codec_t *codec = ((quicktime_codec_t*)track_map->codec)->priv;
int bits = quicktime_audio_bits(file, track);
int byts = bits/8, channels = file->atracks[track].channels;
int size = channels * byts;
get_work_buffer(file, track, samples * size);
result = !quicktime_read_audio(file, codec->work_buffer, samples, track);
if( result ) return result;
// Undo increment since this is done in codecs.c
track_map->current_position -= samples;
if( !little_endian ) {
if( output_i ) {
switch( byts ) {
case 1: rd_samples(int16_t,rd8be_s16,output_i,size); break;
case 2: rd_samples(int16_t,rd16be_s16,output_i,size); break;
case 3: rd_samples(int16_t,rd24be_s16,output_i,size); break;
}
}
else if( output_f ) {
switch( byts ) {
case 1: rd_samples(float,rd8be_flt,output_f,size); break;
case 2: rd_samples(float,rd16be_flt,output_f,size); break;
case 3: rd_samples(float,rd24be_flt,output_f,size); break;
}
}
}
else {
// Undo increment since this is done in codecs.c
track_map->current_position -= samples;
if( output_i ) {
switch( byts ) {
case 1: rd_samples(int16_t,rd8le_s16,output_i,size); break;
case 2: rd_samples(int16_t,rd16le_s16,output_i,size); break;
case 3: rd_samples(int16_t,rd24le_s16,output_i,size); break;
}
}
else if( output_f ) {
switch( byts ) {
case 1: rd_samples(float,rd8le_flt,output_f,size); break;
case 2: rd_samples(float,rd16le_flt,output_f,size); break;
case 3: rd_samples(float,rd24le_flt,output_f,size); break;
}
}
}
/*printf("quicktime_decode_rawaudio 2\n"); */
return 0;
}
static int encode(quicktime_t *file,
int16_t **input_i,
float **input_f,
int track,
long samples)
{
int result = 0;
long i, j, offset;
quicktime_audio_map_t *track_map = &(file->atracks[track]);
quicktime_sowt_codec_t *codec = ((quicktime_codec_t*)track_map->codec)->priv;
int step = track_map->channels * quicktime_audio_bits(file, track) / 8;
int sample;
float sample_f;
get_work_buffer(file, track, samples * step);
if(input_i)
{
for(i = 0; i < track_map->channels; i++)
{
switch(quicktime_audio_bits(file, track))
{
case 8:
for(j = 0; j < samples; j++)
{
sample = input_i[i][j] >> 8;
codec->work_buffer[j * step + i] = sample;
}
break;
case 16:
for(j = 0; j < samples; j++)
{
sample = input_i[i][j];
codec->work_buffer[j * step + i * 2] = ((unsigned int)sample & 0xff00) >> 8;
codec->work_buffer[j * step + i * 2 + 1] = ((unsigned int)sample) & 0xff;
}
break;
case 24:
for(j = 0; j < samples; j++)
{
sample = input_i[i][j];
codec->work_buffer[j * step + i * 3] = ((unsigned int)sample & 0xff00) >> 8;
codec->work_buffer[j * step + i * 3 + 1] = ((unsigned int)sample & 0xff);
codec->work_buffer[j * step + i * 3 + 2] = 0;
}
break;
}
}
}
else
{
for(i = 0; i < track_map->channels; i++)
static int quicktime_encode_rawaudio(quicktime_t *file,
int16_t **input_i, float **input_f, int track, long samples)
{
int i, j, result;
int little_endian = is_little_endian();
quicktime_audio_map_t *track_map = &(file->atracks[track]);
quicktime_rawaudio_codec_t *codec = ((quicktime_codec_t*)track_map->codec)->priv;
int bits = quicktime_audio_bits(file, track);
int byts = bits/8, channels = file->atracks[track].channels;
int size = channels * byts;
get_work_buffer(file, track, samples * size);
if( !little_endian ) {
if( input_i ) {
switch( byts ) {
case 1: wr_samples(int16_t,wr8be_s16,input_i,size); break;
case 2: wr_samples(int16_t,wr16be_s16,input_i,size); break;
case 3: wr_samples(int16_t,wr24be_s16,input_i,size); break;
}
}
else if( input_f ) {
switch( byts ) {
case 1: wr_samples(float,wr8be_flt,input_f,size); break;
case 2: wr_samples(float,wr16be_flt,input_f,size); break;
case 3: wr_samples(float,wr24be_flt,input_f,size); break;
}
}
}
else {
if( input_i ) {
switch( byts ) {
case 1: wr_samples(int16_t,wr8le_s16,input_i,size); break;
case 2: wr_samples(int16_t,wr16le_s16,input_i,size); break;
case 3: wr_samples(int16_t,wr24le_s16,input_i,size); break;
}
}
else if( input_f ) {
switch( byts ) {
case 1: wr_samples(float,wr8le_flt,input_f,size); break;
case 2: wr_samples(float,wr16le_flt,input_f,size); break;
case 3: wr_samples(float,wr24le_flt,input_f,size); break;
}
}
}
result = quicktime_write_audio(file, (char *)codec->work_buffer, samples, track);
return result;
}
static int decode(quicktime_t *file,
int16_t *output_i,
float *output_f,
long samples,
int track,
int channel)
{
int result = 0;
long i, j;
quicktime_audio_map_t *track_map = &(file->atracks[track]);
quicktime_sowt_codec_t *codec = ((quicktime_codec_t*)track_map->codec)->priv;
int step = track_map->channels * quicktime_audio_bits(file, track) / 8;
get_work_buffer(file, track, samples * step);
/*
* printf("decode 1 %d\n", quicktime_audio_bits(file, track));
* sleep(1);
*/
result = !quicktime_read_audio(file, codec->work_buffer, samples, track);
/* Undo increment since this is done in codecs.c */
track_map->current_position -= samples;
/* Handle AVI byte order */
if(!file->use_avi)
swap_bytes(codec->work_buffer,
samples,
track_map->channels,
quicktime_audio_bits(file, track));
switch(quicktime_audio_bits(file, track))
{
case 8:
if(output_i && !result)
{
for(i = 0, j = channel; i < samples; i++)
{
output_i[i] = ((int16_t)codec->work_buffer[j]) << 8;
j += step;
}
}
else
if(output_f && !result)
{
for(i = 0, j = channel; i < samples; i++)
{
output_f[i] = ((float)codec->work_buffer[j]) / 0x7f;
j += step;
}
}
break;
case 16:
if(output_i && !result)
{
for(i = 0, j = channel * 2; i < samples; i++)
{
output_i[i] = ((int16_t)codec->work_buffer[j]) << 8 |
((unsigned char)codec->work_buffer[j + 1]);
j += step;
}
}
else
if(output_f && !result)
{
for(i = 0, j = channel * 2; i < samples; i++)
{
output_f[i] = (float)((((int16_t)codec->work_buffer[j]) << 8) |
((unsigned char)codec->work_buffer[j + 1])) / 0x7fff;
j += step;
}
}
break;
case 24:
if(output_i && !result)
{
for(i = 0, j = channel * 3; i < samples; i++)
{
output_i[i] = (((int16_t)codec->work_buffer[j]) << 8) |
((unsigned char)codec->work_buffer[j + 1]);
j += step;
}
}
else
if(output_f && !result)
{
for(i = 0, j = channel * 3; i < samples; i++)
{
output_f[i] = (float)((((int)codec->work_buffer[j]) << 16) |
(((unsigned char)codec->work_buffer[j + 1]) << 8) |
((unsigned char)codec->work_buffer[j + 2])) / 0x7fffff;
j += step;
}
}
break;
default:
break;
}
return result;
}
