quicktime.h

Go to the documentation of this file.

/*******************************************************************************
 quicktime.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 QUICKTIME_H
#define QUICKTIME_H
 
#ifdef __cplusplus
extern "C" {
#endif
 
#include <inttypes.h>
#include <stddef.h>
 
#ifdef __GNUC__
#pragma GCC visibility push(default)
#endif
  
/* Some public enums needed by most subsequent headers */
 
typedef struct lqt_codec_info_s lqt_codec_info_t;
 
  
typedef enum
  {
    LQT_LOG_ERROR   = (1<<0),
    LQT_LOG_WARNING = (1<<1),
    LQT_LOG_INFO    = (1<<2),
    LQT_LOG_DEBUG   = (1<<3),
  } lqt_log_level_t;
 
typedef void (*lqt_log_callback_t)(lqt_log_level_t level,
                                   const char * domain,
                                   const char * message,
                                   void * data);
 
  
typedef enum
  {
    LQT_FILE_NONE = 0,        
    LQT_FILE_QT_OLD   = (1<<0), 
    LQT_FILE_QT       = (1<<1), 
    LQT_FILE_AVI      = (1<<2), 
    LQT_FILE_AVI_ODML = (1<<3), 
    LQT_FILE_MP4      = (1<<4), 
    LQT_FILE_M4A      = (1<<5), 
    LQT_FILE_3GP      = (1<<6), 
  } lqt_file_type_t;
 
  
typedef enum 
  {
    LQT_CHANNEL_UNKNOWN,
    LQT_CHANNEL_FRONT_LEFT,
    LQT_CHANNEL_FRONT_RIGHT,
    LQT_CHANNEL_FRONT_CENTER,
    LQT_CHANNEL_FRONT_CENTER_LEFT,
    LQT_CHANNEL_FRONT_CENTER_RIGHT,
    LQT_CHANNEL_BACK_CENTER,
    LQT_CHANNEL_BACK_LEFT,
    LQT_CHANNEL_BACK_RIGHT,
    LQT_CHANNEL_SIDE_LEFT,
    LQT_CHANNEL_SIDE_RIGHT,
    LQT_CHANNEL_LFE,
  } lqt_channel_t;
 
  
typedef enum 
  {
    LQT_INTERLACE_NONE = 0, 
    LQT_INTERLACE_TOP_FIRST, 
    LQT_INTERLACE_BOTTOM_FIRST  
  } lqt_interlace_mode_t;
 
typedef enum 
  {
    LQT_CHROMA_PLACEMENT_DEFAULT = 0, 
    LQT_CHROMA_PLACEMENT_MPEG2,       
    LQT_CHROMA_PLACEMENT_DVPAL,       
  } lqt_chroma_placement_t;
 
typedef enum 
  {
    LQT_SAMPLE_UNDEFINED = 0, 
    LQT_SAMPLE_INT8,      
    LQT_SAMPLE_UINT8,     
    LQT_SAMPLE_INT16,     
    LQT_SAMPLE_INT32,     
    LQT_SAMPLE_FLOAT,     
    LQT_SAMPLE_DOUBLE,    
  } lqt_sample_format_t;
  
typedef struct quicktime_s quicktime_t;
  
/* This is the reference for all your library entry points. */
 
/* ===== compression formats for which codecs exist ====== */
 
#define QUICKTIME_DIVX "DIVX"
 
#define QUICKTIME_DIV3 "DIV3"
 
#define QUICKTIME_DV "dvc "
/* AVID DV codec can be processed with libdv as well */
 
#define QUICKTIME_DV_AVID "AVdv"
 
#define QUICKTIME_DV_AVID_A "dvcp"
 
/* RGB uncompressed.  Allows alpha */
#define QUICKTIME_RAW  "raw "
 
/* Jpeg Photo */
#define QUICKTIME_JPEG "jpeg"
 
/* Concatenated png images.  Allows alpha */
 
#define QUICKTIME_PNG "png "
 
#define QUICKTIME_MJPA "mjpa"
 
#define QUICKTIME_YUV2 "yuv2"
 
#define QUICKTIME_YUV4 "yuv4"
 
#define QUICKTIME_YUV420  "yv12"
 
#define QUICKTIME_2VUY "2vuy"
 
#define QUICKTIME_YUVS "yuvs"
 
 
#define QUICKTIME_V308  "v308"
 
#define QUICKTIME_V408 "v408"
 
#define QUICKTIME_V210 "v210"
 
#define QUICKTIME_V410 "v410"
 
/* =================== Audio formats ======================= */
 
#define QUICKTIME_RAWAUDIO "raw "
 
#define QUICKTIME_IMA4 "ima4"
 
#define QUICKTIME_TWOS "twos"
 
#define QUICKTIME_ULAW "ulaw"
 
#define QUICKTIME_VORBIS "OggS"
 
#define QUICKTIME_MP3 ".mp3"
  
/* =========================== public interface ========================= // */
 
  /* Get version information */
int quicktime_major();
 
int quicktime_minor();
 
int quicktime_release();
 
int quicktime_check_sig(char *path);
 
quicktime_t* quicktime_open(const char *filename, int rd, int wr);
 
int quicktime_make_streamable(char *in_path, char *out_path);
 
void quicktime_set_copyright(quicktime_t *file, char *string);
 
void quicktime_set_name(quicktime_t *file, char *string);
 
void quicktime_set_info(quicktime_t *file, char *string);
 
char* quicktime_get_copyright(quicktime_t *file);
 
char* quicktime_get_name(quicktime_t *file);
 
char* quicktime_get_info(quicktime_t *file);
 
 
int quicktime_set_audio(quicktime_t *file, 
        int channels, 
        long sample_rate, 
        int bits, 
        char *compressor);
 
void quicktime_set_framerate(quicktime_t *file, double framerate);
 
int quicktime_set_video(quicktime_t *file, 
        int tracks, 
        int frame_w, 
        int frame_h, 
        double frame_rate, 
        char *compressor);
 
void quicktime_set_jpeg(quicktime_t *file, int quality, int use_float);
 
void quicktime_set_parameter(quicktime_t *file, char *key, void *value);
 
void quicktime_set_depth(quicktime_t *file, 
        int depth, 
        int track);
 
void quicktime_set_cmodel(quicktime_t *file, int colormodel);
 
void quicktime_set_row_span(quicktime_t *file, int row_span);
 
int quicktime_close(quicktime_t *file);
 
/* get length information */
/* channel numbers start on 1 for audio and video */
 
long quicktime_audio_length(quicktime_t *file, int track);
 
long quicktime_video_length(quicktime_t *file, int track);
 
  /* get position information */
long quicktime_audio_position(quicktime_t *file, int track);
 
long quicktime_video_position(quicktime_t *file, int track);
 
/* get file information */
int quicktime_video_tracks(quicktime_t *file);
 
int quicktime_audio_tracks(quicktime_t *file);
 
int quicktime_has_audio(quicktime_t *file);
 
long quicktime_sample_rate(quicktime_t *file, int track);
 
int quicktime_audio_bits(quicktime_t *file, int track);
 
int quicktime_track_channels(quicktime_t *file, int track);
 
char* quicktime_audio_compressor(quicktime_t *file, int track);
 
int quicktime_has_video(quicktime_t *file);
 
int quicktime_video_width(quicktime_t *file, int track);
 
int quicktime_video_height(quicktime_t *file, int track);
 
int quicktime_video_depth(quicktime_t *file, int track);
 
double quicktime_frame_rate(quicktime_t *file, int track);
 
char* quicktime_video_compressor(quicktime_t *file, int track);
 
/* number of bytes of raw data in this frame */
 
long quicktime_frame_size(quicktime_t *file, long frame, int track);
 
int quicktime_channel_location(quicktime_t *file, int *quicktime_track, int *quicktime_channel, int channel);
 
/* file positioning */
/* Remove these and see what happens :) */
 
// int quicktime_seek_end(quicktime_t *file);
 
int quicktime_seek_start(quicktime_t *file);
 
/* set position of file descriptor relative to a track */
 
int quicktime_set_audio_position(quicktime_t *file, int64_t sample, int track);
 
int quicktime_set_video_position(quicktime_t *file, int64_t frame, int track);
 
/* ========================== Access to raw data follows. */
/* write data for one quicktime track */
/* the user must handle conversion to the channels in this track */
int quicktime_write_audio(quicktime_t *file, uint8_t *audio_buffer, long samples, int track);
 
int quicktime_write_frame(quicktime_t *file, uint8_t *video_buffer, int64_t bytes, int track);
 
long quicktime_read_frame(quicktime_t *file, unsigned char *video_buffer, int track);
 
/* for reading frame using a library that needs a file descriptor */
/* Frame caching doesn't work here. */
int quicktime_read_frame_init(quicktime_t *file, int track);
int quicktime_read_frame_end(quicktime_t *file, int track);
 
/* One keyframe table for each track */
long quicktime_get_keyframe_before(quicktime_t *file, long frame, int track);
long quicktime_get_partial_keyframe_before(quicktime_t *file, long frame, int track);
void quicktime_insert_keyframe(quicktime_t *file, long frame, int track);
void quicktime_insert_partial_keyframe(quicktime_t *file, long frame, int track);
/* Track has keyframes */
int quicktime_has_keyframes(quicktime_t *file, int track);
 
/* Sample dependencies for long-GOP formats. */
void quicktime_insert_sdtp_entry(quicktime_t *file, long frame, int track, uint8_t flags);
 
/* ===================== Access to built in codecs follows. */
 
/* If the codec for this track is supported in the library return 1. */
 
int quicktime_supported_video(quicktime_t *file, int track);
 
int quicktime_supported_audio(quicktime_t *file, int track);
 
int quicktime_reads_cmodel(quicktime_t *file, 
                int colormodel, 
                int track);
 
int quicktime_writes_cmodel(quicktime_t *file, 
                int colormodel, 
                int track);
 
 
/* Hacks for temporal codec */
int quicktime_divx_is_key(unsigned char *data, long size);
int quicktime_divx_write_vol(unsigned char *data_start,
        int vol_width, 
        int vol_height, 
        int time_increment_resolution, 
        double frame_rate);
int quicktime_divx_has_vol(unsigned char *data);
 
int quicktime_div3_is_key(unsigned char *data, long size);
 
int quicktime_encode_video(quicktime_t *file, 
        unsigned char **row_pointers, 
        int track);
 
int quicktime_decode_video(quicktime_t *file, 
        unsigned char **row_pointers, 
        int track);
 
long quicktime_decode_scaled(quicktime_t *file, 
        int in_x,                    /* Location of input frame to take picture */
        int in_y,
        int in_w,
        int in_h,
        int out_w,                   /* Dimensions of output frame */
        int out_h,
        int color_model,             /* One of the color models defined above */
        unsigned char **row_pointers, 
        int track);
 
/* Decode or encode audio for a single channel into the buffer. */
/* Pass a buffer for the _i or the _f argument if you want int16 or float data. */
/* Notice that encoding requires an array of pointers to each channel. */
 
int quicktime_decode_audio(quicktime_t *file, int16_t *output_i, float *output_f, long samples, int channel);
 
int quicktime_encode_audio(quicktime_t *file, int16_t **input_i, float **input_f, long samples);
 
int quicktime_dump(quicktime_t *file);
 
/* Specify the number of cpus to utilize. */
 
int quicktime_set_cpus(quicktime_t *file, int cpus);
 
/* Specify whether to read contiguously or not. */
/* preload is the number of bytes to read ahead. */
/* This is no longer functional to the end user but is used to accelerate */
/* reading the header internally. */
void quicktime_set_preload(quicktime_t *file, int64_t preload);
 
int64_t quicktime_byte_position(quicktime_t *file);
 
void quicktime_set_avi(quicktime_t *file, int value);
 
#ifdef __GNUC__
#pragma GCC visibility pop
#endif
 
 
#ifdef __cplusplus
}
#endif
 
#endif