Example #1
0
def setup(verbose=0):
	# Generic main setup function
	vprint("Initializing Setup Procedure...", verbose)
	status = OK
	
	# Call sub setup functions
	status = general_setup (verbose)
	generic.status_check ("general_setup", status)
	status = audio_setup (verbose)
	generic.status_check ("audio_setup", status)
	status = video_setup (verbose)
	generic.status_check ("video_setup", status)
	
	vprint ("Initial Setup Complete.", verbose)
	return status
    def set_constant(self, bit_depth):

        if bit_depth < 8:
            bit_depth = 8  # it is really stored as a byte in memory anyways, so assume it is 8bits in size.

        self.MU_LAW_BIT_DEPTH = bit_depth  # defines mu law bit depth
        self.MU_LAW_BIAS = 1 << (
            self.MU_LAW_BIT_DEPTH - 7
        )  # smallest bias to ensure a "1" in exponent region (LEFT 8 BITS OF SIGN)
        self.MU_LAW_MAX_VALUE = (
            1 << (self.MU_LAW_BIT_DEPTH - 1)
        ) - 1  # 2's compliment ranges from -2^(n-1) to (2^(n-1)-1) n = bitdepth
        self.MU_LAW_CLIP_LIMIT = (
            self.MU_LAW_MAX_VALUE - self.MU_LAW_BIAS
        )  # Want to remove bias from limit since bias will be added on later
        # Error Checking
        output_string = (
            "Mu Law Constants Setup\n - bit_depth: %d\n - bias: %d\n - Max_value: %d\n - Clip_limit: %d\n"
            % (self.MU_LAW_BIT_DEPTH, self.MU_LAW_BIAS, self.MU_LAW_MAX_VALUE, self.MU_LAW_CLIP_LIMIT)
        )
        generic.vprint(output_string, verbose)
        return
    def encode_value(self, original_value, bit_depth=16, signed=True, reference_value=0):
        return_value = 0

        # Set the parameters of mu_law encoding if it isn't already
        if not self.MU_LAW_Initialized:
            self.set_constant(bit_depth)
            self.MU_LAW_Initialized = True

            # If the value isn't signed, then convert it to a signed integer
        if (signed == False) and (original_value > 0):
            # Convert to signed using reference level
            # Check reference_value
            original_value = original_value - reference_value

            # mu_law Algorithm steps
            # Good Article on basis of mu_law http://www.cypress.com/?docID=38075
            # 1. Save Sign bit for a number of a certain BIT_DEPTH, default is 16.
            # 	Ex. 0010 1110 1001 1011 Sign Bit = 0
            # 2. Clip magnitude to maximum positive value subtract bias
            # 	Assuming 16 bit #, bias = 128, then clip value to 2^15-128 if greater
            # 3. Add a bias to ensures a 1 will always appear in the most significant 8 bits left of the sign bit
            # 	Ex. 0010 1110 1001 1011  + 1000 0100 = 0010 1111 0001 1111
            # 4. Determine Exponent and Mantissa Region
            # 	Exp region = 8bits to the right of the sign bit.
            # 	Most significant 1 in EXP region = P,next four bits to the right = Mantissa Region.
            # 	Ex. 0010 1111 0001 1111
            # 	    00PM MMM1 0001 1111
            # 5. Create 8bit encoding.
            # 	Sign Bit = most Significant bit
            # 	Mantissa Region = least significant 4 bits
            # 	Numerical Position of P in 3 bit Binary ecoding = the remaining bits
            # 	Ex. 0P000000 --> 6th position --> 110 in binary = PPP
            # 	    Final 8 bit encoding = SPPP MMMM = 01100111

        generic.vprint("Mu_Law Debugging Constants:", verbose)

        # Stage 1 - Save and remove sign from value
        sign = original_value & (1 << (self.MU_LAW_BIT_DEPTH - 1)) != 0
        return_value = abs(original_value) ^ (1 << (self.MU_LAW_BIT_DEPTH - 1))  # Erases sign bit

        # Debugging Statements
        output_string = (
            " - Original_Value(INT): %d\n - Originial_Value(Bin): %s\n - Sign(bit at bit_depth specified): %s\n - After_Sign_Stage_Value(Bin): %s"
            % (original_value, bin(original_value), sign, bin(return_value))
        )
        generic.vprint(output_string, verbose)

        # Stage 2 - Clip
        return_value = original_value ^ (1 << (self.MU_LAW_BIT_DEPTH - 1))
        if return_value >= self.MU_LAW_CLIP_LIMIT:
            return_value = self.MU_LAW_CLIP_LIMIT
            # Debugging Statements
        output_string = " - Clip Limit: %d\n - After_Clip_Stage_Value: %d" % (self.MU_LAW_CLIP_LIMIT, return_value)
        generic.vprint(output_string, verbose)

        # Stage 3 - Add Bias
        return_value = return_value + int(self.MU_LAW_BIAS)
        # Debugging Statements
        output_string = (
            " - Bias: %d\n - After_Biasing_Stage_Value(INT): %d\n - After_Biasing_Stage_Value (Binary): %s"
            % (self.MU_LAW_BIAS, return_value, bin(return_value))
        )
        generic.vprint(output_string, verbose)

        # Stage 4 - Saves EXP region and mantissa region
        exp_region = (return_value >> (self.MU_LAW_BIT_DEPTH - 9)) & 0xFF  # 1 for sign bit, 8 for exp region
        p_encoding = self.MU_LAW_P_ENCODING[exp_region - 1]
        man_region = (
            return_value >> (self.MU_LAW_BIT_DEPTH - (13 - p_encoding))
        ) & 0x0F  # Bit_Depth - sign bit - (relative position of p) - (4 bits for mantissa) = (bit_depth - 1 - (8-p) - 4) = bit depth - (13-p)
        # Debugging Statements
        output_string = " - Exp Region: %s\n - Mantissa Region: %s" % (bin(exp_region), bin(man_region))
        generic.vprint(output_string, verbose)

        # Stage 5
        return_value = (sign << 7) + (p_encoding << 4) + man_region
        # Debugging Statements
        output_string = " - Sign: %s\n - P_encoding: %s\n - Mantissa Region: %s\n - Encoded Value: %s\n" % (
            bin(sign),
            bin(p_encoding),
            bin(man_region),
            bin(return_value),
        )
        generic.vprint(output_string, verbose)

        return return_value