static av_cold int init_audio(AVFilterContext *ctx)
{
BufferSourceContext *s = ctx->priv;
int ret = 0;
s->sample_fmt = av_get_sample_fmt(s->sample_fmt_str);
if (s->sample_fmt == AV_SAMPLE_FMT_NONE) {
av_log(ctx, AV_LOG_ERROR, "Invalid sample format %s.\n",
s->sample_fmt_str);
return AVERROR(EINVAL);
}
s->channel_layout = av_get_channel_layout(s->channel_layout_str);
if (!s->channel_layout) {
av_log(ctx, AV_LOG_ERROR, "Invalid channel layout %s.\n",
s->channel_layout_str);
return AVERROR(EINVAL);
}
if (!(s->fifo = av_fifo_alloc(sizeof(AVFrame*))))
return AVERROR(ENOMEM);
if (!s->time_base.num)
s->time_base = (AVRational){1, s->sample_rate};
av_log(ctx, AV_LOG_VERBOSE, "tb:%d/%d samplefmt:%s samplerate: %d "
"ch layout:%s\n", s->time_base.num, s->time_base.den, s->sample_fmt_str,
s->sample_rate, s->channel_layout_str);
return ret;
}
static av_cold int init(AVFilterContext *ctx)
{
ChannelSplitContext *s = ctx->priv;
int nb_channels;
int ret = 0, i;
if (!(s->channel_layout = av_get_channel_layout(s->channel_layout_str))) {
av_log(ctx, AV_LOG_ERROR, "Error parsing channel layout '%s'.\n",
s->channel_layout_str);
ret = AVERROR(EINVAL);
goto fail;
}
nb_channels = av_get_channel_layout_nb_channels(s->channel_layout);
for (i = 0; i < nb_channels; i++) {
uint64_t channel = av_channel_layout_extract_channel(s->channel_layout, i);
AVFilterPad pad = { 0 };
pad.type = AVMEDIA_TYPE_AUDIO;
pad.name = av_get_channel_name(channel);
ff_insert_outpad(ctx, i, &pad);
}
fail:
return ret;
}
int ff_parse_channel_layout(int64_t *ret, int *nret, const char *arg,
void *log_ctx)
{
#if 0
char *tail;
int64_t chlayout, count;
if (nret) {
count = strtol(arg, &tail, 10);
if (*tail == 'c' && !tail[1] && count > 0 && count < 63) {
*nret = count;
*ret = 0;
return 0;
}
}
chlayout = av_get_channel_layout(arg);
if (chlayout == 0) {
chlayout = strtol(arg, &tail, 10);
if (*tail || chlayout == 0) {
av_log(log_ctx, AV_LOG_ERROR, "Invalid channel layout '%s'\n", arg);
return AVERROR(EINVAL);
}
}
*ret = chlayout;
if (nret)
*nret = av_get_channel_layout_nb_channels(chlayout);
#endif
return 0;
}
static int init(AVFilterContext *ctx, const char *args, void *opaque)
{
ANullContext *priv = ctx->priv;
char channel_layout_str[128] = "";
priv->sample_rate = 44100;
priv->channel_layout = AV_CH_LAYOUT_STEREO;
if (args)
sscanf(args, "%"PRId64":%s", &priv->sample_rate, channel_layout_str);
if (priv->sample_rate < 0)
{
av_log(ctx, AV_LOG_ERROR, "Invalid negative sample rate: %"PRId64"\n", priv->sample_rate);
return AVERROR(EINVAL);
}
if (*channel_layout_str)
if (!(priv->channel_layout = av_get_channel_layout(channel_layout_str))
&& sscanf(channel_layout_str, "%"PRId64, &priv->channel_layout) != 1)
{
av_log(ctx, AV_LOG_ERROR, "Invalid value '%s' for channel layout\n",
channel_layout_str);
return AVERROR(EINVAL);
}
return 0;
}
static av_cold int init_audio(AVFilterContext *ctx)
{
BufferSourceContext *s = ctx->priv;
int ret = 0;
if (!(s->sample_fmt != AV_SAMPLE_FMT_NONE || s->got_format_from_params)) {
av_log(ctx, AV_LOG_ERROR, "Sample format was not set or was invalid\n");
return AVERROR(EINVAL);
}
if (s->channel_layout_str || s->channel_layout) {
int n;
if (!s->channel_layout) {
s->channel_layout = av_get_channel_layout(s->channel_layout_str);
if (!s->channel_layout) {
av_log(ctx, AV_LOG_ERROR, "Invalid channel layout %s.\n",
s->channel_layout_str);
return AVERROR(EINVAL);
}
}
n = av_get_channel_layout_nb_channels(s->channel_layout);
if (s->channels) {
if (n != s->channels) {
av_log(ctx, AV_LOG_ERROR,
"Mismatching channel count %d and layout '%s' "
"(%d channels)\n",
s->channels, s->channel_layout_str, n);
return AVERROR(EINVAL);
}
}
s->channels = n;
} else if (!s->channels) {
av_log(ctx, AV_LOG_ERROR, "Neither number of channels nor "
"channel layout specified\n");
return AVERROR(EINVAL);
}
if (!(s->fifo = av_fifo_alloc(sizeof(AVFrame*))))
return AVERROR(ENOMEM);
if (!s->time_base.num)
s->time_base = (AVRational){1, s->sample_rate};
av_log(ctx, AV_LOG_VERBOSE,
"tb:%d/%d samplefmt:%s samplerate:%d chlayout:%s\n",
s->time_base.num, s->time_base.den, av_get_sample_fmt_name(s->sample_fmt),
s->sample_rate, s->channel_layout_str);
s->warning_limit = 100;
return ret;
}
AVSValue __cdecl CreateLSMASHAudioSource( AVSValue args, void *user_data, IScriptEnvironment *env )
{
#ifdef NDEBUG
av_log_set_level( AV_LOG_QUIET );
#endif
const char *source = args[0].AsString();
uint32_t track_number = args[1].AsInt( 0 );
bool skip_priming = args[2].AsBool( true );
const char *layout_string = args[3].AsString( NULL );
int sample_rate = args[4].AsInt( 0 );
uint64_t channel_layout = layout_string ? av_get_channel_layout( layout_string ) : 0;
return new LSMASHAudioSource( source, track_number, skip_priming, channel_layout, sample_rate, env );
}
int ff_parse_channel_layout(int64_t *ret, const char *arg, void *log_ctx)
{
char *tail;
int64_t chlayout = av_get_channel_layout(arg);
if (chlayout == 0) {
chlayout = strtol(arg, &tail, 10);
if (*tail || chlayout == 0) {
av_log(log_ctx, AV_LOG_ERROR, "Invalid channel layout '%s'\n", arg);
return AVERROR(EINVAL);
}
}
*ret = chlayout;
return 0;
}
static int parse_channel_name(char **arg, int *rchannel, int *rnamed)
{
char buf[8];
int len, i, channel_id = 0;
int64_t layout, layout0;
skip_spaces(arg);
/* try to parse a channel name, e.g. "FL" */
if (sscanf(*arg, "%7[A-Z]%n", buf, &len)) {
layout0 = layout = av_get_channel_layout(buf);
/* channel_id <- first set bit in layout */
for (i = 32; i > 0; i >>= 1) {
if (layout >= (int64_t)1 << i) {
channel_id += i;
layout >>= i;
}
}
int ff_parse_channel_layout(int64_t *ret, int *nret, const char *arg,
void *log_ctx)
{
char *tail;
int64_t chlayout;
chlayout = av_get_channel_layout(arg);
if (chlayout == 0) {
chlayout = strtol(arg, &tail, 10);
if (!(*tail == '\0' || *tail == 'c' && *(tail + 1) == '\0') || chlayout <= 0 || chlayout > 63) {
av_log(log_ctx, AV_LOG_ERROR, "Invalid channel layout '%s'\n", arg);
return AVERROR(EINVAL);
}
if (nret) {
*nret = chlayout;
*ret = 0;
return 0;
}
}
*ret = chlayout;
if (nret)
*nret = av_get_channel_layout_nb_channels(chlayout);
return 0;
}
static int init(AVFilterContext *ctx)
{
AudioSurroundContext *s = ctx->priv;
float overlap;
int i;
if (!(s->out_channel_layout = av_get_channel_layout(s->out_channel_layout_str))) {
av_log(ctx, AV_LOG_ERROR, "Error parsing output channel layout '%s'.\n",
s->out_channel_layout_str);
return AVERROR(EINVAL);
}
if (!(s->in_channel_layout = av_get_channel_layout(s->in_channel_layout_str))) {
av_log(ctx, AV_LOG_ERROR, "Error parsing input channel layout '%s'.\n",
s->in_channel_layout_str);
return AVERROR(EINVAL);
}
if (s->lowcutf >= s->highcutf) {
av_log(ctx, AV_LOG_ERROR, "Low cut-off '%d' should be less than high cut-off '%d'.\n",
s->lowcutf, s->highcutf);
return AVERROR(EINVAL);
}
switch (s->in_channel_layout) {
case AV_CH_LAYOUT_STEREO:
s->filter = filter_stereo;
switch (s->out_channel_layout) {
case AV_CH_LAYOUT_MONO:
s->upmix_stereo = upmix_1_0;
break;
case AV_CH_LAYOUT_STEREO:
s->upmix_stereo = upmix_stereo;
break;
case AV_CH_LAYOUT_2POINT1:
s->upmix_stereo = upmix_2_1;
break;
case AV_CH_LAYOUT_SURROUND:
s->upmix_stereo = upmix_3_0;
break;
case AV_CH_LAYOUT_3POINT1:
s->upmix_stereo = upmix_3_1;
break;
case AV_CH_LAYOUT_4POINT0:
s->upmix_stereo = upmix_4_0;
break;
case AV_CH_LAYOUT_4POINT1:
s->upmix_stereo = upmix_4_1;
break;
case AV_CH_LAYOUT_5POINT0_BACK:
s->upmix_stereo = upmix_5_0_back;
break;
case AV_CH_LAYOUT_5POINT1_BACK:
s->upmix_stereo = upmix_5_1_back;
break;
case AV_CH_LAYOUT_7POINT0:
s->upmix_stereo = upmix_7_0;
break;
case AV_CH_LAYOUT_7POINT1:
s->upmix_stereo = upmix_7_1;
break;
default:
goto fail;
}
break;
case AV_CH_LAYOUT_2POINT1:
s->filter = filter_2_1;
switch (s->out_channel_layout) {
case AV_CH_LAYOUT_5POINT1_BACK:
s->upmix_2_1 = upmix_5_1_back_2_1;
break;
default:
goto fail;
}
break;
case AV_CH_LAYOUT_SURROUND:
s->filter = filter_surround;
switch (s->out_channel_layout) {
case AV_CH_LAYOUT_3POINT1:
s->upmix_3_0 = upmix_3_1_surround;
break;
case AV_CH_LAYOUT_5POINT1_BACK:
s->upmix_3_0 = upmix_5_1_back_surround;
break;
default:
goto fail;
}
break;
case AV_CH_LAYOUT_5POINT1_BACK:
s->filter = filter_5_1_back;
switch (s->out_channel_layout) {
case AV_CH_LAYOUT_7POINT1:
s->upmix_5_1 = upmix_7_1_5_1;
break;
default:
goto fail;
}
break;
default:
fail:
av_log(ctx, AV_LOG_ERROR, "Unsupported upmix: '%s' -> '%s'.\n",
s->in_channel_layout_str, s->out_channel_layout_str);
return AVERROR(EINVAL);
}
s->buf_size = 4096;
s->pts = AV_NOPTS_VALUE;
s->window_func_lut = av_calloc(s->buf_size, sizeof(*s->window_func_lut));
if (!s->window_func_lut)
return AVERROR(ENOMEM);
for (i = 0; i < s->buf_size; i++)
s->window_func_lut[i] = sqrtf(0.5 * (1 - cosf(2 * M_PI * i / s->buf_size)) / s->buf_size);
overlap = .5;
s->hop_size = s->buf_size * (1. - overlap);
return 0;
}
QVariantMap MediaSink::defaultCodecParams(const QString &codec)
{
AVCodec *avCodec = avcodec_find_encoder_by_name(codec.toStdString().c_str());
if (!avCodec)
return QVariantMap();
QVariantMap codecParams;
AVCodecContext *codecContext = avcodec_alloc_context3(avCodec);
if (avCodec->type == AVMEDIA_TYPE_AUDIO) {
QVariantList supportedSampleRates;
if (avCodec->supported_samplerates)
for (int i = 0; int sampleRate = avCodec->supported_samplerates[i]; i++)
supportedSampleRates << sampleRate;
QStringList supportedSampleFormats;
if (avCodec->sample_fmts)
for (int i = 0; ; i++) {
AVSampleFormat sampleFormat = avCodec->sample_fmts[i];
if (sampleFormat == AV_SAMPLE_FMT_NONE)
break;
supportedSampleFormats << QString(av_get_sample_fmt_name(sampleFormat));
}
QStringList supportedChannelLayouts;
char layout[1024];
if (avCodec->channel_layouts)
for (int i = 0; uint64_t channelLayout = avCodec->channel_layouts[i]; i++) {
int channels = av_get_channel_layout_nb_channels(channelLayout);
av_get_channel_layout_string(layout, 1024, channels, channelLayout);
supportedChannelLayouts << QString(layout);
}
codecParams["supportedSampleRates"] = supportedSampleRates;
codecParams["supportedSampleFormats"] = supportedSampleFormats;
codecParams["supportedChannelLayouts"] = supportedChannelLayouts;
codecParams["defaultSampleFormat"] = codecContext->sample_fmt != AV_SAMPLE_FMT_NONE?
QString(av_get_sample_fmt_name(codecContext->sample_fmt)):
supportedSampleFormats.value(0, "s16");
codecParams["defaultBitRate"] = codecContext->bit_rate?
codecContext->bit_rate: 128000;
codecParams["defaultSampleRate"] = codecContext->sample_rate?
codecContext->sample_rate:
supportedSampleRates.value(0, 44100);
int channels = av_get_channel_layout_nb_channels(codecContext->channel_layout);
av_get_channel_layout_string(layout, 1024, channels, codecContext->channel_layout);
QString channelLayout = codecContext->channel_layout?
QString(layout):
supportedChannelLayouts.value(0, "mono");
codecParams["defaultChannelLayout"] = channelLayout;
int channelsCount = av_get_channel_layout_nb_channels(av_get_channel_layout(channelLayout.toStdString().c_str()));
;
codecParams["defaultChannels"] = codecContext->channels?
codecContext->channels:
channelsCount;
} else if (avCodec->type == AVMEDIA_TYPE_VIDEO) {
QVariantList supportedFrameRates;
if (avCodec->supported_framerates)
for (int i = 0; ; i++) {
AVRational frameRate = avCodec->supported_framerates[i];
if (frameRate.num == 0 && frameRate.den == 0)
break;
supportedFrameRates << QVariant::fromValue(QbFrac(frameRate.num, frameRate.den));
}
codecParams["supportedFrameRates"] = supportedFrameRates;
QStringList supportedPixelFormats;
if (avCodec->pix_fmts)
for (int i = 0; ; i++) {
AVPixelFormat pixelFormat = avCodec->pix_fmts[i];
if (pixelFormat == AV_PIX_FMT_NONE)
break;
supportedPixelFormats << QString(av_get_pix_fmt_name(pixelFormat));
}
codecParams["supportedPixelFormats"] = supportedPixelFormats;
codecParams["defaultGOP"] = codecContext->gop_size > 0?
codecContext->gop_size: 12;
codecParams["defaultBitRate"] = codecContext->bit_rate?
codecContext->bit_rate: 200000;
codecParams["defaultPixelFormat"] = codecContext->pix_fmt != AV_PIX_FMT_NONE?
QString(av_get_pix_fmt_name(codecContext->pix_fmt)):
supportedPixelFormats.value(0, "yuv420p");
}
av_free(codecContext);
return codecParams;
}
static BOOL CALLBACK dialog_proc( HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam )
{
static char edit_buf[256] = { 0 };
switch( message )
{
case WM_INITDIALOG :
InitCommonControls();
get_settings();
/* threads */
sprintf( edit_buf, "%d", reader_opt.threads );
SetDlgItemText( hwnd, IDC_EDIT_THREADS, (LPCTSTR)edit_buf );
SendMessage( GetDlgItem( hwnd, IDC_SPIN_THREADS ), UDM_SETBUDDY, (WPARAM)GetDlgItem( hwnd, IDC_EDIT_THREADS ), 0 );
/* av_sync */
SendMessage( GetDlgItem( hwnd, IDC_CHECK_AV_SYNC ), BM_SETCHECK, (WPARAM) reader_opt.av_sync ? BST_CHECKED : BST_UNCHECKED, 0 );
/* no_create_index */
SendMessage( GetDlgItem( hwnd, IDC_CHECK_CREATE_INDEX_FILE ), BM_SETCHECK, (WPARAM) reader_opt.no_create_index ? BST_UNCHECKED : BST_CHECKED, 0 );
/* force stream index */
SendMessage( GetDlgItem( hwnd, IDC_CHECK_FORCE_VIDEO ), BM_SETCHECK, (WPARAM) reader_opt.force_video ? BST_CHECKED : BST_UNCHECKED, 0 );
sprintf( edit_buf, "%d", reader_opt.force_video_index );
SetDlgItemText( hwnd, IDC_EDIT_FORCE_VIDEO_INDEX, (LPCTSTR)edit_buf );
SendMessage( GetDlgItem( hwnd, IDC_CHECK_FORCE_AUDIO ), BM_SETCHECK, (WPARAM) reader_opt.force_audio ? BST_CHECKED : BST_UNCHECKED, 0 );
sprintf( edit_buf, "%d", reader_opt.force_audio_index );
SetDlgItemText( hwnd, IDC_EDIT_FORCE_AUDIO_INDEX, (LPCTSTR)edit_buf );
/* forward_seek_threshold */
sprintf( edit_buf, "%d", video_opt->forward_seek_threshold );
SetDlgItemText( hwnd, IDC_EDIT_FORWARD_THRESHOLD, (LPCTSTR)edit_buf );
SendMessage( GetDlgItem( hwnd, IDC_SPIN_FORWARD_THRESHOLD ), UDM_SETBUDDY, (WPARAM)GetDlgItem( hwnd, IDC_EDIT_FORWARD_THRESHOLD ), 0 );
/* seek mode */
HWND hcombo = GetDlgItem( hwnd, IDC_COMBOBOX_SEEK_MODE );
for( int i = 0; i < 3; i++ )
SendMessage( hcombo, CB_ADDSTRING, 0, (LPARAM)seek_mode_list[i] );
SendMessage( hcombo, CB_SETCURSEL, video_opt->seek_mode, 0 );
/* scaler */
hcombo = GetDlgItem( hwnd, IDC_COMBOBOX_SCALER );
for( int i = 0; i < 11; i++ )
SendMessage( hcombo, CB_ADDSTRING, 0, (LPARAM)scaler_list[i] );
SendMessage( hcombo, CB_SETCURSEL, video_opt->scaler, 0 );
/* apply_repeat_flag */
SendMessage( GetDlgItem( hwnd, IDC_CHECK_APPLY_REPEAT_FLAG ), BM_SETCHECK, (WPARAM) video_opt->apply_repeat_flag ? BST_CHECKED : BST_UNCHECKED, 0 );
/* field_dominance */
hcombo = GetDlgItem( hwnd, IDC_COMBOBOX_FIELD_DOMINANCE );
for( int i = 0; i < 3; i++ )
SendMessage( hcombo, CB_ADDSTRING, 0, (LPARAM)field_dominance_list[i] );
SendMessage( hcombo, CB_SETCURSEL, video_opt->field_dominance, 0 );
/* LW48 output */
SendMessage( GetDlgItem( hwnd, IDC_CHECK_LW48_OUTPUT ), BM_SETCHECK, (WPARAM) video_opt->colorspace == 0 ? BST_UNCHECKED : BST_CHECKED, 0 );
/* AVS bit-depth */
hcombo = GetDlgItem( hwnd, IDC_COMBOBOX_AVS_BITDEPTH );
for( int i = 0; i < 4; i++ )
{
SendMessage( hcombo, CB_ADDSTRING, 0, (LPARAM)avs_bit_depth_list[i] );
if( video_opt->avs.bit_depth == atoi( avs_bit_depth_list[i] ) )
SendMessage( hcombo, CB_SETCURSEL, i, 0 );
}
/* audio_delay */
sprintf( edit_buf, "%d", audio_delay );
SetDlgItemText( hwnd, IDC_EDIT_AUDIO_DELAY, (LPCTSTR)edit_buf );
/* channel_layout */
if( audio_opt->channel_layout )
{
char *buf = edit_buf;
for( int i = 0; i < 64; i++ )
{
uint64_t audio_channel = audio_opt->channel_layout & (1ULL << i);
if( audio_channel )
{
const char *channel_name = av_get_channel_name( audio_channel );
if( channel_name )
{
int name_length = strlen( channel_name );
memcpy( buf, channel_name, name_length );
buf += name_length;
*(buf++) = '+';
}
}
}
if( buf > edit_buf )
*(buf - 1) = '\0'; /* Set NULL terminator. */
else
memcpy( edit_buf, "Unspecified", 12 );
}
else
memcpy( edit_buf, "Unspecified", 12 );
SetDlgItemText( hwnd, IDC_EDIT_CHANNEL_LAYOUT, (LPCTSTR)edit_buf );
/* sample_rate */
if( audio_opt->sample_rate > 0 )
sprintf( edit_buf, "%d", audio_opt->sample_rate );
else
{
audio_opt->sample_rate = 0;
memcpy( edit_buf, "0 (Auto)", 12 );
}
SetDlgItemText( hwnd, IDC_EDIT_SAMPLE_RATE, (LPCTSTR)edit_buf );
/* mix_level */
send_mix_level( hwnd, IDC_SLIDER_MIX_LEVEL_CENTER, IDC_TEXT_MIX_LEVEL_CENTER, 0, 500, audio_opt->mix_level[MIX_LEVEL_INDEX_CENTER ], edit_buf );
send_mix_level( hwnd, IDC_SLIDER_MIX_LEVEL_SURROUND, IDC_TEXT_MIX_LEVEL_SURROUND, 0, 500, audio_opt->mix_level[MIX_LEVEL_INDEX_SURROUND], edit_buf );
send_mix_level( hwnd, IDC_SLIDER_MIX_LEVEL_LFE, IDC_TEXT_MIX_LEVEL_LFE, 0, 500, audio_opt->mix_level[MIX_LEVEL_INDEX_LFE ], edit_buf );
/* readers */
SendMessage( GetDlgItem( hwnd, IDC_CHECK_LIBAVSMASH_INPUT ), BM_SETCHECK, (WPARAM) reader_disabled[0] ? BST_UNCHECKED : BST_CHECKED, 0 );
SendMessage( GetDlgItem( hwnd, IDC_CHECK_AVS_INPUT ), BM_SETCHECK, (WPARAM) reader_disabled[1] ? BST_UNCHECKED : BST_CHECKED, 0 );
SendMessage( GetDlgItem( hwnd, IDC_CHECK_VPY_INPUT ), BM_SETCHECK, (WPARAM) reader_disabled[2] ? BST_UNCHECKED : BST_CHECKED, 0 );
SendMessage( GetDlgItem( hwnd, IDC_CHECK_LIBAV_INPUT ), BM_SETCHECK, (WPARAM) reader_disabled[3] ? BST_UNCHECKED : BST_CHECKED, 0 );
/* dummy reader */
sprintf( edit_buf, "%d", video_opt->dummy.width );
SetDlgItemText( hwnd, IDC_EDIT_DUMMY_WIDTH, (LPCTSTR)edit_buf );
sprintf( edit_buf, "%d", video_opt->dummy.height );
SetDlgItemText( hwnd, IDC_EDIT_DUMMY_HEIGHT, (LPCTSTR)edit_buf );
sprintf( edit_buf, "%d", video_opt->dummy.framerate_num );
SetDlgItemText( hwnd, IDC_EDIT_DUMMY_FRAMERATE_NUM, (LPCTSTR)edit_buf );
sprintf( edit_buf, "%d", video_opt->dummy.framerate_den );
SetDlgItemText( hwnd, IDC_EDIT_DUMMY_FRAMERATE_DEN, (LPCTSTR)edit_buf );
hcombo = GetDlgItem( hwnd, IDC_COMBOBOX_DUMMY_COLORSPACE );
for( int i = 0; i < 3; i++ )
SendMessage( hcombo, CB_ADDSTRING, 0, (LPARAM)dummy_colorspace_list[i] );
SendMessage( hcombo, CB_SETCURSEL, video_opt->dummy.colorspace, 0 );
/* Library informations */
if( plugin_information[0] == 0 )
get_plugin_information();
SetDlgItemText( hwnd, IDC_TEXT_LIBRARY_INFO, (LPCTSTR)plugin_information );
HFONT hfont = (HFONT)GetStockObject( DEFAULT_GUI_FONT );
LOGFONT lf = { 0 };
GetObject( hfont, sizeof(lf), &lf );
lf.lfWidth *= 0.90;
lf.lfHeight *= 0.90;
lf.lfQuality = ANTIALIASED_QUALITY;
SendMessage( GetDlgItem( hwnd, IDC_TEXT_LIBRARY_INFO ), WM_SETFONT, (WPARAM)CreateFontIndirect( &lf ), 1 );
return TRUE;
case WM_NOTIFY :
if( wparam == IDC_SPIN_THREADS )
{
LPNMUPDOWN lpnmud = (LPNMUPDOWN)lparam;
if( lpnmud->hdr.code == UDN_DELTAPOS )
{
GetDlgItemText( hwnd, IDC_EDIT_THREADS, (LPTSTR)edit_buf, sizeof(edit_buf) );
reader_opt.threads = atoi( edit_buf );
if( lpnmud->iDelta )
reader_opt.threads += lpnmud->iDelta > 0 ? -1 : 1;
if( reader_opt.threads < 0 )
reader_opt.threads = 0;
sprintf( edit_buf, "%d", reader_opt.threads );
SetDlgItemText( hwnd, IDC_EDIT_THREADS, (LPCTSTR)edit_buf );
}
}
else if( wparam == IDC_SPIN_FORWARD_THRESHOLD )
{
LPNMUPDOWN lpnmud = (LPNMUPDOWN)lparam;
if( lpnmud->hdr.code == UDN_DELTAPOS )
{
GetDlgItemText( hwnd, IDC_EDIT_FORWARD_THRESHOLD, (LPTSTR)edit_buf, sizeof(edit_buf) );
video_opt->forward_seek_threshold = atoi( edit_buf );
if( lpnmud->iDelta )
video_opt->forward_seek_threshold += lpnmud->iDelta > 0 ? -1 : 1;
video_opt->forward_seek_threshold = CLIP_VALUE( video_opt->forward_seek_threshold, 1, 999 );
sprintf( edit_buf, "%d", video_opt->forward_seek_threshold );
SetDlgItemText( hwnd, IDC_EDIT_FORWARD_THRESHOLD, (LPCTSTR)edit_buf );
}
}
return TRUE;
case WM_HSCROLL :
if( GetDlgItem( hwnd, IDC_SLIDER_MIX_LEVEL_CENTER ) == (HWND)lparam )
get_mix_level( hwnd, IDC_SLIDER_MIX_LEVEL_CENTER, IDC_TEXT_MIX_LEVEL_CENTER, &audio_opt->mix_level[MIX_LEVEL_INDEX_CENTER ], edit_buf );
else if( GetDlgItem( hwnd, IDC_SLIDER_MIX_LEVEL_SURROUND ) == (HWND)lparam )
get_mix_level( hwnd, IDC_SLIDER_MIX_LEVEL_SURROUND, IDC_TEXT_MIX_LEVEL_SURROUND, &audio_opt->mix_level[MIX_LEVEL_INDEX_SURROUND], edit_buf );
else if( GetDlgItem( hwnd, IDC_SLIDER_MIX_LEVEL_LFE ) == (HWND)lparam )
get_mix_level( hwnd, IDC_SLIDER_MIX_LEVEL_LFE, IDC_TEXT_MIX_LEVEL_LFE, &audio_opt->mix_level[MIX_LEVEL_INDEX_LFE ], edit_buf );
return FALSE;
case WM_COMMAND :
switch( wparam )
{
case IDCANCEL :
EndDialog( hwnd, IDCANCEL );
return TRUE;
case IDOK :
{
if( !settings_path )
settings_path = (char *)settings_path_list[0];
FILE *ini = fopen( settings_path, "w" );
if( !ini )
{
MESSAGE_BOX_DESKTOP( MB_ICONERROR | MB_OK, "Failed to update configuration file" );
return FALSE;
}
/* threads */
GetDlgItemText( hwnd, IDC_EDIT_THREADS, (LPTSTR)edit_buf, sizeof(edit_buf) );
reader_opt.threads = MAX( atoi( edit_buf ), 0 );
if( reader_opt.threads > 0 )
fprintf( ini, "threads=%d\n", reader_opt.threads );
else
fprintf( ini, "threads=0 (auto)\n" );
/* av_sync */
reader_opt.av_sync = (BST_CHECKED == SendMessage( GetDlgItem( hwnd, IDC_CHECK_AV_SYNC ), BM_GETCHECK, 0, 0 ));
fprintf( ini, "av_sync=%d\n", reader_opt.av_sync );
/* no_create_index */
reader_opt.no_create_index = !(BST_CHECKED == SendMessage( GetDlgItem( hwnd, IDC_CHECK_CREATE_INDEX_FILE ), BM_GETCHECK, 0, 0 ));
fprintf( ini, "no_create_index=%d\n", reader_opt.no_create_index );
/* force stream index */
reader_opt.force_video = (BST_CHECKED == SendMessage( GetDlgItem( hwnd, IDC_CHECK_FORCE_VIDEO ), BM_GETCHECK, 0, 0 ));
GetDlgItemText( hwnd, IDC_EDIT_FORCE_VIDEO_INDEX, (LPTSTR)edit_buf, sizeof(edit_buf) );
reader_opt.force_video_index = MAX( atoi( edit_buf ), -1 );
fprintf( ini, "force_video_index=%d:%d\n", reader_opt.force_video, reader_opt.force_video_index );
reader_opt.force_audio = (BST_CHECKED == SendMessage( GetDlgItem( hwnd, IDC_CHECK_FORCE_AUDIO ), BM_GETCHECK, 0, 0 ));
GetDlgItemText( hwnd, IDC_EDIT_FORCE_AUDIO_INDEX, (LPTSTR)edit_buf, sizeof(edit_buf) );
reader_opt.force_audio_index = MAX( atoi( edit_buf ), -1 );
fprintf( ini, "force_audio_index=%d:%d\n", reader_opt.force_audio, reader_opt.force_audio_index );
/* seek_mode */
video_opt->seek_mode = SendMessage( GetDlgItem( hwnd, IDC_COMBOBOX_SEEK_MODE ), CB_GETCURSEL, 0, 0 );
fprintf( ini, "seek_mode=%d\n", video_opt->seek_mode );
/* forward_seek_threshold */
GetDlgItemText( hwnd, IDC_EDIT_FORWARD_THRESHOLD, (LPTSTR)edit_buf, sizeof(edit_buf) );
video_opt->forward_seek_threshold = CLIP_VALUE( atoi( edit_buf ), 1, 999 );
fprintf( ini, "forward_threshold=%d\n", video_opt->forward_seek_threshold );
/* scaler */
video_opt->scaler = SendMessage( GetDlgItem( hwnd, IDC_COMBOBOX_SCALER ), CB_GETCURSEL, 0, 0 );
fprintf( ini, "scaler=%d\n", video_opt->scaler );
/* apply_repeat_flag */
video_opt->apply_repeat_flag = (BST_CHECKED == SendMessage( GetDlgItem( hwnd, IDC_CHECK_APPLY_REPEAT_FLAG ), BM_GETCHECK, 0, 0 ));
fprintf( ini, "apply_repeat_flag=%d\n", video_opt->apply_repeat_flag );
/* field_dominance */
video_opt->field_dominance = SendMessage( GetDlgItem( hwnd, IDC_COMBOBOX_FIELD_DOMINANCE ), CB_GETCURSEL, 0, 0 );
fprintf( ini, "field_dominance=%d\n", video_opt->field_dominance );
/* LW48 output */
video_opt->colorspace = (BST_CHECKED == SendMessage( GetDlgItem( hwnd, IDC_CHECK_LW48_OUTPUT ), BM_GETCHECK, 0, 0 )) ? OUTPUT_LW48 : 0;
fprintf( ini, "colorspace=%d\n", video_opt->colorspace );
/* AVS bit-depth */
video_opt->avs.bit_depth = SendMessage( GetDlgItem( hwnd, IDC_COMBOBOX_AVS_BITDEPTH ), CB_GETCURSEL, 0, 0 );
video_opt->avs.bit_depth = atoi( avs_bit_depth_list[ video_opt->avs.bit_depth ] );
fprintf( ini, "avs_bit_depth=%d\n", video_opt->avs.bit_depth );
/* audio_delay */
GetDlgItemText( hwnd, IDC_EDIT_AUDIO_DELAY, (LPTSTR)edit_buf, sizeof(edit_buf) );
audio_delay = atoi( edit_buf );
fprintf( ini, "audio_delay=%d\n", audio_delay );
/* channel_layout */
GetDlgItemText( hwnd, IDC_EDIT_CHANNEL_LAYOUT, (LPTSTR)edit_buf, sizeof(edit_buf) );
audio_opt->channel_layout = av_get_channel_layout( edit_buf );
fprintf( ini, "channel_layout=0x%"PRIx64"\n", audio_opt->channel_layout );
/* sample_rate */
GetDlgItemText( hwnd, IDC_EDIT_SAMPLE_RATE, (LPTSTR)edit_buf, sizeof(edit_buf) );
audio_opt->sample_rate = atoi( edit_buf );
fprintf( ini, "sample_rate=%d\n", audio_opt->sample_rate );
/* mix_level */
fprintf( ini, "mix_level=%d:%d:%d\n",
audio_opt->mix_level[MIX_LEVEL_INDEX_CENTER ],
audio_opt->mix_level[MIX_LEVEL_INDEX_SURROUND],
audio_opt->mix_level[MIX_LEVEL_INDEX_LFE ] );
/* readers */
reader_disabled[0] = !(BST_CHECKED == SendMessage( GetDlgItem( hwnd, IDC_CHECK_LIBAVSMASH_INPUT ), BM_GETCHECK, 0, 0 ));
reader_disabled[1] = !(BST_CHECKED == SendMessage( GetDlgItem( hwnd, IDC_CHECK_AVS_INPUT ), BM_GETCHECK, 0, 0 ));
reader_disabled[2] = !(BST_CHECKED == SendMessage( GetDlgItem( hwnd, IDC_CHECK_VPY_INPUT ), BM_GETCHECK, 0, 0 ));
reader_disabled[3] = !(BST_CHECKED == SendMessage( GetDlgItem( hwnd, IDC_CHECK_LIBAV_INPUT ), BM_GETCHECK, 0, 0 ));
fprintf( ini, "libavsmash_disabled=%d\n", reader_disabled[0] );
fprintf( ini, "avs_disabled=%d\n", reader_disabled[1] );
fprintf( ini, "vpy_disabled=%d\n", reader_disabled[2] );
fprintf( ini, "libav_disabled=%d\n", reader_disabled[3] );
/* dummy reader */
GetDlgItemText( hwnd, IDC_EDIT_DUMMY_WIDTH, (LPTSTR)edit_buf, sizeof(edit_buf) );
video_opt->dummy.width = MAX( atoi( edit_buf ), 32 );
GetDlgItemText( hwnd, IDC_EDIT_DUMMY_HEIGHT, (LPTSTR)edit_buf, sizeof(edit_buf) );
video_opt->dummy.height = MAX( atoi( edit_buf ), 32 );
GetDlgItemText( hwnd, IDC_EDIT_DUMMY_FRAMERATE_NUM, (LPTSTR)edit_buf, sizeof(edit_buf) );
video_opt->dummy.framerate_num = MAX( atoi( edit_buf ), 1 );
GetDlgItemText( hwnd, IDC_EDIT_DUMMY_FRAMERATE_DEN, (LPTSTR)edit_buf, sizeof(edit_buf) );
video_opt->dummy.framerate_den = MAX( atoi( edit_buf ), 1 );
video_opt->dummy.colorspace = SendMessage( GetDlgItem( hwnd, IDC_COMBOBOX_DUMMY_COLORSPACE ), CB_GETCURSEL, 0, 0 );
fprintf( ini, "dummy_resolution=%dx%d\n", video_opt->dummy.width, video_opt->dummy.height );
fprintf( ini, "dummy_framerate=%d/%d\n", video_opt->dummy.framerate_num, video_opt->dummy.framerate_den );
fprintf( ini, "dummy_colorspace=%d\n", video_opt->dummy.colorspace );
fclose( ini );
EndDialog( hwnd, IDOK );
MESSAGE_BOX_DESKTOP( MB_OK, "Please reopen the input file for updating settings!" );
return TRUE;
}
default :
return FALSE;
}
case WM_CLOSE :
EndDialog( hwnd, IDOK );
return TRUE;
default :
return FALSE;
}
}
int64_t avcodec_get_channel_layout(const char *name)
{
return av_get_channel_layout(name);
}
void ACapsConvertElement::iStream(const QbPacket &packet)
{
if (!packet.caps().isValid() ||
packet.caps().mimeType() != "audio/x-raw" ||
this->state() != ElementStatePlaying)
return;
// Input Format
AVSampleFormat iSampleFormat = av_get_sample_fmt(packet.caps().property("format").toString().toStdString().c_str());
int iNChannels = packet.caps().property("channels").toInt();
int64_t iChannelLayout = av_get_channel_layout(packet.caps().property("layout").toString().toStdString().c_str());
int iNPlanes = av_sample_fmt_is_planar(iSampleFormat)? iNChannels: 1;
int iSampleRate = packet.caps().property("rate").toInt();
int iNSamples = packet.caps().property("samples").toInt();
if (iNSamples < 1)
iNSamples = 1024;
bool sameMimeType = packet.caps().mimeType() == this->m_caps.mimeType();
// Output Format
AVSampleFormat oSampleFormat = (sameMimeType && this->m_caps.dynamicPropertyNames().contains("format"))?
av_get_sample_fmt(this->m_caps.property("format").toString().toStdString().c_str()):
iSampleFormat;
int oNChannels = (sameMimeType && this->m_caps.dynamicPropertyNames().contains("channels"))?
this->m_caps.property("channels").toInt():
iNChannels;
int64_t oChannelLayout = (sameMimeType && this->m_caps.dynamicPropertyNames().contains("layout"))?
av_get_channel_layout(this->m_caps.property("layout").toString().toStdString().c_str()):
iChannelLayout;
int oSampleRate = (sameMimeType && this->m_caps.dynamicPropertyNames().contains("rate"))?
this->m_caps.property("rate").toInt():
iSampleRate;
QVector<uint8_t *> iData(iNPlanes);
int iLineSize;
if (av_samples_fill_arrays(&iData.data()[0],
&iLineSize,
(const uint8_t *) packet.buffer().data(),
iNChannels,
iNSamples,
iSampleFormat,
1) < 0)
return;
QbCaps caps1(packet.caps());
QbCaps caps2(this->m_curInputCaps);
caps1.setProperty("samples", QVariant());
caps2.setProperty("samples", QVariant());
if (caps1 != caps2)
{
// create resampler context
this->m_resampleContext = SwrContextPtr(swr_alloc(), this->deleteSwrContext);
if (!this->m_resampleContext)
return;
// set options
av_opt_set_int(this->m_resampleContext.data(), "in_channel_layout", iChannelLayout, 0);
av_opt_set_int(this->m_resampleContext.data(), "in_sample_rate", iSampleRate, 0);
av_opt_set_sample_fmt(this->m_resampleContext.data(), "in_sample_fmt", iSampleFormat, 0);
av_opt_set_int(this->m_resampleContext.data(), "out_channel_layout", oChannelLayout, 0);
av_opt_set_int(this->m_resampleContext.data(), "out_sample_rate", oSampleRate, 0);
av_opt_set_sample_fmt(this->m_resampleContext.data(), "out_sample_fmt", oSampleFormat, 0);
// initialize the resampling context
if (swr_init(this->m_resampleContext.data()) < 0)
return;
this->m_curInputCaps = packet.caps();
}
// compute destination number of samples
int oNSamples = av_rescale_rnd(swr_get_delay(this->m_resampleContext.data(),
iSampleRate) +
iNSamples,
oSampleRate,
iSampleRate,
AV_ROUND_UP);
// buffer is going to be directly written to a rawaudio file, no alignment
int oNPlanes = av_sample_fmt_is_planar(oSampleFormat)? oNChannels: 1;
QVector<uint8_t *> oData(oNPlanes);
int oLineSize;
int oBufferSize = av_samples_get_buffer_size(&oLineSize,
oNChannels,
oNSamples,
oSampleFormat,
1);
QSharedPointer<uchar> oBuffer(new uchar[oBufferSize]);
if (!oBuffer)
return;
if (av_samples_fill_arrays(&oData.data()[0],
&oLineSize,
(const uint8_t *) oBuffer.data(),
oNChannels,
oNSamples,
oSampleFormat,
1) < 0)
return;
// convert to destination format
if (swr_convert(this->m_resampleContext.data(),
oData.data(),
oNSamples,
(const uint8_t **) iData.data(),
iNSamples) < 0)
return;
const char *format = av_get_sample_fmt_name(oSampleFormat);
char layout[256];
av_get_channel_layout_string(layout,
sizeof(layout),
oNChannels,
oChannelLayout);
QString caps = QString("audio/x-raw,"
"format=%1,"
"channels=%2,"
"rate=%3,"
"layout=%4,"
"samples=%5").arg(format)
.arg(oNChannels)
.arg(oSampleRate)
.arg(layout)
.arg(oNSamples);
QbPacket oPacket(caps,
oBuffer,
oBufferSize);
oPacket.setPts(packet.pts());
oPacket.setDuration(packet.duration());
oPacket.setTimeBase(packet.timeBase());
oPacket.setIndex(packet.index());
emit this->oStream(oPacket);
}
