Fixed-Point Version of TYPECAST?

I really like the MATLAB function typecast. It can easily convert between 32-bit integer and vector of bytes (and vice versa).

>> typecast(uint32(255), 'uint8')

ans =

    255    0    0    0

>> typecast(uint8([255 0 0 0]), 'uint32')

ans =

           255

However, typecast can only handle standard data types (i.e. uint8, int8, uint16, int16, uint32, int32, uint64, int64, single or double).

But in audio signal processing, audio samples are usually stored in 24 bits and I cannot use typecast anymore.

I have Fixed-Point Designer installed on my PC but I cannot find an equivalent fixed-point function that works like typecast. I have already looked into bitconcat and bitsliceget. But most likely I need to use a for-loop calling this functions multiple times to do the job.

Any suggestion? Or I am pretty much stuck ....

[James Tursa]

What conversion are you wanting to do? 24-bits to ...?

[Bruno Luong]

I even have a question move naive than James's: in which form you get the 24-bit data into MATLAB?

[Kevin]

Wow, I posted this almost 3 years ago and suddenly I got 3 answers. Something happened?

Let me try to answer to James and Bruno.

Imagine I (or someone) have done a memory dump from a processor memory into a text file. Imagine that each line in the text file contains one uint8 and so 3 lines would make up one 24-bit integer.

Or sometimes I need to deal with FPGA. It is even worst. In digital hardware, we can do literally arbitrary bit length (i.e. 19-bit, 25-bit integers. really odd). But that is life, something I need to deal with.

[James Tursa]

"... I posted this almost 3 years ago and suddenly I got 3 answers ..."

Someone picks up on an old thread and posts an answer or comment. Then the rest of us see it in the recent list and start replying as well ... often without even looking at the date of the original post.

Answer 1

[Hartmut Schorrig]

I think you should think about usage of Simulink S-functions and C-Programming for your interface to Matlab/Simulink. If you have 24 bit data they should be existing in a hardware layer or via hardware-oriented driver. You can input the data and convert it to 32 bit with ordinarry C-routines, it is simple. For all more sophisticated algorithm you should use Matlab and Simulink as well you think too. If you get input data in a file etc. to evaluate with Matlab, it may be numbers as text. Excel can be inputted by Matlab, it should not be a problem.

Answer 2

[Walter Roberson]

If you were to be using fixed-point objects with 24 bits, then you could directly assign into the bits property of the object.

[Kevin]

Hmm my fixed point MATLAB knowledge is getting a bit rusty. I have not followed the fixed point toolbox lately and so maybe I miss some new capabilities.

Let try this simple example.

>> x = fi([1 -2], 1, 4, 0)
x = 
   1    -2

          DataTypeMode: Fixed-point: binary point scaling
            Signedness: Signed
            WordLength: 4
        FractionLength: 0
>> x.bin
ans =
    '0001   1110'

Now how do I typecast these two 4-bit signed integers into one 8-bit signed integers. For now, let say I am ok with either big endian or little endian.

[Walter Roberson]

Ah, I should have said 'bin' instead of 'bits'

The question seems to originally have been about starting with uint8; say

t = randi([0 255], 1, 3, 'uint8');
y = fi([], 0, 24, 0);
y.bin = reshape(dec2bin(t, 8).',1,[]);

For your case

x = fi([1 -2], 1, 4, 0)

then

y = fi([], 1, 8, 0);
y.bin = regexprep(x.bin,' ','');

It is not immediately clear that it is wise to typecast multiple signed integer into a signed integer, as the effect is not the same as doing any kind of proper sign extension. It is not clear what the desired mathematical result should be. Should [-2 1] be treated like -2*16 + 1 ? Should it be treated like -2*16 + sign(-2)*1 ? Should it be treated like sign(-2)*sign(-1) * (abs(-2)*16 + abs(1)) ?

[Kevin]

Hi Walter,

Thanks for your code. It works well if t has 3 elements. But if t has 6 elements, then we need to tweak your code.

No worry. There are ways to get this to work. It usually requires around 10 lines of code (which is rather hard to read and I don't even remember what is going on after 6 months). I guess the toolbox simply does not support this.

Oh, I am sorry that probably I have confused you guys on why I want to do this. I am not trying to do any math in type-casting. Yes, you are correct that there is probably no meaning whether the 3 bytes are signed or unsigned. Sorry for the confusion.

Kevin

[Walter Roberson]

bits_per = 8;

x = fi(randi([-2^(bits_per-1) 2^(bits_per-1)-1], 1, randi(10)), 1, bits_per, 0);   some random signed values of random length, but do not assume 8 bits

y = fi([], 1, length(x)*bits_per, 0);
y.bin = regexprep(x.bin,' ','');

The operative logic is two lines; the random creation of variable-length x is more complicated than the conversion.

In the case where x might be a 2D array then

y = fi([], 1, numel(x)*bits_per, 0);
y.bin = strjoin(regexprep(cellstr(x.bin),' ',''),'');

[Kevin]

Hi Walter,

Thanks again. Really appreciate your efforts.

But I am very picky. I also care about speed and memory usage.

Also we can do all these codings that you are doing now. Then why do I want to buy Fixed Point Toolbox?

Kevin

[Walter Roberson]

You can speed up the operative line by assigning the results of the x.bin to a temporary variable t and using

   t(:, all(t==' ')) = '' ;
   y.bin = reshape(t.',1,[]);

Which can be simplified if x is know to have only one row.

The premise of the original question was that Fixed Point Designer was being used, and that has fixed point toolbox as a prerequisite. The entire question was about how do these operations in fixed point.

If HDL is being generated but fixed point toolbox is not being used, then you would be doing packing into basic integer data types and avoiding using any floating point. If the question has mutated into how to do efficient bit-level indexing the question has potentially important differences if the largest data type exceeds 64 bits, and even with 33 to 64 bits there might be a preference to avoid more than 32 bits at a time in order to reduce the effective ALU size.