lqt_funcprotos.h

这个库实现了录象功能

/*******************************************************************************
 lqt_funcprotos.h

 libquicktime - A library for reading and writing quicktime/avi/mp4 files.
 http://libquicktime.sourceforge.net

 Copyright (C) 2002 Heroine Virtual Ltd.
 Copyright (C) 2002-2007 Members of the libquicktime project.

 This library is free software; you can redistribute it and/or modify it under
 the terms of the GNU Lesser General Public License as published by the Free
 Software Foundation; either version 2.1 of the License, or (at your option)
 any later version.

 This library is distributed in the hope that it will be useful, but WITHOUT
 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
 details.

 You should have received a copy of the GNU Lesser General Public License along
 with this library; if not, write to the Free Software Foundation, Inc., 51
 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*******************************************************************************/
#include <config.h>
#include <quicktime/lqt.h>
#include <quicktime/qtprivate.h>

#ifdef HAVE_GCC_VISIBILITY
#define LQT_EXTERN __attribute__ ((visibility("default")))
#else
#define LQT_EXTERN extern
#endif

/* Some macros */

#define IS_QUICKTIME(type) (type & (LQT_FILE_QT_OLD | LQT_FILE_QT))
#define IS_MP4(type) (type & (LQT_FILE_MP4 | LQT_FILE_M4A | LQT_FILE_3GP))
#define IS_AVI(type) (type & (LQT_FILE_AVI | LQT_FILE_AVI_ODML))

/* atom.c */

int quicktime_atom_read_header(quicktime_t *file, quicktime_atom_t *atom);
int quicktime_atom_write_header64(quicktime_t *file, quicktime_atom_t *atom, char *text);
int quicktime_atom_write_header(quicktime_t *file, quicktime_atom_t *atom, char *text);
void quicktime_atom_write_footer(quicktime_t *file, quicktime_atom_t *atom);
int quicktime_atom_is(quicktime_atom_t *atom, char *type);
int quicktime_atom_skip(quicktime_t *file, quicktime_atom_t *atom);

/* audio.c */

void lqt_convert_audio_encode(quicktime_t * file, int16_t ** in_int, float ** in_float,
                              void * out, int num_channels, int num_samples,
                              lqt_sample_format_t stream_format);

void lqt_convert_audio_decode(quicktime_t * file, void * in, int16_t ** out_int,
                              float ** out_float, int num_channels, int num_samples,
                              lqt_sample_format_t stream_format);
 

/* avi_avih.c */

void quicktime_read_avih(quicktime_t *file,
                         quicktime_avih_t *avih,
                         quicktime_atom_t *parent_atom);

void quicktime_write_avih(quicktime_t *file,
                          quicktime_avih_t *avih);

void quicktime_avih_dump(quicktime_avih_t *avih);

void quicktime_avih_init(quicktime_avih_t *avih, quicktime_t * file);

/* avi_guid.c */

void quicktime_GUID_dump(quicktime_GUID_t * g);
int  quicktime_GUID_equal(const quicktime_GUID_t * g1, const quicktime_GUID_t * g2);
void quicktime_GUID_read(quicktime_t * file, quicktime_GUID_t * guid);
void quicktime_GUID_write(quicktime_t * file, quicktime_GUID_t * guid);

/* avi_hdrl.c */

void quicktime_read_hdrl(quicktime_t *file, 
                         quicktime_hdrl_t *hdrl,
                         quicktime_atom_t *parent_atom);

void quicktime_write_hdrl(quicktime_t *file);

void quicktime_finalize_hdrl(quicktime_t *file, quicktime_hdrl_t *hdrl);
void quicktime_delete_hdrl(quicktime_t *file, quicktime_hdrl_t *hdrl);
void quicktime_init_hdrl(quicktime_t *file, quicktime_hdrl_t *hdrl);

/* avi_idx1.c */

void quicktime_read_idx1(quicktime_t *file,
                         quicktime_riff_t *riff,
                         quicktime_atom_t *parent_atom);

void quicktime_delete_idx1(quicktime_idx1_t *idx1);

void quicktime_write_idx1(quicktime_t *file,
                          quicktime_idx1_t *idx1);
void quicktime_set_idx1_keyframe(quicktime_t *file,
                                 quicktime_trak_t *trak,
                                 int new_keyframe);

void quicktime_update_idx1table(quicktime_t *file,
                                quicktime_trak_t *trak,
                                int offset,
                                int size);

void quicktime_idx1_dump(quicktime_idx1_t *idx1);


/* avi_indx.c */

void quicktime_finalize_indx(quicktime_t *file, quicktime_indx_t *indx);

void quicktime_delete_indx(quicktime_indx_t *indx);
void quicktime_init_indx(quicktime_t *file,
                         quicktime_indx_t *indx,
                         quicktime_strl_t *strl);

void quicktime_read_indx(quicktime_t *file,
                         quicktime_strl_t *strl,
                         quicktime_atom_t *parent_atom);

void quicktime_indx_dump(quicktime_indx_t *);


void quicktime_indx_init_riff(quicktime_t *file, quicktime_trak_t * trak);
void quicktime_indx_finalize_riff(quicktime_t *file, quicktime_trak_t * trak);

void quicktime_set_indx_keyframe(quicktime_t *file, quicktime_trak_t * trak,
                                 long frame);

/* avi_info.c */

void quicktime_read_riffinfo(quicktime_t *file,
                             quicktime_riffinfo_t *info,
                             quicktime_atom_t *parent_atom);

void quicktime_write_riffinfo(quicktime_t *file,
                              quicktime_riffinfo_t *info);

void quicktime_riffinfo_2_udta(quicktime_riffinfo_t * riffinfo,
                               quicktime_udta_t * udta);
void quicktime_udta_2_riffinfo(quicktime_udta_t * udta,
                               quicktime_riffinfo_t * riffinfo);
void quicktime_delete_riffinfo(quicktime_riffinfo_t * riffinfo);
void quicktime_init_riffinfo(quicktime_riffinfo_t * riffinfo);


/* avi_ix.c */

quicktime_ix_t* quicktime_new_ix(quicktime_t *file,
                                 quicktime_trak_t *trak,
                                 quicktime_strl_t *strl);
void quicktime_delete_ix(quicktime_ix_t *ix);
void quicktime_update_ixtable(quicktime_t *file,
                              quicktime_trak_t *trak,
                              int64_t offset,
                              int size);
void quicktime_write_ix(quicktime_t *file, quicktime_trak_t *trak);

void quicktime_read_ix(quicktime_t *file,
                       quicktime_ix_t *ix);

void quicktime_ix_dump(quicktime_ix_t *ix);



/* avi_movi.c */

void quicktime_read_movi(quicktime_t *file, 
                         quicktime_atom_t *parent_atom,
                         quicktime_movi_t *movi);
void quicktime_write_movi(quicktime_t *file);
void quicktime_delete_movi(quicktime_t *file, quicktime_movi_t *movi);
void quicktime_init_movi(quicktime_t *file, quicktime_riff_t *riff);
void quicktime_finalize_movi(quicktime_t *file, quicktime_movi_t *movi);

/* avi_odml.c */

void quicktime_finalize_odml(quicktime_t *file, quicktime_hdrl_t *hdrl);
void quicktime_init_odml(quicktime_t *file, quicktime_hdrl_t *hdrl);

/* avi_riff.c */

void quicktime_read_riff(quicktime_t *file, quicktime_atom_t *parent_atom);
void quicktime_delete_riff(quicktime_t *file, quicktime_riff_t *riff);
int quicktime_import_avi(quicktime_t *file);
void quicktime_init_riff(quicktime_t *file);
void quicktime_finalize_riff(quicktime_t *file, quicktime_riff_t *riff);
quicktime_riff_t* quicktime_new_riff(quicktime_t *file);

void quicktime_riff_dump(quicktime_riff_t * riff);

/* avi_strf.c */

void quicktime_read_strf_audio(quicktime_t *file,
                               quicktime_strf_t *strf,
                               quicktime_atom_t *parent_atom);

void quicktime_write_strf_audio(quicktime_t *file,
                                quicktime_strf_t *strf);

void quicktime_strf_dump_audio(quicktime_strf_t *strf);

void quicktime_read_strf_video(quicktime_t *file,
                               quicktime_strf_t *strf,
                               quicktime_atom_t *parent_atom);

void quicktime_write_strf_video(quicktime_t *file,
                                quicktime_strf_t *strf);

void quicktime_strf_dump_video(quicktime_strf_t *strf);

void quicktime_strf_set_video_extradata(quicktime_strf_t *strf, const uint8_t * data, int len);
void quicktime_strf_delete_video(quicktime_strf_t *strf);

LQT_EXTERN void quicktime_strf_set_audio_extradata(quicktime_strf_t *strf, const uint8_t * data, int len);
void quicktime_strf_delete_audio(quicktime_strf_t *strf);



/* avi_strh.c */

void quicktime_read_strh(quicktime_t *file,
                         quicktime_strh_t *strh,
                         quicktime_atom_t *parent_atom);

void quicktime_write_strh(quicktime_t *file,
                          quicktime_strh_t *strh);

void quicktime_strh_dump(quicktime_strh_t *strh);


/* avi_strl.c */

void quicktime_delete_strl(quicktime_strl_t *strl);
quicktime_strl_t* quicktime_new_strl();

void quicktime_read_strl(quicktime_t *file,
                         quicktime_strl_t *strl,
                         quicktime_atom_t *parent_atom);

void quicktime_strl_dump(quicktime_strl_t *strl);

/* Convert an strl to a trak */
void quicktime_strl_2_qt(quicktime_t *file,
                         quicktime_strl_t *strl);


void quicktime_init_strl(quicktime_t *file,
                         quicktime_audio_map_t *atrack,
                         quicktime_video_map_t *vtrack,
                         quicktime_trak_t *trak,
                         quicktime_strl_t *strl);

void
quicktime_finalize_strl(quicktime_t *file, quicktime_trak_t * trak,
                        quicktime_strl_t *strl);



/* chan.c */

void quicktime_chan_init(quicktime_chan_t *chan);
void quicktime_chan_delete(quicktime_chan_t *chan);
void quicktime_chan_dump(quicktime_chan_t *chan);
void quicktime_read_chan(quicktime_t *file, quicktime_chan_t *chan);
void quicktime_write_chan(quicktime_t *file, quicktime_chan_t *chan);

/* Update an atrack from a chan atom */
void quicktime_get_chan(quicktime_audio_map_t * atrack);

/* Set the chan atom of an atrack */
LQT_EXTERN void quicktime_set_chan(quicktime_audio_map_t * atrack);

/* clap.c */

void quicktime_clap_init(quicktime_clap_t *clap);
void quicktime_clap_delete(quicktime_clap_t *clap);
void quicktime_clap_dump(quicktime_clap_t *clap);
void quicktime_read_clap(quicktime_t *file, quicktime_clap_t *clap);
void quicktime_write_clap(quicktime_t *file, quicktime_clap_t *clap);

// ******************************** Permutation *******************************

#define PERMUTATION_ARGS \
	unsigned char **output_rows,  \
	unsigned char **input_rows, \
	int in_x,  \
	int in_y,  \
	int in_w,  \
	int in_h, \
	int out_w,  \
	int out_h, \
	int in_colormodel,  \
	int out_colormodel, \
	int in_rowspan, \
	int out_rowspan, \
	int in_rowspan_uv, \
	int out_rowspan_uv, \
	int scale, \
	int out_pixelsize, \
	int in_pixelsize, \
	int *row_table, \
	int *column_table



/* cmodel_default.c */

void cmodel_yuv420p(PERMUTATION_ARGS);
void cmodel_yuv422p(PERMUTATION_ARGS);
void cmodel_yuv411p(PERMUTATION_ARGS);
void cmodel_yuv444p(PERMUTATION_ARGS);
void cmodel_yuv422(PERMUTATION_ARGS);
void cmodel_default(PERMUTATION_ARGS);

/* colr.c */

void quicktime_colr_init(quicktime_colr_t *colr);
void quicktime_colr_delete(quicktime_colr_t *colr);
void quicktime_colr_dump(quicktime_colr_t *colr);
void quicktime_read_colr(quicktime_t *file, quicktime_colr_t *colr);
void quicktime_write_colr(quicktime_t *file, quicktime_colr_t *colr);

/* ctab.c */

int quicktime_ctab_init(quicktime_ctab_t *ctab);
int quicktime_ctab_delete(quicktime_ctab_t *ctab);
void quicktime_ctab_dump(quicktime_ctab_t *ctab);
int quicktime_read_ctab(quicktime_t *file, quicktime_ctab_t *ctab);
void quicktime_default_ctab(quicktime_ctab_t *ctab, int depth);

/* ctts.c */

void quicktime_ctts_init(quicktime_ctts_t *ctts);
void quicktime_ctts_delete(quicktime_ctts_t *ctts);
void quicktime_ctts_dump(quicktime_ctts_t *ctts);
void quicktime_read_ctts(quicktime_t *file, quicktime_ctts_t *ctts);
void quicktime_write_ctts(quicktime_t *file, quicktime_ctts_t *ctts);
void quicktime_update_ctts(quicktime_ctts_t *ctts, long sample, long duration);
void quicktime_compress_ctts(quicktime_ctts_t *ctts);
void quicktime_fix_ctts(quicktime_ctts_t *ctts);

/* dinf.c */

void quicktime_dinf_init(quicktime_dinf_t *dinf);
void quicktime_dinf_delete(quicktime_dinf_t *dinf);
void quicktime_dinf_init_all(quicktime_dinf_t *dinf, lqt_file_type_t type);
void quicktime_dinf_dump(quicktime_dinf_t *dinf);
void quicktime_read_dinf(quicktime_t *file, quicktime_dinf_t *dinf, quicktime_atom_t *dinf_atom);
void quicktime_write_dinf(quicktime_t *file, quicktime_dinf_t *dinf);

/* dref.c */

void quicktime_dref_table_init(quicktime_dref_table_t *table, lqt_file_type_t type);