3 #include "mpeg2dec/mpeg2.h"
11 #define PULLUP_FMT_Y 1
12 #define PULLUP_HAVE_BREAKS 1
13 #define PULLUP_HAVE_AFFINITY 2
14 #define PULLUP_BREAK_LEFT 1
15 #define PULLUP_BREAK_RIGHT 2
17 #define PULLUP_ABS( a ) (((a)^((a)>>31))-((a)>>31))
19 #ifndef PIC_FLAG_REPEAT_FIRST_FIELD
20 #define PIC_FLAG_REPEAT_FIRST_FIELD 256
26 unsigned char **planes;
32 struct pullup_buffer *buffer;
39 struct pullup_field *prev, *next;
47 struct pullup_buffer **ifields, *ofields[2];
48 struct pullup_buffer *buffer;
53 /* Public interface */
56 int *bpp, *w, *h, *stride, *background;
58 int junk_left, junk_right, junk_top, junk_bottom;
65 struct pullup_field *first, *last, *head;
66 struct pullup_buffer *buffers;
68 int (*diff)(unsigned char *, unsigned char *, int);
69 int (*comb)(unsigned char *, unsigned char *, int);
70 int (*var)(unsigned char *, unsigned char *, int);
71 int metric_w, metric_h, metric_len, metric_offset;
72 struct pullup_frame *frame;
77 * DETELECINE FILTER DEFINITIONS
81 struct hb_filter_private_s
87 struct pullup_context * pullup_ctx;
93 hb_buffer_t * buf_out;
96 hb_filter_private_t * hb_detelecine_init( int pix_fmt,
101 int hb_detelecine_work( const hb_buffer_t * buf_in,
102 hb_buffer_t ** buf_out,
106 hb_filter_private_t * pv );
108 void hb_detelecine_close( hb_filter_private_t * pv );
110 hb_filter_object_t hb_filter_detelecine =
113 "Detelecine (pullup)",
122 * PULLUP STATIC FUNCTIONS
126 static int pullup_diff_y( unsigned char *a, unsigned char * b, int s )
131 for( j = 0; j < 8; j++ )
133 diff += PULLUP_ABS( a[j]-b[j] );
140 static int pullup_licomb_y( unsigned char * a, unsigned char * b, int s )
145 for( j = 0; j < 8; j++ )
147 diff += PULLUP_ABS( (a[j]<<1) - b[j-s] - b[j] )
148 + PULLUP_ABS( (b[j]<<1) - a[j] - a[j+s] );
155 static int pullup_var_y( unsigned char * a, unsigned char * b, int s )
160 for( j = 0; j < 8; j++ )
162 var += PULLUP_ABS( a[j]-a[j+s] );
169 static void pullup_alloc_metrics( struct pullup_context * c,
170 struct pullup_field * f )
172 f->diffs = calloc( c->metric_len, sizeof(int) );
173 f->comb = calloc( c->metric_len, sizeof(int) );
174 f->var = calloc( c->metric_len, sizeof(int) );
177 static void pullup_compute_metric( struct pullup_context * c,
178 struct pullup_field * fa, int pa,
179 struct pullup_field * fb, int pb,
180 int (* func)( unsigned char *,
181 unsigned char *, int),
184 unsigned char *a, *b;
186 int mp = c->metric_plane;
187 int xstep = c->bpp[mp];
188 int ystep = c->stride[mp]<<3;
189 int s = c->stride[mp]<<1; /* field stride */
190 int w = c->metric_w*xstep;
192 if( !fa->buffer || !fb->buffer ) return;
194 /* Shortcut for duplicate fields (e.g. from RFF flag) */
195 if( fa->buffer == fb->buffer && pa == pb )
197 memset( dest, 0, c->metric_len * sizeof(int) );
201 a = fa->buffer->planes[mp] + pa * c->stride[mp] + c->metric_offset;
202 b = fb->buffer->planes[mp] + pb * c->stride[mp] + c->metric_offset;
204 for( y = c->metric_h; y; y-- )
206 for( x = 0; x < w; x += xstep )
208 *dest++ = func( a + x, b + x, s );
210 a += ystep; b += ystep;
214 static struct pullup_field * pullup_make_field_queue( struct pullup_context * c,
217 struct pullup_field * head, * f;
218 f = head = calloc( 1, sizeof(struct pullup_field) );
219 pullup_alloc_metrics( c, f );
220 for ( ; len > 0; len-- )
222 f->next = calloc( 1, sizeof(struct pullup_field) );
225 pullup_alloc_metrics( c, f );
232 static void pullup_check_field_queue( struct pullup_context * c )
234 if( c->head->next == c->first )
236 struct pullup_field *f = calloc( 1, sizeof(struct pullup_field) );
237 pullup_alloc_metrics( c, f );
245 static void pullup_copy_field( struct pullup_context * c,
246 struct pullup_buffer * dest,
247 struct pullup_buffer * src,
251 unsigned char *d, *s;
252 for( i = 0; i < c->nplanes; i++ )
254 s = src->planes[i] + parity*c->stride[i];
255 d = dest->planes[i] + parity*c->stride[i];
256 for( j = c->h[i]>>1; j; j-- )
258 memcpy( d, s, c->stride[i] );
259 s += c->stride[i]<<1;
260 d += c->stride[i]<<1;
266 static int pullup_queue_length( struct pullup_field * begin,
267 struct pullup_field * end )
270 struct pullup_field * f;
272 if( !begin || !end ) return 0;
273 for( f = begin; f != end; f = f->next ) count++;
277 static int pullup_find_first_break( struct pullup_field * f, int max )
280 for( i = 0; i < max; i++ )
282 if( f->breaks & PULLUP_BREAK_RIGHT ||
283 f->next->breaks & PULLUP_BREAK_LEFT )
292 static void pullup_compute_breaks( struct pullup_context * c,
293 struct pullup_field * f0 )
296 struct pullup_field *f1 = f0->next;
297 struct pullup_field *f2 = f1->next;
298 struct pullup_field *f3 = f2->next;
299 int l, max_l=0, max_r=0;
301 if( f0->flags & PULLUP_HAVE_BREAKS ) return;
302 f0->flags |= PULLUP_HAVE_BREAKS;
304 /* Special case when fields are 100% identical */
305 if( f0->buffer == f2->buffer && f1->buffer != f3->buffer )
307 f2->breaks |= PULLUP_BREAK_RIGHT;
310 if( f0->buffer != f2->buffer && f1->buffer == f3->buffer )
312 f1->breaks |= PULLUP_BREAK_LEFT;
316 for( i = 0; i < c->metric_len; i++ )
318 l = f2->diffs[i] - f3->diffs[i];
319 if( l > max_l) max_l = l;
320 if( -l > max_r) max_r = -l;
323 /* Don't get tripped up when differences are mostly quant error */
324 if( max_l + max_r < 128 ) return;
325 if( max_l > 4*max_r ) f1->breaks |= PULLUP_BREAK_LEFT;
326 if( max_r > 4*max_l ) f2->breaks |= PULLUP_BREAK_RIGHT;
329 static void pullup_compute_affinity( struct pullup_context * c,
330 struct pullup_field * f )
333 int max_l = 0, max_r = 0, l;
335 if( f->flags & PULLUP_HAVE_AFFINITY )
339 f->flags |= PULLUP_HAVE_AFFINITY;
341 if( f->buffer == f->next->next->buffer )
344 f->next->affinity = 0;
345 f->next->next->affinity = -1;
347 f->next->flags |= PULLUP_HAVE_AFFINITY;
348 f->next->next->flags |= PULLUP_HAVE_AFFINITY;
353 for( i = 0; i < c->metric_len; i++ )
355 int lv = f->prev->var[i];
356 int rv = f->next->var[i];
358 int lc = f->comb[i] - (v+lv) + PULLUP_ABS( v-lv );
359 int rc = f->next->comb[i] - (v+rv) + PULLUP_ABS( v-rv );
361 lc = (lc > 0) ? lc : 0;
362 rc = (rc > 0) ? rc : 0;
364 if( l > max_l ) max_l = l;
365 if( -l > max_r ) max_r = -l;
368 if( max_l + max_r < 64 )
373 if( max_r > 6*max_l )
377 else if( max_l > 6*max_r )
383 static void pullup_foo( struct pullup_context * c )
385 struct pullup_field * f = c->first;
386 int i, n = pullup_queue_length (f, c->last );
387 for( i = 0; i < n-1; i++ )
389 if( i < n-3 ) pullup_compute_breaks( c, f );
390 pullup_compute_affinity( c, f );
395 static int pullup_decide_frame_length( struct pullup_context * c )
397 struct pullup_field *f0 = c->first;
398 struct pullup_field *f1 = f0->next;
399 struct pullup_field *f2 = f1->next;
402 if( pullup_queue_length( c->first, c->last ) < 4 )
408 if( f0->affinity == -1 ) return 1;
410 l = pullup_find_first_break( f0, 3 );
411 if( l == 1 && c->strict_breaks < 0 ) l = 0;
416 if ( c->strict_breaks < 1 &&
428 /* FIXME: strictly speaking, f0->prev is no longer valid... :) */
429 if( c->strict_pairs &&
430 (f0->prev->breaks & PULLUP_BREAK_RIGHT) &&
431 (f2->breaks & PULLUP_BREAK_LEFT) &&
432 (f0->affinity != 1 || f1->affinity != -1) )
436 if( f1->affinity == 1 )
446 if( f2->affinity == 1 )
456 /* 9 possibilities covered before switch */
457 if( f1->affinity == 1 )
459 return 1; /* covers 6 */
461 else if( f1->affinity == -1 )
463 return 2; /* covers 6 */
465 else if( f2->affinity == -1 )
468 if( f0->affinity == 1 )
479 return 2; /* the remaining 6 */
484 static void pullup_print_aff_and_breaks(struct pullup_context * c,
485 struct pullup_field * f )
488 struct pullup_field * f0 = f;
489 const char aff_l[] = "+..", aff_r[] = "..+";
490 printf( "\naffinity: " );
491 for( i = 0; i < 4; i++ )
494 aff_l[1+f->affinity],
496 aff_r[1+f->affinity] );
501 printf("\nbreaks: ");
502 for( i = 0; i < 4; i++ )
505 f->breaks & PULLUP_BREAK_LEFT ? '|' : '.',
507 f->breaks & PULLUP_BREAK_RIGHT ? '|' : '.' );
516 * PULLUP CONTEXT FUNCTIONS
520 struct pullup_context * pullup_alloc_context( void )
522 struct pullup_context * c;
524 c = calloc( 1, sizeof(struct pullup_context)) ;
529 void pullup_preinit_context( struct pullup_context * c )
531 c->bpp = calloc( c->nplanes, sizeof(int) );
532 c->w = calloc( c->nplanes, sizeof(int) );
533 c->h = calloc( c->nplanes, sizeof(int) );
534 c->stride = calloc( c->nplanes, sizeof(int) );
535 c->background = calloc( c->nplanes, sizeof(int) );
538 void pullup_init_context( struct pullup_context * c )
540 int mp = c->metric_plane;
541 if ( c->nbuffers < 10 )
545 c->buffers = calloc( c->nbuffers, sizeof (struct pullup_buffer) );
547 c->metric_w = (c->w[mp] - ((c->junk_left + c->junk_right) << 3)) >> 3;
548 c->metric_h = (c->h[mp] - ((c->junk_top + c->junk_bottom) << 1)) >> 3;
549 c->metric_offset = c->junk_left*c->bpp[mp] + (c->junk_top<<1)*c->stride[mp];
550 c->metric_len = c->metric_w * c->metric_h;
552 c->head = pullup_make_field_queue( c, 8 );
554 c->frame = calloc( 1, sizeof (struct pullup_frame) );
555 c->frame->ifields = calloc( 3, sizeof (struct pullup_buffer *) );
557 if( c->format == PULLUP_FMT_Y )
559 c->diff = pullup_diff_y;
560 c->comb = pullup_licomb_y;
561 c->var = pullup_var_y;
565 void pullup_free_context( struct pullup_context * c )
567 struct pullup_field * f;
572 while( f != c->head )
589 * PULLUP BUFFER FUNCTIONS
593 static void pullup_alloc_buffer( struct pullup_context * c,
594 struct pullup_buffer * b )
597 if( b->planes ) return;
598 b->planes = calloc( c->nplanes, sizeof(unsigned char *) );
599 for ( i = 0; i < c->nplanes; i++ )
601 b->planes[i] = malloc(c->h[i]*c->stride[i]);
602 /* Deal with idiotic 128=0 for chroma: */
603 memset( b->planes[i], c->background[i], c->h[i]*c->stride[i] );
607 struct pullup_buffer * pullup_lock_buffer( struct pullup_buffer * b,
611 if( (parity+1) & 1 ) b->lock[0]++;
612 if( (parity+1) & 2 ) b->lock[1]++;
617 void pullup_release_buffer( struct pullup_buffer * b,
621 if( (parity+1) & 1 ) b->lock[0]--;
622 if( (parity+1) & 2 ) b->lock[1]--;
625 struct pullup_buffer * pullup_get_buffer( struct pullup_context * c,
630 /* Try first to get the sister buffer for the previous field */
633 parity != c->last->parity &&
634 !c->last->buffer->lock[parity])
636 pullup_alloc_buffer( c, c->last->buffer );
637 return pullup_lock_buffer( c->last->buffer, parity );
640 /* Prefer a buffer with both fields open */
641 for( i = 0; i < c->nbuffers; i++ )
643 if( c->buffers[i].lock[0] ) continue;
644 if( c->buffers[i].lock[1] ) continue;
645 pullup_alloc_buffer( c, &c->buffers[i] );
646 return pullup_lock_buffer( &c->buffers[i], parity );
649 if( parity == 2 ) return 0;
651 /* Search for any half-free buffer */
652 for( i = 0; i < c->nbuffers; i++ )
654 if( ((parity+1) & 1) && c->buffers[i].lock[0] ) continue;
655 if( ((parity+1) & 2) && c->buffers[i].lock[1] ) continue;
656 pullup_alloc_buffer( c, &c->buffers[i] );
657 return pullup_lock_buffer( &c->buffers[i], parity );
665 * PULLUP FRAME FUNCTIONS
669 struct pullup_frame * pullup_get_frame( struct pullup_context * c )
672 struct pullup_frame * fr = c->frame;
673 int n = pullup_decide_frame_length( c );
674 int aff = c->first->next->affinity;
677 if ( fr->lock ) return 0;
681 pullup_print_aff_and_breaks(c, c->first);
682 printf("duration: %d \n", n);
687 fr->parity = c->first->parity;
689 for( i = 0; i < n; i++ )
691 /* We cheat and steal the buffer without release+relock */
692 fr->ifields[i] = c->first->buffer;
693 c->first->buffer = 0;
694 c->first = c->first->next;
699 fr->ofields[fr->parity] = fr->ifields[0];
700 fr->ofields[fr->parity^1] = 0;
704 fr->ofields[fr->parity] = fr->ifields[0];
705 fr->ofields[fr->parity^1] = fr->ifields[1];
711 aff = (fr->ifields[0] == fr->ifields[1]) ? -1 : 1;
713 fr->ofields[fr->parity] = fr->ifields[1+aff];
714 fr->ofields[fr->parity^1] = fr->ifields[1];
716 pullup_lock_buffer( fr->ofields[0], 0 );
717 pullup_lock_buffer( fr->ofields[1], 1 );
719 if( fr->ofields[0] == fr->ofields[1] )
721 fr->buffer = fr->ofields[0];
722 pullup_lock_buffer(fr->buffer, 2);
728 void pullup_pack_frame( struct pullup_context * c, struct pullup_frame * fr)
731 if (fr->buffer) return;
732 if (fr->length < 2) return; /* FIXME: deal with this */
733 for( i = 0; i < 2; i++ )
735 if( fr->ofields[i]->lock[i^1] ) continue;
736 fr->buffer = fr->ofields[i];
737 pullup_lock_buffer(fr->buffer, 2);
738 pullup_copy_field( c, fr->buffer, fr->ofields[i^1], i^1 );
741 fr->buffer = pullup_get_buffer( c, 2 );
742 pullup_copy_field( c, fr->buffer, fr->ofields[0], 0 );
743 pullup_copy_field( c, fr->buffer, fr->ofields[1], 1 );
746 void pullup_release_frame( struct pullup_frame * fr )
749 for( i = 0; i < fr->length; i++ )
751 pullup_release_buffer( fr->ifields[i], fr->parity ^ (i&1) );
753 pullup_release_buffer( fr->ofields[0], 0 );
754 pullup_release_buffer( fr->ofields[1], 1 );
755 if (fr->buffer) pullup_release_buffer( fr->buffer, 2 );
761 * PULLUP FIELD FUNCTIONS
765 void pullup_submit_field( struct pullup_context * c,
766 struct pullup_buffer * b,
769 struct pullup_field * f;
771 /* Grow the circular list if needed */
772 pullup_check_field_queue( c );
774 /* Cannot have two fields of same parity in a row; drop the new one */
775 if( c->last && c->last->parity == parity ) return;
779 f->buffer = pullup_lock_buffer( b, parity );
784 pullup_compute_metric( c, f, parity, f->prev->prev,
785 parity, c->diff, f->diffs );
786 pullup_compute_metric( c, parity?f->prev:f, 0,
787 parity?f:f->prev, 1, c->comb, f->comb );
788 pullup_compute_metric( c, f, parity, f,
789 -1, c->var, f->var );
791 /* Advance the circular list */
792 if( !c->first ) c->first = c->head;
794 c->head = c->head->next;
797 void pullup_flush_fields( struct pullup_context * c )
799 struct pullup_field * f;
801 for( f = c->first; f && f != c->head; f = f->next )
803 pullup_release_buffer( f->buffer, f->parity );
806 c->first = c->last = 0;
811 * DETELECINE FILTER FUNCTIONS
815 hb_filter_private_t * hb_detelecine_init( int pix_fmt,
820 if( pix_fmt != PIX_FMT_YUV420P )
825 hb_filter_private_t * pv = malloc( sizeof(struct hb_filter_private_s) );
827 pv->pix_fmt = pix_fmt;
828 pv->width[0] = width;
829 pv->height[0] = height;
830 pv->width[1] = pv->width[2] = width >> 1;
831 pv->height[1] = pv->height[2] = height >> 1;
833 pv->buf_out = hb_video_buffer_init( width, height );
835 struct pullup_context * ctx;
836 pv->pullup_ctx = ctx = pullup_alloc_context();
838 ctx->junk_left = ctx->junk_right = 1;
839 ctx->junk_top = ctx->junk_bottom = 4;
840 ctx->strict_breaks = -1;
841 ctx->metric_plane = 0;
846 sscanf( settings, "%d:%d:%d:%d:%d:%d:%d",
856 ctx->format = PULLUP_FMT_Y;
859 pullup_preinit_context( ctx );
861 ctx->bpp[0] = ctx->bpp[1] = ctx->bpp[2] = 8;
862 ctx->background[1] = ctx->background[2] = 128;
864 ctx->w[0] = pv->width[0];
865 ctx->h[0] = pv->height[0];
866 ctx->stride[0] = pv->width[0];
868 ctx->w[1] = pv->width[1];
869 ctx->h[1] = pv->height[1];
870 ctx->stride[1] = pv->width[1];
872 ctx->w[2] = pv->width[2];
873 ctx->h[2] = pv->height[2];
874 ctx->stride[2] = pv->width[2];
876 ctx->w[3] = ((width+15)/16) * ((height+15)/16);
878 ctx->stride[3] = ctx->w[3];
884 pullup_init_context( ctx );
886 pv->pullup_fakecount = 1;
887 pv->pullup_skipflag = 0;
892 void hb_detelecine_close( hb_filter_private_t * pv )
901 hb_buffer_close( &pv->buf_out );
906 pullup_free_context( pv->pullup_ctx );
912 int hb_detelecine_work( const hb_buffer_t * buf_in,
913 hb_buffer_t ** buf_out,
917 hb_filter_private_t * pv )
920 pix_fmt != pv->pix_fmt ||
921 width != pv->width[0] ||
922 height != pv->height[0] )
924 return FILTER_FAILED;
927 struct pullup_context * ctx = pv->pullup_ctx;
928 struct pullup_buffer * buf;
929 struct pullup_frame * frame;
931 buf = pullup_get_buffer( ctx, 2 );
934 frame = pullup_get_frame( ctx );
935 pullup_release_frame( frame );
936 hb_log( "Could not get buffer from pullup!" );
937 return FILTER_FAILED;
940 /* Copy input buffer into pullup buffer */
941 avpicture_fill( &pv->pic_in, buf_in->data,
942 pix_fmt, width, height );
944 hb_buffer_copy_settings( pv->buf_out, buf_in );
946 memcpy( buf->planes[0], pv->pic_in.data[0],
947 pv->width[0] * pv->height[0] * sizeof(uint8_t) );
948 memcpy( buf->planes[1], pv->pic_in.data[1],
949 pv->width[1] * pv->height[1] * sizeof(uint8_t) );
950 memcpy( buf->planes[2], pv->pic_in.data[2],
951 pv->width[2] * pv->height[2] * sizeof(uint8_t) );
953 /* Submit buffer fields based on buffer flags.
954 Detelecine assumes BFF when the TFF flag isn't present. */
956 if( buf_in->flags & PIC_FLAG_TOP_FIELD_FIRST )
958 /* Source signals TFF */
961 else if( ctx->parity == 0 )
963 /* Many non-MPEG-2 sources lack parity flags even though
964 they are TFF, so this allow users to override. */
967 if( ctx->parity == 1 )
969 /* Override autodetected parity with BFF */
972 pullup_submit_field( ctx, buf, parity );
973 pullup_submit_field( ctx, buf, parity^1 );
974 if( buf_in->flags & PIC_FLAG_REPEAT_FIRST_FIELD )
976 pullup_submit_field( ctx, buf, parity );
978 pullup_release_buffer( buf, 2 );
980 /* Get frame and check if pullup is ready */
981 frame = pullup_get_frame( ctx );
984 if( pv->pullup_fakecount )
986 pv->pullup_fakecount--;
988 memcpy( pv->buf_out->data, buf_in->data, buf_in->size );
998 /* Check to see if frame should be dropped */
999 if( frame->length < 2 )
1001 pullup_release_frame( frame );
1002 frame = pullup_get_frame( ctx );
1008 if( frame->length < 2 )
1010 pullup_release_frame( frame );
1012 if( !(buf_in->flags & PIC_FLAG_REPEAT_FIRST_FIELD) )
1017 frame = pullup_get_frame( ctx );
1023 if( frame->length < 2 )
1025 pullup_release_frame( frame );
1031 /* Check to see if frame buffer is ready for export */
1032 if( !frame->buffer )
1034 pullup_pack_frame( ctx, frame );
1037 /* Copy pullup frame buffer into output buffer */
1038 avpicture_fill( &pv->pic_out, pv->buf_out->data,
1039 pix_fmt, width, height );
1041 memcpy( pv->pic_out.data[0], frame->buffer->planes[0],
1042 pv->width[0] * pv->height[0] * sizeof(uint8_t) );
1043 memcpy( pv->pic_out.data[1], frame->buffer->planes[1],
1044 pv->width[1] * pv->height[1] * sizeof(uint8_t) );
1045 memcpy( pv->pic_out.data[2], frame->buffer->planes[2],
1046 pv->width[2] * pv->height[2] * sizeof(uint8_t) );
1048 pullup_release_frame( frame );
1051 *buf_out = pv->buf_out;
1054 /* This and all discard_frame calls shown above are
1055 the result of me restoring the functionality in
1056 pullup that huevos_rancheros disabled because
1057 HB couldn't handle it. */
1059 *buf_out = pv->buf_out;