int GetAACTrack(MP4FileHandle infile)
{
// find AAC track
int i, rc;
int numTracks = MP4GetNumberOfTracks(infile, NULL, 0);
for (i = 0; i < numTracks; i++)
{
MP4TrackId trackId = MP4FindTrackId(infile, i, NULL, 0);
const char* trackType = MP4GetTrackType(infile, trackId);
if (!strcmp(trackType, MP4_AUDIO_TRACK_TYPE))
{
unsigned char *buff = NULL;
unsigned __int32 buff_size = 0;
mp4AudioSpecificConfig mp4ASC;
MP4GetTrackESConfiguration(infile, trackId, (unsigned __int8 **)&buff, &buff_size);
if (buff)
{
rc = AudioSpecificConfig(buff, buff_size, &mp4ASC);
free(buff);
if (rc < 0)
return -1;
return trackId;
}
}
}
// can't decode this
return -1;
}
/** Finds a suitable track that can reference a chapter track.
*
* This function returns the first video or audio track that is found
* in the <b>file</b>.
* This track ca be used to reference the QuickTime chapter track.
*
* @param file the opened MP4 file
* @param isVideoTrack receives true if the found track is video, false otherwise
* @return the <b>MP4TrackId</b> of the found track
*/
MP4TrackId
ChapterUtility::getReferencingTrack( MP4FileHandle file, bool& isVideoTrack )
{
isVideoTrack = false;
uint32_t trackCount = MP4GetNumberOfTracks( file );
if( 0 == trackCount )
{
return MP4_INVALID_TRACK_ID;
}
MP4TrackId refTrackId = MP4_INVALID_TRACK_ID;
for( uint32_t i = 0; i < trackCount; ++i )
{
MP4TrackId id = MP4FindTrackId( file, i );
const char* type = MP4GetTrackType( file, id );
if( MP4_IS_VIDEO_TRACK_TYPE( type ) )
{
refTrackId = id;
isVideoTrack = true;
break;
}
else if( MP4_IS_AUDIO_TRACK_TYPE( type ) )
{
refTrackId = id;
break;
}
}
return refTrackId;
}
extern "C" char* MP4Info(
MP4FileHandle mp4File,
MP4TrackId trackId)
{
char* info = NULL;
if (MP4_IS_VALID_FILE_HANDLE(mp4File)) {
try {
if (trackId == MP4_INVALID_TRACK_ID) {
uint buflen = 4 * 1024;
info = (char*)MP4Calloc(buflen);
buflen -= snprintf(info, buflen,
"Track\tType\tInfo\n");
u_int32_t numTracks = MP4GetNumberOfTracks(mp4File);
for (u_int32_t i = 0; i < numTracks; i++) {
trackId = MP4FindTrackId(mp4File, i);
char* trackInfo = PrintTrackInfo(mp4File, trackId);
strncat(info, trackInfo, buflen);
uint newlen = wcslen(trackInfo);
if (newlen > buflen) buflen = 0;
else buflen -= newlen;
MP4Free(trackInfo);
}
} else {
info = PrintTrackInfo(mp4File, trackId);
}
}
catch (MP4Error* e) {
delete e;
}
}
return info;
}
int CMp4File::create_media (CPlayerSession *psptr,
int have_audio_driver,
control_callback_vft_t *cc_vft)
{
uint video_count, video_offset;
uint text_count, text_offset;
uint audio_count, audio_offset;
MP4TrackId trackId;
video_query_t *vq;
audio_query_t *aq;
text_query_t *tq;
uint ix;
codec_plugin_t *plugin;
int ret_value = 0;
uint8_t *foo;
u_int32_t bufsize;
uint32_t verb = MP4GetVerbosity(m_mp4file);
MP4SetVerbosity(m_mp4file, verb & ~(MP4_DETAILS_ERROR));
video_count = MP4GetNumberOfTracks(m_mp4file, MP4_VIDEO_TRACK_TYPE);
audio_count = MP4GetNumberOfTracks(m_mp4file, MP4_AUDIO_TRACK_TYPE);
text_count = MP4GetNumberOfTracks(m_mp4file, MP4_CNTL_TRACK_TYPE);
mp4f_message(LOG_DEBUG, "cntl tracks %u", text_count);
MP4SetVerbosity(m_mp4file, verb);
if (video_count == 0 && audio_count == 0 && text_count == 0) {
psptr->set_message("No audio, video or control tracks in file");
return -1;
}
if (video_count > 0) {
vq = (video_query_t *)malloc(sizeof(video_query_t) * video_count);
memset(vq, 0, sizeof(video_query_t) * video_count);
} else {
vq = NULL;
}
if (have_audio_driver && audio_count > 0) {
aq = (audio_query_t *)malloc(sizeof(audio_query_t) * audio_count);
memset(aq, 0, sizeof(audio_query_t) * audio_count);
} else {
aq = NULL;
}
if (text_count > 0) {
tq = (text_query_t *)malloc(sizeof(text_query_t) * text_count);
memset(tq, 0, sizeof(text_query_t) * text_count);
} else {
tq = NULL;
}
for (ix = 0, video_offset = 0; ix < video_count; ix++) {
trackId = MP4FindTrackId(m_mp4file, ix, MP4_VIDEO_TRACK_TYPE);
const char *media_data_name;
media_data_name = MP4GetTrackMediaDataName(m_mp4file, trackId);
// for now, treat mp4v and encv the same
vq[video_offset].track_id = trackId;
vq[video_offset].stream_type = STREAM_TYPE_MP4_FILE;
vq[video_offset].compressor = media_data_name;
if (strcasecmp(media_data_name, "mp4v") == 0 ||
strcasecmp(media_data_name, "encv") == 0) {
uint8_t video_type = MP4GetTrackEsdsObjectTypeId(m_mp4file, trackId);
uint8_t profileID = MP4GetVideoProfileLevel(m_mp4file, trackId);
mp4f_message(LOG_DEBUG, "MP4 - got track %x profile ID %d",
trackId, profileID);
MP4SetVerbosity(m_mp4file, verb & ~(MP4_DETAILS_ERROR));
MP4GetTrackESConfiguration(m_mp4file, trackId, &foo, &bufsize);
MP4SetVerbosity(m_mp4file, verb);
vq[video_offset].type = video_type;
vq[video_offset].profile = profileID;
vq[video_offset].fptr = NULL;
vq[video_offset].config = foo;
vq[video_offset].config_len = bufsize;
} else if (strcasecmp(media_data_name, "avc1") == 0) {
uint8_t profile, level;
uint8_t **seqheader, **pictheader;
uint32_t *pictheadersize, *seqheadersize;
uint32_t ix;
MP4GetTrackH264ProfileLevel(m_mp4file, trackId, &profile, &level);
MP4GetTrackH264SeqPictHeaders(m_mp4file, trackId,
&seqheader, &seqheadersize,
&pictheader, &pictheadersize);
bufsize = 0;
for (ix = 0; seqheadersize[ix] != 0; ix++) {
bufsize += seqheadersize[ix] + 4;
}
for (ix = 0; pictheadersize[ix] != 0; ix++) {
bufsize += pictheadersize[ix] + 4;
}
foo = (uint8_t *)malloc(bufsize + 4);
memset(foo, 0, bufsize + 4);
uint32_t copied = 0;
// headers do not have the byte stream start code stored in the file
for (ix = 0; seqheadersize[ix] != 0; ix++) {
foo[copied] = 0;
foo[copied + 1] = 0;
foo[copied + 2] = 0;
foo[copied + 3] = 1;
copied += 4; // add header
memcpy(foo + copied,
seqheader[ix],
seqheadersize[ix]);
copied += seqheadersize[ix];
free(seqheader[ix]);
}
free(seqheader);
free(seqheadersize);
for (ix = 0; pictheadersize[ix] != 0; ix++) {
foo[copied] = 0;
foo[copied + 1] = 0;
foo[copied + 2] = 0;
foo[copied + 3] = 1;
copied += 4; // add header
memcpy(foo + copied,
pictheader[ix],
pictheadersize[ix]);
copied += pictheadersize[ix];
free(pictheader[ix]);
}
free(pictheader);
free(pictheadersize);
vq[video_offset].type = level;
vq[video_offset].profile = profile;
vq[video_offset].fptr = NULL;
vq[video_offset].config = foo;
vq[video_offset].config_len = bufsize;
} else {
MP4GetTrackVideoMetadata(m_mp4file, trackId, &foo, &bufsize);
vq[video_offset].config = foo;
vq[video_offset].config_len = bufsize;
}
plugin = check_for_video_codec(vq[video_offset].stream_type,
vq[video_offset].compressor,
NULL,
vq[video_offset].type,
vq[video_offset].profile,
vq[video_offset].config,
vq[video_offset].config_len,
&config);
if (plugin == NULL) {
psptr->set_message("Can't find plugin for video %s type %d, profile %d",
vq[video_offset].compressor,
vq[video_offset].type,
vq[video_offset].profile);
m_illegal_video_codec++;
ret_value = 1;
// possibly memleak for foo here
} else {
vq[video_offset].h = MP4GetTrackVideoHeight(m_mp4file, trackId);
vq[video_offset].w = MP4GetTrackVideoWidth(m_mp4file, trackId);
vq[video_offset].frame_rate = MP4GetTrackVideoFrameRate(m_mp4file, trackId);
vq[video_offset].enabled = 0;
vq[video_offset].reference = NULL;
video_offset++;
}
}
audio_offset = 0;
if (have_audio_driver) {
for (ix = 0; ix < audio_count; ix++) {
trackId = MP4FindTrackId(m_mp4file, ix, MP4_AUDIO_TRACK_TYPE);
const char *media_data_name;
media_data_name = MP4GetTrackMediaDataName(m_mp4file, trackId);
aq[audio_offset].track_id = trackId;
aq[audio_offset].stream_type = STREAM_TYPE_MP4_FILE;
aq[audio_offset].compressor = media_data_name;
if (strcasecmp(media_data_name, "mp4a") == 0 ||
strcasecmp(media_data_name, "enca") == 0) {
uint8_t *userdata = NULL;
u_int32_t userdata_size;
aq[audio_offset].type = MP4GetTrackEsdsObjectTypeId(m_mp4file, trackId);
MP4SetVerbosity(m_mp4file, verb & ~(MP4_DETAILS_ERROR));
aq[audio_offset].profile = MP4GetAudioProfileLevel(m_mp4file);
MP4GetTrackESConfiguration(m_mp4file,
trackId,
&userdata,
&userdata_size);
MP4SetVerbosity(m_mp4file, verb);
aq[audio_offset].config = userdata;
aq[audio_offset].config_len = userdata_size;
}
plugin = check_for_audio_codec(aq[audio_offset].stream_type,
aq[audio_offset].compressor,
NULL,
aq[audio_offset].type,
aq[audio_offset].profile,
aq[audio_offset].config,
aq[audio_offset].config_len,
&config);
if (plugin != NULL) {
aq[audio_offset].fptr = NULL;
aq[audio_offset].sampling_freq =
MP4GetTrackTimeScale(m_mp4file, trackId);
MP4SetVerbosity(m_mp4file, verb & ~(MP4_DETAILS_ERROR));
aq[audio_offset].chans = MP4GetTrackAudioChannels(m_mp4file, trackId);
MP4SetVerbosity(m_mp4file, verb);
aq[audio_offset].enabled = 0;
aq[audio_offset].reference = NULL;
audio_offset++;
m_have_audio = true;
} else {
m_illegal_audio_codec++;
ret_value = 1;
}
}
} else {
if (audio_count)
ret_value = 1;
}
text_offset = 0;
for (ix = 0; ix < text_count; ix++) {
trackId = MP4FindTrackId(m_mp4file, ix, MP4_CNTL_TRACK_TYPE);
const char *media_data_name;
media_data_name = MP4GetTrackMediaDataName(m_mp4file, trackId);
tq[text_offset].track_id = trackId;
tq[text_offset].stream_type = STREAM_TYPE_MP4_FILE;
tq[text_offset].compressor = media_data_name;
plugin = check_for_text_codec(tq[text_offset].stream_type,
tq[text_offset].compressor,
NULL,
NULL,
0,
&config);
if (plugin != NULL) {
tq[text_offset].fptr = NULL;
tq[text_offset].enabled = 0;
tq[text_offset].reference = NULL;
text_offset++;
} else {
m_illegal_text_codec++;
ret_value = 1;
}
}
if (video_offset == 0 && audio_offset == 0 && text_offset == 0) {
psptr->set_message("No playable codecs in mp4 file");
return -1;
}
if (cc_vft && cc_vft->media_list_query != NULL) {
(cc_vft->media_list_query)(psptr, video_offset, vq, audio_offset, aq, text_offset, tq);
} else {
if (video_offset > 0) {
vq[0].enabled = 1;
}
if (audio_offset > 0) {
aq[0].enabled = 1;
}
if (text_offset > 0) {
tq[0].enabled = 1;
}
}
int vidret, audret, textret;
uint start_desc = 1;
vidret = create_video(psptr, vq, video_offset, start_desc);
free(vq);
if (vidret < 0) {
free(aq);
free(tq);
return -1;
}
audret = create_audio(psptr, aq, audio_offset, start_desc);
free(aq);
textret = create_text(psptr, tq, text_offset, start_desc);
free(tq);
if (audret < 0 || textret < 0) ret_value = -1;
char *name;
verb = MP4GetVerbosity(m_mp4file);
MP4SetVerbosity(m_mp4file, verb & ~(MP4_DETAILS_ERROR));
if (MP4GetMetadataName(m_mp4file, &name) &&
name != NULL) {
psptr->set_session_desc(0, name);
free(name);
}
MP4SetVerbosity(m_mp4file, verb);
return (ret_value);
}
MP4TrackId Mp4vCreator(MP4FileHandle mp4File, FILE* inFile, bool doEncrypt,
bool allowVariableFrameRate)
{
bool rc;
u_int8_t sampleBuffer[256 * 1024 * 2];
u_int8_t* pCurrentSample = sampleBuffer;
u_int32_t maxSampleSize = sizeof(sampleBuffer) / 2;
u_int32_t prevSampleSize = 0;
// the current syntactical object
// typically 1:1 with a sample
// but not always, i.e. non-VOP's
u_int8_t* pObj = pCurrentSample;
u_int32_t objSize;
u_int8_t objType;
// the current sample
MP4SampleId sampleId = 1;
MP4Timestamp currentSampleTime = 0;
// the last reference VOP
MP4SampleId refVopId = 1;
MP4Timestamp refVopTime = 0;
// track configuration info
u_int8_t videoProfileLevel = MPEG4_SP_L3;
u_int8_t timeBits = 15;
u_int16_t timeTicks = 30000;
u_int16_t frameDuration = 3000;
u_int16_t frameWidth = 320;
u_int16_t frameHeight = 240;
u_int32_t esConfigSize = 0;
int vopType = 0;
int prevVopType = 0;
bool foundVOSH = false, foundVO = false, foundVOL = false;
u_int32_t lastVopTimeIncrement = 0;
bool variableFrameRate = false;
bool lastFrame = false;
bool haveBframes = false;
mpeg4_frame_t *head = NULL, *tail = NULL;
// start reading objects until we get the first VOP
while (LoadNextObject(inFile, pObj, &objSize, &objType)) {
// guard against buffer overflow
if (pObj + objSize >= pCurrentSample + maxSampleSize) {
fprintf(stderr,
"%s: buffer overflow, invalid video stream?\n", ProgName);
return MP4_INVALID_TRACK_ID;
}
#ifdef DEBUG_MP4V
if (Verbosity & MP4_DETAILS_SAMPLE) {
printf("MP4V type %x size %u\n",
objType, objSize);
}
#endif
if (objType == MP4AV_MPEG4_VOSH_START) {
MP4AV_Mpeg4ParseVosh(pObj, objSize,
&videoProfileLevel);
foundVOSH = true;
} else if (objType == MP4AV_MPEG4_VO_START) {
foundVO = true;
} else if (objType == MP4AV_MPEG4_VOL_START) {
MP4AV_Mpeg4ParseVol(pObj, objSize,
&timeBits, &timeTicks, &frameDuration,
&frameWidth, &frameHeight);
foundVOL = true;
#ifdef DEBUG_MP4V
printf("ParseVol: timeBits %u timeTicks %u frameDuration %u\n",
timeBits, timeTicks, frameDuration);
#endif
} else if (foundVOL == true || objType == MP4AV_MPEG4_VOP_START) {
esConfigSize = pObj - pCurrentSample;
// ready to set up mp4 track
break;
}
/* XXX why do we need this if ?
* It looks like it will remove this object ... XXX */
// It does. On Purpose. wmay 6/2004
if (objType != MP4AV_MPEG4_USER_DATA_START) {
pObj += objSize;
}
}
if (foundVOSH == false) {
fprintf(stderr,
"%s: no VOSH header found in MPEG-4 video.\n"
"This can cause problems with players other than mp4player. \n",
ProgName);
} else {
if (VideoProfileLevelSpecified &&
videoProfileLevel != VideoProfileLevel) {
fprintf(stderr,
"%s: You have specified a different video profile level than was detected in the VOSH header\n"
"The level you specified was %d and %d was read from the VOSH\n",
ProgName, VideoProfileLevel, videoProfileLevel);
}
}
if (foundVO == false) {
fprintf(stderr,
"%s: No VO header found in mpeg-4 video.\n"
"This can cause problems with players other than mp4player\n",
ProgName);
}
if (foundVOL == false) {
fprintf(stderr,
"%s: fatal: No VOL header found in mpeg-4 video stream\n",
ProgName);
return MP4_INVALID_TRACK_ID;
}
// convert frame duration to canonical time scale
// note zero value for frame duration signals variable rate video
if (timeTicks == 0) {
timeTicks = 1;
}
u_int32_t mp4FrameDuration = 0;
if (VideoFrameRate) {
mp4FrameDuration = (u_int32_t)(((double)Mp4TimeScale) / VideoFrameRate);
} else if (frameDuration) {
VideoFrameRate = frameDuration;
VideoFrameRate /= timeTicks;
mp4FrameDuration = (Mp4TimeScale * frameDuration) / timeTicks;
} else {
if (allowVariableFrameRate == false ) {
fprintf(stderr,
"%s: variable rate video stream signalled,"
" please specify average frame rate with -r option\n"
" or --variable-frame-rate argument\n",
ProgName);
return MP4_INVALID_TRACK_ID;
}
variableFrameRate = true;
}
ismacryp_session_id_t ismaCrypSId;
mp4v2_ismacrypParams *icPp = (mp4v2_ismacrypParams *) malloc(sizeof(mp4v2_ismacrypParams));
memset(icPp, 0, sizeof(mp4v2_ismacrypParams));
// initialize ismacryp session if encrypting
if (doEncrypt) {
if (ismacrypInitSession(&ismaCrypSId,KeyTypeVideo) != 0) {
fprintf(stderr, "%s: could not initialize the ISMAcryp session\n",
ProgName);
return MP4_INVALID_TRACK_ID;
}
if (ismacrypGetScheme(ismaCrypSId, &(icPp->scheme_type)) != ismacryp_rc_ok) {
fprintf(stderr, "%s: could not get ismacryp scheme type. sid %d\n",
ProgName, ismaCrypSId);
ismacrypEndSession(ismaCrypSId);
return MP4_INVALID_TRACK_ID;
}
if (ismacrypGetSchemeVersion(ismaCrypSId, &(icPp->scheme_version)) != ismacryp_rc_ok) {
fprintf(stderr, "%s: could not get ismacryp scheme ver. sid %d\n",
ProgName, ismaCrypSId);
ismacrypEndSession(ismaCrypSId);
return MP4_INVALID_TRACK_ID;
}
if (ismacrypGetKMSUri(ismaCrypSId, &(icPp->kms_uri)) != ismacryp_rc_ok) {
fprintf(stderr, "%s: could not get ismacryp kms uri. sid %d\n",
ProgName, ismaCrypSId);
CHECK_AND_FREE(icPp->kms_uri);
ismacrypEndSession(ismaCrypSId);
return MP4_INVALID_TRACK_ID;
}
if ( ismacrypGetSelectiveEncryption(ismaCrypSId, &(icPp->selective_enc)) != ismacryp_rc_ok ) {
fprintf(stderr, "%s: could not get ismacryp selec enc. sid %d\n",
ProgName, ismaCrypSId);
ismacrypEndSession(ismaCrypSId);
return MP4_INVALID_TRACK_ID;
}
if (ismacrypGetKeyIndicatorLength(ismaCrypSId, &(icPp->key_ind_len)) != ismacryp_rc_ok) {
fprintf(stderr, "%s: could not get ismacryp key ind len. sid %d\n",
ProgName, ismaCrypSId);
ismacrypEndSession(ismaCrypSId);
return MP4_INVALID_TRACK_ID;
}
if (ismacrypGetIVLength(ismaCrypSId, &(icPp->iv_len)) != ismacryp_rc_ok) {
fprintf(stderr, "%s: could not get ismacryp iv len. sid %d\n",
ProgName, ismaCrypSId);
ismacrypEndSession(ismaCrypSId);
return MP4_INVALID_TRACK_ID;
}
}
// create the new video track
MP4TrackId trackId;
if (doEncrypt) {
trackId =
MP4AddEncVideoTrack(
mp4File,
Mp4TimeScale,
mp4FrameDuration,
frameWidth,
frameHeight,
icPp,
MP4_MPEG4_VIDEO_TYPE);
} else {
trackId =
MP4AddVideoTrack(
mp4File,
Mp4TimeScale,
mp4FrameDuration,
frameWidth,
frameHeight,
MP4_MPEG4_VIDEO_TYPE);
}
if (trackId == MP4_INVALID_TRACK_ID) {
fprintf(stderr,
"%s: can't create video track\n", ProgName);
return MP4_INVALID_TRACK_ID;
}
if (VideoProfileLevelSpecified) {
videoProfileLevel = VideoProfileLevel;
}
if (MP4GetNumberOfTracks(mp4File, MP4_VIDEO_TRACK_TYPE) == 1) {
MP4SetVideoProfileLevel(mp4File, videoProfileLevel);
}
printf("es config size is %d\n", esConfigSize);
if (esConfigSize) {
MP4SetTrackESConfiguration(mp4File, trackId,
pCurrentSample, esConfigSize);
// move past ES config, so it doesn't go into first sample
pCurrentSample += esConfigSize;
}
// Move the current frame to the beginning of the
// buffer
memmove(sampleBuffer, pCurrentSample, pObj - pCurrentSample + objSize);
pObj = sampleBuffer + (pObj - pCurrentSample);
pCurrentSample = sampleBuffer;
MP4Timestamp prevFrameTimestamp = 0;
// now process the rest of the video stream
while ( true ) {
if ( objType != MP4AV_MPEG4_VOP_START ) {
// keep it in the buffer until a VOP comes along
// Actually, do nothings, since we only want VOP
// headers in the stream - wmay 6/2004
//pObj += objSize;
} else { // we have VOP
u_int32_t sampleSize = (pObj + objSize) - pCurrentSample;
vopType = MP4AV_Mpeg4GetVopType(pObj, objSize);
mpeg4_frame_t *fr = MALLOC_STRUCTURE(mpeg4_frame_t);
if (head == NULL) {
head = tail = fr;
} else {
tail->next = fr;
tail = fr;
}
fr->vopType = vopType;
fr->frameTimestamp = currentSampleTime;
fr->next = NULL;
if ( variableFrameRate ) {
// variable frame rate: recalculate "mp4FrameDuration"
if ( lastFrame ) {
// last frame
mp4FrameDuration = Mp4TimeScale / timeTicks;
} else {
// not the last frame
u_int32_t vopTimeIncrement;
MP4AV_Mpeg4ParseVop(pObj, objSize, &vopType, timeBits, timeTicks, &vopTimeIncrement);
u_int32_t vopTime = vopTimeIncrement - lastVopTimeIncrement;
mp4FrameDuration = (Mp4TimeScale * vopTime) / timeTicks;
lastVopTimeIncrement = vopTimeIncrement % timeTicks;
}
}
if ( prevSampleSize > 0 ) { // not the first time
// fill sample data & length to write
u_int8_t* sampleData2Write = NULL;
u_int32_t sampleLen2Write = 0;
if ( doEncrypt ) {
if ( ismacrypEncryptSampleAddHeader(ismaCrypSId,
sampleSize,
sampleBuffer,
&sampleLen2Write,
&sampleData2Write) != 0 ) {
fprintf(stderr,
"%s: can't encrypt video sample and add header %u\n",
ProgName, sampleId);
}
} else {
sampleData2Write = sampleBuffer;
sampleLen2Write = prevSampleSize;
}
if (variableFrameRate == false) {
double now_calc;
now_calc = sampleId;
now_calc *= Mp4TimeScale;
now_calc /= VideoFrameRate;
MP4Timestamp now_ts = (MP4Timestamp)now_calc;
mp4FrameDuration = now_ts - prevFrameTimestamp;
prevFrameTimestamp = now_ts;
currentSampleTime = now_ts;
}
// Write the previous sample
rc = MP4WriteSample(mp4File, trackId,
sampleData2Write, sampleLen2Write,
mp4FrameDuration, 0, prevVopType == VOP_TYPE_I);
if ( doEncrypt && sampleData2Write ) {
// buffer allocated by encrypt function.
// must free it!
free(sampleData2Write);
}
if ( !rc ) {
fprintf(stderr,
"%s: can't write video frame %u\n",
ProgName, sampleId);
MP4DeleteTrack(mp4File, trackId);
return MP4_INVALID_TRACK_ID;
}
// deal with rendering time offsets
// that can occur when B frames are being used
// which is the case for all profiles except Simple Profile
haveBframes |= (prevVopType == VOP_TYPE_B);
if ( lastFrame ) {
// finish read frames
break;
}
sampleId++;
} // not the first time
currentSampleTime += mp4FrameDuration;
// Move the current frame to the beginning of the
// buffer
memmove(sampleBuffer, pCurrentSample, sampleSize);
prevSampleSize = sampleSize;
prevVopType = vopType;
// reset pointers
pObj = pCurrentSample = sampleBuffer + sampleSize;
} // we have VOP
// load next object from bitstream
if (!LoadNextObject(inFile, pObj, &objSize, &objType)) {
if (objType != MP4AV_MPEG4_VOP_START)
break;
lastFrame = true;
objSize = 0;
continue;
}
// guard against buffer overflow
if (pObj + objSize >= pCurrentSample + maxSampleSize) {
fprintf(stderr,
"%s: buffer overflow, invalid video stream?\n", ProgName);
MP4DeleteTrack(mp4File, trackId);
return MP4_INVALID_TRACK_ID;
}
#ifdef DEBUG_MP4V
if (Verbosity & MP4_DETAILS_SAMPLE) {
printf("MP4V type %x size %u\n",
objType, objSize);
}
#endif
}
bool doRenderingOffset = false;
switch (videoProfileLevel) {
case MPEG4_SP_L0:
case MPEG4_SP_L1:
case MPEG4_SP_L2:
case MPEG4_SP_L3:
break;
default:
doRenderingOffset = true;
break;
}
if (doRenderingOffset && haveBframes) {
// only generate ctts (with rendering offset for I, P frames) when
// we need one. We saved all the frames types and timestamps above -
// we can't use MP4ReadSample, because the end frames might not have
// been written
refVopId = 1;
refVopTime = 0;
MP4SampleId maxSamples = MP4GetTrackNumberOfSamples(mp4File, trackId);
// start with sample 2 - we know the first one is a I frame
mpeg4_frame_t *fr = head->next; // skip the first one
for (MP4SampleId ix = 2; ix <= maxSamples; ix++) {
if (fr->vopType != VOP_TYPE_B) {
#ifdef DEBUG_MP4V_TS
printf("sample %u %u renderingOffset "U64"\n",
refVopId, fr->vopType, fr->frameTimestamp - refVopTime);
#endif
MP4SetSampleRenderingOffset(mp4File, trackId, refVopId,
fr->frameTimestamp - refVopTime);
refVopId = ix;
refVopTime = fr->frameTimestamp;
}
fr = fr->next;
}
#ifdef DEBUG_MP4V_TS
printf("sample %u %u renderingOffset "U64"\n",
refVopId, fr->vopType, fr->frameTimestamp - refVopTime);
#endif
MP4SetSampleRenderingOffset(mp4File, trackId, refVopId,
fr->frameTimestamp - refVopTime);
}
while (head != NULL) {
tail = head->next;
free(head);
head = tail;
}
// terminate session if encrypting
if (doEncrypt) {
if (ismacrypEndSession(ismaCrypSId) != 0) {
fprintf(stderr,
"%s: could not end the ISMAcryp session\n",
ProgName);
}
}
return trackId;
}
int main(int argc, char** argv)
{
const char* usageString =
"[options] mp4file where:\n"
"\t--track(-t)= <track-id> - display track id\n"
"\t--dump-offset(-d) - dump offset within sample\n"
"\t--rendering-offset(-r) - dump rendering offset\n"
"\t--verbose=<level> - mp4 file verbosity\n"
"\t--version(-V) - display version\n";
MP4TrackId trackId = MP4_INVALID_TRACK_ID;
u_int32_t verbosity = MP4_DETAILS_ERROR;
bool dump_offset = false;
bool dump_rend = false;
/* begin processing command line */
ProgName = argv[0];
while (true) {
int c = -1;
int option_index = 0;
static struct option long_options[] = {
{ "track", 1, 0, 't' },
{ "verbose", 2, 0, 'v' },
{ "version", 0, 0, 'V' },
{ "dump-offset", 0, 0, 'd'},
{ "rendering-offset", 0, 0, 'r'},
{ "help", 0, 0, '?'},
{ NULL, 0, 0, 0 }
};
c = getopt_long_only(argc, argv, "t:v::V?",
long_options, &option_index);
if (c == -1)
break;
switch (c) {
case 'd': dump_offset = true; break;
case 'r': dump_rend = true; break;
case 't':
if (sscanf(optarg, "%u", &trackId) != 1) {
fprintf(stderr,
"%s: bad track-id specified: %s\n",
ProgName, optarg);
exit(1);
}
break;
case 'v':
verbosity |= MP4_DETAILS_READ;
if (optarg) {
u_int32_t level;
if (sscanf(optarg, "%u", &level) == 1) {
if (level >= 2) {
verbosity |= MP4_DETAILS_TABLE;
}
if (level >= 3) {
verbosity |= MP4_DETAILS_SAMPLE;
}
if (level >= 4) {
verbosity = MP4_DETAILS_ALL;
}
}
}
break;
case '?':
fprintf(stderr, "usage: %s %s", ProgName, usageString);
exit(0);
case 'V':
fprintf(stderr, "%s - %s version %s\n",
ProgName, MPEG4IP_PACKAGE, MPEG4IP_VERSION);
exit(0);
default:
fprintf(stderr, "%s: unknown option specified, ignoring: %c\n",
ProgName, c);
}
}
/* check that we have at least one non-option argument */
if ((argc - optind) < 1) {
fprintf(stderr, "usage: %s %s", ProgName, usageString);
exit(1);
}
if (verbosity) {
fprintf(stderr, "%s version %s\n", ProgName, MPEG4IP_VERSION);
}
/* point to the specified file names */
Mp4PathName = argv[optind++];
char* lastSlash = strrchr(Mp4PathName, '/');
if (lastSlash) {
Mp4FileName = lastSlash + 1;
} else {
Mp4FileName = Mp4PathName;
}
/* warn about extraneous non-option arguments */
if (optind < argc) {
fprintf(stderr, "%s: unknown options specified, ignoring: ", ProgName);
while (optind < argc) {
fprintf(stderr, "%s ", argv[optind++]);
}
fprintf(stderr, "\n");
}
/* end processing of command line */
MP4FileHandle mp4File = MP4Read(Mp4PathName, verbosity);
if (!mp4File) {
exit(1);
}
if (trackId == MP4_INVALID_TRACK_ID) {
u_int32_t numTracks = MP4GetNumberOfTracks(mp4File, MP4_VIDEO_TRACK_TYPE);
printf("tracks %d\n", numTracks);
for (u_int32_t ix = 0; ix < numTracks; ix++) {
trackId = MP4FindTrackId(mp4File, ix, MP4_VIDEO_TRACK_TYPE);
DumpTrack(mp4File, trackId, dump_offset, dump_rend);
}
} else {
DumpTrack(mp4File, trackId, dump_offset, dump_rend);
}
MP4Close(mp4File);
return(0);
}
bool MP4Metadata::ReadMetadata(CFErrorRef *error)
{
// Start from scratch
CFDictionaryRemoveAllValues(mMetadata);
CFDictionaryRemoveAllValues(mChangedMetadata);
UInt8 buf [PATH_MAX];
if(!CFURLGetFileSystemRepresentation(mURL, FALSE, buf, PATH_MAX))
return false;
// Open the file for reading
MP4FileHandle file = MP4Read(reinterpret_cast<const char *>(buf));
if(MP4_INVALID_FILE_HANDLE == file) {
if(error) {
CFMutableDictionaryRef errorDictionary = CFDictionaryCreateMutable(kCFAllocatorDefault,
32,
&kCFTypeDictionaryKeyCallBacks,
&kCFTypeDictionaryValueCallBacks);
CFStringRef displayName = CreateDisplayNameForURL(mURL);
CFStringRef errorString = CFStringCreateWithFormat(kCFAllocatorDefault,
NULL,
CFCopyLocalizedString(CFSTR("The file “%@” is not a valid MPEG-4 file."), ""),
displayName);
CFDictionarySetValue(errorDictionary,
kCFErrorLocalizedDescriptionKey,
errorString);
CFDictionarySetValue(errorDictionary,
kCFErrorLocalizedFailureReasonKey,
CFCopyLocalizedString(CFSTR("Not an MPEG-4 file"), ""));
CFDictionarySetValue(errorDictionary,
kCFErrorLocalizedRecoverySuggestionKey,
CFCopyLocalizedString(CFSTR("The file's extension may not match the file's type."), ""));
CFRelease(errorString), errorString = NULL;
CFRelease(displayName), displayName = NULL;
*error = CFErrorCreate(kCFAllocatorDefault,
AudioMetadataErrorDomain,
AudioMetadataFileFormatNotRecognizedError,
errorDictionary);
CFRelease(errorDictionary), errorDictionary = NULL;
}
return false;
}
// Read the properties
if(0 < MP4GetNumberOfTracks(file)) {
// Should be type 'soun', media data name'mp4a'
MP4TrackId trackID = MP4FindTrackId(file, 0);
// Verify this is an MPEG-4 audio file
if(MP4_INVALID_TRACK_ID == trackID || strncmp("soun", MP4GetTrackType(file, trackID), 4)) {
MP4Close(file), file = NULL;
if(error) {
CFMutableDictionaryRef errorDictionary = CFDictionaryCreateMutable(kCFAllocatorDefault,
32,
&kCFTypeDictionaryKeyCallBacks,
&kCFTypeDictionaryValueCallBacks);
CFStringRef displayName = CreateDisplayNameForURL(mURL);
CFStringRef errorString = CFStringCreateWithFormat(kCFAllocatorDefault,
NULL,
CFCopyLocalizedString(CFSTR("The file “%@” is not a valid MPEG-4 file."), ""),
displayName);
CFDictionarySetValue(errorDictionary,
kCFErrorLocalizedDescriptionKey,
errorString);
CFDictionarySetValue(errorDictionary,
kCFErrorLocalizedFailureReasonKey,
CFCopyLocalizedString(CFSTR("Not an MPEG-4 file"), ""));
CFDictionarySetValue(errorDictionary,
kCFErrorLocalizedRecoverySuggestionKey,
CFCopyLocalizedString(CFSTR("The file's extension may not match the file's type."), ""));
CFRelease(errorString), errorString = NULL;
CFRelease(displayName), displayName = NULL;
*error = CFErrorCreate(kCFAllocatorDefault,
AudioMetadataErrorDomain,
AudioMetadataFileFormatNotSupportedError,
errorDictionary);
CFRelease(errorDictionary), errorDictionary = NULL;
}
return false;
}
MP4Duration mp4Duration = MP4GetTrackDuration(file, trackID);
uint32_t mp4TimeScale = MP4GetTrackTimeScale(file, trackID);
CFNumberRef totalFrames = CFNumberCreate(kCFAllocatorDefault, kCFNumberLongLongType, &mp4Duration);
CFDictionarySetValue(mMetadata, kPropertiesTotalFramesKey, totalFrames);
CFRelease(totalFrames), totalFrames = NULL;
CFNumberRef sampleRate = CFNumberCreate(kCFAllocatorDefault, kCFNumberIntType, &mp4TimeScale);
CFDictionarySetValue(mMetadata, kPropertiesSampleRateKey, sampleRate);
CFRelease(sampleRate), sampleRate = NULL;
double length = static_cast<double>(mp4Duration / mp4TimeScale);
CFNumberRef duration = CFNumberCreate(kCFAllocatorDefault, kCFNumberDoubleType, &length);
CFDictionarySetValue(mMetadata, kPropertiesDurationKey, duration);
CFRelease(duration), duration = NULL;
// "mdia.minf.stbl.stsd.*[0].channels"
int channels = MP4GetTrackAudioChannels(file, trackID);
CFNumberRef channelsPerFrame = CFNumberCreate(kCFAllocatorDefault, kCFNumberIntType, &channels);
CFDictionaryAddValue(mMetadata, kPropertiesChannelsPerFrameKey, channelsPerFrame);
CFRelease(channelsPerFrame), channelsPerFrame = NULL;
// ALAC files
if(MP4HaveTrackAtom(file, trackID, "mdia.minf.stbl.stsd.alac")) {
CFDictionarySetValue(mMetadata, kPropertiesFormatNameKey, CFSTR("Apple Lossless"));
uint64_t sampleSize;
uint8_t *decoderConfig;
uint32_t decoderConfigSize;
if(MP4GetTrackBytesProperty(file, trackID, "mdia.minf.stbl.stsd.alac.alac.decoderConfig", &decoderConfig, &decoderConfigSize) && 28 <= decoderConfigSize) {
// The ALAC magic cookie seems to have the following layout (28 bytes, BE):
// Byte 10: Sample size
// Bytes 25-28: Sample rate
CFNumberRef bitsPerChannel = CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt8Type, decoderConfig + 9);
CFDictionaryAddValue(mMetadata, kPropertiesBitsPerChannelKey, bitsPerChannel);
CFRelease(bitsPerChannel), bitsPerChannel = NULL;
double losslessBitrate = static_cast<double>(mp4TimeScale * channels * sampleSize) / 1000;
CFNumberRef bitrate = CFNumberCreate(kCFAllocatorDefault, kCFNumberDoubleType, &losslessBitrate);
CFDictionarySetValue(mMetadata, kPropertiesBitrateKey, bitrate);
CFRelease(bitrate), bitrate = NULL;
free(decoderConfig), decoderConfig = NULL;
}
else if(MP4GetTrackIntegerProperty(file, trackID, "mdia.minf.stbl.stsd.alac.sampleSize", &sampleSize)) {
CFNumberRef bitsPerChannel = CFNumberCreate(kCFAllocatorDefault, kCFNumberLongLongType, &sampleSize);
CFDictionaryAddValue(mMetadata, kPropertiesBitsPerChannelKey, bitsPerChannel);
CFRelease(bitsPerChannel), bitsPerChannel = NULL;
double losslessBitrate = static_cast<double>(mp4TimeScale * channels * sampleSize) / 1000;
CFNumberRef bitrate = CFNumberCreate(kCFAllocatorDefault, kCFNumberDoubleType, &losslessBitrate);
CFDictionarySetValue(mMetadata, kPropertiesBitrateKey, bitrate);
CFRelease(bitrate), bitrate = NULL;
}
}
// AAC files
if(MP4HaveTrackAtom(file, trackID, "mdia.minf.stbl.stsd.mp4a")) {
CFDictionarySetValue(mMetadata, kPropertiesFormatNameKey, CFSTR("AAC"));
// "mdia.minf.stbl.stsd.*.esds.decConfigDescr.avgBitrate"
uint32_t trackBitrate = MP4GetTrackBitRate(file, trackID) / 1000;
CFNumberRef bitrate = CFNumberCreate(kCFAllocatorDefault, kCFNumberIntType, &trackBitrate);
CFDictionaryAddValue(mMetadata, kPropertiesBitrateKey, bitrate);
CFRelease(bitrate), bitrate = NULL;
}
}
// No valid tracks in file
else {
MP4Close(file), file = NULL;
if(error) {
CFMutableDictionaryRef errorDictionary = CFDictionaryCreateMutable(kCFAllocatorDefault,
32,
&kCFTypeDictionaryKeyCallBacks,
&kCFTypeDictionaryValueCallBacks);
CFStringRef displayName = CreateDisplayNameForURL(mURL);
CFStringRef errorString = CFStringCreateWithFormat(kCFAllocatorDefault,
NULL,
CFCopyLocalizedString(CFSTR("The file “%@” is not a valid MPEG-4 file."), ""),
displayName);
CFDictionarySetValue(errorDictionary,
kCFErrorLocalizedDescriptionKey,
errorString);
CFDictionarySetValue(errorDictionary,
kCFErrorLocalizedFailureReasonKey,
CFCopyLocalizedString(CFSTR("Not an MPEG-4 file"), ""));
CFDictionarySetValue(errorDictionary,
kCFErrorLocalizedRecoverySuggestionKey,
CFCopyLocalizedString(CFSTR("The file's extension may not match the file's type."), ""));
CFRelease(errorString), errorString = NULL;
CFRelease(displayName), displayName = NULL;
*error = CFErrorCreate(kCFAllocatorDefault,
AudioMetadataErrorDomain,
AudioMetadataFileFormatNotSupportedError,
errorDictionary);
CFRelease(errorDictionary), errorDictionary = NULL;
}
return false;
}
// Read the tags
const MP4Tags *tags = MP4TagsAlloc();
if(NULL == tags) {
MP4Close(file), file = NULL;
if(error)
*error = CFErrorCreate(kCFAllocatorDefault, kCFErrorDomainPOSIX, ENOMEM, NULL);
return false;
}
MP4TagsFetch(tags, file);
// Album title
if(tags->album) {
CFStringRef str = CFStringCreateWithCString(kCFAllocatorDefault, tags->album, kCFStringEncodingUTF8);
CFDictionarySetValue(mMetadata, kMetadataAlbumTitleKey, str);
CFRelease(str), str = NULL;
}
// Artist
if(tags->artist) {
CFStringRef str = CFStringCreateWithCString(kCFAllocatorDefault, tags->artist, kCFStringEncodingUTF8);
CFDictionarySetValue(mMetadata, kMetadataArtistKey, str);
CFRelease(str), str = NULL;
}
// Album Artist
if(tags->albumArtist) {
CFStringRef str = CFStringCreateWithCString(kCFAllocatorDefault, tags->albumArtist, kCFStringEncodingUTF8);
CFDictionarySetValue(mMetadata, kMetadataAlbumArtistKey, str);
CFRelease(str), str = NULL;
}
// Genre
if(tags->genre) {
CFStringRef str = CFStringCreateWithCString(kCFAllocatorDefault, tags->genre, kCFStringEncodingUTF8);
CFDictionarySetValue(mMetadata, kMetadataGenreKey, str);
CFRelease(str), str = NULL;
}
// Release date
if(tags->releaseDate) {
CFStringRef str = CFStringCreateWithCString(kCFAllocatorDefault, tags->releaseDate, kCFStringEncodingUTF8);
CFDictionarySetValue(mMetadata, kMetadataReleaseDateKey, str);
CFRelease(str), str = NULL;
}
// Composer
if(tags->composer) {
CFStringRef str = CFStringCreateWithCString(kCFAllocatorDefault, tags->composer, kCFStringEncodingUTF8);
CFDictionarySetValue(mMetadata, kMetadataComposerKey, str);
CFRelease(str), str = NULL;
}
// Comment
if(tags->comments) {
CFStringRef str = CFStringCreateWithCString(kCFAllocatorDefault, tags->comments, kCFStringEncodingUTF8);
CFDictionarySetValue(mMetadata, kMetadataCommentKey, str);
CFRelease(str), str = NULL;
}
// Track title
if(tags->name) {
CFStringRef str = CFStringCreateWithCString(kCFAllocatorDefault, tags->name, kCFStringEncodingUTF8);
CFDictionarySetValue(mMetadata, kMetadataTitleKey, str);
CFRelease(str), str = NULL;
}
// Track number
if(tags->track) {
if(tags->track->index) {
CFNumberRef num = CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt16Type, &tags->track->index);
CFDictionarySetValue(mMetadata, kMetadataTrackNumberKey, num);
CFRelease(num), num = NULL;
}
if(tags->track->total) {
CFNumberRef num = CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt16Type, &tags->track->total);
CFDictionarySetValue(mMetadata, kMetadataTrackTotalKey, num);
CFRelease(num), num = NULL;
}
}
// Disc number
if(tags->disk) {
if(tags->disk->index) {
CFNumberRef num = CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt16Type, &tags->disk->index);
CFDictionarySetValue(mMetadata, kMetadataDiscNumberKey, num);
CFRelease(num), num = NULL;
}
if(tags->disk->total) {
CFNumberRef num = CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt16Type, &tags->disk->total);
CFDictionarySetValue(mMetadata, kMetadataDiscTotalKey, num);
CFRelease(num), num = NULL;
}
}
// Compilation
if(tags->compilation)
CFDictionarySetValue(mMetadata, kMetadataCompilationKey, *(tags->compilation) ? kCFBooleanTrue : kCFBooleanFalse);
// BPM
if(tags->tempo) {
}
// Lyrics
if(tags->lyrics) {
CFStringRef str = CFStringCreateWithCString(kCFAllocatorDefault, tags->lyrics, kCFStringEncodingUTF8);
CFDictionarySetValue(mMetadata, kMetadataLyricsKey, str);
CFRelease(str), str = NULL;
}
// Album art
if(tags->artworkCount) {
for(uint32_t i = 0; i < tags->artworkCount; ++i) {
CFDataRef data = CFDataCreate(kCFAllocatorDefault, reinterpret_cast<const UInt8 *>(tags->artwork[i].data), tags->artwork[i].size);
CFDictionarySetValue(mMetadata, kAlbumArtFrontCoverKey, data);
CFRelease(data), data = NULL;
}
}
// ReplayGain
// Reference loudness
MP4ItmfItemList *items = MP4ItmfGetItemsByMeaning(file, "com.apple.iTunes", "replaygain_reference_loudness");
if(NULL != items) {
float referenceLoudnessValue;
if(1 <= items->size && 1 <= items->elements[0].dataList.size && sscanf(reinterpret_cast<const char *>(items->elements[0].dataList.elements[0].value), "%f", &referenceLoudnessValue)) {
CFNumberRef referenceLoudness = CFNumberCreate(kCFAllocatorDefault, kCFNumberFloatType, &referenceLoudnessValue);
CFDictionaryAddValue(mMetadata, kReplayGainReferenceLoudnessKey, referenceLoudness);
CFRelease(referenceLoudness), referenceLoudness = NULL;
}
MP4ItmfItemListFree(items), items = NULL;
}
// Track gain
items = MP4ItmfGetItemsByMeaning(file, "com.apple.iTunes", "replaygain_track_gain");
if(NULL != items) {
float trackGainValue;
if(1 <= items->size && 1 <= items->elements[0].dataList.size && sscanf(reinterpret_cast<const char *>(items->elements[0].dataList.elements[0].value), "%f", &trackGainValue)) {
CFNumberRef trackGain = CFNumberCreate(kCFAllocatorDefault, kCFNumberFloatType, &trackGainValue);
CFDictionaryAddValue(mMetadata, kReplayGainTrackGainKey, trackGain);
CFRelease(trackGain), trackGain = NULL;
}
MP4ItmfItemListFree(items), items = NULL;
}
// Track peak
items = MP4ItmfGetItemsByMeaning(file, "com.apple.iTunes", "replaygain_track_peak");
if(NULL != items) {
float trackPeakValue;
if(1 <= items->size && 1 <= items->elements[0].dataList.size && sscanf(reinterpret_cast<const char *>(items->elements[0].dataList.elements[0].value), "%f", &trackPeakValue)) {
CFNumberRef trackPeak = CFNumberCreate(kCFAllocatorDefault, kCFNumberFloatType, &trackPeakValue);
CFDictionaryAddValue(mMetadata, kReplayGainTrackPeakKey, trackPeak);
CFRelease(trackPeak), trackPeak = NULL;
}
MP4ItmfItemListFree(items), items = NULL;
}
// Album gain
items = MP4ItmfGetItemsByMeaning(file, "com.apple.iTunes", "replaygain_album_gain");
if(NULL != items) {
float albumGainValue;
if(1 <= items->size && 1 <= items->elements[0].dataList.size && sscanf(reinterpret_cast<const char *>(items->elements[0].dataList.elements[0].value), "%f", &albumGainValue)) {
CFNumberRef albumGain = CFNumberCreate(kCFAllocatorDefault, kCFNumberFloatType, &albumGainValue);
CFDictionaryAddValue(mMetadata, kReplayGainAlbumGainKey, albumGain);
CFRelease(albumGain), albumGain = NULL;
}
MP4ItmfItemListFree(items), items = NULL;
}
// Album peak
items = MP4ItmfGetItemsByMeaning(file, "com.apple.iTunes", "replaygain_album_peak");
if(NULL != items) {
float albumPeakValue;
if(1 <= items->size && 1 <= items->elements[0].dataList.size && sscanf(reinterpret_cast<const char *>(items->elements[0].dataList.elements[0].value), "%f", &albumPeakValue)) {
CFNumberRef albumPeak = CFNumberCreate(kCFAllocatorDefault, kCFNumberDoubleType, &albumPeakValue);
CFDictionaryAddValue(mMetadata, kReplayGainAlbumPeakKey, albumPeak);
CFRelease(albumPeak), albumPeak = NULL;
}
MP4ItmfItemListFree(items), items = NULL;
}
// Clean up
MP4TagsFree(tags), tags = NULL;
MP4Close(file), file = NULL;
return true;
}
static MP4TrackId VideoCreate (MP4FileHandle mp4file,
mpeg2ps_t *file,
int vstream,
bool doEncrypt)
{
double frame_rate = mpeg2ps_get_video_stream_framerate(file, vstream);
uint8_t video_type;
uint16_t w, h;
MP4TrackId id;
ismacryp_session_id_t ismaCrypSId;
mp4v2_ismacrypParams *icPp = (mp4v2_ismacrypParams *) malloc(sizeof(mp4v2_ismacrypParams));
memset(icPp, 0, sizeof(mp4v2_ismacrypParams));
#ifdef _WIN32
MP4Duration mp4FrameDuration;
mp4FrameDuration =
(MP4Duration)((double)Mp4TimeScale / frame_rate);
#else
MP4Duration mp4FrameDuration =
(MP4Duration)(Mp4TimeScale / frame_rate);
#endif
h = mpeg2ps_get_video_stream_height(file, vstream);
w = mpeg2ps_get_video_stream_width(file, vstream);
video_type = mpeg2ps_get_video_stream_type(file, vstream) == MPEG_VIDEO_MPEG2 ?
MP4_MPEG2_MAIN_VIDEO_TYPE : MP4_MPEG1_VIDEO_TYPE;
if (doEncrypt) {
// initialize session
if (ismacrypInitSession(&ismaCrypSId,KeyTypeVideo) != 0) {
fprintf(stderr, "%s: could not initialize the ISMAcryp session\n",
ProgName);
return MP4_INVALID_TRACK_ID;
}
if (ismacrypGetScheme(ismaCrypSId, &(icPp->scheme_type)) != ismacryp_rc_ok) {
fprintf(stderr, "%s: could not get ismacryp scheme type. sid %d\n",
ProgName, ismaCrypSId);
ismacrypEndSession(ismaCrypSId);
return MP4_INVALID_TRACK_ID;
}
if (ismacrypGetSchemeVersion(ismaCrypSId, &(icPp->scheme_version)) != ismacryp_rc_ok) {
fprintf(stderr, "%s: could not get ismacryp scheme ver. sid %d\n",
ProgName, ismaCrypSId);
ismacrypEndSession(ismaCrypSId);
return MP4_INVALID_TRACK_ID;
}
if (ismacrypGetKMSUri(ismaCrypSId, &(icPp->kms_uri)) != ismacryp_rc_ok) {
fprintf(stderr, "%s: could not get ismacryp kms uri. sid %d\n",
ProgName, ismaCrypSId);
if (icPp->kms_uri != NULL) free(icPp->kms_uri);
ismacrypEndSession(ismaCrypSId);
return MP4_INVALID_TRACK_ID;
}
if ( ismacrypGetSelectiveEncryption(ismaCrypSId, &(icPp->selective_enc)) != ismacryp_rc_ok ) {
fprintf(stderr, "%s: could not get ismacryp selec enc. sid %d\n",
ProgName, ismaCrypSId);
ismacrypEndSession(ismaCrypSId);
return MP4_INVALID_TRACK_ID;
}
if (ismacrypGetKeyIndicatorLength(ismaCrypSId, &(icPp->key_ind_len)) != ismacryp_rc_ok) {
fprintf(stderr, "%s: could not get ismacryp key ind len. sid %d\n",
ProgName, ismaCrypSId);
ismacrypEndSession(ismaCrypSId);
return MP4_INVALID_TRACK_ID;
}
if (ismacrypGetIVLength(ismaCrypSId, &(icPp->iv_len)) != ismacryp_rc_ok) {
fprintf(stderr, "%s: could not get ismacryp iv len. sid %d\n",
ProgName, ismaCrypSId);
ismacrypEndSession(ismaCrypSId);
return MP4_INVALID_TRACK_ID;
}
id = MP4AddEncVideoTrack(mp4file,
Mp4TimeScale,
mp4FrameDuration,
w,
h,
icPp,
video_type);
} else {
id = MP4AddVideoTrack(mp4file,
Mp4TimeScale,
mp4FrameDuration,
w,
h,
video_type);
}
//printf("duration "U64" w %d h %d type %x\n", mp4FrameDuration, w, h, video_type);
if (MP4GetNumberOfTracks(mp4file, MP4_VIDEO_TRACK_TYPE) == 1) {
MP4SetVideoProfileLevel(mp4file, 0xfe); // undefined profile
}
if (id == MP4_INVALID_TRACK_ID) {
fprintf(stderr, "%s:Couldn't add video track %d", ProgName, vstream);
return MP4_INVALID_TRACK_ID;
}
uint8_t *buf;
uint32_t blen;
uint32_t frames = 1;
#if 0
printf("Processing %lu video frames\n", frames_max);
#endif
uint32_t refFrame = 1;
uint8_t frame_type;
while (mpeg2ps_get_video_frame(file,
vstream,
&buf,
&blen,
&frame_type,
TS_90000,
NULL)) {
if (buf[blen - 4] == 0 &&
buf[blen - 3] == 0 &&
buf[blen - 2] == 1) blen -= 4;
// encrypt the sample if neeed
if (doEncrypt) {
u_int8_t* encSampleData = NULL;
u_int32_t encSampleLen = 0;
if (ismacrypEncryptSampleAddHeader(ismaCrypSId, blen, buf,
&encSampleLen, &encSampleData) != 0) {
fprintf(stderr,
"%s: can't encrypt video sample and add header %u\n", ProgName, id);
}
MP4WriteSample(mp4file, id, encSampleData, encSampleLen,
mp4FrameDuration, 0,
frame_type == 1 ? true : false);
if (encSampleData != NULL) {
free(encSampleData);
}
} else {
MP4WriteSample(mp4file, id, buf, blen, mp4FrameDuration, 0,
frame_type == 1 ? true : false);
#if 0
printf("frame %d len %d duration "U64" ftype %d\n",
frames, blen, mp4FrameDuration, frame_type);
#endif
}
if (frame_type != 3) {
// I or P frame
MP4SetSampleRenderingOffset(mp4file, id, refFrame,
(frames - refFrame) * mp4FrameDuration);
refFrame = frames;
}
frames++;
#if 0
if ((frames % 100) == 0) printf("%d frames\n", frames);
#endif
}
// if encrypting, terminate the ismacryp session
if (doEncrypt) {
if (ismacrypEndSession(ismaCrypSId) != 0) {
fprintf(stderr,
"%s: could not end the ISMAcryp session\n",
ProgName);
return MP4_INVALID_TRACK_ID;
}
}
return id;
}
static MP4TrackId AudioCreate (MP4FileHandle mp4file,
mpeg2ps_t *file,
int astream,
bool doEncrypt)
{
uint16_t freq;
int type;
MP4TrackId id;
uint16_t samples_per_frame;
uint8_t *buf = NULL;
uint32_t blen = 0;
uint32_t frame_num = 1;
ismacryp_session_id_t ismaCrypSId;
mp4v2_ismacrypParams *icPp = (mp4v2_ismacrypParams *) malloc(sizeof(mp4v2_ismacrypParams));
MP4AV_Mp3Header hdr;
u_int8_t mpegVersion;
memset(icPp, 0, sizeof(mp4v2_ismacrypParams));
type = mpeg2ps_get_audio_stream_type(file, astream);
if (type != MPEG_AUDIO_MPEG) {
fprintf(stderr, "Unsupported audio format %d in audio stream %d\n",
type, astream);
return MP4_INVALID_TRACK_ID;
}
freq = mpeg2ps_get_audio_stream_sample_freq(file, astream);
if (mpeg2ps_get_audio_frame(file,
astream,
&buf,
&blen,
TS_90000,
NULL,
NULL) == false) {
fprintf(stderr, "No audio tracks in audio stream %d\n", astream);
return MP4_INVALID_TRACK_ID;
}
hdr = MP4AV_Mp3HeaderFromBytes(buf);
mpegVersion = MP4AV_Mp3GetHdrVersion(hdr);
samples_per_frame = MP4AV_Mp3GetHdrSamplingWindow(hdr);
u_int8_t audioType = MP4AV_Mp3ToMp4AudioType(mpegVersion);
if (audioType == MP4_INVALID_AUDIO_TYPE
|| samples_per_frame == 0) {
fprintf(stderr,
"%s: data in file doesn't appear to be valid audio\n",
ProgName);
return MP4_INVALID_TRACK_ID;
}
MP4Duration duration = (90000 * samples_per_frame) / freq;
if (doEncrypt) {
// initialize the ismacryp session
if (ismacrypInitSession(&ismaCrypSId,KeyTypeAudio) != 0) {
fprintf(stderr,
"%s: could not initialize the ISMAcryp session\n",
ProgName);
return MP4_INVALID_TRACK_ID;
}
if (ismacrypGetScheme(ismaCrypSId, &(icPp->scheme_type)) != ismacryp_rc_ok) {
fprintf(stderr, "%s: could not get ismacryp scheme type. sid %d\n",
ProgName, ismaCrypSId);
ismacrypEndSession(ismaCrypSId);
return MP4_INVALID_TRACK_ID;
}
if (ismacrypGetSchemeVersion(ismaCrypSId, &(icPp->scheme_version)) != ismacryp_rc_ok) {
fprintf(stderr, "%s: could not get ismacryp scheme ver. sid %d\n",
ProgName, ismaCrypSId);
ismacrypEndSession(ismaCrypSId);
return MP4_INVALID_TRACK_ID;
}
if (ismacrypGetKMSUri(ismaCrypSId, &(icPp->kms_uri)) != ismacryp_rc_ok) {
fprintf(stderr, "%s: could not get ismacryp kms uri. sid %d\n",
ProgName, ismaCrypSId);
if (icPp->kms_uri != NULL) free(icPp->kms_uri);
ismacrypEndSession(ismaCrypSId);
return MP4_INVALID_TRACK_ID;
}
if ( ismacrypGetSelectiveEncryption(ismaCrypSId, &(icPp->selective_enc)) != ismacryp_rc_ok ) {
fprintf(stderr, "%s: could not get ismacryp selec enc. sid %d\n",
ProgName, ismaCrypSId);
ismacrypEndSession(ismaCrypSId);
return MP4_INVALID_TRACK_ID;
}
if (ismacrypGetKeyIndicatorLength(ismaCrypSId, &(icPp->key_ind_len)) != ismacryp_rc_ok) {
fprintf(stderr, "%s: could not get ismacryp key ind len. sid %d\n",
ProgName, ismaCrypSId);
ismacrypEndSession(ismaCrypSId);
return MP4_INVALID_TRACK_ID;
}
if (ismacrypGetIVLength(ismaCrypSId, &(icPp->iv_len)) != ismacryp_rc_ok) {
fprintf(stderr, "%s: could not get ismacryp iv len. sid %d\n",
ProgName, ismaCrypSId);
ismacrypEndSession(ismaCrypSId);
return MP4_INVALID_TRACK_ID;
}
id = MP4AddEncAudioTrack(mp4file,
90000,
duration,
icPp,
audioType);
} else {
id = MP4AddAudioTrack(mp4file,
90000,
duration,
audioType);
}
if (id == MP4_INVALID_TRACK_ID) {
fprintf(stderr,
"%s: can't create audio track from stream %d\n",
ProgName, astream);
return MP4_INVALID_TRACK_ID;
}
if (MP4GetNumberOfTracks(mp4file, MP4_AUDIO_TRACK_TYPE) == 1) {
MP4SetAudioProfileLevel(mp4file, 0xFE);
}
do {
// encrypt if needed
if (doEncrypt) {
u_int8_t* encSampleData = NULL;
u_int32_t encSampleLen = 0;
if (ismacrypEncryptSampleAddHeader(ismaCrypSId, blen, buf,
&encSampleLen, &encSampleData) != 0) {
fprintf(stderr,
"%s: can't encrypt audio sample and add header %u\n", ProgName, id);
}
// now write the sample
if (!MP4WriteSample(mp4file, id, encSampleData, encSampleLen)) {
fprintf(stderr, "%s: can't write audio track %u, stream %d",
ProgName, frame_num, astream);
MP4DeleteTrack(mp4file, id);
return MP4_INVALID_TRACK_ID;
}
if (encSampleData != NULL) {
free(encSampleData);
}
}
// now write the sample
if (!MP4WriteSample(mp4file, id, buf, blen)) {
fprintf(stderr, "%s: can't write audio track %u, stream %d",
ProgName, frame_num, astream);
MP4DeleteTrack(mp4file, id);
return MP4_INVALID_TRACK_ID;
}
frame_num++;
#if 0
if ((frame_num % 100) == 0) printf("Audio frame %d\n", frame_num);
#endif
} while (mpeg2ps_get_audio_frame(file,
astream,
&buf,
&blen,
TS_90000,
NULL, NULL));
// if encrypting, terminate the ismacryp session
if (doEncrypt) {
if (ismacrypEndSession(ismaCrypSId) != 0) {
fprintf(stderr,
"%s: could not end the ISMAcryp session\n",
ProgName);
return MP4_INVALID_TRACK_ID;
}
}
return id;
}
static GtkWidget* CreateMp4TrackMenu(
GtkWidget* menu,
char type,
const char* source,
u_int32_t* pIndex,
u_int32_t* pNumber,
u_int32_t** ppValues)
{
*pIndex = 0;
u_int32_t newTrackNumber = 1;
MP4FileHandle mp4File = MP4Read(source);
char* trackType = NULL;
if (mp4File) {
if (type == 'V') {
trackType = MP4_VIDEO_TRACK_TYPE;
} else {
trackType = MP4_AUDIO_TRACK_TYPE;
}
newTrackNumber =
MP4GetNumberOfTracks(mp4File, trackType);
}
u_int32_t* newTrackValues =
(u_int32_t*)malloc(sizeof(u_int32_t) * newTrackNumber);
char** newTrackNames =
(char**)malloc(sizeof(char*) * newTrackNumber);
if (!mp4File) {
newTrackValues[0] = 0;
newTrackNames[0] = strdup("");
} else {
for (u_int8_t i = 0; i < newTrackNumber; i++) {
MP4TrackId trackId =
MP4FindTrackId(mp4File, i, trackType);
char* trackName = "Unknown";
char buf[64];
if (trackType == MP4_VIDEO_TRACK_TYPE) {
u_int8_t videoType =
MP4GetTrackEsdsObjectTypeId(mp4File,
trackId);
switch (videoType) {
case MP4_MPEG1_VIDEO_TYPE:
trackName = "MPEG1";
break;
case MP4_MPEG2_SIMPLE_VIDEO_TYPE:
case MP4_MPEG2_MAIN_VIDEO_TYPE:
case MP4_MPEG2_SNR_VIDEO_TYPE:
case MP4_MPEG2_SPATIAL_VIDEO_TYPE:
case MP4_MPEG2_HIGH_VIDEO_TYPE:
case MP4_MPEG2_442_VIDEO_TYPE:
trackName = "MPEG2";
break;
case MP4_MPEG4_VIDEO_TYPE:
trackName = "MPEG4";
break;
case MP4_YUV12_VIDEO_TYPE:
trackName = "YUV12";
break;
case MP4_H263_VIDEO_TYPE:
trackName = "H263";
break;
case MP4_H261_VIDEO_TYPE:
trackName = "H261";
break;
}
snprintf(buf, sizeof(buf),
"%u - %s %u x %u %.2f fps %u kbps",
trackId,
trackName,
MP4GetTrackVideoWidth(mp4File, trackId),
MP4GetTrackVideoHeight(mp4File, trackId),
MP4GetTrackVideoFrameRate(mp4File, trackId),
(MP4GetTrackBitRate(mp4File, trackId) + 500) / 1000);
} else { // audio
u_int8_t audioType =
MP4GetTrackEsdsObjectTypeId(mp4File,
trackId);
switch (audioType) {
case MP4_MPEG1_AUDIO_TYPE:
case MP4_MPEG2_AUDIO_TYPE:
trackName = "MPEG (MP3)";
break;
case MP4_MPEG2_AAC_MAIN_AUDIO_TYPE:
case MP4_MPEG2_AAC_LC_AUDIO_TYPE:
case MP4_MPEG2_AAC_SSR_AUDIO_TYPE:
case MP4_MPEG4_AUDIO_TYPE:
trackName = "AAC";
break;
case MP4_PCM16_LITTLE_ENDIAN_AUDIO_TYPE:
trackName = "PCM16 LITTLE ENDIAN";
break;
case MP4_PCM16_BIG_ENDIAN_AUDIO_TYPE:
trackName = "PCM16 BIG ENDIAN";
case MP4_AC3_AUDIO_TYPE:
trackName = "AC3";
break;
case MP4_VORBIS_AUDIO_TYPE:
trackName = "Ogg Vorbis";
break;
case MP4_ALAW_AUDIO_TYPE:
trackName = "G711 aLaw";
break;
case MP4_ULAW_AUDIO_TYPE:
trackName = "G711 uLaw";
break;
}
snprintf(buf, sizeof(buf),
"%u - %s %u kbps",
trackId,
trackName,
(MP4GetTrackBitRate(mp4File, trackId) + 500) / 1000);
}
newTrackValues[i] = trackId;
newTrackNames[i] = strdup(buf);
}
MP4Close(mp4File);
}
// (re)create the menu
menu = CreateOptionMenu(
menu,
newTrackNames,
newTrackNumber,
*pIndex,
GTK_SIGNAL_FUNC(on_track_menu_activate));
// free up old names
for (u_int8_t i = 0; i < *pNumber; i++) {
free(trackNames[i]);
}
free(trackNames);
free(*ppValues);
*pNumber = newTrackNumber;
trackNames = newTrackNames;
*ppValues = newTrackValues;
return menu;
}
int main(int argc, char** argv)
{
const char* usageString =
"[-l] [-t <track-id>] [-s <sample-id>] [-v [<level>]] <file-name>\n";
bool doList = false;
bool doSamples = false;
MP4TrackId trackId = MP4_INVALID_TRACK_ID;
MP4SampleId sampleId = MP4_INVALID_SAMPLE_ID;
char* dstFileName = NULL;
u_int32_t verbosity = MP4_DETAILS_ERROR;
fprintf(stderr, "You don't want to use this utility - use mp4creator --extract instead\n");
fprintf(stderr, "If you really want to use it, remove this warning and the exit call\n");
fprintf(stderr, "from the source file\n");
exit(-1);
/* begin processing command line */
ProgName = argv[0];
while (true) {
int c = -1;
int option_index = 0;
static struct option long_options[] = {
{ "list", 0, 0, 'l' },
{ "track", 1, 0, 't' },
{ "sample", 2, 0, 's' },
{ "verbose", 2, 0, 'v' },
{ "version", 0, 0, 'V' },
{ NULL, 0, 0, 0 }
};
c = getopt_long_only(argc, argv, "lt:s::v::V",
long_options, &option_index);
if (c == -1)
break;
switch (c) {
case 'l':
doList = true;
break;
case 's':
doSamples = true;
if (optarg) {
if (sscanf(optarg, "%u", &sampleId) != 1) {
fprintf(stderr,
"%s: bad sample-id specified: %s\n",
ProgName, optarg);
}
}
break;
case 't':
if (sscanf(optarg, "%u", &trackId) != 1) {
fprintf(stderr,
"%s: bad track-id specified: %s\n",
ProgName, optarg);
exit(1);
}
break;
case 'v':
verbosity |= MP4_DETAILS_READ;
if (optarg) {
u_int32_t level;
if (sscanf(optarg, "%u", &level) == 1) {
if (level >= 2) {
verbosity |= MP4_DETAILS_TABLE;
}
if (level >= 3) {
verbosity |= MP4_DETAILS_SAMPLE;
}
if (level >= 4) {
verbosity = MP4_DETAILS_ALL;
}
}
}
break;
case '?':
fprintf(stderr, "usage: %s %s", ProgName, usageString);
exit(0);
case 'V':
fprintf(stderr, "%s - %s version %s\n",
ProgName, MPEG4IP_PACKAGE, MPEG4IP_VERSION);
exit(0);
default:
fprintf(stderr, "%s: unknown option specified, ignoring: %c\n",
ProgName, c);
}
}
/* check that we have at least one non-option argument */
if ((argc - optind) < 1) {
fprintf(stderr, "usage: %s %s", ProgName, usageString);
exit(1);
}
if (verbosity) {
fprintf(stderr, "%s version %s\n", ProgName, MPEG4IP_VERSION);
}
/* point to the specified file names */
Mp4PathName = argv[optind++];
/* get dest file name for a single track */
if (trackId && (argc - optind) > 0) {
dstFileName = argv[optind++];
}
char* lastSlash = strrchr(Mp4PathName, '/');
if (lastSlash) {
Mp4FileName = lastSlash + 1;
} else {
Mp4FileName = Mp4PathName;
}
/* warn about extraneous non-option arguments */
if (optind < argc) {
fprintf(stderr, "%s: unknown options specified, ignoring: ", ProgName);
while (optind < argc) {
fprintf(stderr, "%s ", argv[optind++]);
}
fprintf(stderr, "\n");
}
/* end processing of command line */
MP4FileHandle mp4File = MP4Read(Mp4PathName, verbosity);
if (!mp4File) {
exit(1);
}
if (doList) {
MP4Info(mp4File);
exit(0);
}
if (trackId == 0) {
u_int32_t numTracks = MP4GetNumberOfTracks(mp4File);
for (u_int32_t i = 0; i < numTracks; i++) {
trackId = MP4FindTrackId(mp4File, i);
ExtractTrack(mp4File, trackId, doSamples, sampleId);
}
} else {
ExtractTrack(mp4File, trackId, doSamples, sampleId, dstFileName);
}
MP4Close(mp4File);
return(0);
}
