rendered paste bodyIndex: libhb/decomb.c===================================================================--- libhb/decomb.c (revision 1474)+++ libhb/decomb.c (working copy)@@ -230,6 +230,205 @@ } } +int tritical_detect_comb( hb_filter_private_t * pv )+{+ int x, y, i, j, k;+ + /* Motion threshold */+ int mthresh = 6;+ /* Spatial threshold */+ int athresh = 15;+ /* Block mask threshold -- The number of pixels+ in a 4x8 block of the mask that need to show+ combing for the whole frame to be seen as such. */+ int threshold = 15;+ + int color_equal = 10;+ int color_diff = 15;+ + /* Make a buffer to store a comb mask. */+ uint8_t * mask[3];+ for( i = 0; i < 3; i++ )+ {+ int is_chroma = !!i;+ int w = ((pv->width[0] + 31) & (~31))>>is_chroma;+ int h = ((pv->height[0]+6+ 31) & (~31))>>is_chroma;++ mask[i] = malloc( w*h*sizeof(uint8_t) ) + 3*w;+ }+ + /* One pas for Y, one pass for Cb, one pass for Cr */ + for( k = 0; k < 1; k++ )+ {+ int ref_stride = pv->ref_stride[k];+ int width = pv->width[k];+ int height = pv->height[k];++ for( y = 2; y < (height-2); y++ )+ {+ /* These are just to make the buffer locations easier to read. */+ int back_2 = y - 2;+ int back_1 = y - 1;+ int forward_1 = y + 1;+ int forward_2 = y + 2;+ + /* We need to examine a column of 5 pixels+ in the prev, cur, and next frames. */+ uint8_t frame_a[5];+ uint8_t frame_b[5];+ uint8_t frame_c[5];+ + for( x = 0; x < width; x++ )+ {+ /* Fill up the frame arrays with the current pixel values.*/+ frame_a[0] = pv->ref[0][k][back_2*ref_stride + x];+ frame_a[1] = pv->ref[0][k][back_1*ref_stride + x];+ frame_a[2] = pv->ref[0][k][y*ref_stride + x];+ frame_a[3] = pv->ref[0][k][forward_1*ref_stride + x];+ frame_a[4] = pv->ref[0][k][forward_2*ref_stride + x];+ frame_b[0] = pv->ref[1][k][back_2*ref_stride + x];+ frame_b[1] = pv->ref[1][k][back_1*ref_stride + x];+ frame_b[2] = pv->ref[1][k][y*ref_stride + x];+ frame_b[3] = pv->ref[1][k][forward_1*ref_stride + x];+ frame_b[4] = pv->ref[1][k][forward_2*ref_stride + x];+ frame_c[0] = pv->ref[2][k][back_2*ref_stride + x];+ frame_c[1] = pv->ref[2][k][back_1*ref_stride + x];+ frame_c[2] = pv->ref[2][k][y*ref_stride + x];+ frame_c[3] = pv->ref[2][k][forward_1*ref_stride + x];+ frame_c[4] = pv->ref[2][k][forward_2*ref_stride + x];+ + /* Make sure there's sufficient motion between frame t-1 to frame t+1. */+ int motion = 0;+ if( abs(frame_a[2] - frame_b[2] ) > mthresh && abs(frame_b[1] - frame_c[1] ) > mthresh && abs(frame_b[3] - frame_c[3] ) > mthresh )+ motion++;+ if( abs(frame_c[2] - frame_b[2] ) > mthresh && abs(frame_a[1] - frame_b[1] ) > mthresh && abs(frame_a[3] - frame_b[3] ) > mthresh )+ motion++;++#if 0+ /* Visualizes the pixel values being examined. */+ hb_log("\n PLANE: %i X: %i Y: %i \n %i %i %i \n %i %i %i \n %i %i %i \n %i %i %i \n %i %i %i", k, x, y,+ frame_a[0], frame_b[0], frame_c[0],+ frame_a[1], frame_b[1], frame_c[1],+ frame_a[2], frame_b[2], frame_c[2],+ frame_a[3], frame_b[3], frame_c[3],+ frame_a[4], frame_b[4], frame_c[4] );+#endif+ if( motion )+ {+ /* There is movement in this pixel location. */+ if( ( frame_b[1] - frame_b[2] ) * ( frame_b[3] - frame_b[2] ) > 0 )+ {+ /* The pixel above and below are different,+ and are so in the same "direction" too.+ That means it's time for the spatial check. */+ + /* Simple 32detect style comb detection */+ if( ( abs( frame_b[2] - frame_b[4] ) < color_equal ) &&+ ( abs( frame_b[2] - frame_b[3] ) > color_diff ) )+ {+ mask[k][y*ref_stride + x] = 255;+ }+ else+ {+ mask[k][y*ref_stride + x] = 0;+ }+ +#if 0+ /* The combing check is done on a bob+blur convolution. */+ int combing = abs( frame_b[0] + (4 * frame_b[2] ) + frame_b[4] - (3 * ( frame_b[1] + frame_b[3] ) ) );++ /* If the frame is sufficiently combed,+ then mark it down on the mask as 255. */+ if( combing > 6*athresh )+ mask[k][y*ref_stride + x] = 255; + else+ mask[k][y*ref_stride + x] = 0;+#endif++#if 0+ /* This, for comparison, is what IsCombed uses.+ It's simpler, but more noise senstive. */+ int combing = (frame_b[1] - frame_b[2]) * (frame_b[3] - frame_b[2]);+ if( combing > 20 )+ mask[k][y*ref_stride + x] = 255; + else+ mask[k][y*ref_stride + x] = 0;+#endif+ }+ else+ {+ mask[k][y*ref_stride + x] = 0;+ }+ }+ else+ {+ mask[k][y*ref_stride + x] = 0;+ }+ }+ }+ }+ + /* Go through the mask in 4x8 blocks. If any of these windows+ have threshold or more combed pixels, consider the whole+ frame to be combed and send it on to be deinterlaced. */+ int block_score = 0;+ for(k = 0; k < 1; k++ )+ {+ int ref_stride = pv->ref_stride[k]; + for( y = 0; y < ( pv->height[k] - 8 ); y = y + 8 )+ {+ for( x = 0; x < ( pv->width[k] - 4 ); x = x + 4 )+ {+ int block_x;+ int block_y;+ block_score = 0;+ for(block_y = 0; block_y < 8; block_y++ )+ {+ for(block_x = 0; block_x < 4; block_x++ )+ {+ int mask_y = y + block_y;+ int mask_x = x + block_x;+ + if( mask[k][mask_y*ref_stride+mask_x] == 255 )+ {+ block_score++;+ }+ }+ }+ + if( block_score >= threshold )+ {+ /* Consider this frame to be combed.+ Clear the mask buffer and return 1. */+ for( i = 0; i<3*3; i++ )+ {+ uint8_t **p = &mask[i/3];+ if (*p)+ {+ free( *p - 3*pv->ref_stride[i/3] );+ *p = NULL;+ }+ }+ return 1;+ }+ }+ } + }+ + /* Consider this frame to be uncombed.+ Clear the mask buffer and return 0. */+ for( i = 0; i<3*3; i++ )+ {+ uint8_t **p = &mask[i/3];+ if (*p)+ {+ free( *p - 3*pv->ref_stride[i/3] );+ *p = NULL;+ }+ }+ return 0;+}+ static void yadif_filter_line( uint8_t *dst, uint8_t *prev, uint8_t *cur,@@ -376,7 +575,17 @@ int tff, hb_filter_private_t * pv ) {-+ + int is_combed = tritical_detect_comb( pv );+ + if(is_combed)+ {+ pv->deinterlaced_frames++;+ }+ else+ {+ pv->passed_frames++;+ } #if 0 /* Buggy, experimental code for macroblock-by-macroblock decombing.*/ if( pv->mode == 7 )@@ -499,7 +708,7 @@ blend_filter_line( dst2, cur, i, y, pv ); }- else if( (y ^ parity) & 1 )+ else if( (y ^ parity) & 1 && is_combed ) { uint8_t *prev = &pv->ref[0][i][y*ref_stride]; uint8_t *cur = &pv->ref[1][i][y*ref_stride];@@ -850,14 +1059,14 @@ pix_fmt, width, height ); /* Check for combing on the input frame */- int interlaced = hb_detect_comb(buf_in, width, height, pv->color_equal, pv->color_diff, pv->threshold, pv->prog_equal, pv->prog_diff, pv->prog_threshold);+ int interlaced = 1; // hb_detect_comb(buf_in, width, height, pv->color_equal, pv->color_diff, pv->threshold, pv->prog_equal, pv->prog_diff, pv->prog_threshold); if(interlaced) { avpicture_deinterlace( &pv->pic_out, &pv->pic_in, pix_fmt, width, height ); - pv->deinterlaced_frames++;+// pv->deinterlaced_frames++; //hb_log("Frame %i is combed (Progressive: %s )", pv->deinterlaced_frames + pv->passed_frames, (buf_in->flags & 16) ? "Y" : "N"); hb_buffer_copy_settings( pv->buf_out[0], buf_in );@@ -867,7 +1076,7 @@ { /* No combing detected, pass input frame through unmolested.*/ - pv->passed_frames++;+ // pv->passed_frames++; hb_buffer_copy_settings( pv->buf_out[0], buf_in ); *buf_out = buf_in;@@ -894,7 +1103,7 @@ if( pv->mode < 7 ) { /* Note down if the input frame is combed */- pv->comb = (pv->comb << 1) | hb_detect_comb(buf_in, width, height, pv->color_equal, pv->color_diff, pv->threshold, pv->prog_equal, pv->prog_diff, pv->prog_threshold);+ pv->comb = (pv->comb << 1) | 1; //hb_detect_comb(buf_in, width, height, pv->color_equal, pv->color_diff, pv->threshold, pv->prog_equal, pv->prog_diff, pv->prog_threshold); } /* If yadif is not ready, store another ref and return FILTER_DELAY */@@ -918,7 +1127,7 @@ { /* Perform yadif filtering */ - pv->deinterlaced_frames++;+// pv->deinterlaced_frames++; int frame; for( frame = 0; frame <= ( ( pv->mode == 2 || pv->mode == 5 )? 1 : 0 ) ; frame++ ) {@@ -955,7 +1164,7 @@ { /* Perform yadif filtering */ - pv->deinterlaced_frames++;+// pv->deinterlaced_frames++; int frame; for( frame = 0; frame <= ( ( pv->mode == 2 || pv->mode == 5 )? 1 : 0 ) ; frame++ ) {