pcm.c

这个库实现了录象功能

  quicktime_set_frma(atrack->track, "in24");

  if(codec->little_endian)
    {
    /* Set enda */
    quicktime_set_enda(&(atrack->track->mdia.minf.stbl.stsd.table[0]), 1);
    }

  if(codec->little_endian)
    codec->encode = encode_s24_le;
  else
    codec->encode = encode_s24_be;
  }

void quicktime_init_codec_in24(quicktime_audio_map_t *atrack)
  {
  quicktime_pcm_codec_t *codec;
  quicktime_codec_t *codec_base = (quicktime_codec_t*)atrack->codec;
  
  /* Init public items */
  codec_base->delete_acodec = delete_pcm;
  codec_base->decode_audio = decode_pcm;
  codec_base->encode_audio = encode_pcm;
  codec_base->set_parameter = set_parameter_pcm;
  /* Init private items */
  codec = calloc(1, sizeof(*codec));
  codec_base->priv = codec;

  codec->block_align = 3 * atrack->channels;
  atrack->sample_format = LQT_SAMPLE_INT32;

  if(quicktime_get_enda(&(atrack->track->mdia.minf.stbl.stsd.table[0])))
    codec->decode = decode_s24_le;
  else
    codec->decode = decode_s24_be;
  codec->init_encode = init_encode_in24;
  }

static void init_encode_in32(quicktime_t * file, int track)
  {
  quicktime_audio_map_t *atrack = &(file->atracks[track]);
  quicktime_pcm_codec_t *codec = ((quicktime_codec_t*)atrack->codec)->priv;
  quicktime_stsd_table_t *table = &(atrack->track->mdia.minf.stbl.stsd.table[0]);
  
  /* Initialize version 1 stsd */
  quicktime_set_stsd_audio_v1(table, 1, 4, 4 * atrack->channels, 2);

  quicktime_set_frma(atrack->track, "in32");

  if(codec->little_endian)
    {
    /* Set enda */
    quicktime_set_enda(&(atrack->track->mdia.minf.stbl.stsd.table[0]), 1);
    }

#ifdef WORDS_BIGENDIAN
  if(codec->little_endian)
    codec->encode = encode_s32_swap;
  else
    codec->encode = encode_s32;
#else
  if(codec->little_endian)
    codec->encode = encode_s32;
  else
    codec->encode = encode_s32_swap;
#endif

  
  }


void quicktime_init_codec_in32(quicktime_audio_map_t *atrack)
  {
  quicktime_pcm_codec_t *codec;
  quicktime_codec_t *codec_base = (quicktime_codec_t*)atrack->codec;
  
  /* Init public items */
  codec_base->delete_acodec = delete_pcm;
  codec_base->decode_audio = decode_pcm;
  codec_base->encode_audio = encode_pcm;

  /* Init private items */
  codec = calloc(1, sizeof(*codec));
  codec_base->priv = codec;

  codec->block_align = 4 * atrack->channels;
  atrack->sample_format = LQT_SAMPLE_INT32;

#ifdef WORDS_BIGENDIAN
  if(quicktime_get_enda(&(atrack->track->mdia.minf.stbl.stsd.table[0])))
    codec->decode = decode_s32_swap;
  else
    codec->decode = decode_s32;
#else
  if(quicktime_get_enda(&(atrack->track->mdia.minf.stbl.stsd.table[0])))
    codec->decode = decode_s32;
  else
    codec->decode = decode_s32_swap;
#endif
  codec->init_encode = init_encode_in32;
  }

/* Floating point */

static void init_encode_fl32(quicktime_t * file, int track)
  {
  quicktime_audio_map_t *atrack = &(file->atracks[track]);
  quicktime_pcm_codec_t *codec = ((quicktime_codec_t*)atrack->codec)->priv;
  quicktime_stsd_table_t *table = &(atrack->track->mdia.minf.stbl.stsd.table[0]);
  
  /* Initialize version 1 stsd */
  quicktime_set_stsd_audio_v1(table, 1, 4, 4 * atrack->channels, 2);

  quicktime_set_frma(atrack->track, "fl32");

  if(codec->little_endian)
    {
    codec->encode = encode_fl32_le;
    /* Set enda */
    quicktime_set_enda(&(atrack->track->mdia.minf.stbl.stsd.table[0]), 1);
    }
  else
    {
    codec->encode = encode_fl32_be;
    }
  }


void quicktime_init_codec_fl32(quicktime_audio_map_t *atrack)
  {
  quicktime_pcm_codec_t *codec;
  quicktime_codec_t *codec_base = (quicktime_codec_t*)atrack->codec;
  
  /* Init public items */
  codec_base->delete_acodec = delete_pcm;
  codec_base->decode_audio = decode_pcm;
  codec_base->encode_audio = encode_pcm;

  /* Init private items */
  codec = calloc(1, sizeof(*codec));
  codec_base->priv = codec;

  codec->block_align = 4 * atrack->channels;
  atrack->sample_format = LQT_SAMPLE_FLOAT;

  if(quicktime_get_enda(&(atrack->track->mdia.minf.stbl.stsd.table[0])))
    codec->decode = decode_fl32_le;
  else
    codec->decode = decode_fl32_be;
  codec->init_encode = init_encode_fl32;
  }



static void init_encode_fl64(quicktime_t * file, int track)
  {
  quicktime_audio_map_t *atrack = &(file->atracks[track]);
  quicktime_pcm_codec_t *codec = ((quicktime_codec_t*)atrack->codec)->priv;
  quicktime_stsd_table_t *table = &(atrack->track->mdia.minf.stbl.stsd.table[0]);
  
  /* Initialize version 1 stsd */
  quicktime_set_stsd_audio_v1(table, 1, 8, 8 * atrack->channels, 2);

  quicktime_set_frma(atrack->track, "fl64");

  if(codec->little_endian)
    {
    codec->encode = encode_fl64_le;
    /* Set enda */
    quicktime_set_enda(&(atrack->track->mdia.minf.stbl.stsd.table[0]), 1);
    }
  else
    {
    codec->encode = encode_fl64_be;
    }
  }

void quicktime_init_codec_fl64(quicktime_audio_map_t *atrack)
  {
  quicktime_pcm_codec_t *codec;
  quicktime_codec_t *codec_base = (quicktime_codec_t*)atrack->codec;
  
  /* Init public items */
  codec_base->delete_acodec = delete_pcm;
  codec_base->decode_audio = decode_pcm;
  codec_base->encode_audio = encode_pcm;

  /* Init private items */
  codec = calloc(1, sizeof(*codec));
  codec_base->priv = codec;

  codec->block_align = 8 * atrack->channels;
  atrack->sample_format = LQT_SAMPLE_DOUBLE;

  if(quicktime_get_enda(&(atrack->track->mdia.minf.stbl.stsd.table[0])))
    codec->decode = decode_fl64_le;
  else
    codec->decode = decode_fl64_be;
  codec->init_encode = init_encode_fl64;
  }


/* raw */

void quicktime_init_codec_rawaudio(quicktime_audio_map_t *atrack)
  {
  quicktime_codec_t *codec_base = (quicktime_codec_t*)atrack->codec;
  quicktime_pcm_codec_t *codec;
  
  /* Init public items */
  codec_base->delete_acodec = delete_pcm;
  codec_base->decode_audio = decode_pcm;
  codec_base->encode_audio = encode_pcm;
  
  /* Init private items */
  codec = calloc(1, sizeof(*codec));
  codec_base->priv = codec;

  switch(atrack->track->mdia.minf.stbl.stsd.table[0].sample_size)
    {
    case 8:
      codec->block_align = atrack->channels;
      atrack->sample_format = LQT_SAMPLE_UINT8;
      codec->encode = encode_8;
      codec->decode = decode_8;
      break;
    case 16:
      codec->block_align = 2 * atrack->channels;
      atrack->sample_format = LQT_SAMPLE_INT16;
#ifdef WORDS_BIGENDIAN
      codec->encode = encode_s16;
      codec->decode = decode_s16;
#else
      codec->encode = encode_s16_swap;
      codec->decode = decode_s16_swap;
#endif
      break;
    case 24:
      codec->block_align = 3 * atrack->channels;
      atrack->sample_format = LQT_SAMPLE_INT32;
      codec->encode = encode_s24_le;
      codec->decode = decode_s24_le;
      break;
    }
  }

void quicktime_init_codec_ulaw(quicktime_audio_map_t *atrack)
  {
  quicktime_codec_t *codec_base = (quicktime_codec_t*)atrack->codec;
  quicktime_pcm_codec_t *codec;
  
  /* Init public items */
  codec_base->delete_acodec = delete_pcm;
  codec_base->decode_video = 0;
  codec_base->encode_video = 0;
  codec_base->decode_audio = decode_pcm;
  codec_base->encode_audio = encode_pcm;
  
  /* Init private items */
  codec = calloc(1, sizeof(*codec));
  codec_base->priv = codec;
  
  codec->block_align = atrack->channels;
  codec->encode = encode_ulaw;
  codec->decode = decode_ulaw;
  atrack->sample_format = LQT_SAMPLE_INT16;
  }

void quicktime_init_codec_alaw(quicktime_audio_map_t *atrack)
  {
  quicktime_codec_t *codec_base = (quicktime_codec_t*)atrack->codec;
  quicktime_pcm_codec_t *codec;
  
  /* Init public items */
  codec_base->delete_acodec = delete_pcm;
  codec_base->decode_video = 0;
  codec_base->encode_video = 0;
  codec_base->decode_audio = decode_pcm;
  codec_base->encode_audio = encode_pcm;
  
  /* Init private items */
  codec = calloc(1, sizeof(*codec));
  codec_base->priv = codec;
  
  codec->block_align = atrack->channels;
  codec->encode = encode_alaw;
  codec->decode = decode_alaw;
  atrack->sample_format = LQT_SAMPLE_INT16;
  }

/* SampleDescription V2 definitions */
#define kAudioFormatFlagIsFloat          (1L<<0) 
#define kAudioFormatFlagIsBigEndian      (1L<<1) 
#define kAudioFormatFlagIsSignedInteger  (1L<<2) 
#define kAudioFormatFlagIsPacked         (1L<<3) 
#define kAudioFormatFlagIsAlignedHigh    (1L<<4) 
#define kAudioFormatFlagIsNonInterleaved (1L<<5) 
#define kAudioFormatFlagIsNonMixable     (1L<<6) 
#define kAudioFormatFlagsAreAllClear     (1L<<31)  

static void init_decode_lpcm(quicktime_t * file, int track)
  {
  quicktime_audio_map_t *atrack = &(file->atracks[track]);
  quicktime_pcm_codec_t *codec = ((quicktime_codec_t*)atrack->codec)->priv;
  quicktime_stsd_table_t *table = &(atrack->track->mdia.minf.stbl.stsd.table[0]);
  
  if(table->formatSpecificFlags & kAudioFormatFlagIsFloat)
    {
    switch(table->sample_size)
      {
      case 32:
        if(!(table->formatSpecificFlags & kAudioFormatFlagIsBigEndian))
          {
          codec->decode = decode_fl32_le;
          }
        else
          {
          codec->decode = decode_fl32_be;
          }
        atrack->sample_format = LQT_SAMPLE_FLOAT;
        break;
      case 64:
        if(!(table->formatSpecificFlags & kAudioFormatFlagIsBigEndian))
          {
          codec->decode = decode_fl64_le;
          }
        else
          {
          codec->decode = decode_fl64_be;
          }
        atrack->sample_format = LQT_SAMPLE_DOUBLE;
        break;
      }
    }
  else
    {
    switch(table->sample_size)
      {
      case 16:
        if(table->formatSpecificFlags & kAudioFormatFlagIsBigEndian)
          {
#ifdef WORDS_BIGENDIAN
          codec->decode = decode_s16;
#else
          codec->decode = decode_s16_swap;
#endif
          }
        else
          {
#ifdef WORDS_BIGENDIAN
          codec->decode = decode_s16_swap;
#else
          codec->decode = decode_s16;
#endif
          }
        atrack->sample_format = LQT_SAMPLE_INT16;
        break;
      case 24:
        if(table->formatSpecificFlags & kAudioFormatFlagIsBigEndian)
          {
          codec->decode = decode_s24_be;
          }
        else
          {
          codec->decode = decode_s24_le;
          }
        atrack->sample_format = LQT_SAMPLE_INT32;
        break;
      case 32:
        if(table->formatSpecificFlags & kAudioFormatFlagIsBigEndian)
          {
#ifdef WORDS_BIGENDIAN
          codec->decode = decode_s32;
#else
          codec->decode = decode_s32_swap;
#endif
          }
        else
          {
#ifdef WORDS_BIGENDIAN
          codec->decode = decode_s32_swap;
#else
          codec->decode = decode_s32;
#endif
          }
        atrack->sample_format = LQT_SAMPLE_INT32;
        break;
      }
    }

  codec->block_align = (table->sample_size/8) * atrack->channels;

  }

static void init_encode_lpcm(quicktime_t * file, int track)
  {
  quicktime_audio_map_t *atrack = &(file->atracks[track]);
  quicktime_pcm_codec_t *codec = ((quicktime_codec_t*)atrack->codec)->priv;
  quicktime_stsd_table_t *table = &(atrack->track->mdia.minf.stbl.stsd.table[0]);

  uint32_t formatSpecificFlags = 0;

  switch(codec->format)
    {
    case FORMAT_INT_16:
      formatSpecificFlags =
        kAudioFormatFlagIsSignedInteger | kAudioFormatFlagIsPacked;
      if(!codec->little_endian)
        {
        formatSpecificFlags |= kAudioFormatFlagIsBigEndian;
#ifdef WORDS_BIGENDIAN
        codec->encode = encode_s16;
#else
        codec->encode = encode_s16_swap;
#endif
        }
      else
        {
#ifdef WORDS_BIGENDIAN
        codec->encode = encode_s16_swap;
#else
        codec->encode = encode_s16;
#endif
        }
      table->sample_size = 16;
      atrack->sample_format = LQT_SAMPLE_INT16;
      break;
    case FORMAT_INT_24:
      formatSpecificFlags = kAudioFormatFlagIsSignedInteger | kAudioFormatFlagIsPacked;
      if(!codec->little_endian)
        {
        formatSpecificFlags |= kAudioFormatFlagIsBigEndian;
        codec->encode = encode_s24_be;
        }
      else
        {
        codec->encode = encode_s24_le;
        }
      table->sample_size = 24;
      atrack->sample_format = LQT_SAMPLE_INT32;
      break;
    case FORMAT_INT_32:
      formatSpecificFlags = kAudioFormatFlagIsSignedInteger | kAudioFormatFlagIsPacked;
      if(!codec->little_endian)
        {
        formatSpecificFlags |= kAudioFormatFlagIsBigEndian;
#ifdef WORDS_BIGENDIAN
        codec->encode = encode_s32;
#else
        codec->encode = encode_s32_swap;
#endif
        }
      else
        {
#ifdef WORDS_BIGENDIAN
        codec->encode = encode_s32_swap;
#else
        codec->encode = encode_s32;
#endif
        }
      table->sample_size = 32;
      atrack->sample_format = LQT_SAMPLE_INT32;
      break;
    case FORMAT_FLOAT_32:
      formatSpecificFlags = kAudioFormatFlagIsFloat | kAudioFormatFlagIsPacked;
      if(!codec->little_endian)
        {
        formatSpecificFlags |= kAudioFormatFlagIsBigEndian;
        codec->encode = encode_fl32_be;
        }
      else
        {
        codec->encode = encode_fl32_le;
        }
      table->sample_size = 32;
      atrack->sample_format = LQT_SAMPLE_FLOAT;
      break;
    case FORMAT_FLOAT_64:
      formatSpecificFlags = kAudioFormatFlagIsFloat | kAudioFormatFlagIsPacked;
      if(!codec->little_endian)
        {
        formatSpecificFlags |= kAudioFormatFlagIsBigEndian;
        codec->encode = encode_fl64_be;
        }
      else
        {
        codec->encode = encode_fl64_le;
        }
      table->sample_size = 64;
      atrack->sample_format = LQT_SAMPLE_DOUBLE;
      break;
    }
  
  /* Initialize version 2 stsd */

  codec->block_align = atrack->channels * (table->sample_size/8);

  quicktime_set_stsd_audio_v2(table,
                              formatSpecificFlags,
                              codec->block_align /* constBytesPerAudioPacket */,
                              1 /* constLPCMFramesPerAudioPacket */);

  /* Set correct stsz */
  atrack->track->mdia.minf.stbl.stsz.sample_size =
    (table->sample_size/8)*atrack->channels;
  
  }


void quicktime_init_codec_lpcm(quicktime_audio_map_t *atrack)
  {
  quicktime_codec_t *codec_base = (quicktime_codec_t*)atrack->codec;
  quicktime_pcm_codec_t *codec;
  
  /* Init public items */
  codec_base->delete_acodec = delete_pcm;
  codec_base->decode_video = 0;
  codec_base->encode_video = 0;
  codec_base->decode_audio = decode_pcm;
  codec_base->encode_audio = encode_pcm;
  codec_base->set_parameter = set_parameter_pcm;
  
  /* Init private items */
  codec = calloc(1, sizeof(*codec));
  codec_base->priv = codec;
    
  codec->init_encode = init_encode_lpcm;
  codec->init_decode = init_decode_lpcm;
  
  //  atrack->sample_format = LQT_SAMPLE_INT16;
  }