static void
gst_dtsdec_class_init (GstDtsDecClass * klass)
{
GObjectClass *gobject_class;
GstElementClass *gstelement_class;
GstAudioDecoderClass *gstbase_class;
guint cpuflags;
gobject_class = (GObjectClass *) klass;
gstelement_class = (GstElementClass *) klass;
gstbase_class = (GstAudioDecoderClass *) klass;
gobject_class->set_property = gst_dtsdec_set_property;
gobject_class->get_property = gst_dtsdec_get_property;
gst_element_class_add_static_pad_template (gstelement_class, &sink_factory);
gst_element_class_add_static_pad_template (gstelement_class, &src_factory);
gst_element_class_set_static_metadata (gstelement_class, "DTS audio decoder",
"Codec/Decoder/Audio",
"Decodes DTS audio streams",
"Jan Schmidt <*****@*****.**>, "
"Ronald Bultje <*****@*****.**>");
gstbase_class->start = GST_DEBUG_FUNCPTR (gst_dtsdec_start);
gstbase_class->stop = GST_DEBUG_FUNCPTR (gst_dtsdec_stop);
gstbase_class->set_format = GST_DEBUG_FUNCPTR (gst_dtsdec_set_format);
gstbase_class->parse = GST_DEBUG_FUNCPTR (gst_dtsdec_parse);
gstbase_class->handle_frame = GST_DEBUG_FUNCPTR (gst_dtsdec_handle_frame);
/**
* GstDtsDec::drc
*
* Set to true to apply the recommended DTS dynamic range compression
* to the audio stream. Dynamic range compression makes loud sounds
* softer and soft sounds louder, so you can more easily listen
* to the stream without disturbing other people.
*/
g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_DRC,
g_param_spec_boolean ("drc", "Dynamic Range Compression",
"Use Dynamic Range Compression", FALSE,
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
klass->dts_cpuflags = 0;
#if HAVE_ORC
cpuflags = orc_target_get_default_flags (orc_target_get_by_name ("mmx"));
if (cpuflags & ORC_TARGET_MMX_MMX)
klass->dts_cpuflags |= MM_ACCEL_X86_MMX;
if (cpuflags & ORC_TARGET_MMX_3DNOW)
klass->dts_cpuflags |= MM_ACCEL_X86_3DNOW;
if (cpuflags & ORC_TARGET_MMX_MMXEXT)
klass->dts_cpuflags |= MM_ACCEL_X86_MMXEXT;
#else
cpuflags = 0;
klass->dts_cpuflags = 0;
#endif
GST_LOG ("CPU flags: dts=%08x, orc=%08x", klass->dts_cpuflags, cpuflags);
}
static void
change_context (GstPostProc * postproc, gint width, gint height)
{
guint mmx_flags;
guint altivec_flags;
gint ppflags;
GST_DEBUG_OBJECT (postproc, "change_context, width:%d, height:%d",
width, height);
if ((width != postproc->width) && (height != postproc->height)) {
if (postproc->context)
pp_free_context (postproc->context);
#ifdef HAVE_ORC
mmx_flags = orc_target_get_default_flags (orc_target_get_by_name ("mmx"));
altivec_flags =
orc_target_get_default_flags (orc_target_get_by_name ("altivec"));
ppflags = (mmx_flags & ORC_TARGET_MMX_MMX ? PP_CPU_CAPS_MMX : 0)
| (mmx_flags & ORC_TARGET_MMX_MMXEXT ? PP_CPU_CAPS_MMX2 : 0)
| (mmx_flags & ORC_TARGET_MMX_3DNOW ? PP_CPU_CAPS_3DNOW : 0)
| (altivec_flags & ORC_TARGET_ALTIVEC_ALTIVEC ? PP_CPU_CAPS_ALTIVEC :
0);
#else
mmx_flags = 0;
altivec_flags = 0;
ppflags = 0;
#endif
postproc->context = pp_get_context (width, height, PP_FORMAT_420 | ppflags);
postproc->width = width;
postproc->height = height;
postproc->ystride = ROUND_UP_4 (width);
postproc->ustride = ROUND_UP_8 (width) / 2;
postproc->vstride = ROUND_UP_8 (postproc->ystride) / 2;
postproc->ysize = postproc->ystride * ROUND_UP_2 (height);
postproc->usize = postproc->ustride * ROUND_UP_2 (height) / 2;
postproc->vsize = postproc->vstride * ROUND_UP_2 (height) / 2;
GST_DEBUG_OBJECT (postproc, "new strides are (YUV) : %d %d %d",
postproc->ystride, postproc->ustride, postproc->vstride);
}
}
static void
gst_deinterlace_method_greedy_l_class_init (GstDeinterlaceMethodGreedyLClass *
klass)
{
GstDeinterlaceMethodClass *dim_class = (GstDeinterlaceMethodClass *) klass;
GObjectClass *gobject_class = (GObjectClass *) klass;
#ifdef BUILD_X86_ASM
guint cpu_flags =
orc_target_get_default_flags (orc_target_get_by_name ("mmx"));
#endif
gobject_class->set_property = gst_deinterlace_method_greedy_l_set_property;
gobject_class->get_property = gst_deinterlace_method_greedy_l_get_property;
g_object_class_install_property (gobject_class, PROP_MAX_COMB,
g_param_spec_uint ("max-comb",
"Max comb",
"Max Comb", 0, 255, 15, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)
);
dim_class->fields_required = 4;
dim_class->name = "Motion Adaptive: Simple Detection";
dim_class->nick = "greedyl";
dim_class->latency = 1;
dim_class->deinterlace_frame_yuy2 = deinterlace_frame_di_greedy_packed;
dim_class->deinterlace_frame_yvyu = deinterlace_frame_di_greedy_packed;
dim_class->deinterlace_frame_uyvy = deinterlace_frame_di_greedy_packed;
dim_class->deinterlace_frame_y444 = deinterlace_frame_di_greedy_planar;
dim_class->deinterlace_frame_y42b = deinterlace_frame_di_greedy_planar;
dim_class->deinterlace_frame_i420 = deinterlace_frame_di_greedy_planar;
dim_class->deinterlace_frame_yv12 = deinterlace_frame_di_greedy_planar;
dim_class->deinterlace_frame_y41b = deinterlace_frame_di_greedy_planar;
dim_class->deinterlace_frame_ayuv = deinterlace_frame_di_greedy_planar;
dim_class->deinterlace_frame_argb = deinterlace_frame_di_greedy_packed;
dim_class->deinterlace_frame_rgba = deinterlace_frame_di_greedy_packed;
dim_class->deinterlace_frame_abgr = deinterlace_frame_di_greedy_packed;
dim_class->deinterlace_frame_bgra = deinterlace_frame_di_greedy_packed;
dim_class->deinterlace_frame_rgb = deinterlace_frame_di_greedy_packed;
dim_class->deinterlace_frame_bgr = deinterlace_frame_di_greedy_packed;
#ifdef BUILD_X86_ASM
if (cpu_flags & ORC_TARGET_MMX_MMXEXT) {
klass->scanline = deinterlace_greedy_scanline_mmxext;
} else if (cpu_flags & ORC_TARGET_MMX_MMX) {
klass->scanline = deinterlace_greedy_scanline_mmx;
} else {
klass->scanline = deinterlace_greedy_scanline_c;
}
#else
klass->scanline = deinterlace_greedy_scanline_c;
#endif
}
static void
gst_deinterlace_method_greedy_h_class_init (GstDeinterlaceMethodGreedyHClass *
klass)
{
GstDeinterlaceMethodClass *dim_class = (GstDeinterlaceMethodClass *) klass;
GObjectClass *gobject_class = (GObjectClass *) klass;
#ifdef BUILD_X86_ASM
guint cpu_flags =
orc_target_get_default_flags (orc_target_get_by_name ("mmx"));
#endif
gobject_class->set_property = gst_deinterlace_method_greedy_h_set_property;
gobject_class->get_property = gst_deinterlace_method_greedy_h_get_property;
g_object_class_install_property (gobject_class, PROP_MAX_COMB,
g_param_spec_uint ("max-comb",
"Max comb",
"Max Comb", 0, 255, 5, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)
);
g_object_class_install_property (gobject_class, PROP_MOTION_THRESHOLD,
g_param_spec_uint ("motion-threshold",
"Motion Threshold",
"Motion Threshold",
0, 255, 25, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)
);
g_object_class_install_property (gobject_class, PROP_MOTION_SENSE,
g_param_spec_uint ("motion-sense",
"Motion Sense",
"Motion Sense",
0, 255, 30, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)
);
dim_class->fields_required = 4;
dim_class->name = "Motion Adaptive: Advanced Detection";
dim_class->nick = "greedyh";
dim_class->latency = 1;
dim_class->deinterlace_frame_yuy2 = deinterlace_frame_di_greedyh_packed;
dim_class->deinterlace_frame_yvyu = deinterlace_frame_di_greedyh_packed;
dim_class->deinterlace_frame_uyvy = deinterlace_frame_di_greedyh_packed;
dim_class->deinterlace_frame_ayuv = deinterlace_frame_di_greedyh_packed;
dim_class->deinterlace_frame_y444 = deinterlace_frame_di_greedyh_planar;
dim_class->deinterlace_frame_i420 = deinterlace_frame_di_greedyh_planar;
dim_class->deinterlace_frame_yv12 = deinterlace_frame_di_greedyh_planar;
dim_class->deinterlace_frame_y42b = deinterlace_frame_di_greedyh_planar;
dim_class->deinterlace_frame_y41b = deinterlace_frame_di_greedyh_planar;
#ifdef BUILD_X86_ASM
if (cpu_flags & ORC_TARGET_MMX_MMXEXT) {
klass->scanline_yuy2 = greedyh_scanline_MMXEXT_yuy2;
klass->scanline_uyvy = greedyh_scanline_MMXEXT_uyvy;
} else if (cpu_flags & ORC_TARGET_MMX_3DNOW) {
klass->scanline_yuy2 = greedyh_scanline_3DNOW_yuy2;
klass->scanline_uyvy = greedyh_scanline_3DNOW_uyvy;
} else if (cpu_flags & ORC_TARGET_MMX_MMX) {
klass->scanline_yuy2 = greedyh_scanline_MMX_yuy2;
klass->scanline_uyvy = greedyh_scanline_MMX_uyvy;
} else {
klass->scanline_yuy2 = greedyh_scanline_C_yuy2;
klass->scanline_uyvy = greedyh_scanline_C_uyvy;
}
#else
klass->scanline_yuy2 = greedyh_scanline_C_yuy2;
klass->scanline_uyvy = greedyh_scanline_C_uyvy;
#endif
/* TODO: MMX implementation of these two */
klass->scanline_ayuv = greedyh_scanline_C_ayuv;
klass->scanline_planar_y = greedyh_scanline_C_planar_y;
klass->scanline_planar_uv = greedyh_scanline_C_planar_uv;
}
double
orc_test_performance_full (OrcProgram *program, int flags,
const char *target_name)
{
OrcExecutor *ex;
int n;
int m;
OrcArray *dest_exec[4] = { NULL, NULL, NULL, NULL };
OrcArray *dest_emul[4] = { NULL, NULL, NULL, NULL };
OrcArray *src[8] = { NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL };
int i, j;
OrcCompileResult result;
OrcProfile prof;
double ave, std;
OrcTarget *target;
int misalignment;
ORC_DEBUG ("got here");
target = orc_target_get_by_name (target_name);
if (!(flags & ORC_TEST_FLAGS_BACKUP)) {
unsigned int flags;
flags = orc_target_get_default_flags (target);
result = orc_program_compile_full (program, target, flags);
if (!ORC_COMPILE_RESULT_IS_SUCCESSFUL(result)) {
//printf("compile failed\n");
orc_program_reset (program);
return 0;
}
}
if (program->constant_n > 0) {
n = program->constant_n;
} else {
//n = 64 + (orc_random(&rand_context)&0xf);
n = 1000;
}
ex = orc_executor_new (program);
orc_executor_set_n (ex, n);
if (program->is_2d) {
if (program->constant_m > 0) {
m = program->constant_m;
} else {
m = 8 + (orc_random(&rand_context)&0xf);
}
} else {
m = 1;
}
orc_executor_set_m (ex, m);
ORC_DEBUG("size %d %d", ex->n, ex->params[ORC_VAR_A1]);
misalignment = 0;
for(i=0;i<ORC_N_VARIABLES;i++){
if (program->vars[i].name == NULL) continue;
if (program->vars[i].vartype == ORC_VAR_TYPE_SRC) {
src[i-ORC_VAR_S1] = orc_array_new (n, m, program->vars[i].size,
misalignment);
orc_array_set_random (src[i-ORC_VAR_S1], &rand_context);
misalignment++;
} else if (program->vars[i].vartype == ORC_VAR_TYPE_DEST) {
dest_exec[i-ORC_VAR_D1] = orc_array_new (n, m, program->vars[i].size,
misalignment);
orc_array_set_pattern (dest_exec[i], ORC_OOB_VALUE);
dest_emul[i-ORC_VAR_D1] = orc_array_new (n, m, program->vars[i].size,
misalignment);
orc_array_set_pattern (dest_emul[i], ORC_OOB_VALUE);
misalignment++;
} else if (program->vars[i].vartype == ORC_VAR_TYPE_PARAM) {
orc_executor_set_param (ex, i, 2);
}
}
ORC_DEBUG ("running");
orc_profile_init (&prof);
for(i=0;i<10;i++){
orc_executor_set_n (ex, n);
orc_executor_set_m (ex, m);
for(j=0;j<ORC_N_VARIABLES;j++){
if (program->vars[j].vartype == ORC_VAR_TYPE_DEST) {
orc_executor_set_array (ex, j, dest_exec[j-ORC_VAR_D1]->data);
orc_executor_set_stride (ex, j, dest_exec[j-ORC_VAR_D1]->stride);
}
if (program->vars[j].vartype == ORC_VAR_TYPE_SRC) {
orc_executor_set_array (ex, j, src[j-ORC_VAR_S1]->data);
orc_executor_set_stride (ex, j, src[j-ORC_VAR_S1]->stride);
}
}
if (flags & ORC_TEST_FLAGS_BACKUP) {
orc_profile_start (&prof);
orc_executor_run_backup (ex);
orc_profile_stop (&prof);
} else if (flags & ORC_TEST_FLAGS_EMULATE) {
orc_profile_start (&prof);
orc_executor_emulate (ex);
orc_profile_stop (&prof);
} else {
orc_profile_start (&prof);
orc_executor_run (ex);
orc_profile_stop (&prof);
}
}
ORC_DEBUG ("done running");
orc_profile_get_ave_std (&prof, &ave, &std);
for(i=0;i<4;i++){
if (dest_exec[i]) orc_array_free (dest_exec[i]);
if (dest_emul[i]) orc_array_free (dest_emul[i]);
}
for(i=0;i<8;i++){
if (src[i]) orc_array_free (src[i]);
}
orc_executor_free (ex);
orc_program_reset (program);
return ave/(n*m);
}
OrcTestResult
orc_test_compare_output_full (OrcProgram *program, int flags)
{
OrcExecutor *ex;
int n;
int m;
OrcArray *dest_exec[4] = { NULL, NULL, NULL, NULL };
OrcArray *dest_emul[4] = { NULL, NULL, NULL, NULL };
OrcArray *src[8] = { NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL };
int i;
int j;
int k;
int have_dest = FALSE;
OrcCompileResult result;
int have_acc = FALSE;
int acc_exec = 0, acc_emul = 0;
int ret = ORC_TEST_OK;
int bad = 0;
int misalignment;
ORC_DEBUG ("got here");
{
OrcTarget *target;
unsigned int flags;
target = orc_target_get_default ();
flags = orc_target_get_default_flags (target);
result = orc_program_compile_full (program, target, flags);
if (ORC_COMPILE_RESULT_IS_FATAL(result)) {
ret = ORC_TEST_FAILED;
goto out;
}
if (!ORC_COMPILE_RESULT_IS_SUCCESSFUL(result)) {
ret = ORC_TEST_INDETERMINATE;
goto out;
}
}
if (program->constant_n > 0) {
n = program->constant_n;
} else {
n = 64 + (orc_random(&rand_context)&0xf);
}
ex = orc_executor_new (program);
orc_executor_set_n (ex, n);
if (program->is_2d) {
if (program->constant_m > 0) {
m = program->constant_m;
} else {
m = 8 + (orc_random(&rand_context)&0xf);
}
} else {
m = 1;
}
orc_executor_set_m (ex, m);
ORC_DEBUG("size %d %d", ex->n, ex->params[ORC_VAR_A1]);
misalignment = 0;
for(i=0;i<ORC_N_VARIABLES;i++){
if (program->vars[i].name == NULL) continue;
if (program->vars[i].vartype == ORC_VAR_TYPE_SRC) {
src[i-ORC_VAR_S1] = orc_array_new (n, m, program->vars[i].size,
misalignment);
orc_array_set_random (src[i-ORC_VAR_S1], &rand_context);
misalignment++;
} else if (program->vars[i].vartype == ORC_VAR_TYPE_DEST) {
dest_exec[i-ORC_VAR_D1] = orc_array_new (n, m, program->vars[i].size,
misalignment);
orc_array_set_pattern (dest_exec[i], ORC_OOB_VALUE);
dest_emul[i-ORC_VAR_D1] = orc_array_new (n, m, program->vars[i].size,
misalignment);
orc_array_set_pattern (dest_emul[i], ORC_OOB_VALUE);
misalignment++;
} else if (program->vars[i].vartype == ORC_VAR_TYPE_PARAM) {
switch (program->vars[i].param_type) {
case ORC_PARAM_TYPE_INT:
orc_executor_set_param (ex, i, 2);
break;
case ORC_PARAM_TYPE_FLOAT:
orc_executor_set_param_float (ex, i, 2.0);
break;
case ORC_PARAM_TYPE_INT64:
orc_executor_set_param_int64 (ex, i, 2);
break;
case ORC_PARAM_TYPE_DOUBLE:
orc_executor_set_param_double (ex, i, 2.0);
break;
}
}
}
for(i=0;i<ORC_N_VARIABLES;i++){
if (program->vars[i].vartype == ORC_VAR_TYPE_DEST) {
orc_executor_set_array (ex, i, dest_exec[i-ORC_VAR_D1]->data);
orc_executor_set_stride (ex, i, dest_exec[i-ORC_VAR_D1]->stride);
have_dest = TRUE;
}
if (program->vars[i].vartype == ORC_VAR_TYPE_SRC) {
orc_executor_set_array (ex, i, src[i-ORC_VAR_S1]->data);
orc_executor_set_stride (ex, i, src[i-ORC_VAR_S1]->stride);
}
}
ORC_DEBUG ("running");
if (flags & ORC_TEST_FLAGS_BACKUP) {
orc_executor_run_backup (ex);
} else {
orc_executor_run (ex);
}
ORC_DEBUG ("done running");
for(i=0;i<ORC_N_VARIABLES;i++){
if (program->vars[i].vartype == ORC_VAR_TYPE_ACCUMULATOR) {
acc_exec = ex->accumulators[0];
have_acc = TRUE;
}
}
for(i=0;i<ORC_N_VARIABLES;i++){
if (program->vars[i].vartype == ORC_VAR_TYPE_DEST) {
orc_executor_set_array (ex, i, dest_emul[i]->data);
orc_executor_set_stride (ex, i, dest_emul[i]->stride);
}
if (program->vars[i].vartype == ORC_VAR_TYPE_SRC) {
ORC_DEBUG("setting array %p", src[i-ORC_VAR_S1]->data);
orc_executor_set_array (ex, i, src[i-ORC_VAR_S1]->data);
orc_executor_set_stride (ex, i, src[i-ORC_VAR_S1]->stride);
}
}
orc_executor_emulate (ex);
for(i=0;i<ORC_N_VARIABLES;i++){
if (program->vars[i].vartype == ORC_VAR_TYPE_ACCUMULATOR) {
acc_emul = ex->accumulators[0];
}
}
for(k=ORC_VAR_D1;k<ORC_VAR_D1+4;k++){
if (program->vars[k].size > 0) {
if (!orc_array_compare (dest_exec[k-ORC_VAR_D1], dest_emul[k-ORC_VAR_D1], flags)) {
printf("dest array %d bad\n", k);
bad = TRUE;
}
if (!orc_array_check_out_of_bounds (dest_exec[k-ORC_VAR_D1])) {
printf("out of bounds failure\n");
ret = ORC_TEST_FAILED;
}
}
}
if (bad) {
for(j=0;j<m;j++){
for(i=0;i<n;i++){
orc_uint64 a,b;
int l;
int line_bad = 0;
printf("%2d %2d:", i, j);
for(l=ORC_VAR_S1;l<ORC_VAR_S1+8;l++){
if (program->vars[l].size > 0) {
if (flags & ORC_TEST_FLAGS_FLOAT) {
print_array_val_float (src[l-ORC_VAR_S1], i, j);
} else {
print_array_val_hex (src[l-ORC_VAR_S1], i, j);
}
}
}
printf(" ->");
for(l=ORC_VAR_D1;l<ORC_VAR_D1+4;l++){
if (program->vars[l].size > 0) {
if (flags & ORC_TEST_FLAGS_FLOAT) {
a = print_array_val_float (dest_emul[l-ORC_VAR_D1], i, j);
b = print_array_val_float (dest_exec[l-ORC_VAR_D1], i, j);
if (!float_compare (dest_emul[l-ORC_VAR_D1], dest_exec[l-ORC_VAR_D1], i, j) != 0) {
line_bad = TRUE;
}
} else {
a = print_array_val_hex (dest_emul[l-ORC_VAR_D1], i, j);
b = print_array_val_hex (dest_exec[l-ORC_VAR_D1], i, j);
if (a != b) {
line_bad = TRUE;
}
}
}
}
if (line_bad) {
printf(" *");
}
printf("\n");
}
}
ret = ORC_TEST_FAILED;
}
if (have_acc) {
if (acc_emul != acc_exec) {
for(j=0;j<m;j++){
for(i=0;i<n;i++){
printf("%2d %2d:", i, j);
for(k=0;k<ORC_N_VARIABLES;k++){
if (program->vars[k].name == NULL) continue;
if (program->vars[k].vartype == ORC_VAR_TYPE_SRC &&
program->vars[k].size > 0) {
if (flags & ORC_TEST_FLAGS_FLOAT) {
print_array_val_float (src[k-ORC_VAR_S1], i, j);
} else {
print_array_val_signed (src[k-ORC_VAR_S1], i, j);
}
}
}
printf(" -> acc\n");
}
}
printf("acc %d %d\n", acc_emul, acc_exec);
ret = ORC_TEST_FAILED;
}
}
if (ret == ORC_TEST_FAILED) {
printf("%s", orc_program_get_asm_code (program));
}
for(i=0;i<4;i++){
if (dest_exec[i]) orc_array_free (dest_exec[i]);
if (dest_emul[i]) orc_array_free (dest_emul[i]);
}
for(i=0;i<8;i++){
if (src[i]) orc_array_free (src[i]);
}
orc_executor_free (ex);
out:
orc_program_reset (program);
return ret;
}
OrcTestResult
orc_test_gcc_compile (OrcProgram *p)
{
char cmd[200];
char *base;
char source_filename[100];
char obj_filename[100];
char dis_filename[100];
char dump_filename[100];
char dump_dis_filename[100];
int ret;
FILE *file;
OrcCompileResult result;
OrcTarget *target;
unsigned int flags;
base = "temp-orc-test";
sprintf(source_filename, "%s-source.s", base);
sprintf(obj_filename, "%s.o", base);
sprintf(dis_filename, "%s-source.dis", base);
sprintf(dump_filename, "%s-dump.bin", base);
sprintf(dump_dis_filename, "%s-dump.dis", base);
target = orc_target_get_default ();
flags = orc_target_get_default_flags (target);
flags |= ORC_TARGET_CLEAN_COMPILE;
if (strcmp (orc_target_get_name (target), "sse") == 0) {
flags |= ORC_TARGET_SSE_SHORT_JUMPS;
}
if (strcmp (orc_target_get_name (target), "mmx") == 0) {
flags |= ORC_TARGET_MMX_SHORT_JUMPS;
}
result = orc_program_compile_full (p, target, flags);
if (ORC_COMPILE_RESULT_IS_FATAL(result)) {
return ORC_TEST_FAILED;
}
if (!ORC_COMPILE_RESULT_IS_SUCCESSFUL(result)) {
return ORC_TEST_INDETERMINATE;
}
fflush (stdout);
file = fopen (source_filename, "w");
fprintf(file, "%s", orc_program_get_asm_code (p));
fclose (file);
file = fopen (dump_filename, "w");
ret = fwrite(p->orccode->code, p->orccode->code_size, 1, file);
fclose (file);
#if defined(HAVE_POWERPC)
sprintf (cmd, "gcc -Wa,-mregnames -Wall -c %s -o %s", source_filename,
obj_filename);
#else
sprintf (cmd, "gcc -Wall -c %s -o %s", source_filename,
obj_filename);
#endif
ret = system (cmd);
if (ret != 0) {
ORC_ERROR ("gcc failed");
printf("%s\n", orc_program_get_asm_code (p));
return ORC_TEST_FAILED;
}
#if 0
sprintf (cmd, "objdump -dr %s | sed 's/^[ 0-9a-f]*:/XXX:/' >%s", obj_filename, dis_filename);
#else
sprintf (cmd, "objdump -dr %s >%s", obj_filename, dis_filename);
#endif
ret = system (cmd);
if (ret != 0) {
ORC_ERROR ("objdump failed");
return ORC_TEST_FAILED;
}
sprintf (cmd, "objcopy -I binary "
#ifdef HAVE_I386
"-O elf32-i386 -B i386 "
#elif defined(HAVE_AMD64)
"-O elf64-x86-64 -B i386 "
#elif defined(HAVE_POWERPC)
"-O elf32-powerpc -B powerpc "
#else
/* FIXME */
#endif
"--rename-section .data=.text "
"--redefine-sym _binary_temp_orc_test_dump_bin_start=%s "
"%s %s", p->name, dump_filename, obj_filename);
ret = system (cmd);
if (ret != 0) {
printf("objcopy failed\n");
return ORC_TEST_FAILED;
}
#if 0
sprintf (cmd, "objdump -Dr %s | sed 's/^[ 0-9a-f]*:/XXX:/' >%s", obj_filename, dump_dis_filename);
#else
sprintf (cmd, "objdump -Dr %s >%s", obj_filename, dump_dis_filename);
#endif
ret = system (cmd);
if (ret != 0) {
printf("objdump failed\n");
return ORC_TEST_FAILED;
}
sprintf (cmd, "diff -u %s %s", dis_filename, dump_dis_filename);
ret = system (cmd);
if (ret != 0) {
printf("diff failed\n");
return ORC_TEST_FAILED;
}
remove (source_filename);
remove (obj_filename);
remove (dis_filename);
remove (dump_filename);
remove (dump_dis_filename);
return ORC_TEST_OK;
}
OrcTestResult
orc_test_gcc_compile_c64x (OrcProgram *p)
{
char cmd[300];
char *base;
char source_filename[100];
char obj_filename[100];
char dis_filename[100];
char dump_filename[100];
char dump_dis_filename[100];
int ret;
FILE *file;
OrcCompileResult result;
OrcTarget *target;
unsigned int flags;
base = "temp-orc-test";
sprintf(source_filename, "%s-source.s", base);
sprintf(obj_filename, "%s-source.obj", base);
sprintf(dis_filename, "%s-source.dis", base);
sprintf(dump_filename, "%s-dump.bin", base);
sprintf(dump_dis_filename, "%s-dump.dis", base);
target = orc_target_get_by_name ("c64x");
flags = orc_target_get_default_flags (target);
result = orc_program_compile_full (p, target, flags);
if (!ORC_COMPILE_RESULT_IS_SUCCESSFUL(result)) {
return ORC_TEST_INDETERMINATE;
}
fflush (stdout);
file = fopen (source_filename, "w");
fprintf(file, "%s", orc_program_get_asm_code (p));
fclose (file);
file = fopen (dump_filename, "w");
ret = fwrite(p->orccode->code, p->orccode->code_size, 1, file);
fclose (file);
sprintf (cmd, C64X_PREFIX "cl6x -mv=6400+ "
"-c %s", source_filename);
ret = system (cmd);
if (ret != 0) {
ORC_ERROR ("compiler failed");
//printf("%s\n", orc_program_get_asm_code (p));
return ORC_TEST_INDETERMINATE;
}
sprintf (cmd, C64X_PREFIX "dis6x %s >%s", obj_filename, dis_filename);
ret = system (cmd);
if (ret != 0) {
ORC_ERROR ("objdump failed");
return ORC_TEST_INDETERMINATE;
}
#if 0
sprintf (cmd, C64X_PREFIX "objcopy -I binary "
"-O elf32-littlearm -B arm "
"--rename-section .data=.text "
"--redefine-sym _binary_temp_orc_test_dump_bin_start=%s "
"%s %s", p->name, dump_filename, obj_filename);
ret = system (cmd);
if (ret != 0) {
printf("objcopy failed\n");
return ORC_TEST_FAILED;
}
#endif
#if 0
sprintf (cmd, C64X_PREFIX "dis6x %s >%s", dump_filename, dump_dis_filename);
ret = system (cmd);
if (ret != 0) {
printf("objdump failed\n");
return ORC_TEST_FAILED;
}
sprintf (cmd, "diff -u %s %s", dis_filename, dump_dis_filename);
ret = system (cmd);
if (ret != 0) {
printf("diff failed\n");
return ORC_TEST_FAILED;
}
#endif
remove (source_filename);
remove (obj_filename);
remove (dis_filename);
remove (dump_filename);
remove (dump_dis_filename);
return ORC_TEST_OK;
}
OrcTestResult
orc_test_gcc_compile_neon (OrcProgram *p)
{
char cmd[300];
char *base;
char source_filename[100];
char obj_filename[100];
char dis_filename[100];
char dump_filename[100];
char dump_dis_filename[100];
int ret;
FILE *file;
OrcCompileResult result;
OrcTarget *target;
unsigned int flags;
base = "temp-orc-test";
sprintf(source_filename, "%s-source.s", base);
sprintf(obj_filename, "%s.o", base);
sprintf(dis_filename, "%s-source.dis", base);
sprintf(dump_filename, "%s-dump.bin", base);
sprintf(dump_dis_filename, "%s-dump.dis", base);
target = orc_target_get_by_name ("neon");
flags = orc_target_get_default_flags (target);
flags |= ORC_TARGET_CLEAN_COMPILE;
result = orc_program_compile_full (p, target, flags);
if (!ORC_COMPILE_RESULT_IS_SUCCESSFUL(result)) {
return ORC_TEST_INDETERMINATE;
}
fflush (stdout);
file = fopen (source_filename, "w");
fprintf(file, "%s", orc_program_get_asm_code (p));
fclose (file);
file = fopen (dump_filename, "w");
ret = fwrite(p->orccode->code, p->orccode->code_size, 1, file);
fclose (file);
sprintf (cmd, PREFIX "gcc -march=armv6t2 -mcpu=cortex-a8 -mfpu=neon -Wall "
"-c %s -o %s", source_filename, obj_filename);
ret = system (cmd);
if (ret != 0) {
ORC_ERROR ("arm gcc failed");
return ORC_TEST_INDETERMINATE;
}
sprintf (cmd, PREFIX "objdump -dr %s >%s", obj_filename, dis_filename);
ret = system (cmd);
if (ret != 0) {
ORC_ERROR ("objdump failed");
return ORC_TEST_INDETERMINATE;
}
sprintf (cmd, PREFIX "objcopy -I binary "
"-O elf32-littlearm -B arm "
"--rename-section .data=.text "
"--redefine-sym _binary_temp_orc_test_dump_bin_start=%s "
"%s %s", p->name, dump_filename, obj_filename);
ret = system (cmd);
if (ret != 0) {
printf("objcopy failed\n");
return ORC_TEST_INDETERMINATE;
}
sprintf (cmd, PREFIX "objdump -Dr %s >%s", obj_filename, dump_dis_filename);
ret = system (cmd);
if (ret != 0) {
printf("objdump failed\n");
return ORC_TEST_INDETERMINATE;
}
sprintf (cmd, "diff -u %s %s", dis_filename, dump_dis_filename);
ret = system (cmd);
if (ret != 0) {
printf("diff failed\n");
return ORC_TEST_FAILED;
}
remove (source_filename);
remove (obj_filename);
remove (dis_filename);
remove (dump_filename);
remove (dump_dis_filename);
return ORC_TEST_OK;
}
static gboolean
gst_ffmpegscale_set_caps(GstBaseTransform* trans, GstCaps* incaps,
GstCaps* outcaps) {
GstFFMpegScale* scale = GST_FFMPEGSCALE(trans);
guint mmx_flags, altivec_flags, sse_flags;
gint swsflags;
gboolean ok;
g_return_val_if_fail(scale->method <
G_N_ELEMENTS(gst_ffmpegscale_method_flags), FALSE);
if (scale->ctx) {
sws_freeContext(scale->ctx);
scale->ctx = NULL;
}
scale->borders_h = 0;
scale->borders_w = 0;
ok = gst_video_format_parse_caps(incaps, &scale->in_format, &scale->in_width,
&scale->in_height);
ok &= gst_video_format_parse_caps(outcaps, &scale->out_format, &scale->out_width,
&scale->out_height);
scale->in_pixfmt = gst_ffmpeg_caps_to_pixfmt(incaps);
scale->out_pixfmt = gst_ffmpeg_caps_to_pixfmt(outcaps);
if (!ok || scale->in_pixfmt == PIX_FMT_NONE ||
scale->out_pixfmt == PIX_FMT_NONE ||
scale->in_format == GST_VIDEO_FORMAT_UNKNOWN ||
scale->out_format == GST_VIDEO_FORMAT_UNKNOWN) {
goto refuse_caps;
}
GST_DEBUG_OBJECT(scale, "format %d => %d, from=%dx%d -> to=%dx%d", scale->in_format,
scale->out_format, scale->in_width, scale->in_height, scale->out_width,
scale->out_height);
gst_ffmpegscale_fill_info(scale, scale->in_format, scale->in_width,
scale->in_height, scale->in_stride, scale->in_offset);
gst_ffmpegscale_fill_info(scale, scale->out_format, scale->out_width,
scale->out_height, scale->out_stride, scale->out_offset);
#ifdef HAVE_ORC
mmx_flags = orc_target_get_default_flags(orc_target_get_by_name("mmx"));
altivec_flags =
orc_target_get_default_flags(orc_target_get_by_name("altivec"));
sse_flags = orc_target_get_default_flags(orc_target_get_by_name("sse"));
swsflags = (mmx_flags & ORC_TARGET_MMX_MMX ? SWS_CPU_CAPS_MMX : 0)
| (mmx_flags & ORC_TARGET_MMX_MMXEXT ? SWS_CPU_CAPS_MMX2 : 0)
| (mmx_flags & ORC_TARGET_MMX_3DNOW ? SWS_CPU_CAPS_3DNOW : 0)
| (altivec_flags & ORC_TARGET_ALTIVEC_ALTIVEC ? SWS_CPU_CAPS_ALTIVEC : 0)
| (sse_flags & ORC_TARGET_SSE_SSE2 ? SWS_CPU_CAPS_SSE2 : 0);
#else
mmx_flags = 0;
altivec_flags = 0;
swsflags = 0;
#endif
if (scale->add_borders && scale->in_width > 0 && scale->in_height > 0 && scale->out_height > 0
&& scale->out_width > 0) {
gfloat ratio = scale->in_width * 1.0f / scale->in_height;
gint ratio_width = (gint)(scale->out_height * ratio);
if (ratio_width > scale->out_width) {
gint ratio_height = (gint)(scale->out_width / ratio);
scale->ctx = sws_getContext(scale->in_width, scale->in_height,
scale->in_pixfmt, scale->out_width, ratio_height, scale->out_pixfmt,
swsflags | gst_ffmpegscale_method_flags[scale->method], NULL, NULL, NULL);
if (ratio_height != scale->out_height) {
gint rows = 0;
scale->borders_h = scale->out_height - ratio_height;
rows = scale->borders_h / 2;
if (rows > 0) {
gst_video_format_add_top_border(scale->out_format, rows, scale->out_offset, scale->out_stride);
}
}
} else {
if (ratio_width != scale->out_width) {
gint cols = 0;
scale->borders_w = scale->out_width - ratio_width;
cols = scale->borders_w / 2;
if (cols > 0) {
int i = 0;
for (i = 0; i < 3; i ++) {
scale->out_offset[i] += cols * scale->out_stride[i] / scale->out_width;
}
}
}
scale->ctx = sws_getContext(scale->in_width, scale->in_height,
scale->in_pixfmt, ratio_width, scale->out_height, scale->out_pixfmt,
swsflags | gst_ffmpegscale_method_flags[scale->method], NULL, NULL, NULL);
}
} else {
scale->ctx = sws_getContext(scale->in_width, scale->in_height,
scale->in_pixfmt, scale->out_width, scale->out_height, scale->out_pixfmt,
swsflags | gst_ffmpegscale_method_flags[scale->method], NULL, NULL, NULL);
}
if (!scale->ctx) {
goto setup_failed;
}
return TRUE;
/* ERRORS */
setup_failed: {
GST_ELEMENT_ERROR(trans, LIBRARY, INIT, (NULL), (NULL));
return FALSE;
}
refuse_caps: {
GST_DEBUG_OBJECT(trans, "refused caps %" GST_PTR_FORMAT, incaps);
return FALSE;
}
}
int
main (int argc, char *argv[])
{
int i;
OrcProgram **programs;
const char *filename = NULL;
orc_init ();
orc_test_init ();
for(i=1;i<argc;i++){
if (strcmp(argv[i], "--help") == 0) {
printf("Usage:\n");
printf(" orc-bugreport [file.orc]\n");
printf("\n");
printf("Options:\n");
printf(" --help Show help options\n");
printf(" --verbose Increase debugging messages\n");
printf("\n");
printf("Environment Variables:\n");
printf(" ORC_DEBUG=<LEVEL> Set debugging level\n");
printf(" ORC_CODE=[KEYWORDS,...] Modify code generation\n");
printf(" General keywords:\n");
printf(" backup Always use backup function\n");
printf(" debug Generate debuggable code (useful for backtraces on i386)\n");
printf(" SSE keywords:\n");
printf(" -sse2 Disable SSE2\n");
printf(" -sse3 Disable SSE3\n");
printf(" -ssse3 Disable SSEE3\n");
printf(" -sse41 Disable SSE4.1\n");
printf(" -sse42 Disable SSE4.2\n");
printf(" -sse4a Disable SSE4a\n");
printf(" -sse5 Disable SSE5\n");
printf("\n");
exit (0);
}
filename = argv[i];
}
printf("Orc " VERSION " - integrated testing tool\n");
printf("Active backend: %s\n",
orc_target_get_name(orc_target_get_default()));
{
int level1, level2, level3;
orc_get_data_cache_sizes(&level1, &level2, &level3);
printf("L1 cache: %d\n", level1);
printf("L2 cache: %d\n", level2);
printf("L3 cache: %d\n", level3);
}
{
int family, model, stepping;
orc_get_cpu_family_model_stepping (&family, &model, &stepping);
printf("Family/Model/Stepping: %d/%d/%d\n", family, model, stepping);
printf("CPU name: %s\n", orc_get_cpu_name ());
}
{
int i;
int flags = orc_target_get_default_flags (orc_target_get_default());
printf("Compiler options: ");
for(i=0;i<32;i++){
if (flags & (1<<i)) {
printf("%s ", orc_target_get_flag_name (orc_target_get_default(), i));
}
}
printf("\n");
}
if (filename) {
int n;
int ret;
char *code;
code = read_file (filename);
if (!code) {
printf("orc-bugreport: could not read file %s\n", filename);
exit(1);
}
printf("Parsing %s\n", filename);
n = orc_parse (code, &programs);
for(i=0;i<n;i++){
ret = orc_test_compare_output_full (programs[i], 0);
if (!ret) {
printf("FAIL: %s\n", programs[i]->name);
error = TRUE;
}
}
} else {
printf("Opcode test:\n");
test_opcodes();
}
if (error) {
printf("Errors detected. Please send entire output to [email protected].\n");
return 1;
} else {
printf("No errors detected.\n");
return 0;
}
}
static gboolean
gst_ffmpegscale_set_caps (GstBaseTransform * trans, GstCaps * incaps,
GstCaps * outcaps)
{
GstFFMpegScale *scale = GST_FFMPEGSCALE (trans);
#ifdef HAVE_ORC
guint mmx_flags, altivec_flags;
#endif
gint swsflags;
gboolean ok;
g_return_val_if_fail (scale->method <
G_N_ELEMENTS (gst_ffmpegscale_method_flags), FALSE);
if (scale->ctx) {
sws_freeContext (scale->ctx);
scale->ctx = NULL;
}
ok = gst_video_info_from_caps (&scale->in_info, incaps);
ok &= gst_video_info_from_caps (&scale->out_info, outcaps);
scale->in_pixfmt = gst_ffmpeg_caps_to_pixfmt (incaps);
scale->out_pixfmt = gst_ffmpeg_caps_to_pixfmt (outcaps);
if (!ok || scale->in_pixfmt == AV_PIX_FMT_NONE ||
scale->out_pixfmt == AV_PIX_FMT_NONE ||
GST_VIDEO_INFO_FORMAT (&scale->in_info) == GST_VIDEO_FORMAT_UNKNOWN ||
GST_VIDEO_INFO_FORMAT (&scale->out_info) == GST_VIDEO_FORMAT_UNKNOWN)
goto refuse_caps;
GST_DEBUG_OBJECT (scale, "format %d => %d, from=%dx%d -> to=%dx%d",
GST_VIDEO_INFO_FORMAT (&scale->in_info),
GST_VIDEO_INFO_FORMAT (&scale->out_info),
GST_VIDEO_INFO_WIDTH (&scale->in_info),
GST_VIDEO_INFO_HEIGHT (&scale->in_info),
GST_VIDEO_INFO_WIDTH (&scale->out_info),
GST_VIDEO_INFO_HEIGHT (&scale->out_info));
#ifdef HAVE_ORC
mmx_flags = orc_target_get_default_flags (orc_target_get_by_name ("mmx"));
altivec_flags =
orc_target_get_default_flags (orc_target_get_by_name ("altivec"));
swsflags = (mmx_flags & ORC_TARGET_MMX_MMX ? SWS_CPU_CAPS_MMX : 0)
| (mmx_flags & ORC_TARGET_MMX_MMXEXT ? SWS_CPU_CAPS_MMX2 : 0)
| (mmx_flags & ORC_TARGET_MMX_3DNOW ? SWS_CPU_CAPS_3DNOW : 0)
| (altivec_flags & ORC_TARGET_ALTIVEC_ALTIVEC ? SWS_CPU_CAPS_ALTIVEC : 0);
#else
swsflags = 0;
#endif
scale->ctx = sws_getContext (scale->in_info.width, scale->in_info.height,
scale->in_pixfmt, scale->out_info.width, scale->out_info.height,
scale->out_pixfmt, swsflags | gst_ffmpegscale_method_flags[scale->method],
NULL, NULL, NULL);
if (!scale->ctx)
goto setup_failed;
return TRUE;
/* ERRORS */
setup_failed:
{
GST_ELEMENT_ERROR (trans, LIBRARY, INIT, (NULL), (NULL));
return FALSE;
}
refuse_caps:
{
GST_DEBUG_OBJECT (trans, "refused caps %" GST_PTR_FORMAT, incaps);
return FALSE;
}
}
void
show (OrcProgram *program)
{
OrcCompileResult result;
OrcTarget *target;
const char *target_name;
unsigned int target_flags;
int n, m;
OrcExecutor *ex;
OrcArray *dest[4] = { NULL, NULL, NULL, NULL };
OrcArray *src[8] = { NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL };
int i,j;
OrcRandomContext rand_context = { 0 };
target_name = NULL;
target = orc_target_get_by_name (target_name);
target_flags = orc_target_get_default_flags (target);
result = orc_program_compile_full (program, target, target_flags);
if (!ORC_COMPILE_RESULT_IS_SUCCESSFUL(result)) {
printf("%s: compile failed\n", program->name);
return;
}
printf("%s:\n", program->name);
if (program->constant_n > 0) {
n = program->constant_n;
} else {
n = array_n;
}
ex = orc_executor_new (program);
orc_executor_set_n (ex, n);
if (program->is_2d) {
if (program->constant_m > 0) {
m = program->constant_m;
} else {
m = 2;
}
} else {
m = 1;
}
orc_executor_set_m (ex, m);
for(i=0;i<ORC_N_VARIABLES;i++){
if (program->vars[i].name == NULL) continue;
if (program->vars[i].vartype == ORC_VAR_TYPE_SRC) {
src[i-ORC_VAR_S1] = orc_array_new (n, m, program->vars[i].size, 0);
orc_array_set_random (src[i-ORC_VAR_S1], &rand_context);
} else if (program->vars[i].vartype == ORC_VAR_TYPE_DEST) {
dest[i-ORC_VAR_D1] = orc_array_new (n, m, program->vars[i].size, 0);
orc_array_set_pattern (dest[i], ORC_OOB_VALUE);
} else if (program->vars[i].vartype == ORC_VAR_TYPE_PARAM) {
switch (program->vars[i].param_type) {
case ORC_PARAM_TYPE_INT:
orc_executor_set_param (ex, i, 2);
break;
case ORC_PARAM_TYPE_FLOAT:
orc_executor_set_param_float (ex, i, 2.0);
break;
case ORC_PARAM_TYPE_INT64:
orc_executor_set_param_int64 (ex, i, 2);
break;
case ORC_PARAM_TYPE_DOUBLE:
orc_executor_set_param_double (ex, i, 2.0);
break;
default:
ORC_ASSERT(0);
}
}
}
orc_executor_set_n (ex, n);
orc_executor_set_m (ex, m);
for(j=0;j<ORC_N_VARIABLES;j++){
if (program->vars[j].vartype == ORC_VAR_TYPE_DEST) {
orc_executor_set_array (ex, j, dest[j-ORC_VAR_D1]->data);
orc_executor_set_stride (ex, j, dest[j-ORC_VAR_D1]->stride);
}
if (program->vars[j].vartype == ORC_VAR_TYPE_SRC) {
orc_executor_set_array (ex, j, src[j-ORC_VAR_S1]->data);
orc_executor_set_stride (ex, j, src[j-ORC_VAR_S1]->stride);
}
}
orc_executor_run (ex);
{
int i,j;
for(j=0;j<m;j++){
for(i=0;i<n;i++){
int l;
printf("%2d %2d:", i, j);
for(l=ORC_VAR_S1;l<ORC_VAR_S1+8;l++){
if (program->vars[l].size > 0) {
switch (format) {
case FORMAT_FLOAT:
print_array_val_float (src[l-ORC_VAR_S1], i, j);
break;
case FORMAT_HEX:
print_array_val_hex (src[l-ORC_VAR_S1], i, j);
break;
case FORMAT_SIGNED:
print_array_val_signed (src[l-ORC_VAR_S1], i, j);
break;
case FORMAT_UNSIGNED:
print_array_val_unsigned (src[l-ORC_VAR_S1], i, j);
break;
}
}
}
printf(" ->");
for(l=ORC_VAR_D1;l<ORC_VAR_D1+4;l++){
if (program->vars[l].size > 0) {
switch (format) {
case FORMAT_FLOAT:
print_array_val_float (dest[l-ORC_VAR_D1], i, j);
break;
case FORMAT_HEX:
print_array_val_hex (dest[l-ORC_VAR_D1], i, j);
break;
case FORMAT_SIGNED:
print_array_val_signed (dest[l-ORC_VAR_D1], i, j);
break;
case FORMAT_UNSIGNED:
print_array_val_unsigned (dest[l-ORC_VAR_D1], i, j);
break;
}
}
}
printf("\n");
}
}
}
for(i=0;i<4;i++){
if (dest[i]) orc_array_free (dest[i]);
}
for(i=0;i<8;i++){
if (src[i]) orc_array_free (src[i]);
}
orc_executor_free (ex);
}
static void
gst_a52dec_class_init (GstA52DecClass * klass)
{
GObjectClass *gobject_class;
GstElementClass *gstelement_class;
GstAudioDecoderClass *gstbase_class;
guint cpuflags = 0;
gobject_class = (GObjectClass *) klass;
gstelement_class = (GstElementClass *) klass;
gstbase_class = (GstAudioDecoderClass *) klass;
gobject_class->set_property = gst_a52dec_set_property;
gobject_class->get_property = gst_a52dec_get_property;
gstbase_class->start = GST_DEBUG_FUNCPTR (gst_a52dec_start);
gstbase_class->stop = GST_DEBUG_FUNCPTR (gst_a52dec_stop);
gstbase_class->set_format = GST_DEBUG_FUNCPTR (gst_a52dec_set_format);
gstbase_class->parse = GST_DEBUG_FUNCPTR (gst_a52dec_parse);
gstbase_class->handle_frame = GST_DEBUG_FUNCPTR (gst_a52dec_handle_frame);
/**
* GstA52Dec::drc
*
* Set to true to apply the recommended Dolby Digital dynamic range compression
* to the audio stream. Dynamic range compression makes loud sounds
* softer and soft sounds louder, so you can more easily listen
* to the stream without disturbing other people.
*/
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_DRC,
g_param_spec_boolean ("drc", "Dynamic Range Compression",
"Use Dynamic Range Compression", FALSE,
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
/**
* GstA52Dec::mode
*
* Force a particular output channel configuration from the decoder. By default,
* the channel downmix (if any) is chosen automatically based on the downstream
* capabilities of the pipeline.
*/
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_MODE,
g_param_spec_enum ("mode", "Decoder Mode", "Decoding Mode (default 3f2r)",
GST_TYPE_A52DEC_MODE, A52_3F2R,
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
/**
* GstA52Dec::lfe
*
* Whether to output the LFE (Low Frequency Emitter) channel of the audio stream.
*/
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_LFE,
g_param_spec_boolean ("lfe", "LFE", "LFE", TRUE,
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
gst_element_class_add_pad_template (gstelement_class,
gst_static_pad_template_get (&sink_factory));
gst_element_class_add_pad_template (gstelement_class,
gst_static_pad_template_get (&src_factory));
gst_element_class_set_static_metadata (gstelement_class,
"ATSC A/52 audio decoder", "Codec/Decoder/Audio",
"Decodes ATSC A/52 encoded audio streams",
"David I. Lehn <*****@*****.**>");
GST_DEBUG_CATEGORY_INIT (a52dec_debug, "a52dec", 0,
"AC3/A52 software decoder");
/* If no CPU instruction based acceleration is available, end up using the
* generic software djbfft based one when available in the used liba52 */
#ifdef MM_ACCEL_DJBFFT
klass->a52_cpuflags = MM_ACCEL_DJBFFT;
#elif defined(A52_ACCEL_DETECT)
klass->a52_cpuflags = A52_ACCEL_DETECT;
#else
klass->a52_cpuflags = 0;
#endif
#if HAVE_ORC && !defined(A52_ACCEL_DETECT)
cpuflags = orc_target_get_default_flags (orc_target_get_by_name ("mmx"));
if (cpuflags & ORC_TARGET_MMX_MMX)
klass->a52_cpuflags |= MM_ACCEL_X86_MMX;
if (cpuflags & ORC_TARGET_MMX_3DNOW)
klass->a52_cpuflags |= MM_ACCEL_X86_3DNOW;
if (cpuflags & ORC_TARGET_MMX_MMXEXT)
klass->a52_cpuflags |= MM_ACCEL_X86_MMXEXT;
#endif
GST_LOG ("CPU flags: a52=%08x, orc=%08x", klass->a52_cpuflags, cpuflags);
}
