Add support using FFdecsa as decryption library.

Use "make ffdecsa" to build tsdecrypt with ffdecsa support
or "make dvbcsa" to build with libdvbcsa (this is still the default).

ChangeLog

 current : Version -next
+ * Add FFdecsa support. FFdecsa decrypts ~2 times faster than libdvcsa.
  * Add --const-cw (-Y) option. This option allows using of constant
    code word for decryption.
 

FFdecsa_init

+#!/bin/sh
+# Compile FFdecsa in different modes to find the fastest
+# This script is based on the conigure script from getstream_a84
+# Copyright (C) 2012 Unix Solutions Ltd.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License version 2
+# as published by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
+
+cd $(dirname $0)
+
+CROSS="$1"
+CC="${2:-cc}"
+FFDECSA_CFLAGS="-O3 -fexpensive-optimizations -funroll-loops"
+
+MAX_MODE="PARALLEL_32_INT"
+
+FFDECSA_MODES="PARALLEL_32_INT"
+FFDECSA_MODES="$FFDECSA_MODES PARALLEL_64_2INT"
+FFDECSA_MODES="$FFDECSA_MODES PARALLEL_64_LONG"
+FFDECSA_MODES="$FFDECSA_MODES PARALLEL_64_MMX"
+FFDECSA_MODES="$FFDECSA_MODES PARALLEL_128_2LONG"
+FFDECSA_MODES="$FFDECSA_MODES PARALLEL_128_2MMX"
+FFDECSA_MODES="$FFDECSA_MODES PARALLEL_128_SSE"
+FFDECSA_MODES="$FFDECSA_MODES PARALLEL_128_SSE2"
+
+# Internal variables
+OUTPUT_FILE="FFdecsa.opts"
+FFDECSA_DIR="FFdecsa"
+LPREFIX="[FFdecsa]"
+MAX_SPEED=0
+TMPDIR=`mktemp -d FFdecsa.build.XXXXXXXX` || exit 1
+
+trap "{ rm -rf $TMPDIR ; exit 1; }" INT TERM
+
+cp $FFDECSA_DIR/Makefile $FFDECSA_DIR/*.{c,h} $TMPDIR
+
+log()  { printf "%s %-26s : %s\n" "$LPREFIX" "$1" "$2"; }
+logn() { printf "%s %-26s : %s"   "$LPREFIX" "$1" "$2"; }
+
+log "Using compiler" "$CROSS$CC"
+log "FFdecsa modes" "$FFDECSA_MODES"
+
+cpu_have() {
+	# Check whether option is supported by the host CPU
+	grep "^flags.* $1 " /proc/cpuinfo >/dev/null 2>&1
+	eval test $? -eq 0
+}
+
+cc_check() {
+	# Check whether option is supported by the target CC
+	$CROSS$CC $1 -xc -o /dev/null - 2>/dev/null << EOF
+int main(void) { return 0; }
+EOF
+	eval test $? -eq 0
+}
+
+test_ffdecsa_mode() {
+	MODE="$1"
+	logn "Testing $MODE"
+
+	ERRLOG="FFdecsa_build_$MODE.log"
+	MAKECMD="make -C $TMPDIR FFdecsa_test PARALLEL_MODE=$MODE FLAGS=\"$FFDECSA_CFLAGS\" COMPILER=\"$CROSS$CC\""
+	eval $MAKECMD >/dev/null 2>$TMPDIR/$ERRLOG
+
+	if [ $? -ne 0 ]
+	then
+		echo "ERROR: build failed, check $ERRLOG"
+		(echo "$MAKECMD" ; echo ; cat $TMPDIR/$ERRLOG) > $ERRLOG
+		return
+	fi
+
+	if [ "$CROSS" != "" ]
+	then
+		cp $TMPDIR/FFdecsa_test FFdecsa_test_$MODE
+		echo "CROSS COMPILE OK: You can run FFdecsa_test_$MODE on the target machine"
+		return
+	fi
+
+	RESULTS_FILE="$TMPDIR/test_results.txt"
+	$TMPDIR/FFdecsa_test >/dev/null 2>$RESULTS_FILE
+	if [ $? -ne 0 ]
+	then
+		echo "ERROR: test run failed"
+		return
+	fi
+
+	grep FAILED $RESULTS_FILE >/dev/null 2>&1
+	if test $? -ne 1; then
+		echo "ERROR: test failed"
+		return
+	fi
+
+	SPEED=`grep "speed=.*Mbit" $RESULTS_FILE | sed -e 's/^.*=\([0-9]*\)\.[0-9]* Mbit.*$/\1/'`
+	echo "OK $SPEED Mbit/s"
+	if [ $SPEED -gt $MAX_SPEED ]
+	then
+		MAX_SPEED=$SPEED
+		MAX_MODE=$MODE
+	fi
+}
+
+# Check CPU and compiler flags
+if cc_check -march=native
+then
+	FFDECSA_CFLAGS="$FFDECSA_CFLAGS -march=native"
+elif cc_check -march=pentium; then
+	FFDECSA_CFLAGS="$FFDECSA_CFLAGS -march=pentium"
+fi
+
+OPTS=""
+FLAGS=""
+for flag in mmx sse sse2
+do
+	if cpu_have $flag
+	then
+		OPTS="$OPTS $flag"
+		if cc_check -m$flag
+		then
+			FFDECSA_CFLAGS="$FFDECSA_CFLAGS -m$flag"
+		fi
+	fi
+done
+
+log "Host CPU" "$(uname -m) $OPTS"
+log "FFdecsa CFLAGS" "$FFDECSA_CFLAGS"
+
+for MODE in $FFDECSA_MODES
+do
+	test_ffdecsa_mode $MODE
+	make -C $TMPDIR clean >/dev/null 2>&1
+done
+
+log "Choosing PARALLEL_MODE" "$MAX_MODE ($MAX_SPEED Mbps)"
+
+echo "# This file is included from Makefile
+DECRYPT_LIB = ffdecsa
+FFDECSA_OBJ = FFdecsa/FFdecsa.o" > $OUTPUT_FILE
+echo "FFDECSA_MODE = $MAX_MODE" >> $OUTPUT_FILE
+echo "FFDECSA_FLAGS = \"$FFDECSA_CFLAGS\"" >> $OUTPUT_FILE
+
+rm -rf $TMPDIR

Makefile

 CC = $(CROSS)$(TARGET)cc
 STRIP = $(CROSS)$(TARGET)strip
 MKDEP = $(CC) -M -o $*.d $<
-RM = /bin/rm -f
+RM = rm -f
+MV = mv -f
 
 BUILD_ID = $(shell date +%F_%R)
 VERSION = $(shell cat RELEASE)
 
 DEFS = -DBUILD_ID=\"$(BUILD_ID)\" \
  -DVERSION=\"$(VERSION)\" -DGIT_VER=\"$(GIT_VER)\"
-DEFS += -DUSE_LIBDVBCSA=1
 
 PREFIX ?= /usr/local
 
  tables.c \
  notify.c \
  tsdecrypt.c
-tsdecrypt_LIBS = -lcrypto -ldvbcsa -lpthread
-tsdecrypt_OBJS = $(FUNCS_LIB) $(TS_LIB) $(tsdecrypt_SRC:.c=.o)
+tsdecrypt_LIBS = -lcrypto -lpthread
+
+# If the file do not exist, libdvbcsa will be used
+-include FFdecsa.opts
+
+tsdecrypt_OBJS = $(FFDECSA_OBJ) $(FUNCS_LIB) $(TS_LIB) $(tsdecrypt_SRC:.c=.o)
 
 ifeq "$(shell uname -s)" "Linux"
 tsdecrypt_LIBS += -lcrypt -lrt
 endif
 
-CLEAN_OBJS = tsdecrypt $(tsdecrypt_SRC:.c=.{o,d})
+ifeq "$(DECRYPT_LIB)" "ffdecsa"
+DEFS += -DDLIB=\"FFdecsa_$(FFDECSA_MODE)\"
+DEFS += -DUSE_FFDECSA=1
+else
+DEFS += -DDLIB=\"libdvbcsa\"
+DEFS += -DUSE_LIBDVBCSA=1
+tsdecrypt_LIBS += -ldvbcsa
+endif
+
+CLEAN_OBJS = $(FFDECSA_OBJ) tsdecrypt $(tsdecrypt_SRC:.c=.{o,d})
 
 PROGS = tsdecrypt
 
-.PHONY: distclean clean install uninstall
+.PHONY: ffdecsa dvbcsa help distclean clean install uninstall
 
 all: $(PROGS)
 
+ffdecsa: clean
+	$(Q)echo "Switching build to FFdecsa."
+	@-if test -e FFdecsa.opts.saved; then $(MV) FFdecsa.opts.saved FFdecsa.opts; fi
+	@-if ! test -e FFdecsa.opts; then ./FFdecsa_init "$(CROSS)$(TARGET)" "$(CC)"; fi
+	$(Q)$(MAKE) -s tsdecrypt
+
+ffdecsa_force:
+	$(Q)$(RM) FFdecsa.opts
+	$(Q)$(MAKE) -s ffdecsa
+
+dvbcsa: clean
+	$(Q)echo "Switching build to libdvbcsa."
+	@-if test -f FFdecsa.opts; then $(MV) FFdecsa.opts FFdecsa.opts.saved; fi
+	$(Q)$(MAKE) -s tsdecrypt
+
 $(FUNCS_LIB): $(FUNCS_DIR)/libfuncs.h
 	$(Q)echo "  MAKE	$(FUNCS_LIB)"
 	$(Q)$(MAKE) -s -C $(FUNCS_DIR)
 	$(Q)echo "  CC	tsdecrypt	$<"
 	$(Q)$(CC) $(CFLAGS) $(DEFS) -c $<
 
+FFdecsa/FFdecsa.o:
+	$(Q)echo "  MAKE	FFdecsa"
+	$(Q)$(MAKE) -s -C FFdecsa FLAGS=$(FFDECSA_FLAGS) PARALLEL_MODE=$(FFDECSA_MODE) COMPILER=$(CROSS)$(CC) FFdecsa.o
+
 -include $(tsdecrypt_SRC:.c=.d)
 
 strip:
 distclean: clean
 	$(Q)$(MAKE) -s -C $(TS_DIR) clean
 	$(Q)$(MAKE) -s -C $(FUNCS_DIR) clean
+	$(Q)$(RM) FFdecsa.opts
 
 install: all strip
 	@install -d "$(INSTALL_PRG_DIR)"

csa.c

 	key->s_csakey[1] = dvbcsa_key_alloc();
 	key->bs_csakey[0] = dvbcsa_bs_key_alloc();
 	key->bs_csakey[1] = dvbcsa_bs_key_alloc();
+	key->ff_csakey = ffdecsa_key_alloc();
 	return (csakey_t *)key;
 }
 
 		dvbcsa_key_free(key->s_csakey[1]);
 		dvbcsa_bs_key_free(key->bs_csakey[0]);
 		dvbcsa_bs_key_free(key->bs_csakey[1]);
+		ffdecsa_key_free(key->ff_csakey);
 		FREE(*pcsakey);
 	}
 }
 	if (use_dvbcsa) {
 		return dvbcsa_bs_batch_size(); // 32?
 	}
+	if (use_ffdecsa) {
+		return ffdecsa_get_suggested_cluster_size() / 2;
+	}
 	return 0;
 }
 
 	struct csakey *key = (struct csakey *)csakey;
 	dvbcsa_key_set(even_cw, key->s_csakey[0]);
 	dvbcsa_bs_key_set(even_cw, key->bs_csakey[0]);
+	ffdecsa_set_even_cw(key->ff_csakey, even_cw);
 }
 
 inline void csa_set_odd_cw(csakey_t *csakey, uint8_t *odd_cw) {
 	struct csakey *key = (struct csakey *)csakey;
 	dvbcsa_key_set(odd_cw, key->s_csakey[1]);
 	dvbcsa_bs_key_set(odd_cw, key->bs_csakey[1]);
+	ffdecsa_set_odd_cw(key->ff_csakey, odd_cw);
 }
 
 inline void csa_decrypt_single_packet(csakey_t *csakey, uint8_t *ts_packet) {
 		ts_packet_set_not_scrambled(ts_packet);
 		dvbcsa_decrypt(key->s_csakey[key_idx], ts_packet + payload_offset, 188 - payload_offset);
 	}
+	if (use_ffdecsa) {
+		uint8_t *cluster[3] = { ts_packet, ts_packet + 188, NULL };
+		ffdecsa_decrypt_packets(key->ff_csakey, cluster);
+	}
 }
 
 inline void csa_decrypt_multiple_even(csakey_t *csakey, struct csa_batch *batch) {
 	dvbcsa_bs_decrypt(key->bs_csakey[1], (struct dvbcsa_bs_batch_s *)batch, 184);
 }
 
+inline void csa_decrypt_multiple_ff(csakey_t *csakey, uint8_t **cluster) {
+	struct csakey *key = (struct csakey *)csakey;
+	ffdecsa_decrypt_packets(key->ff_csakey, cluster);
+}
+
 /* The following routine is taken from benchbitslice in libdvbcsa */
-void csa_benchmark(void) {
+void dvbcsa_benchmark(void) {
 	struct timeval t0, t1;
 	struct dvbcsa_bs_key_s *key = dvbcsa_bs_key_alloc();
 	unsigned int n, i, npackets = 0;
 	struct dvbcsa_bs_batch_s pcks[batch_size + 1];
 	uint8_t cw[8] = { 0x12, 0x34, 0x56, 0x78, 0x89, 0xab, 0xcd, 0xef, };
 
-	srand(time(0));
-	puts("Single threaded CSA decoding benchmark");
-
 	dvbcsa_bs_key_set (cw, key);
 
 	printf("Batch size %d packets.\n\n", batch_size);
 
 	dvbcsa_bs_key_free(key);
 }
+
+void ffdecsa_benchmark(void) {
+	struct timeval t0, t1;
+	ffdecsa_key_t *key = ffdecsa_key_alloc();
+	unsigned int n, i, d, npackets = 0;
+	unsigned int batch_size = ffdecsa_get_suggested_cluster_size() / 2;
+	uint8_t data[batch_size + 1][188];
+	uint8_t *pcks[batch_size * 2 + 1];
+	uint8_t ecw[8] = { 0x12, 0x34, 0x56, 0x78, 0x89, 0xab, 0xcd, 0xef, };
+	uint8_t ocw[8] = { 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10, };
+
+	ffdecsa_set_even_cw(key, ecw);
+	ffdecsa_set_odd_cw (key, ocw);
+
+	printf("Batch size %d packets.\n\n", batch_size);
+	for (i = 0; i < batch_size; i++) {
+		memset(data[i], rand(), 188);
+		data[i][0] = 0x47;
+		data[i][1] = 0x01;
+		data[i][2] = 0x02;
+		data[i][3] = i & 0x0f;
+	}
+
+	gettimeofday(&t0, NULL);
+	for (n = (1 << 12) / batch_size; n < (1 << 18) / batch_size; n *= 2) {
+		static unsigned int key_idx = 0;
+		printf(" Decrypting %6u mpegts packets\r", n * batch_size);
+		fflush(stdout);
+		for (i = 0; i < n; i++) {
+			// ffdecsa_decrypt function modifies data and pcks
+			for (d = 0; d < batch_size; d++) {
+				pcks[d * 2]     = data[d];
+				pcks[d * 2 + 1] = data[d] + 188;
+				data[d][3] |= (key_idx == 0) ? (2 << 6) : (3 << 6);
+			}
+			pcks[d * 2] = NULL;
+			key_idx = !!key_idx;
+			ffdecsa_decrypt_packets(key, pcks);
+		}
+		npackets += n * batch_size;
+	}
+	gettimeofday(&t1, NULL);
+
+	unsigned long long usec = timeval_diff_usec(&t0, &t1);
+	printf("DONE: %u packets (%u bytes) decrypted in %llu ms = %.1f Mbits/s\n\n",
+		npackets,
+		npackets * 188,
+		usec / 1000,
+		(double)(npackets * 188 * 8) / (double)usec
+	);
+
+	dvbcsa_bs_key_free(key);
+}
+
+void csa_benchmark(void) {
+	srand(time(0));
+	printf("Single threaded CSA decoding benchmark : %s\n", DLIB);
+	if (use_dvbcsa)
+		dvbcsa_benchmark();
+	if (use_ffdecsa)
+		ffdecsa_benchmark();
+}

csa.h

 static inline void				dvbcsa_bs_decrypt(const dvbcsa_bs_key_t *key, const struct dvbcsa_bs_batch_s *pcks, unsigned int maxlen) { (void)key; (void)pcks; (void)maxlen; }
 #endif
 
+#define ffdecsa_key_t void
+
+#if USE_FFDECSA
+#include "FFdecsa/FFdecsa.h"
+#define use_ffdecsa 1
+static inline int				ffdecsa_get_internal_parallelism(void) { return get_internal_parallelism(); }
+static inline int				ffdecsa_get_suggested_cluster_size(void) { return get_suggested_cluster_size(); }
+static inline ffdecsa_key_t *	ffdecsa_key_alloc(void) { return get_key_struct(); }
+static inline void				ffdecsa_key_free(ffdecsa_key_t *keys) { free_key_struct(keys); }
+static inline void				ffdecsa_set_cw(ffdecsa_key_t *keys, const uint8_t *even, const uint8_t *odd) { set_control_words(keys, even, odd); }
+static inline void				ffdecsa_set_even_cw(void *keys, const uint8_t *even) { set_even_control_word(keys, even); }
+static inline void				ffdecsa_set_odd_cw(ffdecsa_key_t *keys, const uint8_t *odd) { return set_odd_control_word(keys, odd); }
+static inline int				ffdecsa_decrypt_packets(ffdecsa_key_t *keys, uint8_t **cluster) { return decrypt_packets(keys, cluster); }
+#else
+#define use_ffdecsa 0
+static inline int				ffdecsa_get_internal_parallelism(void) { return 0; }
+static inline int				ffdecsa_get_suggested_cluster_size(void) { return 0; }
+static inline ffdecsa_key_t *	ffdecsa_key_alloc(void) { return NULL; }
+static inline void				ffdecsa_key_free(ffdecsa_key_t *keys) { (void)keys; }
+static inline void				ffdecsa_set_cw(ffdecsa_key_t *keys, const uint8_t *even, const uint8_t *odd) { (void)keys; (void)even; (void)odd; }
+static inline void				ffdecsa_set_even_cw(void *keys, const uint8_t *even) { (void)keys; (void)even; }
+static inline void				ffdecsa_set_odd_cw(ffdecsa_key_t *keys, const uint8_t *odd) { (void)keys; (void)odd; }
+static inline int				ffdecsa_decrypt_packets(ffdecsa_key_t *keys, uint8_t **cluster) { (void)keys; (void)cluster; return 0; }
+#endif
+
 #include "data.h"
 
 struct csakey {
 	dvbcsa_key_t		*s_csakey[2];
 	dvbcsa_bs_key_t		*bs_csakey[2];
+	ffdecsa_key_t		*ff_csakey;
 };
 
 csakey_t *		csa_key_alloc		(void);
 void			csa_decrypt_multiple_even	(csakey_t *csakey, struct csa_batch *batch);
 void			csa_decrypt_multiple_odd	(csakey_t *csakey, struct csa_batch *batch);
 
+void			csa_decrypt_multiple_ff		(csakey_t *csakey, uint8_t **cluster);
+
 void csa_benchmark(void);
 
 #endif

process.c

 
 static void decode_buffer(struct ts *ts, uint8_t *data, int data_len) {
 	int i;
-	int batch_sz = csa_get_batch_size(); // 32?
+	int batch_sz = csa_get_batch_size(); // Tested with 32 for libdvbcsa, 70 for FFdecsa (must be multiplied by 2)
 	int even_packets = 0;
 	int odd_packets  = 0;
 	struct csa_batch even_pcks[batch_sz + 1];
 	struct csa_batch odd_pcks [batch_sz + 1];
+	uint8_t *ff_even_pcks[batch_sz * 2 + 1];
+	uint8_t *ff_odd_pcks [batch_sz * 2 + 1];
 
 	int scramble_idx_old = 0;
 
 					}
 					ts_packet_set_not_scrambled(ts_packet);
 				}
+				if (use_ffdecsa) {
+					if (scramble_idx == 2) { // scramble_idx 2 == even key
+						ff_even_pcks[even_packets * 2    ] = ts_packet;
+						ff_even_pcks[even_packets * 2 + 1] = ts_packet + 188;
+						even_packets++;
+					}
+					if (scramble_idx == 3) { // scramble_idx 3 == odd key
+						ff_odd_pcks[odd_packets * 2    ] = ts_packet;
+						ff_odd_pcks[odd_packets * 2 + 1] = ts_packet + 188;
+						odd_packets++;
+					}
+				}
 				if (scramble_idx_old != scramble_idx && !ts->camd.constant_codeword) {
 					struct timeval tv;
 					gettimeofday(&tv, NULL);
 			even_pcks[even_packets].data = NULL; // Last one...
 			csa_decrypt_multiple_even(ts->key.csakey, even_pcks);
 		}
+		if (use_ffdecsa) {
+			ff_even_pcks[even_packets * 2] = NULL;
+			csa_decrypt_multiple_ff(ts->key.csakey, ff_even_pcks);
+		}
 	}
 	if (odd_packets) {
 		if (use_dvbcsa) {
 			odd_pcks[odd_packets].data = NULL; // Last one...
 			csa_decrypt_multiple_odd(ts->key.csakey, odd_pcks);
 		}
+		if (use_ffdecsa) {
+			ff_odd_pcks[odd_packets * 2] = NULL;
+			csa_decrypt_multiple_ff(ts->key.csakey, ff_odd_pcks);
+		}
 	}
 
 	// Fill write buffer

tsdecrypt.c

 #define FIRST_REPORT_SEC 3
 
 #define PROGRAM_NAME "tsdecrypt"
-static const char *program_id = PROGRAM_NAME " v" VERSION " (" GIT_VER ", build " BUILD_ID ")";
+static const char *program_id = PROGRAM_NAME " v" VERSION " (" GIT_VER ", build " BUILD_ID " " DLIB ")";
 
 static int keep_running = 1;
 static FILE *log_file = NULL;