stsdtable.c

这个库实现了录象功能

    quicktime_write_int32(file, 0);
    quicktime_write_int32(file, 0);
    quicktime_write_int32(file, 0);
    quicktime_write_int16(file, table->width);
    quicktime_write_int16(file, table->height);
    quicktime_write_fixed32(file, 0x00480000);
    quicktime_write_fixed32(file, 0x00480000);
    quicktime_write_int32(file, 0);
    quicktime_write_int16(file, 1);
    quicktime_write_data(file, (uint8_t*)table->compressor_name, compressor_name_len);
    for(i = 0; i < 32 - compressor_name_len; i++)
      quicktime_write_char(file, 0);
    
    quicktime_write_int16(file, 24);
    quicktime_write_int16(file, -1);
    }
    
  quicktime_write_user_atoms(file,
                             &table->user_atoms);
  if(table->has_esds)
    quicktime_write_esds(file, &table->esds);
  }

void quicktime_read_stsd_table(quicktime_t *file, quicktime_minf_t *minf,
                               quicktime_stsd_table_t *table)
  {
  quicktime_atom_t leaf_atom;

  quicktime_atom_read_header(file, &leaf_atom);

  table->format[0] = leaf_atom.type[0];
  table->format[1] = leaf_atom.type[1];
  table->format[2] = leaf_atom.type[2];
  table->format[3] = leaf_atom.type[3];

  quicktime_read_data(file, table->reserved, 6);
  table->data_reference = quicktime_read_int16(file);

  /* Panoramas are neither audio nor video */
  if (quicktime_match_32(leaf_atom.type, "pano"))
    {	    
    minf->is_panorama = 1;
    quicktime_read_pano(file, &(table->pano), &leaf_atom);
    }
  else if (quicktime_match_32(leaf_atom.type, "qtvr"))
    {	    
    minf->is_qtvr = 1;
    quicktime_read_qtvr(file, &(table->qtvr), &leaf_atom);
    }
  else if (quicktime_match_32(leaf_atom.type, "\0\0\0\0") && file->moov.udta.is_qtvr)
    {	    
    minf->is_object = 1;
    }
  else if (quicktime_match_32(leaf_atom.type, "text"))
    {
    quicktime_stsdtable_read_text(file, table, &leaf_atom);
    minf->is_text = 1;
    }
  else if (quicktime_match_32(leaf_atom.type, "tx3g"))
    {
    quicktime_stsdtable_read_tx3g(file, table, &leaf_atom);
    minf->is_text = 1;
    }
  else if (quicktime_match_32(leaf_atom.type, "tmcd"))
    {	    
    quicktime_stsdtable_read_timecode(file, table, &leaf_atom);
    minf->is_timecode = 1;
    }
  else 
    {
    if(minf->is_audio) quicktime_read_stsd_audio(file, table, &leaf_atom);
    if(minf->is_video) quicktime_read_stsd_video(file, table, &leaf_atom);
    }
  }

void quicktime_stsd_table_init(quicktime_stsd_table_t *table)
  {
  int i;
  table->format[0] = 'y';
  table->format[1] = 'u';
  table->format[2] = 'v';
  table->format[3] = '2';
  for(i = 0; i < 6; i++) table->reserved[i] = 0;
  table->data_reference = 1;

  table->version = 0;
  table->revision = 0;
  table->vendor[0] = 'l';
  table->vendor[1] = 'q';
  table->vendor[2] = 't';
  table->vendor[3] = ' ';

  table->temporal_quality = 100;
  table->spatial_quality = 258;
  table->width = 0;
  table->height = 0;
  table->dpi_horizontal = 72;
  table->dpi_vertical = 72;
  table->data_size = 0;
  table->frames_per_sample = 1;
  for(i = 0; i < 32; i++) table->compressor_name[i] = 0;
  sprintf(table->compressor_name, "%s-%s", PACKAGE, VERSION);
  table->depth = 24;
  table->ctab_id = 65535;
  quicktime_ctab_init(&(table->ctab));
  quicktime_pasp_init(&(table->pasp));
  quicktime_gama_init(&(table->gama));
  quicktime_fiel_init(&(table->fiel));
  quicktime_clap_init(&(table->clap));
  quicktime_colr_init(&(table->colr));
  quicktime_pano_init(&(table->pano));
  quicktime_qtvr_init(&(table->qtvr));
  quicktime_chan_init(&(table->chan));
	
  table->channels = 0;
  table->sample_size = 0;
  table->compression_id = 0;
  table->packet_size = 0;
  table->samplerate = 0.0;
  }

void quicktime_stsd_table_delete(quicktime_stsd_table_t *table)
  {
  /* LQT: Delete table_raw as well */
  if(table->table_raw)
    free(table->table_raw);
  quicktime_ctab_delete(&(table->ctab));
  quicktime_wave_delete(&(table->wave));
  quicktime_esds_delete(&(table->esds));
  quicktime_ftab_delete(&(table->tx3g.ftab));
  quicktime_user_atoms_delete(&(table->user_atoms));
  
  if(table->tmcd.name)
    free(table->tmcd.name);
  }

void quicktime_stsd_video_dump(quicktime_stsd_table_t *table)
  {
  lqt_dump("       version %d\n", table->version);
  lqt_dump("       revision %d\n", table->revision);
  lqt_dump("       vendor %c%c%c%c\n", table->vendor[0], table->vendor[1], table->vendor[2], table->vendor[3]);
  lqt_dump("       temporal_quality %ld\n", table->temporal_quality);
  lqt_dump("       spatial_quality %ld\n", table->spatial_quality);
  lqt_dump("       width %d\n", table->width);
  lqt_dump("       height %d\n", table->height);
  lqt_dump("       dpi_horizontal %f\n", table->dpi_horizontal);
  lqt_dump("       dpi_vertical %f\n", table->dpi_vertical);
  lqt_dump("       data_size %"PRId64"\n", table->data_size);
  lqt_dump("       frames_per_sample %d\n", table->frames_per_sample);
  lqt_dump("       compressor_name %s\n", table->compressor_name);
  lqt_dump("       depth %d\n", table->depth);
  lqt_dump("       ctab_id %d\n", table->ctab_id);

  if (table->has_pasp)
    quicktime_pasp_dump(&(table->pasp));
  if (table->has_clap)
    quicktime_clap_dump(&(table->clap));
  if (table->has_colr)
    quicktime_colr_dump(&(table->colr));
  if (table->has_fiel)
    quicktime_fiel_dump(&(table->fiel));
  if (table->has_gama)
    quicktime_gama_dump(&(table->gama));

  if(table->has_ctab) quicktime_ctab_dump(&(table->ctab));
  if(table->has_esds) quicktime_esds_dump(&(table->esds));
  quicktime_user_atoms_dump(&(table->user_atoms));
  }

void quicktime_stsd_audio_dump(quicktime_stsd_table_t *table)
  {
  lqt_dump("       version %d\n", table->version);
  lqt_dump("       revision %d\n", table->revision);
  lqt_dump("       vendor %c%c%c%c\n", table->vendor[0], table->vendor[1], table->vendor[2], table->vendor[3]);
  lqt_dump("       channels %d\n", table->channels);
  lqt_dump("       sample_size %d\n", table->sample_size);

  if(table->version < 2)
    {
    lqt_dump("       compression_id %d\n", table->compression_id);
    lqt_dump("       packet_size %d\n", table->packet_size);
    lqt_dump("       samplerate %f\n",  table->samplerate);
          
    if(table->version == 1)
      {
      lqt_dump("       samples_per_packet: %d\n", table->audio_samples_per_packet);
      lqt_dump("       bytes_per_packet:   %d\n", table->audio_bytes_per_packet);
      lqt_dump("       bytes_per_frame:    %d\n", table->audio_bytes_per_frame);
      lqt_dump("       bytes_per_samples:  %d\n", table->audio_bytes_per_sample);
      }
          
    }
  else if(table->version == 2)
    {
    lqt_dump("       samplerate                     %f\n",  table->samplerate);
    lqt_dump("       formatSpecificFlags:           %08x\n", table->formatSpecificFlags);
    lqt_dump("       constBytesPerAudioPacket:      %d\n", table->constBytesPerAudioPacket);
    lqt_dump("       constLPCMFramesPerAudioPacket: %d\n", table->constLPCMFramesPerAudioPacket);
    }
        
  if(table->has_wave)
    quicktime_wave_dump(&table->wave);
  if(table->has_esds)
    quicktime_esds_dump(&table->esds);
  if(table->has_chan)
    quicktime_chan_dump(&table->chan);
  quicktime_user_atoms_dump(&(table->user_atoms));
  }


void quicktime_stsd_table_dump(void *minf_ptr, quicktime_stsd_table_t *table)
  {
  quicktime_minf_t *minf = minf_ptr;
  lqt_dump("       format %c%c%c%c\n",
           table->format[0], table->format[1],
           table->format[2], table->format[3]);

  quicktime_print_chars("       reserved ", table->reserved, 6);
  lqt_dump("       data_reference %d\n", table->data_reference);

  if(minf->is_audio) quicktime_stsd_audio_dump(table);
  else if(minf->is_video) quicktime_stsd_video_dump(table);
        
  else if (quicktime_match_32(table->format, "pano"))
    quicktime_pano_dump(&(table->pano));
  else if (quicktime_match_32(table->format, "qtvr"))
    quicktime_qtvr_dump(&(table->qtvr));
  else if(quicktime_match_32(table->format, "text"))
    quicktime_stsdtable_dump_text(table);
  else if(quicktime_match_32(table->format, "tx3g"))
    quicktime_stsdtable_dump_tx3g(table);
  else if(quicktime_match_32(table->format, "tx3g"))
    quicktime_stsdtable_dump_tx3g(table);
  else if(quicktime_match_32(table->format, "tmcd"))
    quicktime_stsdtable_dump_timecode(table);
  }

void quicktime_write_stsd_table(quicktime_t *file, quicktime_minf_t *minf, quicktime_stsd_table_t *table)
  {
  quicktime_atom_t atom;
  quicktime_atom_write_header(file, &atom, table->format);
  quicktime_write_data(file, table->reserved, 6);
  quicktime_write_int16(file, table->data_reference);

  if(minf->is_audio) quicktime_write_stsd_audio(file, table);
  if(minf->is_video) quicktime_write_stsd_video(file, table);
  if(minf->is_qtvr == QTVR_QTVR_PAN) quicktime_write_qtvr(file, &(table->qtvr));
  if(minf->is_qtvr == QTVR_QTVR_OBJ) quicktime_write_qtvr(file, &(table->qtvr));
  if(minf->is_timecode) quicktime_write_stsd_timecode(file, table);
  
  if(minf->is_text)
    {
    if(quicktime_match_32(table->format, "text"))
      quicktime_write_stsd_text(file, table);
    else if(quicktime_match_32(table->format, "tx3g"))
      quicktime_write_stsd_tx3g(file, table);
    }
        
  quicktime_atom_write_footer(file, &atom);
  }

void quicktime_set_stsd_audio_v1(quicktime_stsd_table_t *table,
                                 uint32_t samples_per_packet,
                                 uint32_t bytes_per_packet,
                                 uint32_t bytes_per_frame,
                                 uint32_t bytes_per_sample)
  {
  table->version = 1;
  table->audio_samples_per_packet = samples_per_packet;
  table->audio_bytes_per_packet = bytes_per_packet;
  table->audio_bytes_per_frame = bytes_per_frame;
  table->audio_bytes_per_sample = bytes_per_sample;
  }

#if 1
void quicktime_set_stsd_audio_v2(quicktime_stsd_table_t *table,
                                 uint32_t formatSpecificFlags,
                                 uint32_t constBytesPerAudioPacket,
                                 uint32_t constLPCMFramesPerAudioPacket)
  {
  table->version = 2;
  table->formatSpecificFlags = formatSpecificFlags;
  table->constBytesPerAudioPacket = constBytesPerAudioPacket;
  table->constLPCMFramesPerAudioPacket = constLPCMFramesPerAudioPacket;
  }
#endif

uint8_t * quicktime_stsd_get_user_atom(quicktime_trak_t * trak, char * name, uint32_t * len)
  {
  quicktime_stsd_table_t *table = &(trak->mdia.minf.stbl.stsd.table[0]);
  return(quicktime_user_atoms_get_atom(&table->user_atoms, name, len));
  }

void quicktime_stsd_set_user_atom(quicktime_trak_t * trak, char * name,
                                  uint8_t * data, uint32_t len)
  {
  quicktime_stsd_table_t *table = &(trak->mdia.minf.stbl.stsd.table[0]);
  quicktime_user_atoms_add_atom(&table->user_atoms,
                                name, data, len);
  
  }