void
test__pxf_serialize_filter_list__oneFilter(void **state)
{
List* filter_list = NIL;
PxfFilterDesc* filter = build_filter(
PXF_ATTR_CODE, 1, NULL,
PXF_CONST_CODE, 0, "1984",
PXFOP_GT);
filter_list = lappend(filter_list, filter);
char* result = pxf_serialize_filter_list(filter_list);
assert_string_equal(result, "a0c1984o2");
pxf_free_filter_list(filter_list);
filter_list = NIL;
pfree(result);
filter = build_filter(
PXF_ATTR_CODE, 8, NULL,
PXF_CONST_CODE, 0, "\"George Orwell\"",
PXFOP_EQ);
filter_list = lappend(filter_list, filter);
result = pxf_serialize_filter_list(filter_list);
assert_string_equal(result, "a7c\"George Orwell\"o5");
pxf_free_filter_list(filter_list);
pfree(result);
}
AVResampleContext *av_resample_init(int out_rate, int in_rate, int filter_size, int phase_shift, int linear, double cutoff){
AVResampleContext *c= av_mallocz_t(sizeof(AVResampleContext));
double factor= FFMIN_T(out_rate * cutoff / in_rate, 1.0);
int phase_count= 1<<phase_shift;
c->phase_shift= phase_shift;
c->phase_mask= phase_count-1;
c->linear= linear;
c->filter_length= FFMAX_T((int)ceil(filter_size/factor), 1);
c->filter_bank= av_mallocz_t(c->filter_length*(phase_count+1)*sizeof(FELEM));
//printf("out_rate %d in_rate %d filter_length %d,phase_count %d\n",out_rate,in_rate,c->filter_length,phase_count);
//build_filter(c->filter_bank, factor, c->filter_length, phase_count, 1<<FILTER_SHIFT, WINDOW_TYPE);
if((out_rate == 11025) && (in_rate == 8000)){
FILE *fp = fopen("./EngineAudFilterData_8-11","rb");
if(fp != NULL){
fread(c->filter_bank,1,c->filter_length*(phase_count+1)*sizeof(FELEM),fp);
fclose(fp);
} else {
printf("Can't open ./EngineAudFilterData_8-11 to init AVResampleContext\n");
build_filter(c->filter_bank, factor, c->filter_length, phase_count, 1<<FILTER_SHIFT, WINDOW_TYPE);
}
}
else if((in_rate == 11025) && (out_rate == 8000)){
//build_filter(c->filter_bank, factor, c->filter_length, phase_count, 1<<FILTER_SHIFT, WINDOW_TYPE);
FILE *fp = fopen("./EngineAudFilterData_11-8","rb");
if(fp != NULL){
fread(c->filter_bank,1,c->filter_length*(phase_count+1)*sizeof(FELEM),fp);
fclose(fp);
} else {
printf("Can't open ./EngineAudFilterData_11-8 to init AVResampleContext\n");
build_filter(c->filter_bank, factor, c->filter_length, phase_count, 1<<FILTER_SHIFT, WINDOW_TYPE);
}
}
else {
build_filter(c->filter_bank, factor, c->filter_length, phase_count, 1<<FILTER_SHIFT, WINDOW_TYPE);
}
memcpy(&c->filter_bank[c->filter_length*phase_count+1], c->filter_bank, (c->filter_length-1)*sizeof(FELEM));
c->filter_bank[c->filter_length*phase_count]= c->filter_bank[c->filter_length - 1];
c->src_incr= out_rate;
c->ideal_dst_incr= c->dst_incr= in_rate * phase_count;
c->index= -phase_count*((c->filter_length-1)/2);
return c;
}
/*
* Build a chain of filters given filter names and param dicts.
* If head is given, start filter chain with it.
* Assume ownership of head.
*/
static fz_stream *
build_filter_chain(fz_context *ctx, fz_stream *chain, pdf_document *doc, pdf_obj *fs, pdf_obj *ps, int num, int gen, fz_compression_params *params)
{
pdf_obj *f;
pdf_obj *p;
int i, n;
fz_try(ctx)
{
n = pdf_array_len(ctx, fs);
for (i = 0; i < n; i++)
{
fz_stream *chain2;
f = pdf_array_get(ctx, fs, i);
p = pdf_array_get(ctx, ps, i);
chain2 = chain;
chain = NULL;
chain = build_filter(ctx, chain2, doc, f, p, num, gen, (i == n-1 ? params : NULL));
}
}
fz_catch(ctx)
{
fz_drop_stream(ctx, chain);
fz_rethrow(ctx);
}
return chain;
}
char *
ipa_sudo_conv_cmd_filter(TALLOC_CTX *mem_ctx,
struct ipa_sudo_conv *conv)
{
return build_filter(mem_ctx, conv->sysdb, conv->cmds,
conv->map_cmd, get_sudo_cmd_rdn);
}
AVResampleContext *av_resample_init(int out_rate, int in_rate, int filter_size, int phase_shift, int linear, double cutoff){
AVResampleContext *c= av_mallocz(sizeof(AVResampleContext));
double factor= FFMIN(out_rate * cutoff / in_rate, 1.0);
int phase_count= 1<<phase_shift;
if (!c)
return NULL;
c->phase_shift= phase_shift;
c->phase_mask= phase_count-1;
c->linear= linear;
c->filter_length= FFMAX((int)ceil(filter_size/factor), 1);
c->filter_bank= av_mallocz_array(c->filter_length, (phase_count+1)*sizeof(FELEM));
if (!c->filter_bank)
goto error;
if (build_filter(c->filter_bank, factor, c->filter_length, phase_count, 1<<FILTER_SHIFT, WINDOW_TYPE))
goto error;
memcpy(&c->filter_bank[c->filter_length*phase_count+1], c->filter_bank, (c->filter_length-1)*sizeof(FELEM));
c->filter_bank[c->filter_length*phase_count]= c->filter_bank[c->filter_length - 1];
if(!av_reduce(&c->src_incr, &c->dst_incr, out_rate, in_rate * (int64_t)phase_count, INT32_MAX/2))
goto error;
c->ideal_dst_incr= c->dst_incr;
c->index= -phase_count*((c->filter_length-1)/2);
return c;
error:
av_free(c->filter_bank);
av_free(c);
return NULL;
}
ResampleContext *swri_resample_init(ResampleContext *c, int out_rate, int in_rate, int filter_size, int phase_shift, int linear, double cutoff, enum AVSampleFormat format){
double factor= FFMIN(out_rate * cutoff / in_rate, 1.0);
int phase_count= 1<<phase_shift;
if (!c || c->phase_shift != phase_shift || c->linear!=linear || c->factor != factor
|| c->filter_length != FFMAX((int)ceil(filter_size/factor), 1) || c->format != format) {
c = av_mallocz(sizeof(*c));
if (!c)
return NULL;
c->format= format;
c->felem_size= av_get_bytes_per_sample(c->format);
switch(c->format){
case AV_SAMPLE_FMT_S16P:
c->filter_shift = 15;
break;
case AV_SAMPLE_FMT_S32P:
c->filter_shift = 30;
break;
case AV_SAMPLE_FMT_FLTP:
case AV_SAMPLE_FMT_DBLP:
c->filter_shift = 0;
break;
default:
av_log(NULL, AV_LOG_ERROR, "Unsupported sample format\n");
return NULL;
}
c->phase_shift = phase_shift;
c->phase_mask = phase_count - 1;
c->linear = linear;
c->factor = factor;
c->filter_length = FFMAX((int)ceil(filter_size/factor), 1);
c->filter_alloc = FFALIGN(c->filter_length, 8);
c->filter_bank = av_mallocz(c->filter_alloc*(phase_count+1)*c->felem_size);
if (!c->filter_bank)
goto error;
if (build_filter(c, (void*)c->filter_bank, factor, c->filter_length, c->filter_alloc, phase_count, 1<<c->filter_shift, WINDOW_TYPE))
goto error;
memcpy(c->filter_bank + (c->filter_alloc*phase_count+1)*c->felem_size, c->filter_bank, (c->filter_alloc-1)*c->felem_size);
memcpy(c->filter_bank + (c->filter_alloc*phase_count )*c->felem_size, c->filter_bank + (c->filter_alloc - 1)*c->felem_size, c->felem_size);
}
c->compensation_distance= 0;
if(!av_reduce(&c->src_incr, &c->dst_incr, out_rate, in_rate * (int64_t)phase_count, INT32_MAX/2))
goto error;
c->ideal_dst_incr= c->dst_incr;
c->index= -phase_count*((c->filter_length-1)/2);
c->frac= 0;
return c;
error:
av_free(c->filter_bank);
av_free(c);
return NULL;
}
void
test__pxf_serialize_filter_list__manyFilters(void **state)
{
char* result = NULL;
List* filter_list = NIL;
PxfFilterDesc* filter1 = build_filter(
PXF_ATTR_CODE, 2, NULL,
PXF_CONST_CODE, 0, "1983",
PXFOP_GT);
PxfFilterDesc* filter2 = build_filter(
PXF_ATTR_CODE, 3, NULL,
PXF_CONST_CODE, 0, "1985",
PXFOP_LT);
PxfFilterDesc* filter3 = build_filter(
PXF_ATTR_CODE, 4, NULL,
PXF_CONST_CODE, 0, "\"George Orwell\"",
PXFOP_EQ);
PxfFilterDesc* filter4 = build_filter(
PXF_ATTR_CODE, 5, NULL,
PXF_CONST_CODE, 0, "\"Winston\"",
PXFOP_GE);
filter_list = lappend(filter_list, filter1);
filter_list = lappend(filter_list, filter2);
result = pxf_serialize_filter_list(filter_list);
assert_string_equal(result, "a1c1983o2a2c1985o1o7");
pfree(result);
filter_list = lappend(filter_list, filter3);
result = pxf_serialize_filter_list(filter_list);
assert_string_equal(result, "a1c1983o2a2c1985o1o7a3c\"George Orwell\"o5o7");
pfree(result);
filter_list = lappend(filter_list, filter4);
result = pxf_serialize_filter_list(filter_list);
assert_string_equal(result, "a1c1983o2a2c1985o1o7a3c\"George Orwell\"o5o7a4c\"Winston\"o4o7");
pfree(result);
pxf_free_filter_list(filter_list);
filter_list = NIL;
}
/*
* Build a chain of filters given filter names and param dicts.
* If head is given, start filter chain with it.
* Assume ownership of head.
*/
static fz_stream *
build_filter_chain(fz_stream *chain, pdf_xref *xref, fz_obj *fs, fz_obj *ps, int num, int gen)
{
fz_obj *f;
fz_obj *p;
int i;
for (i = 0; i < fz_array_len(fs); i++)
{
f = fz_array_get(fs, i);
p = fz_array_get(ps, i);
chain = build_filter(chain, xref, f, p, num, gen);
}
return chain;
}
WinFileReq( long version, GlobalFunc *global, LWFileReqLocal *local,
void *serverData )
{
HWND hwnd;
OPENFILENAME ofn = { 0 };
char *bname, *filter;
int bsize, ok;
if ( version != LWFILEREQ_VERSION ) return AFUNC_BADVERSION;
hwnd = GetForegroundWindow();
if ( local->reqType == FREQ_DIRECTORY ) {
ok = frdir( local, hwnd );
return ok ? AFUNC_OK : AFUNC_BADLOCAL;
}
bsize = ( local->reqType == FREQ_MULTILOAD ) ? 32767 : 260;
bname = malloc( bsize );
if ( !bname ) return AFUNC_BADLOCAL;
strcpy( bname, local->baseName );
filter = build_filter( global, local->fileType );
ofn.lStructSize = sizeof( OPENFILENAME );
ofn.hwndOwner = hwnd;
ofn.lpstrFilter = filter;
ofn.nFilterIndex = 0;
ofn.lpstrFile = bname;
ofn.nMaxFile = bsize;
ofn.lpstrFileTitle = local->baseName;
ofn.nMaxFileTitle = local->bufLen;
ofn.lpstrInitialDir = local->path;
ofn.lpstrTitle = local->title;
ofn.Flags = OFN_EXPLORER | OFN_NOCHANGEDIR;
switch ( local->reqType ) {
case FREQ_LOAD: ok = frload( local, &ofn ); break;
case FREQ_SAVE: ok = frsave( local, &ofn ); break;
case FREQ_MULTILOAD: ok = frmload( local, &ofn ); break;
}
free( bname );
if ( filter ) free( filter );
return ok ? AFUNC_OK : AFUNC_BADLOCAL;
}
static int rebuild_filter_bank_with_compensation(ResampleContext *c)
{
uint8_t *new_filter_bank;
int new_src_incr, new_dst_incr;
int phase_count = c->phase_count_compensation;
int ret;
if (phase_count == c->phase_count)
return 0;
av_assert0(!c->frac && !c->dst_incr_mod && !c->compensation_distance);
new_filter_bank = av_calloc(c->filter_alloc, (phase_count + 1) * c->felem_size);
if (!new_filter_bank)
return AVERROR(ENOMEM);
ret = build_filter(c, new_filter_bank, c->factor, c->filter_length, c->filter_alloc,
phase_count, 1 << c->filter_shift, c->filter_type, c->kaiser_beta);
if (ret < 0) {
av_freep(&new_filter_bank);
return ret;
}
memcpy(new_filter_bank + (c->filter_alloc*phase_count+1)*c->felem_size, new_filter_bank, (c->filter_alloc-1)*c->felem_size);
memcpy(new_filter_bank + (c->filter_alloc*phase_count )*c->felem_size, new_filter_bank + (c->filter_alloc - 1)*c->felem_size, c->felem_size);
if (!av_reduce(&new_src_incr, &new_dst_incr, c->src_incr,
c->dst_incr * (int64_t)(phase_count/c->phase_count), INT32_MAX/2))
{
av_freep(&new_filter_bank);
return AVERROR(EINVAL);
}
c->src_incr = new_src_incr;
c->dst_incr = new_dst_incr;
while (c->dst_incr < (1<<20) && c->src_incr < (1<<20)) {
c->dst_incr *= 2;
c->src_incr *= 2;
}
c->ideal_dst_incr = c->dst_incr;
c->dst_incr_div = c->dst_incr / c->src_incr;
c->dst_incr_mod = c->dst_incr % c->src_incr;
c->index *= phase_count / c->phase_count;
c->phase_count = phase_count;
av_freep(&c->filter_bank);
c->filter_bank = new_filter_bank;
return 0;
}
/*
* Build a chain of filters given filter names and param dicts.
* If head is given, start filter chain with it.
* Assume ownership of head.
*/
static fz_stream *
build_filter_chain(fz_stream *chain, pdf_document *xref, pdf_obj *fs, pdf_obj *ps, int num, int gen, pdf_image_params *params)
{
pdf_obj *f;
pdf_obj *p;
int i, n;
n = pdf_array_len(fs);
for (i = 0; i < n; i++)
{
f = pdf_array_get(fs, i);
p = pdf_array_get(ps, i);
chain = build_filter(chain, xref, f, p, num, gen, (i == n-1 ? params : NULL));
}
return chain;
}
/*
* Construct a filter to decode a stream, constraining
* to stream length and decrypting.
*/
static fz_stream *
pdf_open_filter(fz_stream *chain, pdf_xref *xref, fz_obj *stmobj, int num, int gen)
{
fz_obj *filters;
fz_obj *params;
filters = fz_dict_getsa(stmobj, "Filter", "F");
params = fz_dict_getsa(stmobj, "DecodeParms", "DP");
chain = pdf_open_raw_filter(chain, xref, stmobj, num, gen);
if (fz_is_name(filters))
return build_filter(chain, xref, filters, params, num, gen);
if (fz_array_len(filters) > 0)
return build_filter_chain(chain, xref, filters, params, num, gen);
return chain;
}
/*
* Construct a filter to decode a stream, constraining
* to stream length and decrypting.
*/
static fz_stream *
pdf_open_filter(fz_stream *chain, pdf_document *xref, pdf_obj *stmobj, int num, int gen, int offset, pdf_image_params *imparams)
{
pdf_obj *filters;
pdf_obj *params;
filters = pdf_dict_getsa(stmobj, "Filter", "F");
params = pdf_dict_getsa(stmobj, "DecodeParms", "DP");
chain = pdf_open_raw_filter(chain, xref, stmobj, num, gen, offset);
if (pdf_is_name(filters))
chain = build_filter(chain, xref, filters, params, num, gen, imparams);
else if (pdf_array_len(filters) > 0)
chain = build_filter_chain(chain, xref, filters, params, num, gen, imparams);
return chain;
}
/*
* Construct a filter to decode a stream, without
* constraining to stream length, and without decryption.
*/
fz_stream *
pdf_open_inline_stream(pdf_document *xref, pdf_obj *stmobj, int length, fz_stream *chain, pdf_image_params *imparams)
{
pdf_obj *filters;
pdf_obj *params;
filters = pdf_dict_getsa(stmobj, "Filter", "F");
params = pdf_dict_getsa(stmobj, "DecodeParms", "DP");
/* don't close chain when we close this filter */
fz_keep_stream(chain);
if (pdf_is_name(filters))
return build_filter(chain, xref, filters, params, 0, 0, imparams);
if (pdf_array_len(filters) > 0)
return build_filter_chain(chain, xref, filters, params, 0, 0, imparams);
return fz_open_null(chain, length);
}
/*
* Construct a filter to decode a stream, without
* constraining to stream length, and without decryption.
*/
fz_stream *
pdf_open_inline_stream(fz_stream *chain, pdf_xref *xref, fz_obj *stmobj, int length)
{
fz_obj *filters;
fz_obj *params;
filters = fz_dict_getsa(stmobj, "Filter", "F");
params = fz_dict_getsa(stmobj, "DecodeParms", "DP");
/* don't close chain when we close this filter */
fz_keep_stream(chain);
if (fz_is_name(filters))
return build_filter(chain, xref, filters, params, 0, 0);
if (fz_array_len(filters) > 0)
return build_filter_chain(chain, xref, filters, params, 0, 0);
return fz_open_null(chain, length);
}
/*
* Construct a filter to decode a stream, without
* constraining to stream length, and without decryption.
*/
fz_stream *
pdf_open_inline_stream(fz_context *ctx, pdf_document *doc, pdf_obj *stmobj, int length, fz_stream *chain, fz_compression_params *imparams)
{
pdf_obj *filters;
pdf_obj *params;
filters = pdf_dict_geta(ctx, stmobj, PDF_NAME_Filter, PDF_NAME_F);
params = pdf_dict_geta(ctx, stmobj, PDF_NAME_DecodeParms, PDF_NAME_DP);
/* don't close chain when we close this filter */
fz_keep_stream(ctx, chain);
if (pdf_is_name(ctx, filters))
return build_filter(ctx, chain, doc, filters, params, 0, 0, imparams);
if (pdf_array_len(ctx, filters) > 0)
return build_filter_chain(ctx, chain, doc, filters, params, 0, 0, imparams);
if (imparams)
imparams->type = FZ_IMAGE_RAW;
return fz_open_null(ctx, chain, length, fz_tell(ctx, chain));
}
/*
* Test for a query with different types.
* Types pairing are not checked, it is covered by the
* supported operations which are type specific.
*/
void
test__opexpr_to_pxffilter__differentTypes(void **state)
{
PxfFilterDesc *filter = (PxfFilterDesc*) palloc0(sizeof(PxfFilterDesc));
Var *arg_var = build_var(INT2OID, 3);
char* const_value = strdup("13"); /* will be free'd by const_to_str */
Const *arg_const = build_const(INT8OID, const_value);
OpExpr *expr = build_op_expr(arg_const, arg_var, 1864 /* int28lt */);
/* run test */
assert_true(opexpr_to_pxffilter(expr, filter));
PxfFilterDesc *expected = build_filter(
PXF_CONST_CODE, 0, "13",
PXF_ATTR_CODE, 3, NULL,
PXFOP_LT);
compare_filters(filter, expected);
pxf_free_filter(filter);
list_free_deep(expr->args); /* free all args */
pfree(expr);
}
/* NOTE: this test is not a use case - when the query includes
* 'is null' or 'is not null' the qualifier code is T_NullTest and not T_OpExpr */
void
test__opexpr_to_pxffilter__attributeIsNull(void **state)
{
PxfFilterDesc *filter = (PxfFilterDesc*) palloc0(sizeof(PxfFilterDesc));
Var *arg_var = build_var(INT2OID, 1);
Const* arg_const = build_const(INT2OID, NULL);
OpExpr *expr = build_op_expr(arg_var, arg_const, 94 /* int2eq */);
PxfFilterDesc* expected = build_filter(
PXF_ATTR_CODE, 1, NULL,
PXF_CONST_CODE, 0, "\"NULL\"",
PXFOP_EQ);
/* run test */
assert_true(opexpr_to_pxffilter(expr, filter));
compare_filters(filter, expected);
pxf_free_filter(filter);
pxf_free_filter(expected);
list_free_deep(expr->args); /* free all args */
pfree(expr);
}
AVResampleContext *swr_resample_init(AVResampleContext *c, int out_rate, int in_rate, int filter_size, int phase_shift, int linear, double cutoff){
double factor= FFMIN(out_rate * cutoff / in_rate, 1.0);
int phase_count= 1<<phase_shift;
if(!c || c->phase_shift!=phase_shift || c->linear!=linear || c->factor != factor
|| c->filter_length!=FFMAX((int)ceil(filter_size/factor), 1)){
c= av_mallocz(sizeof(AVResampleContext));
if (!c)
return NULL;
c->phase_shift= phase_shift;
c->phase_mask= phase_count-1;
c->linear= linear;
c->factor= factor;
c->filter_length= FFMAX((int)ceil(filter_size/factor), 1);
c->filter_bank= av_mallocz(c->filter_length*(phase_count+1)*sizeof(FELEM));
if (!c->filter_bank)
goto error;
if (build_filter(c->filter_bank, factor, c->filter_length, phase_count, 1<<FILTER_SHIFT, WINDOW_TYPE))
goto error;
memcpy(&c->filter_bank[c->filter_length*phase_count+1], c->filter_bank, (c->filter_length-1)*sizeof(FELEM));
c->filter_bank[c->filter_length*phase_count]= c->filter_bank[c->filter_length - 1];
}
c->compensation_distance= 0;
c->src_incr= out_rate;
c->ideal_dst_incr= c->dst_incr= in_rate * phase_count;
c->index= -phase_count*((c->filter_length-1)/2);
c->frac= 0;
return c;
error:
av_free(c->filter_bank);
av_free(c);
return NULL;
}
/*
* Construct a filter to decode a stream, constraining
* to stream length and decrypting.
*/
static fz_stream *
pdf_open_filter(fz_context *ctx, pdf_document *doc, fz_stream *chain, pdf_obj *stmobj, int num, fz_off_t offset, fz_compression_params *imparams)
{
pdf_obj *filters;
pdf_obj *params;
int orig_num, orig_gen;
filters = pdf_dict_geta(ctx, stmobj, PDF_NAME_Filter, PDF_NAME_F);
params = pdf_dict_geta(ctx, stmobj, PDF_NAME_DecodeParms, PDF_NAME_DP);
chain = pdf_open_raw_filter(ctx, chain, doc, stmobj, num, &orig_num, &orig_gen, offset);
fz_var(chain);
fz_try(ctx)
{
if (pdf_is_name(ctx, filters))
{
fz_stream *chain2 = chain;
chain = NULL;
chain = build_filter(ctx, chain2, doc, filters, params, orig_num, orig_gen, imparams);
}
else if (pdf_array_len(ctx, filters) > 0)
{
fz_stream *chain2 = chain;
chain = NULL;
chain = build_filter_chain(ctx, chain2, doc, filters, params, orig_num, orig_gen, imparams);
}
}
fz_catch(ctx)
{
fz_drop_stream(ctx, chain);
fz_rethrow(ctx);
}
return chain;
}
void run__opexpr_to_pxffilter__positive(Oid dbop, PxfOperatorCode expectedPxfOp)
{
PxfFilterDesc *filter = (PxfFilterDesc*) palloc0(sizeof(PxfFilterDesc));
Var *arg_var = build_var(INT2OID, 1);
char* const_value = strdup("1984"); /* will be free'd by const_to_str */
Const* arg_const = build_const(INT2OID, const_value);
OpExpr *expr = build_op_expr(arg_var, arg_const, dbop);
PxfFilterDesc* expected = build_filter(
PXF_ATTR_CODE, 1, NULL,
PXF_CONST_CODE, 0, "1984",
expectedPxfOp);
/* run test */
assert_true(opexpr_to_pxffilter(expr, filter));
compare_filters(filter, expected);
pxf_free_filter(expected);
pxf_free_filter(filter);
list_free_deep(expr->args); /* free all args */
pfree(expr);
}
static ResampleContext *resample_init(ResampleContext *c, int out_rate, int in_rate, int filter_size, int phase_shift, int linear,
double cutoff0, enum AVSampleFormat format, enum SwrFilterType filter_type, double kaiser_beta,
double precision, int cheby, int exact_rational)
{
double cutoff = cutoff0? cutoff0 : 0.97;
double factor= FFMIN(out_rate * cutoff / in_rate, 1.0);
int phase_count= 1<<phase_shift;
int phase_count_compensation = phase_count;
if (exact_rational) {
int phase_count_exact, phase_count_exact_den;
av_reduce(&phase_count_exact, &phase_count_exact_den, out_rate, in_rate, INT_MAX);
if (phase_count_exact <= phase_count) {
phase_count_compensation = phase_count_exact * (phase_count / phase_count_exact);
phase_count = phase_count_exact;
}
}
if (!c || c->phase_count != phase_count || c->linear!=linear || c->factor != factor
|| c->filter_length != FFMAX((int)ceil(filter_size/factor), 1) || c->format != format
|| c->filter_type != filter_type || c->kaiser_beta != kaiser_beta) {
c = av_mallocz(sizeof(*c));
if (!c)
return NULL;
c->format= format;
c->felem_size= av_get_bytes_per_sample(c->format);
switch(c->format){
case AV_SAMPLE_FMT_S16P:
c->filter_shift = 15;
break;
case AV_SAMPLE_FMT_S32P:
c->filter_shift = 30;
break;
case AV_SAMPLE_FMT_FLTP:
case AV_SAMPLE_FMT_DBLP:
c->filter_shift = 0;
break;
default:
av_log(NULL, AV_LOG_ERROR, "Unsupported sample format\n");
av_assert0(0);
}
if (filter_size/factor > INT32_MAX/256) {
av_log(NULL, AV_LOG_ERROR, "Filter length too large\n");
goto error;
}
c->phase_count = phase_count;
c->linear = linear;
c->factor = factor;
c->filter_length = FFMAX((int)ceil(filter_size/factor), 1);
c->filter_alloc = FFALIGN(c->filter_length, 8);
c->filter_bank = av_calloc(c->filter_alloc, (phase_count+1)*c->felem_size);
c->filter_type = filter_type;
c->kaiser_beta = kaiser_beta;
c->phase_count_compensation = phase_count_compensation;
if (!c->filter_bank)
goto error;
if (build_filter(c, (void*)c->filter_bank, factor, c->filter_length, c->filter_alloc, phase_count, 1<<c->filter_shift, filter_type, kaiser_beta))
goto error;
memcpy(c->filter_bank + (c->filter_alloc*phase_count+1)*c->felem_size, c->filter_bank, (c->filter_alloc-1)*c->felem_size);
memcpy(c->filter_bank + (c->filter_alloc*phase_count )*c->felem_size, c->filter_bank + (c->filter_alloc - 1)*c->felem_size, c->felem_size);
}
c->compensation_distance= 0;
if(!av_reduce(&c->src_incr, &c->dst_incr, out_rate, in_rate * (int64_t)phase_count, INT32_MAX/2))
goto error;
while (c->dst_incr < (1<<20) && c->src_incr < (1<<20)) {
c->dst_incr *= 2;
c->src_incr *= 2;
}
c->ideal_dst_incr = c->dst_incr;
c->dst_incr_div = c->dst_incr / c->src_incr;
c->dst_incr_mod = c->dst_incr % c->src_incr;
c->index= -phase_count*((c->filter_length-1)/2);
c->frac= 0;
swri_resample_dsp_init(c);
return c;
error:
av_freep(&c->filter_bank);
av_free(c);
return NULL;
}
