chan.c

这个库实现了录象功能

        {
        lqt_dump("%s", get_channel_name(channel_labels[i]));
        if(i < num_channels-1)
          lqt_dump(", ");
        }
      }
    else
      {
      lqt_dump("Not available");
      }
    lqt_dump("]\n");
    }
  
  lqt_dump("        mChannelBitmap:             0x%08x", chan->mChannelBitmap);

  if(chan->mChannelLayoutTag == CHANNEL_LAYOUT_UseChannelBitmap)
    {
    lqt_dump(" [");
    j = 0;
    mask = 1;
    for(i = 0; i < 32; i++)
      {
      if(chan->mChannelBitmap & mask)
        {
        if(j)
          lqt_dump(", ");
        lqt_dump("%s", get_channel_name(channel_bit_2_channel_label(mask)));
        j++;
        }
      mask <<= 1;
      }
    lqt_dump("]\n");
    }
  else
    lqt_dump("\n");
   
  
  lqt_dump("        mNumberChannelDescriptions: %d\n", chan->mNumberChannelDescriptions);
  for(i = 0; i < chan->mNumberChannelDescriptions; i++)
    {
    lqt_dump("         mChannelLabel[%d]: 0x%08x [%s]\n", i,
           chan->ChannelDescriptions[i].mChannelLabel, get_channel_name(chan->ChannelDescriptions[i].mChannelLabel));
    lqt_dump("         mChannelFlags[%d]: 0x%08x\n", i,
           chan->ChannelDescriptions[i].mChannelFlags);
    lqt_dump("         mCoordinates[%d]: [%f %f %f]\n", i,
           chan->ChannelDescriptions[i].mCoordinates[0],
           chan->ChannelDescriptions[i].mCoordinates[1],
           chan->ChannelDescriptions[i].mCoordinates[2]);
    }
  }



void quicktime_read_chan(quicktime_t *file, quicktime_chan_t *chan)
  {
  int i;
  chan->version = quicktime_read_char(file);
  chan->flags = quicktime_read_int24(file);

  chan->mChannelLayoutTag = quicktime_read_int32(file);
  chan->mChannelBitmap    = quicktime_read_int32(file);
  chan->mNumberChannelDescriptions = quicktime_read_int32(file);

  if(chan->mNumberChannelDescriptions)
    {
    chan->ChannelDescriptions = calloc(chan->mNumberChannelDescriptions,
                                       sizeof(*(chan->ChannelDescriptions)));
    
    for(i = 0; i < chan->mNumberChannelDescriptions; i++)
      {
      chan->ChannelDescriptions[i].mChannelLabel = quicktime_read_int32(file);
      chan->ChannelDescriptions[i].mChannelFlags = quicktime_read_int32(file);
      chan->ChannelDescriptions[i].mCoordinates[0] = quicktime_read_float32(file);
      chan->ChannelDescriptions[i].mCoordinates[1] = quicktime_read_float32(file);
      chan->ChannelDescriptions[i].mCoordinates[2] = quicktime_read_float32(file);
      }
    }
  
  }

void quicktime_write_chan(quicktime_t *file, quicktime_chan_t *chan)
  {
  quicktime_atom_t atom;
  int i;
  quicktime_atom_write_header(file, &atom, "chan");

  quicktime_write_char(file, chan->version);
  quicktime_write_int24(file, chan->flags);

  quicktime_write_int32(file, chan->mChannelLayoutTag);
  quicktime_write_int32(file, chan->mChannelBitmap);
  quicktime_write_int32(file, chan->mNumberChannelDescriptions);
  
  for(i = 0; i < chan->mNumberChannelDescriptions; i++)
    {
    quicktime_write_int32(file, chan->ChannelDescriptions[i].mChannelLabel);
    quicktime_write_int32(file, chan->ChannelDescriptions[i].mChannelFlags);
    quicktime_write_float32(file, chan->ChannelDescriptions[i].mCoordinates[0]);
    quicktime_write_float32(file, chan->ChannelDescriptions[i].mCoordinates[1]);
    quicktime_write_float32(file, chan->ChannelDescriptions[i].mCoordinates[2]);
    }
  quicktime_atom_write_footer(file, &atom);
  }

/* Update an atrack from a chan atom */
void quicktime_get_chan(quicktime_audio_map_t * atrack)
  {
  int i, num_channels;
  uint32_t mask;
  quicktime_chan_t * chan;
  const channel_label_t * channel_labels;
  chan = &(atrack->track->mdia.minf.stbl.stsd.table[0].chan);

  if(chan->mChannelLayoutTag == CHANNEL_LAYOUT_UseChannelDescriptions)
    {
    atrack->channel_setup = calloc(chan->mNumberChannelDescriptions,
                                   sizeof(*atrack->channel_setup));
    atrack->channels = chan->mNumberChannelDescriptions;
    for(i = 0; i < chan->mNumberChannelDescriptions; i++)
      atrack->channel_setup[i] = channel_label_2_channel(chan->ChannelDescriptions[i].mChannelLabel);
    }
  else if(chan->mChannelLayoutTag == CHANNEL_LAYOUT_UseChannelBitmap)
    {
    /* Count the channels */
    mask = 1;
    num_channels = 0;
    for(i = 0; i < 32; i++)
      {
      if(chan->mChannelBitmap & mask)
        num_channels++;
      mask <<= 1;
      }

    /* Set the channels */
    atrack->channels = num_channels;
    atrack->channel_setup = calloc(num_channels,
                                   sizeof(*atrack->channel_setup));
    
    mask = 1;
    num_channels = 0;
    for(i = 0; i < 32; i++)
      {
      if(chan->mChannelBitmap & mask)
        {
        atrack->channel_setup[num_channels] = 
          channel_label_2_channel(channel_bit_2_channel_label(mask));
        num_channels++;
        }
      mask <<= 1;
      }
    }
  else /* Predefined channel layout */
    {
    channel_labels = get_channel_locations(chan->mChannelLayoutTag, &num_channels);
    atrack->channels = num_channels;

    if(channel_labels)
      {
      atrack->channel_setup = calloc(num_channels,
                                     sizeof(*atrack->channel_setup));
      for(i = 0; i < num_channels; i++)
        atrack->channel_setup[i] = channel_label_2_channel(channel_labels[i]);
      }
    
    }
  
  }


static int layout_equal(channel_label_t * labels, lqt_channel_t * channels, int num_channels)
  {
  int i;

  for(i = 0; i < num_channels; i++)
    {
    if(channels[i] != channel_label_2_channel(labels[i]))
      return 0;
    }
  return 1;
  }

static int layout_similar(channel_label_t * labels, lqt_channel_t * channels, int num_channels)
  {
  int i, j, found;
  
  for(i = 0; i < num_channels; i++)
    {
    found = 0;
    for(j = 0; j < num_channels; j++)
      {
      if(channels[i] == channel_label_2_channel(labels[j]))
        {
        found = 1;
        break;
        }
      }
    if(!found)
      return 0;
    }
  return 1;
  }

/* Set the chan atom of an atrack */
void quicktime_set_chan(quicktime_audio_map_t * atrack)
  {
  int i, j;
  quicktime_chan_t * chan;
  
  if(!atrack->channel_setup)
    return;

  chan = &(atrack->track->mdia.minf.stbl.stsd.table[0].chan);

  /* Search for a equal channel setup */
  for(i = 0; i < sizeof(channel_locations) / sizeof(channel_locations[0]); i++)
    {
    if(((channel_locations[i].layout & 0xffff) == atrack->channels) &&
       layout_equal(channel_locations[i].channels,
                    atrack->channel_setup,
                    atrack->channels))
      {
      chan->mChannelLayoutTag = channel_locations[i].layout;
      atrack->track->mdia.minf.stbl.stsd.table[0].has_chan = 1;
      return;
      }
    }

  /* Search for a similar channel setup */
  for(i = 0; i < sizeof(channel_locations) / sizeof(channel_locations[0]); i++)
    {
    if(((channel_locations[i].layout & 0xffff) == atrack->channels) &&
       layout_similar(channel_locations[i].channels,
                    atrack->channel_setup,
                    atrack->channels))
      {
      chan->mChannelLayoutTag = channel_locations[i].layout;
      atrack->track->mdia.minf.stbl.stsd.table[0].has_chan = 1;

      for(j = 0; j < atrack->channels; j++)
        atrack->channel_setup[j] = channel_label_2_channel(channel_locations[i].channels[j]);
      return;
      }
    }

  /* Nothing found, create a custom channel setup */
  chan->ChannelDescriptions =
    calloc(atrack->channels, sizeof(*(chan->ChannelDescriptions)));
  chan->mNumberChannelDescriptions = atrack->channels;
  chan->mChannelLayoutTag = CHANNEL_LAYOUT_UseChannelDescriptions;
  for(i = 0; i < chan->mNumberChannelDescriptions; i++)
    {
    chan->ChannelDescriptions[i].mChannelLabel =
      channel_2_channel_label(atrack->channel_setup[i]);
    }
  atrack->track->mdia.minf.stbl.stsd.table[0].has_chan = 1;

  }