stsdtable.c

这个库实现了录象功能

  else /* SoundDescriptionV2 */
    {
    /*
     *  SInt16     always3;
     *  SInt16     always16;
     *  SInt16     alwaysMinus2;
     *  SInt16     always0;
     *  UInt32     always65536;
     *  UInt32     sizeOfStructOnly;
     */
    quicktime_set_position(file, quicktime_position(file) + 16);
    //          quicktime_set_position(file, quicktime_position(file) + 12);
          
    /*
     * Float64    audioSampleRate;
     */
    table->samplerate = quicktime_read_double64(file);

    /*
     * UInt32     numAudioChannels;
     */

    table->channels = quicktime_read_int32(file);
          
    /*
     * SInt32     always7F000000;
     */
          
    quicktime_set_position(file, quicktime_position(file) + 4);

          

    table->sample_size = quicktime_read_int32(file);
    table->formatSpecificFlags = quicktime_read_int32(file);

    /* The following 2 are (hopefully) unused */
          
          
    table->constBytesPerAudioPacket = quicktime_read_int32(file);
    table->constLPCMFramesPerAudioPacket = quicktime_read_int32(file);

    //          quicktime_set_position(file, quicktime_position(file) + 8);

    }
        
  /* Read additional atoms */
  while(quicktime_position(file) < parent_atom->end)
    {
    quicktime_atom_read_header(file, &leaf_atom);
    if(quicktime_atom_is(&leaf_atom, "wave"))
      {
      quicktime_read_wave(file, &(table->wave), &leaf_atom);
      table->has_wave = 1;
      }
    else if(quicktime_atom_is(&leaf_atom, "esds"))
      {
      quicktime_read_esds(file, &(table->esds));
      table->has_esds = 1;
      quicktime_atom_skip(file, &leaf_atom);
      }
    else if(quicktime_atom_is(&leaf_atom, "chan"))
      {
      quicktime_read_chan(file, &(table->chan));
      table->has_chan = 1;
      quicktime_atom_skip(file, &leaf_atom);
      }
    else
      {
      lqt_log(file, LQT_LOG_INFO, LOG_DOMAIN, "Skipping unknown atom \"%4s\" inside audio stsd",
              leaf_atom.type);
      quicktime_atom_skip(file, &leaf_atom);
      }
    } 

  }

void quicktime_write_stsd_audio(quicktime_t *file, quicktime_stsd_table_t *table)
  {
  int tmp_version = file->file_type & (LQT_FILE_QT|LQT_FILE_QT_OLD) ? table->version : 0;
        
  if(IS_MP4(file->file_type))
    {
    quicktime_write_int32(file, 0);
    quicktime_write_int32(file, 0);
    }
  else
    {
    quicktime_write_int16(file, tmp_version);
    quicktime_write_int16(file, table->revision);
    quicktime_write_data(file, (uint8_t*)(table->vendor), 4);
    }

  if(tmp_version < 2)
    {
    quicktime_write_int16(file, table->channels);
    quicktime_write_int16(file, (file->file_type & (LQT_FILE_QT|LQT_FILE_QT_OLD)) ? table->sample_size : 16);
    quicktime_write_int16(file, (file->file_type & (LQT_FILE_QT|LQT_FILE_QT_OLD)) ? table->compression_id : 0);
    quicktime_write_int16(file, table->packet_size);
    quicktime_write_fixed32(file, table->samplerate);
    if(tmp_version == 1)
      {
      quicktime_write_int32(file, table->audio_samples_per_packet);
      quicktime_write_int32(file, table->audio_bytes_per_packet);
      quicktime_write_int32(file, table->audio_bytes_per_frame);
      quicktime_write_int32(file, table->audio_bytes_per_sample);
      }
    }
  else
    {
    quicktime_write_int16(file, 0x0003); //                               SInt16 always3;
    quicktime_write_int16(file, 0x0010); //                               SInt16 always16;
    quicktime_write_int16(file, 0xFFFE); //                               SInt16 alwaysMinus2;
    quicktime_write_int16(file, 0x0000); //                               SInt16 always0;
    quicktime_write_int32(file, 0x00010000); //                           UInt32 always65536;
    quicktime_write_int32(file, 0x00000048); //                           UInt32 sizeOfStructOnly;
    quicktime_write_double64(file, table->samplerate); //                 Float64 audioSampleRate;
    quicktime_write_int32(file, table->channels); //                      UInt32 numAudioChannels;
    quicktime_write_int32(file, 0x7F000000); //                           SInt32 always7F000000;
    quicktime_write_int32(file, table->sample_size); //                   UInt32 constBitsPerChannel;
    quicktime_write_int32(file, table->formatSpecificFlags); //          UInt32 formatSpecificFlags;
    quicktime_write_int32(file, table->constBytesPerAudioPacket);      // UInt32 constBytesPerAudioPacket;
    quicktime_write_int32(file, table->constLPCMFramesPerAudioPacket); // UInt32 constLPCMFramesPerAudioPacket;
    }
  if(file->file_type & (LQT_FILE_QT|LQT_FILE_QT_OLD))
    {
    if(table->has_wave)
      {
      /* For quicktime, we must put the esds atom into the wave atom */
      if(table->has_esds)
        {
        memcpy(&table->wave.esds, &table->esds, sizeof(table->wave.esds));
        table->wave.has_esds = 1;
        }
      quicktime_write_wave(file, &table->wave);
      if(table->has_esds)
        {
        memset(&table->wave.esds, 0, sizeof(table->wave.esds));
        table->wave.has_esds = 0;
        }
      }
    if(table->has_chan)
      quicktime_write_chan(file, &table->chan);
    }
  else
    {
    if(table->has_esds)
      quicktime_write_esds(file, &table->esds);
    }
        
  }


void quicktime_read_stsd_table_raw(quicktime_t *file, quicktime_stsd_table_t *table)
  {
  quicktime_atom_t leaf_atom;
  int64_t old_position;
  old_position = quicktime_position(file);

  quicktime_atom_read_header(file, &leaf_atom);

  /* We write the raw atom verbatim into the raw table */
  table->table_raw_size = leaf_atom.size;

  table->table_raw = malloc(table->table_raw_size);
  quicktime_set_position(file, leaf_atom.start);
  quicktime_read_data(file, table->table_raw, table->table_raw_size);
  

  }


void quicktime_read_stsd_video(quicktime_t *file, quicktime_stsd_table_t *table,
                               quicktime_atom_t *parent_atom)
  {
  quicktime_atom_t leaf_atom;
  int len, bits_per_pixel;
        
  table->version = quicktime_read_int16(file);
  table->revision = quicktime_read_int16(file);
  quicktime_read_data(file, (uint8_t*)table->vendor, 4);
  table->temporal_quality = quicktime_read_int32(file);
  table->spatial_quality = quicktime_read_int32(file);
  table->width = quicktime_read_int16(file);
  table->height = quicktime_read_int16(file);
  table->dpi_horizontal = quicktime_read_fixed32(file);
  table->dpi_vertical = quicktime_read_fixed32(file);
  table->data_size = quicktime_read_int32(file);
  table->frames_per_sample = quicktime_read_int16(file);
  len = quicktime_read_char(file);
  quicktime_read_data(file, (uint8_t*)table->compressor_name, 31);
  table->depth = quicktime_read_int16(file);
  table->ctab_id = quicktime_read_int16(file);
        
        
  /*  If ctab_id is zero, the colortable follows immediately
   *  after the ctab ID
   */
  bits_per_pixel = table->depth & 0x1f;
  if(!table->ctab_id &&
     ((bits_per_pixel == 1) ||
      (bits_per_pixel == 2) ||
      (bits_per_pixel == 4) ||
      (bits_per_pixel == 8)))
    {
    quicktime_read_ctab(file, &(table->ctab));
    table->has_ctab = 1;
    }
  else
    quicktime_default_ctab(&(table->ctab), table->depth);
        
  while(quicktime_position(file) + 8 < parent_atom->end)
    {
    quicktime_atom_read_header(file, &leaf_atom);
    if(quicktime_atom_is(&leaf_atom, "ctab"))
      {
      quicktime_read_ctab(file, &(table->ctab));
      table->has_ctab = 1;
      }
    else
      if(quicktime_atom_is(&leaf_atom, "gama"))
        {
        quicktime_read_gama(file, &(table->gama));
        table->has_gama = 1;
        }
      else
        if(quicktime_atom_is(&leaf_atom, "fiel"))
          {
          quicktime_read_fiel(file, &(table->fiel));
          table->has_fiel = 1;
          }
        else
          if (quicktime_atom_is(&leaf_atom, "pasp"))
            {
            quicktime_read_pasp(file, &(table->pasp));
            table->has_pasp = 1;
            }
          else
            if (quicktime_atom_is(&leaf_atom, "clap"))
              {
              quicktime_read_clap(file, &(table->clap));
              table->has_clap = 1;
              }
            else
              if (quicktime_atom_is(&leaf_atom, "colr"))
		{
                quicktime_read_colr(file, &(table->colr));
                table->has_colr = 1;
		}
              else
		if (quicktime_atom_is(&leaf_atom, "esds"))
                  {
                  // printf("esds: %"PRId64" bytes\n", leaf_atom.size);
                  quicktime_read_esds(file, &(table->esds));
                  table->has_esds = 1;
                  quicktime_atom_skip(file, &leaf_atom);
                  }
		else
                  {
                  quicktime_user_atoms_read_atom(file,
                                                 &table->user_atoms,
                                                 &leaf_atom);
                  }
    quicktime_atom_skip(file, &leaf_atom);
    }
  }


void quicktime_write_stsd_video(quicktime_t *file, quicktime_stsd_table_t *table)
  {
  int compressor_name_len, i;
  compressor_name_len = strlen(table->compressor_name);
  if(file->file_type & (LQT_FILE_QT|LQT_FILE_QT_OLD))
    {
    quicktime_write_int16(file, table->version);
    quicktime_write_int16(file, table->revision);
    quicktime_write_data(file, (uint8_t*)table->vendor, 4);
    quicktime_write_int32(file, table->temporal_quality);
    quicktime_write_int32(file, table->spatial_quality);
    quicktime_write_int16(file, table->width);
    quicktime_write_int16(file, table->height);
    quicktime_write_fixed32(file, table->dpi_horizontal);
    quicktime_write_fixed32(file, table->dpi_vertical);
    quicktime_write_int32(file, table->data_size);
    quicktime_write_int16(file, table->frames_per_sample);
    quicktime_write_char(file, compressor_name_len);
    quicktime_write_data(file, (uint8_t*)table->compressor_name, 31);
    quicktime_write_int16(file, table->depth);
    quicktime_write_int16(file, table->ctab_id);

    if (table->has_pasp)
      quicktime_write_pasp(file, &(table->pasp));
    if (table->has_clap)
      quicktime_write_clap(file, &(table->clap));
    if (table->has_colr)
      quicktime_write_colr(file, &(table->colr));
    if (table->has_fiel)
      quicktime_write_fiel(file, &(table->fiel));
    if (table->has_gama)
      quicktime_write_gama(file, &(table->gama));
    }
  else /* Different stsd formats for mp4 variants */
    {
    quicktime_write_int16(file, 0);
    quicktime_write_int16(file, 0);