Not enough input arguments.

I am trying to implement DCT compression and save the quantized coefficients into a file that will be read into another program. I am however getting this error of "not enough input arguments"on line 83... what could be wrong with my code? please help.

    function[]=dct11(filename,n,m)
    % "filename" is the string of characters including Image name and its
    % extension.
    % "n" denotes the number of bits per pixel.
    % "m" denotes the number of most significant bits (MSB) of DCT Coefficients. 

    % Matrix Intializations.
    N=8;                        % Block size for which DCT is Computed.
    M=8;
    I=imread('Lenna.bmp');         % Reading the input image file and storing intensity values in 2-D matrix I.
    I_dim=size(I);              % Finding the dimensions of the image file.
    I_Trsfrm.block=zeros(N,M);  % Initialising the DCT Coefficients Structure Matrix "I_Trsfrm" with the required dimensions.

    Norm_Mat=[16 11 10 16 24 40 51 61       % Normalization matrix (8 X 8) used to Normalize the DCT Matrix.
              12 12 14 19 26 58 60 55
              14 13 16 24 40 57 69 56
              14 17 22 29 51 87 80 62
              18 22 37 56 68 109 103 77
              24 35 55 64 81 104 113 92
              49 64 78 87 103 121 120 101
              72 92 95 98 112 100 103 99];

    save('LenaInitial.dat','I');

    %%PART-1: COMPRESSION TECHNIQUE.

    % Computing the Quantized & Normalized Discrete Cosine Transform.
    % Y(k,l)=(2/root(NM))*c(k)*c(l)*sigma(i=0:N-1)sigma(j=0:M-1)y(i,j)cos(pi(2i+1)k/(2N))cos(pi(2j+1)l/(2M))
    % where c(u)=1/root(2) if u=0
    %            = 1       if u>0

    for a=1:I_dim(1)/N
        for b=1:I_dim(2)/M
            for k=1:N
                for l=1:M
                    prod=0;
                    for i=1:N
                        for j=1:M
                            prod=prod+double(I(N*(a-1)+i,M*(b-1)+j))*cos(pi*(k-1)*(2*i-1)/(2*N))*cos(pi*(l-1)*(2*j-1)/(2*M));
                        end
                    end
                    if k==1
                        prod=prod*sqrt(1/N);
                    else
                        prod=prod*sqrt(2/N);
                    end
                    if l==1
                        prod=prod*sqrt(1/M);
                    else
                        prod=prod*sqrt(2/M);
                    end
                    I_Trsfrm(a,b).block(k,l)=prod;
                end
            end
            % Normalizing the DCT Matrix and Quantizing the resulting values.
            I_Trsfrm(a,b).block=round(I_Trsfrm(a,b).block./Norm_Mat);
    %         save ('LenaCompressed1.txt');
        end
    end
    %Andrew added this
    % save ('LenaCompressed.txt');

    % zig-zag coding of the each 8 X 8 Block.
    for a=1:I_dim(1)/N
        for b=1:I_dim(2)/M
            I_zigzag(a,b).block=zeros(1,0);
            freq_sum=2:(N+M);
            counter=1;
            for i=1:length(freq_sum)
                if i<=((length(freq_sum)+1)/2)
                    if rem(i,2)~=0
                        x_indices=counter:freq_sum(i)-counter;
                    else
                        x_indices=freq_sum(i)-counter:-1:counter;
                    end
                        index_len=length(x_indices);
                        y_indices=x_indices(index_len:-1:1); % Creating reverse of the array as "y_indices".
                        for p=1:index_len
                            if I_Trsfrm(a,b).block(x_indices(p),y_indices(p))<0
                                bin_eq=dec2bin(bitxor(2^n-1,abs(I_Trsfrm(a,b).block(x_indices(p),y_indices(p)))),n);
                            else
                                bin_eq=dec2bin(I_Trsfrm(a,b).block(x_indices(p),y_indices(p)),n);
                            end
                            I_zigzag(a,b).block=[I_zigzag(a,b).block,bin_eq(1:m)];
                        end
                else
                    counter=counter+1;
                    if rem(i,2)~=0
                        x_indices=counter:freq_sum(i)-counter;
                    else
                        x_indices=freq_sum(i)-counter:-1:counter;
                    end
                        index_len=length(x_indices);
                        y_indices=x_indices(index_len:-1:1); % Creating reverse of the array as "y_indices".
                        for p=1:index_len
                            if I_Trsfrm(a,b).block(x_indices(p),y_indices(p))<0
                                bin_eq=dec2bin(bitxor(2^n-1,abs(I_Trsfrm(a,b).block(x_indices(p),y_indices(p)))),n);
                            else
                                bin_eq=dec2bin(I_Trsfrm(a,b).block(x_indices(p),y_indices(p)),n);
                            end
                            I_zigzag(a,b).block=[I_zigzag(a,b).block,bin_eq(1:m)];
                        end
                end
            end
        end
    end

    % Clearing unused variables from Memory space
    clear I_Trsfrm prod; 
    clear x_indices y_indices counter;

    %Andrew added this
    save ('LenaCompressed.txt');

    % Run-Length Encoding the resulting code.
    for a=1:I_dim(1)/N
        for b=1:I_dim(2)/M

            % Computing the Count values for the corresponding symbols and
            % savin them in "I_run" structure.
            count=0;
            run=zeros(1,0);
            sym=I_zigzag(a,b).block(1);
            j=1;
            block_len=length(I_zigzag(a,b).block);
            for i=1:block_len
                if I_zigzag(a,b).block(i)==sym
                    count=count+1;
                else
                    run.count(j)=count;
                    run.sym(j)=sym;
                    j=j+1;
                    sym=I_zigzag(a,b).block(i);
                    count=1;
                end
                if i==block_len
                    run.count(j)=count;
                    run.sym(j)=sym;
                end
            end 

            % Computing the codelength needed for the count values.
            dim=length(run.count);  % calculates number of symbols being encoded.
            maxvalue=max(run.count);  % finds the maximum count value in the count array of run structure.
            codelength=log2(maxvalue)+1;
            codelength=floor(codelength);

            % Encoding the count values along with their symbols.
            I_runcode(a,b).code=zeros(1,0);
            for i=1:dim
                I_runcode(a,b).code=[I_runcode(a,b).code,dec2bin(run.count(i),codelength),run.sym(i)];
            end
        end
    end
    % Saving the Compressed Code to Disk.
    save ('LenaCompressed.txt','I_runcode');

    % Clearing unused variables from Memory Space.
    clear I_zigzag run;

[Matt J]

Show the complete error message (copy/pasted, not transcribed).

[Walter Roberson]

Which line is line 83?

[Andrew]

this is line 83. bin_eq=dec2bin(I_Trsfrm(a,b).block(x_indices(p),y_indices(p)),n);

and this is the error message

>> dct11 Error using dct11 (line 83) Not enough input arguments.

>>

[Daniel Shub]

Please simplify the problem into the minimum example providing complete details of the error message and input arguments (class and size).