/*
TODO: decode more than 1024 samples at a time and mix both the mp4 and aac on stream r
*/
mm_word mp4_on_stream_request( mm_word length, mm_addr dest, mm_stream_formats format ) {
int decoded = 0;
int ret = 0;
/* We'll always output 1024 (nah almost) samples */
if(length >=1024) {
readOff = readBuffer;
int read = 0;
/* The decoder is always fed one aac frame */
if(trackSample < samples) {
read = mp4ff_read_sample_v2(infile, track, trackSample++,readOff);
dataLeft+=read;
memset(readBuffer+dataLeft, 0, AAC_MAINBUF_SIZE - dataLeft);
ret = AACDecode(decoder, &readOff, &dataLeft, dest);
if(trackSample == samples && !Endof)
Endof = MM_BUFFER_SIZE;
decoded += 1024; // 1024 a channel
}
/* Either a sample read error occured , an decoding error occured or simply EOF */
if((!read && !Endof) || ret || (length >= Endof && Endof)) {
mp4ff_close(infile);
needsClosing = true;
return 0;
}
}
visualizeBuffer(dest);
return decoded;
}
static void mp4_getSongTitle(char *filename, char **title, int *len) {
FILE* mp4file;
(*title) = NULL;
(*len) = -1;
if((mp4file = fopen(filename, "rb"))){
mp4_get_file_type(mp4file);
fseek(mp4file, 0, SEEK_SET);
if(mp4cfg.file_type == FILE_MP4){
mp4ff_callback_t* mp4cb;
mp4ff_t* infile;
gint mp4track;
mp4cb = getMP4FF_cb(mp4file);
if ((infile = mp4ff_open_read_metaonly(mp4cb)) &&
((mp4track = getAACTrack(infile)) >= 0)){
(*title) = getMP4title(infile, filename);
double track_duration = mp4ff_get_track_duration(infile, mp4track);
unsigned long time_scale = mp4ff_time_scale(infile, mp4track);
unsigned long length = (track_duration * 1000 / time_scale);
(*len) = length;
}
if(infile) mp4ff_close(infile);
if(mp4cb) g_free(mp4cb);
}
else{
// Check AAC ID3 tag...
}
fclose(mp4file);
}
}
static mp4ff_t *mp4ff_open_read_int(mp4ff_callback_t *f, int is_streaming)
{
mp4ff_t *ff = malloc(sizeof(mp4ff_t));
memset(ff, 0, sizeof(mp4ff_t));
ff->stream = f;
if (parse_atoms_int(ff,is_streaming,is_streaming) < 0) {
mp4ff_close (ff);
return NULL;
}
return ff;
}
static void
aac_free (DB_fileinfo_t *_info) {
aac_info_t *info = (aac_info_t *)_info;
if (info) {
if (info->file) {
deadbeef->fclose (info->file);
}
if (info->mp4) {
mp4ff_close (info->mp4);
}
if (info->dec) {
NeAACDecClose (info->dec);
}
free (info);
}
}
int
aac_read_metadata (DB_playItem_t *it) {
deadbeef->pl_lock ();
DB_FILE *fp = deadbeef->fopen (deadbeef->pl_find_meta (it, ":URI"));
deadbeef->pl_unlock ();
if (!fp) {
return -1;
}
if (fp->vfs->is_streaming ()) {
deadbeef->fclose (fp);
return -1;
}
aac_info_t inf;
memset (&inf, 0, sizeof (inf));
inf.file = fp;
inf.junk = deadbeef->junk_get_leading_size (fp);
if (inf.junk >= 0) {
deadbeef->fseek (inf.file, inf.junk, SEEK_SET);
}
else {
inf.junk = 0;
}
MP4FILE_CB cb = {
.read = aac_fs_read,
.write = NULL,
.seek = aac_fs_seek,
.truncate = NULL,
.user_data = &inf
};
deadbeef->pl_delete_all_meta (it);
mp4ff_t *mp4 = mp4ff_open_read (&cb);
if (mp4) {
aac_load_tags (it, mp4);
mp4ff_close (mp4);
}
/*int apeerr = */deadbeef->junk_apev2_read (it, fp);
/*int v2err = */deadbeef->junk_id3v2_read (it, fp);
/*int v1err = */deadbeef->junk_id3v1_read (it, fp);
deadbeef->fclose (fp);
return 0;
}
static void finalize_mp4(value e)
{
mp4_t *mp = Mp4_val(e);
if (mp->ff)
mp4ff_close(mp->ff);
if (mp->read_cb)
caml_remove_global_root(&mp->read_cb);
if (mp->write_cb)
caml_remove_global_root(&mp->write_cb);
if (mp->seek_cb)
caml_remove_global_root(&mp->seek_cb);
if (mp->trunc_cb)
caml_remove_global_root(&mp->trunc_cb);
free(mp);
}
static void
xmms_mp4_destroy (xmms_xform_t *xform)
{
xmms_mp4_data_t *data;
g_return_if_fail (xform);
data = xmms_xform_private_data_get (xform);
g_return_if_fail (data);
if (data->mp4ff) {
mp4ff_close (data->mp4ff);
}
g_free (data->mp4ff_cb);
g_string_free (data->outbuf, TRUE);
g_free (data);
}
static void
aac_free (DB_fileinfo_t *_info) {
aac_info_t *info = (aac_info_t *)_info;
if (info) {
if (info->file) {
deadbeef->fclose (info->file);
}
if (info->mp4file) {
#ifdef USE_MP4FF
mp4ff_close (info->mp4file);
#else
MP4Close (info->mp4file);
#endif
}
if (info->dec) {
NeAACDecClose (info->dec);
}
free (info);
}
}
FXbool MP4Reader::init(InputPlugin*plugin) {
ReaderPlugin::init(plugin);
if (handle) {
mp4ff_close(handle);
handle=NULL;
}
callback.read = mp4_read;
callback.write = mp4_write;
callback.seek = mp4_seek;
callback.truncate = mp4_truncate;
callback.user_data = input;
track=-1;
frame=0;
nframes=-1;
flags&=~FLAG_PARSED;
return true;
}
int
aac_read_metadata (DB_playItem_t *it) {
#ifdef USE_MP4FF
DB_FILE *fp = deadbeef->fopen (deadbeef->pl_find_meta (it, ":URI"));
if (!fp) {
return -1;
}
if (fp->vfs->is_streaming ()) {
deadbeef->fclose (fp);
return -1;
}
MP4FILE_CB cb = {
.read = aac_fs_read,
.write = NULL,
.seek = aac_fs_seek,
.truncate = NULL,
.user_data = fp
};
deadbeef->pl_delete_all_meta (it);
mp4ff_t *mp4 = mp4ff_open_read (&cb);
if (mp4) {
aac_load_tags (it, mp4);
mp4ff_close (mp4);
deadbeef->pl_add_meta (it, "title", NULL);
}
else {
/*int apeerr = */deadbeef->junk_apev2_read (it, fp);
/*int v2err = */deadbeef->junk_id3v2_read (it, fp);
/*int v1err = */deadbeef->junk_id3v1_read (it, fp);
deadbeef->pl_add_meta (it, "title", NULL);
}
deadbeef->fclose (fp);
#endif
return 0;
}
int fdpl_decode_MP4(const char *file_path, size_t &ch, size_t &sr, size_t &samples, std::vector<float> *ch1, std::vector<float> *ch2)
{
unsigned int track;
uint32_t samplerate;//these for init, we prefer to take the ones at frameInfo
unsigned char channels;
void *sample_buffer;
mp4ff_t *infile;
FILE *mp4File;
int sampleId, numSamples;
faacDecHandle hDecoder;
faacDecFrameInfo frameInfo;
unsigned char *buffer;
unsigned int buffer_size;
/* initialise the callback structure */
mp4ff_callback_t *mp4cb;
mp4cb = (mp4ff_callback_t *)malloc(sizeof(mp4ff_callback_t));
mp4File = fopen(file_path, "rb");
mp4cb->read = read_callback;
mp4cb->seek = seek_callback;
mp4cb->user_data = mp4File;
infile = mp4ff_open_read(mp4cb);
if (!infile)
{
/* unable to open file */
std::cerr<<"Error opening file "<< file_path <<std::endl;
return 1;
}
if ((track = GetAACTrack(infile)) < 0)
{
std::cerr<<"Unable to find correct AAC sound track in the MP4 file"<<std::endl;
mp4ff_close(infile);
free(mp4cb);
fclose(mp4File);
return 1;
}
buffer = NULL;
buffer_size = 0;
mp4ff_get_decoder_config(infile, track, &buffer, &buffer_size);
hDecoder = faacDecOpen();
if(faacDecInit2(hDecoder, buffer, buffer_size, &samplerate, &channels) < 0)
{
/* If some error initializing occured, skip the file */
std::cerr<<"Error initializing decoder library"<<std::endl;
faacDecClose(hDecoder);
mp4ff_close(infile);
free(mp4cb);
fclose(mp4File);
return 1;
}
if (buffer)
free(buffer);
numSamples = mp4ff_num_samples(infile, track);
samples = 0;
//firstTime = 1;
for (sampleId = 0; sampleId < numSamples; sampleId++)
{
int rc;
/* get access unit from MP4 file */
buffer = NULL;
buffer_size = 0;
rc = mp4ff_read_sample(infile, track, sampleId, &buffer, &buffer_size);
if (rc == 0)
{
std::cerr<<"error while decoding"<<std::endl;
faacDecClose(hDecoder);
mp4ff_close(infile);
free(mp4cb);
fclose(mp4File);
return 1;
}
sample_buffer = faacDecDecode(hDecoder, &frameInfo, buffer, buffer_size);
if (buffer)
free(buffer);
if ((frameInfo.error == 0) && (frameInfo.samples > 0) && (frameInfo.channels < 3))
{
size_t samples_channel = (size_t)frameInfo.samples/(size_t)frameInfo.channels;
samples += samples_channel;
float *pcm;
pcm = (float *)sample_buffer;
for(size_t i=0; i<samples_channel; i++){
//writing the samples of each channel in separate float vectors
for(size_t j=0; j<frameInfo.channels; j++){
if(j==0){
ch1 -> push_back(pcm[i*frameInfo.channels+j]);
}else if(j==1){
ch2 -> push_back(pcm[i*frameInfo.channels+j]);
}else{
std::cerr<<"Unexpected number of channels: "<<j<<std::endl;
return -1;
}
}
}
}
if (frameInfo.error > 0)
{
std::cerr<<"error: "<<faacDecGetErrorMessage(frameInfo.error)<<std::endl;
break;
}
}
ch = frameInfo.channels;
sr = frameInfo.samplerate;
faacDecClose(hDecoder);
mp4ff_close(infile);
free(mp4cb);
fclose(mp4File);
return frameInfo.error;
}
static DB_playItem_t *
aac_insert (ddb_playlist_t *plt, DB_playItem_t *after, const char *fname) {
trace ("adding %s\n", fname);
DB_FILE *fp = deadbeef->fopen (fname);
if (!fp) {
trace ("not found\n");
return NULL;
}
aac_info_t info = {0};
info.junk = deadbeef->junk_get_leading_size (fp);
if (info.junk >= 0) {
trace ("junk: %d\n", info.junk);
deadbeef->fseek (fp, info.junk, SEEK_SET);
}
else {
info.junk = 0;
}
const char *ftype = NULL;
float duration = -1;
int totalsamples = 0;
int samplerate = 0;
int channels = 0;
int mp4track = -1;
MP4FILE mp4 = NULL;
if (fp->vfs->is_streaming ()) {
trace ("streaming aac (%s)\n", fname);
ftype = "RAW AAC";
}
else {
// slowwww!
info.file = fp;
MP4FILE_CB cb = {
.read = aac_fs_read,
.write = NULL,
.seek = aac_fs_seek,
.truncate = NULL,
.user_data = &info
};
mp4ff_t *mp4 = mp4ff_open_read (&cb);
if (mp4) {
int ntracks = mp4ff_total_tracks (mp4);
trace ("aac: numtracks=%d\n", ntracks);
int i;
for (i = 0; i < ntracks; i++) {
if (mp4ff_get_track_type (mp4, i) != TRACK_AUDIO) {
trace ("aac: track %d is not audio\n", i);
continue;
}
int mp4framesize;
int res = mp4_track_get_info (mp4, i, &duration, &samplerate, &channels, &totalsamples, &mp4framesize);
if (res >= 0 && duration > 0) {
trace ("aac: found audio track %d (duration=%f, totalsamples=%d)\n", i, duration, totalsamples);
int num_chapters;
aac_chapter_t *chapters = NULL;
if (mp4ff_chap_get_num_tracks(mp4) > 0) {
chapters = aac_load_itunes_chapters (mp4, &num_chapters, samplerate);
}
DB_playItem_t *it = deadbeef->pl_item_alloc_init (fname, plugin.plugin.id);
ftype = "MP4 AAC";
deadbeef->pl_add_meta (it, ":FILETYPE", ftype);
deadbeef->pl_set_meta_int (it, ":TRACKNUM", i);
deadbeef->plt_set_item_duration (plt, it, duration);
aac_load_tags (it, mp4);
int apeerr = deadbeef->junk_apev2_read (it, fp);
int v2err = deadbeef->junk_id3v2_read (it, fp);
int v1err = deadbeef->junk_id3v1_read (it, fp);
int64_t fsize = deadbeef->fgetlength (fp);
char s[100];
snprintf (s, sizeof (s), "%lld", fsize);
deadbeef->pl_add_meta (it, ":FILE_SIZE", s);
deadbeef->pl_add_meta (it, ":BPS", "16");
snprintf (s, sizeof (s), "%d", channels);
deadbeef->pl_add_meta (it, ":CHANNELS", s);
snprintf (s, sizeof (s), "%d", samplerate);
deadbeef->pl_add_meta (it, ":SAMPLERATE", s);
int br = (int)roundf(fsize / duration * 8 / 1000);
snprintf (s, sizeof (s), "%d", br);
deadbeef->pl_add_meta (it, ":BITRATE", s);
// embedded chapters
deadbeef->pl_lock (); // FIXME: is it needed?
if (chapters && num_chapters > 0) {
DB_playItem_t *cue = aac_insert_with_chapters (plt, after, it, chapters, num_chapters, totalsamples, samplerate);
for (int n = 0; n < num_chapters; n++) {
if (chapters[n].title) {
free (chapters[n].title);
}
}
free (chapters);
if (cue) {
deadbeef->fclose (fp);
mp4ff_close (mp4);
deadbeef->pl_item_unref (it);
deadbeef->pl_item_unref (cue);
deadbeef->pl_unlock ();
return cue;
}
}
// embedded cue
const char *cuesheet = deadbeef->pl_find_meta (it, "cuesheet");
DB_playItem_t *cue = NULL;
if (cuesheet) {
cue = deadbeef->plt_insert_cue_from_buffer (plt, after, it, cuesheet, strlen (cuesheet), totalsamples, samplerate);
if (cue) {
deadbeef->fclose (fp);
mp4ff_close (mp4);
deadbeef->pl_item_unref (it);
deadbeef->pl_item_unref (cue);
deadbeef->pl_unlock ();
return cue;
}
}
deadbeef->pl_unlock ();
cue = deadbeef->plt_insert_cue (plt, after, it, totalsamples, samplerate);
if (cue) {
deadbeef->pl_item_unref (it);
deadbeef->pl_item_unref (cue);
return cue;
}
after = deadbeef->plt_insert_item (plt, after, it);
deadbeef->pl_item_unref (it);
break;
}
}
mp4ff_close (mp4);
if (i < ntracks) {
deadbeef->fclose (fp);
return after;
}
if (ntracks > 0) {
// mp4 container found, but no valid aac tracks in it
deadbeef->fclose (fp);
return NULL;
}
}
}
trace ("aac: mp4 container failed, trying raw aac\n");
int res = aac_probe (fp, &duration, &samplerate, &channels, &totalsamples);
if (res == -1) {
deadbeef->fclose (fp);
return NULL;
}
ftype = "RAW AAC";
DB_playItem_t *it = deadbeef->pl_item_alloc_init (fname, plugin.plugin.id);
deadbeef->pl_add_meta (it, ":FILETYPE", ftype);
deadbeef->plt_set_item_duration (plt, it, duration);
trace ("duration: %f sec\n", duration);
// read tags
int apeerr = deadbeef->junk_apev2_read (it, fp);
int v2err = deadbeef->junk_id3v2_read (it, fp);
int v1err = deadbeef->junk_id3v1_read (it, fp);
int64_t fsize = deadbeef->fgetlength (fp);
deadbeef->fclose (fp);
if (duration > 0) {
char s[100];
snprintf (s, sizeof (s), "%lld", fsize);
deadbeef->pl_add_meta (it, ":FILE_SIZE", s);
deadbeef->pl_add_meta (it, ":BPS", "16");
snprintf (s, sizeof (s), "%d", channels);
deadbeef->pl_add_meta (it, ":CHANNELS", s);
snprintf (s, sizeof (s), "%d", samplerate);
deadbeef->pl_add_meta (it, ":SAMPLERATE", s);
int br = (int)roundf(fsize / duration * 8 / 1000);
snprintf (s, sizeof (s), "%d", br);
deadbeef->pl_add_meta (it, ":BITRATE", s);
// embedded cue
deadbeef->pl_lock ();
const char *cuesheet = deadbeef->pl_find_meta (it, "cuesheet");
DB_playItem_t *cue = NULL;
if (cuesheet) {
cue = deadbeef->plt_insert_cue_from_buffer (plt, after, it, cuesheet, strlen (cuesheet), totalsamples, samplerate);
if (cue) {
deadbeef->pl_item_unref (it);
deadbeef->pl_item_unref (cue);
deadbeef->pl_unlock ();
return cue;
}
}
deadbeef->pl_unlock ();
cue = deadbeef->plt_insert_cue (plt, after, it, totalsamples, samplerate);
if (cue) {
deadbeef->pl_item_unref (it);
deadbeef->pl_item_unref (cue);
return cue;
}
}
after = deadbeef->plt_insert_item (plt, after, it);
deadbeef->pl_item_unref (it);
return after;
}
MP4Reader::~MP4Reader(){
if (handle) mp4ff_close(handle);
}
int decodeMP4file(char *sndfile, aac_dec_opt *opt)
{
int track;
unsigned long samplerate;
unsigned char channels;
void *sample_buffer;
mp4ff_t *infile;
FILE *mp4File;
int sampleId, numSamples;
audio_file *aufile;
NeAACDecHandle hDecoder;
NeAACDecFrameInfo frameInfo;
unsigned char *buffer;
int buffer_size;
int first_time = 1;
/* initialise the callback structure */
mp4ff_callback_t *mp4cb = malloc(sizeof(mp4ff_callback_t));
mp4File = fopen(opt->filename, "rb");
mp4cb->read = read_callback;
mp4cb->seek = seek_callback;
mp4cb->user_data = mp4File;
infile = mp4ff_open_read(mp4cb);
if (!infile)
{
/* unable to open file */
error_handler("Error opening file: %s\n", opt->filename);
return 1;
}
if ((track = GetAACTrack(infile)) < 0)
{
error_handler("Unable to find correct AAC sound track in the MP4 file.\n");
mp4ff_close(infile);
free(mp4cb);
fclose(mp4File);
return 1;
}
buffer = NULL;
buffer_size = 0;
mp4ff_get_decoder_config(infile, track, &buffer, &buffer_size);
hDecoder = NeAACDecOpen();
if(NeAACDecInit2(hDecoder, buffer, buffer_size, &samplerate, &channels) < 0)
{
/* If some error initializing occured, skip the file */
error_handler("Error initializing decoder library.\n");
NeAACDecClose(hDecoder);
mp4ff_close(infile);
free(mp4cb);
fclose(mp4File);
return 1;
}
if (buffer)
free(buffer);
numSamples = mp4ff_num_samples(infile, track);
for (sampleId = 0; sampleId < numSamples; sampleId++)
{
int rc;
/* get access unit from MP4 file */
buffer = NULL;
buffer_size = 0;
rc = mp4ff_read_sample(infile, track, sampleId, &buffer, &buffer_size);
if (rc == 0)
{
error_handler("Reading from MP4 file failed.\n");
NeAACDecClose(hDecoder);
mp4ff_close(infile);
free(mp4cb);
fclose(mp4File);
return 1;
}
sample_buffer = NeAACDecDecode(hDecoder, &frameInfo, buffer, buffer_size);
if (buffer)
free(buffer);
opt->progress_update((long)numSamples, sampleId);
/* open the sound file now that the number of channels are known */
if (first_time && !frameInfo.error)
{
if(opt->decode_mode == 0)
{
if (Set_WIN_Params (INVALID_FILEDESC, samplerate, SAMPLE_SIZE,
frameInfo.channels) < 0)
{
error_handler("\nCan't access %s\n", "WAVE OUT");
NeAACDecClose(hDecoder);
mp4ff_close(infile);
free(mp4cb);
fclose(mp4File);
return (0);
}
}
else
{
aufile = open_audio_file(sndfile, samplerate, frameInfo.channels,
opt->output_format, opt->file_type, aacChannelConfig2wavexChannelMask(&frameInfo));
if (aufile == NULL)
{
NeAACDecClose(hDecoder);
mp4ff_close(infile);
free(mp4cb);
fclose(mp4File);
return 0;
}
}
first_time = 0;
}
if ((frameInfo.error == 0) && (frameInfo.samples > 0))
{
if(opt->decode_mode == 0)
WIN_Play_Samples((short*)sample_buffer, frameInfo.channels*frameInfo.samples);
else
write_audio_file(aufile, sample_buffer, frameInfo.samples, 0);
}
if (frameInfo.error > 0)
{
error_handler("Error: %s\n",
NeAACDecGetErrorMessage(frameInfo.error));
break;
}
if(stop_decoding)
break;
}
NeAACDecClose(hDecoder);
mp4ff_close(infile);
free(mp4cb);
fclose(mp4File);
if(opt->decode_mode == 0)
WIN_Audio_close();
else
{
if (!first_time)
close_audio_file(aufile);
}
return frameInfo.error;
}
static int
aac_init (DB_fileinfo_t *_info, DB_playItem_t *it) {
aac_info_t *info = (aac_info_t *)_info;
deadbeef->pl_lock ();
info->file = deadbeef->fopen (deadbeef->pl_find_meta (it, ":URI"));
deadbeef->pl_unlock ();
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;
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;
if (!info->file->vfs->is_streaming ()) {
trace ("aac_init: mp4ff_open_read %s\n", deadbeef->pl_find_meta (it, ":URI"));
info->mp4 = mp4ff_open_read (&info->mp4reader);
if (info->mp4) {
int ntracks = mp4ff_total_tracks (info->mp4);
for (int i = 0; i < ntracks; i++) {
if (mp4ff_get_track_type (info->mp4, i) != TRACK_AUDIO) {
continue;
}
int res = mp4_track_get_info (info->mp4, i, &duration, &samplerate, &channels, &totalsamples, &info->mp4framesize);
if (res >= 0 && duration > 0) {
info->mp4track = i;
break;
}
}
trace ("track: %d\n", info->mp4track);
if (info->mp4track >= 0) {
// prepare decoder
int res = mp4_track_get_info (info->mp4, info->mp4track, &duration, &samplerate, &channels, &totalsamples, &info->mp4framesize);
if (res != 0) {
trace ("aac: mp4_track_get_info(%d) returned error\n", info->mp4track);
return -1;
}
// init mp4 decoding
info->mp4samples = mp4ff_num_samples(info->mp4, info->mp4track);
info->dec = NeAACDecOpen ();
unsigned long srate;
unsigned char ch;
unsigned char* buff = 0;
unsigned int buff_size = 0;
mp4AudioSpecificConfig mp4ASC;
mp4ff_get_decoder_config (info->mp4, info->mp4track, &buff, &buff_size);
if (NeAACDecInit2(info->dec, buff, buff_size, &srate, &ch) < 0) {
trace ("NeAACDecInit2 returned error\n");
free (buff);
return -1;
}
if (buff) {
free (buff);
}
trace ("aac: successfully initialized track %d\n", info->mp4track);
_info->fmt.samplerate = samplerate;
_info->fmt.channels = channels;
}
else {
trace ("aac: track not found in mp4 container\n");
mp4ff_close (info->mp4);
info->mp4 = NULL;
}
}
if (!info->mp4) {
trace ("aac: looking for raw 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->mp4) {
trace ("NeAACDecOpen for raw stream\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;
}
}
if (_info->fmt.channels == 7) {
_info->fmt.channels = 8;
}
trace ("totalsamples: %d, endsample: %d, samples-from-duration: %d, samplerate %d, channels %d\n", totalsamples-1, info->endsample, (int)deadbeef->pl_get_item_duration (it)*44100, _info->fmt.samplerate, _info->fmt.channels);
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;
}
static void *mp4Decode(void *args)
{
FILE* mp4file;
pthread_mutex_lock(&mutex);
seekPosition = -1;
bPlaying = TRUE;
if(!(mp4file = fopen(args, "rb"))){
g_print("MP4!AAC - Can't open file\n");
g_free(args);
bPlaying = FALSE;
pthread_mutex_unlock(&mutex);
pthread_exit(NULL);
}
mp4_get_file_type(mp4file);
fseek(mp4file, 0, SEEK_SET);
if(mp4cfg.file_type == FILE_MP4){// We are reading a MP4 file
mp4ff_callback_t* mp4cb;
mp4ff_t* infile;
gint mp4track;
mp4cb = getMP4FF_cb(mp4file);
if(!(infile = mp4ff_open_read(mp4cb))){
g_print("MP4 - Can't open file\n");
goto end;
}
if((mp4track = getAACTrack(infile)) < 0){
/*
* TODO: check here for others Audio format.....
*
*/
g_print("Unsupported Audio track type\n");
g_free(args);
fclose(mp4file);
bPlaying = FALSE;
pthread_mutex_unlock(&mutex);
pthread_exit(NULL);
}else{
NeAACDecHandle decoder;
unsigned char *buffer = NULL;
guint bufferSize = 0;
gulong samplerate;
guchar channels;
//guint avgBitrate;
//MP4Duration duration;
int msDuration;
int numSamples;
int sampleID = 0;
unsigned int framesize;
mp4AudioSpecificConfig mp4ASC;
gchar *xmmstitle;
decoder = NeAACDecOpen();
mp4ff_get_decoder_config(infile, mp4track, &buffer, &bufferSize);
if(NeAACDecInit2(decoder, buffer, bufferSize, &samplerate, &channels)<0){
goto end;
}
if(buffer){
framesize = 1024;
if(NeAACDecAudioSpecificConfig(buffer, bufferSize, &mp4ASC) >= 0){
if(mp4ASC.frameLengthFlag == 1) framesize = 960;
if(mp4ASC.sbr_present_flag == 1) framesize *= 2;
}
g_free(buffer);
}
if(channels == 0){
g_print("Number of Channels not supported\n");
goto end;
}
//duration = MP4GetTrackDuration(mp4file, mp4track);
//msDuration = MP4ConvertFromTrackDuration(mp4file, mp4track,
// duration,MP4_MSECS_TIME_SCALE);
//msDuration = mp4ff_get_track_duration(infile, mp4track);
//printf("%d\n", msDuration);
//numSamples = MP4GetTrackNumberOfSamples(mp4file, mp4track);
numSamples = mp4ff_num_samples(infile, mp4track);
{
float f = 1024.0;
if(mp4ASC.sbr_present_flag == 1)
f = f * 2.0;
msDuration = ((float)numSamples*(float)(f-1.0)/
(float)samplerate)*1000;
}
xmmstitle = getMP4title(infile, args);
mp4_ip.output->open_audio(FMT_S16_NE, samplerate, channels);
mp4_ip.output->flush(0);
mp4_ip.set_info(xmmstitle, msDuration, -1, samplerate/1000, channels);
g_print("MP4 - %d channels @ %ld Hz\n", channels, samplerate);
while(bPlaying){
void* sampleBuffer;
faacDecFrameInfo frameInfo;
gint rc;
if(seekPosition!=-1){
/*
duration = MP4ConvertToTrackDuration(mp4file,
mp4track,
seekPosition*1000,
MP4_MSECS_TIME_SCALE);
sampleID = MP4GetSampleIdFromTime(mp4file, mp4track, duration, 0);
*/
float f = 1024.0;
if(mp4ASC.sbr_present_flag == 1)
f = f * 2.0;
sampleID = (float)seekPosition*(float)samplerate/(float)(f-1.0);
mp4_ip.output->flush(seekPosition*1000);
seekPosition = -1;
}
buffer=NULL;
bufferSize=0;
rc = mp4ff_read_sample(infile, mp4track, sampleID++,
&buffer, &bufferSize);
//g_print("%d/%d\n", sampleID-1, numSamples);
if((rc==0) || (buffer== NULL)){
g_print("MP4: read error\n");
sampleBuffer = NULL;
sampleID=0;
mp4_ip.output->buffer_free();
goto end;
}else{
sampleBuffer = NeAACDecDecode(decoder, &frameInfo, buffer, bufferSize);
if(frameInfo.error > 0){
g_print("MP4: %s\n",
faacDecGetErrorMessage(frameInfo.error));
goto end;
}
if(buffer){
g_free(buffer); buffer=NULL; bufferSize=0;
}
while(bPlaying && mp4_ip.output->buffer_free()<frameInfo.samples<<1)
xmms_usleep(30000);
}
mp4_ip.add_vis_pcm(mp4_ip.output->written_time(),
FMT_S16_NE,
channels,
frameInfo.samples<<1,
sampleBuffer);
mp4_ip.output->write_audio(sampleBuffer, frameInfo.samples<<1);
if(sampleID >= numSamples){
break;
}
}
while(bPlaying && mp4_ip.output->buffer_playing() && mp4_ip.output->buffer_free()){
xmms_usleep(10000);
}
end:
mp4_ip.output->close_audio();
g_free(args);
NeAACDecClose(decoder);
if(infile) mp4ff_close(infile);
if(mp4cb) g_free(mp4cb);
bPlaying = FALSE;
fclose(mp4file);
pthread_mutex_unlock(&mutex);
pthread_exit(NULL);
}
}else{
// WE ARE READING AN AAC FILE
FILE *file = NULL;
NeAACDecHandle decoder = 0;
guchar *buffer = 0;
gulong bufferconsumed = 0;
gulong samplerate = 0;
guchar channels;
gulong buffervalid = 0;
TitleInput* input;
gchar *temp = g_strdup(args);
gchar *ext = strrchr(temp, '.');
gchar *xmmstitle = NULL;
NeAACDecConfigurationPtr config;
if((file = fopen(args, "rb")) == 0){
g_print("AAC: can't find file %s\n", args);
bPlaying = FALSE;
pthread_mutex_unlock(&mutex);
pthread_exit(NULL);
}
if((decoder = NeAACDecOpen()) == NULL){
g_print("AAC: Open Decoder Error\n");
fclose(file);
bPlaying = FALSE;
pthread_mutex_unlock(&mutex);
pthread_exit(NULL);
}
config = NeAACDecGetCurrentConfiguration(decoder);
config->useOldADTSFormat = 0;
NeAACDecSetConfiguration(decoder, config);
if((buffer = g_malloc(BUFFER_SIZE)) == NULL){
g_print("AAC: error g_malloc\n");
fclose(file);
bPlaying = FALSE;
NeAACDecClose(decoder);
pthread_mutex_unlock(&mutex);
pthread_exit(NULL);
}
if((buffervalid = fread(buffer, 1, BUFFER_SIZE, file))==0){
g_print("AAC: Error reading file\n");
g_free(buffer);
fclose(file);
bPlaying = FALSE;
NeAACDecClose(decoder);
pthread_mutex_unlock(&mutex);
pthread_exit(NULL);
}
XMMS_NEW_TITLEINPUT(input);
input->file_name = g_basename(temp);
input->file_ext = ext ? ext+1 : NULL;
input->file_path = temp;
if(!strncmp(buffer, "ID3", 3)){
gint size = 0;
fseek(file, 0, SEEK_SET);
size = (buffer[6]<<21) | (buffer[7]<<14) | (buffer[8]<<7) | buffer[9];
size+=10;
fread(buffer, 1, size, file);
buffervalid = fread(buffer, 1, BUFFER_SIZE, file);
}
xmmstitle = xmms_get_titlestring(xmms_get_gentitle_format(), input);
if(xmmstitle == NULL)
xmmstitle = g_strdup(input->file_name);
if(temp) g_free(temp);
if(input->performer) g_free(input->performer);
if(input->album_name) g_free(input->album_name);
if(input->track_name) g_free(input->track_name);
if(input->genre) g_free(input->genre);
g_free(input);
bufferconsumed = NeAACDecInit(decoder,
buffer,
buffervalid,
&samplerate,
&channels);
if(mp4_ip.output->open_audio(FMT_S16_NE,samplerate,channels) == FALSE){
g_print("AAC: Output Error\n");
g_free(buffer); buffer=0;
faacDecClose(decoder);
fclose(file);
mp4_ip.output->close_audio();
/*
if(positionTable){
g_free(positionTable); positionTable=0;
}
*/
g_free(xmmstitle);
bPlaying = FALSE;
pthread_mutex_unlock(&mutex);
pthread_exit(NULL);
}
//if(bSeek){
//mp4_ip.set_info(xmmstitle, lenght*1000, -1, samplerate, channels);
//}else{
mp4_ip.set_info(xmmstitle, -1, -1, samplerate, channels);
//}
mp4_ip.output->flush(0);
while(bPlaying && buffervalid > 0){
NeAACDecFrameInfo finfo;
unsigned long samplesdecoded;
char* sample_buffer = NULL;
/*
if(bSeek && seekPosition!=-1){
fseek(file, positionTable[seekPosition], SEEK_SET);
bufferconsumed=0;
buffervalid = fread(buffer, 1, BUFFER_SIZE, file);
aac_ip.output->flush(seekPosition*1000);
seekPosition=-1;
}
*/
if(bufferconsumed > 0){
memmove(buffer, &buffer[bufferconsumed], buffervalid-bufferconsumed);
buffervalid -= bufferconsumed;
buffervalid += fread(&buffer[buffervalid], 1,
BUFFER_SIZE-buffervalid, file);
bufferconsumed = 0;
}
sample_buffer = NeAACDecDecode(decoder, &finfo, buffer, buffervalid);
if(finfo.error){
config = NeAACDecGetCurrentConfiguration(decoder);
if(config->useOldADTSFormat != 1){
NeAACDecClose(decoder);
decoder = NeAACDecOpen();
config = NeAACDecGetCurrentConfiguration(decoder);
config->useOldADTSFormat = 1;
NeAACDecSetConfiguration(decoder, config);
finfo.bytesconsumed=0;
finfo.samples = 0;
NeAACDecInit(decoder,
buffer,
buffervalid,
&samplerate,
&channels);
}else{
g_print("FAAD2 Warning %s\n", NeAACDecGetErrorMessage(finfo.error));
buffervalid = 0;
}
}
bufferconsumed += finfo.bytesconsumed;
samplesdecoded = finfo.samples;
if((samplesdecoded<=0) && !sample_buffer){
g_print("AAC: error sample decoding\n");
continue;
}
while(bPlaying && mp4_ip.output->buffer_free() < (samplesdecoded<<1)){
xmms_usleep(10000);
}
mp4_ip.add_vis_pcm(mp4_ip.output->written_time(),
FMT_S16_LE, channels,
samplesdecoded<<1, sample_buffer);
mp4_ip.output->write_audio(sample_buffer, samplesdecoded<<1);
}
while(bPlaying && mp4_ip.output->buffer_playing()){
xmms_usleep(10000);
}
mp4_ip.output->buffer_free();
mp4_ip.output->close_audio();
bPlaying = FALSE;
g_free(buffer);
NeAACDecClose(decoder);
g_free(xmmstitle);
fclose(file);
seekPosition = -1;
/*
if(positionTable){
g_free(positionTable); positionTable=0;
}
*/
bPlaying = FALSE;
pthread_mutex_unlock(&mutex);
pthread_exit(NULL);
}
}
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;
}
// returns -1 for error, 0 for mp4, 1 for aac
int
aac_probe (DB_FILE *fp, const char *fname, MP4FILE_CB *cb, float *duration, int *samplerate, int *channels, int *totalsamples, int *mp4track, MP4FILE *pmp4) {
// try mp4
trace ("aac_probe: pos=%lld, junk=%d\n", deadbeef->ftell (fp), ((aac_info_t*)cb->user_data)->junk);
if (mp4track) {
*mp4track = -1;
}
if (*pmp4) {
*pmp4 = NULL;
}
*duration = -1;
#ifdef USE_MP4FF
trace ("mp4ff_open_read\n");
mp4ff_t *mp4 = mp4ff_open_read (cb);
#else
MP4FileHandle mp4 = MP4ReadProvider (fname, 0, cb);
#endif
if (!mp4) {
trace ("not an mp4 file\n");
return -1;
}
if (pmp4) {
*pmp4 = mp4;
}
#ifdef USE_MP4FF
int ntracks = mp4ff_total_tracks (mp4);
if (ntracks > 0) {
trace ("m4a container detected, ntracks=%d\n", ntracks);
int i = -1;
trace ("looking for mp4 data...\n");
int sr = -1;
unsigned char* buff = 0;
unsigned int buff_size = 0;
for (i = 0; i < ntracks; i++) {
mp4AudioSpecificConfig mp4ASC;
mp4ff_get_decoder_config(mp4, i, &buff, &buff_size);
if (buff) {
int rc = AudioSpecificConfig(buff, buff_size, &mp4ASC);
sr = mp4ASC.samplingFrequency;
if(rc < 0) {
free (buff);
buff = 0;
continue;
}
break;
}
}
if (i != ntracks && buff)
{
trace ("found audio track (%d)\n", i);
// init mp4 decoding
NeAACDecHandle dec = NeAACDecOpen ();
unsigned long srate;
unsigned char ch;
if (NeAACDecInit2(dec, buff, buff_size, &srate, &ch) < 0) {
trace ("NeAACDecInit2 returned error\n");
goto error;
}
*samplerate = srate;
*channels = ch;
int samples = mp4ff_num_samples(mp4, i);
samples = (int64_t)samples * srate / mp4ff_time_scale (mp4, i);
int tsamples = samples;
NeAACDecConfigurationPtr conf = NeAACDecGetCurrentConfiguration (dec);
conf->dontUpSampleImplicitSBR = 1;
NeAACDecSetConfiguration (dec, conf);
mp4AudioSpecificConfig mp4ASC;
int mp4framesize;
if (NeAACDecAudioSpecificConfig(buff, buff_size, &mp4ASC) >= 0)
{
mp4framesize = 1024;
if (mp4ASC.frameLengthFlag == 1) {
mp4framesize = 960;
}
// commented this out, since it fixes double-duration bug on
// some mp4 files
//if (mp4ASC.sbr_present_flag == 1) {
// mp4framesize *= 2;
//}
}
else {
trace ("NeAACDecAudioSpecificConfig failed, can't get mp4framesize\n");
goto error;
}
tsamples *= mp4framesize;
trace ("mp4 nsamples=%d, samplerate=%d, timescale=%d, duration=%lld\n", samples, *samplerate, mp4ff_time_scale(mp4, i), mp4ff_get_track_duration(mp4, i));
*duration = (float)tsamples / (*samplerate);
trace ("mp4 duration: %f (tsamples %d/samplerate %d)\n", *duration, tsamples, *samplerate);
NeAACDecClose (dec);
if (totalsamples) {
*totalsamples = tsamples;
}
if (mp4track) {
*mp4track = i;
}
if (!*pmp4) {
mp4ff_close (mp4);
}
return 0;
error:
NeAACDecClose (dec);
free (buff);
if (!*pmp4) {
mp4ff_close (mp4);
}
return -1;
}
else {
trace ("audio track not found\n");
mp4ff_close (mp4);
mp4 = NULL;
}
if (buff) {
free (buff);
buff = NULL;
}
}
#else
MP4FileHandle mp4File = mp4;
MP4TrackId trackId = MP4FindTrackId(mp4File, 0, "audio", 0);
trace ("trackid: %d\n", trackId);
uint32_t timeScale = MP4GetTrackTimeScale(mp4File, trackId);
MP4Duration trackDuration = MP4GetTrackDuration(mp4File, trackId);
MP4SampleId numSamples = MP4GetTrackNumberOfSamples(mp4File, trackId);
u_int8_t* pConfig;
uint32_t configSize = 0;
bool res = MP4GetTrackESConfiguration(mp4File, trackId, &pConfig, &configSize);
if (res && pConfig) {
mp4AudioSpecificConfig mp4ASC;
int rc = AudioSpecificConfig(pConfig, configSize, &mp4ASC);
free (pConfig);
if (rc >= 0) {
*samplerate = mp4ASC.samplingFrequency;
*channels = MP4GetTrackAudioChannels (mp4File, trackId);
// int64_t duration = MP4ConvertFromTrackDuration (mp4File, trackId, trackDuration, timeScale);
int samples = MP4GetTrackNumberOfSamples (mp4File, trackId) * 1024 * (*channels);
trace ("mp4 nsamples=%d, timescale=%d, samplerate=%d\n", samples, timeScale, *samplerate);
*duration = (float)samples / (*samplerate);
if (totalsamples) {
*totalsamples = samples;
}
if (mp4track) {
*mp4track = trackId;
}
if (!*pmp4) {
MP4Close (mp4);
}
return 0;
}
}
#endif
if (*pmp4) {
*pmp4 = NULL;
}
if (mp4) {
#if USE_MP4FF
mp4ff_close (mp4);
#else
MP4Close (mp4);
#endif
mp4 = NULL;
}
trace ("mp4 track not found, looking for aac stream...\n");
// not an mp4, try raw aac
#if USE_MP4FF
deadbeef->rewind (fp);
#endif
if (parse_aac_stream (fp, samplerate, channels, duration, totalsamples) == -1) {
trace ("aac stream not found\n");
return -1;
}
trace ("found aac stream\n");
return 1;
}
static DB_playItem_t *
aac_insert (ddb_playlist_t *plt, DB_playItem_t *after, const char *fname) {
trace ("adding %s\n", fname);
DB_FILE *fp = deadbeef->fopen (fname);
if (!fp) {
trace ("not found\n");
return NULL;
}
aac_info_t info = {0};
info.junk = deadbeef->junk_get_leading_size (fp);
if (info.junk >= 0) {
trace ("junk: %d\n", info.junk);
deadbeef->fseek (fp, info.junk, SEEK_SET);
}
else {
info.junk = 0;
}
const char *ftype = NULL;
float duration = -1;
int totalsamples = 0;
int samplerate = 0;
int channels = 0;
int mp4track = -1;
MP4FILE mp4 = NULL;
if (fp->vfs->is_streaming ()) {
trace ("streaming aac (%s)\n", fname);
ftype = "RAW AAC";
}
else {
// slowwww!
info.file = fp;
MP4FILE_CB cb = {
#ifdef USE_MP4FF
.read = aac_fs_read,
.write = NULL,
.seek = aac_fs_seek,
.truncate = NULL,
.user_data = &info
#else
.open = aac_fs_open,
.seek = aac_fs_seek,
.read = aac_fs_read,
.write = NULL,
.close = aac_fs_close
#endif
};
int res = aac_probe (fp, fname, &cb, &duration, &samplerate, &channels, &totalsamples, &mp4track, &mp4);
if (res == -1) {
deadbeef->fclose (fp);
return NULL;
}
else if (res == 0) {
ftype = "MP4 AAC";
}
else if (res == 1) {
ftype = "RAW AAC";
}
}
DB_playItem_t *it = deadbeef->pl_item_alloc_init (fname, plugin.plugin.id);
deadbeef->pl_add_meta (it, ":FILETYPE", ftype);
deadbeef->plt_set_item_duration (plt, it, duration);
trace ("duration: %f sec\n", duration);
// read tags
if (mp4) {
#ifdef USE_MP4FF
aac_load_tags (it, mp4);
mp4ff_close (mp4);
#else
const MP4Tags *tags = MP4TagsAlloc ();
MP4TagsFetch (tags, mp4);
deadbeef->pl_add_meta (it, "title", tags->name);
deadbeef->pl_add_meta (it, "artist", tags->artist);
deadbeef->pl_add_meta (it, "albumArtist", tags->albumArtist);
deadbeef->pl_add_meta (it, "album", tags->album);
deadbeef->pl_add_meta (it, "composer", tags->composer);
deadbeef->pl_add_meta (it, "comments", tags->comments);
deadbeef->pl_add_meta (it, "genre", tags->genre);
deadbeef->pl_add_meta (it, "year", tags->releaseDate);
char s[10];
if (tags->track) {
snprintf (s, sizeof (s), "%d", tags->track->index);
deadbeef->pl_add_meta (it, "track", s);
snprintf (s, sizeof (s), "%d", tags->track->total);
deadbeef->pl_add_meta (it, "numtracks", s);
}
if (tags->disk) {
snprintf (s, sizeof (s), "%d", tags->disk->index);
deadbeef->pl_add_meta (it, "disc", s);
snprintf (s, sizeof (s), "%d", tags->disk->total);
deadbeef->pl_add_meta (it, "numdiscs", s);
}
deadbeef->pl_add_meta (it, "copyright", tags->copyright);
deadbeef->pl_add_meta (it, "vendor", tags->encodedBy);
deadbeef->pl_add_meta (it, "title", NULL);
MP4TagsFree (tags);
MP4Close (mp4);
#endif
}
int apeerr = deadbeef->junk_apev2_read (it, fp);
int v2err = deadbeef->junk_id3v2_read (it, fp);
int v1err = deadbeef->junk_id3v1_read (it, fp);
deadbeef->pl_add_meta (it, "title", NULL);
int64_t fsize = deadbeef->fgetlength (fp);
deadbeef->fclose (fp);
if (duration > 0) {
char s[100];
snprintf (s, sizeof (s), "%lld", fsize);
deadbeef->pl_add_meta (it, ":FILE_SIZE", s);
deadbeef->pl_add_meta (it, ":BPS", "16");
snprintf (s, sizeof (s), "%d", channels);
deadbeef->pl_add_meta (it, ":CHANNELS", s);
snprintf (s, sizeof (s), "%d", samplerate);
deadbeef->pl_add_meta (it, ":SAMPLERATE", s);
int br = (int)roundf(fsize / duration * 8 / 1000);
snprintf (s, sizeof (s), "%d", br);
deadbeef->pl_add_meta (it, ":BITRATE", s);
// embedded cue
deadbeef->pl_lock ();
const char *cuesheet = deadbeef->pl_find_meta (it, "cuesheet");
DB_playItem_t *cue = NULL;
if (cuesheet) {
cue = deadbeef->plt_insert_cue_from_buffer (plt, after, it, cuesheet, strlen (cuesheet), totalsamples, samplerate);
if (cue) {
deadbeef->pl_item_unref (it);
deadbeef->pl_item_unref (cue);
deadbeef->pl_unlock ();
return cue;
}
}
deadbeef->pl_unlock ();
cue = deadbeef->plt_insert_cue (plt, after, it, totalsamples, samplerate);
if (cue) {
deadbeef->pl_item_unref (it);
deadbeef->pl_item_unref (cue);
return cue;
}
}
deadbeef->pl_add_meta (it, "title", NULL);
after = deadbeef->plt_insert_item (plt, after, it);
deadbeef->pl_item_unref (it);
return after;
}
static const char * exts[] = { "aac", "mp4", "m4a", NULL };
// define plugin interface
static DB_decoder_t plugin = {
.plugin.api_vmajor = 1,
.plugin.api_vminor = 0,
.plugin.version_major = 1,
.plugin.version_minor = 0,
.plugin.type = DB_PLUGIN_DECODER,
.plugin.id = "aac",
.plugin.name = "AAC player",
.plugin.descr = "plays aac files, supports raw aac files, as well as mp4 container",
.plugin.copyright =
"Copyright (C) 2009-2012 Alexey Yakovenko <*****@*****.**>\n"
"\n"
"Uses modified libmp4ff (C) 2003-2005 M. Bakker, Nero AG, http://www.nero.com\n"
"\n"
"This program is free software; you can redistribute it and/or\n"
"modify it under the terms of the GNU General Public License\n"
"as published by the Free Software Foundation; either version 2\n"
"of the License, or (at your option) any later version.\n"
"\n"
"This program is distributed in the hope that it will be useful,\n"
"but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
"MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
"GNU General Public License for more details.\n"
"\n"
"You should have received a copy of the GNU General Public License\n"
"along with this program; if not, write to the Free Software\n"
"Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.\n"
,
.plugin.website = "http://deadbeef.sf.net",
.open = aac_open,
.init = aac_init,
.free = aac_free,
.read = aac_read,
.seek = aac_seek,
.seek_sample = aac_seek_sample,
.insert = aac_insert,
.read_metadata = aac_read_metadata,
#ifdef USE_MP4FF
// mp4ff metadata writer doesn't work
// .write_metadata = aac_write_metadata,
#else
#endif
.exts = exts,
};
DB_plugin_t *
aac_load (DB_functions_t *api) {
deadbeef = api;
return DB_PLUGIN (&plugin);
}
// returns -1 for error, 0 for mp4, 1 for aac
int
aac_probe (DB_FILE *fp, const char *fname, MP4FILE_CB *cb, float *duration, int *samplerate, int *channels, int *totalsamples, int *mp4track, MP4FILE *pmp4) {
// try mp4
if (mp4track) {
*mp4track = -1;
}
if (*pmp4) {
*pmp4 = NULL;
}
*duration = -1;
#ifdef USE_MP4FF
mp4ff_t *mp4 = mp4ff_open_read (cb);
#else
MP4FileHandle mp4 = MP4ReadProvider (fname, 0, cb);
#endif
if (!mp4) {
trace ("not an mp4 file\n");
return -1;
}
if (pmp4) {
*pmp4 = mp4;
}
#ifdef USE_MP4FF
int ntracks = mp4ff_total_tracks (mp4);
if (ntracks > 0) {
trace ("m4a container detected, ntracks=%d\n", ntracks);
int i = -1;
trace ("looking for mp4 data...\n");
int sr = -1;
for (i = 0; i < ntracks; i++) {
unsigned char* buff = 0;
unsigned int buff_size = 0;
mp4AudioSpecificConfig mp4ASC;
mp4ff_get_decoder_config(mp4, i, &buff, &buff_size);
if(buff){
int rc = AudioSpecificConfig(buff, buff_size, &mp4ASC);
sr = mp4ASC.samplingFrequency;
free(buff);
if(rc < 0)
continue;
break;
}
}
if (i != ntracks)
{
trace ("mp4 track: %d\n", i);
if (sr != -1) {
*samplerate = sr;
}
else {
*samplerate = mp4ff_get_sample_rate (mp4, i);
}
*channels = mp4ff_get_channel_count (mp4, i);
int samples = mp4ff_num_samples(mp4, i) * 1024;
samples = (int64_t)samples * (*samplerate) / mp4ff_time_scale (mp4, i);
trace ("mp4 nsamples=%d, samplerate=%d, timescale=%d, duration=%lld\n", samples, *samplerate, mp4ff_time_scale(mp4, i), mp4ff_get_track_duration(mp4, i));
*duration = (float)samples / (*samplerate);
if (totalsamples) {
*totalsamples = samples;
}
if (mp4track) {
*mp4track = i;
}
if (!*pmp4) {
mp4ff_close (mp4);
}
return 0;
}
}
#else
MP4FileHandle mp4File = mp4;
MP4TrackId trackId = MP4FindTrackId(mp4File, 0, "audio", 0);
trace ("trackid: %d\n", trackId);
uint32_t timeScale = MP4GetTrackTimeScale(mp4File, trackId);
MP4Duration trackDuration = MP4GetTrackDuration(mp4File, trackId);
MP4SampleId numSamples = MP4GetTrackNumberOfSamples(mp4File, trackId);
u_int8_t* pConfig;
uint32_t configSize = 0;
bool res = MP4GetTrackESConfiguration(mp4File, trackId, &pConfig, &configSize);
if (res && pConfig) {
mp4AudioSpecificConfig mp4ASC;
int rc = AudioSpecificConfig(pConfig, configSize, &mp4ASC);
free (pConfig);
if (rc >= 0) {
*samplerate = mp4ASC.samplingFrequency;
*channels = MP4GetTrackAudioChannels (mp4File, trackId);
// int64_t duration = MP4ConvertFromTrackDuration (mp4File, trackId, trackDuration, timeScale);
int samples = MP4GetTrackNumberOfSamples (mp4File, trackId) * 1024 * (*channels);
trace ("mp4 nsamples=%d, timescale=%d, samplerate=%d\n", samples, timeScale, *samplerate);
*duration = (float)samples / (*samplerate);
if (totalsamples) {
*totalsamples = samples;
}
if (mp4track) {
*mp4track = trackId;
}
if (!*pmp4) {
MP4Close (mp4);
}
return 0;
}
}
#endif
if (*pmp4) {
*pmp4 = NULL;
}
if (mp4) {
#if USE_MP4FF
mp4ff_close (mp4);
#else
MP4Close (mp4);
#endif
mp4 = NULL;
}
trace ("mp4 track not found, looking for aac stream...\n");
// not an mp4, try raw aac
#if USE_MP4FF
deadbeef->rewind (fp);
#endif
if (parse_aac_stream (fp, samplerate, channels, duration, totalsamples) == -1) {
trace ("aac stream not found\n");
return -1;
}
trace ("found aac stream\n");
return 1;
}