qtprivate.h

这个库实现了录象功能

	long sample_count;
	long sample_duration;
} quicktime_stts_table_t;

typedef struct
{
	int version;
	long flags;
	long total_entries;
        long entries_allocated;
        int  default_duration;
	quicktime_stts_table_t *table;
} quicktime_stts_t;

/* Composition time to sample */

typedef struct
{
	long sample_count;
	long sample_duration;
} quicktime_ctts_table_t;

typedef struct
{
	int version;
	long flags;
	long total_entries;
        long entries_allocated;
	quicktime_ctts_table_t *table;
} quicktime_ctts_t;

/* sync sample */
typedef struct
{
	long sample;
} quicktime_stss_table_t;

typedef struct
{
	int version;
	long flags;
	long total_entries;
	long entries_allocated;
	quicktime_stss_table_t *table;
} quicktime_stss_t;


/* sample to chunk */
typedef struct
{
	long chunk;
	long samples;
	long id;
} quicktime_stsc_table_t;

typedef struct
{
	int version;
	long flags;
	long total_entries;
	
	long entries_allocated;
	quicktime_stsc_table_t *table;
} quicktime_stsc_t;


/* sample size */
typedef struct
{
	int64_t size;
} quicktime_stsz_table_t;

typedef struct
{
	int version;
	long flags;
	int64_t sample_size;
long total_entries;

	long entries_allocated;    /* used by the library for allocating a table */
	quicktime_stsz_table_t *table;
} quicktime_stsz_t;


/* chunk offset */
typedef struct
{
	int64_t offset;
} quicktime_stco_table_t;

typedef struct
{
	int version;
	long flags;
	long total_entries;
	
	long entries_allocated;    /* used by the library for allocating a table */
	quicktime_stco_table_t *table;
        int co64;
} quicktime_stco_t;


/* sample table */
typedef struct
{
	int version;
	long flags;
	quicktime_stsd_t stsd;
	quicktime_stts_t stts;
	quicktime_stss_t stss;
	quicktime_stsc_t stsc;
	quicktime_stsz_t stsz;
	quicktime_stco_t stco;
	quicktime_ctts_t ctts;
        int has_ctts;
  } quicktime_stbl_t;

typedef struct
  {
  char type[4];
  int num_tracks;
  uint32_t * tracks;
  } quicktime_track_reference_t;

typedef struct
  {
  int num_references;
  quicktime_track_reference_t * references;
  } quicktime_tref_t;

/* data reference */

typedef struct
{
	int64_t size;
	char type[4];
	int version;
	long flags;
	char *data_reference;
} quicktime_dref_table_t;

typedef struct
{
	int version;
	long flags;
	long total_entries;
	quicktime_dref_table_t *table;
} quicktime_dref_t;

/* data information */

typedef struct
{
	quicktime_dref_t dref;
} quicktime_dinf_t;

/* video media header */

typedef struct
{
	int version;
	long flags;
	int graphics_mode;
	int opcolor[3];
} quicktime_vmhd_t;


/* sound media header */

typedef struct
{
	int version;
	long flags;
	int balance;
	int reserved;
} quicktime_smhd_t;


/* Base media info */

typedef struct
{
	int version;
	long flags;
	int graphics_mode;
	int opcolor[3];
	int balance;
	int reserved;
} quicktime_gmin_t;

/* Obscure text atom found inside the gmhd atom
 * of text tracks
 * TODO: Reverse engineer this
 */

typedef struct
  {
  uint32_t unk[9];
  } quicktime_gmhd_text_t;

typedef struct
  {
  int version;
  long flags;
  int font;
  int face;
  int size;
  int txtcolor[3];
  int bgcolor[3];
  char fontname[256];
  } quicktime_tcmi_t;

typedef struct
  {
  quicktime_tcmi_t tcmi;
  } quicktime_tmcd_t;

/* Base (generic) media header */

typedef struct
  {
  quicktime_gmin_t gmin;

  int has_gmhd_text;
  quicktime_gmhd_text_t gmhd_text;
  
  int has_tmcd;
  quicktime_tmcd_t tmcd;
  
  } quicktime_gmhd_t;

typedef struct
{
	int version;
	long flags;
} quicktime_nmhd_t;

/* handler reference */

typedef struct
{
	int version;
	long flags;
	char component_type[4];
	char component_subtype[4];
        char component_manufacturer[4];
	long component_flags;
	long component_flag_mask;
	char component_name[256];
} quicktime_hdlr_t;

/* media information */

typedef struct
{
	int is_video;
	int is_audio;
        int is_audio_vbr;   /* Special flag indicating VBR audio */
	int is_panorama;
	int is_qtvr;
	int is_object;
        int is_text;
        int is_timecode;
	quicktime_vmhd_t vmhd;
	quicktime_smhd_t smhd;
	quicktime_gmhd_t gmhd;
	int has_gmhd;

        quicktime_nmhd_t nmhd;
	int has_nmhd;

        quicktime_stbl_t stbl;
	quicktime_hdlr_t hdlr;
        int has_hdlr;

        quicktime_dinf_t dinf;
} quicktime_minf_t;


/* media header */

typedef struct
{
	int version;
	long flags;
	unsigned long creation_time;
	unsigned long modification_time;
	long time_scale;
	long duration;
	int language;
	int quality;
} quicktime_mdhd_t;


/* media */

typedef struct
{
	quicktime_mdhd_t mdhd;
	quicktime_minf_t minf;
	quicktime_hdlr_t hdlr;
} quicktime_mdia_t;

/* edit list */
typedef struct
{
	long duration;
	long time;
	float rate;
} quicktime_elst_table_t;

typedef struct
{
	int version;
	long flags;
	long total_entries;

	quicktime_elst_table_t *table;
} quicktime_elst_t;

typedef struct
{
	quicktime_elst_t elst;
} quicktime_edts_t;

/* qtvr navg (v1.0) */
typedef struct {
    int    version;        // Always 1
    int    columns;    // Number of columns in movie
    int    rows;        // Number rows in movie
    int    reserved;        // Zero
    int    loop_frames;        // Number of frames shot at each position
    int    loop_dur;        // The duration of each frame
    int    movietype;        // kStandardObject, kObjectInScene, or
                    // kOldNavigableMovieScene
    int    loop_timescale;        // Number of ticks before next frame of
                    // loop is displayed
    float    fieldofview;        // 180.0 for kStandardObject or
                    // kObjectInScene, actual  degrees for
                    // kOldNavigableMovieScene.
    float    startHPan;        // Start horizontal pan angle in
                    //  degrees
    float    endHPan;        // End horizontal pan angle in  degrees
    float    endVPan;        // End vertical pan angle in  degrees
    float    startVPan;        // Start vertical pan angle in  degrees
    float    initialHPan;        // Initial horizontal pan angle in
                    //  degrees (poster view)
    float    initialVPan;        // Initial vertical pan angle in  degrees
                    // (poster view)
    long    reserved2;        // Zero
} quicktime_navg_t;


typedef struct
  {
  quicktime_tkhd_t tkhd;
  quicktime_mdia_t mdia;
  quicktime_edts_t edts;
  int has_edts;
  
  quicktime_tref_t tref;
  quicktime_strl_t * strl; // != NULL for AVI files during reading and writing
  int chunk_sizes_alloc;
  int64_t * chunk_sizes; /* This contains the chunk sizes for audio
                            tracks. They can not so easily be obtained
                            during decoding */
  int has_tref;
  } quicktime_trak_t;


typedef struct
{
	int version;
	long flags;
	uint64_t creation_time;
	uint64_t modification_time;
	long time_scale;
	uint64_t duration;
	float preferred_rate;
	float preferred_volume;
	uint8_t reserved[10];
	quicktime_matrix_t matrix;
	long preview_time;
	long preview_duration;
	long poster_time;
	long selection_time;
	long selection_duration;
	long current_time;
	long next_track_id;
} quicktime_mvhd_t;


typedef struct
{
	char *copyright;
	int copyright_len;
	char *name;
	int name_len;
	char *info;
	int info_len;
/* Additional Metadata for libquicktime */
        char *album;
        int album_len;
        char *author;
        int author_len;
        char *artist;
        int artist_len;
        char *genre;
        int genre_len;
        char *track;
        int track_len;
        char *comment;
        int comment_len;
	int is_qtvr;
	/* player controls */
	char ctyp[4];
	quicktime_navg_t navg;
	quicktime_hdlr_t hdlr;
        int has_hdlr;
} quicktime_udta_t;


typedef struct
{
	int total_tracks;

	quicktime_mvhd_t mvhd;
	quicktime_trak_t *trak[MAXTRACKS];
	quicktime_udta_t udta;
        int has_ctab;
	quicktime_ctab_t ctab;
        int has_iods;
        quicktime_iods_t iods;

} quicktime_moov_t;

typedef struct
{
	quicktime_atom_t atom;
} quicktime_mdat_t;

typedef struct
{
/* Offset of end of 8 byte chunk header relative to ix->base_offset */
        int relative_offset;
/* size of data without 8 byte header */
        uint32_t size;
} quicktime_ixtable_t;
                                                                                                                     
typedef struct
{
        quicktime_atom_t atom;
        quicktime_ixtable_t *table;
        int table_size;
        int table_allocation;
        int longs_per_entry;
        int index_type;
/* ixtable relative_offset is relative to this */
        int64_t base_offset;
/* ix atom title */
        char tag[5];
/* corresponding chunk id */
        char chunk_id[5];
} quicktime_ix_t;
typedef struct
{
        quicktime_atom_t atom;
                                                                                                                     
} quicktime_movi_t;
                                                                                                                     
typedef struct
{
/* Start of start of corresponding ix## header */
        int64_t index_offset;
/* Size not including 8 byte header */
        int index_size;
/* duration in "ticks" */
        int duration;
                                                                                                                     
/* Partial index for reading only. */
        quicktime_ix_t *ix;
} quicktime_indxtable_t;

typedef struct
{
        quicktime_atom_t atom;
        int longs_per_entry;
        int index_subtype;
        int index_type;
/* corresponding chunk id: 00wb, 00dc */
        char chunk_id[5];
                                                                                                                     
/* Number of partial indexes here */
        int table_size;
        int table_allocation;
        quicktime_indxtable_t *table;

/* The following are used internally only. They are
   set by quicktime_finalize_strl and used by quicktime_finalize_indx */
  uint32_t offset;
  uint32_t size;
  } quicktime_indx_t;

/* AVI structures */

/* strh */

typedef struct
  {
  char fccType[4];
  char fccHandler[4];
  uint32_t dwFlags;
  uint32_t dwReserved1;
  uint32_t dwInitialFrames;
  uint32_t dwScale;
  uint32_t dwRate;
  uint32_t dwStart;
  uint32_t dwLength;
  uint32_t dwSuggestedBufferSize;
  uint32_t dwQuality;
  uint32_t dwSampleSize;

  struct {
  uint16_t left;
  uint16_t top;
  uint16_t right;
  uint16_t bottom;
  }  rcFrame;
  
  } quicktime_strh_t;

typedef struct
  {
  uint32_t dwMicroSecPerFrame;
  uint32_t dwMaxBytesPerSec;
  uint32_t dwReserved1;
  uint32_t dwFlags;
  uint32_t dwTotalFrames;
  uint32_t dwInitialFrames;
  uint32_t dwStreams;
  uint32_t dwSuggestedBufferSize;
  uint32_t dwWidth;
  uint32_t dwHeight;
  uint32_t dwScale;
  uint32_t dwRate;
  uint32_t dwStart;