lqt.h

Go to the documentation of this file.

/*******************************************************************************
 lqt.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-2011 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
*******************************************************************************/

#ifndef _LQT_H_
#define _LQT_H_

#include "quicktime.h"
#include "lqt_atoms.h"
#include "compression.h"
#include "lqt_codecinfo.h"
#include "lqt_qtvr.h"

#pragma GCC visibility push(default)


#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */

void *lqt_bufalloc(size_t size);


  
void lqt_set_log_callback(lqt_log_callback_t cb, void * data);
                           
  
int lqt_fileno(quicktime_t *file);

void lqt_set_audio_parameter(quicktime_t *file,int track, const char *key,const void *value);

void lqt_set_video_parameter(quicktime_t *file,int track, const char *key,const void *value);

int lqt_get_pixel_aspect(quicktime_t *file, int track, int * pixel_width,
                         int * pixel_height);

int lqt_set_pixel_aspect(quicktime_t *file, int track, int pixel_width,
                         int pixel_height);

lqt_interlace_mode_t lqt_get_interlace_mode(quicktime_t * file, int track);

int lqt_set_interlace_mode(quicktime_t * file, int track,
                           lqt_interlace_mode_t mode);

  
const char * lqt_interlace_mode_to_string(lqt_interlace_mode_t mode);

lqt_chroma_placement_t lqt_get_chroma_placement(quicktime_t * file, int track);

const char * lqt_chroma_placement_to_string(lqt_chroma_placement_t chroma_placement);

int lqt_get_codec_api_version();

const char * lqt_channel_to_string(lqt_channel_t ch);

void lqt_set_channel_setup(quicktime_t * file, int track, lqt_channel_t * ch);

const lqt_channel_t * lqt_get_channel_setup(quicktime_t * file, int track);


int lqt_add_text_track(quicktime_t * file, int timescale);

void lqt_set_text_language(quicktime_t * file, int track, const char * language);

void lqt_set_chapter_track(quicktime_t * file, int track);

void lqt_set_text_box(quicktime_t * file, int track,
                      uint16_t top, uint16_t left,
                      uint16_t bottom, uint16_t right);

void lqt_set_text_fg_color(quicktime_t * file, int track,
                           uint16_t r, uint16_t g,
                           uint16_t b, uint16_t a);

void lqt_set_text_bg_color(quicktime_t * file, int track,
                           uint16_t r, uint16_t g,
                           uint16_t b, uint16_t a);

  
  
  
int lqt_write_text(quicktime_t * file, int track, const char * text, int64_t duration);
  
int lqt_text_tracks(quicktime_t * file);

int lqt_get_text_language(quicktime_t * file, int track, char * language);

int lqt_text_time_scale(quicktime_t * file, int track);

void lqt_get_text_box(quicktime_t * file, int track,
                      uint16_t * top, uint16_t * left,
                      uint16_t * bottom, uint16_t * right);

  
int lqt_read_text(quicktime_t * file, int track, char ** text, int * text_alloc,
                  int64_t * timestamp, int64_t * duration);

int lqt_is_chapter_track(quicktime_t * file, int track);

int64_t lqt_text_samples(quicktime_t * file, int track);

void lqt_set_text_position(quicktime_t * file, int track, int64_t position);

void lqt_set_text_time(quicktime_t * file, int track, int64_t time);

void lqt_get_text_fg_color(quicktime_t * file, int track,
                           uint16_t * r, uint16_t * g,
                           uint16_t * b, uint16_t * a);

void lqt_get_text_bg_color(quicktime_t * file, int track,
                           uint16_t * r, uint16_t * g,
                           uint16_t * b, uint16_t * a);

#define LQT_TIMECODE_DROP    0x0001 //!< Indicates whether the timecode is drop frame
#define LQT_TIMECODE_24HMAX  0x0002 //!< Indicates whether the timecode wraps after 24 hours
#define LQT_TIMECODE_NEG_OK  0x0004 //!< Indicates whether negative time values are allowed
#define LQT_TIMECODE_COUNTER 0x0008 //!< Indicates whether the time value corresponds to a tape counter value

void lqt_add_timecode_track(quicktime_t * file, int track,
                            uint32_t flags, int framerate);

void lqt_write_timecode(quicktime_t * file, int track,
                        uint32_t timecode);

int lqt_has_timecode_track(quicktime_t * file, int track,
                           uint32_t * flags, int * framerate);

int lqt_read_timecode(quicktime_t * file, int track,
                      uint32_t * timecode);

const char * lqt_get_timecode_tape_name(quicktime_t * file, int track);

void lqt_set_timecode_tape_name(quicktime_t * file, int track,
                                const char * tapename);

int lqt_get_timecode_track_enabled(quicktime_t * file, int track);

void lqt_set_timecode_track_enabled(quicktime_t * file, int track,
                                    int enabled);

/***********************************************
 * Advanced colormodel handling.
 * (defined in lqt_color.c)
 ***********************************************/

#define LQT_COLORMODEL_NONE -1
  
/* Colormodel <-> string conversion (used by registry file routines) */

const char * lqt_colormodel_to_string(int colormodel);

int lqt_string_to_colormodel(const char * str);

/* Query information about the colormodel */

int lqt_colormodel_is_planar(int colormodel);

int lqt_colormodel_has_alpha(int colormodel);

int lqt_colormodel_is_rgb(int colormodel);

int lqt_colormodel_is_yuv(int colormodel);

void lqt_colormodel_get_chroma_sub(int colormodel, int * sub_h, int * sub_v);

void lqt_get_default_rowspan(int colormodel, int width, int * rowspan, int * rowspan_uv);

int lqt_colormodel_has_conversion(int in_cmodel, int out_cmodel);
  
/* Query supported colormodels */

int lqt_num_colormodels();

const char * lqt_get_colormodel_string(int index);

int lqt_get_colormodel(int index);

int lqt_get_decoder_colormodel(quicktime_t * file, int track);

int lqt_get_best_source_colormodel(int const* source_options, int target);

int lqt_get_best_target_colormodel(int source, int const* target_options);

int lqt_get_best_colormodel(quicktime_t * file, int track, int * supported);

int lqt_get_cmodel(quicktime_t * file, int track);
  
uint8_t ** lqt_rows_alloc(int width, int height, int colormodel, int * rowspan, int * rowspan_uv);

void lqt_rows_copy(uint8_t **out_rows, uint8_t **in_rows, int width, int height, int in_rowspan, int in_rowspan_uv,
                   int out_rowspan, int out_rowspan_uv, int colormodel);
  
void lqt_rows_copy_sub(uint8_t **out_rows, uint8_t **in_rows,
                       int width, int height, int in_rowspan,
                       int in_rowspan_uv, int out_rowspan,
                       int out_rowspan_uv, int colormodel, int src_x, int src_y, int dst_x, int dst_y);
  
void lqt_rows_clear(uint8_t **rows,
                    int width, int height, int rowspan, int rowspan_uv, int colormodel);

  
void lqt_rows_free(uint8_t ** rows);
  

/**************************************
 * Set streams for encoding
 **************************************/

int lqt_set_audio(quicktime_t *file, int channels,
                  long sample_rate,  int bits,
                  lqt_codec_info_t * codec_info);

  
int lqt_set_video(quicktime_t *file, int tracks, 
                  int frame_w, int frame_h,
                  int frame_duration, int timescale,
                  lqt_codec_info_t * codec_info);

 
int lqt_add_audio_track(quicktime_t *file,
                        int channels, long sample_rate, int bits,
                        lqt_codec_info_t * codec_info);

int lqt_set_audio_codec(quicktime_t *file, int track,
                        lqt_codec_info_t * info);

  
void lqt_set_audio_language(quicktime_t * file, int track, const char * language);
  
int lqt_add_video_track(quicktime_t *file,
                        int frame_w, int frame_h,
                        int frame_duration, int timescale,
                        lqt_codec_info_t * codec_info);

int lqt_set_video_codec(quicktime_t *file, int track,
                        lqt_codec_info_t * info);

  
int lqt_set_video_pass(quicktime_t *file,
                       int pass, int total_passes, 
                       const char * stats_file, int track);

int64_t lqt_get_frame_time(quicktime_t * file, int track, int frame);

int64_t lqt_frame_time(quicktime_t * file, int track);

int lqt_decode_video(quicktime_t *file,
                     unsigned char **row_pointers, int track);

int lqt_read_video_frame(quicktime_t * file,
                         uint8_t ** buffer, int * buffer_alloc,
                         int64_t frame, int64_t * time, int track);
  
int lqt_encode_video(quicktime_t *file, 
                     unsigned char **row_pointers, 
                     int track, int64_t time);

int lqt_encode_video_d(quicktime_t *file, 
                       unsigned char **row_pointers, 
                       int track, int64_t time, int duration);
  
int lqt_frame_duration(quicktime_t * file, int track, int *constant);
  
int lqt_video_time_scale(quicktime_t * file, int track);

int64_t lqt_video_duration(quicktime_t * file, int track);

void lqt_set_cmodel(quicktime_t *file, int track, int colormodel);

long lqt_video_edit_list_total_entries(quicktime_t * file, int track);

long lqt_video_edit_duration(quicktime_t * file, int track, int entry_index);

long lqt_video_edit_time(quicktime_t * file, int track, int entry_index);

float lqt_video_edit_rate(quicktime_t * file, int track, int entry_index);

void lqt_set_row_span(quicktime_t *file, int track, int row_span);

void lqt_set_row_span_uv(quicktime_t *file, int track, int row_span_uv);
  
int lqt_decode_audio(quicktime_t *file, 
                     int16_t **output_i, 
                     float **output_f, 
                     long samples);
  
int64_t lqt_last_audio_position(quicktime_t * file, int track);
  
int lqt_encode_audio_track(quicktime_t *file, 
                           int16_t **output_i, 
                           float **output_f, 
                           long samples,
                           int track);
  
int lqt_decode_audio_track(quicktime_t *file, 
                           int16_t **output_i, 
                           float **output_f, 
                           long samples,
                           int track);

/*
 *  Support for "raw" audio en-/decoding: This bypasses all
 *  internal sampleformat conversions, and allows access to audio
 *  samples in a format, which is closest to the internal representation.
 */
  
/*
 *  Query the internal sample format. Works for decoding (call after quicktime_open)
 *  and encoding (call after lqt_add_audio_track, lqt_set_audio or quicktime_set_audio).
 */

const char * lqt_sample_format_to_string(lqt_sample_format_t sampleformat);

lqt_sample_format_t lqt_get_sample_format(quicktime_t * file, int track);

/* The following return the actual number of en-/decoded frames */

int lqt_decode_audio_raw(quicktime_t *file, 
                         void * output, 
                         long samples,
                         int track);

int lqt_get_audio_language(quicktime_t * file, int track, char * language);

  
int lqt_encode_audio_raw(quicktime_t *file, 
                         void * input, 
                         long samples,
                         int track);

void lqt_seek_video(quicktime_t * file, int track,
                    int64_t time);
  
long lqt_audio_edit_list_total_entries(quicktime_t * file, int track);

long lqt_audio_edit_duration(quicktime_t * file, int track, int entry_index);

long lqt_audio_edit_time(quicktime_t * file, int track, int entry_index);

float lqt_audio_edit_rate(quicktime_t * file, int track, int entry_index);

/*
 *  AVI Specific stuff
 */

int lqt_is_avi(quicktime_t *file);

int lqt_get_wav_id(quicktime_t *file, int track);
  
int lqt_total_channels(quicktime_t *file);

/* Extended metadata support */

void lqt_set_album(quicktime_t *file, char *string);

void lqt_set_artist(quicktime_t *file, char *string);

void lqt_set_genre(quicktime_t *file, char *string);

void lqt_set_track(quicktime_t *file, char *string);

void lqt_set_comment(quicktime_t *file, char *string);

void lqt_set_author(quicktime_t *file, char *string);

void lqt_set_creation_time(quicktime_t *file, unsigned long time);

  
char * lqt_get_album(quicktime_t * file);
  
char * lqt_get_artist(quicktime_t * file);

char * lqt_get_genre(quicktime_t * file);

char * lqt_get_track(quicktime_t * file);

char * lqt_get_comment(quicktime_t *file);

char * lqt_get_author(quicktime_t *file);

unsigned long lqt_get_creation_time(quicktime_t * file);
  
/* get track number from track id */
int lqt_track_from_id(quicktime_t *file, int track_id);

const char * lqt_file_type_to_string(lqt_file_type_t type);

lqt_file_type_t lqt_get_file_type(quicktime_t * file);
 
  
quicktime_t * lqt_open_read(const char * filename);

  quicktime_t * lqt_open_read_with_log(const char * filename, lqt_log_callback_t cb, void * log_data);
  
quicktime_t * lqt_open_write(const char * filename, lqt_file_type_t type);

quicktime_t * lqt_open_write_with_log(const char * filename, lqt_file_type_t type,
                                      lqt_log_callback_t cb, void * log_data);
  
void lqt_set_max_riff_size(quicktime_t * file, int size);


void lqt_set_audio_pts_offset(quicktime_t * file, int track, int64_t offset);
  
int64_t lqt_get_audio_pts_offset(quicktime_t * file, int track);

void lqt_set_video_pts_offset(quicktime_t * file, int track, int64_t offset);
  
int64_t lqt_get_video_pts_offset(quicktime_t * file, int track);

void lqt_set_text_pts_offset(quicktime_t * file, int track, int64_t offset);
  
int64_t lqt_get_text_pts_offset(quicktime_t * file, int track);
  
#ifdef __cplusplus
}
#endif /* __cplusplus */

#pragma GCC visibility pop
  
#endif