ref: 830fab4aacc7ff6bc5456d935f15f773f6367f0d
dir: /plugins/in_mp4/in_mp4.c/
/*
** FAAD2 - Freeware Advanced Audio (AAC) Decoder including SBR decoding
** Copyright (C) 2003 M. Bakker, Ahead Software AG, http://www.nero.com
**
** This program is free software; you can redistribute it and/or modify
** it under the terms of the GNU General Public License as published by
** the Free Software Foundation; either version 2 of the License, or
** (at your option) any later version.
**
** This program is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
** GNU General Public License for more details.
**
** You should have received a copy of the GNU General Public License
** along with this program; if not, write to the Free Software
** Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
**
** Any non-GPL usage of this software or parts of this software is strictly
** forbidden.
**
** Commercial non-GPL licensing of this software is possible.
** For more info contact Ahead Software through [email protected].
**
** $Id: in_mp4.c,v 1.56 2004/10/19 18:02:10 menno Exp $
**/
//#define DEBUG_OUTPUT
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#include <commctrl.h>
#include <commdlg.h>
#include <stdlib.h>
#include <stdio.h>
#include <io.h>
#include <math.h>
#include <neaacdec.h>
#define USE_TAGGING
#include <mp4ff.h>
#include "resource.h"
#include "in2.h"
#include "utils.h"
#include "config.h"
#include "aacinfo.h"
const char *long_ext_list = "MP4\0MPEG-4 Files (*.MP4)\0M4A\0MPEG-4 Files (*.M4A)\0AAC\0AAC Files (*.AAC)\0";
const char *short_ext_list = "MP4\0MPEG-4 Files (*.MP4)\0M4A\0MPEG-4 Files (*.M4A)\0";
static long priority_table[] = {
0,
THREAD_PRIORITY_HIGHEST,
THREAD_PRIORITY_ABOVE_NORMAL,
THREAD_PRIORITY_NORMAL,
THREAD_PRIORITY_BELOW_NORMAL,
THREAD_PRIORITY_LOWEST
};
static int res_id_table[] = {
IDC_16BITS,
IDC_24BITS,
IDC_32BITS,
0,
0,
/*IDC_16BITS_DITHERED*/ IDC_16BITS /* temp hack */
};
static int res_table[] = {
16,
24,
32,
0,
0,
16
};
static char info_fn[_MAX_PATH];
// post this to the main window at end of file (after playback has stopped)
#define WM_WA_AAC_EOF WM_USER+2
struct seek_list
{
struct seek_list *next;
__int64 offset;
};
typedef struct state
{
/* general stuff */
NeAACDecHandle hDecoder;
int samplerate;
unsigned char channels;
double decode_pos_ms; // current decoding position, in milliseconds
int paused; // are we paused?
int seek_needed; // if != -1, it is the point that the decode thread should seek to, in ms.
char filename[_MAX_PATH];
int filetype; /* 0: MP4; 1: AAC */
int last_frame;
__int64 last_offset;
/* MP4 stuff */
mp4ff_t *mp4file;
int mp4track;
long numSamples;
long sampleId;
mp4ff_callback_t mp4cb;
FILE *mp4File;
/* AAC stuff */
FILE *aacfile;
long m_aac_bytes_into_buffer;
long m_aac_bytes_consumed;
__int64 m_file_offset;
unsigned char *m_aac_buffer;
int m_at_eof;
double cur_pos_sec;
int m_header_type;
struct seek_list *m_head;
struct seek_list *m_tail;
unsigned long m_length;
/* for gapless decoding */
unsigned int useAacLength;
unsigned int framesize;
unsigned int initial;
unsigned long timescale;
} state;
static state mp4state;
static In_Module module; // the output module (declared near the bottom of this file)
static int killPlayThread;
static int PlayThreadAlive = 0; // 1=play thread still running
HANDLE play_thread_handle = INVALID_HANDLE_VALUE; // the handle to the decode thread
/* Function definitions */
void *decode_aac_frame(state *st, NeAACDecFrameInfo *frameInfo);
DWORD WINAPI MP4PlayThread(void *b); // the decode thread procedure
DWORD WINAPI AACPlayThread(void *b); // the decode thread procedure
uint32_t read_callback(void *user_data, void *buffer, uint32_t length)
{
return fread(buffer, 1, length, (FILE*)user_data);
}
uint32_t seek_callback(void *user_data, uint64_t position)
{
return fseek((FILE*)user_data, position, SEEK_SET);
}
uint32_t write_callback(void *user_data, void *buffer, uint32_t length)
{
return fwrite(buffer, 1, length, (FILE*)user_data);
}
uint32_t truncate_callback(void *user_data)
{
_chsize(fileno((FILE*)user_data), ftell((FILE*)user_data));
return 1;
}
int tag_add_field(mp4ff_metadata_t *tags, const char *item, const char *value, size_t v_len)
{
void *backup = (void *)tags->tags;
if (!item || (item && !*item) || !value) return 0;
tags->tags = (mp4ff_tag_t *)realloc(tags->tags, (tags->count+1) * sizeof(mp4ff_tag_t));
if (!tags->tags) {
if (backup) free(backup);
return 0;
}
else
{
size_t i_len = strlen(item);
if (v_len == 0) v_len = strlen(value);
tags->tags[tags->count].item = (char *)malloc(i_len+1);
tags->tags[tags->count].value = (char *)malloc(v_len+1);
if (!tags->tags[tags->count].item || !tags->tags[tags->count].value)
{
if (!tags->tags[tags->count].item) free (tags->tags[tags->count].item);
if (!tags->tags[tags->count].value) free (tags->tags[tags->count].value);
tags->tags[tags->count].item = NULL;
tags->tags[tags->count].value = NULL;
return 0;
}
memcpy(tags->tags[tags->count].item, item, i_len);
memcpy(tags->tags[tags->count].value, value, v_len);
tags->tags[tags->count].item[i_len] = '\0';
tags->tags[tags->count].value[v_len] = '\0';
// tags->tags[tags->count].len = v_len;
tags->count++;
return 1;
}
}
int tag_set_field(mp4ff_metadata_t *tags, const char *item, const char *value, size_t v_len)
{
unsigned int i;
if (!item || (item && !*item) || !value) return 0;
for (i = 0; i < tags->count; i++)
{
if (!stricmp(tags->tags[i].item, item))
{
void *backup = (void *)tags->tags[i].value;
if (v_len == 0) v_len = strlen(value);
tags->tags[i].value = (char *)realloc(tags->tags[i].value, v_len+1);
if (!tags->tags[i].value)
{
if (backup) free(backup);
return 0;
}
memcpy(tags->tags[i].value, value, v_len);
tags->tags[i].value[v_len] = '\0';
// tags->tags[i].len = v_len;
return 1;
}
}
return tag_add_field(tags, item, value, v_len);
}
int tag_delete(mp4ff_metadata_t *tags)
{
unsigned int i;
for (i = 0; i < tags->count; i++)
{
if (tags->tags[i].item) free(tags->tags[i].item);
if (tags->tags[i].value) free(tags->tags[i].value);
}
if (tags->tags) free(tags->tags);
tags->tags = NULL;
tags->count = 0;
}
int ReadMP4Tag(mp4ff_t *file, mp4ff_metadata_t *tags)
{
unsigned __int8 *pValue;
char *pName;
unsigned int i = 0;
do {
pName = 0;
pValue = 0;
if (mp4ff_meta_get_by_index(file, i, (char **)&pName, &pValue))
{
char *val = (char *)strdup(pValue);
if (!val) return 0;
if (pName[0] == '�')
{
if (memcmp(pName, "�nam", 4) == 0)
{
tag_add_field(tags, "title", val, strlen(val));
} else if (memcmp(pName, "�ART", 4) == 0) {
tag_add_field(tags, "artist", val, strlen(val));
} else if (memcmp(pName, "�wrt", 4) == 0) {
tag_add_field(tags, "writer", val, strlen(val));
} else if (memcmp(pName, "�alb", 4) == 0) {
tag_add_field(tags, "album", val, strlen(val));
} else if (memcmp(pName, "�day", 4) == 0) {
tag_add_field(tags, "date", val, strlen(val));
} else if (memcmp(pName, "�too", 4) == 0) {
tag_add_field(tags, "tool", val, strlen(val));
} else if (memcmp(pName, "�cmt", 4) == 0) {
tag_add_field(tags, "comment", val, strlen(val));
} else if (memcmp(pName, "�gen", 4) == 0) {
tag_add_field(tags, "genre", val, strlen(val));
} else {
tag_add_field(tags, pName, val, strlen(val));
}
} else if (memcmp(pName, "covr", 4) == 0) {
tag_add_field(tags, "cover", val, strlen(val));
} else if (memcmp(pName, "gnre", 4) == 0) {
tag_add_field(tags, "genre", val, strlen(val));
} else if (memcmp(pName, "trkn", 4) == 0) {
tag_add_field(tags, "tracknumber", val, strlen(val));
} else if (memcmp(pName, "disk", 4) == 0) {
tag_add_field(tags, "disc", val, strlen(val));
} else if (memcmp(pName, "cpil", 4) == 0) {
tag_add_field(tags, "compilation", val, strlen(val));
} else if (memcmp(pName, "tmpo", 4) == 0) {
tag_add_field(tags, "tempo", val, strlen(val));
} else if (memcmp(pName, "NDFL", 4) == 0) {
/* Removed */
} else {
tag_add_field(tags, pName, val, strlen(val));
}
free(val);
}
i++;
} while (pValue != NULL);
return 1;
}
#ifdef DEBUG_OUTPUT
void in_mp4_DebugOutput(char *message)
{
char s[1024];
sprintf(s, "in_mp4: %s", message);
OutputDebugString(s);
}
#endif
int file_length(FILE *f)
{
long end = 0;
long cur = ftell(f);
fseek(f, 0, SEEK_END);
end = ftell(f);
fseek(f, cur, SEEK_SET);
return end;
}
static void show_error(HWND hwnd, char *message, ...)
{
if (m_show_errors)
MessageBox(hwnd, message, "Error", MB_OK);
}
static void config_init()
{
char *p=INI_FILE;
GetModuleFileName(NULL,INI_FILE,_MAX_PATH);
while (*p) p++;
while (p >= INI_FILE && *p != '.') p--;
strcpy(p+1,"ini");
}
void config_read()
{
char priority[10];
char resolution[10];
char show_errors[10];
char use_for_aac[10];
char downmix[10];
char vbr_display[10];
config_init();
strcpy(show_errors, "1");
strcpy(priority, "3");
strcpy(resolution, "0");
strcpy(use_for_aac, "1");
strcpy(downmix, "0");
strcpy(vbr_display, "1");
strcpy(titleformat, "%7");
RS(priority);
RS(resolution);
RS(show_errors);
RS(use_for_aac);
RS(downmix);
RS(vbr_display);
RS(titleformat);
m_priority = atoi(priority);
m_resolution = atoi(resolution);
m_show_errors = atoi(show_errors);
m_use_for_aac = atoi(use_for_aac);
m_downmix = atoi(downmix);
m_vbr_display = atoi(vbr_display);
}
void config_write()
{
char priority[10];
char resolution[10];
char show_errors[10];
char use_for_aac[10];
char downmix[10];
char vbr_display[10];
itoa(m_priority, priority, 10);
itoa(m_resolution, resolution, 10);
itoa(m_show_errors, show_errors, 10);
itoa(m_use_for_aac, use_for_aac, 10);
itoa(m_downmix, downmix, 10);
itoa(m_vbr_display, vbr_display, 10);
WS(priority);
WS(resolution);
WS(show_errors);
WS(use_for_aac);
WS(downmix);
WS(vbr_display);
WS(titleformat);
}
void init()
{
config_read();
}
void quit()
{
}
/* Convert UNICODE to UTF-8
Return number of bytes written */
int unicodeToUtf8 ( const WCHAR* lpWideCharStr, char* lpMultiByteStr, int cwcChars )
{
const unsigned short* pwc = (unsigned short *)lpWideCharStr;
unsigned char* pmb = (unsigned char *)lpMultiByteStr;
const unsigned short* pwce;
size_t cBytes = 0;
if ( cwcChars >= 0 ) {
pwce = pwc + cwcChars;
} else {
pwce = (unsigned short *)((size_t)-1);
}
while ( pwc < pwce ) {
unsigned short wc = *pwc++;
if ( wc < 0x00000080 ) {
*pmb++ = (char)wc;
cBytes++;
} else
if ( wc < 0x00000800 ) {
*pmb++ = (char)(0xC0 | ((wc >> 6) & 0x1F));
cBytes++;
*pmb++ = (char)(0x80 | (wc & 0x3F));
cBytes++;
} else
if ( wc < 0x00010000 ) {
*pmb++ = (char)(0xE0 | ((wc >> 12) & 0x0F));
cBytes++;
*pmb++ = (char)(0x80 | ((wc >> 6) & 0x3F));
cBytes++;
*pmb++ = (char)(0x80 | (wc & 0x3F));
cBytes++;
}
if ( wc == L'\0' )
return cBytes;
}
return cBytes;
}
/* Convert UTF-8 coded string to UNICODE
Return number of characters converted */
int utf8ToUnicode ( const char* lpMultiByteStr, WCHAR* lpWideCharStr, int cmbChars )
{
const unsigned char* pmb = (unsigned char *)lpMultiByteStr;
unsigned short* pwc = (unsigned short *)lpWideCharStr;
const unsigned char* pmbe;
size_t cwChars = 0;
if ( cmbChars >= 0 ) {
pmbe = pmb + cmbChars;
} else {
pmbe = (unsigned char *)((size_t)-1);
}
while ( pmb < pmbe ) {
char mb = *pmb++;
unsigned int cc = 0;
unsigned int wc;
while ( (cc < 7) && (mb & (1 << (7 - cc)))) {
cc++;
}
if ( cc == 1 || cc > 6 ) // illegal character combination for UTF-8
continue;
if ( cc == 0 ) {
wc = mb;
} else {
wc = (mb & ((1 << (7 - cc)) - 1)) << ((cc - 1) * 6);
while ( --cc > 0 ) {
if ( pmb == pmbe ) // reached end of the buffer
return cwChars;
mb = *pmb++;
if ( ((mb >> 6) & 0x03) != 2 ) // not part of multibyte character
return cwChars;
wc |= (mb & 0x3F) << ((cc - 1) * 6);
}
}
if ( wc & 0xFFFF0000 )
wc = L'?';
*pwc++ = wc;
cwChars++;
if ( wc == L'\0' )
return cwChars;
}
return cwChars;
}
/* convert Windows ANSI to UTF-8 */
int ConvertANSIToUTF8 ( const char* ansi, char* utf8 )
{
WCHAR* wszValue; // Unicode value
size_t ansi_len;
size_t len;
*utf8 = '\0';
if ( ansi == NULL )
return 0;
ansi_len = strlen ( ansi );
if ( (wszValue = (WCHAR *)malloc ( (ansi_len + 1) * 2 )) == NULL )
return 0;
/* Convert ANSI value to Unicode */
if ( (len = MultiByteToWideChar ( CP_ACP, 0, ansi, ansi_len + 1, wszValue, (ansi_len + 1) * 2 )) == 0 ) {
free ( wszValue );
return 0;
}
/* Convert Unicode value to UTF-8 */
if ( (len = unicodeToUtf8 ( wszValue, utf8, -1 )) == 0 ) {
free ( wszValue );
return 0;
}
free ( wszValue );
return len-1;
}
/* convert UTF-8 to Windows ANSI */
int ConvertUTF8ToANSI ( const char* utf8, char* ansi )
{
WCHAR* wszValue; // Unicode value
size_t utf8_len;
size_t len;
*ansi = '\0';
if ( utf8 == NULL )
return 0;
utf8_len = strlen ( utf8 );
if ( (wszValue = (WCHAR *)malloc ( (utf8_len + 1) * 2 )) == NULL )
return 0;
/* Convert UTF-8 value to Unicode */
if ( (len = utf8ToUnicode ( utf8, wszValue, utf8_len + 1 )) == 0 ) {
free ( wszValue );
return 0;
}
/* Convert Unicode value to ANSI */
if ( (len = WideCharToMultiByte ( CP_ACP, 0, wszValue, -1, ansi, (utf8_len + 1) * 2, NULL, NULL )) == 0 ) {
free ( wszValue );
return 0;
}
free ( wszValue );
return len-1;
}
BOOL uSetDlgItemText(HWND hwnd, int id, const char *str)
{
char *temp;
size_t len;
int r;
if (!str) return FALSE;
if (!*str) return TRUE;
len = strlen(str);
temp = malloc(len+1);
if (!temp) return FALSE;
r = ConvertUTF8ToANSI(str, temp);
if (r > 0)
SetDlgItemText(hwnd, id, temp);
free(temp);
return r>0 ? TRUE : FALSE;
}
UINT uGetDlgItemText(HWND hwnd, int id, char *str, int max)
{
char *temp, *utf8;
int len;
HWND w;
if (!str || !max) return 0;
*str = '\0';
w = GetDlgItem(hwnd, id);
len = GetWindowTextLength(w);
temp = malloc(len+1);
if (!temp) return 0;
utf8 = malloc((len+1)*4);
if (!utf8)
{
free(temp);
return 0;
}
len = GetWindowText(w, temp, len+1);
if (len > 0)
{
len = ConvertANSIToUTF8(temp, utf8);
if (len > max-1)
{
len = max-1;
utf8[max] = '\0';
}
memcpy(str, utf8, len+1);
}
free(temp);
free(utf8);
return len;
}
static void mp4fileinfo(mp4ff_t *mp4, char *info, size_t len)
{
char *ot[6] = { "NULL", "MAIN AAC", "LC AAC", "SSR AAC", "LTP AAC", "HE AAC" };
long samples;
float f = 1024.0;
float seconds;
int track;
NeAACDecHandle hDecoder;
NeAACDecFrameInfo frameInfo;
mp4AudioSpecificConfig mp4ASC = {0};
unsigned char *buffer = NULL;
int buffer_size = 0;
unsigned long sr = 0;
unsigned char ch = 0;
if ((track = GetAACTrack(mp4)) < 0)
{
info[0] = '\0';
return;
}
hDecoder = NeAACDecOpen();
samples = mp4ff_num_samples(mp4, track);
mp4ff_get_decoder_config(mp4, track, &buffer, &buffer_size);
if (buffer)
{
if (NeAACDecAudioSpecificConfig(buffer, buffer_size, &mp4ASC) >= 0)
{
if (mp4ASC.frameLengthFlag == 1) f = 960.0;
if (mp4ASC.sbr_present_flag == 1) f *= 2;
}
if(NeAACDecInit2(hDecoder, buffer, buffer_size, &sr, &ch) < 0)
{
/* If some error initializing occured, skip the file */
free(buffer);
return;
}
free(buffer);
buffer = NULL;
}
if (mp4ff_read_sample(mp4, track, 0, &buffer, &buffer_size) == 0)
{
return;
}
NeAACDecDecode(hDecoder, &frameInfo, buffer, buffer_size);
if (buffer) free(buffer);
seconds = (float)samples*(float)(f-1.0)/(float)mp4ASC.samplingFrequency;
wsprintf(info, "MPEG-4 %s, %d.%d secs, %d ch, %d Hz\nSBR: %s\nParametric stereo: %s",
ot[(mp4ASC.objectTypeIndex > 5)?0:mp4ASC.objectTypeIndex],
(int)(seconds),
(int)(seconds*1000.0 + 0.5) % 1000,
mp4ASC.channelsConfiguration,
mp4ASC.samplingFrequency,
/* SBR: 0: off, 1: on; upsample, 2: on; downsampled, 3: off; upsampled */
(frameInfo.sbr == 0) ? "off" : ((frameInfo.sbr == 1) ? "on, normal" : ((frameInfo.sbr == 2) ? "on, downsampled" : "off, upsampled")),
(frameInfo.ps == 0) ? "no" : "yes");
NeAACDecClose(hDecoder);
}
BOOL CALLBACK mp4_info_dialog_proc(HWND hwndDlg, UINT message,
WPARAM wParam, LPARAM lParam)
{
char file_info[1024];
mp4ff_t *file;
FILE *mp4File;
mp4ff_callback_t mp4cb = {0};
char *pVal;
mp4ff_metadata_t tags;
char dummy1[1024];
char temp[1024];
int dummy, dummy2, dummy3;
tags.count = 0;
tags.tags = NULL;
#ifdef DEBUG_OUTPUT
in_mp4_DebugOutput("mp4_info_dialog_proc");
#endif
switch (message) {
case WM_INITDIALOG:
EnableWindow(GetDlgItem(hwndDlg,IDC_CONVERT), FALSE);
ShowWindow(GetDlgItem(hwndDlg,IDC_CONVERT), SW_HIDE);
EnableWindow(GetDlgItem(hwndDlg,IDC_CONVERT1), FALSE);
ShowWindow(GetDlgItem(hwndDlg,IDC_CONVERT1), SW_HIDE);
EnableWindow(GetDlgItem(hwndDlg,IDC_CONVERT2), FALSE);
ShowWindow(GetDlgItem(hwndDlg,IDC_CONVERT2), SW_HIDE);
mp4File = fopen(info_fn, "rb");
mp4cb.read = read_callback;
mp4cb.seek = seek_callback;
mp4cb.user_data = mp4File;
file = mp4ff_open_read(&mp4cb);
if (file == NULL)
return FALSE;
mp4fileinfo(file, file_info, 1024);
SetDlgItemText(hwndDlg, IDC_INFOTEXT, file_info);
/* get Metadata */
pVal = NULL;
if (mp4ff_meta_get_title(file, &pVal))
uSetDlgItemText(hwndDlg,IDC_METANAME, pVal);
pVal = NULL;
if (mp4ff_meta_get_artist(file, &pVal))
uSetDlgItemText(hwndDlg,IDC_METAARTIST, pVal);
pVal = NULL;
if (mp4ff_meta_get_writer(file, &pVal))
uSetDlgItemText(hwndDlg,IDC_METAWRITER, pVal);
pVal = NULL;
if (mp4ff_meta_get_comment(file, &pVal))
uSetDlgItemText(hwndDlg,IDC_METACOMMENTS, pVal);
pVal = NULL;
if (mp4ff_meta_get_album(file, &pVal))
uSetDlgItemText(hwndDlg,IDC_METAALBUM, pVal);
pVal = NULL;
if (mp4ff_meta_get_genre(file, &pVal))
uSetDlgItemText(hwndDlg,IDC_METAGENRE, pVal);
pVal = NULL;
if (mp4ff_meta_get_track(file, &pVal))
{
SetDlgItemText(hwndDlg,IDC_METATRACK1, pVal);
//pVal = NULL;
//mp4ff_meta_get_totaltracks(file, &pVal);
//SetDlgItemText(hwndDlg, IDC_METATRACK2, pVal);
}
pVal = NULL;
if (mp4ff_meta_get_disc(file, &pVal))
{
SetDlgItemText(hwndDlg,IDC_METADISK1, pVal);
//pVal = NULL;
//mp4ff_meta_get_totaldiscs(file, &pVal);
//SetDlgItemText(hwndDlg,IDC_METADISK2, pVal);
}
pVal = NULL;
if (mp4ff_meta_get_date(file, &pVal))
uSetDlgItemText(hwndDlg,IDC_METAYEAR, pVal);
#if 0
/* WERKT NIET */
#endif
pVal = NULL;
if (mp4ff_meta_get_compilation(file, &pVal))
{
if (strcmp(pVal, "1") == 0)
{
SendMessage(GetDlgItem(hwndDlg, IDC_METACOMPILATION), BM_SETCHECK, BST_CHECKED, 0);
}
}
/* ! Metadata */
mp4ff_close(file);
fclose(mp4File);
return TRUE;
case WM_COMMAND:
switch (LOWORD(wParam)) {
case IDCANCEL:
EndDialog(hwndDlg, wParam);
return TRUE;
case IDOK:
/* trying to edit currently playing file */
if (!stricmp(info_fn, mp4state.filename))
{
MessageBox(module.hMainWindow, "Please stop playback before editing tags", "in_mp4", MB_ICONINFORMATION|MB_OK);
return TRUE;
}
/* save Metadata changes */
tag_delete(&tags);
mp4File = fopen(info_fn, "rb");
mp4cb.read = read_callback;
mp4cb.seek = seek_callback;
mp4cb.write = write_callback;
mp4cb.truncate = truncate_callback;
mp4cb.user_data = mp4File;
file = mp4ff_open_read(&mp4cb);
if (file != NULL)
{
ReadMP4Tag(file, &tags);
mp4ff_close(file);
fclose(mp4File);
}
mp4File = fopen(info_fn, "rb+");
mp4cb.read = read_callback;
mp4cb.seek = seek_callback;
mp4cb.write = write_callback;
mp4cb.truncate = truncate_callback;
mp4cb.user_data = mp4File;
uGetDlgItemText(hwndDlg, IDC_METANAME, dummy1, 1024);
tag_set_field(&tags, "title", dummy1, strlen(dummy1));
uGetDlgItemText(hwndDlg, IDC_METAWRITER, dummy1, 1024);
tag_set_field(&tags, "writer", dummy1, strlen(dummy1));
uGetDlgItemText(hwndDlg, IDC_METAARTIST, dummy1, 1024);
tag_set_field(&tags, "artist", dummy1, strlen(dummy1));
uGetDlgItemText(hwndDlg, IDC_METAALBUM, dummy1, 1024);
tag_set_field(&tags, "album", dummy1, strlen(dummy1));
uGetDlgItemText(hwndDlg, IDC_METACOMMENTS, dummy1, 1024);
tag_set_field(&tags, "comment", dummy1, strlen(dummy1));
uGetDlgItemText(hwndDlg, IDC_METAGENRE, dummy1, 1024);
tag_set_field(&tags, "genre", dummy1, strlen(dummy1));
uGetDlgItemText(hwndDlg, IDC_METAYEAR, dummy1, 1024);
tag_set_field(&tags, "year", dummy1, strlen(dummy1));
GetDlgItemText(hwndDlg, IDC_METATRACK1, dummy1, 1024);
dummy = atoi(dummy1);
//GetDlgItemText(hwndDlg, IDC_METATRACK2, dummy1, 1024);
//dummy2 = atoi(dummy1);
//wsprintf(temp, "%d/%d", dummy, dummy2);
wsprintf(temp, "%d", dummy);
tag_set_field(&tags, "track", temp, strlen(dummy1));
GetDlgItemText(hwndDlg, IDC_METADISK1, dummy1, 1024);
dummy = atoi(dummy1);
//GetDlgItemText(hwndDlg, IDC_METADISK2, dummy1, 1024);
//dummy2 = atoi(dummy1);
//wsprintf(temp, "%d/%d", dummy, dummy2);
wsprintf(temp, "%d", dummy);
tag_set_field(&tags, "disc", temp, strlen(dummy1));
dummy3 = SendMessage(GetDlgItem(hwndDlg, IDC_METACOMPILATION), BM_GETCHECK, 0, 0);
tag_set_field(&tags, "compilation", (dummy3 ? "1" : "0"), 1);
mp4ff_meta_update(&mp4cb, &tags);
fclose(mp4File);
/* ! */
EndDialog(hwndDlg, wParam);
return TRUE;
}
}
return FALSE;
}
/* returns the name of the object type */
char *get_ot_string(int ot)
{
switch (ot)
{
case 0:
return "Main";
case 1:
return "LC";
case 2:
return "SSR";
case 3:
return "LTP";
}
return NULL;
}
BOOL CALLBACK aac_info_dialog_proc(HWND hwndDlg, UINT message,
WPARAM wParam, LPARAM lParam)
{
faadAACInfo aacInfo;
char *info_text, *header_string;
#ifdef DEBUG_OUTPUT
in_mp4_DebugOutput("aac_info_dialog_proc");
#endif
switch (message) {
case WM_INITDIALOG:
EnableWindow(GetDlgItem(hwndDlg,IDC_USERDATA), FALSE) ;
ShowWindow(GetDlgItem(hwndDlg,IDC_USERDATA), SW_HIDE);
ShowWindow(GetDlgItem(hwndDlg,IDC_STATIC1), SW_HIDE);
ShowWindow(GetDlgItem(hwndDlg,IDC_STATIC2), SW_HIDE);
ShowWindow(GetDlgItem(hwndDlg,IDC_STATIC3), SW_HIDE);
ShowWindow(GetDlgItem(hwndDlg,IDC_STATIC4), SW_HIDE);
ShowWindow(GetDlgItem(hwndDlg,IDC_STATIC5), SW_HIDE);
ShowWindow(GetDlgItem(hwndDlg,IDC_STATIC6), SW_HIDE);
ShowWindow(GetDlgItem(hwndDlg,IDC_STATIC7), SW_HIDE);
ShowWindow(GetDlgItem(hwndDlg,IDC_STATIC8), SW_HIDE);
ShowWindow(GetDlgItem(hwndDlg,IDC_STATIC9), SW_HIDE);
ShowWindow(GetDlgItem(hwndDlg,IDC_STATIC10), SW_HIDE);
ShowWindow(GetDlgItem(hwndDlg,IDC_STATIC11), SW_HIDE);
ShowWindow(GetDlgItem(hwndDlg,IDC_STATIC12), SW_HIDE);
ShowWindow(GetDlgItem(hwndDlg,IDC_METANAME), SW_HIDE);
ShowWindow(GetDlgItem(hwndDlg,IDC_METAARTIST), SW_HIDE);
ShowWindow(GetDlgItem(hwndDlg,IDC_METAWRITER), SW_HIDE);
ShowWindow(GetDlgItem(hwndDlg,IDC_METACOMMENTS), SW_HIDE);
ShowWindow(GetDlgItem(hwndDlg,IDC_METAALBUM), SW_HIDE);
ShowWindow(GetDlgItem(hwndDlg,IDC_METAGENRE), SW_HIDE);
ShowWindow(GetDlgItem(hwndDlg,IDC_METATRACK1), SW_HIDE);
//ShowWindow(GetDlgItem(hwndDlg,IDC_METATRACK2), SW_HIDE);
ShowWindow(GetDlgItem(hwndDlg,IDC_METADISK1), SW_HIDE);
//ShowWindow(GetDlgItem(hwndDlg,IDC_METADISK2), SW_HIDE);
ShowWindow(GetDlgItem(hwndDlg,IDC_METAYEAR), SW_HIDE);
ShowWindow(GetDlgItem(hwndDlg,IDC_METACOMPILATION), SW_HIDE);
info_text = malloc(1024*sizeof(char));
get_AAC_format(info_fn, &aacInfo);
switch (aacInfo.headertype)
{
case 0: /* RAW */
header_string = " RAW";
break;
case 1: /* ADIF */
header_string = " ADIF";
break;
case 2: /* ADTS */
header_string = " ADTS";
break;
}
sprintf(info_text, "%s AAC %s%s, %d sec, %d kbps, %d Hz",
(aacInfo.version==2)?"MPEG-2":"MPEG-4", get_ot_string(aacInfo.object_type),
header_string,
(int)((float)aacInfo.length/1000.0), (int)((float)aacInfo.bitrate/1000.0+0.5),
aacInfo.sampling_rate);
SetDlgItemText(hwndDlg, IDC_INFOTEXT, info_text);
free(info_text);
return TRUE;
case WM_COMMAND:
switch (LOWORD(wParam))
{
case IDCANCEL:
case IDOK:
EndDialog(hwndDlg, wParam);
return TRUE;
}
}
return FALSE;
}
int infoDlg(char *fn, HWND hwndParent)
{
if(!stricmp(fn + strlen(fn) - 3,"AAC"))
{
lstrcpy(info_fn, fn);
DialogBox(module.hDllInstance, MAKEINTRESOURCE(IDD_INFO),
hwndParent, aac_info_dialog_proc);
} else {
lstrcpy(info_fn, fn);
DialogBox(module.hDllInstance, MAKEINTRESOURCE(IDD_INFO),
hwndParent, mp4_info_dialog_proc);
}
return 0;
}
/* Get the title from the file */
void ConstructTitle(mp4ff_t *file, char *filename, char *title, char *format)
{
char temp[4096];
int some_info = 0;
char *in = format;
char *out = temp;//title;
char *bound = out + sizeof(temp) - 256; //out + (MAX_PATH - 10 - 1);
char *pVal, dummy1[1024];
short dummy, dummy2;
while (*in && out < bound)
{
switch (*in)
{
case '%':
++in;
break;
default:
*out++ = *in++;
continue;
}
/* handle % escape sequence */
switch (*in++)
{
case '0':
pVal = NULL;
if (mp4ff_meta_get_track(file, &pVal))
{
out += wsprintf(out, "%s", pVal);
some_info = 1;
}
break;
case '1':
pVal = NULL;
if (mp4ff_meta_get_artist(file, &pVal))
{
out += wsprintf(out, "%s", pVal);
some_info = 1;
}
break;
case '2':
pVal = NULL;
if (mp4ff_meta_get_title(file, &pVal))
{
out += wsprintf(out, "%s", pVal);
some_info = 1;
}
break;
case '3':
pVal = NULL;
if (mp4ff_meta_get_album(file, &pVal))
{
out += wsprintf(out, "%s", pVal);
some_info = 1;
}
break;
case '4':
pVal = NULL;
if (mp4ff_meta_get_date(file, &pVal))
{
out += wsprintf(out, "%s", pVal);
some_info = 1;
}
break;
case '5':
pVal = NULL;
if (mp4ff_meta_get_comment(file, &pVal))
{
out += wsprintf(out, "%s", pVal);
some_info = 1;
}
break;
case '6':
pVal = NULL;
if (mp4ff_meta_get_genre(file, &pVal))
{
out += wsprintf(out, "%s", pVal);
some_info = 1;
}
break;
case '7':
{
const char *p=strrchr(filename,'\\');
if (!p) p=filename; else p++;
out += ConvertANSIToUTF8(p, out);
some_info = 1;
break;
}
default:
break;
}
}
*out = '\0';
if (!some_info)
{
char *p=filename+lstrlen(filename);
while (*p != '\\' && p >= filename) p--;
lstrcpy(title,++p);
}
else
{
int len = ConvertUTF8ToANSI(temp, dummy1);
if (len > (MAX_PATH - 10 - 1)) len = (MAX_PATH - 10 - 1);
memcpy(title, dummy1, len);
title[len] = '\0';
}
}
BOOL CALLBACK config_dialog_proc(HWND hwndDlg, UINT message,
WPARAM wParam, LPARAM lParam)
{
int i;
switch (message) {
case WM_INITDIALOG:
SendMessage(GetDlgItem(hwndDlg, IDC_PRIORITY), TBM_SETRANGE, TRUE, MAKELONG(1,5));
SendMessage(GetDlgItem(hwndDlg, IDC_PRIORITY), TBM_SETPOS, TRUE, m_priority);
SendMessage(GetDlgItem(hwndDlg, res_id_table[m_resolution]), BM_SETCHECK, BST_CHECKED, 0);
if (m_show_errors)
SendMessage(GetDlgItem(hwndDlg, IDC_ERROR), BM_SETCHECK, BST_CHECKED, 0);
if (m_use_for_aac)
SendMessage(GetDlgItem(hwndDlg, IDC_USEFORAAC), BM_SETCHECK, BST_CHECKED, 0);
if (m_downmix)
SendMessage(GetDlgItem(hwndDlg, IDC_DOWNMIX), BM_SETCHECK, BST_CHECKED, 0);
if (m_vbr_display)
SendMessage(GetDlgItem(hwndDlg, IDC_VBR), BM_SETCHECK, BST_CHECKED, 0);
SetDlgItemText(hwndDlg, IDC_TITLEFORMAT, titleformat);
return TRUE;
case WM_COMMAND:
switch (LOWORD(wParam)) {
case IDCANCEL:
EndDialog(hwndDlg, wParam);
return TRUE;
case IDOK:
m_show_errors = SendMessage(GetDlgItem(hwndDlg, IDC_ERROR), BM_GETCHECK, 0, 0);
m_use_for_aac = SendMessage(GetDlgItem(hwndDlg, IDC_USEFORAAC), BM_GETCHECK, 0, 0);
m_downmix = SendMessage(GetDlgItem(hwndDlg, IDC_DOWNMIX), BM_GETCHECK, 0, 0);
m_vbr_display = SendMessage(GetDlgItem(hwndDlg, IDC_VBR), BM_GETCHECK, 0, 0);
GetDlgItemText(hwndDlg, IDC_TITLEFORMAT, titleformat, MAX_PATH);
m_priority = SendMessage(GetDlgItem(hwndDlg, IDC_PRIORITY), TBM_GETPOS, 0, 0);
for (i = 0; i < 6; i++)
{
if (SendMessage(GetDlgItem(hwndDlg, res_id_table[i]), BM_GETCHECK, 0, 0))
{
m_resolution = i;
break;
}
}
/* save config */
config_write();
if (!m_use_for_aac)
{
module.FileExtensions = short_ext_list;
} else {
module.FileExtensions = long_ext_list;
}
EndDialog(hwndDlg, wParam);
return TRUE;
}
}
return FALSE;
}
void config(HWND hwndParent)
{
DialogBox(module.hDllInstance, MAKEINTRESOURCE(IDD_CONFIG),
hwndParent, config_dialog_proc);
return;
}
void about(HWND hwndParent)
{
MessageBox(hwndParent,
"AudioCoding.com MPEG-4 AAC player " FAAD2_VERSION " compiled on " __DATE__ ".\n"
"Visit the website for more info.\n"
"Copyright 2002-2004 AudioCoding.com",
"About",
MB_OK);
}
int isourfile(char *fn)
{
if (!stricmp(fn + strlen(fn) - 3,"MP4") || !stricmp(fn + strlen(fn) - 3,"M4A"))
{
return 1;
} else if (m_use_for_aac) {
if (!stricmp(fn + strlen(fn) - 3,"AAC"))
{
return 1;
}
}
return 0;
}
int fill_buffer(state *st)
{
int bread;
if (st->m_aac_bytes_consumed > 0)
{
if (st->m_aac_bytes_into_buffer)
{
memmove((void*)st->m_aac_buffer, (void*)(st->m_aac_buffer + st->m_aac_bytes_consumed),
st->m_aac_bytes_into_buffer*sizeof(unsigned char));
}
if (!st->m_at_eof)
{
bread = fread((void*)(st->m_aac_buffer + st->m_aac_bytes_into_buffer),
1, st->m_aac_bytes_consumed, st->aacfile);
if (bread != st->m_aac_bytes_consumed)
st->m_at_eof = 1;
st->m_aac_bytes_into_buffer += bread;
}
st->m_aac_bytes_consumed = 0;
if (st->m_aac_bytes_into_buffer > 3)
{
if (memcmp(st->m_aac_buffer, "TAG", 3) == 0)
st->m_aac_bytes_into_buffer = 0;
}
if (st->m_aac_bytes_into_buffer > 11)
{
if (memcmp(st->m_aac_buffer, "LYRICSBEGIN", 11) == 0)
st->m_aac_bytes_into_buffer = 0;
}
if (st->m_aac_bytes_into_buffer > 8)
{
if (memcmp(st->m_aac_buffer, "APETAGEX", 8) == 0)
st->m_aac_bytes_into_buffer = 0;
}
}
return 1;
}
void advance_buffer(state *st, int bytes)
{
st->m_file_offset += bytes;
st->m_aac_bytes_consumed = bytes;
st->m_aac_bytes_into_buffer -= bytes;
}
int adts_parse(state *st, __int64 *bitrate, double *length)
{
static int sample_rates[] = {96000,88200,64000,48000,44100,32000,24000,22050,16000,12000,11025,8000};
int frames, frame_length;
int t_framelength = 0;
int samplerate;
double frames_per_sec, bytes_per_frame;
/* Read all frames to ensure correct time and bitrate */
for (frames = 0; /* */; frames++)
{
fill_buffer(st);
if (st->m_aac_bytes_into_buffer > 7)
{
/* check syncword */
if (!((st->m_aac_buffer[0] == 0xFF)&&((st->m_aac_buffer[1] & 0xF6) == 0xF0)))
break;
st->m_tail->offset = st->m_file_offset;
st->m_tail->next = (struct seek_list*)malloc(sizeof(struct seek_list));
st->m_tail = st->m_tail->next;
st->m_tail->next = NULL;
if (frames == 0)
samplerate = sample_rates[(st->m_aac_buffer[2]&0x3c)>>2];
frame_length = ((((unsigned int)st->m_aac_buffer[3] & 0x3)) << 11)
| (((unsigned int)st->m_aac_buffer[4]) << 3) | (st->m_aac_buffer[5] >> 5);
t_framelength += frame_length;
if (frame_length > st->m_aac_bytes_into_buffer)
break;
advance_buffer(st, frame_length);
} else {
break;
}
}
frames_per_sec = (double)samplerate/1024.0;
if (frames != 0)
bytes_per_frame = (double)t_framelength/(double)(frames*1000);
else
bytes_per_frame = 0;
*bitrate = (__int64)(8. * bytes_per_frame * frames_per_sec + 0.5);
if (frames_per_sec != 0)
*length = (double)frames/frames_per_sec;
else
*length = 1;
return 1;
}
int skip_id3v2_tag()
{
unsigned char buf[10];
int bread, tagsize = 0;
bread = fread(buf, 1, 10, mp4state.aacfile);
if (bread != 10) return -1;
if (!memcmp(buf, "ID3", 3))
{
/* high bit is not used */
tagsize = (buf[6] << 21) | (buf[7] << 14) | (buf[8] << 7) | (buf[9] << 0);
tagsize += 10;
fseek(mp4state.aacfile, tagsize, SEEK_SET);
} else {
fseek(mp4state.aacfile, 0, SEEK_SET);
}
return tagsize;
}
int play(char *fn)
{
int maxlatency;
int thread_id;
int avg_bitrate, br, sr;
unsigned char *buffer;
int buffer_size;
NeAACDecConfigurationPtr config;
unsigned char header[8];
FILE *hMP4File;
#ifdef DEBUG_OUTPUT
in_mp4_DebugOutput("play");
#endif
memset(&mp4state, 0, sizeof(state));
lstrcpy(mp4state.filename, fn);
hMP4File = fopen(mp4state.filename, "rb");
if (!hMP4File)
{
return -1;
}
fread(header, 1, 8, hMP4File);
fclose(hMP4File);
mp4state.filetype = 1;
if (header[4] == 'f' && header[5] == 't' && header[6] == 'y' && header[7] == 'p')
mp4state.filetype = 0;
if (mp4state.filetype)
{
int tagsize = 0, tmp = 0, init;
int bread = 0;
double length = 0.;
__int64 bitrate = 128;
// NeAACDecFrameInfo frameInfo;
module.is_seekable = 1;
if (!(mp4state.aacfile = fopen(mp4state.filename, "rb")))
{
// error
return -1;
}
tagsize = skip_id3v2_tag();
if (tagsize<0) return 0;
if (!(mp4state.m_aac_buffer = (unsigned char*)malloc(768*6)))
{
show_error(module.hMainWindow, "Memory allocation error.");
return -1;
}
for (init=0; init<2; init++)
{
mp4state.hDecoder = NeAACDecOpen();
if (!mp4state.hDecoder)
{
show_error(module.hMainWindow, "Unable to open decoder library.");
return -1;
}
config = NeAACDecGetCurrentConfiguration(mp4state.hDecoder);
config->outputFormat = m_resolution + 1;
config->downMatrix = m_downmix;
NeAACDecSetConfiguration(mp4state.hDecoder, config);
memset(mp4state.m_aac_buffer, 0, 768*6);
bread = fread(mp4state.m_aac_buffer, 1, 768*6, mp4state.aacfile);
mp4state.m_aac_bytes_into_buffer = bread;
mp4state.m_aac_bytes_consumed = 0;
mp4state.m_file_offset = 0;
mp4state.m_at_eof = (bread != 768*6) ? 1 : 0;
if (init==0)
{
NeAACDecFrameInfo frameInfo;
fill_buffer(&mp4state);
if ((mp4state.m_aac_bytes_consumed = NeAACDecInit(mp4state.hDecoder,
mp4state.m_aac_buffer, mp4state.m_aac_bytes_into_buffer,
&mp4state.samplerate, &mp4state.channels)) < 0)
{
show_error(module.hMainWindow, "Can't initialize decoder library.");
return -1;
}
advance_buffer(&mp4state, mp4state.m_aac_bytes_consumed);
do {
memset(&frameInfo, 0, sizeof(NeAACDecFrameInfo));
fill_buffer(&mp4state);
NeAACDecDecode(mp4state.hDecoder, &frameInfo, mp4state.m_aac_buffer, mp4state.m_aac_bytes_into_buffer);
} while (!frameInfo.samples && !frameInfo.error);
if (frameInfo.error)
{
show_error(module.hMainWindow, NeAACDecGetErrorMessage(frameInfo.error));
return -1;
}
mp4state.channels = frameInfo.channels;
mp4state.samplerate = frameInfo.samplerate;
mp4state.framesize = (frameInfo.channels != 0) ? frameInfo.samples/frameInfo.channels : 0;
/*
sbr = frameInfo.sbr;
profile = frameInfo.object_type;
header_type = frameInfo.header_type;
*/
NeAACDecClose(mp4state.hDecoder);
fseek(mp4state.aacfile, tagsize, SEEK_SET);
}
}
mp4state.m_head = (struct seek_list*)malloc(sizeof(struct seek_list));
mp4state.m_tail = mp4state.m_head;
mp4state.m_tail->next = NULL;
mp4state.m_header_type = 0;
if ((mp4state.m_aac_buffer[0] == 0xFF) && ((mp4state.m_aac_buffer[1] & 0xF6) == 0xF0))
{
if (1) //(can_seek)
{
adts_parse(&mp4state, &bitrate, &length);
fseek(mp4state.aacfile, tagsize, SEEK_SET);
bread = fread(mp4state.m_aac_buffer, 1, 768*6, mp4state.aacfile);
if (bread != 768*6)
mp4state.m_at_eof = 1;
else
mp4state.m_at_eof = 0;
mp4state.m_aac_bytes_into_buffer = bread;
mp4state.m_aac_bytes_consumed = 0;
mp4state.m_header_type = 1;
}
} else if (memcmp(mp4state.m_aac_buffer, "ADIF", 4) == 0) {
int skip_size = (mp4state.m_aac_buffer[4] & 0x80) ? 9 : 0;
bitrate = ((unsigned int)(mp4state.m_aac_buffer[4 + skip_size] & 0x0F)<<19) |
((unsigned int)mp4state.m_aac_buffer[5 + skip_size]<<11) |
((unsigned int)mp4state.m_aac_buffer[6 + skip_size]<<3) |
((unsigned int)mp4state.m_aac_buffer[7 + skip_size] & 0xE0);
length = (double)file_length(mp4state.aacfile);
if (length == -1)
{
module.is_seekable = 0;
length = 0;
} else {
length = ((double)length*8.)/((double)bitrate) + 0.5;
}
mp4state.m_header_type = 2;
} else {
length = (double)file_length(mp4state.aacfile);
length = ((double)length*8.)/((double)bitrate*1000.) + 0.5;
module.is_seekable = 1;
}
mp4state.m_length = (int)(length*1000.);
fill_buffer(&mp4state);
if ((mp4state.m_aac_bytes_consumed = NeAACDecInit(mp4state.hDecoder,
mp4state.m_aac_buffer, mp4state.m_aac_bytes_into_buffer,
&mp4state.samplerate, &mp4state.channels)) < 0)
{
show_error(module.hMainWindow, "Can't initialize decoder library.");
return -1;
}
advance_buffer(&mp4state, mp4state.m_aac_bytes_consumed);
if (mp4state.m_header_type == 2)
avg_bitrate = bitrate;
else
avg_bitrate = bitrate*1000;
} else {
mp4state.hDecoder = NeAACDecOpen();
if (!mp4state.hDecoder)
{
show_error(module.hMainWindow, "Unable to open decoder library.");
return -1;
}
config = NeAACDecGetCurrentConfiguration(mp4state.hDecoder);
config->outputFormat = m_resolution + 1;
config->downMatrix = m_downmix;
NeAACDecSetConfiguration(mp4state.hDecoder, config);
mp4state.mp4File = fopen(mp4state.filename, "rb");
mp4state.mp4cb.read = read_callback;
mp4state.mp4cb.seek = seek_callback;
mp4state.mp4cb.user_data = mp4state.mp4File;
mp4state.mp4file = mp4ff_open_read(&mp4state.mp4cb);
if (!mp4state.mp4file)
{
show_error(module.hMainWindow, "Unable to open file.");
NeAACDecClose(mp4state.hDecoder);
return -1;
}
if ((mp4state.mp4track = GetAACTrack(mp4state.mp4file)) < 0)
{
show_error(module.hMainWindow, "Unsupported Audio track type.");
NeAACDecClose(mp4state.hDecoder);
mp4ff_close(mp4state.mp4file);
fclose(mp4state.mp4File);
return -1;
}
buffer = NULL;
buffer_size = 0;
mp4ff_get_decoder_config(mp4state.mp4file, mp4state.mp4track,
&buffer, &buffer_size);
if (!buffer)
{
NeAACDecClose(mp4state.hDecoder);
mp4ff_close(mp4state.mp4file);
fclose(mp4state.mp4File);
return -1;
}
if(NeAACDecInit2(mp4state.hDecoder, buffer, buffer_size,
&mp4state.samplerate, &mp4state.channels) < 0)
{
/* If some error initializing occured, skip the file */
NeAACDecClose(mp4state.hDecoder);
mp4ff_close(mp4state.mp4file);
fclose(mp4state.mp4File);
if (buffer) free (buffer);
return -1;
}
/* for gapless decoding */
{
mp4AudioSpecificConfig mp4ASC;
mp4state.timescale = mp4ff_time_scale(mp4state.mp4file, mp4state.mp4track);
mp4state.framesize = 1024;
mp4state.useAacLength = 0;
if (buffer)
{
if (NeAACDecAudioSpecificConfig(buffer, buffer_size, &mp4ASC) >= 0)
{
if (mp4ASC.frameLengthFlag == 1) mp4state.framesize = 960;
if (mp4ASC.sbr_present_flag == 1) mp4state.framesize *= 2;
}
}
}
free(buffer);
avg_bitrate = mp4ff_get_avg_bitrate(mp4state.mp4file, mp4state.mp4track);
mp4state.numSamples = mp4ff_num_samples(mp4state.mp4file, mp4state.mp4track);
mp4state.sampleId = 0;
{
double timescale_div = 1.0 / (double)mp4ff_time_scale(mp4state.mp4file, mp4state.mp4track);
int64_t duration = mp4ff_get_track_duration_use_offsets(mp4state.mp4file, mp4state.mp4track);
if (duration == -1)
{
mp4state.m_length = 0;
} else {
mp4state.m_length = (int)((double)duration * timescale_div * 1000.0);
}
}
module.is_seekable = 1;
}
if (mp4state.channels == 0)
{
show_error(module.hMainWindow, "Number of channels not supported for playback.");
NeAACDecClose(mp4state.hDecoder);
if (mp4state.filetype)
fclose(mp4state.aacfile);
else {
mp4ff_close(mp4state.mp4file);
fclose(mp4state.mp4File);
}
return -1;
}
if (m_downmix && (mp4state.channels == 5 || mp4state.channels == 6))
mp4state.channels = 2;
maxlatency = module.outMod->Open(mp4state.samplerate, (int)mp4state.channels,
res_table[m_resolution], -1, -1);
if (maxlatency < 0) // error opening device
{
NeAACDecClose(mp4state.hDecoder);
if (mp4state.filetype)
fclose(mp4state.aacfile);
else {
mp4ff_close(mp4state.mp4file);
fclose(mp4state.mp4File);
}
return -1;
}
mp4state.paused = 0;
mp4state.decode_pos_ms = 0;
mp4state.seek_needed = -1;
// initialize vis stuff
module.SAVSAInit(maxlatency, mp4state.samplerate);
module.VSASetInfo((int)mp4state.channels, mp4state.samplerate);
br = (int)floor(((float)avg_bitrate + 500.0)/1000.0 + 0.5);
sr = (int)floor((float)mp4state.samplerate/1000.0 + 0.5);
module.SetInfo(br, sr, (int)mp4state.channels, 1);
module.outMod->SetVolume(-666); // set the output plug-ins default volume
killPlayThread = 0;
if (mp4state.filetype)
{
if ((play_thread_handle = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)AACPlayThread,
(void *)&killPlayThread, 0, &thread_id)) == NULL)
{
show_error(module.hMainWindow, "Cannot create playback thread");
NeAACDecClose(mp4state.hDecoder);
fclose(mp4state.aacfile);
return -1;
}
} else {
if ((play_thread_handle = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)MP4PlayThread,
(void *)&killPlayThread, 0, &thread_id)) == NULL)
{
show_error(module.hMainWindow, "Cannot create playback thread");
NeAACDecClose(mp4state.hDecoder);
mp4ff_close(mp4state.mp4file);
fclose(mp4state.mp4File);
return -1;
}
}
SetThreadAffinityMask(play_thread_handle, 1);
SetThreadPriority(play_thread_handle, priority_table[m_priority]);
return 0;
}
void pause()
{
#ifdef DEBUG_OUTPUT
in_mp4_DebugOutput("pause");
#endif
mp4state.paused = 1;
module.outMod->Pause(1);
}
void unpause()
{
#ifdef DEBUG_OUTPUT
in_mp4_DebugOutput("unpause");
#endif
mp4state.paused = 0;
module.outMod->Pause(0);
}
int ispaused()
{
#ifdef DEBUG_OUTPUT
in_mp4_DebugOutput("ispaused");
#endif
return mp4state.paused;
}
void setvolume(int volume)
{
#ifdef DEBUG_OUTPUT
in_mp4_DebugOutput("setvolume");
#endif
module.outMod->SetVolume(volume);
}
void setpan(int pan)
{
#ifdef DEBUG_OUTPUT
in_mp4_DebugOutput("setpan");
#endif
module.outMod->SetPan(pan);
}
void stop()
{
struct seek_list *target = mp4state.m_head;
#ifdef DEBUG_OUTPUT
in_mp4_DebugOutput("stop");
#endif
killPlayThread = 1;
if (play_thread_handle != INVALID_HANDLE_VALUE)
{
if (WaitForSingleObject(play_thread_handle, INFINITE) == WAIT_TIMEOUT)
TerminateThread(play_thread_handle,0);
CloseHandle(play_thread_handle);
play_thread_handle = INVALID_HANDLE_VALUE;
}
if (mp4state.m_aac_buffer)
free(mp4state.m_aac_buffer);
while (target)
{
struct seek_list *tmp = target;
target = target->next;
if (tmp) free(tmp);
}
NeAACDecClose(mp4state.hDecoder);
if (mp4state.filetype)
fclose(mp4state.aacfile);
else {
mp4ff_close(mp4state.mp4file);
fclose(mp4state.mp4File);
}
module.outMod->Close();
module.SAVSADeInit();
mp4state.filename[0] = '\0';
}
int getsonglength(const char *fn)
{
long msDuration = 0;
if(!stricmp(fn + strlen(fn) - 3,"MP4") || !stricmp(fn + strlen(fn) - 3,"M4A"))
{
int track;
int64_t length;
FILE *mp4File;
mp4ff_t *file;
mp4ff_callback_t mp4cb = {0};
mp4File = fopen(fn, "rb");
mp4cb.read = read_callback;
mp4cb.seek = seek_callback;
mp4cb.user_data = mp4File;
file = mp4ff_open_read(&mp4cb);
if (file == NULL)
return 0;
if ((track = GetAACTrack(file)) < 0)
{
mp4ff_close(file);
fclose(mp4File);
return -1;
}
length = mp4ff_get_track_duration(file, track);
msDuration = (long)((float)length*1000.0 / (float)mp4ff_time_scale(file, track) + 0.5);
mp4ff_close(file);
fclose(mp4File);
return msDuration;
} else {
int tagsize = 0;
int bread = 0;
double length = 0.;
__int64 bitrate = 128;
struct seek_list *target;
state len_state;
memset(&len_state, 0, sizeof(state));
if (!(len_state.aacfile = fopen(fn, "rb")))
{
// error
return 0;
}
len_state.m_at_eof = 0;
if (!(len_state.m_aac_buffer = (unsigned char*)malloc(768*6)))
{
//console::error("Memory allocation error.", "foo_mp4");
return 0;
}
memset(len_state.m_aac_buffer, 0, 768*6);
bread = fread(len_state.m_aac_buffer, 1, 768*6, len_state.aacfile);
len_state.m_aac_bytes_into_buffer = bread;
len_state.m_aac_bytes_consumed = 0;
len_state.m_file_offset = 0;
if (bread != 768*6)
len_state.m_at_eof = 1;
if (!memcmp(len_state.m_aac_buffer, "ID3", 3))
{
/* high bit is not used */
tagsize = (len_state.m_aac_buffer[6] << 21) | (len_state.m_aac_buffer[7] << 14) |
(len_state.m_aac_buffer[8] << 7) | (len_state.m_aac_buffer[9] << 0);
tagsize += 10;
advance_buffer(&len_state, tagsize);
}
len_state.m_head = (struct seek_list*)malloc(sizeof(struct seek_list));
len_state.m_tail = len_state.m_head;
len_state.m_tail->next = NULL;
len_state.m_header_type = 0;
if ((len_state.m_aac_buffer[0] == 0xFF) && ((len_state.m_aac_buffer[1] & 0xF6) == 0xF0))
{
if (1) //(m_reader->can_seek())
{
adts_parse(&len_state, &bitrate, &length);
fseek(len_state.aacfile, tagsize, SEEK_SET);
bread = fread(len_state.m_aac_buffer, 1, 768*6, len_state.aacfile);
if (bread != 768*6)
len_state.m_at_eof = 1;
else
len_state.m_at_eof = 0;
len_state.m_aac_bytes_into_buffer = bread;
len_state.m_aac_bytes_consumed = 0;
len_state.m_header_type = 1;
}
} else if (memcmp(len_state.m_aac_buffer, "ADIF", 4) == 0) {
int skip_size = (len_state.m_aac_buffer[4] & 0x80) ? 9 : 0;
bitrate = ((unsigned int)(len_state.m_aac_buffer[4 + skip_size] & 0x0F)<<19) |
((unsigned int)len_state.m_aac_buffer[5 + skip_size]<<11) |
((unsigned int)len_state.m_aac_buffer[6 + skip_size]<<3) |
((unsigned int)len_state.m_aac_buffer[7 + skip_size] & 0xE0);
length = (double)file_length(len_state.aacfile);
if (length == -1)
length = 0;
else
length = ((double)length*8.)/((double)bitrate) + 0.5;
len_state.m_header_type = 2;
} else {
length = (double)file_length(len_state.aacfile);
length = ((double)length*8.)/((double)bitrate*1000.) + 0.5;
len_state.m_header_type = 0;
}
if (len_state.m_aac_buffer)
free(len_state.m_aac_buffer);
target = len_state.m_head;
while (target)
{
struct seek_list *tmp = target;
target = target->next;
if (tmp) free(tmp);
}
fclose(len_state.aacfile);
return (int)(length*1000.);
}
}
int getlength()
{
if (!mp4state.filetype)
{
int track;
long msDuration;
long length;
if ((track = GetAACTrack(mp4state.mp4file)) < 0)
{
return -1;
}
length = mp4ff_get_track_duration(mp4state.mp4file, track);
msDuration = (long)(length*1000.0 / (float)mp4ff_time_scale(mp4state.mp4file, track) + 0.5);
return msDuration;
} else {
return mp4state.m_length;
}
return 0;
}
int getoutputtime()
{
return mp4state.decode_pos_ms+(module.outMod->GetOutputTime()-module.outMod->GetWrittenTime());
}
void setoutputtime(int time_in_ms)
{
#ifdef DEBUG_OUTPUT
in_mp4_DebugOutput("setoutputtime");
#endif
mp4state.seek_needed = time_in_ms;
}
void getfileinfo(char *filename, char *title, int *length_in_ms)
{
if (!filename || !*filename) /* currently playing file */
{
if (length_in_ms)
*length_in_ms = getlength();
if (title)
{
if (mp4state.filetype == 0)
{
ConstructTitle(mp4state.mp4file, mp4state.filename, title, titleformat);
} else {
char *tmp2;
char *tmp = PathFindFileName(mp4state.filename);
strcpy(title, tmp);
tmp2 = strrchr(title, '.');
tmp2[0] = '\0';
}
}
} else {
if (length_in_ms)
*length_in_ms = getsonglength(filename);
if (title)
{
unsigned char header[8];
FILE *hMP4File = fopen(filename, "rb");
if (!hMP4File)
{
return;
}
fread(header, 1, 8, hMP4File);
fclose(hMP4File);
if (header[4] == 'f' && header[5] == 't' && header[6] == 'y' && header[7] == 'p')
{
FILE *mp4File;
mp4ff_t *file;
mp4ff_callback_t mp4cb = {0};
mp4File = fopen(filename, "rb");
mp4cb.read = read_callback;
mp4cb.seek = seek_callback;
mp4cb.user_data = mp4File;
file = mp4ff_open_read(&mp4cb);
if (file == NULL)
return;
ConstructTitle(file, filename, title, titleformat);
mp4ff_close(file);
fclose(mp4File);
} else {
char *tmp2;
char *tmp = PathFindFileName(filename);
strcpy(title, tmp);
tmp2 = strrchr(title, '.');
tmp2[0] = '\0';
}
}
}
}
void eq_set(int on, char data[10], int preamp)
{
}
static void remap_channels(unsigned char *data, unsigned int samples, unsigned int bps)
{
unsigned int i;
switch (bps)
{
case 8:
{
unsigned char r1, r2, r3, r4, r5, r6;
for (i = 0; i < samples; i += 6)
{
r1 = data[i];
r2 = data[i+1];
r3 = data[i+2];
r4 = data[i+3];
r5 = data[i+4];
r6 = data[i+5];
data[i] = r2;
data[i+1] = r3;
data[i+2] = r1;
data[i+3] = r6;
data[i+4] = r4;
data[i+5] = r5;
}
}
break;
case 16:
default:
{
unsigned short r1, r2, r3, r4, r5, r6;
unsigned short *sample_buffer = (unsigned short *)data;
for (i = 0; i < samples; i += 6)
{
r1 = sample_buffer[i];
r2 = sample_buffer[i+1];
r3 = sample_buffer[i+2];
r4 = sample_buffer[i+3];
r5 = sample_buffer[i+4];
r6 = sample_buffer[i+5];
sample_buffer[i] = r2;
sample_buffer[i+1] = r3;
sample_buffer[i+2] = r1;
sample_buffer[i+3] = r6;
sample_buffer[i+4] = r4;
sample_buffer[i+5] = r5;
}
}
break;
case 24:
case 32:
{
unsigned int r1, r2, r3, r4, r5, r6;
unsigned int *sample_buffer = (unsigned int *)data;
for (i = 0; i < samples; i += 6)
{
r1 = sample_buffer[i];
r2 = sample_buffer[i+1];
r3 = sample_buffer[i+2];
r4 = sample_buffer[i+3];
r5 = sample_buffer[i+4];
r6 = sample_buffer[i+5];
sample_buffer[i] = r2;
sample_buffer[i+1] = r3;
sample_buffer[i+2] = r1;
sample_buffer[i+3] = r6;
sample_buffer[i+4] = r4;
sample_buffer[i+5] = r5;
}
}
break;
}
}
DWORD WINAPI MP4PlayThread(void *b)
{
int done = 0;
int l;
int seq_frames = 0;
int seq_bytes = 0;
void *sample_buffer;
unsigned char *buffer;
int buffer_size;
NeAACDecFrameInfo frameInfo;
#ifdef DEBUG_OUTPUT
in_mp4_DebugOutput("MP4PlayThread");
#endif
PlayThreadAlive = 1;
mp4state.last_frame = 0;
mp4state.initial = 1;
while (!*((int *)b))
{
/* seeking */
if (mp4state.seek_needed != -1)
{
int64_t duration;
int32_t skip_samples = 0;
module.outMod->Flush(mp4state.decode_pos_ms);
duration = (int64_t)(mp4state.seek_needed/1000.0 * mp4state.samplerate + 0.5);
mp4state.sampleId = mp4ff_find_sample_use_offsets(mp4state.mp4file,
mp4state.mp4track, duration, &skip_samples);
mp4state.decode_pos_ms = mp4state.seek_needed;
mp4state.seek_needed = -1;
}
if (done)
{
module.outMod->CanWrite();
if (!module.outMod->IsPlaying())
{
PostMessage(module.hMainWindow, WM_WA_AAC_EOF, 0, 0);
PlayThreadAlive = 0;
return 0;
}
Sleep(10);
} else if (module.outMod->CanWrite() >= (2048*mp4state.channels*sizeof(short))) {
if (mp4state.last_frame)
{
done = 1;
} else {
int rc;
/* for gapless decoding */
char *buf;
long dur;
unsigned int sample_count;
unsigned int delay = 0;
/* get acces unit from MP4 file */
buffer = NULL;
buffer_size = 0;
dur = mp4ff_get_sample_duration(mp4state.mp4file, mp4state.mp4track, mp4state.sampleId);
rc = mp4ff_read_sample(mp4state.mp4file, mp4state.mp4track, mp4state.sampleId++, &buffer, &buffer_size);
if (mp4state.sampleId == 1) dur = 0;
if (rc == 0 || buffer == NULL)
{
mp4state.last_frame = 1;
sample_buffer = NULL;
frameInfo.samples = 0;
} else {
sample_buffer = NeAACDecDecode(mp4state.hDecoder, &frameInfo,
buffer, buffer_size);
}
if (frameInfo.error > 0)
{
show_error(module.hMainWindow, NeAACDecGetErrorMessage(frameInfo.error));
mp4state.last_frame = 1;
}
if (mp4state.sampleId >= mp4state.numSamples)
mp4state.last_frame = 1;
if (buffer) free(buffer);
if (mp4state.useAacLength || (mp4state.timescale != mp4state.samplerate)) {
sample_count = frameInfo.samples;
} else {
sample_count = (unsigned int)(dur * frameInfo.channels);
if (!mp4state.useAacLength && !mp4state.initial && (mp4state.sampleId < mp4state.numSamples/2) && (dur*frameInfo.channels != frameInfo.samples))
{
//fprintf(stderr, "MP4 seems to have incorrect frame duration, using values from AAC data.\n");
mp4state.useAacLength = 1;
sample_count = frameInfo.samples;
}
}
if (mp4state.initial && (sample_count < mp4state.framesize*mp4state.channels) && (frameInfo.samples > sample_count))
{
delay = frameInfo.samples - sample_count;
}
if (!killPlayThread && (sample_count > 0))
{
buf = (char *)sample_buffer;
mp4state.initial = 0;
switch (res_table[m_resolution])
{
case 8:
buf += delay;
break;
case 16:
default:
buf += delay * 2;
break;
case 24:
case 32:
buf += delay * 4;
break;
case 64:
buf += delay * 8;
}
if (frameInfo.channels == 6 && frameInfo.num_lfe_channels)
remap_channels(buf, sample_count, res_table[m_resolution]);
if (res_table[m_resolution] == 24)
{
/* convert libfaad output (3 bytes packed in 4) */
char *temp_buffer = convert3in4to3in3(buf, sample_count);
memcpy((void*)buf, (void*)temp_buffer, sample_count*3);
free(temp_buffer);
}
module.SAAddPCMData(buf, (int)mp4state.channels, res_table[m_resolution],
mp4state.decode_pos_ms);
module.VSAAddPCMData(buf, (int)mp4state.channels, res_table[m_resolution],
mp4state.decode_pos_ms);
mp4state.decode_pos_ms += (double)sample_count * 1000.0 /
((double)frameInfo.samplerate * (double)frameInfo.channels);
l = sample_count * res_table[m_resolution] / 8;
if (module.dsp_isactive())
{
void *dsp_buffer = malloc(l*2);
memcpy(dsp_buffer, buf, l);
l = module.dsp_dosamples((short*)dsp_buffer,
sample_count/frameInfo.channels,
res_table[m_resolution],
frameInfo.channels,
frameInfo.samplerate) *
(frameInfo.channels*(res_table[m_resolution]/8));
module.outMod->Write(dsp_buffer, l);
if (dsp_buffer) free(dsp_buffer);
} else {
module.outMod->Write(buf, l);
}
/* VBR bitrate display */
if (m_vbr_display)
{
seq_frames++;
seq_bytes += frameInfo.bytesconsumed;
if (seq_frames == (int)(floor((float)frameInfo.samplerate/(float)(sample_count/frameInfo.channels) + 0.5)))
{
module.SetInfo((int)floor(((float)seq_bytes*8.)/1000. + 0.5),
(int)floor(frameInfo.samplerate/1000. + 0.5),
mp4state.channels, 1);
seq_frames = 0;
seq_bytes = 0;
}
}
}
}
} else {
Sleep(10);
}
}
PlayThreadAlive = 0;
return 0;
}
void *decode_aac_frame(state *st, NeAACDecFrameInfo *frameInfo)
{
void *sample_buffer = NULL;
do
{
fill_buffer(st);
if (st->m_aac_bytes_into_buffer != 0)
{
sample_buffer = NeAACDecDecode(st->hDecoder, frameInfo,
st->m_aac_buffer, st->m_aac_bytes_into_buffer);
if (st->m_header_type != 1)
{
if (st->last_offset < st->m_file_offset)
{
st->m_tail->offset = st->m_file_offset;
st->m_tail->next = (struct seek_list*)malloc(sizeof(struct seek_list));
st->m_tail = st->m_tail->next;
st->m_tail->next = NULL;
st->last_offset = st->m_file_offset;
}
}
advance_buffer(st, frameInfo->bytesconsumed);
} else {
break;
}
} while (!frameInfo->samples && !frameInfo->error);
return sample_buffer;
}
int aac_seek(state *st, double seconds)
{
int i, frames;
int bread;
struct seek_list *target = st->m_head;
if (1 /*can_seek*/ && ((st->m_header_type == 1) || (seconds < st->cur_pos_sec)))
{
frames = (int)(seconds*((double)st->samplerate/(double)st->framesize) + 0.5);
for (i = 0; i < frames; i++)
{
if (target->next)
target = target->next;
else
return 0;
}
if (target->offset == 0 && frames > 0)
return 0;
fseek(st->aacfile, target->offset, SEEK_SET);
st->m_file_offset = target->offset;
bread = fread(st->m_aac_buffer, 1, 768*6, st->aacfile);
if (bread != 768*6)
st->m_at_eof = 1;
else
st->m_at_eof = 0;
st->m_aac_bytes_into_buffer = bread;
st->m_aac_bytes_consumed = 0;
st->m_file_offset += bread;
NeAACDecPostSeekReset(st->hDecoder, -1);
return 1;
} else {
if (seconds > st->cur_pos_sec)
{
NeAACDecFrameInfo frameInfo;
frames = (int)((seconds - st->cur_pos_sec)*((double)st->samplerate/(double)st->framesize));
if (frames > 0)
{
for (i = 0; i < frames; i++)
{
memset(&frameInfo, 0, sizeof(NeAACDecFrameInfo));
decode_aac_frame(st, &frameInfo);
if (frameInfo.error || (st->m_aac_bytes_into_buffer == 0))
{
if (frameInfo.error)
{
if (NeAACDecGetErrorMessage(frameInfo.error) != NULL)
show_error(module.hMainWindow, NeAACDecGetErrorMessage(frameInfo.error));
}
return 0;
}
}
}
NeAACDecPostSeekReset(st->hDecoder, -1);
}
return 1;
}
}
DWORD WINAPI AACPlayThread(void *b)
{
int done = 0;
int l;
int seq_frames = 0;
int seq_bytes = 0;
#ifdef DEBUG_OUTPUT
in_mp4_DebugOutput("AACPlayThread");
#endif
PlayThreadAlive = 1;
mp4state.last_frame = 0;
while (!*((int *)b))
{
/* seeking */
if (mp4state.seek_needed != -1)
{
double ms;
ms = mp4state.seek_needed/1000;
if (aac_seek(&mp4state, ms)!=0)
{
module.outMod->Flush(mp4state.decode_pos_ms);
mp4state.cur_pos_sec = ms;
mp4state.decode_pos_ms = mp4state.seek_needed;
}
mp4state.seek_needed = -1;
}
if (done)
{
module.outMod->CanWrite();
if (!module.outMod->IsPlaying())
{
PostMessage(module.hMainWindow, WM_WA_AAC_EOF, 0, 0);
PlayThreadAlive = 0;
return 0;
}
Sleep(10);
} else if (module.outMod->CanWrite() >= (2048*mp4state.channels*sizeof(short))) {
NeAACDecFrameInfo frameInfo;
void *sample_buffer;
memset(&frameInfo, 0, sizeof(NeAACDecFrameInfo));
sample_buffer = decode_aac_frame(&mp4state, &frameInfo);
if (frameInfo.error || (mp4state.m_aac_bytes_into_buffer == 0))
{
if (frameInfo.error)
{
if (NeAACDecGetErrorMessage(frameInfo.error) != NULL)
show_error(module.hMainWindow, NeAACDecGetErrorMessage(frameInfo.error));
}
done = 1;
}
if (!killPlayThread && (frameInfo.samples > 0))
{
if (frameInfo.channels == 6 && frameInfo.num_lfe_channels)
remap_channels(sample_buffer, frameInfo.samples, res_table[m_resolution]);
if (res_table[m_resolution] == 24)
{
/* convert libfaad output (3 bytes packed in 4 bytes) */
char *temp_buffer = convert3in4to3in3(sample_buffer, frameInfo.samples);
memcpy((void*)sample_buffer, (void*)temp_buffer, frameInfo.samples*3);
free(temp_buffer);
}
module.SAAddPCMData(sample_buffer, (int)mp4state.channels, res_table[m_resolution],
mp4state.decode_pos_ms);
module.VSAAddPCMData(sample_buffer, (int)mp4state.channels, res_table[m_resolution],
mp4state.decode_pos_ms);
mp4state.decode_pos_ms += (double)frameInfo.samples * 1000.0 /
((double)frameInfo.samplerate* (double)frameInfo.channels);
l = frameInfo.samples * res_table[m_resolution] / 8;
if (module.dsp_isactive())
{
void *dsp_buffer = malloc(l*2);
memcpy(dsp_buffer, sample_buffer, l);
l = module.dsp_dosamples((short*)dsp_buffer,
frameInfo.samples/frameInfo.channels,
res_table[m_resolution],
frameInfo.channels,
frameInfo.samplerate) *
(frameInfo.channels*(res_table[m_resolution]/8));
module.outMod->Write(dsp_buffer, l);
if (dsp_buffer) free(dsp_buffer);
} else {
module.outMod->Write(sample_buffer, l);
}
/* VBR bitrate display */
if (m_vbr_display)
{
seq_frames++;
seq_bytes += frameInfo.bytesconsumed;
if (seq_frames == (int)(floor((float)frameInfo.samplerate/(float)(frameInfo.samples/frameInfo.channels) + 0.5)))
{
module.SetInfo((int)floor(((float)seq_bytes*8.)/1000. + 0.5),
(int)floor(frameInfo.samplerate/1000. + 0.5),
mp4state.channels, 1);
seq_frames = 0;
seq_bytes = 0;
}
}
}
if (frameInfo.channels > 0 && mp4state.samplerate > 0)
mp4state.cur_pos_sec += ((double)(frameInfo.samples/frameInfo.channels))/(double)mp4state.samplerate;
} else {
Sleep(10);
}
}
PlayThreadAlive = 0;
return 0;
}
static In_Module module =
{
IN_VER,
"AudioCoding.com MPEG-4 AAC player: " FAAD2_VERSION " compiled on " __DATE__,
0, // hMainWindow
0, // hDllInstance
NULL,
1, // is_seekable
1, // uses output
config,
about,
init,
quit,
getfileinfo,
infoDlg,
isourfile,
play,
pause,
unpause,
ispaused,
stop,
getlength,
getoutputtime,
setoutputtime,
setvolume,
setpan,
0,0,0,0,0,0,0,0,0, // vis stuff
0,0, // dsp
eq_set,
NULL, // setinfo
0 // out_mod
};
__declspec(dllexport) In_Module* winampGetInModule2()
{
config_read();
if (!m_use_for_aac)
{
module.FileExtensions = short_ext_list;
} else {
module.FileExtensions = long_ext_list;
}
return &module;
}
/* new Media Library interface */
int mp4_get_metadata(mp4ff_t *file, const char *item, char *dest, int dlen)
{
char *pVal = NULL, dummy1[4096];
if (dlen < 1) return 0;
if (!stricmp(item, "track") || !stricmp(item, "tracknumber"))
{
if (mp4ff_meta_get_track(file, &pVal))
{
wsprintf(dummy1, "%s", pVal);
strncpy(dest, dummy1, dlen-1);
dest[dlen-1] = '\0';
return 1;
}
}
else if (!stricmp(item, "disc") || !stricmp(item, "disknumber"))
{
if (mp4ff_meta_get_disc(file, &pVal))
{
wsprintf(dummy1, "%s", pVal);
strncpy(dest, dummy1, dlen-1);
dest[dlen-1] = '\0';
return 1;
}
}
else if (!stricmp(item, "compilation"))
{
uint8_t cpil = 0;
if (mp4ff_meta_get_compilation(file, &pVal))
{
wsprintf(dummy1, "%s", pVal);
strncpy(dest, dummy1, dlen-1);
dest[dlen-1] = '\0';
return 1;
}
}
else if (!stricmp(item, "tempo"))
{
if (mp4ff_meta_get_tempo(file, &pVal))
{
wsprintf(dummy1, "%s", pVal);
strncpy(dest, dummy1, dlen-1);
dest[dlen-1] = '\0';
return 1;
}
}
else if (!stricmp(item, "artist"))
{
if (mp4ff_meta_get_artist(file, &pVal))
{
strncpy(dest, pVal, dlen-1);
dest[dlen-1] = '\0';
return 1;
}
}
else if (!stricmp(item, "writer"))
{
if (mp4ff_meta_get_writer(file, &pVal))
{
strncpy(dest, pVal, dlen-1);
dest[dlen-1] = '\0';
return 1;
}
}
else if (!stricmp(item, "title"))
{
if (mp4ff_meta_get_title(file, &pVal))
{
strncpy(dest, pVal, dlen-1);
dest[dlen-1] = '\0';
return 1;
}
}
else if (!stricmp(item, "album"))
{
if (mp4ff_meta_get_album(file, &pVal))
{
strncpy(dest, pVal, dlen-1);
dest[dlen-1] = '\0';
return 1;
}
}
else if (!stricmp(item, "date") || !stricmp(item, "year"))
{
if (mp4ff_meta_get_date(file, &pVal))
{
strncpy(dest, pVal, dlen-1);
dest[dlen-1] = '\0';
return 1;
}
}
else if (!stricmp(item, "comment"))
{
if (mp4ff_meta_get_comment(file, &pVal))
{
strncpy(dest, pVal, dlen-1);
dest[dlen-1] = '\0';
return 1;
}
}
else if (!stricmp(item, "genre"))
{
if (mp4ff_meta_get_genre(file, &pVal))
{
strncpy(dest, pVal, dlen-1);
dest[dlen-1] = '\0';
return 1;
}
}
else if (!stricmp(item, "tool"))
{
if (mp4ff_meta_get_tool(file, &pVal))
{
strncpy(dest, pVal, dlen-1);
dest[dlen-1] = '\0';
return 1;
}
}
#if 0
else
{
uint32_t valueSize = 0;
uint8_t *pValue = NULL;
if (MP4GetMetadataFreeForm(file, (char *)item, &pValue, &valueSize))
{
unsigned int len = (valueSize < (unsigned int)(dlen-1)) ? valueSize : (unsigned int)(dlen-1);
memcpy(dest, pValue, len);
dest[len] = '\0';
return 1;
}
}
#endif
return 0;
}
__declspec(dllexport) int winampGetExtendedFileInfo(const char *fn, const char *data, char *dest, int destlen)
{
if (!fn || (fn && !*fn) || !destlen) return 0;
dest[0] = '\0';
if (!stricmp(data, "length"))
{
char temp[32];
int len = getsonglength(fn);
itoa(len, temp, 10);
strncpy(dest, temp, destlen-1);
dest[destlen-1] = '\0';
}
else
{
char temp[2048], temp2[2048];
FILE *mp4File;
mp4ff_callback_t mp4cb = {0};
mp4ff_t *file;
mp4File = fopen(fn, "rb");
mp4cb.read = read_callback;
mp4cb.seek = seek_callback;
mp4cb.write = write_callback;
mp4cb.truncate = truncate_callback;
mp4cb.user_data = mp4File;
file = mp4ff_open_read(&mp4cb);
if (file == NULL) return 0;
if (mp4_get_metadata(file, data, temp, sizeof(temp)))
{
int len = ConvertUTF8ToANSI(temp, temp2);
if (len > destlen-1) len = destlen-1;
memcpy(dest, temp2, len);
dest[len] = '\0';
}
mp4ff_close(file);
fclose(mp4File);
}
return 1;
}
static mp4ff_metadata_t mltags = {0, 0};
static BOOL medialib_init = FALSE;
static char medialib_lastfn[2048] = "";
__declspec(dllexport) int winampSetExtendedFileInfo(const char *fn, const char *data, char *val)
{
int len, ret = 0;
char *temp;
if (!medialib_init || (medialib_init && stricmp(fn, medialib_lastfn))) {
FILE *mp4File;
mp4ff_callback_t mp4cb = {0};
mp4ff_t *file;
strcpy(medialib_lastfn, fn);
if (medialib_init) tag_delete(&mltags);
mp4File = fopen(medialib_lastfn, "rb");
mp4cb.read = read_callback;
mp4cb.seek = seek_callback;
mp4cb.user_data = mp4File;
file = mp4ff_open_read(&mp4cb);
if (file == NULL) return 0;
ReadMP4Tag(file, &mltags);
mp4ff_close(file);
fclose(mp4File);
medialib_init = TRUE;
}
len = strlen(val);
temp = (char *)malloc((len+1)*4);
if (!temp) return 0;
if (ConvertANSIToUTF8(val, temp))
{
ret = 1;
tag_set_field(&mltags, data, temp, len);
}
free(temp);
return ret;
}
__declspec(dllexport) int winampWriteExtendedFileInfo()
{
if (medialib_init)
{
FILE *mp4File;
mp4ff_callback_t mp4cb = {0};
mp4File = fopen(medialib_lastfn, "rb+");
mp4cb.read = read_callback;
mp4cb.seek = seek_callback;
mp4cb.write = write_callback;
mp4cb.truncate = truncate_callback;
mp4cb.user_data = mp4File;
mp4ff_meta_update(&mp4cb, &mltags);
fclose(mp4File);
return 1;
}
else
{
return 0;
}
}