extern "C" bool MP4AV_Rfc3016Hinter(
MP4FileHandle mp4File,
MP4TrackId mediaTrackId,
u_int16_t maxPayloadSize)
{
u_int32_t numSamples = MP4GetTrackNumberOfSamples(mp4File, mediaTrackId);
u_int32_t maxSampleSize = MP4GetTrackMaxSampleSize(mp4File, mediaTrackId);
if (numSamples == 0 || maxSampleSize == 0) {
return false;
}
MP4TrackId hintTrackId =
MP4AV_Rfc3016_HintTrackCreate(mp4File, mediaTrackId);
if (hintTrackId == MP4_INVALID_TRACK_ID) {
return false;
}
u_int8_t* pSampleBuffer = (u_int8_t*)malloc(maxSampleSize);
if (pSampleBuffer == NULL) {
MP4DeleteTrack(mp4File, hintTrackId);
return false;
}
for (MP4SampleId sampleId = 1; sampleId <= numSamples; sampleId++) {
u_int32_t sampleSize = maxSampleSize;
MP4Timestamp startTime;
MP4Duration duration;
MP4Duration renderingOffset;
bool isSyncSample;
bool rc = MP4ReadSample(
mp4File, mediaTrackId, sampleId,
&pSampleBuffer, &sampleSize,
&startTime, &duration,
&renderingOffset, &isSyncSample);
if (rc == false ||
MP4AV_Rfc3016_HintAddSample(mp4File,
hintTrackId,
sampleId,
pSampleBuffer,
sampleSize,
duration,
renderingOffset,
isSyncSample,
maxPayloadSize) == false) {
MP4DeleteTrack(mp4File, hintTrackId);
CHECK_AND_FREE(pSampleBuffer);
return false;
}
}
CHECK_AND_FREE(pSampleBuffer);
return true;
}
MP4Reader(const std::string &file_path)
: time_scale(9 * MP4_MSECS_TIME_SCALE)
, file_path(file_path)
, handle(MP4_INVALID_FILE_HANDLE)
, video_track_id(MP4_INVALID_TRACK_ID)
, next_video_sample_idx(1)
, video_sample(nullptr)
, video_timescale(0)
, video_sample_max_size(0)
, video_sample_number(0)
, video_duration(0)
, pSeqHeaders(nullptr)
, pSeqHeaderSize(nullptr)
, pPictHeaders(nullptr)
, pPictHeaderSize(nullptr)
{
handle = MP4Read(this->file_path.c_str());
video_track_id = MP4FindTrackId(handle, 0, MP4_VIDEO_TRACK_TYPE);
if (video_track_id != MP4_INVALID_TRACK_ID) {
video_timescale = MP4GetTrackTimeScale(handle, video_track_id);
video_sample_max_size = MP4GetTrackMaxSampleSize(handle, video_track_id) * 2;
video_duration = MP4GetTrackDuration(handle, video_track_id);
video_sample = new unsigned char[video_sample_max_size];
video_sample_number = MP4GetTrackNumberOfSamples(handle, video_track_id);
if (MP4GetTrackH264SeqPictHeaders(handle,
video_track_id,
&pSeqHeaders,
&pSeqHeaderSize,
&pPictHeaders,
&pPictHeaderSize))
{
printf("Get SPS(%d) and PPS(%d)\n", *pSeqHeaderSize, *pPictHeaderSize);
for(int i = 0; (pSeqHeaders[i] && pSeqHeaderSize[i]); i++) {
printf("SPS(%d): %02x %02x %02x %02x %02x\n", i,
pSeqHeaders[i][0], pSeqHeaders[i][1], pSeqHeaders[i][2],
pSeqHeaders[i][3], pSeqHeaders[i][4]);
}
for(int i = 0; (pPictHeaders[i] && pPictHeaderSize[i]); i++) {
printf("PPS(%d): %02x %02x %02x %02x %02x\n", i,
pPictHeaders[i][0], pPictHeaders[i][1], pPictHeaders[i][2],
pPictHeaders[i][3], pPictHeaders[i][4]);
}
}
}
}
/**************************************************************************
* Quicktime stream base class functions
**************************************************************************/
CMp4ByteStream::CMp4ByteStream (CMp4File *parent,
MP4TrackId track,
const char *type,
bool has_video)
: COurInByteStream(type)
{
#ifdef ISMACRYP_DEBUG
my_enc_file = fopen("encbuffer.raw", "w");
my_unenc_file = fopen("unencbuffer.raw", "w");
my_unenc_file2 = fopen("unencbuffer2.raw", "w");
#endif
#ifdef OUTPUT_TO_FILE
char buffer[80];
strcpy(buffer, type);
strcat(buffer, ".raw");
m_output_file = fopen(buffer, "w");
#endif
m_track = track;
m_frame_on = 1;
m_parent = parent;
m_eof = false;
MP4FileHandle fh = parent->get_file();
m_frames_max = MP4GetTrackNumberOfSamples(fh, m_track);
mp4f_message(LOG_DEBUG, "%s - %u samples", type, m_frames_max);
m_max_frame_size = MP4GetTrackMaxSampleSize(fh, m_track) + 4;
m_sample_freq = MP4GetTrackTimeScale(fh, m_track);
m_buffer = (u_int8_t *) malloc(m_max_frame_size * sizeof(u_int8_t));
m_has_video = has_video;
m_frame_in_buffer = 0xffffffff;
MP4Duration trackDuration;
trackDuration = MP4GetTrackDuration(fh, m_track);
uint64_t max_ts;
max_ts = MP4ConvertFromTrackDuration(fh,
m_track,
trackDuration,
MP4_MSECS_TIME_SCALE);
m_max_time = UINT64_TO_DOUBLE(max_ts);
m_max_time /= 1000.0;
mp4f_message(LOG_DEBUG,
"MP4 %s max time is "U64" %g", type, max_ts, m_max_time);
read_frame(1, NULL);
}
extern "C" bool MP4AV_Rfc2429Hinter (MP4FileHandle file,
MP4TrackId mediaTrackId,
uint16_t maxPayloadSize)
{
uint32_t numSamples, maxSampleSize;
MP4TrackId hid;
MP4Duration duration;
numSamples = MP4GetTrackNumberOfSamples(file, mediaTrackId);
if (numSamples == 0) {
return false;
}
maxSampleSize = MP4GetTrackMaxSampleSize(file, mediaTrackId);
u_int8_t* pSampleBuffer = (u_int8_t*)malloc(maxSampleSize);
if (pSampleBuffer == NULL) {
return false;
}
hid = MP4AddHintTrack(file, mediaTrackId);
if (hid == MP4_INVALID_TRACK_ID) {
return false;
}
uint8_t payloadNumber = MP4_SET_DYNAMIC_PAYLOAD;
MP4SetHintTrackRtpPayload(file,
hid,
"H263-2000",
&payloadNumber,
0,
NULL,
true,
false);
// strictly speaking, this is not required for H.263 - it's a quicktime
// thing.
u_int16_t videoWidth = MP4GetTrackVideoWidth(file, mediaTrackId);
u_int16_t videoHeight = MP4GetTrackVideoHeight(file, mediaTrackId);
char sdpString[80];
sprintf(sdpString, "a=cliprect:0,0,%d,%d\015\012", videoHeight, videoWidth);
MP4AppendHintTrackSdp(file,
hid,
sdpString);
for (uint32_t sid = 1; sid <= numSamples; sid++) {
duration = MP4GetSampleDuration(file, mediaTrackId, sid);
MP4AddRtpVideoHint(file, hid, false, 0);
u_int32_t sampleSize = maxSampleSize;
MP4Timestamp startTime;
MP4Duration duration;
MP4Duration renderingOffset;
bool isSyncSample;
bool rc = MP4ReadSample(file, mediaTrackId, sid,
&pSampleBuffer, &sampleSize,
&startTime, &duration,
&renderingOffset, &isSyncSample);
if (!rc) {
MP4DeleteTrack(file, hid);
free(pSampleBuffer);
return false;
}
// need to skip the first 2 bytes of the packet - it is the
//start code
uint16_t payload_head = htons(0x400);
uint32_t offset = sizeof(payload_head);
uint32_t remaining = sampleSize - sizeof(payload_head);
while (remaining) {
bool last_pak = false;
uint32_t len;
if (remaining + 2 <= maxPayloadSize) {
len = remaining;
last_pak = true;
} else {
len = maxPayloadSize - 2;
}
MP4AddRtpPacket(file, hid, last_pak);
MP4AddRtpImmediateData(file, hid,
(u_int8_t*)&payload_head, sizeof(payload_head));
payload_head = 0;
MP4AddRtpSampleData(file, hid, sid,
offset, len);
offset += len;
remaining -= len;
}
MP4WriteRtpHint(file, hid, duration, true);
}
free(pSampleBuffer);
return true;
}
extern "C" bool MP4AV_AVSMHinter(
MP4FileHandle mp4File,
MP4TrackId mediaTrackId,
u_int16_t maxPayloadSize)
{
u_int32_t numSamples = MP4GetTrackNumberOfSamples(mp4File, mediaTrackId);
u_int32_t maxSampleSize = MP4GetTrackMaxSampleSize(mp4File, mediaTrackId);
uint32_t sizeLength;
if (numSamples == 0 || maxSampleSize == 0) {
return false;
}
/*if (MP4GetTrackAVSMLengthSize(mp4File, mediaTrackId, &sizeLength) == false) {
return false;
}*/
sizeLength=4; //why?
MP4TrackId hintTrackId =
MP4AV_AVSM_HintTrackCreate(mp4File, mediaTrackId); //****AVSMspecial****
if (hintTrackId == MP4_INVALID_TRACK_ID) {
return false;
}
u_int8_t* pSampleBuffer = (u_int8_t*)malloc(maxSampleSize);
if (pSampleBuffer == NULL) {
MP4DeleteTrack(mp4File, hintTrackId);
return false;
}
for (MP4SampleId sampleId = 1; sampleId <= numSamples; sampleId++) {
u_int32_t sampleSize = maxSampleSize;
MP4Timestamp startTime;
MP4Duration duration;
MP4Duration renderingOffset;
bool isSyncSample;//stss指定同步帧
bool rc = MP4ReadSample(
mp4File, mediaTrackId, sampleId,
&pSampleBuffer, &sampleSize,
&startTime, &duration,
&renderingOffset, &isSyncSample);
if (!rc) {
MP4DeleteTrack(mp4File, hintTrackId);
CHECK_AND_FREE(pSampleBuffer);
return false;
}
MP4AV_AVSM_HintAddSample(mp4File, //****AVSMspecial****
hintTrackId,
sampleId,
pSampleBuffer,
sampleSize,
sizeLength,
duration,
renderingOffset,
isSyncSample,
maxPayloadSize);
}
CHECK_AND_FREE(pSampleBuffer);
return true;
}
extern "C" bool MP4AV_RfcIsmaHinter(
MP4FileHandle mp4File,
MP4TrackId mediaTrackId,
bool interleave,
u_int16_t maxPayloadSize)
{
// gather information, and check for validity
u_int32_t numSamples =
MP4GetTrackNumberOfSamples(mp4File, mediaTrackId);
if (numSamples == 0) {
return false;
}
u_int32_t timeScale =
MP4GetTrackTimeScale(mp4File, mediaTrackId);
if (timeScale == 0) {
return false;
}
u_int8_t audioType =
MP4GetTrackEsdsObjectTypeId(mp4File, mediaTrackId);
if (audioType != MP4_MPEG4_AUDIO_TYPE
&& !MP4_IS_AAC_AUDIO_TYPE(audioType)) {
return false;
}
u_int8_t mpeg4AudioType =
MP4GetTrackAudioMpeg4Type(mp4File, mediaTrackId);
if (audioType == MP4_MPEG4_AUDIO_TYPE) {
// check that track contains either MPEG-4 AAC or CELP
if (!MP4_IS_MPEG4_AAC_AUDIO_TYPE(mpeg4AudioType)
&& mpeg4AudioType != MP4_MPEG4_CELP_AUDIO_TYPE) {
return false;
}
}
MP4Duration sampleDuration =
MP4AV_GetAudioSampleDuration(mp4File, mediaTrackId);
if (sampleDuration == MP4_INVALID_DURATION) {
return false;
}
/* get the ES configuration */
u_int8_t* pConfig = NULL;
u_int32_t configSize;
uint8_t channels;
if (MP4GetTrackESConfiguration(mp4File, mediaTrackId,
&pConfig, &configSize) == false)
return false;
if (!pConfig) {
return false;
}
channels = MP4AV_AacConfigGetChannels(pConfig);
/* convert ES Config into ASCII form */
char* sConfig =
MP4BinaryToBase16(pConfig, configSize);
free(pConfig);
if (!sConfig) {
return false;
}
/* create the appropriate SDP attribute */
uint sdpBufLen = strlen(sConfig) + 256;
char* sdpBuf =
(char*)malloc(sdpBufLen);
if (!sdpBuf) {
free(sConfig);
return false;
}
// now add the hint track
MP4TrackId hintTrackId =
MP4AddHintTrack(mp4File, mediaTrackId);
if (hintTrackId == MP4_INVALID_TRACK_ID) {
free(sConfig);
free(sdpBuf);
return false;
}
u_int8_t payloadNumber = MP4_SET_DYNAMIC_PAYLOAD;
char buffer[10];
if (channels != 1) {
snprintf(buffer, sizeof(buffer), "%u", channels);
}
if (MP4SetHintTrackRtpPayload(mp4File, hintTrackId,
"mpeg4-generic", &payloadNumber, 0,
channels != 1 ? buffer : NULL) == false) {
MP4DeleteTrack(mp4File, hintTrackId);
free(sConfig);
free(sdpBuf);
return false;
}
MP4Duration maxLatency;
bool OneByteHeader = false;
if (mpeg4AudioType == MP4_MPEG4_CELP_AUDIO_TYPE) {
snprintf(sdpBuf, sdpBufLen,
"a=fmtp:%u "
"streamtype=5; profile-level-id=15; mode=CELP-vbr; config=%s; "
"SizeLength=6; IndexLength=2; IndexDeltaLength=2; Profile=0;"
"\015\012",
payloadNumber,
sConfig);
// 200 ms max latency for ISMA profile 1
maxLatency = timeScale / 5;
OneByteHeader = true;
} else { // AAC
snprintf(sdpBuf, sdpBufLen,
"a=fmtp:%u "
"streamtype=5; profile-level-id=15; mode=AAC-hbr; config=%s; "
"SizeLength=13; IndexLength=3; IndexDeltaLength=3;"
"\015\012",
payloadNumber,
sConfig);
// 500 ms max latency for ISMA profile 1
maxLatency = timeScale / 2;
}
/* add this to the track's sdp */
bool val = MP4AppendHintTrackSdp(mp4File, hintTrackId, sdpBuf);
free(sConfig);
free(sdpBuf);
if (val == false) {
MP4DeleteTrack(mp4File, hintTrackId);
return false;
}
u_int32_t samplesPerPacket = 0;
if (interleave) {
u_int32_t maxSampleSize =
MP4GetTrackMaxSampleSize(mp4File, mediaTrackId);
// compute how many maximum size samples would fit in a packet
samplesPerPacket =
(maxPayloadSize - 2) / (maxSampleSize + 2);
// can't interleave if this number is 0 or 1
if (samplesPerPacket < 2) {
interleave = false;
}
}
bool rc;
if (interleave) {
u_int32_t samplesPerGroup = maxLatency / sampleDuration;
u_int32_t stride;
stride = samplesPerGroup / samplesPerPacket;
if (OneByteHeader && stride > 3) stride = 3;
if (!OneByteHeader && stride > 7) stride = 7;
#if 0
printf("max latency %llu sampleDuration %llu spg %u spp %u strid %u\n",
maxLatency, sampleDuration, samplesPerGroup,
samplesPerPacket, stride);
#endif
rc = MP4AV_AudioInterleaveHinter(
mp4File,
mediaTrackId,
hintTrackId,
sampleDuration,
stride, // stride
samplesPerPacket, // bundle
maxPayloadSize,
MP4AV_RfcIsmaConcatenator);
} else {
rc = MP4AV_AudioConsecutiveHinter(
mp4File,
mediaTrackId,
hintTrackId,
sampleDuration,
2, // perPacketHeaderSize
2, // perSampleHeaderSize
maxLatency / sampleDuration, // maxSamplesPerPacket
maxPayloadSize,
MP4GetSampleSize,
MP4AV_RfcIsmaConcatenator,
MP4AV_RfcIsmaFragmenter);
}
if (!rc) {
MP4DeleteTrack(mp4File, hintTrackId);
return false;
}
return true;
}
Result SoundSourceM4A::tryOpen(const AudioSourceConfig& audioSrcCfg) {
DEBUG_ASSERT(MP4_INVALID_FILE_HANDLE == m_hFile);
/* open MP4 file, check for >= ver 1.9.1 */
#if MP4V2_PROJECT_version_hex <= 0x00010901
m_hFile = MP4Read(getLocalFileNameBytes().constData(), 0);
#else
m_hFile = MP4Read(getLocalFileNameBytes().constData());
#endif
if (MP4_INVALID_FILE_HANDLE == m_hFile) {
qWarning() << "Failed to open file for reading:" << getUrlString();
return ERR;
}
m_trackId = findFirstAudioTrackId(m_hFile);
if (MP4_INVALID_TRACK_ID == m_trackId) {
qWarning() << "No AAC track found:" << getUrlString();
return ERR;
}
const MP4SampleId numberOfSamples =
MP4GetTrackNumberOfSamples(m_hFile, m_trackId);
if (0 >= numberOfSamples) {
qWarning() << "Failed to read number of samples from file:" << getUrlString();
return ERR;
}
m_maxSampleBlockId = kSampleBlockIdMin + (numberOfSamples - 1);
// Determine the maximum input size (in bytes) of a
// sample block for the selected track.
const u_int32_t maxSampleBlockInputSize = MP4GetTrackMaxSampleSize(m_hFile,
m_trackId);
m_inputBuffer.resize(maxSampleBlockInputSize, 0);
DEBUG_ASSERT(NULL == m_hDecoder); // not already opened
m_hDecoder = NeAACDecOpen();
if (!m_hDecoder) {
qWarning() << "Failed to open the AAC decoder!";
return ERR;
}
NeAACDecConfigurationPtr pDecoderConfig = NeAACDecGetCurrentConfiguration(
m_hDecoder);
pDecoderConfig->outputFormat = FAAD_FMT_FLOAT;
if ((kChannelCountMono == audioSrcCfg.channelCountHint) ||
(kChannelCountStereo == audioSrcCfg.channelCountHint)) {
pDecoderConfig->downMatrix = 1;
} else {
pDecoderConfig->downMatrix = 0;
}
pDecoderConfig->defObjectType = LC;
if (!NeAACDecSetConfiguration(m_hDecoder, pDecoderConfig)) {
qWarning() << "Failed to configure AAC decoder!";
return ERR;
}
u_int8_t* configBuffer = NULL;
u_int32_t configBufferSize = 0;
if (!MP4GetTrackESConfiguration(m_hFile, m_trackId, &configBuffer,
&configBufferSize)) {
/* failed to get mpeg-4 audio config... this is ok.
* NeAACDecInit2() will simply use default values instead.
*/
qWarning() << "Failed to read the MP4 audio configuration."
<< "Continuing with default values.";
}
SAMPLERATE_TYPE sampleRate;
unsigned char channelCount;
if (0 > NeAACDecInit2(m_hDecoder, configBuffer, configBufferSize,
&sampleRate, &channelCount)) {
free(configBuffer);
qWarning() << "Failed to initialize the AAC decoder!";
return ERR;
} else {
free(configBuffer);
}
setChannelCount(channelCount);
setFrameRate(sampleRate);
setFrameCount(getFrameCountForSampleBlockId(m_maxSampleBlockId));
// Resize temporary buffer for decoded sample data
const SINT sampleBufferCapacity =
frames2samples(kFramesPerSampleBlock);
m_sampleBuffer.resetCapacity(sampleBufferCapacity);
// Invalidate current position to enforce the following
// seek operation
m_curFrameIndex = getMaxFrameIndex();
// (Re-)Start decoding at the beginning of the file
seekSampleFrame(getMinFrameIndex());
return OK;
}
static int
aac_init (DB_fileinfo_t *_info, DB_playItem_t *it) {
aac_info_t *info = (aac_info_t *)_info;
info->file = deadbeef->fopen (deadbeef->pl_find_meta (it, ":URI"));
if (!info->file) {
return -1;
}
// probe
float duration = -1;
int samplerate = -1;
int channels = -1;
int totalsamples = -1;
info->junk = deadbeef->junk_get_leading_size (info->file);
if (!info->file->vfs->is_streaming ()) {
if (info->junk >= 0) {
deadbeef->fseek (info->file, info->junk, SEEK_SET);
}
else {
info->junk = 0;
}
}
else {
deadbeef->fset_track (info->file, it);
}
info->mp4track = -1;
#if USE_MP4FF
info->mp4reader.read = aac_fs_read;
info->mp4reader.write = NULL;
info->mp4reader.seek = aac_fs_seek;
info->mp4reader.truncate = NULL;
info->mp4reader.user_data = info;
#else
info->mp4reader.open = aac_fs_open;
info->mp4reader.seek = aac_fs_seek;
info->mp4reader.read = aac_fs_read;
info->mp4reader.write = NULL;
info->mp4reader.close = aac_fs_close;
#endif
if (!info->file->vfs->is_streaming ()) {
#ifdef USE_MP4FF
trace ("aac_init: mp4ff_open_read %s\n", deadbeef->pl_find_meta (it, ":URI"));
info->mp4file = mp4ff_open_read (&info->mp4reader);
if (info->mp4file) {
int ntracks = mp4ff_total_tracks (info->mp4file);
if (ntracks > 0) {
trace ("m4a container detected, ntracks=%d\n", ntracks);
int i = -1;
unsigned char* buff = 0;
unsigned int buff_size = 0;
for (i = 0; i < ntracks; i++) {
mp4AudioSpecificConfig mp4ASC;
mp4ff_get_decoder_config (info->mp4file, i, &buff, &buff_size);
if(buff){
int rc = AudioSpecificConfig(buff, buff_size, &mp4ASC);
if(rc < 0)
continue;
break;
}
}
trace ("mp4 probe-buffer size: %d\n", buff_size);
if (i != ntracks && buff)
{
trace ("mp4 track: %d\n", i);
int samples = mp4ff_num_samples(info->mp4file, i);
info->mp4samples = samples;
info->mp4track = i;
// init mp4 decoding
info->dec = NeAACDecOpen ();
unsigned long srate;
unsigned char ch;
if (NeAACDecInit2(info->dec, buff, buff_size, &srate, &ch) < 0) {
trace ("NeAACDecInit2 returned error\n");
free (buff);
return -1;
}
samplerate = srate;
channels = ch;
samples = (int64_t)samples * srate / mp4ff_time_scale (info->mp4file, i);
totalsamples = samples;
NeAACDecConfigurationPtr conf = NeAACDecGetCurrentConfiguration (info->dec);
conf->dontUpSampleImplicitSBR = 1;
NeAACDecSetConfiguration (info->dec, conf);
mp4AudioSpecificConfig mp4ASC;
if (NeAACDecAudioSpecificConfig(buff, buff_size, &mp4ASC) >= 0)
{
info->mp4framesize = 1024;
if (mp4ASC.frameLengthFlag == 1) {
info->mp4framesize = 960;
}
// if (mp4ASC.sbr_present_flag == 1) {
// info->mp4framesize *= 2;
// }
}
totalsamples *= info->mp4framesize;
duration = (float)totalsamples / samplerate;
}
else {
mp4ff_close (info->mp4file);
info->mp4file = NULL;
}
if (buff) {
free (buff);
}
}
else {
mp4ff_close (info->mp4file);
info->mp4file = NULL;
}
}
// {{{ libmp4v2 code
#else
trace ("aac_init: MP4ReadProvider %s\n", deadbeef->pl_find_meta (it, ":URI"));
info->mp4file = MP4ReadProvider (deadbeef->pl_find_meta (it, ":URI"), 0, &info->mp4reader);
info->mp4track = MP4FindTrackId(info->mp4file, 0, "audio", 0);
trace ("aac_init: MP4FindTrackId returned %d\n", info->mp4track);
if (info->mp4track >= 0) {
info->timescale = MP4GetTrackTimeScale(info->mp4file, info->mp4track);
u_int8_t* pConfig;
uint32_t configSize = 0;
bool res = MP4GetTrackESConfiguration(info->mp4file, info->mp4track, &pConfig, &configSize);
mp4AudioSpecificConfig mp4ASC;
int rc = AudioSpecificConfig(pConfig, configSize, &mp4ASC);
if (rc >= 0) {
_info->samplerate = mp4ASC.samplingFrequency;
_info->channels = MP4GetTrackAudioChannels (info->mp4file, info->mp4track);
totalsamples = MP4GetTrackNumberOfSamples (info->mp4file, info->mp4track) * 1024 * _info->channels;
// init mp4 decoding
info->dec = NeAACDecOpen ();
unsigned long srate;
unsigned char ch;
if (NeAACDecInit2(info->dec, pConfig, configSize, &srate, &ch) < 0) {
trace ("NeAACDecInit2 returned error\n");
return -1;
}
samplerate = srate;
channels = ch;
NeAACDecConfigurationPtr conf = NeAACDecGetCurrentConfiguration (info->dec);
conf->dontUpSampleImplicitSBR = 1;
NeAACDecSetConfiguration (info->dec, conf);
mp4AudioSpecificConfig mp4ASC;
if (NeAACDecAudioSpecificConfig(pConfig, configSize, &mp4ASC) >= 0)
{
info->mp4framesize = 1024;
if (mp4ASC.frameLengthFlag == 1) {
info->mp4framesize = 960;
}
// if (mp4ASC.sbr_present_flag == 1) {
// info->mp4framesize *= 2;
// }
}
//totalsamples *= info->mp4framesize;
free (pConfig);
info->maxSampleSize = MP4GetTrackMaxSampleSize(info->mp4file, info->mp4track);
info->samplebuffer = malloc (info->maxSampleSize);
info->mp4sample = 1;
}
else {
MP4Close (info->mp4file);
info->mp4file = NULL;
}
}
else {
MP4Close (info->mp4file);
info->mp4file = NULL;
}
#endif
// }}}
if (!info->mp4file) {
trace ("mp4 track not found, looking for aac stream...\n");
if (info->junk >= 0) {
deadbeef->fseek (info->file, info->junk, SEEK_SET);
}
else {
deadbeef->rewind (info->file);
}
int offs = parse_aac_stream (info->file, &samplerate, &channels, &duration, &totalsamples);
if (offs == -1) {
trace ("aac stream not found\n");
return -1;
}
if (offs > info->junk) {
info->junk = offs;
}
if (info->junk >= 0) {
deadbeef->fseek (info->file, info->junk, SEEK_SET);
}
else {
deadbeef->rewind (info->file);
}
trace ("found aac stream (junk: %d, offs: %d)\n", info->junk, offs);
}
_info->fmt.channels = channels;
_info->fmt.samplerate = samplerate;
}
else {
// sync before attempting to init
int samplerate, channels;
float duration;
int offs = parse_aac_stream (info->file, &samplerate, &channels, &duration, NULL);
if (offs < 0) {
trace ("aac: parse_aac_stream failed\n");
return -1;
}
if (offs > info->junk) {
info->junk = offs;
}
trace("parse_aac_stream returned %x\n", offs);
deadbeef->pl_replace_meta (it, "!FILETYPE", "AAC");
}
// duration = (float)totalsamples / samplerate;
// deadbeef->pl_set_item_duration (it, duration);
_info->fmt.bps = 16;
_info->plugin = &plugin;
if (!info->mp4file) {
//trace ("NeAACDecGetCapabilities\n");
//unsigned long caps = NeAACDecGetCapabilities();
trace ("NeAACDecOpen\n");
info->dec = NeAACDecOpen ();
trace ("prepare for NeAACDecInit: fread %d from offs %lld\n", AAC_BUFFER_SIZE, deadbeef->ftell (info->file));
info->remaining = deadbeef->fread (info->buffer, 1, AAC_BUFFER_SIZE, info->file);
NeAACDecConfigurationPtr conf = NeAACDecGetCurrentConfiguration (info->dec);
// conf->dontUpSampleImplicitSBR = 1;
NeAACDecSetConfiguration (info->dec, conf);
unsigned long srate;
unsigned char ch;
trace ("NeAACDecInit (%d bytes)\n", info->remaining);
int consumed = NeAACDecInit (info->dec, info->buffer, info->remaining, &srate, &ch);
trace ("NeAACDecInit returned samplerate=%d, channels=%d, consumed: %d\n", (int)srate, (int)ch, consumed);
if (consumed < 0) {
trace ("NeAACDecInit returned %d\n", consumed);
return -1;
}
if (consumed > info->remaining) {
trace ("NeAACDecInit consumed more than available! wtf?\n");
return -1;
}
if (consumed == info->remaining) {
info->remaining = 0;
}
else if (consumed > 0) {
memmove (info->buffer, info->buffer + consumed, info->remaining - consumed);
info->remaining -= consumed;
}
_info->fmt.channels = ch;
_info->fmt.samplerate = srate;
}
if (!info->file->vfs->is_streaming ()) {
if (it->endsample > 0) {
info->startsample = it->startsample;
info->endsample = it->endsample;
plugin.seek_sample (_info, 0);
}
else {
info->startsample = 0;
info->endsample = totalsamples-1;
}
}
trace ("totalsamples: %d, endsample: %d, samples-from-duration: %d\n", totalsamples-1, info->endsample, (int)deadbeef->pl_get_item_duration (it)*44100);
for (int i = 0; i < _info->fmt.channels; i++) {
_info->fmt.channelmask |= 1 << i;
}
info->noremap = 0;
info->remap[0] = -1;
trace ("init success\n");
return 0;
}
Result SoundSourceM4A::tryOpen(const AudioSourceConfig& audioSrcCfg) {
DEBUG_ASSERT(MP4_INVALID_FILE_HANDLE == m_hFile);
// open MP4 file, check for >= ver 1.9.1
// From mp4v2/file.h:
// * On Windows, this should be a UTF-8 encoded string.
// * On other platforms, it should be an 8-bit encoding that is
// * appropriate for the platform, locale, file system, etc.
// * (prefer to use UTF-8 when possible).
#if MP4V2_PROJECT_version_hex <= 0x00010901
m_hFile = MP4Read(getLocalFileName().toUtf8().constData(), 0);
#else
m_hFile = MP4Read(getLocalFileName().toUtf8().constData());
#endif
if (MP4_INVALID_FILE_HANDLE == m_hFile) {
qWarning() << "Failed to open file for reading:" << getUrlString();
return ERR;
}
m_trackId = findFirstAudioTrackId(m_hFile);
if (MP4_INVALID_TRACK_ID == m_trackId) {
qWarning() << "No AAC track found:" << getUrlString();
return ERR;
}
// Read fixed sample duration. If the sample duration is not
// fixed (that is, if the number of frames per sample block varies
// through the file), the call returns MP4_INVALID_DURATION. We
// can't currently handle these.
m_framesPerSampleBlock = MP4GetTrackFixedSampleDuration(m_hFile, m_trackId);
if (MP4_INVALID_DURATION == m_framesPerSampleBlock) {
qWarning() << "Unable to decode tracks with non-fixed sample durations: " << getUrlString();
return ERR;
}
const MP4SampleId numberOfSamples =
MP4GetTrackNumberOfSamples(m_hFile, m_trackId);
if (0 >= numberOfSamples) {
qWarning() << "Failed to read number of samples from file:" << getUrlString();
return ERR;
}
m_maxSampleBlockId = kSampleBlockIdMin + (numberOfSamples - 1);
// Determine the maximum input size (in bytes) of a
// sample block for the selected track.
const u_int32_t maxSampleBlockInputSize = MP4GetTrackMaxSampleSize(m_hFile,
m_trackId);
m_inputBuffer.resize(maxSampleBlockInputSize, 0);
DEBUG_ASSERT(nullptr == m_hDecoder); // not already opened
m_hDecoder = NeAACDecOpen();
if (!m_hDecoder) {
qWarning() << "Failed to open the AAC decoder!";
return ERR;
}
NeAACDecConfigurationPtr pDecoderConfig = NeAACDecGetCurrentConfiguration(
m_hDecoder);
pDecoderConfig->outputFormat = FAAD_FMT_FLOAT;
if ((kChannelCountMono == audioSrcCfg.channelCountHint) ||
(kChannelCountStereo == audioSrcCfg.channelCountHint)) {
pDecoderConfig->downMatrix = 1;
} else {
pDecoderConfig->downMatrix = 0;
}
pDecoderConfig->defObjectType = LC;
if (!NeAACDecSetConfiguration(m_hDecoder, pDecoderConfig)) {
qWarning() << "Failed to configure AAC decoder!";
return ERR;
}
u_int8_t* configBuffer = nullptr;
u_int32_t configBufferSize = 0;
if (!MP4GetTrackESConfiguration(m_hFile, m_trackId, &configBuffer,
&configBufferSize)) {
/* failed to get mpeg-4 audio config... this is ok.
* NeAACDecInit2() will simply use default values instead.
*/
qWarning() << "Failed to read the MP4 audio configuration."
<< "Continuing with default values.";
}
SAMPLERATE_TYPE sampleRate;
unsigned char channelCount;
if (0 > NeAACDecInit2(m_hDecoder, configBuffer, configBufferSize,
&sampleRate, &channelCount)) {
free(configBuffer);
qWarning() << "Failed to initialize the AAC decoder!";
return ERR;
} else {
free(configBuffer);
}
// Calculate how many sample blocks we need to decode in advance
// of a random seek in order to get the recommended number of
// prefetch frames
m_numberOfPrefetchSampleBlocks = (kNumberOfPrefetchFrames +
(m_framesPerSampleBlock - 1)) / m_framesPerSampleBlock;
setChannelCount(channelCount);
setFrameRate(sampleRate);
setFrameCount(((m_maxSampleBlockId - kSampleBlockIdMin) + 1) * m_framesPerSampleBlock);
// Resize temporary buffer for decoded sample data
const SINT sampleBufferCapacity =
frames2samples(m_framesPerSampleBlock);
m_sampleBuffer.resetCapacity(sampleBufferCapacity);
// Invalidate current position to enforce the following
// seek operation
m_curFrameIndex = getMaxFrameIndex();
// (Re-)Start decoding at the beginning of the file
seekSampleFrame(getMinFrameIndex());
return OK;
}
extern "C" bool MP4AV_Rfc3016LatmHinter (MP4FileHandle mp4File,
MP4TrackId mediaTrackId,
u_int16_t maxPayloadSize)
{
u_int32_t numSamples = MP4GetTrackNumberOfSamples(mp4File, mediaTrackId);
u_int32_t maxSampleSize = MP4GetTrackMaxSampleSize(mp4File, mediaTrackId);
MP4Duration sampleDuration =
MP4AV_GetAudioSampleDuration(mp4File, mediaTrackId);
if (sampleDuration == MP4_INVALID_DURATION) {
return false;
}
if (numSamples == 0 || maxSampleSize == 0) {
return false;
}
/* get the mpeg4 video configuration */
u_int8_t* pAudioSpecificConfig;
u_int32_t AudioSpecificConfigSize;
if (MP4GetTrackESConfiguration(mp4File, mediaTrackId,
&pAudioSpecificConfig,
&AudioSpecificConfigSize) == false)
return false;
if (pAudioSpecificConfig == NULL ||
AudioSpecificConfigSize == 0) return false;
uint8_t channels = MP4AV_AacConfigGetChannels(pAudioSpecificConfig);
uint32_t freq = MP4AV_AacConfigGetSamplingRate(pAudioSpecificConfig);
uint8_t type = MP4AV_AacConfigGetAudioObjectType(pAudioSpecificConfig);
uint8_t *pConfig;
uint32_t configSize;
MP4AV_LatmGetConfiguration(&pConfig, &configSize,
pAudioSpecificConfig, AudioSpecificConfigSize);
free(pAudioSpecificConfig);
if (pConfig == NULL || configSize == 0) {
CHECK_AND_FREE(pConfig);
return false;
}
MP4TrackId hintTrackId =
MP4AddHintTrack(mp4File, mediaTrackId);
if (hintTrackId == MP4_INVALID_TRACK_ID) {
free(pConfig);
return false;
}
u_int8_t payloadNumber = MP4_SET_DYNAMIC_PAYLOAD;
char buffer[10];
if (channels != 1) {
snprintf(buffer, sizeof(buffer), "%u", channels);
}
/* convert it into ASCII form */
char* sConfig = MP4BinaryToBase16(pConfig, configSize);
free(pConfig);
if (sConfig == NULL ||
MP4SetHintTrackRtpPayload(mp4File, hintTrackId,
"MP4A-LATM", &payloadNumber, 0,
channels != 1 ? buffer : NULL) == false) {
MP4DeleteTrack(mp4File, hintTrackId);
return false;
}
uint32_t profile_level;
// from gpac code
switch (type) {
case 2:
if (channels <= 2) profile_level = freq <= 24000 ? 0x28 : 0x29;
else profile_level = freq <= 48000 ? 0x2a : 0x2b;
break;
case 5:
if (channels <= 2) profile_level = freq < 24000 ? 0x2c : 0x2d;
else profile_level = freq <= 48000 ? 0x2e : 0x2f;
break;
default:
if (channels <= 2) profile_level = freq < 24000 ? 0x0e : 0x0f;
else profile_level = 0x10;
break;
}
/* create the appropriate SDP attribute */
char* sdpBuf = (char*)malloc(strlen(sConfig) + 128);
if (sdpBuf == NULL) {
free(sConfig);
MP4DeleteTrack(mp4File, hintTrackId);
return false;
}
snprintf(sdpBuf,
strlen(sConfig) + 128,
"a=fmtp:%u profile-level-id=%u; cpresent=0; config=%s;\015\012",
payloadNumber,
profile_level,
sConfig);
/* add this to the track's sdp */
bool val = MP4AppendHintTrackSdp(mp4File, hintTrackId, sdpBuf);
free(sConfig);
free(sdpBuf);
if (val == false) {
MP4DeleteTrack(mp4File, hintTrackId);
return false;
}
for (MP4SampleId sampleId = 1; sampleId <= numSamples; sampleId++) {
uint8_t buffer[32];
uint32_t offset = 0;
uint32_t sampleSize =
MP4GetSampleSize(mp4File, mediaTrackId, sampleId);
uint32_t size_left = sampleSize;
while (size_left > 0) {
if (size_left > 0xff) {
size_left -= 0xff;
buffer[offset] = 0xff;
} else {
buffer[offset] = size_left;
size_left = 0;
}
offset++;
}
if (MP4AddRtpHint(mp4File, hintTrackId) == false ||
MP4AddRtpPacket(mp4File, hintTrackId, true) == false ||
MP4AddRtpImmediateData(mp4File, hintTrackId,
buffer, offset) == false ||
MP4AddRtpSampleData(mp4File, hintTrackId,
sampleId, 0, sampleSize) == false ||
MP4WriteRtpHint(mp4File, hintTrackId, sampleDuration) == false) {
MP4DeleteTrack(mp4File, hintTrackId);
return false;
}
}
return true;
}
static void DumpTrack (MP4FileHandle mp4file, MP4TrackId tid,
bool dump_off, bool dump_rend)
{
uint32_t numSamples;
MP4SampleId sid;
uint8_t *buffer;
uint32_t max_frame_size;
uint32_t timescale;
uint64_t msectime;
const char *media_data_name;
uint32_t len_size = 0;
uint8_t video_type = 0;
numSamples = MP4GetTrackNumberOfSamples(mp4file, tid);
max_frame_size = MP4GetTrackMaxSampleSize(mp4file, tid) + 4;
media_data_name = MP4GetTrackMediaDataName(mp4file, tid);
if (strcasecmp(media_data_name, "avc1") == 0) {
MP4GetTrackH264LengthSize(mp4file, tid, &len_size);
} else if (strcasecmp(media_data_name, "mp4v") == 0) {
video_type = MP4GetTrackEsdsObjectTypeId(mp4file, tid);
}
buffer = (uint8_t *)malloc(max_frame_size);
if (buffer == NULL) {
printf("couldn't get buffer\n");
return;
}
timescale = MP4GetTrackTimeScale(mp4file, tid);
printf("mp4file %s, track %d, samples %d, timescale %d\n",
Mp4FileName, tid, numSamples, timescale);
for (sid = 1; sid <= numSamples; sid++) {
MP4Timestamp sampleTime;
MP4Duration sampleDuration, sampleRenderingOffset;
bool isSyncSample = FALSE;
bool ret;
u_int8_t *temp;
uint32_t this_frame_size = max_frame_size;
temp = buffer;
ret = MP4ReadSample(mp4file,
tid,
sid,
&temp,
&this_frame_size,
&sampleTime,
&sampleDuration,
&sampleRenderingOffset,
&isSyncSample);
msectime = sampleTime;
msectime *= TO_U64(1000);
msectime /= timescale;
printf("sampleId %6d, size %5u time "U64"("U64")",
sid, MP4GetSampleSize(mp4file, tid, sid),
sampleTime, msectime);
if (dump_rend) printf(" %6"U64F, sampleRenderingOffset);
if (strcasecmp(media_data_name, "mp4v") == 0) {
if (MP4_IS_MPEG4_VIDEO_TYPE(video_type))
ParseMpeg4(temp, this_frame_size, dump_off);
} else if (strcasecmp(media_data_name, "avc1") == 0) {
ParseH264(temp, this_frame_size, len_size, dump_off);
}
printf("\n");
}
}
void main(int argc, char** argv)
{
if (argc < 2) {
fprintf(stderr, "Usage: %s <file>\n", argv[0]);
exit(1);
}
//u_int32_t verbosity = MP4_DETAILS_ALL;
char* fileName = argv[1];
// open the mp4 file, and read meta-info
MP4FileHandle mp4File = MP4Read(fileName );
uint8_t profileLevel = MP4GetVideoProfileLevel(mp4File);
// get a handle on the first video track
MP4TrackId trackId = MP4FindTrackId(mp4File, 0, "video");
// gather the crucial track information
uint32_t timeScale = MP4GetTrackTimeScale(mp4File, trackId);
// note all times and durations
// are in units of the track time scale
MP4Duration trackDuration = MP4GetTrackDuration(mp4File, trackId);
MP4SampleId numSamples = MP4GetTrackNumberOfSamples(mp4File, trackId);
uint32_t maxSampleSize = MP4GetTrackMaxSampleSize(mp4File, trackId);
uint8_t* pConfig;
uint32_t configSize = 0;
MP4GetTrackESConfiguration(mp4File, trackId, &pConfig, &configSize);
// initialize decoder with Elementary Stream (ES) configuration
// done with our copy of ES configuration
free(pConfig);
// now consecutively read and display the track samples
uint8_t* pSample = (uint8_t*)malloc(maxSampleSize);
uint32_t sampleSize;
MP4Timestamp sampleTime;
MP4Duration sampleDuration;
MP4Duration sampleRenderingOffset;
bool isSyncSample;
for (MP4SampleId sampleId = 1; sampleId <= numSamples; sampleId++) {
// give ReadSample our own buffer, and let it know how big it is
sampleSize = maxSampleSize;
// read next sample from video track
MP4ReadSample(mp4File, trackId, sampleId,
&pSample, &sampleSize,
&sampleTime, &sampleDuration, &sampleRenderingOffset,
&isSyncSample);
// convert timestamp and duration from track time to milliseconds
uint64_t myTime = MP4ConvertFromTrackTimestamp(mp4File, trackId,
sampleTime, MP4_MSECS_TIME_SCALE);
uint64_t myDuration = MP4ConvertFromTrackDuration(mp4File, trackId,
sampleDuration, MP4_MSECS_TIME_SCALE);
// decode frame and display it
}
// close mp4 file
MP4Close(mp4File);
// Note to seek to time 'when' in the track
// use MP4GetSampleIdFromTime(MP4FileHandle hFile,
// MP4Timestamp when, bool wantSyncSample)
// 'wantSyncSample' determines if a sync sample is desired or not
// e.g.
// MP4Timestamp when =
// MP4ConvertToTrackTimestamp(mp4File, trackId, 30, MP4_SECS_TIME_SCALE);
// MP4SampleId newSampleId = MP4GetSampleIdFromTime(mp4File, when, true);
// MP4ReadSample(mp4File, trackId, newSampleId, ...);
//
// Note that start time for sample may be later than 'when'
exit(0);
}
