home *** CD-ROM | disk | FTP | other *** search
/ Geek 6 / Geek-006.iso / linux / video / xmovie-1.5.3.tar.gz / xmovie-1.5.3.tar / xmovie-1.5.3 / quicktime / rawaudio.c < prev    next >
C/C++ Source or Header  |  2000-11-29  |  5KB  |  215 lines
  1. #include "rawaudio.h"
  2.  
  3. /* =================================== private for rawaudio */
  4.  
  5. int rawaudio_byte_order(void)
  6. {                /* 1 if little endian */
  7.     QUICKTIME_INT16 byteordertest;
  8.     int byteorder;
  9.  
  10.     byteordertest = 0x0001;
  11.     byteorder = *((unsigned char *)&byteordertest);
  12.     return byteorder;
  13. }
  14.  
  15. int rawaudio_swap_bytes(char *buffer, long samples, int channels, int bits)
  16. {
  17.     long i;
  18.     char byte1, byte2, byte3;
  19.     char *buffer1, *buffer2, *buffer3;
  20.  
  21.     if(!rawaudio_byte_order()) return 0;
  22.  
  23.     switch(bits)
  24.     {
  25.         case 8:
  26.             break;
  27.  
  28.         case 16:
  29.             buffer1 = buffer;
  30.             buffer2 = buffer + 1;
  31.             while(i < samples * 2)
  32.             {
  33.                 byte1 = buffer2[i];
  34.                 buffer2[i] = buffer1[i];
  35.                 buffer1[i] = byte1;
  36.                 i += 2;
  37.             }
  38.             break;
  39.  
  40.         case 24:
  41.             buffer1 = buffer;
  42.             buffer2 = buffer + 2;
  43.             while(i < samples * 3)
  44.             {
  45.                 byte1 = buffer2[i];
  46.                 buffer2[i] = buffer1[i];
  47.                 buffer1[i] = byte1;
  48.                 i += 3;
  49.             }
  50.             break;
  51.  
  52.         default:
  53.             break;
  54.     }
  55.     return 0;
  56. }
  57.  
  58. int rawaudio_get_work_buffer(quicktime_t *file, int track, long bytes)
  59. {
  60.     quicktime_rawaudio_codec_t *codec = ((quicktime_codec_t*)file->atracks[track].codec)->priv;
  61.  
  62.     if(codec->work_buffer && codec->buffer_size != bytes)
  63.     {
  64.         free(codec->work_buffer);
  65.         codec->work_buffer = 0;
  66.     }
  67.     
  68.     if(!codec->work_buffer) 
  69.     {
  70.         codec->buffer_size = bytes;
  71.         if(!(codec->work_buffer = malloc(bytes))) return 1;
  72.     }
  73.     return 0;
  74. }
  75.  
  76. /* =================================== public for rawaudio */
  77.  
  78. static int quicktime_delete_codec_rawaudio(quicktime_audio_map_t *atrack)
  79. {
  80.     quicktime_rawaudio_codec_t *codec = ((quicktime_codec_t*)atrack->codec)->priv;
  81.  
  82.     if(codec->work_buffer) free(codec->work_buffer);
  83.     codec->work_buffer = 0;
  84.     codec->buffer_size = 0;
  85.     free(codec);
  86.     return 0;
  87. }
  88.  
  89. static int quicktime_decode_rawaudio(quicktime_t *file, 
  90.                     QUICKTIME_INT16 *output_i, 
  91.                     float *output_f, 
  92.                     long samples, 
  93.                     int track, 
  94.                     int channel)
  95. {
  96.     int result = 0;
  97.     long i, j;
  98.     quicktime_rawaudio_codec_t *codec = ((quicktime_codec_t*)file->atracks[track].codec)->priv;
  99.     int step = file->atracks[track].channels * quicktime_audio_bits(file, track) / 8;
  100.  
  101.     rawaudio_get_work_buffer(file, track, samples * step);
  102.     result = quicktime_read_audio(file, codec->work_buffer, samples, track);
  103.     result = !result;     /* Defeat fwrite's return */
  104.  
  105.     switch(quicktime_audio_bits(file, track))
  106.     {
  107.         case 8:
  108.             if(output_i && !result)
  109.             {
  110.                 for(i = 0, j = 0; i < samples; i++)
  111.                 {
  112.                     output_i[i] = ((QUICKTIME_INT16)((unsigned char)codec->work_buffer[j]) << 8);
  113.                     j += step;
  114.                     output_i[i] -= 0x8000;
  115.                 }
  116.             }
  117.             else
  118.             if(output_f && !result)
  119.             {
  120.                 for(i = 0, j = 0; i < samples; i++)
  121.                 {
  122.                     output_f[i] = (float)((unsigned char)codec->work_buffer[j]) - 0x80;
  123.                     output_f[i] /= 0x7f;
  124.                     j += step;
  125.                 }
  126.             }
  127.             break;
  128.         
  129.         case 16:
  130.             if(output_i && !result)
  131.             {
  132.                 for(i = 0, j = 0; i < samples; i++)
  133.                 {
  134.                     output_i[i] = (QUICKTIME_INT16)(codec->work_buffer[j]) << 8 |
  135.                                     (unsigned char)(codec->work_buffer[j + 1]);
  136.                     j += step;
  137.                     output_i[i] -= 0x8000;
  138.                 }
  139.             }
  140.             else
  141.             if(output_f && !result)
  142.             {
  143.                 for(i = 0, j = 0; i < samples; i++)
  144.                 {
  145.                     output_f[i] = (float)((QUICKTIME_INT16)(codec->work_buffer[j]) << 8 |
  146.                                     (unsigned char)(codec->work_buffer[j + 1])) - 0x8000;
  147.                     output_f[i] /= 0x7fff;
  148.                     j += step;
  149.                 }
  150.             }
  151.             break;
  152.         
  153.         case 24:
  154.             if(output_i && !result)
  155.             {
  156.                 for(i = 0, j = 0; i < samples; i++)
  157.                 {
  158.                     output_i[i] = ((QUICKTIME_INT16)(codec->work_buffer[j]) << 8) | 
  159.                                     (unsigned char)(codec->work_buffer[j + 1]);
  160.                     output_i[i] -= 0x8000;
  161.                     j += step;
  162.                 }
  163.             }
  164.             else
  165.             if(output_f && !result)
  166.             {
  167.                 for(i = 0, j = 0; i < samples; i++)
  168.                 {
  169.                     output_f[i] = (float)(((int)(codec->work_buffer[j]) << 16) | 
  170.                                     ((unsigned int)(codec->work_buffer[j + 1]) << 8) |
  171.                                     (unsigned char)(codec->work_buffer[j + 2])) - 0x800000;
  172.                     output_f[i] /= 0x7fffff;
  173.                     j += step;
  174.                 }
  175.             }
  176.             break;
  177.         
  178.         default:
  179.             break;
  180.     }
  181. /*printf("quicktime_decode_rawaudio 2\n"); */
  182.  
  183.     return result;
  184. }
  185.  
  186. static int quicktime_encode_rawaudio(quicktime_t *file, 
  187.                             QUICKTIME_INT16 **input_i, 
  188.                             float **input_f, 
  189.                             int track, 
  190.                             long samples)
  191. {
  192.     int result = 0;
  193. printf("quicktime_encode_rawaudio: not implemented\n");
  194.     return result;
  195. }
  196.  
  197.  
  198. void quicktime_init_codec_rawaudio(quicktime_audio_map_t *atrack)
  199. {
  200.     quicktime_rawaudio_codec_t *codec;
  201.  
  202. /* Init public items */
  203.     ((quicktime_codec_t*)atrack->codec)->priv = calloc(1, sizeof(quicktime_rawaudio_codec_t));
  204.     ((quicktime_codec_t*)atrack->codec)->delete_acodec = quicktime_delete_codec_rawaudio;
  205.     ((quicktime_codec_t*)atrack->codec)->decode_video = 0;
  206.     ((quicktime_codec_t*)atrack->codec)->encode_video = 0;
  207.     ((quicktime_codec_t*)atrack->codec)->decode_audio = quicktime_decode_rawaudio;
  208.     ((quicktime_codec_t*)atrack->codec)->encode_audio = quicktime_encode_rawaudio;
  209.  
  210. /* Init private items */
  211.     codec = ((quicktime_codec_t*)atrack->codec)->priv;
  212.     codec->work_buffer = 0;
  213.     codec->buffer_size = 0;
  214. }
  215.