From aae071d922ffabcade0315e2691d671e4cb85478 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Sebastian=20Dr=C3=B6ge?= Date: Sat, 28 Jun 2008 17:25:56 +0000 Subject: gst/deinterlace2/tvtime/: Add a C implementation for the greedyh deinterlacing method, clean up the code a bit and ma... Original commit message from CVS: * gst/deinterlace2/tvtime/greedyh.asm: * gst/deinterlace2/tvtime/greedyh.c: (greedyDScaler_C), (deinterlace_frame_di_greedyh), (dscaler_greedyh_get_method): * gst/deinterlace2/tvtime/greedyhmacros.h: Add a C implementation for the greedyh deinterlacing method, clean up the code a bit and mark the SSE version as MMXEXT as it doesn't require any SSE instructions. --- gst/deinterlace2/tvtime/greedyh.c | 266 +++++++++++++++++++++++++++++++------- 1 file changed, 216 insertions(+), 50 deletions(-) (limited to 'gst/deinterlace2/tvtime/greedyh.c') diff --git a/gst/deinterlace2/tvtime/greedyh.c b/gst/deinterlace2/tvtime/greedyh.c index 623c2d8b..f9d33e74 100644 --- a/gst/deinterlace2/tvtime/greedyh.c +++ b/gst/deinterlace2/tvtime/greedyh.c @@ -41,51 +41,244 @@ #include "gstdeinterlace2.h" #include "speedy.h" +static const unsigned int GreedyMaxComb = 5; +static const unsigned int GreedyMotionThreshold = 25; +static const unsigned int GreedyMotionSense = 30; -#define MAXCOMB_DEFAULT 5 -#define MOTIONTHRESHOLD_DEFAULT 25 -#define MOTIONSENSE_DEFAULT 30 +void +greedyDScaler_C (uint8_t * L1, uint8_t * L2, uint8_t * L3, uint8_t * L2P, + uint8_t * Dest, int size) +{ + int Pos; + uint8_t l1_l, l1_1_l, l3_l, l3_1_l; + uint8_t l1_c, l1_1_c, l3_c, l3_1_c; + uint8_t avg_l, avg_c, avg_l_1, avg_c_1; + uint8_t avg_l__1 = 0, avg_c__1 = 0; + uint8_t avg_s_l, avg_s_c; + uint8_t avg_sc_l, avg_sc_c; + uint8_t best_l, best_c; + uint16_t mov_l; + uint8_t out_l, out_c; + uint8_t l2_l, l2_c, lp2_l, lp2_c; + uint8_t l2_l_diff, l2_c_diff, lp2_l_diff, lp2_c_diff; + uint8_t min_l, min_c, max_l, max_c; + + for (Pos = 0; Pos < size; Pos += 2) { + l1_l = L1[0]; + l1_c = L1[1]; + l3_l = L3[0]; + l3_c = L3[1]; + + if (Pos == size - 1) { + l1_1_l = l1_l; + l1_1_c = l1_c; + l3_1_l = l3_l; + l3_1_c = l3_c; + } else { + l1_1_l = L1[2]; + l1_1_c = L1[3]; + l3_1_l = L3[2]; + l3_1_c = L3[3]; + } + + /* Average of L1 and L3 */ + avg_l = (l1_l + l3_l) / 2; + avg_c = (l1_c + l3_c) / 2; + + /* Average of next L1 and next L3 */ + avg_l_1 = (l1_1_l + l3_1_l) / 2; + avg_c_1 = (l1_1_c + l3_1_c) / 2; + + /* Calculate average of one pixel forward and previous */ + avg_s_l = (avg_l__1 + avg_l_1) / 2; + avg_s_c = (avg_c__1 + avg_c_1) / 2; + + /* Calculate average of center and surrounding pixels */ + avg_sc_l = (avg_l + avg_s_l) / 2; + avg_sc_c = (avg_c + avg_s_c) / 2; + + /* move forward */ + avg_l__1 = avg_l; + avg_c__1 = avg_c; + + /* Get best L2/L2P, i.e. least diff from above average */ + l2_l = L2[0]; + l2_c = L2[1]; + lp2_l = L2P[0]; + lp2_c = L2P[1]; + + l2_l_diff = ABS (l2_l - avg_sc_l); + l2_c_diff = ABS (l2_c - avg_sc_c); + + lp2_l_diff = ABS (lp2_l - avg_sc_l); + lp2_c_diff = ABS (lp2_c - avg_sc_c); + + if (l2_l_diff > lp2_l_diff) + best_l = lp2_l; + else + best_l = l2_l; + + if (l2_c_diff > lp2_c_diff) + best_c = lp2_c; + else + best_c = l2_c; + + /* Clip this best L2/L2P by L1/L3 and allow to differ by GreedyMaxComb */ + max_l = MAX (l1_l, l3_l); + min_l = MIN (l1_l, l3_l); -unsigned int GreedyMaxComb; + if (max_l < 256 - GreedyMaxComb) + max_l += GreedyMaxComb; + else + max_l = 255; -unsigned int GreedyMotionThreshold; + if (min_l > GreedyMaxComb) + min_l -= GreedyMaxComb; + else + min_l = 0; -unsigned int GreedyMotionSense; + max_c = MAX (l1_c, l3_c); + min_c = MIN (l1_c, l3_c); + if (max_c < 256 - GreedyMaxComb) + max_c += GreedyMaxComb; + else + max_c = 255; -#define IS_SSE -#define SSE_TYPE SSE -#define FUNCT_NAME greedyDScaler_SSE + if (min_c > GreedyMaxComb) + min_c -= GreedyMaxComb; + else + min_c = 0; + + out_l = CLAMP (best_l, min_l, max_l); + out_c = CLAMP (best_c, min_c, max_c); + + /* Do motion compensation for luma, i.e. how much + * the weave pixel differs */ + mov_l = ABS (l2_l - lp2_l); + if (mov_l > GreedyMotionThreshold) + mov_l -= GreedyMotionThreshold; + else + mov_l = 0; + + mov_l = mov_l * GreedyMotionSense; + if (mov_l > 256) + mov_l = 256; + + /* Weighted sum on clipped weave pixel and average */ + out_l = (out_l * (256 - mov_l) + avg_sc_l * mov_l) / 256; + + Dest[0] = out_l; + Dest[1] = out_c; + + Dest += 2; + L1 += 2; + L2 += 2; + L3 += 2; + L2P += 2; + } +} + +#define IS_MMXEXT +#define SIMD_TYPE MMXEXT +#define FUNCT_NAME greedyDScaler_MMXEXT #include "greedyh.asm" -#undef SSE_TYPE -#undef IS_SSE +#undef SIMD_TYPE +#undef IS_MMXEXT #undef FUNCT_NAME -#define IS_3DNOW +#define IS_TDNOW +#define SIMD_TYPE TDNOW #define FUNCT_NAME greedyDScaler_3DNOW -#define SSE_TYPE 3DNOW #include "greedyh.asm" -#undef SSE_TYPE -#undef IS_3DNOW +#undef SIMD_TYPE +#undef IS_TDNOW #undef FUNCT_NAME #define IS_MMX -#define SSE_TYPE MMX +#define SIMD_TYPE MMX #define FUNCT_NAME greedyDScaler_MMX #include "greedyh.asm" -#undef SSE_TYPE +#undef SIMD_TYPE #undef IS_MMX #undef FUNCT_NAME -void +static void deinterlace_frame_di_greedyh (GstDeinterlace2 * object) { - if (object->cpu_feature_flags & OIL_IMPL_FLAG_SSE) { - greedyh_filter_sse (object); + void (*func) (uint8_t * L1, uint8_t * L2, uint8_t * L3, uint8_t * L2P, + uint8_t * Dest, int size); + + int InfoIsOdd = 0; + int Line; + unsigned int Pitch = object->field_stride; + + unsigned char *L1; // ptr to Line1, of 3 + unsigned char *L2; // ptr to Line2, the weave line + unsigned char *L3; // ptr to Line3 + + unsigned char *L2P; // ptr to prev Line2 + unsigned char *Dest = GST_BUFFER_DATA (object->out_buf); + + if (object->cpu_feature_flags & OIL_IMPL_FLAG_MMXEXT) { + func = greedyDScaler_MMXEXT; } else if (object->cpu_feature_flags & OIL_IMPL_FLAG_3DNOW) { - greedyh_filter_3dnow (object); + func = greedyDScaler_3DNOW; + } else if (object->cpu_feature_flags & OIL_IMPL_FLAG_MMX) { + func = greedyDScaler_MMX; } else { - greedyh_filter_mmx (object); + func = greedyDScaler_C; + } + + // copy first even line no matter what, and the first odd line if we're + // processing an EVEN field. (note diff from other deint rtns.) + + if (object->field_history[object->history_count - 1].flags == + PICTURE_INTERLACED_BOTTOM) { + InfoIsOdd = 1; + + L1 = GST_BUFFER_DATA (object->field_history[object->history_count - 2].buf); + L2 = GST_BUFFER_DATA (object->field_history[object->history_count - 1].buf); + L3 = L1 + Pitch; + L2P = + GST_BUFFER_DATA (object->field_history[object->history_count - 3].buf); + + // copy first even line + object->pMemcpy (Dest, L1, object->line_length); + Dest += object->output_stride; + } else { + InfoIsOdd = 0; + L1 = GST_BUFFER_DATA (object->field_history[object->history_count - 2].buf); + L2 = GST_BUFFER_DATA (object->field_history[object->history_count - + 1].buf) + Pitch; + L3 = L1 + Pitch; + L2P = + GST_BUFFER_DATA (object->field_history[object->history_count - 3].buf) + + Pitch; + + // copy first even line + object->pMemcpy (Dest, GST_BUFFER_DATA (object->field_history[0].buf), + object->line_length); + Dest += object->output_stride; + // then first odd line + object->pMemcpy (Dest, L1, object->line_length); + Dest += object->output_stride; + } + + for (Line = 0; Line < (object->field_height - 1); ++Line) { + func (L1, L2, L3, L2P, Dest, object->line_length); + Dest += object->output_stride; + object->pMemcpy (Dest, L3, object->line_length); + Dest += object->output_stride; + + L1 += Pitch; + L2 += Pitch; + L3 += Pitch; + L2P += Pitch; + } + + if (InfoIsOdd) { + object->pMemcpy (Dest, L2, object->line_length); } } @@ -94,7 +287,7 @@ static deinterlace_method_t greedyh_method = { "Motion Adaptive: Advanced Detection", "AdaptiveAdvanced", 4, - OIL_IMPL_FLAG_MMX, + 0, 0, 0, 0, @@ -117,32 +310,5 @@ static deinterlace_method_t greedyh_method = { deinterlace_method_t * dscaler_greedyh_get_method (void) { - greedyh_init (); return &greedyh_method; } - -void -greedyh_init (void) -{ - GreedyMaxComb = MAXCOMB_DEFAULT; - GreedyMotionThreshold = MOTIONTHRESHOLD_DEFAULT; - GreedyMotionSense = MOTIONSENSE_DEFAULT; -} - -void -greedyh_filter_mmx (GstDeinterlace2 * object) -{ - greedyDScaler_MMX (object); -} - -void -greedyh_filter_3dnow (GstDeinterlace2 * object) -{ - greedyDScaler_3DNOW (object); -} - -void -greedyh_filter_sse (GstDeinterlace2 * object) -{ - greedyDScaler_SSE (object); -} -- cgit v1.2.1