int main(int argc, char *argv[])
{
int width, height;
width = height = 0;
/* read image file */
if (argc >= 2)
decode_init(argv[1], &width, &height);
/* openGL */
init_gl(argc, argv);
createGLBufTex(width, height, GL_BUFFER_SORC);
createGLBufTex(width/2, height, GL_BUFFER_DEST);
/* openCL */
init_cl();
clloadProgram("./algorithm.cl");
createCLBufferFromGL();
setImageWidth(width);
setKernelRange(width/2, height);
transferParam();
glutMainLoop();
exit:
decode_close();
exit_cl();
exit_gl();
err:
return 0;
}
static av_cold int decode_init(AVCodecContext *avctx)
{
ATRAC3PContext *ctx = avctx->priv_data;
int i, ch, ret;
ff_atrac3p_init_vlcs();
avpriv_float_dsp_init(&ctx->fdsp, avctx->flags & CODEC_FLAG_BITEXACT);
/* initialize IPQF */
ff_mdct_init(&ctx->ipqf_dct_ctx, 5, 1, 32.0 / 32768.0);
ff_atrac3p_init_imdct(avctx, &ctx->mdct_ctx);
ff_atrac_init_gain_compensation(&ctx->gainc_ctx, 6, 2);
ff_atrac3p_init_wave_synth();
if ((ret = set_channel_params(ctx, avctx)) < 0)
return ret;
ctx->my_channel_layout = avctx->channel_layout;
ctx->ch_units = av_mallocz(sizeof(*ctx->ch_units) *
ctx->num_channel_blocks);
if (!ctx->ch_units) {
decode_close(avctx);
return AVERROR(ENOMEM);
}
for (i = 0; i < ctx->num_channel_blocks; i++) {
for (ch = 0; ch < 2; ch++) {
ctx->ch_units[i].channels[ch].ch_num = ch;
ctx->ch_units[i].channels[ch].wnd_shape = &ctx->ch_units[i].channels[ch].wnd_shape_hist[0][0];
ctx->ch_units[i].channels[ch].wnd_shape_prev = &ctx->ch_units[i].channels[ch].wnd_shape_hist[1][0];
ctx->ch_units[i].channels[ch].gain_data = &ctx->ch_units[i].channels[ch].gain_data_hist[0][0];
ctx->ch_units[i].channels[ch].gain_data_prev = &ctx->ch_units[i].channels[ch].gain_data_hist[1][0];
ctx->ch_units[i].channels[ch].tones_info = &ctx->ch_units[i].channels[ch].tones_info_hist[0][0];
ctx->ch_units[i].channels[ch].tones_info_prev = &ctx->ch_units[i].channels[ch].tones_info_hist[1][0];
/* clear IMDCT overlapping buffer */
memset(&ctx->ch_units[i].prev_buf[ch][0], 0,
sizeof(ctx->ch_units[i].prev_buf[ch][0]) *
ATRAC3P_FRAME_SAMPLES);
/* clear IPQF history */
memset(&ctx->ch_units[i].ipqf_ctx[ch], 0,
sizeof(ctx->ch_units[i].ipqf_ctx[ch]));
}
ctx->ch_units[i].waves_info = &ctx->ch_units[i].wave_synth_hist[0];
ctx->ch_units[i].waves_info_prev = &ctx->ch_units[i].wave_synth_hist[1];
}
avctx->sample_fmt = AV_SAMPLE_FMT_FLTP;
return 0;
}
int main(int argc, char *argv[])
{
int ret;
const char *url;
struct sound_file_info *file;
struct decode *dec;
struct fifo *fifo;
pthread_t tid;
struct load_thread_arg arg;
u8 *lrc;
u8 *icon;
size_t lrc_size;
size_t icon_size;
u8 mp3_buff[MP3_BUFF_SIZE];
u8 raw_buff[RAW_BUFF_SIZE];
int mp3_size, raw_size;
struct mp3_param mp3_pm;
struct audio_output *out;
struct window_info *win_info;
if (argc < 2) {
fprintf(stderr, "Usage: %s PATH\n", argv[0]);
return -EINVAL;
}
url = argv[1];
file = sound_file_open(url);
if (NULL == file) {
fprintf(stderr, "Fail to open sound file \"%s\"!\n", url);
return -ENODEV;
}
fifo = fifo_open();
if (NULL == fifo) {
goto L1;
ret = -ENOMEM;
}
ret = parse_mp3_tag(file, &lrc, &lrc_size, &icon, &icon_size);
if (ret < 0) {
DPRINT("\n");
goto L2;
}
DPRINT("mp3_start = %lu, mp3_end = %lu, "
"lrc = %p, lrc_size = %lu, icon = %p, icon_size = %lu\n",
file->mp3_data_start, file->mp3_data_end,
lrc, lrc_size, icon, icon_size);
arg.fifo = fifo;
arg.file = file;
ret = pthread_create(&tid, NULL, load_mp3_data_to_fifo, &arg);
if (ret < 0) {
DPRINT("\n");
goto L2;
}
dec = decode_open(MPAUDEC); // fixme!
if (NULL == dec) {
ret = -ENODEV;
goto L2;
}
while (fifo->used < fifo->size / 3) usleep(1000);
mp3_size = fifo_read(fifo, mp3_buff, sizeof(mp3_buff));
get_mp3_param(dec, mp3_buff, mp3_size, &mp3_pm);
win_info = window_init();
win_info->icon = icon;
win_info->icon_size = icon_size;
win_info->lrc = lrc;
win_info->lrc_size = lrc_size;
win_info->total.tv_sec = (file->mp3_data_end - file->mp3_data_start) * 8 / mp3_pm.bit_rate;
win_info->total.tv_usec = (file->mp3_data_end - file->mp3_data_start) * 8 * 1000000 / mp3_pm.bit_rate % 1000000;
win_info->param = &mp3_pm;
DPRINT("rate = %d, channels = %d, bps = %d, bitrate = %d\n",
mp3_pm.rate, mp3_pm.channels, mp3_pm.bits_per_sample, mp3_pm.bit_rate);
out = open_audio(AUDIO_ALSA, &mp3_pm);
if (NULL == out) {
ret = -ENODEV;
goto L3;
}
while (1) {
if (file->mp3_data_end == file->offset && mp3_size == 0)
break;
if (mp3_size > 0) {
ret = decode(dec, raw_buff, &raw_size, mp3_buff, mp3_size);
mp3_size -= ret;
memmove(mp3_buff, mp3_buff + ret, mp3_size);
}
play_frames(out, raw_buff, raw_size, &mp3_pm);
ret = fifo_read(fifo, mp3_buff + mp3_size, sizeof(mp3_buff) - mp3_size);
mp3_size += ret;
}
close_audio(out);
window_destroy();
L3:
decode_close(dec);
L2:
fifo_close(fifo);
L1:
sound_file_close(file);
return ret;
}
static av_cold int decode_init(AVCodecContext *avctx)
{
RALFContext *ctx = avctx->priv_data;
int i, j, k;
int ret;
if (avctx->extradata_size < 24 || memcmp(avctx->extradata, "LSD:", 4)) {
av_log(avctx, AV_LOG_ERROR, "Extradata is not groovy, dude\n");
return AVERROR_INVALIDDATA;
}
ctx->version = AV_RB16(avctx->extradata + 4);
if (ctx->version != 0x103) {
av_log_ask_for_sample(avctx, "unknown version %X\n", ctx->version);
return AVERROR_PATCHWELCOME;
}
avctx->channels = AV_RB16(avctx->extradata + 8);
avctx->sample_rate = AV_RB32(avctx->extradata + 12);
if (avctx->channels < 1 || avctx->channels > 2
|| avctx->sample_rate < 8000 || avctx->sample_rate > 96000) {
av_log(avctx, AV_LOG_ERROR, "Invalid coding parameters %d Hz %d ch\n",
avctx->sample_rate, avctx->channels);
return AVERROR_INVALIDDATA;
}
avctx->sample_fmt = AV_SAMPLE_FMT_S16;
avctx->channel_layout = (avctx->channels == 2) ? AV_CH_LAYOUT_STEREO
: AV_CH_LAYOUT_MONO;
avcodec_get_frame_defaults(&ctx->frame);
avctx->coded_frame = &ctx->frame;
ctx->max_frame_size = AV_RB32(avctx->extradata + 16);
if (ctx->max_frame_size > (1 << 20) || !ctx->max_frame_size) {
av_log(avctx, AV_LOG_ERROR, "invalid frame size %d\n",
ctx->max_frame_size);
}
ctx->max_frame_size = FFMAX(ctx->max_frame_size, avctx->sample_rate);
for (i = 0; i < 3; i++) {
ret = init_ralf_vlc(&ctx->sets[i].filter_params, filter_param_def[i],
FILTERPARAM_ELEMENTS);
if (ret < 0) {
decode_close(avctx);
return ret;
}
ret = init_ralf_vlc(&ctx->sets[i].bias, bias_def[i], BIAS_ELEMENTS);
if (ret < 0) {
decode_close(avctx);
return ret;
}
ret = init_ralf_vlc(&ctx->sets[i].coding_mode, coding_mode_def[i],
CODING_MODE_ELEMENTS);
if (ret < 0) {
decode_close(avctx);
return ret;
}
for (j = 0; j < 10; j++) {
for (k = 0; k < 11; k++) {
ret = init_ralf_vlc(&ctx->sets[i].filter_coeffs[j][k],
filter_coeffs_def[i][j][k],
FILTER_COEFFS_ELEMENTS);
if (ret < 0) {
decode_close(avctx);
return ret;
}
}
}
for (j = 0; j < 15; j++) {
ret = init_ralf_vlc(&ctx->sets[i].short_codes[j],
short_codes_def[i][j], SHORT_CODES_ELEMENTS);
if (ret < 0) {
decode_close(avctx);
return ret;
}
}
for (j = 0; j < 125; j++) {
ret = init_ralf_vlc(&ctx->sets[i].long_codes[j],
long_codes_def[i][j], LONG_CODES_ELEMENTS);
if (ret < 0) {
decode_close(avctx);
return ret;
}
}
}
return 0;
}