1374 lines
39 KiB
C
1374 lines
39 KiB
C
/*
|
|
* The contents of this file are subject to the Mozilla Public
|
|
* License Version 1.1 (the "License"); you may not use this file
|
|
* except in compliance with the License. You may obtain a copy of
|
|
* the License at http://www.mozilla.org/MPL/
|
|
*
|
|
* Software distributed under the License is distributed on an "AS
|
|
* IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
|
|
* implied. See the License for the specific language governing
|
|
* rights and limitations under the License.
|
|
*
|
|
* The Original Code is MPEG4IP.
|
|
*
|
|
* The Initial Developer of the Original Code is Cisco Systems Inc.
|
|
* Portions created by Cisco Systems Inc. are
|
|
* Copyright (C) Cisco Systems Inc. 2001 - 2005. All Rights Reserved.
|
|
*
|
|
* 3GPP features implementation is based on 3GPP's TS26.234-v5.60,
|
|
* and was contributed by Ximpo Group Ltd.
|
|
*
|
|
* Portions created by Ximpo Group Ltd. are
|
|
* Copyright (C) Ximpo Group Ltd. 2003, 2004. All Rights Reserved.
|
|
*
|
|
* Contributor(s):
|
|
* Dave Mackie dmackie@cisco.com
|
|
* Alix Marchandise-Franquet alix@cisco.com
|
|
* Ximpo Group Ltd. mp4v2@ximpo.com
|
|
* Bill May wmay@cisco.com
|
|
*/
|
|
|
|
#ifndef __MP4_INCLUDED__
|
|
#define __MP4_INCLUDED__
|
|
|
|
/* include system and project specific headers */
|
|
#include "include/mpeg4ip.h"
|
|
#include <math.h> /* to define float HUGE_VAL and/or NAN */
|
|
#ifndef NAN
|
|
#define NAN HUGE_VAL
|
|
#endif
|
|
|
|
#ifdef __cplusplus
|
|
/* exploit C++ ability of default values for function parameters */
|
|
#define DEFAULT(x) =x
|
|
#else
|
|
#define DEFAULT(x)
|
|
#endif
|
|
|
|
/* MP4 API types */
|
|
typedef void* MP4FileHandle;
|
|
typedef u_int32_t MP4TrackId;
|
|
typedef u_int32_t MP4SampleId;
|
|
typedef u_int32_t MP4ChunkId;
|
|
typedef u_int64_t MP4Timestamp;
|
|
typedef u_int64_t MP4Duration;
|
|
typedef u_int32_t MP4EditId;
|
|
|
|
typedef u_int64_t (*VIRTUALIO_GETFILELENGTH)(void *user); // return file length in bytes
|
|
typedef int (*VIRTUALIO_SETPOSITION)(void *user, u_int64_t position); // return 0 on success
|
|
typedef int (*VIRTUALIO_GETPOSITION)(void *user, u_int64_t *position); // fill position, return 0 on success
|
|
typedef size_t (*VIRTUALIO_READ)(void *user, void *buffer, size_t size); // return number of bytes actually read
|
|
typedef size_t (*VIRTUALIO_WRITE)(void *user, void *buffer, size_t size); // return number of bytes actually written
|
|
typedef int (*VIRTUALIO_ENDOFFILE)(void *user); // return 1 if file hit EOF
|
|
typedef int (*VIRTUALIO_CLOSE)(void *user); // return 0 on success
|
|
|
|
typedef struct Virtual_IO
|
|
{
|
|
VIRTUALIO_GETFILELENGTH GetFileLength;
|
|
VIRTUALIO_SETPOSITION SetPosition;
|
|
VIRTUALIO_GETPOSITION GetPosition;
|
|
VIRTUALIO_READ Read;
|
|
VIRTUALIO_WRITE Write;
|
|
VIRTUALIO_ENDOFFILE EndOfFile;
|
|
VIRTUALIO_CLOSE Close;
|
|
} Virtual_IO_t;
|
|
|
|
|
|
/* Invalid values for API types */
|
|
#define MP4_INVALID_FILE_HANDLE ((MP4FileHandle)NULL)
|
|
#define MP4_INVALID_TRACK_ID ((MP4TrackId)0)
|
|
#define MP4_INVALID_SAMPLE_ID ((MP4SampleId)0)
|
|
#define MP4_INVALID_TIMESTAMP ((MP4Timestamp)-1)
|
|
#define MP4_INVALID_DURATION ((MP4Duration)-1)
|
|
#define MP4_INVALID_EDIT_ID ((MP4EditId)0)
|
|
|
|
/* Macros to test for API type validity */
|
|
#define MP4_IS_VALID_FILE_HANDLE(x) ((x) != MP4_INVALID_FILE_HANDLE)
|
|
#define MP4_IS_VALID_TRACK_ID(x) ((x) != MP4_INVALID_TRACK_ID)
|
|
#define MP4_IS_VALID_SAMPLE_ID(x) ((x) != MP4_INVALID_SAMPLE_ID)
|
|
#define MP4_IS_VALID_TIMESTAMP(x) ((x) != MP4_INVALID_TIMESTAMP)
|
|
#define MP4_IS_VALID_DURATION(x) ((x) != MP4_INVALID_DURATION)
|
|
#define MP4_IS_VALID_EDIT_ID(x) ((x) != MP4_INVALID_EDIT_ID)
|
|
|
|
/* MP4 verbosity levels - e.g. MP4SetVerbosity() */
|
|
#define MP4_DETAILS_ALL 0xFFFFFFFF
|
|
#define MP4_DETAILS_ERROR 0x00000001
|
|
#define MP4_DETAILS_WARNING 0x00000002
|
|
#define MP4_DETAILS_READ 0x00000004
|
|
#define MP4_DETAILS_WRITE 0x00000008
|
|
#define MP4_DETAILS_FIND 0x00000010
|
|
#define MP4_DETAILS_TABLE 0x00000020
|
|
#define MP4_DETAILS_SAMPLE 0x00000040
|
|
#define MP4_DETAILS_HINT 0x00000080
|
|
#define MP4_DETAILS_ISMA 0x00000100
|
|
#define MP4_DETAILS_EDIT 0x00000200
|
|
|
|
#define MP4_DETAILS_READ_ALL \
|
|
(MP4_DETAILS_READ | MP4_DETAILS_TABLE | MP4_DETAILS_SAMPLE)
|
|
#define MP4_DETAILS_WRITE_ALL \
|
|
(MP4_DETAILS_WRITE | MP4_DETAILS_TABLE | MP4_DETAILS_SAMPLE)
|
|
|
|
/*
|
|
* MP4 Known track type names - e.g. MP4GetNumberOfTracks(type)
|
|
*
|
|
* Note this first group of track types should be created
|
|
* via the MP4Add<Type>Track() functions, and not MP4AddTrack(type)
|
|
*/
|
|
#define MP4_OD_TRACK_TYPE "odsm"
|
|
#define MP4_SCENE_TRACK_TYPE "sdsm"
|
|
#define MP4_AUDIO_TRACK_TYPE "soun"
|
|
#define MP4_VIDEO_TRACK_TYPE "vide"
|
|
#define MP4_HINT_TRACK_TYPE "hint"
|
|
#define MP4_CNTL_TRACK_TYPE "cntl"
|
|
#define MP4_TEXT_TRACK_TYPE "text"
|
|
/*
|
|
* This second set of track types should be created
|
|
* via MP4AddSystemsTrack(type)
|
|
*/
|
|
#define MP4_CLOCK_TRACK_TYPE "crsm"
|
|
#define MP4_MPEG7_TRACK_TYPE "m7sm"
|
|
#define MP4_OCI_TRACK_TYPE "ocsm"
|
|
#define MP4_IPMP_TRACK_TYPE "ipsm"
|
|
#define MP4_MPEGJ_TRACK_TYPE "mjsm"
|
|
|
|
#define MP4_IS_VIDEO_TRACK_TYPE(type) \
|
|
(!strcasecmp(type, MP4_VIDEO_TRACK_TYPE))
|
|
|
|
#define MP4_IS_AUDIO_TRACK_TYPE(type) \
|
|
(!strcasecmp(type, MP4_AUDIO_TRACK_TYPE))
|
|
|
|
#define MP4_IS_CNTL_TRACK_TYPE(type) \
|
|
(!strcasecmp(type, MP4_CNTL_TRACK_TYPE))
|
|
|
|
#define MP4_IS_OD_TRACK_TYPE(type) \
|
|
(!strcasecmp(type, MP4_OD_TRACK_TYPE))
|
|
|
|
#define MP4_IS_SCENE_TRACK_TYPE(type) \
|
|
(!strcasecmp(type, MP4_SCENE_TRACK_TYPE))
|
|
|
|
#define MP4_IS_HINT_TRACK_TYPE(type) \
|
|
(!strcasecmp(type, MP4_HINT_TRACK_TYPE))
|
|
|
|
#define MP4_IS_SYSTEMS_TRACK_TYPE(type) \
|
|
(!strcasecmp(type, MP4_CLOCK_TRACK_TYPE) \
|
|
|| !strcasecmp(type, MP4_MPEG7_TRACK_TYPE) \
|
|
|| !strcasecmp(type, MP4_OCI_TRACK_TYPE) \
|
|
|| !strcasecmp(type, MP4_IPMP_TRACK_TYPE) \
|
|
|| !strcasecmp(type, MP4_MPEGJ_TRACK_TYPE))
|
|
|
|
/* MP4 Audio track types - see MP4AddAudioTrack()*/
|
|
#define MP4_INVALID_AUDIO_TYPE 0x00
|
|
#define MP4_MPEG1_AUDIO_TYPE 0x6B
|
|
#define MP4_MPEG2_AUDIO_TYPE 0x69
|
|
#define MP4_MP3_AUDIO_TYPE MP4_MPEG2_AUDIO_TYPE
|
|
#define MP4_MPEG2_AAC_MAIN_AUDIO_TYPE 0x66
|
|
#define MP4_MPEG2_AAC_LC_AUDIO_TYPE 0x67
|
|
#define MP4_MPEG2_AAC_SSR_AUDIO_TYPE 0x68
|
|
#define MP4_MPEG2_AAC_AUDIO_TYPE MP4_MPEG2_AAC_MAIN_AUDIO_TYPE
|
|
#define MP4_MPEG4_AUDIO_TYPE 0x40
|
|
#define MP4_PRIVATE_AUDIO_TYPE 0xC0
|
|
#define MP4_PCM16_LITTLE_ENDIAN_AUDIO_TYPE 0xE0 /* a private definition */
|
|
#define MP4_VORBIS_AUDIO_TYPE 0xE1 /* a private definition */
|
|
#define MP4_AC3_AUDIO_TYPE 0xE2 /* a private definition */
|
|
#define MP4_ALAW_AUDIO_TYPE 0xE3 /* a private definition */
|
|
#define MP4_ULAW_AUDIO_TYPE 0xE4 /* a private definition */
|
|
#define MP4_G723_AUDIO_TYPE 0xE5 /* a private definition */
|
|
#define MP4_PCM16_BIG_ENDIAN_AUDIO_TYPE 0xE6 /* a private definition */
|
|
|
|
/* MP4 MPEG-4 Audio types from 14496-3 Table 1.5.1 */
|
|
#define MP4_MPEG4_INVALID_AUDIO_TYPE 0
|
|
#define MP4_MPEG4_AAC_MAIN_AUDIO_TYPE 1
|
|
#define MP4_MPEG4_AAC_LC_AUDIO_TYPE 2
|
|
#define MP4_MPEG4_AAC_SSR_AUDIO_TYPE 3
|
|
#define MP4_MPEG4_AAC_LTP_AUDIO_TYPE 4
|
|
#define MP4_MPEG4_AAC_HE_AUDIO_TYPE 5
|
|
#define MP4_MPEG4_AAC_SCALABLE_AUDIO_TYPE 6
|
|
#define MP4_MPEG4_CELP_AUDIO_TYPE 8
|
|
#define MP4_MPEG4_HVXC_AUDIO_TYPE 9
|
|
#define MP4_MPEG4_TTSI_AUDIO_TYPE 12
|
|
#define MP4_MPEG4_MAIN_SYNTHETIC_AUDIO_TYPE 13
|
|
#define MP4_MPEG4_WAVETABLE_AUDIO_TYPE 14
|
|
#define MP4_MPEG4_MIDI_AUDIO_TYPE 15
|
|
#define MP4_MPEG4_ALGORITHMIC_FX_AUDIO_TYPE 16
|
|
#define MP4_MPEG4_PARAMETRIC_STEREO 29
|
|
#define MP4_MPEG4_ALS_AUDIO_TYPE 31
|
|
#define MP4_MPEG4_LAYER1_AUDIO_TYPE 32
|
|
#define MP4_MPEG4_LAYER2_AUDIO_TYPE 33
|
|
#define MP4_MPEG4_LAYER3_AUDIO_TYPE 34
|
|
#define MP4_MPEG4_SLS_AUDIO_TYPE 35
|
|
|
|
/* MP4 Audio type utilities following common usage */
|
|
#define MP4_IS_MP3_AUDIO_TYPE(type) \
|
|
((type) == MP4_MPEG1_AUDIO_TYPE || (type) == MP4_MPEG2_AUDIO_TYPE)
|
|
|
|
#define MP4_IS_MPEG2_AAC_AUDIO_TYPE(type) \
|
|
(((type) >= MP4_MPEG2_AAC_MAIN_AUDIO_TYPE \
|
|
&& (type) <= MP4_MPEG2_AAC_SSR_AUDIO_TYPE))
|
|
|
|
#define MP4_IS_MPEG4_AAC_AUDIO_TYPE(mpeg4Type) \
|
|
(((mpeg4Type) >= MP4_MPEG4_AAC_MAIN_AUDIO_TYPE \
|
|
&& (mpeg4Type) <= MP4_MPEG4_AAC_HE_AUDIO_TYPE) \
|
|
|| (mpeg4Type) == MP4_MPEG4_AAC_SCALABLE_AUDIO_TYPE \
|
|
|| (mpeg4Type) == 17)
|
|
|
|
#define MP4_IS_AAC_AUDIO_TYPE(type) \
|
|
(MP4_IS_MPEG2_AAC_AUDIO_TYPE(type) \
|
|
|| (type) == MP4_MPEG4_AUDIO_TYPE)
|
|
|
|
/* MP4 Video track types - see MP4AddVideoTrack() */
|
|
#define MP4_INVALID_VIDEO_TYPE 0x00
|
|
#define MP4_MPEG1_VIDEO_TYPE 0x6A
|
|
#define MP4_MPEG2_SIMPLE_VIDEO_TYPE 0x60
|
|
#define MP4_MPEG2_MAIN_VIDEO_TYPE 0x61
|
|
#define MP4_MPEG2_SNR_VIDEO_TYPE 0x62
|
|
#define MP4_MPEG2_SPATIAL_VIDEO_TYPE 0x63
|
|
#define MP4_MPEG2_HIGH_VIDEO_TYPE 0x64
|
|
#define MP4_MPEG2_442_VIDEO_TYPE 0x65
|
|
#define MP4_MPEG2_VIDEO_TYPE MP4_MPEG2_MAIN_VIDEO_TYPE
|
|
#define MP4_MPEG4_VIDEO_TYPE 0x20
|
|
#define MP4_JPEG_VIDEO_TYPE 0x6C
|
|
#define MP4_PRIVATE_VIDEO_TYPE 0xD0
|
|
#define MP4_YUV12_VIDEO_TYPE 0xF0 /* a private definition */
|
|
#define MP4_H263_VIDEO_TYPE 0xF2 /* a private definition */
|
|
#define MP4_H261_VIDEO_TYPE 0xF3 /* a private definition */
|
|
|
|
/* MP4 Video type utilities */
|
|
#define MP4_IS_MPEG1_VIDEO_TYPE(type) \
|
|
((type) == MP4_MPEG1_VIDEO_TYPE)
|
|
|
|
#define MP4_IS_MPEG2_VIDEO_TYPE(type) \
|
|
(((type) >= MP4_MPEG2_SIMPLE_VIDEO_TYPE \
|
|
&& (type) <= MP4_MPEG2_442_VIDEO_TYPE) \
|
|
|| MP4_IS_MPEG1_VIDEO_TYPE(type))
|
|
|
|
#define MP4_IS_MPEG4_VIDEO_TYPE(type) \
|
|
((type) == MP4_MPEG4_VIDEO_TYPE)
|
|
|
|
/* Mpeg4 Visual Profile Defines - ISO/IEC 14496-2:2001/Amd.2:2002(E) */
|
|
#define MPEG4_SP_L1 (0x1)
|
|
#define MPEG4_SP_L2 (0x2)
|
|
#define MPEG4_SP_L3 (0x3)
|
|
#define MPEG4_SP_L0 (0x8)
|
|
#define MPEG4_SSP_L1 (0x11)
|
|
#define MPEG4_SSP_L2 (0x12)
|
|
#define MPEG4_CP_L1 (0x21)
|
|
#define MPEG4_CP_L2 (0x22)
|
|
#define MPEG4_MP_L2 (0x32)
|
|
#define MPEG4_MP_L3 (0x33)
|
|
#define MPEG4_MP_L4 (0x34)
|
|
#define MPEG4_NBP_L2 (0x42)
|
|
#define MPEG4_STP_L1 (0x51)
|
|
#define MPEG4_SFAP_L1 (0x61)
|
|
#define MPEG4_SFAP_L2 (0x62)
|
|
#define MPEG4_SFBAP_L1 (0x63)
|
|
#define MPEG4_SFBAP_L2 (0x64)
|
|
#define MPEG4_BATP_L1 (0x71)
|
|
#define MPEG4_BATP_L2 (0x72)
|
|
#define MPEG4_HP_L1 (0x81)
|
|
#define MPEG4_HP_L2 (0x82)
|
|
#define MPEG4_ARTSP_L1 (0x91)
|
|
#define MPEG4_ARTSP_L2 (0x92)
|
|
#define MPEG4_ARTSP_L3 (0x93)
|
|
#define MPEG4_ARTSP_L4 (0x94)
|
|
#define MPEG4_CSP_L1 (0xa1)
|
|
#define MPEG4_CSP_L2 (0xa2)
|
|
#define MPEG4_CSP_L3 (0xa3)
|
|
#define MPEG4_ACEP_L1 (0xb1)
|
|
#define MPEG4_ACEP_L2 (0xb2)
|
|
#define MPEG4_ACEP_L3 (0xb3)
|
|
#define MPEG4_ACEP_L4 (0xb4)
|
|
#define MPEG4_ACP_L1 (0xc1)
|
|
#define MPEG4_ACP_L2 (0xc2)
|
|
#define MPEG4_AST_L1 (0xd1)
|
|
#define MPEG4_AST_L2 (0xd2)
|
|
#define MPEG4_AST_L3 (0xd3)
|
|
#define MPEG4_S_STUDIO_P_L1 (0xe1)
|
|
#define MPEG4_S_STUDIO_P_L2 (0xe2)
|
|
#define MPEG4_S_STUDIO_P_L3 (0xe3)
|
|
#define MPEG4_S_STUDIO_P_L4 (0xe4)
|
|
#define MPEG4_C_STUDIO_P_L1 (0xe5)
|
|
#define MPEG4_C_STUDIO_P_L2 (0xe6)
|
|
#define MPEG4_C_STUDIO_P_L3 (0xe7)
|
|
#define MPEG4_C_STUDIO_P_L4 (0xe8)
|
|
#define MPEG4_ASP_L0 (0xF0)
|
|
#define MPEG4_ASP_L1 (0xF1)
|
|
#define MPEG4_ASP_L2 (0xF2)
|
|
#define MPEG4_ASP_L3 (0xF3)
|
|
#define MPEG4_ASP_L4 (0xF4)
|
|
#define MPEG4_ASP_L5 (0xF5)
|
|
#define MPEG4_ASP_L3B (0xF7)
|
|
#define MPEG4_FGSP_L0 (0xf8)
|
|
#define MPEG4_FGSP_L1 (0xf9)
|
|
#define MPEG4_FGSP_L2 (0xfa)
|
|
#define MPEG4_FGSP_L3 (0xfb)
|
|
#define MPEG4_FGSP_L4 (0xfc)
|
|
#define MPEG4_FGSP_L5 (0xfd)
|
|
|
|
/* chapter related definitions */
|
|
#define CHAPTERTITLELEN 1023
|
|
typedef struct MP4ChapterStruct {
|
|
MP4Duration duration; /* duration of a chapter in milliseconds*/
|
|
char title[CHAPTERTITLELEN+1]; /* title of the chapter */
|
|
} MP4Chapters_t;
|
|
/* milliseconds to 100 nanoseconds */
|
|
#define MILLI2HUNDREDNANO 10000
|
|
|
|
|
|
/* MP4 API declarations */
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
/* file operations */
|
|
#define MP4_CREATE_64BIT_DATA (0x01)
|
|
#define MP4_CREATE_64BIT_TIME (0x02) // Quicktime is not compatible with this
|
|
#define MP4_CREATE_64BIT (MP4_CREATE_64BIT_DATA | MP4_CREATE_64BIT_TIME)
|
|
#define MP4_CREATE_EXTENSIBLE_FORMAT (0x04)
|
|
|
|
MP4FileHandle MP4Create(
|
|
const MP4_FILENAME_CHAR *fileName,
|
|
u_int32_t verbosity DEFAULT(0),
|
|
u_int32_t flags DEFAULT(0));
|
|
MP4FileHandle MP4CreateEx(
|
|
const MP4_FILENAME_CHAR *fileName,
|
|
u_int32_t verbosity DEFAULT(0),
|
|
u_int32_t flags DEFAULT(0),
|
|
int add_ftyp DEFAULT(1),
|
|
int add_iods DEFAULT(1),
|
|
char* majorBrand DEFAULT(0),
|
|
u_int32_t minorVersion DEFAULT(0),
|
|
char** supportedBrands DEFAULT(0),
|
|
u_int32_t supportedBrandsCount DEFAULT(0));
|
|
|
|
MP4FileHandle MP4Modify(
|
|
const MP4_FILENAME_CHAR *fileName,
|
|
u_int32_t verbosity DEFAULT(0),
|
|
u_int32_t flags DEFAULT(0));
|
|
|
|
MP4FileHandle MP4Read(
|
|
const MP4_FILENAME_CHAR *fileName,
|
|
u_int32_t verbosity DEFAULT(0));
|
|
|
|
// benski>
|
|
MP4FileHandle MP4ReadEx(const MP4_FILENAME_CHAR *fileName,
|
|
void *user,
|
|
Virtual_IO_t *virtual_IO,
|
|
u_int32_t verbosity DEFAULT(0));
|
|
|
|
void MP4Close(
|
|
MP4FileHandle hFile);
|
|
|
|
bool MP4Optimize(
|
|
const MP4_FILENAME_CHAR *existingFileName,
|
|
const MP4_FILENAME_CHAR *newFileName DEFAULT(NULL),
|
|
u_int32_t verbosity DEFAULT(0));
|
|
|
|
bool MP4Dump(
|
|
MP4FileHandle hFile,
|
|
FILE* pDumpFile DEFAULT(NULL),
|
|
bool dumpImplicits DEFAULT(0));
|
|
|
|
#if 0
|
|
char* MP4Info(
|
|
MP4FileHandle hFile,
|
|
MP4TrackId trackId DEFAULT(MP4_INVALID_TRACK_ID));
|
|
|
|
char* MP4FileInfo(
|
|
const MP4_FILENAME_CHAR* fileName,
|
|
MP4TrackId trackId DEFAULT(MP4_INVALID_TRACK_ID));
|
|
#endif
|
|
|
|
/* file properties */
|
|
|
|
/* specific file properties */
|
|
|
|
u_int32_t MP4GetVerbosity(MP4FileHandle hFile);
|
|
|
|
void MP4SetVerbosity(MP4FileHandle hFile, u_int32_t verbosity);
|
|
|
|
MP4Duration MP4GetDuration(MP4FileHandle hFile);
|
|
|
|
u_int32_t MP4GetTimeScale(MP4FileHandle hFile);
|
|
|
|
bool MP4SetTimeScale(MP4FileHandle hFile, u_int32_t value);
|
|
|
|
u_int8_t MP4GetODProfileLevel(MP4FileHandle hFile);
|
|
|
|
bool MP4SetODProfileLevel(MP4FileHandle hFile, u_int8_t value);
|
|
|
|
u_int8_t MP4GetSceneProfileLevel(MP4FileHandle hFile);
|
|
|
|
bool MP4SetSceneProfileLevel(MP4FileHandle hFile, u_int8_t value);
|
|
|
|
u_int8_t MP4GetVideoProfileLevel(MP4FileHandle hFile,
|
|
MP4TrackId trackId DEFAULT(MP4_INVALID_TRACK_ID));
|
|
|
|
void MP4SetVideoProfileLevel(MP4FileHandle hFile, u_int8_t value);
|
|
|
|
u_int8_t MP4GetAudioProfileLevel(MP4FileHandle hFile);
|
|
|
|
void MP4SetAudioProfileLevel(MP4FileHandle hFile, u_int8_t value);
|
|
|
|
u_int8_t MP4GetGraphicsProfileLevel(MP4FileHandle hFile);
|
|
|
|
bool MP4SetGraphicsProfileLevel(MP4FileHandle hFile, u_int8_t value);
|
|
|
|
/* generic file properties */
|
|
bool MP4HaveAtom(MP4FileHandle hFile,
|
|
const char *atomName);
|
|
|
|
bool MP4GetIntegerProperty(
|
|
MP4FileHandle hFile,
|
|
const char* propName,
|
|
u_int64_t *retval );
|
|
|
|
|
|
bool MP4GetFloatProperty(
|
|
MP4FileHandle hFile,
|
|
const char* propName,
|
|
float *retvalue);
|
|
|
|
bool MP4GetStringProperty(
|
|
MP4FileHandle hFile,
|
|
const char* propName,
|
|
const char **retvalue);
|
|
|
|
bool MP4GetBytesProperty(
|
|
MP4FileHandle hFile,
|
|
const char* propName,
|
|
u_int8_t** ppValue,
|
|
u_int32_t* pValueSize);
|
|
|
|
bool MP4SetIntegerProperty(
|
|
MP4FileHandle hFile,
|
|
const char* propName,
|
|
int64_t value);
|
|
|
|
bool MP4SetFloatProperty(
|
|
MP4FileHandle hFile,
|
|
const char* propName,
|
|
float value);
|
|
|
|
bool MP4SetStringProperty(
|
|
MP4FileHandle hFile, const char* propName, const char* value);
|
|
|
|
bool MP4SetBytesProperty(
|
|
MP4FileHandle hFile, const char* propName,
|
|
const u_int8_t* pValue, u_int32_t valueSize);
|
|
|
|
/* track operations */
|
|
|
|
MP4TrackId MP4AddTrack(
|
|
MP4FileHandle hFile,
|
|
const char* type);
|
|
|
|
MP4TrackId MP4AddSystemsTrack(
|
|
MP4FileHandle hFile,
|
|
const char* type);
|
|
|
|
MP4TrackId MP4AddODTrack(
|
|
MP4FileHandle hFile);
|
|
|
|
MP4TrackId MP4AddSceneTrack(
|
|
MP4FileHandle hFile);
|
|
|
|
MP4TrackId MP4AddAudioTrack(
|
|
MP4FileHandle hFile,
|
|
u_int32_t timeScale,
|
|
MP4Duration sampleDuration,
|
|
u_int8_t audioType DEFAULT(MP4_MPEG4_AUDIO_TYPE));
|
|
|
|
typedef struct mp4v2_ismacryp_session_params {
|
|
u_int32_t scheme_type;
|
|
u_int16_t scheme_version;
|
|
u_int8_t key_ind_len;
|
|
u_int8_t iv_len;
|
|
u_int8_t selective_enc;
|
|
const char *kms_uri;
|
|
} mp4v2_ismacrypParams;
|
|
|
|
// API to initialize ismacryp properties to sensible defaults
|
|
// if input param is null then mallocs a params struct
|
|
mp4v2_ismacrypParams *MP4DefaultISMACrypParams(mp4v2_ismacrypParams *ptr);
|
|
|
|
MP4TrackId MP4AddEncAudioTrack(
|
|
MP4FileHandle hFile,
|
|
u_int32_t timeScale,
|
|
MP4Duration sampleDuration,
|
|
mp4v2_ismacrypParams *icPp,
|
|
u_int8_t audioType DEFAULT(MP4_MPEG4_AUDIO_TYPE));
|
|
|
|
MP4TrackId MP4AddAmrAudioTrack(
|
|
MP4FileHandle hFile,
|
|
u_int32_t timeScale,
|
|
u_int16_t modeSet,
|
|
u_int8_t modeChangePeriod,
|
|
u_int8_t framesPerSample,
|
|
bool isAmrWB);
|
|
|
|
void MP4SetAmrVendor(
|
|
MP4FileHandle hFile,
|
|
MP4TrackId trackId,
|
|
u_int32_t vendor);
|
|
|
|
void MP4SetAmrDecoderVersion(
|
|
MP4FileHandle hFile,
|
|
MP4TrackId trackId,
|
|
u_int8_t decoderVersion);
|
|
|
|
void MP4SetAmrModeSet(MP4FileHandle hFile, MP4TrackId trakId, uint16_t modeSet);
|
|
uint16_t MP4GetAmrModeSet(MP4FileHandle hFile, MP4TrackId trackId);
|
|
|
|
MP4TrackId MP4AddHrefTrack(MP4FileHandle hFile,
|
|
uint32_t timeScale,
|
|
MP4Duration sampleDuration,
|
|
const char *base_url DEFAULT(NULL));
|
|
|
|
const char *MP4GetHrefTrackBaseUrl(MP4FileHandle hFile,
|
|
MP4TrackId trackId);
|
|
MP4TrackId MP4AddVideoTrack(
|
|
MP4FileHandle hFile,
|
|
u_int32_t timeScale,
|
|
MP4Duration sampleDuration,
|
|
u_int16_t width,
|
|
u_int16_t height,
|
|
u_int8_t videoType DEFAULT(MP4_MPEG4_VIDEO_TYPE));
|
|
|
|
MP4TrackId MP4AddEncVideoTrack(
|
|
MP4FileHandle hFile,
|
|
u_int32_t timeScale,
|
|
MP4Duration sampleDuration,
|
|
u_int16_t width,
|
|
u_int16_t height,
|
|
mp4v2_ismacrypParams *icPp,
|
|
u_int8_t videoType DEFAULT(MP4_MPEG4_VIDEO_TYPE),
|
|
const char *oFormat DEFAULT(NULL));
|
|
|
|
MP4TrackId MP4AddH264VideoTrack(
|
|
MP4FileHandle hFile,
|
|
u_int32_t timeScale,
|
|
MP4Duration sampleDuration,
|
|
u_int16_t width,
|
|
u_int16_t height,
|
|
uint8_t AVCProfileIndication,
|
|
uint8_t profile_compat,
|
|
uint8_t AVCLevelIndication,
|
|
uint8_t sampleLenFieldSizeMinusOne);
|
|
|
|
MP4TrackId MP4AddEncH264VideoTrack(
|
|
MP4FileHandle dstFile,
|
|
u_int32_t timeScale,
|
|
MP4Duration sampleDuration,
|
|
u_int16_t width,
|
|
u_int16_t height,
|
|
MP4FileHandle srcFile,
|
|
MP4TrackId srcTrackId,
|
|
mp4v2_ismacrypParams *icPp);
|
|
|
|
void MP4AddH264SequenceParameterSet(MP4FileHandle hFile,
|
|
MP4TrackId trackId,
|
|
const uint8_t *pSequence,
|
|
uint16_t sequenceLen);
|
|
void MP4AddH264PictureParameterSet(MP4FileHandle hFile,
|
|
MP4TrackId trackId,
|
|
const uint8_t *pPict,
|
|
uint16_t pictLen);
|
|
void MP4SetH263Vendor(
|
|
MP4FileHandle hFile,
|
|
MP4TrackId trackId,
|
|
u_int32_t vendor);
|
|
|
|
void MP4SetH263DecoderVersion(
|
|
MP4FileHandle hFile,
|
|
MP4TrackId trackId,
|
|
u_int8_t decoderVersion);
|
|
|
|
void MP4SetH263Bitrates(
|
|
MP4FileHandle hFile,
|
|
MP4TrackId trackId,
|
|
u_int32_t avgBitrate,
|
|
u_int32_t maxBitrate);
|
|
|
|
MP4TrackId MP4AddH263VideoTrack(
|
|
MP4FileHandle hFile,
|
|
u_int32_t timeScale,
|
|
MP4Duration sampleDuration,
|
|
u_int16_t width,
|
|
u_int16_t height,
|
|
u_int8_t h263Level,
|
|
u_int8_t h263Profile,
|
|
u_int32_t avgBitrate,
|
|
u_int32_t maxBitrate);
|
|
|
|
MP4TrackId MP4AddHintTrack(
|
|
MP4FileHandle hFile,
|
|
MP4TrackId refTrackId);
|
|
|
|
MP4TrackId MP4AddTextTrack(
|
|
MP4FileHandle hFile,
|
|
MP4TrackId refTrackId);
|
|
|
|
MP4TrackId MP4AddChapterTextTrack(
|
|
MP4FileHandle hFile,
|
|
MP4TrackId refTrackId,
|
|
u_int32_t timescale DEFAULT(0));
|
|
|
|
void MP4AddQTChapter(
|
|
MP4FileHandle hFile,
|
|
MP4TrackId chapterTrackId,
|
|
MP4Duration chapterDuration,
|
|
u_int32_t chapterNr,
|
|
const char * chapterTitle DEFAULT(0));
|
|
|
|
void MP4AddChapter(
|
|
MP4FileHandle hFile,
|
|
MP4Timestamp chapterStart,
|
|
const char * chapterTitle DEFAULT(0));
|
|
|
|
void MP4ConvertChapters(
|
|
MP4FileHandle hFile,
|
|
bool toQT DEFAULT(true));
|
|
|
|
void MP4DeleteChapters(
|
|
MP4FileHandle hFile,
|
|
MP4TrackId chapterTrackId DEFAULT(MP4_INVALID_TRACK_ID),
|
|
bool deleteQT DEFAULT(true));
|
|
|
|
void MP4GetChaptersList(
|
|
MP4FileHandle hFile,
|
|
MP4Chapters_t ** chapterList,
|
|
u_int32_t * chapterCount,
|
|
bool getQT DEFAULT(true));
|
|
|
|
MP4TrackId MP4CloneTrack(
|
|
MP4FileHandle srcFile,
|
|
MP4TrackId srcTrackId,
|
|
MP4FileHandle dstFile DEFAULT(MP4_INVALID_FILE_HANDLE),
|
|
MP4TrackId dstHintTrackReferenceTrack DEFAULT(MP4_INVALID_TRACK_ID));
|
|
|
|
MP4TrackId MP4EncAndCloneTrack(
|
|
MP4FileHandle srcFile,
|
|
MP4TrackId srcTrackId,
|
|
mp4v2_ismacrypParams *icPp,
|
|
MP4FileHandle dstFile DEFAULT(MP4_INVALID_FILE_HANDLE),
|
|
MP4TrackId dstHintTrackReferenceTrack DEFAULT(MP4_INVALID_TRACK_ID));
|
|
|
|
MP4TrackId MP4CopyTrack(
|
|
MP4FileHandle srcFile,
|
|
MP4TrackId srcTrackId,
|
|
MP4FileHandle dstFile DEFAULT(MP4_INVALID_FILE_HANDLE),
|
|
bool applyEdits DEFAULT(false),
|
|
MP4TrackId dstHintTrackReferenceTrack DEFAULT(MP4_INVALID_TRACK_ID));
|
|
|
|
typedef u_int32_t (*encryptFunc_t)(u_int32_t, u_int32_t, u_int8_t*, u_int32_t*, u_int8_t **);
|
|
|
|
MP4TrackId MP4EncAndCopyTrack(
|
|
MP4FileHandle srcFile,
|
|
MP4TrackId srcTrackId,
|
|
mp4v2_ismacrypParams *icPp,
|
|
encryptFunc_t encfcnp,
|
|
u_int32_t encfcnparam1,
|
|
MP4FileHandle dstFile DEFAULT(MP4_INVALID_FILE_HANDLE),
|
|
bool applyEdits DEFAULT(false),
|
|
MP4TrackId dstHintTrackReferenceTrack DEFAULT(MP4_INVALID_TRACK_ID));
|
|
|
|
void MP4DeleteTrack(
|
|
MP4FileHandle hFile,
|
|
MP4TrackId trackId);
|
|
|
|
u_int32_t MP4GetNumberOfTracks(
|
|
MP4FileHandle hFile,
|
|
const char* type DEFAULT(NULL),
|
|
u_int8_t subType DEFAULT(0));
|
|
|
|
MP4TrackId MP4FindTrackId(
|
|
MP4FileHandle hFile,
|
|
u_int16_t index,
|
|
const char* type DEFAULT(NULL),
|
|
u_int8_t subType DEFAULT(0));
|
|
|
|
u_int16_t MP4FindTrackIndex(
|
|
MP4FileHandle hFile,
|
|
MP4TrackId trackId);
|
|
|
|
/* track properties */
|
|
|
|
/* specific track properties */
|
|
|
|
bool MP4HaveTrackAtom(MP4FileHandle hFile,
|
|
MP4TrackId trackId,
|
|
const char *atomname);
|
|
|
|
const char* MP4GetTrackType(
|
|
MP4FileHandle hFile,
|
|
MP4TrackId trackId);
|
|
|
|
const char *MP4GetTrackMediaDataName(MP4FileHandle hFile,
|
|
MP4TrackId trackId);
|
|
|
|
// MP4GetTrackMediaDataOriginalFormat is to be used to get the original
|
|
// MediaDataName if a track has been encrypted.
|
|
bool MP4GetTrackMediaDataOriginalFormat(MP4FileHandle hFile,
|
|
MP4TrackId trackId, char *originalFormat, u_int32_t buflen);
|
|
|
|
MP4Duration MP4GetTrackDuration(
|
|
MP4FileHandle hFile,
|
|
MP4TrackId trackId);
|
|
|
|
u_int32_t MP4GetTrackTimeScale(
|
|
MP4FileHandle hFile,
|
|
MP4TrackId trackId);
|
|
|
|
void MP4SetTrackTimeScale(
|
|
MP4FileHandle hFile,
|
|
MP4TrackId trackId,
|
|
u_int32_t value);
|
|
|
|
u_int8_t MP4GetTrackAudioMpeg4Type(
|
|
MP4FileHandle hFile,
|
|
MP4TrackId trackId);
|
|
|
|
u_int8_t MP4GetTrackEsdsObjectTypeId(
|
|
MP4FileHandle hFile,
|
|
MP4TrackId trackId);
|
|
|
|
/* returns MP4_INVALID_DURATION if track samples do not have a fixed duration */
|
|
MP4Duration MP4GetTrackFixedSampleDuration(
|
|
MP4FileHandle hFile,
|
|
MP4TrackId trackId);
|
|
|
|
u_int32_t MP4GetTrackBitRate(
|
|
MP4FileHandle hFile,
|
|
MP4TrackId trackId);
|
|
|
|
bool MP4GetTrackVideoMetadata(MP4FileHandle hFile,
|
|
MP4TrackId trackId,
|
|
uint8_t **ppConfig,
|
|
uint32_t *pConfigSize);
|
|
|
|
bool MP4GetTrackESConfiguration(
|
|
MP4FileHandle hFile,
|
|
MP4TrackId trackId,
|
|
u_int8_t** ppConfig,
|
|
u_int32_t* pConfigSize);
|
|
|
|
bool MP4SetTrackESConfiguration(
|
|
MP4FileHandle hFile,
|
|
MP4TrackId trackId,
|
|
const u_int8_t* pConfig,
|
|
u_int32_t configSize);
|
|
|
|
/* h264 information routines */
|
|
bool MP4GetTrackH264ProfileLevel(MP4FileHandle hFile,
|
|
MP4TrackId trackId,
|
|
uint8_t *pProfile,
|
|
uint8_t *pLevel);
|
|
void MP4GetTrackH264SeqPictHeaders(MP4FileHandle hFile,
|
|
MP4TrackId trackId,
|
|
uint8_t ***pSeqHeaders,
|
|
uint32_t **pSeqHeaderSize,
|
|
uint8_t ***pPictHeader,
|
|
uint32_t **pPictHeaderSize);
|
|
bool MP4GetTrackH264LengthSize(MP4FileHandle hFile,
|
|
MP4TrackId trackId,
|
|
uint32_t *pLength);
|
|
MP4SampleId MP4GetTrackNumberOfSamples(
|
|
MP4FileHandle hFile,
|
|
MP4TrackId trackId);
|
|
|
|
MP4ChunkId MP4GetTrackNumberOfChunks(
|
|
MP4FileHandle hFile,
|
|
MP4TrackId trackId);
|
|
|
|
u_int16_t MP4GetTrackVideoWidth(
|
|
MP4FileHandle hFile,
|
|
MP4TrackId trackId);
|
|
|
|
u_int16_t MP4GetTrackVideoHeight(
|
|
MP4FileHandle hFile,
|
|
MP4TrackId trackId);
|
|
|
|
double MP4GetTrackVideoFrameRate(
|
|
MP4FileHandle hFile,
|
|
MP4TrackId trackId);
|
|
|
|
int MP4GetTrackAudioChannels(MP4FileHandle hFile,
|
|
MP4TrackId trackId);
|
|
|
|
bool MP4IsIsmaCrypMediaTrack(
|
|
MP4FileHandle hFile,
|
|
MP4TrackId trackId);
|
|
|
|
/* generic track properties */
|
|
|
|
bool MP4HaveTrackAtom(MP4FileHandle hFile,
|
|
MP4TrackId trackId,
|
|
const char *atomName);
|
|
|
|
bool MP4GetTrackIntegerProperty(
|
|
MP4FileHandle hFile,
|
|
MP4TrackId trackId,
|
|
const char* propName,
|
|
u_int64_t *retvalue);
|
|
|
|
bool MP4GetTrackFloatProperty(
|
|
MP4FileHandle hFile,
|
|
MP4TrackId trackId,
|
|
const char* propName,
|
|
float *ret_value);
|
|
|
|
bool MP4GetTrackStringProperty(
|
|
MP4FileHandle hFile,
|
|
MP4TrackId trackId,
|
|
const char* propName,
|
|
const char **retvalue);
|
|
|
|
bool MP4GetTrackBytesProperty(
|
|
MP4FileHandle hFile,
|
|
MP4TrackId trackId,
|
|
const char* propName,
|
|
u_int8_t** ppValue,
|
|
u_int32_t* pValueSize);
|
|
|
|
bool MP4SetTrackIntegerProperty(
|
|
MP4FileHandle hFile,
|
|
MP4TrackId trackId,
|
|
const char* propName,
|
|
int64_t value);
|
|
|
|
bool MP4SetTrackFloatProperty(
|
|
MP4FileHandle hFile,
|
|
MP4TrackId trackId,
|
|
const char* propName,
|
|
float value);
|
|
|
|
bool MP4SetTrackStringProperty(
|
|
MP4FileHandle hFile,
|
|
MP4TrackId trackId,
|
|
const char* propName,
|
|
const char* value);
|
|
|
|
bool MP4SetTrackBytesProperty(
|
|
MP4FileHandle hFile,
|
|
MP4TrackId trackId,
|
|
const char* propName,
|
|
const u_int8_t* pValue,
|
|
u_int32_t valueSize);
|
|
|
|
/* sample operations */
|
|
|
|
bool MP4ReadSample(
|
|
/* input parameters */
|
|
MP4FileHandle hFile,
|
|
MP4TrackId trackId,
|
|
MP4SampleId sampleId,
|
|
/* input/output parameters */
|
|
u_int8_t** ppBytes,
|
|
u_int32_t* pNumBytes,
|
|
/* output parameters */
|
|
MP4Timestamp* pStartTime DEFAULT(NULL),
|
|
MP4Duration* pDuration DEFAULT(NULL),
|
|
MP4Duration* pRenderingOffset DEFAULT(NULL),
|
|
bool* pIsSyncSample DEFAULT(NULL));
|
|
|
|
bool MP4ReadChunk(
|
|
/* input parameters */
|
|
MP4FileHandle hFile,
|
|
MP4TrackId trackId,
|
|
MP4ChunkId sampleId,
|
|
/* input/output parameters */
|
|
u_int8_t** ppBytes,
|
|
u_int32_t* pNumBytes,
|
|
MP4Timestamp* pStartTime DEFAULT(NULL),
|
|
MP4Duration* pDuration DEFAULT(NULL));
|
|
|
|
/* uses (unedited) time to specify sample instead of sample id */
|
|
bool MP4ReadSampleFromTime(
|
|
/* input parameters */
|
|
MP4FileHandle hFile,
|
|
MP4TrackId trackId,
|
|
MP4Timestamp when,
|
|
/* input/output parameters */
|
|
u_int8_t** ppBytes,
|
|
u_int32_t* pNumBytes,
|
|
/* output parameters */
|
|
MP4Timestamp* pStartTime DEFAULT(NULL),
|
|
MP4Duration* pDuration DEFAULT(NULL),
|
|
MP4Duration* pRenderingOffset DEFAULT(NULL),
|
|
bool* pIsSyncSample DEFAULT(NULL));
|
|
|
|
bool MP4WriteSample(
|
|
MP4FileHandle hFile,
|
|
MP4TrackId trackId,
|
|
const u_int8_t* pBytes,
|
|
u_int32_t numBytes,
|
|
MP4Duration duration DEFAULT(MP4_INVALID_DURATION),
|
|
MP4Duration renderingOffset DEFAULT(0),
|
|
bool isSyncSample DEFAULT(true));
|
|
|
|
bool MP4CopySample(
|
|
MP4FileHandle srcFile,
|
|
MP4TrackId srcTrackId,
|
|
MP4SampleId srcSampleId,
|
|
MP4FileHandle dstFile DEFAULT(MP4_INVALID_FILE_HANDLE),
|
|
MP4TrackId dstTrackId DEFAULT(MP4_INVALID_TRACK_ID),
|
|
MP4Duration dstSampleDuration DEFAULT(MP4_INVALID_DURATION));
|
|
|
|
bool MP4EncAndCopySample(
|
|
MP4FileHandle srcFile,
|
|
MP4TrackId srcTrackId,
|
|
MP4SampleId srcSampleId,
|
|
encryptFunc_t encfcnp,
|
|
u_int32_t encfcnparam1,
|
|
MP4FileHandle dstFile DEFAULT(MP4_INVALID_FILE_HANDLE),
|
|
MP4TrackId dstTrackId DEFAULT(MP4_INVALID_TRACK_ID),
|
|
MP4Duration dstSampleDuration DEFAULT(MP4_INVALID_DURATION));
|
|
|
|
/* Note this function is not yet implemented */
|
|
bool MP4ReferenceSample(
|
|
MP4FileHandle srcFile,
|
|
MP4TrackId srcTrackId,
|
|
MP4SampleId srcSampleId,
|
|
MP4FileHandle dstFile,
|
|
MP4TrackId dstTrackId,
|
|
MP4Duration dstSampleDuration DEFAULT(MP4_INVALID_DURATION));
|
|
|
|
u_int32_t MP4GetSampleSize(
|
|
MP4FileHandle hFile,
|
|
MP4TrackId trackId,
|
|
MP4SampleId sampleId);
|
|
|
|
u_int32_t MP4GetTrackMaxSampleSize(
|
|
MP4FileHandle hFile,
|
|
MP4TrackId trackId);
|
|
|
|
MP4SampleId MP4GetSampleIdFromTime(
|
|
MP4FileHandle hFile,
|
|
MP4TrackId trackId,
|
|
MP4Timestamp when,
|
|
bool wantSyncSample DEFAULT(false),
|
|
bool rewind DEFAULT(false));
|
|
|
|
MP4ChunkId MP4GetChunkIdFromTime(
|
|
MP4FileHandle hFile,
|
|
MP4TrackId trackId,
|
|
MP4Timestamp when);
|
|
|
|
MP4Timestamp MP4GetSampleTime(
|
|
MP4FileHandle hFile,
|
|
MP4TrackId trackId,
|
|
MP4SampleId sampleId);
|
|
|
|
MP4Duration MP4GetSampleDuration(
|
|
MP4FileHandle hFile,
|
|
MP4TrackId trackId,
|
|
MP4SampleId sampleId);
|
|
|
|
MP4Duration MP4GetSampleRenderingOffset(
|
|
MP4FileHandle hFile,
|
|
MP4TrackId trackId,
|
|
MP4SampleId sampleId);
|
|
|
|
bool MP4SetSampleRenderingOffset(
|
|
MP4FileHandle hFile,
|
|
MP4TrackId trackId,
|
|
MP4SampleId sampleId,
|
|
MP4Duration renderingOffset);
|
|
|
|
int8_t MP4GetSampleSync(
|
|
MP4FileHandle hFile,
|
|
MP4TrackId trackId,
|
|
MP4SampleId sampleId);
|
|
|
|
/* rtp hint track operations */
|
|
|
|
bool MP4GetHintTrackRtpPayload(
|
|
MP4FileHandle hFile,
|
|
MP4TrackId hintTrackId,
|
|
char** ppPayloadName DEFAULT(NULL),
|
|
u_int8_t* pPayloadNumber DEFAULT(NULL),
|
|
u_int16_t* pMaxPayloadSize DEFAULT(NULL),
|
|
char **ppEncodingParams DEFAULT(NULL));
|
|
|
|
#define MP4_SET_DYNAMIC_PAYLOAD 0xff
|
|
|
|
bool MP4SetHintTrackRtpPayload(
|
|
MP4FileHandle hFile,
|
|
MP4TrackId hintTrackId,
|
|
const char* pPayloadName,
|
|
u_int8_t* pPayloadNumber,
|
|
u_int16_t maxPayloadSize DEFAULT(0),
|
|
const char *encode_params DEFAULT(NULL),
|
|
bool include_rtp_map DEFAULT(true),
|
|
bool include_mpeg4_esid DEFAULT(true));
|
|
|
|
const char* MP4GetSessionSdp(
|
|
MP4FileHandle hFile);
|
|
|
|
bool MP4SetSessionSdp(
|
|
MP4FileHandle hFile,
|
|
const char* sdpString);
|
|
|
|
bool MP4AppendSessionSdp(
|
|
MP4FileHandle hFile,
|
|
const char* sdpString);
|
|
|
|
const char* MP4GetHintTrackSdp(
|
|
MP4FileHandle hFile,
|
|
MP4TrackId hintTrackId);
|
|
|
|
bool MP4SetHintTrackSdp(
|
|
MP4FileHandle hFile,
|
|
MP4TrackId hintTrackId,
|
|
const char* sdpString);
|
|
|
|
bool MP4AppendHintTrackSdp(
|
|
MP4FileHandle hFile,
|
|
MP4TrackId hintTrackId,
|
|
const char* sdpString);
|
|
|
|
MP4TrackId MP4GetHintTrackReferenceTrackId(
|
|
MP4FileHandle hFile,
|
|
MP4TrackId hintTrackId);
|
|
|
|
bool MP4ReadRtpHint(
|
|
MP4FileHandle hFile,
|
|
MP4TrackId hintTrackId,
|
|
MP4SampleId hintSampleId,
|
|
u_int16_t* pNumPackets DEFAULT(NULL));
|
|
|
|
u_int16_t MP4GetRtpHintNumberOfPackets(
|
|
MP4FileHandle hFile,
|
|
MP4TrackId hintTrackId);
|
|
|
|
int8_t MP4GetRtpPacketBFrame(
|
|
MP4FileHandle hFile,
|
|
MP4TrackId hintTrackId,
|
|
u_int16_t packetIndex);
|
|
|
|
int32_t MP4GetRtpPacketTransmitOffset(
|
|
MP4FileHandle hFile,
|
|
MP4TrackId hintTrackId,
|
|
u_int16_t packetIndex);
|
|
|
|
bool MP4ReadRtpPacket(
|
|
MP4FileHandle hFile,
|
|
MP4TrackId hintTrackId,
|
|
u_int16_t packetIndex,
|
|
u_int8_t** ppBytes,
|
|
u_int32_t* pNumBytes,
|
|
u_int32_t ssrc DEFAULT(0),
|
|
bool includeHeader DEFAULT(true),
|
|
bool includePayload DEFAULT(true));
|
|
|
|
MP4Timestamp MP4GetRtpTimestampStart(
|
|
MP4FileHandle hFile,
|
|
MP4TrackId hintTrackId);
|
|
|
|
bool MP4SetRtpTimestampStart(
|
|
MP4FileHandle hFile,
|
|
MP4TrackId hintTrackId,
|
|
MP4Timestamp rtpStart);
|
|
|
|
bool MP4AddRtpHint(
|
|
MP4FileHandle hFile,
|
|
MP4TrackId hintTrackId);
|
|
|
|
bool MP4AddRtpVideoHint(
|
|
MP4FileHandle hFile,
|
|
MP4TrackId hintTrackId,
|
|
bool isBframe DEFAULT(false),
|
|
u_int32_t timestampOffset DEFAULT(0));
|
|
|
|
bool MP4AddRtpPacket(
|
|
MP4FileHandle hFile,
|
|
MP4TrackId hintTrackId,
|
|
bool setMbit DEFAULT(false),
|
|
int32_t transmitOffset DEFAULT(0));
|
|
|
|
bool MP4AddRtpImmediateData(
|
|
MP4FileHandle hFile,
|
|
MP4TrackId hintTrackId,
|
|
const u_int8_t* pBytes,
|
|
u_int32_t numBytes);
|
|
|
|
bool MP4AddRtpSampleData(
|
|
MP4FileHandle hFile,
|
|
MP4TrackId hintTrackId,
|
|
MP4SampleId sampleId,
|
|
u_int32_t dataOffset,
|
|
u_int32_t dataLength);
|
|
|
|
bool MP4AddRtpESConfigurationPacket(
|
|
MP4FileHandle hFile,
|
|
MP4TrackId hintTrackId);
|
|
|
|
bool MP4WriteRtpHint(
|
|
MP4FileHandle hFile,
|
|
MP4TrackId hintTrackId,
|
|
MP4Duration duration,
|
|
bool isSyncSample DEFAULT(true));
|
|
|
|
/* 3GP specific utilities */
|
|
|
|
bool MP4Make3GPCompliant(
|
|
const MP4_FILENAME_CHAR* fileName,
|
|
u_int32_t verbosity DEFAULT(0),
|
|
char* majorBrand DEFAULT(0),
|
|
u_int32_t minorVersion DEFAULT(0),
|
|
char** supportedBrands DEFAULT(NULL),
|
|
u_int32_t supportedBrandsCount DEFAULT(0),
|
|
bool deleteIodsAtom DEFAULT(true));
|
|
|
|
/* ISMA specific utilities */
|
|
|
|
bool MP4MakeIsmaCompliant(const MP4_FILENAME_CHAR* fileName,
|
|
u_int32_t verbosity DEFAULT(0),
|
|
bool addIsmaComplianceSdp DEFAULT(true));
|
|
|
|
char* MP4MakeIsmaSdpIod(
|
|
u_int8_t videoProfile,
|
|
u_int32_t videoBitrate,
|
|
u_int8_t* videoConfig,
|
|
u_int32_t videoConfigLength,
|
|
u_int8_t audioProfile,
|
|
u_int32_t audioBitrate,
|
|
u_int8_t* audioConfig,
|
|
u_int32_t audioConfigLength,
|
|
u_int32_t verbosity DEFAULT(0));
|
|
|
|
/* edit list */
|
|
|
|
/* NOTE this section of functionality
|
|
* has not yet been fully tested
|
|
*/
|
|
|
|
MP4EditId MP4AddTrackEdit(
|
|
MP4FileHandle hFile,
|
|
MP4TrackId trackId,
|
|
MP4EditId editId DEFAULT(MP4_INVALID_EDIT_ID),
|
|
MP4Timestamp startTime DEFAULT(0),
|
|
MP4Duration duration DEFAULT(0),
|
|
bool dwell DEFAULT(false));
|
|
|
|
bool MP4DeleteTrackEdit(
|
|
MP4FileHandle hFile,
|
|
MP4TrackId trackId,
|
|
MP4EditId editId);
|
|
|
|
u_int32_t MP4GetTrackNumberOfEdits(
|
|
MP4FileHandle hFile,
|
|
MP4TrackId trackId);
|
|
|
|
MP4Timestamp MP4GetTrackEditStart(
|
|
MP4FileHandle hFile,
|
|
MP4TrackId trackId,
|
|
MP4EditId editId);
|
|
|
|
MP4Duration MP4GetTrackEditTotalDuration(
|
|
MP4FileHandle hFile,
|
|
MP4TrackId trackId,
|
|
MP4EditId editId DEFAULT(MP4_INVALID_EDIT_ID));
|
|
|
|
MP4Timestamp MP4GetTrackEditMediaStart(
|
|
MP4FileHandle hFile,
|
|
MP4TrackId trackId,
|
|
MP4EditId editId);
|
|
|
|
bool MP4SetTrackEditMediaStart(
|
|
MP4FileHandle hFile,
|
|
MP4TrackId trackId,
|
|
MP4EditId editId,
|
|
MP4Timestamp startTime);
|
|
|
|
MP4Duration MP4GetTrackEditDuration(
|
|
MP4FileHandle hFile,
|
|
MP4TrackId trackId,
|
|
MP4EditId editId);
|
|
|
|
bool MP4SetTrackEditDuration(
|
|
MP4FileHandle hFile,
|
|
MP4TrackId trackId,
|
|
MP4EditId editId,
|
|
MP4Duration duration);
|
|
|
|
int8_t MP4GetTrackEditDwell(
|
|
MP4FileHandle hFile,
|
|
MP4TrackId trackId,
|
|
MP4EditId editId);
|
|
|
|
bool MP4SetTrackEditDwell(
|
|
MP4FileHandle hFile,
|
|
MP4TrackId trackId,
|
|
MP4EditId editId,
|
|
bool dwell);
|
|
|
|
bool MP4ReadSampleFromEditTime(
|
|
/* input parameters */
|
|
MP4FileHandle hFile,
|
|
MP4TrackId trackId,
|
|
MP4Timestamp when,
|
|
/* input/output parameters */
|
|
u_int8_t** ppBytes,
|
|
u_int32_t* pNumBytes,
|
|
/* output parameters */
|
|
MP4Timestamp* pStartTime DEFAULT(NULL),
|
|
MP4Duration* pDuration DEFAULT(NULL),
|
|
MP4Duration* pRenderingOffset DEFAULT(NULL),
|
|
bool* pIsSyncSample DEFAULT(NULL));
|
|
|
|
MP4SampleId MP4GetSampleIdFromEditTime(
|
|
MP4FileHandle hFile,
|
|
MP4TrackId trackId,
|
|
MP4Timestamp when,
|
|
MP4Timestamp* pStartTime DEFAULT(NULL),
|
|
MP4Duration* pDuration DEFAULT(NULL));
|
|
/* iTunes metadata handling */
|
|
bool MP4MetadataDelete(MP4FileHandle hFile);
|
|
bool MP4GetMetadataByIndex(MP4FileHandle hFile, u_int32_t index,
|
|
char** ppName, // need to free memory
|
|
u_int8_t** ppValue, // need to free
|
|
u_int32_t* pValueSize);
|
|
bool MP4SetMetadataName(MP4FileHandle hFile, const char* value);
|
|
bool MP4GetMetadataName(MP4FileHandle hFile, char** value);
|
|
bool MP4DeleteMetadataName(MP4FileHandle hFile);
|
|
bool MP4SetMetadataArtist(MP4FileHandle hFile, const char* value);
|
|
bool MP4GetMetadataArtist(MP4FileHandle hFile, char** value);
|
|
bool MP4DeleteMetadataArtist(MP4FileHandle hFile);
|
|
bool MP4SetMetadataRating(MP4FileHandle hFile, const char* value);
|
|
bool MP4GetMetadataRating(MP4FileHandle hFile, char** value);
|
|
bool MP4DeleteMetadataRating(MP4FileHandle hFile);
|
|
bool MP4SetMetadataWriter(MP4FileHandle hFile, const char* value);
|
|
bool MP4GetMetadataWriter(MP4FileHandle hFile, char** value);
|
|
bool MP4DeleteMetadataWriter(MP4FileHandle hFile);
|
|
bool MP4SetMetadataComment(MP4FileHandle hFile, const char* value);
|
|
bool MP4GetMetadataComment(MP4FileHandle hFile, char** value);
|
|
bool MP4DeleteMetadataComment(MP4FileHandle hFile);
|
|
bool MP4SetMetadataTool(MP4FileHandle hFile, const char* value);
|
|
bool MP4GetMetadataTool(MP4FileHandle hFile, char** value);
|
|
bool MP4DeleteMetadataTool(MP4FileHandle hFile);
|
|
bool MP4SetMetadataYear(MP4FileHandle hFile, const char* value);
|
|
bool MP4GetMetadataYear(MP4FileHandle hFile, char** value);
|
|
bool MP4DeleteMetadataYear(MP4FileHandle hFile);
|
|
bool MP4SetMetadataAlbum(MP4FileHandle hFile, const char* value);
|
|
bool MP4GetMetadataAlbum(MP4FileHandle hFile, char** value);
|
|
bool MP4DeleteMetadataAlbum(MP4FileHandle hFile);
|
|
bool MP4SetMetadataTrack(MP4FileHandle hFile,
|
|
u_int16_t track, u_int16_t totalTracks);
|
|
bool MP4GetMetadataTrack(MP4FileHandle hFile,
|
|
u_int16_t* track, u_int16_t* totalTracks);
|
|
bool MP4DeleteMetadataTrack(MP4FileHandle hFile);
|
|
bool MP4SetMetadataDisk(MP4FileHandle hFile,
|
|
u_int16_t disk, u_int16_t totalDisks);
|
|
bool MP4GetMetadataDisk(MP4FileHandle hFile,
|
|
u_int16_t* disk, u_int16_t* totalDisks);
|
|
bool MP4DeleteMetadataDisk(MP4FileHandle hFile);
|
|
bool MP4SetMetadataGenre(MP4FileHandle hFile, const char *genre);
|
|
bool MP4GetMetadataGenre(MP4FileHandle hFile, char **genre);
|
|
bool MP4DeleteMetadataGenre(MP4FileHandle hFile);
|
|
bool MP4SetMetadataGrouping(MP4FileHandle hFile, const char *grouping);
|
|
bool MP4GetMetadataGrouping(MP4FileHandle hFile, char **grouping);
|
|
bool MP4DeleteMetadataGrouping(MP4FileHandle hFile);
|
|
bool MP4SetMetadataTempo(MP4FileHandle hFile, u_int16_t tempo);
|
|
bool MP4GetMetadataTempo(MP4FileHandle hFile, u_int16_t* tempo);
|
|
bool MP4DeleteMetadataTempo(MP4FileHandle hFile);
|
|
bool MP4SetMetadataCompilation(MP4FileHandle hFile, u_int8_t cpl);
|
|
bool MP4GetMetadataCompilation(MP4FileHandle hFile, u_int8_t* cpl);
|
|
bool MP4DeleteMetadataCompilation(MP4FileHandle hFile);
|
|
bool MP4SetMetadataPartOfGaplessAlbum(MP4FileHandle hFile, uint8_t pgap);
|
|
bool MP4GetMetadataPartOfGaplessAlbum(MP4FileHandle hFile, uint8_t *pgap);
|
|
bool MP4DeleteMetadataPartOfGaplessAlbum(MP4FileHandle hFile);
|
|
bool MP4SetMetadataCoverArt(MP4FileHandle hFile, u_int8_t *coverArt, u_int32_t size, int flags);
|
|
bool MP4GetMetadataCoverArt(MP4FileHandle hFile, u_int8_t **coverArt, u_int32_t* size, int *flags, uint32_t index DEFAULT(0));
|
|
u_int32_t MP4GetMetadataCoverArtCount(MP4FileHandle hFile);
|
|
bool MP4DeleteMetadataCoverArt(MP4FileHandle hFile);
|
|
bool MP4SetMetadataAlbumArtist(MP4FileHandle hFile, const char* value);
|
|
bool MP4GetMetadataAlbumArtist(MP4FileHandle hFile, char** value);
|
|
bool MP4DeleteMetadataAlbumArtist(MP4FileHandle hFile);
|
|
|
|
|
|
bool MP4SetMetadataFreeForm(MP4FileHandle hFile, const char *name,
|
|
const u_int8_t* pValue, u_int32_t valueSize, const char *owner DEFAULT(NULL));
|
|
bool MP4GetMetadataFreeForm(MP4FileHandle hFile, const char *name,
|
|
u_int8_t** pValue, u_int32_t* valueSize, const char *owner DEFAULT(NULL));
|
|
bool MP4DeleteMetadataFreeForm(MP4FileHandle hFile, const char *name, const char *owner DEFAULT(NULL));
|
|
|
|
bool MP4Get3GPMetadata(MP4FileHandle hFile, const char *name, uint16_t **value);
|
|
bool MP4Set3GPMetadata(MP4FileHandle hFile, const char *name, const uint16_t* value);
|
|
bool MP4Get3GPMetadataInteger(MP4FileHandle hFile, const char *name, uint64_t *value);
|
|
bool MP4Set3GPMetadataInteger(MP4FileHandle hFile, const char *name, uint64_t value);
|
|
bool MP4Delete3GPMetadata(MP4FileHandle hFile, const char *name);
|
|
|
|
/* time conversion utilties */
|
|
|
|
/* predefined values for timeScale parameter below */
|
|
#define MP4_SECONDS_TIME_SCALE 1
|
|
#define MP4_MILLISECONDS_TIME_SCALE 1000
|
|
#define MP4_MICROSECONDS_TIME_SCALE 1000000
|
|
#define MP4_NANOSECONDS_TIME_SCALE 1000000000
|
|
|
|
#define MP4_SECS_TIME_SCALE MP4_SECONDS_TIME_SCALE
|
|
#define MP4_MSECS_TIME_SCALE MP4_MILLISECONDS_TIME_SCALE
|
|
#define MP4_USECS_TIME_SCALE MP4_MICROSECONDS_TIME_SCALE
|
|
#define MP4_NSECS_TIME_SCALE MP4_NANOSECONDS_TIME_SCALE
|
|
|
|
u_int64_t MP4ConvertFromMovieDuration(
|
|
MP4FileHandle hFile,
|
|
MP4Duration duration,
|
|
u_int32_t timeScale);
|
|
|
|
u_int64_t MP4ConvertFromTrackTimestamp(
|
|
MP4FileHandle hFile,
|
|
MP4TrackId trackId,
|
|
MP4Timestamp timeStamp,
|
|
u_int32_t timeScale);
|
|
|
|
MP4Timestamp MP4ConvertToTrackTimestamp(
|
|
MP4FileHandle hFile,
|
|
MP4TrackId trackId,
|
|
u_int64_t timeStamp,
|
|
u_int32_t timeScale);
|
|
|
|
u_int64_t MP4ConvertFromTrackDuration(
|
|
MP4FileHandle hFile,
|
|
MP4TrackId trackId,
|
|
MP4Duration duration,
|
|
u_int32_t timeScale);
|
|
|
|
MP4Duration MP4ConvertToTrackDuration(
|
|
MP4FileHandle hFile,
|
|
MP4TrackId trackId,
|
|
u_int64_t duration,
|
|
u_int32_t timeScale);
|
|
|
|
char* MP4BinaryToBase16(
|
|
const u_int8_t* pData,
|
|
u_int32_t dataSize);
|
|
|
|
char* MP4BinaryToBase64(
|
|
const u_int8_t* pData,
|
|
u_int32_t dataSize);
|
|
|
|
uint8_t *Base64ToBinary(const char *pData,
|
|
uint32_t decodeSize,
|
|
uint32_t *pDataSize);
|
|
void MP4Free(void *p);
|
|
|
|
char* MP4PrintAudioInfo(
|
|
MP4FileHandle mp4File,
|
|
MP4TrackId trackId);
|
|
|
|
char* MP4PrintVideoInfo(
|
|
MP4FileHandle mp4File,
|
|
MP4TrackId trackId);
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
/* undefined our utlity macro to avoid conflicts */
|
|
#undef DEFAULT
|
|
|
|
#endif /* __MP4_INCLUDED__ */
|