static gboolean
parse_options (int *argc, char *argv[])
{
GOptionContext *ctx;
gboolean success;
GError *error = NULL;
ctx = g_option_context_new (" - encoder test options");
if (!ctx)
return FALSE;
g_option_context_add_group (ctx, gst_init_get_option_group ());
g_option_context_add_main_entries (ctx, g_options, NULL);
g_option_context_set_help_enabled (ctx, TRUE);
success = g_option_context_parse (ctx, argc, &argv, &error);
if (!success) {
g_printerr ("Option parsing failed: %s\n", error->message);
g_error_free (error);
goto bail;
}
if (!g_codec_str)
g_codec_str = g_strdup ("h264");
if (!g_output_file_name)
g_output_file_name = generate_output_filename (g_codec_str);
bail:
g_option_context_free (ctx);
return success;
}
int main(int argc, char* argv[])
{
int rv = 0;
GError* err = NULL;
GOptionContext* octx = g_option_context_new("- MIME message generator");
g_option_context_add_main_entries(octx, opts, NULL);
if ( g_option_context_parse(octx, &argc, &argv, &err) ) {
gboolean go = FALSE;
if ( !src_fn ) {
g_log(G_LOG_DOMAIN, G_LOG_LEVEL_WARNING, "A source filename is required");
} else if ( !dst_fn && !display && !tmp ) {
g_log(G_LOG_DOMAIN, G_LOG_LEVEL_WARNING, "An output method must be selected");
} else {
go = TRUE;
}
if ( go ) {
gchar* ofn = generate_output_filename(dst_fn, display, tmp);
if ( verbose ) {
g_log(G_LOG_DOMAIN, G_LOG_LEVEL_INFO, "sfn=%s", src_fn);
g_log(G_LOG_DOMAIN, G_LOG_LEVEL_INFO, "ofn=%s", ofn ? ofn : "DISPLAY");
}
if ( !run(src_fn, ofn) ) {
g_log(G_LOG_DOMAIN, G_LOG_LEVEL_WARNING, "Failed to interpret the message spec");
rv = 1;
}
if ( ofn ) {
fprintf(stdout, "%s\n", ofn);
g_free(ofn);
}
} else {
rv = 1;
}
}
return rv;
}
int main(int argc, char **argv)
{
static m4af_io_callbacks_t m4af_io = {
read_callback, write_callback, seek_callback, tell_callback
};
aacenc_param_ex_t params = { 0 };
int result = 2;
char *output_filename = 0;
pcm_reader_t *reader = 0;
HANDLE_AACENCODER encoder = 0;
AACENC_InfoStruct aacinfo = { 0 };
m4af_ctx_t *m4af = 0;
const pcm_sample_description_t *sample_format;
int frame_count = 0;
int sbr_mode = 0;
unsigned scale_shift = 0;
setlocale(LC_CTYPE, "");
setbuf(stderr, 0);
if (parse_options(argc, argv, ¶ms) < 0)
return 1;
if ((reader = open_input(¶ms)) == 0)
goto END;
sample_format = pcm_get_format(reader);
sbr_mode = aacenc_is_sbr_active((aacenc_param_t*)¶ms);
if (sbr_mode && !aacenc_is_sbr_ratio_available()) {
fprintf(stderr, "WARNING: Only dual-rate SBR is available "
"for this version\n");
params.sbr_ratio = 2;
}
scale_shift = aacenc_is_dual_rate_sbr((aacenc_param_t*)¶ms);
params.sbr_signaling =
(params.transport_format == TT_MP4_LOAS) ? 2 :
(params.transport_format == TT_MP4_RAW) ? 1 : 0;
if (sbr_mode && !scale_shift)
params.sbr_signaling = 2;
if (aacenc_init(&encoder, (aacenc_param_t*)¶ms, sample_format,
&aacinfo) < 0)
goto END;
if (!params.output_filename) {
const char *ext = params.transport_format ? ".aac" : ".m4a";
output_filename = generate_output_filename(params.input_filename, ext);
params.output_filename = output_filename;
}
if ((params.output_fp = aacenc_fopen(params.output_filename, "wb+")) == 0) {
aacenc_fprintf(stderr, "ERROR: %s: %s\n", params.output_filename,
strerror(errno));
goto END;
}
handle_signals();
if (!params.transport_format) {
uint32_t scale;
unsigned framelen = aacinfo.frameLength;
scale = sample_format->sample_rate >> scale_shift;
if ((m4af = m4af_create(M4AF_CODEC_MP4A, scale, &m4af_io,
params.output_fp)) < 0)
goto END;
m4af_set_decoder_specific_info(m4af, 0,
aacinfo.confBuf, aacinfo.confSize);
m4af_set_fixed_frame_duration(m4af, 0,
framelen >> scale_shift);
m4af_set_vbr_mode(m4af, 0, params.bitrate_mode);
m4af_set_priming_mode(m4af, params.gapless_mode + 1);
m4af_begin_write(m4af);
}
int process_input_files(settings_t *settings)
{
int i = 0;
int ret = 1;
int file_type = 0;
char *current_file = (char *)0;
char tmpbuf[MAX_BUF_LEN] = {0};
char output_file[MAX_BUF_LEN] = {0};
char resampled_wav_file[MAX_BUF_LEN] = {0};
char input_file_full_path_name[MAX_BUF_LEN] = {0};
if (settings)
{
for(i = 0; i < settings->num_input_files; i++)
{
get_full_path_name(settings->input_files[i],
input_file_full_path_name,MAX_BUF_LEN);
current_file = input_file_full_path_name;
if (settings->verbose)
{
printf("Processing file: %s\n",current_file);
}
strncpy(tmpbuf,current_file,MAX_BUF_LEN);
strip_filename_extension(tmpbuf);
generate_output_filename(settings,tmpbuf,
output_file,MAX_BUF_LEN);
file_type = get_file_type(current_file);
switch(file_type)
{
case FILE_TYPE_OGG:
if (settings->oggdec_enabled &&
ogg_decode(settings,current_file,output_file,
oggdec_callback))
{
fprintf(stderr,"Failed to decode ogg file.\n");
return ret;
}
break;
case FILE_TYPE_MP3:
if (settings->mpgdec_enabled &&
mpg_decode(settings,current_file,output_file,
mpgdec_callback))
{
fprintf(stderr,"Failed to decode mp3 file.\n");
return ret;
}
break;
case FILE_TYPE_WAV:
if (resample_wav_file(settings,current_file,
output_file))
{
fprintf(stderr,"Failed to resample wav file.\n");
return ret;
}
break;
}
/* finally, verify the generated output file */
if (wav_verify_format(output_file))
{
/*
if we have sox enabled and we've just generated
this wav file, we should try to resample it here
to make it a valid format
*/
if ((file_type != FILE_TYPE_WAV) &&
(settings->sox_enabled))
{
strncpy(tmpbuf,current_file,MAX_BUF_LEN);
strip_filename_extension(tmpbuf);
strncat(tmpbuf,"-resampled",MAX_BUF_LEN-strlen(tmpbuf));
generate_output_filename(settings,tmpbuf,
resampled_wav_file,
MAX_BUF_LEN);
if (resample_wav_file(settings,output_file,
resampled_wav_file))
{
fprintf(stderr,"Failed to resample wav file.\n");
}
else
{
/* delete the original generated wav file */
delete_file(output_file);
strncpy(output_file,resampled_wav_file,MAX_BUF_LEN);
goto valid_input_wav;
}
}
fprintf(stderr,"Processed output file %s is "
"invalid! Skipping.\n",output_file);
continue;
}
else
{
valid_input_wav:
/*
if all went well up to this point, store the
output filename in the settings object
*/
if (settings_add_output_file(settings,output_file))
{
fprintf(stderr,"Failed to add valid output file "
"%s. Skipping.\n",output_file);
continue;
}
}
}
ret = (settings->num_output_files ? 0 : 1);
}
return ret;
}
int main(int argc, char **argv)
{
wav_io_context_t wav_io = { read_callback, seek_callback, tell_callback };
m4af_io_callbacks_t
m4af_io = { read_callback, write_callback, seek_callback, tell_callback };
aacenc_param_ex_t params = { 0 };
int result = 2;
FILE *ifp = 0;
FILE *ofp = 0;
char *output_filename = 0;
#ifdef USE_LIBSNDFILE
SNDFILE* snd = NULL;
SF_INFO snd_info;
pcm_sample_description_t snd_desc = { 0 };
#else
wav_reader_t *wavf = 0;
#endif
HANDLE_AACENCODER encoder = 0;
AACENC_InfoStruct aacinfo = { 0 };
m4af_ctx_t *m4af = 0;
const pcm_sample_description_t *sample_format;
int downsampled_timescale = 0;
int frame_count = 0;
struct stat stb = { 0 };
setlocale(LC_CTYPE, "");
setbuf(stderr, 0);
if (parse_options(argc, argv, ¶ms) < 0)
return 1;
#ifdef USE_LIBSNDFILE
if ((snd = sf_open (params.input_filename, SFM_READ, &snd_info)) == NULL) {
fprintf(stderr, "ERROR: broken / unsupported input file\n");
goto END;
}
#ifdef USE_LIBSAMPLERATE
if(params.resample) {
snd_desc.sample_rate = params.resample;
printf("resampling to %dhz\n", snd_desc.sample_rate);
} else {
snd_desc.sample_rate = snd_info.samplerate;
}
snd_desc.sample_type = PCM_TYPE_FLOAT; // always -- libsndfile does the conversion for us
snd_desc.bits_per_channel = sizeof(float)*8;
#else
snd_desc.sample_rate = snd_info.samplerate;
snd_desc.sample_type = PCM_TYPE_SINT; // always -- libsndfile does the conversion for us
snd_desc.bits_per_channel = sizeof(short)*8;
#endif
snd_desc.channels_per_frame = snd_info.channels;
snd_desc.bytes_per_frame = snd_info.channels * (snd_desc.bits_per_channel / 8);
snd_desc.channel_mask = 0;
sample_format = &snd_desc;
#else
if ((ifp = aacenc_fopen(params.input_filename, "rb")) == 0) {
aacenc_fprintf(stderr, "ERROR: %s: %s\n", params.input_filename,
strerror(errno));
goto END;
}
if (fstat(fileno(ifp), &stb) == 0 && (stb.st_mode & S_IFMT) != S_IFREG) {
wav_io.seek = 0;
wav_io.tell = 0;
}
if (!params.is_raw) {
if ((wavf = wav_open(&wav_io, ifp, params.ignore_length)) == 0) {
fprintf(stderr, "ERROR: broken / unsupported input file\n");
goto END;
}
} else {
int bytes_per_channel;
pcm_sample_description_t desc = { 0 };
if (parse_raw_spec(params.raw_format, &desc) < 0) {
fprintf(stderr, "ERROR: invalid raw-format spec\n");
goto END;
}
desc.sample_rate = params.raw_rate;
desc.channels_per_frame = params.raw_channels;
bytes_per_channel = (desc.bits_per_channel + 7) / 8;
desc.bytes_per_frame = params.raw_channels * bytes_per_channel;
if ((wavf = raw_open(&wav_io, ifp, &desc)) == 0) {
fprintf(stderr, "ERROR: failed to open raw input\n");
goto END;
}
}
sample_format = wav_get_format(wavf);
#endif
if (aacenc_init(&encoder, (aacenc_param_t*)¶ms, sample_format,
&aacinfo) < 0)
goto END;
if (!params.output_filename) {
const char *ext = params.transport_format ? ".aac" : ".m4a";
output_filename = generate_output_filename(params.input_filename, ext);
params.output_filename = output_filename;
}
if ((ofp = aacenc_fopen(params.output_filename, "wb+")) == 0) {
aacenc_fprintf(stderr, "ERROR: %s: %s\n", params.output_filename,
strerror(errno));
goto END;
}
handle_signals();
if (!params.transport_format) {
uint32_t scale;
unsigned framelen = aacinfo.frameLength;
int sbr_mode = aacenc_is_sbr_active((aacenc_param_t*)¶ms);
int sig_mode = aacEncoder_GetParam(encoder, AACENC_SIGNALING_MODE);
if (sbr_mode && !sig_mode)
downsampled_timescale = 1;
scale = sample_format->sample_rate >> downsampled_timescale;
if ((m4af = m4af_create(M4AF_CODEC_MP4A, scale, &m4af_io, ofp)) < 0)
goto END;
m4af_set_decoder_specific_info(m4af, 0, aacinfo.confBuf,
aacinfo.confSize);
m4af_set_fixed_frame_duration(m4af, 0,
framelen >> downsampled_timescale);
m4af_set_priming_mode(m4af, params.gapless_mode + 1);
m4af_begin_write(m4af);
}
