int main(int argc, char *argv[])
{
char *from, *to, *what;
const struct format *input_format, *output_format;
struct tag tag;
char output[OUTPUT_MAX_LEN + 1];
default_cust_id = DEFAULT_CUST_ID;
if (argc != 4 && argc != 5)
{
usage(argv[0]);
return (EXIT_FAILURE);
}
from = argv[1];
to = argv[2];
what = argv[3];
// optional cust_id argument
if (argc == 5)
{
if (!is_hexstr(argv[4]))
die("%s: cust_id is expected to be a hex byte\n", argv[0]);
default_cust_id = strtol(argv[4], NULL, 16);
if (default_cust_id < 0 || default_cust_id > 255)
die("%s: cust_id must be non-negative and less than 255\n", argv[0]);
}
if ((input_format = select_format(from)) == NULL)
die("%s: unknown input format: %s.\n", argv[0], from);
if ((output_format = select_format(to)) == NULL)
die("%s: unknown output format: %s.\n", argv[0], to);
if (input_format->from(what, &tag) != 0)
die("%s: error when parsing RFID of format %s.\n", argv[0], input_format->keyword);
if (output_format->to(&tag, output) != 0)
die("%s: error when converting RFID to format %s.\n", argv[0], output_format->keyword);
printf("%s\n", output);
return (EXIT_SUCCESS);
}
// open & setup audio device
static int init(struct ao *ao)
{
struct priv *ac = talloc_zero(ao, struct priv);
AVCodec *codec;
ao->priv = ac;
if (!encode_lavc_available(ao->encode_lavc_ctx)) {
MP_ERR(ao, "the option --o (output file) must be specified\n");
return -1;
}
pthread_mutex_lock(&ao->encode_lavc_ctx->lock);
if (encode_lavc_alloc_stream(ao->encode_lavc_ctx,
AVMEDIA_TYPE_AUDIO,
&ac->stream, &ac->codec) < 0) {
MP_ERR(ao, "could not get a new audio stream\n");
goto fail;
}
codec = ao->encode_lavc_ctx->ac;
int samplerate = af_select_best_samplerate(ao->samplerate,
codec->supported_samplerates);
if (samplerate > 0)
ao->samplerate = samplerate;
// TODO: Remove this redundancy with encode_lavc_alloc_stream also
// setting the time base.
// Using codec->time_bvase is deprecated, but needed for older lavf.
ac->stream->time_base.num = 1;
ac->stream->time_base.den = ao->samplerate;
ac->codec->time_base.num = 1;
ac->codec->time_base.den = ao->samplerate;
ac->codec->sample_rate = ao->samplerate;
struct mp_chmap_sel sel = {0};
mp_chmap_sel_add_any(&sel);
if (!ao_chmap_sel_adjust2(ao, &sel, &ao->channels, false))
goto fail;
mp_chmap_reorder_to_lavc(&ao->channels);
ac->codec->channels = ao->channels.num;
ac->codec->channel_layout = mp_chmap_to_lavc(&ao->channels);
ac->codec->sample_fmt = AV_SAMPLE_FMT_NONE;
select_format(ao, codec);
ac->sample_size = af_fmt_to_bytes(ao->format);
ac->codec->sample_fmt = af_to_avformat(ao->format);
ac->codec->bits_per_raw_sample = ac->sample_size * 8;
if (encode_lavc_open_codec(ao->encode_lavc_ctx, ac->codec) < 0)
goto fail;
ac->pcmhack = 0;
if (ac->codec->frame_size <= 1)
ac->pcmhack = av_get_bits_per_sample(ac->codec->codec_id) / 8;
if (ac->pcmhack)
ac->aframesize = 16384; // "enough"
else
ac->aframesize = ac->codec->frame_size;
// enough frames for at least 0.25 seconds
ac->framecount = ceil(ao->samplerate * 0.25 / ac->aframesize);
// but at least one!
ac->framecount = FFMAX(ac->framecount, 1);
ac->savepts = AV_NOPTS_VALUE;
ac->lastpts = AV_NOPTS_VALUE;
ao->untimed = true;
if (ao->channels.num > AV_NUM_DATA_POINTERS)
goto fail;
pthread_mutex_unlock(&ao->encode_lavc_ctx->lock);
return 0;
fail:
pthread_mutex_unlock(&ao->encode_lavc_ctx->lock);
ac->shutdown = true;
return -1;
}
// open & setup audio device
static int init(struct ao *ao)
{
struct priv *ac = talloc_zero(ao, struct priv);
AVCodec *codec;
ao->priv = ac;
if (!encode_lavc_available(ao->encode_lavc_ctx)) {
MP_ERR(ao, "the option --o (output file) must be specified\n");
return -1;
}
pthread_mutex_lock(&ao->encode_lavc_ctx->lock);
ac->stream = encode_lavc_alloc_stream(ao->encode_lavc_ctx,
AVMEDIA_TYPE_AUDIO);
if (!ac->stream) {
MP_ERR(ao, "could not get a new audio stream\n");
goto fail;
}
codec = encode_lavc_get_codec(ao->encode_lavc_ctx, ac->stream);
// ac->stream->time_base.num = 1;
// ac->stream->time_base.den = ao->samplerate;
// doing this breaks mpeg2ts in ffmpeg
// which doesn't properly force the time base to be 90000
// furthermore, ffmpeg.c doesn't do this either and works
ac->stream->codec->time_base.num = 1;
ac->stream->codec->time_base.den = ao->samplerate;
ac->stream->codec->sample_rate = ao->samplerate;
struct mp_chmap_sel sel = {0};
mp_chmap_sel_add_any(&sel);
if (!ao_chmap_sel_adjust(ao, &sel, &ao->channels))
goto fail;
mp_chmap_reorder_to_lavc(&ao->channels);
ac->stream->codec->channels = ao->channels.num;
ac->stream->codec->channel_layout = mp_chmap_to_lavc(&ao->channels);
ac->stream->codec->sample_fmt = AV_SAMPLE_FMT_NONE;
select_format(ao, codec);
ac->sample_size = af_fmt2bits(ao->format) / 8;
ac->stream->codec->sample_fmt = af_to_avformat(ao->format);
ac->stream->codec->bits_per_raw_sample = ac->sample_size * 8;
if (encode_lavc_open_codec(ao->encode_lavc_ctx, ac->stream) < 0)
goto fail;
ac->pcmhack = 0;
if (ac->stream->codec->frame_size <= 1)
ac->pcmhack = av_get_bits_per_sample(ac->stream->codec->codec_id) / 8;
if (ac->pcmhack) {
ac->aframesize = 16384; // "enough"
ac->buffer_size =
ac->aframesize * ac->pcmhack * ao->channels.num * 2 + 200;
} else {
ac->aframesize = ac->stream->codec->frame_size;
ac->buffer_size =
ac->aframesize * ac->sample_size * ao->channels.num * 2 + 200;
}
if (ac->buffer_size < FF_MIN_BUFFER_SIZE)
ac->buffer_size = FF_MIN_BUFFER_SIZE;
ac->buffer = talloc_size(ac, ac->buffer_size);
// enough frames for at least 0.25 seconds
ac->framecount = ceil(ao->samplerate * 0.25 / ac->aframesize);
// but at least one!
ac->framecount = FFMAX(ac->framecount, 1);
ac->savepts = MP_NOPTS_VALUE;
ac->lastpts = MP_NOPTS_VALUE;
ao->untimed = true;
pthread_mutex_unlock(&ao->encode_lavc_ctx->lock);
return 0;
fail:
pthread_mutex_unlock(&ao->encode_lavc_ctx->lock);
return -1;
}
void play (char *source_string)
{
transport_t *transport;
format_t *format;
data_source_t *source;
decoder_t *decoder;
decoder_callbacks_t decoder_callbacks;
void *decoder_callbacks_arg;
/* Preserve between calls so we only open the audio device when we
have to */
static audio_format_t old_audio_fmt = { 0, 0, 0, 0, 0 };
audio_format_t new_audio_fmt;
audio_reopen_arg_t *reopen_arg;
/* Flags and counters galore */
int eof = 0, eos = 0, ret;
int nthc = 0, ntimesc = 0;
int next_status = 0;
static int status_interval = 0;
/* Reset all of the signal flags */
sig_request.cancel = 0;
sig_request.skipfile = 0;
sig_request.exit = 0;
sig_request.pause = 0;
/* Set preferred audio format (used by decoder) */
new_audio_fmt.big_endian = ao_is_big_endian();
new_audio_fmt.signed_sample = 1;
new_audio_fmt.word_size = 2;
/* Select appropriate callbacks */
if (audio_buffer != NULL) {
decoder_callbacks.printf_error = &decoder_buffered_error_callback;
decoder_callbacks.printf_metadata = &decoder_buffered_metadata_callback;
decoder_callbacks_arg = audio_buffer;
} else {
decoder_callbacks.printf_error = &decoder_error_callback;
decoder_callbacks.printf_metadata = &decoder_metadata_callback;
decoder_callbacks_arg = NULL;
}
/* Locate and use transport for this data source */
if ( (transport = select_transport(source_string)) == NULL ) {
status_error(_("No module could be found to read from %s.\n"), source_string);
return;
}
if ( (source = transport->open(source_string, &options)) == NULL ) {
status_error(_("Cannot open %s.\n"), source_string);
return;
}
/* Detect the file format and initialize a decoder */
if ( (format = select_format(source)) == NULL ) {
status_error(_("The file format of %s is not supported.\n"), source_string);
return;
}
if ( (decoder = format->init(source, &options, &new_audio_fmt,
&decoder_callbacks,
decoder_callbacks_arg)) == NULL ) {
/* We may have failed because of user command */
if (!sig_request.cancel)
status_error(_("Error opening %s using the %s module."
" The file may be corrupted.\n"), source_string,
format->name);
return;
}
/* Decide which statistics are valid */
select_stats(stat_format, &options, source, decoder, audio_buffer);
/* Start the audio playback thread before we begin sending data */
if (audio_buffer != NULL) {
/* First reset mutexes and other synchronization variables */
buffer_reset (audio_buffer);
buffer_thread_start (audio_buffer);
}
/* Show which file we are playing */
decoder_callbacks.printf_metadata(decoder_callbacks_arg, 1,
_("Playing: %s"), source_string);
/* Skip over audio */
if (options.seekpos > 0.0) {
if (!format->seek(decoder, options.seekpos, DECODER_SEEK_START)) {
status_error(_("Could not skip %f seconds of audio."), options.seekpos);
if (audio_buffer != NULL)
buffer_thread_kill(audio_buffer);
return;
}
}
/* Main loop: Iterates over all of the logical bitstreams in the file */
while (!eof && !sig_request.exit) {
/* Loop through data within a logical bitstream */
eos = 0;
while (!eos && !sig_request.exit) {
/* Check signals */
if (sig_request.skipfile) {
eof = eos = 1;
break;
}
if (sig_request.pause) {
if (audio_buffer)
buffer_thread_pause (audio_buffer);
kill (getpid(), SIGSTOP); /* We block here until we unpause */
/* Done pausing */
if (audio_buffer)
buffer_thread_unpause (audio_buffer);
sig_request.pause = 0;
}
/* Read another block of audio data */
ret = format->read(decoder, convbuffer, convsize, &eos, &new_audio_fmt);
/* Bail if we need to */
if (ret == 0) {
eof = eos = 1;
break;
} else if (ret < 0) {
status_error(_("Error: Decoding failure.\n"));
break;
}
/* Check to see if the audio format has changed */
if (!audio_format_equal(&new_audio_fmt, &old_audio_fmt)) {
old_audio_fmt = new_audio_fmt;
/* Update our status printing interval */
status_interval = new_audio_fmt.word_size * new_audio_fmt.channels *
new_audio_fmt.rate / options.status_freq;
next_status = 0;
reopen_arg = new_audio_reopen_arg(options.devices, &new_audio_fmt);
if (audio_buffer)
buffer_insert_action_at_end(audio_buffer, &audio_reopen_action,
reopen_arg);
else
audio_reopen_action(NULL, reopen_arg);
}
/* Update statistics display if needed */
if (next_status <= 0) {
display_statistics(stat_format, audio_buffer, source, decoder);
next_status = status_interval;
} else
next_status -= ret;
if (options.endpos > 0.0 && options.endpos <= current_time(decoder)) {
eof = eos = 1;
break;
}
/* Write audio data block to output, skipping or repeating chunks
as needed */
do {
if (nthc-- == 0) {
if (audio_buffer)
buffer_submit_data(audio_buffer, convbuffer, ret);
else
audio_play_callback(convbuffer, ret, eos, &audio_play_arg);
nthc = options.nth - 1;
}
} while (!sig_request.exit && !sig_request.skipfile &&
++ntimesc < options.ntimes);
ntimesc = 0;
} /* End of data loop */
} /* End of logical bitstream loop */
/* Done playing this logical bitstream. Clean up house. */
if (audio_buffer) {
if (!sig_request.exit && !sig_request.skipfile) {
buffer_mark_eos(audio_buffer);
buffer_wait_for_empty(audio_buffer);
}
buffer_thread_kill(audio_buffer);
}
/* Print final stats */
display_statistics_quick(stat_format, audio_buffer, source, decoder);
format->cleanup(decoder);
transport->close(source);
status_reset_output_lock(); /* In case we were killed mid-output */
status_message(1, _("Done."));
if (sig_request.exit)
exit (0);
}
int
ossrecord_parse_opts (int argc, char ** argv, dspdev_t * dsp)
{
char * p;
int c;
extern char * optarg;
extern int optind;
if (argc < 2)
ossrecord_usage (argv[0]);
while ((c = getopt (argc, argv, "F:L:MORSb:c:d:f:g:hi:lm:r:s:t:wv")) != EOF)
switch (c)
{
case 'F':
type = select_container (optarg);
break;
case 'L':
dsp->reclevel = atoi (optarg);
if (dsp->reclevel < 1 || dsp->reclevel > 100)
{
print_msg (ERRORM, "%s: Bad recording level '%s'\n",
argv[0]?argv[0]:"", optarg);
exit (-1);
}
break;
case 'M':
force_channels = 1;
break;
case 'R':
raw_mode = 1;
break;
case 'S':
force_channels = 2;
break;
case 'b':
c = atoi (optarg);
c += c % 8; /* Simple WAV format always pads to a multiple of 8 */
switch (c)
{
case 8: force_fmt = AFMT_U8; break;
case 16: force_fmt = AFMT_S16_LE; break;
case 24: force_fmt = AFMT_S24_PACKED; break;
case 32: force_fmt = AFMT_S32_LE; break;
default:
print_msg (ERRORM, "Error: Unsupported number of bits %d\n", c);
exit (E_FORMAT_UNSUPPORTED);
}
break;
case 'c':
sscanf (optarg, "%d", &force_channels);
break;
case 'd':
if (*optarg >= '0' && *optarg <= '9') /* Only device number given */
find_devname (dsp->dname, optarg);
else
snprintf (dsp->dname, OSS_DEVNODE_SIZE, "%s", optarg);
break;
case 'f':
force_fmt = select_format (optarg, CR);
break;
case 'g':
sscanf (optarg, "%u", &lification);
if (amplification == 0) ossrecord_usage (argv[0]);
case 'l':
level_meters = 1;
verbose = 1;
break;
case 'i':
if (!strcmp(optarg, "?"))
{
dsp->recsrc = optarg;
dsp->flags = O_RDONLY;
open_device (dsp);
select_recsrc (dsp);
}
dsp->recsrc = optarg;
break;
case 'm':
sscanf (optarg, "%u", &nfiles);
break;
case 's':
sscanf (optarg, "%d", &force_speed);
if (force_speed == 0)
{
print_msg (ERRORM, "Bad sampling rate given\n");
exit (E_USAGE);
}
if (force_speed < 1000) force_speed *= 1000;
break;
case 'r':
c = snprintf (script, sizeof (script), "%s", optarg);
if (((size_t)c >= sizeof (script)) || (c < 0))
{
print_msg (ERRORM, "-r argument is too long!\n");
exit (E_USAGE);
}
break;
case 't':
errno = 0;
datalimit = strtod (optarg, &p);
if ((*p != '\0') || (errno) || (datalimit <= 0)) ossrecord_usage (argv[0]);
break;
case 'O':
overwrite = 0;
break;
case 'w':
break;
case 'v':
verbose = 1;
break;
case 'h':
default:
ossrecord_usage (argv[0]);
}
if (argc != optind + 1)
/* No file or multiple file names given */
ossrecord_usage (argv[0]);
if (force_fmt == 0) force_fmt = container_a[type].dformat;
if (force_channels == 0) force_channels = container_a[type].dchannels;
if (force_speed == 0) force_speed = container_a[type].dspeed;
switch (force_fmt)
{
case AFMT_S8:
case AFMT_U8:
case AFMT_S16_NE:
case AFMT_S24_NE:
case AFMT_S32_NE: break;
default: level_meters = 0; /* Not implemented */
}
if ((signal (SIGSEGV, ossplay_getint) == SIG_ERR) ||
#ifdef SIGPIPE
(signal (SIGPIPE, ossplay_getint) == SIG_ERR) ||
#endif
(signal (SIGTERM, ossplay_getint) == SIG_ERR) ||
#ifdef SIGQUIT
(signal (SIGQUIT, ossplay_getint) == SIG_ERR) ||
#endif
(signal (SIGINT, ossplay_getint) == SIG_ERR))
print_msg (WARNM, "Signal handler not set up!\n");
if (verbose)
{
oss_audioinfo ai;
ai.dev = -1;
if (ioctl(dsp->fd, SNDCTL_ENGINEINFO, &ai) != -1)
print_msg (VERBOSEM, "Recording from %s\n", ai.name);
}
return optind;
}
int
ossplay_parse_opts (int argc, char ** argv, dspdev_t * dsp)
{
extern char * optarg;
extern int optind;
char * p;
int c;
while ((c = getopt (argc, argv, "FRS:Wc:d:f:g:hlo:qs:v")) != EOF)
{
switch (c)
{
case 'v':
verbose++;
quiet = 0;
int_conv = 2;
break;
case 'R':
raw_mode = 1;
break;
case 'q':
quiet++;
verbose = 0;
if (int_conv == 2) int_conv = 0;
break;
case 'd':
if (*optarg >= '0' && *optarg <= '9') /* Only device number given */
find_devname (dsp->dname, optarg);
else
snprintf (dsp->dname, OSS_DEVNODE_SIZE, "%s", optarg);
break;
case 'o':
if (!strcmp(optarg, "?"))
{
dsp->playtgt = optarg;
dsp->flags = O_WRONLY;
open_device (dsp);
select_playtgt (dsp);
}
dsp->playtgt = optarg;
break;
case 'f':
force_fmt = select_format (optarg, CP);
break;
case 's':
sscanf (optarg, "%d", &force_speed);
break;
case 'c':
sscanf (optarg, "%d", &force_channels);
break;
case 'g':
sscanf (optarg, "%u", &lification);
int_conv = 1;
break;
case 'l':
loop = 1;
break;
case 'F':
case 'W':
raw_file = 1;
break;
case 'S':
c = strlen (optarg);
if ((c > 0) && ((optarg[c - 1] == 'b') || (optarg[c - 1] == 'B')))
{
errno = 0;
seek_byte = strtol (optarg, &p, 10);
if ((*p != '\0') || (seek_byte < 0)) ossplay_usage (argv[0]);
}
else
{
errno = 0;
seek_time = strtod (optarg, &p);
if ((*p != '\0') || (errno) || (seek_time < 0)) ossplay_usage (argv[0]);
}
break;
default:
ossplay_usage (argv[0]);
}
}
if (argc < optind + 1)
ossplay_usage (argv[0]);
#ifdef SIGQUIT
signal (SIGQUIT, ossplay_getint);
#endif
return optind;
}
