summaryrefslogtreecommitdiffstats
path: root/gst-libs
diff options
context:
space:
mode:
Diffstat (limited to 'gst-libs')
-rw-r--r--gst-libs/gst/audio/Makefile.am2
-rw-r--r--gst-libs/gst/audio/audio.c2
-rw-r--r--gst-libs/gst/idct/Makefile.am2
-rw-r--r--gst-libs/gst/idct/ieeetest.c2
-rw-r--r--gst-libs/gst/idct/mmx32idct.c958
-rw-r--r--gst-libs/gst/resample/Makefile.am2
-rw-r--r--gst-libs/gst/resample/dtos.c4
-rw-r--r--gst-libs/gst/resample/functable.c58
-rw-r--r--gst-libs/gst/resample/resample.c40
-rw-r--r--gst-libs/gst/resample/test.c34
-rw-r--r--gst-libs/gst/riff/Makefile.am2
-rw-r--r--gst-libs/gst/riff/riff.c38
-rw-r--r--gst-libs/gst/riff/riffencode.c2
-rw-r--r--gst-libs/gst/riff/riffparse.c32
-rw-r--r--gst-libs/gst/riff/riffutil.c2
15 files changed, 590 insertions, 590 deletions
diff --git a/gst-libs/gst/audio/Makefile.am b/gst-libs/gst/audio/Makefile.am
index 082ace35..b6e7b47d 100644
--- a/gst-libs/gst/audio/Makefile.am
+++ b/gst-libs/gst/audio/Makefile.am
@@ -7,6 +7,6 @@ libgstaudio_la_SOURCES = audio.c
libgstaudioincludedir = $(includedir)/gst/audio
libgstaudioinclude_HEADERS = audio.h
-libgstaudio_la_LIBADD = $(GST_LIBS)
+libgstaudio_la_LIBADD =
libgstaudio_la_CFLAGS = $(GST_CFLAGS) -finline-functions -ffast-math
libgstaudio_la_LDFLAGS = $(GST_PLUGIN_LDFLAGS)
diff --git a/gst-libs/gst/audio/audio.c b/gst-libs/gst/audio/audio.c
index 31b9ed89..1a0bcf22 100644
--- a/gst-libs/gst/audio/audio.c
+++ b/gst-libs/gst/audio/audio.c
@@ -131,7 +131,7 @@ gst_audio_highest_sample_value (GstPad* pad)
GstCaps *caps = NULL;
caps = GST_PAD_CAPS (pad);
- // FIXME : Please change this to a better warning method !
+ /* FIXME : Please change this to a better warning method ! */
if (caps == NULL)
printf ("WARNING: gstaudio: could not get caps of pad !\n");
width = gst_caps_get_int (caps, "width");
diff --git a/gst-libs/gst/idct/Makefile.am b/gst-libs/gst/idct/Makefile.am
index 8fea3121..8b9d86ba 100644
--- a/gst-libs/gst/idct/Makefile.am
+++ b/gst-libs/gst/idct/Makefile.am
@@ -27,6 +27,6 @@ ieeetest_LDFLAGS = $(GST_LIBS)
noinst_HEADERS = dct.h
-libgstidct_la_LIBADD = $(GST_LIBS)
+libgstidct_la_LIBADD =
libgstidct_la_CFLAGS = $(GST_CFLAGS) -finline-functions -ffast-math
libgstidct_la_LDFLAGS = $(GST_PLUGIN_LDFLAGS)
diff --git a/gst-libs/gst/idct/ieeetest.c b/gst-libs/gst/idct/ieeetest.c
index 23d64eb5..5925a6fd 100644
--- a/gst-libs/gst/idct/ieeetest.c
+++ b/gst-libs/gst/idct/ieeetest.c
@@ -117,7 +117,7 @@ main(int argc, char **argv)
gst_trace_read_tsc(&tscstart);
gst_idct_convert(idct, testout);
gst_trace_read_tsc(&tscstop);
- //printf("time %llu, %llu %lld\n", tscstart, tscstop, tscstop-tscstart);
+ /*printf("time %llu, %llu %lld\n", tscstart, tscstop, tscstop-tscstart); */
if (tscstop - tscstart < tscmin) tscmin = tscstop-tscstart;
if (tscstop - tscstart > tscmax) tscmax = tscstop-tscstart;
diff --git a/gst-libs/gst/idct/mmx32idct.c b/gst-libs/gst/idct/mmx32idct.c
index 78bf45bf..0090d8a7 100644
--- a/gst-libs/gst/idct/mmx32idct.c
+++ b/gst-libs/gst/idct/mmx32idct.c
@@ -22,148 +22,148 @@
*/
-// MMX32 iDCT algorithm (IEEE-1180 compliant) :: idct_mmx32()
-//
-// MPEG2AVI
-// --------
-// v0.16B33 initial release
-//
-// This was one of the harder pieces of work to code.
-// Intel's app-note focuses on the numerical issues of the algorithm, but
-// assumes the programmer is familiar with IDCT mathematics, leaving the
-// form of the complete function up to the programmer's imagination.
-//
-// ALGORITHM OVERVIEW
-// ------------------
-// I played around with the code for quite a few hours. I came up
-// with *A* working IDCT algorithm, however I'm not sure whether my routine
-// is "the correct one." But rest assured, my code passes all six IEEE
-// accuracy tests with plenty of margin.
-//
-// My IDCT algorithm consists of 4 steps:
-//
-// 1) IDCT-row transformation (using the IDCT-row function) on all 8 rows
-// This yields an intermediate 8x8 matrix.
-//
-// 2) intermediate matrix transpose (mandatory)
-//
-// 3) IDCT-row transformation (2nd time) on all 8 rows of the intermediate
-// matrix. The output is the final-result, in transposed form.
-//
-// 4) post-transformation matrix transpose
-// (not necessary if the input-data is already transposed, this could
-// be done during the MPEG "zig-zag" scan, but since my algorithm
-// requires at least one transpose operation, why not re-use the
-// transpose-code.)
-//
-// Although the (1st) and (3rd) steps use the SAME row-transform operation,
-// the (3rd) step uses different shift&round constants (explained later.)
-//
-// Also note that the intermediate transpose (2) would not be neccessary,
-// if the subsequent operation were a iDCT-column transformation. Since
-// we only have the iDCT-row transform, we transpose the intermediate
-// matrix and use the iDCT-row transform a 2nd time.
-//
-// I had to change some constants/variables for my method to work :
-//
-// As given by Intel, the #defines for SHIFT_INV_COL and RND_INV_COL are
-// wrong. Not surprising since I'm not using a true column-transform
-// operation, but the row-transform operation (as mentioned earlier.)
-// round_inv_col[], which is given as "4 short" values, should have the
-// same dimensions as round_inv_row[]. The corrected variables are
-// shown.
-//
-// Intel's code defines a different table for each each row operation.
-// The tables given are 0/4, 1/7, 2/6, and 5/3. My code only uses row#0.
-// Using the other rows messes up the overall transform.
-//
-// IMPLEMENTATION DETAILs
-// ----------------------
-//
-// I divided the algorithm's work into two subroutines,
-// 1) idct_mmx32_rows() - transforms 8 rows, then transpose
-// 2) idct_mmx32_cols() - transforms 8 rows, then transpose
-// yields final result ("drop-in" direct replacement for INT32 IDCT)
-//
-// The 2nd function is a clone of the 1st, with changes made only to the
-// shift&rounding instructions.
-//
-// In the 1st function (rows), the shift & round instructions use
-// SHIFT_INV_ROW & round_inv_row[] (renamed to r_inv_row[])
-//
-// In the 2nd function (cols)-> r_inv_col[], and
-// SHIFT_INV_COL & round_inv_col[] (renamed to r_inv_col[])
-//
-// Each function contains an integrated transpose-operator, which comes
-// AFTER the primary transformation operation. In the future, I'll optimize
-// the code to do more of the transpose-work "in-place". Right now, I've
-// left the code as two subroutines and a main calling function, so other
-// people can read the code more easily.
-//
-// liaor@umcc.ais.org http://members.tripod.com/~liaor
-//
-
-
-//;=============================================================================
-//;
-//; AP-922 http://developer.intel.com/vtune/cbts/strmsimd
-//; These examples contain code fragments for first stage iDCT 8x8
-//; (for rows) and first stage DCT 8x8 (for columns)
-//;
-//;=============================================================================
+/* MMX32 iDCT algorithm (IEEE-1180 compliant) :: idct_mmx32() */
+/* */
+/* MPEG2AVI */
+/* -------- */
+/* v0.16B33 initial release */
+/* */
+/* This was one of the harder pieces of work to code. */
+/* Intel's app-note focuses on the numerical issues of the algorithm, but */
+/* assumes the programmer is familiar with IDCT mathematics, leaving the */
+/* form of the complete function up to the programmer's imagination. */
+/* */
+/* ALGORITHM OVERVIEW */
+/* ------------------ */
+/* I played around with the code for quite a few hours. I came up */
+/* with *A* working IDCT algorithm, however I'm not sure whether my routine */
+/* is "the correct one." But rest assured, my code passes all six IEEE */
+/* accuracy tests with plenty of margin. */
+/* */
+/* My IDCT algorithm consists of 4 steps: */
+/* */
+/* 1) IDCT-row transformation (using the IDCT-row function) on all 8 rows */
+/* This yields an intermediate 8x8 matrix. */
+/* */
+/* 2) intermediate matrix transpose (mandatory) */
+/* */
+/* 3) IDCT-row transformation (2nd time) on all 8 rows of the intermediate */
+/* matrix. The output is the final-result, in transposed form. */
+/* */
+/* 4) post-transformation matrix transpose */
+/* (not necessary if the input-data is already transposed, this could */
+/* be done during the MPEG "zig-zag" scan, but since my algorithm */
+/* requires at least one transpose operation, why not re-use the */
+/* transpose-code.) */
+/* */
+/* Although the (1st) and (3rd) steps use the SAME row-transform operation, */
+/* the (3rd) step uses different shift&round constants (explained later.) */
+/* */
+/* Also note that the intermediate transpose (2) would not be neccessary, */
+/* if the subsequent operation were a iDCT-column transformation. Since */
+/* we only have the iDCT-row transform, we transpose the intermediate */
+/* matrix and use the iDCT-row transform a 2nd time. */
+/* */
+/* I had to change some constants/variables for my method to work : */
+/* */
+/* As given by Intel, the #defines for SHIFT_INV_COL and RND_INV_COL are */
+/* wrong. Not surprising since I'm not using a true column-transform */
+/* operation, but the row-transform operation (as mentioned earlier.) */
+/* round_inv_col[], which is given as "4 short" values, should have the */
+/* same dimensions as round_inv_row[]. The corrected variables are */
+/* shown. */
+/* */
+/* Intel's code defines a different table for each each row operation. */
+/* The tables given are 0/4, 1/7, 2/6, and 5/3. My code only uses row#0. */
+/* Using the other rows messes up the overall transform. */
+/* */
+/* IMPLEMENTATION DETAILs */
+/* ---------------------- */
+/* */
+/* I divided the algorithm's work into two subroutines, */
+/* 1) idct_mmx32_rows() - transforms 8 rows, then transpose */
+/* 2) idct_mmx32_cols() - transforms 8 rows, then transpose */
+/* yields final result ("drop-in" direct replacement for INT32 IDCT) */
+/* */
+/* The 2nd function is a clone of the 1st, with changes made only to the */
+/* shift&rounding instructions. */
+/* */
+/* In the 1st function (rows), the shift & round instructions use */
+/* SHIFT_INV_ROW & round_inv_row[] (renamed to r_inv_row[]) */
+/* */
+/* In the 2nd function (cols)-> r_inv_col[], and */
+/* SHIFT_INV_COL & round_inv_col[] (renamed to r_inv_col[]) */
+/* */
+/* Each function contains an integrated transpose-operator, which comes */
+/* AFTER the primary transformation operation. In the future, I'll optimize */
+/* the code to do more of the transpose-work "in-place". Right now, I've */
+/* left the code as two subroutines and a main calling function, so other */
+/* people can read the code more easily. */
+/* */
+/* liaor@umcc.ais.org http://members.tripod.com/~liaor */
+/* */
+
+
+/*;============================================================================= */
+/*; */
+/*; AP-922 http://developer.intel.com/vtune/cbts/strmsimd */
+/*; These examples contain code fragments for first stage iDCT 8x8 */
+/*; (for rows) and first stage DCT 8x8 (for columns) */
+/*; */
+/*;============================================================================= */
/*
mword typedef qword
qword ptr equ mword ptr */
#include <mmx.h>
-#define BITS_INV_ACC 4 //; 4 or 5 for IEEE
- // 5 yields higher accuracy, but lessens dynamic range on the input matrix
+#define BITS_INV_ACC 4 /*; 4 or 5 for IEEE */
+ /* 5 yields higher accuracy, but lessens dynamic range on the input matrix */
#define SHIFT_INV_ROW (16 - BITS_INV_ACC)
-#define SHIFT_INV_COL (1 + BITS_INV_ACC +14 ) // changed from Intel's val)
-//#define SHIFT_INV_COL (1 + BITS_INV_ACC )
+#define SHIFT_INV_COL (1 + BITS_INV_ACC +14 ) /* changed from Intel's val) */
+/*#define SHIFT_INV_COL (1 + BITS_INV_ACC ) */
#define RND_INV_ROW (1 << (SHIFT_INV_ROW-1))
#define RND_INV_COL (1 << (SHIFT_INV_COL-1))
-#define RND_INV_CORR (RND_INV_COL - 1) //; correction -1.0 and round
-//#define RND_INV_ROW (1024 * (6 - BITS_INV_ACC)) //; 1 << (SHIFT_INV_ROW-1)
-//#define RND_INV_COL (16 * (BITS_INV_ACC - 3)) //; 1 << (SHIFT_INV_COL-1)
+#define RND_INV_CORR (RND_INV_COL - 1) /*; correction -1.0 and round */
+/*#define RND_INV_ROW (1024 * (6 - BITS_INV_ACC)) //; 1 << (SHIFT_INV_ROW-1) */
+/*#define RND_INV_COL (16 * (BITS_INV_ACC - 3)) //; 1 << (SHIFT_INV_COL-1) */
-//.data
-//Align 16
+/*.data */
+/*Align 16 */
const static long r_inv_row[2] = { RND_INV_ROW, RND_INV_ROW};
const static long r_inv_col[2] = {RND_INV_COL, RND_INV_COL};
const static long r_inv_corr[2] = {RND_INV_CORR, RND_INV_CORR };
-//const static short r_inv_col[4] =
-// {RND_INV_COL, RND_INV_COL, RND_INV_COL, RND_INV_COL};
-//const static short r_inv_corr[4] =
-// {RND_INV_CORR, RND_INV_CORR, RND_INV_CORR, RND_INV_CORR};
+/*const static short r_inv_col[4] = */
+/* {RND_INV_COL, RND_INV_COL, RND_INV_COL, RND_INV_COL}; */
+/*const static short r_inv_corr[4] = */
+/* {RND_INV_CORR, RND_INV_CORR, RND_INV_CORR, RND_INV_CORR}; */
/* constants for the forward DCT
-//#define BITS_FRW_ACC 3 //; 2 or 3 for accuracy
-//#define SHIFT_FRW_COL BITS_FRW_ACC
-//#define SHIFT_FRW_ROW (BITS_FRW_ACC + 17)
-//#define RND_FRW_ROW (262144 * (BITS_FRW_ACC - 1)) //; 1 << (SHIFT_FRW_ROW-1)
+/*#define BITS_FRW_ACC 3 //; 2 or 3 for accuracy */
+/*#define SHIFT_FRW_COL BITS_FRW_ACC */
+/*#define SHIFT_FRW_ROW (BITS_FRW_ACC + 17) */
+/*#define RND_FRW_ROW (262144 * (BITS_FRW_ACC - 1)) //; 1 << (SHIFT_FRW_ROW-1) */
const static __int64 one_corr = 0x0001000100010001;
const static long r_frw_row[2] = {RND_FRW_ROW, RND_FRW_ROW };
-//const static short tg_1_16[4] = {13036, 13036, 13036, 13036 }; //tg * (2<<16) + 0.5
-//const static short tg_2_16[4] = {27146, 27146, 27146, 27146 }; //tg * (2<<16) + 0.5
-//const static short tg_3_16[4] = {-21746, -21746, -21746, -21746 }; //tg * (2<<16) + 0.5
-//const static short cos_4_16[4] = {-19195, -19195, -19195, -19195 }; //cos * (2<<16) + 0.5
-//const static short ocos_4_16[4] = {23170, 23170, 23170, 23170 }; //cos * (2<<15) + 0.5
+/*const static short tg_1_16[4] = {13036, 13036, 13036, 13036 }; //tg * (2<<16) + 0.5 */
+/*const static short tg_2_16[4] = {27146, 27146, 27146, 27146 }; //tg * (2<<16) + 0.5 */
+/*const static short tg_3_16[4] = {-21746, -21746, -21746, -21746 }; //tg * (2<<16) + 0.5 */
+/*const static short cos_4_16[4] = {-19195, -19195, -19195, -19195 }; //cos * (2<<16) + 0.5 */
+/*const static short ocos_4_16[4] = {23170, 23170, 23170, 23170 }; //cos * (2<<15) + 0.5 */
-//concatenated table, for forward DCT transformation
+/*concatenated table, for forward DCT transformation */
const static short tg_all_16[] = {
- 13036, 13036, 13036, 13036, // tg * (2<<16) + 0.5
- 27146, 27146, 27146, 27146, //tg * (2<<16) + 0.5
- -21746, -21746, -21746, -21746, // tg * (2<<16) + 0.5
- -19195, -19195, -19195, -19195, //cos * (2<<16) + 0.5
- 23170, 23170, 23170, 23170 }; //cos * (2<<15) + 0.5
+ 13036, 13036, 13036, 13036, /* tg * (2<<16) + 0.5 */
+ 27146, 27146, 27146, 27146, /*tg * (2<<16) + 0.5 */
+ -21746, -21746, -21746, -21746, /* tg * (2<<16) + 0.5 */
+ -19195, -19195, -19195, -19195, /*cos * (2<<16) + 0.5 */
+ 23170, 23170, 23170, 23170 }; /*cos * (2<<15) + 0.5 */
#define tg_1_16 (tg_all_16 + 0)
#define tg_2_16 (tg_all_16 + 8)
@@ -231,553 +231,553 @@ const static short tg_all_16[] = {
IF _MMX ; MMX code
;=============================================================================
-//; Table for rows 0,4 - constants are multiplied by cos_4_16
+/*; Table for rows 0,4 - constants are multiplied by cos_4_16 */
const short tab_i_04[] = {
- 16384, 16384, 16384, -16384, // ; movq-> w06 w04 w02 w00
- 21407, 8867, 8867, -21407, // w07 w05 w03 w01
- 16384, -16384, 16384, 16384, //; w14 w12 w10 w08
- -8867, 21407, -21407, -8867, //; w15 w13 w11 w09
- 22725, 12873, 19266, -22725, //; w22 w20 w18 w16
- 19266, 4520, -4520, -12873, //; w23 w21 w19 w17
- 12873, 4520, 4520, 19266, //; w30 w28 w26 w24
- -22725, 19266, -12873, -22725 };//w31 w29 w27 w25
-
-//; Table for rows 1,7 - constants are multiplied by cos_1_16
+ 16384, 16384, 16384, -16384, /* ; movq-> w06 w04 w02 w00 */
+ 21407, 8867, 8867, -21407, /* w07 w05 w03 w01 */
+ 16384, -16384, 16384, 16384, /*; w14 w12 w10 w08 */
+ -8867, 21407, -21407, -8867, /*; w15 w13 w11 w09 */
+ 22725, 12873, 19266, -22725, /*; w22 w20 w18 w16 */
+ 19266, 4520, -4520, -12873, /*; w23 w21 w19 w17 */
+ 12873, 4520, 4520, 19266, /*; w30 w28 w26 w24 */
+ -22725, 19266, -12873, -22725 };/*w31 w29 w27 w25 */
+
+/*; Table for rows 1,7 - constants are multiplied by cos_1_16 */
const short tab_i_17[] = {
- 22725, 22725, 22725, -22725, // ; movq-> w06 w04 w02 w00
- 29692, 12299, 12299, -29692, // ; w07 w05 w03 w01
- 22725, -22725, 22725, 22725, //; w14 w12 w10 w08
- -12299, 29692, -29692, -12299, //; w15 w13 w11 w09
- 31521, 17855, 26722, -31521, //; w22 w20 w18 w16
- 26722, 6270, -6270, -17855, //; w23 w21 w19 w17
- 17855, 6270, 6270, 26722, //; w30 w28 w26 w24
- -31521, 26722, -17855, -31521}; // w31 w29 w27 w25
-
-//; Table for rows 2,6 - constants are multiplied by cos_2_16
+ 22725, 22725, 22725, -22725, /* ; movq-> w06 w04 w02 w00 */
+ 29692, 12299, 12299, -29692, /* ; w07 w05 w03 w01 */
+ 22725, -22725, 22725, 22725, /*; w14 w12 w10 w08 */
+ -12299, 29692, -29692, -12299, /*; w15 w13 w11 w09 */
+ 31521, 17855, 26722, -31521, /*; w22 w20 w18 w16 */
+ 26722, 6270, -6270, -17855, /*; w23 w21 w19 w17 */
+ 17855, 6270, 6270, 26722, /*; w30 w28 w26 w24 */
+ -31521, 26722, -17855, -31521}; /* w31 w29 w27 w25 */
+
+/*; Table for rows 2,6 - constants are multiplied by cos_2_16 */
const short tab_i_26[] = {
- 21407, 21407, 21407, -21407, // ; movq-> w06 w04 w02 w00
- 27969, 11585, 11585, -27969, // ; w07 w05 w03 w01
- 21407, -21407, 21407, 21407, // ; w14 w12 w10 w08
- -11585, 27969, -27969, -11585, // ;w15 w13 w11 w09
- 29692, 16819, 25172, -29692, // ;w22 w20 w18 w16
- 25172, 5906, -5906, -16819, // ;w23 w21 w19 w17
- 16819, 5906, 5906, 25172, // ;w30 w28 w26 w24
- -29692, 25172, -16819, -29692}; // ;w31 w29 w27 w25
+ 21407, 21407, 21407, -21407, /* ; movq-> w06 w04 w02 w00 */
+ 27969, 11585, 11585, -27969, /* ; w07 w05 w03 w01 */
+ 21407, -21407, 21407, 21407, /* ; w14 w12 w10 w08 */
+ -11585, 27969, -27969, -11585, /* ;w15 w13 w11 w09 */
+ 29692, 16819, 25172, -29692, /* ;w22 w20 w18 w16 */
+ 25172, 5906, -5906, -16819, /* ;w23 w21 w19 w17 */
+ 16819, 5906, 5906, 25172, /* ;w30 w28 w26 w24 */
+ -29692, 25172, -16819, -29692}; /* ;w31 w29 w27 w25 */
-//; Table for rows 3,5 - constants are multiplied by cos_3_16
+/*; Table for rows 3,5 - constants are multiplied by cos_3_16 */
const short tab_i_35[] = {
- 19266, 19266, 19266, -19266, //; movq-> w06 w04 w02 w00
- 25172, 10426, 10426, -25172, //; w07 w05 w03 w01
- 19266, -19266, 19266, 19266, //; w14 w12 w10 w08
- -10426, 25172, -25172, -10426, //; w15 w13 w11 w09
- 26722, 15137, 22654, -26722, //; w22 w20 w18 w16
- 22654, 5315, -5315, -15137, //; w23 w21 w19 w17
- 15137, 5315, 5315, 22654, //; w30 w28 w26 w24
- -26722, 22654, -15137, -26722}; //; w31 w29 w27 w25
+ 19266, 19266, 19266, -19266, /*; movq-> w06 w04 w02 w00 */
+ 25172, 10426, 10426, -25172, /*; w07 w05 w03 w01 */
+ 19266, -19266, 19266, 19266, /*; w14 w12 w10 w08 */
+ -10426, 25172, -25172, -10426, /*; w15 w13 w11 w09 */
+ 26722, 15137, 22654, -26722, /*; w22 w20 w18 w16 */
+ 22654, 5315, -5315, -15137, /*; w23 w21 w19 w17 */
+ 15137, 5315, 5315, 22654, /*; w30 w28 w26 w24 */
+ -26722, 22654, -15137, -26722}; /*; w31 w29 w27 w25 */
*/
-// CONCATENATED TABLE, rows 0,1,2,3,4,5,6,7 (in order )
-//
-// In our implementation, however, we only use row0 !
-//
+/* CONCATENATED TABLE, rows 0,1,2,3,4,5,6,7 (in order ) */
+/* */
+/* In our implementation, however, we only use row0 ! */
+/* */
static const short tab_i_01234567[] = {
- //row0, this row is required
- 16384, 16384, 16384, -16384, // ; movq-> w06 w04 w02 w00
- 21407, 8867, 8867, -21407, // w07 w05 w03 w01
- 16384, -16384, 16384, 16384, //; w14 w12 w10 w08
- -8867, 21407, -21407, -8867, //; w15 w13 w11 w09
- 22725, 12873, 19266, -22725, //; w22 w20 w18 w16
- 19266, 4520, -4520, -12873, //; w23 w21 w19 w17
- 12873, 4520, 4520, 19266, //; w30 w28 w26 w24
- -22725, 19266, -12873, -22725, //w31 w29 w27 w25
-
- // the rest of these rows (1-7), aren't used !
-
- //row1
- 22725, 22725, 22725, -22725, // ; movq-> w06 w04 w02 w00
- 29692, 12299, 12299, -29692, // ; w07 w05 w03 w01
- 22725, -22725, 22725, 22725, //; w14 w12 w10 w08
- -12299, 29692, -29692, -12299, //; w15 w13 w11 w09
- 31521, 17855, 26722, -31521, //; w22 w20 w18 w16
- 26722, 6270, -6270, -17855, //; w23 w21 w19 w17
- 17855, 6270, 6270, 26722, //; w30 w28 w26 w24
- -31521, 26722, -17855, -31521, // w31 w29 w27 w25
-
- //row2
- 21407, 21407, 21407, -21407, // ; movq-> w06 w04 w02 w00
- 27969, 11585, 11585, -27969, // ; w07 w05 w03 w01
- 21407, -21407, 21407, 21407, // ; w14 w12 w10 w08
- -11585, 27969, -27969, -11585, // ;w15 w13 w11 w09
- 29692, 16819, 25172, -29692, // ;w22 w20 w18 w16
- 25172, 5906, -5906, -16819, // ;w23 w21 w19 w17
- 16819, 5906, 5906, 25172, // ;w30 w28 w26 w24
- -29692, 25172, -16819, -29692, // ;w31 w29 w27 w25
-
- //row3
- 19266, 19266, 19266, -19266, //; movq-> w06 w04 w02 w00
- 25172, 10426, 10426, -25172, //; w07 w05 w03 w01
- 19266, -19266, 19266, 19266, //; w14 w12 w10 w08
- -10426, 25172, -25172, -10426, //; w15 w13 w11 w09
- 26722, 15137, 22654, -26722, //; w22 w20 w18 w16
- 22654, 5315, -5315, -15137, //; w23 w21 w19 w17
- 15137, 5315, 5315, 22654, //; w30 w28 w26 w24
- -26722, 22654, -15137, -26722, //; w31 w29 w27 w25
-
- //row4
- 16384, 16384, 16384, -16384, // ; movq-> w06 w04 w02 w00
- 21407, 8867, 8867, -21407, // w07 w05 w03 w01
- 16384, -16384, 16384, 16384, //; w14 w12 w10 w08
- -8867, 21407, -21407, -8867, //; w15 w13 w11 w09
- 22725, 12873, 19266, -22725, //; w22 w20 w18 w16
- 19266, 4520, -4520, -12873, //; w23 w21 w19 w17
- 12873, 4520, 4520, 19266, //; w30 w28 w26 w24
- -22725, 19266, -12873, -22725, //w31 w29 w27 w25
-
- //row5
- 19266, 19266, 19266, -19266, //; movq-> w06 w04 w02 w00
- 25172, 10426, 10426, -25172, //; w07 w05 w03 w01
- 19266, -19266, 19266, 19266, //; w14 w12 w10 w08
- -10426, 25172, -25172, -10426, //; w15 w13 w11 w09
- 26722, 15137, 22654, -26722, //; w22 w20 w18 w16
- 22654, 5315, -5315, -15137, //; w23 w21 w19 w17
- 15137, 5315, 5315, 22654, //; w30 w28 w26 w24
- -26722, 22654, -15137, -26722, //; w31 w29 w27 w25
-
- //row6
- 21407, 21407, 21407, -21407, // ; movq-> w06 w04 w02 w00
- 27969, 11585, 11585, -27969, // ; w07 w05 w03 w01
- 21407, -21407, 21407, 21407, // ; w14 w12 w10 w08
- -11585, 27969, -27969, -11585, // ;w15 w13 w11 w09
- 29692, 16819, 25172, -29692, // ;w22 w20 w18 w16
- 25172, 5906, -5906, -16819, // ;w23 w21 w19 w17
- 16819, 5906, 5906, 25172, // ;w30 w28 w26 w24
- -29692, 25172, -16819, -29692, // ;w31 w29 w27 w25
-
- //row7
- 22725, 22725, 22725, -22725, // ; movq-> w06 w04 w02 w00
- 29692, 12299, 12299, -29692, // ; w07 w05 w03 w01
- 22725, -22725, 22725, 22725, //; w14 w12 w10 w08
- -12299, 29692, -29692, -12299, //; w15 w13 w11 w09
- 31521, 17855, 26722, -31521, //; w22 w20 w18 w16
- 26722, 6270, -6270, -17855, //; w23 w21 w19 w17
- 17855, 6270, 6270, 26722, //; w30 w28 w26 w24
- -31521, 26722, -17855, -31521}; // w31 w29 w27 w25
-
-
-#define INP eax // pointer to (short *blk)
-#define OUT ecx // pointer to output (temporary store space qwTemp[])
-#define TABLE ebx // pointer to tab_i_01234567[]
+ /*row0, this row is required */
+ 16384, 16384, 16384, -16384, /* ; movq-> w06 w04 w02 w00 */
+ 21407, 8867, 8867, -21407, /* w07 w05 w03 w01 */
+ 16384, -16384, 16384, 16384, /*; w14 w12 w10 w08 */
+ -8867, 21407, -21407, -8867, /*; w15 w13 w11 w09 */
+ 22725, 12873, 19266, -22725, /*; w22 w20 w18 w16 */
+ 19266, 4520, -4520, -12873, /*; w23 w21 w19 w17 */
+ 12873, 4520, 4520, 19266, /*; w30 w28 w26 w24 */
+ -22725, 19266, -12873, -22725, /*w31 w29 w27 w25 */
+
+ /* the rest of these rows (1-7), aren't used ! */
+
+ /*row1 */
+ 22725, 22725, 22725, -22725, /* ; movq-> w06 w04 w02 w00 */
+ 29692, 12299, 12299, -29692, /* ; w07 w05 w03 w01 */
+ 22725, -22725, 22725, 22725, /*; w14 w12 w10 w08 */
+ -12299, 29692, -29692, -12299, /*; w15 w13 w11 w09 */
+ 31521, 17855, 26722, -31521, /*; w22 w20 w18 w16 */
+ 26722, 6270, -6270, -17855, /*; w23 w21 w19 w17 */
+ 17855, 6270, 6270, 26722, /*; w30 w28 w26 w24 */
+ -31521, 26722, -17855, -31521, /* w31 w29 w27 w25 */
+
+ /*row2 */
+ 21407, 21407, 21407, -21407, /* ; movq-> w06 w04 w02 w00 */
+ 27969, 11585, 11585, -27969, /* ; w07 w05 w03 w01 */
+ 21407, -21407, 21407, 21407, /* ; w14 w12 w10 w08 */
+ -11585, 27969, -27969, -11585, /* ;w15 w13 w11 w09 */
+ 29692, 16819, 25172, -29692, /* ;w22 w20 w18 w16 */
+ 25172, 5906, -5906, -16819, /* ;w23 w21 w19 w17 */
+ 16819, 5906, 5906, 25172, /* ;w30 w28 w26 w24 */
+ -29692, 25172, -16819, -29692, /* ;w31 w29 w27 w25 */
+
+ /*row3 */
+ 19266, 19266, 19266, -19266, /*; movq-> w06 w04 w02 w00 */
+ 25172, 10426, 10426, -25172, /*; w07 w05 w03 w01 */
+ 19266, -19266, 19266, 19266, /*; w14 w12 w10 w08 */
+ -10426, 25172, -25172, -10426, /*; w15 w13 w11 w09 */
+ 26722, 15137, 22654, -26722, /*; w22 w20 w18 w16 */
+ 22654, 5315, -5315, -15137, /*; w23 w21 w19 w17 */
+ 15137, 5315, 5315, 22654, /*; w30 w28 w26 w24 */
+ -26722, 22654, -15137, -26722, /*; w31 w29 w27 w25 */
+
+ /*row4 */
+ 16384, 16384, 16384, -16384, /* ; movq-> w06 w04 w02 w00 */
+ 21407, 8867, 8867, -21407, /* w07 w05 w03 w01 */
+ 16384, -16384, 16384, 16384, /*; w14 w12 w10 w08 */
+ -8867, 21407, -21407, -8867, /*; w15 w13 w11 w09 */
+ 22725, 12873, 19266, -22725, /*; w22 w20 w18 w16 */
+ 19266, 4520, -4520, -12873, /*; w23 w21 w19 w17 */
+ 12873, 4520, 4520, 19266, /*; w30 w28 w26 w24 */
+ -22725, 19266, -12873, -22725, /*w31 w29 w27 w25 */
+
+ /*row5 */
+ 19266, 19266, 19266, -19266, /*; movq-> w06 w04 w02 w00 */
+ 25172, 10426, 10426, -25172, /*; w07 w05 w03 w01 */
+ 19266, -19266, 19266, 19266, /*; w14 w12 w10 w08 */
+ -10426, 25172, -25172, -10426, /*; w15 w13 w11 w09 */
+ 26722, 15137, 22654, -26722, /*; w22 w20 w18 w16 */
+ 22654, 5315, -5315, -15137, /*; w23 w21 w19 w17 */
+ 15137, 5315, 5315, 22654, /*; w30 w28 w26 w24 */
+ -26722, 22654, -15137, -26722, /*; w31 w29 w27 w25 */
+
+ /*row6 */
+ 21407, 21407, 21407, -21407, /* ; movq-> w06 w04 w02 w00 */
+ 27969, 11585, 11585, -27969, /* ; w07 w05 w03 w01 */
+ 21407, -21407, 21407, 21407, /* ; w14 w12 w10 w08 */
+ -11585, 27969, -27969, -11585, /* ;w15 w13 w11 w09 */
+ 29692, 16819, 25172, -29692, /* ;w22 w20 w18 w16 */
+ 25172, 5906, -5906, -16819, /* ;w23 w21 w19 w17 */
+ 16819, 5906, 5906, 25172, /* ;w30 w28 w26 w24 */
+ -29692, 25172, -16819, -29692, /* ;w31 w29 w27 w25 */
+
+ /*row7 */
+ 22725, 22725, 22725, -22725, /* ; movq-> w06 w04 w02 w00 */
+ 29692, 12299, 12299, -29692, /* ; w07 w05 w03 w01 */
+ 22725, -22725, 22725, 22725, /*; w14 w12 w10 w08 */
+ -12299, 29692, -29692, -12299, /*; w15 w13 w11 w09 */
+ 31521, 17855, 26722, -31521, /*; w22 w20 w18 w16 */
+ 26722, 6270, -6270, -17855, /*; w23 w21 w19 w17 */
+ 17855, 6270, 6270, 26722, /*; w30 w28 w26 w24 */
+ -31521, 26722, -17855, -31521}; /* w31 w29 w27 w25 */
+
+
+#define INP eax /* pointer to (short *blk) */
+#define OUT ecx /* pointer to output (temporary store space qwTemp[]) */
+#define TABLE ebx /* pointer to tab_i_01234567[] */
#define round_inv_row edx
#define round_inv_col edx
-#define ROW_STRIDE 8 // for 8x8 matrix transposer
+#define ROW_STRIDE 8 /* for 8x8 matrix transposer */
-// private variables and functions
+/* private variables and functions */
-//temporary storage space, 8x8 of shorts
+/*temporary storage space, 8x8 of shorts */
-__inline static void idct_mmx32_rows( short *blk ); // transform rows
-__inline static void idct_mmx32_cols( short *blk ); // transform "columns"
- // the "column" transform actually transforms rows, it is
- // identical to the row-transform except for the ROUNDING
- // and SHIFTING coefficients.
+__inline static void idct_mmx32_rows( short *blk ); /* transform rows */
+__inline static void idct_mmx32_cols( short *blk ); /* transform "columns" */
+ /* the "column" transform actually transforms rows, it is */
+ /* identical to the row-transform except for the ROUNDING */
+ /* and SHIFTING coefficients. */
static void
-idct_mmx32_rows( short *blk ) // transform all 8 rows of 8x8 iDCT block
+idct_mmx32_rows( short *blk ) /* transform all 8 rows of 8x8 iDCT block */
{
int x;
short qwTemp[64];
short *out = &qwTemp[0];
short *inptr = blk;
- // this subroutine performs two operations
- // 1) iDCT row transform
- // for( i = 0; i < 8; ++ i)
- // DCT_8_INV_ROW_1( blk[i*8], qwTemp[i] );
- //
- // 2) transpose the matrix (which was stored in qwTemp[])
- // qwTemp[] -> [8x8 matrix transpose] -> blk[]
+ /* this subroutine performs two operations */
+ /* 1) iDCT row transform */
+ /* for( i = 0; i < 8; ++ i) */
+ /* DCT_8_INV_ROW_1( blk[i*8], qwTemp[i] ); */
+ /* */
+ /* 2) transpose the matrix (which was stored in qwTemp[]) */
+ /* qwTemp[] -> [8x8 matrix transpose] -> blk[] */
- for (x=0; x<8; x++) { // transform one row per iteration
- movq_m2r(*(inptr), mm0); // 0 ; x3 x2 x1 x0
+ for (x=0; x<8; x++) { /* transform one row per iteration */
+ movq_m2r(*(inptr), mm0); /* 0 ; x3 x2 x1 x0 */
- movq_m2r(*(inptr+4), mm1); // 1 ; x7 x6 x5 x4
- movq_r2r(mm0, mm2); // 2 ; x3 x2 x1 x0
+ movq_m2r(*(inptr+4), mm1); /* 1 ; x7 x6 x5 x4 */
+ movq_r2r(mm0, mm2); /* 2 ; x3 x2 x1 x0 */
- movq_m2r(*(tab_i_01234567), mm3); // 3 ; w06 w04 w02 w00
- punpcklwd_r2r(mm1, mm0); // x5 x1 x4 x0
+ movq_m2r(*(tab_i_01234567), mm3); /* 3 ; w06 w04 w02 w00 */
+ punpcklwd_r2r(mm1, mm0); /* x5 x1 x4 x0 */
- // ----------
- movq_r2r(mm0, mm5); // 5 ; x5 x1 x4 x0
- punpckldq_r2r(mm0, mm0); // x4 x0 x4 x0
+ /* ---------- */
+ movq_r2r(mm0, mm5); /* 5 ; x5 x1 x4 x0 */
+ punpckldq_r2r(mm0, mm0); /* x4 x0 x4 x0 */
- movq_m2r(*(tab_i_01234567+4), mm4); // 4 ; w07 w05 w03 w01
- punpckhwd_r2r(mm1, mm2); // 1 ; x7 x3 x6 x2
+ movq_m2r(*(tab_i_01234567+4), mm4); /* 4 ; w07 w05 w03 w01 */
+ punpckhwd_r2r(mm1, mm2); /* 1 ; x7 x3 x6 x2 */
- pmaddwd_r2r(mm0, mm3); // x4*w06+x0*w04 x4*w02+x0*w00
- movq_r2r(mm2, mm6); // 6 ; x7 x3 x6 x2
+ pmaddwd_r2r(mm0, mm3); /* x4*w06+x0*w04 x4*w02+x0*w00 */
+ movq_r2r(mm2, mm6); /* 6 ; x7 x3 x6 x2 */
- movq_m2r(*(tab_i_01234567+16), mm1);// 1 ; w22 w20 w18 w16
- punpckldq_r2r(mm2, mm2); // x6 x2 x6 x2
+ movq_m2r(*(tab_i_01234567+16), mm1);/* 1 ; w22 w20 w18 w16 */
+ punpckldq_r2r(mm2, mm2); /* x6 x2 x6 x2 */
- pmaddwd_r2r(mm2, mm4); // x6*w07+x2*w05 x6*w03+x2*w01
- punpckhdq_r2r(mm5, mm5); // x5 x1 x5 x1
+ pmaddwd_r2r(mm2, mm4); /* x6*w07+x2*w05 x6*w03+x2*w01 */
+ punpckhdq_r2r(mm5, mm5); /* x5 x1 x5 x1 */
- pmaddwd_m2r(*(tab_i_01234567+8), mm0);// x4*w14+x0*w12 x4*w10+x0*w08
- punpckhdq_r2r(mm6, mm6); // x7 x3 x7 x3
+ pmaddwd_m2r(*(tab_i_01234567+8), mm0);/* x4*w14+x0*w12 x4*w10+x0*w08 */
+ punpckhdq_r2r(mm6, mm6); /* x7 x3 x7 x3 */
- movq_m2r(*(tab_i_01234567+20), mm7);// 7 ; w23 w21 w19 w17
- pmaddwd_r2r(mm5, mm1); // x5*w22+x1*w20 x5*w18+x1*w16
+ movq_m2r(*(tab_i_01234567+20), mm7);/* 7 ; w23 w21 w19 w17 */
+ pmaddwd_r2r(mm5, mm1); /* x5*w22+x1*w20 x5*w18+x1*w16 */
- paddd_m2r(*(r_inv_row), mm3);// +rounder
- pmaddwd_r2r(mm6, mm7); // x7*w23+x3*w21 x7*w19+x3*w17
+ paddd_m2r(*(r_inv_row), mm3);/* +rounder */
+ pmaddwd_r2r(mm6, mm7); /* x7*w23+x3*w21 x7*w19+x3*w17 */
- pmaddwd_m2r(*(tab_i_01234567+12), mm2);// x6*w15+x2*w13 x6*w11+x2*w09
- paddd_r2r(mm4, mm3); // 4 ; a1=sum(even1) a0=sum(even0)
+ pmaddwd_m2r(*(tab_i_01234567+12), mm2);/* x6*w15+x2*w13 x6*w11+x2*w09 */
+ paddd_r2r(mm4, mm3); /* 4 ; a1=sum(even1) a0=sum(even0) */
- pmaddwd_m2r(*(tab_i_01234567+24), mm5);// x5*w30+x1*w28 x5*w26+x1*w24
- movq_r2r(mm3, mm4); // 4 ; a1 a0
+ pmaddwd_m2r(*(tab_i_01234567+24), mm5);/* x5*w30+x1*w28 x5*w26+x1*w24 */
+ movq_r2r(mm3, mm4); /* 4 ; a1 a0 */
- pmaddwd_m2r(*(tab_i_01234567+28), mm6);// x7*w31+x3*w29 x7*w27+x3*w25
- paddd_r2r(mm7, mm1); // 7 ; b1=sum(odd1) b0=sum(odd0)
+ pmaddwd_m2r(*(tab_i_01234567+28), mm6);/* x7*w31+x3*w29 x7*w27+x3*w25 */
+ paddd_r2r(mm7, mm1); /* 7 ; b1=sum(odd1) b0=sum(odd0) */
- paddd_m2r(*(r_inv_row), mm0);// +rounder
- psubd_r2r(mm1, mm3); // a1-b1 a0-b0
+ paddd_m2r(*(r_inv_row), mm0);/* +rounder */
+ psubd_r2r(mm1, mm3); /* a1-b1 a0-b0 */
- psrad_i2r(SHIFT_INV_ROW, mm3); // y6=a1-b1 y7=a0-b0
- paddd_r2r(mm4, mm1); // 4 ; a1+b1 a0+b0
+ psrad_i2r(SHIFT_INV_ROW, mm3); /* y6=a1-b1 y7=a0-b0 */
+ paddd_r2r(mm4, mm1); /* 4 ; a1+b1 a0+b0 */
- paddd_r2r(mm2, mm0); // 2 ; a3=sum(even3) a2=sum(even2)
- psrad_i2r(SHIFT_INV_ROW, mm1); // y1=a1+b1 y0=a0+b0
+ paddd_r2r(mm2, mm0); /* 2 ; a3=sum(even3) a2=sum(even2) */
+ psrad_i2r(SHIFT_INV_ROW, mm1); /* y1=a1+b1 y0=a0+b0 */
- paddd_r2r(mm6, mm5); // 6 ; b3=sum(odd3) b2=sum(odd2)
- movq_r2r(mm0, mm4); // 4 ; a3 a2
+ paddd_r2r(mm6, mm5); /* 6 ; b3=sum(odd3) b2=sum(odd2) */
+ movq_r2r(mm0, mm4); /* 4 ; a3 a2 */
- paddd_r2r(mm5, mm0); // a3+b3 a2+b2
- psubd_r2r(mm5, mm4); // 5 ; a3-b3 a2-b2
+ paddd_r2r(mm5, mm0); /* a3+b3 a2+b2 */
+ psubd_r2r(mm5, mm4); /* 5 ; a3-b3 a2-b2 */
- psrad_i2r(SHIFT_INV_ROW, mm4); // y4=a3-b3 y5=a2-b2
- psrad_i2r(SHIFT_INV_ROW, mm0); // y3=a3+b3 y2=a2+b2
+ psrad_i2r(SHIFT_INV_ROW, mm4); /* y4=a3-b3 y5=a2-b2 */
+ psrad_i2r(SHIFT_INV_ROW, mm0); /* y3=a3+b3 y2=a2+b2 */
- packssdw_r2r(mm3, mm4); // 3 ; y6 y7 y4 y5
+ packssdw_r2r(mm3, mm4); /* 3 ; y6 y7 y4 y5 */
- packssdw_r2r(mm0, mm1); // 0 ; y3 y2 y1 y0
- movq_r2r(mm4, mm7); // 7 ; y6 y7 y4 y5
+ packssdw_r2r(mm0, mm1); /* 0 ; y3 y2 y1 y0 */
+ movq_r2r(mm4, mm7); /* 7 ; y6 y7 y4 y5 */
- psrld_i2r(16, mm4); // 0 y6 0 y4
+ psrld_i2r(16, mm4); /* 0 y6 0 y4 */
- movq_r2m(mm1, *(out)); // 1 ; save y3 y2 y1 y0
- pslld_i2r(16, mm7); // y7 0 y5 0
+ movq_r2m(mm1, *(out)); /* 1 ; save y3 y2 y1 y0 */
+ pslld_i2r(16, mm7); /* y7 0 y5 0 */
- por_r2r(mm4, mm7); // 4 ; y7 y6 y5 y4
+ por_r2r(mm4, mm7); /* 4 ; y7 y6 y5 y4 */
- // begin processing row 1
- movq_r2m(mm7, *(out+4)); // 7 ; save y7 y6 y5 y4
+ /* begin processing row 1 */
+ movq_r2m(mm7, *(out+4)); /* 7 ; save y7 y6 y5 y4 */
inptr += 8;
out += 8;
}
- // done with the iDCT row-transformation
+ /* done with the iDCT row-transformation */
- // now we have to transpose the output 8x8 matrix
- // 8x8 (OUT) -> 8x8't' (IN)
- // the transposition is implemented as 4 sub-operations.
- // 1) transpose upper-left quad
- // 2) transpose lower-right quad
- // 3) transpose lower-left quad
- // 4) transpose upper-right quad
+ /* now we have to transpose the output 8x8 matrix */
+ /* 8x8 (OUT) -> 8x8't' (IN) */
+ /* the transposition is implemented as 4 sub-operations. */
+ /* 1) transpose upper-left quad */
+ /* 2) transpose lower-right quad */
+ /* 3) transpose lower-left quad */
+ /* 4) transpose upper-right quad */
- // mm0 = 1st row [ A B C D ] row1
- // mm1 = 2nd row [ E F G H ] 2
- // mm2 = 3rd row [ I J K L ] 3
- // mm3 = 4th row [ M N O P ] 4
+ /* mm0 = 1st row [ A B C D ] row1 */
+ /* mm1 = 2nd row [ E F G H ] 2 */
+ /* mm2 = 3rd row [ I J K L ] 3 */
+ /* mm3 = 4th row [ M N O P ] 4 */
- // 1) transpose upper-left quad
+ /* 1) transpose upper-left quad */
out = &qwTemp[0];
movq_m2r(*(out + ROW_STRIDE * 0), mm0);
movq_m2r(*(out + ROW_STRIDE * 1), mm1);
- movq_r2r(mm0, mm4); // mm4 = copy of row1[A B C D]
+ movq_r2r(mm0, mm4); /* mm4 = copy of row1[A B C D] */
movq_m2r(*(out + ROW_STRIDE * 2), mm2);
- punpcklwd_r2r(mm1, mm0); // mm0 = [ 0 4 1 5]
+ punpcklwd_r2r(mm1, mm0); /* mm0 = [ 0 4 1 5] */
movq_m2r(*(out + ROW_STRIDE * 3), mm3);
- punpckhwd_r2r(mm1, mm4); // mm4 = [ 2 6 3 7]
+ punpckhwd_r2r(mm1, mm4); /* mm4 = [ 2 6 3 7] */
movq_r2r(mm2, mm6);
- punpcklwd_r2r(mm3, mm2); // mm2 = [ 8 12 9 13]
+ punpcklwd_r2r(mm3, mm2); /* mm2 = [ 8 12 9 13] */
- punpckhwd_r2r(mm3, mm6); // mm6 = 10 14 11 15]
- movq_r2r(mm0, mm1); // mm1 = [ 0 4 1 5]
+ punpckhwd_r2r(mm3, mm6); /* mm6 = 10 14 11 15] */
+ movq_r2r(mm0, mm1); /* mm1 = [ 0 4 1 5] */
inptr = blk;
- punpckldq_r2r(mm2, mm0); // final result mm0 = row1 [0 4 8 12]
+ punpckldq_r2r(mm2, mm0); /* final result mm0 = row1 [0 4 8 12] */
- movq_r2r(mm4, mm3); // mm3 = [ 2 6 3 7]
- punpckhdq_r2r(mm2, mm1); // mm1 = final result mm1 = row2 [1 5 9 13]
+ movq_r2r(mm4, mm3); /* mm3 = [ 2 6 3 7] */
+ punpckhdq_r2r(mm2, mm1); /* mm1 = final result mm1 = row2 [1 5 9 13] */
- movq_r2m(mm0, *(inptr + ROW_STRIDE * 0)); // store row 1
- punpckldq_r2r(mm6, mm4); // final result mm4 = row3 [2 6 10 14]
+ movq_r2m(mm0, *(inptr + ROW_STRIDE * 0)); /* store row 1 */
+ punpckldq_r2r(mm6, mm4); /* final result mm4 = row3 [2 6 10 14] */
-// begin reading next quadrant (lower-right)
+/* begin reading next quadrant (lower-right) */
movq_m2r(*(out + ROW_STRIDE*4 + 4), mm0);
- punpckhdq_r2r(mm6, mm3); // final result mm3 = row4 [3 7 11 15]
+ punpckhdq_r2r(mm6, mm3); /* final result mm3 = row4 [3 7 11 15] */
- movq_r2m(mm4, *(inptr + ROW_STRIDE * 2)); // store row 3
- movq_r2r(mm0, mm4); // mm4 = copy of row1[A B C D]
+ movq_r2m(mm4, *(inptr + ROW_STRIDE * 2)); /* store row 3 */
+ movq_r2r(mm0, mm4); /* mm4 = copy of row1[A B C D] */
- movq_r2m(mm1, *(inptr + ROW_STRIDE * 1)); // store row 2
+ movq_r2m(mm1, *(inptr + ROW_STRIDE * 1)); /* store row 2 */
movq_m2r(*(out + ROW_STRIDE*5 + 4), mm1);
- movq_r2m(mm3, *(inptr + ROW_STRIDE * 3)); // store row 4
- punpcklwd_r2r(mm1, mm0); // mm0 = [ 0 4 1 5]
+ movq_r2m(mm3, *(inptr + ROW_STRIDE * 3)); /* store row 4 */
+ punpcklwd_r2r(mm1, mm0); /* mm0 = [ 0 4 1 5] */
- // 2) transpose lower-right quadrant
+ /* 2) transpose lower-right quadrant */
-// movq mm0, qword ptr [OUT + ROW_STRIDE*4 + 8]
+/* movq mm0, qword ptr [OUT + ROW_STRIDE*4 + 8] */
-// movq mm1, qword ptr [OUT + ROW_STRIDE*5 + 8]
-// movq mm4, mm0; // mm4 = copy of row1[A B C D]
+/* movq mm1, qword ptr [OUT + ROW_STRIDE*5 + 8] */
+/* movq mm4, mm0; // mm4 = copy of row1[A B C D] */
movq_m2r(*(out + ROW_STRIDE*6 + 4), mm2);
-// punpcklwd mm0, mm1; // mm0 = [ 0 4 1 5]
- punpckhwd_r2r(mm1, mm4); // mm4 = [ 2 6 3 7]
+/* punpcklwd mm0, mm1; // mm0 = [ 0 4 1 5] */
+ punpckhwd_r2r(mm1, mm4); /* mm4 = [ 2 6 3 7] */
movq_m2r(*(out + ROW_STRIDE*7 + 4), mm3);
movq_r2r(mm2, mm6);
- punpcklwd_r2r(mm3, mm2); // mm2 = [ 8 12 9 13]
- movq_r2r(mm0, mm1); // mm1 = [ 0 4 1 5]
+ punpcklwd_r2r(mm3, mm2); /* mm2 = [ 8 12 9 13] */
+ movq_r2r(mm0, mm1); /* mm1 = [ 0 4 1 5] */
- punpckhwd_r2r(mm3, mm6); // mm6 = 10 14 11 15]
- movq_r2r(mm4, mm3); // mm3 = [ 2 6 3 7]
+ punpckhwd_r2r(mm3, mm6); /* mm6 = 10 14 11 15] */
+ movq_r2r(mm4, mm3); /* mm3 = [ 2 6 3 7] */
- punpckldq_r2r(mm2, mm0); // final result mm0 = row1 [0 4 8 12]
+ punpckldq_r2r(mm2, mm0); /* final result mm0 = row1 [0 4 8 12] */
- punpckhdq_r2r(mm2, mm1); // mm1 = final result mm1 = row2 [1 5 9 13]
- ; // slot
+ punpckhdq_r2r(mm2, mm1); /* mm1 = final result mm1 = row2 [1 5 9 13] */
+ ; /* slot */
- movq_r2m(mm0, *(inptr + ROW_STRIDE*4 + 4)); // store row 1
- punpckldq_r2r(mm6, mm4); // final result mm4 = row3 [2 6 10 14]
+ movq_r2m(mm0, *(inptr + ROW_STRIDE*4 + 4)); /* store row 1 */
+ punpckldq_r2r(mm6, mm4); /* final result mm4 = row3 [2 6 10 14] */
movq_m2r(*(out + ROW_STRIDE * 4 ), mm0);
- punpckhdq_r2r(mm6, mm3); // final result mm3 = row4 [3 7 11 15]
+ punpckhdq_r2r(mm6, mm3); /* final result mm3 = row4 [3 7 11 15] */
- movq_r2m(mm4, *(inptr + ROW_STRIDE*6 + 4)); // store row 3
- movq_r2r(mm0, mm4); // mm4 = copy of row1[A B C D]
+ movq_r2m(mm4, *(inptr + ROW_STRIDE*6 + 4)); /* store row 3 */
+ movq_r2r(mm0, mm4); /* mm4 = copy of row1[A B C D] */
- movq_r2m(mm1, *(inptr + ROW_STRIDE*5 + 4)); // store row 2
- ; // slot
+ movq_r2m(mm1, *(inptr + ROW_STRIDE*5 + 4)); /* store row 2 */
+ ; /* slot */
movq_m2r(*(out + ROW_STRIDE * 5 ), mm1);
- ; // slot
+ ; /* slot */
- movq_r2m(mm3, *(inptr + ROW_STRIDE*7 + 4)); // store row 4
- punpcklwd_r2r(mm1, mm0); // mm0 = [ 0 4 1 5]
+ movq_r2m(mm3, *(inptr + ROW_STRIDE*7 + 4)); /* store row 4 */
+ punpcklwd_r2r(mm1, mm0); /* mm0 = [ 0 4 1 5] */
- // 3) transpose lower-left
-// movq mm0, qword ptr [OUT + ROW_STRIDE * 4 ]
+ /* 3) transpose lower-left */
+/* movq mm0, qword ptr [OUT + ROW_STRIDE * 4 ] */
-// movq mm1, qword ptr [OUT + ROW_STRIDE * 5 ]
-// movq mm4, mm0; // mm4 = copy of row1[A B C D]
+/* movq mm1, qword ptr [OUT + ROW_STRIDE * 5 ] */
+/* movq mm4, mm0; // mm4 = copy of row1[A B C D] */
movq_m2r(*(out + ROW_STRIDE * 6 ), mm2);
-// punpcklwd mm0, mm1; // mm0 = [ 0 4 1 5]
- punpckhwd_r2r(mm1, mm4); // mm4 = [ 2 6 3 7]
+/* punpcklwd mm0, mm1; // mm0 = [ 0 4 1 5] */
+ punpckhwd_r2r(mm1, mm4); /* mm4 = [ 2 6 3 7] */
movq_m2r(*(out + ROW_STRIDE * 7 ), mm3);
movq_r2r(mm2, mm6);
- punpcklwd_r2r(mm3, mm2); // mm2 = [ 8 12 9 13]
- movq_r2r(mm0, mm1); // mm1 = [ 0 4 1 5]
+ punpcklwd_r2r(mm3, mm2); /* mm2 = [ 8 12 9 13] */
+ movq_r2r(mm0, mm1); /* mm1 = [ 0 4 1 5] */
- punpckhwd_r2r(mm3, mm6); // mm6 = 10 14 11 15]
- movq_r2r(mm4, mm3); // mm3 = [ 2 6 3 7]
+ punpckhwd_r2r(mm3, mm6); /* mm6 = 10 14 11 15] */
+ movq_r2r(mm4, mm3); /* mm3 = [ 2 6 3 7] */
- punpckldq_r2r(mm2, mm0); // final result mm0 = row1 [0 4 8 12]
+ punpckldq_r2r(mm2, mm0); /* final result mm0 = row1 [0 4 8 12] */
- punpckhdq_r2r(mm2, mm1); // mm1 = final result mm1 = row2 [1 5 9 13]
- ;//slot
+ punpckhdq_r2r(mm2, mm1); /* mm1 = final result mm1 = row2 [1 5 9 13] */
+ ;/*slot */
- movq_r2m(mm0, *(inptr + ROW_STRIDE * 0 + 4 )); // store row 1
- punpckldq_r2r(mm6, mm4); // final result mm4 = row3 [2 6 10 14]
+ movq_r2m(mm0, *(inptr + ROW_STRIDE * 0 + 4 )); /* store row 1 */
+ punpckldq_r2r(mm6, mm4); /* final result mm4 = row3 [2 6 10 14] */
-// begin reading next quadrant (upper-right)
+/* begin reading next quadrant (upper-right) */
movq_m2r(*(out + ROW_STRIDE*0 + 4), mm0);
- punpckhdq_r2r(mm6, mm3); // final result mm3 = row4 [3 7 11 15]
+ punpckhdq_r2r(mm6, mm3); /* final result mm3 = row4 [3 7 11 15] */
- movq_r2m(mm4, *(inptr + ROW_STRIDE * 2 + 4)); // store row 3
- movq_r2r(mm0, mm4); // mm4 = copy of row1[A B C D]
+ movq_r2m(mm4, *(inptr + ROW_STRIDE * 2 + 4)); /* store row 3 */
+ movq_r2r(mm0, mm4); /* mm4 = copy of row1[A B C D] */
- movq_r2m(mm1, *(inptr + ROW_STRIDE * 1 + 4)); // store row 2
+ movq_r2m(mm1, *(inptr + ROW_STRIDE * 1 + 4)); /* store row 2 */
movq_m2r(*(out + ROW_STRIDE*1 + 4), mm1);
- movq_r2m(mm3, *(inptr + ROW_STRIDE * 3 + 4)); // store row 4
- punpcklwd_r2r(mm1, mm0); // mm0 = [ 0 4 1 5]
+ movq_r2m(mm3, *(inptr + ROW_STRIDE * 3 + 4)); /* store row 4 */
+ punpcklwd_r2r(mm1, mm0); /* mm0 = [ 0 4 1 5] */
- // 2) transpose lower-right quadrant
+ /* 2) transpose lower-right quadrant */
-// movq mm0, qword ptr [OUT + ROW_STRIDE*4 + 8]
+/* movq mm0, qword ptr [OUT + ROW_STRIDE*4 + 8] */
-// movq mm1, qword ptr [OUT + ROW_STRIDE*5 + 8]
-// movq mm4, mm0; // mm4 = copy of row1[A B C D]
+/* movq mm1, qword ptr [OUT + ROW_STRIDE*5 + 8] */
+/* movq mm4, mm0; // mm4 = copy of row1[A B C D] */
movq_m2r(*(out + ROW_STRIDE*2 + 4), mm2);
-// punpcklwd mm0, mm1; // mm0 = [ 0 4 1 5]
- punpckhwd_r2r(mm1, mm4); // mm4 = [ 2 6 3 7]
+/* punpcklwd mm0, mm1; // mm0 = [ 0 4 1 5] */
+ punpckhwd_r2r(mm1, mm4); /* mm4 = [ 2 6 3 7] */
movq_m2r(*(out + ROW_STRIDE*3 + 4), mm3);
movq_r2r(mm2, mm6);
- punpcklwd_r2r(mm3, mm2); // mm2 = [ 8 12 9 13]
- movq_r2r(mm0, mm1); // mm1 = [ 0 4 1 5]
+ punpcklwd_r2r(mm3, mm2); /* mm2 = [ 8 12 9 13] */
+ movq_r2r(mm0, mm1); /* mm1 = [ 0 4 1 5] */
- punpckhwd_r2r(mm3, mm6); // mm6 = 10 14 11 15]
- movq_r2r(mm4, mm3); // mm3 = [ 2 6 3 7]
+ punpckhwd_r2r(mm3, mm6); /* mm6 = 10 14 11 15] */
+ movq_r2r(mm4, mm3); /* mm3 = [ 2 6 3 7] */
- punpckldq_r2r(mm2, mm0); // final result mm0 = row1 [0 4 8 12]
+ punpckldq_r2r(mm2, mm0); /* final result mm0 = row1 [0 4 8 12] */
- punpckhdq_r2r(mm2, mm1); // mm1 = final result mm1 = row2 [1 5 9 13]
- ; // slot
+ punpckhdq_r2r(mm2, mm1); /* mm1 = final result mm1 = row2 [1 5 9 13] */
+ ; /* slot */
- movq_r2m(mm0, *(inptr + ROW_STRIDE*4)); // store row 1
- punpckldq_r2r(mm6, mm4); // final result mm4 = row3 [2 6 10 14]
+ movq_r2m(mm0, *(inptr + ROW_STRIDE*4)); /* store row 1 */
+ punpckldq_r2r(mm6, mm4); /* final result mm4 = row3 [2 6 10 14] */
- movq_r2m(mm1, *(inptr + ROW_STRIDE*5)); // store row 2
- punpckhdq_r2r(mm6, mm3); // final result mm3 = row4 [3 7 11 15]
+ movq_r2m(mm1, *(inptr + ROW_STRIDE*5)); /* store row 2 */
+ punpckhdq_r2r(mm6, mm3); /* final result mm3 = row4 [3 7 11 15] */
- movq_r2m(mm4, *(inptr + ROW_STRIDE*6)); // store row 3
- ; // slot
+ movq_r2m(mm4, *(inptr + ROW_STRIDE*6)); /* store row 3 */
+ ; /* slot */
- movq_r2m(mm3, *(inptr + ROW_STRIDE*7)); // store row 4
- ; // slot
+ movq_r2m(mm3, *(inptr + ROW_STRIDE*7)); /* store row 4 */
+ ; /* slot */
}
static void
-idct_mmx32_cols( short *blk ) // transform all 8 cols of 8x8 iDCT block
+idct_mmx32_cols( short *blk ) /* transform all 8 cols of 8x8 iDCT block */
{
int x;
short *inptr = blk;
- // Despite the function's name, the matrix is transformed
- // row by row. This function is identical to idct_mmx32_rows(),
- // except for the SHIFT amount and ROUND_INV amount.
+ /* Despite the function's name, the matrix is transformed */
+ /* row by row. This function is identical to idct_mmx32_rows(), */
+ /* except for the SHIFT amount and ROUND_INV amount. */
- // this subroutine performs two operations
- // 1) iDCT row transform
- // for( i = 0; i < 8; ++ i)
- // DCT_8_INV_ROW_1( blk[i*8], qwTemp[i] );
- //
- // 2) transpose the matrix (which was stored in qwTemp[])
- // qwTemp[] -> [8x8 matrix transpose] -> blk[]
+ /* this subroutine performs two operations */
+ /* 1) iDCT row transform */
+ /* for( i = 0; i < 8; ++ i) */
+ /* DCT_8_INV_ROW_1( blk[i*8], qwTemp[i] ); */
+ /* */
+ /* 2) transpose the matrix (which was stored in qwTemp[]) */
+ /* qwTemp[] -> [8x8 matrix transpose] -> blk[] */
- for (x=0; x<8; x++) { // transform one row per iteration
+ for (x=0; x<8; x++) { /* transform one row per iteration */
- movq_m2r(*(inptr), mm0); // 0 ; x3 x2 x1 x0
+ movq_m2r(*(inptr), mm0); /* 0 ; x3 x2 x1 x0 */
- movq_m2r(*(inptr+4), mm1); // 1 ; x7 x6 x5 x4
- movq_r2r(mm0, mm2); // 2 ; x3 x2 x1 x0
+ movq_m2r(*(inptr+4), mm1); /* 1 ; x7 x6 x5 x4 */
+ movq_r2r(mm0, mm2); /* 2 ; x3 x2 x1 x0 */
- movq_m2r(*(tab_i_01234567), mm3); // 3 ; w06 w04 w02 w00
- punpcklwd_r2r(mm1, mm0); // x5 x1 x4 x0
+ movq_m2r(*(tab_i_01234567), mm3); /* 3 ; w06 w04 w02 w00 */
+ punpcklwd_r2r(mm1, mm0); /* x5 x1 x4 x0 */
-// ----------
- movq_r2r(mm0, mm5); // 5 ; x5 x1 x4 x0
- punpckldq_r2r(mm0, mm0); // x4 x0 x4 x0
+/* ---------- */
+ movq_r2r(mm0, mm5); /* 5 ; x5 x1 x4 x0 */
+ punpckldq_r2r(mm0, mm0); /* x4 x0 x4 x0 */
- movq_m2r(*(tab_i_01234567+4), mm4); // 4 ; w07 w05 w03 w01
- punpckhwd_r2r(mm1, mm2); // 1 ; x7 x3 x6 x2
+ movq_m2r(*(tab_i_01234567+4), mm4); /* 4 ; w07 w05 w03 w01 */
+ punpckhwd_r2r(mm1, mm2); /* 1 ; x7 x3 x6 x2 */
- pmaddwd_r2r(mm0, mm3); // x4*w06+x0*w04 x4*w02+x0*w00
- movq_r2r(mm2, mm6); // 6 ; x7 x3 x6 x2
+ pmaddwd_r2r(mm0, mm3); /* x4*w06+x0*w04 x4*w02+x0*w00 */
+ movq_r2r(mm2, mm6); /* 6 ; x7 x3 x6 x2 */
- movq_m2r(*(tab_i_01234567+16), mm1);// 1 ; w22 w20 w18 w16
- punpckldq_r2r(mm2, mm2); // x6 x2 x6 x2
+ movq_m2r(*(tab_i_01234567+16), mm1);/* 1 ; w22 w20 w18 w16 */
+ punpckldq_r2r(mm2, mm2); /* x6 x2 x6 x2 */
- pmaddwd_r2r(mm2, mm4); // x6*w07+x2*w05 x6*w03+x2*w01
- punpckhdq_r2r(mm5, mm5); // x5 x1 x5 x1
+ pmaddwd_r2r(mm2, mm4); /* x6*w07+x2*w05 x6*w03+x2*w01 */
+ punpckhdq_r2r(mm5, mm5); /* x5 x1 x5 x1 */
- pmaddwd_m2r(*(tab_i_01234567+8), mm0);// x4*w14+x0*w12 x4*w10+x0*w08
- punpckhdq_r2r(mm6, mm6); // x7 x3 x7 x3
+ pmaddwd_m2r(*(tab_i_01234567+8), mm0);/* x4*w14+x0*w12 x4*w10+x0*w08 */
+ punpckhdq_r2r(mm6, mm6); /* x7 x3 x7 x3 */
- movq_m2r(*(tab_i_01234567+20), mm7);// 7 ; w23 w21 w19 w17
- pmaddwd_r2r(mm5, mm1); // x5*w22+x1*w20 x5*w18+x1*w16
+ movq_m2r(*(tab_i_01234567+20), mm7);/* 7 ; w23 w21 w19 w17 */
+ pmaddwd_r2r(mm5, mm1); /* x5*w22+x1*w20 x5*w18+x1*w16 */
- paddd_m2r(*(r_inv_col), mm3);// +rounder
- pmaddwd_r2r(mm6, mm7); // x7*w23+x3*w21 x7*w19+x3*w17
+ paddd_m2r(*(r_inv_col), mm3);/* +rounder */
+ pmaddwd_r2r(mm6, mm7); /* x7*w23+x3*w21 x7*w19+x3*w17 */
- pmaddwd_m2r(*(tab_i_01234567+12), mm2);// x6*w15+x2*w13 x6*w11+x2*w09
- paddd_r2r(mm4, mm3); // 4 ; a1=sum(even1) a0=sum(even0)
+ pmaddwd_m2r(*(tab_i_01234567+12), mm2);/* x6*w15+x2*w13 x6*w11+x2*w09 */
+ paddd_r2r(mm4, mm3); /* 4 ; a1=sum(even1) a0=sum(even0) */
- pmaddwd_m2r(*(tab_i_01234567+24), mm5);// x5*w30+x1*w28 x5*w26+x1*w24
- movq_r2r(mm3, mm4); // 4 ; a1 a0
+ pmaddwd_m2r(*(tab_i_01234567+24), mm5);/* x5*w30+x1*w28 x5*w26+x1*w24 */
+ movq_r2r(mm3, mm4); /* 4 ; a1 a0 */
- pmaddwd_m2r(*(tab_i_01234567+28), mm6);// x7*w31+x3*w29 x7*w27+x3*w25
- paddd_r2r(mm7, mm1); // 7 ; b1=sum(odd1) b0=sum(odd0)
+ pmaddwd_m2r(*(tab_i_01234567+28), mm6);/* x7*w31+x3*w29 x7*w27+x3*w25 */
+ paddd_r2r(mm7, mm1); /* 7 ; b1=sum(odd1) b0=sum(odd0) */
- paddd_m2r(*(r_inv_col), mm0);// +rounder
- psubd_r2r(mm1, mm3); // a1-b1 a0-b0
+ paddd_m2r(*(r_inv_col), mm0);/* +rounder */
+ psubd_r2r(mm1, mm3); /* a1-b1 a0-b0 */
- psrad_i2r(SHIFT_INV_COL, mm3); // y6=a1-b1 y7=a0-b0
- paddd_r2r(mm4, mm1); // 4 ; a1+b1 a0+b0
+ psrad_i2r(SHIFT_INV_COL, mm3); /* y6=a1-b1 y7=a0-b0 */
+ paddd_r2r(mm4, mm1); /* 4 ; a1+b1 a0+b0 */
- paddd_r2r(mm2, mm0); // 2 ; a3=sum(even3) a2=sum(even2)
- psrad_i2r(SHIFT_INV_COL, mm1); // y1=a1+b1 y0=a0+b0
+ paddd_r2r(mm2, mm0); /* 2 ; a3=sum(even3) a2=sum(even2) */
+ psrad_i2r(SHIFT_INV_COL, mm1); /* y1=a1+b1 y0=a0+b0 */
- paddd_r2r(mm6, mm5); // 6 ; b3=sum(odd3) b2=sum(odd2)
- movq_r2r(mm0, mm4); // 4 ; a3 a2
+ paddd_r2r(mm6, mm5); /* 6 ; b3=sum(odd3) b2=sum(odd2) */
+ movq_r2r(mm0, mm4); /* 4 ; a3 a2 */
- paddd_r2r(mm5, mm0); // a3+b3 a2+b2
- psubd_r2r(mm5, mm4); // 5 ; a3-b3 a2-b2
+ paddd_r2r(mm5, mm0); /* a3+b3 a2+b2 */
+ psubd_r2r(mm5, mm4); /* 5 ; a3-b3 a2-b2 */
- psrad_i2r(SHIFT_INV_COL, mm4); // y4=a3-b3 y5=a2-b2
- psrad_i2r(SHIFT_INV_COL, mm0); // y3=a3+b3 y2=a2+b2
+ psrad_i2r(SHIFT_INV_COL, mm4); /* y4=a3-b3 y5=a2-b2 */
+ psrad_i2r(SHIFT_INV_COL, mm0); /* y3=a3+b3 y2=a2+b2 */
- packssdw_r2r(mm3, mm4); // 3 ; y6 y7 y4 y5
+ packssdw_r2r(mm3, mm4); /* 3 ; y6 y7 y4 y5 */
- packssdw_r2r(mm0, mm1); // 0 ; y3 y2 y1 y0
- movq_r2r(mm4, mm7); // 7 ; y6 y7 y4 y5
+ packssdw_r2r(mm0, mm1); /* 0 ; y3 y2 y1 y0 */
+ movq_r2r(mm4, mm7); /* 7 ; y6 y7 y4 y5 */
- psrld_i2r(16, mm4); // 0 y6 0 y4
+ psrld_i2r(16, mm4); /* 0 y6 0 y4 */
- movq_r2m(mm1, *(inptr)); // 1 ; save y3 y2 y1 y0
- pslld_i2r(16, mm7); // y7 0 y5 0
+ movq_r2m(mm1, *(inptr)); /* 1 ; save y3 y2 y1 y0 */
+ pslld_i2r(16, mm7); /* y7 0 y5 0 */
- por_r2r(mm4, mm7); // 4 ; y7 y6 y5 y4
+ por_r2r(mm4, mm7); /* 4 ; y7 y6 y5 y4 */
- // begin processing row 1
- movq_r2m(mm7, *(inptr+4)); // 7 ; save y7 y6 y5 y4
+ /* begin processing row 1 */
+ movq_r2m(mm7, *(inptr+4)); /* 7 ; save y7 y6 y5 y4 */
inptr += 8;
}
- // done with the iDCT column-transformation
+ /* done with the iDCT column-transformation */
}
-//
-// public interface to MMX32 IDCT 8x8 operation
-//
+/* */
+/* public interface to MMX32 IDCT 8x8 operation */
+/* */
void
gst_idct_mmx32_idct( short *blk )
{
- // 1) iDCT row transformation
- idct_mmx32_rows( blk ); // 1) transform iDCT row, and transpose
+ /* 1) iDCT row transformation */
+ idct_mmx32_rows( blk ); /* 1) transform iDCT row, and transpose */
- // 2) iDCT column transformation
- idct_mmx32_cols( blk ); // 2) transform iDCT row, and transpose
+ /* 2) iDCT column transformation */
+ idct_mmx32_cols( blk ); /* 2) transform iDCT row, and transpose */
- emms(); // restore processor state
- // all done
+ emms(); /* restore processor state */
+ /* all done */
}
diff --git a/gst-libs/gst/resample/Makefile.am b/gst-libs/gst/resample/Makefile.am
index c1def79d..f7056789 100644
--- a/gst-libs/gst/resample/Makefile.am
+++ b/gst-libs/gst/resample/Makefile.am
@@ -13,7 +13,7 @@ endif
endif
libgstresample_la_SOURCES = dtos.c functable.c resample.c resample.h
-libgstresample_la_LIBADD = $(GST_LIBS)
+libgstresample_la_LIBADD =
libgstresample_la_CFLAGS = $(GST_CFLAGS) -ffast-math $(ARCHCFLAGS)
libgstresample_la_LDFLAGS = $(GST_PLUGIN_LDFLAGS)
diff --git a/gst-libs/gst/resample/dtos.c b/gst-libs/gst/resample/dtos.c
index 7762595f..96bfe41d 100644
--- a/gst-libs/gst/resample/dtos.c
+++ b/gst-libs/gst/resample/dtos.c
@@ -23,13 +23,13 @@
#include <stdio.h>
#include <stdlib.h>
-//#include <ml.h>
+/*#include <ml.h> */
#include <resample.h>
#define short_to_double_table
-//#define short_to_double_altivec
+/*#define short_to_double_altivec */
#define short_to_double_unroll
#ifdef short_to_double_table
diff --git a/gst-libs/gst/resample/functable.c b/gst-libs/gst/resample/functable.c
index d61efca4..c225958e 100644
--- a/gst-libs/gst/resample/functable.c
+++ b/gst-libs/gst/resample/functable.c
@@ -124,12 +124,12 @@ double functable_eval(functable_t *t,double x)
w0 = (x - 2 * x2 + x3) * t->offset;
w1 = (-x2 + x3) * t->offset;
- //printf("i=%d x=%g f0=%g f1=%g w0=%g w1=%g\n",i,x,f0,f1,w0,w1);
+ /*printf("i=%d x=%g f0=%g f1=%g w0=%g w1=%g\n",i,x,f0,f1,w0,w1); */
w = t->fx[i] * f0 + t->fx[i + 1] * f1 +
t->fdx[i] * w0 + t->fdx[i + 1] * w1;
- //w = t->fx[i] * (1-x) + t->fx[i+1] * x;
+ /*w = t->fx[i] * (1-x) + t->fx[i+1] * x; */
return w;
}
@@ -266,37 +266,37 @@ void functable_fir2_altivec(functable_t *t, float *r0, float *r1,
sum0 = 0;
sum1 = 0;
for(j=0;j<len;j++){
- // t->fx, t->fdx needs to be multiplexed by n
- // we need 5 consecutive floats, which fit into 2 vecs
- // load v0, t->fx[i]
- // load v1, t->fx[i+n]
- // v2 = v0 (not correct)
- // v3 = (v0>>32) || (v1<<3*32) (not correct)
- //
- // load v4, t->dfx[i]
- // load v5, t->dfx[i+n]
- // v6 = v4 (not correct)
- // v7 = (v4>>32) || (v5<<3*32) (not correct)
- //
- // v8 = splat(f0)
- // v9 = splat(f1)
- // v10 = splat(w0)
- // v11 = splat(w1)
- //
- // v12 = v2 * v8
- // v12 += v3 * v9
- // v12 += v6 * v10
- // v12 += v7 * v11
+ /* t->fx, t->fdx needs to be multiplexed by n */
+ /* we need 5 consecutive floats, which fit into 2 vecs */
+ /* load v0, t->fx[i] */
+ /* load v1, t->fx[i+n] */
+ /* v2 = v0 (not correct) */
+ /* v3 = (v0>>32) || (v1<<3*32) (not correct) */
+ /* */
+ /* load v4, t->dfx[i] */
+ /* load v5, t->dfx[i+n] */
+ /* v6 = v4 (not correct) */
+ /* v7 = (v4>>32) || (v5<<3*32) (not correct) */
+ /* */
+ /* v8 = splat(f0) */
+ /* v9 = splat(f1) */
+ /* v10 = splat(w0) */
+ /* v11 = splat(w1) */
+ /* */
+ /* v12 = v2 * v8 */
+ /* v12 += v3 * v9 */
+ /* v12 += v6 * v10 */
+ /* v12 += v7 * v11 */
w = t->fx[i] * f0 + t->fx[i + 1] * f1 +
t->fdx[i] * w0 + t->fdx[i + 1] * w1;
- // v13 = data[j*2]
- // v14 = data[j*2+4]
- // v15 = deinterlace_high(v13,v14)
- // v16 = deinterlace_low(v13,v14)
- // (sum0) v17 += multsum(v13,v15)
- // (sum1) v18 += multsum(v14,v16)
+ /* v13 = data[j*2] */
+ /* v14 = data[j*2+4] */
+ /* v15 = deinterlace_high(v13,v14) */
+ /* v16 = deinterlace_low(v13,v14) */
+ /* (sum0) v17 += multsum(v13,v15) */
+ /* (sum1) v18 += multsum(v14,v16) */
sum0 += data[j*2] * w;
sum1 += data[j*2+1] * w;
diff --git a/gst-libs/gst/resample/resample.c b/gst-libs/gst/resample/resample.c
index cedb874e..286cb84b 100644
--- a/gst-libs/gst/resample/resample.c
+++ b/gst-libs/gst/resample/resample.c
@@ -243,7 +243,7 @@ void resample_bilinear(resample_t * r)
b = r->i_start;
for (i = 0; i < r->i_samples; i++) {
b += r->i_inc;
- //printf("in %d\n",i_ptr[0]);
+ /*printf("in %d\n",i_ptr[0]); */
if(b>=2){
printf("not expecting b>=2\n");
}
@@ -252,7 +252,7 @@ void resample_bilinear(resample_t * r)
acc1 += (1.0 - (b-r->i_inc)) * i_ptr[1];
o_ptr[0] = rint(acc0);
- //printf("out %d\n",o_ptr[0]);
+ /*printf("out %d\n",o_ptr[0]); */
o_ptr[1] = rint(acc1);
o_ptr += 2;
o_count++;
@@ -319,8 +319,8 @@ void resample_sinc_slow(resample_t * r)
c1 = 0;
for (j = 0; j < r->filter_length; j++) {
weight = (x==0)?1:(sinx/x);
-//printf("j %d sin %g cos %g\n",j,sinx,cosx);
-//printf("j %d sin %g x %g sinc %g\n",j,sinx,x,weight);
+/*printf("j %d sin %g cos %g\n",j,sinx,cosx); */
+/*printf("j %d sin %g x %g sinc %g\n",j,sinx,x,weight); */
c0 += weight * GETBUF((start + j), 0);
c1 += weight * GETBUF((start + j), 1);
t = cosx * cosd - sinx * sind;
@@ -368,11 +368,11 @@ void resample_sinc(resample_t * r)
for (i = 0; i < r->o_samples; i++) {
a = r->o_start + i * r->o_inc;
start = floor(a - r->halftaps);
-//printf("%d: a=%g start=%d end=%d\n",i,a,start,start+r->filter_length-1);
+/*printf("%d: a=%g start=%d end=%d\n",i,a,start,start+r->filter_length-1); */
center = a;
- //x = M_PI * (start - center) * r->o_inc;
- //d = M_PI * r->o_inc;
- //x = (start - center) * r->o_inc;
+ /*x = M_PI * (start - center) * r->o_inc; */
+ /*d = M_PI * r->o_inc; */
+ /*x = (start - center) * r->o_inc; */
x0 = (start - center) * r->o_inc;
d = r->o_inc;
c0 = 0;
@@ -439,20 +439,20 @@ static void resample_sinc_ft(resample_t * r)
double *ptr;
signed short *o_ptr;
int i;
- //int j;
+ /*int j; */
double c0, c1;
- //double a;
+ /*double a; */
double start_f, start_x;
int start;
double center;
- //double weight;
+ /*double weight; */
double x, d;
double scale;
int n = 4;
- scale = r->i_inc; // cutoff at 22050
- //scale = 1.0; // cutoff at 24000
- //scale = r->i_inc * 0.5; // cutoff at 11025
+ scale = r->i_inc; /* cutoff at 22050 */
+ /*scale = 1.0; // cutoff at 24000 */
+ /*scale = r->i_inc * 0.5; // cutoff at 11025 */
if(!ft){
ft = malloc(sizeof(*ft));
@@ -472,7 +472,7 @@ static void resample_sinc_ft(resample_t * r)
functable_init(ft);
- //printf("len=%d offset=%g start=%g\n",ft->len,ft->offset,ft->start);
+ /*printf("len=%d offset=%g start=%g\n",ft->len,ft->offset,ft->start); */
}
ptr = r->buffer;
@@ -484,18 +484,18 @@ static void resample_sinc_ft(resample_t * r)
start_x -= start_f;
start = start_f;
for (i = 0; i < r->o_samples; i++) {
- //start_f = floor(center - r->halftaps);
-//printf("%d: a=%g start=%d end=%d\n",i,a,start,start+r->filter_length-1);
+ /*start_f = floor(center - r->halftaps); */
+/*printf("%d: a=%g start=%d end=%d\n",i,a,start,start+r->filter_length-1); */
x = start_f - center;
d = 1;
c0 = 0;
c1 = 0;
-//#define slow
+/*#define slow */
#ifdef slow
for (j = 0; j < r->filter_length; j++) {
weight = functable_eval(ft,x)*scale;
- //weight = sinc(M_PI * scale * x)*scale*r->i_inc;
- //weight *= window_func(x / r->halftaps);
+ /*weight = sinc(M_PI * scale * x)*scale*r->i_inc; */
+ /*weight *= window_func(x / r->halftaps); */
c0 += weight * ptr[(start + j + r->filter_length)*2 + 0];
c1 += weight * ptr[(start + j + r->filter_length)*2 + 1];
x += d;
diff --git a/gst-libs/gst/resample/test.c b/gst-libs/gst/resample/test.c
index 44d19a65..f268a592 100644
--- a/gst-libs/gst/resample/test.c
+++ b/gst-libs/gst/resample/test.c
@@ -9,11 +9,11 @@
#define AMP 16000
#define I_RATE 48000
#define O_RATE 44100
-//#define O_RATE 24000
+/*#define O_RATE 24000 */
-//#define test_func(x) 1
-//#define test_func(x) sin(2*M_PI*(x)*10)
-//#define test_func(x) sin(2*M_PI*(x)*(x)*1000)
+/*#define test_func(x) 1 */
+/*#define test_func(x) sin(2*M_PI*(x)*10) */
+/*#define test_func(x) sin(2*M_PI*(x)*(x)*1000) */
#define test_func(x) sin(2*M_PI*(x)*(x)*12000)
short i_buf[I_RATE*2*2];
@@ -53,7 +53,7 @@ struct timeval start_time;
void start_timer(void)
{
gettimeofday(&start_time,NULL);
- //printf("start %ld.%06ld\n",start_time.tv_sec,start_time.tv_usec);
+ /*printf("start %ld.%06ld\n",start_time.tv_sec,start_time.tv_usec); */
}
void end_timer(void)
@@ -62,7 +62,7 @@ void end_timer(void)
double diff;
gettimeofday(&end_time,NULL);
- //printf("end %ld.%06ld\n",end_time.tv_sec,end_time.tv_usec);
+ /*printf("end %ld.%06ld\n",end_time.tv_sec,end_time.tv_usec); */
diff = (end_time.tv_sec - start_time.tv_sec) +
1e-6*(end_time.tv_usec - start_time.tv_usec);
@@ -81,7 +81,7 @@ void test_res1(void)
for(i=0;i<I_RATE;i++){
i_buf[i*2+0] = rint(AMP * test_func((double)i/I_RATE));
- //i_buf[i*2+1] = rint(AMP * test_func((double)i/I_RATE));
+ /*i_buf[i*2+1] = rint(AMP * test_func((double)i/I_RATE)); */
i_buf[i*2+1] = (i<1000)?AMP:0;
}
@@ -90,10 +90,10 @@ void test_res1(void)
r->i_rate = I_RATE;
r->o_rate = O_RATE;
- //r->method = RESAMPLE_SINC_SLOW;
+ /*r->method = RESAMPLE_SINC_SLOW; */
r->method = RESAMPLE_SINC;
r->channels = 2;
- //r->verbose = 1;
+ /*r->verbose = 1; */
r->filter_length = 64;
r->get_buffer = get_buffer;
@@ -115,7 +115,7 @@ void test_res1(void)
for(i=0;i<O_RATE;i++){
f = AMP*test_func((double)i/O_RATE);
- //f = rint(AMP*test_func((double)i/O_RATE));
+ /*f = rint(AMP*test_func((double)i/O_RATE)); */
fprintf(out,"%d %d %d %g %g\n",i,
o_buf[2*i+0],o_buf[2*i+1],
f,o_buf[2*i+0]-f);
@@ -127,7 +127,7 @@ void test_res1(void)
n22k=0;
for(i=0;i<O_RATE;i++){
f = AMP*test_func((double)i/O_RATE);
- //f = rint(AMP*test_func((double)i/O_RATE));
+ /*f = rint(AMP*test_func((double)i/O_RATE)); */
x = o_buf[2*i+0]-f;
if(((0.5*i)/O_RATE*I_RATE)<10000){
sum10k += x*x;
@@ -219,8 +219,8 @@ double sinc_poly(double x)
- x2 * INV3FAC
+ x2 * x2 * INV5FAC
- x2 * x2 * x2 * INV7FAC;
- //+ x2 * x2 * x2 * x2 * INV9FAC
- //- x2 * x2 * x2 * x2 * x2 * INV11FAC;
+ /*+ x2 * x2 * x2 * x2 * INV9FAC */
+ /*- x2 * x2 * x2 * x2 * x2 * INV11FAC; */
}
void test_res4(void)
@@ -297,10 +297,10 @@ void test_res7(void)
r->i_rate = I_RATE;
r->o_rate = O_RATE;
- //r->method = RESAMPLE_SINC_SLOW;
+ /*r->method = RESAMPLE_SINC_SLOW; */
r->method = RESAMPLE_SINC;
r->channels = 1;
- //r->verbose = 1;
+ /*r->verbose = 1; */
r->filter_length = 64;
r->get_buffer = get_buffer;
@@ -322,7 +322,7 @@ void test_res7(void)
for(i=0;i<O_RATE;i++){
f = AMP*test_func((double)i/O_RATE);
- //f = rint(AMP*test_func((double)i/O_RATE));
+ /*f = rint(AMP*test_func((double)i/O_RATE)); */
fprintf(out,"%d %d %d %g %g\n",i,
o_buf[i],0,
f,o_buf[i]-f);
@@ -334,7 +334,7 @@ void test_res7(void)
n22k=0;
for(i=0;i<O_RATE;i++){
f = AMP*test_func((double)i/O_RATE);
- //f = rint(AMP*test_func((double)i/O_RATE));
+ /*f = rint(AMP*test_func((double)i/O_RATE)); */
x = o_buf[i]-f;
if(((0.5*i)/O_RATE*I_RATE)<10000){
sum10k += x*x;
diff --git a/gst-libs/gst/riff/Makefile.am b/gst-libs/gst/riff/Makefile.am
index c0931c8a..deaa0bcc 100644
--- a/gst-libs/gst/riff/Makefile.am
+++ b/gst-libs/gst/riff/Makefile.am
@@ -7,6 +7,6 @@ libgstriff_la_SOURCES = riffparse.c riffencode.c riffutil.c
libgstriffincludedir = $(includedir)/gst/riff
libgstriffinclude_HEADERS = riff.h
-libgstriff_la_LIBADD = $(GST_LIBS)
+libgstriff_la_LIBADD =
libgstriff_la_CFLAGS = $(GST_CFLAGS) -funroll-all-loops -finline-functions -ffast-math
libgstriff_la_LDFLAGS = $(GST_PLUGIN_LDFLAGS)
diff --git a/gst-libs/gst/riff/riff.c b/gst-libs/gst/riff/riff.c
index e0bb7293..0ac4ee88 100644
--- a/gst-libs/gst/riff/riff.c
+++ b/gst-libs/gst/riff/riff.c
@@ -20,7 +20,7 @@
#include <riff.h>
-//#define debug(format,args...) g_print(format,##args)
+/*#define debug(format,args...) g_print(format,##args) */
#define debug(format,args...)
@@ -69,33 +69,33 @@ gint gst_riff_next_buffer(GstRiff *riff,GstBuffer *buf,gulong off) {
GST_BUFFER_DATA(buf) = riff->dataleft;
GST_BUFFER_SIZE(buf) = newsize;
off -= riff->dataleft_size;
- //last -= riff->dataleft_size;
+ /*last -= riff->dataleft_size; */
riff->dataleft = NULL;
}
if (off == 0) {
guint32 *words = (guin32 *)GST_BUFFER_DATA(buf);
- // don't even try to parse the head if it's not there FIXME
+ /* don't even try to parse the head if it's not there FIXME */
if (last < 12) {
riff->state = GST_RIFF_ENOTRIFF;
return riff->state;
}
- //g_print("testing is 0x%08lx '%s'\n",words[0],gst_riff_id_to_fourcc(words[0]));
+ /*g_print("testing is 0x%08lx '%s'\n",words[0],gst_riff_id_to_fourcc(words[0])); */
/* verify this is a valid RIFF file, first of all */
if (GUINT32_FROM_LE (words[0]) != GST_RIFF_TAG_RIFF) {
riff->state = GST_RIFF_ENOTRIFF;
return riff->state;
}
riff->form = GUINT32_FROM_LE (words[2]);
- //g_print("form is 0x%08lx '%s'\n",words[2],gst_riff_id_to_fourcc(words[2]));
+ /*g_print("form is 0x%08lx '%s'\n",words[2],gst_riff_id_to_fourcc(words[2])); */
riff->nextlikely = 12; /* skip 'RIFF', length, and form */
- // all OK here
+ /* all OK here */
riff->incomplete_chunk = NULL;
}
- // if we have an incomplete chunk from the previous buffer
+ /* if we have an incomplete chunk from the previous buffer */
if (riff->incomplete_chunk) {
guint leftover;
debug("have incomplete chunk %08x filled\n", riff->incomplete_chunk_size);
@@ -135,14 +135,14 @@ gint gst_riff_next_buffer(GstRiff *riff,GstBuffer *buf,gulong off) {
while ((riff->nextlikely+12) <= last) {
guin32 *words = (guin32 *)((guchar *)GST_BUFFER_DATA(buf) + riff->nextlikely - off );
- // loop over all of the chunks to check which one is finished
+ /* loop over all of the chunks to check which one is finished */
while (riff->chunks) {
chunk = g_list_nth_data(riff->chunks, 0);
debug("next 0x%08x offset 0x%08lx size 0x%08x\n",riff->nextlikely, chunk->offset, chunk->size);
if (riff->nextlikely >= chunk->offset+chunk->size) {
- //g_print("found END LIST\n");
- // we have the end of the chunk on the stack, remove it
+ /*g_print("found END LIST\n"); */
+ /* we have the end of the chunk on the stack, remove it */
riff->chunks = g_list_remove(riff->chunks, chunk);
}
else break;
@@ -157,17 +157,17 @@ gint gst_riff_next_buffer(GstRiff *riff,GstBuffer *buf,gulong off) {
chunk->id = GUINT32_FROM_LE (words[0]));
chunk->size = GUINT32_FROM_LE (words[1]);
chunk->data = (gchar *)(words+2);
- // we need word alignment
- //if (chunk->size & 0x01) chunk->size++;
+ /* we need word alignment */
+ /*if (chunk->size & 0x01) chunk->size++; */
chunk->form = GUINT32_FROM_LE (words[2]); /* fill in the form, might not be valid */
if (chunk->id == GST_RIFF_TAG_LIST) {
- //g_print("found LIST %s\n", gst_riff_id_to_fourcc(chunk->form));
+ /*g_print("found LIST %s\n", gst_riff_id_to_fourcc(chunk->form)); */
riff->nextlikely += 12;
- // we push the list chunk on our 'stack'
+ /* we push the list chunk on our 'stack' */
riff->chunks = g_list_prepend(riff->chunks,chunk);
- // send the buffer to the listener if we have received a function
+ /* send the buffer to the listener if we have received a function */
if (riff->new_tag_found) {
riff->new_tag_found(chunk, riff->callback_data);
}
@@ -178,25 +178,25 @@ gint gst_riff_next_buffer(GstRiff *riff,GstBuffer *buf,gulong off) {
gst_riff_id_to_fourcc(GUINT32_FROM_LE (words[0])), GUINT32_FROM_LE (words[1]));
riff->nextlikely += 8 + chunk->size; /* doesn't include hdr */
- // if this buffer is incomplete
+ /* if this buffer is incomplete */
if (riff->nextlikely > last) {
guint left = size - (riff->nextlikely - chunk->size - off);
- //g_print("make incomplete buffer %08x\n", left);
+ /*g_print("make incomplete buffer %08x\n", left); */
chunk->data = g_malloc(chunk->size);
memcpy(chunk->data, (gchar *)(words+2), left);
riff->incomplete_chunk = chunk;
riff->incomplete_chunk_size = left;
}
else {
- // send the buffer to the listener if we have received a function
+ /* send the buffer to the listener if we have received a function */
if (riff->new_tag_found) {
riff->new_tag_found(chunk, riff->callback_data);
}
g_free(chunk);
}
- //riff->chunks = g_list_prepend(riff->chunks,chunk);
+ /*riff->chunks = g_list_prepend(riff->chunks,chunk); */
}
}
diff --git a/gst-libs/gst/riff/riffencode.c b/gst-libs/gst/riff/riffencode.c
index a6caed9e..febf2599 100644
--- a/gst-libs/gst/riff/riffencode.c
+++ b/gst-libs/gst/riff/riffencode.c
@@ -19,7 +19,7 @@
#include <string.h>
-//#define DEBUG_ENABLED
+/*#define DEBUG_ENABLED */
#include "riff.h"
#define GST_RIFF_ENCODER_BUF_SIZE 1024
diff --git a/gst-libs/gst/riff/riffparse.c b/gst-libs/gst/riff/riffparse.c
index eb4746fc..c7fa3f75 100644
--- a/gst-libs/gst/riff/riffparse.c
+++ b/gst-libs/gst/riff/riffparse.c
@@ -19,7 +19,7 @@
#include <string.h>
-//#define DEBUG_ENABLED
+/*#define DEBUG_ENABLED */
#include <riff.h>
GstRiff*
@@ -71,33 +71,33 @@ gst_riff_parser_next_buffer (GstRiff *riff, GstBuffer *buf, gulong off)
GST_BUFFER_DATA(buf) = riff->dataleft;
size = GST_BUFFER_SIZE(buf) = newsize;
off -= riff->dataleft_size;
- //last -= riff->dataleft_size;
+ /*last -= riff->dataleft_size; */
riff->dataleft = NULL;
}
if (off == 0) {
guint32 *words = (guint32 *)GST_BUFFER_DATA(buf);
- // don't even try to parse the head if it's not there FIXME
+ /* don't even try to parse the head if it's not there FIXME */
if (last < 12) {
riff->state = GST_RIFF_ENOTRIFF;
return riff->state;
}
- //g_print("testing is 0x%08lx '%s'\n",words[0],gst_riff_id_to_fourcc(words[0]));
+ /*g_print("testing is 0x%08lx '%s'\n",words[0],gst_riff_id_to_fourcc(words[0])); */
/* verify this is a valid RIFF file, first of all */
if (GUINT32_FROM_LE (words[0]) != GST_RIFF_TAG_RIFF) {
riff->state = GST_RIFF_ENOTRIFF;
return riff->state;
}
riff->form = GUINT32_FROM_LE (words[2]);
- //g_print("form is 0x%08lx '%s'\n",words[2],gst_riff_id_to_fourcc(words[2]));
+ /*g_print("form is 0x%08lx '%s'\n",words[2],gst_riff_id_to_fourcc(words[2])); */
riff->nextlikely = 12; /* skip 'RIFF', length, and form */
- // all OK here
+ /* all OK here */
riff->incomplete_chunk = NULL;
}
- // if we have an incomplete chunk from the previous buffer
+ /* if we have an incomplete chunk from the previous buffer */
if (riff->incomplete_chunk) {
guint leftover;
GST_DEBUG (0,"gst_riff_parser: have incomplete chunk %08x filled\n", riff->incomplete_chunk_size);
@@ -130,7 +130,7 @@ gst_riff_parser_next_buffer (GstRiff *riff, GstBuffer *buf, gulong off)
while ((riff->nextlikely+12) <= last) {
guint32 *words = (guint32 *)((guchar *)GST_BUFFER_DATA(buf) + riff->nextlikely - off );
- // loop over all of the chunks to check which one is finished
+ /* loop over all of the chunks to check which one is finished */
while (riff->chunks) {
chunk = g_list_nth_data(riff->chunks, 0);
@@ -138,7 +138,7 @@ gst_riff_parser_next_buffer (GstRiff *riff, GstBuffer *buf, gulong off)
chunk->offset, chunk->size);
if (riff->nextlikely >= chunk->offset+chunk->size) {
GST_DEBUG (0,"gst_riff_parser: found END LIST\n");
- // we have the end of the chunk on the stack, remove it
+ /* we have the end of the chunk on the stack, remove it */
riff->chunks = g_list_remove(riff->chunks, chunk);
}
else break;
@@ -153,17 +153,17 @@ gst_riff_parser_next_buffer (GstRiff *riff, GstBuffer *buf, gulong off)
chunk->id = GUINT32_FROM_LE (words[0]);
chunk->size = GUINT32_FROM_LE (words[1]);
chunk->data = (gchar *)(words+2);
- // we need word alignment
- //if (chunk->size & 0x01) chunk->size++;
+ /* we need word alignment */
+ /*if (chunk->size & 0x01) chunk->size++; */
chunk->form = GUINT32_FROM_LE (words[2]); /* fill in the form, might not be valid */
if (chunk->id == GST_RIFF_TAG_LIST) {
GST_DEBUG (0,"found LIST %s\n", gst_riff_id_to_fourcc(chunk->form));
riff->nextlikely += 12;
- // we push the list chunk on our 'stack'
+ /* we push the list chunk on our 'stack' */
riff->chunks = g_list_prepend(riff->chunks,chunk);
- // send the buffer to the listener if we have received a function
+ /* send the buffer to the listener if we have received a function */
if (riff->new_tag_found) {
riff->new_tag_found(chunk, riff->callback_data);
}
@@ -175,7 +175,7 @@ gst_riff_parser_next_buffer (GstRiff *riff, GstBuffer *buf, gulong off)
gst_riff_id_to_fourcc(GUINT32_FROM_LE (words[0])), GUINT32_FROM_LE (words[1]));
riff->nextlikely += 8 + chunk->size; /* doesn't include hdr */
- // if this buffer is incomplete
+ /* if this buffer is incomplete */
if (riff->nextlikely > last) {
guint left = size - (riff->nextlikely - chunk->size - off);
@@ -186,7 +186,7 @@ gst_riff_parser_next_buffer (GstRiff *riff, GstBuffer *buf, gulong off)
riff->incomplete_chunk_size = left;
}
else {
- // send the buffer to the listener if we have received a function
+ /* send the buffer to the listener if we have received a function */
if (riff->new_tag_found) {
riff->new_tag_found(chunk, riff->callback_data);
}
@@ -194,7 +194,7 @@ gst_riff_parser_next_buffer (GstRiff *riff, GstBuffer *buf, gulong off)
}
if (riff->nextlikely & 0x01) riff->nextlikely++;
- //riff->chunks = g_list_prepend(riff->chunks,chunk);
+ /*riff->chunks = g_list_prepend(riff->chunks,chunk); */
}
}
if ((riff->nextlikely+12) > last && !riff->incomplete_chunk) {
diff --git a/gst-libs/gst/riff/riffutil.c b/gst-libs/gst/riff/riffutil.c
index ca01f6e6..9005279f 100644
--- a/gst-libs/gst/riff/riffutil.c
+++ b/gst-libs/gst/riff/riffutil.c
@@ -20,7 +20,7 @@
#include <riff.h>
-//#define debug(format,args...) g_print(format,##args)
+/*#define debug(format,args...) g_print(format,##args) */
#define debug(format,args...)